# HG changeset patch # User sam # Date 1714230270 -25200 # Node ID 967b8fa81b6b8d74af6ed2f3f2e3f48308791052 # Parent ac15ef062e294f92546645ff91406285462bab0f add: thirdparty libraries into repo diff -r ac15ef062e29 -r 967b8fa81b6b semicongine.nimble --- a/semicongine.nimble Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine.nimble Sat Apr 27 22:04:30 2024 +0700 @@ -8,15 +8,14 @@ backend = "c" if detectOS(Linux): + # required for packaging, on windows we use powershell foreignDep "zip" foreignDep "unzip" # required for builds using steam foreignDep "libstdc++6:i386" foreignDep "libc6:i386" + foreignDep "libx11-dev" requires "nim >= 2.0" -requires "winim" -requires "x11" # also requires libx11-dev e.g. on debian systems requires "zippy" -requires "db_connector" diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/platform/linux/symkey_map.nim --- a/semicongine/platform/linux/symkey_map.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/platform/linux/symkey_map.nim Sat Apr 27 22:04:30 2024 +0700 @@ -1,7 +1,7 @@ import std/tables export tables -import x11/x +import ../../thirdparty/x11/x import ../../events diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/platform/linux/window.nim --- a/semicongine/platform/linux/window.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/platform/linux/window.nim Sat Apr 27 22:04:30 2024 +0700 @@ -3,12 +3,11 @@ import std/strformat import std/logging -import - x11/xlib, - x11/xutil, - x11/keysym, - x11/x, - x11/xkblib +import ../../thirdparty/x11/xlib +import ../../thirdparty/x11/xutil +import ../../thirdparty/x11/keysym +import ../../thirdparty/x11/x +import ../../thirdparty/x11/xkblib import ../../core import ../../events diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/platform/windows/audio.nim --- a/semicongine/platform/windows/audio.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/platform/windows/audio.nim Sat Apr 27 22:04:30 2024 +0700 @@ -1,7 +1,7 @@ import std/os -import winim -import winim/extra +import ../../thirdparty/winim/winim +import ../../thirdparty/winim/winim/extra import ../../core/audiotypes @@ -14,7 +14,7 @@ NativeSoundDevice* = object handle: HWAVEOUT buffers: seq[WAVEHDR] - + proc openSoundDevice*(sampleRate: uint32, buffers: seq[ptr SoundData]): NativeSoundDevice = var format = WAVEFORMATEX( wFormatTag: WAVE_FORMAT_PCM, @@ -36,7 +36,7 @@ for i in 0 ..< result.buffers.len: checkWinMMResult waveOutPrepareHeader(result.handle, addr result.buffers[i], UINT(sizeof(WAVEHDR))) checkWinMMResult waveOutWrite(result.handle, addr result.buffers[i], UINT(sizeof(WAVEHDR))) - + proc writeSoundData*(soundDevice: var NativeSoundDevice, buffer: int) = while (soundDevice.buffers[buffer].dwFlags and WHDR_DONE) == 0: sleep(1) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/platform/windows/virtualkey_map.nim --- a/semicongine/platform/windows/virtualkey_map.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/platform/windows/virtualkey_map.nim Sat Apr 27 22:04:30 2024 +0700 @@ -1,7 +1,7 @@ import std/tables export tables -import winim/core +import ../../thirdparty/winim/winim/core import ../../events diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/platform/windows/window.nim --- a/semicongine/platform/windows/window.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/platform/windows/window.nim Sat Apr 27 22:04:30 2024 +0700 @@ -1,5 +1,6 @@ import std/options -import winim + +import ../../thirdparty/winim/winim import ../../core/vector import ../../core/buildconfig diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/resources.nim --- a/semicongine/resources.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/resources.nim Sat Apr 27 22:04:30 2024 +0700 @@ -72,7 +72,7 @@ elif thebundletype == Zip: - import zippy/ziparchives + import ./thirdparty/zippy/zippy/ziparchives proc resourceRoot(): string = absolutePath(getAppDir()).joinPath(RESOURCEROOT) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/storage.nim --- a/semicongine/storage.nim Sat Apr 27 17:21:47 2024 +0700 +++ b/semicongine/storage.nim Sat Apr 27 22:04:30 2024 +0700 @@ -4,7 +4,7 @@ import std/paths import std/os -import db_connector/db_sqlite +import ./thirdparty/db_connector/db_sqlite import ./core diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/db_connector/LICENSE --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/db_connector/LICENSE Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 The Nim programming language + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/db_connector/db_common.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/db_connector/db_common.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,102 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2015 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## .. note:: In order to use this module, run `nimble install db_connector`. +## +## Common datatypes and definitions for all `db_*.nim` ( +## `db_mysql `_, `db_postgres `_, +## and `db_sqlite `_) modules. + +type + DbError* = object of IOError ## exception that is raised if a database error occurs + + SqlQuery* = distinct string ## an SQL query string + + + DbEffect* = object of IOEffect ## effect that denotes a database operation + ReadDbEffect* = object of DbEffect ## effect that denotes a read operation + WriteDbEffect* = object of DbEffect ## effect that denotes a write operation + + DbTypeKind* = enum ## a superset of datatypes that might be supported. + dbUnknown, ## unknown datatype + dbSerial, ## datatype used for primary auto-increment keys + dbNull, ## datatype used for the NULL value + dbBit, ## bit datatype + dbBool, ## boolean datatype + dbBlob, ## blob datatype + dbFixedChar, ## string of fixed length + dbVarchar, ## string datatype + dbJson, ## JSON datatype + dbXml, ## XML datatype + dbInt, ## some integer type + dbUInt, ## some unsigned integer type + dbDecimal, ## decimal numbers (fixed-point number) + dbFloat, ## some floating point type + dbDate, ## a year-month-day description + dbTime, ## HH:MM:SS information + dbDatetime, ## year-month-day and HH:MM:SS information, + ## plus optional time or timezone information + dbTimestamp, ## Timestamp values are stored as the number of seconds + ## since the epoch ('1970-01-01 00:00:00' UTC). + dbTimeInterval, ## an interval [a,b] of times + dbEnum, ## some enum + dbSet, ## set of enum values + dbArray, ## an array of values + dbComposite, ## composite type (record, struct, etc) + dbUrl, ## a URL + dbUuid, ## a UUID + dbInet, ## an IP address + dbMacAddress, ## a MAC address + dbGeometry, ## some geometric type + dbPoint, ## Point on a plane (x,y) + dbLine, ## Infinite line ((x1,y1),(x2,y2)) + dbLseg, ## Finite line segment ((x1,y1),(x2,y2)) + dbBox, ## Rectangular box ((x1,y1),(x2,y2)) + dbPath, ## Closed or open path (similar to polygon) ((x1,y1),...) + dbPolygon, ## Polygon (similar to closed path) ((x1,y1),...) + dbCircle, ## Circle <(x,y),r> (center point and radius) + dbUser1, ## user definable datatype 1 (for unknown extensions) + dbUser2, ## user definable datatype 2 (for unknown extensions) + dbUser3, ## user definable datatype 3 (for unknown extensions) + dbUser4, ## user definable datatype 4 (for unknown extensions) + dbUser5 ## user definable datatype 5 (for unknown extensions) + + DbType* = object ## describes a database type + kind*: DbTypeKind ## the kind of the described type + notNull*: bool ## does the type contain NULL? + name*: string ## the name of the type + size*: Natural ## the size of the datatype; 0 if of variable size + maxReprLen*: Natural ## maximal length required for the representation + precision*, scale*: Natural ## precision and scale of the number + min*, max*: BiggestInt ## the minimum and maximum of allowed values + validValues*: seq[string] ## valid values of an enum or a set + + DbColumn* = object ## information about a database column + name*: string ## name of the column + tableName*: string ## name of the table the column belongs to (optional) + typ*: DbType ## type of the column + primaryKey*: bool ## is this a primary key? + foreignKey*: bool ## is this a foreign key? + DbColumns* = seq[DbColumn] + +template sql*(query: string): SqlQuery = + ## constructs a SqlQuery from the string `query`. This is supposed to be + ## used as a raw-string-literal modifier: + ## `sql"update user set counter = counter + 1"` + ## + ## If assertions are turned off, it does nothing. If assertions are turned + ## on, later versions will check the string for valid syntax. + SqlQuery(query) + +proc dbError*(msg: string) {.noreturn, noinline.} = + ## raises an DbError exception with message `msg`. + var e: ref DbError + new(e) + e.msg = msg + raise e diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/db_connector/db_sqlite.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/db_connector/db_sqlite.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,953 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2015 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## .. note:: In order to use this module, run `nimble install db_connector`. +## +## A higher level `SQLite`:idx: database wrapper. This interface +## is implemented for other databases too. +## +## Basic usage +## =========== +## +## The basic flow of using this module is: +## +## 1. Open database connection +## 2. Execute SQL query +## 3. Close database connection +## +## Parameter substitution +## ---------------------- +## +## All `db_*` modules support the same form of parameter substitution. +## That is, using the `?` (question mark) to signify the place where a +## value should be placed. For example: +## +## ```Nim +## sql"INSERT INTO my_table (colA, colB, colC) VALUES (?, ?, ?)" +## ``` +## +## Opening a connection to a database +## ---------------------------------- +## +## ```Nim +## import db_connector/db_sqlite +## +## # user, password, database name can be empty. +## # These params are not used on db_sqlite module. +## let db = open("mytest.db", "", "", "") +## db.close() +## ``` +## +## Creating a table +## ---------------- +## +## ```Nim +## db.exec(sql"DROP TABLE IF EXISTS my_table") +## db.exec(sql"""CREATE TABLE my_table ( +## id INTEGER, +## name VARCHAR(50) NOT NULL +## )""") +## ``` +## +## Inserting data +## -------------- +## +## ```Nim +## db.exec(sql"INSERT INTO my_table (id, name) VALUES (0, ?)", +## "Jack") +## ``` +## +## Larger example +## -------------- +## +## ```Nim +## import db_connector/db_sqlite +## import std/math +## +## let db = open("mytest.db", "", "", "") +## +## db.exec(sql"DROP TABLE IF EXISTS my_table") +## db.exec(sql"""CREATE TABLE my_table ( +## id INTEGER PRIMARY KEY, +## name VARCHAR(50) NOT NULL, +## i INT(11), +## f DECIMAL(18, 10) +## )""") +## +## db.exec(sql"BEGIN") +## for i in 1..1000: +## db.exec(sql"INSERT INTO my_table (name, i, f) VALUES (?, ?, ?)", +## "Item#" & $i, i, sqrt(i.float)) +## db.exec(sql"COMMIT") +## +## for x in db.fastRows(sql"SELECT * FROM my_table"): +## echo x +## +## let id = db.tryInsertId(sql"""INSERT INTO my_table (name, i, f) +## VALUES (?, ?, ?)""", +## "Item#1001", 1001, sqrt(1001.0)) +## echo "Inserted item: ", db.getValue(sql"SELECT name FROM my_table WHERE id=?", id) +## +## db.close() +## ``` +## +## Storing binary data example +##---------------------------- +## +## ```nim +## import std/random +## +## ## Generate random float datas +## var orig = newSeq[float64](150) +## randomize() +## for x in orig.mitems: +## x = rand(1.0)/10.0 +## +## let db = open("mysqlite.db", "", "", "") +## block: ## Create database +## ## Binary datas needs to be of type BLOB in SQLite +## let createTableStr = sql"""CREATE TABLE test( +## id INTEGER NOT NULL PRIMARY KEY, +## data BLOB +## ) +## """ +## db.exec(createTableStr) +## +## block: ## Insert data +## var id = 1 +## ## Data needs to be converted to seq[byte] to be interpreted as binary by bindParams +## var dbuf = newSeq[byte](orig.len*sizeof(float64)) +## copyMem(unsafeAddr(dbuf[0]), unsafeAddr(orig[0]), dbuf.len) +## +## ## Use prepared statement to insert binary data into database +## var insertStmt = db.prepare("INSERT INTO test (id, data) VALUES (?, ?)") +## insertStmt.bindParams(id, dbuf) +## let bres = db.tryExec(insertStmt) +## ## Check insert +## doAssert(bres) +## # Destroy statement +## finalize(insertStmt) +## +## block: ## Use getValue to select data +## var dataTest = db.getValue(sql"SELECT data FROM test WHERE id = ?", 1) +## ## Calculate sequence size from buffer size +## let seqSize = int(dataTest.len*sizeof(byte)/sizeof(float64)) +## ## Copy binary string data in dataTest into a seq +## var res: seq[float64] = newSeq[float64](seqSize) +## copyMem(unsafeAddr(res[0]), addr(dataTest[0]), dataTest.len) +## +## ## Check datas obtained is identical +## doAssert res == orig +## +## db.close() +## ``` +## +## +## Note +## ==== +## This module does not implement any ORM features such as mapping the types from the schema. +## Instead, a `seq[string]` is returned for each row. +## +## The reasoning is as follows: +## 1. it's close to what many DBs offer natively (`char**`:c:) +## 2. it hides the number of types that the DB supports +## (int? int64? decimal up to 10 places? geo coords?) +## 3. it's convenient when all you do is to forward the data to somewhere else (echo, log, put the data into a new query) +## +## See also +## ======== +## +## * `db_odbc module `_ for ODBC database wrapper +## * `db_mysql module `_ for MySQL database wrapper +## * `db_postgres module `_ for PostgreSQL database wrapper + + +import ./sqlite3, macros + +import ./db_common +export db_common + +import private/dbutils + +import std/private/[since] +when defined(nimPreviewSlimSystem): + import std/assertions + +type + DbConn* = PSqlite3 ## Encapsulates a database connection. + Row* = seq[string] ## A row of a dataset. `NULL` database values will be + ## converted to an empty string. + InstantRow* = PStmt ## A handle that can be used to get a row's column + ## text on demand. + SqlPrepared* = distinct PStmt ## a identifier for the prepared queries + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int32) {.since: (1, 3).} +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int64) {.since: (1, 3).} +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int) {.since: (1, 3).} +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: float64) {.since: (1, 3).} +proc bindNull*(ps: SqlPrepared, paramIdx: int) {.since: (1, 3).} +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: string, copy = true) {.since: (1, 3).} +proc bindParam*(ps: SqlPrepared, paramIdx: int,val: openArray[byte], copy = true) {.since: (1, 3).} + +proc dbError*(db: DbConn) {.noreturn.} = + ## Raises a `DbError` exception. + ## + ## **Examples:** + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## if not db.tryExec(sql"SELECT * FROM not_exist_table"): + ## dbError(db) + ## db.close() + ## ``` + var e: ref DbError + new(e) + e.msg = $sqlite3.errmsg(db) + raise e + +proc dbQuote*(s: string): string = + ## Escapes the `'` (single quote) char to `''`. + ## Because single quote is used for defining `VARCHAR` in SQL. + runnableExamples: + doAssert dbQuote("'") == "''''" + doAssert dbQuote("A Foobar's pen.") == "'A Foobar''s pen.'" + + result = "'" + for c in items(s): + if c == '\'': add(result, "''") + else: add(result, c) + add(result, '\'') + +proc dbFormat(formatstr: SqlQuery, args: varargs[string]): string = + dbFormatImpl(formatstr, dbQuote, args) + +proc prepare*(db: DbConn; q: string): SqlPrepared {.since: (1, 3).} = + ## Creates a new `SqlPrepared` statement. + if prepare_v2(db, q, q.len.cint,result.PStmt, nil) != SQLITE_OK: + discard finalize(result.PStmt) + dbError(db) + +proc tryExec*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): bool {. + tags: [ReadDbEffect, WriteDbEffect].} = + ## Tries to execute the query and returns `true` if successful, `false` otherwise. + ## + ## **Examples:** + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## if not db.tryExec(sql"SELECT * FROM my_table"): + ## dbError(db) + ## db.close() + ## ``` + assert(not db.isNil, "Database not connected.") + var q = dbFormat(query, args) + var stmt: sqlite3.PStmt + if prepare_v2(db, q.cstring, q.len.cint, stmt, nil) == SQLITE_OK: + let x = step(stmt) + if x in [SQLITE_DONE, SQLITE_ROW]: + result = finalize(stmt) == SQLITE_OK + else: + discard finalize(stmt) + result = false + +proc tryExec*(db: DbConn, stmtName: SqlPrepared): bool {. + tags: [ReadDbEffect, WriteDbEffect].} = + let x = step(stmtName.PStmt) + if x in [SQLITE_DONE, SQLITE_ROW]: + result = true + else: + discard finalize(stmtName.PStmt) + result = false + +proc exec*(db: DbConn, query: SqlQuery, args: varargs[string, `$`]) {. + tags: [ReadDbEffect, WriteDbEffect].} = + ## Executes the query and raises a `DbError` exception if not successful. + ## + ## **Examples:** + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## try: + ## db.exec(sql"INSERT INTO my_table (id, name) VALUES (?, ?)", + ## 1, "item#1") + ## except: + ## stderr.writeLine(getCurrentExceptionMsg()) + ## finally: + ## db.close() + ## ``` + if not tryExec(db, query, args): dbError(db) + +macro untypedLen(args: varargs[untyped]): int = + newLit(args.len) + +macro bindParams*(ps: SqlPrepared, params: varargs[untyped]): untyped {.since: (1, 3).} = + let bindParam = bindSym("bindParam", brOpen) + let bindNull = bindSym("bindNull") + let preparedStatement = genSym() + result = newStmtList() + # Store `ps` in a temporary variable. This prevents `ps` from being evaluated every call. + result.add newNimNode(nnkLetSection).add(newIdentDefs(preparedStatement, newEmptyNode(), ps)) + for idx, param in params: + if param.kind != nnkNilLit: + result.add newCall(bindParam, preparedStatement, newIntLitNode idx + 1, param) + else: + result.add newCall(bindNull, preparedStatement, newIntLitNode idx + 1) + + +template exec*(db: DbConn, stmtName: SqlPrepared, + args: varargs[typed]): untyped = + when untypedLen(args) > 0: + if reset(stmtName.PStmt) != SQLITE_OK: + dbError(db) + if clear_bindings(stmtName.PStmt) != SQLITE_OK: + dbError(db) + stmtName.bindParams(args) + if not tryExec(db, stmtName): dbError(db) + +proc newRow(L: int): Row = + newSeq(result, L) + for i in 0..L-1: result[i] = "" + +proc setupQuery(db: DbConn, query: SqlQuery, + args: varargs[string]): PStmt = + assert(not db.isNil, "Database not connected.") + var q = dbFormat(query, args) + if prepare_v2(db, q.cstring, q.len.cint, result, nil) != SQLITE_OK: dbError(db) + +proc setupQuery(db: DbConn, stmtName: SqlPrepared): SqlPrepared {.since: (1, 3).} = + assert(not db.isNil, "Database not connected.") + result = stmtName + +proc setRow(stmt: PStmt, r: var Row, cols: cint) = + for col in 0'i32..cols-1: + let cb = column_bytes(stmt, col) + setLen(r[col], cb) # set capacity + if column_type(stmt, col) == SQLITE_BLOB: + copyMem(addr(r[col][0]), column_blob(stmt, col), cb) + else: + setLen(r[col], 0) + let x = column_text(stmt, col) + if not isNil(x): add(r[col], x) + +iterator fastRows*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): Row {.tags: [ReadDbEffect].} = + ## Executes the query and iterates over the result dataset. + ## + ## This is very fast, but potentially dangerous. Use this iterator only + ## if you require **ALL** the rows. + ## + ## **Note:** Breaking the `fastRows()` iterator during a loop will cause the + ## next database query to raise a `DbError` exception `unable to close due + ## to ...`. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## for row in db.fastRows(sql"SELECT id, name FROM my_table"): + ## echo row + ## + ## # Output: + ## # @["1", "item#1"] + ## # @["2", "item#2"] + ## + ## db.close() + ## ``` + var stmt = setupQuery(db, query, args) + var L = (column_count(stmt)) + var result = newRow(L) + try: + while step(stmt) == SQLITE_ROW: + setRow(stmt, result, L) + yield result + finally: + if finalize(stmt) != SQLITE_OK: dbError(db) + +iterator fastRows*(db: DbConn, stmtName: SqlPrepared): Row + {.tags: [ReadDbEffect,WriteDbEffect], since: (1, 3).} = + discard setupQuery(db, stmtName) + var L = (column_count(stmtName.PStmt)) + var result = newRow(L) + try: + while step(stmtName.PStmt) == SQLITE_ROW: + setRow(stmtName.PStmt, result, L) + yield result + except: + dbError(db) + +iterator instantRows*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): InstantRow + {.tags: [ReadDbEffect].} = + ## Similar to `fastRows iterator <#fastRows.i,DbConn,SqlQuery,varargs[string,]>`_ + ## but returns a handle that can be used to get column text + ## on demand using `[]`. Returned handle is valid only within the iterator body. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## for row in db.instantRows(sql"SELECT * FROM my_table"): + ## echo "id:" & row[0] + ## echo "name:" & row[1] + ## echo "length:" & $len(row) + ## + ## # Output: + ## # id:1 + ## # name:item#1 + ## # length:2 + ## # id:2 + ## # name:item#2 + ## # length:2 + ## + ## db.close() + ## ``` + var stmt = setupQuery(db, query, args) + try: + while step(stmt) == SQLITE_ROW: + yield stmt + finally: + if finalize(stmt) != SQLITE_OK: dbError(db) + +iterator instantRows*(db: DbConn, stmtName: SqlPrepared): InstantRow + {.tags: [ReadDbEffect,WriteDbEffect], since: (1, 3).} = + var stmt = setupQuery(db, stmtName).PStmt + try: + while step(stmt) == SQLITE_ROW: + yield stmt + except: + dbError(db) + +proc toTypeKind(t: var DbType; x: int32) = + case x + of SQLITE_INTEGER: + t.kind = dbInt + t.size = 8 + of SQLITE_FLOAT: + t.kind = dbFloat + t.size = 8 + of SQLITE_BLOB: t.kind = dbBlob + of SQLITE_NULL: t.kind = dbNull + of SQLITE_TEXT: t.kind = dbVarchar + else: t.kind = dbUnknown + +proc setColumns(columns: var DbColumns; x: PStmt) = + let L = column_count(x) + setLen(columns, L) + for i in 0'i32 ..< L: + columns[i].name = $column_name(x, i) + columns[i].typ.name = $column_decltype(x, i) + toTypeKind(columns[i].typ, column_type(x, i)) + columns[i].tableName = $column_table_name(x, i) + +iterator instantRows*(db: DbConn; columns: var DbColumns; query: SqlQuery, + args: varargs[string, `$`]): InstantRow + {.tags: [ReadDbEffect].} = + ## Similar to `instantRows iterator <#instantRows.i,DbConn,SqlQuery,varargs[string,]>`_, + ## but sets information about columns to `columns`. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## var columns: DbColumns + ## for row in db.instantRows(columns, sql"SELECT * FROM my_table"): + ## discard + ## echo columns[0] + ## + ## # Output: + ## # (name: "id", tableName: "my_table", typ: (kind: dbNull, + ## # notNull: false, name: "INTEGER", size: 0, maxReprLen: 0, precision: 0, + ## # scale: 0, min: 0, max: 0, validValues: @[]), primaryKey: false, + ## # foreignKey: false) + ## + ## db.close() + ## ``` + var stmt = setupQuery(db, query, args) + setColumns(columns, stmt) + try: + while step(stmt) == SQLITE_ROW: + yield stmt + finally: + if finalize(stmt) != SQLITE_OK: dbError(db) + +proc `[]`*(row: InstantRow, col: int32): string {.inline.} = + ## Returns text for given column of the row. + ## + ## See also: + ## * `instantRows iterator <#instantRows.i,DbConn,SqlQuery,varargs[string,]>`_ + ## example code + $column_text(row, col) + +proc unsafeColumnAt*(row: InstantRow, index: int32): cstring {.inline.} = + ## Returns cstring for given column of the row. + ## + ## See also: + ## * `instantRows iterator <#instantRows.i,DbConn,SqlQuery,varargs[string,]>`_ + ## example code + column_text(row, index) + +proc len*(row: InstantRow): int32 {.inline.} = + ## Returns number of columns in a row. + ## + ## See also: + ## * `instantRows iterator <#instantRows.i,DbConn,SqlQuery,varargs[string,]>`_ + ## example code + column_count(row) + +proc getRow*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): Row {.tags: [ReadDbEffect].} = + ## Retrieves a single row. If the query doesn't return any rows, this proc + ## will return a `Row` with empty strings for each column. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## doAssert db.getRow(sql"SELECT id, name FROM my_table" + ## ) == Row(@["1", "item#1"]) + ## doAssert db.getRow(sql"SELECT id, name FROM my_table WHERE id = ?", + ## 2) == Row(@["2", "item#2"]) + ## + ## # Returns empty. + ## doAssert db.getRow(sql"INSERT INTO my_table (id, name) VALUES (?, ?)", + ## 3, "item#3") == @[] + ## doAssert db.getRow(sql"DELETE FROM my_table WHERE id = ?", 3) == @[] + ## doAssert db.getRow(sql"UPDATE my_table SET name = 'ITEM#1' WHERE id = ?", + ## 1) == @[] + ## db.close() + ## ``` + var stmt = setupQuery(db, query, args) + var L = (column_count(stmt)) + result = newRow(L) + if step(stmt) == SQLITE_ROW: + setRow(stmt, result, L) + if finalize(stmt) != SQLITE_OK: dbError(db) + +proc getAllRows*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): seq[Row] {.tags: [ReadDbEffect].} = + ## Executes the query and returns the whole result dataset. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## doAssert db.getAllRows(sql"SELECT id, name FROM my_table") == @[Row(@["1", "item#1"]), Row(@["2", "item#2"])] + ## db.close() + ## ``` + result = @[] + for r in fastRows(db, query, args): + result.add(r) + +proc getAllRows*(db: DbConn, stmtName: SqlPrepared): seq[Row] + {.tags: [ReadDbEffect,WriteDbEffect], since: (1, 3).} = + result = @[] + for r in fastRows(db, stmtName): + result.add(r) + +iterator rows*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): Row {.tags: [ReadDbEffect].} = + ## Similar to `fastRows iterator <#fastRows.i,DbConn,SqlQuery,varargs[string,]>`_, + ## but slower and safe. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## for row in db.rows(sql"SELECT id, name FROM my_table"): + ## echo row + ## + ## ## Output: + ## ## @["1", "item#1"] + ## ## @["2", "item#2"] + ## + ## db.close() + ## ``` + for r in fastRows(db, query, args): yield r + +iterator rows*(db: DbConn, stmtName: SqlPrepared): Row + {.tags: [ReadDbEffect,WriteDbEffect], since: (1, 3).} = + for r in fastRows(db, stmtName): yield r + +proc getValue*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): string {.tags: [ReadDbEffect].} = + ## Executes the query and returns the first column of the first row of the + ## result dataset. Returns `""` if the dataset contains no rows or the database + ## value is `NULL`. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## doAssert db.getValue(sql"SELECT name FROM my_table WHERE id = ?", + ## 2) == "item#2" + ## doAssert db.getValue(sql"SELECT id, name FROM my_table") == "1" + ## doAssert db.getValue(sql"SELECT name, id FROM my_table") == "item#1" + ## + ## db.close() + ## ``` + var stmt = setupQuery(db, query, args) + if step(stmt) == SQLITE_ROW: + let cb = column_bytes(stmt, 0) + if cb == 0: + result = "" + else: + if column_type(stmt, 0) == SQLITE_BLOB: + result.setLen(cb) + copyMem(addr(result[0]), column_blob(stmt, 0), cb) + else: + result = newStringOfCap(cb) + add(result, column_text(stmt, 0)) + else: + result = "" + if finalize(stmt) != SQLITE_OK: dbError(db) + +proc getValue*(db: DbConn, stmtName: SqlPrepared): string + {.tags: [ReadDbEffect,WriteDbEffect], since: (1, 3).} = + var stmt = setupQuery(db, stmtName).PStmt + if step(stmt) == SQLITE_ROW: + let cb = column_bytes(stmt, 0) + if cb == 0: + result = "" + else: + if column_type(stmt, 0) == SQLITE_BLOB: + result.setLen(cb) + copyMem(addr(result[0]), column_blob(stmt, 0), cb) + else: + result = newStringOfCap(cb) + add(result, column_text(stmt, 0)) + else: + result = "" + +proc tryInsertID*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): int64 + {.tags: [WriteDbEffect], raises: [DbError].} = + ## Executes the query (typically "INSERT") and returns the + ## generated ID for the row or -1 in case of an error. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## db.exec(sql"CREATE TABLE my_table (id INTEGER, name VARCHAR(50) NOT NULL)") + ## + ## doAssert db.tryInsertID(sql"INSERT INTO not_exist_table (id, name) VALUES (?, ?)", + ## 1, "item#1") == -1 + ## db.close() + ## ``` + assert(not db.isNil, "Database not connected.") + var q = dbFormat(query, args) + var stmt: sqlite3.PStmt + result = -1 + if prepare_v2(db, q.cstring, q.len.cint, stmt, nil) == SQLITE_OK: + if step(stmt) == SQLITE_DONE: + result = last_insert_rowid(db) + if finalize(stmt) != SQLITE_OK: + result = -1 + else: + discard finalize(stmt) + +proc insertID*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): int64 {.tags: [WriteDbEffect].} = + ## Executes the query (typically "INSERT") and returns the + ## generated ID for the row. + ## + ## Raises a `DbError` exception when failed to insert row. + ## For Postgre this adds `RETURNING id` to the query, so it only works + ## if your primary key is named `id`. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## db.exec(sql"CREATE TABLE my_table (id INTEGER, name VARCHAR(50) NOT NULL)") + ## + ## for i in 0..2: + ## let id = db.insertID(sql"INSERT INTO my_table (id, name) VALUES (?, ?)", i, "item#" & $i) + ## echo "LoopIndex = ", i, ", InsertID = ", id + ## + ## # Output: + ## # LoopIndex = 0, InsertID = 1 + ## # LoopIndex = 1, InsertID = 2 + ## # LoopIndex = 2, InsertID = 3 + ## + ## db.close() + ## ``` + result = tryInsertID(db, query, args) + if result < 0: dbError(db) + +proc tryInsert*(db: DbConn, query: SqlQuery, pkName: string, + args: varargs[string, `$`]): int64 + {.tags: [WriteDbEffect], raises: [DbError], since: (1, 3).} = + ## same as tryInsertID + tryInsertID(db, query, args) + +proc insert*(db: DbConn, query: SqlQuery, pkName: string, + args: varargs[string, `$`]): int64 + {.tags: [WriteDbEffect], since: (1, 3).} = + ## same as insertId + result = tryInsert(db, query, pkName, args) + if result < 0: dbError(db) + +proc execAffectedRows*(db: DbConn, query: SqlQuery, + args: varargs[string, `$`]): int64 {. + tags: [ReadDbEffect, WriteDbEffect].} = + ## Executes the query (typically "UPDATE") and returns the + ## number of affected rows. + ## + ## **Examples:** + ## + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## + ## # Records of my_table: + ## # | id | name | + ## # |----|----------| + ## # | 1 | item#1 | + ## # | 2 | item#2 | + ## + ## doAssert db.execAffectedRows(sql"UPDATE my_table SET name = 'TEST'") == 2 + ## + ## db.close() + ## ``` + exec(db, query, args) + result = changes(db) + +proc execAffectedRows*(db: DbConn, stmtName: SqlPrepared): int64 + {.tags: [ReadDbEffect, WriteDbEffect],since: (1, 3).} = + exec(db, stmtName) + result = changes(db) + +proc close*(db: DbConn) {.tags: [DbEffect].} = + ## Closes the database connection. + ## + ## **Examples:** + ## ```Nim + ## let db = open("mytest.db", "", "", "") + ## db.close() + ## ``` + if sqlite3.close(db) != SQLITE_OK: dbError(db) + +proc open*(connection, user, password, database: string): DbConn {. + tags: [DbEffect].} = + ## Opens a database connection. Raises a `DbError` exception if the connection + ## could not be established. + ## + ## **Note:** Only the `connection` parameter is used for `sqlite`. + ## + ## **Examples:** + ## ```Nim + ## try: + ## let db = open("mytest.db", "", "", "") + ## ## do something... + ## ## db.getAllRows(sql"SELECT * FROM my_table") + ## db.close() + ## except: + ## stderr.writeLine(getCurrentExceptionMsg()) + ## ``` + var db: DbConn + if sqlite3.open(connection, db) == SQLITE_OK: + result = db + else: + dbError(db) + +proc setEncoding*(connection: DbConn, encoding: string): bool {. + tags: [DbEffect].} = + ## Sets the encoding of a database connection, returns `true` for + ## success, `false` for failure. + ## + ## **Note:** The encoding cannot be changed once it's been set. + ## According to SQLite3 documentation, any attempt to change + ## the encoding after the database is created will be silently + ## ignored. + exec(connection, sql"PRAGMA encoding = ?", [encoding]) + result = connection.getValue(sql"PRAGMA encoding") == encoding + +proc finalize*(sqlPrepared:SqlPrepared) {.discardable, since: (1, 3).} = + discard finalize(sqlPrepared.PStmt) + +template dbBindParamError*(paramIdx: int, val: varargs[untyped]) = + ## Raises a `DbError` exception. + var e: ref DbError + new(e) + e.msg = "error binding param in position " & $paramIdx + raise e + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int32) {.since: (1, 3).} = + ## Binds a int32 to the specified paramIndex. + if bind_int(ps.PStmt, paramIdx.int32, val) != SQLITE_OK: + dbBindParamError(paramIdx, val) + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int64) {.since: (1, 3).} = + ## Binds a int64 to the specified paramIndex. + if bind_int64(ps.PStmt, paramIdx.int32, val) != SQLITE_OK: + dbBindParamError(paramIdx, val) + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: int) {.since: (1, 3).} = + ## Binds a int to the specified paramIndex. + when sizeof(int) == 8: + bindParam(ps, paramIdx, val.int64) + else: + bindParam(ps, paramIdx, val.int32) + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: float64) {.since: (1, 3).} = + ## Binds a 64bit float to the specified paramIndex. + if bind_double(ps.PStmt, paramIdx.int32, val) != SQLITE_OK: + dbBindParamError(paramIdx, val) + +proc bindNull*(ps: SqlPrepared, paramIdx: int) {.since: (1, 3).} = + ## Sets the bindparam at the specified paramIndex to null + ## (default behaviour by sqlite). + if bind_null(ps.PStmt, paramIdx.int32) != SQLITE_OK: + dbBindParamError(paramIdx) + +proc bindParam*(ps: SqlPrepared, paramIdx: int, val: string, copy = true) {.since: (1, 3).} = + ## Binds a string to the specified paramIndex. + ## if copy is true then SQLite makes its own private copy of the data immediately + if bind_text(ps.PStmt, paramIdx.int32, val.cstring, val.len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK: + dbBindParamError(paramIdx, val) + +proc bindParam*(ps: SqlPrepared, paramIdx: int,val: openArray[byte], copy = true) {.since: (1, 3).} = + ## binds a blob to the specified paramIndex. + ## if copy is true then SQLite makes its own private copy of the data immediately + let len = val.len + if bind_blob(ps.PStmt, paramIdx.int32, val[0].unsafeAddr, len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK: + dbBindParamError(paramIdx, val) + +when not defined(testing) and isMainModule: + var db = open(":memory:", "", "", "") + exec(db, sql"create table tbl1(one varchar(10), two smallint)", []) + exec(db, sql"insert into tbl1 values('hello!',10)", []) + exec(db, sql"insert into tbl1 values('goodbye', 20)", []) + var p1 = db.prepare "create table tbl2(one varchar(10), two smallint)" + exec(db, p1) + finalize(p1) + var p2 = db.prepare "insert into tbl2 values('hello!',10)" + exec(db, p2) + finalize(p2) + var p3 = db.prepare "insert into tbl2 values('goodbye', 20)" + exec(db, p3) + finalize(p3) + #db.query("create table tbl1(one varchar(10), two smallint)") + #db.query("insert into tbl1 values('hello!',10)") + #db.query("insert into tbl1 values('goodbye', 20)") + for r in db.rows(sql"select * from tbl1", []): + echo(r[0], r[1]) + for r in db.instantRows(sql"select * from tbl1", []): + echo(r[0], r[1]) + var p4 = db.prepare "select * from tbl2" + for r in db.rows(p4): + echo(r[0], r[1]) + finalize(p4) + var i5 = 0 + var p5 = db.prepare "select * from tbl2" + for r in db.instantRows(p5): + inc i5 + echo(r[0], r[1]) + assert i5 == 2 + finalize(p5) + + for r in db.rows(sql"select * from tbl2", []): + echo(r[0], r[1]) + for r in db.instantRows(sql"select * from tbl2", []): + echo(r[0], r[1]) + var p6 = db.prepare "select * from tbl2 where one = ? " + p6.bindParams("goodbye") + var rowsP3 = 0 + for r in db.rows(p6): + rowsP3 = 1 + echo(r[0], r[1]) + assert rowsP3 == 1 + finalize(p6) + + var p7 = db.prepare "select * from tbl2 where two=?" + p7.bindParams(20'i32) + when sizeof(int) == 4: + p7.bindParams(20) + var rowsP = 0 + for r in db.rows(p7): + rowsP = 1 + echo(r[0], r[1]) + assert rowsP == 1 + finalize(p7) + + exec(db, sql"CREATE TABLE photos(ID INTEGER PRIMARY KEY AUTOINCREMENT, photo BLOB)") + var p8 = db.prepare "INSERT INTO photos (ID,PHOTO) VALUES (?,?)" + var d = "abcdefghijklmnopqrstuvwxyz" + p8.bindParams(1'i32, "abcdefghijklmnopqrstuvwxyz") + exec(db, p8) + finalize(p8) + var p10 = db.prepare "INSERT INTO photos (ID,PHOTO) VALUES (?,?)" + p10.bindParams(2'i32,nil) + exec(db, p10) + exec( db, p10, 3, nil) + finalize(p10) + for r in db.rows(sql"select * from photos where ID = 1", []): + assert r[1].len == d.len + assert r[1] == d + var i6 = 0 + for r in db.rows(sql"select * from photos where ID = 3", []): + i6 = 1 + assert i6 == 1 + var p9 = db.prepare("select * from photos where PHOTO is ?") + p9.bindParams(nil) + var rowsP2 = 0 + for r in db.rows(p9): + rowsP2 = 1 + echo(r[0], repr r[1]) + assert rowsP2 == 1 + finalize(p9) + + db_sqlite.close(db) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/db_connector/private/dbutils.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/db_connector/private/dbutils.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,15 @@ +import ../db_common + + +template dbFormatImpl*(formatstr: SqlQuery, dbQuote: proc (s: string): string {.nimcall.}, args: varargs[string]): string = + var res = "" + var a = 0 + for c in items(string(formatstr)): + if c == '?': + if a == args.len: + dbError("""The number of "?" given exceeds the number of parameters present in the query.""") + add(res, dbQuote(args[a])) + inc(a) + else: + add(res, c) + res diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/db_connector/sqlite3.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/db_connector/sqlite3.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,392 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2012 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +when defined(nimHasStyleChecks): + {.push styleChecks: off.} + +when defined(windows): + when defined(nimOldDlls): + const Lib = "sqlite3.dll" + elif defined(cpu64): + const Lib = "sqlite3_64.dll" + else: + const Lib = "sqlite3_32.dll" +elif defined(macosx): + const + Lib = "libsqlite3(|.0).dylib" +else: + const + Lib = "libsqlite3.so(|.0)" + +when defined(staticSqlite): + {.pragma: mylib.} + {.compile("sqlite3.c", "-O3").} +else: + {.pragma: mylib, dynlib: Lib.} + +const + SQLITE_INTEGER* = 1 + SQLITE_FLOAT* = 2 + SQLITE_BLOB* = 4 + SQLITE_NULL* = 5 + SQLITE_TEXT* = 3 + SQLITE_UTF8* = 1 + SQLITE_UTF16LE* = 2 + SQLITE_UTF16BE* = 3 # Use native byte order + SQLITE_UTF16* = 4 # sqlite3_create_function only + SQLITE_ANY* = 5 #sqlite_exec return values + SQLITE_OK* = 0 + SQLITE_ERROR* = 1 # SQL error or missing database + SQLITE_INTERNAL* = 2 # An internal logic error in SQLite + SQLITE_PERM* = 3 # Access permission denied + SQLITE_ABORT* = 4 # Callback routine requested an abort + SQLITE_BUSY* = 5 # The database file is locked + SQLITE_LOCKED* = 6 # A table in the database is locked + SQLITE_NOMEM* = 7 # A malloc() failed + SQLITE_READONLY* = 8 # Attempt to write a readonly database + SQLITE_INTERRUPT* = 9 # Operation terminated by sqlite3_interrupt() + SQLITE_IOERR* = 10 # Some kind of disk I/O error occurred + SQLITE_CORRUPT* = 11 # The database disk image is malformed + SQLITE_NOTFOUND* = 12 # (Internal Only) Table or record not found + SQLITE_FULL* = 13 # Insertion failed because database is full + SQLITE_CANTOPEN* = 14 # Unable to open the database file + SQLITE_PROTOCOL* = 15 # Database lock protocol error + SQLITE_EMPTY* = 16 # Database is empty + SQLITE_SCHEMA* = 17 # The database schema changed + SQLITE_TOOBIG* = 18 # Too much data for one row of a table + SQLITE_CONSTRAINT* = 19 # Abort due to constraint violation + SQLITE_MISMATCH* = 20 # Data type mismatch + SQLITE_MISUSE* = 21 # Library used incorrectly + SQLITE_NOLFS* = 22 # Uses OS features not supported on host + SQLITE_AUTH* = 23 # Authorization denied + SQLITE_FORMAT* = 24 # Auxiliary database format error + SQLITE_RANGE* = 25 # 2nd parameter to sqlite3_bind out of range + SQLITE_NOTADB* = 26 # File opened that is not a database file + SQLITE_ROW* = 100 # sqlite3_step() has another row ready + SQLITE_DONE* = 101 # sqlite3_step() has finished executing + SQLITE_COPY* = 0 + SQLITE_CREATE_INDEX* = 1 + SQLITE_CREATE_TABLE* = 2 + SQLITE_CREATE_TEMP_INDEX* = 3 + SQLITE_CREATE_TEMP_TABLE* = 4 + SQLITE_CREATE_TEMP_TRIGGER* = 5 + SQLITE_CREATE_TEMP_VIEW* = 6 + SQLITE_CREATE_TRIGGER* = 7 + SQLITE_CREATE_VIEW* = 8 + SQLITE_DELETE* = 9 + SQLITE_DROP_INDEX* = 10 + SQLITE_DROP_TABLE* = 11 + SQLITE_DROP_TEMP_INDEX* = 12 + SQLITE_DROP_TEMP_TABLE* = 13 + SQLITE_DROP_TEMP_TRIGGER* = 14 + SQLITE_DROP_TEMP_VIEW* = 15 + SQLITE_DROP_TRIGGER* = 16 + SQLITE_DROP_VIEW* = 17 + SQLITE_INSERT* = 18 + SQLITE_PRAGMA* = 19 + SQLITE_READ* = 20 + SQLITE_SELECT* = 21 + SQLITE_TRANSACTION* = 22 + SQLITE_UPDATE* = 23 + SQLITE_ATTACH* = 24 + SQLITE_DETACH* = 25 + SQLITE_ALTER_TABLE* = 26 + SQLITE_REINDEX* = 27 + SQLITE_DENY* = 1 + SQLITE_IGNORE* = 2 # Original from sqlite3.h: + #define SQLITE_STATIC ((void(*)(void *))0) + #define SQLITE_TRANSIENT ((void(*)(void *))-1) + SQLITE_DETERMINISTIC* = 0x800 + +type + Sqlite3 {.pure, final.} = object + PSqlite3* = ptr Sqlite3 + PPSqlite3* = ptr PSqlite3 + Sqlite3_Backup {.pure, final.} = object + PSqlite3_Backup* = ptr Sqlite3_Backup + PPSqlite3_Backup* = ptr PSqlite3_Backup + Context{.pure, final.} = object + Pcontext* = ptr Context + TStmt{.pure, final.} = object + PStmt* = ptr TStmt + Value{.pure, final.} = object + PValue* = ptr Value + PValueArg* = array[0..127, PValue] + + Callback* = proc (para1: pointer, para2: int32, para3, + para4: cstringArray): int32{.cdecl.} + Tbind_destructor_func* = proc (para1: pointer){.cdecl, tags: [], gcsafe.} + Create_function_step_func* = proc (para1: Pcontext, para2: int32, + para3: PValueArg){.cdecl.} + Create_function_func_func* = proc (para1: Pcontext, para2: int32, + para3: PValueArg){.cdecl.} + Create_function_final_func* = proc (para1: Pcontext){.cdecl.} + Result_func* = proc (para1: pointer){.cdecl.} + Create_collation_func* = proc (para1: pointer, para2: int32, para3: pointer, + para4: int32, para5: pointer): int32{.cdecl.} + Collation_needed_func* = proc (para1: pointer, para2: PSqlite3, eTextRep: int32, + para4: cstring){.cdecl.} + +const + SQLITE_STATIC* = nil + SQLITE_TRANSIENT* = cast[Tbind_destructor_func](-1) + +proc close*(para1: PSqlite3): int32{.cdecl, mylib, importc: "sqlite3_close".} +proc exec*(para1: PSqlite3, sql: cstring, para3: Callback, para4: pointer, + errmsg: var cstring): int32{.cdecl, mylib, + importc: "sqlite3_exec".} +proc last_insert_rowid*(para1: PSqlite3): int64{.cdecl, mylib, + importc: "sqlite3_last_insert_rowid".} +proc changes*(para1: PSqlite3): int32{.cdecl, mylib, importc: "sqlite3_changes".} +proc total_changes*(para1: PSqlite3): int32{.cdecl, mylib, + importc: "sqlite3_total_changes".} +proc interrupt*(para1: PSqlite3){.cdecl, mylib, importc: "sqlite3_interrupt".} +proc complete*(sql: cstring): int32{.cdecl, mylib, + importc: "sqlite3_complete".} +proc complete16*(sql: pointer): int32{.cdecl, mylib, + importc: "sqlite3_complete16".} +proc busy_handler*(para1: PSqlite3, + para2: proc (para1: pointer, para2: int32): int32{.cdecl.}, + para3: pointer): int32{.cdecl, mylib, + importc: "sqlite3_busy_handler".} +proc busy_timeout*(para1: PSqlite3, ms: int32): int32{.cdecl, mylib, + importc: "sqlite3_busy_timeout".} +proc get_table*(para1: PSqlite3, sql: cstring, resultp: var cstringArray, + nrow, ncolumn: var cint, errmsg: ptr cstring): int32{.cdecl, + mylib, importc: "sqlite3_get_table".} +proc free_table*(result: cstringArray){.cdecl, mylib, + importc: "sqlite3_free_table".} + # Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf + # function sqlite3_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf'; +proc mprintf*(para1: cstring): cstring{.cdecl, varargs, mylib, + importc: "sqlite3_mprintf".} + #function sqlite3_vmprintf(_para1:Pchar; _para2:va_list):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_vmprintf'; +proc free*(z: cstring){.cdecl, mylib, importc: "sqlite3_free".} + #function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf'; +proc snprintf*(para1: int32, para2: cstring, para3: cstring): cstring{.cdecl, + mylib, varargs, importc: "sqlite3_snprintf".} +proc set_authorizer*(para1: PSqlite3, xAuth: proc (para1: pointer, para2: int32, + para3: cstring, para4: cstring, para5: cstring, para6: cstring): int32{. + cdecl.}, pUserData: pointer): int32{.cdecl, mylib, + importc: "sqlite3_set_authorizer".} +proc trace*(para1: PSqlite3, xTrace: proc (para1: pointer, para2: cstring){.cdecl.}, + para3: pointer): pointer{.cdecl, mylib, + importc: "sqlite3_trace".} +proc progress_handler*(para1: PSqlite3, para2: int32, + para3: proc (para1: pointer): int32{.cdecl.}, + para4: pointer){.cdecl, mylib, + importc: "sqlite3_progress_handler".} +proc commit_hook*(para1: PSqlite3, para2: proc (para1: pointer): int32{.cdecl.}, + para3: pointer): pointer{.cdecl, mylib, + importc: "sqlite3_commit_hook".} +proc open*(filename: cstring, ppDb: var PSqlite3): int32{.cdecl, mylib, + importc: "sqlite3_open".} +proc open16*(filename: pointer, ppDb: var PSqlite3): int32{.cdecl, mylib, + importc: "sqlite3_open16".} +proc errcode*(db: PSqlite3): int32{.cdecl, mylib, importc: "sqlite3_errcode".} +proc errmsg*(para1: PSqlite3): cstring{.cdecl, mylib, importc: "sqlite3_errmsg".} +proc errmsg16*(para1: PSqlite3): pointer{.cdecl, mylib, + importc: "sqlite3_errmsg16".} +proc prepare*(db: PSqlite3, zSql: cstring, nBytes: int32, ppStmt: var PStmt, + pzTail: ptr cstring): int32{.cdecl, mylib, + importc: "sqlite3_prepare".} + +proc prepare_v2*(db: PSqlite3, zSql: cstring, nByte: cint, ppStmt: var PStmt, + pzTail: ptr cstring): cint {. + importc: "sqlite3_prepare_v2", cdecl, mylib.} + +proc prepare16*(db: PSqlite3, zSql: pointer, nBytes: int32, ppStmt: var PStmt, + pzTail: var pointer): int32{.cdecl, mylib, + importc: "sqlite3_prepare16".} +proc bind_blob*(para1: PStmt, para2: int32, para3: pointer, n: int32, + para5: Tbind_destructor_func): int32{.cdecl, mylib, + importc: "sqlite3_bind_blob".} +proc bind_double*(para1: PStmt, para2: int32, para3: float64): int32{.cdecl, + mylib, importc: "sqlite3_bind_double".} +proc bind_int*(para1: PStmt, para2: int32, para3: int32): int32{.cdecl, + mylib, importc: "sqlite3_bind_int".} +proc bind_int64*(para1: PStmt, para2: int32, para3: int64): int32{.cdecl, + mylib, importc: "sqlite3_bind_int64".} +proc bind_null*(para1: PStmt, para2: int32): int32{.cdecl, mylib, + importc: "sqlite3_bind_null".} +proc bind_text*(para1: PStmt, para2: int32, para3: cstring, n: int32, + para5: Tbind_destructor_func): int32{.cdecl, mylib, + importc: "sqlite3_bind_text".} +proc bind_text16*(para1: PStmt, para2: int32, para3: pointer, para4: int32, + para5: Tbind_destructor_func): int32{.cdecl, mylib, + importc: "sqlite3_bind_text16".} + #function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value'; + #These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT + #It's the c world man ;-) +proc bind_blob*(para1: PStmt, para2: int32, para3: pointer, n: int32, + para5: int32): int32{.cdecl, mylib, + importc: "sqlite3_bind_blob".} +proc bind_text*(para1: PStmt, para2: int32, para3: cstring, n: int32, + para5: int32): int32{.cdecl, mylib, + importc: "sqlite3_bind_text".} +proc bind_text16*(para1: PStmt, para2: int32, para3: pointer, para4: int32, + para5: int32): int32{.cdecl, mylib, + importc: "sqlite3_bind_text16".} +proc bind_parameter_count*(para1: PStmt): int32{.cdecl, mylib, + importc: "sqlite3_bind_parameter_count".} +proc bind_parameter_name*(para1: PStmt, para2: int32): cstring{.cdecl, + mylib, importc: "sqlite3_bind_parameter_name".} +proc bind_parameter_index*(para1: PStmt, zName: cstring): int32{.cdecl, + mylib, importc: "sqlite3_bind_parameter_index".} +proc clear_bindings*(para1: PStmt): int32 {.cdecl, + mylib, importc: "sqlite3_clear_bindings".} +proc column_count*(PStmt: PStmt): int32{.cdecl, mylib, + importc: "sqlite3_column_count".} +proc column_name*(para1: PStmt, para2: int32): cstring{.cdecl, mylib, + importc: "sqlite3_column_name".} +proc column_table_name*(para1: PStmt; para2: int32): cstring{.cdecl, mylib, + importc: "sqlite3_column_table_name".} +proc column_name16*(para1: PStmt, para2: int32): pointer{.cdecl, mylib, + importc: "sqlite3_column_name16".} +proc column_decltype*(para1: PStmt, i: int32): cstring{.cdecl, mylib, + importc: "sqlite3_column_decltype".} +proc column_decltype16*(para1: PStmt, para2: int32): pointer{.cdecl, + mylib, importc: "sqlite3_column_decltype16".} +proc step*(para1: PStmt): int32{.cdecl, mylib, importc: "sqlite3_step".} +proc data_count*(PStmt: PStmt): int32{.cdecl, mylib, + importc: "sqlite3_data_count".} +proc column_blob*(para1: PStmt, iCol: int32): pointer{.cdecl, mylib, + importc: "sqlite3_column_blob".} +proc column_bytes*(para1: PStmt, iCol: int32): int32{.cdecl, mylib, + importc: "sqlite3_column_bytes".} +proc column_bytes16*(para1: PStmt, iCol: int32): int32{.cdecl, mylib, + importc: "sqlite3_column_bytes16".} +proc column_double*(para1: PStmt, iCol: int32): float64{.cdecl, mylib, + importc: "sqlite3_column_double".} +proc column_int*(para1: PStmt, iCol: int32): int32{.cdecl, mylib, + importc: "sqlite3_column_int".} +proc column_int64*(para1: PStmt, iCol: int32): int64{.cdecl, mylib, + importc: "sqlite3_column_int64".} +proc column_text*(para1: PStmt, iCol: int32): cstring{.cdecl, mylib, + importc: "sqlite3_column_text".} +proc column_text16*(para1: PStmt, iCol: int32): pointer{.cdecl, mylib, + importc: "sqlite3_column_text16".} +proc column_type*(para1: PStmt, iCol: int32): int32{.cdecl, mylib, + importc: "sqlite3_column_type".} +proc finalize*(PStmt: PStmt): int32{.cdecl, mylib, + importc: "sqlite3_finalize".} +proc reset*(PStmt: PStmt): int32{.cdecl, mylib, importc: "sqlite3_reset".} +proc create_function*(para1: PSqlite3, zFunctionName: cstring, nArg: int32, + eTextRep: int32, para5: pointer, + xFunc: Create_function_func_func, + xStep: Create_function_step_func, + xFinal: Create_function_final_func): int32{.cdecl, + mylib, importc: "sqlite3_create_function".} +proc create_function16*(para1: PSqlite3, zFunctionName: pointer, nArg: int32, + eTextRep: int32, para5: pointer, + xFunc: Create_function_func_func, + xStep: Create_function_step_func, + xFinal: Create_function_final_func): int32{.cdecl, + mylib, importc: "sqlite3_create_function16".} +proc aggregate_count*(para1: Pcontext): int32{.cdecl, mylib, + importc: "sqlite3_aggregate_count".} +proc value_blob*(para1: PValue): pointer{.cdecl, mylib, + importc: "sqlite3_value_blob".} +proc value_bytes*(para1: PValue): int32{.cdecl, mylib, + importc: "sqlite3_value_bytes".} +proc value_bytes16*(para1: PValue): int32{.cdecl, mylib, + importc: "sqlite3_value_bytes16".} +proc value_double*(para1: PValue): float64{.cdecl, mylib, + importc: "sqlite3_value_double".} +proc value_int*(para1: PValue): int32{.cdecl, mylib, + importc: "sqlite3_value_int".} +proc value_int64*(para1: PValue): int64{.cdecl, mylib, + importc: "sqlite3_value_int64".} +proc value_text*(para1: PValue): cstring{.cdecl, mylib, + importc: "sqlite3_value_text".} +proc value_text16*(para1: PValue): pointer{.cdecl, mylib, + importc: "sqlite3_value_text16".} +proc value_text16le*(para1: PValue): pointer{.cdecl, mylib, + importc: "sqlite3_value_text16le".} +proc value_text16be*(para1: PValue): pointer{.cdecl, mylib, + importc: "sqlite3_value_text16be".} +proc value_type*(para1: PValue): int32{.cdecl, mylib, + importc: "sqlite3_value_type".} +proc aggregate_context*(para1: Pcontext, nBytes: int32): pointer{.cdecl, + mylib, importc: "sqlite3_aggregate_context".} +proc user_data*(para1: Pcontext): pointer{.cdecl, mylib, + importc: "sqlite3_user_data".} +proc get_auxdata*(para1: Pcontext, para2: int32): pointer{.cdecl, mylib, + importc: "sqlite3_get_auxdata".} +proc set_auxdata*(para1: Pcontext, para2: int32, para3: pointer, + para4: proc (para1: pointer){.cdecl.}){.cdecl, mylib, + importc: "sqlite3_set_auxdata".} +proc result_blob*(para1: Pcontext, para2: pointer, para3: int32, + para4: Result_func){.cdecl, mylib, + importc: "sqlite3_result_blob".} +proc result_double*(para1: Pcontext, para2: float64){.cdecl, mylib, + importc: "sqlite3_result_double".} +proc result_error*(para1: Pcontext, para2: cstring, para3: int32){.cdecl, + mylib, importc: "sqlite3_result_error".} +proc result_error16*(para1: Pcontext, para2: pointer, para3: int32){.cdecl, + mylib, importc: "sqlite3_result_error16".} +proc result_int*(para1: Pcontext, para2: int32){.cdecl, mylib, + importc: "sqlite3_result_int".} +proc result_int64*(para1: Pcontext, para2: int64){.cdecl, mylib, + importc: "sqlite3_result_int64".} +proc result_null*(para1: Pcontext){.cdecl, mylib, + importc: "sqlite3_result_null".} +proc result_text*(para1: Pcontext, para2: cstring, para3: int32, + para4: Result_func){.cdecl, mylib, + importc: "sqlite3_result_text".} +proc result_text16*(para1: Pcontext, para2: pointer, para3: int32, + para4: Result_func){.cdecl, mylib, + importc: "sqlite3_result_text16".} +proc result_text16le*(para1: Pcontext, para2: pointer, para3: int32, + para4: Result_func){.cdecl, mylib, + importc: "sqlite3_result_text16le".} +proc result_text16be*(para1: Pcontext, para2: pointer, para3: int32, + para4: Result_func){.cdecl, mylib, + importc: "sqlite3_result_text16be".} +proc result_value*(para1: Pcontext, para2: PValue){.cdecl, mylib, + importc: "sqlite3_result_value".} +proc create_collation*(para1: PSqlite3, zName: cstring, eTextRep: int32, + para4: pointer, xCompare: Create_collation_func): int32{. + cdecl, mylib, importc: "sqlite3_create_collation".} +proc create_collation16*(para1: PSqlite3, zName: cstring, eTextRep: int32, + para4: pointer, xCompare: Create_collation_func): int32{. + cdecl, mylib, importc: "sqlite3_create_collation16".} +proc collation_needed*(para1: PSqlite3, para2: pointer, para3: Collation_needed_func): int32{. + cdecl, mylib, importc: "sqlite3_collation_needed".} +proc collation_needed16*(para1: PSqlite3, para2: pointer, para3: Collation_needed_func): int32{. + cdecl, mylib, importc: "sqlite3_collation_needed16".} +proc libversion*(): cstring{.cdecl, mylib, importc: "sqlite3_libversion".} + #Alias for allowing better code portability (win32 is not working with external variables) +proc version*(): cstring{.cdecl, mylib, importc: "sqlite3_libversion".} + # Not published functions +proc libversion_number*(): int32{.cdecl, mylib, + importc: "sqlite3_libversion_number".} + +proc backup_init*(pDest: PSqlite3, zDestName: cstring, pSource: PSqlite3, zSourceName: cstring): PSqlite3_Backup {. + cdecl, mylib, importc: "sqlite3_backup_init".} + +proc backup_step*(pBackup: PSqlite3_Backup, nPage: int32): int32 {.cdecl, mylib, importc: "sqlite3_backup_step".} + +proc backup_finish*(pBackup: PSqlite3_Backup): int32 {.cdecl, mylib, importc: "sqlite3_backup_finish".} + +proc backup_pagecount*(pBackup: PSqlite3_Backup): int32 {.cdecl, mylib, importc: "sqlite3_backup_pagecount".} + +proc backup_remaining*(pBackup: PSqlite3_Backup): int32 {.cdecl, mylib, importc: "sqlite3_backup_remaining".} + +proc sqlite3_sleep*(t: int64): int64 {.cdecl, mylib, importc: "sqlite3_sleep".} + + #function sqlite3_key(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_key'; + #function sqlite3_rekey(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_rekey'; + #function sqlite3_sleep(_para1:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_sleep'; + #function sqlite3_expired(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_expired'; + #function sqlite3_global_recover:longint;cdecl; external Sqlite3Lib name 'sqlite3_global_recover'; +# implementation + +when defined(nimHasStyleChecks): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/license.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/license.txt Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,7 @@ +Copyright (C) Chen Kai-Hung, Ward + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,42 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== + +## This module contains Windows API, struct, and constant definitions. +## The definitions are translated from MinGW's Windows headers. +## +## The module also include some windows string type utilities and COM support. +## See utils.nim, winstr.nim, and com.nim for details. +## +## Usage: +## .. code-block:: Nim +## import winim # impore all modules, except COM support +## import winim/lean # for core SDK only +## import winim/mean # for core SDK + Shell + OLE +## import winim/com # for core SDK + Shell + OLE + COM support +## +## To compile: +## .. code-block:: Nim +## nim c source.nim +## add -d:winansi or -d:useWinAnsi for Ansi version (Unicode by default). +## add -d:noDiscardableApi if not like discardable windows API. +## add -d:noRes to disable the visual styles (not to link winim32.res or winim64.res). +## add -d:lean same as import winim/lean. +## add -d:mean or -d:win32_lean_and_mean same as import winim/mean. +## add -d:notrace disable COM objects trace. See com.nim for details. + +when defined(lean): + import winim/[core] + export core +elif defined(mean) or defined(win32_lean_and_mean): + import winim/[core, shell, ole] + export core, shell, ole +else: + import winim/[core, shell, net, ole, extra] + export core, shell, net, ole, extra + +import winim/[utils, winstr] +export utils, winstr diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/clr.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/clr.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,833 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows .NET Common Language Runtime Supports +# +#==================================================================== + +## This module add Windows Common Language Runtime (CLR) support to Winim. +## So that we can use Nim to interact with Windows .NET frameworks. +## +## This module heavily dependent on `winim/com` module. So please also +## read the document about it to help understanding the usage. +## Notice: `int` will be converted into `int32` before passing to CLR even in +## 64-bit environment. + +{.push hint[Name]: off.} + +when NimVersion < "1.2": + {.fatal: "winim/clr require nim compiler version >= 1.2".} + +runnableExamples: + proc example1() = + ## Create a CLR object (aka. C# instance) and call the method + var mscor = load("mscorlib") + var rand = mscor.new("System.Random") + echo rand.Next() + + proc example2() = + ## Create a type object and call the static method + var mscor = load("mscorlib") + var Int32 = mscor.GetType("System.Int32") + echo @Int32.Parse("12345") + + proc example3() = + ## Compile some code and run it + var code = """ + + using System; + public class Test { + public void Hello() { + Console.WriteLine("Hello, world"); + } + } + """ + var res = compile(code) + var o = res.CompiledAssembly.new("Test") + o.Hello() + +{.experimental.} # experimental for dot operators + +import ole, com +import strutils, macros +import strformat except `&` +export com + +const + VBCodeProvider* = "Microsoft.VisualBasic.VBCodeProvider" + CSharpCodeProvider* = "Microsoft.CSharp.CSharpCodeProvider" + +type + CLRError* = object of CatchableError + ## Raised if a CLR error occurred. + hresult*: HRESULT + + CLRVariant* = distinct variant + ## `distinct variant` to represent CLR object or value. + + CLRType* = distinct variant + ## `distinct variant` to represent CLR Type object. + + CLRInterface* = object + ## Represent CLR object with specified interface. + ## Use `{}` to create interface object. + obj*: CLRVariant + intf*: CLRVariant + +# forward declarations +proc toObject*[T](x: T): CLRVariant + +let Null = CLRVariant wrap(VARIANT()) +var + hresult {.threadvar.}: HRESULT + CurrentAssembly {.threadvar.}: CLRVariant + +converter voidpp_converter(x: ptr ptr object): ptr pointer {.used.} = cast[ptr pointer](x) + +proc isNil*(x: CLRVariant): bool {.borrow.} + ## Check if `CLRVariant` is nil or not. + +proc isNil*(x: CLRType): bool {.borrow.} + ## Check if `CLRType` is nil or not. + +proc isNull*(x: CLRVariant): bool {.borrow.} + ## Check if `CLRVariant` is C# null or VB nothing. + +proc unwrap*(x: CLRVariant): VARIANT {.borrow.} + ## Unwrap `CLRVariant` to `VARIANT` object. + +proc `==`*(x, y: CLRVariant): bool {.borrow.} + ## Checks for equality between two `CLRVariant` variables. + +proc toVariant*(x: CLRVariant): variant {.inline.} = + ## Converts a `CLRVariant` x into a `variant`. + result = variant x + +proc toCLRVariant*[T](x: T): CLRVariant {.inline.} = + ## Converts any supported types into a `CLRVariant`. + when T is int: + result = CLRVariant toVariant(int32 x) + else: + result = CLRVariant toVariant(x) + +proc toCLRVariant*[T](x: openArray[T], vt: VARENUM = VT_VARIANT): CLRVariant {.inline.} = + ## Converts any supported openArray types into a `CLRVariant`. + result = CLRVariant toVariant(x, vt) + +proc toCLRVariant*(x: typeof(nil)): CLRVariant {.inline.} = + ## Converts nil into a `CLRVariant`. + {.gcsafe.}: + result = Null + +proc fromCLRVariant*[T](x: CLRVariant): T {.inline.} = + ## Converts a `CLRVariant` into any supported types. + result = fromVariant[T](variant x) + +converter clrVariantToVariant*(x: CLRVariant): variant = variant x + ## Converts `CLRVariant` into `variant` automatically. + +converter clrVariantToString*(x: CLRVariant): string = fromCLRVariant[string](x) + ## Converts `CLRVariant` into `string` automatically. + +converter clrVariantToCString*(x: CLRVariant): cstring = fromCLRVariant[cstring](x) + ## Converts `CLRVariant` into `cstring` automatically. + +converter clrVariantToMString*(x: CLRVariant): mstring = fromCLRVariant[mstring](x) + ## Converts `CLRVariant` into `mstring` automatically. + +converter clrVariantToWString*(x: CLRVariant): wstring = fromCLRVariant[wstring](x) + ## Converts `CLRVariant` into `wstring` automatically. + +converter clrVariantToChar*(x: CLRVariant): char = fromCLRVariant[char](x) + ## Converts `CLRVariant` into `char` automatically. + +converter clrVariantToBool*(x: CLRVariant): bool = fromCLRVariant[bool](x) + ## Converts `CLRVariant` into `bool` automatically. + +converter clrVariantToPtrIDispatch*(x: CLRVariant): ptr IDispatch = fromCLRVariant[ptr IDispatch](x) + ## Converts `CLRVariant` into `ptr IDispatch` automatically. + +converter clrVariantToPtrIUnknown*(x: CLRVariant): ptr IUnknown = fromCLRVariant[ptr IUnknown](x) + ## Converts `CLRVariant` into `ptr IUnknown` automatically. + +converter clrVariantToPointer*(x: CLRVariant): pointer = fromCLRVariant[pointer](x) + ## Converts `CLRVariant` into `ptr IUnknown` automatically. + +converter clrVariantToInt*(x: CLRVariant): int = fromCLRVariant[int](x) + ## Converts `CLRVariant` into `int` automatically. + +converter clrVariantToUint*(x: CLRVariant): uint = fromCLRVariant[uint](x) + ## Converts `CLRVariant` into `uint` automatically. + +converter clrVariantToInt8*(x: CLRVariant): int8 = fromCLRVariant[int8](x) + ## Converts `CLRVariant` into `int8` automatically. + +converter clrVariantToUint8*(x: CLRVariant): uint8 = fromCLRVariant[uint8](x) + ## Converts `CLRVariant` into `uint8` automatically. + +converter clrVariantToInt16*(x: CLRVariant): int16 = fromCLRVariant[int16](x) + ## Converts `CLRVariant` into `int16` automatically. + +converter clrVariantToUInt16*(x: CLRVariant): uint16 = fromCLRVariant[uint16](x) + ## Converts `CLRVariant` into `uint16` automatically. + +converter clrVariantToInt32*(x: CLRVariant): int32 = fromCLRVariant[int32](x) + ## Converts `CLRVariant` into `int32` automatically. + +converter clrVariantToUInt32*(x: CLRVariant): uint32 = fromCLRVariant[uint32](x) + ## Converts `CLRVariant` into `uint32` automatically. + +converter clrVariantToInt64*(x: CLRVariant): int64 = fromCLRVariant[int64](x) + ## Converts `CLRVariant` into `int64` automatically. + +converter clrVariantToUInt64*(x: CLRVariant): uint64 = fromCLRVariant[uint64](x) + ## Converts `CLRVariant` into `uint64` automatically. + +converter clrVariantToFloat32*(x: CLRVariant): float32 = fromCLRVariant[float32](x) + ## Converts `CLRVariant` into `float32` automatically. + +converter clrVariantToFloat64*(x: CLRVariant): float64 = fromCLRVariant[float64](x) + ## Converts `CLRVariant` into `float64` automatically. + +converter clrVariantToVARIANTRaw*(x: CLRVariant): VARIANT = fromCLRVariant[VARIANT](x) + ## Converts `CLRVariant` into `VARIANT` automatically. + +converter clrVariantToCOMArray1D*(x: CLRVariant): COMArray1D = fromCLRVariant[COMArray1D](x) + ## Converts `CLRVariant` into `COMArray1D` automatically. + +converter clrVariantToCOMArray2D*(x: CLRVariant): COMArray2D = fromCLRVariant[COMArray2D](x) + ## Converts `CLRVariant` into `COMArray2D` automatically. + +converter clrVariantToCOMArray3D*(x: CLRVariant): COMArray3D = fromCLRVariant[COMArray3D](x) + ## Converts `CLRVariant` into `COMArray3D` automatically. + +converter clrVariantToCOMBinary*(x: CLRVariant): COMBinary = fromCLRVariant[COMBinary](x) + ## Converts `CLRVariant` into `COMBinary` automatically. + +template ERR(x: HRESULT): bool = + hresult = x + hresult != S_OK + +proc clrError(msg: string, hr: HRESULT = 0) = + var hr = hr + if hr == 0: hr = hresult + if hr == 0: hr = E_FAIL + + var e = newException(CLRError, fmt"{msg} (0x{hr.tohex})") + e.hresult = hr + raise e + +template to(v: CLRVariant, T: typedesc): untyped = + var ret: ptr T + if v.unwrap.vt == VT_UNKNOWN: + hresult = v.unwrap.punkVal.QueryInterface(&(`IID T`), &ret) + + elif v.unwrap.vt == VT_DISPATCH: + hresult = v.unwrap.pdispVal.QueryInterface(&(`IID T`), &ret) + + else: + hresult = E_NOINTERFACE + + ret + +proc isObject*(v: CLRVariant): bool = + ## Check if `CLRVariant` is CLR object or not. + var obj = v.to(IObject) + if not obj.isNil: + result = true + obj.Release() + +proc isType*(v: CLRVariant): bool = + ## Check if `CLRVariant` is CLR Type object or not. + var obj = v.to(IType) + if not obj.isNil: + result = true + obj.Release() + +proc isStruct*(v: CLRVariant): bool {.inline.} = + ## Check if `CLRVariant` is CLR struct type (returnd from CLR as VT_RECORD variant). + result = v.unwrap.vt == VT_RECORD + +proc `@`*(v: CLRVariant): CLRType = + ## Convert `CLRVariant` into `CLRType` so that static members can be invoked. + if not v.isType(): + clrError("variant is not a type object") + + result = CLRType v + +proc com*(v: CLRVariant): com = + ## Convert `CLRVariant` to winim's com object, aka. COM callable wrapper (CCW). + if not v.isObject(): + clrError("variant is not an object") + + result = newCom(cast[ptr IDispatch](v.unwrap.punkVal)) + +proc invoke(typ: ptr IType, self: VARIANT, name: string, flags: int, + vargs: varargs[CLRVariant, toCLRVariant]): CLRVariant {.discardable.} = + + var + bstr = SysAllocString(name) + retVal: VARIANT + + defer: + SysFreeString(bstr) + + let hr = + if vargs.len == 0: + typ.InvokeMember_3(bstr, int32 flags, nil, self, nil, &retVal) + else: + let arr = toCLRVariant(vargs) + typ.InvokeMember_3(bstr, int32 flags, nil, self, arr.unwrap.parray, &retVal) + + if hr.ERR: + clrError("unable to invoke specified member: " & name) + + result = CLRVariant wrap(retVal) + +proc invoke*(v: CLRVariant, name: string, flags: int, + vargs: varargs[CLRVariant, toCLRVariant]): CLRVariant {.discardable.} = + ## Low level `invoke` for `CLRVariant`. Equal to `CLRVariant.GetType().InvokeMember(...)` + if v.isNil: + clrError("variant is nil", E_POINTER) + + var + obj: ptr IObject + typ: ptr IType + self: VARIANT + + defer: + if not obj.isNil: obj.Release() + if not typ.isNil: typ.Release() + + obj = v.to(IObject) + if obj.isNil: + obj = toObject(v).to(IObject) + if obj.isNil: + clrError("variant is not an object") + + if obj.GetType(&typ).ERR: + clrError("unable to get type of object") + + self.vt = VT_UNKNOWN + self.punkVal = obj + + result = invoke(typ, self, name, flags, vargs) + +proc invoke*(v: CLRType, name: string, flags: int, + vargs: varargs[CLRVariant, toCLRVariant]): CLRVariant {.discardable.} = + ## Low level `invoke` for `CLRType`. Equal to `CLRType.InvokeMember(...)` + let v = CLRVariant v + if v.isNil: + clrError("variant is nil", E_POINTER) + + var + typ: ptr IType + self: VARIANT + + defer: + if not typ.isNil: typ.Release() + + typ = v.to(IType) + if typ.isNil: + clrError("variant is not a type") + + result = invoke(typ, self, name, flags, vargs) + +proc invoke*(v: CLRInterface, name: string, flags: int, + vargs: varargs[CLRVariant, toCLRVariant]): CLRVariant {.discardable.} = + ## Low level `invoke` for `CLRInterface`. + if v.obj.isNil or v.intf.isNil: + clrError("invalid interface", E_POINTER) + + var + obj: ptr IObject + typ: ptr IType + self: VARIANT + + defer: + if not obj.isNil: obj.Release() + if not typ.isNil: typ.Release() + + obj = v.obj.to(IObject) + if obj.isNil: + obj = toObject(v.obj).to(IObject) + if obj.isNil: + clrError("CLRInterface.obj is not an object") + + typ = v.intf.to(IType) + if typ.isNil: + clrError("CLRInterface.intf is not a type") + + self.vt = VT_UNKNOWN + self.punkVal = obj + + result = invoke(typ, self, name, flags, vargs) + +macro `.`*(v: CLRVariant, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot operator for `CLRVariant`. Invoke a method, get a property, or get a field. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_InvokeMethod or BindingFlags_GetProperty or + BindingFlags_GetField or BindingFlags_OptionalParamBinding)) + + for i in vargs: result.add i + +macro `.=`*(v: CLRVariant, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot assignment operator for `CLRVariant`. Set a property or field. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_SetProperty or BindingFlags_SetField)) + + for i in vargs: result.add i + +macro `.`*(v: CLRType, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot operator for `CLRType`. Invoke a static method, get a static property, or get a static field. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_InvokeMethod or BindingFlags_GetProperty or + BindingFlags_GetField or BindingFlags_FlattenHierarchy or BindingFlags_Static or + BindingFlags_Public or BindingFlags_NonPublic or BindingFlags_OptionalParamBinding)) + + for i in vargs: result.add i + +macro `.=`*(v: CLRType, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot assignment operator for `CLRType`. Set a static property or field. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_SetProperty or BindingFlags_SetField or + BindingFlags_FlattenHierarchy or BindingFlags_Static or BindingFlags_Public or + BindingFlags_NonPublic)) + + for i in vargs: result.add i + +macro `.`*(v: CLRInterface, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot operator for `CLRInterface`. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_InvokeMethod or BindingFlags_GetProperty or + BindingFlags_GetField or BindingFlags_OptionalParamBinding)) + + for i in vargs: result.add i + +macro `.=`*(v: CLRInterface, name: untyped, vargs: varargs[untyped]): untyped = + ## Dot assignment operator for `CLRInterface`. + result = newCall("invoke", v, newStrLitNode($name), + newIntLitNode(BindingFlags_SetProperty or BindingFlags_SetField)) + + for i in vargs: result.add i + +proc reformatAsgn(n: NimNode): NimNode = + # reformat code: + # a.b(c, ...) = d -> a.b.invoke("c", ..., d) + expectKind(n, nnkAsgn) + + var + params = n[0] + dots = n[0][0] + + params.insert(1, newIntLitNode(BindingFlags_SetProperty or BindingFlags_SetField)) + params.insert(1, dots.last.toStrLit) + params.add(n.last) + dots.del(dots.len-1) + dots.add(newIdentNode("invoke")) + result = n[0] + +proc clrReformat(n: NimNode): NimNode = + result = n + + if n.kind == nnkAsgn and n[0].kind == nnkCall and n[0][0].kind == nnkDotExpr: + # deal with a.b(c) = d + result = clrReformat(reformatAsgn(n)) + + elif n.len != 0: + for i in 0..(Object o){return(T)o;} + public static IntPtr wrapAny(Object o,Type t){try{if(t==o.GetType()){return wrapAny(o);} + else if(t.IsEnum){return wrapAny(Enum.ToObject(t,o));} + else if(t==typeof(Color)){int i=(int)Convert.ChangeType(o,typeof(int));return wrapAny(Color.FromArgb(i&0xff,(i>>8)&0xff,(i>>16)&0xff));} + else{try{return wrapAny(Convert.ChangeType(o,t));} + catch(System.InvalidCastException){return wrapAny(typeof(RuntimeHelper).GetMethod("Cast").MakeGenericMethod(t).Invoke(null,new object[]{o}));}}} + catch{return IntPtr.Zero;}} + public static IntPtr wrapAny(Object o,String type){try{return wrapAny(o,Type.GetType(type,true,true));} + catch{return IntPtr.Zero;}}} + """ + + if CurrentAssembly.isNil: + clrStart() + + var RuntimeHelp {.threadvar.}: CLRVariant + if RuntimeHelp.isNil: + var res = compile(code, ["System.dll", "System.Drawing.dll"]) + assert res.Errors.Count == 0 + RuntimeHelp = res.CompiledAssembly.GetType("RuntimeHelper") + + result = RuntimeHelp + +proc toObjectRaw(iunknown: CLRVariant): CLRVariant = + var v: VARIANT + v.vt = VT_UNKNOWN + v.byref = iunknown.unwrap.byref + if v.byref.isNil: + clrError("unable to convert to object", E_NOTIMPL) + + # Decrement the reference count for Marshal.GetIUnknownForObject() + if not v.punkVal.isNil: + v.punkVal.Release() + result = toCLRVariant(v) + +proc toObject*(x: pointer|proc): CLRVariant = + ## Converts `pointer` or `proc` into a `System.IntPtr` object. + var RuntimeHelp = getRuntimeHelp() + toObjectRaw(@RuntimeHelp.wrapIntPtr(cast[int64](x))) + +proc toObject*[T](x: T): CLRVariant = + ## Try to convert any value types or struct types into a CLR object. + var RuntimeHelp = getRuntimeHelp() + toObjectRaw(@RuntimeHelp.wrapAny(x)) + +proc toObject*[T](x: T, typ: string): CLRVariant = + ## Try to convert any value types or struct types into CLR object of specified type. + var RuntimeHelp = getRuntimeHelp() + toObjectRaw(@RuntimeHelp.wrapAny(x, typ)) + +proc toObject*[T](x: T, typ: CLRVariant): CLRVariant = + ## Try to convert any value types or struct types into CLR object of specified type. + var RuntimeHelp = getRuntimeHelp() + toObjectRaw(@RuntimeHelp.wrapAny(x, typ)) + +proc `[]`*[T: variant|SomeNumber|string|proc|array|seq](x: T): CLRVariant = + ## Syntax sugar for x.toObject(). + toObject(x) + +proc `[]`*[T](x: T, typ: CLRVariant): CLRVariant {.inline.} = + ## Syntax sugar for x.toObject(CLRVariant). + if typ.isNil: + clrError("variant is nil", E_POINTER) + + toObject(x, typ) + +proc `{}`*(v, i: CLRVariant): CLRInterface {.inline.} = + ## Syntax suger to create CLRInterface (require nim compiler version >= 1.2.0). + result.obj = v + result.intf = i + +proc item(v: CLRVariant, i: int): CLRVariant = + var v = v + if not v.isObject: + v = v.toObject() + + let iList = CLRInterface(obj: v, intf: v.GetType.GetInterface("System.Collections.IList")) + result = iList.Item(i) + +proc `[]`*(v: CLRVariant, i: SomeOrdinal): CLRVariant = + ## Index operator for `CLRVariant` (via `IList` interface). + try: + result = v.item(int i) + except CLRError: + clrError("variant is not indexable") + +iterator pairs*(v: CLRVariant): (int, CLRVariant) = + ## Iterates over every member of `CLRVariant`. Yields (int, CLRVariant) pairs. + ## Support System.Array, Enumerable, Collection, etc. + var v = v + if not v.isObject: + var Array {.threadvar.}: CLRVariant + if Array.isNil: + Array = load("mscorlib").GetType("System.Array") + + try: + v = v[Array] + except CLRError: + clrError("variant is not enumerable") + + proc ok(i: CLRInterface): bool {.inline.} = (not i.intf.isNil) and (not i.intf.isNull) + + let + vtype = v.GetType + iCollection = CLRInterface(obj: v, intf: vtype.GetInterface("System.Collections.ICollection")) + iList = CLRInterface(obj: v, intf: vtype.GetInterface("System.Collections.IList")) + iEnumerable = CLRInterface(obj: v, intf: vtype.GetInterface("System.Collections.IEnumerable")) + + if iCollection.ok and iList.ok: + for i in 0 ..< iCollection.Count: + yield (i, iList.Item(i)) + + elif iEnumerable.ok: + var + enumerator: CLRVariant + i = 0 + + try: + enumerator = iEnumerable.GetEnumerator + except CLRError: + clrError("variant is not enumerable") + + while enumerator.MoveNext: + yield (i, enumerator.Current) + i.inc + + else: + clrError("variant is not enumerable") + +iterator items*(v: CLRVariant): CLRVariant = + ## Iterates over every member of `CLRVariant`. + ## Support System.Array, Enumerable, Collection, etc. + for i, o in v: + yield o diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/com.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/com.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1440 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows COM Object And COM Event Supports +# +#==================================================================== + +## This module add windows COM support to Winim. +## So that we can use Nim to interact with COM object like a script language. +## For example: +## +## .. code-block:: Nim +## comScript: +## var dict = CreateObject("Scripting.Dictionary") +## dict.add("a", "the") +## dict.add("b", item:="quick") +## dict.add(item:="fox", key:="c") +## dict.item(key:="c") = "dog" +## for key in dict: +## echo key, " => ", dict.item(key) +## +## This module introduce two new types to deal with COM objects: "com" and "variant". +## In summary, CreateObject() or GetObject() returned a "com" type value, +## and any input/ouput of COM method should be a "variant" type value. +## +## Most Nim's data type and Winim's string type can convert to/from "variant" type value. +## The conversion is usually done automatically. However, specific conversion is aslo welcome. +## +## .. code-block:: Nim +## proc toVariant[T](x: T): variant +## proc fromVariant[T](x: variant): T +## +## # Supported type: +## # char|string|cstring|mstring|wstring|BSTR +## # bool|enum|SomeInteger|SomeReal +## # com|variant|VARIANT|ptr IUnknown|ptr IDispatch|pointer +## # SYSTEMTIME|FILETIME +## # 1D~3D array|seq|COMBinary +## +## *COMBinary* type can help to deal with binary data. +## For example: +## +## .. code-block:: Nim +## var input = "binary\0string\0test\0" +## var v = toVariant(COMBinary input) +## var output = string fromVariant[COMBinary](v) +## assert input == output + +{.experimental.} # experimental for dot operators + +import strutils, macros +import inc/winimbase, utils, winstr, core, shell, ole +export winimbase, utils, winstr, core, shell, ole + +when defined(notrace) or defined(gcDestructors): + const hasTraceTable = false +else: + const hasTraceTable = true + +type + COMError* = object of CatchableError + hresult*: HRESULT + COMException* = object of COMError + VariantConversionError* = object of ValueError + SomeFloat = float | float32 | float64 # SomeReal is deprecated in devel + +template notNil[T](x: T): bool = + when T is BSTR: not cast[pointer](x).isNil + else: not x.isNil + +proc free(x: pointer) = + if not x.isNil: + system.dealloc(x) + +converter voidpp_converter(x: ptr ptr object): ptr pointer = cast[ptr pointer](x) +converter vartype_converter(x: VARENUM): VARTYPE = VARTYPE x + +# make these const store in global scope to avoid repeat init in every proc +discard &IID_NULL +discard &IID_IEnumVARIANT +discard &IID_IClassFactory +discard &IID_IDispatch +discard &IID_ITypeInfo + +type + com* = ref object + disp: ptr IDispatch + + variant* = ref object + raw: VARIANT + + COMArray* = seq[variant] + COMArray1D* = seq[variant] + COMArray2D* = seq[seq[variant]] + COMArray3D* = seq[seq[seq[variant]]] + COMBinary* = distinct string + +proc `len`*(x: COMBinary): int {.borrow.} +proc high*(s: COMBinary): int {.borrow.} +proc low*(s: COMBinary): int {.borrow.} +proc cmp*(x, y: COMBinary): int {.borrow.} +proc `==`*(x, y: COMBinary): bool {.borrow.} +proc `<=` *(x, y: COMBinary): bool {.borrow.} +proc `<` *(x, y: COMBinary): bool {.borrow.} +proc substr*(s: COMBinary, first, last: int): COMBinary {.borrow.} +proc substr*(s: COMBinary, first = 0): COMBinary {.borrow.} + +when hasTraceTable: + import tables + + var + comTrace {.threadvar.}: TableRef[pointer, bool] + varTrace {.threadvar.}: TableRef[pointer, bool] + +var hresult {.threadvar.}: HRESULT +var isInitialized {.threadvar.}: bool + +template ERR(x: HRESULT): bool = + hresult = x + hresult != S_OK + +template OK(x: HRESULT): bool = + hresult = x + hresult == S_OK + +proc newCOMError(msg: string, hr: HRESULT = hresult): ref COMError = + result = newException(COMError, msg) + result.hresult = hr + +proc newCOMException(msg: string, hr: HRESULT = hresult): ref COMException = + result = newException(COMException, msg) + result.hresult = hr + +proc getCurrentCOMError*(): ref COMError {.inline.} = + result = (ref COMError)(getCurrentException()) + +proc desc*(e: ref COMError): string = + var buffer = newWString(4096) + + FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM or FORMAT_MESSAGE_IGNORE_INSERTS, + nil, + DWORD e.hresult, + DWORD MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + buffer, 4096, nil) + + result = $buffer + +when (NimMajor, NimMinor) >= (2, 0): + proc `=destroy`(x: type(com()[])) {.raises: [Exception].} = + if not x.disp.isNil: + x.disp.Release() + + proc `=destroy`(x: type(variant()[])) = + VariantClear(&x.raw) + +else: + proc `=destroy`(x: var type(com()[])) {.raises: [Exception].} = + if not x.disp.isNil: + x.disp.Release() + x.disp = nil + + proc `=destroy`(x: var type(variant()[])) = + VariantClear(&x.raw) + +when not defined(gcDestructors): + proc del*(x: com) = + when hasTraceTable: + comTrace.del(cast[pointer](x)) + + `=destroy`(x[]) + + proc del*(x: variant) = + when hasTraceTable: + varTrace.del(cast[pointer](x)) + + `=destroy`(x[]) + +template init(x): untyped = + # lazy initialize, in case of the it need different apartment or OleInitialize + if not isInitialized: + CoInitialize(nil) + isInitialized = true + + when not defined(gcDestructors): + new(x, del) + else: + new(x) + + when hasTraceTable: + if comTrace.isNil: comTrace = newTable[pointer, bool]() + if varTrace.isNil: varTrace = newTable[pointer, bool]() + + when x.type is variant: + varTrace[cast[pointer](x)] = true + + elif x.type is com: + comTrace[cast[pointer](x)] = true + +proc COM_FullRelease*() = + ## Clean up all COM objects and variants. + ## + ## Usually, we let garbage collector to release the objects. + ## However, sometimes the garbage collector can't release all the object even we call GC_fullCollect(). + ## Some object will create a endless process in this situation. (for example: Excel.Application). + ## So we need this function. + ## + ## Use -d:notrace to disable this function. + when hasTraceTable: + for k, v in varTrace: `=destroy`(cast[variant](k)[]) + for k, v in comTrace: `=destroy`(cast[com](k)[]) + varTrace.clear + comTrace.clear + +proc typeDesc(vt: VARTYPE, d: UINT = 0): string = + proc typeStr(vt: VARTYPE): string = + case vt + of 0: "VT_EMPTY" + of 1: "VT_NULL" + of 2: "VT_I2" + of 3: "VT_I4" + of 4: "VT_R4" + of 5: "VT_R8" + of 6: "VT_CY" + of 7: "VT_DATE" + of 8: "VT_BSTR" + of 9: "VT_DISPATCH" + of 10: "VT_ERROR" + of 11: "VT_BOOL" + of 12: "VT_VARIANT" + of 13: "VT_UNKNOWN" + of 14: "VT_DECIMAL" + of 16: "VT_I1" + of 17: "VT_UI1" + of 18: "VT_UI2" + of 19: "VT_UI4" + of 20: "VT_I8" + of 21: "VT_UI8" + of 22: "VT_INT" + of 23: "VT_UINT" + of 24: "VT_VOID" + of 25: "VT_HRESULT" + of 26: "VT_PTR" + of 27: "VT_SAFEARRAY" + of 28: "VT_CARRAY" + of 29: "VT_USERDEFINED" + of 30: "VT_LPSTR" + of 31: "VT_LPWSTR" + of 36: "VT_RECORD" + of 37: "VT_INT_PTR" + of 38: "VT_UINT_PTR" + of 64: "VT_FILETIME" + of 65: "VT_BLOB" + of 66: "VT_STREAM" + of 67: "VT_STORAGE" + of 68: "VT_STREAMED_OBJECT" + of 69: "VT_STORED_OBJECT" + of 70: "VT_BLOB_OBJECT" + of 71: "VT_CF" + of 72: "VT_CLSID" + of 0xfff: "VT_BSTR_BLOB" + else: "VT_ILLEGAL" + + if vt == VT_ILLEGAL: + result = "VT_ILLEGAL" + else: + result = "" + + if (vt and VT_VECTOR) != 0: result &= "VT_VECTOR|" + if (vt and VT_BYREF) != 0: result &= "VT_BYREF|" + if (vt and VT_RESERVED) != 0: result &= "VT_RESERVED|" + if (vt and VT_ARRAY) != 0: + if d != 0: result &= "VT_ARRAY(" & $d & "D)|" + else: result &= "VT_ARRAY|" + + result &= typeStr(vt and 0xfff) + +proc vcErrorMsg(f: string, t: string = ""): string = + "convert from " & f & " to " & (if t.len == 0: f else: t) + +proc rawType*(x: variant): VARTYPE {.inline.} = + result = x.raw.vt + +proc rawTypeDesc*(x: variant): string = + var dimensions: UINT = 0 + if (x.raw.vt and VT_ARRAY) != 0: + dimensions = SafeArrayGetDim(x.raw.parray) + + result = x.raw.vt.typeDesc(dimensions) + +proc newCom*(x: ptr IDispatch): com = + if x.notNil: + result.init() + x.AddRef() + result.disp = x + +proc copy*(x: com): com {.inline.} = + if x.notNil: + result = newCom(x.disp) + +proc wrap*(x: ptr IDispatch): com {.inline.} = + result = newCom(x) + +proc wrap*(x: VARIANT): variant {.inline.} = + result.init() + result.raw = x + +proc unwrap*(x: com): ptr IDispatch {.inline.} = + result = x.disp + +proc unwrap*(x: variant): VARIANT {.inline.} = + result = x.raw + +proc isNull*(x: variant): bool {.inline.} = + result = (x.raw.vt == VT_EMPTY or x.raw.vt == VT_NULL or (x.raw.vt == VT_DISPATCH and x.raw.byref.isNil)) + +proc newVariant*(x: VARIANT): variant = + result.init() + if VariantCopy(&result.raw, x.unsafeaddr).FAILED: + raise newException(VariantConversionError, vcErrorMsg(x.vt.typeDesc)) + +proc copy*(x: variant): variant = + if x.notNil: + result.init() + if VariantCopy(&result.raw, x.raw.unsafeaddr).FAILED: + raise newException(VariantConversionError, vcErrorMsg(x.raw.vt.typeDesc)) + +proc toVariant*(x: string|cstring|mstring): variant = + result.init() + result.raw.vt = VT_BSTR + var ws = +$x + result.raw.bstrVal = SysAllocString(&ws) + +proc toVariant*(x: wstring): variant = + result.init() + result.raw.vt = VT_BSTR + result.raw.bstrVal = SysAllocString(&x) + +proc toVariant*(x: BSTR): variant = + result.init() + result.raw.vt = VT_BSTR + result.raw.bstrVal = SysAllocString(x) + +proc toVariant*(x: bool): variant = + result.init() + result.raw.vt = VT_BOOL + result.raw.boolVal = if x: VARIANT_TRUE else: VARIANT_FALSE + +proc toVariant*(x: SomeInteger|enum): variant = + result.init() + when x.type is SomeSignedInt: + when sizeof(x) == 1: + result.raw.vt = VT_I1 + result.raw.bVal = cast[uint8](x) + elif sizeof(x) == 2: + result.raw.vt = VT_I2 + result.raw.iVal = x.int16 + elif sizeof(x) == 4: + result.raw.vt = VT_I4 + result.raw.lVal = x.int32 + else: + result.raw.vt = VT_I8 + result.raw.llVal = x.int64 + else: + when sizeof(x) == 1: + result.raw.vt = VT_UI1 + result.raw.bVal = x.uint8 + elif sizeof(x) == 2: + result.raw.vt = VT_UI2 + result.raw.uiVal = x.uint16 + elif sizeof(x) == 4: + result.raw.vt = VT_UI4 + result.raw.ulVal = x.int32 # ULONG is declared as int32 for compatibility + else: + result.raw.vt = VT_UI8 + result.raw.ullVal = x.int64 # ULONG64 is declared as int64 for compatibility + +proc toVariant*(x: SomeFloat): variant = + result.init() + when sizeof(x) == 4: + result.raw.vt = VT_R4 + result.raw.fltVal = x.float32 + else: + result.raw.vt = VT_R8 + result.raw.dblVal = x.float64 + +proc toVariant*(x: char): variant = + result.init() + result.raw.vt = VT_UI1 + result.raw.bVal = x.byte + +proc toVariant*(x: pointer): variant = + result.init() + result.raw.vt = VT_PTR + result.raw.byref = x + +proc toVariant*(x: ptr IDispatch): variant = + result.init() + x.AddRef() + result.raw.vt = VT_DISPATCH + result.raw.pdispVal = x + +proc toVariant*(x: com): variant = + result.init() + x.disp.AddRef() + result.raw.vt = VT_DISPATCH + result.raw.pdispVal = x.disp + +proc toVariant*(x: ptr IUnknown): variant = + result.init() + x.AddRef() + result.raw.vt = VT_UNKNOWN + result.raw.punkVal = x + +proc toVariant*(x: SYSTEMTIME): variant = + # SystemTimeToVariantTime and VariantTimeToSystemTime ignored milliseconds + # https://www.codeproject.com/Articles/17576/SystemTime-to-VariantTime-with-Milliseconds + + const ONETHOUSANDMILLISECONDS = 0.0000115740740740'f64 + var x = x + result.init() + result.raw.vt = VT_DATE + + let wMilliSeconds = float x.wMilliseconds + x.wMilliseconds = 0 + + var date: float64 + if SystemTimeToVariantTime(&x, &date) == FALSE: + raise newException(VariantConversionError, vcErrorMsg("SYSTEMTIME", "VT_DATE")) + + result.raw.date = date + ONETHOUSANDMILLISECONDS / 1000 * wMilliSeconds + +proc toVariant*(x: FILETIME): variant = + result.init() + result.raw.vt = VT_DATE + + var st: SYSTEMTIME + var date: float64 + if FileTimeToSystemTime(x.unsafeaddr, &st) == FALSE or SystemTimeToVariantTime(&st, &date) == FALSE: + raise newException(VariantConversionError, vcErrorMsg("FILETIME", "VT_DATE")) + + result.raw.date = date + +proc toVariant*(x: ptr SomeInteger|ptr SomeFloat|ptr char|ptr bool|ptr BSTR): variant = + result = toVariant(x[]) + result.raw.byref = cast[pointer](x) + result.raw.vt = result.raw.vt or VT_BYREF + +proc toVariant*(x: VARIANT): variant = + result.init() + if VariantCopy(&result.raw, x.unsafeaddr).FAILED: + raise newException(VariantConversionError, vcErrorMsg(x.vt.typeDesc)) + +proc toVariant*(x: variant): variant = + result.init() + if x.isNil: # nil.variant for missing optional parameters + result.raw.vt = VT_ERROR + result.raw.scode = DISP_E_PARAMNOTFOUND + else: + result = x.copy + +proc toVariant*(x: COMBinary): variant = + result.init() + result.raw.vt = VARTYPE(VT_ARRAY or VT_UI1) + result.raw.parray = SafeArrayCreateVector(VT_UI1, 0, ULONG len(string x)) + + block okay: + var pBuffer: pointer + if result.raw.parray == nil: break okay + if SafeArrayAccessData(result.raw.parray, &pBuffer) != S_OK: break okay + defer: SafeArrayUnaccessData(result.raw.parray) + + copyMem(pBuffer, &(string x), x.len) + return + + raise newException(VariantConversionError, vcErrorMsg("COMBinary", VARTYPE(VT_ARRAY or VT_UI1).typeDesc(1))) + +template toVariant1D(x: typed, vt: VARENUM) = + var sab: array[1, SAFEARRAYBOUND] + sab[0].cElements = x.len.ULONG + result.raw.parray = SafeArrayCreate(VARTYPE vt, 1, &sab[0]) + if result.raw.parray == nil: + raise newException(VariantConversionError, vcErrorMsg("openarray", VARTYPE(vt or VT_ARRAY).typeDesc(1))) + + for i in 0.. sab[1].cElements: sab[1].cElements = x[i].len.ULONG + + result.raw.parray = SafeArrayCreate(VARTYPE vt, 2, &sab[0]) + if result.raw.parray == nil: + raise newException(VariantConversionError, vcErrorMsg("openarray", VARTYPE(vt or VT_ARRAY).typeDesc(2))) + + for i in 0.. sab[1].cElements: sab[1].cElements = x[i].len.ULONG + for j in 0.. sab[2].cElements: sab[2].cElements = x[i][j].len.ULONG + + result.raw.parray = SafeArrayCreate(VARTYPE vt, 3, &sab[0]) + if result.raw.parray == nil: + raise newException(VariantConversionError, vcErrorMsg("openarray", VARTYPE(vt or VT_ARRAY).typeDesc(3))) + + for i in 0.. 999.0: + milliseconds = 0 + + if milliseconds != 0: + result.wMilliseconds = WORD milliseconds + else: + if VariantTimeToSystemTime(ret.date, &result) == FALSE: + raise newException(VariantConversionError, vcErrorMsg(x.raw.vt.typeDesc(dimensions), targetName)) + + elif T is FILETIME: + var st: SYSTEMTIME + if VariantTimeToSystemTime(ret.date, &st) == FALSE or SystemTimeToFileTime(&st, &result) == FALSE: + raise newException(VariantConversionError, vcErrorMsg(x.raw.vt.typeDesc(dimensions), targetName)) + + elif T is com: + result = newCom(ret.pdispVal) + + elif T is ptr IDispatch: + ret.pdispVal.AddRef() + result = ret.pdispVal + + elif T is ptr IUnknown: + ret.punkVal.AddRef() + result = ret.punkVal + + elif T is pointer: + result = ret.byref + + elif T is SomeInteger: result = cast[T](ret.llVal) + elif T is SomeFloat: result = T(ret.dblVal) + elif T is char: result = char(ret.bVal) + elif T is bool: result = if ret.boolVal != 0: true else: false + +proc `$`*(x: variant): string {.inline.} = fromVariant[string](x) +converter variantConverterToString*(x: variant): string = fromVariant[string](x) +converter variantConverterToCString*(x: variant): cstring = fromVariant[cstring](x) +converter variantConverterToMString*(x: variant): mstring = fromVariant[mstring](x) +converter variantConverterToWString*(x: variant): wstring = fromVariant[wstring](x) +converter variantConverterToChar*(x: variant): char = fromVariant[char](x) +converter variantConverterToBool*(x: variant): bool = fromVariant[bool](x) +converter variantConverterToCom*(x: variant): com = fromVariant[com](x) +converter variantConverterToIDispatch*(x: variant): ptr IDispatch = fromVariant[ptr IDispatch](x) +converter variantConverterToIUnknown*(x: variant): ptr IUnknown = fromVariant[ptr IUnknown](x) +converter variantConverterToPointer*(x: variant): pointer = fromVariant[pointer](x) +converter variantConverterToInt*(x: variant): int = fromVariant[int](x) +converter variantConverterToUInt*(x: variant): uint = fromVariant[uint](x) +converter variantConverterToInt8*(x: variant): int8 = fromVariant[int8](x) +converter variantConverterToUInt8*(x: variant): uint8 = fromVariant[uint8](x) +converter variantConverterToInt16*(x: variant): int16 = fromVariant[int16](x) +converter variantConverterToUInt16*(x: variant): uint16 = fromVariant[uint16](x) +converter variantConverterToInt32*(x: variant): int32 = fromVariant[int32](x) +converter variantConverterToUInt32*(x: variant): uint32 = fromVariant[uint32](x) +converter variantConverterToInt64*(x: variant): int64 = fromVariant[int64](x) +converter variantConverterToUInt64*(x: variant): uint64 = fromVariant[uint64](x) +converter variantConverterToFloat32*(x: variant): float32 = fromVariant[float32](x) +converter variantConverterToFloat64*(x: variant): float64 = fromVariant[float64](x) +converter variantConverterToFILETIME*(x: variant): FILETIME = fromVariant[FILETIME](x) +converter variantConverterToSYSTEMTIME*(x: variant): SYSTEMTIME = fromVariant[SYSTEMTIME](x) +converter variantConverterToVARIANT*(x: variant): VARIANT = fromVariant[VARIANT](x) +converter variantConverterToCOMArray1D*(x: variant): COMArray1D = fromVariant[COMArray1D](x) +converter variantConverterToCOMArray2D*(x: variant): COMArray2D = fromVariant[COMArray2D](x) +converter variantConverterToCOMArray3D*(x: variant): COMArray3D = fromVariant[COMArray3D](x) +converter variantConverterToCOMBinary*(x: variant): COMBinary = fromVariant[COMBinary](x) + +proc getEnumeration(self: com, name: string): variant = + var + tinfo: ptr ITypeInfo + tlib: ptr ITypeLib + index: UINT + kind: TYPEKIND + bname: BSTR + + if self.disp.GetTypeInfo(0, 0, &tinfo).ERR: return + defer: tinfo.Release() + + if tinfo.GetContainingTypeLib(&tlib, &index).ERR: return + defer: tlib.Release() + + for i in 0..= vargs.len: break + if args[i].vt == VT_EMPTY: + args[i] = vargs[index].raw + index.inc + + var + dp: DISPPARAMS + dispidNamed: DISPID = DISPID_PROPERTYPUT + ret: VARIANT + excep: EXCEPINFO + skipArgs = 0 + + if args.len != 0: + for i in 0..args.high: + if args[i].vt == VT_EMPTY: skipArgs.inc + else: break + + dp.rgvarg = &args[skipArgs] + dp.cArgs = DWORD(args.len - skipArgs) + + if isSet: + dp.rgdispidNamedArgs = &dispidNamed + dp.cNamedArgs = 1 + + if self.disp.Invoke(dispid, &IID_NULL, LOCALE_USER_DEFAULT, invokeType, &dp, &ret, &excep, nil).ERR: + {.gcsafe.}: + if cast[pointer](excep.pfnDeferredFillIn).notNil: + discard excep.pfnDeferredFillIn(&excep) + + if excep.bstrSource.notNil: + var err = $toVariant(excep.bstrSource) + if excep.bstrDescription.notNil: err &= ": " & $toVariant(excep.bstrDescription) + SysFreeString(excep.bstrSource) + SysFreeString(excep.bstrDescription) + SysFreeString(excep.bstrHelpFile) + raise newCOMException(err) + + raise newCOMError("invoke method failed: " & name) + + result = newVariant(ret) + discard VariantClear(&ret) + +proc call*(self: com, name: string, vargs: varargs[variant, toVariant], + kwargs: openarray[(string, variant)] = []): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_METHOD, vargs, kwargs=kwargs) + +proc call*(self: com, name: string, vargs: varargs[variant, toVariant]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_METHOD, vargs, kwargs=[]) + +proc set*(self: com, name: string, vargs: varargs[variant, toVariant], + kwargs: openarray[(string, variant)]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_PROPERTYPUT, vargs, kwargs=kwargs) + +proc set*(self: com, name: string, vargs: varargs[variant, toVariant]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_PROPERTYPUT, vargs, kwargs=[]) + +proc setRef*(self: com, name: string, vargs: varargs[variant, toVariant], + kwargs: openarray[(string, variant)]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_PROPERTYPUTREF, vargs, kwargs=kwargs) + +proc setRef*(self: com, name: string, vargs: varargs[variant, toVariant]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_PROPERTYPUTREF, vargs, kwargs=[]) + +proc get*(self: com, name: string, vargs: varargs[variant, toVariant], + kwargs: openarray[(string, variant)]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_METHOD or DISPATCH_PROPERTYGET, vargs, kwargs=kwargs) + +proc get*(self: com, name: string, vargs: varargs[variant, toVariant]): variant {.discardable, inline.} = + result = invoke(self, name, DISPATCH_METHOD or DISPATCH_PROPERTYGET, vargs, kwargs=[]) + +proc `[]`*(self: variant, name: string): variant = + var tinfo = self.getVariantTypeInfo() + if tinfo.notNil: + defer: tinfo.Release() + return tinfo.getValue(name) + + else: + return invoke(self, name, DISPATCH_METHOD or DISPATCH_PROPERTYGET) + +template `[]`*(self: com, name: string): variant = + discardable invoke(self, name, DISPATCH_METHOD or DISPATCH_PROPERTYGET) + +template `[]=`*(self: com, name: string, v: untyped) = + discardable invoke(self, name, DISPATCH_PROPERTYPUT, toVariant(v)) + +template `.`*(self: variant, name: untyped): variant = + discardable `[]`(self, astToStr(name)) + +iterator items*(x: com): variant = + var + ret, item: VARIANT + dp: DISPPARAMS + enumvar: ptr IEnumVARIANT + + if x.disp.Invoke(DISPID_NEWENUM, &IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD or DISPATCH_PROPERTYGET, &dp, &ret, nil, nil).ERR: + raise newCOMError("object is not iterable") + + if ret.punkVal.QueryInterface(&IID_IEnumVARIANT, &enumvar).ERR: + raise newCOMError("object is not iterable") + + while enumvar.Next(1, &item, nil) == 0: + yield newVariant(item) + discard VariantClear(&item) + + enumvar.Release() + ret.punkVal.Release() + +iterator items*(x: variant): variant = + if not x.isNil: + var tinfo = x.getVariantTypeInfo() + if tinfo.notNil: + defer: tinfo.Release() + for tup in tinfo.items(keyOnly=true): + yield toVariant(tup.key) + + else: + var obj = x.com + for v in obj: + yield v + +proc standardizeKwargs(n: var NimNode) = + # if last argument is table constructor, name it as kwargs + if n[^1].kind == nnkTableConstr: + n[^1] = newTree(nnkExprEqExpr, ident("kwargs"), n[^1]) + + # if last argument is already named kwargs, just do nothing + elif n[^1].kind == nnkExprEqExpr and n[^1][0].eqIdent("kwargs") and + n[^1][1].kind == nnkTableConstr: + return + + # otherwise, add empty array as kwargs + else: + n.add newTree(nnkExprEqExpr, ident("kwargs"), newNimNode(nnkBracket)) + +macro `.`*(self: com, name: untyped, vargs: varargs[untyped]): untyped = + result = newCall("get", self, newStrLitNode($name)) + for i in vargs: result.add i + result.standardizeKwargs() + +macro `.=`*(self: com, name: untyped, vargs: varargs[untyped]): untyped = + result = newCall("set", self, newStrLitNode($name)) + for i in vargs: result.add i + result.standardizeKwargs() + +proc GetCLSID(progId: string, clsid: var GUID): HRESULT = + if progId[0] == '{': + result = CLSIDFromString(progId, &clsid) + else: + result = CLSIDFromProgID(progId, &clsid) + +proc CreateObject*(progId: string): com = + ## Creates a reference to a COM object. + + result.init() + var + clsid: GUID + pCf: ptr IClassFactory + + if GetCLSID(progId, clsid).OK: + # better than CoCreateInstance: + # some IClassFactory.CreateInstance return SUCCEEDED with nil pointer, this crash CoCreateInstance + # for example: {D5F7E36B-5B38-445D-A50F-439B8FCBB87A} + if CoGetClassObject(&clsid, CLSCTX_LOCAL_SERVER or CLSCTX_INPROC_SERVER, nil, &IID_IClassFactory, &pCf).OK: + defer: pCf.Release() + + if pCf.CreateInstance(nil, &IID_IDispatch, &(result.disp)).OK and result.disp.notNil: + return result + + raise newCOMError("unable to create object from " & progId) + +proc GetObject*(file: string, progId: string = ""): com = + ## Retrieves a reference to a COM object from an existing process or filename. + + result.init() + var + clsid: GUID + pUk: ptr IUnknown + pPf: ptr IPersistFile + + if progId.len != 0: + if GetCLSID(progId, clsid).OK: + if file.len != 0: + if CoCreateInstance(&clsid, nil, CLSCTX_LOCAL_SERVER or CLSCTX_INPROC_SERVER, &IID_IPersistFile, &pPf).OK: + defer: pPf.Release() + + if pPf.Load(file, 0).OK and pPf.QueryInterface(&IID_IDispatch, &(result.disp)).OK: + return result + else: + if GetActiveObject(&clsid, nil, &pUk).OK: + defer: pUk.Release() + + if pUk.QueryInterface(&IID_IDispatch, &(result.disp)).OK: + return result + + elif file.len != 0: + if CoGetObject(file, nil, &IID_IDispatch, &(result.disp)).OK: + return result + + raise newCOMError("unable to get object") + +proc newCom*(progId: string): com {.inline.} = + result = CreateObject(progId) + +proc newCom*(file, progId: string): com {.inline.} = + result = GetObject(file, progId) + +type + comEventHandler* = proc(self: com, name: string, params: varargs[variant]): variant + SinkObj {.pure.} = object + lpVtbl: ptr IDispatchVtbl + typeInfo: ptr ITypeInfo + iid: GUID + refCount: ULONG + handler: comEventHandler + parent: com + Sink {.pure.} = ptr SinkObj + +proc Sink_QueryInterface(self: ptr IUnknown, riid: ptr IID, pvObject: ptr pointer): HRESULT {.stdcall.} = + var this = cast[Sink](self) + if IsEqualGUID(riid, &IID_IUnknown) or IsEqualGUID(riid, &IID_IDispatch) or IsEqualGUID(riid, &this.iid): + pvObject[] = self + self.AddRef() + result = S_OK + else: + pvObject[] = nil + result = E_NOINTERFACE + +proc Sink_AddRef(self: ptr IUnknown): ULONG {.stdcall.} = + var this = cast[Sink](self) + this.refCount.inc + result = this.refCount + +proc Sink_Release(self: ptr IUnknown): ULONG {.stdcall.} = + var this = cast[Sink](self) + this.refCount.dec + if this.refCount == 0: + this.typeInfo.Release() + free(self) + result = 0 + else: + result = this.refCount + +proc Sink_GetTypeInfoCount(self: ptr IDispatch, pctinfo: ptr UINT): HRESULT {.stdcall.} = + pctinfo[] = 1 + result = S_OK + +proc Sink_GetTypeInfo(self: ptr IDispatch, iTInfo: UINT, lcid: LCID, ppTInfo: ptr LPTYPEINFO): HRESULT {.stdcall.} = + var this = cast[Sink](self) + ppTInfo[] = this.typeInfo + this.typeInfo.AddRef() + result = S_OK + +proc Sink_GetIDsOfNames(self: ptr IDispatch, riid: REFIID, rgszNames: ptr LPOLESTR, cNames: UINT, lcid: LCID, rgDispId: ptr DISPID): HRESULT {.stdcall.} = + var this = cast[Sink](self) + result = DispGetIDsOfNames(this.typeInfo, rgszNames, cNames, rgDispId) + +proc Sink_Invoke(self: ptr IDispatch, dispid: DISPID, riid: REFIID, lcid: LCID, wFlags: WORD, params: ptr DISPPARAMS, ret: ptr VARIANT, pExcepInfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.stdcall, thread.} = + var this = cast[Sink](self) + var + bname: BSTR + nameCount: UINT + vret: variant + name: string + args = cast[ptr UncheckedArray[VARIANT]](params.rgvarg) + sargs = newSeq[variant]() + total = params.cArgs + params.cNamedArgs + + result = this.typeInfo.GetNames(dispid, &bname, 1, &nameCount) + + if result == S_OK: + name = $bname + SysFreeString(bname) + + for i in 1..total: + sargs.add(newVariant(args[total-i])) + + try: + {.gcsafe.}: vret = this.handler(this.parent, name, sargs) + + except CatchableError: + let e = getCurrentException() + echo "uncatched exception inside event hander: " & $e.name & " (" & $e.msg & ")" + + finally: + if vret.notNil and ret.notNil: + result = VariantCopy(ret, &vret.raw) + else: + result = S_OK + +let + SinkVtbl: IDispatchVtbl = IDispatchVtbl( + QueryInterface: Sink_QueryInterface, + AddRef: Sink_AddRef, + Release: Sink_Release, + GetTypeInfoCount: Sink_GetTypeInfoCount, + GetTypeInfo: Sink_GetTypeInfo, + GetIDsOfNames: Sink_GetIDsOfNames, + Invoke: Sink_Invoke + ) + +proc newSink(parent: com, iid: GUID, typeInfo: ptr ITypeInfo, handler: comEventHandler): Sink = + result = cast[Sink.type](alloc0(sizeof(SinkObj))) + result.lpVtbl = SinkVtbl.unsafeaddr + result.parent = parent + result.iid = iid + result.typeInfo = typeInfo + typeInfo.AddRef() + result.handler = handler + +proc connectRaw(self: com, riid: REFIID = nil, cookie: DWORD, handler: comEventHandler = nil): DWORD = + var + iid: IID + count, index: UINT + typeInfo, dispTypeInfo: ptr ITypeInfo + connection: ptr IConnectionPoint + typeLib: ptr ITypeLib + container: ptr IConnectionPointContainer + enu: ptr IEnumConnectionPoints + sink: Sink + + defer: + if typeInfo.notNil: typeInfo.Release() + if dispTypeInfo.notNil: dispTypeInfo.Release() + if connection.notNil: connection.Release() + if typeLib.notNil: typeLib.Release() + if container.notNil: container.Release() + if enu.notNil: enu.Release() + + block okay: + if self.disp.GetTypeInfoCount(&count).ERR or count != 1: break okay + if self.disp.GetTypeInfo(0, 0, &dispTypeInfo).ERR: break okay + if dispTypeInfo.GetContainingTypeLib(&typeLib, &index).ERR: break okay + if self.disp.QueryInterface(&IID_IConnectionPointContainer, &container).ERR: break okay + + if riid.isNil: + if container.EnumConnectionPoints(&enu).ERR: break okay + enu.Reset() + while enu.Next(1, &connection, nil) != S_FALSE: + if connection.GetConnectionInterface(&iid).OK and + typeLib.GetTypeInfoOfGuid(&iid, &typeInfo).OK: + break + + connection.Release() + connection = nil + + else: + if container.FindConnectionPoint(riid, &connection).ERR: break okay + if connection.GetConnectionInterface(&iid).ERR: break okay + if typeLib.GetTypeInfoOfGuid(riid, &typeInfo).ERR: break okay + + if handler.notNil: + sink = newSink(self, iid, typeInfo, handler) + if connection.Advise(cast[ptr IUnknown](sink), &result).OK: return result + + elif cookie != 0: + if connection.Unadvise(cookie).OK: return 1 + + raise newCOMError("unable to connect/disconnect event") + +proc connect*(self: com, handler: comEventHandler, riid: REFIID = nil): DWORD {.discardable.} = + ## Connect a COM object to a comEventHandler. Return a cookie to disconnect (if needed). + ## Handler is a user defined proc to receive the COM event. + ## comEventHandler is defined as: + ## + ## .. code-block:: Nim + ## type comEventHandler = proc(self: com, name: string, params: varargs[variant]): variant + + if handler.notNil: + result = connectRaw(self, riid, 0, handler) + +proc disconnect*(self: com, cookie: DWORD, riid: REFIID = nil): bool {.discardable.} = + ## Disconnect a COM object from a comEventHandler. + + if cookie != 0 and connectRaw(self, riid, cookie, nil) != 0: + result = true + +proc reformatAsgn(n: NimNode): NimNode = + # reformat code: + # a.b(c, ...) = d -> a.b.set("c", ..., d) + expectKind(n, nnkAsgn) + + var + params = n[0] + dots = n[0][0] + + params.insert(1, dots.last.toStrLit) + params.add(n.last) + dots.del(dots.len-1) + dots.add(newIdentNode("set")) + result = n[0] + +proc reformatCall(n: NimNode): NimNode = + # reformat code: + # a(b, c:=d, e:=f, g, h) -> a(b, g, h, kwargs={"c": toVariant(d), "e": toVariant(f)}) + expectKind(n, nnkCall) + + result = newNimNode(nnkCall) + var table = newNimNode(nnkTableConstr) + + for i in 0.. ", dict.item(key) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/core.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/core.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,14 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows Core Headers +# +#==================================================================== + +import inc/[windef, winerror, winbase, wingdi, winuser, wincon, winnls, + winver, winreg, winnetwk, winsvc, virtdisk, winsock, wincrypt] + +export windef, winerror, winbase, wingdi, winuser, wincon, winnls, + winver, winreg, winnetwk, winsvc, virtdisk, winsock, wincrypt diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/extra.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/extra.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,16 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows Extra Headers +# +#==================================================================== + +import inc/[psapi, tlhelp32, wintrust, imagehlp, odbc, dde, lzexpand, nb30, + winperf, mmsystem, winefs, winioctl, winscard, winspool, mcx, powrprof, vfw, + usp10, subauth, snmp, aclapi, dhcpcsdk, wincodec, gdiplus] + +export psapi, tlhelp32, wintrust, imagehlp, odbc, dde, lzexpand, nb30, + winperf, mmsystem, winefs, winioctl, winscard, winspool, mcx, powrprof, vfw, + usp10, subauth, snmp, aclapi, dhcpcsdk, wincodec, gdiplus diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/aclapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/aclapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1008 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winuser +import objbase +import commctrl +#include +#include +#include +#include +#include +type + SE_OBJECT_TYPE* = int32 + TRUSTEE_TYPE* = int32 + TRUSTEE_FORM* = int32 + MULTIPLE_TRUSTEE_OPERATION* = int32 + ACCESS_MODE* = int32 + PROG_INVOKE_SETTING* = int32 + PPROG_INVOKE_SETTING* = ptr int32 + AUDIT_PARAM_TYPE* = int32 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION* = int32 + PAUTHZ_SECURITY_ATTRIBUTE_OPERATION* = ptr int32 + AUTHZ_SID_OPERATION* = int32 + PAUTHZ_SID_OPERATION* = ptr int32 + AUTHZ_CONTEXT_INFORMATION_CLASS* = int32 + AUTHZ_AUDIT_EVENT_INFORMATION_CLASS* = int32 + SI_PAGE_TYPE* = int32 + SI_PAGE_ACTIVATED* = int32 + ACCESS_RIGHTS* = ULONG + PACCESS_RIGHTS* = ptr ULONG + INHERIT_FLAGS* = ULONG + PINHERIT_FLAGS* = ptr ULONG + AUDIT_HANDLE* = PVOID + PAUDIT_HANDLE* = ptr PVOID + AUTHZ_ACCESS_CHECK_RESULTS_HANDLE* = HANDLE + AUTHZ_CLIENT_CONTEXT_HANDLE* = HANDLE + AUTHZ_RESOURCE_MANAGER_HANDLE* = HANDLE + AUTHZ_AUDIT_EVENT_HANDLE* = HANDLE + AUTHZ_AUDIT_EVENT_TYPE_HANDLE* = HANDLE + AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE* = HANDLE + AUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE* = HANDLE + OBJECTS_AND_SID* {.pure.} = object + ObjectsPresent*: DWORD + ObjectTypeGuid*: GUID + InheritedObjectTypeGuid*: GUID + pSid*: ptr SID + POBJECTS_AND_SID* = ptr OBJECTS_AND_SID + OBJECTS_AND_NAME_A* {.pure.} = object + ObjectsPresent*: DWORD + ObjectType*: SE_OBJECT_TYPE + ObjectTypeName*: LPSTR + InheritedObjectTypeName*: LPSTR + ptstrName*: LPSTR + POBJECTS_AND_NAME_A* = ptr OBJECTS_AND_NAME_A + OBJECTS_AND_NAME_W* {.pure.} = object + ObjectsPresent*: DWORD + ObjectType*: SE_OBJECT_TYPE + ObjectTypeName*: LPWSTR + InheritedObjectTypeName*: LPWSTR + ptstrName*: LPWSTR + POBJECTS_AND_NAME_W* = ptr OBJECTS_AND_NAME_W + TRUSTEE_A* {.pure.} = object + pMultipleTrustee*: ptr TRUSTEE_A + MultipleTrusteeOperation*: MULTIPLE_TRUSTEE_OPERATION + TrusteeForm*: TRUSTEE_FORM + TrusteeType*: TRUSTEE_TYPE + ptstrName*: LPSTR + PTRUSTEE_A* = ptr TRUSTEE_A + TRUSTEE_W* {.pure.} = object + pMultipleTrustee*: ptr TRUSTEE_W + MultipleTrusteeOperation*: MULTIPLE_TRUSTEE_OPERATION + TrusteeForm*: TRUSTEE_FORM + TrusteeType*: TRUSTEE_TYPE + ptstrName*: LPWSTR + PTRUSTEE_W* = ptr TRUSTEE_W + EXPLICIT_ACCESS_A* {.pure.} = object + grfAccessPermissions*: DWORD + grfAccessMode*: ACCESS_MODE + grfInheritance*: DWORD + Trustee*: TRUSTEE_A + PEXPLICIT_ACCESS_A* = ptr EXPLICIT_ACCESS_A + EXPLICIT_ACCESS_W* {.pure.} = object + grfAccessPermissions*: DWORD + grfAccessMode*: ACCESS_MODE + grfInheritance*: DWORD + Trustee*: TRUSTEE_W + PEXPLICIT_ACCESS_W* = ptr EXPLICIT_ACCESS_W + ACTRL_ACCESS_ENTRYA* {.pure.} = object + Trustee*: TRUSTEE_A + fAccessFlags*: ULONG + Access*: ACCESS_RIGHTS + ProvSpecificAccess*: ACCESS_RIGHTS + Inheritance*: INHERIT_FLAGS + lpInheritProperty*: LPSTR + PACTRL_ACCESS_ENTRYA* = ptr ACTRL_ACCESS_ENTRYA + ACTRL_ACCESS_ENTRYW* {.pure.} = object + Trustee*: TRUSTEE_W + fAccessFlags*: ULONG + Access*: ACCESS_RIGHTS + ProvSpecificAccess*: ACCESS_RIGHTS + Inheritance*: INHERIT_FLAGS + lpInheritProperty*: LPWSTR + PACTRL_ACCESS_ENTRYW* = ptr ACTRL_ACCESS_ENTRYW + ACTRL_ACCESS_ENTRY_LISTA* {.pure.} = object + cEntries*: ULONG + pAccessList*: ptr ACTRL_ACCESS_ENTRYA + PACTRL_ACCESS_ENTRY_LISTA* = ptr ACTRL_ACCESS_ENTRY_LISTA + ACTRL_ACCESS_ENTRY_LISTW* {.pure.} = object + cEntries*: ULONG + pAccessList*: ptr ACTRL_ACCESS_ENTRYW + PACTRL_ACCESS_ENTRY_LISTW* = ptr ACTRL_ACCESS_ENTRY_LISTW + ACTRL_PROPERTY_ENTRYA* {.pure.} = object + lpProperty*: LPSTR + pAccessEntryList*: PACTRL_ACCESS_ENTRY_LISTA + fListFlags*: ULONG + PACTRL_PROPERTY_ENTRYA* = ptr ACTRL_PROPERTY_ENTRYA + ACTRL_PROPERTY_ENTRYW* {.pure.} = object + lpProperty*: LPWSTR + pAccessEntryList*: PACTRL_ACCESS_ENTRY_LISTW + fListFlags*: ULONG + PACTRL_PROPERTY_ENTRYW* = ptr ACTRL_PROPERTY_ENTRYW + ACTRL_ACCESSA* {.pure.} = object + cEntries*: ULONG + pPropertyAccessList*: PACTRL_PROPERTY_ENTRYA + PACTRL_ACCESSA* = ptr ACTRL_ACCESSA + ACTRL_AUDITA* = ACTRL_ACCESSA + PACTRL_AUDITA* = ptr ACTRL_ACCESSA + ACTRL_ACCESSW* {.pure.} = object + cEntries*: ULONG + pPropertyAccessList*: PACTRL_PROPERTY_ENTRYW + PACTRL_ACCESSW* = ptr ACTRL_ACCESSW + ACTRL_AUDITW* = ACTRL_ACCESSW + PACTRL_AUDITW* = ptr ACTRL_ACCESSW + TRUSTEE_ACCESSA* {.pure.} = object + lpProperty*: LPSTR + Access*: ACCESS_RIGHTS + fAccessFlags*: ULONG + fReturnedAccess*: ULONG + PTRUSTEE_ACCESSA* = ptr TRUSTEE_ACCESSA + TRUSTEE_ACCESSW* {.pure.} = object + lpProperty*: LPWSTR + Access*: ACCESS_RIGHTS + fAccessFlags*: ULONG + fReturnedAccess*: ULONG + PTRUSTEE_ACCESSW* = ptr TRUSTEE_ACCESSW + ACTRL_OVERLAPPED_UNION1* {.pure, union.} = object + Provider*: PVOID + Reserved1*: ULONG + ACTRL_OVERLAPPED* {.pure.} = object + union1*: ACTRL_OVERLAPPED_UNION1 + Reserved2*: ULONG + hEvent*: HANDLE + PACTRL_OVERLAPPED* = ptr ACTRL_OVERLAPPED + ACTRL_ACCESS_INFOA* {.pure.} = object + fAccessPermission*: ULONG + lpAccessPermissionName*: LPSTR + PACTRL_ACCESS_INFOA* = ptr ACTRL_ACCESS_INFOA + ACTRL_ACCESS_INFOW* {.pure.} = object + fAccessPermission*: ULONG + lpAccessPermissionName*: LPWSTR + PACTRL_ACCESS_INFOW* = ptr ACTRL_ACCESS_INFOW + ACTRL_CONTROL_INFOA* {.pure.} = object + lpControlId*: LPSTR + lpControlName*: LPSTR + PACTRL_CONTROL_INFOA* = ptr ACTRL_CONTROL_INFOA + ACTRL_CONTROL_INFOW* {.pure.} = object + lpControlId*: LPWSTR + lpControlName*: LPWSTR + PACTRL_CONTROL_INFOW* = ptr ACTRL_CONTROL_INFOW + FN_OBJECT_MGR_FUNCTS* {.pure.} = object + Placeholder*: ULONG + PFN_OBJECT_MGR_FUNCTS* = ptr FN_OBJECT_MGR_FUNCTS + INHERITED_FROMA* {.pure.} = object + GenerationGap*: LONG + AncestorName*: LPSTR + PINHERITED_FROMA* = ptr INHERITED_FROMA + INHERITED_FROMW* {.pure.} = object + GenerationGap*: LONG + AncestorName*: LPWSTR + PINHERITED_FROMW* = ptr INHERITED_FROMW + AUDIT_OBJECT_TYPE* {.pure.} = object + ObjectType*: GUID + Flags*: USHORT + Level*: USHORT + AccessMask*: ACCESS_MASK + PAUDIT_OBJECT_TYPE* = ptr AUDIT_OBJECT_TYPE + AUDIT_OBJECT_TYPES* {.pure.} = object + Count*: USHORT + Flags*: USHORT + pObjectTypes*: ptr AUDIT_OBJECT_TYPE + PAUDIT_OBJECT_TYPES* = ptr AUDIT_OBJECT_TYPES +const + AUTHZ_SS_MAXSIZE* = 128 +type + AUDIT_IP_ADDRESS* {.pure.} = object + pIpAddress*: array[AUTHZ_SS_MAXSIZE, BYTE] + PAUDIT_IP_ADDRESS* = ptr AUDIT_IP_ADDRESS + AUDIT_PARAM_UNION1* {.pure, union.} = object + Data0*: ULONG_PTR + Str*: PWSTR + u*: ULONG_PTR + psid*: ptr SID + pguid*: ptr GUID + LogonId_LowPart*: ULONG + pObjectTypes*: ptr AUDIT_OBJECT_TYPES + pIpAddress*: ptr AUDIT_IP_ADDRESS + AUDIT_PARAM_UNION2* {.pure, union.} = object + Data1*: ULONG_PTR + LogonId_HighPart*: LONG + AUDIT_PARAM* {.pure.} = object + Type*: AUDIT_PARAM_TYPE + Length*: ULONG + Flags*: DWORD + union1*: AUDIT_PARAM_UNION1 + union2*: AUDIT_PARAM_UNION2 + PAUDIT_PARAM* = ptr AUDIT_PARAM + AUDIT_PARAMS* {.pure.} = object + Length*: ULONG + Flags*: DWORD + Count*: USHORT + Parameters*: ptr AUDIT_PARAM + PAUDIT_PARAMS* = ptr AUDIT_PARAMS + AUTHZ_AUDIT_EVENT_TYPE_LEGACY* {.pure.} = object + CategoryId*: USHORT + AuditId*: USHORT + ParameterCount*: USHORT + PAUTHZ_AUDIT_EVENT_TYPE_LEGACY* = ptr AUTHZ_AUDIT_EVENT_TYPE_LEGACY + AUTHZ_AUDIT_EVENT_TYPE_UNION* {.pure, union.} = object + Legacy*: AUTHZ_AUDIT_EVENT_TYPE_LEGACY + PAUTHZ_AUDIT_EVENT_TYPE_UNION* = ptr AUTHZ_AUDIT_EVENT_TYPE_UNION + AUTHZ_AUDIT_EVENT_TYPE_OLD* {.pure.} = object + Version*: ULONG + dwFlags*: DWORD + RefCount*: LONG + hAudit*: ULONG_PTR + LinkId*: LUID + u*: AUTHZ_AUDIT_EVENT_TYPE_UNION + PAUTHZ_AUDIT_EVENT_TYPE_OLD* = ptr AUTHZ_AUDIT_EVENT_TYPE_OLD + PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE* = ptr AUTHZ_ACCESS_CHECK_RESULTS_HANDLE + PAUTHZ_CLIENT_CONTEXT_HANDLE* = ptr AUTHZ_CLIENT_CONTEXT_HANDLE + PAUTHZ_RESOURCE_MANAGER_HANDLE* = ptr AUTHZ_RESOURCE_MANAGER_HANDLE + PAUTHZ_AUDIT_EVENT_HANDLE* = ptr AUTHZ_AUDIT_EVENT_HANDLE + PAUTHZ_AUDIT_EVENT_TYPE_HANDLE* = ptr AUTHZ_AUDIT_EVENT_TYPE_HANDLE + PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE* = ptr AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE + PAUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE* = ptr AUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE + AUTHZ_ACCESS_REQUEST* {.pure.} = object + DesiredAccess*: ACCESS_MASK + PrincipalSelfSid*: PSID + ObjectTypeList*: POBJECT_TYPE_LIST + ObjectTypeListLength*: DWORD + OptionalArguments*: PVOID + PAUTHZ_ACCESS_REQUEST* = ptr AUTHZ_ACCESS_REQUEST + AUTHZ_ACCESS_REPLY* {.pure.} = object + ResultListLength*: DWORD + GrantedAccessMask*: PACCESS_MASK + SaclEvaluationResults*: PDWORD + Error*: PDWORD + PAUTHZ_ACCESS_REPLY* = ptr AUTHZ_ACCESS_REPLY + AUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE* {.pure.} = object + Version*: ULONG64 + pName*: PWSTR + PAUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE* = ptr AUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE + AUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE* {.pure.} = object + pValue*: PVOID + ValueLength*: ULONG + PAUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE* = ptr AUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + AUTHZ_SECURITY_ATTRIBUTE_V1_Values* {.pure, union.} = object + pInt64*: PLONG64 + pUint64*: PULONG64 + ppString*: ptr PWSTR + pFqbn*: PAUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE + pOctetString*: PAUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + AUTHZ_SECURITY_ATTRIBUTE_V1* {.pure.} = object + pName*: PWSTR + ValueType*: USHORT + Reserved*: USHORT + Flags*: ULONG + ValueCount*: ULONG + Values*: AUTHZ_SECURITY_ATTRIBUTE_V1_Values + PAUTHZ_SECURITY_ATTRIBUTE_V1* = ptr AUTHZ_SECURITY_ATTRIBUTE_V1 + AUTHZ_SECURITY_ATTRIBUTES_INFORMATION_Attribute* {.pure, union.} = object + pAttributeV1*: PAUTHZ_SECURITY_ATTRIBUTE_V1 + AUTHZ_SECURITY_ATTRIBUTES_INFORMATION* {.pure.} = object + Version*: USHORT + Reserved*: USHORT + AttributeCount*: ULONG + Attribute*: AUTHZ_SECURITY_ATTRIBUTES_INFORMATION_Attribute + PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION* = ptr AUTHZ_SECURITY_ATTRIBUTES_INFORMATION + AUTHZ_RPC_INIT_INFO_CLIENT* {.pure.} = object + version*: USHORT + ObjectUuid*: PWSTR + ProtSeq*: PWSTR + NetworkAddr*: PWSTR + Endpoint*: PWSTR + Options*: PWSTR + ServerSpn*: PWSTR + PAUTHZ_RPC_INIT_INFO_CLIENT* = ptr AUTHZ_RPC_INIT_INFO_CLIENT + PFN_AUTHZ_DYNAMIC_ACCESS_CHECK* = proc (hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pAce: PACE_HEADER, pArgs: PVOID, pbAceApplicable: PBOOL): WINBOOL {.stdcall.} + PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS* = proc (hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, Args: PVOID, pSidAttrArray: ptr PSID_AND_ATTRIBUTES, pSidCount: PDWORD, pRestrictedSidAttrArray: ptr PSID_AND_ATTRIBUTES, pRestrictedSidCount: PDWORD): WINBOOL {.stdcall.} + PFN_AUTHZ_FREE_DYNAMIC_GROUPS* = proc (pSidAttrArray: PSID_AND_ATTRIBUTES): VOID {.stdcall.} + PFN_AUTHZ_GET_CENTRAL_ACCESS_POLICY* = proc (hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, capid: PSID, pArgs: PVOID, pCentralAccessPolicyApplicable: PBOOL, ppCentralAccessPolicy: ptr PVOID): WINBOOL {.stdcall.} + PFN_AUTHZ_FREE_CENTRAL_ACCESS_POLICY* = proc (pCentralAccessPolicy: PVOID): VOID {.stdcall.} + AUTHZ_INIT_INFO* {.pure.} = object + version*: USHORT + szResourceManagerName*: PCWSTR + pfnDynamicAccessCheck*: PFN_AUTHZ_DYNAMIC_ACCESS_CHECK + pfnComputeDynamicGroups*: PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS + pfnFreeDynamicGroups*: PFN_AUTHZ_FREE_DYNAMIC_GROUPS + pfnGetCentralAccessPolicy*: PFN_AUTHZ_GET_CENTRAL_ACCESS_POLICY + pfnFreeCentralAccessPolicy*: PFN_AUTHZ_FREE_CENTRAL_ACCESS_POLICY + PAUTHZ_INIT_INFO* = ptr AUTHZ_INIT_INFO + AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET* {.pure.} = object + szObjectTypeName*: PWSTR + dwOffset*: DWORD + PAUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET* = ptr AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET + AUTHZ_SOURCE_SCHEMA_REGISTRATION_UNION1* {.pure, union.} = object + pReserved*: PVOID + pProviderGuid*: ptr GUID + AUTHZ_SOURCE_SCHEMA_REGISTRATION* {.pure.} = object + dwFlags*: DWORD + szEventSourceName*: PWSTR + szEventMessageFile*: PWSTR + szEventSourceXmlSchemaFile*: PWSTR + szEventAccessStringsFile*: PWSTR + szExecutableImagePath*: PWSTR + union1*: AUTHZ_SOURCE_SCHEMA_REGISTRATION_UNION1 + dwObjectTypeNameCount*: DWORD + ObjectTypeNames*: array[ANYSIZE_ARRAY, AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET] + PAUTHZ_SOURCE_SCHEMA_REGISTRATION* = ptr AUTHZ_SOURCE_SCHEMA_REGISTRATION + SI_OBJECT_INFO* {.pure.} = object + dwFlags*: DWORD + hInstance*: HINSTANCE + pszServerName*: LPWSTR + pszObjectName*: LPWSTR + pszPageTitle*: LPWSTR + guidObjectType*: GUID + PSI_OBJECT_INFO* = ptr SI_OBJECT_INFO + SI_ACCESS* {.pure.} = object + pguid*: ptr GUID + mask*: ACCESS_MASK + pszName*: LPCWSTR + dwFlags*: DWORD + PSI_ACCESS* = ptr SI_ACCESS + SI_INHERIT_TYPE* {.pure.} = object + pguid*: ptr GUID + dwFlags*: ULONG + pszName*: LPCWSTR + PSI_INHERIT_TYPE* = ptr SI_INHERIT_TYPE + ISecurityInformation* {.pure.} = object + lpVtbl*: ptr ISecurityInformationVtbl + ISecurityInformationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetObjectInformation*: proc(self: ptr ISecurityInformation, pObjectInfo: PSI_OBJECT_INFO): HRESULT {.stdcall.} + GetSecurity*: proc(self: ptr ISecurityInformation, RequestedInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, fDefault: WINBOOL): HRESULT {.stdcall.} + SetSecurity*: proc(self: ptr ISecurityInformation, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): HRESULT {.stdcall.} + GetAccessRights*: proc(self: ptr ISecurityInformation, pguidObjectType: ptr GUID, dwFlags: DWORD, ppAccess: ptr PSI_ACCESS, pcAccesses: ptr ULONG, piDefaultAccess: ptr ULONG): HRESULT {.stdcall.} + MapGeneric*: proc(self: ptr ISecurityInformation, pguidObjectType: ptr GUID, pAceFlags: ptr UCHAR, pMask: ptr ACCESS_MASK): HRESULT {.stdcall.} + GetInheritTypes*: proc(self: ptr ISecurityInformation, ppInheritTypes: ptr PSI_INHERIT_TYPE, pcInheritTypes: ptr ULONG): HRESULT {.stdcall.} + PropertySheetPageCallback*: proc(self: ptr ISecurityInformation, hwnd: HWND, uMsg: UINT, uPage: SI_PAGE_TYPE): HRESULT {.stdcall.} + LPSECURITYINFO* = ptr ISecurityInformation + ISecurityInformation2* {.pure.} = object + lpVtbl*: ptr ISecurityInformation2Vtbl + ISecurityInformation2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsDaclCanonical*: proc(self: ptr ISecurityInformation2, pDacl: PACL): WINBOOL {.stdcall.} + LookupSids*: proc(self: ptr ISecurityInformation2, cSids: ULONG, rgpSids: ptr PSID, ppdo: ptr LPDATAOBJECT): HRESULT {.stdcall.} + LPSECURITYINFO2* = ptr ISecurityInformation2 + SID_INFO* {.pure.} = object + pSid*: PSID + pwzCommonName*: PWSTR + pwzClass*: PWSTR + pwzUPN*: PWSTR + PSID_INFO* = ptr SID_INFO + SID_INFO_LIST* {.pure.} = object + cItems*: ULONG + aSidInfo*: array[ANYSIZE_ARRAY, SID_INFO] + PSID_INFO_LIST* = ptr SID_INFO_LIST + IEffectivePermission* {.pure.} = object + lpVtbl*: ptr IEffectivePermissionVtbl + IEffectivePermissionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetEffectivePermission*: proc(self: ptr IEffectivePermission, pguidObjectType: ptr GUID, pUserSid: PSID, pszServerName: LPCWSTR, pSD: PSECURITY_DESCRIPTOR, ppObjectTypeList: ptr POBJECT_TYPE_LIST, pcObjectTypeListLength: ptr ULONG, ppGrantedAccessList: ptr PACCESS_MASK, pcGrantedAccessListLength: ptr ULONG): HRESULT {.stdcall.} + LPEFFECTIVEPERMISSION* = ptr IEffectivePermission +when winimUnicode: + type + PINHERITED_FROM* = PINHERITED_FROMW +when winimAnsi: + type + PINHERITED_FROM* = PINHERITED_FROMA +type + ISecurityObjectTypeInfo* {.pure.} = object + lpVtbl*: ptr ISecurityObjectTypeInfoVtbl + ISecurityObjectTypeInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetInheritSource*: proc(self: ptr ISecurityObjectTypeInfo, si: SECURITY_INFORMATION, pACL: PACL, ppInheritArray: ptr PINHERITED_FROM): HRESULT {.stdcall.} + LPSecurityObjectTypeInfo* = ptr ISecurityObjectTypeInfo + ISecurityInformation3* {.pure.} = object + lpVtbl*: ptr ISecurityInformation3Vtbl + ISecurityInformation3Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFullResourceName*: proc(self: ptr ISecurityInformation3, ppszResourceName: ptr LPWSTR): HRESULT {.stdcall.} + OpenElevatedEditor*: proc(self: ptr ISecurityInformation3, hWnd: HWND, uPage: SI_PAGE_TYPE): HRESULT {.stdcall.} + LPSECURITYINFO3* = ptr ISecurityInformation3 + SECURITY_OBJECT* {.pure.} = object + pwszName*: PWSTR + pData*: PVOID + cbData*: DWORD + pData2*: PVOID + cbData2*: DWORD + Id*: DWORD + fWellKnown*: BOOLEAN + PSECURITY_OBJECT* = ptr SECURITY_OBJECT + EFFPERM_RESULT_LIST* {.pure.} = object + fEvaluated*: BOOLEAN + cObjectTypeListLength*: ULONG + pObjectTypeList*: ptr OBJECT_TYPE_LIST + pGrantedAccessList*: ptr ACCESS_MASK + PEFFPERM_RESULT_LIST* = ptr EFFPERM_RESULT_LIST + ISecurityInformation4* {.pure.} = object + lpVtbl*: ptr ISecurityInformation4Vtbl + ISecurityInformation4Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSecondarySecurity*: proc(self: ptr ISecurityInformation4, pSecurityObjects: ptr PSECURITY_OBJECT, pSecurityObjectCount: PULONG): HRESULT {.stdcall.} + LPSECURITYINFO4* = ptr ISecurityInformation4 + IEffectivePermission2* {.pure.} = object + lpVtbl*: ptr IEffectivePermission2Vtbl + IEffectivePermission2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ComputeEffectivePermissionWithSecondarySecurity*: proc(self: ptr IEffectivePermission2, pSid: PSID, pDeviceSid: PSID, pszServerName: PCWSTR, pSecurityObjects: PSECURITY_OBJECT, dwSecurityObjectCount: DWORD, pUserGroups: PTOKEN_GROUPS, pAuthzUserGroupsOperations: PAUTHZ_SID_OPERATION, pDeviceGroups: PTOKEN_GROUPS, pAuthzDeviceGroupsOperations: PAUTHZ_SID_OPERATION, pAuthzUserClaims: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION, pAuthzUserClaimsOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pAuthzDeviceClaims: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION, pAuthzDeviceClaimsOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pEffpermResultLists: PEFFPERM_RESULT_LIST): HRESULT {.stdcall.} + LPEFFECTIVEPERMISSION2* = ptr IEffectivePermission2 +const + SE_UNKNOWN_OBJECT_TYPE* = 0 + SE_FILE_OBJECT* = 1 + SE_SERVICE* = 2 + SE_PRINTER* = 3 + SE_REGISTRY_KEY* = 4 + SE_LMSHARE* = 5 + SE_KERNEL_OBJECT* = 6 + SE_WINDOW_OBJECT* = 7 + SE_DS_OBJECT* = 8 + SE_DS_OBJECT_ALL* = 9 + SE_PROVIDER_DEFINED_OBJECT* = 10 + SE_WMIGUID_OBJECT* = 11 + SE_REGISTRY_WOW64_32KEY* = 12 + TRUSTEE_IS_UNKNOWN* = 0 + TRUSTEE_IS_USER* = 1 + TRUSTEE_IS_GROUP* = 2 + TRUSTEE_IS_DOMAIN* = 3 + TRUSTEE_IS_ALIAS* = 4 + TRUSTEE_IS_WELL_KNOWN_GROUP* = 5 + TRUSTEE_IS_DELETED* = 6 + TRUSTEE_IS_INVALID* = 7 + TRUSTEE_IS_COMPUTER* = 8 + TRUSTEE_IS_SID* = 0 + TRUSTEE_IS_NAME* = 1 + TRUSTEE_BAD_FORM* = 2 + TRUSTEE_IS_OBJECTS_AND_SID* = 3 + TRUSTEE_IS_OBJECTS_AND_NAME* = 4 + NO_MULTIPLE_TRUSTEE* = 0 + TRUSTEE_IS_IMPERSONATE* = 1 + NOT_USED_ACCESS* = 0 + GRANT_ACCESS* = 1 + SET_ACCESS* = 2 + DENY_ACCESS* = 3 + REVOKE_ACCESS* = 4 + SET_AUDIT_SUCCESS* = 5 + SET_AUDIT_FAILURE* = 6 + NO_INHERITANCE* = 0x0 + SUB_OBJECTS_ONLY_INHERIT* = 0x1 + SUB_CONTAINERS_ONLY_INHERIT* = 0x2 + SUB_CONTAINERS_AND_OBJECTS_INHERIT* = 0x3 + INHERIT_NO_PROPAGATE* = 0x4 + INHERIT_ONLY* = 0x8 + INHERITED_ACCESS_ENTRY* = 0x10 + INHERITED_PARENT* = 0x10000000 + INHERITED_GRANDPARENT* = 0x20000000 + ACCCTRL_DEFAULT_PROVIDERA* = "Windows NT Access Provider" + ACCCTRL_DEFAULT_PROVIDERW* = "Windows NT Access Provider" + TRUSTEE_ACCESS_ALLOWED* = 0x1 + TRUSTEE_ACCESS_READ* = 0x2 + TRUSTEE_ACCESS_WRITE* = 0x4 + TRUSTEE_ACCESS_EXPLICIT* = 0x1 + TRUSTEE_ACCESS_READ_WRITE* = TRUSTEE_ACCESS_READ or TRUSTEE_ACCESS_WRITE + TRUSTEE_ACCESS_ALL* = 0xffffffff'i32 + ACTRL_RESERVED* = 0x00000000 + ACTRL_PERM_1* = 0x00000001 + ACTRL_PERM_2* = 0x00000002 + ACTRL_PERM_3* = 0x00000004 + ACTRL_PERM_4* = 0x00000008 + ACTRL_PERM_5* = 0x00000010 + ACTRL_PERM_6* = 0x00000020 + ACTRL_PERM_7* = 0x00000040 + ACTRL_PERM_8* = 0x00000080 + ACTRL_PERM_9* = 0x00000100 + ACTRL_PERM_10* = 0x00000200 + ACTRL_PERM_11* = 0x00000400 + ACTRL_PERM_12* = 0x00000800 + ACTRL_PERM_13* = 0x00001000 + ACTRL_PERM_14* = 0x00002000 + ACTRL_PERM_15* = 0x00004000 + ACTRL_PERM_16* = 0x00008000 + ACTRL_PERM_17* = 0x00010000 + ACTRL_PERM_18* = 0x00020000 + ACTRL_PERM_19* = 0x00040000 + ACTRL_PERM_20* = 0x00080000 + ACTRL_ACCESS_ALLOWED* = 0x00000001 + ACTRL_ACCESS_DENIED* = 0x00000002 + ACTRL_AUDIT_SUCCESS* = 0x00000004 + ACTRL_AUDIT_FAILURE* = 0x00000008 + ACTRL_ACCESS_PROTECTED* = 0x00000001 + ACTRL_SYSTEM_ACCESS* = 0x04000000 + ACTRL_DELETE* = 0x08000000 + ACTRL_READ_CONTROL* = 0x10000000 + ACTRL_CHANGE_ACCESS* = 0x20000000 + ACTRL_CHANGE_OWNER* = 0x40000000 + ACTRL_SYNCHRONIZE* = 0x80000000'i32 + ACTRL_STD_RIGHTS_ALL* = 0xf8000000'i32 + ACTRL_STD_RIGHT_REQUIRED* = ACTRL_STD_RIGHTS_ALL and not ACTRL_SYNCHRONIZE + ACTRL_DS_OPEN* = ACTRL_RESERVED + ACTRL_DS_CREATE_CHILD* = ACTRL_PERM_1 + ACTRL_DS_DELETE_CHILD* = ACTRL_PERM_2 + ACTRL_DS_LIST* = ACTRL_PERM_3 + ACTRL_DS_SELF* = ACTRL_PERM_4 + ACTRL_DS_READ_PROP* = ACTRL_PERM_5 + ACTRL_DS_WRITE_PROP* = ACTRL_PERM_6 + ACTRL_DS_DELETE_TREE* = ACTRL_PERM_7 + ACTRL_DS_LIST_OBJECT* = ACTRL_PERM_8 + ACTRL_DS_CONTROL_ACCESS* = ACTRL_PERM_9 + ACTRL_FILE_READ* = ACTRL_PERM_1 + ACTRL_FILE_WRITE* = ACTRL_PERM_2 + ACTRL_FILE_APPEND* = ACTRL_PERM_3 + ACTRL_FILE_READ_PROP* = ACTRL_PERM_4 + ACTRL_FILE_WRITE_PROP* = ACTRL_PERM_5 + ACTRL_FILE_EXECUTE* = ACTRL_PERM_6 + ACTRL_FILE_READ_ATTRIB* = ACTRL_PERM_8 + ACTRL_FILE_WRITE_ATTRIB* = ACTRL_PERM_9 + ACTRL_FILE_CREATE_PIPE* = ACTRL_PERM_10 + ACTRL_DIR_LIST* = ACTRL_PERM_1 + ACTRL_DIR_CREATE_OBJECT* = ACTRL_PERM_2 + ACTRL_DIR_CREATE_CHILD* = ACTRL_PERM_3 + ACTRL_DIR_DELETE_CHILD* = ACTRL_PERM_7 + ACTRL_DIR_TRAVERSE* = ACTRL_PERM_6 + ACTRL_KERNEL_TERMINATE* = ACTRL_PERM_1 + ACTRL_KERNEL_THREAD* = ACTRL_PERM_2 + ACTRL_KERNEL_VM* = ACTRL_PERM_3 + ACTRL_KERNEL_VM_READ* = ACTRL_PERM_4 + ACTRL_KERNEL_VM_WRITE* = ACTRL_PERM_5 + ACTRL_KERNEL_DUP_HANDLE* = ACTRL_PERM_6 + ACTRL_KERNEL_PROCESS* = ACTRL_PERM_7 + ACTRL_KERNEL_SET_INFO* = ACTRL_PERM_8 + ACTRL_KERNEL_GET_INFO* = ACTRL_PERM_9 + ACTRL_KERNEL_CONTROL* = ACTRL_PERM_10 + ACTRL_KERNEL_ALERT* = ACTRL_PERM_11 + ACTRL_KERNEL_GET_CONTEXT* = ACTRL_PERM_12 + ACTRL_KERNEL_SET_CONTEXT* = ACTRL_PERM_13 + ACTRL_KERNEL_TOKEN* = ACTRL_PERM_14 + ACTRL_KERNEL_IMPERSONATE* = ACTRL_PERM_15 + ACTRL_KERNEL_DIMPERSONATE* = ACTRL_PERM_16 + ACTRL_PRINT_SADMIN* = ACTRL_PERM_1 + ACTRL_PRINT_SLIST* = ACTRL_PERM_2 + ACTRL_PRINT_PADMIN* = ACTRL_PERM_3 + ACTRL_PRINT_PUSE* = ACTRL_PERM_4 + ACTRL_PRINT_JADMIN* = ACTRL_PERM_5 + ACTRL_SVC_GET_INFO* = ACTRL_PERM_1 + ACTRL_SVC_SET_INFO* = ACTRL_PERM_2 + ACTRL_SVC_STATUS* = ACTRL_PERM_3 + ACTRL_SVC_LIST* = ACTRL_PERM_4 + ACTRL_SVC_START* = ACTRL_PERM_5 + ACTRL_SVC_STOP* = ACTRL_PERM_6 + ACTRL_SVC_PAUSE* = ACTRL_PERM_7 + ACTRL_SVC_INTERROGATE* = ACTRL_PERM_8 + ACTRL_SVC_UCONTROL* = ACTRL_PERM_9 + ACTRL_REG_QUERY* = ACTRL_PERM_1 + ACTRL_REG_SET* = ACTRL_PERM_2 + ACTRL_REG_CREATE_CHILD* = ACTRL_PERM_3 + ACTRL_REG_LIST* = ACTRL_PERM_4 + ACTRL_REG_NOTIFY* = ACTRL_PERM_5 + ACTRL_REG_LINK* = ACTRL_PERM_6 + ACTRL_WIN_CLIPBRD* = ACTRL_PERM_1 + ACTRL_WIN_GLOBAL_ATOMS* = ACTRL_PERM_2 + ACTRL_WIN_CREATE* = ACTRL_PERM_3 + ACTRL_WIN_LIST_DESK* = ACTRL_PERM_4 + ACTRL_WIN_LIST* = ACTRL_PERM_5 + ACTRL_WIN_READ_ATTRIBS* = ACTRL_PERM_6 + ACTRL_WIN_WRITE_ATTRIBS* = ACTRL_PERM_7 + ACTRL_WIN_SCREEN* = ACTRL_PERM_8 + ACTRL_WIN_EXIT* = ACTRL_PERM_9 + ACTRL_ACCESS_NO_OPTIONS* = 0x0 + ACTRL_ACCESS_SUPPORTS_OBJECT_ENTRIES* = 0x1 + TREE_SEC_INFO_SET* = 0x00000001 + TREE_SEC_INFO_RESET* = 0x00000002 + TREE_SEC_INFO_RESET_KEEP_EXPLICIT* = 0x00000003 + progressInvokeNever* = 1 + progressInvokeEveryObject* = 2 + progressInvokeOnError* = 3 + progressCancelOperation* = 4 + progressRetryOperation* = 5 + progressInvokePrePostError* = 6 + AUDIT_TYPE_LEGACY* = 1 + AUDIT_TYPE_WMI* = 2 + APT_None* = 1 + APT_String* = 2 + APT_Ulong* = 3 + APT_Pointer* = 4 + APT_Sid* = 5 + APT_LogonId* = 6 + APT_ObjectTypeList* = 7 + APT_Luid* = 8 + APT_Guid* = 9 + APT_Time* = 10 + APT_Int64* = 11 + APT_IpAddress* = 12 + APT_LogonIdWithSid* = 13 + AP_ParamTypeBits* = 8 + AP_ParamTypeMask* = 0xff + AP_FormatHex* = 0x1 shl AP_ParamTypeBits + AP_AccessMask* = 0x2 shl AP_ParamTypeBits + AP_Filespec* = 0x1 shl AP_ParamTypeBits + AP_SidAsLogonId* = 0x1 shl AP_ParamTypeBits + AP_PrimaryLogonId* = 0x1 shl AP_ParamTypeBits + AP_ClientLogonId* = 0x2 shl AP_ParamTypeBits + APF_AuditFailure* = 0x0 + APF_AuditSuccess* = 0x1 + APF_ValidFlags* = APF_AuditSuccess + AUTHZ_ALLOW_MULTIPLE_SOURCE_INSTANCES* = 0x1 + AUTHZ_MIGRATED_LEGACY_PUBLISHER* = 0x2 + AUTHZ_AUDIT_INSTANCE_INFORMATION* = 0x2 + AUTHZP_WPD_EVENT* = 0x10 + AUTHZ_SKIP_TOKEN_GROUPS* = 0x2 + AUTHZ_REQUIRE_S4U_LOGON* = 0x4 + AUTHZ_COMPUTE_PRIVILEGES* = 0x8 + AUTHZ_GENERATE_SUCCESS_AUDIT* = 0x1 + AUTHZ_GENERATE_FAILURE_AUDIT* = 0x2 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_INVALID* = 0x00 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_INT64* = 0x01 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_UINT64* = 0x02 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_STRING* = 0x03 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_FQBN* = 0x04 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_SID* = 0x05 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_BOOLEAN* = 0x06 + AUTHZ_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING* = 0x10 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION_NONE* = 0 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION_REPLACE_ALL* = 1 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION_ADD* = 2 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION_DELETE* = 3 + AUTHZ_SECURITY_ATTRIBUTE_OPERATION_REPLACE* = 4 + AUTHZ_SID_OPERATION_NONE* = 0 + AUTHZ_SID_OPERATION_REPLACE_ALL* = 1 + AUTHZ_SID_OPERATION_ADD* = 2 + AUTHZ_SID_OPERATION_DELETE* = 3 + AUTHZ_SID_OPERATION_REPLACE* = 4 + AUTHZ_SECURITY_ATTRIBUTE_NON_INHERITABLE* = 0x1 + AUTHZ_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE* = 0x2 + AUTHZ_SECURITY_ATTRIBUTE_VALID_FLAGS* = AUTHZ_SECURITY_ATTRIBUTE_NON_INHERITABLE or AUTHZ_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE + AUTHZ_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1* = 1 + AUTHZ_SECURITY_ATTRIBUTES_INFORMATION_VERSION* = AUTHZ_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1 + AUTHZ_ACCESS_CHECK_NO_DEEP_COPY_SD* = 0x1 + AUTHZ_RM_FLAG_NO_AUDIT* = 0x1 + AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION* = 0x2 + AUTHZ_RM_FLAG_NO_CENTRAL_ACCESS_POLICIES* = 0x4 + AUTHZ_VALID_RM_INIT_FLAGS* = AUTHZ_RM_FLAG_NO_AUDIT or AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION or AUTHZ_RM_FLAG_NO_CENTRAL_ACCESS_POLICIES + AUTHZ_RPC_INIT_INFO_CLIENT_VERSION_V1* = 1 + AUTHZ_INIT_INFO_VERSION_V1* = 1 + authzContextInfoUserSid* = 1 + authzContextInfoGroupsSids* = 2 + authzContextInfoRestrictedSids* = 3 + authzContextInfoPrivileges* = 4 + authzContextInfoExpirationTime* = 5 + authzContextInfoServerContext* = 6 + authzContextInfoIdentifier* = 7 + authzContextInfoSource* = 8 + authzContextInfoAll* = 9 + authzContextInfoAuthenticationId* = 10 + authzContextInfoSecurityAttributes* = 11 + authzContextInfoDeviceSids* = 12 + authzContextInfoUserClaims* = 13 + authzContextInfoDeviceClaims* = 14 + authzContextInfoAppContainerSid* = 15 + authzContextInfoCapabilitySids* = 16 + AUTHZ_NO_SUCCESS_AUDIT* = 0x1 + AUTHZ_NO_FAILURE_AUDIT* = 0x2 + AUTHZ_NO_ALLOC_STRINGS* = 0x4 + AUTHZ_WPD_CATEGORY_FLAG* = 0x10 + AUTHZ_VALID_OBJECT_ACCESS_AUDIT_FLAGS* = AUTHZ_NO_SUCCESS_AUDIT or AUTHZ_NO_FAILURE_AUDIT or AUTHZ_NO_ALLOC_STRINGS or AUTHZ_WPD_CATEGORY_FLAG + authzAuditEventInfoFlags* = 1 + authzAuditEventInfoOperationType* = 2 + authzAuditEventInfoObjectType* = 3 + authzAuditEventInfoObjectName* = 4 + authzAuditEventInfoAdditionalInfo* = 5 + AUTHZ_FLAG_ALLOW_MULTIPLE_SOURCE_INSTANCES* = 0x1 + SI_EDIT_PERMS* = 0x00000000 + SI_EDIT_OWNER* = 0x00000001 + SI_EDIT_AUDITS* = 0x00000002 + SI_CONTAINER* = 0x00000004 + SI_READONLY* = 0x00000008 + SI_ADVANCED* = 0x00000010 + SI_RESET* = 0x00000020 + SI_OWNER_READONLY* = 0x00000040 + SI_EDIT_PROPERTIES* = 0x00000080 + SI_OWNER_RECURSE* = 0x00000100 + SI_NO_ACL_PROTECT* = 0x00000200 + SI_NO_TREE_APPLY* = 0x00000400 + SI_PAGE_TITLE* = 0x00000800 + SI_SERVER_IS_DC* = 0x00001000 + SI_RESET_DACL_TREE* = 0x00004000 + SI_RESET_SACL_TREE* = 0x00008000 + SI_OBJECT_GUID* = 0x00010000 + SI_EDIT_EFFECTIVE* = 0x00020000 + SI_RESET_DACL* = 0x00040000 + SI_RESET_SACL* = 0x00080000 + SI_RESET_OWNER* = 0x00100000 + SI_NO_ADDITIONAL_PERMISSION* = 0x00200000 + SI_VIEW_ONLY* = 0x00400000 + SI_PERMS_ELEVATION_REQUIRED* = 0x01000000 + SI_AUDITS_ELEVATION_REQUIRED* = 0x02000000 + SI_OWNER_ELEVATION_REQUIRED* = 0x04000000 + SI_SCOPE_ELEVATION_REQUIRED* = 0x08000000 + SI_MAY_WRITE* = 0x10000000 + SI_ENABLE_EDIT_ATTRIBUTE_CONDITION* = 0x20000000 + SI_ENABLE_CENTRAL_POLICY* = 0x40000000 + SI_DISABLE_DENY_ACE* = 0x80000000'i32 + SI_EDIT_ALL* = SI_EDIT_PERMS or SI_EDIT_OWNER or SI_EDIT_AUDITS + SI_ACCESS_SPECIFIC* = 0x00010000 + SI_ACCESS_GENERAL* = 0x00020000 + SI_ACCESS_CONTAINER* = 0x00040000 + SI_ACCESS_PROPERTY* = 0x00080000 + SI_PAGE_PERM* = 0 + SI_PAGE_ADVPERM* = 1 + SI_PAGE_AUDIT* = 2 + SI_PAGE_OWNER* = 3 + SI_PAGE_EFFECTIVE* = 4 + SI_PAGE_TAKEOWNERSHIP* = 5 + SI_PAGE_SHARE* = 6 + SI_SHOW_DEFAULT* = 0 + SI_SHOW_PERM_ACTIVATED* = 1 + SI_SHOW_AUDIT_ACTIVATED* = 2 + SI_SHOW_OWNER_ACTIVATED* = 3 + SI_SHOW_EFFECTIVE_ACTIVATED* = 4 + SI_SHOW_SHARE_ACTIVATED* = 5 + SI_SHOW_CENTRAL_POLICY_ACTIVATED* = 6 + DOBJ_RES_CONT* = 0x00000001 + DOBJ_RES_ROOT* = 0x00000002 + DOBJ_VOL_NTACLS* = 0x00000004 + DOBJ_COND_NTACLS* = 0x00000008 + DOBJ_RIBBON_LAUNCH* = 0x00000010 + PSPCB_SI_INITDIALOG* = WM_USER+1 + IID_ISecurityInformation* = DEFINE_GUID("965fc360-16ff-11d0-91cb-00aa00bbb723") + IID_ISecurityInformation2* = DEFINE_GUID("c3ccfdb4-6f88-11d2-a3ce-00c04fb1782a") + CFSTR_ACLUI_SID_INFO_LIST* = "CFSTR_ACLUI_SID_INFO_LIST" + IID_IEffectivePermission* = DEFINE_GUID("3853dc76-9f35-407c-88a1-d19344365fbc") + IID_ISecurityObjectTypeInfo* = DEFINE_GUID("fc3066eb-79ef-444b-9111-d18a75ebf2fa") + IID_ISecurityInformation3* = DEFINE_GUID("e2cdc9cc-31bd-4f8f-8c8b-b641af516a1a") + SECURITY_OBJECT_ID_OBJECT_SD* = 1 + SECURITY_OBJECT_ID_SHARE* = 2 + SECURITY_OBJECT_ID_CENTRAL_POLICY* = 3 + SECURITY_OBJECT_ID_CENTRAL_ACCESS_RULE* = 4 + IID_ISecurityInformation4* = DEFINE_GUID("ea961070-cd14-4621-ace4-f63c03e583e4") + IID_IEffectivePermission2* = DEFINE_GUID("941fabca-dd47-4fca-90bb-b0e10255f20d") +type + FN_PROGRESS* = proc (pObjectName: LPWSTR, Status: DWORD, pInvokeSetting: PPROG_INVOKE_SETTING, Args: PVOID, SecuritySet: WINBOOL): VOID {.stdcall.} +proc SetEntriesInAclA*(cCountOfExplicitEntries: ULONG, pListOfExplicitEntries: PEXPLICIT_ACCESS_A, OldAcl: PACL, NewAcl: ptr PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetEntriesInAclW*(cCountOfExplicitEntries: ULONG, pListOfExplicitEntries: PEXPLICIT_ACCESS_W, OldAcl: PACL, NewAcl: ptr PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetExplicitEntriesFromAclA*(pacl: PACL, pcCountOfExplicitEntries: PULONG, pListOfExplicitEntries: ptr PEXPLICIT_ACCESS_A): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetExplicitEntriesFromAclW*(pacl: PACL, pcCountOfExplicitEntries: PULONG, pListOfExplicitEntries: ptr PEXPLICIT_ACCESS_W): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetEffectiveRightsFromAclA*(pacl: PACL, pTrustee: PTRUSTEE_A, pAccessRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetEffectiveRightsFromAclW*(pacl: PACL, pTrustee: PTRUSTEE_W, pAccessRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetAuditedPermissionsFromAclA*(pacl: PACL, pTrustee: PTRUSTEE_A, pSuccessfulAuditedRights: PACCESS_MASK, pFailedAuditRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetAuditedPermissionsFromAclW*(pacl: PACL, pTrustee: PTRUSTEE_W, pSuccessfulAuditedRights: PACCESS_MASK, pFailedAuditRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetNamedSecurityInfoA*(pObjectName: LPCSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, ppsidOwner: ptr PSID, ppsidGroup: ptr PSID, ppDacl: ptr PACL, ppSacl: ptr PACL, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetNamedSecurityInfoW*(pObjectName: LPCWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, ppsidOwner: ptr PSID, ppsidGroup: ptr PSID, ppDacl: ptr PACL, ppSacl: ptr PACL, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityInfo*(handle: HANDLE, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, ppsidOwner: ptr PSID, ppsidGroup: ptr PSID, ppDacl: ptr PACL, ppSacl: ptr PACL, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetNamedSecurityInfoA*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, psidOwner: PSID, psidGroup: PSID, pDacl: PACL, pSacl: PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetNamedSecurityInfoW*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, psidOwner: PSID, psidGroup: PSID, pDacl: PACL, pSacl: PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityInfo*(handle: HANDLE, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, psidOwner: PSID, psidGroup: PSID, pDacl: PACL, pSacl: PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetInheritanceSourceA*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, Container: WINBOOL, pObjectClassGuids: ptr ptr GUID, GuidCount: DWORD, pAcl: PACL, pfnArray: PFN_OBJECT_MGR_FUNCTS, pGenericMapping: PGENERIC_MAPPING, pInheritArray: PINHERITED_FROMA): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetInheritanceSourceW*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, Container: WINBOOL, pObjectClassGuids: ptr ptr GUID, GuidCount: DWORD, pAcl: PACL, pfnArray: PFN_OBJECT_MGR_FUNCTS, pGenericMapping: PGENERIC_MAPPING, pInheritArray: PINHERITED_FROMW): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FreeInheritedFromArray*(pInheritArray: PINHERITED_FROMW, AceCnt: USHORT, pfnArray: PFN_OBJECT_MGR_FUNCTS): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc TreeResetNamedSecurityInfoA*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, KeepExplicit: WINBOOL, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc TreeResetNamedSecurityInfoW*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, KeepExplicit: WINBOOL, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildSecurityDescriptorA*(pOwner: PTRUSTEE_A, pGroup: PTRUSTEE_A, cCountOfAccessEntries: ULONG, pListOfAccessEntries: PEXPLICIT_ACCESS_A, cCountOfAuditEntries: ULONG, pListOfAuditEntries: PEXPLICIT_ACCESS_A, pOldSD: PSECURITY_DESCRIPTOR, pSizeNewSD: PULONG, pNewSD: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildSecurityDescriptorW*(pOwner: PTRUSTEE_W, pGroup: PTRUSTEE_W, cCountOfAccessEntries: ULONG, pListOfAccessEntries: PEXPLICIT_ACCESS_W, cCountOfAuditEntries: ULONG, pListOfAuditEntries: PEXPLICIT_ACCESS_W, pOldSD: PSECURITY_DESCRIPTOR, pSizeNewSD: PULONG, pNewSD: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupSecurityDescriptorPartsA*(ppOwner: ptr PTRUSTEE_A, ppGroup: ptr PTRUSTEE_A, pcCountOfAccessEntries: PULONG, ppListOfAccessEntries: ptr PEXPLICIT_ACCESS_A, pcCountOfAuditEntries: PULONG, ppListOfAuditEntries: ptr PEXPLICIT_ACCESS_A, pSD: PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupSecurityDescriptorPartsW*(ppOwner: ptr PTRUSTEE_W, ppGroup: ptr PTRUSTEE_W, pcCountOfAccessEntries: PULONG, ppListOfAccessEntries: ptr PEXPLICIT_ACCESS_W, pcCountOfAuditEntries: PULONG, ppListOfAuditEntries: ptr PEXPLICIT_ACCESS_W, pSD: PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildExplicitAccessWithNameA*(pExplicitAccess: PEXPLICIT_ACCESS_A, pTrusteeName: LPSTR, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildExplicitAccessWithNameW*(pExplicitAccess: PEXPLICIT_ACCESS_W, pTrusteeName: LPWSTR, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildImpersonateExplicitAccessWithNameA*(pExplicitAccess: PEXPLICIT_ACCESS_A, pTrusteeName: LPSTR, pTrustee: PTRUSTEE_A, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildImpersonateExplicitAccessWithNameW*(pExplicitAccess: PEXPLICIT_ACCESS_W, pTrusteeName: LPWSTR, pTrustee: PTRUSTEE_W, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithNameA*(pTrustee: PTRUSTEE_A, pName: LPSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithNameW*(pTrustee: PTRUSTEE_W, pName: LPWSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildImpersonateTrusteeA*(pTrustee: PTRUSTEE_A, pImpersonateTrustee: PTRUSTEE_A): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildImpersonateTrusteeW*(pTrustee: PTRUSTEE_W, pImpersonateTrustee: PTRUSTEE_W): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithSidA*(pTrustee: PTRUSTEE_A, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithSidW*(pTrustee: PTRUSTEE_W, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithObjectsAndSidA*(pTrustee: PTRUSTEE_A, pObjSid: POBJECTS_AND_SID, pObjectGuid: ptr GUID, pInheritedObjectGuid: ptr GUID, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithObjectsAndSidW*(pTrustee: PTRUSTEE_W, pObjSid: POBJECTS_AND_SID, pObjectGuid: ptr GUID, pInheritedObjectGuid: ptr GUID, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithObjectsAndNameA*(pTrustee: PTRUSTEE_A, pObjName: POBJECTS_AND_NAME_A, ObjectType: SE_OBJECT_TYPE, ObjectTypeName: LPSTR, InheritedObjectTypeName: LPSTR, Name: LPSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildTrusteeWithObjectsAndNameW*(pTrustee: PTRUSTEE_W, pObjName: POBJECTS_AND_NAME_W, ObjectType: SE_OBJECT_TYPE, ObjectTypeName: LPWSTR, InheritedObjectTypeName: LPWSTR, Name: LPWSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeNameA*(pTrustee: PTRUSTEE_A): LPSTR {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeNameW*(pTrustee: PTRUSTEE_W): LPWSTR {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeTypeA*(pTrustee: PTRUSTEE_A): TRUSTEE_TYPE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeTypeW*(pTrustee: PTRUSTEE_W): TRUSTEE_TYPE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeFormA*(pTrustee: PTRUSTEE_A): TRUSTEE_FORM {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTrusteeFormW*(pTrustee: PTRUSTEE_W): TRUSTEE_FORM {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetMultipleTrusteeOperationA*(pTrustee: PTRUSTEE_A): MULTIPLE_TRUSTEE_OPERATION {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetMultipleTrusteeOperationW*(pTrustee: PTRUSTEE_W): MULTIPLE_TRUSTEE_OPERATION {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetMultipleTrusteeA*(pTrustee: PTRUSTEE_A): PTRUSTEE_A {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetMultipleTrusteeW*(pTrustee: PTRUSTEE_W): PTRUSTEE_W {.winapi, stdcall, dynlib: "advapi32", importc.} +proc TreeSetNamedSecurityInfoA*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, dwAction: DWORD, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc TreeSetNamedSecurityInfoW*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, dwAction: DWORD, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuthzAccessCheck*(Flags: DWORD, hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pRequest: PAUTHZ_ACCESS_REQUEST, hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE, pSecurityDescriptor: PSECURITY_DESCRIPTOR, OptionalSecurityDescriptorArray: ptr PSECURITY_DESCRIPTOR, OptionalSecurityDescriptorCount: DWORD, pReply: PAUTHZ_ACCESS_REPLY, phAccessCheckResults: PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzCachedAccessCheck*(Flags: DWORD, hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE, pRequest: PAUTHZ_ACCESS_REQUEST, hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE, pReply: PAUTHZ_ACCESS_REPLY): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzOpenObjectAudit*(Flags: DWORD, hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pRequest: PAUTHZ_ACCESS_REQUEST, hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE, pSecurityDescriptor: PSECURITY_DESCRIPTOR, OptionalSecurityDescriptorArray: ptr PSECURITY_DESCRIPTOR, OptionalSecurityDescriptorCount: DWORD, pReply: PAUTHZ_ACCESS_REPLY): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzFreeHandle*(hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeResourceManager*(Flags: DWORD, pfnDynamicAccessCheck: PFN_AUTHZ_DYNAMIC_ACCESS_CHECK, pfnComputeDynamicGroups: PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS, pfnFreeDynamicGroups: PFN_AUTHZ_FREE_DYNAMIC_GROUPS, szResourceManagerName: PCWSTR, phAuthzResourceManager: PAUTHZ_RESOURCE_MANAGER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeResourceManagerEx*(Flags: DWORD, pAuthzInitInfo: PAUTHZ_INIT_INFO, phAuthzResourceManager: PAUTHZ_RESOURCE_MANAGER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeRemoteResourceManager*(pRpcInitInfo: PAUTHZ_RPC_INIT_INFO_CLIENT, phAuthzResourceManager: PAUTHZ_RESOURCE_MANAGER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzFreeResourceManager*(hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeContextFromToken*(Flags: DWORD, TokenHandle: HANDLE, hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE, pExpirationTime: PLARGE_INTEGER, Identifier: LUID, DynamicGroupArgs: PVOID, phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeContextFromSid*(Flags: DWORD, UserSid: PSID, hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE, pExpirationTime: PLARGE_INTEGER, Identifier: LUID, DynamicGroupArgs: PVOID, phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeContextFromAuthzContext*(Flags: DWORD, hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pExpirationTime: PLARGE_INTEGER, Identifier: LUID, DynamicGroupArgs: PVOID, phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeCompoundContext*(UserContext: AUTHZ_CLIENT_CONTEXT_HANDLE, DeviceContext: AUTHZ_CLIENT_CONTEXT_HANDLE, phCompoundContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzAddSidsToContext*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, Sids: PSID_AND_ATTRIBUTES, SidCount: DWORD, RestrictedSids: PSID_AND_ATTRIBUTES, RestrictedSidCount: DWORD, phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzModifySecurityAttributes*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pAttributes: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzModifyClaims*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, ClaimClass: AUTHZ_CONTEXT_INFORMATION_CLASS, pClaimOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pClaims: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzModifySids*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, SidClass: AUTHZ_CONTEXT_INFORMATION_CLASS, pSidOperations: PAUTHZ_SID_OPERATION, pSids: PTOKEN_GROUPS): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzSetAppContainerInformation*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pAppContainerSid: PSID, CapabilityCount: DWORD, pCapabilitySids: PSID_AND_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzGetInformationFromContext*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, InfoClass: AUTHZ_CONTEXT_INFORMATION_CLASS, BufferSize: DWORD, pSizeRequired: PDWORD, Buffer: PVOID): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzFreeContext*(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInitializeObjectAccessAuditEvent*(Flags: DWORD, hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE, szOperationType: PWSTR, szObjectType: PWSTR, szObjectName: PWSTR, szAdditionalInfo: PWSTR, phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE, dwAdditionalParameterCount: DWORD): WINBOOL {.winapi, cdecl, varargs, dynlib: "authz", importc.} +proc AuthzInitializeObjectAccessAuditEvent2*(Flags: DWORD, hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE, szOperationType: PWSTR, szObjectType: PWSTR, szObjectName: PWSTR, szAdditionalInfo: PWSTR, szAdditionalInfo2: PWSTR, phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE, dwAdditionalParameterCount: DWORD): WINBOOL {.winapi, cdecl, varargs, dynlib: "authz", importc.} +proc AuthzFreeAuditEvent*(hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzEvaluateSacl*(AuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE, pRequest: PAUTHZ_ACCESS_REQUEST, Sacl: PACL, GrantedAccess: ACCESS_MASK, AccessGranted: WINBOOL, pbGenerateAudit: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzInstallSecurityEventSource*(dwFlags: DWORD, pRegistration: PAUTHZ_SOURCE_SCHEMA_REGISTRATION): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzUninstallSecurityEventSource*(dwFlags: DWORD, szEventSourceName: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzEnumerateSecurityEventSources*(dwFlags: DWORD, Buffer: PAUTHZ_SOURCE_SCHEMA_REGISTRATION, pdwCount: PDWORD, pdwLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzRegisterSecurityEventSource*(dwFlags: DWORD, szEventSourceName: PCWSTR, phEventProvider: PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzUnregisterSecurityEventSource*(dwFlags: DWORD, phEventProvider: PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzReportSecurityEvent*(dwFlags: DWORD, hEventProvider: AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE, dwAuditId: DWORD, pUserSid: PSID, dwCount: DWORD): WINBOOL {.winapi, cdecl, varargs, dynlib: "authz", importc.} +proc AuthzReportSecurityEventFromParams*(dwFlags: DWORD, hEventProvider: AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE, dwAuditId: DWORD, pUserSid: PSID, pParams: PAUDIT_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzRegisterCapChangeNotification*(phCapChangeSubscription: PAUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE, pfnCapChangeCallback: LPTHREAD_START_ROUTINE, pCallbackContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzUnregisterCapChangeNotification*(hCapChangeSubscription: AUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc AuthzFreeCentralAccessPolicyCache*(): WINBOOL {.winapi, stdcall, dynlib: "authz", importc.} +proc CreateSecurityPage*(psi: LPSECURITYINFO): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "aclui", importc.} +proc EditSecurity*(hwndOwner: HWND, psi: LPSECURITYINFO): WINBOOL {.winapi, stdcall, dynlib: "aclui", importc.} +proc EditSecurityAdvanced*(hwndOwner: HWND, psi: LPSECURITYINFO, uSIPage: SI_PAGE_TYPE): HRESULT {.winapi, stdcall, dynlib: "aclui", importc.} +proc `Provider=`*(self: var ACTRL_OVERLAPPED, x: PVOID) {.inline.} = self.union1.Provider = x +proc Provider*(self: ACTRL_OVERLAPPED): PVOID {.inline.} = self.union1.Provider +proc Provider*(self: var ACTRL_OVERLAPPED): var PVOID {.inline.} = self.union1.Provider +proc `Reserved1=`*(self: var ACTRL_OVERLAPPED, x: ULONG) {.inline.} = self.union1.Reserved1 = x +proc Reserved1*(self: ACTRL_OVERLAPPED): ULONG {.inline.} = self.union1.Reserved1 +proc Reserved1*(self: var ACTRL_OVERLAPPED): var ULONG {.inline.} = self.union1.Reserved1 +proc `Data0=`*(self: var AUDIT_PARAM, x: ULONG_PTR) {.inline.} = self.union1.Data0 = x +proc Data0*(self: AUDIT_PARAM): ULONG_PTR {.inline.} = self.union1.Data0 +proc Data0*(self: var AUDIT_PARAM): var ULONG_PTR {.inline.} = self.union1.Data0 +proc `Str=`*(self: var AUDIT_PARAM, x: PWSTR) {.inline.} = self.union1.Str = x +proc Str*(self: AUDIT_PARAM): PWSTR {.inline.} = self.union1.Str +proc Str*(self: var AUDIT_PARAM): var PWSTR {.inline.} = self.union1.Str +proc `u=`*(self: var AUDIT_PARAM, x: ULONG_PTR) {.inline.} = self.union1.u = x +proc u*(self: AUDIT_PARAM): ULONG_PTR {.inline.} = self.union1.u +proc u*(self: var AUDIT_PARAM): var ULONG_PTR {.inline.} = self.union1.u +proc `psid=`*(self: var AUDIT_PARAM, x: ptr SID) {.inline.} = self.union1.psid = x +proc psid*(self: AUDIT_PARAM): ptr SID {.inline.} = self.union1.psid +proc psid*(self: var AUDIT_PARAM): var ptr SID {.inline.} = self.union1.psid +proc `pguid=`*(self: var AUDIT_PARAM, x: ptr GUID) {.inline.} = self.union1.pguid = x +proc pguid*(self: AUDIT_PARAM): ptr GUID {.inline.} = self.union1.pguid +proc pguid*(self: var AUDIT_PARAM): var ptr GUID {.inline.} = self.union1.pguid +proc `LogonId_LowPart=`*(self: var AUDIT_PARAM, x: ULONG) {.inline.} = self.union1.LogonId_LowPart = x +proc LogonId_LowPart*(self: AUDIT_PARAM): ULONG {.inline.} = self.union1.LogonId_LowPart +proc LogonId_LowPart*(self: var AUDIT_PARAM): var ULONG {.inline.} = self.union1.LogonId_LowPart +proc `pObjectTypes=`*(self: var AUDIT_PARAM, x: ptr AUDIT_OBJECT_TYPES) {.inline.} = self.union1.pObjectTypes = x +proc pObjectTypes*(self: AUDIT_PARAM): ptr AUDIT_OBJECT_TYPES {.inline.} = self.union1.pObjectTypes +proc pObjectTypes*(self: var AUDIT_PARAM): var ptr AUDIT_OBJECT_TYPES {.inline.} = self.union1.pObjectTypes +proc `pIpAddress=`*(self: var AUDIT_PARAM, x: ptr AUDIT_IP_ADDRESS) {.inline.} = self.union1.pIpAddress = x +proc pIpAddress*(self: AUDIT_PARAM): ptr AUDIT_IP_ADDRESS {.inline.} = self.union1.pIpAddress +proc pIpAddress*(self: var AUDIT_PARAM): var ptr AUDIT_IP_ADDRESS {.inline.} = self.union1.pIpAddress +proc `Data1=`*(self: var AUDIT_PARAM, x: ULONG_PTR) {.inline.} = self.union2.Data1 = x +proc Data1*(self: AUDIT_PARAM): ULONG_PTR {.inline.} = self.union2.Data1 +proc Data1*(self: var AUDIT_PARAM): var ULONG_PTR {.inline.} = self.union2.Data1 +proc `LogonId_HighPart=`*(self: var AUDIT_PARAM, x: LONG) {.inline.} = self.union2.LogonId_HighPart = x +proc LogonId_HighPart*(self: AUDIT_PARAM): LONG {.inline.} = self.union2.LogonId_HighPart +proc LogonId_HighPart*(self: var AUDIT_PARAM): var LONG {.inline.} = self.union2.LogonId_HighPart +proc `pReserved=`*(self: var AUTHZ_SOURCE_SCHEMA_REGISTRATION, x: PVOID) {.inline.} = self.union1.pReserved = x +proc pReserved*(self: AUTHZ_SOURCE_SCHEMA_REGISTRATION): PVOID {.inline.} = self.union1.pReserved +proc pReserved*(self: var AUTHZ_SOURCE_SCHEMA_REGISTRATION): var PVOID {.inline.} = self.union1.pReserved +proc `pProviderGuid=`*(self: var AUTHZ_SOURCE_SCHEMA_REGISTRATION, x: ptr GUID) {.inline.} = self.union1.pProviderGuid = x +proc pProviderGuid*(self: AUTHZ_SOURCE_SCHEMA_REGISTRATION): ptr GUID {.inline.} = self.union1.pProviderGuid +proc pProviderGuid*(self: var AUTHZ_SOURCE_SCHEMA_REGISTRATION): var ptr GUID {.inline.} = self.union1.pProviderGuid +proc GetObjectInformation*(self: ptr ISecurityInformation, pObjectInfo: PSI_OBJECT_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectInformation(self, pObjectInfo) +proc GetSecurity*(self: ptr ISecurityInformation, RequestedInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, fDefault: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecurity(self, RequestedInformation, ppSecurityDescriptor, fDefault) +proc SetSecurity*(self: ptr ISecurityInformation, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSecurity(self, SecurityInformation, pSecurityDescriptor) +proc GetAccessRights*(self: ptr ISecurityInformation, pguidObjectType: ptr GUID, dwFlags: DWORD, ppAccess: ptr PSI_ACCESS, pcAccesses: ptr ULONG, piDefaultAccess: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAccessRights(self, pguidObjectType, dwFlags, ppAccess, pcAccesses, piDefaultAccess) +proc MapGeneric*(self: ptr ISecurityInformation, pguidObjectType: ptr GUID, pAceFlags: ptr UCHAR, pMask: ptr ACCESS_MASK): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapGeneric(self, pguidObjectType, pAceFlags, pMask) +proc GetInheritTypes*(self: ptr ISecurityInformation, ppInheritTypes: ptr PSI_INHERIT_TYPE, pcInheritTypes: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInheritTypes(self, ppInheritTypes, pcInheritTypes) +proc PropertySheetPageCallback*(self: ptr ISecurityInformation, hwnd: HWND, uMsg: UINT, uPage: SI_PAGE_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PropertySheetPageCallback(self, hwnd, uMsg, uPage) +proc IsDaclCanonical*(self: ptr ISecurityInformation2, pDacl: PACL): WINBOOL {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDaclCanonical(self, pDacl) +proc LookupSids*(self: ptr ISecurityInformation2, cSids: ULONG, rgpSids: ptr PSID, ppdo: ptr LPDATAOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LookupSids(self, cSids, rgpSids, ppdo) +proc GetEffectivePermission*(self: ptr IEffectivePermission, pguidObjectType: ptr GUID, pUserSid: PSID, pszServerName: LPCWSTR, pSD: PSECURITY_DESCRIPTOR, ppObjectTypeList: ptr POBJECT_TYPE_LIST, pcObjectTypeListLength: ptr ULONG, ppGrantedAccessList: ptr PACCESS_MASK, pcGrantedAccessListLength: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEffectivePermission(self, pguidObjectType, pUserSid, pszServerName, pSD, ppObjectTypeList, pcObjectTypeListLength, ppGrantedAccessList, pcGrantedAccessListLength) +proc GetInheritSource*(self: ptr ISecurityObjectTypeInfo, si: SECURITY_INFORMATION, pACL: PACL, ppInheritArray: ptr PINHERITED_FROM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInheritSource(self, si, pACL, ppInheritArray) +proc GetFullResourceName*(self: ptr ISecurityInformation3, ppszResourceName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFullResourceName(self, ppszResourceName) +proc OpenElevatedEditor*(self: ptr ISecurityInformation3, hWnd: HWND, uPage: SI_PAGE_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenElevatedEditor(self, hWnd, uPage) +proc GetSecondarySecurity*(self: ptr ISecurityInformation4, pSecurityObjects: ptr PSECURITY_OBJECT, pSecurityObjectCount: PULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecondarySecurity(self, pSecurityObjects, pSecurityObjectCount) +proc ComputeEffectivePermissionWithSecondarySecurity*(self: ptr IEffectivePermission2, pSid: PSID, pDeviceSid: PSID, pszServerName: PCWSTR, pSecurityObjects: PSECURITY_OBJECT, dwSecurityObjectCount: DWORD, pUserGroups: PTOKEN_GROUPS, pAuthzUserGroupsOperations: PAUTHZ_SID_OPERATION, pDeviceGroups: PTOKEN_GROUPS, pAuthzDeviceGroupsOperations: PAUTHZ_SID_OPERATION, pAuthzUserClaims: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION, pAuthzUserClaimsOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pAuthzDeviceClaims: PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION, pAuthzDeviceClaimsOperations: PAUTHZ_SECURITY_ATTRIBUTE_OPERATION, pEffpermResultLists: PEFFPERM_RESULT_LIST): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComputeEffectivePermissionWithSecondarySecurity(self, pSid, pDeviceSid, pszServerName, pSecurityObjects, dwSecurityObjectCount, pUserGroups, pAuthzUserGroupsOperations, pDeviceGroups, pAuthzDeviceGroupsOperations, pAuthzUserClaims, pAuthzUserClaimsOperations, pAuthzDeviceClaims, pAuthzDeviceClaimsOperations, pEffpermResultLists) +converter winimConverterISecurityInformationToIUnknown*(x: ptr ISecurityInformation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISecurityInformation2ToIUnknown*(x: ptr ISecurityInformation2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEffectivePermissionToIUnknown*(x: ptr IEffectivePermission): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISecurityObjectTypeInfoToIUnknown*(x: ptr ISecurityObjectTypeInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISecurityInformation3ToIUnknown*(x: ptr ISecurityInformation3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISecurityInformation4ToIUnknown*(x: ptr ISecurityInformation4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEffectivePermission2ToIUnknown*(x: ptr IEffectivePermission2): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + OBJECTS_AND_NAME* = OBJECTS_AND_NAME_W + POBJECTS_AND_NAME* = POBJECTS_AND_NAME_W + TRUSTEE* = TRUSTEE_W + PTRUSTEE* = PTRUSTEE_W + EXPLICIT_ACCESS* = EXPLICIT_ACCESS_W + PEXPLICIT_ACCESS* = PEXPLICIT_ACCESS_W + ACTRL_ACCESS_ENTRY* = ACTRL_ACCESS_ENTRYW + PACTRL_ACCESS_ENTRY* = PACTRL_ACCESS_ENTRYW + ACTRL_ACCESS_ENTRY_LIST* = ACTRL_ACCESS_ENTRY_LISTW + PACTRL_ACCESS_ENTRY_LIST* = PACTRL_ACCESS_ENTRY_LISTW + ACTRL_PROPERTY_ENTRY* = ACTRL_PROPERTY_ENTRYW + PACTRL_PROPERTY_ENTRY* = PACTRL_PROPERTY_ENTRYW + ACTRL_ACCESS* = ACTRL_ACCESSW + PACTRL_ACCESS* = PACTRL_ACCESSW + ACTRL_AUDIT* = ACTRL_AUDITW + PACTRL_AUDIT* = PACTRL_AUDITW + TRUSTEE_ACCESS* = TRUSTEE_ACCESSW + PTRUSTEE_ACCESS* = PTRUSTEE_ACCESSW + ACTRL_ACCESS_INFO* = ACTRL_ACCESS_INFOW + PACTRL_ACCESS_INFO* = PACTRL_ACCESS_INFOW + ACTRL_CONTROL_INFO* = ACTRL_CONTROL_INFOW + PACTRL_CONTROL_INFO* = PACTRL_CONTROL_INFOW + INHERITED_FROM* = INHERITED_FROMW + const + ACCCTRL_DEFAULT_PROVIDER* = ACCCTRL_DEFAULT_PROVIDERW + proc SetEntriesInAcl*(cCountOfExplicitEntries: ULONG, pListOfExplicitEntries: PEXPLICIT_ACCESS_W, OldAcl: PACL, NewAcl: ptr PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "SetEntriesInAclW".} + proc GetExplicitEntriesFromAcl*(pacl: PACL, pcCountOfExplicitEntries: PULONG, pListOfExplicitEntries: ptr PEXPLICIT_ACCESS_W): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetExplicitEntriesFromAclW".} + proc GetEffectiveRightsFromAcl*(pacl: PACL, pTrustee: PTRUSTEE_W, pAccessRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetEffectiveRightsFromAclW".} + proc GetAuditedPermissionsFromAcl*(pacl: PACL, pTrustee: PTRUSTEE_W, pSuccessfulAuditedRights: PACCESS_MASK, pFailedAuditRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetAuditedPermissionsFromAclW".} + proc GetNamedSecurityInfo*(pObjectName: LPCWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, ppsidOwner: ptr PSID, ppsidGroup: ptr PSID, ppDacl: ptr PACL, ppSacl: ptr PACL, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetNamedSecurityInfoW".} + proc SetNamedSecurityInfo*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, psidOwner: PSID, psidGroup: PSID, pDacl: PACL, pSacl: PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "SetNamedSecurityInfoW".} + proc GetInheritanceSource*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, Container: WINBOOL, pObjectClassGuids: ptr ptr GUID, GuidCount: DWORD, pAcl: PACL, pfnArray: PFN_OBJECT_MGR_FUNCTS, pGenericMapping: PGENERIC_MAPPING, pInheritArray: PINHERITED_FROMW): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetInheritanceSourceW".} + proc TreeResetNamedSecurityInfo*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, KeepExplicit: WINBOOL, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "TreeResetNamedSecurityInfoW".} + proc BuildSecurityDescriptor*(pOwner: PTRUSTEE_W, pGroup: PTRUSTEE_W, cCountOfAccessEntries: ULONG, pListOfAccessEntries: PEXPLICIT_ACCESS_W, cCountOfAuditEntries: ULONG, pListOfAuditEntries: PEXPLICIT_ACCESS_W, pOldSD: PSECURITY_DESCRIPTOR, pSizeNewSD: PULONG, pNewSD: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "BuildSecurityDescriptorW".} + proc LookupSecurityDescriptorParts*(ppOwner: ptr PTRUSTEE_W, ppGroup: ptr PTRUSTEE_W, pcCountOfAccessEntries: PULONG, ppListOfAccessEntries: ptr PEXPLICIT_ACCESS_W, pcCountOfAuditEntries: PULONG, ppListOfAuditEntries: ptr PEXPLICIT_ACCESS_W, pSD: PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "LookupSecurityDescriptorPartsW".} + proc BuildExplicitAccessWithName*(pExplicitAccess: PEXPLICIT_ACCESS_W, pTrusteeName: LPWSTR, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildExplicitAccessWithNameW".} + proc BuildImpersonateExplicitAccessWithName*(pExplicitAccess: PEXPLICIT_ACCESS_W, pTrusteeName: LPWSTR, pTrustee: PTRUSTEE_W, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildImpersonateExplicitAccessWithNameW".} + proc BuildTrusteeWithName*(pTrustee: PTRUSTEE_W, pName: LPWSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithNameW".} + proc BuildImpersonateTrustee*(pTrustee: PTRUSTEE_W, pImpersonateTrustee: PTRUSTEE_W): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildImpersonateTrusteeW".} + proc BuildTrusteeWithSid*(pTrustee: PTRUSTEE_W, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithSidW".} + proc BuildTrusteeWithObjectsAndSid*(pTrustee: PTRUSTEE_W, pObjSid: POBJECTS_AND_SID, pObjectGuid: ptr GUID, pInheritedObjectGuid: ptr GUID, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithObjectsAndSidW".} + proc BuildTrusteeWithObjectsAndName*(pTrustee: PTRUSTEE_W, pObjName: POBJECTS_AND_NAME_W, ObjectType: SE_OBJECT_TYPE, ObjectTypeName: LPWSTR, InheritedObjectTypeName: LPWSTR, Name: LPWSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithObjectsAndNameW".} + proc GetTrusteeName*(pTrustee: PTRUSTEE_W): LPWSTR {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeNameW".} + proc GetTrusteeType*(pTrustee: PTRUSTEE_W): TRUSTEE_TYPE {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeTypeW".} + proc GetTrusteeForm*(pTrustee: PTRUSTEE_W): TRUSTEE_FORM {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeFormW".} + proc GetMultipleTrusteeOperation*(pTrustee: PTRUSTEE_W): MULTIPLE_TRUSTEE_OPERATION {.winapi, stdcall, dynlib: "advapi32", importc: "GetMultipleTrusteeOperationW".} + proc GetMultipleTrustee*(pTrustee: PTRUSTEE_W): PTRUSTEE_W {.winapi, stdcall, dynlib: "advapi32", importc: "GetMultipleTrusteeW".} + proc TreeSetNamedSecurityInfo*(pObjectName: LPWSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, dwAction: DWORD, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "TreeSetNamedSecurityInfoW".} +when winimAnsi: + type + OBJECTS_AND_NAME* = OBJECTS_AND_NAME_A + POBJECTS_AND_NAME* = POBJECTS_AND_NAME_A + TRUSTEE* = TRUSTEE_A + PTRUSTEE* = PTRUSTEE_A + EXPLICIT_ACCESS* = EXPLICIT_ACCESS_A + PEXPLICIT_ACCESS* = PEXPLICIT_ACCESS_A + ACTRL_ACCESS_ENTRY* = ACTRL_ACCESS_ENTRYA + PACTRL_ACCESS_ENTRY* = PACTRL_ACCESS_ENTRYA + ACTRL_ACCESS_ENTRY_LIST* = ACTRL_ACCESS_ENTRY_LISTA + PACTRL_ACCESS_ENTRY_LIST* = PACTRL_ACCESS_ENTRY_LISTA + ACTRL_PROPERTY_ENTRY* = ACTRL_PROPERTY_ENTRYA + PACTRL_PROPERTY_ENTRY* = PACTRL_PROPERTY_ENTRYA + ACTRL_ACCESS* = ACTRL_ACCESSA + PACTRL_ACCESS* = PACTRL_ACCESSA + ACTRL_AUDIT* = ACTRL_AUDITA + PACTRL_AUDIT* = PACTRL_AUDITA + TRUSTEE_ACCESS* = TRUSTEE_ACCESSA + PTRUSTEE_ACCESS* = PTRUSTEE_ACCESSA + ACTRL_ACCESS_INFO* = ACTRL_ACCESS_INFOA + PACTRL_ACCESS_INFO* = PACTRL_ACCESS_INFOA + ACTRL_CONTROL_INFO* = ACTRL_CONTROL_INFOA + PACTRL_CONTROL_INFO* = PACTRL_CONTROL_INFOA + INHERITED_FROM* = INHERITED_FROMA + const + ACCCTRL_DEFAULT_PROVIDER* = ACCCTRL_DEFAULT_PROVIDERA + proc SetEntriesInAcl*(cCountOfExplicitEntries: ULONG, pListOfExplicitEntries: PEXPLICIT_ACCESS_A, OldAcl: PACL, NewAcl: ptr PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "SetEntriesInAclA".} + proc GetExplicitEntriesFromAcl*(pacl: PACL, pcCountOfExplicitEntries: PULONG, pListOfExplicitEntries: ptr PEXPLICIT_ACCESS_A): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetExplicitEntriesFromAclA".} + proc GetEffectiveRightsFromAcl*(pacl: PACL, pTrustee: PTRUSTEE_A, pAccessRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetEffectiveRightsFromAclA".} + proc GetAuditedPermissionsFromAcl*(pacl: PACL, pTrustee: PTRUSTEE_A, pSuccessfulAuditedRights: PACCESS_MASK, pFailedAuditRights: PACCESS_MASK): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetAuditedPermissionsFromAclA".} + proc GetNamedSecurityInfo*(pObjectName: LPCSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, ppsidOwner: ptr PSID, ppsidGroup: ptr PSID, ppDacl: ptr PACL, ppSacl: ptr PACL, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetNamedSecurityInfoA".} + proc SetNamedSecurityInfo*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, psidOwner: PSID, psidGroup: PSID, pDacl: PACL, pSacl: PACL): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "SetNamedSecurityInfoA".} + proc GetInheritanceSource*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, Container: WINBOOL, pObjectClassGuids: ptr ptr GUID, GuidCount: DWORD, pAcl: PACL, pfnArray: PFN_OBJECT_MGR_FUNCTS, pGenericMapping: PGENERIC_MAPPING, pInheritArray: PINHERITED_FROMA): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "GetInheritanceSourceA".} + proc TreeResetNamedSecurityInfo*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, KeepExplicit: WINBOOL, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "TreeResetNamedSecurityInfoA".} + proc BuildSecurityDescriptor*(pOwner: PTRUSTEE_A, pGroup: PTRUSTEE_A, cCountOfAccessEntries: ULONG, pListOfAccessEntries: PEXPLICIT_ACCESS_A, cCountOfAuditEntries: ULONG, pListOfAuditEntries: PEXPLICIT_ACCESS_A, pOldSD: PSECURITY_DESCRIPTOR, pSizeNewSD: PULONG, pNewSD: ptr PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "BuildSecurityDescriptorA".} + proc LookupSecurityDescriptorParts*(ppOwner: ptr PTRUSTEE_A, ppGroup: ptr PTRUSTEE_A, pcCountOfAccessEntries: PULONG, ppListOfAccessEntries: ptr PEXPLICIT_ACCESS_A, pcCountOfAuditEntries: PULONG, ppListOfAuditEntries: ptr PEXPLICIT_ACCESS_A, pSD: PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "LookupSecurityDescriptorPartsA".} + proc BuildExplicitAccessWithName*(pExplicitAccess: PEXPLICIT_ACCESS_A, pTrusteeName: LPSTR, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildExplicitAccessWithNameA".} + proc BuildImpersonateExplicitAccessWithName*(pExplicitAccess: PEXPLICIT_ACCESS_A, pTrusteeName: LPSTR, pTrustee: PTRUSTEE_A, AccessPermissions: DWORD, AccessMode: ACCESS_MODE, Inheritance: DWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildImpersonateExplicitAccessWithNameA".} + proc BuildTrusteeWithName*(pTrustee: PTRUSTEE_A, pName: LPSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithNameA".} + proc BuildImpersonateTrustee*(pTrustee: PTRUSTEE_A, pImpersonateTrustee: PTRUSTEE_A): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildImpersonateTrusteeA".} + proc BuildTrusteeWithSid*(pTrustee: PTRUSTEE_A, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithSidA".} + proc BuildTrusteeWithObjectsAndSid*(pTrustee: PTRUSTEE_A, pObjSid: POBJECTS_AND_SID, pObjectGuid: ptr GUID, pInheritedObjectGuid: ptr GUID, pSid: PSID): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithObjectsAndSidA".} + proc BuildTrusteeWithObjectsAndName*(pTrustee: PTRUSTEE_A, pObjName: POBJECTS_AND_NAME_A, ObjectType: SE_OBJECT_TYPE, ObjectTypeName: LPSTR, InheritedObjectTypeName: LPSTR, Name: LPSTR): VOID {.winapi, stdcall, dynlib: "advapi32", importc: "BuildTrusteeWithObjectsAndNameA".} + proc GetTrusteeName*(pTrustee: PTRUSTEE_A): LPSTR {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeNameA".} + proc GetTrusteeType*(pTrustee: PTRUSTEE_A): TRUSTEE_TYPE {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeTypeA".} + proc GetTrusteeForm*(pTrustee: PTRUSTEE_A): TRUSTEE_FORM {.winapi, stdcall, dynlib: "advapi32", importc: "GetTrusteeFormA".} + proc GetMultipleTrusteeOperation*(pTrustee: PTRUSTEE_A): MULTIPLE_TRUSTEE_OPERATION {.winapi, stdcall, dynlib: "advapi32", importc: "GetMultipleTrusteeOperationA".} + proc GetMultipleTrustee*(pTrustee: PTRUSTEE_A): PTRUSTEE_A {.winapi, stdcall, dynlib: "advapi32", importc: "GetMultipleTrusteeA".} + proc TreeSetNamedSecurityInfo*(pObjectName: LPSTR, ObjectType: SE_OBJECT_TYPE, SecurityInfo: SECURITY_INFORMATION, pOwner: PSID, pGroup: PSID, pDacl: PACL, pSacl: PACL, dwAction: DWORD, fnProgress: FN_PROGRESS, ProgressInvokeSetting: PROG_INVOKE_SETTING, Args: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "TreeSetNamedSecurityInfoA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/commctrl.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/commctrl.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,5116 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winuser +import winnls +import objbase +#include +#include +#include +type + TVITEMPART* = int32 + TASKDIALOG_FLAGS* = int32 + TASKDIALOG_MESSAGES* = int32 + TASKDIALOG_NOTIFICATIONS* = int32 + TASKDIALOG_ELEMENTS* = int32 + TASKDIALOG_ICON_ELEMENTS* = int32 + TASKDIALOG_COMMON_BUTTON_FLAGS* = int32 + MONTHDAYSTATE* = DWORD + LPMONTHDAYSTATE* = ptr DWORD + HDPA* = HANDLE + HDSA* = HANDLE + HIMAGELIST* = HANDLE + HPROPSHEETPAGE* = HANDLE + HTREEITEM* = HANDLE + PROPSHEETPAGE_RESOURCE* = LPCDLGTEMPLATE + PROPSHEETPAGEA_UNION1* {.pure, union.} = object + pszTemplate*: LPCSTR + pResource*: LPCDLGTEMPLATE + PROPSHEETPAGEA_UNION2* {.pure, union.} = object + hIcon*: HICON + pszIcon*: LPCSTR + LPFNPSPCALLBACKA* = proc (hwnd: HWND, uMsg: UINT, ppsp: ptr PROPSHEETPAGEA): UINT {.stdcall.} + PROPSHEETPAGEA* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + hInstance*: HINSTANCE + union1*: PROPSHEETPAGEA_UNION1 + union2*: PROPSHEETPAGEA_UNION2 + pszTitle*: LPCSTR + pfnDlgProc*: DLGPROC + lParam*: LPARAM + pfnCallback*: LPFNPSPCALLBACKA + pcRefParent*: ptr UINT + pszHeaderTitle*: LPCSTR + pszHeaderSubTitle*: LPCSTR + hActCtx*: HANDLE + LPPROPSHEETPAGEA* = ptr PROPSHEETPAGEA + LPCPROPSHEETPAGEA* = ptr PROPSHEETPAGEA + PROPSHEETPAGEW_UNION1* {.pure, union.} = object + pszTemplate*: LPCWSTR + pResource*: LPCDLGTEMPLATE + PROPSHEETPAGEW_UNION2* {.pure, union.} = object + hIcon*: HICON + pszIcon*: LPCWSTR + LPFNPSPCALLBACKW* = proc (hwnd: HWND, uMsg: UINT, ppsp: ptr PROPSHEETPAGEW): UINT {.stdcall.} + PROPSHEETPAGEW* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + hInstance*: HINSTANCE + union1*: PROPSHEETPAGEW_UNION1 + union2*: PROPSHEETPAGEW_UNION2 + pszTitle*: LPCWSTR + pfnDlgProc*: DLGPROC + lParam*: LPARAM + pfnCallback*: LPFNPSPCALLBACKW + pcRefParent*: ptr UINT + pszHeaderTitle*: LPCWSTR + pszHeaderSubTitle*: LPCWSTR + hActCtx*: HANDLE + LPPROPSHEETPAGEW* = ptr PROPSHEETPAGEW + LPCPROPSHEETPAGEW* = ptr PROPSHEETPAGEW + PROPSHEETHEADERA_UNION1* {.pure, union.} = object + hIcon*: HICON + pszIcon*: LPCSTR + PROPSHEETHEADERA_UNION2* {.pure, union.} = object + nStartPage*: UINT + pStartPage*: LPCSTR + PROPSHEETHEADERA_UNION3* {.pure, union.} = object + ppsp*: LPCPROPSHEETPAGEA + phpage*: ptr HPROPSHEETPAGE + PFNPROPSHEETCALLBACK* = proc (P1: HWND, P2: UINT, P3: LPARAM): int32 {.stdcall.} + PROPSHEETHEADERA_UNION4* {.pure, union.} = object + hbmWatermark*: HBITMAP + pszbmWatermark*: LPCSTR + PROPSHEETHEADERA_UNION5* {.pure, union.} = object + hbmHeader*: HBITMAP + pszbmHeader*: LPCSTR + PROPSHEETHEADERA* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + hwndParent*: HWND + hInstance*: HINSTANCE + union1*: PROPSHEETHEADERA_UNION1 + pszCaption*: LPCSTR + nPages*: UINT + union2*: PROPSHEETHEADERA_UNION2 + union3*: PROPSHEETHEADERA_UNION3 + pfnCallback*: PFNPROPSHEETCALLBACK + union4*: PROPSHEETHEADERA_UNION4 + hplWatermark*: HPALETTE + union5*: PROPSHEETHEADERA_UNION5 + LPPROPSHEETHEADERA* = ptr PROPSHEETHEADERA + LPCPROPSHEETHEADERA* = ptr PROPSHEETHEADERA + PROPSHEETHEADERW_UNION1* {.pure, union.} = object + hIcon*: HICON + pszIcon*: LPCWSTR + PROPSHEETHEADERW_UNION2* {.pure, union.} = object + nStartPage*: UINT + pStartPage*: LPCWSTR + PROPSHEETHEADERW_UNION3* {.pure, union.} = object + ppsp*: LPCPROPSHEETPAGEW + phpage*: ptr HPROPSHEETPAGE + PROPSHEETHEADERW_UNION4* {.pure, union.} = object + hbmWatermark*: HBITMAP + pszbmWatermark*: LPCWSTR + PROPSHEETHEADERW_UNION5* {.pure, union.} = object + hbmHeader*: HBITMAP + pszbmHeader*: LPCWSTR + PROPSHEETHEADERW* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + hwndParent*: HWND + hInstance*: HINSTANCE + union1*: PROPSHEETHEADERW_UNION1 + pszCaption*: LPCWSTR + nPages*: UINT + union2*: PROPSHEETHEADERW_UNION2 + union3*: PROPSHEETHEADERW_UNION3 + pfnCallback*: PFNPROPSHEETCALLBACK + union4*: PROPSHEETHEADERW_UNION4 + hplWatermark*: HPALETTE + union5*: PROPSHEETHEADERW_UNION5 + LPPROPSHEETHEADERW* = ptr PROPSHEETHEADERW + LPCPROPSHEETHEADERW* = ptr PROPSHEETHEADERW + PSHNOTIFY* {.pure.} = object + hdr*: NMHDR + lParam*: LPARAM + LPPSHNOTIFY* = ptr PSHNOTIFY + TINITCOMMONCONTROLSEX* {.pure.} = object + dwSize*: DWORD + dwICC*: DWORD + LPINITCOMMONCONTROLSEX* = ptr TINITCOMMONCONTROLSEX + COLORSCHEME* {.pure.} = object + dwSize*: DWORD + clrBtnHighlight*: COLORREF + clrBtnShadow*: COLORREF + LPCOLORSCHEME* = ptr COLORSCHEME + TNMTOOLTIPSCREATED* {.pure.} = object + hdr*: NMHDR + hwndToolTips*: HWND + LPNMTOOLTIPSCREATED* = ptr TNMTOOLTIPSCREATED + NMMOUSE* {.pure.} = object + hdr*: NMHDR + dwItemSpec*: DWORD_PTR + dwItemData*: DWORD_PTR + pt*: POINT + dwHitInfo*: LPARAM + LPNMMOUSE* = ptr NMMOUSE + TNMCLICK* = NMMOUSE + LPNMCLICK* = LPNMMOUSE + NMOBJECTNOTIFY* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + piid*: ptr IID + pObject*: pointer + hResult*: HRESULT + dwFlags*: DWORD + LPNMOBJECTNOTIFY* = ptr NMOBJECTNOTIFY + NMKEY* {.pure.} = object + hdr*: NMHDR + nVKey*: UINT + uFlags*: UINT + LPNMKEY* = ptr NMKEY + TNMCHAR* {.pure.} = object + hdr*: NMHDR + ch*: UINT + dwItemPrev*: DWORD + dwItemNext*: DWORD + LPNMCHAR* = ptr TNMCHAR + TNMCUSTOMTEXT* {.pure.} = object + hdr*: NMHDR + hDC*: HDC + lpString*: LPCWSTR + nCount*: int32 + lpRect*: LPRECT + uFormat*: UINT + fLink*: WINBOOL + LPNMCUSTOMTEXT* = ptr TNMCUSTOMTEXT + TNMCUSTOMDRAW* {.pure.} = object + hdr*: NMHDR + dwDrawStage*: DWORD + hdc*: HDC + rc*: RECT + dwItemSpec*: DWORD_PTR + uItemState*: UINT + lItemlParam*: LPARAM + LPNMCUSTOMDRAW* = ptr TNMCUSTOMDRAW + NMTTCUSTOMDRAW* {.pure.} = object + nmcd*: TNMCUSTOMDRAW + uDrawFlags*: UINT + LPNMTTCUSTOMDRAW* = ptr NMTTCUSTOMDRAW + NMCUSTOMSPLITRECTINFO* {.pure.} = object + hdr*: NMHDR + rcClient*: RECT + rcButton*: RECT + rcSplit*: RECT + LPNMCUSTOMSPLITRECTINFO* = ptr NMCUSTOMSPLITRECTINFO + IMAGELISTDRAWPARAMS* {.pure.} = object + cbSize*: DWORD + himl*: HIMAGELIST + i*: int32 + hdcDst*: HDC + x*: int32 + y*: int32 + cx*: int32 + cy*: int32 + xBitmap*: int32 + yBitmap*: int32 + rgbBk*: COLORREF + rgbFg*: COLORREF + fStyle*: UINT + dwRop*: DWORD + fState*: DWORD + Frame*: DWORD + crEffect*: COLORREF + LPIMAGELISTDRAWPARAMS* = ptr IMAGELISTDRAWPARAMS + IMAGEINFO* {.pure.} = object + hbmImage*: HBITMAP + hbmMask*: HBITMAP + Unused1*: int32 + Unused2*: int32 + rcImage*: RECT + LPIMAGEINFO* = ptr IMAGEINFO + HD_TEXTFILTERA* {.pure.} = object + pszText*: LPSTR + cchTextMax*: INT + LPHD_TEXTFILTERA* = ptr HD_TEXTFILTERA + HD_TEXTFILTERW* {.pure.} = object + pszText*: LPWSTR + cchTextMax*: INT + LPHD_TEXTFILTERW* = ptr HD_TEXTFILTERW + HDITEMA* {.pure.} = object + mask*: UINT + cxy*: int32 + pszText*: LPSTR + hbm*: HBITMAP + cchTextMax*: int32 + fmt*: int32 + lParam*: LPARAM + iImage*: int32 + iOrder*: int32 + `type`*: UINT + pvFilter*: pointer + state*: UINT + LPHDITEMA* = ptr HDITEMA + HDITEMW* {.pure.} = object + mask*: UINT + cxy*: int32 + pszText*: LPWSTR + hbm*: HBITMAP + cchTextMax*: int32 + fmt*: int32 + lParam*: LPARAM + iImage*: int32 + iOrder*: int32 + `type`*: UINT + pvFilter*: pointer + state*: UINT + LPHDITEMW* = ptr HDITEMW + HDLAYOUT* {.pure.} = object + prc*: ptr RECT + pwpos*: ptr WINDOWPOS + LPHDLAYOUT* = ptr HDLAYOUT + HDHITTESTINFO* {.pure.} = object + pt*: POINT + flags*: UINT + iItem*: int32 + LPHDHITTESTINFO* = ptr HDHITTESTINFO + NMHEADERA* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + iButton*: int32 + pitem*: ptr HDITEMA + HD_NOTIFYA* = NMHEADERA + NMHEADERW* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + iButton*: int32 + pitem*: ptr HDITEMW + HD_NOTIFYW* = NMHEADERW +when winimUnicode: + type + NMHEADER* = NMHEADERW +when winimAnsi: + type + NMHEADER* = NMHEADERA +type + HD_NOTIFY* = NMHEADER + LPNMHEADERA* = ptr NMHEADERA + LPNMHEADERW* = ptr NMHEADERW + NMHDDISPINFOW* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + mask*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + LPNMHDDISPINFOW* = ptr NMHDDISPINFOW + NMHDDISPINFOA* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + mask*: UINT + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + LPNMHDDISPINFOA* = ptr NMHDDISPINFOA + NMHDFILTERBTNCLICK* {.pure.} = object + hdr*: NMHDR + iItem*: INT + rc*: RECT + LPNMHDFILTERBTNCLICK* = ptr NMHDFILTERBTNCLICK +when winimCpu64: + type + TBBUTTON* {.pure.} = object + iBitmap*: int32 + idCommand*: int32 + fsState*: BYTE + fsStyle*: BYTE + bReserved*: array[6, BYTE] + dwData*: DWORD_PTR + iString*: INT_PTR +when winimCpu32: + type + TBBUTTON* {.pure.} = object + iBitmap*: int32 + idCommand*: int32 + fsState*: BYTE + fsStyle*: BYTE + bReserved*: array[2, BYTE] + dwData*: DWORD_PTR + iString*: INT_PTR +type + LPCTBBUTTON* = ptr TBBUTTON + COLORMAP* {.pure.} = object + `from`*: COLORREF + to*: COLORREF + LPCOLORMAP* = ptr COLORMAP + NMTBCUSTOMDRAW* {.pure.} = object + nmcd*: TNMCUSTOMDRAW + hbrMonoDither*: HBRUSH + hbrLines*: HBRUSH + hpenLines*: HPEN + clrText*: COLORREF + clrMark*: COLORREF + clrTextHighlight*: COLORREF + clrBtnFace*: COLORREF + clrBtnHighlight*: COLORREF + clrHighlightHotTrack*: COLORREF + rcText*: RECT + nStringBkMode*: int32 + nHLStringBkMode*: int32 + iListGap*: int32 + LPNMTBCUSTOMDRAW* = ptr NMTBCUSTOMDRAW + TTBADDBITMAP* {.pure.} = object + hInst*: HINSTANCE + nID*: UINT_PTR + LPTBADDBITMAP* = ptr TTBADDBITMAP + TBSAVEPARAMSA* {.pure.} = object + hkr*: HKEY + pszSubKey*: LPCSTR + pszValueName*: LPCSTR + LPTBSAVEPARAMSA* = ptr TBSAVEPARAMSA + TBSAVEPARAMSW* {.pure.} = object + hkr*: HKEY + pszSubKey*: LPCWSTR + pszValueName*: LPCWSTR + LPTBSAVEPARAMW* = ptr TBSAVEPARAMSW + TBINSERTMARK* {.pure.} = object + iButton*: int32 + dwFlags*: DWORD + LPTBINSERTMARK* = ptr TBINSERTMARK + TTBREPLACEBITMAP* {.pure.} = object + hInstOld*: HINSTANCE + nIDOld*: UINT_PTR + hInstNew*: HINSTANCE + nIDNew*: UINT_PTR + nButtons*: int32 + LPTBREPLACEBITMAP* = ptr TTBREPLACEBITMAP + TBBUTTONINFOA* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + idCommand*: int32 + iImage*: int32 + fsState*: BYTE + fsStyle*: BYTE + cx*: WORD + lParam*: DWORD_PTR + pszText*: LPSTR + cchText*: int32 + LPTBBUTTONINFOA* = ptr TBBUTTONINFOA + TBBUTTONINFOW* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + idCommand*: int32 + iImage*: int32 + fsState*: BYTE + fsStyle*: BYTE + cx*: WORD + lParam*: DWORD_PTR + pszText*: LPWSTR + cchText*: int32 + LPTBBUTTONINFOW* = ptr TBBUTTONINFOW + TBMETRICS* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + cxPad*: int32 + cyPad*: int32 + cxBarPad*: int32 + cyBarPad*: int32 + cxButtonSpacing*: int32 + cyButtonSpacing*: int32 + LPTBMETRICS* = ptr TBMETRICS + NMTBHOTITEM* {.pure.} = object + hdr*: NMHDR + idOld*: int32 + idNew*: int32 + dwFlags*: DWORD + LPNMTBHOTITEM* = ptr NMTBHOTITEM + NMTBSAVE* {.pure.} = object + hdr*: NMHDR + pData*: ptr DWORD + pCurrent*: ptr DWORD + cbData*: UINT + iItem*: int32 + cButtons*: int32 + tbButton*: TBBUTTON + LPNMTBSAVE* = ptr NMTBSAVE + NMTBRESTORE* {.pure.} = object + hdr*: NMHDR + pData*: ptr DWORD + pCurrent*: ptr DWORD + cbData*: UINT + iItem*: int32 + cButtons*: int32 + cbBytesPerRecord*: int32 + tbButton*: TBBUTTON + LPNMTBRESTORE* = ptr NMTBRESTORE + NMTBGETINFOTIPA* {.pure.} = object + hdr*: NMHDR + pszText*: LPSTR + cchTextMax*: int32 + iItem*: int32 + lParam*: LPARAM + LPNMTBGETINFOTIPA* = ptr NMTBGETINFOTIPA + NMTBGETINFOTIPW* {.pure.} = object + hdr*: NMHDR + pszText*: LPWSTR + cchTextMax*: int32 + iItem*: int32 + lParam*: LPARAM + LPNMTBGETINFOTIPW* = ptr NMTBGETINFOTIPW + NMTBDISPINFOA* {.pure.} = object + hdr*: NMHDR + dwMask*: DWORD + idCommand*: int32 + lParam*: DWORD_PTR + iImage*: int32 + pszText*: LPSTR + cchText*: int32 + LPNMTBDISPINFOA* = ptr NMTBDISPINFOA + NMTBDISPINFOW* {.pure.} = object + hdr*: NMHDR + dwMask*: DWORD + idCommand*: int32 + lParam*: DWORD_PTR + iImage*: int32 + pszText*: LPWSTR + cchText*: int32 + LPNMTBDISPINFOW* = ptr NMTBDISPINFOW + NMTOOLBARA* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + tbButton*: TBBUTTON + cchText*: int32 + pszText*: LPSTR + rcButton*: RECT + TBNOTIFYA* = NMTOOLBARA + NMTOOLBARW* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + tbButton*: TBBUTTON + cchText*: int32 + pszText*: LPWSTR + rcButton*: RECT + TBNOTIFYW* = NMTOOLBARW + LPNMTOOLBARA* = ptr NMTOOLBARA + LPTBNOTIFYA* = LPNMTOOLBARA + LPNMTOOLBARW* = ptr NMTOOLBARW + LPTBNOTIFYW* = LPNMTOOLBARW +when winimUnicode: + type + NMTOOLBAR* = NMTOOLBARW +when winimAnsi: + type + NMTOOLBAR* = NMTOOLBARA +type + TBNOTIFY* = NMTOOLBAR +when winimUnicode: + type + LPNMTOOLBAR* = LPNMTOOLBARW +when winimAnsi: + type + LPNMTOOLBAR* = LPNMTOOLBARA +type + LPTBNOTIFY* = LPNMTOOLBAR + REBARINFO* {.pure.} = object + cbSize*: UINT + fMask*: UINT + himl*: HIMAGELIST + LPREBARINFO* = ptr REBARINFO + REBARBANDINFOA* {.pure.} = object + cbSize*: UINT + fMask*: UINT + fStyle*: UINT + clrFore*: COLORREF + clrBack*: COLORREF + lpText*: LPSTR + cch*: UINT + iImage*: int32 + hwndChild*: HWND + cxMinChild*: UINT + cyMinChild*: UINT + cx*: UINT + hbmBack*: HBITMAP + wID*: UINT + cyChild*: UINT + cyMaxChild*: UINT + cyIntegral*: UINT + cxIdeal*: UINT + lParam*: LPARAM + cxHeader*: UINT + rcChevronLocation*: RECT + uChevronState*: UINT + LPREBARBANDINFOA* = ptr REBARBANDINFOA + LPCREBARBANDINFOA* = ptr REBARBANDINFOA + REBARBANDINFOW* {.pure.} = object + cbSize*: UINT + fMask*: UINT + fStyle*: UINT + clrFore*: COLORREF + clrBack*: COLORREF + lpText*: LPWSTR + cch*: UINT + iImage*: int32 + hwndChild*: HWND + cxMinChild*: UINT + cyMinChild*: UINT + cx*: UINT + hbmBack*: HBITMAP + wID*: UINT + cyChild*: UINT + cyMaxChild*: UINT + cyIntegral*: UINT + cxIdeal*: UINT + lParam*: LPARAM + cxHeader*: UINT + rcChevronLocation*: RECT + uChevronState*: UINT + LPREBARBANDINFOW* = ptr REBARBANDINFOW + LPCREBARBANDINFOW* = ptr REBARBANDINFOW + NMREBARCHILDSIZE* {.pure.} = object + hdr*: NMHDR + uBand*: UINT + wID*: UINT + rcChild*: RECT + rcBand*: RECT + LPNMREBARCHILDSIZE* = ptr NMREBARCHILDSIZE + NMREBAR* {.pure.} = object + hdr*: NMHDR + dwMask*: DWORD + uBand*: UINT + fStyle*: UINT + wID*: UINT + lParam*: LPARAM + LPNMREBAR* = ptr NMREBAR + NMRBAUTOSIZE* {.pure.} = object + hdr*: NMHDR + fChanged*: WINBOOL + rcTarget*: RECT + rcActual*: RECT + LPNMRBAUTOSIZE* = ptr NMRBAUTOSIZE + NMREBARCHEVRON* {.pure.} = object + hdr*: NMHDR + uBand*: UINT + wID*: UINT + lParam*: LPARAM + rc*: RECT + lParamNM*: LPARAM + LPNMREBARCHEVRON* = ptr NMREBARCHEVRON + NMREBARSPLITTER* {.pure.} = object + hdr*: NMHDR + rcSizing*: RECT + LPNMREBARSPLITTER* = ptr NMREBARSPLITTER + NMREBARAUTOBREAK* {.pure.} = object + hdr*: NMHDR + uBand*: UINT + wID*: UINT + lParam*: LPARAM + uMsg*: UINT + fStyleCurrent*: UINT + fAutoBreak*: WINBOOL + LPNMREBARAUTOBREAK* = ptr NMREBARAUTOBREAK + RBHITTESTINFO* {.pure.} = object + pt*: POINT + flags*: UINT + iBand*: int32 + LPRBHITTESTINFO* = ptr RBHITTESTINFO + TTTOOLINFOA* {.pure.} = object + cbSize*: UINT + uFlags*: UINT + hwnd*: HWND + uId*: UINT_PTR + rect*: RECT + hinst*: HINSTANCE + lpszText*: LPSTR + lParam*: LPARAM + lpReserved*: pointer + LPTTTOOLINFOA* = ptr TTTOOLINFOA + LPTOOLINFOA* = LPTTTOOLINFOA + TTTOOLINFOW* {.pure.} = object + cbSize*: UINT + uFlags*: UINT + hwnd*: HWND + uId*: UINT_PTR + rect*: RECT + hinst*: HINSTANCE + lpszText*: LPWSTR + lParam*: LPARAM + lpReserved*: pointer + LPTTTOOLINFOW* = ptr TTTOOLINFOW + LPTOOLINFOW* = LPTTTOOLINFOW + TOOLINFOA* = TTTOOLINFOA + TOOLINFOW* = TTTOOLINFOW +when winimUnicode: + type + LPTTTOOLINFO* = LPTTTOOLINFOW +when winimAnsi: + type + LPTTTOOLINFO* = LPTTTOOLINFOA +type + LPTOOLINFO* = LPTTTOOLINFO + PTOOLINFOA* = ptr TTTOOLINFOA + PTOOLINFOW* = ptr TTTOOLINFOW + TTGETTITLE* {.pure.} = object + dwSize*: DWORD + uTitleBitmap*: UINT + cch*: UINT + pszTitle*: ptr WCHAR + PTTGETTITLE* = ptr TTGETTITLE + TTHITTESTINFOW* {.pure.} = object + hwnd*: HWND + pt*: POINT + ti*: TTTOOLINFOW + LPTTHITTESTINFOW* = ptr TTHITTESTINFOW + LPHITTESTINFOW* = LPTTHITTESTINFOW + TTHITTESTINFOA* {.pure.} = object + hwnd*: HWND + pt*: POINT + ti*: TTTOOLINFOA + LPTTHITTESTINFOA* = ptr TTHITTESTINFOA + LPHITTESTINFOA* = LPTTHITTESTINFOA +when winimUnicode: + type + LPTTHITTESTINFO* = LPTTHITTESTINFOW +when winimAnsi: + type + LPTTHITTESTINFO* = LPTTHITTESTINFOA +type + LPHITTESTINFO* = LPTTHITTESTINFO + NMTTDISPINFOW* {.pure.} = object + hdr*: NMHDR + lpszText*: LPWSTR + szText*: array[80, WCHAR] + hinst*: HINSTANCE + uFlags*: UINT + lParam*: LPARAM + TOOLTIPTEXTW* = NMTTDISPINFOW + NMTTDISPINFOA* {.pure.} = object + hdr*: NMHDR + lpszText*: LPSTR + szText*: array[80, char] + hinst*: HINSTANCE + uFlags*: UINT + lParam*: LPARAM + TOOLTIPTEXTA* = NMTTDISPINFOA + LPNMTTDISPINFOA* = ptr NMTTDISPINFOA + LPTOOLTIPTEXTA* = LPNMTTDISPINFOA + LPNMTTDISPINFOW* = ptr NMTTDISPINFOW + LPTOOLTIPTEXTW* = LPNMTTDISPINFOW +when winimUnicode: + type + NMTTDISPINFO* = NMTTDISPINFOW +when winimAnsi: + type + NMTTDISPINFO* = NMTTDISPINFOA +type + TOOLTIPTEXT* = NMTTDISPINFO +when winimUnicode: + type + LPNMTTDISPINFO* = LPNMTTDISPINFOW +when winimAnsi: + type + LPNMTTDISPINFO* = LPNMTTDISPINFOA +type + LPTOOLTIPTEXT* = LPNMTTDISPINFO + DRAGLISTINFO* {.pure.} = object + uNotification*: UINT + hWnd*: HWND + ptCursor*: POINT + LPDRAGLISTINFO* = ptr DRAGLISTINFO + UDACCEL* {.pure.} = object + nSec*: UINT + nInc*: UINT + LPUDACCEL* = ptr UDACCEL + NMUPDOWN* {.pure.} = object + hdr*: NMHDR + iPos*: int32 + iDelta*: int32 + LPNMUPDOWN* = ptr NMUPDOWN + PBRANGE* {.pure.} = object + iLow*: int32 + iHigh*: int32 + PPBRANGE* = ptr PBRANGE +const + MAX_LINKID_TEXT* = 48 + L_MAX_URL_LENGTH* = 2084 +type + LITEM* {.pure.} = object + mask*: UINT + iLink*: int32 + state*: UINT + stateMask*: UINT + szID*: array[MAX_LINKID_TEXT, WCHAR] + szUrl*: array[L_MAX_URL_LENGTH, WCHAR] + PLITEM* = ptr LITEM + LHITTESTINFO* {.pure.} = object + pt*: POINT + item*: LITEM + PLHITTESTINFO* = ptr LHITTESTINFO + NMLINK* {.pure.} = object + hdr*: NMHDR + item*: LITEM + PNMLINK* = ptr NMLINK + LVITEMA* {.pure.} = object + mask*: UINT + iItem*: int32 + iSubItem*: int32 + state*: UINT + stateMask*: UINT + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + iIndent*: int32 + iGroupId*: int32 + cColumns*: UINT + puColumns*: PUINT + piColFmt*: ptr int32 + iGroup*: int32 + LPLVITEMA* = ptr LVITEMA + LVITEMW* {.pure.} = object + mask*: UINT + iItem*: int32 + iSubItem*: int32 + state*: UINT + stateMask*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + iIndent*: int32 + iGroupId*: int32 + cColumns*: UINT + puColumns*: PUINT + piColFmt*: ptr int32 + iGroup*: int32 + LPLVITEMW* = ptr LVITEMW + LVFINDINFOA* {.pure.} = object + flags*: UINT + psz*: LPCSTR + lParam*: LPARAM + pt*: POINT + vkDirection*: UINT + LPFINDINFOA* = ptr LVFINDINFOA + LVFINDINFOW* {.pure.} = object + flags*: UINT + psz*: LPCWSTR + lParam*: LPARAM + pt*: POINT + vkDirection*: UINT + LPFINDINFOW* = ptr LVFINDINFOW + LVHITTESTINFO* {.pure.} = object + pt*: POINT + flags*: UINT + iItem*: int32 + iSubItem*: int32 + iGroup*: int32 + LPLVHITTESTINFO* = ptr LVHITTESTINFO + LVCOLUMNA* {.pure.} = object + mask*: UINT + fmt*: int32 + cx*: int32 + pszText*: LPSTR + cchTextMax*: int32 + iSubItem*: int32 + iImage*: int32 + iOrder*: int32 + cxMin*: int32 + cxDefault*: int32 + cxIdeal*: int32 + LPLVCOLUMNA* = ptr LVCOLUMNA + LVCOLUMNW* {.pure.} = object + mask*: UINT + fmt*: int32 + cx*: int32 + pszText*: LPWSTR + cchTextMax*: int32 + iSubItem*: int32 + iImage*: int32 + iOrder*: int32 + cxMin*: int32 + cxDefault*: int32 + cxIdeal*: int32 + LPLVCOLUMNW* = ptr LVCOLUMNW + LVBKIMAGEA* {.pure.} = object + ulFlags*: ULONG + hbm*: HBITMAP + pszImage*: LPSTR + cchImageMax*: UINT + xOffsetPercent*: int32 + yOffsetPercent*: int32 + LPLVBKIMAGEA* = ptr LVBKIMAGEA + LVBKIMAGEW* {.pure.} = object + ulFlags*: ULONG + hbm*: HBITMAP + pszImage*: LPWSTR + cchImageMax*: UINT + xOffsetPercent*: int32 + yOffsetPercent*: int32 + LPLVBKIMAGEW* = ptr LVBKIMAGEW + LVGROUP* {.pure.} = object + cbSize*: UINT + mask*: UINT + pszHeader*: LPWSTR + cchHeader*: int32 + pszFooter*: LPWSTR + cchFooter*: int32 + iGroupId*: int32 + stateMask*: UINT + state*: UINT + uAlign*: UINT + pszSubtitle*: LPWSTR + cchSubtitle*: UINT + pszTask*: LPWSTR + cchTask*: UINT + pszDescriptionTop*: LPWSTR + cchDescriptionTop*: UINT + pszDescriptionBottom*: LPWSTR + cchDescriptionBottom*: UINT + iTitleImage*: int32 + iExtendedImage*: int32 + iFirstItem*: int32 + cItems*: UINT + pszSubsetTitle*: LPWSTR + cchSubsetTitle*: UINT + PLVGROUP* = ptr LVGROUP + LVGROUPMETRICS* {.pure.} = object + cbSize*: UINT + mask*: UINT + Left*: UINT + Top*: UINT + Right*: UINT + Bottom*: UINT + crLeft*: COLORREF + crTop*: COLORREF + crRight*: COLORREF + crBottom*: COLORREF + crHeader*: COLORREF + crFooter*: COLORREF + PLVGROUPMETRICS* = ptr LVGROUPMETRICS + PFNLVGROUPCOMPARE* = proc (P1: int32, P2: int32, P3: pointer): int32 {.stdcall.} + LVINSERTGROUPSORTED* {.pure.} = object + pfnGroupCompare*: PFNLVGROUPCOMPARE + pvData*: pointer + lvGroup*: LVGROUP + PLVINSERTGROUPSORTED* = ptr LVINSERTGROUPSORTED + LVTILEVIEWINFO* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + dwFlags*: DWORD + sizeTile*: SIZE + cLines*: int32 + rcLabelMargin*: RECT + PLVTILEVIEWINFO* = ptr LVTILEVIEWINFO + LVTILEINFO* {.pure.} = object + cbSize*: UINT + iItem*: int32 + cColumns*: UINT + puColumns*: PUINT + piColFmt*: ptr int32 + PLVTILEINFO* = ptr LVTILEINFO + LVINSERTMARK* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iItem*: int32 + dwReserved*: DWORD + LPLVINSERTMARK* = ptr LVINSERTMARK + LVSETINFOTIP* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + pszText*: LPWSTR + iItem*: int32 + iSubItem*: int32 + PLVSETINFOTIP* = ptr LVSETINFOTIP + LVFOOTERINFO* {.pure.} = object + mask*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + cItems*: UINT + LPLVFOOTERINFO* = ptr LVFOOTERINFO + LVFOOTERITEM* {.pure.} = object + mask*: UINT + iItem*: int32 + pszText*: LPWSTR + cchTextMax*: int32 + state*: UINT + stateMask*: UINT + LPLVFOOTERITEM* = ptr LVFOOTERITEM + LVITEMINDEX* {.pure.} = object + iItem*: int32 + iGroup*: int32 + PLVITEMINDEX* = ptr LVITEMINDEX + NMLISTVIEW* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + iSubItem*: int32 + uNewState*: UINT + uOldState*: UINT + uChanged*: UINT + ptAction*: POINT + lParam*: LPARAM + LPNMLISTVIEW* = ptr NMLISTVIEW + NMITEMACTIVATE* {.pure.} = object + hdr*: NMHDR + iItem*: int32 + iSubItem*: int32 + uNewState*: UINT + uOldState*: UINT + uChanged*: UINT + ptAction*: POINT + lParam*: LPARAM + uKeyFlags*: UINT + LPNMITEMACTIVATE* = ptr NMITEMACTIVATE + NMLVCUSTOMDRAW* {.pure.} = object + nmcd*: TNMCUSTOMDRAW + clrText*: COLORREF + clrTextBk*: COLORREF + iSubItem*: int32 + dwItemType*: DWORD + clrFace*: COLORREF + iIconEffect*: int32 + iIconPhase*: int32 + iPartId*: int32 + iStateId*: int32 + rcText*: RECT + uAlign*: UINT + LPNMLVCUSTOMDRAW* = ptr NMLVCUSTOMDRAW + NMLVCACHEHINT* {.pure.} = object + hdr*: NMHDR + iFrom*: int32 + iTo*: int32 + LPNMLVCACHEHINT* = ptr NMLVCACHEHINT + LPNM_CACHEHINT* = LPNMLVCACHEHINT + PNM_CACHEHINT* = LPNMLVCACHEHINT + NM_CACHEHINT* = NMLVCACHEHINT + NMLVFINDITEMA* {.pure.} = object + hdr*: NMHDR + iStart*: int32 + lvfi*: LVFINDINFOA + LPNMLVFINDITEMA* = ptr NMLVFINDITEMA + NMLVFINDITEMW* {.pure.} = object + hdr*: NMHDR + iStart*: int32 + lvfi*: LVFINDINFOW + LPNMLVFINDITEMW* = ptr NMLVFINDITEMW + PNM_FINDITEMA* = LPNMLVFINDITEMA + LPNM_FINDITEMA* = LPNMLVFINDITEMA + NM_FINDITEMA* = NMLVFINDITEMA + PNM_FINDITEMW* = LPNMLVFINDITEMW + LPNM_FINDITEMW* = LPNMLVFINDITEMW + NM_FINDITEMW* = NMLVFINDITEMW + NMLVODSTATECHANGE* {.pure.} = object + hdr*: NMHDR + iFrom*: int32 + iTo*: int32 + uNewState*: UINT + uOldState*: UINT + LPNMLVODSTATECHANGE* = ptr NMLVODSTATECHANGE + PNM_ODSTATECHANGE* = LPNMLVODSTATECHANGE + LPNM_ODSTATECHANGE* = LPNMLVODSTATECHANGE + NM_ODSTATECHANGE* = NMLVODSTATECHANGE + NMLVDISPINFOA* {.pure.} = object + hdr*: NMHDR + item*: LVITEMA + LV_DISPINFOA* = NMLVDISPINFOA + NMLVDISPINFOW* {.pure.} = object + hdr*: NMHDR + item*: LVITEMW + LV_DISPINFOW* = NMLVDISPINFOW +when winimUnicode: + type + NMLVDISPINFO* = NMLVDISPINFOW +when winimAnsi: + type + NMLVDISPINFO* = NMLVDISPINFOA +type + LV_DISPINFO* = NMLVDISPINFO + LPNMLVDISPINFOA* = ptr NMLVDISPINFOA + LPNMLVDISPINFOW* = ptr NMLVDISPINFOW + NMLVKEYDOWN* {.pure, packed.} = object + hdr*: NMHDR + wVKey*: WORD + flags*: UINT + LV_KEYDOWN* = NMLVKEYDOWN + LPNMLVKEYDOWN* = ptr NMLVKEYDOWN + NMLVLINK* {.pure.} = object + hdr*: NMHDR + link*: LITEM + iItem*: int32 + iSubItem*: int32 + PNMLVLINK* = ptr NMLVLINK + NMLVGETINFOTIPA* {.pure.} = object + hdr*: NMHDR + dwFlags*: DWORD + pszText*: LPSTR + cchTextMax*: int32 + iItem*: int32 + iSubItem*: int32 + lParam*: LPARAM + LPNMLVGETINFOTIPA* = ptr NMLVGETINFOTIPA + NMLVGETINFOTIPW* {.pure.} = object + hdr*: NMHDR + dwFlags*: DWORD + pszText*: LPWSTR + cchTextMax*: int32 + iItem*: int32 + iSubItem*: int32 + lParam*: LPARAM + LPNMLVGETINFOTIPW* = ptr NMLVGETINFOTIPW + NMLVSCROLL* {.pure.} = object + hdr*: NMHDR + dx*: int32 + dy*: int32 + LPNMLVSCROLL* = ptr NMLVSCROLL + TNMTVSTATEIMAGECHANGING* {.pure.} = object + hdr*: NMHDR + hti*: HTREEITEM + iOldStateImageIndex*: int32 + iNewStateImageIndex*: int32 + LPNMTVSTATEIMAGECHANGING* = ptr TNMTVSTATEIMAGECHANGING + TVITEMA* {.pure.} = object + mask*: UINT + hItem*: HTREEITEM + state*: UINT + stateMask*: UINT + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + cChildren*: int32 + lParam*: LPARAM + LPTVITEMA* = ptr TVITEMA + TVITEMW* {.pure.} = object + mask*: UINT + hItem*: HTREEITEM + state*: UINT + stateMask*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + cChildren*: int32 + lParam*: LPARAM + LPTVITEMW* = ptr TVITEMW + TVITEMEXA* {.pure.} = object + mask*: UINT + hItem*: HTREEITEM + state*: UINT + stateMask*: UINT + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + cChildren*: int32 + lParam*: LPARAM + iIntegral*: int32 + uStateEx*: UINT + hwnd*: HWND + iExpandedImage*: int32 + iReserved*: int32 + LPTVITEMEXA* = ptr TVITEMEXA + TVITEMEXW* {.pure.} = object + mask*: UINT + hItem*: HTREEITEM + state*: UINT + stateMask*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + cChildren*: int32 + lParam*: LPARAM + iIntegral*: int32 + uStateEx*: UINT + hwnd*: HWND + iExpandedImage*: int32 + iReserved*: int32 + LPTVITEMEXW* = ptr TVITEMEXW + TVINSERTSTRUCTA_UNION1* {.pure, union.} = object + itemex*: TVITEMEXA + item*: TV_ITEMA + TVINSERTSTRUCTA* {.pure.} = object + hParent*: HTREEITEM + hInsertAfter*: HTREEITEM + union1*: TVINSERTSTRUCTA_UNION1 + LPTVINSERTSTRUCTA* = ptr TVINSERTSTRUCTA + TVINSERTSTRUCTW_UNION1* {.pure, union.} = object + itemex*: TVITEMEXW + item*: TV_ITEMW + TVINSERTSTRUCTW* {.pure.} = object + hParent*: HTREEITEM + hInsertAfter*: HTREEITEM + union1*: TVINSERTSTRUCTW_UNION1 + LPTVINSERTSTRUCTW* = ptr TVINSERTSTRUCTW + TVHITTESTINFO* {.pure.} = object + pt*: POINT + flags*: UINT + hItem*: HTREEITEM + LPTVHITTESTINFO* = ptr TVHITTESTINFO + PFNTVCOMPARE* = proc (lParam1: LPARAM, lParam2: LPARAM, lParamSort: LPARAM): int32 {.stdcall.} + TVSORTCB* {.pure.} = object + hParent*: HTREEITEM + lpfnCompare*: PFNTVCOMPARE + lParam*: LPARAM + LPTVSORTCB* = ptr TVSORTCB + NMTREEVIEWA* {.pure.} = object + hdr*: NMHDR + action*: UINT + itemOld*: TVITEMA + itemNew*: TVITEMA + ptDrag*: POINT + LPNMTREEVIEWA* = ptr NMTREEVIEWA + NMTREEVIEWW* {.pure.} = object + hdr*: NMHDR + action*: UINT + itemOld*: TVITEMW + itemNew*: TVITEMW + ptDrag*: POINT + LPNMTREEVIEWW* = ptr NMTREEVIEWW + NMTVDISPINFOA* {.pure.} = object + hdr*: NMHDR + item*: TVITEMA + TV_DISPINFOA* = NMTVDISPINFOA + NMTVDISPINFOW* {.pure.} = object + hdr*: NMHDR + item*: TVITEMW + TV_DISPINFOW* = NMTVDISPINFOW +when winimUnicode: + type + NMTVDISPINFO* = NMTVDISPINFOW +when winimAnsi: + type + NMTVDISPINFO* = NMTVDISPINFOA +type + TV_DISPINFO* = NMTVDISPINFO + LPNMTVDISPINFOA* = ptr NMTVDISPINFOA + LPNMTVDISPINFOW* = ptr NMTVDISPINFOW + NMTVDISPINFOEXA* {.pure.} = object + hdr*: NMHDR + item*: TVITEMEXA + LPNMTVDISPINFOEXA* = ptr NMTVDISPINFOEXA + NMTVDISPINFOEXW* {.pure.} = object + hdr*: NMHDR + item*: TVITEMEXW + LPNMTVDISPINFOEXW* = ptr NMTVDISPINFOEXW + TV_DISPINFOEXA* = NMTVDISPINFOEXA + TV_DISPINFOEXW* = NMTVDISPINFOEXW +when winimUnicode: + type + NMTVDISPINFOEX* = NMTVDISPINFOEXW +when winimAnsi: + type + NMTVDISPINFOEX* = NMTVDISPINFOEXA +type + TV_DISPINFOEX* = NMTVDISPINFOEX + NMTVKEYDOWN* {.pure, packed.} = object + hdr*: NMHDR + wVKey*: WORD + flags*: UINT + TV_KEYDOWN* = NMTVKEYDOWN + LPNMTVKEYDOWN* = ptr NMTVKEYDOWN + NMTVCUSTOMDRAW* {.pure.} = object + nmcd*: TNMCUSTOMDRAW + clrText*: COLORREF + clrTextBk*: COLORREF + iLevel*: int32 + LPNMTVCUSTOMDRAW* = ptr NMTVCUSTOMDRAW + NMTVGETINFOTIPA* {.pure.} = object + hdr*: NMHDR + pszText*: LPSTR + cchTextMax*: int32 + hItem*: HTREEITEM + lParam*: LPARAM + LPNMTVGETINFOTIPA* = ptr NMTVGETINFOTIPA + NMTVGETINFOTIPW* {.pure.} = object + hdr*: NMHDR + pszText*: LPWSTR + cchTextMax*: int32 + hItem*: HTREEITEM + lParam*: LPARAM + LPNMTVGETINFOTIPW* = ptr NMTVGETINFOTIPW + COMBOBOXEXITEMA* {.pure.} = object + mask*: UINT + iItem*: INT_PTR + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + iOverlay*: int32 + iIndent*: int32 + lParam*: LPARAM + PCOMBOBOXEXITEMA* = ptr COMBOBOXEXITEMA + PCCOMBOEXITEMA* = ptr COMBOBOXEXITEMA + COMBOBOXEXITEMW* {.pure.} = object + mask*: UINT + iItem*: INT_PTR + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + iSelectedImage*: int32 + iOverlay*: int32 + iIndent*: int32 + lParam*: LPARAM + PCOMBOBOXEXITEMW* = ptr COMBOBOXEXITEMW + PCCOMBOEXITEMW* = ptr COMBOBOXEXITEMW + NMCOMBOBOXEXA* {.pure.} = object + hdr*: NMHDR + ceItem*: COMBOBOXEXITEMA + PNMCOMBOBOXEXA* = ptr NMCOMBOBOXEXA + NMCOMBOBOXEXW* {.pure.} = object + hdr*: NMHDR + ceItem*: COMBOBOXEXITEMW + PNMCOMBOBOXEXW* = ptr NMCOMBOBOXEXW +const + CBEMAXSTRLEN* = 260 +type + NMCBEDRAGBEGINW* {.pure.} = object + hdr*: NMHDR + iItemid*: int32 + szText*: array[CBEMAXSTRLEN, WCHAR] + LPNMCBEDRAGBEGINW* = ptr NMCBEDRAGBEGINW + PNMCBEDRAGBEGINW* = ptr NMCBEDRAGBEGINW + NMCBEDRAGBEGINA* {.pure.} = object + hdr*: NMHDR + iItemid*: int32 + szText*: array[CBEMAXSTRLEN, char] + LPNMCBEDRAGBEGINA* = ptr NMCBEDRAGBEGINA + PNMCBEDRAGBEGINA* = ptr NMCBEDRAGBEGINA + NMCBEENDEDITW* {.pure.} = object + hdr*: NMHDR + fChanged*: WINBOOL + iNewSelection*: int32 + szText*: array[CBEMAXSTRLEN, WCHAR] + iWhy*: int32 + LPNMCBEENDEDITW* = ptr NMCBEENDEDITW + PNMCBEENDEDITW* = ptr NMCBEENDEDITW + NMCBEENDEDITA* {.pure.} = object + hdr*: NMHDR + fChanged*: WINBOOL + iNewSelection*: int32 + szText*: array[CBEMAXSTRLEN, char] + iWhy*: int32 + LPNMCBEENDEDITA* = ptr NMCBEENDEDITA + PNMCBEENDEDITA* = ptr NMCBEENDEDITA + TCITEMHEADERA* {.pure.} = object + mask*: UINT + lpReserved1*: UINT + lpReserved2*: UINT + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + LPTCITEMHEADERA* = ptr TCITEMHEADERA + TCITEMHEADERW* {.pure.} = object + mask*: UINT + lpReserved1*: UINT + lpReserved2*: UINT + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + LPTCITEMHEADERW* = ptr TCITEMHEADERW + TCITEMA* {.pure.} = object + mask*: UINT + dwState*: DWORD + dwStateMask*: DWORD + pszText*: LPSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + LPTCITEMA* = ptr TCITEMA + TCITEMW* {.pure.} = object + mask*: UINT + dwState*: DWORD + dwStateMask*: DWORD + pszText*: LPWSTR + cchTextMax*: int32 + iImage*: int32 + lParam*: LPARAM + LPTCITEMW* = ptr TCITEMW + TCHITTESTINFO* {.pure.} = object + pt*: POINT + flags*: UINT + LPTCHITTESTINFO* = ptr TCHITTESTINFO + NMTCKEYDOWN* {.pure, packed.} = object + hdr*: NMHDR + wVKey*: WORD + flags*: UINT + TC_KEYDOWN* = NMTCKEYDOWN + MCHITTESTINFO* {.pure.} = object + cbSize*: UINT + pt*: POINT + uHit*: UINT + st*: SYSTEMTIME + rc*: RECT + iOffset*: int32 + iRow*: int32 + iCol*: int32 + PMCHITTESTINFO* = ptr MCHITTESTINFO + MCGRIDINFO* {.pure.} = object + cbSize*: UINT + dwPart*: DWORD + dwFlags*: DWORD + iCalendar*: int32 + iRow*: int32 + iCol*: int32 + bSelected*: WINBOOL + stStart*: SYSTEMTIME + stEnd*: SYSTEMTIME + rc*: RECT + pszName*: PWSTR + cchName*: int + PMCGRIDINFO* = ptr MCGRIDINFO + NMSELCHANGE* {.pure.} = object + nmhdr*: NMHDR + stSelStart*: SYSTEMTIME + stSelEnd*: SYSTEMTIME + LPNMSELCHANGE* = ptr NMSELCHANGE + NMDAYSTATE* {.pure.} = object + nmhdr*: NMHDR + stStart*: SYSTEMTIME + cDayState*: int32 + prgDayState*: LPMONTHDAYSTATE + LPNMDAYSTATE* = ptr NMDAYSTATE + NMSELECT* = NMSELCHANGE + LPNMSELECT* = ptr NMSELCHANGE + NMVIEWCHANGE* {.pure.} = object + nmhdr*: NMHDR + dwOldView*: DWORD + dwNewView*: DWORD + LPNMVIEWCHANGE* = ptr NMVIEWCHANGE + DATETIMEPICKERINFO* {.pure.} = object + cbSize*: DWORD + rcCheck*: RECT + stateCheck*: DWORD + rcButton*: RECT + stateButton*: DWORD + hwndEdit*: HWND + hwndUD*: HWND + hwndDropDown*: HWND + LPDATETIMEPICKERINFO* = ptr DATETIMEPICKERINFO + NMDATETIMECHANGE* {.pure.} = object + nmhdr*: NMHDR + dwFlags*: DWORD + st*: SYSTEMTIME + LPNMDATETIMECHANGE* = ptr NMDATETIMECHANGE + NMDATETIMESTRINGA* {.pure.} = object + nmhdr*: NMHDR + pszUserString*: LPCSTR + st*: SYSTEMTIME + dwFlags*: DWORD + LPNMDATETIMESTRINGA* = ptr NMDATETIMESTRINGA + NMDATETIMESTRINGW* {.pure.} = object + nmhdr*: NMHDR + pszUserString*: LPCWSTR + st*: SYSTEMTIME + dwFlags*: DWORD + LPNMDATETIMESTRINGW* = ptr NMDATETIMESTRINGW + NMDATETIMEWMKEYDOWNA* {.pure.} = object + nmhdr*: NMHDR + nVirtKey*: int32 + pszFormat*: LPCSTR + st*: SYSTEMTIME + LPNMDATETIMEWMKEYDOWNA* = ptr NMDATETIMEWMKEYDOWNA + NMDATETIMEWMKEYDOWNW* {.pure.} = object + nmhdr*: NMHDR + nVirtKey*: int32 + pszFormat*: LPCWSTR + st*: SYSTEMTIME + LPNMDATETIMEWMKEYDOWNW* = ptr NMDATETIMEWMKEYDOWNW + NMDATETIMEFORMATA* {.pure.} = object + nmhdr*: NMHDR + pszFormat*: LPCSTR + st*: SYSTEMTIME + pszDisplay*: LPCSTR + szDisplay*: array[64, CHAR] + LPNMDATETIMEFORMATA* = ptr NMDATETIMEFORMATA + NMDATETIMEFORMATW* {.pure.} = object + nmhdr*: NMHDR + pszFormat*: LPCWSTR + st*: SYSTEMTIME + pszDisplay*: LPCWSTR + szDisplay*: array[64, WCHAR] + LPNMDATETIMEFORMATW* = ptr NMDATETIMEFORMATW + NMDATETIMEFORMATQUERYA* {.pure.} = object + nmhdr*: NMHDR + pszFormat*: LPCSTR + szMax*: SIZE + LPNMDATETIMEFORMATQUERYA* = ptr NMDATETIMEFORMATQUERYA + NMDATETIMEFORMATQUERYW* {.pure.} = object + nmhdr*: NMHDR + pszFormat*: LPCWSTR + szMax*: SIZE + LPNMDATETIMEFORMATQUERYW* = ptr NMDATETIMEFORMATQUERYW + NMIPADDRESS* {.pure.} = object + hdr*: NMHDR + iField*: int32 + iValue*: int32 + LPNMIPADDRESS* = ptr NMIPADDRESS + NMPGSCROLL* {.pure, packed.} = object + hdr*: NMHDR + fwKeys*: WORD + rcParent*: RECT + iDir*: int32 + iXpos*: int32 + iYpos*: int32 + iScroll*: int32 + LPNMPGSCROLL* = ptr NMPGSCROLL + NMPGCALCSIZE* {.pure.} = object + hdr*: NMHDR + dwFlag*: DWORD + iWidth*: int32 + iHeight*: int32 + LPNMPGCALCSIZE* = ptr NMPGCALCSIZE + NMPGHOTITEM* {.pure.} = object + hdr*: NMHDR + idOld*: int32 + idNew*: int32 + dwFlags*: DWORD + LPNMPGHOTITEM* = ptr NMPGHOTITEM + BUTTON_IMAGELIST* {.pure.} = object + himl*: HIMAGELIST + margin*: RECT + uAlign*: UINT + PBUTTON_IMAGELIST* = ptr BUTTON_IMAGELIST + NMBCHOTITEM* {.pure.} = object + hdr*: NMHDR + dwFlags*: DWORD + LPNMBCHOTITEM* = ptr NMBCHOTITEM + BUTTON_SPLITINFO* {.pure.} = object + mask*: UINT + himlGlyph*: HIMAGELIST + uSplitStyle*: UINT + size*: SIZE + PBUTTON_SPLITINFO* = ptr BUTTON_SPLITINFO + NMBCDROPDOWN* {.pure.} = object + hdr*: NMHDR + rcButton*: RECT + LPNMBCDROPDOWN* = ptr NMBCDROPDOWN + EDITBALLOONTIP* {.pure.} = object + cbStruct*: DWORD + pszTitle*: LPCWSTR + pszText*: LPCWSTR + ttiIcon*: INT + PEDITBALLOONTIP* = ptr EDITBALLOONTIP + PFNDAENUMCALLBACK* = proc (p: pointer, pData: pointer): int32 {.stdcall.} + PFNDSAENUMCALLBACK* = PFNDAENUMCALLBACK + PFNDAENUMCALLBACKCONST* = proc (p: pointer, pData: pointer): int32 {.stdcall.} + PFNDSAENUMCALLBACKCONST* = PFNDAENUMCALLBACKCONST + PFNDACOMPARE* = proc (p1: pointer, p2: pointer, lParam: LPARAM): int32 {.stdcall.} + PFNDSACOMPARE* = PFNDACOMPARE + PFNDACOMPARECONST* = proc (p1: pointer, p2: pointer, lParam: LPARAM): int32 {.stdcall.} + PFNDSACOMPARECONST* = PFNDACOMPARECONST + PFNDPAENUMCALLBACK* = PFNDAENUMCALLBACK + PFNDPAENUMCALLBACKCONST* = PFNDAENUMCALLBACKCONST + PFNDPACOMPARE* = PFNDACOMPARE + PFNDPACOMPARECONST* = PFNDACOMPARECONST +when winimUnicode: + type + TTTOOLINFO* = TTTOOLINFOW +when winimAnsi: + type + TTTOOLINFO* = TTTOOLINFOA +type + TOOLINFO* = TTTOOLINFO +const + MAXPROPPAGES* = 100 + PSP_DEFAULT* = 0x00000000 + PSP_DLGINDIRECT* = 0x00000001 + PSP_USEHICON* = 0x00000002 + PSP_USEICONID* = 0x00000004 + PSP_USETITLE* = 0x00000008 + PSP_RTLREADING* = 0x00000010 + PSP_HASHELP* = 0x00000020 + PSP_USEREFPARENT* = 0x00000040 + PSP_USECALLBACK* = 0x00000080 + PSP_PREMATURE* = 0x00000400 + PSP_HIDEHEADER* = 0x00000800 + PSP_USEHEADERTITLE* = 0x00001000 + PSP_USEHEADERSUBTITLE* = 0x00002000 + PSP_USEFUSIONCONTEXT* = 0x00004000 + PSPCB_ADDREF* = 0 + PSPCB_RELEASE* = 1 + PSPCB_CREATE* = 2 + PSH_DEFAULT* = 0x00000000 + PSH_PROPTITLE* = 0x00000001 + PSH_USEHICON* = 0x00000002 + PSH_USEICONID* = 0x00000004 + PSH_PROPSHEETPAGE* = 0x00000008 + PSH_WIZARDHASFINISH* = 0x00000010 + PSH_WIZARD* = 0x00000020 + PSH_USEPSTARTPAGE* = 0x00000040 + PSH_NOAPPLYNOW* = 0x00000080 + PSH_USECALLBACK* = 0x00000100 + PSH_HASHELP* = 0x00000200 + PSH_MODELESS* = 0x00000400 + PSH_RTLREADING* = 0x00000800 + PSH_WIZARDCONTEXTHELP* = 0x00001000 + PSH_WIZARD97* = 0x01000000 + PSH_WATERMARK* = 0x00008000 + PSH_USEHBMWATERMARK* = 0x00010000 + PSH_USEHPLWATERMARK* = 0x00020000 + PSH_STRETCHWATERMARK* = 0x00040000 + PSH_HEADER* = 0x00080000 + PSH_USEHBMHEADER* = 0x00100000 + PSH_USEPAGELANG* = 0x00200000 + PSH_WIZARD_LITE* = 0x00400000 + PSH_NOCONTEXTHELP* = 0x02000000 + PSCB_INITIALIZED* = 1 + PSCB_PRECREATE* = 2 + PSCB_BUTTONPRESSED* = 3 + PSN_FIRST* = 0-200 + PSN_LAST* = 0-299 + PSN_SETACTIVE* = PSN_FIRST-0 + PSN_KILLACTIVE* = PSN_FIRST-1 + PSN_APPLY* = PSN_FIRST-2 + PSN_RESET* = PSN_FIRST-3 + PSN_HELP* = PSN_FIRST-5 + PSN_WIZBACK* = PSN_FIRST-6 + PSN_WIZNEXT* = PSN_FIRST-7 + PSN_WIZFINISH* = PSN_FIRST-8 + PSN_QUERYCANCEL* = PSN_FIRST-9 + PSN_GETOBJECT* = PSN_FIRST-10 + PSN_TRANSLATEACCELERATOR* = PSN_FIRST-12 + PSN_QUERYINITIALFOCUS* = PSN_FIRST-13 + PSNRET_NOERROR* = 0 + PSNRET_INVALID* = 1 + PSNRET_INVALID_NOCHANGEPAGE* = 2 + PSNRET_MESSAGEHANDLED* = 3 + PSM_SETCURSEL* = WM_USER+101 + PSM_REMOVEPAGE* = WM_USER+102 + PSM_ADDPAGE* = WM_USER+103 + PSM_CHANGED* = WM_USER+104 + PSM_RESTARTWINDOWS* = WM_USER+105 + PSM_REBOOTSYSTEM* = WM_USER+106 + PSM_CANCELTOCLOSE* = WM_USER+107 + PSM_QUERYSIBLINGS* = WM_USER+108 + PSM_UNCHANGED* = WM_USER+109 + PSM_APPLY* = WM_USER+110 + PSM_SETTITLEA* = WM_USER+111 + PSM_SETTITLEW* = WM_USER+120 + PSM_SETWIZBUTTONS* = WM_USER+112 + PSWIZB_BACK* = 0x00000001 + PSWIZB_NEXT* = 0x00000002 + PSWIZB_FINISH* = 0x00000004 + PSWIZB_DISABLEDFINISH* = 0x00000008 + PSM_PRESSBUTTON* = WM_USER+113 + PSBTN_BACK* = 0 + PSBTN_NEXT* = 1 + PSBTN_FINISH* = 2 + PSBTN_OK* = 3 + PSBTN_APPLYNOW* = 4 + PSBTN_CANCEL* = 5 + PSBTN_HELP* = 6 + PSBTN_MAX* = 6 + PSM_SETCURSELID* = WM_USER+114 + PSM_SETFINISHTEXTA* = WM_USER+115 + PSM_SETFINISHTEXTW* = WM_USER+121 + PSM_GETTABCONTROL* = WM_USER+116 + PSM_ISDIALOGMESSAGE* = WM_USER+117 + PSM_GETCURRENTPAGEHWND* = WM_USER+118 + PSM_INSERTPAGE* = WM_USER+119 + PSM_SETHEADERTITLEA* = WM_USER+125 + PSM_SETHEADERTITLEW* = WM_USER+126 + PSM_SETHEADERSUBTITLEA* = WM_USER+127 + PSM_SETHEADERSUBTITLEW* = WM_USER+128 + PSM_HWNDTOINDEX* = WM_USER+129 + PSM_INDEXTOHWND* = WM_USER+130 + PSM_PAGETOINDEX* = WM_USER+131 + PSM_INDEXTOPAGE* = WM_USER+132 + PSM_IDTOINDEX* = WM_USER+133 + PSM_INDEXTOID* = WM_USER+134 + PSM_GETRESULT* = WM_USER+135 + PSM_RECALCPAGESIZES* = WM_USER+136 + ID_PSRESTARTWINDOWS* = 0x2 + ID_PSREBOOTSYSTEM* = ID_PSRESTARTWINDOWS or 0x1 + WIZ_CXDLG* = 276 + WIZ_CYDLG* = 140 + WIZ_CXBMP* = 80 + WIZ_BODYX* = 92 + WIZ_BODYCX* = 184 + PROP_SM_CXDLG* = 212 + PROP_SM_CYDLG* = 188 + PROP_MED_CXDLG* = 227 + PROP_MED_CYDLG* = 215 + PROP_LG_CXDLG* = 252 + PROP_LG_CYDLG* = 218 + ICC_LISTVIEW_CLASSES* = 0x1 + ICC_TREEVIEW_CLASSES* = 0x2 + ICC_BAR_CLASSES* = 0x4 + ICC_TAB_CLASSES* = 0x8 + ICC_UPDOWN_CLASS* = 0x10 + ICC_PROGRESS_CLASS* = 0x20 + ICC_HOTKEY_CLASS* = 0x40 + ICC_ANIMATE_CLASS* = 0x80 + ICC_WIN95_CLASSES* = 0xff + ICC_DATE_CLASSES* = 0x100 + ICC_USEREX_CLASSES* = 0x200 + ICC_COOL_CLASSES* = 0x400 + ICC_INTERNET_CLASSES* = 0x800 + ICC_PAGESCROLLER_CLASS* = 0x1000 + ICC_NATIVEFNTCTL_CLASS* = 0x2000 + ICC_STANDARD_CLASSES* = 0x4000 + ICC_LINK_CLASS* = 0x8000 + ODT_HEADER* = 100 + ODT_TAB* = 101 + ODT_LISTVIEW* = 102 + LVM_FIRST* = 0x1000 + TV_FIRST* = 0x1100 + HDM_FIRST* = 0x1200 + TCM_FIRST* = 0x1300 + PGM_FIRST* = 0x1400 + ECM_FIRST* = 0x1500 + BCM_FIRST* = 0x1600 + CBM_FIRST* = 0x1700 + CCM_FIRST* = 0x2000 + CCM_LAST* = CCM_FIRST+0x200 + CCM_SETBKCOLOR* = CCM_FIRST+1 + CCM_SETCOLORSCHEME* = CCM_FIRST+2 + CCM_GETCOLORSCHEME* = CCM_FIRST+3 + CCM_GETDROPTARGET* = CCM_FIRST+4 + CCM_SETUNICODEFORMAT* = CCM_FIRST+5 + CCM_GETUNICODEFORMAT* = CCM_FIRST+6 + CCM_SETVERSION* = CCM_FIRST+0x7 + CCM_GETVERSION* = CCM_FIRST+0x8 + CCM_SETNOTIFYWINDOW* = CCM_FIRST+0x9 + CCM_SETWINDOWTHEME* = CCM_FIRST+0xb + CCM_DPISCALE* = CCM_FIRST+0xc + COMCTL32_VERSION* = 6 + INFOTIPSIZE* = 1024 + NM_FIRST* = 0-0 + NM_OUTOFMEMORY* = NM_FIRST-1 + NM_CLICK* = NM_FIRST-2 + NM_DBLCLK* = NM_FIRST-3 + NM_RETURN* = NM_FIRST-4 + NM_RCLICK* = NM_FIRST-5 + NM_RDBLCLK* = NM_FIRST-6 + NM_SETFOCUS* = NM_FIRST-7 + NM_KILLFOCUS* = NM_FIRST-8 + NM_CUSTOMDRAW* = NM_FIRST-12 + NM_HOVER* = NM_FIRST-13 + NM_NCHITTEST* = NM_FIRST-14 + NM_KEYDOWN* = NM_FIRST-15 + NM_RELEASEDCAPTURE* = NM_FIRST-16 + NM_SETCURSOR* = NM_FIRST-17 + NM_CHAR* = NM_FIRST-18 + NM_TOOLTIPSCREATED* = NM_FIRST-19 + NM_LDOWN* = NM_FIRST-20 + NM_RDOWN* = NM_FIRST-21 + NM_THEMECHANGED* = NM_FIRST-22 + NM_FONTCHANGED* = NM_FIRST-23 + NM_CUSTOMTEXT* = NM_FIRST-24 + NM_TVSTATEIMAGECHANGING* = NM_FIRST-24 + NM_LAST* = 0-99 + LVN_FIRST* = 0-100 + LVN_LAST* = 0-199 + HDN_FIRST* = 0-300 + HDN_LAST* = 0-399 + TVN_FIRST* = 0-400 + TVN_LAST* = 0-499 + TTN_FIRST* = 0-520 + TTN_LAST* = 0-549 + TCN_FIRST* = 0-550 + TCN_LAST* = 0-580 + CDN_FIRST* = 0-601 + CDN_LAST* = 0-699 + TBN_FIRST* = 0-700 + TBN_LAST* = 0-720 + UDN_FIRST* = 0-721 + UDN_LAST* = 0-729 + DTN_FIRST* = 0-740 + DTN_LAST* = 0-745 + MCN_FIRST* = 0-746 + MCN_LAST* = 0-752 + DTN_FIRST2* = 0-753 + DTN_LAST2* = 0-799 + CBEN_FIRST* = 0-800 + CBEN_LAST* = 0-830 + RBN_FIRST* = 0-831 + RBN_LAST* = 0-859 + IPN_FIRST* = 0-860 + IPN_LAST* = 0-879 + SBN_FIRST* = 0-880 + SBN_LAST* = 0-899 + PGN_FIRST* = 0-900 + PGN_LAST* = 0-950 + WMN_FIRST* = 0-1000 + WMN_LAST* = 0-1200 + BCN_FIRST* = 0-1250 + BCN_LAST* = 0-1350 + TRBN_FIRST* = 0-1501 + TRBN_LAST* = 0-1519 + MSGF_COMMCTRL_BEGINDRAG* = 0x4200 + MSGF_COMMCTRL_SIZEHEADER* = 0x4201 + MSGF_COMMCTRL_DRAGSELECT* = 0x4202 + MSGF_COMMCTRL_TOOLBARCUST* = 0x4203 + CDRF_DODEFAULT* = 0x0 + CDRF_NEWFONT* = 0x2 + CDRF_SKIPDEFAULT* = 0x4 + CDRF_DOERASE* = 0x8 + CDRF_SKIPPOSTPAINT* = 0x100 + CDRF_NOTIFYPOSTPAINT* = 0x10 + CDRF_NOTIFYITEMDRAW* = 0x20 + CDRF_NOTIFYSUBITEMDRAW* = 0x20 + CDRF_NOTIFYPOSTERASE* = 0x40 + CDDS_PREPAINT* = 0x1 + CDDS_POSTPAINT* = 0x2 + CDDS_PREERASE* = 0x3 + CDDS_POSTERASE* = 0x4 + CDDS_ITEM* = 0x10000 + CDDS_ITEMPREPAINT* = CDDS_ITEM or CDDS_PREPAINT + CDDS_ITEMPOSTPAINT* = CDDS_ITEM or CDDS_POSTPAINT + CDDS_ITEMPREERASE* = CDDS_ITEM or CDDS_PREERASE + CDDS_ITEMPOSTERASE* = CDDS_ITEM or CDDS_POSTERASE + CDDS_SUBITEM* = 0x20000 + CDIS_SELECTED* = 0x1 + CDIS_GRAYED* = 0x2 + CDIS_DISABLED* = 0x4 + CDIS_CHECKED* = 0x8 + CDIS_FOCUS* = 0x10 + CDIS_DEFAULT* = 0x20 + CDIS_HOT* = 0x40 + CDIS_MARKED* = 0x80 + CDIS_INDETERMINATE* = 0x100 + CDIS_SHOWKEYBOARDCUES* = 0x200 + CDIS_NEARHOT* = 0x0400 + CDIS_OTHERSIDEHOT* = 0x0800 + CDIS_DROPHILITED* = 0x1000 + NM_GETCUSTOMSPLITRECT* = BCN_FIRST+0x0003 + CLR_NONE* = 0xffffffff'i32 + CLR_DEFAULT* = 0xff000000'i32 + ILC_MASK* = 0x1 + ILC_COLOR* = 0x0 + ILC_COLORDDB* = 0xfe + ILC_COLOR4* = 0x4 + ILC_COLOR8* = 0x8 + ILC_COLOR16* = 0x10 + ILC_COLOR24* = 0x18 + ILC_COLOR32* = 0x20 + ILC_PALETTE* = 0x800 + ILC_MIRROR* = 0x2000 + ILC_PERITEMMIRROR* = 0x8000 + ILC_ORIGINALSIZE* = 0x00010000 + ILC_HIGHQUALITYSCALE* = 0x00020000 + ILD_NORMAL* = 0x0 + ILD_TRANSPARENT* = 0x1 + ILD_MASK* = 0x10 + ILD_IMAGE* = 0x20 + ILD_ROP* = 0x40 + ILD_BLEND25* = 0x2 + ILD_BLEND50* = 0x4 + ILD_OVERLAYMASK* = 0xf00 + ILD_PRESERVEALPHA* = 0x1000 + ILD_SCALE* = 0x2000 + ILD_DPISCALE* = 0x4000 + ILD_ASYNC* = 0x8000 + ILD_SELECTED* = ILD_BLEND50 + ILD_FOCUS* = ILD_BLEND25 + ILD_BLEND* = ILD_BLEND50 + CLR_HILIGHT* = CLR_DEFAULT + ILS_NORMAL* = 0x0 + ILS_GLOW* = 0x1 + ILS_SHADOW* = 0x2 + ILS_SATURATE* = 0x4 + ILS_ALPHA* = 0x8 + ILGT_NORMAL* = 0x0 + ILGT_ASYNC* = 0x1 + HBITMAP_CALLBACK* = HBITMAP(-1) + ILCF_MOVE* = 0x0 + ILCF_SWAP* = 0x1 + ILP_NORMAL* = 0 + ILP_DOWNLEVEL* = 1 + WC_HEADERA* = "SysHeader32" + WC_HEADERW* = "SysHeader32" + HDS_HORZ* = 0x0 + HDS_BUTTONS* = 0x2 + HDS_HOTTRACK* = 0x4 + HDS_HIDDEN* = 0x8 + HDS_DRAGDROP* = 0x40 + HDS_FULLDRAG* = 0x80 + HDS_FILTERBAR* = 0x100 + HDS_FLAT* = 0x200 + HDS_CHECKBOXES* = 0x400 + HDS_NOSIZING* = 0x800 + HDS_OVERFLOW* = 0x1000 + HDFT_ISSTRING* = 0x0 + HDFT_ISNUMBER* = 0x1 + HDFT_ISDATE* = 0x2 + HDFT_HASNOVALUE* = 0x8000 + HDI_WIDTH* = 0x1 + HDI_HEIGHT* = HDI_WIDTH + HDI_TEXT* = 0x2 + HDI_FORMAT* = 0x4 + HDI_LPARAM* = 0x8 + HDI_BITMAP* = 0x10 + HDI_IMAGE* = 0x20 + HDI_DI_SETITEM* = 0x40 + HDI_ORDER* = 0x80 + HDI_FILTER* = 0x100 + HDI_STATE* = 0x0200 + HDF_LEFT* = 0x0 + HDF_RIGHT* = 0x1 + HDF_CENTER* = 0x2 + HDF_JUSTIFYMASK* = 0x3 + HDF_RTLREADING* = 0x4 + HDF_OWNERDRAW* = 0x8000 + HDF_STRING* = 0x4000 + HDF_BITMAP* = 0x2000 + HDF_BITMAP_ON_RIGHT* = 0x1000 + HDF_IMAGE* = 0x800 + HDF_SORTUP* = 0x400 + HDF_SORTDOWN* = 0x200 + HDF_CHECKBOX* = 0x40 + HDF_CHECKED* = 0x80 + HDF_FIXEDWIDTH* = 0x100 + HDF_SPLITBUTTON* = 0x1000000 + HDIS_FOCUSED* = 0x1 + HDM_GETITEMCOUNT* = HDM_FIRST+0 + HDM_INSERTITEMA* = HDM_FIRST+1 + HDM_INSERTITEMW* = HDM_FIRST+10 + HDM_DELETEITEM* = HDM_FIRST+2 + HDM_GETITEMA* = HDM_FIRST+3 + HDM_GETITEMW* = HDM_FIRST+11 + HDM_SETITEMA* = HDM_FIRST+4 + HDM_SETITEMW* = HDM_FIRST+12 + HDM_LAYOUT* = HDM_FIRST+5 + HHT_NOWHERE* = 0x1 + HHT_ONHEADER* = 0x2 + HHT_ONDIVIDER* = 0x4 + HHT_ONDIVOPEN* = 0x8 + HHT_ONFILTER* = 0x10 + HHT_ONFILTERBUTTON* = 0x20 + HHT_ABOVE* = 0x100 + HHT_BELOW* = 0x200 + HHT_TORIGHT* = 0x400 + HHT_TOLEFT* = 0x800 + HHT_ONITEMSTATEICON* = 0x1000 + HHT_ONDROPDOWN* = 0x2000 + HHT_ONOVERFLOW* = 0x4000 + HDSIL_NORMAL* = 0 + HDSIL_STATE* = 1 + HDM_HITTEST* = HDM_FIRST+6 + HDM_GETITEMRECT* = HDM_FIRST+7 + HDM_SETIMAGELIST* = HDM_FIRST+8 + HDM_GETIMAGELIST* = HDM_FIRST+9 + HDM_ORDERTOINDEX* = HDM_FIRST+15 + HDM_CREATEDRAGIMAGE* = HDM_FIRST+16 + HDM_GETORDERARRAY* = HDM_FIRST+17 + HDM_SETORDERARRAY* = HDM_FIRST+18 + HDM_SETHOTDIVIDER* = HDM_FIRST+19 + HDM_SETBITMAPMARGIN* = HDM_FIRST+20 + HDM_GETBITMAPMARGIN* = HDM_FIRST+21 + HDM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + HDM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + HDM_SETFILTERCHANGETIMEOUT* = HDM_FIRST+22 + HDM_EDITFILTER* = HDM_FIRST+23 + HDM_CLEARFILTER* = HDM_FIRST+24 + HDM_GETITEMDROPDOWNRECT* = HDM_FIRST+25 + HDM_GETOVERFLOWRECT* = HDM_FIRST+26 + HDM_GETFOCUSEDITEM* = HDM_FIRST+27 + HDM_SETFOCUSEDITEM* = HDM_FIRST+28 + HDN_ITEMCHANGINGA* = HDN_FIRST-0 + HDN_ITEMCHANGINGW* = HDN_FIRST-20 + HDN_ITEMCHANGEDA* = HDN_FIRST-1 + HDN_ITEMCHANGEDW* = HDN_FIRST-21 + HDN_ITEMCLICKA* = HDN_FIRST-2 + HDN_ITEMCLICKW* = HDN_FIRST-22 + HDN_ITEMDBLCLICKA* = HDN_FIRST-3 + HDN_ITEMDBLCLICKW* = HDN_FIRST-23 + HDN_DIVIDERDBLCLICKA* = HDN_FIRST-5 + HDN_DIVIDERDBLCLICKW* = HDN_FIRST-25 + HDN_BEGINTRACKA* = HDN_FIRST-6 + HDN_BEGINTRACKW* = HDN_FIRST-26 + HDN_ENDTRACKA* = HDN_FIRST-7 + HDN_ENDTRACKW* = HDN_FIRST-27 + HDN_TRACKA* = HDN_FIRST-8 + HDN_TRACKW* = HDN_FIRST-28 + HDN_GETDISPINFOA* = HDN_FIRST-9 + HDN_GETDISPINFOW* = HDN_FIRST-29 + HDN_BEGINDRAG* = HDN_FIRST-10 + HDN_ENDDRAG* = HDN_FIRST-11 + HDN_FILTERCHANGE* = HDN_FIRST-12 + HDN_FILTERBTNCLICK* = HDN_FIRST-13 + HDN_BEGINFILTEREDIT* = HDN_FIRST-14 + HDN_ENDFILTEREDIT* = HDN_FIRST-15 + HDN_ITEMSTATEICONCLICK* = HDN_FIRST-16 + HDN_ITEMKEYDOWN* = HDN_FIRST-17 + HDN_DROPDOWN* = HDN_FIRST-18 + HDN_OVERFLOWCLICK* = HDN_FIRST-19 + TOOLBARCLASSNAMEW* = "ToolbarWindow32" + TOOLBARCLASSNAMEA* = "ToolbarWindow32" + CMB_MASKED* = 0x2 + TBSTATE_CHECKED* = 0x1 + TBSTATE_PRESSED* = 0x2 + TBSTATE_ENABLED* = 0x4 + TBSTATE_HIDDEN* = 0x8 + TBSTATE_INDETERMINATE* = 0x10 + TBSTATE_WRAP* = 0x20 + TBSTATE_ELLIPSES* = 0x40 + TBSTATE_MARKED* = 0x80 + TBSTYLE_BUTTON* = 0x0 + TBSTYLE_SEP* = 0x1 + TBSTYLE_CHECK* = 0x2 + TBSTYLE_GROUP* = 0x4 + TBSTYLE_CHECKGROUP* = TBSTYLE_GROUP or TBSTYLE_CHECK + TBSTYLE_DROPDOWN* = 0x8 + TBSTYLE_AUTOSIZE* = 0x10 + TBSTYLE_NOPREFIX* = 0x20 + TBSTYLE_TOOLTIPS* = 0x100 + TBSTYLE_WRAPABLE* = 0x200 + TBSTYLE_ALTDRAG* = 0x400 + TBSTYLE_FLAT* = 0x800 + TBSTYLE_LIST* = 0x1000 + TBSTYLE_CUSTOMERASE* = 0x2000 + TBSTYLE_REGISTERDROP* = 0x4000 + TBSTYLE_TRANSPARENT* = 0x8000 + TBSTYLE_EX_DRAWDDARROWS* = 0x1 + BTNS_BUTTON* = TBSTYLE_BUTTON + BTNS_SEP* = TBSTYLE_SEP + BTNS_CHECK* = TBSTYLE_CHECK + BTNS_GROUP* = TBSTYLE_GROUP + BTNS_CHECKGROUP* = TBSTYLE_CHECKGROUP + BTNS_DROPDOWN* = TBSTYLE_DROPDOWN + BTNS_AUTOSIZE* = TBSTYLE_AUTOSIZE + BTNS_NOPREFIX* = TBSTYLE_NOPREFIX + BTNS_SHOWTEXT* = 0x40 + BTNS_WHOLEDROPDOWN* = 0x80 + TBSTYLE_EX_MULTICOLUMN* = 0x2 + TBSTYLE_EX_VERTICAL* = 0x4 + TBSTYLE_EX_MIXEDBUTTONS* = 0x8 + TBSTYLE_EX_HIDECLIPPEDBUTTONS* = 0x10 + TBSTYLE_EX_DOUBLEBUFFER* = 0x80 + TBCDRF_NOEDGES* = 0x10000 + TBCDRF_HILITEHOTTRACK* = 0x20000 + TBCDRF_NOOFFSET* = 0x40000 + TBCDRF_NOMARK* = 0x80000 + TBCDRF_NOETCHEDEFFECT* = 0x100000 + TBCDRF_BLENDICON* = 0x200000 + TBCDRF_NOBACKGROUND* = 0x400000 + TBCDRF_USECDCOLORS* = 0x00800000 + TB_ENABLEBUTTON* = WM_USER+1 + TB_CHECKBUTTON* = WM_USER+2 + TB_PRESSBUTTON* = WM_USER+3 + TB_HIDEBUTTON* = WM_USER+4 + TB_INDETERMINATE* = WM_USER+5 + TB_MARKBUTTON* = WM_USER+6 + TB_ISBUTTONENABLED* = WM_USER+9 + TB_ISBUTTONCHECKED* = WM_USER+10 + TB_ISBUTTONPRESSED* = WM_USER+11 + TB_ISBUTTONHIDDEN* = WM_USER+12 + TB_ISBUTTONINDETERMINATE* = WM_USER+13 + TB_ISBUTTONHIGHLIGHTED* = WM_USER+14 + TB_SETSTATE* = WM_USER+17 + TB_GETSTATE* = WM_USER+18 + TB_ADDBITMAP* = WM_USER+19 + HINST_COMMCTRL* = HINSTANCE(-1) + IDB_STD_SMALL_COLOR* = 0 + IDB_STD_LARGE_COLOR* = 1 + IDB_VIEW_SMALL_COLOR* = 4 + IDB_VIEW_LARGE_COLOR* = 5 + IDB_HIST_SMALL_COLOR* = 8 + IDB_HIST_LARGE_COLOR* = 9 + IDB_HIST_NORMAL* = 12 + IDB_HIST_HOT* = 13 + IDB_HIST_DISABLED* = 14 + IDB_HIST_PRESSED* = 15 + STD_CUT* = 0 + STD_COPY* = 1 + STD_PASTE* = 2 + STD_UNDO* = 3 + STD_REDOW* = 4 + STD_DELETE* = 5 + STD_FILENEW* = 6 + STD_FILEOPEN* = 7 + STD_FILESAVE* = 8 + STD_PRINTPRE* = 9 + STD_PROPERTIES* = 10 + STD_HELP* = 11 + STD_FIND* = 12 + STD_REPLACE* = 13 + STD_PRINT* = 14 + VIEW_LARGEICONS* = 0 + VIEW_SMALLICONS* = 1 + VIEW_LIST* = 2 + VIEW_DETAILS* = 3 + VIEW_SORTNAME* = 4 + VIEW_SORTSIZE* = 5 + VIEW_SORTDATE* = 6 + VIEW_SORTTYPE* = 7 + VIEW_PARENTFOLDER* = 8 + VIEW_NETCONNECT* = 9 + VIEW_NETDISCONNECT* = 10 + VIEW_NEWFOLDER* = 11 + VIEW_VIEWMENU* = 12 + HIST_BACK* = 0 + HIST_FORWARD* = 1 + HIST_FAVORITES* = 2 + HIST_ADDTOFAVORITES* = 3 + HIST_VIEWTREE* = 4 + TB_ADDBUTTONSA* = WM_USER+20 + TB_INSERTBUTTONA* = WM_USER+21 + TB_DELETEBUTTON* = WM_USER+22 + TB_GETBUTTON* = WM_USER+23 + TB_BUTTONCOUNT* = WM_USER+24 + TB_COMMANDTOINDEX* = WM_USER+25 + TB_SAVERESTOREA* = WM_USER+26 + TB_SAVERESTOREW* = WM_USER+76 + TB_CUSTOMIZE* = WM_USER+27 + TB_ADDSTRINGA* = WM_USER+28 + TB_ADDSTRINGW* = WM_USER+77 + TB_GETITEMRECT* = WM_USER+29 + TB_BUTTONSTRUCTSIZE* = WM_USER+30 + TB_SETBUTTONSIZE* = WM_USER+31 + TB_SETBITMAPSIZE* = WM_USER+32 + TB_AUTOSIZE* = WM_USER+33 + TB_GETTOOLTIPS* = WM_USER+35 + TB_SETTOOLTIPS* = WM_USER+36 + TB_SETPARENT* = WM_USER+37 + TB_SETROWS* = WM_USER+39 + TB_GETROWS* = WM_USER+40 + TB_SETCMDID* = WM_USER+42 + TB_CHANGEBITMAP* = WM_USER+43 + TB_GETBITMAP* = WM_USER+44 + TB_GETBUTTONTEXTA* = WM_USER+45 + TB_GETBUTTONTEXTW* = WM_USER+75 + TB_REPLACEBITMAP* = WM_USER+46 + TB_SETINDENT* = WM_USER+47 + TB_SETIMAGELIST* = WM_USER+48 + TB_GETIMAGELIST* = WM_USER+49 + TB_LOADIMAGES* = WM_USER+50 + TB_GETRECT* = WM_USER+51 + TB_SETHOTIMAGELIST* = WM_USER+52 + TB_GETHOTIMAGELIST* = WM_USER+53 + TB_SETDISABLEDIMAGELIST* = WM_USER+54 + TB_GETDISABLEDIMAGELIST* = WM_USER+55 + TB_SETSTYLE* = WM_USER+56 + TB_GETSTYLE* = WM_USER+57 + TB_GETBUTTONSIZE* = WM_USER+58 + TB_SETBUTTONWIDTH* = WM_USER+59 + TB_SETMAXTEXTROWS* = WM_USER+60 + TB_GETTEXTROWS* = WM_USER+61 + TB_GETOBJECT* = WM_USER+62 + TB_GETHOTITEM* = WM_USER+71 + TB_SETHOTITEM* = WM_USER+72 + TB_SETANCHORHIGHLIGHT* = WM_USER+73 + TB_GETANCHORHIGHLIGHT* = WM_USER+74 + TB_MAPACCELERATORA* = WM_USER+78 + TBIMHT_AFTER* = 0x1 + TBIMHT_BACKGROUND* = 0x2 + TB_GETINSERTMARK* = WM_USER+79 + TB_SETINSERTMARK* = WM_USER+80 + TB_INSERTMARKHITTEST* = WM_USER+81 + TB_MOVEBUTTON* = WM_USER+82 + TB_GETMAXSIZE* = WM_USER+83 + TB_SETEXTENDEDSTYLE* = WM_USER+84 + TB_GETEXTENDEDSTYLE* = WM_USER+85 + TB_GETPADDING* = WM_USER+86 + TB_SETPADDING* = WM_USER+87 + TB_SETINSERTMARKCOLOR* = WM_USER+88 + TB_GETINSERTMARKCOLOR* = WM_USER+89 + TB_SETCOLORSCHEME* = CCM_SETCOLORSCHEME + TB_GETCOLORSCHEME* = CCM_GETCOLORSCHEME + TB_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + TB_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + TB_MAPACCELERATORW* = WM_USER+90 + TBBF_LARGE* = 0x1 + TB_GETBITMAPFLAGS* = WM_USER+41 + TBIF_IMAGE* = 0x1 + TBIF_TEXT* = 0x2 + TBIF_STATE* = 0x4 + TBIF_STYLE* = 0x8 + TBIF_LPARAM* = 0x10 + TBIF_COMMAND* = 0x20 + TBIF_SIZE* = 0x40 + TBIF_BYINDEX* = 0x80000000'i32 + TB_GETBUTTONINFOW* = WM_USER+63 + TB_SETBUTTONINFOW* = WM_USER+64 + TB_GETBUTTONINFOA* = WM_USER+65 + TB_SETBUTTONINFOA* = WM_USER+66 + TB_INSERTBUTTONW* = WM_USER+67 + TB_ADDBUTTONSW* = WM_USER+68 + TB_HITTEST* = WM_USER+69 + TB_SETDRAWTEXTFLAGS* = WM_USER+70 + TB_GETSTRINGW* = WM_USER+91 + TB_GETSTRINGA* = WM_USER+92 + TB_SETBOUNDINGSIZE* = WM_USER+93 + TB_SETHOTITEM2* = WM_USER+94 + TB_HASACCELERATOR* = WM_USER+95 + TB_SETLISTGAP* = WM_USER+96 + TB_GETIMAGELISTCOUNT* = WM_USER+98 + TB_GETIDEALSIZE* = WM_USER+99 + TBMF_PAD* = 0x1 + TBMF_BARPAD* = 0x2 + TBMF_BUTTONSPACING* = 0x4 + TB_GETMETRICS* = WM_USER+101 + TB_SETMETRICS* = WM_USER+102 + TB_GETITEMDROPDOWNRECT* = WM_USER+103 + TB_SETPRESSEDIMAGELIST* = WM_USER+104 + TB_GETPRESSEDIMAGELIST* = WM_USER+105 + TB_SETWINDOWTHEME* = CCM_SETWINDOWTHEME + TBN_GETBUTTONINFOA* = TBN_FIRST-0 + TBN_BEGINDRAG* = TBN_FIRST-1 + TBN_ENDDRAG* = TBN_FIRST-2 + TBN_BEGINADJUST* = TBN_FIRST-3 + TBN_ENDADJUST* = TBN_FIRST-4 + TBN_RESET* = TBN_FIRST-5 + TBN_QUERYINSERT* = TBN_FIRST-6 + TBN_QUERYDELETE* = TBN_FIRST-7 + TBN_TOOLBARCHANGE* = TBN_FIRST-8 + TBN_CUSTHELP* = TBN_FIRST-9 + TBN_DROPDOWN* = TBN_FIRST-10 + TBN_GETOBJECT* = TBN_FIRST-12 + HICF_OTHER* = 0x0 + HICF_MOUSE* = 0x1 + HICF_ARROWKEYS* = 0x2 + HICF_ACCELERATOR* = 0x4 + HICF_DUPACCEL* = 0x8 + HICF_ENTERING* = 0x10 + HICF_LEAVING* = 0x20 + HICF_RESELECT* = 0x40 + HICF_LMOUSE* = 0x80 + HICF_TOGGLEDROPDOWN* = 0x100 + TBN_HOTITEMCHANGE* = TBN_FIRST-13 + TBN_DRAGOUT* = TBN_FIRST-14 + TBN_DELETINGBUTTON* = TBN_FIRST-15 + TBN_GETDISPINFOA* = TBN_FIRST-16 + TBN_GETDISPINFOW* = TBN_FIRST-17 + TBN_GETINFOTIPA* = TBN_FIRST-18 + TBN_GETINFOTIPW* = TBN_FIRST-19 + TBN_GETBUTTONINFOW* = TBN_FIRST-20 + TBN_RESTORE* = TBN_FIRST-21 + TBN_SAVE* = TBN_FIRST-22 + TBN_INITCUSTOMIZE* = TBN_FIRST-23 + TBNRF_HIDEHELP* = 0x1 + TBNRF_ENDCUSTOMIZE* = 0x2 + TBN_WRAPHOTITEM* = TBN_FIRST-24 + TBN_DUPACCELERATOR* = TBN_FIRST-25 + TBN_WRAPACCELERATOR* = TBN_FIRST-26 + TBN_DRAGOVER* = TBN_FIRST-27 + TBN_MAPACCELERATOR* = TBN_FIRST-28 + TBNF_IMAGE* = 0x1 + TBNF_TEXT* = 0x2 + TBNF_DI_SETITEM* = 0x10000000 + TBDDRET_DEFAULT* = 0 + TBDDRET_NODEFAULT* = 1 + TBDDRET_TREATPRESSED* = 2 + REBARCLASSNAMEW* = "ReBarWindow32" + REBARCLASSNAMEA* = "ReBarWindow32" + RBIM_IMAGELIST* = 0x1 + RBS_TOOLTIPS* = 0x100 + RBS_VARHEIGHT* = 0x200 + RBS_BANDBORDERS* = 0x400 + RBS_FIXEDORDER* = 0x800 + RBS_REGISTERDROP* = 0x1000 + RBS_AUTOSIZE* = 0x2000 + RBS_VERTICALGRIPPER* = 0x4000 + RBS_DBLCLKTOGGLE* = 0x8000 + RBBS_BREAK* = 0x1 + RBBS_FIXEDSIZE* = 0x2 + RBBS_CHILDEDGE* = 0x4 + RBBS_HIDDEN* = 0x8 + RBBS_NOVERT* = 0x10 + RBBS_FIXEDBMP* = 0x20 + RBBS_VARIABLEHEIGHT* = 0x40 + RBBS_GRIPPERALWAYS* = 0x80 + RBBS_NOGRIPPER* = 0x100 + RBBS_USECHEVRON* = 0x200 + RBBS_HIDETITLE* = 0x400 + RBBS_TOPALIGN* = 0x800 + RBBIM_STYLE* = 0x1 + RBBIM_COLORS* = 0x2 + RBBIM_TEXT* = 0x4 + RBBIM_IMAGE* = 0x8 + RBBIM_CHILD* = 0x10 + RBBIM_CHILDSIZE* = 0x20 + RBBIM_SIZE* = 0x40 + RBBIM_BACKGROUND* = 0x80 + RBBIM_ID* = 0x100 + RBBIM_IDEALSIZE* = 0x200 + RBBIM_LPARAM* = 0x400 + RBBIM_HEADERSIZE* = 0x800 + RBBIM_CHEVRONLOCATION* = 0x00001000 + RBBIM_CHEVRONSTATE* = 0x00002000 + RB_INSERTBANDA* = WM_USER+1 + RB_DELETEBAND* = WM_USER+2 + RB_GETBARINFO* = WM_USER+3 + RB_SETBARINFO* = WM_USER+4 + RB_SETBANDINFOA* = WM_USER+6 + RB_SETPARENT* = WM_USER+7 + RB_HITTEST* = WM_USER+8 + RB_GETRECT* = WM_USER+9 + RB_INSERTBANDW* = WM_USER+10 + RB_SETBANDINFOW* = WM_USER+11 + RB_GETBANDCOUNT* = WM_USER+12 + RB_GETROWCOUNT* = WM_USER+13 + RB_GETROWHEIGHT* = WM_USER+14 + RB_IDTOINDEX* = WM_USER+16 + RB_GETTOOLTIPS* = WM_USER+17 + RB_SETTOOLTIPS* = WM_USER+18 + RB_SETBKCOLOR* = WM_USER+19 + RB_GETBKCOLOR* = WM_USER+20 + RB_SETTEXTCOLOR* = WM_USER+21 + RB_GETTEXTCOLOR* = WM_USER+22 + RBSTR_CHANGERECT* = 0x1 + RB_SIZETORECT* = WM_USER+23 + RB_SETCOLORSCHEME* = CCM_SETCOLORSCHEME + RB_GETCOLORSCHEME* = CCM_GETCOLORSCHEME + RB_BEGINDRAG* = WM_USER+24 + RB_ENDDRAG* = WM_USER+25 + RB_DRAGMOVE* = WM_USER+26 + RB_GETBARHEIGHT* = WM_USER+27 + RB_GETBANDINFOW* = WM_USER+28 + RB_GETBANDINFOA* = WM_USER+29 + RB_MINIMIZEBAND* = WM_USER+30 + RB_MAXIMIZEBAND* = WM_USER+31 + RB_GETDROPTARGET* = CCM_GETDROPTARGET + RB_GETBANDBORDERS* = WM_USER+34 + RB_SHOWBAND* = WM_USER+35 + RB_SETPALETTE* = WM_USER+37 + RB_GETPALETTE* = WM_USER+38 + RB_MOVEBAND* = WM_USER+39 + RB_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + RB_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + RB_GETBANDMARGINS* = WM_USER+40 + RB_SETWINDOWTHEME* = CCM_SETWINDOWTHEME + RB_SETEXTENDEDSTYLE* = WM_USER+41 + RB_GETEXTENDEDSTYLE* = WM_USER+42 + RB_PUSHCHEVRON* = WM_USER+43 + RB_SETBANDWIDTH* = WM_USER+44 + RBN_HEIGHTCHANGE* = RBN_FIRST-0 + RBN_GETOBJECT* = RBN_FIRST-1 + RBN_LAYOUTCHANGED* = RBN_FIRST-2 + RBN_AUTOSIZE* = RBN_FIRST-3 + RBN_BEGINDRAG* = RBN_FIRST-4 + RBN_ENDDRAG* = RBN_FIRST-5 + RBN_DELETINGBAND* = RBN_FIRST-6 + RBN_DELETEDBAND* = RBN_FIRST-7 + RBN_CHILDSIZE* = RBN_FIRST-8 + RBN_CHEVRONPUSHED* = RBN_FIRST-10 + RBN_SPLITTERDRAG* = RBN_FIRST-11 + RBN_MINMAX* = RBN_FIRST-21 + RBN_AUTOBREAK* = RBN_FIRST-22 + RBNM_ID* = 0x1 + RBNM_STYLE* = 0x2 + RBNM_LPARAM* = 0x4 + RBAB_AUTOSIZE* = 0x1 + RBAB_ADDBAND* = 0x2 + RBHT_NOWHERE* = 0x1 + RBHT_CAPTION* = 0x2 + RBHT_CLIENT* = 0x3 + RBHT_GRABBER* = 0x4 + RBHT_CHEVRON* = 0x8 + RBHT_SPLITTER* = 0x10 + TOOLTIPS_CLASSW* = "tooltips_class32" + TOOLTIPS_CLASSA* = "tooltips_class32" + TTS_ALWAYSTIP* = 0x1 + TTS_NOPREFIX* = 0x2 + TTS_NOANIMATE* = 0x10 + TTS_NOFADE* = 0x20 + TTS_BALLOON* = 0x40 + TTS_CLOSE* = 0x80 + TTS_USEVISUALSTYLE* = 0x100 + TTF_IDISHWND* = 0x1 + TTF_CENTERTIP* = 0x2 + TTF_RTLREADING* = 0x4 + TTF_SUBCLASS* = 0x10 + TTF_TRACK* = 0x20 + TTF_ABSOLUTE* = 0x80 + TTF_TRANSPARENT* = 0x100 + TTF_PARSELINKS* = 0x1000 + TTF_DI_SETITEM* = 0x8000 + TTDT_AUTOMATIC* = 0 + TTDT_RESHOW* = 1 + TTDT_AUTOPOP* = 2 + TTDT_INITIAL* = 3 + TTI_NONE* = 0 + TTI_INFO* = 1 + TTI_WARNING* = 2 + TTI_ERROR* = 3 + TTI_INFO_LARGE* = 4 + TTI_WARNING_LARGE* = 5 + TTI_ERROR_LARGE* = 6 + TTM_ACTIVATE* = WM_USER+1 + TTM_SETDELAYTIME* = WM_USER+3 + TTM_ADDTOOLA* = WM_USER+4 + TTM_ADDTOOLW* = WM_USER+50 + TTM_DELTOOLA* = WM_USER+5 + TTM_DELTOOLW* = WM_USER+51 + TTM_NEWTOOLRECTA* = WM_USER+6 + TTM_NEWTOOLRECTW* = WM_USER+52 + TTM_RELAYEVENT* = WM_USER+7 + TTM_GETTOOLINFOA* = WM_USER+8 + TTM_GETTOOLINFOW* = WM_USER+53 + TTM_SETTOOLINFOA* = WM_USER+9 + TTM_SETTOOLINFOW* = WM_USER+54 + TTM_HITTESTA* = WM_USER+10 + TTM_HITTESTW* = WM_USER+55 + TTM_GETTEXTA* = WM_USER+11 + TTM_GETTEXTW* = WM_USER+56 + TTM_UPDATETIPTEXTA* = WM_USER+12 + TTM_UPDATETIPTEXTW* = WM_USER+57 + TTM_GETTOOLCOUNT* = WM_USER+13 + TTM_ENUMTOOLSA* = WM_USER+14 + TTM_ENUMTOOLSW* = WM_USER+58 + TTM_GETCURRENTTOOLA* = WM_USER+15 + TTM_GETCURRENTTOOLW* = WM_USER+59 + TTM_WINDOWFROMPOINT* = WM_USER+16 + TTM_TRACKACTIVATE* = WM_USER+17 + TTM_TRACKPOSITION* = WM_USER+18 + TTM_SETTIPBKCOLOR* = WM_USER+19 + TTM_SETTIPTEXTCOLOR* = WM_USER+20 + TTM_GETDELAYTIME* = WM_USER+21 + TTM_GETTIPBKCOLOR* = WM_USER+22 + TTM_GETTIPTEXTCOLOR* = WM_USER+23 + TTM_SETMAXTIPWIDTH* = WM_USER+24 + TTM_GETMAXTIPWIDTH* = WM_USER+25 + TTM_SETMARGIN* = WM_USER+26 + TTM_GETMARGIN* = WM_USER+27 + TTM_POP* = WM_USER+28 + TTM_UPDATE* = WM_USER+29 + TTM_GETBUBBLESIZE* = WM_USER+30 + TTM_ADJUSTRECT* = WM_USER+31 + TTM_SETTITLEA* = WM_USER+32 + TTM_SETTITLEW* = WM_USER+33 + TTM_POPUP* = WM_USER+34 + TTM_GETTITLE* = WM_USER+35 + TTM_SETWINDOWTHEME* = CCM_SETWINDOWTHEME + TTN_GETDISPINFOA* = TTN_FIRST-0 + TTN_GETDISPINFOW* = TTN_FIRST-10 + TTN_SHOW* = TTN_FIRST-1 + TTN_POP* = TTN_FIRST-2 + TTN_LINKCLICK* = TTN_FIRST-3 +when winimUnicode: + const + TTN_GETDISPINFO* = TTN_GETDISPINFOW +when winimAnsi: + const + TTN_GETDISPINFO* = TTN_GETDISPINFOA +const + TTN_NEEDTEXT* = TTN_GETDISPINFO + TTN_NEEDTEXTA* = TTN_GETDISPINFOA + TTN_NEEDTEXTW* = TTN_GETDISPINFOW + SBARS_SIZEGRIP* = 0x100 + SBARS_TOOLTIPS* = 0x800 + SBT_TOOLTIPS* = 0x800 + STATUSCLASSNAMEW* = "msctls_statusbar32" + STATUSCLASSNAMEA* = "msctls_statusbar32" + SB_SETTEXTA* = WM_USER+1 + SB_SETTEXTW* = WM_USER+11 + SB_GETTEXTA* = WM_USER+2 + SB_GETTEXTW* = WM_USER+13 + SB_GETTEXTLENGTHA* = WM_USER+3 + SB_GETTEXTLENGTHW* = WM_USER+12 + SB_SETPARTS* = WM_USER+4 + SB_GETPARTS* = WM_USER+6 + SB_GETBORDERS* = WM_USER+7 + SB_SETMINHEIGHT* = WM_USER+8 + SB_SIMPLE* = WM_USER+9 + SB_GETRECT* = WM_USER+10 + SB_ISSIMPLE* = WM_USER+14 + SB_SETICON* = WM_USER+15 + SB_SETTIPTEXTA* = WM_USER+16 + SB_SETTIPTEXTW* = WM_USER+17 + SB_GETTIPTEXTA* = WM_USER+18 + SB_GETTIPTEXTW* = WM_USER+19 + SB_GETICON* = WM_USER+20 + SB_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + SB_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + SBT_OWNERDRAW* = 0x1000 + SBT_NOBORDERS* = 0x100 + SBT_POPOUT* = 0x200 + SBT_RTLREADING* = 0x400 + SBT_NOTABPARSING* = 0x800 + SB_SETBKCOLOR* = CCM_SETBKCOLOR + SBN_SIMPLEMODECHANGE* = SBN_FIRST-0 + SB_SIMPLEID* = 0xff + MINSYSCOMMAND* = SC_SIZE + TRACKBAR_CLASSA* = "msctls_trackbar32" + TRACKBAR_CLASSW* = "msctls_trackbar32" + TBS_AUTOTICKS* = 0x1 + TBS_VERT* = 0x2 + TBS_HORZ* = 0x0 + TBS_TOP* = 0x4 + TBS_BOTTOM* = 0x0 + TBS_LEFT* = 0x4 + TBS_RIGHT* = 0x0 + TBS_BOTH* = 0x8 + TBS_NOTICKS* = 0x10 + TBS_ENABLESELRANGE* = 0x20 + TBS_FIXEDLENGTH* = 0x40 + TBS_NOTHUMB* = 0x80 + TBS_TOOLTIPS* = 0x100 + TBS_REVERSED* = 0x200 + TBS_DOWNISLEFT* = 0x400 + TBS_NOTIFYBEFOREMOVE* = 0x800 + TBS_TRANSPARENTBKGND* = 0x1000 + TBM_GETPOS* = WM_USER + TBM_GETRANGEMIN* = WM_USER+1 + TBM_GETRANGEMAX* = WM_USER+2 + TBM_GETTIC* = WM_USER+3 + TBM_SETTIC* = WM_USER+4 + TBM_SETPOS* = WM_USER+5 + TBM_SETRANGE* = WM_USER+6 + TBM_SETRANGEMIN* = WM_USER+7 + TBM_SETRANGEMAX* = WM_USER+8 + TBM_CLEARTICS* = WM_USER+9 + TBM_SETSEL* = WM_USER+10 + TBM_SETSELSTART* = WM_USER+11 + TBM_SETSELEND* = WM_USER+12 + TBM_GETPTICS* = WM_USER+14 + TBM_GETTICPOS* = WM_USER+15 + TBM_GETNUMTICS* = WM_USER+16 + TBM_GETSELSTART* = WM_USER+17 + TBM_GETSELEND* = WM_USER+18 + TBM_CLEARSEL* = WM_USER+19 + TBM_SETTICFREQ* = WM_USER+20 + TBM_SETPAGESIZE* = WM_USER+21 + TBM_GETPAGESIZE* = WM_USER+22 + TBM_SETLINESIZE* = WM_USER+23 + TBM_GETLINESIZE* = WM_USER+24 + TBM_GETTHUMBRECT* = WM_USER+25 + TBM_GETCHANNELRECT* = WM_USER+26 + TBM_SETTHUMBLENGTH* = WM_USER+27 + TBM_GETTHUMBLENGTH* = WM_USER+28 + TBM_SETTOOLTIPS* = WM_USER+29 + TBM_GETTOOLTIPS* = WM_USER+30 + TBM_SETTIPSIDE* = WM_USER+31 + TBTS_TOP* = 0 + TBTS_LEFT* = 1 + TBTS_BOTTOM* = 2 + TBTS_RIGHT* = 3 + TBM_SETBUDDY* = WM_USER+32 + TBM_GETBUDDY* = WM_USER+33 + TBM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + TBM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + TB_LINEUP* = 0 + TB_LINEDOWN* = 1 + TB_PAGEUP* = 2 + TB_PAGEDOWN* = 3 + TB_THUMBPOSITION* = 4 + TB_THUMBTRACK* = 5 + TB_TOP* = 6 + TB_BOTTOM* = 7 + TB_ENDTRACK* = 8 + TBCD_TICS* = 0x1 + TBCD_THUMB* = 0x2 + TBCD_CHANNEL* = 0x3 + TRBN_THUMBPOSCHANGING* = TRBN_FIRST-1 + DL_BEGINDRAG* = WM_USER+133 + DL_DRAGGING* = WM_USER+134 + DL_DROPPED* = WM_USER+135 + DL_CANCELDRAG* = WM_USER+136 + DL_CURSORSET* = 0 + DL_STOPCURSOR* = 1 + DL_COPYCURSOR* = 2 + DL_MOVECURSOR* = 3 + DRAGLISTMSGSTRING* = "commctrl_DragListMsg" + UPDOWN_CLASSA* = "msctls_updown32" + UPDOWN_CLASSW* = "msctls_updown32" + UD_MAXVAL* = 0x7fff + UD_MINVAL* = -UD_MAXVAL + UDS_WRAP* = 0x1 + UDS_SETBUDDYINT* = 0x2 + UDS_ALIGNRIGHT* = 0x4 + UDS_ALIGNLEFT* = 0x8 + UDS_AUTOBUDDY* = 0x10 + UDS_ARROWKEYS* = 0x20 + UDS_HORZ* = 0x40 + UDS_NOTHOUSANDS* = 0x80 + UDS_HOTTRACK* = 0x100 + UDM_SETRANGE* = WM_USER+101 + UDM_GETRANGE* = WM_USER+102 + UDM_SETPOS* = WM_USER+103 + UDM_GETPOS* = WM_USER+104 + UDM_SETBUDDY* = WM_USER+105 + UDM_GETBUDDY* = WM_USER+106 + UDM_SETACCEL* = WM_USER+107 + UDM_GETACCEL* = WM_USER+108 + UDM_SETBASE* = WM_USER+109 + UDM_GETBASE* = WM_USER+110 + UDM_SETRANGE32* = WM_USER+111 + UDM_GETRANGE32* = WM_USER+112 + UDM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + UDM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + UDM_SETPOS32* = WM_USER+113 + UDM_GETPOS32* = WM_USER+114 + UDN_DELTAPOS* = UDN_FIRST-1 + PROGRESS_CLASSA* = "msctls_progress32" + PROGRESS_CLASSW* = "msctls_progress32" + PBS_SMOOTH* = 0x1 + PBS_VERTICAL* = 0x4 + PBM_SETRANGE* = WM_USER+1 + PBM_SETPOS* = WM_USER+2 + PBM_DELTAPOS* = WM_USER+3 + PBM_SETSTEP* = WM_USER+4 + PBM_STEPIT* = WM_USER+5 + PBM_SETRANGE32* = WM_USER+6 + PBM_GETRANGE* = WM_USER+7 + PBM_GETPOS* = WM_USER+8 + PBM_SETBARCOLOR* = WM_USER+9 + PBM_SETBKCOLOR* = CCM_SETBKCOLOR + PBS_MARQUEE* = 0x8 + PBM_SETMARQUEE* = WM_USER+10 + PBM_GETSTEP* = WM_USER+13 + PBM_GETBKCOLOR* = WM_USER+14 + PBM_GETBARCOLOR* = WM_USER+15 + PBM_SETSTATE* = WM_USER+16 + PBM_GETSTATE* = WM_USER+17 + PBS_SMOOTHREVERSE* = 0x10 + PBST_NORMAL* = 1 + PBST_ERROR* = 2 + PBST_PAUSED* = 3 + HOTKEYF_SHIFT* = 0x1 + HOTKEYF_CONTROL* = 0x2 + HOTKEYF_ALT* = 0x4 + HOTKEYF_EXT* = 0x8 + HKCOMB_NONE* = 0x1 + HKCOMB_S* = 0x2 + HKCOMB_C* = 0x4 + HKCOMB_A* = 0x8 + HKCOMB_SC* = 0x10 + HKCOMB_SA* = 0x20 + HKCOMB_CA* = 0x40 + HKCOMB_SCA* = 0x80 + HKM_SETHOTKEY* = WM_USER+1 + HKM_GETHOTKEY* = WM_USER+2 + HKM_SETRULES* = WM_USER+3 + HOTKEY_CLASSA* = "msctls_hotkey32" + HOTKEY_CLASSW* = "msctls_hotkey32" + CCS_TOP* = 0x1 + CCS_NOMOVEY* = 0x2 + CCS_BOTTOM* = 0x3 + CCS_NORESIZE* = 0x4 + CCS_NOPARENTALIGN* = 0x8 + CCS_ADJUSTABLE* = 0x20 + CCS_NODIVIDER* = 0x40 + CCS_VERT* = 0x80 + CCS_LEFT* = CCS_VERT or CCS_TOP + CCS_RIGHT* = CCS_VERT or CCS_BOTTOM + CCS_NOMOVEX* = CCS_VERT or CCS_NOMOVEY + INVALID_LINK_INDEX* = -1 + WC_LINK* = "SysLink" + WC_LISTVIEWA* = "SysListView32" + WC_LISTVIEWW* = "SysListView32" + LVS_ICON* = 0x0 + LVS_REPORT* = 0x1 + LVS_SMALLICON* = 0x2 + LVS_LIST* = 0x3 + LVS_TYPEMASK* = 0x3 + LVS_SINGLESEL* = 0x4 + LVS_SHOWSELALWAYS* = 0x8 + LVS_SORTASCENDING* = 0x10 + LVS_SORTDESCENDING* = 0x20 + LVS_SHAREIMAGELISTS* = 0x40 + LVS_NOLABELWRAP* = 0x80 + LVS_AUTOARRANGE* = 0x100 + LVS_EDITLABELS* = 0x200 + LVS_OWNERDATA* = 0x1000 + LVS_NOSCROLL* = 0x2000 + LVS_TYPESTYLEMASK* = 0xfc00 + LVS_ALIGNTOP* = 0x0 + LVS_ALIGNLEFT* = 0x800 + LVS_ALIGNMASK* = 0xc00 + LVS_OWNERDRAWFIXED* = 0x400 + LVS_NOCOLUMNHEADER* = 0x4000 + LVS_NOSORTHEADER* = 0x8000 + LVM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + LVM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + LVM_GETBKCOLOR* = LVM_FIRST+0 + LVM_SETBKCOLOR* = LVM_FIRST+1 + LVM_GETIMAGELIST* = LVM_FIRST+2 + LVSIL_NORMAL* = 0 + LVSIL_SMALL* = 1 + LVSIL_STATE* = 2 + LVSIL_GROUPHEADER* = 3 + LVM_SETIMAGELIST* = LVM_FIRST+3 + LVM_GETITEMCOUNT* = LVM_FIRST+4 + LVIF_TEXT* = 0x1 + LVIF_IMAGE* = 0x2 + LVIF_PARAM* = 0x4 + LVIF_STATE* = 0x8 + LVIF_INDENT* = 0x10 + LVIF_NORECOMPUTE* = 0x800 + LVIF_GROUPID* = 0x100 + LVIF_COLUMNS* = 0x200 + LVIF_COLFMT* = 0x10000 + LVIS_FOCUSED* = 0x1 + LVIS_SELECTED* = 0x2 + LVIS_CUT* = 0x4 + LVIS_DROPHILITED* = 0x8 + LVIS_GLOW* = 0x10 + LVIS_ACTIVATING* = 0x20 + LVIS_OVERLAYMASK* = 0xf00 + LVIS_STATEIMAGEMASK* = 0xF000 + I_INDENTCALLBACK* = -1 + I_GROUPIDCALLBACK* = -1 + I_GROUPIDNONE* = -2 + I_IMAGECALLBACK* = -1 + I_IMAGENONE* = -2 + I_COLUMNSCALLBACK* = UINT(-1) + LVM_GETITEMA* = LVM_FIRST+5 + LVM_GETITEMW* = LVM_FIRST+75 + LVM_SETITEMA* = LVM_FIRST+6 + LVM_SETITEMW* = LVM_FIRST+76 + LVM_INSERTITEMA* = LVM_FIRST+7 + LVM_INSERTITEMW* = LVM_FIRST+77 + LVM_DELETEITEM* = LVM_FIRST+8 + LVM_DELETEALLITEMS* = LVM_FIRST+9 + LVM_GETCALLBACKMASK* = LVM_FIRST+10 + LVM_SETCALLBACKMASK* = LVM_FIRST+11 + LVNI_ALL* = 0x0 + LVNI_FOCUSED* = 0x1 + LVNI_SELECTED* = 0x2 + LVNI_CUT* = 0x4 + LVNI_DROPHILITED* = 0x8 + LVNI_STATEMASK* = LVNI_FOCUSED or LVNI_SELECTED or LVNI_CUT or LVNI_DROPHILITED + LVNI_VISIBLEORDER* = 0x10 + LVNI_PREVIOUS* = 0x20 + LVNI_VISIBLEONLY* = 0x40 + LVNI_SAMEGROUPONLY* = 0x80 + LVNI_ABOVE* = 0x100 + LVNI_BELOW* = 0x200 + LVNI_TOLEFT* = 0x400 + LVNI_TORIGHT* = 0x800 + LVNI_DIRECTIONMASK* = LVNI_ABOVE or LVNI_BELOW or LVNI_TOLEFT or LVNI_TORIGHT + LVM_GETNEXTITEM* = LVM_FIRST+12 + LVFI_PARAM* = 0x1 + LVFI_STRING* = 0x2 + LVFI_PARTIAL* = 0x8 + LVFI_WRAP* = 0x20 + LVFI_NEARESTXY* = 0x40 + LVM_FINDITEMA* = LVM_FIRST+13 + LVM_FINDITEMW* = LVM_FIRST+83 + LVIR_BOUNDS* = 0 + LVIR_ICON* = 1 + LVIR_LABEL* = 2 + LVIR_SELECTBOUNDS* = 3 + LVM_GETITEMRECT* = LVM_FIRST+14 + LVM_SETITEMPOSITION* = LVM_FIRST+15 + LVM_GETITEMPOSITION* = LVM_FIRST+16 + LVM_GETSTRINGWIDTHA* = LVM_FIRST+17 + LVM_GETSTRINGWIDTHW* = LVM_FIRST+87 + LVHT_NOWHERE* = 0x1 + LVHT_ONITEMICON* = 0x2 + LVHT_ONITEMLABEL* = 0x4 + LVHT_ONITEMSTATEICON* = 0x8 + LVHT_ONITEM* = LVHT_ONITEMICON or LVHT_ONITEMLABEL or LVHT_ONITEMSTATEICON + LVHT_ABOVE* = 0x8 + LVHT_BELOW* = 0x10 + LVHT_TORIGHT* = 0x20 + LVHT_TOLEFT* = 0x40 + LVHT_EX_GROUP_HEADER* = 0x10000000 + LVHT_EX_GROUP_FOOTER* = 0x20000000 + LVHT_EX_GROUP_COLLAPSE* = 0x40000000 + LVHT_EX_GROUP_BACKGROUND* = 0x80000000'i32 + LVHT_EX_GROUP_STATEICON* = 0x01000000 + LVHT_EX_GROUP_SUBSETLINK* = 0x02000000 + LVHT_EX_GROUP* = LVHT_EX_GROUP_BACKGROUND or LVHT_EX_GROUP_COLLAPSE or LVHT_EX_GROUP_FOOTER or LVHT_EX_GROUP_HEADER or LVHT_EX_GROUP_STATEICON or LVHT_EX_GROUP_SUBSETLINK + LVHT_EX_ONCONTENTS* = 0x04000000 + LVM_HITTEST* = LVM_FIRST+18 + LVM_ENSUREVISIBLE* = LVM_FIRST+19 + LVM_SCROLL* = LVM_FIRST+20 + LVM_REDRAWITEMS* = LVM_FIRST+21 + LVA_DEFAULT* = 0x0 + LVA_ALIGNLEFT* = 0x1 + LVA_ALIGNTOP* = 0x2 + LVA_SNAPTOGRID* = 0x5 + LVM_ARRANGE* = LVM_FIRST+22 + LVM_EDITLABELA* = LVM_FIRST+23 + LVM_EDITLABELW* = LVM_FIRST+118 + LVM_GETEDITCONTROL* = LVM_FIRST+24 + LVCF_FMT* = 0x1 + LVCF_WIDTH* = 0x2 + LVCF_TEXT* = 0x4 + LVCF_SUBITEM* = 0x8 + LVCF_IMAGE* = 0x10 + LVCF_ORDER* = 0x20 + LVCF_MINWIDTH* = 0x40 + LVCF_DEFAULTWIDTH* = 0x80 + LVCF_IDEALWIDTH* = 0x100 + LVCFMT_LEFT* = 0x0 + LVCFMT_RIGHT* = 0x1 + LVCFMT_CENTER* = 0x2 + LVCFMT_JUSTIFYMASK* = 0x3 + LVCFMT_IMAGE* = 0x800 + LVCFMT_BITMAP_ON_RIGHT* = 0x1000 + LVCFMT_COL_HAS_IMAGES* = 0x8000 + LVCFMT_FIXED_WIDTH* = 0x100 + LVCFMT_NO_DPI_SCALE* = 0x40000 + LVCFMT_FIXED_RATIO* = 0x80000 + LVCFMT_LINE_BREAK* = 0x100000 + LVCFMT_FILL* = 0x200000 + LVCFMT_WRAP* = 0x400000 + LVCFMT_NO_TITLE* = 0x800000 + LVCFMT_SPLITBUTTON* = 0x1000000 + LVCFMT_TILE_PLACEMENTMASK* = LVCFMT_LINE_BREAK or LVCFMT_FILL + LVM_GETCOLUMNA* = LVM_FIRST+25 + LVM_GETCOLUMNW* = LVM_FIRST+95 + LVM_SETCOLUMNA* = LVM_FIRST+26 + LVM_SETCOLUMNW* = LVM_FIRST+96 + LVM_INSERTCOLUMNA* = LVM_FIRST+27 + LVM_INSERTCOLUMNW* = LVM_FIRST+97 + LVM_DELETECOLUMN* = LVM_FIRST+28 + LVM_GETCOLUMNWIDTH* = LVM_FIRST+29 + LVSCW_AUTOSIZE* = -1 + LVSCW_AUTOSIZE_USEHEADER* = -2 + LVM_SETCOLUMNWIDTH* = LVM_FIRST+30 + LVM_GETHEADER* = LVM_FIRST+31 + LVM_CREATEDRAGIMAGE* = LVM_FIRST+33 + LVM_GETVIEWRECT* = LVM_FIRST+34 + LVM_GETTEXTCOLOR* = LVM_FIRST+35 + LVM_SETTEXTCOLOR* = LVM_FIRST+36 + LVM_GETTEXTBKCOLOR* = LVM_FIRST+37 + LVM_SETTEXTBKCOLOR* = LVM_FIRST+38 + LVM_GETTOPINDEX* = LVM_FIRST+39 + LVM_GETCOUNTPERPAGE* = LVM_FIRST+40 + LVM_GETORIGIN* = LVM_FIRST+41 + LVM_UPDATE* = LVM_FIRST+42 + LVM_SETITEMSTATE* = LVM_FIRST+43 + LVM_GETITEMSTATE* = LVM_FIRST+44 + LVM_GETITEMTEXTA* = LVM_FIRST+45 + LVM_GETITEMTEXTW* = LVM_FIRST+115 + LVM_SETITEMTEXTA* = LVM_FIRST+46 + LVM_SETITEMTEXTW* = LVM_FIRST+116 + LVSICF_NOINVALIDATEALL* = 0x1 + LVSICF_NOSCROLL* = 0x2 + LVM_SETITEMCOUNT* = LVM_FIRST+47 + LVM_SORTITEMS* = LVM_FIRST+48 + LVM_SETITEMPOSITION32* = LVM_FIRST+49 + LVM_GETSELECTEDCOUNT* = LVM_FIRST+50 + LVM_GETITEMSPACING* = LVM_FIRST+51 + LVM_GETISEARCHSTRINGA* = LVM_FIRST+52 + LVM_GETISEARCHSTRINGW* = LVM_FIRST+117 + LVM_SETICONSPACING* = LVM_FIRST+53 + LVM_SETEXTENDEDLISTVIEWSTYLE* = LVM_FIRST+54 + LVM_GETEXTENDEDLISTVIEWSTYLE* = LVM_FIRST+55 + LVS_EX_GRIDLINES* = 0x1 + LVS_EX_SUBITEMIMAGES* = 0x2 + LVS_EX_CHECKBOXES* = 0x4 + LVS_EX_TRACKSELECT* = 0x8 + LVS_EX_HEADERDRAGDROP* = 0x10 + LVS_EX_FULLROWSELECT* = 0x20 + LVS_EX_ONECLICKACTIVATE* = 0x40 + LVS_EX_TWOCLICKACTIVATE* = 0x80 + LVS_EX_FLATSB* = 0x100 + LVS_EX_REGIONAL* = 0x200 + LVS_EX_INFOTIP* = 0x400 + LVS_EX_UNDERLINEHOT* = 0x800 + LVS_EX_UNDERLINECOLD* = 0x1000 + LVS_EX_MULTIWORKAREAS* = 0x2000 + LVS_EX_LABELTIP* = 0x4000 + LVS_EX_BORDERSELECT* = 0x8000 + LVS_EX_DOUBLEBUFFER* = 0x10000 + LVS_EX_HIDELABELS* = 0x20000 + LVS_EX_SINGLEROW* = 0x40000 + LVS_EX_SNAPTOGRID* = 0x80000 + LVS_EX_SIMPLESELECT* = 0x100000 + LVS_EX_JUSTIFYCOLUMNS* = 0x200000 + LVS_EX_TRANSPARENTBKGND* = 0x400000 + LVS_EX_TRANSPARENTSHADOWTEXT* = 0x800000 + LVS_EX_AUTOAUTOARRANGE* = 0x1000000 + LVS_EX_HEADERINALLVIEWS* = 0x2000000 + LVS_EX_AUTOCHECKSELECT* = 0x8000000 + LVS_EX_AUTOSIZECOLUMNS* = 0x10000000 + LVS_EX_COLUMNSNAPPOINTS* = 0x40000000 + LVS_EX_COLUMNOVERFLOW* = 0x80000000'i32 + LVM_GETSUBITEMRECT* = LVM_FIRST+56 + LVM_SUBITEMHITTEST* = LVM_FIRST+57 + LVM_SETCOLUMNORDERARRAY* = LVM_FIRST+58 + LVM_GETCOLUMNORDERARRAY* = LVM_FIRST+59 + LVM_SETHOTITEM* = LVM_FIRST+60 + LVM_GETHOTITEM* = LVM_FIRST+61 + LVM_SETHOTCURSOR* = LVM_FIRST+62 + LVM_GETHOTCURSOR* = LVM_FIRST+63 + LVM_APPROXIMATEVIEWRECT* = LVM_FIRST+64 + LV_MAX_WORKAREAS* = 16 + LVM_SETWORKAREAS* = LVM_FIRST+65 + LVM_GETWORKAREAS* = LVM_FIRST+70 + LVM_GETNUMBEROFWORKAREAS* = LVM_FIRST+73 + LVM_GETSELECTIONMARK* = LVM_FIRST+66 + LVM_SETSELECTIONMARK* = LVM_FIRST+67 + LVM_SETHOVERTIME* = LVM_FIRST+71 + LVM_GETHOVERTIME* = LVM_FIRST+72 + LVM_SETTOOLTIPS* = LVM_FIRST+74 + LVM_GETTOOLTIPS* = LVM_FIRST+78 + LVM_SORTITEMSEX* = LVM_FIRST+81 + LVBKIF_SOURCE_NONE* = 0x0 + LVBKIF_SOURCE_HBITMAP* = 0x1 + LVBKIF_SOURCE_URL* = 0x2 + LVBKIF_SOURCE_MASK* = 0x3 + LVBKIF_STYLE_NORMAL* = 0x0 + LVBKIF_STYLE_TILE* = 0x10 + LVBKIF_STYLE_MASK* = 0x10 + LVBKIF_FLAG_TILEOFFSET* = 0x100 + LVBKIF_TYPE_WATERMARK* = 0x10000000 + LVBKIF_FLAG_ALPHABLEND* = 0x20000000 + LVM_SETBKIMAGEA* = LVM_FIRST+68 + LVM_SETBKIMAGEW* = LVM_FIRST+138 + LVM_GETBKIMAGEA* = LVM_FIRST+69 + LVM_GETBKIMAGEW* = LVM_FIRST+139 + LVM_SETSELECTEDCOLUMN* = LVM_FIRST+140 + LVM_SETTILEWIDTH* = LVM_FIRST+141 + LV_VIEW_ICON* = 0x0 + LV_VIEW_DETAILS* = 0x1 + LV_VIEW_SMALLICON* = 0x2 + LV_VIEW_LIST* = 0x3 + LV_VIEW_TILE* = 0x4 + LV_VIEW_MAX* = 0x4 + LVM_SETVIEW* = LVM_FIRST+142 + LVM_GETVIEW* = LVM_FIRST+143 + LVGF_NONE* = 0x0 + LVGF_HEADER* = 0x1 + LVGF_FOOTER* = 0x2 + LVGF_STATE* = 0x4 + LVGF_ALIGN* = 0x8 + LVGF_GROUPID* = 0x10 + LVGF_SUBTITLE* = 0x100 + LVGF_TASK* = 0x200 + LVGF_DESCRIPTIONTOP* = 0x400 + LVGF_DESCRIPTIONBOTTOM* = 0x800 + LVGF_TITLEIMAGE* = 0x1000 + LVGF_EXTENDEDIMAGE* = 0x2000 + LVGF_ITEMS* = 0x4000 + LVGF_SUBSET* = 0x00008000 + LVGF_SUBSETITEMS* = 0x10000 + LVGS_NORMAL* = 0x0 + LVGS_COLLAPSED* = 0x1 + LVGS_HIDDEN* = 0x2 + LVGS_NOHEADER* = 0x4 + LVGS_COLLAPSIBLE* = 0x8 + LVGS_FOCUSED* = 0x10 + LVGS_SELECTED* = 0x20 + LVGS_SUBSETED* = 0x40 + LVGS_SUBSETLINKFOCUSED* = 0x80 + LVGA_HEADER_LEFT* = 0x1 + LVGA_HEADER_CENTER* = 0x2 + LVGA_HEADER_RIGHT* = 0x4 + LVGA_FOOTER_LEFT* = 0x8 + LVGA_FOOTER_CENTER* = 0x10 + LVGA_FOOTER_RIGHT* = 0x20 + LVM_INSERTGROUP* = LVM_FIRST+145 + LVM_SETGROUPINFO* = LVM_FIRST+147 + LVM_GETGROUPINFO* = LVM_FIRST+149 + LVM_REMOVEGROUP* = LVM_FIRST+150 + LVM_MOVEGROUP* = LVM_FIRST+151 + LVM_GETGROUPCOUNT* = LVM_FIRST+152 + LVM_GETGROUPINFOBYINDEX* = LVM_FIRST+153 + LVM_MOVEITEMTOGROUP* = LVM_FIRST+154 + LVGGR_GROUP* = 0 + LVGGR_HEADER* = 1 + LVGGR_LABEL* = 2 + LVGGR_SUBSETLINK* = 3 + LVM_GETGROUPRECT* = LVM_FIRST+98 + LVGMF_NONE* = 0x0 + LVGMF_BORDERSIZE* = 0x1 + LVGMF_BORDERCOLOR* = 0x2 + LVGMF_TEXTCOLOR* = 0x4 + LVM_SETGROUPMETRICS* = LVM_FIRST+155 + LVM_GETGROUPMETRICS* = LVM_FIRST+156 + LVM_ENABLEGROUPVIEW* = LVM_FIRST+157 + LVM_SORTGROUPS* = LVM_FIRST+158 + LVM_INSERTGROUPSORTED* = LVM_FIRST+159 + LVM_REMOVEALLGROUPS* = LVM_FIRST+160 + LVM_HASGROUP* = LVM_FIRST+161 + LVM_GETGROUPSTATE* = LVM_FIRST+92 + LVM_GETFOCUSEDGROUP* = LVM_FIRST+93 + LVTVIF_AUTOSIZE* = 0x0 + LVTVIF_FIXEDWIDTH* = 0x1 + LVTVIF_FIXEDHEIGHT* = 0x2 + LVTVIF_FIXEDSIZE* = 0x3 + LVTVIF_EXTENDED* = 0x4 + LVTVIM_TILESIZE* = 0x1 + LVTVIM_COLUMNS* = 0x2 + LVTVIM_LABELMARGIN* = 0x4 + LVM_SETTILEVIEWINFO* = LVM_FIRST+162 + LVM_GETTILEVIEWINFO* = LVM_FIRST+163 + LVM_SETTILEINFO* = LVM_FIRST+164 + LVM_GETTILEINFO* = LVM_FIRST+165 + LVIM_AFTER* = 0x1 + LVM_SETINSERTMARK* = LVM_FIRST+166 + LVM_GETINSERTMARK* = LVM_FIRST+167 + LVM_INSERTMARKHITTEST* = LVM_FIRST+168 + LVM_GETINSERTMARKRECT* = LVM_FIRST+169 + LVM_SETINSERTMARKCOLOR* = LVM_FIRST+170 + LVM_GETINSERTMARKCOLOR* = LVM_FIRST+171 + LVM_SETINFOTIP* = LVM_FIRST+173 + LVM_GETSELECTEDCOLUMN* = LVM_FIRST+174 + LVM_ISGROUPVIEWENABLED* = LVM_FIRST+175 + LVM_GETOUTLINECOLOR* = LVM_FIRST+176 + LVM_SETOUTLINECOLOR* = LVM_FIRST+177 + LVM_CANCELEDITLABEL* = LVM_FIRST+179 + LVM_MAPINDEXTOID* = LVM_FIRST+180 + LVM_MAPIDTOINDEX* = LVM_FIRST+181 + LVM_ISITEMVISIBLE* = LVM_FIRST+182 + LVM_GETEMPTYTEXT* = LVM_FIRST+204 + LVM_GETFOOTERRECT* = LVM_FIRST+205 + LVFF_ITEMCOUNT* = 0x1 + LVM_GETFOOTERINFO* = LVM_FIRST+206 + LVM_GETFOOTERITEMRECT* = LVM_FIRST+207 + LVFIF_TEXT* = 0x1 + LVFIF_STATE* = 0x2 + LVFIS_FOCUSED* = 0x1 + LVM_GETFOOTERITEM* = LVM_FIRST+208 + LVM_GETITEMINDEXRECT* = LVM_FIRST+209 + LVM_SETITEMINDEXSTATE* = LVM_FIRST+210 + LVM_GETNEXTITEMINDEX* = LVM_FIRST+211 + LVKF_ALT* = 0x1 + LVKF_CONTROL* = 0x2 + LVKF_SHIFT* = 0x4 + LVCDI_ITEM* = 0x0 + LVCDI_GROUP* = 0x1 + LVCDI_ITEMSLIST* = 0x2 + LVCDRF_NOSELECT* = 0x10000 + LVCDRF_NOGROUPFRAME* = 0x20000 + LVN_ITEMCHANGING* = LVN_FIRST-0 + LVN_ITEMCHANGED* = LVN_FIRST-1 + LVN_INSERTITEM* = LVN_FIRST-2 + LVN_DELETEITEM* = LVN_FIRST-3 + LVN_DELETEALLITEMS* = LVN_FIRST-4 + LVN_BEGINLABELEDITA* = LVN_FIRST-5 + LVN_BEGINLABELEDITW* = LVN_FIRST-75 + LVN_ENDLABELEDITA* = LVN_FIRST-6 + LVN_ENDLABELEDITW* = LVN_FIRST-76 + LVN_COLUMNCLICK* = LVN_FIRST-8 + LVN_BEGINDRAG* = LVN_FIRST-9 + LVN_BEGINRDRAG* = LVN_FIRST-11 + LVN_ODCACHEHINT* = LVN_FIRST-13 + LVN_ODFINDITEMA* = LVN_FIRST-52 + LVN_ODFINDITEMW* = LVN_FIRST-79 + LVN_ITEMACTIVATE* = LVN_FIRST-14 + LVN_ODSTATECHANGED* = LVN_FIRST-15 + LVN_HOTTRACK* = LVN_FIRST-21 + LVN_GETDISPINFOA* = LVN_FIRST-50 + LVN_GETDISPINFOW* = LVN_FIRST-77 + LVN_SETDISPINFOA* = LVN_FIRST-51 + LVN_SETDISPINFOW* = LVN_FIRST-78 + LVIF_DI_SETITEM* = 0x1000 + LVN_KEYDOWN* = LVN_FIRST-55 + LVN_MARQUEEBEGIN* = LVN_FIRST-56 + LVGIT_UNFOLDED* = 0x1 + LVN_GETINFOTIPA* = LVN_FIRST-57 + LVN_GETINFOTIPW* = LVN_FIRST-58 + LVNSCH_DEFAULT* = -1 + LVNSCH_ERROR* = -2 + LVNSCH_IGNORE* = -3 + LVN_INCREMENTALSEARCHA* = LVN_FIRST-62 + LVN_INCREMENTALSEARCHW* = LVN_FIRST-63 + LVN_COLUMNDROPDOWN* = LVN_FIRST-64 + LVN_COLUMNOVERFLOWCLICK* = LVN_FIRST-66 + LVN_BEGINSCROLL* = LVN_FIRST-80 + LVN_ENDSCROLL* = LVN_FIRST-81 + LVN_LINKCLICK* = LVN_FIRST-84 + EMF_CENTERED* = 0x1 + LVN_GETEMPTYMARKUP* = LVN_FIRST-87 + WC_TREEVIEWA* = "SysTreeView32" + WC_TREEVIEWW* = "SysTreeView32" + TVS_HASBUTTONS* = 0x1 + TVS_HASLINES* = 0x2 + TVS_LINESATROOT* = 0x4 + TVS_EDITLABELS* = 0x8 + TVS_DISABLEDRAGDROP* = 0x10 + TVS_SHOWSELALWAYS* = 0x20 + TVS_RTLREADING* = 0x40 + TVS_NOTOOLTIPS* = 0x80 + TVS_CHECKBOXES* = 0x100 + TVS_TRACKSELECT* = 0x200 + TVS_SINGLEEXPAND* = 0x400 + TVS_INFOTIP* = 0x800 + TVS_FULLROWSELECT* = 0x1000 + TVS_NOSCROLL* = 0x2000 + TVS_NONEVENHEIGHT* = 0x4000 + TVS_NOHSCROLL* = 0x8000 + TVS_EX_NOSINGLECOLLAPSE* = 0x1 + TVS_EX_MULTISELECT* = 0x2 + TVS_EX_DOUBLEBUFFER* = 0x4 + TVS_EX_NOINDENTSTATE* = 0x8 + TVS_EX_RICHTOOLTIP* = 0x10 + TVS_EX_AUTOHSCROLL* = 0x20 + TVS_EX_FADEINOUTEXPANDOS* = 0x40 + TVS_EX_PARTIALCHECKBOXES* = 0x80 + TVS_EX_EXCLUSIONCHECKBOXES* = 0x100 + TVS_EX_DIMMEDCHECKBOXES* = 0x200 + TVS_EX_DRAWIMAGEASYNC* = 0x400 + TVIF_TEXT* = 0x1 + TVIF_IMAGE* = 0x2 + TVIF_PARAM* = 0x4 + TVIF_STATE* = 0x8 + TVIF_HANDLE* = 0x10 + TVIF_SELECTEDIMAGE* = 0x20 + TVIF_CHILDREN* = 0x40 + TVIF_INTEGRAL* = 0x80 + TVIF_STATEEX* = 0x100 + TVIF_EXPANDEDIMAGE* = 0x200 + TVIS_SELECTED* = 0x2 + TVIS_CUT* = 0x4 + TVIS_DROPHILITED* = 0x8 + TVIS_BOLD* = 0x10 + TVIS_EXPANDED* = 0x20 + TVIS_EXPANDEDONCE* = 0x40 + TVIS_EXPANDPARTIAL* = 0x80 + TVIS_OVERLAYMASK* = 0xf00 + TVIS_STATEIMAGEMASK* = 0xF000 + TVIS_USERMASK* = 0xF000 + TVIS_EX_FLAT* = 0x1 + TVIS_EX_DISABLED* = 0x2 + TVIS_EX_ALL* = 0x0002 + I_CHILDRENCALLBACK* = -1 + I_CHILDRENAUTO* = -2 + TVM_INSERTITEMA* = TV_FIRST+0 + TVM_INSERTITEMW* = TV_FIRST+50 + TVM_DELETEITEM* = TV_FIRST+1 + TVM_EXPAND* = TV_FIRST+2 + TVE_COLLAPSE* = 0x1 + TVE_EXPAND* = 0x2 + TVE_TOGGLE* = 0x3 + TVE_EXPANDPARTIAL* = 0x4000 + TVE_COLLAPSERESET* = 0x8000 + TVM_GETITEMRECT* = TV_FIRST+4 + TVM_GETCOUNT* = TV_FIRST+5 + TVM_GETINDENT* = TV_FIRST+6 + TVM_SETINDENT* = TV_FIRST+7 + TVM_GETIMAGELIST* = TV_FIRST+8 + TVSIL_NORMAL* = 0 + TVSIL_STATE* = 2 + TVM_SETIMAGELIST* = TV_FIRST+9 + TVM_GETNEXTITEM* = TV_FIRST+10 + TVGN_ROOT* = 0x0 + TVGN_NEXT* = 0x1 + TVGN_PREVIOUS* = 0x2 + TVGN_PARENT* = 0x3 + TVGN_CHILD* = 0x4 + TVGN_FIRSTVISIBLE* = 0x5 + TVGN_NEXTVISIBLE* = 0x6 + TVGN_PREVIOUSVISIBLE* = 0x7 + TVGN_DROPHILITE* = 0x8 + TVGN_CARET* = 0x9 + TVGN_LASTVISIBLE* = 0xa + TVGN_NEXTSELECTED* = 0xb + TVSI_NOSINGLEEXPAND* = 0x8000 + TVM_SELECTITEM* = TV_FIRST+11 + TVM_GETITEMA* = TV_FIRST+12 + TVM_GETITEMW* = TV_FIRST+62 + TVM_SETITEMA* = TV_FIRST+13 + TVM_SETITEMW* = TV_FIRST+63 + TVM_EDITLABELA* = TV_FIRST+14 + TVM_EDITLABELW* = TV_FIRST+65 + TVM_GETEDITCONTROL* = TV_FIRST+15 + TVM_GETVISIBLECOUNT* = TV_FIRST+16 + TVM_HITTEST* = TV_FIRST+17 + TVHT_NOWHERE* = 0x1 + TVHT_ONITEMICON* = 0x2 + TVHT_ONITEMLABEL* = 0x4 + TVHT_ONITEMSTATEICON* = 0x40 + TVHT_ONITEM* = TVHT_ONITEMICON or TVHT_ONITEMLABEL or TVHT_ONITEMSTATEICON + TVHT_ONITEMINDENT* = 0x8 + TVHT_ONITEMBUTTON* = 0x10 + TVHT_ONITEMRIGHT* = 0x20 + TVHT_ABOVE* = 0x100 + TVHT_BELOW* = 0x200 + TVHT_TORIGHT* = 0x400 + TVHT_TOLEFT* = 0x800 + TVM_CREATEDRAGIMAGE* = TV_FIRST+18 + TVM_SORTCHILDREN* = TV_FIRST+19 + TVM_ENSUREVISIBLE* = TV_FIRST+20 + TVM_SORTCHILDRENCB* = TV_FIRST+21 + TVM_ENDEDITLABELNOW* = TV_FIRST+22 + TVM_GETISEARCHSTRINGA* = TV_FIRST+23 + TVM_GETISEARCHSTRINGW* = TV_FIRST+64 + TVM_SETTOOLTIPS* = TV_FIRST+24 + TVM_GETTOOLTIPS* = TV_FIRST+25 + TVM_SETINSERTMARK* = TV_FIRST+26 + TVM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + TVM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + TVM_SETITEMHEIGHT* = TV_FIRST+27 + TVM_GETITEMHEIGHT* = TV_FIRST+28 + TVM_SETBKCOLOR* = TV_FIRST+29 + TVM_SETTEXTCOLOR* = TV_FIRST+30 + TVM_GETBKCOLOR* = TV_FIRST+31 + TVM_GETTEXTCOLOR* = TV_FIRST+32 + TVM_SETSCROLLTIME* = TV_FIRST+33 + TVM_GETSCROLLTIME* = TV_FIRST+34 + TVM_SETBORDER* = TV_FIRST+35 + TVSBF_XBORDER* = 0x1 + TVSBF_YBORDER* = 0x2 + TVM_SETINSERTMARKCOLOR* = TV_FIRST+37 + TVM_GETINSERTMARKCOLOR* = TV_FIRST+38 + TVM_GETITEMSTATE* = TV_FIRST+39 + TVM_SETLINECOLOR* = TV_FIRST+40 + TVM_GETLINECOLOR* = TV_FIRST+41 + TVM_MAPACCIDTOHTREEITEM* = TV_FIRST+42 + TVM_MAPHTREEITEMTOACCID* = TV_FIRST+43 + TVM_SETEXTENDEDSTYLE* = TV_FIRST+44 + TVM_GETEXTENDEDSTYLE* = TV_FIRST+45 + TVM_SETHOT* = TV_FIRST+58 + TVM_SETAUTOSCROLLINFO* = TV_FIRST+59 + TVM_GETSELECTEDCOUNT* = TV_FIRST+70 + TVM_SHOWINFOTIP* = TV_FIRST+71 + TVGIPR_BUTTON* = 0x0001 + TVM_GETITEMPARTRECT* = TV_FIRST+72 + TVN_SELCHANGINGA* = TVN_FIRST-1 + TVN_SELCHANGINGW* = TVN_FIRST-50 + TVN_SELCHANGEDA* = TVN_FIRST-2 + TVN_SELCHANGEDW* = TVN_FIRST-51 + TVC_UNKNOWN* = 0x0 + TVC_BYMOUSE* = 0x1 + TVC_BYKEYBOARD* = 0x2 + TVN_GETDISPINFOA* = TVN_FIRST-3 + TVN_GETDISPINFOW* = TVN_FIRST-52 + TVN_SETDISPINFOA* = TVN_FIRST-4 + TVN_SETDISPINFOW* = TVN_FIRST-53 + TVIF_DI_SETITEM* = 0x1000 + TVN_ITEMEXPANDINGA* = TVN_FIRST-5 + TVN_ITEMEXPANDINGW* = TVN_FIRST-54 + TVN_ITEMEXPANDEDA* = TVN_FIRST-6 + TVN_ITEMEXPANDEDW* = TVN_FIRST-55 + TVN_BEGINDRAGA* = TVN_FIRST-7 + TVN_BEGINDRAGW* = TVN_FIRST-56 + TVN_BEGINRDRAGA* = TVN_FIRST-8 + TVN_BEGINRDRAGW* = TVN_FIRST-57 + TVN_DELETEITEMA* = TVN_FIRST-9 + TVN_DELETEITEMW* = TVN_FIRST-58 + TVN_BEGINLABELEDITA* = TVN_FIRST-10 + TVN_BEGINLABELEDITW* = TVN_FIRST-59 + TVN_ENDLABELEDITA* = TVN_FIRST-11 + TVN_ENDLABELEDITW* = TVN_FIRST-60 + TVN_KEYDOWN* = TVN_FIRST-12 + TVN_GETINFOTIPA* = TVN_FIRST-13 + TVN_GETINFOTIPW* = TVN_FIRST-14 + TVN_SINGLEEXPAND* = TVN_FIRST-15 + TVNRET_DEFAULT* = 0 + TVNRET_SKIPOLD* = 1 + TVNRET_SKIPNEW* = 2 + TVN_ITEMCHANGINGA* = TVN_FIRST-16 + TVN_ITEMCHANGINGW* = TVN_FIRST-17 + TVN_ITEMCHANGEDA* = TVN_FIRST-18 + TVN_ITEMCHANGEDW* = TVN_FIRST-19 + TVN_ASYNCDRAW* = TVN_FIRST-20 + TVCDRF_NOIMAGES* = 0x10000 + WC_COMBOBOXEXW* = "ComboBoxEx32" + WC_COMBOBOXEXA* = "ComboBoxEx32" + CBEIF_TEXT* = 0x1 + CBEIF_IMAGE* = 0x2 + CBEIF_SELECTEDIMAGE* = 0x4 + CBEIF_OVERLAY* = 0x8 + CBEIF_INDENT* = 0x10 + CBEIF_LPARAM* = 0x20 + CBEIF_DI_SETITEM* = 0x10000000 + CBEM_INSERTITEMA* = WM_USER+1 + CBEM_SETIMAGELIST* = WM_USER+2 + CBEM_GETIMAGELIST* = WM_USER+3 + CBEM_GETITEMA* = WM_USER+4 + CBEM_SETITEMA* = WM_USER+5 + CBEM_DELETEITEM* = CB_DELETESTRING + CBEM_GETCOMBOCONTROL* = WM_USER+6 + CBEM_GETEDITCONTROL* = WM_USER+7 + CBEM_SETEXSTYLE* = WM_USER+8 + CBEM_SETEXTENDEDSTYLE* = WM_USER+14 + CBEM_GETEXSTYLE* = WM_USER+9 + CBEM_GETEXTENDEDSTYLE* = WM_USER+9 + CBEM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + CBEM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + CBEM_HASEDITCHANGED* = WM_USER+10 + CBEM_INSERTITEMW* = WM_USER+11 + CBEM_SETITEMW* = WM_USER+12 + CBEM_GETITEMW* = WM_USER+13 + CBEM_SETWINDOWTHEME* = CCM_SETWINDOWTHEME + CBES_EX_NOEDITIMAGE* = 0x1 + CBES_EX_NOEDITIMAGEINDENT* = 0x2 + CBES_EX_PATHWORDBREAKPROC* = 0x4 + CBES_EX_NOSIZELIMIT* = 0x8 + CBES_EX_CASESENSITIVE* = 0x10 + CBES_EX_TEXTENDELLIPSIS* = 0x00000020 + CBEN_GETDISPINFOA* = CBEN_FIRST-0 + CBEN_INSERTITEM* = CBEN_FIRST-1 + CBEN_DELETEITEM* = CBEN_FIRST-2 + CBEN_BEGINEDIT* = CBEN_FIRST-4 + CBEN_ENDEDITA* = CBEN_FIRST-5 + CBEN_ENDEDITW* = CBEN_FIRST-6 + CBEN_GETDISPINFOW* = CBEN_FIRST-7 + CBEN_DRAGBEGINA* = CBEN_FIRST-8 + CBEN_DRAGBEGINW* = CBEN_FIRST-9 + CBENF_KILLFOCUS* = 1 + CBENF_RETURN* = 2 + CBENF_ESCAPE* = 3 + CBENF_DROPDOWN* = 4 + WC_TABCONTROLA* = "SysTabControl32" + WC_TABCONTROLW* = "SysTabControl32" + TCS_SCROLLOPPOSITE* = 0x1 + TCS_BOTTOM* = 0x2 + TCS_RIGHT* = 0x2 + TCS_MULTISELECT* = 0x4 + TCS_FLATBUTTONS* = 0x8 + TCS_FORCEICONLEFT* = 0x10 + TCS_FORCELABELLEFT* = 0x20 + TCS_HOTTRACK* = 0x40 + TCS_VERTICAL* = 0x80 + TCS_TABS* = 0x0 + TCS_BUTTONS* = 0x100 + TCS_SINGLELINE* = 0x0 + TCS_MULTILINE* = 0x200 + TCS_RIGHTJUSTIFY* = 0x0 + TCS_FIXEDWIDTH* = 0x400 + TCS_RAGGEDRIGHT* = 0x800 + TCS_FOCUSONBUTTONDOWN* = 0x1000 + TCS_OWNERDRAWFIXED* = 0x2000 + TCS_TOOLTIPS* = 0x4000 + TCS_FOCUSNEVER* = 0x8000 + TCS_EX_FLATSEPARATORS* = 0x1 + TCS_EX_REGISTERDROP* = 0x2 + TCM_GETIMAGELIST* = TCM_FIRST+2 + TCM_SETIMAGELIST* = TCM_FIRST+3 + TCM_GETITEMCOUNT* = TCM_FIRST+4 + TCIF_TEXT* = 0x1 + TCIF_IMAGE* = 0x2 + TCIF_RTLREADING* = 0x4 + TCIF_PARAM* = 0x8 + TCIF_STATE* = 0x10 + TCIS_BUTTONPRESSED* = 0x1 + TCIS_HIGHLIGHTED* = 0x2 + TCM_GETITEMA* = TCM_FIRST+5 + TCM_GETITEMW* = TCM_FIRST+60 + TCM_SETITEMA* = TCM_FIRST+6 + TCM_SETITEMW* = TCM_FIRST+61 + TCM_INSERTITEMA* = TCM_FIRST+7 + TCM_INSERTITEMW* = TCM_FIRST+62 + TCM_DELETEITEM* = TCM_FIRST+8 + TCM_DELETEALLITEMS* = TCM_FIRST+9 + TCM_GETITEMRECT* = TCM_FIRST+10 + TCM_GETCURSEL* = TCM_FIRST+11 + TCM_SETCURSEL* = TCM_FIRST+12 + TCHT_NOWHERE* = 0x1 + TCHT_ONITEMICON* = 0x2 + TCHT_ONITEMLABEL* = 0x4 + TCHT_ONITEM* = TCHT_ONITEMICON or TCHT_ONITEMLABEL + TCM_HITTEST* = TCM_FIRST+13 + TCM_SETITEMEXTRA* = TCM_FIRST+14 + TCM_ADJUSTRECT* = TCM_FIRST+40 + TCM_SETITEMSIZE* = TCM_FIRST+41 + TCM_REMOVEIMAGE* = TCM_FIRST+42 + TCM_SETPADDING* = TCM_FIRST+43 + TCM_GETROWCOUNT* = TCM_FIRST+44 + TCM_GETTOOLTIPS* = TCM_FIRST+45 + TCM_SETTOOLTIPS* = TCM_FIRST+46 + TCM_GETCURFOCUS* = TCM_FIRST+47 + TCM_SETCURFOCUS* = TCM_FIRST+48 + TCM_SETMINTABWIDTH* = TCM_FIRST+49 + TCM_DESELECTALL* = TCM_FIRST+50 + TCM_HIGHLIGHTITEM* = TCM_FIRST+51 + TCM_SETEXTENDEDSTYLE* = TCM_FIRST+52 + TCM_GETEXTENDEDSTYLE* = TCM_FIRST+53 + TCM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + TCM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + TCN_KEYDOWN* = TCN_FIRST-0 + TCN_SELCHANGE* = TCN_FIRST-1 + TCN_SELCHANGING* = TCN_FIRST-2 + TCN_GETOBJECT* = TCN_FIRST-3 + TCN_FOCUSCHANGE* = TCN_FIRST-4 + ANIMATE_CLASSW* = "SysAnimate32" + ANIMATE_CLASSA* = "SysAnimate32" + ACS_CENTER* = 0x1 + ACS_TRANSPARENT* = 0x2 + ACS_AUTOPLAY* = 0x4 + ACS_TIMER* = 0x8 + ACM_OPENA* = WM_USER+100 + ACM_OPENW* = WM_USER+103 + ACM_PLAY* = WM_USER+101 + ACM_STOP* = WM_USER+102 + ACM_ISPLAYING* = WM_USER+104 + ACN_START* = 1 + ACN_STOP* = 2 + MONTHCAL_CLASSW* = "SysMonthCal32" + MONTHCAL_CLASSA* = "SysMonthCal32" + MCM_FIRST* = 0x1000 + MCM_GETCURSEL* = MCM_FIRST+1 + MCM_SETCURSEL* = MCM_FIRST+2 + MCM_GETMAXSELCOUNT* = MCM_FIRST+3 + MCM_SETMAXSELCOUNT* = MCM_FIRST+4 + MCM_GETSELRANGE* = MCM_FIRST+5 + MCM_SETSELRANGE* = MCM_FIRST+6 + MCM_GETMONTHRANGE* = MCM_FIRST+7 + MCM_SETDAYSTATE* = MCM_FIRST+8 + MCM_GETMINREQRECT* = MCM_FIRST+9 + MCM_SETCOLOR* = MCM_FIRST+10 + MCM_GETCOLOR* = MCM_FIRST+11 + MCSC_BACKGROUND* = 0 + MCSC_TEXT* = 1 + MCSC_TITLEBK* = 2 + MCSC_TITLETEXT* = 3 + MCSC_MONTHBK* = 4 + MCSC_TRAILINGTEXT* = 5 + MCM_SETTODAY* = MCM_FIRST+12 + MCM_GETTODAY* = MCM_FIRST+13 + MCM_HITTEST* = MCM_FIRST+14 + MCHT_TITLE* = 0x10000 + MCHT_CALENDAR* = 0x20000 + MCHT_TODAYLINK* = 0x30000 + MCHT_CALENDARCONTROL* = 0x100000 + MCHT_NEXT* = 0x1000000 + MCHT_PREV* = 0x2000000 + MCHT_NOWHERE* = 0x0 + MCHT_TITLEBK* = MCHT_TITLE + MCHT_TITLEMONTH* = MCHT_TITLE or 0x1 + MCHT_TITLEYEAR* = MCHT_TITLE or 0x2 + MCHT_TITLEBTNNEXT* = MCHT_TITLE or MCHT_NEXT or 0x3 + MCHT_TITLEBTNPREV* = MCHT_TITLE or MCHT_PREV or 0x3 + MCHT_CALENDARBK* = MCHT_CALENDAR + MCHT_CALENDARDATE* = MCHT_CALENDAR or 0x1 + MCHT_CALENDARDATENEXT* = MCHT_CALENDARDATE or MCHT_NEXT + MCHT_CALENDARDATEPREV* = MCHT_CALENDARDATE or MCHT_PREV + MCHT_CALENDARDAY* = MCHT_CALENDAR or 0x2 + MCHT_CALENDARWEEKNUM* = MCHT_CALENDAR or 0x3 + MCHT_CALENDARDATEMIN* = MCHT_CALENDAR or 0x4 + MCHT_CALENDARDATEMAX* = MCHT_CALENDAR or 0x5 + MCM_SETFIRSTDAYOFWEEK* = MCM_FIRST+15 + MCM_GETFIRSTDAYOFWEEK* = MCM_FIRST+16 + MCM_GETRANGE* = MCM_FIRST+17 + MCM_SETRANGE* = MCM_FIRST+18 + MCM_GETMONTHDELTA* = MCM_FIRST+19 + MCM_SETMONTHDELTA* = MCM_FIRST+20 + MCM_GETMAXTODAYWIDTH* = MCM_FIRST+21 + MCM_SETUNICODEFORMAT* = CCM_SETUNICODEFORMAT + MCM_GETUNICODEFORMAT* = CCM_GETUNICODEFORMAT + MCMV_MONTH* = 0 + MCMV_YEAR* = 1 + MCMV_DECADE* = 2 + MCMV_CENTURY* = 3 + MCMV_MAX* = MCMV_CENTURY + MCM_GETCURRENTVIEW* = MCM_FIRST+22 + MCM_GETCALENDARCOUNT* = MCM_FIRST+23 + MCGIP_CALENDARCONTROL* = 0 + MCGIP_NEXT* = 1 + MCGIP_PREV* = 2 + MCGIP_FOOTER* = 3 + MCGIP_CALENDAR* = 4 + MCGIP_CALENDARHEADER* = 5 + MCGIP_CALENDARBODY* = 6 + MCGIP_CALENDARROW* = 7 + MCGIP_CALENDARCELL* = 8 + MCGIF_DATE* = 01 + MCGIF_RECT* = 0x2 + MCGIF_NAME* = 0x4 + MCM_GETCALENDARGRIDINFO* = MCM_FIRST+24 + MCM_GETCALID* = MCM_FIRST+27 + MCM_SETCALID* = MCM_FIRST+28 + MCM_SIZERECTTOMIN* = MCM_FIRST+29 + MCM_SETCALENDARBORDER* = MCM_FIRST+30 + MCM_GETCALENDARBORDER* = MCM_FIRST+31 + MCM_SETCURRENTVIEW* = MCM_FIRST+32 + MCN_SELCHANGE* = MCN_FIRST-3 + MCN_GETDAYSTATE* = MCN_FIRST+3 + MCN_SELECT* = MCN_FIRST + MCN_VIEWCHANGE* = MCN_FIRST-4 + MCS_DAYSTATE* = 0x1 + MCS_MULTISELECT* = 0x2 + MCS_WEEKNUMBERS* = 0x4 + MCS_NOTODAYCIRCLE* = 0x8 + MCS_NOTODAY* = 0x10 + MCS_NOTRAILINGDATES* = 0x40 + MCS_SHORTDAYSOFWEEK* = 0x80 + MCS_NOSELCHANGEONNAV* = 0x100 + GMR_VISIBLE* = 0 + GMR_DAYSTATE* = 1 + DATETIMEPICK_CLASSW* = "SysDateTimePick32" + DATETIMEPICK_CLASSA* = "SysDateTimePick32" + DTM_FIRST* = 0x1000 + DTM_GETSYSTEMTIME* = DTM_FIRST+1 + DTM_SETSYSTEMTIME* = DTM_FIRST+2 + DTM_GETRANGE* = DTM_FIRST+3 + DTM_SETRANGE* = DTM_FIRST+4 + DTM_SETFORMATA* = DTM_FIRST+5 + DTM_SETFORMATW* = DTM_FIRST+50 + DTM_SETMCCOLOR* = DTM_FIRST+6 + DTM_GETMCCOLOR* = DTM_FIRST+7 + DTM_GETMONTHCAL* = DTM_FIRST+8 + DTM_SETMCFONT* = DTM_FIRST+9 + DTM_GETMCFONT* = DTM_FIRST+10 + DTM_SETMCSTYLE* = DTM_FIRST+11 + DTM_GETMCSTYLE* = DTM_FIRST+12 + DTM_CLOSEMONTHCAL* = DTM_FIRST+13 + DTM_GETDATETIMEPICKERINFO* = DTM_FIRST+14 + DTM_GETIDEALSIZE* = DTM_FIRST+15 + DTS_UPDOWN* = 0x1 + DTS_SHOWNONE* = 0x2 + DTS_SHORTDATEFORMAT* = 0x0 + DTS_LONGDATEFORMAT* = 0x4 + DTS_SHORTDATECENTURYFORMAT* = 0xc + DTS_TIMEFORMAT* = 0x9 + DTS_APPCANPARSE* = 0x10 + DTS_RIGHTALIGN* = 0x20 + DTN_DATETIMECHANGE* = DTN_FIRST2-6 + DTN_USERSTRINGA* = DTN_FIRST2-5 + DTN_USERSTRINGW* = DTN_FIRST-5 + DTN_WMKEYDOWNA* = DTN_FIRST2-4 + DTN_WMKEYDOWNW* = DTN_FIRST-4 + DTN_FORMATA* = DTN_FIRST2-3 + DTN_FORMATW* = DTN_FIRST-3 + DTN_FORMATQUERYA* = DTN_FIRST2-2 + DTN_FORMATQUERYW* = DTN_FIRST-2 + DTN_DROPDOWN* = DTN_FIRST2-1 + DTN_CLOSEUP* = DTN_FIRST2 + GDTR_MIN* = 0x1 + GDTR_MAX* = 0x2 + GDT_ERROR* = -1 + GDT_VALID* = 0 + GDT_NONE* = 1 + IPM_CLEARADDRESS* = WM_USER+100 + IPM_SETADDRESS* = WM_USER+101 + IPM_GETADDRESS* = WM_USER+102 + IPM_SETRANGE* = WM_USER+103 + IPM_SETFOCUS* = WM_USER+104 + IPM_ISBLANK* = WM_USER+105 + WC_IPADDRESSW* = "SysIPAddress32" + WC_IPADDRESSA* = "SysIPAddress32" + IPN_FIELDCHANGED* = IPN_FIRST-0 + WC_PAGESCROLLERW* = "SysPager" + WC_PAGESCROLLERA* = "SysPager" + PGS_VERT* = 0x0 + PGS_HORZ* = 0x1 + PGS_AUTOSCROLL* = 0x2 + PGS_DRAGNDROP* = 0x4 + PGF_INVISIBLE* = 0 + PGF_NORMAL* = 1 + PGF_GRAYED* = 2 + PGF_DEPRESSED* = 4 + PGF_HOT* = 8 + PGB_TOPORLEFT* = 0 + PGB_BOTTOMORRIGHT* = 1 + PGM_SETCHILD* = PGM_FIRST+1 + PGM_RECALCSIZE* = PGM_FIRST+2 + PGM_FORWARDMOUSE* = PGM_FIRST+3 + PGM_SETBKCOLOR* = PGM_FIRST+4 + PGM_GETBKCOLOR* = PGM_FIRST+5 + PGM_SETBORDER* = PGM_FIRST+6 + PGM_GETBORDER* = PGM_FIRST+7 + PGM_SETPOS* = PGM_FIRST+8 + PGM_GETPOS* = PGM_FIRST+9 + PGM_SETBUTTONSIZE* = PGM_FIRST+10 + PGM_GETBUTTONSIZE* = PGM_FIRST+11 + PGM_GETBUTTONSTATE* = PGM_FIRST+12 + PGM_GETDROPTARGET* = CCM_GETDROPTARGET + PGM_SETSCROLLINFO* = PGM_FIRST+13 + PGN_SCROLL* = PGN_FIRST-1 + PGF_SCROLLUP* = 1 + PGF_SCROLLDOWN* = 2 + PGF_SCROLLLEFT* = 4 + PGF_SCROLLRIGHT* = 8 + PGK_SHIFT* = 1 + PGK_CONTROL* = 2 + PGK_MENU* = 4 + PGN_CALCSIZE* = PGN_FIRST-2 + PGF_CALCWIDTH* = 1 + PGF_CALCHEIGHT* = 2 + PGN_HOTITEMCHANGE* = PGN_FIRST-3 + WC_NATIVEFONTCTLW* = "NativeFontCtl" + WC_NATIVEFONTCTLA* = "NativeFontCtl" + NFS_EDIT* = 0x1 + NFS_STATIC* = 0x2 + NFS_LISTCOMBO* = 0x4 + NFS_BUTTON* = 0x8 + NFS_ALL* = 0x10 + NFS_USEFONTASSOC* = 0x20 + WC_BUTTONA* = "Button" + WC_BUTTONW* = "Button" + BUTTON_IMAGELIST_ALIGN_LEFT* = 0 + BUTTON_IMAGELIST_ALIGN_RIGHT* = 1 + BUTTON_IMAGELIST_ALIGN_TOP* = 2 + BUTTON_IMAGELIST_ALIGN_BOTTOM* = 3 + BUTTON_IMAGELIST_ALIGN_CENTER* = 4 + BCM_GETIDEALSIZE* = BCM_FIRST+0x1 + BCM_SETIMAGELIST* = BCM_FIRST+0x2 + BCM_GETIMAGELIST* = BCM_FIRST+0x3 + BCM_SETTEXTMARGIN* = BCM_FIRST+0x4 + BCM_GETTEXTMARGIN* = BCM_FIRST+0x5 + BCN_HOTITEMCHANGE* = BCN_FIRST+0x1 + BST_HOT* = 0x0200 + BST_DROPDOWNPUSHED* = 0x0400 + BS_SPLITBUTTON* = 0xc + BS_DEFSPLITBUTTON* = 0xd + BS_COMMANDLINK* = 0xe + BS_DEFCOMMANDLINK* = 0xf + BCSIF_GLYPH* = 0x0001 + BCSIF_IMAGE* = 0x0002 + BCSIF_STYLE* = 0x0004 + BCSIF_SIZE* = 0x0008 + BCSS_NOSPLIT* = 0x0001 + BCSS_STRETCH* = 0x0002 + BCSS_ALIGNLEFT* = 0x0004 + BCSS_IMAGE* = 0x0008 + BCM_SETDROPDOWNSTATE* = BCM_FIRST+0x6 + BCM_SETSPLITINFO* = BCM_FIRST+0x7 + BCM_GETSPLITINFO* = BCM_FIRST+0x8 + BCM_SETNOTE* = BCM_FIRST+0x9 + BCM_GETNOTE* = BCM_FIRST+0xa + BCM_GETNOTELENGTH* = BCM_FIRST+0xb + BCM_SETSHIELD* = BCM_FIRST+0xc + BCN_DROPDOWN* = BCN_FIRST+0x0002 + WC_STATICA* = "Static" + WC_STATICW* = "Static" + WC_EDITA* = "Edit" + WC_EDITW* = "Edit" + EM_SETCUEBANNER* = ECM_FIRST+1 + EM_GETCUEBANNER* = ECM_FIRST+2 + EM_SHOWBALLOONTIP* = ECM_FIRST+3 + EM_HIDEBALLOONTIP* = ECM_FIRST+4 + EM_SETHILITE* = ECM_FIRST+5 + EM_GETHILITE* = ECM_FIRST+6 + EM_NOSETFOCUS* = ECM_FIRST+7 + EM_TAKEFOCUS* = ECM_FIRST+8 + WC_LISTBOXA* = "ListBox" + WC_LISTBOXW* = "ListBox" + WC_COMBOBOXA* = "ComboBox" + WC_COMBOBOXW* = "ComboBox" + CB_SETMINVISIBLE* = CBM_FIRST+1 + CB_GETMINVISIBLE* = CBM_FIRST+2 + CB_SETCUEBANNER* = CBM_FIRST+3 + CB_GETCUEBANNER* = CBM_FIRST+4 + WC_SCROLLBARA* = "ScrollBar" + WC_SCROLLBARW* = "ScrollBar" + LWS_TRANSPARENT* = 0x1 + LWS_IGNORERETURN* = 0x2 + LWS_NOPREFIX* = 0x4 + LWS_USEVISUALSTYLE* = 0x8 + LWS_USECUSTOMTEXT* = 0x10 + LWS_RIGHT* = 0x20 + LIF_ITEMINDEX* = 0x1 + LIF_STATE* = 0x2 + LIF_ITEMID* = 0x4 + LIF_URL* = 0x8 + LIS_FOCUSED* = 0x1 + LIS_ENABLED* = 0x2 + LIS_VISITED* = 0x4 + LIS_HOTTRACK* = 0x8 + LIS_DEFAULTCOLORS* = 0x10 + LM_HITTEST* = WM_USER+0x300 + LM_GETIDEALHEIGHT* = WM_USER+0x301 + LM_SETITEM* = WM_USER+0x302 + LM_GETITEM* = WM_USER+0x303 + TDF_ENABLE_HYPERLINKS* = 0x1 + TDF_USE_HICON_MAIN* = 0x2 + TDF_USE_HICON_FOOTER* = 0x4 + TDF_ALLOW_DIALOG_CANCELLATION* = 0x8 + TDF_USE_COMMAND_LINKS* = 0x10 + TDF_USE_COMMAND_LINKS_NO_ICON* = 0x20 + TDF_EXPAND_FOOTER_AREA* = 0x40 + TDF_EXPANDED_BY_DEFAULT* = 0x80 + TDF_VERIFICATION_FLAG_CHECKED* = 0x100 + TDF_SHOW_PROGRESS_BAR* = 0x0200 + TDF_SHOW_MARQUEE_PROGRESS_BAR* = 0x0400 + TDF_CALLBACK_TIMER* = 0x0800 + TDF_POSITION_RELATIVE_TO_WINDOW* = 0x1000 + TDF_RTL_LAYOUT* = 0x2000 + TDF_NO_DEFAULT_RADIO_BUTTON* = 0x4000 + TDF_CAN_BE_MINIMIZED* = 0x8000 + TDF_NO_SET_FOREGROUND* = 0x10000 + TDF_SIZE_TO_CONTENT* = 0x1000000 + TDM_NAVIGATE_PAGE* = WM_USER+101 + TDM_CLICK_BUTTON* = WM_USER+102 + TDM_SET_MARQUEE_PROGRESS_BAR* = WM_USER+103 + TDM_SET_PROGRESS_BAR_STATE* = WM_USER+104 + TDM_SET_PROGRESS_BAR_RANGE* = WM_USER+105 + TDM_SET_PROGRESS_BAR_POS* = WM_USER+106 + TDM_SET_PROGRESS_BAR_MARQUEE* = WM_USER+107 + TDM_SET_ELEMENT_TEXT* = WM_USER+108 + TDM_CLICK_RADIO_BUTTON* = WM_USER+110 + TDM_ENABLE_BUTTON* = WM_USER+111 + TDM_ENABLE_RADIO_BUTTON* = WM_USER+112 + TDM_CLICK_VERIFICATION* = WM_USER+113 + TDM_UPDATE_ELEMENT_TEXT* = WM_USER+114 + TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE* = WM_USER+115 + TDM_UPDATE_ICON* = WM_USER+116 + TDN_CREATED* = 0 + TDN_NAVIGATED* = 1 + TDN_BUTTON_CLICKED* = 2 + TDN_HYPERLINK_CLICKED* = 3 + TDN_TIMER* = 4 + TDN_DESTROYED* = 5 + TDN_RADIO_BUTTON_CLICKED* = 6 + TDN_DIALOG_CONSTRUCTED* = 7 + TDN_VERIFICATION_CLICKED* = 8 + TDN_HELP* = 9 + TDN_EXPANDO_BUTTON_CLICKED* = 10 + TDE_CONTENT* = 0 + TDE_EXPANDED_INFORMATION* = 1 + TDE_FOOTER* = 2 + TDE_MAIN_INSTRUCTION* = 3 + TDIE_ICON_MAIN* = 0 + TDIE_ICON_FOOTER* = 1 + TD_WARNING_ICON* = MAKEINTRESOURCEW(-1) + TD_ERROR_ICON* = MAKEINTRESOURCEW(-2) + TD_INFORMATION_ICON* = MAKEINTRESOURCEW(-3) + TD_SHIELD_ICON* = MAKEINTRESOURCEW(-4) + TDCBF_OK_BUTTON* = 0x1 + TDCBF_YES_BUTTON* = 0x2 + TDCBF_NO_BUTTON* = 0x4 + TDCBF_CANCEL_BUTTON* = 0x8 + TDCBF_RETRY_BUTTON* = 0x10 + TDCBF_CLOSE_BUTTON* = 0x20 + DA_LAST* = 0x7fffffff + DA_ERR* = -1 + DSA_APPEND* = DA_LAST + DSA_ERR* = DA_ERR + DPAM_SORTED* = 0x1 + DPAM_NORMAL* = 0x2 + DPAM_UNION* = 0x4 + DPAM_INTERSECT* = 0x8 + DPAMM_MERGE* = 1 + DPAMM_DELETE* = 2 + DPAMM_INSERT* = 3 + DPAS_SORTED* = 0x1 + DPAS_INSERTBEFORE* = 0x2 + DPAS_INSERTAFTER* = 0x4 + DPA_APPEND* = DA_LAST + DPA_ERR* = DA_ERR + WSB_PROP_CYVSCROLL* = 0x1 + WSB_PROP_CXHSCROLL* = 0x2 + WSB_PROP_CYHSCROLL* = 0x4 + WSB_PROP_CXVSCROLL* = 0x8 + WSB_PROP_CXHTHUMB* = 0x10 + WSB_PROP_CYVTHUMB* = 0x20 + WSB_PROP_VBKGCOLOR* = 0x40 + WSB_PROP_HBKGCOLOR* = 0x80 + WSB_PROP_VSTYLE* = 0x100 + WSB_PROP_HSTYLE* = 0x200 + WSB_PROP_WINSTYLE* = 0x400 + WSB_PROP_PALETTE* = 0x800 + WSB_PROP_MASK* = 0xfff + FSB_FLAT_MODE* = 2 + FSB_ENCARTA_MODE* = 1 + FSB_REGULAR_MODE* = 0 + LIM_SMALL* = 0 + LIM_LARGE* = 1 + ILIF_ALPHA* = 0x1 + ILIF_LOWQUALITY* = 0x2 + ILDRF_IMAGELOWQUALITY* = 0x1 + ILDRF_OVERLAYLOWQUALITY* = 0x10 + ILR_DEFAULT* = 0x0 + ILR_HORIZONTAL_LEFT* = 0x0 + ILR_HORIZONTAL_CENTER* = 0x1 + ILR_HORIZONTAL_RIGHT* = 0x2 + ILR_VERTICAL_TOP* = 0x0 + ILR_VERTICAL_CENTER* = 0x10 + ILR_VERTICAL_BOTTOM* = 0x20 + ILR_SCALE_CLIP* = 0x0 + ILR_SCALE_ASPECTRATIO* = 0x100 + ILGOS_ALWAYS* = 0x0 + ILGOS_FROMSTANDBY* = 0x1 + ILFIP_ALWAYS* = 0x0 + ILFIP_FROMSTANDBY* = 0x1 + ILDI_PURGE* = 0x1 + ILDI_STANDBY* = 0x2 + ILDI_RESETACCESS* = 0x4 + ILDI_QUERYACCESS* = 0x8 + IID_IImageList* = DEFINE_GUID("46eb5926-582e-4017-9fdf-e8998daa0950") + IID_IImageList2* = DEFINE_GUID("192b9d83-50fc-457b-90a0-2b82a8b5dae1") + LIBID_CommonControlObjects* = DEFINE_GUID("bcada15b-b428-420c-8d28-023590924c9f") + CLSID_ImageList* = DEFINE_GUID("7c476ba2-02b1-48f4-8048-b24619ddc058") + BCCL_NOGLYPH* = HIMAGELIST(-1) + LPSTR_TEXTCALLBACKA* = cast[LPSTR](-1) + LPSTR_TEXTCALLBACKW* = cast[LPWSTR](-1) + TVI_FIRST* = HTREEITEM(-0xffff) + TVI_LAST* = HTREEITEM(-0xfffe) + TVI_ROOT* = HTREEITEM(-0x10000) + TVI_SORT* = HTREEITEM(-0xfffd) + LM_GETIDEALSIZE* = LM_GETIDEALHEIGHT +type + LPFNADDPROPSHEETPAGE* = proc (P1: HPROPSHEETPAGE, P2: LPARAM): WINBOOL {.stdcall.} + LPFNADDPROPSHEETPAGES* = proc (P1: LPVOID, P2: LPFNADDPROPSHEETPAGE, P3: LPARAM): WINBOOL {.stdcall.} + PFNLVCOMPARE* = proc (P1: LPARAM, P2: LPARAM, P3: LPARAM): int32 {.stdcall.} + PFTASKDIALOGCALLBACK* = proc (hwnd: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM, lpRefData: LONG_PTR): HRESULT {.stdcall.} + DPASTREAMINFO* {.pure.} = object + iPos*: int32 + pvItem*: pointer + PFNDPASTREAM* = proc (pinfo: ptr DPASTREAMINFO, pstream: ptr IStream, pvInstData: pointer): HRESULT {.stdcall.} + PFNDPAMERGE* = proc (uMsg: UINT, pvDest: pointer, pvSrc: pointer, lParam: LPARAM): pointer {.stdcall.} + PFNDPAMERGECONST* = proc (uMsg: UINT, pvDest: pointer, pvSrc: pointer, lParam: LPARAM): pointer {.stdcall.} + SUBCLASSPROC* = proc (hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, uIdSubclass: UINT_PTR, dwRefData: DWORD_PTR): LRESULT {.stdcall.} + NMTRBTHUMBPOSCHANGING* {.pure.} = object + hdr*: NMHDR + dwPos*: DWORD + nReason*: int32 + NMLVEMPTYMARKUP* {.pure.} = object + hdr*: NMHDR + dwFlags*: DWORD + szMarkup*: array[L_MAX_URL_LENGTH, WCHAR] + TVGETITEMPARTRECTINFO* {.pure.} = object + hti*: HTREEITEM + prc*: ptr RECT + partID*: TVITEMPART + NMTVITEMCHANGE* {.pure.} = object + hdr*: NMHDR + uChanged*: UINT + hItem*: HTREEITEM + uStateNew*: UINT + uStateOld*: UINT + lParam*: LPARAM + NMTVASYNCDRAW* {.pure.} = object + hdr*: NMHDR + pimldp*: ptr IMAGELISTDRAWPARAMS + hr*: HRESULT + hItem*: HTREEITEM + lParam*: LPARAM + dwRetFlags*: DWORD + iRetImageIndex*: int32 + TASKDIALOG_BUTTON* {.pure, packed.} = object + nButtonID*: int32 + pszButtonText*: PCWSTR + TASKDIALOGCONFIG_UNION1* {.pure, union.} = object + hMainIcon*: HICON + pszMainIcon*: PCWSTR + TASKDIALOGCONFIG_UNION2* {.pure, union.} = object + hFooterIcon*: HICON + pszFooterIcon*: PCWSTR + TASKDIALOGCONFIG* {.pure, packed.} = object + cbSize*: UINT + hwndParent*: HWND + hInstance*: HINSTANCE + dwFlags*: TASKDIALOG_FLAGS + dwCommonButtons*: TASKDIALOG_COMMON_BUTTON_FLAGS + pszWindowTitle*: PCWSTR + union1*: TASKDIALOGCONFIG_UNION1 + pszMainInstruction*: PCWSTR + pszContent*: PCWSTR + cButtons*: UINT + pButtons*: ptr TASKDIALOG_BUTTON + nDefaultButton*: int32 + cRadioButtons*: UINT + pRadioButtons*: ptr TASKDIALOG_BUTTON + nDefaultRadioButton*: int32 + pszVerificationText*: PCWSTR + pszExpandedInformation*: PCWSTR + pszExpandedControlText*: PCWSTR + pszCollapsedControlText*: PCWSTR + union2*: TASKDIALOGCONFIG_UNION2 + pszFooter*: PCWSTR + pfCallback*: PFTASKDIALOGCALLBACK + lpCallbackData*: LONG_PTR + cxWidth*: UINT + IMAGELISTSTATS* {.pure.} = object + cbSize*: DWORD + cAlloc*: int32 + cUsed*: int32 + cStandby*: int32 + IImageList* {.pure.} = object + lpVtbl*: ptr IImageListVtbl + IImageListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Add*: proc(self: ptr IImageList, hbmImage: HBITMAP, hbmMask: HBITMAP, pi: ptr int32): HRESULT {.stdcall.} + ReplaceIcon*: proc(self: ptr IImageList, i: int32, hicon: HICON, pi: ptr int32): HRESULT {.stdcall.} + SetOverlayImage*: proc(self: ptr IImageList, iImage: int32, iOverlay: int32): HRESULT {.stdcall.} + Replace*: proc(self: ptr IImageList, i: int32, hbmImage: HBITMAP, hbmMask: HBITMAP): HRESULT {.stdcall.} + AddMasked*: proc(self: ptr IImageList, hbmImage: HBITMAP, crMask: COLORREF, pi: ptr int32): HRESULT {.stdcall.} + Draw*: proc(self: ptr IImageList, pimldp: ptr IMAGELISTDRAWPARAMS): HRESULT {.stdcall.} + Remove*: proc(self: ptr IImageList, i: int32): HRESULT {.stdcall.} + GetIcon*: proc(self: ptr IImageList, i: int32, flags: UINT, picon: ptr HICON): HRESULT {.stdcall.} + GetImageInfo*: proc(self: ptr IImageList, i: int32, pImageInfo: ptr IMAGEINFO): HRESULT {.stdcall.} + Copy*: proc(self: ptr IImageList, iDst: int32, punkSrc: ptr IUnknown, iSrc: int32, uFlags: UINT): HRESULT {.stdcall.} + Merge*: proc(self: ptr IImageList, i1: int32, punk2: ptr IUnknown, i2: int32, dx: int32, dy: int32, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + Clone*: proc(self: ptr IImageList, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetImageRect*: proc(self: ptr IImageList, i: int32, prc: ptr RECT): HRESULT {.stdcall.} + GetIconSize*: proc(self: ptr IImageList, cx: ptr int32, cy: ptr int32): HRESULT {.stdcall.} + SetIconSize*: proc(self: ptr IImageList, cx: int32, cy: int32): HRESULT {.stdcall.} + GetImageCount*: proc(self: ptr IImageList, pi: ptr int32): HRESULT {.stdcall.} + SetImageCount*: proc(self: ptr IImageList, uNewCount: UINT): HRESULT {.stdcall.} + SetBkColor*: proc(self: ptr IImageList, clrBk: COLORREF, pclr: ptr COLORREF): HRESULT {.stdcall.} + GetBkColor*: proc(self: ptr IImageList, pclr: ptr COLORREF): HRESULT {.stdcall.} + BeginDrag*: proc(self: ptr IImageList, iTrack: int32, dxHotspot: int32, dyHotspot: int32): HRESULT {.stdcall.} + EndDrag*: proc(self: ptr IImageList): HRESULT {.stdcall.} + DragEnter*: proc(self: ptr IImageList, hwndLock: HWND, x: int32, y: int32): HRESULT {.stdcall.} + DragLeave*: proc(self: ptr IImageList, hwndLock: HWND): HRESULT {.stdcall.} + DragMove*: proc(self: ptr IImageList, x: int32, y: int32): HRESULT {.stdcall.} + SetDragCursorImage*: proc(self: ptr IImageList, punk: ptr IUnknown, iDrag: int32, dxHotspot: int32, dyHotspot: int32): HRESULT {.stdcall.} + DragShowNolock*: proc(self: ptr IImageList, fShow: WINBOOL): HRESULT {.stdcall.} + GetDragImage*: proc(self: ptr IImageList, ppt: ptr POINT, pptHotspot: ptr POINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetItemFlags*: proc(self: ptr IImageList, i: int32, dwFlags: ptr DWORD): HRESULT {.stdcall.} + GetOverlayImage*: proc(self: ptr IImageList, iOverlay: int32, piIndex: ptr int32): HRESULT {.stdcall.} + IImageList2* {.pure.} = object + lpVtbl*: ptr IImageList2Vtbl + IImageList2Vtbl* {.pure, inheritable.} = object of IImageListVtbl + Resize*: proc(self: ptr IImageList2, cxNewIconSize: int32, cyNewIconSize: int32): HRESULT {.stdcall.} + GetOriginalSize*: proc(self: ptr IImageList2, iImage: int32, dwFlags: DWORD, pcx: ptr int32, pcy: ptr int32): HRESULT {.stdcall.} + SetOriginalSize*: proc(self: ptr IImageList2, iImage: int32, cx: int32, cy: int32): HRESULT {.stdcall.} + SetCallback*: proc(self: ptr IImageList2, punk: ptr IUnknown): HRESULT {.stdcall.} + GetCallback*: proc(self: ptr IImageList2, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + ForceImagePresent*: proc(self: ptr IImageList2, iImage: int32, dwFlags: DWORD): HRESULT {.stdcall.} + DiscardImages*: proc(self: ptr IImageList2, iFirstImage: int32, iLastImage: int32, dwFlags: DWORD): HRESULT {.stdcall.} + PreloadImages*: proc(self: ptr IImageList2, pimldp: ptr IMAGELISTDRAWPARAMS): HRESULT {.stdcall.} + GetStatistics*: proc(self: ptr IImageList2, pils: ptr IMAGELISTSTATS): HRESULT {.stdcall.} + Initialize*: proc(self: ptr IImageList2, cx: int32, cy: int32, flags: UINT, cInitial: int32, cGrow: int32): HRESULT {.stdcall.} + Replace2*: proc(self: ptr IImageList2, i: int32, hbmImage: HBITMAP, hbmMask: HBITMAP, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.stdcall.} + ReplaceFromImageList*: proc(self: ptr IImageList2, i: int32, pil: ptr IImageList, iSrc: int32, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.stdcall.} +proc CreatePropertySheetPageA*(constPropSheetPagePointer: LPCPROPSHEETPAGEA): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreatePropertySheetPageW*(constPropSheetPagePointer: LPCPROPSHEETPAGEW): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DestroyPropertySheetPage*(P1: HPROPSHEETPAGE): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc PropertySheetA*(P1: LPCPROPSHEETHEADERA): INT_PTR {.winapi, stdcall, dynlib: "comctl32", importc.} +proc PropertySheetW*(P1: LPCPROPSHEETHEADERW): INT_PTR {.winapi, stdcall, dynlib: "comctl32", importc.} +proc InitCommonControls*(): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc InitCommonControlsEx*(P1: ptr TINITCOMMONCONTROLSEX): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Create*(cx: int32, cy: int32, flags: UINT, cInitial: int32, cGrow: int32): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Destroy*(himl: HIMAGELIST): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetImageCount*(himl: HIMAGELIST): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_SetImageCount*(himl: HIMAGELIST, uNewCount: UINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Add*(himl: HIMAGELIST, hbmImage: HBITMAP, hbmMask: HBITMAP): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_ReplaceIcon*(himl: HIMAGELIST, i: int32, hicon: HICON): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_SetBkColor*(himl: HIMAGELIST, clrBk: COLORREF): COLORREF {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetBkColor*(himl: HIMAGELIST): COLORREF {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_SetOverlayImage*(himl: HIMAGELIST, iImage: int32, iOverlay: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Draw*(himl: HIMAGELIST, i: int32, hdcDst: HDC, x: int32, y: int32, fStyle: UINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Replace*(himl: HIMAGELIST, i: int32, hbmImage: HBITMAP, hbmMask: HBITMAP): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_AddMasked*(himl: HIMAGELIST, hbmImage: HBITMAP, crMask: COLORREF): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DrawEx*(himl: HIMAGELIST, i: int32, hdcDst: HDC, x: int32, y: int32, dx: int32, dy: int32, rgbBk: COLORREF, rgbFg: COLORREF, fStyle: UINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DrawIndirect*(pimldp: ptr IMAGELISTDRAWPARAMS): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Remove*(himl: HIMAGELIST, i: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetIcon*(himl: HIMAGELIST, i: int32, flags: UINT): HICON {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_LoadImageA*(hi: HINSTANCE, lpbmp: LPCSTR, cx: int32, cGrow: int32, crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_LoadImageW*(hi: HINSTANCE, lpbmp: LPCWSTR, cx: int32, cGrow: int32, crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Copy*(himlDst: HIMAGELIST, iDst: int32, himlSrc: HIMAGELIST, iSrc: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_BeginDrag*(himlTrack: HIMAGELIST, iTrack: int32, dxHotspot: int32, dyHotspot: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_EndDrag*(): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DragEnter*(hwndLock: HWND, x: int32, y: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DragLeave*(hwndLock: HWND): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DragMove*(x: int32, y: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_SetDragCursorImage*(himlDrag: HIMAGELIST, iDrag: int32, dxHotspot: int32, dyHotspot: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_DragShowNolock*(fShow: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetDragImage*(ppt: ptr POINT, pptHotspot: ptr POINT): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Read*(pstm: LPSTREAM): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Write*(himl: HIMAGELIST, pstm: LPSTREAM): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_ReadEx*(dwFlags: DWORD, pstm: LPSTREAM, riid: REFIID, ppv: ptr PVOID): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_WriteEx*(himl: HIMAGELIST, dwFlags: DWORD, pstm: LPSTREAM): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetIconSize*(himl: HIMAGELIST, cx: ptr int32, cy: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_SetIconSize*(himl: HIMAGELIST, cx: int32, cy: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_GetImageInfo*(himl: HIMAGELIST, i: int32, pImageInfo: ptr IMAGEINFO): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Merge*(himl1: HIMAGELIST, i1: int32, himl2: HIMAGELIST, i2: int32, dx: int32, dy: int32): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_Duplicate*(himl: HIMAGELIST): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc.} +proc HIMAGELIST_QueryInterface*(himl: HIMAGELIST, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreateToolbarEx*(hwnd: HWND, ws: DWORD, wID: UINT, nBitmaps: int32, hBMInst: HINSTANCE, wBMID: UINT_PTR, lpButtons: LPCTBBUTTON, iNumButtons: int32, dxButton: int32, dyButton: int32, dxBitmap: int32, dyBitmap: int32, uStructSize: UINT): HWND {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreateMappedBitmap*(hInstance: HINSTANCE, idBitmap: INT_PTR, wFlags: UINT, lpColorMap: LPCOLORMAP, iNumMaps: int32): HBITMAP {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DrawStatusTextA*(hDC: HDC, lprc: LPCRECT, pszText: LPCSTR, uFlags: UINT): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DrawStatusTextW*(hDC: HDC, lprc: LPCRECT, pszText: LPCWSTR, uFlags: UINT): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreateStatusWindowA*(style: LONG, lpszText: LPCSTR, hwndParent: HWND, wID: UINT): HWND {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreateStatusWindowW*(style: LONG, lpszText: LPCWSTR, hwndParent: HWND, wID: UINT): HWND {.winapi, stdcall, dynlib: "comctl32", importc.} +proc MenuHelp*(uMsg: UINT, wParam: WPARAM, lParam: LPARAM, hMainMenu: HMENU, hInst: HINSTANCE, hwndStatus: HWND, lpwIDs: ptr UINT): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ShowHideMenuCtl*(hWnd: HWND, uFlags: UINT_PTR, lpInfo: LPINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc GetEffectiveClientRect*(hWnd: HWND, lprc: LPRECT, lpInfo: ptr INT): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc MakeDragList*(hLB: HWND): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DrawInsert*(handParent: HWND, hLB: HWND, nItem: int32): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc LBItemFromPt*(hLB: HWND, pt: POINT, bAutoScroll: WINBOOL): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc CreateUpDownControl*(dwStyle: DWORD, x: int32, y: int32, cx: int32, cy: int32, hParent: HWND, nID: int32, hInst: HINSTANCE, hBuddy: HWND, nUpper: int32, nLower: int32, nPos: int32): HWND {.winapi, stdcall, dynlib: "comctl32", importc.} +proc TaskDialogIndirect*(pTaskConfig: ptr TASKDIALOGCONFIG, pnButton: ptr int32, pnRadioButton: ptr int32, pfVerificationFlagChecked: ptr WINBOOL): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc TaskDialog*(hwndOwner: HWND, hInstance: HINSTANCE, pszWindowTitle: PCWSTR, pszMainInstruction: PCWSTR, pszContent: PCWSTR, dwCommonButtons: TASKDIALOG_COMMON_BUTTON_FLAGS, pszIcon: PCWSTR, pnButton: ptr int32): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc InitMUILanguage*(uiLang: LANGID): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc GetMUILanguage*(): LANGID {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_Create*(cbItem: int32, cItemGrow: int32): HDSA {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_Destroy*(hdsa: HDSA): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_DestroyCallback*(hdsa: HDSA, pfnCB: PFNDAENUMCALLBACK, pData: pointer): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_DeleteItem*(hdsa: HDSA, i: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_DeleteAllItems*(hdsa: HDSA): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_EnumCallback*(hdsa: HDSA, pfnCB: PFNDAENUMCALLBACK, pData: pointer): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_InsertItem*(hdsa: HDSA, i: int32, pitem: pointer): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_GetItemPtr*(hdsa: HDSA, i: int32): PVOID {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_GetItem*(hdsa: HDSA, i: int32, pitem: pointer): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_SetItem*(hdsa: HDSA, i: int32, pitem: pointer): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_Clone*(hdsa: HDSA): HDSA {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_GetSize*(hdsa: HDSA): ULONGLONG {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DSA_Sort*(pdsa: HDSA, pfnCompare: PFNDACOMPARE, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Create*(cItemGrow: int32): HDPA {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_CreateEx*(cpGrow: int32, hheap: HANDLE): HDPA {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Clone*(hdpa: HDPA, hdpaNew: HDPA): HDPA {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Destroy*(hdpa: HDPA): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_DestroyCallback*(hdpa: HDPA, pfnCB: PFNDAENUMCALLBACK, pData: pointer): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_DeletePtr*(hdpa: HDPA, i: int32): PVOID {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_DeleteAllPtrs*(hdpa: HDPA): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_EnumCallback*(hdpa: HDPA, pfnCB: PFNDAENUMCALLBACK, pData: pointer): void {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Grow*(pdpa: HDPA, cp: int32): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_InsertPtr*(hdpa: HDPA, i: int32, p: pointer): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_SetPtr*(hdpa: HDPA, i: int32, p: pointer): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_GetPtr*(hdpa: HDPA, i: INT_PTR): PVOID {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_GetPtrIndex*(hdpa: HDPA, p: pointer): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_GetSize*(hdpa: HDPA): ULONGLONG {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Sort*(hdpa: HDPA, pfnCompare: PFNDACOMPARE, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_LoadStream*(phdpa: ptr HDPA, pfn: PFNDPASTREAM, pstream: ptr IStream, pvInstData: pointer): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_SaveStream*(hdpa: HDPA, pfn: PFNDPASTREAM, pstream: ptr IStream, pvInstData: pointer): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Merge*(hdpaDest: HDPA, hdpaSrc: HDPA, dwFlags: DWORD, pfnCompare: PFNDACOMPARE, pfnMerge: PFNDPAMERGE, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DPA_Search*(hdpa: HDPA, pFind: pointer, iStart: int32, pfnCompare: PFNDACOMPARE, lParam: LPARAM, options: UINT): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc Str_SetPtrW*(ppsz: ptr LPWSTR, psz: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc COMCTL32_TrackMouseEvent*(lpEventTrack: LPTRACKMOUSEEVENT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc: "_TrackMouseEvent".} +proc FlatSB_EnableScrollBar*(P1: HWND, P2: int32, P3: UINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_ShowScrollBar*(P1: HWND, code: int32, P3: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_GetScrollRange*(P1: HWND, code: int32, P3: LPINT, P4: LPINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_GetScrollInfo*(P1: HWND, code: int32, P3: LPSCROLLINFO): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_GetScrollPos*(P1: HWND, code: int32): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_GetScrollProp*(P1: HWND, propIndex: int32, P3: LPINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_SetScrollPos*(P1: HWND, code: int32, pos: int32, fRedraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_SetScrollInfo*(P1: HWND, code: int32, P3: LPSCROLLINFO, fRedraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_SetScrollRange*(P1: HWND, code: int32, min: int32, max: int32, fRedraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_SetScrollProp*(P1: HWND, index: UINT, newValue: INT_PTR, P4: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc FlatSB_SetScrollPropPtr*(P1: HWND, index: UINT, newValue: INT_PTR, P4: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc: "FlatSB_SetScrollProp".} +proc InitializeFlatSB*(P1: HWND): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc UninitializeFlatSB*(P1: HWND): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc SetWindowSubclass*(hWnd: HWND, pfnSubclass: SUBCLASSPROC, uIdSubclass: UINT_PTR, dwRefData: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc GetWindowSubclass*(hWnd: HWND, pfnSubclass: SUBCLASSPROC, uIdSubclass: UINT_PTR, pdwRefData: ptr DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc RemoveWindowSubclass*(hWnd: HWND, pfnSubclass: SUBCLASSPROC, uIdSubclass: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DefSubclassProc*(hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc DrawShadowText*(hdc: HDC, pszText: LPCWSTR, cch: UINT, prc: ptr RECT, dwFlags: DWORD, crText: COLORREF, crShadow: COLORREF, ixOffset: int32, iyOffset: int32): int32 {.winapi, stdcall, dynlib: "comctl32", importc.} +proc LoadIconMetric*(hinst: HINSTANCE, pszName: PCWSTR, lims: int32, phico: ptr HICON): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc LoadIconWithScaleDown*(hinst: HINSTANCE, pszName: PCWSTR, cx: int32, cy: int32, phico: ptr HICON): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +proc ImageList_CoCreateInstance*(rclsid: REFCLSID, punkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "comctl32", importc.} +template HANDLE_WM_NOTIFY*(hwnd: HWND, wParam: WPARAM, lParam: LPARAM, fn: proc(hwnd: HWND, wParam: WPARAM, nmhdr: ptr NMHDR)) = fn(hwnd, wParam, cast[ptr NMHDR](lParam)) +template FORWARD_WM_NOTIFY*(hwnd: HWND, idFrom: int32, pnmhdr: ptr NMHDR, fn: SendMessage.type|PostMessage.type): untyped = fn(hwnd, WM_NOTIFY, WPARAM idFrom, cast[LPARAM](pnmhdr)) +template INDEXTOOVERLAYMASK*(i: untyped): untyped = i shl 8 +template INDEXTOSTATEIMAGEMASK*(i: untyped): untyped = i shl 12 +template MAKEIPRANGE*(low: BYTE, high: BYTE): LPARAM = (high.LPARAM shl 8) + low.LPARAM +template MAKEIPADDRESS*(b1: BYTE, b2: BYTE, b3: BYTE, b4: BYTE): LPARAM = (b1.LPARAM shl 24) + (b2.LPARAM shl 16) + (b3.LPARAM shl 8) + (b4.LPARAM) +template FIRST_IPADDRESS*(x: LPARAM): BYTE = cast[BYTE](x shr 24) +template SECOND_IPADDRESS*(x: LPARAM): BYTE = cast[BYTE](x shr 16) +template THIRD_IPADDRESS*(x: LPARAM): BYTE = cast[BYTE](x shr 8) +template FOURTH_IPADDRESS*(x: LPARAM): BYTE = cast[BYTE](x) +when winimUnicode: + const + ACM_OPEN* = ACM_OPENW +when winimAnsi: + const + ACM_OPEN* = ACM_OPENA +template Animate_Open*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL SendMessage(hwnd, ACM_OPEN, 0, cast[LPARAM](szName)) +template Animate_Close*(hwnd: HWND): BOOL = Animate_Open(hwnd, NULL) +when winimUnicode: + const + ANIMATE_CLASS* = ANIMATE_CLASSW +when winimAnsi: + const + ANIMATE_CLASS* = ANIMATE_CLASSA +template Animate_Create*(hwndP: HWND, id: UINT, dwStyle: DWORD, hInstance: HINSTANCE): HWND = CreateWindow(ANIMATE_CLASS, NULL, dwStyle, 0, 0, 0, 0, hwndP, id, hInstance, NULL) +template Animate_IsPlaying*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, ACM_ISPLAYING, 0, 0) +template Animate_OpenEx*(hwnd: HWND, hInst: HINSTANCE, szName: LPTSTR): BOOL = discardable BOOL SendMessage(hwnd, ACM_OPEN, cast[WPARAM](hInst), cast[LPARAM](szName)) +template Animate_Play*(hwnd: HWND, `from`: UINT, `to`: UINT, rep: UINT): BOOL = discardable BOOL SendMessage(hwnd, ACM_PLAY, cast[WPARAM](rep), cast[LPARAM](MAKELONG(`from`, `to`))) +template Animate_Seek*(hwnd: HWND, frame: UINT): BOOL = Animate_Play(hwnd, frame, frame, 1) +template Animate_Stop*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, ACM_STOP, 0, 0) +template Button_GetIdealSize*(hwnd: HWND, psize: ptr SIZE): BOOL = discardable BOOL SendMessage(hwnd, BCM_GETIDEALSIZE, 0, cast[LPARAM](psize)) +template Button_GetImageList*(hwnd: HWND, pbuttonImagelist: PBUTTON_IMAGELIST): BOOL = discardable BOOL SendMessage(hwnd, BCM_GETIMAGELIST, 0, cast[LPARAM](pbuttonImagelist)) +template Button_GetNote*(hwnd: HWND, psz: LPCWSTR, pcc: int32): BOOL = discardable BOOL SendMessage(hwnd, BCM_GETNOTE, cast[WPARAM](pcc), cast[LPARAM](psz)) +template Button_GetNoteLength*(hwnd: HWND): LRESULT = discardable LRESULT SendMessage(hwnd, BCM_GETNOTELENGTH, 0, 0) +template Button_GetSplitInfo*(hwnd: HWND, pInfo: ptr BUTTON_SPLITINFO): BOOL = discardable BOOL SendMessage(hwnd, BCM_GETSPLITINFO, 0, cast[LPARAM](pInfo)) +template Button_GetTextMargin*(hwnd: HWND, pmargin: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, BCM_GETTEXTMARGIN, 0, cast[LPARAM](pmargin)) +template Button_SetDropDownState*(hwnd: HWND, fDropDown: BOOL): BOOL = discardable BOOL SendMessage(hwnd, BCM_SETDROPDOWNSTATE, cast[WPARAM](fDropDown), 0) +template Button_SetElevationRequiredState*(hwnd: HWND, fRequired: BOOL): LRESULT = discardable LRESULT SendMessage(hwnd, BCM_SETSHIELD, 0, cast[LPARAM](fRequired)) +template Button_SetImageList*(hwnd: HWND, pbuttonImagelist: PBUTTON_IMAGELIST): BOOL = discardable BOOL SendMessage(hwnd, BCM_SETIMAGELIST, 0, cast[LPARAM](pbuttonImagelist)) +template Button_SetNote*(hwnd: HWND, psz: PCWSTR): BOOL = discardable BOOL SendMessage(hwnd, BCM_SETNOTE, 0, cast[LPARAM](psz)) +template Button_SetSplitInfo*(hwnd: HWND, pInfo: ptr BUTTON_SPLITINFO): BOOL = discardable BOOL SendMessage(hwnd, BCM_SETSPLITINFO, 0, cast[LPARAM](pInfo)) +template Button_SetTextMargin*(hwnd: HWND, pmargin: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, BCM_SETTEXTMARGIN, 0, cast[LPARAM](pmargin)) +template ComboBox_GetCueBannerText*(hwnd: HWND, lpwText: LPWSTR, cchText: int32): BOOL = discardable BOOL SendMessage(hwnd, CB_GETCUEBANNER, cast[WPARAM](lpwText), cast[LPARAM](cchText)) +template ComboBox_GetMinVisible*(hwnd: HWND): INT = discardable INT SendMessage(hwnd, CB_GETMINVISIBLE, 0, 0) +template ComboBox_SetCueBannerText*(hwnd: HWND, lpcwText: LPCWSTR): BOOL = discardable BOOL SendMessage(hwnd, CB_SETCUEBANNER, 0, cast[LPARAM](lpcwText)) +template ComboBox_SetMinVisible*(hwnd: HWND, iMinVisible: INT): BOOL = discardable BOOL SendMessage(hwnd, CB_SETMINVISIBLE, cast[WPARAM](iMinVisible), 0) +template DateTime_CloseMonthCal*(hdp: HWND): LRESULT = discardable LRESULT SendMessage(hdp, DTM_CLOSEMONTHCAL, 0, 0) +template DateTime_GetDateTimePickerInfo*(hdp: HWND, pdtpi: ptr DATETIMEPICKERINFO): LRESULT = discardable LRESULT SendMessage(hdp, DTM_GETDATETIMEPICKERINFO, 0, cast[LPARAM](pdtpi)) +template DateTime_GetIdealSize*(hdp: HWND, psize: SIZE): BOOL = discardable BOOL SendMessage(hdp, DTM_GETIDEALSIZE, 0, cast[LPARAM](psize)) +template DateTime_GetMonthCal*(hdp: HWND): HWND = discardable HWND SendMessage(hdp, DTM_GETMONTHCAL, 0, 0) +template DateTime_GetMonthCalColor*(hdp: HWND, iColor: int32): COLORREF = discardable COLORREF SendMessage(hdp, DTM_GETMCCOLOR, cast[WPARAM](iColor), 0) +template DateTime_GetMonthCalFont*(hdp: HWND): HFONT = discardable HFONT SendMessage(hdp, DTM_GETMCFONT, 0, 0) +template DateTime_GetMonthCalStyle*(hdp: HWND): LRESULT = discardable LRESULT SendMessage(hdp, DTM_GETMCSTYLE, 0, 0) +template DateTime_GetRange*(hdp: HWND, rgst: LPSYSTEMTIME): DWORD = discardable DWORD SendMessage(hdp, DTM_GETRANGE, 0, cast[LPARAM](rgst)) +template DateTime_GetSystemtime*(hdp: HWND, pst: LPSYSTEMTIME): DWORD = discardable DWORD SendMessage(hdp, DTM_GETSYSTEMTIME, 0, cast[LPARAM](pst)) +when winimUnicode: + const + DTM_SETFORMAT* = DTM_SETFORMATW +when winimAnsi: + const + DTM_SETFORMAT* = DTM_SETFORMATA +template DateTime_SetFormat*(hdp: HWND, sz: LPCTSTR): void = SendMessage(hdp, DTM_SETFORMAT, 0, cast[LPARAM](sz)) +template DateTime_SetMonthCalColor*(hdp: HWND, iColor: int32, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hdp, DTM_SETMCCOLOR, cast[WPARAM](iColor), cast[LPARAM](clr)) +template DateTime_SetMonthCalFont*(hdp: HWND, hfont: HFONT, fRedraw: int32): void = SendMessage(hdp, DTM_SETMCFONT, cast[WPARAM](hfont), cast[LPARAM](fRedraw)) +template DateTime_SetMonthCalStyle*(hdp: HWND, dwStyle: DWORD): LRESULT = discardable LRESULT SendMessage(hdp, DTM_SETMCSTYLE, 0, cast[LPARAM](dwStyle)) +template DateTime_SetRange*(hdp: HWND, gd: DWORD, rgst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hdp, DTM_SETRANGE, cast[WPARAM](gd), cast[LPARAM](rgst)) +template DateTime_SetSystemtime*(hdp: HWND, gd: DWORD, pst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hdp, DTM_SETSYSTEMTIME, cast[WPARAM](gd), cast[LPARAM](pst)) +template DPA_AppendPtr*(hdpa: HDPA, pitem: pointer): int32 = DPA_InsertPtr(hdpa, DA_LAST, pitem) +template DPA_FastDeleteLastPtr*(hdpa: HDPA): void = cast[ptr int32](hdpa)[].dec +template DPA_GetPtrPtr*(hdpa: HDPA): ptr pointer = discardable (cast[ptr ptr pointer](cast[int](hdpa) + sizeof(pointer)))[] +template DPA_FastGetPtr*(hdpa: HDPA, i: int32): ptr pointer = discardable cast[ptr pointer](cast[int](DPA_GetPtrPtr(hdpa)) + sizeof(pointer) * i) +template DPA_GetPtrCount*(hdpa: HDPA): int32 = discardable int32 cast[ptr int32](hdpa)[] +template DPA_SetPtrCount*(hdpa: HDPA, cItems: int32): int32 = (cast[ptr int32](hdpa)[] = cItems; discardable int32 cItems) +template DPA_SortedInsertPtr*(hdpa: HDPA, pFind: pointer, iStart: int32, pfnCompare: PFNDPACOMPARE, lParam: LPARAM, options: UINT, pitem: pointer): int32 = DPA_InsertPtr(hdpa, DPA_Search(hdpa, pFind, iStart, pfnCompare, lParam, options or DPAS_SORTED), pitem) +template DSA_AppendItem*(hdsa: HDSA, pitem: pointer): int32 = DSA_InsertItem(hdsa, DA_LAST, pitem) +template DSA_GetItemCount*(hdsa: HDSA): int32 = discardable int32 cast[ptr int32](hdsa)[] +template Edit_GetCueBannerText*(hwnd: HWND, lpwText: LPCWSTR, cchText: LONG): BOOL = discardable BOOL SendMessage(hwnd, EM_GETCUEBANNER, cast[WPARAM](lpwText), cast[LPARAM](cchText)) +template Edit_GetHilite*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, EM_GETHILITE, 0, 0) +template Edit_HideBalloonTip*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, EM_HIDEBALLOONTIP, 0, 0) +template Edit_NoSetFocus*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, EM_NOSETFOCUS, 0, 0) +template Edit_SetCueBannerText*(hwnd: HWND, lpcwText: LPCWSTR): BOOL = discardable BOOL SendMessage(hwnd, EM_SETCUEBANNER, 0, cast[LPARAM](lpcwText)) +template Edit_SetHilite*(hwnd: HWND, ichStart: int32, ichEnd: int32): void = SendMessage(hwnd, EM_SETHILITE, cast[WPARAM](ichStart), cast[LPARAM](ichEnd)) +template Edit_ShowBalloonTip*(hwnd: HWND, peditballoontip: PEDITBALLOONTIP): BOOL = discardable BOOL SendMessage(hwnd, EM_SHOWBALLOONTIP, 0, cast[LPARAM](peditballoontip)) +template Edit_TakeFocus*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, EM_TAKEFOCUS, 0, 0) +template Header_ClearAllFilters*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, HDM_CLEARFILTER, cast[WPARAM](-1), 0) +template Header_ClearFilter*(hwnd: HWND, i: int32): int32 = discardable int32 SendMessage(hwnd, HDM_CLEARFILTER, cast[WPARAM](i), 0) +template Header_CreateDragImage*(hwnd: HWND, i: int32): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, HDM_CREATEDRAGIMAGE, cast[WPARAM](i), 0) +template Header_DeleteItem*(hwndHD: HWND, i: int32): BOOL = discardable BOOL SendMessage(hwndHD, HDM_DELETEITEM, cast[WPARAM](i), 0) +template Header_EditFilter*(hwnd: HWND, i: int32, fDiscardChanges: BOOL): int32 = discardable int32 SendMessage(hwnd, HDM_EDITFILTER, cast[WPARAM](i), MAKELPARAM(fDiscardChanges, 0)) +template Header_GetBitmapMargin*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, HDM_GETBITMAPMARGIN, 0, 0) +template Header_GetFocusedItem*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, HDM_GETFOCUSEDITEM, 0, 0) +template Header_GetImageList*(hwnd: HWND): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, HDM_GETIMAGELIST, 0, 0) +when winimUnicode: + type + LPHDITEM* = LPHDITEMW +when winimAnsi: + type + LPHDITEM* = LPHDITEMA +when winimUnicode: + const + HDM_GETITEM* = HDM_GETITEMW +when winimAnsi: + const + HDM_GETITEM* = HDM_GETITEMA +template Header_GetItem*(hwndHD: HWND, i: int32, phdi: LPHDITEM): BOOL = discardable BOOL SendMessage(hwndHD, HDM_GETITEM, cast[WPARAM](i), cast[LPARAM](phdi)) +template Header_GetItemCount*(hwndHD: HWND): int32 = discardable int32 SendMessage(hwndHD, HDM_GETITEMCOUNT, 0, 0) +template Header_GetItemDropDownRect*(hwnd: HWND, iItem: int32, lprc: LPRECT): BOOL = discardable BOOL SendMessage(hwnd, HDM_GETITEMDROPDOWNRECT, cast[WPARAM](iItem), cast[LPARAM](lprc)) +template Header_GetItemRect*(hwnd: HWND, iItem: int32, lprc: LPRECT): BOOL = discardable BOOL SendMessage(hwnd, HDM_GETITEMRECT, cast[WPARAM](iItem), cast[LPARAM](lprc)) +template Header_GetOrderArray*(hwnd: HWND, iCount: int32, lpi: ptr int32): BOOL = discardable BOOL SendMessage(hwnd, HDM_GETORDERARRAY, cast[WPARAM](iCount), cast[LPARAM](lpi)) +template Header_GetOverflowRect*(hwnd: HWND, lprc: LPRECT): BOOL = discardable BOOL SendMessage(hwnd, HDM_GETOVERFLOWRECT, 0, cast[LPARAM](lprc)) +template Header_GetUnicodeFormat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, HDM_GETUNICODEFORMAT, 0, 0) +when winimUnicode: + const + HDM_INSERTITEM* = HDM_INSERTITEMW +when winimAnsi: + const + HDM_INSERTITEM* = HDM_INSERTITEMA +template Header_InsertItem*(hwndHD: HWND, i: int32, phdi: LPHDITEM): int32 = discardable int32 SendMessage(hwndHD, HDM_INSERTITEM, cast[WPARAM](i), cast[LPARAM](phdi)) +template Header_Layout*(hwndHD: HWND, playout: LPHDLAYOUT): BOOL = discardable BOOL SendMessage(hwndHD, HDM_LAYOUT, 0, cast[LPARAM](playout)) +template Header_OrderToIndex*(hwnd: HWND, i: int32): int32 = discardable int32 SendMessage(hwnd, HDM_ORDERTOINDEX, cast[WPARAM](i), 0) +template Header_SetBitmapMargin*(hwnd: HWND, iWidth: int32): int32 = discardable int32 SendMessage(hwnd, HDM_SETBITMAPMARGIN, cast[WPARAM](iWidth), 0) +template Header_SetFilterChangeTimeout*(hwnd: HWND, i: int32): int32 = discardable int32 SendMessage(hwnd, HDM_SETFILTERCHANGETIMEOUT, 0, cast[LPARAM](i)) +template Header_SetFocusedItem*(hwnd: HWND, iItem: int32): BOOL = discardable BOOL SendMessage(hwnd, HDM_SETFOCUSEDITEM, 0, cast[LPARAM](iItem)) +template Header_SetHotDivider*(hwnd: HWND, fPos: BOOL, dw: DWORD): int32 = discardable int32 SendMessage(hwnd, HDM_SETHOTDIVIDER, cast[WPARAM](fPos), cast[LPARAM](dw)) +template Header_SetImageList*(hwnd: HWND, himl: HIMAGELIST): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, HDM_SETIMAGELIST, 0, cast[LPARAM](himl)) +when winimUnicode: + const + HDM_SETITEM* = HDM_SETITEMW +when winimAnsi: + const + HDM_SETITEM* = HDM_SETITEMA +template Header_SetItem*(hwndHD: HWND, i: int32, phdi: LPHDITEM): BOOL = discardable BOOL SendMessage(hwndHD, HDM_SETITEM, cast[WPARAM](i), cast[LPARAM](phdi)) +template Header_SetOrderArray*(hwnd: HWND, iCount: int32, lpi: ptr int32): BOOL = discardable BOOL SendMessage(hwnd, HDM_SETORDERARRAY, cast[WPARAM](iCount), cast[LPARAM](lpi)) +template Header_SetUnicodeFormat*(hwnd: HWND, fUnicode: BOOL): BOOL = discardable BOOL SendMessage(hwnd, HDM_SETUNICODEFORMAT, cast[WPARAM](fUnicode), 0) +template ImageList_AddIcon*(himl: HIMAGELIST, hicon: HICON): int32 = ImageList_ReplaceIcon(himl, -1, hicon) +template ImageList_ExtractIcon*(hi: HINSTANCE, himl: HIMAGELIST, i: int32): HICON = ImageList_GetIcon(himl, i, 0) +template ImageList_LoadBitmap*(hi: HINSTANCE, lpbmp: LPCTSTR, cx: int32, cGrow: int32, crMask: COLORREF): HIMAGELIST = ImageList_LoadImage(hi, lpbmp, cx, cGrow, crMask, IMAGE_BITMAP, 0) +template ImageList_RemoveAll*(himl: HIMAGELIST): BOOL = ImageList_Remove(himl, -1) +template ListView_ApproximateViewRect*(hwnd: HWND, iWidth: int32, iHeight: int32, iCount: int32): DWORD = discardable DWORD SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, cast[WPARAM](iCount), MAKELPARAM(iWidth, iHeight)) +template ListView_Arrange*(hwnd: HWND, code: UINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_ARRANGE, cast[WPARAM](code), 0) +template ListView_CancelEditLabel*(hwnd: HWND): void = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0) +template ListView_CreateDragImage*(hwnd: HWND, i: int32, lpptUpLeft: LPPOINT): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, LVM_CREATEDRAGIMAGE, cast[WPARAM](i), cast[LPARAM](lpptUpLeft)) +template ListView_DeleteAllItems*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0) +template ListView_DeleteColumn*(hwnd: HWND, iCol: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_DELETECOLUMN, cast[WPARAM](iCol), 0) +template ListView_DeleteItem*(hwnd: HWND, i: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_DELETEITEM, cast[WPARAM](i), 0) +when winimUnicode: + const + LVM_EDITLABEL* = LVM_EDITLABELW +when winimAnsi: + const + LVM_EDITLABEL* = LVM_EDITLABELA +template ListView_EditLabel*(hwnd: HWND, i: int32): HWND = discardable HWND SendMessage(hwnd, LVM_EDITLABEL, cast[WPARAM](i), 0) +template ListView_EnableGroupView*(hwnd: HWND, fEnable: BOOL): int32 = discardable int32 SendMessage(hwnd, LVM_ENABLEGROUPVIEW, cast[WPARAM](fEnable), 0) +template ListView_EnsureVisible*(hwnd: HWND, i: int32, fPartialOK: BOOL): BOOL = discardable BOOL SendMessage(hwnd, LVM_ENSUREVISIBLE, cast[WPARAM](i), MAKELPARAM(fPartialOK, 0)) +when winimUnicode: + type + LVFINDINFO* = LVFINDINFOW +when winimAnsi: + type + LVFINDINFO* = LVFINDINFOA +when winimUnicode: + const + LVM_FINDITEM* = LVM_FINDITEMW +when winimAnsi: + const + LVM_FINDITEM* = LVM_FINDITEMA +template ListView_FindItem*(hwnd: HWND, iStart: int32, plvfi: ptr LVFINDINFO): int32 = discardable int32 SendMessage(hwnd, LVM_FINDITEM, cast[WPARAM](iStart), cast[LPARAM](plvfi)) +template ListView_GetBkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_GETBKCOLOR, 0, 0) +when winimUnicode: + type + LPLVBKIMAGE* = LPLVBKIMAGEW +when winimAnsi: + type + LPLVBKIMAGE* = LPLVBKIMAGEA +when winimUnicode: + const + LVM_GETBKIMAGE* = LVM_GETBKIMAGEW +when winimAnsi: + const + LVM_GETBKIMAGE* = LVM_GETBKIMAGEA +template ListView_GetBkImage*(hwnd: HWND, plvbki: LPLVBKIMAGE): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETBKIMAGE, 0, cast[LPARAM](plvbki)) +template ListView_GetCallbackMask*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, LVM_GETCALLBACKMASK, 0, 0) +template ListView_GetCheckState*(hwnd: HWND, i: UINT): BOOL = discardable BOOL((SendMessage(hwnd, LVM_GETITEMSTATE, cast[WPARAM](i), LVIS_STATEIMAGEMASK) shr 12) - 1) +when winimUnicode: + type + LPLVCOLUMN* = LPLVCOLUMNW +when winimAnsi: + type + LPLVCOLUMN* = LPLVCOLUMNA +when winimUnicode: + const + LVM_GETCOLUMN* = LVM_GETCOLUMNW +when winimAnsi: + const + LVM_GETCOLUMN* = LVM_GETCOLUMNA +template ListView_GetColumn*(hwnd: HWND, iCol: int32, pcol: LPLVCOLUMN): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETCOLUMN, cast[WPARAM](iCol), cast[LPARAM](pcol)) +template ListView_GetColumnOrderArray*(hwnd: HWND, iCount: int32, pi: ptr int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETCOLUMNORDERARRAY, cast[WPARAM](iCount), cast[LPARAM](pi)) +template ListView_GetColumnWidth*(hwnd: HWND, iCol: int32): int32 = discardable int32 SendMessage(hwnd, LVM_GETCOLUMNWIDTH, cast[WPARAM](iCol), 0) +template ListView_GetCountPerPage*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, LVM_GETCOUNTPERPAGE, 0, 0) +template ListView_GetEditControl*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, LVM_GETEDITCONTROL, 0, 0) +template ListView_GetEmptyText*(hwnd: HWND, pszText: PWSTR, cchText: UINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETEMPTYTEXT, cast[WPARAM](cchText), cast[LPARAM](pszText)) +template ListView_GetExtendedListViewStyle*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0) +template ListView_GetFocusedGroup*(hwnd: HWND): INT = discardable INT SendMessage(hwnd, LVM_GETFOCUSEDGROUP, 0, 0) +template ListView_GetFooterInfo*(hwnd: HWND, plvfi: LPLVFOOTERINFO): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETFOOTERINFO, cast[WPARAM]((0)), cast[LPARAM](plvfi)) +template ListView_GetFooterItem*(hwnd: HWND, iItem: UINT, pfi: ptr LVFOOTERITEM): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETFOOTERITEM, cast[WPARAM](iItem), cast[LPARAM](pfi)) +template ListView_GetFooterItemRect*(hwnd: HWND, iItem: UINT, prc: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETFOOTERITEMRECT, cast[WPARAM](iItem), cast[LPARAM](prc)) +template ListView_GetFooterRect*(hwnd: HWND, prc: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETFOOTERRECT, cast[WPARAM]((0)), cast[LPARAM](prc)) +template ListView_GetGroupCount*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, LVM_GETGROUPCOUNT, 0, 0) +template ListView_GetGroupHeaderImageList*(hwnd: HWND): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, LVM_GETIMAGELIST, cast[WPARAM](LVSIL_GROUPHEADER), 0) +template ListView_GetGroupInfo*(hwnd: HWND, iGroupId: int32, pgrp: PLVGROUP): int32 = discardable int32 SendMessage(hwnd, LVM_GETGROUPINFO, cast[WPARAM](iGroupId), cast[LPARAM](pgrp)) +template ListView_GetGroupInfoByIndex*(hwnd: HWND, iIndex: int32, pgrp: PLVGROUP): LRESULT = discardable LRESULT SendMessage(hwnd, LVM_GETGROUPINFOBYINDEX, cast[WPARAM](iIndex), cast[LPARAM](pgrp)) +template ListView_GetGroupMetrics*(hwnd: HWND, pGroupMetrics: PLVGROUPMETRICS): void = SendMessage(hwnd, LVM_GETGROUPMETRICS, 0, cast[LPARAM](pGroupMetrics)) +template ListView_GetGroupRect*(hwnd: HWND, iGroupId: int32, `type`: LONG, prc: ptr RECT): BOOL = (if prc.pointer != nil: cast[ptr RECT](cast[int](prc)).top = `type`; discardable BOOL SendMessage(hwnd, LVM_GETGROUPRECT, cast[WPARAM](iGroupId), cast[LPARAM](prc))) +template ListView_GetGroupState*(hwnd: HWND, dwGroupId: UINT, dwMask: UINT): UINT = discardable UINT SendMessage(hwnd, LVM_GETGROUPSTATE, cast[WPARAM](dwGroupId), cast[LPARAM](dwMask)) +template ListView_GetHeader*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, LVM_GETHEADER, 0, 0) +template ListView_GetHotCursor*(hwnd: HWND): HCURSOR = discardable HCURSOR SendMessage(hwnd, LVM_GETHOTCURSOR, 0, 0) +template ListView_GetHotItem*(hwnd: HWND): INT = discardable INT SendMessage(hwnd, LVM_GETHOTITEM, 0, 0) +template ListView_GetHoverTime*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, LVM_GETHOVERTIME, 0, 0) +template ListView_GetImageList*(hwnd: HWND, iImageList: int32): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, LVM_GETIMAGELIST, cast[WPARAM](iImageList), 0) +template ListView_GetInsertMark*(hwnd: HWND, lvim: LPLVINSERTMARK): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETINSERTMARK, 0, cast[LPARAM](lvim)) +template ListView_GetInsertMarkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_GETINSERTMARKCOLOR, 0, 0) +template ListView_GetInsertMarkRect*(hwnd: HWND, rc: LPRECT): int32 = discardable int32 SendMessage(hwnd, LVM_GETINSERTMARKRECT, 0, cast[LPARAM](rc)) +when winimUnicode: + const + LVM_GETISEARCHSTRING* = LVM_GETISEARCHSTRINGW +when winimAnsi: + const + LVM_GETISEARCHSTRING* = LVM_GETISEARCHSTRINGA +template ListView_GetISearchString*(hwnd: HWND, lpsz: LPSTR): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETISEARCHSTRING, 0, cast[LPARAM](lpsz)) +when winimUnicode: + type + LPLVITEM* = LPLVITEMW +when winimAnsi: + type + LPLVITEM* = LPLVITEMA +when winimUnicode: + const + LVM_GETITEM* = LVM_GETITEMW +when winimAnsi: + const + LVM_GETITEM* = LVM_GETITEMA +template ListView_GetItem*(hwnd: HWND, pitem: LPLVITEM): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETITEM, 0, cast[LPARAM](pitem)) +template ListView_GetItemCount*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0) +template ListView_GetItemIndexRect*(hwnd: HWND, plvii: ptr LVITEMINDEX, iSubItem: LONG, code: LONG, prc: LPRECT): BOOL = (if prc.pointer != nil: (cast[ptr RECT](cast[int](prc)).top = iSubItem; cast[ptr RECT](cast[int](prc)).left = code); discardable BOOL SendMessage(hwnd, LVM_GETITEMINDEXRECT, cast[WPARAM](plvii), cast[LPARAM](prc))) +template ListView_GetItemPosition*(hwnd: HWND, i: int32, ppt: ptr POINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETITEMPOSITION, cast[WPARAM](i), cast[LPARAM](ppt)) +template ListView_GetItemRect*(hwnd: HWND, i: int32, prc: ptr RECT, code: int32): BOOL = (if prc.pointer != nil: cast[ptr RECT](cast[int](prc)).left = code; discardable BOOL SendMessage(hwnd, LVM_GETITEMRECT, cast[WPARAM](i), cast[LPARAM](prc))) +template ListView_GetItemSpacing*(hwnd: HWND, fSmall: BOOL): DWORD = discardable DWORD SendMessage(hwnd, LVM_GETITEMSPACING, cast[WPARAM](fSmall), 0) +template ListView_GetItemState*(hwnd: HWND, i: int32, mask: UINT): UINT = discardable UINT SendMessage(hwnd, LVM_GETITEMSTATE, cast[WPARAM](i), cast[LPARAM](mask)) +when winimUnicode: + const + LVM_GETITEMTEXT* = LVM_GETITEMTEXTW +when winimAnsi: + const + LVM_GETITEMTEXT* = LVM_GETITEMTEXTA +template ListView_GetItemText*(hwnd: HWND, i: int32, iSub: int32, text: LPTSTR, max: int32): void = (var lvi = LV_ITEM(iSubItem: iSub, cchTextMax: max, pszText: text); SendMessage(hwnd, LVM_GETITEMTEXT, cast[WPARAM](i), cast[LPARAM](addr lvi))) +template ListView_GetNextItem*(hwnd: HWND, i: int32, flags: UINT): int32 = discardable int32 SendMessage(hwnd, LVM_GETNEXTITEM, cast[WPARAM](i), MAKELPARAM(flags, 0)) +template ListView_GetNextItemIndex*(hwnd: HWND, plvii: ptr LVITEMINDEX, flags: LPARAM): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETNEXTITEMINDEX, cast[WPARAM](plvii), MAKELPARAM(flags, 0)) +template ListView_GetNumberOfWorkAreas*(hwnd: HWND, pnWorkAreas: ptr UINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETNUMBEROFWORKAREAS, 0, cast[LPARAM](pnWorkAreas)) +template ListView_GetOrigin*(hwnd: HWND, ppt: LPPOINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETORIGIN, 0, cast[LPARAM](ppt)) +template ListView_GetOutlineColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_GETOUTLINECOLOR, 0, 0) +template ListView_GetSelectedColumn*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, LVM_GETSELECTEDCOLUMN, 0, 0) +template ListView_GetSelectedCount*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0) +template ListView_GetSelectionMark*(hwnd: HWND): INT = discardable INT SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0) +when winimUnicode: + const + LVM_GETSTRINGWIDTH* = LVM_GETSTRINGWIDTHW +when winimAnsi: + const + LVM_GETSTRINGWIDTH* = LVM_GETSTRINGWIDTHA +template ListView_GetStringWidth*(hwnd: HWND, psz: LPCSTR): int32 = discardable int32 SendMessage(hwnd, LVM_GETSTRINGWIDTH, 0, cast[LPARAM](psz)) +template ListView_GetSubItemRect*(hwnd: HWND, iItem: int32, iSubItem: int32, code: int32, prc: LPRECT): BOOL = (if prc.pointer != nil: (cast[LPRECT](cast[int](prc)).top = iSubItem; cast[LPRECT](cast[int](prc)).left = code); discardable BOOL SendMessage(hwnd, LVM_GETSUBITEMRECT, cast[WPARAM](iItem), cast[LPARAM](prc))) +template ListView_GetTextBkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_GETTEXTBKCOLOR, 0, 0) +template ListView_GetTextColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_GETTEXTCOLOR, 0, 0) +template ListView_GetTileInfo*(hwnd: HWND, pti: PLVTILEINFO): void = SendMessage(hwnd, LVM_GETTILEINFO, 0, cast[LPARAM](pti)) +template ListView_GetTileViewInfo*(hwnd: HWND, ptvi: PLVTILEVIEWINFO): void = SendMessage(hwnd, LVM_GETTILEVIEWINFO, 0, cast[LPARAM](ptvi)) +template ListView_GetToolTips*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, LVM_GETTOOLTIPS, 0, 0) +template ListView_GetTopIndex*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, LVM_GETTOPINDEX, 0, 0) +template ListView_GetUnicodeFormat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0) +template ListView_GetView*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, LVM_GETVIEW, 0, 0) +template ListView_GetViewRect*(hwnd: HWND, prc: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, LVM_GETVIEWRECT, 0, cast[LPARAM](prc)) +template ListView_GetWorkAreas*(hwnd: HWND, nWorkAreas: INT, prc: LPRECT): void = SendMessage(hwnd, LVM_GETWORKAREAS, cast[WPARAM](nWorkAreas), cast[LPARAM](prc)) +template ListView_HasGroup*(hwnd: HWND, dwGroupId: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_HASGROUP, cast[WPARAM](dwGroupId), 0) +template ListView_HitTest*(hwnd: HWND, pinfo: LPLVHITTESTINFO): int32 = discardable int32 SendMessage(hwnd, LVM_HITTEST, 0, cast[LPARAM](pinfo)) +when winimUnicode: + const + LVM_INSERTCOLUMN* = LVM_INSERTCOLUMNW +when winimAnsi: + const + LVM_INSERTCOLUMN* = LVM_INSERTCOLUMNA +template ListView_InsertColumn*(hwnd: HWND, iCol: int32, pcol: LPLVCOLUMN): int32 = discardable int32 SendMessage(hwnd, LVM_INSERTCOLUMN, cast[WPARAM](iCol), cast[LPARAM](pcol)) +template ListView_InsertGroup*(hwnd: HWND, index: int32, pgrp: PLVGROUP): int32 = discardable int32 SendMessage(hwnd, LVM_INSERTGROUP, cast[WPARAM](index), cast[LPARAM](pgrp)) +template ListView_InsertGroupSorted*(hwnd: HWND, structInsert: PLVINSERTGROUPSORTED): void = SendMessage(hwnd, LVM_INSERTGROUPSORTED, cast[WPARAM](structInsert), 0) +when winimUnicode: + const + LVM_INSERTITEM* = LVM_INSERTITEMW +when winimAnsi: + const + LVM_INSERTITEM* = LVM_INSERTITEMA +template ListView_InsertItem*(hwnd: HWND, pitem: LPLVITEM): int32 = discardable int32 SendMessage(hwnd, LVM_INSERTITEM, 0, cast[LPARAM](pitem)) +template ListView_InsertMarkHitTest*(hwnd: HWND, point: LPPOINT, lvim: LPLVINSERTMARK): BOOL = discardable BOOL SendMessage(hwnd, LVM_INSERTMARKHITTEST, cast[WPARAM](point), cast[LPARAM](lvim)) +template ListView_IsGroupViewEnabled*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, LVM_ISGROUPVIEWENABLED, 0, 0) +template ListView_IsItemVisible*(hwnd: HWND, index: UINT): UINT = discardable UINT SendMessage(hwnd, LVM_ISITEMVISIBLE, cast[WPARAM](index), 0) +template ListView_MapIDToIndex*(hwnd: HWND, id: UINT): UINT = discardable UINT SendMessage(hwnd, LVM_MAPIDTOINDEX, cast[WPARAM](id), 0) +template ListView_MapIndexToID*(hwnd: HWND, index: UINT): UINT = discardable UINT SendMessage(hwnd, LVM_MAPINDEXTOID, cast[WPARAM](index), 0) +template ListView_MoveGroup*(hwnd: HWND, iGroupId: int32, toIndex: int32): void = SendMessage(hwnd, LVM_MOVEGROUP, cast[WPARAM](iGroupId), cast[LPARAM](toIndex)) +template ListView_MoveItemToGroup*(hwnd: HWND, idItemFrom: int32, idGroupTo: int32): void = SendMessage(hwnd, LVM_MOVEITEMTOGROUP, cast[WPARAM](idItemFrom), cast[LPARAM](idGroupTo)) +template ListView_RedrawItems*(hwnd: HWND, iFirst: int32, iLast: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_REDRAWITEMS, cast[WPARAM](iFirst), cast[LPARAM](iLast)) +template ListView_RemoveAllGroups*(hwnd: HWND): void = SendMessage(hwnd, LVM_REMOVEALLGROUPS, 0, 0) +template ListView_RemoveGroup*(hwnd: HWND, iGroupId: int32): int32 = discardable int32 SendMessage(hwnd, LVM_REMOVEGROUP, cast[WPARAM](iGroupId), 0) +template ListView_Scroll*(hwnd: HWND, dx: int32, dy: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_SCROLL, cast[WPARAM](dx), cast[LPARAM](dy)) +template ListView_SetBkColor*(hwnd: HWND, clrBk: COLORREF): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETBKCOLOR, 0, cast[LPARAM](clrBk)) +when winimUnicode: + const + LVM_SETBKIMAGE* = LVM_SETBKIMAGEW +when winimAnsi: + const + LVM_SETBKIMAGE* = LVM_SETBKIMAGEA +template ListView_SetBkImage*(hwnd: HWND, plvbki: LPLVBKIMAGE): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETBKIMAGE, 0, cast[LPARAM](plvbki)) +template ListView_SetCallbackMask*(hwnd: HWND, mask: UINT): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETCALLBACKMASK, cast[WPARAM](mask), 0) +template ListView_SetItemState*(hwnd: HWND, i: int32, data: UINT, mask: UINT): void = (var lvi = LV_ITEM(stateMask: mask, state: data); SendMessage(hwnd, LVM_SETITEMSTATE, cast[WPARAM](i), cast[LPARAM](addr lvi))) +template ListView_SetCheckState*(hwnd: HWND, i: UINT, fCheck: BOOL) = ListView_SetItemState(hwnd, i, INDEXTOSTATEIMAGEMASK(if bool fCheck:2 else:1), LVIS_STATEIMAGEMASK) +when winimUnicode: + const + LVM_SETCOLUMN* = LVM_SETCOLUMNW +when winimAnsi: + const + LVM_SETCOLUMN* = LVM_SETCOLUMNA +template ListView_SetColumn*(hwnd: HWND, iCol: int32, pcol: LPLVCOLUMN): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETCOLUMN, cast[WPARAM](iCol), cast[LPARAM](pcol)) +template ListView_SetColumnOrderArray*(hwnd: HWND, iCount: int32, pi: ptr int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, cast[WPARAM](iCount), cast[LPARAM](pi)) +template ListView_SetColumnWidth*(hwnd: HWND, iCol: int32, cx: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETCOLUMNWIDTH, cast[WPARAM](iCol), MAKELPARAM(cx, 0)) +template ListView_SetExtendedListViewStyle*(hwnd: HWND, dw: DWORD): void = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, cast[LPARAM](dw)) +template ListView_SetExtendedListViewStyleEx*(hwnd: HWND, dwMask: DWORD, dw: DWORD): void = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, cast[WPARAM](dwMask), cast[LPARAM](dw)) +template ListView_SetGroupHeaderImageList*(hwnd: HWND, himl: HIMAGELIST): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, LVM_SETIMAGELIST, cast[WPARAM](LVSIL_GROUPHEADER), cast[LPARAM](himl)) +template ListView_SetGroupInfo*(hwnd: HWND, iGroupId: int32, pgrp: PLVGROUP): int32 = discardable int32 SendMessage(hwnd, LVM_SETGROUPINFO, cast[WPARAM](iGroupId), cast[LPARAM](pgrp)) +template ListView_SetGroupMetrics*(hwnd: HWND, pGroupMetrics: PLVGROUPMETRICS): void = SendMessage(hwnd, LVM_SETGROUPMETRICS, 0, cast[LPARAM](pGroupMetrics)) +template ListView_SetGroupState*(hwnd: HWND, dwGroupId: UINT, dwMask: UINT, dwState: UINT): LRESULT = (var lvg = LVGROUP(cbSize: int32 sizeof(LVGROUP), mask: LVGF_STATE, stateMask: dwMask, state: dwState); discardable LRESULT SendMessage(hwnd, LVM_SETGROUPINFO, cast[WPARAM](dwGroupId), cast[LPARAM](addr lvg))) +template ListView_SetHotCursor*(hwnd: HWND, hcur: HCURSOR): HCURSOR = discardable HCURSOR SendMessage(hwnd, LVM_SETHOTCURSOR, 0, cast[LPARAM](hcur)) +template ListView_SetHotItem*(hwnd: HWND, i: INT): INT = discardable INT SendMessage(hwnd, LVM_SETHOTITEM, cast[WPARAM](i), 0) +template ListView_SetHoverTime*(hwnd: HWND, dwHoverTimeMs: DWORD): void = SendMessage(hwnd, LVM_SETHOVERTIME, 0, cast[LPARAM](dwHoverTimeMs)) +template ListView_SetIconSpacing*(hwnd: HWND, cx: int32, cy: int32): DWORD = discardable DWORD SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELONG(cx, cy)) +template ListView_SetImageList*(hwnd: HWND, himl: HIMAGELIST, iImageList: int32): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, LVM_SETIMAGELIST, cast[WPARAM](iImageList), cast[LPARAM](himl)) +template ListView_SetInfoTip*(hwnd: HWND, plvInfoTip: PLVSETINFOTIP): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETINFOTIP, 0, cast[LPARAM](plvInfoTip)) +template ListView_SetInsertMark*(hwnd: HWND, lvim: LPLVINSERTMARK): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETINSERTMARK, 0, cast[LPARAM](lvim)) +template ListView_SetInsertMarkColor*(hwnd: HWND, color: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_SETINSERTMARKCOLOR, 0, cast[LPARAM](color)) +when winimUnicode: + const + LVM_SETITEM* = LVM_SETITEMW +when winimAnsi: + const + LVM_SETITEM* = LVM_SETITEMA +template ListView_SetItem*(hwnd: HWND, pitem: LPLVITEM): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETITEM, 0, cast[LPARAM](pitem)) +template ListView_SetItemCount*(hwnd: HWND, cItems: int32): void = SendMessage(hwnd, LVM_SETITEMCOUNT, cast[WPARAM](cItems), 0) +template ListView_SetItemCountEx*(hwnd: HWND, cItems: int32, dwFlags: DWORD): void = SendMessage(hwnd, LVM_SETITEMCOUNT, cast[WPARAM](cItems), cast[LPARAM](dwFlags)) +template ListView_SetItemIndexState*(hwnd: HWND, plvii: ptr LVITEMINDEX, data: UINT, mask: UINT): HRESULT = (var lvi = LV_ITEM(stateMask: mask, state: data); discardable HRESULT SendMessage(hwnd, LVM_SETITEMINDEXSTATE, cast[WPARAM](plvii), cast[LPARAM](addr lvi))) +template ListView_SetItemPosition*(hwnd: HWND, i: int32, x: int32, y: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETITEMPOSITION, cast[WPARAM](i), MAKELPARAM(x, y)) +template ListView_SetItemPosition32*(hwnd: HWND, i: int32, x0: int32, y0: int32): void = (var p = POINT(x: x0, y: y0); SendMessage(hwnd, LVM_SETITEMPOSITION32, cast[WPARAM](i), cast[LPARAM](addr p))) +when winimUnicode: + const + LVM_SETITEMTEXT* = LVM_SETITEMTEXTW +when winimAnsi: + const + LVM_SETITEMTEXT* = LVM_SETITEMTEXTA +template ListView_SetItemText*(hwnd: HWND, i: int32, iSub: int32, text: LPCTSTR): void = (var lvi = LV_ITEM(iSubItem: iSub, pszText: text); SendMessage(hwnd, LVM_SETITEMTEXT, cast[WPARAM](i), cast[LPARAM](addr lvi))) +template ListView_SetOutlineColor*(hwnd: HWND, color: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, LVM_SETOUTLINECOLOR, 0, cast[LPARAM](color)) +template ListView_SetSelectedColumn*(hwnd: HWND, iCol: int32): void = SendMessage(hwnd, LVM_SETSELECTEDCOLUMN, cast[WPARAM](iCol), 0) +template ListView_SetSelectionMark*(hwnd: HWND, i: INT): INT = discardable INT SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, cast[LPARAM](i)) +template ListView_SetTextBkColor*(hwnd: HWND, clrTextBk: COLORREF): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETTEXTBKCOLOR, 0, cast[LPARAM](clrTextBk)) +template ListView_SetTextColor*(hwnd: HWND, clrText: COLORREF): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, cast[LPARAM](clrText)) +template ListView_SetTileInfo*(hwnd: HWND, pti: PLVTILEINFO): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETTILEINFO, 0, cast[LPARAM](pti)) +template ListView_SetTileViewInfo*(hwnd: HWND, ptvi: PLVTILEVIEWINFO): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETTILEVIEWINFO, 0, cast[LPARAM](ptvi)) +template ListView_SetTileWidth*(hwnd: HWND, cpWidth: int32): void = SendMessage(hwnd, LVM_SETTILEWIDTH, cast[WPARAM](cpWidth), 0) +template ListView_SetToolTips*(hwnd: HWND, hwndNewHwnd: HWND): HWND = discardable HWND SendMessage(hwnd, LVM_SETTOOLTIPS, cast[WPARAM](hwndNewHwnd), 0) +template ListView_SetUnicodeFormat*(hwnd: HWND, fUnicode: BOOL): BOOL = discardable BOOL SendMessage(hwnd, LVM_SETUNICODEFORMAT, cast[WPARAM](fUnicode), 0) +template ListView_SetView*(hwnd: HWND, iView: DWORD): int32 = discardable int32 SendMessage(hwnd, LVM_SETVIEW, cast[WPARAM](iView), 0) +template ListView_SetWorkAreas*(hwnd: HWND, nWorkAreas: INT, prc: LPRECT): void = SendMessage(hwnd, LVM_SETWORKAREAS, cast[WPARAM](nWorkAreas), cast[LPARAM](prc)) +template ListView_SortGroups*(hwnd: HWND, pfnGroupCompate: PFNLVGROUPCOMPARE, plv: LPVOID): int32 = discardable int32 SendMessage(hwnd, LVM_SORTGROUPS, cast[WPARAM](pfnGroupCompate), cast[LPARAM](plv)) +template ListView_SortItems*(hwnd: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): BOOL = discardable BOOL SendMessage(hwnd, LVM_SORTITEMS, cast[WPARAM](lPrm), cast[LPARAM](pfnCompare)) +template ListView_SortItemsEx*(hwnd: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): BOOL = discardable BOOL SendMessage(hwnd, LVM_SORTITEMSEX, cast[WPARAM](lPrm), cast[LPARAM](pfnCompare)) +template ListView_SubItemHitTest*(hwnd: HWND, plvhti: LPLVHITTESTINFO): INT = discardable INT SendMessage(hwnd, LVM_SUBITEMHITTEST, 0, cast[LPARAM](plvhti)) +template ListView_SubItemHitTestEx*(hwnd: HWND, plvhti: LPLVHITTESTINFO): INT = discardable INT SendMessage(hwnd, LVM_SUBITEMHITTEST, cast[WPARAM](-1), cast[LPARAM](plvhti)) +template ListView_Update*(hwnd: HWND, i: int32): BOOL = discardable BOOL SendMessage(hwnd, LVM_UPDATE, cast[WPARAM](i), 0) +template MonthCal_GetCalendarBorder*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETCALENDARBORDER, 0, 0) +template MonthCal_GetCalendarCount*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETCALENDARCOUNT, 0, 0) +template MonthCal_GetCalendarGridInfo*(hmc: HWND, pmcGridInfo: ptr MCGRIDINFO): BOOL = discardable BOOL SendMessage(hmc, MCM_GETCALENDARGRIDINFO, 0, cast[LPARAM](pmcGridInfo)) +template MonthCal_GetCALID*(hmc: HWND): CALID = discardable CALID SendMessage(hmc, MCM_GETCALID, 0, 0) +template MonthCal_GetColor*(hmc: HWND, iColor: INT): COLORREF = discardable COLORREF SendMessage(hmc, MCM_GETCOLOR, cast[WPARAM](iColor), 0) +template MonthCal_GetCurrentView*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETCURRENTVIEW, 0, 0) +template MonthCal_GetCurSel*(hmc: HWND, pst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_GETCURSEL, 0, cast[LPARAM](pst)) +template MonthCal_GetFirstDayOfWeek*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETFIRSTDAYOFWEEK, 0, 0) +template MonthCal_GetMaxSelCount*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETMAXSELCOUNT, 0, 0) +template MonthCal_GetMaxTodayWidth*(hmc: HWND): DWORD = discardable DWORD SendMessage(hmc, MCM_GETMAXTODAYWIDTH, 0, 0) +template MonthCal_GetMinReqRect*(hmc: HWND, prc: LPRECT): BOOL = discardable BOOL SendMessage(hmc, MCM_GETMINREQRECT, 0, cast[LPARAM](prc)) +template MonthCal_GetMonthDelta*(hmc: HWND): INT = discardable INT SendMessage(hmc, MCM_GETMONTHDELTA, 0, 0) +template MonthCal_GetMonthRange*(hmc: HWND, gmr: DWORD, rgst: LPSYSTEMTIME): INT = discardable INT SendMessage(hmc, MCM_GETMONTHRANGE, cast[WPARAM](gmr), cast[LPARAM](rgst)) +template MonthCal_GetRange*(hmc: HWND, rgst: LPSYSTEMTIME): DWORD = discardable DWORD SendMessage(hmc, MCM_GETRANGE, 0, cast[LPARAM](rgst)) +template MonthCal_GetSelRange*(hmc: HWND, rgst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_GETSELRANGE, 0, cast[LPARAM](rgst)) +template MonthCal_GetToday*(hmc: HWND, pst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_GETTODAY, 0, cast[LPARAM](pst)) +template MonthCal_GetUnicodeFormat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0) +template MonthCal_HitTest*(hmc: HWND, pinfo: PMCHITTESTINFO): DWORD = discardable DWORD SendMessage(hmc, MCM_HITTEST, 0, cast[LPARAM](pinfo)) +template MonthCal_SetCalendarBorder*(hmc: HWND, fset: BOOL, xyborder: int32): LRESULT = discardable LRESULT SendMessage(hmc, MCM_SETCALENDARBORDER, cast[WPARAM](fset), cast[LPARAM](xyborder)) +template MonthCal_SetCALID*(hmc: HWND, calid: UINT): LRESULT = discardable LRESULT SendMessage(hmc, MCM_SETCALID, cast[WPARAM](calid), 0) +template MonthCal_SetColor*(hmc: HWND, iColor: INT, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hmc, MCM_SETCOLOR, cast[WPARAM](iColor), cast[LPARAM](clr)) +template MonthCal_SetCurrentView*(hmc: HWND, dwNewView: DWORD): BOOL = discardable BOOL SendMessage(hmc, MCM_SETCURRENTVIEW, 0, cast[LPARAM](dwNewView)) +template MonthCal_SetCurSel*(hmc: HWND, pst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_SETCURSEL, 0, cast[LPARAM](pst)) +template MonthCal_SetDayState*(hmc: HWND, cbds: INT, rgds: LPMONTHDAYSTATE): BOOL = discardable BOOL SendMessage(hmc, MCM_SETDAYSTATE, cast[WPARAM](cbds), cast[LPARAM](rgds)) +template MonthCal_SetFirstDayOfWeek*(hmc: HWND, iDay: INT): DWORD = discardable DWORD SendMessage(hmc, MCM_SETFIRSTDAYOFWEEK, 0, cast[LPARAM](iDay)) +template MonthCal_SetMaxSelCount*(hmc: HWND, n: UINT): BOOL = discardable BOOL SendMessage(hmc, MCM_SETMAXSELCOUNT, cast[WPARAM](n), 0) +template MonthCal_SetMonthDelta*(hmc: HWND, n: INT): INT = discardable INT SendMessage(hmc, MCM_SETMONTHDELTA, cast[WPARAM](n), 0) +template MonthCal_SetRange*(hmc: HWND, gd: DWORD, rgst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_SETRANGE, cast[WPARAM](gd), cast[LPARAM](rgst)) +template MonthCal_SetSelRange*(hmc: HWND, rgst: LPSYSTEMTIME): BOOL = discardable BOOL SendMessage(hmc, MCM_SETSELRANGE, 0, cast[LPARAM](rgst)) +template MonthCal_SetToday*(hmc: HWND, pst: LPSYSTEMTIME): void = SendMessage(hmc, MCM_SETTODAY, 0, cast[LPARAM](pst)) +template MonthCal_SetUnicodeFormat*(hwnd: HWND, fUnicode: BOOL): BOOL = discardable BOOL SendMessage(hwnd, MCM_SETUNICODEFORMAT, cast[WPARAM](fUnicode), 0) +template MonthCal_SizeRectToMin*(hmc: HWND, prc: RECT): LRESULT = discardable LRESULT SendMessage(hmc, MCM_SIZERECTTOMIN, 0, cast[LPARAM](prc)) +template Pager_ForwardMouse*(hwnd: HWND, bForward: BOOL): void = SendMessage(hwnd, PGM_FORWARDMOUSE, cast[WPARAM](bForward), 0) +template Pager_GetBkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, PGM_GETBKCOLOR, 0, 0) +template Pager_GetBorder*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, PGM_GETBORDER, 0, 0) +template Pager_GetButtonSize*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, PGM_GETBUTTONSIZE, 0, 0) +template Pager_GetButtonState*(hwnd: HWND, iButton: int32): DWORD = discardable DWORD SendMessage(hwnd, PGM_GETBUTTONSTATE, 0, cast[LPARAM](iButton)) +template Pager_GetDropTarget*(hwnd: HWND, ppdt: ptr ptr IDropTarget): void = SendMessage(hwnd, PGM_GETDROPTARGET, 0, cast[LPARAM](ppdt)) +template Pager_GetPos*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, PGM_GETPOS, 0, 0) +template Pager_RecalcSize*(hwnd: HWND): void = SendMessage(hwnd, PGM_RECALCSIZE, 0, 0) +template Pager_SetBkColor*(hwnd: HWND, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, PGM_SETBKCOLOR, 0, cast[LPARAM](clr)) +template Pager_SetBorder*(hwnd: HWND, iBorder: int32): INT = discardable INT SendMessage(hwnd, PGM_SETBORDER, 0, cast[LPARAM](iBorder)) +template Pager_SetButtonSize*(hwnd: HWND, iSize: int32): int32 = discardable int32 SendMessage(hwnd, PGM_SETBUTTONSIZE, 0, cast[LPARAM](iSize)) +template Pager_SetChild*(hwnd: HWND, hwndChild: HWND): void = SendMessage(hwnd, PGM_SETCHILD, 0, cast[LPARAM](hwndChild)) +template Pager_SetPos*(hwnd: HWND, iPos: int32): int32 = discardable int32 SendMessage(hwnd, PGM_SETPOS, 0, cast[LPARAM](iPos)) +template Pager_SetScrollInfo*(hwnd: HWND, cTimeOut: UINT, cLinesPer: UINT, cPixelsPerLine: UINT): void = SendMessage(hwnd, PGM_SETSCROLLINFO, cast[WPARAM](cTimeOut), cast[LPARAM](MAKELONG(cLinesPer, cPixelsPerLine))) +template PropSheet_AddPage*(hDlg: HWND, hpage: HPROPSHEETPAGE): BOOL = discardable BOOL SendMessage(hDlg, PSM_ADDPAGE, 0, cast[LPARAM](hpage)) +template PropSheet_Apply*(hDlg: HWND): BOOL = discardable BOOL SendMessage(hDlg, PSM_APPLY, 0, 0) +template PropSheet_CancelToClose*(hDlg: HWND): void = PostMessage(hDlg, PSM_CANCELTOCLOSE, 0, 0) +template PropSheet_Changed*(hDlg: HWND, hwnd: HWND): BOOL = discardable BOOL SendMessage(hDlg, PSM_CHANGED, cast[WPARAM](hwnd), 0) +template PropSheet_GetCurrentPageHwnd*(hDlg: HWND): HWND = discardable HWND SendMessage(hDlg, PSM_GETCURRENTPAGEHWND, 0, 0) +template PropSheet_GetResult*(hDlg: HWND): int32 = discardable int32 SendMessage(hDlg, PSM_GETRESULT, 0, 0) +template PropSheet_GetTabControl*(hDlg: HWND): HWND = discardable HWND SendMessage(hDlg, PSM_GETTABCONTROL, 0, 0) +template PropSheet_HwndToIndex*(hDlg: HWND, hwnd: HWND): int32 = discardable int32 SendMessage(hDlg, PSM_HWNDTOINDEX, cast[WPARAM](hwnd), 0) +template PropSheet_IdToIndex*(hDlg: HWND, id: int32): int32 = discardable int32 SendMessage(hDlg, PSM_IDTOINDEX, 0, cast[LPARAM](id)) +template PropSheet_IndexToHwnd*(hDlg: HWND, i: int32): HWND = discardable HWND SendMessage(hDlg, PSM_INDEXTOHWND, cast[WPARAM](i), 0) +template PropSheet_IndexToId*(hDlg: HWND, i: int32): int32 = discardable int32 SendMessage(hDlg, PSM_INDEXTOID, cast[WPARAM](i), 0) +template PropSheet_IndexToPage*(hDlg: HWND, i: int32): HPROPSHEETPAGE = discardable HPROPSHEETPAGE SendMessage(hDlg, PSM_INDEXTOPAGE, cast[WPARAM](i), 0) +template PropSheet_InsertPage*(hDlg: HWND, index: HWND, hpage: HWND): BOOL = discardable BOOL SendMessage(hDlg, PSM_INSERTPAGE, cast[WPARAM](index), cast[LPARAM](hpage)) +template PropSheet_IsDialogMessage*(hDlg: HWND, pMsg: LPMSG): BOOL = discardable BOOL SendMessage(hDlg, PSM_ISDIALOGMESSAGE, 0, cast[LPARAM](pMsg)) +template PropSheet_PageToIndex*(hDlg: HWND, hpage: HPROPSHEETPAGE): int32 = discardable int32 SendMessage(hDlg, PSM_PAGETOINDEX, 0, cast[LPARAM](hpage)) +template PropSheet_PressButton*(hDlg: HWND, iButton: int32): BOOL = PostMessage(hDlg, PSM_PRESSBUTTON, cast[WPARAM](iButton), 0) +template PropSheet_QuerySiblings*(hDlg: HWND, wParam: WPARAM, lParam: LPARAM): int32 = discardable int32 SendMessage(hDlg, PSM_QUERYSIBLINGS, cast[WPARAM](wParam), cast[LPARAM](lParam)) +template PropSheet_RebootSystem*(hDlg: HWND): void = SendMessage(hDlg, PSM_REBOOTSYSTEM, 0, 0) +template PropSheet_RecalcPageSizes*(hDlg: HWND): BOOL = discardable BOOL SendMessage(hDlg, PSM_RECALCPAGESIZES, 0, 0) +template PropSheet_RemovePage*(hDlg: HWND, index: int32, hpage: HPROPSHEETPAGE): void = SendMessage(hDlg, PSM_REMOVEPAGE, cast[WPARAM](index), cast[LPARAM](hpage)) +template PropSheet_RestartWindows*(hDlg: HWND): void = SendMessage(hDlg, PSM_RESTARTWINDOWS, 0, 0) +template PropSheet_SetCurSel*(hDlg: HWND, hpage: HPROPSHEETPAGE, index: UINT): BOOL = discardable BOOL SendMessage(hDlg, PSM_SETCURSEL, cast[WPARAM](index), cast[LPARAM](hpage)) +template PropSheet_SetCurSelByID*(hDlg: HWND, id: int32): BOOL = discardable BOOL SendMessage(hDlg, PSM_SETCURSELID, 0, cast[LPARAM](id)) +when winimUnicode: + const + PSM_SETFINISHTEXT* = PSM_SETFINISHTEXTW +when winimAnsi: + const + PSM_SETFINISHTEXT* = PSM_SETFINISHTEXTA +template PropSheet_SetFinishText*(hDlg: HWND, lpszText: LPTSTR): void = SendMessage(hDlg, PSM_SETFINISHTEXT, 0, cast[LPARAM](lpszText)) +when winimUnicode: + const + PSM_SETHEADERSUBTITLE* = PSM_SETHEADERSUBTITLEW +when winimAnsi: + const + PSM_SETHEADERSUBTITLE* = PSM_SETHEADERSUBTITLEA +template PropSheet_SetHeaderSubTitle*(hDlg: HWND, index: int32, lpszText: LPCSTR): void = SendMessage(hDlg, PSM_SETHEADERSUBTITLE, cast[WPARAM](index), cast[LPARAM](lpszText)) +when winimUnicode: + const + PSM_SETHEADERTITLE* = PSM_SETHEADERTITLEW +when winimAnsi: + const + PSM_SETHEADERTITLE* = PSM_SETHEADERTITLEA +template PropSheet_SetHeaderTitle*(hDlg: HWND, index: int32, lpszText: LPCTSTR): int32 = discardable int32 SendMessage(hDlg, PSM_SETHEADERTITLE, cast[WPARAM](index), cast[LPARAM](lpszText)) +when winimUnicode: + const + PSM_SETTITLE* = PSM_SETTITLEW +when winimAnsi: + const + PSM_SETTITLE* = PSM_SETTITLEA +template PropSheet_SetTitle*(hDlg: HWND, wStyle: DWORD, lpszText: LPTSTR): void = SendMessage(hDlg, PSM_SETTITLE, cast[WPARAM](wStyle), cast[LPARAM](lpszText)) +template PropSheet_SetWizButtons*(hDlg: HWND, dwFlags: DWORD): void = PostMessage(hDlg, PSM_SETWIZBUTTONS, 0, cast[LPARAM](dwFlags)) +template PropSheet_SetWizButtons*(hDlg: HWND, iButton: int32): void = PostMessage(hDlg, PSM_PRESSBUTTON, cast[WPARAM](iButton), 0) +template PropSheet_UnChanged*(hDlg: HWND, hwnd: HWND): void = SendMessage(hDlg, PSM_UNCHANGED, cast[WPARAM](hwnd), 0) +template TabCtrl_AdjustRect*(hwnd: HWND, bLarger: BOOL, prc: ptr RECT): void = SendMessage(hwnd, TCM_ADJUSTRECT, cast[WPARAM](bLarger), cast[LPARAM](prc)) +template TabCtrl_DeleteAllItems*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, TCM_DELETEALLITEMS, 0, 0) +template TabCtrl_DeleteItem*(hwnd: HWND, i: int32): BOOL = discardable BOOL SendMessage(hwnd, TCM_DELETEITEM, cast[WPARAM](i), 0) +template TabCtrl_DeselectAll*(hwnd: HWND, fExcludeFocus: UINT): void = SendMessage(hwnd, TCM_DESELECTALL, cast[WPARAM](fExcludeFocus), 0) +template TabCtrl_GetCurFocus*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, TCM_GETCURFOCUS, 0, 0) +template TabCtrl_GetCurSel*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, TCM_GETCURSEL, 0, 0) +template TabCtrl_GetExtendedStyle*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, TCM_GETEXTENDEDSTYLE, 0, 0) +template TabCtrl_GetImageList*(hwnd: HWND): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, TCM_GETIMAGELIST, 0, 0) +when winimUnicode: + type + LPTCITEM* = LPTCITEMW +when winimAnsi: + type + LPTCITEM* = LPTCITEMA +when winimUnicode: + const + TCM_GETITEM* = TCM_GETITEMW +when winimAnsi: + const + TCM_GETITEM* = TCM_GETITEMA +template TabCtrl_GetItem*(hwnd: HWND, iItem: int32, pitem: LPTCITEM): BOOL = discardable BOOL SendMessage(hwnd, TCM_GETITEM, cast[WPARAM](iItem), cast[LPARAM](pitem)) +template TabCtrl_GetItemCount*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, TCM_GETITEMCOUNT, 0, 0) +template TabCtrl_GetItemRect*(hwnd: HWND, i: int32, prc: ptr RECT): BOOL = discardable BOOL SendMessage(hwnd, TCM_GETITEMRECT, cast[WPARAM](i), cast[LPARAM](prc)) +template TabCtrl_GetRowCount*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, TCM_GETROWCOUNT, 0, 0) +template TabCtrl_GetToolTips*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, TCM_GETTOOLTIPS, 0, 0) +template TabCtrl_GetUnicodeFormat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, TCM_GETUNICODEFORMAT, 0, 0) +template TabCtrl_HighlightItem*(hwnd: HWND, i: INT, fHighlight: WORD): BOOL = discardable BOOL SendMessage(hwnd, TCM_HIGHLIGHTITEM, cast[WPARAM](i), MAKELONG(fHighlight, 0)) +template TabCtrl_HitTest*(hwnd: HWND, pinfo: LPTCHITTESTINFO): int32 = discardable int32 SendMessage(hwnd, TCM_HITTEST, 0, cast[LPARAM](pinfo)) +when winimUnicode: + const + TCM_INSERTITEM* = TCM_INSERTITEMW +when winimAnsi: + const + TCM_INSERTITEM* = TCM_INSERTITEMA +template TabCtrl_InsertItem*(hwnd: HWND, iItem: int32, pitem: LPTCITEM): int32 = discardable int32 SendMessage(hwnd, TCM_INSERTITEM, cast[WPARAM](iItem), cast[LPARAM](pitem)) +template TabCtrl_RemoveImage*(hwnd: HWND, i: int32): void = SendMessage(hwnd, TCM_REMOVEIMAGE, cast[WPARAM](i), 0) +template TabCtrl_SetCurFocus*(hwnd: HWND, i: int32): void = SendMessage(hwnd, TCM_SETCURFOCUS, cast[WPARAM](i), 0) +template TabCtrl_SetCurSel*(hwnd: HWND, i: int32): int32 = discardable int32 SendMessage(hwnd, TCM_SETCURSEL, cast[WPARAM](i), 0) +template TabCtrl_SetExtendedStyle*(hwnd: HWND, dw: DWORD): DWORD = discardable DWORD SendMessage(hwnd, TCM_SETEXTENDEDSTYLE, 0, cast[LPARAM](dw)) +template TabCtrl_SetImageList*(hwnd: HWND, himl: HIMAGELIST): BOOL = discardable BOOL SendMessage(hwnd, TCM_SETIMAGELIST, 0, cast[LPARAM](himl)) +when winimUnicode: + const + TCM_SETITEM* = TCM_SETITEMW +when winimAnsi: + const + TCM_SETITEM* = TCM_SETITEMA +template TabCtrl_SetItem*(hwnd: HWND, iItem: int32, pitem: LPTCITEM): BOOL = discardable BOOL SendMessage(hwnd, TCM_SETITEM, cast[WPARAM](iItem), cast[LPARAM](pitem)) +template TabCtrl_SetItemExtra*(hwndTC: HWND, cb: int32): BOOL = discardable BOOL SendMessage(hwndTC, TCM_SETITEMEXTRA, cast[WPARAM](cb), 0) +template TabCtrl_SetItemSize*(hwnd: HWND, x: int32, y: int32): DWORD = discardable DWORD SendMessage(hwnd, TCM_SETITEMSIZE, 0, MAKELPARAM(x, y)) +template TabCtrl_SetMinTabWidth*(hwnd: HWND, x: int32): int32 = discardable int32 SendMessage(hwnd, TCM_SETMINTABWIDTH, 0, cast[LPARAM](x)) +template TabCtrl_SetPadding*(hwnd: HWND, cx: int32, cy: int32): void = SendMessage(hwnd, TCM_SETPADDING, 0, MAKELPARAM(cx,cy)) +template TabCtrl_SetToolTips*(hwnd: HWND, hwndTT: HWND): void = SendMessage(hwnd, TCM_SETTOOLTIPS, cast[WPARAM](hwndTT), 0) +template TabCtrl_SetUnicodeFormat*(hwnd: HWND, fUnicode: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TCM_SETUNICODEFORMAT, cast[WPARAM](fUnicode), 0) +template TreeView_CreateDragImage*(hwnd: HWND, hitem: HTREEITEM): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, TVM_CREATEDRAGIMAGE, 0, cast[LPARAM](hitem)) +template TreeView_DeleteAllItems*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, TVM_DELETEITEM, 0, cast[LPARAM](TVI_ROOT)) +template TreeView_DeleteItem*(hwnd: HWND, hitem: HTREEITEM): BOOL = discardable BOOL SendMessage(hwnd, TVM_DELETEITEM, 0, cast[LPARAM](hitem)) +when winimUnicode: + const + TVM_EDITLABEL* = TVM_EDITLABELW +when winimAnsi: + const + TVM_EDITLABEL* = TVM_EDITLABELA +template TreeView_EditLabel*(hwnd: HWND, hitem: HTREEITEM): HWND = discardable HWND SendMessage(hwnd, TVM_EDITLABEL, 0, cast[LPARAM](hitem)) +template TreeView_EndEditLabelNow*(hwnd: HWND, fCancel: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TVM_ENDEDITLABELNOW, cast[WPARAM](fCancel), 0) +template TreeView_EnsureVisible*(hwnd: HWND, hitem: HTREEITEM): BOOL = discardable BOOL SendMessage(hwnd, TVM_ENSUREVISIBLE, 0, cast[LPARAM](hitem)) +template TreeView_Expand*(hwnd: HWND, hitem: HTREEITEM, code: UINT): BOOL = discardable BOOL SendMessage(hwnd, TVM_EXPAND, cast[WPARAM](code), cast[LPARAM](hitem)) +template TreeView_GetBkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_GETBKCOLOR, 0, 0) +template TreeView_GetCheckState*(hwnd: HWND, hti: HTREEITEM): UINT = discardable UINT((SendMessage(hwnd, TVM_GETITEMSTATE, cast[WPARAM](hti), TVIS_STATEIMAGEMASK) shr 12) - 1) +template TreeView_GetNextItem*(hwnd: HWND, hitem: HTREEITEM, code: UINT): HTREEITEM = discardable HTREEITEM SendMessage(hwnd, TVM_GETNEXTITEM, cast[WPARAM](code), cast[LPARAM](hitem)) +template TreeView_GetChild*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_CHILD) +template TreeView_GetCount*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, TVM_GETCOUNT, 0, 0) +template TreeView_GetDropHilight*(hwnd: HWND): HTREEITEM = TreeView_GetNextItem(hwnd, 0, TVGN_DROPHILITE) +template TreeView_GetEditControl*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, TVM_GETEDITCONTROL, 0, 0) +template TreeView_GetExtendedStyle*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, TVM_GETEXTENDEDSTYLE, 0, 0) +template TreeView_GetFirstVisible*(hwnd: HWND): HTREEITEM = TreeView_GetNextItem(hwnd, 0, TVGN_FIRSTVISIBLE) +template TreeView_GetImageList*(hwnd: HWND, iImage: INT): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, TVM_GETIMAGELIST, cast[WPARAM](iImage), 0) +template TreeView_GetIndent*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, TVM_GETINDENT, 0, 0) +template TreeView_GetInsertMarkColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_GETINSERTMARKCOLOR, 0, 0) +when winimUnicode: + const + TVM_GETISEARCHSTRING* = TVM_GETISEARCHSTRINGW +when winimAnsi: + const + TVM_GETISEARCHSTRING* = TVM_GETISEARCHSTRINGA +template TreeView_GetISearchString*(hwndTV: HWND, lpsz: LPTSTR): BOOL = discardable BOOL SendMessage(hwndTV, TVM_GETISEARCHSTRING, 0, cast[LPARAM](lpsz)) +when winimUnicode: + type + LPTVITEM* = LPTVITEMW +when winimAnsi: + type + LPTVITEM* = LPTVITEMA +when winimUnicode: + const + TVM_GETITEM* = TVM_GETITEMW +when winimAnsi: + const + TVM_GETITEM* = TVM_GETITEMA +template TreeView_GetItem*(hwnd: HWND, pitem: LPTVITEM): BOOL = discardable BOOL SendMessage(hwnd, TVM_GETITEM, 0, cast[LPARAM](pitem)) +template TreeView_GetItemHeight*(hwnd: HWND): int32 = discardable int32 SendMessage(hwnd, TVM_GETITEMHEIGHT, 0, 0) +template TreeView_GetItemPartRect*(hwnd: HWND, hitem: HTREEITEM, pRect: ptr RECT, pPartID: TVITEMPART): BOOL = (var info = TVGETITEMPARTRECTINFO(hti: hItem, prc: pRect, partID: pPartID); discardable BOOL SendMessage(hwnd, TVM_GETITEMPARTRECT, 0, cast[LPARAM](addr info))) +template TreeView_GetItemRect*(hwnd: HWND, hitem: HTREEITEM, prc: LPRECT, fItemRect: BOOL): BOOL = (cast[ptr HTREEITEM](prc)[] = hitem; discardable BOOL SendMessage(hwnd, TVM_GETITEMRECT, cast[WPARAM](fItemRect), cast[LPARAM](prc))) +template TreeView_GetItemState*(hwndTV: HWND, hti: HTREEITEM, mask: UINT): UINT = discardable UINT SendMessage(hwndTV, TVM_GETITEMSTATE, cast[WPARAM](hti), cast[LPARAM](mask)) +template TreeView_GetLastVisible*(hwnd: HWND): HTREEITEM = TreeView_GetNextItem(hwnd, 0, TVGN_LASTVISIBLE) +template TreeView_GetLineColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_GETLINECOLOR, 0, 0) +template TreeView_GetNextSelected*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem (hwnd, hitem, TVGN_NEXTSELECTED) +template TreeView_GetNextSibling*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_NEXT) +template TreeView_GetNextVisible*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_NEXTVISIBLE) +template TreeView_GetParent*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_PARENT) +template TreeView_GetPrevSibling*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_PREVIOUS) +template TreeView_GetPrevVisible*(hwnd: HWND, hitem: HTREEITEM): HTREEITEM = TreeView_GetNextItem(hwnd, hitem, TVGN_PREVIOUSVISIBLE) +template TreeView_GetRoot*(hwnd: HWND): HTREEITEM = TreeView_GetNextItem(hwnd, 0, TVGN_ROOT) +template TreeView_GetScrollTime*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, TVM_GETSCROLLTIME, 0, 0) +template TreeView_GetSelectedCount*(hwnd: HWND): DWORD = discardable DWORD SendMessage(hwnd, TVM_GETSELECTEDCOUNT, 0, 0) +template TreeView_GetSelection*(hwnd: HWND): HTREEITEM = TreeView_GetNextItem(hwnd, 0, TVGN_CARET) +template TreeView_GetTextColor*(hwnd: HWND): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_GETTEXTCOLOR, 0, 0) +template TreeView_GetToolTips*(hwnd: HWND): HWND = discardable HWND SendMessage(hwnd, TVM_GETTOOLTIPS, 0, 0) +template TreeView_GetUnicodeFormat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, TVM_GETUNICODEFORMAT, 0, 0) +template TreeView_GetVisibleCount*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, TVM_GETVISIBLECOUNT, 0, 0) +template TreeView_HitTest*(hwnd: HWND, lpht: LPTVHITTESTINFO): HTREEITEM = discardable HTREEITEM SendMessage(hwnd, TVM_HITTEST, 0, cast[LPARAM](lpht)) +when winimUnicode: + type + LPTVINSERTSTRUCT* = LPTVINSERTSTRUCTW +when winimAnsi: + type + LPTVINSERTSTRUCT* = LPTVINSERTSTRUCTA +when winimUnicode: + const + TVM_INSERTITEM* = TVM_INSERTITEMW +when winimAnsi: + const + TVM_INSERTITEM* = TVM_INSERTITEMA +template TreeView_InsertItem*(hwnd: HWND, lpis: LPTVINSERTSTRUCT): HTREEITEM = discardable HTREEITEM SendMessage(hwnd, TVM_INSERTITEM, 0, cast[LPARAM](lpis)) +template TreeView_MapAccIDToHTREEITEM*(hwnd: HWND, id: UINT): HTREEITEM = discardable HTREEITEM SendMessage(hwnd, TVM_MAPACCIDTOHTREEITEM, cast[WPARAM](id), 0) +template TreeView_MapHTREEITEMToAccID*(hwnd: HWND, htreeitem: HTREEITEM): UINT = discardable UINT SendMessage(hwnd, TVM_MAPHTREEITEMTOACCID, cast[WPARAM](htreeitem), 0) +template TreeView_Select*(hwnd: HWND, hitem: HTREEITEM, code: UINT): BOOL = discardable BOOL SendMessage(hwnd, TVM_SELECTITEM, cast[WPARAM](code), cast[LPARAM](hitem)) +template TreeView_SelectDropTarget*(hwnd: HWND, hitem: HTREEITEM): BOOL = TreeView_Select(hwnd, hitem, TVGN_DROPHILITE) +template TreeView_SelectItem*(hwnd: HWND, hitem: HTREEITEM): BOOL = TreeView_Select(hwnd, hitem, TVGN_CARET) +template TreeView_SelectSetFirstVisible*(hwnd: HWND, hitem: HTREEITEM): BOOL = TreeView_Select(hwnd, hitem, TVGN_FIRSTVISIBLE) +template TreeView_SetAutoScrollInfo*(hwnd: HWND, uPixPerSec: UINT, uUpdateTime: UINT): LRESULT = discardable LRESULT SendMessage(hwnd, TVM_SETAUTOSCROLLINFO, cast[WPARAM](uPixPerSec), cast[LPARAM](uUpdateTime)) +template TreeView_SetBkColor*(hwnd: HWND, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_SETBKCOLOR, 0, cast[LPARAM](clr)) +template TreeView_SetBorder*(hwnd: HWND, dwFlags: DWORD, xBorder: SHORT, yBorder: SHORT): int32 = discardable int32 SendMessage(hwnd, TVM_SETBORDER, cast[WPARAM](dwFlags), MAKELPARAM(xBorder, yBorder)) +when winimUnicode: + type + TVITEM* = TVITEMW +when winimAnsi: + type + TVITEM* = TVITEMA +when winimUnicode: + const + TVM_SETITEM* = TVM_SETITEMW +when winimAnsi: + const + TVM_SETITEM* = TVM_SETITEMA +template TreeView_SetItemState*(hwnd: HWND, hti: HTREEITEM, data: UINT, m: UINT): UINT = (var tvi = TVITEM(mask: TVIF_STATE, hItem: hti, stateMask: m, state: data); discardable UINT SendMessage(hwnd, TVM_SETITEM, 0, cast[LPARAM](addr tvi))) +template TreeView_SetCheckState*(hwnd: HWND, hti: HTREEITEM, fCheck: BOOL): UINT = TreeView_SetItemState(hwnd, hti, INDEXTOSTATEIMAGEMASK(if bool fCheck:2 else:1), TVIS_STATEIMAGEMASK) +template TreeView_SetExtendedStyle*(hwnd: HWND, dw: DWORD, mask: UINT): HRESULT = discardable HRESULT SendMessage(hwnd, TVM_SETEXTENDEDSTYLE, cast[WPARAM](mask), cast[LPARAM](dw)) +template TreeView_SetHot*(hwnd: HWND, hitem: HTREEITEM): LRESULT = discardable LRESULT SendMessage(hwnd, TVM_SETHOT, 0, cast[LPARAM](hitem)) +template TreeView_SetImageList*(hwnd: HWND, himl: HIMAGELIST, iImage: INT): HIMAGELIST = discardable HIMAGELIST SendMessage(hwnd, TVM_SETIMAGELIST, cast[WPARAM](iImage), cast[LPARAM](himl)) +template TreeView_SetIndent*(hwnd: HWND, indent: INT): BOOL = discardable BOOL SendMessage(hwnd, TVM_SETINDENT, cast[WPARAM](indent), 0) +template TreeView_SetInsertMark*(hwnd: HWND, hItem: HTREEITEM, fAfter: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TVM_SETINSERTMARK, cast[WPARAM](fAfter), cast[LPARAM](hItem)) +template TreeView_SetInsertMarkColor*(hwnd: HWND, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_SETINSERTMARKCOLOR, 0, cast[LPARAM](clr)) +template TreeView_SetItem*(hwnd: HWND, pitem: LPTVITEM): BOOL = discardable BOOL SendMessage(hwnd, TVM_SETITEM, 0, cast[LPARAM](pitem)) +template TreeView_SetItemHeight*(hwnd: HWND, iHeight: SHORT): int32 = discardable int32 SendMessage(hwnd, TVM_SETITEMHEIGHT, cast[WPARAM](iHeight), 0) +template TreeView_SetLineColor*(hwnd: HWND, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_SETLINECOLOR, 0, cast[LPARAM](clr)) +template TreeView_SetScrollTime*(hwnd: HWND, uTime: UINT): UINT = discardable UINT SendMessage(hwnd, TVM_SETSCROLLTIME, cast[WPARAM](uTime), 0) +template TreeView_SetTextColor*(hwnd: HWND, clr: COLORREF): COLORREF = discardable COLORREF SendMessage(hwnd, TVM_SETTEXTCOLOR, 0, cast[LPARAM](clr)) +template TreeView_SetToolTips*(hwnd: HWND, hwndTT: HWND): HWND = discardable HWND SendMessage(hwnd, TVM_SETTOOLTIPS, cast[WPARAM](hwndTT), 0) +template TreeView_SetUnicodeFormat*(hwnd: HWND, fUnicode: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TVM_SETUNICODEFORMAT, cast[WPARAM](fUnicode), 0) +template TreeView_ShowInfoTip*(hwnd: HWND, hitem: HTREEITEM): DWORD = discardable DWORD SendMessage(hwnd, TVM_SHOWINFOTIP, 0, cast[LPARAM](hitem)) +template TreeView_SortChildren*(hwnd: HWND, hitem: HTREEITEM, recurse: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TVM_SORTCHILDREN, cast[WPARAM](recurse), cast[LPARAM](hitem)) +template TreeView_SortChildrenCB*(hwnd: HWND, psort: LPTVSORTCB, recurse: BOOL): BOOL = discardable BOOL SendMessage(hwnd, TVM_SORTCHILDRENCB, cast[WPARAM](recurse), cast[LPARAM](psort)) +proc `pszTemplate=`*(self: var PROPSHEETPAGEA, x: LPCSTR) {.inline.} = self.union1.pszTemplate = x +proc pszTemplate*(self: PROPSHEETPAGEA): LPCSTR {.inline.} = self.union1.pszTemplate +proc pszTemplate*(self: var PROPSHEETPAGEA): var LPCSTR {.inline.} = self.union1.pszTemplate +proc `pResource=`*(self: var PROPSHEETPAGEA, x: LPCDLGTEMPLATE) {.inline.} = self.union1.pResource = x +proc pResource*(self: PROPSHEETPAGEA): LPCDLGTEMPLATE {.inline.} = self.union1.pResource +proc pResource*(self: var PROPSHEETPAGEA): var LPCDLGTEMPLATE {.inline.} = self.union1.pResource +proc `hIcon=`*(self: var PROPSHEETPAGEA, x: HICON) {.inline.} = self.union2.hIcon = x +proc hIcon*(self: PROPSHEETPAGEA): HICON {.inline.} = self.union2.hIcon +proc hIcon*(self: var PROPSHEETPAGEA): var HICON {.inline.} = self.union2.hIcon +proc `pszIcon=`*(self: var PROPSHEETPAGEA, x: LPCSTR) {.inline.} = self.union2.pszIcon = x +proc pszIcon*(self: PROPSHEETPAGEA): LPCSTR {.inline.} = self.union2.pszIcon +proc pszIcon*(self: var PROPSHEETPAGEA): var LPCSTR {.inline.} = self.union2.pszIcon +proc `pszTemplate=`*(self: var PROPSHEETPAGEW, x: LPCWSTR) {.inline.} = self.union1.pszTemplate = x +proc pszTemplate*(self: PROPSHEETPAGEW): LPCWSTR {.inline.} = self.union1.pszTemplate +proc pszTemplate*(self: var PROPSHEETPAGEW): var LPCWSTR {.inline.} = self.union1.pszTemplate +proc `pResource=`*(self: var PROPSHEETPAGEW, x: LPCDLGTEMPLATE) {.inline.} = self.union1.pResource = x +proc pResource*(self: PROPSHEETPAGEW): LPCDLGTEMPLATE {.inline.} = self.union1.pResource +proc pResource*(self: var PROPSHEETPAGEW): var LPCDLGTEMPLATE {.inline.} = self.union1.pResource +proc `hIcon=`*(self: var PROPSHEETPAGEW, x: HICON) {.inline.} = self.union2.hIcon = x +proc hIcon*(self: PROPSHEETPAGEW): HICON {.inline.} = self.union2.hIcon +proc hIcon*(self: var PROPSHEETPAGEW): var HICON {.inline.} = self.union2.hIcon +proc `pszIcon=`*(self: var PROPSHEETPAGEW, x: LPCWSTR) {.inline.} = self.union2.pszIcon = x +proc pszIcon*(self: PROPSHEETPAGEW): LPCWSTR {.inline.} = self.union2.pszIcon +proc pszIcon*(self: var PROPSHEETPAGEW): var LPCWSTR {.inline.} = self.union2.pszIcon +proc `hIcon=`*(self: var PROPSHEETHEADERA, x: HICON) {.inline.} = self.union1.hIcon = x +proc hIcon*(self: PROPSHEETHEADERA): HICON {.inline.} = self.union1.hIcon +proc hIcon*(self: var PROPSHEETHEADERA): var HICON {.inline.} = self.union1.hIcon +proc `pszIcon=`*(self: var PROPSHEETHEADERA, x: LPCSTR) {.inline.} = self.union1.pszIcon = x +proc pszIcon*(self: PROPSHEETHEADERA): LPCSTR {.inline.} = self.union1.pszIcon +proc pszIcon*(self: var PROPSHEETHEADERA): var LPCSTR {.inline.} = self.union1.pszIcon +proc `nStartPage=`*(self: var PROPSHEETHEADERA, x: UINT) {.inline.} = self.union2.nStartPage = x +proc nStartPage*(self: PROPSHEETHEADERA): UINT {.inline.} = self.union2.nStartPage +proc nStartPage*(self: var PROPSHEETHEADERA): var UINT {.inline.} = self.union2.nStartPage +proc `pStartPage=`*(self: var PROPSHEETHEADERA, x: LPCSTR) {.inline.} = self.union2.pStartPage = x +proc pStartPage*(self: PROPSHEETHEADERA): LPCSTR {.inline.} = self.union2.pStartPage +proc pStartPage*(self: var PROPSHEETHEADERA): var LPCSTR {.inline.} = self.union2.pStartPage +proc `ppsp=`*(self: var PROPSHEETHEADERA, x: LPCPROPSHEETPAGEA) {.inline.} = self.union3.ppsp = x +proc ppsp*(self: PROPSHEETHEADERA): LPCPROPSHEETPAGEA {.inline.} = self.union3.ppsp +proc ppsp*(self: var PROPSHEETHEADERA): var LPCPROPSHEETPAGEA {.inline.} = self.union3.ppsp +proc `phpage=`*(self: var PROPSHEETHEADERA, x: ptr HPROPSHEETPAGE) {.inline.} = self.union3.phpage = x +proc phpage*(self: PROPSHEETHEADERA): ptr HPROPSHEETPAGE {.inline.} = self.union3.phpage +proc phpage*(self: var PROPSHEETHEADERA): var ptr HPROPSHEETPAGE {.inline.} = self.union3.phpage +proc `hbmWatermark=`*(self: var PROPSHEETHEADERA, x: HBITMAP) {.inline.} = self.union4.hbmWatermark = x +proc hbmWatermark*(self: PROPSHEETHEADERA): HBITMAP {.inline.} = self.union4.hbmWatermark +proc hbmWatermark*(self: var PROPSHEETHEADERA): var HBITMAP {.inline.} = self.union4.hbmWatermark +proc `pszbmWatermark=`*(self: var PROPSHEETHEADERA, x: LPCSTR) {.inline.} = self.union4.pszbmWatermark = x +proc pszbmWatermark*(self: PROPSHEETHEADERA): LPCSTR {.inline.} = self.union4.pszbmWatermark +proc pszbmWatermark*(self: var PROPSHEETHEADERA): var LPCSTR {.inline.} = self.union4.pszbmWatermark +proc `hbmHeader=`*(self: var PROPSHEETHEADERA, x: HBITMAP) {.inline.} = self.union5.hbmHeader = x +proc hbmHeader*(self: PROPSHEETHEADERA): HBITMAP {.inline.} = self.union5.hbmHeader +proc hbmHeader*(self: var PROPSHEETHEADERA): var HBITMAP {.inline.} = self.union5.hbmHeader +proc `pszbmHeader=`*(self: var PROPSHEETHEADERA, x: LPCSTR) {.inline.} = self.union5.pszbmHeader = x +proc pszbmHeader*(self: PROPSHEETHEADERA): LPCSTR {.inline.} = self.union5.pszbmHeader +proc pszbmHeader*(self: var PROPSHEETHEADERA): var LPCSTR {.inline.} = self.union5.pszbmHeader +proc `hIcon=`*(self: var PROPSHEETHEADERW, x: HICON) {.inline.} = self.union1.hIcon = x +proc hIcon*(self: PROPSHEETHEADERW): HICON {.inline.} = self.union1.hIcon +proc hIcon*(self: var PROPSHEETHEADERW): var HICON {.inline.} = self.union1.hIcon +proc `pszIcon=`*(self: var PROPSHEETHEADERW, x: LPCWSTR) {.inline.} = self.union1.pszIcon = x +proc pszIcon*(self: PROPSHEETHEADERW): LPCWSTR {.inline.} = self.union1.pszIcon +proc pszIcon*(self: var PROPSHEETHEADERW): var LPCWSTR {.inline.} = self.union1.pszIcon +proc `nStartPage=`*(self: var PROPSHEETHEADERW, x: UINT) {.inline.} = self.union2.nStartPage = x +proc nStartPage*(self: PROPSHEETHEADERW): UINT {.inline.} = self.union2.nStartPage +proc nStartPage*(self: var PROPSHEETHEADERW): var UINT {.inline.} = self.union2.nStartPage +proc `pStartPage=`*(self: var PROPSHEETHEADERW, x: LPCWSTR) {.inline.} = self.union2.pStartPage = x +proc pStartPage*(self: PROPSHEETHEADERW): LPCWSTR {.inline.} = self.union2.pStartPage +proc pStartPage*(self: var PROPSHEETHEADERW): var LPCWSTR {.inline.} = self.union2.pStartPage +proc `ppsp=`*(self: var PROPSHEETHEADERW, x: LPCPROPSHEETPAGEW) {.inline.} = self.union3.ppsp = x +proc ppsp*(self: PROPSHEETHEADERW): LPCPROPSHEETPAGEW {.inline.} = self.union3.ppsp +proc ppsp*(self: var PROPSHEETHEADERW): var LPCPROPSHEETPAGEW {.inline.} = self.union3.ppsp +proc `phpage=`*(self: var PROPSHEETHEADERW, x: ptr HPROPSHEETPAGE) {.inline.} = self.union3.phpage = x +proc phpage*(self: PROPSHEETHEADERW): ptr HPROPSHEETPAGE {.inline.} = self.union3.phpage +proc phpage*(self: var PROPSHEETHEADERW): var ptr HPROPSHEETPAGE {.inline.} = self.union3.phpage +proc `hbmWatermark=`*(self: var PROPSHEETHEADERW, x: HBITMAP) {.inline.} = self.union4.hbmWatermark = x +proc hbmWatermark*(self: PROPSHEETHEADERW): HBITMAP {.inline.} = self.union4.hbmWatermark +proc hbmWatermark*(self: var PROPSHEETHEADERW): var HBITMAP {.inline.} = self.union4.hbmWatermark +proc `pszbmWatermark=`*(self: var PROPSHEETHEADERW, x: LPCWSTR) {.inline.} = self.union4.pszbmWatermark = x +proc pszbmWatermark*(self: PROPSHEETHEADERW): LPCWSTR {.inline.} = self.union4.pszbmWatermark +proc pszbmWatermark*(self: var PROPSHEETHEADERW): var LPCWSTR {.inline.} = self.union4.pszbmWatermark +proc `hbmHeader=`*(self: var PROPSHEETHEADERW, x: HBITMAP) {.inline.} = self.union5.hbmHeader = x +proc hbmHeader*(self: PROPSHEETHEADERW): HBITMAP {.inline.} = self.union5.hbmHeader +proc hbmHeader*(self: var PROPSHEETHEADERW): var HBITMAP {.inline.} = self.union5.hbmHeader +proc `pszbmHeader=`*(self: var PROPSHEETHEADERW, x: LPCWSTR) {.inline.} = self.union5.pszbmHeader = x +proc pszbmHeader*(self: PROPSHEETHEADERW): LPCWSTR {.inline.} = self.union5.pszbmHeader +proc pszbmHeader*(self: var PROPSHEETHEADERW): var LPCWSTR {.inline.} = self.union5.pszbmHeader +proc `itemex=`*(self: var TVINSERTSTRUCTA, x: TVITEMEXA) {.inline.} = self.union1.itemex = x +proc itemex*(self: TVINSERTSTRUCTA): TVITEMEXA {.inline.} = self.union1.itemex +proc itemex*(self: var TVINSERTSTRUCTA): var TVITEMEXA {.inline.} = self.union1.itemex +proc `item=`*(self: var TVINSERTSTRUCTA, x: TV_ITEMA) {.inline.} = self.union1.item = x +proc item*(self: TVINSERTSTRUCTA): TV_ITEMA {.inline.} = self.union1.item +proc item*(self: var TVINSERTSTRUCTA): var TV_ITEMA {.inline.} = self.union1.item +proc `itemex=`*(self: var TVINSERTSTRUCTW, x: TVITEMEXW) {.inline.} = self.union1.itemex = x +proc itemex*(self: TVINSERTSTRUCTW): TVITEMEXW {.inline.} = self.union1.itemex +proc itemex*(self: var TVINSERTSTRUCTW): var TVITEMEXW {.inline.} = self.union1.itemex +proc `item=`*(self: var TVINSERTSTRUCTW, x: TV_ITEMW) {.inline.} = self.union1.item = x +proc item*(self: TVINSERTSTRUCTW): TV_ITEMW {.inline.} = self.union1.item +proc item*(self: var TVINSERTSTRUCTW): var TV_ITEMW {.inline.} = self.union1.item +proc `hMainIcon=`*(self: var TASKDIALOGCONFIG, x: HICON) {.inline.} = self.union1.hMainIcon = x +proc hMainIcon*(self: TASKDIALOGCONFIG): HICON {.inline.} = self.union1.hMainIcon +proc hMainIcon*(self: var TASKDIALOGCONFIG): var HICON {.inline.} = self.union1.hMainIcon +proc `pszMainIcon=`*(self: var TASKDIALOGCONFIG, x: PCWSTR) {.inline.} = self.union1.pszMainIcon = x +proc pszMainIcon*(self: TASKDIALOGCONFIG): PCWSTR {.inline.} = self.union1.pszMainIcon +proc pszMainIcon*(self: var TASKDIALOGCONFIG): var PCWSTR {.inline.} = self.union1.pszMainIcon +proc `hFooterIcon=`*(self: var TASKDIALOGCONFIG, x: HICON) {.inline.} = self.union2.hFooterIcon = x +proc hFooterIcon*(self: TASKDIALOGCONFIG): HICON {.inline.} = self.union2.hFooterIcon +proc hFooterIcon*(self: var TASKDIALOGCONFIG): var HICON {.inline.} = self.union2.hFooterIcon +proc `pszFooterIcon=`*(self: var TASKDIALOGCONFIG, x: PCWSTR) {.inline.} = self.union2.pszFooterIcon = x +proc pszFooterIcon*(self: TASKDIALOGCONFIG): PCWSTR {.inline.} = self.union2.pszFooterIcon +proc pszFooterIcon*(self: var TASKDIALOGCONFIG): var PCWSTR {.inline.} = self.union2.pszFooterIcon +proc Add*(self: ptr IImageList, hbmImage: HBITMAP, hbmMask: HBITMAP, pi: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Add(self, hbmImage, hbmMask, pi) +proc ReplaceIcon*(self: ptr IImageList, i: int32, hicon: HICON, pi: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReplaceIcon(self, i, hicon, pi) +proc SetOverlayImage*(self: ptr IImageList, iImage: int32, iOverlay: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOverlayImage(self, iImage, iOverlay) +proc Replace*(self: ptr IImageList, i: int32, hbmImage: HBITMAP, hbmMask: HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Replace(self, i, hbmImage, hbmMask) +proc AddMasked*(self: ptr IImageList, hbmImage: HBITMAP, crMask: COLORREF, pi: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddMasked(self, hbmImage, crMask, pi) +proc Draw*(self: ptr IImageList, pimldp: ptr IMAGELISTDRAWPARAMS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Draw(self, pimldp) +proc Remove*(self: ptr IImageList, i: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Remove(self, i) +proc GetIcon*(self: ptr IImageList, i: int32, flags: UINT, picon: ptr HICON): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIcon(self, i, flags, picon) +proc GetImageInfo*(self: ptr IImageList, i: int32, pImageInfo: ptr IMAGEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImageInfo(self, i, pImageInfo) +proc Copy*(self: ptr IImageList, iDst: int32, punkSrc: ptr IUnknown, iSrc: int32, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Copy(self, iDst, punkSrc, iSrc, uFlags) +proc Merge*(self: ptr IImageList, i1: int32, punk2: ptr IUnknown, i2: int32, dx: int32, dy: int32, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Merge(self, i1, punk2, i2, dx, dy, riid, ppv) +proc Clone*(self: ptr IImageList, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, riid, ppv) +proc GetImageRect*(self: ptr IImageList, i: int32, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImageRect(self, i, prc) +proc GetIconSize*(self: ptr IImageList, cx: ptr int32, cy: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconSize(self, cx, cy) +proc SetIconSize*(self: ptr IImageList, cx: int32, cy: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconSize(self, cx, cy) +proc GetImageCount*(self: ptr IImageList, pi: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImageCount(self, pi) +proc SetImageCount*(self: ptr IImageList, uNewCount: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetImageCount(self, uNewCount) +proc SetBkColor*(self: ptr IImageList, clrBk: COLORREF, pclr: ptr COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBkColor(self, clrBk, pclr) +proc GetBkColor*(self: ptr IImageList, pclr: ptr COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBkColor(self, pclr) +proc BeginDrag*(self: ptr IImageList, iTrack: int32, dxHotspot: int32, dyHotspot: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginDrag(self, iTrack, dxHotspot, dyHotspot) +proc EndDrag*(self: ptr IImageList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndDrag(self) +proc DragEnter*(self: ptr IImageList, hwndLock: HWND, x: int32, y: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragEnter(self, hwndLock, x, y) +proc DragLeave*(self: ptr IImageList, hwndLock: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragLeave(self, hwndLock) +proc DragMove*(self: ptr IImageList, x: int32, y: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragMove(self, x, y) +proc SetDragCursorImage*(self: ptr IImageList, punk: ptr IUnknown, iDrag: int32, dxHotspot: int32, dyHotspot: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDragCursorImage(self, punk, iDrag, dxHotspot, dyHotspot) +proc DragShowNolock*(self: ptr IImageList, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragShowNolock(self, fShow) +proc GetDragImage*(self: ptr IImageList, ppt: ptr POINT, pptHotspot: ptr POINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDragImage(self, ppt, pptHotspot, riid, ppv) +proc GetItemFlags*(self: ptr IImageList, i: int32, dwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemFlags(self, i, dwFlags) +proc GetOverlayImage*(self: ptr IImageList, iOverlay: int32, piIndex: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverlayImage(self, iOverlay, piIndex) +proc Resize*(self: ptr IImageList2, cxNewIconSize: int32, cyNewIconSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resize(self, cxNewIconSize, cyNewIconSize) +proc GetOriginalSize*(self: ptr IImageList2, iImage: int32, dwFlags: DWORD, pcx: ptr int32, pcy: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOriginalSize(self, iImage, dwFlags, pcx, pcy) +proc SetOriginalSize*(self: ptr IImageList2, iImage: int32, cx: int32, cy: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOriginalSize(self, iImage, cx, cy) +proc SetCallback*(self: ptr IImageList2, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCallback(self, punk) +proc GetCallback*(self: ptr IImageList2, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCallback(self, riid, ppv) +proc ForceImagePresent*(self: ptr IImageList2, iImage: int32, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ForceImagePresent(self, iImage, dwFlags) +proc DiscardImages*(self: ptr IImageList2, iFirstImage: int32, iLastImage: int32, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DiscardImages(self, iFirstImage, iLastImage, dwFlags) +proc PreloadImages*(self: ptr IImageList2, pimldp: ptr IMAGELISTDRAWPARAMS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreloadImages(self, pimldp) +proc GetStatistics*(self: ptr IImageList2, pils: ptr IMAGELISTSTATS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStatistics(self, pils) +proc Initialize*(self: ptr IImageList2, cx: int32, cy: int32, flags: UINT, cInitial: int32, cGrow: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, cx, cy, flags, cInitial, cGrow) +proc Replace2*(self: ptr IImageList2, i: int32, hbmImage: HBITMAP, hbmMask: HBITMAP, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Replace2(self, i, hbmImage, hbmMask, punk, dwFlags) +proc ReplaceFromImageList*(self: ptr IImageList2, i: int32, pil: ptr IImageList, iSrc: int32, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReplaceFromImageList(self, i, pil, iSrc, punk, dwFlags) +converter winimConverterIImageListToIUnknown*(x: ptr IImageList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIImageList2ToIImageList*(x: ptr IImageList2): ptr IImageList = cast[ptr IImageList](x) +converter winimConverterIImageList2ToIUnknown*(x: ptr IImageList2): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + LPNMLVDISPINFO* = LPNMLVDISPINFOW + LPFNPSPCALLBACK* = LPFNPSPCALLBACKW + PROPSHEETPAGE* = PROPSHEETPAGEW + LPPROPSHEETPAGE* = LPPROPSHEETPAGEW + LPCPROPSHEETPAGE* = LPCPROPSHEETPAGEW + PROPSHEETHEADER* = PROPSHEETHEADERW + LPPROPSHEETHEADER* = LPPROPSHEETHEADERW + LPCPROPSHEETHEADER* = LPCPROPSHEETHEADERW + HD_TEXTFILTER* = HD_TEXTFILTERW + LPHD_TEXTFILTER* = LPHD_TEXTFILTERW + HDITEM* = HDITEMW + LPNMHEADER* = LPNMHEADERW + NMHDDISPINFO* = NMHDDISPINFOW + LPNMHDDISPINFO* = LPNMHDDISPINFOW + TBSAVEPARAMS* = TBSAVEPARAMSW + TBBUTTONINFO* = TBBUTTONINFOW + LPTBBUTTONINFO* = LPTBBUTTONINFOW + NMTBGETINFOTIP* = NMTBGETINFOTIPW + LPNMTBGETINFOTIP* = LPNMTBGETINFOTIPW + NMTBDISPINFO* = NMTBDISPINFOW + LPNMTBDISPINFO* = LPNMTBDISPINFOW + REBARBANDINFO* = REBARBANDINFOW + LPREBARBANDINFO* = LPREBARBANDINFOW + LPCREBARBANDINFO* = LPCREBARBANDINFOW + PTOOLINFO* = PTOOLINFOW + TTHITTESTINFO* = TTHITTESTINFOW + LVITEM* = LVITEMW + LVCOLUMN* = LVCOLUMNW + LVBKIMAGE* = LVBKIMAGEW + PNM_FINDITEM* = PNM_FINDITEMW + LPNM_FINDITEM* = LPNM_FINDITEMW + NM_FINDITEM* = NM_FINDITEMW + NMLVFINDITEM* = NMLVFINDITEMW + LPNMLVFINDITEM* = LPNMLVFINDITEMW + NMLVGETINFOTIP* = NMLVGETINFOTIPW + LPNMLVGETINFOTIP* = LPNMLVGETINFOTIPW + TVITEMEX* = TVITEMEXW + LPTVITEMEX* = LPTVITEMEXW + TVINSERTSTRUCT* = TVINSERTSTRUCTW + NMTREEVIEW* = NMTREEVIEWW + LPNMTREEVIEW* = LPNMTREEVIEWW + LPNMTVDISPINFO* = LPNMTVDISPINFOW + LPNMTVDISPINFOEX* = LPNMTVDISPINFOEXW + NMTVGETINFOTIP* = NMTVGETINFOTIPW + LPNMTVGETINFOTIP* = LPNMTVGETINFOTIPW + COMBOBOXEXITEM* = COMBOBOXEXITEMW + PCOMBOBOXEXITEM* = PCOMBOBOXEXITEMW + NMCOMBOBOXEX* = NMCOMBOBOXEXW + PNMCOMBOBOXEX* = PNMCOMBOBOXEXW + NMCBEDRAGBEGIN* = NMCBEDRAGBEGINW + LPNMCBEDRAGBEGIN* = LPNMCBEDRAGBEGINW + PNMCBEDRAGBEGIN* = PNMCBEDRAGBEGINW + NMCBEENDEDIT* = NMCBEENDEDITW + LPNMCBEENDEDIT* = LPNMCBEENDEDITW + PNMCBEENDEDIT* = PNMCBEENDEDITW + TCITEMHEADER* = TCITEMHEADERW + LPTCITEMHEADER* = LPTCITEMHEADERW + TCITEM* = TCITEMW + NMDATETIMESTRING* = NMDATETIMESTRINGW + LPNMDATETIMESTRING* = LPNMDATETIMESTRINGW + NMDATETIMEWMKEYDOWN* = NMDATETIMEWMKEYDOWNW + LPNMDATETIMEWMKEYDOWN* = LPNMDATETIMEWMKEYDOWNW + NMDATETIMEFORMAT* = NMDATETIMEFORMATW + LPNMDATETIMEFORMAT* = LPNMDATETIMEFORMATW + NMDATETIMEFORMATQUERY* = NMDATETIMEFORMATQUERYW + LPNMDATETIMEFORMATQUERY* = LPNMDATETIMEFORMATQUERYW + const + WC_HEADER* = WC_HEADERW + HDN_ITEMCHANGING* = HDN_ITEMCHANGINGW + HDN_ITEMCHANGED* = HDN_ITEMCHANGEDW + HDN_ITEMCLICK* = HDN_ITEMCLICKW + HDN_ITEMDBLCLICK* = HDN_ITEMDBLCLICKW + HDN_DIVIDERDBLCLICK* = HDN_DIVIDERDBLCLICKW + HDN_BEGINTRACK* = HDN_BEGINTRACKW + HDN_ENDTRACK* = HDN_ENDTRACKW + HDN_TRACK* = HDN_TRACKW + HDN_GETDISPINFO* = HDN_GETDISPINFOW + TOOLBARCLASSNAME* = TOOLBARCLASSNAMEW + TB_GETBUTTONTEXT* = TB_GETBUTTONTEXTW + TB_SAVERESTORE* = TB_SAVERESTOREW + TB_ADDSTRING* = TB_ADDSTRINGW + TB_MAPACCELERATOR* = TB_MAPACCELERATORW + TB_GETBUTTONINFO* = TB_GETBUTTONINFOW + TB_SETBUTTONINFO* = TB_SETBUTTONINFOW + TB_INSERTBUTTON* = TB_INSERTBUTTONW + TB_ADDBUTTONS* = TB_ADDBUTTONSW + TB_GETSTRING* = TB_GETSTRINGW + TBN_GETINFOTIP* = TBN_GETINFOTIPW + TBN_GETDISPINFO* = TBN_GETDISPINFOW + TBN_GETBUTTONINFO* = TBN_GETBUTTONINFOW + REBARCLASSNAME* = REBARCLASSNAMEW + RB_INSERTBAND* = RB_INSERTBANDW + RB_SETBANDINFO* = RB_SETBANDINFOW + RB_GETBANDINFO* = RB_GETBANDINFOW + TOOLTIPS_CLASS* = TOOLTIPS_CLASSW + TTM_ADDTOOL* = TTM_ADDTOOLW + TTM_DELTOOL* = TTM_DELTOOLW + TTM_NEWTOOLRECT* = TTM_NEWTOOLRECTW + TTM_GETTOOLINFO* = TTM_GETTOOLINFOW + TTM_SETTOOLINFO* = TTM_SETTOOLINFOW + TTM_HITTEST* = TTM_HITTESTW + TTM_GETTEXT* = TTM_GETTEXTW + TTM_UPDATETIPTEXT* = TTM_UPDATETIPTEXTW + TTM_ENUMTOOLS* = TTM_ENUMTOOLSW + TTM_GETCURRENTTOOL* = TTM_GETCURRENTTOOLW + TTM_SETTITLE* = TTM_SETTITLEW + STATUSCLASSNAME* = STATUSCLASSNAMEW + SB_GETTEXT* = SB_GETTEXTW + SB_SETTEXT* = SB_SETTEXTW + SB_GETTEXTLENGTH* = SB_GETTEXTLENGTHW + SB_SETTIPTEXT* = SB_SETTIPTEXTW + SB_GETTIPTEXT* = SB_GETTIPTEXTW + TRACKBAR_CLASS* = TRACKBAR_CLASSW + UPDOWN_CLASS* = UPDOWN_CLASSW + PROGRESS_CLASS* = PROGRESS_CLASSW + HOTKEY_CLASS* = HOTKEY_CLASSW + WC_LISTVIEW* = WC_LISTVIEWW + LPSTR_TEXTCALLBACK* = LPSTR_TEXTCALLBACKW + LVN_ODFINDITEM* = LVN_ODFINDITEMW + LVN_BEGINLABELEDIT* = LVN_BEGINLABELEDITW + LVN_ENDLABELEDIT* = LVN_ENDLABELEDITW + LVN_GETDISPINFO* = LVN_GETDISPINFOW + LVN_SETDISPINFO* = LVN_SETDISPINFOW + LVN_GETINFOTIP* = LVN_GETINFOTIPW + LVN_INCREMENTALSEARCH* = LVN_INCREMENTALSEARCHW + WC_TREEVIEW* = WC_TREEVIEWW + TVN_SELCHANGING* = TVN_SELCHANGINGW + TVN_SELCHANGED* = TVN_SELCHANGEDW + TVN_GETDISPINFO* = TVN_GETDISPINFOW + TVN_SETDISPINFO* = TVN_SETDISPINFOW + TVN_ITEMEXPANDING* = TVN_ITEMEXPANDINGW + TVN_ITEMEXPANDED* = TVN_ITEMEXPANDEDW + TVN_BEGINDRAG* = TVN_BEGINDRAGW + TVN_BEGINRDRAG* = TVN_BEGINRDRAGW + TVN_DELETEITEM* = TVN_DELETEITEMW + TVN_BEGINLABELEDIT* = TVN_BEGINLABELEDITW + TVN_ENDLABELEDIT* = TVN_ENDLABELEDITW + TVN_GETINFOTIP* = TVN_GETINFOTIPW + TVN_ITEMCHANGING* = TVN_ITEMCHANGINGW + TVN_ITEMCHANGED* = TVN_ITEMCHANGEDW + WC_COMBOBOXEX* = WC_COMBOBOXEXW + CBEM_INSERTITEM* = CBEM_INSERTITEMW + CBEM_SETITEM* = CBEM_SETITEMW + CBEM_GETITEM* = CBEM_GETITEMW + CBEN_GETDISPINFO* = CBEN_GETDISPINFOW + CBEN_DRAGBEGIN* = CBEN_DRAGBEGINW + CBEN_ENDEDIT* = CBEN_ENDEDITW + WC_TABCONTROL* = WC_TABCONTROLW + MONTHCAL_CLASS* = MONTHCAL_CLASSW + DATETIMEPICK_CLASS* = DATETIMEPICK_CLASSW + DTN_USERSTRING* = DTN_USERSTRINGW + DTN_WMKEYDOWN* = DTN_WMKEYDOWNW + DTN_FORMAT* = DTN_FORMATW + DTN_FORMATQUERY* = DTN_FORMATQUERYW + WC_IPADDRESS* = WC_IPADDRESSW + WC_PAGESCROLLER* = WC_PAGESCROLLERW + WC_NATIVEFONTCTL* = WC_NATIVEFONTCTLW + WC_BUTTON* = WC_BUTTONW + WC_STATIC* = WC_STATICW + WC_EDIT* = WC_EDITW + WC_LISTBOX* = WC_LISTBOXW + WC_COMBOBOX* = WC_COMBOBOXW + WC_SCROLLBAR* = WC_SCROLLBARW + proc CreatePropertySheetPage*(constPropSheetPagePointer: LPCPROPSHEETPAGEW): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "comctl32", importc: "CreatePropertySheetPageW".} + proc PropertySheet*(P1: LPCPROPSHEETHEADERW): INT_PTR {.winapi, stdcall, dynlib: "comctl32", importc: "PropertySheetW".} + proc ImageList_LoadImage*(hi: HINSTANCE, lpbmp: LPCWSTR, cx: int32, cGrow: int32, crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageW".} + proc CreateStatusWindow*(style: LONG, lpszText: LPCWSTR, hwndParent: HWND, wID: UINT): HWND {.winapi, stdcall, dynlib: "comctl32", importc: "CreateStatusWindowW".} + proc DrawStatusText*(hDC: HDC, lprc: LPCRECT, pszText: LPCWSTR, uFlags: UINT): void {.winapi, stdcall, dynlib: "comctl32", importc: "DrawStatusTextW".} +when winimAnsi: + type + LPNMLVDISPINFO* = LPNMLVDISPINFOA + LPFNPSPCALLBACK* = LPFNPSPCALLBACKA + PROPSHEETPAGE* = PROPSHEETPAGEA + LPPROPSHEETPAGE* = LPPROPSHEETPAGEA + LPCPROPSHEETPAGE* = LPCPROPSHEETPAGEA + PROPSHEETHEADER* = PROPSHEETHEADERA + LPPROPSHEETHEADER* = LPPROPSHEETHEADERA + LPCPROPSHEETHEADER* = LPCPROPSHEETHEADERA + HD_TEXTFILTER* = HD_TEXTFILTERA + LPHD_TEXTFILTER* = LPHD_TEXTFILTERA + HDITEM* = HDITEMA + LPNMHEADER* = LPNMHEADERA + NMHDDISPINFO* = NMHDDISPINFOA + LPNMHDDISPINFO* = LPNMHDDISPINFOA + TBSAVEPARAMS* = TBSAVEPARAMSA + LPTBSAVEPARAMS* = LPTBSAVEPARAMSA + TBBUTTONINFO* = TBBUTTONINFOA + LPTBBUTTONINFO* = LPTBBUTTONINFOA + NMTBGETINFOTIP* = NMTBGETINFOTIPA + LPNMTBGETINFOTIP* = LPNMTBGETINFOTIPA + NMTBDISPINFO* = NMTBDISPINFOA + LPNMTBDISPINFO* = LPNMTBDISPINFOA + REBARBANDINFO* = REBARBANDINFOA + LPREBARBANDINFO* = LPREBARBANDINFOA + LPCREBARBANDINFO* = LPCREBARBANDINFOA + PTOOLINFO* = PTOOLINFOA + TTHITTESTINFO* = TTHITTESTINFOA + LVITEM* = LVITEMA + LVCOLUMN* = LVCOLUMNA + LVBKIMAGE* = LVBKIMAGEA + PNM_FINDITEM* = PNM_FINDITEMA + LPNM_FINDITEM* = LPNM_FINDITEMA + NM_FINDITEM* = NM_FINDITEMA + NMLVFINDITEM* = NMLVFINDITEMA + LPNMLVFINDITEM* = LPNMLVFINDITEMA + NMLVGETINFOTIP* = NMLVGETINFOTIPA + LPNMLVGETINFOTIP* = LPNMLVGETINFOTIPA + TVITEMEX* = TVITEMEXA + LPTVITEMEX* = LPTVITEMEXA + TVINSERTSTRUCT* = TVINSERTSTRUCTA + NMTREEVIEW* = NMTREEVIEWA + LPNMTREEVIEW* = LPNMTREEVIEWA + LPNMTVDISPINFO* = LPNMTVDISPINFOA + LPNMTVDISPINFOEX* = LPNMTVDISPINFOEXA + NMTVGETINFOTIP* = NMTVGETINFOTIPA + LPNMTVGETINFOTIP* = LPNMTVGETINFOTIPA + COMBOBOXEXITEM* = COMBOBOXEXITEMA + PCOMBOBOXEXITEM* = PCOMBOBOXEXITEMA + NMCOMBOBOXEX* = NMCOMBOBOXEXA + PNMCOMBOBOXEX* = PNMCOMBOBOXEXA + NMCBEDRAGBEGIN* = NMCBEDRAGBEGINA + LPNMCBEDRAGBEGIN* = LPNMCBEDRAGBEGINA + PNMCBEDRAGBEGIN* = PNMCBEDRAGBEGINA + NMCBEENDEDIT* = NMCBEENDEDITA + LPNMCBEENDEDIT* = LPNMCBEENDEDITA + PNMCBEENDEDIT* = PNMCBEENDEDITA + TCITEMHEADER* = TCITEMHEADERA + LPTCITEMHEADER* = LPTCITEMHEADERA + TCITEM* = TCITEMA + NMDATETIMESTRING* = NMDATETIMESTRINGA + LPNMDATETIMESTRING* = LPNMDATETIMESTRINGA + NMDATETIMEWMKEYDOWN* = NMDATETIMEWMKEYDOWNA + LPNMDATETIMEWMKEYDOWN* = LPNMDATETIMEWMKEYDOWNA + NMDATETIMEFORMAT* = NMDATETIMEFORMATA + LPNMDATETIMEFORMAT* = LPNMDATETIMEFORMATA + NMDATETIMEFORMATQUERY* = NMDATETIMEFORMATQUERYA + LPNMDATETIMEFORMATQUERY* = LPNMDATETIMEFORMATQUERYA + const + WC_HEADER* = WC_HEADERA + HDN_ITEMCHANGING* = HDN_ITEMCHANGINGA + HDN_ITEMCHANGED* = HDN_ITEMCHANGEDA + HDN_ITEMCLICK* = HDN_ITEMCLICKA + HDN_ITEMDBLCLICK* = HDN_ITEMDBLCLICKA + HDN_DIVIDERDBLCLICK* = HDN_DIVIDERDBLCLICKA + HDN_BEGINTRACK* = HDN_BEGINTRACKA + HDN_ENDTRACK* = HDN_ENDTRACKA + HDN_TRACK* = HDN_TRACKA + HDN_GETDISPINFO* = HDN_GETDISPINFOA + TOOLBARCLASSNAME* = TOOLBARCLASSNAMEA + TB_GETBUTTONTEXT* = TB_GETBUTTONTEXTA + TB_SAVERESTORE* = TB_SAVERESTOREA + TB_ADDSTRING* = TB_ADDSTRINGA + TB_MAPACCELERATOR* = TB_MAPACCELERATORA + TB_GETBUTTONINFO* = TB_GETBUTTONINFOA + TB_SETBUTTONINFO* = TB_SETBUTTONINFOA + TB_INSERTBUTTON* = TB_INSERTBUTTONA + TB_ADDBUTTONS* = TB_ADDBUTTONSA + TB_GETSTRING* = TB_GETSTRINGA + TBN_GETINFOTIP* = TBN_GETINFOTIPA + TBN_GETDISPINFO* = TBN_GETDISPINFOA + TBN_GETBUTTONINFO* = TBN_GETBUTTONINFOA + REBARCLASSNAME* = REBARCLASSNAMEA + RB_INSERTBAND* = RB_INSERTBANDA + RB_SETBANDINFO* = RB_SETBANDINFOA + RB_GETBANDINFO* = RB_GETBANDINFOA + TOOLTIPS_CLASS* = TOOLTIPS_CLASSA + TTM_ADDTOOL* = TTM_ADDTOOLA + TTM_DELTOOL* = TTM_DELTOOLA + TTM_NEWTOOLRECT* = TTM_NEWTOOLRECTA + TTM_GETTOOLINFO* = TTM_GETTOOLINFOA + TTM_SETTOOLINFO* = TTM_SETTOOLINFOA + TTM_HITTEST* = TTM_HITTESTA + TTM_GETTEXT* = TTM_GETTEXTA + TTM_UPDATETIPTEXT* = TTM_UPDATETIPTEXTA + TTM_ENUMTOOLS* = TTM_ENUMTOOLSA + TTM_GETCURRENTTOOL* = TTM_GETCURRENTTOOLA + TTM_SETTITLE* = TTM_SETTITLEA + STATUSCLASSNAME* = STATUSCLASSNAMEA + SB_GETTEXT* = SB_GETTEXTA + SB_SETTEXT* = SB_SETTEXTA + SB_GETTEXTLENGTH* = SB_GETTEXTLENGTHA + SB_SETTIPTEXT* = SB_SETTIPTEXTA + SB_GETTIPTEXT* = SB_GETTIPTEXTA + TRACKBAR_CLASS* = TRACKBAR_CLASSA + UPDOWN_CLASS* = UPDOWN_CLASSA + PROGRESS_CLASS* = PROGRESS_CLASSA + HOTKEY_CLASS* = HOTKEY_CLASSA + WC_LISTVIEW* = WC_LISTVIEWA + LPSTR_TEXTCALLBACK* = LPSTR_TEXTCALLBACKA + LVN_ODFINDITEM* = LVN_ODFINDITEMA + LVN_BEGINLABELEDIT* = LVN_BEGINLABELEDITA + LVN_ENDLABELEDIT* = LVN_ENDLABELEDITA + LVN_GETDISPINFO* = LVN_GETDISPINFOA + LVN_SETDISPINFO* = LVN_SETDISPINFOA + LVN_GETINFOTIP* = LVN_GETINFOTIPA + LVN_INCREMENTALSEARCH* = LVN_INCREMENTALSEARCHA + WC_TREEVIEW* = WC_TREEVIEWA + TVN_SELCHANGING* = TVN_SELCHANGINGA + TVN_SELCHANGED* = TVN_SELCHANGEDA + TVN_GETDISPINFO* = TVN_GETDISPINFOA + TVN_SETDISPINFO* = TVN_SETDISPINFOA + TVN_ITEMEXPANDING* = TVN_ITEMEXPANDINGA + TVN_ITEMEXPANDED* = TVN_ITEMEXPANDEDA + TVN_BEGINDRAG* = TVN_BEGINDRAGA + TVN_BEGINRDRAG* = TVN_BEGINRDRAGA + TVN_DELETEITEM* = TVN_DELETEITEMA + TVN_BEGINLABELEDIT* = TVN_BEGINLABELEDITA + TVN_ENDLABELEDIT* = TVN_ENDLABELEDITA + TVN_GETINFOTIP* = TVN_GETINFOTIPA + TVN_ITEMCHANGING* = TVN_ITEMCHANGINGA + TVN_ITEMCHANGED* = TVN_ITEMCHANGEDA + WC_COMBOBOXEX* = WC_COMBOBOXEXA + CBEM_INSERTITEM* = CBEM_INSERTITEMA + CBEM_SETITEM* = CBEM_SETITEMA + CBEM_GETITEM* = CBEM_GETITEMA + CBEN_GETDISPINFO* = CBEN_GETDISPINFOA + CBEN_DRAGBEGIN* = CBEN_DRAGBEGINA + CBEN_ENDEDIT* = CBEN_ENDEDITA + WC_TABCONTROL* = WC_TABCONTROLA + MONTHCAL_CLASS* = MONTHCAL_CLASSA + DATETIMEPICK_CLASS* = DATETIMEPICK_CLASSA + DTN_USERSTRING* = DTN_USERSTRINGA + DTN_WMKEYDOWN* = DTN_WMKEYDOWNA + DTN_FORMAT* = DTN_FORMATA + DTN_FORMATQUERY* = DTN_FORMATQUERYA + WC_IPADDRESS* = WC_IPADDRESSA + WC_PAGESCROLLER* = WC_PAGESCROLLERA + WC_NATIVEFONTCTL* = WC_NATIVEFONTCTLA + WC_BUTTON* = WC_BUTTONA + WC_STATIC* = WC_STATICA + WC_EDIT* = WC_EDITA + WC_LISTBOX* = WC_LISTBOXA + WC_COMBOBOX* = WC_COMBOBOXA + WC_SCROLLBAR* = WC_SCROLLBARA + proc CreatePropertySheetPage*(constPropSheetPagePointer: LPCPROPSHEETPAGEA): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "comctl32", importc: "CreatePropertySheetPageA".} + proc PropertySheet*(P1: LPCPROPSHEETHEADERA): INT_PTR {.winapi, stdcall, dynlib: "comctl32", importc: "PropertySheetA".} + proc ImageList_LoadImage*(hi: HINSTANCE, lpbmp: LPCSTR, cx: int32, cGrow: int32, crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST {.winapi, stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageA".} + proc CreateStatusWindow*(style: LONG, lpszText: LPCSTR, hwndParent: HWND, wID: UINT): HWND {.winapi, stdcall, dynlib: "comctl32", importc: "CreateStatusWindowA".} + proc DrawStatusText*(hDC: HDC, lprc: LPCRECT, pszText: LPCSTR, uFlags: UINT): void {.winapi, stdcall, dynlib: "comctl32", importc: "DrawStatusTextA".} +when winimCpu64: + type + PTBBUTTON* = ptr TBBUTTON + LPTBBUTTON* = ptr TBBUTTON + proc FlatSB_GetScrollPropPtr*(P1: HWND, propIndex: int32, P3: PINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc.} +when winimCpu32: + type + PTBBUTTON* = ptr TBBUTTON + LPTBBUTTON* = ptr TBBUTTON + proc FlatSB_GetScrollPropPtr*(P1: HWND, propIndex: int32, P3: LPINT): WINBOOL {.winapi, stdcall, dynlib: "comctl32", importc: "FlatSB_GetScrollProp".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/commdlg.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/commdlg.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,728 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import winuser +import objbase +import commctrl +#include +type + LPOFNHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + OPENFILENAME_NT4A* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + lpstrFilter*: LPCSTR + lpstrCustomFilter*: LPSTR + nMaxCustFilter*: DWORD + nFilterIndex*: DWORD + lpstrFile*: LPSTR + nMaxFile*: DWORD + lpstrFileTitle*: LPSTR + nMaxFileTitle*: DWORD + lpstrInitialDir*: LPCSTR + lpstrTitle*: LPCSTR + Flags*: DWORD + nFileOffset*: WORD + nFileExtension*: WORD + lpstrDefExt*: LPCSTR + lCustData*: LPARAM + lpfnHook*: LPOFNHOOKPROC + lpTemplateName*: LPCSTR + LPOPENFILENAME_NT4A* = ptr OPENFILENAME_NT4A + OPENFILENAME_NT4W* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + lpstrFilter*: LPCWSTR + lpstrCustomFilter*: LPWSTR + nMaxCustFilter*: DWORD + nFilterIndex*: DWORD + lpstrFile*: LPWSTR + nMaxFile*: DWORD + lpstrFileTitle*: LPWSTR + nMaxFileTitle*: DWORD + lpstrInitialDir*: LPCWSTR + lpstrTitle*: LPCWSTR + Flags*: DWORD + nFileOffset*: WORD + nFileExtension*: WORD + lpstrDefExt*: LPCWSTR + lCustData*: LPARAM + lpfnHook*: LPOFNHOOKPROC + lpTemplateName*: LPCWSTR + LPOPENFILENAME_NT4W* = ptr OPENFILENAME_NT4W + OPENFILENAMEA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + lpstrFilter*: LPCSTR + lpstrCustomFilter*: LPSTR + nMaxCustFilter*: DWORD + nFilterIndex*: DWORD + lpstrFile*: LPSTR + nMaxFile*: DWORD + lpstrFileTitle*: LPSTR + nMaxFileTitle*: DWORD + lpstrInitialDir*: LPCSTR + lpstrTitle*: LPCSTR + Flags*: DWORD + nFileOffset*: WORD + nFileExtension*: WORD + lpstrDefExt*: LPCSTR + lCustData*: LPARAM + lpfnHook*: LPOFNHOOKPROC + lpTemplateName*: LPCSTR + pvReserved*: pointer + dwReserved*: DWORD + FlagsEx*: DWORD + LPOPENFILENAMEA* = ptr OPENFILENAMEA + OPENFILENAMEW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + lpstrFilter*: LPCWSTR + lpstrCustomFilter*: LPWSTR + nMaxCustFilter*: DWORD + nFilterIndex*: DWORD + lpstrFile*: LPWSTR + nMaxFile*: DWORD + lpstrFileTitle*: LPWSTR + nMaxFileTitle*: DWORD + lpstrInitialDir*: LPCWSTR + lpstrTitle*: LPCWSTR + Flags*: DWORD + nFileOffset*: WORD + nFileExtension*: WORD + lpstrDefExt*: LPCWSTR + lCustData*: LPARAM + lpfnHook*: LPOFNHOOKPROC + lpTemplateName*: LPCWSTR + pvReserved*: pointer + dwReserved*: DWORD + FlagsEx*: DWORD + LPOPENFILENAMEW* = ptr OPENFILENAMEW + OFNOTIFYA* {.pure.} = object + hdr*: NMHDR + lpOFN*: LPOPENFILENAMEA + pszFile*: LPSTR + LPOFNOTIFYA* = ptr OFNOTIFYA + OFNOTIFYW* {.pure.} = object + hdr*: NMHDR + lpOFN*: LPOPENFILENAMEW + pszFile*: LPWSTR + LPOFNOTIFYW* = ptr OFNOTIFYW + OFNOTIFYEXA* {.pure.} = object + hdr*: NMHDR + lpOFN*: LPOPENFILENAMEA + psf*: LPVOID + pidl*: LPVOID + LPOFNOTIFYEXA* = ptr OFNOTIFYEXA + OFNOTIFYEXW* {.pure.} = object + hdr*: NMHDR + lpOFN*: LPOPENFILENAMEW + psf*: LPVOID + pidl*: LPVOID + LPOFNOTIFYEXW* = ptr OFNOTIFYEXW + LPCCHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + TCHOOSECOLORA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HWND + rgbResult*: COLORREF + lpCustColors*: ptr COLORREF + Flags*: DWORD + lCustData*: LPARAM + lpfnHook*: LPCCHOOKPROC + lpTemplateName*: LPCSTR + LPCHOOSECOLORA* = ptr TCHOOSECOLORA + TCHOOSECOLORW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HWND + rgbResult*: COLORREF + lpCustColors*: ptr COLORREF + Flags*: DWORD + lCustData*: LPARAM + lpfnHook*: LPCCHOOKPROC + lpTemplateName*: LPCWSTR + LPCHOOSECOLORW* = ptr TCHOOSECOLORW + LPFRHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + FINDREPLACEA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + Flags*: DWORD + lpstrFindWhat*: LPSTR + lpstrReplaceWith*: LPSTR + wFindWhatLen*: WORD + wReplaceWithLen*: WORD + lCustData*: LPARAM + lpfnHook*: LPFRHOOKPROC + lpTemplateName*: LPCSTR + LPFINDREPLACEA* = ptr FINDREPLACEA + FINDREPLACEW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hInstance*: HINSTANCE + Flags*: DWORD + lpstrFindWhat*: LPWSTR + lpstrReplaceWith*: LPWSTR + wFindWhatLen*: WORD + wReplaceWithLen*: WORD + lCustData*: LPARAM + lpfnHook*: LPFRHOOKPROC + lpTemplateName*: LPCWSTR + LPFINDREPLACEW* = ptr FINDREPLACEW + LPCFHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + TCHOOSEFONTA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDC*: HDC + lpLogFont*: LPLOGFONTA + iPointSize*: INT + Flags*: DWORD + rgbColors*: COLORREF + lCustData*: LPARAM + lpfnHook*: LPCFHOOKPROC + lpTemplateName*: LPCSTR + hInstance*: HINSTANCE + lpszStyle*: LPSTR + nFontType*: WORD + MISSING_ALIGNMENT*: WORD + nSizeMin*: INT + nSizeMax*: INT + LPCHOOSEFONTA* = ptr TCHOOSEFONTA + TCHOOSEFONTW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDC*: HDC + lpLogFont*: LPLOGFONTW + iPointSize*: INT + Flags*: DWORD + rgbColors*: COLORREF + lCustData*: LPARAM + lpfnHook*: LPCFHOOKPROC + lpTemplateName*: LPCWSTR + hInstance*: HINSTANCE + lpszStyle*: LPWSTR + nFontType*: WORD + MISSING_ALIGNMENT*: WORD + nSizeMin*: INT + nSizeMax*: INT + LPCHOOSEFONTW* = ptr TCHOOSEFONTW + LPPRINTHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + LPSETUPHOOKPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} +when winimCpu64: + type + TPRINTDLGA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + nFromPage*: WORD + nToPage*: WORD + nMinPage*: WORD + nMaxPage*: WORD + nCopies*: WORD + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPrintHook*: LPPRINTHOOKPROC + lpfnSetupHook*: LPSETUPHOOKPROC + lpPrintTemplateName*: LPCSTR + lpSetupTemplateName*: LPCSTR + hPrintTemplate*: HGLOBAL + hSetupTemplate*: HGLOBAL +when winimCpu32: + type + TPRINTDLGA* {.pure, packed.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + nFromPage*: WORD + nToPage*: WORD + nMinPage*: WORD + nMaxPage*: WORD + nCopies*: WORD + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPrintHook*: LPPRINTHOOKPROC + lpfnSetupHook*: LPSETUPHOOKPROC + lpPrintTemplateName*: LPCSTR + lpSetupTemplateName*: LPCSTR + hPrintTemplate*: HGLOBAL + hSetupTemplate*: HGLOBAL +type + LPPRINTDLGA* = ptr TPRINTDLGA +when winimCpu64: + type + TPRINTDLGW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + nFromPage*: WORD + nToPage*: WORD + nMinPage*: WORD + nMaxPage*: WORD + nCopies*: WORD + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPrintHook*: LPPRINTHOOKPROC + lpfnSetupHook*: LPSETUPHOOKPROC + lpPrintTemplateName*: LPCWSTR + lpSetupTemplateName*: LPCWSTR + hPrintTemplate*: HGLOBAL + hSetupTemplate*: HGLOBAL +when winimCpu32: + type + TPRINTDLGW* {.pure, packed.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + nFromPage*: WORD + nToPage*: WORD + nMinPage*: WORD + nMaxPage*: WORD + nCopies*: WORD + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPrintHook*: LPPRINTHOOKPROC + lpfnSetupHook*: LPSETUPHOOKPROC + lpPrintTemplateName*: LPCWSTR + lpSetupTemplateName*: LPCWSTR + hPrintTemplate*: HGLOBAL + hSetupTemplate*: HGLOBAL +type + LPPRINTDLGW* = ptr TPRINTDLGW + PRINTPAGERANGE* {.pure.} = object + nFromPage*: DWORD + nToPage*: DWORD + LPPRINTPAGERANGE* = ptr PRINTPAGERANGE + TPRINTDLGEXA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + Flags2*: DWORD + ExclusionFlags*: DWORD + nPageRanges*: DWORD + nMaxPageRanges*: DWORD + lpPageRanges*: LPPRINTPAGERANGE + nMinPage*: DWORD + nMaxPage*: DWORD + nCopies*: DWORD + hInstance*: HINSTANCE + lpPrintTemplateName*: LPCSTR + lpCallback*: LPUNKNOWN + nPropertyPages*: DWORD + lphPropertyPages*: ptr HPROPSHEETPAGE + nStartPage*: DWORD + dwResultAction*: DWORD + LPPRINTDLGEXA* = ptr TPRINTDLGEXA + TPRINTDLGEXW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + hDC*: HDC + Flags*: DWORD + Flags2*: DWORD + ExclusionFlags*: DWORD + nPageRanges*: DWORD + nMaxPageRanges*: DWORD + lpPageRanges*: LPPRINTPAGERANGE + nMinPage*: DWORD + nMaxPage*: DWORD + nCopies*: DWORD + hInstance*: HINSTANCE + lpPrintTemplateName*: LPCWSTR + lpCallback*: LPUNKNOWN + nPropertyPages*: DWORD + lphPropertyPages*: ptr HPROPSHEETPAGE + nStartPage*: DWORD + dwResultAction*: DWORD + LPPRINTDLGEXW* = ptr TPRINTDLGEXW + DEVNAMES* {.pure.} = object + wDriverOffset*: WORD + wDeviceOffset*: WORD + wOutputOffset*: WORD + wDefault*: WORD + LPDEVNAMES* = ptr DEVNAMES + LPPAGESETUPHOOK* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + LPPAGEPAINTHOOK* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT_PTR {.stdcall.} + TPAGESETUPDLGA* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + Flags*: DWORD + ptPaperSize*: POINT + rtMinMargin*: RECT + rtMargin*: RECT + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPageSetupHook*: LPPAGESETUPHOOK + lpfnPagePaintHook*: LPPAGEPAINTHOOK + lpPageSetupTemplateName*: LPCSTR + hPageSetupTemplate*: HGLOBAL + LPPAGESETUPDLGA* = ptr TPAGESETUPDLGA + TPAGESETUPDLGW* {.pure.} = object + lStructSize*: DWORD + hwndOwner*: HWND + hDevMode*: HGLOBAL + hDevNames*: HGLOBAL + Flags*: DWORD + ptPaperSize*: POINT + rtMinMargin*: RECT + rtMargin*: RECT + hInstance*: HINSTANCE + lCustData*: LPARAM + lpfnPageSetupHook*: LPPAGESETUPHOOK + lpfnPagePaintHook*: LPPAGEPAINTHOOK + lpPageSetupTemplateName*: LPCWSTR + hPageSetupTemplate*: HGLOBAL + LPPAGESETUPDLGW* = ptr TPAGESETUPDLGW +const + IID_IPrintDialogCallback* = DEFINE_GUID("5852a2c3-6530-11d1-b6a3-0000f8757bf9") + IID_IPrintDialogServices* = DEFINE_GUID("509aaeda-5639-11d1-b6a1-0000f8757bf9") + OFN_READONLY* = 0x1 + OFN_OVERWRITEPROMPT* = 0x2 + OFN_HIDEREADONLY* = 0x4 + OFN_NOCHANGEDIR* = 0x8 + OFN_SHOWHELP* = 0x10 + OFN_ENABLEHOOK* = 0x20 + OFN_ENABLETEMPLATE* = 0x40 + OFN_ENABLETEMPLATEHANDLE* = 0x80 + OFN_NOVALIDATE* = 0x100 + OFN_ALLOWMULTISELECT* = 0x200 + OFN_EXTENSIONDIFFERENT* = 0x400 + OFN_PATHMUSTEXIST* = 0x800 + OFN_FILEMUSTEXIST* = 0x1000 + OFN_CREATEPROMPT* = 0x2000 + OFN_SHAREAWARE* = 0x4000 + OFN_NOREADONLYRETURN* = 0x8000 + OFN_NOTESTFILECREATE* = 0x10000 + OFN_NONETWORKBUTTON* = 0x20000 + OFN_NOLONGNAMES* = 0x40000 + OFN_EXPLORER* = 0x80000 + OFN_NODEREFERENCELINKS* = 0x100000 + OFN_LONGNAMES* = 0x200000 + OFN_ENABLEINCLUDENOTIFY* = 0x400000 + OFN_ENABLESIZING* = 0x800000 + OFN_DONTADDTORECENT* = 0x2000000 + OFN_FORCESHOWHIDDEN* = 0x10000000 + OFN_EX_NOPLACESBAR* = 0x1 + OFN_SHAREFALLTHROUGH* = 2 + OFN_SHARENOWARN* = 1 + OFN_SHAREWARN* = 0 + CDN_INITDONE* = CDN_FIRST + CDN_SELCHANGE* = CDN_FIRST-1 + CDN_FOLDERCHANGE* = CDN_FIRST-2 + CDN_SHAREVIOLATION* = CDN_FIRST-3 + CDN_HELP* = CDN_FIRST-4 + CDN_FILEOK* = CDN_FIRST-5 + CDN_TYPECHANGE* = CDN_FIRST-6 + CDN_INCLUDEITEM* = CDN_FIRST-7 + CDM_FIRST* = WM_USER+100 + CDM_LAST* = WM_USER+200 + CDM_GETSPEC* = CDM_FIRST + CDM_GETFILEPATH* = CDM_FIRST+1 + CDM_GETFOLDERPATH* = CDM_FIRST+2 + CDM_GETFOLDERIDLIST* = CDM_FIRST+3 + CDM_SETCONTROLTEXT* = CDM_FIRST+4 + CDM_HIDECONTROL* = CDM_FIRST+5 + CDM_SETDEFEXT* = CDM_FIRST+6 + CC_RGBINIT* = 0x1 + CC_FULLOPEN* = 0x2 + CC_PREVENTFULLOPEN* = 0x4 + CC_SHOWHELP* = 0x8 + CC_ENABLEHOOK* = 0x10 + CC_ENABLETEMPLATE* = 0x20 + CC_ENABLETEMPLATEHANDLE* = 0x40 + CC_SOLIDCOLOR* = 0x80 + CC_ANYCOLOR* = 0x100 + FR_DOWN* = 0x1 + FR_WHOLEWORD* = 0x2 + FR_MATCHCASE* = 0x4 + FR_FINDNEXT* = 0x8 + FR_REPLACE* = 0x10 + FR_REPLACEALL* = 0x20 + FR_DIALOGTERM* = 0x40 + FR_SHOWHELP* = 0x80 + FR_ENABLEHOOK* = 0x100 + FR_ENABLETEMPLATE* = 0x200 + FR_NOUPDOWN* = 0x400 + FR_NOMATCHCASE* = 0x800 + FR_NOWHOLEWORD* = 0x1000 + FR_ENABLETEMPLATEHANDLE* = 0x2000 + FR_HIDEUPDOWN* = 0x4000 + FR_HIDEMATCHCASE* = 0x8000 + FR_HIDEWHOLEWORD* = 0x10000 + FR_RAW* = 0x20000 + FR_MATCHDIAC* = 0x20000000 + FR_MATCHKASHIDA* = 0x40000000 + FR_MATCHALEFHAMZA* = 0x80000000'i32 + CF_SCREENFONTS* = 0x1 + CF_PRINTERFONTS* = 0x2 + CF_BOTH* = CF_SCREENFONTS or CF_PRINTERFONTS + CF_SHOWHELP* = 0x4 + CF_ENABLEHOOK* = 0x8 + CF_ENABLETEMPLATE* = 0x10 + CF_ENABLETEMPLATEHANDLE* = 0x20 + CF_INITTOLOGFONTSTRUCT* = 0x40 + CF_USESTYLE* = 0x80 + CF_EFFECTS* = 0x100 + CF_APPLY* = 0x200 + CF_ANSIONLY* = 0x400 + CF_SCRIPTSONLY* = CF_ANSIONLY + CF_NOVECTORFONTS* = 0x800 + CF_NOOEMFONTS* = CF_NOVECTORFONTS + CF_NOSIMULATIONS* = 0x1000 + CF_LIMITSIZE* = 0x2000 + CF_FIXEDPITCHONLY* = 0x4000 + CF_WYSIWYG* = 0x8000 + CF_FORCEFONTEXIST* = 0x10000 + CF_SCALABLEONLY* = 0x20000 + CF_TTONLY* = 0x40000 + CF_NOFACESEL* = 0x80000 + CF_NOSTYLESEL* = 0x100000 + CF_NOSIZESEL* = 0x200000 + CF_SELECTSCRIPT* = 0x400000 + CF_NOSCRIPTSEL* = 0x800000 + CF_NOVERTFONTS* = 0x1000000 + CF_INACTIVEFONTS* = 0x02000000 + SIMULATED_FONTTYPE* = 0x8000 + PRINTER_FONTTYPE* = 0x4000 + SCREEN_FONTTYPE* = 0x2000 + BOLD_FONTTYPE* = 0x100 + ITALIC_FONTTYPE* = 0x200 + REGULAR_FONTTYPE* = 0x400 + PS_OPENTYPE_FONTTYPE* = 0x10000 + TT_OPENTYPE_FONTTYPE* = 0x20000 + TYPE1_FONTTYPE* = 0x40000 + SYMBOL_FONTTYPE* = 0x80000 + WM_CHOOSEFONT_GETLOGFONT* = WM_USER+1 + WM_CHOOSEFONT_SETLOGFONT* = WM_USER+101 + WM_CHOOSEFONT_SETFLAGS* = WM_USER+102 + LBSELCHSTRINGA* = "commdlg_LBSelChangedNotify" + SHAREVISTRINGA* = "commdlg_ShareViolation" + FILEOKSTRINGA* = "commdlg_FileNameOK" + COLOROKSTRINGA* = "commdlg_ColorOK" + SETRGBSTRINGA* = "commdlg_SetRGBColor" + HELPMSGSTRINGA* = "commdlg_help" + FINDMSGSTRINGA* = "commdlg_FindReplace" + LBSELCHSTRINGW* = "commdlg_LBSelChangedNotify" + SHAREVISTRINGW* = "commdlg_ShareViolation" + FILEOKSTRINGW* = "commdlg_FileNameOK" + COLOROKSTRINGW* = "commdlg_ColorOK" + SETRGBSTRINGW* = "commdlg_SetRGBColor" + HELPMSGSTRINGW* = "commdlg_help" + FINDMSGSTRINGW* = "commdlg_FindReplace" + CD_LBSELNOITEMS* = -1 + CD_LBSELCHANGE* = 0 + CD_LBSELSUB* = 1 + CD_LBSELADD* = 2 + PD_ALLPAGES* = 0x0 + PD_SELECTION* = 0x1 + PD_PAGENUMS* = 0x2 + PD_NOSELECTION* = 0x4 + PD_NOPAGENUMS* = 0x8 + PD_COLLATE* = 0x10 + PD_PRINTTOFILE* = 0x20 + PD_PRINTSETUP* = 0x40 + PD_NOWARNING* = 0x80 + PD_RETURNDC* = 0x100 + PD_RETURNIC* = 0x200 + PD_RETURNDEFAULT* = 0x400 + PD_SHOWHELP* = 0x800 + PD_ENABLEPRINTHOOK* = 0x1000 + PD_ENABLESETUPHOOK* = 0x2000 + PD_ENABLEPRINTTEMPLATE* = 0x4000 + PD_ENABLESETUPTEMPLATE* = 0x8000 + PD_ENABLEPRINTTEMPLATEHANDLE* = 0x10000 + PD_ENABLESETUPTEMPLATEHANDLE* = 0x20000 + PD_USEDEVMODECOPIES* = 0x40000 + PD_USEDEVMODECOPIESANDCOLLATE* = 0x40000 + PD_DISABLEPRINTTOFILE* = 0x80000 + PD_HIDEPRINTTOFILE* = 0x100000 + PD_NONETWORKBUTTON* = 0x200000 + PD_CURRENTPAGE* = 0x400000 + PD_NOCURRENTPAGE* = 0x800000 + PD_EXCLUSIONFLAGS* = 0x1000000 + PD_USELARGETEMPLATE* = 0x10000000 + PD_EXCL_COPIESANDCOLLATE* = DM_COPIES or DM_COLLATE + START_PAGE_GENERAL* = 0xffffffff'i32 + PD_RESULT_CANCEL* = 0 + PD_RESULT_PRINT* = 1 + PD_RESULT_APPLY* = 2 + DN_DEFAULTPRN* = 0x1 + WM_PSD_PAGESETUPDLG* = WM_USER + WM_PSD_FULLPAGERECT* = WM_USER+1 + WM_PSD_MINMARGINRECT* = WM_USER+2 + WM_PSD_MARGINRECT* = WM_USER+3 + WM_PSD_GREEKTEXTRECT* = WM_USER+4 + WM_PSD_ENVSTAMPRECT* = WM_USER+5 + WM_PSD_YAFULLPAGERECT* = WM_USER+6 + PSD_DEFAULTMINMARGINS* = 0x0 + PSD_INWININIINTLMEASURE* = 0x0 + PSD_MINMARGINS* = 0x1 + PSD_MARGINS* = 0x2 + PSD_INTHOUSANDTHSOFINCHES* = 0x4 + PSD_INHUNDREDTHSOFMILLIMETERS* = 0x8 + PSD_DISABLEMARGINS* = 0x10 + PSD_DISABLEPRINTER* = 0x20 + PSD_NOWARNING* = 0x80 + PSD_DISABLEORIENTATION* = 0x100 + PSD_RETURNDEFAULT* = 0x400 + PSD_DISABLEPAPER* = 0x200 + PSD_SHOWHELP* = 0x800 + PSD_ENABLEPAGESETUPHOOK* = 0x2000 + PSD_ENABLEPAGESETUPTEMPLATE* = 0x8000 + PSD_ENABLEPAGESETUPTEMPLATEHANDLE* = 0x20000 + PSD_ENABLEPAGEPAINTHOOK* = 0x40000 + PSD_DISABLEPAGEPAINTING* = 0x80000 + PSD_NONETWORKBUTTON* = 0x200000 + OPENFILENAME_SIZE_VERSION_400A* = 0x00000088 + OPENFILENAME_SIZE_VERSION_400W* = 0x00000088 +type + IPrintDialogCallback* {.pure.} = object + lpVtbl*: ptr IPrintDialogCallbackVtbl + IPrintDialogCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitDone*: proc(self: ptr IPrintDialogCallback): HRESULT {.stdcall.} + SelectionChange*: proc(self: ptr IPrintDialogCallback): HRESULT {.stdcall.} + HandleMessage*: proc(self: ptr IPrintDialogCallback, hDlg: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, pResult: ptr LRESULT): HRESULT {.stdcall.} + IPrintDialogServices* {.pure.} = object + lpVtbl*: ptr IPrintDialogServicesVtbl + IPrintDialogServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentDevMode*: proc(self: ptr IPrintDialogServices, pDevMode: LPDEVMODE, pcbSize: ptr UINT): HRESULT {.stdcall.} + GetCurrentPrinterName*: proc(self: ptr IPrintDialogServices, pPrinterName: LPTSTR, pcchSize: ptr UINT): HRESULT {.stdcall.} + GetCurrentPortName*: proc(self: ptr IPrintDialogServices, pPortName: LPTSTR, pcchSize: ptr UINT): HRESULT {.stdcall.} +proc GetOpenFileNameA*(P1: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc GetOpenFileNameW*(P1: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc GetSaveFileNameA*(P1: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc GetSaveFileNameW*(P1: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc GetFileTitleA*(P1: LPCSTR, P2: LPSTR, P3: WORD): int16 {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc GetFileTitleW*(P1: LPCWSTR, P2: LPWSTR, P3: WORD): int16 {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ChooseColorA*(P1: LPCHOOSECOLORA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ChooseColorW*(P1: LPCHOOSECOLORW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc FindTextA*(P1: LPFINDREPLACEA): HWND {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc FindTextW*(P1: LPFINDREPLACEW): HWND {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ReplaceTextA*(P1: LPFINDREPLACEA): HWND {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ReplaceTextW*(P1: LPFINDREPLACEW): HWND {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ChooseFontA*(P1: LPCHOOSEFONTA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc ChooseFontW*(P1: LPCHOOSEFONTW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PrintDlgA*(P1: LPPRINTDLGA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PrintDlgW*(P1: LPPRINTDLGW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PrintDlgExA*(P1: LPPRINTDLGEXA): HRESULT {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PrintDlgExW*(P1: LPPRINTDLGEXW): HRESULT {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc CommDlgExtendedError*(): DWORD {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PageSetupDlgA*(P1: LPPAGESETUPDLGA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc PageSetupDlgW*(P1: LPPAGESETUPDLGW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc.} +proc InitDone*(self: ptr IPrintDialogCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitDone(self) +proc SelectionChange*(self: ptr IPrintDialogCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectionChange(self) +proc HandleMessage*(self: ptr IPrintDialogCallback, hDlg: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, pResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleMessage(self, hDlg, uMsg, wParam, lParam, pResult) +proc GetCurrentDevMode*(self: ptr IPrintDialogServices, pDevMode: LPDEVMODE, pcbSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentDevMode(self, pDevMode, pcbSize) +proc GetCurrentPrinterName*(self: ptr IPrintDialogServices, pPrinterName: LPTSTR, pcchSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPrinterName(self, pPrinterName, pcchSize) +proc GetCurrentPortName*(self: ptr IPrintDialogServices, pPortName: LPTSTR, pcchSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPortName(self, pPortName, pcchSize) +converter winimConverterIPrintDialogCallbackToIUnknown*(x: ptr IPrintDialogCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPrintDialogServicesToIUnknown*(x: ptr IPrintDialogServices): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + OPENFILENAME_NT4* = OPENFILENAME_NT4W + LPOPENFILENAME_NT4* = LPOPENFILENAME_NT4W + OPENFILENAME* = OPENFILENAMEW + LPOPENFILENAME* = LPOPENFILENAMEW + OFNOTIFY* = OFNOTIFYW + LPOFNOTIFY* = LPOFNOTIFYW + OFNOTIFYEX* = OFNOTIFYEXW + LPOFNOTIFYEX* = LPOFNOTIFYEXW + TCHOOSECOLOR* = TCHOOSECOLORW + LPCHOOSECOLOR* = LPCHOOSECOLORW + FINDREPLACE* = FINDREPLACEW + LPFINDREPLACE* = LPFINDREPLACEW + TCHOOSEFONT* = TCHOOSEFONTW + LPCHOOSEFONT* = LPCHOOSEFONTW + TPRINTDLG* = TPRINTDLGW + LPPRINTDLG* = LPPRINTDLGW + TPRINTDLGEX* = TPRINTDLGEXW + LPPRINTDLGEX* = LPPRINTDLGEXW + TPAGESETUPDLG* = TPAGESETUPDLGW + LPPAGESETUPDLG* = LPPAGESETUPDLGW + const + OPENFILENAME_SIZE_VERSION_400* = OPENFILENAME_SIZE_VERSION_400W + LBSELCHSTRING* = LBSELCHSTRINGW + SHAREVISTRING* = SHAREVISTRINGW + FILEOKSTRING* = FILEOKSTRINGW + COLOROKSTRING* = COLOROKSTRINGW + SETRGBSTRING* = SETRGBSTRINGW + HELPMSGSTRING* = HELPMSGSTRINGW + FINDMSGSTRING* = FINDMSGSTRINGW + proc GetOpenFileName*(P1: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "GetOpenFileNameW".} + proc GetSaveFileName*(P1: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "GetSaveFileNameW".} + proc GetFileTitle*(P1: LPCWSTR, P2: LPWSTR, P3: WORD): int16 {.winapi, stdcall, dynlib: "comdlg32", importc: "GetFileTitleW".} + proc ChooseColor*(P1: LPCHOOSECOLORW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "ChooseColorW".} + proc FindText*(P1: LPFINDREPLACEW): HWND {.winapi, stdcall, dynlib: "comdlg32", importc: "FindTextW".} + proc ReplaceText*(P1: LPFINDREPLACEW): HWND {.winapi, stdcall, dynlib: "comdlg32", importc: "ReplaceTextW".} + proc ChooseFont*(P1: LPCHOOSEFONTW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "ChooseFontW".} + proc PrintDlg*(P1: LPPRINTDLGW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "PrintDlgW".} + proc PrintDlgEx*(P1: LPPRINTDLGEXW): HRESULT {.winapi, stdcall, dynlib: "comdlg32", importc: "PrintDlgExW".} + proc PageSetupDlg*(P1: LPPAGESETUPDLGW): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "PageSetupDlgW".} +when winimAnsi: + type + OPENFILENAME_NT4* = OPENFILENAME_NT4A + LPOPENFILENAME_NT4* = LPOPENFILENAME_NT4A + OPENFILENAME* = OPENFILENAMEA + LPOPENFILENAME* = LPOPENFILENAMEA + OFNOTIFY* = OFNOTIFYA + LPOFNOTIFY* = LPOFNOTIFYA + OFNOTIFYEX* = OFNOTIFYEXA + LPOFNOTIFYEX* = LPOFNOTIFYEXA + TCHOOSECOLOR* = TCHOOSECOLORA + LPCHOOSECOLOR* = LPCHOOSECOLORA + FINDREPLACE* = FINDREPLACEA + LPFINDREPLACE* = LPFINDREPLACEA + TCHOOSEFONT* = TCHOOSEFONTA + LPCHOOSEFONT* = LPCHOOSEFONTA + TPRINTDLG* = TPRINTDLGA + LPPRINTDLG* = LPPRINTDLGA + TPRINTDLGEX* = TPRINTDLGEXA + LPPRINTDLGEX* = LPPRINTDLGEXA + TPAGESETUPDLG* = TPAGESETUPDLGA + LPPAGESETUPDLG* = LPPAGESETUPDLGA + const + OPENFILENAME_SIZE_VERSION_400* = OPENFILENAME_SIZE_VERSION_400A + LBSELCHSTRING* = LBSELCHSTRINGA + SHAREVISTRING* = SHAREVISTRINGA + FILEOKSTRING* = FILEOKSTRINGA + COLOROKSTRING* = COLOROKSTRINGA + SETRGBSTRING* = SETRGBSTRINGA + HELPMSGSTRING* = HELPMSGSTRINGA + FINDMSGSTRING* = FINDMSGSTRINGA + proc GetOpenFileName*(P1: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "GetOpenFileNameA".} + proc GetSaveFileName*(P1: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "GetSaveFileNameA".} + proc GetFileTitle*(P1: LPCSTR, P2: LPSTR, P3: WORD): int16 {.winapi, stdcall, dynlib: "comdlg32", importc: "GetFileTitleA".} + proc ChooseColor*(P1: LPCHOOSECOLORA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "ChooseColorA".} + proc FindText*(P1: LPFINDREPLACEA): HWND {.winapi, stdcall, dynlib: "comdlg32", importc: "FindTextA".} + proc ReplaceText*(P1: LPFINDREPLACEA): HWND {.winapi, stdcall, dynlib: "comdlg32", importc: "ReplaceTextA".} + proc ChooseFont*(P1: LPCHOOSEFONTA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "ChooseFontA".} + proc PrintDlg*(P1: LPPRINTDLGA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "PrintDlgA".} + proc PrintDlgEx*(P1: LPPRINTDLGEXA): HRESULT {.winapi, stdcall, dynlib: "comdlg32", importc: "PrintDlgExA".} + proc PageSetupDlg*(P1: LPPAGESETUPDLGA): WINBOOL {.winapi, stdcall, dynlib: "comdlg32", importc: "PageSetupDlgA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/dde.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/dde.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,411 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +#include +#include +type + HCONVLIST* = HANDLE + HCONV* = HANDLE + HSZ* = HANDLE + HDDEDATA* = HANDLE + HSZPAIR* {.pure.} = object + hszSvc*: HSZ + hszTopic*: HSZ + PHSZPAIR* = ptr HSZPAIR + CONVCONTEXT* {.pure.} = object + cb*: UINT + wFlags*: UINT + wCountryID*: UINT + iCodePage*: int32 + dwLangID*: DWORD + dwSecurity*: DWORD + qos*: SECURITY_QUALITY_OF_SERVICE + PCONVCONTEXT* = ptr CONVCONTEXT + CONVINFO* {.pure.} = object + cb*: DWORD + hUser*: DWORD_PTR + hConvPartner*: HCONV + hszSvcPartner*: HSZ + hszServiceReq*: HSZ + hszTopic*: HSZ + hszItem*: HSZ + wFmt*: UINT + wType*: UINT + wStatus*: UINT + wConvst*: UINT + wLastError*: UINT + hConvList*: HCONVLIST + ConvCtxt*: CONVCONTEXT + hwnd*: HWND + hwndPartner*: HWND + PCONVINFO* = ptr CONVINFO + DDEML_MSG_HOOK_DATA* {.pure.} = object + uiLo*: UINT_PTR + uiHi*: UINT_PTR + cbData*: DWORD + Data*: array[8, DWORD] + PDDEML_MSG_HOOK_DATA* = ptr DDEML_MSG_HOOK_DATA + MONMSGSTRUCT* {.pure.} = object + cb*: UINT + hwndTo*: HWND + dwTime*: DWORD + hTask*: HANDLE + wMsg*: UINT + wParam*: WPARAM + lParam*: LPARAM + dmhd*: DDEML_MSG_HOOK_DATA + PMONMSGSTRUCT* = ptr MONMSGSTRUCT + MONCBSTRUCT* {.pure.} = object + cb*: UINT + dwTime*: DWORD + hTask*: HANDLE + dwRet*: DWORD + wType*: UINT + wFmt*: UINT + hConv*: HCONV + hsz1*: HSZ + hsz2*: HSZ + hData*: HDDEDATA + dwData1*: ULONG_PTR + dwData2*: ULONG_PTR + cc*: CONVCONTEXT + cbData*: DWORD + Data*: array[8, DWORD] + PMONCBSTRUCT* = ptr MONCBSTRUCT + MONHSZSTRUCTA* {.pure.} = object + cb*: UINT + fsAction*: WINBOOL + dwTime*: DWORD + hsz*: HSZ + hTask*: HANDLE + str*: array[1, CHAR] + PMONHSZSTRUCTA* = ptr MONHSZSTRUCTA + MONHSZSTRUCTW* {.pure.} = object + cb*: UINT + fsAction*: WINBOOL + dwTime*: DWORD + hsz*: HSZ + hTask*: HANDLE + str*: array[1, WCHAR] + PMONHSZSTRUCTW* = ptr MONHSZSTRUCTW + MONERRSTRUCT* {.pure.} = object + cb*: UINT + wLastError*: UINT + dwTime*: DWORD + hTask*: HANDLE + PMONERRSTRUCT* = ptr MONERRSTRUCT + MONLINKSTRUCT* {.pure.} = object + cb*: UINT + dwTime*: DWORD + hTask*: HANDLE + fEstablished*: WINBOOL + fNoData*: WINBOOL + hszSvc*: HSZ + hszTopic*: HSZ + hszItem*: HSZ + wFmt*: UINT + fServer*: WINBOOL + hConvServer*: HCONV + hConvClient*: HCONV + PMONLINKSTRUCT* = ptr MONLINKSTRUCT + MONCONVSTRUCT* {.pure.} = object + cb*: UINT + fConnect*: WINBOOL + dwTime*: DWORD + hTask*: HANDLE + hszSvc*: HSZ + hszTopic*: HSZ + hConvClient*: HCONV + hConvServer*: HCONV + PMONCONVSTRUCT* = ptr MONCONVSTRUCT +const + CDERR_DIALOGFAILURE* = 0xFFFF + CDERR_GENERALCODES* = 0x0000 + CDERR_STRUCTSIZE* = 0x0001 + CDERR_INITIALIZATION* = 0x0002 + CDERR_NOTEMPLATE* = 0x0003 + CDERR_NOHINSTANCE* = 0x0004 + CDERR_LOADSTRFAILURE* = 0x0005 + CDERR_FINDRESFAILURE* = 0x0006 + CDERR_LOADRESFAILURE* = 0x0007 + CDERR_LOCKRESFAILURE* = 0x0008 + CDERR_MEMALLOCFAILURE* = 0x0009 + CDERR_MEMLOCKFAILURE* = 0x000A + CDERR_NOHOOK* = 0x000B + CDERR_REGISTERMSGFAIL* = 0x000C + PDERR_PRINTERCODES* = 0x1000 + PDERR_SETUPFAILURE* = 0x1001 + PDERR_PARSEFAILURE* = 0x1002 + PDERR_RETDEFFAILURE* = 0x1003 + PDERR_LOADDRVFAILURE* = 0x1004 + PDERR_GETDEVMODEFAIL* = 0x1005 + PDERR_INITFAILURE* = 0x1006 + PDERR_NODEVICES* = 0x1007 + PDERR_NODEFAULTPRN* = 0x1008 + PDERR_DNDMMISMATCH* = 0x1009 + PDERR_CREATEICFAILURE* = 0x100A + PDERR_PRINTERNOTFOUND* = 0x100B + PDERR_DEFAULTDIFFERENT* = 0x100C + CFERR_CHOOSEFONTCODES* = 0x2000 + CFERR_NOFONTS* = 0x2001 + CFERR_MAXLESSTHANMIN* = 0x2002 + FNERR_FILENAMECODES* = 0x3000 + FNERR_SUBCLASSFAILURE* = 0x3001 + FNERR_INVALIDFILENAME* = 0x3002 + FNERR_BUFFERTOOSMALL* = 0x3003 + FRERR_FINDREPLACECODES* = 0x4000 + FRERR_BUFFERLENGTHZERO* = 0x4001 + CCERR_CHOOSECOLORCODES* = 0x5000 + WM_DDE_FIRST* = 0x03E0 + WM_DDE_INITIATE* = WM_DDE_FIRST + WM_DDE_TERMINATE* = WM_DDE_FIRST+1 + WM_DDE_ADVISE* = WM_DDE_FIRST+2 + WM_DDE_UNADVISE* = WM_DDE_FIRST+3 + WM_DDE_ACK* = WM_DDE_FIRST+4 + WM_DDE_DATA* = WM_DDE_FIRST+5 + WM_DDE_REQUEST* = WM_DDE_FIRST+6 + WM_DDE_POKE* = WM_DDE_FIRST+7 + WM_DDE_EXECUTE* = WM_DDE_FIRST+8 + WM_DDE_LAST* = WM_DDE_FIRST+8 + XST_NULL* = 0 + XST_INCOMPLETE* = 1 + XST_CONNECTED* = 2 + XST_INIT1* = 3 + XST_INIT2* = 4 + XST_REQSENT* = 5 + XST_DATARCVD* = 6 + XST_POKESENT* = 7 + XST_POKEACKRCVD* = 8 + XST_EXECSENT* = 9 + XST_EXECACKRCVD* = 10 + XST_ADVSENT* = 11 + XST_UNADVSENT* = 12 + XST_ADVACKRCVD* = 13 + XST_UNADVACKRCVD* = 14 + XST_ADVDATASENT* = 15 + XST_ADVDATAACKRCVD* = 16 + CADV_LATEACK* = 0xFFFF + ST_CONNECTED* = 0x0001 + ST_ADVISE* = 0x0002 + ST_ISLOCAL* = 0x0004 + ST_BLOCKED* = 0x0008 + ST_CLIENT* = 0x0010 + ST_TERMINATED* = 0x0020 + ST_INLIST* = 0x0040 + ST_BLOCKNEXT* = 0x0080 + ST_ISSELF* = 0x0100 + DDE_FACK* = 0x8000 + DDE_FBUSY* = 0x4000 + DDE_FDEFERUPD* = 0x4000 + DDE_FACKREQ* = 0x8000 + DDE_FRELEASE* = 0x2000 + DDE_FREQUESTED* = 0x1000 + DDE_FAPPSTATUS* = 0x00ff + DDE_FNOTPROCESSED* = 0x0000 + DDE_FACKRESERVED* = not (DDE_FACK or DDE_FBUSY or DDE_FAPPSTATUS) + DDE_FADVRESERVED* = not (DDE_FACKREQ or DDE_FDEFERUPD) + DDE_FDATRESERVED* = not (DDE_FACKREQ or DDE_FRELEASE or DDE_FREQUESTED) + DDE_FPOKRESERVED* = not (DDE_FRELEASE) + MSGF_DDEMGR* = 0x8001 + CP_WINANSI* = 1004 + CP_WINUNICODE* = 1200 + XTYPF_NOBLOCK* = 0x0002 + XTYPF_NODATA* = 0x0004 + XTYPF_ACKREQ* = 0x0008 + XCLASS_MASK* = 0xFC00 + XCLASS_BOOL* = 0x1000 + XCLASS_DATA* = 0x2000 + XCLASS_FLAGS* = 0x4000 + XCLASS_NOTIFICATION* = 0x8000 + XTYP_ERROR* = 0x0000 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + XTYP_ADVDATA* = 0x0010 or XCLASS_FLAGS + XTYP_ADVREQ* = 0x0020 or XCLASS_DATA or XTYPF_NOBLOCK + XTYP_ADVSTART* = 0x0030 or XCLASS_BOOL + XTYP_ADVSTOP* = 0x0040 or XCLASS_NOTIFICATION + XTYP_EXECUTE* = 0x0050 or XCLASS_FLAGS + XTYP_CONNECT* = 0x0060 or XCLASS_BOOL or XTYPF_NOBLOCK + XTYP_CONNECT_CONFIRM* = 0x0070 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + XTYP_XACT_COMPLETE* = 0x0080 or XCLASS_NOTIFICATION + XTYP_POKE* = 0x0090 or XCLASS_FLAGS + XTYP_REGISTER* = 0x00A0 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + XTYP_REQUEST* = 0x00B0 or XCLASS_DATA + XTYP_DISCONNECT* = 0x00C0 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + XTYP_UNREGISTER* = 0x00D0 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + XTYP_WILDCONNECT* = 0x00E0 or XCLASS_DATA or XTYPF_NOBLOCK + XTYP_MASK* = 0x00F0 + XTYP_SHIFT* = 4 + TIMEOUT_ASYNC* = 0xFFFFFFFF'i32 + QID_SYNC* = 0xFFFFFFFF'i32 + SZDDESYS_TOPIC* = "System" + SZDDESYS_ITEM_TOPICS* = "Topics" + SZDDESYS_ITEM_SYSITEMS* = "SysItems" + SZDDESYS_ITEM_RTNMSG* = "ReturnMessage" + SZDDESYS_ITEM_STATUS* = "Status" + SZDDESYS_ITEM_FORMATS* = "Formats" + SZDDESYS_ITEM_HELP* = "Help" + SZDDE_ITEM_ITEMLIST* = "TopicItemList" + CBR_BLOCK* = HDDEDATA(-1) + CBF_FAIL_SELFCONNECTIONS* = 0x00001000 + CBF_FAIL_CONNECTIONS* = 0x00002000 + CBF_FAIL_ADVISES* = 0x00004000 + CBF_FAIL_EXECUTES* = 0x00008000 + CBF_FAIL_POKES* = 0x00010000 + CBF_FAIL_REQUESTS* = 0x00020000 + CBF_FAIL_ALLSVRXACTIONS* = 0x0003f000 + CBF_SKIP_CONNECT_CONFIRMS* = 0x00040000 + CBF_SKIP_REGISTRATIONS* = 0x00080000 + CBF_SKIP_UNREGISTRATIONS* = 0x00100000 + CBF_SKIP_DISCONNECTS* = 0x00200000 + CBF_SKIP_ALLNOTIFICATIONS* = 0x003c0000 + APPCMD_CLIENTONLY* = 0x00000010 + APPCMD_FILTERINITS* = 0x00000020 + APPCMD_MASK* = 0x00000FF0 + APPCLASS_STANDARD* = 0x00000000 + APPCLASS_MASK* = 0x0000000F + EC_ENABLEALL* = 0 + EC_ENABLEONE* = ST_BLOCKNEXT + EC_DISABLE* = ST_BLOCKED + EC_QUERYWAITING* = 2 + DNS_REGISTER* = 0x0001 + DNS_UNREGISTER* = 0x0002 + DNS_FILTERON* = 0x0004 + DNS_FILTEROFF* = 0x0008 + HDATA_APPOWNED* = 0x0001 + DMLERR_NO_ERROR* = 0 + DMLERR_FIRST* = 0x4000 + DMLERR_ADVACKTIMEOUT* = 0x4000 + DMLERR_BUSY* = 0x4001 + DMLERR_DATAACKTIMEOUT* = 0x4002 + DMLERR_DLL_NOT_INITIALIZED* = 0x4003 + DMLERR_DLL_USAGE* = 0x4004 + DMLERR_EXECACKTIMEOUT* = 0x4005 + DMLERR_INVALIDPARAMETER* = 0x4006 + DMLERR_LOW_MEMORY* = 0x4007 + DMLERR_MEMORY_ERROR* = 0x4008 + DMLERR_NOTPROCESSED* = 0x4009 + DMLERR_NO_CONV_ESTABLISHED* = 0x400a + DMLERR_POKEACKTIMEOUT* = 0x400b + DMLERR_POSTMSG_FAILED* = 0x400c + DMLERR_REENTRANCY* = 0x400d + DMLERR_SERVER_DIED* = 0x400e + DMLERR_SYS_ERROR* = 0x400f + DMLERR_UNADVACKTIMEOUT* = 0x4010 + DMLERR_UNFOUND_QUEUE_ID* = 0x4011 + DMLERR_LAST* = 0x4011 + MH_CREATE* = 1 + MH_KEEP* = 2 + MH_DELETE* = 3 + MH_CLEANUP* = 4 + MAX_MONITORS* = 4 + APPCLASS_MONITOR* = 0x00000001 + XTYP_MONITOR* = 0x00F0 or XCLASS_NOTIFICATION or XTYPF_NOBLOCK + MF_HSZ_INFO* = 0x01000000 + MF_SENDMSGS* = 0x02000000 + MF_POSTMSGS* = 0x04000000 + MF_CALLBACKS* = 0x08000000 + MF_ERRORS* = 0x10000000 + MF_LINKS* = 0x20000000 + MF_CONV* = 0x40000000 + MF_MASK* = 0xFF000000'i32 +type + FNCALLBACK* = proc (wType: UINT, wFmt: UINT, hConv: HCONV, hsz1: HSZ, hsz2: HSZ, hData: HDDEDATA, dwData1: ULONG_PTR, dwData2: ULONG_PTR): HDDEDATA {.stdcall.} + PFNCALLBACK* = proc (wType: UINT, wFmt: UINT, hConv: HCONV, hsz1: HSZ, hsz2: HSZ, hData: HDDEDATA, dwData1: ULONG_PTR, dwData2: ULONG_PTR): HDDEDATA {.stdcall.} + DDEACK* {.pure.} = object + bAppReturnCode* {.bitsize:8.}: uint16 + reserved* {.bitsize:6.}: uint16 + fBusy* {.bitsize:1.}: uint16 + fAck* {.bitsize:1.}: uint16 + DDEADVISE* {.pure.} = object + reserved* {.bitsize:14.}: uint16 + fDeferUpd* {.bitsize:1.}: uint16 + fAckReq* {.bitsize:1.}: uint16 + cfFormat*: int16 + DDEDATA* {.pure.} = object + unused* {.bitsize:12.}: uint16 + fResponse* {.bitsize:1.}: uint16 + fRelease* {.bitsize:1.}: uint16 + reserved* {.bitsize:1.}: uint16 + fAckReq* {.bitsize:1.}: uint16 + cfFormat*: int16 + Value*: array[1, BYTE] + DDEPOKE* {.pure.} = object + unused* {.bitsize:13.}: uint16 + fRelease* {.bitsize:1.}: uint16 + fReserved* {.bitsize:2.}: uint16 + cfFormat*: int16 + Value*: array[1, BYTE] + DDELN* {.pure.} = object + unused* {.bitsize:13.}: uint16 + fRelease* {.bitsize:1.}: uint16 + fDeferUpd* {.bitsize:1.}: uint16 + fAckReq* {.bitsize:1.}: uint16 + cfFormat*: int16 + DDEUP* {.pure.} = object + unused* {.bitsize:12.}: uint16 + fAck* {.bitsize:1.}: uint16 + fRelease* {.bitsize:1.}: uint16 + fReserved* {.bitsize:1.}: uint16 + fAckReq* {.bitsize:1.}: uint16 + cfFormat*: int16 + rgb*: array[1, BYTE] +proc DdeSetQualityOfService*(hwndClient: HWND, pqosNew: ptr SECURITY_QUALITY_OF_SERVICE, pqosPrev: PSECURITY_QUALITY_OF_SERVICE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ImpersonateDdeClientWindow*(hWndClient: HWND, hWndServer: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PackDDElParam*(msg: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR): LPARAM {.winapi, stdcall, dynlib: "user32", importc.} +proc UnpackDDElParam*(msg: UINT, lParam: LPARAM, puiLo: PUINT_PTR, puiHi: PUINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc FreeDDElParam*(msg: UINT, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ReuseDDElParam*(lParam: LPARAM, msgIn: UINT, msgOut: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR): LPARAM {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeInitializeA*(pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeInitializeW*(pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeUninitialize*(idInst: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeConnectList*(idInst: DWORD, hszService: HSZ, hszTopic: HSZ, hConvList: HCONVLIST, pCC: PCONVCONTEXT): HCONVLIST {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeQueryNextServer*(hConvList: HCONVLIST, hConvPrev: HCONV): HCONV {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeDisconnectList*(hConvList: HCONVLIST): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeConnect*(idInst: DWORD, hszService: HSZ, hszTopic: HSZ, pCC: PCONVCONTEXT): HCONV {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeDisconnect*(hConv: HCONV): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeReconnect*(hConv: HCONV): HCONV {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeQueryConvInfo*(hConv: HCONV, idTransaction: DWORD, pConvInfo: PCONVINFO): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeSetUserHandle*(hConv: HCONV, id: DWORD, hUser: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeAbandonTransaction*(idInst: DWORD, hConv: HCONV, idTransaction: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdePostAdvise*(idInst: DWORD, hszTopic: HSZ, hszItem: HSZ): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeEnableCallback*(idInst: DWORD, hConv: HCONV, wCmd: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeImpersonateClient*(hConv: HCONV): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeNameService*(idInst: DWORD, hsz1: HSZ, hsz2: HSZ, afCmd: UINT): HDDEDATA {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeClientTransaction*(pData: LPBYTE, cbData: DWORD, hConv: HCONV, hszItem: HSZ, wFmt: UINT, wType: UINT, dwTimeout: DWORD, pdwResult: LPDWORD): HDDEDATA {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeCreateDataHandle*(idInst: DWORD, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD, hszItem: HSZ, wFmt: UINT, afCmd: UINT): HDDEDATA {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeAddData*(hData: HDDEDATA, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD): HDDEDATA {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeGetData*(hData: HDDEDATA, pDst: LPBYTE, cbMax: DWORD, cbOff: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeAccessData*(hData: HDDEDATA, pcbDataSize: LPDWORD): LPBYTE {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeUnaccessData*(hData: HDDEDATA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeFreeDataHandle*(hData: HDDEDATA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeGetLastError*(idInst: DWORD): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeCreateStringHandleA*(idInst: DWORD, psz: LPCSTR, iCodePage: int32): HSZ {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeCreateStringHandleW*(idInst: DWORD, psz: LPCWSTR, iCodePage: int32): HSZ {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeQueryStringA*(idInst: DWORD, hsz: HSZ, psz: LPSTR, cchMax: DWORD, iCodePage: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeQueryStringW*(idInst: DWORD, hsz: HSZ, psz: LPWSTR, cchMax: DWORD, iCodePage: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeFreeStringHandle*(idInst: DWORD, hsz: HSZ): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeKeepStringHandle*(idInst: DWORD, hsz: HSZ): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DdeCmpStringHandles*(hsz1: HSZ, hsz2: HSZ): int32 {.winapi, stdcall, dynlib: "user32", importc.} +when winimUnicode: + type + MONHSZSTRUCT* = MONHSZSTRUCTW + PMONHSZSTRUCT* = PMONHSZSTRUCTW + const + CP_WINNEUTRAL* = CP_WINUNICODE + proc DdeInitialize*(pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD): UINT {.winapi, stdcall, dynlib: "user32", importc: "DdeInitializeW".} + proc DdeCreateStringHandle*(idInst: DWORD, psz: LPCWSTR, iCodePage: int32): HSZ {.winapi, stdcall, dynlib: "user32", importc: "DdeCreateStringHandleW".} + proc DdeQueryString*(idInst: DWORD, hsz: HSZ, psz: LPWSTR, cchMax: DWORD, iCodePage: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "DdeQueryStringW".} +when winimAnsi: + type + MONHSZSTRUCT* = MONHSZSTRUCTA + PMONHSZSTRUCT* = PMONHSZSTRUCTA + const + CP_WINNEUTRAL* = CP_WINANSI + proc DdeInitialize*(pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD): UINT {.winapi, stdcall, dynlib: "user32", importc: "DdeInitializeA".} + proc DdeCreateStringHandle*(idInst: DWORD, psz: LPCSTR, iCodePage: int32): HSZ {.winapi, stdcall, dynlib: "user32", importc: "DdeCreateStringHandleA".} + proc DdeQueryString*(idInst: DWORD, hsz: HSZ, psz: LPSTR, cchMax: DWORD, iCodePage: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "DdeQueryStringA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/dhcpcsdk.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/dhcpcsdk.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,112 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + DHCPAPI_PARAMS* {.pure.} = object + Flags*: ULONG + OptionId*: ULONG + IsVendor*: WINBOOL + Data*: LPBYTE + nBytesData*: DWORD + PDHCPAPI_PARAMS* = ptr DHCPAPI_PARAMS + LPDHCPAPI_PARAMS* = ptr DHCPAPI_PARAMS + DHCPCAPI_PARAMS* = DHCPAPI_PARAMS + PDHCPCAPI_PARAMS* = ptr DHCPAPI_PARAMS + LPDHCPCAPI_PARAMS* = ptr DHCPAPI_PARAMS + DHCPCAPI_PARAMS_ARRAY* {.pure.} = object + nParams*: ULONG + Params*: LPDHCPCAPI_PARAMS + PDHCPCAPI_PARAMS_ARRAY* = ptr DHCPCAPI_PARAMS_ARRAY + LPDHCPCAPI_PARAMS_ARRAY* = ptr DHCPCAPI_PARAMS_ARRAY + DHCPCAPI_CLASSID* {.pure.} = object + Flags*: ULONG + Data*: LPBYTE + nBytesData*: ULONG + PDHCPCAPI_CLASSID* = ptr DHCPCAPI_CLASSID + LPDHCPCAPI_CLASSID* = ptr DHCPCAPI_CLASSID +const + OPTION_PAD* = 0 + OPTION_SUBNET_MASK* = 1 + OPTION_TIME_OFFSET* = 2 + OPTION_ROUTER_ADDRESS* = 3 + OPTION_TIME_SERVERS* = 4 + OPTION_IEN116_NAME_SERVERS* = 5 + OPTION_DOMAIN_NAME_SERVERS* = 6 + OPTION_LOG_SERVERS* = 7 + OPTION_COOKIE_SERVERS* = 8 + OPTION_LPR_SERVERS* = 9 + OPTION_IMPRESS_SERVERS* = 10 + OPTION_RLP_SERVERS* = 11 + OPTION_HOST_NAME* = 12 + OPTION_BOOT_FILE_SIZE* = 13 + OPTION_MERIT_DUMP_FILE* = 14 + OPTION_DOMAIN_NAME* = 15 + OPTION_SWAP_SERVER* = 16 + OPTION_ROOT_DISK* = 17 + OPTION_EXTENSIONS_PATH* = 18 + OPTION_BE_A_ROUTER* = 19 + OPTION_NON_LOCAL_SOURCE_ROUTING* = 20 + OPTION_POLICY_FILTER_FOR_NLSR* = 21 + OPTION_MAX_REASSEMBLY_SIZE* = 22 + OPTION_DEFAULT_TTL* = 23 + OPTION_PMTU_AGING_TIMEOUT* = 24 + OPTION_PMTU_PLATEAU_TABLE* = 25 + OPTION_MTU* = 26 + OPTION_ALL_SUBNETS_MTU* = 27 + OPTION_BROADCAST_ADDRESS* = 28 + OPTION_PERFORM_MASK_DISCOVERY* = 29 + OPTION_BE_A_MASK_SUPPLIER* = 30 + OPTION_PERFORM_ROUTER_DISCOVERY* = 31 + OPTION_ROUTER_SOLICITATION_ADDR* = 32 + OPTION_STATIC_ROUTES* = 33 + OPTION_TRAILERS* = 34 + OPTION_ARP_CACHE_TIMEOUT* = 35 + OPTION_ETHERNET_ENCAPSULATION* = 36 + OPTION_TTL* = 37 + OPTION_KEEP_ALIVE_INTERVAL* = 38 + OPTION_KEEP_ALIVE_DATA_SIZE* = 39 + OPTION_NETWORK_INFO_SERVICE_DOM* = 40 + OPTION_NETWORK_INFO_SERVERS* = 41 + OPTION_NETWORK_TIME_SERVERS* = 42 + OPTION_VENDOR_SPEC_INFO* = 43 + OPTION_NETBIOS_NAME_SERVER* = 44 + OPTION_NETBIOS_DATAGRAM_SERVER* = 45 + OPTION_NETBIOS_NODE_TYPE* = 46 + OPTION_NETBIOS_SCOPE_OPTION* = 47 + OPTION_XWINDOW_FONT_SERVER* = 48 + OPTION_XWINDOW_DISPLAY_MANAGER* = 49 + OPTION_REQUESTED_ADDRESS* = 50 + OPTION_LEASE_TIME* = 51 + OPTION_OK_TO_OVERLAY* = 52 + OPTION_MESSAGE_TYPE* = 53 + OPTION_SERVER_IDENTIFIER* = 54 + OPTION_PARAMETER_REQUEST_LIST* = 55 + OPTION_MESSAGE* = 56 + OPTION_MESSAGE_LENGTH* = 57 + OPTION_RENEWAL_TIME* = 58 + OPTION_REBIND_TIME* = 59 + OPTION_CLIENT_CLASS_INFO* = 60 + OPTION_CLIENT_ID* = 61 + OPTION_TFTP_SERVER_NAME* = 66 + OPTION_BOOTFILE_NAME* = 67 + OPTION_END* = 255 + DHCPCAPI_REQUEST_PERSISTENT* = 0x01 + DHCPCAPI_REQUEST_SYNCHRONOUS* = 0x02 + DHCPCAPI_REQUEST_ASYNCHRONOUS* = 0x04 + DHCPCAPI_REQUEST_CANCEL* = 0x08 + DHCPCAPI_REQUEST_MASK* = 0x0F + DHCPCAPI_REGISTER_HANDLE_EVENT* = 0x01 + DHCPCAPI_DEREGISTER_HANDLE_EVENT* = 0x01 +proc DhcpCApiInitialize*(Version: LPDWORD): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpCApiCleanup*(): VOID {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpRequestParams*(Flags: DWORD, Reserved: LPVOID, AdapterName: LPWSTR, ClassId: LPDHCPCAPI_CLASSID, SendParams: DHCPCAPI_PARAMS_ARRAY, RecdParams: DHCPCAPI_PARAMS_ARRAY, Buffer: LPBYTE, pSize: LPDWORD, RequestIdStr: LPWSTR): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpUndoRequestParams*(Flags: DWORD, Reserved: LPVOID, AdapterName: LPWSTR, RequestIdStr: LPWSTR): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpRegisterParamChange*(Flags: DWORD, Reserved: LPVOID, AdapterName: LPWSTR, ClassId: LPDHCPCAPI_CLASSID, Params: DHCPCAPI_PARAMS_ARRAY, Handle: LPVOID): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpDeRegisterParamChange*(Flags: DWORD, Reserved: LPVOID, Event: LPVOID): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} +proc DhcpRemoveDNSRegistrations*(): DWORD {.winapi, stdcall, dynlib: "dhcpcsvc", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/dwmapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/dwmapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,206 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import uxtheme +#include +type + DWMWINDOWATTRIBUTE* = int32 + DWMNCRENDERINGPOLICY* = int32 + DWMFLIP3DWINDOWPOLICY* = int32 + DWM_SOURCE_FRAME_SAMPLING* = int32 + DWMTRANSITION_OWNEDWINDOW_TARGET* = int32 + GESTURE_TYPE* = int32 + DWM_SHOWCONTACT_ENUM* = int32 + DWM_TAB_WINDOW_REQUIREMENTS* = int32 + HTHUMBNAIL* = HANDLE + DWM_FRAME_COUNT* = ULONGLONG + QPC_TIME* = ULONGLONG + DWM_BLURBEHIND* {.pure.} = object + dwFlags*: DWORD + fEnable*: BOOL + hRgnBlur*: HRGN + fTransitionOnMaximized*: BOOL + PDWM_BLURBEHIND* = ptr DWM_BLURBEHIND + PHTHUMBNAIL* = ptr HTHUMBNAIL + DWM_THUMBNAIL_PROPERTIES* {.pure.} = object + dwFlags*: DWORD + rcDestination*: RECT + rcSource*: RECT + opacity*: BYTE + fVisible*: BOOL + fSourceClientAreaOnly*: BOOL + PDWM_THUMBNAIL_PROPERTIES* = ptr DWM_THUMBNAIL_PROPERTIES +const + DWM_BB_ENABLE* = 0x00000001 + DWM_BB_BLURREGION* = 0x00000002 + DWM_BB_TRANSITIONONMAXIMIZED* = 0x00000004 + DWMWA_NCRENDERING_ENABLED* = 1 + DWMWA_NCRENDERING_POLICY* = 2 + DWMWA_TRANSITIONS_FORCEDISABLED* = 3 + DWMWA_ALLOW_NCPAINT* = 4 + DWMWA_CAPTION_BUTTON_BOUNDS* = 5 + DWMWA_NONCLIENT_RTL_LAYOUT* = 6 + DWMWA_FORCE_ICONIC_REPRESENTATION* = 7 + DWMWA_FLIP3D_POLICY* = 8 + DWMWA_EXTENDED_FRAME_BOUNDS* = 9 + DWMWA_HAS_ICONIC_BITMAP* = 10 + DWMWA_DISALLOW_PEEK* = 11 + DWMWA_EXCLUDED_FROM_PEEK* = 12 + DWMWA_CLOAK* = 13 + DWMWA_CLOAKED* = 14 + DWMWA_FREEZE_REPRESENTATION* = 15 + DWMWA_LAST* = 16 + DWMNCRP_USEWINDOWSTYLE* = 0 + DWMNCRP_DISABLED* = 1 + DWMNCRP_ENABLED* = 2 + DWMNCRP_LAST* = 3 + DWMFLIP3D_DEFAULT* = 0 + DWMFLIP3D_EXCLUDEBELOW* = 1 + DWMFLIP3D_EXCLUDEABOVE* = 2 + DWMFLIP3D_LAST* = 3 + DWM_CLOAKED_APP* = 0x00000001 + DWM_CLOAKED_SHELL* = 0x00000002 + DWM_CLOAKED_INHERITED* = 0x00000004 + DWM_TNP_RECTDESTINATION* = 0x00000001 + DWM_TNP_RECTSOURCE* = 0x00000002 + DWM_TNP_OPACITY* = 0x00000004 + DWM_TNP_VISIBLE* = 0x00000008 + DWM_TNP_SOURCECLIENTAREAONLY* = 0x00000010 + DWM_SOURCE_FRAME_SAMPLING_POINT* = 0 + DWM_SOURCE_FRAME_SAMPLING_COVERAGE* = 1 + DWM_SOURCE_FRAME_SAMPLING_LAST* = 2 + c_DwmMaxQueuedBuffers* = 8 + c_DwmMaxMonitors* = 16 + c_DwmMaxAdapters* = 16 + DWM_FRAME_DURATION_DEFAULT* = -1 + DWM_EC_DISABLECOMPOSITION* = 0 + DWM_EC_ENABLECOMPOSITION* = 1 + DWM_SIT_DISPLAYFRAME* = 0x00000001 + DWMTRANSITION_OWNEDWINDOW_NULL* = -1 + DWMTRANSITION_OWNEDWINDOW_REPOSITION* = 0 + GT_PEN_TAP* = 0 + GT_PEN_DOUBLETAP* = 1 + GT_PEN_RIGHTTAP* = 2 + GT_PEN_PRESSANDHOLD* = 3 + GT_PEN_PRESSANDHOLDABORT* = 4 + GT_TOUCH_TAP* = 5 + GT_TOUCH_DOUBLETAP* = 6 + GT_TOUCH_RIGHTTAP* = 7 + GT_TOUCH_PRESSANDHOLD* = 8 + GT_TOUCH_PRESSANDHOLDABORT* = 9 + GT_TOUCH_PRESSANDTAP* = 10 + DWMSC_DOWN* = 0x00000001 + DWMSC_UP* = 0x00000002 + DWMSC_DRAG* = 0x00000004 + DWMSC_HOLD* = 0x00000008 + DWMSC_PENBARREL* = 0x00000010 + DWMSC_NONE* = 0x00000000 + DWMSC_ALL* = 0xFFFFFFFF'i32 + DWMTWR_NONE* = 0x0000 + DWMTWR_IMPLEMENTED_BY_SYSTEM* = 0x0001 + DWMTWR_WINDOW_RELATIONSHIP* = 0x0002 + DWMTWR_WINDOW_STYLES* = 0x0004 + DWMTWR_WINDOW_REGION* = 0x0008 + DWMTWR_WINDOW_DWM_ATTRIBUTES* = 0x0010 + DWMTWR_WINDOW_MARGINS* = 0x0020 + DWMTWR_TABBING_ENABLED* = 0x0040 + DWMTWR_USER_POLICY* = 0x0080 + DWMTWR_GROUP_POLICY* = 0x0100 + DWMTWR_APP_COMPAT* = 0x0200 +type + UNSIGNED_RATIO* {.pure.} = object + uiNumerator*: UINT32 + uiDenominator*: UINT32 + DWM_TIMING_INFO* {.pure.} = object + cbSize*: UINT32 + rateRefresh*: UNSIGNED_RATIO + qpcRefreshPeriod*: QPC_TIME + rateCompose*: UNSIGNED_RATIO + qpcVBlank*: QPC_TIME + cRefresh*: DWM_FRAME_COUNT + cDXRefresh*: UINT + qpcCompose*: QPC_TIME + cFrame*: DWM_FRAME_COUNT + cDXPresent*: UINT + cRefreshFrame*: DWM_FRAME_COUNT + cFrameSubmitted*: DWM_FRAME_COUNT + cDXPresentSubmitted*: UINT + cFrameConfirmed*: DWM_FRAME_COUNT + cDXPresentConfirmed*: UINT + cRefreshConfirmed*: DWM_FRAME_COUNT + cDXRefreshConfirmed*: UINT + cFramesLate*: DWM_FRAME_COUNT + cFramesOutstanding*: UINT + cFrameDisplayed*: DWM_FRAME_COUNT + qpcFrameDisplayed*: QPC_TIME + cRefreshFrameDisplayed*: DWM_FRAME_COUNT + cFrameComplete*: DWM_FRAME_COUNT + qpcFrameComplete*: QPC_TIME + cFramePending*: DWM_FRAME_COUNT + qpcFramePending*: QPC_TIME + cFramesDisplayed*: DWM_FRAME_COUNT + cFramesComplete*: DWM_FRAME_COUNT + cFramesPending*: DWM_FRAME_COUNT + cFramesAvailable*: DWM_FRAME_COUNT + cFramesDropped*: DWM_FRAME_COUNT + cFramesMissed*: DWM_FRAME_COUNT + cRefreshNextDisplayed*: DWM_FRAME_COUNT + cRefreshNextPresented*: DWM_FRAME_COUNT + cRefreshesDisplayed*: DWM_FRAME_COUNT + cRefreshesPresented*: DWM_FRAME_COUNT + cRefreshStarted*: DWM_FRAME_COUNT + cPixelsReceived*: ULONGLONG + cPixelsDrawn*: ULONGLONG + cBuffersEmpty*: DWM_FRAME_COUNT + DWM_PRESENT_PARAMETERS* {.pure.} = object + cbSize*: UINT32 + fQueue*: BOOL + cRefreshStart*: DWM_FRAME_COUNT + cBuffer*: UINT + fUseSourceRate*: BOOL + rateSource*: UNSIGNED_RATIO + cRefreshesPerFrame*: UINT + eSampling*: DWM_SOURCE_FRAME_SAMPLING + MIL_MATRIX3X2D* {.pure.} = object + S_11*: DOUBLE + S_12*: DOUBLE + S_21*: DOUBLE + S_22*: DOUBLE + DX*: DOUBLE + DY*: DOUBLE +proc DwmDefWindowProc*(hWnd: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): BOOL {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmEnableBlurBehindWindow*(hWnd: HWND, pBlurBehind: ptr DWM_BLURBEHIND): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmEnableComposition*(uCompositionAction: UINT): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmEnableMMCSS*(fEnableMMCSS: BOOL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmExtendFrameIntoClientArea*(hWnd: HWND, pMarInset: ptr MARGINS): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetColorizationColor*(pcrColorization: ptr DWORD, pfOpaqueBlend: ptr BOOL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetCompositionTimingInfo*(hwnd: HWND, pTimingInfo: ptr DWM_TIMING_INFO): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetWindowAttribute*(hwnd: HWND, dwAttribute: DWORD, pvAttribute: PVOID, cbAttribute: DWORD): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmIsCompositionEnabled*(pfEnabled: ptr BOOL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmModifyPreviousDxFrameDuration*(hwnd: HWND, cRefreshes: INT, fRelative: BOOL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmQueryThumbnailSourceSize*(hThumbnail: HTHUMBNAIL, pSize: PSIZE): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmRegisterThumbnail*(hwndDestination: HWND, hwndSource: HWND, phThumbnailId: PHTHUMBNAIL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmSetDxFrameDuration*(hwnd: HWND, cRefreshes: INT): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmSetPresentParameters*(hwnd: HWND, pPresentParams: ptr DWM_PRESENT_PARAMETERS): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmSetWindowAttribute*(hwnd: HWND, dwAttribute: DWORD, pvAttribute: LPCVOID, cbAttribute: DWORD): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmUnregisterThumbnail*(hThumbnailId: HTHUMBNAIL): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmUpdateThumbnailProperties*(hThumbnailId: HTHUMBNAIL, ptnProperties: ptr DWM_THUMBNAIL_PROPERTIES): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmSetIconicThumbnail*(hwnd: HWND, hbmp: HBITMAP, dwSITFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmSetIconicLivePreviewBitmap*(hwnd: HWND, hbmp: HBITMAP, pptClient: ptr POINT, dwSITFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmInvalidateIconicBitmaps*(hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmAttachMilContent*(hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmDetachMilContent*(hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmFlush*(): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetGraphicsStreamTransformHint*(uIndex: UINT, pTransform: ptr MIL_MATRIX3X2D): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetGraphicsStreamClient*(uIndex: UINT, pClientUuid: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetTransportAttributes*(pfIsRemoting: ptr BOOL, pfIsConnected: ptr BOOL, pDwGeneration: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmTransitionOwnedWindow*(hwnd: HWND, target: DWMTRANSITION_OWNEDWINDOW_TARGET): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmRenderGesture*(gt: GESTURE_TYPE, cContacts: UINT, pdwPointerID: ptr DWORD, pPoints: ptr POINT): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmTetherContact*(dwPointerID: DWORD, fEnable: BOOL, ptTether: POINT): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmShowContact*(dwPointerID: DWORD, eShowContact: DWM_SHOWCONTACT_ENUM): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} +proc DwmGetUnmetTabRequirements*(appWindow: HWND, value: ptr DWM_TAB_WINDOW_REQUIREMENTS): HRESULT {.winapi, stdcall, dynlib: "dwmapi", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/gdiplus.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/gdiplus.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1876 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import objbase +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + GpBrushType* = int32 + CombineMode* = int32 + CompositingMode* = int32 + CompositingQuality* = int32 + GpCoordinateSpace* = int32 + CustomLineCapType* = int32 + GpDashCap* = int32 + GpDashStyle* = int32 + DitherType* = int32 + DriverStringOptions* = int32 + EmfPlusRecordType* = int32 + EmfToWmfBitsFlags* = int32 + EmfType* = int32 + EncoderParameterValueType* = int32 + EncoderValue* = int32 + GpFillMode* = int32 + GpFlushIntention* = int32 + FontStyle* = int32 + GpHatchStyle* = int32 + HotkeyPrefix* = int32 + ImageType* = int32 + InterpolationMode* = int32 + LinearGradientMode* = int32 + GpLineCap* = int32 + GpLineJoin* = int32 + GpMatrixOrder* = int32 + MetafileFrameUnit* = int32 + MetafileType* = int32 + ObjectType* = int32 + PathPointType* = int32 + GpPenAlignment* = int32 + GpPenType* = int32 + PixelOffsetMode* = int32 + QualityMode* = int32 + SmoothingMode* = int32 + StringAlignment* = int32 + StringDigitSubstitute* = int32 + StringFormatFlags* = int32 + StringTrimming* = int32 + TextRenderingHint* = int32 + GpUnit* = int32 + WarpMode* = int32 + GpWrapMode* = int32 + GpTestControlEnum* = int32 + GpStatus* = int32 + DebugEventProc* = pointer + DrawImageAbort* = pointer + GetThumbnailImageAbort* = pointer + ImageCodecFlags* = int32 + ImageFlags* = int32 + ImageLockMode* = int32 + ItemDataPosition* = int32 + RotateFlipType* = int32 + PaletteFlags* = int32 + PaletteType* = int32 + ColorChannelFlags* = int32 + ColorAdjustType* = int32 + ColorMatrixFlags* = int32 + HistogramFormat* = int32 + CurveAdjustments* = int32 + CurveChannel* = int32 + GraphicsContainer* = DWORD + GraphicsState* = DWORD + ARGB* = DWORD + REAL* = float32 + ENHMETAHEADER3* {.pure.} = object + iType*: DWORD + nSize*: DWORD + rclBounds*: RECTL + rclFrame*: RECTL + dSignature*: DWORD + nVersion*: DWORD + nBytes*: DWORD + nRecords*: DWORD + nHandles*: WORD + sReserved*: WORD + nDescription*: DWORD + offDescription*: DWORD + nPalEntries*: DWORD + szlDevice*: SIZEL + szlMillimeters*: SIZEL + LPENHMETAHEADER3* = ptr ENHMETAHEADER3 + PixelFormat* = INT + ColorChannelLUT* = array[256, BYTE] +const + brushTypeSolidColor* = 0 + brushTypeHatchFill* = 1 + brushTypeTextureFill* = 2 + brushTypePathGradient* = 3 + brushTypeLinearGradient* = 4 + combineModeReplace* = 0 + combineModeIntersect* = 1 + combineModeUnion* = 2 + combineModeXor* = 3 + combineModeExclude* = 4 + combineModeComplement* = 5 + compositingModeSourceOver* = 0 + compositingModeSourceCopy* = 1 + compositingQualityDefault* = 0 + compositingQualityHighSpeed* = 1 + compositingQualityHighQuality* = 2 + compositingQualityGammaCorrected* = 3 + compositingQualityAssumeLinear* = 4 + coordinateSpaceWorld* = 0 + coordinateSpacePage* = 1 + coordinateSpaceDevice* = 2 + customLineCapTypeDefault* = 0 + customLineCapTypeAdjustableArrow* = 1 + dashCapFlat* = 0 + dashCapRound* = 2 + dashCapTriangle* = 3 + dashStyleSolid* = 0 + dashStyleDash* = 1 + dashStyleDot* = 2 + dashStyleDashDot* = 3 + dashStyleDashDotDot* = 4 + dashStyleCustom* = 5 + ditherTypeNone* = 0 + ditherTypeSolid* = 1 + ditherTypeOrdered4x4* = 2 + ditherTypeOrdered8x8* = 3 + ditherTypeOrdered16x16* = 4 + ditherTypeOrdered91x91* = 5 + ditherTypeSpiral4x4* = 6 + ditherTypeSpiral8x8* = 7 + ditherTypeDualSpiral4x4* = 8 + ditherTypeDualSpiral8x8* = 9 + ditherTypeErrorDiffusion* = 10 + driverStringOptionsCmapLookup* = 1 + driverStringOptionsVertical* = 2 + driverStringOptionsRealizedAdvance* = 4 + driverStringOptionsLimitSubpixel* = 8 + GDIP_EMFPLUS_RECORD_BASE* = 0x4000 +template GDIP_WMF_RECORD_TO_EMFPLUS*(meta: untyped): untyped = meta or 0x00010000 +const + wmfRecordTypeSetBkColor* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKCOLOR) + wmfRecordTypeSetBkMode* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKMODE) + wmfRecordTypeSetMapMode* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPMODE) + wmfRecordTypeSetROP2* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETROP2) + wmfRecordTypeSetRelAbs* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETRELABS) + wmfRecordTypeSetPolyFillMode* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPOLYFILLMODE) + wmfRecordTypeSetStretchBltMode* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETSTRETCHBLTMODE) + wmfRecordTypeSetTextCharExtra* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCHAREXTRA) + wmfRecordTypeSetTextColor* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCOLOR) + wmfRecordTypeSetTextJustification* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTJUSTIFICATION) + wmfRecordTypeSetWindowOrg* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWORG) + wmfRecordTypeSetWindowExt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWEXT) + wmfRecordTypeSetViewportOrg* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTORG) + wmfRecordTypeSetViewportExt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTEXT) + wmfRecordTypeOffsetWindowOrg* = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETWINDOWORG) + wmfRecordTypeScaleWindowExt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEWINDOWEXT) + wmfRecordTypeOffsetViewportOrg* = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETVIEWPORTORG) + wmfRecordTypeScaleViewportExt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEVIEWPORTEXT) + wmfRecordTypeLineTo* = GDIP_WMF_RECORD_TO_EMFPLUS(META_LINETO) + wmfRecordTypeMoveTo* = GDIP_WMF_RECORD_TO_EMFPLUS(META_MOVETO) + wmfRecordTypeExcludeClipRect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXCLUDECLIPRECT) + wmfRecordTypeIntersectClipRect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_INTERSECTCLIPRECT) + wmfRecordTypeArc* = GDIP_WMF_RECORD_TO_EMFPLUS(META_ARC) + wmfRecordTypeEllipse* = GDIP_WMF_RECORD_TO_EMFPLUS(META_ELLIPSE) + wmfRecordTypeFloodFill* = GDIP_WMF_RECORD_TO_EMFPLUS(META_FLOODFILL) + wmfRecordTypePie* = GDIP_WMF_RECORD_TO_EMFPLUS(META_PIE) + wmfRecordTypeRectangle* = GDIP_WMF_RECORD_TO_EMFPLUS(META_RECTANGLE) + wmfRecordTypeRoundRect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_ROUNDRECT) + wmfRecordTypePatBlt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_PATBLT) + wmfRecordTypeSaveDC* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SAVEDC) + wmfRecordTypeSetPixel* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPIXEL) + wmfRecordTypeOffsetClipRgn* = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETCLIPRGN) + wmfRecordTypeTextOut* = GDIP_WMF_RECORD_TO_EMFPLUS(META_TEXTOUT) + wmfRecordTypeBitBlt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_BITBLT) + wmfRecordTypeStretchBlt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHBLT) + wmfRecordTypePolygon* = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYGON) + wmfRecordTypePolyline* = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYLINE) + wmfRecordTypeEscape* = GDIP_WMF_RECORD_TO_EMFPLUS(META_ESCAPE) + wmfRecordTypeRestoreDC* = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESTOREDC) + wmfRecordTypeFillRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_FILLREGION) + wmfRecordTypeFrameRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_FRAMEREGION) + wmfRecordTypeInvertRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_INVERTREGION) + wmfRecordTypePaintRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_PAINTREGION) + wmfRecordTypeSelectClipRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTCLIPREGION) + wmfRecordTypeSelectObject* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTOBJECT) + wmfRecordTypeSetTextAlign* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTALIGN) + wmfRecordTypeDrawText* = GDIP_WMF_RECORD_TO_EMFPLUS(0x062F) + wmfRecordTypeChord* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CHORD) + wmfRecordTypeSetMapperFlags* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPPERFLAGS) + wmfRecordTypeExtTextOut* = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTTEXTOUT) + wmfRecordTypeSetDIBToDev* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETDIBTODEV) + wmfRecordTypeSelectPalette* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTPALETTE) + wmfRecordTypeRealizePalette* = GDIP_WMF_RECORD_TO_EMFPLUS(META_REALIZEPALETTE) + wmfRecordTypeAnimatePalette* = GDIP_WMF_RECORD_TO_EMFPLUS(META_ANIMATEPALETTE) + wmfRecordTypeSetPalEntries* = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPALENTRIES) + wmfRecordTypePolyPolygon* = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYPOLYGON) + wmfRecordTypeResizePalette* = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESIZEPALETTE) + wmfRecordTypeDIBBitBlt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBBITBLT) + wmfRecordTypeDIBStretchBlt* = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBSTRETCHBLT) + wmfRecordTypeDIBCreatePatternBrush* = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBCREATEPATTERNBRUSH) + wmfRecordTypeStretchDIB* = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHDIB) + wmfRecordTypeExtFloodFill* = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTFLOODFILL) + wmfRecordTypeSetLayout* = GDIP_WMF_RECORD_TO_EMFPLUS(0x0149) + wmfRecordTypeResetDC* = GDIP_WMF_RECORD_TO_EMFPLUS(0x014C) + wmfRecordTypeStartDoc* = GDIP_WMF_RECORD_TO_EMFPLUS(0x014D) + wmfRecordTypeStartPage* = GDIP_WMF_RECORD_TO_EMFPLUS(0x004F) + wmfRecordTypeEndPage* = GDIP_WMF_RECORD_TO_EMFPLUS(0x0050) + wmfRecordTypeAbortDoc* = GDIP_WMF_RECORD_TO_EMFPLUS(0x0052) + wmfRecordTypeEndDoc* = GDIP_WMF_RECORD_TO_EMFPLUS(0x005E) + wmfRecordTypeDeleteObject* = GDIP_WMF_RECORD_TO_EMFPLUS(META_DELETEOBJECT) + wmfRecordTypeCreatePalette* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPALETTE) + wmfRecordTypeCreateBrush* = GDIP_WMF_RECORD_TO_EMFPLUS(0x00F8) + wmfRecordTypeCreatePatternBrush* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPATTERNBRUSH) + wmfRecordTypeCreatePenIndirect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPENINDIRECT) + wmfRecordTypeCreateFontIndirect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEFONTINDIRECT) + wmfRecordTypeCreateBrushIndirect* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEBRUSHINDIRECT) + wmfRecordTypeCreateBitmapIndirect* = GDIP_WMF_RECORD_TO_EMFPLUS(0x02FD) + wmfRecordTypeCreateBitmap* = GDIP_WMF_RECORD_TO_EMFPLUS(0x06FE) + wmfRecordTypeCreateRegion* = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEREGION) + emfRecordTypeHeader* = emrHEADER + emfRecordTypePolyBezier* = emrPOLYBEZIER + emfRecordTypePolygon* = emrPOLYGON + emfRecordTypePolyline* = emrPOLYLINE + emfRecordTypePolyBezierTo* = emrPOLYBEZIERTO + emfRecordTypePolyLineTo* = emrPOLYLINETO + emfRecordTypePolyPolyline* = emrPOLYPOLYLINE + emfRecordTypePolyPolygon* = emrPOLYPOLYGON + emfRecordTypeSetWindowExtEx* = emrSETWINDOWEXTEX + emfRecordTypeSetWindowOrgEx* = emrSETWINDOWORGEX + emfRecordTypeSetViewportExtEx* = emrSETVIEWPORTEXTEX + emfRecordTypeSetViewportOrgEx* = emrSETVIEWPORTORGEX + emfRecordTypeSetBrushOrgEx* = emrSETBRUSHORGEX + emfRecordTypeEOF* = emrEOF + emfRecordTypeSetPixelV* = emrSETPIXELV + emfRecordTypeSetMapperFlags* = emrSETMAPPERFLAGS + emfRecordTypeSetMapMode* = emrSETMAPMODE + emfRecordTypeSetBkMode* = emrSETBKMODE + emfRecordTypeSetPolyFillMode* = emrSETPOLYFILLMODE + emfRecordTypeSetROP2* = emrSETROP2 + emfRecordTypeSetStretchBltMode* = emrSETSTRETCHBLTMODE + emfRecordTypeSetTextAlign* = emrSETTEXTALIGN + emfRecordTypeSetColorAdjustment* = emrSETCOLORADJUSTMENT + emfRecordTypeSetTextColor* = emrSETTEXTCOLOR + emfRecordTypeSetBkColor* = emrSETBKCOLOR + emfRecordTypeOffsetClipRgn* = emrOFFSETCLIPRGN + emfRecordTypeMoveToEx* = emrMOVETOEX + emfRecordTypeSetMetaRgn* = emrSETMETARGN + emfRecordTypeExcludeClipRect* = emrEXCLUDECLIPRECT + emfRecordTypeIntersectClipRect* = emrINTERSECTCLIPRECT + emfRecordTypeScaleViewportExtEx* = emrSCALEVIEWPORTEXTEX + emfRecordTypeScaleWindowExtEx* = emrSCALEWINDOWEXTEX + emfRecordTypeSaveDC* = emrSAVEDC + emfRecordTypeRestoreDC* = emrRESTOREDC + emfRecordTypeSetWorldTransform* = emrSETWORLDTRANSFORM + emfRecordTypeModifyWorldTransform* = emrMODIFYWORLDTRANSFORM + emfRecordTypeSelectObject* = emrSELECTOBJECT + emfRecordTypeCreatePen* = emrCREATEPEN + emfRecordTypeCreateBrushIndirect* = emrCREATEBRUSHINDIRECT + emfRecordTypeDeleteObject* = emrDELETEOBJECT + emfRecordTypeAngleArc* = emrANGLEARC + emfRecordTypeEllipse* = emrELLIPSE + emfRecordTypeRectangle* = emrRECTANGLE + emfRecordTypeRoundRect* = emrROUNDRECT + emfRecordTypeArc* = emrARC + emfRecordTypeChord* = emrCHORD + emfRecordTypePie* = emrPIE + emfRecordTypeSelectPalette* = emrSELECTPALETTE + emfRecordTypeCreatePalette* = emrCREATEPALETTE + emfRecordTypeSetPaletteEntries* = emrSETPALETTEENTRIES + emfRecordTypeResizePalette* = emrRESIZEPALETTE + emfRecordTypeRealizePalette* = emrREALIZEPALETTE + emfRecordTypeExtFloodFill* = emrEXTFLOODFILL + emfRecordTypeLineTo* = emrLINETO + emfRecordTypeArcTo* = emrARCTO + emfRecordTypePolyDraw* = emrPOLYDRAW + emfRecordTypeSetArcDirection* = emrSETARCDIRECTION + emfRecordTypeSetMiterLimit* = emrSETMITERLIMIT + emfRecordTypeBeginPath* = emrBEGINPATH + emfRecordTypeEndPath* = emrENDPATH + emfRecordTypeCloseFigure* = emrCLOSEFIGURE + emfRecordTypeFillPath* = emrFILLPATH + emfRecordTypeStrokeAndFillPath* = emrSTROKEANDFILLPATH + emfRecordTypeStrokePath* = emrSTROKEPATH + emfRecordTypeFlattenPath* = emrFLATTENPATH + emfRecordTypeWidenPath* = emrWIDENPATH + emfRecordTypeSelectClipPath* = emrSELECTCLIPPATH + emfRecordTypeAbortPath* = emrABORTPATH + EmfRecordTypeReserved_069* = 69 + emfRecordTypeGdiComment* = emrGDICOMMENT + emfRecordTypeFillRgn* = emrFILLRGN + emfRecordTypeFrameRgn* = emrFRAMERGN + emfRecordTypeInvertRgn* = emrINVERTRGN + emfRecordTypePaintRgn* = emrPAINTRGN + emfRecordTypeExtSelectClipRgn* = emrEXTSELECTCLIPRGN + emfRecordTypeBitBlt* = emrBITBLT + emfRecordTypeStretchBlt* = emrSTRETCHBLT + emfRecordTypeMaskBlt* = emrMASKBLT + emfRecordTypePlgBlt* = emrPLGBLT + emfRecordTypeSetDIBitsToDevice* = emrSETDIBITSTODEVICE + emfRecordTypeStretchDIBits* = emrSTRETCHDIBITS + emfRecordTypeExtCreateFontIndirect* = emrEXTCREATEFONTINDIRECTW + emfRecordTypeExtTextOutA* = emrEXTTEXTOUTA + emfRecordTypeExtTextOutW* = emrEXTTEXTOUTW + emfRecordTypePolyBezier16* = emrPOLYBEZIER16 + emfRecordTypePolygon16* = emrPOLYGON16 + emfRecordTypePolyline16* = emrPOLYLINE16 + emfRecordTypePolyBezierTo16* = emrPOLYBEZIERTO16 + emfRecordTypePolylineTo16* = emrPOLYLINETO16 + emfRecordTypePolyPolyline16* = emrPOLYPOLYLINE16 + emfRecordTypePolyPolygon16* = emrPOLYPOLYGON16 + emfRecordTypePolyDraw16* = emrPOLYDRAW16 + emfRecordTypeCreateMonoBrush* = emrCREATEMONOBRUSH + emfRecordTypeCreateDIBPatternBrushPt* = emrCREATEDIBPATTERNBRUSHPT + emfRecordTypeExtCreatePen* = emrEXTCREATEPEN + emfRecordTypePolyTextOutA* = emrPOLYTEXTOUTA + emfRecordTypePolyTextOutW* = emrPOLYTEXTOUTW + emfRecordTypeSetICMMode* = 98 + emfRecordTypeCreateColorSpace* = 99 + emfRecordTypeSetColorSpace* = 100 + emfRecordTypeDeleteColorSpace* = 101 + emfRecordTypeGLSRecord* = 102 + emfRecordTypeGLSBoundedRecord* = 103 + emfRecordTypePixelFormat* = 104 + emfRecordTypeDrawEscape* = 105 + emfRecordTypeExtEscape* = 106 + emfRecordTypeStartDoc* = 107 + emfRecordTypeSmallTextOut* = 108 + emfRecordTypeForceUFIMapping* = 109 + emfRecordTypeNamedEscape* = 110 + emfRecordTypeColorCorrectPalette* = 111 + emfRecordTypeSetICMProfileA* = 112 + emfRecordTypeSetICMProfileW* = 113 + emfRecordTypeAlphaBlend* = 114 + emfRecordTypeSetLayout* = 115 + emfRecordTypeTransparentBlt* = 116 + EmfRecordTypeReserved_117* = 117 + emfRecordTypeGradientFill* = 118 + emfRecordTypeSetLinkedUFIs* = 119 + emfRecordTypeSetTextJustification* = 120 + emfRecordTypeColorMatchToTargetW* = 121 + emfRecordTypeCreateColorSpaceW* = 122 + emfRecordTypeMax* = 122 + emfRecordTypeMin* = 1 + emfPlusRecordTypeInvalid* = GDIP_EMFPLUS_RECORD_BASE + emfPlusRecordTypeHeader* = GDIP_EMFPLUS_RECORD_BASE+1 + emfPlusRecordTypeEndOfFile* = GDIP_EMFPLUS_RECORD_BASE+2 + emfPlusRecordTypeComment* = GDIP_EMFPLUS_RECORD_BASE+3 + emfPlusRecordTypeGetDC* = GDIP_EMFPLUS_RECORD_BASE+4 + emfPlusRecordTypeMultiFormatStart* = GDIP_EMFPLUS_RECORD_BASE+5 + emfPlusRecordTypeMultiFormatSection* = GDIP_EMFPLUS_RECORD_BASE+6 + emfPlusRecordTypeMultiFormatEnd* = GDIP_EMFPLUS_RECORD_BASE+7 + emfPlusRecordTypeObject* = GDIP_EMFPLUS_RECORD_BASE+8 + emfPlusRecordTypeClear* = GDIP_EMFPLUS_RECORD_BASE+9 + emfPlusRecordTypeFillRects* = GDIP_EMFPLUS_RECORD_BASE+10 + emfPlusRecordTypeDrawRects* = GDIP_EMFPLUS_RECORD_BASE+11 + emfPlusRecordTypeFillPolygon* = GDIP_EMFPLUS_RECORD_BASE+12 + emfPlusRecordTypeDrawLines* = GDIP_EMFPLUS_RECORD_BASE+13 + emfPlusRecordTypeFillEllipse* = GDIP_EMFPLUS_RECORD_BASE+14 + emfPlusRecordTypeDrawEllipse* = GDIP_EMFPLUS_RECORD_BASE+15 + emfPlusRecordTypeFillPie* = GDIP_EMFPLUS_RECORD_BASE+16 + emfPlusRecordTypeDrawPie* = GDIP_EMFPLUS_RECORD_BASE+17 + emfPlusRecordTypeDrawArc* = GDIP_EMFPLUS_RECORD_BASE+18 + emfPlusRecordTypeFillRegion* = GDIP_EMFPLUS_RECORD_BASE+19 + emfPlusRecordTypeFillPath* = GDIP_EMFPLUS_RECORD_BASE+20 + emfPlusRecordTypeDrawPath* = GDIP_EMFPLUS_RECORD_BASE+21 + emfPlusRecordTypeFillClosedCurve* = GDIP_EMFPLUS_RECORD_BASE+22 + emfPlusRecordTypeDrawClosedCurve* = GDIP_EMFPLUS_RECORD_BASE+23 + emfPlusRecordTypeDrawCurve* = GDIP_EMFPLUS_RECORD_BASE+24 + emfPlusRecordTypeDrawBeziers* = GDIP_EMFPLUS_RECORD_BASE+25 + emfPlusRecordTypeDrawImage* = GDIP_EMFPLUS_RECORD_BASE+26 + emfPlusRecordTypeDrawImagePoints* = GDIP_EMFPLUS_RECORD_BASE+27 + emfPlusRecordTypeDrawString* = GDIP_EMFPLUS_RECORD_BASE+28 + emfPlusRecordTypeSetRenderingOrigin* = GDIP_EMFPLUS_RECORD_BASE+29 + emfPlusRecordTypeSetAntiAliasMode* = GDIP_EMFPLUS_RECORD_BASE+30 + emfPlusRecordTypeSetTextRenderingHint* = GDIP_EMFPLUS_RECORD_BASE+31 + emfPlusRecordTypeSetTextContrast* = GDIP_EMFPLUS_RECORD_BASE+32 + emfPlusRecordTypeSetGammaValue* = GDIP_EMFPLUS_RECORD_BASE+33 + emfPlusRecordTypeSetInterpolationMode* = GDIP_EMFPLUS_RECORD_BASE+34 + emfPlusRecordTypeSetPixelOffsetMode* = GDIP_EMFPLUS_RECORD_BASE+35 + emfPlusRecordTypeSetCompositingMode* = GDIP_EMFPLUS_RECORD_BASE+36 + emfPlusRecordTypeSetCompositingQuality* = GDIP_EMFPLUS_RECORD_BASE+37 + emfPlusRecordTypeSave* = GDIP_EMFPLUS_RECORD_BASE+38 + emfPlusRecordTypeRestore* = GDIP_EMFPLUS_RECORD_BASE+39 + emfPlusRecordTypeBeginContainer* = GDIP_EMFPLUS_RECORD_BASE+40 + emfPlusRecordTypeBeginContainerNoParams* = GDIP_EMFPLUS_RECORD_BASE+41 + emfPlusRecordTypeEndContainer* = GDIP_EMFPLUS_RECORD_BASE+42 + emfPlusRecordTypeSetWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+43 + emfPlusRecordTypeResetWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+44 + emfPlusRecordTypeMultiplyWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+45 + emfPlusRecordTypeTranslateWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+46 + emfPlusRecordTypeScaleWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+47 + emfPlusRecordTypeRotateWorldTransform* = GDIP_EMFPLUS_RECORD_BASE+48 + emfPlusRecordTypeSetPageTransform* = GDIP_EMFPLUS_RECORD_BASE+49 + emfPlusRecordTypeResetClip* = GDIP_EMFPLUS_RECORD_BASE+50 + emfPlusRecordTypeSetClipRect* = GDIP_EMFPLUS_RECORD_BASE+51 + emfPlusRecordTypeSetClipPath* = GDIP_EMFPLUS_RECORD_BASE+52 + emfPlusRecordTypeSetClipRegion* = GDIP_EMFPLUS_RECORD_BASE+53 + emfPlusRecordTypeOffsetClip* = GDIP_EMFPLUS_RECORD_BASE+54 + emfPlusRecordTypeDrawDriverString* = GDIP_EMFPLUS_RECORD_BASE+55 + emfPlusRecordTypeStrokeFillPath* = GDIP_EMFPLUS_RECORD_BASE+56 + emfPlusRecordTypeSerializableObject* = GDIP_EMFPLUS_RECORD_BASE+57 + emfPlusRecordTypeSetTSGraphics* = GDIP_EMFPLUS_RECORD_BASE+58 + emfPlusRecordTypeSetTSClip* = GDIP_EMFPLUS_RECORD_BASE+59 + emfPlusRecordTotal* = GDIP_EMFPLUS_RECORD_BASE+60 + emfPlusRecordTypeMax* = emfPlusRecordTotal-1 + emfPlusRecordTypeMin* = emfPlusRecordTypeHeader + emfToWmfBitsFlagsDefault* = 0 + emfToWmfBitsFlagsEmbedEmf* = 1 + emfToWmfBitsFlagsIncludePlaceable* = 2 + emfToWmfBitsFlagsNoXORClip* = 4 + emfTypeEmfOnly* = 3 + emfTypeEmfPlusOnly* = 4 + emfTypeEmfPlusDual* = 5 + encoderParameterValueTypeByte* = 1 + encoderParameterValueTypeASCII* = 2 + encoderParameterValueTypeShort* = 3 + encoderParameterValueTypeLong* = 4 + encoderParameterValueTypeRational* = 5 + encoderParameterValueTypeLongRange* = 6 + encoderParameterValueTypeUndefined* = 7 + encoderParameterValueTypeRationalRange* = 8 + encoderParameterValueTypePointer* = 9 + encoderValueColorTypeCMYK* = 0 + encoderValueColorTypeYCCK* = 1 + encoderValueCompressionLZW* = 2 + encoderValueCompressionCCITT3* = 3 + encoderValueCompressionCCITT4* = 4 + encoderValueCompressionRle* = 5 + encoderValueCompressionNone* = 6 + encoderValueScanMethodInterlaced* = 7 + encoderValueScanMethodNonInterlaced* = 8 + encoderValueVersionGif87* = 9 + encoderValueVersionGif89* = 10 + encoderValueRenderProgressive* = 11 + encoderValueRenderNonProgressive* = 12 + encoderValueTransformRotate90* = 13 + encoderValueTransformRotate180* = 14 + encoderValueTransformRotate270* = 15 + encoderValueTransformFlipHorizontal* = 16 + encoderValueTransformFlipVertical* = 17 + encoderValueMultiFrame* = 18 + encoderValueLastFrame* = 19 + encoderValueFlush* = 20 + encoderValueFrameDimensionTime* = 21 + encoderValueFrameDimensionResolution* = 22 + encoderValueFrameDimensionPage* = 23 + fillModeAlternate* = 0 + fillModeWinding* = 1 + flushIntentionFlush* = 0 + flushIntentionSync* = 1 + fontStyleRegular* = 0 + fontStyleBold* = 1 + fontStyleItalic* = 2 + fontStyleBoldItalic* = 3 + fontStyleUnderline* = 4 + fontStyleStrikeout* = 8 + hatchStyleHorizontal* = 0 + hatchStyleVertical* = 1 + hatchStyleForwardDiagonal* = 2 + hatchStyleBackwardDiagonal* = 3 + hatchStyleCross* = 4 + hatchStyleLargeGrid* = 4 + hatchStyleDiagonalCross* = 5 + hatchStyle05Percent* = 6 + hatchStyle10Percent* = 7 + hatchStyle20Percent* = 8 + hatchStyle25Percent* = 9 + hatchStyle30Percent* = 10 + hatchStyle40Percent* = 11 + hatchStyle50Percent* = 12 + hatchStyle60Percent* = 13 + hatchStyle70Percent* = 14 + hatchStyle75Percent* = 15 + hatchStyle80Percent* = 16 + hatchStyle90Percent* = 17 + hatchStyleLightDownwardDiagonal* = 18 + hatchStyleLightUpwardDiagonal* = 19 + hatchStyleDarkDownwardDiagonal* = 20 + hatchStyleDarkUpwardDiagonal* = 21 + hatchStyleWideDownwardDiagonal* = 22 + hatchStyleWideUpwardDiagonal* = 23 + hatchStyleLightVertical* = 24 + hatchStyleLightHorizontal* = 25 + hatchStyleNarrowVertical* = 26 + hatchStyleNarrowHorizontal* = 27 + hatchStyleDarkVertical* = 28 + hatchStyleDarkHorizontal* = 29 + hatchStyleDashedDownwardDiagonal* = 30 + hatchStyleDashedUpwardDiagonal* = 31 + hatchStyleDashedHorizontal* = 32 + hatchStyleDashedVertical* = 33 + hatchStyleSmallConfetti* = 34 + hatchStyleLargeConfetti* = 35 + hatchStyleZigZag* = 36 + hatchStyleWave* = 37 + hatchStyleDiagonalBrick* = 38 + hatchStyleHorizontalBrick* = 39 + hatchStyleWeave* = 40 + hatchStylePlaid* = 41 + hatchStyleDivot* = 42 + hatchStyleDottedGrid* = 43 + hatchStyleDottedDiamond* = 44 + hatchStyleShingle* = 45 + hatchStyleTrellis* = 46 + hatchStyleSphere* = 47 + hatchStyleSmallGrid* = 48 + hatchStyleSmallCheckerBoard* = 49 + hatchStyleLargeCheckerBoard* = 50 + hatchStyleOutlinedDiamond* = 51 + hatchStyleSolidDiamond* = 52 + hatchStyleTotal* = 53 + hatchStyleMin* = hatchStyleHorizontal + hatchStyleMax* = hatchStyleTotal-1 + hotkeyPrefixNone* = 0 + hotkeyPrefixShow* = 1 + hotkeyPrefixHide* = 2 + imageTypeUnknown* = 0 + imageTypeBitmap* = 1 + imageTypeMetafile* = 2 + interpolationModeInvalid* = -1 + interpolationModeDefault* = 0 + interpolationModeLowQuality* = 1 + interpolationModeHighQuality* = 2 + interpolationModeBilinear* = 3 + interpolationModeBicubic* = 4 + interpolationModeNearestNeighbor* = 5 + interpolationModeHighQualityBilinear* = 6 + interpolationModeHighQualityBicubic* = 7 + linearGradientModeHorizontal* = 0 + linearGradientModeVertical* = 1 + linearGradientModeForwardDiagonal* = 2 + linearGradientModeBackwardDiagonal* = 3 + lineCapFlat* = 0 + lineCapSquare* = 1 + lineCapRound* = 2 + lineCapTriangle* = 3 + lineCapNoAnchor* = 16 + lineCapSquareAnchor* = 17 + lineCapRoundAnchor* = 18 + lineCapDiamondAnchor* = 19 + lineCapArrowAnchor* = 20 + lineCapCustom* = 255 + lineJoinMiter* = 0 + lineJoinBevel* = 1 + lineJoinRound* = 2 + lineJoinMiterClipped* = 3 + matrixOrderPrepend* = 0 + matrixOrderAppend* = 1 + metafileFrameUnitPixel* = 2 + metafileFrameUnitPoint* = 3 + metafileFrameUnitInch* = 4 + metafileFrameUnitDocument* = 5 + metafileFrameUnitMillimeter* = 6 + metafileFrameUnitGdi* = 7 + metafileTypeInvalid* = 0 + metafileTypeWmf* = 1 + metafileTypeWmfPlaceable* = 2 + metafileTypeEmf* = 3 + metafileTypeEmfPlusOnly* = 4 + metafileTypeEmfPlusDual* = 5 + objectTypeInvalid* = 0 + objectTypeBrush* = 1 + objectTypePen* = 2 + objectTypePath* = 3 + objectTypeRegion* = 4 + objectTypeFont* = 5 + objectTypeStringFormat* = 6 + objectTypeImageAttributes* = 7 + objectTypeCustomLineCap* = 8 + objectTypeGraphics* = 9 + objectTypeMin* = objectTypeBrush + objectTypeMax* = objectTypeGraphics + pathPointTypeStart* = 0x00 + pathPointTypeLine* = 0x01 + pathPointTypeBezier* = 0x03 + pathPointTypeBezier3* = 0x03 + pathPointTypePathTypeMask* = 0x07 + pathPointTypePathDashMode* = 0x10 + pathPointTypePathMarker* = 0x20 + pathPointTypeCloseSubpath* = 0x80 + penAlignmentCenter* = 0 + penAlignmentInset* = 1 + penTypeUnknown* = -1 + penTypeSolidColor* = 0 + penTypeHatchFill* = 1 + penTypeTextureFill* = 2 + penTypePathGradient* = 3 + penTypeLinearGradient* = 4 + pixelOffsetModeInvalid* = -1 + pixelOffsetModeDefault* = 0 + pixelOffsetModeHighSpeed* = 1 + pixelOffsetModeHighQuality* = 2 + pixelOffsetModeNone* = 3 + pixelOffsetModeHalf* = 4 + qualityModeInvalid* = -1 + qualityModeDefault* = 0 + qualityModeLow* = 1 + qualityModeHigh* = 2 + smoothingModeInvalid* = qualityModeInvalid + smoothingModeDefault* = 0 + smoothingModeHighSpeed* = 1 + smoothingModeHighQuality* = 2 + smoothingModeNone* = 3 + smoothingModeAntiAlias8x4* = 4 + smoothingModeAntiAlias* = 4 + smoothingModeAntiAlias8x8* = 5 + stringAlignmentNear* = 0 + stringAlignmentCenter* = 1 + stringAlignmentFar* = 2 + stringDigitSubstituteUser* = 0 + stringDigitSubstituteNone* = 1 + stringDigitSubstituteNational* = 2 + stringDigitSubstituteTraditional* = 3 + stringFormatFlagsDirectionRightToLeft* = 0x00000001 + stringFormatFlagsDirectionVertical* = 0x00000002 + stringFormatFlagsNoFitBlackBox* = 0x00000004 + stringFormatFlagsDisplayFormatControl* = 0x00000020 + stringFormatFlagsNoFontFallback* = 0x00000400 + stringFormatFlagsMeasureTrailingSpaces* = 0x00000800 + stringFormatFlagsNoWrap* = 0x00001000 + stringFormatFlagsLineLimit* = 0x00002000 + stringFormatFlagsNoClip* = 0x00004000 + stringTrimmingNone* = 0 + stringTrimmingCharacter* = 1 + stringTrimmingWord* = 2 + stringTrimmingEllipsisCharacter* = 3 + stringTrimmingEllipsisWord* = 4 + stringTrimmingEllipsisPath* = 5 + textRenderingHintSystemDefault* = 0 + textRenderingHintSingleBitPerPixelGridFit* = 1 + textRenderingHintSingleBitPerPixel* = 2 + textRenderingHintAntiAliasGridFit* = 3 + textRenderingHintAntiAlias* = 4 + textRenderingHintClearTypeGridFit* = 5 + unitWorld* = 0 + unitDisplay* = 1 + unitPixel* = 2 + unitPoint* = 3 + unitInch* = 4 + unitDocument* = 5 + unitMillimeter* = 6 + warpModePerspective* = 0 + warpModeBilinear* = 1 + wrapModeTile* = 0 + wrapModeTileFlipX* = 1 + wrapModeTileFlipY* = 2 + wrapModeTileFlipXY* = 3 + wrapModeClamp* = 4 + testControlForceBilinear* = 0 + testControlForceNoICM* = 1 + testControlGetBuildNumber* = 2 + flatnessDefault* = (REAL) 0.25f + Ok* = 0 + genericError* = 1 + invalidParameter* = 2 + outOfMemory* = 3 + objectBusy* = 4 + insufficientBuffer* = 5 + notImplemented* = 6 + win32Error* = 7 + wrongState* = 8 + aborted* = 9 + fileNotFound* = 10 + valueOverflow* = 11 + accessDenied* = 12 + unknownImageFormat* = 13 + fontFamilyNotFound* = 14 + fontStyleNotFound* = 15 + notTrueTypeFont* = 16 + unsupportedGdiplusVersion* = 17 + gdiplusNotInitialized* = 18 + propertyNotFound* = 19 + propertyNotSupported* = 20 + profileNotFound* = 21 + imageCodecFlagsEncoder* = 0x00000001 + imageCodecFlagsDecoder* = 0x00000002 + imageCodecFlagsSupportBitmap* = 0x00000004 + imageCodecFlagsSupportVector* = 0x00000008 + imageCodecFlagsSeekableEncode* = 0x00000010 + imageCodecFlagsBlockingDecode* = 0x00000020 + imageCodecFlagsBuiltin* = 0x00010000 + imageCodecFlagsSystem* = 0x00020000 + imageCodecFlagsUser* = 0x00040000 + imageFlagsNone* = 0 + imageFlagsScalable* = 0x00000001 + imageFlagsHasAlpha* = 0x00000002 + imageFlagsHasTranslucent* = 0x00000004 + imageFlagsPartiallyScalable* = 0x00000008 + imageFlagsColorSpaceRGB* = 0x00000010 + imageFlagsColorSpaceCMYK* = 0x00000020 + imageFlagsColorSpaceGRAY* = 0x00000040 + imageFlagsColorSpaceYCBCR* = 0x00000080 + imageFlagsColorSpaceYCCK* = 0x00000100 + imageFlagsHasRealDPI* = 0x00001000 + imageFlagsHasRealPixelSize* = 0x00002000 + imageFlagsReadOnly* = 0x00010000 + imageFlagsCaching* = 0x00020000 + imageLockModeRead* = 1 + imageLockModeWrite* = 2 + imageLockModeUserInputBuf* = 4 + itemDataPositionAfterHeader* = 0 + itemDataPositionAfterPalette* = 1 + itemDataPositionAfterBits* = 2 + rotateNoneFlipNone* = 0 + rotate90FlipNone* = 1 + rotate180FlipNone* = 2 + rotate270FlipNone* = 3 + rotateNoneFlipX* = 4 + rotate90FlipX* = 5 + rotate180FlipX* = 6 + rotate270FlipX* = 7 + rotate180FlipXY* = 0 + rotate270FlipXY* = 1 + rotateNoneFlipXY* = 2 + rotate90FlipXY* = 3 + rotate180FlipY* = 4 + rotate270FlipY* = 5 + rotateNoneFlipY* = 6 + rotate90FlipY* = 7 + propertyTagGpsVer* = PROPID 0x0000 + propertyTagGpsLatitudeRef* = PROPID 0x0001 + propertyTagGpsLatitude* = PROPID 0x0002 + propertyTagGpsLongitudeRef* = PROPID 0x0003 + propertyTagGpsLongitude* = PROPID 0x0004 + propertyTagGpsAltitudeRef* = PROPID 0x0005 + propertyTagGpsAltitude* = PROPID 0x0006 + propertyTagGpsGpsTime* = PROPID 0x0007 + propertyTagGpsGpsSatellites* = PROPID 0x0008 + propertyTagGpsGpsStatus* = PROPID 0x0009 + propertyTagGpsGpsMeasureMode* = PROPID 0x000A + propertyTagGpsGpsDop* = PROPID 0x000B + propertyTagGpsSpeedRef* = PROPID 0x000C + propertyTagGpsSpeed* = PROPID 0x000D + propertyTagGpsTrackRef* = PROPID 0x000E + propertyTagGpsTrack* = PROPID 0x000F + propertyTagGpsImgDirRef* = PROPID 0x0010 + propertyTagGpsImgDir* = PROPID 0x0011 + propertyTagGpsMapDatum* = PROPID 0x0012 + propertyTagGpsDestLatRef* = PROPID 0x0013 + propertyTagGpsDestLat* = PROPID 0x0014 + propertyTagGpsDestLongRef* = PROPID 0x0015 + propertyTagGpsDestLong* = PROPID 0x0016 + propertyTagGpsDestBearRef* = PROPID 0x0017 + propertyTagGpsDestBear* = PROPID 0x0018 + propertyTagGpsDestDistRef* = PROPID 0x0019 + propertyTagGpsDestDist* = PROPID 0x001A + propertyTagNewSubfileType* = PROPID 0x00FE + propertyTagSubfileType* = PROPID 0x00FF + propertyTagImageWidth* = PROPID 0x0100 + propertyTagImageHeight* = PROPID 0x0101 + propertyTagBitsPerSample* = PROPID 0x0102 + propertyTagCompression* = PROPID 0x0103 + propertyTagPhotometricInterp* = PROPID 0x0106 + propertyTagThreshHolding* = PROPID 0x0107 + propertyTagCellWidth* = PROPID 0x0108 + propertyTagCellHeight* = PROPID 0x0109 + propertyTagFillOrder* = PROPID 0x010A + propertyTagDocumentName* = PROPID 0x010D + propertyTagImageDescription* = PROPID 0x010E + propertyTagEquipMake* = PROPID 0x010F + propertyTagEquipModel* = PROPID 0x0110 + propertyTagStripOffsets* = PROPID 0x0111 + propertyTagOrientation* = PROPID 0x0112 + propertyTagSamplesPerPixel* = PROPID 0x0115 + propertyTagRowsPerStrip* = PROPID 0x0116 + propertyTagStripBytesCount* = PROPID 0x0117 + propertyTagMinSampleValue* = PROPID 0x0118 + propertyTagMaxSampleValue* = PROPID 0x0119 + propertyTagXResolution* = PROPID 0x011A + propertyTagYResolution* = PROPID 0x011B + propertyTagPlanarConfig* = PROPID 0x011C + propertyTagPageName* = PROPID 0x011D + propertyTagXPosition* = PROPID 0x011E + propertyTagYPosition* = PROPID 0x011F + propertyTagFreeOffset* = PROPID 0x0120 + propertyTagFreeByteCounts* = PROPID 0x0121 + propertyTagGrayResponseUnit* = PROPID 0x0122 + propertyTagGrayResponseCurve* = PROPID 0x0123 + propertyTagT4Option* = PROPID 0x0124 + propertyTagT6Option* = PROPID 0x0125 + propertyTagResolutionUnit* = PROPID 0x0128 + propertyTagPageNumber* = PROPID 0x0129 + propertyTagTransferFunction* = PROPID 0x012D + propertyTagSoftwareUsed* = PROPID 0x0131 + propertyTagDateTime* = PROPID 0x0132 + propertyTagArtist* = PROPID 0x013B + propertyTagHostComputer* = PROPID 0x013C + propertyTagPredictor* = PROPID 0x013D + propertyTagWhitePoint* = PROPID 0x013E + propertyTagPrimaryChromaticities* = PROPID 0x013F + propertyTagColorMap* = PROPID 0x0140 + propertyTagHalftoneHints* = PROPID 0x0141 + propertyTagTileWidth* = PROPID 0x0142 + propertyTagTileLength* = PROPID 0x0143 + propertyTagTileOffset* = PROPID 0x0144 + propertyTagTileByteCounts* = PROPID 0x0145 + propertyTagInkSet* = PROPID 0x014C + propertyTagInkNames* = PROPID 0x014D + propertyTagNumberOfInks* = PROPID 0x014E + propertyTagDotRange* = PROPID 0x0150 + propertyTagTargetPrinter* = PROPID 0x0151 + propertyTagExtraSamples* = PROPID 0x0152 + propertyTagSampleFormat* = PROPID 0x0153 + propertyTagSMinSampleValue* = PROPID 0x0154 + propertyTagSMaxSampleValue* = PROPID 0x0155 + propertyTagTransferRange* = PROPID 0x0156 + propertyTagJPEGProc* = PROPID 0x0200 + propertyTagJPEGInterFormat* = PROPID 0x0201 + propertyTagJPEGInterLength* = PROPID 0x0202 + propertyTagJPEGRestartInterval* = PROPID 0x0203 + propertyTagJPEGLosslessPredictors* = PROPID 0x0205 + propertyTagJPEGPointTransforms* = PROPID 0x0206 + propertyTagJPEGQTables* = PROPID 0x0207 + propertyTagJPEGDCTables* = PROPID 0x0208 + propertyTagJPEGACTables* = PROPID 0x0209 + propertyTagYCbCrCoefficients* = PROPID 0x0211 + propertyTagYCbCrSubsampling* = PROPID 0x0212 + propertyTagYCbCrPositioning* = PROPID 0x0213 + propertyTagREFBlackWhite* = PROPID 0x0214 + propertyTagGamma* = PROPID 0x0301 + propertyTagICCProfileDescriptor* = PROPID 0x0302 + propertyTagSRGBRenderingIntent* = PROPID 0x0303 + propertyTagImageTitle* = PROPID 0x0320 + propertyTagResolutionXUnit* = PROPID 0x5001 + propertyTagResolutionYUnit* = PROPID 0x5002 + propertyTagResolutionXLengthUnit* = PROPID 0x5003 + propertyTagResolutionYLengthUnit* = PROPID 0x5004 + propertyTagPrintFlags* = PROPID 0x5005 + propertyTagPrintFlagsVersion* = PROPID 0x5006 + propertyTagPrintFlagsCrop* = PROPID 0x5007 + propertyTagPrintFlagsBleedWidth* = PROPID 0x5008 + propertyTagPrintFlagsBleedWidthScale* = PROPID 0x5009 + propertyTagHalftoneLPI* = PROPID 0x500A + propertyTagHalftoneLPIUnit* = PROPID 0x500B + propertyTagHalftoneDegree* = PROPID 0x500C + propertyTagHalftoneShape* = PROPID 0x500D + propertyTagHalftoneMisc* = PROPID 0x500E + propertyTagHalftoneScreen* = PROPID 0x500F + propertyTagJPEGQuality* = PROPID 0x5010 + propertyTagGridSize* = PROPID 0x5011 + propertyTagThumbnailFormat* = PROPID 0x5012 + propertyTagThumbnailWidth* = PROPID 0x5013 + propertyTagThumbnailHeight* = PROPID 0x5014 + propertyTagThumbnailColorDepth* = PROPID 0x5015 + propertyTagThumbnailPlanes* = PROPID 0x5016 + propertyTagThumbnailRawBytes* = PROPID 0x5017 + propertyTagThumbnailSize* = PROPID 0x5018 + propertyTagThumbnailCompressedSize* = PROPID 0x5019 + propertyTagColorTransferFunction* = PROPID 0x501A + propertyTagThumbnailData* = PROPID 0x501B + propertyTagThumbnailImageWidth* = PROPID 0x5020 + propertyTagThumbnailImageHeight* = PROPID 0x5021 + propertyTagThumbnailBitsPerSample* = PROPID 0x5022 + propertyTagThumbnailCompression* = PROPID 0x5023 + propertyTagThumbnailPhotometricInterp* = PROPID 0x5024 + propertyTagThumbnailImageDescription* = PROPID 0x5025 + propertyTagThumbnailEquipMake* = PROPID 0x5026 + propertyTagThumbnailEquipModel* = PROPID 0x5027 + propertyTagThumbnailStripOffsets* = PROPID 0x5028 + propertyTagThumbnailOrientation* = PROPID 0x5029 + propertyTagThumbnailSamplesPerPixel* = PROPID 0x502A + propertyTagThumbnailRowsPerStrip* = PROPID 0x502B + propertyTagThumbnailStripBytesCount* = PROPID 0x502C + propertyTagThumbnailResolutionX* = PROPID 0x502D + propertyTagThumbnailResolutionY* = PROPID 0x502E + propertyTagThumbnailPlanarConfig* = PROPID 0x502F + propertyTagThumbnailResolutionUnit* = PROPID 0x5030 + propertyTagThumbnailTransferFunction* = PROPID 0x5031 + propertyTagThumbnailSoftwareUsed* = PROPID 0x5032 + propertyTagThumbnailDateTime* = PROPID 0x5033 + propertyTagThumbnailArtist* = PROPID 0x5034 + propertyTagThumbnailWhitePoint* = PROPID 0x5035 + propertyTagThumbnailPrimaryChromaticities* = PROPID 0x5036 + propertyTagThumbnailYCbCrCoefficients* = PROPID 0x5037 + propertyTagThumbnailYCbCrSubsampling* = PROPID 0x5038 + propertyTagThumbnailYCbCrPositioning* = PROPID 0x5039 + propertyTagThumbnailRefBlackWhite* = PROPID 0x503A + propertyTagThumbnailCopyRight* = PROPID 0x503B + propertyTagLuminanceTable* = PROPID 0x5090 + propertyTagChrominanceTable* = PROPID 0x5091 + propertyTagFrameDelay* = PROPID 0x5100 + propertyTagLoopCount* = PROPID 0x5101 + propertyTagGlobalPalette* = PROPID 0x5102 + propertyTagIndexBackground* = PROPID 0x5103 + propertyTagIndexTransparent* = PROPID 0x5104 + propertyTagPixelUnit* = PROPID 0x5110 + propertyTagPixelPerUnitX* = PROPID 0x5111 + propertyTagPixelPerUnitY* = PROPID 0x5112 + propertyTagPaletteHistogram* = PROPID 0x5113 + propertyTagCopyright* = PROPID 0x8298 + propertyTagExifExposureTime* = PROPID 0x829A + propertyTagExifFNumber* = PROPID 0x829D + propertyTagExifIFD* = PROPID 0x8769 + propertyTagICCProfile* = PROPID 0x8773 + propertyTagExifExposureProg* = PROPID 0x8822 + propertyTagExifSpectralSense* = PROPID 0x8824 + propertyTagGpsIFD* = PROPID 0x8825 + propertyTagExifISOSpeed* = PROPID 0x8827 + propertyTagExifOECF* = PROPID 0x8828 + propertyTagExifVer* = PROPID 0x9000 + propertyTagExifDTOrig* = PROPID 0x9003 + propertyTagExifDTDigitized* = PROPID 0x9004 + propertyTagExifCompConfig* = PROPID 0x9101 + propertyTagExifCompBPP* = PROPID 0x9102 + propertyTagExifShutterSpeed* = PROPID 0x9201 + propertyTagExifAperture* = PROPID 0x9202 + propertyTagExifBrightness* = PROPID 0x9203 + propertyTagExifExposureBias* = PROPID 0x9204 + propertyTagExifMaxAperture* = PROPID 0x9205 + propertyTagExifSubjectDist* = PROPID 0x9206 + propertyTagExifMeteringMode* = PROPID 0x9207 + propertyTagExifLightSource* = PROPID 0x9208 + propertyTagExifFlash* = PROPID 0x9209 + propertyTagExifFocalLength* = PROPID 0x920A + propertyTagExifMakerNote* = PROPID 0x927C + propertyTagExifUserComment* = PROPID 0x9286 + propertyTagExifDTSubsec* = PROPID 0x9290 + propertyTagExifDTOrigSS* = PROPID 0x9291 + propertyTagExifDTDigSS* = PROPID 0x9292 + propertyTagExifFPXVer* = PROPID 0xA000 + propertyTagExifColorSpace* = PROPID 0xA001 + propertyTagExifPixXDim* = PROPID 0xA002 + propertyTagExifPixYDim* = PROPID 0xA003 + propertyTagExifRelatedWav* = PROPID 0xA004 + propertyTagExifInterop* = PROPID 0xA005 + propertyTagExifFlashEnergy* = PROPID 0xA20B + propertyTagExifSpatialFR* = PROPID 0xA20C + propertyTagExifFocalXRes* = PROPID 0xA20E + propertyTagExifFocalYRes* = PROPID 0xA20F + propertyTagExifFocalResUnit* = PROPID 0xA210 + propertyTagExifSubjectLoc* = PROPID 0xA214 + propertyTagExifExposureIndex* = PROPID 0xA215 + propertyTagExifSensingMethod* = PROPID 0xA217 + propertyTagExifFileSource* = PROPID 0xA300 + propertyTagExifSceneType* = PROPID 0xA301 + propertyTagExifCfaPattern* = PROPID 0xA302 + propertyTagTypeByte* = WORD 1 + propertyTagTypeASCII* = WORD 2 + propertyTagTypeShort* = WORD 3 + propertyTagTypeLong* = WORD 4 + propertyTagTypeRational* = WORD 5 + propertyTagTypeUndefined* = WORD 7 + propertyTagTypeSLONG* = WORD 9 + propertyTagTypeSRational* = WORD 10 + GDIP_EMFPLUSFLAGS_DISPLAY* = UINT 1 + pixelFormatIndexed* = INT 0x00010000 + pixelFormatGDI* = INT 0x00020000 + pixelFormatAlpha* = INT 0x00040000 + pixelFormatPAlpha* = INT 0x00080000 + pixelFormatExtended* = INT 0x00100000 + pixelFormatCanonical* = INT 0x00200000 + pixelFormatUndefined* = INT 0 + pixelFormatDontCare* = INT 0 + pixelFormat1bppIndexed* = INT(1 or (1 shl 8) or pixelFormatIndexed or pixelFormatGDI) + pixelFormat4bppIndexed* = INT(2 or (4 shl 8) or pixelFormatIndexed or pixelFormatGDI) + pixelFormat8bppIndexed* = INT(3 or (8 shl 8) or pixelFormatIndexed or pixelFormatGDI) + pixelFormat16bppGrayScale* = INT(4 or (16 shl 8) or pixelFormatExtended) + pixelFormat16bppRGB555* = INT(5 or (16 shl 8) or pixelFormatGDI) + pixelFormat16bppRGB565* = INT(6 or (16 shl 8) or pixelFormatGDI) + pixelFormat16bppARGB1555* = INT(7 or (16 shl 8) or pixelFormatAlpha or pixelFormatGDI) + pixelFormat24bppRGB* = INT(8 or (24 shl 8) or pixelFormatGDI) + pixelFormat32bppRGB* = INT(9 or (32 shl 8) or pixelFormatGDI) + pixelFormat32bppARGB* = INT(10 or (32 shl 8) or pixelFormatAlpha or pixelFormatGDI or pixelFormatCanonical) + pixelFormat32bppPARGB* = INT(11 or (32 shl 8) or pixelFormatAlpha or pixelFormatPAlpha or pixelFormatGDI) + pixelFormat48bppRGB* = INT(12 or (48 shl 8) or pixelFormatExtended) + pixelFormat64bppARGB* = INT(13 or (64 shl 8) or pixelFormatAlpha or pixelFormatCanonical or pixelFormatExtended) + pixelFormat64bppPARGB* = INT(14 or (64 shl 8) or pixelFormatAlpha or pixelFormatPAlpha or pixelFormatExtended) + pixelFormatMax* = INT 15 + paletteFlagsHasAlpha* = 1 + paletteFlagsGrayScale* = 2 + paletteFlagsHalftone* = 4 + paletteTypeCustom* = 0 + paletteTypeOptimal* = 1 + paletteTypeFixedBW* = 2 + paletteTypeFixedHalftone8* = 3 + paletteTypeFixedHalftone27* = 4 + paletteTypeFixedHalftone64* = 5 + paletteTypeFixedHalftone125* = 6 + paletteTypeFixedHalftone216* = 7 + paletteTypeFixedHalftone252* = 8 + paletteTypeFixedHalftone256* = 9 + colorChannelFlagsC* = 0 + colorChannelFlagsM* = 1 + colorChannelFlagsY* = 2 + colorChannelFlagsK* = 3 + colorChannelFlagsLast* = 4 + colorAdjustTypeDefault* = 0 + colorAdjustTypeBitmap* = 1 + colorAdjustTypeBrush* = 2 + colorAdjustTypePen* = 3 + colorAdjustTypeText* = 4 + colorAdjustTypeCount* = 5 + colorAdjustTypeAny* = 6 + colorMatrixFlagsDefault* = 0 + colorMatrixFlagsSkipGrays* = 1 + colorMatrixFlagsAltGray* = 2 + histogramFormatARGB* = 0 + histogramFormatPARGB* = 1 + histogramFormatRGB* = 2 + histogramFormatGray* = 3 + histogramFormatB* = 4 + histogramFormatG* = 5 + histogramFormatR* = 6 + histogramFormatA* = 7 + adjustExposure* = 0 + adjustDensity* = 1 + adjustContrast* = 2 + adjustHighlight* = 3 + adjustShadow* = 4 + adjustMidtone* = 5 + adjustWhiteSaturation* = 6 + adjustBlackSaturation* = 7 + curveChannelAll* = 0 + curveChannelRed* = 1 + curveChannelGreen* = 2 + curveChannelBlue* = 3 + EncoderChrominanceTable* = DEFINE_GUID(0xF2E455DC'i32, 0x09B3, 0x4316, [0x82'u8,0x60,0x67,0x6A,0xDA,0x32,0x48,0x1C]) + EncoderColorDepth* = DEFINE_GUID(0x66087055'i32, 0xAD66, 0x4C7C, [0x9A'u8,0x18,0x38,0xA2,0x31,0x0B,0x83,0x37]) + EncoderCompression* = DEFINE_GUID(0xE09D739D'i32, 0xCCD4, 0x44EE, [0x8E'u8,0xBA,0x3F,0xBF,0x8B,0xE4,0xFC,0x58]) + EncoderLuminanceTable* = DEFINE_GUID(0xEDB33BCE'i32, 0x0266, 0x4A77, [0xB9'u8,0x04,0x27,0x21,0x60,0x99,0xE7,0x17]) + EncoderQuality* = DEFINE_GUID(0x1D5BE4B5'i32, 0xFA4A, 0x452D, [0x9C'u8,0xDD,0x5D,0xB3,0x51,0x05,0xE7,0xEB]) + EncoderRenderMethod* = DEFINE_GUID(0x6D42C53A'i32, 0x229A, 0x4825, [0x8B'u8,0xB7,0x5C,0x99,0xE2,0xB9,0xA8,0xB8]) + EncoderSaveFlag* = DEFINE_GUID(0x292266FC'i32, 0xAC40, 0x47BF, [0x8C'u8,0xFC,0xA8,0x5B,0x89,0xA6,0x55,0xDE]) + EncoderScanMethod* = DEFINE_GUID(0x3A4E2661'i32, 0x3109, 0x4E56, [0x85'u8,0x36,0x42,0xC1,0x56,0xE7,0xDC,0xFA]) + EncoderTransformation* = DEFINE_GUID(0x8D0EB2D1'i32, 0xA58E, 0x4EA8, [0xAA'u8,0x14,0x10,0x80,0x74,0xB7,0xB6,0xF9]) + EncoderVersion* = DEFINE_GUID(0x24D18C76'i32, 0x814A, 0x41A4, [0xBF'u8,0x53,0x1C,0x21,0x9C,0xCC,0xF7,0x97]) + ImageFormatBMP* = DEFINE_GUID(0xB96B3CAB'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatEMF* = DEFINE_GUID(0xB96B3CAC'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatGIF* = DEFINE_GUID(0xB96B3CB0'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatIcon* = DEFINE_GUID(0xB96B3CB5'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatJPEG* = DEFINE_GUID(0xB96B3CAE'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatMemoryBMP* = DEFINE_GUID(0xB96B3CAA'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatPNG* = DEFINE_GUID(0xB96B3CAF'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatTIFF* = DEFINE_GUID(0xB96B3CB1'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + ImageFormatWMF* = DEFINE_GUID(0xB96B3CAD'i32, 0x0728, 0x11D3, [0x9D'u8,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E]) + FrameDimensionPage* = DEFINE_GUID(0x7462DC86'i32, 0x6180, 0x4C7E, [0x8E'u8,0x3F,0xEE,0x73,0x33,0xA7,0xA4,0x83]) + FrameDimensionTime* = DEFINE_GUID(0x6AEDBD6D'i32, 0x3FB5, 0x418A, [0x83'u8,0xA6,0x7F,0x45,0x22,0x9D,0xC8,0x72]) + BlurEffectGuid* = DEFINE_GUID(0x633C80A4'i32, 0x1843, 0x482B, [0x9E'u8,0xF2,0xBE,0x28,0x34,0xC5,0xFD,0xD4]) + BrightnessContrastEffectGuid* = DEFINE_GUID(0xD3A1DBE1'i32, 0x8EC4, 0x4C17, [0x9F'u8,0x4C,0xEA,0x97,0xAD,0x1C,0x34,0x3D]) + ColorBalanceEffectGuid* = DEFINE_GUID(0x537E597D'i32, 0x251E, 0x48DA, [0x96'u8,0x64,0x29,0xCA,0x49,0x6B,0x70,0xF8]) + ColorCurveEffectGuid* = DEFINE_GUID(0xDD6A0022'i32, 0x58E4, 0x4A67, [0x9D'u8,0x9B,0xD4,0x8E,0xB8,0x81,0xA5,0x3D]) + ColorLookupTableEffectGuid* = DEFINE_GUID(0xA7CE72A9'i32, 0x0F7F, 0x40D7, [0xB3'u8,0xCC,0xD0,0xC0,0x2D,0x5C,0x32,0x12]) + ColorMatrixEffectGuid* = DEFINE_GUID(0x718F2615'i32, 0x7933, 0x40E3, [0xA5'u8,0x11,0x5F,0x68,0xFE,0x14,0xDD,0x74]) + HueSaturationLightnessEffectGuid* = DEFINE_GUID(0x8B2DD6C3'i32, 0xEB07, 0x4D87, [0xA5'u8,0xF0,0x71,0x08,0xE2,0x6A,0x9C,0x5F]) + LevelsEffectGuid* = DEFINE_GUID(0x99C354EC'i32, 0x2A31, 0x4F3A, [0x8C'u8,0x34,0x17,0xA8,0x03,0xB3,0x3A,0x25]) + RedEyeCorrectionEffectGuid* = DEFINE_GUID(0x74D29D05'i32, 0x69A4, 0x4266, [0x95'u8,0x49,0x3C,0xC5,0x28,0x36,0xB6,0x32]) + SharpenEffectGuid* = DEFINE_GUID(0x63CBF3EE'i32, 0xC526, 0x402C, [0x8F'u8,0x71,0x62,0xC5,0x40,0xBF,0x51,0x42]) + TintEffectGuid* = DEFINE_GUID(0x1077AF00'i32, 0x2848, 0x4441, [0x94'u8,0x89,0x44,0xAD,0x4C,0x2D,0x7A,0x2C]) +type + EnumerateMetafileProc* = proc (P1: EmfPlusRecordType, P2: UINT, P3: UINT, P4: ptr BYTE, P5: pointer): BOOL {.stdcall.} + NotificationHookProc* = proc (token: ptr ULONG_PTR): GpStatus {.stdcall.} + NotificationUnhookProc* = proc (token: ULONG_PTR): VOID {.stdcall.} + GpSize* {.pure.} = object + Width*: INT + Height*: INT + GpSizeF* {.pure.} = object + Width*: REAL + Height*: REAL + GpPoint* {.pure.} = object + X*: INT + Y*: INT + GpPointF* {.pure.} = object + X*: REAL + Y*: REAL + GpRect* {.pure.} = object + X*: INT + Y*: INT + Width*: INT + Height*: INT + GpRectF* {.pure.} = object + X*: REAL + Y*: REAL + Width*: REAL + Height*: REAL + GdiplusAbort* {.pure.} = object + CharacterRange* {.pure.} = object + First*: INT + Length*: INT + PathData* {.pure.} = object + Count*: INT + Points*: ptr GpPointF + Types*: ptr BYTE + BitmapData* {.pure.} = object + Width*: UINT + Height*: UINT + Stride*: INT + PixelFormat*: INT + Scan0*: pointer + Reserved*: UINT_PTR + EncoderParameter* {.pure.} = object + Guid*: GUID + NumberOfValues*: ULONG + Type*: ULONG + Value*: pointer + EncoderParameters* {.pure.} = object + Count*: UINT + Parameter*: array[1, EncoderParameter] + ImageCodecInfo* {.pure.} = object + Clsid*: CLSID + FormatID*: GUID + CodecName*: ptr WCHAR + DllName*: ptr WCHAR + FormatDescription*: ptr WCHAR + FilenameExtension*: ptr WCHAR + MimeType*: ptr WCHAR + Flags*: DWORD + Version*: DWORD + SigCount*: DWORD + SigSize*: DWORD + SigPattern*: ptr BYTE + SigMask*: ptr BYTE + ImageItemData* {.pure.} = object + Size*: UINT + Position*: UINT + Desc*: pointer + DescSize*: UINT + Data*: ptr UINT + DataSize*: UINT + Cookie*: UINT + PropertyItem* {.pure.} = object + id*: PROPID + length*: ULONG + `type`*: WORD + value*: pointer + GdiplusStartupInput* {.pure.} = object + GdiplusVersion*: UINT32 + DebugEventCallback*: DebugEventProc + SuppressBackgroundThread*: BOOL + SuppressExternalCodecs*: BOOL + GdiplusStartupOutput* {.pure.} = object + NotificationHook*: NotificationHookProc + NotificationUnhook*: NotificationUnhookProc + PWMFRect16* {.pure.} = object + Left*: INT16 + Top*: INT16 + Right*: INT16 + Bottom*: INT16 + WmfPlaceableFileHeader* {.pure.} = object + Key*: UINT32 + Hmf*: INT16 + BoundingBox*: PWMFRect16 + Inch*: INT16 + Reserved*: UINT32 + Checksum*: INT16 + MetafileHeader_UNION1* {.pure, union.} = object + WmfHeader*: METAHEADER + EmfHeader*: ENHMETAHEADER3 + MetafileHeader* {.pure.} = object + Type*: MetafileType + Size*: UINT + Version*: UINT + EmfPlusFlags*: UINT + DpiX*: REAL + DpiY*: REAL + X*: INT + Y*: INT + Width*: INT + Height*: INT + union1*: MetafileHeader_UNION1 + EmfPlusHeaderSize*: INT + LogicalDpiX*: INT + LogicalDpiY*: INT + ColorPalette* {.pure.} = object + Flags*: UINT + Count*: UINT + Entries*: array[1, ARGB] + Color* {.pure.} = object + Value*: ARGB + GpColorMap* {.pure.} = object + oldColor*: Color + newColor*: Color + ColorMatrix* {.pure.} = object + m*: array[5, array[5, REAL]] + BlurParams* {.pure.} = object + radius*: REAL + expandEdge*: BOOL + BrightnessContrastParams* {.pure.} = object + brightnessLevel*: INT + contrastLevel*: INT + ColorBalanceParams* {.pure.} = object + cyanRed*: INT + magentaGreen*: INT + yellowBlue*: INT + ColorCurveParams* {.pure.} = object + adjustment*: CurveAdjustments + channel*: CurveChannel + adjustValue*: INT + ColorLUTParams* {.pure.} = object + lutB*: ColorChannelLUT + lutG*: ColorChannelLUT + lutR*: ColorChannelLUT + lutA*: ColorChannelLUT + HueSaturationLightnessParams* {.pure.} = object + hueLevel*: INT + saturationLevel*: INT + lightnessLevel*: INT + LevelsParams* {.pure.} = object + highlight*: INT + midtone*: INT + shadow*: INT + RedEyeCorrectionParams* {.pure.} = object + numberOfAreas*: UINT + areas*: ptr RECT + SharpenParams* {.pure.} = object + radius*: REAL + amount*: REAL + TintParams* {.pure.} = object + hue*: INT + amount*: INT + CGpEffect* {.pure.} = object + GpAdjustableArrowCap* {.pure.} = object + GpBitmap* {.pure.} = object + GpBrush* {.pure.} = object + GpCachedBitmap* {.pure.} = object + GpCustomLineCap* {.pure.} = object + GpFont* {.pure.} = object + GpFontFamily* {.pure.} = object + GpFontCollection* {.pure.} = object + GpGraphics* {.pure.} = object + GpHatch* {.pure.} = object + GpImage* {.pure.} = object + GpImageAttributes* {.pure.} = object + GpLineGradient* {.pure.} = object + GpMatrix* {.pure.} = object + GpMetafile* {.pure.} = object + GpPath* {.pure.} = object + GpPathData* {.pure.} = object + GpPathGradient* {.pure.} = object + GpPathIterator* {.pure.} = object + GpPen* {.pure.} = object + GpRegion* {.pure.} = object + GpSolidFill* {.pure.} = object + GpStringFormat* {.pure.} = object + GpTexture* {.pure.} = object +proc GdiplusStartup*(token: ptr ULONG_PTR, input: ptr GdiplusStartupInput, output: ptr GdiplusStartupOutput): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdiplusShutdown*(token: ULONG_PTR): VOID {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdiplusNotificationHook*(token: ptr ULONG_PTR): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdiplusNotificationUnhook*(token: ULONG_PTR): VOID {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFree*(`ptr`: pointer): VOID {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateAdjustableArrowCap*(height: REAL, width: REAL, isFilled: BOOL, cap: ptr ptr GpAdjustableArrowCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetAdjustableArrowCapHeight*(cap: ptr GpAdjustableArrowCap, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetAdjustableArrowCapHeight*(cap: ptr GpAdjustableArrowCap, height: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetAdjustableArrowCapWidth*(cap: ptr GpAdjustableArrowCap, width: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetAdjustableArrowCapWidth*(cap: ptr GpAdjustableArrowCap, width: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetAdjustableArrowCapMiddleInset*(cap: ptr GpAdjustableArrowCap, middleInset: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetAdjustableArrowCapMiddleInset*(cap: ptr GpAdjustableArrowCap, middleInset: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetAdjustableArrowCapFillState*(cap: ptr GpAdjustableArrowCap, fillState: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetAdjustableArrowCapFillState*(cap: ptr GpAdjustableArrowCap, fillState: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromStream*(stream: ptr IStream, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromFile*(filename: ptr WCHAR, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromStreamICM*(stream: ptr IStream, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromFileICM*(filename: ptr WCHAR, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromScan0*(width: INT, height: INT, stride: INT, format: PixelFormat, scan0: ptr BYTE, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromGraphics*(width: INT, height: INT, target: ptr GpGraphics, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromGdiDib*(gdiBitmapInfo: ptr BITMAPINFO, gdiBitmapData: pointer, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromHBITMAP*(hbm: HBITMAP, hpal: HPALETTE, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateHBITMAPFromBitmap*(bitmap: ptr GpBitmap, hbmReturn: ptr HBITMAP, background: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromHICON*(hicon: HICON, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateHICONFromBitmap*(bitmap: ptr GpBitmap, hbmReturn: ptr HICON): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateBitmapFromResource*(hInstance: HINSTANCE, lpBitmapName: ptr WCHAR, bitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneBitmapArea*(x: REAL, y: REAL, width: REAL, height: REAL, format: PixelFormat, srcBitmap: ptr GpBitmap, dstBitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneBitmapAreaI*(x: INT, y: INT, width: INT, height: INT, format: PixelFormat, srcBitmap: ptr GpBitmap, dstBitmap: ptr ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapLockBits*(bitmap: ptr GpBitmap, rect: ptr GpRect, flags: UINT, format: PixelFormat, lockedBitmapData: ptr BitmapData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapUnlockBits*(bitmap: ptr GpBitmap, lockedBitmapData: ptr BitmapData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapGetPixel*(bitmap: ptr GpBitmap, x: INT, y: INT, color: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapSetPixel*(bitmap: ptr GpBitmap, x: INT, y: INT, color: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapSetResolution*(bitmap: ptr GpBitmap, xdpi: REAL, ydpi: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapConvertFormat*(pInputBitmap: ptr GpBitmap, format: PixelFormat, dithertype: DitherType, palettetype: PaletteType, palette: ptr ColorPalette, alphaThresholdPercent: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipInitializePalette*(palette: ptr ColorPalette, palettetype: PaletteType, optimalColors: INT, useTransparentColor: BOOL, bitmap: ptr GpBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapApplyEffect*(bitmap: ptr GpBitmap, effect: ptr CGpEffect, roi: ptr RECT, useAuxData: BOOL, auxData: ptr pointer, auxDataSize: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapCreateApplyEffect*(inputBitmaps: ptr ptr GpBitmap, numInputs: INT, effect: ptr CGpEffect, roi: ptr RECT, outputRect: ptr RECT, outputBitmap: ptr ptr GpBitmap, useAuxData: BOOL, auxData: ptr pointer, auxDataSize: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapGetHistogram*(bitmap: ptr GpBitmap, format: HistogramFormat, NumberOfEntries: UINT, channel0: ptr UINT, channel1: ptr UINT, channel2: ptr UINT, channel3: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBitmapGetHistogramSize*(format: HistogramFormat, NumberOfEntries: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneBrush*(brush: ptr GpBrush, cloneBrush: ptr ptr GpBrush): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteBrush*(brush: ptr GpBrush): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetBrushType*(brush: ptr GpBrush, Type: ptr GpBrushType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateCachedBitmap*(bitmap: ptr GpBitmap, graphics: ptr GpGraphics, cachedBitmap: ptr ptr GpCachedBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteCachedBitmap*(cachedBitmap: ptr GpCachedBitmap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCachedBitmap*(graphics: ptr GpGraphics, cachedBitmap: ptr GpCachedBitmap, x: INT, y: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateCustomLineCap*(fillPath: ptr GpPath, strokePath: ptr GpPath, baseCap: GpLineCap, baseInset: REAL, customCap: ptr ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteCustomLineCap*(customCap: ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneCustomLineCap*(customCap: ptr GpCustomLineCap, clonedCap: ptr ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapType*(customCap: ptr GpCustomLineCap, capType: ptr CustomLineCapType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCustomLineCapStrokeCaps*(customCap: ptr GpCustomLineCap, startCap: GpLineCap, endCap: GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapStrokeCaps*(customCap: ptr GpCustomLineCap, startCap: ptr GpLineCap, endCap: ptr GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCustomLineCapStrokeJoin*(customCap: ptr GpCustomLineCap, lineJoin: GpLineJoin): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapStrokeJoin*(customCap: ptr GpCustomLineCap, lineJoin: ptr GpLineJoin): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCustomLineCapBaseCap*(customCap: ptr GpCustomLineCap, baseCap: GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapBaseCap*(customCap: ptr GpCustomLineCap, baseCap: ptr GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCustomLineCapBaseInset*(customCap: ptr GpCustomLineCap, inset: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapBaseInset*(customCap: ptr GpCustomLineCap, inset: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCustomLineCapWidthScale*(customCap: ptr GpCustomLineCap, widthScale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCustomLineCapWidthScale*(customCap: ptr GpCustomLineCap, widthScale: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateEffect*(guid: GUID, effect: ptr ptr CGpEffect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteEffect*(effect: ptr CGpEffect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetEffectParameterSize*(effect: ptr CGpEffect, size: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetEffectParameters*(effect: ptr CGpEffect, params: pointer, size: UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetEffectParameters*(effect: ptr CGpEffect, size: ptr UINT, params: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFontFromDC*(hdc: HDC, font: ptr ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFontFromLogfontA*(hdc: HDC, logfont: ptr LOGFONTA, font: ptr ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFontFromLogfontW*(hdc: HDC, logfont: ptr LOGFONTW, font: ptr ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFont*(fontFamily: ptr GpFontFamily, emSize: REAL, style: INT, unit: GpUnit, font: ptr ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneFont*(font: ptr GpFont, cloneFont: ptr ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteFont*(font: ptr GpFont): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFamily*(font: ptr GpFont, family: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontStyle*(font: ptr GpFont, style: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontSize*(font: ptr GpFont, size: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontUnit*(font: ptr GpFont, unit: ptr GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontHeight*(font: ptr GpFont, graphics: ptr GpGraphics, height: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontHeightGivenDPI*(font: ptr GpFont, dpi: REAL, height: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLogFontA*(font: ptr GpFont, graphics: ptr GpGraphics, logfontA: ptr LOGFONTA): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLogFontW*(font: ptr GpFont, graphics: ptr GpGraphics, logfontW: ptr LOGFONTW): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipNewInstalledFontCollection*(fontCollection: ptr ptr GpFontCollection): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipNewPrivateFontCollection*(fontCollection: ptr ptr GpFontCollection): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeletePrivateFontCollection*(fontCollection: ptr ptr GpFontCollection): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontCollectionFamilyCount*(fontCollection: ptr GpFontCollection, numFound: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFontCollectionFamilyList*(fontCollection: ptr GpFontCollection, numSought: INT, gpfamilies: ptr ptr GpFontFamily, numFound: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPrivateAddFontFile*(fontCollection: ptr GpFontCollection, filename: ptr WCHAR): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPrivateAddMemoryFont*(fontCollection: ptr GpFontCollection, memory: pointer, length: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFontFamilyFromName*(name: ptr WCHAR, fontCollection: ptr GpFontCollection, FontFamily: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteFontFamily*(fontFamily: ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneFontFamily*(FontFamily: ptr GpFontFamily, clonedFontFamily: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetGenericFontFamilySansSerif*(nativeFamily: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetGenericFontFamilySerif*(nativeFamily: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetGenericFontFamilyMonospace*(nativeFamily: ptr ptr GpFontFamily): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetFamilyName*(family: ptr GpFontFamily, name: ptr WCHAR, language: LANGID): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsStyleAvailable*(family: ptr GpFontFamily, style: INT, IsStyleAvailable: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetEmHeight*(family: ptr GpFontFamily, style: INT, EmHeight: ptr UINT16): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCellAscent*(family: ptr GpFontFamily, style: INT, CellAscent: ptr UINT16): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCellDescent*(family: ptr GpFontFamily, style: INT, CellDescent: ptr UINT16): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineSpacing*(family: ptr GpFontFamily, style: INT, LineSpacing: ptr UINT16): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFlush*(graphics: ptr GpGraphics, intention: GpFlushIntention): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFromHDC*(hdc: HDC, graphics: ptr ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFromHDC2*(hdc: HDC, hDevice: HANDLE, graphics: ptr ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFromHWND*(hwnd: HWND, graphics: ptr ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateFromHWNDICM*(hwnd: HWND, graphics: ptr ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteGraphics*(graphics: ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetDC*(graphics: ptr GpGraphics, hdc: ptr HDC): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipReleaseDC*(graphics: ptr GpGraphics, hdc: HDC): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCompositingMode*(graphics: ptr GpGraphics, compositingMode: CompositingMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCompositingMode*(graphics: ptr GpGraphics, compositingMode: ptr CompositingMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetRenderingOrigin*(graphics: ptr GpGraphics, x: INT, y: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRenderingOrigin*(graphics: ptr GpGraphics, x: ptr INT, y: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetCompositingQuality*(graphics: ptr GpGraphics, compositingQuality: CompositingQuality): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetCompositingQuality*(graphics: ptr GpGraphics, compositingQuality: ptr CompositingQuality): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetSmoothingMode*(graphics: ptr GpGraphics, smoothingMode: SmoothingMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetSmoothingMode*(graphics: ptr GpGraphics, smoothingMode: ptr SmoothingMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPixelOffsetMode*(graphics: ptr GpGraphics, pixelOffsetMode: PixelOffsetMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPixelOffsetMode*(graphics: ptr GpGraphics, pixelOffsetMode: ptr PixelOffsetMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetTextRenderingHint*(graphics: ptr GpGraphics, mode: TextRenderingHint): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetTextRenderingHint*(graphics: ptr GpGraphics, mode: ptr TextRenderingHint): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetTextContrast*(graphics: ptr GpGraphics, contrast: UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetTextContrast*(graphics: ptr GpGraphics, contrast: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetInterpolationMode*(graphics: ptr GpGraphics, interpolationMode: InterpolationMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGraphicsSetAbort*(pGraphics: ptr GpGraphics, pIAbort: ptr GdiplusAbort): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetInterpolationMode*(graphics: ptr GpGraphics, interpolationMode: ptr InterpolationMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetWorldTransform*(graphics: ptr GpGraphics, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetWorldTransform*(graphics: ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyWorldTransform*(graphics: ptr GpGraphics, matrix: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateWorldTransform*(graphics: ptr GpGraphics, dx: REAL, dy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScaleWorldTransform*(graphics: ptr GpGraphics, sx: REAL, sy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotateWorldTransform*(graphics: ptr GpGraphics, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetWorldTransform*(graphics: ptr GpGraphics, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetPageTransform*(graphics: ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPageUnit*(graphics: ptr GpGraphics, unit: ptr GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPageScale*(graphics: ptr GpGraphics, scale: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPageUnit*(graphics: ptr GpGraphics, unit: GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPageScale*(graphics: ptr GpGraphics, scale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetDpiX*(graphics: ptr GpGraphics, dpi: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetDpiY*(graphics: ptr GpGraphics, dpi: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformPoints*(graphics: ptr GpGraphics, destSpace: GpCoordinateSpace, srcSpace: GpCoordinateSpace, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformPointsI*(graphics: ptr GpGraphics, destSpace: GpCoordinateSpace, srcSpace: GpCoordinateSpace, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetNearestColor*(graphics: ptr GpGraphics, argb: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateHalftonePalette*(): HPALETTE {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawLine*(graphics: ptr GpGraphics, pen: ptr GpPen, x1: REAL, y1: REAL, x2: REAL, y2: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawLineI*(graphics: ptr GpGraphics, pen: ptr GpPen, x1: INT, y1: INT, x2: INT, y2: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawLines*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawLinesI*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawArc*(graphics: ptr GpGraphics, pen: ptr GpPen, x: REAL, y: REAL, width: REAL, height: REAL, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawArcI*(graphics: ptr GpGraphics, pen: ptr GpPen, x: INT, y: INT, width: INT, height: INT, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawBezier*(graphics: ptr GpGraphics, pen: ptr GpPen, x1: REAL, y1: REAL, x2: REAL, y2: REAL, x3: REAL, y3: REAL, x4: REAL, y4: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawBezierI*(graphics: ptr GpGraphics, pen: ptr GpPen, x1: INT, y1: INT, x2: INT, y2: INT, x3: INT, y3: INT, x4: INT, y4: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawBeziers*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawBeziersI*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawRectangle*(graphics: ptr GpGraphics, pen: ptr GpPen, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawRectangleI*(graphics: ptr GpGraphics, pen: ptr GpPen, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawRectangles*(graphics: ptr GpGraphics, pen: ptr GpPen, rects: ptr GpRectF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawRectanglesI*(graphics: ptr GpGraphics, pen: ptr GpPen, rects: ptr GpRect, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawEllipse*(graphics: ptr GpGraphics, pen: ptr GpPen, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawEllipseI*(graphics: ptr GpGraphics, pen: ptr GpPen, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawPie*(graphics: ptr GpGraphics, pen: ptr GpPen, x: REAL, y: REAL, width: REAL, height: REAL, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawPieI*(graphics: ptr GpGraphics, pen: ptr GpPen, x: INT, y: INT, width: INT, height: INT, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawPolygon*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawPolygonI*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawPath*(graphics: ptr GpGraphics, pen: ptr GpPen, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurve*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurveI*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurve2*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurve2I*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurve3*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT, offset: INT, numberOfSegments: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawCurve3I*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT, offset: INT, numberOfSegments: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawClosedCurve*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawClosedCurveI*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawClosedCurve2*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPointF, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawClosedCurve2I*(graphics: ptr GpGraphics, pen: ptr GpPen, points: ptr GpPoint, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGraphicsClear*(graphics: ptr GpGraphics, color: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillRectangle*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillRectangleI*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillRectangles*(graphics: ptr GpGraphics, brush: ptr GpBrush, rects: ptr GpRectF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillRectanglesI*(graphics: ptr GpGraphics, brush: ptr GpBrush, rects: ptr GpRect, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPolygon*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPointF, count: INT, fillMode: GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPolygonI*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPoint, count: INT, fillMode: GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPolygon2*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPolygon2I*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillEllipse*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillEllipseI*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPie*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: REAL, y: REAL, width: REAL, height: REAL, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPieI*(graphics: ptr GpGraphics, brush: ptr GpBrush, x: INT, y: INT, width: INT, height: INT, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillPath*(graphics: ptr GpGraphics, brush: ptr GpBrush, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillClosedCurve*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillClosedCurveI*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillClosedCurve2*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPointF, count: INT, tension: REAL, fillMode: GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillClosedCurve2I*(graphics: ptr GpGraphics, brush: ptr GpBrush, points: ptr GpPoint, count: INT, tension: REAL, fillMode: GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFillRegion*(graphics: ptr GpGraphics, brush: ptr GpBrush, region: ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImage*(graphics: ptr GpGraphics, image: ptr GpImage, x: REAL, y: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageI*(graphics: ptr GpGraphics, image: ptr GpImage, x: INT, y: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageRect*(graphics: ptr GpGraphics, image: ptr GpImage, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageRectI*(graphics: ptr GpGraphics, image: ptr GpImage, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePoints*(graphics: ptr GpGraphics, image: ptr GpImage, dstpoints: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePointsI*(graphics: ptr GpGraphics, image: ptr GpImage, dstpoints: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePointRect*(graphics: ptr GpGraphics, image: ptr GpImage, x: REAL, y: REAL, srcx: REAL, srcy: REAL, srcwidth: REAL, srcheight: REAL, srcUnit: GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePointRectI*(graphics: ptr GpGraphics, image: ptr GpImage, x: INT, y: INT, srcx: INT, srcy: INT, srcwidth: INT, srcheight: INT, srcUnit: GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageRectRect*(graphics: ptr GpGraphics, image: ptr GpImage, dstx: REAL, dsty: REAL, dstwidth: REAL, dstheight: REAL, srcx: REAL, srcy: REAL, srcwidth: REAL, srcheight: REAL, srcUnit: GpUnit, imageAttributes: ptr GpImageAttributes, callback: DrawImageAbort, callbackData: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageRectRectI*(graphics: ptr GpGraphics, image: ptr GpImage, dstx: INT, dsty: INT, dstwidth: INT, dstheight: INT, srcx: INT, srcy: INT, srcwidth: INT, srcheight: INT, srcUnit: GpUnit, imageAttributes: ptr GpImageAttributes, callback: DrawImageAbort, callbackData: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePointsRect*(graphics: ptr GpGraphics, image: ptr GpImage, points: ptr GpPointF, count: INT, srcx: REAL, srcy: REAL, srcwidth: REAL, srcheight: REAL, srcUnit: GpUnit, imageAttributes: ptr GpImageAttributes, callback: DrawImageAbort, callbackData: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImagePointsRectI*(graphics: ptr GpGraphics, image: ptr GpImage, points: ptr GpPoint, count: INT, srcx: INT, srcy: INT, srcwidth: INT, srcheight: INT, srcUnit: GpUnit, imageAttributes: ptr GpImageAttributes, callback: DrawImageAbort, callbackData: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawImageFX*(graphics: ptr GpGraphics, image: ptr GpImage, source: ptr GpRectF, xForm: ptr GpMatrix, effect: ptr CGpEffect, imageAttributes: ptr GpImageAttributes, srcUnit: GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipEnumerateMetafileDestPoints*(graphics: ptr GpGraphics, metafile: ptr GpMetafile, destPoints: ptr GpPointF, count: INT, callback: EnumerateMetafileProc, callbackData: pointer, imageAttributes: ptr GpImageAttributes): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipEnumerateMetafileDestPointsI*(graphics: ptr GpGraphics, metafile: ptr GpMetafile, destGpPoints: ptr GpPoint, count: INT, callback: EnumerateMetafileProc, callbackData: pointer, imageAttributes: ptr GpImageAttributes): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipGraphics*(graphics: ptr GpGraphics, srcgraphics: ptr GpGraphics, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipRect*(graphics: ptr GpGraphics, x: REAL, y: REAL, width: REAL, height: REAL, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipRectI*(graphics: ptr GpGraphics, x: INT, y: INT, width: INT, height: INT, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipPath*(graphics: ptr GpGraphics, path: ptr GpPath, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipRegion*(graphics: ptr GpGraphics, region: ptr GpRegion, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetClipHrgn*(graphics: ptr GpGraphics, hRgn: HRGN, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetClip*(graphics: ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateClip*(graphics: ptr GpGraphics, dx: REAL, dy: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateClipI*(graphics: ptr GpGraphics, dx: INT, dy: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetClip*(graphics: ptr GpGraphics, region: ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetClipBounds*(graphics: ptr GpGraphics, rect: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetClipBoundsI*(graphics: ptr GpGraphics, rect: ptr GpRect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsClipEmpty*(graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetVisibleClipBounds*(graphics: ptr GpGraphics, rect: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetVisibleClipBoundsI*(graphics: ptr GpGraphics, rect: ptr GpRect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleClipEmpty*(graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisiblePoint*(graphics: ptr GpGraphics, x: REAL, y: REAL, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisiblePointI*(graphics: ptr GpGraphics, x: INT, y: INT, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRect*(graphics: ptr GpGraphics, x: REAL, y: REAL, width: REAL, height: REAL, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRectI*(graphics: ptr GpGraphics, x: INT, y: INT, width: INT, height: INT, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSaveGraphics*(graphics: ptr GpGraphics, state: ptr GraphicsState): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRestoreGraphics*(graphics: ptr GpGraphics, state: GraphicsState): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBeginContainer*(graphics: ptr GpGraphics, dstrect: ptr GpRectF, srcrect: ptr GpRectF, unit: GpUnit, state: ptr GraphicsContainer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBeginContainerI*(graphics: ptr GpGraphics, dstrect: ptr GpRect, srcrect: ptr GpRect, unit: GpUnit, state: ptr GraphicsContainer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipBeginContainer2*(graphics: ptr GpGraphics, state: ptr GraphicsContainer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipEndContainer*(graphics: ptr GpGraphics, state: GraphicsContainer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipComment*(graphics: ptr GpGraphics, sizeData: UINT, data: ptr BYTE): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePath*(brushMode: GpFillMode, path: ptr ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePath2*(points: ptr GpPointF, types: ptr BYTE, count: INT, fillMode: GpFillMode, path: ptr ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePath2I*(points: ptr GpPoint, types: ptr BYTE, count: INT, fillMode: GpFillMode, path: ptr ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipClonePath*(path: ptr GpPath, clonePath: ptr ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeletePath*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetPath*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPointCount*(path: ptr GpPath, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathTypes*(path: ptr GpPath, types: ptr BYTE, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathPoints*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathPointsI*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathFillMode*(path: ptr GpPath, fillmode: ptr GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathFillMode*(path: ptr GpPath, fillmode: GpFillMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathData*(path: ptr GpPath, pathData: ptr GpPathData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipStartPathFigure*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipClosePathFigure*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipClosePathFigures*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathMarker*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipClearPathMarkers*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipReversePath*(path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathLastPoint*(path: ptr GpPath, lastPoint: ptr GpPointF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathLine*(path: ptr GpPath, x1: REAL, y1: REAL, x2: REAL, y2: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathLine2*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathArc*(path: ptr GpPath, x: REAL, y: REAL, width: REAL, height: REAL, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathBezier*(path: ptr GpPath, x1: REAL, y1: REAL, x2: REAL, y2: REAL, x3: REAL, y3: REAL, x4: REAL, y4: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathBeziers*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurve*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurve2*(path: ptr GpPath, points: ptr GpPointF, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurve3*(path: ptr GpPath, points: ptr GpPointF, count: INT, offset: INT, numberOfSegments: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathClosedCurve*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathClosedCurve2*(path: ptr GpPath, points: ptr GpPointF, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathRectangle*(path: ptr GpPath, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathRectangles*(path: ptr GpPath, rects: ptr GpRectF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathEllipse*(path: ptr GpPath, x: REAL, y: REAL, width: REAL, height: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathPie*(path: ptr GpPath, x: REAL, y: REAL, width: REAL, height: REAL, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathPolygon*(path: ptr GpPath, points: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathPath*(path: ptr GpPath, addingPath: ptr GpPath, connect: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathString*(path: ptr GpPath, string: ptr WCHAR, length: INT, family: ptr GpFontFamily, style: INT, emSize: REAL, layoutRect: ptr GpRectF, format: ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathStringI*(path: ptr GpPath, string: ptr WCHAR, length: INT, family: ptr GpFontFamily, style: INT, emSize: REAL, layoutGpRect: ptr GpRect, format: ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathLineI*(path: ptr GpPath, x1: INT, y1: INT, x2: INT, y2: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathLine2I*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathArcI*(path: ptr GpPath, x: INT, y: INT, width: INT, height: INT, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathBezierI*(path: ptr GpPath, x1: INT, y1: INT, x2: INT, y2: INT, x3: INT, y3: INT, x4: INT, y4: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathBeziersI*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurveI*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurve2I*(path: ptr GpPath, points: ptr GpPoint, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathCurve3I*(path: ptr GpPath, points: ptr GpPoint, count: INT, offset: INT, numberOfSegments: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathClosedCurveI*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathClosedCurve2I*(path: ptr GpPath, points: ptr GpPoint, count: INT, tension: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathRectangleI*(path: ptr GpPath, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathRectanglesI*(path: ptr GpPath, rects: ptr GpRect, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathEllipseI*(path: ptr GpPath, x: INT, y: INT, width: INT, height: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathPieI*(path: ptr GpPath, x: INT, y: INT, width: INT, height: INT, startAngle: REAL, sweepAngle: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipAddPathPolygonI*(path: ptr GpPath, points: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFlattenPath*(path: ptr GpPath, matrix: ptr GpMatrix, flatness: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipWindingModeOutline*(path: ptr GpPath, matrix: ptr GpMatrix, flatness: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipWidenPath*(nativePath: ptr GpPath, pen: ptr GpPen, matrix: ptr GpMatrix, flatness: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipWarpPath*(path: ptr GpPath, matrix: ptr GpMatrix, points: ptr GpPointF, count: INT, srcx: REAL, srcy: REAL, srcwidth: REAL, srcheight: REAL, warpMode: WarpMode, flatness: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformPath*(path: ptr GpPath, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathWorldBounds*(path: ptr GpPath, bounds: ptr GpRectF, matrix: ptr GpMatrix, pen: ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathWorldBoundsI*(path: ptr GpPath, bounds: ptr GpRect, matrix: ptr GpMatrix, pen: ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisiblePathPoint*(path: ptr GpPath, x: REAL, y: REAL, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisiblePathPointI*(path: ptr GpPath, x: INT, y: INT, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsOutlineVisiblePathPoint*(path: ptr GpPath, x: REAL, y: REAL, pen: ptr GpPen, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsOutlineVisiblePathPointI*(path: ptr GpPath, x: INT, y: INT, pen: ptr GpPen, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateHatchBrush*(hatchstyle: GpHatchStyle, forecol: ARGB, backcol: ARGB, brush: ptr ptr GpHatch): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetHatchStyle*(brush: ptr GpHatch, hatchstyle: ptr GpHatchStyle): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetHatchForegroundColor*(brush: ptr GpHatch, forecol: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetHatchBackgroundColor*(brush: ptr GpHatch, backcol: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipLoadImageFromStream*(stream: ptr IStream, image: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipLoadImageFromFile*(filename: ptr WCHAR, image: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipLoadImageFromStreamICM*(stream: ptr IStream, image: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipLoadImageFromFileICM*(filename: ptr WCHAR, image: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneImage*(image: ptr GpImage, cloneImage: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDisposeImage*(image: ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSaveImageToFile*(image: ptr GpImage, filename: ptr WCHAR, clsidEncoder: ptr CLSID, encoderParams: ptr EncoderParameters): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSaveImageToStream*(image: ptr GpImage, stream: ptr IStream, clsidEncoder: ptr CLSID, encoderParams: ptr EncoderParameters): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSaveAdd*(image: ptr GpImage, encoderParams: ptr EncoderParameters): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSaveAddImage*(image: ptr GpImage, newImage: ptr GpImage, encoderParams: ptr EncoderParameters): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageGraphicsContext*(image: ptr GpImage, graphics: ptr ptr GpGraphics): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageBounds*(image: ptr GpImage, srcRect: ptr GpRectF, srcUnit: ptr GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageDimension*(image: ptr GpImage, width: ptr REAL, height: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageType*(image: ptr GpImage, Type: ptr ImageType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageWidth*(image: ptr GpImage, width: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageHeight*(image: ptr GpImage, height: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageHorizontalResolution*(image: ptr GpImage, resolution: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageVerticalResolution*(image: ptr GpImage, resolution: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageFlags*(image: ptr GpImage, flags: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageRawFormat*(image: ptr GpImage, format: ptr GUID): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImagePixelFormat*(image: ptr GpImage, format: ptr PixelFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageThumbnail*(image: ptr GpImage, thumbWidth: UINT, thumbHeight: UINT, thumbImage: ptr ptr GpImage, callback: GetThumbnailImageAbort, callbackData: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetEncoderParameterListSize*(image: ptr GpImage, clsidEncoder: ptr CLSID, size: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetEncoderParameterList*(image: ptr GpImage, clsidEncoder: ptr CLSID, size: UINT, buffer: ptr EncoderParameters): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageGetFrameDimensionsCount*(image: ptr GpImage, count: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageGetFrameDimensionsList*(image: ptr GpImage, dimensionIDs: ptr GUID, count: UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageGetFrameCount*(image: ptr GpImage, dimensionID: ptr GUID, count: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageSelectActiveFrame*(image: ptr GpImage, dimensionID: ptr GUID, frameIndex: UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageRotateFlip*(image: ptr GpImage, rfType: RotateFlipType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImagePalette*(image: ptr GpImage, palette: ptr ColorPalette, size: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImagePalette*(image: ptr GpImage, palette: ptr ColorPalette): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImagePaletteSize*(image: ptr GpImage, size: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPropertyCount*(image: ptr GpImage, numOfProperty: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPropertyIdList*(image: ptr GpImage, numOfProperty: UINT, list: ptr PROPID): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPropertyItemSize*(image: ptr GpImage, propId: PROPID, size: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPropertyItem*(image: ptr GpImage, propId: PROPID, propSize: UINT, buffer: ptr PropertyItem): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPropertySize*(image: ptr GpImage, totalBufferSize: ptr UINT, numProperties: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetAllPropertyItems*(image: ptr GpImage, totalBufferSize: UINT, numProperties: UINT, allItems: ptr PropertyItem): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRemovePropertyItem*(image: ptr GpImage, propId: PROPID): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPropertyItem*(image: ptr GpImage, item: ptr PropertyItem): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFindFirstImageItem*(image: ptr GpImage, item: ptr ImageItemData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipFindNextImageItem*(image: ptr GpImage, item: ptr ImageItemData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageItemData*(image: ptr GpImage, item: ptr ImageItemData): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageSetAbort*(pImage: ptr GpImage, pIAbort: ptr GdiplusAbort): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipImageForceValidation*(image: ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageDecodersSize*(numDecoders: ptr UINT, size: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageDecoders*(numDecoders: UINT, size: UINT, decoders: ptr ImageCodecInfo): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageEncodersSize*(numEncoders: ptr UINT, size: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageEncoders*(numEncoders: UINT, size: UINT, encoders: ptr ImageCodecInfo): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateImageAttributes*(imageattr: ptr ptr GpImageAttributes): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneImageAttributes*(imageattr: ptr GpImageAttributes, cloneImageattr: ptr ptr GpImageAttributes): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDisposeImageAttributes*(imageattr: ptr GpImageAttributes): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesToIdentity*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetImageAttributes*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesColorMatrix*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, colorMatrix: ptr ColorMatrix, grayMatrix: ptr ColorMatrix, flags: ColorMatrixFlags): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesThreshold*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, threshold: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesGamma*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, gamma: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesNoOp*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesColorKeys*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, colorLow: ARGB, colorHigh: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesOutputChannel*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, channelFlags: ColorChannelFlags): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesOutputChannelColorProfile*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, colorProfileFilename: ptr WCHAR): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesRemapTable*(imageattr: ptr GpImageAttributes, Type: ColorAdjustType, enableFlag: BOOL, mapSize: UINT, map: ptr GpColorMap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesWrapMode*(imageAttr: ptr GpImageAttributes, wrap: GpWrapMode, argb: ARGB, clamp: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetImageAttributesAdjustedPalette*(imageAttr: ptr GpImageAttributes, colorPalette: ptr ColorPalette, colorAdjustType: ColorAdjustType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetImageAttributesCachedBackground*(imageattr: ptr GpImageAttributes, enableFlag: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrush*(point1: ptr GpPointF, point2: ptr GpPointF, color1: ARGB, color2: ARGB, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrushI*(point1: ptr GpPoint, point2: ptr GpPoint, color1: ARGB, color2: ARGB, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrushFromRect*(rect: ptr GpRectF, color1: ARGB, color2: ARGB, mode: LinearGradientMode, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrushFromRectI*(rect: ptr GpRect, color1: ARGB, color2: ARGB, mode: LinearGradientMode, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrushFromRectWithAngle*(rect: ptr GpRectF, color1: ARGB, color2: ARGB, angle: REAL, isAngleScalable: BOOL, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateLineBrushFromRectWithAngleI*(rect: ptr GpRect, color1: ARGB, color2: ARGB, angle: REAL, isAngleScalable: BOOL, wrapMode: GpWrapMode, lineGradient: ptr ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineColors*(brush: ptr GpLineGradient, color1: ARGB, color2: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineColors*(brush: ptr GpLineGradient, colors: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineRect*(brush: ptr GpLineGradient, rect: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineRectI*(brush: ptr GpLineGradient, rect: ptr GpRect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineGammaCorrection*(brush: ptr GpLineGradient, useGammaCorrection: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineGammaCorrection*(brush: ptr GpLineGradient, useGammaCorrection: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineBlendCount*(brush: ptr GpLineGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineBlend*(brush: ptr GpLineGradient, blend: ptr REAL, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineBlend*(brush: ptr GpLineGradient, blend: ptr REAL, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLinePresetBlendCount*(brush: ptr GpLineGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLinePresetBlend*(brush: ptr GpLineGradient, blend: ptr ARGB, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLinePresetBlend*(brush: ptr GpLineGradient, blend: ptr ARGB, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineSigmaBlend*(brush: ptr GpLineGradient, focus: REAL, scale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineLinearBlend*(brush: ptr GpLineGradient, focus: REAL, scale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineWrapMode*(brush: ptr GpLineGradient, wrapmode: GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineWrapMode*(brush: ptr GpLineGradient, wrapmode: ptr GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetLineTransform*(brush: ptr GpLineGradient, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetLineTransform*(brush: ptr GpLineGradient, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetLineTransform*(brush: ptr GpLineGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyLineTransform*(brush: ptr GpLineGradient, matrix: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateLineTransform*(brush: ptr GpLineGradient, dx: REAL, dy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScaleLineTransform*(brush: ptr GpLineGradient, sx: REAL, sy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotateLineTransform*(brush: ptr GpLineGradient, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMatrix*(matrix: ptr ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMatrix2*(m11: REAL, m12: REAL, m21: REAL, m22: REAL, dx: REAL, dy: REAL, matrix: ptr ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMatrix3*(rect: ptr GpRectF, dstplg: ptr GpPointF, matrix: ptr ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMatrix3I*(rect: ptr GpRect, dstplg: ptr GpPoint, matrix: ptr ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneMatrix*(matrix: ptr GpMatrix, cloneMatrix: ptr ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteMatrix*(matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetMatrixElements*(matrix: ptr GpMatrix, m11: REAL, m12: REAL, m21: REAL, m22: REAL, dx: REAL, dy: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyMatrix*(matrix: ptr GpMatrix, matrix2: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateMatrix*(matrix: ptr GpMatrix, offsetX: REAL, offsetY: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScaleMatrix*(matrix: ptr GpMatrix, scaleX: REAL, scaleY: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotateMatrix*(matrix: ptr GpMatrix, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipShearMatrix*(matrix: ptr GpMatrix, shearX: REAL, shearY: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipInvertMatrix*(matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformMatrixPoints*(matrix: ptr GpMatrix, pts: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformMatrixPointsI*(matrix: ptr GpMatrix, pts: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipVectorTransformMatrixPoints*(matrix: ptr GpMatrix, pts: ptr GpPointF, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipVectorTransformMatrixPointsI*(matrix: ptr GpMatrix, pts: ptr GpPoint, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMatrixElements*(matrix: ptr GpMatrix, matrixOut: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsMatrixInvertible*(matrix: ptr GpMatrix, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsMatrixIdentity*(matrix: ptr GpMatrix, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsMatrixEqual*(matrix: ptr GpMatrix, matrix2: ptr GpMatrix, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMetafileHeaderFromEmf*(hEmf: HENHMETAFILE, header: ptr MetafileHeader): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMetafileHeaderFromFile*(filename: ptr WCHAR, header: ptr MetafileHeader): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMetafileHeaderFromStream*(stream: ptr IStream, header: ptr MetafileHeader): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMetafileHeaderFromMetafile*(metafile: ptr GpMetafile, header: ptr MetafileHeader): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetHemfFromMetafile*(metafile: ptr GpMetafile, hEmf: ptr HENHMETAFILE): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateStreamOnFile*(filename: ptr WCHAR, access: UINT, stream: ptr ptr IStream): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMetafileFromWmf*(hWmf: HMETAFILE, deleteWmf: BOOL, wmfPlaceableFileHeader: ptr WmfPlaceableFileHeader, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMetafileFromEmf*(hEmf: HENHMETAFILE, deleteEmf: BOOL, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMetafileFromFile*(file: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMetafileFromWmfFile*(file: ptr WCHAR, wmfPlaceableFileHeader: ptr WmfPlaceableFileHeader, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateMetafileFromStream*(stream: ptr IStream, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafile*(referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRectF, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafileI*(referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRect, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafileFileName*(fileName: ptr WCHAR, referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRectF, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafileFileNameI*(fileName: ptr WCHAR, referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRect, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafileStream*(stream: ptr IStream, referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRectF, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRecordMetafileStreamI*(stream: ptr IStream, referenceHdc: HDC, Type: EmfType, frameRect: ptr GpRect, frameUnit: MetafileFrameUnit, description: ptr WCHAR, metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPlayMetafileRecord*(metafile: ptr GpMetafile, recordType: EmfPlusRecordType, flags: UINT, dataSize: UINT, data: ptr BYTE): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetMetafileDownLevelRasterizationLimit*(metafile: ptr GpMetafile, metafileRasterizationLimitDpi: UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetMetafileDownLevelRasterizationLimit*(metafile: ptr GpMetafile, metafileRasterizationLimitDpi: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipConvertToEmfPlus*(refGraphics: ptr GpGraphics, metafile: ptr GpMetafile, conversionSuccess: ptr BOOL, emfType: EmfType, description: ptr WCHAR, out_metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipConvertToEmfPlusToFile*(refGraphics: ptr GpGraphics, metafile: ptr GpMetafile, conversionSuccess: ptr BOOL, filename: ptr WCHAR, emfType: EmfType, description: ptr WCHAR, out_metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipConvertToEmfPlusToStream*(refGraphics: ptr GpGraphics, metafile: ptr GpMetafile, conversionSuccess: ptr BOOL, stream: ptr IStream, emfType: EmfType, description: ptr WCHAR, out_metafile: ptr ptr GpMetafile): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipEmfToWmfBits*(hemf: HENHMETAFILE, cbData16: UINT, pData16: LPBYTE, iMapMode: INT, eFlags: INT): UINT {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePathGradient*(points: ptr GpPointF, count: INT, wrapMode: GpWrapMode, polyGradient: ptr ptr GpPathGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePathGradientI*(points: ptr GpPoint, count: INT, wrapMode: GpWrapMode, polyGradient: ptr ptr GpPathGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePathGradientFromPath*(path: ptr GpPath, polyGradient: ptr ptr GpPathGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientCenterColor*(brush: ptr GpPathGradient, colors: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientCenterColor*(brush: ptr GpPathGradient, colors: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientSurroundColorsWithCount*(brush: ptr GpPathGradient, color: ptr ARGB, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientSurroundColorsWithCount*(brush: ptr GpPathGradient, color: ptr ARGB, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientPath*(brush: ptr GpPathGradient, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientPath*(brush: ptr GpPathGradient, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientCenterPoint*(brush: ptr GpPathGradient, points: ptr GpPointF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientCenterPointI*(brush: ptr GpPathGradient, points: ptr GpPoint): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientCenterPoint*(brush: ptr GpPathGradient, points: ptr GpPointF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientCenterPointI*(brush: ptr GpPathGradient, points: ptr GpPoint): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientRect*(brush: ptr GpPathGradient, rect: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientRectI*(brush: ptr GpPathGradient, rect: ptr GpRect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientPointCount*(brush: ptr GpPathGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientSurroundColorCount*(brush: ptr GpPathGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientGammaCorrection*(brush: ptr GpPathGradient, useGammaCorrection: BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientGammaCorrection*(brush: ptr GpPathGradient, useGammaCorrection: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientBlendCount*(brush: ptr GpPathGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientBlend*(brush: ptr GpPathGradient, blend: ptr REAL, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientBlend*(brush: ptr GpPathGradient, blend: ptr REAL, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientPresetBlendCount*(brush: ptr GpPathGradient, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientPresetBlend*(brush: ptr GpPathGradient, blend: ptr ARGB, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientPresetBlend*(brush: ptr GpPathGradient, blend: ptr ARGB, positions: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientSigmaBlend*(brush: ptr GpPathGradient, focus: REAL, scale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientLinearBlend*(brush: ptr GpPathGradient, focus: REAL, scale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientWrapMode*(brush: ptr GpPathGradient, wrapmode: ptr GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientWrapMode*(brush: ptr GpPathGradient, wrapmode: GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientTransform*(brush: ptr GpPathGradient, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientTransform*(brush: ptr GpPathGradient, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetPathGradientTransform*(brush: ptr GpPathGradient): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyPathGradientTransform*(brush: ptr GpPathGradient, matrix: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslatePathGradientTransform*(brush: ptr GpPathGradient, dx: REAL, dy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScalePathGradientTransform*(brush: ptr GpPathGradient, sx: REAL, sy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotatePathGradientTransform*(brush: ptr GpPathGradient, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPathGradientFocusScales*(brush: ptr GpPathGradient, xScale: ptr REAL, yScale: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPathGradientFocusScales*(brush: ptr GpPathGradient, xScale: REAL, yScale: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePathIter*(Iterator: ptr ptr GpPathIterator, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeletePathIter*(Iterator: ptr GpPathIterator): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterNextSubpath*(Iterator: ptr GpPathIterator, resultCount: ptr INT, startIndex: ptr INT, endIndex: ptr INT, isClosed: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterNextSubpathPath*(Iterator: ptr GpPathIterator, resultCount: ptr INT, path: ptr GpPath, isClosed: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterNextPathType*(Iterator: ptr GpPathIterator, resultCount: ptr INT, pathType: ptr BYTE, startIndex: ptr INT, endIndex: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterNextMarker*(Iterator: ptr GpPathIterator, resultCount: ptr INT, startIndex: ptr INT, endIndex: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterNextMarkerPath*(Iterator: ptr GpPathIterator, resultCount: ptr INT, path: ptr GpPath): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterGetCount*(Iterator: ptr GpPathIterator, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterGetSubpathCount*(Iterator: ptr GpPathIterator, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterIsValid*(Iterator: ptr GpPathIterator, valid: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterHasCurve*(Iterator: ptr GpPathIterator, hasCurve: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterRewind*(Iterator: ptr GpPathIterator): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterEnumerate*(Iterator: ptr GpPathIterator, resultCount: ptr INT, points: ptr GpPointF, types: ptr BYTE, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipPathIterCopyData*(Iterator: ptr GpPathIterator, resultCount: ptr INT, points: ptr GpPointF, types: ptr BYTE, startIndex: INT, endIndex: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePen1*(color: ARGB, width: REAL, unit: GpUnit, pen: ptr ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreatePen2*(brush: ptr GpBrush, width: REAL, unit: GpUnit, pen: ptr ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipClonePen*(pen: ptr GpPen, clonepen: ptr ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeletePen*(pen: ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenWidth*(pen: ptr GpPen, width: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenWidth*(pen: ptr GpPen, width: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenUnit*(pen: ptr GpPen, unit: GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenUnit*(pen: ptr GpPen, unit: ptr GpUnit): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenLineCap197819*(pen: ptr GpPen, startCap: GpLineCap, endCap: GpLineCap, dashCap: GpDashCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenStartCap*(pen: ptr GpPen, startCap: GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenEndCap*(pen: ptr GpPen, endCap: GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenDashCap197819*(pen: ptr GpPen, dashCap: GpDashCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenStartCap*(pen: ptr GpPen, startCap: ptr GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenEndCap*(pen: ptr GpPen, endCap: ptr GpLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenDashCap197819*(pen: ptr GpPen, dashCap: ptr GpDashCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenLineJoin*(pen: ptr GpPen, lineJoin: GpLineJoin): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenLineJoin*(pen: ptr GpPen, lineJoin: ptr GpLineJoin): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenCustomStartCap*(pen: ptr GpPen, customCap: ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenCustomStartCap*(pen: ptr GpPen, customCap: ptr ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenCustomEndCap*(pen: ptr GpPen, customCap: ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenCustomEndCap*(pen: ptr GpPen, customCap: ptr ptr GpCustomLineCap): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenMiterLimit*(pen: ptr GpPen, miterLimit: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenMiterLimit*(pen: ptr GpPen, miterLimit: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenMode*(pen: ptr GpPen, penMode: GpPenAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenMode*(pen: ptr GpPen, penMode: ptr GpPenAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenTransform*(pen: ptr GpPen, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenTransform*(pen: ptr GpPen, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetPenTransform*(pen: ptr GpPen): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyPenTransform*(pen: ptr GpPen, matrix: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslatePenTransform*(pen: ptr GpPen, dx: REAL, dy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScalePenTransform*(pen: ptr GpPen, sx: REAL, sy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotatePenTransform*(pen: ptr GpPen, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenColor*(pen: ptr GpPen, argb: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenColor*(pen: ptr GpPen, argb: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenBrushFill*(pen: ptr GpPen, brush: ptr GpBrush): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenBrushFill*(pen: ptr GpPen, brush: ptr ptr GpBrush): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenFillType*(pen: ptr GpPen, Type: ptr GpPenType): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenDashStyle*(pen: ptr GpPen, dashstyle: ptr GpDashStyle): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenDashStyle*(pen: ptr GpPen, dashstyle: GpDashStyle): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenDashOffset*(pen: ptr GpPen, offset: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenDashOffset*(pen: ptr GpPen, offset: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenDashCount*(pen: ptr GpPen, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenDashArray*(pen: ptr GpPen, dash: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenDashArray*(pen: ptr GpPen, dash: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenCompoundCount*(pen: ptr GpPen, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetPenCompoundArray*(pen: ptr GpPen, dash: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetPenCompoundArray*(pen: ptr GpPen, dash: ptr REAL, count: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegion*(region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegionRect*(rect: ptr GpRectF, region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegionRectI*(rect: ptr GpRect, region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegionPath*(path: ptr GpPath, region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegionRgnData*(regionData: ptr BYTE, size: INT, region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateRegionHrgn*(hRgn: HRGN, region: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneRegion*(region: ptr GpRegion, cloneRegion: ptr ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteRegion*(region: ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetInfinite*(region: ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetEmpty*(region: ptr GpRegion): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCombineRegionRect*(region: ptr GpRegion, rect: ptr GpRectF, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCombineRegionRectI*(region: ptr GpRegion, rect: ptr GpRect, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCombineRegionPath*(region: ptr GpRegion, path: ptr GpPath, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCombineRegionRegion*(region: ptr GpRegion, region2: ptr GpRegion, combineMode: CombineMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateRegion*(region: ptr GpRegion, dx: REAL, dy: REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateRegionI*(region: ptr GpRegion, dx: INT, dy: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTransformRegion*(region: ptr GpRegion, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionBounds*(region: ptr GpRegion, graphics: ptr GpGraphics, rect: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionBoundsI*(region: ptr GpRegion, graphics: ptr GpGraphics, rect: ptr GpRect): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionHRgn*(region: ptr GpRegion, graphics: ptr GpGraphics, hRgn: ptr HRGN): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsEmptyRegion*(region: ptr GpRegion, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsInfiniteRegion*(region: ptr GpRegion, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsEqualRegion*(region: ptr GpRegion, region2: ptr GpRegion, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionDataSize*(region: ptr GpRegion, bufferSize: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionData*(region: ptr GpRegion, buffer: ptr BYTE, bufferSize: UINT, sizeFilled: ptr UINT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRegionPoint*(region: ptr GpRegion, x: REAL, y: REAL, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRegionPointI*(region: ptr GpRegion, x: INT, y: INT, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRegionRect*(region: ptr GpRegion, x: REAL, y: REAL, width: REAL, height: REAL, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipIsVisibleRegionRectI*(region: ptr GpRegion, x: INT, y: INT, width: INT, height: INT, graphics: ptr GpGraphics, result: ptr BOOL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionScansCount*(region: ptr GpRegion, count: ptr UINT, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionScans*(region: ptr GpRegion, rects: ptr GpRectF, count: ptr INT, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetRegionScansI*(region: ptr GpRegion, rects: ptr GpRect, count: ptr INT, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateSolidFill*(color: ARGB, brush: ptr ptr GpSolidFill): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetSolidFillColor*(brush: ptr GpSolidFill, color: ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetSolidFillColor*(brush: ptr GpSolidFill, color: ptr ARGB): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateStringFormat*(formatAttributes: INT, language: LANGID, format: ptr ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipStringFormatGetGenericDefault*(format: ptr ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipStringFormatGetGenericTypographic*(format: ptr ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDeleteStringFormat*(format: ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCloneStringFormat*(format: ptr GpStringFormat, newFormat: ptr ptr GpStringFormat): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatFlags*(format: ptr GpStringFormat, flags: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatFlags*(format: ptr GpStringFormat, flags: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatAlign*(format: ptr GpStringFormat, align: StringAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatAlign*(format: ptr GpStringFormat, align: ptr StringAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatLineAlign*(format: ptr GpStringFormat, align: StringAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatLineAlign*(format: ptr GpStringFormat, align: ptr StringAlignment): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatTrimming*(format: ptr GpStringFormat, trimming: StringTrimming): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatTrimming*(format: ptr GpStringFormat, trimming: ptr StringTrimming): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatHotkeyPrefix*(format: ptr GpStringFormat, hotkeyPrefix: INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatHotkeyPrefix*(format: ptr GpStringFormat, hotkeyPrefix: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatTabStops*(format: ptr GpStringFormat, firstTabOffset: REAL, count: INT, tabStops: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatTabStops*(format: ptr GpStringFormat, count: INT, firstTabOffset: ptr REAL, tabStops: ptr REAL): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatTabStopCount*(format: ptr GpStringFormat, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatDigitSubstitution*(format: ptr GpStringFormat, language: LANGID, substitute: StringDigitSubstitute): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatDigitSubstitution*(format: ptr GpStringFormat, language: ptr LANGID, substitute: ptr StringDigitSubstitute): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetStringFormatMeasurableCharacterRangeCount*(format: ptr GpStringFormat, count: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetStringFormatMeasurableCharacterRanges*(format: ptr GpStringFormat, rangeCount: INT, ranges: ptr CharacterRange): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawString*(graphics: ptr GpGraphics, string: ptr WCHAR, length: INT, font: ptr GpFont, layoutRect: ptr GpRectF, stringFormat: ptr GpStringFormat, brush: ptr GpBrush): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMeasureString*(graphics: ptr GpGraphics, string: ptr WCHAR, length: INT, font: ptr GpFont, layoutRect: ptr GpRectF, stringFormat: ptr GpStringFormat, boundingBox: ptr GpRectF, codepointsFitted: ptr INT, linesFilled: ptr INT): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipDrawDriverString*(graphics: ptr GpGraphics, text: ptr UINT16, length: INT, font: ptr GpFont, brush: ptr GpBrush, positions: ptr GpPointF, flags: INT, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMeasureDriverString*(graphics: ptr GpGraphics, text: ptr UINT16, length: INT, font: ptr GpFont, positions: ptr GpPointF, flags: INT, matrix: ptr GpMatrix, boundingBox: ptr GpRectF): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateTexture*(image: ptr GpImage, wrapmode: GpWrapMode, texture: ptr ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateTexture2*(image: ptr GpImage, wrapmode: GpWrapMode, x: REAL, y: REAL, width: REAL, height: REAL, texture: ptr ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateTexture2I*(image: ptr GpImage, wrapmode: GpWrapMode, x: INT, y: INT, width: INT, height: INT, texture: ptr ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateTextureIA*(image: ptr GpImage, imageAttributes: ptr GpImageAttributes, x: REAL, y: REAL, width: REAL, height: REAL, texture: ptr ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipCreateTextureIAI*(image: ptr GpImage, imageAttributes: ptr GpImageAttributes, x: INT, y: INT, width: INT, height: INT, texture: ptr ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetTextureTransform*(brush: ptr GpTexture, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetTextureTransform*(brush: ptr GpTexture, matrix: ptr GpMatrix): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipResetTextureTransform*(brush: ptr GpTexture): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipMultiplyTextureTransform*(brush: ptr GpTexture, matrix: ptr GpMatrix, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTranslateTextureTransform*(brush: ptr GpTexture, dx: REAL, dy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipScaleTextureTransform*(brush: ptr GpTexture, sx: REAL, sy: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipRotateTextureTransform*(brush: ptr GpTexture, angle: REAL, order: GpMatrixOrder): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipSetTextureWrapMode*(brush: ptr GpTexture, wrapmode: GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetTextureWrapMode*(brush: ptr GpTexture, wrapmode: ptr GpWrapMode): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipGetTextureImage*(brush: ptr GpTexture, image: ptr ptr GpImage): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc GdipTestControl*(control: GpTestControlEnum, param: pointer): GpStatus {.winapi, stdcall, dynlib: "gdiplus", importc.} +proc `WmfHeader=`*(self: var MetafileHeader, x: METAHEADER) {.inline.} = self.union1.WmfHeader = x +proc WmfHeader*(self: MetafileHeader): METAHEADER {.inline.} = self.union1.WmfHeader +proc WmfHeader*(self: var MetafileHeader): var METAHEADER {.inline.} = self.union1.WmfHeader +proc `EmfHeader=`*(self: var MetafileHeader, x: ENHMETAHEADER3) {.inline.} = self.union1.EmfHeader = x +proc EmfHeader*(self: MetafileHeader): ENHMETAHEADER3 {.inline.} = self.union1.EmfHeader +proc EmfHeader*(self: var MetafileHeader): var ENHMETAHEADER3 {.inline.} = self.union1.EmfHeader diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/http.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/http.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,737 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winsock +import wincrypt +#include +type + HTTP_VERB* = int32 + PHTTP_VERB* = ptr int32 + HTTP_HEADER_ID* = int32 + PHTTP_HEADER_ID* = ptr int32 + HTTP_DATA_CHUNK_TYPE* = int32 + PHTTP_DATA_CHUNK_TYPE* = ptr int32 + HTTP_REQUEST_INFO_TYPE* = int32 + PHTTP_REQUEST_INFO_TYPE* = ptr int32 + HTTP_RESPONSE_INFO_TYPE* = int32 + PHTTP_RESPONSE_INFO_TYPE* = ptr int32 + HTTP_CACHE_POLICY_TYPE* = int32 + PHTTP_CACHE_POLICY_TYPE* = ptr int32 + HTTP_SERVICE_CONFIG_ID* = int32 + PHTTP_SERVICE_CONFIG_ID* = ptr int32 + HTTP_SERVICE_CONFIG_QUERY_TYPE* = int32 + PHTTP_SERVICE_CONFIG_QUERY_TYPE* = ptr int32 + HTTP_503_RESPONSE_VERBOSITY* = int32 + PHTTP_503_RESPONSE_VERBOSITY* = ptr int32 + HTTP_ENABLED_STATE* = int32 + PHTTP_ENABLED_STATE* = ptr int32 + HTTP_LOGGING_ROLLOVER_TYPE* = int32 + PHTTP_LOGGING_ROLLOVER_TYPE* = ptr int32 + HTTP_LOGGING_TYPE* = int32 + PHTTP_LOGGING_TYPE* = ptr int32 + HTTP_QOS_SETTING_TYPE* = int32 + PHTTP_QOS_SETTING_TYPE* = ptr int32 + HTTP_SERVER_PROPERTY* = int32 + PHTTP_SERVER_PROPERTY* = ptr int32 + HTTP_AUTHENTICATION_HARDENING_LEVELS* = int32 + HTTP_SERVICE_BINDING_TYPE* = int32 + HTTP_LOG_DATA_TYPE* = int32 + PHTTP_LOG_DATA_TYPE* = ptr int32 + HTTP_REQUEST_AUTH_TYPE* = int32 + PHTTP_REQUEST_AUTH_TYPE* = ptr int32 + HTTP_AUTH_STATUS* = int32 + PHTTP_AUTH_STATUS* = ptr int32 + HTTP_SERVICE_CONFIG_TIMEOUT_KEY* = int32 + PHTTP_SERVICE_CONFIG_TIMEOUT_KEY* = ptr int32 + HTTP_SERVICE_CONFIG_CACHE_KEY* = int32 + HTTP_OPAQUE_ID* = ULONGLONG + PHTTP_OPAQUE_ID* = ptr ULONGLONG + HTTP_URL_CONTEXT* = ULONGLONG + HTTP_SERVICE_CONFIG_TIMEOUT_PARAM* = USHORT + PHTTP_SERVICE_CONFIG_TIMEOUT_PARAM* = ptr USHORT + HTTP_SERVICE_CONFIG_CACHE_PARAM* = ULONG + HTTP_REQUEST_ID* = HTTP_OPAQUE_ID + PHTTP_REQUEST_ID* = ptr HTTP_OPAQUE_ID + HTTP_CONNECTION_ID* = HTTP_OPAQUE_ID + PHTTP_CONNECTION_ID* = ptr HTTP_OPAQUE_ID + HTTP_RAW_CONNECTION_ID* = HTTP_OPAQUE_ID + PHTTP_RAW_CONNECTION_ID* = ptr HTTP_OPAQUE_ID + HTTP_URL_GROUP_ID* = HTTP_OPAQUE_ID + PHTTP_URL_GROUP_ID* = ptr HTTP_OPAQUE_ID + HTTP_SERVER_SESSION_ID* = HTTP_OPAQUE_ID + PHTTP_SERVER_SESSION_ID* = ptr HTTP_OPAQUE_ID + HTTP_BYTE_RANGE* {.pure.} = object + StartingOffset*: ULARGE_INTEGER + Length*: ULARGE_INTEGER + PHTTP_BYTE_RANGE* = ptr HTTP_BYTE_RANGE + HTTP_VERSION* {.pure.} = object + MajorVersion*: USHORT + MinorVersion*: USHORT + PHTTP_VERSION* = ptr HTTP_VERSION + HTTP_KNOWN_HEADER* {.pure.} = object + RawValueLength*: USHORT + pRawValue*: PCSTR + PHTTP_KNOWN_HEADER* = ptr HTTP_KNOWN_HEADER + HTTP_UNKNOWN_HEADER* {.pure.} = object + NameLength*: USHORT + RawValueLength*: USHORT + pName*: PCSTR + pRawValue*: PCSTR + PHTTP_UNKNOWN_HEADER* = ptr HTTP_UNKNOWN_HEADER + HTTP_DATA_CHUNK_UNION1_FromMemory* {.pure.} = object + pBuffer*: PVOID + BufferLength*: ULONG + HTTP_DATA_CHUNK_UNION1_FromFileHandle* {.pure.} = object + ByteRange*: HTTP_BYTE_RANGE + FileHandle*: HANDLE + HTTP_DATA_CHUNK_UNION1_FromFragmentCache* {.pure.} = object + FragmentNameLength*: USHORT + pFragmentName*: PCWSTR + HTTP_DATA_CHUNK_UNION1* {.pure, union.} = object + FromMemory*: HTTP_DATA_CHUNK_UNION1_FromMemory + FromFileHandle*: HTTP_DATA_CHUNK_UNION1_FromFileHandle + FromFragmentCache*: HTTP_DATA_CHUNK_UNION1_FromFragmentCache + HTTP_DATA_CHUNK* {.pure.} = object + DataChunkType*: HTTP_DATA_CHUNK_TYPE + union1*: HTTP_DATA_CHUNK_UNION1 + PHTTP_DATA_CHUNK* = ptr HTTP_DATA_CHUNK +const + httpHeaderRequestMaximum* = 41 +type + HTTP_REQUEST_HEADERS* {.pure.} = object + UnknownHeaderCount*: USHORT + pUnknownHeaders*: PHTTP_UNKNOWN_HEADER + TrailerCount*: USHORT + pTrailers*: PHTTP_UNKNOWN_HEADER + KnownHeaders*: array[httpHeaderRequestMaximum, HTTP_KNOWN_HEADER] + PHTTP_REQUEST_HEADERS* = ptr HTTP_REQUEST_HEADERS +const + httpHeaderResponseMaximum* = 30 +type + HTTP_RESPONSE_HEADERS* {.pure.} = object + UnknownHeaderCount*: USHORT + pUnknownHeaders*: PHTTP_UNKNOWN_HEADER + TrailerCount*: USHORT + pTrailers*: PHTTP_UNKNOWN_HEADER + KnownHeaders*: array[httpHeaderResponseMaximum, HTTP_KNOWN_HEADER] + PHTTP_RESPONSE_HEADERS* = ptr HTTP_RESPONSE_HEADERS + HTTP_TRANSPORT_ADDRESS* {.pure.} = object + pRemoteAddress*: PSOCKADDR + pLocalAddress*: PSOCKADDR + PHTTP_TRANSPORT_ADDRESS* = ptr HTTP_TRANSPORT_ADDRESS + HTTP_COOKED_URL* {.pure.} = object + FullUrlLength*: USHORT + HostLength*: USHORT + AbsPathLength*: USHORT + QueryStringLength*: USHORT + pFullUrl*: PCWSTR + pHost*: PCWSTR + pAbsPath*: PCWSTR + pQueryString*: PCWSTR + PHTTP_COOKED_URL* = ptr HTTP_COOKED_URL + HTTP_SSL_CLIENT_CERT_INFO* {.pure.} = object + CertFlags*: ULONG + CertEncodedSize*: ULONG + pCertEncoded*: PUCHAR + Token*: HANDLE + CertDeniedByMapper*: BOOLEAN + PHTTP_SSL_CLIENT_CERT_INFO* = ptr HTTP_SSL_CLIENT_CERT_INFO + HTTP_SSL_INFO* {.pure.} = object + ServerCertKeySize*: USHORT + ConnectionKeySize*: USHORT + ServerCertIssuerSize*: ULONG + ServerCertSubjectSize*: ULONG + pServerCertIssuer*: PCSTR + pServerCertSubject*: PCSTR + pClientCertInfo*: PHTTP_SSL_CLIENT_CERT_INFO + SslClientCertNegotiated*: ULONG + PHTTP_SSL_INFO* = ptr HTTP_SSL_INFO + HTTP_REQUEST_V1* {.pure.} = object + Flags*: ULONG + ConnectionId*: HTTP_CONNECTION_ID + RequestId*: HTTP_REQUEST_ID + UrlContext*: HTTP_URL_CONTEXT + Version*: HTTP_VERSION + Verb*: HTTP_VERB + UnknownVerbLength*: USHORT + RawUrlLength*: USHORT + pUnknownVerb*: PCSTR + pRawUrl*: PCSTR + CookedUrl*: HTTP_COOKED_URL + Address*: HTTP_TRANSPORT_ADDRESS + Headers*: HTTP_REQUEST_HEADERS + BytesReceived*: ULONGLONG + EntityChunkCount*: USHORT + pEntityChunks*: PHTTP_DATA_CHUNK + RawConnectionId*: HTTP_RAW_CONNECTION_ID + pSslInfo*: PHTTP_SSL_INFO + PHTTP_REQUEST_V1* = ptr HTTP_REQUEST_V1 + HTTP_REQUEST_INFO* {.pure.} = object + InfoType*: HTTP_REQUEST_INFO_TYPE + InfoLength*: ULONG + pInfo*: PVOID + PHTTP_REQUEST_INFO* = ptr HTTP_REQUEST_INFO + HTTP_REQUEST_V2_STRUCT1* {.pure.} = object + Flags*: ULONG + ConnectionId*: HTTP_CONNECTION_ID + RequestId*: HTTP_REQUEST_ID + UrlContext*: HTTP_URL_CONTEXT + Version*: HTTP_VERSION + Verb*: HTTP_VERB + UnknownVerbLength*: USHORT + RawUrlLength*: USHORT + pUnknownVerb*: PCSTR + pRawUrl*: PCSTR + CookedUrl*: HTTP_COOKED_URL + Address*: HTTP_TRANSPORT_ADDRESS + Headers*: HTTP_REQUEST_HEADERS + BytesReceived*: ULONGLONG + EntityChunkCount*: USHORT + pEntityChunks*: PHTTP_DATA_CHUNK + RawConnectionId*: HTTP_RAW_CONNECTION_ID + pSslInfo*: PHTTP_SSL_INFO + HTTP_REQUEST_V2* {.pure.} = object + struct1*: HTTP_REQUEST_V2_STRUCT1 + RequestInfoCount*: USHORT + pRequestInfo*: PHTTP_REQUEST_INFO + PHTTP_REQUEST_V2* = ptr HTTP_REQUEST_V2 + HTTP_REQUEST* = HTTP_REQUEST_V2 + PHTTP_REQUEST* = ptr HTTP_REQUEST_V2 + HTTP_RESPONSE_V1* {.pure.} = object + Flags*: ULONG + Version*: HTTP_VERSION + StatusCode*: USHORT + ReasonLength*: USHORT + pReason*: PCSTR + Headers*: HTTP_RESPONSE_HEADERS + EntityChunkCount*: USHORT + pEntityChunks*: PHTTP_DATA_CHUNK + PHTTP_RESPONSE_V1* = ptr HTTP_RESPONSE_V1 + HTTP_RESPONSE_INFO* {.pure.} = object + Type*: HTTP_RESPONSE_INFO_TYPE + Length*: ULONG + pInfo*: PVOID + PHTTP_RESPONSE_INFO* = ptr HTTP_RESPONSE_INFO + HTTP_RESPONSE_V2_STRUCT1* {.pure.} = object + Flags*: ULONG + Version*: HTTP_VERSION + StatusCode*: USHORT + ReasonLength*: USHORT + pReason*: PCSTR + Headers*: HTTP_RESPONSE_HEADERS + EntityChunkCount*: USHORT + pEntityChunks*: PHTTP_DATA_CHUNK + HTTP_RESPONSE_V2* {.pure.} = object + struct1*: HTTP_RESPONSE_V2_STRUCT1 + ResponseInfoCount*: USHORT + pResponseInfo*: PHTTP_RESPONSE_INFO + PHTTP_RESPONSE_V2* = ptr HTTP_RESPONSE_V2 + HTTP_RESPONSE* = HTTP_RESPONSE_V2 + PHTTP_RESPONSE* = ptr HTTP_RESPONSE_V2 + HTTP_CACHE_POLICY* {.pure.} = object + Policy*: HTTP_CACHE_POLICY_TYPE + SecondsToLive*: ULONG + PHTTP_CACHE_POLICY* = ptr HTTP_CACHE_POLICY + HTTP_SERVICE_CONFIG_SSL_KEY* {.pure.} = object + pIpPort*: PSOCKADDR + PHTTP_SERVICE_CONFIG_SSL_KEY* = ptr HTTP_SERVICE_CONFIG_SSL_KEY + HTTP_SERVICE_CONFIG_SSL_PARAM* {.pure.} = object + SslHashLength*: ULONG + pSslHash*: PVOID + AppId*: GUID + pSslCertStoreName*: PWSTR + DefaultCertCheckMode*: DWORD + DefaultRevocationFreshnessTime*: DWORD + DefaultRevocationUrlRetrievalTimeout*: DWORD + pDefaultSslCtlIdentifier*: PWSTR + pDefaultSslCtlStoreName*: PWSTR + DefaultFlags*: DWORD + PHTTP_SERVICE_CONFIG_SSL_PARAM* = ptr HTTP_SERVICE_CONFIG_SSL_PARAM + HTTP_SERVICE_CONFIG_SSL_SET* {.pure.} = object + KeyDesc*: HTTP_SERVICE_CONFIG_SSL_KEY + ParamDesc*: HTTP_SERVICE_CONFIG_SSL_PARAM + PHTTP_SERVICE_CONFIG_SSL_SET* = ptr HTTP_SERVICE_CONFIG_SSL_SET + HTTP_SERVICE_CONFIG_SSL_QUERY* {.pure.} = object + QueryDesc*: HTTP_SERVICE_CONFIG_QUERY_TYPE + KeyDesc*: HTTP_SERVICE_CONFIG_SSL_KEY + dwToken*: DWORD + PHTTP_SERVICE_CONFIG_SSL_QUERY* = ptr HTTP_SERVICE_CONFIG_SSL_QUERY + HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM* {.pure.} = object + AddrLength*: USHORT + pAddress*: PSOCKADDR + PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM* = ptr HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM + HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY* {.pure.} = object + AddrCount*: ULONG + AddrList*: array[ANYSIZE_ARRAY, SOCKADDR_STORAGE] + PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY* = ptr HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY + HTTP_SERVICE_CONFIG_URLACL_KEY* {.pure.} = object + pUrlPrefix*: PWSTR + PHTTP_SERVICE_CONFIG_URLACL_KEY* = ptr HTTP_SERVICE_CONFIG_URLACL_KEY + HTTP_SERVICE_CONFIG_URLACL_PARAM* {.pure.} = object + pStringSecurityDescriptor*: PWSTR + PHTTP_SERVICE_CONFIG_URLACL_PARAM* = ptr HTTP_SERVICE_CONFIG_URLACL_PARAM + HTTP_SERVICE_CONFIG_URLACL_SET* {.pure.} = object + KeyDesc*: HTTP_SERVICE_CONFIG_URLACL_KEY + ParamDesc*: HTTP_SERVICE_CONFIG_URLACL_PARAM + PHTTP_SERVICE_CONFIG_URLACL_SET* = ptr HTTP_SERVICE_CONFIG_URLACL_SET + HTTP_SERVICE_CONFIG_URLACL_QUERY* {.pure.} = object + QueryDesc*: HTTP_SERVICE_CONFIG_QUERY_TYPE + KeyDesc*: HTTP_SERVICE_CONFIG_URLACL_KEY + dwToken*: DWORD + PHTTP_SERVICE_CONFIG_URLACL_QUERY* = ptr HTTP_SERVICE_CONFIG_URLACL_QUERY + HTTPAPI_VERSION* {.pure.} = object + HttpApiMajorVersion*: USHORT + HttpApiMinorVersion*: USHORT + PHTTPAPI_VERSION* = ptr HTTPAPI_VERSION + HTTP_LOG_DATA* {.pure.} = object + Type*: HTTP_LOG_DATA_TYPE + PHTTP_LOG_DATA* = ptr HTTP_LOG_DATA + HTTP_PROPERTY_FLAGS* {.pure.} = object + Present* {.bitsize:1.}: ULONG + PHTTP_PROPERTY_FLAGS* = ptr HTTP_PROPERTY_FLAGS + HTTP_CONNECTION_LIMIT_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + MaxConnections*: ULONG + PHTTP_CONNECTION_LIMIT_INFO* = ptr HTTP_CONNECTION_LIMIT_INFO + HTTP_STATE_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + State*: HTTP_ENABLED_STATE + PHTTP_STATE_INFO* = ptr HTTP_STATE_INFO + HTTP_QOS_SETTING_INFO* {.pure.} = object + QosType*: HTTP_QOS_SETTING_TYPE + QosSetting*: PVOID + PHTTP_QOS_SETTING_INFO* = ptr HTTP_QOS_SETTING_INFO + HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS* {.pure.} = object + DomainNameLength*: USHORT + DomainName*: PWSTR + RealmLength*: USHORT + Realm*: PWSTR + PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS* = ptr HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS + HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS* {.pure.} = object + RealmLength*: USHORT + Realm*: PWSTR + PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS* = ptr HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS + HTTP_SERVER_AUTHENTICATION_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + AuthSchemes*: ULONG + ReceiveMutualAuth*: BOOLEAN + ReceiveContextHandle*: BOOLEAN + DisableNTLMCredentialCaching*: BOOLEAN + ExFlags*: UCHAR + DigestParams*: HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS + BasicParams*: HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS + PHTTP_SERVER_AUTHENTICATION_INFO* = ptr HTTP_SERVER_AUTHENTICATION_INFO + HTTP_LOGGING_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + LoggingFlags*: ULONG + SoftwareName*: PCWSTR + SoftwareNameLength*: USHORT + DirectoryNameLength*: USHORT + DirectoryName*: PCWSTR + Format*: HTTP_LOGGING_TYPE + Fields*: ULONG + pExtFields*: PVOID + NumOfExtFields*: USHORT + MaxRecordSize*: USHORT + RolloverType*: HTTP_LOGGING_ROLLOVER_TYPE + RolloverSize*: ULONG + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + PHTTP_LOGGING_INFO* = ptr HTTP_LOGGING_INFO + HTTP_TIMEOUT_LIMIT_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + EntityBody*: USHORT + DrainEntityBody*: USHORT + RequestQueue*: USHORT + IdleConnection*: USHORT + HeaderWait*: USHORT + MinSendRate*: ULONG + PHTTP_TIMEOUT_LIMIT_INFO* = ptr HTTP_TIMEOUT_LIMIT_INFO + HTTP_SERVICE_BINDING_BASE* {.pure.} = object + Type*: HTTP_SERVICE_BINDING_TYPE + PHTTP_SERVICE_BINDING_BASE* = ptr HTTP_SERVICE_BINDING_BASE + HTTP_CHANNEL_BIND_INFO* {.pure.} = object + Hardening*: HTTP_AUTHENTICATION_HARDENING_LEVELS + Flags*: ULONG + ServiceNames*: ptr PHTTP_SERVICE_BINDING_BASE + NumberOfServiceNames*: ULONG + PHTTP_CHANNEL_BIND_INFO* = ptr HTTP_CHANNEL_BIND_INFO + HTTP_REQUEST_CHANNEL_BIND_STATUS* {.pure.} = object + ServiceName*: PHTTP_SERVICE_BINDING_BASE + ChannelToken*: PUCHAR + ChannelTokenSize*: ULONG + Flags*: ULONG + PHTTP_REQUEST_CHANNEL_BIND_STATUS* = ptr HTTP_REQUEST_CHANNEL_BIND_STATUS + HTTP_SERVICE_BINDING_A* {.pure.} = object + Base*: HTTP_SERVICE_BINDING_BASE + Buffer*: PCHAR + BufferSize*: ULONG + PHTTP_SERVICE_BINDING_A* = ptr HTTP_SERVICE_BINDING_A + HTTP_SERVICE_BINDING_W* {.pure.} = object + Base*: HTTP_SERVICE_BINDING_BASE + Buffer*: PWCHAR + BufferSize*: ULONG + PHTTP_SERVICE_BINDING_W* = ptr HTTP_SERVICE_BINDING_W + HTTP_LOG_FIELDS_DATA* {.pure.} = object + Base*: HTTP_LOG_DATA + UserNameLength*: USHORT + UriStemLength*: USHORT + ClientIpLength*: USHORT + ServerNameLength*: USHORT + ServerIpLength*: USHORT + MethodLength*: USHORT + UriQueryLength*: USHORT + HostLength*: USHORT + UserAgentLength*: USHORT + CookieLength*: USHORT + ReferrerLength*: USHORT + UserName*: PWCHAR + UriStem*: PWCHAR + ClientIp*: PCHAR + ServerName*: PCHAR + ServiceName*: PCHAR + ServerIp*: PCHAR + Method*: PCHAR + UriQuery*: PCHAR + Host*: PCHAR + UserAgent*: PCHAR + Cookie*: PCHAR + Referrer*: PCHAR + ServerPort*: USHORT + ProtocolStatus*: USHORT + Win32Status*: ULONG + MethodNum*: HTTP_VERB + SubStatus*: USHORT + PHTTP_LOG_FIELDS_DATA* = ptr HTTP_LOG_FIELDS_DATA + HTTP_REQUEST_AUTH_INFO* {.pure.} = object + AuthStatus*: HTTP_AUTH_STATUS + SecStatus*: SECURITY_STATUS + Flags*: ULONG + AuthType*: HTTP_REQUEST_AUTH_TYPE + AccessToken*: HANDLE + ContextAttributes*: ULONG + PackedContextLength*: ULONG + PackedContextType*: ULONG + PackedContext*: PVOID + MutualAuthDataLength*: ULONG + pMutualAuthData*: PCHAR + PHTTP_REQUEST_AUTH_INFO* = ptr HTTP_REQUEST_AUTH_INFO + HTTP_MULTIPLE_KNOWN_HEADERS* {.pure.} = object + HeaderId*: HTTP_HEADER_ID + Flags*: ULONG + KnownHeaderCount*: USHORT + KnownHeaders*: PHTTP_KNOWN_HEADER + PHTTP_MULTIPLE_KNOWN_HEADERS* = ptr HTTP_MULTIPLE_KNOWN_HEADERS + HTTP_SERVICE_CONFIG_TIMEOUT_SET* {.pure.} = object + KeyDesc*: HTTP_SERVICE_CONFIG_TIMEOUT_KEY + ParamDesc*: HTTP_SERVICE_CONFIG_TIMEOUT_PARAM + PHTTP_SERVICE_CONFIG_TIMEOUT_SET* = ptr HTTP_SERVICE_CONFIG_TIMEOUT_SET + HTTP_BANDWIDTH_LIMIT_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + MaxBandwidth*: ULONG + PHTTP_BANDWIDTH_LIMIT_INFO* = ptr HTTP_BANDWIDTH_LIMIT_INFO + HTTP_BINDING_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + RequestQueueHandle*: HANDLE + PHTTP_BINDING_INFO* = ptr HTTP_BINDING_INFO + HTTP_LISTEN_ENDPOINT_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + EnableSharing*: BOOLEAN + PHTTP_LISTEN_ENDPOINT_INFO* = ptr HTTP_LISTEN_ENDPOINT_INFO + HTTP_FLOWRATE_INFO* {.pure.} = object + Flags*: HTTP_PROPERTY_FLAGS + MaxBandwidth*: ULONG + MaxPeakBandwidth*: ULONG + BurstSize*: ULONG + PHTTP_FLOWRATE_INFO* = ptr HTTP_FLOWRATE_INFO + HTTP_SERVICE_CONFIG_CACHE_SET* {.pure.} = object + KeyDesc*: HTTP_SERVICE_CONFIG_CACHE_KEY + ParamDesc*: HTTP_SERVICE_CONFIG_CACHE_PARAM + PHTTP_SERVICE_CONFIG_CACHE_SET* = ptr HTTP_SERVICE_CONFIG_CACHE_SET +const + HTTP_INITIALIZE_SERVER* = 0x00000001 + HTTP_INITIALIZE_CONFIG* = 0x00000002 + HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY* = 0x00000001 + HTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFER* = 0x00000001 + HTTP_SEND_RESPONSE_FLAG_DISCONNECT* = 0x00000001 + HTTP_SEND_RESPONSE_FLAG_MORE_DATA* = 0x00000002 + HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA* = 0x00000004 + HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE* = 0x00000001 + HTTP_NULL_ID* = 0 + HTTP_VERSION_UNKNOWN* = [0'u8,0] + HTTP_VERSION_0_9* = [0'u8,9] + HTTP_VERSION_1_0* = [1'u8,0] + HTTP_VERSION_1_1* = [1'u8,1] + httpVerbUnparsed* = 0 + httpVerbUnknown* = 1 + httpVerbInvalid* = 2 + httpVerbOPTIONS* = 3 + httpVerbGET* = 4 + httpVerbHEAD* = 5 + httpVerbPOST* = 6 + httpVerbPUT* = 7 + httpVerbDELETE* = 8 + httpVerbTRACE* = 9 + httpVerbCONNECT* = 10 + httpVerbTRACK* = 11 + httpVerbMOVE* = 12 + httpVerbCOPY* = 13 + httpVerbPROPFIND* = 14 + httpVerbPROPPATCH* = 15 + httpVerbMKCOL* = 16 + httpVerbLOCK* = 17 + httpVerbUNLOCK* = 18 + httpVerbSEARCH* = 19 + httpVerbMaximum* = 20 + httpHeaderCacheControl* = 0 + httpHeaderConnection* = 1 + httpHeaderDate* = 2 + httpHeaderKeepAlive* = 3 + httpHeaderPragma* = 4 + httpHeaderTrailer* = 5 + httpHeaderTransferEncoding* = 6 + httpHeaderUpgrade* = 7 + httpHeaderVia* = 8 + httpHeaderWarning* = 9 + httpHeaderAllow* = 10 + httpHeaderContentLength* = 11 + httpHeaderContentType* = 12 + httpHeaderContentEncoding* = 13 + httpHeaderContentLanguage* = 14 + httpHeaderContentLocation* = 15 + httpHeaderContentMd5* = 16 + httpHeaderContentRange* = 17 + httpHeaderExpires* = 18 + httpHeaderLastModified* = 19 + httpHeaderAccept* = 20 + httpHeaderAcceptCharset* = 21 + httpHeaderAcceptEncoding* = 22 + httpHeaderAcceptLanguage* = 23 + httpHeaderAuthorization* = 24 + httpHeaderCookie* = 25 + httpHeaderExpect* = 26 + httpHeaderFrom* = 27 + httpHeaderHost* = 28 + httpHeaderIfMatch* = 29 + httpHeaderIfModifiedSince* = 30 + httpHeaderIfNoneMatch* = 31 + httpHeaderIfRange* = 32 + httpHeaderIfUnmodifiedSince* = 33 + httpHeaderMaxForwards* = 34 + httpHeaderProxyAuthorization* = 35 + httpHeaderReferer* = 36 + httpHeaderRange* = 37 + httpHeaderTe* = 38 + httpHeaderTranslate* = 39 + httpHeaderUserAgent* = 40 + httpHeaderAcceptRanges* = 20 + httpHeaderAge* = 21 + httpHeaderEtag* = 22 + httpHeaderLocation* = 23 + httpHeaderProxyAuthenticate* = 24 + httpHeaderRetryAfter* = 25 + httpHeaderServer* = 26 + httpHeaderSetCookie* = 27 + httpHeaderVary* = 28 + httpHeaderWwwAuthenticate* = 29 + httpHeaderMaximum* = 41 + httpDataChunkFromMemory* = 0 + httpDataChunkFromFileHandle* = 1 + httpDataChunkFromFragmentCache* = 2 + httpDataChunkFromFragmentCacheEx* = 3 + httpDataChunkMaximum* = 4 + httpRequestInfoTypeAuth* = 0 + HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS* = 0x00000001 + httpResponseInfoTypeMultipleKnownHeaders* = 0 + httpResponseInfoTypeAuthenticationProperty* = 1 + httpResponseInfoTypeQosProperty* = 2 + httpResponseInfoTypeChannelBind* = 3 + httpCachePolicyNocache* = 0 + httpCachePolicyUserInvalidates* = 1 + httpCachePolicyTimeToLive* = 2 + httpCachePolicyMaximum* = 3 + httpServiceConfigIPListenList* = 0 + httpServiceConfigSSLCertInfo* = 1 + httpServiceConfigUrlAclInfo* = 2 + httpServiceConfigMax* = 3 + httpServiceConfigQueryExact* = 0 + httpServiceConfigQueryNext* = 1 + httpServiceConfigQueryMax* = 2 + HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER* = 0x00000001 + HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT* = 0x00000002 + HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER* = 0x00000004 + http503ResponseVerbosityBasic* = 0 + http503ResponseVerbosityLimited* = 1 + http503ResponseVerbosityFull* = 2 + httpEnabledStateActive* = 0 + httpEnabledStateInactive* = 1 + httpLoggingRolloverSize* = 0 + httpLoggingRolloverDaily* = 1 + httpLoggingRolloverWeekly* = 2 + httpLoggingRolloverMonthly* = 3 + httpLoggingRolloverHourly* = 4 + httpLoggingTypeW3C* = 0 + httpLoggingTypeIIS* = 1 + httpLoggingTypeNCSA* = 2 + httpLoggingTypeRaw* = 3 + httpQosSettingTypeBandwidth* = 0 + httpQosSettingTypeConnectionLimit* = 1 + httpQosSettingTypeFlowRate* = 2 + httpServerAuthenticationProperty* = 0 + httpServerLoggingProperty* = 1 + httpServerQosProperty* = 2 + httpServerTimeoutsProperty* = 3 + httpServerQueueLengthProperty* = 4 + httpServerStateProperty* = 5 + httpServer503VerbosityProperty* = 6 + httpServerBindingProperty* = 7 + httpServerExtendedAuthenticationProperty* = 8 + httpServerListenEndpointProperty* = 9 + httpServerChannelBindProperty* = 10 + httpAuthenticationHardeningLegacy* = 0 + httpAuthenticationHardeningMedium* = 1 + httpAuthenticationHardeningStrict* = 2 + httpServiceBindingTypeNone* = 0 + httpServiceBindingTypeW* = 1 + httpServiceBindingTypeA* = 2 + httpLogDataTypeFields* = 0 + httpRequestAuthTypeNone* = 0 + httpRequestAuthTypeBasic* = 1 + httpRequestAuthTypeDigest* = 2 + httpRequestAuthTypeNTLM* = 3 + httpRequestAuthTypeNegotiate* = 4 + httpRequestAuthTypeKerberos* = 5 + httpAuthStatusSuccess* = 0 + httpAuthStatusNotAuthenticated* = 1 + httpAuthStatusFailure* = 2 + idleConnectionTimeout* = 0 + headerWaitTimeout* = 1 + maxCacheResponseSize* = 0 + cacheRangeChunkSize* = 1 + HTTP_BYTE_RANGE_TO_EOF* = not ULONGLONG(0) +proc HttpInitialize*(Version: HTTPAPI_VERSION, Flags: ULONG, pReserved: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpTerminate*(Flags: ULONG, pReserved: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCreateHttpHandle*(pReqQueueHandle: PHANDLE, Options: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpReceiveClientCertificate*(ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, Flags: ULONG, pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO, SslClientCertInfoSize: ULONG, pBytesReceived: PULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpAddUrl*(ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pReserved: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpRemoveUrl*(ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpReceiveHttpRequest*(ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pRequestBuffer: PHTTP_REQUEST, RequestBufferLength: ULONG, pBytesReceived: PULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpReceiveRequestEntityBody*(ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pBuffer: PVOID, BufferLength: ULONG, pBytesReceived: PULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSendHttpResponse*(ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pHttpResponse: PHTTP_RESPONSE, pReserved1: PVOID, pBytesSent: PULONG, pReserved2: PVOID, Reserved3: ULONG, pOverlapped: LPOVERLAPPED, pReserved4: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSendResponseEntityBody*(ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, EntityChunkCount: USHORT, pEntityChunks: PHTTP_DATA_CHUNK, pBytesSent: PULONG, pReserved1: PVOID, Reserved2: ULONG, pOverlapped: LPOVERLAPPED, pReserved3: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpWaitForDisconnect*(ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpFlushResponseCache*(ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, Flags: ULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpAddFragmentToCache*(ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pDataChunk: PHTTP_DATA_CHUNK, pCachePolicy: PHTTP_CACHE_POLICY, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpReadFragmentFromCache*(ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pByteRange: PHTTP_BYTE_RANGE, pBuffer: PVOID, BufferLength: ULONG, pBytesRead: PULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSetServiceConfiguration*(ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpDeleteServiceConfiguration*(ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpQueryServiceConfiguration*(ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pInputConfigInformation: PVOID, InputConfigInformationLength: ULONG, pOutputConfigInformation: PVOID, OutputConfigInformationLength: ULONG, pReturnLength: PULONG, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSetRequestQueueProperty*(Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReserved: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpQueryRequestQueueProperty*(Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReturnLength: PULONG, pReserved: PVOID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCreateRequestQueue*(Version: HTTPAPI_VERSION, pName: PCWSTR, pSecurityAttributes: PSECURITY_ATTRIBUTES, Flags: ULONG, pReqQueueHandle: PHANDLE): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpAddUrlToUrlGroup*(UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, UrlContext: HTTP_URL_CONTEXT, Reserved: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCancelHttpRequest*(ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCloseRequestQueue*(ReqQueueHandle: HANDLE): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCloseServerSession*(ServerSessionId: HTTP_SERVER_SESSION_ID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCloseUrlGroup*(UrlGroupId: HTTP_URL_GROUP_ID): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCreateServerSession*(Version: HTTPAPI_VERSION, pServerSessionId: PHTTP_SERVER_SESSION_ID, Reserved: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpCreateUrlGroup*(ServerSessionId: HTTP_SERVER_SESSION_ID, pUrlGroupId: PHTTP_URL_GROUP_ID, Reserved: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpQueryServerSessionProperty*(ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpQueryUrlGroupProperty*(UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpRemoveUrlFromUrlGroup*(UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, Flags: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSetServerSessionProperty*(ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpSetUrlGroupProperty*(UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpShutdownRequestQueue*(ReqQueueHandle: HANDLE): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc HttpWaitForDemandStart*(ReqQueueHandle: HANDLE, pOverlapped: LPOVERLAPPED): ULONG {.winapi, stdcall, dynlib: "httpapi", importc.} +proc `FromMemory=`*(self: var HTTP_DATA_CHUNK, x: HTTP_DATA_CHUNK_UNION1_FromMemory) {.inline.} = self.union1.FromMemory = x +proc FromMemory*(self: HTTP_DATA_CHUNK): HTTP_DATA_CHUNK_UNION1_FromMemory {.inline.} = self.union1.FromMemory +proc FromMemory*(self: var HTTP_DATA_CHUNK): var HTTP_DATA_CHUNK_UNION1_FromMemory {.inline.} = self.union1.FromMemory +proc `FromFileHandle=`*(self: var HTTP_DATA_CHUNK, x: HTTP_DATA_CHUNK_UNION1_FromFileHandle) {.inline.} = self.union1.FromFileHandle = x +proc FromFileHandle*(self: HTTP_DATA_CHUNK): HTTP_DATA_CHUNK_UNION1_FromFileHandle {.inline.} = self.union1.FromFileHandle +proc FromFileHandle*(self: var HTTP_DATA_CHUNK): var HTTP_DATA_CHUNK_UNION1_FromFileHandle {.inline.} = self.union1.FromFileHandle +proc `FromFragmentCache=`*(self: var HTTP_DATA_CHUNK, x: HTTP_DATA_CHUNK_UNION1_FromFragmentCache) {.inline.} = self.union1.FromFragmentCache = x +proc FromFragmentCache*(self: HTTP_DATA_CHUNK): HTTP_DATA_CHUNK_UNION1_FromFragmentCache {.inline.} = self.union1.FromFragmentCache +proc FromFragmentCache*(self: var HTTP_DATA_CHUNK): var HTTP_DATA_CHUNK_UNION1_FromFragmentCache {.inline.} = self.union1.FromFragmentCache +proc `Flags=`*(self: var HTTP_REQUEST_V2, x: ULONG) {.inline.} = self.struct1.Flags = x +proc Flags*(self: HTTP_REQUEST_V2): ULONG {.inline.} = self.struct1.Flags +proc Flags*(self: var HTTP_REQUEST_V2): var ULONG {.inline.} = self.struct1.Flags +proc `ConnectionId=`*(self: var HTTP_REQUEST_V2, x: HTTP_CONNECTION_ID) {.inline.} = self.struct1.ConnectionId = x +proc ConnectionId*(self: HTTP_REQUEST_V2): HTTP_CONNECTION_ID {.inline.} = self.struct1.ConnectionId +proc ConnectionId*(self: var HTTP_REQUEST_V2): var HTTP_CONNECTION_ID {.inline.} = self.struct1.ConnectionId +proc `RequestId=`*(self: var HTTP_REQUEST_V2, x: HTTP_REQUEST_ID) {.inline.} = self.struct1.RequestId = x +proc RequestId*(self: HTTP_REQUEST_V2): HTTP_REQUEST_ID {.inline.} = self.struct1.RequestId +proc RequestId*(self: var HTTP_REQUEST_V2): var HTTP_REQUEST_ID {.inline.} = self.struct1.RequestId +proc `UrlContext=`*(self: var HTTP_REQUEST_V2, x: HTTP_URL_CONTEXT) {.inline.} = self.struct1.UrlContext = x +proc UrlContext*(self: HTTP_REQUEST_V2): HTTP_URL_CONTEXT {.inline.} = self.struct1.UrlContext +proc UrlContext*(self: var HTTP_REQUEST_V2): var HTTP_URL_CONTEXT {.inline.} = self.struct1.UrlContext +proc `Version=`*(self: var HTTP_REQUEST_V2, x: HTTP_VERSION) {.inline.} = self.struct1.Version = x +proc Version*(self: HTTP_REQUEST_V2): HTTP_VERSION {.inline.} = self.struct1.Version +proc Version*(self: var HTTP_REQUEST_V2): var HTTP_VERSION {.inline.} = self.struct1.Version +proc `Verb=`*(self: var HTTP_REQUEST_V2, x: HTTP_VERB) {.inline.} = self.struct1.Verb = x +proc Verb*(self: HTTP_REQUEST_V2): HTTP_VERB {.inline.} = self.struct1.Verb +proc Verb*(self: var HTTP_REQUEST_V2): var HTTP_VERB {.inline.} = self.struct1.Verb +proc `UnknownVerbLength=`*(self: var HTTP_REQUEST_V2, x: USHORT) {.inline.} = self.struct1.UnknownVerbLength = x +proc UnknownVerbLength*(self: HTTP_REQUEST_V2): USHORT {.inline.} = self.struct1.UnknownVerbLength +proc UnknownVerbLength*(self: var HTTP_REQUEST_V2): var USHORT {.inline.} = self.struct1.UnknownVerbLength +proc `RawUrlLength=`*(self: var HTTP_REQUEST_V2, x: USHORT) {.inline.} = self.struct1.RawUrlLength = x +proc RawUrlLength*(self: HTTP_REQUEST_V2): USHORT {.inline.} = self.struct1.RawUrlLength +proc RawUrlLength*(self: var HTTP_REQUEST_V2): var USHORT {.inline.} = self.struct1.RawUrlLength +proc `pUnknownVerb=`*(self: var HTTP_REQUEST_V2, x: PCSTR) {.inline.} = self.struct1.pUnknownVerb = x +proc pUnknownVerb*(self: HTTP_REQUEST_V2): PCSTR {.inline.} = self.struct1.pUnknownVerb +proc pUnknownVerb*(self: var HTTP_REQUEST_V2): var PCSTR {.inline.} = self.struct1.pUnknownVerb +proc `pRawUrl=`*(self: var HTTP_REQUEST_V2, x: PCSTR) {.inline.} = self.struct1.pRawUrl = x +proc pRawUrl*(self: HTTP_REQUEST_V2): PCSTR {.inline.} = self.struct1.pRawUrl +proc pRawUrl*(self: var HTTP_REQUEST_V2): var PCSTR {.inline.} = self.struct1.pRawUrl +proc `CookedUrl=`*(self: var HTTP_REQUEST_V2, x: HTTP_COOKED_URL) {.inline.} = self.struct1.CookedUrl = x +proc CookedUrl*(self: HTTP_REQUEST_V2): HTTP_COOKED_URL {.inline.} = self.struct1.CookedUrl +proc CookedUrl*(self: var HTTP_REQUEST_V2): var HTTP_COOKED_URL {.inline.} = self.struct1.CookedUrl +proc `Address=`*(self: var HTTP_REQUEST_V2, x: HTTP_TRANSPORT_ADDRESS) {.inline.} = self.struct1.Address = x +proc Address*(self: HTTP_REQUEST_V2): HTTP_TRANSPORT_ADDRESS {.inline.} = self.struct1.Address +proc Address*(self: var HTTP_REQUEST_V2): var HTTP_TRANSPORT_ADDRESS {.inline.} = self.struct1.Address +proc `Headers=`*(self: var HTTP_REQUEST_V2, x: HTTP_REQUEST_HEADERS) {.inline.} = self.struct1.Headers = x +proc Headers*(self: HTTP_REQUEST_V2): HTTP_REQUEST_HEADERS {.inline.} = self.struct1.Headers +proc Headers*(self: var HTTP_REQUEST_V2): var HTTP_REQUEST_HEADERS {.inline.} = self.struct1.Headers +proc `BytesReceived=`*(self: var HTTP_REQUEST_V2, x: ULONGLONG) {.inline.} = self.struct1.BytesReceived = x +proc BytesReceived*(self: HTTP_REQUEST_V2): ULONGLONG {.inline.} = self.struct1.BytesReceived +proc BytesReceived*(self: var HTTP_REQUEST_V2): var ULONGLONG {.inline.} = self.struct1.BytesReceived +proc `EntityChunkCount=`*(self: var HTTP_REQUEST_V2, x: USHORT) {.inline.} = self.struct1.EntityChunkCount = x +proc EntityChunkCount*(self: HTTP_REQUEST_V2): USHORT {.inline.} = self.struct1.EntityChunkCount +proc EntityChunkCount*(self: var HTTP_REQUEST_V2): var USHORT {.inline.} = self.struct1.EntityChunkCount +proc `pEntityChunks=`*(self: var HTTP_REQUEST_V2, x: PHTTP_DATA_CHUNK) {.inline.} = self.struct1.pEntityChunks = x +proc pEntityChunks*(self: HTTP_REQUEST_V2): PHTTP_DATA_CHUNK {.inline.} = self.struct1.pEntityChunks +proc pEntityChunks*(self: var HTTP_REQUEST_V2): var PHTTP_DATA_CHUNK {.inline.} = self.struct1.pEntityChunks +proc `RawConnectionId=`*(self: var HTTP_REQUEST_V2, x: HTTP_RAW_CONNECTION_ID) {.inline.} = self.struct1.RawConnectionId = x +proc RawConnectionId*(self: HTTP_REQUEST_V2): HTTP_RAW_CONNECTION_ID {.inline.} = self.struct1.RawConnectionId +proc RawConnectionId*(self: var HTTP_REQUEST_V2): var HTTP_RAW_CONNECTION_ID {.inline.} = self.struct1.RawConnectionId +proc `pSslInfo=`*(self: var HTTP_REQUEST_V2, x: PHTTP_SSL_INFO) {.inline.} = self.struct1.pSslInfo = x +proc pSslInfo*(self: HTTP_REQUEST_V2): PHTTP_SSL_INFO {.inline.} = self.struct1.pSslInfo +proc pSslInfo*(self: var HTTP_REQUEST_V2): var PHTTP_SSL_INFO {.inline.} = self.struct1.pSslInfo +proc `Flags=`*(self: var HTTP_RESPONSE_V2, x: ULONG) {.inline.} = self.struct1.Flags = x +proc Flags*(self: HTTP_RESPONSE_V2): ULONG {.inline.} = self.struct1.Flags +proc Flags*(self: var HTTP_RESPONSE_V2): var ULONG {.inline.} = self.struct1.Flags +proc `Version=`*(self: var HTTP_RESPONSE_V2, x: HTTP_VERSION) {.inline.} = self.struct1.Version = x +proc Version*(self: HTTP_RESPONSE_V2): HTTP_VERSION {.inline.} = self.struct1.Version +proc Version*(self: var HTTP_RESPONSE_V2): var HTTP_VERSION {.inline.} = self.struct1.Version +proc `StatusCode=`*(self: var HTTP_RESPONSE_V2, x: USHORT) {.inline.} = self.struct1.StatusCode = x +proc StatusCode*(self: HTTP_RESPONSE_V2): USHORT {.inline.} = self.struct1.StatusCode +proc StatusCode*(self: var HTTP_RESPONSE_V2): var USHORT {.inline.} = self.struct1.StatusCode +proc `ReasonLength=`*(self: var HTTP_RESPONSE_V2, x: USHORT) {.inline.} = self.struct1.ReasonLength = x +proc ReasonLength*(self: HTTP_RESPONSE_V2): USHORT {.inline.} = self.struct1.ReasonLength +proc ReasonLength*(self: var HTTP_RESPONSE_V2): var USHORT {.inline.} = self.struct1.ReasonLength +proc `pReason=`*(self: var HTTP_RESPONSE_V2, x: PCSTR) {.inline.} = self.struct1.pReason = x +proc pReason*(self: HTTP_RESPONSE_V2): PCSTR {.inline.} = self.struct1.pReason +proc pReason*(self: var HTTP_RESPONSE_V2): var PCSTR {.inline.} = self.struct1.pReason +proc `Headers=`*(self: var HTTP_RESPONSE_V2, x: HTTP_RESPONSE_HEADERS) {.inline.} = self.struct1.Headers = x +proc Headers*(self: HTTP_RESPONSE_V2): HTTP_RESPONSE_HEADERS {.inline.} = self.struct1.Headers +proc Headers*(self: var HTTP_RESPONSE_V2): var HTTP_RESPONSE_HEADERS {.inline.} = self.struct1.Headers +proc `EntityChunkCount=`*(self: var HTTP_RESPONSE_V2, x: USHORT) {.inline.} = self.struct1.EntityChunkCount = x +proc EntityChunkCount*(self: HTTP_RESPONSE_V2): USHORT {.inline.} = self.struct1.EntityChunkCount +proc EntityChunkCount*(self: var HTTP_RESPONSE_V2): var USHORT {.inline.} = self.struct1.EntityChunkCount +proc `pEntityChunks=`*(self: var HTTP_RESPONSE_V2, x: PHTTP_DATA_CHUNK) {.inline.} = self.struct1.pEntityChunks = x +proc pEntityChunks*(self: HTTP_RESPONSE_V2): PHTTP_DATA_CHUNK {.inline.} = self.struct1.pEntityChunks +proc pEntityChunks*(self: var HTTP_RESPONSE_V2): var PHTTP_DATA_CHUNK {.inline.} = self.struct1.pEntityChunks diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/imagehlp.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/imagehlp.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1488 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winver +import wintrust +#include +#include +#include +type + IMAGEHLP_STATUS_REASON* = int32 + ADDRESS_MODE* = int32 + SYM_TYPE* = int32 + PIMAGEHLP_CONTEXT* = pointer + IMAGEHLP_SYMBOL_TYPE_INFO* = int32 + MINIDUMP_STREAM_TYPE* = int32 + MINIDUMP_CALLBACK_TYPE* = int32 + TTHREAD_WRITE_FLAGS* = int32 + TMODULE_WRITE_FLAGS* = int32 + MINIDUMP_SECONDARY_FLAGS* = int32 + MINIDUMP_TYPE* = int32 + DIGEST_HANDLE* = PVOID + RVA* = DWORD + LOADED_IMAGE* {.pure.} = object + ModuleName*: PSTR + hFile*: HANDLE + MappedAddress*: PUCHAR + FileHeader*: PIMAGE_NT_HEADERS + LastRvaSection*: PIMAGE_SECTION_HEADER + NumberOfSections*: ULONG + Sections*: PIMAGE_SECTION_HEADER + Characteristics*: ULONG + fSystemImage*: BOOLEAN + fDOSImage*: BOOLEAN + fReadOnly*: BOOLEAN + Version*: UCHAR + Links*: LIST_ENTRY + SizeOfImage*: ULONG + PLOADED_IMAGE* = ptr LOADED_IMAGE + MODLOAD_DATA* {.pure.} = object + ssize*: DWORD + ssig*: DWORD + data*: PVOID + size*: DWORD + flags*: DWORD + PMODLOAD_DATA* = ptr MODLOAD_DATA + MODLOAD_CVMISC* {.pure.} = object + oCV*: DWORD + cCV*: int + oMisc*: DWORD + cMisc*: int + dtImage*: DWORD + cImage*: DWORD + PMODLOAD_CVMISC* = ptr MODLOAD_CVMISC + TADDRESS64* {.pure.} = object + Offset*: DWORD64 + Segment*: WORD + Mode*: ADDRESS_MODE + LPADDRESS64* = ptr TADDRESS64 + KDHELP64* {.pure.} = object + Thread*: DWORD64 + ThCallbackStack*: DWORD + ThCallbackBStore*: DWORD + NextCallback*: DWORD + FramePointer*: DWORD + KiCallUserMode*: DWORD64 + KeUserCallbackDispatcher*: DWORD64 + SystemRangeStart*: DWORD64 + KiUserExceptionDispatcher*: DWORD64 + StackBase*: DWORD64 + StackLimit*: DWORD64 + Reserved*: array[5, DWORD64] + PKDHELP64* = ptr KDHELP64 + STACKFRAME64* {.pure.} = object + AddrPC*: TADDRESS64 + AddrReturn*: TADDRESS64 + AddrFrame*: TADDRESS64 + AddrStack*: TADDRESS64 + AddrBStore*: TADDRESS64 + FuncTableEntry*: PVOID + Params*: array[4, DWORD64] + Far*: WINBOOL + Virtual*: WINBOOL + Reserved*: array[3, DWORD64] + KdHelp*: KDHELP64 + LPSTACKFRAME64* = ptr STACKFRAME64 + API_VERSION* {.pure.} = object + MajorVersion*: USHORT + MinorVersion*: USHORT + Revision*: USHORT + Reserved*: USHORT + LPAPI_VERSION* = ptr API_VERSION + IMAGEHLP_SYMBOL64* {.pure.} = object + SizeOfStruct*: DWORD + Address*: DWORD64 + Size*: DWORD + Flags*: DWORD + MaxNameLength*: DWORD + Name*: array[1, CHAR] + PIMAGEHLP_SYMBOL64* = ptr IMAGEHLP_SYMBOL64 +const + MAX_SYM_NAME* = 2000 +type + IMAGEHLP_SYMBOL64_PACKAGE* {.pure.} = object + sym*: IMAGEHLP_SYMBOL64 + name*: array[MAX_SYM_NAME+1, CHAR] + PIMAGEHLP_SYMBOL64_PACKAGE* = ptr IMAGEHLP_SYMBOL64_PACKAGE + IMAGEHLP_MODULE64* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD64 + ImageSize*: DWORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + NumSyms*: DWORD + SymType*: SYM_TYPE + ModuleName*: array[32, CHAR] + ImageName*: array[256, CHAR] + LoadedImageName*: array[256, CHAR] + LoadedPdbName*: array[256, CHAR] + CVSig*: DWORD + CVData*: array[MAX_PATH*3, CHAR] + PdbSig*: DWORD + PdbSig70*: GUID + PdbAge*: DWORD + PdbUnmatched*: WINBOOL + DbgUnmatched*: WINBOOL + LineNumbers*: WINBOOL + GlobalSymbols*: WINBOOL + TypeInfo*: WINBOOL + SourceIndexed*: WINBOOL + Publics*: WINBOOL + PIMAGEHLP_MODULE64* = ptr IMAGEHLP_MODULE64 + IMAGEHLP_MODULEW64* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD64 + ImageSize*: DWORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + NumSyms*: DWORD + SymType*: SYM_TYPE + ModuleName*: array[32, WCHAR] + ImageName*: array[256, WCHAR] + LoadedImageName*: array[256, WCHAR] + LoadedPdbName*: array[256, WCHAR] + CVSig*: DWORD + CVData*: array[MAX_PATH*3, WCHAR] + PdbSig*: DWORD + PdbSig70*: GUID + PdbAge*: DWORD + PdbUnmatched*: WINBOOL + DbgUnmatched*: WINBOOL + LineNumbers*: WINBOOL + GlobalSymbols*: WINBOOL + TypeInfo*: WINBOOL + SourceIndexed*: WINBOOL + Publics*: WINBOOL + PIMAGEHLP_MODULEW64* = ptr IMAGEHLP_MODULEW64 + IMAGEHLP_LINE64* {.pure.} = object + SizeOfStruct*: DWORD + Key*: PVOID + LineNumber*: DWORD + FileName*: PCHAR + Address*: DWORD64 + PIMAGEHLP_LINE64* = ptr IMAGEHLP_LINE64 + IMAGEHLP_LINEW64* {.pure.} = object + SizeOfStruct*: DWORD + Key*: PVOID + LineNumber*: DWORD + FileName*: PWSTR + Address*: DWORD64 + PIMAGEHLP_LINEW64* = ptr IMAGEHLP_LINEW64 + SOURCEFILE* {.pure.} = object + ModBase*: DWORD64 + FileName*: PCHAR + PSOURCEFILE* = ptr SOURCEFILE + SOURCEFILEW* {.pure.} = object + ModBase*: DWORD64 + FileName*: PWCHAR + PSOURCEFILEW* = ptr SOURCEFILEW + IMAGEHLP_CBA_READ_MEMORY* {.pure.} = object + `addr`*: DWORD64 + buf*: PVOID + bytes*: DWORD + bytesread*: ptr DWORD + PIMAGEHLP_CBA_READ_MEMORY* = ptr IMAGEHLP_CBA_READ_MEMORY + IMAGEHLP_CBA_EVENT* {.pure.} = object + severity*: DWORD + code*: DWORD + desc*: PCHAR + `object`*: PVOID + PIMAGEHLP_CBA_EVENT* = ptr IMAGEHLP_CBA_EVENT + IMAGEHLP_DEFERRED_SYMBOL_LOAD64* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD64 + CheckSum*: DWORD + TimeDateStamp*: DWORD + FileName*: array[MAX_PATH, CHAR] + Reparse*: BOOLEAN + hFile*: HANDLE + Flags*: DWORD + PIMAGEHLP_DEFERRED_SYMBOL_LOAD64* = ptr IMAGEHLP_DEFERRED_SYMBOL_LOAD64 + IMAGEHLP_DUPLICATE_SYMBOL64* {.pure.} = object + SizeOfStruct*: DWORD + NumberOfDups*: DWORD + Symbol*: PIMAGEHLP_SYMBOL64 + SelectedSymbol*: DWORD + PIMAGEHLP_DUPLICATE_SYMBOL64* = ptr IMAGEHLP_DUPLICATE_SYMBOL64 + SYMSRV_INDEX_INFO* {.pure.} = object + sizeofstruct*: DWORD + file*: array[MAX_PATH+1, CHAR] + stripped*: WINBOOL + timestamp*: DWORD + size*: DWORD + dbgfile*: array[MAX_PATH+1, CHAR] + pdbfile*: array[MAX_PATH+1, CHAR] + guid*: GUID + sig*: DWORD + age*: DWORD + PSYMSRV_INDEX_INFO* = ptr SYMSRV_INDEX_INFO + SYMSRV_INDEX_INFOW* {.pure.} = object + sizeofstruct*: DWORD + file*: array[MAX_PATH+1, WCHAR] + stripped*: WINBOOL + timestamp*: DWORD + size*: DWORD + dbgfile*: array[MAX_PATH+1, WCHAR] + pdbfile*: array[MAX_PATH+1, WCHAR] + guid*: GUID + sig*: DWORD + age*: DWORD + PSYMSRV_INDEX_INFOW* = ptr SYMSRV_INDEX_INFOW + PSYM_ENUMSOURCEFILES_CALLBACK* = proc (pSourceFile: PSOURCEFILE, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMSOURCFILES_CALLBACK* = PSYM_ENUMSOURCEFILES_CALLBACK + SRCCODEINFO* {.pure.} = object + SizeOfStruct*: DWORD + Key*: PVOID + ModBase*: DWORD64 + Obj*: array[MAX_PATH+1, CHAR] + FileName*: array[MAX_PATH+1, CHAR] + LineNumber*: DWORD + Address*: DWORD64 + PSRCCODEINFO* = ptr SRCCODEINFO + SRCCODEINFOW* {.pure.} = object + SizeOfStruct*: DWORD + Key*: PVOID + ModBase*: DWORD64 + Obj*: array[MAX_PATH+1, WCHAR] + FileName*: array[MAX_PATH+1, WCHAR] + LineNumber*: DWORD + Address*: DWORD64 + PSRCCODEINFOW* = ptr SRCCODEINFOW + IMAGEHLP_SYMBOL_SRC* {.pure.} = object + sizeofstruct*: DWORD + `type`*: DWORD + file*: array[MAX_PATH, char] + PIMAGEHLP_SYMBOL_SRC* = ptr IMAGEHLP_SYMBOL_SRC + MODULE_TYPE_INFO* {.pure.} = object + dataLength*: USHORT + leaf*: USHORT + data*: array[1, BYTE] + PMODULE_TYPE_INFO* = ptr MODULE_TYPE_INFO + SYMBOL_INFO* {.pure.} = object + SizeOfStruct*: ULONG + TypeIndex*: ULONG + Reserved*: array[2, ULONG64] + info*: ULONG + Size*: ULONG + ModBase*: ULONG64 + Flags*: ULONG + Value*: ULONG64 + Address*: ULONG64 + Register*: ULONG + Scope*: ULONG + Tag*: ULONG + NameLen*: ULONG + MaxNameLen*: ULONG + Name*: array[1, CHAR] + PSYMBOL_INFO* = ptr SYMBOL_INFO + SYMBOL_INFOW* {.pure.} = object + SizeOfStruct*: ULONG + TypeIndex*: ULONG + Reserved*: array[2, ULONG64] + info*: ULONG + Size*: ULONG + ModBase*: ULONG64 + Flags*: ULONG + Value*: ULONG64 + Address*: ULONG64 + Register*: ULONG + Scope*: ULONG + Tag*: ULONG + NameLen*: ULONG + MaxNameLen*: ULONG + Name*: array[1, WCHAR] + PSYMBOL_INFOW* = ptr SYMBOL_INFOW + SYMBOL_INFO_PACKAGE* {.pure.} = object + si*: SYMBOL_INFO + name*: array[MAX_SYM_NAME+1, CHAR] + PSYMBOL_INFO_PACKAGE* = ptr SYMBOL_INFO_PACKAGE + IMAGEHLP_STACK_FRAME* {.pure.} = object + InstructionOffset*: ULONG64 + ReturnOffset*: ULONG64 + FrameOffset*: ULONG64 + StackOffset*: ULONG64 + BackingStoreOffset*: ULONG64 + FuncTableEntry*: ULONG64 + Params*: array[4, ULONG64] + Reserved*: array[5, ULONG64] + Virtual*: WINBOOL + Reserved2*: ULONG + PIMAGEHLP_STACK_FRAME* = ptr IMAGEHLP_STACK_FRAME + IMAGEHLP_CONTEXT* = VOID + RVA64* = ULONG64 + MINIDUMP_LOCATION_DESCRIPTOR* {.pure.} = object + DataSize*: ULONG32 + Rva*: RVA + MINIDUMP_MEMORY_DESCRIPTOR* {.pure.} = object + StartOfMemoryRange*: ULONG64 + Memory*: MINIDUMP_LOCATION_DESCRIPTOR + PMINIDUMP_MEMORY_DESCRIPTOR* = ptr MINIDUMP_MEMORY_DESCRIPTOR + MINIDUMP_MEMORY_DESCRIPTOR64* {.pure.} = object + StartOfMemoryRange*: ULONG64 + DataSize*: ULONG64 + PMINIDUMP_MEMORY_DESCRIPTOR64* = ptr MINIDUMP_MEMORY_DESCRIPTOR64 + MINIDUMP_HEADER_UNION1* {.pure, union.} = object + Reserved*: ULONG32 + TimeDateStamp*: ULONG32 + MINIDUMP_HEADER* {.pure.} = object + Signature*: ULONG32 + Version*: ULONG32 + NumberOfStreams*: ULONG32 + StreamDirectoryRva*: RVA + CheckSum*: ULONG32 + union1*: MINIDUMP_HEADER_UNION1 + Flags*: ULONG64 + PMINIDUMP_HEADER* = ptr MINIDUMP_HEADER + MINIDUMP_DIRECTORY* {.pure.} = object + StreamType*: ULONG32 + Location*: MINIDUMP_LOCATION_DESCRIPTOR + PMINIDUMP_DIRECTORY* = ptr MINIDUMP_DIRECTORY + MINIDUMP_STRING* {.pure.} = object + Length*: ULONG32 + Buffer*: UncheckedArray[WCHAR] + PMINIDUMP_STRING* = ptr MINIDUMP_STRING + CPU_INFORMATION_X86CpuInfo* {.pure.} = object + VendorId*: array[3, ULONG32] + VersionInformation*: ULONG32 + FeatureInformation*: ULONG32 + AMDExtendedCpuFeatures*: ULONG32 + CPU_INFORMATION_OtherCpuInfo* {.pure.} = object + ProcessorFeatures*: array[2, ULONG64] + CPU_INFORMATION* {.pure, union.} = object + X86CpuInfo*: CPU_INFORMATION_X86CpuInfo + OtherCpuInfo*: CPU_INFORMATION_OtherCpuInfo + PCPU_INFORMATION* = ptr CPU_INFORMATION + MINIDUMP_SYSTEM_INFO_UNION1_STRUCT1* {.pure.} = object + NumberOfProcessors*: UCHAR + ProductType*: UCHAR + MINIDUMP_SYSTEM_INFO_UNION1* {.pure, union.} = object + Reserved0*: USHORT + struct1*: MINIDUMP_SYSTEM_INFO_UNION1_STRUCT1 + MINIDUMP_SYSTEM_INFO_UNION2_STRUCT1* {.pure.} = object + SuiteMask*: USHORT + Reserved2*: USHORT + MINIDUMP_SYSTEM_INFO_UNION2* {.pure, union.} = object + Reserved1*: ULONG32 + struct1*: MINIDUMP_SYSTEM_INFO_UNION2_STRUCT1 + MINIDUMP_SYSTEM_INFO* {.pure.} = object + ProcessorArchitecture*: USHORT + ProcessorLevel*: USHORT + ProcessorRevision*: USHORT + union1*: MINIDUMP_SYSTEM_INFO_UNION1 + MajorVersion*: ULONG32 + MinorVersion*: ULONG32 + BuildNumber*: ULONG32 + PlatformId*: ULONG32 + CSDVersionRva*: RVA + union2*: MINIDUMP_SYSTEM_INFO_UNION2 + Cpu*: CPU_INFORMATION + PMINIDUMP_SYSTEM_INFO* = ptr MINIDUMP_SYSTEM_INFO + MINIDUMP_THREAD* {.pure.} = object + ThreadId*: ULONG32 + SuspendCount*: ULONG32 + PriorityClass*: ULONG32 + Priority*: ULONG32 + Teb*: ULONG64 + Stack*: MINIDUMP_MEMORY_DESCRIPTOR + ThreadContext*: MINIDUMP_LOCATION_DESCRIPTOR + PMINIDUMP_THREAD* = ptr MINIDUMP_THREAD + MINIDUMP_THREAD_LIST* {.pure, packed.} = object + NumberOfThreads*: ULONG32 + Threads*: UncheckedArray[MINIDUMP_THREAD] + PMINIDUMP_THREAD_LIST* = ptr MINIDUMP_THREAD_LIST + MINIDUMP_THREAD_EX* {.pure.} = object + ThreadId*: ULONG32 + SuspendCount*: ULONG32 + PriorityClass*: ULONG32 + Priority*: ULONG32 + Teb*: ULONG64 + Stack*: MINIDUMP_MEMORY_DESCRIPTOR + ThreadContext*: MINIDUMP_LOCATION_DESCRIPTOR + BackingStore*: MINIDUMP_MEMORY_DESCRIPTOR + PMINIDUMP_THREAD_EX* = ptr MINIDUMP_THREAD_EX + MINIDUMP_THREAD_EX_LIST* {.pure, packed.} = object + NumberOfThreads*: ULONG32 + Threads*: UncheckedArray[MINIDUMP_THREAD_EX] + PMINIDUMP_THREAD_EX_LIST* = ptr MINIDUMP_THREAD_EX_LIST + MINIDUMP_EXCEPTION* {.pure.} = object + ExceptionCode*: ULONG32 + ExceptionFlags*: ULONG32 + ExceptionRecord*: ULONG64 + ExceptionAddress*: ULONG64 + NumberParameters*: ULONG32 + unusedAlignment*: ULONG32 + ExceptionInformation*: array[EXCEPTION_MAXIMUM_PARAMETERS, ULONG64] + PMINIDUMP_EXCEPTION* = ptr MINIDUMP_EXCEPTION + MINIDUMP_EXCEPTION_STREAM* {.pure.} = object + ThreadId*: ULONG32 + alignment*: ULONG32 + ExceptionRecord*: MINIDUMP_EXCEPTION + ThreadContext*: MINIDUMP_LOCATION_DESCRIPTOR + PMINIDUMP_EXCEPTION_STREAM* = ptr MINIDUMP_EXCEPTION_STREAM + MINIDUMP_MODULE* {.pure, packed.} = object + BaseOfImage*: ULONG64 + SizeOfImage*: ULONG32 + CheckSum*: ULONG32 + TimeDateStamp*: ULONG32 + ModuleNameRva*: RVA + VersionInfo*: VS_FIXEDFILEINFO + CvRecord*: MINIDUMP_LOCATION_DESCRIPTOR + MiscRecord*: MINIDUMP_LOCATION_DESCRIPTOR + Reserved0*: ULONG64 + Reserved1*: ULONG64 + PMINIDUMP_MODULE* = ptr MINIDUMP_MODULE + MINIDUMP_MODULE_LIST* {.pure, packed.} = object + NumberOfModules*: ULONG32 + Modules*: UncheckedArray[MINIDUMP_MODULE] + PMINIDUMP_MODULE_LIST* = ptr MINIDUMP_MODULE_LIST + MINIDUMP_MEMORY_LIST* {.pure, packed.} = object + NumberOfMemoryRanges*: ULONG32 + MemoryRanges*: UncheckedArray[MINIDUMP_MEMORY_DESCRIPTOR] + PMINIDUMP_MEMORY_LIST* = ptr MINIDUMP_MEMORY_LIST + MINIDUMP_MEMORY64_LIST* {.pure.} = object + NumberOfMemoryRanges*: ULONG64 + BaseRva*: RVA64 + MemoryRanges*: UncheckedArray[MINIDUMP_MEMORY_DESCRIPTOR64] + PMINIDUMP_MEMORY64_LIST* = ptr MINIDUMP_MEMORY64_LIST + MINIDUMP_EXCEPTION_INFORMATION* {.pure, packed.} = object + ThreadId*: DWORD + ExceptionPointers*: PEXCEPTION_POINTERS + ClientPointers*: WINBOOL + PMINIDUMP_EXCEPTION_INFORMATION* = ptr MINIDUMP_EXCEPTION_INFORMATION + MINIDUMP_EXCEPTION_INFORMATION64* {.pure, packed.} = object + ThreadId*: DWORD + ExceptionRecord*: ULONG64 + ContextRecord*: ULONG64 + ClientPointers*: WINBOOL + PMINIDUMP_EXCEPTION_INFORMATION64* = ptr MINIDUMP_EXCEPTION_INFORMATION64 + MINIDUMP_HANDLE_DESCRIPTOR* {.pure.} = object + Handle*: ULONG64 + TypeNameRva*: RVA + ObjectNameRva*: RVA + Attributes*: ULONG32 + GrantedAccess*: ULONG32 + HandleCount*: ULONG32 + PointerCount*: ULONG32 + PMINIDUMP_HANDLE_DESCRIPTOR* = ptr MINIDUMP_HANDLE_DESCRIPTOR + MINIDUMP_HANDLE_DATA_STREAM* {.pure.} = object + SizeOfHeader*: ULONG32 + SizeOfDescriptor*: ULONG32 + NumberOfDescriptors*: ULONG32 + Reserved*: ULONG32 + PMINIDUMP_HANDLE_DATA_STREAM* = ptr MINIDUMP_HANDLE_DATA_STREAM + MINIDUMP_FUNCTION_TABLE_DESCRIPTOR* {.pure.} = object + MinimumAddress*: ULONG64 + MaximumAddress*: ULONG64 + BaseAddress*: ULONG64 + EntryCount*: ULONG32 + SizeOfAlignPad*: ULONG32 + PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR* = ptr MINIDUMP_FUNCTION_TABLE_DESCRIPTOR + MINIDUMP_FUNCTION_TABLE_STREAM* {.pure.} = object + SizeOfHeader*: ULONG32 + SizeOfDescriptor*: ULONG32 + SizeOfNativeDescriptor*: ULONG32 + SizeOfFunctionEntry*: ULONG32 + NumberOfDescriptors*: ULONG32 + SizeOfAlignPad*: ULONG32 + PMINIDUMP_FUNCTION_TABLE_STREAM* = ptr MINIDUMP_FUNCTION_TABLE_STREAM + MINIDUMP_UNLOADED_MODULE* {.pure.} = object + BaseOfImage*: ULONG64 + SizeOfImage*: ULONG32 + CheckSum*: ULONG32 + TimeDateStamp*: ULONG32 + ModuleNameRva*: RVA + PMINIDUMP_UNLOADED_MODULE* = ptr MINIDUMP_UNLOADED_MODULE + MINIDUMP_UNLOADED_MODULE_LIST* {.pure.} = object + SizeOfHeader*: ULONG32 + SizeOfEntry*: ULONG32 + NumberOfEntries*: ULONG32 + PMINIDUMP_UNLOADED_MODULE_LIST* = ptr MINIDUMP_UNLOADED_MODULE_LIST + MINIDUMP_MISC_INFO* {.pure.} = object + SizeOfInfo*: ULONG32 + Flags1*: ULONG32 + ProcessId*: ULONG32 + ProcessCreateTime*: ULONG32 + ProcessUserTime*: ULONG32 + ProcessKernelTime*: ULONG32 + PMINIDUMP_MISC_INFO* = ptr MINIDUMP_MISC_INFO + MINIDUMP_USER_RECORD* {.pure.} = object + Type*: ULONG32 + Memory*: MINIDUMP_LOCATION_DESCRIPTOR + PMINIDUMP_USER_RECORD* = ptr MINIDUMP_USER_RECORD + MINIDUMP_USER_STREAM* {.pure.} = object + Type*: ULONG32 + BufferSize*: ULONG + Buffer*: PVOID + PMINIDUMP_USER_STREAM* = ptr MINIDUMP_USER_STREAM + MINIDUMP_USER_STREAM_INFORMATION* {.pure, packed.} = object + UserStreamCount*: ULONG + UserStreamArray*: PMINIDUMP_USER_STREAM + PMINIDUMP_USER_STREAM_INFORMATION* = ptr MINIDUMP_USER_STREAM_INFORMATION + MINIDUMP_THREAD_CALLBACK* {.pure, packed.} = object + ThreadId*: ULONG + ThreadHandle*: HANDLE + Context*: CONTEXT + SizeOfContext*: ULONG + StackBase*: ULONG64 + StackEnd*: ULONG64 + PMINIDUMP_THREAD_CALLBACK* = ptr MINIDUMP_THREAD_CALLBACK + MINIDUMP_THREAD_EX_CALLBACK* {.pure, packed.} = object + ThreadId*: ULONG + ThreadHandle*: HANDLE + Context*: CONTEXT + SizeOfContext*: ULONG + StackBase*: ULONG64 + StackEnd*: ULONG64 + BackingStoreBase*: ULONG64 + BackingStoreEnd*: ULONG64 + PMINIDUMP_THREAD_EX_CALLBACK* = ptr MINIDUMP_THREAD_EX_CALLBACK + MINIDUMP_INCLUDE_THREAD_CALLBACK* {.pure.} = object + ThreadId*: ULONG + PMINIDUMP_INCLUDE_THREAD_CALLBACK* = ptr MINIDUMP_INCLUDE_THREAD_CALLBACK + MINIDUMP_MODULE_CALLBACK* {.pure, packed.} = object + FullPath*: PWCHAR + BaseOfImage*: ULONG64 + SizeOfImage*: ULONG + CheckSum*: ULONG + TimeDateStamp*: ULONG + VersionInfo*: VS_FIXEDFILEINFO + CvRecord*: PVOID + SizeOfCvRecord*: ULONG + MiscRecord*: PVOID + SizeOfMiscRecord*: ULONG + PMINIDUMP_MODULE_CALLBACK* = ptr MINIDUMP_MODULE_CALLBACK + MINIDUMP_INCLUDE_MODULE_CALLBACK* {.pure.} = object + BaseOfImage*: ULONG64 + PMINIDUMP_INCLUDE_MODULE_CALLBACK* = ptr MINIDUMP_INCLUDE_MODULE_CALLBACK + MINIDUMP_CALLBACK_INPUT_UNION1* {.pure, union.} = object + Thread*: MINIDUMP_THREAD_CALLBACK + ThreadEx*: MINIDUMP_THREAD_EX_CALLBACK + Module*: MINIDUMP_MODULE_CALLBACK + IncludeThread*: MINIDUMP_INCLUDE_THREAD_CALLBACK + IncludeModule*: MINIDUMP_INCLUDE_MODULE_CALLBACK + MINIDUMP_CALLBACK_INPUT* {.pure, packed.} = object + ProcessId*: ULONG + ProcessHandle*: HANDLE + CallbackType*: ULONG + union1*: MINIDUMP_CALLBACK_INPUT_UNION1 + PMINIDUMP_CALLBACK_INPUT* = ptr MINIDUMP_CALLBACK_INPUT + MINIDUMP_MEMORY_INFO* {.pure.} = object + BaseAddress*: ULONG64 + AllocationBase*: ULONG64 + AllocationProtect*: ULONG32 + alignment1*: ULONG32 + RegionSize*: ULONG64 + State*: ULONG32 + Protect*: ULONG32 + Type*: ULONG32 + alignment2*: ULONG32 + PMINIDUMP_MEMORY_INFO* = ptr MINIDUMP_MEMORY_INFO + MINIDUMP_MISC_INFO_2* {.pure.} = object + SizeOfInfo*: ULONG32 + Flags1*: ULONG32 + ProcessId*: ULONG32 + ProcessCreateTime*: ULONG32 + ProcessUserTime*: ULONG32 + ProcessKernelTime*: ULONG32 + ProcessorMaxMhz*: ULONG32 + ProcessorCurrentMhz*: ULONG32 + ProcessorMhzLimit*: ULONG32 + ProcessorMaxIdleState*: ULONG32 + ProcessorCurrentIdleState*: ULONG32 + PMINIDUMP_MISC_INFO_2* = ptr MINIDUMP_MISC_INFO_2 + MINIDUMP_MEMORY_INFO_LIST* {.pure.} = object + SizeOfHeader*: ULONG + SizeOfEntry*: ULONG + NumberOfEntries*: ULONG64 + PMINIDUMP_MEMORY_INFO_LIST* = ptr MINIDUMP_MEMORY_INFO_LIST + MINIDUMP_CALLBACK_OUTPUT_UNION1_STRUCT1* {.pure, packed.} = object + MemoryBase*: ULONG64 + MemorySize*: ULONG + MINIDUMP_CALLBACK_OUTPUT_UNION1_STRUCT2* {.pure, packed.} = object + CheckCancel*: WINBOOL + Cancel*: WINBOOL + MINIDUMP_CALLBACK_OUTPUT_UNION1* {.pure, union.} = object + ModuleWriteFlags*: ULONG + ThreadWriteFlags*: ULONG + SecondaryFlags*: ULONG + struct1*: MINIDUMP_CALLBACK_OUTPUT_UNION1_STRUCT1 + struct2*: MINIDUMP_CALLBACK_OUTPUT_UNION1_STRUCT2 + Handle*: HANDLE + MINIDUMP_CALLBACK_OUTPUT_STRUCT1* {.pure, packed.} = object + VmRegion*: MINIDUMP_MEMORY_INFO + Continue*: WINBOOL + MINIDUMP_CALLBACK_OUTPUT* {.pure, packed.} = object + union1*: MINIDUMP_CALLBACK_OUTPUT_UNION1 + struct1*: MINIDUMP_CALLBACK_OUTPUT_STRUCT1 + Status*: HRESULT + PMINIDUMP_CALLBACK_OUTPUT* = ptr MINIDUMP_CALLBACK_OUTPUT + MINIDUMP_THREAD_INFO* {.pure.} = object + ThreadId*: ULONG32 + DumpFlags*: ULONG32 + DumpError*: ULONG32 + ExitStatus*: ULONG32 + CreateTime*: ULONG64 + ExitTime*: ULONG64 + KernelTime*: ULONG64 + UserTime*: ULONG64 + StartAddress*: ULONG64 + Affinity*: ULONG64 + PMINIDUMP_THREAD_INFO* = ptr MINIDUMP_THREAD_INFO + MINIDUMP_THREAD_INFO_LIST* {.pure.} = object + SizeOfHeader*: ULONG + SizeOfEntry*: ULONG + NumberOfEntries*: ULONG + PMINIDUMP_THREAD_INFO_LIST* = ptr MINIDUMP_THREAD_INFO_LIST + MINIDUMP_HANDLE_OPERATION_LIST* {.pure.} = object + SizeOfHeader*: ULONG32 + SizeOfEntry*: ULONG32 + NumberOfEntries*: ULONG32 + Reserved*: ULONG32 + PMINIDUMP_HANDLE_OPERATION_LIST* = ptr MINIDUMP_HANDLE_OPERATION_LIST + MINIDUMP_CALLBACK_ROUTINE* = proc (CallbackParam: PVOID, CallbackInput: PMINIDUMP_CALLBACK_INPUT, CallbackOutput: PMINIDUMP_CALLBACK_OUTPUT): WINBOOL {.stdcall.} + MINIDUMP_CALLBACK_INFORMATION* {.pure.} = object + CallbackRoutine*: MINIDUMP_CALLBACK_ROUTINE + CallbackParam*: PVOID + PMINIDUMP_CALLBACK_INFORMATION* = ptr MINIDUMP_CALLBACK_INFORMATION +const + IMAGE_SEPARATION* = 64*1024 + bindOutOfMemory* = 0 + bindRvaToVaFailed* = 1 + bindNoRoomInImage* = 2 + bindImportModuleFailed* = 3 + bindImportProcedureFailed* = 4 + bindImportModule* = 5 + bindImportProcedure* = 6 + bindForwarder* = 7 + bindForwarderNOT* = 8 + bindImageModified* = 9 + bindExpandFileHeaders* = 10 + bindImageComplete* = 11 + bindMismatchedSymbols* = 12 + bindSymbolsNotUpdated* = 13 + bindImportProcedure32* = 14 + bindImportProcedure64* = 15 + bindForwarder32* = 16 + bindForwarder64* = 17 + bindForwarderNOT32* = 18 + bindForwarderNOT64* = 19 + BIND_NO_BOUND_IMPORTS* = 0x00000001 + BIND_NO_UPDATE* = 0x00000002 + BIND_ALL_IMAGES* = 0x00000004 + BIND_CACHE_IMPORT_DLLS* = 0x00000008 + BIND_REPORT_64BIT_VA* = 0x00000010 + CHECKSUM_SUCCESS* = 0 + CHECKSUM_OPEN_FAILURE* = 1 + CHECKSUM_MAP_FAILURE* = 2 + CHECKSUM_MAPVIEW_FAILURE* = 3 + CHECKSUM_UNICODE_FAILURE* = 4 + SPLITSYM_REMOVE_PRIVATE* = 0x00000001 + SPLITSYM_EXTRACT_ALL* = 0x00000002 + SPLITSYM_SYMBOLPATH_IS_SRC* = 0x00000004 + CERT_PE_IMAGE_DIGEST_DEBUG_INFO* = 0x01 + CERT_PE_IMAGE_DIGEST_RESOURCES* = 0x02 + CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO* = 0x04 + CERT_PE_IMAGE_DIGEST_NON_PE_INFO* = 0x08 + CERT_SECTION_TYPE_ANY* = 0xFF + SSRVOPT_CALLBACK* = 0x0001 + SSRVOPT_DWORD* = 0x0002 + SSRVOPT_DWORDPTR* = 0x0004 + SSRVOPT_GUIDPTR* = 0x0008 + SSRVOPT_OLDGUIDPTR* = 0x0010 + SSRVOPT_UNATTENDED* = 0x0020 + SSRVOPT_NOCOPY* = 0x0040 + SSRVOPT_PARENTWIN* = 0x0080 + SSRVOPT_PARAMTYPE* = 0x0100 + SSRVOPT_SECURE* = 0x0200 + SSRVOPT_TRACE* = 0x0400 + SSRVOPT_SETCONTEXT* = 0x0800 + SSRVOPT_PROXY* = 0x1000 + SSRVOPT_DOWNSTREAM_STORE* = 0x2000 + SSRVACTION_TRACE* = 1 + SSRVACTION_QUERYCANCEL* = 2 + SSRVACTION_EVENT* = 3 + UNDNAME_COMPLETE* = 0x0000 + UNDNAME_NO_LEADING_UNDERSCORES* = 0x0001 + UNDNAME_NO_MS_KEYWORDS* = 0x0002 + UNDNAME_NO_FUNCTION_RETURNS* = 0x0004 + UNDNAME_NO_ALLOCATION_MODEL* = 0x0008 + UNDNAME_NO_ALLOCATION_LANGUAGE* = 0x0010 + UNDNAME_NO_MS_THISTYPE* = 0x0020 + UNDNAME_NO_CV_THISTYPE* = 0x0040 + UNDNAME_NO_THISTYPE* = 0x0060 + UNDNAME_NO_ACCESS_SPECIFIERS* = 0x0080 + UNDNAME_NO_THROW_SIGNATURES* = 0x0100 + UNDNAME_NO_MEMBER_TYPE* = 0x0200 + UNDNAME_NO_RETURN_UDT_MODEL* = 0x0400 + UNDNAME_32_BIT_DECODE* = 0x0800 + UNDNAME_NAME_ONLY* = 0x1000 + UNDNAME_NO_ARGUMENTS* = 0x2000 + UNDNAME_NO_SPECIAL_SYMS* = 0x4000 + DBHHEADER_DEBUGDIRS* = 0x1 + DBHHEADER_CVMISC* = 0x2 + addrMode1616* = 0 + addrMode1632* = 1 + addrModeReal* = 2 + addrModeFlat* = 3 + API_VERSION_NUMBER* = 11 + SYMFLAG_VALUEPRESENT* = 0x00000001 + SYMFLAG_REGISTER* = 0x00000008 + SYMFLAG_REGREL* = 0x00000010 + SYMFLAG_FRAMEREL* = 0x00000020 + SYMFLAG_PARAMETER* = 0x00000040 + SYMFLAG_LOCAL* = 0x00000080 + SYMFLAG_CONSTANT* = 0x00000100 + SYMFLAG_EXPORT* = 0x00000200 + SYMFLAG_FORWARDER* = 0x00000400 + SYMFLAG_FUNCTION* = 0x00000800 + SYMFLAG_VIRTUAL* = 0x00001000 + SYMFLAG_THUNK* = 0x00002000 + SYMFLAG_TLSREL* = 0x00004000 + symNone* = 0 + symCoff* = 1 + symCv* = 2 + symPdb* = 3 + symExport* = 4 + symDeferred* = 5 + symSym* = 6 + symDia* = 7 + symVirtual* = 8 + numSymTypes* = 9 + CBA_DEFERRED_SYMBOL_LOAD_START* = 0x00000001 + CBA_DEFERRED_SYMBOL_LOAD_COMPLETE* = 0x00000002 + CBA_DEFERRED_SYMBOL_LOAD_FAILURE* = 0x00000003 + CBA_SYMBOLS_UNLOADED* = 0x00000004 + CBA_DUPLICATE_SYMBOL* = 0x00000005 + CBA_READ_MEMORY* = 0x00000006 + CBA_DEFERRED_SYMBOL_LOAD_CANCEL* = 0x00000007 + CBA_SET_OPTIONS* = 0x00000008 + CBA_EVENT* = 0x00000010 + CBA_DEFERRED_SYMBOL_LOAD_PARTIAL* = 0x00000020 + CBA_DEBUG_INFO* = 0x10000000 + CBA_SRCSRV_INFO* = 0x20000000 + CBA_SRCSRV_EVENT* = 0x40000000 + sevInfo* = 0 + sevProblem* = 1 + sevAttn* = 2 + sevFatal* = 3 + sevMax* = 4 + DSLFLAG_MISMATCHED_PDB* = 0x1 + DSLFLAG_MISMATCHED_DBG* = 0x2 + hdBase* = 0 + hdSym* = 1 + hdSrc* = 2 + hdMax* = 3 + SYMOPT_CASE_INSENSITIVE* = 0x00000001 + SYMOPT_UNDNAME* = 0x00000002 + SYMOPT_DEFERRED_LOADS* = 0x00000004 + SYMOPT_NO_CPP* = 0x00000008 + SYMOPT_LOAD_LINES* = 0x00000010 + SYMOPT_OMAP_FIND_NEAREST* = 0x00000020 + SYMOPT_LOAD_ANYTHING* = 0x00000040 + SYMOPT_IGNORE_CVREC* = 0x00000080 + SYMOPT_NO_UNQUALIFIED_LOADS* = 0x00000100 + SYMOPT_FAIL_CRITICAL_ERRORS* = 0x00000200 + SYMOPT_EXACT_SYMBOLS* = 0x00000400 + SYMOPT_ALLOW_ABSOLUTE_SYMBOLS* = 0x00000800 + SYMOPT_IGNORE_NT_SYMPATH* = 0x00001000 + SYMOPT_INCLUDE_32BIT_MODULES* = 0x00002000 + SYMOPT_PUBLICS_ONLY* = 0x00004000 + SYMOPT_NO_PUBLICS* = 0x00008000 + SYMOPT_AUTO_PUBLICS* = 0x00010000 + SYMOPT_NO_IMAGE_SEARCH* = 0x00020000 + SYMOPT_SECURE* = 0x00040000 + SYMOPT_NO_PROMPTS* = 0x00080000 + SYMOPT_ALLOW_ZERO_ADDRESS* = 0x01000000 + SYMOPT_DISABLE_SYMSRV_AUTODETECT* = 0x02000000 + SYMOPT_FAVOR_COMPRESSED* = 0x00800000 + SYMOPT_FLAT_DIRECTORY* = 0x00400000 + SYMOPT_IGNORE_IMAGEDIR* = 0x00200000 + SYMOPT_OVERWRITE* = 0x00100000 + SYMOPT_DEBUG* = 0x80000000'i32 + SLMFLAG_VIRTUAL* = 0x1 + SYMFLAG_CLR_TOKEN* = 0x00040000 + SYMFLAG_ILREL* = 0x00010000 + SYMFLAG_METADATA* = 0x00020000 + SYMFLAG_SLOT* = 0x00008000 + SYMENUMFLAG_FULLSRCH* = 1 + SYMENUMFLAG_SPEEDSRCH* = 2 + TI_GET_SYMTAG* = 0 + TI_GET_SYMNAME* = 1 + TI_GET_LENGTH* = 2 + TI_GET_TYPE* = 3 + TI_GET_TYPEID* = 4 + TI_GET_BASETYPE* = 5 + TI_GET_ARRAYINDEXTYPEID* = 6 + TI_FINDCHILDREN* = 7 + TI_GET_DATAKIND* = 8 + TI_GET_ADDRESSOFFSET* = 9 + TI_GET_OFFSET* = 10 + TI_GET_VALUE* = 11 + TI_GET_COUNT* = 12 + TI_GET_CHILDRENCOUNT* = 13 + TI_GET_BITPOSITION* = 14 + TI_GET_VIRTUALBASECLASS* = 15 + TI_GET_VIRTUALTABLESHAPEID* = 16 + TI_GET_VIRTUALBASEPOINTEROFFSET* = 17 + TI_GET_CLASSPARENTID* = 18 + TI_GET_NESTED* = 19 + TI_GET_SYMINDEX* = 20 + TI_GET_LEXICALPARENT* = 21 + TI_GET_ADDRESS* = 22 + TI_GET_THISADJUST* = 23 + TI_GET_UDTKIND* = 24 + TI_IS_EQUIV_TO* = 25 + TI_GET_CALLING_CONVENTION* = 26 + SYMF_OMAP_GENERATED* = 0x00000001 + SYMF_OMAP_MODIFIED* = 0x00000002 + SYMF_REGISTER* = 0x00000008 + SYMF_REGREL* = 0x00000010 + SYMF_FRAMEREL* = 0x00000020 + SYMF_PARAMETER* = 0x00000040 + SYMF_LOCAL* = 0x00000080 + SYMF_CONSTANT* = 0x00000100 + SYMF_EXPORT* = 0x00000200 + SYMF_FORWARDER* = 0x00000400 + SYMF_FUNCTION* = 0x00000800 + SYMF_VIRTUAL* = 0x00001000 + SYMF_THUNK* = 0x00002000 + SYMF_TLSREL* = 0x00004000 + IMAGEHLP_SYMBOL_INFO_VALUEPRESENT* = 1 + IMAGEHLP_SYMBOL_INFO_REGISTER* = SYMF_REGISTER + IMAGEHLP_SYMBOL_INFO_REGRELATIVE* = SYMF_REGREL + IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE* = SYMF_FRAMEREL + IMAGEHLP_SYMBOL_INFO_PARAMETER* = SYMF_PARAMETER + IMAGEHLP_SYMBOL_INFO_LOCAL* = SYMF_LOCAL + IMAGEHLP_SYMBOL_INFO_CONSTANT* = SYMF_CONSTANT + IMAGEHLP_SYMBOL_FUNCTION* = SYMF_FUNCTION + IMAGEHLP_SYMBOL_VIRTUAL* = SYMF_VIRTUAL + IMAGEHLP_SYMBOL_THUNK* = SYMF_THUNK + IMAGEHLP_SYMBOL_INFO_TLSRELATIVE* = SYMF_TLSREL + MINIDUMP_SIGNATURE* = 0x504D444D + MINIDUMP_VERSION* = 42899 + unusedStream* = 0 + reservedStream0* = 1 + reservedStream1* = 2 + threadListStream* = 3 + moduleListStream* = 4 + memoryListStream* = 5 + exceptionStream* = 6 + systemInfoStream* = 7 + threadExListStream* = 8 + memory64ListStream* = 9 + commentStreamA* = 10 + commentStreamW* = 11 + handleDataStream* = 12 + functionTableStream* = 13 + unloadedModuleListStream* = 14 + miscInfoStream* = 15 + memoryInfoListStream* = 16 + threadInfoListStream* = 17 + handleOperationListStream* = 18 + tokenStream* = 19 + ceStreamNull* = 0x8000 + ceStreamSystemInfo* = 0x8001 + ceStreamException* = 0x8002 + ceStreamModuleList* = 0x8003 + ceStreamProcessList* = 0x8004 + ceStreamThreadList* = 0x8005 + ceStreamThreadContextList* = 0x8006 + ceStreamThreadCallStackList* = 0x8007 + ceStreamMemoryVirtualList* = 0x8008 + ceStreamMemoryPhysicalList* = 0x8009 + ceStreamBucketParameters* = 0x800a + ceStreamProcessModuleMap* = 0x800b + ceStreamDiagnosisList* = 0x800c + lastReservedStream* = 0xffff + MINIDUMP_MISC1_PROCESS_ID* = 0x00000001 + MINIDUMP_MISC1_PROCESS_TIMES* = 0x00000002 + MINIDUMP_MISC1_PROCESSOR_POWER_INFO* = 0x00000004 + moduleCallback* = 0 + threadCallback* = 1 + threadExCallback* = 2 + includeThreadCallback* = 3 + includeModuleCallback* = 4 + memoryCallback* = 5 + cancelCallback* = 6 + writeKernelMinidumpCallback* = 7 + kernelMinidumpStatusCallback* = 8 + removeMemoryCallback* = 9 + includeVmRegionCallback* = 10 + ioStartCallback* = 11 + ioWriteAllCallback* = 12 + ioFinishCallback* = 13 + readMemoryFailureCallback* = 14 + secondaryFlagsCallback* = 15 + threadWriteThread* = 0x0001 + threadWriteStack* = 0x0002 + threadWriteContext* = 0x0004 + threadWriteBackingStore* = 0x0008 + threadWriteInstructionWindow* = 0x0010 + threadWriteThreadData* = 0x0020 + threadWriteThreadInfo* = 0x0040 + moduleWriteModule* = 0x0001 + moduleWriteDataSeg* = 0x0002 + moduleWriteMiscRecord* = 0x0004 + moduleWriteCvRecord* = 0x0008 + moduleReferencedByMemory* = 0x0010 + moduleWriteTlsData* = 0x0020 + moduleWriteCodeSegs* = 0x0040 + miniSecondaryWithoutPowerInfo* = 0x00000001 + miniDumpNormal* = 0x00000000 + miniDumpWithDataSegs* = 0x00000001 + miniDumpWithFullMemory* = 0x00000002 + miniDumpWithHandleData* = 0x00000004 + miniDumpFilterMemory* = 0x00000008 + miniDumpScanMemory* = 0x00000010 + miniDumpWithUnloadedModules* = 0x00000020 + miniDumpWithIndirectlyReferencedMemory* = 0x00000040 + miniDumpFilterModulePaths* = 0x00000080 + miniDumpWithProcessThreadData* = 0x00000100 + miniDumpWithPrivateReadWriteMemory* = 0x00000200 + miniDumpWithoutOptionalData* = 0x00000400 + miniDumpWithFullMemoryInfo* = 0x00000800 + miniDumpWithThreadInfo* = 0x00001000 + miniDumpWithCodeSegs* = 0x00002000 + miniDumpWithoutAuxiliaryState* = 0x00004000 + miniDumpWithFullAuxiliaryState* = 0x00008000 + miniDumpWithPrivateWriteCopyMemory* = 0x00010000 + miniDumpIgnoreInaccessibleMemory* = 0x00020000 + miniDumpWithTokenInformation* = 0x00040000 + MINIDUMP_THREAD_INFO_ERROR_THREAD* = 0x00000001 + MINIDUMP_THREAD_INFO_WRITING_THREAD* = 0x00000002 + MINIDUMP_THREAD_INFO_EXITED_THREAD* = 0x00000004 + MINIDUMP_THREAD_INFO_INVALID_INFO* = 0x00000008 + MINIDUMP_THREAD_INFO_INVALID_CONTEXT* = 0x00000010 + MINIDUMP_THREAD_INFO_INVALID_TEB* = 0x00000020 + SYMSEARCH_MASKOBJS* = 0x01 + SYMSEARCH_RECURSE* = 0x02 + SYMSEARCH_GLOBALSONLY* = 0x04 + SYMSEARCH_ALLITEMS* = 0x08 + SYMSTOREOPT_COMPRESS* = 0x01 + SYMSTOREOPT_OVERWRITE* = 0x02 + SYMSTOREOPT_RETURNINDEX* = 0x04 + SYMSTOREOPT_POINTER* = 0x08 + SYMSTOREOPT_PASS_IF_EXISTS* = 0x40 + SSRVOPT_RESET* = not ULONG_PTR(0) +type + PIMAGEHLP_STATUS_ROUTINE* = proc (Reason: IMAGEHLP_STATUS_REASON, ImageName: PCSTR, DllName: PCSTR, Va: ULONG_PTR, Parameter: ULONG_PTR): WINBOOL {.stdcall.} + PIMAGEHLP_STATUS_ROUTINE32* = proc (Reason: IMAGEHLP_STATUS_REASON, ImageName: PCSTR, DllName: PCSTR, Va: ULONG, Parameter: ULONG_PTR): WINBOOL {.stdcall.} + PIMAGEHLP_STATUS_ROUTINE64* = proc (Reason: IMAGEHLP_STATUS_REASON, ImageName: PCSTR, DllName: PCSTR, Va: ULONG64, Parameter: ULONG_PTR): WINBOOL {.stdcall.} + DIGEST_FUNCTION* = proc (refdata: DIGEST_HANDLE, pData: PBYTE, dwLength: DWORD): WINBOOL {.stdcall.} + PFIND_DEBUG_FILE_CALLBACK* = proc (FileHandle: HANDLE, FileName: PCSTR, CallerData: PVOID): WINBOOL {.stdcall.} + PFIND_DEBUG_FILE_CALLBACKW* = proc (FileHandle: HANDLE, FileName: PCWSTR, CallerData: PVOID): WINBOOL {.stdcall.} + PFINDFILEINPATHCALLBACK* = proc (filename: PCSTR, context: PVOID): WINBOOL {.stdcall.} + PFINDFILEINPATHCALLBACKW* = proc (filename: PCWSTR, context: PVOID): WINBOOL {.stdcall.} + PFIND_EXE_FILE_CALLBACK* = proc (FileHandle: HANDLE, FileName: PCSTR, CallerData: PVOID): WINBOOL {.stdcall.} + PFIND_EXE_FILE_CALLBACKW* = proc (FileHandle: HANDLE, FileName: PCWSTR, CallerData: PVOID): WINBOOL {.stdcall.} + PSYMBOLSERVERPROC* = proc (P1: LPCSTR, P2: LPCSTR, P3: PVOID, P4: DWORD, P5: DWORD, P6: LPSTR): WINBOOL {.stdcall.} + PSYMBOLSERVEROPENPROC* = proc (): WINBOOL {.stdcall.} + PSYMBOLSERVERCLOSEPROC* = proc (): WINBOOL {.stdcall.} + PSYMBOLSERVERSETOPTIONSPROC* = proc (P1: UINT_PTR, P2: ULONG64): WINBOOL {.stdcall.} + PSYMBOLSERVERCALLBACKPROC* = proc (action: UINT_PTR, data: ULONG64, context: ULONG64): WINBOOL {.stdcall.} + PSYMBOLSERVERGETOPTIONSPROC* = proc (): UINT_PTR {.stdcall.} + PSYMBOLSERVERPINGPROC* = proc (P1: LPCSTR): WINBOOL {.stdcall.} + PENUMDIRTREE_CALLBACK* = proc (FilePath: LPCSTR, CallerData: PVOID): WINBOOL {.stdcall.} + PREAD_PROCESS_MEMORY_ROUTINE64* = proc (hProcess: HANDLE, qwBaseAddress: DWORD64, lpBuffer: PVOID, nSize: DWORD, lpNumberOfBytesRead: LPDWORD): WINBOOL {.stdcall.} + PFUNCTION_TABLE_ACCESS_ROUTINE64* = proc (hProcess: HANDLE, AddrBase: DWORD64): PVOID {.stdcall.} + PGET_MODULE_BASE_ROUTINE64* = proc (hProcess: HANDLE, Address: DWORD64): DWORD64 {.stdcall.} + PTRANSLATE_ADDRESS_ROUTINE64* = proc (hProcess: HANDLE, hThread: HANDLE, lpaddr: LPADDRESS64): DWORD64 {.stdcall.} + PSYM_ENUMMODULES_CALLBACK64* = proc (ModuleName: PCSTR, BaseOfDll: DWORD64, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMMODULES_CALLBACKW64* = proc (ModuleName: PCWSTR, BaseOfDll: DWORD64, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMSYMBOLS_CALLBACK64* = proc (SymbolName: PCSTR, SymbolAddress: DWORD64, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMSYMBOLS_CALLBACK64W* = proc (SymbolName: PCWSTR, SymbolAddress: DWORD64, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PENUMLOADED_MODULES_CALLBACK64* = proc (ModuleName: PCSTR, ModuleBase: DWORD64, ModuleSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PENUMLOADED_MODULES_CALLBACKW64* = proc (ModuleName: PCWSTR, ModuleBase: DWORD64, ModuleSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYMBOL_REGISTERED_CALLBACK64* = proc (hProcess: HANDLE, ActionCode: ULONG, CallbackData: ULONG64, UserContext: ULONG64): WINBOOL {.stdcall.} + PSYMBOL_FUNCENTRY_CALLBACK64* = proc (hProcess: HANDLE, AddrBase: ULONG64, UserContext: ULONG64): PVOID {.stdcall.} + PSYM_ENUMSOURCEFILES_CALLBACKW* = proc (pSourceFile: PSOURCEFILEW, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMLINES_CALLBACK* = proc (LineInfo: PSRCCODEINFO, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMLINES_CALLBACKW* = proc (LineInfo: PSRCCODEINFOW, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMERATESYMBOLS_CALLBACK* = proc (pSymInfo: PSYMBOL_INFO, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMERATESYMBOLS_CALLBACKW* = proc (pSymInfo: PSYMBOL_INFOW, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PDBGHELP_CREATE_USER_DUMP_CALLBACK* = proc (DataType: DWORD, Data: ptr PVOID, DataLength: LPDWORD, UserData: PVOID): WINBOOL {.stdcall.} + TI_FINDCHILDREN_PARAMS* {.pure.} = object + Count*: ULONG + Start*: ULONG + ChildId*: array[1, ULONG] + MINIDUMP_LOCATION_DESCRIPTOR64* {.pure.} = object + DataSize*: ULONG64 + Rva*: RVA64 +proc BindImage*(ImageName: PCSTR, DllPath: PCSTR, SymbolPath: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc BindImageEx*(Flags: DWORD, ImageName: PCSTR, DllPath: PCSTR, SymbolPath: PCSTR, StatusRoutine: PIMAGEHLP_STATUS_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ReBaseImage*(CurrentImageName: PCSTR, SymbolPath: PCSTR, fReBase: WINBOOL, fRebaseSysfileOk: WINBOOL, fGoingDown: WINBOOL, CheckImageSize: ULONG, OldImageSize: ptr ULONG, OldImageBase: ptr ULONG_PTR, NewImageSize: ptr ULONG, NewImageBase: ptr ULONG_PTR, TimeStamp: ULONG): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ReBaseImage64*(CurrentImageName: PCSTR, SymbolPath: PCSTR, fReBase: WINBOOL, fRebaseSysfileOk: WINBOOL, fGoingDown: WINBOOL, CheckImageSize: ULONG, OldImageSize: ptr ULONG, OldImageBase: ptr ULONG64, NewImageSize: ptr ULONG, NewImageBase: ptr ULONG64, TimeStamp: ULONG): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc GetImageConfigInformation*(LoadedImage: PLOADED_IMAGE, ImageConfigInformation: PIMAGE_LOAD_CONFIG_DIRECTORY): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc GetImageUnusedHeaderBytes*(LoadedImage: PLOADED_IMAGE, SizeUnusedHeaderBytes: PDWORD): DWORD {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc SetImageConfigInformation*(LoadedImage: PLOADED_IMAGE, ImageConfigInformation: PIMAGE_LOAD_CONFIG_DIRECTORY): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc CheckSumMappedFile*(BaseAddress: PVOID, FileLength: DWORD, HeaderSum: PDWORD, CheckSum: PDWORD): PIMAGE_NT_HEADERS {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc MapFileAndCheckSumA*(Filename: PCSTR, HeaderSum: PDWORD, CheckSum: PDWORD): DWORD {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc MapFileAndCheckSumW*(Filename: PCWSTR, HeaderSum: PDWORD, CheckSum: PDWORD): DWORD {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageGetDigestStream*(FileHandle: HANDLE, DigestLevel: DWORD, DigestFunction: DIGEST_FUNCTION, DigestHandle: DIGEST_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageAddCertificate*(FileHandle: HANDLE, Certificate: LPWIN_CERTIFICATE, Index: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageRemoveCertificate*(FileHandle: HANDLE, Index: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageEnumerateCertificates*(FileHandle: HANDLE, TypeFilter: WORD, CertificateCount: PDWORD, Indices: PDWORD, IndexCount: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageGetCertificateData*(FileHandle: HANDLE, CertificateIndex: DWORD, Certificate: LPWIN_CERTIFICATE, RequiredLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageGetCertificateHeader*(FileHandle: HANDLE, CertificateIndex: DWORD, Certificateheader: LPWIN_CERTIFICATE): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageLoad*(DllName: PCSTR, DllPath: PCSTR): PLOADED_IMAGE {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc ImageUnload*(LoadedImage: PLOADED_IMAGE): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc MapAndLoad*(ImageName: PCSTR, DllPath: PCSTR, LoadedImage: PLOADED_IMAGE, DotDll: WINBOOL, ReadOnly: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc UnMapAndLoad*(LoadedImage: PLOADED_IMAGE): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc TouchFileTimes*(FileHandle: HANDLE, pSystemTime: PSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc SplitSymbols*(ImageName: PSTR, SymbolsPath: PCSTR, SymbolFilePath: PSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc UpdateDebugInfoFile*(ImageFileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, NtHeaders: PIMAGE_NT_HEADERS32): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc UpdateDebugInfoFileEx*(ImageFileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, NtHeaders: PIMAGE_NT_HEADERS32, OldChecksum: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imagehlp", importc.} +proc FindDebugInfoFile*(FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc FindDebugInfoFileEx*(FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc FindDebugInfoFileExW*(FileName: PCWSTR, SymbolPath: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindFileInPath*(hprocess: HANDLE, SearchPath: PCSTR, FileName: PCSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: LPSTR, callback: PFINDFILEINPATHCALLBACK, context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindFileInPathW*(hprocess: HANDLE, SearchPath: PCWSTR, FileName: PCWSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: LPSTR, callback: PFINDFILEINPATHCALLBACKW, context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc FindExecutableImage*(FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc FindExecutableImageEx*(FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc FindExecutableImageExW*(FileName: PCWSTR, SymbolPath: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImageNtHeader*(Base: PVOID): PIMAGE_NT_HEADERS {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImageDirectoryEntryToDataEx*(Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, FoundHeader: ptr PIMAGE_SECTION_HEADER): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImageDirectoryEntryToData*(Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImageRvaToSection*(NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG): PIMAGE_SECTION_HEADER {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImageRvaToVa*(NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, LastRvaSection: ptr PIMAGE_SECTION_HEADER): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SearchTreeForFile*(RootPath: PSTR, InputPathName: PSTR, OutputPathBuffer: PSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SearchTreeForFileW*(RootPath: PWSTR, InputPathName: PWSTR, OutputPathBuffer: PWSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc EnumDirTree*(hProcess: HANDLE, RootPath: PSTR, InputPathName: PSTR, OutputPathBuffer: PSTR, Callback: PENUMDIRTREE_CALLBACK, CallbackData: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc MakeSureDirectoryPathExists*(DirPath: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc UnDecorateSymbolNameA*(DecoratedName: PCSTR, UnDecoratedName: PSTR, UndecoratedLength: DWORD, Flags: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc: "UnDecorateSymbolName".} +proc UnDecorateSymbolNameW*(DecoratedName: PCWSTR, UnDecoratedName: PWSTR, UndecoratedLength: DWORD, Flags: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc StackWalk64*(MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME64, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImagehlpApiVersion*(): LPAPI_VERSION {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc ImagehlpApiVersionEx*(AppVersion: LPAPI_VERSION): LPAPI_VERSION {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc GetTimestampForLoadedLibrary*(Module: HMODULE): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetParentWindow*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetHomeDirectory*(hProcess: HANDLE, dir: PCSTR): PCHAR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetHomeDirectoryW*(hProcess: HANDLE, dir: PCWSTR): PCHAR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetHomeDirectory*(`type`: DWORD, dir: PSTR, size: int): PCHAR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetHomeDirectoryW*(`type`: DWORD, dir: PWSTR, size: int): PWCHAR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetOptions*(SymOptions: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetOptions*(): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymCleanup*(hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymMatchString*(string: PCSTR, expression: PCSTR, fCase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymMatchStringW*(string: PCWSTR, expression: PCWSTR, fCase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSourceFiles*(hProcess: HANDLE, ModBase: ULONG64, Mask: PCSTR, cbSrcFiles: PSYM_ENUMSOURCEFILES_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSourceFilesW*(hProcess: HANDLE, ModBase: ULONG64, Mask: PCWSTR, cbSrcFiles: PSYM_ENUMSOURCEFILES_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumerateModules64*(hProcess: HANDLE, EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumerateModulesW64*(hProcess: HANDLE, EnumModulesCallback: PSYM_ENUMMODULES_CALLBACKW64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumerateSymbols64*(hProcess: HANDLE, BaseOfDll: DWORD64, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumerateSymbolsW64*(hProcess: HANDLE, BaseOfDll: DWORD64, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64W, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc EnumerateLoadedModulesA64*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "EnumerateLoadedModules64".} +proc EnumerateLoadedModulesW64*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACKW64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFunctionTableAccess64*(hProcess: HANDLE, AddrBase: DWORD64): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetModuleInfo64*(hProcess: HANDLE, qwAddr: DWORD64, ModuleInfo: PIMAGEHLP_MODULE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetModuleInfoW64*(hProcess: HANDLE, qwAddr: DWORD64, ModuleInfo: PIMAGEHLP_MODULEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetModuleBase64*(hProcess: HANDLE, qwAddr: DWORD64): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymNext64*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymPrev64*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumLines*(hProcess: HANDLE, Base: ULONG64, Obj: PCSTR, File: PCSTR, EnumLinesCallback: PSYM_ENUMLINES_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumLinesW*(hProcess: HANDLE, Base: ULONG64, Obj: PCWSTR, File: PCSTR, EnumLinesCallback: PSYM_ENUMLINES_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineFromAddr64*(hProcess: HANDLE, qwAddr: DWORD64, pdwDisplacement: PDWORD, Line64: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineFromAddrW64*(hProcess: HANDLE, qwAddr: DWORD64, pdwDisplacement: PDWORD, Line64: PIMAGEHLP_LINEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineFromName64*(hProcess: HANDLE, ModuleName: PCSTR, FileName: PCSTR, dwLineNumber: DWORD, plDisplacement: PLONG, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineFromNameW64*(hProcess: HANDLE, ModuleName: PCWSTR, FileName: PCWSTR, dwLineNumber: DWORD, plDisplacement: PLONG, Line: PIMAGEHLP_LINEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineNext64*(hProcess: HANDLE, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLineNextW64*(hProcess: HANDLE, Line: PIMAGEHLP_LINEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLinePrev64*(hProcess: HANDLE, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetLinePrevW64*(hProcess: HANDLE, Line: PIMAGEHLP_LINEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymMatchFileName*(FileName: PCSTR, Match: PCSTR, FileNameStop: ptr PSTR, MatchStop: ptr PSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymMatchFileNameW*(FileName: PCWSTR, Match: PCWSTR, FileNameStop: ptr PWSTR, MatchStop: ptr PWSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymInitialize*(hProcess: HANDLE, UserSearchPath: PCSTR, fInvadeProcess: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymInitializeW*(hProcess: HANDLE, UserSearchPath: PCWSTR, fInvadeProcess: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSearchPath*(hProcess: HANDLE, SearchPath: PSTR, SearchPathLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSearchPathW*(hProcess: HANDLE, SearchPath: PWSTR, SearchPathLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetSearchPath*(hProcess: HANDLE, SearchPath: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetSearchPathW*(hProcess: HANDLE, SearchPath: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymLoadModule64*(hProcess: HANDLE, hFile: HANDLE, ImageName: PSTR, ModuleName: PSTR, BaseOfDll: DWORD64, SizeOfDll: DWORD): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymLoadModuleEx*(hProcess: HANDLE, hFile: HANDLE, ImageName: PCSTR, ModuleName: PCSTR, BaseOfDll: DWORD64, DllSize: DWORD, Data: PMODLOAD_DATA, Flags: DWORD): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymLoadModuleExW*(hProcess: HANDLE, hFile: HANDLE, ImageName: PCWSTR, ModuleName: PCWSTR, BaseOfDll: DWORD64, DllSize: DWORD, Data: PMODLOAD_DATA, Flags: DWORD): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymUnloadModule64*(hProcess: HANDLE, BaseOfDll: DWORD64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymUnDName64*(sym: PIMAGEHLP_SYMBOL64, UnDecName: PSTR, UnDecNameLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymRegisterCallback64*(hProcess: HANDLE, CallbackFunction: PSYMBOL_REGISTERED_CALLBACK64, UserContext: ULONG64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymRegisterFunctionEntryCallback64*(hProcess: HANDLE, CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK64, UserContext: ULONG64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSetContext*(hProcess: HANDLE, StackFrame: PIMAGEHLP_STACK_FRAME, Context: PIMAGEHLP_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromAddr*(hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromAddrW*(hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromToken*(hProcess: HANDLE, Base: DWORD64, Token: DWORD, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromTokenW*(hProcess: HANDLE, Base: DWORD64, Token: DWORD, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromName*(hProcess: HANDLE, Name: PCSTR, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromNameW*(hProcess: HANDLE, Name: PCWSTR, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSymbols*(hProcess: HANDLE, BaseOfDll: ULONG64, Mask: PCSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSymbolsW*(hProcess: HANDLE, BaseOfDll: ULONG64, Mask: PCWSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSymbolsForAddr*(hProcess: HANDLE, Address: DWORD64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSymbolsForAddrW*(hProcess: HANDLE, Address: DWORD64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetTypeInfo*(hProcess: HANDLE, ModBase: DWORD64, TypeId: ULONG, GetType: IMAGEHLP_SYMBOL_TYPE_INFO, pInfo: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumTypes*(hProcess: HANDLE, BaseOfDll: ULONG64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumTypesW*(hProcess: HANDLE, BaseOfDll: ULONG64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetTypeFromName*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCSTR, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetTypeFromNameW*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCWSTR, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymAddSymbol*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCSTR, Address: DWORD64, Size: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymAddSymbolW*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCWSTR, Address: DWORD64, Size: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymDeleteSymbol*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCSTR, Address: DWORD64, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymDeleteSymbolW*(hProcess: HANDLE, BaseOfDll: ULONG64, Name: PCWSTR, Address: DWORD64, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc DbgHelpCreateUserDump*(FileName: LPCSTR, Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK, UserData: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc DbgHelpCreateUserDumpW*(FileName: LPCWSTR, Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK, UserData: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymFromAddr64*(hProcess: HANDLE, qwAddr: DWORD64, pdwDisplacement: PDWORD64, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymFromName64*(hProcess: HANDLE, Name: PCSTR, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc MiniDumpWriteDump*(hProcess: HANDLE, ProcessId: DWORD, hFile: HANDLE, DumpType: MINIDUMP_TYPE, ExceptionParam: PMINIDUMP_EXCEPTION_INFORMATION, UserStreamParam: PMINIDUMP_USER_STREAM_INFORMATION, CallbackParam: PMINIDUMP_CALLBACK_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc MiniDumpReadDumpStream*(BaseOfDump: PVOID, StreamNumber: ULONG, Dir: ptr PMINIDUMP_DIRECTORY, StreamPointer: ptr PVOID, StreamSize: ptr ULONG): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc EnumerateLoadedModulesEx*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc EnumerateLoadedModulesExW*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACKW64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymAddSourceStream*(hProcess: HANDLE, Base: ULONG64, StreamFile: PCSTR, Buffer: PBYTE, Size: int): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymAddSourceStreamW*(hProcess: HANDLE, Base: ULONG64, StreamFile: PCWSTR, Buffer: PBYTE, Size: int): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSourceLines*(hProcess: HANDLE, Base: ULONG64, Obj: PCSTR, File: PCSTR, Line: DWORD, Flags: DWORD, EnumLinesCallback: PSYM_ENUMLINES_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumSourceLinesW*(hProcess: HANDLE, Base: ULONG64, Obj: PCWSTR, File: PCWSTR, Line: DWORD, Flags: DWORD, EnumLinesCallback: PSYM_ENUMLINES_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumTypesByName*(hProcess: HANDLE, BaseOfDll: ULONG64, mask: PCSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymEnumTypesByNameW*(hProcess: HANDLE, BaseOfDll: ULONG64, mask: PCSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindDebugInfoFile*(hProcess: HANDLE, FileName: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindDebugInfoFileW*(hProcess: HANDLE, FileName: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindExecutableImage*(hProcess: HANDLE, FileName: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFindExecutableImageW*(hProcess: HANDLE, FileName: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID): HANDLE {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromIndex*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymFromIndexW*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetScope*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetScopeW*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFileFromToken*(hProcess: HANDLE, Token: PVOID, Params: PCSTR, FilePath: PSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFileFromTokenW*(hProcess: HANDLE, Token: PVOID, Params: PCWSTR, FilePath: PWSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFileToken*(hProcess: HANDLE, Base: ULONG64, FileSpec: PCSTR, Token: ptr PVOID, Size: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFileTokenW*(hProcess: HANDLE, Base: ULONG64, FileSpec: PCWSTR, Token: ptr PVOID, Size: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFile*(hProcess: HANDLE, Base: ULONG64, Params: PCSTR, FileSpec: PCSTR, FilePath: PSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceFileW*(hProcess: HANDLE, Base: ULONG64, Params: PCWSTR, FileSpec: PCWSTR, FilePath: PWSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceVarFromToken*(hProcess: HANDLE, Token: PVOID, Params: PCSTR, VarName: PCSTR, Value: PSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSourceVarFromTokenW*(hProcess: HANDLE, Token: PVOID, Params: PCWSTR, VarName: PCWSTR, Value: PWSTR, Size: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymbolFile*(hProcess: HANDLE, SymPath: PCSTR, ImageFile: PCSTR, Type: DWORD, SymbolFile: PSTR, cSymbolFile: int, DbgFile: PSTR, cDbgFile: int): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymGetSymbolFileW*(hProcess: HANDLE, SymPath: PCWSTR, ImageFile: PCWSTR, Type: DWORD, SymbolFile: PWSTR, cSymbolFile: int, DbgFile: PWSTR, cDbgFile: int): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymNext*(hProcess: HANDLE, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymNextW*(hProcess: HANDLE, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymPrev*(hProcess: HANDLE, Symbol: PSYMBOL_INFO): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymPrevW*(hProcess: HANDLE, Symbol: PSYMBOL_INFOW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymRefreshModuleList*(hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSearch*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, SymTag: DWORD, Mask: PCSTR, Address: DWORD64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK, UserContext: PVOID, Options: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSearchW*(hProcess: HANDLE, BaseOfDll: ULONG64, Index: DWORD, SymTag: DWORD, Mask: PCWSTR, Address: DWORD64, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, UserContext: PVOID, Options: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvGetFileIndexStringA*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Index: PSTR, Size: int, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexString".} +proc SymSrvGetFileIndexStringW*(hProcess: HANDLE, SrvPath: PCWSTR, File: PCWSTR, Index: PWSTR, Size: int, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvGetFileIndexInfoA*(File: PCSTR, Info: PSYMSRV_INDEX_INFO, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexInfo".} +proc SymSrvGetFileIndexInfoW*(File: PCWSTR, Info: PSYMSRV_INDEX_INFOW, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvGetFileIndexesA*(File: PCSTR, Id: ptr GUID, Val1: ptr DWORD, Val2: ptr DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexes".} +proc SymSrvGetFileIndexesW*(File: PCWSTR, Id: ptr GUID, Val1: ptr DWORD, Val2: ptr DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvGetSupplementA*(hProcess: HANDLE, SymPath: PCSTR, Node: PCSTR, File: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetSupplement".} +proc SymSrvGetSupplementW*(hProcess: HANDLE, SymPath: PCWSTR, Node: PCWSTR, File: PCWSTR): PCWSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvIsStoreA*(hProcess: HANDLE, path: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvIsStore".} +proc SymSrvIsStoreW*(hProcess: HANDLE, path: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvStoreFileA*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvStoreFile".} +proc SymSrvStoreFileW*(hProcess: HANDLE, SrvPath: PCWSTR, File: PCWSTR, Flags: DWORD): PCWSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvStoreSupplementA*(hProcess: HANDLE, SymPath: PCTSTR, Node: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvStoreSupplement".} +proc SymSrvStoreSupplementW*(hProcess: HANDLE, SymPath: PCWSTR, Node: PCWSTR, File: PCWSTR, Flags: DWORD): PCWSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc SymSrvDeltaNameA*(hProcess: HANDLE, SymPath: PCSTR, Type: PCSTR, File1: PCSTR, File2: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvDeltaName".} +proc SymSrvDeltaNameW*(hProcess: HANDLE, SymPath: PCWSTR, Type: PCWSTR, File1: PCWSTR, File2: PCWSTR): PCWSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} +proc `Reserved=`*(self: var MINIDUMP_HEADER, x: ULONG32) {.inline.} = self.union1.Reserved = x +proc Reserved*(self: MINIDUMP_HEADER): ULONG32 {.inline.} = self.union1.Reserved +proc Reserved*(self: var MINIDUMP_HEADER): var ULONG32 {.inline.} = self.union1.Reserved +proc `TimeDateStamp=`*(self: var MINIDUMP_HEADER, x: ULONG32) {.inline.} = self.union1.TimeDateStamp = x +proc TimeDateStamp*(self: MINIDUMP_HEADER): ULONG32 {.inline.} = self.union1.TimeDateStamp +proc TimeDateStamp*(self: var MINIDUMP_HEADER): var ULONG32 {.inline.} = self.union1.TimeDateStamp +proc `Reserved0=`*(self: var MINIDUMP_SYSTEM_INFO, x: USHORT) {.inline.} = self.union1.Reserved0 = x +proc Reserved0*(self: MINIDUMP_SYSTEM_INFO): USHORT {.inline.} = self.union1.Reserved0 +proc Reserved0*(self: var MINIDUMP_SYSTEM_INFO): var USHORT {.inline.} = self.union1.Reserved0 +proc `NumberOfProcessors=`*(self: var MINIDUMP_SYSTEM_INFO, x: UCHAR) {.inline.} = self.union1.struct1.NumberOfProcessors = x +proc NumberOfProcessors*(self: MINIDUMP_SYSTEM_INFO): UCHAR {.inline.} = self.union1.struct1.NumberOfProcessors +proc NumberOfProcessors*(self: var MINIDUMP_SYSTEM_INFO): var UCHAR {.inline.} = self.union1.struct1.NumberOfProcessors +proc `ProductType=`*(self: var MINIDUMP_SYSTEM_INFO, x: UCHAR) {.inline.} = self.union1.struct1.ProductType = x +proc ProductType*(self: MINIDUMP_SYSTEM_INFO): UCHAR {.inline.} = self.union1.struct1.ProductType +proc ProductType*(self: var MINIDUMP_SYSTEM_INFO): var UCHAR {.inline.} = self.union1.struct1.ProductType +proc `Reserved1=`*(self: var MINIDUMP_SYSTEM_INFO, x: ULONG32) {.inline.} = self.union2.Reserved1 = x +proc Reserved1*(self: MINIDUMP_SYSTEM_INFO): ULONG32 {.inline.} = self.union2.Reserved1 +proc Reserved1*(self: var MINIDUMP_SYSTEM_INFO): var ULONG32 {.inline.} = self.union2.Reserved1 +proc `SuiteMask=`*(self: var MINIDUMP_SYSTEM_INFO, x: USHORT) {.inline.} = self.union2.struct1.SuiteMask = x +proc SuiteMask*(self: MINIDUMP_SYSTEM_INFO): USHORT {.inline.} = self.union2.struct1.SuiteMask +proc SuiteMask*(self: var MINIDUMP_SYSTEM_INFO): var USHORT {.inline.} = self.union2.struct1.SuiteMask +proc `Reserved2=`*(self: var MINIDUMP_SYSTEM_INFO, x: USHORT) {.inline.} = self.union2.struct1.Reserved2 = x +proc Reserved2*(self: MINIDUMP_SYSTEM_INFO): USHORT {.inline.} = self.union2.struct1.Reserved2 +proc Reserved2*(self: var MINIDUMP_SYSTEM_INFO): var USHORT {.inline.} = self.union2.struct1.Reserved2 +proc `Thread=`*(self: var MINIDUMP_CALLBACK_INPUT, x: MINIDUMP_THREAD_CALLBACK) {.inline.} = self.union1.Thread = x +proc Thread*(self: MINIDUMP_CALLBACK_INPUT): MINIDUMP_THREAD_CALLBACK {.inline.} = self.union1.Thread +proc Thread*(self: var MINIDUMP_CALLBACK_INPUT): var MINIDUMP_THREAD_CALLBACK {.inline.} = self.union1.Thread +proc `ThreadEx=`*(self: var MINIDUMP_CALLBACK_INPUT, x: MINIDUMP_THREAD_EX_CALLBACK) {.inline.} = self.union1.ThreadEx = x +proc ThreadEx*(self: MINIDUMP_CALLBACK_INPUT): MINIDUMP_THREAD_EX_CALLBACK {.inline.} = self.union1.ThreadEx +proc ThreadEx*(self: var MINIDUMP_CALLBACK_INPUT): var MINIDUMP_THREAD_EX_CALLBACK {.inline.} = self.union1.ThreadEx +proc `Module=`*(self: var MINIDUMP_CALLBACK_INPUT, x: MINIDUMP_MODULE_CALLBACK) {.inline.} = self.union1.Module = x +proc Module*(self: MINIDUMP_CALLBACK_INPUT): MINIDUMP_MODULE_CALLBACK {.inline.} = self.union1.Module +proc Module*(self: var MINIDUMP_CALLBACK_INPUT): var MINIDUMP_MODULE_CALLBACK {.inline.} = self.union1.Module +proc `IncludeThread=`*(self: var MINIDUMP_CALLBACK_INPUT, x: MINIDUMP_INCLUDE_THREAD_CALLBACK) {.inline.} = self.union1.IncludeThread = x +proc IncludeThread*(self: MINIDUMP_CALLBACK_INPUT): MINIDUMP_INCLUDE_THREAD_CALLBACK {.inline.} = self.union1.IncludeThread +proc IncludeThread*(self: var MINIDUMP_CALLBACK_INPUT): var MINIDUMP_INCLUDE_THREAD_CALLBACK {.inline.} = self.union1.IncludeThread +proc `IncludeModule=`*(self: var MINIDUMP_CALLBACK_INPUT, x: MINIDUMP_INCLUDE_MODULE_CALLBACK) {.inline.} = self.union1.IncludeModule = x +proc IncludeModule*(self: MINIDUMP_CALLBACK_INPUT): MINIDUMP_INCLUDE_MODULE_CALLBACK {.inline.} = self.union1.IncludeModule +proc IncludeModule*(self: var MINIDUMP_CALLBACK_INPUT): var MINIDUMP_INCLUDE_MODULE_CALLBACK {.inline.} = self.union1.IncludeModule +proc `ModuleWriteFlags=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: ULONG) {.inline.} = self.union1.ModuleWriteFlags = x +proc ModuleWriteFlags*(self: MINIDUMP_CALLBACK_OUTPUT): ULONG {.inline.} = self.union1.ModuleWriteFlags +proc ModuleWriteFlags*(self: var MINIDUMP_CALLBACK_OUTPUT): var ULONG {.inline.} = self.union1.ModuleWriteFlags +proc `ThreadWriteFlags=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: ULONG) {.inline.} = self.union1.ThreadWriteFlags = x +proc ThreadWriteFlags*(self: MINIDUMP_CALLBACK_OUTPUT): ULONG {.inline.} = self.union1.ThreadWriteFlags +proc ThreadWriteFlags*(self: var MINIDUMP_CALLBACK_OUTPUT): var ULONG {.inline.} = self.union1.ThreadWriteFlags +proc `SecondaryFlags=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: ULONG) {.inline.} = self.union1.SecondaryFlags = x +proc SecondaryFlags*(self: MINIDUMP_CALLBACK_OUTPUT): ULONG {.inline.} = self.union1.SecondaryFlags +proc SecondaryFlags*(self: var MINIDUMP_CALLBACK_OUTPUT): var ULONG {.inline.} = self.union1.SecondaryFlags +proc `MemoryBase=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: ULONG64) {.inline.} = self.union1.struct1.MemoryBase = x +proc MemoryBase*(self: MINIDUMP_CALLBACK_OUTPUT): ULONG64 {.inline.} = self.union1.struct1.MemoryBase +proc MemoryBase*(self: var MINIDUMP_CALLBACK_OUTPUT): var ULONG64 {.inline.} = self.union1.struct1.MemoryBase +proc `MemorySize=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: ULONG) {.inline.} = self.union1.struct1.MemorySize = x +proc MemorySize*(self: MINIDUMP_CALLBACK_OUTPUT): ULONG {.inline.} = self.union1.struct1.MemorySize +proc MemorySize*(self: var MINIDUMP_CALLBACK_OUTPUT): var ULONG {.inline.} = self.union1.struct1.MemorySize +proc `CheckCancel=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: WINBOOL) {.inline.} = self.union1.struct2.CheckCancel = x +proc CheckCancel*(self: MINIDUMP_CALLBACK_OUTPUT): WINBOOL {.inline.} = self.union1.struct2.CheckCancel +proc CheckCancel*(self: var MINIDUMP_CALLBACK_OUTPUT): var WINBOOL {.inline.} = self.union1.struct2.CheckCancel +proc `Cancel=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: WINBOOL) {.inline.} = self.union1.struct2.Cancel = x +proc Cancel*(self: MINIDUMP_CALLBACK_OUTPUT): WINBOOL {.inline.} = self.union1.struct2.Cancel +proc Cancel*(self: var MINIDUMP_CALLBACK_OUTPUT): var WINBOOL {.inline.} = self.union1.struct2.Cancel +proc `VmRegion=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: MINIDUMP_MEMORY_INFO) {.inline.} = self.struct1.VmRegion = x +proc VmRegion*(self: MINIDUMP_CALLBACK_OUTPUT): MINIDUMP_MEMORY_INFO {.inline.} = self.struct1.VmRegion +proc VmRegion*(self: var MINIDUMP_CALLBACK_OUTPUT): var MINIDUMP_MEMORY_INFO {.inline.} = self.struct1.VmRegion +proc `Continue=`*(self: var MINIDUMP_CALLBACK_OUTPUT, x: WINBOOL) {.inline.} = self.struct1.Continue = x +proc Continue*(self: MINIDUMP_CALLBACK_OUTPUT): WINBOOL {.inline.} = self.struct1.Continue +proc Continue*(self: var MINIDUMP_CALLBACK_OUTPUT): var WINBOOL {.inline.} = self.struct1.Continue +when winimUnicode: + proc UnDecorateSymbolName*(DecoratedName: PCSTR, UnDecoratedName: PSTR, UndecoratedLength: DWORD, Flags: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc: "UnDecorateSymbolNameW".} + proc EnumerateLoadedModules64*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "EnumerateLoadedModulesW64".} + proc SymSrvGetFileIndexString*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Index: PSTR, Size: int, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexStringW".} + proc SymSrvGetFileIndexInfo*(File: PCSTR, Info: PSYMSRV_INDEX_INFO, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexInfoW".} + proc SymSrvGetFileIndexes*(File: PCSTR, Id: ptr GUID, Val1: ptr DWORD, Val2: ptr DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetFileIndexesW".} + proc SymSrvGetSupplement*(hProcess: HANDLE, SymPath: PCSTR, Node: PCSTR, File: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvGetSupplementW".} + proc SymSrvIsStore*(hProcess: HANDLE, path: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvIsStoreW".} + proc SymSrvStoreFile*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvStoreFileW".} + proc SymSrvStoreSupplement*(hProcess: HANDLE, SymPath: PCTSTR, Node: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvStoreSupplementW".} + proc SymSrvDeltaName*(hProcess: HANDLE, SymPath: PCSTR, Type: PCSTR, File1: PCSTR, File2: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc: "SymSrvDeltaNameW".} + proc MapFileAndCheckSum*(Filename: PCWSTR, HeaderSum: PDWORD, CheckSum: PDWORD): DWORD {.winapi, stdcall, dynlib: "imagehlp", importc: "MapFileAndCheckSumW".} +when winimAnsi: + proc UnDecorateSymbolName*(DecoratedName: PCSTR, UnDecoratedName: PSTR, UndecoratedLength: DWORD, Flags: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc EnumerateLoadedModules64*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvGetFileIndexString*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Index: PSTR, Size: int, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvGetFileIndexInfo*(File: PCSTR, Info: PSYMSRV_INDEX_INFO, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvGetFileIndexes*(File: PCSTR, Id: ptr GUID, Val1: ptr DWORD, Val2: ptr DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvGetSupplement*(hProcess: HANDLE, SymPath: PCSTR, Node: PCSTR, File: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvIsStore*(hProcess: HANDLE, path: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvStoreFile*(hProcess: HANDLE, SrvPath: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvStoreSupplement*(hProcess: HANDLE, SymPath: PCTSTR, Node: PCSTR, File: PCSTR, Flags: DWORD): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymSrvDeltaName*(hProcess: HANDLE, SymPath: PCSTR, Type: PCSTR, File1: PCSTR, File2: PCSTR): PCSTR {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc MapFileAndCheckSum*(Filename: PCSTR, HeaderSum: PDWORD, CheckSum: PDWORD): DWORD {.winapi, stdcall, dynlib: "imagehlp", importc: "MapFileAndCheckSumA".} +when winimCpu64: + type + TADDRESS* = TADDRESS64 + LPADDRESS* = LPADDRESS64 + KDHELP* = KDHELP64 + PKDHELP* = PKDHELP64 + STACKFRAME* = STACKFRAME64 + LPSTACKFRAME* = LPSTACKFRAME64 + PREAD_PROCESS_MEMORY_ROUTINE* = PREAD_PROCESS_MEMORY_ROUTINE64 + PFUNCTION_TABLE_ACCESS_ROUTINE* = PFUNCTION_TABLE_ACCESS_ROUTINE64 + PGET_MODULE_BASE_ROUTINE* = PGET_MODULE_BASE_ROUTINE64 + PTRANSLATE_ADDRESS_ROUTINE* = PTRANSLATE_ADDRESS_ROUTINE64 + PSYM_ENUMMODULES_CALLBACK* = PSYM_ENUMMODULES_CALLBACK64 + PSYM_ENUMSYMBOLS_CALLBACK* = PSYM_ENUMSYMBOLS_CALLBACK64 + PSYM_ENUMSYMBOLS_CALLBACKW* = PSYM_ENUMSYMBOLS_CALLBACK64W + PENUMLOADED_MODULES_CALLBACK* = PENUMLOADED_MODULES_CALLBACK64 + PSYMBOL_REGISTERED_CALLBACK* = PSYMBOL_REGISTERED_CALLBACK64 + PSYMBOL_FUNCENTRY_CALLBACK* = PSYMBOL_FUNCENTRY_CALLBACK64 + IMAGEHLP_SYMBOL* = IMAGEHLP_SYMBOL64 + PIMAGEHLP_SYMBOL* = PIMAGEHLP_SYMBOL64 + IMAGEHLP_SYMBOL_PACKAGE* = IMAGEHLP_SYMBOL64_PACKAGE + PIMAGEHLP_SYMBOL_PACKAGE* = PIMAGEHLP_SYMBOL64_PACKAGE + IMAGEHLP_MODULE* = IMAGEHLP_MODULE64 + PIMAGEHLP_MODULE* = PIMAGEHLP_MODULE64 + IMAGEHLP_MODULEW* = IMAGEHLP_MODULEW64 + PIMAGEHLP_MODULEW* = PIMAGEHLP_MODULEW64 + IMAGEHLP_LINE* = IMAGEHLP_LINE64 + PIMAGEHLP_LINE* = PIMAGEHLP_LINE64 + IMAGEHLP_DEFERRED_SYMBOL_LOAD* = IMAGEHLP_DEFERRED_SYMBOL_LOAD64 + PIMAGEHLP_DEFERRED_SYMBOL_LOAD* = PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 + IMAGEHLP_DUPLICATE_SYMBOL* = IMAGEHLP_DUPLICATE_SYMBOL64 + PIMAGEHLP_DUPLICATE_SYMBOL* = PIMAGEHLP_DUPLICATE_SYMBOL64 + proc StackWalk*(MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME64, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "StackWalk64".} + proc SymEnumerateModules*(hProcess: HANDLE, EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymEnumerateModules64".} + proc SymEnumerateSymbols*(hProcess: HANDLE, BaseOfDll: DWORD64, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymEnumerateSymbols64".} + proc SymEnumerateSymbolsW*(hProcess: HANDLE, BaseOfDll: DWORD64, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64W, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymEnumerateSymbolsW64".} + proc EnumerateLoadedModules*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "EnumerateLoadedModules64".} + proc SymFunctionTableAccess*(hProcess: HANDLE, AddrBase: DWORD64): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc: "SymFunctionTableAccess64".} + proc SymGetModuleInfo*(hProcess: HANDLE, qwAddr: DWORD64, ModuleInfo: PIMAGEHLP_MODULE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetModuleInfo64".} + proc SymGetModuleInfoW*(hProcess: HANDLE, qwAddr: DWORD64, ModuleInfo: PIMAGEHLP_MODULEW64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetModuleInfoW64".} + proc SymGetModuleBase*(hProcess: HANDLE, qwAddr: DWORD64): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetModuleBase64".} + proc SymGetSymNext*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetSymNext64".} + proc SymGetSymPrev*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetSymPrev64".} + proc SymGetLineFromAddr*(hProcess: HANDLE, qwAddr: DWORD64, pdwDisplacement: PDWORD, Line64: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetLineFromAddr64".} + proc SymGetLineFromName*(hProcess: HANDLE, ModuleName: PCSTR, FileName: PCSTR, dwLineNumber: DWORD, plDisplacement: PLONG, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetLineFromName64".} + proc SymGetLineNext*(hProcess: HANDLE, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetLineNext64".} + proc SymGetLinePrev*(hProcess: HANDLE, Line: PIMAGEHLP_LINE64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetLinePrev64".} + proc SymLoadModule*(hProcess: HANDLE, hFile: HANDLE, ImageName: PSTR, ModuleName: PSTR, BaseOfDll: DWORD64, SizeOfDll: DWORD): DWORD64 {.winapi, stdcall, dynlib: "dbghelp", importc: "SymLoadModule64".} + proc SymUnloadModule*(hProcess: HANDLE, BaseOfDll: DWORD64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymUnloadModule64".} + proc SymUnDName*(sym: PIMAGEHLP_SYMBOL64, UnDecName: PSTR, UnDecNameLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymUnDName64".} + proc SymRegisterCallback*(hProcess: HANDLE, CallbackFunction: PSYMBOL_REGISTERED_CALLBACK64, UserContext: ULONG64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymRegisterCallback64".} + proc SymRegisterFunctionEntryCallback*(hProcess: HANDLE, CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK64, UserContext: ULONG64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymRegisterFunctionEntryCallback64".} + proc SymGetSymFromAddr*(hProcess: HANDLE, qwAddr: DWORD64, pdwDisplacement: PDWORD64, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetSymFromAddr64".} + proc SymGetSymFromName*(hProcess: HANDLE, Name: PCSTR, Symbol: PIMAGEHLP_SYMBOL64): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc: "SymGetSymFromName64".} +when winimCpu32: + type + IMAGE_DEBUG_INFORMATION* {.pure.} = object + List*: LIST_ENTRY + ReservedSize*: DWORD + ReservedMappedBase*: PVOID + ReservedMachine*: USHORT + ReservedCharacteristics*: USHORT + ReservedCheckSum*: DWORD + ImageBase*: DWORD + SizeOfImage*: DWORD + ReservedNumberOfSections*: DWORD + ReservedSections*: PIMAGE_SECTION_HEADER + ReservedExportedNamesSize*: DWORD + ReservedExportedNames*: PSTR + ReservedNumberOfFunctionTableEntries*: DWORD + ReservedFunctionTableEntries*: PIMAGE_FUNCTION_ENTRY + ReservedLowestFunctionStartingAddress*: DWORD + ReservedHighestFunctionEndingAddress*: DWORD + ReservedNumberOfFpoTableEntries*: DWORD + ReservedFpoTableEntries*: PFPO_DATA + SizeOfCoffSymbols*: DWORD + CoffSymbols*: PIMAGE_COFF_SYMBOLS_HEADER + ReservedSizeOfCodeViewSymbols*: DWORD + ReservedCodeViewSymbols*: PVOID + ImageFilePath*: PSTR + ImageFileName*: PSTR + ReservedDebugFilePath*: PSTR + ReservedTimeDateStamp*: DWORD + ReservedRomImage*: WINBOOL + ReservedDebugDirectory*: PIMAGE_DEBUG_DIRECTORY + ReservedNumberOfDebugDirectories*: DWORD + ReservedOriginalFunctionTableBaseAddress*: DWORD + Reserved*: array[2, DWORD] + PIMAGE_DEBUG_INFORMATION* = ptr IMAGE_DEBUG_INFORMATION + TADDRESS* {.pure.} = object + Offset*: DWORD + Segment*: WORD + Mode*: ADDRESS_MODE + LPADDRESS* = ptr TADDRESS + KDHELP* {.pure.} = object + Thread*: DWORD + ThCallbackStack*: DWORD + NextCallback*: DWORD + FramePointer*: DWORD + KiCallUserMode*: DWORD + KeUserCallbackDispatcher*: DWORD + SystemRangeStart*: DWORD + ThCallbackBStore*: DWORD + KiUserExceptionDispatcher*: DWORD + StackBase*: DWORD + StackLimit*: DWORD + Reserved*: array[5, DWORD] + PKDHELP* = ptr KDHELP + STACKFRAME* {.pure.} = object + AddrPC*: TADDRESS + AddrReturn*: TADDRESS + AddrFrame*: TADDRESS + AddrStack*: TADDRESS + FuncTableEntry*: PVOID + Params*: array[4, DWORD] + Far*: WINBOOL + Virtual*: WINBOOL + Reserved*: array[3, DWORD] + KdHelp*: KDHELP + AddrBStore*: TADDRESS + LPSTACKFRAME* = ptr STACKFRAME + IMAGEHLP_SYMBOL* {.pure.} = object + SizeOfStruct*: DWORD + Address*: DWORD + Size*: DWORD + Flags*: DWORD + MaxNameLength*: DWORD + Name*: array[1, CHAR] + PIMAGEHLP_SYMBOL* = ptr IMAGEHLP_SYMBOL + IMAGEHLP_SYMBOL_PACKAGE* {.pure.} = object + sym*: IMAGEHLP_SYMBOL + name*: array[MAX_SYM_NAME+1, CHAR] + PIMAGEHLP_SYMBOL_PACKAGE* = ptr IMAGEHLP_SYMBOL_PACKAGE + IMAGEHLP_MODULE* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD + ImageSize*: DWORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + NumSyms*: DWORD + SymType*: SYM_TYPE + ModuleName*: array[32, CHAR] + ImageName*: array[256, CHAR] + LoadedImageName*: array[256, CHAR] + PIMAGEHLP_MODULE* = ptr IMAGEHLP_MODULE + IMAGEHLP_MODULEW* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD + ImageSize*: DWORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + NumSyms*: DWORD + SymType*: SYM_TYPE + ModuleName*: array[32, WCHAR] + ImageName*: array[256, WCHAR] + LoadedImageName*: array[256, WCHAR] + PIMAGEHLP_MODULEW* = ptr IMAGEHLP_MODULEW + IMAGEHLP_LINE* {.pure.} = object + SizeOfStruct*: DWORD + Key*: PVOID + LineNumber*: DWORD + FileName*: PCHAR + Address*: DWORD + PIMAGEHLP_LINE* = ptr IMAGEHLP_LINE + IMAGEHLP_DEFERRED_SYMBOL_LOAD* {.pure.} = object + SizeOfStruct*: DWORD + BaseOfImage*: DWORD + CheckSum*: DWORD + TimeDateStamp*: DWORD + FileName*: array[MAX_PATH, CHAR] + Reparse*: BOOLEAN + hFile*: HANDLE + PIMAGEHLP_DEFERRED_SYMBOL_LOAD* = ptr IMAGEHLP_DEFERRED_SYMBOL_LOAD + IMAGEHLP_DUPLICATE_SYMBOL* {.pure.} = object + SizeOfStruct*: DWORD + NumberOfDups*: DWORD + Symbol*: PIMAGEHLP_SYMBOL + SelectedSymbol*: DWORD + PIMAGEHLP_DUPLICATE_SYMBOL* = ptr IMAGEHLP_DUPLICATE_SYMBOL + PREAD_PROCESS_MEMORY_ROUTINE* = proc (hProcess: HANDLE, lpBaseAddress: DWORD, lpBuffer: PVOID, nSize: DWORD, lpNumberOfBytesRead: PDWORD): WINBOOL {.stdcall.} + PFUNCTION_TABLE_ACCESS_ROUTINE* = proc (hProcess: HANDLE, AddrBase: DWORD): PVOID {.stdcall.} + PGET_MODULE_BASE_ROUTINE* = proc (hProcess: HANDLE, Address: DWORD): DWORD {.stdcall.} + PTRANSLATE_ADDRESS_ROUTINE* = proc (hProcess: HANDLE, hThread: HANDLE, lpaddr: LPADDRESS): DWORD {.stdcall.} + PSYMBOL_FUNCENTRY_CALLBACK* = proc (hProcess: HANDLE, AddrBase: DWORD, UserContext: PVOID): PVOID {.stdcall.} + PSYM_ENUMMODULES_CALLBACK* = proc (ModuleName: PCSTR, BaseOfDll: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMSYMBOLS_CALLBACK* = proc (SymbolName: PCSTR, SymbolAddress: ULONG, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYM_ENUMSYMBOLS_CALLBACKW* = proc (SymbolName: PCWSTR, SymbolAddress: ULONG, SymbolSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PENUMLOADED_MODULES_CALLBACK* = proc (ModuleName: PCSTR, ModuleBase: ULONG, ModuleSize: ULONG, UserContext: PVOID): WINBOOL {.stdcall.} + PSYMBOL_REGISTERED_CALLBACK* = proc (hProcess: HANDLE, ActionCode: ULONG, CallbackData: PVOID, UserContext: PVOID): WINBOOL {.stdcall.} + proc StackWalk*(MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymEnumerateModules*(hProcess: HANDLE, EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymEnumerateSymbols*(hProcess: HANDLE, BaseOfDll: DWORD, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymEnumerateSymbolsW*(hProcess: HANDLE, BaseOfDll: DWORD, EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACKW, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc EnumerateLoadedModules*(hProcess: HANDLE, EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymFunctionTableAccess*(hProcess: HANDLE, AddrBase: DWORD): PVOID {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetModuleInfo*(hProcess: HANDLE, dwAddr: DWORD, ModuleInfo: PIMAGEHLP_MODULE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetModuleInfoW*(hProcess: HANDLE, dwAddr: DWORD, ModuleInfo: PIMAGEHLP_MODULEW): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetModuleBase*(hProcess: HANDLE, dwAddr: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetSymNext*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetSymPrev*(hProcess: HANDLE, Symbol: PIMAGEHLP_SYMBOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetLineFromAddr*(hProcess: HANDLE, dwAddr: DWORD, pdwDisplacement: PDWORD, Line: PIMAGEHLP_LINE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetLineFromName*(hProcess: HANDLE, ModuleName: PCSTR, FileName: PCSTR, dwLineNumber: DWORD, plDisplacement: PLONG, Line: PIMAGEHLP_LINE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetLineNext*(hProcess: HANDLE, Line: PIMAGEHLP_LINE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetLinePrev*(hProcess: HANDLE, Line: PIMAGEHLP_LINE): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymLoadModule*(hProcess: HANDLE, hFile: HANDLE, ImageName: PCSTR, ModuleName: PCSTR, BaseOfDll: DWORD, SizeOfDll: DWORD): DWORD {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymUnloadModule*(hProcess: HANDLE, BaseOfDll: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymUnDName*(sym: PIMAGEHLP_SYMBOL, UnDecName: PSTR, UnDecNameLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymRegisterCallback*(hProcess: HANDLE, CallbackFunction: PSYMBOL_REGISTERED_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymRegisterFunctionEntryCallback*(hProcess: HANDLE, CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK, UserContext: PVOID): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetSymFromAddr*(hProcess: HANDLE, dwAddr: DWORD, pdwDisplacement: PDWORD, Symbol: PIMAGEHLP_SYMBOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} + proc SymGetSymFromName*(hProcess: HANDLE, Name: PCSTR, Symbol: PIMAGEHLP_SYMBOL): WINBOOL {.winapi, stdcall, dynlib: "dbghelp", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/imm.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/imm.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,952 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import winuser +import objbase +#include +#include +type + HIMC* = HANDLE + HIMCC* = HANDLE + LPHKL* = ptr HKL + LPUINT* = ptr UINT + COMPOSITIONFORM* {.pure.} = object + dwStyle*: DWORD + ptCurrentPos*: POINT + rcArea*: RECT + PCOMPOSITIONFORM* = ptr COMPOSITIONFORM + NPCOMPOSITIONFORM* = ptr COMPOSITIONFORM + LPCOMPOSITIONFORM* = ptr COMPOSITIONFORM + CANDIDATEFORM* {.pure.} = object + dwIndex*: DWORD + dwStyle*: DWORD + ptCurrentPos*: POINT + rcArea*: RECT + PCANDIDATEFORM* = ptr CANDIDATEFORM + NPCANDIDATEFORM* = ptr CANDIDATEFORM + LPCANDIDATEFORM* = ptr CANDIDATEFORM + CANDIDATELIST* {.pure.} = object + dwSize*: DWORD + dwStyle*: DWORD + dwCount*: DWORD + dwSelection*: DWORD + dwPageStart*: DWORD + dwPageSize*: DWORD + dwOffset*: array[1, DWORD] + PCANDIDATELIST* = ptr CANDIDATELIST + NPCANDIDATELIST* = ptr CANDIDATELIST + LPCANDIDATELIST* = ptr CANDIDATELIST + REGISTERWORDA* {.pure.} = object + lpReading*: LPSTR + lpWord*: LPSTR + PREGISTERWORDA* = ptr REGISTERWORDA + NPREGISTERWORDA* = ptr REGISTERWORDA + LPREGISTERWORDA* = ptr REGISTERWORDA + REGISTERWORDW* {.pure.} = object + lpReading*: LPWSTR + lpWord*: LPWSTR + PREGISTERWORDW* = ptr REGISTERWORDW + NPREGISTERWORDW* = ptr REGISTERWORDW + LPREGISTERWORDW* = ptr REGISTERWORDW + RECONVERTSTRING* {.pure.} = object + dwSize*: DWORD + dwVersion*: DWORD + dwStrLen*: DWORD + dwStrOffset*: DWORD + dwCompStrLen*: DWORD + dwCompStrOffset*: DWORD + dwTargetStrLen*: DWORD + dwTargetStrOffset*: DWORD + PRECONVERTSTRING* = ptr RECONVERTSTRING + NPRECONVERTSTRING* = ptr RECONVERTSTRING + LPRECONVERTSTRING* = ptr RECONVERTSTRING +const + STYLE_DESCRIPTION_SIZE* = 32 +type + STYLEBUFA* {.pure.} = object + dwStyle*: DWORD + szDescription*: array[STYLE_DESCRIPTION_SIZE, CHAR] + PSTYLEBUFA* = ptr STYLEBUFA + NPSTYLEBUFA* = ptr STYLEBUFA + LPSTYLEBUFA* = ptr STYLEBUFA + STYLEBUFW* {.pure.} = object + dwStyle*: DWORD + szDescription*: array[STYLE_DESCRIPTION_SIZE, WCHAR] + PSTYLEBUFW* = ptr STYLEBUFW + NPSTYLEBUFW* = ptr STYLEBUFW + LPSTYLEBUFW* = ptr STYLEBUFW +const + IMEMENUITEM_STRING_SIZE* = 80 +type + IMEMENUITEMINFOA* {.pure.} = object + cbSize*: UINT + fType*: UINT + fState*: UINT + wID*: UINT + hbmpChecked*: HBITMAP + hbmpUnchecked*: HBITMAP + dwItemData*: DWORD + szString*: array[IMEMENUITEM_STRING_SIZE, CHAR] + hbmpItem*: HBITMAP + PIMEMENUITEMINFOA* = ptr IMEMENUITEMINFOA + NPIMEMENUITEMINFOA* = ptr IMEMENUITEMINFOA + LPIMEMENUITEMINFOA* = ptr IMEMENUITEMINFOA + IMEMENUITEMINFOW* {.pure.} = object + cbSize*: UINT + fType*: UINT + fState*: UINT + wID*: UINT + hbmpChecked*: HBITMAP + hbmpUnchecked*: HBITMAP + dwItemData*: DWORD + szString*: array[IMEMENUITEM_STRING_SIZE, WCHAR] + hbmpItem*: HBITMAP + PIMEMENUITEMINFOW* = ptr IMEMENUITEMINFOW + NPIMEMENUITEMINFOW* = ptr IMEMENUITEMINFOW + LPIMEMENUITEMINFOW* = ptr IMEMENUITEMINFOW + IMECHARPOSITION* {.pure.} = object + dwSize*: DWORD + dwCharPos*: DWORD + pt*: POINT + cLineHeight*: UINT + rcDocument*: RECT + PIMECHARPOSITION* = ptr IMECHARPOSITION + NPIMECHARPOSITION* = ptr IMECHARPOSITION + LPIMECHARPOSITION* = ptr IMECHARPOSITION +const + IMC_GETCANDIDATEPOS* = 0x0007 + IMC_SETCANDIDATEPOS* = 0x0008 + IMC_GETCOMPOSITIONFONT* = 0x0009 + IMC_SETCOMPOSITIONFONT* = 0x000A + IMC_GETCOMPOSITIONWINDOW* = 0x000B + IMC_SETCOMPOSITIONWINDOW* = 0x000C + IMC_GETSTATUSWINDOWPOS* = 0x000F + IMC_SETSTATUSWINDOWPOS* = 0x0010 + IMC_CLOSESTATUSWINDOW* = 0x0021 + IMC_OPENSTATUSWINDOW* = 0x0022 + NI_OPENCANDIDATE* = 0x0010 + NI_CLOSECANDIDATE* = 0x0011 + NI_SELECTCANDIDATESTR* = 0x0012 + NI_CHANGECANDIDATELIST* = 0x0013 + NI_FINALIZECONVERSIONRESULT* = 0x0014 + NI_COMPOSITIONSTR* = 0x0015 + NI_SETCANDIDATE_PAGESTART* = 0x0016 + NI_SETCANDIDATE_PAGESIZE* = 0x0017 + NI_IMEMENUSELECTED* = 0x0018 + ISC_SHOWUICANDIDATEWINDOW* = 0x00000001 + ISC_SHOWUICOMPOSITIONWINDOW* = 0x80000000'i32 + ISC_SHOWUIGUIDELINE* = 0x40000000 + ISC_SHOWUIALLCANDIDATEWINDOW* = 0x0000000F + ISC_SHOWUIALL* = 0xC000000F'i32 + CPS_COMPLETE* = 0x0001 + CPS_CONVERT* = 0x0002 + CPS_REVERT* = 0x0003 + CPS_CANCEL* = 0x0004 + MOD_LEFT* = 0x8000 + MOD_RIGHT* = 0x4000 + MOD_ON_KEYUP* = 0x0800 + MOD_IGNORE_ALL_MODIFIER* = 0x0400 + IME_CHOTKEY_IME_NONIME_TOGGLE* = 0x10 + IME_CHOTKEY_SHAPE_TOGGLE* = 0x11 + IME_CHOTKEY_SYMBOL_TOGGLE* = 0x12 + IME_JHOTKEY_CLOSE_OPEN* = 0x30 + IME_KHOTKEY_SHAPE_TOGGLE* = 0x50 + IME_KHOTKEY_HANJACONVERT* = 0x51 + IME_KHOTKEY_ENGLISH* = 0x52 + IME_THOTKEY_IME_NONIME_TOGGLE* = 0x70 + IME_THOTKEY_SHAPE_TOGGLE* = 0x71 + IME_THOTKEY_SYMBOL_TOGGLE* = 0x72 + IME_HOTKEY_DSWITCH_FIRST* = 0x100 + IME_HOTKEY_DSWITCH_LAST* = 0x11F + IME_HOTKEY_PRIVATE_FIRST* = 0x200 + IME_ITHOTKEY_RESEND_RESULTSTR* = 0x200 + IME_ITHOTKEY_PREVIOUS_COMPOSITION* = 0x201 + IME_ITHOTKEY_UISTYLE_TOGGLE* = 0x202 + IME_ITHOTKEY_RECONVERTSTRING* = 0x203 + IME_HOTKEY_PRIVATE_LAST* = 0x21F + GCS_COMPREADSTR* = 0x0001 + GCS_COMPREADATTR* = 0x0002 + GCS_COMPREADCLAUSE* = 0x0004 + GCS_COMPSTR* = 0x0008 + GCS_COMPATTR* = 0x0010 + GCS_COMPCLAUSE* = 0x0020 + GCS_CURSORPOS* = 0x0080 + GCS_DELTASTART* = 0x0100 + GCS_RESULTREADSTR* = 0x0200 + GCS_RESULTREADCLAUSE* = 0x0400 + GCS_RESULTSTR* = 0x0800 + GCS_RESULTCLAUSE* = 0x1000 + CS_INSERTCHAR* = 0x2000 + CS_NOMOVECARET* = 0x4000 + IMEVER_0310* = 0x0003000A + IMEVER_0400* = 0x00040000 + IME_PROP_AT_CARET* = 0x00010000 + IME_PROP_SPECIAL_UI* = 0x00020000 + IME_PROP_CANDLIST_START_FROM_1* = 0x00040000 + IME_PROP_UNICODE* = 0x00080000 + IME_PROP_COMPLETE_ON_UNSELECT* = 0x00100000 + UI_CAP_2700* = 0x00000001 + UI_CAP_ROT90* = 0x00000002 + UI_CAP_ROTANY* = 0x00000004 + SCS_CAP_COMPSTR* = 0x00000001 + SCS_CAP_MAKEREAD* = 0x00000002 + SCS_CAP_SETRECONVERTSTRING* = 0x00000004 + SELECT_CAP_CONVERSION* = 0x00000001 + SELECT_CAP_SENTENCE* = 0x00000002 + GGL_LEVEL* = 0x00000001 + GGL_INDEX* = 0x00000002 + GGL_STRING* = 0x00000003 + GGL_PRIVATE* = 0x00000004 + GL_LEVEL_NOGUIDELINE* = 0x00000000 + GL_LEVEL_FATAL* = 0x00000001 + GL_LEVEL_ERROR* = 0x00000002 + GL_LEVEL_WARNING* = 0x00000003 + GL_LEVEL_INFORMATION* = 0x00000004 + GL_ID_UNKNOWN* = 0x00000000 + GL_ID_NOMODULE* = 0x00000001 + GL_ID_NODICTIONARY* = 0x00000010 + GL_ID_CANNOTSAVE* = 0x00000011 + GL_ID_NOCONVERT* = 0x00000020 + GL_ID_TYPINGERROR* = 0x00000021 + GL_ID_TOOMANYSTROKE* = 0x00000022 + GL_ID_READINGCONFLICT* = 0x00000023 + GL_ID_INPUTREADING* = 0x00000024 + GL_ID_INPUTRADICAL* = 0x00000025 + GL_ID_INPUTCODE* = 0x00000026 + GL_ID_INPUTSYMBOL* = 0x00000027 + GL_ID_CHOOSECANDIDATE* = 0x00000028 + GL_ID_REVERSECONVERSION* = 0x00000029 + GL_ID_PRIVATE_FIRST* = 0x00008000 + GL_ID_PRIVATE_LAST* = 0x0000FFFF + IGP_PROPERTY* = 0x00000004 + IGP_CONVERSION* = 0x00000008 + IGP_SENTENCE* = 0x0000000c + IGP_UI* = 0x00000010 + IGP_SETCOMPSTR* = 0x00000014 + IGP_SELECT* = 0x00000018 + SCS_SETSTR* = GCS_COMPREADSTR or GCS_COMPSTR + SCS_CHANGEATTR* = GCS_COMPREADATTR or GCS_COMPATTR + SCS_CHANGECLAUSE* = GCS_COMPREADCLAUSE or GCS_COMPCLAUSE + SCS_SETRECONVERTSTRING* = 0x00010000 + SCS_QUERYRECONVERTSTRING* = 0x00020000 + ATTR_INPUT* = 0x00 + ATTR_TARGET_CONVERTED* = 0x01 + ATTR_CONVERTED* = 0x02 + ATTR_TARGET_NOTCONVERTED* = 0x03 + ATTR_INPUT_ERROR* = 0x04 + ATTR_FIXEDCONVERTED* = 0x05 + CFS_DEFAULT* = 0x0000 + CFS_RECT* = 0x0001 + CFS_POINT* = 0x0002 + CFS_FORCE_POSITION* = 0x0020 + CFS_CANDIDATEPOS* = 0x0040 + CFS_EXCLUDE* = 0x0080 + GCL_CONVERSION* = 0x0001 + GCL_REVERSECONVERSION* = 0x0002 + GCL_REVERSE_LENGTH* = 0x0003 + IME_CMODE_ALPHANUMERIC* = 0x0000 + IME_CMODE_NATIVE* = 0x0001 + IME_CMODE_CHINESE* = IME_CMODE_NATIVE + IME_CMODE_HANGEUL* = IME_CMODE_NATIVE + IME_CMODE_HANGUL* = IME_CMODE_NATIVE + IME_CMODE_JAPANESE* = IME_CMODE_NATIVE + IME_CMODE_KATAKANA* = 0x0002 + IME_CMODE_LANGUAGE* = 0x0003 + IME_CMODE_FULLSHAPE* = 0x0008 + IME_CMODE_ROMAN* = 0x0010 + IME_CMODE_CHARCODE* = 0x0020 + IME_CMODE_HANJACONVERT* = 0x0040 + IME_CMODE_SOFTKBD* = 0x0080 + IME_CMODE_NOCONVERSION* = 0x0100 + IME_CMODE_EUDC* = 0x0200 + IME_CMODE_SYMBOL* = 0x0400 + IME_CMODE_FIXED* = 0x0800 + IME_CMODE_RESERVED* = 0xF0000000'i32 + IME_SMODE_NONE* = 0x0000 + IME_SMODE_PLAURALCLAUSE* = 0x0001 + IME_SMODE_SINGLECONVERT* = 0x0002 + IME_SMODE_AUTOMATIC* = 0x0004 + IME_SMODE_PHRASEPREDICT* = 0x0008 + IME_SMODE_CONVERSATION* = 0x0010 + IME_SMODE_RESERVED* = 0x0000F000 + IME_CAND_UNKNOWN* = 0x0000 + IME_CAND_READ* = 0x0001 + IME_CAND_CODE* = 0x0002 + IME_CAND_MEANING* = 0x0003 + IME_CAND_RADICAL* = 0x0004 + IME_CAND_STROKE* = 0x0005 + IMN_CLOSESTATUSWINDOW* = 0x0001 + IMN_OPENSTATUSWINDOW* = 0x0002 + IMN_CHANGECANDIDATE* = 0x0003 + IMN_CLOSECANDIDATE* = 0x0004 + IMN_OPENCANDIDATE* = 0x0005 + IMN_SETCONVERSIONMODE* = 0x0006 + IMN_SETSENTENCEMODE* = 0x0007 + IMN_SETOPENSTATUS* = 0x0008 + IMN_SETCANDIDATEPOS* = 0x0009 + IMN_SETCOMPOSITIONFONT* = 0x000A + IMN_SETCOMPOSITIONWINDOW* = 0x000B + IMN_SETSTATUSWINDOWPOS* = 0x000C + IMN_GUIDELINE* = 0x000D + IMN_PRIVATE* = 0x000E + IMR_COMPOSITIONWINDOW* = 0x0001 + IMR_CANDIDATEWINDOW* = 0x0002 + IMR_COMPOSITIONFONT* = 0x0003 + IMR_RECONVERTSTRING* = 0x0004 + IMR_CONFIRMRECONVERTSTRING* = 0x0005 + IMR_QUERYCHARPOSITION* = 0x0006 + IMR_DOCUMENTFEED* = 0x0007 + IMM_ERROR_NODATA* = -1 + IMM_ERROR_GENERAL* = -2 + IME_CONFIG_GENERAL* = 1 + IME_CONFIG_REGISTERWORD* = 2 + IME_CONFIG_SELECTDICTIONARY* = 3 + IME_ESC_QUERY_SUPPORT* = 0x0003 + IME_ESC_RESERVED_FIRST* = 0x0004 + IME_ESC_RESERVED_LAST* = 0x07FF + IME_ESC_PRIVATE_FIRST* = 0x0800 + IME_ESC_PRIVATE_LAST* = 0x0FFF + IME_ESC_SEQUENCE_TO_INTERNAL* = 0x1001 + IME_ESC_GET_EUDC_DICTIONARY* = 0x1003 + IME_ESC_SET_EUDC_DICTIONARY* = 0x1004 + IME_ESC_MAX_KEY* = 0x1005 + IME_ESC_IME_NAME* = 0x1006 + IME_ESC_SYNC_HOTKEY* = 0x1007 + IME_ESC_HANJA_MODE* = 0x1008 + IME_ESC_AUTOMATA* = 0x1009 + IME_ESC_PRIVATE_HOTKEY* = 0x100a + IME_ESC_GETHELPFILENAME* = 0x100b + IME_REGWORD_STYLE_EUDC* = 0x00000001 + IME_REGWORD_STYLE_USER_FIRST* = 0x80000000'i32 + IME_REGWORD_STYLE_USER_LAST* = 0xFFFFFFFF'i32 + IACE_CHILDREN* = 0x0001 + IACE_DEFAULT* = 0x0010 + IACE_IGNORENOCONTEXT* = 0x0020 + IGIMIF_RIGHTMENU* = 0x0001 + IGIMII_CMODE* = 0x0001 + IGIMII_SMODE* = 0x0002 + IGIMII_CONFIGURE* = 0x0004 + IGIMII_TOOLS* = 0x0008 + IGIMII_HELP* = 0x0010 + IGIMII_OTHER* = 0x0020 + IGIMII_INPUTTOOLS* = 0x0040 + IMFT_RADIOCHECK* = 0x00001 + IMFT_SEPARATOR* = 0x00002 + IMFT_SUBMENU* = 0x00004 + IMFS_GRAYED* = MFS_GRAYED + IMFS_DISABLED* = MFS_DISABLED + IMFS_CHECKED* = MFS_CHECKED + IMFS_HILITE* = MFS_HILITE + IMFS_ENABLED* = MFS_ENABLED + IMFS_UNCHECKED* = MFS_UNCHECKED + IMFS_UNHILITE* = MFS_UNHILITE + IMFS_DEFAULT* = MFS_DEFAULT + SOFTKEYBOARD_TYPE_T1* = 0x0001 + SOFTKEYBOARD_TYPE_C1* = 0x0002 + LIBID_ActiveIMM* = DEFINE_GUID("4955dd30-b159-11d0-8fcf-00aa006bcc59") + IID_IEnumInputContext* = DEFINE_GUID("09b5eab0-f997-11d1-93d4-0060b067b86e") + IID_IActiveIMMRegistrar* = DEFINE_GUID("b3458082-bd00-11d1-939b-0060b067b86e") + IID_IActiveIMMMessagePumpOwner* = DEFINE_GUID("b5cf2cfa-8aeb-11d1-9364-0060b067b86e") + IID_IActiveIMMApp* = DEFINE_GUID("08c0e040-62d1-11d1-9326-0060b067b86e") + IID_IActiveIMMIME* = DEFINE_GUID("08c03411-f96b-11d0-a475-00aa006bcc59") + IID_IActiveIME* = DEFINE_GUID("6fe20962-d077-11d0-8fe7-00aa006bcc59") + IID_IActiveIME2* = DEFINE_GUID("e1c4bf0e-2d53-11d2-93e1-0060b067b86e") + IID_IEnumRegisterWordA* = DEFINE_GUID("08c03412-f96b-11d0-a475-00aa006bcc59") + IID_IEnumRegisterWordW* = DEFINE_GUID("4955dd31-b159-11d0-8fcf-00aa006bcc59") + CLSID_CActiveIMM* = DEFINE_GUID("4955dd33-b159-11d0-8fcf-00aa006bcc59") + IGP_GETIMEVERSION* = DWORD(-4) +type + IMCENUMPROC* = proc (P1: HIMC, P2: LPARAM): WINBOOL {.stdcall.} + REGISTERWORDENUMPROCA* = proc (P1: LPCSTR, P2: DWORD, P3: LPCSTR, P4: LPVOID): int32 {.stdcall.} + REGISTERWORDENUMPROCW* = proc (P1: LPCWSTR, P2: DWORD, P3: LPCWSTR, P4: LPVOID): int32 {.stdcall.} + INPUTCONTEXT_lfFont* {.pure, union.} = object + A*: LOGFONTA + W*: LOGFONTW + INPUTCONTEXT* {.pure.} = object + hWnd*: HWND + fOpen*: WINBOOL + ptStatusWndPos*: POINT + ptSoftKbdPos*: POINT + fdwConversion*: DWORD + fdwSentence*: DWORD + lfFont*: INPUTCONTEXT_lfFont + cfCompForm*: COMPOSITIONFORM + cfCandForm*: array[4, CANDIDATEFORM] + hCompStr*: HIMCC + hCandInfo*: HIMCC + hGuideLine*: HIMCC + hPrivate*: HIMCC + dwNumMsgBuf*: DWORD + hMsgBuf*: HIMCC + fdwInit*: DWORD + dwReserve*: array[3, DWORD] + IMEINFO* {.pure.} = object + dwPrivateDataSize*: DWORD + fdwProperty*: DWORD + fdwConversionCaps*: DWORD + fdwSentenceCaps*: DWORD + fdwUICaps*: DWORD + fdwSCSCaps*: DWORD + fdwSelectCaps*: DWORD + IEnumInputContext* {.pure.} = object + lpVtbl*: ptr IEnumInputContextVtbl + IEnumInputContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Clone*: proc(self: ptr IEnumInputContext, ppEnum: ptr ptr IEnumInputContext): HRESULT {.stdcall.} + Next*: proc(self: ptr IEnumInputContext, ulCount: ULONG, rgInputContext: ptr HIMC, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumInputContext): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumInputContext, ulCount: ULONG): HRESULT {.stdcall.} + IActiveIMMRegistrar* {.pure.} = object + lpVtbl*: ptr IActiveIMMRegistrarVtbl + IActiveIMMRegistrarVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterIME*: proc(self: ptr IActiveIMMRegistrar, rclsid: REFCLSID, lgid: LANGID, pszIconFile: LPCWSTR, pszDesc: LPCWSTR): HRESULT {.stdcall.} + UnregisterIME*: proc(self: ptr IActiveIMMRegistrar, rclsid: REFCLSID): HRESULT {.stdcall.} + IActiveIMMMessagePumpOwner* {.pure.} = object + lpVtbl*: ptr IActiveIMMMessagePumpOwnerVtbl + IActiveIMMMessagePumpOwnerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Start*: proc(self: ptr IActiveIMMMessagePumpOwner): HRESULT {.stdcall.} + End*: proc(self: ptr IActiveIMMMessagePumpOwner): HRESULT {.stdcall.} + OnTranslateMessage*: proc(self: ptr IActiveIMMMessagePumpOwner, pMsg: ptr MSG): HRESULT {.stdcall.} + Pause*: proc(self: ptr IActiveIMMMessagePumpOwner, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Resume*: proc(self: ptr IActiveIMMMessagePumpOwner, dwCookie: DWORD): HRESULT {.stdcall.} + IEnumRegisterWordA* {.pure.} = object + lpVtbl*: ptr IEnumRegisterWordAVtbl + IEnumRegisterWordAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Clone*: proc(self: ptr IEnumRegisterWordA, ppEnum: ptr ptr IEnumRegisterWordA): HRESULT {.stdcall.} + Next*: proc(self: ptr IEnumRegisterWordA, ulCount: ULONG, rgRegisterWord: ptr REGISTERWORDA, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumRegisterWordA): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumRegisterWordA, ulCount: ULONG): HRESULT {.stdcall.} + IEnumRegisterWordW* {.pure.} = object + lpVtbl*: ptr IEnumRegisterWordWVtbl + IEnumRegisterWordWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Clone*: proc(self: ptr IEnumRegisterWordW, ppEnum: ptr ptr IEnumRegisterWordW): HRESULT {.stdcall.} + Next*: proc(self: ptr IEnumRegisterWordW, ulCount: ULONG, rgRegisterWord: ptr REGISTERWORDW, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumRegisterWordW): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumRegisterWordW, ulCount: ULONG): HRESULT {.stdcall.} + IActiveIMMApp* {.pure.} = object + lpVtbl*: ptr IActiveIMMAppVtbl + IActiveIMMAppVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AssociateContext*: proc(self: ptr IActiveIMMApp, hWnd: HWND, hIME: HIMC, phPrev: ptr HIMC): HRESULT {.stdcall.} + ConfigureIMEA*: proc(self: ptr IActiveIMMApp, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDA): HRESULT {.stdcall.} + ConfigureIMEW*: proc(self: ptr IActiveIMMApp, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDW): HRESULT {.stdcall.} + CreateContext*: proc(self: ptr IActiveIMMApp, phIMC: ptr HIMC): HRESULT {.stdcall.} + DestroyContext*: proc(self: ptr IActiveIMMApp, hIME: HIMC): HRESULT {.stdcall.} + EnumRegisterWordA*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordA): HRESULT {.stdcall.} + EnumRegisterWordW*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordW): HRESULT {.stdcall.} + EscapeA*: proc(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.stdcall.} + EscapeW*: proc(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.stdcall.} + GetCandidateListA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetCandidateListW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetCandidateListCountA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.stdcall.} + GetCandidateListCountW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.stdcall.} + GetCandidateWindow*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pCandidate: ptr CANDIDATEFORM): HRESULT {.stdcall.} + GetCompositionFontA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.stdcall.} + GetCompositionFontW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.stdcall.} + GetCompositionStringA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.stdcall.} + GetCompositionStringW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.stdcall.} + GetCompositionWindow*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.stdcall.} + GetContext*: proc(self: ptr IActiveIMMApp, hWnd: HWND, phIMC: ptr HIMC): HRESULT {.stdcall.} + GetConversionListA*: proc(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, pSrc: LPSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetConversionListW*: proc(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, pSrc: LPWSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetConversionStatus*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pfdwConversion: ptr DWORD, pfdwSentence: ptr DWORD): HRESULT {.stdcall.} + GetDefaultIMEWnd*: proc(self: ptr IActiveIMMApp, hWnd: HWND, phDefWnd: ptr HWND): HRESULT {.stdcall.} + GetDescriptionA*: proc(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szDescription: LPSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetDescriptionW*: proc(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szDescription: LPWSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetGuideLineA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetGuideLineW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPWSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetIMEFileNameA*: proc(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szFileName: LPSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetIMEFileNameW*: proc(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szFileName: LPWSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetOpenStatus*: proc(self: ptr IActiveIMMApp, hIMC: HIMC): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IActiveIMMApp, hKL: HKL, fdwIndex: DWORD, pdwProperty: ptr DWORD): HRESULT {.stdcall.} + GetRegisterWordStyleA*: proc(self: ptr IActiveIMMApp, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFA, puCopied: ptr UINT): HRESULT {.stdcall.} + GetRegisterWordStyleW*: proc(self: ptr IActiveIMMApp, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puCopied: ptr UINT): HRESULT {.stdcall.} + GetStatusWindowPos*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.stdcall.} + GetVirtualKey*: proc(self: ptr IActiveIMMApp, hWnd: HWND, puVirtualKey: ptr UINT): HRESULT {.stdcall.} + InstallIMEA*: proc(self: ptr IActiveIMMApp, szIMEFileName: LPSTR, szLayoutText: LPSTR, phKL: ptr HKL): HRESULT {.stdcall.} + InstallIMEW*: proc(self: ptr IActiveIMMApp, szIMEFileName: LPWSTR, szLayoutText: LPWSTR, phKL: ptr HKL): HRESULT {.stdcall.} + IsIME*: proc(self: ptr IActiveIMMApp, hKL: HKL): HRESULT {.stdcall.} + IsUIMessageA*: proc(self: ptr IActiveIMMApp, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + IsUIMessageW*: proc(self: ptr IActiveIMMApp, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + NotifyIME*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.stdcall.} + RegisterWordA*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR): HRESULT {.stdcall.} + RegisterWordW*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR): HRESULT {.stdcall.} + ReleaseContext*: proc(self: ptr IActiveIMMApp, hWnd: HWND, hIMC: HIMC): HRESULT {.stdcall.} + SetCandidateWindow*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pCandidate: ptr CANDIDATEFORM): HRESULT {.stdcall.} + SetCompositionFontA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.stdcall.} + SetCompositionFontW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.stdcall.} + SetCompositionStringA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.stdcall.} + SetCompositionStringW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.stdcall.} + SetCompositionWindow*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.stdcall.} + SetConversionStatus*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, fdwConversion: DWORD, fdwSentence: DWORD): HRESULT {.stdcall.} + SetOpenStatus*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, fOpen: WINBOOL): HRESULT {.stdcall.} + SetStatusWindowPos*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.stdcall.} + SimulateHotKey*: proc(self: ptr IActiveIMMApp, hWnd: HWND, dwHotKeyID: DWORD): HRESULT {.stdcall.} + UnregisterWordA*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szUnregister: LPSTR): HRESULT {.stdcall.} + UnregisterWordW*: proc(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szUnregister: LPWSTR): HRESULT {.stdcall.} + Activate*: proc(self: ptr IActiveIMMApp, fRestoreLayout: WINBOOL): HRESULT {.stdcall.} + Deactivate*: proc(self: ptr IActiveIMMApp): HRESULT {.stdcall.} + OnDefWindowProc*: proc(self: ptr IActiveIMMApp, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + FilterClientWindows*: proc(self: ptr IActiveIMMApp, aaClassList: ptr ATOM, uSize: UINT): HRESULT {.stdcall.} + GetCodePageA*: proc(self: ptr IActiveIMMApp, hKL: HKL, uCodePage: ptr UINT): HRESULT {.stdcall.} + GetLangId*: proc(self: ptr IActiveIMMApp, hKL: HKL, plid: ptr LANGID): HRESULT {.stdcall.} + AssociateContextEx*: proc(self: ptr IActiveIMMApp, hWnd: HWND, hIMC: HIMC, dwFlags: DWORD): HRESULT {.stdcall.} + DisableIME*: proc(self: ptr IActiveIMMApp, idThread: DWORD): HRESULT {.stdcall.} + GetImeMenuItemsA*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOA, pImeMenu: ptr IMEMENUITEMINFOA, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetImeMenuItemsW*: proc(self: ptr IActiveIMMApp, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOW, pImeMenu: ptr IMEMENUITEMINFOW, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.stdcall.} + EnumInputContext*: proc(self: ptr IActiveIMMApp, idThread: DWORD, ppEnum: ptr ptr IEnumInputContext): HRESULT {.stdcall.} + IActiveIMMIME* {.pure.} = object + lpVtbl*: ptr IActiveIMMIMEVtbl + IActiveIMMIMEVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AssociateContext*: proc(self: ptr IActiveIMMIME, hWnd: HWND, hIME: HIMC, phPrev: ptr HIMC): HRESULT {.stdcall.} + ConfigureIMEA*: proc(self: ptr IActiveIMMIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDA): HRESULT {.stdcall.} + ConfigureIMEW*: proc(self: ptr IActiveIMMIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDW): HRESULT {.stdcall.} + CreateContext*: proc(self: ptr IActiveIMMIME, phIMC: ptr HIMC): HRESULT {.stdcall.} + DestroyContext*: proc(self: ptr IActiveIMMIME, hIME: HIMC): HRESULT {.stdcall.} + EnumRegisterWordA*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordA): HRESULT {.stdcall.} + EnumRegisterWordW*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordW): HRESULT {.stdcall.} + EscapeA*: proc(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.stdcall.} + EscapeW*: proc(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.stdcall.} + GetCandidateListA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetCandidateListW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetCandidateListCountA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.stdcall.} + GetCandidateListCountW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.stdcall.} + GetCandidateWindow*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pCandidate: ptr CANDIDATEFORM): HRESULT {.stdcall.} + GetCompositionFontA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.stdcall.} + GetCompositionFontW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.stdcall.} + GetCompositionStringA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.stdcall.} + GetCompositionStringW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.stdcall.} + GetCompositionWindow*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.stdcall.} + GetContext*: proc(self: ptr IActiveIMMIME, hWnd: HWND, phIMC: ptr HIMC): HRESULT {.stdcall.} + GetConversionListA*: proc(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, pSrc: LPSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetConversionListW*: proc(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, pSrc: LPWSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + GetConversionStatus*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pfdwConversion: ptr DWORD, pfdwSentence: ptr DWORD): HRESULT {.stdcall.} + GetDefaultIMEWnd*: proc(self: ptr IActiveIMMIME, hWnd: HWND, phDefWnd: ptr HWND): HRESULT {.stdcall.} + GetDescriptionA*: proc(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szDescription: LPSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetDescriptionW*: proc(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szDescription: LPWSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetGuideLineA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetGuideLineW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPWSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetIMEFileNameA*: proc(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szFileName: LPSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetIMEFileNameW*: proc(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szFileName: LPWSTR, puCopied: ptr UINT): HRESULT {.stdcall.} + GetOpenStatus*: proc(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IActiveIMMIME, hKL: HKL, fdwIndex: DWORD, pdwProperty: ptr DWORD): HRESULT {.stdcall.} + GetRegisterWordStyleA*: proc(self: ptr IActiveIMMIME, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFA, puCopied: ptr UINT): HRESULT {.stdcall.} + GetRegisterWordStyleW*: proc(self: ptr IActiveIMMIME, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puCopied: ptr UINT): HRESULT {.stdcall.} + GetStatusWindowPos*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.stdcall.} + GetVirtualKey*: proc(self: ptr IActiveIMMIME, hWnd: HWND, puVirtualKey: ptr UINT): HRESULT {.stdcall.} + InstallIMEA*: proc(self: ptr IActiveIMMIME, szIMEFileName: LPSTR, szLayoutText: LPSTR, phKL: ptr HKL): HRESULT {.stdcall.} + InstallIMEW*: proc(self: ptr IActiveIMMIME, szIMEFileName: LPWSTR, szLayoutText: LPWSTR, phKL: ptr HKL): HRESULT {.stdcall.} + IsIME*: proc(self: ptr IActiveIMMIME, hKL: HKL): HRESULT {.stdcall.} + IsUIMessageA*: proc(self: ptr IActiveIMMIME, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + IsUIMessageW*: proc(self: ptr IActiveIMMIME, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + NotifyIME*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.stdcall.} + RegisterWordA*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR): HRESULT {.stdcall.} + RegisterWordW*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR): HRESULT {.stdcall.} + ReleaseContext*: proc(self: ptr IActiveIMMIME, hWnd: HWND, hIMC: HIMC): HRESULT {.stdcall.} + SetCandidateWindow*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pCandidate: ptr CANDIDATEFORM): HRESULT {.stdcall.} + SetCompositionFontA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.stdcall.} + SetCompositionFontW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.stdcall.} + SetCompositionStringA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.stdcall.} + SetCompositionStringW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.stdcall.} + SetCompositionWindow*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.stdcall.} + SetConversionStatus*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, fdwConversion: DWORD, fdwSentence: DWORD): HRESULT {.stdcall.} + SetOpenStatus*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, fOpen: WINBOOL): HRESULT {.stdcall.} + SetStatusWindowPos*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.stdcall.} + SimulateHotKey*: proc(self: ptr IActiveIMMIME, hWnd: HWND, dwHotKeyID: DWORD): HRESULT {.stdcall.} + UnregisterWordA*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szUnregister: LPSTR): HRESULT {.stdcall.} + UnregisterWordW*: proc(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szUnregister: LPWSTR): HRESULT {.stdcall.} + GenerateMessage*: proc(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.stdcall.} + LockIMC*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, ppIMC: ptr ptr INPUTCONTEXT): HRESULT {.stdcall.} + UnlockIMC*: proc(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.stdcall.} + GetIMCLockCount*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, pdwLockCount: ptr DWORD): HRESULT {.stdcall.} + CreateIMCC*: proc(self: ptr IActiveIMMIME, dwSize: DWORD, phIMCC: ptr HIMCC): HRESULT {.stdcall.} + DestroyIMCC*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC): HRESULT {.stdcall.} + LockIMCC*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC, ppv: ptr pointer): HRESULT {.stdcall.} + UnlockIMCC*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC): HRESULT {.stdcall.} + ReSizeIMCC*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC, dwSize: DWORD, phIMCC: ptr HIMCC): HRESULT {.stdcall.} + GetIMCCSize*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC, pdwSize: ptr DWORD): HRESULT {.stdcall.} + GetIMCCLockCount*: proc(self: ptr IActiveIMMIME, hIMCC: HIMCC, pdwLockCount: ptr DWORD): HRESULT {.stdcall.} + GetHotKey*: proc(self: ptr IActiveIMMIME, dwHotKeyID: DWORD, puModifiers: ptr UINT, puVKey: ptr UINT, phKL: ptr HKL): HRESULT {.stdcall.} + SetHotKey*: proc(self: ptr IActiveIMMIME, dwHotKeyID: DWORD, uModifiers: UINT, uVKey: UINT, hKL: HKL): HRESULT {.stdcall.} + CreateSoftKeyboard*: proc(self: ptr IActiveIMMIME, uType: UINT, hOwner: HWND, x: int32, y: int32, phSoftKbdWnd: ptr HWND): HRESULT {.stdcall.} + DestroySoftKeyboard*: proc(self: ptr IActiveIMMIME, hSoftKbdWnd: HWND): HRESULT {.stdcall.} + ShowSoftKeyboard*: proc(self: ptr IActiveIMMIME, hSoftKbdWnd: HWND, nCmdShow: int32): HRESULT {.stdcall.} + GetCodePageA*: proc(self: ptr IActiveIMMIME, hKL: HKL, uCodePage: ptr UINT): HRESULT {.stdcall.} + GetLangId*: proc(self: ptr IActiveIMMIME, hKL: HKL, plid: ptr LANGID): HRESULT {.stdcall.} + KeybdEvent*: proc(self: ptr IActiveIMMIME, lgidIME: LANGID, bVk: BYTE, bScan: BYTE, dwFlags: DWORD, dwExtraInfo: DWORD): HRESULT {.stdcall.} + LockModal*: proc(self: ptr IActiveIMMIME): HRESULT {.stdcall.} + UnlockModal*: proc(self: ptr IActiveIMMIME): HRESULT {.stdcall.} + AssociateContextEx*: proc(self: ptr IActiveIMMIME, hWnd: HWND, hIMC: HIMC, dwFlags: DWORD): HRESULT {.stdcall.} + DisableIME*: proc(self: ptr IActiveIMMIME, idThread: DWORD): HRESULT {.stdcall.} + GetImeMenuItemsA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOA, pImeMenu: ptr IMEMENUITEMINFOA, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.stdcall.} + GetImeMenuItemsW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOW, pImeMenu: ptr IMEMENUITEMINFOW, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.stdcall.} + EnumInputContext*: proc(self: ptr IActiveIMMIME, idThread: DWORD, ppEnum: ptr ptr IEnumInputContext): HRESULT {.stdcall.} + RequestMessageA*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + RequestMessageW*: proc(self: ptr IActiveIMMIME, hIMC: HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + SendIMCA*: proc(self: ptr IActiveIMMIME, hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + SendIMCW*: proc(self: ptr IActiveIMMIME, hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + IsSleeping*: proc(self: ptr IActiveIMMIME): HRESULT {.stdcall.} + IActiveIME* {.pure.} = object + lpVtbl*: ptr IActiveIMEVtbl + IActiveIMEVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Inquire*: proc(self: ptr IActiveIME, dwSystemInfoFlags: DWORD, pIMEInfo: ptr IMEINFO, szWndClass: LPWSTR, pdwPrivate: ptr DWORD): HRESULT {.stdcall.} + ConversionList*: proc(self: ptr IActiveIME, hIMC: HIMC, szSource: LPWSTR, uFlag: UINT, uBufLen: UINT, pDest: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.stdcall.} + Configure*: proc(self: ptr IActiveIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pRegisterWord: ptr REGISTERWORDW): HRESULT {.stdcall.} + Destroy*: proc(self: ptr IActiveIME, uReserved: UINT): HRESULT {.stdcall.} + Escape*: proc(self: ptr IActiveIME, hIMC: HIMC, uEscape: UINT, pData: pointer, plResult: ptr LRESULT): HRESULT {.stdcall.} + SetActiveContext*: proc(self: ptr IActiveIME, hIMC: HIMC, fFlag: WINBOOL): HRESULT {.stdcall.} + ProcessKey*: proc(self: ptr IActiveIME, hIMC: HIMC, uVirKey: UINT, lParam: DWORD, pbKeyState: ptr BYTE): HRESULT {.stdcall.} + Notify*: proc(self: ptr IActiveIME, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.stdcall.} + Select*: proc(self: ptr IActiveIME, hIMC: HIMC, fSelect: WINBOOL): HRESULT {.stdcall.} + SetCompositionString*: proc(self: ptr IActiveIME, hIMC: HIMC, dwIndex: DWORD, pComp: pointer, dwCompLen: DWORD, pRead: pointer, dwReadLen: DWORD): HRESULT {.stdcall.} + ToAsciiEx*: proc(self: ptr IActiveIME, uVirKey: UINT, uScanCode: UINT, pbKeyState: ptr BYTE, fuState: UINT, hIMC: HIMC, pdwTransBuf: ptr DWORD, puSize: ptr UINT): HRESULT {.stdcall.} + RegisterWord*: proc(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szString: LPWSTR): HRESULT {.stdcall.} + UnregisterWord*: proc(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szString: LPWSTR): HRESULT {.stdcall.} + GetRegisterWordStyle*: proc(self: ptr IActiveIME, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puBufSize: ptr UINT): HRESULT {.stdcall.} + EnumRegisterWord*: proc(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, ppEnum: ptr ptr IEnumRegisterWordW): HRESULT {.stdcall.} + GetCodePageA*: proc(self: ptr IActiveIME, uCodePage: ptr UINT): HRESULT {.stdcall.} + GetLangId*: proc(self: ptr IActiveIME, plid: ptr LANGID): HRESULT {.stdcall.} + IActiveIME2* {.pure.} = object + lpVtbl*: ptr IActiveIME2Vtbl + IActiveIME2Vtbl* {.pure, inheritable.} = object of IActiveIMEVtbl + Sleep*: proc(self: ptr IActiveIME2): HRESULT {.stdcall.} + Unsleep*: proc(self: ptr IActiveIME2, fDead: WINBOOL): HRESULT {.stdcall.} +proc ImmInstallIMEA*(lpszIMEFileName: LPCSTR, lpszLayoutText: LPCSTR): HKL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmInstallIMEW*(lpszIMEFileName: LPCWSTR, lpszLayoutText: LPCWSTR): HKL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetDefaultIMEWnd*(P1: HWND): HWND {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetDescriptionA*(P1: HKL, P2: LPSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetDescriptionW*(P1: HKL, P2: LPWSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetIMEFileNameA*(P1: HKL, P2: LPSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetIMEFileNameW*(P1: HKL, P2: LPWSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetProperty*(P1: HKL, P2: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmIsIME*(P1: HKL): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSimulateHotKey*(P1: HWND, P2: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmCreateContext*(): HIMC {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmDestroyContext*(P1: HIMC): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetContext*(P1: HWND): HIMC {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmReleaseContext*(P1: HWND, P2: HIMC): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmAssociateContext*(P1: HWND, P2: HIMC): HIMC {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmAssociateContextEx*(P1: HWND, P2: HIMC, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCompositionStringA*(P1: HIMC, P2: DWORD, P3: LPVOID, P4: DWORD): LONG {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCompositionStringW*(P1: HIMC, P2: DWORD, P3: LPVOID, P4: DWORD): LONG {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCompositionStringA*(P1: HIMC, dwIndex: DWORD, lpComp: LPVOID, P4: DWORD, lpRead: LPVOID, P6: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCompositionStringW*(P1: HIMC, dwIndex: DWORD, lpComp: LPVOID, P4: DWORD, lpRead: LPVOID, P6: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCandidateListCountA*(P1: HIMC, lpdwListCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCandidateListCountW*(P1: HIMC, lpdwListCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCandidateListA*(P1: HIMC, deIndex: DWORD, P3: LPCANDIDATELIST, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCandidateListW*(P1: HIMC, deIndex: DWORD, P3: LPCANDIDATELIST, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetGuideLineA*(P1: HIMC, dwIndex: DWORD, P3: LPSTR, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetGuideLineW*(P1: HIMC, dwIndex: DWORD, P3: LPWSTR, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetConversionStatus*(P1: HIMC, P2: LPDWORD, P3: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetConversionStatus*(P1: HIMC, P2: DWORD, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetOpenStatus*(P1: HIMC): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetOpenStatus*(P1: HIMC, P2: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCompositionFontA*(P1: HIMC, P2: LPLOGFONTA): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCompositionFontW*(P1: HIMC, P2: LPLOGFONTW): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCompositionFontA*(P1: HIMC, P2: LPLOGFONTA): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCompositionFontW*(P1: HIMC, P2: LPLOGFONTW): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmConfigureIMEA*(P1: HKL, P2: HWND, P3: DWORD, P4: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmConfigureIMEW*(P1: HKL, P2: HWND, P3: DWORD, P4: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmEscapeA*(P1: HKL, P2: HIMC, P3: UINT, P4: LPVOID): LRESULT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmEscapeW*(P1: HKL, P2: HIMC, P3: UINT, P4: LPVOID): LRESULT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetConversionListA*(P1: HKL, P2: HIMC, P3: LPCSTR, P4: LPCANDIDATELIST, dwBufLen: DWORD, uFlag: UINT): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetConversionListW*(P1: HKL, P2: HIMC, P3: LPCWSTR, P4: LPCANDIDATELIST, dwBufLen: DWORD, uFlag: UINT): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmNotifyIME*(P1: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetStatusWindowPos*(P1: HIMC, P2: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetStatusWindowPos*(P1: HIMC, P2: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCompositionWindow*(P1: HIMC, P2: LPCOMPOSITIONFORM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCompositionWindow*(P1: HIMC, P2: LPCOMPOSITIONFORM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetCandidateWindow*(P1: HIMC, P2: DWORD, P3: LPCANDIDATEFORM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmSetCandidateWindow*(P1: HIMC, P2: LPCANDIDATEFORM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmIsUIMessageA*(P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmIsUIMessageW*(P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetVirtualKey*(P1: HWND): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmRegisterWordA*(P1: HKL, lpszReading: LPCSTR, P3: DWORD, lpszRegister: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmRegisterWordW*(P1: HKL, lpszReading: LPCWSTR, P3: DWORD, lpszRegister: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmUnregisterWordA*(P1: HKL, lpszReading: LPCSTR, P3: DWORD, lpszUnregister: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmUnregisterWordW*(P1: HKL, lpszReading: LPCWSTR, P3: DWORD, lpszUnregister: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetRegisterWordStyleA*(P1: HKL, nItem: UINT, P3: LPSTYLEBUFA): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetRegisterWordStyleW*(P1: HKL, nItem: UINT, P3: LPSTYLEBUFW): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmEnumRegisterWordA*(P1: HKL, P2: REGISTERWORDENUMPROCA, lpszReading: LPCSTR, P4: DWORD, lpszRegister: LPCSTR, P6: LPVOID): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmEnumRegisterWordW*(P1: HKL, P2: REGISTERWORDENUMPROCW, lpszReading: LPCWSTR, P4: DWORD, lpszRegister: LPCWSTR, P6: LPVOID): UINT {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmDisableIME*(P1: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmEnumInputContext*(idThread: DWORD, lpfn: IMCENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetImeMenuItemsA*(P1: HIMC, P2: DWORD, P3: DWORD, P4: LPIMEMENUITEMINFOA, P5: LPIMEMENUITEMINFOA, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmGetImeMenuItemsW*(P1: HIMC, P2: DWORD, P3: DWORD, P4: LPIMEMENUITEMINFOW, P5: LPIMEMENUITEMINFOW, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc.} +proc ImmDisableTextFrameService*(idThread: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc.} +proc Clone*(self: ptr IEnumInputContext, ppEnum: ptr ptr IEnumInputContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Next*(self: ptr IEnumInputContext, ulCount: ULONG, rgInputContext: ptr HIMC, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, ulCount, rgInputContext, pcFetched) +proc Reset*(self: ptr IEnumInputContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Skip*(self: ptr IEnumInputContext, ulCount: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, ulCount) +proc RegisterIME*(self: ptr IActiveIMMRegistrar, rclsid: REFCLSID, lgid: LANGID, pszIconFile: LPCWSTR, pszDesc: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterIME(self, rclsid, lgid, pszIconFile, pszDesc) +proc UnregisterIME*(self: ptr IActiveIMMRegistrar, rclsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterIME(self, rclsid) +proc Start*(self: ptr IActiveIMMMessagePumpOwner): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Start(self) +proc End*(self: ptr IActiveIMMMessagePumpOwner): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.End(self) +proc OnTranslateMessage*(self: ptr IActiveIMMMessagePumpOwner, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnTranslateMessage(self, pMsg) +proc Pause*(self: ptr IActiveIMMMessagePumpOwner, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Pause(self, pdwCookie) +proc Resume*(self: ptr IActiveIMMMessagePumpOwner, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resume(self, dwCookie) +proc AssociateContext*(self: ptr IActiveIMMApp, hWnd: HWND, hIME: HIMC, phPrev: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AssociateContext(self, hWnd, hIME, phPrev) +proc ConfigureIMEA*(self: ptr IActiveIMMApp, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfigureIMEA(self, hKL, hWnd, dwMode, pData) +proc ConfigureIMEW*(self: ptr IActiveIMMApp, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfigureIMEW(self, hKL, hWnd, dwMode, pData) +proc CreateContext*(self: ptr IActiveIMMApp, phIMC: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateContext(self, phIMC) +proc DestroyContext*(self: ptr IActiveIMMApp, hIME: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyContext(self, hIME) +proc EnumRegisterWordA*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRegisterWordA(self, hKL, szReading, dwStyle, szRegister, pData, pEnum) +proc EnumRegisterWordW*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRegisterWordW(self, hKL, szReading, dwStyle, szRegister, pData, pEnum) +proc EscapeA*(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EscapeA(self, hKL, hIMC, uEscape, pData, plResult) +proc EscapeW*(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EscapeW(self, hKL, hIMC, uEscape, pData, plResult) +proc GetCandidateListA*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListA(self, hIMC, dwIndex, uBufLen, pCandList, puCopied) +proc GetCandidateListW*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListW(self, hIMC, dwIndex, uBufLen, pCandList, puCopied) +proc GetCandidateListCountA*(self: ptr IActiveIMMApp, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListCountA(self, hIMC, pdwListSize, pdwBufLen) +proc GetCandidateListCountW*(self: ptr IActiveIMMApp, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListCountW(self, hIMC, pdwListSize, pdwBufLen) +proc GetCandidateWindow*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pCandidate: ptr CANDIDATEFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateWindow(self, hIMC, dwIndex, pCandidate) +proc GetCompositionFontA*(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionFontA(self, hIMC, plf) +proc GetCompositionFontW*(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionFontW(self, hIMC, plf) +proc GetCompositionStringA*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionStringA(self, hIMC, dwIndex, dwBufLen, plCopied, pBuf) +proc GetCompositionStringW*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionStringW(self, hIMC, dwIndex, dwBufLen, plCopied, pBuf) +proc GetCompositionWindow*(self: ptr IActiveIMMApp, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionWindow(self, hIMC, pCompForm) +proc GetContext*(self: ptr IActiveIMMApp, hWnd: HWND, phIMC: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContext(self, hWnd, phIMC) +proc GetConversionListA*(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, pSrc: LPSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionListA(self, hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied) +proc GetConversionListW*(self: ptr IActiveIMMApp, hKL: HKL, hIMC: HIMC, pSrc: LPWSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionListW(self, hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied) +proc GetConversionStatus*(self: ptr IActiveIMMApp, hIMC: HIMC, pfdwConversion: ptr DWORD, pfdwSentence: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionStatus(self, hIMC, pfdwConversion, pfdwSentence) +proc GetDefaultIMEWnd*(self: ptr IActiveIMMApp, hWnd: HWND, phDefWnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultIMEWnd(self, hWnd, phDefWnd) +proc GetDescriptionA*(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szDescription: LPSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescriptionA(self, hKL, uBufLen, szDescription, puCopied) +proc GetDescriptionW*(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szDescription: LPWSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescriptionW(self, hKL, uBufLen, szDescription, puCopied) +proc GetGuideLineA*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGuideLineA(self, hIMC, dwIndex, dwBufLen, pBuf, pdwResult) +proc GetGuideLineW*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPWSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGuideLineW(self, hIMC, dwIndex, dwBufLen, pBuf, pdwResult) +proc GetIMEFileNameA*(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szFileName: LPSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMEFileNameA(self, hKL, uBufLen, szFileName, puCopied) +proc GetIMEFileNameW*(self: ptr IActiveIMMApp, hKL: HKL, uBufLen: UINT, szFileName: LPWSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMEFileNameW(self, hKL, uBufLen, szFileName, puCopied) +proc GetOpenStatus*(self: ptr IActiveIMMApp, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOpenStatus(self, hIMC) +proc GetProperty*(self: ptr IActiveIMMApp, hKL: HKL, fdwIndex: DWORD, pdwProperty: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, hKL, fdwIndex, pdwProperty) +proc GetRegisterWordStyleA*(self: ptr IActiveIMMApp, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFA, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisterWordStyleA(self, hKL, nItem, pStyleBuf, puCopied) +proc GetRegisterWordStyleW*(self: ptr IActiveIMMApp, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisterWordStyleW(self, hKL, nItem, pStyleBuf, puCopied) +proc GetStatusWindowPos*(self: ptr IActiveIMMApp, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStatusWindowPos(self, hIMC, pptPos) +proc GetVirtualKey*(self: ptr IActiveIMMApp, hWnd: HWND, puVirtualKey: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVirtualKey(self, hWnd, puVirtualKey) +proc InstallIMEA*(self: ptr IActiveIMMApp, szIMEFileName: LPSTR, szLayoutText: LPSTR, phKL: ptr HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InstallIMEA(self, szIMEFileName, szLayoutText, phKL) +proc InstallIMEW*(self: ptr IActiveIMMApp, szIMEFileName: LPWSTR, szLayoutText: LPWSTR, phKL: ptr HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InstallIMEW(self, szIMEFileName, szLayoutText, phKL) +proc IsIME*(self: ptr IActiveIMMApp, hKL: HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsIME(self, hKL) +proc IsUIMessageA*(self: ptr IActiveIMMApp, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsUIMessageA(self, hWndIME, msg, wParam, lParam) +proc IsUIMessageW*(self: ptr IActiveIMMApp, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsUIMessageW(self, hWndIME, msg, wParam, lParam) +proc NotifyIME*(self: ptr IActiveIMMApp, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NotifyIME(self, hIMC, dwAction, dwIndex, dwValue) +proc mRegisterWordA*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterWordA(self, hKL, szReading, dwStyle, szRegister) +proc mRegisterWordW*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterWordW(self, hKL, szReading, dwStyle, szRegister) +proc ReleaseContext*(self: ptr IActiveIMMApp, hWnd: HWND, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseContext(self, hWnd, hIMC) +proc SetCandidateWindow*(self: ptr IActiveIMMApp, hIMC: HIMC, pCandidate: ptr CANDIDATEFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCandidateWindow(self, hIMC, pCandidate) +proc SetCompositionFontA*(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionFontA(self, hIMC, plf) +proc SetCompositionFontW*(self: ptr IActiveIMMApp, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionFontW(self, hIMC, plf) +proc SetCompositionStringA*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionStringA(self, hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen) +proc SetCompositionStringW*(self: ptr IActiveIMMApp, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionStringW(self, hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen) +proc SetCompositionWindow*(self: ptr IActiveIMMApp, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionWindow(self, hIMC, pCompForm) +proc SetConversionStatus*(self: ptr IActiveIMMApp, hIMC: HIMC, fdwConversion: DWORD, fdwSentence: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetConversionStatus(self, hIMC, fdwConversion, fdwSentence) +proc SetOpenStatus*(self: ptr IActiveIMMApp, hIMC: HIMC, fOpen: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOpenStatus(self, hIMC, fOpen) +proc SetStatusWindowPos*(self: ptr IActiveIMMApp, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStatusWindowPos(self, hIMC, pptPos) +proc SimulateHotKey*(self: ptr IActiveIMMApp, hWnd: HWND, dwHotKeyID: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SimulateHotKey(self, hWnd, dwHotKeyID) +proc UnregisterWordA*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szUnregister: LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterWordA(self, hKL, szReading, dwStyle, szUnregister) +proc UnregisterWordW*(self: ptr IActiveIMMApp, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szUnregister: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterWordW(self, hKL, szReading, dwStyle, szUnregister) +proc Activate*(self: ptr IActiveIMMApp, fRestoreLayout: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Activate(self, fRestoreLayout) +proc Deactivate*(self: ptr IActiveIMMApp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Deactivate(self) +proc OnDefWindowProc*(self: ptr IActiveIMMApp, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDefWindowProc(self, hWnd, Msg, wParam, lParam, plResult) +proc FilterClientWindows*(self: ptr IActiveIMMApp, aaClassList: ptr ATOM, uSize: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FilterClientWindows(self, aaClassList, uSize) +proc GetCodePageA*(self: ptr IActiveIMMApp, hKL: HKL, uCodePage: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCodePageA(self, hKL, uCodePage) +proc GetLangId*(self: ptr IActiveIMMApp, hKL: HKL, plid: ptr LANGID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLangId(self, hKL, plid) +proc AssociateContextEx*(self: ptr IActiveIMMApp, hWnd: HWND, hIMC: HIMC, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AssociateContextEx(self, hWnd, hIMC, dwFlags) +proc DisableIME*(self: ptr IActiveIMMApp, idThread: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DisableIME(self, idThread) +proc GetImeMenuItemsA*(self: ptr IActiveIMMApp, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOA, pImeMenu: ptr IMEMENUITEMINFOA, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImeMenuItemsA(self, hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult) +proc GetImeMenuItemsW*(self: ptr IActiveIMMApp, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOW, pImeMenu: ptr IMEMENUITEMINFOW, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImeMenuItemsW(self, hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult) +proc EnumInputContext*(self: ptr IActiveIMMApp, idThread: DWORD, ppEnum: ptr ptr IEnumInputContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumInputContext(self, idThread, ppEnum) +proc AssociateContext*(self: ptr IActiveIMMIME, hWnd: HWND, hIME: HIMC, phPrev: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AssociateContext(self, hWnd, hIME, phPrev) +proc ConfigureIMEA*(self: ptr IActiveIMMIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfigureIMEA(self, hKL, hWnd, dwMode, pData) +proc ConfigureIMEW*(self: ptr IActiveIMMIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pData: ptr REGISTERWORDW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfigureIMEW(self, hKL, hWnd, dwMode, pData) +proc CreateContext*(self: ptr IActiveIMMIME, phIMC: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateContext(self, phIMC) +proc DestroyContext*(self: ptr IActiveIMMIME, hIME: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyContext(self, hIME) +proc EnumRegisterWordA*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRegisterWordA(self, hKL, szReading, dwStyle, szRegister, pData, pEnum) +proc EnumRegisterWordW*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, pEnum: ptr ptr IEnumRegisterWordW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRegisterWordW(self, hKL, szReading, dwStyle, szRegister, pData, pEnum) +proc EscapeA*(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EscapeA(self, hKL, hIMC, uEscape, pData, plResult) +proc EscapeW*(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, uEscape: UINT, pData: LPVOID, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EscapeW(self, hKL, hIMC, uEscape, pData, plResult) +proc GetCandidateListA*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListA(self, hIMC, dwIndex, uBufLen, pCandList, puCopied) +proc GetCandidateListW*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, uBufLen: UINT, pCandList: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListW(self, hIMC, dwIndex, uBufLen, pCandList, puCopied) +proc GetCandidateListCountA*(self: ptr IActiveIMMIME, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListCountA(self, hIMC, pdwListSize, pdwBufLen) +proc GetCandidateListCountW*(self: ptr IActiveIMMIME, hIMC: HIMC, pdwListSize: ptr DWORD, pdwBufLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateListCountW(self, hIMC, pdwListSize, pdwBufLen) +proc GetCandidateWindow*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pCandidate: ptr CANDIDATEFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCandidateWindow(self, hIMC, dwIndex, pCandidate) +proc GetCompositionFontA*(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionFontA(self, hIMC, plf) +proc GetCompositionFontW*(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionFontW(self, hIMC, plf) +proc GetCompositionStringA*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionStringA(self, hIMC, dwIndex, dwBufLen, plCopied, pBuf) +proc GetCompositionStringW*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, plCopied: ptr LONG, pBuf: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionStringW(self, hIMC, dwIndex, dwBufLen, plCopied, pBuf) +proc GetCompositionWindow*(self: ptr IActiveIMMIME, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionWindow(self, hIMC, pCompForm) +proc GetContext*(self: ptr IActiveIMMIME, hWnd: HWND, phIMC: ptr HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContext(self, hWnd, phIMC) +proc GetConversionListA*(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, pSrc: LPSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionListA(self, hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied) +proc GetConversionListW*(self: ptr IActiveIMMIME, hKL: HKL, hIMC: HIMC, pSrc: LPWSTR, uBufLen: UINT, uFlag: UINT, pDst: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionListW(self, hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied) +proc GetConversionStatus*(self: ptr IActiveIMMIME, hIMC: HIMC, pfdwConversion: ptr DWORD, pfdwSentence: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionStatus(self, hIMC, pfdwConversion, pfdwSentence) +proc GetDefaultIMEWnd*(self: ptr IActiveIMMIME, hWnd: HWND, phDefWnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultIMEWnd(self, hWnd, phDefWnd) +proc GetDescriptionA*(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szDescription: LPSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescriptionA(self, hKL, uBufLen, szDescription, puCopied) +proc GetDescriptionW*(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szDescription: LPWSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescriptionW(self, hKL, uBufLen, szDescription, puCopied) +proc GetGuideLineA*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGuideLineA(self, hIMC, dwIndex, dwBufLen, pBuf, pdwResult) +proc GetGuideLineW*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, dwBufLen: DWORD, pBuf: LPWSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGuideLineW(self, hIMC, dwIndex, dwBufLen, pBuf, pdwResult) +proc GetIMEFileNameA*(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szFileName: LPSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMEFileNameA(self, hKL, uBufLen, szFileName, puCopied) +proc GetIMEFileNameW*(self: ptr IActiveIMMIME, hKL: HKL, uBufLen: UINT, szFileName: LPWSTR, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMEFileNameW(self, hKL, uBufLen, szFileName, puCopied) +proc GetOpenStatus*(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOpenStatus(self, hIMC) +proc GetProperty*(self: ptr IActiveIMMIME, hKL: HKL, fdwIndex: DWORD, pdwProperty: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, hKL, fdwIndex, pdwProperty) +proc GetRegisterWordStyleA*(self: ptr IActiveIMMIME, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFA, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisterWordStyleA(self, hKL, nItem, pStyleBuf, puCopied) +proc GetRegisterWordStyleW*(self: ptr IActiveIMMIME, hKL: HKL, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisterWordStyleW(self, hKL, nItem, pStyleBuf, puCopied) +proc GetStatusWindowPos*(self: ptr IActiveIMMIME, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStatusWindowPos(self, hIMC, pptPos) +proc GetVirtualKey*(self: ptr IActiveIMMIME, hWnd: HWND, puVirtualKey: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVirtualKey(self, hWnd, puVirtualKey) +proc InstallIMEA*(self: ptr IActiveIMMIME, szIMEFileName: LPSTR, szLayoutText: LPSTR, phKL: ptr HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InstallIMEA(self, szIMEFileName, szLayoutText, phKL) +proc InstallIMEW*(self: ptr IActiveIMMIME, szIMEFileName: LPWSTR, szLayoutText: LPWSTR, phKL: ptr HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InstallIMEW(self, szIMEFileName, szLayoutText, phKL) +proc IsIME*(self: ptr IActiveIMMIME, hKL: HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsIME(self, hKL) +proc IsUIMessageA*(self: ptr IActiveIMMIME, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsUIMessageA(self, hWndIME, msg, wParam, lParam) +proc IsUIMessageW*(self: ptr IActiveIMMIME, hWndIME: HWND, msg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsUIMessageW(self, hWndIME, msg, wParam, lParam) +proc NotifyIME*(self: ptr IActiveIMMIME, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NotifyIME(self, hIMC, dwAction, dwIndex, dwValue) +proc mRegisterWordA*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szRegister: LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterWordA(self, hKL, szReading, dwStyle, szRegister) +proc mRegisterWordW*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterWordW(self, hKL, szReading, dwStyle, szRegister) +proc ReleaseContext*(self: ptr IActiveIMMIME, hWnd: HWND, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseContext(self, hWnd, hIMC) +proc SetCandidateWindow*(self: ptr IActiveIMMIME, hIMC: HIMC, pCandidate: ptr CANDIDATEFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCandidateWindow(self, hIMC, pCandidate) +proc SetCompositionFontA*(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionFontA(self, hIMC, plf) +proc SetCompositionFontW*(self: ptr IActiveIMMIME, hIMC: HIMC, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionFontW(self, hIMC, plf) +proc SetCompositionStringA*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionStringA(self, hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen) +proc SetCompositionStringW*(self: ptr IActiveIMMIME, hIMC: HIMC, dwIndex: DWORD, pComp: LPVOID, dwCompLen: DWORD, pRead: LPVOID, dwReadLen: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionStringW(self, hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen) +proc SetCompositionWindow*(self: ptr IActiveIMMIME, hIMC: HIMC, pCompForm: ptr COMPOSITIONFORM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionWindow(self, hIMC, pCompForm) +proc SetConversionStatus*(self: ptr IActiveIMMIME, hIMC: HIMC, fdwConversion: DWORD, fdwSentence: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetConversionStatus(self, hIMC, fdwConversion, fdwSentence) +proc SetOpenStatus*(self: ptr IActiveIMMIME, hIMC: HIMC, fOpen: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOpenStatus(self, hIMC, fOpen) +proc SetStatusWindowPos*(self: ptr IActiveIMMIME, hIMC: HIMC, pptPos: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStatusWindowPos(self, hIMC, pptPos) +proc SimulateHotKey*(self: ptr IActiveIMMIME, hWnd: HWND, dwHotKeyID: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SimulateHotKey(self, hWnd, dwHotKeyID) +proc UnregisterWordA*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPSTR, dwStyle: DWORD, szUnregister: LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterWordA(self, hKL, szReading, dwStyle, szUnregister) +proc UnregisterWordW*(self: ptr IActiveIMMIME, hKL: HKL, szReading: LPWSTR, dwStyle: DWORD, szUnregister: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterWordW(self, hKL, szReading, dwStyle, szUnregister) +proc GenerateMessage*(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GenerateMessage(self, hIMC) +proc LockIMC*(self: ptr IActiveIMMIME, hIMC: HIMC, ppIMC: ptr ptr INPUTCONTEXT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockIMC(self, hIMC, ppIMC) +proc UnlockIMC*(self: ptr IActiveIMMIME, hIMC: HIMC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockIMC(self, hIMC) +proc GetIMCLockCount*(self: ptr IActiveIMMIME, hIMC: HIMC, pdwLockCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMCLockCount(self, hIMC, pdwLockCount) +proc CreateIMCC*(self: ptr IActiveIMMIME, dwSize: DWORD, phIMCC: ptr HIMCC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateIMCC(self, dwSize, phIMCC) +proc DestroyIMCC*(self: ptr IActiveIMMIME, hIMCC: HIMCC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyIMCC(self, hIMCC) +proc LockIMCC*(self: ptr IActiveIMMIME, hIMCC: HIMCC, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockIMCC(self, hIMCC, ppv) +proc UnlockIMCC*(self: ptr IActiveIMMIME, hIMCC: HIMCC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockIMCC(self, hIMCC) +proc ReSizeIMCC*(self: ptr IActiveIMMIME, hIMCC: HIMCC, dwSize: DWORD, phIMCC: ptr HIMCC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReSizeIMCC(self, hIMCC, dwSize, phIMCC) +proc GetIMCCSize*(self: ptr IActiveIMMIME, hIMCC: HIMCC, pdwSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMCCSize(self, hIMCC, pdwSize) +proc GetIMCCLockCount*(self: ptr IActiveIMMIME, hIMCC: HIMCC, pdwLockCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIMCCLockCount(self, hIMCC, pdwLockCount) +proc GetHotKey*(self: ptr IActiveIMMIME, dwHotKeyID: DWORD, puModifiers: ptr UINT, puVKey: ptr UINT, phKL: ptr HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHotKey(self, dwHotKeyID, puModifiers, puVKey, phKL) +proc SetHotKey*(self: ptr IActiveIMMIME, dwHotKeyID: DWORD, uModifiers: UINT, uVKey: UINT, hKL: HKL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHotKey(self, dwHotKeyID, uModifiers, uVKey, hKL) +proc CreateSoftKeyboard*(self: ptr IActiveIMMIME, uType: UINT, hOwner: HWND, x: int32, y: int32, phSoftKbdWnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateSoftKeyboard(self, uType, hOwner, x, y, phSoftKbdWnd) +proc DestroySoftKeyboard*(self: ptr IActiveIMMIME, hSoftKbdWnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroySoftKeyboard(self, hSoftKbdWnd) +proc ShowSoftKeyboard*(self: ptr IActiveIMMIME, hSoftKbdWnd: HWND, nCmdShow: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowSoftKeyboard(self, hSoftKbdWnd, nCmdShow) +proc GetCodePageA*(self: ptr IActiveIMMIME, hKL: HKL, uCodePage: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCodePageA(self, hKL, uCodePage) +proc GetLangId*(self: ptr IActiveIMMIME, hKL: HKL, plid: ptr LANGID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLangId(self, hKL, plid) +proc KeybdEvent*(self: ptr IActiveIMMIME, lgidIME: LANGID, bVk: BYTE, bScan: BYTE, dwFlags: DWORD, dwExtraInfo: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.KeybdEvent(self, lgidIME, bVk, bScan, dwFlags, dwExtraInfo) +proc LockModal*(self: ptr IActiveIMMIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockModal(self) +proc UnlockModal*(self: ptr IActiveIMMIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockModal(self) +proc AssociateContextEx*(self: ptr IActiveIMMIME, hWnd: HWND, hIMC: HIMC, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AssociateContextEx(self, hWnd, hIMC, dwFlags) +proc DisableIME*(self: ptr IActiveIMMIME, idThread: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DisableIME(self, idThread) +proc GetImeMenuItemsA*(self: ptr IActiveIMMIME, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOA, pImeMenu: ptr IMEMENUITEMINFOA, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImeMenuItemsA(self, hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult) +proc GetImeMenuItemsW*(self: ptr IActiveIMMIME, hIMC: HIMC, dwFlags: DWORD, dwType: DWORD, pImeParentMenu: ptr IMEMENUITEMINFOW, pImeMenu: ptr IMEMENUITEMINFOW, dwSize: DWORD, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImeMenuItemsW(self, hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult) +proc EnumInputContext*(self: ptr IActiveIMMIME, idThread: DWORD, ppEnum: ptr ptr IEnumInputContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumInputContext(self, idThread, ppEnum) +proc RequestMessageA*(self: ptr IActiveIMMIME, hIMC: HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestMessageA(self, hIMC, wParam, lParam, plResult) +proc RequestMessageW*(self: ptr IActiveIMMIME, hIMC: HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestMessageW(self, hIMC, wParam, lParam, plResult) +proc SendIMCA*(self: ptr IActiveIMMIME, hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendIMCA(self, hWnd, uMsg, wParam, lParam, plResult) +proc SendIMCW*(self: ptr IActiveIMMIME, hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendIMCW(self, hWnd, uMsg, wParam, lParam, plResult) +proc IsSleeping*(self: ptr IActiveIMMIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSleeping(self) +proc Inquire*(self: ptr IActiveIME, dwSystemInfoFlags: DWORD, pIMEInfo: ptr IMEINFO, szWndClass: LPWSTR, pdwPrivate: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Inquire(self, dwSystemInfoFlags, pIMEInfo, szWndClass, pdwPrivate) +proc ConversionList*(self: ptr IActiveIME, hIMC: HIMC, szSource: LPWSTR, uFlag: UINT, uBufLen: UINT, pDest: ptr CANDIDATELIST, puCopied: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConversionList(self, hIMC, szSource, uFlag, uBufLen, pDest, puCopied) +proc Configure*(self: ptr IActiveIME, hKL: HKL, hWnd: HWND, dwMode: DWORD, pRegisterWord: ptr REGISTERWORDW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Configure(self, hKL, hWnd, dwMode, pRegisterWord) +proc Destroy*(self: ptr IActiveIME, uReserved: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Destroy(self, uReserved) +proc Escape*(self: ptr IActiveIME, hIMC: HIMC, uEscape: UINT, pData: pointer, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Escape(self, hIMC, uEscape, pData, plResult) +proc SetActiveContext*(self: ptr IActiveIME, hIMC: HIMC, fFlag: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetActiveContext(self, hIMC, fFlag) +proc ProcessKey*(self: ptr IActiveIME, hIMC: HIMC, uVirKey: UINT, lParam: DWORD, pbKeyState: ptr BYTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessKey(self, hIMC, uVirKey, lParam, pbKeyState) +proc Notify*(self: ptr IActiveIME, hIMC: HIMC, dwAction: DWORD, dwIndex: DWORD, dwValue: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Notify(self, hIMC, dwAction, dwIndex, dwValue) +proc Select*(self: ptr IActiveIME, hIMC: HIMC, fSelect: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self, hIMC, fSelect) +proc SetCompositionString*(self: ptr IActiveIME, hIMC: HIMC, dwIndex: DWORD, pComp: pointer, dwCompLen: DWORD, pRead: pointer, dwReadLen: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionString(self, hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen) +proc ToAsciiEx*(self: ptr IActiveIME, uVirKey: UINT, uScanCode: UINT, pbKeyState: ptr BYTE, fuState: UINT, hIMC: HIMC, pdwTransBuf: ptr DWORD, puSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ToAsciiEx(self, uVirKey, uScanCode, pbKeyState, fuState, hIMC, pdwTransBuf, puSize) +proc mRegisterWord*(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szString: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterWord(self, szReading, dwStyle, szString) +proc UnregisterWord*(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szString: LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterWord(self, szReading, dwStyle, szString) +proc GetRegisterWordStyle*(self: ptr IActiveIME, nItem: UINT, pStyleBuf: ptr STYLEBUFW, puBufSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisterWordStyle(self, nItem, pStyleBuf, puBufSize) +proc EnumRegisterWord*(self: ptr IActiveIME, szReading: LPWSTR, dwStyle: DWORD, szRegister: LPWSTR, pData: LPVOID, ppEnum: ptr ptr IEnumRegisterWordW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRegisterWord(self, szReading, dwStyle, szRegister, pData, ppEnum) +proc GetCodePageA*(self: ptr IActiveIME, uCodePage: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCodePageA(self, uCodePage) +proc GetLangId*(self: ptr IActiveIME, plid: ptr LANGID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLangId(self, plid) +proc Sleep*(self: ptr IActiveIME2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Sleep(self) +proc Unsleep*(self: ptr IActiveIME2, fDead: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unsleep(self, fDead) +proc Clone*(self: ptr IEnumRegisterWordA, ppEnum: ptr ptr IEnumRegisterWordA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Next*(self: ptr IEnumRegisterWordA, ulCount: ULONG, rgRegisterWord: ptr REGISTERWORDA, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, ulCount, rgRegisterWord, pcFetched) +proc Reset*(self: ptr IEnumRegisterWordA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Skip*(self: ptr IEnumRegisterWordA, ulCount: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, ulCount) +proc Clone*(self: ptr IEnumRegisterWordW, ppEnum: ptr ptr IEnumRegisterWordW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Next*(self: ptr IEnumRegisterWordW, ulCount: ULONG, rgRegisterWord: ptr REGISTERWORDW, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, ulCount, rgRegisterWord, pcFetched) +proc Reset*(self: ptr IEnumRegisterWordW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Skip*(self: ptr IEnumRegisterWordW, ulCount: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, ulCount) +converter winimConverterIEnumInputContextToIUnknown*(x: ptr IEnumInputContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIMMRegistrarToIUnknown*(x: ptr IActiveIMMRegistrar): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIMMMessagePumpOwnerToIUnknown*(x: ptr IActiveIMMMessagePumpOwner): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIMMAppToIUnknown*(x: ptr IActiveIMMApp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIMMIMEToIUnknown*(x: ptr IActiveIMMIME): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIMEToIUnknown*(x: ptr IActiveIME): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveIME2ToIActiveIME*(x: ptr IActiveIME2): ptr IActiveIME = cast[ptr IActiveIME](x) +converter winimConverterIActiveIME2ToIUnknown*(x: ptr IActiveIME2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumRegisterWordAToIUnknown*(x: ptr IEnumRegisterWordA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumRegisterWordWToIUnknown*(x: ptr IEnumRegisterWordW): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + REGISTERWORD* = REGISTERWORDW + PREGISTERWORD* = PREGISTERWORDW + NPREGISTERWORD* = NPREGISTERWORDW + LPREGISTERWORD* = LPREGISTERWORDW + STYLEBUF* = STYLEBUFW + PSTYLEBUF* = PSTYLEBUFW + NPSTYLEBUF* = NPSTYLEBUFW + LPSTYLEBUF* = LPSTYLEBUFW + IMEMENUITEMINFO* = IMEMENUITEMINFOW + PIMEMENUITEMINFO* = PIMEMENUITEMINFOW + NPIMEMENUITEMINFO* = NPIMEMENUITEMINFOW + LPIMEMENUITEMINFO* = LPIMEMENUITEMINFOW + REGISTERWORDENUMPROC* = REGISTERWORDENUMPROCW + proc ImmInstallIME*(lpszIMEFileName: LPCWSTR, lpszLayoutText: LPCWSTR): HKL {.winapi, stdcall, dynlib: "imm32", importc: "ImmInstallIMEW".} + proc ImmGetDescription*(P1: HKL, P2: LPWSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetDescriptionW".} + proc ImmGetIMEFileName*(P1: HKL, P2: LPWSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetIMEFileNameW".} + proc ImmGetCompositionString*(P1: HIMC, P2: DWORD, P3: LPVOID, P4: DWORD): LONG {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCompositionStringW".} + proc ImmSetCompositionString*(P1: HIMC, dwIndex: DWORD, lpComp: LPVOID, P4: DWORD, lpRead: LPVOID, P6: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmSetCompositionStringW".} + proc ImmGetCandidateListCount*(P1: HIMC, lpdwListCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCandidateListCountW".} + proc ImmGetCandidateList*(P1: HIMC, deIndex: DWORD, P3: LPCANDIDATELIST, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCandidateListW".} + proc ImmGetGuideLine*(P1: HIMC, dwIndex: DWORD, P3: LPWSTR, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetGuideLineW".} + proc ImmGetCompositionFont*(P1: HIMC, P2: LPLOGFONTW): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCompositionFontW".} + proc ImmSetCompositionFont*(P1: HIMC, P2: LPLOGFONTW): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmSetCompositionFontW".} + proc ImmConfigureIME*(P1: HKL, P2: HWND, P3: DWORD, P4: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmConfigureIMEW".} + proc ImmEscape*(P1: HKL, P2: HIMC, P3: UINT, P4: LPVOID): LRESULT {.winapi, stdcall, dynlib: "imm32", importc: "ImmEscapeW".} + proc ImmGetConversionList*(P1: HKL, P2: HIMC, P3: LPCWSTR, P4: LPCANDIDATELIST, dwBufLen: DWORD, uFlag: UINT): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetConversionListW".} + proc ImmIsUIMessage*(P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmIsUIMessageW".} + proc ImmRegisterWord*(P1: HKL, lpszReading: LPCWSTR, P3: DWORD, lpszRegister: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmRegisterWordW".} + proc ImmUnregisterWord*(P1: HKL, lpszReading: LPCWSTR, P3: DWORD, lpszUnregister: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmUnregisterWordW".} + proc ImmGetRegisterWordStyle*(P1: HKL, nItem: UINT, P3: LPSTYLEBUFW): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetRegisterWordStyleW".} + proc ImmEnumRegisterWord*(P1: HKL, P2: REGISTERWORDENUMPROCW, lpszReading: LPCWSTR, P4: DWORD, lpszRegister: LPCWSTR, P6: LPVOID): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmEnumRegisterWordW".} + proc ImmGetImeMenuItems*(P1: HIMC, P2: DWORD, P3: DWORD, P4: LPIMEMENUITEMINFOW, P5: LPIMEMENUITEMINFOW, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetImeMenuItemsW".} +when winimAnsi: + type + REGISTERWORD* = REGISTERWORDA + PREGISTERWORD* = PREGISTERWORDA + NPREGISTERWORD* = NPREGISTERWORDA + LPREGISTERWORD* = LPREGISTERWORDA + STYLEBUF* = STYLEBUFA + PSTYLEBUF* = PSTYLEBUFA + NPSTYLEBUF* = NPSTYLEBUFA + LPSTYLEBUF* = LPSTYLEBUFA + IMEMENUITEMINFO* = IMEMENUITEMINFOA + PIMEMENUITEMINFO* = PIMEMENUITEMINFOA + NPIMEMENUITEMINFO* = NPIMEMENUITEMINFOA + LPIMEMENUITEMINFO* = LPIMEMENUITEMINFOA + REGISTERWORDENUMPROC* = REGISTERWORDENUMPROCA + proc ImmInstallIME*(lpszIMEFileName: LPCSTR, lpszLayoutText: LPCSTR): HKL {.winapi, stdcall, dynlib: "imm32", importc: "ImmInstallIMEA".} + proc ImmGetDescription*(P1: HKL, P2: LPSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetDescriptionA".} + proc ImmGetIMEFileName*(P1: HKL, P2: LPSTR, uBufLen: UINT): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetIMEFileNameA".} + proc ImmGetCompositionString*(P1: HIMC, P2: DWORD, P3: LPVOID, P4: DWORD): LONG {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCompositionStringA".} + proc ImmSetCompositionString*(P1: HIMC, dwIndex: DWORD, lpComp: LPVOID, P4: DWORD, lpRead: LPVOID, P6: DWORD): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmSetCompositionStringA".} + proc ImmGetCandidateListCount*(P1: HIMC, lpdwListCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCandidateListCountA".} + proc ImmGetCandidateList*(P1: HIMC, deIndex: DWORD, P3: LPCANDIDATELIST, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCandidateListA".} + proc ImmGetGuideLine*(P1: HIMC, dwIndex: DWORD, P3: LPSTR, dwBufLen: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetGuideLineA".} + proc ImmGetCompositionFont*(P1: HIMC, P2: LPLOGFONTA): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetCompositionFontA".} + proc ImmSetCompositionFont*(P1: HIMC, P2: LPLOGFONTA): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmSetCompositionFontA".} + proc ImmConfigureIME*(P1: HKL, P2: HWND, P3: DWORD, P4: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmConfigureIMEA".} + proc ImmEscape*(P1: HKL, P2: HIMC, P3: UINT, P4: LPVOID): LRESULT {.winapi, stdcall, dynlib: "imm32", importc: "ImmEscapeA".} + proc ImmGetConversionList*(P1: HKL, P2: HIMC, P3: LPCSTR, P4: LPCANDIDATELIST, dwBufLen: DWORD, uFlag: UINT): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetConversionListA".} + proc ImmIsUIMessage*(P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmIsUIMessageA".} + proc ImmRegisterWord*(P1: HKL, lpszReading: LPCSTR, P3: DWORD, lpszRegister: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmRegisterWordA".} + proc ImmUnregisterWord*(P1: HKL, lpszReading: LPCSTR, P3: DWORD, lpszUnregister: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "imm32", importc: "ImmUnregisterWordA".} + proc ImmGetRegisterWordStyle*(P1: HKL, nItem: UINT, P3: LPSTYLEBUFA): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetRegisterWordStyleA".} + proc ImmEnumRegisterWord*(P1: HKL, P2: REGISTERWORDENUMPROCA, lpszReading: LPCSTR, P4: DWORD, lpszRegister: LPCSTR, P6: LPVOID): UINT {.winapi, stdcall, dynlib: "imm32", importc: "ImmEnumRegisterWordA".} + proc ImmGetImeMenuItems*(P1: HIMC, P2: DWORD, P3: DWORD, P4: LPIMEMENUITEMINFOA, P5: LPIMEMENUITEMINFOA, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "imm32", importc: "ImmGetImeMenuItemsA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/iphlpapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/iphlpapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,6096 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winsock +import windns +import objbase +import ras +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + NL_DAD_STATE* = int32 + NL_ROUTE_PROTOCOL* = int32 + PNL_ROUTE_PROTOCOL* = ptr int32 + NL_PREFIX_ORIGIN* = int32 + NL_SUFFIX_ORIGIN* = int32 + NL_ADDRESS_TYPE* = int32 + PNL_ADDRESS_TYPE* = ptr int32 + NL_ROUTE_ORIGIN* = int32 + PNL_ROUTE_ORIGIN* = ptr int32 + NL_NEIGHBOR_STATE* = int32 + PNL_NEIGHBOR_STATE* = ptr int32 + NL_LINK_LOCAL_ADDRESS_BEHAVIOR* = int32 + NL_ROUTER_DISCOVERY_BEHAVIOR* = int32 + NL_BANDWIDTH_FLAG* = int32 + PNL_BANDWIDTH_FLAG* = ptr int32 + NL_INTERFACE_NETWORK_CATEGORY_STATE* = int32 + PNL_INTERFACE_NETWORK_CATEGORY_STATE* = ptr int32 + NL_NETWORK_CATEGORY* = int32 + PNL_NETWORK_CATEGORY* = ptr int32 + MIB_TCP_STATE* = int32 + TCP_CONNECTION_OFFLOAD_STATE* = int32 + ICMP6_TYPE* = int32 + PICMP6_TYPE* = ptr int32 + ICMP4_TYPE* = int32 + PICMP4_TYPE* = ptr int32 + TCP_TABLE_CLASS* = int32 + PTCP_TABLE_CLASS* = ptr int32 + UDP_TABLE_CLASS* = int32 + PUDP_TABLE_CLASS* = ptr int32 + TCPIP_OWNER_MODULE_INFO_CLASS* = int32 + PTCPIP_OWNER_MODULE_INFO_CLASS* = ptr int32 + IF_OPER_STATUS* = int32 + NET_IF_OPER_STATUS* = int32 + PNET_IF_OPER_STATUS* = ptr int32 + NET_IF_ADMIN_STATUS* = int32 + PNET_IF_ADMIN_STATUS* = ptr int32 + NET_IF_MEDIA_CONNECT_STATE* = int32 + PNET_IF_MEDIA_CONNECT_STATE* = ptr int32 + NET_IF_ACCESS_TYPE* = int32 + PNET_IF_ACCESS_TYPE* = ptr int32 + NET_IF_CONNECTION_TYPE* = int32 + PNET_IF_CONNECTION_TYPE* = ptr int32 + NET_IF_DIRECTION_TYPE* = int32 + PNET_IF_DIRECTION_TYPE* = ptr int32 + NET_IF_MEDIA_DUPLEX_STATE* = int32 + PNET_IF_MEDIA_DUPLEX_STATE* = ptr int32 + TUNNEL_TYPE* = int32 + PTUNNEL_TYPE* = ptr int32 + TCP_BOOLEAN_OPTIONAL* = int32 + TCP_ESTATS_TYPE* = int32 + NET_ADDRESS_FORMAT* = int32 + MIB_NOTIFICATION_TYPE* = int32 + PMIB_NOTIFICATION_TYPE* = ptr int32 + NDIS_REQUEST_TYPE* = int32 + PNDIS_REQUEST_TYPE* = ptr int32 + NDIS_INTERRUPT_MODERATION* = int32 + PNDIS_INTERRUPT_MODERATION* = ptr int32 + NDIS_802_11_STATUS_TYPE* = int32 + PNDIS_802_11_STATUS_TYPE* = ptr int32 + NDIS_802_11_NETWORK_TYPE* = int32 + PNDIS_802_11_NETWORK_TYPE* = ptr int32 + NDIS_802_11_POWER_MODE* = int32 + PNDIS_802_11_POWER_MODE* = ptr int32 + NDIS_802_11_NETWORK_INFRASTRUCTURE* = int32 + PNDIS_802_11_NETWORK_INFRASTRUCTURE* = ptr int32 + NDIS_802_11_AUTHENTICATION_MODE* = int32 + PNDIS_802_11_AUTHENTICATION_MODE* = ptr int32 + NDIS_802_11_PRIVACY_FILTER* = int32 + PNDIS_802_11_PRIVACY_FILTER* = ptr int32 + NDIS_802_11_WEP_STATUS* = int32 + PNDIS_802_11_WEP_STATUS* = ptr int32 + NDIS_802_11_ENCRYPTION_STATUS* = int32 + PNDIS_802_11_ENCRYPTION_STATUS* = ptr int32 + NDIS_802_11_RELOAD_DEFAULTS* = int32 + PNDIS_802_11_RELOAD_DEFAULTS* = ptr int32 + NDIS_802_11_MEDIA_STREAM_MODE* = int32 + PNDIS_802_11_MEDIA_STREAM_MODE* = ptr int32 + NDIS_802_11_RADIO_STATUS* = int32 + PNDIS_802_11_RADIO_STATUS* = ptr int32 + OFFLOAD_OPERATION_E* = int32 + OFFLOAD_CONF_ALGO* = int32 + OFFLOAD_INTEGRITY_ALGO* = int32 + UDP_ENCAP_TYPE* = int32 + PUDP_ENCAP_TYPE* = ptr int32 + NDIS_MEDIUM* = int32 + PNDIS_MEDIUM* = ptr int32 + NDIS_PHYSICAL_MEDIUM* = int32 + PNDIS_PHYSICAL_MEDIUM* = ptr int32 + NDIS_HARDWARE_STATUS* = int32 + PNDIS_HARDWARE_STATUS* = ptr int32 + NDIS_DEVICE_POWER_STATE* = int32 + PNDIS_DEVICE_POWER_STATE* = ptr int32 + NDIS_FDDI_ATTACHMENT_TYPE* = int32 + PNDIS_FDDI_ATTACHMENT_TYPE* = ptr int32 + NDIS_FDDI_RING_MGT_STATE* = int32 + PNDIS_FDDI_RING_MGT_STATE* = ptr int32 + NDIS_FDDI_LCONNECTION_STATE* = int32 + PNDIS_FDDI_LCONNECTION_STATE* = ptr int32 + NDIS_WAN_MEDIUM_SUBTYPE* = int32 + PNDIS_WAN_MEDIUM_SUBTYPE* = ptr int32 + NDIS_WAN_HEADER_FORMAT* = int32 + PNDIS_WAN_HEADER_FORMAT* = ptr int32 + NDIS_WAN_QUALITY* = int32 + PNDIS_WAN_QUALITY* = ptr int32 + NDIS_802_5_RING_STATE* = int32 + PNDIS_802_5_RING_STATE* = ptr int32 + NDIS_MEDIA_STATE* = int32 + PNDIS_MEDIA_STATE* = ptr int32 + NDIS_STATUS* = int32 + PNDIS_STATUS* = ptr int32 + NDIS_SUPPORTED_PAUSE_FUNCTIONS* = int32 + PNDIS_SUPPORTED_PAUSE_FUNCTIONS* = ptr int32 + NDIS_PORT_TYPE* = int32 + PNDIS_PORT_TYPE* = ptr int32 + NDIS_PORT_AUTHORIZATION_STATE* = int32 + PNDIS_PORT_AUTHORIZATION_STATE* = ptr int32 + NDIS_PORT_CONTROL_STATE* = int32 + PNDIS_PORT_CONTROL_STATE* = ptr int32 + NDIS_NETWORK_CHANGE_TYPE* = int32 + PNDIS_NETWORK_CHANGE_TYPE* = ptr int32 + NDIS_PM_WOL_PACKET* = int32 + PNDIS_PM_WOL_PACKET* = ptr int32 + NDIS_PM_PROTOCOL_OFFLOAD_TYPE* = int32 + PNDIS_PM_PROTOCOL_OFFLOAD_TYPE* = ptr int32 + NDIS_PM_WAKE_REASON_TYPE* = int32 + PNDIS_PM_WAKE_REASON_TYPE* = ptr int32 + NDIS_PM_ADMIN_CONFIG_STATE* = int32 + PNDIS_PM_ADMIN_CONFIG_STATE* = ptr int32 + NDIS_PM_CAPABILITY_STATE* = int32 + PNDIS_PM_CAPABILITY_STATE* = ptr int32 + NDIS_RECEIVE_FILTER_TYPE* = int32 + PNDIS_RECEIVE_FILTER_TYPE* = ptr int32 + NDIS_FRAME_HEADER* = int32 + PNDIS_FRAME_HEADER* = ptr int32 + NDIS_MAC_HEADER_FIELD* = int32 + PNDIS_MAC_HEADER_FIELD* = ptr int32 + NDIS_MAC_PACKET_TYPE* = int32 + PNDIS_MAC_PACKET_TYPE* = ptr int32 + NDIS_ARP_HEADER_FIELD* = int32 + PNDIS_ARP_HEADER_FIELD* = ptr int32 + NDIS_IPV4_HEADER_FIELD* = int32 + PNDIS_IPV4_HEADER_FIELD* = ptr int32 + NDIS_IPV6_HEADER_FIELD* = int32 + PNDIS_IPV6_HEADER_FIELD* = ptr int32 + NDIS_UDP_HEADER_FIELD* = int32 + PNDIS_UDP_HEADER_FIELD* = ptr int32 + NDIS_RECEIVE_FILTER_TEST* = int32 + PNDIS_RECEIVE_FILTER_TEST* = ptr int32 + NDIS_RECEIVE_QUEUE_TYPE* = int32 + PNDIS_RECEIVE_QUEUE_TYPE* = ptr int32 + NDIS_RECEIVE_QUEUE_OPERATIONAL_STATE* = int32 + PNDIS_RECEIVE_QUEUE_OPERATIONAL_STATE* = ptr int32 + NDIS_PROCESSOR_VENDOR* = int32 + PNDIS_PROCESSOR_VENDOR* = ptr int32 + NDIS_RSS_PROFILE* = int32 + PNDIS_RSS_PROFILE* = ptr int32 + NDIS_HYPERVISOR_PARTITION_TYPE* = int32 + PNDIS_HYPERVISOR_PARTITION_TYPE* = ptr int32 + NDIS_NIC_SWITCH_TYPE* = int32 + PNDIS_NIC_SWITCH_TYPE* = ptr int32 + NDIS_NIC_SWITCH_VPORT_STATE* = int32 + PNDIS_NIC_SWITCH_VPORT_STATE* = ptr int32 + NDIS_NIC_SWITCH_VPORT_INTERRUPT_MODERATION* = int32 + PNDIS_NIC_SWITCH_VPORT_INTERRUPT_MODERATION* = ptr int32 + NDIS_SWITCH_PORT_PROPERTY_TYPE* = int32 + PNDIS_SWITCH_PORT_PROPERTY_TYPE* = ptr int32 + NDIS_SWITCH_PORT_VLAN_MODE* = int32 + PNDIS_SWITCH_PORT_VLAN_MODE* = ptr int32 + NDIS_SWITCH_PORT_PVLAN_MODE* = int32 + PNDIS_SWITCH_PORT_PVLAN_MODE* = ptr int32 + NDIS_SWITCH_PORT_FEATURE_STATUS_TYPE* = int32 + PNDIS_SWITCH_PORT_FEATURE_STATUS_TYPE* = ptr int32 + NDIS_SWITCH_PROPERTY_TYPE* = int32 + PNDIS_SWITCH_PROPERTY_TYPE* = ptr int32 + NDIS_SWITCH_FEATURE_STATUS_TYPE* = int32 + PNDIS_SWITCH_FEATURE_STATUS_TYPE* = ptr int32 + NDIS_SWITCH_PORT_TYPE* = int32 + NDIS_SWITCH_PORT_STATE* = int32 + NDIS_SWITCH_NIC_TYPE* = int32 + NDIS_SWITCH_NIC_STATE* = int32 + MIB_IF_TABLE_LEVEL* = int32 + PMIB_IF_TABLE_LEVEL* = ptr int32 + IFTYPE* = ULONG + SN_CHAR* = WCHAR + IPAddr* = ULONG + IPMask* = ULONG + IP_STATUS* = ULONG + NET_IFINDEX* = ULONG + PNET_IFINDEX* = ptr ULONG + NDIS_OID* = ULONG + PNDIS_OID* = ptr ULONG + NDIS_802_11_TX_POWER_LEVEL* = ULONG + NDIS_802_11_RSSI* = LONG + NDIS_802_11_KEY_INDEX* = ULONG + NDIS_802_11_KEY_RSC* = ULONGLONG + NDIS_802_11_FRAGMENTATION_THRESHOLD* = ULONG + NDIS_802_11_RTS_THRESHOLD* = ULONG + NDIS_802_11_ANTENNA* = ULONG + SPI_TYPE* = ULONG + NDIS_VLAN_ID* = ULONG + Priority_802_3* = ULONG + NDIS_PORT_NUMBER* = ULONG + PNDIS_PORT_NUMBER* = ptr ULONG + NDIS_RECEIVE_QUEUE_ID* = ULONG + PNDIS_RECEIVE_QUEUE_ID* = ptr ULONG + NDIS_RECEIVE_QUEUE_GROUP_ID* = ULONG + PNDIS_RECEIVE_QUEUE_GROUP_ID* = ptr ULONG + NDIS_RECEIVE_FILTER_ID* = ULONG + PNDIS_RECEIVE_FILTER_ID* = ptr ULONG + NDIS_NIC_SWITCH_VPORT_ID* = ULONG + PNDIS_NIC_SWITCH_VPORT_ID* = ptr ULONG + NDIS_NIC_SWITCH_ID* = ULONG + PNDIS_NIC_SWITCH_ID* = ptr ULONG + NDIS_SRIOV_FUNCTION_ID* = USHORT + PNDIS_SRIOV_FUNCTION_ID* = ptr USHORT + NDIS_VF_RID* = ULONG + PNDIS_VF_RID* = ptr ULONG + NDIS_SWITCH_OBJECT_VERSION* = USHORT + PNDIS_SWITCH_OBJECT_VERSION* = ptr USHORT + NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION* = USHORT + PNDIS_SWITCH_OBJECT_SERIALIZATION_VERSION* = ptr USHORT + NDIS_SWITCH_NIC_INDEX* = USHORT + PNDIS_SWITCH_NIC_INDEX* = ptr USHORT + NL_INTERFACE_OFFLOAD_ROD* {.pure.} = object + NlChecksumSupported* {.bitsize:1.}: BOOLEAN + NlOptionsSupported* {.bitsize:1.}: BOOLEAN + TlDatagramChecksumSupported* {.bitsize:1.}: BOOLEAN + TlStreamChecksumSupported* {.bitsize:1.}: BOOLEAN + TlStreamOptionsSupported* {.bitsize:1.}: BOOLEAN + FastPathCompatible* {.bitsize:1.}: BOOLEAN + TlLargeSendOffloadSupported* {.bitsize:1.}: BOOLEAN + TlGiantSendOffloadSupported* {.bitsize:1.}: BOOLEAN + PNL_INTERFACE_OFFLOAD_ROD* = ptr NL_INTERFACE_OFFLOAD_ROD + NL_PATH_BANDWIDTH_ROD* {.pure.} = object + Bandwidth*: ULONG64 + Instability*: ULONG64 + BandwidthPeaked*: BOOLEAN + PNL_PATH_BANDWIDTH_ROD* = ptr NL_PATH_BANDWIDTH_ROD + NL_BANDWIDTH_INFORMATION* {.pure.} = object + Bandwidth*: ULONG64 + Instability*: ULONG64 + BandwidthPeaked*: BOOLEAN + PNL_BANDWIDTH_INFORMATION* = ptr NL_BANDWIDTH_INFORMATION + MIB_UDP6ROW* {.pure.} = object + dwLocalAddr*: IN6_ADDR + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + PMIB_UDP6ROW* = ptr MIB_UDP6ROW +const + ANY_SIZE* = 1 +type + MIB_UDP6TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDP6ROW] + PMIB_UDP6TABLE* = ptr MIB_UDP6TABLE + MIB_TCP6ROW* {.pure.} = object + State*: MIB_TCP_STATE + LocalAddr*: IN6_ADDR + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + RemoteAddr*: IN6_ADDR + dwRemoteScopeId*: DWORD + dwRemotePort*: DWORD + PMIB_TCP6ROW* = ptr MIB_TCP6ROW + MIB_TCP6TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCP6ROW] + PMIB_TCP6TABLE* = ptr MIB_TCP6TABLE + MIB_TCP6ROW2* {.pure.} = object + LocalAddr*: IN6_ADDR + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + RemoteAddr*: IN6_ADDR + dwRemoteScopeId*: DWORD + dwRemotePort*: DWORD + State*: MIB_TCP_STATE + dwOwningPid*: DWORD + dwOffloadState*: TCP_CONNECTION_OFFLOAD_STATE + PMIB_TCP6ROW2* = ptr MIB_TCP6ROW2 + MIB_TCP6TABLE2* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCP6ROW2] + PMIB_TCP6TABLE2* = ptr MIB_TCP6TABLE2 + MIB_TCPROW2* {.pure.} = object + dwState*: DWORD + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwRemoteAddr*: DWORD + dwRemotePort*: DWORD + dwOwningPid*: DWORD + dwOffloadState*: TCP_CONNECTION_OFFLOAD_STATE + PMIB_TCPROW2* = ptr MIB_TCPROW2 + MIB_TCPTABLE2* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCPROW2] + PMIB_TCPTABLE2* = ptr MIB_TCPTABLE2 + MIB_OPAQUE_QUERY* {.pure.} = object + dwVarId*: DWORD + rgdwVarIndex*: array[ANY_SIZE, DWORD] + PMIB_OPAQUE_QUERY* = ptr MIB_OPAQUE_QUERY + MIB_IFNUMBER* {.pure.} = object + dwValue*: DWORD + PMIB_IFNUMBER* = ptr MIB_IFNUMBER +const + MAXLEN_PHYSADDR* = 8 + MAXLEN_IFDESCR* = 256 +type + MIB_IFROW* {.pure.} = object + wszName*: array[MAX_INTERFACE_NAME_LEN, WCHAR] + dwIndex*: DWORD + dwType*: DWORD + dwMtu*: DWORD + dwSpeed*: DWORD + dwPhysAddrLen*: DWORD + bPhysAddr*: array[MAXLEN_PHYSADDR, BYTE] + dwAdminStatus*: DWORD + dwOperStatus*: DWORD + dwLastChange*: DWORD + dwInOctets*: DWORD + dwInUcastPkts*: DWORD + dwInNUcastPkts*: DWORD + dwInDiscards*: DWORD + dwInErrors*: DWORD + dwInUnknownProtos*: DWORD + dwOutOctets*: DWORD + dwOutUcastPkts*: DWORD + dwOutNUcastPkts*: DWORD + dwOutDiscards*: DWORD + dwOutErrors*: DWORD + dwOutQLen*: DWORD + dwDescrLen*: DWORD + bDescr*: array[MAXLEN_IFDESCR, BYTE] + PMIB_IFROW* = ptr MIB_IFROW + MIB_IFTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IFROW] + PMIB_IFTABLE* = ptr MIB_IFTABLE + MIBICMPSTATS* {.pure.} = object + dwMsgs*: DWORD + dwErrors*: DWORD + dwDestUnreachs*: DWORD + dwTimeExcds*: DWORD + dwParmProbs*: DWORD + dwSrcQuenchs*: DWORD + dwRedirects*: DWORD + dwEchos*: DWORD + dwEchoReps*: DWORD + dwTimestamps*: DWORD + dwTimestampReps*: DWORD + dwAddrMasks*: DWORD + dwAddrMaskReps*: DWORD + PMIBICMPSTATS* = ptr MIBICMPSTATS + MIBICMPINFO* {.pure.} = object + icmpInStats*: MIBICMPSTATS + icmpOutStats*: MIBICMPSTATS + MIB_ICMP* {.pure.} = object + stats*: MIBICMPINFO + PMIB_ICMP* = ptr MIB_ICMP + MIBICMPSTATS_EX* {.pure.} = object + dwMsgs*: DWORD + dwErrors*: DWORD + rgdwTypeCount*: array[256, DWORD] + PMIBICMPSTATS_EX* = ptr MIBICMPSTATS_EX + MIB_ICMP_EX* {.pure.} = object + icmpInStats*: MIBICMPSTATS_EX + icmpOutStats*: MIBICMPSTATS_EX + PMIB_ICMP_EX* = ptr MIB_ICMP_EX + MIB_UDPSTATS* {.pure.} = object + dwInDatagrams*: DWORD + dwNoPorts*: DWORD + dwInErrors*: DWORD + dwOutDatagrams*: DWORD + dwNumAddrs*: DWORD + PMIB_UDPSTATS* = ptr MIB_UDPSTATS + MIB_UDPROW* {.pure.} = object + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + PMIB_UDPROW* = ptr MIB_UDPROW + MIB_UDPROW_BASIC* = MIB_UDPROW + PMIB_UDPROW_BASIC* = ptr MIB_UDPROW + MIB_UDPROW_OWNER_PID* {.pure.} = object + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwOwningPid*: DWORD + PMIB_UDPROW_OWNER_PID* = ptr MIB_UDPROW_OWNER_PID + MIB_UDPROW_OWNER_MODULE_UNION1_STRUCT1* {.pure.} = object + SpecificPortBind* {.bitsize:1.}: DWORD + MIB_UDPROW_OWNER_MODULE_UNION1* {.pure, union.} = object + struct1*: MIB_UDPROW_OWNER_MODULE_UNION1_STRUCT1 + dwFlags*: DWORD +const + TCPIP_OWNING_MODULE_SIZE* = 16 +type + MIB_UDPROW_OWNER_MODULE* {.pure.} = object + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwOwningPid*: DWORD + liCreateTimestamp*: LARGE_INTEGER + union1*: MIB_UDPROW_OWNER_MODULE_UNION1 + OwningModuleInfo*: array[TCPIP_OWNING_MODULE_SIZE, ULONGLONG] + PMIB_UDPROW_OWNER_MODULE* = ptr MIB_UDPROW_OWNER_MODULE + MIB_UDP6ROW_OWNER_PID* {.pure.} = object + ucLocalAddr*: array[16, UCHAR] + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + dwOwningPid*: DWORD + PMIB_UDP6ROW_OWNER_PID* = ptr MIB_UDP6ROW_OWNER_PID + MIB_UDP6ROW_OWNER_MODULE_UNION1_STRUCT1* {.pure.} = object + SpecificPortBind* {.bitsize:1.}: DWORD + MIB_UDP6ROW_OWNER_MODULE_UNION1* {.pure, union.} = object + struct1*: MIB_UDP6ROW_OWNER_MODULE_UNION1_STRUCT1 + dwFlags*: DWORD + MIB_UDP6ROW_OWNER_MODULE* {.pure.} = object + ucLocalAddr*: array[16, UCHAR] + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + dwOwningPid*: DWORD + liCreateTimestamp*: LARGE_INTEGER + union1*: MIB_UDP6ROW_OWNER_MODULE_UNION1 + OwningModuleInfo*: array[TCPIP_OWNING_MODULE_SIZE, ULONGLONG] + PMIB_UDP6ROW_OWNER_MODULE* = ptr MIB_UDP6ROW_OWNER_MODULE + MIB_UDPTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDPROW] + PMIB_UDPTABLE* = ptr MIB_UDPTABLE + MIB_UDPTABLE_BASIC* = MIB_UDPTABLE + PMIB_UDPTABLE_BASIC* = ptr MIB_UDPTABLE + MIB_UDPTABLE_OWNER_PID* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDPROW_OWNER_PID] + PMIB_UDPTABLE_OWNER_PID* = ptr MIB_UDPTABLE_OWNER_PID + MIB_UDPTABLE_OWNER_MODULE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDPROW_OWNER_MODULE] + PMIB_UDPTABLE_OWNER_MODULE* = ptr MIB_UDPTABLE_OWNER_MODULE + MIB_UDP6TABLE_OWNER_PID* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDP6ROW_OWNER_PID] + PMIB_UDP6TABLE_OWNER_PID* = ptr MIB_UDP6TABLE_OWNER_PID + MIB_UDP6TABLE_OWNER_MODULE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_UDP6ROW_OWNER_MODULE] + PMIB_UDP6TABLE_OWNER_MODULE* = ptr MIB_UDP6TABLE_OWNER_MODULE + MIB_TCPSTATS* {.pure.} = object + dwRtoAlgorithm*: DWORD + dwRtoMin*: DWORD + dwRtoMax*: DWORD + dwMaxConn*: DWORD + dwActiveOpens*: DWORD + dwPassiveOpens*: DWORD + dwAttemptFails*: DWORD + dwEstabResets*: DWORD + dwCurrEstab*: DWORD + dwInSegs*: DWORD + dwOutSegs*: DWORD + dwRetransSegs*: DWORD + dwInErrs*: DWORD + dwOutRsts*: DWORD + dwNumConns*: DWORD + PMIB_TCPSTATS* = ptr MIB_TCPSTATS + MIB_TCPROW* {.pure.} = object + dwState*: DWORD + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwRemoteAddr*: DWORD + dwRemotePort*: DWORD + PMIB_TCPROW* = ptr MIB_TCPROW + MIB_TCPROW_BASIC* = MIB_TCPROW + PMIB_TCPROW_BASIC* = ptr MIB_TCPROW + MIB_TCPROW_OWNER_PID* {.pure.} = object + dwState*: DWORD + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwRemoteAddr*: DWORD + dwRemotePort*: DWORD + dwOwningPid*: DWORD + PMIB_TCPROW_OWNER_PID* = ptr MIB_TCPROW_OWNER_PID + MIB_TCPROW_OWNER_MODULE* {.pure.} = object + dwState*: DWORD + dwLocalAddr*: DWORD + dwLocalPort*: DWORD + dwRemoteAddr*: DWORD + dwRemotePort*: DWORD + dwOwningPid*: DWORD + liCreateTimestamp*: LARGE_INTEGER + OwningModuleInfo*: array[TCPIP_OWNING_MODULE_SIZE, ULONGLONG] + PMIB_TCPROW_OWNER_MODULE* = ptr MIB_TCPROW_OWNER_MODULE + MIB_TCP6ROW_OWNER_PID* {.pure.} = object + ucLocalAddr*: array[16, UCHAR] + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + ucRemoteAddr*: array[16, UCHAR] + dwRemoteScopeId*: DWORD + dwRemotePort*: DWORD + dwState*: DWORD + dwOwningPid*: DWORD + PMIB_TCP6ROW_OWNER_PID* = ptr MIB_TCP6ROW_OWNER_PID + MIB_TCP6ROW_OWNER_MODULE* {.pure.} = object + ucLocalAddr*: array[16, UCHAR] + dwLocalScopeId*: DWORD + dwLocalPort*: DWORD + ucRemoteAddr*: array[16, UCHAR] + dwRemoteScopeId*: DWORD + dwRemotePort*: DWORD + dwState*: DWORD + dwOwningPid*: DWORD + liCreateTimestamp*: LARGE_INTEGER + OwningModuleInfo*: array[TCPIP_OWNING_MODULE_SIZE, ULONGLONG] + PMIB_TCP6ROW_OWNER_MODULE* = ptr MIB_TCP6ROW_OWNER_MODULE + MIB_TCPTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCPROW] + PMIB_TCPTABLE* = ptr MIB_TCPTABLE + MIB_TCPTABLE_BASIC* = MIB_TCPTABLE + PMIB_TCPTABLE_BASIC* = ptr MIB_TCPTABLE + MIB_TCPTABLE_OWNER_PID* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCPROW_OWNER_PID] + PMIB_TCPTABLE_OWNER_PID* = ptr MIB_TCPTABLE_OWNER_PID + MIB_TCPTABLE_OWNER_MODULE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCPROW_OWNER_MODULE] + PMIB_TCPTABLE_OWNER_MODULE* = ptr MIB_TCPTABLE_OWNER_MODULE + MIB_TCP6TABLE_OWNER_PID* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCP6ROW_OWNER_PID] + PMIB_TCP6TABLE_OWNER_PID* = ptr MIB_TCP6TABLE_OWNER_PID + MIB_TCP6TABLE_OWNER_MODULE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_TCP6ROW_OWNER_MODULE] + PMIB_TCP6TABLE_OWNER_MODULE* = ptr MIB_TCP6TABLE_OWNER_MODULE + MIB_IPSTATS* {.pure.} = object + dwForwarding*: DWORD + dwDefaultTTL*: DWORD + dwInReceives*: DWORD + dwInHdrErrors*: DWORD + dwInAddrErrors*: DWORD + dwForwDatagrams*: DWORD + dwInUnknownProtos*: DWORD + dwInDiscards*: DWORD + dwInDelivers*: DWORD + dwOutRequests*: DWORD + dwRoutingDiscards*: DWORD + dwOutDiscards*: DWORD + dwOutNoRoutes*: DWORD + dwReasmTimeout*: DWORD + dwReasmReqds*: DWORD + dwReasmOks*: DWORD + dwReasmFails*: DWORD + dwFragOks*: DWORD + dwFragFails*: DWORD + dwFragCreates*: DWORD + dwNumIf*: DWORD + dwNumAddr*: DWORD + dwNumRoutes*: DWORD + PMIB_IPSTATS* = ptr MIB_IPSTATS + MIB_IPADDRROW* {.pure.} = object + dwAddr*: DWORD + dwIndex*: DWORD + dwMask*: DWORD + dwBCastAddr*: DWORD + dwReasmSize*: DWORD + unused1*: uint16 + wType*: uint16 + PMIB_IPADDRROW* = ptr MIB_IPADDRROW + MIB_IPADDRTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPADDRROW] + PMIB_IPADDRTABLE* = ptr MIB_IPADDRTABLE + MIB_IPFORWARDNUMBER* {.pure.} = object + dwValue*: DWORD + PMIB_IPFORWARDNUMBER* = ptr MIB_IPFORWARDNUMBER + MIB_IPFORWARDROW* {.pure.} = object + dwForwardDest*: DWORD + dwForwardMask*: DWORD + dwForwardPolicy*: DWORD + dwForwardNextHop*: DWORD + dwForwardIfIndex*: DWORD + dwForwardType*: DWORD + dwForwardProto*: DWORD + dwForwardAge*: DWORD + dwForwardNextHopAS*: DWORD + dwForwardMetric1*: DWORD + dwForwardMetric2*: DWORD + dwForwardMetric3*: DWORD + dwForwardMetric4*: DWORD + dwForwardMetric5*: DWORD + PMIB_IPFORWARDROW* = ptr MIB_IPFORWARDROW + MIB_IPFORWARDTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPFORWARDROW] + PMIB_IPFORWARDTABLE* = ptr MIB_IPFORWARDTABLE + MIB_IPNETROW* {.pure.} = object + dwIndex*: DWORD + dwPhysAddrLen*: DWORD + bPhysAddr*: array[MAXLEN_PHYSADDR, BYTE] + dwAddr*: DWORD + dwType*: DWORD + PMIB_IPNETROW* = ptr MIB_IPNETROW + MIB_IPNETTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPNETROW] + PMIB_IPNETTABLE* = ptr MIB_IPNETTABLE + MIB_IPMCAST_OIF* {.pure.} = object + dwOutIfIndex*: DWORD + dwNextHopAddr*: DWORD + dwReserved*: DWORD + dwReserved1*: DWORD + PMIB_IPMCAST_OIF* = ptr MIB_IPMCAST_OIF + MIB_IPMCAST_MFE* {.pure.} = object + dwGroup*: DWORD + dwSource*: DWORD + dwSrcMask*: DWORD + dwUpStrmNgbr*: DWORD + dwInIfIndex*: DWORD + dwInIfProtocol*: DWORD + dwRouteProtocol*: DWORD + dwRouteNetwork*: DWORD + dwRouteMask*: DWORD + ulUpTime*: ULONG + ulExpiryTime*: ULONG + ulTimeOut*: ULONG + ulNumOutIf*: ULONG + fFlags*: DWORD + dwReserved*: DWORD + rgmioOutInfo*: array[ANY_SIZE, MIB_IPMCAST_OIF] + PMIB_IPMCAST_MFE* = ptr MIB_IPMCAST_MFE + MIB_MFE_TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPMCAST_MFE] + PMIB_MFE_TABLE* = ptr MIB_MFE_TABLE + MIB_IPMCAST_OIF_STATS* {.pure.} = object + dwOutIfIndex*: DWORD + dwNextHopAddr*: DWORD + dwDialContext*: DWORD + ulTtlTooLow*: ULONG + ulFragNeeded*: ULONG + ulOutPackets*: ULONG + ulOutDiscards*: ULONG + PMIB_IPMCAST_OIF_STATS* = ptr MIB_IPMCAST_OIF_STATS + MIB_IPMCAST_MFE_STATS* {.pure.} = object + dwGroup*: DWORD + dwSource*: DWORD + dwSrcMask*: DWORD + dwUpStrmNgbr*: DWORD + dwInIfIndex*: DWORD + dwInIfProtocol*: DWORD + dwRouteProtocol*: DWORD + dwRouteNetwork*: DWORD + dwRouteMask*: DWORD + ulUpTime*: ULONG + ulExpiryTime*: ULONG + ulNumOutIf*: ULONG + ulInPkts*: ULONG + ulInOctets*: ULONG + ulPktsDifferentIf*: ULONG + ulQueueOverflow*: ULONG + rgmiosOutStats*: array[ANY_SIZE, MIB_IPMCAST_OIF_STATS] + PMIB_IPMCAST_MFE_STATS* = ptr MIB_IPMCAST_MFE_STATS + MIB_MFE_STATS_TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPMCAST_MFE_STATS] + PMIB_MFE_STATS_TABLE* = ptr MIB_MFE_STATS_TABLE + MIB_IPMCAST_MFE_STATS_EX* {.pure.} = object + dwGroup*: DWORD + dwSource*: DWORD + dwSrcMask*: DWORD + dwUpStrmNgbr*: DWORD + dwInIfIndex*: DWORD + dwInIfProtocol*: DWORD + dwRouteProtocol*: DWORD + dwRouteNetwork*: DWORD + dwRouteMask*: DWORD + ulUpTime*: ULONG + ulExpiryTime*: ULONG + ulNumOutIf*: ULONG + ulInPkts*: ULONG + ulInOctets*: ULONG + ulPktsDifferentIf*: ULONG + ulQueueOverflow*: ULONG + ulUninitMfe*: ULONG + ulNegativeMfe*: ULONG + ulInDiscards*: ULONG + ulInHdrErrors*: ULONG + ulTotalOutPackets*: ULONG + rgmiosOutStats*: array[ANY_SIZE, MIB_IPMCAST_OIF_STATS] + PMIB_IPMCAST_MFE_STATS_EX* = ptr MIB_IPMCAST_MFE_STATS_EX + MIB_MFE_STATS_TABLE_EX* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPMCAST_MFE_STATS_EX] + PMIB_MFE_STATS_TABLE_EX* = ptr MIB_MFE_STATS_TABLE_EX + MIB_IPMCAST_GLOBAL* {.pure.} = object + dwEnable*: DWORD + PMIB_IPMCAST_GLOBAL* = ptr MIB_IPMCAST_GLOBAL + MIB_IPMCAST_IF_ENTRY* {.pure.} = object + dwIfIndex*: DWORD + dwTtl*: DWORD + dwProtocol*: DWORD + dwRateLimit*: DWORD + ulInMcastOctets*: ULONG + ulOutMcastOctets*: ULONG + PMIB_IPMCAST_IF_ENTRY* = ptr MIB_IPMCAST_IF_ENTRY + MIB_IPMCAST_IF_TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPMCAST_IF_ENTRY] + PMIB_IPMCAST_IF_TABLE* = ptr MIB_IPMCAST_IF_TABLE + MIB_IPMCAST_BOUNDARY* {.pure.} = object + dwIfIndex*: DWORD + dwGroupAddress*: DWORD + dwGroupMask*: DWORD + dwStatus*: DWORD + PMIB_IPMCAST_BOUNDARY* = ptr MIB_IPMCAST_BOUNDARY + MIB_IPMCAST_BOUNDARY_TABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPMCAST_BOUNDARY] + PMIB_IPMCAST_BOUNDARY_TABLE* = ptr MIB_IPMCAST_BOUNDARY_TABLE + MIB_BOUNDARYROW* {.pure.} = object + dwGroupAddress*: DWORD + dwGroupMask*: DWORD + PMIB_BOUNDARYROW* = ptr MIB_BOUNDARYROW + MIB_MCAST_LIMIT_ROW* {.pure.} = object + dwTtl*: DWORD + dwRateLimit*: DWORD + PMIB_MCAST_LIMIT_ROW* = ptr MIB_MCAST_LIMIT_ROW +const + MAX_SCOPE_NAME_LEN* = 255 +type + SCOPE_NAME_BUFFER* = array[MAX_SCOPE_NAME_LEN+1, SN_CHAR] + SCOPE_NAME* = ptr SN_CHAR + MIB_IPMCAST_SCOPE* {.pure.} = object + dwGroupAddress*: DWORD + dwGroupMask*: DWORD + snNameBuffer*: SCOPE_NAME_BUFFER + dwStatus*: DWORD + PMIB_IPMCAST_SCOPE* = ptr MIB_IPMCAST_SCOPE + MIB_IPDESTROW* {.pure.} = object + ForwardRow*: MIB_IPFORWARDROW + dwForwardPreference*: DWORD + dwForwardViewSet*: DWORD + PMIB_IPDESTROW* = ptr MIB_IPDESTROW + MIB_IPDESTTABLE* {.pure.} = object + dwNumEntries*: DWORD + table*: array[ANY_SIZE, MIB_IPDESTROW] + PMIB_IPDESTTABLE* = ptr MIB_IPDESTTABLE + MIB_BEST_IF* {.pure.} = object + dwDestAddr*: DWORD + dwIfIndex*: DWORD + PMIB_BEST_IF* = ptr MIB_BEST_IF + MIB_PROXYARP* {.pure.} = object + dwAddress*: DWORD + dwMask*: DWORD + dwIfIndex*: DWORD + PMIB_PROXYARP* = ptr MIB_PROXYARP + MIB_IFSTATUS* {.pure.} = object + dwIfIndex*: DWORD + dwAdminStatus*: DWORD + dwOperationalStatus*: DWORD + bMHbeatActive*: WINBOOL + bMHbeatAlive*: WINBOOL + PMIB_IFSTATUS* = ptr MIB_IFSTATUS + MIB_ROUTESTATE* {.pure.} = object + bRoutesSetToStack*: WINBOOL + PMIB_ROUTESTATE* = ptr MIB_ROUTESTATE + MIB_OPAQUE_INFO_UNION1* {.pure, union.} = object + ullAlign*: ULONGLONG + rgbyData*: array[1, BYTE] + MIB_OPAQUE_INFO* {.pure.} = object + dwId*: DWORD + union1*: MIB_OPAQUE_INFO_UNION1 + PMIB_OPAQUE_INFO* = ptr MIB_OPAQUE_INFO + TCPIP_OWNER_MODULE_BASIC_INFO* {.pure.} = object + pModuleName*: PWCHAR + pModulePath*: PWCHAR + PTCPIP_OWNER_MODULE_BASIC_INFO* = ptr TCPIP_OWNER_MODULE_BASIC_INFO + IP_OPTION_INFORMATION* {.pure.} = object + Ttl*: UCHAR + Tos*: UCHAR + Flags*: UCHAR + OptionsSize*: UCHAR + OptionsData*: PUCHAR + PIP_OPTION_INFORMATION* = ptr IP_OPTION_INFORMATION + ICMP_ECHO_REPLY* {.pure.} = object + Address*: IPAddr + Status*: ULONG + RoundTripTime*: ULONG + DataSize*: USHORT + Reserved*: USHORT + Data*: PVOID + Options*: IP_OPTION_INFORMATION + PICMP_ECHO_REPLY* = ptr ICMP_ECHO_REPLY + ARP_SEND_REPLY* {.pure.} = object + DestAddress*: IPAddr + SrcAddress*: IPAddr + PARP_SEND_REPLY* = ptr ARP_SEND_REPLY + TCP_RESERVE_PORT_RANGE* {.pure.} = object + UpperRange*: USHORT + LowerRange*: USHORT + PTCP_RESERVE_PORT_RANGE* = ptr TCP_RESERVE_PORT_RANGE +const + MAX_ADAPTER_NAME* = 128 +type + IP_ADAPTER_INDEX_MAP* {.pure.} = object + Index*: ULONG + Name*: array[MAX_ADAPTER_NAME, WCHAR] + PIP_ADAPTER_INDEX_MAP* = ptr IP_ADAPTER_INDEX_MAP + IP_INTERFACE_INFO* {.pure.} = object + NumAdapters*: LONG + Adapter*: array[1, IP_ADAPTER_INDEX_MAP] + PIP_INTERFACE_INFO* = ptr IP_INTERFACE_INFO + IP_UNIDIRECTIONAL_ADAPTER_ADDRESS* {.pure.} = object + NumAdapters*: ULONG + Address*: array[1, IPAddr] + PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS* = ptr IP_UNIDIRECTIONAL_ADAPTER_ADDRESS + IP_ADAPTER_ORDER_MAP* {.pure.} = object + NumAdapters*: ULONG + AdapterOrder*: array[1, ULONG] + PIP_ADAPTER_ORDER_MAP* = ptr IP_ADAPTER_ORDER_MAP + IP_MCAST_COUNTER_INFO* {.pure.} = object + InMcastOctets*: ULONG64 + OutMcastOctets*: ULONG64 + InMcastPkts*: ULONG64 + OutMcastPkts*: ULONG64 + PIP_MCAST_COUNTER_INFO* = ptr IP_MCAST_COUNTER_INFO + IPV6_ADDRESS_EX* {.pure.} = object + sin6_port*: USHORT + sin6_flowinfo*: ULONG + sin6_addr*: array[8, USHORT] + sin6_scope_id*: ULONG + PIPV6_ADDRESS_EX* = ptr IPV6_ADDRESS_EX + NET_IF_COMPARTMENT_ID* = UINT32 + PNET_IF_COMPARTMENT_ID* = ptr UINT32 + NET_IFTYPE* = UINT16 + PNET_IFTYPE* = ptr UINT16 + IF_INDEX* = NET_IFINDEX + PIF_INDEX* = ptr NET_IFINDEX + NET_IF_NETWORK_GUID* = GUID + NET_LUID_Info* {.pure.} = object + Reserved* {.bitsize:24.}: ULONG64 + NetLuidIndex* {.bitsize:24.}: ULONG64 + IfType* {.bitsize:16.}: ULONG64 + NET_LUID* {.pure, union.} = object + Value*: ULONG64 + Info*: NET_LUID_Info + PNET_LUID* = ptr NET_LUID + IF_LUID* = NET_LUID + PIF_LUID* = ptr NET_LUID +const + IF_MAX_STRING_SIZE* = 256 +type + IF_COUNTED_STRING_LH* {.pure.} = object + Length*: USHORT + String*: array[IF_MAX_STRING_SIZE + 1, WCHAR] + PIF_COUNTED_STRING_LH* = ptr IF_COUNTED_STRING_LH + IF_COUNTED_STRING* = IF_COUNTED_STRING_LH + PIF_COUNTED_STRING* = ptr IF_COUNTED_STRING +const + IF_MAX_PHYS_ADDRESS_LENGTH* = 32 +type + IF_PHYSICAL_ADDRESS_LH* {.pure.} = object + Length*: USHORT + Address*: array[IF_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + PIF_PHYSICAL_ADDRESS_LH* = ptr IF_PHYSICAL_ADDRESS_LH + IF_PHYSICAL_ADDRESS* = IF_PHYSICAL_ADDRESS_LH + PIF_PHYSICAL_ADDRESS* = ptr IF_PHYSICAL_ADDRESS + IP_ADDRESS_STRING* {.pure.} = object + String*: array[4*4, char] + PIP_ADDRESS_STRING* = ptr IP_ADDRESS_STRING + IP_MASK_STRING* = IP_ADDRESS_STRING + PIP_MASK_STRING* = ptr IP_ADDRESS_STRING + IP_ADDR_STRING* {.pure.} = object + Next*: ptr IP_ADDR_STRING + IpAddress*: IP_ADDRESS_STRING + IpMask*: IP_MASK_STRING + Context*: DWORD + PIP_ADDR_STRING* = ptr IP_ADDR_STRING +const + MAX_ADAPTER_NAME_LENGTH* = 256 + MAX_ADAPTER_DESCRIPTION_LENGTH* = 128 + MAX_ADAPTER_ADDRESS_LENGTH* = 8 +type + IP_ADAPTER_INFO* {.pure.} = object + Next*: ptr IP_ADAPTER_INFO + ComboIndex*: DWORD + AdapterName*: array[MAX_ADAPTER_NAME_LENGTH + 4, char] + Description*: array[MAX_ADAPTER_DESCRIPTION_LENGTH + 4, char] + AddressLength*: UINT + Address*: array[MAX_ADAPTER_ADDRESS_LENGTH, BYTE] + Index*: DWORD + Type*: UINT + DhcpEnabled*: UINT + CurrentIpAddress*: PIP_ADDR_STRING + IpAddressList*: IP_ADDR_STRING + GatewayList*: IP_ADDR_STRING + DhcpServer*: IP_ADDR_STRING + HaveWins*: WINBOOL + PrimaryWinsServer*: IP_ADDR_STRING + SecondaryWinsServer*: IP_ADDR_STRING + LeaseObtained*: int + LeaseExpires*: int + PIP_ADAPTER_INFO* = ptr IP_ADAPTER_INFO + IP_PREFIX_ORIGIN* = NL_PREFIX_ORIGIN + IP_SUFFIX_ORIGIN* = NL_SUFFIX_ORIGIN + IP_DAD_STATE* = NL_DAD_STATE + IP_ADAPTER_UNICAST_ADDRESS_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Flags*: DWORD + IP_ADAPTER_UNICAST_ADDRESS_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_UNICAST_ADDRESS_XP_UNION1_STRUCT1 + IP_ADAPTER_UNICAST_ADDRESS_XP* {.pure.} = object + union1*: IP_ADAPTER_UNICAST_ADDRESS_XP_UNION1 + Next*: ptr IP_ADAPTER_UNICAST_ADDRESS_XP + Address*: SOCKET_ADDRESS + PrefixOrigin*: IP_PREFIX_ORIGIN + SuffixOrigin*: IP_SUFFIX_ORIGIN + DadState*: IP_DAD_STATE + ValidLifetime*: ULONG + PreferredLifetime*: ULONG + LeaseLifetime*: ULONG + PIP_ADAPTER_UNICAST_ADDRESS_XP* = ptr IP_ADAPTER_UNICAST_ADDRESS_XP + IP_ADAPTER_UNICAST_ADDRESS_LH_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Flags*: DWORD + IP_ADAPTER_UNICAST_ADDRESS_LH_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_UNICAST_ADDRESS_LH_UNION1_STRUCT1 + IP_ADAPTER_UNICAST_ADDRESS_LH* {.pure.} = object + union1*: IP_ADAPTER_UNICAST_ADDRESS_LH_UNION1 + Next*: ptr IP_ADAPTER_UNICAST_ADDRESS_LH + Address*: SOCKET_ADDRESS + PrefixOrigin*: IP_PREFIX_ORIGIN + SuffixOrigin*: IP_SUFFIX_ORIGIN + DadState*: IP_DAD_STATE + ValidLifetime*: ULONG + PreferredLifetime*: ULONG + LeaseLifetime*: ULONG + OnLinkPrefixLength*: UINT8 + PIP_ADAPTER_UNICAST_ADDRESS_LH* = ptr IP_ADAPTER_UNICAST_ADDRESS_LH + IP_ADAPTER_UNICAST_ADDRESS* = IP_ADAPTER_UNICAST_ADDRESS_XP + PIP_ADAPTER_UNICAST_ADDRESS* = ptr IP_ADAPTER_UNICAST_ADDRESS_XP + IP_ADAPTER_ANYCAST_ADDRESS_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Flags*: DWORD + IP_ADAPTER_ANYCAST_ADDRESS_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_ANYCAST_ADDRESS_XP_UNION1_STRUCT1 + IP_ADAPTER_ANYCAST_ADDRESS_XP* {.pure.} = object + union1*: IP_ADAPTER_ANYCAST_ADDRESS_XP_UNION1 + Next*: ptr IP_ADAPTER_ANYCAST_ADDRESS_XP + Address*: SOCKET_ADDRESS + PIP_ADAPTER_ANYCAST_ADDRESS_XP* = ptr IP_ADAPTER_ANYCAST_ADDRESS_XP + IP_ADAPTER_ANYCAST_ADDRESS* = IP_ADAPTER_ANYCAST_ADDRESS_XP + PIP_ADAPTER_ANYCAST_ADDRESS* = ptr IP_ADAPTER_ANYCAST_ADDRESS_XP + IP_ADAPTER_MULTICAST_ADDRESS_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Flags*: DWORD + IP_ADAPTER_MULTICAST_ADDRESS_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_MULTICAST_ADDRESS_XP_UNION1_STRUCT1 + IP_ADAPTER_MULTICAST_ADDRESS_XP* {.pure.} = object + union1*: IP_ADAPTER_MULTICAST_ADDRESS_XP_UNION1 + Next*: ptr IP_ADAPTER_MULTICAST_ADDRESS_XP + Address*: SOCKET_ADDRESS + PIP_ADAPTER_MULTICAST_ADDRESS_XP* = ptr IP_ADAPTER_MULTICAST_ADDRESS_XP + IP_ADAPTER_MULTICAST_ADDRESS* = IP_ADAPTER_MULTICAST_ADDRESS_XP + PIP_ADAPTER_MULTICAST_ADDRESS* = ptr IP_ADAPTER_MULTICAST_ADDRESS_XP + IP_ADAPTER_DNS_SERVER_ADDRESS_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Reserved*: DWORD + IP_ADAPTER_DNS_SERVER_ADDRESS_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_DNS_SERVER_ADDRESS_XP_UNION1_STRUCT1 + IP_ADAPTER_DNS_SERVER_ADDRESS_XP* {.pure.} = object + union1*: IP_ADAPTER_DNS_SERVER_ADDRESS_XP_UNION1 + Next*: ptr IP_ADAPTER_DNS_SERVER_ADDRESS_XP + Address*: SOCKET_ADDRESS + PIP_ADAPTER_DNS_SERVER_ADDRESS_XP* = ptr IP_ADAPTER_DNS_SERVER_ADDRESS_XP + IP_ADAPTER_DNS_SERVER_ADDRESS* = IP_ADAPTER_DNS_SERVER_ADDRESS_XP + PIP_ADAPTER_DNS_SERVER_ADDRESS* = ptr IP_ADAPTER_DNS_SERVER_ADDRESS_XP + IP_ADAPTER_PREFIX_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Flags*: DWORD + IP_ADAPTER_PREFIX_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_PREFIX_XP_UNION1_STRUCT1 + IP_ADAPTER_PREFIX_XP* {.pure.} = object + union1*: IP_ADAPTER_PREFIX_XP_UNION1 + Next*: ptr IP_ADAPTER_PREFIX_XP + Address*: SOCKET_ADDRESS + PrefixLength*: ULONG + PIP_ADAPTER_PREFIX_XP* = ptr IP_ADAPTER_PREFIX_XP + IP_ADAPTER_PREFIX* = IP_ADAPTER_PREFIX_XP + PIP_ADAPTER_PREFIX* = ptr IP_ADAPTER_PREFIX_XP + IP_ADAPTER_WINS_SERVER_ADDRESS_LH_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Reserved*: DWORD + IP_ADAPTER_WINS_SERVER_ADDRESS_LH_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_WINS_SERVER_ADDRESS_LH_UNION1_STRUCT1 + IP_ADAPTER_WINS_SERVER_ADDRESS_LH* {.pure.} = object + union1*: IP_ADAPTER_WINS_SERVER_ADDRESS_LH_UNION1 + Next*: ptr IP_ADAPTER_WINS_SERVER_ADDRESS_LH + Address*: SOCKET_ADDRESS + PIP_ADAPTER_WINS_SERVER_ADDRESS_LH* = ptr IP_ADAPTER_WINS_SERVER_ADDRESS_LH + IP_ADAPTER_WINS_SERVER_ADDRESS* = IP_ADAPTER_WINS_SERVER_ADDRESS_LH + PIP_ADAPTER_WINS_SERVER_ADDRESS* = ptr IP_ADAPTER_WINS_SERVER_ADDRESS_LH + IP_ADAPTER_GATEWAY_ADDRESS_LH_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + Reserved*: DWORD + IP_ADAPTER_GATEWAY_ADDRESS_LH_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_GATEWAY_ADDRESS_LH_UNION1_STRUCT1 + IP_ADAPTER_GATEWAY_ADDRESS_LH* {.pure.} = object + union1*: IP_ADAPTER_GATEWAY_ADDRESS_LH_UNION1 + Next*: ptr IP_ADAPTER_GATEWAY_ADDRESS_LH + Address*: SOCKET_ADDRESS + PIP_ADAPTER_GATEWAY_ADDRESS_LH* = ptr IP_ADAPTER_GATEWAY_ADDRESS_LH + IP_ADAPTER_GATEWAY_ADDRESS* = IP_ADAPTER_GATEWAY_ADDRESS_LH + PIP_ADAPTER_GATEWAY_ADDRESS* = ptr IP_ADAPTER_GATEWAY_ADDRESS_LH +const + MAX_DNS_SUFFIX_STRING_LENGTH* = 256 +type + IP_ADAPTER_DNS_SUFFIX* {.pure.} = object + Next*: ptr IP_ADAPTER_DNS_SUFFIX + String*: array[MAX_DNS_SUFFIX_STRING_LENGTH, WCHAR] + PIP_ADAPTER_DNS_SUFFIX* = ptr IP_ADAPTER_DNS_SUFFIX + IP_ADAPTER_ADDRESSES_LH_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + IfIndex*: IF_INDEX + IP_ADAPTER_ADDRESSES_LH_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_ADDRESSES_LH_UNION1_STRUCT1 + IP_ADAPTER_ADDRESSES_LH_UNION2_STRUCT1* {.pure.} = object + DdnsEnabled* {.bitsize:1.}: ULONG + RegisterAdapterSuffix* {.bitsize:1.}: ULONG + Dhcpv4Enabled* {.bitsize:1.}: ULONG + ReceiveOnly* {.bitsize:1.}: ULONG + NoMulticast* {.bitsize:1.}: ULONG + Ipv6OtherStatefulConfig* {.bitsize:1.}: ULONG + NetbiosOverTcpipEnabled* {.bitsize:1.}: ULONG + Ipv4Enabled* {.bitsize:1.}: ULONG + Ipv6Enabled* {.bitsize:1.}: ULONG + Ipv6ManagedAddressConfigurationSupported* {.bitsize:1.}: ULONG + IP_ADAPTER_ADDRESSES_LH_UNION2* {.pure, union.} = object + Flags*: ULONG + struct1*: IP_ADAPTER_ADDRESSES_LH_UNION2_STRUCT1 +const + MAX_DHCPV6_DUID_LENGTH* = 130 +type + IP_ADAPTER_ADDRESSES_LH* {.pure.} = object + union1*: IP_ADAPTER_ADDRESSES_LH_UNION1 + Next*: ptr IP_ADAPTER_ADDRESSES_LH + AdapterName*: PCHAR + FirstUnicastAddress*: PIP_ADAPTER_UNICAST_ADDRESS_LH + FirstAnycastAddress*: PIP_ADAPTER_ANYCAST_ADDRESS_XP + FirstMulticastAddress*: PIP_ADAPTER_MULTICAST_ADDRESS_XP + FirstDnsServerAddress*: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP + DnsSuffix*: PWCHAR + Description*: PWCHAR + FriendlyName*: PWCHAR + PhysicalAddress*: array[MAX_ADAPTER_ADDRESS_LENGTH, BYTE] + PhysicalAddressLength*: ULONG + union2*: IP_ADAPTER_ADDRESSES_LH_UNION2 + Mtu*: ULONG + IfType*: IFTYPE + OperStatus*: IF_OPER_STATUS + Ipv6IfIndex*: IF_INDEX + ZoneIndices*: array[16, ULONG] + FirstPrefix*: PIP_ADAPTER_PREFIX_XP + TransmitLinkSpeed*: ULONG64 + ReceiveLinkSpeed*: ULONG64 + FirstWinsServerAddress*: PIP_ADAPTER_WINS_SERVER_ADDRESS_LH + FirstGatewayAddress*: PIP_ADAPTER_GATEWAY_ADDRESS_LH + Ipv4Metric*: ULONG + Ipv6Metric*: ULONG + Luid*: IF_LUID + Dhcpv4Server*: SOCKET_ADDRESS + CompartmentId*: NET_IF_COMPARTMENT_ID + NetworkGuid*: NET_IF_NETWORK_GUID + ConnectionType*: NET_IF_CONNECTION_TYPE + TunnelType*: TUNNEL_TYPE + Dhcpv6Server*: SOCKET_ADDRESS + Dhcpv6ClientDuid*: array[MAX_DHCPV6_DUID_LENGTH, BYTE] + Dhcpv6ClientDuidLength*: ULONG + Dhcpv6Iaid*: ULONG + FirstDnsSuffix*: PIP_ADAPTER_DNS_SUFFIX + PIP_ADAPTER_ADDRESSES_LH* = ptr IP_ADAPTER_ADDRESSES_LH + IP_ADAPTER_ADDRESSES_XP_UNION1_STRUCT1* {.pure.} = object + Length*: ULONG + IfIndex*: DWORD + IP_ADAPTER_ADDRESSES_XP_UNION1* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: IP_ADAPTER_ADDRESSES_XP_UNION1_STRUCT1 + IP_ADAPTER_ADDRESSES_XP* {.pure.} = object + union1*: IP_ADAPTER_ADDRESSES_XP_UNION1 + Next*: ptr IP_ADAPTER_ADDRESSES_XP + AdapterName*: PCHAR + FirstUnicastAddress*: PIP_ADAPTER_UNICAST_ADDRESS_XP + FirstAnycastAddress*: PIP_ADAPTER_ANYCAST_ADDRESS_XP + FirstMulticastAddress*: PIP_ADAPTER_MULTICAST_ADDRESS_XP + FirstDnsServerAddress*: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP + DnsSuffix*: PWCHAR + Description*: PWCHAR + FriendlyName*: PWCHAR + PhysicalAddress*: array[MAX_ADAPTER_ADDRESS_LENGTH, BYTE] + PhysicalAddressLength*: DWORD + Flags*: DWORD + Mtu*: DWORD + IfType*: DWORD + OperStatus*: IF_OPER_STATUS + Ipv6IfIndex*: DWORD + ZoneIndices*: array[16, DWORD] + FirstPrefix*: PIP_ADAPTER_PREFIX_XP + PIP_ADAPTER_ADDRESSES_XP* = ptr IP_ADAPTER_ADDRESSES_XP + IP_ADAPTER_ADDRESSES* = IP_ADAPTER_ADDRESSES_XP + PIP_ADAPTER_ADDRESSES* = ptr IP_ADAPTER_ADDRESSES_XP + IP_PER_ADAPTER_INFO* {.pure.} = object + AutoconfigEnabled*: UINT + AutoconfigActive*: UINT + CurrentDnsServer*: PIP_ADDR_STRING + DnsServerList*: IP_ADDR_STRING + PIP_PER_ADAPTER_INFO* = ptr IP_PER_ADAPTER_INFO +const + MAX_HOSTNAME_LEN* = 128 + MAX_DOMAIN_NAME_LEN* = 128 + MAX_SCOPE_ID_LEN* = 256 +type + FIXED_INFO* {.pure.} = object + HostName*: array[MAX_HOSTNAME_LEN + 4, char] + DomainName*: array[MAX_DOMAIN_NAME_LEN + 4, char] + CurrentDnsServer*: PIP_ADDR_STRING + DnsServerList*: IP_ADDR_STRING + NodeType*: UINT + ScopeId*: array[MAX_SCOPE_ID_LEN + 4, char] + EnableRouting*: UINT + EnableProxy*: UINT + EnableDns*: UINT + PFIXED_INFO* = ptr FIXED_INFO + IP_INTERFACE_NAME_INFO* {.pure.} = object + Index*: ULONG + MediaType*: ULONG + ConnectionType*: UCHAR + AccessType*: UCHAR + DeviceGuid*: GUID + InterfaceGuid*: GUID + PIP_INTERFACE_NAME_INFO* = ptr IP_INTERFACE_NAME_INFO + TCP_ESTATS_BANDWIDTH_ROD_v0* {.pure.} = object + OutboundBandwidth*: ULONG64 + InboundBandwidth*: ULONG64 + OutboundInstability*: ULONG64 + InboundInstability*: ULONG64 + OutboundBandwidthPeaked*: BOOLEAN + InboundBandwidthPeaked*: BOOLEAN + PTCP_ESTATS_BANDWIDTH_ROD_v0* = ptr TCP_ESTATS_BANDWIDTH_ROD_v0 + TCP_ESTATS_BANDWIDTH_RW_v0* {.pure.} = object + EnableCollectionOutbound*: TCP_BOOLEAN_OPTIONAL + EnableCollectionInbound*: TCP_BOOLEAN_OPTIONAL + PTCP_ESTATS_BANDWIDTH_RW_v0* = ptr TCP_ESTATS_BANDWIDTH_RW_v0 + TCP_ESTATS_DATA_ROD_v0* {.pure.} = object + DataBytesOut*: ULONG64 + DataSegsOut*: ULONG64 + DataBytesIn*: ULONG64 + DataSegsIn*: ULONG64 + SegsOut*: ULONG64 + SegsIn*: ULONG64 + SoftErrors*: ULONG + SoftErrorReason*: ULONG + SndUna*: ULONG + SndNxt*: ULONG + SndMax*: ULONG + ThruBytesAcked*: ULONG64 + RcvNxt*: ULONG + ThruBytesReceived*: ULONG64 + PTCP_ESTATS_DATA_ROD_v0* = ptr TCP_ESTATS_DATA_ROD_v0 + TCP_ESTATS_DATA_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_DATA_RW_v0* = ptr TCP_ESTATS_DATA_RW_v0 + TCP_ESTATS_FINE_RTT_ROD_v0* {.pure.} = object + RttVar*: ULONG + MaxRtt*: ULONG + MinRtt*: ULONG + SumRtt*: ULONG + PTCP_ESTATS_FINE_RTT_ROD_v0* = ptr TCP_ESTATS_FINE_RTT_ROD_v0 + TCP_ESTATS_FINE_RTT_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_FINE_RTT_RW_v0* = ptr TCP_ESTATS_FINE_RTT_RW_v0 + TCP_ESTATS_OBS_REC_ROD_v0* {.pure.} = object + CurRwinRcvd*: ULONG + MaxRwinRcvd*: ULONG + MinRwinRcvd*: ULONG + WinScaleRcvd*: UCHAR + PTCP_ESTATS_OBS_REC_ROD_v0* = ptr TCP_ESTATS_OBS_REC_ROD_v0 + TCP_ESTATS_OBS_REC_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_OBS_REC_RW_v0* = ptr TCP_ESTATS_OBS_REC_RW_v0 + TCP_ESTATS_PATH_ROD_v0* {.pure.} = object + FastRetran*: ULONG + Timeouts*: ULONG + SubsequentTimeouts*: ULONG + CurTimeoutCount*: ULONG + AbruptTimeouts*: ULONG + PktsRetrans*: ULONG + BytesRetrans*: ULONG + DupAcksIn*: ULONG + SacksRcvd*: ULONG + SackBlocksRcvd*: ULONG + CongSignals*: ULONG + PreCongSumCwnd*: ULONG + PreCongSumRtt*: ULONG + PostCongSumRtt*: ULONG + PostCongCountRtt*: ULONG + EcnSignals*: ULONG + EceRcvd*: ULONG + SendStall*: ULONG + QuenchRcvd*: ULONG + RetranThresh*: ULONG + SndDupAckEpisodes*: ULONG + SumBytesReordered*: ULONG + NonRecovDa*: ULONG + NonRecovDaEpisodes*: ULONG + AckAfterFr*: ULONG + DsackDups*: ULONG + SampleRtt*: ULONG + SmoothedRtt*: ULONG + RttVar*: ULONG + MaxRtt*: ULONG + MinRtt*: ULONG + SumRtt*: ULONG + CountRtt*: ULONG + CurRto*: ULONG + MaxRto*: ULONG + MinRto*: ULONG + CurMss*: ULONG + MaxMss*: ULONG + MinMss*: ULONG + SpuriousRtoDetections*: ULONG + PTCP_ESTATS_PATH_ROD_v0* = ptr TCP_ESTATS_PATH_ROD_v0 + TCP_ESTATS_PATH_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_PATH_RW_v0* = ptr TCP_ESTATS_PATH_RW_v0 + TCP_ESTATS_REC_ROD_v0* {.pure.} = object + CurRwinSent*: ULONG + MaxRwinSent*: ULONG + MinRwinSent*: ULONG + LimRwin*: ULONG + DupAckEpisodes*: ULONG + DupAcksOut*: ULONG + CeRcvd*: ULONG + EcnSent*: ULONG + EcnNoncesRcvd*: ULONG + CurReasmQueue*: ULONG + MaxReasmQueue*: ULONG + CurAppRQueue*: SIZE_T + MaxAppRQueue*: SIZE_T + WinScaleSent*: UCHAR + PTCP_ESTATS_REC_ROD_v0* = ptr TCP_ESTATS_REC_ROD_v0 + TCP_ESTATS_REC_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_REC_RW_v0* = ptr TCP_ESTATS_REC_RW_v0 + TCP_ESTATS_SEND_BUFF_ROD_v0* {.pure.} = object + CurRetxQueue*: SIZE_T + MaxRetxQueue*: SIZE_T + CurAppWQueue*: SIZE_T + MaxAppWQueue*: SIZE_T + PTCP_ESTATS_SEND_BUFF_ROD_v0* = ptr TCP_ESTATS_SEND_BUFF_ROD_v0 + TCP_ESTATS_SEND_BUFF_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_SEND_BUFF_RW_v0* = ptr TCP_ESTATS_SEND_BUFF_RW_v0 + TCP_ESTATS_SND_CONG_ROD_v0* {.pure.} = object + SndLimTransRwin*: ULONG + SndLimTimeRwin*: ULONG + SndLimBytesRwin*: SIZE_T + SndLimTransCwnd*: ULONG + SndLimTimeCwnd*: ULONG + SndLimBytesCwnd*: SIZE_T + SndLimTransSnd*: ULONG + SndLimTimeSnd*: ULONG + SndLimBytesSnd*: SIZE_T + SlowStart*: ULONG + CongAvoid*: ULONG + OtherReductions*: ULONG + CurCwnd*: ULONG + MaxSsCwnd*: ULONG + MaxCaCwnd*: ULONG + CurSsthresh*: ULONG + MaxSsthresh*: ULONG + MinSsthresh*: ULONG + PTCP_ESTATS_SND_CONG_ROD_v0* = ptr TCP_ESTATS_SND_CONG_ROD_v0 + TCP_ESTATS_SND_CONG_ROS_v0* {.pure.} = object + LimCwnd*: ULONG + PTCP_ESTATS_SND_CONG_ROS_v0* = ptr TCP_ESTATS_SND_CONG_ROS_v0 + TCP_ESTATS_SND_CONG_RW_v0* {.pure.} = object + EnableCollection*: BOOLEAN + PTCP_ESTATS_SND_CONG_RW_v0* = ptr TCP_ESTATS_SND_CONG_RW_v0 + TCP_ESTATS_SYN_OPTS_ROS_v0* {.pure.} = object + ActiveOpen*: BOOLEAN + MssRcvd*: ULONG + MssSent*: ULONG + PTCP_ESTATS_SYN_OPTS_ROS_v0* = ptr TCP_ESTATS_SYN_OPTS_ROS_v0 + NET_ADDRESS_INFO_UNION1_NamedAddress* {.pure.} = object + Address*: array[DNS_MAX_NAME_BUFFER_LENGTH, WCHAR] + Port*: array[6, WCHAR] + NET_ADDRESS_INFO_UNION1* {.pure, union.} = object + NamedAddress*: NET_ADDRESS_INFO_UNION1_NamedAddress + Ipv4Address*: SOCKADDR_IN + Ipv6Address*: SOCKADDR_IN6 + IpAddress*: SOCKADDR + NET_ADDRESS_INFO* {.pure.} = object + Format*: NET_ADDRESS_FORMAT + union1*: NET_ADDRESS_INFO_UNION1 + PNET_ADDRESS_INFO* = ptr NET_ADDRESS_INFO + IConnectionRequestCallback* {.pure.} = object + lpVtbl*: ptr IConnectionRequestCallbackVtbl + IConnectionRequestCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnComplete*: proc(self: ptr IConnectionRequestCallback, hrStatus: HRESULT): HRESULT {.stdcall.} + ILocationReport* = IConnectionRequestCallback + NDIS_STATISTICS_VALUE* {.pure.} = object + Oid*: NDIS_OID + DataLength*: ULONG + Data*: array[1, UCHAR] + PNDIS_STATISTICS_VALUE* = ptr NDIS_STATISTICS_VALUE + NDIS_STATISTICS_VALUE_EX* {.pure.} = object + Oid*: NDIS_OID + DataLength*: ULONG + Length*: ULONG + Data*: array[1, UCHAR] + PNDIS_STATISTICS_VALUE_EX* = ptr NDIS_STATISTICS_VALUE_EX + NDIS_VAR_DATA_DESC* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Offset*: ULONG_PTR + PNDIS_VAR_DATA_DESC* = ptr NDIS_VAR_DATA_DESC + NDIS_OBJECT_HEADER* {.pure.} = object + Type*: UCHAR + Revision*: UCHAR + Size*: USHORT + PNDIS_OBJECT_HEADER* = ptr NDIS_OBJECT_HEADER + NDIS_STATISTICS_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + SupportedStatistics*: ULONG + ifInDiscards*: ULONG64 + ifInErrors*: ULONG64 + ifHCInOctets*: ULONG64 + ifHCInUcastPkts*: ULONG64 + ifHCInMulticastPkts*: ULONG64 + ifHCInBroadcastPkts*: ULONG64 + ifHCOutOctets*: ULONG64 + ifHCOutUcastPkts*: ULONG64 + ifHCOutMulticastPkts*: ULONG64 + ifHCOutBroadcastPkts*: ULONG64 + ifOutErrors*: ULONG64 + ifOutDiscards*: ULONG64 + ifHCInUcastOctets*: ULONG64 + ifHCInMulticastOctets*: ULONG64 + ifHCInBroadcastOctets*: ULONG64 + ifHCOutUcastOctets*: ULONG64 + ifHCOutMulticastOctets*: ULONG64 + ifHCOutBroadcastOctets*: ULONG64 + PNDIS_STATISTICS_INFO* = ptr NDIS_STATISTICS_INFO + NDIS_RSC_STATISTICS_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + CoalescedPkts*: ULONG64 + CoalescedOctets*: ULONG64 + CoalesceEvents*: ULONG64 + Aborts*: ULONG64 + PNDIS_RSC_STATISTICS_INFO* = ptr NDIS_RSC_STATISTICS_INFO + NDIS_INTERRUPT_MODERATION_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + InterruptModeration*: NDIS_INTERRUPT_MODERATION + PNDIS_INTERRUPT_MODERATION_PARAMETERS* = ptr NDIS_INTERRUPT_MODERATION_PARAMETERS + NDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + TimeoutArrayLength*: ULONG + TimeoutArray*: array[1, ULONG] + PNDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES* = ptr NDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES + NDIS_PCI_DEVICE_CUSTOM_PROPERTIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + DeviceType*: UINT32 + CurrentSpeedAndMode*: UINT32 + CurrentPayloadSize*: UINT32 + MaxPayloadSize*: UINT32 + MaxReadRequestSize*: UINT32 + CurrentLinkSpeed*: UINT32 + CurrentLinkWidth*: UINT32 + MaxLinkSpeed*: UINT32 + MaxLinkWidth*: UINT32 + PciExpressVersion*: UINT32 + InterruptType*: UINT32 + MaxInterruptMessages*: UINT32 + PNDIS_PCI_DEVICE_CUSTOM_PROPERTIES* = ptr NDIS_PCI_DEVICE_CUSTOM_PROPERTIES + NDIS_802_11_MAC_ADDRESS* = array[6, UCHAR] + NDIS_802_11_STATUS_INDICATION* {.pure.} = object + StatusType*: NDIS_802_11_STATUS_TYPE + PNDIS_802_11_STATUS_INDICATION* = ptr NDIS_802_11_STATUS_INDICATION + NDIS_802_11_AUTHENTICATION_REQUEST* {.pure.} = object + Length*: ULONG + Bssid*: NDIS_802_11_MAC_ADDRESS + Flags*: ULONG + PNDIS_802_11_AUTHENTICATION_REQUEST* = ptr NDIS_802_11_AUTHENTICATION_REQUEST + PMKID_CANDIDATE* {.pure.} = object + BSSID*: NDIS_802_11_MAC_ADDRESS + Flags*: ULONG + PPMKID_CANDIDATE* = ptr PMKID_CANDIDATE + NDIS_802_11_PMKID_CANDIDATE_LIST* {.pure.} = object + Version*: ULONG + NumCandidates*: ULONG + CandidateList*: array[1, PMKID_CANDIDATE] + PNDIS_802_11_PMKID_CANDIDATE_LIST* = ptr NDIS_802_11_PMKID_CANDIDATE_LIST + NDIS_802_11_NETWORK_TYPE_LIST* {.pure.} = object + NumberOfItems*: ULONG + NetworkType*: array[1, NDIS_802_11_NETWORK_TYPE] + PNDIS_802_11_NETWORK_TYPE_LIST* = ptr NDIS_802_11_NETWORK_TYPE_LIST + NDIS_802_11_CONFIGURATION_FH* {.pure.} = object + Length*: ULONG + HopPattern*: ULONG + HopSet*: ULONG + DwellTime*: ULONG + PNDIS_802_11_CONFIGURATION_FH* = ptr NDIS_802_11_CONFIGURATION_FH + NDIS_802_11_CONFIGURATION* {.pure.} = object + Length*: ULONG + BeaconPeriod*: ULONG + ATIMWindow*: ULONG + DSConfig*: ULONG + FHConfig*: NDIS_802_11_CONFIGURATION_FH + PNDIS_802_11_CONFIGURATION* = ptr NDIS_802_11_CONFIGURATION + NDIS_802_11_STATISTICS* {.pure.} = object + Length*: ULONG + TransmittedFragmentCount*: LARGE_INTEGER + MulticastTransmittedFrameCount*: LARGE_INTEGER + FailedCount*: LARGE_INTEGER + RetryCount*: LARGE_INTEGER + MultipleRetryCount*: LARGE_INTEGER + RTSSuccessCount*: LARGE_INTEGER + RTSFailureCount*: LARGE_INTEGER + ACKFailureCount*: LARGE_INTEGER + FrameDuplicateCount*: LARGE_INTEGER + ReceivedFragmentCount*: LARGE_INTEGER + MulticastReceivedFrameCount*: LARGE_INTEGER + FCSErrorCount*: LARGE_INTEGER + TKIPLocalMICFailures*: LARGE_INTEGER + TKIPICVErrorCount*: LARGE_INTEGER + TKIPCounterMeasuresInvoked*: LARGE_INTEGER + TKIPReplays*: LARGE_INTEGER + CCMPFormatErrors*: LARGE_INTEGER + CCMPReplays*: LARGE_INTEGER + CCMPDecryptErrors*: LARGE_INTEGER + FourWayHandshakeFailures*: LARGE_INTEGER + WEPUndecryptableCount*: LARGE_INTEGER + WEPICVErrorCount*: LARGE_INTEGER + DecryptSuccessCount*: LARGE_INTEGER + DecryptFailureCount*: LARGE_INTEGER + PNDIS_802_11_STATISTICS* = ptr NDIS_802_11_STATISTICS + NDIS_802_11_KEY* {.pure.} = object + Length*: ULONG + KeyIndex*: ULONG + KeyLength*: ULONG + BSSID*: NDIS_802_11_MAC_ADDRESS + KeyRSC*: NDIS_802_11_KEY_RSC + KeyMaterial*: array[1, UCHAR] + PNDIS_802_11_KEY* = ptr NDIS_802_11_KEY + NDIS_802_11_REMOVE_KEY* {.pure.} = object + Length*: ULONG + KeyIndex*: ULONG + BSSID*: NDIS_802_11_MAC_ADDRESS + PNDIS_802_11_REMOVE_KEY* = ptr NDIS_802_11_REMOVE_KEY + NDIS_802_11_WEP* {.pure.} = object + Length*: ULONG + KeyIndex*: ULONG + KeyLength*: ULONG + KeyMaterial*: array[1, UCHAR] + PNDIS_802_11_WEP* = ptr NDIS_802_11_WEP +const + NDIS_802_11_LENGTH_RATES* = 8 +type + NDIS_802_11_RATES* = array[NDIS_802_11_LENGTH_RATES, UCHAR] +const + NDIS_802_11_LENGTH_RATES_EX* = 16 +type + NDIS_802_11_RATES_EX* = array[NDIS_802_11_LENGTH_RATES_EX, UCHAR] +const + NDIS_802_11_LENGTH_SSID* = 32 +type + NDIS_802_11_SSID* {.pure.} = object + SsidLength*: ULONG + Ssid*: array[NDIS_802_11_LENGTH_SSID, UCHAR] + PNDIS_802_11_SSID* = ptr NDIS_802_11_SSID + NDIS_WLAN_BSSID* {.pure.} = object + Length*: ULONG + MacAddress*: NDIS_802_11_MAC_ADDRESS + Reserved*: array[2, UCHAR] + Ssid*: NDIS_802_11_SSID + Privacy*: ULONG + Rssi*: NDIS_802_11_RSSI + NetworkTypeInUse*: NDIS_802_11_NETWORK_TYPE + Configuration*: NDIS_802_11_CONFIGURATION + InfrastructureMode*: NDIS_802_11_NETWORK_INFRASTRUCTURE + SupportedRates*: NDIS_802_11_RATES + PNDIS_WLAN_BSSID* = ptr NDIS_WLAN_BSSID + NDIS_802_11_BSSID_LIST* {.pure.} = object + NumberOfItems*: ULONG + Bssid*: array[1, NDIS_WLAN_BSSID] + PNDIS_802_11_BSSID_LIST* = ptr NDIS_802_11_BSSID_LIST + NDIS_WLAN_BSSID_EX* {.pure.} = object + Length*: ULONG + MacAddress*: NDIS_802_11_MAC_ADDRESS + Reserved*: array[2, UCHAR] + Ssid*: NDIS_802_11_SSID + Privacy*: ULONG + Rssi*: NDIS_802_11_RSSI + NetworkTypeInUse*: NDIS_802_11_NETWORK_TYPE + Configuration*: NDIS_802_11_CONFIGURATION + InfrastructureMode*: NDIS_802_11_NETWORK_INFRASTRUCTURE + SupportedRates*: NDIS_802_11_RATES_EX + IELength*: ULONG + IEs*: array[1, UCHAR] + PNDIS_WLAN_BSSID_EX* = ptr NDIS_WLAN_BSSID_EX + NDIS_802_11_BSSID_LIST_EX* {.pure.} = object + NumberOfItems*: ULONG + Bssid*: array[1, NDIS_WLAN_BSSID_EX] + PNDIS_802_11_BSSID_LIST_EX* = ptr NDIS_802_11_BSSID_LIST_EX + NDIS_802_11_FIXED_IEs* {.pure.} = object + Timestamp*: array[8, UCHAR] + BeaconInterval*: USHORT + Capabilities*: USHORT + PNDIS_802_11_FIXED_IEs* = ptr NDIS_802_11_FIXED_IEs + NDIS_802_11_VARIABLE_IEs* {.pure.} = object + ElementID*: UCHAR + Length*: UCHAR + data*: array[1, UCHAR] + PNDIS_802_11_VARIABLE_IEs* = ptr NDIS_802_11_VARIABLE_IEs + NDIS_802_11_AI_REQFI* {.pure.} = object + Capabilities*: USHORT + ListenInterval*: USHORT + CurrentAPAddress*: NDIS_802_11_MAC_ADDRESS + PNDIS_802_11_AI_REQFI* = ptr NDIS_802_11_AI_REQFI + NDIS_802_11_AI_RESFI* {.pure.} = object + Capabilities*: USHORT + StatusCode*: USHORT + AssociationId*: USHORT + PNDIS_802_11_AI_RESFI* = ptr NDIS_802_11_AI_RESFI + NDIS_802_11_ASSOCIATION_INFORMATION* {.pure.} = object + Length*: ULONG + AvailableRequestFixedIEs*: USHORT + RequestFixedIEs*: NDIS_802_11_AI_REQFI + RequestIELength*: ULONG + OffsetRequestIEs*: ULONG + AvailableResponseFixedIEs*: USHORT + ResponseFixedIEs*: NDIS_802_11_AI_RESFI + ResponseIELength*: ULONG + OffsetResponseIEs*: ULONG + PNDIS_802_11_ASSOCIATION_INFORMATION* = ptr NDIS_802_11_ASSOCIATION_INFORMATION + NDIS_802_11_AUTHENTICATION_EVENT* {.pure.} = object + Status*: NDIS_802_11_STATUS_INDICATION + Request*: array[1, NDIS_802_11_AUTHENTICATION_REQUEST] + PNDIS_802_11_AUTHENTICATION_EVENT* = ptr NDIS_802_11_AUTHENTICATION_EVENT + NDIS_802_11_TEST_UNION1* {.pure, union.} = object + AuthenticationEvent*: NDIS_802_11_AUTHENTICATION_EVENT + RssiTrigger*: NDIS_802_11_RSSI + NDIS_802_11_TEST* {.pure.} = object + Length*: ULONG + Type*: ULONG + union1*: NDIS_802_11_TEST_UNION1 + PNDIS_802_11_TEST* = ptr NDIS_802_11_TEST + NDIS_802_11_PMKID_VALUE* = array[16, UCHAR] + BSSID_INFO* {.pure.} = object + BSSID*: NDIS_802_11_MAC_ADDRESS + PMKID*: NDIS_802_11_PMKID_VALUE + PBSSID_INFO* = ptr BSSID_INFO + NDIS_802_11_PMKID* {.pure.} = object + Length*: ULONG + BSSIDInfoCount*: ULONG + BSSIDInfo*: array[1, BSSID_INFO] + PNDIS_802_11_PMKID* = ptr NDIS_802_11_PMKID + NDIS_802_11_AUTHENTICATION_ENCRYPTION* {.pure.} = object + AuthModeSupported*: NDIS_802_11_AUTHENTICATION_MODE + EncryptStatusSupported*: NDIS_802_11_ENCRYPTION_STATUS + PNDIS_802_11_AUTHENTICATION_ENCRYPTION* = ptr NDIS_802_11_AUTHENTICATION_ENCRYPTION + NDIS_802_11_CAPABILITY* {.pure.} = object + Length*: ULONG + Version*: ULONG + NoOfPMKIDs*: ULONG + NoOfAuthEncryptPairsSupported*: ULONG + AuthenticationEncryptionSupported*: array[1, NDIS_802_11_AUTHENTICATION_ENCRYPTION] + PNDIS_802_11_CAPABILITY* = ptr NDIS_802_11_CAPABILITY + NDIS_802_11_NON_BCAST_SSID_LIST* {.pure.} = object + NumberOfItems*: ULONG + Non_Bcast_Ssid*: array[1, NDIS_802_11_SSID] + PNDIS_802_11_NON_BCAST_SSID_LIST* = ptr NDIS_802_11_NON_BCAST_SSID_LIST + NDIS_CO_DEVICE_PROFILE* {.pure.} = object + DeviceDescription*: NDIS_VAR_DATA_DESC + DevSpecificInfo*: NDIS_VAR_DATA_DESC + ulTAPISupplementaryPassThru*: ULONG + ulAddressModes*: ULONG + ulNumAddresses*: ULONG + ulBearerModes*: ULONG + ulMaxTxRate*: ULONG + ulMinTxRate*: ULONG + ulMaxRxRate*: ULONG + ulMinRxRate*: ULONG + ulMediaModes*: ULONG + ulGenerateToneModes*: ULONG + ulGenerateToneMaxNumFreq*: ULONG + ulGenerateDigitModes*: ULONG + ulMonitorToneMaxNumFreq*: ULONG + ulMonitorToneMaxNumEntries*: ULONG + ulMonitorDigitModes*: ULONG + ulGatherDigitsMinTimeout*: ULONG + ulGatherDigitsMaxTimeout*: ULONG + ulDevCapFlags*: ULONG + ulMaxNumActiveCalls*: ULONG + ulAnswerMode*: ULONG + ulUUIAcceptSize*: ULONG + ulUUIAnswerSize*: ULONG + ulUUIMakeCallSize*: ULONG + ulUUIDropSize*: ULONG + ulUUISendUserUserInfoSize*: ULONG + ulUUICallInfoSize*: ULONG + PNDIS_CO_DEVICE_PROFILE* = ptr NDIS_CO_DEVICE_PROFILE + OFFLOAD_ALGO_INFO* {.pure.} = object + algoIdentifier*: ULONG + algoKeylen*: ULONG + algoRounds*: ULONG + POFFLOAD_ALGO_INFO* = ptr OFFLOAD_ALGO_INFO + OFFLOAD_SECURITY_ASSOCIATION* {.pure.} = object + Operation*: OFFLOAD_OPERATION_E + SPI*: SPI_TYPE + IntegrityAlgo*: OFFLOAD_ALGO_INFO + ConfAlgo*: OFFLOAD_ALGO_INFO + Reserved*: OFFLOAD_ALGO_INFO + POFFLOAD_SECURITY_ASSOCIATION* = ptr OFFLOAD_SECURITY_ASSOCIATION +const + OFFLOAD_MAX_SAS* = 3 +type + OFFLOAD_IPSEC_ADD_SA* {.pure.} = object + SrcAddr*: IPAddr + SrcMask*: IPMask + DestAddr*: IPAddr + DestMask*: IPMask + Protocol*: ULONG + SrcPort*: USHORT + DestPort*: USHORT + SrcTunnelAddr*: IPAddr + DestTunnelAddr*: IPAddr + Flags*: USHORT + NumSAs*: SHORT + SecAssoc*: array[OFFLOAD_MAX_SAS, OFFLOAD_SECURITY_ASSOCIATION] + OffloadHandle*: HANDLE + KeyLen*: ULONG + KeyMat*: array[1, UCHAR] + POFFLOAD_IPSEC_ADD_SA* = ptr OFFLOAD_IPSEC_ADD_SA + OFFLOAD_IPSEC_DELETE_SA* {.pure.} = object + OffloadHandle*: HANDLE + POFFLOAD_IPSEC_DELETE_SA* = ptr OFFLOAD_IPSEC_DELETE_SA + OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY* {.pure.} = object + UdpEncapType*: UDP_ENCAP_TYPE + DstEncapPort*: USHORT + POFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY* = ptr OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY + OFFLOAD_IPSEC_ADD_UDPESP_SA* {.pure.} = object + SrcAddr*: IPAddr + SrcMask*: IPMask + DstAddr*: IPAddr + DstMask*: IPMask + Protocol*: ULONG + SrcPort*: USHORT + DstPort*: USHORT + SrcTunnelAddr*: IPAddr + DstTunnelAddr*: IPAddr + Flags*: USHORT + NumSAs*: SHORT + SecAssoc*: array[OFFLOAD_MAX_SAS, OFFLOAD_SECURITY_ASSOCIATION] + OffloadHandle*: HANDLE + EncapTypeEntry*: OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY + EncapTypeEntryOffldHandle*: HANDLE + KeyLen*: ULONG + KeyMat*: array[1, UCHAR] + POFFLOAD_IPSEC_ADD_UDPESP_SA* = ptr OFFLOAD_IPSEC_ADD_UDPESP_SA + OFFLOAD_IPSEC_DELETE_UDPESP_SA* {.pure.} = object + OffloadHandle*: HANDLE + EncapTypeEntryOffldHandle*: HANDLE + POFFLOAD_IPSEC_DELETE_UDPESP_SA* = ptr OFFLOAD_IPSEC_DELETE_UDPESP_SA + TRANSPORT_HEADER_OFFSET* {.pure.} = object + ProtocolType*: USHORT + HeaderOffset*: USHORT + PTRANSPORT_HEADER_OFFSET* = ptr TRANSPORT_HEADER_OFFSET + NETWORK_ADDRESS* {.pure.} = object + AddressLength*: USHORT + AddressType*: USHORT + Address*: array[1, UCHAR] + PNETWORK_ADDRESS* = ptr NETWORK_ADDRESS + NETWORK_ADDRESS_LIST* {.pure.} = object + AddressCount*: LONG + AddressType*: USHORT + Address*: array[1, NETWORK_ADDRESS] + PNETWORK_ADDRESS_LIST* = ptr NETWORK_ADDRESS_LIST + NETWORK_ADDRESS_IP* {.pure.} = object + sin_port*: USHORT + in_addr*: ULONG + sin_zero*: array[8, UCHAR] + PNETWORK_ADDRESS_IP* = ptr NETWORK_ADDRESS_IP + NETWORK_ADDRESS_IPX* {.pure.} = object + NetworkAddress*: ULONG + NodeAddress*: array[6, UCHAR] + Socket*: USHORT + PNETWORK_ADDRESS_IPX* = ptr NETWORK_ADDRESS_IPX + GEN_GET_TIME_CAPS* {.pure.} = object + Flags*: ULONG + ClockPrecision*: ULONG + PGEN_GET_TIME_CAPS* = ptr GEN_GET_TIME_CAPS + GEN_GET_NETCARD_TIME* {.pure.} = object + ReadTime*: ULONGLONG + PGEN_GET_NETCARD_TIME* = ptr GEN_GET_NETCARD_TIME + NDIS_PM_PACKET_PATTERN* {.pure.} = object + Priority*: ULONG + Reserved*: ULONG + MaskSize*: ULONG + PatternOffset*: ULONG + PatternSize*: ULONG + PatternFlags*: ULONG + PNDIS_PM_PACKET_PATTERN* = ptr NDIS_PM_PACKET_PATTERN + NDIS_PM_WAKE_UP_CAPABILITIES* {.pure.} = object + MinMagicPacketWakeUp*: NDIS_DEVICE_POWER_STATE + MinPatternWakeUp*: NDIS_DEVICE_POWER_STATE + MinLinkChangeWakeUp*: NDIS_DEVICE_POWER_STATE + PNDIS_PM_WAKE_UP_CAPABILITIES* = ptr NDIS_PM_WAKE_UP_CAPABILITIES + NDIS_PNP_CAPABILITIES* {.pure.} = object + Flags*: ULONG + WakeUpCapabilities*: NDIS_PM_WAKE_UP_CAPABILITIES + PNDIS_PNP_CAPABILITIES* = ptr NDIS_PNP_CAPABILITIES + NDIS_WAN_PROTOCOL_CAPS* {.pure.} = object + Flags*: ULONG + Reserved*: ULONG + PNDIS_WAN_PROTOCOL_CAPS* = ptr NDIS_WAN_PROTOCOL_CAPS + NDIS_CO_LINK_SPEED* {.pure.} = object + Outbound*: ULONG + Inbound*: ULONG + PNDIS_CO_LINK_SPEED* = ptr NDIS_CO_LINK_SPEED + NDIS_LINK_SPEED* {.pure.} = object + XmitLinkSpeed*: ULONG64 + RcvLinkSpeed*: ULONG64 + PNDIS_LINK_SPEED* = ptr NDIS_LINK_SPEED + NDIS_GUID_UNION1* {.pure, union.} = object + Oid*: NDIS_OID + Status*: NDIS_STATUS + NDIS_GUID* {.pure.} = object + Guid*: GUID + union1*: NDIS_GUID_UNION1 + Size*: ULONG + Flags*: ULONG + PNDIS_GUID* = ptr NDIS_GUID + NDIS_IRDA_PACKET_INFO* {.pure.} = object + ExtraBOFs*: ULONG + MinTurnAroundTime*: ULONG + PNDIS_IRDA_PACKET_INFO* = ptr NDIS_IRDA_PACKET_INFO + NDIS_IF_COUNTED_STRING* = IF_COUNTED_STRING + PNDIS_IF_COUNTED_STRING* = ptr IF_COUNTED_STRING + NDIS_IF_PHYSICAL_ADDRESS* = IF_PHYSICAL_ADDRESS + PNDIS_IF_PHYSICAL_ADDRESS* = ptr IF_PHYSICAL_ADDRESS + NDIS_MEDIA_CONNECT_STATE* = NET_IF_MEDIA_CONNECT_STATE + PNDIS_MEDIA_CONNECT_STATE* = ptr NET_IF_MEDIA_CONNECT_STATE + NDIS_MEDIA_DUPLEX_STATE* = NET_IF_MEDIA_DUPLEX_STATE + PNDIS_MEDIA_DUPLEX_STATE* = ptr NET_IF_MEDIA_DUPLEX_STATE + NDIS_LINK_STATE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + MediaConnectState*: NDIS_MEDIA_CONNECT_STATE + MediaDuplexState*: NDIS_MEDIA_DUPLEX_STATE + XmitLinkSpeed*: ULONG64 + RcvLinkSpeed*: ULONG64 + PauseFunctions*: NDIS_SUPPORTED_PAUSE_FUNCTIONS + AutoNegotiationFlags*: ULONG + PNDIS_LINK_STATE* = ptr NDIS_LINK_STATE + NDIS_LINK_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + MediaDuplexState*: NDIS_MEDIA_DUPLEX_STATE + XmitLinkSpeed*: ULONG64 + RcvLinkSpeed*: ULONG64 + PauseFunctions*: NDIS_SUPPORTED_PAUSE_FUNCTIONS + AutoNegotiationFlags*: ULONG + PNDIS_LINK_PARAMETERS* = ptr NDIS_LINK_PARAMETERS + NDIS_OPER_STATE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + OperationalStatus*: NET_IF_OPER_STATUS + OperationalStatusFlags*: ULONG + PNDIS_OPER_STATE* = ptr NDIS_OPER_STATE + NDIS_IP_OPER_STATUS* {.pure.} = object + AddressFamily*: ULONG + OperationalStatus*: NET_IF_OPER_STATUS + OperationalStatusFlags*: ULONG + PNDIS_IP_OPER_STATUS* = ptr NDIS_IP_OPER_STATUS +const + MAXIMUM_IP_OPER_STATUS_ADDRESS_FAMILIES_SUPPORTED* = 32 +type + NDIS_IP_OPER_STATUS_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + NumberofAddressFamiliesReturned*: ULONG + IpOperationalStatus*: array[MAXIMUM_IP_OPER_STATUS_ADDRESS_FAMILIES_SUPPORTED, NDIS_IP_OPER_STATUS] + PNDIS_IP_OPER_STATUS_INFO* = ptr NDIS_IP_OPER_STATUS_INFO + NDIS_IP_OPER_STATE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + IpOperationalStatus*: NDIS_IP_OPER_STATUS + PNDIS_IP_OPER_STATE* = ptr NDIS_IP_OPER_STATE + NDIS_OFFLOAD_PARAMETERS_STRUCT1* {.pure.} = object + RscIPv4*: UCHAR + RscIPv6*: UCHAR + NDIS_OFFLOAD_PARAMETERS_STRUCT2* {.pure.} = object + EncapsulatedPacketTaskOffload*: UCHAR + EncapsulationTypes*: UCHAR + NDIS_OFFLOAD_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + IPv4Checksum*: UCHAR + TCPIPv4Checksum*: UCHAR + UDPIPv4Checksum*: UCHAR + TCPIPv6Checksum*: UCHAR + UDPIPv6Checksum*: UCHAR + LsoV1*: UCHAR + IPsecV1*: UCHAR + LsoV2IPv4*: UCHAR + LsoV2IPv6*: UCHAR + TcpConnectionIPv4*: UCHAR + TcpConnectionIPv6*: UCHAR + Flags*: ULONG + IPsecV2*: UCHAR + IPsecV2IPv4*: UCHAR + struct1*: NDIS_OFFLOAD_PARAMETERS_STRUCT1 + struct2*: NDIS_OFFLOAD_PARAMETERS_STRUCT2 + PNDIS_OFFLOAD_PARAMETERS* = ptr NDIS_OFFLOAD_PARAMETERS + NDIS_TCP_LARGE_SEND_OFFLOAD_V1_IPv4* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + TcpOptions* {.bitsize:2.}: ULONG + IpOptions* {.bitsize:2.}: ULONG + NDIS_TCP_LARGE_SEND_OFFLOAD_V1* {.pure.} = object + IPv4*: NDIS_TCP_LARGE_SEND_OFFLOAD_V1_IPv4 + PNDIS_TCP_LARGE_SEND_OFFLOAD_V1* = ptr NDIS_TCP_LARGE_SEND_OFFLOAD_V1 + NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv4Transmit* {.pure.} = object + Encapsulation*: ULONG + IpOptionsSupported* {.bitsize:2.}: ULONG + TcpOptionsSupported* {.bitsize:2.}: ULONG + TcpChecksum* {.bitsize:2.}: ULONG + UdpChecksum* {.bitsize:2.}: ULONG + IpChecksum* {.bitsize:2.}: ULONG + NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv4Receive* {.pure.} = object + Encapsulation*: ULONG + IpOptionsSupported* {.bitsize:2.}: ULONG + TcpOptionsSupported* {.bitsize:2.}: ULONG + TcpChecksum* {.bitsize:2.}: ULONG + UdpChecksum* {.bitsize:2.}: ULONG + IpChecksum* {.bitsize:2.}: ULONG + NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv6Transmit* {.pure.} = object + Encapsulation*: ULONG + IpExtensionHeadersSupported* {.bitsize:2.}: ULONG + TcpOptionsSupported* {.bitsize:2.}: ULONG + TcpChecksum* {.bitsize:2.}: ULONG + UdpChecksum* {.bitsize:2.}: ULONG + NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv6Receive* {.pure.} = object + Encapsulation*: ULONG + IpExtensionHeadersSupported* {.bitsize:2.}: ULONG + TcpOptionsSupported* {.bitsize:2.}: ULONG + TcpChecksum* {.bitsize:2.}: ULONG + UdpChecksum* {.bitsize:2.}: ULONG + NDIS_TCP_IP_CHECKSUM_OFFLOAD* {.pure.} = object + IPv4Transmit*: NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv4Transmit + IPv4Receive*: NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv4Receive + IPv6Transmit*: NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv6Transmit + IPv6Receive*: NDIS_TCP_IP_CHECKSUM_OFFLOAD_IPv6Receive + PNDIS_TCP_IP_CHECKSUM_OFFLOAD* = ptr NDIS_TCP_IP_CHECKSUM_OFFLOAD + NDIS_IPSEC_OFFLOAD_V1_Supported* {.pure.} = object + Encapsulation*: ULONG + AhEspCombined*: ULONG + TransportTunnelCombined*: ULONG + IPv4Options*: ULONG + Flags*: ULONG + NDIS_IPSEC_OFFLOAD_V1_IPv4AH* {.pure.} = object + Md5* {.bitsize:2.}: ULONG + Sha_1* {.bitsize:2.}: ULONG + Transport* {.bitsize:2.}: ULONG + Tunnel* {.bitsize:2.}: ULONG + Send* {.bitsize:2.}: ULONG + Receive* {.bitsize:2.}: ULONG + NDIS_IPSEC_OFFLOAD_V1_IPv4ESP* {.pure.} = object + Des* {.bitsize:2.}: ULONG + Reserved* {.bitsize:2.}: ULONG + TripleDes* {.bitsize:2.}: ULONG + NullEsp* {.bitsize:2.}: ULONG + Transport* {.bitsize:2.}: ULONG + Tunnel* {.bitsize:2.}: ULONG + Send* {.bitsize:2.}: ULONG + Receive* {.bitsize:2.}: ULONG + NDIS_IPSEC_OFFLOAD_V1* {.pure.} = object + Supported*: NDIS_IPSEC_OFFLOAD_V1_Supported + IPv4AH*: NDIS_IPSEC_OFFLOAD_V1_IPv4AH + IPv4ESP*: NDIS_IPSEC_OFFLOAD_V1_IPv4ESP + PNDIS_IPSEC_OFFLOAD_V1* = ptr NDIS_IPSEC_OFFLOAD_V1 + NDIS_TCP_LARGE_SEND_OFFLOAD_V2_IPv4* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + NDIS_TCP_LARGE_SEND_OFFLOAD_V2_IPv6* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + IpExtensionHeadersSupported* {.bitsize:2.}: ULONG + TcpOptionsSupported* {.bitsize:2.}: ULONG + NDIS_TCP_LARGE_SEND_OFFLOAD_V2* {.pure.} = object + IPv4*: NDIS_TCP_LARGE_SEND_OFFLOAD_V2_IPv4 + IPv6*: NDIS_TCP_LARGE_SEND_OFFLOAD_V2_IPv6 + PNDIS_TCP_LARGE_SEND_OFFLOAD_V2* = ptr NDIS_TCP_LARGE_SEND_OFFLOAD_V2 + NDIS_IPSEC_OFFLOAD_V2* {.pure.} = object + Encapsulation*: ULONG + IPv6Supported*: BOOLEAN + IPv4Options*: BOOLEAN + IPv6NonIPsecExtensionHeaders*: BOOLEAN + Ah*: BOOLEAN + Esp*: BOOLEAN + AhEspCombined*: BOOLEAN + Transport*: BOOLEAN + Tunnel*: BOOLEAN + TransportTunnelCombined*: BOOLEAN + LsoSupported*: BOOLEAN + ExtendedSequenceNumbers*: BOOLEAN + UdpEsp*: ULONG + AuthenticationAlgorithms*: ULONG + EncryptionAlgorithms*: ULONG + SaOffloadCapacity*: ULONG + PNDIS_IPSEC_OFFLOAD_V2* = ptr NDIS_IPSEC_OFFLOAD_V2 + NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD_IPv4* {.pure.} = object + Enabled*: BOOLEAN + NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD_IPv6* {.pure.} = object + Enabled*: BOOLEAN + NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD* {.pure.} = object + IPv4*: NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD_IPv4 + IPv6*: NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD_IPv6 + PNDIS_TCP_RECV_SEG_COALESCE_OFFLOAD* = ptr NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD* {.pure.} = object + TransmitChecksumOffloadSupported* {.bitsize:4.}: ULONG + ReceiveChecksumOffloadSupported* {.bitsize:4.}: ULONG + LsoV2Supported* {.bitsize:4.}: ULONG + RssSupported* {.bitsize:4.}: ULONG + VmqSupported* {.bitsize:4.}: ULONG + MaxHeaderSizeSupported*: ULONG + PNDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD* = ptr NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD + NDIS_OFFLOAD* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Checksum*: NDIS_TCP_IP_CHECKSUM_OFFLOAD + LsoV1*: NDIS_TCP_LARGE_SEND_OFFLOAD_V1 + IPsecV1*: NDIS_IPSEC_OFFLOAD_V1 + LsoV2*: NDIS_TCP_LARGE_SEND_OFFLOAD_V2 + Flags*: ULONG + IPsecV2*: NDIS_IPSEC_OFFLOAD_V2 + Rsc*: NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD + EncapsulatedPacketTaskOffloadGre*: NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD + PNDIS_OFFLOAD* = ptr NDIS_OFFLOAD + NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1_IPv4* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + TcpOptions*: ULONG + IpOptions*: ULONG + NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1* {.pure.} = object + IPv4*: NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1_IPv4 + PNDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1* = ptr NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1 + NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv4Transmit* {.pure.} = object + Encapsulation*: ULONG + IpOptionsSupported*: ULONG + TcpOptionsSupported*: ULONG + TcpChecksum*: ULONG + UdpChecksum*: ULONG + IpChecksum*: ULONG + NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv4Receive* {.pure.} = object + Encapsulation*: ULONG + IpOptionsSupported*: ULONG + TcpOptionsSupported*: ULONG + TcpChecksum*: ULONG + UdpChecksum*: ULONG + IpChecksum*: ULONG + NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv6Transmit* {.pure.} = object + Encapsulation*: ULONG + IpExtensionHeadersSupported*: ULONG + TcpOptionsSupported*: ULONG + TcpChecksum*: ULONG + UdpChecksum*: ULONG + NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv6Receive* {.pure.} = object + Encapsulation*: ULONG + IpExtensionHeadersSupported*: ULONG + TcpOptionsSupported*: ULONG + TcpChecksum*: ULONG + UdpChecksum*: ULONG + NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD* {.pure.} = object + IPv4Transmit*: NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv4Transmit + IPv4Receive*: NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv4Receive + IPv6Transmit*: NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv6Transmit + IPv6Receive*: NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD_IPv6Receive + PNDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD* = ptr NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD + NDIS_WMI_IPSEC_OFFLOAD_V1_Supported* {.pure.} = object + Encapsulation*: ULONG + AhEspCombined*: ULONG + TransportTunnelCombined*: ULONG + IPv4Options*: ULONG + Flags*: ULONG + NDIS_WMI_IPSEC_OFFLOAD_V1_IPv4AH* {.pure.} = object + Md5*: ULONG + Sha_1*: ULONG + Transport*: ULONG + Tunnel*: ULONG + Send*: ULONG + Receive*: ULONG + NDIS_WMI_IPSEC_OFFLOAD_V1_IPv4ESP* {.pure.} = object + Des*: ULONG + Reserved*: ULONG + TripleDes*: ULONG + NullEsp*: ULONG + Transport*: ULONG + Tunnel*: ULONG + Send*: ULONG + Receive*: ULONG + NDIS_WMI_IPSEC_OFFLOAD_V1* {.pure.} = object + Supported*: NDIS_WMI_IPSEC_OFFLOAD_V1_Supported + IPv4AH*: NDIS_WMI_IPSEC_OFFLOAD_V1_IPv4AH + IPv4ESP*: NDIS_WMI_IPSEC_OFFLOAD_V1_IPv4ESP + PNDIS_WMI_IPSEC_OFFLOAD_V1* = ptr NDIS_WMI_IPSEC_OFFLOAD_V1 + NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2_IPv4* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2_IPv6* {.pure.} = object + Encapsulation*: ULONG + MaxOffLoadSize*: ULONG + MinSegmentCount*: ULONG + IpExtensionHeadersSupported*: ULONG + TcpOptionsSupported*: ULONG + NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2* {.pure.} = object + IPv4*: NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2_IPv4 + IPv6*: NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2_IPv6 + PNDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2* = ptr NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2 + NDIS_WMI_OFFLOAD* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Checksum*: NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD + LsoV1*: NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1 + IPsecV1*: NDIS_WMI_IPSEC_OFFLOAD_V1 + LsoV2*: NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2 + Flags*: ULONG + IPsecV2*: NDIS_IPSEC_OFFLOAD_V2 + Rsc*: NDIS_TCP_RECV_SEG_COALESCE_OFFLOAD + EncapsulatedPacketTaskOffloadGre*: NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD + PNDIS_WMI_OFFLOAD* = ptr NDIS_WMI_OFFLOAD + NDIS_TCP_CONNECTION_OFFLOAD* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Encapsulation*: ULONG + SupportIPv4* {.bitsize:2.}: ULONG + SupportIPv6* {.bitsize:2.}: ULONG + SupportIPv6ExtensionHeaders* {.bitsize:2.}: ULONG + SupportSack* {.bitsize:2.}: ULONG + CongestionAlgorithm* {.bitsize:4.}: ULONG + TcpConnectionOffloadCapacity*: ULONG + Flags*: ULONG + PNDIS_TCP_CONNECTION_OFFLOAD* = ptr NDIS_TCP_CONNECTION_OFFLOAD + NDIS_WMI_TCP_CONNECTION_OFFLOAD* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Encapsulation*: ULONG + SupportIPv4*: ULONG + SupportIPv6*: ULONG + SupportIPv6ExtensionHeaders*: ULONG + SupportSack*: ULONG + TcpConnectionOffloadCapacity*: ULONG + Flags*: ULONG + PNDIS_WMI_TCP_CONNECTION_OFFLOAD* = ptr NDIS_WMI_TCP_CONNECTION_OFFLOAD + NDIS_PORT_CONTROLL_STATE* = NDIS_PORT_CONTROL_STATE + PNDIS_PORT_CONTROLL_STATE* = PNDIS_PORT_CONTROL_STATE + NDIS_PORT_AUTHENTICATION_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + SendControlState*: NDIS_PORT_CONTROL_STATE + RcvControlState*: NDIS_PORT_CONTROL_STATE + SendAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + RcvAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + PNDIS_PORT_AUTHENTICATION_PARAMETERS* = ptr NDIS_PORT_AUTHENTICATION_PARAMETERS + NDIS_WMI_METHOD_HEADER* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + PortNumber*: NDIS_PORT_NUMBER + NetLuid*: NET_LUID + RequestId*: ULONG64 + Timeout*: ULONG + Padding*: array[4, UCHAR] + PNDIS_WMI_METHOD_HEADER* = ptr NDIS_WMI_METHOD_HEADER + NDIS_WMI_SET_HEADER* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + PortNumber*: NDIS_PORT_NUMBER + NetLuid*: NET_LUID + RequestId*: ULONG64 + Timeout*: ULONG + Padding*: array[4, UCHAR] + PNDIS_WMI_SET_HEADER* = ptr NDIS_WMI_SET_HEADER + NDIS_WMI_EVENT_HEADER* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + IfIndex*: NET_IFINDEX + NetLuid*: NET_LUID + RequestId*: ULONG64 + PortNumber*: NDIS_PORT_NUMBER + DeviceNameLength*: ULONG + DeviceNameOffset*: ULONG + Padding*: array[4, UCHAR] + PNDIS_WMI_EVENT_HEADER* = ptr NDIS_WMI_EVENT_HEADER + NDIS_WMI_ENUM_ADAPTER* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + IfIndex*: NET_IFINDEX + NetLuid*: NET_LUID + DeviceNameLength*: USHORT + DeviceName*: array[1, CHAR] + PNDIS_WMI_ENUM_ADAPTER* = ptr NDIS_WMI_ENUM_ADAPTER + NDIS_HD_SPLIT_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + HDSplitCombineFlags*: ULONG + PNDIS_HD_SPLIT_PARAMETERS* = ptr NDIS_HD_SPLIT_PARAMETERS + NDIS_HD_SPLIT_CURRENT_CONFIG* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + HardwareCapabilities*: ULONG + CurrentCapabilities*: ULONG + HDSplitFlags*: ULONG + HDSplitCombineFlags*: ULONG + BackfillSize*: ULONG + MaxHeaderSize*: ULONG + PNDIS_HD_SPLIT_CURRENT_CONFIG* = ptr NDIS_HD_SPLIT_CURRENT_CONFIG + NDIS_WMI_OUTPUT_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SupportedRevision*: UCHAR + DataOffset*: ULONG + PNDIS_WMI_OUTPUT_INFO* = ptr NDIS_WMI_OUTPUT_INFO +const + NDIS_PM_MAX_STRING_SIZE* = 64 +type + NDIS_PM_COUNTED_STRING* {.pure.} = object + Length*: USHORT + String*: array[NDIS_PM_MAX_STRING_SIZE + 1, WCHAR] + PNDIS_PM_COUNTED_STRING* = ptr NDIS_PM_COUNTED_STRING + NDIS_PM_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SupportedWoLPacketPatterns*: ULONG + NumTotalWoLPatterns*: ULONG + MaxWoLPatternSize*: ULONG + MaxWoLPatternOffset*: ULONG + MaxWoLPacketSaveBuffer*: ULONG + SupportedProtocolOffloads*: ULONG + NumArpOffloadIPv4Addresses*: ULONG + NumNSOffloadIPv6Addresses*: ULONG + MinMagicPacketWakeUp*: NDIS_DEVICE_POWER_STATE + MinPatternWakeUp*: NDIS_DEVICE_POWER_STATE + MinLinkChangeWakeUp*: NDIS_DEVICE_POWER_STATE + SupportedWakeUpEvents*: ULONG + MediaSpecificWakeUpEvents*: ULONG + PNDIS_PM_CAPABILITIES* = ptr NDIS_PM_CAPABILITIES + NDIS_PM_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + EnabledWoLPacketPatterns*: ULONG + EnabledProtocolOffloads*: ULONG + WakeUpFlags*: ULONG + MediaSpecificWakeUpEvents*: ULONG + PNDIS_PM_PARAMETERS* = ptr NDIS_PM_PARAMETERS + NDIS_PM_WOL_PATTERN_WoLPattern_IPv4TcpSynParameters* {.pure.} = object + Flags*: ULONG + IPv4SourceAddress*: array[4, UCHAR] + IPv4DestAddress*: array[4, UCHAR] + TCPSourcePortNumber*: USHORT + TCPDestPortNumber*: USHORT + NDIS_PM_WOL_PATTERN_WoLPattern_IPv6TcpSynParameters* {.pure.} = object + Flags*: ULONG + IPv6SourceAddress*: array[16, UCHAR] + IPv6DestAddress*: array[16, UCHAR] + TCPSourcePortNumber*: USHORT + TCPDestPortNumber*: USHORT + NDIS_PM_WOL_PATTERN_WoLPattern_EapolRequestIdMessageParameters* {.pure.} = object + Flags*: ULONG + NDIS_PM_WOL_PATTERN_WoLPattern_WoLBitMapPattern* {.pure.} = object + Flags*: ULONG + MaskOffset*: ULONG + MaskSize*: ULONG + PatternOffset*: ULONG + PatternSize*: ULONG + NDIS_PM_WOL_PATTERN_WoLPattern* {.pure, union.} = object + IPv4TcpSynParameters*: NDIS_PM_WOL_PATTERN_WoLPattern_IPv4TcpSynParameters + IPv6TcpSynParameters*: NDIS_PM_WOL_PATTERN_WoLPattern_IPv6TcpSynParameters + EapolRequestIdMessageParameters*: NDIS_PM_WOL_PATTERN_WoLPattern_EapolRequestIdMessageParameters + WoLBitMapPattern*: NDIS_PM_WOL_PATTERN_WoLPattern_WoLBitMapPattern + NDIS_PM_WOL_PATTERN* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + Priority*: ULONG + WoLPacketType*: NDIS_PM_WOL_PACKET + FriendlyName*: NDIS_PM_COUNTED_STRING + PatternId*: ULONG + NextWoLPatternOffset*: ULONG + WoLPattern*: NDIS_PM_WOL_PATTERN_WoLPattern + PNDIS_PM_WOL_PATTERN* = ptr NDIS_PM_WOL_PATTERN + NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_IPv4ARPParameters* {.pure.} = object + Flags*: ULONG + RemoteIPv4Address*: array[4, UCHAR] + HostIPv4Address*: array[4, UCHAR] + MacAddress*: array[6, UCHAR] + NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_IPv6NSParameters* {.pure.} = object + Flags*: ULONG + RemoteIPv6Address*: array[16, UCHAR] + SolicitedNodeIPv6Address*: array[16, UCHAR] + MacAddress*: array[6, UCHAR] + TargetIPv6Addresses*: array[2, array[16, UCHAR]] +const + DOT11_RSN_KCK_LENGTH* = 16 + DOT11_RSN_KEK_LENGTH* = 16 +type + NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_Dot11RSNRekeyParameters* {.pure.} = object + Flags*: ULONG + KCK*: array[DOT11_RSN_KCK_LENGTH, UCHAR] + KEK*: array[DOT11_RSN_KEK_LENGTH, UCHAR] + KeyReplayCounter*: ULONGLONG + NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters* {.pure, union.} = object + IPv4ARPParameters*: NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_IPv4ARPParameters + IPv6NSParameters*: NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_IPv6NSParameters + Dot11RSNRekeyParameters*: NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters_Dot11RSNRekeyParameters + NDIS_PM_PROTOCOL_OFFLOAD* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + Priority*: ULONG + ProtocolOffloadType*: NDIS_PM_PROTOCOL_OFFLOAD_TYPE + FriendlyName*: NDIS_PM_COUNTED_STRING + ProtocolOffloadId*: ULONG + NextProtocolOffloadOffset*: ULONG + ProtocolOffloadParameters*: NDIS_PM_PROTOCOL_OFFLOAD_ProtocolOffloadParameters + PNDIS_PM_PROTOCOL_OFFLOAD* = ptr NDIS_PM_PROTOCOL_OFFLOAD + NDIS_PM_WAKE_REASON* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + WakeReason*: NDIS_PM_WAKE_REASON_TYPE + InfoBufferOffset*: ULONG + InfoBufferSize*: ULONG + PNDIS_PM_WAKE_REASON* = ptr NDIS_PM_WAKE_REASON + NDIS_PM_WAKE_PACKET* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PatternId*: ULONG + PatternFriendlyName*: NDIS_PM_COUNTED_STRING + OriginalPacketSize*: ULONG + SavedPacketSize*: ULONG + SavedPacketOffset*: ULONG + PNDIS_PM_WAKE_PACKET* = ptr NDIS_PM_WAKE_PACKET + NDIS_WMI_PM_ADMIN_CONFIG* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + WakeOnPattern*: NDIS_PM_ADMIN_CONFIG_STATE + WakeOnMagicPacket*: NDIS_PM_ADMIN_CONFIG_STATE + DeviceSleepOnDisconnect*: NDIS_PM_ADMIN_CONFIG_STATE + PMARPOffload*: NDIS_PM_ADMIN_CONFIG_STATE + PMNSOffload*: NDIS_PM_ADMIN_CONFIG_STATE + PMWiFiRekeyOffload*: NDIS_PM_ADMIN_CONFIG_STATE + PNDIS_WMI_PM_ADMIN_CONFIG* = ptr NDIS_WMI_PM_ADMIN_CONFIG + NDIS_WMI_PM_ACTIVE_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + WakeOnPattern*: NDIS_PM_CAPABILITY_STATE + WakeOnMagicPacket*: NDIS_PM_CAPABILITY_STATE + DeviceSleepOnDisconnect*: NDIS_PM_CAPABILITY_STATE + PMARPOffload*: NDIS_PM_CAPABILITY_STATE + PMNSOffload*: NDIS_PM_CAPABILITY_STATE + PMWiFiRekeyOffload*: NDIS_PM_CAPABILITY_STATE + PNDIS_WMI_PM_ACTIVE_CAPABILITIES* = ptr NDIS_WMI_PM_ACTIVE_CAPABILITIES + NDIS_RECEIVE_FILTER_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + EnabledFilterTypes*: ULONG + EnabledQueueTypes*: ULONG + NumQueues*: ULONG + SupportedQueueProperties*: ULONG + SupportedFilterTests*: ULONG + SupportedHeaders*: ULONG + SupportedMacHeaderFields*: ULONG + MaxMacHeaderFilters*: ULONG + MaxQueueGroups*: ULONG + MaxQueuesPerQueueGroup*: ULONG + MinLookaheadSplitSize*: ULONG + MaxLookaheadSplitSize*: ULONG + SupportedARPHeaderFields*: ULONG + SupportedIPv4HeaderFields*: ULONG + SupportedIPv6HeaderFields*: ULONG + SupportedUdpHeaderFields*: ULONG + MaxFieldTestsPerPacketCoalescingFilter*: ULONG + MaxPacketCoalescingFilters*: ULONG + NdisReserved*: ULONG + PNDIS_RECEIVE_FILTER_CAPABILITIES* = ptr NDIS_RECEIVE_FILTER_CAPABILITIES + NDIS_NIC_SWITCH_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + NdisReserved1*: ULONG + NumTotalMacAddresses*: ULONG + NumMacAddressesPerPort*: ULONG + NumVlansPerPort*: ULONG + NdisReserved2*: ULONG + NdisReserved3*: ULONG + NicSwitchCapabilities*: ULONG + MaxNumSwitches*: ULONG + MaxNumVPorts*: ULONG + NdisReserved4*: ULONG + MaxNumVFs*: ULONG + MaxNumQueuePairs*: ULONG + NdisReserved5*: ULONG + NdisReserved6*: ULONG + NdisReserved7*: ULONG + MaxNumQueuePairsPerNonDefaultVPort*: ULONG + NdisReserved8*: ULONG + NdisReserved9*: ULONG + NdisReserved10*: ULONG + NdisReserved11*: ULONG + NdisReserved12*: ULONG + MaxNumMacAddresses*: ULONG + NdisReserved13*: ULONG + NdisReserved14*: ULONG + NdisReserved15*: ULONG + NdisReserved16*: ULONG + NdisReserved17*: ULONG + PNDIS_NIC_SWITCH_CAPABILITIES* = ptr NDIS_NIC_SWITCH_CAPABILITIES + NDIS_RECEIVE_FILTER_GLOBAL_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + EnabledFilterTypes*: ULONG + EnabledQueueTypes*: ULONG + PNDIS_RECEIVE_FILTER_GLOBAL_PARAMETERS* = ptr NDIS_RECEIVE_FILTER_GLOBAL_PARAMETERS + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_HeaderField* {.pure, union.} = object + MacHeaderField*: NDIS_MAC_HEADER_FIELD + ArpHeaderField*: NDIS_ARP_HEADER_FIELD + IPv4HeaderField*: NDIS_IPV4_HEADER_FIELD + IPv6HeaderField*: NDIS_IPV6_HEADER_FIELD + UdpHeaderField*: NDIS_UDP_HEADER_FIELD + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_FieldValue* {.pure, union.} = object + FieldByteValue*: UCHAR + FieldShortValue*: USHORT + FieldLongValue*: ULONG + FieldLong64Value*: ULONG64 + FieldByteArrayValue*: array[16, UCHAR] + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_ResultValue* {.pure, union.} = object + ResultByteValue*: UCHAR + ResultShortValue*: USHORT + ResultLongValue*: ULONG + ResultLong64Value*: ULONG64 + ResultByteArrayValue*: array[16, UCHAR] + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FrameHeader*: NDIS_FRAME_HEADER + ReceiveFilterTest*: NDIS_RECEIVE_FILTER_TEST + HeaderField*: NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_HeaderField + FieldValue*: NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_FieldValue + ResultValue*: NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_ResultValue + PNDIS_RECEIVE_FILTER_FIELD_PARAMETERS* = ptr NDIS_RECEIVE_FILTER_FIELD_PARAMETERS + NDIS_RECEIVE_FILTER_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FilterType*: NDIS_RECEIVE_FILTER_TYPE + QueueId*: NDIS_RECEIVE_QUEUE_ID + FilterId*: NDIS_RECEIVE_FILTER_ID + FieldParametersArrayOffset*: ULONG + FieldParametersArrayNumElements*: ULONG + FieldParametersArrayElementSize*: ULONG + RequestedFilterIdBitCount*: ULONG + MaxCoalescingDelay*: ULONG + VPortId*: NDIS_NIC_SWITCH_VPORT_ID + PNDIS_RECEIVE_FILTER_PARAMETERS* = ptr NDIS_RECEIVE_FILTER_PARAMETERS + NDIS_RECEIVE_FILTER_CLEAR_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueId*: NDIS_RECEIVE_QUEUE_ID + FilterId*: NDIS_RECEIVE_FILTER_ID + PNDIS_RECEIVE_FILTER_CLEAR_PARAMETERS* = ptr NDIS_RECEIVE_FILTER_CLEAR_PARAMETERS + NDIS_QUEUE_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_QUEUE_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_VM_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_VM_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_VM_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_VM_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_PORT_PROPERTY_PROFILE_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_PORT_PROPERTY_PROFILE_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_PORT_PROPERTY_PROFILE_CDN_LABEL* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_PORT_PROPERTY_PROFILE_CDN_LABEL* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_PORT_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_PORT_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_PORT_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_PORT_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_NIC_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_NIC_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_NIC_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_NIC_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_SWITCH_EXTENSION_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_SWITCH_EXTENSION_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_VENDOR_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_VENDOR_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_RECEIVE_QUEUE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueType*: NDIS_RECEIVE_QUEUE_TYPE + QueueId*: NDIS_RECEIVE_QUEUE_ID + QueueGroupId*: NDIS_RECEIVE_QUEUE_GROUP_ID + ProcessorAffinity*: GROUP_AFFINITY + NumSuggestedReceiveBuffers*: ULONG + MSIXTableEntry*: ULONG + LookaheadSize*: ULONG + VmName*: NDIS_VM_NAME + QueueName*: NDIS_QUEUE_NAME + PortId*: ULONG + InterruptCoalescingDomainId*: ULONG + PNDIS_RECEIVE_QUEUE_PARAMETERS* = ptr NDIS_RECEIVE_QUEUE_PARAMETERS + NDIS_RECEIVE_QUEUE_FREE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueId*: NDIS_RECEIVE_QUEUE_ID + PNDIS_RECEIVE_QUEUE_FREE_PARAMETERS* = ptr NDIS_RECEIVE_QUEUE_FREE_PARAMETERS + NDIS_RECEIVE_QUEUE_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueType*: NDIS_RECEIVE_QUEUE_TYPE + QueueId*: NDIS_RECEIVE_QUEUE_ID + QueueGroupId*: NDIS_RECEIVE_QUEUE_GROUP_ID + QueueState*: NDIS_RECEIVE_QUEUE_OPERATIONAL_STATE + ProcessorAffinity*: GROUP_AFFINITY + NumSuggestedReceiveBuffers*: ULONG + MSIXTableEntry*: ULONG + LookaheadSize*: ULONG + VmName*: NDIS_VM_NAME + QueueName*: NDIS_QUEUE_NAME + NumFilters*: ULONG + InterruptCoalescingDomainId*: ULONG + PNDIS_RECEIVE_QUEUE_INFO* = ptr NDIS_RECEIVE_QUEUE_INFO + NDIS_RECEIVE_QUEUE_INFO_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_RECEIVE_QUEUE_INFO_ARRAY* = ptr NDIS_RECEIVE_QUEUE_INFO_ARRAY + NDIS_RECEIVE_FILTER_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FilterType*: NDIS_RECEIVE_FILTER_TYPE + FilterId*: NDIS_RECEIVE_FILTER_ID + PNDIS_RECEIVE_FILTER_INFO* = ptr NDIS_RECEIVE_FILTER_INFO + NDIS_RECEIVE_FILTER_INFO_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + QueueId*: NDIS_RECEIVE_QUEUE_ID + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + Flags*: ULONG + VPortId*: NDIS_NIC_SWITCH_VPORT_ID + PNDIS_RECEIVE_FILTER_INFO_ARRAY* = ptr NDIS_RECEIVE_FILTER_INFO_ARRAY + NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueId*: NDIS_RECEIVE_QUEUE_ID + CompletionStatus*: NDIS_STATUS + PNDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_PARAMETERS* = ptr NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_PARAMETERS + NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_ARRAY* = ptr NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_ARRAY + NDIS_RECEIVE_SCALE_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + CapabilitiesFlags*: ULONG + NumberOfInterruptMessages*: ULONG + NumberOfReceiveQueues*: ULONG + NumberOfIndirectionTableEntries*: USHORT + PNDIS_RECEIVE_SCALE_CAPABILITIES* = ptr NDIS_RECEIVE_SCALE_CAPABILITIES + NDIS_RECEIVE_SCALE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: USHORT + BaseCpuNumber*: USHORT + HashInformation*: ULONG + IndirectionTableSize*: USHORT + IndirectionTableOffset*: ULONG + HashSecretKeySize*: USHORT + HashSecretKeyOffset*: ULONG + ProcessorMasksOffset*: ULONG + NumberOfProcessorMasks*: ULONG + ProcessorMasksEntrySize*: ULONG + PNDIS_RECEIVE_SCALE_PARAMETERS* = ptr NDIS_RECEIVE_SCALE_PARAMETERS + NDIS_RECEIVE_HASH_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + HashInformation*: ULONG + HashSecretKeySize*: USHORT + HashSecretKeyOffset*: ULONG + PNDIS_RECEIVE_HASH_PARAMETERS* = ptr NDIS_RECEIVE_HASH_PARAMETERS + NDIS_RSS_PROCESSOR* {.pure.} = object + ProcNum*: PROCESSOR_NUMBER + PreferenceIndex*: USHORT + Reserved*: USHORT + PNDIS_RSS_PROCESSOR* = ptr NDIS_RSS_PROCESSOR + NDIS_RSS_PROCESSOR_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + RssBaseProcessor*: PROCESSOR_NUMBER + MaxNumRssProcessors*: ULONG + PreferredNumaNode*: USHORT + RssProcessorArrayOffset*: ULONG + RssProcessorCount*: ULONG + RssProcessorEntrySize*: ULONG + RssMaxProcessor*: PROCESSOR_NUMBER + RssProfile*: NDIS_RSS_PROFILE + PNDIS_RSS_PROCESSOR_INFO* = ptr NDIS_RSS_PROCESSOR_INFO + NDIS_PROCESSOR_INFO_EX* {.pure.} = object + ProcNum*: PROCESSOR_NUMBER + SocketId*: ULONG + CoreId*: ULONG + HyperThreadId*: ULONG + NodeId*: USHORT + NodeDistance*: USHORT + PNDIS_PROCESSOR_INFO_EX* = ptr NDIS_PROCESSOR_INFO_EX + NDIS_SYSTEM_PROCESSOR_INFO_EX* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + ProcessorVendor*: NDIS_PROCESSOR_VENDOR + NumSockets*: ULONG + NumCores*: ULONG + NumCoresPerSocket*: ULONG + MaxHyperThreadingProcsPerCore*: ULONG + ProcessorInfoOffset*: ULONG + NumberOfProcessors*: ULONG + ProcessorInfoEntrySize*: ULONG + PNDIS_SYSTEM_PROCESSOR_INFO_EX* = ptr NDIS_SYSTEM_PROCESSOR_INFO_EX + NDIS_HYPERVISOR_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PartitionType*: NDIS_HYPERVISOR_PARTITION_TYPE + PNDIS_HYPERVISOR_INFO* = ptr NDIS_HYPERVISOR_INFO + NDIS_WMI_GROUP_AFFINITY* {.pure.} = object + Mask*: ULONG64 + Group*: USHORT + Reserved*: array[3, USHORT] + PNDIS_WMI_GROUP_AFFINITY* = ptr NDIS_WMI_GROUP_AFFINITY + NDIS_WMI_RECEIVE_QUEUE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueType*: NDIS_RECEIVE_QUEUE_TYPE + QueueId*: NDIS_RECEIVE_QUEUE_ID + QueueGroupId*: NDIS_RECEIVE_QUEUE_GROUP_ID + ProcessorAffinity*: NDIS_WMI_GROUP_AFFINITY + NumSuggestedReceiveBuffers*: ULONG + MSIXTableEntry*: ULONG + LookaheadSize*: ULONG + VmName*: NDIS_VM_NAME + QueueName*: NDIS_QUEUE_NAME + PNDIS_WMI_RECEIVE_QUEUE_PARAMETERS* = ptr NDIS_WMI_RECEIVE_QUEUE_PARAMETERS + NDIS_WMI_RECEIVE_QUEUE_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + QueueType*: NDIS_RECEIVE_QUEUE_TYPE + QueueId*: NDIS_RECEIVE_QUEUE_ID + QueueGroupId*: NDIS_RECEIVE_QUEUE_GROUP_ID + QueueState*: NDIS_RECEIVE_QUEUE_OPERATIONAL_STATE + ProcessorAffinity*: NDIS_WMI_GROUP_AFFINITY + NumSuggestedReceiveBuffers*: ULONG + MSIXTableEntry*: ULONG + LookaheadSize*: ULONG + VmName*: NDIS_VM_NAME + QueueName*: NDIS_QUEUE_NAME + PNDIS_WMI_RECEIVE_QUEUE_INFO* = ptr NDIS_WMI_RECEIVE_QUEUE_INFO + NDIS_NDK_PERFORMANCE_COUNTERS* {.pure.} = object + Connect*: ULONG64 + Accept*: ULONG64 + ConnectFailure*: ULONG64 + ConnectionError*: ULONG64 + ActiveConnection*: ULONG64 + Reserved01*: ULONG64 + Reserved02*: ULONG64 + Reserved03*: ULONG64 + Reserved04*: ULONG64 + Reserved05*: ULONG64 + Reserved06*: ULONG64 + Reserved07*: ULONG64 + Reserved08*: ULONG64 + Reserved09*: ULONG64 + Reserved10*: ULONG64 + Reserved11*: ULONG64 + Reserved12*: ULONG64 + Reserved13*: ULONG64 + Reserved14*: ULONG64 + Reserved15*: ULONG64 + Reserved16*: ULONG64 + Reserved17*: ULONG64 + Reserved18*: ULONG64 + Reserved19*: ULONG64 + Reserved20*: ULONG64 + CQError*: ULONG64 + RDMAInOctets*: ULONG64 + RDMAOutOctets*: ULONG64 + RDMAInFrames*: ULONG64 + RDMAOutFrames*: ULONG64 + PNDIS_NDK_PERFORMANCE_COUNTERS* = ptr NDIS_NDK_PERFORMANCE_COUNTERS + NDK_VERSION* {.pure.} = object + Major*: USHORT + Minor*: USHORT + NDK_ADAPTER_INFO* {.pure.} = object + Version*: NDK_VERSION + VendorId*: UINT32 + DeviceId*: UINT32 + MaxRegistrationSize*: SIZE_T + MaxWindowSize*: SIZE_T + FRMRPageCount*: ULONG + MaxInitiatorRequestSge*: ULONG + MaxReceiveRequestSge*: ULONG + MaxReadRequestSge*: ULONG + MaxTransferLength*: ULONG + MaxInlineDataSize*: ULONG + MaxInboundReadLimit*: ULONG + MaxOutboundReadLimit*: ULONG + MaxReceiveQueueDepth*: ULONG + MaxInitiatorQueueDepth*: ULONG + MaxSrqDepth*: ULONG + MaxCqDepth*: ULONG + LargeRequestThreshold*: ULONG + MaxCallerData*: ULONG + MaxCalleeData*: ULONG + AdapterFlags*: ULONG + NDIS_NDK_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + MaxQpCount*: ULONG + MaxCqCount*: ULONG + MaxMrCount*: ULONG + MaxPdCount*: ULONG + MaxInboundReadLimit*: ULONG + MaxOutboundReadLimit*: ULONG + MaxMwCount*: ULONG + MaxSrqCount*: ULONG + MissingCounterMask*: ULONG64 + NdkInfo*: ptr NDK_ADAPTER_INFO + PNDIS_NDK_CAPABILITIES* = ptr NDIS_NDK_CAPABILITIES + NDK_WMI_ADAPTER_INFO* {.pure.} = object + Version*: NDK_VERSION + VendorId*: UINT32 + DeviceId*: UINT32 + MaxRegistrationSize*: ULONGLONG + MaxWindowSize*: ULONGLONG + FRMRPageCount*: ULONG + MaxInitiatorRequestSge*: ULONG + MaxReceiveRequestSge*: ULONG + MaxReadRequestSge*: ULONG + MaxTransferLength*: ULONG + MaxInlineDataSize*: ULONG + MaxInboundReadLimit*: ULONG + MaxOutboundReadLimit*: ULONG + MaxReceiveQueueDepth*: ULONG + MaxInitiatorQueueDepth*: ULONG + MaxSrqDepth*: ULONG + MaxCqDepth*: ULONG + LargeRequestThreshold*: ULONG + MaxCallerData*: ULONG + MaxCalleeData*: ULONG + AdapterFlags*: ULONG + PNDK_WMI_ADAPTER_INFO* = ptr NDK_WMI_ADAPTER_INFO + NDIS_WMI_NDK_CAPABILITIES* {.pure.} = object + MaxQpCount*: ULONG + MaxCqCount*: ULONG + MaxMrCount*: ULONG + MaxPdCount*: ULONG + MaxInboundReadLimit*: ULONG + MaxOutboundReadLimit*: ULONG + MaxMwCount*: ULONG + MaxSrqCount*: ULONG + MissingCounterMask*: ULONG64 + NdkInfo*: NDK_WMI_ADAPTER_INFO + PNDIS_WMI_NDK_CAPABILITIES* = ptr NDIS_WMI_NDK_CAPABILITIES + NDIS_QOS_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + MaxNumTrafficClasses*: ULONG + MaxNumEtsCapableTrafficClasses*: ULONG + MaxNumPfcEnabledTrafficClasses*: ULONG + PNDIS_QOS_CAPABILITIES* = ptr NDIS_QOS_CAPABILITIES + NDIS_QOS_CLASSIFICATION_ELEMENT* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + ConditionSelector*: USHORT + ConditionField*: USHORT + ActionSelector*: USHORT + ActionField*: USHORT + PNDIS_QOS_CLASSIFICATION_ELEMENT* = ptr NDIS_QOS_CLASSIFICATION_ELEMENT +const + NDIS_QOS_MAXIMUM_PRIORITIES* = 8 + NDIS_QOS_MAXIMUM_TRAFFIC_CLASSES* = 8 +type + NDIS_QOS_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + NumTrafficClasses*: ULONG + PriorityAssignmentTable*: array[NDIS_QOS_MAXIMUM_PRIORITIES, UCHAR] + TcBandwidthAssignmentTable*: array[NDIS_QOS_MAXIMUM_TRAFFIC_CLASSES, UCHAR] + TsaAssignmentTable*: array[NDIS_QOS_MAXIMUM_TRAFFIC_CLASSES, UCHAR] + PfcEnable*: ULONG + NumClassificationElements*: ULONG + ClassificationElementSize*: ULONG + FirstClassificationElementOffset*: ULONG + PNDIS_QOS_PARAMETERS* = ptr NDIS_QOS_PARAMETERS + NDIS_NIC_SWITCH_FRIENDLYNAME* = NDIS_IF_COUNTED_STRING + PNDIS_NIC_SWITCH_FRIENDLYNAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_VPORT_NAME* = NDIS_IF_COUNTED_STRING + PNDIS_VPORT_NAME* = ptr NDIS_IF_COUNTED_STRING + NDIS_NIC_SWITCH_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchType*: NDIS_NIC_SWITCH_TYPE + SwitchId*: NDIS_NIC_SWITCH_ID + SwitchFriendlyName*: NDIS_NIC_SWITCH_FRIENDLYNAME + NumVFs*: ULONG + NdisReserved1*: ULONG + NdisReserved2*: ULONG + NdisReserved3*: ULONG + PNDIS_NIC_SWITCH_PARAMETERS* = ptr NDIS_NIC_SWITCH_PARAMETERS + NDIS_NIC_SWITCH_DELETE_SWITCH_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + PNDIS_NIC_SWITCH_DELETE_SWITCH_PARAMETERS* = ptr NDIS_NIC_SWITCH_DELETE_SWITCH_PARAMETERS + NDIS_NIC_SWITCH_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchType*: NDIS_NIC_SWITCH_TYPE + SwitchId*: NDIS_NIC_SWITCH_ID + SwitchFriendlyName*: NDIS_NIC_SWITCH_FRIENDLYNAME + NumVFs*: ULONG + NumAllocatedVFs*: ULONG + NumVPorts*: ULONG + NumActiveVPorts*: ULONG + NumQueuePairsForDefaultVPort*: ULONG + NumQueuePairsForNonDefaultVPorts*: ULONG + NumActiveDefaultVPortMacAddresses*: ULONG + NumActiveNonDefaultVPortMacAddresses*: ULONG + NumActiveDefaultVPortVlanIds*: ULONG + NumActiveNonDefaultVPortVlanIds*: ULONG + PNDIS_NIC_SWITCH_INFO* = ptr NDIS_NIC_SWITCH_INFO + NDIS_NIC_SWITCH_INFO_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_NIC_SWITCH_INFO_ARRAY* = ptr NDIS_NIC_SWITCH_INFO_ARRAY + NDIS_NIC_SWITCH_VPORT_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + VPortId*: NDIS_NIC_SWITCH_VPORT_ID + VPortName*: NDIS_VPORT_NAME + AttachedFunctionId*: NDIS_SRIOV_FUNCTION_ID + NumQueuePairs*: ULONG + InterruptModeration*: NDIS_NIC_SWITCH_VPORT_INTERRUPT_MODERATION + VPortState*: NDIS_NIC_SWITCH_VPORT_STATE + ProcessorAffinity*: GROUP_AFFINITY + LookaheadSize*: ULONG + PNDIS_NIC_SWITCH_VPORT_PARAMETERS* = ptr NDIS_NIC_SWITCH_VPORT_PARAMETERS + NDIS_NIC_SWITCH_DELETE_VPORT_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + VPortId*: NDIS_NIC_SWITCH_VPORT_ID + PNDIS_NIC_SWITCH_DELETE_VPORT_PARAMETERS* = ptr NDIS_NIC_SWITCH_DELETE_VPORT_PARAMETERS + NDIS_NIC_SWITCH_VPORT_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VPortId*: NDIS_NIC_SWITCH_VPORT_ID + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + VPortName*: NDIS_VPORT_NAME + AttachedFunctionId*: NDIS_SRIOV_FUNCTION_ID + NumQueuePairs*: ULONG + InterruptModeration*: NDIS_NIC_SWITCH_VPORT_INTERRUPT_MODERATION + VPortState*: NDIS_NIC_SWITCH_VPORT_STATE + ProcessorAffinity*: GROUP_AFFINITY + LookaheadSize*: ULONG + NumFilters*: ULONG + PNDIS_NIC_SWITCH_VPORT_INFO* = ptr NDIS_NIC_SWITCH_VPORT_INFO + NDIS_NIC_SWITCH_VPORT_INFO_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + AttachedFunctionId*: NDIS_SRIOV_FUNCTION_ID + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_NIC_SWITCH_VPORT_INFO_ARRAY* = ptr NDIS_NIC_SWITCH_VPORT_INFO_ARRAY +const + NDIS_MAX_PHYS_ADDRESS_LENGTH* = IF_MAX_PHYS_ADDRESS_LENGTH +type + NDIS_NIC_SWITCH_VF_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + VMName*: NDIS_VM_NAME + VMFriendlyName*: NDIS_VM_FRIENDLYNAME + NicName*: NDIS_SWITCH_NIC_NAME + MacAddressLength*: USHORT + PermanentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + CurrentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + VFId*: NDIS_SRIOV_FUNCTION_ID + RequestorId*: NDIS_VF_RID + PNDIS_NIC_SWITCH_VF_PARAMETERS* = ptr NDIS_NIC_SWITCH_VF_PARAMETERS + NDIS_NIC_SWITCH_FREE_VF_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + VFId*: NDIS_SRIOV_FUNCTION_ID + PNDIS_NIC_SWITCH_FREE_VF_PARAMETERS* = ptr NDIS_NIC_SWITCH_FREE_VF_PARAMETERS + NDIS_NIC_SWITCH_VF_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + VMName*: NDIS_VM_NAME + VMFriendlyName*: NDIS_VM_FRIENDLYNAME + NicName*: NDIS_SWITCH_NIC_NAME + MacAddressLength*: USHORT + PermanentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + CurrentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + VFId*: NDIS_SRIOV_FUNCTION_ID + RequestorId*: NDIS_VF_RID + PNDIS_NIC_SWITCH_VF_INFO* = ptr NDIS_NIC_SWITCH_VF_INFO + NDIS_NIC_SWITCH_VF_INFO_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchId*: NDIS_NIC_SWITCH_ID + FirstElementOffset*: ULONG + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_NIC_SWITCH_VF_INFO_ARRAY* = ptr NDIS_NIC_SWITCH_VF_INFO_ARRAY + NDIS_SRIOV_CAPABILITIES* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SriovCapabilities*: ULONG + PNDIS_SRIOV_CAPABILITIES* = ptr NDIS_SRIOV_CAPABILITIES + NDIS_SRIOV_READ_VF_CONFIG_SPACE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + Offset*: ULONG + Length*: ULONG + BufferOffset*: ULONG + PNDIS_SRIOV_READ_VF_CONFIG_SPACE_PARAMETERS* = ptr NDIS_SRIOV_READ_VF_CONFIG_SPACE_PARAMETERS + NDIS_SRIOV_WRITE_VF_CONFIG_SPACE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + Offset*: ULONG + Length*: ULONG + BufferOffset*: ULONG + PNDIS_SRIOV_WRITE_VF_CONFIG_SPACE_PARAMETERS* = ptr NDIS_SRIOV_WRITE_VF_CONFIG_SPACE_PARAMETERS + NDIS_SRIOV_READ_VF_CONFIG_BLOCK_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + BlockId*: ULONG + Length*: ULONG + BufferOffset*: ULONG + PNDIS_SRIOV_READ_VF_CONFIG_BLOCK_PARAMETERS* = ptr NDIS_SRIOV_READ_VF_CONFIG_BLOCK_PARAMETERS + NDIS_SRIOV_WRITE_VF_CONFIG_BLOCK_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + BlockId*: ULONG + Length*: ULONG + BufferOffset*: ULONG + PNDIS_SRIOV_WRITE_VF_CONFIG_BLOCK_PARAMETERS* = ptr NDIS_SRIOV_WRITE_VF_CONFIG_BLOCK_PARAMETERS + NDIS_SRIOV_RESET_VF_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + PNDIS_SRIOV_RESET_VF_PARAMETERS* = ptr NDIS_SRIOV_RESET_VF_PARAMETERS + NDIS_SRIOV_SET_VF_POWER_STATE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + PowerState*: NDIS_DEVICE_POWER_STATE + WakeEnable*: BOOLEAN + PNDIS_SRIOV_SET_VF_POWER_STATE_PARAMETERS* = ptr NDIS_SRIOV_SET_VF_POWER_STATE_PARAMETERS + NDIS_SRIOV_CONFIG_STATE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + BlockId*: ULONG + Length*: ULONG + PNDIS_SRIOV_CONFIG_STATE_PARAMETERS* = ptr NDIS_SRIOV_CONFIG_STATE_PARAMETERS + NDIS_SRIOV_VF_VENDOR_DEVICE_ID_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + VendorId*: USHORT + DeviceId*: USHORT + PNDIS_SRIOV_VF_VENDOR_DEVICE_ID_INFO* = ptr NDIS_SRIOV_VF_VENDOR_DEVICE_ID_INFO + NDIS_SRIOV_PROBED_BARS_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + BaseRegisterValuesOffset*: ULONG + PNDIS_SRIOV_PROBED_BARS_INFO* = ptr NDIS_SRIOV_PROBED_BARS_INFO + NDIS_RECEIVE_FILTER_MOVE_FILTER_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + FilterId*: NDIS_RECEIVE_FILTER_ID + SourceQueueId*: NDIS_RECEIVE_QUEUE_ID + SourceVPortId*: NDIS_NIC_SWITCH_VPORT_ID + DestQueueId*: NDIS_RECEIVE_QUEUE_ID + DestVPortId*: NDIS_NIC_SWITCH_VPORT_ID + PNDIS_RECEIVE_FILTER_MOVE_FILTER_PARAMETERS* = ptr NDIS_RECEIVE_FILTER_MOVE_FILTER_PARAMETERS + NDIS_SRIOV_BAR_RESOURCES_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + VFId*: NDIS_SRIOV_FUNCTION_ID + BarIndex*: USHORT + BarResourcesOffset*: ULONG + PNDIS_SRIOV_BAR_RESOURCES_INFO* = ptr NDIS_SRIOV_BAR_RESOURCES_INFO + NDIS_SRIOV_PF_LUID_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Luid*: LUID + PNDIS_SRIOV_PF_LUID_INFO* = ptr NDIS_SRIOV_PF_LUID_INFO + NDIS_SRIOV_VF_SERIAL_NUMBER_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + SerialNumber*: ULONG + PNDIS_SRIOV_VF_SERIAL_NUMBER_INFO* = ptr NDIS_SRIOV_VF_SERIAL_NUMBER_INFO + NDIS_SRIOV_VF_INVALIDATE_CONFIG_BLOCK_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + BlockMask*: ULONG64 + PNDIS_SRIOV_VF_INVALIDATE_CONFIG_BLOCK_INFO* = ptr NDIS_SRIOV_VF_INVALIDATE_CONFIG_BLOCK_INFO + NDIS_SWITCH_OBJECT_INSTANCE_ID* = GUID + PNDIS_SWITCH_OBJECT_INSTANCE_ID* = ptr GUID + NDIS_SWITCH_OBJECT_ID* = GUID + PNDIS_SWITCH_OBJECT_ID* = ptr GUID + NDIS_SWITCH_PORT_ID* = UINT32 + PNDIS_SWITCH_PORT_ID* = ptr UINT32 + NDIS_SWITCH_PORT_PROPERTY_SECURITY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + AllowMacSpoofing*: BOOLEAN + AllowIeeePriorityTag*: BOOLEAN + VirtualSubnetId*: UINT32 + AllowTeaming*: BOOLEAN + PNDIS_SWITCH_PORT_PROPERTY_SECURITY* = ptr NDIS_SWITCH_PORT_PROPERTY_SECURITY + NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_VlanProperties* {.pure.} = object + AccessVlanId*: UINT16 + NativeVlanId*: UINT16 + PruneVlanIdArray*: array[64, UINT64] + TrunkVlanIdArray*: array[64, UINT64] + NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties_UNION1* {.pure, union.} = object + SecondaryVlanId*: UINT16 + SecondaryVlanIdArray*: array[64, UINT64] + NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties* {.pure.} = object + PvlanMode*: NDIS_SWITCH_PORT_PVLAN_MODE + PrimaryVlanId*: UINT16 + union1*: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties_UNION1 + NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1* {.pure, union.} = object + VlanProperties*: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_VlanProperties + PvlanProperties*: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties + NDIS_SWITCH_PORT_PROPERTY_VLAN* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + OperationMode*: NDIS_SWITCH_PORT_VLAN_MODE + union1*: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1 + PNDIS_SWITCH_PORT_PROPERTY_VLAN* = ptr NDIS_SWITCH_PORT_PROPERTY_VLAN + NDIS_SWITCH_PORT_PROPERTY_PROFILE_PciLocation* {.pure.} = object + PciSegmentNumber* {.bitsize:16.}: UINT32 + PciBusNumber* {.bitsize:8.}: UINT32 + PciDeviceNumber* {.bitsize:5.}: UINT32 + PciFunctionNumber* {.bitsize:3.}: UINT32 + NDIS_SWITCH_PORT_PROPERTY_PROFILE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + ProfileName*: NDIS_SWITCH_PORT_PROPERTY_PROFILE_NAME + ProfileId*: GUID + VendorName*: NDIS_VENDOR_NAME + VendorId*: GUID + ProfileData*: UINT32 + NetCfgInstanceId*: GUID + PciLocation*: NDIS_SWITCH_PORT_PROPERTY_PROFILE_PciLocation + CdnLabelId*: UINT32 + CdnLabel*: NDIS_SWITCH_PORT_PROPERTY_PROFILE_CDN_LABEL + PNDIS_SWITCH_PORT_PROPERTY_PROFILE* = ptr NDIS_SWITCH_PORT_PROPERTY_PROFILE + NDIS_SWITCH_PORT_PROPERTY_CUSTOM* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + PNDIS_SWITCH_PORT_PROPERTY_CUSTOM* = ptr NDIS_SWITCH_PORT_PROPERTY_CUSTOM + NDIS_SWITCH_PORT_PROPERTY_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + PropertyType*: NDIS_SWITCH_PORT_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + PropertyVersion*: NDIS_SWITCH_OBJECT_VERSION + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + Reserved*: ULONG + PNDIS_SWITCH_PORT_PROPERTY_PARAMETERS* = ptr NDIS_SWITCH_PORT_PROPERTY_PARAMETERS + NDIS_SWITCH_PORT_PROPERTY_DELETE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + PropertyType*: NDIS_SWITCH_PORT_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + PNDIS_SWITCH_PORT_PROPERTY_DELETE_PARAMETERS* = ptr NDIS_SWITCH_PORT_PROPERTY_DELETE_PARAMETERS + NDIS_SWITCH_PORT_PROPERTY_ENUM_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + PropertyType*: NDIS_SWITCH_PORT_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + FirstPropertyOffset*: ULONG + NumProperties*: ULONG + Reserved*: USHORT + PNDIS_SWITCH_PORT_PROPERTY_ENUM_PARAMETERS* = ptr NDIS_SWITCH_PORT_PROPERTY_ENUM_PARAMETERS + NDIS_SWITCH_PORT_PROPERTY_ENUM_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyVersion*: NDIS_SWITCH_OBJECT_VERSION + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + QwordAlignedPropertyBufferLength*: ULONG + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + PNDIS_SWITCH_PORT_PROPERTY_ENUM_INFO* = ptr NDIS_SWITCH_PORT_PROPERTY_ENUM_INFO + NDIS_SWITCH_PORT_FEATURE_STATUS_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + FeatureStatusType*: NDIS_SWITCH_PORT_FEATURE_STATUS_TYPE + FeatureStatusId*: NDIS_SWITCH_OBJECT_ID + FeatureStatusVersion*: NDIS_SWITCH_OBJECT_VERSION + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + FeatureStatusInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + FeatureStatusBufferLength*: ULONG + FeatureStatusBufferOffset*: ULONG + Reserved*: ULONG + PNDIS_SWITCH_PORT_FEATURE_STATUS_PARAMETERS* = ptr NDIS_SWITCH_PORT_FEATURE_STATUS_PARAMETERS + NDIS_SWITCH_PORT_FEATURE_STATUS_CUSTOM* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FeatureStatusBufferLength*: ULONG + FeatureStatusBufferOffset*: ULONG + PNDIS_SWITCH_PORT_FEATURE_STATUS_CUSTOM* = ptr NDIS_SWITCH_PORT_FEATURE_STATUS_CUSTOM + NDIS_SWITCH_PROPERTY_CUSTOM* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + PNDIS_SWITCH_PROPERTY_CUSTOM* = ptr NDIS_SWITCH_PROPERTY_CUSTOM + NDIS_SWITCH_PROPERTY_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyType*: NDIS_SWITCH_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + PropertyVersion*: NDIS_SWITCH_OBJECT_VERSION + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + PNDIS_SWITCH_PROPERTY_PARAMETERS* = ptr NDIS_SWITCH_PROPERTY_PARAMETERS + NDIS_SWITCH_PROPERTY_DELETE_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyType*: NDIS_SWITCH_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + PNDIS_SWITCH_PROPERTY_DELETE_PARAMETERS* = ptr NDIS_SWITCH_PROPERTY_DELETE_PARAMETERS + NDIS_SWITCH_PROPERTY_ENUM_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + PropertyVersion*: NDIS_SWITCH_OBJECT_VERSION + QwordAlignedPropertyBufferLength*: ULONG + PropertyBufferLength*: ULONG + PropertyBufferOffset*: ULONG + PNDIS_SWITCH_PROPERTY_ENUM_INFO* = ptr NDIS_SWITCH_PROPERTY_ENUM_INFO + NDIS_SWITCH_PROPERTY_ENUM_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PropertyType*: NDIS_SWITCH_PROPERTY_TYPE + PropertyId*: NDIS_SWITCH_OBJECT_ID + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + FirstPropertyOffset*: ULONG + NumProperties*: ULONG + PNDIS_SWITCH_PROPERTY_ENUM_PARAMETERS* = ptr NDIS_SWITCH_PROPERTY_ENUM_PARAMETERS + NDIS_SWITCH_FEATURE_STATUS_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FeatureStatusType*: NDIS_SWITCH_FEATURE_STATUS_TYPE + FeatureStatusId*: NDIS_SWITCH_OBJECT_ID + FeatureStatusInstanceId*: NDIS_SWITCH_OBJECT_INSTANCE_ID + FeatureStatusVersion*: NDIS_SWITCH_OBJECT_VERSION + SerializationVersion*: NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION + FeatureStatusBufferOffset*: ULONG + FeatureStatusBufferLength*: ULONG + PNDIS_SWITCH_FEATURE_STATUS_PARAMETERS* = ptr NDIS_SWITCH_FEATURE_STATUS_PARAMETERS + NDIS_SWITCH_FEATURE_STATUS_CUSTOM* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FeatureStatusCustomBufferLength*: ULONG + FeatureStatusCustomBufferOffset*: ULONG + PNDIS_SWITCH_FEATURE_STATUS_CUSTOM* = ptr NDIS_SWITCH_FEATURE_STATUS_CUSTOM + NDIS_SWITCH_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SwitchName*: NDIS_SWITCH_NAME + SwitchFriendlyName*: NDIS_SWITCH_FRIENDLYNAME + NumSwitchPorts*: UINT32 + IsActive*: BOOLEAN + PNDIS_SWITCH_PARAMETERS* = ptr NDIS_SWITCH_PARAMETERS + NDIS_SWITCH_PORT_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + PortName*: NDIS_SWITCH_PORT_NAME + PortFriendlyName*: NDIS_SWITCH_PORT_FRIENDLYNAME + PortType*: NDIS_SWITCH_PORT_TYPE + IsValidationPort*: BOOLEAN + PortState*: NDIS_SWITCH_PORT_STATE + PNDIS_SWITCH_PORT_PARAMETERS* = ptr NDIS_SWITCH_PORT_PARAMETERS + NDIS_SWITCH_PORT_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FirstElementOffset*: USHORT + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_SWITCH_PORT_ARRAY* = ptr NDIS_SWITCH_PORT_ARRAY + NDIS_SWITCH_NIC_PARAMETERS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + NicName*: NDIS_SWITCH_NIC_NAME + NicFriendlyName*: NDIS_SWITCH_NIC_FRIENDLYNAME + PortId*: NDIS_SWITCH_PORT_ID + NicIndex*: NDIS_SWITCH_NIC_INDEX + NicType*: NDIS_SWITCH_NIC_TYPE + NicState*: NDIS_SWITCH_NIC_STATE + VmName*: NDIS_VM_NAME + VmFriendlyName*: NDIS_VM_FRIENDLYNAME + NetCfgInstanceId*: GUID + MTU*: ULONG + NumaNodeId*: USHORT + PermanentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + VMMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + CurrentMacAddress*: array[NDIS_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + VFAssigned*: BOOLEAN + PNDIS_SWITCH_NIC_PARAMETERS* = ptr NDIS_SWITCH_NIC_PARAMETERS + NDIS_SWITCH_NIC_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + FirstElementOffset*: USHORT + NumElements*: ULONG + ElementSize*: ULONG + PNDIS_SWITCH_NIC_ARRAY* = ptr NDIS_SWITCH_NIC_ARRAY + NDIS_OID_REQUEST* {.pure.} = object + PNDIS_OID_REQUEST* = ptr NDIS_OID_REQUEST + NDIS_SWITCH_NIC_OID_REQUEST* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + SourcePortId*: NDIS_SWITCH_PORT_ID + SourceNicIndex*: NDIS_SWITCH_NIC_INDEX + DestinationPortId*: NDIS_SWITCH_PORT_ID + DestinationNicIndex*: NDIS_SWITCH_NIC_INDEX + OidRequest*: PNDIS_OID_REQUEST + PNDIS_SWITCH_NIC_OID_REQUEST* = ptr NDIS_SWITCH_NIC_OID_REQUEST + NDIS_SWITCH_NIC_SAVE_STATE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + PortId*: NDIS_SWITCH_PORT_ID + NicIndex*: NDIS_SWITCH_NIC_INDEX + ExtensionId*: GUID + ExtensionFriendlyName*: NDIS_SWITCH_EXTENSION_FRIENDLYNAME + FeatureClassId*: GUID + SaveDataSize*: USHORT + SaveDataOffset*: USHORT + PNDIS_SWITCH_NIC_SAVE_STATE* = ptr NDIS_SWITCH_NIC_SAVE_STATE + NDIS_PORT_STATE* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + MediaConnectState*: NDIS_MEDIA_CONNECT_STATE + XmitLinkSpeed*: ULONG64 + RcvLinkSpeed*: ULONG64 + Direction*: NET_IF_DIRECTION_TYPE + SendControlState*: NDIS_PORT_CONTROL_STATE + RcvControlState*: NDIS_PORT_CONTROL_STATE + SendAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + RcvAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + Flags*: ULONG + PNDIS_PORT_STATE* = ptr NDIS_PORT_STATE + NDIS_PORT_CHARACTERISTICS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + PortNumber*: NDIS_PORT_NUMBER + Flags*: ULONG + Type*: NDIS_PORT_TYPE + MediaConnectState*: NDIS_MEDIA_CONNECT_STATE + XmitLinkSpeed*: ULONG64 + RcvLinkSpeed*: ULONG64 + Direction*: NET_IF_DIRECTION_TYPE + SendControlState*: NDIS_PORT_CONTROL_STATE + RcvControlState*: NDIS_PORT_CONTROL_STATE + SendAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + RcvAuthorizationState*: NDIS_PORT_AUTHORIZATION_STATE + PNDIS_PORT_CHARACTERISTICS* = ptr NDIS_PORT_CHARACTERISTICS + NDIS_PORT* {.pure.} = object + Next*: PNDIS_PORT + NdisReserved*: PVOID + MiniportReserved*: PVOID + ProtocolReserved*: PVOID + PortCharacteristics*: NDIS_PORT_CHARACTERISTICS + PNDIS_PORT* = ptr NDIS_PORT + NDIS_PORT_ARRAY* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + NumberOfPorts*: ULONG + OffsetFirstPort*: ULONG + ElementSize*: ULONG + Ports*: array[1, NDIS_PORT_CHARACTERISTICS] + PNDIS_PORT_ARRAY* = ptr NDIS_PORT_ARRAY + MIB_IF_ROW2_InterfaceAndOperStatusFlags* {.pure.} = object + HardwareInterface* {.bitsize:1.}: BOOLEAN + FilterInterface* {.bitsize:1.}: BOOLEAN + ConnectorPresent* {.bitsize:1.}: BOOLEAN + NotAuthenticated* {.bitsize:1.}: BOOLEAN + NotMediaConnected* {.bitsize:1.}: BOOLEAN + Paused* {.bitsize:1.}: BOOLEAN + LowPower* {.bitsize:1.}: BOOLEAN + EndPointInterface* {.bitsize:1.}: BOOLEAN + MIB_IF_ROW2* {.pure.} = object + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + InterfaceGuid*: GUID + Alias*: array[IF_MAX_STRING_SIZE + 1, WCHAR] + Description*: array[IF_MAX_STRING_SIZE + 1, WCHAR] + PhysicalAddressLength*: ULONG + PhysicalAddress*: array[IF_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + PermanentPhysicalAddress*: array[IF_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + Mtu*: ULONG + Type*: IFTYPE + TunnelType*: TUNNEL_TYPE + MediaType*: NDIS_MEDIUM + PhysicalMediumType*: NDIS_PHYSICAL_MEDIUM + AccessType*: NET_IF_ACCESS_TYPE + DirectionType*: NET_IF_DIRECTION_TYPE + InterfaceAndOperStatusFlags*: MIB_IF_ROW2_InterfaceAndOperStatusFlags + OperStatus*: IF_OPER_STATUS + AdminStatus*: NET_IF_ADMIN_STATUS + MediaConnectState*: NET_IF_MEDIA_CONNECT_STATE + NetworkGuid*: NET_IF_NETWORK_GUID + ConnectionType*: NET_IF_CONNECTION_TYPE + TransmitLinkSpeed*: ULONG64 + ReceiveLinkSpeed*: ULONG64 + InOctets*: ULONG64 + InUcastPkts*: ULONG64 + InNUcastPkts*: ULONG64 + InDiscards*: ULONG64 + InErrors*: ULONG64 + InUnknownProtos*: ULONG64 + InUcastOctets*: ULONG64 + InMulticastOctets*: ULONG64 + InBroadcastOctets*: ULONG64 + OutOctets*: ULONG64 + OutUcastPkts*: ULONG64 + OutNUcastPkts*: ULONG64 + OutDiscards*: ULONG64 + OutErrors*: ULONG64 + OutUcastOctets*: ULONG64 + OutMulticastOctets*: ULONG64 + OutBroadcastOctets*: ULONG64 + OutQLen*: ULONG64 + PMIB_IF_ROW2* = ptr MIB_IF_ROW2 + MIB_IF_TABLE2* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IF_ROW2] + PMIB_IF_TABLE2* = ptr MIB_IF_TABLE2 + MIB_IPINTERFACE_ROW* {.pure.} = object + Family*: ADDRESS_FAMILY + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + MaxReassemblySize*: ULONG + InterfaceIdentifier*: ULONG64 + MinRouterAdvertisementInterval*: ULONG + MaxRouterAdvertisementInterval*: ULONG + AdvertisingEnabled*: BOOLEAN + ForwardingEnabled*: BOOLEAN + WeakHostSend*: BOOLEAN + WeakHostReceive*: BOOLEAN + UseAutomaticMetric*: BOOLEAN + UseNeighborUnreachabilityDetection*: BOOLEAN + ManagedAddressConfigurationSupported*: BOOLEAN + OtherStatefulConfigurationSupported*: BOOLEAN + AdvertiseDefaultRoute*: BOOLEAN + RouterDiscoveryBehavior*: NL_ROUTER_DISCOVERY_BEHAVIOR + DadTransmits*: ULONG + BaseReachableTime*: ULONG + RetransmitTime*: ULONG + PathMtuDiscoveryTimeout*: ULONG + LinkLocalAddressBehavior*: NL_LINK_LOCAL_ADDRESS_BEHAVIOR + LinkLocalAddressTimeout*: ULONG + ZoneIndices*: array[scopeLevelCount, ULONG] + SitePrefixLength*: ULONG + Metric*: ULONG + NlMtu*: ULONG + Connected*: BOOLEAN + SupportsWakeUpPatterns*: BOOLEAN + SupportsNeighborDiscovery*: BOOLEAN + SupportsRouterDiscovery*: BOOLEAN + ReachableTime*: ULONG + TransmitOffload*: NL_INTERFACE_OFFLOAD_ROD + ReceiveOffload*: NL_INTERFACE_OFFLOAD_ROD + DisableDefaultRoutes*: BOOLEAN + PMIB_IPINTERFACE_ROW* = ptr MIB_IPINTERFACE_ROW + MIB_IPINTERFACE_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IPINTERFACE_ROW] + PMIB_IPINTERFACE_TABLE* = ptr MIB_IPINTERFACE_TABLE + MIB_IFSTACK_ROW* {.pure.} = object + HigherLayerInterfaceIndex*: NET_IFINDEX + LowerLayerInterfaceIndex*: NET_IFINDEX + PMIB_IFSTACK_ROW* = ptr MIB_IFSTACK_ROW + MIB_INVERTEDIFSTACK_ROW* {.pure.} = object + LowerLayerInterfaceIndex*: NET_IFINDEX + HigherLayerInterfaceIndex*: NET_IFINDEX + PMIB_INVERTEDIFSTACK_ROW* = ptr MIB_INVERTEDIFSTACK_ROW + MIB_IFSTACK_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IFSTACK_ROW] + PMIB_IFSTACK_TABLE* = ptr MIB_IFSTACK_TABLE + MIB_INVERTEDIFSTACK_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_INVERTEDIFSTACK_ROW] + PMIB_INVERTEDIFSTACK_TABLE* = ptr MIB_INVERTEDIFSTACK_TABLE + MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES* {.pure.} = object + InboundBandwidthInformation*: NL_BANDWIDTH_INFORMATION + OutboundBandwidthInformation*: NL_BANDWIDTH_INFORMATION + PMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES* = ptr MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES + MIB_UNICASTIPADDRESS_ROW* {.pure.} = object + Address*: SOCKADDR_INET + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + PrefixOrigin*: NL_PREFIX_ORIGIN + SuffixOrigin*: NL_SUFFIX_ORIGIN + ValidLifetime*: ULONG + PreferredLifetime*: ULONG + OnLinkPrefixLength*: UINT8 + SkipAsSource*: BOOLEAN + DadState*: NL_DAD_STATE + ScopeId*: SCOPE_ID + CreationTimeStamp*: LARGE_INTEGER + PMIB_UNICASTIPADDRESS_ROW* = ptr MIB_UNICASTIPADDRESS_ROW + MIB_UNICASTIPADDRESS_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_UNICASTIPADDRESS_ROW] + PMIB_UNICASTIPADDRESS_TABLE* = ptr MIB_UNICASTIPADDRESS_TABLE + MIB_ANYCASTIPADDRESS_ROW* {.pure.} = object + Address*: SOCKADDR_INET + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + ScopeId*: SCOPE_ID + PMIB_ANYCASTIPADDRESS_ROW* = ptr MIB_ANYCASTIPADDRESS_ROW + MIB_ANYCASTIPADDRESS_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_ANYCASTIPADDRESS_ROW] + PMIB_ANYCASTIPADDRESS_TABLE* = ptr MIB_ANYCASTIPADDRESS_TABLE + MIB_MULTICASTIPADDRESS_ROW* {.pure.} = object + Address*: SOCKADDR_INET + InterfaceIndex*: NET_IFINDEX + InterfaceLuid*: NET_LUID + ScopeId*: SCOPE_ID + PMIB_MULTICASTIPADDRESS_ROW* = ptr MIB_MULTICASTIPADDRESS_ROW + MIB_MULTICASTIPADDRESS_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_MULTICASTIPADDRESS_ROW] + PMIB_MULTICASTIPADDRESS_TABLE* = ptr MIB_MULTICASTIPADDRESS_TABLE + IP_ADDRESS_PREFIX* {.pure.} = object + Prefix*: SOCKADDR_INET + PrefixLength*: UINT8 + PIP_ADDRESS_PREFIX* = ptr IP_ADDRESS_PREFIX + MIB_IPFORWARD_ROW2* {.pure.} = object + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + DestinationPrefix*: IP_ADDRESS_PREFIX + NextHop*: SOCKADDR_INET + SitePrefixLength*: UCHAR + ValidLifetime*: ULONG + PreferredLifetime*: ULONG + Metric*: ULONG + Protocol*: NL_ROUTE_PROTOCOL + Loopback*: BOOLEAN + AutoconfigureAddress*: BOOLEAN + Publish*: BOOLEAN + Immortal*: BOOLEAN + Age*: ULONG + Origin*: NL_ROUTE_ORIGIN + PMIB_IPFORWARD_ROW2* = ptr MIB_IPFORWARD_ROW2 + MIB_IPFORWARD_TABLE2* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IPFORWARD_ROW2] + PMIB_IPFORWARD_TABLE2* = ptr MIB_IPFORWARD_TABLE2 + MIB_IPPATH_ROW_UNION1* {.pure, union.} = object + LastReachable*: ULONG + LastUnreachable*: ULONG + MIB_IPPATH_ROW* {.pure.} = object + Source*: SOCKADDR_INET + Destination*: SOCKADDR_INET + InterfaceLuid*: NET_LUID + InterfaceIndex*: NET_IFINDEX + CurrentNextHop*: SOCKADDR_INET + PathMtu*: ULONG + RttMean*: ULONG + RttDeviation*: ULONG + union1*: MIB_IPPATH_ROW_UNION1 + IsReachable*: BOOLEAN + LinkTransmitSpeed*: ULONG64 + LinkReceiveSpeed*: ULONG64 + PMIB_IPPATH_ROW* = ptr MIB_IPPATH_ROW + MIB_IPPATH_TABLE* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IPPATH_ROW] + PMIB_IPPATH_TABLE* = ptr MIB_IPPATH_TABLE + MIB_IPNET_ROW2_UNION1_STRUCT1* {.pure.} = object + IsRouter* {.bitsize:1.}: BOOLEAN + IsUnreachable* {.bitsize:1.}: BOOLEAN + MIB_IPNET_ROW2_UNION1* {.pure, union.} = object + struct1*: MIB_IPNET_ROW2_UNION1_STRUCT1 + Flags*: UCHAR + MIB_IPNET_ROW2_ReachabilityTime* {.pure, union.} = object + LastReachable*: ULONG + LastUnreachable*: ULONG + MIB_IPNET_ROW2* {.pure.} = object + Address*: SOCKADDR_INET + InterfaceIndex*: NET_IFINDEX + InterfaceLuid*: NET_LUID + PhysicalAddress*: array[IF_MAX_PHYS_ADDRESS_LENGTH, UCHAR] + PhysicalAddressLength*: ULONG + State*: NL_NEIGHBOR_STATE + union1*: MIB_IPNET_ROW2_UNION1 + ReachabilityTime*: MIB_IPNET_ROW2_ReachabilityTime + PMIB_IPNET_ROW2* = ptr MIB_IPNET_ROW2 + MIB_IPNET_TABLE2* {.pure.} = object + NumEntries*: ULONG + Table*: array[ANY_SIZE, MIB_IPNET_ROW2] + PMIB_IPNET_TABLE2* = ptr MIB_IPNET_TABLE2 + IPv6Addr* = IN6_ADDR + NETIO_STATUS* = NTSTATUS +const + nldsInvalid* = 0 + nldsTentative* = 1 + nldsDuplicate* = 2 + nldsDeprecated* = 3 + nldsPreferred* = 4 + ipDadStateInvalid* = 0 + ipDadStateTentative* = 1 + ipDadStateDuplicate* = 2 + ipDadStateDeprecated* = 3 + ipDadStatePreferred* = 4 + routeProtocolOther* = 1 + routeProtocolLocal* = 2 + routeProtocolNetMgmt* = 3 + routeProtocolIcmp* = 4 + routeProtocolEgp* = 5 + routeProtocolGgp* = 6 + routeProtocolHello* = 7 + routeProtocolRip* = 8 + routeProtocolIsIs* = 9 + routeProtocolEsIs* = 10 + routeProtocolCisco* = 11 + routeProtocolBbn* = 12 + routeProtocolOspf* = 13 + routeProtocolBgp* = 14 + OTHER* = 15 + LOCAL* = 16 + NETMGMT* = 17 + ICMP* = 18 + EGP* = 19 + GGP* = 20 + HELLO* = 21 + RIP* = 22 + IS_IS* = 23 + ES_IS* = 24 + CISCO* = 25 + BBN* = 26 + OSPF* = 27 + BGP* = 28 + NT_AUTOSTATIC* = 29 + NT_STATIC* = 30 + NT_STATIC_NON_DOD* = 31 + ipPrefixOriginOther* = 0 + ipPrefixOriginManual* = 1 + ipPrefixOriginWellKnown* = 2 + ipPrefixOriginDhcp* = 3 + ipPrefixOriginRouterAdvertisement* = 4 + ipPrefixOriginUnchanged* = 16 + nlsoOther* = 0 + nlsoManual* = 1 + nlsoWellKnown* = 2 + nlsoDhcp* = 3 + nlsoLinkLayerAddress* = 4 + nlsoRandom* = 5 + ipSuffixOriginOther* = 0 + ipSuffixOriginManual* = 1 + ipSuffixOriginWellKnown* = 2 + ipSuffixOriginDhcp* = 3 + ipSuffixOriginLinkLayerAddress* = 4 + ipSuffixOriginRandom* = 5 + ipSuffixOriginUnchanged* = 16 + nlatUnspecified* = 0 + nlatUnicast* = 1 + nlatAnycast* = 2 + nlatMulticast* = 3 + nlatBroadcast* = 4 + nlatInvalid* = 5 + nlroManual* = 0 + nlroWellKnown* = 1 + nlroDHCP* = 2 + nlroRouterAdvertisement* = 3 + nlro6to4* = 4 + nlnsUnreachable* = 0 + nlnsIncomplete* = 1 + nlnsProbe* = 2 + nlnsDelay* = 3 + nlnsStale* = 4 + nlnsReachable* = 5 + nlnsPermanent* = 6 + nlnsMaximum* = 7 + linkLocalAlwaysOff* = 0 + linkLocalDelayed* = 1 + linkLocalAlwaysOn* = 2 + linkLocalUnchanged* = -1 + routerDiscoveryDisabled* = 0 + routerDiscoveryEnabled* = 1 + routerDiscoveryDhcp* = 2 + routerDiscoveryUnchanged* = -1 + nlbwDisabled* = 0 + nlbwEnabled* = 1 + nlbwUnchanged* = -1 + nlincCategoryUnknown* = 0 + nlincPublic* = 1 + nlincPrivate* = 2 + nlincDomainAuthenticated* = 3 + nlincCategoryStateMax* = 4 + networkCategoryPublic* = 0 + networkCategoryPrivate* = 1 + networkCategoryDomainAuthenticated* = 2 + networkCategoryUnchanged* = -1 + networkCategoryUnknown* = -1 + nlpoOther* = ipPrefixOriginOther + nlpoManual* = ipPrefixOriginManual + nlpoWellKnown* = ipPrefixOriginWellKnown + nlpoDhcp* = ipPrefixOriginDhcp + nlpoRouterAdvertisement* = ipPrefixOriginRouterAdvertisement + NET_IF_CURRENT_SESSION* = ULONG(-1) + MIN_IF_TYPE* = 1 + IF_TYPE_OTHER* = 1 + IF_TYPE_REGULAR_1822* = 2 + IF_TYPE_HDH_1822* = 3 + IF_TYPE_DDN_X25* = 4 + IF_TYPE_RFC877_X25* = 5 + IF_TYPE_ETHERNET_CSMACD* = 6 + IF_TYPE_IS088023_CSMACD* = 7 + IF_TYPE_ISO88024_TOKENBUS* = 8 + IF_TYPE_ISO88025_TOKENRING* = 9 + IF_TYPE_ISO88026_MAN* = 10 + IF_TYPE_STARLAN* = 11 + IF_TYPE_PROTEON_10MBIT* = 12 + IF_TYPE_PROTEON_80MBIT* = 13 + IF_TYPE_HYPERCHANNEL* = 14 + IF_TYPE_FDDI* = 15 + IF_TYPE_LAP_B* = 16 + IF_TYPE_SDLC* = 17 + IF_TYPE_DS1* = 18 + IF_TYPE_E1* = 19 + IF_TYPE_BASIC_ISDN* = 20 + IF_TYPE_PRIMARY_ISDN* = 21 + IF_TYPE_PROP_POINT2POINT_SERIAL* = 22 + IF_TYPE_PPP* = 23 + IF_TYPE_SOFTWARE_LOOPBACK* = 24 + IF_TYPE_EON* = 25 + IF_TYPE_ETHERNET_3MBIT* = 26 + IF_TYPE_NSIP* = 27 + IF_TYPE_SLIP* = 28 + IF_TYPE_ULTRA* = 29 + IF_TYPE_DS3* = 30 + IF_TYPE_SIP* = 31 + IF_TYPE_FRAMERELAY* = 32 + IF_TYPE_RS232* = 33 + IF_TYPE_PARA* = 34 + IF_TYPE_ARCNET* = 35 + IF_TYPE_ARCNET_PLUS* = 36 + IF_TYPE_ATM* = 37 + IF_TYPE_MIO_X25* = 38 + IF_TYPE_SONET* = 39 + IF_TYPE_X25_PLE* = 40 + IF_TYPE_ISO88022_LLC* = 41 + IF_TYPE_LOCALTALK* = 42 + IF_TYPE_SMDS_DXI* = 43 + IF_TYPE_FRAMERELAY_SERVICE* = 44 + IF_TYPE_V35* = 45 + IF_TYPE_HSSI* = 46 + IF_TYPE_HIPPI* = 47 + IF_TYPE_MODEM* = 48 + IF_TYPE_AAL5* = 49 + IF_TYPE_SONET_PATH* = 50 + IF_TYPE_SONET_VT* = 51 + IF_TYPE_SMDS_ICIP* = 52 + IF_TYPE_PROP_VIRTUAL* = 53 + IF_TYPE_PROP_MULTIPLEXOR* = 54 + IF_TYPE_IEEE80212* = 55 + IF_TYPE_FIBRECHANNEL* = 56 + IF_TYPE_HIPPIINTERFACE* = 57 + IF_TYPE_FRAMERELAY_INTERCONNECT* = 58 + IF_TYPE_AFLANE_8023* = 59 + IF_TYPE_AFLANE_8025* = 60 + IF_TYPE_CCTEMUL* = 61 + IF_TYPE_FASTETHER* = 62 + IF_TYPE_ISDN* = 63 + IF_TYPE_V11* = 64 + IF_TYPE_V36* = 65 + IF_TYPE_G703_64K* = 66 + IF_TYPE_G703_2MB* = 67 + IF_TYPE_QLLC* = 68 + IF_TYPE_FASTETHER_FX* = 69 + IF_TYPE_CHANNEL* = 70 + IF_TYPE_IEEE80211* = 71 + IF_TYPE_IBM370PARCHAN* = 72 + IF_TYPE_ESCON* = 73 + IF_TYPE_DLSW* = 74 + IF_TYPE_ISDN_S* = 75 + IF_TYPE_ISDN_U* = 76 + IF_TYPE_LAP_D* = 77 + IF_TYPE_IPSWITCH* = 78 + IF_TYPE_RSRB* = 79 + IF_TYPE_ATM_LOGICAL* = 80 + IF_TYPE_DS0* = 81 + IF_TYPE_DS0_BUNDLE* = 82 + IF_TYPE_BSC* = 83 + IF_TYPE_ASYNC* = 84 + IF_TYPE_CNR* = 85 + IF_TYPE_ISO88025R_DTR* = 86 + IF_TYPE_EPLRS* = 87 + IF_TYPE_ARAP* = 88 + IF_TYPE_PROP_CNLS* = 89 + IF_TYPE_HOSTPAD* = 90 + IF_TYPE_TERMPAD* = 91 + IF_TYPE_FRAMERELAY_MPI* = 92 + IF_TYPE_X213* = 93 + IF_TYPE_ADSL* = 94 + IF_TYPE_RADSL* = 95 + IF_TYPE_SDSL* = 96 + IF_TYPE_VDSL* = 97 + IF_TYPE_ISO88025_CRFPRINT* = 98 + IF_TYPE_MYRINET* = 99 + IF_TYPE_VOICE_EM* = 100 + IF_TYPE_VOICE_FXO* = 101 + IF_TYPE_VOICE_FXS* = 102 + IF_TYPE_VOICE_ENCAP* = 103 + IF_TYPE_VOICE_OVERIP* = 104 + IF_TYPE_ATM_DXI* = 105 + IF_TYPE_ATM_FUNI* = 106 + IF_TYPE_ATM_IMA* = 107 + IF_TYPE_PPPMULTILINKBUNDLE* = 108 + IF_TYPE_IPOVER_CDLC* = 109 + IF_TYPE_IPOVER_CLAW* = 110 + IF_TYPE_STACKTOSTACK* = 111 + IF_TYPE_VIRTUALIPADDRESS* = 112 + IF_TYPE_MPC* = 113 + IF_TYPE_IPOVER_ATM* = 114 + IF_TYPE_ISO88025_FIBER* = 115 + IF_TYPE_TDLC* = 116 + IF_TYPE_GIGABITETHERNET* = 117 + IF_TYPE_HDLC* = 118 + IF_TYPE_LAP_F* = 119 + IF_TYPE_V37* = 120 + IF_TYPE_X25_MLP* = 121 + IF_TYPE_X25_HUNTGROUP* = 122 + IF_TYPE_TRANSPHDLC* = 123 + IF_TYPE_INTERLEAVE* = 124 + IF_TYPE_FAST* = 125 + IF_TYPE_IP* = 126 + IF_TYPE_DOCSCABLE_MACLAYER* = 127 + IF_TYPE_DOCSCABLE_DOWNSTREAM* = 128 + IF_TYPE_DOCSCABLE_UPSTREAM* = 129 + IF_TYPE_A12MPPSWITCH* = 130 + IF_TYPE_TUNNEL* = 131 + IF_TYPE_COFFEE* = 132 + IF_TYPE_CES* = 133 + IF_TYPE_ATM_SUBINTERFACE* = 134 + IF_TYPE_L2_VLAN* = 135 + IF_TYPE_L3_IPVLAN* = 136 + IF_TYPE_L3_IPXVLAN* = 137 + IF_TYPE_DIGITALPOWERLINE* = 138 + IF_TYPE_MEDIAMAILOVERIP* = 139 + IF_TYPE_DTM* = 140 + IF_TYPE_DCN* = 141 + IF_TYPE_IPFORWARD* = 142 + IF_TYPE_MSDSL* = 143 + IF_TYPE_IEEE1394* = 144 + IF_TYPE_RECEIVE_ONLY* = 145 + MAX_IF_TYPE* = 145 + IF_ACCESS_LOOPBACK* = 1 + IF_ACCESS_BROADCAST* = 2 + IF_ACCESS_POINTTOPOINT* = 3 + IF_ACCESS_POINTTOMULTIPOINT* = 4 + IF_CHECK_NONE* = 0x00 + IF_CHECK_MCAST* = 0x01 + IF_CHECK_SEND* = 0x02 + IF_CONNECTION_DEDICATED* = 1 + IF_CONNECTION_PASSIVE* = 2 + IF_CONNECTION_DEMAND* = 3 + IF_ADMIN_STATUS_UP* = 1 + IF_ADMIN_STATUS_DOWN* = 2 + IF_ADMIN_STATUS_TESTING* = 3 + IF_OPER_STATUS_NON_OPERATIONAL* = 0 + IF_OPER_STATUS_UNREACHABLE* = 1 + IF_OPER_STATUS_DISCONNECTED* = 2 + IF_OPER_STATUS_CONNECTING* = 3 + IF_OPER_STATUS_CONNECTED* = 4 + IF_OPER_STATUS_OPERATIONAL* = 5 + MIB_IF_TYPE_OTHER* = 1 + MIB_IF_TYPE_ETHERNET* = 6 + MIB_IF_TYPE_TOKENRING* = 9 + MIB_IF_TYPE_FDDI* = 15 + MIB_IF_TYPE_PPP* = 23 + MIB_IF_TYPE_LOOPBACK* = 24 + MIB_IF_TYPE_SLIP* = 28 + MIB_IF_ADMIN_STATUS_UP* = 1 + MIB_IF_ADMIN_STATUS_DOWN* = 2 + MIB_IF_ADMIN_STATUS_TESTING* = 3 + MIB_IF_OPER_STATUS_NON_OPERATIONAL* = 0 + MIB_IF_OPER_STATUS_UNREACHABLE* = 1 + MIB_IF_OPER_STATUS_DISCONNECTED* = 2 + MIB_IF_OPER_STATUS_CONNECTING* = 3 + MIB_IF_OPER_STATUS_CONNECTED* = 4 + MIB_IF_OPER_STATUS_OPERATIONAL* = 5 + tcpConnectionOffloadStateInHost* = 0 + tcpConnectionOffloadStateOffloading* = 1 + tcpConnectionOffloadStateOffloaded* = 2 + tcpConnectionOffloadStateUploading* = 3 + tcpConnectionOffloadStateMax* = 4 + IPRTRMGR_PID* = 10000 + IF_NUMBER* = 0 + IF_TABLE* = IF_NUMBER+1 + IF_ROW* = IF_TABLE+1 + IP_STATS* = IF_ROW+1 + IP_ADDRTABLE* = IP_STATS+1 + IP_ADDRROW* = IP_ADDRTABLE+1 + IP_FORWARDNUMBER* = IP_ADDRROW+1 + IP_FORWARDTABLE* = IP_FORWARDNUMBER+1 + IP_FORWARDROW* = IP_FORWARDTABLE+1 + IP_NETTABLE* = IP_FORWARDROW+1 + IP_NETROW* = IP_NETTABLE+1 + ICMP_STATS* = IP_NETROW+1 + TCP_STATS* = ICMP_STATS+1 + TCP_TABLE* = TCP_STATS+1 + TCP_ROW* = TCP_TABLE+1 + UDP_STATS* = TCP_ROW+1 + UDP_TABLE* = UDP_STATS+1 + UDP_ROW* = UDP_TABLE+1 + MCAST_MFE* = UDP_ROW+1 + MCAST_MFE_STATS* = MCAST_MFE+1 + BEST_IF* = MCAST_MFE_STATS+1 + BEST_ROUTE* = BEST_IF+1 + PROXY_ARP* = BEST_ROUTE+1 + MCAST_IF_ENTRY* = PROXY_ARP+1 + MCAST_GLOBAL* = MCAST_IF_ENTRY+1 + IF_STATUS* = MCAST_GLOBAL+1 + MCAST_BOUNDARY* = IF_STATUS+1 + MCAST_SCOPE* = MCAST_BOUNDARY+1 + DEST_MATCHING* = MCAST_SCOPE+1 + DEST_LONGER* = DEST_MATCHING+1 + DEST_SHORTER* = DEST_LONGER+1 + ROUTE_MATCHING* = DEST_SHORTER+1 + ROUTE_LONGER* = ROUTE_MATCHING+1 + ROUTE_SHORTER* = ROUTE_LONGER+1 + ROUTE_STATE* = ROUTE_SHORTER+1 + MCAST_MFE_STATS_EX* = ROUTE_STATE+1 + IP6_STATS* = MCAST_MFE_STATS_EX+1 + UDP6_STATS* = IP6_STATS+1 + TCP6_STATS* = UDP6_STATS+1 + NUMBER_OF_EXPORTED_VARIABLES* = TCP6_STATS+1 + ICMP6_DST_UNREACH* = 1 + ICMP6_PACKET_TOO_BIG* = 2 + ICMP6_TIME_EXCEEDED* = 3 + ICMP6_PARAM_PROB* = 4 + ICMP6_ECHO_REQUEST* = 128 + ICMP6_ECHO_REPLY* = 129 + ICMP6_MEMBERSHIP_QUERY* = 130 + ICMP6_MEMBERSHIP_REPORT* = 131 + ICMP6_MEMBERSHIP_REDUCTION* = 132 + ND_ROUTER_SOLICIT* = 133 + ND_ROUTER_ADVERT* = 134 + ND_NEIGHBOR_SOLICIT* = 135 + ND_NEIGHBOR_ADVERT* = 136 + ND_REDIRECT* = 137 + ICMP4_ECHO_REPLY* = 0 + ICMP4_DST_UNREACH* = 3 + ICMP4_SOURCE_QUENCH* = 4 + ICMP4_REDIRECT* = 5 + ICMP4_ECHO_REQUEST* = 8 + ICMP4_ROUTER_ADVERT* = 9 + ICMP4_ROUTER_SOLICIT* = 10 + ICMP4_TIME_EXCEEDED* = 11 + ICMP4_PARAM_PROB* = 12 + ICMP4_TIMESTAMP_REQUEST* = 13 + ICMP4_TIMESTAMP_REPLY* = 14 + ICMP4_MASK_REQUEST* = 17 + ICMP4_MASK_REPLY* = 18 + MIB_TCP_RTO_OTHER* = 1 + MIB_TCP_RTO_CONSTANT* = 2 + MIB_TCP_RTO_RSRE* = 3 + MIB_TCP_RTO_VANJ* = 4 + MIB_TCP_MAXCONN_DYNAMIC* = DWORD(-1) + TCP_TABLE_BASIC_LISTENER* = 0 + TCP_TABLE_BASIC_CONNECTIONS* = 1 + TCP_TABLE_BASIC_ALL* = 2 + TCP_TABLE_OWNER_PID_LISTENER* = 3 + TCP_TABLE_OWNER_PID_CONNECTIONS* = 4 + TCP_TABLE_OWNER_PID_ALL* = 5 + TCP_TABLE_OWNER_MODULE_LISTENER* = 6 + TCP_TABLE_OWNER_MODULE_CONNECTIONS* = 7 + TCP_TABLE_OWNER_MODULE_ALL* = 8 + MIB_TCP_STATE_CLOSED* = 1 + MIB_TCP_STATE_LISTEN* = 2 + MIB_TCP_STATE_SYN_SENT* = 3 + MIB_TCP_STATE_SYN_RCVD* = 4 + MIB_TCP_STATE_ESTAB* = 5 + MIB_TCP_STATE_FIN_WAIT1* = 6 + MIB_TCP_STATE_FIN_WAIT2* = 7 + MIB_TCP_STATE_CLOSE_WAIT* = 8 + MIB_TCP_STATE_CLOSING* = 9 + MIB_TCP_STATE_LAST_ACK* = 10 + MIB_TCP_STATE_TIME_WAIT* = 11 + MIB_TCP_STATE_DELETE_TCB* = 12 + MIB_SECURITY_TCP_SYN_ATTACK* = 0x00000001 + MIB_USE_CURRENT_TTL* = DWORD(-1) + MIB_USE_CURRENT_FORWARDING* = DWORD(-1) + MIB_IP_FORWARDING* = 1 + MIB_IP_NOT_FORWARDING* = 2 + MIB_IPADDR_PRIMARY* = 0x0001 + MIB_IPADDR_DYNAMIC* = 0x0004 + MIB_IPADDR_DISCONNECTED* = 0x0008 + MIB_IPADDR_DELETED* = 0x0040 + MIB_IPADDR_TRANSIENT* = 0x0080 + MIB_IPROUTE_TYPE_OTHER* = 1 + MIB_IPROUTE_TYPE_INVALID* = 2 + MIB_IPROUTE_TYPE_DIRECT* = 3 + MIB_IPROUTE_TYPE_INDIRECT* = 4 + MIB_IPROUTE_METRIC_UNUSED* = DWORD(-1) + MIB_IPPROTO_OTHER* = 1 + MIB_IPPROTO_LOCAL* = 2 + MIB_IPPROTO_NETMGMT* = 3 + MIB_IPPROTO_ICMP* = 4 + MIB_IPPROTO_EGP* = 5 + MIB_IPPROTO_GGP* = 6 + MIB_IPPROTO_HELLO* = 7 + MIB_IPPROTO_RIP* = 8 + MIB_IPPROTO_IS_IS* = 9 + MIB_IPPROTO_ES_IS* = 10 + MIB_IPPROTO_CISCO* = 11 + MIB_IPPROTO_BBN* = 12 + MIB_IPPROTO_OSPF* = 13 + MIB_IPPROTO_BGP* = 14 + MIB_IPPROTO_NT_AUTOSTATIC* = 10002 + MIB_IPPROTO_NT_STATIC* = 10006 + MIB_IPPROTO_NT_STATIC_NON_DOD* = 10007 + MIB_IPNET_TYPE_OTHER* = 1 + MIB_IPNET_TYPE_INVALID* = 2 + MIB_IPNET_TYPE_DYNAMIC* = 3 + MIB_IPNET_TYPE_STATIC* = 4 + UDP_TABLE_BASIC* = 0 + UDP_TABLE_OWNER_PID* = 1 + UDP_TABLE_OWNER_MODULE* = 2 + TCPIP_OWNER_MODULE_INFO_BASIC* = 0 + MAX_MIB_OFFSET* = 8 + IP_EXPORT_INCLUDED* = 1 + IP_STATUS_BASE* = 11000 + IP_SUCCESS* = 0 + IP_BUF_TOO_SMALL* = IP_STATUS_BASE+1 + IP_DEST_NET_UNREACHABLE* = IP_STATUS_BASE+2 + IP_DEST_HOST_UNREACHABLE* = IP_STATUS_BASE+3 + IP_DEST_PROT_UNREACHABLE* = IP_STATUS_BASE+4 + IP_DEST_PORT_UNREACHABLE* = IP_STATUS_BASE+5 + IP_NO_RESOURCES* = IP_STATUS_BASE+6 + IP_BAD_OPTION* = IP_STATUS_BASE+7 + IP_HW_ERROR* = IP_STATUS_BASE+8 + IP_PACKET_TOO_BIG* = IP_STATUS_BASE+9 + IP_REQ_TIMED_OUT* = IP_STATUS_BASE+10 + IP_BAD_REQ* = IP_STATUS_BASE+11 + IP_BAD_ROUTE* = IP_STATUS_BASE+12 + IP_TTL_EXPIRED_TRANSIT* = IP_STATUS_BASE+13 + IP_TTL_EXPIRED_REASSEM* = IP_STATUS_BASE+14 + IP_PARAM_PROBLEM* = IP_STATUS_BASE+15 + IP_SOURCE_QUENCH* = IP_STATUS_BASE+16 + IP_OPTION_TOO_BIG* = IP_STATUS_BASE+17 + IP_BAD_DESTINATION* = IP_STATUS_BASE+18 + IP_DEST_NO_ROUTE* = IP_STATUS_BASE+2 + IP_DEST_ADDR_UNREACHABLE* = IP_STATUS_BASE+3 + IP_DEST_PROHIBITED* = IP_STATUS_BASE+4 + IP_HOP_LIMIT_EXCEEDED* = IP_STATUS_BASE+13 + IP_REASSEMBLY_TIME_EXCEEDED* = IP_STATUS_BASE+14 + IP_PARAMETER_PROBLEM* = IP_STATUS_BASE+15 + IP_DEST_UNREACHABLE* = IP_STATUS_BASE+40 + IP_TIME_EXCEEDED* = IP_STATUS_BASE+41 + IP_BAD_HEADER* = IP_STATUS_BASE+42 + IP_UNRECOGNIZED_NEXT_HEADER* = IP_STATUS_BASE+43 + IP_ICMP_ERROR* = IP_STATUS_BASE+44 + IP_DEST_SCOPE_MISMATCH* = IP_STATUS_BASE+45 + IP_ADDR_DELETED* = IP_STATUS_BASE+19 + IP_SPEC_MTU_CHANGE* = IP_STATUS_BASE+20 + IP_MTU_CHANGE* = IP_STATUS_BASE+21 + IP_UNLOAD* = IP_STATUS_BASE+22 + IP_ADDR_ADDED* = IP_STATUS_BASE+23 + IP_MEDIA_CONNECT* = IP_STATUS_BASE+24 + IP_MEDIA_DISCONNECT* = IP_STATUS_BASE+25 + IP_BIND_ADAPTER* = IP_STATUS_BASE+26 + IP_UNBIND_ADAPTER* = IP_STATUS_BASE+27 + IP_DEVICE_DOES_NOT_EXIST* = IP_STATUS_BASE+28 + IP_DUPLICATE_ADDRESS* = IP_STATUS_BASE+29 + IP_INTERFACE_METRIC_CHANGE* = IP_STATUS_BASE+30 + IP_RECONFIG_SECFLTR* = IP_STATUS_BASE+31 + IP_NEGOTIATING_IPSEC* = IP_STATUS_BASE+32 + IP_INTERFACE_WOL_CAPABILITY_CHANGE* = IP_STATUS_BASE+33 + IP_DUPLICATE_IPADD* = IP_STATUS_BASE+34 + IP_NO_FURTHER_SENDS* = IP_STATUS_BASE+35 + IP_GENERAL_FAILURE* = IP_STATUS_BASE+50 + MAX_IP_STATUS* = IP_GENERAL_FAILURE + IP_PENDING* = IP_STATUS_BASE+255 + IP_FLAG_DF* = 0x2 + IP_OPT_EOL* = 0 + IP_OPT_NOP* = 1 + IP_OPT_SECURITY* = 0x82 + IP_OPT_LSRR* = 0x83 + IP_OPT_SSRR* = 0x89 + IP_OPT_RR* = 0x7 + IP_OPT_TS* = 0x44 + IP_OPT_SID* = 0x88 + IP_OPT_ROUTER_ALERT* = 0x94 + MAX_OPT_SIZE* = 40 + IOCTL_IP_RTCHANGE_NOTIFY_REQUEST* = 101 + IOCTL_IP_ADDCHANGE_NOTIFY_REQUEST* = 102 + IOCTL_ARP_SEND_REQUEST* = 103 + IOCTL_IP_INTERFACE_INFO* = 104 + IOCTL_IP_GET_BEST_INTERFACE* = 105 + IOCTL_IP_UNIDIRECTIONAL_ADAPTER_ADDRESS* = 106 + ifOperStatusUp* = 1 + ifOperStatusDown* = 2 + ifOperStatusTesting* = 3 + ifOperStatusUnknown* = 4 + ifOperStatusDormant* = 5 + ifOperStatusNotPresent* = 6 + ifOperStatusLowerLayerDown* = 7 + NET_IF_OPER_STATUS_UP* = 1 + NET_IF_OPER_STATUS_DOWN* = 2 + NET_IF_OPER_STATUS_TESTING* = 3 + NET_IF_OPER_STATUS_UNKNOWN* = 4 + NET_IF_OPER_STATUS_DORMANT* = 5 + NET_IF_OPER_STATUS_NOT_PRESENT* = 6 + NET_IF_OPER_STATUS_LOWER_LAYER_DOWN* = 7 + NET_IF_ADMIN_STATUS_UP* = 1 + NET_IF_ADMIN_STATUS_DOWN* = 2 + NET_IF_ADMIN_STATUS_TESTING* = 3 + mediaConnectStateUnknown* = 0 + mediaConnectStateConnected* = 1 + mediaConnectStateDisconnected* = 2 + NET_IF_ACCESS_LOOPBACK* = 1 + NET_IF_ACCESS_BROADCAST* = 2 + NET_IF_ACCESS_POINT_TO_POINT* = 3 + NET_IF_ACCESS_POINT_TO_MULTI_POINT* = 4 + NET_IF_ACCESS_MAXIMUM* = 5 + NET_IF_CONNECTION_DEDICATED* = 1 + NET_IF_CONNECTION_PASSIVE* = 2 + NET_IF_CONNECTION_DEMAND* = 3 + NET_IF_CONNECTION_MAXIMUM* = 4 + NET_IF_DIRECTION_SENDRECEIVE* = 0 + NET_IF_DIRECTION_SENDONLY* = 1 + NET_IF_DIRECTION_RECEIVEONLY* = 2 + NET_IF_DIRECTION_MAXIMUM* = 3 + mediaDuplexStateUnknown* = 0 + mediaDuplexStateHalf* = 1 + mediaDuplexStateFull* = 2 + TUNNEL_TYPE_NONE* = 0 + TUNNEL_TYPE_OTHER* = 1 + TUNNEL_TYPE_DIRECT* = 2 + TUNNEL_TYPE_6TO4* = 11 + TUNNEL_TYPE_ISATAP* = 13 + TUNNEL_TYPE_TEREDO* = 14 + TUNNEL_TYPE_IPHTTPS* = 15 + DEFAULT_MINIMUM_ENTITIES* = 32 + BROADCAST_NODETYPE* = 1 + PEER_TO_PEER_NODETYPE* = 2 + MIXED_NODETYPE* = 4 + HYBRID_NODETYPE* = 8 + IP_ADAPTER_ADDRESS_DNS_ELIGIBLE* = 0x01 + IP_ADAPTER_ADDRESS_TRANSIENT* = 0x02 + IP_ADAPTER_ADDRESS_PRIMARY* = 0x04 + IP_ADAPTER_DDNS_ENABLED* = 0x01 + IP_ADAPTER_REGISTER_ADAPTER_SUFFIX* = 0x02 + IP_ADAPTER_DHCP_ENABLED* = 0x04 + IP_ADAPTER_RECEIVE_ONLY* = 0x08 + IP_ADAPTER_NO_MULTICAST* = 0x10 + IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG* = 0x20 + IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED* = 0x40 + IP_ADAPTER_IPV4_ENABLED* = 0x80 + IP_ADAPTER_IPV6_ENABLED* = 0x100 + IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG* = 0x200 + GAA_FLAG_SKIP_UNICAST* = 0x0001 + GAA_FLAG_SKIP_ANYCAST* = 0x0002 + GAA_FLAG_SKIP_MULTICAST* = 0x0004 + GAA_FLAG_SKIP_DNS_SERVER* = 0x0008 + GAA_FLAG_INCLUDE_PREFIX* = 0x0010 + GAA_FLAG_SKIP_FRIENDLY_NAME* = 0x0020 + GAA_FLAG_INCLUDE_WINS_INFO* = 0x0040 + GAA_FLAG_INCLUDE_GATEWAYS* = 0x0080 + GAA_FLAG_INCLUDE_ALL_INTERFACES* = 0x0100 + GAA_FLAG_INCLUDE_ALL_COMPARTMENTS* = 0x0200 + GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER* = 0x0400 + tcpBoolOptDisabled* = 0 + tcpBoolOptEnabled* = 1 + tcpBoolOptUnchanged* = -1 + tcpConnectionEstatsSynOpts* = 0 + tcpConnectionEstatsData* = 1 + tcpConnectionEstatsSndCong* = 2 + tcpConnectionEstatsPath* = 3 + tcpConnectionEstatsSendBuff* = 4 + tcpConnectionEstatsRec* = 5 + tcpConnectionEstatsObsRec* = 6 + tcpConnectionEstatsBandwidth* = 7 + tcpConnectionEstatsFineRtt* = 8 + tcpConnectionEstatsMaximum* = 9 + NET_STRING_IPV4_ADDRESS* = 0x00000001 + NET_STRING_IPV4_SERVICE* = 0x00000002 + NET_STRING_IPV4_NETWORK* = 0x00000004 + NET_STRING_IPV6_ADDRESS* = 0x00000008 + NET_STRING_IPV6_ADDRESS_NO_SCOPE* = 0x00000010 + NET_STRING_IPV6_SERVICE* = 0x00000020 + NET_STRING_IPV6_SERVICE_NO_SCOPE* = 0x00000040 + NET_STRING_IPV6_NETWORK* = 0x00000080 + NET_STRING_NAMED_ADDRESS* = 0x00000100 + NET_STRING_NAMED_SERVICE* = 0x00000200 + NET_STRING_IP_ADDRESS* = NET_STRING_IPV4_ADDRESS or NET_STRING_IPV6_ADDRESS + NET_STRING_IP_ADDRESS_NO_SCOPE* = NET_STRING_IPV4_ADDRESS or NET_STRING_IPV6_ADDRESS_NO_SCOPE + NET_STRING_IP_SERVICE* = NET_STRING_IPV4_SERVICE or NET_STRING_IPV6_SERVICE + NET_STRING_IP_SERVICE_NO_SCOPE* = NET_STRING_IPV4_SERVICE or NET_STRING_IPV6_SERVICE_NO_SCOPE + NET_STRING_IP_NETWORK* = NET_STRING_IPV4_NETWORK or NET_STRING_IPV6_NETWORK + NET_STRING_ANY_ADDRESS* = NET_STRING_NAMED_ADDRESS or NET_STRING_IP_ADDRESS + NET_STRING_ANY_ADDRESS_NO_SCOPE* = NET_STRING_NAMED_ADDRESS or NET_STRING_IP_ADDRESS_NO_SCOPE + NET_STRING_ANY_SERVICE* = NET_STRING_NAMED_SERVICE or NET_STRING_IP_SERVICE + NET_STRING_ANY_SERVICE_NO_SCOPE* = NET_STRING_NAMED_SERVICE or NET_STRING_IP_SERVICE_NO_SCOPE + NET_ADDRESS_FORMAT_UNSPECIFIED* = 0 + NET_ADDRESS_DNS_NAME* = 1 + NET_ADDRESS_IPV4* = 2 + NET_ADDRESS_IPV6* = 3 + NDIS_IF_MAX_STRING_SIZE* = IF_MAX_STRING_SIZE + IF_NAMESIZE* = NDIS_IF_MAX_STRING_SIZE + mibParameterNotification* = 0 + mibAddInstance* = 1 + mibDeleteInstance* = 2 + mibInitialNotification* = 3 + DD_NDIS_DEVICE_NAME* = "\\Device\\UNKNOWN" + NDIS_OBJECT_TYPE_DEFAULT* = 0x80 + NDIS_OBJECT_TYPE_MINIPORT_INIT_PARAMETERS* = 0x81 + NDIS_OBJECT_TYPE_SG_DMA_DESCRIPTION* = 0x83 + NDIS_OBJECT_TYPE_MINIPORT_INTERRUPT* = 0x84 + NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES* = 0x85 + NDIS_OBJECT_TYPE_BIND_PARAMETERS* = 0x86 + NDIS_OBJECT_TYPE_OPEN_PARAMETERS* = 0x87 + NDIS_OBJECT_TYPE_RSS_CAPABILITIES* = 0x88 + NDIS_OBJECT_TYPE_RSS_PARAMETERS* = 0x89 + NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS* = 0x8a + NDIS_OBJECT_TYPE_FILTER_DRIVER_CHARACTERISTICS* = 0x8b + NDIS_OBJECT_TYPE_FILTER_PARTIAL_CHARACTERISTICS* = 0x8c + NDIS_OBJECT_TYPE_FILTER_ATTRIBUTES* = 0x8d + NDIS_OBJECT_TYPE_CLIENT_CHIMNEY_OFFLOAD_GENERIC_CHARACTERISTICS* = 0x8e + NDIS_OBJECT_TYPE_PROVIDER_CHIMNEY_OFFLOAD_GENERIC_CHARACTERISTICS* = 0x8f + NDIS_OBJECT_TYPE_CO_PROTOCOL_CHARACTERISTICS* = 0x90 + NDIS_OBJECT_TYPE_CO_MINIPORT_CHARACTERISTICS* = 0x91 + NDIS_OBJECT_TYPE_MINIPORT_PNP_CHARACTERISTICS* = 0x92 + NDIS_OBJECT_TYPE_CLIENT_CHIMNEY_OFFLOAD_CHARACTERISTICS* = 0x93 + NDIS_OBJECT_TYPE_PROVIDER_CHIMNEY_OFFLOAD_CHARACTERISTICS* = 0x94 + NDIS_OBJECT_TYPE_PROTOCOL_DRIVER_CHARACTERISTICS* = 0x95 + NDIS_OBJECT_TYPE_REQUEST_EX* = 0x96 + NDIS_OBJECT_TYPE_OID_REQUEST* = 0x96 + NDIS_OBJECT_TYPE_TIMER_CHARACTERISTICS* = 0x97 + NDIS_OBJECT_TYPE_STATUS_INDICATION* = 0x98 + NDIS_OBJECT_TYPE_FILTER_ATTACH_PARAMETERS* = 0x99 + NDIS_OBJECT_TYPE_FILTER_PAUSE_PARAMETERS* = 0x9a + NDIS_OBJECT_TYPE_FILTER_RESTART_PARAMETERS* = 0x9b + NDIS_OBJECT_TYPE_PORT_CHARACTERISTICS* = 0x9c + NDIS_OBJECT_TYPE_PORT_STATE* = 0x9d + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES* = 0x9e + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES* = 0x9f + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_OFFLOAD_ATTRIBUTES* = 0xa0 + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_NATIVE_802_11_ATTRIBUTES* = 0xa1 + NDIS_OBJECT_TYPE_RESTART_GENERAL_ATTRIBUTES* = 0xa2 + NDIS_OBJECT_TYPE_PROTOCOL_RESTART_PARAMETERS* = 0xa3 + NDIS_OBJECT_TYPE_MINIPORT_ADD_DEVICE_REGISTRATION_ATTRIBUTES* = 0xa4 + NDIS_OBJECT_TYPE_CO_CALL_MANAGER_OPTIONAL_HANDLERS* = 0xa5 + NDIS_OBJECT_TYPE_CO_CLIENT_OPTIONAL_HANDLERS* = 0xa6 + NDIS_OBJECT_TYPE_OFFLOAD* = 0xa7 + NDIS_OBJECT_TYPE_OFFLOAD_ENCAPSULATION* = 0xa8 + NDIS_OBJECT_TYPE_CONFIGURATION_OBJECT* = 0xa9 + NDIS_OBJECT_TYPE_DRIVER_WRAPPER_OBJECT* = 0xaa + NDIS_OBJECT_TYPE_HD_SPLIT_ATTRIBUTES* = 0xab + NDIS_OBJECT_TYPE_NSI_NETWORK_RW_STRUCT* = 0xac + NDIS_OBJECT_TYPE_NSI_COMPARTMENT_RW_STRUCT* = 0xad + NDIS_OBJECT_TYPE_NSI_INTERFACE_PERSIST_RW_STRUCT* = 0xae + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_HARDWARE_ASSIST_ATTRIBUTES* = 0xaf + NDIS_OBJECT_TYPE_SHARED_MEMORY_PROVIDER_CHARACTERISTICS* = 0xb0 + NDIS_OBJECT_TYPE_RSS_PROCESSOR_INFO* = 0xb1 + NDIS_OBJECT_TYPE_NDK_PROVIDER_CHARACTERISTICS* = 0xb2 + NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_NDK_ATTRIBUTES* = 0xb3 + NDIS_OBJECT_TYPE_MINIPORT_SS_CHARACTERISTICS* = 0xb4 + NDIS_OBJECT_TYPE_QOS_CAPABILITIES* = 0xb5 + NDIS_OBJECT_TYPE_QOS_PARAMETERS* = 0xb6 + NDIS_OBJECT_TYPE_QOS_CLASSIFICATION_ELEMENT* = 0xb7 + NDIS_OBJECT_TYPE_SWITCH_OPTIONAL_HANDLERS* = 0xb8 + NDIS_OBJECT_TYPE_IOCTL_OID_INFO* = 0xb9 + NDIS_OBJECT_TYPE_LBFO_DIAGNOSTIC_OID* = 0xba + ndisRequestQueryInformation* = 0 + ndisRequestSetInformation* = 1 + ndisRequestQueryStatistics* = 2 + ndisRequestOpen* = 3 + ndisRequestClose* = 4 + ndisRequestSend* = 5 + ndisRequestTransferData* = 6 + ndisRequestReset* = 7 + ndisRequestGeneric1* = 8 + ndisRequestGeneric2* = 9 + ndisRequestGeneric3* = 10 + ndisRequestGeneric4* = 11 + ndisRequestMethod* = 12 + NDIS_OBJECT_REVISION_1* = 1 + NDIS_STATISTICS_FLAGS_VALID_DIRECTED_FRAMES_RCV* = 0x00000001 + NDIS_STATISTICS_FLAGS_VALID_MULTICAST_FRAMES_RCV* = 0x00000002 + NDIS_STATISTICS_FLAGS_VALID_BROADCAST_FRAMES_RCV* = 0x00000004 + NDIS_STATISTICS_FLAGS_VALID_BYTES_RCV* = 0x00000008 + NDIS_STATISTICS_FLAGS_VALID_RCV_DISCARDS* = 0x00000010 + NDIS_STATISTICS_FLAGS_VALID_RCV_ERROR* = 0x00000020 + NDIS_STATISTICS_FLAGS_VALID_DIRECTED_FRAMES_XMIT* = 0x00000040 + NDIS_STATISTICS_FLAGS_VALID_MULTICAST_FRAMES_XMIT* = 0x00000080 + NDIS_STATISTICS_FLAGS_VALID_BROADCAST_FRAMES_XMIT* = 0x00000100 + NDIS_STATISTICS_FLAGS_VALID_BYTES_XMIT* = 0x00000200 + NDIS_STATISTICS_FLAGS_VALID_XMIT_ERROR* = 0x00000400 + NDIS_STATISTICS_FLAGS_VALID_XMIT_DISCARDS* = 0x00008000 + NDIS_STATISTICS_FLAGS_VALID_DIRECTED_BYTES_RCV* = 0x00010000 + NDIS_STATISTICS_FLAGS_VALID_MULTICAST_BYTES_RCV* = 0x00020000 + NDIS_STATISTICS_FLAGS_VALID_BROADCAST_BYTES_RCV* = 0x00040000 + NDIS_STATISTICS_FLAGS_VALID_DIRECTED_BYTES_XMIT* = 0x00080000 + NDIS_STATISTICS_FLAGS_VALID_MULTICAST_BYTES_XMIT* = 0x00100000 + NDIS_STATISTICS_FLAGS_VALID_BROADCAST_BYTES_XMIT* = 0x00200000 + NDIS_INTERRUPT_MODERATION_CHANGE_NEEDS_RESET* = 0x00000001 + NDIS_INTERRUPT_MODERATION_CHANGE_NEEDS_REINITIALIZE* = 0x00000002 + NDIS_STATISTICS_INFO_REVISION_1* = 1 + NDIS_INTERRUPT_MODERATION_PARAMETERS_REVISION_1* = 1 + NDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES_REVISION_1* = 1 + NDIS_OBJECT_TYPE_PCI_DEVICE_CUSTOM_PROPERTIES_REVISION_1* = 1 + NDIS_OBJECT_TYPE_PCI_DEVICE_CUSTOM_PROPERTIES_REVISION_2* = 2 + NDIS_RSC_STATISTICS_REVISION_1* = 1 + ndisInterruptModerationUnknown* = 0 + ndisInterruptModerationNotSupported* = 1 + ndisInterruptModerationEnabled* = 2 + ndisInterruptModerationDisabled* = 3 + OID_GEN_SUPPORTED_LIST* = 0x00010101 + OID_GEN_HARDWARE_STATUS* = 0x00010102 + OID_GEN_MEDIA_SUPPORTED* = 0x00010103 + OID_GEN_MEDIA_IN_USE* = 0x00010104 + OID_GEN_MAXIMUM_LOOKAHEAD* = 0x00010105 + OID_GEN_MAXIMUM_FRAME_SIZE* = 0x00010106 + OID_GEN_LINK_SPEED* = 0x00010107 + OID_GEN_TRANSMIT_BUFFER_SPACE* = 0x00010108 + OID_GEN_RECEIVE_BUFFER_SPACE* = 0x00010109 + OID_GEN_TRANSMIT_BLOCK_SIZE* = 0x0001010a + OID_GEN_RECEIVE_BLOCK_SIZE* = 0x0001010b + OID_GEN_VENDOR_ID* = 0x0001010c + OID_GEN_VENDOR_DESCRIPTION* = 0x0001010d + OID_GEN_CURRENT_PACKET_FILTER* = 0x0001010e + OID_GEN_CURRENT_LOOKAHEAD* = 0x0001010f + OID_GEN_DRIVER_VERSION* = 0x00010110 + OID_GEN_MAXIMUM_TOTAL_SIZE* = 0x00010111 + OID_GEN_PROTOCOL_OPTIONS* = 0x00010112 + OID_GEN_MAC_OPTIONS* = 0x00010113 + OID_GEN_MEDIA_CONNECT_STATUS* = 0x00010114 + OID_GEN_MAXIMUM_SEND_PACKETS* = 0x00010115 + OID_GEN_VENDOR_DRIVER_VERSION* = 0x00010116 + OID_GEN_SUPPORTED_GUIDS* = 0x00010117 + OID_GEN_NETWORK_LAYER_ADDRESSES* = 0x00010118 + OID_GEN_TRANSPORT_HEADER_OFFSET* = 0x00010119 + OID_GEN_MEDIA_CAPABILITIES* = 0x00010201 + OID_GEN_PHYSICAL_MEDIUM* = 0x00010202 + OID_GEN_RECEIVE_SCALE_CAPABILITIES* = 0x00010203 + OID_GEN_RECEIVE_SCALE_PARAMETERS* = 0x00010204 + OID_GEN_MAC_ADDRESS* = 0x00010205 + OID_GEN_MAX_LINK_SPEED* = 0x00010206 + OID_GEN_LINK_STATE* = 0x00010207 + OID_GEN_LINK_PARAMETERS* = 0x00010208 + OID_GEN_INTERRUPT_MODERATION* = 0x00010209 + OID_GEN_NDIS_RESERVED_3* = 0x0001020a + OID_GEN_NDIS_RESERVED_4* = 0x0001020b + OID_GEN_NDIS_RESERVED_5* = 0x0001020c + OID_GEN_ENUMERATE_PORTS* = 0x0001020d + OID_GEN_PORT_STATE* = 0x0001020e + OID_GEN_PORT_AUTHENTICATION_PARAMETERS* = 0x0001020f + OID_GEN_TIMEOUT_DPC_REQUEST_CAPABILITIES* = 0x00010210 + OID_GEN_PCI_DEVICE_CUSTOM_PROPERTIES* = 0x00010211 + OID_GEN_NDIS_RESERVED_6* = 0x00010212 + OID_GEN_PHYSICAL_MEDIUM_EX* = 0x00010213 + OID_GEN_MACHINE_NAME* = 0x0001021a + OID_GEN_RNDIS_CONFIG_PARAMETER* = 0x0001021b + OID_GEN_VLAN_ID* = 0x0001021c + OID_GEN_RECEIVE_HASH* = 0x0001021f + OID_GEN_MINIPORT_RESTART_ATTRIBUTES* = 0x0001021d + OID_GEN_HD_SPLIT_PARAMETERS* = 0x0001021e + OID_GEN_HD_SPLIT_CURRENT_CONFIG* = 0x00010220 + OID_GEN_PROMISCUOUS_MODE* = 0x00010280 + OID_GEN_LAST_CHANGE* = 0x00010281 + OID_GEN_DISCONTINUITY_TIME* = 0x00010282 + OID_GEN_OPERATIONAL_STATUS* = 0x00010283 + OID_GEN_XMIT_LINK_SPEED* = 0x00010284 + OID_GEN_RCV_LINK_SPEED* = 0x00010285 + OID_GEN_UNKNOWN_PROTOS* = 0x00010286 + OID_GEN_INTERFACE_INFO* = 0x00010287 + OID_GEN_ADMIN_STATUS* = 0x00010288 + OID_GEN_ALIAS* = 0x00010289 + OID_GEN_MEDIA_CONNECT_STATUS_EX* = 0x0001028a + OID_GEN_LINK_SPEED_EX* = 0x0001028b + OID_GEN_MEDIA_DUPLEX_STATE* = 0x0001028c + OID_GEN_IP_OPER_STATUS* = 0x0001028d + OID_WWAN_DRIVER_CAPS* = 0x0e010100 + OID_WWAN_DEVICE_CAPS* = 0x0e010101 + OID_WWAN_READY_INFO* = 0x0e010102 + OID_WWAN_RADIO_STATE* = 0x0e010103 + OID_WWAN_PIN* = 0x0e010104 + OID_WWAN_PIN_LIST* = 0x0e010105 + OID_WWAN_HOME_PROVIDER* = 0x0e010106 + OID_WWAN_PREFERRED_PROVIDERS* = 0x0e010107 + OID_WWAN_VISIBLE_PROVIDERS* = 0x0e010108 + OID_WWAN_REGISTER_STATE* = 0x0e010109 + OID_WWAN_PACKET_SERVICE* = 0x0e01010a + OID_WWAN_SIGNAL_STATE* = 0x0e01010b + OID_WWAN_CONNECT* = 0x0e01010c + OID_WWAN_PROVISIONED_CONTEXTS* = 0x0e01010d + OID_WWAN_SERVICE_ACTIVATION* = 0x0e01010e + OID_WWAN_SMS_CONFIGURATION* = 0x0e01010f + OID_WWAN_SMS_READ* = 0x0e010110 + OID_WWAN_SMS_SEND* = 0x0e010111 + OID_WWAN_SMS_DELETE* = 0x0e010112 + OID_WWAN_SMS_STATUS* = 0x0e010113 + OID_WWAN_VENDOR_SPECIFIC* = 0x0e010114 + OID_WWAN_AUTH_CHALLENGE* = 0x0e010115 + OID_WWAN_ENUMERATE_DEVICE_SERVICES* = 0x0e010116 + OID_WWAN_SUBSCRIBE_DEVICE_SERVICE_EVENTS* = 0x0e010117 + OID_WWAN_DEVICE_SERVICE_COMMAND* = 0x0e010118 + OID_WWAN_USSD* = 0x0e010119 + OID_WWAN_PIN_EX* = 0x0e010121 + OID_WWAN_ENUMERATE_DEVICE_SERVICE_COMMANDS* = 0x0e010122 + OID_WWAN_DEVICE_SERVICE_SESSION* = 0x0e010123 + OID_WWAN_DEVICE_SERVICE_SESSION_WRITE* = 0x0e010124 + OID_WWAN_PREFERRED_MULTICARRIER_PROVIDERS* = 0x0e010125 + OID_GEN_XMIT_OK* = 0x00020101 + OID_GEN_RCV_OK* = 0x00020102 + OID_GEN_XMIT_ERROR* = 0x00020103 + OID_GEN_RCV_ERROR* = 0x00020104 + OID_GEN_RCV_NO_BUFFER* = 0x00020105 + OID_GEN_STATISTICS* = 0x00020106 + OID_GEN_DIRECTED_BYTES_XMIT* = 0x00020201 + OID_GEN_DIRECTED_FRAMES_XMIT* = 0x00020202 + OID_GEN_MULTICAST_BYTES_XMIT* = 0x00020203 + OID_GEN_MULTICAST_FRAMES_XMIT* = 0x00020204 + OID_GEN_BROADCAST_BYTES_XMIT* = 0x00020205 + OID_GEN_BROADCAST_FRAMES_XMIT* = 0x00020206 + OID_GEN_DIRECTED_BYTES_RCV* = 0x00020207 + OID_GEN_DIRECTED_FRAMES_RCV* = 0x00020208 + OID_GEN_MULTICAST_BYTES_RCV* = 0x00020209 + OID_GEN_MULTICAST_FRAMES_RCV* = 0x0002020a + OID_GEN_BROADCAST_BYTES_RCV* = 0x0002020b + OID_GEN_BROADCAST_FRAMES_RCV* = 0x0002020c + OID_GEN_RCV_CRC_ERROR* = 0x0002020d + OID_GEN_TRANSMIT_QUEUE_LENGTH* = 0x0002020e + OID_GEN_GET_TIME_CAPS* = 0x0002020f + OID_GEN_GET_NETCARD_TIME* = 0x00020210 + OID_GEN_NETCARD_LOAD* = 0x00020211 + OID_GEN_DEVICE_PROFILE* = 0x00020212 + OID_GEN_INIT_TIME_MS* = 0x00020213 + OID_GEN_RESET_COUNTS* = 0x00020214 + OID_GEN_MEDIA_SENSE_COUNTS* = 0x00020215 + OID_GEN_FRIENDLY_NAME* = 0x00020216 + OID_GEN_NDIS_RESERVED_1* = 0x00020217 + OID_GEN_NDIS_RESERVED_2* = 0x00020218 + OID_GEN_BYTES_RCV* = 0x00020219 + OID_GEN_BYTES_XMIT* = 0x0002021a + OID_GEN_RCV_DISCARDS* = 0x0002021b + OID_GEN_XMIT_DISCARDS* = 0x0002021c + OID_TCP_RSC_STATISTICS* = 0x0002021d + OID_GEN_NDIS_RESERVED_7* = 0x0002021e + OID_GEN_CO_SUPPORTED_LIST* = OID_GEN_SUPPORTED_LIST + OID_GEN_CO_HARDWARE_STATUS* = OID_GEN_HARDWARE_STATUS + OID_GEN_CO_MEDIA_SUPPORTED* = OID_GEN_MEDIA_SUPPORTED + OID_GEN_CO_MEDIA_IN_USE* = OID_GEN_MEDIA_IN_USE + OID_GEN_CO_LINK_SPEED* = OID_GEN_LINK_SPEED + OID_GEN_CO_VENDOR_ID* = OID_GEN_VENDOR_ID + OID_GEN_CO_VENDOR_DESCRIPTION* = OID_GEN_VENDOR_DESCRIPTION + OID_GEN_CO_DRIVER_VERSION* = OID_GEN_DRIVER_VERSION + OID_GEN_CO_PROTOCOL_OPTIONS* = OID_GEN_PROTOCOL_OPTIONS + OID_GEN_CO_MAC_OPTIONS* = OID_GEN_MAC_OPTIONS + OID_GEN_CO_MEDIA_CONNECT_STATUS* = OID_GEN_MEDIA_CONNECT_STATUS + OID_GEN_CO_VENDOR_DRIVER_VERSION* = OID_GEN_VENDOR_DRIVER_VERSION + OID_GEN_CO_SUPPORTED_GUIDS* = OID_GEN_SUPPORTED_GUIDS + OID_GEN_CO_GET_TIME_CAPS* = OID_GEN_GET_TIME_CAPS + OID_GEN_CO_GET_NETCARD_TIME* = OID_GEN_GET_NETCARD_TIME + OID_GEN_CO_MINIMUM_LINK_SPEED* = 0x00020120 + OID_GEN_CO_XMIT_PDUS_OK* = OID_GEN_XMIT_OK + OID_GEN_CO_RCV_PDUS_OK* = OID_GEN_RCV_OK + OID_GEN_CO_XMIT_PDUS_ERROR* = OID_GEN_XMIT_ERROR + OID_GEN_CO_RCV_PDUS_ERROR* = OID_GEN_RCV_ERROR + OID_GEN_CO_RCV_PDUS_NO_BUFFER* = OID_GEN_RCV_NO_BUFFER + OID_GEN_CO_RCV_CRC_ERROR* = OID_GEN_RCV_CRC_ERROR + OID_GEN_CO_TRANSMIT_QUEUE_LENGTH* = OID_GEN_TRANSMIT_QUEUE_LENGTH + OID_GEN_CO_BYTES_XMIT* = OID_GEN_DIRECTED_BYTES_XMIT + OID_GEN_CO_BYTES_RCV* = OID_GEN_DIRECTED_BYTES_RCV + OID_GEN_CO_NETCARD_LOAD* = OID_GEN_NETCARD_LOAD + OID_GEN_CO_DEVICE_PROFILE* = OID_GEN_DEVICE_PROFILE + OID_GEN_CO_BYTES_XMIT_OUTSTANDING* = 0x00020221 + OID_802_3_PERMANENT_ADDRESS* = 0x01010101 + OID_802_3_CURRENT_ADDRESS* = 0x01010102 + OID_802_3_MULTICAST_LIST* = 0x01010103 + OID_802_3_MAXIMUM_LIST_SIZE* = 0x01010104 + OID_802_3_MAC_OPTIONS* = 0x01010105 + NDIS_802_3_MAC_OPTION_PRIORITY* = 0x00000001 + OID_802_3_RCV_ERROR_ALIGNMENT* = 0x01020101 + OID_802_3_XMIT_ONE_COLLISION* = 0x01020102 + OID_802_3_XMIT_MORE_COLLISIONS* = 0x01020103 + OID_802_3_XMIT_DEFERRED* = 0x01020201 + OID_802_3_XMIT_MAX_COLLISIONS* = 0x01020202 + OID_802_3_RCV_OVERRUN* = 0x01020203 + OID_802_3_XMIT_UNDERRUN* = 0x01020204 + OID_802_3_XMIT_HEARTBEAT_FAILURE* = 0x01020205 + OID_802_3_XMIT_TIMES_CRS_LOST* = 0x01020206 + OID_802_3_XMIT_LATE_COLLISIONS* = 0x01020207 + OID_802_3_ADD_MULTICAST_ADDRESS* = 0x01010208 + OID_802_3_DELETE_MULTICAST_ADDRESS* = 0x01010209 + OID_802_5_PERMANENT_ADDRESS* = 0x02010101 + OID_802_5_CURRENT_ADDRESS* = 0x02010102 + OID_802_5_CURRENT_FUNCTIONAL* = 0x02010103 + OID_802_5_CURRENT_GROUP* = 0x02010104 + OID_802_5_LAST_OPEN_STATUS* = 0x02010105 + OID_802_5_CURRENT_RING_STATUS* = 0x02010106 + OID_802_5_CURRENT_RING_STATE* = 0x02010107 + OID_802_5_LINE_ERRORS* = 0x02020101 + OID_802_5_LOST_FRAMES* = 0x02020102 + OID_802_5_BURST_ERRORS* = 0x02020201 + OID_802_5_AC_ERRORS* = 0x02020202 + OID_802_5_ABORT_DELIMETERS* = 0x02020203 + OID_802_5_FRAME_COPIED_ERRORS* = 0x02020204 + OID_802_5_FREQUENCY_ERRORS* = 0x02020205 + OID_802_5_TOKEN_ERRORS* = 0x02020206 + OID_802_5_INTERNAL_ERRORS* = 0x02020207 + OID_FDDI_LONG_PERMANENT_ADDR* = 0x03010101 + OID_FDDI_LONG_CURRENT_ADDR* = 0x03010102 + OID_FDDI_LONG_MULTICAST_LIST* = 0x03010103 + OID_FDDI_LONG_MAX_LIST_SIZE* = 0x03010104 + OID_FDDI_SHORT_PERMANENT_ADDR* = 0x03010105 + OID_FDDI_SHORT_CURRENT_ADDR* = 0x03010106 + OID_FDDI_SHORT_MULTICAST_LIST* = 0x03010107 + OID_FDDI_SHORT_MAX_LIST_SIZE* = 0x03010108 + OID_FDDI_ATTACHMENT_TYPE* = 0x03020101 + OID_FDDI_UPSTREAM_NODE_LONG* = 0x03020102 + OID_FDDI_DOWNSTREAM_NODE_LONG* = 0x03020103 + OID_FDDI_FRAME_ERRORS* = 0x03020104 + OID_FDDI_FRAMES_LOST* = 0x03020105 + OID_FDDI_RING_MGT_STATE* = 0x03020106 + OID_FDDI_LCT_FAILURES* = 0x03020107 + OID_FDDI_LEM_REJECTS* = 0x03020108 + OID_FDDI_LCONNECTION_STATE* = 0x03020109 + OID_FDDI_SMT_STATION_ID* = 0x03030201 + OID_FDDI_SMT_OP_VERSION_ID* = 0x03030202 + OID_FDDI_SMT_HI_VERSION_ID* = 0x03030203 + OID_FDDI_SMT_LO_VERSION_ID* = 0x03030204 + OID_FDDI_SMT_MANUFACTURER_DATA* = 0x03030205 + OID_FDDI_SMT_USER_DATA* = 0x03030206 + OID_FDDI_SMT_MIB_VERSION_ID* = 0x03030207 + OID_FDDI_SMT_MAC_CT* = 0x03030208 + OID_FDDI_SMT_NON_MASTER_CT* = 0x03030209 + OID_FDDI_SMT_MASTER_CT* = 0x0303020a + OID_FDDI_SMT_AVAILABLE_PATHS* = 0x0303020b + OID_FDDI_SMT_CONFIG_CAPABILITIES* = 0x0303020c + OID_FDDI_SMT_CONFIG_POLICY* = 0x0303020d + OID_FDDI_SMT_CONNECTION_POLICY* = 0x0303020e + OID_FDDI_SMT_T_NOTIFY* = 0x0303020f + OID_FDDI_SMT_STAT_RPT_POLICY* = 0x03030210 + OID_FDDI_SMT_TRACE_MAX_EXPIRATION* = 0x03030211 + OID_FDDI_SMT_PORT_INDEXES* = 0x03030212 + OID_FDDI_SMT_MAC_INDEXES* = 0x03030213 + OID_FDDI_SMT_BYPASS_PRESENT* = 0x03030214 + OID_FDDI_SMT_ECM_STATE* = 0x03030215 + OID_FDDI_SMT_CF_STATE* = 0x03030216 + OID_FDDI_SMT_HOLD_STATE* = 0x03030217 + OID_FDDI_SMT_REMOTE_DISCONNECT_FLAG* = 0x03030218 + OID_FDDI_SMT_STATION_STATUS* = 0x03030219 + OID_FDDI_SMT_PEER_WRAP_FLAG* = 0x0303021a + OID_FDDI_SMT_MSG_TIME_STAMP* = 0x0303021b + OID_FDDI_SMT_TRANSITION_TIME_STAMP* = 0x0303021c + OID_FDDI_SMT_SET_COUNT* = 0x0303021d + OID_FDDI_SMT_LAST_SET_STATION_ID* = 0x0303021e + OID_FDDI_MAC_FRAME_STATUS_FUNCTIONS* = 0x0303021f + OID_FDDI_MAC_BRIDGE_FUNCTIONS* = 0x03030220 + OID_FDDI_MAC_T_MAX_CAPABILITY* = 0x03030221 + OID_FDDI_MAC_TVX_CAPABILITY* = 0x03030222 + OID_FDDI_MAC_AVAILABLE_PATHS* = 0x03030223 + OID_FDDI_MAC_CURRENT_PATH* = 0x03030224 + OID_FDDI_MAC_UPSTREAM_NBR* = 0x03030225 + OID_FDDI_MAC_DOWNSTREAM_NBR* = 0x03030226 + OID_FDDI_MAC_OLD_UPSTREAM_NBR* = 0x03030227 + OID_FDDI_MAC_OLD_DOWNSTREAM_NBR* = 0x03030228 + OID_FDDI_MAC_DUP_ADDRESS_TEST* = 0x03030229 + OID_FDDI_MAC_REQUESTED_PATHS* = 0x0303022a + OID_FDDI_MAC_DOWNSTREAM_PORT_TYPE* = 0x0303022b + OID_FDDI_MAC_INDEX* = 0x0303022c + OID_FDDI_MAC_SMT_ADDRESS* = 0x0303022d + OID_FDDI_MAC_LONG_GRP_ADDRESS* = 0x0303022e + OID_FDDI_MAC_SHORT_GRP_ADDRESS* = 0x0303022f + OID_FDDI_MAC_T_REQ* = 0x03030230 + OID_FDDI_MAC_T_NEG* = 0x03030231 + OID_FDDI_MAC_T_MAX* = 0x03030232 + OID_FDDI_MAC_TVX_VALUE* = 0x03030233 + OID_FDDI_MAC_T_PRI0* = 0x03030234 + OID_FDDI_MAC_T_PRI1* = 0x03030235 + OID_FDDI_MAC_T_PRI2* = 0x03030236 + OID_FDDI_MAC_T_PRI3* = 0x03030237 + OID_FDDI_MAC_T_PRI4* = 0x03030238 + OID_FDDI_MAC_T_PRI5* = 0x03030239 + OID_FDDI_MAC_T_PRI6* = 0x0303023a + OID_FDDI_MAC_FRAME_CT* = 0x0303023b + OID_FDDI_MAC_COPIED_CT* = 0x0303023c + OID_FDDI_MAC_TRANSMIT_CT* = 0x0303023d + OID_FDDI_MAC_TOKEN_CT* = 0x0303023e + OID_FDDI_MAC_ERROR_CT* = 0x0303023f + OID_FDDI_MAC_LOST_CT* = 0x03030240 + OID_FDDI_MAC_TVX_EXPIRED_CT* = 0x03030241 + OID_FDDI_MAC_NOT_COPIED_CT* = 0x03030242 + OID_FDDI_MAC_LATE_CT* = 0x03030243 + OID_FDDI_MAC_RING_OP_CT* = 0x03030244 + OID_FDDI_MAC_FRAME_ERROR_THRESHOLD* = 0x03030245 + OID_FDDI_MAC_FRAME_ERROR_RATIO* = 0x03030246 + OID_FDDI_MAC_NOT_COPIED_THRESHOLD* = 0x03030247 + OID_FDDI_MAC_NOT_COPIED_RATIO* = 0x03030248 + OID_FDDI_MAC_RMT_STATE* = 0x03030249 + OID_FDDI_MAC_DA_FLAG* = 0x0303024a + OID_FDDI_MAC_UNDA_FLAG* = 0x0303024b + OID_FDDI_MAC_FRAME_ERROR_FLAG* = 0x0303024c + OID_FDDI_MAC_NOT_COPIED_FLAG* = 0x0303024d + OID_FDDI_MAC_MA_UNITDATA_AVAILABLE* = 0x0303024e + OID_FDDI_MAC_HARDWARE_PRESENT* = 0x0303024f + OID_FDDI_MAC_MA_UNITDATA_ENABLE* = 0x03030250 + OID_FDDI_PATH_INDEX* = 0x03030251 + OID_FDDI_PATH_RING_LATENCY* = 0x03030252 + OID_FDDI_PATH_TRACE_STATUS* = 0x03030253 + OID_FDDI_PATH_SBA_PAYLOAD* = 0x03030254 + OID_FDDI_PATH_SBA_OVERHEAD* = 0x03030255 + OID_FDDI_PATH_CONFIGURATION* = 0x03030256 + OID_FDDI_PATH_T_R_MODE* = 0x03030257 + OID_FDDI_PATH_SBA_AVAILABLE* = 0x03030258 + OID_FDDI_PATH_TVX_LOWER_BOUND* = 0x03030259 + OID_FDDI_PATH_T_MAX_LOWER_BOUND* = 0x0303025a + OID_FDDI_PATH_MAX_T_REQ* = 0x0303025b + OID_FDDI_PORT_MY_TYPE* = 0x0303025c + OID_FDDI_PORT_NEIGHBOR_TYPE* = 0x0303025d + OID_FDDI_PORT_CONNECTION_POLICIES* = 0x0303025e + OID_FDDI_PORT_MAC_INDICATED* = 0x0303025f + OID_FDDI_PORT_CURRENT_PATH* = 0x03030260 + OID_FDDI_PORT_REQUESTED_PATHS* = 0x03030261 + OID_FDDI_PORT_MAC_PLACEMENT* = 0x03030262 + OID_FDDI_PORT_AVAILABLE_PATHS* = 0x03030263 + OID_FDDI_PORT_MAC_LOOP_TIME* = 0x03030264 + OID_FDDI_PORT_PMD_CLASS* = 0x03030265 + OID_FDDI_PORT_CONNECTION_CAPABILITIES* = 0x03030266 + OID_FDDI_PORT_INDEX* = 0x03030267 + OID_FDDI_PORT_MAINT_LS* = 0x03030268 + OID_FDDI_PORT_BS_FLAG* = 0x03030269 + OID_FDDI_PORT_PC_LS* = 0x0303026a + OID_FDDI_PORT_EB_ERROR_CT* = 0x0303026b + OID_FDDI_PORT_LCT_FAIL_CT* = 0x0303026c + OID_FDDI_PORT_LER_ESTIMATE* = 0x0303026d + OID_FDDI_PORT_LEM_REJECT_CT* = 0x0303026e + OID_FDDI_PORT_LEM_CT* = 0x0303026f + OID_FDDI_PORT_LER_CUTOFF* = 0x03030270 + OID_FDDI_PORT_LER_ALARM* = 0x03030271 + OID_FDDI_PORT_CONNNECT_STATE* = 0x03030272 + OID_FDDI_PORT_PCM_STATE* = 0x03030273 + OID_FDDI_PORT_PC_WITHHOLD* = 0x03030274 + OID_FDDI_PORT_LER_FLAG* = 0x03030275 + OID_FDDI_PORT_HARDWARE_PRESENT* = 0x03030276 + OID_FDDI_SMT_STATION_ACTION* = 0x03030277 + OID_FDDI_PORT_ACTION* = 0x03030278 + OID_FDDI_IF_DESCR* = 0x03030279 + OID_FDDI_IF_TYPE* = 0x0303027a + OID_FDDI_IF_MTU* = 0x0303027b + OID_FDDI_IF_SPEED* = 0x0303027c + OID_FDDI_IF_PHYS_ADDRESS* = 0x0303027d + OID_FDDI_IF_ADMIN_STATUS* = 0x0303027e + OID_FDDI_IF_OPER_STATUS* = 0x0303027f + OID_FDDI_IF_LAST_CHANGE* = 0x03030280 + OID_FDDI_IF_IN_OCTETS* = 0x03030281 + OID_FDDI_IF_IN_UCAST_PKTS* = 0x03030282 + OID_FDDI_IF_IN_NUCAST_PKTS* = 0x03030283 + OID_FDDI_IF_IN_DISCARDS* = 0x03030284 + OID_FDDI_IF_IN_ERRORS* = 0x03030285 + OID_FDDI_IF_IN_UNKNOWN_PROTOS* = 0x03030286 + OID_FDDI_IF_OUT_OCTETS* = 0x03030287 + OID_FDDI_IF_OUT_UCAST_PKTS* = 0x03030288 + OID_FDDI_IF_OUT_NUCAST_PKTS* = 0x03030289 + OID_FDDI_IF_OUT_DISCARDS* = 0x0303028a + OID_FDDI_IF_OUT_ERRORS* = 0x0303028b + OID_FDDI_IF_OUT_QLEN* = 0x0303028c + OID_FDDI_IF_SPECIFIC* = 0x0303028d + OID_WAN_PERMANENT_ADDRESS* = 0x04010101 + OID_WAN_CURRENT_ADDRESS* = 0x04010102 + OID_WAN_QUALITY_OF_SERVICE* = 0x04010103 + OID_WAN_PROTOCOL_TYPE* = 0x04010104 + OID_WAN_MEDIUM_SUBTYPE* = 0x04010105 + OID_WAN_HEADER_FORMAT* = 0x04010106 + OID_WAN_GET_INFO* = 0x04010107 + OID_WAN_SET_LINK_INFO* = 0x04010108 + OID_WAN_GET_LINK_INFO* = 0x04010109 + OID_WAN_LINE_COUNT* = 0x0401010a + OID_WAN_PROTOCOL_CAPS* = 0x0401010b + OID_WAN_GET_BRIDGE_INFO* = 0x0401020a + OID_WAN_SET_BRIDGE_INFO* = 0x0401020b + OID_WAN_GET_COMP_INFO* = 0x0401020c + OID_WAN_SET_COMP_INFO* = 0x0401020d + OID_WAN_GET_STATS_INFO* = 0x0401020e + OID_WAN_CO_GET_INFO* = 0x04010180 + OID_WAN_CO_SET_LINK_INFO* = 0x04010181 + OID_WAN_CO_GET_LINK_INFO* = 0x04010182 + OID_WAN_CO_GET_COMP_INFO* = 0x04010280 + OID_WAN_CO_SET_COMP_INFO* = 0x04010281 + OID_WAN_CO_GET_STATS_INFO* = 0x04010282 + OID_LTALK_CURRENT_NODE_ID* = 0x05010102 + OID_LTALK_IN_BROADCASTS* = 0x05020101 + OID_LTALK_IN_LENGTH_ERRORS* = 0x05020102 + OID_LTALK_OUT_NO_HANDLERS* = 0x05020201 + OID_LTALK_COLLISIONS* = 0x05020202 + OID_LTALK_DEFERS* = 0x05020203 + OID_LTALK_NO_DATA_ERRORS* = 0x05020204 + OID_LTALK_RANDOM_CTS_ERRORS* = 0x05020205 + OID_LTALK_FCS_ERRORS* = 0x05020206 + OID_ARCNET_PERMANENT_ADDRESS* = 0x06010101 + OID_ARCNET_CURRENT_ADDRESS* = 0x06010102 + OID_ARCNET_RECONFIGURATIONS* = 0x06020201 + OID_TAPI_ACCEPT* = 0x07030101 + OID_TAPI_ANSWER* = 0x07030102 + OID_TAPI_CLOSE* = 0x07030103 + OID_TAPI_CLOSE_CALL* = 0x07030104 + OID_TAPI_CONDITIONAL_MEDIA_DETECTION* = 0x07030105 + OID_TAPI_CONFIG_DIALOG* = 0x07030106 + OID_TAPI_DEV_SPECIFIC* = 0x07030107 + OID_TAPI_DIAL* = 0x07030108 + OID_TAPI_DROP* = 0x07030109 + OID_TAPI_GET_ADDRESS_CAPS* = 0x0703010a + OID_TAPI_GET_ADDRESS_ID* = 0x0703010b + OID_TAPI_GET_ADDRESS_STATUS* = 0x0703010c + OID_TAPI_GET_CALL_ADDRESS_ID* = 0x0703010d + OID_TAPI_GET_CALL_INFO* = 0x0703010e + OID_TAPI_GET_CALL_STATUS* = 0x0703010f + OID_TAPI_GET_DEV_CAPS* = 0x07030110 + OID_TAPI_GET_DEV_CONFIG* = 0x07030111 + OID_TAPI_GET_EXTENSION_ID* = 0x07030112 + OID_TAPI_GET_ID* = 0x07030113 + OID_TAPI_GET_LINE_DEV_STATUS* = 0x07030114 + OID_TAPI_MAKE_CALL* = 0x07030115 + OID_TAPI_NEGOTIATE_EXT_VERSION* = 0x07030116 + OID_TAPI_OPEN* = 0x07030117 + OID_TAPI_PROVIDER_INITIALIZE* = 0x07030118 + OID_TAPI_PROVIDER_SHUTDOWN* = 0x07030119 + OID_TAPI_SECURE_CALL* = 0x0703011a + OID_TAPI_SELECT_EXT_VERSION* = 0x0703011b + OID_TAPI_SEND_USER_USER_INFO* = 0x0703011c + OID_TAPI_SET_APP_SPECIFIC* = 0x0703011d + OID_TAPI_SET_CALL_PARAMS* = 0x0703011e + OID_TAPI_SET_DEFAULT_MEDIA_DETECTION* = 0x0703011f + OID_TAPI_SET_DEV_CONFIG* = 0x07030120 + OID_TAPI_SET_MEDIA_MODE* = 0x07030121 + OID_TAPI_SET_STATUS_MESSAGES* = 0x07030122 + OID_TAPI_GATHER_DIGITS* = 0x07030123 + OID_TAPI_MONITOR_DIGITS* = 0x07030124 + OID_ATM_SUPPORTED_VC_RATES* = 0x08010101 + OID_ATM_SUPPORTED_SERVICE_CATEGORY* = 0x08010102 + OID_ATM_SUPPORTED_AAL_TYPES* = 0x08010103 + OID_ATM_HW_CURRENT_ADDRESS* = 0x08010104 + OID_ATM_MAX_ACTIVE_VCS* = 0x08010105 + OID_ATM_MAX_ACTIVE_VCI_BITS* = 0x08010106 + OID_ATM_MAX_ACTIVE_VPI_BITS* = 0x08010107 + OID_ATM_MAX_AAL0_PACKET_SIZE* = 0x08010108 + OID_ATM_MAX_AAL1_PACKET_SIZE* = 0x08010109 + OID_ATM_MAX_AAL34_PACKET_SIZE* = 0x0801010a + OID_ATM_MAX_AAL5_PACKET_SIZE* = 0x0801010b + OID_ATM_SIGNALING_VPIVCI* = 0x08010201 + OID_ATM_ASSIGNED_VPI* = 0x08010202 + OID_ATM_ACQUIRE_ACCESS_NET_RESOURCES* = 0x08010203 + OID_ATM_RELEASE_ACCESS_NET_RESOURCES* = 0x08010204 + OID_ATM_ILMI_VPIVCI* = 0x08010205 + OID_ATM_DIGITAL_BROADCAST_VPIVCI* = 0x08010206 + OID_ATM_GET_NEAREST_FLOW* = 0x08010207 + OID_ATM_ALIGNMENT_REQUIRED* = 0x08010208 + OID_ATM_LECS_ADDRESS* = 0x08010209 + OID_ATM_SERVICE_ADDRESS* = 0x0801020a + OID_ATM_CALL_PROCEEDING* = 0x0801020b + OID_ATM_CALL_ALERTING* = 0x0801020c + OID_ATM_PARTY_ALERTING* = 0x0801020d + OID_ATM_CALL_NOTIFY* = 0x0801020e + OID_ATM_MY_IP_NM_ADDRESS* = 0x0801020f + OID_ATM_RCV_CELLS_OK* = 0x08020101 + OID_ATM_XMIT_CELLS_OK* = 0x08020102 + OID_ATM_RCV_CELLS_DROPPED* = 0x08020103 + OID_ATM_RCV_INVALID_VPI_VCI* = 0x08020201 + OID_ATM_CELLS_HEC_ERROR* = 0x08020202 + OID_ATM_RCV_REASSEMBLY_ERROR* = 0x08020203 + OID_802_11_BSSID* = 0x0d010101 + OID_802_11_SSID* = 0x0d010102 + OID_802_11_NETWORK_TYPES_SUPPORTED* = 0x0d010203 + OID_802_11_NETWORK_TYPE_IN_USE* = 0x0d010204 + OID_802_11_TX_POWER_LEVEL* = 0x0d010205 + OID_802_11_RSSI* = 0x0d010206 + OID_802_11_RSSI_TRIGGER* = 0x0d010207 + OID_802_11_INFRASTRUCTURE_MODE* = 0x0d010108 + OID_802_11_FRAGMENTATION_THRESHOLD* = 0x0d010209 + OID_802_11_RTS_THRESHOLD* = 0x0d01020a + OID_802_11_NUMBER_OF_ANTENNAS* = 0x0d01020b + OID_802_11_RX_ANTENNA_SELECTED* = 0x0d01020c + OID_802_11_TX_ANTENNA_SELECTED* = 0x0d01020d + OID_802_11_SUPPORTED_RATES* = 0x0d01020e + OID_802_11_DESIRED_RATES* = 0x0d010210 + OID_802_11_CONFIGURATION* = 0x0d010211 + OID_802_11_STATISTICS* = 0x0d020212 + OID_802_11_ADD_WEP* = 0x0d010113 + OID_802_11_REMOVE_WEP* = 0x0d010114 + OID_802_11_DISASSOCIATE* = 0x0d010115 + OID_802_11_POWER_MODE* = 0x0d010216 + OID_802_11_BSSID_LIST* = 0x0d010217 + OID_802_11_AUTHENTICATION_MODE* = 0x0d010118 + OID_802_11_PRIVACY_FILTER* = 0x0d010119 + OID_802_11_BSSID_LIST_SCAN* = 0x0d01011a + OID_802_11_WEP_STATUS* = 0x0d01011b + OID_802_11_ENCRYPTION_STATUS* = OID_802_11_WEP_STATUS + OID_802_11_RELOAD_DEFAULTS* = 0x0d01011c + OID_802_11_ADD_KEY* = 0x0d01011d + OID_802_11_REMOVE_KEY* = 0x0d01011e + OID_802_11_ASSOCIATION_INFORMATION* = 0x0d01011f + OID_802_11_TEST* = 0x0d010120 + OID_802_11_MEDIA_STREAM_MODE* = 0x0d010121 + OID_802_11_CAPABILITY* = 0x0d010122 + OID_802_11_PMKID* = 0x0d010123 + OID_802_11_NON_BCAST_SSID_LIST* = 0x0d010124 + OID_802_11_RADIO_STATUS* = 0x0d010125 + NDIS_ETH_TYPE_IPV4* = 0x0800 + NDIS_ETH_TYPE_ARP* = 0x0806 + NDIS_ETH_TYPE_IPV6* = 0x86dd + NDIS_ETH_TYPE_802_1X* = 0x888e + NDIS_ETH_TYPE_802_1Q* = 0x8100 + NDIS_ETH_TYPE_SLOW_PROTOCOL* = 0x8809 + NDIS_802_11_AUTH_REQUEST_REAUTH* = 0x01 + NDIS_802_11_AUTH_REQUEST_KEYUPDATE* = 0x02 + NDIS_802_11_AUTH_REQUEST_PAIRWISE_ERROR* = 0x06 + NDIS_802_11_AUTH_REQUEST_GROUP_ERROR* = 0x0e + NDIS_802_11_AUTH_REQUEST_AUTH_FIELDS* = 0x0f + NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED* = 0x01 + NDIS_802_11_AI_REQFI_CAPABILITIES* = 1 + NDIS_802_11_AI_REQFI_LISTENINTERVAL* = 2 + NDIS_802_11_AI_REQFI_CURRENTAPADDRESS* = 4 + NDIS_802_11_AI_RESFI_CAPABILITIES* = 1 + NDIS_802_11_AI_RESFI_STATUSCODE* = 2 + NDIS_802_11_AI_RESFI_ASSOCIATIONID* = 4 + Ndis802_11StatusType_Authentication* = 0 + Ndis802_11StatusType_MediaStreamMode* = 1 + Ndis802_11StatusType_PMKID_CandidateList* = 2 + Ndis802_11StatusTypeMax* = 3 + Ndis802_11FH* = 0 + Ndis802_11DS* = 1 + Ndis802_11OFDM5* = 2 + Ndis802_11OFDM24* = 3 + Ndis802_11Automode* = 4 + Ndis802_11NetworkTypeMax* = 5 + Ndis802_11PowerModeCAM* = 0 + Ndis802_11PowerModeMAX_PSP* = 1 + Ndis802_11PowerModeFast_PSP* = 2 + Ndis802_11PowerModeMax* = 3 + Ndis802_11IBSS* = 0 + Ndis802_11Infrastructure* = 1 + Ndis802_11AutoUnknown* = 2 + Ndis802_11InfrastructureMax* = 3 + Ndis802_11AuthModeOpen* = 0 + Ndis802_11AuthModeShared* = 1 + Ndis802_11AuthModeAutoSwitch* = 2 + Ndis802_11AuthModeWPA* = 3 + Ndis802_11AuthModeWPAPSK* = 4 + Ndis802_11AuthModeWPANone* = 5 + Ndis802_11AuthModeWPA2* = 6 + Ndis802_11AuthModeWPA2PSK* = 7 + Ndis802_11AuthModeMax* = 8 + Ndis802_11PrivFilterAcceptAll* = 0 + Ndis802_11PrivFilter8021xWEP* = 1 + Ndis802_11WEPEnabled* = 0 + Ndis802_11Encryption1Enabled* = Ndis802_11WEPEnabled + Ndis802_11WEPDisabled* = Ndis802_11WEPEnabled+1 + Ndis802_11EncryptionDisabled* = Ndis802_11WEPDisabled + Ndis802_11WEPKeyAbsent* = Ndis802_11WEPDisabled+1 + Ndis802_11Encryption1KeyAbsent* = Ndis802_11WEPKeyAbsent + Ndis802_11WEPNotSupported* = Ndis802_11WEPKeyAbsent+1 + Ndis802_11EncryptionNotSupported* = Ndis802_11WEPNotSupported + Ndis802_11Encryption2Enabled* = Ndis802_11WEPNotSupported+1 + Ndis802_11Encryption2KeyAbsent* = Ndis802_11WEPNotSupported+2 + Ndis802_11Encryption3Enabled* = Ndis802_11WEPNotSupported+3 + Ndis802_11Encryption3KeyAbsent* = Ndis802_11WEPNotSupported+4 + Ndis802_11ReloadWEPKeys* = 0 + Ndis802_11MediaStreamOff* = 0 + Ndis802_11MediaStreamOn* = 1 + Ndis802_11RadioStatusOn* = 0 + Ndis802_11RadioStatusHardwareOff* = 1 + Ndis802_11RadioStatusSoftwareOff* = 2 + Ndis802_11RadioStatusHardwareSoftwareOff* = 3 + Ndis802_11RadioStatusMax* = 4 + OID_IRDA_RECEIVING* = 0x0a010100 + OID_IRDA_TURNAROUND_TIME* = 0x0a010101 + OID_IRDA_SUPPORTED_SPEEDS* = 0x0a010102 + OID_IRDA_LINK_SPEED* = 0x0a010103 + OID_IRDA_MEDIA_BUSY* = 0x0a010104 + OID_IRDA_EXTRA_RCV_BOFS* = 0x0a010200 + OID_IRDA_RATE_SNIFF* = 0x0a010201 + OID_IRDA_UNICAST_LIST* = 0x0a010202 + OID_IRDA_MAX_UNICAST_LIST_SIZE* = 0x0a010203 + OID_IRDA_MAX_RECEIVE_WINDOW_SIZE* = 0x0a010204 + OID_IRDA_MAX_SEND_WINDOW_SIZE* = 0x0a010205 + OID_IRDA_RESERVED1* = 0x0a01020a + OID_IRDA_RESERVED2* = 0x0a01020f + OID_1394_LOCAL_NODE_INFO* = 0x0c010101 + OID_1394_VC_INFO* = 0x0c010102 + OID_CO_ADD_PVC* = 0xfe000001'i32 + OID_CO_DELETE_PVC* = 0xfe000002'i32 + OID_CO_GET_CALL_INFORMATION* = 0xfe000003'i32 + OID_CO_ADD_ADDRESS* = 0xfe000004'i32 + OID_CO_DELETE_ADDRESS* = 0xfe000005'i32 + OID_CO_GET_ADDRESSES* = 0xfe000006'i32 + OID_CO_ADDRESS_CHANGE* = 0xfe000007'i32 + OID_CO_SIGNALING_ENABLED* = 0xfe000008'i32 + OID_CO_SIGNALING_DISABLED* = 0xfe000009'i32 + OID_CO_AF_CLOSE* = 0xfe00000a'i32 + OID_CO_TAPI_CM_CAPS* = 0xfe001001'i32 + OID_CO_TAPI_LINE_CAPS* = 0xfe001002'i32 + OID_CO_TAPI_ADDRESS_CAPS* = 0xfe001003'i32 + OID_CO_TAPI_TRANSLATE_TAPI_CALLPARAMS* = 0xfe001004'i32 + OID_CO_TAPI_TRANSLATE_NDIS_CALLPARAMS* = 0xfe001005'i32 + OID_CO_TAPI_TRANSLATE_TAPI_SAP* = 0xfe001006'i32 + OID_CO_TAPI_GET_CALL_DIAGNOSTICS* = 0xfe001007'i32 + OID_CO_TAPI_REPORT_DIGITS* = 0xfe001008'i32 + OID_CO_TAPI_DONT_REPORT_DIGITS* = 0xfe001009'i32 + OID_PNP_CAPABILITIES* = 0xfd010100'i32 + OID_PNP_SET_POWER* = 0xfd010101'i32 + OID_PNP_QUERY_POWER* = 0xfd010102'i32 + OID_PNP_ADD_WAKE_UP_PATTERN* = 0xfd010103'i32 + OID_PNP_REMOVE_WAKE_UP_PATTERN* = 0xfd010104'i32 + OID_PNP_WAKE_UP_PATTERN_LIST* = 0xfd010105'i32 + OID_PNP_ENABLE_WAKE_UP* = 0xfd010106'i32 + OID_PNP_WAKE_UP_OK* = 0xfd020200'i32 + OID_PNP_WAKE_UP_ERROR* = 0xfd020201'i32 + OID_PM_CURRENT_CAPABILITIES* = 0xfd010107'i32 + OID_PM_HARDWARE_CAPABILITIES* = 0xfd010108'i32 + OID_PM_PARAMETERS* = 0xfd010109'i32 + OID_PM_ADD_WOL_PATTERN* = 0xfd01010a'i32 + OID_PM_REMOVE_WOL_PATTERN* = 0xfd01010b'i32 + OID_PM_WOL_PATTERN_LIST* = 0xfd01010c'i32 + OID_PM_ADD_PROTOCOL_OFFLOAD* = 0xfd01010d'i32 + OID_PM_GET_PROTOCOL_OFFLOAD* = 0xfd01010e'i32 + OID_PM_REMOVE_PROTOCOL_OFFLOAD* = 0xfd01010f'i32 + OID_PM_PROTOCOL_OFFLOAD_LIST* = 0xfd010110'i32 + OID_PM_RESERVED_1* = 0xfd010111'i32 + OID_RECEIVE_FILTER_HARDWARE_CAPABILITIES* = 0x00010221 + OID_RECEIVE_FILTER_GLOBAL_PARAMETERS* = 0x00010222 + OID_RECEIVE_FILTER_ALLOCATE_QUEUE* = 0x00010223 + OID_RECEIVE_FILTER_FREE_QUEUE* = 0x00010224 + OID_RECEIVE_FILTER_ENUM_QUEUES* = 0x00010225 + OID_RECEIVE_FILTER_QUEUE_PARAMETERS* = 0x00010226 + OID_RECEIVE_FILTER_SET_FILTER* = 0x00010227 + OID_RECEIVE_FILTER_CLEAR_FILTER* = 0x00010228 + OID_RECEIVE_FILTER_ENUM_FILTERS* = 0x00010229 + OID_RECEIVE_FILTER_PARAMETERS* = 0x0001022a + OID_RECEIVE_FILTER_QUEUE_ALLOCATION_COMPLETE* = 0x0001022b + OID_RECEIVE_FILTER_CURRENT_CAPABILITIES* = 0x0001022d + OID_NIC_SWITCH_HARDWARE_CAPABILITIES* = 0x0001022e + OID_NIC_SWITCH_CURRENT_CAPABILITIES* = 0x0001022f + OID_RECEIVE_FILTER_MOVE_FILTER* = 0x00010230 + OID_VLAN_RESERVED1* = 0x00010231 + OID_VLAN_RESERVED2* = 0x00010232 + OID_VLAN_RESERVED3* = 0x00010233 + OID_VLAN_RESERVED4* = 0x00010234 + OID_PACKET_COALESCING_FILTER_MATCH_COUNT* = 0x00010235 + OID_NIC_SWITCH_CREATE_SWITCH* = 0x00010237 + OID_NIC_SWITCH_PARAMETERS* = 0x00010238 + OID_NIC_SWITCH_DELETE_SWITCH* = 0x00010239 + OID_NIC_SWITCH_ENUM_SWITCHES* = 0x00010240 + OID_NIC_SWITCH_CREATE_VPORT* = 0x00010241 + OID_NIC_SWITCH_VPORT_PARAMETERS* = 0x00010242 + OID_NIC_SWITCH_ENUM_VPORTS* = 0x00010243 + OID_NIC_SWITCH_DELETE_VPORT* = 0x00010244 + OID_NIC_SWITCH_ALLOCATE_VF* = 0x00010245 + OID_NIC_SWITCH_FREE_VF* = 0x00010246 + OID_NIC_SWITCH_VF_PARAMETERS* = 0x00010247 + OID_NIC_SWITCH_ENUM_VFS* = 0x00010248 + OID_SRIOV_HARDWARE_CAPABILITIES* = 0x00010249 + OID_SRIOV_CURRENT_CAPABILITIES* = 0x00010250 + OID_SRIOV_READ_VF_CONFIG_SPACE* = 0x00010251 + OID_SRIOV_WRITE_VF_CONFIG_SPACE* = 0x00010252 + OID_SRIOV_READ_VF_CONFIG_BLOCK* = 0x00010253 + OID_SRIOV_WRITE_VF_CONFIG_BLOCK* = 0x00010254 + OID_SRIOV_RESET_VF* = 0x00010255 + OID_SRIOV_SET_VF_POWER_STATE* = 0x00010256 + OID_SRIOV_VF_VENDOR_DEVICE_ID* = 0x00010257 + OID_SRIOV_PROBED_BARS* = 0x00010258 + OID_SRIOV_BAR_RESOURCES* = 0x00010259 + OID_SRIOV_PF_LUID* = 0x00010260 + OID_SRIOV_CONFIG_STATE* = 0x00010261 + OID_SRIOV_VF_SERIAL_NUMBER* = 0x00010262 + OID_SRIOV_VF_INVALIDATE_CONFIG_BLOCK* = 0x00010269 + OID_SWITCH_PROPERTY_ADD* = 0x00010263 + OID_SWITCH_PROPERTY_UPDATE* = 0x00010264 + OID_SWITCH_PROPERTY_DELETE* = 0x00010265 + OID_SWITCH_PROPERTY_ENUM* = 0x00010266 + OID_SWITCH_FEATURE_STATUS_QUERY* = 0x00010267 + OID_SWITCH_NIC_REQUEST* = 0x00010270 + OID_SWITCH_PORT_PROPERTY_ADD* = 0x00010271 + OID_SWITCH_PORT_PROPERTY_UPDATE* = 0x00010272 + OID_SWITCH_PORT_PROPERTY_DELETE* = 0x00010273 + OID_SWITCH_PORT_PROPERTY_ENUM* = 0x00010274 + OID_SWITCH_PARAMETERS* = 0x00010275 + OID_SWITCH_PORT_ARRAY* = 0x00010276 + OID_SWITCH_NIC_ARRAY* = 0x00010277 + OID_SWITCH_PORT_CREATE* = 0x00010278 + OID_SWITCH_PORT_DELETE* = 0x00010279 + OID_SWITCH_NIC_CREATE* = 0x0001027a + OID_SWITCH_NIC_CONNECT* = 0x0001027b + OID_SWITCH_NIC_DISCONNECT* = 0x0001027c + OID_SWITCH_NIC_DELETE* = 0x0001027d + OID_SWITCH_PORT_FEATURE_STATUS_QUERY* = 0x0001027e + OID_SWITCH_PORT_TEARDOWN* = 0x0001027f + OID_SWITCH_NIC_SAVE* = 0x00010290 + OID_SWITCH_NIC_SAVE_COMPLETE* = 0x00010291 + OID_SWITCH_NIC_RESTORE* = 0x00010292 + OID_SWITCH_NIC_RESTORE_COMPLETE* = 0x00010293 + OID_SWITCH_NIC_UPDATED* = 0x00010294 + OID_SWITCH_PORT_UPDATED* = 0x00010295 + NDIS_PNP_WAKE_UP_MAGIC_PACKET* = 0x00000001 + NDIS_PNP_WAKE_UP_PATTERN_MATCH* = 0x00000002 + NDIS_PNP_WAKE_UP_LINK_CHANGE* = 0x00000004 + OID_TCP_TASK_OFFLOAD* = 0xfc010201'i32 + OID_TCP_TASK_IPSEC_ADD_SA* = 0xfc010202'i32 + OID_TCP_TASK_IPSEC_DELETE_SA* = 0xfc010203'i32 + OID_TCP_SAN_SUPPORT* = 0xfc010204'i32 + OID_TCP_TASK_IPSEC_ADD_UDPESP_SA* = 0xfc010205'i32 + OID_TCP_TASK_IPSEC_DELETE_UDPESP_SA* = 0xfc010206'i32 + OID_TCP4_OFFLOAD_STATS* = 0xfc010207'i32 + OID_TCP6_OFFLOAD_STATS* = 0xfc010208'i32 + OID_IP4_OFFLOAD_STATS* = 0xfc010209'i32 + OID_IP6_OFFLOAD_STATS* = 0xfc01020a'i32 + OID_TCP_OFFLOAD_CURRENT_CONFIG* = 0xfc01020b'i32 + OID_TCP_OFFLOAD_PARAMETERS* = 0xfc01020c'i32 + OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES* = 0xfc01020d'i32 + OID_TCP_CONNECTION_OFFLOAD_CURRENT_CONFIG* = 0xfc01020e'i32 + OID_TCP_CONNECTION_OFFLOAD_HARDWARE_CAPABILITIES* = 0xfc01020f'i32 + OID_OFFLOAD_ENCAPSULATION* = 0x0101010a + OID_TCP_TASK_IPSEC_OFFLOAD_V2_ADD_SA* = 0xfc030202'i32 + OID_TCP_TASK_IPSEC_OFFLOAD_V2_DELETE_SA* = 0xfc030203'i32 + OID_TCP_TASK_IPSEC_OFFLOAD_V2_UPDATE_SA* = 0xfc030204'i32 + OID_TCP_TASK_IPSEC_OFFLOAD_V2_ADD_SA_EX* = 0xfc030205'i32 + OID_FFP_SUPPORT* = 0xfc010210'i32 + OID_FFP_FLUSH* = 0xfc010211'i32 + OID_FFP_CONTROL* = 0xfc010212'i32 + OID_FFP_PARAMS* = 0xfc010213'i32 + OID_FFP_DATA* = 0xfc010214'i32 + OID_FFP_DRIVER_STATS* = 0xfc020210'i32 + OID_FFP_ADAPTER_STATS* = 0xfc020211'i32 + OID_TCP_CONNECTION_OFFLOAD_PARAMETERS* = 0xfc030201'i32 + OID_TUNNEL_INTERFACE_SET_OID* = 0x0f010106 + OID_TUNNEL_INTERFACE_RELEASE_OID* = 0x0f010107 + OID_QOS_RESERVED1* = 0xfb010100'i32 + OID_QOS_RESERVED2* = 0xfb010101'i32 + OID_QOS_RESERVED3* = 0xfb010102'i32 + OID_QOS_RESERVED4* = 0xfb010103'i32 + OID_QOS_RESERVED5* = 0xfb010104'i32 + OID_QOS_RESERVED6* = 0xfb010105'i32 + OID_QOS_RESERVED7* = 0xfb010106'i32 + OID_QOS_RESERVED8* = 0xfb010107'i32 + OID_QOS_RESERVED9* = 0xfb010108'i32 + OID_QOS_RESERVED10* = 0xfb010109'i32 + OID_QOS_RESERVED11* = 0xfb01010a'i32 + OID_QOS_RESERVED12* = 0xfb01010b'i32 + OID_QOS_RESERVED13* = 0xfb01010c'i32 + OID_QOS_RESERVED14* = 0xfb01010d'i32 + OID_QOS_RESERVED15* = 0xfb01010e'i32 + OID_QOS_RESERVED16* = 0xfb01010f'i32 + OID_QOS_RESERVED17* = 0xfb010110'i32 + OID_QOS_RESERVED18* = 0xfb010111'i32 + OID_QOS_RESERVED19* = 0xfb010112'i32 + OID_QOS_RESERVED20* = 0xfb010113'i32 + OFFLOAD_INBOUND_SA* = 0x0001 + OFFLOAD_OUTBOUND_SA* = 0x0002 + ENCRYPT* = 2 + OFFLOAD_IPSEC_CONF_NONE* = 0 + OFFLOAD_IPSEC_CONF_DES* = 1 + OFFLOAD_IPSEC_CONF_RESERVED* = 2 + OFFLOAD_IPSEC_CONF_3_DES* = 3 + OFFLOAD_IPSEC_CONF_MAX* = 4 + OFFLOAD_IPSEC_INTEGRITY_NONE* = 0 + OFFLOAD_IPSEC_INTEGRITY_MD5* = 1 + OFFLOAD_IPSEC_INTEGRITY_SHA* = 2 + OFFLOAD_IPSEC_INTEGRITY_MAX* = 3 + OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_IKE* = 0 + OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_OTHER* = 1 + NdisMedium802_3* = 0 + NdisMedium802_5* = 1 + ndisMediumFddi* = 2 + ndisMediumWan* = 3 + ndisMediumLocalTalk* = 4 + ndisMediumDix* = 5 + ndisMediumArcnetRaw* = 6 + NdisMediumArcnet878_2* = 7 + ndisMediumAtm* = 8 + ndisMediumWirelessWan* = 9 + ndisMediumIrda* = 10 + ndisMediumBpc* = 11 + ndisMediumCoWan* = 12 + ndisMedium1394* = 13 + ndisMediumInfiniBand* = 14 + ndisMediumTunnel* = 15 + NdisMediumNative802_11* = 16 + ndisMediumLoopback* = 17 + ndisMediumWiMAX* = 18 + ndisMediumIP* = 19 + ndisMediumMax* = 20 + ndisPhysicalMediumUnspecified* = 0 + ndisPhysicalMediumWirelessLan* = 1 + ndisPhysicalMediumCableModem* = 2 + ndisPhysicalMediumPhoneLine* = 3 + ndisPhysicalMediumPowerLine* = 4 + ndisPhysicalMediumDSL* = 5 + ndisPhysicalMediumFibreChannel* = 6 + ndisPhysicalMedium1394* = 7 + ndisPhysicalMediumWirelessWan* = 8 + NdisPhysicalMediumNative802_11* = 9 + ndisPhysicalMediumBluetooth* = 10 + ndisPhysicalMediumInfiniband* = 11 + ndisPhysicalMediumWiMax* = 12 + ndisPhysicalMediumUWB* = 13 + NdisPhysicalMedium802_3* = 14 + NdisPhysicalMedium802_5* = 15 + ndisPhysicalMediumIrda* = 16 + ndisPhysicalMediumWiredWAN* = 17 + ndisPhysicalMediumWiredCoWan* = 18 + ndisPhysicalMediumOther* = 19 + ndisPhysicalMediumMax* = 20 + NDIS_PROTOCOL_ID_DEFAULT* = 0x00 + NDIS_PROTOCOL_ID_TCP_IP* = 0x02 + NDIS_PROTOCOL_ID_IPX* = 0x06 + NDIS_PROTOCOL_ID_NBF* = 0x07 + NDIS_PROTOCOL_ID_MAX* = 0x0f + NDIS_PROTOCOL_ID_MASK* = 0x0f + READABLE_LOCAL_CLOCK* = 0x00000001 + CLOCK_NETWORK_DERIVED* = 0x00000002 + CLOCK_PRECISION* = 0x00000004 + RECEIVE_TIME_INDICATION_CAPABLE* = 0x00000008 + TIMED_SEND_CAPABLE* = 0x00000010 + TIME_STAMP_CAPABLE* = 0x00000020 + NDIS_DEVICE_WAKE_UP_ENABLE* = 0x00000001 + NDIS_DEVICE_WAKE_ON_PATTERN_MATCH_ENABLE* = 0x00000002 + NDIS_DEVICE_WAKE_ON_MAGIC_PACKET_ENABLE* = 0x00000004 + WAN_PROTOCOL_KEEPS_STATS* = 0x00000001 + ndisHardwareStatusReady* = 0 + ndisHardwareStatusInitializing* = 1 + ndisHardwareStatusReset* = 2 + ndisHardwareStatusClosing* = 3 + ndisHardwareStatusNotReady* = 4 + ndisDeviceStateUnspecified* = 0 + ndisDeviceStateD0* = 1 + ndisDeviceStateD1* = 2 + ndisDeviceStateD2* = 3 + ndisDeviceStateD3* = 4 + ndisDeviceStateMaximum* = 5 + ndisFddiTypeIsolated* = 1 + ndisFddiTypeLocalA* = 2 + ndisFddiTypeLocalB* = 3 + ndisFddiTypeLocalAB* = 4 + ndisFddiTypeLocalS* = 5 + ndisFddiTypeWrapA* = 6 + ndisFddiTypeWrapB* = 7 + ndisFddiTypeWrapAB* = 8 + ndisFddiTypeWrapS* = 9 + ndisFddiTypeCWrapA* = 10 + ndisFddiTypeCWrapB* = 11 + ndisFddiTypeCWrapS* = 12 + ndisFddiTypeThrough* = 13 + ndisFddiRingIsolated* = 1 + ndisFddiRingNonOperational* = 2 + ndisFddiRingOperational* = 3 + ndisFddiRingDetect* = 4 + ndisFddiRingNonOperationalDup* = 5 + ndisFddiRingOperationalDup* = 6 + ndisFddiRingDirected* = 7 + ndisFddiRingTrace* = 8 + ndisFddiStateOff* = 1 + ndisFddiStateBreak* = 2 + ndisFddiStateTrace* = 3 + ndisFddiStateConnect* = 4 + ndisFddiStateNext* = 5 + ndisFddiStateSignal* = 6 + ndisFddiStateJoin* = 7 + ndisFddiStateVerify* = 8 + ndisFddiStateActive* = 9 + ndisFddiStateMaintenance* = 10 + ndisWanMediumHub* = 0 + NdisWanMediumX_25* = 1 + ndisWanMediumIsdn* = 2 + ndisWanMediumSerial* = 3 + ndisWanMediumFrameRelay* = 4 + ndisWanMediumAtm* = 5 + ndisWanMediumSonet* = 6 + ndisWanMediumSW56K* = 7 + ndisWanMediumPPTP* = 8 + ndisWanMediumL2TP* = 9 + ndisWanMediumIrda* = 10 + ndisWanMediumParallel* = 11 + ndisWanMediumPppoe* = 12 + ndisWanMediumSSTP* = 13 + ndisWanMediumAgileVPN* = 14 + ndisWanHeaderNative* = 0 + ndisWanHeaderEthernet* = 1 + ndisWanRaw* = 0 + ndisWanErrorControl* = 1 + ndisWanReliable* = 2 + ndisRingStateOpened* = 1 + ndisRingStateClosed* = 2 + ndisRingStateOpening* = 3 + ndisRingStateClosing* = 4 + ndisRingStateOpenFailure* = 5 + ndisRingStateRingFailure* = 6 + ndisMediaStateConnected* = 0 + ndisMediaStateDisconnected* = 1 + fNDIS_GUID_TO_OID* = 0x00000001 + fNDIS_GUID_TO_STATUS* = 0x00000002 + fNDIS_GUID_ANSI_STRING* = 0x00000004 + fNDIS_GUID_UNICODE_STRING* = 0x00000008 + fNDIS_GUID_ARRAY* = 0x00000010 + fNDIS_GUID_ALLOW_READ* = 0x00000020 + fNDIS_GUID_ALLOW_WRITE* = 0x00000040 + fNDIS_GUID_METHOD* = 0x00000080 + fNDIS_GUID_NDIS_RESERVED* = 0x00000100 + fNDIS_GUID_SUPPORT_COMMON_HEADER* = 0x00000200 + NDIS_PACKET_TYPE_DIRECTED* = 0x00000001 + NDIS_PACKET_TYPE_MULTICAST* = 0x00000002 + NDIS_PACKET_TYPE_ALL_MULTICAST* = 0x00000004 + NDIS_PACKET_TYPE_BROADCAST* = 0x00000008 + NDIS_PACKET_TYPE_SOURCE_ROUTING* = 0x00000010 + NDIS_PACKET_TYPE_PROMISCUOUS* = 0x00000020 + NDIS_PACKET_TYPE_SMT* = 0x00000040 + NDIS_PACKET_TYPE_ALL_LOCAL* = 0x00000080 + NDIS_PACKET_TYPE_GROUP* = 0x00001000 + NDIS_PACKET_TYPE_ALL_FUNCTIONAL* = 0x00002000 + NDIS_PACKET_TYPE_FUNCTIONAL* = 0x00004000 + NDIS_PACKET_TYPE_MAC_FRAME* = 0x00008000 + NDIS_PACKET_TYPE_NO_LOCAL* = 0x00010000 + NDIS_RING_SIGNAL_LOSS* = 0x00008000 + NDIS_RING_HARD_ERROR* = 0x00004000 + NDIS_RING_SOFT_ERROR* = 0x00002000 + NDIS_RING_TRANSMIT_BEACON* = 0x00001000 + NDIS_RING_LOBE_WIRE_FAULT* = 0x00000800 + NDIS_RING_AUTO_REMOVAL_ERROR* = 0x00000400 + NDIS_RING_REMOVE_RECEIVED* = 0x00000200 + NDIS_RING_COUNTER_OVERFLOW* = 0x00000100 + NDIS_RING_SINGLE_STATION* = 0x00000080 + NDIS_RING_RING_RECOVERY* = 0x00000040 + NDIS_PROT_OPTION_ESTIMATED_LENGTH* = 0x00000001 + NDIS_PROT_OPTION_NO_LOOPBACK* = 0x00000002 + NDIS_PROT_OPTION_NO_RSVD_ON_RCVPKT* = 0x00000004 + NDIS_PROT_OPTION_SEND_RESTRICTED* = 0x00000008 + NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA* = 0x00000001 + NDIS_MAC_OPTION_RECEIVE_SERIALIZED* = 0x00000002 + NDIS_MAC_OPTION_TRANSFERS_NOT_PEND* = 0x00000004 + NDIS_MAC_OPTION_NO_LOOPBACK* = 0x00000008 + NDIS_MAC_OPTION_FULL_DUPLEX* = 0x00000010 + NDIS_MAC_OPTION_EOTX_INDICATION* = 0x00000020 + NDIS_MAC_OPTION_8021P_PRIORITY* = 0x00000040 + NDIS_MAC_OPTION_SUPPORTS_MAC_ADDRESS_OVERWRITE* = 0x00000080 + NDIS_MAC_OPTION_RECEIVE_AT_DPC* = 0x00000100 + NDIS_MAC_OPTION_8021Q_VLAN* = 0x00000200 + NDIS_MAC_OPTION_RESERVED* = 0x80000000'i32 + NDIS_MEDIA_CAP_TRANSMIT* = 0x00000001 + NDIS_MEDIA_CAP_RECEIVE* = 0x00000002 + NDIS_CO_MAC_OPTION_DYNAMIC_LINK_SPEED* = 0x00000001 + NDIS_LINK_STATE_XMIT_LINK_SPEED_AUTO_NEGOTIATED* = 0x00000001 + NDIS_LINK_STATE_RCV_LINK_SPEED_AUTO_NEGOTIATED* = 0x00000002 + NDIS_LINK_STATE_DUPLEX_AUTO_NEGOTIATED* = 0x00000004 + NDIS_LINK_STATE_PAUSE_FUNCTIONS_AUTO_NEGOTIATED* = 0x00000008 + NDIS_LINK_STATE_REVISION_1* = 1 + NDIS_LINK_PARAMETERS_REVISION_1* = 1 + NDIS_OPER_STATE_REVISION_1* = 1 + NDIS_IP_OPER_STATUS_INFO_REVISION_1* = 1 + NDIS_IP_OPER_STATE_REVISION_1* = 1 + ndisPauseFunctionsUnsupported* = 0 + ndisPauseFunctionsSendOnly* = 1 + ndisPauseFunctionsReceiveOnly* = 2 + ndisPauseFunctionsSendAndReceive* = 3 + ndisPauseFunctionsUnknown* = 4 + NDIS_OFFLOAD_PARAMETERS_NO_CHANGE* = 0 + NDIS_OFFLOAD_PARAMETERS_TX_RX_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_TX_ENABLED_RX_DISABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_RX_ENABLED_TX_DISABLED* = 3 + NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED* = 4 + NDIS_OFFLOAD_PARAMETERS_LSOV1_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_LSOV1_ENABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_IPSECV1_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_IPSECV1_AH_ENABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_IPSECV1_ESP_ENABLED* = 3 + NDIS_OFFLOAD_PARAMETERS_IPSECV1_AH_AND_ESP_ENABLED* = 4 + NDIS_OFFLOAD_PARAMETERS_LSOV2_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_IPSECV2_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_IPSECV2_AH_ENABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_IPSECV2_ESP_ENABLED* = 3 + NDIS_OFFLOAD_PARAMETERS_IPSECV2_AH_AND_ESP_ENABLED* = 4 + NDIS_OFFLOAD_PARAMETERS_RSC_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED* = 2 + NDIS_ENCAPSULATION_TYPE_GRE_MAC* = 0x00000001 + NDIS_ENCAPSULATION_TYPE_MAX* = NDIS_ENCAPSULATION_TYPE_GRE_MAC + NDIS_OFFLOAD_PARAMETERS_CONNECTION_OFFLOAD_DISABLED* = 1 + NDIS_OFFLOAD_PARAMETERS_CONNECTION_OFFLOAD_ENABLED* = 2 + NDIS_OFFLOAD_PARAMETERS_REVISION_1* = 1 + NDIS_OFFLOAD_PARAMETERS_REVISION_2* = 2 + NDIS_OFFLOAD_PARAMETERS_REVISION_3* = 3 + NDIS_OFFLOAD_PARAMETERS_SKIP_REGISTRY_UPDATE* = 0x00000001 +proc Flags*(self: IP_ADAPTER_UNICAST_ADDRESS_XP): DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP): var DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: IP_ADAPTER_UNICAST_ADDRESS_LH): DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH): var DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: IP_ADAPTER_ANYCAST_ADDRESS_XP): DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP): var DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: IP_ADAPTER_MULTICAST_ADDRESS_XP): DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP): var DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: IP_ADAPTER_PREFIX_XP): DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: var IP_ADAPTER_PREFIX_XP): var DWORD {.inline.} = self.union1.struct1.Flags +proc Flags*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.Flags +proc Flags*(self: var IP_ADAPTER_ADDRESSES_LH): var ULONG {.inline.} = self.union2.Flags +proc Flags*(self: MIB_IPNET_ROW2): UCHAR {.inline.} = self.union1.Flags +proc Flags*(self: var MIB_IPNET_ROW2): var UCHAR {.inline.} = self.union1.Flags +proc EncapsulationTypes*(self: NDIS_OFFLOAD_PARAMETERS): UCHAR {.inline.} = self.struct2.EncapsulationTypes +proc EncapsulationTypes*(self: var NDIS_OFFLOAD_PARAMETERS): var UCHAR {.inline.} = self.struct2.EncapsulationTypes +const + NDIS_OFFLOAD_NOT_SUPPORTED* = 0 + NDIS_OFFLOAD_SUPPORTED* = 1 + NDIS_OFFLOAD_SET_NO_CHANGE* = 0 + NDIS_OFFLOAD_SET_ON* = 1 + NDIS_OFFLOAD_SET_OFF* = 2 + NDIS_ENCAPSULATION_NOT_SUPPORTED* = 0x00000000 + NDIS_ENCAPSULATION_NULL* = 0x00000001 + NDIS_ENCAPSULATION_IEEE_802_3* = 0x00000002 + NDIS_ENCAPSULATION_IEEE_802_3_P_AND_Q* = 0x00000004 + NDIS_ENCAPSULATION_IEEE_802_3_P_AND_Q_IN_OOB* = 0x00000008 + NDIS_ENCAPSULATION_IEEE_LLC_SNAP_ROUTED* = 0x00000010 + IPSEC_OFFLOAD_V2_AUTHENTICATION_MD5* = 0x00000001 + IPSEC_OFFLOAD_V2_AUTHENTICATION_SHA_1* = 0x00000002 + IPSEC_OFFLOAD_V2_AUTHENTICATION_SHA_256* = 0x00000004 + IPSEC_OFFLOAD_V2_AUTHENTICATION_AES_GCM_128* = 0x00000008 + IPSEC_OFFLOAD_V2_AUTHENTICATION_AES_GCM_192* = 0x00000010 + IPSEC_OFFLOAD_V2_AUTHENTICATION_AES_GCM_256* = 0x00000020 + IPSEC_OFFLOAD_V2_ENCRYPTION_NONE* = 0x00000001 + IPSEC_OFFLOAD_V2_ENCRYPTION_DES_CBC* = 0x00000002 + IPSEC_OFFLOAD_V2_ENCRYPTION_3_DES_CBC* = 0x00000004 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_GCM_128* = 0x00000008 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_GCM_192* = 0x00000010 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_GCM_256* = 0x00000020 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_CBC_128* = 0x00000040 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_CBC_192* = 0x00000080 + IPSEC_OFFLOAD_V2_ENCRYPTION_AES_CBC_256* = 0x00000100 + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD_NOT_SUPPORTED* = 0x00000000 + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD_INNER_IPV4* = 0x00000001 + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD_OUTER_IPV4* = 0x00000002 + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD_INNER_IPV6* = 0x00000004 + NDIS_ENCAPSULATED_PACKET_TASK_OFFLOAD_OUTER_IPV6* = 0x00000008 + NDIS_OFFLOAD_FLAGS_GROUP_CHECKSUM_CAPABILITIES* = 0x1 + IPSEC_OFFLOAD_V2_AND_TCP_CHECKSUM_COEXISTENCE* = 0x2 + IPSEC_OFFLOAD_V2_AND_UDP_CHECKSUM_COEXISTENCE* = 0x4 + NDIS_MAXIMUM_PORTS* = 0x1000000 + NDIS_DEFAULT_PORT_NUMBER* = NDIS_PORT_NUMBER 0 + NDIS_WMI_DEFAULT_METHOD_ID* = 1 + NDIS_WMI_OBJECT_TYPE_SET* = 0x01 + NDIS_WMI_OBJECT_TYPE_METHOD* = 0x02 + NDIS_WMI_OBJECT_TYPE_EVENT* = 0x03 + NDIS_WMI_OBJECT_TYPE_ENUM_ADAPTER* = 0x04 + NDIS_WMI_OBJECT_TYPE_OUTPUT_INFO* = 0x05 + NDIS_DEVICE_TYPE_ENDPOINT* = 0x00000001 + NDIS_OFFLOAD_REVISION_1* = 1 + NDIS_TCP_CONNECTION_OFFLOAD_REVISION_1* = 1 + NDIS_PORT_AUTHENTICATION_PARAMETERS_REVISION_1* = 1 + NDIS_WMI_METHOD_HEADER_REVISION_1* = 1 + NDIS_WMI_SET_HEADER_REVISION_1* = 1 + NDIS_WMI_EVENT_HEADER_REVISION_1* = 1 + NDIS_WMI_ENUM_ADAPTER_REVISION_1* = 1 + NDIS_TCP_CONNECTION_OFFLOAD_REVISION_2* = 2 + NDIS_OFFLOAD_REVISION_2* = 2 + NDIS_OFFLOAD_REVISION_3* = 3 + NDIS_TCP_RECV_SEG_COALESC_OFFLOAD_REVISION_1* = 1 + ndisPortTypeUndefined* = 0 + ndisPortTypeBridge* = 1 + ndisPortTypeRasConnection* = 2 + ndisPortType8021xSupplicant* = 3 + ndisPortTypeNdisImPlatform* = 4 + ndisPortTypeMax* = 5 + ndisPortAuthorizationUnknown* = 0 + ndisPortAuthorized* = 1 + ndisPortUnauthorized* = 2 + ndisPortReauthorizing* = 3 + ndisPortControlStateUnknown* = 0 + ndisPortControlStateControlled* = 1 + ndisPortControlStateUncontrolled* = 2 + ndisPossibleNetworkChange* = 1 + ndisDefinitelyNetworkChange* = 2 + ndisNetworkChangeFromMediaConnect* = 3 + ndisNetworkChangeMax* = 4 + NDIS_HD_SPLIT_COMBINE_ALL_HEADERS* = 0x00000001 + NDIS_HD_SPLIT_CAPS_SUPPORTS_HEADER_DATA_SPLIT* = 0x00000001 + NDIS_HD_SPLIT_CAPS_SUPPORTS_IPV4_OPTIONS* = 0x00000002 + NDIS_HD_SPLIT_CAPS_SUPPORTS_IPV6_EXTENSION_HEADERS* = 0x00000004 + NDIS_HD_SPLIT_CAPS_SUPPORTS_TCP_OPTIONS* = 0x00000008 + NDIS_HD_SPLIT_ENABLE_HEADER_DATA_SPLIT* = 0x00000001 + NDIS_HD_SPLIT_PARAMETERS_REVISION_1* = 1 + NDIS_HD_SPLIT_CURRENT_CONFIG_REVISION_1* = 1 + NDIS_WMI_OUTPUT_INFO_REVISION_1* = 1 + NDIS_PM_WOL_BITMAP_PATTERN_SUPPORTED* = 0x00000001 + NDIS_PM_WOL_MAGIC_PACKET_SUPPORTED* = 0x00000002 + NDIS_PM_WOL_IPV4_TCP_SYN_SUPPORTED* = 0x00000004 + NDIS_PM_WOL_IPV6_TCP_SYN_SUPPORTED* = 0x00000008 + NDIS_PM_WOL_IPV4_DEST_ADDR_WILDCARD_SUPPORTED* = 0x00000200 + NDIS_PM_WOL_IPV6_DEST_ADDR_WILDCARD_SUPPORTED* = 0x00000800 + NDIS_PM_WOL_EAPOL_REQUEST_ID_MESSAGE_SUPPORTED* = 0x00010000 + NDIS_PM_PROTOCOL_OFFLOAD_ARP_SUPPORTED* = 0x00000001 + NDIS_PM_PROTOCOL_OFFLOAD_NS_SUPPORTED* = 0x00000002 + NDIS_PM_PROTOCOL_OFFLOAD_80211_RSN_REKEY_SUPPORTED* = 0x00000080 + NDIS_PM_WAKE_ON_MEDIA_CONNECT_SUPPORTED* = 0x00000001 + NDIS_PM_WAKE_ON_MEDIA_DISCONNECT_SUPPORTED* = 0x00000002 + NDIS_WLAN_WAKE_ON_NLO_DISCOVERY_SUPPORTED* = 0x00000001 + NDIS_WLAN_WAKE_ON_AP_ASSOCIATION_LOST_SUPPORTED* = 0x00000002 + NDIS_WLAN_WAKE_ON_GTK_HANDSHAKE_ERROR_SUPPORTED* = 0x00000004 + NDIS_WLAN_WAKE_ON_4WAY_HANDSHAKE_REQUEST_SUPPORTED* = 0x00000008 + NDIS_WWAN_WAKE_ON_REGISTER_STATE_SUPPORTED* = 0x00000001 + NDIS_WWAN_WAKE_ON_SMS_RECEIVE_SUPPORTED* = 0x00000002 + NDIS_WWAN_WAKE_ON_USSD_RECEIVE_SUPPORTED* = 0x00000004 + NDIS_PM_WAKE_PACKET_INDICATION_SUPPORTED* = 0x00000001 + NDIS_PM_SELECTIVE_SUSPEND_SUPPORTED* = 0x00000002 + NDIS_PM_WOL_BITMAP_PATTERN_ENABLED* = 0x00000001 + NDIS_PM_WOL_MAGIC_PACKET_ENABLED* = 0x00000002 + NDIS_PM_WOL_IPV4_TCP_SYN_ENABLED* = 0x00000004 + NDIS_PM_WOL_IPV6_TCP_SYN_ENABLED* = 0x00000008 + NDIS_PM_WOL_IPV4_DEST_ADDR_WILDCARD_ENABLED* = 0x00000200 + NDIS_PM_WOL_IPV6_DEST_ADDR_WILDCARD_ENABLED* = 0x00000800 + NDIS_PM_WOL_EAPOL_REQUEST_ID_MESSAGE_ENABLED* = 0x00010000 + NDIS_PM_PROTOCOL_OFFLOAD_ARP_ENABLED* = 0x00000001 + NDIS_PM_PROTOCOL_OFFLOAD_NS_ENABLED* = 0x00000002 + NDIS_PM_PROTOCOL_OFFLOAD_80211_RSN_REKEY_ENABLED* = 0x00000080 + NDIS_PM_WAKE_ON_LINK_CHANGE_ENABLED* = 0x1 + NDIS_PM_WAKE_ON_MEDIA_DISCONNECT_ENABLED* = 0x2 + NDIS_PM_SELECTIVE_SUSPEND_ENABLED* = 0x10 + NDIS_WLAN_WAKE_ON_NLO_DISCOVERY_ENABLED* = 0x1 + NDIS_WLAN_WAKE_ON_AP_ASSOCIATION_LOST_ENABLED* = 0x2 + NDIS_WLAN_WAKE_ON_GTK_HANDSHAKE_ERROR_ENABLED* = 0x4 + NDIS_WLAN_WAKE_ON_4WAY_HANDSHAKE_REQUEST_ENABLED* = 0x8 + NDIS_WWAN_WAKE_ON_REGISTER_STATE_ENABLED* = 0x1 + NDIS_WWAN_WAKE_ON_SMS_RECEIVE_ENABLED* = 0x2 + NDIS_WWAN_WAKE_ON_USSD_RECEIVE_ENABLED* = 0x4 + NDIS_PM_WOL_PRIORITY_LOWEST* = 0xffffffff'i32 + NDIS_PM_WOL_PRIORITY_NORMAL* = 0x10000000 + NDIS_PM_WOL_PRIORITY_HIGHEST* = 0x00000001 + NDIS_PM_PROTOCOL_OFFLOAD_PRIORITY_LOWEST* = 0xffffffff'i32 + NDIS_PM_PROTOCOL_OFFLOAD_PRIORITY_NORMAL* = 0x10000000 + NDIS_PM_PROTOCOL_OFFLOAD_PRIORITY_HIGHEST* = 0x00000001 + EAPOL_REQUEST_ID_WOL_FLAG_MUST_ENCRYPT* = 0x00000001 + NDIS_PM_MAX_PATTERN_ID* = 0x0000ffff + NDIS_PM_PRIVATE_PATTERN_ID* = 0x00000001 + NDIS_RECEIVE_FILTER_MAC_HEADER_SUPPORTED* = 0x00000001 + NDIS_RECEIVE_FILTER_IPV4_HEADER_SUPPORTED* = 0x00000002 + NDIS_RECEIVE_FILTER_IPV6_HEADER_SUPPORTED* = 0x00000004 + NDIS_RECEIVE_FILTER_ARP_HEADER_SUPPORTED* = 0x00000008 + NDIS_RECEIVE_FILTER_UDP_HEADER_SUPPORTED* = 0x00000010 + NDIS_RECEIVE_FILTER_MAC_HEADER_DEST_ADDR_SUPPORTED* = 0x00000001 + NDIS_RECEIVE_FILTER_MAC_HEADER_SOURCE_ADDR_SUPPORTED* = 0x00000002 + NDIS_RECEIVE_FILTER_MAC_HEADER_PROTOCOL_SUPPORTED* = 0x00000004 + NDIS_RECEIVE_FILTER_MAC_HEADER_VLAN_ID_SUPPORTED* = 0x00000008 + NDIS_RECEIVE_FILTER_MAC_HEADER_PRIORITY_SUPPORTED* = 0x00000010 + NDIS_RECEIVE_FILTER_MAC_HEADER_PACKET_TYPE_SUPPORTED* = 0x00000020 + NDIS_RECEIVE_FILTER_ARP_HEADER_OPERATION_SUPPORTED* = 0x1 + NDIS_RECEIVE_FILTER_ARP_HEADER_SPA_SUPPORTED* = 0x2 + NDIS_RECEIVE_FILTER_ARP_HEADER_TPA_SUPPORTED* = 0x4 + NDIS_RECEIVE_FILTER_IPV4_HEADER_PROTOCOL_SUPPORTED* = 0x1 + NDIS_RECEIVE_FILTER_IPV6_HEADER_PROTOCOL_SUPPORTED* = 0x1 + NDIS_RECEIVE_FILTER_UDP_HEADER_DEST_PORT_SUPPORTED* = 0x1 + NDIS_RECEIVE_FILTER_TEST_HEADER_FIELD_EQUAL_SUPPORTED* = 0x00000001 + NDIS_RECEIVE_FILTER_TEST_HEADER_FIELD_MASK_EQUAL_SUPPORTED* = 0x00000002 + NDIS_RECEIVE_FILTER_TEST_HEADER_FIELD_NOT_EQUAL_SUPPORTED* = 0x00000004 + NDIS_RECEIVE_FILTER_MSI_X_SUPPORTED* = 0x00000001 + NDIS_RECEIVE_FILTER_VM_QUEUE_SUPPORTED* = 0x00000002 + NDIS_RECEIVE_FILTER_LOOKAHEAD_SPLIT_SUPPORTED* = 0x00000004 + NDIS_RECEIVE_FILTER_DYNAMIC_PROCESSOR_AFFINITY_CHANGE_SUPPORTED* = 0x00000008 + NDIS_RECEIVE_FILTER_INTERRUPT_VECTOR_COALESCING_SUPPORTED* = 0x00000010 + NDIS_RECEIVE_FILTER_ANY_VLAN_SUPPORTED* = 0x00000020 + NDIS_RECEIVE_FILTER_IMPLAT_MIN_OF_QUEUES_MODE* = 0x00000040 + NDIS_RECEIVE_FILTER_IMPLAT_SUM_OF_QUEUES_MODE* = 0x00000080 + NDIS_RECEIVE_FILTER_PACKET_COALESCING_SUPPORTED_ON_DEFAULT_QUEUE* = 0x00000100 + NDIS_RECEIVE_FILTER_VMQ_FILTERS_ENABLED* = 0x00000001 + NDIS_RECEIVE_FILTER_PACKET_COALESCING_FILTERS_ENABLED* = 0x00000002 + NDIS_RECEIVE_FILTER_VM_QUEUES_ENABLED* = 0x00000001 + NDIS_NIC_SWITCH_CAPS_VLAN_SUPPORTED* = 0x00000001 + NDIS_NIC_SWITCH_CAPS_PER_VPORT_INTERRUPT_MODERATION_SUPPORTED* = 0x00000002 + NDIS_NIC_SWITCH_CAPS_ASYMMETRIC_QUEUE_PAIRS_FOR_NONDEFAULT_VPORT_SUPPORTED* = 0x00000004 + NDIS_NIC_SWITCH_CAPS_VF_RSS_SUPPORTED* = 0x00000008 + NDIS_NIC_SWITCH_CAPS_SINGLE_VPORT_POOL* = 0x00000010 + NDIS_DEFAULT_RECEIVE_QUEUE_ID* = 0 + NDIS_DEFAULT_RECEIVE_QUEUE_GROUP_ID* = 0 + NDIS_DEFAULT_RECEIVE_FILTER_ID* = 0 + NDIS_RECEIVE_FILTER_FIELD_MAC_HEADER_VLAN_UNTAGGED_OR_ZERO* = 0x00000001 + NDIS_RECEIVE_FILTER_PACKET_ENCAPSULATION_GRE* = 0x00000002 + NDIS_RECEIVE_QUEUE_PARAMETERS_PER_QUEUE_RECEIVE_INDICATION* = 0x00000001 + NDIS_RECEIVE_QUEUE_PARAMETERS_LOOKAHEAD_SPLIT_REQUIRED* = 0x00000002 + NDIS_RECEIVE_QUEUE_PARAMETERS_FLAGS_CHANGED* = 0x00010000 + NDIS_RECEIVE_QUEUE_PARAMETERS_PROCESSOR_AFFINITY_CHANGED* = 0x00020000 + NDIS_RECEIVE_QUEUE_PARAMETERS_SUGGESTED_RECV_BUFFER_NUMBERS_CHANGED* = 0x00040000 + NDIS_RECEIVE_QUEUE_PARAMETERS_NAME_CHANGED* = 0x00080000 + NDIS_RECEIVE_QUEUE_PARAMETERS_INTERRUPT_COALESCING_DOMAIN_ID_CHANGED* = 0x00100000 + NDIS_RECEIVE_QUEUE_PARAMETERS_CHANGE_MASK* = 0xffff0000'i32 + NDIS_RECEIVE_FILTER_INFO_ARRAY_VPORT_ID_SPECIFIED* = 0x00000001 + NDIS_PM_CAPABILITIES_REVISION_1* = 1 + NDIS_PM_PARAMETERS_REVISION_1* = 1 + NDIS_PM_WOL_PATTERN_REVISION_1* = 1 + NDIS_PM_PROTOCOL_OFFLOAD_REVISION_1* = 1 + NDIS_WMI_PM_ADMIN_CONFIG_REVISION_1* = 1 + NDIS_WMI_PM_ACTIVE_CAPABILITIES_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_CAPABILITIES_REVISION_1* = 1 + NDIS_NIC_SWITCH_CAPABILITIES_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_GLOBAL_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_CLEAR_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_FREE_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_INFO_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_INFO_ARRAY_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_INFO_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_INFO_ARRAY_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_QUEUE_ALLOCATION_COMPLETE_ARRAY_REVISION_1* = 1 + NDIS_PM_CAPABILITIES_REVISION_2* = 2 + NDIS_PM_PARAMETERS_REVISION_2* = 2 + NDIS_PM_WOL_PATTERN_REVISION_2* = 2 + NDIS_PM_WAKE_REASON_REVISION_1* = 1 + NDIS_PM_WAKE_PACKET_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_CAPABILITIES_REVISION_2* = 2 + NDIS_NIC_SWITCH_CAPABILITIES_REVISION_2* = 2 + NDIS_RECEIVE_FILTER_FIELD_PARAMETERS_REVISION_2* = 2 + NDIS_RECEIVE_FILTER_PARAMETERS_REVISION_2* = 2 + NDIS_RECEIVE_QUEUE_PARAMETERS_REVISION_2* = 2 + NDIS_RECEIVE_FILTER_INFO_ARRAY_REVISION_2* = 2 + NDIS_RECEIVE_QUEUE_INFO_REVISION_2* = 2 + ndisPMWoLPacketUnspecified* = 0 + ndisPMWoLPacketBitmapPattern* = 1 + ndisPMWoLPacketMagicPacket* = 2 + ndisPMWoLPacketIPv4TcpSyn* = 3 + ndisPMWoLPacketIPv6TcpSyn* = 4 + ndisPMWoLPacketEapolRequestIdMessage* = 5 + ndisPMWoLPacketMaximum* = 6 + ndisPMProtocolOffloadIdUnspecified* = 0 + ndisPMProtocolOffloadIdIPv4ARP* = 1 + ndisPMProtocolOffloadIdIPv6NS* = 2 + ndisPMProtocolOffload80211RSNRekey* = 3 + ndisPMProtocolOffloadIdMaximum* = 4 + ndisWakeReasonUnspecified* = 0x0000 + ndisWakeReasonPacket* = 0x0001 + ndisWakeReasonMediaDisconnect* = 0x0002 + ndisWakeReasonMediaConnect* = 0x0003 + ndisWakeReasonWlanNLODiscovery* = 0x1000 + ndisWakeReasonWlanAPAssociationLost* = 0x1001 + ndisWakeReasonWlanGTKHandshakeError* = 0x1002 + ndisWakeReasonWlan4WayHandshakeRequest* = 0x1003 + ndisWakeReasonWwanRegisterState* = 0x2000 + ndisWakeReasonWwanSMSReceive* = 0x2001 + ndisWakeReasonWwanUSSDReceive* = 0x2002 + ndisPMAdminConfigUnspecified* = 0 + ndisPMAdminConfigDisabled* = 1 + ndisPMAdminConfigEnabled* = 2 + ndisPMAdminConfigUnsupported* = 0 + ndisPMAdminConfigInactive* = 1 + ndisPMAdminConfigActive* = 2 + ndisReceiveFilterTypeUndefined* = 0 + ndisReceiveFilterTypeVMQueue* = 1 + ndisReceiveFilterTypePacketCoalescing* = 2 + ndisReceiveFilterTypeMaximum* = 3 + ndisFrameHeaderUndefined* = 0 + ndisFrameHeaderMac* = 1 + ndisFrameHeaderArp* = 2 + ndisFrameHeaderIPv4* = 3 + ndisFrameHeaderIPv6* = 4 + ndisFrameHeaderUdp* = 5 + ndisFrameHeaderMaximum* = 6 + ndisMacHeaderFieldUndefined* = 0 + ndisMacHeaderFieldDestinationAddress* = 1 + ndisMacHeaderFieldSourceAddress* = 2 + ndisMacHeaderFieldProtocol* = 3 + ndisMacHeaderFieldVlanId* = 4 + ndisMacHeaderFieldPriority* = 5 + ndisMacHeaderFieldPacketType* = 6 + ndisMacHeaderFieldMaximum* = 7 + ndisMacPacketTypeUndefined* = 0 + ndisMacPacketTypeUnicast* = 1 + ndisMacPacketTypeMulticast* = 2 + ndisMacPacketTypeBroadcast* = 3 + ndisMacPacketTypeMaximum* = 4 + ndisARPHeaderFieldUndefined* = 0 + ndisARPHeaderFieldOperation* = 1 + ndisARPHeaderFieldSPA* = 2 + ndisARPHeaderFieldTPA* = 3 + ndisARPHeaderFieldMaximum* = 4 + ndisIPv4HeaderFieldUndefined* = 0 + ndisIPv4HeaderFieldProtocol* = 1 + ndisIPv4HeaderFieldMaximum* = 2 + ndisIPv6HeaderFieldUndefined* = 0 + ndisIPv6HeaderFieldProtocol* = 1 + ndisIPv6HeaderFieldMaximum* = 2 + ndisUdpHeaderFieldUndefined* = 0 + ndisUdpHeaderFieldDestinationPort* = 1 + ndisUdpHeaderFieldMaximum* = 2 + ndisReceiveFilterTestUndefined* = 0 + ndisReceiveFilterTestEqual* = 1 + ndisReceiveFilterTestMaskEqual* = 2 + ndisReceiveFilterTestNotEqual* = 3 + ndisReceiveFilterTestMaximum* = 4 + ndisReceiveQueueTypeUnspecified* = 0 + ndisReceiveQueueTypeVMQueue* = 1 + ndisReceiveQueueTypeMaximum* = 2 + ndisReceiveQueueOperationalStateUndefined* = 0 + ndisReceiveQueueOperationalStateRunning* = 1 + ndisReceiveQueueOperationalStatePaused* = 2 + ndisReceiveQueueOperationalStateDmaStopped* = 3 + ndisReceiveQueueOperationalStateMaximum* = 4 + NDIS_RSS_CAPS_MESSAGE_SIGNALED_INTERRUPTS* = 0x01000000 + NDIS_RSS_CAPS_CLASSIFICATION_AT_ISR* = 0x02000000 + NDIS_RSS_CAPS_CLASSIFICATION_AT_DPC* = 0x04000000 + NDIS_RSS_CAPS_USING_MSI_X* = 0x08000000 + NDIS_RSS_CAPS_RSS_AVAILABLE_ON_PORTS* = 0x10000000 + NDIS_RSS_CAPS_SUPPORTS_MSI_X* = 0x20000000 + NDIS_RSS_CAPS_HASH_TYPE_TCP_IPV4* = 0x00000100 + NDIS_RSS_CAPS_HASH_TYPE_TCP_IPV6* = 0x00000200 + NDIS_RSS_CAPS_HASH_TYPE_TCP_IPV6_EX* = 0x00000400 + ndisHashFunctionToeplitz* = 0x00000001 + ndisHashFunctionReserved1* = 0x00000002 + ndisHashFunctionReserved2* = 0x00000004 + ndisHashFunctionReserved3* = 0x00000008 + NDIS_HASH_FUNCTION_MASK* = 0x000000ff + NDIS_HASH_TYPE_MASK* = 0x00ffff00 + NDIS_HASH_IPV4* = 0x00000100 + NDIS_HASH_TCP_IPV4* = 0x00000200 + NDIS_HASH_IPV6* = 0x00000400 + NDIS_HASH_IPV6_EX* = 0x00000800 + NDIS_HASH_TCP_IPV6* = 0x00001000 + NDIS_HASH_TCP_IPV6_EX* = 0x00002000 + NDIS_RSS_PARAM_FLAG_BASE_CPU_UNCHANGED* = 0x0001 + NDIS_RSS_PARAM_FLAG_HASH_INFO_UNCHANGED* = 0x0002 + NDIS_RSS_PARAM_FLAG_ITABLE_UNCHANGED* = 0x0004 + NDIS_RSS_PARAM_FLAG_HASH_KEY_UNCHANGED* = 0x0008 + NDIS_RSS_PARAM_FLAG_DISABLE_RSS* = 0x0010 + NDIS_RSS_INDIRECTION_TABLE_SIZE_REVISION_1* = 128 + NDIS_RSS_HASH_SECRET_KEY_SIZE_REVISION_1* = 40 + NDIS_RSS_INDIRECTION_TABLE_MAX_SIZE_REVISION_1* = 128 + NDIS_RSS_HASH_SECRET_KEY_MAX_SIZE_REVISION_1* = 40 + NDIS_RSS_HASH_SECRET_KEY_MAX_SIZE_REVISION_2* = 40 + NDIS_RECEIVE_HASH_FLAG_ENABLE_HASH* = 0x00000001 + NDIS_RECEIVE_HASH_FLAG_HASH_INFO_UNCHANGED* = 0x00000002 + NDIS_RECEIVE_HASH_FLAG_HASH_KEY_UNCHANGED* = 0x00000004 + NDIS_PORT_CHAR_USE_DEFAULT_AUTH_SETTINGS* = 0x00000001 + NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_1* = 1 + NDIS_RECEIVE_HASH_PARAMETERS_REVISION_1* = 1 + NDIS_PORT_STATE_REVISION_1* = 1 + NDIS_PORT_CHARACTERISTICS_REVISION_1* = 1 + NDIS_PORT_ARRAY_REVISION_1* = 1 + NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_1* = 1 + NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2* = 2 + NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2* = 2 + ndisProcessorVendorUnknown* = 0 + ndisProcessorVendorGenuinIntel* = 1 + ndisProcessorVendorGenuineIntel* = ndisProcessorVendorGenuinIntel + ndisProcessorVendorAuthenticAMD* = ndisProcessorVendorGenuinIntel+1 + NDIS_HYPERVISOR_INFO_FLAG_HYPERVISOR_PRESENT* = 0x00000001 + NDIS_RSS_PROCESSOR_INFO_REVISION_1* = 1 + NDIS_SYSTEM_PROCESSOR_INFO_EX_REVISION_1* = 1 + NDIS_HYPERVISOR_INFO_REVISION_1* = 1 + NDIS_WMI_RECEIVE_QUEUE_INFO_REVISION_1* = 1 + NDIS_WMI_RECEIVE_QUEUE_PARAMETERS_REVISION_1* = 1 + NDIS_RSS_PROCESSOR_INFO_REVISION_2* = 2 + ndisRssProfileClosest* = 1 + ndisRssProfileClosestStatic* = 2 + ndisRssProfileNuma* = 3 + ndisRssProfileNumaStatic* = 4 + ndisRssProfileConservative* = 5 + ndisRssProfileMaximum* = 6 + ndisHypervisorPartitionTypeUnknown* = 0 + ndisHypervisorPartitionTypeMsHvParent* = 1 + ndisHypervisorPartitionMsHvChild* = 2 + ndisHypervisorPartitionTypeMax* = 3 + OID_NDK_SET_STATE* = 0xfc040201'i32 + OID_NDK_STATISTICS* = 0xfc040202'i32 + OID_NDK_CONNECTIONS* = 0xfc040203'i32 + OID_NDK_LOCAL_ENDPOINTS* = 0xfc040204'i32 + OID_QOS_HARDWARE_CAPABILITIES* = 0xfc050001'i32 + OID_QOS_CURRENT_CAPABILITIES* = 0xfc050002'i32 + OID_QOS_PARAMETERS* = 0xfc050003'i32 + OID_QOS_OPERATIONAL_PARAMETERS* = 0xfc050004'i32 + OID_QOS_REMOTE_PARAMETERS* = 0xfc050005'i32 + NDIS_QOS_CAPABILITIES_STRICT_TSA_SUPPORTED* = 0x00000001 + NDIS_QOS_CAPABILITIES_MACSEC_BYPASS_SUPPORTED* = 0x00000002 + NDIS_QOS_CAPABILITIES_CEE_DCBX_SUPPORTED* = 0x00000004 + NDIS_QOS_CAPABILITIES_IEEE_DCBX_SUPPORTED* = 0x00000008 + NDIS_QOS_CLASSIFICATION_SET_BY_MINIPORT_MASK* = 0xff000000'i32 + NDIS_QOS_CLASSIFICATION_ENFORCED_BY_MINIPORT* = 0x01000000 + NDIS_QOS_CONDITION_RESERVED* = 0x0 + NDIS_QOS_CONDITION_DEFAULT* = 0x1 + NDIS_QOS_CONDITION_TCP_PORT* = 0x2 + NDIS_QOS_CONDITION_UDP_PORT* = 0x3 + NDIS_QOS_CONDITION_TCP_OR_UDP_PORT* = 0x4 + NDIS_QOS_CONDITION_ETHERTYPE* = 0x5 + NDIS_QOS_CONDITION_NETDIRECT_PORT* = 0x6 + NDIS_QOS_CONDITION_MAXIMUM* = 0x7 + NDIS_QOS_ACTION_PRIORITY* = 0x0 + NDIS_QOS_ACTION_MAXIMUM* = 0x1 + NDIS_QOS_PARAMETERS_ETS_CHANGED* = 0x00000001 + NDIS_QOS_PARAMETERS_ETS_CONFIGURED* = 0x00000002 + NDIS_QOS_PARAMETERS_PFC_CHANGED* = 0x00000100 + NDIS_QOS_PARAMETERS_PFC_CONFIGURED* = 0x00000200 + NDIS_QOS_PARAMETERS_CLASSIFICATION_CHANGED* = 0x00010000 + NDIS_QOS_PARAMETERS_CLASSIFICATION_CONFIGURED* = 0x00020000 + NDIS_QOS_PARAMETERS_WILLING* = 0x80000000'i32 + NDIS_QOS_TSA_STRICT* = 0x0 + NDIS_QOS_TSA_CBS* = 0x1 + NDIS_QOS_TSA_ETS* = 0x2 + NDIS_QOS_TSA_MAXIMUM* = 0x3 + NDIS_INVALID_RID* = ULONG(-1) + NDIS_DEFAULT_VPORT_ID* = 0 + NDIS_DEFAULT_SWITCH_ID* = 0 + NDIS_INVALID_SWITCH_ID* = ULONG(-1) + NDIS_NIC_SWITCH_PARAMETERS_CHANGE_MASK* = 0xffff0000'i32 + NDIS_NIC_SWITCH_PARAMETERS_SWITCH_NAME_CHANGED* = 0x00010000 + NDIS_SRIOV_CAPS_SRIOV_SUPPORTED* = 0x00000001 + NDIS_SRIOV_CAPS_PF_MINIPORT* = 0x00000002 + NDIS_SRIOV_CAPS_VF_MINIPORT* = 0x00000004 + NDIS_NIC_SWITCH_VF_INFO_ARRAY_ENUM_ON_SPECIFIC_SWITCH* = 0x00000001 + NDIS_NIC_SWITCH_VPORT_PARAMS_LOOKAHEAD_SPLIT_ENABLED* = 0x00000001 + NDIS_NIC_SWITCH_VPORT_PARAMS_CHANGE_MASK* = 0xffff0000'i32 + NDIS_NIC_SWITCH_VPORT_PARAMS_FLAGS_CHANGED* = 0x00010000 + NDIS_NIC_SWITCH_VPORT_PARAMS_NAME_CHANGED* = 0x00020000 + NDIS_NIC_SWITCH_VPORT_PARAMS_INT_MOD_CHANGED* = 0x00040000 + NDIS_NIC_SWITCH_VPORT_PARAMS_STATE_CHANGED* = 0x00080000 + NDIS_NIC_SWITCH_VPORT_PARAMS_PROCESSOR_AFFINITY_CHANGED* = 0x00100000 + NDIS_NIC_SWITCH_VPORT_INFO_ARRAY_ENUM_ON_SPECIFIC_FUNCTION* = 0x00000001 + NDIS_NIC_SWITCH_VPORT_INFO_ARRAY_ENUM_ON_SPECIFIC_SWITCH* = 0x00000002 + NDIS_NIC_SWITCH_VPORT_INFO_LOOKAHEAD_SPLIT_ENABLED* = 0x00000001 + GUID_NDIS_NDK_CAPABILITIES* = DEFINE_GUID("7969ba4d-dd80-4bc7-b3e6-68043997e519") + GUID_NDIS_NDK_STATE* = DEFINE_GUID("530c69c9-2f51-49de-a1af-088d54ffa474") + NDIS_NDK_CAPABILITIES_REVISION_1* = 1 + NDIS_NDK_STATISTICS_INFO_REVISION_1* = 1 + NDIS_NDK_CONNECTIONS_REVISION_1* = 1 + NDIS_NDK_LOCAL_ENDPOINTS_REVISION_1* = 1 + NDIS_QOS_CAPABILITIES_REVISION_1* = 1 + NDIS_QOS_CLASSIFICATION_ELEMENT_REVISION_1* = 1 + NDIS_QOS_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_DELETE_SWITCH_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_INFO_REVISION_1* = 1 + NDIS_NIC_SWITCH_INFO_ARRAY_REVISION_1* = 1 + NDIS_NIC_SWITCH_VPORT_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_DELETE_VPORT_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_VPORT_INFO_REVISION_1* = 1 + NDIS_NIC_SWITCH_VPORT_INFO_ARRAY_REVISION_1* = 1 + NDIS_NIC_SWITCH_VF_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_FREE_VF_PARAMETERS_REVISION_1* = 1 + NDIS_NIC_SWITCH_VF_INFO_REVISION_1* = 1 + NDIS_NIC_SWITCH_VF_INFO_ARRAY_REVISION_1* = 1 + NDIS_SRIOV_CAPABILITIES_REVISION_1* = 1 + NDIS_SRIOV_READ_VF_CONFIG_SPACE_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_WRITE_VF_CONFIG_SPACE_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_READ_VF_CONFIG_BLOCK_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_WRITE_VF_CONFIG_BLOCK_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_RESET_VF_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_SET_VF_POWER_STATE_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_CONFIG_STATE_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_VF_VENDOR_DEVICE_ID_INFO_REVISION_1* = 1 + NDIS_SRIOV_PROBED_BARS_INFO_REVISION_1* = 1 + NDIS_RECEIVE_FILTER_MOVE_FILTER_PARAMETERS_REVISION_1* = 1 + NDIS_SRIOV_BAR_RESOURCES_INFO_REVISION_1* = 1 + NDIS_SRIOV_PF_LUID_INFO_REVISION_1* = 1 + NDIS_SRIOV_VF_SERIAL_NUMBER_INFO_REVISION_1* = 1 + NDIS_SRIOV_VF_INVALIDATE_CONFIG_BLOCK_INFO_REVISION_1* = 1 + NDIS_SWITCH_OBJECT_SERIALIZATION_VERSION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_SECURITY_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_VLAN_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_PROFILE_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_CUSTOM_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_DELETE_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_ENUM_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PORT_PROPERTY_ENUM_INFO_REVISION_1* = 1 + NDIS_SWITCH_PROPERTY_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PROPERTY_CUSTOM_REVISION_1* = 1 + NDIS_SWITCH_PORT_FEATURE_STATUS_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PORT_FEATURE_STATUS_CUSTOM_REVISION_1* = 1 + NDIS_SWITCH_PROPERTY_DELETE_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PROPERTY_ENUM_INFO_REVISION_1* = 1 + NDIS_SWITCH_PROPERTY_ENUM_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_FEATURE_STATUS_CUSTOM_REVISION_1* = 1 + NDIS_SWITCH_PORT_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_PORT_ARRAY_REVISION_1* = 1 + NDIS_SWITCH_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_NIC_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_NIC_ARRAY_REVISION_1* = 1 + NDIS_SWITCH_NIC_OID_REQUEST_REVISION_1* = 1 + NDIS_SWITCH_FEATURE_STATUS_PARAMETERS_REVISION_1* = 1 + NDIS_SWITCH_NIC_SAVE_STATE_REVISION_1* = 1 +type + NDIS_NDK_STATISTICS_INFO* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + CounterSet*: NDIS_NDK_PERFORMANCE_COUNTERS +proc Length*(self: IP_ADAPTER_UNICAST_ADDRESS_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_UNICAST_ADDRESS_LH): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_ANYCAST_ADDRESS_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_MULTICAST_ADDRESS_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_DNS_SERVER_ADDRESS_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_PREFIX_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_PREFIX_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_WINS_SERVER_ADDRESS_LH): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_GATEWAY_ADDRESS_LH): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_ADDRESSES_LH): var ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: IP_ADAPTER_ADDRESSES_XP): ULONG {.inline.} = self.union1.struct1.Length +proc Length*(self: var IP_ADAPTER_ADDRESSES_XP): var ULONG {.inline.} = self.union1.struct1.Length +proc VlanProperties*(self: NDIS_SWITCH_PORT_PROPERTY_VLAN): NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_VlanProperties {.inline.} = self.union1.VlanProperties +proc VlanProperties*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN): var NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_VlanProperties {.inline.} = self.union1.VlanProperties +proc Reserved*(self: IP_ADAPTER_DNS_SERVER_ADDRESS_XP): DWORD {.inline.} = self.union1.struct1.Reserved +proc Reserved*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP): var DWORD {.inline.} = self.union1.struct1.Reserved +proc Reserved*(self: IP_ADAPTER_WINS_SERVER_ADDRESS_LH): DWORD {.inline.} = self.union1.struct1.Reserved +proc Reserved*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH): var DWORD {.inline.} = self.union1.struct1.Reserved +proc Reserved*(self: IP_ADAPTER_GATEWAY_ADDRESS_LH): DWORD {.inline.} = self.union1.struct1.Reserved +proc Reserved*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH): var DWORD {.inline.} = self.union1.struct1.Reserved +const + NDK_ADAPTER_FLAG_IN_ORDER_DMA_SUPPORTED* = 0x1 + NDK_ADAPTER_FLAG_RDMA_READ_SINK_NOT_REQUIRED* = 0x2 + NDK_ADAPTER_FLAG_CQ_INTERRUPT_MODERATION_SUPPORTED* = 0x4 + NDK_ADAPTER_FLAG_MULTI_ENGINE_SUPPORTED* = 0x8 + NDK_ADAPTER_FLAG_CQ_RESIZE_SUPPORTED* = 0x100 + NDK_ADAPTER_FLAG_LOOPBACK_CONNECTIONS_SUPPORTED* = 0x10000 + ndisNicSwitchTypeUnspecified* = 0 + ndisNicSwitchTypeExternal* = 1 + ndisNicSwitchTypeMax* = 2 + ndisNicSwitchVPortStateUndefined* = 0 + ndisNicSwitchVPortStateActivated* = 1 + ndisNicSwitchVPortStateDeactivated* = 2 + ndisNicSwitchVPortStateMaximum* = 3 + ndisNicSwitchVPortInterruptModerationUndefined* = 0 + ndisNicSwitchVPortInterruptModerationAdaptive* = 1 + ndisNicSwitchVPortInterruptModerationOff* = 2 + ndisNicSwitchVPortInterruptModerationLow* = 100 + ndisNicSwitchVPortInterruptModerationMedium* = 200 + ndisNicSwitchVPortInterruptModerationHigh* = 300 + ndisSwitchPortPropertyTypeUndefined* = 0 + ndisSwitchPortPropertyTypeCustom* = 1 + ndisSwitchPortPropertyTypeSecurity* = 2 + ndisSwitchPortPropertyTypeVlan* = 3 + ndisSwitchPortPropertyTypeProfile* = 4 + ndisSwitchPortPropertyTypeMaximum* = 5 + ndisSwitchPortVlanModeUnknown* = 0 + ndisSwitchPortVlanModeAccess* = 1 + ndisSwitchPortVlanModeTrunk* = 2 + ndisSwitchPortVlanModePrivate* = 3 + ndisSwitchPortVlanModeMax* = 4 + ndisSwitchPortPvlanModeUndefined* = 0 + ndisSwitchPortPvlanModeIsolated* = 1 + ndisSwitchPortPvlanModeCommunity* = 2 + ndisSwitchPortPvlanModePromiscuous* = 3 + ndisSwitchPortFeatureStatusTypeUndefined* = 0 + ndisSwitchPortFeatureStatusTypeCustom* = 1 + ndisSwitchPortFeatureStatusTypeMaximum* = 2 + ndisSwitchPropertyTypeUndefined* = 0 + ndisSwitchPropertyTypeCustom* = 1 + ndisSwitchPropertyTypeMaximum* = 2 + ndisSwitchFeatureStatusTypeUndefined* = 0 + ndisSwitchFeatureStatusTypeCustom* = 1 + ndisSwitchFeatureStatusTypeMaximum* = 2 + ndisSwitchPortTypeGeneric* = 0 + ndisSwitchPortTypeExternal* = 1 + ndisSwitchPortTypeSynthetic* = 2 + ndisSwitchPortTypeEmulated* = 3 + ndisSwitchPortTypeInternal* = 4 + ndisSwitchPortStateUnknown* = 0 + ndisSwitchPortStateCreated* = 1 + ndisSwitchPortStateTeardown* = 2 + ndisSwitchPortStateDeleted* = 3 + ndisSwitchNicTypeExternal* = 0 + ndisSwitchNicTypeSynthetic* = 1 + ndisSwitchNicTypeEmulated* = 2 + ndisSwitchNicTypeInternal* = 3 + ndisSwitchNicStateUnknown* = 0 + ndisSwitchNicStateCreated* = 1 + ndisSwitchNicStateConnected* = 2 + ndisSwitchNicStateDisconnected* = 3 + ndisSwitchNicStateDeleted* = 4 + MIB_INVALID_TEREDO_PORT_NUMBER* = 0 + mibIfTableNormal* = 0 + mibIfTableRaw* = 1 + IOCTL_NDIS_QUERY_GLOBAL_STATS* = 0x00170002 + IOCTL_NDIS_QUERY_ALL_STATS* = 0x00170006 + IOCTL_NDIS_DO_PNP_OPERATION* = 0x00170008 + IOCTL_NDIS_QUERY_SELECTED_STATS* = 0x0017000E + IOCTL_NDIS_ENUMERATE_INTERFACES* = 0x00170010 + IOCTL_NDIS_ADD_TDI_DEVICE* = 0x00170014 + IOCTL_NDIS_GET_LOG_DATA* = 0x0017001E + IOCTL_NDIS_GET_VERSION* = 0x00170020 + NETWORK_ADDRESS_LENGTH_IP* = 16 + NETWORK_ADDRESS_LENGTH_IPX* = 12 + NL_MAX_METRIC_COMPONENT* = ULONG(1.uint32 shl 31 - 1) + NDIS_PF_FUNCTION_ID* = not USHORT(0) + NDIS_INVALID_VF_FUNCTION_ID* = not USHORT(0) +type + PIPINTERFACE_CHANGE_CALLBACK* = proc (CallerContext: PVOID, Row: PMIB_IPINTERFACE_ROW, NotificationType: MIB_NOTIFICATION_TYPE): VOID {.stdcall.} + PUNICAST_IPADDRESS_CHANGE_CALLBACK* = proc (CallerContext: PVOID, Row: PMIB_UNICASTIPADDRESS_ROW, NotificationType: MIB_NOTIFICATION_TYPE): VOID {.stdcall.} + PSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACK* = proc (CallerContext: PVOID, AddressTable: PMIB_UNICASTIPADDRESS_TABLE): VOID {.stdcall.} + PTEREDO_PORT_CHANGE_CALLBACK* = proc (CallerContext: PVOID, Port: USHORT, NotificationType: MIB_NOTIFICATION_TYPE): VOID {.stdcall.} + PIPFORWARD_CHANGE_CALLBACK* = proc (CallerContext: PVOID, Row: PMIB_IPFORWARD_ROW2, NotificationType: MIB_NOTIFICATION_TYPE): VOID {.stdcall.} + NDIS_NDK_CONNECTION_ENTRY* {.pure.} = object + Local*: SOCKADDR_INET + Remote*: SOCKADDR_INET + UserModeOwner*: BOOLEAN + OwnerPid*: ULONG + NDIS_NDK_CONNECTIONS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + Count*: ULONG + NDConnectionsMappedtoTCPConnections*: BOOLEAN + Connections*: array[1, NDIS_NDK_CONNECTION_ENTRY] + NDIS_NDK_LOCAL_ENDPOINT_ENTRY* {.pure.} = object + Local*: SOCKADDR_INET + UserModeOwner*: BOOLEAN + Listener*: BOOLEAN + OwnerPid*: ULONG + NDIS_NDK_LOCAL_ENDPOINTS* {.pure.} = object + Header*: NDIS_OBJECT_HEADER + Flags*: ULONG + Count*: ULONG + NDLocalEndpointsMappedtoTCPLocalEndpoints*: BOOLEAN + LocalEndpoints*: array[1, NDIS_NDK_LOCAL_ENDPOINT_ENTRY] +proc GetNumberOfInterfaces*(pdwNumIf: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfEntry*(pIfRow: PMIB_IFROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfTable*(pIfTable: PMIB_IFTABLE, pdwSize: PULONG, bOrder: WINBOOL): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpAddrTable*(pIpAddrTable: PMIB_IPADDRTABLE, pdwSize: PULONG, bOrder: WINBOOL): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpNetTable*(IpNetTable: PMIB_IPNETTABLE, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpForwardTable*(pIpForwardTable: PMIB_IPFORWARDTABLE, pdwSize: PULONG, bOrder: WINBOOL): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcpTable*(TcpTable: PMIB_TCPTABLE, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetExtendedTcpTable*(pTcpTable: PVOID, pdwSize: PDWORD, bOrder: WINBOOL, ulAf: ULONG, TableClass: TCP_TABLE_CLASS, Reserved: ULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetOwnerModuleFromTcpEntry*(pTcpEntry: PMIB_TCPROW_OWNER_MODULE, Class: TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer: PVOID, pdwSize: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUdpTable*(UdpTable: PMIB_UDPTABLE, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetExtendedUdpTable*(pUdpTable: PVOID, pdwSize: PDWORD, bOrder: WINBOOL, ulAf: ULONG, TableClass: UDP_TABLE_CLASS, Reserved: ULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetOwnerModuleFromUdpEntry*(pUdpEntry: PMIB_UDPROW_OWNER_MODULE, Class: TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer: PVOID, pdwSize: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcpTable2*(TcpTable: PMIB_TCPTABLE2, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcp6Table*(TcpTable: PMIB_TCP6TABLE, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcp6Table2*(TcpTable: PMIB_TCP6TABLE2, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetPerTcpConnectionEStats*(Row: PMIB_TCPROW, EstatsType: TCP_ESTATS_TYPE, Rw: PUCHAR, RwVersion: ULONG, RwSize: ULONG, Ros: PUCHAR, RosVersion: ULONG, RosSize: ULONG, Rod: PUCHAR, RodVersion: ULONG, RodSize: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetPerTcpConnectionEStats*(Row: PMIB_TCPROW, EstatsType: TCP_ESTATS_TYPE, Rw: PUCHAR, RwVersion: ULONG, RwSize: ULONG, Offset: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetPerTcp6ConnectionEStats*(Row: PMIB_TCP6ROW, EstatsType: TCP_ESTATS_TYPE, Rw: PUCHAR, RwVersion: ULONG, RwSize: ULONG, Ros: PUCHAR, RosVersion: ULONG, RosSize: ULONG, Rod: PUCHAR, RodVersion: ULONG, RodSize: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetPerTcp6ConnectionEStats*(Row: PMIB_TCP6ROW, EstatsType: TCP_ESTATS_TYPE, Rw: PUCHAR, RwVersion: ULONG, RwSize: ULONG, Offset: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUdp6Table*(Udp6Table: PMIB_UDP6TABLE, SizePointer: PULONG, Order: WINBOOL): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetOwnerModuleFromTcp6Entry*(pTcpEntry: PMIB_TCP6ROW_OWNER_MODULE, Class: TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer: PVOID, pdwSize: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetOwnerModuleFromUdp6Entry*(pUdpEntry: PMIB_UDP6ROW_OWNER_MODULE, Class: TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer: PVOID, pdwSize: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetOwnerModuleFromPidAndInfo*(ulPid: ULONG, pInfo: ptr ULONGLONG, Class: TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer: PVOID, pdwSize: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpStatistics*(Statistics: PMIB_IPSTATS): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIcmpStatistics*(Statistics: PMIB_ICMP): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcpStatistics*(Statistics: PMIB_TCPSTATS): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUdpStatistics*(Stats: PMIB_UDPSTATS): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpStatisticsEx*(Statistics: PMIB_IPSTATS, Family: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpStatisticsEx*(Statistics: PMIB_IPSTATS, Family: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIcmpStatisticsEx*(Statistics: PMIB_ICMP_EX, Family: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTcpStatisticsEx*(Statistics: PMIB_TCPSTATS, Family: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUdpStatisticsEx*(Statistics: PMIB_UDPSTATS, Family: ULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIfEntry*(pIfRow: PMIB_IFROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateIpForwardEntry*(pRoute: PMIB_IPFORWARDROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpForwardEntry*(pRoute: PMIB_IPFORWARDROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteIpForwardEntry*(pRoute: PMIB_IPFORWARDROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpStatistics*(pIpStats: PMIB_IPSTATS): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpTTL*(nTTL: UINT): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateIpNetEntry*(pArpEntry: PMIB_IPNETROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpNetEntry*(pArpEntry: PMIB_IPNETROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteIpNetEntry*(pArpEntry: PMIB_IPNETROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc FlushIpNetTable*(dwIfIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateProxyArpEntry*(dwAddress: DWORD, dwMask: DWORD, dwIfIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteProxyArpEntry*(dwAddress: DWORD, dwMask: DWORD, dwIfIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetTcpEntry*(pTcpRow: PMIB_TCPROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetInterfaceInfo*(pIfTable: PIP_INTERFACE_INFO, dwOutBufLen: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUniDirectionalAdapterInfo*(pIPIfInfo: PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, dwOutBufLen: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NhpAllocateAndGetInterfaceInfoFromStack*(ppTable: ptr ptr IP_INTERFACE_NAME_INFO, pdwCount: PDWORD, bOrder: WINBOOL, hHeap: HANDLE, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetBestInterface*(dwDestAddr: IPAddr, pdwBestIfIndex: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetBestInterfaceEx*(pDestAddr: ptr sockaddr, pdwBestIfIndex: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetBestRoute*(dwDestAddr: DWORD, dwSourceAddr: DWORD, pBestRoute: PMIB_IPFORWARDROW): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyAddrChange*(Handle: PHANDLE, overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyRouteChange*(Handle: PHANDLE, overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CancelIPChangeNotify*(notifyOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAdapterIndex*(AdapterName: LPWSTR, IfIndex: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc AddIPAddress*(Address: IPAddr, IpMask: IPMask, IfIndex: DWORD, NTEContext: PULONG, NTEInstance: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteIPAddress*(NTEContext: ULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetNetworkParams*(pFixedInfo: PFIXED_INFO, pOutBufLen: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAdaptersInfo*(AdapterInfo: PIP_ADAPTER_INFO, SizePointer: PULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAdapterOrderMap*(): PIP_ADAPTER_ORDER_MAP {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAdaptersAddresses*(Family: ULONG, Flags: ULONG, Reserved: PVOID, AdapterAddresses: PIP_ADAPTER_ADDRESSES, SizePointer: PULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetPerAdapterInfo*(IfIndex: ULONG, pPerAdapterInfo: PIP_PER_ADAPTER_INFO, pOutBufLen: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc IpReleaseAddress*(AdapterInfo: PIP_ADAPTER_INDEX_MAP): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc IpRenewAddress*(AdapterInfo: PIP_ADAPTER_INDEX_MAP): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SendARP*(DestIP: IPAddr, SrcIP: IPAddr, pMacAddr: PVOID, PhyAddrLen: PULONG): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetRTTAndHopCount*(DestIpAddress: IPAddr, HopCount: PULONG, MaxHops: ULONG, RTT: PULONG): WINBOOL {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetFriendlyIfIndex*(IfIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc EnableRouter*(pHandle: ptr HANDLE, pOverlapped: ptr OVERLAPPED): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc UnenableRouter*(pOverlapped: ptr OVERLAPPED, lpdwEnableCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DisableMediaSense*(pHandle: ptr HANDLE, pOverLapped: ptr OVERLAPPED): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc RestoreMediaSense*(pOverlapped: ptr OVERLAPPED, lpdwEnableCount: LPDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ParseNetworkString*(NetworkString: ptr WCHAR, Types: DWORD, AddressInfo: PNET_ADDRESS_INFO, PortNumber: ptr USHORT, PrefixLength: ptr BYTE): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpErrorString*(ErrorCode: IP_STATUS, Buffer: PWSTR, Size: PDWORD): DWORD {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ResolveNeighbor*(NetworkAddress: ptr SOCKADDR, PhysicalAddress: PVOID, PhysicalAddressLength: PULONG): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreatePersistentTcpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT, Token: PULONG64): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreatePersistentUdpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT, Token: PULONG64): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeletePersistentTcpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeletePersistentUdpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc LookupPersistentTcpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT, Token: PULONG64): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc LookupPersistentUdpPortReservation*(StartPort: USHORT, NumberOfPorts: USHORT, Token: PULONG64): ULONG {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfEntry2*(Row: PMIB_IF_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfTable2*(Table: ptr PMIB_IF_TABLE2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfTable2Ex*(Level: MIB_IF_TABLE_LEVEL, Table: ptr PMIB_IF_TABLE2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIfStackTable*(Table: ptr PMIB_IFSTACK_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetInvertedIfStackTable*(Table: ptr PMIB_INVERTEDIFSTACK_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpInterfaceEntry*(Row: PMIB_IPINTERFACE_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpInterfaceTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_IPINTERFACE_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc InitializeIpInterfaceEntry*(Row: PMIB_IPINTERFACE_ROW): VOID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyIpInterfaceChange*(Family: ADDRESS_FAMILY, Callback: PIPINTERFACE_CHANGE_CALLBACK, CallerContext: PVOID, InitialNotification: BOOLEAN, NotificationHandle: ptr HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpInterfaceEntry*(Row: PMIB_IPINTERFACE_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpNetworkConnectionBandwidthEstimates*(InterfaceIndex: NET_IFINDEX, AddressFamily: ADDRESS_FAMILY, BandwidthEstimates: PMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateUnicastIpAddressEntry*(Row: ptr MIB_UNICASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteUnicastIpAddressEntry*(Row: ptr MIB_UNICASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUnicastIpAddressEntry*(Row: PMIB_UNICASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetUnicastIpAddressTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_UNICASTIPADDRESS_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc InitializeUnicastIpAddressEntry*(Row: PMIB_UNICASTIPADDRESS_ROW): VOID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyUnicastIpAddressChange*(Family: ADDRESS_FAMILY, Callback: PUNICAST_IPADDRESS_CHANGE_CALLBACK, CallerContext: PVOID, InitialNotification: BOOLEAN, NotificationHandle: ptr HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateAnycastIpAddressEntry*(Row: ptr MIB_ANYCASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteAnycastIpAddressEntry*(Row: ptr MIB_ANYCASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAnycastIpAddressEntry*(Row: PMIB_ANYCASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetAnycastIpAddressTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_ANYCASTIPADDRESS_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyStableUnicastIpAddressTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_UNICASTIPADDRESS_TABLE, CallerCallback: PSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACK, CallerContext: PVOID, NotificationHandle: ptr HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetUnicastIpAddressEntry*(Row: ptr MIB_UNICASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetMulticastIpAddressEntry*(Row: PMIB_MULTICASTIPADDRESS_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetMulticastIpAddressTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_MULTICASTIPADDRESS_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateIpForwardEntry2*(Row: ptr MIB_IPFORWARD_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteIpForwardEntry2*(Row: ptr MIB_IPFORWARD_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetBestRoute2*(InterfaceLuid: ptr NET_LUID, InterfaceIndex: NET_IFINDEX, SourceAddress: ptr SOCKADDR_INET, DestinationAddress: ptr SOCKADDR_INET, AddressSortOptions: ULONG, BestRoute: PMIB_IPFORWARD_ROW2, BestSourceAddress: ptr SOCKADDR_INET): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpForwardEntry2*(Row: PMIB_IPFORWARD_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpForwardTable2*(Family: ADDRESS_FAMILY, Table: ptr PMIB_IPFORWARD_TABLE2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc InitializeIpForwardEntry*(Row: PMIB_IPFORWARD_ROW2): VOID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyRouteChange2*(AddressFamily: ADDRESS_FAMILY, Callback: PIPFORWARD_CHANGE_CALLBACK, CallerContext: PVOID, InitialNotification: BOOLEAN, NotificationHandle: ptr HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpForwardEntry2*(Route: ptr MIB_IPFORWARD_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc FlushIpPathTable*(Family: ADDRESS_FAMILY): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpPathEntry*(Row: PMIB_IPPATH_ROW): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpPathTable*(Family: ADDRESS_FAMILY, Table: ptr PMIB_IPPATH_TABLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateIpNetEntry2*(Row: ptr MIB_IPNET_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc DeleteIpNetEntry2*(Row: ptr MIB_IPNET_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc FlushIpNetTable2*(Family: ADDRESS_FAMILY, InterfaceIndex: NET_IFINDEX): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpNetEntry2*(Row: PMIB_IPNET_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetIpNetTable2*(Family: ADDRESS_FAMILY, Table: ptr PMIB_IPNET_TABLE2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ResolveIpNetEntry2*(Row: PMIB_IPNET_ROW2, SourceAddress: ptr SOCKADDR_INET): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetIpNetEntry2*(Row: PMIB_IPNET_ROW2): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc NotifyTeredoPortChange*(Callback: PTEREDO_PORT_CHANGE_CALLBACK, CallerContext: PVOID, InitialNotification: BOOLEAN, NotificationHandle: ptr HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetTeredoPort*(Port: ptr USHORT): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CancelMibChangeNotify2*(NotificationHandle: HANDLE): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc FreeMibTable*(Memory: PVOID): VOID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc CreateSortedAddressPairs*(SourceAddressList: PSOCKADDR_IN6, SourceAddressCount: ULONG, DestinationAddressList: PSOCKADDR_IN6, DestinationAddressCount: ULONG, AddressSortOptions: ULONG, SortedAddressPairList: ptr PSOCKADDR_IN6_PAIR, SortedAddressPairCount: ptr ULONG): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceNameToLuidA*(InterfaceName: ptr CHAR, InterfaceLuid: ptr NET_LUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceNameToLuidW*(InterfaceName: ptr WCHAR, InterfaceLuid: ptr NET_LUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceLuidToNameA*(InterfaceLuid: ptr NET_LUID, InterfaceName: PSTR, Length: SIZE_T): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceLuidToNameW*(InterfaceLuid: ptr NET_LUID, InterfaceName: PWSTR, Length: SIZE_T): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceLuidToIndex*(InterfaceLuid: ptr NET_LUID, InterfaceIndex: PNET_IFINDEX): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceIndexToLuid*(InterfaceIndex: NET_IFINDEX, InterfaceLuid: PNET_LUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceLuidToAlias*(InterfaceLuid: ptr NET_LUID, InterfaceAlias: PWSTR, Length: SIZE_T): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceAliasToLuid*(InterfaceAlias: ptr WCHAR, InterfaceLuid: PNET_LUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceLuidToGuid*(InterfaceLuid: ptr NET_LUID, InterfaceGuid: ptr GUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertInterfaceGuidToLuid*(InterfaceGuid: ptr GUID, InterfaceLuid: PNET_LUID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc if_nametoindex*(InterfaceName: PCSTR): NET_IFINDEX {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc if_indextoname*(InterfaceIndex: NET_IFINDEX, InterfaceName: PCHAR): PCHAR {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetCurrentThreadCompartmentId*(): NET_IF_COMPARTMENT_ID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetCurrentThreadCompartmentId*(CompartmentId: NET_IF_COMPARTMENT_ID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetSessionCompartmentId*(SessionId: ULONG): NET_IF_COMPARTMENT_ID {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetSessionCompartmentId*(SessionId: ULONG, CompartmentId: NET_IF_COMPARTMENT_ID): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc GetNetworkInformation*(NetworkGuid: ptr NET_IF_NETWORK_GUID, CompartmentId: PNET_IF_COMPARTMENT_ID, SiteId: PULONG, NetworkName: PWCHAR, Length: ULONG): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc SetNetworkInformation*(NetworkGuid: ptr NET_IF_NETWORK_GUID, CompartmentId: NET_IF_COMPARTMENT_ID, NetworkName: ptr WCHAR): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertLengthToIpv4Mask*(MaskLength: ULONG, Mask: PULONG): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc ConvertIpv4MaskToLength*(Mask: ULONG, MaskLength: PUINT8): NETIO_STATUS {.winapi, stdcall, dynlib: "iphlpapi", importc.} +proc `SpecificPortBind=`*(self: var MIB_UDPROW_OWNER_MODULE, x: DWORD) {.inline.} = self.union1.struct1.SpecificPortBind = x +proc SpecificPortBind*(self: MIB_UDPROW_OWNER_MODULE): DWORD {.inline.} = self.union1.struct1.SpecificPortBind +proc `dwFlags=`*(self: var MIB_UDPROW_OWNER_MODULE, x: DWORD) {.inline.} = self.union1.dwFlags = x +proc dwFlags*(self: MIB_UDPROW_OWNER_MODULE): DWORD {.inline.} = self.union1.dwFlags +proc dwFlags*(self: var MIB_UDPROW_OWNER_MODULE): var DWORD {.inline.} = self.union1.dwFlags +proc `SpecificPortBind=`*(self: var MIB_UDP6ROW_OWNER_MODULE, x: DWORD) {.inline.} = self.union1.struct1.SpecificPortBind = x +proc SpecificPortBind*(self: MIB_UDP6ROW_OWNER_MODULE): DWORD {.inline.} = self.union1.struct1.SpecificPortBind +proc `dwFlags=`*(self: var MIB_UDP6ROW_OWNER_MODULE, x: DWORD) {.inline.} = self.union1.dwFlags = x +proc dwFlags*(self: MIB_UDP6ROW_OWNER_MODULE): DWORD {.inline.} = self.union1.dwFlags +proc dwFlags*(self: var MIB_UDP6ROW_OWNER_MODULE): var DWORD {.inline.} = self.union1.dwFlags +proc `ullAlign=`*(self: var MIB_OPAQUE_INFO, x: ULONGLONG) {.inline.} = self.union1.ullAlign = x +proc ullAlign*(self: MIB_OPAQUE_INFO): ULONGLONG {.inline.} = self.union1.ullAlign +proc ullAlign*(self: var MIB_OPAQUE_INFO): var ULONGLONG {.inline.} = self.union1.ullAlign +proc `rgbyData=`*(self: var MIB_OPAQUE_INFO, x: array[1, BYTE]) {.inline.} = self.union1.rgbyData = x +proc rgbyData*(self: MIB_OPAQUE_INFO): array[1, BYTE] {.inline.} = self.union1.rgbyData +proc rgbyData*(self: var MIB_OPAQUE_INFO): var array[1, BYTE] {.inline.} = self.union1.rgbyData +proc `Alignment=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_UNICAST_ADDRESS_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Flags=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_XP, x: DWORD) {.inline.} = self.union1.struct1.Flags = x +proc `Alignment=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_UNICAST_ADDRESS_LH): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Flags=`*(self: var IP_ADAPTER_UNICAST_ADDRESS_LH, x: DWORD) {.inline.} = self.union1.struct1.Flags = x +proc `Alignment=`*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_ANYCAST_ADDRESS_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Flags=`*(self: var IP_ADAPTER_ANYCAST_ADDRESS_XP, x: DWORD) {.inline.} = self.union1.struct1.Flags = x +proc `Alignment=`*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_MULTICAST_ADDRESS_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Flags=`*(self: var IP_ADAPTER_MULTICAST_ADDRESS_XP, x: DWORD) {.inline.} = self.union1.struct1.Flags = x +proc `Alignment=`*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_DNS_SERVER_ADDRESS_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Reserved=`*(self: var IP_ADAPTER_DNS_SERVER_ADDRESS_XP, x: DWORD) {.inline.} = self.union1.struct1.Reserved = x +proc `Alignment=`*(self: var IP_ADAPTER_PREFIX_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_PREFIX_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_PREFIX_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_PREFIX_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Flags=`*(self: var IP_ADAPTER_PREFIX_XP, x: DWORD) {.inline.} = self.union1.struct1.Flags = x +proc `Alignment=`*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_WINS_SERVER_ADDRESS_LH): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Reserved=`*(self: var IP_ADAPTER_WINS_SERVER_ADDRESS_LH, x: DWORD) {.inline.} = self.union1.struct1.Reserved = x +proc `Alignment=`*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_GATEWAY_ADDRESS_LH): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `Reserved=`*(self: var IP_ADAPTER_GATEWAY_ADDRESS_LH, x: DWORD) {.inline.} = self.union1.struct1.Reserved = x +proc `Alignment=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_ADDRESSES_LH): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_ADDRESSES_LH): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `IfIndex=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: IF_INDEX) {.inline.} = self.union1.struct1.IfIndex = x +proc ifIndex*(self: IP_ADAPTER_ADDRESSES_LH): IF_INDEX {.inline.} = self.union1.struct1.IfIndex +proc ifIndex*(self: var IP_ADAPTER_ADDRESSES_LH): var IF_INDEX {.inline.} = self.union1.struct1.IfIndex +proc `Flags=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.Flags = x +proc `DdnsEnabled=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.DdnsEnabled = x +proc DdnsEnabled*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.DdnsEnabled +proc `RegisterAdapterSuffix=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.RegisterAdapterSuffix = x +proc RegisterAdapterSuffix*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.RegisterAdapterSuffix +proc `Dhcpv4Enabled=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.Dhcpv4Enabled = x +proc Dhcpv4Enabled*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.Dhcpv4Enabled +proc `ReceiveOnly=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.ReceiveOnly = x +proc ReceiveOnly*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.ReceiveOnly +proc `NoMulticast=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.NoMulticast = x +proc NoMulticast*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.NoMulticast +proc `Ipv6OtherStatefulConfig=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.Ipv6OtherStatefulConfig = x +proc Ipv6OtherStatefulConfig*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.Ipv6OtherStatefulConfig +proc `NetbiosOverTcpipEnabled=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.NetbiosOverTcpipEnabled = x +proc NetbiosOverTcpipEnabled*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.NetbiosOverTcpipEnabled +proc `Ipv4Enabled=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.Ipv4Enabled = x +proc Ipv4Enabled*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.Ipv4Enabled +proc `Ipv6Enabled=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.Ipv6Enabled = x +proc Ipv6Enabled*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.Ipv6Enabled +proc `Ipv6ManagedAddressConfigurationSupported=`*(self: var IP_ADAPTER_ADDRESSES_LH, x: ULONG) {.inline.} = self.union2.struct1.Ipv6ManagedAddressConfigurationSupported = x +proc Ipv6ManagedAddressConfigurationSupported*(self: IP_ADAPTER_ADDRESSES_LH): ULONG {.inline.} = self.union2.struct1.Ipv6ManagedAddressConfigurationSupported +proc `Alignment=`*(self: var IP_ADAPTER_ADDRESSES_XP, x: ULONGLONG) {.inline.} = self.union1.Alignment = x +proc Alignment*(self: IP_ADAPTER_ADDRESSES_XP): ULONGLONG {.inline.} = self.union1.Alignment +proc Alignment*(self: var IP_ADAPTER_ADDRESSES_XP): var ULONGLONG {.inline.} = self.union1.Alignment +proc `Length=`*(self: var IP_ADAPTER_ADDRESSES_XP, x: ULONG) {.inline.} = self.union1.struct1.Length = x +proc `IfIndex=`*(self: var IP_ADAPTER_ADDRESSES_XP, x: DWORD) {.inline.} = self.union1.struct1.IfIndex = x +proc ifIndex*(self: IP_ADAPTER_ADDRESSES_XP): DWORD {.inline.} = self.union1.struct1.IfIndex +proc ifIndex*(self: var IP_ADAPTER_ADDRESSES_XP): var DWORD {.inline.} = self.union1.struct1.IfIndex +proc `NamedAddress=`*(self: var NET_ADDRESS_INFO, x: NET_ADDRESS_INFO_UNION1_NamedAddress) {.inline.} = self.union1.NamedAddress = x +proc NamedAddress*(self: NET_ADDRESS_INFO): NET_ADDRESS_INFO_UNION1_NamedAddress {.inline.} = self.union1.NamedAddress +proc NamedAddress*(self: var NET_ADDRESS_INFO): var NET_ADDRESS_INFO_UNION1_NamedAddress {.inline.} = self.union1.NamedAddress +proc `Ipv4Address=`*(self: var NET_ADDRESS_INFO, x: SOCKADDR_IN) {.inline.} = self.union1.Ipv4Address = x +proc ipv4Address*(self: NET_ADDRESS_INFO): SOCKADDR_IN {.inline.} = self.union1.Ipv4Address +proc ipv4Address*(self: var NET_ADDRESS_INFO): var SOCKADDR_IN {.inline.} = self.union1.Ipv4Address +proc `Ipv6Address=`*(self: var NET_ADDRESS_INFO, x: SOCKADDR_IN6) {.inline.} = self.union1.Ipv6Address = x +proc ipv6Address*(self: NET_ADDRESS_INFO): SOCKADDR_IN6 {.inline.} = self.union1.Ipv6Address +proc ipv6Address*(self: var NET_ADDRESS_INFO): var SOCKADDR_IN6 {.inline.} = self.union1.Ipv6Address +proc `IpAddress=`*(self: var NET_ADDRESS_INFO, x: SOCKADDR) {.inline.} = self.union1.IpAddress = x +proc ipAddress*(self: NET_ADDRESS_INFO): SOCKADDR {.inline.} = self.union1.IpAddress +proc ipAddress*(self: var NET_ADDRESS_INFO): var SOCKADDR {.inline.} = self.union1.IpAddress +proc `AuthenticationEvent=`*(self: var NDIS_802_11_TEST, x: NDIS_802_11_AUTHENTICATION_EVENT) {.inline.} = self.union1.AuthenticationEvent = x +proc AuthenticationEvent*(self: NDIS_802_11_TEST): NDIS_802_11_AUTHENTICATION_EVENT {.inline.} = self.union1.AuthenticationEvent +proc AuthenticationEvent*(self: var NDIS_802_11_TEST): var NDIS_802_11_AUTHENTICATION_EVENT {.inline.} = self.union1.AuthenticationEvent +proc `RssiTrigger=`*(self: var NDIS_802_11_TEST, x: NDIS_802_11_RSSI) {.inline.} = self.union1.RssiTrigger = x +proc RssiTrigger*(self: NDIS_802_11_TEST): NDIS_802_11_RSSI {.inline.} = self.union1.RssiTrigger +proc RssiTrigger*(self: var NDIS_802_11_TEST): var NDIS_802_11_RSSI {.inline.} = self.union1.RssiTrigger +proc `Oid=`*(self: var NDIS_GUID, x: NDIS_OID) {.inline.} = self.union1.Oid = x +proc Oid*(self: NDIS_GUID): NDIS_OID {.inline.} = self.union1.Oid +proc Oid*(self: var NDIS_GUID): var NDIS_OID {.inline.} = self.union1.Oid +proc `Status=`*(self: var NDIS_GUID, x: NDIS_STATUS) {.inline.} = self.union1.Status = x +proc Status*(self: NDIS_GUID): NDIS_STATUS {.inline.} = self.union1.Status +proc Status*(self: var NDIS_GUID): var NDIS_STATUS {.inline.} = self.union1.Status +proc `RscIPv4=`*(self: var NDIS_OFFLOAD_PARAMETERS, x: UCHAR) {.inline.} = self.struct1.RscIPv4 = x +proc RscIPv4*(self: NDIS_OFFLOAD_PARAMETERS): UCHAR {.inline.} = self.struct1.RscIPv4 +proc RscIPv4*(self: var NDIS_OFFLOAD_PARAMETERS): var UCHAR {.inline.} = self.struct1.RscIPv4 +proc `RscIPv6=`*(self: var NDIS_OFFLOAD_PARAMETERS, x: UCHAR) {.inline.} = self.struct1.RscIPv6 = x +proc RscIPv6*(self: NDIS_OFFLOAD_PARAMETERS): UCHAR {.inline.} = self.struct1.RscIPv6 +proc RscIPv6*(self: var NDIS_OFFLOAD_PARAMETERS): var UCHAR {.inline.} = self.struct1.RscIPv6 +proc `EncapsulatedPacketTaskOffload=`*(self: var NDIS_OFFLOAD_PARAMETERS, x: UCHAR) {.inline.} = self.struct2.EncapsulatedPacketTaskOffload = x +proc EncapsulatedPacketTaskOffload*(self: NDIS_OFFLOAD_PARAMETERS): UCHAR {.inline.} = self.struct2.EncapsulatedPacketTaskOffload +proc EncapsulatedPacketTaskOffload*(self: var NDIS_OFFLOAD_PARAMETERS): var UCHAR {.inline.} = self.struct2.EncapsulatedPacketTaskOffload +proc `EncapsulationTypes=`*(self: var NDIS_OFFLOAD_PARAMETERS, x: UCHAR) {.inline.} = self.struct2.EncapsulationTypes = x +proc `VlanProperties=`*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN, x: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_VlanProperties) {.inline.} = self.union1.VlanProperties = x +proc `SecondaryVlanId=`*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN, x: UINT16) {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanId = x +proc SecondaryVlanId*(self: NDIS_SWITCH_PORT_PROPERTY_VLAN): UINT16 {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanId +proc SecondaryVlanId*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN): var UINT16 {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanId +proc `SecondaryVlanIdArray=`*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN, x: array[64, UINT64]) {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanIdArray = x +proc SecondaryVlanIdArray*(self: NDIS_SWITCH_PORT_PROPERTY_VLAN): array[64, UINT64] {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanIdArray +proc SecondaryVlanIdArray*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN): var array[64, UINT64] {.inline.} = self.union1.PvlanProperties.union1.SecondaryVlanIdArray +proc `PvlanProperties=`*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN, x: NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties) {.inline.} = self.union1.PvlanProperties = x +proc PvlanProperties*(self: NDIS_SWITCH_PORT_PROPERTY_VLAN): NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties {.inline.} = self.union1.PvlanProperties +proc PvlanProperties*(self: var NDIS_SWITCH_PORT_PROPERTY_VLAN): var NDIS_SWITCH_PORT_PROPERTY_VLAN_UNION1_PvlanProperties {.inline.} = self.union1.PvlanProperties +proc `LastReachable=`*(self: var MIB_IPPATH_ROW, x: ULONG) {.inline.} = self.union1.LastReachable = x +proc LastReachable*(self: MIB_IPPATH_ROW): ULONG {.inline.} = self.union1.LastReachable +proc LastReachable*(self: var MIB_IPPATH_ROW): var ULONG {.inline.} = self.union1.LastReachable +proc `LastUnreachable=`*(self: var MIB_IPPATH_ROW, x: ULONG) {.inline.} = self.union1.LastUnreachable = x +proc LastUnreachable*(self: MIB_IPPATH_ROW): ULONG {.inline.} = self.union1.LastUnreachable +proc LastUnreachable*(self: var MIB_IPPATH_ROW): var ULONG {.inline.} = self.union1.LastUnreachable +proc `IsRouter=`*(self: var MIB_IPNET_ROW2, x: BOOLEAN) {.inline.} = self.union1.struct1.IsRouter = x +proc IsRouter*(self: MIB_IPNET_ROW2): BOOLEAN {.inline.} = self.union1.struct1.IsRouter +proc `IsUnreachable=`*(self: var MIB_IPNET_ROW2, x: BOOLEAN) {.inline.} = self.union1.struct1.IsUnreachable = x +proc IsUnreachable*(self: MIB_IPNET_ROW2): BOOLEAN {.inline.} = self.union1.struct1.IsUnreachable +proc `Flags=`*(self: var MIB_IPNET_ROW2, x: UCHAR) {.inline.} = self.union1.Flags = x +proc OnComplete*(self: ptr IConnectionRequestCallback, hrStatus: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnComplete(self, hrStatus) +converter winimConverterIConnectionRequestCallbackToIUnknown*(x: ptr IConnectionRequestCallback): ptr IUnknown = cast[ptr IUnknown](x) +when winimCpu64: + type + IP_OPTION_INFORMATION32* {.pure.} = object + Ttl*: UCHAR + Tos*: UCHAR + Flags*: UCHAR + OptionsSize*: UCHAR + OptionsData*: ptr UCHAR + PIP_OPTION_INFORMATION32* = ptr IP_OPTION_INFORMATION32 + ICMP_ECHO_REPLY32* {.pure.} = object + Address*: IPAddr + Status*: ULONG + RoundTripTime*: ULONG + DataSize*: USHORT + Reserved*: USHORT + Data*: pointer + Options*: IP_OPTION_INFORMATION32 + PICMP_ECHO_REPLY32* = ptr ICMP_ECHO_REPLY32 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/lm.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/lm.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,4061 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winsvc +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + NET_VALIDATE_PASSWORD_TYPE* = int32 + PNET_VALIDATE_PASSWORD_TYPE* = ptr int32 + MSA_INFO_STATE* = int32 + NETSETUP_NAME_TYPE* = int32 + PNETSETUP_NAME_TYPE* = ptr int32 + NETSETUP_JOIN_STATUS* = int32 + PNETSETUP_JOIN_STATUS* = ptr int32 + NET_COMPUTER_NAME_TYPE* = int32 + PNET_COMPUTER_NAME_TYPE* = ptr int32 + DFS_TARGET_PRIORITY_CLASS* = int32 + DFS_NAMESPACE_VERSION_ORIGIN* = int32 + LMSTR* = LPWSTR + LMCSTR* = LPCWSTR + NET_API_STATUS* = DWORD +when winimUnicode: + type + DESC_CHAR* = WCHAR +when winimAnsi: + type + DESC_CHAR* = CHAR +type + API_RET_TYPE* = NET_API_STATUS + USER_INFO_0* {.pure.} = object + usri0_name*: LPWSTR + PUSER_INFO_0* = ptr USER_INFO_0 + LPUSER_INFO_0* = ptr USER_INFO_0 + USER_INFO_1* {.pure.} = object + usri1_name*: LPWSTR + usri1_password*: LPWSTR + usri1_password_age*: DWORD + usri1_priv*: DWORD + usri1_home_dir*: LPWSTR + usri1_comment*: LPWSTR + usri1_flags*: DWORD + usri1_script_path*: LPWSTR + PUSER_INFO_1* = ptr USER_INFO_1 + LPUSER_INFO_1* = ptr USER_INFO_1 + USER_INFO_2* {.pure.} = object + usri2_name*: LPWSTR + usri2_password*: LPWSTR + usri2_password_age*: DWORD + usri2_priv*: DWORD + usri2_home_dir*: LPWSTR + usri2_comment*: LPWSTR + usri2_flags*: DWORD + usri2_script_path*: LPWSTR + usri2_auth_flags*: DWORD + usri2_full_name*: LPWSTR + usri2_usr_comment*: LPWSTR + usri2_parms*: LPWSTR + usri2_workstations*: LPWSTR + usri2_last_logon*: DWORD + usri2_last_logoff*: DWORD + usri2_acct_expires*: DWORD + usri2_max_storage*: DWORD + usri2_units_per_week*: DWORD + usri2_logon_hours*: PBYTE + usri2_bad_pw_count*: DWORD + usri2_num_logons*: DWORD + usri2_logon_server*: LPWSTR + usri2_country_code*: DWORD + usri2_code_page*: DWORD + PUSER_INFO_2* = ptr USER_INFO_2 + LPUSER_INFO_2* = ptr USER_INFO_2 + USER_INFO_3* {.pure.} = object + usri3_name*: LPWSTR + usri3_password*: LPWSTR + usri3_password_age*: DWORD + usri3_priv*: DWORD + usri3_home_dir*: LPWSTR + usri3_comment*: LPWSTR + usri3_flags*: DWORD + usri3_script_path*: LPWSTR + usri3_auth_flags*: DWORD + usri3_full_name*: LPWSTR + usri3_usr_comment*: LPWSTR + usri3_parms*: LPWSTR + usri3_workstations*: LPWSTR + usri3_last_logon*: DWORD + usri3_last_logoff*: DWORD + usri3_acct_expires*: DWORD + usri3_max_storage*: DWORD + usri3_units_per_week*: DWORD + usri3_logon_hours*: PBYTE + usri3_bad_pw_count*: DWORD + usri3_num_logons*: DWORD + usri3_logon_server*: LPWSTR + usri3_country_code*: DWORD + usri3_code_page*: DWORD + usri3_user_id*: DWORD + usri3_primary_group_id*: DWORD + usri3_profile*: LPWSTR + usri3_home_dir_drive*: LPWSTR + usri3_password_expired*: DWORD + PUSER_INFO_3* = ptr USER_INFO_3 + LPUSER_INFO_3* = ptr USER_INFO_3 + USER_INFO_4* {.pure.} = object + usri4_name*: LPWSTR + usri4_password*: LPWSTR + usri4_password_age*: DWORD + usri4_priv*: DWORD + usri4_home_dir*: LPWSTR + usri4_comment*: LPWSTR + usri4_flags*: DWORD + usri4_script_path*: LPWSTR + usri4_auth_flags*: DWORD + usri4_full_name*: LPWSTR + usri4_usr_comment*: LPWSTR + usri4_parms*: LPWSTR + usri4_workstations*: LPWSTR + usri4_last_logon*: DWORD + usri4_last_logoff*: DWORD + usri4_acct_expires*: DWORD + usri4_max_storage*: DWORD + usri4_units_per_week*: DWORD + usri4_logon_hours*: PBYTE + usri4_bad_pw_count*: DWORD + usri4_num_logons*: DWORD + usri4_logon_server*: LPWSTR + usri4_country_code*: DWORD + usri4_code_page*: DWORD + usri4_user_sid*: PSID + usri4_primary_group_id*: DWORD + usri4_profile*: LPWSTR + usri4_home_dir_drive*: LPWSTR + usri4_password_expired*: DWORD + PUSER_INFO_4* = ptr USER_INFO_4 + LPUSER_INFO_4* = ptr USER_INFO_4 + USER_INFO_10* {.pure.} = object + usri10_name*: LPWSTR + usri10_comment*: LPWSTR + usri10_usr_comment*: LPWSTR + usri10_full_name*: LPWSTR + PUSER_INFO_10* = ptr USER_INFO_10 + LPUSER_INFO_10* = ptr USER_INFO_10 + USER_INFO_11* {.pure.} = object + usri11_name*: LPWSTR + usri11_comment*: LPWSTR + usri11_usr_comment*: LPWSTR + usri11_full_name*: LPWSTR + usri11_priv*: DWORD + usri11_auth_flags*: DWORD + usri11_password_age*: DWORD + usri11_home_dir*: LPWSTR + usri11_parms*: LPWSTR + usri11_last_logon*: DWORD + usri11_last_logoff*: DWORD + usri11_bad_pw_count*: DWORD + usri11_num_logons*: DWORD + usri11_logon_server*: LPWSTR + usri11_country_code*: DWORD + usri11_workstations*: LPWSTR + usri11_max_storage*: DWORD + usri11_units_per_week*: DWORD + usri11_logon_hours*: PBYTE + usri11_code_page*: DWORD + PUSER_INFO_11* = ptr USER_INFO_11 + LPUSER_INFO_11* = ptr USER_INFO_11 + USER_INFO_20* {.pure.} = object + usri20_name*: LPWSTR + usri20_full_name*: LPWSTR + usri20_comment*: LPWSTR + usri20_flags*: DWORD + usri20_user_id*: DWORD + PUSER_INFO_20* = ptr USER_INFO_20 + LPUSER_INFO_20* = ptr USER_INFO_20 +const + ENCRYPTED_PWLEN* = 16 +type + USER_INFO_21* {.pure.} = object + usri21_password*: array[ENCRYPTED_PWLEN, BYTE] + PUSER_INFO_21* = ptr USER_INFO_21 + LPUSER_INFO_21* = ptr USER_INFO_21 + USER_INFO_22* {.pure.} = object + usri22_name*: LPWSTR + usri22_password*: array[ENCRYPTED_PWLEN, BYTE] + usri22_password_age*: DWORD + usri22_priv*: DWORD + usri22_home_dir*: LPWSTR + usri22_comment*: LPWSTR + usri22_flags*: DWORD + usri22_script_path*: LPWSTR + usri22_auth_flags*: DWORD + usri22_full_name*: LPWSTR + usri22_usr_comment*: LPWSTR + usri22_parms*: LPWSTR + usri22_workstations*: LPWSTR + usri22_last_logon*: DWORD + usri22_last_logoff*: DWORD + usri22_acct_expires*: DWORD + usri22_max_storage*: DWORD + usri22_units_per_week*: DWORD + usri22_logon_hours*: PBYTE + usri22_bad_pw_count*: DWORD + usri22_num_logons*: DWORD + usri22_logon_server*: LPWSTR + usri22_country_code*: DWORD + usri22_code_page*: DWORD + PUSER_INFO_22* = ptr USER_INFO_22 + LPUSER_INFO_22* = ptr USER_INFO_22 + USER_INFO_23* {.pure.} = object + usri23_name*: LPWSTR + usri23_full_name*: LPWSTR + usri23_comment*: LPWSTR + usri23_flags*: DWORD + usri23_user_sid*: PSID + PUSER_INFO_23* = ptr USER_INFO_23 + LPUSER_INFO_23* = ptr USER_INFO_23 + USER_INFO_24* {.pure.} = object + usri24_internet_identity*: BOOL + usri24_flags*: DWORD + usri24_internet_provider_name*: LPWSTR + usri24_internet_principal_name*: LPWSTR + usri24_user_sid*: PSID + PUSER_INFO_24* = ptr USER_INFO_24 + LPUSER_INFO_24* = ptr USER_INFO_24 + USER_INFO_1003* {.pure.} = object + usri1003_password*: LPWSTR + PUSER_INFO_1003* = ptr USER_INFO_1003 + LPUSER_INFO_1003* = ptr USER_INFO_1003 + USER_INFO_1005* {.pure.} = object + usri1005_priv*: DWORD + PUSER_INFO_1005* = ptr USER_INFO_1005 + LPUSER_INFO_1005* = ptr USER_INFO_1005 + USER_INFO_1006* {.pure.} = object + usri1006_home_dir*: LPWSTR + PUSER_INFO_1006* = ptr USER_INFO_1006 + LPUSER_INFO_1006* = ptr USER_INFO_1006 + USER_INFO_1007* {.pure.} = object + usri1007_comment*: LPWSTR + PUSER_INFO_1007* = ptr USER_INFO_1007 + LPUSER_INFO_1007* = ptr USER_INFO_1007 + USER_INFO_1008* {.pure.} = object + usri1008_flags*: DWORD + PUSER_INFO_1008* = ptr USER_INFO_1008 + LPUSER_INFO_1008* = ptr USER_INFO_1008 + USER_INFO_1009* {.pure.} = object + usri1009_script_path*: LPWSTR + PUSER_INFO_1009* = ptr USER_INFO_1009 + LPUSER_INFO_1009* = ptr USER_INFO_1009 + USER_INFO_1010* {.pure.} = object + usri1010_auth_flags*: DWORD + PUSER_INFO_1010* = ptr USER_INFO_1010 + LPUSER_INFO_1010* = ptr USER_INFO_1010 + USER_INFO_1011* {.pure.} = object + usri1011_full_name*: LPWSTR + PUSER_INFO_1011* = ptr USER_INFO_1011 + LPUSER_INFO_1011* = ptr USER_INFO_1011 + USER_INFO_1012* {.pure.} = object + usri1012_usr_comment*: LPWSTR + PUSER_INFO_1012* = ptr USER_INFO_1012 + LPUSER_INFO_1012* = ptr USER_INFO_1012 + USER_INFO_1013* {.pure.} = object + usri1013_parms*: LPWSTR + PUSER_INFO_1013* = ptr USER_INFO_1013 + LPUSER_INFO_1013* = ptr USER_INFO_1013 + USER_INFO_1014* {.pure.} = object + usri1014_workstations*: LPWSTR + PUSER_INFO_1014* = ptr USER_INFO_1014 + LPUSER_INFO_1014* = ptr USER_INFO_1014 + USER_INFO_1017* {.pure.} = object + usri1017_acct_expires*: DWORD + PUSER_INFO_1017* = ptr USER_INFO_1017 + LPUSER_INFO_1017* = ptr USER_INFO_1017 + USER_INFO_1018* {.pure.} = object + usri1018_max_storage*: DWORD + PUSER_INFO_1018* = ptr USER_INFO_1018 + LPUSER_INFO_1018* = ptr USER_INFO_1018 + USER_INFO_1020* {.pure.} = object + usri1020_units_per_week*: DWORD + usri1020_logon_hours*: LPBYTE + PUSER_INFO_1020* = ptr USER_INFO_1020 + LPUSER_INFO_1020* = ptr USER_INFO_1020 + USER_INFO_1023* {.pure.} = object + usri1023_logon_server*: LPWSTR + PUSER_INFO_1023* = ptr USER_INFO_1023 + LPUSER_INFO_1023* = ptr USER_INFO_1023 + USER_INFO_1024* {.pure.} = object + usri1024_country_code*: DWORD + PUSER_INFO_1024* = ptr USER_INFO_1024 + LPUSER_INFO_1024* = ptr USER_INFO_1024 + USER_INFO_1025* {.pure.} = object + usri1025_code_page*: DWORD + PUSER_INFO_1025* = ptr USER_INFO_1025 + LPUSER_INFO_1025* = ptr USER_INFO_1025 + USER_INFO_1051* {.pure.} = object + usri1051_primary_group_id*: DWORD + PUSER_INFO_1051* = ptr USER_INFO_1051 + LPUSER_INFO_1051* = ptr USER_INFO_1051 + USER_INFO_1052* {.pure.} = object + usri1052_profile*: LPWSTR + PUSER_INFO_1052* = ptr USER_INFO_1052 + LPUSER_INFO_1052* = ptr USER_INFO_1052 + USER_INFO_1053* {.pure.} = object + usri1053_home_dir_drive*: LPWSTR + PUSER_INFO_1053* = ptr USER_INFO_1053 + LPUSER_INFO_1053* = ptr USER_INFO_1053 + USER_MODALS_INFO_0* {.pure.} = object + usrmod0_min_passwd_len*: DWORD + usrmod0_max_passwd_age*: DWORD + usrmod0_min_passwd_age*: DWORD + usrmod0_force_logoff*: DWORD + usrmod0_password_hist_len*: DWORD + PUSER_MODALS_INFO_0* = ptr USER_MODALS_INFO_0 + LPUSER_MODALS_INFO_0* = ptr USER_MODALS_INFO_0 + USER_MODALS_INFO_1* {.pure.} = object + usrmod1_role*: DWORD + usrmod1_primary*: LPWSTR + PUSER_MODALS_INFO_1* = ptr USER_MODALS_INFO_1 + LPUSER_MODALS_INFO_1* = ptr USER_MODALS_INFO_1 + USER_MODALS_INFO_2* {.pure.} = object + usrmod2_domain_name*: LPWSTR + usrmod2_domain_id*: PSID + PUSER_MODALS_INFO_2* = ptr USER_MODALS_INFO_2 + LPUSER_MODALS_INFO_2* = ptr USER_MODALS_INFO_2 + USER_MODALS_INFO_3* {.pure.} = object + usrmod3_lockout_duration*: DWORD + usrmod3_lockout_observation_window*: DWORD + usrmod3_lockout_threshold*: DWORD + PUSER_MODALS_INFO_3* = ptr USER_MODALS_INFO_3 + LPUSER_MODALS_INFO_3* = ptr USER_MODALS_INFO_3 + USER_MODALS_INFO_1001* {.pure.} = object + usrmod1001_min_passwd_len*: DWORD + PUSER_MODALS_INFO_1001* = ptr USER_MODALS_INFO_1001 + LPUSER_MODALS_INFO_1001* = ptr USER_MODALS_INFO_1001 + USER_MODALS_INFO_1002* {.pure.} = object + usrmod1002_max_passwd_age*: DWORD + PUSER_MODALS_INFO_1002* = ptr USER_MODALS_INFO_1002 + LPUSER_MODALS_INFO_1002* = ptr USER_MODALS_INFO_1002 + USER_MODALS_INFO_1003* {.pure.} = object + usrmod1003_min_passwd_age*: DWORD + PUSER_MODALS_INFO_1003* = ptr USER_MODALS_INFO_1003 + LPUSER_MODALS_INFO_1003* = ptr USER_MODALS_INFO_1003 + USER_MODALS_INFO_1004* {.pure.} = object + usrmod1004_force_logoff*: DWORD + PUSER_MODALS_INFO_1004* = ptr USER_MODALS_INFO_1004 + LPUSER_MODALS_INFO_1004* = ptr USER_MODALS_INFO_1004 + USER_MODALS_INFO_1005* {.pure.} = object + usrmod1005_password_hist_len*: DWORD + PUSER_MODALS_INFO_1005* = ptr USER_MODALS_INFO_1005 + LPUSER_MODALS_INFO_1005* = ptr USER_MODALS_INFO_1005 + USER_MODALS_INFO_1006* {.pure.} = object + usrmod1006_role*: DWORD + PUSER_MODALS_INFO_1006* = ptr USER_MODALS_INFO_1006 + LPUSER_MODALS_INFO_1006* = ptr USER_MODALS_INFO_1006 + USER_MODALS_INFO_1007* {.pure.} = object + usrmod1007_primary*: LPWSTR + PUSER_MODALS_INFO_1007* = ptr USER_MODALS_INFO_1007 + LPUSER_MODALS_INFO_1007* = ptr USER_MODALS_INFO_1007 + GROUP_INFO_0* {.pure.} = object + grpi0_name*: LPWSTR + PGROUP_INFO_0* = ptr GROUP_INFO_0 + LPGROUP_INFO_0* = ptr GROUP_INFO_0 + GROUP_INFO_1* {.pure.} = object + grpi1_name*: LPWSTR + grpi1_comment*: LPWSTR + PGROUP_INFO_1* = ptr GROUP_INFO_1 + LPGROUP_INFO_1* = ptr GROUP_INFO_1 + GROUP_INFO_2* {.pure.} = object + grpi2_name*: LPWSTR + grpi2_comment*: LPWSTR + grpi2_group_id*: DWORD + grpi2_attributes*: DWORD + PGROUP_INFO_2* = ptr GROUP_INFO_2 + GROUP_INFO_3* {.pure.} = object + grpi3_name*: LPWSTR + grpi3_comment*: LPWSTR + grpi3_group_sid*: PSID + grpi3_attributes*: DWORD + PGROUP_INFO_3* = ptr GROUP_INFO_3 + GROUP_INFO_1002* {.pure.} = object + grpi1002_comment*: LPWSTR + PGROUP_INFO_1002* = ptr GROUP_INFO_1002 + LPGROUP_INFO_1002* = ptr GROUP_INFO_1002 + GROUP_INFO_1005* {.pure.} = object + grpi1005_attributes*: DWORD + PGROUP_INFO_1005* = ptr GROUP_INFO_1005 + LPGROUP_INFO_1005* = ptr GROUP_INFO_1005 + GROUP_USERS_INFO_0* {.pure.} = object + grui0_name*: LPWSTR + PGROUP_USERS_INFO_0* = ptr GROUP_USERS_INFO_0 + LPGROUP_USERS_INFO_0* = ptr GROUP_USERS_INFO_0 + GROUP_USERS_INFO_1* {.pure.} = object + grui1_name*: LPWSTR + grui1_attributes*: DWORD + PGROUP_USERS_INFO_1* = ptr GROUP_USERS_INFO_1 + LPGROUP_USERS_INFO_1* = ptr GROUP_USERS_INFO_1 + LOCALGROUP_INFO_0* {.pure.} = object + lgrpi0_name*: LPWSTR + PLOCALGROUP_INFO_0* = ptr LOCALGROUP_INFO_0 + LPLOCALGROUP_INFO_0* = ptr LOCALGROUP_INFO_0 + LOCALGROUP_INFO_1* {.pure.} = object + lgrpi1_name*: LPWSTR + lgrpi1_comment*: LPWSTR + PLOCALGROUP_INFO_1* = ptr LOCALGROUP_INFO_1 + LPLOCALGROUP_INFO_1* = ptr LOCALGROUP_INFO_1 + LOCALGROUP_INFO_1002* {.pure.} = object + lgrpi1002_comment*: LPWSTR + PLOCALGROUP_INFO_1002* = ptr LOCALGROUP_INFO_1002 + LPLOCALGROUP_INFO_1002* = ptr LOCALGROUP_INFO_1002 + LOCALGROUP_MEMBERS_INFO_0* {.pure.} = object + lgrmi0_sid*: PSID + PLOCALGROUP_MEMBERS_INFO_0* = ptr LOCALGROUP_MEMBERS_INFO_0 + LPLOCALGROUP_MEMBERS_INFO_0* = ptr LOCALGROUP_MEMBERS_INFO_0 + LOCALGROUP_MEMBERS_INFO_1* {.pure.} = object + lgrmi1_sid*: PSID + lgrmi1_sidusage*: SID_NAME_USE + lgrmi1_name*: LPWSTR + PLOCALGROUP_MEMBERS_INFO_1* = ptr LOCALGROUP_MEMBERS_INFO_1 + LPLOCALGROUP_MEMBERS_INFO_1* = ptr LOCALGROUP_MEMBERS_INFO_1 + LOCALGROUP_MEMBERS_INFO_2* {.pure.} = object + lgrmi2_sid*: PSID + lgrmi2_sidusage*: SID_NAME_USE + lgrmi2_domainandname*: LPWSTR + PLOCALGROUP_MEMBERS_INFO_2* = ptr LOCALGROUP_MEMBERS_INFO_2 + LPLOCALGROUP_MEMBERS_INFO_2* = ptr LOCALGROUP_MEMBERS_INFO_2 + LOCALGROUP_MEMBERS_INFO_3* {.pure.} = object + lgrmi3_domainandname*: LPWSTR + PLOCALGROUP_MEMBERS_INFO_3* = ptr LOCALGROUP_MEMBERS_INFO_3 + LPLOCALGROUP_MEMBERS_INFO_3* = ptr LOCALGROUP_MEMBERS_INFO_3 + LOCALGROUP_USERS_INFO_0* {.pure.} = object + lgrui0_name*: LPWSTR + PLOCALGROUP_USERS_INFO_0* = ptr LOCALGROUP_USERS_INFO_0 + LPLOCALGROUP_USERS_INFO_0* = ptr LOCALGROUP_USERS_INFO_0 + NET_DISPLAY_USER* {.pure.} = object + usri1_name*: LPWSTR + usri1_comment*: LPWSTR + usri1_flags*: DWORD + usri1_full_name*: LPWSTR + usri1_user_id*: DWORD + usri1_next_index*: DWORD + PNET_DISPLAY_USER* = ptr NET_DISPLAY_USER + NET_DISPLAY_MACHINE* {.pure.} = object + usri2_name*: LPWSTR + usri2_comment*: LPWSTR + usri2_flags*: DWORD + usri2_user_id*: DWORD + usri2_next_index*: DWORD + PNET_DISPLAY_MACHINE* = ptr NET_DISPLAY_MACHINE + NET_DISPLAY_GROUP* {.pure.} = object + grpi3_name*: LPWSTR + grpi3_comment*: LPWSTR + grpi3_group_id*: DWORD + grpi3_attributes*: DWORD + grpi3_next_index*: DWORD + PNET_DISPLAY_GROUP* = ptr NET_DISPLAY_GROUP + ACCESS_INFO_0* {.pure.} = object + acc0_resource_name*: LPWSTR + PACCESS_INFO_0* = ptr ACCESS_INFO_0 + LPACCESS_INFO_0* = ptr ACCESS_INFO_0 + ACCESS_INFO_1* {.pure.} = object + acc1_resource_name*: LPWSTR + acc1_attr*: DWORD + acc1_count*: DWORD + PACCESS_INFO_1* = ptr ACCESS_INFO_1 + LPACCESS_INFO_1* = ptr ACCESS_INFO_1 + ACCESS_INFO_1002* {.pure.} = object + acc1002_attr*: DWORD + PACCESS_INFO_1002* = ptr ACCESS_INFO_1002 + LPACCESS_INFO_1002* = ptr ACCESS_INFO_1002 + ACCESS_LIST* {.pure.} = object + acl_ugname*: LPWSTR + acl_access*: DWORD + PACCESS_LIST* = ptr ACCESS_LIST + LPACCESS_LIST* = ptr ACCESS_LIST + NET_VALIDATE_PASSWORD_HASH* {.pure.} = object + Length*: ULONG + Hash*: LPBYTE + PNET_VALIDATE_PASSWORD_HASH* = ptr NET_VALIDATE_PASSWORD_HASH + NET_VALIDATE_PERSISTED_FIELDS* {.pure.} = object + PresentFields*: ULONG + PasswordLastSet*: FILETIME + BadPasswordTime*: FILETIME + LockoutTime*: FILETIME + BadPasswordCount*: ULONG + PasswordHistoryLength*: ULONG + PasswordHistory*: PNET_VALIDATE_PASSWORD_HASH + PNET_VALIDATE_PERSISTED_FIELDS* = ptr NET_VALIDATE_PERSISTED_FIELDS + NET_VALIDATE_OUTPUT_ARG* {.pure.} = object + ChangedPersistedFields*: NET_VALIDATE_PERSISTED_FIELDS + ValidationStatus*: NET_API_STATUS + PNET_VALIDATE_OUTPUT_ARG* = ptr NET_VALIDATE_OUTPUT_ARG + NET_VALIDATE_AUTHENTICATION_INPUT_ARG* {.pure.} = object + InputPersistedFields*: NET_VALIDATE_PERSISTED_FIELDS + PasswordMatched*: BOOLEAN + PNET_VALIDATE_AUTHENTICATION_INPUT_ARG* = ptr NET_VALIDATE_AUTHENTICATION_INPUT_ARG + NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG* {.pure.} = object + InputPersistedFields*: NET_VALIDATE_PERSISTED_FIELDS + ClearPassword*: LPWSTR + UserAccountName*: LPWSTR + HashedPassword*: NET_VALIDATE_PASSWORD_HASH + PasswordMatch*: BOOLEAN + PNET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG* = ptr NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG + NET_VALIDATE_PASSWORD_RESET_INPUT_ARG* {.pure.} = object + InputPersistedFields*: NET_VALIDATE_PERSISTED_FIELDS + ClearPassword*: LPWSTR + UserAccountName*: LPWSTR + HashedPassword*: NET_VALIDATE_PASSWORD_HASH + PasswordMustChangeAtNextLogon*: BOOLEAN + ClearLockout*: BOOLEAN + PNET_VALIDATE_PASSWORD_RESET_INPUT_ARG* = ptr NET_VALIDATE_PASSWORD_RESET_INPUT_ARG + NETLOGON_INFO_1* {.pure.} = object + netlog1_flags*: DWORD + netlog1_pdc_connection_status*: NET_API_STATUS + PNETLOGON_INFO_1* = ptr NETLOGON_INFO_1 + NETLOGON_INFO_2* {.pure.} = object + netlog2_flags*: DWORD + netlog2_pdc_connection_status*: NET_API_STATUS + netlog2_trusted_dc_name*: LPWSTR + netlog2_tc_connection_status*: NET_API_STATUS + PNETLOGON_INFO_2* = ptr NETLOGON_INFO_2 + NETLOGON_INFO_3* {.pure.} = object + netlog3_flags*: DWORD + netlog3_logon_attempts*: DWORD + netlog3_reserved1*: DWORD + netlog3_reserved2*: DWORD + netlog3_reserved3*: DWORD + netlog3_reserved4*: DWORD + netlog3_reserved5*: DWORD + PNETLOGON_INFO_3* = ptr NETLOGON_INFO_3 + NETLOGON_INFO_4* {.pure.} = object + netlog4_trusted_dc_name*: LPWSTR + netlog4_trusted_domain_name*: LPWSTR + PNETLOGON_INFO_4* = ptr NETLOGON_INFO_4 + MSA_INFO_0* {.pure.} = object + State*: MSA_INFO_STATE + PMSA_INFO_0* = ptr MSA_INFO_0 +const + EVLEN* = 16 + SNLEN* = 80 +type + STD_ALERT* {.pure.} = object + alrt_timestamp*: DWORD + alrt_eventname*: array[EVLEN + 1, WCHAR] + alrt_servicename*: array[SNLEN + 1, WCHAR] + PSTD_ALERT* = ptr STD_ALERT + LPSTD_ALERT* = ptr STD_ALERT + ADMIN_OTHER_INFO* {.pure.} = object + alrtad_errcode*: DWORD + alrtad_numstrings*: DWORD + PADMIN_OTHER_INFO* = ptr ADMIN_OTHER_INFO + LPADMIN_OTHER_INFO* = ptr ADMIN_OTHER_INFO + ERRLOG_OTHER_INFO* {.pure.} = object + alrter_errcode*: DWORD + alrter_offset*: DWORD + PERRLOG_OTHER_INFO* = ptr ERRLOG_OTHER_INFO + LPERRLOG_OTHER_INFO* = ptr ERRLOG_OTHER_INFO + PRINT_OTHER_INFO* {.pure.} = object + alrtpr_jobid*: DWORD + alrtpr_status*: DWORD + alrtpr_submitted*: DWORD + alrtpr_size*: DWORD + PPRINT_OTHER_INFO* = ptr PRINT_OTHER_INFO + LPPRINT_OTHER_INFO* = ptr PRINT_OTHER_INFO + USER_OTHER_INFO* {.pure.} = object + alrtus_errcode*: DWORD + alrtus_numstrings*: DWORD + PUSER_OTHER_INFO* = ptr USER_OTHER_INFO + LPUSER_OTHER_INFO* = ptr USER_OTHER_INFO + SHARE_INFO_0* {.pure.} = object + shi0_netname*: LMSTR + PSHARE_INFO_0* = ptr SHARE_INFO_0 + LPSHARE_INFO_0* = ptr SHARE_INFO_0 + SHARE_INFO_1* {.pure.} = object + shi1_netname*: LMSTR + shi1_type*: DWORD + shi1_remark*: LMSTR + PSHARE_INFO_1* = ptr SHARE_INFO_1 + LPSHARE_INFO_1* = ptr SHARE_INFO_1 + SHARE_INFO_2* {.pure.} = object + shi2_netname*: LMSTR + shi2_type*: DWORD + shi2_remark*: LMSTR + shi2_permissions*: DWORD + shi2_max_uses*: DWORD + shi2_current_uses*: DWORD + shi2_path*: LMSTR + shi2_passwd*: LMSTR + PSHARE_INFO_2* = ptr SHARE_INFO_2 + LPSHARE_INFO_2* = ptr SHARE_INFO_2 + SHARE_INFO_501* {.pure.} = object + shi501_netname*: LMSTR + shi501_type*: DWORD + shi501_remark*: LMSTR + shi501_flags*: DWORD + PSHARE_INFO_501* = ptr SHARE_INFO_501 + LPSHARE_INFO_501* = ptr SHARE_INFO_501 + SHARE_INFO_502* {.pure.} = object + shi502_netname*: LMSTR + shi502_type*: DWORD + shi502_remark*: LMSTR + shi502_permissions*: DWORD + shi502_max_uses*: DWORD + shi502_current_uses*: DWORD + shi502_path*: LMSTR + shi502_passwd*: LMSTR + shi502_reserved*: DWORD + shi502_security_descriptor*: PSECURITY_DESCRIPTOR + PSHARE_INFO_502* = ptr SHARE_INFO_502 + LPSHARE_INFO_502* = ptr SHARE_INFO_502 + SHARE_INFO_1004* {.pure.} = object + shi1004_remark*: LMSTR + PSHARE_INFO_1004* = ptr SHARE_INFO_1004 + LPSHARE_INFO_1004* = ptr SHARE_INFO_1004 + SHARE_INFO_1005* {.pure.} = object + shi1005_flags*: DWORD + PSHARE_INFO_1005* = ptr SHARE_INFO_1005 + LPSHARE_INFO_1005* = ptr SHARE_INFO_1005 + SHARE_INFO_1006* {.pure.} = object + shi1006_max_uses*: DWORD + PSHARE_INFO_1006* = ptr SHARE_INFO_1006 + LPSHARE_INFO_1006* = ptr SHARE_INFO_1006 + SHARE_INFO_1501* {.pure.} = object + shi1501_reserved*: DWORD + shi1501_security_descriptor*: PSECURITY_DESCRIPTOR + PSHARE_INFO_1501* = ptr SHARE_INFO_1501 + LPSHARE_INFO_1501* = ptr SHARE_INFO_1501 + SESSION_INFO_0* {.pure.} = object + sesi0_cname*: LMSTR + PSESSION_INFO_0* = ptr SESSION_INFO_0 + LPSESSION_INFO_0* = ptr SESSION_INFO_0 + SESSION_INFO_1* {.pure.} = object + sesi1_cname*: LMSTR + sesi1_username*: LMSTR + sesi1_num_opens*: DWORD + sesi1_time*: DWORD + sesi1_idle_time*: DWORD + sesi1_user_flags*: DWORD + PSESSION_INFO_1* = ptr SESSION_INFO_1 + LPSESSION_INFO_1* = ptr SESSION_INFO_1 + SESSION_INFO_2* {.pure.} = object + sesi2_cname*: LMSTR + sesi2_username*: LMSTR + sesi2_num_opens*: DWORD + sesi2_time*: DWORD + sesi2_idle_time*: DWORD + sesi2_user_flags*: DWORD + sesi2_cltype_name*: LMSTR + PSESSION_INFO_2* = ptr SESSION_INFO_2 + LPSESSION_INFO_2* = ptr SESSION_INFO_2 + SESSION_INFO_10* {.pure.} = object + sesi10_cname*: LMSTR + sesi10_username*: LMSTR + sesi10_time*: DWORD + sesi10_idle_time*: DWORD + PSESSION_INFO_10* = ptr SESSION_INFO_10 + LPSESSION_INFO_10* = ptr SESSION_INFO_10 + SESSION_INFO_502* {.pure.} = object + sesi502_cname*: LMSTR + sesi502_username*: LMSTR + sesi502_num_opens*: DWORD + sesi502_time*: DWORD + sesi502_idle_time*: DWORD + sesi502_user_flags*: DWORD + sesi502_cltype_name*: LMSTR + sesi502_transport*: LMSTR + PSESSION_INFO_502* = ptr SESSION_INFO_502 + LPSESSION_INFO_502* = ptr SESSION_INFO_502 + CONNECTION_INFO_0* {.pure.} = object + coni0_id*: DWORD + PCONNECTION_INFO_0* = ptr CONNECTION_INFO_0 + LPCONNECTION_INFO_0* = ptr CONNECTION_INFO_0 + CONNECTION_INFO_1* {.pure.} = object + coni1_id*: DWORD + coni1_type*: DWORD + coni1_num_opens*: DWORD + coni1_num_users*: DWORD + coni1_time*: DWORD + coni1_username*: LMSTR + coni1_netname*: LMSTR + PCONNECTION_INFO_1* = ptr CONNECTION_INFO_1 + LPCONNECTION_INFO_1* = ptr CONNECTION_INFO_1 + FILE_INFO_2* {.pure.} = object + fi2_id*: DWORD + PFILE_INFO_2* = ptr FILE_INFO_2 + LPFILE_INFO_2* = ptr FILE_INFO_2 + FILE_INFO_3* {.pure.} = object + fi3_id*: DWORD + fi3_permissions*: DWORD + fi3_num_locks*: DWORD + fi3_pathname*: LMSTR + fi3_username*: LMSTR + PFILE_INFO_3* = ptr FILE_INFO_3 + LPFILE_INFO_3* = ptr FILE_INFO_3 + MSG_INFO_0* {.pure.} = object + msgi0_name*: LPWSTR + PMSG_INFO_0* = ptr MSG_INFO_0 + LPMSG_INFO_0* = ptr MSG_INFO_0 + MSG_INFO_1* {.pure.} = object + msgi1_name*: LPWSTR + msgi1_forward_flag*: DWORD + msgi1_forward*: LPWSTR + PMSG_INFO_1* = ptr MSG_INFO_1 + LPMSG_INFO_1* = ptr MSG_INFO_1 + LPDESC* = ptr DESC_CHAR + TIME_OF_DAY_INFO* {.pure.} = object + tod_elapsedt*: DWORD + tod_msecs*: DWORD + tod_hours*: DWORD + tod_mins*: DWORD + tod_secs*: DWORD + tod_hunds*: DWORD + tod_timezone*: LONG + tod_tinterval*: DWORD + tod_day*: DWORD + tod_month*: DWORD + tod_year*: DWORD + tod_weekday*: DWORD + PTIME_OF_DAY_INFO* = ptr TIME_OF_DAY_INFO + LPTIME_OF_DAY_INFO* = ptr TIME_OF_DAY_INFO + REPL_INFO_0* {.pure.} = object + rp0_role*: DWORD + rp0_exportpath*: LPWSTR + rp0_exportlist*: LPWSTR + rp0_importpath*: LPWSTR + rp0_importlist*: LPWSTR + rp0_logonusername*: LPWSTR + rp0_interval*: DWORD + rp0_pulse*: DWORD + rp0_guardtime*: DWORD + rp0_random*: DWORD + PREPL_INFO_0* = ptr REPL_INFO_0 + LPREPL_INFO_0* = ptr REPL_INFO_0 + REPL_INFO_1000* {.pure.} = object + rp1000_interval*: DWORD + PREPL_INFO_1000* = ptr REPL_INFO_1000 + LPREPL_INFO_1000* = ptr REPL_INFO_1000 + REPL_INFO_1001* {.pure.} = object + rp1001_pulse*: DWORD + PREPL_INFO_1001* = ptr REPL_INFO_1001 + LPREPL_INFO_1001* = ptr REPL_INFO_1001 + REPL_INFO_1002* {.pure.} = object + rp1002_guardtime*: DWORD + PREPL_INFO_1002* = ptr REPL_INFO_1002 + LPREPL_INFO_1002* = ptr REPL_INFO_1002 + REPL_INFO_1003* {.pure.} = object + rp1003_random*: DWORD + PREPL_INFO_1003* = ptr REPL_INFO_1003 + LPREPL_INFO_1003* = ptr REPL_INFO_1003 + REPL_EDIR_INFO_0* {.pure.} = object + rped0_dirname*: LPWSTR + PREPL_EDIR_INFO_0* = ptr REPL_EDIR_INFO_0 + LPREPL_EDIR_INFO_0* = ptr REPL_EDIR_INFO_0 + REPL_EDIR_INFO_1* {.pure.} = object + rped1_dirname*: LPWSTR + rped1_integrity*: DWORD + rped1_extent*: DWORD + PREPL_EDIR_INFO_1* = ptr REPL_EDIR_INFO_1 + LPREPL_EDIR_INFO_1* = ptr REPL_EDIR_INFO_1 + REPL_EDIR_INFO_2* {.pure.} = object + rped2_dirname*: LPWSTR + rped2_integrity*: DWORD + rped2_extent*: DWORD + rped2_lockcount*: DWORD + rped2_locktime*: DWORD + PREPL_EDIR_INFO_2* = ptr REPL_EDIR_INFO_2 + LPREPL_EDIR_INFO_2* = ptr REPL_EDIR_INFO_2 + REPL_EDIR_INFO_1000* {.pure.} = object + rped1000_integrity*: DWORD + PREPL_EDIR_INFO_1000* = ptr REPL_EDIR_INFO_1000 + LPREPL_EDIR_INFO_1000* = ptr REPL_EDIR_INFO_1000 + REPL_EDIR_INFO_1001* {.pure.} = object + rped1001_extent*: DWORD + PREPL_EDIR_INFO_1001* = ptr REPL_EDIR_INFO_1001 + LPREPL_EDIR_INFO_1001* = ptr REPL_EDIR_INFO_1001 + REPL_IDIR_INFO_0* {.pure.} = object + rpid0_dirname*: LPWSTR + PREPL_IDIR_INFO_0* = ptr REPL_IDIR_INFO_0 + LPREPL_IDIR_INFO_0* = ptr REPL_IDIR_INFO_0 + REPL_IDIR_INFO_1* {.pure.} = object + rpid1_dirname*: LPWSTR + rpid1_state*: DWORD + rpid1_mastername*: LPWSTR + rpid1_last_update_time*: DWORD + rpid1_lockcount*: DWORD + rpid1_locktime*: DWORD + PREPL_IDIR_INFO_1* = ptr REPL_IDIR_INFO_1 + LPREPL_IDIR_INFO_1* = ptr REPL_IDIR_INFO_1 + SERVER_INFO_100* {.pure.} = object + sv100_platform_id*: DWORD + sv100_name*: LMSTR + PSERVER_INFO_100* = ptr SERVER_INFO_100 + LPSERVER_INFO_100* = ptr SERVER_INFO_100 + SERVER_INFO_101* {.pure.} = object + sv101_platform_id*: DWORD + sv101_name*: LMSTR + sv101_version_major*: DWORD + sv101_version_minor*: DWORD + sv101_type*: DWORD + sv101_comment*: LMSTR + PSERVER_INFO_101* = ptr SERVER_INFO_101 + LPSERVER_INFO_101* = ptr SERVER_INFO_101 + SERVER_INFO_102* {.pure.} = object + sv102_platform_id*: DWORD + sv102_name*: LMSTR + sv102_version_major*: DWORD + sv102_version_minor*: DWORD + sv102_type*: DWORD + sv102_comment*: LMSTR + sv102_users*: DWORD + sv102_disc*: LONG + sv102_hidden*: WINBOOL + sv102_announce*: DWORD + sv102_anndelta*: DWORD + sv102_licenses*: DWORD + sv102_userpath*: LMSTR + PSERVER_INFO_102* = ptr SERVER_INFO_102 + LPSERVER_INFO_102* = ptr SERVER_INFO_102 + SERVER_INFO_402* {.pure.} = object + sv402_ulist_mtime*: DWORD + sv402_glist_mtime*: DWORD + sv402_alist_mtime*: DWORD + sv402_alerts*: LMSTR + sv402_security*: DWORD + sv402_numadmin*: DWORD + sv402_lanmask*: DWORD + sv402_guestacct*: LMSTR + sv402_chdevs*: DWORD + sv402_chdevq*: DWORD + sv402_chdevjobs*: DWORD + sv402_connections*: DWORD + sv402_shares*: DWORD + sv402_openfiles*: DWORD + sv402_sessopens*: DWORD + sv402_sessvcs*: DWORD + sv402_sessreqs*: DWORD + sv402_opensearch*: DWORD + sv402_activelocks*: DWORD + sv402_numreqbuf*: DWORD + sv402_sizreqbuf*: DWORD + sv402_numbigbuf*: DWORD + sv402_numfiletasks*: DWORD + sv402_alertsched*: DWORD + sv402_erroralert*: DWORD + sv402_logonalert*: DWORD + sv402_accessalert*: DWORD + sv402_diskalert*: DWORD + sv402_netioalert*: DWORD + sv402_maxauditsz*: DWORD + sv402_srvheuristics*: LMSTR + PSERVER_INFO_402* = ptr SERVER_INFO_402 + LPSERVER_INFO_402* = ptr SERVER_INFO_402 + SERVER_INFO_403* {.pure.} = object + sv403_ulist_mtime*: DWORD + sv403_glist_mtime*: DWORD + sv403_alist_mtime*: DWORD + sv403_alerts*: LMSTR + sv403_security*: DWORD + sv403_numadmin*: DWORD + sv403_lanmask*: DWORD + sv403_guestacct*: LMSTR + sv403_chdevs*: DWORD + sv403_chdevq*: DWORD + sv403_chdevjobs*: DWORD + sv403_connections*: DWORD + sv403_shares*: DWORD + sv403_openfiles*: DWORD + sv403_sessopens*: DWORD + sv403_sessvcs*: DWORD + sv403_sessreqs*: DWORD + sv403_opensearch*: DWORD + sv403_activelocks*: DWORD + sv403_numreqbuf*: DWORD + sv403_sizreqbuf*: DWORD + sv403_numbigbuf*: DWORD + sv403_numfiletasks*: DWORD + sv403_alertsched*: DWORD + sv403_erroralert*: DWORD + sv403_logonalert*: DWORD + sv403_accessalert*: DWORD + sv403_diskalert*: DWORD + sv403_netioalert*: DWORD + sv403_maxauditsz*: DWORD + sv403_srvheuristics*: LMSTR + sv403_auditedevents*: DWORD + sv403_autoprofile*: DWORD + sv403_autopath*: LMSTR + PSERVER_INFO_403* = ptr SERVER_INFO_403 + LPSERVER_INFO_403* = ptr SERVER_INFO_403 + SERVER_INFO_502* {.pure.} = object + sv502_sessopens*: DWORD + sv502_sessvcs*: DWORD + sv502_opensearch*: DWORD + sv502_sizreqbuf*: DWORD + sv502_initworkitems*: DWORD + sv502_maxworkitems*: DWORD + sv502_rawworkitems*: DWORD + sv502_irpstacksize*: DWORD + sv502_maxrawbuflen*: DWORD + sv502_sessusers*: DWORD + sv502_sessconns*: DWORD + sv502_maxpagedmemoryusage*: DWORD + sv502_maxnonpagedmemoryusage*: DWORD + sv502_enablesoftcompat*: WINBOOL + sv502_enableforcedlogoff*: WINBOOL + sv502_timesource*: WINBOOL + sv502_acceptdownlevelapis*: WINBOOL + sv502_lmannounce*: WINBOOL + PSERVER_INFO_502* = ptr SERVER_INFO_502 + LPSERVER_INFO_502* = ptr SERVER_INFO_502 + SERVER_INFO_503* {.pure.} = object + sv503_sessopens*: DWORD + sv503_sessvcs*: DWORD + sv503_opensearch*: DWORD + sv503_sizreqbuf*: DWORD + sv503_initworkitems*: DWORD + sv503_maxworkitems*: DWORD + sv503_rawworkitems*: DWORD + sv503_irpstacksize*: DWORD + sv503_maxrawbuflen*: DWORD + sv503_sessusers*: DWORD + sv503_sessconns*: DWORD + sv503_maxpagedmemoryusage*: DWORD + sv503_maxnonpagedmemoryusage*: DWORD + sv503_enablesoftcompat*: WINBOOL + sv503_enableforcedlogoff*: WINBOOL + sv503_timesource*: WINBOOL + sv503_acceptdownlevelapis*: WINBOOL + sv503_lmannounce*: WINBOOL + sv503_domain*: LMSTR + sv503_maxcopyreadlen*: DWORD + sv503_maxcopywritelen*: DWORD + sv503_minkeepsearch*: DWORD + sv503_maxkeepsearch*: DWORD + sv503_minkeepcomplsearch*: DWORD + sv503_maxkeepcomplsearch*: DWORD + sv503_threadcountadd*: DWORD + sv503_numblockthreads*: DWORD + sv503_scavtimeout*: DWORD + sv503_minrcvqueue*: DWORD + sv503_minfreeworkitems*: DWORD + sv503_xactmemsize*: DWORD + sv503_threadpriority*: DWORD + sv503_maxmpxct*: DWORD + sv503_oplockbreakwait*: DWORD + sv503_oplockbreakresponsewait*: DWORD + sv503_enableoplocks*: WINBOOL + sv503_enableoplockforceclose*: WINBOOL + sv503_enablefcbopens*: WINBOOL + sv503_enableraw*: WINBOOL + sv503_enablesharednetdrives*: WINBOOL + sv503_minfreeconnections*: DWORD + sv503_maxfreeconnections*: DWORD + PSERVER_INFO_503* = ptr SERVER_INFO_503 + LPSERVER_INFO_503* = ptr SERVER_INFO_503 + SERVER_INFO_599* {.pure.} = object + sv599_sessopens*: DWORD + sv599_sessvcs*: DWORD + sv599_opensearch*: DWORD + sv599_sizreqbuf*: DWORD + sv599_initworkitems*: DWORD + sv599_maxworkitems*: DWORD + sv599_rawworkitems*: DWORD + sv599_irpstacksize*: DWORD + sv599_maxrawbuflen*: DWORD + sv599_sessusers*: DWORD + sv599_sessconns*: DWORD + sv599_maxpagedmemoryusage*: DWORD + sv599_maxnonpagedmemoryusage*: DWORD + sv599_enablesoftcompat*: WINBOOL + sv599_enableforcedlogoff*: WINBOOL + sv599_timesource*: WINBOOL + sv599_acceptdownlevelapis*: WINBOOL + sv599_lmannounce*: WINBOOL + sv599_domain*: LMSTR + sv599_maxcopyreadlen*: DWORD + sv599_maxcopywritelen*: DWORD + sv599_minkeepsearch*: DWORD + sv599_maxkeepsearch*: DWORD + sv599_minkeepcomplsearch*: DWORD + sv599_maxkeepcomplsearch*: DWORD + sv599_threadcountadd*: DWORD + sv599_numblockthreads*: DWORD + sv599_scavtimeout*: DWORD + sv599_minrcvqueue*: DWORD + sv599_minfreeworkitems*: DWORD + sv599_xactmemsize*: DWORD + sv599_threadpriority*: DWORD + sv599_maxmpxct*: DWORD + sv599_oplockbreakwait*: DWORD + sv599_oplockbreakresponsewait*: DWORD + sv599_enableoplocks*: WINBOOL + sv599_enableoplockforceclose*: WINBOOL + sv599_enablefcbopens*: WINBOOL + sv599_enableraw*: WINBOOL + sv599_enablesharednetdrives*: WINBOOL + sv599_minfreeconnections*: DWORD + sv599_maxfreeconnections*: DWORD + sv599_initsesstable*: DWORD + sv599_initconntable*: DWORD + sv599_initfiletable*: DWORD + sv599_initsearchtable*: DWORD + sv599_alertschedule*: DWORD + sv599_errorthreshold*: DWORD + sv599_networkerrorthreshold*: DWORD + sv599_diskspacethreshold*: DWORD + sv599_reserved*: DWORD + sv599_maxlinkdelay*: DWORD + sv599_minlinkthroughput*: DWORD + sv599_linkinfovalidtime*: DWORD + sv599_scavqosinfoupdatetime*: DWORD + sv599_maxworkitemidletime*: DWORD + PSERVER_INFO_599* = ptr SERVER_INFO_599 + LPSERVER_INFO_599* = ptr SERVER_INFO_599 + SERVER_INFO_598* {.pure.} = object + sv598_maxrawworkitems*: DWORD + sv598_maxthreadsperqueue*: DWORD + sv598_producttype*: DWORD + sv598_serversize*: DWORD + sv598_connectionlessautodisc*: DWORD + sv598_sharingviolationretries*: DWORD + sv598_sharingviolationdelay*: DWORD + sv598_maxglobalopensearch*: DWORD + sv598_removeduplicatesearches*: DWORD + sv598_lockviolationoffset*: DWORD + sv598_lockviolationdelay*: DWORD + sv598_mdlreadswitchover*: DWORD + sv598_cachedopenlimit*: DWORD + sv598_otherqueueaffinity*: DWORD + sv598_restrictnullsessaccess*: WINBOOL + sv598_enablewfw311directipx*: WINBOOL + sv598_queuesamplesecs*: DWORD + sv598_balancecount*: DWORD + sv598_preferredaffinity*: DWORD + sv598_maxfreerfcbs*: DWORD + sv598_maxfreemfcbs*: DWORD + sv598_maxfreelfcbs*: DWORD + sv598_maxfreepagedpoolchunks*: DWORD + sv598_minpagedpoolchunksize*: DWORD + sv598_maxpagedpoolchunksize*: DWORD + sv598_sendsfrompreferredprocessor*: WINBOOL + sv598_cacheddirectorylimit*: DWORD + sv598_maxcopylength*: DWORD + sv598_enablecompression*: WINBOOL + sv598_autosharewks*: WINBOOL + sv598_autoshareserver*: WINBOOL + sv598_enablesecuritysignature*: WINBOOL + sv598_requiresecuritysignature*: WINBOOL + sv598_minclientbuffersize*: DWORD + sv598_serverguid*: GUID + sv598_ConnectionNoSessionsTimeout*: DWORD + sv598_IdleThreadTimeOut*: DWORD + sv598_enableW9xsecuritysignature*: WINBOOL + sv598_enforcekerberosreauthentication*: WINBOOL + sv598_disabledos*: WINBOOL + sv598_lowdiskspaceminimum*: DWORD + sv598_disablestrictnamechecking*: WINBOOL + PSERVER_INFO_598* = ptr SERVER_INFO_598 + LPSERVER_INFO_598* = ptr SERVER_INFO_598 + SERVER_INFO_1005* {.pure.} = object + sv1005_comment*: LMSTR + PSERVER_INFO_1005* = ptr SERVER_INFO_1005 + LPSERVER_INFO_1005* = ptr SERVER_INFO_1005 + SERVER_INFO_1107* {.pure.} = object + sv1107_users*: DWORD + PSERVER_INFO_1107* = ptr SERVER_INFO_1107 + LPSERVER_INFO_1107* = ptr SERVER_INFO_1107 + SERVER_INFO_1010* {.pure.} = object + sv1010_disc*: LONG + PSERVER_INFO_1010* = ptr SERVER_INFO_1010 + LPSERVER_INFO_1010* = ptr SERVER_INFO_1010 + SERVER_INFO_1016* {.pure.} = object + sv1016_hidden*: WINBOOL + PSERVER_INFO_1016* = ptr SERVER_INFO_1016 + LPSERVER_INFO_1016* = ptr SERVER_INFO_1016 + SERVER_INFO_1017* {.pure.} = object + sv1017_announce*: DWORD + PSERVER_INFO_1017* = ptr SERVER_INFO_1017 + LPSERVER_INFO_1017* = ptr SERVER_INFO_1017 + SERVER_INFO_1018* {.pure.} = object + sv1018_anndelta*: DWORD + PSERVER_INFO_1018* = ptr SERVER_INFO_1018 + LPSERVER_INFO_1018* = ptr SERVER_INFO_1018 + SERVER_INFO_1501* {.pure.} = object + sv1501_sessopens*: DWORD + PSERVER_INFO_1501* = ptr SERVER_INFO_1501 + LPSERVER_INFO_1501* = ptr SERVER_INFO_1501 + SERVER_INFO_1502* {.pure.} = object + sv1502_sessvcs*: DWORD + PSERVER_INFO_1502* = ptr SERVER_INFO_1502 + LPSERVER_INFO_1502* = ptr SERVER_INFO_1502 + SERVER_INFO_1503* {.pure.} = object + sv1503_opensearch*: DWORD + PSERVER_INFO_1503* = ptr SERVER_INFO_1503 + LPSERVER_INFO_1503* = ptr SERVER_INFO_1503 + SERVER_INFO_1506* {.pure.} = object + sv1506_maxworkitems*: DWORD + PSERVER_INFO_1506* = ptr SERVER_INFO_1506 + LPSERVER_INFO_1506* = ptr SERVER_INFO_1506 + SERVER_INFO_1509* {.pure.} = object + sv1509_maxrawbuflen*: DWORD + PSERVER_INFO_1509* = ptr SERVER_INFO_1509 + LPSERVER_INFO_1509* = ptr SERVER_INFO_1509 + SERVER_INFO_1510* {.pure.} = object + sv1510_sessusers*: DWORD + PSERVER_INFO_1510* = ptr SERVER_INFO_1510 + LPSERVER_INFO_1510* = ptr SERVER_INFO_1510 + SERVER_INFO_1511* {.pure.} = object + sv1511_sessconns*: DWORD + PSERVER_INFO_1511* = ptr SERVER_INFO_1511 + LPSERVER_INFO_1511* = ptr SERVER_INFO_1511 + SERVER_INFO_1512* {.pure.} = object + sv1512_maxnonpagedmemoryusage*: DWORD + PSERVER_INFO_1512* = ptr SERVER_INFO_1512 + LPSERVER_INFO_1512* = ptr SERVER_INFO_1512 + SERVER_INFO_1513* {.pure.} = object + sv1513_maxpagedmemoryusage*: DWORD + PSERVER_INFO_1513* = ptr SERVER_INFO_1513 + LPSERVER_INFO_1513* = ptr SERVER_INFO_1513 + SERVER_INFO_1514* {.pure.} = object + sv1514_enablesoftcompat*: WINBOOL + PSERVER_INFO_1514* = ptr SERVER_INFO_1514 + LPSERVER_INFO_1514* = ptr SERVER_INFO_1514 + SERVER_INFO_1515* {.pure.} = object + sv1515_enableforcedlogoff*: WINBOOL + PSERVER_INFO_1515* = ptr SERVER_INFO_1515 + LPSERVER_INFO_1515* = ptr SERVER_INFO_1515 + SERVER_INFO_1516* {.pure.} = object + sv1516_timesource*: WINBOOL + PSERVER_INFO_1516* = ptr SERVER_INFO_1516 + LPSERVER_INFO_1516* = ptr SERVER_INFO_1516 + SERVER_INFO_1518* {.pure.} = object + sv1518_lmannounce*: WINBOOL + PSERVER_INFO_1518* = ptr SERVER_INFO_1518 + LPSERVER_INFO_1518* = ptr SERVER_INFO_1518 + SERVER_INFO_1520* {.pure.} = object + sv1520_maxcopyreadlen*: DWORD + PSERVER_INFO_1520* = ptr SERVER_INFO_1520 + LPSERVER_INFO_1520* = ptr SERVER_INFO_1520 + SERVER_INFO_1521* {.pure.} = object + sv1521_maxcopywritelen*: DWORD + PSERVER_INFO_1521* = ptr SERVER_INFO_1521 + LPSERVER_INFO_1521* = ptr SERVER_INFO_1521 + SERVER_INFO_1522* {.pure.} = object + sv1522_minkeepsearch*: DWORD + PSERVER_INFO_1522* = ptr SERVER_INFO_1522 + LPSERVER_INFO_1522* = ptr SERVER_INFO_1522 + SERVER_INFO_1523* {.pure.} = object + sv1523_maxkeepsearch*: DWORD + PSERVER_INFO_1523* = ptr SERVER_INFO_1523 + LPSERVER_INFO_1523* = ptr SERVER_INFO_1523 + SERVER_INFO_1524* {.pure.} = object + sv1524_minkeepcomplsearch*: DWORD + PSERVER_INFO_1524* = ptr SERVER_INFO_1524 + LPSERVER_INFO_1524* = ptr SERVER_INFO_1524 + SERVER_INFO_1525* {.pure.} = object + sv1525_maxkeepcomplsearch*: DWORD + PSERVER_INFO_1525* = ptr SERVER_INFO_1525 + LPSERVER_INFO_1525* = ptr SERVER_INFO_1525 + SERVER_INFO_1528* {.pure.} = object + sv1528_scavtimeout*: DWORD + PSERVER_INFO_1528* = ptr SERVER_INFO_1528 + LPSERVER_INFO_1528* = ptr SERVER_INFO_1528 + SERVER_INFO_1529* {.pure.} = object + sv1529_minrcvqueue*: DWORD + PSERVER_INFO_1529* = ptr SERVER_INFO_1529 + LPSERVER_INFO_1529* = ptr SERVER_INFO_1529 + SERVER_INFO_1530* {.pure.} = object + sv1530_minfreeworkitems*: DWORD + PSERVER_INFO_1530* = ptr SERVER_INFO_1530 + LPSERVER_INFO_1530* = ptr SERVER_INFO_1530 + SERVER_INFO_1533* {.pure.} = object + sv1533_maxmpxct*: DWORD + PSERVER_INFO_1533* = ptr SERVER_INFO_1533 + LPSERVER_INFO_1533* = ptr SERVER_INFO_1533 + SERVER_INFO_1534* {.pure.} = object + sv1534_oplockbreakwait*: DWORD + PSERVER_INFO_1534* = ptr SERVER_INFO_1534 + LPSERVER_INFO_1534* = ptr SERVER_INFO_1534 + SERVER_INFO_1535* {.pure.} = object + sv1535_oplockbreakresponsewait*: DWORD + PSERVER_INFO_1535* = ptr SERVER_INFO_1535 + LPSERVER_INFO_1535* = ptr SERVER_INFO_1535 + SERVER_INFO_1536* {.pure.} = object + sv1536_enableoplocks*: WINBOOL + PSERVER_INFO_1536* = ptr SERVER_INFO_1536 + LPSERVER_INFO_1536* = ptr SERVER_INFO_1536 + SERVER_INFO_1537* {.pure.} = object + sv1537_enableoplockforceclose*: WINBOOL + PSERVER_INFO_1537* = ptr SERVER_INFO_1537 + LPSERVER_INFO_1537* = ptr SERVER_INFO_1537 + SERVER_INFO_1538* {.pure.} = object + sv1538_enablefcbopens*: WINBOOL + PSERVER_INFO_1538* = ptr SERVER_INFO_1538 + LPSERVER_INFO_1538* = ptr SERVER_INFO_1538 + SERVER_INFO_1539* {.pure.} = object + sv1539_enableraw*: WINBOOL + PSERVER_INFO_1539* = ptr SERVER_INFO_1539 + LPSERVER_INFO_1539* = ptr SERVER_INFO_1539 + SERVER_INFO_1540* {.pure.} = object + sv1540_enablesharednetdrives*: WINBOOL + PSERVER_INFO_1540* = ptr SERVER_INFO_1540 + LPSERVER_INFO_1540* = ptr SERVER_INFO_1540 + SERVER_INFO_1541* {.pure.} = object + sv1541_minfreeconnections*: WINBOOL + PSERVER_INFO_1541* = ptr SERVER_INFO_1541 + LPSERVER_INFO_1541* = ptr SERVER_INFO_1541 + SERVER_INFO_1542* {.pure.} = object + sv1542_maxfreeconnections*: WINBOOL + PSERVER_INFO_1542* = ptr SERVER_INFO_1542 + LPSERVER_INFO_1542* = ptr SERVER_INFO_1542 + SERVER_INFO_1543* {.pure.} = object + sv1543_initsesstable*: DWORD + PSERVER_INFO_1543* = ptr SERVER_INFO_1543 + LPSERVER_INFO_1543* = ptr SERVER_INFO_1543 + SERVER_INFO_1544* {.pure.} = object + sv1544_initconntable*: DWORD + PSERVER_INFO_1544* = ptr SERVER_INFO_1544 + LPSERVER_INFO_1544* = ptr SERVER_INFO_1544 + SERVER_INFO_1545* {.pure.} = object + sv1545_initfiletable*: DWORD + PSERVER_INFO_1545* = ptr SERVER_INFO_1545 + LPSERVER_INFO_1545* = ptr SERVER_INFO_1545 + SERVER_INFO_1546* {.pure.} = object + sv1546_initsearchtable*: DWORD + PSERVER_INFO_1546* = ptr SERVER_INFO_1546 + LPSERVER_INFO_1546* = ptr SERVER_INFO_1546 + SERVER_INFO_1547* {.pure.} = object + sv1547_alertschedule*: DWORD + PSERVER_INFO_1547* = ptr SERVER_INFO_1547 + LPSERVER_INFO_1547* = ptr SERVER_INFO_1547 + SERVER_INFO_1548* {.pure.} = object + sv1548_errorthreshold*: DWORD + PSERVER_INFO_1548* = ptr SERVER_INFO_1548 + LPSERVER_INFO_1548* = ptr SERVER_INFO_1548 + SERVER_INFO_1549* {.pure.} = object + sv1549_networkerrorthreshold*: DWORD + PSERVER_INFO_1549* = ptr SERVER_INFO_1549 + LPSERVER_INFO_1549* = ptr SERVER_INFO_1549 + SERVER_INFO_1550* {.pure.} = object + sv1550_diskspacethreshold*: DWORD + PSERVER_INFO_1550* = ptr SERVER_INFO_1550 + LPSERVER_INFO_1550* = ptr SERVER_INFO_1550 + SERVER_INFO_1552* {.pure.} = object + sv1552_maxlinkdelay*: DWORD + PSERVER_INFO_1552* = ptr SERVER_INFO_1552 + LPSERVER_INFO_1552* = ptr SERVER_INFO_1552 + SERVER_INFO_1553* {.pure.} = object + sv1553_minlinkthroughput*: DWORD + PSERVER_INFO_1553* = ptr SERVER_INFO_1553 + LPSERVER_INFO_1553* = ptr SERVER_INFO_1553 + SERVER_INFO_1554* {.pure.} = object + sv1554_linkinfovalidtime*: DWORD + PSERVER_INFO_1554* = ptr SERVER_INFO_1554 + LPSERVER_INFO_1554* = ptr SERVER_INFO_1554 + SERVER_INFO_1555* {.pure.} = object + sv1555_scavqosinfoupdatetime*: DWORD + PSERVER_INFO_1555* = ptr SERVER_INFO_1555 + LPSERVER_INFO_1555* = ptr SERVER_INFO_1555 + SERVER_INFO_1556* {.pure.} = object + sv1556_maxworkitemidletime*: DWORD + PSERVER_INFO_1556* = ptr SERVER_INFO_1556 + LPSERVER_INFO_1556* = ptr SERVER_INFO_1556 + SERVER_INFO_1557* {.pure.} = object + sv1557_maxrawworkitems*: DWORD + PSERVER_INFO_1557* = ptr SERVER_INFO_1557 + LPSERVER_INFO_1557* = ptr SERVER_INFO_1557 + SERVER_INFO_1560* {.pure.} = object + sv1560_producttype*: DWORD + PSERVER_INFO_1560* = ptr SERVER_INFO_1560 + LPSERVER_INFO_1560* = ptr SERVER_INFO_1560 + SERVER_INFO_1561* {.pure.} = object + sv1561_serversize*: DWORD + PSERVER_INFO_1561* = ptr SERVER_INFO_1561 + LPSERVER_INFO_1561* = ptr SERVER_INFO_1561 + SERVER_INFO_1562* {.pure.} = object + sv1562_connectionlessautodisc*: DWORD + PSERVER_INFO_1562* = ptr SERVER_INFO_1562 + LPSERVER_INFO_1562* = ptr SERVER_INFO_1562 + SERVER_INFO_1563* {.pure.} = object + sv1563_sharingviolationretries*: DWORD + PSERVER_INFO_1563* = ptr SERVER_INFO_1563 + LPSERVER_INFO_1563* = ptr SERVER_INFO_1563 + SERVER_INFO_1564* {.pure.} = object + sv1564_sharingviolationdelay*: DWORD + PSERVER_INFO_1564* = ptr SERVER_INFO_1564 + LPSERVER_INFO_1564* = ptr SERVER_INFO_1564 + SERVER_INFO_1565* {.pure.} = object + sv1565_maxglobalopensearch*: DWORD + PSERVER_INFO_1565* = ptr SERVER_INFO_1565 + LPSERVER_INFO_1565* = ptr SERVER_INFO_1565 + SERVER_INFO_1566* {.pure.} = object + sv1566_removeduplicatesearches*: WINBOOL + PSERVER_INFO_1566* = ptr SERVER_INFO_1566 + LPSERVER_INFO_1566* = ptr SERVER_INFO_1566 + SERVER_INFO_1567* {.pure.} = object + sv1567_lockviolationretries*: DWORD + PSERVER_INFO_1567* = ptr SERVER_INFO_1567 + LPSERVER_INFO_1567* = ptr SERVER_INFO_1567 + SERVER_INFO_1568* {.pure.} = object + sv1568_lockviolationoffset*: DWORD + PSERVER_INFO_1568* = ptr SERVER_INFO_1568 + LPSERVER_INFO_1568* = ptr SERVER_INFO_1568 + SERVER_INFO_1569* {.pure.} = object + sv1569_lockviolationdelay*: DWORD + PSERVER_INFO_1569* = ptr SERVER_INFO_1569 + LPSERVER_INFO_1569* = ptr SERVER_INFO_1569 + SERVER_INFO_1570* {.pure.} = object + sv1570_mdlreadswitchover*: DWORD + PSERVER_INFO_1570* = ptr SERVER_INFO_1570 + LPSERVER_INFO_1570* = ptr SERVER_INFO_1570 + SERVER_INFO_1571* {.pure.} = object + sv1571_cachedopenlimit*: DWORD + PSERVER_INFO_1571* = ptr SERVER_INFO_1571 + LPSERVER_INFO_1571* = ptr SERVER_INFO_1571 + SERVER_INFO_1572* {.pure.} = object + sv1572_criticalthreads*: DWORD + PSERVER_INFO_1572* = ptr SERVER_INFO_1572 + LPSERVER_INFO_1572* = ptr SERVER_INFO_1572 + SERVER_INFO_1573* {.pure.} = object + sv1573_restrictnullsessaccess*: DWORD + PSERVER_INFO_1573* = ptr SERVER_INFO_1573 + LPSERVER_INFO_1573* = ptr SERVER_INFO_1573 + SERVER_INFO_1574* {.pure.} = object + sv1574_enablewfw311directipx*: DWORD + PSERVER_INFO_1574* = ptr SERVER_INFO_1574 + LPSERVER_INFO_1574* = ptr SERVER_INFO_1574 + SERVER_INFO_1575* {.pure.} = object + sv1575_otherqueueaffinity*: DWORD + PSERVER_INFO_1575* = ptr SERVER_INFO_1575 + LPSERVER_INFO_1575* = ptr SERVER_INFO_1575 + SERVER_INFO_1576* {.pure.} = object + sv1576_queuesamplesecs*: DWORD + PSERVER_INFO_1576* = ptr SERVER_INFO_1576 + LPSERVER_INFO_1576* = ptr SERVER_INFO_1576 + SERVER_INFO_1577* {.pure.} = object + sv1577_balancecount*: DWORD + PSERVER_INFO_1577* = ptr SERVER_INFO_1577 + LPSERVER_INFO_1577* = ptr SERVER_INFO_1577 + SERVER_INFO_1578* {.pure.} = object + sv1578_preferredaffinity*: DWORD + PSERVER_INFO_1578* = ptr SERVER_INFO_1578 + LPSERVER_INFO_1578* = ptr SERVER_INFO_1578 + SERVER_INFO_1579* {.pure.} = object + sv1579_maxfreerfcbs*: DWORD + PSERVER_INFO_1579* = ptr SERVER_INFO_1579 + LPSERVER_INFO_1579* = ptr SERVER_INFO_1579 + SERVER_INFO_1580* {.pure.} = object + sv1580_maxfreemfcbs*: DWORD + PSERVER_INFO_1580* = ptr SERVER_INFO_1580 + LPSERVER_INFO_1580* = ptr SERVER_INFO_1580 + SERVER_INFO_1581* {.pure.} = object + sv1581_maxfreemlcbs*: DWORD + PSERVER_INFO_1581* = ptr SERVER_INFO_1581 + LPSERVER_INFO_1581* = ptr SERVER_INFO_1581 + SERVER_INFO_1582* {.pure.} = object + sv1582_maxfreepagedpoolchunks*: DWORD + PSERVER_INFO_1582* = ptr SERVER_INFO_1582 + LPSERVER_INFO_1582* = ptr SERVER_INFO_1582 + SERVER_INFO_1583* {.pure.} = object + sv1583_minpagedpoolchunksize*: DWORD + PSERVER_INFO_1583* = ptr SERVER_INFO_1583 + LPSERVER_INFO_1583* = ptr SERVER_INFO_1583 + SERVER_INFO_1584* {.pure.} = object + sv1584_maxpagedpoolchunksize*: DWORD + PSERVER_INFO_1584* = ptr SERVER_INFO_1584 + LPSERVER_INFO_1584* = ptr SERVER_INFO_1584 + SERVER_INFO_1585* {.pure.} = object + sv1585_sendsfrompreferredprocessor*: WINBOOL + PSERVER_INFO_1585* = ptr SERVER_INFO_1585 + LPSERVER_INFO_1585* = ptr SERVER_INFO_1585 + SERVER_INFO_1586* {.pure.} = object + sv1586_maxthreadsperqueue*: DWORD + PSERVER_INFO_1586* = ptr SERVER_INFO_1586 + LPSERVER_INFO_1586* = ptr SERVER_INFO_1586 + SERVER_INFO_1587* {.pure.} = object + sv1587_cacheddirectorylimit*: DWORD + PSERVER_INFO_1587* = ptr SERVER_INFO_1587 + LPSERVER_INFO_1587* = ptr SERVER_INFO_1587 + SERVER_INFO_1588* {.pure.} = object + sv1588_maxcopylength*: DWORD + PSERVER_INFO_1588* = ptr SERVER_INFO_1588 + LPSERVER_INFO_1588* = ptr SERVER_INFO_1588 + SERVER_INFO_1590* {.pure.} = object + sv1590_enablecompression*: DWORD + PSERVER_INFO_1590* = ptr SERVER_INFO_1590 + LPSERVER_INFO_1590* = ptr SERVER_INFO_1590 + SERVER_INFO_1591* {.pure.} = object + sv1591_autosharewks*: DWORD + PSERVER_INFO_1591* = ptr SERVER_INFO_1591 + LPSERVER_INFO_1591* = ptr SERVER_INFO_1591 + SERVER_INFO_1592* {.pure.} = object + sv1592_autosharewks*: DWORD + PSERVER_INFO_1592* = ptr SERVER_INFO_1592 + LPSERVER_INFO_1592* = ptr SERVER_INFO_1592 + SERVER_INFO_1593* {.pure.} = object + sv1593_enablesecuritysignature*: DWORD + PSERVER_INFO_1593* = ptr SERVER_INFO_1593 + LPSERVER_INFO_1593* = ptr SERVER_INFO_1593 + SERVER_INFO_1594* {.pure.} = object + sv1594_requiresecuritysignature*: DWORD + PSERVER_INFO_1594* = ptr SERVER_INFO_1594 + LPSERVER_INFO_1594* = ptr SERVER_INFO_1594 + SERVER_INFO_1595* {.pure.} = object + sv1595_minclientbuffersize*: DWORD + PSERVER_INFO_1595* = ptr SERVER_INFO_1595 + LPSERVER_INFO_1595* = ptr SERVER_INFO_1595 + SERVER_INFO_1596* {.pure.} = object + sv1596_ConnectionNoSessionsTimeout*: DWORD + PSERVER_INFO_1596* = ptr SERVER_INFO_1596 + LPSERVER_INFO_1596* = ptr SERVER_INFO_1596 + SERVER_INFO_1597* {.pure.} = object + sv1597_IdleThreadTimeOut*: DWORD + PSERVER_INFO_1597* = ptr SERVER_INFO_1597 + LPSERVER_INFO_1597* = ptr SERVER_INFO_1597 + SERVER_INFO_1598* {.pure.} = object + sv1598_enableW9xsecuritysignature*: DWORD + PSERVER_INFO_1598* = ptr SERVER_INFO_1598 + LPSERVER_INFO_1598* = ptr SERVER_INFO_1598 + SERVER_INFO_1599* {.pure.} = object + sv1598_enforcekerberosreauthentication*: BOOLEAN + PSERVER_INFO_1599* = ptr SERVER_INFO_1599 + LPSERVER_INFO_1599* = ptr SERVER_INFO_1599 + SERVER_INFO_1600* {.pure.} = object + sv1598_disabledos*: BOOLEAN + PSERVER_INFO_1600* = ptr SERVER_INFO_1600 + LPSERVER_INFO_1600* = ptr SERVER_INFO_1600 + SERVER_INFO_1601* {.pure.} = object + sv1598_lowdiskspaceminimum*: DWORD + PSERVER_INFO_1601* = ptr SERVER_INFO_1601 + LPSERVER_INFO_1601* = ptr SERVER_INFO_1601 + SERVER_INFO_1602* {.pure.} = object + sv_1598_disablestrictnamechecking*: WINBOOL + PSERVER_INFO_1602* = ptr SERVER_INFO_1602 + LPSERVER_INFO_1602* = ptr SERVER_INFO_1602 + SERVER_TRANSPORT_INFO_0* {.pure.} = object + svti0_numberofvcs*: DWORD + svti0_transportname*: LMSTR + svti0_transportaddress*: LPBYTE + svti0_transportaddresslength*: DWORD + svti0_networkaddress*: LMSTR + PSERVER_TRANSPORT_INFO_0* = ptr SERVER_TRANSPORT_INFO_0 + LPSERVER_TRANSPORT_INFO_0* = ptr SERVER_TRANSPORT_INFO_0 + SERVER_TRANSPORT_INFO_1* {.pure.} = object + svti1_numberofvcs*: DWORD + svti1_transportname*: LMSTR + svti1_transportaddress*: LPBYTE + svti1_transportaddresslength*: DWORD + svti1_networkaddress*: LMSTR + svti1_domain*: LMSTR + PSERVER_TRANSPORT_INFO_1* = ptr SERVER_TRANSPORT_INFO_1 + LPSERVER_TRANSPORT_INFO_1* = ptr SERVER_TRANSPORT_INFO_1 + SERVER_TRANSPORT_INFO_2* {.pure.} = object + svti2_numberofvcs*: DWORD + svti2_transportname*: LMSTR + svti2_transportaddress*: LPBYTE + svti2_transportaddresslength*: DWORD + svti2_networkaddress*: LMSTR + svti2_domain*: LMSTR + svti2_flags*: ULONG + PSERVER_TRANSPORT_INFO_2* = ptr SERVER_TRANSPORT_INFO_2 + LPSERVER_TRANSPORT_INFO_2* = ptr SERVER_TRANSPORT_INFO_2 + SERVER_TRANSPORT_INFO_3* {.pure.} = object + svti3_numberofvcs*: DWORD + svti3_transportname*: LMSTR + svti3_transportaddress*: LPBYTE + svti3_transportaddresslength*: DWORD + svti3_networkaddress*: LMSTR + svti3_domain*: LMSTR + svti3_flags*: ULONG + svti3_passwordlength*: DWORD + svti3_password*: array[256 , BYTE] + PSERVER_TRANSPORT_INFO_3* = ptr SERVER_TRANSPORT_INFO_3 + LPSERVER_TRANSPORT_INFO_3* = ptr SERVER_TRANSPORT_INFO_3 + SERVICE_INFO_0* {.pure.} = object + svci0_name*: LPWSTR + PSERVICE_INFO_0* = ptr SERVICE_INFO_0 + LPSERVICE_INFO_0* = ptr SERVICE_INFO_0 + SERVICE_INFO_1* {.pure.} = object + svci1_name*: LPWSTR + svci1_status*: DWORD + svci1_code*: DWORD + svci1_pid*: DWORD + PSERVICE_INFO_1* = ptr SERVICE_INFO_1 + LPSERVICE_INFO_1* = ptr SERVICE_INFO_1 + SERVICE_INFO_2* {.pure.} = object + svci2_name*: LPWSTR + svci2_status*: DWORD + svci2_code*: DWORD + svci2_pid*: DWORD + svci2_text*: LPWSTR + svci2_specific_error*: DWORD + svci2_display_name*: LPWSTR + PSERVICE_INFO_2* = ptr SERVICE_INFO_2 + LPSERVICE_INFO_2* = ptr SERVICE_INFO_2 + USE_INFO_0* {.pure.} = object + ui0_local*: LMSTR + ui0_remote*: LMSTR + PUSE_INFO_0* = ptr USE_INFO_0 + LPUSE_INFO_0* = ptr USE_INFO_0 + USE_INFO_1* {.pure.} = object + ui1_local*: LMSTR + ui1_remote*: LMSTR + ui1_password*: LMSTR + ui1_status*: DWORD + ui1_asg_type*: DWORD + ui1_refcount*: DWORD + ui1_usecount*: DWORD + PUSE_INFO_1* = ptr USE_INFO_1 + LPUSE_INFO_1* = ptr USE_INFO_1 + USE_INFO_2* {.pure.} = object + ui2_local*: LMSTR + ui2_remote*: LMSTR + ui2_password*: LMSTR + ui2_status*: DWORD + ui2_asg_type*: DWORD + ui2_refcount*: DWORD + ui2_usecount*: DWORD + ui2_username*: LMSTR + ui2_domainname*: LMSTR + PUSE_INFO_2* = ptr USE_INFO_2 + LPUSE_INFO_2* = ptr USE_INFO_2 + USE_INFO_3* {.pure.} = object + ui3_ui2*: USE_INFO_2 + ui3_flags*: ULONG + PUSE_INFO_3* = ptr USE_INFO_3 + LPUSE_INFO_3* = ptr USE_INFO_3 + WKSTA_INFO_100* {.pure.} = object + wki100_platform_id*: DWORD + wki100_computername*: LMSTR + wki100_langroup*: LMSTR + wki100_ver_major*: DWORD + wki100_ver_minor*: DWORD + PWKSTA_INFO_100* = ptr WKSTA_INFO_100 + LPWKSTA_INFO_100* = ptr WKSTA_INFO_100 + WKSTA_INFO_101* {.pure.} = object + wki101_platform_id*: DWORD + wki101_computername*: LMSTR + wki101_langroup*: LMSTR + wki101_ver_major*: DWORD + wki101_ver_minor*: DWORD + wki101_lanroot*: LMSTR + PWKSTA_INFO_101* = ptr WKSTA_INFO_101 + LPWKSTA_INFO_101* = ptr WKSTA_INFO_101 + WKSTA_INFO_102* {.pure.} = object + wki102_platform_id*: DWORD + wki102_computername*: LMSTR + wki102_langroup*: LMSTR + wki102_ver_major*: DWORD + wki102_ver_minor*: DWORD + wki102_lanroot*: LMSTR + wki102_logged_on_users*: DWORD + PWKSTA_INFO_102* = ptr WKSTA_INFO_102 + LPWKSTA_INFO_102* = ptr WKSTA_INFO_102 + WKSTA_INFO_302* {.pure.} = object + wki302_char_wait*: DWORD + wki302_collection_time*: DWORD + wki302_maximum_collection_count*: DWORD + wki302_keep_conn*: DWORD + wki302_keep_search*: DWORD + wki302_max_cmds*: DWORD + wki302_num_work_buf*: DWORD + wki302_siz_work_buf*: DWORD + wki302_max_wrk_cache*: DWORD + wki302_sess_timeout*: DWORD + wki302_siz_error*: DWORD + wki302_num_alerts*: DWORD + wki302_num_services*: DWORD + wki302_errlog_sz*: DWORD + wki302_print_buf_time*: DWORD + wki302_num_char_buf*: DWORD + wki302_siz_char_buf*: DWORD + wki302_wrk_heuristics*: LMSTR + wki302_mailslots*: DWORD + wki302_num_dgram_buf*: DWORD + PWKSTA_INFO_302* = ptr WKSTA_INFO_302 + LPWKSTA_INFO_302* = ptr WKSTA_INFO_302 + WKSTA_INFO_402* {.pure.} = object + wki402_char_wait*: DWORD + wki402_collection_time*: DWORD + wki402_maximum_collection_count*: DWORD + wki402_keep_conn*: DWORD + wki402_keep_search*: DWORD + wki402_max_cmds*: DWORD + wki402_num_work_buf*: DWORD + wki402_siz_work_buf*: DWORD + wki402_max_wrk_cache*: DWORD + wki402_sess_timeout*: DWORD + wki402_siz_error*: DWORD + wki402_num_alerts*: DWORD + wki402_num_services*: DWORD + wki402_errlog_sz*: DWORD + wki402_print_buf_time*: DWORD + wki402_num_char_buf*: DWORD + wki402_siz_char_buf*: DWORD + wki402_wrk_heuristics*: LMSTR + wki402_mailslots*: DWORD + wki402_num_dgram_buf*: DWORD + wki402_max_threads*: DWORD + PWKSTA_INFO_402* = ptr WKSTA_INFO_402 + LPWKSTA_INFO_402* = ptr WKSTA_INFO_402 + WKSTA_INFO_502* {.pure.} = object + wki502_char_wait*: DWORD + wki502_collection_time*: DWORD + wki502_maximum_collection_count*: DWORD + wki502_keep_conn*: DWORD + wki502_max_cmds*: DWORD + wki502_sess_timeout*: DWORD + wki502_siz_char_buf*: DWORD + wki502_max_threads*: DWORD + wki502_lock_quota*: DWORD + wki502_lock_increment*: DWORD + wki502_lock_maximum*: DWORD + wki502_pipe_increment*: DWORD + wki502_pipe_maximum*: DWORD + wki502_cache_file_timeout*: DWORD + wki502_dormant_file_limit*: DWORD + wki502_read_ahead_throughput*: DWORD + wki502_num_mailslot_buffers*: DWORD + wki502_num_srv_announce_buffers*: DWORD + wki502_max_illegal_datagram_events*: DWORD + wki502_illegal_datagram_event_reset_frequency*: DWORD + wki502_log_election_packets*: WINBOOL + wki502_use_opportunistic_locking*: WINBOOL + wki502_use_unlock_behind*: WINBOOL + wki502_use_close_behind*: WINBOOL + wki502_buf_named_pipes*: WINBOOL + wki502_use_lock_read_unlock*: WINBOOL + wki502_utilize_nt_caching*: WINBOOL + wki502_use_raw_read*: WINBOOL + wki502_use_raw_write*: WINBOOL + wki502_use_write_raw_data*: WINBOOL + wki502_use_encryption*: WINBOOL + wki502_buf_files_deny_write*: WINBOOL + wki502_buf_read_only_files*: WINBOOL + wki502_force_core_create_mode*: WINBOOL + wki502_use_512_byte_max_transfer*: WINBOOL + PWKSTA_INFO_502* = ptr WKSTA_INFO_502 + LPWKSTA_INFO_502* = ptr WKSTA_INFO_502 + WKSTA_INFO_1010* {.pure.} = object + wki1010_char_wait*: DWORD + PWKSTA_INFO_1010* = ptr WKSTA_INFO_1010 + LPWKSTA_INFO_1010* = ptr WKSTA_INFO_1010 + WKSTA_INFO_1011* {.pure.} = object + wki1011_collection_time*: DWORD + PWKSTA_INFO_1011* = ptr WKSTA_INFO_1011 + LPWKSTA_INFO_1011* = ptr WKSTA_INFO_1011 + WKSTA_INFO_1012* {.pure.} = object + wki1012_maximum_collection_count*: DWORD + PWKSTA_INFO_1012* = ptr WKSTA_INFO_1012 + LPWKSTA_INFO_1012* = ptr WKSTA_INFO_1012 + WKSTA_INFO_1027* {.pure.} = object + wki1027_errlog_sz*: DWORD + PWKSTA_INFO_1027* = ptr WKSTA_INFO_1027 + LPWKSTA_INFO_1027* = ptr WKSTA_INFO_1027 + WKSTA_INFO_1028* {.pure.} = object + wki1028_print_buf_time*: DWORD + PWKSTA_INFO_1028* = ptr WKSTA_INFO_1028 + LPWKSTA_INFO_1028* = ptr WKSTA_INFO_1028 + WKSTA_INFO_1032* {.pure.} = object + wki1032_wrk_heuristics*: DWORD + PWKSTA_INFO_1032* = ptr WKSTA_INFO_1032 + LPWKSTA_INFO_1032* = ptr WKSTA_INFO_1032 + WKSTA_INFO_1013* {.pure.} = object + wki1013_keep_conn*: DWORD + PWKSTA_INFO_1013* = ptr WKSTA_INFO_1013 + LPWKSTA_INFO_1013* = ptr WKSTA_INFO_1013 + WKSTA_INFO_1018* {.pure.} = object + wki1018_sess_timeout*: DWORD + PWKSTA_INFO_1018* = ptr WKSTA_INFO_1018 + LPWKSTA_INFO_1018* = ptr WKSTA_INFO_1018 + WKSTA_INFO_1023* {.pure.} = object + wki1023_siz_char_buf*: DWORD + PWKSTA_INFO_1023* = ptr WKSTA_INFO_1023 + LPWKSTA_INFO_1023* = ptr WKSTA_INFO_1023 + WKSTA_INFO_1033* {.pure.} = object + wki1033_max_threads*: DWORD + PWKSTA_INFO_1033* = ptr WKSTA_INFO_1033 + LPWKSTA_INFO_1033* = ptr WKSTA_INFO_1033 + WKSTA_INFO_1041* {.pure.} = object + wki1041_lock_quota*: DWORD + PWKSTA_INFO_1041* = ptr WKSTA_INFO_1041 + LPWKSTA_INFO_1041* = ptr WKSTA_INFO_1041 + WKSTA_INFO_1042* {.pure.} = object + wki1042_lock_increment*: DWORD + PWKSTA_INFO_1042* = ptr WKSTA_INFO_1042 + LPWKSTA_INFO_1042* = ptr WKSTA_INFO_1042 + WKSTA_INFO_1043* {.pure.} = object + wki1043_lock_maximum*: DWORD + PWKSTA_INFO_1043* = ptr WKSTA_INFO_1043 + LPWKSTA_INFO_1043* = ptr WKSTA_INFO_1043 + WKSTA_INFO_1044* {.pure.} = object + wki1044_pipe_increment*: DWORD + PWKSTA_INFO_1044* = ptr WKSTA_INFO_1044 + LPWKSTA_INFO_1044* = ptr WKSTA_INFO_1044 + WKSTA_INFO_1045* {.pure.} = object + wki1045_pipe_maximum*: DWORD + PWKSTA_INFO_1045* = ptr WKSTA_INFO_1045 + LPWKSTA_INFO_1045* = ptr WKSTA_INFO_1045 + WKSTA_INFO_1046* {.pure.} = object + wki1046_dormant_file_limit*: DWORD + PWKSTA_INFO_1046* = ptr WKSTA_INFO_1046 + LPWKSTA_INFO_1046* = ptr WKSTA_INFO_1046 + WKSTA_INFO_1047* {.pure.} = object + wki1047_cache_file_timeout*: DWORD + PWKSTA_INFO_1047* = ptr WKSTA_INFO_1047 + LPWKSTA_INFO_1047* = ptr WKSTA_INFO_1047 + WKSTA_INFO_1048* {.pure.} = object + wki1048_use_opportunistic_locking*: WINBOOL + PWKSTA_INFO_1048* = ptr WKSTA_INFO_1048 + LPWKSTA_INFO_1048* = ptr WKSTA_INFO_1048 + WKSTA_INFO_1049* {.pure.} = object + wki1049_use_unlock_behind*: WINBOOL + PWKSTA_INFO_1049* = ptr WKSTA_INFO_1049 + LPWKSTA_INFO_1049* = ptr WKSTA_INFO_1049 + WKSTA_INFO_1050* {.pure.} = object + wki1050_use_close_behind*: WINBOOL + PWKSTA_INFO_1050* = ptr WKSTA_INFO_1050 + LPWKSTA_INFO_1050* = ptr WKSTA_INFO_1050 + WKSTA_INFO_1051* {.pure.} = object + wki1051_buf_named_pipes*: WINBOOL + PWKSTA_INFO_1051* = ptr WKSTA_INFO_1051 + LPWKSTA_INFO_1051* = ptr WKSTA_INFO_1051 + WKSTA_INFO_1052* {.pure.} = object + wki1052_use_lock_read_unlock*: WINBOOL + PWKSTA_INFO_1052* = ptr WKSTA_INFO_1052 + LPWKSTA_INFO_1052* = ptr WKSTA_INFO_1052 + WKSTA_INFO_1053* {.pure.} = object + wki1053_utilize_nt_caching*: WINBOOL + PWKSTA_INFO_1053* = ptr WKSTA_INFO_1053 + LPWKSTA_INFO_1053* = ptr WKSTA_INFO_1053 + WKSTA_INFO_1054* {.pure.} = object + wki1054_use_raw_read*: WINBOOL + PWKSTA_INFO_1054* = ptr WKSTA_INFO_1054 + LPWKSTA_INFO_1054* = ptr WKSTA_INFO_1054 + WKSTA_INFO_1055* {.pure.} = object + wki1055_use_raw_write*: WINBOOL + PWKSTA_INFO_1055* = ptr WKSTA_INFO_1055 + LPWKSTA_INFO_1055* = ptr WKSTA_INFO_1055 + WKSTA_INFO_1056* {.pure.} = object + wki1056_use_write_raw_data*: WINBOOL + PWKSTA_INFO_1056* = ptr WKSTA_INFO_1056 + LPWKSTA_INFO_1056* = ptr WKSTA_INFO_1056 + WKSTA_INFO_1057* {.pure.} = object + wki1057_use_encryption*: WINBOOL + PWKSTA_INFO_1057* = ptr WKSTA_INFO_1057 + LPWKSTA_INFO_1057* = ptr WKSTA_INFO_1057 + WKSTA_INFO_1058* {.pure.} = object + wki1058_buf_files_deny_write*: WINBOOL + PWKSTA_INFO_1058* = ptr WKSTA_INFO_1058 + LPWKSTA_INFO_1058* = ptr WKSTA_INFO_1058 + WKSTA_INFO_1059* {.pure.} = object + wki1059_buf_read_only_files*: WINBOOL + PWKSTA_INFO_1059* = ptr WKSTA_INFO_1059 + LPWKSTA_INFO_1059* = ptr WKSTA_INFO_1059 + WKSTA_INFO_1060* {.pure.} = object + wki1060_force_core_create_mode*: WINBOOL + PWKSTA_INFO_1060* = ptr WKSTA_INFO_1060 + LPWKSTA_INFO_1060* = ptr WKSTA_INFO_1060 + WKSTA_INFO_1061* {.pure.} = object + wki1061_use_512_byte_max_transfer*: WINBOOL + PWKSTA_INFO_1061* = ptr WKSTA_INFO_1061 + LPWKSTA_INFO_1061* = ptr WKSTA_INFO_1061 + WKSTA_INFO_1062* {.pure.} = object + wki1062_read_ahead_throughput*: DWORD + PWKSTA_INFO_1062* = ptr WKSTA_INFO_1062 + LPWKSTA_INFO_1062* = ptr WKSTA_INFO_1062 + WKSTA_USER_INFO_0* {.pure.} = object + wkui0_username*: LMSTR + PWKSTA_USER_INFO_0* = ptr WKSTA_USER_INFO_0 + LPWKSTA_USER_INFO_0* = ptr WKSTA_USER_INFO_0 + WKSTA_USER_INFO_1* {.pure.} = object + wkui1_username*: LMSTR + wkui1_logon_domain*: LMSTR + wkui1_oth_domains*: LMSTR + wkui1_logon_server*: LMSTR + PWKSTA_USER_INFO_1* = ptr WKSTA_USER_INFO_1 + LPWKSTA_USER_INFO_1* = ptr WKSTA_USER_INFO_1 + WKSTA_USER_INFO_1101* {.pure.} = object + wkui1101_oth_domains*: LMSTR + PWKSTA_USER_INFO_1101* = ptr WKSTA_USER_INFO_1101 + LPWKSTA_USER_INFO_1101* = ptr WKSTA_USER_INFO_1101 + WKSTA_TRANSPORT_INFO_0* {.pure.} = object + wkti0_quality_of_service*: DWORD + wkti0_number_of_vcs*: DWORD + wkti0_transport_name*: LMSTR + wkti0_transport_address*: LMSTR + wkti0_wan_ish*: WINBOOL + PWKSTA_TRANSPORT_INFO_0* = ptr WKSTA_TRANSPORT_INFO_0 + LPWKSTA_TRANSPORT_INFO_0* = ptr WKSTA_TRANSPORT_INFO_0 + ERROR_LOG* {.pure.} = object + el_len*: DWORD + el_reserved*: DWORD + el_time*: DWORD + el_error*: DWORD + el_name*: LPWSTR + el_text*: LPWSTR + el_data*: LPBYTE + el_data_size*: DWORD + el_nstrings*: DWORD + PERROR_LOG* = ptr ERROR_LOG + HLOG* {.pure.} = object + time*: DWORD + last_flags*: DWORD + offset*: DWORD + rec_offset*: DWORD + PHLOG* = ptr HLOG + LPHLOG* = ptr HLOG + CONFIG_INFO_0* {.pure.} = object + cfgi0_key*: LPWSTR + cfgi0_data*: LPWSTR + PCONFIG_INFO_0* = ptr CONFIG_INFO_0 + LPCONFIG_INFO_0* = ptr CONFIG_INFO_0 + STAT_WORKSTATION_0* {.pure.} = object + StatisticsStartTime*: LARGE_INTEGER + BytesReceived*: LARGE_INTEGER + SmbsReceived*: LARGE_INTEGER + PagingReadBytesRequested*: LARGE_INTEGER + NonPagingReadBytesRequested*: LARGE_INTEGER + CacheReadBytesRequested*: LARGE_INTEGER + NetworkReadBytesRequested*: LARGE_INTEGER + BytesTransmitted*: LARGE_INTEGER + SmbsTransmitted*: LARGE_INTEGER + PagingWriteBytesRequested*: LARGE_INTEGER + NonPagingWriteBytesRequested*: LARGE_INTEGER + CacheWriteBytesRequested*: LARGE_INTEGER + NetworkWriteBytesRequested*: LARGE_INTEGER + InitiallyFailedOperations*: DWORD + FailedCompletionOperations*: DWORD + ReadOperations*: DWORD + RandomReadOperations*: DWORD + ReadSmbs*: DWORD + LargeReadSmbs*: DWORD + SmallReadSmbs*: DWORD + WriteOperations*: DWORD + RandomWriteOperations*: DWORD + WriteSmbs*: DWORD + LargeWriteSmbs*: DWORD + SmallWriteSmbs*: DWORD + RawReadsDenied*: DWORD + RawWritesDenied*: DWORD + NetworkErrors*: DWORD + Sessions*: DWORD + FailedSessions*: DWORD + Reconnects*: DWORD + CoreConnects*: DWORD + Lanman20Connects*: DWORD + Lanman21Connects*: DWORD + LanmanNtConnects*: DWORD + ServerDisconnects*: DWORD + HungSessions*: DWORD + UseCount*: DWORD + FailedUseCount*: DWORD + CurrentCommands*: DWORD + PSTAT_WORKSTATION_0* = ptr STAT_WORKSTATION_0 + LPSTAT_WORKSTATION_0* = ptr STAT_WORKSTATION_0 + STAT_SERVER_0* {.pure.} = object + sts0_start*: DWORD + sts0_fopens*: DWORD + sts0_devopens*: DWORD + sts0_jobsqueued*: DWORD + sts0_sopens*: DWORD + sts0_stimedout*: DWORD + sts0_serrorout*: DWORD + sts0_pwerrors*: DWORD + sts0_permerrors*: DWORD + sts0_syserrors*: DWORD + sts0_bytessent_low*: DWORD + sts0_bytessent_high*: DWORD + sts0_bytesrcvd_low*: DWORD + sts0_bytesrcvd_high*: DWORD + sts0_avresponse*: DWORD + sts0_reqbufneed*: DWORD + sts0_bigbufneed*: DWORD + PSTAT_SERVER_0* = ptr STAT_SERVER_0 + LPSTAT_SERVER_0* = ptr STAT_SERVER_0 + AUDIT_ENTRY* {.pure.} = object + ae_len*: DWORD + ae_reserved*: DWORD + ae_time*: DWORD + ae_type*: DWORD + ae_data_offset*: DWORD + ae_data_size*: DWORD + PAUDIT_ENTRY* = ptr AUDIT_ENTRY + LPAUDIT_ENTRY* = ptr AUDIT_ENTRY + TAE_SRVSTATUS* {.pure.} = object + ae_sv_status*: DWORD + PAE_SRVSTATUS* = ptr TAE_SRVSTATUS + LPAE_SRVSTATUS* = ptr TAE_SRVSTATUS + TAE_SESSLOGON* {.pure.} = object + ae_so_compname*: DWORD + ae_so_username*: DWORD + ae_so_privilege*: DWORD + PAE_SESSLOGON* = ptr TAE_SESSLOGON + LPAE_SESSLOGON* = ptr TAE_SESSLOGON + TAE_SESSLOGOFF* {.pure.} = object + ae_sf_compname*: DWORD + ae_sf_username*: DWORD + ae_sf_reason*: DWORD + PAE_SESSLOGOFF* = ptr TAE_SESSLOGOFF + LPAE_SESSLOGOFF* = ptr TAE_SESSLOGOFF + TAE_SESSPWERR* {.pure.} = object + ae_sp_compname*: DWORD + ae_sp_username*: DWORD + PAE_SESSPWERR* = ptr TAE_SESSPWERR + LPAE_SESSPWERR* = ptr TAE_SESSPWERR + TAE_CONNSTART* {.pure.} = object + ae_ct_compname*: DWORD + ae_ct_username*: DWORD + ae_ct_netname*: DWORD + ae_ct_connid*: DWORD + PAE_CONNSTART* = ptr TAE_CONNSTART + LPAE_CONNSTART* = ptr TAE_CONNSTART + TAE_CONNSTOP* {.pure.} = object + ae_cp_compname*: DWORD + ae_cp_username*: DWORD + ae_cp_netname*: DWORD + ae_cp_connid*: DWORD + ae_cp_reason*: DWORD + PAE_CONNSTOP* = ptr TAE_CONNSTOP + LPAE_CONNSTOP* = ptr TAE_CONNSTOP + TAE_CONNREJ* {.pure.} = object + ae_cr_compname*: DWORD + ae_cr_username*: DWORD + ae_cr_netname*: DWORD + ae_cr_reason*: DWORD + PAE_CONNREJ* = ptr TAE_CONNREJ + LPAE_CONNREJ* = ptr TAE_CONNREJ + TAE_RESACCESS* {.pure.} = object + ae_ra_compname*: DWORD + ae_ra_username*: DWORD + ae_ra_resname*: DWORD + ae_ra_operation*: DWORD + ae_ra_returncode*: DWORD + ae_ra_restype*: DWORD + ae_ra_fileid*: DWORD + PAE_RESACCESS* = ptr TAE_RESACCESS + LPAE_RESACCESS* = ptr TAE_RESACCESS + TAE_RESACCESSREJ* {.pure.} = object + ae_rr_compname*: DWORD + ae_rr_username*: DWORD + ae_rr_resname*: DWORD + ae_rr_operation*: DWORD + PAE_RESACCESSREJ* = ptr TAE_RESACCESSREJ + LPAE_RESACCESSREJ* = ptr TAE_RESACCESSREJ + TAE_CLOSEFILE* {.pure.} = object + ae_cf_compname*: DWORD + ae_cf_username*: DWORD + ae_cf_resname*: DWORD + ae_cf_fileid*: DWORD + ae_cf_duration*: DWORD + ae_cf_reason*: DWORD + PAE_CLOSEFILE* = ptr TAE_CLOSEFILE + LPAE_CLOSEFILE* = ptr TAE_CLOSEFILE + TAE_SERVICESTAT* {.pure.} = object + ae_ss_compname*: DWORD + ae_ss_username*: DWORD + ae_ss_svcname*: DWORD + ae_ss_status*: DWORD + ae_ss_code*: DWORD + ae_ss_text*: DWORD + ae_ss_returnval*: DWORD + PAE_SERVICESTAT* = ptr TAE_SERVICESTAT + LPAE_SERVICESTAT* = ptr TAE_SERVICESTAT + TAE_ACLMOD* {.pure.} = object + ae_am_compname*: DWORD + ae_am_username*: DWORD + ae_am_resname*: DWORD + ae_am_action*: DWORD + ae_am_datalen*: DWORD + PAE_ACLMOD* = ptr TAE_ACLMOD + LPAE_ACLMOD* = ptr TAE_ACLMOD + TAE_UASMOD* {.pure.} = object + ae_um_compname*: DWORD + ae_um_username*: DWORD + ae_um_resname*: DWORD + ae_um_rectype*: DWORD + ae_um_action*: DWORD + ae_um_datalen*: DWORD + PAE_UASMOD* = ptr TAE_UASMOD + LPAE_UASMOD* = ptr TAE_UASMOD + TAE_NETLOGON* {.pure.} = object + ae_no_compname*: DWORD + ae_no_username*: DWORD + ae_no_privilege*: DWORD + ae_no_authflags*: DWORD + PAE_NETLOGON* = ptr TAE_NETLOGON + LPAE_NETLOGON* = ptr TAE_NETLOGON + TAE_NETLOGOFF* {.pure.} = object + ae_nf_compname*: DWORD + ae_nf_username*: DWORD + ae_nf_reserved1*: DWORD + ae_nf_reserved2*: DWORD + PAE_NETLOGOFF* = ptr TAE_NETLOGOFF + LPAE_NETLOGOFF* = ptr TAE_NETLOGOFF + AE_ACCLIM* {.pure.} = object + ae_al_compname*: DWORD + ae_al_username*: DWORD + ae_al_resname*: DWORD + ae_al_limit*: DWORD + PAE_ACCLIM* = ptr AE_ACCLIM + LPAE_ACCLIM* = ptr AE_ACCLIM + TAE_LOCKOUT* {.pure.} = object + ae_lk_compname*: DWORD + ae_lk_username*: DWORD + ae_lk_action*: DWORD + ae_lk_bad_pw_count*: DWORD + PAE_LOCKOUT* = ptr TAE_LOCKOUT + LPAE_LOCKOUT* = ptr TAE_LOCKOUT + AE_GENERIC* {.pure.} = object + ae_ge_msgfile*: DWORD + ae_ge_msgnum*: DWORD + ae_ge_params*: DWORD + ae_ge_param1*: DWORD + ae_ge_param2*: DWORD + ae_ge_param3*: DWORD + ae_ge_param4*: DWORD + ae_ge_param5*: DWORD + ae_ge_param6*: DWORD + ae_ge_param7*: DWORD + ae_ge_param8*: DWORD + ae_ge_param9*: DWORD + PAE_GENERIC* = ptr AE_GENERIC + LPAE_GENERIC* = ptr AE_GENERIC + AT_INFO* {.pure.} = object + JobTime*: DWORD_PTR + DaysOfMonth*: DWORD + DaysOfWeek*: UCHAR + Flags*: UCHAR + Command*: LPWSTR + PAT_INFO* = ptr AT_INFO + LPAT_INFO* = ptr AT_INFO + AT_ENUM* {.pure.} = object + JobId*: DWORD + JobTime*: DWORD_PTR + DaysOfMonth*: DWORD + DaysOfWeek*: UCHAR + Flags*: UCHAR + Command*: LPWSTR + PAT_ENUM* = ptr AT_ENUM + LPAT_ENUM* = ptr AT_ENUM + DFS_TARGET_PRIORITY* {.pure.} = object + TargetPriorityClass*: DFS_TARGET_PRIORITY_CLASS + TargetPriorityRank*: USHORT + Reserved*: USHORT + PDFS_TARGET_PRIORITY* = ptr DFS_TARGET_PRIORITY + DFS_INFO_1* {.pure.} = object + EntryPath*: LPWSTR + PDFS_INFO_1* = ptr DFS_INFO_1 + LPDFS_INFO_1* = ptr DFS_INFO_1 + DFS_INFO_2* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + NumberOfStorages*: DWORD + PDFS_INFO_2* = ptr DFS_INFO_2 + LPDFS_INFO_2* = ptr DFS_INFO_2 + DFS_STORAGE_INFO* {.pure.} = object + State*: ULONG + ServerName*: LPWSTR + ShareName*: LPWSTR + PDFS_STORAGE_INFO* = ptr DFS_STORAGE_INFO + LPDFS_STORAGE_INFO* = ptr DFS_STORAGE_INFO + DFS_STORAGE_INFO_1* {.pure.} = object + State*: ULONG + ServerName*: LPWSTR + ShareName*: LPWSTR + TargetPriority*: DFS_TARGET_PRIORITY + PDFS_STORAGE_INFO_1* = ptr DFS_STORAGE_INFO_1 + LPDFS_STORAGE_INFO_1* = ptr DFS_STORAGE_INFO_1 + DFS_INFO_3* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + NumberOfStorages*: DWORD + Storage*: LPDFS_STORAGE_INFO + PDFS_INFO_3* = ptr DFS_INFO_3 + LPDFS_INFO_3* = ptr DFS_INFO_3 + DFS_INFO_4* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + Guid*: GUID + NumberOfStorages*: DWORD + Storage*: LPDFS_STORAGE_INFO + PDFS_INFO_4* = ptr DFS_INFO_4 + LPDFS_INFO_4* = ptr DFS_INFO_4 + DFS_INFO_5* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + Guid*: GUID + PropertyFlags*: ULONG + MetadataSize*: ULONG + NumberOfStorages*: DWORD + PDFS_INFO_5* = ptr DFS_INFO_5 + LPDFS_INFO_5* = ptr DFS_INFO_5 + DFS_INFO_6* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + Guid*: GUID + PropertyFlags*: ULONG + MetadataSize*: ULONG + NumberOfStorages*: DWORD + Storage*: LPDFS_STORAGE_INFO_1 + PDFS_INFO_6* = ptr DFS_INFO_6 + LPDFS_INFO_6* = ptr DFS_INFO_6 + DFS_INFO_7* {.pure.} = object + GenerationGuid*: GUID + PDFS_INFO_7* = ptr DFS_INFO_7 + LPDFS_INFO_7* = ptr DFS_INFO_7 + DFS_INFO_100* {.pure.} = object + Comment*: LPWSTR + PDFS_INFO_100* = ptr DFS_INFO_100 + LPDFS_INFO_100* = ptr DFS_INFO_100 + DFS_INFO_101* {.pure.} = object + State*: DWORD + PDFS_INFO_101* = ptr DFS_INFO_101 + LPDFS_INFO_101* = ptr DFS_INFO_101 + DFS_INFO_102* {.pure.} = object + Timeout*: ULONG + PDFS_INFO_102* = ptr DFS_INFO_102 + LPDFS_INFO_102* = ptr DFS_INFO_102 + DFS_INFO_103* {.pure.} = object + PropertyFlagMask*: ULONG + PropertyFlags*: ULONG + PDFS_INFO_103* = ptr DFS_INFO_103 + LPDFS_INFO_103* = ptr DFS_INFO_103 + DFS_INFO_104* {.pure.} = object + TargetPriority*: DFS_TARGET_PRIORITY + PDFS_INFO_104* = ptr DFS_INFO_104 + LPDFS_INFO_104* = ptr DFS_INFO_104 + DFS_INFO_105* {.pure.} = object + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + PropertyFlagMask*: ULONG + PropertyFlags*: ULONG + PDFS_INFO_105* = ptr DFS_INFO_105 + LPDFS_INFO_105* = ptr DFS_INFO_105 + DFS_INFO_106* {.pure.} = object + State*: DWORD + TargetPriority*: DFS_TARGET_PRIORITY + PDFS_INFO_106* = ptr DFS_INFO_106 + LPDFS_INFO_106* = ptr DFS_INFO_106 + DFS_SUPPORTED_NAMESPACE_VERSION_INFO* {.pure.} = object + DomainDfsMajorVersion*: ULONG + NamespaceMinorVersion*: ULONG + DomainDfsCapabilities*: ULONGLONG + StandaloneDfsMajorVersion*: ULONG + StandaloneDfsMinorVersion*: ULONG + StandaloneDfsCapabilities*: ULONGLONG + PDFS_SUPPORTED_NAMESPACE_VERSION_INFO* = ptr DFS_SUPPORTED_NAMESPACE_VERSION_INFO + DFS_INFO_8* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + Guid*: GUID + PropertyFlags*: ULONG + MetadataSize*: ULONG + SdLengthReserved*: ULONG + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + NumberOfStorages*: DWORD + PDFS_INFO_8* = ptr DFS_INFO_8 + DFS_INFO_9* {.pure.} = object + EntryPath*: LPWSTR + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + Guid*: GUID + PropertyFlags*: ULONG + MetadataSize*: ULONG + SdLengthReserved*: ULONG + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + NumberOfStorages*: DWORD + Storage*: LPDFS_STORAGE_INFO_1 + PDFS_INFO_9* = ptr DFS_INFO_9 + DFS_INFO_50* {.pure.} = object + NamespaceMajorVersion*: ULONG + NamespaceMinorVersion*: ULONG + NamespaceCapabilities*: ULONGLONG + PDFS_INFO_50* = ptr DFS_INFO_50 + DFS_INFO_107* {.pure.} = object + Comment*: LPWSTR + State*: DWORD + Timeout*: ULONG + PropertyFlagMask*: ULONG + PropertyFlags*: ULONG + SdLengthReserved*: ULONG + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + PDFS_INFO_107* = ptr DFS_INFO_107 + DFS_INFO_150* {.pure.} = object + SdLengthReserved*: ULONG + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + PDFS_INFO_150* = ptr DFS_INFO_150 + DFS_INFO_200* {.pure.} = object + FtDfsName*: LPWSTR + PDFS_INFO_200* = ptr DFS_INFO_200 + LPDFS_INFO_200* = ptr DFS_INFO_200 + DFS_INFO_300* {.pure.} = object + Flags*: DWORD + DfsName*: LPWSTR + PDFS_INFO_300* = ptr DFS_INFO_300 + LPDFS_INFO_300* = ptr DFS_INFO_300 + DFS_SITENAME_INFO* {.pure.} = object + SiteFlags*: ULONG + SiteName*: LPWSTR + PDFS_SITENAME_INFO* = ptr DFS_SITENAME_INFO + LPDFS_SITENAME_INFO* = ptr DFS_SITENAME_INFO + DFS_SITELIST_INFO* {.pure.} = object + cSites*: ULONG + Site*: array[1, DFS_SITENAME_INFO] + PDFS_SITELIST_INFO* = ptr DFS_SITELIST_INFO + LPDFS_SITELIST_INFO* = ptr DFS_SITELIST_INFO + PORT_INFO_FFW* {.pure.} = object + pName*: LPWSTR + cbMonitorData*: DWORD + pMonitorData*: LPBYTE + PPORT_INFO_FFW* = ptr PORT_INFO_FFW + LPPORT_INFO_FFW* = ptr PORT_INFO_FFW + PORT_INFO_FFA* {.pure.} = object + pName*: LPSTR + cbMonitorData*: DWORD + pMonitorData*: LPBYTE + PPORT_INFO_FFA* = ptr PORT_INFO_FFA + LPPORT_INFO_FFA* = ptr PORT_INFO_FFA +const + CNLEN* = 15 + LM20_CNLEN* = 15 + DNLEN* = CNLEN + LM20_DNLEN* = LM20_CNLEN + UNCLEN* = CNLEN+2 + LM20_UNCLEN* = LM20_CNLEN+2 + NNLEN* = 80 + LM20_NNLEN* = 12 + RMLEN* = UNCLEN+1+NNLEN + LM20_RMLEN* = LM20_UNCLEN+1+LM20_NNLEN + LM20_SNLEN* = 15 + STXTLEN* = 256 + LM20_STXTLEN* = 63 + PATHLEN* = 256 + LM20_PATHLEN* = 256 + DEVLEN* = 80 + LM20_DEVLEN* = 8 + UNLEN* = 256 + LM20_UNLEN* = 20 + GNLEN* = UNLEN + LM20_GNLEN* = LM20_UNLEN + PWLEN* = 256 + LM20_PWLEN* = 14 + SHPWLEN* = 8 + CLTYPE_LEN* = 12 + MAXCOMMENTSZ* = 256 + LM20_MAXCOMMENTSZ* = 48 + QNLEN* = NNLEN + LM20_QNLEN* = LM20_NNLEN + ALERTSZ* = 128 + NETBIOS_NAME_LEN* = 16 + MAX_PREFERRED_LENGTH* = DWORD(-1) + CRYPT_KEY_LEN* = 7 + CRYPT_TXT_LEN* = 8 + SESSION_PWLEN* = 24 + SESSION_CRYPT_KLEN* = 21 + PARMNUM_ALL* = 0 + PARM_ERROR_NONE* = 0 + PARMNUM_BASE_INFOLEVEL* = 1000 + MESSAGE_FILENAME* = "NETMSG" + OS2MSG_FILENAME* = "BASE" + HELP_MSG_FILENAME* = "NETH" + BACKUP_MSG_FILENAME* = "BAK.MSG" + PLATFORM_ID_DOS* = 300 + PLATFORM_ID_OS2* = 400 + PLATFORM_ID_NT* = 500 + PLATFORM_ID_OSF* = 600 + PLATFORM_ID_VMS* = 700 + NERR_BASE* = 2100 + MIN_LANMAN_MESSAGE_ID* = NERR_BASE + MAX_LANMAN_MESSAGE_ID* = 5899 + NERR_Success* = 0 + NERR_NetNotStarted* = NERR_BASE+2 + NERR_UnknownServer* = NERR_BASE+3 + NERR_ShareMem* = NERR_BASE+4 + NERR_NoNetworkResource* = NERR_BASE+5 + NERR_RemoteOnly* = NERR_BASE+6 + NERR_DevNotRedirected* = NERR_BASE+7 + NERR_ServerNotStarted* = NERR_BASE+14 + NERR_ItemNotFound* = NERR_BASE+15 + NERR_UnknownDevDir* = NERR_BASE+16 + NERR_RedirectedPath* = NERR_BASE+17 + NERR_DuplicateShare* = NERR_BASE+18 + NERR_NoRoom* = NERR_BASE+19 + NERR_TooManyItems* = NERR_BASE+21 + NERR_InvalidMaxUsers* = NERR_BASE+22 + NERR_BufTooSmall* = NERR_BASE+23 + NERR_RemoteErr* = NERR_BASE+27 + NERR_LanmanIniError* = NERR_BASE+31 + NERR_NetworkError* = NERR_BASE+36 + NERR_WkstaInconsistentState* = NERR_BASE+37 + NERR_WkstaNotStarted* = NERR_BASE+38 + NERR_BrowserNotStarted* = NERR_BASE+39 + NERR_InternalError* = NERR_BASE+40 + NERR_BadTransactConfig* = NERR_BASE+41 + NERR_InvalidAPI* = NERR_BASE+42 + NERR_BadEventName* = NERR_BASE+43 + NERR_DupNameReboot* = NERR_BASE+44 + NERR_CfgCompNotFound* = NERR_BASE+46 + NERR_CfgParamNotFound* = NERR_BASE+47 + NERR_LineTooLong* = NERR_BASE+49 + NERR_QNotFound* = NERR_BASE+50 + NERR_JobNotFound* = NERR_BASE+51 + NERR_DestNotFound* = NERR_BASE+52 + NERR_DestExists* = NERR_BASE+53 + NERR_QExists* = NERR_BASE+54 + NERR_QNoRoom* = NERR_BASE+55 + NERR_JobNoRoom* = NERR_BASE+56 + NERR_DestNoRoom* = NERR_BASE+57 + NERR_DestIdle* = NERR_BASE+58 + NERR_DestInvalidOp* = NERR_BASE+59 + NERR_ProcNoRespond* = NERR_BASE+60 + NERR_SpoolerNotLoaded* = NERR_BASE+61 + NERR_DestInvalidState* = NERR_BASE+62 + NERR_QInvalidState* = NERR_BASE+63 + NERR_JobInvalidState* = NERR_BASE+64 + NERR_SpoolNoMemory* = NERR_BASE+65 + NERR_DriverNotFound* = NERR_BASE+66 + NERR_DataTypeInvalid* = NERR_BASE+67 + NERR_ProcNotFound* = NERR_BASE+68 + NERR_ServiceTableLocked* = NERR_BASE+80 + NERR_ServiceTableFull* = NERR_BASE+81 + NERR_ServiceInstalled* = NERR_BASE+82 + NERR_ServiceEntryLocked* = NERR_BASE+83 + NERR_ServiceNotInstalled* = NERR_BASE+84 + NERR_BadServiceName* = NERR_BASE+85 + NERR_ServiceCtlTimeout* = NERR_BASE+86 + NERR_ServiceCtlBusy* = NERR_BASE+87 + NERR_BadServiceProgName* = NERR_BASE+88 + NERR_ServiceNotCtrl* = NERR_BASE+89 + NERR_ServiceKillProc* = NERR_BASE+90 + NERR_ServiceCtlNotValid* = NERR_BASE+91 + NERR_NotInDispatchTbl* = NERR_BASE+92 + NERR_BadControlRecv* = NERR_BASE+93 + NERR_ServiceNotStarting* = NERR_BASE+94 + NERR_AlreadyLoggedOn* = NERR_BASE+100 + NERR_NotLoggedOn* = NERR_BASE+101 + NERR_BadUsername* = NERR_BASE+102 + NERR_BadPassword* = NERR_BASE+103 + NERR_UnableToAddName_W* = NERR_BASE+104 + NERR_UnableToAddName_F* = NERR_BASE+105 + NERR_UnableToDelName_W* = NERR_BASE+106 + NERR_UnableToDelName_F* = NERR_BASE+107 + NERR_LogonsPaused* = NERR_BASE+109 + NERR_LogonServerConflict* = NERR_BASE+110 + NERR_LogonNoUserPath* = NERR_BASE+111 + NERR_LogonScriptError* = NERR_BASE+112 + NERR_StandaloneLogon* = NERR_BASE+114 + NERR_LogonServerNotFound* = NERR_BASE+115 + NERR_LogonDomainExists* = NERR_BASE+116 + NERR_NonValidatedLogon* = NERR_BASE+117 + NERR_ACFNotFound* = NERR_BASE+119 + NERR_GroupNotFound* = NERR_BASE+120 + NERR_UserNotFound* = NERR_BASE+121 + NERR_ResourceNotFound* = NERR_BASE+122 + NERR_GroupExists* = NERR_BASE+123 + NERR_UserExists* = NERR_BASE+124 + NERR_ResourceExists* = NERR_BASE+125 + NERR_NotPrimary* = NERR_BASE+126 + NERR_ACFNotLoaded* = NERR_BASE+127 + NERR_ACFNoRoom* = NERR_BASE+128 + NERR_ACFFileIOFail* = NERR_BASE+129 + NERR_ACFTooManyLists* = NERR_BASE+130 + NERR_UserLogon* = NERR_BASE+131 + NERR_ACFNoParent* = NERR_BASE+132 + NERR_CanNotGrowSegment* = NERR_BASE+133 + NERR_SpeGroupOp* = NERR_BASE+134 + NERR_NotInCache* = NERR_BASE+135 + NERR_UserInGroup* = NERR_BASE+136 + NERR_UserNotInGroup* = NERR_BASE+137 + NERR_AccountUndefined* = NERR_BASE+138 + NERR_AccountExpired* = NERR_BASE+139 + NERR_InvalidWorkstation* = NERR_BASE+140 + NERR_InvalidLogonHours* = NERR_BASE+141 + NERR_PasswordExpired* = NERR_BASE+142 + NERR_PasswordCantChange* = NERR_BASE+143 + NERR_PasswordHistConflict* = NERR_BASE+144 + NERR_PasswordTooShort* = NERR_BASE+145 + NERR_PasswordTooRecent* = NERR_BASE+146 + NERR_InvalidDatabase* = NERR_BASE+147 + NERR_DatabaseUpToDate* = NERR_BASE+148 + NERR_SyncRequired* = NERR_BASE+149 + NERR_UseNotFound* = NERR_BASE+150 + NERR_BadAsgType* = NERR_BASE+151 + NERR_DeviceIsShared* = NERR_BASE+152 + NERR_NoComputerName* = NERR_BASE+170 + NERR_MsgAlreadyStarted* = NERR_BASE+171 + NERR_MsgInitFailed* = NERR_BASE+172 + NERR_NameNotFound* = NERR_BASE+173 + NERR_AlreadyForwarded* = NERR_BASE+174 + NERR_AddForwarded* = NERR_BASE+175 + NERR_AlreadyExists* = NERR_BASE+176 + NERR_TooManyNames* = NERR_BASE+177 + NERR_DelComputerName* = NERR_BASE+178 + NERR_LocalForward* = NERR_BASE+179 + NERR_GrpMsgProcessor* = NERR_BASE+180 + NERR_PausedRemote* = NERR_BASE+181 + NERR_BadReceive* = NERR_BASE+182 + NERR_NameInUse* = NERR_BASE+183 + NERR_MsgNotStarted* = NERR_BASE+184 + NERR_NotLocalName* = NERR_BASE+185 + NERR_NoForwardName* = NERR_BASE+186 + NERR_RemoteFull* = NERR_BASE+187 + NERR_NameNotForwarded* = NERR_BASE+188 + NERR_TruncatedBroadcast* = NERR_BASE+189 + NERR_InvalidDevice* = NERR_BASE+194 + NERR_WriteFault* = NERR_BASE+195 + NERR_DuplicateName* = NERR_BASE+197 + NERR_DeleteLater* = NERR_BASE+198 + NERR_IncompleteDel* = NERR_BASE+199 + NERR_MultipleNets* = NERR_BASE+200 + NERR_NetNameNotFound* = NERR_BASE+210 + NERR_DeviceNotShared* = NERR_BASE+211 + NERR_ClientNameNotFound* = NERR_BASE+212 + NERR_FileIdNotFound* = NERR_BASE+214 + NERR_ExecFailure* = NERR_BASE+215 + NERR_TmpFile* = NERR_BASE+216 + NERR_TooMuchData* = NERR_BASE+217 + NERR_DeviceShareConflict* = NERR_BASE+218 + NERR_BrowserTableIncomplete* = NERR_BASE+219 + NERR_NotLocalDomain* = NERR_BASE+220 + NERR_IsDfsShare* = NERR_BASE+221 + NERR_DevInvalidOpCode* = NERR_BASE+231 + NERR_DevNotFound* = NERR_BASE+232 + NERR_DevNotOpen* = NERR_BASE+233 + NERR_BadQueueDevString* = NERR_BASE+234 + NERR_BadQueuePriority* = NERR_BASE+235 + NERR_NoCommDevs* = NERR_BASE+237 + NERR_QueueNotFound* = NERR_BASE+238 + NERR_BadDevString* = NERR_BASE+240 + NERR_BadDev* = NERR_BASE+241 + NERR_InUseBySpooler* = NERR_BASE+242 + NERR_CommDevInUse* = NERR_BASE+243 + NERR_InvalidComputer* = NERR_BASE+251 + NERR_MaxLenExceeded* = NERR_BASE+254 + NERR_BadComponent* = NERR_BASE+256 + NERR_CantType* = NERR_BASE+257 + NERR_TooManyEntries* = NERR_BASE+262 + NERR_ProfileFileTooBig* = NERR_BASE+270 + NERR_ProfileOffset* = NERR_BASE+271 + NERR_ProfileCleanup* = NERR_BASE+272 + NERR_ProfileUnknownCmd* = NERR_BASE+273 + NERR_ProfileLoadErr* = NERR_BASE+274 + NERR_ProfileSaveErr* = NERR_BASE+275 + NERR_LogOverflow* = NERR_BASE+277 + NERR_LogFileChanged* = NERR_BASE+278 + NERR_LogFileCorrupt* = NERR_BASE+279 + NERR_SourceIsDir* = NERR_BASE+280 + NERR_BadSource* = NERR_BASE+281 + NERR_BadDest* = NERR_BASE+282 + NERR_DifferentServers* = NERR_BASE+283 + NERR_RunSrvPaused* = NERR_BASE+285 + NERR_ErrCommRunSrv* = NERR_BASE+289 + NERR_ErrorExecingGhost* = NERR_BASE+291 + NERR_ShareNotFound* = NERR_BASE+292 + NERR_InvalidLana* = NERR_BASE+300 + NERR_OpenFiles* = NERR_BASE+301 + NERR_ActiveConns* = NERR_BASE+302 + NERR_BadPasswordCore* = NERR_BASE+303 + NERR_DevInUse* = NERR_BASE+304 + NERR_LocalDrive* = NERR_BASE+305 + NERR_AlertExists* = NERR_BASE+330 + NERR_TooManyAlerts* = NERR_BASE+331 + NERR_NoSuchAlert* = NERR_BASE+332 + NERR_BadRecipient* = NERR_BASE+333 + NERR_AcctLimitExceeded* = NERR_BASE+334 + NERR_InvalidLogSeek* = NERR_BASE+340 + NERR_BadUasConfig* = NERR_BASE+350 + NERR_InvalidUASOp* = NERR_BASE+351 + NERR_LastAdmin* = NERR_BASE+352 + NERR_DCNotFound* = NERR_BASE+353 + NERR_LogonTrackingError* = NERR_BASE+354 + NERR_NetlogonNotStarted* = NERR_BASE+355 + NERR_CanNotGrowUASFile* = NERR_BASE+356 + NERR_TimeDiffAtDC* = NERR_BASE+357 + NERR_PasswordMismatch* = NERR_BASE+358 + NERR_NoSuchServer* = NERR_BASE+360 + NERR_NoSuchSession* = NERR_BASE+361 + NERR_NoSuchConnection* = NERR_BASE+362 + NERR_TooManyServers* = NERR_BASE+363 + NERR_TooManySessions* = NERR_BASE+364 + NERR_TooManyConnections* = NERR_BASE+365 + NERR_TooManyFiles* = NERR_BASE+366 + NERR_NoAlternateServers* = NERR_BASE+367 + NERR_TryDownLevel* = NERR_BASE+370 + NERR_UPSDriverNotStarted* = NERR_BASE+380 + NERR_UPSInvalidConfig* = NERR_BASE+381 + NERR_UPSInvalidCommPort* = NERR_BASE+382 + NERR_UPSSignalAsserted* = NERR_BASE+383 + NERR_UPSShutdownFailed* = NERR_BASE+384 + NERR_BadDosRetCode* = NERR_BASE+400 + NERR_ProgNeedsExtraMem* = NERR_BASE+401 + NERR_BadDosFunction* = NERR_BASE+402 + NERR_RemoteBootFailed* = NERR_BASE+403 + NERR_BadFileCheckSum* = NERR_BASE+404 + NERR_NoRplBootSystem* = NERR_BASE+405 + NERR_RplLoadrNetBiosErr* = NERR_BASE+406 + NERR_RplLoadrDiskErr* = NERR_BASE+407 + NERR_ImageParamErr* = NERR_BASE+408 + NERR_TooManyImageParams* = NERR_BASE+409 + NERR_NonDosFloppyUsed* = NERR_BASE+410 + NERR_RplBootRestart* = NERR_BASE+411 + NERR_RplSrvrCallFailed* = NERR_BASE+412 + NERR_CantConnectRplSrvr* = NERR_BASE+413 + NERR_CantOpenImageFile* = NERR_BASE+414 + NERR_CallingRplSrvr* = NERR_BASE+415 + NERR_StartingRplBoot* = NERR_BASE+416 + NERR_RplBootServiceTerm* = NERR_BASE+417 + NERR_RplBootStartFailed* = NERR_BASE+418 + NERR_RPL_CONNECTED* = NERR_BASE+419 + NERR_BrowserConfiguredToNotRun* = NERR_BASE+450 + NERR_RplNoAdaptersStarted* = NERR_BASE+510 + NERR_RplBadRegistry* = NERR_BASE+511 + NERR_RplBadDatabase* = NERR_BASE+512 + NERR_RplRplfilesShare* = NERR_BASE+513 + NERR_RplNotRplServer* = NERR_BASE+514 + NERR_RplCannotEnum* = NERR_BASE+515 + NERR_RplWkstaInfoCorrupted* = NERR_BASE+516 + NERR_RplWkstaNotFound* = NERR_BASE+517 + NERR_RplWkstaNameUnavailable* = NERR_BASE+518 + NERR_RplProfileInfoCorrupted* = NERR_BASE+519 + NERR_RplProfileNotFound* = NERR_BASE+520 + NERR_RplProfileNameUnavailable* = NERR_BASE+521 + NERR_RplProfileNotEmpty* = NERR_BASE+522 + NERR_RplConfigInfoCorrupted* = NERR_BASE+523 + NERR_RplConfigNotFound* = NERR_BASE+524 + NERR_RplAdapterInfoCorrupted* = NERR_BASE+525 + NERR_RplInternal* = NERR_BASE+526 + NERR_RplVendorInfoCorrupted* = NERR_BASE+527 + NERR_RplBootInfoCorrupted* = NERR_BASE+528 + NERR_RplWkstaNeedsUserAcct* = NERR_BASE+529 + NERR_RplNeedsRPLUSERAcct* = NERR_BASE+530 + NERR_RplBootNotFound* = NERR_BASE+531 + NERR_RplIncompatibleProfile* = NERR_BASE+532 + NERR_RplAdapterNameUnavailable* = NERR_BASE+533 + NERR_RplConfigNotEmpty* = NERR_BASE+534 + NERR_RplBootInUse* = NERR_BASE+535 + NERR_RplBackupDatabase* = NERR_BASE+536 + NERR_RplAdapterNotFound* = NERR_BASE+537 + NERR_RplVendorNotFound* = NERR_BASE+538 + NERR_RplVendorNameUnavailable* = NERR_BASE+539 + NERR_RplBootNameUnavailable* = NERR_BASE+540 + NERR_RplConfigNameUnavailable* = NERR_BASE+541 + NERR_DfsInternalCorruption* = NERR_BASE+560 + NERR_DfsVolumeDataCorrupt* = NERR_BASE+561 + NERR_DfsNoSuchVolume* = NERR_BASE+562 + NERR_DfsVolumeAlreadyExists* = NERR_BASE+563 + NERR_DfsAlreadyShared* = NERR_BASE+564 + NERR_DfsNoSuchShare* = NERR_BASE+565 + NERR_DfsNotALeafVolume* = NERR_BASE+566 + NERR_DfsLeafVolume* = NERR_BASE+567 + NERR_DfsVolumeHasMultipleServers* = NERR_BASE+568 + NERR_DfsCantCreateJunctionPoint* = NERR_BASE+569 + NERR_DfsServerNotDfsAware* = NERR_BASE+570 + NERR_DfsBadRenamePath* = NERR_BASE+571 + NERR_DfsVolumeIsOffline* = NERR_BASE+572 + NERR_DfsNoSuchServer* = NERR_BASE+573 + NERR_DfsCyclicalName* = NERR_BASE+574 + NERR_DfsNotSupportedInServerDfs* = NERR_BASE+575 + NERR_DfsDuplicateService* = NERR_BASE+576 + NERR_DfsCantRemoveLastServerShare* = NERR_BASE+577 + NERR_DfsVolumeIsInterDfs* = NERR_BASE+578 + NERR_DfsInconsistent* = NERR_BASE+579 + NERR_DfsServerUpgraded* = NERR_BASE+580 + NERR_DfsDataIsIdentical* = NERR_BASE+581 + NERR_DfsCantRemoveDfsRoot* = NERR_BASE+582 + NERR_DfsChildOrParentInDfs* = NERR_BASE+583 + NERR_DfsInternalError* = NERR_BASE+590 + NERR_SetupAlreadyJoined* = NERR_BASE+591 + NERR_SetupNotJoined* = NERR_BASE+592 + NERR_SetupDomainController* = NERR_BASE+593 + NERR_DefaultJoinRequired* = NERR_BASE+594 + NERR_InvalidWorkgroupName* = NERR_BASE+595 + NERR_NameUsesIncompatibleCodePage* = NERR_BASE+596 + NERR_ComputerAccountNotFound* = NERR_BASE+597 + NERR_PersonalSku* = NERR_BASE+598 + NERR_PasswordMustChange* = NERR_BASE+601 + NERR_AccountLockedOut* = NERR_BASE+602 + NERR_PasswordTooLong* = NERR_BASE+603 + NERR_PasswordNotComplexEnough* = NERR_BASE+604 + NERR_PasswordFilterError* = NERR_BASE+605 + MAX_NERR* = NERR_BASE+899 + UF_SCRIPT* = 0x0001 + UF_ACCOUNTDISABLE* = 0x0002 + UF_HOMEDIR_REQUIRED* = 0x0008 + UF_LOCKOUT* = 0x0010 + UF_PASSWD_NOTREQD* = 0x0020 + UF_PASSWD_CANT_CHANGE* = 0x0040 + UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED* = 0x0080 + UF_TEMP_DUPLICATE_ACCOUNT* = 0x0100 + UF_NORMAL_ACCOUNT* = 0x0200 + UF_INTERDOMAIN_TRUST_ACCOUNT* = 0x0800 + UF_WORKSTATION_TRUST_ACCOUNT* = 0x1000 + UF_SERVER_TRUST_ACCOUNT* = 0x2000 + UF_MACHINE_ACCOUNT_MASK* = UF_INTERDOMAIN_TRUST_ACCOUNT or UF_WORKSTATION_TRUST_ACCOUNT or UF_SERVER_TRUST_ACCOUNT + UF_ACCOUNT_TYPE_MASK* = UF_TEMP_DUPLICATE_ACCOUNT or UF_NORMAL_ACCOUNT or UF_INTERDOMAIN_TRUST_ACCOUNT or UF_WORKSTATION_TRUST_ACCOUNT or UF_SERVER_TRUST_ACCOUNT + UF_DONT_EXPIRE_PASSWD* = 0x10000 + UF_MNS_LOGON_ACCOUNT* = 0x20000 + UF_SMARTCARD_REQUIRED* = 0x40000 + UF_TRUSTED_FOR_DELEGATION* = 0x80000 + UF_NOT_DELEGATED* = 0x100000 + UF_USE_DES_KEY_ONLY* = 0x200000 + UF_DONT_REQUIRE_PREAUTH* = 0x400000 + UF_PASSWORD_EXPIRED* = 0x800000 + UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION* = 0x1000000 + UF_NO_AUTH_DATA_REQUIRED* = 0x2000000 + UF_SETTABLE_BITS* = UF_SCRIPT or UF_ACCOUNTDISABLE or UF_LOCKOUT or UF_HOMEDIR_REQUIRED or UF_PASSWD_NOTREQD or UF_PASSWD_CANT_CHANGE or UF_ACCOUNT_TYPE_MASK or UF_DONT_EXPIRE_PASSWD or UF_MNS_LOGON_ACCOUNT or UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED or UF_SMARTCARD_REQUIRED or UF_TRUSTED_FOR_DELEGATION or UF_NOT_DELEGATED or UF_USE_DES_KEY_ONLY or UF_DONT_REQUIRE_PREAUTH or UF_PASSWORD_EXPIRED or UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION or UF_NO_AUTH_DATA_REQUIRED + FILTER_TEMP_DUPLICATE_ACCOUNT* = 0x0001 + FILTER_NORMAL_ACCOUNT* = 0x0002 + FILTER_INTERDOMAIN_TRUST_ACCOUNT* = 0x0008 + FILTER_WORKSTATION_TRUST_ACCOUNT* = 0x0010 + FILTER_SERVER_TRUST_ACCOUNT* = 0x0020 + LG_INCLUDE_INDIRECT* = 0x0001 + AF_OP_PRINT* = 0x1 + AF_OP_COMM* = 0x2 + AF_OP_SERVER* = 0x4 + AF_OP_ACCOUNTS* = 0x8 + AF_SETTABLE_BITS* = AF_OP_PRINT or AF_OP_COMM or AF_OP_SERVER or AF_OP_ACCOUNTS + UAS_ROLE_STANDALONE* = 0 + UAS_ROLE_MEMBER* = 1 + UAS_ROLE_BACKUP* = 2 + UAS_ROLE_PRIMARY* = 3 + USER_NAME_PARMNUM* = 1 + USER_PASSWORD_PARMNUM* = 3 + USER_PASSWORD_AGE_PARMNUM* = 4 + USER_PRIV_PARMNUM* = 5 + USER_HOME_DIR_PARMNUM* = 6 + USER_COMMENT_PARMNUM* = 7 + USER_FLAGS_PARMNUM* = 8 + USER_SCRIPT_PATH_PARMNUM* = 9 + USER_AUTH_FLAGS_PARMNUM* = 10 + USER_FULL_NAME_PARMNUM* = 11 + USER_USR_COMMENT_PARMNUM* = 12 + USER_PARMS_PARMNUM* = 13 + USER_WORKSTATIONS_PARMNUM* = 14 + USER_LAST_LOGON_PARMNUM* = 15 + USER_LAST_LOGOFF_PARMNUM* = 16 + USER_ACCT_EXPIRES_PARMNUM* = 17 + USER_MAX_STORAGE_PARMNUM* = 18 + USER_UNITS_PER_WEEK_PARMNUM* = 19 + USER_LOGON_HOURS_PARMNUM* = 20 + USER_PAD_PW_COUNT_PARMNUM* = 21 + USER_NUM_LOGONS_PARMNUM* = 22 + USER_LOGON_SERVER_PARMNUM* = 23 + USER_COUNTRY_CODE_PARMNUM* = 24 + USER_CODE_PAGE_PARMNUM* = 25 + USER_PRIMARY_GROUP_PARMNUM* = 51 + USER_PROFILE* = 52 + USER_PROFILE_PARMNUM* = 52 + USER_HOME_DIR_DRIVE_PARMNUM* = 53 + USER_NAME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_NAME_PARMNUM + USER_PASSWORD_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PASSWORD_PARMNUM + USER_PASSWORD_AGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PASSWORD_AGE_PARMNUM + USER_PRIV_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PRIV_PARMNUM + USER_HOME_DIR_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_HOME_DIR_PARMNUM + USER_COMMENT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_COMMENT_PARMNUM + USER_FLAGS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_FLAGS_PARMNUM + USER_SCRIPT_PATH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_SCRIPT_PATH_PARMNUM + USER_AUTH_FLAGS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_AUTH_FLAGS_PARMNUM + USER_FULL_NAME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_FULL_NAME_PARMNUM + USER_USR_COMMENT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_USR_COMMENT_PARMNUM + USER_PARMS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PARMS_PARMNUM + USER_WORKSTATIONS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_WORKSTATIONS_PARMNUM + USER_LAST_LOGON_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_LAST_LOGON_PARMNUM + USER_LAST_LOGOFF_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_LAST_LOGOFF_PARMNUM + USER_ACCT_EXPIRES_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_ACCT_EXPIRES_PARMNUM + USER_MAX_STORAGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_MAX_STORAGE_PARMNUM + USER_UNITS_PER_WEEK_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_UNITS_PER_WEEK_PARMNUM + USER_LOGON_HOURS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_LOGON_HOURS_PARMNUM + USER_PAD_PW_COUNT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PAD_PW_COUNT_PARMNUM + USER_NUM_LOGONS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_NUM_LOGONS_PARMNUM + USER_LOGON_SERVER_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_LOGON_SERVER_PARMNUM + USER_COUNTRY_CODE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_COUNTRY_CODE_PARMNUM + USER_CODE_PAGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_CODE_PAGE_PARMNUM + USER_PRIMARY_GROUP_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_PRIMARY_GROUP_PARMNUM + USER_HOME_DIR_DRIVE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+USER_HOME_DIR_DRIVE_PARMNUM + NULL_USERSETINFO_PASSWD* = " " + TIMEQ_FOREVER* = -1 + USER_MAXSTORAGE_UNLIMITED* = -1 + USER_NO_LOGOFF* = -1 + UNITS_PER_DAY* = 24 + UNITS_PER_WEEK* = UNITS_PER_DAY*7 + USER_PRIV_MASK* = 0x3 + USER_PRIV_GUEST* = 0 + USER_PRIV_USER* = 1 + USER_PRIV_ADMIN* = 2 + MAX_PASSWD_LEN* = PWLEN + DEF_MIN_PWLEN* = 6 + DEF_PWUNIQUENESS* = 5 + DEF_MAX_PWHIST* = 8 + DEF_MAX_PWAGE* = TIMEQ_FOREVER + DEF_MIN_PWAGE* = 0 + DEF_FORCE_LOGOFF* = 0xffffffff'i32 + DEF_MAX_BADPW* = 0 + ONE_DAY* = 01*24*3600 + VALIDATED_LOGON* = 0 + PASSWORD_EXPIRED* = 2 + NON_VALIDATED_LOGON* = 3 + VALID_LOGOFF* = 1 + MODALS_MIN_PASSWD_LEN_PARMNUM* = 1 + MODALS_MAX_PASSWD_AGE_PARMNUM* = 2 + MODALS_MIN_PASSWD_AGE_PARMNUM* = 3 + MODALS_FORCE_LOGOFF_PARMNUM* = 4 + MODALS_PASSWD_HIST_LEN_PARMNUM* = 5 + MODALS_ROLE_PARMNUM* = 6 + MODALS_PRIMARY_PARMNUM* = 7 + MODALS_DOMAIN_NAME_PARMNUM* = 8 + MODALS_DOMAIN_ID_PARMNUM* = 9 + MODALS_LOCKOUT_DURATION_PARMNUM* = 10 + MODALS_LOCKOUT_OBSERVATION_WINDOW_PARMNUM* = 11 + MODALS_LOCKOUT_THRESHOLD_PARMNUM* = 12 + MODALS_MIN_PASSWD_LEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_MIN_PASSWD_LEN_PARMNUM + MODALS_MAX_PASSWD_AGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_MAX_PASSWD_AGE_PARMNUM + MODALS_MIN_PASSWD_AGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_MIN_PASSWD_AGE_PARMNUM + MODALS_FORCE_LOGOFF_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_FORCE_LOGOFF_PARMNUM + MODALS_PASSWD_HIST_LEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_PASSWD_HIST_LEN_PARMNUM + MODALS_ROLE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_ROLE_PARMNUM + MODALS_PRIMARY_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_PRIMARY_PARMNUM + MODALS_DOMAIN_NAME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_DOMAIN_NAME_PARMNUM + MODALS_DOMAIN_ID_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+MODALS_DOMAIN_ID_PARMNUM + GROUPIDMASK* = 0x8000 + GROUP_SPECIALGRP_USERS* = "USERS" + GROUP_SPECIALGRP_ADMINS* = "ADMINS" + GROUP_SPECIALGRP_GUESTS* = "GUESTS" + GROUP_SPECIALGRP_LOCAL* = "LOCA" + GROUP_ALL_PARMNUM* = 0 + GROUP_NAME_PARMNUM* = 1 + GROUP_COMMENT_PARMNUM* = 2 + GROUP_ATTRIBUTES_PARMNUM* = 3 + GROUP_ALL_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+GROUP_ALL_PARMNUM + GROUP_NAME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+GROUP_NAME_PARMNUM + GROUP_COMMENT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+GROUP_COMMENT_PARMNUM + GROUP_ATTRIBUTES_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+GROUP_ATTRIBUTES_PARMNUM + LOCALGROUP_NAME_PARMNUM* = 1 + LOCALGROUP_COMMENT_PARMNUM* = 2 + MAXPERMENTRIES* = 64 + ACCESS_NONE* = 0 + ACCESS_READ* = 0x01 + ACCESS_WRITE* = 0x02 + ACCESS_CREATE* = 0x04 + ACCESS_EXEC* = 0x08 + ACCESS_DELETE* = 0x10 + ACCESS_ATRIB* = 0x20 + ACCESS_PERM* = 0x40 + ACCESS_ALL* = ACCESS_READ or ACCESS_WRITE or ACCESS_CREATE or ACCESS_EXEC or ACCESS_DELETE or ACCESS_ATRIB or ACCESS_PERM + ACCESS_GROUP* = 0x8000 + ACCESS_AUDIT* = 0x1 + ACCESS_SUCCESS_OPEN* = 0x10 + ACCESS_SUCCESS_WRITE* = 0x20 + ACCESS_SUCCESS_DELETE* = 0x40 + ACCESS_SUCCESS_ACL* = 0x80 + ACCESS_SUCCESS_MASK* = 0xF0 + ACCESS_FAIL_OPEN* = 0x100 + ACCESS_FAIL_WRITE* = 0x200 + ACCESS_FAIL_DELETE* = 0x400 + ACCESS_FAIL_ACL* = 0x800 + ACCESS_FAIL_MASK* = 0xF00 + ACCESS_FAIL_SHIFT* = 4 + ACCESS_RESOURCE_NAME_PARMNUM* = 1 + ACCESS_ATTR_PARMNUM* = 2 + ACCESS_COUNT_PARMNUM* = 3 + ACCESS_ACCESS_LIST_PARMNUM* = 4 + ACCESS_RESOURCE_NAME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+ACCESS_RESOURCE_NAME_PARMNUM + ACCESS_ATTR_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+ACCESS_ATTR_PARMNUM + ACCESS_COUNT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+ACCESS_COUNT_PARMNUM + ACCESS_ACCESS_LIST_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+ACCESS_ACCESS_LIST_PARMNUM + ACCESS_LETTERS* = "RWCXDAP " + netValidateAuthentication* = 1 + netValidatePasswordChange* = 2 + netValidatePasswordReset* = 3 + NET_VALIDATE_PASSWORD_LAST_SET* = 0x00000001 + NET_VALIDATE_BAD_PASSWORD_TIME* = 0x00000002 + NET_VALIDATE_LOCKOUT_TIME* = 0x00000004 + NET_VALIDATE_BAD_PASSWORD_COUNT* = 0x00000008 + NET_VALIDATE_PASSWORD_HISTORY_LENGTH* = 0x00000010 + NET_VALIDATE_PASSWORD_HISTORY* = 0x00000020 + NETLOGON_CONTROL_QUERY* = 1 + NETLOGON_CONTROL_REPLICATE* = 2 + NETLOGON_CONTROL_SYNCHRONIZE* = 3 + NETLOGON_CONTROL_PDC_REPLICATE* = 4 + NETLOGON_CONTROL_REDISCOVER* = 5 + NETLOGON_CONTROL_TC_QUERY* = 6 + NETLOGON_CONTROL_TRANSPORT_NOTIFY* = 7 + NETLOGON_CONTROL_FIND_USER* = 8 + NETLOGON_CONTROL_CHANGE_PASSWORD* = 9 + NETLOGON_CONTROL_TC_VERIFY* = 10 + NETLOGON_CONTROL_FORCE_DNS_REG* = 11 + NETLOGON_CONTROL_QUERY_DNS_REG* = 12 + NETLOGON_CONTROL_UNLOAD_NETLOGON_DLL* = 0xFFFB + NETLOGON_CONTROL_BACKUP_CHANGE_LOG* = 0xFFFC + NETLOGON_CONTROL_TRUNCATE_LOG* = 0xFFFD + NETLOGON_CONTROL_SET_DBFLAG* = 0xFFFE + NETLOGON_CONTROL_BREAKPOINT* = 0xFFFF + NETLOGON_REPLICATION_NEEDED* = 0x01 + NETLOGON_REPLICATION_IN_PROGRESS* = 0x02 + NETLOGON_FULL_SYNC_REPLICATION* = 0x04 + NETLOGON_REDO_NEEDED* = 0x08 + NETLOGON_HAS_IP* = 0x10 + NETLOGON_HAS_TIMESERV* = 0x20 + NETLOGON_DNS_UPDATE_FAILURE* = 0x40 + NETLOGON_VERIFY_STATUS_RETURNED* = 0x80 + msaInfoNotExist* = 1 + msaInfoNotService* = 2 + msaInfoCannotInstall* = 3 + msaInfoCanInstall* = 4 + msaInfoInstalled* = 5 + SERVICE_ACCOUNT_FLAG_LINK_TO_HOST_ONLY* = 0x00000001 + ALERTER_MAILSLOT* = "\\\\.\\MAILSLOT\\Alerter" + ALERT_PRINT_EVENT* = "PRINTING" + ALERT_MESSAGE_EVENT* = "MESSAGE" + ALERT_ERRORLOG_EVENT* = "ERRORLOG" + ALERT_ADMIN_EVENT* = "ADMIN" + ALERT_USER_EVENT* = "USER" + PRJOB_QSTATUS* = 0x3 + PRJOB_DEVSTATUS* = 0x1fc + PRJOB_COMPLETE* = 0x4 + PRJOB_INTERV* = 0x8 + PRJOB_ERROR* = 0x10 + PRJOB_DESTOFFLINE* = 0x20 + PRJOB_DESTPAUSED* = 0x40 + PRJOB_NOTIFY* = 0x80 + PRJOB_DESTNOPAPER* = 0x100 + PRJOB_DELETED* = 0x8000 + PRJOB_QS_QUEUED* = 0 + PRJOB_QS_PAUSED* = 1 + PRJOB_QS_SPOOLING* = 2 + PRJOB_QS_PRINTING* = 3 + SHARE_NETNAME_PARMNUM* = 1 + SHARE_TYPE_PARMNUM* = 3 + SHARE_REMARK_PARMNUM* = 4 + SHARE_PERMISSIONS_PARMNUM* = 5 + SHARE_MAX_USES_PARMNUM* = 6 + SHARE_CURRENT_USES_PARMNUM* = 7 + SHARE_PATH_PARMNUM* = 8 + SHARE_PASSWD_PARMNUM* = 9 + SHARE_FILE_SD_PARMNUM* = 501 + SHARE_REMARK_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SHARE_REMARK_PARMNUM + SHARE_MAX_USES_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SHARE_MAX_USES_PARMNUM + SHARE_FILE_SD_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SHARE_FILE_SD_PARMNUM + SHI1_NUM_ELEMENTS* = 4 + SHI2_NUM_ELEMENTS* = 10 + STYPE_DISKTREE* = 0 + STYPE_PRINTQ* = 1 + STYPE_DEVICE* = 2 + STYPE_IPC* = 3 + STYPE_TEMPORARY* = 0x40000000 + STYPE_SPECIAL* = 0x80000000'i32 + SHI_USES_UNLIMITED* = DWORD(-1) + SHI1005_FLAGS_DFS* = 0x01 + SHI1005_FLAGS_DFS_ROOT* = 0x02 + CSC_MASK* = 0x30 + CSC_CACHE_MANUAL_REINT* = 0x00 + CSC_CACHE_AUTO_REINT* = 0x10 + CSC_CACHE_VDO* = 0x20 + CSC_CACHE_NONE* = 0x30 + SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS* = 0x0100 + SHI1005_FLAGS_FORCE_SHARED_DELETE* = 0x0200 + SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING* = 0x0400 + SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM* = 0x0800 + SHI1005_VALID_FLAGS_SET* = CSC_MASK or SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS or SHI1005_FLAGS_FORCE_SHARED_DELETE or SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING or SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM + SESS_GUEST* = 0x00000001 + SESS_NOENCRYPTION* = 0x00000002 + SESI1_NUM_ELEMENTS* = 8 + SESI2_NUM_ELEMENTS* = 9 + PERM_FILE_READ* = 0x1 + PERM_FILE_WRITE* = 0x2 + PERM_FILE_CREATE* = 0x4 + MSGNAME_NOT_FORWARDED* = 0 + MSGNAME_FORWARDED_TO* = 0x04 + MSGNAME_FORWARDED_FROM* = 0x10 + SUPPORTS_REMOTE_ADMIN_PROTOCOL* = 0x00000002 + SUPPORTS_RPC* = 0x00000004 + SUPPORTS_SAM_PROTOCOL* = 0x00000008 + SUPPORTS_UNICODE* = 0x00000010 + SUPPORTS_LOCAL* = 0x00000020 + SUPPORTS_ANY* = 0xFFFFFFFF'i32 + NO_PERMISSION_REQUIRED* = 0x00000001 + ALLOCATE_RESPONSE* = 0x00000002 + USE_SPECIFIC_TRANSPORT* = 0x80000000'i32 + REPL_ROLE_EXPORT* = 1 + REPL_ROLE_IMPORT* = 2 + REPL_ROLE_BOTH* = 3 + REPL_INTERVAL_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+0 + REPL_PULSE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+1 + REPL_GUARDTIME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+2 + REPL_RANDOM_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+3 + REPL_INTEGRITY_FILE* = 1 + REPL_INTEGRITY_TREE* = 2 + REPL_EXTENT_FILE* = 1 + REPL_EXTENT_TREE* = 2 + REPL_EXPORT_INTEGRITY_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+0 + REPL_EXPORT_EXTENT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+1 + REPL_UNLOCK_NOFORCE* = 0 + REPL_UNLOCK_FORCE* = 1 + REPL_STATE_OK* = 0 + REPL_STATE_NO_MASTER* = 1 + REPL_STATE_NO_SYNC* = 2 + REPL_STATE_NEVER_REPLICATED* = 3 + SV_PLATFORM_ID_OS2* = 400 + SV_PLATFORM_ID_NT* = 500 + MAJOR_VERSION_MASK* = 0x0F + SV_TYPE_WORKSTATION* = 0x00000001 + SV_TYPE_SERVER* = 0x00000002 + SV_TYPE_SQLSERVER* = 0x00000004 + SV_TYPE_DOMAIN_CTRL* = 0x00000008 + SV_TYPE_DOMAIN_BAKCTRL* = 0x00000010 + SV_TYPE_TIME_SOURCE* = 0x00000020 + SV_TYPE_AFP* = 0x00000040 + SV_TYPE_NOVELL* = 0x00000080 + SV_TYPE_DOMAIN_MEMBER* = 0x00000100 + SV_TYPE_PRINTQ_SERVER* = 0x00000200 + SV_TYPE_DIALIN_SERVER* = 0x00000400 + SV_TYPE_XENIX_SERVER* = 0x00000800 + SV_TYPE_SERVER_UNIX* = SV_TYPE_XENIX_SERVER + SV_TYPE_NT* = 0x00001000 + SV_TYPE_WFW* = 0x00002000 + SV_TYPE_SERVER_MFPN* = 0x00004000 + SV_TYPE_SERVER_NT* = 0x00008000 + SV_TYPE_POTENTIAL_BROWSER* = 0x00010000 + SV_TYPE_BACKUP_BROWSER* = 0x00020000 + SV_TYPE_MASTER_BROWSER* = 0x00040000 + SV_TYPE_DOMAIN_MASTER* = 0x00080000 + SV_TYPE_SERVER_OSF* = 0x00100000 + SV_TYPE_SERVER_VMS* = 0x00200000 + SV_TYPE_WINDOWS* = 0x00400000 + SV_TYPE_DFS* = 0x00800000 + SV_TYPE_CLUSTER_NT* = 0x01000000 + SV_TYPE_TERMINALSERVER* = 0x02000000 + SV_TYPE_CLUSTER_VS_NT* = 0x04000000 + SV_TYPE_DCE* = 0x10000000 + SV_TYPE_ALTERNATE_XPORT* = 0x20000000 + SV_TYPE_LOCAL_LIST_ONLY* = 0x40000000 + SV_TYPE_DOMAIN_ENUM* = 0x80000000'i32 + SV_TYPE_ALL* = 0xFFFFFFFF'i32 + SV_NODISC* = -1 + SV_USERSECURITY* = 1 + SV_SHARESECURITY* = 0 + SV_HIDDEN* = 1 + SV_VISIBLE* = 0 + SV_PLATFORM_ID_PARMNUM* = 101 + SV_NAME_PARMNUM* = 102 + SV_VERSION_MAJOR_PARMNUM* = 103 + SV_VERSION_MINOR_PARMNUM* = 104 + SV_TYPE_PARMNUM* = 105 + SV_COMMENT_PARMNUM* = 5 + SV_USERS_PARMNUM* = 107 + SV_DISC_PARMNUM* = 10 + SV_HIDDEN_PARMNUM* = 16 + SV_ANNOUNCE_PARMNUM* = 17 + SV_ANNDELTA_PARMNUM* = 18 + SV_USERPATH_PARMNUM* = 112 + SV_ULIST_MTIME_PARMNUM* = 401 + SV_GLIST_MTIME_PARMNUM* = 402 + SV_ALIST_MTIME_PARMNUM* = 403 + SV_ALERTS_PARMNUM* = 11 + SV_SECURITY_PARMNUM* = 405 + SV_NUMADMIN_PARMNUM* = 406 + SV_LANMASK_PARMNUM* = 407 + SV_GUESTACC_PARMNUM* = 408 + SV_CHDEVQ_PARMNUM* = 410 + SV_CHDEVJOBS_PARMNUM* = 411 + SV_CONNECTIONS_PARMNUM* = 412 + SV_SHARES_PARMNUM* = 413 + SV_OPENFILES_PARMNUM* = 414 + SV_SESSREQS_PARMNUM* = 417 + SV_ACTIVELOCKS_PARMNUM* = 419 + SV_NUMREQBUF_PARMNUM* = 420 + SV_NUMBIGBUF_PARMNUM* = 422 + SV_NUMFILETASKS_PARMNUM* = 423 + SV_ALERTSCHED_PARMNUM* = 37 + SV_ERRORALERT_PARMNUM* = 38 + SV_LOGONALERT_PARMNUM* = 39 + SV_ACCESSALERT_PARMNUM* = 40 + SV_DISKALERT_PARMNUM* = 41 + SV_NETIOALERT_PARMNUM* = 42 + SV_MAXAUDITSZ_PARMNUM* = 43 + SV_SRVHEURISTICS_PARMNUM* = 431 + SV_SESSOPENS_PARMNUM* = 501 + SV_SESSVCS_PARMNUM* = 502 + SV_OPENSEARCH_PARMNUM* = 503 + SV_SIZREQBUF_PARMNUM* = 504 + SV_INITWORKITEMS_PARMNUM* = 505 + SV_MAXWORKITEMS_PARMNUM* = 506 + SV_RAWWORKITEMS_PARMNUM* = 507 + SV_IRPSTACKSIZE_PARMNUM* = 508 + SV_MAXRAWBUFLEN_PARMNUM* = 509 + SV_SESSUSERS_PARMNUM* = 510 + SV_SESSCONNS_PARMNUM* = 511 + SV_MAXNONPAGEDMEMORYUSAGE_PARMNUM* = 512 + SV_MAXPAGEDMEMORYUSAGE_PARMNUM* = 513 + SV_ENABLESOFTCOMPAT_PARMNUM* = 514 + SV_ENABLEFORCEDLOGOFF_PARMNUM* = 515 + SV_TIMESOURCE_PARMNUM* = 516 + SV_ACCEPTDOWNLEVELAPIS_PARMNUM* = 517 + SV_LMANNOUNCE_PARMNUM* = 518 + SV_DOMAIN_PARMNUM* = 519 + SV_MAXCOPYREADLEN_PARMNUM* = 520 + SV_MAXCOPYWRITELEN_PARMNUM* = 521 + SV_MINKEEPSEARCH_PARMNUM* = 522 + SV_MAXKEEPSEARCH_PARMNUM* = 523 + SV_MINKEEPCOMPLSEARCH_PARMNUM* = 524 + SV_MAXKEEPCOMPLSEARCH_PARMNUM* = 525 + SV_THREADCOUNTADD_PARMNUM* = 526 + SV_NUMBLOCKTHREADS_PARMNUM* = 527 + SV_SCAVTIMEOUT_PARMNUM* = 528 + SV_MINRCVQUEUE_PARMNUM* = 529 + SV_MINFREEWORKITEMS_PARMNUM* = 530 + SV_XACTMEMSIZE_PARMNUM* = 531 + SV_THREADPRIORITY_PARMNUM* = 532 + SV_MAXMPXCT_PARMNUM* = 533 + SV_OPLOCKBREAKWAIT_PARMNUM* = 534 + SV_OPLOCKBREAKRESPONSEWAIT_PARMNUM* = 535 + SV_ENABLEOPLOCKS_PARMNUM* = 536 + SV_ENABLEOPLOCKFORCECLOSE_PARMNUM* = 537 + SV_ENABLEFCBOPENS_PARMNUM* = 538 + SV_ENABLERAW_PARMNUM* = 539 + SV_ENABLESHAREDNETDRIVES_PARMNUM* = 540 + SV_MINFREECONNECTIONS_PARMNUM* = 541 + SV_MAXFREECONNECTIONS_PARMNUM* = 542 + SV_INITSESSTABLE_PARMNUM* = 543 + SV_INITCONNTABLE_PARMNUM* = 544 + SV_INITFILETABLE_PARMNUM* = 545 + SV_INITSEARCHTABLE_PARMNUM* = 546 + SV_ALERTSCHEDULE_PARMNUM* = 547 + SV_ERRORTHRESHOLD_PARMNUM* = 548 + SV_NETWORKERRORTHRESHOLD_PARMNUM* = 549 + SV_DISKSPACETHRESHOLD_PARMNUM* = 550 + SV_MAXLINKDELAY_PARMNUM* = 552 + SV_MINLINKTHROUGHPUT_PARMNUM* = 553 + SV_LINKINFOVALIDTIME_PARMNUM* = 554 + SV_SCAVQOSINFOUPDATETIME_PARMNUM* = 555 + SV_MAXWORKITEMIDLETIME_PARMNUM* = 556 + SV_MAXRAWWORKITEMS_PARMNUM* = 557 + SV_PRODUCTTYPE_PARMNUM* = 560 + SV_SERVERSIZE_PARMNUM* = 561 + SV_CONNECTIONLESSAUTODISC_PARMNUM* = 562 + SV_SHARINGVIOLATIONRETRIES_PARMNUM* = 563 + SV_SHARINGVIOLATIONDELAY_PARMNUM* = 564 + SV_MAXGLOBALOPENSEARCH_PARMNUM* = 565 + SV_REMOVEDUPLICATESEARCHES_PARMNUM* = 566 + SV_LOCKVIOLATIONRETRIES_PARMNUM* = 567 + SV_LOCKVIOLATIONOFFSET_PARMNUM* = 568 + SV_LOCKVIOLATIONDELAY_PARMNUM* = 569 + SV_MDLREADSWITCHOVER_PARMNUM* = 570 + SV_CACHEDOPENLIMIT_PARMNUM* = 571 + SV_CRITICALTHREADS_PARMNUM* = 572 + SV_RESTRICTNULLSESSACCESS_PARMNUM* = 573 + SV_ENABLEWFW311DIRECTIPX_PARMNUM* = 574 + SV_OTHERQUEUEAFFINITY_PARMNUM* = 575 + SV_QUEUESAMPLESECS_PARMNUM* = 576 + SV_BALANCECOUNT_PARMNUM* = 577 + SV_PREFERREDAFFINITY_PARMNUM* = 578 + SV_MAXFREERFCBS_PARMNUM* = 579 + SV_MAXFREEMFCBS_PARMNUM* = 580 + SV_MAXFREELFCBS_PARMNUM* = 581 + SV_MAXFREEPAGEDPOOLCHUNKS_PARMNUM* = 582 + SV_MINPAGEDPOOLCHUNKSIZE_PARMNUM* = 583 + SV_MAXPAGEDPOOLCHUNKSIZE_PARMNUM* = 584 + SV_SENDSFROMPREFERREDPROCESSOR_PARMNUM* = 585 + SV_MAXTHREADSPERQUEUE_PARMNUM* = 586 + SV_CACHEDDIRECTORYLIMIT_PARMNUM* = 587 + SV_MAXCOPYLENGTH_PARMNUM* = 588 + SV_ENABLECOMPRESSION_PARMNUM* = 590 + SV_AUTOSHAREWKS_PARMNUM* = 591 + SV_AUTOSHARESERVER_PARMNUM* = 592 + SV_ENABLESECURITYSIGNATURE_PARMNUM* = 593 + SV_REQUIRESECURITYSIGNATURE_PARMNUM* = 594 + SV_MINCLIENTBUFFERSIZE_PARMNUM* = 595 + SV_CONNECTIONNOSESSIONSTIMEOUT_PARMNUM* = 596 + SV_IDLETHREADTIMEOUT_PARMNUM* = 597 + SV_ENABLEW9XSECURITYSIGNATURE_PARMNUM* = 598 + SV_ENFORCEKERBEROSREAUTHENTICATION_PARMNUM* = 599 + SV_DISABLEDOS_PARMNUM* = 600 + SV_LOWDISKSPACEMINIMUM_PARMNUM* = 601 + SV_DISABLESTRICTNAMECHECKING_PARMNUM* = 602 + SV_COMMENT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_COMMENT_PARMNUM + SV_USERS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_USERS_PARMNUM + SV_DISC_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_DISC_PARMNUM + SV_HIDDEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_HIDDEN_PARMNUM + SV_ANNOUNCE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ANNOUNCE_PARMNUM + SV_ANNDELTA_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ANNDELTA_PARMNUM + SV_SESSOPENS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SESSOPENS_PARMNUM + SV_SESSVCS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SESSVCS_PARMNUM + SV_OPENSEARCH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_OPENSEARCH_PARMNUM + SV_MAXWORKITEMS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXWORKITEMS_PARMNUM + SV_MAXRAWBUFLEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXRAWBUFLEN_PARMNUM + SV_SESSUSERS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SESSUSERS_PARMNUM + SV_SESSCONNS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SESSCONNS_PARMNUM + SV_MAXNONPAGEDMEMORYUSAGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXNONPAGEDMEMORYUSAGE_PARMNUM + SV_MAXPAGEDMEMORYUSAGE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXPAGEDMEMORYUSAGE_PARMNUM + SV_ENABLESOFTCOMPAT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLESOFTCOMPAT_PARMNUM + SV_ENABLEFORCEDLOGOFF_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEFORCEDLOGOFF_PARMNUM + SV_TIMESOURCE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_TIMESOURCE_PARMNUM + SV_LMANNOUNCE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LMANNOUNCE_PARMNUM + SV_MAXCOPYREADLEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXCOPYREADLEN_PARMNUM + SV_MAXCOPYWRITELEN_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXCOPYWRITELEN_PARMNUM + SV_MINKEEPSEARCH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINKEEPSEARCH_PARMNUM + SV_MAXKEEPSEARCH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXKEEPSEARCH_PARMNUM + SV_MINKEEPCOMPLSEARCH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINKEEPCOMPLSEARCH_PARMNUM + SV_MAXKEEPCOMPLSEARCH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXKEEPCOMPLSEARCH_PARMNUM + SV_SCAVTIMEOUT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SCAVTIMEOUT_PARMNUM + SV_MINRCVQUEUE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINRCVQUEUE_PARMNUM + SV_MINFREEWORKITEMS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINFREEWORKITEMS_PARMNUM + SV_MAXMPXCT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXMPXCT_PARMNUM + SV_OPLOCKBREAKWAIT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_OPLOCKBREAKWAIT_PARMNUM + SV_OPLOCKBREAKRESPONSEWAIT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_OPLOCKBREAKRESPONSEWAIT_PARMNUM + SV_ENABLEOPLOCKS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEOPLOCKS_PARMNUM + SV_ENABLEOPLOCKFORCECLOSE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEOPLOCKFORCECLOSE_PARMNUM + SV_ENABLEFCBOPENS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEFCBOPENS_PARMNUM + SV_ENABLERAW_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLERAW_PARMNUM + SV_ENABLESHAREDNETDRIVES_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLESHAREDNETDRIVES_PARMNUM + SV_MINFREECONNECTIONS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINFREECONNECTIONS_PARMNUM + SV_MAXFREECONNECTIONS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXFREECONNECTIONS_PARMNUM + SV_INITSESSTABLE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_INITSESSTABLE_PARMNUM + SV_INITCONNTABLE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_INITCONNTABLE_PARMNUM + SV_INITFILETABLE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_INITFILETABLE_PARMNUM + SV_INITSEARCHTABLE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_INITSEARCHTABLE_PARMNUM + SV_ALERTSCHEDULE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ALERTSCHEDULE_PARMNUM + SV_ERRORTHRESHOLD_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ERRORTHRESHOLD_PARMNUM + SV_NETWORKERRORTHRESHOLD_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_NETWORKERRORTHRESHOLD_PARMNUM + SV_DISKSPACETHRESHOLD_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_DISKSPACETHRESHOLD_PARMNUM + SV_MAXLINKDELAY_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXLINKDELAY_PARMNUM + SV_MINLINKTHROUGHPUT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINLINKTHROUGHPUT_PARMNUM + SV_LINKINFOVALIDTIME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LINKINFOVALIDTIME_PARMNUM + SV_SCAVQOSINFOUPDATETIME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SCAVQOSINFOUPDATETIME_PARMNUM + SV_MAXWORKITEMIDLETIME_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXWORKITEMIDLETIME_PARMNUM + SV_MAXRAWWORKITEMS_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXRAWWORKITEMS_PARMNUM + SV_PRODUCTTYPE_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_PRODUCTTYPE_PARMNUM + SV_SERVERSIZE_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SERVERSIZE_PARMNUM + SV_CONNECTIONLESSAUTODISC_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_CONNECTIONLESSAUTODISC_PARMNUM + SV_SHARINGVIOLATIONRETRIES_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SHARINGVIOLATIONRETRIES_PARMNUM + SV_SHARINGVIOLATIONDELAY_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SHARINGVIOLATIONDELAY_PARMNUM + SV_MAXGLOBALOPENSEARCH_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXGLOBALOPENSEARCH_PARMNUM + SV_REMOVEDUPLICATESEARCHES_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_REMOVEDUPLICATESEARCHES_PARMNUM + SV_LOCKVIOLATIONRETRIES_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LOCKVIOLATIONRETRIES_PARMNUM + SV_LOCKVIOLATIONOFFSET_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LOCKVIOLATIONOFFSET_PARMNUM + SV_LOCKVIOLATIONDELAY_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LOCKVIOLATIONDELAY_PARMNUM + SV_MDLREADSWITCHOVER_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MDLREADSWITCHOVER_PARMNUM + SV_CACHEDOPENLIMIT_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_CACHEDOPENLIMIT_PARMNUM + SV_CRITICALTHREADS_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_CRITICALTHREADS_PARMNUM + SV_RESTRICTNULLSESSACCESS_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_RESTRICTNULLSESSACCESS_PARMNUM + SV_ENABLEWFW311DIRECTIPX_INFOLOEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEWFW311DIRECTIPX_PARMNUM + SV_OTHERQUEUEAFFINITY_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_OTHERQUEUEAFFINITY_PARMNUM + SV_QUEUESAMPLESECS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_QUEUESAMPLESECS_PARMNUM + SV_BALANCECOUNT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_BALANCECOUNT_PARMNUM + SV_PREFERREDAFFINITY_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_PREFERREDAFFINITY_PARMNUM + SV_MAXFREERFCBS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXFREERFCBS_PARMNUM + SV_MAXFREEMFCBS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXFREEMFCBS_PARMNUM + SV_MAXFREELFCBS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXFREELFCBS_PARMNUM + SV_MAXFREEPAGEDPOOLCHUNKS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXFREEPAGEDPOOLCHUNKS_PARMNUM + SV_MINPAGEDPOOLCHUNKSIZE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINPAGEDPOOLCHUNKSIZE_PARMNUM + SV_MAXPAGEDPOOLCHUNKSIZE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXPAGEDPOOLCHUNKSIZE_PARMNUM + SV_SENDSFROMPREFERREDPROCESSOR_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_SENDSFROMPREFERREDPROCESSOR_PARMNUM + SV_MAXTHREADSPERQUEUE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXTHREADSPERQUEUE_PARMNUM + SV_CACHEDDIRECTORYLIMIT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_CACHEDDIRECTORYLIMIT_PARMNUM + SV_MAXCOPYLENGTH_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MAXCOPYLENGTH_PARMNUM + SV_ENABLECOMPRESSION_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLECOMPRESSION_PARMNUM + SV_AUTOSHAREWKS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_AUTOSHAREWKS_PARMNUM + SV_AUTOSHARESERVER_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_AUTOSHARESERVER_PARMNUM + SV_ENABLESECURITYSIGNATURE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLESECURITYSIGNATURE_PARMNUM + SV_REQUIRESECURITYSIGNATURE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_REQUIRESECURITYSIGNATURE_PARMNUM + SV_MINCLIENTBUFFERSIZE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_MINCLIENTBUFFERSIZE_PARMNUM + SV_CONNECTIONNOSESSIONSTIMEOUT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_CONNECTIONNOSESSIONSTIMEOUT_PARMNUM + SV_IDLETHREADTIMEOUT_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_IDLETHREADTIMEOUT_PARMNUM + SV_ENABLEW9XSECURITYSIGNATURE_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENABLEW9XSECURITYSIGNATURE_PARMNUM + SV_ENFORCEKERBEROSREAUTHENTICATION_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_ENFORCEKERBEROSREAUTHENTICATION_PARMNUM + SV_DISABLEDOS_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_DISABLEDOS_PARMNUM + SV_LOWDISKSPACEMINIMUM_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_LOWDISKSPACEMINIMUM_PARMNUM + SV_DISABLESTRICTNAMECHECKING_INFOLEVEL* = PARMNUM_BASE_INFOLEVEL+SV_DISABLESTRICTNAMECHECKING_PARMNUM + SVI1_NUM_ELEMENTS* = 5 + SVI2_NUM_ELEMENTS* = 40 + SVI3_NUM_ELEMENTS* = 44 + SV_MAX_CMD_LEN* = PATHLEN + SW_AUTOPROF_LOAD_MASK* = 0x1 + SW_AUTOPROF_SAVE_MASK* = 0x2 + SV_MAX_SRV_HEUR_LEN* = 32 + SV_USERS_PER_LICENSE* = 5 + SVTI2_REMAP_PIPE_NAMES* = 0x2 + SERVICE_WORKSTATION* = "LanmanWorkstation" + SERVICE_LM20_WORKSTATION* = "WORKSTATION" + WORKSTATION_DISPLAY_NAME* = "Workstation" + SERVICE_SERVER* = "LanmanServer" + SERVICE_LM20_SERVER* = "SERVER" + SERVER_DISPLAY_NAME* = "Server" + SERVICE_BROWSER* = "BROWSER" + SERVICE_LM20_BROWSER* = SERVICE_BROWSER + SERVICE_MESSENGER* = "MESSENGER" + SERVICE_LM20_MESSENGER* = SERVICE_MESSENGER + SERVICE_NETRUN* = "NETRUN" + SERVICE_LM20_NETRUN* = SERVICE_NETRUN + SERVICE_SPOOLER* = "SPOOLER" + SERVICE_LM20_SPOOLER* = SERVICE_SPOOLER + SERVICE_ALERTER* = "ALERTER" + SERVICE_LM20_ALERTER* = SERVICE_ALERTER + SERVICE_NETLOGON* = "NETLOGON" + SERVICE_LM20_NETLOGON* = SERVICE_NETLOGON + SERVICE_NETPOPUP* = "NETPOPUP" + SERVICE_LM20_NETPOPUP* = SERVICE_NETPOPUP + SERVICE_SQLSERVER* = "SQLSERVER" + SERVICE_LM20_SQLSERVER* = SERVICE_SQLSERVER + SERVICE_REPL* = "REPLICATOR" + SERVICE_LM20_REPL* = SERVICE_REPL + SERVICE_RIPL* = "REMOTEBOOT" + SERVICE_LM20_RIPL* = SERVICE_RIPL + SERVICE_TIMESOURCE* = "TIMESOURCE" + SERVICE_LM20_TIMESOURCE* = SERVICE_TIMESOURCE + SERVICE_AFP* = "AFP" + SERVICE_LM20_AFP* = SERVICE_AFP + SERVICE_UPS* = "UPS" + SERVICE_LM20_UPS* = SERVICE_UPS + SERVICE_XACTSRV* = "XACTSRV" + SERVICE_LM20_XACTSRV* = SERVICE_XACTSRV + SERVICE_TCPIP* = "TCPIP" + SERVICE_LM20_TCPIP* = SERVICE_TCPIP + SERVICE_NBT* = "NBT" + SERVICE_LM20_NBT* = SERVICE_NBT + SERVICE_LMHOSTS* = "LMHOSTS" + SERVICE_LM20_LMHOSTS* = SERVICE_LMHOSTS + SERVICE_TELNET* = "Telnet" + SERVICE_LM20_TELNET* = SERVICE_TELNET + SERVICE_SCHEDULE* = "Schedule" + SERVICE_LM20_SCHEDULE* = SERVICE_SCHEDULE + SERVICE_NTLMSSP* = "NtLmSsp" + SERVICE_DHCP* = "DHCP" + SERVICE_LM20_DHCP* = SERVICE_DHCP + SERVICE_NWSAP* = "NwSapAgent" + SERVICE_LM20_NWSAP* = SERVICE_NWSAP + NWSAP_DISPLAY_NAME* = "NW Sap Agent" + SERVICE_NWCS* = "NWCWorkstation" + SERVICE_DNS_CACHE* = "DnsCache" + SERVICE_W32TIME* = "w32time" + SERVCE_LM20_W32TIME* = SERVICE_W32TIME + SERVICE_KDC* = "kdc" + SERVICE_LM20_KDC* = SERVICE_KDC + SERVICE_RPCLOCATOR* = "RPCLOCATOR" + SERVICE_LM20_RPCLOCATOR* = SERVICE_RPCLOCATOR + SERVICE_TRKSVR* = "TrkSvr" + SERVICE_LM20_TRKSVR* = SERVICE_TRKSVR + SERVICE_TRKWKS* = "TrkWks" + SERVICE_LM20_TRKWKS* = SERVICE_TRKWKS + SERVICE_NTFRS* = "NtFrs" + SERVICE_LM20_NTFRS* = SERVICE_NTFRS + SERVICE_ISMSERV* = "IsmServ" + SERVICE_LM20_ISMSERV* = SERVICE_ISMSERV + SERVICE_INSTALL_STATE* = 0x03 + SERVICE_UNINSTALLED* = 0x00 + SERVICE_INSTALL_PENDING* = 0x01 + SERVICE_UNINSTALL_PENDING* = 0x02 + SERVICE_INSTALLED* = 0x03 + SERVICE_PAUSE_STATE* = 0x0C + LM20_SERVICE_ACTIVE* = 0x00 + LM20_SERVICE_CONTINUE_PENDING* = 0x04 + LM20_SERVICE_PAUSE_PENDING* = 0x08 + LM20_SERVICE_PAUSED* = 0x0C + SERVICE_NOT_UNINSTALLABLE* = 0x00 + SERVICE_UNINSTALLABLE* = 0x10 + SERVICE_NOT_PAUSABLE* = 0x00 + SERVICE_PAUSABLE* = 0x20 + SERVICE_REDIR_PAUSED* = 0x700 + SERVICE_REDIR_DISK_PAUSED* = 0x100 + SERVICE_REDIR_PRINT_PAUSED* = 0x200 + SERVICE_REDIR_COMM_PAUSED* = 0x400 + SERVICE_DOS_ENCRYPTION* = "ENCRYPT" + SERVICE_CTRL_INTERROGATE* = 0 + SERVICE_CTRL_PAUSE* = 1 + SERVICE_CTRL_CONTINUE* = 2 + SERVICE_CTRL_UNINSTALL* = 3 + SERVICE_CTRL_REDIR_DISK* = 0x1 + SERVICE_CTRL_REDIR_PRINT* = 0x2 + SERVICE_CTRL_REDIR_COMM* = 0x4 + SERVICE_IP_NO_HINT* = 0x0 + SERVICE_CCP_NO_HINT* = 0x0 + SERVICE_IP_QUERY_HINT* = 0x10000 + SERVICE_CCP_QUERY_HINT* = 0x10000 + SERVICE_IP_CHKPT_NUM* = 0x0FF + SERVICE_CCP_CHKPT_NUM* = 0x0FF + SERVICE_IP_WAIT_TIME* = 0x0FF00 + SERVICE_CCP_WAIT_TIME* = 0x0FF00 + SERVICE_IP_WAITTIME_SHIFT* = 8 + SERVICE_NTIP_WAITTIME_SHIFT* = 12 + UPPER_HINT_MASK* = 0x0000FF00 + LOWER_HINT_MASK* = 0x000000FF + UPPER_GET_HINT_MASK* = 0x0FF00000 + LOWER_GET_HINT_MASK* = 0x0000FF00 + SERVICE_NT_MAXTIME* = 0x0000FFFF + SERVICE_RESRV_MASK* = 0x0001FFFF + SERVICE_MAXTIME* = 0x000000FF + SERVICE_BASE* = 3050 + SERVICE_UIC_NORMAL* = 0 + SERVICE_UIC_BADPARMVAL* = SERVICE_BASE+1 + SERVICE_UIC_MISSPARM* = SERVICE_BASE+2 + SERVICE_UIC_UNKPARM* = SERVICE_BASE+3 + SERVICE_UIC_RESOURCE* = SERVICE_BASE+4 + SERVICE_UIC_CONFIG* = SERVICE_BASE+5 + SERVICE_UIC_SYSTEM* = SERVICE_BASE+6 + SERVICE_UIC_INTERNAL* = SERVICE_BASE+7 + SERVICE_UIC_AMBIGPARM* = SERVICE_BASE+8 + SERVICE_UIC_DUPPARM* = SERVICE_BASE+9 + SERVICE_UIC_KILL* = SERVICE_BASE+10 + SERVICE_UIC_EXEC* = SERVICE_BASE+11 + SERVICE_UIC_SUBSERV* = SERVICE_BASE+12 + SERVICE_UIC_CONFLPARM* = SERVICE_BASE+13 + SERVICE_UIC_FILE* = SERVICE_BASE+14 + SERVICE_UIC_M_NULL* = 0 + SERVICE_UIC_M_MEMORY* = SERVICE_BASE+20 + SERVICE_UIC_M_DISK* = SERVICE_BASE+21 + SERVICE_UIC_M_THREADS* = SERVICE_BASE+22 + SERVICE_UIC_M_PROCESSES* = SERVICE_BASE+23 + SERVICE_UIC_M_SECURITY* = SERVICE_BASE+24 + SERVICE_UIC_M_LANROOT* = SERVICE_BASE+25 + SERVICE_UIC_M_REDIR* = SERVICE_BASE+26 + SERVICE_UIC_M_SERVER* = SERVICE_BASE+27 + SERVICE_UIC_M_SEC_FILE_ERR* = SERVICE_BASE+28 + SERVICE_UIC_M_FILES* = SERVICE_BASE+29 + SERVICE_UIC_M_LOGS* = SERVICE_BASE+30 + SERVICE_UIC_M_LANGROUP* = SERVICE_BASE+31 + SERVICE_UIC_M_MSGNAME* = SERVICE_BASE+32 + SERVICE_UIC_M_ANNOUNCE* = SERVICE_BASE+33 + SERVICE_UIC_M_UAS* = SERVICE_BASE+34 + SERVICE_UIC_M_SERVER_SEC_ERR* = SERVICE_BASE+35 + SERVICE_UIC_M_WKSTA* = SERVICE_BASE+37 + SERVICE_UIC_M_ERRLOG* = SERVICE_BASE+38 + SERVICE_UIC_M_FILE_UW* = SERVICE_BASE+39 + SERVICE_UIC_M_ADDPAK* = SERVICE_BASE+40 + SERVICE_UIC_M_LAZY* = SERVICE_BASE+41 + SERVICE_UIC_M_UAS_MACHINE_ACCT* = SERVICE_BASE+42 + SERVICE_UIC_M_UAS_SERVERS_NMEMB* = SERVICE_BASE+43 + SERVICE_UIC_M_UAS_SERVERS_NOGRP* = SERVICE_BASE+44 + SERVICE_UIC_M_UAS_INVALID_ROLE* = SERVICE_BASE+45 + SERVICE_UIC_M_NETLOGON_NO_DC* = SERVICE_BASE+46 + SERVICE_UIC_M_NETLOGON_DC_CFLCT* = SERVICE_BASE+47 + SERVICE_UIC_M_NETLOGON_AUTH* = SERVICE_BASE+48 + SERVICE_UIC_M_UAS_PROLOG* = SERVICE_BASE+49 + SERVICE2_BASE* = 5600 + SERVICE_UIC_M_NETLOGON_MPATH* = SERVICE2_BASE+0 + SERVICE_UIC_M_LSA_MACHINE_ACCT* = SERVICE2_BASE+1 + SERVICE_UIC_M_DATABASE_ERROR* = SERVICE2_BASE+2 + USE_NOFORCE* = 0 + USE_FORCE* = 1 + USE_LOTS_OF_FORCE* = 2 + USE_LOCAL_PARMNUM* = 1 + USE_REMOTE_PARMNUM* = 2 + USE_PASSWORD_PARMNUM* = 3 + USE_ASGTYPE_PARMNUM* = 4 + USE_USERNAME_PARMNUM* = 5 + USE_DOMAINNAME_PARMNUM* = 6 + USE_OK* = 0 + USE_PAUSED* = 1 + USE_SESSLOST* = 2 + USE_DISCONN* = 2 + USE_NETERR* = 3 + USE_CONN* = 4 + USE_RECONN* = 5 + USE_DISKDEV* = 0 + USE_SPOOLDEV* = 1 + USE_CHARDEV* = 2 + USE_IPC* = 3 + CREATE_NO_CONNECT* = 0x1 + CREATE_BYPASS_CSC* = 0x2 + USE_DEFAULT_CREDENTIALS* = 0x4 + WKSTA_PLATFORM_ID_PARMNUM* = 100 + WKSTA_COMPUTERNAME_PARMNUM* = 1 + WKSTA_LANGROUP_PARMNUM* = 2 + WKSTA_VER_MAJOR_PARMNUM* = 4 + WKSTA_VER_MINOR_PARMNUM* = 5 + WKSTA_LOGGED_ON_USERS_PARMNUM* = 6 + WKSTA_LANROOT_PARMNUM* = 7 + WKSTA_LOGON_DOMAIN_PARMNUM* = 8 + WKSTA_LOGON_SERVER_PARMNUM* = 9 + WKSTA_CHARWAIT_PARMNUM* = 10 + WKSTA_CHARTIME_PARMNUM* = 11 + WKSTA_CHARCOUNT_PARMNUM* = 12 + WKSTA_KEEPCONN_PARMNUM* = 13 + WKSTA_KEEPSEARCH_PARMNUM* = 14 + WKSTA_MAXCMDS_PARMNUM* = 15 + WKSTA_NUMWORKBUF_PARMNUM* = 16 + WKSTA_MAXWRKCACHE_PARMNUM* = 17 + WKSTA_SESSTIMEOUT_PARMNUM* = 18 + WKSTA_SIZERROR_PARMNUM* = 19 + WKSTA_NUMALERTS_PARMNUM* = 20 + WKSTA_NUMSERVICES_PARMNUM* = 21 + WKSTA_NUMCHARBUF_PARMNUM* = 22 + WKSTA_SIZCHARBUF_PARMNUM* = 23 + WKSTA_ERRLOGSZ_PARMNUM* = 27 + WKSTA_PRINTBUFTIME_PARMNUM* = 28 + WKSTA_SIZWORKBUF_PARMNUM* = 29 + WKSTA_MAILSLOTS_PARMNUM* = 30 + WKSTA_NUMDGRAMBUF_PARMNUM* = 31 + WKSTA_WRKHEURISTICS_PARMNUM* = 32 + WKSTA_MAXTHREADS_PARMNUM* = 33 + WKSTA_LOCKQUOTA_PARMNUM* = 41 + WKSTA_LOCKINCREMENT_PARMNUM* = 42 + WKSTA_LOCKMAXIMUM_PARMNUM* = 43 + WKSTA_PIPEINCREMENT_PARMNUM* = 44 + WKSTA_PIPEMAXIMUM_PARMNUM* = 45 + WKSTA_DORMANTFILELIMIT_PARMNUM* = 46 + WKSTA_CACHEFILETIMEOUT_PARMNUM* = 47 + WKSTA_USEOPPORTUNISTICLOCKING_PARMNUM* = 48 + WKSTA_USEUNLOCKBEHIND_PARMNUM* = 49 + WKSTA_USECLOSEBEHIND_PARMNUM* = 50 + WKSTA_BUFFERNAMEDPIPES_PARMNUM* = 51 + WKSTA_USELOCKANDREADANDUNLOCK_PARMNUM* = 52 + WKSTA_UTILIZENTCACHING_PARMNUM* = 53 + WKSTA_USERAWREAD_PARMNUM* = 54 + WKSTA_USERAWWRITE_PARMNUM* = 55 + WKSTA_USEWRITERAWWITHDATA_PARMNUM* = 56 + WKSTA_USEENCRYPTION_PARMNUM* = 57 + WKSTA_BUFFILESWITHDENYWRITE_PARMNUM* = 58 + WKSTA_BUFFERREADONLYFILES_PARMNUM* = 59 + WKSTA_FORCECORECREATEMODE_PARMNUM* = 60 + WKSTA_USE512BYTESMAXTRANSFER_PARMNUM* = 61 + WKSTA_READAHEADTHRUPUT_PARMNUM* = 62 + WKSTA_OTH_DOMAINS_PARMNUM* = 101 + TRANSPORT_QUALITYOFSERVICE_PARMNUM* = 201 + TRANSPORT_NAME_PARMNUM* = 202 + LOGFLAGS_FORWARD* = 0 + LOGFLAGS_BACKWARD* = 0x1 + LOGFLAGS_SEEK* = 0x2 + ERRLOG_BASE* = 3100 + NELOG_Internal_Error* = ERRLOG_BASE+0 + NELOG_Resource_Shortage* = ERRLOG_BASE+1 + NELOG_Unable_To_Lock_Segment* = ERRLOG_BASE+2 + NELOG_Unable_To_Unlock_Segment* = ERRLOG_BASE+3 + NELOG_Uninstall_Service* = ERRLOG_BASE+4 + NELOG_Init_Exec_Fail* = ERRLOG_BASE+5 + NELOG_Ncb_Error* = ERRLOG_BASE+6 + NELOG_Net_Not_Started* = ERRLOG_BASE+7 + NELOG_Ioctl_Error* = ERRLOG_BASE+8 + NELOG_System_Semaphore* = ERRLOG_BASE+9 + NELOG_Init_OpenCreate_Err* = ERRLOG_BASE+10 + NELOG_NetBios* = ERRLOG_BASE+11 + NELOG_SMB_Illegal* = ERRLOG_BASE+12 + NELOG_Service_Fail* = ERRLOG_BASE+13 + NELOG_Entries_Lost* = ERRLOG_BASE+14 + NELOG_Init_Seg_Overflow* = ERRLOG_BASE+20 + NELOG_Srv_No_Mem_Grow* = ERRLOG_BASE+21 + NELOG_Access_File_Bad* = ERRLOG_BASE+22 + NELOG_Srvnet_Not_Started* = ERRLOG_BASE+23 + NELOG_Init_Chardev_Err* = ERRLOG_BASE+24 + NELOG_Remote_API* = ERRLOG_BASE+25 + NELOG_Ncb_TooManyErr* = ERRLOG_BASE+26 + NELOG_Mailslot_err* = ERRLOG_BASE+27 + NELOG_ReleaseMem_Alert* = ERRLOG_BASE+28 + NELOG_AT_cannot_write* = ERRLOG_BASE+29 + NELOG_Cant_Make_Msg_File* = ERRLOG_BASE+30 + NELOG_Exec_Netservr_NoMem* = ERRLOG_BASE+31 + NELOG_Server_Lock_Failure* = ERRLOG_BASE+32 + NELOG_Msg_Shutdown* = ERRLOG_BASE+40 + NELOG_Msg_Sem_Shutdown* = ERRLOG_BASE+41 + NELOG_Msg_Log_Err* = ERRLOG_BASE+50 + NELOG_VIO_POPUP_ERR* = ERRLOG_BASE+51 + NELOG_Msg_Unexpected_SMB_Type* = ERRLOG_BASE+52 + NELOG_Wksta_Infoseg* = ERRLOG_BASE+60 + NELOG_Wksta_Compname* = ERRLOG_BASE+61 + NELOG_Wksta_BiosThreadFailure* = ERRLOG_BASE+62 + NELOG_Wksta_IniSeg* = ERRLOG_BASE+63 + NELOG_Wksta_HostTab_Full* = ERRLOG_BASE+64 + NELOG_Wksta_Bad_Mailslot_SMB* = ERRLOG_BASE+65 + NELOG_Wksta_UASInit* = ERRLOG_BASE+66 + NELOG_Wksta_SSIRelogon* = ERRLOG_BASE+67 + NELOG_Build_Name* = ERRLOG_BASE+70 + NELOG_Name_Expansion* = ERRLOG_BASE+71 + NELOG_Message_Send* = ERRLOG_BASE+72 + NELOG_Mail_Slt_Err* = ERRLOG_BASE+73 + NELOG_AT_cannot_read* = ERRLOG_BASE+74 + NELOG_AT_sched_err* = ERRLOG_BASE+75 + NELOG_AT_schedule_file_created* = ERRLOG_BASE+76 + NELOG_Srvnet_NB_Open* = ERRLOG_BASE+77 + NELOG_AT_Exec_Err* = ERRLOG_BASE+78 + NELOG_Lazy_Write_Err* = ERRLOG_BASE+80 + NELOG_HotFix* = ERRLOG_BASE+81 + NELOG_HardErr_From_Server* = ERRLOG_BASE+82 + NELOG_LocalSecFail1* = ERRLOG_BASE+83 + NELOG_LocalSecFail2* = ERRLOG_BASE+84 + NELOG_LocalSecFail3* = ERRLOG_BASE+85 + NELOG_LocalSecGeneralFail* = ERRLOG_BASE+86 + NELOG_NetWkSta_Internal_Error* = ERRLOG_BASE+90 + NELOG_NetWkSta_No_Resource* = ERRLOG_BASE+91 + NELOG_NetWkSta_SMB_Err* = ERRLOG_BASE+92 + NELOG_NetWkSta_VC_Err* = ERRLOG_BASE+93 + NELOG_NetWkSta_Stuck_VC_Err* = ERRLOG_BASE+94 + NELOG_NetWkSta_NCB_Err* = ERRLOG_BASE+95 + NELOG_NetWkSta_Write_Behind_Err* = ERRLOG_BASE+96 + NELOG_NetWkSta_Reset_Err* = ERRLOG_BASE+97 + NELOG_NetWkSta_Too_Many* = ERRLOG_BASE+98 + NELOG_Srv_Thread_Failure* = ERRLOG_BASE+104 + NELOG_Srv_Close_Failure* = ERRLOG_BASE+105 + NELOG_ReplUserCurDir* = ERRLOG_BASE+106 + NELOG_ReplCannotMasterDir* = ERRLOG_BASE+107 + NELOG_ReplUpdateError* = ERRLOG_BASE+108 + NELOG_ReplLostMaster* = ERRLOG_BASE+109 + NELOG_NetlogonAuthDCFail* = ERRLOG_BASE+110 + NELOG_ReplLogonFailed* = ERRLOG_BASE+111 + NELOG_ReplNetErr* = ERRLOG_BASE+112 + NELOG_ReplMaxFiles* = ERRLOG_BASE+113 + NELOG_ReplMaxTreeDepth* = ERRLOG_BASE+114 + NELOG_ReplBadMsg* = ERRLOG_BASE+115 + NELOG_ReplSysErr* = ERRLOG_BASE+116 + NELOG_ReplUserLoged* = ERRLOG_BASE+117 + NELOG_ReplBadImport* = ERRLOG_BASE+118 + NELOG_ReplBadExport* = ERRLOG_BASE+119 + NELOG_ReplSignalFileErr* = ERRLOG_BASE+120 + NELOG_DiskFT* = ERRLOG_BASE+121 + NELOG_ReplAccessDenied* = ERRLOG_BASE+122 + NELOG_NetlogonFailedPrimary* = ERRLOG_BASE+123 + NELOG_NetlogonPasswdSetFailed* = ERRLOG_BASE+124 + NELOG_NetlogonTrackingError* = ERRLOG_BASE+125 + NELOG_NetlogonSyncError* = ERRLOG_BASE+126 + NELOG_NetlogonRequireSignOrSealError* = ERRLOG_BASE+127 + NELOG_UPS_PowerOut* = ERRLOG_BASE+130 + NELOG_UPS_Shutdown* = ERRLOG_BASE+131 + NELOG_UPS_CmdFileError* = ERRLOG_BASE+132 + NELOG_UPS_CannotOpenDriver* = ERRLOG_BASE+133 + NELOG_UPS_PowerBack* = ERRLOG_BASE+134 + NELOG_UPS_CmdFileConfig* = ERRLOG_BASE+135 + NELOG_UPS_CmdFileExec* = ERRLOG_BASE+136 + NELOG_Missing_Parameter* = ERRLOG_BASE+150 + NELOG_Invalid_Config_Line* = ERRLOG_BASE+151 + NELOG_Invalid_Config_File* = ERRLOG_BASE+152 + NELOG_File_Changed* = ERRLOG_BASE+153 + NELOG_Files_Dont_Fit* = ERRLOG_BASE+154 + NELOG_Wrong_DLL_Version* = ERRLOG_BASE+155 + NELOG_Error_in_DLL* = ERRLOG_BASE+156 + NELOG_System_Error* = ERRLOG_BASE+157 + NELOG_FT_ErrLog_Too_Large* = ERRLOG_BASE+158 + NELOG_FT_Update_In_Progress* = ERRLOG_BASE+159 + NELOG_Joined_Domain* = ERRLOG_BASE+160 + NELOG_Joined_Workgroup* = ERRLOG_BASE+161 + NELOG_OEM_Code* = ERRLOG_BASE+199 + ERRLOG2_BASE* = 5700 + NELOG_NetlogonSSIInitError* = ERRLOG2_BASE+0 + NELOG_NetlogonFailedToUpdateTrustList* = ERRLOG2_BASE+1 + NELOG_NetlogonFailedToAddRpcInterface* = ERRLOG2_BASE+2 + NELOG_NetlogonFailedToReadMailslot* = ERRLOG2_BASE+3 + NELOG_NetlogonFailedToRegisterSC* = ERRLOG2_BASE+4 + NELOG_NetlogonChangeLogCorrupt* = ERRLOG2_BASE+5 + NELOG_NetlogonFailedToCreateShare* = ERRLOG2_BASE+6 + NELOG_NetlogonDownLevelLogonFailed* = ERRLOG2_BASE+7 + NELOG_NetlogonDownLevelLogoffFailed* = ERRLOG2_BASE+8 + NELOG_NetlogonNTLogonFailed* = ERRLOG2_BASE+9 + NELOG_NetlogonNTLogoffFailed* = ERRLOG2_BASE+10 + NELOG_NetlogonPartialSyncCallSuccess* = ERRLOG2_BASE+11 + NELOG_NetlogonPartialSyncCallFailed* = ERRLOG2_BASE+12 + NELOG_NetlogonFullSyncCallSuccess* = ERRLOG2_BASE+13 + NELOG_NetlogonFullSyncCallFailed* = ERRLOG2_BASE+14 + NELOG_NetlogonPartialSyncSuccess* = ERRLOG2_BASE+15 + NELOG_NetlogonPartialSyncFailed* = ERRLOG2_BASE+16 + NELOG_NetlogonFullSyncSuccess* = ERRLOG2_BASE+17 + NELOG_NetlogonFullSyncFailed* = ERRLOG2_BASE+18 + NELOG_NetlogonAuthNoDomainController* = ERRLOG2_BASE+19 + NELOG_NetlogonAuthNoTrustLsaSecret* = ERRLOG2_BASE+20 + NELOG_NetlogonAuthNoTrustSamAccount* = ERRLOG2_BASE+21 + NELOG_NetlogonServerAuthFailed* = ERRLOG2_BASE+22 + NELOG_NetlogonServerAuthNoTrustSamAccount* = ERRLOG2_BASE+23 + NELOG_FailedToRegisterSC* = ERRLOG2_BASE+24 + NELOG_FailedToSetServiceStatus* = ERRLOG2_BASE+25 + NELOG_FailedToGetComputerName* = ERRLOG2_BASE+26 + NELOG_DriverNotLoaded* = ERRLOG2_BASE+27 + NELOG_NoTranportLoaded* = ERRLOG2_BASE+28 + NELOG_NetlogonFailedDomainDelta* = ERRLOG2_BASE+29 + NELOG_NetlogonFailedGlobalGroupDelta* = ERRLOG2_BASE+30 + NELOG_NetlogonFailedLocalGroupDelta* = ERRLOG2_BASE+31 + NELOG_NetlogonFailedUserDelta* = ERRLOG2_BASE+32 + NELOG_NetlogonFailedPolicyDelta* = ERRLOG2_BASE+33 + NELOG_NetlogonFailedTrustedDomainDelta* = ERRLOG2_BASE+34 + NELOG_NetlogonFailedAccountDelta* = ERRLOG2_BASE+35 + NELOG_NetlogonFailedSecretDelta* = ERRLOG2_BASE+36 + NELOG_NetlogonSystemError* = ERRLOG2_BASE+37 + NELOG_NetlogonDuplicateMachineAccounts* = ERRLOG2_BASE+38 + NELOG_NetlogonTooManyGlobalGroups* = ERRLOG2_BASE+39 + NELOG_NetlogonBrowserDriver* = ERRLOG2_BASE+40 + NELOG_NetlogonAddNameFailure* = ERRLOG2_BASE+41 + NELOG_RplMessages* = ERRLOG2_BASE+42 + NELOG_RplXnsBoot* = ERRLOG2_BASE+43 + NELOG_RplSystem* = ERRLOG2_BASE+44 + NELOG_RplWkstaTimeout* = ERRLOG2_BASE+45 + NELOG_RplWkstaFileOpen* = ERRLOG2_BASE+46 + NELOG_RplWkstaFileRead* = ERRLOG2_BASE+47 + NELOG_RplWkstaMemory* = ERRLOG2_BASE+48 + NELOG_RplWkstaFileChecksum* = ERRLOG2_BASE+49 + NELOG_RplWkstaFileLineCount* = ERRLOG2_BASE+50 + NELOG_RplWkstaBbcFile* = ERRLOG2_BASE+51 + NELOG_RplWkstaFileSize* = ERRLOG2_BASE+52 + NELOG_RplWkstaInternal* = ERRLOG2_BASE+53 + NELOG_RplWkstaWrongVersion* = ERRLOG2_BASE+54 + NELOG_RplWkstaNetwork* = ERRLOG2_BASE+55 + NELOG_RplAdapterResource* = ERRLOG2_BASE+56 + NELOG_RplFileCopy* = ERRLOG2_BASE+57 + NELOG_RplFileDelete* = ERRLOG2_BASE+58 + NELOG_RplFilePerms* = ERRLOG2_BASE+59 + NELOG_RplCheckConfigs* = ERRLOG2_BASE+60 + NELOG_RplCreateProfiles* = ERRLOG2_BASE+61 + NELOG_RplRegistry* = ERRLOG2_BASE+62 + NELOG_RplReplaceRPLDISK* = ERRLOG2_BASE+63 + NELOG_RplCheckSecurity* = ERRLOG2_BASE+64 + NELOG_RplBackupDatabase* = ERRLOG2_BASE+65 + NELOG_RplInitDatabase* = ERRLOG2_BASE+66 + NELOG_RplRestoreDatabaseFailure* = ERRLOG2_BASE+67 + NELOG_RplRestoreDatabaseSuccess* = ERRLOG2_BASE+68 + NELOG_RplInitRestoredDatabase* = ERRLOG2_BASE+69 + NELOG_NetlogonSessionTypeWrong* = ERRLOG2_BASE+70 + NELOG_RplUpgradeDBTo40* = ERRLOG2_BASE+71 + NELOG_NetlogonLanmanBdcsNotAllowed* = ERRLOG2_BASE+72 + NELOG_NetlogonNoDynamicDns* = ERRLOG2_BASE+73 + NELOG_NetlogonDynamicDnsRegisterFailure* = ERRLOG2_BASE+74 + NELOG_NetlogonDynamicDnsDeregisterFailure* = ERRLOG2_BASE+75 + NELOG_NetlogonFailedFileCreate* = ERRLOG2_BASE+76 + NELOG_NetlogonGetSubnetToSite* = ERRLOG2_BASE+77 + NELOG_NetlogonNoSiteForClient* = ERRLOG2_BASE+78 + NELOG_NetlogonBadSiteName* = ERRLOG2_BASE+79 + NELOG_NetlogonBadSubnetName* = ERRLOG2_BASE+80 + NELOG_NetlogonDynamicDnsServerFailure* = ERRLOG2_BASE+81 + NELOG_NetlogonDynamicDnsFailure* = ERRLOG2_BASE+82 + NELOG_NetlogonRpcCallCancelled* = ERRLOG2_BASE+83 + NELOG_NetlogonDcSiteCovered* = ERRLOG2_BASE+84 + NELOG_NetlogonDcSiteNotCovered* = ERRLOG2_BASE+85 + NELOG_NetlogonGcSiteCovered* = ERRLOG2_BASE+86 + NELOG_NetlogonGcSiteNotCovered* = ERRLOG2_BASE+87 + NELOG_NetlogonFailedSpnUpdate* = ERRLOG2_BASE+88 + NELOG_NetlogonFailedDnsHostNameUpdate* = ERRLOG2_BASE+89 + NELOG_NetlogonAuthNoUplevelDomainController* = ERRLOG2_BASE+90 + NELOG_NetlogonAuthDomainDowngraded* = ERRLOG2_BASE+91 + NELOG_NetlogonNdncSiteCovered* = ERRLOG2_BASE+92 + NELOG_NetlogonNdncSiteNotCovered* = ERRLOG2_BASE+93 + NELOG_NetlogonDcOldSiteCovered* = ERRLOG2_BASE+94 + NELOG_NetlogonDcSiteNotCoveredAuto* = ERRLOG2_BASE+95 + NELOG_NetlogonGcOldSiteCovered* = ERRLOG2_BASE+96 + NELOG_NetlogonGcSiteNotCoveredAuto* = ERRLOG2_BASE+97 + NELOG_NetlogonNdncOldSiteCovered* = ERRLOG2_BASE+98 + NELOG_NetlogonNdncSiteNotCoveredAuto* = ERRLOG2_BASE+99 + NELOG_NetlogonSpnMultipleSamAccountNames* = ERRLOG2_BASE+100 + NELOG_NetlogonSpnCrackNamesFailure* = ERRLOG2_BASE+101 + NELOG_NetlogonNoAddressToSiteMapping* = ERRLOG2_BASE+102 + NELOG_NetlogonInvalidGenericParameterValue* = ERRLOG2_BASE+103 + NELOG_NetlogonInvalidDwordParameterValue* = ERRLOG2_BASE+104 + NELOG_NetlogonServerAuthFailedNoAccount* = ERRLOG2_BASE+105 + NELOG_NetlogonNoDynamicDnsManual* = ERRLOG2_BASE+106 + NELOG_NetlogonNoSiteForClients* = ERRLOG2_BASE+107 + NELOG_NetlogonDnsDeregAborted* = ERRLOG2_BASE+108 + NELOG_NetlogonRpcPortRequestFailure* = ERRLOG2_BASE+109 + STATSOPT_CLR* = 1 + STATS_NO_VALUE* = -1 + STATS_OVERFLOW* = -2 + ACTION_LOCKOUT* = 00 + ACTION_ADMINUNLOCK* = 01 + AE_SRVSTATUS* = 0 + AE_SESSLOGON* = 1 + AE_SESSLOGOFF* = 2 + AE_SESSPWERR* = 3 + AE_CONNSTART* = 4 + AE_CONNSTOP* = 5 + AE_CONNREJ* = 6 + AE_RESACCESS* = 7 + AE_RESACCESSREJ* = 8 + AE_CLOSEFILE* = 9 + AE_SERVICESTAT* = 11 + AE_ACLMOD* = 12 + AE_UASMOD* = 13 + AE_NETLOGON* = 14 + AE_NETLOGOFF* = 15 + AE_NETLOGDENIED* = 16 + AE_ACCLIMITEXCD* = 17 + AE_RESACCESS2* = 18 + AE_ACLMODFAIL* = 19 + AE_LOCKOUT* = 20 + AE_GENERIC_TYPE* = 21 + AE_SRVSTART* = 0 + AE_SRVPAUSED* = 1 + AE_SRVCONT* = 2 + AE_SRVSTOP* = 3 + AE_GUEST* = 0 + AE_USER* = 1 + AE_ADMIN* = 2 + AE_NORMAL* = 0 + AE_USERLIMIT* = 0 + AE_GENERAL* = 0 + AE_ERROR* = 1 + AE_SESSDIS* = 1 + AE_BADPW* = 1 + AE_AUTODIS* = 2 + AE_UNSHARE* = 2 + AE_ADMINPRIVREQD* = 2 + AE_ADMINDIS* = 3 + AE_NOACCESSPERM* = 3 + AE_ACCRESTRICT* = 4 + AE_NORMAL_CLOSE* = 0 + AE_SES_CLOSE* = 1 + AE_ADMIN_CLOSE* = 2 + AE_LIM_UNKNOWN* = 0 + AE_LIM_LOGONHOURS* = 1 + AE_LIM_EXPIRED* = 2 + AE_LIM_INVAL_WKSTA* = 3 + AE_LIM_DISABLED* = 4 + AE_LIM_DELETED* = 5 + AE_MOD* = 0 + AE_DELETE* = 1 + AE_ADD* = 2 + AE_UAS_USER* = 0 + AE_UAS_GROUP* = 1 + AE_UAS_MODALS* = 2 + SVAUD_SERVICE* = 0x1 + SVAUD_GOODSESSLOGON* = 0x6 + SVAUD_BADSESSLOGON* = 0x18 + SVAUD_SESSLOGON* = SVAUD_GOODSESSLOGON or SVAUD_BADSESSLOGON + SVAUD_GOODNETLOGON* = 0x60 + SVAUD_BADNETLOGON* = 0x180 + SVAUD_NETLOGON* = SVAUD_GOODNETLOGON or SVAUD_BADNETLOGON + SVAUD_LOGON* = SVAUD_NETLOGON or SVAUD_SESSLOGON + SVAUD_GOODUSE* = 0x600 + SVAUD_BADUSE* = 0x1800 + SVAUD_USE* = SVAUD_GOODUSE or SVAUD_BADUSE + SVAUD_USERLIST* = 0x2000 + SVAUD_PERMISSIONS* = 0x4000 + SVAUD_RESOURCE* = 0x8000 + SVAUD_LOGONLIM* = 0x00010000 + AA_AUDIT_ALL* = 0x0001 + AA_A_OWNER* = 0x0004 + AA_CLOSE* = 0x0008 + AA_S_OPEN* = 0x0010 + AA_S_WRITE* = 0x0020 + AA_S_CREATE* = 0x0020 + AA_S_DELETE* = 0x0040 + AA_S_ACL* = 0x0080 + AA_S_ALL* = AA_S_OPEN or AA_S_WRITE or AA_S_DELETE or AA_S_ACL + AA_F_OPEN* = 0x0100 + AA_F_WRITE* = 0x0200 + AA_F_CREATE* = 0x0200 + AA_F_DELETE* = 0x0400 + AA_F_ACL* = 0x0800 + AA_F_ALL* = AA_F_OPEN or AA_F_WRITE or AA_F_DELETE or AA_F_ACL + AA_A_OPEN* = 0x1000 + AA_A_WRITE* = 0x2000 + AA_A_CREATE* = 0x2000 + AA_A_DELETE* = 0x4000 + AA_A_ACL* = 0x8000 + AA_A_ALL* = AA_F_OPEN or AA_F_WRITE or AA_F_DELETE or AA_F_ACL + netSetupUnknown* = 0 + netSetupMachine* = 1 + netSetupWorkgroup* = 2 + netSetupDomain* = 3 + netSetupNonExistentDomain* = 4 + netSetupDnsMachine* = 5 + netSetupUnknownStatus* = 0 + netSetupUnjoined* = 1 + netSetupWorkgroupName* = 2 + netSetupDomainName* = 3 + NETSETUP_JOIN_DOMAIN* = 0x00000001 + NETSETUP_ACCT_CREATE* = 0x00000002 + NETSETUP_ACCT_DELETE* = 0x00000004 + NETSETUP_WIN9X_UPGRADE* = 0x00000010 + NETSETUP_DOMAIN_JOIN_IF_JOINED* = 0x00000020 + NETSETUP_JOIN_UNSECURE* = 0x00000040 + NETSETUP_MACHINE_PWD_PASSED* = 0x00000080 + NETSETUP_DEFER_SPN_SET* = 0x00000100 + NETSETUP_INSTALL_INVOCATION* = 0x00040000 + NETSETUP_IGNORE_UNSUPPORTED_FLAGS* = 0x10000000 + NETSETUP_VALID_UNJOIN_FLAGS* = NETSETUP_ACCT_DELETE or NETSETUP_IGNORE_UNSUPPORTED_FLAGS + NET_IGNORE_UNSUPPORTED_FLAGS* = 0x01 + netPrimaryComputerName* = 0 + netAlternateComputerNames* = 1 + netAllComputerNames* = 2 + netComputerNameTypeMax* = 3 + JOB_RUN_PERIODICALLY* = 0x01 + JOB_EXEC_ERROR* = 0x02 + JOB_RUNS_TODAY* = 0x04 + JOB_ADD_CURRENT_DATE* = 0x08 + JOB_NONINTERACTIVE* = 0x10 + JOB_INPUT_FLAGS* = JOB_RUN_PERIODICALLY or JOB_ADD_CURRENT_DATE or JOB_NONINTERACTIVE + JOB_OUTPUT_FLAGS* = JOB_RUN_PERIODICALLY or JOB_EXEC_ERROR or JOB_RUNS_TODAY or JOB_NONINTERACTIVE + DFS_VOLUME_STATES* = 0xF + DFS_VOLUME_STATE_OK* = 1 + DFS_VOLUME_STATE_INCONSISTENT* = 2 + DFS_VOLUME_STATE_OFFLINE* = 3 + DFS_VOLUME_STATE_ONLINE* = 4 + DFS_VOLUME_STATE_RESYNCHRONIZE* = 0x10 + DFS_VOLUME_STATE_STANDBY* = 0x20 + DFS_VOLUME_FLAVORS* = 0x0300 + DFS_VOLUME_FLAVOR_UNUSED1* = 0x0000 + DFS_VOLUME_FLAVOR_STANDALONE* = 0x0100 + DFS_VOLUME_FLAVOR_AD_BLOB* = 0x0200 + DFS_STORAGE_FLAVOR_UNUSED2* = 0x0300 + DFS_STORAGE_STATES* = 0xF + DFS_STORAGE_STATE_OFFLINE* = 1 + DFS_STORAGE_STATE_ONLINE* = 2 + DFS_STORAGE_STATE_ACTIVE* = 4 + dfsInvalidPriorityClass* = -1 + dfsSiteCostNormalPriorityClass* = 0 + dfsGlobalHighPriorityClass* = 1 + dfsSiteCostHighPriorityClass* = 2 + dfsSiteCostLowPriorityClass* = 3 + dfsGlobalLowPriorityClass* = 4 + DFS_PROPERTY_FLAG_INSITE_REFERRALS* = 0x00000001 + DFS_PROPERTY_FLAG_ROOT_SCALABILITY* = 0x00000002 + DFS_PROPERTY_FLAG_SITE_COSTING* = 0x00000004 + DFS_PROPERTY_FLAG_TARGET_FAILBACK* = 0x00000008 + DFS_PROPERTY_FLAG_CLUSTER_ENABLED* = 0x00000010 + DFS_PROPERTY_FLAG_ABDE* = 0x00000020 + DFS_NAMESPACE_CAPABILITY_ABDE* = 0x0000000000000001 + DFS_NAMESPACE_VERSION_ORIGIN_COMBINED* = 0 + DFS_NAMESPACE_VERSION_ORIGIN_SERVER* = 1 + DFS_NAMESPACE_VERSION_ORIGIN_DOMAIN* = 2 + DFS_ADD_VOLUME* = 1 + DFS_RESTORE_VOLUME* = 2 + NET_DFS_SETDC_FLAGS* = 0x00000000 + NET_DFS_SETDC_TIMEOUT* = 0x00000001 + NET_DFS_SETDC_INITPKT* = 0x00000002 + DFS_SITE_PRIMARY* = 0x1 + DFS_MOVE_FLAG_REPLACE_IF_EXISTS* = 0x00000001 + PARM_ERROR_UNKNOWN* = DWORD(-1) + USE_WILDCARD* = DWORD(-1) + MAXDEVENTRIES* = sizeof(int32)*8 +proc NetUserAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserEnum*(servername: LPCWSTR, level: DWORD, filter: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserGetInfo*(servername: LPCWSTR, username: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserSetInfo*(servername: LPCWSTR, username: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserDel*(servername: LPCWSTR, username: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserGetGroups*(servername: LPCWSTR, username: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserSetGroups*(servername: LPCWSTR, username: LPCWSTR, level: DWORD, buf: LPBYTE, num_entries: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserGetLocalGroups*(servername: LPCWSTR, username: LPCWSTR, level: DWORD, flags: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserModalsGet*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserModalsSet*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUserChangePassword*(domainname: LPCWSTR, username: LPCWSTR, oldpassword: LPCWSTR, newpassword: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupAddUser*(servername: LPCWSTR, GroupName: LPCWSTR, username: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: PDWORD_PTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupGetInfo*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupSetInfo*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupDel*(servername: LPCWSTR, groupname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupDelUser*(servername: LPCWSTR, GroupName: LPCWSTR, Username: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupGetUsers*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, ResumeHandle: PDWORD_PTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGroupSetUsers*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, totalentries: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupAddMember*(servername: LPCWSTR, groupname: LPCWSTR, membersid: PSID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: PDWORD_PTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupGetInfo*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupSetInfo*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupDel*(servername: LPCWSTR, groupname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupDelMember*(servername: LPCWSTR, groupname: LPCWSTR, membersid: PSID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupGetMembers*(servername: LPCWSTR, localgroupname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: PDWORD_PTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupSetMembers*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, totalentries: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupAddMembers*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, totalentries: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetLocalGroupDelMembers*(servername: LPCWSTR, groupname: LPCWSTR, level: DWORD, buf: LPBYTE, totalentries: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetQueryDisplayInformation*(ServerName: LPCWSTR, Level: DWORD, Index: DWORD, EntriesRequested: DWORD, PreferredMaximumLength: DWORD, ReturnedEntryCount: LPDWORD, SortedBuffer: ptr PVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGetDisplayInformationIndex*(ServerName: LPCWSTR, Level: DWORD, Prefix: LPCWSTR, Index: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessEnum*(servername: LPCWSTR, BasePath: LPCWSTR, Recursive: DWORD, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessGetInfo*(servername: LPCWSTR, resource: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessSetInfo*(servername: LPCWSTR, resource: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessDel*(servername: LPCWSTR, resource: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc RxNetAccessGetUserPerms*(servername: LPCWSTR, UGname: LPCWSTR, resource: LPCWSTR, Perms: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetValidatePasswordPolicy*(ServerName: LPCWSTR, Qualifier: LPVOID, ValidationType: NET_VALIDATE_PASSWORD_TYPE, InputArg: LPVOID, OutputArg: ptr LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetValidatePasswordPolicyFree*(OutputArg: ptr LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGetDCName*(servername: LPCWSTR, domainname: LPCWSTR, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGetAnyDCName*(servername: LPCWSTR, domainname: LPCWSTR, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc I_NetLogonControl*(ServerName: LPCWSTR, FunctionCode: DWORD, QueryLevel: DWORD, Buffer: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc I_NetLogonControl2*(ServerName: LPCWSTR, FunctionCode: DWORD, QueryLevel: DWORD, Data: LPBYTE, Buffer: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetEnumerateTrustedDomains*(ServerName: LPWSTR, DomainNames: ptr LPWSTR): NTSTATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAddServiceAccount*(ServerName: LPWSTR, AccountName: LPWSTR, Reserved: LPWSTR, Flags: DWORD): NTSTATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRemoveServiceAccount*(ServerName: LPWSTR, AccountName: LPWSTR, Flags: DWORD): NTSTATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetIsServiceAccount*(ServerName: LPWSTR, AccountName: LPWSTR, IsService: ptr BOOL): NTSTATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetEnumerateServiceAccounts*(ServerName: LPWSTR, Flags: DWORD, AccountsCount: ptr DWORD, Accounts: ptr PZPWSTR): NTSTATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAlertRaise*(AlertEventName: LPCWSTR, Buffer: LPVOID, BufferSize: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAlertRaiseEx*(AlertEventName: LPCWSTR, VariableInfo: LPVOID, VariableInfoSize: DWORD, ServiceName: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareAdd*(servername: LMSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareEnum*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareEnumSticky*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareGetInfo*(servername: LMSTR, netname: LMSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareSetInfo*(servername: LMSTR, netname: LMSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareDel*(servername: LMSTR, netname: LMSTR, reserved: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareDelSticky*(servername: LMSTR, netname: LMSTR, reserved: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareCheck*(servername: LMSTR, device: LMSTR, `type`: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetSessionEnum*(servername: LMSTR, UncClientName: LMSTR, username: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetSessionDel*(servername: LMSTR, UncClientName: LMSTR, username: LMSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetSessionGetInfo*(servername: LMSTR, UncClientName: LMSTR, username: LMSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetConnectionEnum*(servername: LMSTR, qualifier: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetFileClose*(servername: LMSTR, fileid: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetFileEnum*(servername: LMSTR, basepath: LMSTR, username: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: PDWORD_PTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetFileGetInfo*(servername: LMSTR, fileid: DWORD, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetMessageNameAdd*(servername: LPCWSTR, msgname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetMessageNameEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetMessageNameGetInfo*(servername: LPCWSTR, msgname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetMessageNameDel*(servername: LPCWSTR, msgname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetMessageBufferSend*(servername: LPCWSTR, msgname: LPCWSTR, fromname: LPCWSTR, buf: LPBYTE, buflen: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRemoteTOD*(UncServerName: LPCWSTR, BufferPtr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRemoteComputerSupports*(UncServerName: LPCWSTR, OptionsWanted: DWORD, OptionsSupported: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplGetInfo*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplSetInfo*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirDel*(servername: LPCWSTR, dirname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirGetInfo*(servername: LPCWSTR, dirname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirSetInfo*(servername: LPCWSTR, dirname: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirLock*(servername: LPCWSTR, dirname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplExportDirUnlock*(servername: LPCWSTR, dirname: LPCWSTR, unlockforce: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirDel*(servername: LPCWSTR, dirname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirGetInfo*(servername: LPCWSTR, dirname: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirLock*(servername: LPCWSTR, dirname: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetReplImportDirUnlock*(servername: LPCWSTR, dirname: LPCWSTR, unlockforce: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerEnum*(servername: LMCSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, servertype: DWORD, domain: LMCSTR, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerEnumEx*(ServerName: LMCSTR, Level: DWORD, Bufptr: ptr LPBYTE, PrefMaxlen: DWORD, EntriesRead: LPDWORD, totalentries: LPDWORD, servertype: DWORD, domain: LMCSTR, FirstNameToReturn: LMCSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerGetInfo*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerSetInfo*(servername: LMSTR, level: DWORD, buf: LPBYTE, ParmError: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerDiskEnum*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerComputerNameAdd*(ServerName: LMSTR, EmulatedDomainName: LMSTR, EmulatedServerName: LMSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerComputerNameDel*(ServerName: LMSTR, EmulatedServerName: LMSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerTransportAdd*(servername: LMSTR, level: DWORD, bufptr: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerTransportAddEx*(servername: LMSTR, level: DWORD, bufptr: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerTransportDel*(servername: LMSTR, level: DWORD, bufptr: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServerTransportEnum*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc SetServiceBits*(hServiceStatus: SERVICE_STATUS_HANDLE, dwServiceBits: DWORD, bSetBitsOn: WINBOOL, bUpdateImmediately: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc NetServiceControl*(servername: LPCWSTR, service: LPCWSTR, opcode: DWORD, arg: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServiceEnum*(servername: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServiceGetInfo*(servername: LPCWSTR, service: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetServiceInstall*(servername: LPCWSTR, service: LPCWSTR, argc: DWORD, argv: ptr LPCWSTR, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUseAdd*(UncServerName: LMSTR, Level: DWORD, Buf: LPBYTE, ParmError: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUseDel*(UncServerName: LMSTR, UseName: LMSTR, ForceCond: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUseEnum*(UncServerName: LMSTR, Level: DWORD, BufPtr: ptr LPBYTE, PreferedMaximumSize: DWORD, EntriesRead: LPDWORD, TotalEntries: LPDWORD, ResumeHandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUseGetInfo*(UncServerName: LMSTR, UseName: LMSTR, Level: DWORD, BufPtr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaGetInfo*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaSetInfo*(servername: LMSTR, level: DWORD, buffer: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaUserGetInfo*(reserved: LMSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaUserSetInfo*(reserved: LMSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaUserEnum*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaTransportAdd*(servername: LMSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaTransportDel*(servername: LMSTR, transportname: LMSTR, ucond: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetWkstaTransportEnum*(servername: LMSTR, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resumehandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetApiBufferAllocate*(ByteCount: DWORD, Buffer: ptr LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetApiBufferFree*(Buffer: LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetApiBufferReallocate*(OldBuffer: LPVOID, NewByteCount: DWORD, NewBuffer: ptr LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetApiBufferSize*(Buffer: LPVOID, ByteCount: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetapipBufferAllocate*(ByteCount: DWORD, Buffer: ptr LPVOID): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetErrorLogClear*(server: LPCWSTR, backupfile: LPCWSTR, reserved: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetErrorLogRead*(server: LPCWSTR, reserved1: LPWSTR, errloghandle: LPHLOG, offset: DWORD, reserved2: LPDWORD, reserved3: DWORD, offsetflag: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, bytesread: LPDWORD, totalbytes: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetErrorLogWrite*(reserved1: LPBYTE, code: DWORD, component: LPCWSTR, buffer: LPBYTE, numbytes: DWORD, msgbuf: LPBYTE, strcount: DWORD, reserved2: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetConfigGet*(server: LPCWSTR, component: LPCWSTR, parameter: LPCWSTR, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetConfigGetAll*(server: LPCWSTR, component: LPCWSTR, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetConfigSet*(server: LPCWSTR, reserved1: LPCWSTR, component: LPCWSTR, level: DWORD, reserved2: DWORD, buf: LPBYTE, reserved3: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRegisterDomainNameChangeNotification*(NotificationEventHandle: PHANDLE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUnregisterDomainNameChangeNotification*(NotificationEventHandle: HANDLE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetStatisticsGet*(server: LMSTR, service: LMSTR, level: DWORD, options: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAuditClear*(server: LPCWSTR, backupfile: LPCWSTR, service: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAuditRead*(server: LPCWSTR, service: LPCWSTR, auditloghandle: LPHLOG, offset: DWORD, reserved1: LPDWORD, reserved2: DWORD, offsetflag: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, bytesread: LPDWORD, totalavailable: LPDWORD): DWORD {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAuditWrite*(`type`: DWORD, buf: LPBYTE, numbytes: DWORD, service: LPCWSTR, reserved: LPBYTE): DWORD {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetJoinDomain*(lpServer: LPCWSTR, lpDomain: LPCWSTR, lpAccountOU: LPCWSTR, lpAccount: LPCWSTR, lpPassword: LPCWSTR, fJoinOptions: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetUnjoinDomain*(lpServer: LPCWSTR, lpAccount: LPCWSTR, lpPassword: LPCWSTR, fUnjoinOptions: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRenameMachineInDomain*(lpServer: LPCWSTR, lpNewMachineName: LPCWSTR, lpAccount: LPCWSTR, lpPassword: LPCWSTR, fRenameOptions: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetValidateName*(lpServer: LPCWSTR, lpName: LPCWSTR, lpAccount: LPCWSTR, lpPassword: LPCWSTR, NameType: NETSETUP_NAME_TYPE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGetJoinInformation*(lpServer: LPCWSTR, lpNameBuffer: ptr LPWSTR, BufferType: PNETSETUP_JOIN_STATUS): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetGetJoinableOUs*(lpServer: LPCWSTR, lpDomain: LPCWSTR, lpAccount: LPCWSTR, lpPassword: LPCWSTR, OUCount: ptr DWORD, OUs: ptr ptr LPWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAddAlternateComputerName*(Server: LPCWSTR, AlternateName: LPCWSTR, DomainAccount: LPCWSTR, DomainAccountPassword: LPCWSTR, Reserved: ULONG): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetRemoveAlternateComputerName*(Server: LPCWSTR, AlternateName: LPCWSTR, DomainAccount: LPCWSTR, DomainAccountPassword: LPCWSTR, Reserved: ULONG): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetSetPrimaryComputerName*(Server: LPCWSTR, PrimaryName: LPCWSTR, DomainAccount: LPCWSTR, DomainAccountPassword: LPCWSTR, Reserved: ULONG): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetEnumerateComputerNames*(Server: LPCWSTR, NameType: NET_COMPUTER_NAME_TYPE, Reserved: ULONG, EntryCount: PDWORD, ComputerNames: ptr ptr LPWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetScheduleJobAdd*(Servername: LPCWSTR, Buffer: LPBYTE, JobId: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetScheduleJobDel*(Servername: LPCWSTR, MinJobId: DWORD, MaxJobId: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetScheduleJobEnum*(Servername: LPCWSTR, PointerToBuffer: ptr LPBYTE, PrefferedMaximumLength: DWORD, EntriesRead: LPDWORD, TotalEntries: LPDWORD, ResumeHandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetScheduleJobGetInfo*(Servername: LPCWSTR, JobId: DWORD, PointerToBuffer: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetShareDelEx*(servername: LMSTR, level: DWORD, buf: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsAdd*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR, Comment: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsAddStdRoot*(ServerName: LPWSTR, RootShare: LPWSTR, Comment: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsRemoveStdRoot*(ServerName: LPWSTR, RootShare: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsAddFtRoot*(ServerName: LPWSTR, RootShare: LPWSTR, FtDfsName: LPWSTR, Comment: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsRemoveFtRoot*(ServerName: LPWSTR, RootShare: LPWSTR, FtDfsName: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsRemoveFtRootForced*(DomainName: LPWSTR, ServerName: LPWSTR, RootShare: LPWSTR, FtDfsName: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsManagerInitialize*(ServerName: LPWSTR, Flags: DWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsAddStdRootForced*(ServerName: LPWSTR, RootShare: LPWSTR, Comment: LPWSTR, Store: LPWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetDcAddress*(ServerName: LPWSTR, DcIpAddress: ptr LPWSTR, IsRoot: ptr BOOLEAN, Timeout: ptr ULONG): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsRemove*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsEnum*(DfsName: LPWSTR, Level: DWORD, PrefMaxLen: DWORD, Buffer: ptr LPBYTE, EntriesRead: LPDWORD, ResumeHandle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetInfo*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR, Level: DWORD, Buffer: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsSetInfo*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR, Level: DWORD, Buffer: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetClientInfo*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR, Level: DWORD, Buffer: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsSetClientInfo*(DfsEntryPath: LPWSTR, ServerName: LPWSTR, ShareName: LPWSTR, Level: DWORD, Buffer: LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsMove*(DfsEntryPath: LPWSTR, DfsNewEntryPath: LPWSTR, Flags: ULONG): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsRename*(Path: LPWSTR, NewPath: LPWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetSecurity*(DfsEntryPath: LPWSTR, SecurityInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsSetSecurity*(DfsEntryPath: LPWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetStdContainerSecurity*(MachineName: LPWSTR, SecurityInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsSetStdContainerSecurity*(MachineName: LPWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsGetFtContainerSecurity*(DomainName: LPWSTR, SecurityInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetDfsSetFtContainerSecurity*(DomainName: LPWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc.} +proc NetAccessAdd*(servername: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessAdd".} +proc NetAccessEnum*(servername: LPCWSTR, BasePath: LPCWSTR, Recursive: DWORD, level: DWORD, bufptr: ptr LPBYTE, prefmaxlen: DWORD, entriesread: LPDWORD, totalentries: LPDWORD, resume_handle: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessEnum".} +proc NetAccessGetInfo*(servername: LPCWSTR, resource: LPCWSTR, level: DWORD, bufptr: ptr LPBYTE): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessGetInfo".} +proc NetAccessSetInfo*(servername: LPCWSTR, resource: LPCWSTR, level: DWORD, buf: LPBYTE, parm_err: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessSetInfo".} +proc NetAccessDel*(servername: LPCWSTR, resource: LPCWSTR): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessDel".} +proc NetAccessGetUserPerms*(servername: LPCWSTR, UGname: LPCWSTR, resource: LPCWSTR, Perms: LPDWORD): NET_API_STATUS {.winapi, stdcall, dynlib: "netapi32", importc: "RxNetAccessGetUserPerms".} +when winimUnicode: + type + PORT_INFO_FF* = PORT_INFO_FFW + PPORT_INFO_FF* = PPORT_INFO_FFW + LPPORT_INFO_FF* = LPPORT_INFO_FFW +when winimAnsi: + type + PORT_INFO_FF* = PORT_INFO_FFA + PPORT_INFO_FF* = PPORT_INFO_FFA + LPPORT_INFO_FF* = LPPORT_INFO_FFA +when winimCpu64: + type + DFS_STORAGE_INFO_0_32* {.pure.} = object + State*: ULONG + ServerName*: ULONG + ShareName*: ULONG + PDFS_STORAGE_INFO_0_32* = ptr DFS_STORAGE_INFO_0_32 + LPDFS_STORAGE_INFO_0_32* = ptr DFS_STORAGE_INFO_0_32 + DFS_INFO_3_32* {.pure.} = object + EntryPath*: ULONG + Comment*: ULONG + State*: DWORD + NumberOfStorages*: DWORD + Storage*: ULONG + PDFS_INFO_3_32* = ptr DFS_INFO_3_32 + LPDFS_INFO_3_32* = ptr DFS_INFO_3_32 + DFS_INFO_4_32* {.pure.} = object + EntryPath*: ULONG + Comment*: ULONG + State*: DWORD + Timeout*: ULONG + Guid*: GUID + NumberOfStorages*: DWORD + Storage*: ULONG + PDFS_INFO_4_32* = ptr DFS_INFO_4_32 + LPDFS_INFO_4_32* = ptr DFS_INFO_4_32 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/lzexpand.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/lzexpand.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,37 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +const + LZERROR_BADINHANDLE* = -1 + LZERROR_BADOUTHANDLE* = -2 + LZERROR_READ* = -3 + LZERROR_WRITE* = -4 + LZERROR_GLOBALLOC* = -5 + LZERROR_GLOBLOCK* = -6 + LZERROR_BADVALUE* = -7 + LZERROR_UNKNOWNALG* = -8 +proc LZStart*(): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZDone*(): VOID {.winapi, stdcall, dynlib: "lz32", importc.} +proc CopyLZFile*(P1: INT, P2: INT): LONG {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZCopy*(P1: INT, P2: INT): LONG {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZInit*(P1: INT): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc GetExpandedNameA*(P1: LPSTR, P2: LPSTR): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc GetExpandedNameW*(P1: LPWSTR, P2: LPWSTR): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZOpenFileA*(P1: LPSTR, P2: LPOFSTRUCT, P3: WORD): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZOpenFileW*(P1: LPWSTR, P2: LPOFSTRUCT, P3: WORD): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZSeek*(P1: INT, P2: LONG, P3: INT): LONG {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZRead*(P1: INT, P2: LPSTR, P3: INT): INT {.winapi, stdcall, dynlib: "lz32", importc.} +proc LZClose*(P1: INT): VOID {.winapi, stdcall, dynlib: "lz32", importc.} +when winimUnicode: + proc GetExpandedName*(P1: LPWSTR, P2: LPWSTR): INT {.winapi, stdcall, dynlib: "lz32", importc: "GetExpandedNameW".} + proc LZOpenFile*(P1: LPWSTR, P2: LPOFSTRUCT, P3: WORD): INT {.winapi, stdcall, dynlib: "lz32", importc: "LZOpenFileW".} +when winimAnsi: + proc GetExpandedName*(P1: LPSTR, P2: LPSTR): INT {.winapi, stdcall, dynlib: "lz32", importc: "GetExpandedNameA".} + proc LZOpenFile*(P1: LPSTR, P2: LPOFSTRUCT, P3: WORD): INT {.winapi, stdcall, dynlib: "lz32", importc: "LZOpenFileA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/mcx.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/mcx.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,196 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import windef +#include +type + MODEMDEVCAPS* {.pure.} = object + dwActualSize*: DWORD + dwRequiredSize*: DWORD + dwDevSpecificOffset*: DWORD + dwDevSpecificSize*: DWORD + dwModemProviderVersion*: DWORD + dwModemManufacturerOffset*: DWORD + dwModemManufacturerSize*: DWORD + dwModemModelOffset*: DWORD + dwModemModelSize*: DWORD + dwModemVersionOffset*: DWORD + dwModemVersionSize*: DWORD + dwDialOptions*: DWORD + dwCallSetupFailTimer*: DWORD + dwInactivityTimeout*: DWORD + dwSpeakerVolume*: DWORD + dwSpeakerMode*: DWORD + dwModemOptions*: DWORD + dwMaxDTERate*: DWORD + dwMaxDCERate*: DWORD + abVariablePortion*: array[1, BYTE] + PMODEMDEVCAPS* = ptr MODEMDEVCAPS + LPMODEMDEVCAPS* = ptr MODEMDEVCAPS + MODEMSETTINGS* {.pure.} = object + dwActualSize*: DWORD + dwRequiredSize*: DWORD + dwDevSpecificOffset*: DWORD + dwDevSpecificSize*: DWORD + dwCallSetupFailTimer*: DWORD + dwInactivityTimeout*: DWORD + dwSpeakerVolume*: DWORD + dwSpeakerMode*: DWORD + dwPreferredModemOptions*: DWORD + dwNegotiatedModemOptions*: DWORD + dwNegotiatedDCERate*: DWORD + abVariablePortion*: array[1, BYTE] + PMODEMSETTINGS* = ptr MODEMSETTINGS + LPMODEMSETTINGS* = ptr MODEMSETTINGS +const + DIALOPTION_BILLING* = 0x00000040 + DIALOPTION_QUIET* = 0x00000080 + DIALOPTION_DIALTONE* = 0x00000100 + MDMVOLFLAG_LOW* = 0x00000001 + MDMVOLFLAG_MEDIUM* = 0x00000002 + MDMVOLFLAG_HIGH* = 0x00000004 + MDMVOL_LOW* = 0x00000000 + MDMVOL_MEDIUM* = 0x00000001 + MDMVOL_HIGH* = 0x00000002 + MDMSPKRFLAG_OFF* = 0x00000001 + MDMSPKRFLAG_DIAL* = 0x00000002 + MDMSPKRFLAG_ON* = 0x00000004 + MDMSPKRFLAG_CALLSETUP* = 0x00000008 + MDMSPKR_OFF* = 0x00000000 + MDMSPKR_DIAL* = 0x00000001 + MDMSPKR_ON* = 0x00000002 + MDMSPKR_CALLSETUP* = 0x00000003 + MDM_COMPRESSION* = 0x00000001 + MDM_ERROR_CONTROL* = 0x00000002 + MDM_FORCED_EC* = 0x00000004 + MDM_CELLULAR* = 0x00000008 + MDM_FLOWCONTROL_HARD* = 0x00000010 + MDM_FLOWCONTROL_SOFT* = 0x00000020 + MDM_CCITT_OVERRIDE* = 0x00000040 + MDM_SPEED_ADJUST* = 0x00000080 + MDM_TONE_DIAL* = 0x00000100 + MDM_BLIND_DIAL* = 0x00000200 + MDM_V23_OVERRIDE* = 0x00000400 + MDM_DIAGNOSTICS* = 0x00000800 + MDM_MASK_BEARERMODE* = 0x0000f000 + MDM_SHIFT_BEARERMODE* = 12 + MDM_MASK_PROTOCOLID* = 0x000f0000 + MDM_SHIFT_PROTOCOLID* = 16 + MDM_MASK_PROTOCOLDATA* = 0x0ff00000 + MDM_SHIFT_PROTOCOLDATA* = 20 + MDM_MASK_PROTOCOLINFO* = MDM_MASK_PROTOCOLID or MDM_MASK_PROTOCOLDATA + MDM_SHIFT_PROTOCOLINFO* = MDM_SHIFT_PROTOCOLID + MDM_MASK_EXTENDEDINFO* = MDM_MASK_BEARERMODE or MDM_MASK_PROTOCOLINFO + MDM_SHIFT_EXTENDEDINFO* = MDM_SHIFT_BEARERMODE + MDM_BEARERMODE_ANALOG* = 0x0 + MDM_BEARERMODE_ISDN* = 0x1 + MDM_BEARERMODE_GSM* = 0x2 + MDM_PROTOCOLID_DEFAULT* = 0x0 + MDM_PROTOCOLID_HDLCPPP* = 0x1 + MDM_PROTOCOLID_V128* = 0x2 + MDM_PROTOCOLID_X75* = 0x3 + MDM_PROTOCOLID_V110* = 0x4 + MDM_PROTOCOLID_V120* = 0x5 + MDM_PROTOCOLID_AUTO* = 0x6 + MDM_PROTOCOLID_ANALOG* = 0x7 + MDM_PROTOCOLID_GPRS* = 0x8 + MDM_PROTOCOLID_PIAFS* = 0x9 + MDM_SHIFT_HDLCPPP_SPEED* = 0x0 + MDM_MASK_HDLCPPP_SPEED* = 0x7 + MDM_HDLCPPP_SPEED_DEFAULT* = 0x0 + MDM_HDLCPPP_SPEED_64K* = 0x1 + MDM_HDLCPPP_SPEED_56K* = 0x2 + MDM_SHIFT_HDLCPPP_AUTH* = 0x3 + MDM_MASK_HDLCPPP_AUTH* = 0x7 shl 3 + MDM_HDLCPPP_AUTH_DEFAULT* = 0x0 + MDM_HDLCPPP_AUTH_NONE* = 0x1 + MDM_HDLCPPP_AUTH_PAP* = 0x2 + MDM_HDLCPPP_AUTH_CHAP* = 0x3 + MDM_HDLCPPP_AUTH_MSCHAP* = 0x4 + MDM_SHIFT_HDLCPPP_ML* = 0x6 + MDM_MASK_HDLCPPP_ML* = 0x3 shl 6 + MDM_HDLCPPP_ML_DEFAULT* = 0x0 + MDM_HDLCPPP_ML_NONE* = 0x1 + MDM_HDLCPPP_ML_2* = 0x2 + MDM_SHIFT_V120_SPEED* = 0x0 + MDM_MASK_V120_SPEED* = 0x7 + MDM_V120_SPEED_DEFAULT* = 0x0 + MDM_V120_SPEED_64K* = 0x1 + MDM_V120_SPEED_56K* = 0x2 + MDM_SHIFT_V120_ML* = 0x6 + MDM_MASK_V120_ML* = 0x3 shl 6 + MDM_V120_ML_DEFAULT* = 0x0 + MDM_V120_ML_NONE* = 0x1 + MDM_V120_ML_2* = 0x2 + MDM_SHIFT_X75_DATA* = 0x0 + MDM_MASK_X75_DATA* = 0x7 + MDM_X75_DATA_DEFAULT* = 0x0 + MDM_X75_DATA_64K* = 0x1 + MDM_X75_DATA_128K* = 0x2 + MDM_X75_DATA_T_70* = 0x3 + MDM_X75_DATA_BTX* = 0x4 + MDM_SHIFT_V110_SPEED* = 0x0 + MDM_MASK_V110_SPEED* = 0xf + MDM_V110_SPEED_DEFAULT* = 0x0 + MDM_V110_SPEED_1DOT2K* = 0x1 + MDM_V110_SPEED_2DOT4K* = 0x2 + MDM_V110_SPEED_4DOT8K* = 0x3 + MDM_V110_SPEED_9DOT6K* = 0x4 + MDM_V110_SPEED_12DOT0K* = 0x5 + MDM_V110_SPEED_14DOT4K* = 0x6 + MDM_V110_SPEED_19DOT2K* = 0x7 + MDM_V110_SPEED_28DOT8K* = 0x8 + MDM_V110_SPEED_38DOT4K* = 0x9 + MDM_V110_SPEED_57DOT6K* = 0xA + MDM_SHIFT_AUTO_SPEED* = 0x0 + MDM_MASK_AUTO_SPEED* = 0x7 + MDM_AUTO_SPEED_DEFAULT* = 0x0 + MDM_SHIFT_AUTO_ML* = 0x6 + MDM_MASK_AUTO_ML* = 0x3 shl 6 + MDM_AUTO_ML_DEFAULT* = 0x0 + MDM_AUTO_ML_NONE* = 0x1 + MDM_AUTO_ML_2* = 0x2 + MDM_ANALOG_RLP_ON* = 0x0 + MDM_ANALOG_RLP_OFF* = 0x1 + MDM_ANALOG_V34* = 0x2 + MDM_PIAFS_INCOMING* = 0 + MDM_PIAFS_OUTGOING* = 1 + MDM_PROTOCOL_HDLCPPP_64K* = 0x00110000 + MDM_PROTOCOL_HDLCPPP_56K* = 0x00210000 + MDM_PROTOCOL_HDLCPPP_112K* = 0x08210000 + MDM_PROTOCOL_HDLCPPP_112K_PAP* = 0x09210000 + MDM_PROTOCOL_HDLCPPP_112K_CHAP* = 0x09A10000 + MDM_PROTOCOL_HDLCPPP_112K_MSCHAP* = 0x0A210000 + MDM_PROTOCOL_HDLCPPP_128K* = 0x08110000 + MDM_PROTOCOL_HDLCPPP_128K_PAP* = 0x09110000 + MDM_PROTOCOL_HDLCPPP_128K_CHAP* = 0x09910000 + MDM_PROTOCOL_HDLCPPP_128K_MSCHAP* = 0x0A110000 + MDM_PROTOCOL_V120_64K* = 0x04150000 + MDM_PROTOCOL_V120_56K* = 0x04250000 + MDM_PROTOCOL_V120_112K* = 0x08250000 + MDM_PROTOCOL_V120_128K* = 0x08150000 + MDM_PROTOCOL_X75_64K* = 0x00130000 + MDM_PROTOCOL_X75_128K* = 0x00230000 + MDM_PROTOCOL_X75_T_70* = 0x00330000 + MDM_PROTOCOL_X75_BTX* = 0x00430000 + MDM_PROTOCOL_V110_1DOT2K* = 0x00140000 + MDM_PROTOCOL_V110_2DOT4K* = 0x00240000 + MDM_PROTOCOL_V110_4DOT8K* = 0x00340000 + MDM_PROTOCOL_V110_9DOT6K* = 0x00440000 + MDM_PROTOCOL_V110_12DOT0K* = 0x00540000 + MDM_PROTOCOL_V110_14DOT4K* = 0x00640000 + MDM_PROTOCOL_V110_19DOT2K* = 0x00740000 + MDM_PROTOCOL_V110_28DOT8K* = 0x00840000 + MDM_PROTOCOL_V110_38DOT4K* = 0x00940000 + MDM_PROTOCOL_V110_57DOT6K* = 0x00A40000 + MDM_PROTOCOL_AUTO_1CH* = 0x04060000 + MDM_PROTOCOL_AUTO_2CH* = 0x08060000 + MDM_PROTOCOL_ANALOG_RLP* = 0x00070000 + MDM_PROTOCOL_ANALOG_NRLP* = 0x00170000 + MDM_PROTOCOL_ANALOG_V34* = 0x00270000 + MDM_PROTOCOL_GPRS* = 0x00080000 + MDM_PROTOCOL_PIAFS_INCOMING* = 0x00090000 + MDM_PROTOCOL_PIAFS_OUTGOING* = 0x00190000 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/mmsystem.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/mmsystem.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,4742 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import imm +#include +#include +type + HPSTR* = ptr char + HDRVR* = HANDLE + HWAVE* = HANDLE + HWAVEIN* = HANDLE + HWAVEOUT* = HANDLE + HMIDI* = HANDLE + HMIDIIN* = HANDLE + HMIDIOUT* = HANDLE + HMIDISTRM* = HANDLE + LPPATCHARRAY* = ptr WORD + LPKEYARRAY* = ptr WORD + HMIXEROBJ* = HANDLE + HMIXER* = HANDLE + FOURCC* = DWORD + HMMIO* = HANDLE + MCIERROR* = DWORD + MMVERSION* = UINT + MMRESULT* = UINT + MMTIME_u_smpte* {.pure.} = object + hour*: BYTE + min*: BYTE + sec*: BYTE + frame*: BYTE + fps*: BYTE + dummy*: BYTE + pad*: array[2, BYTE] + MMTIME_u_midi* {.pure.} = object + songptrpos*: DWORD + MMTIME_u* {.pure, union.} = object + ms*: DWORD + sample*: DWORD + cb*: DWORD + ticks*: DWORD + smpte*: MMTIME_u_smpte + midi*: MMTIME_u_midi + MMTIME* {.pure.} = object + wType*: UINT + u*: MMTIME_u + PMMTIME* = ptr MMTIME + NPMMTIME* = ptr MMTIME + LPMMTIME* = ptr MMTIME + DRVCONFIGINFOEX* {.pure, packed.} = object + dwDCISize*: DWORD + lpszDCISectionName*: LPCWSTR + lpszDCIAliasName*: LPCWSTR + dnDevNode*: DWORD + PDRVCONFIGINFOEX* = ptr DRVCONFIGINFOEX + NPDRVCONFIGINFOEX* = ptr DRVCONFIGINFOEX + LPDRVCONFIGINFOEX* = ptr DRVCONFIGINFOEX + DRVCONFIGINFO* {.pure, packed.} = object + dwDCISize*: DWORD + lpszDCISectionName*: LPCWSTR + lpszDCIAliasName*: LPCWSTR + PDRVCONFIGINFO* = ptr DRVCONFIGINFO + NPDRVCONFIGINFO* = ptr DRVCONFIGINFO + LPDRVCONFIGINFO* = ptr DRVCONFIGINFO + DRVCALLBACK* = proc (hdrvr: HDRVR, uMsg: UINT, dwUser: DWORD_PTR, dw1: DWORD_PTR, dw2: DWORD_PTR): void {.stdcall.} + LPDRVCALLBACK* = ptr DRVCALLBACK + PDRVCALLBACK* = ptr DRVCALLBACK + LPHWAVEIN* = ptr HWAVEIN + LPHWAVEOUT* = ptr HWAVEOUT + WAVECALLBACK* = DRVCALLBACK + LPWAVECALLBACK* = ptr WAVECALLBACK + WAVEHDR* {.pure.} = object + lpData*: LPSTR + dwBufferLength*: DWORD + dwBytesRecorded*: DWORD + dwUser*: DWORD_PTR + dwFlags*: DWORD + dwLoops*: DWORD + lpNext*: ptr WAVEHDR + reserved*: DWORD_PTR + PWAVEHDR* = ptr WAVEHDR + NPWAVEHDR* = ptr WAVEHDR + LPWAVEHDR* = ptr WAVEHDR +const + MAXPNAMELEN* = 32 +type + WAVEOUTCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + dwSupport*: DWORD + PWAVEOUTCAPSA* = ptr WAVEOUTCAPSA + NPWAVEOUTCAPSA* = ptr WAVEOUTCAPSA + LPWAVEOUTCAPSA* = ptr WAVEOUTCAPSA + WAVEOUTCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + dwSupport*: DWORD + PWAVEOUTCAPSW* = ptr WAVEOUTCAPSW + NPWAVEOUTCAPSW* = ptr WAVEOUTCAPSW + LPWAVEOUTCAPSW* = ptr WAVEOUTCAPSW + WAVEOUTCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PWAVEOUTCAPS2A* = ptr WAVEOUTCAPS2A + NPWAVEOUTCAPS2A* = ptr WAVEOUTCAPS2A + LPWAVEOUTCAPS2A* = ptr WAVEOUTCAPS2A + WAVEOUTCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PWAVEOUTCAPS2W* = ptr WAVEOUTCAPS2W + NPWAVEOUTCAPS2W* = ptr WAVEOUTCAPS2W + LPWAVEOUTCAPS2W* = ptr WAVEOUTCAPS2W + WAVEINCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + PWAVEINCAPSA* = ptr WAVEINCAPSA + NPWAVEINCAPSA* = ptr WAVEINCAPSA + LPWAVEINCAPSA* = ptr WAVEINCAPSA + WAVEINCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + PWAVEINCAPSW* = ptr WAVEINCAPSW + NPWAVEINCAPSW* = ptr WAVEINCAPSW + LPWAVEINCAPSW* = ptr WAVEINCAPSW + WAVEINCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PWAVEINCAPS2A* = ptr WAVEINCAPS2A + NPWAVEINCAPS2A* = ptr WAVEINCAPS2A + LPWAVEINCAPS2A* = ptr WAVEINCAPS2A + WAVEINCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwFormats*: DWORD + wChannels*: WORD + wReserved1*: WORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PWAVEINCAPS2W* = ptr WAVEINCAPS2W + NPWAVEINCAPS2W* = ptr WAVEINCAPS2W + LPWAVEINCAPS2W* = ptr WAVEINCAPS2W + WAVEFORMAT* {.pure, packed.} = object + wFormatTag*: WORD + nChannels*: WORD + nSamplesPerSec*: DWORD + nAvgBytesPerSec*: DWORD + nBlockAlign*: WORD + PWAVEFORMAT* = ptr WAVEFORMAT + NPWAVEFORMAT* = ptr WAVEFORMAT + LPWAVEFORMAT* = ptr WAVEFORMAT + PCMWAVEFORMAT* {.pure, packed.} = object + wf*: WAVEFORMAT + wBitsPerSample*: WORD + PPCMWAVEFORMAT* = ptr PCMWAVEFORMAT + NPPCMWAVEFORMAT* = ptr PCMWAVEFORMAT + LPPCMWAVEFORMAT* = ptr PCMWAVEFORMAT + WAVEFORMATEX* {.pure, packed.} = object + wFormatTag*: WORD + nChannels*: WORD + nSamplesPerSec*: DWORD + nAvgBytesPerSec*: DWORD + nBlockAlign*: WORD + wBitsPerSample*: WORD + cbSize*: WORD + PWAVEFORMATEX* = ptr WAVEFORMATEX + NPWAVEFORMATEX* = ptr WAVEFORMATEX + LPWAVEFORMATEX* = ptr WAVEFORMATEX + LPCWAVEFORMATEX* = ptr WAVEFORMATEX + LPHMIDI* = ptr HMIDI + LPHMIDIIN* = ptr HMIDIIN + LPHMIDIOUT* = ptr HMIDIOUT + LPHMIDISTRM* = ptr HMIDISTRM + MIDICALLBACK* = DRVCALLBACK + LPMIDICALLBACK* = ptr MIDICALLBACK +const + MIDIPATCHSIZE* = 128 +type + PATCHARRAY* = array[MIDIPATCHSIZE, WORD] + KEYARRAY* = array[MIDIPATCHSIZE, WORD] + MIDIOUTCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + wTechnology*: WORD + wVoices*: WORD + wNotes*: WORD + wChannelMask*: WORD + dwSupport*: DWORD + PMIDIOUTCAPSA* = ptr MIDIOUTCAPSA + NPMIDIOUTCAPSA* = ptr MIDIOUTCAPSA + LPMIDIOUTCAPSA* = ptr MIDIOUTCAPSA + MIDIOUTCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + wTechnology*: WORD + wVoices*: WORD + wNotes*: WORD + wChannelMask*: WORD + dwSupport*: DWORD + PMIDIOUTCAPSW* = ptr MIDIOUTCAPSW + NPMIDIOUTCAPSW* = ptr MIDIOUTCAPSW + LPMIDIOUTCAPSW* = ptr MIDIOUTCAPSW + MIDIOUTCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + wTechnology*: WORD + wVoices*: WORD + wNotes*: WORD + wChannelMask*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIDIOUTCAPS2A* = ptr MIDIOUTCAPS2A + NPMIDIOUTCAPS2A* = ptr MIDIOUTCAPS2A + LPMIDIOUTCAPS2A* = ptr MIDIOUTCAPS2A + MIDIOUTCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + wTechnology*: WORD + wVoices*: WORD + wNotes*: WORD + wChannelMask*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIDIOUTCAPS2W* = ptr MIDIOUTCAPS2W + NPMIDIOUTCAPS2W* = ptr MIDIOUTCAPS2W + LPMIDIOUTCAPS2W* = ptr MIDIOUTCAPS2W + MIDIINCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwSupport*: DWORD + PMIDIINCAPSA* = ptr MIDIINCAPSA + NPMIDIINCAPSA* = ptr MIDIINCAPSA + LPMIDIINCAPSA* = ptr MIDIINCAPSA + MIDIINCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwSupport*: DWORD + PMIDIINCAPSW* = ptr MIDIINCAPSW + NPMIDIINCAPSW* = ptr MIDIINCAPSW + LPMIDIINCAPSW* = ptr MIDIINCAPSW + MIDIINCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIDIINCAPS2A* = ptr MIDIINCAPS2A + NPMIDIINCAPS2A* = ptr MIDIINCAPS2A + LPMIDIINCAPS2A* = ptr MIDIINCAPS2A + MIDIINCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIDIINCAPS2W* = ptr MIDIINCAPS2W + NPMIDIINCAPS2W* = ptr MIDIINCAPS2W + LPMIDIINCAPS2W* = ptr MIDIINCAPS2W + MIDIHDR* {.pure, packed.} = object + lpData*: LPSTR + dwBufferLength*: DWORD + dwBytesRecorded*: DWORD + dwUser*: DWORD_PTR + dwFlags*: DWORD + lpNext*: ptr MIDIHDR + reserved*: DWORD_PTR + dwOffset*: DWORD + dwReserved*: array[8, DWORD_PTR] + PMIDIHDR* = ptr MIDIHDR + NPMIDIHDR* = ptr MIDIHDR + LPMIDIHDR* = ptr MIDIHDR + TMIDIPROPTIMEDIV* {.pure.} = object + cbStruct*: DWORD + dwTimeDiv*: DWORD + LPMIDIPROPTIMEDIV* = ptr TMIDIPROPTIMEDIV + TMIDIPROPTEMPO* {.pure.} = object + cbStruct*: DWORD + dwTempo*: DWORD + LPMIDIPROPTEMPO* = ptr TMIDIPROPTEMPO + AUXCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + wTechnology*: WORD + wReserved1*: WORD + dwSupport*: DWORD + PAUXCAPSA* = ptr AUXCAPSA + NPAUXCAPSA* = ptr AUXCAPSA + LPAUXCAPSA* = ptr AUXCAPSA + AUXCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + wTechnology*: WORD + wReserved1*: WORD + dwSupport*: DWORD + PAUXCAPSW* = ptr AUXCAPSW + NPAUXCAPSW* = ptr AUXCAPSW + LPAUXCAPSW* = ptr AUXCAPSW + AUXCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + wTechnology*: WORD + wReserved1*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PAUXCAPS2A* = ptr AUXCAPS2A + NPAUXCAPS2A* = ptr AUXCAPS2A + LPAUXCAPS2A* = ptr AUXCAPS2A + AUXCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + wTechnology*: WORD + wReserved1*: WORD + dwSupport*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PAUXCAPS2W* = ptr AUXCAPS2W + NPAUXCAPS2W* = ptr AUXCAPS2W + LPAUXCAPS2W* = ptr AUXCAPS2W + LPHMIXEROBJ* = ptr HMIXEROBJ + LPHMIXER* = ptr HMIXER + MIXERCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + fdwSupport*: DWORD + cDestinations*: DWORD + PMIXERCAPSA* = ptr MIXERCAPSA + LPMIXERCAPSA* = ptr MIXERCAPSA + MIXERCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + fdwSupport*: DWORD + cDestinations*: DWORD + PMIXERCAPSW* = ptr MIXERCAPSW + LPMIXERCAPSW* = ptr MIXERCAPSW + MIXERCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + fdwSupport*: DWORD + cDestinations*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIXERCAPS2A* = ptr MIXERCAPS2A + LPMIXERCAPS2A* = ptr MIXERCAPS2A + MIXERCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + fdwSupport*: DWORD + cDestinations*: DWORD + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PMIXERCAPS2W* = ptr MIXERCAPS2W + LPMIXERCAPS2W* = ptr MIXERCAPS2W +const + MIXER_SHORT_NAME_CHARS* = 16 + MIXER_LONG_NAME_CHARS* = 64 +type + MIXERLINEA_Target* {.pure.} = object + dwType*: DWORD + dwDeviceID*: DWORD + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, CHAR] + MIXERLINEA* {.pure, packed.} = object + cbStruct*: DWORD + dwDestination*: DWORD + dwSource*: DWORD + dwLineID*: DWORD + fdwLine*: DWORD + dwUser*: DWORD_PTR + dwComponentType*: DWORD + cChannels*: DWORD + cConnections*: DWORD + cControls*: DWORD + szShortName*: array[MIXER_SHORT_NAME_CHARS, CHAR] + szName*: array[MIXER_LONG_NAME_CHARS, CHAR] + Target*: MIXERLINEA_Target + PMIXERLINEA* = ptr MIXERLINEA + LPMIXERLINEA* = ptr MIXERLINEA + MIXERLINEW_Target* {.pure.} = object + dwType*: DWORD + dwDeviceID*: DWORD + wMid*: WORD + wPid*: WORD + vDriverVersion*: MMVERSION + szPname*: array[MAXPNAMELEN, WCHAR] + MIXERLINEW* {.pure, packed.} = object + cbStruct*: DWORD + dwDestination*: DWORD + dwSource*: DWORD + dwLineID*: DWORD + fdwLine*: DWORD + dwUser*: DWORD_PTR + dwComponentType*: DWORD + cChannels*: DWORD + cConnections*: DWORD + cControls*: DWORD + szShortName*: array[MIXER_SHORT_NAME_CHARS, WCHAR] + szName*: array[MIXER_LONG_NAME_CHARS, WCHAR] + Target*: MIXERLINEW_Target + PMIXERLINEW* = ptr MIXERLINEW + LPMIXERLINEW* = ptr MIXERLINEW + MIXERCONTROLA_Bounds_STRUCT1* {.pure.} = object + lMinimum*: LONG + lMaximum*: LONG + MIXERCONTROLA_Bounds_STRUCT2* {.pure.} = object + dwMinimum*: DWORD + dwMaximum*: DWORD + MIXERCONTROLA_Bounds* {.pure, union.} = object + struct1*: MIXERCONTROLA_Bounds_STRUCT1 + struct2*: MIXERCONTROLA_Bounds_STRUCT2 + dwReserved*: array[6, DWORD] + MIXERCONTROLA_Metrics* {.pure, union.} = object + cSteps*: DWORD + cbCustomData*: DWORD + dwReserved*: array[6, DWORD] + MIXERCONTROLA* {.pure.} = object + cbStruct*: DWORD + dwControlID*: DWORD + dwControlType*: DWORD + fdwControl*: DWORD + cMultipleItems*: DWORD + szShortName*: array[MIXER_SHORT_NAME_CHARS, CHAR] + szName*: array[MIXER_LONG_NAME_CHARS, CHAR] + Bounds*: MIXERCONTROLA_Bounds + Metrics*: MIXERCONTROLA_Metrics + PMIXERCONTROLA* = ptr MIXERCONTROLA + LPMIXERCONTROLA* = ptr MIXERCONTROLA + MIXERCONTROLW_Bounds_STRUCT1* {.pure.} = object + lMinimum*: LONG + lMaximum*: LONG + MIXERCONTROLW_Bounds_STRUCT2* {.pure.} = object + dwMinimum*: DWORD + dwMaximum*: DWORD + MIXERCONTROLW_Bounds* {.pure, union.} = object + struct1*: MIXERCONTROLW_Bounds_STRUCT1 + struct2*: MIXERCONTROLW_Bounds_STRUCT2 + dwReserved*: array[6, DWORD] + MIXERCONTROLW_Metrics* {.pure, union.} = object + cSteps*: DWORD + cbCustomData*: DWORD + dwReserved*: array[6, DWORD] + MIXERCONTROLW* {.pure.} = object + cbStruct*: DWORD + dwControlID*: DWORD + dwControlType*: DWORD + fdwControl*: DWORD + cMultipleItems*: DWORD + szShortName*: array[MIXER_SHORT_NAME_CHARS, WCHAR] + szName*: array[MIXER_LONG_NAME_CHARS, WCHAR] + Bounds*: MIXERCONTROLW_Bounds + Metrics*: MIXERCONTROLW_Metrics + PMIXERCONTROLW* = ptr MIXERCONTROLW + LPMIXERCONTROLW* = ptr MIXERCONTROLW + MIXERLINECONTROLSA_UNION1* {.pure, union.} = object + dwControlID*: DWORD + dwControlType*: DWORD + MIXERLINECONTROLSA* {.pure, packed.} = object + cbStruct*: DWORD + dwLineID*: DWORD + union1*: MIXERLINECONTROLSA_UNION1 + cControls*: DWORD + cbmxctrl*: DWORD + pamxctrl*: LPMIXERCONTROLA + PMIXERLINECONTROLSA* = ptr MIXERLINECONTROLSA + LPMIXERLINECONTROLSA* = ptr MIXERLINECONTROLSA + MIXERLINECONTROLSW_UNION1* {.pure, union.} = object + dwControlID*: DWORD + dwControlType*: DWORD + MIXERLINECONTROLSW* {.pure, packed.} = object + cbStruct*: DWORD + dwLineID*: DWORD + union1*: MIXERLINECONTROLSW_UNION1 + cControls*: DWORD + cbmxctrl*: DWORD + pamxctrl*: LPMIXERCONTROLW + PMIXERLINECONTROLSW* = ptr MIXERLINECONTROLSW + LPMIXERLINECONTROLSW* = ptr MIXERLINECONTROLSW + MIXERCONTROLDETAILS_UNION1* {.pure, union.} = object + hwndOwner*: HWND + cMultipleItems*: DWORD + MIXERCONTROLDETAILS* {.pure, packed.} = object + cbStruct*: DWORD + dwControlID*: DWORD + cChannels*: DWORD + union1*: MIXERCONTROLDETAILS_UNION1 + cbDetails*: DWORD + paDetails*: LPVOID + PMIXERCONTROLDETAILS* = ptr MIXERCONTROLDETAILS + LPMIXERCONTROLDETAILS* = ptr MIXERCONTROLDETAILS + MIXERCONTROLDETAILS_LISTTEXTA* {.pure.} = object + dwParam1*: DWORD + dwParam2*: DWORD + szName*: array[MIXER_LONG_NAME_CHARS, CHAR] + PMIXERCONTROLDETAILS_LISTTEXTA* = ptr MIXERCONTROLDETAILS_LISTTEXTA + LPMIXERCONTROLDETAILS_LISTTEXTA* = ptr MIXERCONTROLDETAILS_LISTTEXTA + MIXERCONTROLDETAILS_LISTTEXTW* {.pure.} = object + dwParam1*: DWORD + dwParam2*: DWORD + szName*: array[MIXER_LONG_NAME_CHARS, WCHAR] + PMIXERCONTROLDETAILS_LISTTEXTW* = ptr MIXERCONTROLDETAILS_LISTTEXTW + LPMIXERCONTROLDETAILS_LISTTEXTW* = ptr MIXERCONTROLDETAILS_LISTTEXTW + MIXERCONTROLDETAILS_BOOLEAN* {.pure.} = object + fValue*: LONG + PMIXERCONTROLDETAILS_BOOLEAN* = ptr MIXERCONTROLDETAILS_BOOLEAN + LPMIXERCONTROLDETAILS_BOOLEAN* = ptr MIXERCONTROLDETAILS_BOOLEAN + MIXERCONTROLDETAILS_SIGNED* {.pure.} = object + lValue*: LONG + PMIXERCONTROLDETAILS_SIGNED* = ptr MIXERCONTROLDETAILS_SIGNED + LPMIXERCONTROLDETAILS_SIGNED* = ptr MIXERCONTROLDETAILS_SIGNED + MIXERCONTROLDETAILS_UNSIGNED* {.pure.} = object + dwValue*: DWORD + PMIXERCONTROLDETAILS_UNSIGNED* = ptr MIXERCONTROLDETAILS_UNSIGNED + LPMIXERCONTROLDETAILS_UNSIGNED* = ptr MIXERCONTROLDETAILS_UNSIGNED + TIMECALLBACK* = proc (uTimerID: UINT, uMsg: UINT, dwUser: DWORD_PTR, dw1: DWORD_PTR, dw2: DWORD_PTR): void {.stdcall.} + LPTIMECALLBACK* = ptr TIMECALLBACK + TIMECAPS* {.pure.} = object + wPeriodMin*: UINT + wPeriodMax*: UINT + PTIMECAPS* = ptr TIMECAPS + NPTIMECAPS* = ptr TIMECAPS + LPTIMECAPS* = ptr TIMECAPS +const + MAX_JOYSTICKOEMVXDNAME* = 260 +type + JOYCAPSA* {.pure.} = object + wMid*: WORD + wPid*: WORD + szPname*: array[MAXPNAMELEN, CHAR] + wXmin*: UINT + wXmax*: UINT + wYmin*: UINT + wYmax*: UINT + wZmin*: UINT + wZmax*: UINT + wNumButtons*: UINT + wPeriodMin*: UINT + wPeriodMax*: UINT + wRmin*: UINT + wRmax*: UINT + wUmin*: UINT + wUmax*: UINT + wVmin*: UINT + wVmax*: UINT + wCaps*: UINT + wMaxAxes*: UINT + wNumAxes*: UINT + wMaxButtons*: UINT + szRegKey*: array[MAXPNAMELEN, CHAR] + szOEMVxD*: array[MAX_JOYSTICKOEMVXDNAME, CHAR] + PJOYCAPSA* = ptr JOYCAPSA + NPJOYCAPSA* = ptr JOYCAPSA + LPJOYCAPSA* = ptr JOYCAPSA + JOYCAPSW* {.pure.} = object + wMid*: WORD + wPid*: WORD + szPname*: array[MAXPNAMELEN, WCHAR] + wXmin*: UINT + wXmax*: UINT + wYmin*: UINT + wYmax*: UINT + wZmin*: UINT + wZmax*: UINT + wNumButtons*: UINT + wPeriodMin*: UINT + wPeriodMax*: UINT + wRmin*: UINT + wRmax*: UINT + wUmin*: UINT + wUmax*: UINT + wVmin*: UINT + wVmax*: UINT + wCaps*: UINT + wMaxAxes*: UINT + wNumAxes*: UINT + wMaxButtons*: UINT + szRegKey*: array[MAXPNAMELEN, WCHAR] + szOEMVxD*: array[MAX_JOYSTICKOEMVXDNAME, WCHAR] + PJOYCAPSW* = ptr JOYCAPSW + NPJOYCAPSW* = ptr JOYCAPSW + LPJOYCAPSW* = ptr JOYCAPSW + JOYCAPS2A* {.pure.} = object + wMid*: WORD + wPid*: WORD + szPname*: array[MAXPNAMELEN, CHAR] + wXmin*: UINT + wXmax*: UINT + wYmin*: UINT + wYmax*: UINT + wZmin*: UINT + wZmax*: UINT + wNumButtons*: UINT + wPeriodMin*: UINT + wPeriodMax*: UINT + wRmin*: UINT + wRmax*: UINT + wUmin*: UINT + wUmax*: UINT + wVmin*: UINT + wVmax*: UINT + wCaps*: UINT + wMaxAxes*: UINT + wNumAxes*: UINT + wMaxButtons*: UINT + szRegKey*: array[MAXPNAMELEN, CHAR] + szOEMVxD*: array[MAX_JOYSTICKOEMVXDNAME, CHAR] + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PJOYCAPS2A* = ptr JOYCAPS2A + NPJOYCAPS2A* = ptr JOYCAPS2A + LPJOYCAPS2A* = ptr JOYCAPS2A + JOYCAPS2W* {.pure.} = object + wMid*: WORD + wPid*: WORD + szPname*: array[MAXPNAMELEN, WCHAR] + wXmin*: UINT + wXmax*: UINT + wYmin*: UINT + wYmax*: UINT + wZmin*: UINT + wZmax*: UINT + wNumButtons*: UINT + wPeriodMin*: UINT + wPeriodMax*: UINT + wRmin*: UINT + wRmax*: UINT + wUmin*: UINT + wUmax*: UINT + wVmin*: UINT + wVmax*: UINT + wCaps*: UINT + wMaxAxes*: UINT + wNumAxes*: UINT + wMaxButtons*: UINT + szRegKey*: array[MAXPNAMELEN, WCHAR] + szOEMVxD*: array[MAX_JOYSTICKOEMVXDNAME, WCHAR] + ManufacturerGuid*: GUID + ProductGuid*: GUID + NameGuid*: GUID + PJOYCAPS2W* = ptr JOYCAPS2W + NPJOYCAPS2W* = ptr JOYCAPS2W + LPJOYCAPS2W* = ptr JOYCAPS2W + JOYINFO* {.pure.} = object + wXpos*: UINT + wYpos*: UINT + wZpos*: UINT + wButtons*: UINT + PJOYINFO* = ptr JOYINFO + NPJOYINFO* = ptr JOYINFO + LPJOYINFO* = ptr JOYINFO + JOYINFOEX* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + dwXpos*: DWORD + dwYpos*: DWORD + dwZpos*: DWORD + dwRpos*: DWORD + dwUpos*: DWORD + dwVpos*: DWORD + dwButtons*: DWORD + dwButtonNumber*: DWORD + dwPOV*: DWORD + dwReserved1*: DWORD + dwReserved2*: DWORD + PJOYINFOEX* = ptr JOYINFOEX + NPJOYINFOEX* = ptr JOYINFOEX + LPJOYINFOEX* = ptr JOYINFOEX + MMIOPROC* = proc (lpmmioinfo: LPSTR, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.stdcall.} + LPMMIOPROC* = ptr MMIOPROC + MMIOINFO* {.pure, packed.} = object + dwFlags*: DWORD + fccIOProc*: FOURCC + pIOProc*: LPMMIOPROC + wErrorRet*: UINT + htask*: HTASK + cchBuffer*: LONG + pchBuffer*: HPSTR + pchNext*: HPSTR + pchEndRead*: HPSTR + pchEndWrite*: HPSTR + lBufOffset*: LONG + lDiskOffset*: LONG + adwInfo*: array[3, DWORD] + dwReserved1*: DWORD + dwReserved2*: DWORD + hmmio*: HMMIO + PMMIOINFO* = ptr MMIOINFO + NPMMIOINFO* = ptr MMIOINFO + LPMMIOINFO* = ptr MMIOINFO + LPCMMIOINFO* = ptr MMIOINFO + MMCKINFO* {.pure.} = object + ckid*: FOURCC + cksize*: DWORD + fccType*: FOURCC + dwDataOffset*: DWORD + dwFlags*: DWORD + PMMCKINFO* = ptr MMCKINFO + NPMMCKINFO* = ptr MMCKINFO + LPMMCKINFO* = ptr MMCKINFO + LPCMMCKINFO* = ptr MMCKINFO + MCIDEVICEID* = UINT + MCI_GENERIC_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + PMCI_GENERIC_PARMS* = ptr MCI_GENERIC_PARMS + LPMCI_GENERIC_PARMS* = ptr MCI_GENERIC_PARMS + MCI_OPEN_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCSTR + lpstrElementName*: LPCSTR + lpstrAlias*: LPCSTR + PMCI_OPEN_PARMSA* = ptr MCI_OPEN_PARMSA + LPMCI_OPEN_PARMSA* = ptr MCI_OPEN_PARMSA + MCI_OPEN_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCWSTR + lpstrElementName*: LPCWSTR + lpstrAlias*: LPCWSTR + PMCI_OPEN_PARMSW* = ptr MCI_OPEN_PARMSW + LPMCI_OPEN_PARMSW* = ptr MCI_OPEN_PARMSW + MCI_PLAY_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwFrom*: DWORD + dwTo*: DWORD + PMCI_PLAY_PARMS* = ptr MCI_PLAY_PARMS + LPMCI_PLAY_PARMS* = ptr MCI_PLAY_PARMS + MCI_SEEK_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwTo*: DWORD + PMCI_SEEK_PARMS* = ptr MCI_SEEK_PARMS + LPMCI_SEEK_PARMS* = ptr MCI_SEEK_PARMS + MCI_STATUS_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwReturn*: DWORD_PTR + dwItem*: DWORD + dwTrack*: DWORD + PMCI_STATUS_PARMS* = ptr MCI_STATUS_PARMS + LPMCI_STATUS_PARMS* = ptr MCI_STATUS_PARMS + MCI_INFO_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + lpstrReturn*: LPSTR + dwRetSize*: DWORD + LPMCI_INFO_PARMSA* = ptr MCI_INFO_PARMSA + MCI_INFO_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + lpstrReturn*: LPWSTR + dwRetSize*: DWORD + LPMCI_INFO_PARMSW* = ptr MCI_INFO_PARMSW + MCI_GETDEVCAPS_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwReturn*: DWORD + dwItem*: DWORD + PMCI_GETDEVCAPS_PARMS* = ptr MCI_GETDEVCAPS_PARMS + LPMCI_GETDEVCAPS_PARMS* = ptr MCI_GETDEVCAPS_PARMS + MCI_SYSINFO_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + lpstrReturn*: LPSTR + dwRetSize*: DWORD + dwNumber*: DWORD + wDeviceType*: UINT + PMCI_SYSINFO_PARMSA* = ptr MCI_SYSINFO_PARMSA + LPMCI_SYSINFO_PARMSA* = ptr MCI_SYSINFO_PARMSA + MCI_SYSINFO_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + lpstrReturn*: LPWSTR + dwRetSize*: DWORD + dwNumber*: DWORD + wDeviceType*: UINT + PMCI_SYSINFO_PARMSW* = ptr MCI_SYSINFO_PARMSW + LPMCI_SYSINFO_PARMSW* = ptr MCI_SYSINFO_PARMSW + MCI_SET_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwTimeFormat*: DWORD + dwAudio*: DWORD + PMCI_SET_PARMS* = ptr MCI_SET_PARMS + LPMCI_SET_PARMS* = ptr MCI_SET_PARMS + MCI_BREAK_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + nVirtKey*: int32 + hwndBreak*: HWND + PMCI_BREAK_PARMS* = ptr MCI_BREAK_PARMS + LPMCI_BREAK_PARMS* = ptr MCI_BREAK_PARMS + MCI_SAVE_PARMSA* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCSTR + PMCI_SAVE_PARMSA* = ptr MCI_SAVE_PARMSA + LPMCI_SAVE_PARMSA* = ptr MCI_SAVE_PARMSA + MCI_SAVE_PARMSW* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCWSTR + PMCI_SAVE_PARMSW* = ptr MCI_SAVE_PARMSW + LPMCI_SAVE_PARMSW* = ptr MCI_SAVE_PARMSW + MCI_LOAD_PARMSA* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCSTR + PMCI_LOAD_PARMSA* = ptr MCI_LOAD_PARMSA + LPMCI_LOAD_PARMSA* = ptr MCI_LOAD_PARMSA + MCI_LOAD_PARMSW* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCWSTR + PMCI_LOAD_PARMSW* = ptr MCI_LOAD_PARMSW + LPMCI_LOAD_PARMSW* = ptr MCI_LOAD_PARMSW + MCI_RECORD_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwFrom*: DWORD + dwTo*: DWORD + LPMCI_RECORD_PARMS* = ptr MCI_RECORD_PARMS + MCI_VD_PLAY_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwFrom*: DWORD + dwTo*: DWORD + dwSpeed*: DWORD + PMCI_VD_PLAY_PARMS* = ptr MCI_VD_PLAY_PARMS + LPMCI_VD_PLAY_PARMS* = ptr MCI_VD_PLAY_PARMS + MCI_VD_STEP_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwFrames*: DWORD + PMCI_VD_STEP_PARMS* = ptr MCI_VD_STEP_PARMS + LPMCI_VD_STEP_PARMS* = ptr MCI_VD_STEP_PARMS + MCI_VD_ESCAPE_PARMSA* {.pure.} = object + dwCallback*: DWORD_PTR + lpstrCommand*: LPCSTR + PMCI_VD_ESCAPE_PARMSA* = ptr MCI_VD_ESCAPE_PARMSA + LPMCI_VD_ESCAPE_PARMSA* = ptr MCI_VD_ESCAPE_PARMSA + MCI_VD_ESCAPE_PARMSW* {.pure.} = object + dwCallback*: DWORD_PTR + lpstrCommand*: LPCWSTR + PMCI_VD_ESCAPE_PARMSW* = ptr MCI_VD_ESCAPE_PARMSW + LPMCI_VD_ESCAPE_PARMSW* = ptr MCI_VD_ESCAPE_PARMSW + MCI_WAVE_OPEN_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCSTR + lpstrElementName*: LPCSTR + lpstrAlias*: LPCSTR + dwBufferSeconds*: DWORD + PMCI_WAVE_OPEN_PARMSA* = ptr MCI_WAVE_OPEN_PARMSA + LPMCI_WAVE_OPEN_PARMSA* = ptr MCI_WAVE_OPEN_PARMSA + MCI_WAVE_OPEN_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCWSTR + lpstrElementName*: LPCWSTR + lpstrAlias*: LPCWSTR + dwBufferSeconds*: DWORD + PMCI_WAVE_OPEN_PARMSW* = ptr MCI_WAVE_OPEN_PARMSW + LPMCI_WAVE_OPEN_PARMSW* = ptr MCI_WAVE_OPEN_PARMSW + MCI_WAVE_DELETE_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwFrom*: DWORD + dwTo*: DWORD + PMCI_WAVE_DELETE_PARMS* = ptr MCI_WAVE_DELETE_PARMS + LPMCI_WAVE_DELETE_PARMS* = ptr MCI_WAVE_DELETE_PARMS + MCI_WAVE_SET_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + dwTimeFormat*: DWORD + dwAudio*: DWORD + wInput*: UINT + wOutput*: UINT + wFormatTag*: WORD + wReserved2*: WORD + nChannels*: WORD + wReserved3*: WORD + nSamplesPerSec*: DWORD + nAvgBytesPerSec*: DWORD + nBlockAlign*: WORD + wReserved4*: WORD + wBitsPerSample*: WORD + wReserved5*: WORD + PMCI_WAVE_SET_PARMS* = ptr MCI_WAVE_SET_PARMS + LPMCI_WAVE_SET_PARMS* = ptr MCI_WAVE_SET_PARMS + MCI_SEQ_SET_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwTimeFormat*: DWORD + dwAudio*: DWORD + dwTempo*: DWORD + dwPort*: DWORD + dwSlave*: DWORD + dwMaster*: DWORD + dwOffset*: DWORD + PMCI_SEQ_SET_PARMS* = ptr MCI_SEQ_SET_PARMS + LPMCI_SEQ_SET_PARMS* = ptr MCI_SEQ_SET_PARMS + MCI_ANIM_OPEN_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCSTR + lpstrElementName*: LPCSTR + lpstrAlias*: LPCSTR + dwStyle*: DWORD + hWndParent*: HWND + PMCI_ANIM_OPEN_PARMSA* = ptr MCI_ANIM_OPEN_PARMSA + LPMCI_ANIM_OPEN_PARMSA* = ptr MCI_ANIM_OPEN_PARMSA + MCI_ANIM_OPEN_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCWSTR + lpstrElementName*: LPCWSTR + lpstrAlias*: LPCWSTR + dwStyle*: DWORD + hWndParent*: HWND + PMCI_ANIM_OPEN_PARMSW* = ptr MCI_ANIM_OPEN_PARMSW + LPMCI_ANIM_OPEN_PARMSW* = ptr MCI_ANIM_OPEN_PARMSW + MCI_ANIM_PLAY_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwFrom*: DWORD + dwTo*: DWORD + dwSpeed*: DWORD + PMCI_ANIM_PLAY_PARMS* = ptr MCI_ANIM_PLAY_PARMS + LPMCI_ANIM_PLAY_PARMS* = ptr MCI_ANIM_PLAY_PARMS + MCI_ANIM_STEP_PARMS* {.pure, packed.} = object + dwCallback*: DWORD_PTR + dwFrames*: DWORD + PMCI_ANIM_STEP_PARMS* = ptr MCI_ANIM_STEP_PARMS + LPMCI_ANIM_STEP_PARMS* = ptr MCI_ANIM_STEP_PARMS + MCI_ANIM_WINDOW_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + hWnd*: HWND + nCmdShow*: UINT + lpstrText*: LPCSTR + PMCI_ANIM_WINDOW_PARMSA* = ptr MCI_ANIM_WINDOW_PARMSA + LPMCI_ANIM_WINDOW_PARMSA* = ptr MCI_ANIM_WINDOW_PARMSA + MCI_ANIM_WINDOW_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + hWnd*: HWND + nCmdShow*: UINT + lpstrText*: LPCWSTR + PMCI_ANIM_WINDOW_PARMSW* = ptr MCI_ANIM_WINDOW_PARMSW + LPMCI_ANIM_WINDOW_PARMSW* = ptr MCI_ANIM_WINDOW_PARMSW + MCI_ANIM_RECT_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + rc*: RECT + PMCI_ANIM_RECT_PARMS* = ptr MCI_ANIM_RECT_PARMS + LPMCI_ANIM_RECT_PARMS* = ptr MCI_ANIM_RECT_PARMS + MCI_ANIM_UPDATE_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + rc*: RECT + hDC*: HDC + PMCI_ANIM_UPDATE_PARMS* = ptr MCI_ANIM_UPDATE_PARMS + LPMCI_ANIM_UPDATE_PARMS* = ptr MCI_ANIM_UPDATE_PARMS + MCI_OVLY_OPEN_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCSTR + lpstrElementName*: LPCSTR + lpstrAlias*: LPCSTR + dwStyle*: DWORD + hWndParent*: HWND + PMCI_OVLY_OPEN_PARMSA* = ptr MCI_OVLY_OPEN_PARMSA + LPMCI_OVLY_OPEN_PARMSA* = ptr MCI_OVLY_OPEN_PARMSA + MCI_OVLY_OPEN_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + wDeviceID*: MCIDEVICEID + lpstrDeviceType*: LPCWSTR + lpstrElementName*: LPCWSTR + lpstrAlias*: LPCWSTR + dwStyle*: DWORD + hWndParent*: HWND + PMCI_OVLY_OPEN_PARMSW* = ptr MCI_OVLY_OPEN_PARMSW + LPMCI_OVLY_OPEN_PARMSW* = ptr MCI_OVLY_OPEN_PARMSW + MCI_OVLY_WINDOW_PARMSA* {.pure, packed.} = object + dwCallback*: DWORD_PTR + hWnd*: HWND + nCmdShow*: UINT + lpstrText*: LPCSTR + PMCI_OVLY_WINDOW_PARMSA* = ptr MCI_OVLY_WINDOW_PARMSA + LPMCI_OVLY_WINDOW_PARMSA* = ptr MCI_OVLY_WINDOW_PARMSA + MCI_OVLY_WINDOW_PARMSW* {.pure, packed.} = object + dwCallback*: DWORD_PTR + hWnd*: HWND + nCmdShow*: UINT + lpstrText*: LPCWSTR + PMCI_OVLY_WINDOW_PARMSW* = ptr MCI_OVLY_WINDOW_PARMSW + LPMCI_OVLY_WINDOW_PARMSW* = ptr MCI_OVLY_WINDOW_PARMSW + MCI_OVLY_RECT_PARMS* {.pure.} = object + dwCallback*: DWORD_PTR + rc*: RECT + PMCI_OVLY_RECT_PARMS* = ptr MCI_OVLY_RECT_PARMS + LPMCI_OVLY_RECT_PARMS* = ptr MCI_OVLY_RECT_PARMS + MCI_OVLY_SAVE_PARMSA* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCSTR + rc*: RECT + PMCI_OVLY_SAVE_PARMSA* = ptr MCI_OVLY_SAVE_PARMSA + LPMCI_OVLY_SAVE_PARMSA* = ptr MCI_OVLY_SAVE_PARMSA + MCI_OVLY_SAVE_PARMSW* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCWSTR + rc*: RECT + PMCI_OVLY_SAVE_PARMSW* = ptr MCI_OVLY_SAVE_PARMSW + LPMCI_OVLY_SAVE_PARMSW* = ptr MCI_OVLY_SAVE_PARMSW + MCI_OVLY_LOAD_PARMSA* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCSTR + rc*: RECT + PMCI_OVLY_LOAD_PARMSA* = ptr MCI_OVLY_LOAD_PARMSA + LPMCI_OVLY_LOAD_PARMSA* = ptr MCI_OVLY_LOAD_PARMSA + MCI_OVLY_LOAD_PARMSW* {.pure.} = object + dwCallback*: DWORD_PTR + lpfilename*: LPCWSTR + rc*: RECT + PMCI_OVLY_LOAD_PARMSW* = ptr MCI_OVLY_LOAD_PARMSW + LPMCI_OVLY_LOAD_PARMSW* = ptr MCI_OVLY_LOAD_PARMSW + WAVEFORMATEXTENSIBLE_Samples* {.pure, union.} = object + wValidBitsPerSample*: WORD + wSamplesPerBlock*: WORD + wReserved*: WORD + TWAVEFORMATEXTENSIBLE* {.pure, packed.} = object + Format*: WAVEFORMATEX + Samples*: WAVEFORMATEXTENSIBLE_Samples + dwChannelMask*: DWORD + SubFormat*: GUID + PWAVEFORMATEXTENSIBLE* = ptr TWAVEFORMATEXTENSIBLE + WAVEFORMATPCMEX* = TWAVEFORMATEXTENSIBLE + PWAVEFORMATPCMEX* = ptr WAVEFORMATPCMEX + NPWAVEFORMATPCMEX* = ptr WAVEFORMATPCMEX + LPWAVEFORMATPCMEX* = ptr WAVEFORMATPCMEX + WAVEFORMATIEEEFLOATEX* = TWAVEFORMATEXTENSIBLE + PWAVEFORMATIEEEFLOATEX* = ptr WAVEFORMATIEEEFLOATEX + NPWAVEFORMATIEEEFLOATEX* = ptr WAVEFORMATIEEEFLOATEX + LPWAVEFORMATIEEEFLOATEX* = ptr WAVEFORMATIEEEFLOATEX + ADPCMCOEFSET* {.pure.} = object + iCoef1*: int16 + iCoef2*: int16 + PADPCMCOEFSET* = ptr ADPCMCOEFSET + NPADPCMCOEFSET* = ptr ADPCMCOEFSET + LPADPCMCOEFSET* = ptr ADPCMCOEFSET + ADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + wNumCoef*: WORD + aCoef*: UncheckedArray[ADPCMCOEFSET] + PADPCMWAVEFORMAT* = ptr ADPCMWAVEFORMAT + NPADPCMWAVEFORMAT* = ptr ADPCMWAVEFORMAT + LPADPCMWAVEFORMAT* = ptr ADPCMWAVEFORMAT + DRMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wReserved*: WORD + ulContentId*: ULONG + wfxSecure*: WAVEFORMATEX + PDRMWAVEFORMAT* = ptr DRMWAVEFORMAT + NPDRMWAVEFORMAT* = ptr DRMWAVEFORMAT + LPDRMWAVEFORMAT* = ptr DRMWAVEFORMAT + DVIADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PDVIADPCMWAVEFORMAT* = ptr DVIADPCMWAVEFORMAT + NPDVIADPCMWAVEFORMAT* = ptr DVIADPCMWAVEFORMAT + LPDVIADPCMWAVEFORMAT* = ptr DVIADPCMWAVEFORMAT + IMAADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PIMAADPCMWAVEFORMAT* = ptr IMAADPCMWAVEFORMAT + NPIMAADPCMWAVEFORMAT* = ptr IMAADPCMWAVEFORMAT + LPIMAADPCMWAVEFORMAT* = ptr IMAADPCMWAVEFORMAT + MEDIASPACEADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PMEDIASPACEADPCMWAVEFORMAT* = ptr MEDIASPACEADPCMWAVEFORMAT + NPMEDIASPACEADPCMWAVEFORMAT* = ptr MEDIASPACEADPCMWAVEFORMAT + LPMEDIASPACEADPCMWAVEFORMAT* = ptr MEDIASPACEADPCMWAVEFORMAT + SIERRAADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PSIERRAADPCMWAVEFORMAT* = ptr SIERRAADPCMWAVEFORMAT + NPSIERRAADPCMWAVEFORMAT* = ptr SIERRAADPCMWAVEFORMAT + LPSIERRAADPCMWAVEFORMAT* = ptr SIERRAADPCMWAVEFORMAT + G723_ADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + cbExtraSize*: WORD + nAuxBlockSize*: WORD + PG723_ADPCMWAVEFORMAT* = ptr G723_ADPCMWAVEFORMAT + NPG723_ADPCMWAVEFORMAT* = ptr G723_ADPCMWAVEFORMAT + LPG723_ADPCMWAVEFORMAT* = ptr G723_ADPCMWAVEFORMAT + DIGISTDWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PDIGISTDWAVEFORMAT* = ptr DIGISTDWAVEFORMAT + NPDIGISTDWAVEFORMAT* = ptr DIGISTDWAVEFORMAT + LPDIGISTDWAVEFORMAT* = ptr DIGISTDWAVEFORMAT + DIGIFIXWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PDIGIFIXWAVEFORMAT* = ptr DIGIFIXWAVEFORMAT + NPDIGIFIXWAVEFORMAT* = ptr DIGIFIXWAVEFORMAT + LPDIGIFIXWAVEFORMAT* = ptr DIGIFIXWAVEFORMAT + DIALOGICOKIADPCMWAVEFORMAT* {.pure, packed.} = object + ewf*: WAVEFORMATEX + PDIALOGICOKIADPCMWAVEFORMAT* = ptr DIALOGICOKIADPCMWAVEFORMAT + NPDIALOGICOKIADPCMWAVEFORMAT* = ptr DIALOGICOKIADPCMWAVEFORMAT + LPDIALOGICOKIADPCMWAVEFORMAT* = ptr DIALOGICOKIADPCMWAVEFORMAT + YAMAHA_ADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PYAMAHA_ADPCMWAVEFORMAT* = ptr YAMAHA_ADPCMWAVEFORMAT + NPYAMAHA_ADPCMWAVEFORMAT* = ptr YAMAHA_ADPCMWAVEFORMAT + LPYAMAHA_ADPCMWAVEFORMAT* = ptr YAMAHA_ADPCMWAVEFORMAT + SONARCWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wCompType*: WORD + PSONARCWAVEFORMAT* = ptr SONARCWAVEFORMAT + NPSONARCWAVEFORMAT* = ptr SONARCWAVEFORMAT + LPSONARCWAVEFORMAT* = ptr SONARCWAVEFORMAT + TRUESPEECHWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + nSamplesPerBlock*: WORD + abReserved*: array[28, BYTE] + PTRUESPEECHWAVEFORMAT* = ptr TRUESPEECHWAVEFORMAT + NPTRUESPEECHWAVEFORMAT* = ptr TRUESPEECHWAVEFORMAT + LPTRUESPEECHWAVEFORMAT* = ptr TRUESPEECHWAVEFORMAT + ECHOSC1WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PECHOSC1WAVEFORMAT* = ptr ECHOSC1WAVEFORMAT + NPECHOSC1WAVEFORMAT* = ptr ECHOSC1WAVEFORMAT + LPECHOSC1WAVEFORMAT* = ptr ECHOSC1WAVEFORMAT + AUDIOFILE_AF36WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PAUDIOFILE_AF36WAVEFORMAT* = ptr AUDIOFILE_AF36WAVEFORMAT + NPAUDIOFILE_AF36WAVEFORMAT* = ptr AUDIOFILE_AF36WAVEFORMAT + LPAUDIOFILE_AF36WAVEFORMAT* = ptr AUDIOFILE_AF36WAVEFORMAT + APTXWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PAPTXWAVEFORMAT* = ptr APTXWAVEFORMAT + NPAPTXWAVEFORMAT* = ptr APTXWAVEFORMAT + LPAPTXWAVEFORMAT* = ptr APTXWAVEFORMAT + AUDIOFILE_AF10WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PAUDIOFILE_AF10WAVEFORMAT* = ptr AUDIOFILE_AF10WAVEFORMAT + NPAUDIOFILE_AF10WAVEFORMAT* = ptr AUDIOFILE_AF10WAVEFORMAT + LPAUDIOFILE_AF10WAVEFORMAT* = ptr AUDIOFILE_AF10WAVEFORMAT + GSM610WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PGSM610WAVEFORMAT* = ptr GSM610WAVEFORMAT + NPGSM610WAVEFORMAT* = ptr GSM610WAVEFORMAT + LPGSM610WAVEFORMAT* = ptr GSM610WAVEFORMAT + ADPCMEWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PADPCMEWAVEFORMAT* = ptr ADPCMEWAVEFORMAT + NPADPCMEWAVEFORMAT* = ptr ADPCMEWAVEFORMAT + LPADPCMEWAVEFORMAT* = ptr ADPCMEWAVEFORMAT + CONTRESVQLPCWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PCONTRESVQLPCWAVEFORMAT* = ptr CONTRESVQLPCWAVEFORMAT + NPCONTRESVQLPCWAVEFORMAT* = ptr CONTRESVQLPCWAVEFORMAT + LPCONTRESVQLPCWAVEFORMAT* = ptr CONTRESVQLPCWAVEFORMAT + DIGIREALWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PDIGIREALWAVEFORMAT* = ptr DIGIREALWAVEFORMAT + NPDIGIREALWAVEFORMAT* = ptr DIGIREALWAVEFORMAT + LPDIGIREALWAVEFORMAT* = ptr DIGIREALWAVEFORMAT + DIGIADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PDIGIADPCMWAVEFORMAT* = ptr DIGIADPCMWAVEFORMAT + NPDIGIADPCMWAVEFORMAT* = ptr DIGIADPCMWAVEFORMAT + LPDIGIADPCMWAVEFORMAT* = ptr DIGIADPCMWAVEFORMAT + CONTRESCR10WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PCONTRESCR10WAVEFORMAT* = ptr CONTRESCR10WAVEFORMAT + NPCONTRESCR10WAVEFORMAT* = ptr CONTRESCR10WAVEFORMAT + LPCONTRESCR10WAVEFORMAT* = ptr CONTRESCR10WAVEFORMAT + NMS_VBXADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + PNMS_VBXADPCMWAVEFORMAT* = ptr NMS_VBXADPCMWAVEFORMAT + NPNMS_VBXADPCMWAVEFORMAT* = ptr NMS_VBXADPCMWAVEFORMAT + LPNMS_VBXADPCMWAVEFORMAT* = ptr NMS_VBXADPCMWAVEFORMAT + G721_ADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + nAuxBlockSize*: WORD + PG721_ADPCMWAVEFORMAT* = ptr G721_ADPCMWAVEFORMAT + NPG721_ADPCMWAVEFORMAT* = ptr G721_ADPCMWAVEFORMAT + LPG721_ADPCMWAVEFORMAT* = ptr G721_ADPCMWAVEFORMAT + MPEG1WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + fwHeadLayer*: WORD + dwHeadBitrate*: DWORD + fwHeadMode*: WORD + fwHeadModeExt*: WORD + wHeadEmphasis*: WORD + fwHeadFlags*: WORD + dwPTSLow*: DWORD + dwPTSHigh*: DWORD + PMPEG1WAVEFORMAT* = ptr MPEG1WAVEFORMAT + NPMPEG1WAVEFORMAT* = ptr MPEG1WAVEFORMAT + LPMPEG1WAVEFORMAT* = ptr MPEG1WAVEFORMAT + MPEGLAYER3WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wID*: WORD + fdwFlags*: DWORD + nBlockSize*: WORD + nFramesPerBlock*: WORD + nCodecDelay*: WORD + PMPEGLAYER3WAVEFORMAT* = ptr MPEGLAYER3WAVEFORMAT + NPMPEGLAYER3WAVEFORMAT* = ptr MPEGLAYER3WAVEFORMAT + LPMPEGLAYER3WAVEFORMAT* = ptr MPEGLAYER3WAVEFORMAT + HEAACWAVEINFO* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wPayloadType*: WORD + wAudioProfileLevelIndication*: WORD + wStructType*: WORD + wReserved1*: WORD + dwReserved2*: DWORD + PHEAACWAVEINFO* = ptr HEAACWAVEINFO + NPHEAACWAVEINFO* = ptr HEAACWAVEINFO + LPHEAACWAVEINFO* = ptr HEAACWAVEINFO + HEAACWAVEFORMAT* {.pure, packed.} = object + wfInfo*: HEAACWAVEINFO + pbAudioSpecificConfig*: array[1, BYTE] + PHEAACWAVEFORMAT* = ptr HEAACWAVEFORMAT + NPHEAACWAVEFORMAT* = ptr HEAACWAVEFORMAT + LPHEAACWAVEFORMAT* = ptr HEAACWAVEFORMAT + MSAUDIO1WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wSamplesPerBlock*: WORD + wEncodeOptions*: WORD + LPMSAUDIO1WAVEFORMAT* = ptr MSAUDIO1WAVEFORMAT + WMAUDIO2WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + dwSamplesPerBlock*: DWORD + wEncodeOptions*: WORD + dwSuperBlockAlign*: DWORD + LPWMAUDIO2WAVEFORMAT* = ptr WMAUDIO2WAVEFORMAT + WMAUDIO3WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wValidBitsPerSample*: WORD + dwChannelMask*: DWORD + dwReserved1*: DWORD + dwReserved2*: DWORD + wEncodeOptions*: WORD + wReserved3*: WORD + LPWMAUDIO3WAVEFORMAT* = ptr WMAUDIO3WAVEFORMAT + CREATIVEADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PCREATIVEADPCMWAVEFORMAT* = ptr CREATIVEADPCMWAVEFORMAT + NPCREATIVEADPCMWAVEFORMAT* = ptr CREATIVEADPCMWAVEFORMAT + LPCREATIVEADPCMWAVEFORMAT* = ptr CREATIVEADPCMWAVEFORMAT + CREATIVEFASTSPEECH8WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PCREATIVEFASTSPEECH8WAVEFORMAT* = ptr CREATIVEFASTSPEECH8WAVEFORMAT + NPCREATIVEFASTSPEECH8WAVEFORMAT* = ptr CREATIVEFASTSPEECH8WAVEFORMAT + LPCREATIVEFASTSPEECH8WAVEFORMAT* = ptr CREATIVEFASTSPEECH8WAVEFORMAT + CREATIVEFASTSPEECH10WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PCREATIVEFASTSPEECH10WAVEFORMAT* = ptr CREATIVEFASTSPEECH10WAVEFORMAT + NPCREATIVEFASTSPEECH10WAVEFORMAT* = ptr CREATIVEFASTSPEECH10WAVEFORMAT + LPCREATIVEFASTSPEECH10WAVEFORMAT* = ptr CREATIVEFASTSPEECH10WAVEFORMAT + FMTOWNS_SND_WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + wRevision*: WORD + PFMTOWNS_SND_WAVEFORMAT* = ptr FMTOWNS_SND_WAVEFORMAT + NPFMTOWNS_SND_WAVEFORMAT* = ptr FMTOWNS_SND_WAVEFORMAT + LPFMTOWNS_SND_WAVEFORMAT* = ptr FMTOWNS_SND_WAVEFORMAT + OLIGSMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + POLIGSMWAVEFORMAT* = ptr OLIGSMWAVEFORMAT + NPOLIGSMWAVEFORMAT* = ptr OLIGSMWAVEFORMAT + LPOLIGSMWAVEFORMAT* = ptr OLIGSMWAVEFORMAT + OLIADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + POLIADPCMWAVEFORMAT* = ptr OLIADPCMWAVEFORMAT + NPOLIADPCMWAVEFORMAT* = ptr OLIADPCMWAVEFORMAT + LPOLIADPCMWAVEFORMAT* = ptr OLIADPCMWAVEFORMAT + OLICELPWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + POLICELPWAVEFORMAT* = ptr OLICELPWAVEFORMAT + NPOLICELPWAVEFORMAT* = ptr OLICELPWAVEFORMAT + LPOLICELPWAVEFORMAT* = ptr OLICELPWAVEFORMAT + OLISBCWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + POLISBCWAVEFORMAT* = ptr OLISBCWAVEFORMAT + NPOLISBCWAVEFORMAT* = ptr OLISBCWAVEFORMAT + LPOLISBCWAVEFORMAT* = ptr OLISBCWAVEFORMAT + OLIOPRWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + POLIOPRWAVEFORMAT* = ptr OLIOPRWAVEFORMAT + NPOLIOPRWAVEFORMAT* = ptr OLIOPRWAVEFORMAT + LPOLIOPRWAVEFORMAT* = ptr OLIOPRWAVEFORMAT + CSIMAADPCMWAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + PCSIMAADPCMWAVEFORMAT* = ptr CSIMAADPCMWAVEFORMAT + NPCSIMAADPCMWAVEFORMAT* = ptr CSIMAADPCMWAVEFORMAT + LPCSIMAADPCMWAVEFORMAT* = ptr CSIMAADPCMWAVEFORMAT + WAVEFILTER* {.pure.} = object + cbStruct*: DWORD + dwFilterTag*: DWORD + fdwFilter*: DWORD + dwReserved*: array[5, DWORD] + PWAVEFILTER* = ptr WAVEFILTER + NPWAVEFILTER* = ptr WAVEFILTER + LPWAVEFILTER* = ptr WAVEFILTER + VOLUMEWAVEFILTER* {.pure.} = object + wfltr*: WAVEFILTER + dwVolume*: DWORD + PVOLUMEWAVEFILTER* = ptr VOLUMEWAVEFILTER + NPVOLUMEWAVEFILTER* = ptr VOLUMEWAVEFILTER + LPVOLUMEWAVEFILTER* = ptr VOLUMEWAVEFILTER + ECHOWAVEFILTER* {.pure.} = object + wfltr*: WAVEFILTER + dwVolume*: DWORD + dwDelay*: DWORD + PECHOWAVEFILTER* = ptr ECHOWAVEFILTER + NPECHOWAVEFILTER* = ptr ECHOWAVEFILTER + LPECHOWAVEFILTER* = ptr ECHOWAVEFILTER +const + MAXERRORLENGTH* = 256 + TIME_MS* = 0x0001 + TIME_SAMPLES* = 0x0002 + TIME_BYTES* = 0x0004 + TIME_SMPTE* = 0x0008 + TIME_MIDI* = 0x0010 + TIME_TICKS* = 0x0020 + MM_JOY1MOVE* = 0x3A0 + MM_JOY2MOVE* = 0x3A1 + MM_JOY1ZMOVE* = 0x3A2 + MM_JOY2ZMOVE* = 0x3A3 + MM_JOY1BUTTONDOWN* = 0x3B5 + MM_JOY2BUTTONDOWN* = 0x3B6 + MM_JOY1BUTTONUP* = 0x3B7 + MM_JOY2BUTTONUP* = 0x3B8 + MM_MCINOTIFY* = 0x3B9 + MM_WOM_OPEN* = 0x3BB + MM_WOM_CLOSE* = 0x3BC + MM_WOM_DONE* = 0x3BD + MM_WIM_OPEN* = 0x3BE + MM_WIM_CLOSE* = 0x3BF + MM_WIM_DATA* = 0x3C0 + MM_MIM_OPEN* = 0x3C1 + MM_MIM_CLOSE* = 0x3C2 + MM_MIM_DATA* = 0x3C3 + MM_MIM_LONGDATA* = 0x3C4 + MM_MIM_ERROR* = 0x3C5 + MM_MIM_LONGERROR* = 0x3C6 + MM_MOM_OPEN* = 0x3C7 + MM_MOM_CLOSE* = 0x3C8 + MM_MOM_DONE* = 0x3C9 + MM_DRVM_OPEN* = 0x3D0 + MM_DRVM_CLOSE* = 0x3D1 + MM_DRVM_DATA* = 0x3D2 + MM_DRVM_ERROR* = 0x3D3 + MM_STREAM_OPEN* = 0x3D4 + MM_STREAM_CLOSE* = 0x3D5 + MM_STREAM_DONE* = 0x3D6 + MM_STREAM_ERROR* = 0x3D7 + MM_MOM_POSITIONCB* = 0x3CA + MM_MCISIGNAL* = 0x3CB + MM_MIM_MOREDATA* = 0x3CC + MM_MIXM_LINE_CHANGE* = 0x3D0 + MM_MIXM_CONTROL_CHANGE* = 0x3D1 + MMSYSERR_BASE* = 0 + WAVERR_BASE* = 32 + MIDIERR_BASE* = 64 + TIMERR_BASE* = 96 + JOYERR_BASE* = 160 + MCIERR_BASE* = 256 + MIXERR_BASE* = 1024 + MCI_STRING_OFFSET* = 512 + MCI_VD_OFFSET* = 1024 + MCI_CD_OFFSET* = 1088 + MCI_WAVE_OFFSET* = 1152 + MCI_SEQ_OFFSET* = 1216 + MMSYSERR_NOERROR* = 0 + MMSYSERR_ERROR* = MMSYSERR_BASE+1 + MMSYSERR_BADDEVICEID* = MMSYSERR_BASE+2 + MMSYSERR_NOTENABLED* = MMSYSERR_BASE+3 + MMSYSERR_ALLOCATED* = MMSYSERR_BASE+4 + MMSYSERR_INVALHANDLE* = MMSYSERR_BASE+5 + MMSYSERR_NODRIVER* = MMSYSERR_BASE+6 + MMSYSERR_NOMEM* = MMSYSERR_BASE+7 + MMSYSERR_NOTSUPPORTED* = MMSYSERR_BASE+8 + MMSYSERR_BADERRNUM* = MMSYSERR_BASE+9 + MMSYSERR_INVALFLAG* = MMSYSERR_BASE+10 + MMSYSERR_INVALPARAM* = MMSYSERR_BASE+11 + MMSYSERR_HANDLEBUSY* = MMSYSERR_BASE+12 + MMSYSERR_INVALIDALIAS* = MMSYSERR_BASE+13 + MMSYSERR_BADDB* = MMSYSERR_BASE+14 + MMSYSERR_KEYNOTFOUND* = MMSYSERR_BASE+15 + MMSYSERR_READERROR* = MMSYSERR_BASE+16 + MMSYSERR_WRITEERROR* = MMSYSERR_BASE+17 + MMSYSERR_DELETEERROR* = MMSYSERR_BASE+18 + MMSYSERR_VALNOTFOUND* = MMSYSERR_BASE+19 + MMSYSERR_NODRIVERCB* = MMSYSERR_BASE+20 + MMSYSERR_MOREDATA* = MMSYSERR_BASE+21 + MMSYSERR_LASTERROR* = MMSYSERR_BASE+21 + DRV_LOAD* = 0x0001 + DRV_ENABLE* = 0x0002 + DRV_OPEN* = 0x0003 + DRV_CLOSE* = 0x0004 + DRV_DISABLE* = 0x0005 + DRV_FREE* = 0x0006 + DRV_CONFIGURE* = 0x0007 + DRV_QUERYCONFIGURE* = 0x0008 + DRV_INSTALL* = 0x0009 + DRV_REMOVE* = 0x000A + DRV_EXITSESSION* = 0x000B + DRV_POWER* = 0x000F + DRV_RESERVED* = 0x0800 + DRV_USER* = 0x4000 + DRVCNF_CANCEL* = 0x0000 + DRVCNF_OK* = 0x0001 + DRVCNF_RESTART* = 0x0002 + DRV_CANCEL* = DRVCNF_CANCEL + DRV_OK* = DRVCNF_OK + DRV_RESTART* = DRVCNF_RESTART + DRV_MCI_FIRST* = DRV_RESERVED + DRV_MCI_LAST* = DRV_RESERVED+0xFFF + CALLBACK_TYPEMASK* = 0x00070000 + CALLBACK_NULL* = 0x00000000 + CALLBACK_WINDOW* = 0x00010000 + CALLBACK_TASK* = 0x00020000 + CALLBACK_FUNCTION* = 0x00030000 + CALLBACK_THREAD* = CALLBACK_TASK + CALLBACK_EVENT* = 0x00050000 + SND_SYNC* = 0x0000 + SND_ASYNC* = 0x0001 + SND_NODEFAULT* = 0x0002 + SND_MEMORY* = 0x0004 + SND_LOOP* = 0x0008 + SND_NOSTOP* = 0x0010 + SND_NOWAIT* = 0x00002000 + SND_ALIAS* = 0x00010000 + SND_ALIAS_ID* = 0x00110000 + SND_FILENAME* = 0x00020000 + SND_RESOURCE* = 0x00040004 + SND_PURGE* = 0x0040 + SND_APPLICATION* = 0x0080 + SND_ALIAS_START* = 0 + WAVERR_BADFORMAT* = WAVERR_BASE+0 + WAVERR_STILLPLAYING* = WAVERR_BASE+1 + WAVERR_UNPREPARED* = WAVERR_BASE+2 + WAVERR_SYNC* = WAVERR_BASE+3 + WAVERR_LASTERROR* = WAVERR_BASE+3 + WOM_OPEN* = MM_WOM_OPEN + WOM_CLOSE* = MM_WOM_CLOSE + WOM_DONE* = MM_WOM_DONE + WIM_OPEN* = MM_WIM_OPEN + WIM_CLOSE* = MM_WIM_CLOSE + WIM_DATA* = MM_WIM_DATA + WAVE_MAPPER* = UINT(-1) + WAVE_FORMAT_QUERY* = 0x0001 + WAVE_ALLOWSYNC* = 0x0002 + WAVE_MAPPED* = 0x0004 + WAVE_FORMAT_DIRECT* = 0x0008 + WAVE_FORMAT_DIRECT_QUERY* = WAVE_FORMAT_QUERY or WAVE_FORMAT_DIRECT + WHDR_DONE* = 0x00000001 + WHDR_PREPARED* = 0x00000002 + WHDR_BEGINLOOP* = 0x00000004 + WHDR_ENDLOOP* = 0x00000008 + WHDR_INQUEUE* = 0x00000010 + WAVECAPS_PITCH* = 0x0001 + WAVECAPS_PLAYBACKRATE* = 0x0002 + WAVECAPS_VOLUME* = 0x0004 + WAVECAPS_LRVOLUME* = 0x0008 + WAVECAPS_SYNC* = 0x0010 + WAVECAPS_SAMPLEACCURATE* = 0x0020 + WAVE_INVALIDFORMAT* = 0x00000000 + WAVE_FORMAT_1M08* = 0x00000001 + WAVE_FORMAT_1S08* = 0x00000002 + WAVE_FORMAT_1M16* = 0x00000004 + WAVE_FORMAT_1S16* = 0x00000008 + WAVE_FORMAT_2M08* = 0x00000010 + WAVE_FORMAT_2S08* = 0x00000020 + WAVE_FORMAT_2M16* = 0x00000040 + WAVE_FORMAT_2S16* = 0x00000080 + WAVE_FORMAT_4M08* = 0x00000100 + WAVE_FORMAT_4S08* = 0x00000200 + WAVE_FORMAT_4M16* = 0x00000400 + WAVE_FORMAT_4S16* = 0x00000800 + WAVE_FORMAT_44M08* = 0x00000100 + WAVE_FORMAT_44S08* = 0x00000200 + WAVE_FORMAT_44M16* = 0x00000400 + WAVE_FORMAT_44S16* = 0x00000800 + WAVE_FORMAT_48M08* = 0x00001000 + WAVE_FORMAT_48S08* = 0x00002000 + WAVE_FORMAT_48M16* = 0x00004000 + WAVE_FORMAT_48S16* = 0x00008000 + WAVE_FORMAT_96M08* = 0x00010000 + WAVE_FORMAT_96S08* = 0x00020000 + WAVE_FORMAT_96M16* = 0x00040000 + WAVE_FORMAT_96S16* = 0x00080000 + WAVE_FORMAT_PCM* = 1 + MIDIERR_UNPREPARED* = MIDIERR_BASE+0 + MIDIERR_STILLPLAYING* = MIDIERR_BASE+1 + MIDIERR_NOMAP* = MIDIERR_BASE+2 + MIDIERR_NOTREADY* = MIDIERR_BASE+3 + MIDIERR_NODEVICE* = MIDIERR_BASE+4 + MIDIERR_INVALIDSETUP* = MIDIERR_BASE+5 + MIDIERR_BADOPENMODE* = MIDIERR_BASE+6 + MIDIERR_DONT_CONTINUE* = MIDIERR_BASE+7 + MIDIERR_LASTERROR* = MIDIERR_BASE+7 + MIM_OPEN* = MM_MIM_OPEN + MIM_CLOSE* = MM_MIM_CLOSE + MIM_DATA* = MM_MIM_DATA + MIM_LONGDATA* = MM_MIM_LONGDATA + MIM_ERROR* = MM_MIM_ERROR + MIM_LONGERROR* = MM_MIM_LONGERROR + MOM_OPEN* = MM_MOM_OPEN + MOM_CLOSE* = MM_MOM_CLOSE + MOM_DONE* = MM_MOM_DONE + MIM_MOREDATA* = MM_MIM_MOREDATA + MOM_POSITIONCB* = MM_MOM_POSITIONCB + MIDI_MAPPER* = UINT(-1) + MIDI_IO_STATUS* = 0x00000020 + MIDI_CACHE_ALL* = 1 + MIDI_CACHE_BESTFIT* = 2 + MIDI_CACHE_QUERY* = 3 + MIDI_UNCACHE* = 4 + MOD_MIDIPORT* = 1 + MOD_SYNTH* = 2 + MOD_SQSYNTH* = 3 + MOD_FMSYNTH* = 4 + MOD_MAPPER* = 5 + MOD_WAVETABLE* = 6 + MOD_SWSYNTH* = 7 + MIDICAPS_VOLUME* = 0x0001 + MIDICAPS_LRVOLUME* = 0x0002 + MIDICAPS_CACHE* = 0x0004 + MIDICAPS_STREAM* = 0x0008 + MHDR_DONE* = 0x00000001 + MHDR_PREPARED* = 0x00000002 + MHDR_INQUEUE* = 0x00000004 + MHDR_ISSTRM* = 0x00000008 + MEVT_F_SHORT* = 0x00000000 + MEVT_F_LONG* = 0x80000000'i32 + MEVT_F_CALLBACK* = 0x40000000 + MEVT_SHORTMSG* = BYTE 0x00 + MEVT_TEMPO* = BYTE 0x01 + MEVT_NOP* = BYTE 0x02 + MEVT_LONGMSG* = BYTE 0x80 + MEVT_COMMENT* = BYTE 0x82 + MEVT_VERSION* = BYTE 0x84 + MIDISTRM_ERROR* = -2 + MIDIPROP_SET* = 0x80000000'i32 + MIDIPROP_GET* = 0x40000000 + MIDIPROP_TIMEDIV* = 0x00000001 + MIDIPROP_TEMPO* = 0x00000002 + AUX_MAPPER* = UINT(-1) + AUXCAPS_CDAUDIO* = 1 + AUXCAPS_AUXIN* = 2 + AUXCAPS_VOLUME* = 0x0001 + AUXCAPS_LRVOLUME* = 0x0002 + MIXERR_INVALLINE* = MIXERR_BASE+0 + MIXERR_INVALCONTROL* = MIXERR_BASE+1 + MIXERR_INVALVALUE* = MIXERR_BASE+2 + MIXERR_LASTERROR* = MIXERR_BASE+2 + MIXER_OBJECTF_HANDLE* = 0x80000000'i32 + MIXER_OBJECTF_MIXER* = 0x00000000 + MIXER_OBJECTF_HMIXER* = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIXER + MIXER_OBJECTF_WAVEOUT* = 0x10000000 + MIXER_OBJECTF_HWAVEOUT* = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_WAVEOUT + MIXER_OBJECTF_WAVEIN* = 0x20000000 + MIXER_OBJECTF_HWAVEIN* = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_WAVEIN + MIXER_OBJECTF_MIDIOUT* = 0x30000000 + MIXER_OBJECTF_HMIDIOUT* = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIDIOUT + MIXER_OBJECTF_MIDIIN* = 0x40000000 + MIXER_OBJECTF_HMIDIIN* = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIDIIN + MIXER_OBJECTF_AUX* = 0x50000000 + MIXERLINE_LINEF_ACTIVE* = 0x00000001 + MIXERLINE_LINEF_DISCONNECTED* = 0x00008000 + MIXERLINE_LINEF_SOURCE* = 0x80000000'i32 + MIXERLINE_COMPONENTTYPE_DST_FIRST* = 0x0 + MIXERLINE_COMPONENTTYPE_DST_UNDEFINED* = MIXERLINE_COMPONENTTYPE_DST_FIRST+0 + MIXERLINE_COMPONENTTYPE_DST_DIGITAL* = MIXERLINE_COMPONENTTYPE_DST_FIRST+1 + MIXERLINE_COMPONENTTYPE_DST_LINE* = MIXERLINE_COMPONENTTYPE_DST_FIRST+2 + MIXERLINE_COMPONENTTYPE_DST_MONITOR* = MIXERLINE_COMPONENTTYPE_DST_FIRST+3 + MIXERLINE_COMPONENTTYPE_DST_SPEAKERS* = MIXERLINE_COMPONENTTYPE_DST_FIRST+4 + MIXERLINE_COMPONENTTYPE_DST_HEADPHONES* = MIXERLINE_COMPONENTTYPE_DST_FIRST+5 + MIXERLINE_COMPONENTTYPE_DST_TELEPHONE* = MIXERLINE_COMPONENTTYPE_DST_FIRST+6 + MIXERLINE_COMPONENTTYPE_DST_WAVEIN* = MIXERLINE_COMPONENTTYPE_DST_FIRST+7 + MIXERLINE_COMPONENTTYPE_DST_VOICEIN* = MIXERLINE_COMPONENTTYPE_DST_FIRST+8 + MIXERLINE_COMPONENTTYPE_DST_LAST* = MIXERLINE_COMPONENTTYPE_DST_FIRST+8 + MIXERLINE_COMPONENTTYPE_SRC_FIRST* = 0x00001000 + MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+0 + MIXERLINE_COMPONENTTYPE_SRC_DIGITAL* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+1 + MIXERLINE_COMPONENTTYPE_SRC_LINE* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+2 + MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+3 + MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+4 + MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+5 + MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+6 + MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+7 + MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+8 + MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+9 + MIXERLINE_COMPONENTTYPE_SRC_ANALOG* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+10 + MIXERLINE_COMPONENTTYPE_SRC_LAST* = MIXERLINE_COMPONENTTYPE_SRC_FIRST+10 + MIXERLINE_TARGETTYPE_UNDEFINED* = 0 + MIXERLINE_TARGETTYPE_WAVEOUT* = 1 + MIXERLINE_TARGETTYPE_WAVEIN* = 2 + MIXERLINE_TARGETTYPE_MIDIOUT* = 3 + MIXERLINE_TARGETTYPE_MIDIIN* = 4 + MIXERLINE_TARGETTYPE_AUX* = 5 + MIXER_GETLINEINFOF_DESTINATION* = 0x00000000 + MIXER_GETLINEINFOF_SOURCE* = 0x00000001 + MIXER_GETLINEINFOF_LINEID* = 0x00000002 + MIXER_GETLINEINFOF_COMPONENTTYPE* = 0x00000003 + MIXER_GETLINEINFOF_TARGETTYPE* = 0x00000004 + MIXER_GETLINEINFOF_QUERYMASK* = 0x0000000F + MIXERCONTROL_CONTROLF_UNIFORM* = 0x00000001 + MIXERCONTROL_CONTROLF_MULTIPLE* = 0x00000002 + MIXERCONTROL_CONTROLF_DISABLED* = 0x80000000'i32 + MIXERCONTROL_CT_CLASS_MASK* = 0xF0000000'i32 + MIXERCONTROL_CT_CLASS_CUSTOM* = 0x00000000 + MIXERCONTROL_CT_CLASS_METER* = 0x10000000 + MIXERCONTROL_CT_CLASS_SWITCH* = 0x20000000 + MIXERCONTROL_CT_CLASS_NUMBER* = 0x30000000 + MIXERCONTROL_CT_CLASS_SLIDER* = 0x40000000 + MIXERCONTROL_CT_CLASS_FADER* = 0x50000000 + MIXERCONTROL_CT_CLASS_TIME* = 0x60000000 + MIXERCONTROL_CT_CLASS_LIST* = 0x70000000 + MIXERCONTROL_CT_SUBCLASS_MASK* = 0x0F000000 + MIXERCONTROL_CT_SC_SWITCH_BOOLEAN* = 0x00000000 + MIXERCONTROL_CT_SC_SWITCH_BUTTON* = 0x01000000 + MIXERCONTROL_CT_SC_METER_POLLED* = 0x00000000 + MIXERCONTROL_CT_SC_TIME_MICROSECS* = 0x00000000 + MIXERCONTROL_CT_SC_TIME_MILLISECS* = 0x01000000 + MIXERCONTROL_CT_SC_LIST_SINGLE* = 0x00000000 + MIXERCONTROL_CT_SC_LIST_MULTIPLE* = 0x01000000 + MIXERCONTROL_CT_UNITS_MASK* = 0x00FF0000 + MIXERCONTROL_CT_UNITS_CUSTOM* = 0x00000000 + MIXERCONTROL_CT_UNITS_BOOLEAN* = 0x00010000 + MIXERCONTROL_CT_UNITS_SIGNED* = 0x00020000 + MIXERCONTROL_CT_UNITS_UNSIGNED* = 0x00030000 + MIXERCONTROL_CT_UNITS_DECIBELS* = 0x00040000 + MIXERCONTROL_CT_UNITS_PERCENT* = 0x00050000 + MIXERCONTROL_CONTROLTYPE_CUSTOM* = MIXERCONTROL_CT_CLASS_CUSTOM or MIXERCONTROL_CT_UNITS_CUSTOM + MIXERCONTROL_CONTROLTYPE_BOOLEANMETER* = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_BOOLEAN + MIXERCONTROL_CONTROLTYPE_SIGNEDMETER* = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_SIGNED + MIXERCONTROL_CONTROLTYPE_PEAKMETER* = MIXERCONTROL_CONTROLTYPE_SIGNEDMETER+1 + MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER* = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_UNSIGNED + MIXERCONTROL_CONTROLTYPE_BOOLEAN* = MIXERCONTROL_CT_CLASS_SWITCH or MIXERCONTROL_CT_SC_SWITCH_BOOLEAN or MIXERCONTROL_CT_UNITS_BOOLEAN + MIXERCONTROL_CONTROLTYPE_ONOFF* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+1 + MIXERCONTROL_CONTROLTYPE_MUTE* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+2 + MIXERCONTROL_CONTROLTYPE_MONO* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+3 + MIXERCONTROL_CONTROLTYPE_LOUDNESS* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+4 + MIXERCONTROL_CONTROLTYPE_STEREOENH* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+5 + MIXERCONTROL_CONTROLTYPE_BASS_BOOST* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+0x00002277 + MIXERCONTROL_CONTROLTYPE_BUTTON* = MIXERCONTROL_CT_CLASS_SWITCH or MIXERCONTROL_CT_SC_SWITCH_BUTTON or MIXERCONTROL_CT_UNITS_BOOLEAN + MIXERCONTROL_CONTROLTYPE_DECIBELS* = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_DECIBELS + MIXERCONTROL_CONTROLTYPE_SIGNED* = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_SIGNED + MIXERCONTROL_CONTROLTYPE_UNSIGNED* = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_UNSIGNED + MIXERCONTROL_CONTROLTYPE_PERCENT* = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_PERCENT + MIXERCONTROL_CONTROLTYPE_SLIDER* = MIXERCONTROL_CT_CLASS_SLIDER or MIXERCONTROL_CT_UNITS_SIGNED + MIXERCONTROL_CONTROLTYPE_PAN* = MIXERCONTROL_CONTROLTYPE_SLIDER+1 + MIXERCONTROL_CONTROLTYPE_QSOUNDPAN* = MIXERCONTROL_CONTROLTYPE_SLIDER+2 + MIXERCONTROL_CONTROLTYPE_FADER* = MIXERCONTROL_CT_CLASS_FADER or MIXERCONTROL_CT_UNITS_UNSIGNED + MIXERCONTROL_CONTROLTYPE_VOLUME* = MIXERCONTROL_CONTROLTYPE_FADER+1 + MIXERCONTROL_CONTROLTYPE_BASS* = MIXERCONTROL_CONTROLTYPE_FADER+2 + MIXERCONTROL_CONTROLTYPE_TREBLE* = MIXERCONTROL_CONTROLTYPE_FADER+3 + MIXERCONTROL_CONTROLTYPE_EQUALIZER* = MIXERCONTROL_CONTROLTYPE_FADER+4 + MIXERCONTROL_CONTROLTYPE_SINGLESELECT* = MIXERCONTROL_CT_CLASS_LIST or MIXERCONTROL_CT_SC_LIST_SINGLE or MIXERCONTROL_CT_UNITS_BOOLEAN + MIXERCONTROL_CONTROLTYPE_MUX* = MIXERCONTROL_CONTROLTYPE_SINGLESELECT+1 + MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT* = MIXERCONTROL_CT_CLASS_LIST or MIXERCONTROL_CT_SC_LIST_MULTIPLE or MIXERCONTROL_CT_UNITS_BOOLEAN + MIXERCONTROL_CONTROLTYPE_MIXER* = MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT+1 + MIXERCONTROL_CONTROLTYPE_MICROTIME* = MIXERCONTROL_CT_CLASS_TIME or MIXERCONTROL_CT_SC_TIME_MICROSECS or MIXERCONTROL_CT_UNITS_UNSIGNED + MIXERCONTROL_CONTROLTYPE_MILLITIME* = MIXERCONTROL_CT_CLASS_TIME or MIXERCONTROL_CT_SC_TIME_MILLISECS or MIXERCONTROL_CT_UNITS_UNSIGNED + MIXER_GETLINECONTROLSF_ALL* = 0x00000000 + MIXER_GETLINECONTROLSF_ONEBYID* = 0x00000001 + MIXER_GETLINECONTROLSF_ONEBYTYPE* = 0x00000002 + MIXER_GETLINECONTROLSF_QUERYMASK* = 0x0000000F + MIXER_GETCONTROLDETAILSF_VALUE* = 0x00000000 + MIXER_GETCONTROLDETAILSF_LISTTEXT* = 0x00000001 + MIXER_GETCONTROLDETAILSF_QUERYMASK* = 0x0000000F + MIXER_SETCONTROLDETAILSF_VALUE* = 0x00000000 + MIXER_SETCONTROLDETAILSF_CUSTOM* = 0x00000001 + MIXER_SETCONTROLDETAILSF_QUERYMASK* = 0x0000000F + TIMERR_NOERROR* = 0 + TIMERR_NOCANDO* = TIMERR_BASE+1 + TIMERR_STRUCT* = TIMERR_BASE+33 + TIME_ONESHOT* = 0x0000 + TIME_PERIODIC* = 0x0001 + TIME_CALLBACK_FUNCTION* = 0x0000 + TIME_CALLBACK_EVENT_SET* = 0x0010 + TIME_CALLBACK_EVENT_PULSE* = 0x0020 + TIME_KILL_SYNCHRONOUS* = 0x0100 + JOYERR_NOERROR* = 0 + JOYERR_PARMS* = JOYERR_BASE+5 + JOYERR_NOCANDO* = JOYERR_BASE+6 + JOYERR_UNPLUGGED* = JOYERR_BASE+7 + JOY_BUTTON1* = 0x0001 + JOY_BUTTON2* = 0x0002 + JOY_BUTTON3* = 0x0004 + JOY_BUTTON4* = 0x0008 + JOY_BUTTON1CHG* = 0x0100 + JOY_BUTTON2CHG* = 0x0200 + JOY_BUTTON3CHG* = 0x0400 + JOY_BUTTON4CHG* = 0x0800 + JOY_BUTTON5* = 0x00000010 + JOY_BUTTON6* = 0x00000020 + JOY_BUTTON7* = 0x00000040 + JOY_BUTTON8* = 0x00000080 + JOY_BUTTON9* = 0x00000100 + JOY_BUTTON10* = 0x00000200 + JOY_BUTTON11* = 0x00000400 + JOY_BUTTON12* = 0x00000800 + JOY_BUTTON13* = 0x00001000 + JOY_BUTTON14* = 0x00002000 + JOY_BUTTON15* = 0x00004000 + JOY_BUTTON16* = 0x00008000 + JOY_BUTTON17* = 0x00010000 + JOY_BUTTON18* = 0x00020000 + JOY_BUTTON19* = 0x00040000 + JOY_BUTTON20* = 0x00080000 + JOY_BUTTON21* = 0x00100000 + JOY_BUTTON22* = 0x00200000 + JOY_BUTTON23* = 0x00400000 + JOY_BUTTON24* = 0x00800000 + JOY_BUTTON25* = 0x01000000 + JOY_BUTTON26* = 0x02000000 + JOY_BUTTON27* = 0x04000000 + JOY_BUTTON28* = 0x08000000 + JOY_BUTTON29* = 0x10000000 + JOY_BUTTON30* = 0x20000000 + JOY_BUTTON31* = 0x40000000 + JOY_BUTTON32* = 0x80000000'i32 + JOY_POVFORWARD* = 0 + JOY_POVRIGHT* = 9000 + JOY_POVBACKWARD* = 18000 + JOY_POVLEFT* = 27000 + JOY_RETURNX* = 0x00000001 + JOY_RETURNY* = 0x00000002 + JOY_RETURNZ* = 0x00000004 + JOY_RETURNR* = 0x00000008 + JOY_RETURNU* = 0x00000010 + JOY_RETURNV* = 0x00000020 + JOY_RETURNPOV* = 0x00000040 + JOY_RETURNBUTTONS* = 0x00000080 + JOY_RETURNRAWDATA* = 0x00000100 + JOY_RETURNPOVCTS* = 0x00000200 + JOY_RETURNCENTERED* = 0x00000400 + JOY_USEDEADZONE* = 0x00000800 + JOY_RETURNALL* = JOY_RETURNX or JOY_RETURNY or JOY_RETURNZ or JOY_RETURNR or JOY_RETURNU or JOY_RETURNV or JOY_RETURNPOV or JOY_RETURNBUTTONS + JOY_CAL_READALWAYS* = 0x00010000 + JOY_CAL_READXYONLY* = 0x00020000 + JOY_CAL_READ3* = 0x00040000 + JOY_CAL_READ4* = 0x00080000 + JOY_CAL_READXONLY* = 0x00100000 + JOY_CAL_READYONLY* = 0x00200000 + JOY_CAL_READ5* = 0x00400000 + JOY_CAL_READ6* = 0x00800000 + JOY_CAL_READZONLY* = 0x01000000 + JOY_CAL_READRONLY* = 0x02000000 + JOY_CAL_READUONLY* = 0x04000000 + JOY_CAL_READVONLY* = 0x08000000 + JOYSTICKID1* = 0 + JOYSTICKID2* = 1 + JOYCAPS_HASZ* = 0x0001 + JOYCAPS_HASR* = 0x0002 + JOYCAPS_HASU* = 0x0004 + JOYCAPS_HASV* = 0x0008 + JOYCAPS_HASPOV* = 0x0010 + JOYCAPS_POV4DIR* = 0x0020 + JOYCAPS_POVCTS* = 0x0040 + MMIOERR_BASE* = 256 + MMIOERR_FILENOTFOUND* = MMIOERR_BASE+1 + MMIOERR_OUTOFMEMORY* = MMIOERR_BASE+2 + MMIOERR_CANNOTOPEN* = MMIOERR_BASE+3 + MMIOERR_CANNOTCLOSE* = MMIOERR_BASE+4 + MMIOERR_CANNOTREAD* = MMIOERR_BASE+5 + MMIOERR_CANNOTWRITE* = MMIOERR_BASE+6 + MMIOERR_CANNOTSEEK* = MMIOERR_BASE+7 + MMIOERR_CANNOTEXPAND* = MMIOERR_BASE+8 + MMIOERR_CHUNKNOTFOUND* = MMIOERR_BASE+9 + MMIOERR_UNBUFFERED* = MMIOERR_BASE+10 + MMIOERR_PATHNOTFOUND* = MMIOERR_BASE+11 + MMIOERR_ACCESSDENIED* = MMIOERR_BASE+12 + MMIOERR_SHARINGVIOLATION* = MMIOERR_BASE+13 + MMIOERR_NETWORKERROR* = MMIOERR_BASE+14 + MMIOERR_TOOMANYOPENFILES* = MMIOERR_BASE+15 + MMIOERR_INVALIDFILE* = MMIOERR_BASE+16 + CFSEPCHAR* = 0x2B + MMIO_RWMODE* = 0x00000003 + MMIO_SHAREMODE* = 0x00000070 + MMIO_CREATE* = 0x00001000 + MMIO_PARSE* = 0x00000100 + MMIO_DELETE* = 0x00000200 + MMIO_EXIST* = 0x00004000 + MMIO_ALLOCBUF* = 0x00010000 + MMIO_GETTEMP* = 0x00020000 + MMIO_DIRTY* = 0x10000000 + MMIO_READ* = 0x00000000 + MMIO_WRITE* = 0x00000001 + MMIO_READWRITE* = 0x00000002 + MMIO_COMPAT* = 0x00000000 + MMIO_EXCLUSIVE* = 0x00000010 + MMIO_DENYWRITE* = 0x00000020 + MMIO_DENYREAD* = 0x00000030 + MMIO_DENYNONE* = 0x00000040 + MMIO_FHOPEN* = 0x0010 + MMIO_EMPTYBUF* = 0x0010 + MMIO_TOUPPER* = 0x0010 + MMIO_INSTALLPROC* = 0x00010000 + MMIO_GLOBALPROC* = 0x10000000 + MMIO_REMOVEPROC* = 0x00020000 + MMIO_UNICODEPROC* = 0x01000000 + MMIO_FINDPROC* = 0x00040000 + MMIO_FINDCHUNK* = 0x0010 + MMIO_FINDRIFF* = 0x0020 + MMIO_FINDLIST* = 0x0040 + MMIO_CREATERIFF* = 0x0020 + MMIO_CREATELIST* = 0x0040 + MMIOM_READ* = MMIO_READ + MMIOM_WRITE* = MMIO_WRITE + MMIOM_SEEK* = 2 + MMIOM_OPEN* = 3 + MMIOM_CLOSE* = 4 + MMIOM_WRITEFLUSH* = 5 + MMIOM_RENAME* = 6 + MMIOM_USER* = 0x8000 + SEEK_SET* = 0 + SEEK_CUR* = 1 + SEEK_END* = 2 + MMIO_DEFAULTBUFFER* = 8192 + MCIERR_INVALID_DEVICE_ID* = MCIERR_BASE+1 + MCIERR_UNRECOGNIZED_KEYWORD* = MCIERR_BASE+3 + MCIERR_UNRECOGNIZED_COMMAND* = MCIERR_BASE+5 + MCIERR_HARDWARE* = MCIERR_BASE+6 + MCIERR_INVALID_DEVICE_NAME* = MCIERR_BASE+7 + MCIERR_OUT_OF_MEMORY* = MCIERR_BASE+8 + MCIERR_DEVICE_OPEN* = MCIERR_BASE+9 + MCIERR_CANNOT_LOAD_DRIVER* = MCIERR_BASE+10 + MCIERR_MISSING_COMMAND_STRING* = MCIERR_BASE+11 + MCIERR_PARAM_OVERFLOW* = MCIERR_BASE+12 + MCIERR_MISSING_STRING_ARGUMENT* = MCIERR_BASE+13 + MCIERR_BAD_INTEGER* = MCIERR_BASE+14 + MCIERR_PARSER_INTERNAL* = MCIERR_BASE+15 + MCIERR_DRIVER_INTERNAL* = MCIERR_BASE+16 + MCIERR_MISSING_PARAMETER* = MCIERR_BASE+17 + MCIERR_UNSUPPORTED_FUNCTION* = MCIERR_BASE+18 + MCIERR_FILE_NOT_FOUND* = MCIERR_BASE+19 + MCIERR_DEVICE_NOT_READY* = MCIERR_BASE+20 + MCIERR_INTERNAL* = MCIERR_BASE+21 + MCIERR_DRIVER* = MCIERR_BASE+22 + MCIERR_CANNOT_USE_ALL* = MCIERR_BASE+23 + MCIERR_MULTIPLE* = MCIERR_BASE+24 + MCIERR_EXTENSION_NOT_FOUND* = MCIERR_BASE+25 + MCIERR_OUTOFRANGE* = MCIERR_BASE+26 + MCIERR_FLAGS_NOT_COMPATIBLE* = MCIERR_BASE+28 + MCIERR_FILE_NOT_SAVED* = MCIERR_BASE+30 + MCIERR_DEVICE_TYPE_REQUIRED* = MCIERR_BASE+31 + MCIERR_DEVICE_LOCKED* = MCIERR_BASE+32 + MCIERR_DUPLICATE_ALIAS* = MCIERR_BASE+33 + MCIERR_BAD_CONSTANT* = MCIERR_BASE+34 + MCIERR_MUST_USE_SHAREABLE* = MCIERR_BASE+35 + MCIERR_MISSING_DEVICE_NAME* = MCIERR_BASE+36 + MCIERR_BAD_TIME_FORMAT* = MCIERR_BASE+37 + MCIERR_NO_CLOSING_QUOTE* = MCIERR_BASE+38 + MCIERR_DUPLICATE_FLAGS* = MCIERR_BASE+39 + MCIERR_INVALID_FILE* = MCIERR_BASE+40 + MCIERR_NULL_PARAMETER_BLOCK* = MCIERR_BASE+41 + MCIERR_UNNAMED_RESOURCE* = MCIERR_BASE+42 + MCIERR_NEW_REQUIRES_ALIAS* = MCIERR_BASE+43 + MCIERR_NOTIFY_ON_AUTO_OPEN* = MCIERR_BASE+44 + MCIERR_NO_ELEMENT_ALLOWED* = MCIERR_BASE+45 + MCIERR_NONAPPLICABLE_FUNCTION* = MCIERR_BASE+46 + MCIERR_ILLEGAL_FOR_AUTO_OPEN* = MCIERR_BASE+47 + MCIERR_FILENAME_REQUIRED* = MCIERR_BASE+48 + MCIERR_EXTRA_CHARACTERS* = MCIERR_BASE+49 + MCIERR_DEVICE_NOT_INSTALLED* = MCIERR_BASE+50 + MCIERR_GET_CD* = MCIERR_BASE+51 + MCIERR_SET_CD* = MCIERR_BASE+52 + MCIERR_SET_DRIVE* = MCIERR_BASE+53 + MCIERR_DEVICE_LENGTH* = MCIERR_BASE+54 + MCIERR_DEVICE_ORD_LENGTH* = MCIERR_BASE+55 + MCIERR_NO_INTEGER* = MCIERR_BASE+56 + MCIERR_WAVE_OUTPUTSINUSE* = MCIERR_BASE+64 + MCIERR_WAVE_SETOUTPUTINUSE* = MCIERR_BASE+65 + MCIERR_WAVE_INPUTSINUSE* = MCIERR_BASE+66 + MCIERR_WAVE_SETINPUTINUSE* = MCIERR_BASE+67 + MCIERR_WAVE_OUTPUTUNSPECIFIED* = MCIERR_BASE+68 + MCIERR_WAVE_INPUTUNSPECIFIED* = MCIERR_BASE+69 + MCIERR_WAVE_OUTPUTSUNSUITABLE* = MCIERR_BASE+70 + MCIERR_WAVE_SETOUTPUTUNSUITABLE* = MCIERR_BASE+71 + MCIERR_WAVE_INPUTSUNSUITABLE* = MCIERR_BASE+72 + MCIERR_WAVE_SETINPUTUNSUITABLE* = MCIERR_BASE+73 + MCIERR_SEQ_DIV_INCOMPATIBLE* = MCIERR_BASE+80 + MCIERR_SEQ_PORT_INUSE* = MCIERR_BASE+81 + MCIERR_SEQ_PORT_NONEXISTENT* = MCIERR_BASE+82 + MCIERR_SEQ_PORT_MAPNODEVICE* = MCIERR_BASE+83 + MCIERR_SEQ_PORT_MISCERROR* = MCIERR_BASE+84 + MCIERR_SEQ_TIMER* = MCIERR_BASE+85 + MCIERR_SEQ_PORTUNSPECIFIED* = MCIERR_BASE+86 + MCIERR_SEQ_NOMIDIPRESENT* = MCIERR_BASE+87 + MCIERR_NO_WINDOW* = MCIERR_BASE+90 + MCIERR_CREATEWINDOW* = MCIERR_BASE+91 + MCIERR_FILE_READ* = MCIERR_BASE+92 + MCIERR_FILE_WRITE* = MCIERR_BASE+93 + MCIERR_NO_IDENTITY* = MCIERR_BASE+94 + MCIERR_CUSTOM_DRIVER_BASE* = MCIERR_BASE+256 + MCI_FIRST* = DRV_MCI_FIRST + MCI_OPEN* = 0x0803 + MCI_CLOSE* = 0x0804 + MCI_ESCAPE* = 0x0805 + MCI_PLAY* = 0x0806 + MCI_SEEK* = 0x0807 + MCI_STOP* = 0x0808 + MCI_PAUSE* = 0x0809 + MCI_INFO* = 0x080A + MCI_GETDEVCAPS* = 0x080B + MCI_SPIN* = 0x080C + MCI_SET* = 0x080D + MCI_STEP* = 0x080E + MCI_RECORD* = 0x080F + MCI_SYSINFO* = 0x0810 + MCI_BREAK* = 0x0811 + MCI_SAVE* = 0x0813 + MCI_STATUS* = 0x0814 + MCI_CUE* = 0x0830 + MCI_REALIZE* = 0x0840 + MCI_WINDOW* = 0x0841 + MCI_PUT* = 0x0842 + MCI_WHERE* = 0x0843 + MCI_FREEZE* = 0x0844 + MCI_UNFREEZE* = 0x0845 + MCI_LOAD* = 0x0850 + MCI_CUT* = 0x0851 + MCI_COPY* = 0x0852 + MCI_PASTE* = 0x0853 + MCI_UPDATE* = 0x0854 + MCI_RESUME* = 0x0855 + MCI_DELETE* = 0x0856 + MCI_USER_MESSAGES* = DRV_MCI_FIRST+0x400 + MCI_LAST* = 0x0FFF + MCI_ALL_DEVICE_ID* = MCIDEVICEID(-1) + MCI_DEVTYPE_VCR* = 513 + MCI_DEVTYPE_VIDEODISC* = 514 + MCI_DEVTYPE_OVERLAY* = 515 + MCI_DEVTYPE_CD_AUDIO* = 516 + MCI_DEVTYPE_DAT* = 517 + MCI_DEVTYPE_SCANNER* = 518 + MCI_DEVTYPE_ANIMATION* = 519 + MCI_DEVTYPE_DIGITAL_VIDEO* = 520 + MCI_DEVTYPE_OTHER* = 521 + MCI_DEVTYPE_WAVEFORM_AUDIO* = 522 + MCI_DEVTYPE_SEQUENCER* = 523 + MCI_DEVTYPE_FIRST* = MCI_DEVTYPE_VCR + MCI_DEVTYPE_LAST* = MCI_DEVTYPE_SEQUENCER + MCI_DEVTYPE_FIRST_USER* = 0x1000 + MCI_MODE_NOT_READY* = MCI_STRING_OFFSET+12 + MCI_MODE_STOP* = MCI_STRING_OFFSET+13 + MCI_MODE_PLAY* = MCI_STRING_OFFSET+14 + MCI_MODE_RECORD* = MCI_STRING_OFFSET+15 + MCI_MODE_SEEK* = MCI_STRING_OFFSET+16 + MCI_MODE_PAUSE* = MCI_STRING_OFFSET+17 + MCI_MODE_OPEN* = MCI_STRING_OFFSET+18 + MCI_FORMAT_MILLISECONDS* = 0 + MCI_FORMAT_HMS* = 1 + MCI_FORMAT_MSF* = 2 + MCI_FORMAT_FRAMES* = 3 + MCI_FORMAT_SMPTE_24* = 4 + MCI_FORMAT_SMPTE_25* = 5 + MCI_FORMAT_SMPTE_30* = 6 + MCI_FORMAT_SMPTE_30DROP* = 7 + MCI_FORMAT_BYTES* = 8 + MCI_FORMAT_SAMPLES* = 9 + MCI_FORMAT_TMSF* = 10 + MCI_NOTIFY_SUCCESSFUL* = 0x0001 + MCI_NOTIFY_SUPERSEDED* = 0x0002 + MCI_NOTIFY_ABORTED* = 0x0004 + MCI_NOTIFY_FAILURE* = 0x0008 + MCI_NOTIFY* = 0x00000001 + MCI_WAIT* = 0x00000002 + MCI_FROM* = 0x00000004 + MCI_TO* = 0x00000008 + MCI_TRACK* = 0x00000010 + MCI_OPEN_SHAREABLE* = 0x00000100 + MCI_OPEN_ELEMENT* = 0x00000200 + MCI_OPEN_ALIAS* = 0x00000400 + MCI_OPEN_ELEMENT_ID* = 0x00000800 + MCI_OPEN_TYPE_ID* = 0x00001000 + MCI_OPEN_TYPE* = 0x00002000 + MCI_SEEK_TO_START* = 0x00000100 + MCI_SEEK_TO_END* = 0x00000200 + MCI_STATUS_ITEM* = 0x00000100 + MCI_STATUS_START* = 0x00000200 + MCI_STATUS_LENGTH* = 0x00000001 + MCI_STATUS_POSITION* = 0x00000002 + MCI_STATUS_NUMBER_OF_TRACKS* = 0x00000003 + MCI_STATUS_MODE* = 0x00000004 + MCI_STATUS_MEDIA_PRESENT* = 0x00000005 + MCI_STATUS_TIME_FORMAT* = 0x00000006 + MCI_STATUS_READY* = 0x00000007 + MCI_STATUS_CURRENT_TRACK* = 0x00000008 + MCI_INFO_PRODUCT* = 0x00000100 + MCI_INFO_FILE* = 0x00000200 + MCI_INFO_MEDIA_UPC* = 0x00000400 + MCI_INFO_MEDIA_IDENTITY* = 0x00000800 + MCI_INFO_NAME* = 0x00001000 + MCI_INFO_COPYRIGHT* = 0x00002000 + MCI_GETDEVCAPS_ITEM* = 0x00000100 + MCI_GETDEVCAPS_CAN_RECORD* = 0x00000001 + MCI_GETDEVCAPS_HAS_AUDIO* = 0x00000002 + MCI_GETDEVCAPS_HAS_VIDEO* = 0x00000003 + MCI_GETDEVCAPS_DEVICE_TYPE* = 0x00000004 + MCI_GETDEVCAPS_USES_FILES* = 0x00000005 + MCI_GETDEVCAPS_COMPOUND_DEVICE* = 0x00000006 + MCI_GETDEVCAPS_CAN_EJECT* = 0x00000007 + MCI_GETDEVCAPS_CAN_PLAY* = 0x00000008 + MCI_GETDEVCAPS_CAN_SAVE* = 0x00000009 + MCI_SYSINFO_QUANTITY* = 0x00000100 + MCI_SYSINFO_OPEN* = 0x00000200 + MCI_SYSINFO_NAME* = 0x00000400 + MCI_SYSINFO_INSTALLNAME* = 0x00000800 + MCI_SET_DOOR_OPEN* = 0x00000100 + MCI_SET_DOOR_CLOSED* = 0x00000200 + MCI_SET_TIME_FORMAT* = 0x00000400 + MCI_SET_AUDIO* = 0x00000800 + MCI_SET_VIDEO* = 0x00001000 + MCI_SET_ON* = 0x00002000 + MCI_SET_OFF* = 0x00004000 + MCI_SET_AUDIO_ALL* = 0x00000000 + MCI_SET_AUDIO_LEFT* = 0x00000001 + MCI_SET_AUDIO_RIGHT* = 0x00000002 + MCI_BREAK_KEY* = 0x00000100 + MCI_BREAK_HWND* = 0x00000200 + MCI_BREAK_OFF* = 0x00000400 + MCI_RECORD_INSERT* = 0x00000100 + MCI_RECORD_OVERWRITE* = 0x00000200 + MCI_SAVE_FILE* = 0x00000100 + MCI_LOAD_FILE* = 0x00000100 + MCI_VD_MODE_PARK* = MCI_VD_OFFSET+1 + MCI_VD_MEDIA_CLV* = MCI_VD_OFFSET+2 + MCI_VD_MEDIA_CAV* = MCI_VD_OFFSET+3 + MCI_VD_MEDIA_OTHER* = MCI_VD_OFFSET+4 + MCI_VD_FORMAT_TRACK* = 0x4001 + MCI_VD_PLAY_REVERSE* = 0x00010000 + MCI_VD_PLAY_FAST* = 0x00020000 + MCI_VD_PLAY_SPEED* = 0x00040000 + MCI_VD_PLAY_SCAN* = 0x00080000 + MCI_VD_PLAY_SLOW* = 0x00100000 + MCI_VD_SEEK_REVERSE* = 0x00010000 + MCI_VD_STATUS_SPEED* = 0x00004002 + MCI_VD_STATUS_FORWARD* = 0x00004003 + MCI_VD_STATUS_MEDIA_TYPE* = 0x00004004 + MCI_VD_STATUS_SIDE* = 0x00004005 + MCI_VD_STATUS_DISC_SIZE* = 0x00004006 + MCI_VD_GETDEVCAPS_CLV* = 0x00010000 + MCI_VD_GETDEVCAPS_CAV* = 0x00020000 + MCI_VD_SPIN_UP* = 0x00010000 + MCI_VD_SPIN_DOWN* = 0x00020000 + MCI_VD_GETDEVCAPS_CAN_REVERSE* = 0x00004002 + MCI_VD_GETDEVCAPS_FAST_RATE* = 0x00004003 + MCI_VD_GETDEVCAPS_SLOW_RATE* = 0x00004004 + MCI_VD_GETDEVCAPS_NORMAL_RATE* = 0x00004005 + MCI_VD_STEP_FRAMES* = 0x00010000 + MCI_VD_STEP_REVERSE* = 0x00020000 + MCI_VD_ESCAPE_STRING* = 0x00000100 + MCI_CDA_STATUS_TYPE_TRACK* = 0x00004001 + MCI_CDA_TRACK_AUDIO* = MCI_CD_OFFSET+0 + MCI_CDA_TRACK_OTHER* = MCI_CD_OFFSET+1 + MCI_WAVE_PCM* = MCI_WAVE_OFFSET+0 + MCI_WAVE_MAPPER* = MCI_WAVE_OFFSET+1 + MCI_WAVE_OPEN_BUFFER* = 0x00010000 + MCI_WAVE_SET_FORMATTAG* = 0x00010000 + MCI_WAVE_SET_CHANNELS* = 0x00020000 + MCI_WAVE_SET_SAMPLESPERSEC* = 0x00040000 + MCI_WAVE_SET_AVGBYTESPERSEC* = 0x00080000 + MCI_WAVE_SET_BLOCKALIGN* = 0x00100000 + MCI_WAVE_SET_BITSPERSAMPLE* = 0x00200000 + MCI_WAVE_INPUT* = 0x00400000 + MCI_WAVE_OUTPUT* = 0x00800000 + MCI_WAVE_STATUS_FORMATTAG* = 0x00004001 + MCI_WAVE_STATUS_CHANNELS* = 0x00004002 + MCI_WAVE_STATUS_SAMPLESPERSEC* = 0x00004003 + MCI_WAVE_STATUS_AVGBYTESPERSEC* = 0x00004004 + MCI_WAVE_STATUS_BLOCKALIGN* = 0x00004005 + MCI_WAVE_STATUS_BITSPERSAMPLE* = 0x00004006 + MCI_WAVE_STATUS_LEVEL* = 0x00004007 + MCI_WAVE_SET_ANYINPUT* = 0x04000000 + MCI_WAVE_SET_ANYOUTPUT* = 0x08000000 + MCI_WAVE_GETDEVCAPS_INPUTS* = 0x00004001 + MCI_WAVE_GETDEVCAPS_OUTPUTS* = 0x00004002 + MCI_SEQ_DIV_PPQN* = 0+MCI_SEQ_OFFSET + MCI_SEQ_DIV_SMPTE_24* = 1+MCI_SEQ_OFFSET + MCI_SEQ_DIV_SMPTE_25* = 2+MCI_SEQ_OFFSET + MCI_SEQ_DIV_SMPTE_30DROP* = 3+MCI_SEQ_OFFSET + MCI_SEQ_DIV_SMPTE_30* = 4+MCI_SEQ_OFFSET + MCI_SEQ_FORMAT_SONGPTR* = 0x4001 + MCI_SEQ_FILE* = 0x4002 + MCI_SEQ_MIDI* = 0x4003 + MCI_SEQ_SMPTE* = 0x4004 + MCI_SEQ_NONE* = 65533 + MCI_SEQ_MAPPER* = 65535 + MCI_SEQ_STATUS_TEMPO* = 0x00004002 + MCI_SEQ_STATUS_PORT* = 0x00004003 + MCI_SEQ_STATUS_SLAVE* = 0x00004007 + MCI_SEQ_STATUS_MASTER* = 0x00004008 + MCI_SEQ_STATUS_OFFSET* = 0x00004009 + MCI_SEQ_STATUS_DIVTYPE* = 0x0000400A + MCI_SEQ_STATUS_NAME* = 0x0000400B + MCI_SEQ_STATUS_COPYRIGHT* = 0x0000400C + MCI_SEQ_SET_TEMPO* = 0x00010000 + MCI_SEQ_SET_PORT* = 0x00020000 + MCI_SEQ_SET_SLAVE* = 0x00040000 + MCI_SEQ_SET_MASTER* = 0x00080000 + MCI_SEQ_SET_OFFSET* = 0x01000000 + MCI_ANIM_OPEN_WS* = 0x00010000 + MCI_ANIM_OPEN_PARENT* = 0x00020000 + MCI_ANIM_OPEN_NOSTATIC* = 0x00040000 + MCI_ANIM_PLAY_SPEED* = 0x00010000 + MCI_ANIM_PLAY_REVERSE* = 0x00020000 + MCI_ANIM_PLAY_FAST* = 0x00040000 + MCI_ANIM_PLAY_SLOW* = 0x00080000 + MCI_ANIM_PLAY_SCAN* = 0x00100000 + MCI_ANIM_STEP_REVERSE* = 0x00010000 + MCI_ANIM_STEP_FRAMES* = 0x00020000 + MCI_ANIM_STATUS_SPEED* = 0x00004001 + MCI_ANIM_STATUS_FORWARD* = 0x00004002 + MCI_ANIM_STATUS_HWND* = 0x00004003 + MCI_ANIM_STATUS_HPAL* = 0x00004004 + MCI_ANIM_STATUS_STRETCH* = 0x00004005 + MCI_ANIM_INFO_TEXT* = 0x00010000 + MCI_ANIM_GETDEVCAPS_CAN_REVERSE* = 0x00004001 + MCI_ANIM_GETDEVCAPS_FAST_RATE* = 0x00004002 + MCI_ANIM_GETDEVCAPS_SLOW_RATE* = 0x00004003 + MCI_ANIM_GETDEVCAPS_NORMAL_RATE* = 0x00004004 + MCI_ANIM_GETDEVCAPS_PALETTES* = 0x00004006 + MCI_ANIM_GETDEVCAPS_CAN_STRETCH* = 0x00004007 + MCI_ANIM_GETDEVCAPS_MAX_WINDOWS* = 0x00004008 + MCI_ANIM_REALIZE_NORM* = 0x00010000 + MCI_ANIM_REALIZE_BKGD* = 0x00020000 + MCI_ANIM_WINDOW_HWND* = 0x00010000 + MCI_ANIM_WINDOW_STATE* = 0x00040000 + MCI_ANIM_WINDOW_TEXT* = 0x00080000 + MCI_ANIM_WINDOW_ENABLE_STRETCH* = 0x00100000 + MCI_ANIM_WINDOW_DISABLE_STRETCH* = 0x00200000 + MCI_ANIM_WINDOW_DEFAULT* = 0x00000000 + MCI_ANIM_RECT* = 0x00010000 + MCI_ANIM_PUT_SOURCE* = 0x00020000 + MCI_ANIM_PUT_DESTINATION* = 0x00040000 + MCI_ANIM_WHERE_SOURCE* = 0x00020000 + MCI_ANIM_WHERE_DESTINATION* = 0x00040000 + MCI_ANIM_UPDATE_HDC* = 0x00020000 + MCI_OVLY_OPEN_WS* = 0x00010000 + MCI_OVLY_OPEN_PARENT* = 0x00020000 + MCI_OVLY_STATUS_HWND* = 0x00004001 + MCI_OVLY_STATUS_STRETCH* = 0x00004002 + MCI_OVLY_INFO_TEXT* = 0x00010000 + MCI_OVLY_GETDEVCAPS_CAN_STRETCH* = 0x00004001 + MCI_OVLY_GETDEVCAPS_CAN_FREEZE* = 0x00004002 + MCI_OVLY_GETDEVCAPS_MAX_WINDOWS* = 0x00004003 + MCI_OVLY_WINDOW_HWND* = 0x00010000 + MCI_OVLY_WINDOW_STATE* = 0x00040000 + MCI_OVLY_WINDOW_TEXT* = 0x00080000 + MCI_OVLY_WINDOW_ENABLE_STRETCH* = 0x00100000 + MCI_OVLY_WINDOW_DISABLE_STRETCH* = 0x00200000 + MCI_OVLY_WINDOW_DEFAULT* = 0x00000000 + MCI_OVLY_RECT* = 0x00010000 + MCI_OVLY_PUT_SOURCE* = 0x00020000 + MCI_OVLY_PUT_DESTINATION* = 0x00040000 + MCI_OVLY_PUT_FRAME* = 0x00080000 + MCI_OVLY_PUT_VIDEO* = 0x00100000 + MCI_OVLY_WHERE_SOURCE* = 0x00020000 + MCI_OVLY_WHERE_DESTINATION* = 0x00040000 + MCI_OVLY_WHERE_FRAME* = 0x00080000 + MCI_OVLY_WHERE_VIDEO* = 0x00100000 + NEWTRANSPARENT* = 3 + QUERYROPSUPPORT* = 40 + SELECTDIB* = 41 + INC_MMREG* = 158 + MM_MICROSOFT* = 1 + MM_CREATIVE* = 2 + MM_MEDIAVISION* = 3 + MM_FUJITSU* = 4 + MM_PRAGMATRAX* = 5 + MM_CYRIX* = 6 + MM_PHILIPS_SPEECH_PROCESSING* = 7 + MM_NETXL* = 8 + MM_ZYXEL* = 9 + MM_BECUBED* = 10 + MM_AARDVARK* = 11 + MM_BINTEC* = 12 + MM_HEWLETT_PACKARD* = 13 + MM_ACULAB* = 14 + MM_FAITH* = 15 + MM_MITEL* = 16 + MM_QUANTUM3D* = 17 + MM_SNI* = 18 + MM_EMU* = 19 + MM_ARTISOFT* = 20 + MM_TURTLE_BEACH* = 21 + MM_IBM* = 22 + MM_VOCALTEC* = 23 + MM_ROLAND* = 24 + MM_DSP_SOLUTIONS* = 25 + MM_NEC* = 26 + MM_ATI* = 27 + MM_WANGLABS* = 28 + MM_TANDY* = 29 + MM_VOYETRA* = 30 + MM_ANTEX* = 31 + MM_ICL_PS* = 32 + MM_INTEL* = 33 + MM_GRAVIS* = 34 + MM_VAL* = 35 + MM_INTERACTIVE* = 36 + MM_YAMAHA* = 37 + MM_EVEREX* = 38 + MM_ECHO* = 39 + MM_SIERRA* = 40 + MM_CAT* = 41 + MM_APPS* = 42 + MM_DSP_GROUP* = 43 + MM_MELABS* = 44 + MM_COMPUTER_FRIENDS* = 45 + MM_ESS* = 46 + MM_AUDIOFILE* = 47 + MM_MOTOROLA* = 48 + MM_CANOPUS* = 49 + MM_EPSON* = 50 + MM_TRUEVISION* = 51 + MM_AZTECH* = 52 + MM_VIDEOLOGIC* = 53 + MM_SCALACS* = 54 + MM_KORG* = 55 + MM_APT* = 56 + MM_ICS* = 57 + MM_ITERATEDSYS* = 58 + MM_METHEUS* = 59 + MM_LOGITECH* = 60 + MM_WINNOV* = 61 + MM_NCR* = 62 + MM_EXAN* = 63 + MM_AST* = 64 + MM_WILLOWPOND* = 65 + MM_SONICFOUNDRY* = 66 + MM_VITEC* = 67 + MM_MOSCOM* = 68 + MM_SILICONSOFT* = 69 + MM_TERRATEC* = 70 + MM_MEDIASONIC* = 71 + MM_SANYO* = 72 + MM_SUPERMAC* = 73 + MM_AUDIOPT* = 74 + MM_NOGATECH* = 75 + MM_SPEECHCOMP* = 76 + MM_AHEAD* = 77 + MM_DOLBY* = 78 + MM_OKI* = 79 + MM_AURAVISION* = 80 + MM_OLIVETTI* = 81 + MM_IOMAGIC* = 82 + MM_MATSUSHITA* = 83 + MM_CONTROLRES* = 84 + MM_XEBEC* = 85 + MM_NEWMEDIA* = 86 + MM_NMS* = 87 + MM_LYRRUS* = 88 + MM_COMPUSIC* = 89 + MM_OPTI* = 90 + MM_ADLACC* = 91 + MM_COMPAQ* = 92 + MM_DIALOGIC* = 93 + MM_INSOFT* = 94 + MM_MPTUS* = 95 + MM_WEITEK* = 96 + MM_LERNOUT_AND_HAUSPIE* = 97 + MM_QCIAR* = 98 + MM_APPLE* = 99 + MM_DIGITAL* = 100 + MM_MOTU* = 101 + MM_WORKBIT* = 102 + MM_OSITECH* = 103 + MM_MIRO* = 104 + MM_CIRRUSLOGIC* = 105 + MM_ISOLUTION* = 106 + MM_HORIZONS* = 107 + MM_CONCEPTS* = 108 + MM_VTG* = 109 + MM_RADIUS* = 110 + MM_ROCKWELL* = 111 + MM_XYZ* = 112 + MM_OPCODE* = 113 + MM_VOXWARE* = 114 + MM_NORTHERN_TELECOM* = 115 + MM_APICOM* = 116 + MM_GRANDE* = 117 + MM_ADDX* = 118 + MM_WILDCAT* = 119 + MM_RHETOREX* = 120 + MM_BROOKTREE* = 121 + MM_ENSONIQ* = 125 + MM_FAST* = 126 + MM_NVIDIA* = 127 + MM_OKSORI* = 128 + MM_DIACOUSTICS* = 129 + MM_GULBRANSEN* = 130 + MM_KAY_ELEMETRICS* = 131 + MM_CRYSTAL* = 132 + MM_SPLASH_STUDIOS* = 133 + MM_QUARTERDECK* = 134 + MM_TDK* = 135 + MM_DIGITAL_AUDIO_LABS* = 136 + MM_SEERSYS* = 137 + MM_PICTURETEL* = 138 + MM_ATT_MICROELECTRONICS* = 139 + MM_OSPREY* = 140 + MM_MEDIATRIX* = 141 + MM_SOUNDESIGNS* = 142 + MM_ALDIGITAL* = 143 + MM_SPECTRUM_SIGNAL_PROCESSING* = 144 + MM_ECS* = 145 + MM_AMD* = 146 + MM_COREDYNAMICS* = 147 + MM_CANAM* = 148 + MM_SOFTSOUND* = 149 + MM_NORRIS* = 150 + MM_DDD* = 151 + MM_EUPHONICS* = 152 + MM_PRECEPT* = 153 + MM_CRYSTAL_NET* = 154 + MM_CHROMATIC* = 155 + MM_VOICEINFO* = 156 + MM_VIENNASYS* = 157 + MM_CONNECTIX* = 158 + MM_GADGETLABS* = 159 + MM_FRONTIER* = 160 + MM_VIONA* = 161 + MM_CASIO* = 162 + MM_DIAMONDMM* = 163 + MM_S3* = 164 + MM_DVISION* = 165 + MM_NETSCAPE* = 166 + MM_SOUNDSPACE* = 167 + MM_VANKOEVERING* = 168 + MM_QTEAM* = 169 + MM_ZEFIRO* = 170 + MM_STUDER* = 171 + MM_FRAUNHOFER_IIS* = 172 + MM_QUICKNET* = 173 + MM_ALARIS* = 174 + MM_SICRESOURCE* = 175 + MM_NEOMAGIC* = 176 + MM_MERGING_TECHNOLOGIES* = 177 + MM_XIRLINK* = 178 + MM_COLORGRAPH* = 179 + MM_OTI* = 180 + MM_AUREAL* = 181 + MM_VIVO* = 182 + MM_SHARP* = 183 + MM_LUCENT* = 184 + MM_ATT* = 185 + MM_SUNCOM* = 186 + MM_SORVIS* = 187 + MM_INVISION* = 188 + MM_BERKOM* = 189 + MM_MARIAN* = 190 + MM_DPSINC* = 191 + MM_BCB* = 192 + MM_MOTIONPIXELS* = 193 + MM_QDESIGN* = 194 + MM_NMP* = 195 + MM_DATAFUSION* = 196 + MM_DUCK* = 197 + MM_FTR* = 198 + MM_BERCOS* = 199 + MM_ONLIVE* = 200 + MM_SIEMENS_SBC* = 201 + MM_TERALOGIC* = 202 + MM_PHONET* = 203 + MM_WINBOND* = 204 + MM_VIRTUALMUSIC* = 205 + MM_ENET* = 206 + MM_GUILLEMOT* = 207 + MM_EMAGIC* = 208 + MM_MWM* = 209 + MM_PACIFICRESEARCH* = 210 + MM_SIPROLAB* = 211 + MM_LYNX* = 212 + MM_SPECTRUM_PRODUCTIONS* = 213 + MM_DICTAPHONE* = 214 + MM_QUALCOMM* = 215 + MM_RZS* = 216 + MM_AUDIOSCIENCE* = 217 + MM_PINNACLE* = 218 + MM_EES* = 219 + MM_HAFTMANN* = 220 + MM_LUCID* = 221 + MM_HEADSPACE* = 222 + MM_UNISYS* = 223 + MM_LUMINOSITI* = 224 + MM_ACTIVEVOICE* = 225 + MM_DTS* = 226 + MM_DIGIGRAM* = 227 + MM_SOFTLAB_NSK* = 228 + MM_FORTEMEDIA* = 229 + MM_SONORUS* = 230 + MM_ARRAY* = 231 + MM_DATARAN* = 232 + MM_I_LINK* = 233 + MM_SELSIUS_SYSTEMS* = 234 + MM_ADMOS* = 235 + MM_LEXICON* = 236 + MM_SGI* = 237 + MM_IPI* = 238 + MM_ICE* = 239 + MM_VQST* = 240 + MM_ETEK* = 241 + MM_CS* = 242 + MM_ALESIS* = 243 + MM_INTERNET* = 244 + MM_SONY* = 245 + MM_HYPERACTIVE* = 246 + MM_UHER_INFORMATIC* = 247 + MM_SYDEC_NV* = 248 + MM_FLEXION* = 249 + MM_VIA* = 250 + MM_MICRONAS* = 251 + MM_ANALOGDEVICES* = 252 + MM_HP* = 253 + MM_MATROX_DIV* = 254 + MM_QUICKAUDIO* = 255 + MM_YOUCOM* = 256 + MM_RICHMOND* = 257 + MM_IODD* = 258 + MM_ICCC* = 259 + MM_3COM* = 260 + MM_MALDEN* = 261 + MM_3DFX* = 262 + MM_MINDMAKER* = 263 + MM_TELEKOL* = 264 + MM_ST_MICROELECTRONICS* = 265 + MM_ALGOVISION* = 266 + MM_UNMAPPED* = 0xffff + MM_PID_UNMAPPED* = MM_UNMAPPED + MM_MIDI_MAPPER* = 1 + MM_WAVE_MAPPER* = 2 + MM_SNDBLST_MIDIOUT* = 3 + MM_SNDBLST_MIDIIN* = 4 + MM_SNDBLST_SYNTH* = 5 + MM_SNDBLST_WAVEOUT* = 6 + MM_SNDBLST_WAVEIN* = 7 + MM_ADLIB* = 9 + MM_MPU401_MIDIOUT* = 10 + MM_MPU401_MIDIIN* = 11 + MM_PC_JOYSTICK* = 12 + MM_PCSPEAKER_WAVEOUT* = 13 + MM_MSFT_WSS_WAVEIN* = 14 + MM_MSFT_WSS_WAVEOUT* = 15 + MM_MSFT_WSS_FMSYNTH_STEREO* = 16 + MM_MSFT_WSS_MIXER* = 17 + MM_MSFT_WSS_OEM_WAVEIN* = 18 + MM_MSFT_WSS_OEM_WAVEOUT* = 19 + MM_MSFT_WSS_OEM_FMSYNTH_STEREO* = 20 + MM_MSFT_WSS_AUX* = 21 + MM_MSFT_WSS_OEM_AUX* = 22 + MM_MSFT_GENERIC_WAVEIN* = 23 + MM_MSFT_GENERIC_WAVEOUT* = 24 + MM_MSFT_GENERIC_MIDIIN* = 25 + MM_MSFT_GENERIC_MIDIOUT* = 26 + MM_MSFT_GENERIC_MIDISYNTH* = 27 + MM_MSFT_GENERIC_AUX_LINE* = 28 + MM_MSFT_GENERIC_AUX_MIC* = 29 + MM_MSFT_GENERIC_AUX_CD* = 30 + MM_MSFT_WSS_OEM_MIXER* = 31 + MM_MSFT_MSACM* = 32 + MM_MSFT_ACM_MSADPCM* = 33 + MM_MSFT_ACM_IMAADPCM* = 34 + MM_MSFT_ACM_MSFILTER* = 35 + MM_MSFT_ACM_GSM610* = 36 + MM_MSFT_ACM_G711* = 37 + MM_MSFT_ACM_PCM* = 38 + MM_WSS_SB16_WAVEIN* = 39 + MM_WSS_SB16_WAVEOUT* = 40 + MM_WSS_SB16_MIDIIN* = 41 + MM_WSS_SB16_MIDIOUT* = 42 + MM_WSS_SB16_SYNTH* = 43 + MM_WSS_SB16_AUX_LINE* = 44 + MM_WSS_SB16_AUX_CD* = 45 + MM_WSS_SB16_MIXER* = 46 + MM_WSS_SBPRO_WAVEIN* = 47 + MM_WSS_SBPRO_WAVEOUT* = 48 + MM_WSS_SBPRO_MIDIIN* = 49 + MM_WSS_SBPRO_MIDIOUT* = 50 + MM_WSS_SBPRO_SYNTH* = 51 + MM_WSS_SBPRO_AUX_LINE* = 52 + MM_WSS_SBPRO_AUX_CD* = 53 + MM_WSS_SBPRO_MIXER* = 54 + MM_MSFT_WSS_NT_WAVEIN* = 55 + MM_MSFT_WSS_NT_WAVEOUT* = 56 + MM_MSFT_WSS_NT_FMSYNTH_STEREO* = 57 + MM_MSFT_WSS_NT_MIXER* = 58 + MM_MSFT_WSS_NT_AUX* = 59 + MM_MSFT_SB16_WAVEIN* = 60 + MM_MSFT_SB16_WAVEOUT* = 61 + MM_MSFT_SB16_MIDIIN* = 62 + MM_MSFT_SB16_MIDIOUT* = 63 + MM_MSFT_SB16_SYNTH* = 64 + MM_MSFT_SB16_AUX_LINE* = 65 + MM_MSFT_SB16_AUX_CD* = 66 + MM_MSFT_SB16_MIXER* = 67 + MM_MSFT_SBPRO_WAVEIN* = 68 + MM_MSFT_SBPRO_WAVEOUT* = 69 + MM_MSFT_SBPRO_MIDIIN* = 70 + MM_MSFT_SBPRO_MIDIOUT* = 71 + MM_MSFT_SBPRO_SYNTH* = 72 + MM_MSFT_SBPRO_AUX_LINE* = 73 + MM_MSFT_SBPRO_AUX_CD* = 74 + MM_MSFT_SBPRO_MIXER* = 75 + MM_MSFT_MSOPL_SYNTH* = 76 + MM_MSFT_VMDMS_LINE_WAVEIN* = 80 + MM_MSFT_VMDMS_LINE_WAVEOUT* = 81 + MM_MSFT_VMDMS_HANDSET_WAVEIN* = 82 + MM_MSFT_VMDMS_HANDSET_WAVEOUT* = 83 + MM_MSFT_VMDMW_LINE_WAVEIN* = 84 + MM_MSFT_VMDMW_LINE_WAVEOUT* = 85 + MM_MSFT_VMDMW_HANDSET_WAVEIN* = 86 + MM_MSFT_VMDMW_HANDSET_WAVEOUT* = 87 + MM_MSFT_VMDMW_MIXER* = 88 + MM_MSFT_VMDM_GAME_WAVEOUT* = 89 + MM_MSFT_VMDM_GAME_WAVEIN* = 90 + MM_MSFT_ACM_MSNAUDIO* = 91 + MM_MSFT_ACM_MSG723* = 92 + MM_MSFT_ACM_MSRT24* = 93 + MM_MSFT_WDMAUDIO_WAVEOUT* = 100 + MM_MSFT_WDMAUDIO_WAVEIN* = 101 + MM_MSFT_WDMAUDIO_MIDIOUT* = 102 + MM_MSFT_WDMAUDIO_MIDIIN* = 103 + MM_MSFT_WDMAUDIO_MIXER* = 104 + MM_MSFT_WDMAUDIO_AUX* = 105 + MM_CREATIVE_SB15_WAVEIN* = 1 + MM_CREATIVE_SB20_WAVEIN* = 2 + MM_CREATIVE_SBPRO_WAVEIN* = 3 + MM_CREATIVE_SBP16_WAVEIN* = 4 + MM_CREATIVE_PHNBLST_WAVEIN* = 5 + MM_CREATIVE_SB15_WAVEOUT* = 101 + MM_CREATIVE_SB20_WAVEOUT* = 102 + MM_CREATIVE_SBPRO_WAVEOUT* = 103 + MM_CREATIVE_SBP16_WAVEOUT* = 104 + MM_CREATIVE_PHNBLST_WAVEOUT* = 105 + MM_CREATIVE_MIDIOUT* = 201 + MM_CREATIVE_MIDIIN* = 202 + MM_CREATIVE_FMSYNTH_MONO* = 301 + MM_CREATIVE_FMSYNTH_STEREO* = 302 + MM_CREATIVE_MIDI_AWE32* = 303 + MM_CREATIVE_AUX_CD* = 401 + MM_CREATIVE_AUX_LINE* = 402 + MM_CREATIVE_AUX_MIC* = 403 + MM_CREATIVE_AUX_MASTER* = 404 + MM_CREATIVE_AUX_PCSPK* = 405 + MM_CREATIVE_AUX_WAVE* = 406 + MM_CREATIVE_AUX_MIDI* = 407 + MM_CREATIVE_SBPRO_MIXER* = 408 + MM_CREATIVE_SB16_MIXER* = 409 + MM_MEDIAVISION_PROAUDIO* = 0x10 + MM_PROAUD_MIDIOUT* = MM_MEDIAVISION_PROAUDIO+1 + MM_PROAUD_MIDIIN* = MM_MEDIAVISION_PROAUDIO+2 + MM_PROAUD_SYNTH* = MM_MEDIAVISION_PROAUDIO+3 + MM_PROAUD_WAVEOUT* = MM_MEDIAVISION_PROAUDIO+4 + MM_PROAUD_WAVEIN* = MM_MEDIAVISION_PROAUDIO+5 + MM_PROAUD_MIXER* = MM_MEDIAVISION_PROAUDIO+6 + MM_PROAUD_AUX* = MM_MEDIAVISION_PROAUDIO+7 + MM_MEDIAVISION_THUNDER* = 0x20 + MM_THUNDER_SYNTH* = MM_MEDIAVISION_THUNDER+3 + MM_THUNDER_WAVEOUT* = MM_MEDIAVISION_THUNDER+4 + MM_THUNDER_WAVEIN* = MM_MEDIAVISION_THUNDER+5 + MM_THUNDER_AUX* = MM_MEDIAVISION_THUNDER+7 + MM_MEDIAVISION_TPORT* = 0x40 + MM_TPORT_WAVEOUT* = MM_MEDIAVISION_TPORT+1 + MM_TPORT_WAVEIN* = MM_MEDIAVISION_TPORT+2 + MM_TPORT_SYNTH* = MM_MEDIAVISION_TPORT+3 + MM_MEDIAVISION_PROAUDIO_PLUS* = 0x50 + MM_PROAUD_PLUS_MIDIOUT* = MM_MEDIAVISION_PROAUDIO_PLUS+1 + MM_PROAUD_PLUS_MIDIIN* = MM_MEDIAVISION_PROAUDIO_PLUS+2 + MM_PROAUD_PLUS_SYNTH* = MM_MEDIAVISION_PROAUDIO_PLUS+3 + MM_PROAUD_PLUS_WAVEOUT* = MM_MEDIAVISION_PROAUDIO_PLUS+4 + MM_PROAUD_PLUS_WAVEIN* = MM_MEDIAVISION_PROAUDIO_PLUS+5 + MM_PROAUD_PLUS_MIXER* = MM_MEDIAVISION_PROAUDIO_PLUS+6 + MM_PROAUD_PLUS_AUX* = MM_MEDIAVISION_PROAUDIO_PLUS+7 + MM_MEDIAVISION_PROAUDIO_16* = 0x60 + MM_PROAUD_16_MIDIOUT* = MM_MEDIAVISION_PROAUDIO_16+1 + MM_PROAUD_16_MIDIIN* = MM_MEDIAVISION_PROAUDIO_16+2 + MM_PROAUD_16_SYNTH* = MM_MEDIAVISION_PROAUDIO_16+3 + MM_PROAUD_16_WAVEOUT* = MM_MEDIAVISION_PROAUDIO_16+4 + MM_PROAUD_16_WAVEIN* = MM_MEDIAVISION_PROAUDIO_16+5 + MM_PROAUD_16_MIXER* = MM_MEDIAVISION_PROAUDIO_16+6 + MM_PROAUD_16_AUX* = MM_MEDIAVISION_PROAUDIO_16+7 + MM_MEDIAVISION_PROSTUDIO_16* = 0x60 + MM_STUDIO_16_MIDIOUT* = MM_MEDIAVISION_PROSTUDIO_16+1 + MM_STUDIO_16_MIDIIN* = MM_MEDIAVISION_PROSTUDIO_16+2 + MM_STUDIO_16_SYNTH* = MM_MEDIAVISION_PROSTUDIO_16+3 + MM_STUDIO_16_WAVEOUT* = MM_MEDIAVISION_PROSTUDIO_16+4 + MM_STUDIO_16_WAVEIN* = MM_MEDIAVISION_PROSTUDIO_16+5 + MM_STUDIO_16_MIXER* = MM_MEDIAVISION_PROSTUDIO_16+6 + MM_STUDIO_16_AUX* = MM_MEDIAVISION_PROSTUDIO_16+7 + MM_MEDIAVISION_CDPC* = 0x70 + MM_CDPC_MIDIOUT* = MM_MEDIAVISION_CDPC+1 + MM_CDPC_MIDIIN* = MM_MEDIAVISION_CDPC+2 + MM_CDPC_SYNTH* = MM_MEDIAVISION_CDPC+3 + MM_CDPC_WAVEOUT* = MM_MEDIAVISION_CDPC+4 + MM_CDPC_WAVEIN* = MM_MEDIAVISION_CDPC+5 + MM_CDPC_MIXER* = MM_MEDIAVISION_CDPC+6 + MM_CDPC_AUX* = MM_MEDIAVISION_CDPC+7 + MM_MEDIAVISION_OPUS1208* = 0x80 + MM_OPUS401_MIDIOUT* = MM_MEDIAVISION_OPUS1208+1 + MM_OPUS401_MIDIIN* = MM_MEDIAVISION_OPUS1208+2 + MM_OPUS1208_SYNTH* = MM_MEDIAVISION_OPUS1208+3 + MM_OPUS1208_WAVEOUT* = MM_MEDIAVISION_OPUS1208+4 + MM_OPUS1208_WAVEIN* = MM_MEDIAVISION_OPUS1208+5 + MM_OPUS1208_MIXER* = MM_MEDIAVISION_OPUS1208+6 + MM_OPUS1208_AUX* = MM_MEDIAVISION_OPUS1208+7 + MM_MEDIAVISION_OPUS1216* = 0x90 + MM_OPUS1216_MIDIOUT* = MM_MEDIAVISION_OPUS1216+1 + MM_OPUS1216_MIDIIN* = MM_MEDIAVISION_OPUS1216+2 + MM_OPUS1216_SYNTH* = MM_MEDIAVISION_OPUS1216+3 + MM_OPUS1216_WAVEOUT* = MM_MEDIAVISION_OPUS1216+4 + MM_OPUS1216_WAVEIN* = MM_MEDIAVISION_OPUS1216+5 + MM_OPUS1216_MIXER* = MM_MEDIAVISION_OPUS1216+6 + MM_OPUS1216_AUX* = MM_MEDIAVISION_OPUS1216+7 + MM_CYRIX_XASYNTH* = 1 + MM_CYRIX_XAMIDIIN* = 2 + MM_CYRIX_XAMIDIOUT* = 3 + MM_CYRIX_XAWAVEIN* = 4 + MM_CYRIX_XAWAVEOUT* = 5 + MM_CYRIX_XAAUX* = 6 + MM_CYRIX_XAMIXER* = 7 + MM_PHILIPS_ACM_LPCBB* = 1 + MM_NETXL_XLVIDEO* = 1 + MM_ZYXEL_ACM_ADPCM* = 1 + MM_AARDVARK_STUDIO12_WAVEOUT* = 1 + MM_AARDVARK_STUDIO12_WAVEIN* = 2 + MM_AARDVARK_STUDIO88_WAVEOUT* = 3 + MM_AARDVARK_STUDIO88_WAVEIN* = 4 + MM_BINTEC_TAPI_WAVE* = 1 + MM_HEWLETT_PACKARD_CU_CODEC* = 1 + MM_MITEL_TALKTO_LINE_WAVEOUT* = 100 + MM_MITEL_TALKTO_LINE_WAVEIN* = 101 + MM_MITEL_TALKTO_HANDSET_WAVEOUT* = 102 + MM_MITEL_TALKTO_HANDSET_WAVEIN* = 103 + MM_MITEL_TALKTO_BRIDGED_WAVEOUT* = 104 + MM_MITEL_TALKTO_BRIDGED_WAVEIN* = 105 + MM_MITEL_MPA_HANDSET_WAVEOUT* = 200 + MM_MITEL_MPA_HANDSET_WAVEIN* = 201 + MM_MITEL_MPA_HANDSFREE_WAVEOUT* = 202 + MM_MITEL_MPA_HANDSFREE_WAVEIN* = 203 + MM_MITEL_MPA_LINE1_WAVEOUT* = 204 + MM_MITEL_MPA_LINE1_WAVEIN* = 205 + MM_MITEL_MPA_LINE2_WAVEOUT* = 206 + MM_MITEL_MPA_LINE2_WAVEIN* = 207 + MM_MITEL_MEDIAPATH_WAVEOUT* = 300 + MM_MITEL_MEDIAPATH_WAVEIN* = 301 + MM_SNI_ACM_G721* = 1 + MM_EMU_APSSYNTH* = 1 + MM_EMU_APSMIDIIN* = 2 + MM_EMU_APSMIDIOUT* = 3 + MM_EMU_APSWAVEIN* = 4 + MM_EMU_APSWAVEOUT* = 5 + MM_ARTISOFT_SBWAVEIN* = 1 + MM_ARTISOFT_SBWAVEOUT* = 2 + MM_TBS_TROPEZ_WAVEIN* = 37 + MM_TBS_TROPEZ_WAVEOUT* = 38 + MM_TBS_TROPEZ_AUX1* = 39 + MM_TBS_TROPEZ_AUX2* = 40 + MM_TBS_TROPEZ_LINE* = 41 + MM_MMOTION_WAVEAUX* = 1 + MM_MMOTION_WAVEOUT* = 2 + MM_MMOTION_WAVEIN* = 3 + MM_IBM_PCMCIA_WAVEIN* = 11 + MM_IBM_PCMCIA_WAVEOUT* = 12 + MM_IBM_PCMCIA_SYNTH* = 13 + MM_IBM_PCMCIA_MIDIIN* = 14 + MM_IBM_PCMCIA_MIDIOUT* = 15 + MM_IBM_PCMCIA_AUX* = 16 + MM_IBM_THINKPAD200* = 17 + MM_IBM_MWAVE_WAVEIN* = 18 + MM_IBM_MWAVE_WAVEOUT* = 19 + MM_IBM_MWAVE_MIXER* = 20 + MM_IBM_MWAVE_MIDIIN* = 21 + MM_IBM_MWAVE_MIDIOUT* = 22 + MM_IBM_MWAVE_AUX* = 23 + MM_IBM_WC_MIDIOUT* = 30 + MM_IBM_WC_WAVEOUT* = 31 + MM_IBM_WC_MIXEROUT* = 33 + MM_VOCALTEC_WAVEOUT* = 1 + MM_VOCALTEC_WAVEIN* = 2 + MM_ROLAND_RAP10_MIDIOUT* = 10 + MM_ROLAND_RAP10_MIDIIN* = 11 + MM_ROLAND_RAP10_SYNTH* = 12 + MM_ROLAND_RAP10_WAVEOUT* = 13 + MM_ROLAND_RAP10_WAVEIN* = 14 + MM_ROLAND_MPU401_MIDIOUT* = 15 + MM_ROLAND_MPU401_MIDIIN* = 16 + MM_ROLAND_SMPU_MIDIOUTA* = 17 + MM_ROLAND_SMPU_MIDIOUTB* = 18 + MM_ROLAND_SMPU_MIDIINA* = 19 + MM_ROLAND_SMPU_MIDIINB* = 20 + MM_ROLAND_SC7_MIDIOUT* = 21 + MM_ROLAND_SC7_MIDIIN* = 22 + MM_ROLAND_SERIAL_MIDIOUT* = 23 + MM_ROLAND_SERIAL_MIDIIN* = 24 + MM_ROLAND_SCP_MIDIOUT* = 38 + MM_ROLAND_SCP_MIDIIN* = 39 + MM_ROLAND_SCP_WAVEOUT* = 40 + MM_ROLAND_SCP_WAVEIN* = 41 + MM_ROLAND_SCP_MIXER* = 42 + MM_ROLAND_SCP_AUX* = 48 + MM_DSP_SOLUTIONS_WAVEOUT* = 1 + MM_DSP_SOLUTIONS_WAVEIN* = 2 + MM_DSP_SOLUTIONS_SYNTH* = 3 + MM_DSP_SOLUTIONS_AUX* = 4 + MM_NEC_73_86_SYNTH* = 5 + MM_NEC_73_86_WAVEOUT* = 6 + MM_NEC_73_86_WAVEIN* = 7 + MM_NEC_26_SYNTH* = 9 + MM_NEC_MPU401_MIDIOUT* = 10 + MM_NEC_MPU401_MIDIIN* = 11 + MM_NEC_JOYSTICK* = 12 + MM_WANGLABS_WAVEIN1* = 1 + MM_WANGLABS_WAVEOUT1* = 2 + MM_TANDY_VISWAVEIN* = 1 + MM_TANDY_VISWAVEOUT* = 2 + MM_TANDY_VISBIOSSYNTH* = 3 + MM_TANDY_SENS_MMAWAVEIN* = 4 + MM_TANDY_SENS_MMAWAVEOUT* = 5 + MM_TANDY_SENS_MMAMIDIIN* = 6 + MM_TANDY_SENS_MMAMIDIOUT* = 7 + MM_TANDY_SENS_VISWAVEOUT* = 8 + MM_TANDY_PSSJWAVEIN* = 9 + MM_TANDY_PSSJWAVEOUT* = 10 + MM_ANTEX_SX12_WAVEIN* = 1 + MM_ANTEX_SX12_WAVEOUT* = 2 + MM_ANTEX_SX15_WAVEIN* = 3 + MM_ANTEX_SX15_WAVEOUT* = 4 + MM_ANTEX_VP625_WAVEIN* = 5 + MM_ANTEX_VP625_WAVEOUT* = 6 + MM_ANTEX_AUDIOPORT22_WAVEIN* = 7 + MM_ANTEX_AUDIOPORT22_WAVEOUT* = 8 + MM_ANTEX_AUDIOPORT22_FEEDTHRU* = 9 + MM_INTELOPD_WAVEIN* = 1 + MM_INTELOPD_WAVEOUT* = 101 + MM_INTELOPD_AUX* = 401 + MM_INTEL_NSPMODEMLINEIN* = 501 + MM_INTEL_NSPMODEMLINEOUT* = 502 + MM_VAL_MICROKEY_AP_WAVEIN* = 1 + MM_VAL_MICROKEY_AP_WAVEOUT* = 2 + MM_INTERACTIVE_WAVEIN* = 0x45 + MM_INTERACTIVE_WAVEOUT* = 0x45 + MM_YAMAHA_GSS_SYNTH* = 0x01 + MM_YAMAHA_GSS_WAVEOUT* = 0x02 + MM_YAMAHA_GSS_WAVEIN* = 0x03 + MM_YAMAHA_GSS_MIDIOUT* = 0x04 + MM_YAMAHA_GSS_MIDIIN* = 0x05 + MM_YAMAHA_GSS_AUX* = 0x06 + MM_YAMAHA_SERIAL_MIDIOUT* = 0x07 + MM_YAMAHA_SERIAL_MIDIIN* = 0x08 + MM_YAMAHA_OPL3SA_WAVEOUT* = 0x10 + MM_YAMAHA_OPL3SA_WAVEIN* = 0x11 + MM_YAMAHA_OPL3SA_FMSYNTH* = 0x12 + MM_YAMAHA_OPL3SA_YSYNTH* = 0x13 + MM_YAMAHA_OPL3SA_MIDIOUT* = 0x14 + MM_YAMAHA_OPL3SA_MIDIIN* = 0x15 + MM_YAMAHA_OPL3SA_MIXER* = 0x17 + MM_YAMAHA_OPL3SA_JOYSTICK* = 0x18 + MM_YAMAHA_YMF724LEG_MIDIOUT* = 0x19 + MM_YAMAHA_YMF724LEG_MIDIIN* = 0x1a + MM_YAMAHA_YMF724_WAVEOUT* = 0x1b + MM_YAMAHA_YMF724_WAVEIN* = 0x1c + MM_YAMAHA_YMF724_MIDIOUT* = 0x1d + MM_YAMAHA_YMF724_AUX* = 0x1e + MM_YAMAHA_YMF724_MIXER* = 0x1f + MM_YAMAHA_YMF724LEG_FMSYNTH* = 0x20 + MM_YAMAHA_YMF724LEG_MIXER* = 0x21 + MM_YAMAHA_SXG_MIDIOUT* = 0x22 + MM_YAMAHA_SXG_WAVEOUT* = 0x23 + MM_YAMAHA_SXG_MIXER* = 0x24 + MM_YAMAHA_ACXG_WAVEIN* = 0x25 + MM_YAMAHA_ACXG_WAVEOUT* = 0x26 + MM_YAMAHA_ACXG_MIDIOUT* = 0x27 + MM_YAMAHA_ACXG_MIXER* = 0x28 + MM_YAMAHA_ACXG_AUX* = 0x29 + MM_EVEREX_CARRIER* = 1 + MM_ECHO_SYNTH* = 1 + MM_ECHO_WAVEOUT* = 2 + MM_ECHO_WAVEIN* = 3 + MM_ECHO_MIDIOUT* = 4 + MM_ECHO_MIDIIN* = 5 + MM_ECHO_AUX* = 6 + MM_SIERRA_ARIA_MIDIOUT* = 0x14 + MM_SIERRA_ARIA_MIDIIN* = 0x15 + MM_SIERRA_ARIA_SYNTH* = 0x16 + MM_SIERRA_ARIA_WAVEOUT* = 0x17 + MM_SIERRA_ARIA_WAVEIN* = 0x18 + MM_SIERRA_ARIA_AUX* = 0x19 + MM_SIERRA_ARIA_AUX2* = 0x20 + MM_SIERRA_QUARTET_WAVEIN* = 0x50 + MM_SIERRA_QUARTET_WAVEOUT* = 0x51 + MM_SIERRA_QUARTET_MIDIIN* = 0x52 + MM_SIERRA_QUARTET_MIDIOUT* = 0x53 + MM_SIERRA_QUARTET_SYNTH* = 0x54 + MM_SIERRA_QUARTET_AUX_CD* = 0x55 + MM_SIERRA_QUARTET_AUX_LINE* = 0x56 + MM_SIERRA_QUARTET_AUX_MODEM* = 0x57 + MM_SIERRA_QUARTET_MIXER* = 0x58 + MM_CAT_WAVEOUT* = 1 + MM_DSP_GROUP_TRUESPEECH* = 1 + MM_MELABS_MIDI2GO* = 1 + MM_ESS_AMWAVEOUT* = 0x01 + MM_ESS_AMWAVEIN* = 0x02 + MM_ESS_AMAUX* = 0x03 + MM_ESS_AMSYNTH* = 0x04 + MM_ESS_AMMIDIOUT* = 0x05 + MM_ESS_AMMIDIIN* = 0x06 + MM_ESS_MIXER* = 0x07 + MM_ESS_AUX_CD* = 0x08 + MM_ESS_MPU401_MIDIOUT* = 0x09 + MM_ESS_MPU401_MIDIIN* = 0x0a + MM_ESS_ES488_WAVEOUT* = 0x10 + MM_ESS_ES488_WAVEIN* = 0x11 + MM_ESS_ES488_MIXER* = 0x12 + MM_ESS_ES688_WAVEOUT* = 0x13 + MM_ESS_ES688_WAVEIN* = 0x14 + MM_ESS_ES688_MIXER* = 0x15 + MM_ESS_ES1488_WAVEOUT* = 0x16 + MM_ESS_ES1488_WAVEIN* = 0x17 + MM_ESS_ES1488_MIXER* = 0x18 + MM_ESS_ES1688_WAVEOUT* = 0x19 + MM_ESS_ES1688_WAVEIN* = 0x1a + MM_ESS_ES1688_MIXER* = 0x1b + MM_ESS_ES1788_WAVEOUT* = 0x1c + MM_ESS_ES1788_WAVEIN* = 0x1d + MM_ESS_ES1788_MIXER* = 0x1e + MM_ESS_ES1888_WAVEOUT* = 0x1f + MM_ESS_ES1888_WAVEIN* = 0x20 + MM_ESS_ES1888_MIXER* = 0x21 + MM_ESS_ES1868_WAVEOUT* = 0x22 + MM_ESS_ES1868_WAVEIN* = 0x23 + MM_ESS_ES1868_MIXER* = 0x24 + MM_ESS_ES1878_WAVEOUT* = 0x25 + MM_ESS_ES1878_WAVEIN* = 0x26 + MM_ESS_ES1878_MIXER* = 0x27 + MM_CANOPUS_ACM_DVREX* = 1 + MM_EPS_FMSND* = 1 + MM_TRUEVISION_WAVEIN1* = 1 + MM_TRUEVISION_WAVEOUT1* = 2 + MM_AZTECH_MIDIOUT* = 3 + MM_AZTECH_MIDIIN* = 4 + MM_AZTECH_WAVEIN* = 17 + MM_AZTECH_WAVEOUT* = 18 + MM_AZTECH_FMSYNTH* = 20 + MM_AZTECH_MIXER* = 21 + MM_AZTECH_PRO16_WAVEIN* = 33 + MM_AZTECH_PRO16_WAVEOUT* = 34 + MM_AZTECH_PRO16_FMSYNTH* = 38 + MM_AZTECH_DSP16_WAVEIN* = 65 + MM_AZTECH_DSP16_WAVEOUT* = 66 + MM_AZTECH_DSP16_FMSYNTH* = 68 + MM_AZTECH_DSP16_WAVESYNTH* = 70 + MM_AZTECH_NOVA16_WAVEIN* = 71 + MM_AZTECH_NOVA16_WAVEOUT* = 72 + MM_AZTECH_NOVA16_MIXER* = 73 + MM_AZTECH_WASH16_WAVEIN* = 74 + MM_AZTECH_WASH16_WAVEOUT* = 75 + MM_AZTECH_WASH16_MIXER* = 76 + MM_AZTECH_AUX_CD* = 401 + MM_AZTECH_AUX_LINE* = 402 + MM_AZTECH_AUX_MIC* = 403 + MM_AZTECH_AUX* = 404 + MM_VIDEOLOGIC_MSWAVEIN* = 1 + MM_VIDEOLOGIC_MSWAVEOUT* = 2 + MM_KORG_PCIF_MIDIOUT* = 1 + MM_KORG_PCIF_MIDIIN* = 2 + MM_KORG_1212IO_MSWAVEIN* = 3 + MM_KORG_1212IO_MSWAVEOUT* = 4 + MM_APT_ACE100CD* = 1 + MM_ICS_WAVEDECK_WAVEOUT* = 1 + MM_ICS_WAVEDECK_WAVEIN* = 2 + MM_ICS_WAVEDECK_MIXER* = 3 + MM_ICS_WAVEDECK_AUX* = 4 + MM_ICS_WAVEDECK_SYNTH* = 5 + MM_ICS_WAVEDEC_SB_WAVEOUT* = 6 + MM_ICS_WAVEDEC_SB_WAVEIN* = 7 + MM_ICS_WAVEDEC_SB_FM_MIDIOUT* = 8 + MM_ICS_WAVEDEC_SB_MPU401_MIDIOUT* = 9 + MM_ICS_WAVEDEC_SB_MPU401_MIDIIN* = 10 + MM_ICS_WAVEDEC_SB_MIXER* = 11 + MM_ICS_WAVEDEC_SB_AUX* = 12 + MM_ICS_2115_LITE_MIDIOUT* = 13 + MM_ICS_2120_LITE_MIDIOUT* = 14 + MM_ITERATEDSYS_FUFCODEC* = 1 + MM_METHEUS_ZIPPER* = 1 + MM_WINNOV_CAVIAR_WAVEIN* = 1 + MM_WINNOV_CAVIAR_WAVEOUT* = 2 + MM_WINNOV_CAVIAR_VIDC* = 3 + MM_WINNOV_CAVIAR_CHAMPAGNE* = 4 + MM_WINNOV_CAVIAR_YUV8* = 5 + MM_NCR_BA_WAVEIN* = 1 + MM_NCR_BA_WAVEOUT* = 2 + MM_NCR_BA_SYNTH* = 3 + MM_NCR_BA_AUX* = 4 + MM_NCR_BA_MIXER* = 5 + MM_AST_MODEMWAVE_WAVEIN* = 13 + MM_AST_MODEMWAVE_WAVEOUT* = 14 + MM_WILLOWPOND_FMSYNTH_STEREO* = 20 + MM_WILLOWPOND_MPU401* = 21 + MM_WILLOWPOND_SNDPORT_WAVEIN* = 100 + MM_WILLOWPOND_SNDPORT_WAVEOUT* = 101 + MM_WILLOWPOND_SNDPORT_MIXER* = 102 + MM_WILLOWPOND_SNDPORT_AUX* = 103 + MM_WILLOWPOND_PH_WAVEIN* = 104 + MM_WILLOWPOND_PH_WAVEOUT* = 105 + MM_WILLOWPOND_PH_MIXER* = 106 + MM_WILLOWPOND_PH_AUX* = 107 + MM_WILLOPOND_SNDCOMM_WAVEIN* = 108 + MM_WILLOWPOND_SNDCOMM_WAVEOUT* = 109 + MM_WILLOWPOND_SNDCOMM_MIXER* = 110 + MM_WILLOWPOND_SNDCOMM_AUX* = 111 + MM_WILLOWPOND_GENERIC_WAVEIN* = 112 + MM_WILLOWPOND_GENERIC_WAVEOUT* = 113 + MM_WILLOWPOND_GENERIC_MIXER* = 114 + MM_WILLOWPOND_GENERIC_AUX* = 115 + MM_VITEC_VMAKER* = 1 + MM_VITEC_VMPRO* = 2 + MM_MOSCOM_VPC2400_IN* = 1 + MM_MOSCOM_VPC2400_OUT* = 2 + MM_SILICONSOFT_SC1_WAVEIN* = 1 + MM_SILICONSOFT_SC1_WAVEOUT* = 2 + MM_SILICONSOFT_SC2_WAVEIN* = 3 + MM_SILICONSOFT_SC2_WAVEOUT* = 4 + MM_SILICONSOFT_SOUNDJR2_WAVEOUT* = 5 + MM_SILICONSOFT_SOUNDJR2PR_WAVEIN* = 6 + MM_SILICONSOFT_SOUNDJR2PR_WAVEOUT* = 7 + MM_SILICONSOFT_SOUNDJR3_WAVEOUT* = 8 + MM_TTEWS_WAVEIN* = 1 + MM_TTEWS_WAVEOUT* = 2 + MM_TTEWS_MIDIIN* = 3 + MM_TTEWS_MIDIOUT* = 4 + MM_TTEWS_MIDISYNTH* = 5 + MM_TTEWS_MIDIMONITOR* = 6 + MM_TTEWS_VMIDIIN* = 7 + MM_TTEWS_VMIDIOUT* = 8 + MM_TTEWS_AUX* = 9 + MM_TTEWS_MIXER* = 10 + MM_MEDIASONIC_ACM_G723* = 1 + MM_MEDIASONIC_ICOM* = 2 + MM_ICOM_WAVEIN* = 3 + MM_ICOM_WAVEOUT* = 4 + MM_ICOM_MIXER* = 5 + MM_ICOM_AUX* = 6 + MM_ICOM_LINE* = 7 + MM_SANYO_ACM_LD_ADPCM* = 1 + MM_AHEAD_MULTISOUND* = 1 + MM_AHEAD_SOUNDBLASTER* = 2 + MM_AHEAD_PROAUDIO* = 3 + MM_AHEAD_GENERIC* = 4 + MM_OLIVETTI_WAVEIN* = 1 + MM_OLIVETTI_WAVEOUT* = 2 + MM_OLIVETTI_MIXER* = 3 + MM_OLIVETTI_AUX* = 4 + MM_OLIVETTI_MIDIIN* = 5 + MM_OLIVETTI_MIDIOUT* = 6 + MM_OLIVETTI_SYNTH* = 7 + MM_OLIVETTI_JOYSTICK* = 8 + MM_OLIVETTI_ACM_GSM* = 9 + MM_OLIVETTI_ACM_ADPCM* = 10 + MM_OLIVETTI_ACM_CELP* = 11 + MM_OLIVETTI_ACM_SBC* = 12 + MM_OLIVETTI_ACM_OPR* = 13 + MM_IOMAGIC_TEMPO_WAVEOUT* = 1 + MM_IOMAGIC_TEMPO_WAVEIN* = 2 + MM_IOMAGIC_TEMPO_SYNTH* = 3 + MM_IOMAGIC_TEMPO_MIDIOUT* = 4 + MM_IOMAGIC_TEMPO_MXDOUT* = 5 + MM_IOMAGIC_TEMPO_AUXOUT* = 6 + MM_MATSUSHITA_WAVEIN* = 1 + MM_MATSUSHITA_WAVEOUT* = 2 + MM_MATSUSHITA_FMSYNTH_STEREO* = 3 + MM_MATSUSHITA_MIXER* = 4 + MM_MATSUSHITA_AUX* = 5 + MM_NEWMEDIA_WAVJAMMER* = 1 + MM_LYRRUS_BRIDGE_GUITAR* = 1 + MM_OPTI_M16_FMSYNTH_STEREO* = 0x0001 + MM_OPTI_M16_MIDIIN* = 0x0002 + MM_OPTI_M16_MIDIOUT* = 0x0003 + MM_OPTI_M16_WAVEIN* = 0x0004 + MM_OPTI_M16_WAVEOUT* = 0x0005 + MM_OPTI_M16_MIXER* = 0x0006 + MM_OPTI_M16_AUX* = 0x0007 + MM_OPTI_P16_FMSYNTH_STEREO* = 0x0010 + MM_OPTI_P16_MIDIIN* = 0x0011 + MM_OPTI_P16_MIDIOUT* = 0x0012 + MM_OPTI_P16_WAVEIN* = 0x0013 + MM_OPTI_P16_WAVEOUT* = 0x0014 + MM_OPTI_P16_MIXER* = 0x0015 + MM_OPTI_P16_AUX* = 0x0016 + MM_OPTI_M32_WAVEIN* = 0x0020 + MM_OPTI_M32_WAVEOUT* = 0x0021 + MM_OPTI_M32_MIDIIN* = 0x0022 + MM_OPTI_M32_MIDIOUT* = 0x0023 + MM_OPTI_M32_SYNTH_STEREO* = 0x0024 + MM_OPTI_M32_MIXER* = 0x0025 + MM_OPTI_M32_AUX* = 0x0026 + MM_COMPAQ_BB_WAVEIN* = 1 + MM_COMPAQ_BB_WAVEOUT* = 2 + MM_COMPAQ_BB_WAVEAUX* = 3 + MM_MPTUS_SPWAVEOUT* = 1 + MM_LERNOUT_ANDHAUSPIE_LHCODECACM* = 1 + MM_DIGITAL_AV320_WAVEIN* = 1 + MM_DIGITAL_AV320_WAVEOUT* = 2 + MM_DIGITAL_ACM_G723* = 3 + MM_DIGITAL_ICM_H263* = 4 + MM_DIGITAL_ICM_H261* = 5 + MM_MOTU_MTP_MIDIOUT_ALL* = 100 + MM_MOTU_MTP_MIDIIN_1* = 101 + MM_MOTU_MTP_MIDIOUT_1* = 101 + MM_MOTU_MTP_MIDIIN_2* = 102 + MM_MOTU_MTP_MIDIOUT_2* = 102 + MM_MOTU_MTP_MIDIIN_3* = 103 + MM_MOTU_MTP_MIDIOUT_3* = 103 + MM_MOTU_MTP_MIDIIN_4* = 104 + MM_MOTU_MTP_MIDIOUT_4* = 104 + MM_MOTU_MTP_MIDIIN_5* = 105 + MM_MOTU_MTP_MIDIOUT_5* = 105 + MM_MOTU_MTP_MIDIIN_6* = 106 + MM_MOTU_MTP_MIDIOUT_6* = 106 + MM_MOTU_MTP_MIDIIN_7* = 107 + MM_MOTU_MTP_MIDIOUT_7* = 107 + MM_MOTU_MTP_MIDIIN_8* = 108 + MM_MOTU_MTP_MIDIOUT_8* = 108 + MM_MOTU_MTPII_MIDIOUT_ALL* = 200 + MM_MOTU_MTPII_MIDIIN_SYNC* = 200 + MM_MOTU_MTPII_MIDIIN_1* = 201 + MM_MOTU_MTPII_MIDIOUT_1* = 201 + MM_MOTU_MTPII_MIDIIN_2* = 202 + MM_MOTU_MTPII_MIDIOUT_2* = 202 + MM_MOTU_MTPII_MIDIIN_3* = 203 + MM_MOTU_MTPII_MIDIOUT_3* = 203 + MM_MOTU_MTPII_MIDIIN_4* = 204 + MM_MOTU_MTPII_MIDIOUT_4* = 204 + MM_MOTU_MTPII_MIDIIN_5* = 205 + MM_MOTU_MTPII_MIDIOUT_5* = 205 + MM_MOTU_MTPII_MIDIIN_6* = 206 + MM_MOTU_MTPII_MIDIOUT_6* = 206 + MM_MOTU_MTPII_MIDIIN_7* = 207 + MM_MOTU_MTPII_MIDIOUT_7* = 207 + MM_MOTU_MTPII_MIDIIN_8* = 208 + MM_MOTU_MTPII_MIDIOUT_8* = 208 + MM_MOTU_MTPII_NET_MIDIIN_1* = 209 + MM_MOTU_MTPII_NET_MIDIOUT_1* = 209 + MM_MOTU_MTPII_NET_MIDIIN_2* = 210 + MM_MOTU_MTPII_NET_MIDIOUT_2* = 210 + MM_MOTU_MTPII_NET_MIDIIN_3* = 211 + MM_MOTU_MTPII_NET_MIDIOUT_3* = 211 + MM_MOTU_MTPII_NET_MIDIIN_4* = 212 + MM_MOTU_MTPII_NET_MIDIOUT_4* = 212 + MM_MOTU_MTPII_NET_MIDIIN_5* = 213 + MM_MOTU_MTPII_NET_MIDIOUT_5* = 213 + MM_MOTU_MTPII_NET_MIDIIN_6* = 214 + MM_MOTU_MTPII_NET_MIDIOUT_6* = 214 + MM_MOTU_MTPII_NET_MIDIIN_7* = 215 + MM_MOTU_MTPII_NET_MIDIOUT_7* = 215 + MM_MOTU_MTPII_NET_MIDIIN_8* = 216 + MM_MOTU_MTPII_NET_MIDIOUT_8* = 216 + MM_MOTU_MXP_MIDIIN_MIDIOUT_ALL* = 300 + MM_MOTU_MXP_MIDIIN_SYNC* = 300 + MM_MOTU_MXP_MIDIIN_MIDIIN_1* = 301 + MM_MOTU_MXP_MIDIIN_MIDIOUT_1* = 301 + MM_MOTU_MXP_MIDIIN_MIDIIN_2* = 302 + MM_MOTU_MXP_MIDIIN_MIDIOUT_2* = 302 + MM_MOTU_MXP_MIDIIN_MIDIIN_3* = 303 + MM_MOTU_MXP_MIDIIN_MIDIOUT_3* = 303 + MM_MOTU_MXP_MIDIIN_MIDIIN_4* = 304 + MM_MOTU_MXP_MIDIIN_MIDIOUT_4* = 304 + MM_MOTU_MXP_MIDIIN_MIDIIN_5* = 305 + MM_MOTU_MXP_MIDIIN_MIDIOUT_5* = 305 + MM_MOTU_MXP_MIDIIN_MIDIIN_6* = 306 + MM_MOTU_MXP_MIDIIN_MIDIOUT_6* = 306 + MM_MOTU_MXPMPU_MIDIOUT_ALL* = 400 + MM_MOTU_MXPMPU_MIDIIN_SYNC* = 400 + MM_MOTU_MXPMPU_MIDIIN_1* = 401 + MM_MOTU_MXPMPU_MIDIOUT_1* = 401 + MM_MOTU_MXPMPU_MIDIIN_2* = 402 + MM_MOTU_MXPMPU_MIDIOUT_2* = 402 + MM_MOTU_MXPMPU_MIDIIN_3* = 403 + MM_MOTU_MXPMPU_MIDIOUT_3* = 403 + MM_MOTU_MXPMPU_MIDIIN_4* = 404 + MM_MOTU_MXPMPU_MIDIOUT_4* = 404 + MM_MOTU_MXPMPU_MIDIIN_5* = 405 + MM_MOTU_MXPMPU_MIDIOUT_5* = 405 + MM_MOTU_MXPMPU_MIDIIN_6* = 406 + MM_MOTU_MXPMPU_MIDIOUT_6* = 406 + MM_MOTU_MXN_MIDIOUT_ALL* = 500 + MM_MOTU_MXN_MIDIIN_SYNC* = 500 + MM_MOTU_MXN_MIDIIN_1* = 501 + MM_MOTU_MXN_MIDIOUT_1* = 501 + MM_MOTU_MXN_MIDIIN_2* = 502 + MM_MOTU_MXN_MIDIOUT_2* = 502 + MM_MOTU_MXN_MIDIIN_3* = 503 + MM_MOTU_MXN_MIDIOUT_3* = 503 + MM_MOTU_MXN_MIDIIN_4* = 504 + MM_MOTU_MXN_MIDIOUT_4* = 504 + MM_MOTU_FLYER_MIDI_IN_SYNC* = 600 + MM_MOTU_FLYER_MIDI_IN_A* = 601 + MM_MOTU_FLYER_MIDI_OUT_A* = 601 + MM_MOTU_FLYER_MIDI_IN_B* = 602 + MM_MOTU_FLYER_MIDI_OUT_B* = 602 + MM_MOTU_PKX_MIDI_IN_SYNC* = 700 + MM_MOTU_PKX_MIDI_IN_A* = 701 + MM_MOTU_PKX_MIDI_OUT_A* = 701 + MM_MOTU_PKX_MIDI_IN_B* = 702 + MM_MOTU_PKX_MIDI_OUT_B* = 702 + MM_MOTU_DTX_MIDI_IN_SYNC* = 800 + MM_MOTU_DTX_MIDI_IN_A* = 801 + MM_MOTU_DTX_MIDI_OUT_A* = 801 + MM_MOTU_DTX_MIDI_IN_B* = 802 + MM_MOTU_DTX_MIDI_OUT_B* = 802 + MM_MOTU_MTPAV_MIDIOUT_ALL* = 900 + MM_MOTU_MTPAV_MIDIIN_SYNC* = 900 + MM_MOTU_MTPAV_MIDIIN_1* = 901 + MM_MOTU_MTPAV_MIDIOUT_1* = 901 + MM_MOTU_MTPAV_MIDIIN_2* = 902 + MM_MOTU_MTPAV_MIDIOUT_2* = 902 + MM_MOTU_MTPAV_MIDIIN_3* = 903 + MM_MOTU_MTPAV_MIDIOUT_3* = 903 + MM_MOTU_MTPAV_MIDIIN_4* = 904 + MM_MOTU_MTPAV_MIDIOUT_4* = 904 + MM_MOTU_MTPAV_MIDIIN_5* = 905 + MM_MOTU_MTPAV_MIDIOUT_5* = 905 + MM_MOTU_MTPAV_MIDIIN_6* = 906 + MM_MOTU_MTPAV_MIDIOUT_6* = 906 + MM_MOTU_MTPAV_MIDIIN_7* = 907 + MM_MOTU_MTPAV_MIDIOUT_7* = 907 + MM_MOTU_MTPAV_MIDIIN_8* = 908 + MM_MOTU_MTPAV_MIDIOUT_8* = 908 + MM_MOTU_MTPAV_NET_MIDIIN_1* = 909 + MM_MOTU_MTPAV_NET_MIDIOUT_1* = 909 + MM_MOTU_MTPAV_NET_MIDIIN_2* = 910 + MM_MOTU_MTPAV_NET_MIDIOUT_2* = 910 + MM_MOTU_MTPAV_NET_MIDIIN_3* = 911 + MM_MOTU_MTPAV_NET_MIDIOUT_3* = 911 + MM_MOTU_MTPAV_NET_MIDIIN_4* = 912 + MM_MOTU_MTPAV_NET_MIDIOUT_4* = 912 + MM_MOTU_MTPAV_NET_MIDIIN_5* = 913 + MM_MOTU_MTPAV_NET_MIDIOUT_5* = 913 + MM_MOTU_MTPAV_NET_MIDIIN_6* = 914 + MM_MOTU_MTPAV_NET_MIDIOUT_6* = 914 + MM_MOTU_MTPAV_NET_MIDIIN_7* = 915 + MM_MOTU_MTPAV_NET_MIDIOUT_7* = 915 + MM_MOTU_MTPAV_NET_MIDIIN_8* = 916 + MM_MOTU_MTPAV_NET_MIDIOUT_8* = 916 + MM_MOTU_MTPAV_MIDIIN_ADAT* = 917 + MM_MOTU_MTPAV_MIDIOUT_ADAT* = 917 + MM_MOTU_MXPXT_MIDIIN_SYNC* = 1000 + MM_MOTU_MXPXT_MIDIOUT_ALL* = 1000 + MM_MOTU_MXPXT_MIDIIN_1* = 1001 + MM_MOTU_MXPXT_MIDIOUT_1* = 1001 + MM_MOTU_MXPXT_MIDIOUT_2* = 1002 + MM_MOTU_MXPXT_MIDIIN_2* = 1002 + MM_MOTU_MXPXT_MIDIIN_3* = 1003 + MM_MOTU_MXPXT_MIDIOUT_3* = 1003 + MM_MOTU_MXPXT_MIDIIN_4* = 1004 + MM_MOTU_MXPXT_MIDIOUT_4* = 1004 + MM_MOTU_MXPXT_MIDIIN_5* = 1005 + MM_MOTU_MXPXT_MIDIOUT_5* = 1005 + MM_MOTU_MXPXT_MIDIOUT_6* = 1006 + MM_MOTU_MXPXT_MIDIIN_6* = 1006 + MM_MOTU_MXPXT_MIDIOUT_7* = 1007 + MM_MOTU_MXPXT_MIDIIN_7* = 1007 + MM_MOTU_MXPXT_MIDIOUT_8* = 1008 + MM_MOTU_MXPXT_MIDIIN_8* = 1008 + MM_WORKBIT_MIXER* = 1 + MM_WORKBIT_WAVEOUT* = 2 + MM_WORKBIT_WAVEIN* = 3 + MM_WORKBIT_MIDIIN* = 4 + MM_WORKBIT_MIDIOUT* = 5 + MM_WORKBIT_FMSYNTH* = 6 + MM_WORKBIT_AUX* = 7 + MM_WORKBIT_JOYSTICK* = 8 + MM_OSITECH_TRUMPCARD* = 1 + MM_MIRO_MOVIEPRO* = 1 + MM_MIRO_VIDEOD1* = 2 + MM_MIRO_VIDEODC1TV* = 3 + MM_MIRO_VIDEOTD* = 4 + MM_MIRO_DC30_WAVEOUT* = 5 + MM_MIRO_DC30_WAVEIN* = 6 + MM_MIRO_DC30_MIX* = 7 + MM_ISOLUTION_PASCAL* = 1 + MM_VOICEMIXER* = 1 + ROCKWELL_WA1_WAVEIN* = 100 + ROCKWELL_WA1_WAVEOUT* = 101 + ROCKWELL_WA1_SYNTH* = 102 + ROCKWELL_WA1_MIXER* = 103 + ROCKWELL_WA1_MPU401_IN* = 104 + ROCKWELL_WA1_MPU401_OUT* = 105 + ROCKWELL_WA2_WAVEIN* = 200 + ROCKWELL_WA2_WAVEOUT* = 201 + ROCKWELL_WA2_SYNTH* = 202 + ROCKWELL_WA2_MIXER* = 203 + ROCKWELL_WA2_MPU401_IN* = 204 + ROCKWELL_WA2_MPU401_OUT* = 205 + MM_VOXWARE_CODEC* = 1 + MM_NORTEL_MPXAC_WAVEIN* = 1 + MM_NORTEL_MPXAC_WAVEOUT* = 2 + MM_ADDX_PCTV_DIGITALMIX* = 1 + MM_ADDX_PCTV_WAVEIN* = 2 + MM_ADDX_PCTV_WAVEOUT* = 3 + MM_ADDX_PCTV_MIXER* = 4 + MM_ADDX_PCTV_AUX_CD* = 5 + MM_ADDX_PCTV_AUX_LINE* = 6 + MM_WILDCAT_AUTOSCOREMIDIIN* = 1 + MM_RHETOREX_WAVEIN* = 1 + MM_RHETOREX_WAVEOUT* = 2 + MM_BTV_WAVEIN* = 1 + MM_BTV_WAVEOUT* = 2 + MM_BTV_MIDIIN* = 3 + MM_BTV_MIDIOUT* = 4 + MM_BTV_MIDISYNTH* = 5 + MM_BTV_AUX_LINE* = 6 + MM_BTV_AUX_MIC* = 7 + MM_BTV_AUX_CD* = 8 + MM_BTV_DIGITALIN* = 9 + MM_BTV_DIGITALOUT* = 10 + MM_BTV_MIDIWAVESTREAM* = 11 + MM_BTV_MIXER* = 12 + MM_ENSONIQ_SOUNDSCAPE* = 0x10 + MM_SOUNDSCAPE_WAVEOUT* = MM_ENSONIQ_SOUNDSCAPE+1 + MM_SOUNDSCAPE_WAVEOUT_AUX* = MM_ENSONIQ_SOUNDSCAPE+2 + MM_SOUNDSCAPE_WAVEIN* = MM_ENSONIQ_SOUNDSCAPE+3 + MM_SOUNDSCAPE_MIDIOUT* = MM_ENSONIQ_SOUNDSCAPE+4 + MM_SOUNDSCAPE_MIDIIN* = MM_ENSONIQ_SOUNDSCAPE+5 + MM_SOUNDSCAPE_SYNTH* = MM_ENSONIQ_SOUNDSCAPE+6 + MM_SOUNDSCAPE_MIXER* = MM_ENSONIQ_SOUNDSCAPE+7 + MM_SOUNDSCAPE_AUX* = MM_ENSONIQ_SOUNDSCAPE+8 + MM_NVIDIA_WAVEOUT* = 1 + MM_NVIDIA_WAVEIN* = 2 + MM_NVIDIA_MIDIOUT* = 3 + MM_NVIDIA_MIDIIN* = 4 + MM_NVIDIA_GAMEPORT* = 5 + MM_NVIDIA_MIXER* = 6 + MM_NVIDIA_AUX* = 7 + MM_OKSORI_BASE* = 0 + MM_OKSORI_OSR8_WAVEOUT* = MM_OKSORI_BASE+1 + MM_OKSORI_OSR8_WAVEIN* = MM_OKSORI_BASE+2 + MM_OKSORI_OSR16_WAVEOUT* = MM_OKSORI_BASE+3 + MM_OKSORI_OSR16_WAVEIN* = MM_OKSORI_BASE+4 + MM_OKSORI_FM_OPL4* = MM_OKSORI_BASE+5 + MM_OKSORI_MIX_MASTER* = MM_OKSORI_BASE+6 + MM_OKSORI_MIX_WAVE* = MM_OKSORI_BASE+7 + MM_OKSORI_MIX_FM* = MM_OKSORI_BASE+8 + MM_OKSORI_MIX_LINE* = MM_OKSORI_BASE+9 + MM_OKSORI_MIX_CD* = MM_OKSORI_BASE+10 + MM_OKSORI_MIX_MIC* = MM_OKSORI_BASE+11 + MM_OKSORI_MIX_ECHO* = MM_OKSORI_BASE+12 + MM_OKSORI_MIX_AUX1* = MM_OKSORI_BASE+13 + MM_OKSORI_MIX_LINE1* = MM_OKSORI_BASE+14 + MM_OKSORI_EXT_MIC1* = MM_OKSORI_BASE+15 + MM_OKSORI_EXT_MIC2* = MM_OKSORI_BASE+16 + MM_OKSORI_MIDIOUT* = MM_OKSORI_BASE+17 + MM_OKSORI_MIDIIN* = MM_OKSORI_BASE+18 + MM_OKSORI_MPEG_CDVISION* = MM_OKSORI_BASE+19 + MM_DIACOUSTICS_DRUM_ACTION* = 1 + MM_KAY_ELEMETRICS_CSL* = 0x4300 + MM_KAY_ELEMETRICS_CSL_DAT* = 0x4308 + MM_KAY_ELEMETRICS_CSL_4CHANNEL* = 0x4309 + MM_CRYSTAL_CS4232_WAVEIN* = 1 + MM_CRYSTAL_CS4232_WAVEOUT* = 2 + MM_CRYSTAL_CS4232_WAVEMIXER* = 3 + MM_CRYSTAL_CS4232_WAVEAUX_AUX1* = 4 + MM_CRYSTAL_CS4232_WAVEAUX_AUX2* = 5 + MM_CRYSTAL_CS4232_WAVEAUX_LINE* = 6 + MM_CRYSTAL_CS4232_WAVEAUX_MONO* = 7 + MM_CRYSTAL_CS4232_WAVEAUX_MASTER* = 8 + MM_CRYSTAL_CS4232_MIDIIN* = 9 + MM_CRYSTAL_CS4232_MIDIOUT* = 10 + MM_CRYSTAL_CS4232_INPUTGAIN_AUX1* = 13 + MM_CRYSTAL_CS4232_INPUTGAIN_LOOP* = 14 + MM_CRYSTAL_SOUND_FUSION_WAVEIN* = 21 + MM_CRYSTAL_SOUND_FUSION_WAVEOUT* = 22 + MM_CRYSTAL_SOUND_FUSION_MIXER* = 23 + MM_CRYSTAL_SOUND_FUSION_MIDIIN* = 24 + MM_CRYSTAL_SOUND_FUSION_MIDIOUT* = 25 + MM_CRYSTAL_SOUND_FUSION_JOYSTICK* = 26 + MM_QUARTERDECK_LHWAVEIN* = 0 + MM_QUARTERDECK_LHWAVEOUT* = 1 + MM_TDK_MW_MIDI_SYNTH* = 1 + MM_TDK_MW_MIDI_IN* = 2 + MM_TDK_MW_MIDI_OUT* = 3 + MM_TDK_MW_WAVE_IN* = 4 + MM_TDK_MW_WAVE_OUT* = 5 + MM_TDK_MW_AUX* = 6 + MM_TDK_MW_MIXER* = 10 + MM_TDK_MW_AUX_MASTER* = 100 + MM_TDK_MW_AUX_BASS* = 101 + MM_TDK_MW_AUX_TREBLE* = 102 + MM_TDK_MW_AUX_MIDI_VOL* = 103 + MM_TDK_MW_AUX_WAVE_VOL* = 104 + MM_TDK_MW_AUX_WAVE_RVB* = 105 + MM_TDK_MW_AUX_WAVE_CHR* = 106 + MM_TDK_MW_AUX_VOL* = 107 + MM_TDK_MW_AUX_RVB* = 108 + MM_TDK_MW_AUX_CHR* = 109 + MM_DIGITAL_AUDIO_LABS_TC* = 0x01 + MM_DIGITAL_AUDIO_LABS_DOC* = 0x02 + MM_DIGITAL_AUDIO_LABS_V8* = 0x10 + MM_DIGITAL_AUDIO_LABS_CPRO* = 0x11 + MM_DIGITAL_AUDIO_LABS_VP* = 0x12 + MM_DIGITAL_AUDIO_LABS_CDLX* = 0x13 + MM_DIGITAL_AUDIO_LABS_CTDIF* = 0x14 + MM_SEERSYS_SEERSYNTH* = 1 + MM_SEERSYS_SEERWAVE* = 2 + MM_SEERSYS_SEERMIX* = 3 + MM_SEERSYS_WAVESYNTH* = 4 + MM_SEERSYS_WAVESYNTH_WG* = 5 + MM_SEERSYS_REALITY* = 6 + MM_OSPREY_1000WAVEIN* = 1 + MM_OSPREY_1000WAVEOUT* = 2 + MM_SOUNDESIGNS_WAVEIN* = 1 + MM_SOUNDESIGNS_WAVEOUT* = 2 + MM_SSP_SNDFESWAVEIN* = 1 + MM_SSP_SNDFESWAVEOUT* = 2 + MM_SSP_SNDFESMIDIIN* = 3 + MM_SSP_SNDFESMIDIOUT* = 4 + MM_SSP_SNDFESSYNTH* = 5 + MM_SSP_SNDFESMIX* = 6 + MM_SSP_SNDFESAUX* = 7 + MM_ECS_AADF_MIDI_IN* = 10 + MM_ECS_AADF_MIDI_OUT* = 11 + MM_ECS_AADF_WAVE2MIDI_IN* = 12 + MM_AMD_INTERWAVE_WAVEIN* = 1 + MM_AMD_INTERWAVE_WAVEOUT* = 2 + MM_AMD_INTERWAVE_SYNTH* = 3 + MM_AMD_INTERWAVE_MIXER1* = 4 + MM_AMD_INTERWAVE_MIXER2* = 5 + MM_AMD_INTERWAVE_JOYSTICK* = 6 + MM_AMD_INTERWAVE_EX_CD* = 7 + MM_AMD_INTERWAVE_MIDIIN* = 8 + MM_AMD_INTERWAVE_MIDIOUT* = 9 + MM_AMD_INTERWAVE_AUX1* = 10 + MM_AMD_INTERWAVE_AUX2* = 11 + MM_AMD_INTERWAVE_AUX_MIC* = 12 + MM_AMD_INTERWAVE_AUX_CD* = 13 + MM_AMD_INTERWAVE_MONO_IN* = 14 + MM_AMD_INTERWAVE_MONO_OUT* = 15 + MM_AMD_INTERWAVE_EX_TELEPHONY* = 16 + MM_AMD_INTERWAVE_WAVEOUT_BASE* = 17 + MM_AMD_INTERWAVE_WAVEOUT_TREBLE* = 18 + MM_AMD_INTERWAVE_STEREO_ENHANCED* = 19 + MM_COREDYNAMICS_DYNAMIXHR* = 1 + MM_COREDYNAMICS_DYNASONIX_SYNTH* = 2 + MM_COREDYNAMICS_DYNASONIX_MIDI_IN* = 3 + MM_COREDYNAMICS_DYNASONIX_MIDI_OUT* = 4 + MM_COREDYNAMICS_DYNASONIX_WAVE_IN* = 5 + MM_COREDYNAMICS_DYNASONIX_WAVE_OUT* = 6 + MM_COREDYNAMICS_DYNASONIX_AUDIO_IN* = 7 + MM_COREDYNAMICS_DYNASONIX_AUDIO_OUT* = 8 + MM_COREDYNAMICS_DYNAGRAFX_VGA* = 9 + MM_COREDYNAMICS_DYNAGRAFX_WAVE_IN* = 10 + MM_COREDYNAMICS_DYNAGRAFX_WAVE_OUT* = 11 + MM_CANAM_CBXWAVEOUT* = 1 + MM_CANAM_CBXWAVEIN* = 2 + MM_SOFTSOUND_CODEC* = 1 + MM_NORRIS_VOICELINK* = 1 + MM_DDD_MIDILINK_MIDIIN* = 1 + MM_DDD_MIDILINK_MIDIOUT* = 2 + MM_EUPHONICS_AUX_CD* = 1 + MM_EUPHONICS_AUX_LINE* = 2 + MM_EUPHONICS_AUX_MASTER* = 3 + MM_EUPHONICS_AUX_MIC* = 4 + MM_EUPHONICS_AUX_MIDI* = 5 + MM_EUPHONICS_AUX_WAVE* = 6 + MM_EUPHONICS_FMSYNTH_MONO* = 7 + MM_EUPHONICS_FMSYNTH_STEREO* = 8 + MM_EUPHONICS_MIDIIN* = 9 + MM_EUPHONICS_MIDIOUT* = 10 + MM_EUPHONICS_MIXER* = 11 + MM_EUPHONICS_WAVEIN* = 12 + MM_EUPHONICS_WAVEOUT* = 13 + MM_EUPHONICS_EUSYNTH* = 14 + CRYSTAL_NET_SFM_CODEC* = 1 + MM_CHROMATIC_M1* = 0x0001 + MM_CHROMATIC_M1_WAVEIN* = 0x0002 + MM_CHROMATIC_M1_WAVEOUT* = 0x0003 + MM_CHROMATIC_M1_FMSYNTH* = 0x0004 + MM_CHROMATIC_M1_MIXER* = 0x0005 + MM_CHROMATIC_M1_AUX* = 0x0006 + MM_CHROMATIC_M1_AUX_CD* = 0x0007 + MM_CHROMATIC_M1_MIDIIN* = 0x0008 + MM_CHROMATIC_M1_MIDIOUT* = 0x0009 + MM_CHROMATIC_M1_WTSYNTH* = 0x0010 + MM_CHROMATIC_M1_MPEGWAVEIN* = 0x0011 + MM_CHROMATIC_M1_MPEGWAVEOUT* = 0x0012 + MM_CHROMATIC_M2* = 0x0013 + MM_CHROMATIC_M2_WAVEIN* = 0x0014 + MM_CHROMATIC_M2_WAVEOUT* = 0x0015 + MM_CHROMATIC_M2_FMSYNTH* = 0x0016 + MM_CHROMATIC_M2_MIXER* = 0x0017 + MM_CHROMATIC_M2_AUX* = 0x0018 + MM_CHROMATIC_M2_AUX_CD* = 0x0019 + MM_CHROMATIC_M2_MIDIIN* = 0x0020 + MM_CHROMATIC_M2_MIDIOUT* = 0x0021 + MM_CHROMATIC_M2_WTSYNTH* = 0x0022 + MM_CHROMATIC_M2_MPEGWAVEIN* = 0x0023 + MM_CHROMATIC_M2_MPEGWAVEOUT* = 0x0024 + MM_VIENNASYS_TSP_WAVE_DRIVER* = 1 + MM_CONNECTIX_VIDEC_CODEC* = 1 + MM_GADGETLABS_WAVE44_WAVEIN* = 1 + MM_GADGETLABS_WAVE44_WAVEOUT* = 2 + MM_GADGETLABS_WAVE42_WAVEIN* = 3 + MM_GADGETLABS_WAVE42_WAVEOUT* = 4 + MM_GADGETLABS_WAVE4_MIDIIN* = 5 + MM_GADGETLABS_WAVE4_MIDIOUT* = 6 + MM_FRONTIER_WAVECENTER_MIDIIN* = 1 + MM_FRONTIER_WAVECENTER_MIDIOUT* = 2 + MM_FRONTIER_WAVECENTER_WAVEIN* = 3 + MM_FRONTIER_WAVECENTER_WAVEOUT* = 4 + MM_VIONA_QVINPCI_MIXER* = 1 + MM_VIONA_QVINPCI_WAVEIN* = 2 + MM_VIONAQVINPCI_WAVEOUT* = 3 + MM_VIONA_BUSTER_MIXER* = 4 + MM_VIONA_CINEMASTER_MIXER* = 5 + MM_VIONA_CONCERTO_MIXER* = 6 + MM_CASIO_WP150_MIDIOUT* = 1 + MM_CASIO_WP150_MIDIIN* = 2 + MM_CASIO_LSG_MIDIOUT* = 3 + MM_DIMD_PLATFORM* = 0 + MM_DIMD_DIRSOUND* = 1 + MM_DIMD_VIRTMPU* = 2 + MM_DIMD_VIRTSB* = 3 + MM_DIMD_VIRTJOY* = 4 + MM_DIMD_WAVEIN* = 5 + MM_DIMD_WAVEOUT* = 6 + MM_DIMD_MIDIIN* = 7 + MM_DIMD_MIDIOUT* = 8 + MM_DIMD_AUX_LINE* = 9 + MM_DIMD_MIXER* = 10 + MM_DIMD_WSS_WAVEIN* = 14 + MM_DIMD_WSS_WAVEOUT* = 15 + MM_DIMD_WSS_MIXER* = 17 + MM_DIMD_WSS_AUX* = 21 + MM_DIMD_WSS_SYNTH* = 76 + MM_S3_WAVEOUT* = 1 + MM_S3_WAVEIN* = 2 + MM_S3_MIDIOUT* = 3 + MM_S3_MIDIIN* = 4 + MM_S3_FMSYNTH* = 5 + MM_S3_MIXER* = 6 + MM_S3_AUX* = 7 + MM_VKC_MPU401_MIDIIN* = 0x0100 + MM_VKC_SERIAL_MIDIIN* = 0x0101 + MM_VKC_MPU401_MIDIOUT* = 0x0200 + MM_VKC_SERIAL_MIDIOUT* = 0x0201 + MM_ZEFIRO_ZA2* = 2 + MM_FHGIIS_MPEGLAYER3_DECODE* = 9 + MM_FHGIIS_MPEGLAYER3* = 10 + MM_FHGIIS_MPEGLAYER3_LITE* = 10 + MM_FHGIIS_MPEGLAYER3_BASIC* = 11 + MM_FHGIIS_MPEGLAYER3_ADVANCED* = 12 + MM_FHGIIS_MPEGLAYER3_PROFESSIONAL* = 13 + MM_FHGIIS_MPEGLAYER3_ADVANCEDPLUS* = 14 + MM_QUICKNET_PJWAVEIN* = 1 + MM_QUICKNET_PJWAVEOUT* = 2 + MM_SICRESOURCE_SSO3D* = 2 + MM_SICRESOURCE_SSOW3DI* = 3 + MM_NEOMAGIC_SYNTH* = 1 + MM_NEOMAGIC_WAVEOUT* = 2 + MM_NEOMAGIC_WAVEIN* = 3 + MM_NEOMAGIC_MIDIOUT* = 4 + MM_NEOMAGIC_MIDIIN* = 5 + MM_NEOMAGIC_AUX* = 6 + MM_NEOMAGIC_MW3DX_WAVEOUT* = 10 + MM_NEOMAGIC_MW3DX_WAVEIN* = 11 + MM_NEOMAGIC_MW3DX_MIDIOUT* = 12 + MM_NEOMAGIC_MW3DX_MIDIIN* = 13 + MM_NEOMAGIC_MW3DX_FMSYNTH* = 14 + MM_NEOMAGIC_MW3DX_GMSYNTH* = 15 + MM_NEOMAGIC_MW3DX_MIXER* = 16 + MM_NEOMAGIC_MW3DX_AUX* = 17 + MM_NEOMAGIC_MWAVE_WAVEOUT* = 20 + MM_NEOMAGIC_MWAVE_WAVEIN* = 21 + MM_NEOMAGIC_MWAVE_MIDIOUT* = 22 + MM_NEOMAGIC_MWAVE_MIDIIN* = 23 + MM_NEOMAGIC_MWAVE_MIXER* = 24 + MM_NEOMAGIC_MWAVE_AUX* = 25 + MM_MERGING_MPEGL3* = 1 + MM_XIRLINK_VISIONLINK* = 1 + MM_OTI_611WAVEIN* = 5 + MM_OTI_611WAVEOUT* = 6 + MM_OTI_611MIXER* = 7 + MM_OTI_611MIDIN* = 0x12 + MM_OTI_611MIDIOUT* = 0x13 + MM_AUREAL_AU8820* = 16 + MM_AU8820_SYNTH* = 17 + MM_AU8820_WAVEOUT* = 18 + MM_AU8820_WAVEIN* = 19 + MM_AU8820_MIXER* = 20 + MM_AU8820_AUX* = 21 + MM_AU8820_MIDIOUT* = 22 + MM_AU8820_MIDIIN* = 23 + MM_AUREAL_AU8830* = 32 + MM_AU8830_SYNTH* = 33 + MM_AU8830_WAVEOUT* = 34 + MM_AU8830_WAVEIN* = 35 + MM_AU8830_MIXER* = 36 + MM_AU8830_AUX* = 37 + MM_AU8830_MIDIOUT* = 38 + MM_AU8830_MIDIIN* = 39 + MM_VIVO_AUDIO_CODEC* = 1 + MM_SHARP_MDC_MIDI_SYNTH* = 1 + MM_SHARP_MDC_MIDI_IN* = 2 + MM_SHARP_MDC_MIDI_OUT* = 3 + MM_SHARP_MDC_WAVE_IN* = 4 + MM_SHARP_MDC_WAVE_OUT* = 5 + MM_SHARP_MDC_AUX* = 6 + MM_SHARP_MDC_MIXER* = 10 + MM_SHARP_MDC_AUX_MASTER* = 100 + MM_SHARP_MDC_AUX_BASS* = 101 + MM_SHARP_MDC_AUX_TREBLE* = 102 + MM_SHARP_MDC_AUX_MIDI_VOL* = 103 + MM_SHARP_MDC_AUX_WAVE_VOL* = 104 + MM_SHARP_MDC_AUX_WAVE_RVB* = 105 + MM_SHARP_MDC_AUX_WAVE_CHR* = 106 + MM_SHARP_MDC_AUX_VOL* = 107 + MM_SHARP_MDC_AUX_RVB* = 108 + MM_SHARP_MDC_AUX_CHR* = 109 + MM_LUCENT_ACM_G723* = 0 + MM_ATT_G729A* = 1 + MM_MARIAN_ARC44WAVEIN* = 1 + MM_MARIAN_ARC44WAVEOUT* = 2 + MM_MARIAN_PRODIF24WAVEIN* = 3 + MM_MARIAN_PRODIF24WAVEOUT* = 4 + MM_MARIAN_ARC88WAVEIN* = 5 + MM_MARIAN_ARC88WAVEOUT* = 6 + MM_BCB_NETBOARD_10* = 1 + MM_BCB_TT75_10* = 2 + MM_MOTIONPIXELS_MVI2* = 1 + MM_QDESIGN_ACM_MPEG* = 1 + MM_QDESIGN_ACM_QDESIGN_MUSIC* = 2 + MM_NMP_CCP_WAVEIN* = 1 + MM_NMP_CCP_WAVEOUT* = 2 + MM_NMP_ACM_AMR* = 10 + MM_DF_ACM_G726* = 1 + MM_DF_ACM_GSM610* = 2 + MM_BERCOS_WAVEIN* = 1 + MM_BERCOS_MIXER* = 2 + MM_BERCOS_WAVEOUT* = 3 + MM_ONLIVE_MPCODEC* = 1 + MM_PHONET_PP_WAVEOUT* = 1 + MM_PHONET_PP_WAVEIN* = 2 + MM_PHONET_PP_MIXER* = 3 + MM_FTR_ENCODER_WAVEIN* = 1 + MM_FTR_ACM* = 2 + MM_ENET_T2000_LINEIN* = 1 + MM_ENET_T2000_LINEOUT* = 2 + MM_ENET_T2000_HANDSETIN* = 3 + MM_ENET_T2000_HANDSETOUT* = 4 + MM_EMAGIC_UNITOR8* = 1 + MM_SIPROLAB_ACELPNET* = 1 + MM_DICTAPHONE_G726* = 1 + MM_RZS_ACM_TUBGSM* = 1 + MM_EES_PCMIDI14* = 1 + MM_EES_PCMIDI14_IN* = 2 + MM_EES_PCMIDI14_OUT1* = 3 + MM_EES_PCMIDI14_OUT2* = 4 + MM_EES_PCMIDI14_OUT3* = 5 + MM_EES_PCMIDI14_OUT4* = 6 + MM_HAFTMANN_LPTDAC2* = 1 + MM_LUCID_PCI24WAVEIN* = 1 + MM_LUCID_PCI24WAVEOUT* = 2 + MM_HEADSPACE_HAESYNTH* = 1 + MM_HEADSPACE_HAEWAVEOUT* = 2 + MM_HEADSPACE_HAEWAVEIN* = 3 + MM_HEADSPACE_HAEMIXER* = 4 + MM_UNISYS_ACM_NAP* = 1 + MM_LUMINOSITI_SCWAVEIN* = 1 + MM_LUMINOSITI_SCWAVEOUT* = 2 + MM_LUMINOSITI_SCWAVEMIX* = 3 + MM_ACTIVEVOICE_ACM_VOXADPCM* = 1 + MM_DTS_DS* = 1 + MM_SOFTLAB_NSK_FRW_WAVEIN* = 1 + MM_SOFTLAB_NSK_FRW_WAVEOUT* = 2 + MM_SOFTLAB_NSK_FRW_MIXER* = 3 + MM_SOFTLAB_NSK_FRW_AUX* = 4 + MM_FORTEMEDIA_WAVEIN* = 1 + MM_FORTEMEDIA_WAVEOUT* = 2 + MM_FORTEMEDIA_FMSYNC* = 3 + MM_FORTEMEDIA_MIXER* = 4 + MM_FORTEMEDIA_AUX* = 5 + MM_SONORUS_STUDIO* = 1 + MM_I_LINK_VOICE_CODER* = 1 + MM_SELSIUS_SYSTEMS_RTPWAVEOUT* = 1 + MM_SELSIUS_SYSTEMS_RTPWAVEIN* = 2 + MM_ADMOS_FM_SYNTH* = 1 + MM_ADMOS_QS3AMIDIOUT* = 2 + MM_ADMOS_QS3AMIDIIN* = 3 + MM_ADMOS_QS3AWAVEOUT* = 4 + MM_ADMOS_QS3AWAVEIN* = 5 + MM_LEXICON_STUDIO_WAVE_OUT* = 1 + MM_LEXICON_STUDIO_WAVE_IN* = 2 + MM_SGI_320_WAVEIN* = 1 + MM_SGI_320_WAVEOUT* = 2 + MM_SGI_320_MIXER* = 3 + MM_SGI_540_WAVEIN* = 4 + MM_SGI_540_WAVEOUT* = 5 + MM_SGI_540_MIXER* = 6 + MM_SGI_RAD_ADATMONO1_WAVEIN* = 7 + MM_SGI_RAD_ADATMONO2_WAVEIN* = 8 + MM_SGI_RAD_ADATMONO3_WAVEIN* = 9 + MM_SGI_RAD_ADATMONO4_WAVEIN* = 10 + MM_SGI_RAD_ADATMONO5_WAVEIN* = 11 + MM_SGI_RAD_ADATMONO6_WAVEIN* = 12 + MM_SGI_RAD_ADATMONO7_WAVEIN* = 13 + MM_SGI_RAD_ADATMONO8_WAVEIN* = 14 + MM_SGI_RAD_ADATSTEREO12_WAVEIN* = 15 + MM_SGI_RAD_ADATSTEREO34_WAVEIN* = 16 + MM_SGI_RAD_ADATSTEREO56_WAVEIN* = 17 + MM_SGI_RAD_ADATSTEREO78_WAVEIN* = 18 + MM_SGI_RAD_ADAT8CHAN_WAVEIN* = 19 + MM_SGI_RAD_ADATMONO1_WAVEOUT* = 20 + MM_SGI_RAD_ADATMONO2_WAVEOUT* = 21 + MM_SGI_RAD_ADATMONO3_WAVEOUT* = 22 + MM_SGI_RAD_ADATMONO4_WAVEOUT* = 23 + MM_SGI_RAD_ADATMONO5_WAVEOUT* = 24 + MM_SGI_RAD_ADATMONO6_WAVEOUT* = 25 + MM_SGI_RAD_ADATMONO7_WAVEOUT* = 26 + MM_SGI_RAD_ADATMONO8_WAVEOUT* = 27 + MM_SGI_RAD_ADATSTEREO12_WAVEOUT* = 28 + MM_SGI_RAD_ADATSTEREO32_WAVEOUT* = 29 + MM_SGI_RAD_ADATSTEREO56_WAVEOUT* = 30 + MM_SGI_RAD_ADATSTEREO78_WAVEOUT* = 31 + MM_SGI_RAD_ADAT8CHAN_WAVEOUT* = 32 + MM_SGI_RAD_AESMONO1_WAVEIN* = 33 + MM_SGI_RAD_AESMONO2_WAVEIN* = 34 + MM_SGI_RAD_AESSTEREO_WAVEIN* = 35 + MM_SGI_RAD_AESMONO1_WAVEOUT* = 36 + MM_SGI_RAD_AESMONO2_WAVEOUT* = 37 + MM_SGI_RAD_AESSTEREO_WAVEOUT* = 38 + MM_IPI_ACM_HSX* = 1 + MM_IPI_ACM_RPELP* = 2 + MM_IPI_WF_ASSS* = 3 + MM_IPI_AT_WAVEOUT* = 4 + MM_IPI_AT_WAVEIN* = 5 + MM_IPI_AT_MIXER* = 6 + MM_ICE_WAVEOUT* = 1 + MM_ICE_WAVEIN* = 2 + MM_ICE_MTWAVEOUT* = 3 + MM_ICE_MTWAVEIN* = 4 + MM_ICE_MIDIOUT1* = 5 + MM_ICE_MIDIIN1* = 6 + MM_ICE_MIDIOUT2* = 7 + MM_ICE_MIDIIN2* = 8 + MM_ICE_SYNTH* = 9 + MM_ICE_MIXER* = 10 + MM_ICE_AUX* = 11 + MM_VQST_VQC1* = 1 + MM_VQST_VQC2* = 2 + MM_ETEK_KWIKMIDI_MIDIIN* = 1 + MM_ETEK_KWIKMIDI_MIDIOUT* = 2 + MM_INTERNET_SSW_MIDIOUT* = 10 + MM_INTERNET_SSW_MIDIIN* = 11 + MM_INTERNET_SSW_WAVEOUT* = 12 + MM_INTERNET_SSW_WAVEIN* = 13 + MM_SONY_ACM_SCX* = 1 + MM_UH_ACM_ADPCM* = 1 + MM_SYDEC_NV_WAVEIN* = 1 + MM_SYDEC_NV_WAVEOUT* = 2 + MM_FLEXION_X300_WAVEIN* = 1 + MM_FLEXION_X300_WAVEOUT* = 2 + MM_VIA_WAVEOUT* = 1 + MM_VIA_WAVEIN* = 2 + MM_VIA_MIXER* = 3 + MM_VIA_AUX* = 4 + MM_VIA_MPU401_MIDIOUT* = 5 + MM_VIA_MPU401_MIDIIN* = 6 + MM_VIA_SWFM_SYNTH* = 7 + MM_VIA_WDM_WAVEOUT* = 8 + MM_VIA_WDM_WAVEIN* = 9 + MM_VIA_WDM_MIXER* = 10 + MM_VIA_WDM_MPU401_MIDIOUT* = 11 + MM_VIA_WDM_MPU401_MIDIIN* = 12 + MM_MICRONAS_SC4* = 1 + MM_MICRONAS_CLP833* = 2 + MM_HP_WAVEOUT* = 1 + MM_HP_WAVEIN* = 2 + MM_QUICKAUDIO_MINIMIDI* = 1 + MM_QUICKAUDIO_MAXIMIDI* = 2 + MM_ICCC_UNA3_WAVEIN* = 1 + MM_ICCC_UNA3_WAVEOUT* = 2 + MM_ICCC_UNA3_AUX* = 3 + MM_ICCC_UNA3_MIXER* = 4 + MM_3COM_CB_MIXER* = 1 + MM_3COM_CB_WAVEIN* = 2 + MM_3COM_CB_WAVEOUT* = 3 + MM_MINDMAKER_GC_WAVEIN* = 1 + MM_MINDMAKER_GC_WAVEOUT* = 2 + MM_MINDMAKER_GC_MIXER* = 3 + MM_TELEKOL_WAVEOUT* = 1 + MM_TELEKOL_WAVEIN* = 2 + MM_ALGOVISION_VB80WAVEOUT* = 1 + MM_ALGOVISION_VB80WAVEIN* = 2 + MM_ALGOVISION_VB80MIXER* = 3 + MM_ALGOVISION_VB80AUX* = 4 + MM_ALGOVISION_VB80AUX2* = 5 +template mmioFOURCC*(c0: untyped, c1: untyped, c2: untyped, c3: untyped): untyped = c0.DWORD or (c1.DWORD shl 8) or (c2.DWORD shl 16) or (c3.DWORD shl 24) +const + RIFFINFO_IARL* = mmioFOURCC('I', 'A', 'R', 'L') + RIFFINFO_IART* = mmioFOURCC('I', 'A', 'R', 'T') + RIFFINFO_ICMS* = mmioFOURCC('I', 'C', 'M', 'S') + RIFFINFO_ICMT* = mmioFOURCC('I', 'C', 'M', 'T') + RIFFINFO_ICOP* = mmioFOURCC('I', 'C', 'O', 'P') + RIFFINFO_ICRD* = mmioFOURCC('I', 'C', 'R', 'D') + RIFFINFO_ICRP* = mmioFOURCC('I', 'C', 'R', 'P') + RIFFINFO_IDIM* = mmioFOURCC('I', 'D', 'I', 'M') + RIFFINFO_IDPI* = mmioFOURCC('I', 'D', 'P', 'I') + RIFFINFO_IENG* = mmioFOURCC('I', 'E', 'N', 'G') + RIFFINFO_IGNR* = mmioFOURCC('I', 'G', 'N', 'R') + RIFFINFO_IKEY* = mmioFOURCC('I', 'K', 'E', 'Y') + RIFFINFO_ILGT* = mmioFOURCC('I', 'L', 'G', 'T') + RIFFINFO_IMED* = mmioFOURCC('I', 'M', 'E', 'D') + RIFFINFO_INAM* = mmioFOURCC('I', 'N', 'A', 'M') + RIFFINFO_IPLT* = mmioFOURCC('I', 'P', 'L', 'T') + RIFFINFO_IPRD* = mmioFOURCC('I', 'P', 'R', 'D') + RIFFINFO_ISBJ* = mmioFOURCC('I', 'S', 'B', 'J') + RIFFINFO_ISFT* = mmioFOURCC('I', 'S', 'F', 'T') + RIFFINFO_ISHP* = mmioFOURCC('I', 'S', 'H', 'P') + RIFFINFO_ISRC* = mmioFOURCC('I', 'S', 'R', 'C') + RIFFINFO_ISRF* = mmioFOURCC('I', 'S', 'R', 'F') + RIFFINFO_ITCH* = mmioFOURCC('I', 'T', 'C', 'H') + RIFFINFO_ISMP* = mmioFOURCC('I', 'S', 'M', 'P') + RIFFINFO_IDIT* = mmioFOURCC('I', 'D', 'I', 'T') + RIFFINFO_ITRK* = mmioFOURCC('I', 'T', 'R', 'K') + RIFFINFO_ITOC* = mmioFOURCC('I', 'T', 'O', 'C') + WAVE_FORMAT_UNKNOWN* = 0x0000 + WAVE_FORMAT_ADPCM* = 0x0002 + WAVE_FORMAT_IEEE_FLOAT* = 0x0003 + WAVE_FORMAT_VSELP* = 0x0004 + WAVE_FORMAT_IBM_CVSD* = 0x0005 + WAVE_FORMAT_ALAW* = 0x0006 + WAVE_FORMAT_MULAW* = 0x0007 + WAVE_FORMAT_DTS* = 0x0008 + WAVE_FORMAT_DRM* = 0x0009 + WAVE_FORMAT_WMAVOICE9* = 0x000a + WAVE_FORMAT_WMAVOICE10* = 0x000b + WAVE_FORMAT_OKI_ADPCM* = 0x0010 + WAVE_FORMAT_DVI_ADPCM* = 0x0011 + WAVE_FORMAT_IMA_ADPCM* = WAVE_FORMAT_DVI_ADPCM + WAVE_FORMAT_MEDIASPACE_ADPCM* = 0x0012 + WAVE_FORMAT_SIERRA_ADPCM* = 0x0013 + WAVE_FORMAT_G723_ADPCM* = 0x0014 + WAVE_FORMAT_DIGISTD* = 0x0015 + WAVE_FORMAT_DIGIFIX* = 0x0016 + WAVE_FORMAT_DIALOGIC_OKI_ADPCM* = 0x0017 + WAVE_FORMAT_MEDIAVISION_ADPCM* = 0x0018 + WAVE_FORMAT_CU_CODEC* = 0x0019 + WAVE_FORMAT_HP_DYN_VOICE* = 0x001a + WAVE_FORMAT_YAMAHA_ADPCM* = 0x0020 + WAVE_FORMAT_SONARC* = 0x0021 + WAVE_FORMAT_DSPGROUP_TRUESPEECH* = 0x0022 + WAVE_FORMAT_ECHOSC1* = 0x0023 + WAVE_FORMAT_AUDIOFILE_AF36* = 0x0024 + WAVE_FORMAT_APTX* = 0x0025 + WAVE_FORMAT_AUDIOFILE_AF10* = 0x0026 + WAVE_FORMAT_PROSODY_1612* = 0x0027 + WAVE_FORMAT_LRC* = 0x0028 + WAVE_FORMAT_DOLBY_AC2* = 0x0030 + WAVE_FORMAT_MSNAUDIO* = 0x0032 + WAVE_FORMAT_ANTEX_ADPCME* = 0x0033 + WAVE_FORMAT_CONTROL_RES_VQLPC* = 0x0034 + WAVE_FORMAT_DIGIREAL* = 0x0035 + WAVE_FORMAT_DIGIADPCM* = 0x0036 + WAVE_FORMAT_CONTROL_RES_CR10* = 0x0037 + WAVE_FORMAT_NMS_VBXADPCM* = 0x0038 + WAVE_FORMAT_CS_IMAADPCM* = 0x0039 + WAVE_FORMAT_ECHOSC3* = 0x003a + WAVE_FORMAT_ROCKWELL_ADPCM* = 0x003b + WAVE_FORMAT_ROCKWELL_DIGITALK* = 0x003c + WAVE_FORMAT_XEBEC* = 0x003d + WAVE_FORMAT_G721_ADPCM* = 0x0040 + WAVE_FORMAT_G728_CELP* = 0x0041 + WAVE_FORMAT_MSG723* = 0x0042 + WAVE_FORMAT_INTEL_G723_1* = 0x0043 + WAVE_FORMAT_INTEL_G729* = 0x0044 + WAVE_FORMAT_SHARP_G726* = 0x0045 + WAVE_FORMAT_MPEG* = 0x0050 + WAVE_FORMAT_RT24* = 0x0052 + WAVE_FORMAT_PAC* = 0x0053 + WAVE_FORMAT_MPEGLAYER3* = 0x0055 + WAVE_FORMAT_LUCENT_G723* = 0x0059 + WAVE_FORMAT_CIRRUS* = 0x0060 + WAVE_FORMAT_ESPCM* = 0x0061 + WAVE_FORMAT_VOXWARE* = 0x0062 + WAVE_FORMAT_CANOPUS_ATRAC* = 0x0063 + WAVE_FORMAT_G726_ADPCM* = 0x0064 + WAVE_FORMAT_G722_ADPCM* = 0x0065 + WAVE_FORMAT_DSAT* = 0x0066 + WAVE_FORMAT_DSAT_DISPLAY* = 0x0067 + WAVE_FORMAT_VOXWARE_BYTE_ALIGNED* = 0x0069 + WAVE_FORMAT_VOXWARE_AC8* = 0x0070 + WAVE_FORMAT_VOXWARE_AC10* = 0x0071 + WAVE_FORMAT_VOXWARE_AC16* = 0x0072 + WAVE_FORMAT_VOXWARE_AC20* = 0x0073 + WAVE_FORMAT_VOXWARE_RT24* = 0x0074 + WAVE_FORMAT_VOXWARE_RT29* = 0x0075 + WAVE_FORMAT_VOXWARE_RT29HW* = 0x0076 + WAVE_FORMAT_VOXWARE_VR12* = 0x0077 + WAVE_FORMAT_VOXWARE_VR18* = 0x0078 + WAVE_FORMAT_VOXWARE_TQ40* = 0x0079 + WAVE_FORMAT_VOXWARE_SC3* = 0x007a + WAVE_FORMAT_VOXWARE_SC3_1* = 0x007b + WAVE_FORMAT_SOFTSOUND* = 0x0080 + WAVE_FORMAT_VOXWARE_TQ60* = 0x0081 + WAVE_FORMAT_MSRT24* = 0x0082 + WAVE_FORMAT_G729A* = 0x0083 + WAVE_FORMAT_MVI_MVI2* = 0x0084 + WAVE_FORMAT_DF_G726* = 0x0085 + WAVE_FORMAT_DF_GSM610* = 0x0086 + WAVE_FORMAT_ISIAUDIO* = 0x0088 + WAVE_FORMAT_ONLIVE* = 0x0089 + WAVE_FORMAT_MULTITUDE_FT_SX20* = 0x008a + WAVE_FORMAT_INFOCOM_ITS_G721_ADPCM* = 0x008b + WAVE_FORMAT_CONVEDIA_G729* = 0x008c + WAVE_FORMAT_CONGRUENCY* = 0x008d + WAVE_FORMAT_SBC24* = 0x0091 + WAVE_FORMAT_DOLBY_AC3_SPDIF* = 0x0092 + WAVE_FORMAT_MEDIASONIC_G723* = 0x0093 + WAVE_FORMAT_PROSODY_8KBPS* = 0x0094 + WAVE_FORMAT_ZYXEL_ADPCM* = 0x0097 + WAVE_FORMAT_PHILIPS_LPCBB* = 0x0098 + WAVE_FORMAT_PACKED* = 0x0099 + WAVE_FORMAT_MALDEN_PHONYTALK* = 0x00a0 + WAVE_FORMAT_RACAL_RECORDER_GSM* = 0x00a1 + WAVE_FORMAT_RACAL_RECORDER_G720_A* = 0x00a2 + WAVE_FORMAT_RACAL_RECORDER_G723_1* = 0x00a3 + WAVE_FORMAT_RACAL_RECORDER_TETRA_ACELP* = 0x00a4 + WAVE_FORMAT_NEC_AAC* = 0x00b0 + WAVE_FORMAT_RAW_AAC1* = 0x00ff + WAVE_FORMAT_RHETOREX_ADPCM* = 0x0100 + WAVE_FORMAT_IRAT* = 0x0101 + WAVE_FORMAT_VIVO_G723* = 0x0111 + WAVE_FORMAT_VIVO_SIREN* = 0x0112 + WAVE_FORMAT_PHILIPS_CELP* = 0x0120 + WAVE_FORMAT_PHILIPS_GRUNDIG* = 0x0121 + WAVE_FORMAT_DIGITAL_G723* = 0x0123 + WAVE_FORMAT_SANYO_LD_ADPCM* = 0x0125 + WAVE_FORMAT_SIPROLAB_ACEPLNET* = 0x0130 + WAVE_FORMAT_SIPROLAB_ACELP4800* = 0x0131 + WAVE_FORMAT_SIPROLAB_ACELP8V3* = 0x0132 + WAVE_FORMAT_SIPROLAB_G729* = 0x0133 + WAVE_FORMAT_SIPROLAB_G729A* = 0x0134 + WAVE_FORMAT_SIPROLAB_KELVIN* = 0x0135 + WAVE_FORMAT_VOICEAGE_AMR* = 0x0136 + WAVE_FORMAT_DICTAPHONE_CELP68* = 0x0141 + WAVE_FORMAT_DICTAPHONE_CELP54* = 0x0142 + WAVE_FORMAT_QUALCOMM_PUREVOICE* = 0x0150 + WAVE_FORMAT_QUALCOMM_HALFRATE* = 0x0151 + WAVE_FORMAT_TUBGSM* = 0x0155 + WAVE_FORMAT_MSAUDIO1* = 0x0160 + WAVE_FORMAT_WMAUDIO2* = 0x0161 + WAVE_FORMAT_WMAUDIO3* = 0x0162 + WAVE_FORMAT_WMAUDIO_LOSSLESS* = 0x0163 + WAVE_FORMAT_WMASPDIF* = 0x0164 + WAVE_FORMAT_UNISYS_NAP_ADPCM* = 0x0170 + WAVE_FORMAT_UNISYS_NAP_ULAW* = 0x0171 + WAVE_FORMAT_UNISYS_NAP_ALAW* = 0x0172 + WAVE_FORMAT_UNISYS_NAP_16K* = 0x0173 + WAVE_FORMAT_SYCOM_ACM_SYC008* = 0x0174 + WAVE_FORMAT_SYCOM_ACM_SYC701_G726L* = 0x0175 + WAVE_FORMAT_SYCOM_ACM_SYC701_CELP54* = 0x0176 + WAVE_FORMAT_SYCOM_ACM_SYC701_CELP68* = 0x0177 + WAVE_FORMAT_KNOWLEDGE_ADVENTURE_ADPCM* = 0x0178 + WAVE_FORMAT_FRAUNHOFER_IIS_MPEG2_AAC* = 0x0180 + WAVE_FORMAT_DTS_DS* = 0x0190 + WAVE_FORMAT_CREATIVE_ADPCM* = 0x0200 + WAVE_FORMAT_CREATIVE_FASTSPEECH8* = 0x0202 + WAVE_FORMAT_CREATIVE_FASTSPEECH10* = 0x0203 + WAVE_FORMAT_UHER_ADPCM* = 0x0210 + WAVE_FORMAT_ULEAD_DV_AUDIO* = 0x0215 + WAVE_FORMAT_ULEAD_DV_AUDIO_1* = 0x0216 + WAVE_FORMAT_QUARTERDECK* = 0x0220 + WAVE_FORMAT_ILINK_VC* = 0x0230 + WAVE_FORMAT_RAW_SPORT* = 0x0240 + WAVE_FORMAT_ESST_AC3* = 0x0241 + WAVE_FORMAT_GENERIC_PASSTHRU* = 0x0249 + WAVE_FORMAT_IPI_HSX* = 0x0250 + WAVE_FORMAT_IPI_RPELP* = 0x0251 + WAVE_FORMAT_CS2* = 0x0260 + WAVE_FORMAT_SONY_SCX* = 0x0270 + WAVE_FORMAT_SONY_SCY* = 0x0271 + WAVE_FORMAT_SONY_ATRAC3* = 0x0272 + WAVE_FORMAT_SONY_SPC* = 0x0273 + WAVE_FORMAT_TELUM_AUDIO* = 0x0280 + WAVE_FORMAT_TELUM_IA_AUDIO* = 0x0281 + WAVE_FORMAT_NORCOM_VOICE_SYSTEMS_ADPCM* = 0x0285 + WAVE_FORMAT_FM_TOWNS_SND* = 0x0300 + WAVE_FORMAT_MICRONAS* = 0x0350 + WAVE_FORMAT_MICRONAS_CELP833* = 0x0351 + WAVE_FORMAT_BTV_DIGITAL* = 0x0400 + WAVE_FORMAT_INTEL_MUSIC_CODER* = 0x0401 + WAVE_FORMAT_INDEO_AUDIO* = 0x0402 + WAVE_FORMAT_QDESIGN_MUSIC* = 0x0450 + WAVE_FORMAT_ON2_VP7_AUDIO* = 0x0500 + WAVE_FORMAT_ON2_VP6_AUDIO* = 0x0501 + WAVE_FORMAT_VME_VMPCM* = 0x0680 + WAVE_FORMAT_TPC* = 0x0681 + WAVE_FORMAT_LIGHTWAVE_LOSSLESS* = 0x08ae + WAVE_FORMAT_OLIGSM* = 0x1000 + WAVE_FORMAT_OLIADPCM* = 0x1001 + WAVE_FORMAT_OLICELP* = 0x1002 + WAVE_FORMAT_OLISBC* = 0x1003 + WAVE_FORMAT_OLIOPR* = 0x1004 + WAVE_FORMAT_LH_CODEC* = 0x1100 + WAVE_FORMAT_LH_CODEC_CELP* = 0x1101 + WAVE_FORMAT_LH_CODEC_SBC8* = 0x1102 + WAVE_FORMAT_LH_CODEC_SBC12* = 0x1103 + WAVE_FORMAT_LH_CODEC_SBC16* = 0x1104 + WAVE_FORMAT_NORRIS* = 0x1400 + WAVE_FORMAT_ISIAUDIO_2* = 0x1401 + WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS* = 0x1500 + WAVE_FORMAT_MPEG_ADTS_AAC* = 0x1600 + WAVE_FORMAT_MPEG_RAW_AAC* = 0x1601 + WAVE_FORMAT_MPEG_LOAS* = 0x1602 + WAVE_FORMAT_NOKIA_MPEG_ADTS_AAC* = 0x1608 + WAVE_FORMAT_NOKIA_MPEG_RAW_AAC* = 0x1609 + WAVE_FORMAT_VODAFONE_MPEG_ADTS_AAC* = 0x160a + WAVE_FORMAT_VODAFONE_MPEG_RAW_AAC* = 0x160b + WAVE_FORMAT_MPEG_HEAAC* = 0x1610 + WAVE_FORMAT_VOXWARE_RT24_SPEECH* = 0x181c + WAVE_FORMAT_SONICFOUNDRY_LOSSLESS* = 0x1971 + WAVE_FORMAT_INNINGS_TELECOM_ADPCM* = 0x1979 + WAVE_FORMAT_LUCENT_SX8300P* = 0x1c07 + WAVE_FORMAT_LUCENT_SX5363S* = 0x1c0c + WAVE_FORMAT_CUSEEME* = 0x1f03 + WAVE_FORMAT_NTCSOFT_ALF2CM_ACM* = 0x1fc4 + WAVE_FORMAT_DVM* = 0x2000 + WAVE_FORMAT_DTS2* = 0x2001 + WAVE_FORMAT_MAKEAVIS* = 0x3313 + WAVE_FORMAT_DIVIO_MPEG4_AAC* = 0x4143 + WAVE_FORMAT_NOKIA_ADAPTIVE_MULTIRATE* = 0x4201 + WAVE_FORMAT_DIVIO_G726* = 0x4243 + WAVE_FORMAT_LEAD_SPEECH* = 0x434c + WAVE_FORMAT_LEAD_VORBIS* = 0x564c + WAVE_FORMAT_WAVPACK_AUDIO* = 0x5756 + WAVE_FORMAT_OGG_VORBIS_MODE_1* = 0x674f + WAVE_FORMAT_OGG_VORBIS_MODE_2* = 0x6750 + WAVE_FORMAT_OGG_VORBIS_MODE_3* = 0x6751 + WAVE_FORMAT_OGG_VORBIS_MODE_1_PLUS* = 0x676f + WAVE_FORMAT_OGG_VORBIS_MODE_2_PLUS* = 0x6770 + WAVE_FORMAT_OGG_VORBIS_MODE_3_PLUS* = 0x6771 + WAVE_FORMAT_3COM_NBX* = 0x7000 + WAVE_FORMAT_FAAD_AAC* = 0x706d + WAVE_FORMAT_GSM_AMR_CBR* = 0x7a21 + WAVE_FORMAT_GSM_AMR_VBR_SID* = 0x7a22 + WAVE_FORMAT_COMVERSE_INFOSYS_G723_1* = 0xa100 + WAVE_FORMAT_COMVERSE_INFOSYS_AVQSBC* = 0xa101 + WAVE_FORMAT_COMVERSE_INFOSYS_SBC* = 0xa102 + WAVE_FORMAT_SYMBOL_G729_A* = 0xa103 + WAVE_FORMAT_VOICEAGE_AMR_WB* = 0xa104 + WAVE_FORMAT_INGENIENT_G726* = 0xa105 + WAVE_FORMAT_MPEG4_AAC* = 0xa106 + WAVE_FORMAT_ENCORE_G726* = 0xa107 + WAVE_FORMAT_ZOLL_ASAO* = 0xa108 + WAVE_FORMAT_SPEEX_VOICE* = 0xa109 + WAVE_FORMAT_VIANIX_MASC* = 0xa10a + WAVE_FORMAT_WM9_SPECTRUM_ANALYZER* = 0xa10b + WAVE_FORMAT_WMF_SPECTRUM_ANAYZER* = 0xa10c + WAVE_FORMAT_GSM_610* = 0xa10d + WAVE_FORMAT_GSM_620* = 0xa10e + WAVE_FORMAT_GSM_660* = 0xa10f + WAVE_FORMAT_GSM_690* = 0xa110 + WAVE_FORMAT_GSM_ADAPTIVE_MULTIRATE_WB* = 0xa111 + WAVE_FORMAT_POLYCOM_G722* = 0xa112 + WAVE_FORMAT_POLYCOM_G728* = 0xa113 + WAVE_FORMAT_POLYCOM_G729_A* = 0xa114 + WAVE_FORMAT_POLYCOM_SIREN* = 0xa115 + WAVE_FORMAT_GLOBAL_IP_ILBC* = 0xa116 + WAVE_FORMAT_RADIOTIME_TIME_SHIFT_RADIO* = 0xa117 + WAVE_FORMAT_NICE_ACA* = 0xa118 + WAVE_FORMAT_NICE_ADPCM* = 0xa119 + WAVE_FORMAT_VOCORD_G721* = 0xa11a + WAVE_FORMAT_VOCORD_G726* = 0xa11b + WAVE_FORMAT_VOCORD_G722_1* = 0xa11c + WAVE_FORMAT_VOCORD_G728* = 0xa11d + WAVE_FORMAT_VOCORD_G729* = 0xa11e + WAVE_FORMAT_VOCORD_G729_A* = 0xa11f + WAVE_FORMAT_VOCORD_G723_1* = 0xa120 + WAVE_FORMAT_VOCORD_LBC* = 0xa121 + WAVE_FORMAT_NICE_G728* = 0xa122 + WAVE_FORMAT_FRACE_TELECOM_G729* = 0xa123 + WAVE_FORMAT_CODIAN* = 0xa124 + WAVE_FORMAT_FLAC* = 0xf1ac + WAVE_FORMAT_EXTENSIBLE* = 0xfffe + WAVE_FORMAT_DEVELOPMENT* = 0xffff + STATIC_KSDATAFORMAT_SUBTYPE_PCM* = DEFINE_GUID("00000001-0000-0010-8000-00aa00389b71") + KSDATAFORMAT_SUBTYPE_PCM* = DEFINE_GUID("00000001-0000-0010-8000-00aa00389b71") + STATIC_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT* = DEFINE_GUID("00000003-0000-0010-8000-00aa00389b71") + KSDATAFORMAT_SUBTYPE_IEEE_FLOAT* = DEFINE_GUID("00000003-0000-0010-8000-00aa00389b71") + STATIC_KSDATAFORMAT_SUBTYPE_WAVEFORMATEX* = 0x00000000 + KSDATAFORMAT_SUBTYPE_WAVEFORMATEX* = DEFINE_GUID("00000000-0000-0010-8000-00aa00389b71") + SPEAKER_FRONT_LEFT* = 0x1 + SPEAKER_FRONT_RIGHT* = 0x2 + SPEAKER_FRONT_CENTER* = 0x4 + SPEAKER_LOW_FREQUENCY* = 0x8 + SPEAKER_BACK_LEFT* = 0x10 + SPEAKER_BACK_RIGHT* = 0x20 + SPEAKER_FRONT_LEFT_OF_CENTER* = 0x40 + SPEAKER_FRONT_RIGHT_OF_CENTER* = 0x80 + SPEAKER_BACK_CENTER* = 0x100 + SPEAKER_SIDE_LEFT* = 0x200 + SPEAKER_SIDE_RIGHT* = 0x400 + SPEAKER_TOP_CENTER* = 0x800 + SPEAKER_TOP_FRONT_LEFT* = 0x1000 + SPEAKER_TOP_FRONT_CENTER* = 0x2000 + SPEAKER_TOP_FRONT_RIGHT* = 0x4000 + SPEAKER_TOP_BACK_LEFT* = 0x8000 + SPEAKER_TOP_BACK_CENTER* = 0x10000 + SPEAKER_TOP_BACK_RIGHT* = 0x20000 + SPEAKER_RESERVED* = 0x7ffc0000 + SPEAKER_ALL* = 0x80000000'i32 + ACM_MPEG_LAYER1* = 0x0001 + ACM_MPEG_LAYER2* = 0x0002 + ACM_MPEG_LAYER3* = 0x0004 + ACM_MPEG_STEREO* = 0x0001 + ACM_MPEG_JOINTSTEREO* = 0x0002 + ACM_MPEG_DUALCHANNEL* = 0x0004 + ACM_MPEG_SINGLECHANNEL* = 0x0008 + ACM_MPEG_PRIVATEBIT* = 0x0001 + ACM_MPEG_COPYRIGHT* = 0x0002 + ACM_MPEG_ORIGINALHOME* = 0x0004 + ACM_MPEG_PROTECTIONBIT* = 0x0008 + ACM_MPEG_ID_MPEG1* = 0x0010 + MPEGLAYER3_WFX_EXTRA_BYTES* = 12 + MPEGLAYER3_ID_UNKNOWN* = 0 + MPEGLAYER3_ID_MPEG* = 1 + MPEGLAYER3_ID_CONSTANTFRAMESIZE* = 2 + MPEGLAYER3_FLAG_PADDING_ISO* = 0x00000000 + MPEGLAYER3_FLAG_PADDING_ON* = 0x00000001 + MPEGLAYER3_FLAG_PADDING_OFF* = 0x00000002 + MM_MSFT_ACM_WMAUDIO* = 39 + MM_MSFT_ACM_MSAUDIO1* = 39 + WMAUDIO_BITS_PER_SAMPLE* = 16 + WMAUDIO_MAX_CHANNELS* = 2 + MSAUDIO1_BITS_PER_SAMPLE* = WMAUDIO_BITS_PER_SAMPLE + MSAUDIO1_MAX_CHANNELS* = WMAUDIO_MAX_CHANNELS + MM_MSFT_ACM_WMAUDIO2* = 101 + WMAUDIO2_BITS_PER_SAMPLE* = WMAUDIO_BITS_PER_SAMPLE + WMAUDIO2_MAX_CHANNELS* = WMAUDIO_MAX_CHANNELS + WAVE_FILTER_UNKNOWN* = 0x0000 + WAVE_FILTER_DEVELOPMENT* = 0xffff + WAVE_FILTER_VOLUME* = 0x0001 + WAVE_FILTER_ECHO* = 0x0002 + RIFFWAVE_inst* = mmioFOURCC('i', 'n', 's', 't') + RIFFCPPO* = mmioFOURCC('C', 'P', 'P', 'O') + RIFFCPPO_objr* = mmioFOURCC('o', 'b', 'j', 'r') + RIFFCPPO_obji* = mmioFOURCC('o', 'b', 'j', 'i') + RIFFCPPO_clsr* = mmioFOURCC('c', 'l', 's', 'r') + RIFFCPPO_clsi* = mmioFOURCC('c', 'l', 's', 'i') + RIFFCPPO_mbr* = mmioFOURCC('m', 'b', 'r', ' ') + RIFFCPPO_char* = mmioFOURCC('c', 'h', 'a', 'r') + RIFFCPPO_byte* = mmioFOURCC('b', 'y', 't', 'e') + RIFFCPPO_int* = mmioFOURCC('i', 'n', 't', ' ') + RIFFCPPO_word* = mmioFOURCC('w', 'o', 'r', 'd') + RIFFCPPO_long* = mmioFOURCC('l', 'o', 'n', 'g') + RIFFCPPO_dwrd* = mmioFOURCC('d', 'w', 'r', 'd') + RIFFCPPO_flt* = mmioFOURCC('f', 'l', 't', ' ') + RIFFCPPO_dbl* = mmioFOURCC('d', 'b', 'l', ' ') + RIFFCPPO_str* = mmioFOURCC('s', 't', 'r', ' ') + BICOMP_IBMULTIMOTION* = mmioFOURCC('U', 'L', 'T', 'I') + BICOMP_IBMPHOTOMOTION* = mmioFOURCC('P', 'H', 'M', 'O') + BICOMP_CREATIVEYUV* = mmioFOURCC('c', 'y', 'u', 'v') + JPEG_DIB* = mmioFOURCC('J', 'P', 'E', 'G') + MJPG_DIB* = mmioFOURCC('M', 'J', 'P', 'G') + JPEG_PROCESS_BASELINE* = 0 + AVIIF_CONTROLFRAME* = 0x00000200 + JIFMK_SOF0* = 0xffc0 + JIFMK_SOF1* = 0xffc1 + JIFMK_SOF2* = 0xffc2 + JIFMK_SOF3* = 0xffc3 + JIFMK_SOF5* = 0xffc5 + JIFMK_SOF6* = 0xffc6 + JIFMK_SOF7* = 0xffc7 + JIFMK_JPG* = 0xffc8 + JIFMK_SOF9* = 0xffc9 + JIFMK_SOF10* = 0xffca + JIFMK_SOF11* = 0xffcb + JIFMK_SOF13* = 0xffcd + JIFMK_SOF14* = 0xffce + JIFMK_SOF15* = 0xffcf + JIFMK_DHT* = 0xffc4 + JIFMK_DAC* = 0xffcc + JIFMK_RST0* = 0xffd0 + JIFMK_RST1* = 0xffd1 + JIFMK_RST2* = 0xffd2 + JIFMK_RST3* = 0xffd3 + JIFMK_RST4* = 0xffd4 + JIFMK_RST5* = 0xffd5 + JIFMK_RST6* = 0xffd6 + JIFMK_RST7* = 0xffd7 + JIFMK_SOI* = 0xffd8 + JIFMK_EOI* = 0xffd9 + JIFMK_SOS* = 0xffda + JIFMK_DQT* = 0xffdb + JIFMK_DNL* = 0xffdc + JIFMK_DRI* = 0xffdd + JIFMK_DHP* = 0xffde + JIFMK_EXP* = 0xffdf + JIFMK_APP0* = 0xffe0 + JIFMK_APP1* = 0xffe1 + JIFMK_APP2* = 0xffe2 + JIFMK_APP3* = 0xffe3 + JIFMK_APP4* = 0xffe4 + JIFMK_APP5* = 0xffe5 + JIFMK_APP6* = 0xffe6 + JIFMK_APP7* = 0xffe7 + JIFMK_JPG0* = 0xfff0 + JIFMK_JPG1* = 0xfff1 + JIFMK_JPG2* = 0xfff2 + JIFMK_JPG3* = 0xfff3 + JIFMK_JPG4* = 0xfff4 + JIFMK_JPG5* = 0xfff5 + JIFMK_JPG6* = 0xfff6 + JIFMK_JPG7* = 0xfff7 + JIFMK_JPG8* = 0xfff8 + JIFMK_JPG9* = 0xfff9 + JIFMK_JPG10* = 0xfffa + JIFMK_JPG11* = 0xfffb + JIFMK_JPG12* = 0xfffc + JIFMK_JPG13* = 0xfffd + JIFMK_COM* = 0xfffe + JIFMK_TEM* = 0xff01 + JIFMK_RES* = 0xff02 + JIFMK_00* = 0xff00 + JIFMK_FF* = 0xffff + JPEG_Y* = 1 + JPEG_YCbCr* = 2 + JPEG_RGB* = 3 + ICTYPE_VIDEO* = mmioFOURCC('v', 'i', 'd', 'c') + ICTYPE_AUDIO* = mmioFOURCC('a', 'u', 'd', 'c') + FOURCC_RDSP* = mmioFOURCC('R', 'D', 'S', 'P') + MIXERCONTROL_CONTROLTYPE_SRS_MTS* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+6 + MIXERCONTROL_CONTROLTYPE_SRS_ONOFF* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+7 + MIXERCONTROL_CONTROLTYPE_SRS_SYNTHSELECT* = MIXERCONTROL_CONTROLTYPE_BOOLEAN+8 + SND_ALIAS_SYSTEMASTERISK* = 0x00002A53 + SND_ALIAS_SYSTEMQUESTION* = 0x00003F53 + SND_ALIAS_SYSTEMHAND* = 0x00004853 + SND_ALIAS_SYSTEMEXIT* = 0x00004553 + SND_ALIAS_SYSTEMSTART* = 0x00005353 + SND_ALIAS_SYSTEMWELCOME* = 0x00005753 + SND_ALIAS_SYSTEMEXCLAMATION* = 0x00002153 + SND_ALIAS_SYSTEMDEFAULT* = 0x00004453 + FOURCC_RIFF* = 0x46464952 + FOURCC_LIST* = 0x5453494C + FOURCC_DOS* = 0x20534F44 + FOURCC_MEM* = 0x204D454D + JOY_POVCENTERED* = not WORD(0) +type + DRIVERPROC* = proc (P1: DWORD_PTR, P2: HDRVR, P3: UINT, P4: LPARAM, P5: LPARAM): LRESULT {.stdcall.} + YIELDPROC* = proc (mciId: MCIDEVICEID, dwYieldData: DWORD): UINT {.stdcall.} + MIDIEVENT* {.pure.} = object + dwDeltaTime*: DWORD + dwStreamID*: DWORD + dwEvent*: DWORD + dwParms*: array[1, DWORD] + MIDISTRMBUFFVER* {.pure.} = object + dwVersion*: DWORD + dwMid*: DWORD + dwOEMVersion*: DWORD + DOLBYAC2WAVEFORMAT* {.pure, packed.} = object + wfx*: WAVEFORMATEX + nAuxBitsCode*: WORD + s_RIFFWAVE_inst* {.pure.} = object + bUnshiftedNote*: BYTE + chFineTune*: char + chGain*: char + bLowNote*: BYTE + bHighNote*: BYTE + bLowVelocity*: BYTE + bHighVelocity*: BYTE + EXBMINFOHEADER* {.pure.} = object + bmi*: BITMAPINFOHEADER + biExtDataOffset*: DWORD + JPEGINFOHEADER* {.pure.} = object + JPEGSize*: DWORD + JPEGProcess*: DWORD + JPEGColorSpaceID*: DWORD + JPEGBitsPerSample*: DWORD + JPEGHSubSampling*: DWORD + JPEGVSubSampling*: DWORD +proc CloseDriver*(hDriver: HDRVR, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc OpenDriver*(szDriverName: LPCWSTR, szSectionName: LPCWSTR, lParam2: LPARAM): HDRVR {.winapi, stdcall, dynlib: "winmm", importc.} +proc SendDriverMessage*(hDriver: HDRVR, message: UINT, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc DrvGetModuleHandle*(hDriver: HDRVR): HMODULE {.winapi, stdcall, dynlib: "winmm", importc.} +proc GetDriverModuleHandle*(hDriver: HDRVR): HMODULE {.winapi, stdcall, dynlib: "winmm", importc.} +proc DefDriverProc*(dwDriverIdentifier: DWORD_PTR, hdrvr: HDRVR, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc sndPlaySoundA*(pszSound: LPCSTR, fuSound: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc sndPlaySoundW*(pszSound: LPCWSTR, fuSound: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc PlaySoundA*(pszSound: LPCSTR, hmod: HMODULE, fdwSound: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc PlaySoundW*(pszSound: LPCWSTR, hmod: HMODULE, fdwSound: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetDevCapsA*(uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSA, cbwoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetDevCapsW*(uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSW, cbwoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetVolume*(hwo: HWAVEOUT, pdwVolume: LPDWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutSetVolume*(hwo: HWAVEOUT, dwVolume: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetErrorTextA*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetErrorTextW*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutOpen*(phwo: LPHWAVEOUT, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutClose*(hwo: HWAVEOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutPrepareHeader*(hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutUnprepareHeader*(hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutWrite*(hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutPause*(hwo: HWAVEOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutRestart*(hwo: HWAVEOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutReset*(hwo: HWAVEOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutBreakLoop*(hwo: HWAVEOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetPosition*(hwo: HWAVEOUT, pmmt: LPMMTIME, cbmmt: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetPitch*(hwo: HWAVEOUT, pdwPitch: LPDWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutSetPitch*(hwo: HWAVEOUT, dwPitch: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetPlaybackRate*(hwo: HWAVEOUT, pdwRate: LPDWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutSetPlaybackRate*(hwo: HWAVEOUT, dwRate: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutGetID*(hwo: HWAVEOUT, puDeviceID: LPUINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveOutMessage*(hwo: HWAVEOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetDevCapsA*(uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSA, cbwic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetDevCapsW*(uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSW, cbwic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetErrorTextA*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetErrorTextW*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInOpen*(phwi: LPHWAVEIN, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInClose*(hwi: HWAVEIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInPrepareHeader*(hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInUnprepareHeader*(hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInAddBuffer*(hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInStart*(hwi: HWAVEIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInStop*(hwi: HWAVEIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInReset*(hwi: HWAVEIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetPosition*(hwi: HWAVEIN, pmmt: LPMMTIME, cbmmt: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInGetID*(hwi: HWAVEIN, puDeviceID: LPUINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc waveInMessage*(hwi: HWAVEIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamOpen*(phms: LPHMIDISTRM, puDeviceID: LPUINT, cMidi: DWORD, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamClose*(hms: HMIDISTRM): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamProperty*(hms: HMIDISTRM, lppropdata: LPBYTE, dwProperty: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamPosition*(hms: HMIDISTRM, lpmmt: LPMMTIME, cbmmt: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamOut*(hms: HMIDISTRM, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamPause*(hms: HMIDISTRM): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamRestart*(hms: HMIDISTRM): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiStreamStop*(hms: HMIDISTRM): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiConnect*(hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiDisconnect*(hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetDevCapsA*(uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSA, cbmoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetDevCapsW*(uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSW, cbmoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetVolume*(hmo: HMIDIOUT, pdwVolume: LPDWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutSetVolume*(hmo: HMIDIOUT, dwVolume: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetErrorTextA*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetErrorTextW*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutOpen*(phmo: LPHMIDIOUT, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutClose*(hmo: HMIDIOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutPrepareHeader*(hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutUnprepareHeader*(hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutShortMsg*(hmo: HMIDIOUT, dwMsg: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutLongMsg*(hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutReset*(hmo: HMIDIOUT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutCachePatches*(hmo: HMIDIOUT, uBank: UINT, pwpa: LPWORD, fuCache: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutCacheDrumPatches*(hmo: HMIDIOUT, uPatch: UINT, pwkya: LPWORD, fuCache: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutGetID*(hmo: HMIDIOUT, puDeviceID: LPUINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiOutMessage*(hmo: HMIDIOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetDevCapsA*(uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSA, cbmic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetDevCapsW*(uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSW, cbmic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetErrorTextA*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetErrorTextW*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInOpen*(phmi: LPHMIDIIN, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInClose*(hmi: HMIDIIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInPrepareHeader*(hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInUnprepareHeader*(hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInAddBuffer*(hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInStart*(hmi: HMIDIIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInStop*(hmi: HMIDIIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInReset*(hmi: HMIDIIN): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInGetID*(hmi: HMIDIIN, puDeviceID: LPUINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc midiInMessage*(hmi: HMIDIIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxGetDevCapsA*(uDeviceID: UINT_PTR, pac: LPAUXCAPSA, cbac: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxGetDevCapsW*(uDeviceID: UINT_PTR, pac: LPAUXCAPSW, cbac: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxSetVolume*(uDeviceID: UINT, dwVolume: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxGetVolume*(uDeviceID: UINT, pdwVolume: LPDWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc auxOutMessage*(uDeviceID: UINT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetDevCapsA*(uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSA, cbmxcaps: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetDevCapsW*(uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSW, cbmxcaps: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerOpen*(phmx: LPHMIXER, uMxId: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerClose*(hmx: HMIXER): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerMessage*(hmx: HMIXER, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetLineInfoA*(hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEA, fdwInfo: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetLineInfoW*(hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEW, fdwInfo: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetID*(hmxobj: HMIXEROBJ, puMxId: ptr UINT, fdwId: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetLineControlsA*(hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSA, fdwControls: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetLineControlsW*(hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSW, fdwControls: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetControlDetailsA*(hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerGetControlDetailsW*(hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mixerSetControlDetails*(hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeGetSystemTime*(pmmt: LPMMTIME, cbmmt: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeGetTime*(): DWORD {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeSetEvent*(uDelay: UINT, uResolution: UINT, fptc: LPTIMECALLBACK, dwUser: DWORD_PTR, fuEvent: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeKillEvent*(uTimerID: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeGetDevCaps*(ptc: LPTIMECAPS, cbtc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeBeginPeriod*(uPeriod: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc timeEndPeriod*(uPeriod: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetNumDevs*(): UINT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetDevCapsA*(uJoyID: UINT_PTR, pjc: LPJOYCAPSA, cbjc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetDevCapsW*(uJoyID: UINT_PTR, pjc: LPJOYCAPSW, cbjc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetPos*(uJoyID: UINT, pji: LPJOYINFO): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetPosEx*(uJoyID: UINT, pji: LPJOYINFOEX): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyGetThreshold*(uJoyID: UINT, puThreshold: LPUINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joyReleaseCapture*(uJoyID: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joySetCapture*(hwnd: HWND, uJoyID: UINT, uPeriod: UINT, fChanged: WINBOOL): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc joySetThreshold*(uJoyID: UINT, uThreshold: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioStringToFOURCCA*(sz: LPCSTR, uFlags: UINT): FOURCC {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioStringToFOURCCW*(sz: LPCWSTR, uFlags: UINT): FOURCC {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioInstallIOProcA*(fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD): LPMMIOPROC {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioInstallIOProcW*(fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD): LPMMIOPROC {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioOpenA*(pszFileName: LPSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD): HMMIO {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioOpenW*(pszFileName: LPWSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD): HMMIO {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioRenameA*(pszFileName: LPCSTR, pszNewFileName: LPCSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioRenameW*(pszFileName: LPCWSTR, pszNewFileName: LPCWSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioClose*(hmmio: HMMIO, fuClose: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioRead*(hmmio: HMMIO, pch: HPSTR, cch: LONG): LONG {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioWrite*(hmmio: HMMIO, pch: ptr char, cch: LONG): LONG {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioSeek*(hmmio: HMMIO, lOffset: LONG, iOrigin: int32): LONG {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioGetInfo*(hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuInfo: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioSetInfo*(hmmio: HMMIO, pmmioinfo: LPCMMIOINFO, fuInfo: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioSetBuffer*(hmmio: HMMIO, pchBuffer: LPSTR, cchBuffer: LONG, fuBuffer: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioFlush*(hmmio: HMMIO, fuFlush: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioAdvance*(hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuAdvance: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioSendMessage*(hmmio: HMMIO, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioDescend*(hmmio: HMMIO, pmmcki: LPMMCKINFO, pmmckiParent: ptr MMCKINFO, fuDescend: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioAscend*(hmmio: HMMIO, pmmcki: LPMMCKINFO, fuAscend: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mmioCreateChunk*(hmmio: HMMIO, pmmcki: LPMMCKINFO, fuCreate: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciSendCommandA*(mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciSendCommandW*(mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciSendStringA*(lpstrCommand: LPCSTR, lpstrReturnString: LPSTR, uReturnLength: UINT, hwndCallback: HWND): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciSendStringW*(lpstrCommand: LPCWSTR, lpstrReturnString: LPWSTR, uReturnLength: UINT, hwndCallback: HWND): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetDeviceIDA*(pszDevice: LPCSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetDeviceIDW*(pszDevice: LPCWSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetDeviceIDFromElementIDA*(dwElementID: DWORD, lpstrType: LPCSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetDeviceIDFromElementIDW*(dwElementID: DWORD, lpstrType: LPCWSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetErrorStringA*(mcierr: MCIERROR, pszText: LPSTR, cchText: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetErrorStringW*(mcierr: MCIERROR, pszText: LPWSTR, cchText: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciSetYieldProc*(mciId: MCIDEVICEID, fpYieldProc: YIELDPROC, dwYieldData: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetCreatorTask*(mciId: MCIDEVICEID): HTASK {.winapi, stdcall, dynlib: "winmm", importc.} +proc mciGetYieldProc*(mciId: MCIDEVICEID, pdwYieldData: LPDWORD): YIELDPROC {.winapi, stdcall, dynlib: "winmm", importc.} +proc `lMinimum=`*(self: var MIXERCONTROLA, x: LONG) {.inline.} = self.Bounds.struct1.lMinimum = x +proc lMinimum*(self: MIXERCONTROLA): LONG {.inline.} = self.Bounds.struct1.lMinimum +proc lMinimum*(self: var MIXERCONTROLA): var LONG {.inline.} = self.Bounds.struct1.lMinimum +proc `lMaximum=`*(self: var MIXERCONTROLA, x: LONG) {.inline.} = self.Bounds.struct1.lMaximum = x +proc lMaximum*(self: MIXERCONTROLA): LONG {.inline.} = self.Bounds.struct1.lMaximum +proc lMaximum*(self: var MIXERCONTROLA): var LONG {.inline.} = self.Bounds.struct1.lMaximum +proc `dwMinimum=`*(self: var MIXERCONTROLA, x: DWORD) {.inline.} = self.Bounds.struct2.dwMinimum = x +proc dwMinimum*(self: MIXERCONTROLA): DWORD {.inline.} = self.Bounds.struct2.dwMinimum +proc dwMinimum*(self: var MIXERCONTROLA): var DWORD {.inline.} = self.Bounds.struct2.dwMinimum +proc `dwMaximum=`*(self: var MIXERCONTROLA, x: DWORD) {.inline.} = self.Bounds.struct2.dwMaximum = x +proc dwMaximum*(self: MIXERCONTROLA): DWORD {.inline.} = self.Bounds.struct2.dwMaximum +proc dwMaximum*(self: var MIXERCONTROLA): var DWORD {.inline.} = self.Bounds.struct2.dwMaximum +proc `lMinimum=`*(self: var MIXERCONTROLW, x: LONG) {.inline.} = self.Bounds.struct1.lMinimum = x +proc lMinimum*(self: MIXERCONTROLW): LONG {.inline.} = self.Bounds.struct1.lMinimum +proc lMinimum*(self: var MIXERCONTROLW): var LONG {.inline.} = self.Bounds.struct1.lMinimum +proc `lMaximum=`*(self: var MIXERCONTROLW, x: LONG) {.inline.} = self.Bounds.struct1.lMaximum = x +proc lMaximum*(self: MIXERCONTROLW): LONG {.inline.} = self.Bounds.struct1.lMaximum +proc lMaximum*(self: var MIXERCONTROLW): var LONG {.inline.} = self.Bounds.struct1.lMaximum +proc `dwMinimum=`*(self: var MIXERCONTROLW, x: DWORD) {.inline.} = self.Bounds.struct2.dwMinimum = x +proc dwMinimum*(self: MIXERCONTROLW): DWORD {.inline.} = self.Bounds.struct2.dwMinimum +proc dwMinimum*(self: var MIXERCONTROLW): var DWORD {.inline.} = self.Bounds.struct2.dwMinimum +proc `dwMaximum=`*(self: var MIXERCONTROLW, x: DWORD) {.inline.} = self.Bounds.struct2.dwMaximum = x +proc dwMaximum*(self: MIXERCONTROLW): DWORD {.inline.} = self.Bounds.struct2.dwMaximum +proc dwMaximum*(self: var MIXERCONTROLW): var DWORD {.inline.} = self.Bounds.struct2.dwMaximum +proc `dwControlID=`*(self: var MIXERLINECONTROLSA, x: DWORD) {.inline.} = self.union1.dwControlID = x +proc dwControlID*(self: MIXERLINECONTROLSA): DWORD {.inline.} = self.union1.dwControlID +proc dwControlID*(self: var MIXERLINECONTROLSA): var DWORD {.inline.} = self.union1.dwControlID +proc `dwControlType=`*(self: var MIXERLINECONTROLSA, x: DWORD) {.inline.} = self.union1.dwControlType = x +proc dwControlType*(self: MIXERLINECONTROLSA): DWORD {.inline.} = self.union1.dwControlType +proc dwControlType*(self: var MIXERLINECONTROLSA): var DWORD {.inline.} = self.union1.dwControlType +proc `dwControlID=`*(self: var MIXERLINECONTROLSW, x: DWORD) {.inline.} = self.union1.dwControlID = x +proc dwControlID*(self: MIXERLINECONTROLSW): DWORD {.inline.} = self.union1.dwControlID +proc dwControlID*(self: var MIXERLINECONTROLSW): var DWORD {.inline.} = self.union1.dwControlID +proc `dwControlType=`*(self: var MIXERLINECONTROLSW, x: DWORD) {.inline.} = self.union1.dwControlType = x +proc dwControlType*(self: MIXERLINECONTROLSW): DWORD {.inline.} = self.union1.dwControlType +proc dwControlType*(self: var MIXERLINECONTROLSW): var DWORD {.inline.} = self.union1.dwControlType +proc `hwndOwner=`*(self: var MIXERCONTROLDETAILS, x: HWND) {.inline.} = self.union1.hwndOwner = x +proc hwndOwner*(self: MIXERCONTROLDETAILS): HWND {.inline.} = self.union1.hwndOwner +proc hwndOwner*(self: var MIXERCONTROLDETAILS): var HWND {.inline.} = self.union1.hwndOwner +proc `cMultipleItems=`*(self: var MIXERCONTROLDETAILS, x: DWORD) {.inline.} = self.union1.cMultipleItems = x +proc cMultipleItems*(self: MIXERCONTROLDETAILS): DWORD {.inline.} = self.union1.cMultipleItems +proc cMultipleItems*(self: var MIXERCONTROLDETAILS): var DWORD {.inline.} = self.union1.cMultipleItems +when winimUnicode: + type + WAVEOUTCAPS* = WAVEOUTCAPSW + PWAVEOUTCAPS* = PWAVEOUTCAPSW + NPWAVEOUTCAPS* = NPWAVEOUTCAPSW + LPWAVEOUTCAPS* = LPWAVEOUTCAPSW + WAVEOUTCAPS2* = WAVEOUTCAPS2W + PWAVEOUTCAPS2* = PWAVEOUTCAPS2W + NPWAVEOUTCAPS2* = NPWAVEOUTCAPS2W + LPWAVEOUTCAPS2* = LPWAVEOUTCAPS2W + WAVEINCAPS* = WAVEINCAPSW + PWAVEINCAPS* = PWAVEINCAPSW + NPWAVEINCAPS* = NPWAVEINCAPSW + LPWAVEINCAPS* = LPWAVEINCAPSW + WAVEINCAPS2* = WAVEINCAPS2W + PWAVEINCAPS2* = PWAVEINCAPS2W + NPWAVEINCAPS2* = NPWAVEINCAPS2W + LPWAVEINCAPS2* = LPWAVEINCAPS2W + MIDIOUTCAPS* = MIDIOUTCAPSW + PMIDIOUTCAPS* = PMIDIOUTCAPSW + NPMIDIOUTCAPS* = NPMIDIOUTCAPSW + LPMIDIOUTCAPS* = LPMIDIOUTCAPSW + MIDIOUTCAPS2* = MIDIOUTCAPS2W + PMIDIOUTCAPS2* = PMIDIOUTCAPS2W + NPMIDIOUTCAPS2* = NPMIDIOUTCAPS2W + LPMIDIOUTCAPS2* = LPMIDIOUTCAPS2W + MIDIINCAPS* = MIDIINCAPSW + PMIDIINCAPS* = PMIDIINCAPSW + NPMIDIINCAPS* = NPMIDIINCAPSW + LPMIDIINCAPS* = LPMIDIINCAPSW + MIDIINCAPS2* = MIDIINCAPS2W + PMIDIINCAPS2* = PMIDIINCAPS2W + NPMIDIINCAPS2* = NPMIDIINCAPS2W + LPMIDIINCAPS2* = LPMIDIINCAPS2W + AUXCAPS* = AUXCAPSW + PAUXCAPS* = PAUXCAPSW + NPAUXCAPS* = NPAUXCAPSW + LPAUXCAPS* = LPAUXCAPSW + AUXCAPS2* = AUXCAPS2W + PAUXCAPS2* = PAUXCAPS2W + NPAUXCAPS2* = NPAUXCAPS2W + LPAUXCAPS2* = LPAUXCAPS2W + MIXERCAPS* = MIXERCAPSW + PMIXERCAPS* = PMIXERCAPSW + LPMIXERCAPS* = LPMIXERCAPSW + MIXERCAPS2* = MIXERCAPS2W + PMIXERCAPS2* = PMIXERCAPS2W + LPMIXERCAPS2* = LPMIXERCAPS2W + MIXERLINE* = MIXERLINEW + PMIXERLINE* = PMIXERLINEW + LPMIXERLINE* = LPMIXERLINEW + MIXERCONTROL* = MIXERCONTROLW + PMIXERCONTROL* = PMIXERCONTROLW + LPMIXERCONTROL* = LPMIXERCONTROLW + MIXERLINECONTROLS* = MIXERLINECONTROLSW + PMIXERLINECONTROLS* = PMIXERLINECONTROLSW + LPMIXERLINECONTROLS* = LPMIXERLINECONTROLSW + MIXERCONTROLDETAILS_LISTTEXT* = MIXERCONTROLDETAILS_LISTTEXTW + PMIXERCONTROLDETAILS_LISTTEXT* = PMIXERCONTROLDETAILS_LISTTEXTW + LPMIXERCONTROLDETAILS_LISTTEXT* = LPMIXERCONTROLDETAILS_LISTTEXTW + JOYCAPS* = JOYCAPSW + PJOYCAPS* = PJOYCAPSW + NPJOYCAPS* = NPJOYCAPSW + LPJOYCAPS* = LPJOYCAPSW + JOYCAPS2* = JOYCAPS2W + PJOYCAPS2* = PJOYCAPS2W + NPJOYCAPS2* = NPJOYCAPS2W + LPJOYCAPS2* = LPJOYCAPS2W + MCI_OPEN_PARMS* = MCI_OPEN_PARMSW + PMCI_OPEN_PARMS* = PMCI_OPEN_PARMSW + LPMCI_OPEN_PARMS* = LPMCI_OPEN_PARMSW + MCI_INFO_PARMS* = MCI_INFO_PARMSW + LPMCI_INFO_PARMS* = LPMCI_INFO_PARMSW + MCI_SYSINFO_PARMS* = MCI_SYSINFO_PARMSW + PMCI_SYSINFO_PARMS* = PMCI_SYSINFO_PARMSW + LPMCI_SYSINFO_PARMS* = LPMCI_SYSINFO_PARMSW + MCI_SAVE_PARMS* = MCI_SAVE_PARMSW + PMCI_SAVE_PARMS* = PMCI_SAVE_PARMSW + LPMCI_SAVE_PARMS* = LPMCI_SAVE_PARMSW + MCI_LOAD_PARMS* = MCI_LOAD_PARMSW + PMCI_LOAD_PARMS* = PMCI_LOAD_PARMSW + LPMCI_LOAD_PARMS* = LPMCI_LOAD_PARMSW + MCI_VD_ESCAPE_PARMS* = MCI_VD_ESCAPE_PARMSW + PMCI_VD_ESCAPE_PARMS* = PMCI_VD_ESCAPE_PARMSW + LPMCI_VD_ESCAPE_PARMS* = LPMCI_VD_ESCAPE_PARMSW + MCI_WAVE_OPEN_PARMS* = MCI_WAVE_OPEN_PARMSW + PMCI_WAVE_OPEN_PARMS* = PMCI_WAVE_OPEN_PARMSW + LPMCI_WAVE_OPEN_PARMS* = LPMCI_WAVE_OPEN_PARMSW + MCI_ANIM_OPEN_PARMS* = MCI_ANIM_OPEN_PARMSW + PMCI_ANIM_OPEN_PARMS* = PMCI_ANIM_OPEN_PARMSW + LPMCI_ANIM_OPEN_PARMS* = LPMCI_ANIM_OPEN_PARMSW + MCI_ANIM_WINDOW_PARMS* = MCI_ANIM_WINDOW_PARMSW + PMCI_ANIM_WINDOW_PARMS* = PMCI_ANIM_WINDOW_PARMSW + LPMCI_ANIM_WINDOW_PARMS* = LPMCI_ANIM_WINDOW_PARMSW + MCI_OVLY_OPEN_PARMS* = MCI_OVLY_OPEN_PARMSW + PMCI_OVLY_OPEN_PARMS* = PMCI_OVLY_OPEN_PARMSW + LPMCI_OVLY_OPEN_PARMS* = LPMCI_OVLY_OPEN_PARMSW + MCI_OVLY_WINDOW_PARMS* = MCI_OVLY_WINDOW_PARMSW + PMCI_OVLY_WINDOW_PARMS* = PMCI_OVLY_WINDOW_PARMSW + LPMCI_OVLY_WINDOW_PARMS* = LPMCI_OVLY_WINDOW_PARMSW + MCI_OVLY_SAVE_PARMS* = MCI_OVLY_SAVE_PARMSW + PMCI_OVLY_SAVE_PARMS* = PMCI_OVLY_SAVE_PARMSW + LPMCI_OVLY_SAVE_PARMS* = LPMCI_OVLY_SAVE_PARMSW + MCI_OVLY_LOAD_PARMS* = MCI_OVLY_LOAD_PARMSW + PMCI_OVLY_LOAD_PARMS* = PMCI_OVLY_LOAD_PARMSW + LPMCI_OVLY_LOAD_PARMS* = LPMCI_OVLY_LOAD_PARMSW + proc sndPlaySound*(pszSound: LPCWSTR, fuSound: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "sndPlaySoundW".} + proc PlaySound*(pszSound: LPCWSTR, hmod: HMODULE, fdwSound: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "PlaySoundW".} + proc waveOutGetDevCaps*(uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSW, cbwoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveOutGetDevCapsW".} + proc waveOutGetErrorText*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveOutGetErrorTextW".} + proc waveInGetDevCaps*(uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSW, cbwic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveInGetDevCapsW".} + proc waveInGetErrorText*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveInGetErrorTextW".} + proc midiOutGetDevCaps*(uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSW, cbmoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiOutGetDevCapsW".} + proc midiOutGetErrorText*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiOutGetErrorTextW".} + proc midiInGetDevCaps*(uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSW, cbmic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiInGetDevCapsW".} + proc midiInGetErrorText*(mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiInGetErrorTextW".} + proc auxGetDevCaps*(uDeviceID: UINT_PTR, pac: LPAUXCAPSW, cbac: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "auxGetDevCapsW".} + proc mixerGetDevCaps*(uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSW, cbmxcaps: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetDevCapsW".} + proc mixerGetLineInfo*(hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEW, fdwInfo: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetLineInfoW".} + proc mixerGetLineControls*(hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSW, fdwControls: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetLineControlsW".} + proc mixerGetControlDetails*(hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetControlDetailsW".} + proc joyGetDevCaps*(uJoyID: UINT_PTR, pjc: LPJOYCAPSW, cbjc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "joyGetDevCapsW".} + proc mmioStringToFOURCC*(sz: LPCWSTR, uFlags: UINT): FOURCC {.winapi, stdcall, dynlib: "winmm", importc: "mmioStringToFOURCCW".} + proc mmioInstallIOProc*(fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD): LPMMIOPROC {.winapi, stdcall, dynlib: "winmm", importc: "mmioInstallIOProcW".} + proc mmioOpen*(pszFileName: LPWSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD): HMMIO {.winapi, stdcall, dynlib: "winmm", importc: "mmioOpenW".} + proc mmioRename*(pszFileName: LPCWSTR, pszNewFileName: LPCWSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mmioRenameW".} + proc mciSendCommand*(mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc: "mciSendCommandW".} + proc mciSendString*(lpstrCommand: LPCWSTR, lpstrReturnString: LPWSTR, uReturnLength: UINT, hwndCallback: HWND): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc: "mciSendStringW".} + proc mciGetDeviceID*(pszDevice: LPCWSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc: "mciGetDeviceIDW".} + proc mciGetDeviceIDFromElementID*(dwElementID: DWORD, lpstrType: LPCWSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc: "mciGetDeviceIDFromElementIDW".} + proc mciGetErrorString*(mcierr: MCIERROR, pszText: LPWSTR, cchText: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "mciGetErrorStringW".} +when winimAnsi: + type + WAVEOUTCAPS* = WAVEOUTCAPSA + PWAVEOUTCAPS* = PWAVEOUTCAPSA + NPWAVEOUTCAPS* = NPWAVEOUTCAPSA + LPWAVEOUTCAPS* = LPWAVEOUTCAPSA + WAVEOUTCAPS2* = WAVEOUTCAPS2A + PWAVEOUTCAPS2* = PWAVEOUTCAPS2A + NPWAVEOUTCAPS2* = NPWAVEOUTCAPS2A + LPWAVEOUTCAPS2* = LPWAVEOUTCAPS2A + WAVEINCAPS* = WAVEINCAPSA + PWAVEINCAPS* = PWAVEINCAPSA + NPWAVEINCAPS* = NPWAVEINCAPSA + LPWAVEINCAPS* = LPWAVEINCAPSA + WAVEINCAPS2* = WAVEINCAPS2A + PWAVEINCAPS2* = PWAVEINCAPS2A + NPWAVEINCAPS2* = NPWAVEINCAPS2A + LPWAVEINCAPS2* = LPWAVEINCAPS2A + MIDIOUTCAPS* = MIDIOUTCAPSA + PMIDIOUTCAPS* = PMIDIOUTCAPSA + NPMIDIOUTCAPS* = NPMIDIOUTCAPSA + LPMIDIOUTCAPS* = LPMIDIOUTCAPSA + MIDIOUTCAPS2* = MIDIOUTCAPS2A + PMIDIOUTCAPS2* = PMIDIOUTCAPS2A + NPMIDIOUTCAPS2* = NPMIDIOUTCAPS2A + LPMIDIOUTCAPS2* = LPMIDIOUTCAPS2A + MIDIINCAPS* = MIDIINCAPSA + PMIDIINCAPS* = PMIDIINCAPSA + NPMIDIINCAPS* = NPMIDIINCAPSA + LPMIDIINCAPS* = LPMIDIINCAPSA + MIDIINCAPS2* = MIDIINCAPS2A + PMIDIINCAPS2* = PMIDIINCAPS2A + NPMIDIINCAPS2* = NPMIDIINCAPS2A + LPMIDIINCAPS2* = LPMIDIINCAPS2A + AUXCAPS* = AUXCAPSA + PAUXCAPS* = PAUXCAPSA + NPAUXCAPS* = NPAUXCAPSA + LPAUXCAPS* = LPAUXCAPSA + AUXCAPS2* = AUXCAPS2A + PAUXCAPS2* = PAUXCAPS2A + NPAUXCAPS2* = NPAUXCAPS2A + LPAUXCAPS2* = LPAUXCAPS2A + MIXERCAPS* = MIXERCAPSA + PMIXERCAPS* = PMIXERCAPSA + LPMIXERCAPS* = LPMIXERCAPSA + MIXERCAPS2* = MIXERCAPS2A + PMIXERCAPS2* = PMIXERCAPS2A + LPMIXERCAPS2* = LPMIXERCAPS2A + MIXERLINE* = MIXERLINEA + PMIXERLINE* = PMIXERLINEA + LPMIXERLINE* = LPMIXERLINEA + MIXERCONTROL* = MIXERCONTROLA + PMIXERCONTROL* = PMIXERCONTROLA + LPMIXERCONTROL* = LPMIXERCONTROLA + MIXERLINECONTROLS* = MIXERLINECONTROLSA + PMIXERLINECONTROLS* = PMIXERLINECONTROLSA + LPMIXERLINECONTROLS* = LPMIXERLINECONTROLSA + MIXERCONTROLDETAILS_LISTTEXT* = MIXERCONTROLDETAILS_LISTTEXTA + PMIXERCONTROLDETAILS_LISTTEXT* = PMIXERCONTROLDETAILS_LISTTEXTA + LPMIXERCONTROLDETAILS_LISTTEXT* = LPMIXERCONTROLDETAILS_LISTTEXTA + JOYCAPS* = JOYCAPSA + PJOYCAPS* = PJOYCAPSA + NPJOYCAPS* = NPJOYCAPSA + LPJOYCAPS* = LPJOYCAPSA + JOYCAPS2* = JOYCAPS2A + PJOYCAPS2* = PJOYCAPS2A + NPJOYCAPS2* = NPJOYCAPS2A + LPJOYCAPS2* = LPJOYCAPS2A + MCI_OPEN_PARMS* = MCI_OPEN_PARMSA + PMCI_OPEN_PARMS* = PMCI_OPEN_PARMSA + LPMCI_OPEN_PARMS* = LPMCI_OPEN_PARMSA + MCI_INFO_PARMS* = MCI_INFO_PARMSA + LPMCI_INFO_PARMS* = LPMCI_INFO_PARMSA + MCI_SYSINFO_PARMS* = MCI_SYSINFO_PARMSA + PMCI_SYSINFO_PARMS* = PMCI_SYSINFO_PARMSA + LPMCI_SYSINFO_PARMS* = LPMCI_SYSINFO_PARMSA + MCI_SAVE_PARMS* = MCI_SAVE_PARMSA + PMCI_SAVE_PARMS* = PMCI_SAVE_PARMSA + LPMCI_SAVE_PARMS* = LPMCI_SAVE_PARMSA + MCI_LOAD_PARMS* = MCI_LOAD_PARMSA + PMCI_LOAD_PARMS* = PMCI_LOAD_PARMSA + LPMCI_LOAD_PARMS* = LPMCI_LOAD_PARMSA + MCI_VD_ESCAPE_PARMS* = MCI_VD_ESCAPE_PARMSA + PMCI_VD_ESCAPE_PARMS* = PMCI_VD_ESCAPE_PARMSA + LPMCI_VD_ESCAPE_PARMS* = LPMCI_VD_ESCAPE_PARMSA + MCI_WAVE_OPEN_PARMS* = MCI_WAVE_OPEN_PARMSA + PMCI_WAVE_OPEN_PARMS* = PMCI_WAVE_OPEN_PARMSA + LPMCI_WAVE_OPEN_PARMS* = LPMCI_WAVE_OPEN_PARMSA + MCI_ANIM_OPEN_PARMS* = MCI_ANIM_OPEN_PARMSA + PMCI_ANIM_OPEN_PARMS* = PMCI_ANIM_OPEN_PARMSA + LPMCI_ANIM_OPEN_PARMS* = LPMCI_ANIM_OPEN_PARMSA + MCI_ANIM_WINDOW_PARMS* = MCI_ANIM_WINDOW_PARMSA + PMCI_ANIM_WINDOW_PARMS* = PMCI_ANIM_WINDOW_PARMSA + LPMCI_ANIM_WINDOW_PARMS* = LPMCI_ANIM_WINDOW_PARMSA + MCI_OVLY_OPEN_PARMS* = MCI_OVLY_OPEN_PARMSA + PMCI_OVLY_OPEN_PARMS* = PMCI_OVLY_OPEN_PARMSA + LPMCI_OVLY_OPEN_PARMS* = LPMCI_OVLY_OPEN_PARMSA + MCI_OVLY_WINDOW_PARMS* = MCI_OVLY_WINDOW_PARMSA + PMCI_OVLY_WINDOW_PARMS* = PMCI_OVLY_WINDOW_PARMSA + LPMCI_OVLY_WINDOW_PARMS* = LPMCI_OVLY_WINDOW_PARMSA + MCI_OVLY_SAVE_PARMS* = MCI_OVLY_SAVE_PARMSA + PMCI_OVLY_SAVE_PARMS* = PMCI_OVLY_SAVE_PARMSA + LPMCI_OVLY_SAVE_PARMS* = LPMCI_OVLY_SAVE_PARMSA + MCI_OVLY_LOAD_PARMS* = MCI_OVLY_LOAD_PARMSA + PMCI_OVLY_LOAD_PARMS* = PMCI_OVLY_LOAD_PARMSA + LPMCI_OVLY_LOAD_PARMS* = LPMCI_OVLY_LOAD_PARMSA + proc sndPlaySound*(pszSound: LPCSTR, fuSound: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "sndPlaySoundA".} + proc PlaySound*(pszSound: LPCSTR, hmod: HMODULE, fdwSound: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "PlaySoundA".} + proc waveOutGetDevCaps*(uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSA, cbwoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveOutGetDevCapsA".} + proc waveOutGetErrorText*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveOutGetErrorTextA".} + proc waveInGetDevCaps*(uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSA, cbwic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveInGetDevCapsA".} + proc waveInGetErrorText*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "waveInGetErrorTextA".} + proc midiOutGetDevCaps*(uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSA, cbmoc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiOutGetDevCapsA".} + proc midiOutGetErrorText*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiOutGetErrorTextA".} + proc midiInGetDevCaps*(uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSA, cbmic: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiInGetDevCapsA".} + proc midiInGetErrorText*(mmrError: MMRESULT, pszText: LPSTR, cchText: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "midiInGetErrorTextA".} + proc auxGetDevCaps*(uDeviceID: UINT_PTR, pac: LPAUXCAPSA, cbac: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "auxGetDevCapsA".} + proc mixerGetDevCaps*(uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSA, cbmxcaps: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetDevCapsA".} + proc mixerGetLineInfo*(hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEA, fdwInfo: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetLineInfoA".} + proc mixerGetLineControls*(hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSA, fdwControls: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetLineControlsA".} + proc mixerGetControlDetails*(hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mixerGetControlDetailsA".} + proc joyGetDevCaps*(uJoyID: UINT_PTR, pjc: LPJOYCAPSA, cbjc: UINT): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "joyGetDevCapsA".} + proc mmioStringToFOURCC*(sz: LPCSTR, uFlags: UINT): FOURCC {.winapi, stdcall, dynlib: "winmm", importc: "mmioStringToFOURCCA".} + proc mmioInstallIOProc*(fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD): LPMMIOPROC {.winapi, stdcall, dynlib: "winmm", importc: "mmioInstallIOProcA".} + proc mmioOpen*(pszFileName: LPSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD): HMMIO {.winapi, stdcall, dynlib: "winmm", importc: "mmioOpenA".} + proc mmioRename*(pszFileName: LPCSTR, pszNewFileName: LPCSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD): MMRESULT {.winapi, stdcall, dynlib: "winmm", importc: "mmioRenameA".} + proc mciSendCommand*(mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc: "mciSendCommandA".} + proc mciSendString*(lpstrCommand: LPCSTR, lpstrReturnString: LPSTR, uReturnLength: UINT, hwndCallback: HWND): MCIERROR {.winapi, stdcall, dynlib: "winmm", importc: "mciSendStringA".} + proc mciGetDeviceID*(pszDevice: LPCSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc: "mciGetDeviceIDA".} + proc mciGetDeviceIDFromElementID*(dwElementID: DWORD, lpstrType: LPCSTR): MCIDEVICEID {.winapi, stdcall, dynlib: "winmm", importc: "mciGetDeviceIDFromElementIDA".} + proc mciGetErrorString*(mcierr: MCIERROR, pszText: LPSTR, cchText: UINT): WINBOOL {.winapi, stdcall, dynlib: "winmm", importc: "mciGetErrorStringA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/mscoree.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/mscoree.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1997 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import objbase +#include +#include +#include +#include +#include +#include +#include +type + COR_GC_STAT_TYPES* = int32 + COR_GC_THREAD_STATS_TYPES* = int32 + ValidatorFlags* = int32 + HOST_TYPE* = int32 + STARTUP_FLAGS* = int32 + CLSID_RESOLUTION_FLAGS* = int32 + RUNTIME_INFO_FLAGS* = int32 + APPDOMAIN_SECURITY_FLAGS* = int32 + HDOMAINENUM* = pointer + EMemoryAvailable* = int32 + EMemoryCriticalLevel* = int32 + WAIT_OPTION* = int32 + MALLOC_TYPE* = int32 + ETaskType* = int32 + ESymbolReadingPolicy* = int32 + ECustomDumpFlavor* = int32 + ECustomDumpItemKind* = int32 + BucketParameterIndex* = int32 + EClrOperation* = int32 + EClrFailure* = int32 + EClrUnhandledException* = int32 + EPolicyAction* = int32 + EClrEvent* = int32 + StackOverflowType* = int32 + ECLRAssemblyIdentityFlags* = int32 + EHostBindingPolicyModifyFlags* = int32 + EBindPolicyLevels* = int32 + EHostApplicationPolicy* = int32 + EApiCategories* = int32 + EInitializeNewDomainFlags* = int32 + EContextType* = int32 + METAHOST_POLICY_FLAGS* = int32 + METAHOST_CONFIG_FLAGS* = int32 + CLR_DEBUGGING_PROCESS_FLAGS* = int32 + BindingFlags* = int32 + MemberTypes* = int32 + MethodImplAttributes* = int32 + MethodAttributes* = int32 + CallingConventions* = int32 + TypeAttributes* = int32 + AssemblyBuilderAccess* = int32 + AssemblyBuilder* = int32 + PrincipalPolicy* = int32 + CONNID* = DWORD + VerError* {.pure.} = object + flags*: int32 + opcode*: int32 + uOffset*: int32 + Token*: int32 + item1_flags*: int32 + item1_data*: ptr int32 + item2_flags*: int32 + item2_data*: ptr int32 + VEContext* = VerError + TASKID* = UINT64 + POBJECT* = ptr object +const + COR_GC_COUNTS* = 0x1 + COR_GC_MEMORYUSAGE* = 0x2 + COR_GC_THREAD_HAS_PROMOTED_BYTES* = 0x1 + IID_IGCHost* = DEFINE_GUID("fac34f6e-0dcd-47b5-8021-531bc5ecca63") + IID_IGCHost2* = DEFINE_GUID("a1d70cec-2dbe-4e2f-9291-fdf81438a1df") + CLSID_VEHandlerClass* = DEFINE_GUID("856ca1b1-7dab-11d3-acec-00c04f86c309") + IID_IVEHandler* = DEFINE_GUID("856ca1b2-7dab-11d3-acec-00c04f86c309") + VALIDATOR_EXTRA_VERBOSE* = 0x1 + VALIDATOR_SHOW_SOURCE_LINES* = 0x2 + VALIDATOR_CHECK_ILONLY* = 0x4 + VALIDATOR_CHECK_PEFORMAT_ONLY* = 0x8 + VALIDATOR_NOCHECK_PEFORMAT* = 0x10 + VALIDATOR_TRANSPARENT_ONLY* = 0x20 + IID_IValidator* = DEFINE_GUID("63df8730-dc81-4062-84a2-1ff943f59fac") + IID_ICLRValidator* = DEFINE_GUID("63df8730-dc81-4062-84a2-1ff943f59fdd") + CLR_MAJOR_VERSION* = 4 + CLR_MINOR_VERSION* = 0 + CLR_BUILD_VERSION* = 30319 + CLR_ASSEMBLY_MAJOR_VERSION* = 4 + CLR_ASSEMBLY_MINOR_VERSION* = 0 + CLR_ASSEMBLY_BUILD_VERSION* = 0 + LIBID_mscoree* = DEFINE_GUID("5477469e-83b1-11d2-8b49-00a0c9b7c9c4") + CLSID_CorRuntimeHost* = DEFINE_GUID("cb2f6723-ab3a-11d2-9c40-00c04fa30a3e") + CLSID_TypeNameFactory* = DEFINE_GUID("b81ff171-20f3-11d2-8dcc-00a0c9b00525") + CLSID_CLRRuntimeHost* = DEFINE_GUID("90f1a06e-7712-4762-86b5-7a5eba6bdb02") + CLSID_ComCallUnmarshal* = DEFINE_GUID("3f281000-e95a-11d2-886b-00c04f869f04") + CLSID_ComCallUnmarshalV4* = DEFINE_GUID("45fb4600-e6e8-4928-b25e-50476ff79425") + IID_IObjectHandle* = DEFINE_GUID("c460e2b4-e199-412a-8456-84dc3e4838c3") + IID_IManagedObject* = DEFINE_GUID("c3fcc19e-a970-11d2-8b5a-00a0c9b7c9c4") + IID_IApartmentCallback* = DEFINE_GUID("178e5337-1528-4591-b1c9-1c6e484686d8") + IID_ICatalogServices* = DEFINE_GUID("04c6be1e-1db1-4058-ab7a-700cccfbf254") + IID_ICorRuntimeHost* = DEFINE_GUID("cb2f6722-ab3a-11d2-9c40-00c04fa30a3e") + IID_ICorThreadpool* = DEFINE_GUID("84680d3a-b2c1-46e8-acc2-dbc0a359159a") + IID_ICLRDebugManager* = DEFINE_GUID("00dcaec6-2ac0-43a9-acf9-1e36c139b10d") + IID_IHostMemoryNeededCallback* = DEFINE_GUID("47eb8e57-0846-4546-af76-6f42fcfc2649") + IID_IHostMalloc* = DEFINE_GUID("1831991c-cc53-4a31-b218-04e910446479") + IID_IHostMemoryManager* = DEFINE_GUID("7bc698d1-f9e3-4460-9cde-d04248e9fa25") + IID_ICLRTask* = DEFINE_GUID("28e66a4a-9906-4225-b231-9187c3eb8611") + IID_ICLRTask2* = DEFINE_GUID("28e66a4a-9906-4225-b231-9187c3eb8612") + IID_IHostTask* = DEFINE_GUID("c2275828-c4b1-4b55-82c9-92135f74df1a") + IID_ICLRTaskManager* = DEFINE_GUID("4862efbe-3ae5-44f8-8feb-346190ee8a34") + IID_IHostTaskManager* = DEFINE_GUID("997ff24c-43b7-4352-8667-0dc04fafd354") + IID_IHostThreadpoolManager* = DEFINE_GUID("983d50e2-cb15-466b-80fc-845dc6e8c5fd") + IID_ICLRIoCompletionManager* = DEFINE_GUID("2d74ce86-b8d6-4c84-b3a7-9768933b3c12") + IID_IHostIoCompletionManager* = DEFINE_GUID("8bde9d80-ec06-41d6-83e6-22580effcc20") + IID_IHostSyncManager* = DEFINE_GUID("234330c7-5f10-4f20-9615-5122dab7a0ac") + IID_IHostCrst* = DEFINE_GUID("6df710a6-26a4-4a65-8cd5-7237b8bda8dc") + IID_IHostAutoEvent* = DEFINE_GUID("50b0cfce-4063-4278-9673-e5cb4ed0bdb8") + IID_IHostManualEvent* = DEFINE_GUID("1bf4ec38-affe-4fb9-85a6-525268f15b54") + IID_IHostSemaphore* = DEFINE_GUID("855efd47-cc09-463a-a97d-16acab882661") + IID_ICLRSyncManager* = DEFINE_GUID("55ff199d-ad21-48f9-a16c-f24ebbb8727d") + IID_ICLRAppDomainResourceMonitor* = DEFINE_GUID("c62de18c-2e23-4aea-8423-b40c1fc59eae") + IID_ICLRPolicyManager* = DEFINE_GUID("7d290010-d781-45da-a6f8-aa5d711a730e") + IID_ICLRGCManager* = DEFINE_GUID("54d9007e-a8e2-4885-b7bf-f998deee4f2a") + IID_ICLRGCManager2* = DEFINE_GUID("0603b793-a97a-4712-9cb4-0cd1c74c0f7c") + IID_ICLRErrorReportingManager* = DEFINE_GUID("980d2f1a-bf79-4c08-812a-bb9778928f78") + IID_IHostPolicyManager* = DEFINE_GUID("7ae49844-b1e3-4683-ba7c-1e8212ea3b79") + IID_IHostGCManager* = DEFINE_GUID("5d4ec34e-f248-457b-b603-255faaba0d21") + IID_IActionOnCLREvent* = DEFINE_GUID("607be24b-d91b-4e28-a242-61871ce56e35") + IID_ICLROnEventManager* = DEFINE_GUID("1d0e0132-e64f-493d-9260-025c0e32c175") + IID_ICLRRuntimeHost* = DEFINE_GUID("90f1a06c-7712-4762-86b5-7a5eba6bdb02") + IID_ICLRHostProtectionManager* = DEFINE_GUID("89f25f5c-ceef-43e1-9cfa-a68ce863aaac") + IID_IHostAssemblyStore* = DEFINE_GUID("7b102a88-3f7f-496d-8fa2-c35374e01af3") + IID_IHostAssemblyManager* = DEFINE_GUID("613dabd7-62b2-493e-9e65-c1e32a1e0c5e") + IID_IHostSecurityManager* = DEFINE_GUID("75ad2468-a349-4d02-a764-76a68aee0c4f") + IID_IHostSecurityContext* = DEFINE_GUID("7e573ce4-0343-4423-98d7-6318348a1d3c") + IID_ICLRAssemblyIdentityManager* = DEFINE_GUID("15f0a9da-3ff6-4393-9da9-fdfd284e6972") + IID_ICLRDomainManager* = DEFINE_GUID("270d00a2-8e15-4d0b-adeb-37bc3e47df77") + IID_ITypeName* = DEFINE_GUID("b81ff171-20f3-11d2-8dcc-00a0c9b00522") + IID_ICLRAssemblyReferenceList* = DEFINE_GUID("1b2c9750-2e66-4bda-8b44-0a642c5cd733") + IID_ICLRReferenceAssemblyEnum* = DEFINE_GUID("d509cb5d-cf32-4876-ae61-67770cf91973") + IID_ICLRProbingAssemblyEnum* = DEFINE_GUID("d0c5fb1f-416b-4f97-81f4-7ac7dc24dd5d") + IID_ICLRHostBindingPolicyManager* = DEFINE_GUID("4b3545e7-1856-48c9-a8ba-24b21a753c09") + IID_ITypeNameBuilder* = DEFINE_GUID("b81ff171-20f3-11d2-8dcc-00a0c9b00523") + IID_ITypeNameFactory* = DEFINE_GUID("b81ff171-20f3-11d2-8dcc-00a0c9b00521") + HOST_TYPE_DEFAULT* = 0 + HOST_TYPE_APPLAUNCH* = 0x1 + HOST_TYPE_CORFLAG* = 0x2 + STARTUP_CONCURRENT_GC* = 0x1 + STARTUP_LOADER_OPTIMIZATION_MASK* = 0x3 shl 1 + STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN* = 0x1 shl 1 + STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN* = 0x2 shl 1 + STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST* = 0x3 shl 1 + STARTUP_LOADER_SAFEMODE* = 0x10 + STARTUP_LOADER_SETPREFERENCE* = 0x100 + STARTUP_SERVER_GC* = 0x1000 + STARTUP_HOARD_GC_VM* = 0x2000 + STARTUP_SINGLE_VERSION_HOSTING_INTERFACE* = 0x4000 + STARTUP_LEGACY_IMPERSONATION* = 0x10000 + STARTUP_DISABLE_COMMITTHREADSTACK* = 0x20000 + STARTUP_ALWAYSFLOW_IMPERSONATION* = 0x40000 + STARTUP_TRIM_GC_COMMIT* = 0x80000 + STARTUP_ETW* = 0x100000 + STARTUP_ARM* = 0x400000 + CLSID_RESOLUTION_DEFAULT* = 0 + CLSID_RESOLUTION_REGISTERED* = 0x1 + RUNTIME_INFO_UPGRADE_VERSION* = 0x1 + RUNTIME_INFO_REQUEST_IA64* = 0x2 + RUNTIME_INFO_REQUEST_AMD64* = 0x4 + RUNTIME_INFO_REQUEST_X86* = 0x8 + RUNTIME_INFO_DONT_RETURN_DIRECTORY* = 0x10 + RUNTIME_INFO_DONT_RETURN_VERSION* = 0x20 + RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG* = 0x40 + RUNTIME_INFO_IGNORE_ERROR_MODE* = 0x1000 + APPDOMAIN_SECURITY_DEFAULT* = 0 + APPDOMAIN_SECURITY_SANDBOXED* = 0x1 + APPDOMAIN_SECURITY_FORBID_CROSSAD_REVERSE_PINVOKE* = 0x2 + APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS* = 0x8 + IID_IAppDomainBinding* = DEFINE_GUID("5c2b07a7-1e98-11d3-872f-00c04f79ed0d") + IID_IGCThreadControl* = DEFINE_GUID("f31d1788-c397-4725-87a5-6af3472c2791") + IID_IGCHostControl* = DEFINE_GUID("5513d564-8374-4cb9-aed9-0083f4160a1d") + IID_IDebuggerThreadControl* = DEFINE_GUID("23d86786-0bb5-4774-8fb5-e3522add6246") + IID_IDebuggerInfo* = DEFINE_GUID("bf24142d-a47d-4d24-a66d-8c2141944e44") + IID_ICorConfiguration* = DEFINE_GUID("5c2b07a5-1e98-11d3-872f-00c04f79ed0d") + eMemoryAvailableLow* = 1 + eMemoryAvailableNeutral* = 2 + eMemoryAvailableHigh* = 3 + eTaskCritical* = 0 + eAppDomainCritical* = 1 + eProcessCritical* = 2 + WAIT_MSGPUMP* = 0x1 + WAIT_ALERTABLE* = 0x2 + WAIT_NOTINDEADLOCK* = 0x4 + IID_ICLRMemoryNotificationCallback* = DEFINE_GUID("47eb8e57-0846-4546-af76-6f42fcfc2649") + MALLOC_THREADSAFE* = 0x1 + MALLOC_EXECUTABLE* = 0x2 + TT_DEBUGGERHELPER* = 0x1 + TT_GC* = 0x2 + TT_FINALIZER* = 0x4 + TT_THREADPOOL_TIMER* = 0x8 + TT_THREADPOOL_GATE* = 0x10 + TT_THREADPOOL_WORKER* = 0x20 + TT_THREADPOOL_IOCOMPLETION* = 0x40 + TT_ADUNLOAD* = 0x80 + TT_USER* = 0x100 + TT_THREADPOOL_WAIT* = 0x200 + TT_UNKNOWN* = 0x80000000'i32 + eSymbolReadingNever* = 0 + eSymbolReadingAlways* = 1 + eSymbolReadingFullTrustOnly* = 2 + DUMP_FLAVOR_Mini* = 0 + DUMP_FLAVOR_CriticalCLRState* = 1 + DUMP_FLAVOR_NonHeapCLRState* = 2 + DUMP_FLAVOR_Default* = DUMP_FLAVOR_Mini + DUMP_ITEM_None* = 0 + bucketParamsCount* = 10 + bucketParamLength* = 255 + parameter1* = 0 + parameter2* = parameter1+1 + parameter3* = parameter2+1 + parameter4* = parameter3+1 + parameter5* = parameter4+1 + parameter6* = parameter5+1 + parameter7* = parameter6+1 + parameter8* = parameter7+1 + parameter9* = parameter8+1 + invalidBucketParamIndex* = parameter9+1 + OPR_ThreadAbort* = 0 + OPR_ThreadRudeAbortInNonCriticalRegion* = OPR_ThreadAbort+1 + OPR_ThreadRudeAbortInCriticalRegion* = OPR_ThreadRudeAbortInNonCriticalRegion+1 + OPR_AppDomainUnload* = OPR_ThreadRudeAbortInCriticalRegion+1 + OPR_AppDomainRudeUnload* = OPR_AppDomainUnload+1 + OPR_ProcessExit* = OPR_AppDomainRudeUnload+1 + OPR_FinalizerRun* = OPR_ProcessExit+1 + maxClrOperation* = OPR_FinalizerRun+1 + FAIL_NonCriticalResource* = 0 + FAIL_CriticalResource* = FAIL_NonCriticalResource+1 + FAIL_FatalRuntime* = FAIL_CriticalResource+1 + FAIL_OrphanedLock* = FAIL_FatalRuntime+1 + FAIL_StackOverflow* = FAIL_OrphanedLock+1 + FAIL_AccessViolation* = FAIL_StackOverflow+1 + FAIL_CodeContract* = FAIL_AccessViolation+1 + maxClrFailure* = FAIL_CodeContract+1 + eRuntimeDeterminedPolicy* = 0 + eHostDeterminedPolicy* = eRuntimeDeterminedPolicy+1 + eNoAction* = 0 + eThrowException* = eNoAction+1 + eAbortThread* = eThrowException+1 + eRudeAbortThread* = eAbortThread+1 + eUnloadAppDomain* = eRudeAbortThread+1 + eRudeUnloadAppDomain* = eUnloadAppDomain+1 + eExitProcess* = eRudeUnloadAppDomain+1 + eFastExitProcess* = eExitProcess+1 + eRudeExitProcess* = eFastExitProcess+1 + eDisableRuntime* = eRudeExitProcess+1 + maxPolicyAction* = eDisableRuntime+1 + Event_DomainUnload* = 0 + Event_ClrDisabled* = Event_DomainUnload+1 + Event_MDAFired* = Event_ClrDisabled+1 + Event_StackOverflow* = Event_MDAFired+1 + maxClrEvent* = Event_StackOverflow+1 + SO_Managed* = 0 + SO_ClrEngine* = SO_Managed+1 + SO_Other* = SO_ClrEngine+1 + CLR_ASSEMBLY_IDENTITY_FLAGS_DEFAULT* = 0 + HOST_BINDING_POLICY_MODIFY_DEFAULT* = 0 + HOST_BINDING_POLICY_MODIFY_CHAIN* = 1 + HOST_BINDING_POLICY_MODIFY_REMOVE* = 2 + HOST_BINDING_POLICY_MODIFY_MAX* = 3 + ePolicyLevelNone* = 0 + ePolicyLevelRetargetable* = 0x1 + ePolicyUnifiedToCLR* = 0x2 + ePolicyLevelApp* = 0x4 + ePolicyLevelPublisher* = 0x8 + ePolicyLevelHost* = 0x10 + ePolicyLevelAdmin* = 0x20 + ePolicyPortability* = 0x40 + HOST_APPLICATION_BINDING_POLICY* = 1 + IID_IHostControl* = DEFINE_GUID("02ca073c-7079-4860-880a-c2f7a449c991") + IID_ICLRControl* = DEFINE_GUID("9065597e-d1a1-4fb2-b6ba-7e1fce230f61") + eNoChecks* = 0 + eSynchronization* = 0x1 + eSharedState* = 0x2 + eExternalProcessMgmt* = 0x4 + eSelfAffectingProcessMgmt* = 0x8 + eExternalThreading* = 0x10 + eSelfAffectingThreading* = 0x20 + eSecurityInfrastructure* = 0x40 + eUI* = 0x80 + eMayLeakOnAbort* = 0x100 + eAll* = 0x1ff + eInitializeNewDomainFlags_None* = 0 + eInitializeNewDomainFlags_NoSecurityChanges* = 0x2 + eCurrentContext* = 0 + eRestrictedContext* = 0x1 + CLSID_CLRStrongName* = DEFINE_GUID("b79b0acd-f5cd-409b-b5a5-a16244610b92") + IID_ICLRMetaHost* = DEFINE_GUID("d332db9e-b9b3-4125-8207-a14884f53216") + CLSID_CLRMetaHost* = DEFINE_GUID("9280188d-0e8e-4867-b30c-7fa83884e8de") + IID_ICLRMetaHostPolicy* = DEFINE_GUID("e2190695-77b2-492e-8e14-c4b3a7fdd593") + CLSID_CLRMetaHostPolicy* = DEFINE_GUID("2ebcd49a-1b47-4a61-b13a-4a03701e594b") + IID_ICLRDebugging* = DEFINE_GUID("d28f3c5a-9634-4206-a509-477552eefb10") + CLSID_CLRDebugging* = DEFINE_GUID("bacc578d-fbdd-48a4-969f-02d932b74634") + IID_ICLRRuntimeInfo* = DEFINE_GUID("bd39d1d2-ba2f-486a-89b0-b4b0cb466891") + IID_ICLRStrongName* = DEFINE_GUID("9fd93ccf-3280-4391-b3a9-96e1cde77c8d") + IID_ICLRStrongName2* = DEFINE_GUID("c22ed5c5-4b59-4975-90eb-85ea55c0069b") + IID_ICLRStrongName3* = DEFINE_GUID("22c7089b-bbd3-414a-b698-210f263f1fed") + CLSID_CLRDebuggingLegacy* = DEFINE_GUID("df8395b5-a4ba-450b-a77c-a9a47762c520") + CLSID_CLRProfiling* = DEFINE_GUID("bd097ed8-733e-43fe-8ed7-a95ff9a8448c") + IID_ICLRProfiling* = DEFINE_GUID("b349abe3-b56f-4689-bfcd-76bf39d888ea") + IID_ICLRDebuggingLibraryProvider* = DEFINE_GUID("3151c08d-4d09-4f9b-8838-2880bf18fe51") + METAHOST_POLICY_HIGHCOMPAT* = 0 + METAHOST_POLICY_APPLY_UPGRADE_POLICY* = 0x8 + METAHOST_POLICY_EMULATE_EXE_LAUNCH* = 0x10 + METAHOST_POLICY_SHOW_ERROR_DIALOG* = 0x20 + METAHOST_POLICY_USE_PROCESS_IMAGE_PATH* = 0x40 + METAHOST_POLICY_ENSURE_SKU_SUPPORTED* = 0x80 + METAHOST_POLICY_IGNORE_ERROR_MODE* = 0x1000 + METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_UNSET* = 0 + METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_TRUE* = 0x1 + METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_FALSE* = 0x2 + METAHOST_CONFIG_FLAGS_LEGACY_V2_ACTIVATION_POLICY_MASK* = 0x3 + CLR_DEBUGGING_MANAGED_EVENT_PENDING* = 1 + CLR_DEBUGGING_MANAGED_EVENT_DEBUGGER_LAUNCH* = 2 + IID_AppDomain* = DEFINE_GUID("05f696dc-2b29-3663-ad8b-c4389cf2a713") + IID_ObjectHandle* = DEFINE_GUID("ea675b47-64e0-3b5f-9be7-f7dc2990730d") + IID_IAppDomainSetup* = DEFINE_GUID("27fff232-a7a8-40dd-8d4a-734ad59fcd41") + IID_IType* = DEFINE_GUID("bca8b44d-aad6-3a86-8ab7-03349f4f2da2") + IID_IObject* = DEFINE_GUID("65074f7f-63c0-304e-af0a-d51741cb4a8d") + BindingFlags_Default* = 0 + BindingFlags_IgnoreCase* = 1 + BindingFlags_DeclaredOnly* = 2 + BindingFlags_Instance* = 4 + BindingFlags_Static* = 8 + BindingFlags_Public* = 16 + BindingFlags_NonPublic* = 32 + BindingFlags_FlattenHierarchy* = 64 + BindingFlags_InvokeMethod* = 256 + BindingFlags_CreateInstance* = 512 + BindingFlags_GetField* = 1024 + BindingFlags_SetField* = 2048 + BindingFlags_GetProperty* = 4096 + BindingFlags_SetProperty* = 8192 + BindingFlags_PutDispProperty* = 16384 + BindingFlags_PutRefDispProperty* = 32768 + BindingFlags_ExactBinding* = 65536 + BindingFlags_SuppressChangeType* = 131072 + BindingFlags_OptionalParamBinding* = 262144 + BindingFlags_IgnoreReturn* = 16777216 + IID_IAssembly* = DEFINE_GUID("17156360-2f1a-384a-bc52-fde93c215c5b") + MemberTypes_Constructor* = 1 + MemberTypes_Event* = 2 + MemberTypes_Field* = 4 + MemberTypes_Method* = 8 + MemberTypes_Property* = 16 + MemberTypes_TypeInfo* = 32 + MemberTypes_Custom* = 64 + MemberTypes_NestedType* = 128 + MemberTypes_All* = 191 + MethodImplAttributes_CodeTypeMask* = 3 + MethodImplAttributes_IL* = 0 + MethodImplAttributes_Native* = 1 + MethodImplAttributes_OPTIL* = 2 + MethodImplAttributes_Runtime* = 3 + MethodImplAttributes_ManagedMask* = 4 + MethodImplAttributes_Unmanaged* = 4 + MethodImplAttributes_Managed* = 0 + MethodImplAttributes_ForwardRef* = 16 + MethodImplAttributes_PreserveSig* = 128 + MethodImplAttributes_InternalCall* = 4096 + MethodImplAttributes_Synchronized* = 32 + MethodImplAttributes_NoInlining* = 8 + MethodImplAttributes_NoOptimization* = 64 + MethodImplAttributes_MaxMethodImplVal* = 65535 + MethodAttributes_MemberAccessMask* = 7 + MethodAttributes_PrivateScope* = 0 + MethodAttributes_Private* = 1 + MethodAttributes_FamANDAssem* = 2 + methodAttributesIAssembly* = 3 + MethodAttributes_Family* = 4 + MethodAttributes_FamORAssem* = 5 + MethodAttributes_Public* = 6 + MethodAttributes_Static* = 16 + MethodAttributes_Final* = 32 + MethodAttributes_Virtual* = 64 + MethodAttributes_HideBySig* = 128 + MethodAttributes_CheckAccessOnOverride* = 512 + MethodAttributes_VtableLayoutMask* = 256 + MethodAttributes_ReuseSlot* = 0 + MethodAttributes_NewSlot* = 256 + MethodAttributes_Abstract* = 1024 + MethodAttributes_SpecialName* = 2048 + MethodAttributes_PinvokeImpl* = 8192 + MethodAttributes_UnmanagedExport* = 8 + MethodAttributes_RTSpecialName* = 4096 + MethodAttributes_ReservedMask* = 53248 + MethodAttributes_HasSecurity* = 16384 + MethodAttributes_RequireSecObject* = 32768 + CallingConventions_Standard* = 1 + CallingConventions_VarArgs* = 2 + CallingConventions_Any* = 3 + CallingConventions_HasThis* = 32 + CallingConventions_ExplicitThis* = 64 + IID_IMethodInfo* = DEFINE_GUID("ffcc1b5d-ecb8-38dd-9b01-3dc8abc2aa5f") +type + FLockClrVersionCallback* = proc (): HRESULT {.stdcall.} + FExecuteInAppDomainCallback* = proc (cookie: pointer): HRESULT {.stdcall.} + PTLS_CALLBACK_FUNCTION* = proc (MIDL_itf_mscoree_0000_00040005: PVOID): VOID {.stdcall.} + CLRCreateInstanceFnPtr* = proc (clsid: REFCLSID, riid: REFIID, ppInterface: ptr LPVOID): HRESULT {.stdcall.} + CreateInterfaceFnPtr* = proc (clsid: REFCLSID, riid: REFIID, ppInterface: ptr LPVOID): HRESULT {.stdcall.} + CallbackThreadSetFnPtr* = proc (P1: void): HRESULT {.stdcall.} + CallbackThreadUnsetFnPtr* = proc (P1: void): HRESULT {.stdcall.} + ICLRRuntimeInfo* {.pure.} = object + lpVtbl*: ptr ICLRRuntimeInfoVtbl + ICLRRuntimeInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetVersionString*: proc(self: ptr ICLRRuntimeInfo, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.stdcall.} + GetRuntimeDirectory*: proc(self: ptr ICLRRuntimeInfo, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.stdcall.} + IsLoaded*: proc(self: ptr ICLRRuntimeInfo, hndProcess: HANDLE, pbLoaded: ptr BOOL): HRESULT {.stdcall.} + LoadErrorString*: proc(self: ptr ICLRRuntimeInfo, iResourceID: UINT, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD, iLocaleID: LONG): HRESULT {.stdcall.} + LoadLibrary*: proc(self: ptr ICLRRuntimeInfo, pwzDllName: LPCWSTR, phndModule: ptr HMODULE): HRESULT {.stdcall.} + GetProcAddress*: proc(self: ptr ICLRRuntimeInfo, pszProcName: LPCSTR, ppProc: ptr LPVOID): HRESULT {.stdcall.} + GetInterface*: proc(self: ptr ICLRRuntimeInfo, rclsid: REFCLSID, riid: REFIID, ppUnk: ptr LPVOID): HRESULT {.stdcall.} + IsLoadable*: proc(self: ptr ICLRRuntimeInfo, pbLoadable: ptr BOOL): HRESULT {.stdcall.} + SetDefaultStartupFlags*: proc(self: ptr ICLRRuntimeInfo, dwStartupFlags: DWORD, pwzHostConfigFile: LPCWSTR): HRESULT {.stdcall.} + GetDefaultStartupFlags*: proc(self: ptr ICLRRuntimeInfo, pdwStartupFlags: ptr DWORD, pwzHostConfigFile: LPWSTR, pcchHostConfigFile: ptr DWORD): HRESULT {.stdcall.} + BindAsLegacyV2Runtime*: proc(self: ptr ICLRRuntimeInfo): HRESULT {.stdcall.} + IsStarted*: proc(self: ptr ICLRRuntimeInfo, pbStarted: ptr BOOL, pdwStartupFlags: ptr DWORD): HRESULT {.stdcall.} + RuntimeLoadedCallbackFnPtr* = proc (pRuntimeInfo: ptr ICLRRuntimeInfo, pfnCallbackThreadSet: CallbackThreadSetFnPtr, pfnCallbackThreadUnset: CallbackThreadUnsetFnPtr): void {.stdcall.} + COR_GC_STATS* {.pure.} = object + Flags*: ULONG + ExplicitGCCount*: SIZE_T + GenCollectionsTaken*: array[ 3 , SIZE_T] + CommittedKBytes*: SIZE_T + ReservedKBytes*: SIZE_T + Gen0HeapSizeKBytes*: SIZE_T + Gen1HeapSizeKBytes*: SIZE_T + Gen2HeapSizeKBytes*: SIZE_T + LargeObjectHeapSizeKBytes*: SIZE_T + KBytesPromotedFromGen0*: SIZE_T + KBytesPromotedFromGen1*: SIZE_T + COR_GC_THREAD_STATS* {.pure.} = object + PerThreadAllocation*: ULONGLONG + Flags*: ULONG + CustomDumpItem_UNION1* {.pure, union.} = object + pReserved*: UINT_PTR + CustomDumpItem* {.pure.} = object + itemKind*: ECustomDumpItemKind + union1*: CustomDumpItem_UNION1 + BucketParameters* {.pure.} = object + fInited*: BOOL + pszEventTypeName*: array[ 255 , WCHAR] + pszParams*: array[ 10 , array[ 255 , WCHAR]] + MDAInfo* {.pure.} = object + lpMDACaption*: LPCWSTR + lpMDAMessage*: LPCWSTR + lpStackTrace*: LPCWSTR + StackOverflowInfo* {.pure.} = object + soType*: StackOverflowType + pExceptionInfo*: ptr EXCEPTION_POINTERS + AssemblyBindInfo* {.pure.} = object + dwAppDomainId*: DWORD + lpReferencedIdentity*: LPCWSTR + lpPostPolicyIdentity*: LPCWSTR + ePolicyLevel*: DWORD + ModuleBindInfo* {.pure.} = object + dwAppDomainId*: DWORD + lpAssemblyIdentity*: LPCWSTR + lpModuleName*: LPCWSTR + CLR_DEBUGGING_VERSION* {.pure.} = object + wStructVersion*: WORD + wMajor*: WORD + wMinor*: WORD + wBuild*: WORD + wRevision*: WORD + StreamingContext* {.pure.} = object + IGCHost* {.pure.} = object + lpVtbl*: ptr IGCHostVtbl + IGCHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetGCStartupLimits*: proc(self: ptr IGCHost, SegmentSize: DWORD, MaxGen0Size: DWORD): HRESULT {.stdcall.} + Collect*: proc(self: ptr IGCHost, Generation: LONG): HRESULT {.stdcall.} + GetStats*: proc(self: ptr IGCHost, pStats: ptr COR_GC_STATS): HRESULT {.stdcall.} + GetThreadStats*: proc(self: ptr IGCHost, pFiberCookie: ptr DWORD, pStats: ptr COR_GC_THREAD_STATS): HRESULT {.stdcall.} + SetVirtualMemLimit*: proc(self: ptr IGCHost, sztMaxVirtualMemMB: SIZE_T): HRESULT {.stdcall.} + IGCHost2* {.pure.} = object + lpVtbl*: ptr IGCHost2Vtbl + IGCHost2Vtbl* {.pure, inheritable.} = object of IGCHostVtbl + SetGCStartupLimitsEx*: proc(self: ptr IGCHost2, SegmentSize: SIZE_T, MaxGen0Size: SIZE_T): HRESULT {.stdcall.} + IVEHandler* {.pure.} = object + lpVtbl*: ptr IVEHandlerVtbl + IVEHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + VEHandler*: proc(self: ptr IVEHandler, VECode: HRESULT, Context: VEContext, psa: ptr SAFEARRAY): HRESULT {.stdcall.} + SetReporterFtn*: proc(self: ptr IVEHandler, lFnPtr: int64): HRESULT {.stdcall.} + IValidator* {.pure.} = object + lpVtbl*: ptr IValidatorVtbl + IValidatorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Validate*: proc(self: ptr IValidator, veh: ptr IVEHandler, pAppDomain: ptr IUnknown, ulFlags: int32, ulMaxError: int32, token: int32, fileName: LPWSTR, pe: ptr BYTE, ulSize: int32): HRESULT {.stdcall.} + FormatEventInfo*: proc(self: ptr IValidator, hVECode: HRESULT, Context: VEContext, msg: LPWSTR, ulMaxLength: int32, psa: ptr SAFEARRAY): HRESULT {.stdcall.} + ICLRValidator* {.pure.} = object + lpVtbl*: ptr ICLRValidatorVtbl + ICLRValidatorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Validate*: proc(self: ptr ICLRValidator, veh: ptr IVEHandler, ulAppDomainId: int32, ulFlags: int32, ulMaxError: int32, token: int32, fileName: LPWSTR, pe: ptr BYTE, ulSize: int32): HRESULT {.stdcall.} + FormatEventInfo*: proc(self: ptr ICLRValidator, hVECode: HRESULT, Context: VEContext, msg: LPWSTR, ulMaxLength: int32, psa: ptr SAFEARRAY): HRESULT {.stdcall.} + IObjectHandle* {.pure.} = object + lpVtbl*: ptr IObjectHandleVtbl + IObjectHandleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Unwrap*: proc(self: ptr IObjectHandle, ppv: ptr VARIANT): HRESULT {.stdcall.} + IAppDomainBinding* {.pure.} = object + lpVtbl*: ptr IAppDomainBindingVtbl + IAppDomainBindingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnAppDomain*: proc(self: ptr IAppDomainBinding, pAppdomain: ptr IUnknown): HRESULT {.stdcall.} + IGCThreadControl* {.pure.} = object + lpVtbl*: ptr IGCThreadControlVtbl + IGCThreadControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ThreadIsBlockingForSuspension*: proc(self: ptr IGCThreadControl): HRESULT {.stdcall.} + SuspensionStarting*: proc(self: ptr IGCThreadControl): HRESULT {.stdcall.} + SuspensionEnding*: proc(self: ptr IGCThreadControl, Generation: DWORD): HRESULT {.stdcall.} + IGCHostControl* {.pure.} = object + lpVtbl*: ptr IGCHostControlVtbl + IGCHostControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RequestVirtualMemLimit*: proc(self: ptr IGCHostControl, sztMaxVirtualMemMB: SIZE_T, psztNewMaxVirtualMemMB: ptr SIZE_T): HRESULT {.stdcall.} + ICorThreadpool* {.pure.} = object + lpVtbl*: ptr ICorThreadpoolVtbl + ICorThreadpoolVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CorRegisterWaitForSingleObject*: proc(self: ptr ICorThreadpool, phNewWaitObject: ptr HANDLE, hWaitObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, timeout: ULONG, executeOnlyOnce: BOOL, ret: ptr BOOL): HRESULT {.stdcall.} + CorUnregisterWait*: proc(self: ptr ICorThreadpool, hWaitObject: HANDLE, CompletionEvent: HANDLE, ret: ptr BOOL): HRESULT {.stdcall.} + CorQueueUserWorkItem*: proc(self: ptr ICorThreadpool, Function: LPTHREAD_START_ROUTINE, Context: PVOID, executeOnlyOnce: BOOL, ret: ptr BOOL): HRESULT {.stdcall.} + CorCreateTimer*: proc(self: ptr ICorThreadpool, phNewTimer: ptr HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, ret: ptr BOOL): HRESULT {.stdcall.} + CorChangeTimer*: proc(self: ptr ICorThreadpool, Timer: HANDLE, DueTime: ULONG, Period: ULONG, ret: ptr BOOL): HRESULT {.stdcall.} + CorDeleteTimer*: proc(self: ptr ICorThreadpool, Timer: HANDLE, CompletionEvent: HANDLE, ret: ptr BOOL): HRESULT {.stdcall.} + CorBindIoCompletionCallback*: proc(self: ptr ICorThreadpool, fileHandle: HANDLE, callback: LPOVERLAPPED_COMPLETION_ROUTINE): HRESULT {.stdcall.} + CorCallOrQueueUserWorkItem*: proc(self: ptr ICorThreadpool, Function: LPTHREAD_START_ROUTINE, Context: PVOID, ret: ptr BOOL): HRESULT {.stdcall.} + CorSetMaxThreads*: proc(self: ptr ICorThreadpool, MaxWorkerThreads: DWORD, MaxIOCompletionThreads: DWORD): HRESULT {.stdcall.} + CorGetMaxThreads*: proc(self: ptr ICorThreadpool, MaxWorkerThreads: ptr DWORD, MaxIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + CorGetAvailableThreads*: proc(self: ptr ICorThreadpool, AvailableWorkerThreads: ptr DWORD, AvailableIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + IDebuggerThreadControl* {.pure.} = object + lpVtbl*: ptr IDebuggerThreadControlVtbl + IDebuggerThreadControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ThreadIsBlockingForDebugger*: proc(self: ptr IDebuggerThreadControl): HRESULT {.stdcall.} + ReleaseAllRuntimeThreads*: proc(self: ptr IDebuggerThreadControl): HRESULT {.stdcall.} + StartBlockingForDebugger*: proc(self: ptr IDebuggerThreadControl, dwUnused: DWORD): HRESULT {.stdcall.} + IDebuggerInfo* {.pure.} = object + lpVtbl*: ptr IDebuggerInfoVtbl + IDebuggerInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsDebuggerAttached*: proc(self: ptr IDebuggerInfo, pbAttached: ptr BOOL): HRESULT {.stdcall.} + ICorConfiguration* {.pure.} = object + lpVtbl*: ptr ICorConfigurationVtbl + ICorConfigurationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetGCThreadControl*: proc(self: ptr ICorConfiguration, pGCThreadControl: ptr IGCThreadControl): HRESULT {.stdcall.} + SetGCHostControl*: proc(self: ptr ICorConfiguration, pGCHostControl: ptr IGCHostControl): HRESULT {.stdcall.} + SetDebuggerThreadControl*: proc(self: ptr ICorConfiguration, pDebuggerThreadControl: ptr IDebuggerThreadControl): HRESULT {.stdcall.} + AddDebuggerSpecialThread*: proc(self: ptr ICorConfiguration, dwSpecialThreadId: DWORD): HRESULT {.stdcall.} + ICorRuntimeHost* {.pure.} = object + lpVtbl*: ptr ICorRuntimeHostVtbl + ICorRuntimeHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateLogicalThreadState*: proc(self: ptr ICorRuntimeHost): HRESULT {.stdcall.} + DeleteLogicalThreadState*: proc(self: ptr ICorRuntimeHost): HRESULT {.stdcall.} + SwitchInLogicalThreadState*: proc(self: ptr ICorRuntimeHost, pFiberCookie: ptr DWORD): HRESULT {.stdcall.} + SwitchOutLogicalThreadState*: proc(self: ptr ICorRuntimeHost, pFiberCookie: ptr ptr DWORD): HRESULT {.stdcall.} + LocksHeldByLogicalThread*: proc(self: ptr ICorRuntimeHost, pCount: ptr DWORD): HRESULT {.stdcall.} + MapFile*: proc(self: ptr ICorRuntimeHost, hFile: HANDLE, hMapAddress: ptr HMODULE): HRESULT {.stdcall.} + GetConfiguration*: proc(self: ptr ICorRuntimeHost, pConfiguration: ptr ptr ICorConfiguration): HRESULT {.stdcall.} + Start*: proc(self: ptr ICorRuntimeHost): HRESULT {.stdcall.} + Stop*: proc(self: ptr ICorRuntimeHost): HRESULT {.stdcall.} + CreateDomain*: proc(self: ptr ICorRuntimeHost, pwzFriendlyName: LPCWSTR, pIdentityArray: ptr IUnknown, pAppDomain: ptr ptr IUnknown): HRESULT {.stdcall.} + GetDefaultDomain*: proc(self: ptr ICorRuntimeHost, pAppDomain: ptr ptr IUnknown): HRESULT {.stdcall.} + EnumDomains*: proc(self: ptr ICorRuntimeHost, hEnum: ptr HDOMAINENUM): HRESULT {.stdcall.} + NextDomain*: proc(self: ptr ICorRuntimeHost, hEnum: HDOMAINENUM, pAppDomain: ptr ptr IUnknown): HRESULT {.stdcall.} + CloseEnum*: proc(self: ptr ICorRuntimeHost, hEnum: HDOMAINENUM): HRESULT {.stdcall.} + CreateDomainEx*: proc(self: ptr ICorRuntimeHost, pwzFriendlyName: LPCWSTR, pSetup: ptr IUnknown, pEvidence: ptr IUnknown, pAppDomain: ptr ptr IUnknown): HRESULT {.stdcall.} + CreateDomainSetup*: proc(self: ptr ICorRuntimeHost, pAppDomainSetup: ptr ptr IUnknown): HRESULT {.stdcall.} + CreateEvidence*: proc(self: ptr ICorRuntimeHost, pEvidence: ptr ptr IUnknown): HRESULT {.stdcall.} + UnloadDomain*: proc(self: ptr ICorRuntimeHost, pAppDomain: ptr IUnknown): HRESULT {.stdcall.} + CurrentDomain*: proc(self: ptr ICorRuntimeHost, pAppDomain: ptr ptr IUnknown): HRESULT {.stdcall.} + ICLRMemoryNotificationCallback* {.pure.} = object + lpVtbl*: ptr ICLRMemoryNotificationCallbackVtbl + ICLRMemoryNotificationCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnMemoryNotification*: proc(self: ptr ICLRMemoryNotificationCallback, eMemoryAvailable: EMemoryAvailable): HRESULT {.stdcall.} + IHostMalloc* {.pure.} = object + lpVtbl*: ptr IHostMallocVtbl + IHostMallocVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Alloc*: proc(self: ptr IHostMalloc, cbSize: SIZE_T, eCriticalLevel: EMemoryCriticalLevel, ppMem: ptr pointer): HRESULT {.stdcall.} + DebugAlloc*: proc(self: ptr IHostMalloc, cbSize: SIZE_T, eCriticalLevel: EMemoryCriticalLevel, pszFileName: ptr char, iLineNo: int32, ppMem: ptr pointer): HRESULT {.stdcall.} + Free*: proc(self: ptr IHostMalloc, pMem: pointer): HRESULT {.stdcall.} + IHostMemoryManager* {.pure.} = object + lpVtbl*: ptr IHostMemoryManagerVtbl + IHostMemoryManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateMalloc*: proc(self: ptr IHostMemoryManager, dwMallocType: DWORD, ppMalloc: ptr ptr IHostMalloc): HRESULT {.stdcall.} + VirtualAlloc*: proc(self: ptr IHostMemoryManager, pAddress: pointer, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, eCriticalLevel: EMemoryCriticalLevel, ppMem: ptr pointer): HRESULT {.stdcall.} + VirtualFree*: proc(self: ptr IHostMemoryManager, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD): HRESULT {.stdcall.} + VirtualQuery*: proc(self: ptr IHostMemoryManager, lpAddress: pointer, lpBuffer: pointer, dwLength: SIZE_T, pResult: ptr SIZE_T): HRESULT {.stdcall.} + VirtualProtect*: proc(self: ptr IHostMemoryManager, lpAddress: pointer, dwSize: SIZE_T, flNewProtect: DWORD, pflOldProtect: ptr DWORD): HRESULT {.stdcall.} + GetMemoryLoad*: proc(self: ptr IHostMemoryManager, pMemoryLoad: ptr DWORD, pAvailableBytes: ptr SIZE_T): HRESULT {.stdcall.} + RegisterMemoryNotificationCallback*: proc(self: ptr IHostMemoryManager, pCallback: ptr ICLRMemoryNotificationCallback): HRESULT {.stdcall.} + NeedsVirtualAddressSpace*: proc(self: ptr IHostMemoryManager, startAddress: LPVOID, size: SIZE_T): HRESULT {.stdcall.} + AcquiredVirtualAddressSpace*: proc(self: ptr IHostMemoryManager, startAddress: LPVOID, size: SIZE_T): HRESULT {.stdcall.} + ReleasedVirtualAddressSpace*: proc(self: ptr IHostMemoryManager, startAddress: LPVOID): HRESULT {.stdcall.} + ICLRTask* {.pure.} = object + lpVtbl*: ptr ICLRTaskVtbl + ICLRTaskVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SwitchIn*: proc(self: ptr ICLRTask, threadHandle: HANDLE): HRESULT {.stdcall.} + SwitchOut*: proc(self: ptr ICLRTask): HRESULT {.stdcall.} + GetMemStats*: proc(self: ptr ICLRTask, memUsage: ptr COR_GC_THREAD_STATS): HRESULT {.stdcall.} + Reset*: proc(self: ptr ICLRTask, fFull: BOOL): HRESULT {.stdcall.} + ExitTask*: proc(self: ptr ICLRTask): HRESULT {.stdcall.} + Abort*: proc(self: ptr ICLRTask): HRESULT {.stdcall.} + RudeAbort*: proc(self: ptr ICLRTask): HRESULT {.stdcall.} + NeedsPriorityScheduling*: proc(self: ptr ICLRTask, pbNeedsPriorityScheduling: ptr BOOL): HRESULT {.stdcall.} + YieldTask*: proc(self: ptr ICLRTask): HRESULT {.stdcall.} + LocksHeld*: proc(self: ptr ICLRTask, pLockCount: ptr SIZE_T): HRESULT {.stdcall.} + SetTaskIdentifier*: proc(self: ptr ICLRTask, asked: TASKID): HRESULT {.stdcall.} + ICLRTask2* {.pure.} = object + lpVtbl*: ptr ICLRTask2Vtbl + ICLRTask2Vtbl* {.pure, inheritable.} = object of ICLRTaskVtbl + BeginPreventAsyncAbort*: proc(self: ptr ICLRTask2): HRESULT {.stdcall.} + EndPreventAsyncAbort*: proc(self: ptr ICLRTask2): HRESULT {.stdcall.} + IHostTask* {.pure.} = object + lpVtbl*: ptr IHostTaskVtbl + IHostTaskVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Start*: proc(self: ptr IHostTask): HRESULT {.stdcall.} + Alert*: proc(self: ptr IHostTask): HRESULT {.stdcall.} + Join*: proc(self: ptr IHostTask, dwMilliseconds: DWORD, option: DWORD): HRESULT {.stdcall.} + SetPriority*: proc(self: ptr IHostTask, newPriority: int32): HRESULT {.stdcall.} + GetPriority*: proc(self: ptr IHostTask, pPriority: ptr int32): HRESULT {.stdcall.} + SetCLRTask*: proc(self: ptr IHostTask, pCLRTask: ptr ICLRTask): HRESULT {.stdcall.} + ICLRTaskManager* {.pure.} = object + lpVtbl*: ptr ICLRTaskManagerVtbl + ICLRTaskManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateTask*: proc(self: ptr ICLRTaskManager, pTask: ptr ptr ICLRTask): HRESULT {.stdcall.} + GetCurrentTask*: proc(self: ptr ICLRTaskManager, pTask: ptr ptr ICLRTask): HRESULT {.stdcall.} + SetUILocale*: proc(self: ptr ICLRTaskManager, lcid: LCID): HRESULT {.stdcall.} + SetLocale*: proc(self: ptr ICLRTaskManager, lcid: LCID): HRESULT {.stdcall.} + GetCurrentTaskType*: proc(self: ptr ICLRTaskManager, pTaskType: ptr ETaskType): HRESULT {.stdcall.} + IHostTaskManager* {.pure.} = object + lpVtbl*: ptr IHostTaskManagerVtbl + IHostTaskManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentTask*: proc(self: ptr IHostTaskManager, pTask: ptr ptr IHostTask): HRESULT {.stdcall.} + CreateTask*: proc(self: ptr IHostTaskManager, dwStackSize: DWORD, pStartAddress: LPTHREAD_START_ROUTINE, pParameter: PVOID, ppTask: ptr ptr IHostTask): HRESULT {.stdcall.} + Sleep*: proc(self: ptr IHostTaskManager, dwMilliseconds: DWORD, option: DWORD): HRESULT {.stdcall.} + SwitchToTask*: proc(self: ptr IHostTaskManager, option: DWORD): HRESULT {.stdcall.} + SetUILocale*: proc(self: ptr IHostTaskManager, lcid: LCID): HRESULT {.stdcall.} + SetLocale*: proc(self: ptr IHostTaskManager, lcid: LCID): HRESULT {.stdcall.} + CallNeedsHostHook*: proc(self: ptr IHostTaskManager, target: SIZE_T, pbCallNeedsHostHook: ptr BOOL): HRESULT {.stdcall.} + LeaveRuntime*: proc(self: ptr IHostTaskManager, target: SIZE_T): HRESULT {.stdcall.} + EnterRuntime*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + ReverseLeaveRuntime*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + ReverseEnterRuntime*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + BeginDelayAbort*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + EndDelayAbort*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + BeginThreadAffinity*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + EndThreadAffinity*: proc(self: ptr IHostTaskManager): HRESULT {.stdcall.} + SetStackGuarantee*: proc(self: ptr IHostTaskManager, guarantee: ULONG): HRESULT {.stdcall.} + GetStackGuarantee*: proc(self: ptr IHostTaskManager, pGuarantee: ptr ULONG): HRESULT {.stdcall.} + SetCLRTaskManager*: proc(self: ptr IHostTaskManager, ppManager: ptr ICLRTaskManager): HRESULT {.stdcall.} + IHostThreadpoolManager* {.pure.} = object + lpVtbl*: ptr IHostThreadpoolManagerVtbl + IHostThreadpoolManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueueUserWorkItem*: proc(self: ptr IHostThreadpoolManager, Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG): HRESULT {.stdcall.} + SetMaxThreads*: proc(self: ptr IHostThreadpoolManager, dwMaxWorkerThreads: DWORD): HRESULT {.stdcall.} + GetMaxThreads*: proc(self: ptr IHostThreadpoolManager, pdwMaxWorkerThreads: ptr DWORD): HRESULT {.stdcall.} + GetAvailableThreads*: proc(self: ptr IHostThreadpoolManager, pdwAvailableWorkerThreads: ptr DWORD): HRESULT {.stdcall.} + SetMinThreads*: proc(self: ptr IHostThreadpoolManager, dwMinIOCompletionThreads: DWORD): HRESULT {.stdcall.} + GetMinThreads*: proc(self: ptr IHostThreadpoolManager, pdwMinIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + ICLRIoCompletionManager* {.pure.} = object + lpVtbl*: ptr ICLRIoCompletionManagerVtbl + ICLRIoCompletionManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnComplete*: proc(self: ptr ICLRIoCompletionManager, dwErrorCode: DWORD, NumberOfBytesTransferred: DWORD, pvOverlapped: pointer): HRESULT {.stdcall.} + IHostIoCompletionManager* {.pure.} = object + lpVtbl*: ptr IHostIoCompletionManagerVtbl + IHostIoCompletionManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateIoCompletionPort*: proc(self: ptr IHostIoCompletionManager, phPort: ptr HANDLE): HRESULT {.stdcall.} + CloseIoCompletionPort*: proc(self: ptr IHostIoCompletionManager, hPort: HANDLE): HRESULT {.stdcall.} + SetMaxThreads*: proc(self: ptr IHostIoCompletionManager, dwMaxIOCompletionThreads: DWORD): HRESULT {.stdcall.} + GetMaxThreads*: proc(self: ptr IHostIoCompletionManager, pdwMaxIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + GetAvailableThreads*: proc(self: ptr IHostIoCompletionManager, pdwAvailableIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + GetHostOverlappedSize*: proc(self: ptr IHostIoCompletionManager, pcbSize: ptr DWORD): HRESULT {.stdcall.} + SetCLRIoCompletionManager*: proc(self: ptr IHostIoCompletionManager, pManager: ptr ICLRIoCompletionManager): HRESULT {.stdcall.} + InitializeHostOverlapped*: proc(self: ptr IHostIoCompletionManager, pvOverlapped: pointer): HRESULT {.stdcall.} + Bind*: proc(self: ptr IHostIoCompletionManager, hPort: HANDLE, hHandle: HANDLE): HRESULT {.stdcall.} + SetMinThreads*: proc(self: ptr IHostIoCompletionManager, dwMinIOCompletionThreads: DWORD): HRESULT {.stdcall.} + GetMinThreads*: proc(self: ptr IHostIoCompletionManager, pdwMinIOCompletionThreads: ptr DWORD): HRESULT {.stdcall.} + ICLRDebugManager* {.pure.} = object + lpVtbl*: ptr ICLRDebugManagerVtbl + ICLRDebugManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BeginConnection*: proc(self: ptr ICLRDebugManager, dwConnectionId: CONNID, szConnectionName: ptr uint16): HRESULT {.stdcall.} + SetConnectionTasks*: proc(self: ptr ICLRDebugManager, id: CONNID, dwCount: DWORD, ppCLRTask: ptr ptr ICLRTask): HRESULT {.stdcall.} + EndConnection*: proc(self: ptr ICLRDebugManager, dwConnectionId: CONNID): HRESULT {.stdcall.} + SetDacl*: proc(self: ptr ICLRDebugManager, pacl: PACL): HRESULT {.stdcall.} + GetDacl*: proc(self: ptr ICLRDebugManager, pacl: ptr PACL): HRESULT {.stdcall.} + IsDebuggerAttached*: proc(self: ptr ICLRDebugManager, pbAttached: ptr BOOL): HRESULT {.stdcall.} + SetSymbolReadingPolicy*: proc(self: ptr ICLRDebugManager, policy: ESymbolReadingPolicy): HRESULT {.stdcall.} + ICLRErrorReportingManager* {.pure.} = object + lpVtbl*: ptr ICLRErrorReportingManagerVtbl + ICLRErrorReportingManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetBucketParametersForCurrentException*: proc(self: ptr ICLRErrorReportingManager, pParams: ptr BucketParameters): HRESULT {.stdcall.} + BeginCustomDump*: proc(self: ptr ICLRErrorReportingManager, dwFlavor: ECustomDumpFlavor, dwNumItems: DWORD, items: ptr CustomDumpItem, dwReserved: DWORD): HRESULT {.stdcall.} + EndCustomDump*: proc(self: ptr ICLRErrorReportingManager): HRESULT {.stdcall.} + IHostCrst* {.pure.} = object + lpVtbl*: ptr IHostCrstVtbl + IHostCrstVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Enter*: proc(self: ptr IHostCrst, option: DWORD): HRESULT {.stdcall.} + Leave*: proc(self: ptr IHostCrst): HRESULT {.stdcall.} + TryEnter*: proc(self: ptr IHostCrst, option: DWORD, pbSucceeded: ptr BOOL): HRESULT {.stdcall.} + SetSpinCount*: proc(self: ptr IHostCrst, dwSpinCount: DWORD): HRESULT {.stdcall.} + IHostAutoEvent* {.pure.} = object + lpVtbl*: ptr IHostAutoEventVtbl + IHostAutoEventVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Wait*: proc(self: ptr IHostAutoEvent, dwMilliseconds: DWORD, option: DWORD): HRESULT {.stdcall.} + Set*: proc(self: ptr IHostAutoEvent): HRESULT {.stdcall.} + IHostManualEvent* {.pure.} = object + lpVtbl*: ptr IHostManualEventVtbl + IHostManualEventVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Wait*: proc(self: ptr IHostManualEvent, dwMilliseconds: DWORD, option: DWORD): HRESULT {.stdcall.} + Reset*: proc(self: ptr IHostManualEvent): HRESULT {.stdcall.} + Set*: proc(self: ptr IHostManualEvent): HRESULT {.stdcall.} + IHostSemaphore* {.pure.} = object + lpVtbl*: ptr IHostSemaphoreVtbl + IHostSemaphoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Wait*: proc(self: ptr IHostSemaphore, dwMilliseconds: DWORD, option: DWORD): HRESULT {.stdcall.} + ReleaseSemaphore*: proc(self: ptr IHostSemaphore, lReleaseCount: LONG, lpPreviousCount: ptr LONG): HRESULT {.stdcall.} + ICLRSyncManager* {.pure.} = object + lpVtbl*: ptr ICLRSyncManagerVtbl + ICLRSyncManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetMonitorOwner*: proc(self: ptr ICLRSyncManager, Cookie: SIZE_T, ppOwnerHostTask: ptr ptr IHostTask): HRESULT {.stdcall.} + CreateRWLockOwnerIterator*: proc(self: ptr ICLRSyncManager, Cookie: SIZE_T, pIterator: ptr SIZE_T): HRESULT {.stdcall.} + GetRWLockOwnerNext*: proc(self: ptr ICLRSyncManager, Iterator: SIZE_T, ppOwnerHostTask: ptr ptr IHostTask): HRESULT {.stdcall.} + DeleteRWLockOwnerIterator*: proc(self: ptr ICLRSyncManager, Iterator: SIZE_T): HRESULT {.stdcall.} + IHostSyncManager* {.pure.} = object + lpVtbl*: ptr IHostSyncManagerVtbl + IHostSyncManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetCLRSyncManager*: proc(self: ptr IHostSyncManager, pManager: ptr ICLRSyncManager): HRESULT {.stdcall.} + CreateCrst*: proc(self: ptr IHostSyncManager, ppCrst: ptr ptr IHostCrst): HRESULT {.stdcall.} + CreateCrstWithSpinCount*: proc(self: ptr IHostSyncManager, dwSpinCount: DWORD, ppCrst: ptr ptr IHostCrst): HRESULT {.stdcall.} + CreateAutoEvent*: proc(self: ptr IHostSyncManager, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.stdcall.} + CreateManualEvent*: proc(self: ptr IHostSyncManager, bInitialState: BOOL, ppEvent: ptr ptr IHostManualEvent): HRESULT {.stdcall.} + CreateMonitorEvent*: proc(self: ptr IHostSyncManager, Cookie: SIZE_T, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.stdcall.} + CreateRWLockWriterEvent*: proc(self: ptr IHostSyncManager, Cookie: SIZE_T, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.stdcall.} + CreateRWLockReaderEvent*: proc(self: ptr IHostSyncManager, bInitialState: BOOL, Cookie: SIZE_T, ppEvent: ptr ptr IHostManualEvent): HRESULT {.stdcall.} + CreateSemaphore*: proc(self: ptr IHostSyncManager, dwInitial: DWORD, dwMax: DWORD, ppSemaphore: ptr ptr IHostSemaphore): HRESULT {.stdcall.} + ICLRPolicyManager* {.pure.} = object + lpVtbl*: ptr ICLRPolicyManagerVtbl + ICLRPolicyManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetDefaultAction*: proc(self: ptr ICLRPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.stdcall.} + SetTimeout*: proc(self: ptr ICLRPolicyManager, operation: EClrOperation, dwMilliseconds: DWORD): HRESULT {.stdcall.} + SetActionOnTimeout*: proc(self: ptr ICLRPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.stdcall.} + SetTimeoutAndAction*: proc(self: ptr ICLRPolicyManager, operation: EClrOperation, dwMilliseconds: DWORD, action: EPolicyAction): HRESULT {.stdcall.} + SetActionOnFailure*: proc(self: ptr ICLRPolicyManager, failure: EClrFailure, action: EPolicyAction): HRESULT {.stdcall.} + SetUnhandledExceptionPolicy*: proc(self: ptr ICLRPolicyManager, policy: EClrUnhandledException): HRESULT {.stdcall.} + IHostPolicyManager* {.pure.} = object + lpVtbl*: ptr IHostPolicyManagerVtbl + IHostPolicyManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnDefaultAction*: proc(self: ptr IHostPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.stdcall.} + OnTimeout*: proc(self: ptr IHostPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.stdcall.} + OnFailure*: proc(self: ptr IHostPolicyManager, failure: EClrFailure, action: EPolicyAction): HRESULT {.stdcall.} + IActionOnCLREvent* {.pure.} = object + lpVtbl*: ptr IActionOnCLREventVtbl + IActionOnCLREventVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnEvent*: proc(self: ptr IActionOnCLREvent, event: EClrEvent, data: PVOID): HRESULT {.stdcall.} + ICLROnEventManager* {.pure.} = object + lpVtbl*: ptr ICLROnEventManagerVtbl + ICLROnEventManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterActionOnEvent*: proc(self: ptr ICLROnEventManager, event: EClrEvent, pAction: ptr IActionOnCLREvent): HRESULT {.stdcall.} + UnregisterActionOnEvent*: proc(self: ptr ICLROnEventManager, event: EClrEvent, pAction: ptr IActionOnCLREvent): HRESULT {.stdcall.} + IHostGCManager* {.pure.} = object + lpVtbl*: ptr IHostGCManagerVtbl + IHostGCManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ThreadIsBlockingForSuspension*: proc(self: ptr IHostGCManager): HRESULT {.stdcall.} + SuspensionStarting*: proc(self: ptr IHostGCManager): HRESULT {.stdcall.} + SuspensionEnding*: proc(self: ptr IHostGCManager, Generation: DWORD): HRESULT {.stdcall.} + ICLRAssemblyReferenceList* {.pure.} = object + lpVtbl*: ptr ICLRAssemblyReferenceListVtbl + ICLRAssemblyReferenceListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsStringAssemblyReferenceInList*: proc(self: ptr ICLRAssemblyReferenceList, pwzAssemblyName: LPCWSTR): HRESULT {.stdcall.} + IsAssemblyReferenceInList*: proc(self: ptr ICLRAssemblyReferenceList, pName: ptr IUnknown): HRESULT {.stdcall.} + ICLRReferenceAssemblyEnum* {.pure.} = object + lpVtbl*: ptr ICLRReferenceAssemblyEnumVtbl + ICLRReferenceAssemblyEnumVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Get*: proc(self: ptr ICLRReferenceAssemblyEnum, dwIndex: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.stdcall.} + ICLRProbingAssemblyEnum* {.pure.} = object + lpVtbl*: ptr ICLRProbingAssemblyEnumVtbl + ICLRProbingAssemblyEnumVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Get*: proc(self: ptr ICLRProbingAssemblyEnum, dwIndex: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.stdcall.} + ICLRAssemblyIdentityManager* {.pure.} = object + lpVtbl*: ptr ICLRAssemblyIdentityManagerVtbl + ICLRAssemblyIdentityManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCLRAssemblyReferenceList*: proc(self: ptr ICLRAssemblyIdentityManager, ppwzAssemblyReferences: ptr LPCWSTR, dwNumOfReferences: DWORD, ppReferenceList: ptr ptr ICLRAssemblyReferenceList): HRESULT {.stdcall.} + GetBindingIdentityFromFile*: proc(self: ptr ICLRAssemblyIdentityManager, pwzFilePath: LPCWSTR, dwFlags: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.stdcall.} + GetBindingIdentityFromStream*: proc(self: ptr ICLRAssemblyIdentityManager, pStream: ptr IStream, dwFlags: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.stdcall.} + GetReferencedAssembliesFromFile*: proc(self: ptr ICLRAssemblyIdentityManager, pwzFilePath: LPCWSTR, dwFlags: DWORD, pExcludeAssembliesList: ptr ICLRAssemblyReferenceList, ppReferenceEnum: ptr ptr ICLRReferenceAssemblyEnum): HRESULT {.stdcall.} + GetReferencedAssembliesFromStream*: proc(self: ptr ICLRAssemblyIdentityManager, pStream: ptr IStream, dwFlags: DWORD, pExcludeAssembliesList: ptr ICLRAssemblyReferenceList, ppReferenceEnum: ptr ptr ICLRReferenceAssemblyEnum): HRESULT {.stdcall.} + GetProbingAssembliesFromReference*: proc(self: ptr ICLRAssemblyIdentityManager, dwMachineType: DWORD, dwFlags: DWORD, pwzReferenceIdentity: LPCWSTR, ppProbingAssemblyEnum: ptr ptr ICLRProbingAssemblyEnum): HRESULT {.stdcall.} + IsStronglyNamed*: proc(self: ptr ICLRAssemblyIdentityManager, pwzAssemblyIdentity: LPCWSTR, pbIsStronglyNamed: ptr BOOL): HRESULT {.stdcall.} + ICLRHostBindingPolicyManager* {.pure.} = object + lpVtbl*: ptr ICLRHostBindingPolicyManagerVtbl + ICLRHostBindingPolicyManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ModifyApplicationPolicy*: proc(self: ptr ICLRHostBindingPolicyManager, pwzSourceAssemblyIdentity: LPCWSTR, pwzTargetAssemblyIdentity: LPCWSTR, pbApplicationPolicy: ptr BYTE, cbAppPolicySize: DWORD, dwPolicyModifyFlags: DWORD, pbNewApplicationPolicy: ptr BYTE, pcbNewAppPolicySize: ptr DWORD): HRESULT {.stdcall.} + EvaluatePolicy*: proc(self: ptr ICLRHostBindingPolicyManager, pwzReferenceIdentity: LPCWSTR, pbApplicationPolicy: ptr BYTE, cbAppPolicySize: DWORD, pwzPostPolicyReferenceIdentity: LPWSTR, pcchPostPolicyReferenceIdentity: ptr DWORD, pdwPoliciesApplied: ptr DWORD): HRESULT {.stdcall.} + ICLRGCManager* {.pure.} = object + lpVtbl*: ptr ICLRGCManagerVtbl + ICLRGCManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Collect*: proc(self: ptr ICLRGCManager, Generation: LONG): HRESULT {.stdcall.} + GetStats*: proc(self: ptr ICLRGCManager, pStats: ptr COR_GC_STATS): HRESULT {.stdcall.} + SetGCStartupLimits*: proc(self: ptr ICLRGCManager, SegmentSize: DWORD, MaxGen0Size: DWORD): HRESULT {.stdcall.} + ICLRGCManager2* {.pure.} = object + lpVtbl*: ptr ICLRGCManager2Vtbl + ICLRGCManager2Vtbl* {.pure, inheritable.} = object of ICLRGCManagerVtbl + SetGCStartupLimitsEx*: proc(self: ptr ICLRGCManager2, SegmentSize: SIZE_T, MaxGen0Size: SIZE_T): HRESULT {.stdcall.} + IHostAssemblyStore* {.pure.} = object + lpVtbl*: ptr IHostAssemblyStoreVtbl + IHostAssemblyStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ProvideAssembly*: proc(self: ptr IHostAssemblyStore, pBindInfo: ptr AssemblyBindInfo, pAssemblyId: ptr UINT64, pContext: ptr UINT64, ppStmAssemblyImage: ptr ptr IStream, ppStmPDB: ptr ptr IStream): HRESULT {.stdcall.} + ProvideModule*: proc(self: ptr IHostAssemblyStore, pBindInfo: ptr ModuleBindInfo, pdwModuleId: ptr DWORD, ppStmModuleImage: ptr ptr IStream, ppStmPDB: ptr ptr IStream): HRESULT {.stdcall.} + IHostAssemblyManager* {.pure.} = object + lpVtbl*: ptr IHostAssemblyManagerVtbl + IHostAssemblyManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNonHostStoreAssemblies*: proc(self: ptr IHostAssemblyManager, ppReferenceList: ptr ptr ICLRAssemblyReferenceList): HRESULT {.stdcall.} + GetAssemblyStore*: proc(self: ptr IHostAssemblyManager, ppAssemblyStore: ptr ptr IHostAssemblyStore): HRESULT {.stdcall.} + IHostControl* {.pure.} = object + lpVtbl*: ptr IHostControlVtbl + IHostControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetHostManager*: proc(self: ptr IHostControl, riid: REFIID, ppObject: ptr pointer): HRESULT {.stdcall.} + SetAppDomainManager*: proc(self: ptr IHostControl, dwAppDomainID: DWORD, pUnkAppDomainManager: ptr IUnknown): HRESULT {.stdcall.} + ICLRControl* {.pure.} = object + lpVtbl*: ptr ICLRControlVtbl + ICLRControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCLRManager*: proc(self: ptr ICLRControl, riid: REFIID, ppObject: ptr pointer): HRESULT {.stdcall.} + SetAppDomainManagerType*: proc(self: ptr ICLRControl, pwzAppDomainManagerAssembly: LPCWSTR, pwzAppDomainManagerType: LPCWSTR): HRESULT {.stdcall.} + ICLRRuntimeHost* {.pure.} = object + lpVtbl*: ptr ICLRRuntimeHostVtbl + ICLRRuntimeHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Start*: proc(self: ptr ICLRRuntimeHost): HRESULT {.stdcall.} + Stop*: proc(self: ptr ICLRRuntimeHost): HRESULT {.stdcall.} + SetHostControl*: proc(self: ptr ICLRRuntimeHost, pHostControl: ptr IHostControl): HRESULT {.stdcall.} + GetCLRControl*: proc(self: ptr ICLRRuntimeHost, pCLRControl: ptr ptr ICLRControl): HRESULT {.stdcall.} + UnloadAppDomain*: proc(self: ptr ICLRRuntimeHost, dwAppDomainId: DWORD, fWaitUntilDone: BOOL): HRESULT {.stdcall.} + ExecuteInAppDomain*: proc(self: ptr ICLRRuntimeHost, dwAppDomainId: DWORD, pCallback: FExecuteInAppDomainCallback, cookie: pointer): HRESULT {.stdcall.} + GetCurrentAppDomainId*: proc(self: ptr ICLRRuntimeHost, pdwAppDomainId: ptr DWORD): HRESULT {.stdcall.} + ExecuteApplication*: proc(self: ptr ICLRRuntimeHost, pwzAppFullName: LPCWSTR, dwManifestPaths: DWORD, ppwzManifestPaths: ptr LPCWSTR, dwActivationData: DWORD, ppwzActivationData: ptr LPCWSTR, pReturnValue: ptr int32): HRESULT {.stdcall.} + ExecuteInDefaultAppDomain*: proc(self: ptr ICLRRuntimeHost, pwzAssemblyPath: LPCWSTR, pwzTypeName: LPCWSTR, pwzMethodName: LPCWSTR, pwzArgument: LPCWSTR, pReturnValue: ptr DWORD): HRESULT {.stdcall.} + ICLRHostProtectionManager* {.pure.} = object + lpVtbl*: ptr ICLRHostProtectionManagerVtbl + ICLRHostProtectionManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetProtectedCategories*: proc(self: ptr ICLRHostProtectionManager, categories: EApiCategories): HRESULT {.stdcall.} + SetEagerSerializeGrantSets*: proc(self: ptr ICLRHostProtectionManager): HRESULT {.stdcall.} + ICLRDomainManager* {.pure.} = object + lpVtbl*: ptr ICLRDomainManagerVtbl + ICLRDomainManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAppDomainManagerType*: proc(self: ptr ICLRDomainManager, wszAppDomainManagerAssembly: LPCWSTR, wszAppDomainManagerType: LPCWSTR, dwInitializeDomainFlags: EInitializeNewDomainFlags): HRESULT {.stdcall.} + SetPropertiesForDefaultAppDomain*: proc(self: ptr ICLRDomainManager, nProperties: DWORD, pwszPropertyNames: ptr LPCWSTR, pwszPropertyValues: ptr LPCWSTR): HRESULT {.stdcall.} + ITypeName* {.pure.} = object + lpVtbl*: ptr ITypeNameVtbl + ITypeNameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNameCount*: proc(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.stdcall.} + GetNames*: proc(self: ptr ITypeName, count: DWORD, rgbszNames: ptr BSTR, pCount: ptr DWORD): HRESULT {.stdcall.} + GetTypeArgumentCount*: proc(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.stdcall.} + GetTypeArguments*: proc(self: ptr ITypeName, count: DWORD, rgpArguments: ptr ptr ITypeName, pCount: ptr DWORD): HRESULT {.stdcall.} + GetModifierLength*: proc(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.stdcall.} + GetModifiers*: proc(self: ptr ITypeName, count: DWORD, rgModifiers: ptr DWORD, pCount: ptr DWORD): HRESULT {.stdcall.} + GetAssemblyName*: proc(self: ptr ITypeName, rgbszAssemblyNames: ptr BSTR): HRESULT {.stdcall.} + ITypeNameBuilder* {.pure.} = object + lpVtbl*: ptr ITypeNameBuilderVtbl + ITypeNameBuilderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OpenGenericArguments*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + CloseGenericArguments*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + OpenGenericArgument*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + CloseGenericArgument*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + AddName*: proc(self: ptr ITypeNameBuilder, szName: LPCWSTR): HRESULT {.stdcall.} + AddPointer*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + AddByRef*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + AddSzArray*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + AddArray*: proc(self: ptr ITypeNameBuilder, rank: DWORD): HRESULT {.stdcall.} + AddAssemblySpec*: proc(self: ptr ITypeNameBuilder, szAssemblySpec: LPCWSTR): HRESULT {.stdcall.} + ToString*: proc(self: ptr ITypeNameBuilder, pszStringRepresentation: ptr BSTR): HRESULT {.stdcall.} + Clear*: proc(self: ptr ITypeNameBuilder): HRESULT {.stdcall.} + ITypeNameFactory* {.pure.} = object + lpVtbl*: ptr ITypeNameFactoryVtbl + ITypeNameFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseTypeName*: proc(self: ptr ITypeNameFactory, szName: LPCWSTR, pError: ptr DWORD, ppTypeName: ptr ptr ITypeName): HRESULT {.stdcall.} + GetTypeNameBuilder*: proc(self: ptr ITypeNameFactory, ppTypeBuilder: ptr ptr ITypeNameBuilder): HRESULT {.stdcall.} + IApartmentCallback* {.pure.} = object + lpVtbl*: ptr IApartmentCallbackVtbl + IApartmentCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DoCallback*: proc(self: ptr IApartmentCallback, pFunc: SIZE_T, pData: SIZE_T): HRESULT {.stdcall.} + IManagedObject* {.pure.} = object + lpVtbl*: ptr IManagedObjectVtbl + IManagedObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSerializedBuffer*: proc(self: ptr IManagedObject, pBSTR: ptr BSTR): HRESULT {.stdcall.} + GetObjectIdentity*: proc(self: ptr IManagedObject, pBSTRGUID: ptr BSTR, AppDomainID: ptr int32, pCCW: ptr int32): HRESULT {.stdcall.} + ICatalogServices* {.pure.} = object + lpVtbl*: ptr ICatalogServicesVtbl + ICatalogServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Autodone*: proc(self: ptr ICatalogServices): HRESULT {.stdcall.} + NotAutodone*: proc(self: ptr ICatalogServices): HRESULT {.stdcall.} + IHostSecurityContext* {.pure.} = object + lpVtbl*: ptr IHostSecurityContextVtbl + IHostSecurityContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Capture*: proc(self: ptr IHostSecurityContext, ppClonedContext: ptr ptr IHostSecurityContext): HRESULT {.stdcall.} + IHostSecurityManager* {.pure.} = object + lpVtbl*: ptr IHostSecurityManagerVtbl + IHostSecurityManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ImpersonateLoggedOnUser*: proc(self: ptr IHostSecurityManager, hToken: HANDLE): HRESULT {.stdcall.} + RevertToSelf*: proc(self: ptr IHostSecurityManager): HRESULT {.stdcall.} + OpenThreadToken*: proc(self: ptr IHostSecurityManager, dwDesiredAccess: DWORD, bOpenAsSelf: BOOL, phThreadToken: ptr HANDLE): HRESULT {.stdcall.} + SetThreadToken*: proc(self: ptr IHostSecurityManager, hToken: HANDLE): HRESULT {.stdcall.} + GetSecurityContext*: proc(self: ptr IHostSecurityManager, eContextType: EContextType, ppSecurityContext: ptr ptr IHostSecurityContext): HRESULT {.stdcall.} + SetSecurityContext*: proc(self: ptr IHostSecurityManager, eContextType: EContextType, pSecurityContext: ptr IHostSecurityContext): HRESULT {.stdcall.} + ICLRAppDomainResourceMonitor* {.pure.} = object + lpVtbl*: ptr ICLRAppDomainResourceMonitorVtbl + ICLRAppDomainResourceMonitorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentAllocated*: proc(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pBytesAllocated: ptr ULONGLONG): HRESULT {.stdcall.} + GetCurrentSurvived*: proc(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pAppDomainBytesSurvived: ptr ULONGLONG, pTotalBytesSurvived: ptr ULONGLONG): HRESULT {.stdcall.} + GetCurrentCpuTime*: proc(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pMilliseconds: ptr ULONGLONG): HRESULT {.stdcall.} + ICLRMetaHost* {.pure.} = object + lpVtbl*: ptr ICLRMetaHostVtbl + ICLRMetaHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRuntime*: proc(self: ptr ICLRMetaHost, pwzVersion: LPCWSTR, riid: REFIID, ppRuntime: ptr LPVOID): HRESULT {.stdcall.} + GetVersionFromFile*: proc(self: ptr ICLRMetaHost, pwzFilePath: LPCWSTR, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.stdcall.} + EnumerateInstalledRuntimes*: proc(self: ptr ICLRMetaHost, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + EnumerateLoadedRuntimes*: proc(self: ptr ICLRMetaHost, hndProcess: HANDLE, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + RequestRuntimeLoadedNotification*: proc(self: ptr ICLRMetaHost, pCallbackFunction: RuntimeLoadedCallbackFnPtr): HRESULT {.stdcall.} + QueryLegacyV2RuntimeBinding*: proc(self: ptr ICLRMetaHost, riid: REFIID, ppUnk: ptr LPVOID): HRESULT {.stdcall.} + ExitProcess*: proc(self: ptr ICLRMetaHost, iExitCode: INT32): HRESULT {.stdcall.} + ICLRMetaHostPolicy* {.pure.} = object + lpVtbl*: ptr ICLRMetaHostPolicyVtbl + ICLRMetaHostPolicyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRequestedRuntime*: proc(self: ptr ICLRMetaHostPolicy, dwPolicyFlags: METAHOST_POLICY_FLAGS, pwzBinary: LPCWSTR, pCfgStream: ptr IStream, pwzVersion: LPWSTR, pcchVersion: ptr DWORD, pwzImageVersion: LPWSTR, pcchImageVersion: ptr DWORD, pdwConfigFlags: ptr DWORD, riid: REFIID, ppRuntime: ptr LPVOID): HRESULT {.stdcall.} + ICLRProfiling* {.pure.} = object + lpVtbl*: ptr ICLRProfilingVtbl + ICLRProfilingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AttachProfiler*: proc(self: ptr ICLRProfiling, dwProfileeProcessID: DWORD, dwMillisecondsMax: DWORD, pClsidProfiler: ptr CLSID, wszProfilerPath: LPCWSTR, pvClientData: pointer, cbClientData: UINT): HRESULT {.stdcall.} + ICLRDebuggingLibraryProvider* {.pure.} = object + lpVtbl*: ptr ICLRDebuggingLibraryProviderVtbl + ICLRDebuggingLibraryProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ProvideLibrary*: proc(self: ptr ICLRDebuggingLibraryProvider, pwszFileName: ptr WCHAR, dwTimestamp: DWORD, dwSizeOfImage: DWORD, phModule: ptr HMODULE): HRESULT {.stdcall.} + ICLRDebugging* {.pure.} = object + lpVtbl*: ptr ICLRDebuggingVtbl + ICLRDebuggingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OpenVirtualProcess*: proc(self: ptr ICLRDebugging, moduleBaseAddress: ULONG64, pDataTarget: ptr IUnknown, pLibraryProvider: ptr ICLRDebuggingLibraryProvider, pMaxDebuggerSupportedVersion: ptr CLR_DEBUGGING_VERSION, riidProcess: REFIID, ppProcess: ptr ptr IUnknown, pVersion: ptr CLR_DEBUGGING_VERSION, pdwFlags: ptr CLR_DEBUGGING_PROCESS_FLAGS): HRESULT {.stdcall.} + CanUnloadNow*: proc(self: ptr ICLRDebugging, hModule: HMODULE): HRESULT {.stdcall.} + ICLRStrongName* {.pure.} = object + lpVtbl*: ptr ICLRStrongNameVtbl + ICLRStrongNameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetHashFromAssemblyFile*: proc(self: ptr ICLRStrongName, pszFilePath: LPCSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + GetHashFromAssemblyFileW*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + GetHashFromBlob*: proc(self: ptr ICLRStrongName, pbBlob: ptr BYTE, cchBlob: DWORD, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + GetHashFromFile*: proc(self: ptr ICLRStrongName, pszFilePath: LPCSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + GetHashFromFileW*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + GetHashFromHandle*: proc(self: ptr ICLRStrongName, hFile: HANDLE, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.stdcall.} + StrongNameCompareAssemblies*: proc(self: ptr ICLRStrongName, pwzAssembly1: LPCWSTR, pwzAssembly2: LPCWSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + StrongNameFreeBuffer*: proc(self: ptr ICLRStrongName, pbMemory: ptr BYTE): HRESULT {.stdcall.} + StrongNameGetBlob*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, pbBlob: ptr BYTE, pcbBlob: ptr DWORD): HRESULT {.stdcall.} + StrongNameGetBlobFromImage*: proc(self: ptr ICLRStrongName, pbBase: ptr BYTE, dwLength: DWORD, pbBlob: ptr BYTE, pcbBlob: ptr DWORD): HRESULT {.stdcall.} + StrongNameGetPublicKey*: proc(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG): HRESULT {.stdcall.} + StrongNameHashSize*: proc(self: ptr ICLRStrongName, ulHashAlg: ULONG, pcbSize: ptr DWORD): HRESULT {.stdcall.} + StrongNameKeyDelete*: proc(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR): HRESULT {.stdcall.} + StrongNameKeyGen*: proc(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, dwFlags: DWORD, ppbKeyBlob: ptr ptr BYTE, pcbKeyBlob: ptr ULONG): HRESULT {.stdcall.} + StrongNameKeyGenEx*: proc(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, dwFlags: DWORD, dwKeySize: DWORD, ppbKeyBlob: ptr ptr BYTE, pcbKeyBlob: ptr ULONG): HRESULT {.stdcall.} + StrongNameKeyInstall*: proc(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG): HRESULT {.stdcall.} + StrongNameSignatureGeneration*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG): HRESULT {.stdcall.} + StrongNameSignatureGenerationEx*: proc(self: ptr ICLRStrongName, wszFilePath: LPCWSTR, wszKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.stdcall.} + StrongNameSignatureSize*: proc(self: ptr ICLRStrongName, pbPublicKeyBlob: ptr BYTE, cbPublicKeyBlob: ULONG, pcbSize: ptr DWORD): HRESULT {.stdcall.} + StrongNameSignatureVerification*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, dwInFlags: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.stdcall.} + StrongNameSignatureVerificationEx*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, fForceVerification: BOOLEAN, pfWasVerified: ptr BOOLEAN): HRESULT {.stdcall.} + StrongNameSignatureVerificationFromImage*: proc(self: ptr ICLRStrongName, pbBase: ptr BYTE, dwLength: DWORD, dwInFlags: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.stdcall.} + StrongNameTokenFromAssembly*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG): HRESULT {.stdcall.} + StrongNameTokenFromAssemblyEx*: proc(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG): HRESULT {.stdcall.} + StrongNameTokenFromPublicKey*: proc(self: ptr ICLRStrongName, pbPublicKeyBlob: ptr BYTE, cbPublicKeyBlob: ULONG, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG): HRESULT {.stdcall.} + ICLRStrongName2* {.pure.} = object + lpVtbl*: ptr ICLRStrongName2Vtbl + ICLRStrongName2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + StrongNameGetPublicKeyEx*: proc(self: ptr ICLRStrongName2, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG, uHashAlgId: ULONG, uReserved: ULONG): HRESULT {.stdcall.} + StrongNameSignatureVerificationEx2*: proc(self: ptr ICLRStrongName2, wszFilePath: LPCWSTR, fForceVerification: BOOLEAN, pbEcmaPublicKey: ptr BYTE, cbEcmaPublicKey: DWORD, pfWasVerified: ptr BOOLEAN): HRESULT {.stdcall.} + ICLRStrongName3* {.pure.} = object + lpVtbl*: ptr ICLRStrongName3Vtbl + ICLRStrongName3Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + StrongNameDigestGenerate*: proc(self: ptr ICLRStrongName3, wszFilePath: LPCWSTR, ppbDigestBlob: ptr ptr BYTE, pcbDigestBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.stdcall.} + StrongNameDigestSign*: proc(self: ptr ICLRStrongName3, wszKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, pbDigestBlob: ptr BYTE, cbDigestBlob: ULONG, hashAlgId: DWORD, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.stdcall.} + StrongNameDigestEmbed*: proc(self: ptr ICLRStrongName3, wszFilePath: LPCWSTR, pbSignatureBlob: ptr BYTE, cbSignatureBlob: ULONG): HRESULT {.stdcall.} + IMethodInfo* {.pure.} = object + lpVtbl*: ptr IMethodInfoVtbl + IMethodInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTypeInfoCount*: proc(self: ptr IMethodInfo, pcTInfo: ptr int32): HRESULT {.stdcall.} + GetTypeInfo*: proc(self: ptr IMethodInfo, iTInfo: int32, lcid: int32, ppTInfo: int32): HRESULT {.stdcall.} + GetIDsOfNames*: proc(self: ptr IMethodInfo, riid: ptr GUID, rgszNames: int32, cNames: int32, lcid: int32, rgDispId: int32): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IMethodInfo, dispIdMember: int32, riid: ptr GUID, lcid: int32, wFlags: int16, pDispParams: int32, pVarResult: int32, pExcepInfo: int32, puArgErr: int32): HRESULT {.stdcall.} + get_ToString*: proc(self: ptr IMethodInfo, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr IMethodInfo, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr IMethodInfo, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_MemberType*: proc(self: ptr IMethodInfo, pRetVal: ptr MemberTypes): HRESULT {.stdcall.} + get_name*: proc(self: ptr IMethodInfo, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_DeclaringType*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_ReflectedType*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetCustomAttributes*: proc(self: ptr IMethodInfo, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetCustomAttributes_2*: proc(self: ptr IMethodInfo, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IsDefined*: proc(self: ptr IMethodInfo, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetParameters*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetMethodImplementationFlags*: proc(self: ptr IMethodInfo, pRetVal: ptr MethodImplAttributes): HRESULT {.stdcall.} + get_MethodHandle*: proc(self: ptr IMethodInfo, pRetVal: POBJECT): HRESULT {.stdcall.} + get_Attributes*: proc(self: ptr IMethodInfo, pRetVal: ptr MethodAttributes): HRESULT {.stdcall.} + get_CallingConvention*: proc(self: ptr IMethodInfo, pRetVal: ptr CallingConventions): HRESULT {.stdcall.} + Invoke_2*: proc(self: ptr IMethodInfo, obj: VARIANT, invokeAttr: BindingFlags, Binder: POBJECT, parameters: ptr SAFEARRAY, culture: POBJECT, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + get_IsPublic*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsPrivate*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFamily*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAssembly*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFamilyAndAssembly*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFamilyOrAssembly*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsStatic*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFinal*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsVirtual*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsHideBySig*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAbstract*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsSpecialName*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsConstructor*: proc(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + Invoke_3*: proc(self: ptr IMethodInfo, obj: VARIANT, parameters: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + get_returnType*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_ReturnTypeCustomAttributes*: proc(self: ptr IMethodInfo, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetBaseDefinition*: proc(self: ptr IMethodInfo, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + IAssembly* {.pure.} = object + lpVtbl*: ptr IAssemblyVtbl + IAssemblyVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_ToString*: proc(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr IAssembly, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr IAssembly, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr IAssembly, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_CodeBase*: proc(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_EscapedCodeBase*: proc(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.stdcall.} + GetName*: proc(self: ptr IAssembly, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetName_2*: proc(self: ptr IAssembly, copiedName: VARIANT_BOOL, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + get_FullName*: proc(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_EntryPoint*: proc(self: ptr IAssembly, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetType_2*: proc(self: ptr IAssembly, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetType_3*: proc(self: ptr IAssembly, name: BSTR, throwOnError: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetExportedTypes*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetTypes*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetManifestResourceStream*: proc(self: ptr IAssembly, Type: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetManifestResourceStream_2*: proc(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetFile*: proc(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetFiles*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetFiles_2*: proc(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetManifestResourceNames*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetManifestResourceInfo*: proc(self: ptr IAssembly, resourceName: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + get_Location*: proc(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_Evidence*: proc(self: ptr IAssembly, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetCustomAttributes*: proc(self: ptr IAssembly, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetCustomAttributes_2*: proc(self: ptr IAssembly, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IsDefined*: proc(self: ptr IAssembly, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetObjectData*: proc(self: ptr IAssembly, info: POBJECT, Context: StreamingContext): HRESULT {.stdcall.} + add_ModuleResolve*: proc(self: ptr IAssembly, value: POBJECT): HRESULT {.stdcall.} + remove_ModuleResolve*: proc(self: ptr IAssembly, value: POBJECT): HRESULT {.stdcall.} + GetType_4*: proc(self: ptr IAssembly, name: BSTR, throwOnError: VARIANT_BOOL, ignoreCase: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetSatelliteAssembly*: proc(self: ptr IAssembly, culture: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + GetSatelliteAssembly_2*: proc(self: ptr IAssembly, culture: POBJECT, Version: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + LoadModule*: proc(self: ptr IAssembly, moduleName: BSTR, rawModule: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + LoadModule_2*: proc(self: ptr IAssembly, moduleName: BSTR, rawModule: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + CreateInstance*: proc(self: ptr IAssembly, typeName: BSTR, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + CreateInstance_2*: proc(self: ptr IAssembly, typeName: BSTR, ignoreCase: VARIANT_BOOL, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + CreateInstance_3*: proc(self: ptr IAssembly, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + GetLoadedModules*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetLoadedModules_2*: proc(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetModules*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetModules_2*: proc(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetModule*: proc(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetReferencedAssemblies*: proc(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_GlobalAssemblyCache*: proc(self: ptr IAssembly, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IType* {.pure.} = object + lpVtbl*: ptr ITypeVtbl + ITypeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTypeInfoCount*: proc(self: ptr IType, pcTInfo: ptr int32): HRESULT {.stdcall.} + GetTypeInfo*: proc(self: ptr IType, iTInfo: int32, lcid: int32, ppTInfo: int32): HRESULT {.stdcall.} + GetIDsOfNames*: proc(self: ptr IType, riid: ptr GUID, rgszNames: int32, cNames: int32, lcid: int32, rgDispId: int32): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IType, dispIdMember: int32, riid: ptr GUID, lcid: int32, wFlags: int16, pDispParams: int32, pVarResult: int32, pExcepInfo: int32, puArgErr: int32): HRESULT {.stdcall.} + get_ToString*: proc(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr IType, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr IType, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_MemberType*: proc(self: ptr IType, pRetVal: ptr MemberTypes): HRESULT {.stdcall.} + get_name*: proc(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_DeclaringType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + get_ReflectedType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetCustomAttributes*: proc(self: ptr IType, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetCustomAttributes_2*: proc(self: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IsDefined*: proc(self: ptr IType, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_Guid*: proc(self: ptr IType, pRetVal: ptr GUID): HRESULT {.stdcall.} + get_Module*: proc(self: ptr IType, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + getIAssembly*: proc(self: ptr IType, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + get_TypeHandle*: proc(self: ptr IType, pRetVal: POBJECT): HRESULT {.stdcall.} + get_FullName*: proc(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_Namespace*: proc(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_AssemblyQualifiedName*: proc(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.stdcall.} + GetArrayRank*: proc(self: ptr IType, pRetVal: ptr int32): HRESULT {.stdcall.} + get_BaseType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetConstructors*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetInterface*: proc(self: ptr IType, name: BSTR, ignoreCase: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetInterfaces*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + FindInterfaces*: proc(self: ptr IType, filter: POBJECT, filterCriteria: VARIANT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetEvent*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetEvents*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetEvents_2*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetNestedTypes*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetNestedType*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetMember*: proc(self: ptr IType, name: BSTR, Type: MemberTypes, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetDefaultMembers*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + FindMembers*: proc(self: ptr IType, MemberType: MemberTypes, bindingAttr: BindingFlags, filter: POBJECT, filterCriteria: VARIANT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetElementType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + IsSubclassOf*: proc(self: ptr IType, c: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IsInstanceOfType*: proc(self: ptr IType, o: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IsAssignableFrom*: proc(self: ptr IType, c: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetInterfaceMap*: proc(self: ptr IType, interfaceType: ptr IType, pRetVal: POBJECT): HRESULT {.stdcall.} + GetMethod*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethod_2*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethods*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetField*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetFields*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_2*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, returnType: ptr IType, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperties*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetMember_2*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetMembers*: proc(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + InvokeMember*: proc(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, culture: POBJECT, namedParameters: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + get_UnderlyingSystemType*: proc(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + InvokeMember_2*: proc(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, culture: POBJECT, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + InvokeMember_3*: proc(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + GetConstructor*: proc(self: ptr IType, bindingAttr: BindingFlags, Binder: POBJECT, callConvention: CallingConventions, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetConstructor_2*: proc(self: ptr IType, bindingAttr: BindingFlags, Binder: POBJECT, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetConstructor_3*: proc(self: ptr IType, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetConstructors_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_TypeInitializer*: proc(self: ptr IType, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetMethod_3*: proc(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, callConvention: CallingConventions, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethod_4*: proc(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethod_5*: proc(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethod_6*: proc(self: ptr IType, name: BSTR, pRetVal: ptr ptr IMethodInfo): HRESULT {.stdcall.} + GetMethods_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetField_2*: proc(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetFields_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetInterface_2*: proc(self: ptr IType, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetEvent_2*: proc(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_3*: proc(self: ptr IType, name: BSTR, returnType: ptr IType, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_4*: proc(self: ptr IType, name: BSTR, returnType: ptr IType, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_5*: proc(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_6*: proc(self: ptr IType, name: BSTR, returnType: ptr IType, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperty_7*: proc(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + GetProperties_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetNestedTypes_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetNestedType_2*: proc(self: ptr IType, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetMember_3*: proc(self: ptr IType, name: BSTR, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetMembers_2*: proc(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_Attributes*: proc(self: ptr IType, pRetVal: ptr TypeAttributes): HRESULT {.stdcall.} + get_IsNotPublic*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsPublic*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedPublic*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedPrivate*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedFamily*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedAssembly*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedFamANDAssem*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsNestedFamORAssem*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAutoLayout*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsLayoutSequential*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsExplicitLayout*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsClass*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsInterface*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsValueType*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAbstract*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsSealed*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsEnum*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsSpecialName*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsImport*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsSerializable*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAnsiClass*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsUnicodeClass*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsAutoClass*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsArray*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsByRef*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsPointer*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsPrimitive*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsCOMObject*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_HasElementType*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsContextful*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsMarshalByRef*: proc(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + Equals_2*: proc(self: ptr IType, o: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IObject* {.pure.} = object + lpVtbl*: ptr IObjectVtbl + IObjectVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_ToString*: proc(self: ptr IObject, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr IObject, obj: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr IObject, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr IObject, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + IAppDomainSetup* {.pure.} = object + lpVtbl*: ptr IAppDomainSetupVtbl + IAppDomainSetupVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_ApplicationBase*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_ApplicationBase*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_ApplicationName*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_ApplicationName*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_CachePath*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_CachePath*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_ConfigurationFile*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_ConfigurationFile*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_DynamicBase*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_DynamicBase*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_LicenseFile*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_LicenseFile*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_PrivateBinPath*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_PrivateBinPath*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_PrivateBinPathProbe*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_PrivateBinPathProbe*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_ShadowCopyDirectories*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_ShadowCopyDirectories*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + get_ShadowCopyFiles*: proc(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.stdcall.} + put_ShadowCopyFiles*: proc(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.stdcall.} + ObjectHandle* {.pure.} = object + lpVtbl*: ptr ObjectHandleVtbl + ObjectHandleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_ToString*: proc(self: ptr ObjectHandle, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr ObjectHandle, obj: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr ObjectHandle, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr ObjectHandle, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + GetLifetimeService*: proc(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + InitializeLifetimeService*: proc(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + CreateObjRef*: proc(self: ptr ObjectHandle, requestedType: ptr IType, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + Unwrap*: proc(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + AppDomain* {.pure.} = object + lpVtbl*: ptr AppDomainVtbl + AppDomainVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_ToString*: proc(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Equals*: proc(self: ptr AppDomain, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetHashCode*: proc(self: ptr AppDomain, pRetVal: ptr int32): HRESULT {.stdcall.} + GetType*: proc(self: ptr AppDomain, pRetVal: ptr ptr IType): HRESULT {.stdcall.} + InitializeLifetimeService*: proc(self: ptr AppDomain, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + GetLifetimeService*: proc(self: ptr AppDomain, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + get_Evidence*: proc(self: ptr AppDomain, pRetVal: ptr POBJECT): HRESULT {.stdcall.} + add_DomainUnload*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_DomainUnload*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_AssemblyLoad*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_AssemblyLoad*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_ProcessExit*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_ProcessExit*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_TypeResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_TypeResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_ResourceResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_ResourceResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_AssemblyResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_AssemblyResolve*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + add_UnhandledException*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + remove_UnhandledException*: proc(self: ptr AppDomain, value: POBJECT): HRESULT {.stdcall.} + DefineDynamicAssembly*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_2*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_3*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, Evidence: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_4*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_5*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_6*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_7*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_8*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + DefineDynamicAssembly_9*: proc(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, IsSynchronized: VARIANT_BOOL, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.stdcall.} + CreateInstance*: proc(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + CreateInstanceFrom*: proc(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + CreateInstance_2*: proc(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, activationAttributes: ptr SAFEARRAY, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + CreateInstanceFrom_2*: proc(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, activationAttributes: ptr SAFEARRAY, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + CreateInstance_3*: proc(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, securityAttributes: POBJECT, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + CreateInstanceFrom_3*: proc(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, securityAttributes: POBJECT, pRetVal: ptr ptr ObjectHandle): HRESULT {.stdcall.} + Load*: proc(self: ptr AppDomain, assemblyRef: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_2*: proc(self: ptr AppDomain, assemblyString: BSTR, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_3*: proc(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_4*: proc(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_5*: proc(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, securityEvidence: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_6*: proc(self: ptr AppDomain, assemblyRef: POBJECT, assemblySecurity: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + Load_7*: proc(self: ptr AppDomain, assemblyString: BSTR, assemblySecurity: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.stdcall.} + ExecuteAssembly*: proc(self: ptr AppDomain, assemblyFile: BSTR, assemblySecurity: POBJECT, pRetVal: ptr int32): HRESULT {.stdcall.} + ExecuteAssembly_2*: proc(self: ptr AppDomain, assemblyFile: BSTR, pRetVal: ptr int32): HRESULT {.stdcall.} + ExecuteAssembly_3*: proc(self: ptr AppDomain, assemblyFile: BSTR, assemblySecurity: POBJECT, args: ptr SAFEARRAY, pRetVal: ptr int32): HRESULT {.stdcall.} + get_FriendlyName*: proc(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_BaseDirectory*: proc(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_RelativeSearchPath*: proc(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_ShadowCopyFiles*: proc(self: ptr AppDomain, pRetVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + GetAssemblies*: proc(self: ptr AppDomain, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + AppendPrivatePath*: proc(self: ptr AppDomain, Path: BSTR): HRESULT {.stdcall.} + ClearPrivatePath*: proc(self: ptr AppDomain): HRESULT {.stdcall.} + SetShadowCopyPath*: proc(self: ptr AppDomain, s: BSTR): HRESULT {.stdcall.} + ClearShadowCopyPath*: proc(self: ptr AppDomain): HRESULT {.stdcall.} + SetCachePath*: proc(self: ptr AppDomain, s: BSTR): HRESULT {.stdcall.} + SetData*: proc(self: ptr AppDomain, name: BSTR, data: VARIANT): HRESULT {.stdcall.} + GetData*: proc(self: ptr AppDomain, name: BSTR, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + SetAppDomainPolicy*: proc(self: ptr AppDomain, domainPolicy: POBJECT): HRESULT {.stdcall.} + SetThreadPrincipal*: proc(self: ptr AppDomain, principal: POBJECT): HRESULT {.stdcall.} + SetPrincipalPolicy*: proc(self: ptr AppDomain, policy: PrincipalPolicy): HRESULT {.stdcall.} + DoCallBack*: proc(self: ptr AppDomain, theDelegate: POBJECT): HRESULT {.stdcall.} + get_DynamicDirectory*: proc(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.stdcall.} +proc GetCORSystemDirectory*(pbuffer: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetCORVersion*(pbBuffer: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetFileVersion*(szFilename: LPCWSTR, szBuffer: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetCORRequiredVersion*(pbuffer: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetRequestedRuntimeInfo*(pExe: LPCWSTR, pwszVersion: LPCWSTR, pConfigurationFile: LPCWSTR, startupFlags: DWORD, runtimeInfoFlags: DWORD, pDirectory: LPWSTR, dwDirectory: DWORD, dwDirectoryLength: ptr DWORD, pVersion: LPWSTR, cchBuffer: DWORD, dwlength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetRequestedRuntimeVersion*(pExe: LPWSTR, pVersion: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CorBindToRuntimeHost*(pwszVersion: LPCWSTR, pwszBuildFlavor: LPCWSTR, pwszHostConfigFile: LPCWSTR, pReserved: pointer, startupFlags: DWORD, rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CorBindToRuntimeEx*(pwszVersion: LPCWSTR, pwszBuildFlavor: LPCWSTR, startupFlags: DWORD, rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CorBindToRuntimeByCfg*(pCfgStream: ptr IStream, reserved: DWORD, startupFlags: DWORD, rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CorBindToRuntime*(pwszVersion: LPCWSTR, pwszBuildFlavor: LPCWSTR, rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CorBindToCurrentRuntime*(pwszFileName: LPCWSTR, rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc ClrCreateManagedInstance*(pTypeName: LPCWSTR, riid: REFIID, ppObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc RunDll32ShimW*(hwnd: HWND, hinst: HINSTANCE, lpszCmdLine: LPCWSTR, nCmdShow: int32): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc LoadLibraryShim*(szDllName: LPCWSTR, szVersion: LPCWSTR, pvReserved: LPVOID, phModDll: ptr HMODULE): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CallFunctionShim*(szDllName: LPCWSTR, szFunctionName: LPCSTR, lpvArgument1: LPVOID, lpvArgument2: LPVOID, szVersion: LPCWSTR, pvReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetRealProcAddress*(pwszProcName: LPCSTR, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc LoadStringRC*(iResouceID: UINT, szBuffer: LPWSTR, iMax: int32, bQuiet: int32): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc LoadStringRCEx*(lcid: LCID, iResouceID: UINT, szBuffer: LPWSTR, iMax: int32, bQuiet: int32, pcwchUsed: ptr int32): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc LockClrVersion*(hostCallback: FLockClrVersionCallback, pBeginHostSetup: ptr FLockClrVersionCallback, pEndHostSetup: ptr FLockClrVersionCallback): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CreateDebuggingInterfaceFromVersion*(iDebuggerVersion: int32, szDebuggeeVersion: LPCWSTR, ppCordb: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetVersionFromProcess*(hProcess: HANDLE, pVersion: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc GetRequestedRuntimeVersionForCLSID*(rclsid: REFCLSID, pVersion: LPWSTR, cchBuffer: DWORD, dwLength: ptr DWORD, dwResolutionFlags: CLSID_RESOLUTION_FLAGS): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc CLRCreateInstance*(clsid: REFCLSID, riid: REFIID, ppInterface: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "mscoree", importc.} +proc `pReserved=`*(self: var CustomDumpItem, x: UINT_PTR) {.inline.} = self.union1.pReserved = x +proc pReserved*(self: CustomDumpItem): UINT_PTR {.inline.} = self.union1.pReserved +proc pReserved*(self: var CustomDumpItem): var UINT_PTR {.inline.} = self.union1.pReserved +proc SetGCStartupLimits*(self: ptr IGCHost, SegmentSize: DWORD, MaxGen0Size: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCStartupLimits(self, SegmentSize, MaxGen0Size) +proc Collect*(self: ptr IGCHost, Generation: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Collect(self, Generation) +proc GetStats*(self: ptr IGCHost, pStats: ptr COR_GC_STATS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStats(self, pStats) +proc GetThreadStats*(self: ptr IGCHost, pFiberCookie: ptr DWORD, pStats: ptr COR_GC_THREAD_STATS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetThreadStats(self, pFiberCookie, pStats) +proc SetVirtualMemLimit*(self: ptr IGCHost, sztMaxVirtualMemMB: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVirtualMemLimit(self, sztMaxVirtualMemMB) +proc SetGCStartupLimitsEx*(self: ptr IGCHost2, SegmentSize: SIZE_T, MaxGen0Size: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCStartupLimitsEx(self, SegmentSize, MaxGen0Size) +proc VEHandler*(self: ptr IVEHandler, VECode: HRESULT, Context: VEContext, psa: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VEHandler(self, VECode, Context, psa) +proc SetReporterFtn*(self: ptr IVEHandler, lFnPtr: int64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetReporterFtn(self, lFnPtr) +proc Validate*(self: ptr IValidator, veh: ptr IVEHandler, pAppDomain: ptr IUnknown, ulFlags: int32, ulMaxError: int32, token: int32, fileName: LPWSTR, pe: ptr BYTE, ulSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Validate(self, veh, pAppDomain, ulFlags, ulMaxError, token, fileName, pe, ulSize) +proc FormatEventInfo*(self: ptr IValidator, hVECode: HRESULT, Context: VEContext, msg: LPWSTR, ulMaxLength: int32, psa: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatEventInfo(self, hVECode, Context, msg, ulMaxLength, psa) +proc Validate*(self: ptr ICLRValidator, veh: ptr IVEHandler, ulAppDomainId: int32, ulFlags: int32, ulMaxError: int32, token: int32, fileName: LPWSTR, pe: ptr BYTE, ulSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Validate(self, veh, ulAppDomainId, ulFlags, ulMaxError, token, fileName, pe, ulSize) +proc FormatEventInfo*(self: ptr ICLRValidator, hVECode: HRESULT, Context: VEContext, msg: LPWSTR, ulMaxLength: int32, psa: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatEventInfo(self, hVECode, Context, msg, ulMaxLength, psa) +proc Unwrap*(self: ptr IObjectHandle, ppv: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unwrap(self, ppv) +proc OnAppDomain*(self: ptr IAppDomainBinding, pAppdomain: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnAppDomain(self, pAppdomain) +proc ThreadIsBlockingForSuspension*(self: ptr IGCThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThreadIsBlockingForSuspension(self) +proc SuspensionStarting*(self: ptr IGCThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SuspensionStarting(self) +proc SuspensionEnding*(self: ptr IGCThreadControl, Generation: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SuspensionEnding(self, Generation) +proc RequestVirtualMemLimit*(self: ptr IGCHostControl, sztMaxVirtualMemMB: SIZE_T, psztNewMaxVirtualMemMB: ptr SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestVirtualMemLimit(self, sztMaxVirtualMemMB, psztNewMaxVirtualMemMB) +proc CorRegisterWaitForSingleObject*(self: ptr ICorThreadpool, phNewWaitObject: ptr HANDLE, hWaitObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, timeout: ULONG, executeOnlyOnce: BOOL, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorRegisterWaitForSingleObject(self, phNewWaitObject, hWaitObject, Callback, Context, timeout, executeOnlyOnce, ret) +proc CorUnregisterWait*(self: ptr ICorThreadpool, hWaitObject: HANDLE, CompletionEvent: HANDLE, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorUnregisterWait(self, hWaitObject, CompletionEvent, ret) +proc CorQueueUserWorkItem*(self: ptr ICorThreadpool, Function: LPTHREAD_START_ROUTINE, Context: PVOID, executeOnlyOnce: BOOL, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorQueueUserWorkItem(self, Function, Context, executeOnlyOnce, ret) +proc CorCreateTimer*(self: ptr ICorThreadpool, phNewTimer: ptr HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorCreateTimer(self, phNewTimer, Callback, Parameter, DueTime, Period, ret) +proc CorChangeTimer*(self: ptr ICorThreadpool, Timer: HANDLE, DueTime: ULONG, Period: ULONG, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorChangeTimer(self, Timer, DueTime, Period, ret) +proc CorDeleteTimer*(self: ptr ICorThreadpool, Timer: HANDLE, CompletionEvent: HANDLE, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorDeleteTimer(self, Timer, CompletionEvent, ret) +proc CorBindIoCompletionCallback*(self: ptr ICorThreadpool, fileHandle: HANDLE, callback: LPOVERLAPPED_COMPLETION_ROUTINE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorBindIoCompletionCallback(self, fileHandle, callback) +proc CorCallOrQueueUserWorkItem*(self: ptr ICorThreadpool, Function: LPTHREAD_START_ROUTINE, Context: PVOID, ret: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorCallOrQueueUserWorkItem(self, Function, Context, ret) +proc CorSetMaxThreads*(self: ptr ICorThreadpool, MaxWorkerThreads: DWORD, MaxIOCompletionThreads: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorSetMaxThreads(self, MaxWorkerThreads, MaxIOCompletionThreads) +proc CorGetMaxThreads*(self: ptr ICorThreadpool, MaxWorkerThreads: ptr DWORD, MaxIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorGetMaxThreads(self, MaxWorkerThreads, MaxIOCompletionThreads) +proc CorGetAvailableThreads*(self: ptr ICorThreadpool, AvailableWorkerThreads: ptr DWORD, AvailableIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CorGetAvailableThreads(self, AvailableWorkerThreads, AvailableIOCompletionThreads) +proc ThreadIsBlockingForDebugger*(self: ptr IDebuggerThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThreadIsBlockingForDebugger(self) +proc ReleaseAllRuntimeThreads*(self: ptr IDebuggerThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseAllRuntimeThreads(self) +proc StartBlockingForDebugger*(self: ptr IDebuggerThreadControl, dwUnused: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartBlockingForDebugger(self, dwUnused) +proc IsDebuggerAttached*(self: ptr IDebuggerInfo, pbAttached: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDebuggerAttached(self, pbAttached) +proc SetGCThreadControl*(self: ptr ICorConfiguration, pGCThreadControl: ptr IGCThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCThreadControl(self, pGCThreadControl) +proc SetGCHostControl*(self: ptr ICorConfiguration, pGCHostControl: ptr IGCHostControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCHostControl(self, pGCHostControl) +proc SetDebuggerThreadControl*(self: ptr ICorConfiguration, pDebuggerThreadControl: ptr IDebuggerThreadControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDebuggerThreadControl(self, pDebuggerThreadControl) +proc AddDebuggerSpecialThread*(self: ptr ICorConfiguration, dwSpecialThreadId: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDebuggerSpecialThread(self, dwSpecialThreadId) +proc CreateLogicalThreadState*(self: ptr ICorRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateLogicalThreadState(self) +proc DeleteLogicalThreadState*(self: ptr ICorRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteLogicalThreadState(self) +proc SwitchInLogicalThreadState*(self: ptr ICorRuntimeHost, pFiberCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchInLogicalThreadState(self, pFiberCookie) +proc SwitchOutLogicalThreadState*(self: ptr ICorRuntimeHost, pFiberCookie: ptr ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchOutLogicalThreadState(self, pFiberCookie) +proc LocksHeldByLogicalThread*(self: ptr ICorRuntimeHost, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LocksHeldByLogicalThread(self, pCount) +proc MapFile*(self: ptr ICorRuntimeHost, hFile: HANDLE, hMapAddress: ptr HMODULE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapFile(self, hFile, hMapAddress) +proc GetConfiguration*(self: ptr ICorRuntimeHost, pConfiguration: ptr ptr ICorConfiguration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConfiguration(self, pConfiguration) +proc Start*(self: ptr ICorRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Start(self) +proc Stop*(self: ptr ICorRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stop(self) +proc CreateDomain*(self: ptr ICorRuntimeHost, pwzFriendlyName: LPCWSTR, pIdentityArray: ptr IUnknown, pAppDomain: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDomain(self, pwzFriendlyName, pIdentityArray, pAppDomain) +proc GetDefaultDomain*(self: ptr ICorRuntimeHost, pAppDomain: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultDomain(self, pAppDomain) +proc EnumDomains*(self: ptr ICorRuntimeHost, hEnum: ptr HDOMAINENUM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumDomains(self, hEnum) +proc NextDomain*(self: ptr ICorRuntimeHost, hEnum: HDOMAINENUM, pAppDomain: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NextDomain(self, hEnum, pAppDomain) +proc CloseEnum*(self: ptr ICorRuntimeHost, hEnum: HDOMAINENUM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseEnum(self, hEnum) +proc CreateDomainEx*(self: ptr ICorRuntimeHost, pwzFriendlyName: LPCWSTR, pSetup: ptr IUnknown, pEvidence: ptr IUnknown, pAppDomain: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDomainEx(self, pwzFriendlyName, pSetup, pEvidence, pAppDomain) +proc CreateDomainSetup*(self: ptr ICorRuntimeHost, pAppDomainSetup: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDomainSetup(self, pAppDomainSetup) +proc CreateEvidence*(self: ptr ICorRuntimeHost, pEvidence: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateEvidence(self, pEvidence) +proc UnloadDomain*(self: ptr ICorRuntimeHost, pAppDomain: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnloadDomain(self, pAppDomain) +proc CurrentDomain*(self: ptr ICorRuntimeHost, pAppDomain: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CurrentDomain(self, pAppDomain) +proc OnMemoryNotification*(self: ptr ICLRMemoryNotificationCallback, eMemoryAvailable: EMemoryAvailable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnMemoryNotification(self, eMemoryAvailable) +proc Alloc*(self: ptr IHostMalloc, cbSize: SIZE_T, eCriticalLevel: EMemoryCriticalLevel, ppMem: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Alloc(self, cbSize, eCriticalLevel, ppMem) +proc DebugAlloc*(self: ptr IHostMalloc, cbSize: SIZE_T, eCriticalLevel: EMemoryCriticalLevel, pszFileName: ptr char, iLineNo: int32, ppMem: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DebugAlloc(self, cbSize, eCriticalLevel, pszFileName, iLineNo, ppMem) +proc Free*(self: ptr IHostMalloc, pMem: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Free(self, pMem) +proc CreateMalloc*(self: ptr IHostMemoryManager, dwMallocType: DWORD, ppMalloc: ptr ptr IHostMalloc): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMalloc(self, dwMallocType, ppMalloc) +proc VirtualAlloc*(self: ptr IHostMemoryManager, pAddress: pointer, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, eCriticalLevel: EMemoryCriticalLevel, ppMem: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VirtualAlloc(self, pAddress, dwSize, flAllocationType, flProtect, eCriticalLevel, ppMem) +proc VirtualFree*(self: ptr IHostMemoryManager, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VirtualFree(self, lpAddress, dwSize, dwFreeType) +proc VirtualQuery*(self: ptr IHostMemoryManager, lpAddress: pointer, lpBuffer: pointer, dwLength: SIZE_T, pResult: ptr SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VirtualQuery(self, lpAddress, lpBuffer, dwLength, pResult) +proc VirtualProtect*(self: ptr IHostMemoryManager, lpAddress: pointer, dwSize: SIZE_T, flNewProtect: DWORD, pflOldProtect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VirtualProtect(self, lpAddress, dwSize, flNewProtect, pflOldProtect) +proc GetMemoryLoad*(self: ptr IHostMemoryManager, pMemoryLoad: ptr DWORD, pAvailableBytes: ptr SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMemoryLoad(self, pMemoryLoad, pAvailableBytes) +proc RegisterMemoryNotificationCallback*(self: ptr IHostMemoryManager, pCallback: ptr ICLRMemoryNotificationCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterMemoryNotificationCallback(self, pCallback) +proc NeedsVirtualAddressSpace*(self: ptr IHostMemoryManager, startAddress: LPVOID, size: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NeedsVirtualAddressSpace(self, startAddress, size) +proc AcquiredVirtualAddressSpace*(self: ptr IHostMemoryManager, startAddress: LPVOID, size: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AcquiredVirtualAddressSpace(self, startAddress, size) +proc ReleasedVirtualAddressSpace*(self: ptr IHostMemoryManager, startAddress: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleasedVirtualAddressSpace(self, startAddress) +proc SwitchIn*(self: ptr ICLRTask, threadHandle: HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchIn(self, threadHandle) +proc SwitchOut*(self: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchOut(self) +proc GetMemStats*(self: ptr ICLRTask, memUsage: ptr COR_GC_THREAD_STATS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMemStats(self, memUsage) +proc Reset*(self: ptr ICLRTask, fFull: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self, fFull) +proc ExitTask*(self: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExitTask(self) +proc Abort*(self: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Abort(self) +proc RudeAbort*(self: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RudeAbort(self) +proc NeedsPriorityScheduling*(self: ptr ICLRTask, pbNeedsPriorityScheduling: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NeedsPriorityScheduling(self, pbNeedsPriorityScheduling) +proc YieldTask*(self: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.YieldTask(self) +proc LocksHeld*(self: ptr ICLRTask, pLockCount: ptr SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LocksHeld(self, pLockCount) +proc SetTaskIdentifier*(self: ptr ICLRTask, asked: TASKID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTaskIdentifier(self, asked) +proc BeginPreventAsyncAbort*(self: ptr ICLRTask2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginPreventAsyncAbort(self) +proc EndPreventAsyncAbort*(self: ptr ICLRTask2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndPreventAsyncAbort(self) +proc Start*(self: ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Start(self) +proc Alert*(self: ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Alert(self) +proc Join*(self: ptr IHostTask, dwMilliseconds: DWORD, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Join(self, dwMilliseconds, option) +proc SetPriority*(self: ptr IHostTask, newPriority: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPriority(self, newPriority) +proc GetPriority*(self: ptr IHostTask, pPriority: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPriority(self, pPriority) +proc SetCLRTask*(self: ptr IHostTask, pCLRTask: ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCLRTask(self, pCLRTask) +proc CreateTask*(self: ptr ICLRTaskManager, pTask: ptr ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateTask(self, pTask) +proc GetCurrentTask*(self: ptr ICLRTaskManager, pTask: ptr ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentTask(self, pTask) +proc SetUILocale*(self: ptr ICLRTaskManager, lcid: LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUILocale(self, lcid) +proc SetLocale*(self: ptr ICLRTaskManager, lcid: LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLocale(self, lcid) +proc GetCurrentTaskType*(self: ptr ICLRTaskManager, pTaskType: ptr ETaskType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentTaskType(self, pTaskType) +proc GetCurrentTask*(self: ptr IHostTaskManager, pTask: ptr ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentTask(self, pTask) +proc CreateTask*(self: ptr IHostTaskManager, dwStackSize: DWORD, pStartAddress: LPTHREAD_START_ROUTINE, pParameter: PVOID, ppTask: ptr ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateTask(self, dwStackSize, pStartAddress, pParameter, ppTask) +proc Sleep*(self: ptr IHostTaskManager, dwMilliseconds: DWORD, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Sleep(self, dwMilliseconds, option) +proc SwitchToTask*(self: ptr IHostTaskManager, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchToTask(self, option) +proc SetUILocale*(self: ptr IHostTaskManager, lcid: LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUILocale(self, lcid) +proc SetLocale*(self: ptr IHostTaskManager, lcid: LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLocale(self, lcid) +proc CallNeedsHostHook*(self: ptr IHostTaskManager, target: SIZE_T, pbCallNeedsHostHook: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CallNeedsHostHook(self, target, pbCallNeedsHostHook) +proc LeaveRuntime*(self: ptr IHostTaskManager, target: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LeaveRuntime(self, target) +proc EnterRuntime*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnterRuntime(self) +proc ReverseLeaveRuntime*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReverseLeaveRuntime(self) +proc ReverseEnterRuntime*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReverseEnterRuntime(self) +proc BeginDelayAbort*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginDelayAbort(self) +proc EndDelayAbort*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndDelayAbort(self) +proc BeginThreadAffinity*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginThreadAffinity(self) +proc EndThreadAffinity*(self: ptr IHostTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndThreadAffinity(self) +proc SetStackGuarantee*(self: ptr IHostTaskManager, guarantee: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStackGuarantee(self, guarantee) +proc GetStackGuarantee*(self: ptr IHostTaskManager, pGuarantee: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStackGuarantee(self, pGuarantee) +proc SetCLRTaskManager*(self: ptr IHostTaskManager, ppManager: ptr ICLRTaskManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCLRTaskManager(self, ppManager) +proc QueueUserWorkItem*(self: ptr IHostThreadpoolManager, Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueueUserWorkItem(self, Function, Context, Flags) +proc SetMaxThreads*(self: ptr IHostThreadpoolManager, dwMaxWorkerThreads: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMaxThreads(self, dwMaxWorkerThreads) +proc GetMaxThreads*(self: ptr IHostThreadpoolManager, pdwMaxWorkerThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMaxThreads(self, pdwMaxWorkerThreads) +proc GetAvailableThreads*(self: ptr IHostThreadpoolManager, pdwAvailableWorkerThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAvailableThreads(self, pdwAvailableWorkerThreads) +proc SetMinThreads*(self: ptr IHostThreadpoolManager, dwMinIOCompletionThreads: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMinThreads(self, dwMinIOCompletionThreads) +proc GetMinThreads*(self: ptr IHostThreadpoolManager, pdwMinIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMinThreads(self, pdwMinIOCompletionThreads) +proc OnComplete*(self: ptr ICLRIoCompletionManager, dwErrorCode: DWORD, NumberOfBytesTransferred: DWORD, pvOverlapped: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnComplete(self, dwErrorCode, NumberOfBytesTransferred, pvOverlapped) +proc CreateIoCompletionPort*(self: ptr IHostIoCompletionManager, phPort: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateIoCompletionPort(self, phPort) +proc CloseIoCompletionPort*(self: ptr IHostIoCompletionManager, hPort: HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseIoCompletionPort(self, hPort) +proc SetMaxThreads*(self: ptr IHostIoCompletionManager, dwMaxIOCompletionThreads: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMaxThreads(self, dwMaxIOCompletionThreads) +proc GetMaxThreads*(self: ptr IHostIoCompletionManager, pdwMaxIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMaxThreads(self, pdwMaxIOCompletionThreads) +proc GetAvailableThreads*(self: ptr IHostIoCompletionManager, pdwAvailableIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAvailableThreads(self, pdwAvailableIOCompletionThreads) +proc GetHostOverlappedSize*(self: ptr IHostIoCompletionManager, pcbSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHostOverlappedSize(self, pcbSize) +proc SetCLRIoCompletionManager*(self: ptr IHostIoCompletionManager, pManager: ptr ICLRIoCompletionManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCLRIoCompletionManager(self, pManager) +proc InitializeHostOverlapped*(self: ptr IHostIoCompletionManager, pvOverlapped: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeHostOverlapped(self, pvOverlapped) +proc Bind*(self: ptr IHostIoCompletionManager, hPort: HANDLE, hHandle: HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Bind(self, hPort, hHandle) +proc SetMinThreads*(self: ptr IHostIoCompletionManager, dwMinIOCompletionThreads: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMinThreads(self, dwMinIOCompletionThreads) +proc GetMinThreads*(self: ptr IHostIoCompletionManager, pdwMinIOCompletionThreads: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMinThreads(self, pdwMinIOCompletionThreads) +proc BeginConnection*(self: ptr ICLRDebugManager, dwConnectionId: CONNID, szConnectionName: ptr uint16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginConnection(self, dwConnectionId, szConnectionName) +proc SetConnectionTasks*(self: ptr ICLRDebugManager, id: CONNID, dwCount: DWORD, ppCLRTask: ptr ptr ICLRTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetConnectionTasks(self, id, dwCount, ppCLRTask) +proc EndConnection*(self: ptr ICLRDebugManager, dwConnectionId: CONNID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndConnection(self, dwConnectionId) +proc SetDacl*(self: ptr ICLRDebugManager, pacl: PACL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDacl(self, pacl) +proc GetDacl*(self: ptr ICLRDebugManager, pacl: ptr PACL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDacl(self, pacl) +proc IsDebuggerAttached*(self: ptr ICLRDebugManager, pbAttached: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDebuggerAttached(self, pbAttached) +proc SetSymbolReadingPolicy*(self: ptr ICLRDebugManager, policy: ESymbolReadingPolicy): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSymbolReadingPolicy(self, policy) +proc GetBucketParametersForCurrentException*(self: ptr ICLRErrorReportingManager, pParams: ptr BucketParameters): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBucketParametersForCurrentException(self, pParams) +proc BeginCustomDump*(self: ptr ICLRErrorReportingManager, dwFlavor: ECustomDumpFlavor, dwNumItems: DWORD, items: ptr CustomDumpItem, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginCustomDump(self, dwFlavor, dwNumItems, items, dwReserved) +proc EndCustomDump*(self: ptr ICLRErrorReportingManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndCustomDump(self) +proc Enter*(self: ptr IHostCrst, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enter(self, option) +proc Leave*(self: ptr IHostCrst): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Leave(self) +proc TryEnter*(self: ptr IHostCrst, option: DWORD, pbSucceeded: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TryEnter(self, option, pbSucceeded) +proc SetSpinCount*(self: ptr IHostCrst, dwSpinCount: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSpinCount(self, dwSpinCount) +proc Wait*(self: ptr IHostAutoEvent, dwMilliseconds: DWORD, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Wait(self, dwMilliseconds, option) +proc Set*(self: ptr IHostAutoEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Set(self) +proc Wait*(self: ptr IHostManualEvent, dwMilliseconds: DWORD, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Wait(self, dwMilliseconds, option) +proc Reset*(self: ptr IHostManualEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Set*(self: ptr IHostManualEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Set(self) +proc Wait*(self: ptr IHostSemaphore, dwMilliseconds: DWORD, option: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Wait(self, dwMilliseconds, option) +proc ReleaseSemaphore*(self: ptr IHostSemaphore, lReleaseCount: LONG, lpPreviousCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseSemaphore(self, lReleaseCount, lpPreviousCount) +proc GetMonitorOwner*(self: ptr ICLRSyncManager, Cookie: SIZE_T, ppOwnerHostTask: ptr ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMonitorOwner(self, Cookie, ppOwnerHostTask) +proc CreateRWLockOwnerIterator*(self: ptr ICLRSyncManager, Cookie: SIZE_T, pIterator: ptr SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateRWLockOwnerIterator(self, Cookie, pIterator) +proc GetRWLockOwnerNext*(self: ptr ICLRSyncManager, Iterator: SIZE_T, ppOwnerHostTask: ptr ptr IHostTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRWLockOwnerNext(self, Iterator, ppOwnerHostTask) +proc DeleteRWLockOwnerIterator*(self: ptr ICLRSyncManager, Iterator: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteRWLockOwnerIterator(self, Iterator) +proc SetCLRSyncManager*(self: ptr IHostSyncManager, pManager: ptr ICLRSyncManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCLRSyncManager(self, pManager) +proc CreateCrst*(self: ptr IHostSyncManager, ppCrst: ptr ptr IHostCrst): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateCrst(self, ppCrst) +proc CreateCrstWithSpinCount*(self: ptr IHostSyncManager, dwSpinCount: DWORD, ppCrst: ptr ptr IHostCrst): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateCrstWithSpinCount(self, dwSpinCount, ppCrst) +proc CreateAutoEvent*(self: ptr IHostSyncManager, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateAutoEvent(self, ppEvent) +proc CreateManualEvent*(self: ptr IHostSyncManager, bInitialState: BOOL, ppEvent: ptr ptr IHostManualEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateManualEvent(self, bInitialState, ppEvent) +proc CreateMonitorEvent*(self: ptr IHostSyncManager, Cookie: SIZE_T, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMonitorEvent(self, Cookie, ppEvent) +proc CreateRWLockWriterEvent*(self: ptr IHostSyncManager, Cookie: SIZE_T, ppEvent: ptr ptr IHostAutoEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateRWLockWriterEvent(self, Cookie, ppEvent) +proc CreateRWLockReaderEvent*(self: ptr IHostSyncManager, bInitialState: BOOL, Cookie: SIZE_T, ppEvent: ptr ptr IHostManualEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateRWLockReaderEvent(self, bInitialState, Cookie, ppEvent) +proc CreateSemaphore*(self: ptr IHostSyncManager, dwInitial: DWORD, dwMax: DWORD, ppSemaphore: ptr ptr IHostSemaphore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateSemaphore(self, dwInitial, dwMax, ppSemaphore) +proc SetDefaultAction*(self: ptr ICLRPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultAction(self, operation, action) +proc SetTimeout*(self: ptr ICLRPolicyManager, operation: EClrOperation, dwMilliseconds: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTimeout(self, operation, dwMilliseconds) +proc SetActionOnTimeout*(self: ptr ICLRPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetActionOnTimeout(self, operation, action) +proc SetTimeoutAndAction*(self: ptr ICLRPolicyManager, operation: EClrOperation, dwMilliseconds: DWORD, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTimeoutAndAction(self, operation, dwMilliseconds, action) +proc SetActionOnFailure*(self: ptr ICLRPolicyManager, failure: EClrFailure, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetActionOnFailure(self, failure, action) +proc SetUnhandledExceptionPolicy*(self: ptr ICLRPolicyManager, policy: EClrUnhandledException): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUnhandledExceptionPolicy(self, policy) +proc OnDefaultAction*(self: ptr IHostPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDefaultAction(self, operation, action) +proc OnTimeout*(self: ptr IHostPolicyManager, operation: EClrOperation, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnTimeout(self, operation, action) +proc OnFailure*(self: ptr IHostPolicyManager, failure: EClrFailure, action: EPolicyAction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFailure(self, failure, action) +proc OnEvent*(self: ptr IActionOnCLREvent, event: EClrEvent, data: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnEvent(self, event, data) +proc RegisterActionOnEvent*(self: ptr ICLROnEventManager, event: EClrEvent, pAction: ptr IActionOnCLREvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterActionOnEvent(self, event, pAction) +proc UnregisterActionOnEvent*(self: ptr ICLROnEventManager, event: EClrEvent, pAction: ptr IActionOnCLREvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterActionOnEvent(self, event, pAction) +proc ThreadIsBlockingForSuspension*(self: ptr IHostGCManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThreadIsBlockingForSuspension(self) +proc SuspensionStarting*(self: ptr IHostGCManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SuspensionStarting(self) +proc SuspensionEnding*(self: ptr IHostGCManager, Generation: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SuspensionEnding(self, Generation) +proc IsStringAssemblyReferenceInList*(self: ptr ICLRAssemblyReferenceList, pwzAssemblyName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsStringAssemblyReferenceInList(self, pwzAssemblyName) +proc IsAssemblyReferenceInList*(self: ptr ICLRAssemblyReferenceList, pName: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsAssemblyReferenceInList(self, pName) +proc Get*(self: ptr ICLRReferenceAssemblyEnum, dwIndex: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Get(self, dwIndex, pwzBuffer, pcchBufferSize) +proc Get*(self: ptr ICLRProbingAssemblyEnum, dwIndex: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Get(self, dwIndex, pwzBuffer, pcchBufferSize) +proc GetCLRAssemblyReferenceList*(self: ptr ICLRAssemblyIdentityManager, ppwzAssemblyReferences: ptr LPCWSTR, dwNumOfReferences: DWORD, ppReferenceList: ptr ptr ICLRAssemblyReferenceList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCLRAssemblyReferenceList(self, ppwzAssemblyReferences, dwNumOfReferences, ppReferenceList) +proc GetBindingIdentityFromFile*(self: ptr ICLRAssemblyIdentityManager, pwzFilePath: LPCWSTR, dwFlags: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindingIdentityFromFile(self, pwzFilePath, dwFlags, pwzBuffer, pcchBufferSize) +proc GetBindingIdentityFromStream*(self: ptr ICLRAssemblyIdentityManager, pStream: ptr IStream, dwFlags: DWORD, pwzBuffer: LPWSTR, pcchBufferSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindingIdentityFromStream(self, pStream, dwFlags, pwzBuffer, pcchBufferSize) +proc GetReferencedAssembliesFromFile*(self: ptr ICLRAssemblyIdentityManager, pwzFilePath: LPCWSTR, dwFlags: DWORD, pExcludeAssembliesList: ptr ICLRAssemblyReferenceList, ppReferenceEnum: ptr ptr ICLRReferenceAssemblyEnum): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReferencedAssembliesFromFile(self, pwzFilePath, dwFlags, pExcludeAssembliesList, ppReferenceEnum) +proc GetReferencedAssembliesFromStream*(self: ptr ICLRAssemblyIdentityManager, pStream: ptr IStream, dwFlags: DWORD, pExcludeAssembliesList: ptr ICLRAssemblyReferenceList, ppReferenceEnum: ptr ptr ICLRReferenceAssemblyEnum): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReferencedAssembliesFromStream(self, pStream, dwFlags, pExcludeAssembliesList, ppReferenceEnum) +proc GetProbingAssembliesFromReference*(self: ptr ICLRAssemblyIdentityManager, dwMachineType: DWORD, dwFlags: DWORD, pwzReferenceIdentity: LPCWSTR, ppProbingAssemblyEnum: ptr ptr ICLRProbingAssemblyEnum): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProbingAssembliesFromReference(self, dwMachineType, dwFlags, pwzReferenceIdentity, ppProbingAssemblyEnum) +proc IsStronglyNamed*(self: ptr ICLRAssemblyIdentityManager, pwzAssemblyIdentity: LPCWSTR, pbIsStronglyNamed: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsStronglyNamed(self, pwzAssemblyIdentity, pbIsStronglyNamed) +proc ModifyApplicationPolicy*(self: ptr ICLRHostBindingPolicyManager, pwzSourceAssemblyIdentity: LPCWSTR, pwzTargetAssemblyIdentity: LPCWSTR, pbApplicationPolicy: ptr BYTE, cbAppPolicySize: DWORD, dwPolicyModifyFlags: DWORD, pbNewApplicationPolicy: ptr BYTE, pcbNewAppPolicySize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ModifyApplicationPolicy(self, pwzSourceAssemblyIdentity, pwzTargetAssemblyIdentity, pbApplicationPolicy, cbAppPolicySize, dwPolicyModifyFlags, pbNewApplicationPolicy, pcbNewAppPolicySize) +proc EvaluatePolicy*(self: ptr ICLRHostBindingPolicyManager, pwzReferenceIdentity: LPCWSTR, pbApplicationPolicy: ptr BYTE, cbAppPolicySize: DWORD, pwzPostPolicyReferenceIdentity: LPWSTR, pcchPostPolicyReferenceIdentity: ptr DWORD, pdwPoliciesApplied: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EvaluatePolicy(self, pwzReferenceIdentity, pbApplicationPolicy, cbAppPolicySize, pwzPostPolicyReferenceIdentity, pcchPostPolicyReferenceIdentity, pdwPoliciesApplied) +proc Collect*(self: ptr ICLRGCManager, Generation: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Collect(self, Generation) +proc GetStats*(self: ptr ICLRGCManager, pStats: ptr COR_GC_STATS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStats(self, pStats) +proc SetGCStartupLimits*(self: ptr ICLRGCManager, SegmentSize: DWORD, MaxGen0Size: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCStartupLimits(self, SegmentSize, MaxGen0Size) +proc SetGCStartupLimitsEx*(self: ptr ICLRGCManager2, SegmentSize: SIZE_T, MaxGen0Size: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGCStartupLimitsEx(self, SegmentSize, MaxGen0Size) +proc ProvideAssembly*(self: ptr IHostAssemblyStore, pBindInfo: ptr AssemblyBindInfo, pAssemblyId: ptr UINT64, pContext: ptr UINT64, ppStmAssemblyImage: ptr ptr IStream, ppStmPDB: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProvideAssembly(self, pBindInfo, pAssemblyId, pContext, ppStmAssemblyImage, ppStmPDB) +proc ProvideModule*(self: ptr IHostAssemblyStore, pBindInfo: ptr ModuleBindInfo, pdwModuleId: ptr DWORD, ppStmModuleImage: ptr ptr IStream, ppStmPDB: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProvideModule(self, pBindInfo, pdwModuleId, ppStmModuleImage, ppStmPDB) +proc GetNonHostStoreAssemblies*(self: ptr IHostAssemblyManager, ppReferenceList: ptr ptr ICLRAssemblyReferenceList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNonHostStoreAssemblies(self, ppReferenceList) +proc GetAssemblyStore*(self: ptr IHostAssemblyManager, ppAssemblyStore: ptr ptr IHostAssemblyStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAssemblyStore(self, ppAssemblyStore) +proc GetHostManager*(self: ptr IHostControl, riid: REFIID, ppObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHostManager(self, riid, ppObject) +proc SetAppDomainManager*(self: ptr IHostControl, dwAppDomainID: DWORD, pUnkAppDomainManager: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppDomainManager(self, dwAppDomainID, pUnkAppDomainManager) +proc GetCLRManager*(self: ptr ICLRControl, riid: REFIID, ppObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCLRManager(self, riid, ppObject) +proc SetAppDomainManagerType*(self: ptr ICLRControl, pwzAppDomainManagerAssembly: LPCWSTR, pwzAppDomainManagerType: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppDomainManagerType(self, pwzAppDomainManagerAssembly, pwzAppDomainManagerType) +proc Start*(self: ptr ICLRRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Start(self) +proc Stop*(self: ptr ICLRRuntimeHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stop(self) +proc SetHostControl*(self: ptr ICLRRuntimeHost, pHostControl: ptr IHostControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHostControl(self, pHostControl) +proc GetCLRControl*(self: ptr ICLRRuntimeHost, pCLRControl: ptr ptr ICLRControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCLRControl(self, pCLRControl) +proc UnloadAppDomain*(self: ptr ICLRRuntimeHost, dwAppDomainId: DWORD, fWaitUntilDone: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnloadAppDomain(self, dwAppDomainId, fWaitUntilDone) +proc ExecuteInAppDomain*(self: ptr ICLRRuntimeHost, dwAppDomainId: DWORD, pCallback: FExecuteInAppDomainCallback, cookie: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteInAppDomain(self, dwAppDomainId, pCallback, cookie) +proc GetCurrentAppDomainId*(self: ptr ICLRRuntimeHost, pdwAppDomainId: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentAppDomainId(self, pdwAppDomainId) +proc ExecuteApplication*(self: ptr ICLRRuntimeHost, pwzAppFullName: LPCWSTR, dwManifestPaths: DWORD, ppwzManifestPaths: ptr LPCWSTR, dwActivationData: DWORD, ppwzActivationData: ptr LPCWSTR, pReturnValue: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteApplication(self, pwzAppFullName, dwManifestPaths, ppwzManifestPaths, dwActivationData, ppwzActivationData, pReturnValue) +proc ExecuteInDefaultAppDomain*(self: ptr ICLRRuntimeHost, pwzAssemblyPath: LPCWSTR, pwzTypeName: LPCWSTR, pwzMethodName: LPCWSTR, pwzArgument: LPCWSTR, pReturnValue: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteInDefaultAppDomain(self, pwzAssemblyPath, pwzTypeName, pwzMethodName, pwzArgument, pReturnValue) +proc SetProtectedCategories*(self: ptr ICLRHostProtectionManager, categories: EApiCategories): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProtectedCategories(self, categories) +proc SetEagerSerializeGrantSets*(self: ptr ICLRHostProtectionManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEagerSerializeGrantSets(self) +proc SetAppDomainManagerType*(self: ptr ICLRDomainManager, wszAppDomainManagerAssembly: LPCWSTR, wszAppDomainManagerType: LPCWSTR, dwInitializeDomainFlags: EInitializeNewDomainFlags): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppDomainManagerType(self, wszAppDomainManagerAssembly, wszAppDomainManagerType, dwInitializeDomainFlags) +proc SetPropertiesForDefaultAppDomain*(self: ptr ICLRDomainManager, nProperties: DWORD, pwszPropertyNames: ptr LPCWSTR, pwszPropertyValues: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropertiesForDefaultAppDomain(self, nProperties, pwszPropertyNames, pwszPropertyValues) +proc GetNameCount*(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNameCount(self, pCount) +proc GetNames*(self: ptr ITypeName, count: DWORD, rgbszNames: ptr BSTR, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNames(self, count, rgbszNames, pCount) +proc GetTypeArgumentCount*(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeArgumentCount(self, pCount) +proc GetTypeArguments*(self: ptr ITypeName, count: DWORD, rgpArguments: ptr ptr ITypeName, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeArguments(self, count, rgpArguments, pCount) +proc GetModifierLength*(self: ptr ITypeName, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetModifierLength(self, pCount) +proc GetModifiers*(self: ptr ITypeName, count: DWORD, rgModifiers: ptr DWORD, pCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetModifiers(self, count, rgModifiers, pCount) +proc GetAssemblyName*(self: ptr ITypeName, rgbszAssemblyNames: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAssemblyName(self, rgbszAssemblyNames) +proc OpenGenericArguments*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenGenericArguments(self) +proc CloseGenericArguments*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseGenericArguments(self) +proc OpenGenericArgument*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenGenericArgument(self) +proc CloseGenericArgument*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseGenericArgument(self) +proc AddName*(self: ptr ITypeNameBuilder, szName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddName(self, szName) +proc AddPointer*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPointer(self) +proc AddByRef*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddByRef(self) +proc AddSzArray*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSzArray(self) +proc AddArray*(self: ptr ITypeNameBuilder, rank: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddArray(self, rank) +proc AddAssemblySpec*(self: ptr ITypeNameBuilder, szAssemblySpec: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddAssemblySpec(self, szAssemblySpec) +proc ToString*(self: ptr ITypeNameBuilder, pszStringRepresentation: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ToString(self, pszStringRepresentation) +proc Clear*(self: ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clear(self) +proc ParseTypeName*(self: ptr ITypeNameFactory, szName: LPCWSTR, pError: ptr DWORD, ppTypeName: ptr ptr ITypeName): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseTypeName(self, szName, pError, ppTypeName) +proc GetTypeNameBuilder*(self: ptr ITypeNameFactory, ppTypeBuilder: ptr ptr ITypeNameBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeNameBuilder(self, ppTypeBuilder) +proc DoCallback*(self: ptr IApartmentCallback, pFunc: SIZE_T, pData: SIZE_T): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoCallback(self, pFunc, pData) +proc GetSerializedBuffer*(self: ptr IManagedObject, pBSTR: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSerializedBuffer(self, pBSTR) +proc GetObjectIdentity*(self: ptr IManagedObject, pBSTRGUID: ptr BSTR, AppDomainID: ptr int32, pCCW: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectIdentity(self, pBSTRGUID, AppDomainID, pCCW) +proc Autodone*(self: ptr ICatalogServices): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Autodone(self) +proc NotAutodone*(self: ptr ICatalogServices): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NotAutodone(self) +proc Capture*(self: ptr IHostSecurityContext, ppClonedContext: ptr ptr IHostSecurityContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Capture(self, ppClonedContext) +proc ImpersonateLoggedOnUser*(self: ptr IHostSecurityManager, hToken: HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ImpersonateLoggedOnUser(self, hToken) +proc RevertToSelf*(self: ptr IHostSecurityManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevertToSelf(self) +proc OpenThreadToken*(self: ptr IHostSecurityManager, dwDesiredAccess: DWORD, bOpenAsSelf: BOOL, phThreadToken: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenThreadToken(self, dwDesiredAccess, bOpenAsSelf, phThreadToken) +proc SetThreadToken*(self: ptr IHostSecurityManager, hToken: HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThreadToken(self, hToken) +proc GetSecurityContext*(self: ptr IHostSecurityManager, eContextType: EContextType, ppSecurityContext: ptr ptr IHostSecurityContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecurityContext(self, eContextType, ppSecurityContext) +proc SetSecurityContext*(self: ptr IHostSecurityManager, eContextType: EContextType, pSecurityContext: ptr IHostSecurityContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSecurityContext(self, eContextType, pSecurityContext) +proc GetCurrentAllocated*(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pBytesAllocated: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentAllocated(self, dwAppDomainId, pBytesAllocated) +proc GetCurrentSurvived*(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pAppDomainBytesSurvived: ptr ULONGLONG, pTotalBytesSurvived: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSurvived(self, dwAppDomainId, pAppDomainBytesSurvived, pTotalBytesSurvived) +proc GetCurrentCpuTime*(self: ptr ICLRAppDomainResourceMonitor, dwAppDomainId: DWORD, pMilliseconds: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentCpuTime(self, dwAppDomainId, pMilliseconds) +proc GetRuntime*(self: ptr ICLRMetaHost, pwzVersion: LPCWSTR, riid: REFIID, ppRuntime: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntime(self, pwzVersion, riid, ppRuntime) +proc GetVersionFromFile*(self: ptr ICLRMetaHost, pwzFilePath: LPCWSTR, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVersionFromFile(self, pwzFilePath, pwzBuffer, pcchBuffer) +proc EnumerateInstalledRuntimes*(self: ptr ICLRMetaHost, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumerateInstalledRuntimes(self, ppEnumerator) +proc EnumerateLoadedRuntimes*(self: ptr ICLRMetaHost, hndProcess: HANDLE, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumerateLoadedRuntimes(self, hndProcess, ppEnumerator) +proc RequestRuntimeLoadedNotification*(self: ptr ICLRMetaHost, pCallbackFunction: RuntimeLoadedCallbackFnPtr): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestRuntimeLoadedNotification(self, pCallbackFunction) +proc QueryLegacyV2RuntimeBinding*(self: ptr ICLRMetaHost, riid: REFIID, ppUnk: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryLegacyV2RuntimeBinding(self, riid, ppUnk) +proc ExitProcess*(self: ptr ICLRMetaHost, iExitCode: INT32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExitProcess(self, iExitCode) +proc GetRequestedRuntime*(self: ptr ICLRMetaHostPolicy, dwPolicyFlags: METAHOST_POLICY_FLAGS, pwzBinary: LPCWSTR, pCfgStream: ptr IStream, pwzVersion: LPWSTR, pcchVersion: ptr DWORD, pwzImageVersion: LPWSTR, pcchImageVersion: ptr DWORD, pdwConfigFlags: ptr DWORD, riid: REFIID, ppRuntime: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRequestedRuntime(self, dwPolicyFlags, pwzBinary, pCfgStream, pwzVersion, pcchVersion, pwzImageVersion, pcchImageVersion, pdwConfigFlags, riid, ppRuntime) +proc AttachProfiler*(self: ptr ICLRProfiling, dwProfileeProcessID: DWORD, dwMillisecondsMax: DWORD, pClsidProfiler: ptr CLSID, wszProfilerPath: LPCWSTR, pvClientData: pointer, cbClientData: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AttachProfiler(self, dwProfileeProcessID, dwMillisecondsMax, pClsidProfiler, wszProfilerPath, pvClientData, cbClientData) +proc ProvideLibrary*(self: ptr ICLRDebuggingLibraryProvider, pwszFileName: ptr WCHAR, dwTimestamp: DWORD, dwSizeOfImage: DWORD, phModule: ptr HMODULE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProvideLibrary(self, pwszFileName, dwTimestamp, dwSizeOfImage, phModule) +proc OpenVirtualProcess*(self: ptr ICLRDebugging, moduleBaseAddress: ULONG64, pDataTarget: ptr IUnknown, pLibraryProvider: ptr ICLRDebuggingLibraryProvider, pMaxDebuggerSupportedVersion: ptr CLR_DEBUGGING_VERSION, riidProcess: REFIID, ppProcess: ptr ptr IUnknown, pVersion: ptr CLR_DEBUGGING_VERSION, pdwFlags: ptr CLR_DEBUGGING_PROCESS_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenVirtualProcess(self, moduleBaseAddress, pDataTarget, pLibraryProvider, pMaxDebuggerSupportedVersion, riidProcess, ppProcess, pVersion, pdwFlags) +proc CanUnloadNow*(self: ptr ICLRDebugging, hModule: HMODULE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanUnloadNow(self, hModule) +proc GetVersionString*(self: ptr ICLRRuntimeInfo, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVersionString(self, pwzBuffer, pcchBuffer) +proc GetRuntimeDirectory*(self: ptr ICLRRuntimeInfo, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntimeDirectory(self, pwzBuffer, pcchBuffer) +proc IsLoaded*(self: ptr ICLRRuntimeInfo, hndProcess: HANDLE, pbLoaded: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLoaded(self, hndProcess, pbLoaded) +proc LoadErrorString*(self: ptr ICLRRuntimeInfo, iResourceID: UINT, pwzBuffer: LPWSTR, pcchBuffer: ptr DWORD, iLocaleID: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadErrorString(self, iResourceID, pwzBuffer, pcchBuffer, iLocaleID) +proc LoadLibrary*(self: ptr ICLRRuntimeInfo, pwzDllName: LPCWSTR, phndModule: ptr HMODULE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadLibrary(self, pwzDllName, phndModule) +proc GetProcAddress*(self: ptr ICLRRuntimeInfo, pszProcName: LPCSTR, ppProc: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProcAddress(self, pszProcName, ppProc) +proc GetInterface*(self: ptr ICLRRuntimeInfo, rclsid: REFCLSID, riid: REFIID, ppUnk: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterface(self, rclsid, riid, ppUnk) +proc IsLoadable*(self: ptr ICLRRuntimeInfo, pbLoadable: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLoadable(self, pbLoadable) +proc SetDefaultStartupFlags*(self: ptr ICLRRuntimeInfo, dwStartupFlags: DWORD, pwzHostConfigFile: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultStartupFlags(self, dwStartupFlags, pwzHostConfigFile) +proc GetDefaultStartupFlags*(self: ptr ICLRRuntimeInfo, pdwStartupFlags: ptr DWORD, pwzHostConfigFile: LPWSTR, pcchHostConfigFile: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultStartupFlags(self, pdwStartupFlags, pwzHostConfigFile, pcchHostConfigFile) +proc BindAsLegacyV2Runtime*(self: ptr ICLRRuntimeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindAsLegacyV2Runtime(self) +proc IsStarted*(self: ptr ICLRRuntimeInfo, pbStarted: ptr BOOL, pdwStartupFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsStarted(self, pbStarted, pdwStartupFlags) +proc GetHashFromAssemblyFile*(self: ptr ICLRStrongName, pszFilePath: LPCSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromAssemblyFile(self, pszFilePath, piHashAlg, pbHash, cchHash, pchHash) +proc GetHashFromAssemblyFileW*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromAssemblyFileW(self, pwzFilePath, piHashAlg, pbHash, cchHash, pchHash) +proc GetHashFromBlob*(self: ptr ICLRStrongName, pbBlob: ptr BYTE, cchBlob: DWORD, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromBlob(self, pbBlob, cchBlob, piHashAlg, pbHash, cchHash, pchHash) +proc GetHashFromFile*(self: ptr ICLRStrongName, pszFilePath: LPCSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromFile(self, pszFilePath, piHashAlg, pbHash, cchHash, pchHash) +proc GetHashFromFileW*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromFileW(self, pwzFilePath, piHashAlg, pbHash, cchHash, pchHash) +proc GetHashFromHandle*(self: ptr ICLRStrongName, hFile: HANDLE, piHashAlg: ptr int32, pbHash: ptr BYTE, cchHash: DWORD, pchHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashFromHandle(self, hFile, piHashAlg, pbHash, cchHash, pchHash) +proc StrongNameCompareAssemblies*(self: ptr ICLRStrongName, pwzAssembly1: LPCWSTR, pwzAssembly2: LPCWSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameCompareAssemblies(self, pwzAssembly1, pwzAssembly2, pdwResult) +proc StrongNameFreeBuffer*(self: ptr ICLRStrongName, pbMemory: ptr BYTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameFreeBuffer(self, pbMemory) +proc StrongNameGetBlob*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, pbBlob: ptr BYTE, pcbBlob: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameGetBlob(self, pwzFilePath, pbBlob, pcbBlob) +proc StrongNameGetBlobFromImage*(self: ptr ICLRStrongName, pbBase: ptr BYTE, dwLength: DWORD, pbBlob: ptr BYTE, pcbBlob: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameGetBlobFromImage(self, pbBase, dwLength, pbBlob, pcbBlob) +proc StrongNameGetPublicKey*(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameGetPublicKey(self, pwzKeyContainer, pbKeyBlob, cbKeyBlob, ppbPublicKeyBlob, pcbPublicKeyBlob) +proc StrongNameHashSize*(self: ptr ICLRStrongName, ulHashAlg: ULONG, pcbSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameHashSize(self, ulHashAlg, pcbSize) +proc StrongNameKeyDelete*(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameKeyDelete(self, pwzKeyContainer) +proc StrongNameKeyGen*(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, dwFlags: DWORD, ppbKeyBlob: ptr ptr BYTE, pcbKeyBlob: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameKeyGen(self, pwzKeyContainer, dwFlags, ppbKeyBlob, pcbKeyBlob) +proc StrongNameKeyGenEx*(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, dwFlags: DWORD, dwKeySize: DWORD, ppbKeyBlob: ptr ptr BYTE, pcbKeyBlob: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameKeyGenEx(self, pwzKeyContainer, dwFlags, dwKeySize, ppbKeyBlob, pcbKeyBlob) +proc StrongNameKeyInstall*(self: ptr ICLRStrongName, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameKeyInstall(self, pwzKeyContainer, pbKeyBlob, cbKeyBlob) +proc StrongNameSignatureGeneration*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureGeneration(self, pwzFilePath, pwzKeyContainer, pbKeyBlob, cbKeyBlob, ppbSignatureBlob, pcbSignatureBlob) +proc StrongNameSignatureGenerationEx*(self: ptr ICLRStrongName, wszFilePath: LPCWSTR, wszKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureGenerationEx(self, wszFilePath, wszKeyContainer, pbKeyBlob, cbKeyBlob, ppbSignatureBlob, pcbSignatureBlob, dwFlags) +proc StrongNameSignatureSize*(self: ptr ICLRStrongName, pbPublicKeyBlob: ptr BYTE, cbPublicKeyBlob: ULONG, pcbSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureSize(self, pbPublicKeyBlob, cbPublicKeyBlob, pcbSize) +proc StrongNameSignatureVerification*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, dwInFlags: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureVerification(self, pwzFilePath, dwInFlags, pdwOutFlags) +proc StrongNameSignatureVerificationEx*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, fForceVerification: BOOLEAN, pfWasVerified: ptr BOOLEAN): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureVerificationEx(self, pwzFilePath, fForceVerification, pfWasVerified) +proc StrongNameSignatureVerificationFromImage*(self: ptr ICLRStrongName, pbBase: ptr BYTE, dwLength: DWORD, dwInFlags: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureVerificationFromImage(self, pbBase, dwLength, dwInFlags, pdwOutFlags) +proc StrongNameTokenFromAssembly*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameTokenFromAssembly(self, pwzFilePath, ppbStrongNameToken, pcbStrongNameToken) +proc StrongNameTokenFromAssemblyEx*(self: ptr ICLRStrongName, pwzFilePath: LPCWSTR, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameTokenFromAssemblyEx(self, pwzFilePath, ppbStrongNameToken, pcbStrongNameToken, ppbPublicKeyBlob, pcbPublicKeyBlob) +proc StrongNameTokenFromPublicKey*(self: ptr ICLRStrongName, pbPublicKeyBlob: ptr BYTE, cbPublicKeyBlob: ULONG, ppbStrongNameToken: ptr ptr BYTE, pcbStrongNameToken: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameTokenFromPublicKey(self, pbPublicKeyBlob, cbPublicKeyBlob, ppbStrongNameToken, pcbStrongNameToken) +proc StrongNameGetPublicKeyEx*(self: ptr ICLRStrongName2, pwzKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, ppbPublicKeyBlob: ptr ptr BYTE, pcbPublicKeyBlob: ptr ULONG, uHashAlgId: ULONG, uReserved: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameGetPublicKeyEx(self, pwzKeyContainer, pbKeyBlob, cbKeyBlob, ppbPublicKeyBlob, pcbPublicKeyBlob, uHashAlgId, uReserved) +proc StrongNameSignatureVerificationEx2*(self: ptr ICLRStrongName2, wszFilePath: LPCWSTR, fForceVerification: BOOLEAN, pbEcmaPublicKey: ptr BYTE, cbEcmaPublicKey: DWORD, pfWasVerified: ptr BOOLEAN): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameSignatureVerificationEx2(self, wszFilePath, fForceVerification, pbEcmaPublicKey, cbEcmaPublicKey, pfWasVerified) +proc StrongNameDigestGenerate*(self: ptr ICLRStrongName3, wszFilePath: LPCWSTR, ppbDigestBlob: ptr ptr BYTE, pcbDigestBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameDigestGenerate(self, wszFilePath, ppbDigestBlob, pcbDigestBlob, dwFlags) +proc StrongNameDigestSign*(self: ptr ICLRStrongName3, wszKeyContainer: LPCWSTR, pbKeyBlob: ptr BYTE, cbKeyBlob: ULONG, pbDigestBlob: ptr BYTE, cbDigestBlob: ULONG, hashAlgId: DWORD, ppbSignatureBlob: ptr ptr BYTE, pcbSignatureBlob: ptr ULONG, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameDigestSign(self, wszKeyContainer, pbKeyBlob, cbKeyBlob, pbDigestBlob, cbDigestBlob, hashAlgId, ppbSignatureBlob, pcbSignatureBlob, dwFlags) +proc StrongNameDigestEmbed*(self: ptr ICLRStrongName3, wszFilePath: LPCWSTR, pbSignatureBlob: ptr BYTE, cbSignatureBlob: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrongNameDigestEmbed(self, wszFilePath, pbSignatureBlob, cbSignatureBlob) +proc get_ToString*(self: ptr IObject, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr IObject, obj: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, obj, pRetVal) +proc GetHashCode*(self: ptr IObject, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr IObject, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc GetTypeInfoCount*(self: ptr IType, pcTInfo: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoCount(self, pcTInfo) +proc GetTypeInfo*(self: ptr IType, iTInfo: int32, lcid: int32, ppTInfo: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfo(self, iTInfo, lcid, ppTInfo) +proc GetIDsOfNames*(self: ptr IType, riid: ptr GUID, rgszNames: int32, cNames: int32, lcid: int32, rgDispId: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDsOfNames(self, riid, rgszNames, cNames, lcid, rgDispId) +proc Invoke*(self: ptr IType, dispIdMember: int32, riid: ptr GUID, lcid: int32, wFlags: int16, pDispParams: int32, pVarResult: int32, pExcepInfo: int32, puArgErr: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr) +proc get_ToString*(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr IType, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, other, pRetVal) +proc GetHashCode*(self: ptr IType, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc get_MemberType*(self: ptr IType, pRetVal: ptr MemberTypes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_MemberType(self, pRetVal) +proc get_name*(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, pRetVal) +proc get_DeclaringType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DeclaringType(self, pRetVal) +proc get_ReflectedType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReflectedType(self, pRetVal) +proc GetCustomAttributes*(self: ptr IType, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes(self, attributeType, inherit, pRetVal) +proc GetCustomAttributes_2*(self: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes_2(self, inherit, pRetVal) +proc IsDefined*(self: ptr IType, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDefined(self, attributeType, inherit, pRetVal) +proc get_Guid*(self: ptr IType, pRetVal: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Guid(self, pRetVal) +proc get_Module*(self: ptr IType, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Module(self, pRetVal) +proc getIAssembly*(self: ptr IType, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getIAssembly(self, pRetVal) +proc get_TypeHandle*(self: ptr IType, pRetVal: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TypeHandle(self, pRetVal) +proc get_FullName*(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FullName(self, pRetVal) +proc get_Namespace*(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Namespace(self, pRetVal) +proc get_AssemblyQualifiedName*(self: ptr IType, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AssemblyQualifiedName(self, pRetVal) +proc GetArrayRank*(self: ptr IType, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetArrayRank(self, pRetVal) +proc get_BaseType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BaseType(self, pRetVal) +proc GetConstructors*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConstructors(self, bindingAttr, pRetVal) +proc GetInterface*(self: ptr IType, name: BSTR, ignoreCase: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterface(self, name, ignoreCase, pRetVal) +proc GetInterfaces*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterfaces(self, pRetVal) +proc FindInterfaces*(self: ptr IType, filter: POBJECT, filterCriteria: VARIANT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindInterfaces(self, filter, filterCriteria, pRetVal) +proc GetEvent*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEvent(self, name, bindingAttr, pRetVal) +proc GetEvents*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEvents(self, pRetVal) +proc GetEvents_2*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEvents_2(self, bindingAttr, pRetVal) +proc GetNestedTypes*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNestedTypes(self, bindingAttr, pRetVal) +proc GetNestedType*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNestedType(self, name, bindingAttr, pRetVal) +proc GetMember*(self: ptr IType, name: BSTR, Type: MemberTypes, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMember(self, name, Type, bindingAttr, pRetVal) +proc GetDefaultMembers*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultMembers(self, pRetVal) +proc FindMembers*(self: ptr IType, MemberType: MemberTypes, bindingAttr: BindingFlags, filter: POBJECT, filterCriteria: VARIANT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindMembers(self, MemberType, bindingAttr, filter, filterCriteria, pRetVal) +proc GetElementType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElementType(self, pRetVal) +proc IsSubclassOf*(self: ptr IType, c: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSubclassOf(self, c, pRetVal) +proc IsInstanceOfType*(self: ptr IType, o: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsInstanceOfType(self, o, pRetVal) +proc IsAssignableFrom*(self: ptr IType, c: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsAssignableFrom(self, c, pRetVal) +proc GetInterfaceMap*(self: ptr IType, interfaceType: ptr IType, pRetVal: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterfaceMap(self, interfaceType, pRetVal) +proc GetMethod*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod(self, name, bindingAttr, Binder, types, modifiers, pRetVal) +proc GetMethod_2*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod_2(self, name, bindingAttr, pRetVal) +proc GetMethods*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethods(self, bindingAttr, pRetVal) +proc GetField*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetField(self, name, bindingAttr, pRetVal) +proc GetFields*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFields(self, bindingAttr, pRetVal) +proc GetProperty*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, name, bindingAttr, pRetVal) +proc GetProperty_2*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, returnType: ptr IType, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_2(self, name, bindingAttr, Binder, returnType, types, modifiers, pRetVal) +proc GetProperties*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperties(self, bindingAttr, pRetVal) +proc GetMember_2*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMember_2(self, name, bindingAttr, pRetVal) +proc GetMembers*(self: ptr IType, bindingAttr: BindingFlags, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMembers(self, bindingAttr, pRetVal) +proc InvokeMember*(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, culture: POBJECT, namedParameters: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeMember(self, name, invokeAttr, Binder, Target, args, modifiers, culture, namedParameters, pRetVal) +proc get_UnderlyingSystemType*(self: ptr IType, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_UnderlyingSystemType(self, pRetVal) +proc InvokeMember_2*(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, culture: POBJECT, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeMember_2(self, name, invokeAttr, Binder, Target, args, culture, pRetVal) +proc InvokeMember_3*(self: ptr IType, name: BSTR, invokeAttr: BindingFlags, Binder: POBJECT, Target: VARIANT, args: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeMember_3(self, name, invokeAttr, Binder, Target, args, pRetVal) +proc GetConstructor*(self: ptr IType, bindingAttr: BindingFlags, Binder: POBJECT, callConvention: CallingConventions, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConstructor(self, bindingAttr, Binder, callConvention, types, modifiers, pRetVal) +proc GetConstructor_2*(self: ptr IType, bindingAttr: BindingFlags, Binder: POBJECT, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConstructor_2(self, bindingAttr, Binder, types, modifiers, pRetVal) +proc GetConstructor_3*(self: ptr IType, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConstructor_3(self, types, pRetVal) +proc GetConstructors_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConstructors_2(self, pRetVal) +proc get_TypeInitializer*(self: ptr IType, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TypeInitializer(self, pRetVal) +proc GetMethod_3*(self: ptr IType, name: BSTR, bindingAttr: BindingFlags, Binder: POBJECT, callConvention: CallingConventions, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod_3(self, name, bindingAttr, Binder, callConvention, types, modifiers, pRetVal) +proc GetMethod_4*(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod_4(self, name, types, modifiers, pRetVal) +proc GetMethod_5*(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod_5(self, name, types, pRetVal) +proc GetMethod_6*(self: ptr IType, name: BSTR, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethod_6(self, name, pRetVal) +proc GetMethods_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethods_2(self, pRetVal) +proc GetField_2*(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetField_2(self, name, pRetVal) +proc GetFields_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFields_2(self, pRetVal) +proc GetInterface_2*(self: ptr IType, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterface_2(self, name, pRetVal) +proc GetEvent_2*(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEvent_2(self, name, pRetVal) +proc GetProperty_3*(self: ptr IType, name: BSTR, returnType: ptr IType, types: ptr SAFEARRAY, modifiers: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_3(self, name, returnType, types, modifiers, pRetVal) +proc GetProperty_4*(self: ptr IType, name: BSTR, returnType: ptr IType, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_4(self, name, returnType, types, pRetVal) +proc GetProperty_5*(self: ptr IType, name: BSTR, types: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_5(self, name, types, pRetVal) +proc GetProperty_6*(self: ptr IType, name: BSTR, returnType: ptr IType, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_6(self, name, returnType, pRetVal) +proc GetProperty_7*(self: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty_7(self, name, pRetVal) +proc GetProperties_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperties_2(self, pRetVal) +proc GetNestedTypes_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNestedTypes_2(self, pRetVal) +proc GetNestedType_2*(self: ptr IType, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNestedType_2(self, name, pRetVal) +proc GetMember_3*(self: ptr IType, name: BSTR, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMember_3(self, name, pRetVal) +proc GetMembers_2*(self: ptr IType, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMembers_2(self, pRetVal) +proc get_Attributes*(self: ptr IType, pRetVal: ptr TypeAttributes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Attributes(self, pRetVal) +proc get_IsNotPublic*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNotPublic(self, pRetVal) +proc get_IsPublic*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsPublic(self, pRetVal) +proc get_IsNestedPublic*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedPublic(self, pRetVal) +proc get_IsNestedPrivate*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedPrivate(self, pRetVal) +proc get_IsNestedFamily*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedFamily(self, pRetVal) +proc get_IsNestedAssembly*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedAssembly(self, pRetVal) +proc get_IsNestedFamANDAssem*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedFamANDAssem(self, pRetVal) +proc get_IsNestedFamORAssem*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsNestedFamORAssem(self, pRetVal) +proc get_IsAutoLayout*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAutoLayout(self, pRetVal) +proc get_IsLayoutSequential*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsLayoutSequential(self, pRetVal) +proc get_IsExplicitLayout*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsExplicitLayout(self, pRetVal) +proc get_IsClass*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsClass(self, pRetVal) +proc get_IsInterface*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsInterface(self, pRetVal) +proc get_IsValueType*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsValueType(self, pRetVal) +proc get_IsAbstract*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAbstract(self, pRetVal) +proc get_IsSealed*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSealed(self, pRetVal) +proc get_IsEnum*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsEnum(self, pRetVal) +proc get_IsSpecialName*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSpecialName(self, pRetVal) +proc get_IsImport*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsImport(self, pRetVal) +proc get_IsSerializable*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSerializable(self, pRetVal) +proc get_IsAnsiClass*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAnsiClass(self, pRetVal) +proc get_IsUnicodeClass*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsUnicodeClass(self, pRetVal) +proc get_IsAutoClass*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAutoClass(self, pRetVal) +proc get_IsArray*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsArray(self, pRetVal) +proc get_IsByRef*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsByRef(self, pRetVal) +proc get_IsPointer*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsPointer(self, pRetVal) +proc get_IsPrimitive*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsPrimitive(self, pRetVal) +proc get_IsCOMObject*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsCOMObject(self, pRetVal) +proc get_HasElementType*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HasElementType(self, pRetVal) +proc get_IsContextful*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsContextful(self, pRetVal) +proc get_IsMarshalByRef*(self: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsMarshalByRef(self, pRetVal) +proc Equals_2*(self: ptr IType, o: ptr IType, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals_2(self, o, pRetVal) +proc get_ApplicationBase*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ApplicationBase(self, pRetVal) +proc put_ApplicationBase*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ApplicationBase(self, pRetVal) +proc get_ApplicationName*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ApplicationName(self, pRetVal) +proc put_ApplicationName*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ApplicationName(self, pRetVal) +proc get_CachePath*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachePath(self, pRetVal) +proc put_CachePath*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_CachePath(self, pRetVal) +proc get_ConfigurationFile*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ConfigurationFile(self, pRetVal) +proc put_ConfigurationFile*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ConfigurationFile(self, pRetVal) +proc get_DynamicBase*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DynamicBase(self, pRetVal) +proc put_DynamicBase*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_DynamicBase(self, pRetVal) +proc get_LicenseFile*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_LicenseFile(self, pRetVal) +proc put_LicenseFile*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_LicenseFile(self, pRetVal) +proc get_PrivateBinPath*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_PrivateBinPath(self, pRetVal) +proc put_PrivateBinPath*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_PrivateBinPath(self, pRetVal) +proc get_PrivateBinPathProbe*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_PrivateBinPathProbe(self, pRetVal) +proc put_PrivateBinPathProbe*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_PrivateBinPathProbe(self, pRetVal) +proc get_ShadowCopyDirectories*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShadowCopyDirectories(self, pRetVal) +proc put_ShadowCopyDirectories*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ShadowCopyDirectories(self, pRetVal) +proc get_ShadowCopyFiles*(self: ptr IAppDomainSetup, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShadowCopyFiles(self, pRetVal) +proc put_ShadowCopyFiles*(self: ptr IAppDomainSetup, pRetVal: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ShadowCopyFiles(self, pRetVal) +proc get_ToString*(self: ptr ObjectHandle, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr ObjectHandle, obj: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, obj, pRetVal) +proc GetHashCode*(self: ptr ObjectHandle, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr ObjectHandle, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc GetLifetimeService*(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLifetimeService(self, pRetVal) +proc InitializeLifetimeService*(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeLifetimeService(self, pRetVal) +proc CreateObjRef*(self: ptr ObjectHandle, requestedType: ptr IType, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateObjRef(self, requestedType, pRetVal) +proc Unwrap*(self: ptr ObjectHandle, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unwrap(self, pRetVal) +proc get_ToString*(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr AppDomain, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, other, pRetVal) +proc GetHashCode*(self: ptr AppDomain, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr AppDomain, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc InitializeLifetimeService*(self: ptr AppDomain, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeLifetimeService(self, pRetVal) +proc GetLifetimeService*(self: ptr AppDomain, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLifetimeService(self, pRetVal) +proc get_Evidence*(self: ptr AppDomain, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Evidence(self, pRetVal) +proc add_DomainUnload*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_DomainUnload(self, value) +proc remove_DomainUnload*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_DomainUnload(self, value) +proc add_AssemblyLoad*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_AssemblyLoad(self, value) +proc remove_AssemblyLoad*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_AssemblyLoad(self, value) +proc add_ProcessExit*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_ProcessExit(self, value) +proc remove_ProcessExit*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_ProcessExit(self, value) +proc add_TypeResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_TypeResolve(self, value) +proc remove_TypeResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_TypeResolve(self, value) +proc add_ResourceResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_ResourceResolve(self, value) +proc remove_ResourceResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_ResourceResolve(self, value) +proc add_AssemblyResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_AssemblyResolve(self, value) +proc remove_AssemblyResolve*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_AssemblyResolve(self, value) +proc add_UnhandledException*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_UnhandledException(self, value) +proc remove_UnhandledException*(self: ptr AppDomain, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_UnhandledException(self, value) +proc DefineDynamicAssembly*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly(self, name, access, pRetVal) +proc DefineDynamicAssembly_2*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_2(self, name, access, dir, pRetVal) +proc DefineDynamicAssembly_3*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, Evidence: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_3(self, name, access, Evidence, pRetVal) +proc DefineDynamicAssembly_4*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_4(self, name, access, requiredPermissions, optionalPermissions, refusedPermissions, pRetVal) +proc DefineDynamicAssembly_5*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_5(self, name, access, dir, Evidence, pRetVal) +proc DefineDynamicAssembly_6*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_6(self, name, access, dir, requiredPermissions, optionalPermissions, refusedPermissions, pRetVal) +proc DefineDynamicAssembly_7*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_7(self, name, access, Evidence, requiredPermissions, optionalPermissions, refusedPermissions, pRetVal) +proc DefineDynamicAssembly_8*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_8(self, name, access, dir, Evidence, requiredPermissions, optionalPermissions, refusedPermissions, pRetVal) +proc DefineDynamicAssembly_9*(self: ptr AppDomain, name: POBJECT, access: AssemblyBuilderAccess, dir: BSTR, Evidence: POBJECT, requiredPermissions: POBJECT, optionalPermissions: POBJECT, refusedPermissions: POBJECT, IsSynchronized: VARIANT_BOOL, pRetVal: ptr ptr AssemblyBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineDynamicAssembly_9(self, name, access, dir, Evidence, requiredPermissions, optionalPermissions, refusedPermissions, IsSynchronized, pRetVal) +proc CreateInstance*(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, AssemblyName, typeName, pRetVal) +proc CreateInstanceFrom*(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstanceFrom(self, assemblyFile, typeName, pRetVal) +proc CreateInstance_2*(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, activationAttributes: ptr SAFEARRAY, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance_2(self, AssemblyName, typeName, activationAttributes, pRetVal) +proc CreateInstanceFrom_2*(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, activationAttributes: ptr SAFEARRAY, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstanceFrom_2(self, assemblyFile, typeName, activationAttributes, pRetVal) +proc CreateInstance_3*(self: ptr AppDomain, AssemblyName: BSTR, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, securityAttributes: POBJECT, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance_3(self, AssemblyName, typeName, ignoreCase, bindingAttr, Binder, args, culture, activationAttributes, securityAttributes, pRetVal) +proc CreateInstanceFrom_3*(self: ptr AppDomain, assemblyFile: BSTR, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, securityAttributes: POBJECT, pRetVal: ptr ptr ObjectHandle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstanceFrom_3(self, assemblyFile, typeName, ignoreCase, bindingAttr, Binder, args, culture, activationAttributes, securityAttributes, pRetVal) +proc Load*(self: ptr AppDomain, assemblyRef: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, assemblyRef, pRetVal) +proc Load_2*(self: ptr AppDomain, assemblyString: BSTR, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_2(self, assemblyString, pRetVal) +proc Load_3*(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_3(self, rawAssembly, pRetVal) +proc Load_4*(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_4(self, rawAssembly, rawSymbolStore, pRetVal) +proc Load_5*(self: ptr AppDomain, rawAssembly: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, securityEvidence: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_5(self, rawAssembly, rawSymbolStore, securityEvidence, pRetVal) +proc Load_6*(self: ptr AppDomain, assemblyRef: POBJECT, assemblySecurity: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_6(self, assemblyRef, assemblySecurity, pRetVal) +proc Load_7*(self: ptr AppDomain, assemblyString: BSTR, assemblySecurity: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load_7(self, assemblyString, assemblySecurity, pRetVal) +proc ExecuteAssembly*(self: ptr AppDomain, assemblyFile: BSTR, assemblySecurity: POBJECT, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteAssembly(self, assemblyFile, assemblySecurity, pRetVal) +proc ExecuteAssembly_2*(self: ptr AppDomain, assemblyFile: BSTR, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteAssembly_2(self, assemblyFile, pRetVal) +proc ExecuteAssembly_3*(self: ptr AppDomain, assemblyFile: BSTR, assemblySecurity: POBJECT, args: ptr SAFEARRAY, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecuteAssembly_3(self, assemblyFile, assemblySecurity, args, pRetVal) +proc get_FriendlyName*(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FriendlyName(self, pRetVal) +proc get_BaseDirectory*(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BaseDirectory(self, pRetVal) +proc get_RelativeSearchPath*(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RelativeSearchPath(self, pRetVal) +proc get_ShadowCopyFiles*(self: ptr AppDomain, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShadowCopyFiles(self, pRetVal) +proc GetAssemblies*(self: ptr AppDomain, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAssemblies(self, pRetVal) +proc AppendPrivatePath*(self: ptr AppDomain, Path: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppendPrivatePath(self, Path) +proc ClearPrivatePath*(self: ptr AppDomain): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearPrivatePath(self) +proc SetShadowCopyPath*(self: ptr AppDomain, s: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShadowCopyPath(self, s) +proc ClearShadowCopyPath*(self: ptr AppDomain): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearShadowCopyPath(self) +proc SetCachePath*(self: ptr AppDomain, s: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCachePath(self, s) +proc SetData*(self: ptr AppDomain, name: BSTR, data: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetData(self, name, data) +proc GetData*(self: ptr AppDomain, name: BSTR, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetData(self, name, pRetVal) +proc SetAppDomainPolicy*(self: ptr AppDomain, domainPolicy: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppDomainPolicy(self, domainPolicy) +proc SetThreadPrincipal*(self: ptr AppDomain, principal: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThreadPrincipal(self, principal) +proc SetPrincipalPolicy*(self: ptr AppDomain, policy: PrincipalPolicy): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPrincipalPolicy(self, policy) +proc DoCallBack*(self: ptr AppDomain, theDelegate: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoCallBack(self, theDelegate) +proc get_DynamicDirectory*(self: ptr AppDomain, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DynamicDirectory(self, pRetVal) +proc get_ToString*(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr IAssembly, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, other, pRetVal) +proc GetHashCode*(self: ptr IAssembly, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr IAssembly, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc get_CodeBase*(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CodeBase(self, pRetVal) +proc get_EscapedCodeBase*(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_EscapedCodeBase(self, pRetVal) +proc GetName*(self: ptr IAssembly, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName(self, pRetVal) +proc GetName_2*(self: ptr IAssembly, copiedName: VARIANT_BOOL, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName_2(self, copiedName, pRetVal) +proc get_FullName*(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FullName(self, pRetVal) +proc get_EntryPoint*(self: ptr IAssembly, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_EntryPoint(self, pRetVal) +proc GetType_2*(self: ptr IAssembly, name: BSTR, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType_2(self, name, pRetVal) +proc GetType_3*(self: ptr IAssembly, name: BSTR, throwOnError: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType_3(self, name, throwOnError, pRetVal) +proc GetExportedTypes*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExportedTypes(self, pRetVal) +proc GetTypes*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypes(self, pRetVal) +proc GetManifestResourceStream*(self: ptr IAssembly, Type: ptr IType, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetManifestResourceStream(self, Type, name, pRetVal) +proc GetManifestResourceStream_2*(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetManifestResourceStream_2(self, name, pRetVal) +proc GetFile*(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFile(self, name, pRetVal) +proc GetFiles*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFiles(self, pRetVal) +proc GetFiles_2*(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFiles_2(self, getResourceModules, pRetVal) +proc GetManifestResourceNames*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetManifestResourceNames(self, pRetVal) +proc GetManifestResourceInfo*(self: ptr IAssembly, resourceName: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetManifestResourceInfo(self, resourceName, pRetVal) +proc get_Location*(self: ptr IAssembly, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Location(self, pRetVal) +proc get_Evidence*(self: ptr IAssembly, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Evidence(self, pRetVal) +proc GetCustomAttributes*(self: ptr IAssembly, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes(self, attributeType, inherit, pRetVal) +proc GetCustomAttributes_2*(self: ptr IAssembly, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes_2(self, inherit, pRetVal) +proc IsDefined*(self: ptr IAssembly, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDefined(self, attributeType, inherit, pRetVal) +proc GetObjectData*(self: ptr IAssembly, info: POBJECT, Context: StreamingContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectData(self, info, Context) +proc add_ModuleResolve*(self: ptr IAssembly, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add_ModuleResolve(self, value) +proc remove_ModuleResolve*(self: ptr IAssembly, value: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove_ModuleResolve(self, value) +proc GetType_4*(self: ptr IAssembly, name: BSTR, throwOnError: VARIANT_BOOL, ignoreCase: VARIANT_BOOL, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType_4(self, name, throwOnError, ignoreCase, pRetVal) +proc GetSatelliteAssembly*(self: ptr IAssembly, culture: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSatelliteAssembly(self, culture, pRetVal) +proc GetSatelliteAssembly_2*(self: ptr IAssembly, culture: POBJECT, Version: POBJECT, pRetVal: ptr ptr IAssembly): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSatelliteAssembly_2(self, culture, Version, pRetVal) +proc LoadModule*(self: ptr IAssembly, moduleName: BSTR, rawModule: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadModule(self, moduleName, rawModule, pRetVal) +proc LoadModule_2*(self: ptr IAssembly, moduleName: BSTR, rawModule: ptr SAFEARRAY, rawSymbolStore: ptr SAFEARRAY, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadModule_2(self, moduleName, rawModule, rawSymbolStore, pRetVal) +proc CreateInstance*(self: ptr IAssembly, typeName: BSTR, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, typeName, pRetVal) +proc CreateInstance_2*(self: ptr IAssembly, typeName: BSTR, ignoreCase: VARIANT_BOOL, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance_2(self, typeName, ignoreCase, pRetVal) +proc CreateInstance_3*(self: ptr IAssembly, typeName: BSTR, ignoreCase: VARIANT_BOOL, bindingAttr: BindingFlags, Binder: POBJECT, args: ptr SAFEARRAY, culture: POBJECT, activationAttributes: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance_3(self, typeName, ignoreCase, bindingAttr, Binder, args, culture, activationAttributes, pRetVal) +proc GetLoadedModules*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLoadedModules(self, pRetVal) +proc GetLoadedModules_2*(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLoadedModules_2(self, getResourceModules, pRetVal) +proc GetModules*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetModules(self, pRetVal) +proc GetModules_2*(self: ptr IAssembly, getResourceModules: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetModules_2(self, getResourceModules, pRetVal) +proc GetModule*(self: ptr IAssembly, name: BSTR, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetModule(self, name, pRetVal) +proc GetReferencedAssemblies*(self: ptr IAssembly, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReferencedAssemblies(self, pRetVal) +proc get_GlobalAssemblyCache*(self: ptr IAssembly, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_GlobalAssemblyCache(self, pRetVal) +proc GetTypeInfoCount*(self: ptr IMethodInfo, pcTInfo: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoCount(self, pcTInfo) +proc GetTypeInfo*(self: ptr IMethodInfo, iTInfo: int32, lcid: int32, ppTInfo: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfo(self, iTInfo, lcid, ppTInfo) +proc GetIDsOfNames*(self: ptr IMethodInfo, riid: ptr GUID, rgszNames: int32, cNames: int32, lcid: int32, rgDispId: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDsOfNames(self, riid, rgszNames, cNames, lcid, rgDispId) +proc Invoke*(self: ptr IMethodInfo, dispIdMember: int32, riid: ptr GUID, lcid: int32, wFlags: int16, pDispParams: int32, pVarResult: int32, pExcepInfo: int32, puArgErr: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr) +proc get_ToString*(self: ptr IMethodInfo, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToString(self, pRetVal) +proc Equals*(self: ptr IMethodInfo, other: VARIANT, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Equals(self, other, pRetVal) +proc GetHashCode*(self: ptr IMethodInfo, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHashCode(self, pRetVal) +proc GetType*(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pRetVal) +proc get_MemberType*(self: ptr IMethodInfo, pRetVal: ptr MemberTypes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_MemberType(self, pRetVal) +proc get_name*(self: ptr IMethodInfo, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, pRetVal) +proc get_DeclaringType*(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DeclaringType(self, pRetVal) +proc get_ReflectedType*(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReflectedType(self, pRetVal) +proc GetCustomAttributes*(self: ptr IMethodInfo, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes(self, attributeType, inherit, pRetVal) +proc GetCustomAttributes_2*(self: ptr IMethodInfo, inherit: VARIANT_BOOL, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustomAttributes_2(self, inherit, pRetVal) +proc IsDefined*(self: ptr IMethodInfo, attributeType: ptr IType, inherit: VARIANT_BOOL, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDefined(self, attributeType, inherit, pRetVal) +proc GetParameters*(self: ptr IMethodInfo, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParameters(self, pRetVal) +proc GetMethodImplementationFlags*(self: ptr IMethodInfo, pRetVal: ptr MethodImplAttributes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMethodImplementationFlags(self, pRetVal) +proc get_MethodHandle*(self: ptr IMethodInfo, pRetVal: POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_MethodHandle(self, pRetVal) +proc get_Attributes*(self: ptr IMethodInfo, pRetVal: ptr MethodAttributes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Attributes(self, pRetVal) +proc get_CallingConvention*(self: ptr IMethodInfo, pRetVal: ptr CallingConventions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CallingConvention(self, pRetVal) +proc Invoke_2*(self: ptr IMethodInfo, obj: VARIANT, invokeAttr: BindingFlags, Binder: POBJECT, parameters: ptr SAFEARRAY, culture: POBJECT, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke_2(self, obj, invokeAttr, Binder, parameters, culture, pRetVal) +proc get_IsPublic*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsPublic(self, pRetVal) +proc get_IsPrivate*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsPrivate(self, pRetVal) +proc get_IsFamily*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFamily(self, pRetVal) +proc get_IsAssembly*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAssembly(self, pRetVal) +proc get_IsFamilyAndAssembly*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFamilyAndAssembly(self, pRetVal) +proc get_IsFamilyOrAssembly*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFamilyOrAssembly(self, pRetVal) +proc get_IsStatic*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsStatic(self, pRetVal) +proc get_IsFinal*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFinal(self, pRetVal) +proc get_IsVirtual*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsVirtual(self, pRetVal) +proc get_IsHideBySig*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsHideBySig(self, pRetVal) +proc get_IsAbstract*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsAbstract(self, pRetVal) +proc get_IsSpecialName*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSpecialName(self, pRetVal) +proc get_IsConstructor*(self: ptr IMethodInfo, pRetVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsConstructor(self, pRetVal) +proc Invoke_3*(self: ptr IMethodInfo, obj: VARIANT, parameters: ptr SAFEARRAY, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke_3(self, obj, parameters, pRetVal) +proc get_returnType*(self: ptr IMethodInfo, pRetVal: ptr ptr IType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_returnType(self, pRetVal) +proc get_ReturnTypeCustomAttributes*(self: ptr IMethodInfo, pRetVal: ptr POBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReturnTypeCustomAttributes(self, pRetVal) +proc GetBaseDefinition*(self: ptr IMethodInfo, pRetVal: ptr ptr IMethodInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBaseDefinition(self, pRetVal) +converter winimConverterIGCHostToIUnknown*(x: ptr IGCHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGCHost2ToIGCHost*(x: ptr IGCHost2): ptr IGCHost = cast[ptr IGCHost](x) +converter winimConverterIGCHost2ToIUnknown*(x: ptr IGCHost2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIVEHandlerToIUnknown*(x: ptr IVEHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIValidatorToIUnknown*(x: ptr IValidator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRValidatorToIUnknown*(x: ptr ICLRValidator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectHandleToIUnknown*(x: ptr IObjectHandle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAppDomainBindingToIUnknown*(x: ptr IAppDomainBinding): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGCThreadControlToIUnknown*(x: ptr IGCThreadControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGCHostControlToIUnknown*(x: ptr IGCHostControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICorThreadpoolToIUnknown*(x: ptr ICorThreadpool): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDebuggerThreadControlToIUnknown*(x: ptr IDebuggerThreadControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDebuggerInfoToIUnknown*(x: ptr IDebuggerInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICorConfigurationToIUnknown*(x: ptr ICorConfiguration): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICorRuntimeHostToIUnknown*(x: ptr ICorRuntimeHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRMemoryNotificationCallbackToIUnknown*(x: ptr ICLRMemoryNotificationCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostMallocToIUnknown*(x: ptr IHostMalloc): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostMemoryManagerToIUnknown*(x: ptr IHostMemoryManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRTaskToIUnknown*(x: ptr ICLRTask): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRTask2ToICLRTask*(x: ptr ICLRTask2): ptr ICLRTask = cast[ptr ICLRTask](x) +converter winimConverterICLRTask2ToIUnknown*(x: ptr ICLRTask2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostTaskToIUnknown*(x: ptr IHostTask): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRTaskManagerToIUnknown*(x: ptr ICLRTaskManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostTaskManagerToIUnknown*(x: ptr IHostTaskManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostThreadpoolManagerToIUnknown*(x: ptr IHostThreadpoolManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRIoCompletionManagerToIUnknown*(x: ptr ICLRIoCompletionManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostIoCompletionManagerToIUnknown*(x: ptr IHostIoCompletionManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRDebugManagerToIUnknown*(x: ptr ICLRDebugManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRErrorReportingManagerToIUnknown*(x: ptr ICLRErrorReportingManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostCrstToIUnknown*(x: ptr IHostCrst): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostAutoEventToIUnknown*(x: ptr IHostAutoEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostManualEventToIUnknown*(x: ptr IHostManualEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostSemaphoreToIUnknown*(x: ptr IHostSemaphore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRSyncManagerToIUnknown*(x: ptr ICLRSyncManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostSyncManagerToIUnknown*(x: ptr IHostSyncManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRPolicyManagerToIUnknown*(x: ptr ICLRPolicyManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostPolicyManagerToIUnknown*(x: ptr IHostPolicyManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActionOnCLREventToIUnknown*(x: ptr IActionOnCLREvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLROnEventManagerToIUnknown*(x: ptr ICLROnEventManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostGCManagerToIUnknown*(x: ptr IHostGCManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRAssemblyReferenceListToIUnknown*(x: ptr ICLRAssemblyReferenceList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRReferenceAssemblyEnumToIUnknown*(x: ptr ICLRReferenceAssemblyEnum): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRProbingAssemblyEnumToIUnknown*(x: ptr ICLRProbingAssemblyEnum): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRAssemblyIdentityManagerToIUnknown*(x: ptr ICLRAssemblyIdentityManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRHostBindingPolicyManagerToIUnknown*(x: ptr ICLRHostBindingPolicyManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRGCManagerToIUnknown*(x: ptr ICLRGCManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRGCManager2ToICLRGCManager*(x: ptr ICLRGCManager2): ptr ICLRGCManager = cast[ptr ICLRGCManager](x) +converter winimConverterICLRGCManager2ToIUnknown*(x: ptr ICLRGCManager2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostAssemblyStoreToIUnknown*(x: ptr IHostAssemblyStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostAssemblyManagerToIUnknown*(x: ptr IHostAssemblyManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostControlToIUnknown*(x: ptr IHostControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRControlToIUnknown*(x: ptr ICLRControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRRuntimeHostToIUnknown*(x: ptr ICLRRuntimeHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRHostProtectionManagerToIUnknown*(x: ptr ICLRHostProtectionManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRDomainManagerToIUnknown*(x: ptr ICLRDomainManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeNameToIUnknown*(x: ptr ITypeName): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeNameBuilderToIUnknown*(x: ptr ITypeNameBuilder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeNameFactoryToIUnknown*(x: ptr ITypeNameFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApartmentCallbackToIUnknown*(x: ptr IApartmentCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIManagedObjectToIUnknown*(x: ptr IManagedObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICatalogServicesToIUnknown*(x: ptr ICatalogServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostSecurityContextToIUnknown*(x: ptr IHostSecurityContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostSecurityManagerToIUnknown*(x: ptr IHostSecurityManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRAppDomainResourceMonitorToIUnknown*(x: ptr ICLRAppDomainResourceMonitor): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRMetaHostToIUnknown*(x: ptr ICLRMetaHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRMetaHostPolicyToIUnknown*(x: ptr ICLRMetaHostPolicy): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRProfilingToIUnknown*(x: ptr ICLRProfiling): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRDebuggingLibraryProviderToIUnknown*(x: ptr ICLRDebuggingLibraryProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRDebuggingToIUnknown*(x: ptr ICLRDebugging): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRRuntimeInfoToIUnknown*(x: ptr ICLRRuntimeInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRStrongNameToIUnknown*(x: ptr ICLRStrongName): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRStrongName2ToIUnknown*(x: ptr ICLRStrongName2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICLRStrongName3ToIUnknown*(x: ptr ICLRStrongName3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectToIDispatch*(x: ptr IObject): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIObjectToIUnknown*(x: ptr IObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeToIUnknown*(x: ptr IType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAppDomainSetupToIUnknown*(x: ptr IAppDomainSetup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterObjectHandleToIDispatch*(x: ptr ObjectHandle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterObjectHandleToIUnknown*(x: ptr ObjectHandle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterAppDomainToIDispatch*(x: ptr AppDomain): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterAppDomainToIUnknown*(x: ptr AppDomain): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAssemblyToIDispatch*(x: ptr IAssembly): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIAssemblyToIUnknown*(x: ptr IAssembly): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMethodInfoToIUnknown*(x: ptr IMethodInfo): ptr IUnknown = cast[ptr IUnknown](x) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/mshtml.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/mshtml.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,20084 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import winuser +import objbase +import imm +import objext +#include +#include +#include +#include +#include +type + DXGI_FORMAT* = int32 + DXGI_MODE_ROTATION* = int32 + DXGI_MODE_SCANLINE_ORDER* = int32 + DXGI_MODE_SCALING* = int32 + htmlBlockAlign* = int32 + htmlClear* = int32 + htmlControlAlign* = int32 + htmlDesignMode* = int32 + htmlReadyState* = int32 + htmlZOrder* = int32 + htmlLoop* = int32 + mediaType* = int32 + DomConstructor* = int32 + styleBackgroundAttachment* = int32 + styleBackgroundAttachment3* = int32 + styleBackgroundClip* = int32 + styleBackgroundOrigin* = int32 + styleBackgroundRepeat* = int32 + styleBorderCollapse* = int32 + styleCaptionSide* = int32 + styleDataRepeat* = int32 + styleEmptyCells* = int32 + styleFontStyle* = int32 + styleFontVariant* = int32 + styleFontSize* = int32 + styleFontWeight* = int32 + styleMsOverflowStyle* = int32 + styleOverflow* = int32 + styleTableLayout* = int32 + styleTextTransform* = int32 + styleVerticalAlign* = int32 + styleWidowsOrphans* = int32 + styleZIndex* = int32 + styleAuto* = int32 + styleNone* = int32 + styleNormal* = int32 + styleBorderWidth* = int32 + stylePosition* = int32 + styleBorderStyle* = int32 + styleOutlineStyle* = int32 + styleStyleFloat* = int32 + styleDisplay* = int32 + styleVisibility* = int32 + styleListStyleType* = int32 + styleListStylePosition* = int32 + styleWhiteSpace* = int32 + stylePageBreak* = int32 + stylePageBreakInside* = int32 + styleCursor* = int32 + styleDir* = int32 + styleBidi* = int32 + styleImeMode* = int32 + styleRubyAlign* = int32 + styleRubyPosition* = int32 + styleRubyOverhang* = int32 + styleLayoutGridChar* = int32 + styleLayoutGridLine* = int32 + styleLayoutGridMode* = int32 + styleLayoutGridType* = int32 + styleLineBreak* = int32 + styleWordBreak* = int32 + styleWordWrap* = int32 + styleTextJustify* = int32 + styleTextAlignLast* = int32 + styleTextJustifyTrim* = int32 + styleAccelerator* = int32 + styleLayoutFlow* = int32 + styleBlockProgression* = int32 + styleWritingMode* = int32 + styleBool* = int32 + styleTextUnderlinePosition* = int32 + styleTextOverflow* = int32 + styleInterpolation* = int32 + styleBoxSizing* = int32 + styleMsFlex* = int32 + styleMsFlexPreferredSize* = int32 + styleMsFlexDirection* = int32 + styleMsFlexWrap* = int32 + styleMsFlexAlign* = int32 + styleMsFlexItemAlign* = int32 + styleMsFlexPack* = int32 + styleMsFlexLinePack* = int32 + styleColumnFill* = int32 + styleColumnSpan* = int32 + styleBreak* = int32 + styleBreakInside* = int32 + styleMsScrollChaining* = int32 + styleMsContentZooming* = int32 + styleMsContentZoomSnapType* = int32 + styleMsScrollRails* = int32 + styleMsContentZoomChaining* = int32 + styleMsScrollSnapType* = int32 + styleGridColumn* = int32 + styleGridColumnAlign* = int32 + styleGridColumnSpan* = int32 + styleGridRow* = int32 + styleGridRowAlign* = int32 + styleGridRowSpan* = int32 + styleWrapThrough* = int32 + styleWrapFlow* = int32 + styleAlignmentBaseline* = int32 + styleBaselineShift* = int32 + styleClipRule* = int32 + styleDominantBaseline* = int32 + styleFillRule* = int32 + styleFontStretch* = int32 + stylePointerEvents* = int32 + styleEnableBackground* = int32 + styleStrokeLinecap* = int32 + styleStrokeLinejoin* = int32 + styleTextAnchor* = int32 + styleAttrType* = int32 + styleInitialColor* = int32 + styleInitialString* = int32 + styleTransformOriginX* = int32 + styleTransformOriginY* = int32 + stylePerspectiveOriginX* = int32 + stylePerspectiveOriginY* = int32 + styleTransformStyle* = int32 + styleBackfaceVisibility* = int32 + styleTextSizeAdjust* = int32 + styleColorInterpolationFilters* = int32 + styleHyphens* = int32 + styleHyphenateLimitLines* = int32 + styleMsAnimationPlayState* = int32 + styleMsAnimationDirection* = int32 + styleMsAnimationFillMode* = int32 + styleMsHighContrastAdjust* = int32 + styleMsUserSelect* = int32 + styleMsTouchAction* = int32 + styleMsTouchSelect* = int32 + styleMsScrollTranslation* = int32 + styleViewportSize* = int32 + styleUserZoom* = int32 + styleTextLineThroughStyle* = int32 + styleTextUnderlineStyle* = int32 + styleTextEffect* = int32 + styleDefaultTextSelection* = int32 + styleTextDecoration* = int32 + textDecoration* = int32 + htmlListType* = int32 + htmlMethod* = int32 + htmlWrap* = int32 + htmlDir* = int32 + htmlEditable* = int32 + htmlInput* = int32 + htmlSpellCheck* = int32 + htmlEncoding* = int32 + htmlAdjacency* = int32 + htmlTabIndex* = int32 + htmlComponent* = int32 + htmlApplyLocation* = int32 + htmlGlyphMode* = int32 + htmlDraggable* = int32 + htmlUnit* = int32 + htmlEndPoints* = int32 + htmlDirection* = int32 + htmlStart* = int32 + bodyScroll* = int32 + htmlSelectType* = int32 + htmlSelectExFlag* = int32 + htmlSelection* = int32 + htmlMarqueeBehavior* = int32 + htmlMarqueeDirection* = int32 + htmlPersistState* = int32 + htmlDropEffect* = int32 + htmlEffectAllowed* = int32 + htmlCompatMode* = int32 + BoolValue* = int32 + htmlCaptionAlign* = int32 + htmlCaptionVAlign* = int32 + htmlFrame* = int32 + htmlRules* = int32 + htmlCellAlign* = int32 + htmlCellVAlign* = int32 + frameScrolling* = int32 + sandboxAllow* = int32 + svgAngleType* = int32 + svgExternalResourcesRequired* = int32 + svgFocusable* = int32 + svgLengthType* = int32 + svgPathSegType* = int32 + svgTransformType* = int32 + svgPreserveAspectRatioAlignType* = int32 + svgPreserveAspectMeetOrSliceType* = int32 + svgUnitTypes* = int32 + svgSpreadMethod* = int32 + svgFeblendMode* = int32 + svgFecolormatrixType* = int32 + svgFecomponenttransferType* = int32 + svgFecompositeOperator* = int32 + svgEdgemode* = int32 + svgPreserveAlpha* = int32 + svgChannel* = int32 + svgMorphologyOperator* = int32 + svgTurbulenceType* = int32 + svgStitchtype* = int32 + svgMarkerUnits* = int32 + svgMarkerOrient* = int32 + svgMarkerOrientAttribute* = int32 + htmlMediaNetworkState* = int32 + htmlMediaReadyState* = int32 + htmlMediaErr* = int32 + lengthAdjust* = int32 + textpathMethodtype* = int32 + textpathSpacingtype* = int32 + ELEMENT_CORNER* = int32 + SECUREURLHOSTVALIDATE_FLAGS* = int32 + POINTER_GRAVITY* = int32 + ELEMENT_ADJACENCY* = int32 + MARKUP_CONTEXT_TYPE* = int32 + FINDTEXT_FLAGS* = int32 + MOVEUNIT_ACTION* = int32 + PARSE_FLAGS* = int32 + ELEMENT_TAG_ID* = int32 + SELECTION_TYPE* = int32 + SAVE_SEGMENTS_FLAGS* = int32 + CARET_DIRECTION* = int32 + LINE_DIRECTION* = int32 + HT_OPTIONS* = int32 + HT_RESULTS* = int32 + DISPLAY_MOVEUNIT* = int32 + DISPLAY_GRAVITY* = int32 + DISPLAY_BREAK* = int32 + COORD_SYSTEM* = int32 + DEV_CONSOLE_MESSAGE_LEVEL* = int32 + DOM_EVENT_PHASE* = int32 + SCRIPT_TIMER_TYPE* = int32 + HTML_PAINTER* = int32 + HTML_PAINT_ZORDER* = int32 + HTML_PAINT_DRAW_FLAGS* = int32 + HTML_PAINT_EVENT_FLAGS* = int32 + HTML_PAINT_DRAW_INFO_FLAGS* = int32 + HTMLDlgFlag* = int32 + HTMLDlgBorder* = int32 + HTMLDlgEdge* = int32 + HTMLDlgCenter* = int32 + HTMLAppFlag* = int32 + HTMLMinimizeFlag* = int32 + HTMLMaximizeFlag* = int32 + HTMLCaptionFlag* = int32 + HTMLSysMenuFlag* = int32 + HTMLBorder* = int32 + HTMLBorderStyle* = int32 + HTMLWindowState* = int32 + BEHAVIOR_EVENT* = int32 + BEHAVIOR_EVENT_FLAGS* = int32 + BEHAVIOR_RENDER_INFO* = int32 + BEHAVIOR_RELATION* = int32 + BEHAVIOR_LAYOUT_INFO* = int32 + BEHAVIOR_LAYOUT_MODE* = int32 + ELEMENTDESCRIPTOR_FLAGS* = int32 + ELEMENTNAMESPACE_FLAGS* = int32 + VIEW_OBJECT_ALPHA_MODE* = int32 + VIEW_OBJECT_COMPOSITION_MODE* = int32 + DOCHOSTUIDBLCLK* = int32 + DOCHOSTUIFLAG* = int32 + DOCHOSTUITYPE* = int32 + D3DCOLORVALUE* {.pure.} = object + r*: float32 + g*: float32 + b*: float32 + a*: float32 + DXGI_RGBA* = D3DCOLORVALUE + IClassFactoryEx* {.pure.} = object + lpVtbl*: ptr IClassFactoryExVtbl + IClassFactoryExVtbl* {.pure, inheritable.} = object of IClassFactoryVtbl + CreateInstanceWithContext*: proc(self: ptr IClassFactoryEx, punkContext: ptr IUnknown, punkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IClassFactory3* = IClassFactoryEx +const + SID_VariantConversion* = DEFINE_GUID("1f101481-bccd-11d0-9336-00a0c90dcaa9") + SID_GetCaller* = DEFINE_GUID("4717cc40-bcb9-11d0-9336-00a0c90dcaa9") + SID_ProvideRuntimeContext* = DEFINE_GUID("74a5040c-dd0c-48f0-ac85-194c3259180a") + SID_GetScriptSite* = IID_IActiveScriptSite + fdexNameCaseSensitive* = 0x1 + fdexNameEnsure* = 0x2 + fdexNameImplicit* = 0x4 + fdexNameCaseInsensitive* = 0x8 + fdexNameInternal* = 0x10 + fdexNameNoDynamicProperties* = 0x20 + fdexPropCanGet* = 0x1 + fdexPropCannotGet* = 0x2 + fdexPropCanPut* = 0x4 + fdexPropCannotPut* = 0x8 + fdexPropCanPutRef* = 0x10 + fdexPropCannotPutRef* = 0x20 + fdexPropNoSideEffects* = 0x40 + fdexPropDynamicType* = 0x80 + fdexPropCanCall* = 0x100 + fdexPropCannotCall* = 0x200 + fdexPropCanConstruct* = 0x400 + fdexPropCannotConstruct* = 0x800 + fdexPropCanSourceEvents* = 0x1000 + fdexPropCannotSourceEvents* = 0x02000 + grfdexPropCanAll* = fdexPropCanGet or fdexPropCanPut or fdexPropCanPutRef or fdexPropCanCall or fdexPropCanConstruct or fdexPropCanSourceEvents + grfdexPropCannotAll* = fdexPropCannotGet or fdexPropCannotPut or fdexPropCannotPutRef or fdexPropCannotCall or fdexPropCannotConstruct or fdexPropCannotSourceEvents + grfdexPropExtraAll* = fdexPropNoSideEffects or fdexPropDynamicType + grfdexPropAll* = grfdexPropCanAll or grfdexPropCannotAll or grfdexPropExtraAll + fdexEnumDefault* = 0x1 + fdexEnumAll* = 0x2 + DISPATCH_CONSTRUCT* = 0x4000 + DISPID_STARTENUM* = DISPID_UNKNOWN + IID_IDispatchEx* = DEFINE_GUID("a6ef9860-c720-11d0-9337-00a0c90dcaa9") + IID_IDispError* = DEFINE_GUID("a6ef9861-c720-11d0-9337-00a0c90dcaa9") + IID_IVariantChangeType* = DEFINE_GUID("a6ef9862-c720-11d0-9337-00a0c90dcaa9") + IID_IObjectIdentity* = DEFINE_GUID("ca04b7e6-0d21-11d1-8cc5-00c04fc2b085") + IID_ICanHandleException* = DEFINE_GUID("c5598e60-b307-11d1-b27d-006008c3fbfb") + IID_IProvideRuntimeContext* = DEFINE_GUID("10e2414a-ec59-49d2-bc51-5add2c36febc") + DXGI_FORMAT_DEFINED* = 1 + DXGI_FORMAT_UNKNOWN* = 0 + DXGI_FORMAT_R32G32B32A32_TYPELESS* = 1 + DXGI_FORMAT_R32G32B32A32_FLOAT* = 2 + DXGI_FORMAT_R32G32B32A32_UINT* = 3 + DXGI_FORMAT_R32G32B32A32_SINT* = 4 + DXGI_FORMAT_R32G32B32_TYPELESS* = 5 + DXGI_FORMAT_R32G32B32_FLOAT* = 6 + DXGI_FORMAT_R32G32B32_UINT* = 7 + DXGI_FORMAT_R32G32B32_SINT* = 8 + DXGI_FORMAT_R16G16B16A16_TYPELESS* = 9 + DXGI_FORMAT_R16G16B16A16_FLOAT* = 10 + DXGI_FORMAT_R16G16B16A16_UNORM* = 11 + DXGI_FORMAT_R16G16B16A16_UINT* = 12 + DXGI_FORMAT_R16G16B16A16_SNORM* = 13 + DXGI_FORMAT_R16G16B16A16_SINT* = 14 + DXGI_FORMAT_R32G32_TYPELESS* = 15 + DXGI_FORMAT_R32G32_FLOAT* = 16 + DXGI_FORMAT_R32G32_UINT* = 17 + DXGI_FORMAT_R32G32_SINT* = 18 + DXGI_FORMAT_R32G8X24_TYPELESS* = 19 + DXGI_FORMAT_D32_FLOAT_S8X24_UINT* = 20 + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS* = 21 + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT* = 22 + DXGI_FORMAT_R10G10B10A2_TYPELESS* = 23 + DXGI_FORMAT_R10G10B10A2_UNORM* = 24 + DXGI_FORMAT_R10G10B10A2_UINT* = 25 + DXGI_FORMAT_R11G11B10_FLOAT* = 26 + DXGI_FORMAT_R8G8B8A8_TYPELESS* = 27 + DXGI_FORMAT_R8G8B8A8_UNORM* = 28 + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB* = 29 + DXGI_FORMAT_R8G8B8A8_UINT* = 30 + DXGI_FORMAT_R8G8B8A8_SNORM* = 31 + DXGI_FORMAT_R8G8B8A8_SINT* = 32 + DXGI_FORMAT_R16G16_TYPELESS* = 33 + DXGI_FORMAT_R16G16_FLOAT* = 34 + DXGI_FORMAT_R16G16_UNORM* = 35 + DXGI_FORMAT_R16G16_UINT* = 36 + DXGI_FORMAT_R16G16_SNORM* = 37 + DXGI_FORMAT_R16G16_SINT* = 38 + DXGI_FORMAT_R32_TYPELESS* = 39 + DXGI_FORMAT_D32_FLOAT* = 40 + DXGI_FORMAT_R32_FLOAT* = 41 + DXGI_FORMAT_R32_UINT* = 42 + DXGI_FORMAT_R32_SINT* = 43 + DXGI_FORMAT_R24G8_TYPELESS* = 44 + DXGI_FORMAT_D24_UNORM_S8_UINT* = 45 + DXGI_FORMAT_R24_UNORM_X8_TYPELESS* = 46 + DXGI_FORMAT_X24_TYPELESS_G8_UINT* = 47 + DXGI_FORMAT_R8G8_TYPELESS* = 48 + DXGI_FORMAT_R8G8_UNORM* = 49 + DXGI_FORMAT_R8G8_UINT* = 50 + DXGI_FORMAT_R8G8_SNORM* = 51 + DXGI_FORMAT_R8G8_SINT* = 52 + DXGI_FORMAT_R16_TYPELESS* = 53 + DXGI_FORMAT_R16_FLOAT* = 54 + DXGI_FORMAT_D16_UNORM* = 55 + DXGI_FORMAT_R16_UNORM* = 56 + DXGI_FORMAT_R16_UINT* = 57 + DXGI_FORMAT_R16_SNORM* = 58 + DXGI_FORMAT_R16_SINT* = 59 + DXGI_FORMAT_R8_TYPELESS* = 60 + DXGI_FORMAT_R8_UNORM* = 61 + DXGI_FORMAT_R8_UINT* = 62 + DXGI_FORMAT_R8_SNORM* = 63 + DXGI_FORMAT_R8_SINT* = 64 + DXGI_FORMAT_A8_UNORM* = 65 + DXGI_FORMAT_R1_UNORM* = 66 + DXGI_FORMAT_R9G9B9E5_SHAREDEXP* = 67 + DXGI_FORMAT_R8G8_B8G8_UNORM* = 68 + DXGI_FORMAT_G8R8_G8B8_UNORM* = 69 + DXGI_FORMAT_BC1_TYPELESS* = 70 + DXGI_FORMAT_BC1_UNORM* = 71 + DXGI_FORMAT_BC1_UNORM_SRGB* = 72 + DXGI_FORMAT_BC2_TYPELESS* = 73 + DXGI_FORMAT_BC2_UNORM* = 74 + DXGI_FORMAT_BC2_UNORM_SRGB* = 75 + DXGI_FORMAT_BC3_TYPELESS* = 76 + DXGI_FORMAT_BC3_UNORM* = 77 + DXGI_FORMAT_BC3_UNORM_SRGB* = 78 + DXGI_FORMAT_BC4_TYPELESS* = 79 + DXGI_FORMAT_BC4_UNORM* = 80 + DXGI_FORMAT_BC4_SNORM* = 81 + DXGI_FORMAT_BC5_TYPELESS* = 82 + DXGI_FORMAT_BC5_UNORM* = 83 + DXGI_FORMAT_BC5_SNORM* = 84 + DXGI_FORMAT_B5G6R5_UNORM* = 85 + DXGI_FORMAT_B5G5R5A1_UNORM* = 86 + DXGI_FORMAT_B8G8R8A8_UNORM* = 87 + DXGI_FORMAT_B8G8R8X8_UNORM* = 88 + DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM* = 89 + DXGI_FORMAT_B8G8R8A8_TYPELESS* = 90 + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB* = 91 + DXGI_FORMAT_B8G8R8X8_TYPELESS* = 92 + DXGI_FORMAT_B8G8R8X8_UNORM_SRGB* = 93 + DXGI_FORMAT_BC6H_TYPELESS* = 94 + DXGI_FORMAT_BC6H_UF16* = 95 + DXGI_FORMAT_BC6H_SF16* = 96 + DXGI_FORMAT_BC7_TYPELESS* = 97 + DXGI_FORMAT_BC7_UNORM* = 98 + DXGI_FORMAT_BC7_UNORM_SRGB* = 99 + DXGI_FORMAT_AYUV* = 100 + DXGI_FORMAT_Y410* = 101 + DXGI_FORMAT_Y416* = 102 + DXGI_FORMAT_NV12* = 103 + DXGI_FORMAT_P010* = 104 + DXGI_FORMAT_P016* = 105 + DXGI_FORMAT_420_OPAQUE* = 106 + DXGI_FORMAT_YUY2* = 107 + DXGI_FORMAT_Y210* = 108 + DXGI_FORMAT_Y216* = 109 + DXGI_FORMAT_NV11* = 110 + DXGI_FORMAT_AI44* = 111 + DXGI_FORMAT_IA44* = 112 + DXGI_FORMAT_P8* = 113 + DXGI_FORMAT_A8P8* = 114 + DXGI_FORMAT_B4G4R4A4_UNORM* = 115 + DXGI_FORMAT_FORCE_UINT* = 0xffffffff'i32 + DXGI_MODE_ROTATION_UNSPECIFIED* = 0 + DXGI_MODE_ROTATION_IDENTITY* = 1 + DXGI_MODE_ROTATION_ROTATE90* = 2 + DXGI_MODE_ROTATION_ROTATE180* = 3 + DXGI_MODE_ROTATION_ROTATE270* = 4 + DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED* = 0 + DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE* = 1 + DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST* = 2 + DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST* = 3 + DXGI_MODE_SCALING_UNSPECIFIED* = 0 + DXGI_MODE_SCALING_CENTERED* = 1 + DXGI_MODE_SCALING_STRETCHED* = 2 + SID_SEditCommandTarget* = DEFINE_GUID("3050f4b5-98b5-11cf-bb82-00aa00bdce0b") + CGID_EditStateCommands* = DEFINE_GUID("3050f4b6-98b5-11cf-bb82-00aa00bdce0b") + SID_SHTMLEditHost* = DEFINE_GUID("3050f6a0-98b5-11cf-bb82-00aa00bdce0b") + SID_SHTMLEditServices* = DEFINE_GUID("3050f7f9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow2* = DEFINE_GUID("332c4427-26cb-11d0-b483-00c04fd90119") + SID_SHTMLWindow* = IID_IHTMLWindow2 + IID_IElementBehaviorFactory* = DEFINE_GUID("3050f429-98b5-11cf-bb82-00aa00bdce0b") + SID_SElementBehaviorFactory* = IID_IElementBehaviorFactory + IID_ITrackingProtection* = DEFINE_GUID("30510803-98b5-11cf-bb82-00aa00bdce0b") + SID_STrackingProtection* = IID_ITrackingProtection + COOKIEACTION_NONE* = 0x0 + COOKIEACTION_ACCEPT* = 0x1 + COOKIEACTION_REJECT* = 0x2 + COOKIEACTION_DOWNGRADE* = 0x4 + COOKIEACTION_LEASH* = 0x8 + COOKIEACTION_SUPPRESS* = 0x10 + COOKIEACTION_READ* = 0x20 + PRIVACY_URLISTOPLEVEL* = 0x10000 + PRIVACY_URLHASCOMPACTPOLICY* = 0x20000 + PRIVACY_URLHASPOSTDATA* = 0x80000 + PRIVACY_URLHASPOLICYREFLINK* = 0x100000 + PRIVACY_URLHASPOLICYREFHEADER* = 0x200000 + PRIVACY_URLHASP3PHEADER* = 0x400000 + DEBUGCALLBACKNOTIFICATION_TIMEOUT* = 0x1 + DEBUGCALLBACKNOTIFICATION_INTERVAL* = 0x2 + DEBUGCALLBACKNOTIFICATION_IMMEDIATE* = 0x4 + DEBUGCALLBACKNOTIFICATION_ANIMATIONFRAME* = 0x8 + DEBUGCALLBACKNOTIFICATION_DOMEVENT* = 0x10 + DEBUGDOMEVENTPROPAGATIONSTATUS_DEFAULTCANCELED* = 0x1 + DEBUGDOMEVENTPROPAGATIONSTATUS_STOPIMMEDIATEPROPAGATION* = 0x2 + DEBUGDOMEVENTPROPAGATIONSTATUS_STOPPROPAGATION* = 0x4 + IID_IHTMLFiltersCollection* = DEFINE_GUID("3050f3ee-98b5-11cf-bb82-00aa00bdce0b") + IID_IIE70DispatchEx* = DEFINE_GUID("3051046b-98b5-11cf-bb82-00aa00bdce0b") + IID_IIE80DispatchEx* = DEFINE_GUID("3051046c-98b5-11cf-bb82-00aa00bdce0b") + LIBID_MSHTML* = DEFINE_GUID("3050f1c5-98b5-11cf-bb82-00aa00bdce0b") + htmlBlockAlignNotSet* = 0 + htmlBlockAlignLeft* = 1 + htmlBlockAlignCenter* = 2 + htmlBlockAlignRight* = 3 + htmlBlockAlignJustify* = 4 + htmlBlockAlign_Max* = 0x7fffffff + htmlClearNotSet* = 0 + htmlClearAll* = 1 + htmlClearLeft* = 2 + htmlClearRight* = 3 + htmlClearBoth* = 4 + htmlClearNone* = 5 + htmlClear_Max* = 0x7fffffff + htmlControlAlignNotSet* = 0 + htmlControlAlignLeft* = 1 + htmlControlAlignCenter* = 2 + htmlControlAlignRight* = 3 + htmlControlAlignTextTop* = 4 + htmlControlAlignAbsMiddle* = 5 + htmlControlAlignBaseline* = 6 + htmlControlAlignAbsBottom* = 7 + htmlControlAlignBottom* = 8 + htmlControlAlignMiddle* = 9 + htmlControlAlignTop* = 10 + htmlControlAlign_Max* = 0x7fffffff + htmlDesignModeInherit* = -2 + htmlDesignModeOn* = -1 + htmlDesignModeOff* = 0 + htmlDesignMode_Max* = 0x7fffffff + htmlReadyStateuninitialized* = 0 + htmlReadyStateloading* = 1 + htmlReadyStateloaded* = 2 + htmlReadyStateinteractive* = 3 + htmlReadyStatecomplete* = 4 + htmlReadyState_Max* = 0x7fffffff + htmlZOrderFront* = 0 + htmlZOrderBack* = 1 + htmlZOrder_Max* = 0x7fffffff + htmlLoopLoopInfinite* = -1 + htmlLoop_Max* = 0x7fffffff + mediaTypeNotSet* = 0 + mediaTypeAll* = 511 + mediaTypeAural* = 1 + mediaTypeBraille* = 2 + mediaTypeEmbossed* = 4 + mediaTypeHandheld* = 8 + mediaTypePrint* = 16 + mediaTypeProjection* = 32 + mediaTypeScreen* = 64 + mediaTypeTty* = 128 + mediaTypeTv* = 256 + mediaType_Max* = 0x7fffffff + domConstructorObject* = 0 + domConstructorAttr* = 1 + domConstructorBehaviorUrnsCollection* = 2 + domConstructorBookmarkCollection* = 3 + domConstructorCompatibleInfo* = 4 + domConstructorCompatibleInfoCollection* = 5 + domConstructorControlRangeCollection* = 6 + domConstructorCSSCurrentStyleDeclaration* = 7 + domConstructorCSSRuleList* = 8 + domConstructorCSSRuleStyleDeclaration* = 9 + domConstructorCSSStyleDeclaration* = 10 + domConstructorCSSStyleRule* = 11 + domConstructorCSSStyleSheet* = 12 + domConstructorDataTransfer* = 13 + domConstructorDOMImplementation* = 14 + domConstructorElement* = 15 + domConstructorEvent* = 16 + domConstructorHistory* = 17 + domConstructorHTCElementBehaviorDefaults* = 18 + domConstructorHTMLAnchorElement* = 19 + domConstructorHTMLAreaElement* = 20 + domConstructorHTMLAreasCollection* = 21 + domConstructorHTMLBaseElement* = 22 + domConstructorHTMLBaseFontElement* = 23 + domConstructorHTMLBGSoundElement* = 24 + domConstructorHTMLBlockElement* = 25 + domConstructorHTMLBodyElement* = 26 + domConstructorHTMLBRElement* = 27 + domConstructorHTMLButtonElement* = 28 + domConstructorHTMLCollection* = 29 + domConstructorHTMLCommentElement* = 30 + domConstructorHTMLDDElement* = 31 + domConstructorHTMLDivElement* = 32 + domConstructorHTMLDocument* = 33 + domConstructorHTMLDListElement* = 34 + domConstructorHTMLDTElement* = 35 + domConstructorHTMLEmbedElement* = 36 + domConstructorHTMLFieldSetElement* = 37 + domConstructorHTMLFontElement* = 38 + domConstructorHTMLFormElement* = 39 + domConstructorHTMLFrameElement* = 40 + domConstructorHTMLFrameSetElement* = 41 + domConstructorHTMLGenericElement* = 42 + domConstructorHTMLHeadElement* = 43 + domConstructorHTMLHeadingElement* = 44 + domConstructorHTMLHRElement* = 45 + domConstructorHTMLHtmlElement* = 46 + domConstructorHTMLIFrameElement* = 47 + domConstructorHTMLImageElement* = 48 + domConstructorHTMLInputElement* = 49 + domConstructorHTMLIsIndexElement* = 50 + domConstructorHTMLLabelElement* = 51 + domConstructorHTMLLegendElement* = 52 + domConstructorHTMLLIElement* = 53 + domConstructorHTMLLinkElement* = 54 + domConstructorHTMLMapElement* = 55 + domConstructorHTMLMarqueeElement* = 56 + domConstructorHTMLMetaElement* = 57 + domConstructorHTMLModelessDialog* = 58 + domConstructorHTMLNamespaceInfo* = 59 + domConstructorHTMLNamespaceInfoCollection* = 60 + domConstructorHTMLNextIdElement* = 61 + domConstructorHTMLNoShowElement* = 62 + domConstructorHTMLObjectElement* = 63 + domConstructorHTMLOListElement* = 64 + domConstructorHTMLOptionElement* = 65 + domConstructorHTMLParagraphElement* = 66 + domConstructorHTMLParamElement* = 67 + domConstructorHTMLPhraseElement* = 68 + domConstructorHTMLPluginsCollection* = 69 + domConstructorHTMLPopup* = 70 + domConstructorHTMLScriptElement* = 71 + domConstructorHTMLSelectElement* = 72 + domConstructorHTMLSpanElement* = 73 + domConstructorHTMLStyleElement* = 74 + domConstructorHTMLTableCaptionElement* = 75 + domConstructorHTMLTableCellElement* = 76 + domConstructorHTMLTableColElement* = 77 + domConstructorHTMLTableElement* = 78 + domConstructorHTMLTableRowElement* = 79 + domConstructorHTMLTableSectionElement* = 80 + domConstructorHTMLTextAreaElement* = 81 + domConstructorHTMLTextElement* = 82 + domConstructorHTMLTitleElement* = 83 + domConstructorHTMLUListElement* = 84 + domConstructorHTMLUnknownElement* = 85 + domConstructorImage* = 86 + domConstructorLocation* = 87 + domConstructorNamedNodeMap* = 88 + domConstructorNavigator* = 89 + domConstructorNodeList* = 90 + domConstructorOption* = 91 + domConstructorScreen* = 92 + domConstructorSelection* = 93 + domConstructorStaticNodeList* = 94 + domConstructorStorage* = 95 + domConstructorStyleSheetList* = 96 + domConstructorStyleSheetPage* = 97 + domConstructorStyleSheetPageList* = 98 + domConstructorText* = 99 + domConstructorTextRange* = 100 + domConstructorTextRangeCollection* = 101 + domConstructorTextRectangle* = 102 + domConstructorTextRectangleList* = 103 + domConstructorWindow* = 104 + domConstructorXDomainRequest* = 105 + domConstructorXMLHttpRequest* = 106 + domConstructorMax* = 107 + DomConstructor_Max* = 0x7fffffff + styleBackgroundAttachmentFixed* = 0 + styleBackgroundAttachmentScroll* = 1 + styleBackgroundAttachmentNotSet* = 2 + styleBackgroundAttachment_Max* = 0x7fffffff + styleBackgroundAttachment3Fixed* = 0 + styleBackgroundAttachment3Scroll* = 1 + styleBackgroundAttachment3Local* = 2 + styleBackgroundAttachment3NotSet* = 3 + styleBackgroundAttachment3_Max* = 0x7fffffff + styleBackgroundClipBorderBox* = 0 + styleBackgroundClipPaddingBox* = 1 + styleBackgroundClipContentBox* = 2 + styleBackgroundClipNotSet* = 3 + styleBackgroundClip_Max* = 0x7fffffff + styleBackgroundOriginBorderBox* = 0 + styleBackgroundOriginPaddingBox* = 1 + styleBackgroundOriginContentBox* = 2 + styleBackgroundOriginNotSet* = 3 + styleBackgroundOrigin_Max* = 0x7fffffff + styleBackgroundRepeatRepeat* = 0 + styleBackgroundRepeatRepeatX* = 1 + styleBackgroundRepeatRepeatY* = 2 + styleBackgroundRepeatNoRepeat* = 3 + styleBackgroundRepeatNotSet* = 4 + styleBackgroundRepeat_Max* = 0x7fffffff + styleBorderCollapseNotSet* = 0 + styleBorderCollapseSeparate* = 1 + styleBorderCollapseCollapse* = 2 + styleBorderCollapse_Max* = 0x7fffffff + styleCaptionSideNotSet* = 0 + styleCaptionSideTop* = 1 + styleCaptionSideBottom* = 2 + styleCaptionSideLeft* = 3 + styleCaptionSideRight* = 4 + styleCaptionSide_Max* = 0x7fffffff + styleDataRepeatNone* = 0 + styleDataRepeatInner* = 1 + styleDataRepeat_Max* = 0x7fffffff + styleEmptyCellsNotSet* = 0 + styleEmptyCellsShow* = 1 + styleEmptyCellsHide* = 2 + styleEmptyCells_Max* = 0x7fffffff + styleFontStyleNotSet* = 0 + styleFontStyleItalic* = 1 + styleFontStyleOblique* = 2 + styleFontStyleNormal* = 3 + styleFontStyle_Max* = 0x7fffffff + styleFontVariantNotSet* = 0 + styleFontVariantSmallCaps* = 1 + styleFontVariantNormal* = 2 + styleFontVariant_Max* = 0x7fffffff + styleFontSizeXXSmall* = 0 + styleFontSizeXSmall* = 1 + styleFontSizeSmall* = 2 + styleFontSizeMedium* = 3 + styleFontSizeLarge* = 4 + styleFontSizeXLarge* = 5 + styleFontSizeXXLarge* = 6 + styleFontSizeSmaller* = 7 + styleFontSizeLarger* = 8 + styleFontSize_Max* = 0x7fffffff + styleFontWeightNotSet* = 0 + styleFontWeight100* = 1 + styleFontWeight200* = 2 + styleFontWeight300* = 3 + styleFontWeight400* = 4 + styleFontWeight500* = 5 + styleFontWeight600* = 6 + styleFontWeight700* = 7 + styleFontWeight800* = 8 + styleFontWeight900* = 9 + styleFontWeightNormal* = 10 + styleFontWeightBold* = 11 + styleFontWeightBolder* = 12 + styleFontWeightLighter* = 13 + styleFontWeight_Max* = 0x7fffffff + styleMsOverflowStyleNotSet* = 0 + styleMsOverflowStyleAuto* = 1 + styleMsOverflowStyleNone* = 2 + styleMsOverflowStyleScrollbar* = 3 + styleMsOverflowStyleMsAutoHidingScrollbar* = 4 + styleMsOverflowStyle_Max* = 0x7fffffff + styleOverflowNotSet* = 0 + styleOverflowAuto* = 1 + styleOverflowHidden* = 2 + styleOverflowVisible* = 3 + styleOverflowScroll* = 4 + styleOverflow_Max* = 0x7fffffff + styleTableLayoutNotSet* = 0 + styleTableLayoutAuto* = 1 + styleTableLayoutFixed* = 2 + styleTableLayout_Max* = 0x7fffffff + styleTextTransformNotSet* = 0 + styleTextTransformCapitalize* = 1 + styleTextTransformLowercase* = 2 + styleTextTransformUppercase* = 3 + styleTextTransformNone* = 4 + styleTextTransform_Max* = 0x7fffffff + styleVerticalAlignAuto* = 0 + styleVerticalAlignBaseline* = 1 + styleVerticalAlignSub* = 2 + styleVerticalAlignSuper* = 3 + styleVerticalAlignTop* = 4 + styleVerticalAlignTextTop* = 5 + styleVerticalAlignMiddle* = 6 + styleVerticalAlignBottom* = 7 + styleVerticalAlignTextBottom* = 8 + styleVerticalAlignInherit* = 9 + styleVerticalAlignNotSet* = 10 + styleVerticalAlign_Max* = 0x7fffffff + styleWidowsOrphansNotSet* = -2147483647 + styleWidowsOrphans_Max* = 0x7fffffff + styleZIndexAuto* = -2147483647 + styleZIndex_Max* = 0x7fffffff + styleAutoAuto* = 0 + styleAuto_Max* = 0x7fffffff + styleNoneNone* = 0 + styleNone_Max* = 0x7fffffff + styleNormalNormal* = 0 + styleNormal_Max* = 0x7fffffff + styleBorderWidthThin* = 0 + styleBorderWidthMedium* = 1 + styleBorderWidthThick* = 2 + styleBorderWidth_Max* = 0x7fffffff + stylePositionNotSet* = 0 + stylePositionstatic* = 1 + stylePositionrelative* = 2 + stylePositionabsolute* = 3 + stylePositionfixed* = 4 + stylePositionMsPage* = 5 + stylePosition_Max* = 0x7fffffff + styleBorderStyleNotSet* = 0 + styleBorderStyleDotted* = 1 + styleBorderStyleDashed* = 2 + styleBorderStyleSolid* = 3 + styleBorderStyleDouble* = 4 + styleBorderStyleGroove* = 5 + styleBorderStyleRidge* = 6 + styleBorderStyleInset* = 7 + styleBorderStyleOutset* = 8 + styleBorderStyleWindowInset* = 9 + styleBorderStyleNone* = 10 + styleBorderStyleHidden* = 11 + styleBorderStyle_Max* = 0x7fffffff + styleOutlineStyleNotSet* = 0 + styleOutlineStyleDotted* = 1 + styleOutlineStyleDashed* = 2 + styleOutlineStyleSolid* = 3 + styleOutlineStyleDouble* = 4 + styleOutlineStyleGroove* = 5 + styleOutlineStyleRidge* = 6 + styleOutlineStyleInset* = 7 + styleOutlineStyleOutset* = 8 + styleOutlineStyleWindowInset* = 9 + styleOutlineStyleNone* = 10 + styleOutlineStyle_Max* = 0x7fffffff + styleStyleFloatNotSet* = 0 + styleStyleFloatLeft* = 1 + styleStyleFloatRight* = 2 + styleStyleFloatNone* = 3 + styleStyleFloat_Max* = 0x7fffffff + styleDisplayNotSet* = 0 + styleDisplayBlock* = 1 + styleDisplayInline* = 2 + styleDisplayListItem* = 3 + styleDisplayNone* = 4 + styleDisplayTableHeaderGroup* = 5 + styleDisplayTableFooterGroup* = 6 + styleDisplayInlineBlock* = 7 + styleDisplayTable* = 8 + styleDisplayInlineTable* = 9 + styleDisplayTableRow* = 10 + styleDisplayTableRowGroup* = 11 + styleDisplayTableColumn* = 12 + styleDisplayTableColumnGroup* = 13 + styleDisplayTableCell* = 14 + styleDisplayTableCaption* = 15 + styleDisplayRunIn* = 16 + styleDisplayRuby* = 17 + styleDisplayRubyBase* = 18 + styleDisplayRubyText* = 19 + styleDisplayRubyBaseContainer* = 20 + styleDisplayRubyTextContainer* = 21 + styleDisplayMsFlexbox* = 22 + styleDisplayMsInlineFlexbox* = 23 + styleDisplayMsGrid* = 24 + styleDisplayMsInlineGrid* = 25 + styleDisplay_Max* = 0x7fffffff + styleVisibilityNotSet* = 0 + styleVisibilityInherit* = 1 + styleVisibilityVisible* = 2 + styleVisibilityHidden* = 3 + styleVisibilityCollapse* = 4 + styleVisibility_Max* = 0x7fffffff + styleListStyleTypeNotSet* = 0 + styleListStyleTypeDisc* = 1 + styleListStyleTypeCircle* = 2 + styleListStyleTypeSquare* = 3 + styleListStyleTypeDecimal* = 4 + styleListStyleTypeLowerRoman* = 5 + styleListStyleTypeUpperRoman* = 6 + styleListStyleTypeLowerAlpha* = 7 + styleListStyleTypeUpperAlpha* = 8 + styleListStyleTypeNone* = 9 + styleListStyleTypeDecimalLeadingZero* = 10 + styleListStyleTypeGeorgian* = 11 + styleListStyleTypeArmenian* = 12 + styleListStyleTypeUpperLatin* = 13 + styleListStyleTypeLowerLatin* = 14 + styleListStyleTypeUpperGreek* = 15 + styleListStyleTypeLowerGreek* = 16 + styleListStyleType_Max* = 0x7fffffff + styleListStylePositionNotSet* = 0 + styleListStylePositionInside* = 1 + styleListStylePositionOutSide* = 2 + styleListStylePosition_Max* = 0x7fffffff + styleWhiteSpaceNotSet* = 0 + styleWhiteSpaceNormal* = 1 + styleWhiteSpacePre* = 2 + styleWhiteSpaceNowrap* = 3 + styleWhiteSpacePreline* = 4 + styleWhiteSpacePrewrap* = 5 + styleWhiteSpace_Max* = 0x7fffffff + stylePageBreakNotSet* = 0 + stylePageBreakAuto* = 1 + stylePageBreakAlways* = 2 + stylePageBreakLeft* = 3 + stylePageBreakRight* = 4 + stylePageBreakAvoid* = 5 + stylePageBreak_Max* = 0x7fffffff + stylePageBreakInsideNotSet* = 0 + stylePageBreakInsideAuto* = 1 + stylePageBreakInsideAvoid* = 2 + stylePageBreakInside_Max* = 0x7fffffff + styleCursorAuto* = 0 + styleCursorCrosshair* = 1 + styleCursorDefault* = 2 + styleCursorHand* = 3 + styleCursorMove* = 4 + styleCursorE_resize* = 5 + styleCursorNe_resize* = 6 + styleCursorNw_resize* = 7 + styleCursorN_resize* = 8 + styleCursorSe_resize* = 9 + styleCursorSw_resize* = 10 + styleCursorS_resize* = 11 + styleCursorW_resize* = 12 + styleCursorText* = 13 + styleCursorWait* = 14 + styleCursorHelp* = 15 + styleCursorPointer* = 16 + styleCursorProgress* = 17 + styleCursorNot_allowed* = 18 + styleCursorNo_drop* = 19 + styleCursorVertical_text* = 20 + styleCursorall_scroll* = 21 + styleCursorcol_resize* = 22 + styleCursorrow_resize* = 23 + styleCursorNone* = 24 + styleCursorContext_menu* = 25 + styleCursorEw_resize* = 26 + styleCursorNs_resize* = 27 + styleCursorNesw_resize* = 28 + styleCursorNwse_resize* = 29 + styleCursorCell* = 30 + styleCursorCopy* = 31 + styleCursorAlias* = 32 + styleCursorcustom* = 33 + styleCursorNotSet* = 34 + styleCursor_Max* = 0x7fffffff + styleDirNotSet* = 0 + styleDirLeftToRight* = 1 + styleDirRightToLeft* = 2 + styleDirInherit* = 3 + styleDir_Max* = 0x7fffffff + styleBidiNotSet* = 0 + styleBidiNormal* = 1 + styleBidiEmbed* = 2 + styleBidiOverride* = 3 + styleBidiInherit* = 4 + styleBidi_Max* = 0x7fffffff + styleImeModeAuto* = 0 + styleImeModeActive* = 1 + styleImeModeInactive* = 2 + styleImeModeDisabled* = 3 + styleImeModeNotSet* = 4 + styleImeMode_Max* = 0x7fffffff + styleRubyAlignNotSet* = 0 + styleRubyAlignAuto* = 1 + styleRubyAlignLeft* = 2 + styleRubyAlignCenter* = 3 + styleRubyAlignRight* = 4 + styleRubyAlignDistributeLetter* = 5 + styleRubyAlignDistributeSpace* = 6 + styleRubyAlignLineEdge* = 7 + styleRubyAlign_Max* = 0x7fffffff + styleRubyPositionNotSet* = 0 + styleRubyPositionAbove* = 1 + styleRubyPositionInline* = 2 + styleRubyPosition_Max* = 0x7fffffff + styleRubyOverhangNotSet* = 0 + styleRubyOverhangAuto* = 1 + styleRubyOverhangWhitespace* = 2 + styleRubyOverhangNone* = 3 + styleRubyOverhang_Max* = 0x7fffffff + styleLayoutGridCharNotSet* = 0 + styleLayoutGridCharAuto* = 1 + styleLayoutGridCharNone* = 2 + styleLayoutGridChar_Max* = 0x7fffffff + styleLayoutGridLineNotSet* = 0 + styleLayoutGridLineAuto* = 1 + styleLayoutGridLineNone* = 2 + styleLayoutGridLine_Max* = 0x7fffffff + styleLayoutGridModeNotSet* = 0 + styleLayoutGridModeChar* = 1 + styleLayoutGridModeLine* = 2 + styleLayoutGridModeBoth* = 3 + styleLayoutGridModeNone* = 4 + styleLayoutGridMode_Max* = 0x7fffffff + styleLayoutGridTypeNotSet* = 0 + styleLayoutGridTypeLoose* = 1 + styleLayoutGridTypeStrict* = 2 + styleLayoutGridTypeFixed* = 3 + styleLayoutGridType_Max* = 0x7fffffff + styleLineBreakNotSet* = 0 + styleLineBreakNormal* = 1 + styleLineBreakStrict* = 2 + styleLineBreak_Max* = 0x7fffffff + styleWordBreakNotSet* = 0 + styleWordBreakNormal* = 1 + styleWordBreakBreakAll* = 2 + styleWordBreakKeepAll* = 3 + styleWordBreak_Max* = 0x7fffffff + styleWordWrapNotSet* = 0 + styleWordWrapOff* = 1 + styleWordWrapOn* = 2 + styleWordWrap_Max* = 0x7fffffff + styleTextJustifyNotSet* = 0 + styleTextJustifyInterWord* = 1 + styleTextJustifyNewspaper* = 2 + styleTextJustifyDistribute* = 3 + styleTextJustifyDistributeAllLines* = 4 + styleTextJustifyInterIdeograph* = 5 + styleTextJustifyInterCluster* = 6 + styleTextJustifyKashida* = 7 + styleTextJustifyAuto* = 8 + styleTextJustify_Max* = 0x7fffffff + styleTextAlignLastNotSet* = 0 + styleTextAlignLastLeft* = 1 + styleTextAlignLastCenter* = 2 + styleTextAlignLastRight* = 3 + styleTextAlignLastJustify* = 4 + styleTextAlignLastAuto* = 5 + styleTextAlignLast_Max* = 0x7fffffff + styleTextJustifyTrimNotSet* = 0 + styleTextJustifyTrimNone* = 1 + styleTextJustifyTrimPunctuation* = 2 + styleTextJustifyTrimPunctAndKana* = 3 + styleTextJustifyTrim_Max* = 0x7fffffff + styleAcceleratorFalse* = 0 + styleAcceleratorTrue* = 1 + styleAccelerator_Max* = 0x7fffffff + styleLayoutFlowHorizontal* = 0 + styleLayoutFlowVerticalIdeographic* = 1 + styleLayoutFlowNotSet* = 2 + styleLayoutFlow_Max* = 0x7fffffff + styleBlockProgressionTb* = 0 + styleBlockProgressionRl* = 1 + styleBlockProgressionBt* = 2 + styleBlockProgressionLr* = 3 + styleBlockProgressionNotSet* = 4 + styleBlockProgression_Max* = 0x7fffffff + styleWritingModeLrtb* = 0 + styleWritingModeTbrl* = 1 + styleWritingModeRltb* = 2 + styleWritingModeBtrl* = 3 + styleWritingModeNotSet* = 4 + styleWritingModeTblr* = 5 + styleWritingModeBtlr* = 6 + styleWritingModeLrbt* = 7 + styleWritingModeRlbt* = 8 + styleWritingModeLr* = 9 + styleWritingModeRl* = 10 + styleWritingModeTb* = 11 + styleWritingMode_Max* = 0x7fffffff + styleBoolFalse* = 0 + styleBoolTrue* = 1 + styleBool_Max* = 0x7fffffff + styleTextUnderlinePositionBelow* = 0 + styleTextUnderlinePositionAbove* = 1 + styleTextUnderlinePositionAuto* = 2 + styleTextUnderlinePositionNotSet* = 3 + styleTextUnderlinePosition_Max* = 0x7fffffff + styleTextOverflowClip* = 0 + styleTextOverflowEllipsis* = 1 + styleTextOverflowNotSet* = 2 + styleTextOverflow_Max* = 0x7fffffff + styleInterpolationNotSet* = 0 + styleInterpolationNN* = 1 + styleInterpolationBCH* = 2 + styleInterpolation_Max* = 0x7fffffff + styleBoxSizingNotSet* = 0 + styleBoxSizingContentBox* = 1 + styleBoxSizingBorderBox* = 2 + styleBoxSizing_Max* = 0x7fffffff + styleMsFlexNone* = 0 + styleMsFlexNotSet* = 1 + styleMsFlex_Max* = 0x7fffffff + styleMsFlexPreferredSizeAuto* = 0 + styleMsFlexPreferredSizeNotSet* = 1 + styleMsFlexPreferredSize_Max* = 0x7fffffff + styleMsFlexDirectionRow* = 0 + styleMsFlexDirectionRowReverse* = 1 + styleMsFlexDirectionColumn* = 2 + styleMsFlexDirectionColumnReverse* = 3 + styleMsFlexDirectionNotSet* = 4 + styleMsFlexDirection_Max* = 0x7fffffff + styleMsFlexWrapNowrap* = 0 + styleMsFlexWrapWrap* = 1 + styleMsFlexWrapWrapReverse* = 2 + styleMsFlexWrapNotSet* = 3 + styleMsFlexWrap_Max* = 0x7fffffff + styleMsFlexAlignStart* = 0 + styleMsFlexAlignEnd* = 1 + styleMsFlexAlignCenter* = 2 + styleMsFlexAlignBaseline* = 3 + styleMsFlexAlignStretch* = 4 + styleMsFlexAlignNotSet* = 5 + styleMsFlexAlign_Max* = 0x7fffffff + styleMsFlexItemAlignStart* = 0 + styleMsFlexItemAlignEnd* = 1 + styleMsFlexItemAlignCenter* = 2 + styleMsFlexItemAlignBaseline* = 3 + styleMsFlexItemAlignStretch* = 4 + styleMsFlexItemAlignAuto* = 5 + styleMsFlexItemAlignNotSet* = 6 + styleMsFlexItemAlign_Max* = 0x7fffffff + styleMsFlexPackStart* = 0 + styleMsFlexPackEnd* = 1 + styleMsFlexPackCenter* = 2 + styleMsFlexPackJustify* = 3 + styleMsFlexPackDistribute* = 4 + styleMsFlexPackNotSet* = 5 + styleMsFlexPack_Max* = 0x7fffffff + styleMsFlexLinePackStart* = 0 + styleMsFlexLinePackEnd* = 1 + styleMsFlexLinePackCenter* = 2 + styleMsFlexLinePackJustify* = 3 + styleMsFlexLinePackDistribute* = 4 + styleMsFlexLinePackStretch* = 5 + styleMsFlexLinePackNotSet* = 6 + styleMsFlexLinePack_Max* = 0x7fffffff + styleColumnFillAuto* = 0 + styleColumnFillBalance* = 1 + styleColumnFillNotSet* = 2 + styleColumnFill_Max* = 0x7fffffff + styleColumnSpanOne* = 0 + styleColumnSpanAll* = 1 + styleColumnSpanNotSet* = 2 + styleColumnSpan_Max* = 0x7fffffff + styleBreakNotSet* = 0 + styleBreakAuto* = 1 + styleBreakAlways* = 2 + styleBreakAvoid* = 3 + styleBreakLeft* = 4 + styleBreakRight* = 5 + styleBreakPage* = 6 + styleBreakColumn* = 7 + styleBreakAvoidPage* = 8 + styleBreakAvoidColumn* = 9 + styleBreak_Max* = 0x7fffffff + styleBreakInsideNotSet* = 0 + styleBreakInsideAuto* = 1 + styleBreakInsideAvoid* = 2 + styleBreakInsideAvoidPage* = 3 + styleBreakInsideAvoidColumn* = 4 + styleBreakInside_Max* = 0x7fffffff + styleMsScrollChainingNotSet* = 0 + styleMsScrollChainingNone* = 1 + styleMsScrollChainingChained* = 2 + styleMsScrollChaining_Max* = 0x7fffffff + styleMsContentZoomingNotSet* = 0 + styleMsContentZoomingNone* = 1 + styleMsContentZoomingZoom* = 2 + styleMsContentZooming_Max* = 0x7fffffff + styleMsContentZoomSnapTypeNotSet* = 0 + styleMsContentZoomSnapTypeNone* = 1 + styleMsContentZoomSnapTypeMandatory* = 2 + styleMsContentZoomSnapTypeProximity* = 3 + styleMsContentZoomSnapType_Max* = 0x7fffffff + styleMsScrollRailsNotSet* = 0 + styleMsScrollRailsNone* = 1 + styleMsScrollRailsRailed* = 2 + styleMsScrollRails_Max* = 0x7fffffff + styleMsContentZoomChainingNotSet* = 0 + styleMsContentZoomChainingNone* = 1 + styleMsContentZoomChainingChained* = 2 + styleMsContentZoomChaining_Max* = 0x7fffffff + styleMsScrollSnapTypeNotSet* = 0 + styleMsScrollSnapTypeNone* = 1 + styleMsScrollSnapTypeMandatory* = 2 + styleMsScrollSnapTypeProximity* = 3 + styleMsScrollSnapType_Max* = 0x7fffffff + styleGridColumnNotSet* = 0 + styleGridColumn_Max* = 0x7fffffff + styleGridColumnAlignCenter* = 0 + styleGridColumnAlignEnd* = 1 + styleGridColumnAlignStart* = 2 + styleGridColumnAlignStretch* = 3 + styleGridColumnAlignNotSet* = 4 + styleGridColumnAlign_Max* = 0x7fffffff + styleGridColumnSpanNotSet* = 0 + styleGridColumnSpan_Max* = 0x7fffffff + styleGridRowNotSet* = 0 + styleGridRow_Max* = 0x7fffffff + styleGridRowAlignCenter* = 0 + styleGridRowAlignEnd* = 1 + styleGridRowAlignStart* = 2 + styleGridRowAlignStretch* = 3 + styleGridRowAlignNotSet* = 4 + styleGridRowAlign_Max* = 0x7fffffff + styleGridRowSpanNotSet* = 0 + styleGridRowSpan_Max* = 0x7fffffff + styleWrapThroughNotSet* = 0 + styleWrapThroughWrap* = 1 + styleWrapThroughNone* = 2 + styleWrapThrough_Max* = 0x7fffffff + styleWrapFlowNotSet* = 0 + styleWrapFlowAuto* = 1 + styleWrapFlowBoth* = 2 + styleWrapFlowStart* = 3 + styleWrapFlowEnd* = 4 + styleWrapFlowClear* = 5 + styleWrapFlowMinimum* = 6 + styleWrapFlowMaximum* = 7 + styleWrapFlow_Max* = 0x7fffffff + styleAlignmentBaselineNotSet* = 0 + styleAlignmentBaselineAfterEdge* = 1 + styleAlignmentBaselineAlphabetic* = 2 + styleAlignmentBaselineAuto* = 3 + styleAlignmentBaselineBaseline* = 4 + styleAlignmentBaselineBeforeEdge* = 5 + styleAlignmentBaselineCentral* = 6 + styleAlignmentBaselineHanging* = 7 + styleAlignmentBaselineMathematical* = 8 + styleAlignmentBaselineMiddle* = 9 + styleAlignmentBaselineTextAfterEdge* = 10 + styleAlignmentBaselineTextBeforeEdge* = 11 + styleAlignmentBaselineIdeographic* = 12 + styleAlignmentBaseline_Max* = 0x7fffffff + styleBaselineShiftBaseline* = 0 + styleBaselineShiftSub* = 1 + styleBaselineShiftSuper* = 2 + styleBaselineShift_Max* = 0x7fffffff + styleClipRuleNotSet* = 0 + styleClipRuleNonZero* = 1 + styleClipRuleEvenOdd* = 2 + styleClipRule_Max* = 0x7fffffff + styleDominantBaselineNotSet* = 0 + styleDominantBaselineAlphabetic* = 1 + styleDominantBaselineAuto* = 2 + styleDominantBaselineCentral* = 3 + styleDominantBaselineHanging* = 4 + styleDominantBaselineIdeographic* = 5 + styleDominantBaselineMathematical* = 6 + styleDominantBaselineMiddle* = 7 + styleDominantBaselineNoChange* = 8 + styleDominantBaselineResetSize* = 9 + styleDominantBaselineTextAfterEdge* = 10 + styleDominantBaselineTextBeforeEdge* = 11 + styleDominantBaselineUseScript* = 12 + styleDominantBaseline_Max* = 0x7fffffff + styleFillRuleNotSet* = 0 + styleFillRuleNonZero* = 1 + styleFillRuleEvenOdd* = 2 + styleFillRule_Max* = 0x7fffffff + styleFontStretchNotSet* = 0 + styleFontStretchWider* = 1 + styleFontStretchNarrower* = 2 + styleFontStretchUltraCondensed* = 3 + styleFontStretchExtraCondensed* = 4 + styleFontStretchCondensed* = 5 + styleFontStretchSemiCondensed* = 6 + styleFontStretchNormal* = 7 + styleFontStretchSemiExpanded* = 8 + styleFontStretchExpanded* = 9 + styleFontStretchExtraExpanded* = 10 + styleFontStretchUltraExpanded* = 11 + styleFontStretch_Max* = 0x7fffffff + stylePointerEventsNotSet* = 0 + stylePointerEventsVisiblePainted* = 1 + stylePointerEventsVisibleFill* = 2 + stylePointerEventsVisibleStroke* = 3 + stylePointerEventsVisible* = 4 + stylePointerEventsPainted* = 5 + stylePointerEventsFill* = 6 + stylePointerEventsStroke* = 7 + stylePointerEventsAll* = 8 + stylePointerEventsNone* = 9 + stylePointerEvents_Max* = 0x7fffffff + styleEnableBackgroundNotSet* = 0 + styleEnableBackgroundAccumulate* = 1 + styleEnableBackgroundNew* = 2 + styleEnableBackgroundInherit* = 3 + styleEnableBackground_Max* = 0x7fffffff + styleStrokeLinecapNotSet* = 0 + styleStrokeLinecapButt* = 1 + styleStrokeLinecapRound* = 2 + styleStrokeLinecapSquare* = 3 + styleStrokeLinecap_Max* = 0x7fffffff + styleStrokeLinejoinNotSet* = 0 + styleStrokeLinejoinMiter* = 1 + styleStrokeLinejoinRound* = 2 + styleStrokeLinejoinBevel* = 3 + styleStrokeLinejoin_Max* = 0x7fffffff + styleTextAnchorNotSet* = 0 + styleTextAnchorStart* = 1 + styleTextAnchorMiddle* = 2 + styleTextAnchorEnd* = 3 + styleTextAnchor_Max* = 0x7fffffff + styleAttrTypeString* = 0 + styleAttrTypeColor* = 1 + styleAttrTypeUrl* = 2 + styleAttrTypeInteger* = 3 + styleAttrTypeNumber* = 4 + styleAttrTypeLength* = 5 + styleAttrTypePx* = 6 + styleAttrTypeEm* = 7 + styleAttrTypeEx* = 8 + styleAttrTypeIn* = 9 + styleAttrTypeCm* = 10 + styleAttrTypeMm* = 11 + styleAttrTypePt* = 12 + styleAttrTypePc* = 13 + styleAttrTypeRem* = 14 + styleAttrTypeCh* = 15 + styleAttrTypeVh* = 16 + styleAttrTypeVw* = 17 + styleAttrTypeVmin* = 18 + styleAttrTypePercentage* = 19 + styleAttrTypeAngle* = 20 + styleAttrTypeDeg* = 21 + styleAttrTypeRad* = 22 + styleAttrTypeGrad* = 23 + styleAttrTypeTime* = 24 + styleAttrTypeS* = 25 + styleAttrTypeMs* = 26 + styleAttrType_Max* = 0x7fffffff + styleInitialColorNoInitial* = 0 + styleInitialColorColorProperty* = 1 + styleInitialColorTransparent* = 2 + styleInitialColorInvert* = 3 + styleInitialColor_Max* = 0x7fffffff + styleInitialStringNoInitial* = 0 + styleInitialStringNone* = 1 + styleInitialStringAuto* = 2 + styleInitialStringNormal* = 3 + styleInitialString_Max* = 0x7fffffff + styleTransformOriginXNotSet* = 0 + styleTransformOriginXLeft* = 1 + styleTransformOriginXCenter* = 2 + styleTransformOriginXRight* = 3 + styleTransformOriginX_Max* = 0x7fffffff + styleTransformOriginYNotSet* = 0 + styleTransformOriginYTop* = 1 + styleTransformOriginYCenter* = 2 + styleTransformOriginYBottom* = 3 + styleTransformOriginY_Max* = 0x7fffffff + stylePerspectiveOriginXNotSet* = 0 + stylePerspectiveOriginXLeft* = 1 + stylePerspectiveOriginXCenter* = 2 + stylePerspectiveOriginXRight* = 3 + stylePerspectiveOriginX_Max* = 0x7fffffff + stylePerspectiveOriginYNotSet* = 0 + stylePerspectiveOriginYTop* = 1 + stylePerspectiveOriginYCenter* = 2 + stylePerspectiveOriginYBottom* = 3 + stylePerspectiveOriginY_Max* = 0x7fffffff + styleTransformStyleFlat* = 0 + styleTransformStyleNotSet* = 1 + styleTransformStyle_Max* = 0x7fffffff + styleBackfaceVisibilityVisible* = 0 + styleBackfaceVisibilityHidden* = 1 + styleBackfaceVisibilityNotSet* = 2 + styleBackfaceVisibility_Max* = 0x7fffffff + styleTextSizeAdjustNone* = 0 + styleTextSizeAdjustAuto* = 1 + styleTextSizeAdjust_Max* = 0x7fffffff + styleColorInterpolationFiltersAuto* = 0 + styleColorInterpolationFiltersSRgb* = 1 + styleColorInterpolationFiltersLinearRgb* = 2 + styleColorInterpolationFiltersNotSet* = 3 + styleColorInterpolationFilters_Max* = 0x7fffffff + styleHyphensNone* = 0 + styleHyphensManual* = 1 + styleHyphensAuto* = 2 + styleHyphensNotSet* = 3 + styleHyphens_Max* = 0x7fffffff + styleHyphenateLimitLinesNoLimit* = 0 + styleHyphenateLimitLines_Max* = 0x7fffffff + styleMsAnimationPlayStateRunning* = 0 + styleMsAnimationPlayStatePaused* = 1 + styleMsAnimationPlayStateNotSet* = 2 + styleMsAnimationPlayState_Max* = 0x7fffffff + styleMsAnimationDirectionNormal* = 0 + styleMsAnimationDirectionAlternate* = 1 + styleMsAnimationDirectionReverse* = 2 + styleMsAnimationDirectionAlternateReverse* = 3 + styleMsAnimationDirectionNotSet* = 4 + styleMsAnimationDirection_Max* = 0x7fffffff + styleMsAnimationFillModeNone* = 0 + styleMsAnimationFillModeForwards* = 1 + styleMsAnimationFillModeBackwards* = 2 + styleMsAnimationFillModeBoth* = 3 + styleMsAnimationFillModeNotSet* = 4 + styleMsAnimationFillMode_Max* = 0x7fffffff + styleMsHighContrastAdjustNotSet* = 0 + styleMsHighContrastAdjustAuto* = 1 + styleMsHighContrastAdjustNone* = 2 + styleMsHighContrastAdjust_Max* = 0x7fffffff + styleMsUserSelectAuto* = 0 + styleMsUserSelectText* = 1 + styleMsUserSelectElement* = 2 + styleMsUserSelectNone* = 3 + styleMsUserSelectNotSet* = 4 + styleMsUserSelect_Max* = 0x7fffffff + styleMsTouchActionNotSet* = -1 + styleMsTouchActionNone* = 0 + styleMsTouchActionAuto* = 1 + styleMsTouchActionManipulation* = 2 + styleMsTouchActionDoubleTapZoom* = 4 + styleMsTouchActionPanX* = 8 + styleMsTouchActionPanY* = 16 + styleMsTouchActionPinchZoom* = 32 + styleMsTouchAction_Max* = 0x7fffffff + styleMsTouchSelectGrippers* = 0 + styleMsTouchSelectNone* = 1 + styleMsTouchSelectNotSet* = 2 + styleMsTouchSelect_Max* = 0x7fffffff + styleMsScrollTranslationNotSet* = 0 + styleMsScrollTranslationNone* = 1 + styleMsScrollTranslationVtoH* = 2 + styleMsScrollTranslation_Max* = 0x7fffffff + IID_IHTMLDOMConstructor* = DEFINE_GUID("3051049b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSStyleDeclaration* = DEFINE_GUID("30510740-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSStyleDeclaration2* = DEFINE_GUID("305107d1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleEnabled* = DEFINE_GUID("305104c2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSStyleDeclaration* = DEFINE_GUID("3059009a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSStyleDeclaration* = DEFINE_GUID("3059009a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSStyleDeclaration* = DEFINE_GUID("30510741-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle* = DEFINE_GUID("3050f25e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle2* = DEFINE_GUID("3050f4a2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle3* = DEFINE_GUID("3050f656-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle4* = DEFINE_GUID("3050f816-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle5* = DEFINE_GUID("3050f33a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyle6* = DEFINE_GUID("30510480-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle* = DEFINE_GUID("3050f3cf-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle2* = DEFINE_GUID("3050f4ac-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle3* = DEFINE_GUID("3050f657-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle4* = DEFINE_GUID("3050f817-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle5* = DEFINE_GUID("3050f335-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRuleStyle6* = DEFINE_GUID("30510471-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyle* = DEFINE_GUID("3050f55a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyle* = DEFINE_GUID("3050f55a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyle* = DEFINE_GUID("3050f285-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLRuleStyle* = DEFINE_GUID("3050f55c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLRuleStyle* = DEFINE_GUID("3050f55c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLRuleStyle* = DEFINE_GUID("3050f3d0-98b5-11cf-bb82-00aa00bdce0b") + styleViewportSizeAuto* = 0 + styleViewportSizeDeviceWidth* = 1 + styleViewportSizeDeviceHeight* = 2 + styleViewportSize_Max* = 0x7fffffff + styleUserZoomNotSet* = 0 + styleUserZoomZoom* = 1 + styleUserZoomFixed* = 2 + styleUserZoom_Max* = 0x7fffffff + IID_IHTMLCSSRule* = DEFINE_GUID("305106e9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSImportRule* = DEFINE_GUID("305106ea-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSMediaRule* = DEFINE_GUID("305106eb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSMediaList* = DEFINE_GUID("30510731-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCSSNamespaceRule* = DEFINE_GUID("305106ee-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMSCSSKeyframeRule* = DEFINE_GUID("3051080c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMSCSSKeyframesRule* = DEFINE_GUID("3051080d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSRule* = DEFINE_GUID("3059007d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSRule* = DEFINE_GUID("3059007d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSRule* = DEFINE_GUID("305106ef-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSImportRule* = DEFINE_GUID("3059007e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSImportRule* = DEFINE_GUID("3059007e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSImportRule* = DEFINE_GUID("305106f0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSMediaRule* = DEFINE_GUID("3059007f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSMediaRule* = DEFINE_GUID("3059007f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSMediaRule* = DEFINE_GUID("305106f1-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSMediaList* = DEFINE_GUID("30590097-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSMediaList* = DEFINE_GUID("30590097-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSMediaList* = DEFINE_GUID("30510732-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCSSNamespaceRule* = DEFINE_GUID("30590080-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCSSNamespaceRule* = DEFINE_GUID("30590080-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCSSNamespaceRule* = DEFINE_GUID("305106f2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMSCSSKeyframeRule* = DEFINE_GUID("305900de-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMSCSSKeyframeRule* = DEFINE_GUID("305900de-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMSCSSKeyframeRule* = DEFINE_GUID("3051080e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMSCSSKeyframesRule* = DEFINE_GUID("305900df-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMSCSSKeyframesRule* = DEFINE_GUID("305900df-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMSCSSKeyframesRule* = DEFINE_GUID("3051080f-98b5-11cf-bb82-00aa00bdce0b") + styleTextLineThroughStyleUndefined* = 0 + styleTextLineThroughStyleSingle* = 1 + styleTextLineThroughStyleDouble* = 2 + styleTextLineThroughStyle_Max* = 0x7fffffff + styleTextUnderlineStyleUndefined* = 0 + styleTextUnderlineStyleSingle* = 1 + styleTextUnderlineStyleDouble* = 2 + styleTextUnderlineStyleWords* = 3 + styleTextUnderlineStyleDotted* = 4 + styleTextUnderlineStyleThick* = 5 + styleTextUnderlineStyleDash* = 6 + styleTextUnderlineStyleDotDash* = 7 + styleTextUnderlineStyleDotDotDash* = 8 + styleTextUnderlineStyleWave* = 9 + styleTextUnderlineStyleSingleAccounting* = 10 + styleTextUnderlineStyleDoubleAccounting* = 11 + styleTextUnderlineStyleThickDash* = 12 + styleTextUnderlineStyle_Max* = 0x7fffffff + styleTextEffectNone* = 0 + styleTextEffectEmboss* = 1 + styleTextEffectEngrave* = 2 + styleTextEffectOutline* = 3 + styleTextEffect_Max* = 0x7fffffff + styleDefaultTextSelectionFalse* = 0 + styleDefaultTextSelectionTrue* = 1 + styleDefaultTextSelection_Max* = 0x7fffffff + styleTextDecorationNone* = 0 + styleTextDecorationUnderline* = 1 + styleTextDecorationOverline* = 2 + styleTextDecorationLineThrough* = 3 + styleTextDecorationBlink* = 4 + styleTextDecoration_Max* = 0x7fffffff + IID_IHTMLRenderStyle* = DEFINE_GUID("3050f6ae-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLRenderStyle* = DEFINE_GUID("3050f58b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLRenderStyle* = DEFINE_GUID("3050f58b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLRenderStyle* = DEFINE_GUID("3050f6aa-98b5-11cf-bb82-00aa00bdce0b") + textDecorationNone* = 0 + textDecorationUnderline* = 1 + textDecorationOverline* = 2 + textDecorationLineThrough* = 3 + textDecorationBlink* = 4 + textDecoration_Max* = 0x7fffffff + IID_IHTMLCurrentStyle* = DEFINE_GUID("3050f3db-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCurrentStyle2* = DEFINE_GUID("3050f658-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCurrentStyle3* = DEFINE_GUID("3050f818-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCurrentStyle4* = DEFINE_GUID("3050f33b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCurrentStyle5* = DEFINE_GUID("30510481-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCurrentStyle* = DEFINE_GUID("3050f557-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCurrentStyle* = DEFINE_GUID("3050f557-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCurrentStyle* = DEFINE_GUID("3050f3dc-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRect* = DEFINE_GUID("3050f4a3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRect2* = DEFINE_GUID("3051076c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLRectCollection* = DEFINE_GUID("3050f4a4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMNode* = DEFINE_GUID("3050f5da-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMNode2* = DEFINE_GUID("3050f80b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMNode3* = DEFINE_GUID("305106e0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMAttribute* = DEFINE_GUID("3050f4b0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMAttribute2* = DEFINE_GUID("3050f810-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMAttribute3* = DEFINE_GUID("30510468-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMAttribute4* = DEFINE_GUID("305106f9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMTextNode* = DEFINE_GUID("3050f4b1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMTextNode2* = DEFINE_GUID("3050f809-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMTextNode3* = DEFINE_GUID("3051073e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMImplementation* = DEFINE_GUID("3050f80d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMImplementation2* = DEFINE_GUID("3051073c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDOMAttribute* = DEFINE_GUID("3050f564-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDOMAttribute* = DEFINE_GUID("3050f564-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDOMAttribute* = DEFINE_GUID("3050f4b2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDOMTextNode* = DEFINE_GUID("3050f565-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDOMTextNode* = DEFINE_GUID("3050f565-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDOMTextNode* = DEFINE_GUID("3050f4ba-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDOMImplementation* = DEFINE_GUID("3050f58f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDOMImplementation* = DEFINE_GUID("3050f58f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDOMImplementation* = DEFINE_GUID("3050f80e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAttributeCollection* = DEFINE_GUID("3050f4c3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAttributeCollection2* = DEFINE_GUID("3050f80a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAttributeCollection3* = DEFINE_GUID("30510469-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAttributeCollection4* = DEFINE_GUID("305106fa-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMChildrenCollection* = DEFINE_GUID("3050f5ab-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMChildrenCollection2* = DEFINE_GUID("30510791-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAttributeCollection* = DEFINE_GUID("3050f56c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAttributeCollection* = DEFINE_GUID("3050f56c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAttributeCollection* = DEFINE_GUID("3050f4cc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispStaticNodeList* = DEFINE_GUID("3050f59b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispStaticNodeList* = DEFINE_GUID("3050f59b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_StaticNodeList* = DEFINE_GUID("30510467-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMChildrenCollection* = DEFINE_GUID("3050f577-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMChildrenCollection* = DEFINE_GUID("3050f577-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMChildrenCollection* = DEFINE_GUID("3050f5aa-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLElementEvents4* = DEFINE_GUID("3051075e-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLElementEvents4* = DEFINE_GUID("3051075e-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLElementEvents3* = DEFINE_GUID("3050f59f-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLElementEvents3* = DEFINE_GUID("3050f59f-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLElementEvents2* = DEFINE_GUID("3050f60f-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLElementEvents2* = DEFINE_GUID("3050f60f-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLElementEvents* = DEFINE_GUID("3050f33c-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLElementEvents* = DEFINE_GUID("3050f33c-98b5-11cf-bb82-00aa00bdce0b") + htmlListTypeNotSet* = 0 + htmlListTypeLargeAlpha* = 1 + htmlListTypeSmallAlpha* = 2 + htmlListTypeLargeRoman* = 3 + htmlListTypeSmallRoman* = 4 + htmlListTypeNumbers* = 5 + htmlListTypeDisc* = 6 + htmlListTypeCircle* = 7 + htmlListTypeSquare* = 8 + htmlListType_Max* = 0x7fffffff + htmlMethodNotSet* = 0 + htmlMethodGet* = 1 + htmlMethodPost* = 2 + htmlMethod_Max* = 0x7fffffff + htmlWrapOff* = 1 + htmlWrapSoft* = 2 + htmlWrapHard* = 3 + htmlWrap_Max* = 0x7fffffff + htmlDirNotSet* = 0 + htmlDirLeftToRight* = 1 + htmlDirRightToLeft* = 2 + htmlDir_Max* = 0x7fffffff + htmlEditableInherit* = 0 + htmlEditableTrue* = 1 + htmlEditableFalse* = 2 + htmlEditable_Max* = 0x7fffffff + htmlInputNotSet* = 0 + htmlInputButton* = 1 + htmlInputCheckbox* = 2 + htmlInputFile* = 3 + htmlInputHidden* = 4 + htmlInputImage* = 5 + htmlInputPassword* = 6 + htmlInputRadio* = 7 + htmlInputReset* = 8 + htmlInputSelectOne* = 9 + htmlInputSelectMultiple* = 10 + htmlInputSubmit* = 11 + htmlInputText* = 12 + htmlInputTextarea* = 13 + htmlInputRichtext* = 14 + htmlInputRange* = 15 + htmlInputUrl* = 16 + htmlInputEmail* = 17 + htmlInputNumber* = 18 + htmlInputTel* = 19 + htmlInputSearch* = 20 + htmlInput_Max* = 0x7fffffff + htmlSpellCheckNotSet* = 0 + htmlSpellCheckTrue* = 1 + htmlSpellCheckFalse* = 2 + htmlSpellCheckDefault* = 3 + htmlSpellCheck_Max* = 0x7fffffff + htmlEncodingURL* = 0 + htmlEncodingMultipart* = 1 + htmlEncodingText* = 2 + htmlEncoding_Max* = 0x7fffffff + htmlAdjacencyBeforeBegin* = 1 + htmlAdjacencyAfterBegin* = 2 + htmlAdjacencyBeforeEnd* = 3 + htmlAdjacencyAfterEnd* = 4 + htmlAdjacency_Max* = 0x7fffffff + htmlTabIndexNotSet* = -32768 + htmlTabIndex_Max* = 0x7fffffff + htmlComponentClient* = 0 + htmlComponentSbLeft* = 1 + htmlComponentSbPageLeft* = 2 + htmlComponentSbHThumb* = 3 + htmlComponentSbPageRight* = 4 + htmlComponentSbRight* = 5 + htmlComponentSbUp* = 6 + htmlComponentSbPageUp* = 7 + htmlComponentSbVThumb* = 8 + htmlComponentSbPageDown* = 9 + htmlComponentSbDown* = 10 + htmlComponentSbLeft2* = 11 + htmlComponentSbPageLeft2* = 12 + htmlComponentSbRight2* = 13 + htmlComponentSbPageRight2* = 14 + htmlComponentSbUp2* = 15 + htmlComponentSbPageUp2* = 16 + htmlComponentSbDown2* = 17 + htmlComponentSbPageDown2* = 18 + htmlComponentSbTop* = 19 + htmlComponentSbBottom* = 20 + htmlComponentOutside* = 21 + htmlComponentGHTopLeft* = 22 + htmlComponentGHLeft* = 23 + htmlComponentGHTop* = 24 + htmlComponentGHBottomLeft* = 25 + htmlComponentGHTopRight* = 26 + htmlComponentGHBottom* = 27 + htmlComponentGHRight* = 28 + htmlComponentGHBottomRight* = 29 + htmlComponent_Max* = 0x7fffffff + htmlApplyLocationInside* = 0 + htmlApplyLocationOutside* = 1 + htmlApplyLocation_Max* = 0x7fffffff + htmlGlyphModeNone* = 0 + htmlGlyphModeBegin* = 1 + htmlGlyphModeEnd* = 2 + htmlGlyphModeBoth* = 3 + htmlGlyphMode_Max* = 0x7fffffff + htmlDraggableAuto* = 0 + htmlDraggableTrue* = 1 + htmlDraggableFalse* = 2 + htmlDraggable_Max* = 0x7fffffff + IID_IHTMLElement* = DEFINE_GUID("3050f1ff-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement2* = DEFINE_GUID("3050f434-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement3* = DEFINE_GUID("3050f673-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement4* = DEFINE_GUID("3050f80f-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementSelector* = DEFINE_GUID("30510463-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementRender* = DEFINE_GUID("3050f669-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLUniqueName* = DEFINE_GUID("3050f4d0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement5* = DEFINE_GUID("3051045d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement6* = DEFINE_GUID("305106f8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElement7* = DEFINE_GUID("305107aa-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementAppliedStyles* = DEFINE_GUID("305104bd-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementTraversal* = DEFINE_GUID("30510736-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDatabinding* = DEFINE_GUID("3050f3f2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementDefaults* = DEFINE_GUID("3050f6c9-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDefaults* = DEFINE_GUID("3050f58c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDefaults* = DEFINE_GUID("3050f58c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDefaults* = DEFINE_GUID("3050f6c8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCDefaultDispatch* = DEFINE_GUID("3050f4fd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCPropertyBehavior* = DEFINE_GUID("3050f5df-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCMethodBehavior* = DEFINE_GUID("3050f631-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCEventBehavior* = DEFINE_GUID("3050f4ff-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCAttachBehavior* = DEFINE_GUID("3050f5f4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCAttachBehavior2* = DEFINE_GUID("3050f7eb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTCDescBehavior* = DEFINE_GUID("3050f5dc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCDefaultDispatch* = DEFINE_GUID("3050f573-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCDefaultDispatch* = DEFINE_GUID("3050f573-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCDefaultDispatch* = DEFINE_GUID("3050f4fc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCPropertyBehavior* = DEFINE_GUID("3050f57f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCPropertyBehavior* = DEFINE_GUID("3050f57f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCPropertyBehavior* = DEFINE_GUID("3050f5de-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCMethodBehavior* = DEFINE_GUID("3050f587-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCMethodBehavior* = DEFINE_GUID("3050f587-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCMethodBehavior* = DEFINE_GUID("3050f630-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCEventBehavior* = DEFINE_GUID("3050f574-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCEventBehavior* = DEFINE_GUID("3050f574-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCEventBehavior* = DEFINE_GUID("3050f4fe-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCAttachBehavior* = DEFINE_GUID("3050f583-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCAttachBehavior* = DEFINE_GUID("3050f583-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCAttachBehavior* = DEFINE_GUID("3050f5f5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTCDescBehavior* = DEFINE_GUID("3050f57e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTCDescBehavior* = DEFINE_GUID("3050f57e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTCDescBehavior* = DEFINE_GUID("3050f5dd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLUrnCollection* = DEFINE_GUID("3050f5e2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLUrnCollection* = DEFINE_GUID("3050f551-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLUrnCollection* = DEFINE_GUID("3050f551-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLUrnCollection* = DEFINE_GUID("3050f580-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLGenericElement* = DEFINE_GUID("3050f4b7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLGenericElement* = DEFINE_GUID("3050f563-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLGenericElement* = DEFINE_GUID("3050f563-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLGenericElement* = DEFINE_GUID("3050f4b8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRule* = DEFINE_GUID("3050f357-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRuleApplied* = DEFINE_GUID("305104c1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRule2* = DEFINE_GUID("305106fd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRulesCollection* = DEFINE_GUID("3050f2e5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRulesCollection2* = DEFINE_GUID("305106e8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetRule* = DEFINE_GUID("3050f50e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetRule* = DEFINE_GUID("3050f50e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetRule* = DEFINE_GUID("3050f3ce-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetRulesCollection* = DEFINE_GUID("3050f52f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetRulesCollection* = DEFINE_GUID("3050f52f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetRulesCollection* = DEFINE_GUID("3050f3cd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetPage* = DEFINE_GUID("3050f7ee-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetPage2* = DEFINE_GUID("305106ed-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetPagesCollection* = DEFINE_GUID("3050f7f0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetPage* = DEFINE_GUID("3050f540-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetPage* = DEFINE_GUID("3050f540-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetPage* = DEFINE_GUID("3050f7ef-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetPagesCollection* = DEFINE_GUID("3050f543-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetPagesCollection* = DEFINE_GUID("3050f543-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetPagesCollection* = DEFINE_GUID("3050f7f1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheet* = DEFINE_GUID("3050f2e3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheet2* = DEFINE_GUID("3050f3d1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheet3* = DEFINE_GUID("30510496-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheet4* = DEFINE_GUID("305106f4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheet* = DEFINE_GUID("3050f58d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheet* = DEFINE_GUID("3050f58d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheet* = DEFINE_GUID("3050f2e4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetsCollection* = DEFINE_GUID("3050f37e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetsCollection2* = DEFINE_GUID("305106e7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetsCollection* = DEFINE_GUID("3050f547-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetsCollection* = DEFINE_GUID("3050f547-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetsCollection* = DEFINE_GUID("3050f37f-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLLinkElementEvents2* = DEFINE_GUID("3050f61d-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLLinkElementEvents2* = DEFINE_GUID("3050f61d-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLLinkElementEvents* = DEFINE_GUID("3050f3cc-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLLinkElementEvents* = DEFINE_GUID("3050f3cc-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLinkElement* = DEFINE_GUID("3050f205-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLinkElement2* = DEFINE_GUID("3050f4e5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLinkElement3* = DEFINE_GUID("3050f81e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLinkElement4* = DEFINE_GUID("3051043a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLinkElement5* = DEFINE_GUID("30510726-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLLinkElement* = DEFINE_GUID("3050f524-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLLinkElement* = DEFINE_GUID("3050f524-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLLinkElement* = DEFINE_GUID("3050f277-98b5-11cf-bb82-00aa00bdce0b") + htmlUnitCharacter* = 1 + htmlUnitWord* = 2 + htmlUnitSentence* = 3 + htmlUnitTextEdit* = 6 + htmlUnit_Max* = 0x7fffffff + htmlEndPointsStartToStart* = 1 + htmlEndPointsStartToEnd* = 2 + htmlEndPointsEndToStart* = 3 + htmlEndPointsEndToEnd* = 4 + htmlEndPoints_Max* = 0x7fffffff + htmlDirectionForward* = 99999 + htmlDirectionBackward* = -99999 + htmlDirection_Max* = 0x7fffffff + IID_IHTMLTxtRange* = DEFINE_GUID("3050f220-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTextRangeMetrics* = DEFINE_GUID("3050f40b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTextRangeMetrics2* = DEFINE_GUID("3050f4a6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTxtRangeCollection* = DEFINE_GUID("3050f7ed-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMRange* = DEFINE_GUID("305104ae-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDOMRange* = DEFINE_GUID("3050f5a3-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDOMRange* = DEFINE_GUID("3050f5a3-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDOMRange* = DEFINE_GUID("305106c3-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLFormElementEvents2* = DEFINE_GUID("3050f614-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLFormElementEvents2* = DEFINE_GUID("3050f614-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLFormElementEvents* = DEFINE_GUID("3050f364-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLFormElementEvents* = DEFINE_GUID("3050f364-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFormElement* = DEFINE_GUID("3050f1f7-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFormElement2* = DEFINE_GUID("3050f4f6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFormElement3* = DEFINE_GUID("3050f836-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSubmitData* = DEFINE_GUID("3050f645-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFormElement4* = DEFINE_GUID("3051042c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFormElement* = DEFINE_GUID("3050f510-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFormElement* = DEFINE_GUID("3050f510-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFormElement* = DEFINE_GUID("3050f251-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLControlElementEvents2* = DEFINE_GUID("3050f612-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLControlElementEvents2* = DEFINE_GUID("3050f612-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLControlElementEvents* = DEFINE_GUID("3050f4ea-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLControlElementEvents* = DEFINE_GUID("3050f4ea-98b5-11cf-bb82-00aa00bdce0b") + htmlStartfileopen* = 0 + htmlStartmouseover* = 1 + htmlStart_Max* = 0x7fffffff + IID_IHTMLControlElement* = DEFINE_GUID("3050f4e9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTextElement* = DEFINE_GUID("3050f218-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTextElement* = DEFINE_GUID("3050f537-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTextElement* = DEFINE_GUID("3050f537-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTextElement* = DEFINE_GUID("3050f26a-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLTextContainerEvents2* = DEFINE_GUID("3050f624-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLTextContainerEvents2* = DEFINE_GUID("3050f624-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLTextContainerEvents* = DEFINE_GUID("1ff6aa72-5842-11cf-a707-00aa00c0098d") + IID_HTMLTextContainerEvents* = DEFINE_GUID("1ff6aa72-5842-11cf-a707-00aa00c0098d") + IID_IHTMLTextContainer* = DEFINE_GUID("3050f230-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLControlRange* = DEFINE_GUID("3050f29c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLControlRange2* = DEFINE_GUID("3050f65e-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLImgEvents2* = DEFINE_GUID("3050f616-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLImgEvents2* = DEFINE_GUID("3050f616-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLImgEvents* = DEFINE_GUID("3050f25b-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLImgEvents* = DEFINE_GUID("3050f25b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLImgElement* = DEFINE_GUID("3050f240-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLImgElement2* = DEFINE_GUID("3050f826-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLImgElement3* = DEFINE_GUID("30510434-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLImgElement4* = DEFINE_GUID("305107f6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMSImgElement* = DEFINE_GUID("30510793-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLImageElementFactory* = DEFINE_GUID("3050f38e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLImg* = DEFINE_GUID("3050f51c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLImg* = DEFINE_GUID("3050f51c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLImg* = DEFINE_GUID("3050f241-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLImageElementFactory* = DEFINE_GUID("3050f38f-98b5-11cf-bb82-00aa00bdce0b") + bodyScrollyes* = 1 + bodyScrollno* = 2 + bodyScrollauto* = 4 + bodyScrolldefault* = 3 + bodyScroll_Max* = 0x7fffffff + IID_IHTMLBodyElement* = DEFINE_GUID("3050f1d8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBodyElement2* = DEFINE_GUID("3050f5c5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBodyElement3* = DEFINE_GUID("30510422-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBodyElement4* = DEFINE_GUID("30510795-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBodyElement5* = DEFINE_GUID("30510822-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBody* = DEFINE_GUID("3050f507-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBody* = DEFINE_GUID("3050f507-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBody* = DEFINE_GUID("3050f24a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFontElement* = DEFINE_GUID("3050f1d9-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFontElement* = DEFINE_GUID("3050f512-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFontElement* = DEFINE_GUID("3050f512-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFontElement* = DEFINE_GUID("3050f27b-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLAnchorEvents2* = DEFINE_GUID("3050f610-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLAnchorEvents2* = DEFINE_GUID("3050f610-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLAnchorEvents* = DEFINE_GUID("3050f29d-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLAnchorEvents* = DEFINE_GUID("3050f29d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAnchorElement* = DEFINE_GUID("3050f1da-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAnchorElement2* = DEFINE_GUID("3050f825-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAnchorElement3* = DEFINE_GUID("3051041d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAnchorElement* = DEFINE_GUID("3050f502-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAnchorElement* = DEFINE_GUID("3050f502-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAnchorElement* = DEFINE_GUID("3050f248-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLLabelEvents2* = DEFINE_GUID("3050f61c-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLLabelEvents2* = DEFINE_GUID("3050f61c-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLLabelEvents* = DEFINE_GUID("3050f329-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLLabelEvents* = DEFINE_GUID("3050f329-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLabelElement* = DEFINE_GUID("3050f32a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLabelElement2* = DEFINE_GUID("3050f832-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLLabelElement* = DEFINE_GUID("3050f522-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLLabelElement* = DEFINE_GUID("3050f522-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLLabelElement* = DEFINE_GUID("3050f32b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLListElement* = DEFINE_GUID("3050f20e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLListElement2* = DEFINE_GUID("3050f822-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLListElement* = DEFINE_GUID("3050f525-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLListElement* = DEFINE_GUID("3050f525-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLListElement* = DEFINE_GUID("3050f272-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLUListElement* = DEFINE_GUID("3050f1dd-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLUListElement* = DEFINE_GUID("3050f538-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLUListElement* = DEFINE_GUID("3050f538-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLUListElement* = DEFINE_GUID("3050f269-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOListElement* = DEFINE_GUID("3050f1de-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLOListElement* = DEFINE_GUID("3050f52a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLOListElement* = DEFINE_GUID("3050f52a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLOListElement* = DEFINE_GUID("3050f270-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLIElement* = DEFINE_GUID("3050f1e0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLLIElement* = DEFINE_GUID("3050f523-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLLIElement* = DEFINE_GUID("3050f523-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLLIElement* = DEFINE_GUID("3050f273-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBlockElement* = DEFINE_GUID("3050f208-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBlockElement2* = DEFINE_GUID("3050f823-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBlockElement3* = DEFINE_GUID("30510494-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBlockElement* = DEFINE_GUID("3050f506-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBlockElement* = DEFINE_GUID("3050f506-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBlockElement* = DEFINE_GUID("3050f281-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDivElement* = DEFINE_GUID("3050f200-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDivElement* = DEFINE_GUID("3050f50c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDivElement* = DEFINE_GUID("3050f50c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDivElement* = DEFINE_GUID("3050f27e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDDElement* = DEFINE_GUID("3050f1f2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDDElement* = DEFINE_GUID("3050f50b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDDElement* = DEFINE_GUID("3050f50b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDDElement* = DEFINE_GUID("3050f27f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDTElement* = DEFINE_GUID("3050f1f3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDTElement* = DEFINE_GUID("3050f50d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDTElement* = DEFINE_GUID("3050f50d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDTElement* = DEFINE_GUID("3050f27c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBRElement* = DEFINE_GUID("3050f1f0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBRElement* = DEFINE_GUID("3050f53a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBRElement* = DEFINE_GUID("3050f53a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBRElement* = DEFINE_GUID("3050f280-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDListElement* = DEFINE_GUID("3050f1f1-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDListElement* = DEFINE_GUID("3050f53b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDListElement* = DEFINE_GUID("3050f53b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDListElement* = DEFINE_GUID("3050f27d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLHRElement* = DEFINE_GUID("3050f1f4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLHRElement* = DEFINE_GUID("3050f53d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLHRElement* = DEFINE_GUID("3050f53d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLHRElement* = DEFINE_GUID("3050f252-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLParaElement* = DEFINE_GUID("3050f1f5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLParaElement* = DEFINE_GUID("3050f52c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLParaElement* = DEFINE_GUID("3050f52c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLParaElement* = DEFINE_GUID("3050f26f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementCollection* = DEFINE_GUID("3050f21f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementCollection2* = DEFINE_GUID("3050f5ee-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementCollection3* = DEFINE_GUID("3050f835-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLElementCollection4* = DEFINE_GUID("30510425-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLElementCollection* = DEFINE_GUID("3050f56b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLElementCollection* = DEFINE_GUID("3050f56b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLElementCollection* = DEFINE_GUID("3050f4cb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLHeaderElement* = DEFINE_GUID("3050f1f6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLHeaderElement* = DEFINE_GUID("3050f515-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLHeaderElement* = DEFINE_GUID("3050f515-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLHeaderElement* = DEFINE_GUID("3050f27a-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLSelectElementEvents2* = DEFINE_GUID("3050f622-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLSelectElementEvents2* = DEFINE_GUID("3050f622-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLSelectElementEvents* = DEFINE_GUID("3050f302-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLSelectElementEvents* = DEFINE_GUID("3050f302-98b5-11cf-bb82-00aa00bdce0b") + htmlSelectTypeSelectOne* = 1 + htmlSelectTypeSelectMultiple* = 2 + htmlSelectType_Max* = 0x7fffffff + htmlSelectExFlagNone* = 0 + htmlSelectExFlagHideSelectionInDesign* = 0x1 + htmlSelectExFlag_Max* = 0x7fffffff + IID_IHTMLSelectElementEx* = DEFINE_GUID("3050f2d1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectElement* = DEFINE_GUID("3050f244-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectElement2* = DEFINE_GUID("3050f5ed-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectElement4* = DEFINE_GUID("3050f838-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectElement5* = DEFINE_GUID("3051049d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectElement6* = DEFINE_GUID("30510760-98b6-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLSelectElement* = DEFINE_GUID("3050f531-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLSelectElement* = DEFINE_GUID("3050f531-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLSelectElement* = DEFINE_GUID("3050f245-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLWndSelectElement* = DEFINE_GUID("3050f597-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLWndSelectElement* = DEFINE_GUID("3050f597-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLWndSelectElement* = DEFINE_GUID("3050f2cf-98b5-11cf-bb82-00aa00bdce0b") + htmlSelectionNone* = 0 + htmlSelectionText* = 1 + htmlSelectionControl* = 2 + htmlSelectionTable* = 3 + htmlSelection_Max* = 0x7fffffff + IID_IHTMLSelectionObject* = DEFINE_GUID("3050f25a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelectionObject2* = DEFINE_GUID("3050f7ec-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSelection* = DEFINE_GUID("305104b6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionElement* = DEFINE_GUID("3050f211-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionElement3* = DEFINE_GUID("3050f820-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionElement4* = DEFINE_GUID("305107b4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionElementFactory* = DEFINE_GUID("3050f38c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLOptionElement* = DEFINE_GUID("3050f52b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLOptionElement* = DEFINE_GUID("3050f52b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLOptionElement* = DEFINE_GUID("3050f24d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLOptionElementFactory* = DEFINE_GUID("3050f38d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLWndOptionElement* = DEFINE_GUID("3050f598-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLWndOptionElement* = DEFINE_GUID("3050f598-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLWndOptionElement* = DEFINE_GUID("3050f2d0-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLButtonElementEvents2* = DEFINE_GUID("3050f617-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLButtonElementEvents2* = DEFINE_GUID("3050f617-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLButtonElementEvents* = DEFINE_GUID("3050f2b3-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLButtonElementEvents* = DEFINE_GUID("3050f2b3-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputTextElementEvents2* = DEFINE_GUID("3050f618-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputTextElementEvents2* = DEFINE_GUID("3050f618-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLOptionButtonElementEvents2* = DEFINE_GUID("3050f619-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLOptionButtonElementEvents2* = DEFINE_GUID("3050f619-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputFileElementEvents2* = DEFINE_GUID("3050f61a-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputFileElementEvents2* = DEFINE_GUID("3050f61a-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputImageEvents2* = DEFINE_GUID("3050f61b-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputImageEvents2* = DEFINE_GUID("3050f61b-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputTextElementEvents* = DEFINE_GUID("3050f2a7-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputTextElementEvents* = DEFINE_GUID("3050f2a7-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLOptionButtonElementEvents* = DEFINE_GUID("3050f2bd-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLOptionButtonElementEvents* = DEFINE_GUID("3050f2bd-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputFileElementEvents* = DEFINE_GUID("3050f2af-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputFileElementEvents* = DEFINE_GUID("3050f2af-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLInputImageEvents* = DEFINE_GUID("3050f2c3-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLInputImageEvents* = DEFINE_GUID("3050f2c3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputElement* = DEFINE_GUID("3050f5d2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputElement2* = DEFINE_GUID("3050f821-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputElement3* = DEFINE_GUID("30510435-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputButtonElement* = DEFINE_GUID("3050f2b2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputHiddenElement* = DEFINE_GUID("3050f2a4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputTextElement* = DEFINE_GUID("3050f2a6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputTextElement2* = DEFINE_GUID("3050f2d2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputFileElement* = DEFINE_GUID("3050f2ad-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionButtonElement* = DEFINE_GUID("3050f2bc-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputImage* = DEFINE_GUID("3050f2c2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLInputRangeElement* = DEFINE_GUID("3050f2d4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLInputElement* = DEFINE_GUID("3050f57d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLInputElement* = DEFINE_GUID("3050f57d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLInputElement* = DEFINE_GUID("3050f5d8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTextAreaElement* = DEFINE_GUID("3050f2aa-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTextAreaElement2* = DEFINE_GUID("3050f2d3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTextAreaElement* = DEFINE_GUID("3050f521-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTextAreaElement* = DEFINE_GUID("3050f521-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTextAreaElement* = DEFINE_GUID("3050f2ac-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLRichtextElement* = DEFINE_GUID("3050f54d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLRichtextElement* = DEFINE_GUID("3050f54d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLRichtextElement* = DEFINE_GUID("3050f2df-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLButtonElement* = DEFINE_GUID("3050f2bb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLButtonElement2* = DEFINE_GUID("305106f3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLButtonElement* = DEFINE_GUID("3050f51f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLButtonElement* = DEFINE_GUID("3050f51f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLButtonElement* = DEFINE_GUID("3050f2c6-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLMarqueeElementEvents2* = DEFINE_GUID("3050f61f-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLMarqueeElementEvents2* = DEFINE_GUID("3050f61f-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLMarqueeElementEvents* = DEFINE_GUID("3050f2b8-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLMarqueeElementEvents* = DEFINE_GUID("3050f2b8-98b5-11cf-bb82-00aa00bdce0b") + htmlMarqueeBehaviorscroll* = 1 + htmlMarqueeBehaviorslide* = 2 + htmlMarqueeBehavioralternate* = 3 + htmlMarqueeBehavior_Max* = 0x7fffffff + htmlMarqueeDirectionleft* = 1 + htmlMarqueeDirectionright* = 3 + htmlMarqueeDirectionup* = 5 + htmlMarqueeDirectiondown* = 7 + htmlMarqueeDirection_Max* = 0x7fffffff + IID_IHTMLMarqueeElement* = DEFINE_GUID("3050f2b5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMarqueeElement* = DEFINE_GUID("3050f527-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMarqueeElement* = DEFINE_GUID("3050f527-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMarqueeElement* = DEFINE_GUID("3050f2b9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLHtmlElement* = DEFINE_GUID("3050f81c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLHeadElement* = DEFINE_GUID("3050f81d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLHeadElement2* = DEFINE_GUID("3051042f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTitleElement* = DEFINE_GUID("3050f322-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMetaElement* = DEFINE_GUID("3050f203-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMetaElement2* = DEFINE_GUID("3050f81f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMetaElement3* = DEFINE_GUID("30510495-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBaseElement* = DEFINE_GUID("3050f204-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBaseElement2* = DEFINE_GUID("30510420-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLIsIndexElement* = DEFINE_GUID("3050f206-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLIsIndexElement2* = DEFINE_GUID("3050f82f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLNextIdElement* = DEFINE_GUID("3050f207-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLHtmlElement* = DEFINE_GUID("3050f560-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLHtmlElement* = DEFINE_GUID("3050f560-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLHtmlElement* = DEFINE_GUID("3050f491-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLHeadElement* = DEFINE_GUID("3050f561-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLHeadElement* = DEFINE_GUID("3050f561-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLHeadElement* = DEFINE_GUID("3050f493-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTitleElement* = DEFINE_GUID("3050f516-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTitleElement* = DEFINE_GUID("3050f516-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTitleElement* = DEFINE_GUID("3050f284-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMetaElement* = DEFINE_GUID("3050f517-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMetaElement* = DEFINE_GUID("3050f517-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMetaElement* = DEFINE_GUID("3050f275-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBaseElement* = DEFINE_GUID("3050f518-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBaseElement* = DEFINE_GUID("3050f518-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBaseElement* = DEFINE_GUID("3050f276-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLIsIndexElement* = DEFINE_GUID("3050f519-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLIsIndexElement* = DEFINE_GUID("3050f519-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLIsIndexElement* = DEFINE_GUID("3050f278-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLNextIdElement* = DEFINE_GUID("3050f51a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLNextIdElement* = DEFINE_GUID("3050f51a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLNextIdElement* = DEFINE_GUID("3050f279-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBaseFontElement* = DEFINE_GUID("3050f202-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBaseFontElement* = DEFINE_GUID("3050f504-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBaseFontElement* = DEFINE_GUID("3050f504-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBaseFontElement* = DEFINE_GUID("3050f282-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLUnknownElement* = DEFINE_GUID("3050f209-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLUnknownElement* = DEFINE_GUID("3050f539-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLUnknownElement* = DEFINE_GUID("3050f539-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLUnknownElement* = DEFINE_GUID("3050f268-98b5-11cf-bb82-00aa00bdce0b") + IID_IOmHistory* = DEFINE_GUID("feceaaa2-8405-11cf-8ba1-00aa00476da6") + IID_IHTMLMimeTypesCollection* = DEFINE_GUID("3050f3fc-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPluginsCollection* = DEFINE_GUID("3050f3fd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOpsProfile* = DEFINE_GUID("3050f401-98b5-11cf-bb82-00aa00bdce0b") + IID_IOmNavigator* = DEFINE_GUID("feceaaa5-8405-11cf-8ba1-00aa00476da6") + IID_INavigatorGeolocation* = DEFINE_GUID("305107cf-98b5-11cf-bb82-00aa00bdce0b") + IID_INavigatorDoNotTrack* = DEFINE_GUID("30510804-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLocation* = DEFINE_GUID("163bb1e0-6e00-11cf-837a-48dc04c10000") + DIID_DispHTMLHistory* = DEFINE_GUID("3050f549-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLHistory* = DEFINE_GUID("3050f549-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLHistory* = DEFINE_GUID("feceaaa3-8405-11cf-8ba1-00aa00476da6") + CLSID_CMimeTypes* = DEFINE_GUID("3050f3fe-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCPlugins* = DEFINE_GUID("3050f54a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCPlugins* = DEFINE_GUID("3050f54a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CPlugins* = DEFINE_GUID("3050f3ff-98b5-11cf-bb82-00aa00bdce0b") + CLSID_COpsProfile* = DEFINE_GUID("3050f402-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLNavigator* = DEFINE_GUID("3050f54c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLNavigator* = DEFINE_GUID("3050f54c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLNavigator* = DEFINE_GUID("feceaaa6-8405-11cf-8ba1-00aa00476da6") + DIID_DispHTMLLocation* = DEFINE_GUID("3050f54e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLLocation* = DEFINE_GUID("3050f54e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLLocation* = DEFINE_GUID("163bb1e1-6e00-11cf-837a-48dc04c10000") + IID_IHTMLBookmarkCollection* = DEFINE_GUID("3050f4ce-98b5-11cf-bb82-00aa00bdce0b") + htmlPersistStateNormal* = 0 + htmlPersistStateFavorite* = 1 + htmlPersistStateHistory* = 2 + htmlPersistStateSnapshot* = 3 + htmlPersistStateUserData* = 4 + htmlPersistState_Max* = 0x7fffffff + htmlDropEffectCopy* = 0 + htmlDropEffectLink* = 1 + htmlDropEffectMove* = 2 + htmlDropEffectNone* = 3 + htmlDropEffect_Max* = 0x7fffffff + htmlEffectAllowedCopy* = 0 + htmlEffectAllowedLink* = 1 + htmlEffectAllowedMove* = 2 + htmlEffectAllowedCopyLink* = 3 + htmlEffectAllowedCopyMove* = 4 + htmlEffectAllowedLinkMove* = 5 + htmlEffectAllowedAll* = 6 + htmlEffectAllowedNone* = 7 + htmlEffectAllowedUninitialized* = 8 + htmlEffectAllowed_Max* = 0x7fffffff + IID_IHTMLDataTransfer* = DEFINE_GUID("3050f4b3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj* = DEFINE_GUID("3050f32d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj2* = DEFINE_GUID("3050f48b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj3* = DEFINE_GUID("3050f680-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj4* = DEFINE_GUID("3050f814-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj5* = DEFINE_GUID("30510478-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEventObj6* = DEFINE_GUID("30510734-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCEventObj* = DEFINE_GUID("3050f558-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCEventObj* = DEFINE_GUID("3050f558-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CEventObj* = DEFINE_GUID("3050f48a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleMedia* = DEFINE_GUID("3051074b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleMedia* = DEFINE_GUID("3059009e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleMedia* = DEFINE_GUID("3059009e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleMedia* = DEFINE_GUID("3051074c-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLWindowEvents3* = DEFINE_GUID("3050f5a1-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLWindowEvents3* = DEFINE_GUID("3050f5a1-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLWindowEvents2* = DEFINE_GUID("3050f625-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLWindowEvents2* = DEFINE_GUID("3050f625-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLWindowEvents* = DEFINE_GUID("96a0a4e0-d062-11cf-94b6-00aa0060275c") + IID_HTMLWindowEvents* = DEFINE_GUID("96a0a4e0-d062-11cf-94b6-00aa0060275c") + IID_IHTMLFramesCollection2* = DEFINE_GUID("332c4426-26cb-11d0-b483-00c04fd90119") + IID_IHTMLScreen* = DEFINE_GUID("3050f35c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScreen2* = DEFINE_GUID("3050f84a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScreen3* = DEFINE_GUID("305104a1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScreen4* = DEFINE_GUID("3051076b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow3* = DEFINE_GUID("3050f4ae-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow4* = DEFINE_GUID("3050f6cf-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow5* = DEFINE_GUID("3051040e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow6* = DEFINE_GUID("30510453-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow7* = DEFINE_GUID("305104b7-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLWindow8* = DEFINE_GUID("305107ab-98b5-11cf-bb82-00aa00bdce0b") + CLSID_FramesCollection* = DEFINE_GUID("3050f7f6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLScreen* = DEFINE_GUID("3050f591-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLScreen* = DEFINE_GUID("3050f591-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLScreen* = DEFINE_GUID("3050f35d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLWindow2* = DEFINE_GUID("3050f55d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLWindow2* = DEFINE_GUID("3050f55d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLWindow2* = DEFINE_GUID("d48a6ec6-6a4a-11cf-94a7-444553540000") + DIID_DispHTMLWindowProxy* = DEFINE_GUID("3050f55e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLWindowProxy* = DEFINE_GUID("3050f55e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLWindowProxy* = DEFINE_GUID("3050f391-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocumentCompatibleInfo* = DEFINE_GUID("3051041a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocumentCompatibleInfoCollection* = DEFINE_GUID("30510418-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDocumentCompatibleInfo* = DEFINE_GUID("3050f53e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDocumentCompatibleInfo* = DEFINE_GUID("3050f53e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDocumentCompatibleInfo* = DEFINE_GUID("3051041b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDocumentCompatibleInfoCollection* = DEFINE_GUID("3050f53f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDocumentCompatibleInfoCollection* = DEFINE_GUID("3050f53f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDocumentCompatibleInfoCollection* = DEFINE_GUID("30510419-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLDocumentEvents4* = DEFINE_GUID("30510737-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLDocumentEvents4* = DEFINE_GUID("30510737-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLDocumentEvents3* = DEFINE_GUID("3050f5a0-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLDocumentEvents3* = DEFINE_GUID("3050f5a0-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLDocumentEvents2* = DEFINE_GUID("3050f613-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLDocumentEvents2* = DEFINE_GUID("3050f613-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLDocumentEvents* = DEFINE_GUID("3050f260-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLDocumentEvents* = DEFINE_GUID("3050f260-98b5-11cf-bb82-00aa00bdce0b") + htmlCompatModeBackCompat* = 0 + htmlCompatModeCSS1Compat* = 1 + htmlCompatMode_Max* = 0x7fffffff + IID_IHTMLDocument* = DEFINE_GUID("626fc520-a41e-11cf-a731-00a0c9082637") + IID_IHTMLDocument2* = DEFINE_GUID("332c4425-26cb-11d0-b483-00c04fd90119") + IID_IHTMLDocument3* = DEFINE_GUID("3050f485-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocument4* = DEFINE_GUID("3050f69a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocument5* = DEFINE_GUID("3050f80c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocument6* = DEFINE_GUID("30510417-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocument7* = DEFINE_GUID("305104b8-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDocument8* = DEFINE_GUID("305107d0-98b5-11cf-bb82-00aa00bdce0b") + IID_IDocumentEvent* = DEFINE_GUID("305104bc-98b5-11cf-bb82-00aa00bdce0b") + IID_IDocumentRange* = DEFINE_GUID("305104af-98b5-11cf-bb82-00aa00bdce0b") + IID_IDocumentSelector* = DEFINE_GUID("30510462-98b5-11cf-bb82-00aa00bdce0b") + IID_IDocumentTraversal* = DEFINE_GUID("30510744-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDocument* = DEFINE_GUID("3050f55f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDocument* = DEFINE_GUID("3050f55f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDocument* = DEFINE_GUID("25336920-03f9-11cf-8fd0-00aa00686f13") + DIID_DWebBridgeEvents* = DEFINE_GUID("a6d897ff-0a95-11d1-b0ba-006008166e11") + IID_DWebBridgeEvents* = DEFINE_GUID("a6d897ff-0a95-11d1-b0ba-006008166e11") + IID_IWebBridge* = DEFINE_GUID("ae24fdad-03c6-11d1-8b76-0080c744f389") + IID_IWBScriptControl* = DEFINE_GUID("a5170870-0cf8-11d1-8b91-0080c744f389") + CLSID_Scriptlet* = DEFINE_GUID("ae24fdae-03c6-11d1-8b76-0080c744f389") + BoolValue_Max* = 0x7fffffff + IID_IHTMLEmbedElement* = DEFINE_GUID("3050f25f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEmbedElement2* = DEFINE_GUID("30510493-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLEmbed* = DEFINE_GUID("3050f52e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLEmbed* = DEFINE_GUID("3050f52e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLEmbed* = DEFINE_GUID("3050f25d-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLMapEvents2* = DEFINE_GUID("3050f61e-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLMapEvents2* = DEFINE_GUID("3050f61e-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLMapEvents* = DEFINE_GUID("3050f3ba-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLMapEvents* = DEFINE_GUID("3050f3ba-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreasCollection* = DEFINE_GUID("3050f383-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreasCollection2* = DEFINE_GUID("3050f5ec-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreasCollection3* = DEFINE_GUID("3050f837-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreasCollection4* = DEFINE_GUID("30510492-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMapElement* = DEFINE_GUID("3050f266-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAreasCollection* = DEFINE_GUID("3050f56a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAreasCollection* = DEFINE_GUID("3050f56a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAreasCollection* = DEFINE_GUID("3050f4ca-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMapElement* = DEFINE_GUID("3050f526-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMapElement* = DEFINE_GUID("3050f526-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMapElement* = DEFINE_GUID("3050f271-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLAreaEvents2* = DEFINE_GUID("3050f611-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLAreaEvents2* = DEFINE_GUID("3050f611-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLAreaEvents* = DEFINE_GUID("3050f366-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLAreaEvents* = DEFINE_GUID("3050f366-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreaElement* = DEFINE_GUID("3050f265-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAreaElement2* = DEFINE_GUID("3051041f-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAreaElement* = DEFINE_GUID("3050f503-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAreaElement* = DEFINE_GUID("3050f503-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAreaElement* = DEFINE_GUID("3050f283-98b5-11cf-bb82-00aa00bdce0b") + htmlCaptionAlignNotSet* = 0 + htmlCaptionAlignLeft* = 1 + htmlCaptionAlignCenter* = 2 + htmlCaptionAlignRight* = 3 + htmlCaptionAlignJustify* = 4 + htmlCaptionAlignTop* = 5 + htmlCaptionAlignBottom* = 6 + htmlCaptionAlign_Max* = 0x7fffffff + htmlCaptionVAlignNotSet* = 0 + htmlCaptionVAlignTop* = 1 + htmlCaptionVAlignBottom* = 2 + htmlCaptionVAlign_Max* = 0x7fffffff + IID_IHTMLTableCaption* = DEFINE_GUID("3050f2eb-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTableCaption* = DEFINE_GUID("3050f508-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTableCaption* = DEFINE_GUID("3050f508-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTableCaption* = DEFINE_GUID("3050f2ec-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCommentElement* = DEFINE_GUID("3050f20c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCommentElement2* = DEFINE_GUID("3050f813-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCommentElement3* = DEFINE_GUID("3051073f-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCommentElement* = DEFINE_GUID("3050f50a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCommentElement* = DEFINE_GUID("3050f50a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCommentElement* = DEFINE_GUID("3050f317-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPhraseElement* = DEFINE_GUID("3050f20a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPhraseElement2* = DEFINE_GUID("3050f824-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPhraseElement3* = DEFINE_GUID("3051043d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSpanElement* = DEFINE_GUID("3050f3f3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLPhraseElement* = DEFINE_GUID("3050f52d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLPhraseElement* = DEFINE_GUID("3050f52d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLPhraseElement* = DEFINE_GUID("3050f26e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLSpanElement* = DEFINE_GUID("3050f548-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLSpanElement* = DEFINE_GUID("3050f548-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLSpanElement* = DEFINE_GUID("3050f3f5-98b4-11cf-bb82-00aa00bdce0b") + DIID_HTMLTableEvents2* = DEFINE_GUID("3050f623-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLTableEvents2* = DEFINE_GUID("3050f623-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLTableEvents* = DEFINE_GUID("3050f407-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLTableEvents* = DEFINE_GUID("3050f407-98b5-11cf-bb82-00aa00bdce0b") + htmlFrameNotSet* = 0 + htmlFramevoid* = 1 + htmlFrameabove* = 2 + htmlFramebelow* = 3 + htmlFramehsides* = 4 + htmlFramelhs* = 5 + htmlFramerhs* = 6 + htmlFramevsides* = 7 + htmlFramebox* = 8 + htmlFrameborder* = 9 + htmlFrame_Max* = 0x7fffffff + htmlRulesNotSet* = 0 + htmlRulesnone* = 1 + htmlRulesgroups* = 2 + htmlRulesrows* = 3 + htmlRulescols* = 4 + htmlRulesall* = 5 + htmlRules_Max* = 0x7fffffff + htmlCellAlignNotSet* = 0 + htmlCellAlignLeft* = 1 + htmlCellAlignCenter* = 2 + htmlCellAlignRight* = 3 + htmlCellAlignMiddle* = htmlCellAlignCenter + htmlCellAlign_Max* = 0x7fffffff + htmlCellVAlignNotSet* = 0 + htmlCellVAlignTop* = 1 + htmlCellVAlignMiddle* = 2 + htmlCellVAlignBottom* = 3 + htmlCellVAlignBaseline* = 4 + htmlCellVAlignCenter* = htmlCellVAlignMiddle + htmlCellVAlign_Max* = 0x7fffffff + IID_IHTMLTable* = DEFINE_GUID("3050f21e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTable2* = DEFINE_GUID("3050f4ad-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTable3* = DEFINE_GUID("3050f829-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTable4* = DEFINE_GUID("305106c2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCol* = DEFINE_GUID("3050f23a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCol2* = DEFINE_GUID("3050f82a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCol3* = DEFINE_GUID("305106c4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableSection* = DEFINE_GUID("3050f23b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableSection2* = DEFINE_GUID("3050f5c7-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableSection3* = DEFINE_GUID("3050f82b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableSection4* = DEFINE_GUID("305106c5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableRow* = DEFINE_GUID("3050f23c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableRow2* = DEFINE_GUID("3050f4a1-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableRow3* = DEFINE_GUID("3050f82c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableRow4* = DEFINE_GUID("305106c6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableRowMetrics* = DEFINE_GUID("3050f413-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCell* = DEFINE_GUID("3050f23d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCell2* = DEFINE_GUID("3050f82d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTableCell3* = DEFINE_GUID("305106c7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTable* = DEFINE_GUID("3050f532-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTable* = DEFINE_GUID("3050f532-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTable* = DEFINE_GUID("3050f26b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTableCol* = DEFINE_GUID("3050f533-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTableCol* = DEFINE_GUID("3050f533-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTableCol* = DEFINE_GUID("3050f26c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTableSection* = DEFINE_GUID("3050f534-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTableSection* = DEFINE_GUID("3050f534-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTableSection* = DEFINE_GUID("3050f2e9-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTableRow* = DEFINE_GUID("3050f535-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTableRow* = DEFINE_GUID("3050f535-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTableRow* = DEFINE_GUID("3050f26d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTableCell* = DEFINE_GUID("3050f536-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTableCell* = DEFINE_GUID("3050f536-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTableCell* = DEFINE_GUID("3050f246-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLScriptEvents2* = DEFINE_GUID("3050f621-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLScriptEvents2* = DEFINE_GUID("3050f621-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLScriptEvents* = DEFINE_GUID("3050f3e2-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLScriptEvents* = DEFINE_GUID("3050f3e2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScriptElement* = DEFINE_GUID("3050f28b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScriptElement2* = DEFINE_GUID("3050f828-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScriptElement3* = DEFINE_GUID("30510447-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLScriptElement4* = DEFINE_GUID("30510801-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLScriptElement* = DEFINE_GUID("3050f530-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLScriptElement* = DEFINE_GUID("3050f530-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLScriptElement* = DEFINE_GUID("3050f28c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLNoShowElement* = DEFINE_GUID("3050f38a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLNoShowElement* = DEFINE_GUID("3050f528-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLNoShowElement* = DEFINE_GUID("3050f528-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLNoShowElement* = DEFINE_GUID("3050f38b-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLObjectElementEvents2* = DEFINE_GUID("3050f620-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLObjectElementEvents2* = DEFINE_GUID("3050f620-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLObjectElementEvents* = DEFINE_GUID("3050f3c4-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLObjectElementEvents* = DEFINE_GUID("3050f3c4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLObjectElement* = DEFINE_GUID("3050f24f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLObjectElement2* = DEFINE_GUID("3050f4cd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLObjectElement3* = DEFINE_GUID("3050f827-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLObjectElement4* = DEFINE_GUID("3051043e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLObjectElement5* = DEFINE_GUID("305104b5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLParamElement* = DEFINE_GUID("3050f83d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLParamElement2* = DEFINE_GUID("30510444-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLObjectElement* = DEFINE_GUID("3050f529-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLObjectElement* = DEFINE_GUID("3050f529-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLObjectElement* = DEFINE_GUID("3050f24e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLParamElement* = DEFINE_GUID("3050f590-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLParamElement* = DEFINE_GUID("3050f590-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLParamElement* = DEFINE_GUID("3050f83e-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLFrameSiteEvents2* = DEFINE_GUID("3050f7ff-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLFrameSiteEvents2* = DEFINE_GUID("3050f7ff-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLFrameSiteEvents* = DEFINE_GUID("3050f800-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLFrameSiteEvents* = DEFINE_GUID("3050f800-98b5-11cf-bb82-00aa00bdce0b") + frameScrollingyes* = 1 + frameScrollingno* = 2 + frameScrollingauto* = 4 + frameScrolling_Max* = 0x7fffffff + IID_IHTMLFrameBase* = DEFINE_GUID("3050f311-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameBase2* = DEFINE_GUID("3050f6db-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameBase3* = DEFINE_GUID("3050f82e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFrameBase* = DEFINE_GUID("3050f541-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFrameBase* = DEFINE_GUID("3050f541-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFrameBase* = DEFINE_GUID("3050f312-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameElement* = DEFINE_GUID("3050f313-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameElement2* = DEFINE_GUID("3050f7f5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameElement3* = DEFINE_GUID("3051042d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFrameElement* = DEFINE_GUID("3050f513-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFrameElement* = DEFINE_GUID("3050f513-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFrameElement* = DEFINE_GUID("3050f314-98b5-11cf-bb82-00aa00bdce0b") + sandboxAllowScripts* = 0 + sandboxAllowSameOrigin* = 1 + sandboxAllowTopNavigation* = 2 + sandboxAllowForms* = 3 + sandboxAllowPopups* = 4 + sandboxAllow_Max* = 0x7fffffff + IID_IHTMLIFrameElement* = DEFINE_GUID("3050f315-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLIFrameElement2* = DEFINE_GUID("3050f4e6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLIFrameElement3* = DEFINE_GUID("30510433-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLIFrame* = DEFINE_GUID("3050f51b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLIFrame* = DEFINE_GUID("3050f51b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLIFrame* = DEFINE_GUID("3050f316-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDivPosition* = DEFINE_GUID("3050f212-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFieldSetElement* = DEFINE_GUID("3050f3e7-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFieldSetElement2* = DEFINE_GUID("3050f833-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLegendElement* = DEFINE_GUID("3050f3ea-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLLegendElement2* = DEFINE_GUID("3050f834-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLDivPosition* = DEFINE_GUID("3050f50f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLDivPosition* = DEFINE_GUID("3050f50f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDivPosition* = DEFINE_GUID("3050f249-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFieldSetElement* = DEFINE_GUID("3050f545-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFieldSetElement* = DEFINE_GUID("3050f545-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFieldSetElement* = DEFINE_GUID("3050f3e8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLLegendElement* = DEFINE_GUID("3050f546-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLLegendElement* = DEFINE_GUID("3050f546-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLLegendElement* = DEFINE_GUID("3050f3e9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSpanFlow* = DEFINE_GUID("3050f3e5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLSpanFlow* = DEFINE_GUID("3050f544-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLSpanFlow* = DEFINE_GUID("3050f544-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLSpanFlow* = DEFINE_GUID("3050f3e6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameSetElement* = DEFINE_GUID("3050f319-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameSetElement2* = DEFINE_GUID("3050f5c6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFrameSetElement3* = DEFINE_GUID("30510796-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLFrameSetSite* = DEFINE_GUID("3050f514-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLFrameSetSite* = DEFINE_GUID("3050f514-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLFrameSetSite* = DEFINE_GUID("3050f31a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLBGsound* = DEFINE_GUID("3050f369-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLBGsound* = DEFINE_GUID("3050f53c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLBGsound* = DEFINE_GUID("3050f53c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLBGsound* = DEFINE_GUID("3050f370-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFontNamesCollection* = DEFINE_GUID("3050f376-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLFontSizesCollection* = DEFINE_GUID("3050f377-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLOptionsHolder* = DEFINE_GUID("3050f378-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLStyleElementEvents2* = DEFINE_GUID("3050f615-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLStyleElementEvents2* = DEFINE_GUID("3050f615-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLStyleElementEvents* = DEFINE_GUID("3050f3cb-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLStyleElementEvents* = DEFINE_GUID("3050f3cb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleElement* = DEFINE_GUID("3050f375-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleElement2* = DEFINE_GUID("3051072a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleElement* = DEFINE_GUID("3050f511-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleElement* = DEFINE_GUID("3050f511-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleElement* = DEFINE_GUID("3050f37d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleFontFace* = DEFINE_GUID("3050f3d5-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleFontFace2* = DEFINE_GUID("305106ec-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleFontFace* = DEFINE_GUID("30590081-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleFontFace* = DEFINE_GUID("30590081-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleFontFace* = DEFINE_GUID("3050f3d4-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLXDomainRequest* = DEFINE_GUID("30510454-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLXDomainRequestFactory* = DEFINE_GUID("30510456-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispXDomainRequest* = DEFINE_GUID("3050f599-98b5-11cf-bb82-00aa00bdce0b") + IID_DispXDomainRequest* = DEFINE_GUID("3050f599-98b5-11cf-bb82-00aa00bdce0b") + CLSID_XDomainRequest* = DEFINE_GUID("30510455-98b5-11cf-bb82-00aa00bdce0b") + CLSID_XDomainRequestFactory* = DEFINE_GUID("30510457-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStorage* = DEFINE_GUID("30510474-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStorage2* = DEFINE_GUID("30510799-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStorage* = DEFINE_GUID("3050f59d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStorage* = DEFINE_GUID("3050f59d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStorage* = DEFINE_GUID("30510475-98b5-11cf-bb82-00aa00bdce0b") + IID_IEventTarget* = DEFINE_GUID("305104b9-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMEvent* = DEFINE_GUID("305104ba-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMEvent* = DEFINE_GUID("3050f5a2-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMEvent* = DEFINE_GUID("3050f5a2-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMEvent* = DEFINE_GUID("305104bb-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMUIEvent* = DEFINE_GUID("305106ca-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMUIEvent* = DEFINE_GUID("30590072-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMUIEvent* = DEFINE_GUID("30590072-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMUIEvent* = DEFINE_GUID("305106cb-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMouseEvent* = DEFINE_GUID("305106ce-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMouseEvent* = DEFINE_GUID("30590073-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMouseEvent* = DEFINE_GUID("30590073-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMouseEvent* = DEFINE_GUID("305106cf-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMDragEvent* = DEFINE_GUID("30510761-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMDragEvent* = DEFINE_GUID("305900a7-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMDragEvent* = DEFINE_GUID("305900a7-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMDragEvent* = DEFINE_GUID("30510762-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMouseWheelEvent* = DEFINE_GUID("305106d0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMouseWheelEvent* = DEFINE_GUID("30590074-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMouseWheelEvent* = DEFINE_GUID("30590074-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMouseWheelEvent* = DEFINE_GUID("305106d1-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMWheelEvent* = DEFINE_GUID("305106d2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMWheelEvent* = DEFINE_GUID("30590075-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMWheelEvent* = DEFINE_GUID("30590075-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMWheelEvent* = DEFINE_GUID("305106d3-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMTextEvent* = DEFINE_GUID("305106d4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMTextEvent* = DEFINE_GUID("30590076-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMTextEvent* = DEFINE_GUID("30590076-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMTextEvent* = DEFINE_GUID("305106d5-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMKeyboardEvent* = DEFINE_GUID("305106d6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMKeyboardEvent* = DEFINE_GUID("30590077-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMKeyboardEvent* = DEFINE_GUID("30590077-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMKeyboardEvent* = DEFINE_GUID("305106d7-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMCompositionEvent* = DEFINE_GUID("305106d8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMCompositionEvent* = DEFINE_GUID("30590078-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMCompositionEvent* = DEFINE_GUID("30590078-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMCompositionEvent* = DEFINE_GUID("305106d9-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMutationEvent* = DEFINE_GUID("305106da-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMutationEvent* = DEFINE_GUID("30590079-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMutationEvent* = DEFINE_GUID("30590079-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMutationEvent* = DEFINE_GUID("305106db-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMBeforeUnloadEvent* = DEFINE_GUID("30510763-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMBeforeUnloadEvent* = DEFINE_GUID("305900a8-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMBeforeUnloadEvent* = DEFINE_GUID("305900a8-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMBeforeUnloadEvent* = DEFINE_GUID("30510764-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMFocusEvent* = DEFINE_GUID("305106cc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMFocusEvent* = DEFINE_GUID("30590071-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMFocusEvent* = DEFINE_GUID("30590071-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMFocusEvent* = DEFINE_GUID("305106cd-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMCustomEvent* = DEFINE_GUID("305106de-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMCustomEvent* = DEFINE_GUID("3059007c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMCustomEvent* = DEFINE_GUID("3059007c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMCustomEvent* = DEFINE_GUID("305106df-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasGradient* = DEFINE_GUID("30510714-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasPattern* = DEFINE_GUID("30510716-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasTextMetrics* = DEFINE_GUID("30510718-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasImageData* = DEFINE_GUID("3051071a-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasPixelArray* = DEFINE_GUID("3051071c-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasRenderingContext2D* = DEFINE_GUID("305106ff-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCanvasElement* = DEFINE_GUID("305106e4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCanvasGradient* = DEFINE_GUID("3059008c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCanvasGradient* = DEFINE_GUID("3059008c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CanvasGradient* = DEFINE_GUID("30510715-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCanvasPattern* = DEFINE_GUID("3059008d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCanvasPattern* = DEFINE_GUID("3059008d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CanvasPattern* = DEFINE_GUID("30510717-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCanvasTextMetrics* = DEFINE_GUID("3059008e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCanvasTextMetrics* = DEFINE_GUID("3059008e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CanvasTextMetrics* = DEFINE_GUID("30510719-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCanvasImageData* = DEFINE_GUID("3059008f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCanvasImageData* = DEFINE_GUID("3059008f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CanvasImageData* = DEFINE_GUID("3051071b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCanvasRenderingContext2D* = DEFINE_GUID("30590082-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCanvasRenderingContext2D* = DEFINE_GUID("30590082-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CanvasRenderingContext2D* = DEFINE_GUID("30510700-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLCanvasElement* = DEFINE_GUID("3059007b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLCanvasElement* = DEFINE_GUID("3059007b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLCanvasElement* = DEFINE_GUID("305106e5-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMProgressEvent* = DEFINE_GUID("3051071e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMProgressEvent* = DEFINE_GUID("30590091-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMProgressEvent* = DEFINE_GUID("30590091-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMProgressEvent* = DEFINE_GUID("3051071f-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMessageEvent* = DEFINE_GUID("30510720-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMessageEvent* = DEFINE_GUID("30590092-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMessageEvent* = DEFINE_GUID("30590092-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMessageEvent* = DEFINE_GUID("30510721-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMSiteModeEvent* = DEFINE_GUID("30510765-98b6-11cf-bb82-00aa00bdce0b") + DIID_DispDOMSiteModeEvent* = DEFINE_GUID("305900a9-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMSiteModeEvent* = DEFINE_GUID("305900a9-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMSiteModeEvent* = DEFINE_GUID("30510766-98b6-11cf-bb82-00aa00bdce0b") + IID_IDOMStorageEvent* = DEFINE_GUID("30510722-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMStorageEvent* = DEFINE_GUID("30590093-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMStorageEvent* = DEFINE_GUID("30590093-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMStorageEvent* = DEFINE_GUID("30510723-98b5-11cf-bb82-00aa00bdce0b") + IID_IXMLHttpRequestEventTarget* = DEFINE_GUID("30510830-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispXMLHttpRequestEventTarget* = DEFINE_GUID("305900e7-98b5-11cf-bb82-00aa00bdce0b") + IID_DispXMLHttpRequestEventTarget* = DEFINE_GUID("305900e7-98b5-11cf-bb82-00aa00bdce0b") + CLSID_XMLHttpRequestEventTarget* = DEFINE_GUID("30510831-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLXMLHttpRequestEvents* = DEFINE_GUID("30510498-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLXMLHttpRequestEvents* = DEFINE_GUID("30510498-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLXMLHttpRequest* = DEFINE_GUID("3051040a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLXMLHttpRequest2* = DEFINE_GUID("30510482-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLXMLHttpRequestFactory* = DEFINE_GUID("3051040c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLXMLHttpRequest* = DEFINE_GUID("3050f596-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLXMLHttpRequest* = DEFINE_GUID("3050f596-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLXMLHttpRequest* = DEFINE_GUID("3051040b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLXMLHttpRequestFactory* = DEFINE_GUID("3051040d-98b5-11cf-bb82-00aa00bdce0b") + SVG_ANGLETYPE_UNKNOWN* = 0 + SVG_ANGLETYPE_UNSPECIFIED* = 1 + SVG_ANGLETYPE_DEG* = 2 + SVG_ANGLETYPE_RAD* = 3 + SVG_ANGLETYPE_GRAD* = 4 + svgAngleType_Max* = 0x7fffffff + IID_ISVGAngle* = DEFINE_GUID("305104d3-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAngle* = DEFINE_GUID("30510584-98b5-11cf-bb82-00aa00bdce0b") + svgExternalResourcesRequiredFalse* = 0 + svgExternalResourcesRequiredTrue* = 1 + svgExternalResourcesRequired_Max* = 0x7fffffff + IID_ISVGStylable* = DEFINE_GUID("305104da-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGLocatable* = DEFINE_GUID("305104db-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTransformable* = DEFINE_GUID("305104dc-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTests* = DEFINE_GUID("305104dd-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGLangSpace* = DEFINE_GUID("305104de-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGExternalResourcesRequired* = DEFINE_GUID("305104df-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGFitToViewBox* = DEFINE_GUID("305104e0-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGZoomAndPan* = DEFINE_GUID("305104e1-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGURIReference* = DEFINE_GUID("305104e3-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedAngle* = DEFINE_GUID("305104d4-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedAngle* = DEFINE_GUID("305105e4-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedTransformList* = DEFINE_GUID("305104f9-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedTransformList* = DEFINE_GUID("305105b1-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedBoolean* = DEFINE_GUID("305104c6-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedBoolean* = DEFINE_GUID("3051058b-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedEnumeration* = DEFINE_GUID("305104c9-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedEnumeration* = DEFINE_GUID("3051058e-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedInteger* = DEFINE_GUID("305104ca-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedInteger* = DEFINE_GUID("3051058f-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedLength* = DEFINE_GUID("305104d0-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedLength* = DEFINE_GUID("30510581-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedLengthList* = DEFINE_GUID("305104d2-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedLengthList* = DEFINE_GUID("30510582-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedNumber* = DEFINE_GUID("305104cc-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedNumber* = DEFINE_GUID("30510588-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedNumberList* = DEFINE_GUID("305104ce-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedNumberList* = DEFINE_GUID("3051058a-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedRect* = DEFINE_GUID("305104d8-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedRect* = DEFINE_GUID("30510586-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedString* = DEFINE_GUID("305104c7-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedString* = DEFINE_GUID("3051058c-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGClipPathElement* = DEFINE_GUID("3051052d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGClipPathElement* = DEFINE_GUID("3059003b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGClipPathElement* = DEFINE_GUID("3059003b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGClipPathElement* = DEFINE_GUID("305105e6-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGDocument* = DEFINE_GUID("305104e6-98b5-11cf-bb82-00aa00bdce0b") + IID_IGetSVGDocument* = DEFINE_GUID("305105ab-98b5-11cf-bb82-00aa00bdce0b") + svgFocusableNotSet* = 0 + svgFocusableAuto* = 1 + svgFocusableTrue* = 2 + svgFocusableFalse* = 3 + svgFocusable_Max* = 0x7fffffff + IID_ISVGElement* = DEFINE_GUID("305104c5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGElement* = DEFINE_GUID("30590000-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGElement* = DEFINE_GUID("30590000-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGElement* = DEFINE_GUID("30510564-98b5-11cf-bb82-00aa00bdce0b") + IID_IICCSVGColor* = DEFINE_GUID("305104d6-98b5-11cf-bb82-00aa00bdce0b") + SVG_LENGTHTYPE_UNKNOWN* = 0 + SVG_LENGTHTYPE_NUMBER* = 1 + SVG_LENGTHTYPE_PERCENTAGE* = 2 + SVG_LENGTHTYPE_EMS* = 3 + SVG_LENGTHTYPE_EXS* = 4 + SVG_LENGTHTYPE_PX* = 5 + SVG_LENGTHTYPE_CM* = 6 + SVG_LENGTHTYPE_MM* = 7 + SVG_LENGTHTYPE_IN* = 8 + SVG_LENGTHTYPE_PT* = 9 + SVG_LENGTHTYPE_PC* = 10 + svgLengthType_Max* = 0x7fffffff + IID_ISVGLength* = DEFINE_GUID("305104cf-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGLength* = DEFINE_GUID("3051057e-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGLengthList* = DEFINE_GUID("305104d1-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGLengthList* = DEFINE_GUID("30510580-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGMatrix* = DEFINE_GUID("305104f6-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGMatrix* = DEFINE_GUID("305105ae-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGNumber* = DEFINE_GUID("305104cb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGNumber* = DEFINE_GUID("30510587-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGNumberList* = DEFINE_GUID("305104cd-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGNumberList* = DEFINE_GUID("30510589-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPaint* = DEFINE_GUID("30510524-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPatternElement* = DEFINE_GUID("3051052c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPatternElement* = DEFINE_GUID("3059002c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPatternElement* = DEFINE_GUID("3059002c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPatternElement* = DEFINE_GUID("305105d4-98b5-11cf-bb82-00aa00bdce0b") + PATHSEG_UNKNOWN* = 0 + PATHSEG_CLOSEPATH* = 1 + PATHSEG_MOVETO_ABS* = 2 + PATHSEG_MOVETO_REL* = 3 + PATHSEG_LINETO_ABS* = 4 + PATHSEG_LINETO_REL* = 5 + PATHSEG_CURVETO_CUBIC_ABS* = 6 + PATHSEG_CURVETO_CUBIC_REL* = 7 + PATHSEG_CURVETO_QUADRATIC_ABS* = 8 + PATHSEG_CURVETO_QUADRATIC_REL* = 9 + PATHSEG_ARC_ABS* = 10 + PATHSEG_ARC_REL* = 11 + PATHSEG_LINETO_HORIZONTAL_ABS* = 12 + PATHSEG_LINETO_HORIZONTAL_REL* = 13 + PATHSEG_LINETO_VERTICAL_ABS* = 14 + PATHSEG_LINETO_VERTICAL_REL* = 15 + PATHSEG_CURVETO_CUBIC_SMOOTH_ABS* = 16 + PATHSEG_CURVETO_CUBIC_SMOOTH_REL* = 17 + PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS* = 18 + PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL* = 19 + svgPathSegType_Max* = 0x7fffffff + IID_ISVGPathSeg* = DEFINE_GUID("305104fc-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegArcAbs* = DEFINE_GUID("30510506-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegArcRel* = DEFINE_GUID("30510507-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegClosePath* = DEFINE_GUID("305104fd-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegMovetoAbs* = DEFINE_GUID("305104fe-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegMovetoRel* = DEFINE_GUID("305104ff-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoAbs* = DEFINE_GUID("30510500-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoRel* = DEFINE_GUID("30510501-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoCubicAbs* = DEFINE_GUID("30510502-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoCubicRel* = DEFINE_GUID("30510503-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoCubicSmoothAbs* = DEFINE_GUID("3051050c-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoCubicSmoothRel* = DEFINE_GUID("3051050d-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoQuadraticAbs* = DEFINE_GUID("30510504-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoQuadraticRel* = DEFINE_GUID("30510505-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoQuadraticSmoothAbs* = DEFINE_GUID("3051050e-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegCurvetoQuadraticSmoothRel* = DEFINE_GUID("3051050f-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoHorizontalAbs* = DEFINE_GUID("30510508-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoHorizontalRel* = DEFINE_GUID("30510509-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoVerticalAbs* = DEFINE_GUID("3051050a-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegLinetoVerticalRel* = DEFINE_GUID("3051050b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSeg* = DEFINE_GUID("305105b3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegArcAbs* = DEFINE_GUID("30590013-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegArcAbs* = DEFINE_GUID("30590013-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegArcAbs* = DEFINE_GUID("305105bb-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegArcRel* = DEFINE_GUID("30590014-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegArcRel* = DEFINE_GUID("30590014-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegArcRel* = DEFINE_GUID("305105bc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegClosePath* = DEFINE_GUID("30590015-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegClosePath* = DEFINE_GUID("30590015-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegClosePath* = DEFINE_GUID("305105bd-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegMovetoAbs* = DEFINE_GUID("30590024-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegMovetoAbs* = DEFINE_GUID("30590024-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegMovetoAbs* = DEFINE_GUID("305105cc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegMovetoRel* = DEFINE_GUID("30590025-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegMovetoRel* = DEFINE_GUID("30590025-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegMovetoRel* = DEFINE_GUID("305105cd-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoAbs* = DEFINE_GUID("3059001e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoAbs* = DEFINE_GUID("3059001e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoAbs* = DEFINE_GUID("305105c6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoRel* = DEFINE_GUID("30590021-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoRel* = DEFINE_GUID("30590021-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoRel* = DEFINE_GUID("305105c9-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoCubicAbs* = DEFINE_GUID("30590016-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoCubicAbs* = DEFINE_GUID("30590016-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoCubicAbs* = DEFINE_GUID("305105be-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoCubicRel* = DEFINE_GUID("30590017-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoCubicRel* = DEFINE_GUID("30590017-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoCubicRel* = DEFINE_GUID("305105bf-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoCubicSmoothAbs* = DEFINE_GUID("30590018-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoCubicSmoothAbs* = DEFINE_GUID("30590018-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoCubicSmoothAbs* = DEFINE_GUID("305105c0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoCubicSmoothRel* = DEFINE_GUID("30590019-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoCubicSmoothRel* = DEFINE_GUID("30590019-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoCubicSmoothRel* = DEFINE_GUID("305105c1-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoQuadraticAbs* = DEFINE_GUID("3059001a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoQuadraticAbs* = DEFINE_GUID("3059001a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoQuadraticAbs* = DEFINE_GUID("305105c2-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoQuadraticRel* = DEFINE_GUID("3059001b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoQuadraticRel* = DEFINE_GUID("3059001b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoQuadraticRel* = DEFINE_GUID("305105c3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoQuadraticSmoothAbs* = DEFINE_GUID("3059001c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoQuadraticSmoothAbs* = DEFINE_GUID("3059001c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoQuadraticSmoothAbs* = DEFINE_GUID("305105c4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegCurvetoQuadraticSmoothRel* = DEFINE_GUID("3059001d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegCurvetoQuadraticSmoothRel* = DEFINE_GUID("3059001d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegCurvetoQuadraticSmoothRel* = DEFINE_GUID("305105c5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoHorizontalAbs* = DEFINE_GUID("3059001f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoHorizontalAbs* = DEFINE_GUID("3059001f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoHorizontalAbs* = DEFINE_GUID("305105c7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoHorizontalRel* = DEFINE_GUID("30590020-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoHorizontalRel* = DEFINE_GUID("30590020-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoHorizontalRel* = DEFINE_GUID("305105c8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoVerticalAbs* = DEFINE_GUID("30590022-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoVerticalAbs* = DEFINE_GUID("30590022-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoVerticalAbs* = DEFINE_GUID("305105ca-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathSegLinetoVerticalRel* = DEFINE_GUID("30590023-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathSegLinetoVerticalRel* = DEFINE_GUID("30590023-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegLinetoVerticalRel* = DEFINE_GUID("305105cb-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathSegList* = DEFINE_GUID("30510510-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathSegList* = DEFINE_GUID("305105b4-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPoint* = DEFINE_GUID("305104f4-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPoint* = DEFINE_GUID("305105ba-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPointList* = DEFINE_GUID("305104f5-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPointList* = DEFINE_GUID("305105b9-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGRect* = DEFINE_GUID("305104d7-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGRect* = DEFINE_GUID("30510583-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGStringList* = DEFINE_GUID("305104c8-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGStringList* = DEFINE_GUID("3051058d-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGViewSpec* = DEFINE_GUID("305104e2-98b5-11cf-bb82-00aa00bdce0b") + SVG_TRANSFORM_UNKNOWN* = 0 + SVG_TRANSFORM_MATRIX* = 1 + SVG_TRANSFORM_TRANSLATE* = 2 + SVG_TRANSFORM_SCALE* = 3 + SVG_TRANSFORM_ROTATE* = 4 + SVG_TRANSFORM_SKEWX* = 5 + SVG_TRANSFORM_SKEWY* = 6 + svgTransformType_Max* = 0x7fffffff + IID_ISVGTransform* = DEFINE_GUID("305104f7-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTransform* = DEFINE_GUID("305105af-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGSVGElement* = DEFINE_GUID("305104e7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGSVGElement* = DEFINE_GUID("30590001-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGSVGElement* = DEFINE_GUID("30590001-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGSVGElement* = DEFINE_GUID("30510574-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGUseElement* = DEFINE_GUID("305104ed-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGUseElement* = DEFINE_GUID("30590010-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGUseElement* = DEFINE_GUID("30590010-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGUseElement* = DEFINE_GUID("30510590-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLStyleSheetRulesAppliedCollection* = DEFINE_GUID("305104c0-98b5-11cf-bb82-00aa00bdce0b") + IID_IRulesApplied* = DEFINE_GUID("305104bf-98b5-11cf-bb82-00aa00bdce0b") + IID_IRulesAppliedCollection* = DEFINE_GUID("305104be-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLStyleSheetRulesAppliedCollection* = DEFINE_GUID("3050f5a6-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLStyleSheetRulesAppliedCollection* = DEFINE_GUID("3050f5a6-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLStyleSheetRulesAppliedCollection* = DEFINE_GUID("eb36f845-2395-4719-b85c-d0d80e184bd9") + DIID_DispRulesApplied* = DEFINE_GUID("3050f5a5-98b5-11cf-bb82-00aa00bdce0b") + IID_DispRulesApplied* = DEFINE_GUID("3050f5a5-98b5-11cf-bb82-00aa00bdce0b") + CLSID_RulesApplied* = DEFINE_GUID("7c803920-7a53-4d26-98ac-fdd23e6b9e01") + DIID_DispRulesAppliedCollection* = DEFINE_GUID("3050f5a4-98b5-11cf-bb82-00aa00bdce0b") + IID_DispRulesAppliedCollection* = DEFINE_GUID("3050f5a4-98b5-11cf-bb82-00aa00bdce0b") + CLSID_RulesAppliedCollection* = DEFINE_GUID("671926ee-c3cf-40af-be8f-1cbaee6486e8") + DIID_DispHTMLW3CComputedStyle* = DEFINE_GUID("30590070-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLW3CComputedStyle* = DEFINE_GUID("30590070-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLW3CComputedStyle* = DEFINE_GUID("305106c8-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTransformList* = DEFINE_GUID("305104f8-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTransformList* = DEFINE_GUID("305105b0-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedPoints* = DEFINE_GUID("30510517-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGCircleElement* = DEFINE_GUID("30510514-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGEllipseElement* = DEFINE_GUID("30510515-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGLineElement* = DEFINE_GUID("30510516-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGRectElement* = DEFINE_GUID("30510513-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPolygonElement* = DEFINE_GUID("30510519-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPolylineElement* = DEFINE_GUID("30510518-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGCircleElement* = DEFINE_GUID("3059000a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGCircleElement* = DEFINE_GUID("3059000a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGCircleElement* = DEFINE_GUID("30510578-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGEllipseElement* = DEFINE_GUID("3059000b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGEllipseElement* = DEFINE_GUID("3059000b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGEllipseElement* = DEFINE_GUID("30510579-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGLineElement* = DEFINE_GUID("3059000c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGLineElement* = DEFINE_GUID("3059000c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGLineElement* = DEFINE_GUID("3051057a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGRectElement* = DEFINE_GUID("30590009-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGRectElement* = DEFINE_GUID("30590009-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGRectElement* = DEFINE_GUID("30510577-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPolygonElement* = DEFINE_GUID("3059000d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPolygonElement* = DEFINE_GUID("3059000d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPolygonElement* = DEFINE_GUID("3051057b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPolylineElement* = DEFINE_GUID("3059000e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPolylineElement* = DEFINE_GUID("3059000e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPolylineElement* = DEFINE_GUID("3051057c-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGGElement* = DEFINE_GUID("305104e8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGGElement* = DEFINE_GUID("30590002-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGGElement* = DEFINE_GUID("30590002-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGGElement* = DEFINE_GUID("3051056f-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGSymbolElement* = DEFINE_GUID("305104ec-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGSymbolElement* = DEFINE_GUID("30590004-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGSymbolElement* = DEFINE_GUID("30590004-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGSymbolElement* = DEFINE_GUID("30510571-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGDefsElement* = DEFINE_GUID("305104e9-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGDefsElement* = DEFINE_GUID("30590003-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGDefsElement* = DEFINE_GUID("30590003-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGDefsElement* = DEFINE_GUID("30510570-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedPathData* = DEFINE_GUID("30510511-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGPathElement* = DEFINE_GUID("30510512-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGPathElement* = DEFINE_GUID("30590011-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGPathElement* = DEFINE_GUID("30590011-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPathElement* = DEFINE_GUID("305105b2-98b5-11cf-bb82-00aa00bdce0b") + SVG_PRESERVEASPECTRATIO_UNKNOWN* = 0 + SVG_PRESERVEASPECTRATIO_NONE* = 1 + SVG_PRESERVEASPECTRATIO_XMINYMIN* = 2 + SVG_PRESERVEASPECTRATIO_XMIDYMIN* = 3 + SVG_PRESERVEASPECTRATIO_XMAXYMIN* = 4 + SVG_PRESERVEASPECTRATIO_XMINYMID* = 5 + SVG_PRESERVEASPECTRATIO_XMIDYMID* = 6 + SVG_PRESERVEASPECTRATIO_XMAXYMID* = 7 + SVG_PRESERVEASPECTRATIO_XMINYMAX* = 8 + SVG_PRESERVEASPECTRATIO_XMIDYMAX* = 9 + SVG_PRESERVEASPECTRATIO_XMAXYMAX* = 10 + svgPreserveAspectRatioAlignType_Max* = 0x7fffffff + SVG_MEETORSLICE_UNKNOWN* = 0 + SVG_MEETORSLICE_MEET* = 1 + SVG_MEETORSLICE_SLICE* = 2 + svgPreserveAspectMeetOrSliceType_Max* = 0x7fffffff + IID_ISVGPreserveAspectRatio* = DEFINE_GUID("305104fa-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGPreserveAspectRatio* = DEFINE_GUID("305105d0-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTextElement* = DEFINE_GUID("3051051c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTextElement* = DEFINE_GUID("30590037-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTextElement* = DEFINE_GUID("30590037-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTextElement* = DEFINE_GUID("305105df-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAnimatedPreserveAspectRatio* = DEFINE_GUID("305104fb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAnimatedPreserveAspectRatio* = DEFINE_GUID("305105ce-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGImageElement* = DEFINE_GUID("305104f0-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGImageElement* = DEFINE_GUID("30590027-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGImageElement* = DEFINE_GUID("30590027-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGImageElement* = DEFINE_GUID("305105cf-98b5-11cf-bb82-00aa00bdce0b") + SVG_UNITTYPE_UNKNOWN* = 0 + SVG_UNITTYPE_USERSPACEONUSE* = 1 + SVG_UNITTYPE_OBJECTBOUNDINGBOX* = 2 + svgUnitTypes_Max* = 0x7fffffff + IID_ISVGStopElement* = DEFINE_GUID("3051052b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGStopElement* = DEFINE_GUID("3059002d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGStopElement* = DEFINE_GUID("3059002d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGStopElement* = DEFINE_GUID("305105d5-98b5-11cf-bb82-00aa00bdce0b") + SVG_SPREADMETHOD_UNKNOWN* = 0 + SVG_SPREADMETHOD_PAD* = 1 + SVG_SPREADMETHOD_REFLECT* = 2 + SVG_SPREADMETHOD_REPEAT* = 3 + svgSpreadMethod_Max* = 0x7fffffff + IID_ISVGGradientElement* = DEFINE_GUID("30510528-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGGradientElement* = DEFINE_GUID("3059002e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGGradientElement* = DEFINE_GUID("3059002e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGGradientElement* = DEFINE_GUID("305105d6-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGLinearGradientElement* = DEFINE_GUID("30510529-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGLinearGradientElement* = DEFINE_GUID("3059002a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGLinearGradientElement* = DEFINE_GUID("3059002a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGLinearGradientElement* = DEFINE_GUID("305105d2-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGRadialGradientElement* = DEFINE_GUID("3051052a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGRadialGradientElement* = DEFINE_GUID("3059002b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGRadialGradientElement* = DEFINE_GUID("3059002b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGRadialGradientElement* = DEFINE_GUID("305105d3-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGMaskElement* = DEFINE_GUID("3051052e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGMaskElement* = DEFINE_GUID("3059003c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGMaskElement* = DEFINE_GUID("3059003c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGMaskElement* = DEFINE_GUID("305105e7-98b5-11cf-bb82-00aa00bdce0b") + SVG_FEBLEND_MODE_UNKNOWN* = 0 + SVG_FEBLEND_MODE_NORMAL* = 1 + SVG_FEBLEND_MODE_MULTIPLY* = 2 + SVG_FEBLEND_MODE_SCREEN* = 3 + SVG_FEBLEND_MODE_DARKEN* = 4 + SVG_FEBLEND_MODE_LIGHTEN* = 5 + svgFeblendMode_Max* = 0x7fffffff + SVG_FECOLORMATRIX_TYPE_UNKNOWN* = 0 + SVG_FECOLORMATRIX_TYPE_MATRIX* = 1 + SVG_FECOLORMATRIX_TYPE_SATURATE* = 2 + SVG_FECOLORMATRIX_TYPE_HUEROTATE* = 3 + SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA* = 4 + svgFecolormatrixType_Max* = 0x7fffffff + SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN* = 0 + SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY* = 1 + SVG_FECOMPONENTTRANSFER_TYPE_TABLE* = 2 + SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE* = 3 + SVG_FECOMPONENTTRANSFER_TYPE_LINEAR* = 4 + SVG_FECOMPONENTTRANSFER_TYPE_GAMMA* = 5 + svgFecomponenttransferType_Max* = 0x7fffffff + SVG_FECOMPOSITE_OPERATOR_UNKNOWN* = 0 + SVG_FECOMPOSITE_OPERATOR_OVER* = 1 + SVG_FECOMPOSITE_OPERATOR_IN* = 2 + SVG_FECOMPOSITE_OPERATOR_OUT* = 3 + SVG_FECOMPOSITE_OPERATOR_ATOP* = 4 + SVG_FECOMPOSITE_OPERATOR_XOR* = 5 + SVG_FECOMPOSITE_OPERATOR_ARITHMETIC* = 6 + svgFecompositeOperator_Max* = 0x7fffffff + SVG_EDGEMODE_UNKNOWN* = 0 + SVG_EDGEMODE_DUPLICATE* = 1 + SVG_EDGEMODE_WRAP* = 2 + SVG_EDGEMODE_NONE* = 3 + svgEdgemode_Max* = 0x7fffffff + SVG_PRESERVEALPHA_FALSE* = 0 + SVG_PRESERVEALPHA_TRUE* = 1 + svgPreserveAlpha_Max* = 0x7fffffff + SVG_CHANNEL_UNKNOWN* = 0 + SVG_CHANNEL_R* = 1 + SVG_CHANNEL_G* = 2 + SVG_CHANNEL_B* = 3 + SVG_CHANNEL_A* = 4 + svgChannel_Max* = 0x7fffffff + SVG_MORPHOLOGY_OPERATOR_UNKNOWN* = 0 + SVG_MORPHOLOGY_OPERATOR_ERODE* = 1 + SVG_MORPHOLOGY_OPERATOR_DILATE* = 2 + svgMorphologyOperator_Max* = 0x7fffffff + SVG_TURBULENCE_TYPE_UNKNOWN* = 0 + SVG_TURBULENCE_TYPE_FACTALNOISE* = 1 + SVG_TURBULENCE_TYPE_TURBULENCE* = 2 + svgTurbulenceType_Max* = 0x7fffffff + SVG_STITCHTYPE_UNKNOWN* = 0 + SVG_STITCHTYPE_STITCH* = 1 + SVG_STITCHTYPE_NOSTITCH* = 2 + svgStitchtype_Max* = 0x7fffffff + SVG_MARKERUNITS_UNKNOWN* = 0 + SVG_MARKERUNITS_USERSPACEONUSE* = 1 + SVG_MARKERUNITS_STROKEWIDTH* = 2 + svgMarkerUnits_Max* = 0x7fffffff + SVG_MARKER_ORIENT_UNKNOWN* = 0 + SVG_MARKER_ORIENT_AUTO* = 1 + SVG_MARKER_ORIENT_ANGLE* = 2 + svgMarkerOrient_Max* = 0x7fffffff + svgMarkerOrientAttributeAuto* = 0 + svgMarkerOrientAttribute_Max* = 0x7fffffff + IID_ISVGMarkerElement* = DEFINE_GUID("30510525-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGMarkerElement* = DEFINE_GUID("30590036-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGMarkerElement* = DEFINE_GUID("30590036-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGMarkerElement* = DEFINE_GUID("305105de-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGZoomEvent* = DEFINE_GUID("3051054e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGZoomEvent* = DEFINE_GUID("30590031-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGZoomEvent* = DEFINE_GUID("30590031-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGZoomEvent* = DEFINE_GUID("305105d9-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGAElement* = DEFINE_GUID("3051054b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGAElement* = DEFINE_GUID("30590033-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGAElement* = DEFINE_GUID("30590033-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGAElement* = DEFINE_GUID("305105db-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGViewElement* = DEFINE_GUID("3051054c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGViewElement* = DEFINE_GUID("30590034-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGViewElement* = DEFINE_GUID("30590034-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGViewElement* = DEFINE_GUID("305105dc-98b5-11cf-bb82-00aa00bdce0b") + htmlMediaNetworkStateEmpty* = 0 + htmlMediaNetworkStateIdle* = 1 + htmlMediaNetworkStateLoading* = 2 + htmlMediaNetworkStateNoSource* = 3 + htmlMediaNetworkState_Max* = 0x7fffffff + htmlMediaReadyStateHaveNothing* = 0 + htmlMediaReadyStateHaveMetadata* = 1 + htmlMediaReadyStateHaveCurrentData* = 2 + htmlMediaReadyStateHaveFutureData* = 3 + htmlMediaReadyStateHaveEnoughData* = 4 + htmlMediaReadyState_Max* = 0x7fffffff + htmlMediaErrAborted* = 0 + htmlMediaErrNetwork* = 1 + htmlMediaErrDecode* = 2 + htmlMediaErrSrcNotSupported* = 3 + htmlMediaErr_Max* = 0x7fffffff + IID_IHTMLMediaError* = DEFINE_GUID("30510704-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTimeRanges* = DEFINE_GUID("30510705-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLTimeRanges2* = DEFINE_GUID("3051080b-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMediaElement* = DEFINE_GUID("30510706-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMediaElement2* = DEFINE_GUID("30510809-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLMSMediaElement* = DEFINE_GUID("30510792-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLSourceElement* = DEFINE_GUID("30510707-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAudioElement* = DEFINE_GUID("30510708-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLVideoElement* = DEFINE_GUID("30510709-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAudioElementFactory* = DEFINE_GUID("305107eb-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMediaError* = DEFINE_GUID("30590086-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMediaError* = DEFINE_GUID("30590086-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMediaError* = DEFINE_GUID("3051070a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLTimeRanges* = DEFINE_GUID("30590087-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLTimeRanges* = DEFINE_GUID("30590087-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLTimeRanges* = DEFINE_GUID("3051070b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLMediaElement* = DEFINE_GUID("30590088-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLMediaElement* = DEFINE_GUID("30590088-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLMediaElement* = DEFINE_GUID("3051070c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLSourceElement* = DEFINE_GUID("30590089-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLSourceElement* = DEFINE_GUID("30590089-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLSourceElement* = DEFINE_GUID("3051070d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAudioElement* = DEFINE_GUID("3059008a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAudioElement* = DEFINE_GUID("3059008a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAudioElement* = DEFINE_GUID("3051070e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAudioElementFactory* = DEFINE_GUID("305107ec-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLVideoElement* = DEFINE_GUID("3059008b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLVideoElement* = DEFINE_GUID("3059008b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLVideoElement* = DEFINE_GUID("3051070f-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGSwitchElement* = DEFINE_GUID("305104f1-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGSwitchElement* = DEFINE_GUID("30590030-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGSwitchElement* = DEFINE_GUID("30590030-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGSwitchElement* = DEFINE_GUID("305105d8-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGDescElement* = DEFINE_GUID("305104ea-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGDescElement* = DEFINE_GUID("30590005-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGDescElement* = DEFINE_GUID("30590005-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGDescElement* = DEFINE_GUID("30510572-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTitleElement* = DEFINE_GUID("305104eb-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTitleElement* = DEFINE_GUID("30590006-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTitleElement* = DEFINE_GUID("30590006-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTitleElement* = DEFINE_GUID("30510573-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGMetadataElement* = DEFINE_GUID("30510560-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGMetadataElement* = DEFINE_GUID("3059002f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGMetadataElement* = DEFINE_GUID("3059002f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGMetadataElement* = DEFINE_GUID("305105d7-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGElementInstance* = DEFINE_GUID("305104ee-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGElementInstance* = DEFINE_GUID("30590007-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGElementInstance* = DEFINE_GUID("30590007-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGElementInstance* = DEFINE_GUID("30510575-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGElementInstanceList* = DEFINE_GUID("305104ef-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGElementInstanceList* = DEFINE_GUID("30590008-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGElementInstanceList* = DEFINE_GUID("30590008-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGElementInstanceList* = DEFINE_GUID("30510576-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMException* = DEFINE_GUID("3051072b-98b5-11cf-bb82-00aa00bdce0b") + IID_IRangeException* = DEFINE_GUID("3051072d-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGException* = DEFINE_GUID("3051072f-98b5-11cf-bb82-00aa00bdce0b") + IID_IEventException* = DEFINE_GUID("3051073a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMException* = DEFINE_GUID("30590094-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMException* = DEFINE_GUID("30590094-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMException* = DEFINE_GUID("3051072c-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispRangeException* = DEFINE_GUID("30590095-98b5-11cf-bb82-00aa00bdce0b") + IID_DispRangeException* = DEFINE_GUID("30590095-98b5-11cf-bb82-00aa00bdce0b") + CLSID_RangeException* = DEFINE_GUID("3051072e-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGException* = DEFINE_GUID("30590096-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGException* = DEFINE_GUID("30590096-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGException* = DEFINE_GUID("30510730-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispEventException* = DEFINE_GUID("30590099-98b5-11cf-bb82-00aa00bdce0b") + IID_DispEventException* = DEFINE_GUID("30590099-98b5-11cf-bb82-00aa00bdce0b") + CLSID_EventException* = DEFINE_GUID("3051073b-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGScriptElement* = DEFINE_GUID("3051054d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGScriptElement* = DEFINE_GUID("30590039-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGScriptElement* = DEFINE_GUID("30590039-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGScriptElement* = DEFINE_GUID("305105e1-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGStyleElement* = DEFINE_GUID("305104f3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGStyleElement* = DEFINE_GUID("30590029-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGStyleElement* = DEFINE_GUID("30590029-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGStyleElement* = DEFINE_GUID("305105d1-98b5-11cf-bb82-00aa00bdce0b") + LENGTHADJUST_UNKNOWN* = 0 + LENGTHADJUST_SPACING* = 1 + LENGTHADJUST_SPACINGANDGLYPHS* = 2 + lengthAdjust_Max* = 0x7fffffff + IID_ISVGTextContentElement* = DEFINE_GUID("3051051a-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTextContentElement* = DEFINE_GUID("30590035-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTextContentElement* = DEFINE_GUID("30590035-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTextContentElement* = DEFINE_GUID("305105dd-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTextPositioningElement* = DEFINE_GUID("3051051b-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTextPositioningElement* = DEFINE_GUID("30590038-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTextPositioningElement* = DEFINE_GUID("30590038-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTextPositioningElement* = DEFINE_GUID("305105e0-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMDocumentType* = DEFINE_GUID("30510738-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMDocumentType* = DEFINE_GUID("30590098-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMDocumentType* = DEFINE_GUID("30590098-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMDocumentType* = DEFINE_GUID("30510739-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMNodeIterator* = DEFINE_GUID("30510746-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMTreeWalker* = DEFINE_GUID("30510748-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispNodeIterator* = DEFINE_GUID("3059009c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispNodeIterator* = DEFINE_GUID("3059009c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_NodeIterator* = DEFINE_GUID("30510745-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispTreeWalker* = DEFINE_GUID("3059009d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispTreeWalker* = DEFINE_GUID("3059009d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_TreeWalker* = DEFINE_GUID("30510747-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMProcessingInstruction* = DEFINE_GUID("30510742-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMProcessingInstruction* = DEFINE_GUID("3059009b-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMProcessingInstruction* = DEFINE_GUID("3059009b-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMProcessingInstruction* = DEFINE_GUID("30510743-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPerformance* = DEFINE_GUID("3051074e-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPerformanceNavigation* = DEFINE_GUID("30510750-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPerformanceTiming* = DEFINE_GUID("30510752-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLPerformance* = DEFINE_GUID("3059009f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLPerformance* = DEFINE_GUID("3059009f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLPerformance* = DEFINE_GUID("3051074f-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLPerformanceNavigation* = DEFINE_GUID("305900a0-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLPerformanceNavigation* = DEFINE_GUID("305900a0-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLPerformanceNavigation* = DEFINE_GUID("30510751-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLPerformanceTiming* = DEFINE_GUID("305900a1-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLPerformanceTiming* = DEFINE_GUID("305900a1-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLPerformanceTiming* = DEFINE_GUID("30510753-98b5-11cf-bb82-00aa00bdce0b") + IID_ISVGTSpanElement* = DEFINE_GUID("3051051d-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTSpanElement* = DEFINE_GUID("3059003a-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTSpanElement* = DEFINE_GUID("3059003a-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTSpanElement* = DEFINE_GUID("305105e2-98b5-11cf-bb82-00aa00bdce0b") + IID_ITemplatePrinter* = DEFINE_GUID("3050f6b4-98b5-11cf-bb82-00aa00bdce0b") + IID_ITemplatePrinter2* = DEFINE_GUID("3050f83f-98b5-11cf-bb82-00aa00bdce0b") + IID_ITemplatePrinter3* = DEFINE_GUID("305104a3-98b5-11cf-bb82-00aa00bdce0b") + IID_IPrintManagerTemplatePrinter* = DEFINE_GUID("f633be14-9eff-4c4d-929e-05717b21b3e6") + CLSID_CTemplatePrinter* = DEFINE_GUID("3050f6b3-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispCPrintManagerTemplatePrinter* = DEFINE_GUID("305900e9-98b5-11cf-bb82-00aa00bdce0b") + IID_DispCPrintManagerTemplatePrinter* = DEFINE_GUID("305900e9-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CPrintManagerTemplatePrinter* = DEFINE_GUID("63619f54-9d71-4c23-a08d-50d7f18db2e9") + TEXTPATH_METHODTYPE_UNKNOWN* = 0 + TEXTPATH_METHODTYPE_ALIGN* = 1 + TEXTPATH_METHODTYPE_STRETCH* = 2 + textpathMethodtype_Max* = 0x7fffffff + TEXTPATH_SPACINGTYPE_UNKNOWN* = 0 + TEXTPATH_SPACINGTYPE_AUTO* = 1 + TEXTPATH_SPACINGTYPE_EXACT* = 2 + textpathSpacingtype_Max* = 0x7fffffff + IID_ISVGTextPathElement* = DEFINE_GUID("3051051f-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispSVGTextPathElement* = DEFINE_GUID("3059003d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispSVGTextPathElement* = DEFINE_GUID("3059003d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_SVGTextPathElement* = DEFINE_GUID("305105eb-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMXmlSerializer* = DEFINE_GUID("3051077d-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMXmlSerializerFactory* = DEFINE_GUID("3051077f-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMParser* = DEFINE_GUID("30510781-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMParserFactory* = DEFINE_GUID("30510783-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispXMLSerializer* = DEFINE_GUID("305900ad-98b5-11cf-bb82-00aa00bdce0b") + IID_DispXMLSerializer* = DEFINE_GUID("305900ad-98b5-11cf-bb82-00aa00bdce0b") + CLSID_XMLSerializer* = DEFINE_GUID("3051077e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDOMXmlSerializerFactory* = DEFINE_GUID("30510780-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMParser* = DEFINE_GUID("305900ae-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMParser* = DEFINE_GUID("305900ae-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMParser* = DEFINE_GUID("30510782-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMParserFactory* = DEFINE_GUID("30510784-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLSemanticElement* = DEFINE_GUID("305900ba-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLSemanticElement* = DEFINE_GUID("305900ba-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLSemanticElement* = DEFINE_GUID("305107b0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLProgressElement* = DEFINE_GUID("3050f2d6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLProgressElement* = DEFINE_GUID("305900af-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLProgressElement* = DEFINE_GUID("305900af-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLProgressElement* = DEFINE_GUID("3050f2d5-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMSTransitionEvent* = DEFINE_GUID("305107b5-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMSTransitionEvent* = DEFINE_GUID("305900bb-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMSTransitionEvent* = DEFINE_GUID("305900bb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMSTransitionEvent* = DEFINE_GUID("305107b6-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMMSAnimationEvent* = DEFINE_GUID("305107b7-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMSAnimationEvent* = DEFINE_GUID("305900bc-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMSAnimationEvent* = DEFINE_GUID("305900bc-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMSAnimationEvent* = DEFINE_GUID("305107b8-98b5-11cf-bb82-00aa00bdce0b") + IID_IWebGeolocation* = DEFINE_GUID("305107c5-98b5-11cf-bb82-00aa00bdce0b") + IID_IWebGeocoordinates* = DEFINE_GUID("305107c7-98b5-11cf-bb82-00aa00bdce0b") + IID_IWebGeopositionError* = DEFINE_GUID("305107c9-98b5-11cf-bb82-00aa00bdce0b") + IID_IWebGeoposition* = DEFINE_GUID("305107cd-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispWebGeolocation* = DEFINE_GUID("305900bd-98b5-11cf-bb82-00aa00bdce0b") + IID_DispWebGeolocation* = DEFINE_GUID("305900bd-98b5-11cf-bb82-00aa00bdce0b") + CLSID_WebGeolocation* = DEFINE_GUID("305107c6-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispWebGeocoordinates* = DEFINE_GUID("305900be-98b5-11cf-bb82-00aa00bdce0b") + IID_DispWebGeocoordinates* = DEFINE_GUID("305900be-98b5-11cf-bb82-00aa00bdce0b") + CLSID_WebGeocoordinates* = DEFINE_GUID("305107c8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispWebGeopositionError* = DEFINE_GUID("305900bf-98b5-11cf-bb82-00aa00bdce0b") + IID_DispWebGeopositionError* = DEFINE_GUID("305900bf-98b5-11cf-bb82-00aa00bdce0b") + CLSID_WebGeopositionError* = DEFINE_GUID("305107ca-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispWebGeoposition* = DEFINE_GUID("305900c1-98b5-11cf-bb82-00aa00bdce0b") + IID_DispWebGeoposition* = DEFINE_GUID("305900c1-98b5-11cf-bb82-00aa00bdce0b") + CLSID_WebGeoposition* = DEFINE_GUID("305107ce-98b5-11cf-bb82-00aa00bdce0b") + IID_IClientCaps* = DEFINE_GUID("7e8bc44d-aeff-11d1-89c2-00c04fb6bfc4") + CLSID_CClientCaps* = DEFINE_GUID("7e8bc44e-aeff-11d1-89c2-00c04fb6bfc4") + IID_IDOMMSManipulationEvent* = DEFINE_GUID("30510816-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMMSManipulationEvent* = DEFINE_GUID("305900e1-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMMSManipulationEvent* = DEFINE_GUID("305900e1-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMMSManipulationEvent* = DEFINE_GUID("30510817-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMCloseEvent* = DEFINE_GUID("305107ff-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispDOMCloseEvent* = DEFINE_GUID("305900dc-98b5-11cf-bb82-00aa00bdce0b") + IID_DispDOMCloseEvent* = DEFINE_GUID("305900dc-98b5-11cf-bb82-00aa00bdce0b") + CLSID_DOMCloseEvent* = DEFINE_GUID("30510800-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLApplicationCache* = DEFINE_GUID("30510828-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispApplicationCache* = DEFINE_GUID("305900e4-98b5-11cf-bb82-00aa00bdce0b") + IID_DispApplicationCache* = DEFINE_GUID("305900e4-98b5-11cf-bb82-00aa00bdce0b") + CLSID_ApplicationCache* = DEFINE_GUID("30510829-98b5-11cf-bb82-00aa00bdce0b") + ELEMENT_CORNER_NONE* = 0 + ELEMENT_CORNER_TOP* = 1 + ELEMENT_CORNER_LEFT* = 2 + ELEMENT_CORNER_BOTTOM* = 3 + ELEMENT_CORNER_RIGHT* = 4 + ELEMENT_CORNER_TOPLEFT* = 5 + ELEMENT_CORNER_TOPRIGHT* = 6 + ELEMENT_CORNER_BOTTOMLEFT* = 7 + ELEMENT_CORNER_BOTTOMRIGHT* = 8 + ELEMENT_CORNER_Max* = 0x7fffffff + SUHV_PROMPTBEFORENO* = 0x1 + SUHV_SILENTYES* = 0x2 + SUHV_UNSECURESOURCE* = 0x4 + SECUREURLHOSTVALIDATE_FLAGS_Max* = 0x7fffffff + POINTER_GRAVITY_Left* = 0 + POINTER_GRAVITY_Right* = 1 + POINTER_GRAVITY_Max* = 0x7fffffff + ELEM_ADJ_BeforeBegin* = 0 + ELEM_ADJ_AfterBegin* = 1 + ELEM_ADJ_BeforeEnd* = 2 + ELEM_ADJ_AfterEnd* = 3 + ELEMENT_ADJACENCY_Max* = 0x7fffffff + CONTEXT_TYPE_None* = 0 + CONTEXT_TYPE_Text* = 1 + CONTEXT_TYPE_EnterScope* = 2 + CONTEXT_TYPE_ExitScope* = 3 + CONTEXT_TYPE_NoScope* = 4 + MARKUP_CONTEXT_TYPE_Max* = 0x7fffffff + FINDTEXT_BACKWARDS* = 0x1 + FINDTEXT_WHOLEWORD* = 0x2 + FINDTEXT_MATCHCASE* = 0x4 + FINDTEXT_RAW* = 0x20000 + FINDTEXT_MATCHREPEATEDWHITESPACE* = 0x40000 + FINDTEXT_MATCHDIAC* = 0x20000000 + FINDTEXT_MATCHKASHIDA* = 0x40000000 + FINDTEXT_MATCHALEFHAMZA* = 0x80000000'i32 + FINDTEXT_FLAGS_Max* = 0x7fffffff + MOVEUNIT_PREVCHAR* = 0 + MOVEUNIT_NEXTCHAR* = 1 + MOVEUNIT_PREVCLUSTERBEGIN* = 2 + MOVEUNIT_NEXTCLUSTERBEGIN* = 3 + MOVEUNIT_PREVCLUSTEREND* = 4 + MOVEUNIT_NEXTCLUSTEREND* = 5 + MOVEUNIT_PREVWORDBEGIN* = 6 + MOVEUNIT_NEXTWORDBEGIN* = 7 + MOVEUNIT_PREVWORDEND* = 8 + MOVEUNIT_NEXTWORDEND* = 9 + MOVEUNIT_PREVPROOFWORD* = 10 + MOVEUNIT_NEXTPROOFWORD* = 11 + MOVEUNIT_NEXTURLBEGIN* = 12 + MOVEUNIT_PREVURLBEGIN* = 13 + MOVEUNIT_NEXTURLEND* = 14 + MOVEUNIT_PREVURLEND* = 15 + MOVEUNIT_PREVSENTENCE* = 16 + MOVEUNIT_NEXTSENTENCE* = 17 + MOVEUNIT_PREVBLOCK* = 18 + MOVEUNIT_NEXTBLOCK* = 19 + MOVEUNIT_ACTION_Max* = 0x7fffffff + PARSE_ABSOLUTIFYIE40URLS* = 0x1 + PARSE_DISABLEVML* = 0x2 + PARSE_FLAGS_Max* = 0x7fffffff + TAGID_NULL* = 0 + TAGID_UNKNOWN* = 1 + TAGID_A* = 2 + TAGID_ACRONYM* = 3 + TAGID_ADDRESS* = 4 + TAGID_APPLET* = 5 + TAGID_AREA* = 6 + TAGID_B* = 7 + TAGID_BASE* = 8 + TAGID_BASEFONT* = 9 + TAGID_BDO* = 10 + TAGID_BGSOUND* = 11 + TAGID_BIG* = 12 + TAGID_BLINK* = 13 + TAGID_BLOCKQUOTE* = 14 + TAGID_BODY* = 15 + TAGID_BR* = 16 + TAGID_BUTTON* = 17 + TAGID_CAPTION* = 18 + TAGID_CENTER* = 19 + TAGID_CITE* = 20 + TAGID_CODE* = 21 + TAGID_COL* = 22 + TAGID_COLGROUP* = 23 + TAGID_COMMENT* = 24 + TAGID_COMMENT_RAW* = 25 + TAGID_DD* = 26 + TAGID_DEL* = 27 + TAGID_DFN* = 28 + TAGID_DIR* = 29 + TAGID_DIV* = 30 + TAGID_DL* = 31 + TAGID_DT* = 32 + TAGID_EM* = 33 + TAGID_EMBED* = 34 + TAGID_FIELDSET* = 35 + TAGID_FONT* = 36 + TAGID_FORM* = 37 + TAGID_FRAME* = 38 + TAGID_FRAMESET* = 39 + TAGID_GENERIC* = 40 + TAGID_H1* = 41 + TAGID_H2* = 42 + TAGID_H3* = 43 + TAGID_H4* = 44 + TAGID_H5* = 45 + TAGID_H6* = 46 + TAGID_HEAD* = 47 + TAGID_HR* = 48 + TAGID_HTML* = 49 + TAGID_I* = 50 + TAGID_IFRAME* = 51 + TAGID_IMG* = 52 + TAGID_INPUT* = 53 + TAGID_INS* = 54 + TAGID_KBD* = 55 + TAGID_LABEL* = 56 + TAGID_LEGEND* = 57 + TAGID_LI* = 58 + TAGID_LINK* = 59 + TAGID_LISTING* = 60 + TAGID_MAP* = 61 + TAGID_MARQUEE* = 62 + TAGID_MENU* = 63 + TAGID_META* = 64 + TAGID_NEXTID* = 65 + TAGID_NOBR* = 66 + TAGID_NOEMBED* = 67 + TAGID_NOFRAMES* = 68 + TAGID_NOSCRIPT* = 69 + TAGID_OBJECT* = 70 + TAGID_OL* = 71 + TAGID_OPTION* = 72 + TAGID_P* = 73 + TAGID_PARAM* = 74 + TAGID_PLAINTEXT* = 75 + TAGID_PRE* = 76 + TAGID_Q* = 77 + TAGID_RP* = 78 + TAGID_RT* = 79 + TAGID_RUBY* = 80 + TAGID_S* = 81 + TAGID_SAMP* = 82 + TAGID_SCRIPT* = 83 + TAGID_SELECT* = 84 + TAGID_SMALL* = 85 + TAGID_SPAN* = 86 + TAGID_STRIKE* = 87 + TAGID_STRONG* = 88 + TAGID_STYLE* = 89 + TAGID_SUB* = 90 + TAGID_SUP* = 91 + TAGID_TABLE* = 92 + TAGID_TBODY* = 93 + TAGID_TC* = 94 + TAGID_TD* = 95 + TAGID_TEXTAREA* = 96 + TAGID_TFOOT* = 97 + TAGID_TH* = 98 + TAGID_THEAD* = 99 + TAGID_TITLE* = 100 + TAGID_TR* = 101 + TAGID_TT* = 102 + TAGID_U* = 103 + TAGID_UL* = 104 + TAGID_VAR* = 105 + TAGID_WBR* = 106 + TAGID_XMP* = 107 + TAGID_ROOT* = 108 + TAGID_OPTGROUP* = 109 + TAGID_ABBR* = 110 + TAGID_SVG_A* = 111 + TAGID_SVG_ALTGLYPH* = 112 + TAGID_SVG_ALTGLYPHDEF* = 113 + TAGID_SVG_ALTGLYPHITEM* = 114 + TAGID_SVG_ANIMATE* = 115 + TAGID_SVG_ANIMATECOLOR* = 116 + TAGID_SVG_ANIMATEMOTION* = 117 + TAGID_SVG_ANIMATETRANSFORM* = 118 + TAGID_SVG_CIRCLE* = 119 + TAGID_SVG_CLIPPATH* = 120 + TAGID_SVG_COLOR_PROFILE* = 121 + TAGID_SVG_CURSOR* = 122 + TAGID_SVG_DEFINITION_SRC* = 123 + TAGID_SVG_DEFS* = 124 + TAGID_SVG_DESC* = 125 + TAGID_SVG_ELLIPSE* = 126 + TAGID_SVG_FEBLEND* = 127 + TAGID_SVG_FECOLORMATRIX* = 128 + TAGID_SVG_FECOMPONENTTRANSFER* = 129 + TAGID_SVG_FECOMPOSITE* = 130 + TAGID_SVG_FECONVOLVEMATRIX* = 131 + TAGID_SVG_FEDIFFUSELIGHTING* = 132 + TAGID_SVG_FEDISPLACEMENTMAP* = 133 + TAGID_SVG_FEDISTANTLIGHT* = 134 + TAGID_SVG_FEFLOOD* = 135 + TAGID_SVG_FEFUNCA* = 136 + TAGID_SVG_FEFUNCB* = 137 + TAGID_SVG_FEFUNCG* = 138 + TAGID_SVG_FEFUNCR* = 139 + TAGID_SVG_FEGAUSSIANBLUR* = 140 + TAGID_SVG_FEIMAGE* = 141 + TAGID_SVG_FEMERGE* = 142 + TAGID_SVG_FEMERGENODE* = 143 + TAGID_SVG_FEMORPHOLOGY* = 144 + TAGID_SVG_FEOFFSET* = 145 + TAGID_SVG_FEPOINTLIGHT* = 146 + TAGID_SVG_FESPECULARLIGHTING* = 147 + TAGID_SVG_FESPOTLIGHT* = 148 + TAGID_SVG_FETILE* = 149 + TAGID_SVG_FETURBULENCE* = 150 + TAGID_SVG_FILTER* = 151 + TAGID_SVG_FONT* = 152 + TAGID_SVG_FONT_FACE* = 153 + TAGID_SVG_FONT_FACE_FORMAT* = 154 + TAGID_SVG_FONT_FACE_NAME* = 155 + TAGID_SVG_FONT_FACE_SRC* = 156 + TAGID_SVG_FONT_FACE_URI* = 157 + TAGID_SVG_FOREIGNOBJECT* = 158 + TAGID_SVG_G* = 159 + TAGID_SVG_GLYPH* = 160 + TAGID_SVG_GLYPHREF* = 161 + TAGID_SVG_HKERN* = 162 + TAGID_SVG_IMAGE* = 163 + TAGID_SVG_LINE* = 164 + TAGID_SVG_LINEARGRADIENT* = 165 + TAGID_SVG_MARKER* = 166 + TAGID_SVG_MASK* = 167 + TAGID_SVG_METADATA* = 168 + TAGID_SVG_MISSING_GLYPH* = 169 + TAGID_SVG_MPATH* = 170 + TAGID_SVG_PATH* = 171 + TAGID_SVG_PATTERN* = 172 + TAGID_SVG_POLYGON* = 173 + TAGID_SVG_POLYLINE* = 174 + TAGID_SVG_RADIALGRADIENT* = 175 + TAGID_SVG_RECT* = 176 + TAGID_SVG_SCRIPT* = 177 + TAGID_SVG_SET* = 178 + TAGID_SVG_STOP* = 179 + TAGID_SVG_STYLE* = 180 + TAGID_SVG_SVG* = 181 + TAGID_SVG_SWITCH* = 182 + TAGID_SVG_SYMBOL* = 183 + TAGID_SVG_TEXT* = 184 + TAGID_SVG_TEXTPATH* = 185 + TAGID_SVG_TITLE* = 186 + TAGID_SVG_TREF* = 187 + TAGID_SVG_TSPAN* = 188 + TAGID_SVG_USE* = 189 + TAGID_SVG_VIEW* = 190 + TAGID_SVG_VKERN* = 191 + TAGID_AUDIO* = 192 + TAGID_SOURCE* = 193 + TAGID_VIDEO* = 194 + TAGID_CANVAS* = 195 + TAGID_DOCTYPE* = 196 + TAGID_KEYGEN* = 197 + TAGID_PROCESSINGINSTRUCTION* = 198 + TAGID_ARTICLE* = 199 + TAGID_ASIDE* = 200 + TAGID_FIGCAPTION* = 201 + TAGID_FIGURE* = 202 + TAGID_FOOTER* = 203 + TAGID_HEADER* = 204 + TAGID_HGROUP* = 205 + TAGID_MARK* = 206 + TAGID_NAV* = 207 + TAGID_SECTION* = 208 + TAGID_PROGRESS* = 209 + TAGID_MATHML_ANNOTATION_XML* = 210 + TAGID_MATHML_MATH* = 211 + TAGID_MATHML_MI* = 212 + TAGID_MATHML_MN* = 213 + TAGID_MATHML_MO* = 214 + TAGID_MATHML_MS* = 215 + TAGID_MATHML_MTEXT* = 216 + TAGID_DATALIST* = 217 + TAGID_TRACK* = 218 + TAGID_ISINDEX* = 219 + TAGID_COMMAND* = 220 + TAGID_DETAILS* = 221 + TAGID_SUMMARY* = 222 + TAGID_COUNT* = 223 + TAGID_LAST_PREDEFINED* = 10000 + ELEMENT_TAG_ID_Max* = 0x7fffffff + SELECTION_TYPE_None* = 0 + SELECTION_TYPE_Caret* = 1 + SELECTION_TYPE_Text* = 2 + SELECTION_TYPE_Control* = 3 + SELECTION_TYPE_Max* = 0x7fffffff + SAVE_SEGMENTS_NoIE4SelectionCompat* = 0x1 + SAVE_SEGMENTS_FLAGS_Max* = 0x7fffffff + CARET_DIRECTION_INDETERMINATE* = 0 + CARET_DIRECTION_SAME* = 1 + CARET_DIRECTION_BACKWARD* = 2 + CARET_DIRECTION_FORWARD* = 3 + CARET_DIRECTION_Max* = 0x7fffffff + LINE_DIRECTION_RightToLeft* = 1 + LINE_DIRECTION_LeftToRight* = 2 + LINE_DIRECTION_Max* = 0x7fffffff + HT_OPT_AllowAfterEOL* = 0x1 + HT_OPTIONS_Max* = 0x7fffffff + HT_RESULTS_Glyph* = 0x1 + HT_RESULTS_Max* = 0x7fffffff + DISPLAY_MOVEUNIT_PreviousLine* = 1 + DISPLAY_MOVEUNIT_NextLine* = 2 + DISPLAY_MOVEUNIT_CurrentLineStart* = 3 + DISPLAY_MOVEUNIT_CurrentLineEnd* = 4 + DISPLAY_MOVEUNIT_TopOfWindow* = 5 + DISPLAY_MOVEUNIT_BottomOfWindow* = 6 + DISPLAY_MOVEUNIT_Max* = 0x7fffffff + DISPLAY_GRAVITY_PreviousLine* = 1 + DISPLAY_GRAVITY_NextLine* = 2 + DISPLAY_GRAVITY_Max* = 0x7fffffff + DISPLAY_BREAK_None* = 0x0 + DISPLAY_BREAK_Block* = 0x1 + DISPLAY_BREAK_Break* = 0x2 + DISPLAY_BREAK_Max* = 0x7fffffff + COORD_SYSTEM_GLOBAL* = 0 + COORD_SYSTEM_PARENT* = 1 + COORD_SYSTEM_CONTAINER* = 2 + COORD_SYSTEM_CONTENT* = 3 + COORD_SYSTEM_FRAME* = 4 + COORD_SYSTEM_CLIENT* = 5 + COORD_SYSTEM_Max* = 0x7fffffff + DCML_INFORMATIONAL* = 0x0 + DCML_WARNING* = 0x1 + DCML_ERROR* = 0x2 + DEV_CONSOLE_MESSAGE_LEVEL_Max* = 0x7fffffff + DEP_CAPTURING_PHASE* = 0x1 + DEP_AT_TARGET* = 0x2 + DEP_BUBBLING_PHASE* = 0x3 + DOM_EVENT_PHASE_Max* = 0x7fffffff + STT_TIMEOUT* = 0x0 + STT_INTERVAL* = 0x1 + STT_IMMEDIATE* = 0x2 + STT_ANIMATION_FRAME* = 0x3 + SCRIPT_TIMER_TYPE_Max* = 0x7fffffff + HTMLPAINTER_OPAQUE* = 0x1 + HTMLPAINTER_TRANSPARENT* = 0x2 + HTMLPAINTER_ALPHA* = 0x4 + HTMLPAINTER_COMPLEX* = 0x8 + HTMLPAINTER_OVERLAY* = 0x10 + HTMLPAINTER_HITTEST* = 0x20 + HTMLPAINTER_SURFACE* = 0x100 + HTMLPAINTER_3DSURFACE* = 0x200 + HTMLPAINTER_NOBAND* = 0x400 + HTMLPAINTER_NODC* = 0x1000 + HTMLPAINTER_NOPHYSICALCLIP* = 0x2000 + HTMLPAINTER_NOSAVEDC* = 0x4000 + HTMLPAINTER_SUPPORTS_XFORM* = 0x8000 + HTMLPAINTER_EXPAND* = 0x10000 + HTMLPAINTER_NOSCROLLBITS* = 0x20000 + HTML_PAINTER_Max* = 0x7fffffff + HTMLPAINT_ZORDER_NONE* = 0 + HTMLPAINT_ZORDER_REPLACE_ALL* = 1 + HTMLPAINT_ZORDER_REPLACE_CONTENT* = 2 + HTMLPAINT_ZORDER_REPLACE_BACKGROUND* = 3 + HTMLPAINT_ZORDER_BELOW_CONTENT* = 4 + HTMLPAINT_ZORDER_BELOW_FLOW* = 5 + HTMLPAINT_ZORDER_ABOVE_FLOW* = 6 + HTMLPAINT_ZORDER_ABOVE_CONTENT* = 7 + HTMLPAINT_ZORDER_WINDOW_TOP* = 8 + HTML_PAINT_ZORDER_Max* = 0x7fffffff + HTMLPAINT_DRAW_UPDATEREGION* = 0x1 + HTMLPAINT_DRAW_USE_XFORM* = 0x2 + HTML_PAINT_DRAW_FLAGS_Max* = 0x7fffffff + HTMLPAINT_EVENT_TARGET* = 0x1 + HTMLPAINT_EVENT_SETCURSOR* = 0x2 + HTML_PAINT_EVENT_FLAGS_Max* = 0x7fffffff + HTMLPAINT_DRAWINFO_VIEWPORT* = 0x1 + HTMLPAINT_DRAWINFO_UPDATEREGION* = 0x2 + HTMLPAINT_DRAWINFO_XFORM* = 0x4 + HTML_PAINT_DRAW_INFO_FLAGS_Max* = 0x7fffffff + hTMLDlgFlagNo* = 0 + hTMLDlgFlagOff* = 0 + hTMLDlgFlag0* = 0 + hTMLDlgFlagYes* = 1 + hTMLDlgFlagOn* = 1 + hTMLDlgFlag1* = 1 + hTMLDlgFlagNotSet* = -1 + HTMLDlgFlag_Max* = 0x7fffffff + hTMLDlgBorderThin* = 0 + hTMLDlgBorderThick* = 0x40000 + HTMLDlgBorder_Max* = 0x7fffffff + hTMLDlgEdgeSunken* = 0 + hTMLDlgEdgeRaised* = 16 + HTMLDlgEdge_Max* = 0x7fffffff + hTMLDlgCenterNo* = 0 + hTMLDlgCenterOff* = 0 + hTMLDlgCenter0* = 0 + hTMLDlgCenterYes* = 1 + hTMLDlgCenterOn* = 1 + hTMLDlgCenter1* = 1 + hTMLDlgCenterParent* = 1 + hTMLDlgCenterDesktop* = 2 + HTMLDlgCenter_Max* = 0x7fffffff + hTMLAppFlagNo* = 0 + hTMLAppFlagOff* = 0 + hTMLAppFlag0* = 0 + hTMLAppFlagYes* = 1 + hTMLAppFlagOn* = 1 + hTMLAppFlag1* = 1 + HTMLAppFlag_Max* = 0x7fffffff + hTMLMinimizeFlagNo* = 0 + hTMLMinimizeFlagYes* = 0x20000 + HTMLMinimizeFlag_Max* = 0x7fffffff + hTMLMaximizeFlagNo* = 0 + hTMLMaximizeFlagYes* = 0x10000 + HTMLMaximizeFlag_Max* = 0x7fffffff + hTMLCaptionFlagNo* = 0 + hTMLCaptionFlagYes* = 0xc00000 + HTMLCaptionFlag_Max* = 0x7fffffff + hTMLSysMenuFlagNo* = 0 + hTMLSysMenuFlagYes* = 0x80000 + HTMLSysMenuFlag_Max* = 0x7fffffff + hTMLBorderNone* = 0 + hTMLBorderThick* = 0x40000 + hTMLBorderDialog* = 0x400000 + hTMLBorderThin* = 0x800000 + HTMLBorder_Max* = 0x7fffffff + hTMLBorderStyleNormal* = 0 + hTMLBorderStyleRaised* = 0x100 + hTMLBorderStyleSunken* = 0x200 + hTMLBorderStylecombined* = 0x300 + hTMLBorderStyleStatic* = 0x20000 + HTMLBorderStyle_Max* = 0x7fffffff + hTMLWindowStateNormal* = 1 + hTMLWindowStateMaximize* = 3 + hTMLWindowStateMinimize* = 6 + HTMLWindowState_Max* = 0x7fffffff + BEHAVIOREVENT_FIRST* = 0 + BEHAVIOREVENT_CONTENTREADY* = 0 + BEHAVIOREVENT_DOCUMENTREADY* = 1 + BEHAVIOREVENT_APPLYSTYLE* = 2 + BEHAVIOREVENT_DOCUMENTCONTEXTCHANGE* = 3 + BEHAVIOREVENT_CONTENTSAVE* = 4 + BEHAVIOREVENT_LAST* = 4 + BEHAVIOR_EVENT_Max* = 0x7fffffff + BEHAVIOREVENTFLAGS_BUBBLE* = 1 + BEHAVIOREVENTFLAGS_STANDARDADDITIVE* = 2 + BEHAVIOR_EVENT_FLAGS_Max* = 0x7fffffff + BEHAVIORRENDERINFO_BEFOREBACKGROUND* = 0x1 + BEHAVIORRENDERINFO_AFTERBACKGROUND* = 0x2 + BEHAVIORRENDERINFO_BEFORECONTENT* = 0x4 + BEHAVIORRENDERINFO_AFTERCONTENT* = 0x8 + BEHAVIORRENDERINFO_AFTERFOREGROUND* = 0x20 + BEHAVIORRENDERINFO_ABOVECONTENT* = 0x28 + BEHAVIORRENDERINFO_ALLLAYERS* = 0xff + BEHAVIORRENDERINFO_DISABLEBACKGROUND* = 0x100 + BEHAVIORRENDERINFO_DISABLENEGATIVEZ* = 0x200 + BEHAVIORRENDERINFO_DISABLECONTENT* = 0x400 + BEHAVIORRENDERINFO_DISABLEPOSITIVEZ* = 0x800 + BEHAVIORRENDERINFO_DISABLEALLLAYERS* = 0xf00 + BEHAVIORRENDERINFO_HITTESTING* = 0x1000 + BEHAVIORRENDERINFO_SURFACE* = 0x100000 + BEHAVIORRENDERINFO_3DSURFACE* = 0x200000 + BEHAVIOR_RENDER_INFO_Max* = 0x7fffffff + BEHAVIOR_FIRSTRELATION* = 0 + BEHAVIOR_SAMEELEMENT* = 0 + BEHAVIOR_PARENT* = 1 + BEHAVIOR_CHILD* = 2 + BEHAVIOR_SIBLING* = 3 + BEHAVIOR_LASTRELATION* = 3 + BEHAVIOR_RELATION_Max* = 0x7fffffff + BEHAVIORLAYOUTINFO_FULLDELEGATION* = 0x1 + BEHAVIORLAYOUTINFO_MODIFYNATURAL* = 0x2 + BEHAVIORLAYOUTINFO_MAPSIZE* = 0x4 + BEHAVIOR_LAYOUT_INFO_Max* = 0x7fffffff + BEHAVIORLAYOUTMODE_NATURAL* = 0x1 + BEHAVIORLAYOUTMODE_MINWIDTH* = 0x2 + BEHAVIORLAYOUTMODE_MAXWIDTH* = 0x4 + BEHAVIORLAYOUTMODE_MEDIA_RESOLUTION* = 0x4000 + BEHAVIORLAYOUTMODE_FINAL_PERCENT* = 0x8000 + BEHAVIOR_LAYOUT_MODE_Max* = 0x7fffffff + ELEMENTDESCRIPTORFLAGS_LITERAL* = 1 + ELEMENTDESCRIPTORFLAGS_NESTED_LITERAL* = 2 + ELEMENTDESCRIPTOR_FLAGS_Max* = 0x7fffffff + ELEMENTNAMESPACEFLAGS_ALLOWANYTAG* = 0x1 + ELEMENTNAMESPACEFLAGS_QUERYFORUNKNOWNTAGS* = 0x2 + ELEMENTNAMESPACE_FLAGS_Max* = 0x7fffffff + VIEW_OBJECT_ALPHA_MODE_IGNORE* = 0 + VIEW_OBJECT_ALPHA_MODE_PREMULTIPLIED* = 1 + VIEW_OBJECT_ALPHA_MODE_Max* = 0x7fffffff + VIEW_OBJECT_COMPOSITION_MODE_LEGACY* = 0 + VIEW_OBJECT_COMPOSITION_MODE_SURFACEPRESENTER* = 1 + VIEW_OBJECT_COMPOSITION_MODE_Max* = 0x7fffffff + IID_ICSSFilterSite* = DEFINE_GUID("3050f3ed-98b5-11cf-bb82-00aa00bdce0b") + IID_ICSSFilter* = DEFINE_GUID("3050f3ec-98b5-11cf-bb82-00aa00bdce0b") + IID_ISecureUrlHost* = DEFINE_GUID("c81984c4-74c8-11d2-baa9-00c04fc2040e") + IID_IMarkupServices* = DEFINE_GUID("3050f4a0-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupServices2* = DEFINE_GUID("3050f682-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupContainer* = DEFINE_GUID("3050f5f9-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupContainer2* = DEFINE_GUID("3050f648-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLChangePlayback* = DEFINE_GUID("3050f6e0-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupPointer* = DEFINE_GUID("3050f49f-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupPointer2* = DEFINE_GUID("3050f675-98b5-11cf-bb82-00aa00bdce0b") + IID_IMarkupTextFrags* = DEFINE_GUID("3050f5fa-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLChangeLog* = DEFINE_GUID("3050f649-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLChangeSink* = DEFINE_GUID("3050f64a-98b5-11cf-bb82-00aa00bdce0b") + IID_IXMLGenericParse* = DEFINE_GUID("e4e23071-4d07-11d2-ae76-0080c73bc199") + IID_IHTMLEditHost* = DEFINE_GUID("3050f6a0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEditHost2* = DEFINE_GUID("3050f848-98b5-11cf-bb82-00aa00bdce0d") + IID_ISegment* = DEFINE_GUID("3050f683-98b5-11cf-bb82-00aa00bdce0b") + IID_ISegmentListIterator* = DEFINE_GUID("3050f692-98b5-11cf-bb82-00aa00bdce0b") + IID_ISegmentList* = DEFINE_GUID("3050f605-98b5-11cf-bb82-00aa00bdce0b") + IID_ISequenceNumber* = DEFINE_GUID("3050f6c1-98b5-11cf-bb82-00aa00bdce0b") + IID_IIMEServices* = DEFINE_GUID("3050f6ca-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLCaret* = DEFINE_GUID("3050f604-98b5-11cf-bb82-00aa00bdce0b") + IID_IHighlightRenderingServices* = DEFINE_GUID("3050f606-98b5-11cf-bb82-00aa00bdce0b") + IID_ISelectionServicesListener* = DEFINE_GUID("3050f699-98b5-11cf-bb82-00aa00bdce0b") + IID_ISelectionServices* = DEFINE_GUID("3050f684-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementSegment* = DEFINE_GUID("3050f68f-98b5-11cf-bb82-00aa00bdce0b") + IID_IHighlightSegment* = DEFINE_GUID("3050f690-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEditDesigner* = DEFINE_GUID("3050f662-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEditServices* = DEFINE_GUID("3050f663-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLEditServices2* = DEFINE_GUID("3050f812-98b5-11cf-bb82-00aa00bdce0b") + IID_ILineInfo* = DEFINE_GUID("3050f7e2-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLComputedStyle* = DEFINE_GUID("3050f6c3-98b5-11cf-bb82-00aa00bdce0b") + IID_IDisplayPointer* = DEFINE_GUID("3050f69e-98b5-11cf-bb82-00aa00bdce0b") + IID_IDisplayServices* = DEFINE_GUID("3050f69d-98b5-11cf-bb82-00aa00bdce0b") + IID_IHtmlDlgSafeHelper* = DEFINE_GUID("3050f81a-98b5-11cf-bb82-00aa00bdce0b") + IID_IBlockFormats* = DEFINE_GUID("3050f830-98b5-11cf-bb82-00aa00bdce0b") + IID_IFontNames* = DEFINE_GUID("3050f839-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HtmlDlgSafeHelper* = DEFINE_GUID("3050f819-98b5-11cf-bb82-00aa00bdce0b") + CLSID_BlockFormats* = DEFINE_GUID("3050f831-98b5-11cf-bb82-00aa00bdce0b") + CLSID_FontNames* = DEFINE_GUID("3050f83a-98b5-11cf-bb82-00aa00bdce0b") + IID_IDeveloperConsoleMessageReceiver* = DEFINE_GUID("30510808-98b5-11cf-bb82-00aa00bdce0b") + IID_IDebugCallbackNotificationHandler* = DEFINE_GUID("30510842-98b5-11cf-bb82-00aa00bdce0b") + IID_IScriptEventHandler* = DEFINE_GUID("3051083a-98b5-11cf-bb82-00aa00bdce0b") + IID_IScriptEventHandlerSourceInfo* = DEFINE_GUID("30510841-98b5-11cf-bb82-00aa00bdce0b") + IID_IDOMEventRegistrationCallback* = DEFINE_GUID("3051083b-98b5-11cf-bb82-00aa00bdce0b") + IID_IEventTarget2* = DEFINE_GUID("30510839-98b5-11cf-bb82-00aa00bdce0b") + DIID_HTMLNamespaceEvents* = DEFINE_GUID("3050f6bd-98b5-11cf-bb82-00aa00bdce0b") + IID_HTMLNamespaceEvents* = DEFINE_GUID("3050f6bd-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLNamespace* = DEFINE_GUID("3050f6bb-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLNamespaceCollection* = DEFINE_GUID("3050f6b8-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLNamespace* = DEFINE_GUID("3050f54f-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLNamespace* = DEFINE_GUID("3050f54f-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLNamespace* = DEFINE_GUID("3050f6bc-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLNamespaceCollection* = DEFINE_GUID("3050f550-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLNamespaceCollection* = DEFINE_GUID("3050f550-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLNamespaceCollection* = DEFINE_GUID("3050f6b9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPainter* = DEFINE_GUID("3050f6a6-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPainterEventInfo* = DEFINE_GUID("3050f6df-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPainterOverlay* = DEFINE_GUID("3050f7e3-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPaintSite* = DEFINE_GUID("3050f6a7-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLIPrintCollection* = DEFINE_GUID("3050f6b5-98b5-11cf-bb82-00aa00bdce0b") + IID_IEnumPrivacyRecords* = DEFINE_GUID("3050f844-98b5-11cf-bb82-00aa00bdce0b") + IID_IWPCBlockedUrls* = DEFINE_GUID("30510413-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDOMConstructorCollection* = DEFINE_GUID("3051049c-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDialog* = DEFINE_GUID("3050f216-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDialog2* = DEFINE_GUID("3050f5e0-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLDialog3* = DEFINE_GUID("3050f388-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLModelessInit* = DEFINE_GUID("3050f5e4-98b5-11cf-bb82-00aa00bdce0b") + CLSID_ThreadDialogProcParam* = DEFINE_GUID("3050f5eb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLDialog* = DEFINE_GUID("3050f28a-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLPopup* = DEFINE_GUID("3050f666-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLPopup* = DEFINE_GUID("3050f589-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLPopup* = DEFINE_GUID("3050f589-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLPopup* = DEFINE_GUID("3050f667-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAppBehavior* = DEFINE_GUID("3050f5ca-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAppBehavior2* = DEFINE_GUID("3050f5c9-98b5-11cf-bb82-00aa00bdce0b") + IID_IHTMLAppBehavior3* = DEFINE_GUID("3050f5cd-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispHTMLAppBehavior* = DEFINE_GUID("3050f57c-98b5-11cf-bb82-00aa00bdce0b") + IID_DispHTMLAppBehavior* = DEFINE_GUID("3050f57c-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLAppBehavior* = DEFINE_GUID("3050f5cb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_OldHTMLDocument* = DEFINE_GUID("d48a6ec9-6a4a-11cf-94a7-444553540000") + CLSID_OldHTMLFormElement* = DEFINE_GUID("0d04d285-6bec-11cf-8b97-00aa00476da6") + DIID_DispIHTMLInputButtonElement* = DEFINE_GUID("3050f51e-98b5-11cf-bb82-00aa00bdce0b") + IID_DispIHTMLInputButtonElement* = DEFINE_GUID("3050f51e-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLInputButtonElement* = DEFINE_GUID("3050f2b4-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispIHTMLInputTextElement* = DEFINE_GUID("3050f520-98b5-11cf-bb82-00aa00bdce0b") + IID_DispIHTMLInputTextElement* = DEFINE_GUID("3050f520-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLInputTextElement* = DEFINE_GUID("3050f2ab-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispIHTMLInputFileElement* = DEFINE_GUID("3050f542-98b5-11cf-bb82-00aa00bdce0b") + IID_DispIHTMLInputFileElement* = DEFINE_GUID("3050f542-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLInputFileElement* = DEFINE_GUID("3050f2ae-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispIHTMLOptionButtonElement* = DEFINE_GUID("3050f509-98b5-11cf-bb82-00aa00bdce0b") + IID_DispIHTMLOptionButtonElement* = DEFINE_GUID("3050f509-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLOptionButtonElement* = DEFINE_GUID("3050f2be-98b5-11cf-bb82-00aa00bdce0b") + DIID_DispIHTMLInputImage* = DEFINE_GUID("3050f51d-98b5-11cf-bb82-00aa00bdce0b") + IID_DispIHTMLInputImage* = DEFINE_GUID("3050f51d-98b5-11cf-bb82-00aa00bdce0b") + CLSID_HTMLInputImage* = DEFINE_GUID("3050f2c4-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementNamespace* = DEFINE_GUID("3050f671-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementNamespaceTable* = DEFINE_GUID("3050f670-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementNamespaceFactory* = DEFINE_GUID("3050f672-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementNamespaceFactory2* = DEFINE_GUID("3050f805-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementNamespaceFactoryCallback* = DEFINE_GUID("3050f7fd-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehavior* = DEFINE_GUID("3050f425-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSite* = DEFINE_GUID("3050f427-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteOM* = DEFINE_GUID("3050f489-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteOM2* = DEFINE_GUID("3050f659-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorRender* = DEFINE_GUID("3050f4aa-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteRender* = DEFINE_GUID("3050f4a7-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorCategory* = DEFINE_GUID("3050f4ed-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteCategory* = DEFINE_GUID("3050f4ee-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSubmit* = DEFINE_GUID("3050f646-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorFocus* = DEFINE_GUID("3050f6b6-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorLayout* = DEFINE_GUID("3050f6ba-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorLayout2* = DEFINE_GUID("3050f846-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteLayout* = DEFINE_GUID("3050f6b7-98b5-11cf-bb82-00aa00bdce0b") + IID_IElementBehaviorSiteLayout2* = DEFINE_GUID("3050f847-98b5-11cf-bb82-00aa00bdce0b") + IID_IHostBehaviorInit* = DEFINE_GUID("3050f842-98b5-11cf-bb82-00aa00bdce0b") + IID_IViewObjectPresentSite* = DEFINE_GUID("305106e1-98b5-11cf-bb82-00aa00bdce0b") + IID_ISurfacePresenter* = DEFINE_GUID("305106e2-98b5-11cf-bb82-00aa00bdce0b") + IID_ICanvasPixelArrayData* = DEFINE_GUID("305107f9-98b5-11cf-bb82-00aa00bdce0b") + IID_IViewObjectPrint* = DEFINE_GUID("305106e3-98b5-11cf-bb82-00aa00bdce0b") + IID_IViewObjectPresentNotifySite* = DEFINE_GUID("305107fa-98b5-11cf-bb82-00aa00bdce0b") + IID_IViewObjectPresentNotify* = DEFINE_GUID("305107f8-98b5-11cf-bb82-00aa00bdce0b") + CONTEXT_MENU_DEFAULT* = 0 + CONTEXT_MENU_IMAGE* = 1 + CONTEXT_MENU_CONTROL* = 2 + CONTEXT_MENU_TABLE* = 3 + CONTEXT_MENU_TEXTSELECT* = 4 + CONTEXT_MENU_ANCHOR* = 5 + CONTEXT_MENU_UNKNOWN* = 6 + CONTEXT_MENU_IMGDYNSRC* = 7 + CONTEXT_MENU_DEBUG* = 8 + CONTEXT_MENU_VSCROLL* = 9 + CONTEXT_MENU_HSCROLL* = 10 + CONTEXT_MENU_MEDIA* = 11 + MENUEXT_SHOWDIALOG* = 0x1 + CMDID_SCRIPTSITE_URL* = 0 + CMDID_SCRIPTSITE_HTMLDLGTRUST* = 1 + CMDID_SCRIPTSITE_SECSTATE* = 2 + CMDID_SCRIPTSITE_SID* = 3 + CMDID_SCRIPTSITE_TRUSTEDDOC* = 4 + CMDID_SCRIPTSITE_SECURITY_WINDOW* = 5 + CMDID_SCRIPTSITE_NAMESPACE* = 6 + CMDID_SCRIPTSITE_IURI* = 7 + CMDID_HOSTCONTEXT_URL* = 8 + CMDID_SCRIPTSITE_ALLOWRECOVERY* = 9 + HTMLDLG_NOUI* = 0x10 + HTMLDLG_MODAL* = 0x20 + HTMLDLG_MODELESS* = 0x40 + HTMLDLG_PRINT_TEMPLATE* = 0x80 + HTMLDLG_VERIFY* = 0x100 + HTMLDLG_ALLOW_UNKNOWN_THREAD* = 0x200 + PRINT_DONTBOTHERUSER* = 0x1 + PRINT_WAITFORCOMPLETION* = 0x2 + CGID_MSHTML* = DEFINE_GUID(0xde4ba900'i32, 0x59ca, 0x11cf, [0x95'u8, 0x92, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00]) + CMDSETID_Forms3* = CGID_MSHTML + SZ_HTML_CLIENTSITE_OBJECTPARAM* = "{d4db6850-5385-11d0-89e9-00a0c90a90ac}" + CGID_DocHostCommandHandler* = DEFINE_GUID("f38bc242-b950-11d1-8918-00c04fc2c836") + DOCHOSTUIDBLCLK_DEFAULT* = 0 + DOCHOSTUIDBLCLK_SHOWPROPERTIES* = 1 + DOCHOSTUIDBLCLK_SHOWCODE* = 2 + DOCHOSTUIFLAG_DIALOG* = 0x1 + DOCHOSTUIFLAG_DISABLE_HELP_MENU* = 0x2 + DOCHOSTUIFLAG_NO3DBORDER* = 0x4 + DOCHOSTUIFLAG_SCROLL_NO* = 0x8 + DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE* = 0x10 + DOCHOSTUIFLAG_OPENNEWWIN* = 0x20 + DOCHOSTUIFLAG_DISABLE_OFFSCREEN* = 0x40 + DOCHOSTUIFLAG_FLAT_SCROLLBAR* = 0x80 + DOCHOSTUIFLAG_DIV_BLOCKDEFAULT* = 0x100 + DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY* = 0x200 + DOCHOSTUIFLAG_OVERRIDEBEHAVIORFACTORY* = 0x400 + DOCHOSTUIFLAG_CODEPAGELINKEDFONTS* = 0x800 + DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8* = 0x1000 + DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8* = 0x2000 + DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE* = 0x4000 + DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION* = 0x10000 + DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION* = 0x20000 + DOCHOSTUIFLAG_THEME* = 0x40000 + DOCHOSTUIFLAG_NOTHEME* = 0x80000 + DOCHOSTUIFLAG_NOPICS* = 0x100000 + DOCHOSTUIFLAG_NO3DOUTERBORDER* = 0x200000 + DOCHOSTUIFLAG_DISABLE_EDIT_NS_FIXUP* = 0x400000 + DOCHOSTUIFLAG_LOCAL_MACHINE_ACCESS_CHECK* = 0x800000 + DOCHOSTUIFLAG_DISABLE_UNTRUSTEDPROTOCOL* = 0x1000000 + DOCHOSTUIFLAG_HOST_NAVIGATES* = 0x2000000 + DOCHOSTUIFLAG_ENABLE_REDIRECT_NOTIFICATION* = 0x4000000 + DOCHOSTUIFLAG_USE_WINDOWLESS_SELECTCONTROL* = 0x8000000 + DOCHOSTUIFLAG_USE_WINDOWED_SELECTCONTROL* = 0x10000000 + DOCHOSTUIFLAG_ENABLE_ACTIVEX_INACTIVATE_MODE* = 0x20000000 + DOCHOSTUIFLAG_DPI_AWARE* = 0x40000000 + DOCHOSTUIFLAG_BROWSER* = DOCHOSTUIFLAG_DISABLE_HELP_MENU or DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE + DOCHOSTUITYPE_BROWSE* = 0 + DOCHOSTUITYPE_AUTHOR* = 1 + IID_IHostDialogHelper* = DEFINE_GUID("53dec138-a51e-11d2-861e-00c04fa35c89") + CLSID_HostDialogHelper* = DEFINE_GUID("429af92c-a51f-11d2-861e-00c04fa35c89") + IID_IDocHostUIHandler* = DEFINE_GUID("bd3f23c0-d43e-11cf-893b-00aa00bdce1a") + IID_IDocHostUIHandler2* = DEFINE_GUID("3050f6d0-98b5-11cf-bb82-00aa00bdce0b") + IID_ICustomDoc* = DEFINE_GUID("3050f3f0-98b5-11cf-bb82-00aa00bdce0b") + IID_IDocHostShowUI* = DEFINE_GUID("c4d244b0-d43e-11cf-893b-00aa00bdce1a") + IID_IClassFactoryEx* = DEFINE_GUID("342d1ea0-ae25-11d1-89c5-006008c3fbfc") + IID_IClassFactory3* = IID_IClassFactoryEx + IID_IHTMLOMWindowServices* = DEFINE_GUID("3050f5fc-98b5-11cf-bb82-00aa00bdce0b") + SID_SHTMLOMWindowServices* = IID_IHTMLOMWindowServices +type + SHOWHTMLDIALOGFN* = proc (hwndParent: HWND, pmk: ptr IMoniker, pvarArgIn: ptr VARIANT, pchOptions: ptr WCHAR, pvArgOut: ptr VARIANT): HRESULT {.stdcall.} + SHOWHTMLDIALOGEXFN* = proc (hwndParent: HWND, pmk: ptr IMoniker, dwDialogFlags: DWORD, pvarArgIn: ptr VARIANT, pchOptions: ptr WCHAR, pvArgOut: ptr VARIANT): HRESULT {.stdcall.} + IHTMLFramesCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLFramesCollection2Vtbl + IHTMLFramesCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + item*: proc(self: ptr IHTMLFramesCollection2, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLFramesCollection2, p: ptr LONG): HRESULT {.stdcall.} + IHTMLImgElement* {.pure.} = object + lpVtbl*: ptr IHTMLImgElementVtbl + IHTMLImgElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_isMap*: proc(self: ptr IHTMLImgElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_isMap*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_useMap*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_useMap*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_mimeType*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_fileSize*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_fileCreatedDate*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_fileModifiedDate*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_fileUpdatedDate*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_protocol*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_nameProp*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_vspace*: proc(self: ptr IHTMLImgElement, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLImgElement, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_lowsrc*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_lowsrc*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_vrml*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_vrml*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_dynsrc*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_dynsrc*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + get_complete*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLImgElement, v: LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLImgElement, v: LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.stdcall.} + put_start*: proc(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.stdcall.} + get_start*: proc(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLImageElementFactory* {.pure.} = object + lpVtbl*: ptr IHTMLImageElementFactoryVtbl + IHTMLImageElementFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IHTMLImageElementFactory, width: VARIANT, height: VARIANT, a: ptr ptr IHTMLImgElement): HRESULT {.stdcall.} + IHTMLLocation* {.pure.} = object + lpVtbl*: ptr IHTMLLocationVtbl + IHTMLLocationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_protocol*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_protocol*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_host*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_host*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_hostname*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_hostname*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_port*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_port*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_pathname*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_pathname*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_search*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_search*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + put_hash*: proc(self: ptr IHTMLLocation, v: BSTR): HRESULT {.stdcall.} + get_hash*: proc(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.stdcall.} + reload*: proc(self: ptr IHTMLLocation, flag: VARIANT_BOOL): HRESULT {.stdcall.} + replace*: proc(self: ptr IHTMLLocation, bstr: BSTR): HRESULT {.stdcall.} + assign*: proc(self: ptr IHTMLLocation, bstr: BSTR): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLLocation, string: ptr BSTR): HRESULT {.stdcall.} + IOmHistory* {.pure.} = object + lpVtbl*: ptr IOmHistoryVtbl + IOmHistoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IOmHistory, p: ptr int16): HRESULT {.stdcall.} + back*: proc(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.stdcall.} + forward*: proc(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.stdcall.} + go*: proc(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.stdcall.} + IHTMLMimeTypesCollection* {.pure.} = object + lpVtbl*: ptr IHTMLMimeTypesCollectionVtbl + IHTMLMimeTypesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLMimeTypesCollection, p: ptr LONG): HRESULT {.stdcall.} + IHTMLPluginsCollection* {.pure.} = object + lpVtbl*: ptr IHTMLPluginsCollectionVtbl + IHTMLPluginsCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLPluginsCollection, p: ptr LONG): HRESULT {.stdcall.} + refresh*: proc(self: ptr IHTMLPluginsCollection, reload: VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLOpsProfile* {.pure.} = object + lpVtbl*: ptr IHTMLOpsProfileVtbl + IHTMLOpsProfileVtbl* {.pure, inheritable.} = object of IDispatchVtbl + addRequest*: proc(self: ptr IHTMLOpsProfile, name: BSTR, reserved: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + clearRequest*: proc(self: ptr IHTMLOpsProfile): HRESULT {.stdcall.} + doRequest*: proc(self: ptr IHTMLOpsProfile, usage: VARIANT, fname: VARIANT, domain: VARIANT, path: VARIANT, expire: VARIANT, reserved: VARIANT): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLOpsProfile, name: BSTR, value: ptr BSTR): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IHTMLOpsProfile, name: BSTR, value: BSTR, prefs: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + commitChanges*: proc(self: ptr IHTMLOpsProfile, success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + addReadRequest*: proc(self: ptr IHTMLOpsProfile, name: BSTR, reserved: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + doReadRequest*: proc(self: ptr IHTMLOpsProfile, usage: VARIANT, fname: VARIANT, domain: VARIANT, path: VARIANT, expire: VARIANT, reserved: VARIANT): HRESULT {.stdcall.} + doWriteRequest*: proc(self: ptr IHTMLOpsProfile, success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IOmNavigator* {.pure.} = object + lpVtbl*: ptr IOmNavigatorVtbl + IOmNavigatorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_appCodeName*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_appName*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_appVersion*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_userAgent*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + javaEnabled*: proc(self: ptr IOmNavigator, enabled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + taintEnabled*: proc(self: ptr IOmNavigator, enabled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_mimeTypes*: proc(self: ptr IOmNavigator, p: ptr ptr IHTMLMimeTypesCollection): HRESULT {.stdcall.} + get_plugins*: proc(self: ptr IOmNavigator, p: ptr ptr IHTMLPluginsCollection): HRESULT {.stdcall.} + get_cookieEnabled*: proc(self: ptr IOmNavigator, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_opsProfile*: proc(self: ptr IOmNavigator, p: ptr ptr IHTMLOpsProfile): HRESULT {.stdcall.} + toString*: proc(self: ptr IOmNavigator, string: ptr BSTR): HRESULT {.stdcall.} + get_cpuClass*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_systemLanguage*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_browserLanguage*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_userLanguage*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_platform*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_appMinorVersion*: proc(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.stdcall.} + get_connectionSpeed*: proc(self: ptr IOmNavigator, p: ptr LONG): HRESULT {.stdcall.} + get_onLine*: proc(self: ptr IOmNavigator, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_userProfile*: proc(self: ptr IOmNavigator, p: ptr ptr IHTMLOpsProfile): HRESULT {.stdcall.} + IHTMLDocument* {.pure.} = object + lpVtbl*: ptr IHTMLDocumentVtbl + IHTMLDocumentVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Script*: proc(self: ptr IHTMLDocument, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLElementCollection* {.pure.} = object + lpVtbl*: ptr IHTMLElementCollectionVtbl + IHTMLElementCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + toString*: proc(self: ptr IHTMLElementCollection, String: ptr BSTR): HRESULT {.stdcall.} + put_length*: proc(self: ptr IHTMLElementCollection, v: LONG): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLElementCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLElementCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLElementCollection, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + tags*: proc(self: ptr IHTMLElementCollection, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLStyle* {.pure.} = object + lpVtbl*: ptr IHTMLStyleVtbl + IHTMLStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_fontFamily*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_fontFamily*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_fontStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontVariant*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_fontVariant*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontWeight*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_fontWeight*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontSize*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_fontSize*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_font*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_font*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_color*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_background*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundColor*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundColor*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundImage*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundImage*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundRepeat*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundRepeat*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundAttachment*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundAttachment*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPosition*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundPosition*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPositionX*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionX*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundPositionY*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionY*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordSpacing*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_wordSpacing*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_letterSpacing*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_letterSpacing*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textDecoration*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_textDecoration*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textDecorationNone*: proc(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationNone*: proc(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationUnderline*: proc(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationUnderline*: proc(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationOverline*: proc(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationOverline*: proc(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationLineThrough*: proc(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationLineThrough*: proc(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationBlink*: proc(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationBlink*: proc(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_verticalAlign*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_verticalAlign*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textTransform*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_textTransform*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlign*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_textAlign*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textIndent*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_textIndent*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_lineHeight*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_lineHeight*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginTop*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginTop*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginRight*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginRight*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginBottom*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginBottom*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginLeft*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginLeft*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_margin*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_margin*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_paddingTop*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingTop*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingRight*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingRight*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingBottom*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingBottom*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingLeft*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingLeft*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_padding*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_padding*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTop*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderTop*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRight*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderRight*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottom*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderBottom*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeft*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderLeft*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopColor*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderTopColor*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightColor*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderRightColor*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomColor*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomColor*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftColor*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftColor*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderWidth*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderWidth*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopWidth*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderTopWidth*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightWidth*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderRightWidth*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomWidth*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomWidth*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftWidth*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftWidth*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderTopStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRightStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderRightStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottomStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderBottomStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeftStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_borderLeftStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_styleFloat*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_styleFloat*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_clear*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_display*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_display*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_visibility*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_visibility*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleType*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyleType*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStylePosition*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_listStylePosition*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleImage*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyleImage*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyle*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyle*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_whiteSpace*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_whiteSpace*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_top*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_left*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_left*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_zIndex*: proc(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.stdcall.} + get_zIndex*: proc(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_overflow*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_overflow*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakBefore*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_pageBreakBefore*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakAfter*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_pageBreakAfter*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_cssText*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_cssText*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_pixelTop*: proc(self: ptr IHTMLStyle, v: LONG): HRESULT {.stdcall.} + get_pixelTop*: proc(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.stdcall.} + put_pixelLeft*: proc(self: ptr IHTMLStyle, v: LONG): HRESULT {.stdcall.} + get_pixelLeft*: proc(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.stdcall.} + put_pixelWidth*: proc(self: ptr IHTMLStyle, v: LONG): HRESULT {.stdcall.} + get_pixelWidth*: proc(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.stdcall.} + put_pixelHeight*: proc(self: ptr IHTMLStyle, v: LONG): HRESULT {.stdcall.} + get_pixelHeight*: proc(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.stdcall.} + put_posTop*: proc(self: ptr IHTMLStyle, v: float32): HRESULT {.stdcall.} + get_posTop*: proc(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.stdcall.} + put_posLeft*: proc(self: ptr IHTMLStyle, v: float32): HRESULT {.stdcall.} + get_posLeft*: proc(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.stdcall.} + put_posWidth*: proc(self: ptr IHTMLStyle, v: float32): HRESULT {.stdcall.} + get_posWidth*: proc(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.stdcall.} + put_posHeight*: proc(self: ptr IHTMLStyle, v: float32): HRESULT {.stdcall.} + get_posHeight*: proc(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.stdcall.} + put_cursor*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_cursor*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_clip*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_clip*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_filter*: proc(self: ptr IHTMLStyle, v: BSTR): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IHTMLStyle, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLStyle, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLStyle, String: ptr BSTR): HRESULT {.stdcall.} + IHTMLFiltersCollection* {.pure.} = object + lpVtbl*: ptr IHTMLFiltersCollectionVtbl + IHTMLFiltersCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLFiltersCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLFiltersCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLFiltersCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + IHTMLElement* {.pure.} = object + lpVtbl*: ptr IHTMLElementVtbl + IHTMLElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + setAttribute*: proc(self: ptr IHTMLElement, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLElement, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLElement, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_className*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_className*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_id*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_id*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + get_tagName*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + get_parentElement*: proc(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_style*: proc(self: ptr IHTMLElement, p: ptr ptr IHTMLStyle): HRESULT {.stdcall.} + put_onhelp*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onhelp*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onclick*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onclick*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondblclick*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_ondblclick*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeydown*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onkeydown*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeyup*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onkeyup*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeypress*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onkeypress*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseout*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onmouseout*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseover*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onmouseover*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousemove*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onmousemove*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousedown*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onmousedown*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseup*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onmouseup*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + get_document*: proc(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_title*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_title*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_language*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_language*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onselectstart*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onselectstart*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + scrollIntoView*: proc(self: ptr IHTMLElement, varargStart: VARIANT): HRESULT {.stdcall.} + contains*: proc(self: ptr IHTMLElement, pChild: ptr IHTMLElement, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_sourceIndex*: proc(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.stdcall.} + get_recordNumber*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_lang*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_lang*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + get_offsetLeft*: proc(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.stdcall.} + get_offsetTop*: proc(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.stdcall.} + get_offsetWidth*: proc(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.stdcall.} + get_offsetHeight*: proc(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.stdcall.} + get_offsetParent*: proc(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_innerHTML*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_innerHTML*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_innerText*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_innerText*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_outerHTML*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_outerHTML*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_outerText*: proc(self: ptr IHTMLElement, v: BSTR): HRESULT {.stdcall.} + get_outerText*: proc(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.stdcall.} + insertAdjacentHTML*: proc(self: ptr IHTMLElement, where: BSTR, html: BSTR): HRESULT {.stdcall.} + insertAdjacentText*: proc(self: ptr IHTMLElement, where: BSTR, text: BSTR): HRESULT {.stdcall.} + get_parentTextEdit*: proc(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_isTextEdit*: proc(self: ptr IHTMLElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + click*: proc(self: ptr IHTMLElement): HRESULT {.stdcall.} + get_filters*: proc(self: ptr IHTMLElement, p: ptr ptr IHTMLFiltersCollection): HRESULT {.stdcall.} + put_ondragstart*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_ondragstart*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLElement, String: ptr BSTR): HRESULT {.stdcall.} + put_onbeforeupdate*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeupdate*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onafterupdate*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onafterupdate*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerrorupdate*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onerrorupdate*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowexit*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onrowexit*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowenter*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onrowenter*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondatasetchanged*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_ondatasetchanged*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondataavailable*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_ondataavailable*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondatasetcomplete*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_ondatasetcomplete*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfilterchange*: proc(self: ptr IHTMLElement, v: VARIANT): HRESULT {.stdcall.} + get_onfilterchange*: proc(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.stdcall.} + get_children*: proc(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_all*: proc(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLSelectionObject* {.pure.} = object + lpVtbl*: ptr IHTMLSelectionObjectVtbl + IHTMLSelectionObjectVtbl* {.pure, inheritable.} = object of IDispatchVtbl + createRange*: proc(self: ptr IHTMLSelectionObject, range: ptr ptr IDispatch): HRESULT {.stdcall.} + empty*: proc(self: ptr IHTMLSelectionObject): HRESULT {.stdcall.} + clear*: proc(self: ptr IHTMLSelectionObject): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLSelectionObject, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleSheetsCollection* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetsCollectionVtbl + IHTMLStyleSheetsCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLStyleSheetsCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLStyleSheetsCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLStyleSheetsCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + IHTMLRuleStyle* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyleVtbl + IHTMLRuleStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_fontFamily*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_fontFamily*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_fontStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontVariant*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_fontVariant*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontWeight*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_fontWeight*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_fontSize*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_fontSize*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_font*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_font*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_color*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_background*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundColor*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundColor*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundImage*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundImage*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundRepeat*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundRepeat*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundAttachment*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundAttachment*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPosition*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_backgroundPosition*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPositionX*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionX*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundPositionY*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionY*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordSpacing*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_wordSpacing*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_letterSpacing*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_letterSpacing*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textDecoration*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_textDecoration*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textDecorationNone*: proc(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationNone*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationUnderline*: proc(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationUnderline*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationOverline*: proc(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationOverline*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationLineThrough*: proc(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationLineThrough*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_textDecorationBlink*: proc(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_textDecorationBlink*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_verticalAlign*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_verticalAlign*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textTransform*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_textTransform*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlign*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_textAlign*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textIndent*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_textIndent*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_lineHeight*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_lineHeight*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginTop*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginTop*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginRight*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginRight*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginBottom*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginBottom*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginLeft*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_marginLeft*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_margin*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_margin*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_paddingTop*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingTop*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingRight*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingRight*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingBottom*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingBottom*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingLeft*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_paddingLeft*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_padding*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_padding*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTop*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderTop*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRight*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderRight*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottom*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderBottom*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeft*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderLeft*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopColor*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderTopColor*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightColor*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderRightColor*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomColor*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomColor*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftColor*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftColor*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderWidth*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderWidth*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopWidth*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderTopWidth*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightWidth*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderRightWidth*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomWidth*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomWidth*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftWidth*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftWidth*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderTopStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRightStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderRightStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottomStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderBottomStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeftStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_borderLeftStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_styleFloat*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_styleFloat*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_clear*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_display*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_display*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_visibility*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_visibility*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleType*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyleType*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStylePosition*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_listStylePosition*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleImage*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyleImage*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyle*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_listStyle*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_whiteSpace*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_whiteSpace*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_top*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_left*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_left*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_zIndex*: proc(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.stdcall.} + get_zIndex*: proc(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_overflow*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_overflow*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakBefore*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_pageBreakBefore*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakAfter*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_pageBreakAfter*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_cssText*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_cssText*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_cursor*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_cursor*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_clip*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_clip*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_filter*: proc(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLStyleSheetRule* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRuleVtbl + IHTMLStyleSheetRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selectorText*: proc(self: ptr IHTMLStyleSheetRule, v: BSTR): HRESULT {.stdcall.} + get_selectorText*: proc(self: ptr IHTMLStyleSheetRule, p: ptr BSTR): HRESULT {.stdcall.} + get_style*: proc(self: ptr IHTMLStyleSheetRule, p: ptr ptr IHTMLRuleStyle): HRESULT {.stdcall.} + get_readOnly*: proc(self: ptr IHTMLStyleSheetRule, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLStyleSheetRulesCollection* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRulesCollectionVtbl + IHTMLStyleSheetRulesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLStyleSheetRulesCollection, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLStyleSheetRulesCollection, index: LONG, ppHTMLStyleSheetRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.stdcall.} + IHTMLStyleSheet* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetVtbl + IHTMLStyleSheetVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_title*: proc(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.stdcall.} + get_title*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + get_parentStyleSheet*: proc(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + get_owningElement*: proc(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLStyleSheet, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLStyleSheet, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_readOnly*: proc(self: ptr IHTMLStyleSheet, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_imports*: proc(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheetsCollection): HRESULT {.stdcall.} + put_href*: proc(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + get_id*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + addImport*: proc(self: ptr IHTMLStyleSheet, bstrURL: BSTR, lIndex: LONG, plIndex: ptr LONG): HRESULT {.stdcall.} + addRule*: proc(self: ptr IHTMLStyleSheet, bstrSelector: BSTR, bstrStyle: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.stdcall.} + removeImport*: proc(self: ptr IHTMLStyleSheet, lIndex: LONG): HRESULT {.stdcall.} + removeRule*: proc(self: ptr IHTMLStyleSheet, lIndex: LONG): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + put_cssText*: proc(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.stdcall.} + get_cssText*: proc(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.stdcall.} + get_rules*: proc(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.stdcall.} + IHTMLDocument2* {.pure.} = object + lpVtbl*: ptr IHTMLDocument2Vtbl + IHTMLDocument2Vtbl* {.pure, inheritable.} = object of IHTMLDocumentVtbl + get_all*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_body*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_activeElement*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_images*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_applets*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_links*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_forms*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_anchors*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + put_title*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_title*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_scripts*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + put_designMode*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_designMode*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_selection*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLSelectionObject): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_frames*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLFramesCollection2): HRESULT {.stdcall.} + get_embeds*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_plugins*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + put_alinkColor*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_alinkColor*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_fgColor*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_fgColor*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_linkColor*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_linkColor*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_vlinkColor*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_vlinkColor*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + get_referrer*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_location*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLLocation): HRESULT {.stdcall.} + get_lastModified*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_URL*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_URL*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_domain*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_domain*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_cookie*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_cookie*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_expando*: proc(self: ptr IHTMLDocument2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_expando*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_charset*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_defaultCharset*: proc(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.stdcall.} + get_defaultCharset*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_mimeType*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileSize*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileCreatedDate*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileModifiedDate*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileUpdatedDate*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_security*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_protocol*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_nameProp*: proc(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + write*: proc(self: ptr IHTMLDocument2, psarray: ptr SAFEARRAY): HRESULT {.stdcall.} + writeln*: proc(self: ptr IHTMLDocument2, psarray: ptr SAFEARRAY): HRESULT {.stdcall.} + open*: proc(self: ptr IHTMLDocument2, url: BSTR, name: VARIANT, features: VARIANT, replace: VARIANT, pomWindowResult: ptr ptr IDispatch): HRESULT {.stdcall.} + close*: proc(self: ptr IHTMLDocument2): HRESULT {.stdcall.} + clear*: proc(self: ptr IHTMLDocument2): HRESULT {.stdcall.} + queryCommandSupported*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandEnabled*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandState*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandIndeterm*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandText*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.stdcall.} + queryCommandValue*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.stdcall.} + execCommand*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + execCommandShowHelp*: proc(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + createElement*: proc(self: ptr IHTMLDocument2, eTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_onhelp*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onhelp*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onclick*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onclick*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondblclick*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_ondblclick*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeyup*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onkeyup*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeydown*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onkeydown*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeypress*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onkeypress*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseup*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onmouseup*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousedown*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onmousedown*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousemove*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onmousemove*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseout*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onmouseout*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseover*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onmouseover*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onafterupdate*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onafterupdate*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowexit*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onrowexit*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowenter*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onrowenter*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragstart*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_ondragstart*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselectstart*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onselectstart*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + elementFromPoint*: proc(self: ptr IHTMLDocument2, x: LONG, y: LONG, elementHit: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_parentWindow*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + get_styleSheets*: proc(self: ptr IHTMLDocument2, p: ptr ptr IHTMLStyleSheetsCollection): HRESULT {.stdcall.} + put_onbeforeupdate*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeupdate*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerrorupdate*: proc(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.stdcall.} + get_onerrorupdate*: proc(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLDocument2, String: ptr BSTR): HRESULT {.stdcall.} + createStyleSheet*: proc(self: ptr IHTMLDocument2, bstrHref: BSTR, lIndex: LONG, ppnewStyleSheet: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + IHTMLEventObj* {.pure.} = object + lpVtbl*: ptr IHTMLEventObjVtbl + IHTMLEventObjVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_srcElement*: proc(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_altKey*: proc(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_ctrlKey*: proc(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_shiftKey*: proc(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_returnValue*: proc(self: ptr IHTMLEventObj, v: VARIANT): HRESULT {.stdcall.} + get_returnValue*: proc(self: ptr IHTMLEventObj, p: ptr VARIANT): HRESULT {.stdcall.} + put_cancelBubble*: proc(self: ptr IHTMLEventObj, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_cancelBubble*: proc(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_fromElement*: proc(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_toElement*: proc(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_keyCode*: proc(self: ptr IHTMLEventObj, v: LONG): HRESULT {.stdcall.} + get_keyCode*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_button*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLEventObj, p: ptr BSTR): HRESULT {.stdcall.} + get_qualifier*: proc(self: ptr IHTMLEventObj, p: ptr BSTR): HRESULT {.stdcall.} + get_reason*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_x*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_y*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_clientX*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_clientY*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_offsetX*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_offsetY*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_screenX*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_screenY*: proc(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.stdcall.} + get_srcFilter*: proc(self: ptr IHTMLEventObj, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLScreen* {.pure.} = object + lpVtbl*: ptr IHTMLScreenVtbl + IHTMLScreenVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_colorDepth*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + put_bufferDepth*: proc(self: ptr IHTMLScreen, v: LONG): HRESULT {.stdcall.} + get_bufferDepth*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + put_updateInterval*: proc(self: ptr IHTMLScreen, v: LONG): HRESULT {.stdcall.} + get_updateInterval*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + get_availHeight*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + get_availWidth*: proc(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.stdcall.} + get_fontSmoothingEnabled*: proc(self: ptr IHTMLScreen, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLFormElement* {.pure.} = object + lpVtbl*: ptr IHTMLFormElementVtbl + IHTMLFormElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_action*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_action*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + put_dir*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_dir*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + put_encoding*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_encoding*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + put_method*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_method*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + get_elements*: proc(self: ptr IHTMLFormElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_target*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_target*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onsubmit*: proc(self: ptr IHTMLFormElement, v: VARIANT): HRESULT {.stdcall.} + get_onsubmit*: proc(self: ptr IHTMLFormElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreset*: proc(self: ptr IHTMLFormElement, v: VARIANT): HRESULT {.stdcall.} + get_onreset*: proc(self: ptr IHTMLFormElement, p: ptr VARIANT): HRESULT {.stdcall.} + submit*: proc(self: ptr IHTMLFormElement): HRESULT {.stdcall.} + reset*: proc(self: ptr IHTMLFormElement): HRESULT {.stdcall.} + put_length*: proc(self: ptr IHTMLFormElement, v: LONG): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLFormElement, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLFormElement, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLFormElement, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + tags*: proc(self: ptr IHTMLFormElement, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLOptionElement* {.pure.} = object + lpVtbl*: ptr IHTMLOptionElementVtbl + IHTMLOptionElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selected*: proc(self: ptr IHTMLOptionElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_selected*: proc(self: ptr IHTMLOptionElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLOptionElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLOptionElement, p: ptr BSTR): HRESULT {.stdcall.} + put_defaultSelected*: proc(self: ptr IHTMLOptionElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_defaultSelected*: proc(self: ptr IHTMLOptionElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_index*: proc(self: ptr IHTMLOptionElement, v: LONG): HRESULT {.stdcall.} + get_index*: proc(self: ptr IHTMLOptionElement, p: ptr LONG): HRESULT {.stdcall.} + put_text*: proc(self: ptr IHTMLOptionElement, v: BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLOptionElement, p: ptr BSTR): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLOptionElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + IHTMLOptionElementFactory* {.pure.} = object + lpVtbl*: ptr IHTMLOptionElementFactoryVtbl + IHTMLOptionElementFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IHTMLOptionElementFactory, text: VARIANT, value: VARIANT, defaultselected: VARIANT, selected: VARIANT, a: ptr ptr IHTMLOptionElement): HRESULT {.stdcall.} + IHTMLWindow2* {.pure.} = object + lpVtbl*: ptr IHTMLWindow2Vtbl + IHTMLWindow2Vtbl* {.pure, inheritable.} = object of IHTMLFramesCollection2Vtbl + get_frames*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLFramesCollection2): HRESULT {.stdcall.} + put_defaultStatus*: proc(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.stdcall.} + get_defaultStatus*: proc(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.stdcall.} + setTimeout*: proc(self: ptr IHTMLWindow2, expression: BSTR, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.stdcall.} + clearTimeout*: proc(self: ptr IHTMLWindow2, timerID: LONG): HRESULT {.stdcall.} + alert*: proc(self: ptr IHTMLWindow2, message: BSTR): HRESULT {.stdcall.} + confirm*: proc(self: ptr IHTMLWindow2, message: BSTR, confirmed: ptr VARIANT_BOOL): HRESULT {.stdcall.} + prompt*: proc(self: ptr IHTMLWindow2, message: BSTR, defstr: BSTR, textdata: ptr VARIANT): HRESULT {.stdcall.} + get_Image*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLImageElementFactory): HRESULT {.stdcall.} + get_location*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLLocation): HRESULT {.stdcall.} + get_history*: proc(self: ptr IHTMLWindow2, p: ptr ptr IOmHistory): HRESULT {.stdcall.} + close*: proc(self: ptr IHTMLWindow2): HRESULT {.stdcall.} + put_opener*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_opener*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + get_navigator*: proc(self: ptr IHTMLWindow2, p: ptr ptr IOmNavigator): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.stdcall.} + get_parent*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + open*: proc(self: ptr IHTMLWindow2, url: BSTR, name: BSTR, features: BSTR, replace: VARIANT_BOOL, pomWindowResult: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + get_self*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + get_window*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + navigate*: proc(self: ptr IHTMLWindow2, url: BSTR): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforeunload*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeunload*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onunload*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onunload*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onhelp*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onhelp*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onresize*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onresize*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onscroll*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_onscroll*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + get_document*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + get_event*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLEventObj): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLWindow2, p: ptr ptr IUnknown): HRESULT {.stdcall.} + showModalDialog*: proc(self: ptr IHTMLWindow2, dialog: BSTR, varArgIn: ptr VARIANT, varOptions: ptr VARIANT, varArgOut: ptr VARIANT): HRESULT {.stdcall.} + showHelp*: proc(self: ptr IHTMLWindow2, helpURL: BSTR, helpArg: VARIANT, features: BSTR): HRESULT {.stdcall.} + get_screen*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLScreen): HRESULT {.stdcall.} + get_Option*: proc(self: ptr IHTMLWindow2, p: ptr ptr IHTMLOptionElementFactory): HRESULT {.stdcall.} + focus*: proc(self: ptr IHTMLWindow2): HRESULT {.stdcall.} + get_closed*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + blur*: proc(self: ptr IHTMLWindow2): HRESULT {.stdcall.} + scroll*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + get_clientInformation*: proc(self: ptr IHTMLWindow2, p: ptr ptr IOmNavigator): HRESULT {.stdcall.} + setInterval*: proc(self: ptr IHTMLWindow2, expression: BSTR, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.stdcall.} + clearInterval*: proc(self: ptr IHTMLWindow2, timerID: LONG): HRESULT {.stdcall.} + put_offscreenBuffering*: proc(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.stdcall.} + get_offscreenBuffering*: proc(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.stdcall.} + execScript*: proc(self: ptr IHTMLWindow2, code: BSTR, language: BSTR, pvarRet: ptr VARIANT): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLWindow2, String: ptr BSTR): HRESULT {.stdcall.} + scrollBy*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + scrollTo*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + moveTo*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + moveBy*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + resizeTo*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + resizeBy*: proc(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.stdcall.} + get_external*: proc(self: ptr IHTMLWindow2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + SHOWMODELESSHTMLDIALOGFN* = proc (hwndParent: HWND, pmk: ptr IMoniker, pvarArgIn: ptr VARIANT, pvarOptions: ptr VARIANT, ppWindow: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + IEREGISTERXMLNSFN* = proc (lpszURI: LPCWSTR, clsid: GUID, fMachine: BOOL): HRESULT {.stdcall.} + IEISXMLNSREGISTEREDFN* = proc (lpszURI: LPCWSTR, pCLSID: ptr GUID): HRESULT {.stdcall.} + DXGI_SAMPLE_DESC* {.pure.} = object + Count*: UINT + Quality*: UINT + DXGI_RATIONAL* {.pure.} = object + Numerator*: UINT + Denominator*: UINT + DXGI_MODE_DESC* {.pure.} = object + Width*: UINT + Height*: UINT + RefreshRate*: DXGI_RATIONAL + Format*: DXGI_FORMAT + ScanlineOrdering*: DXGI_MODE_SCANLINE_ORDER + Scaling*: DXGI_MODE_SCALING + DXGI_GAMMA_CONTROL_CAPABILITIES* {.pure.} = object + ScaleAndOffsetSupported*: WINBOOL + MaxConvertedValue*: float32 + MinConvertedValue*: float32 + NumGammaControlPoints*: UINT + ControlPointPositions*: array[1025, float32] + DXGI_RGB* {.pure.} = object + Red*: float32 + Green*: float32 + Blue*: float32 + DXGI_GAMMA_CONTROL* {.pure.} = object + Scale*: DXGI_RGB + Offset*: DXGI_RGB + GammaCurve*: array[1025, DXGI_RGB] + HTML_PAINTER_INFO* {.pure.} = object + lFlags*: LONG + lZOrder*: LONG + iidDrawObject*: IID + rcExpand*: RECT + HTML_PAINT_XFORM* {.pure.} = object + eM11*: FLOAT + eM12*: FLOAT + eM21*: FLOAT + eM22*: FLOAT + eDx*: FLOAT + eDy*: FLOAT + HTML_PAINT_DRAW_INFO* {.pure.} = object + rcViewport*: RECT + hrgnUpdate*: HRGN + xform*: HTML_PAINT_XFORM + DOCHOSTUIINFO* {.pure.} = object + cbSize*: ULONG + dwFlags*: DWORD + dwDoubleClick*: DWORD + pchHostCss*: ptr OLECHAR + pchHostNS*: ptr OLECHAR + IDispatchEx* {.pure.} = object + lpVtbl*: ptr IDispatchExVtbl + IDispatchExVtbl* {.pure, inheritable.} = object of IDispatchVtbl + GetDispID*: proc(self: ptr IDispatchEx, bstrName: BSTR, grfdex: DWORD, pid: ptr DISPID): HRESULT {.stdcall.} + InvokeEx*: proc(self: ptr IDispatchEx, id: DISPID, lcid: LCID, wFlags: WORD, pdp: ptr DISPPARAMS, pvarRes: ptr VARIANT, pei: ptr EXCEPINFO, pspCaller: ptr IServiceProvider): HRESULT {.stdcall.} + DeleteMemberByName*: proc(self: ptr IDispatchEx, bstrName: BSTR, grfdex: DWORD): HRESULT {.stdcall.} + DeleteMemberByDispID*: proc(self: ptr IDispatchEx, id: DISPID): HRESULT {.stdcall.} + GetMemberProperties*: proc(self: ptr IDispatchEx, id: DISPID, grfdexFetch: DWORD, pgrfdex: ptr DWORD): HRESULT {.stdcall.} + GetMemberName*: proc(self: ptr IDispatchEx, id: DISPID, pbstrName: ptr BSTR): HRESULT {.stdcall.} + GetNextDispID*: proc(self: ptr IDispatchEx, grfdex: DWORD, id: DISPID, pid: ptr DISPID): HRESULT {.stdcall.} + GetNameSpaceParent*: proc(self: ptr IDispatchEx, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + IDispError* {.pure.} = object + lpVtbl*: ptr IDispErrorVtbl + IDispErrorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryErrorInfo*: proc(self: ptr IDispError, guidErrorType: GUID, ppde: ptr ptr IDispError): HRESULT {.stdcall.} + GetNext*: proc(self: ptr IDispError, ppde: ptr ptr IDispError): HRESULT {.stdcall.} + GetHresult*: proc(self: ptr IDispError, phr: ptr HRESULT): HRESULT {.stdcall.} + GetSource*: proc(self: ptr IDispError, pbstrSource: ptr BSTR): HRESULT {.stdcall.} + GetHelpInfo*: proc(self: ptr IDispError, pbstrFileName: ptr BSTR, pdwContext: ptr DWORD): HRESULT {.stdcall.} + GetDescription*: proc(self: ptr IDispError, pbstrDescription: ptr BSTR): HRESULT {.stdcall.} + IVariantChangeType* {.pure.} = object + lpVtbl*: ptr IVariantChangeTypeVtbl + IVariantChangeTypeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ChangeType*: proc(self: ptr IVariantChangeType, pvarDst: ptr VARIANT, pvarSrc: ptr VARIANT, lcid: LCID, vtNew: VARTYPE): HRESULT {.stdcall.} + IObjectIdentity* {.pure.} = object + lpVtbl*: ptr IObjectIdentityVtbl + IObjectIdentityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsEqualObject*: proc(self: ptr IObjectIdentity, punk: ptr IUnknown): HRESULT {.stdcall.} + ICanHandleException* {.pure.} = object + lpVtbl*: ptr ICanHandleExceptionVtbl + ICanHandleExceptionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CanHandleException*: proc(self: ptr ICanHandleException, pExcepInfo: ptr EXCEPINFO, pvar: ptr VARIANT): HRESULT {.stdcall.} + IProvideRuntimeContext* {.pure.} = object + lpVtbl*: ptr IProvideRuntimeContextVtbl + IProvideRuntimeContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentSourceContext*: proc(self: ptr IProvideRuntimeContext, pdwContext: ptr DWORD_PTR, pfExecutingGlobalCode: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IIE70DispatchEx* {.pure.} = object + lpVtbl*: ptr IIE70DispatchExVtbl + IIE70DispatchExVtbl* {.pure, inheritable.} = object of IDispatchExVtbl + IIE80DispatchEx* {.pure.} = object + lpVtbl*: ptr IIE80DispatchExVtbl + IIE80DispatchExVtbl* {.pure, inheritable.} = object of IDispatchExVtbl + IHTMLDOMConstructor* {.pure.} = object + lpVtbl*: ptr IHTMLDOMConstructorVtbl + IHTMLDOMConstructorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_constructor*: proc(self: ptr IHTMLDOMConstructor, p: ptr ptr IDispatch): HRESULT {.stdcall.} + LookupGetter*: proc(self: ptr IHTMLDOMConstructor, propname: BSTR, ppDispHandler: ptr VARIANT): HRESULT {.stdcall.} + LookupSetter*: proc(self: ptr IHTMLDOMConstructor, propname: BSTR, ppDispHandler: ptr VARIANT): HRESULT {.stdcall.} + DefineGetter*: proc(self: ptr IHTMLDOMConstructor, propname: BSTR, pdispHandler: ptr VARIANT): HRESULT {.stdcall.} + DefineSetter*: proc(self: ptr IHTMLDOMConstructor, propname: BSTR, pdispHandler: ptr VARIANT): HRESULT {.stdcall.} + IHTMLCSSStyleDeclaration* {.pure.} = object + lpVtbl*: ptr IHTMLCSSStyleDeclarationVtbl + IHTMLCSSStyleDeclarationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr LONG): HRESULT {.stdcall.} + get_parentRule*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + getPropertyValue*: proc(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyValue: ptr BSTR): HRESULT {.stdcall.} + getPropertyPriority*: proc(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyPriority: ptr BSTR): HRESULT {.stdcall.} + removeProperty*: proc(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyValue: ptr BSTR): HRESULT {.stdcall.} + setProperty*: proc(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pvarPropertyValue: ptr VARIANT, pvarPropertyPriority: ptr VARIANT): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLCSSStyleDeclaration, index: LONG, pbstrPropertyName: ptr BSTR): HRESULT {.stdcall.} + put_fontFamily*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fontFamily*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fontStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fontStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fontVariant*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fontVariant*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fontWeight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fontWeight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fontSize*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_fontSize*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_font*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_font*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_color*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_background*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_backgroundColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundImage*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundImage*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundRepeat*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundRepeat*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundAttachment*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundAttachment*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPosition*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundPosition*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundPositionX*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionX*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_backgroundPositionY*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_backgroundPositionY*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_wordSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_letterSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_letterSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_textDecoration*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textDecoration*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_verticalAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_verticalAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_textTransform*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textTransform*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textIndent*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_textIndent*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_lineHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_lineHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginTop*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_marginTop*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginRight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_marginRight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_marginBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_marginLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_margin*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_margin*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_paddingTop*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_paddingTop*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingRight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_paddingRight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_paddingBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_paddingLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_paddingLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_padding*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_padding*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTop*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderTop*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderRight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderTopColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderRightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderTopWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRightWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderRightWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderBottomWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderBottomWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderLeftWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_borderLeftWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderTopStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderRightStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderRightStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottomStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderBottomStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderLeftStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderLeftStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_styleFloat*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_styleFloat*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_clear*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_display*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_display*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_visibility*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_visibility*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleType*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_listStyleType*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_listStylePosition*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_listStylePosition*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyleImage*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_listStyleImage*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_listStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_listStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_whiteSpace*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_whiteSpace*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_top*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_left*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_left*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_zIndex*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_zIndex*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_overflow*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_overflow*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakBefore*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_pageBreakBefore*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_pageBreakAfter*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_pageBreakAfter*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_cssText*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_cssText*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_cursor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_cursor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_clip*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_clip*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_filter*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_tableLayout*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_tableLayout*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderCollapse*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderCollapse*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_direction*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_behavior*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_behavior*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_position*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_unicodeBidi*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_unicodeBidi*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_bottom*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_bottom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_right*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_right*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_imeMode*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_imeMode*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_rubyAlign*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyPosition*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_rubyPosition*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyOverhang*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_rubyOverhang*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridChar*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridChar*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridLine*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridLine*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridMode*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_layoutGridMode*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridType*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_layoutGridType*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGrid*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_layoutGrid*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textAutospace*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textAutospace*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_wordBreak*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_wordBreak*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_lineBreak*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_lineBreak*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustify*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textJustify*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustifyTrim*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textJustifyTrim*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashida*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_textKashida*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_overflowX*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_overflowX*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_overflowY*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_overflowY*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_accelerator*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_accelerator*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutFlow*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_layoutFlow*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_zoom*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_zoom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordWrap*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_wordWrap*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textUnderlinePosition*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textUnderlinePosition*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_scrollbarBaseColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarBaseColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarFaceColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarFaceColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbar3dLightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbar3dLightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarShadowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarShadowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarHighlightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarHighlightColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarDarkShadowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarDarkShadowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarArrowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarArrowColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarTrackColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarTrackColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_writingMode*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_writingMode*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlignLast*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textAlignLast*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashidaSpace*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_textKashidaSpace*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_textOverflow*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textOverflow*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_minHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_minHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_msInterpolationMode*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_msInterpolationMode*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_maxHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_maxHeight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_minWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_minWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_maxWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_maxWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_content*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_content*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_captionSide*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_captionSide*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_counterIncrement*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_counterIncrement*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_counterReset*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_counterReset*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_outline*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_outline*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_outlineWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_outlineStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_outlineStyle*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_outlineColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_boxSizing*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_boxSizing*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderSpacing*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_orphans*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_orphans*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_widows*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_widows*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_pageBreakInside*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_pageBreakInside*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_emptyCells*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_emptyCells*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_msBlockProgression*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_msBlockProgression*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_quotes*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_quotes*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_alignmentBaseline*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_alignmentBaseline*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_baselineShift*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_baselineShift*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_dominantBaseline*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_dominantBaseline*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fontSizeAdjust*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_fontSizeAdjust*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_fontStretch*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fontStretch*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_opacity*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_opacity*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_clipPath*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_clipPath*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_clipRule*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_clipRule*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fill*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fill*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_fillOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_fillOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_fillRule*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_fillRule*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_kerning*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_kerning*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_marker*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_marker*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_markerEnd*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_markerEnd*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_markerMid*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_markerMid*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_markerStart*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_markerStart*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_mask*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_mask*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_pointerEvents*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_pointerEvents*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_stopColor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_stopColor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_stopOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_stopOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_stroke*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_stroke*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_strokeDasharray*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_strokeDasharray*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_strokeDashoffset*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_strokeDashoffset*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_strokeLinecap*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_strokeLinecap*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_strokeLinejoin*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_strokeLinejoin*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_strokeMiterlimit*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_strokeMiterlimit*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_strokeOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_strokeOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_strokeWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_strokeWidth*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_textAnchor*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_textAnchor*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_glyphOrientationHorizontal*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_glyphOrientationHorizontal*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_glyphOrientationVertical*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_glyphOrientationVertical*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopLeftRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderTopLeftRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderTopRightRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderTopRightRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottomRightRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderBottomRightRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_borderBottomLeftRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_borderBottomLeftRadius*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_clipTop*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_clipTop*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_clipRight*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_clipRight*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + get_clipBottom*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_clipLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.stdcall.} + get_clipLeft*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.stdcall.} + put_cssFloat*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_cssFloat*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundClip*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundClip*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_backgroundSize*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_backgroundSize*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_boxShadow*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_boxShadow*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransform*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_msTransform*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransformOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.stdcall.} + get_msTransformOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLCSSStyleDeclaration2* {.pure.} = object + lpVtbl*: ptr IHTMLCSSStyleDeclaration2Vtbl + IHTMLCSSStyleDeclaration2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_msScrollChaining*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollChaining*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZooming*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZooming*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomSnapType*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZoomSnapType*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollRails*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollRails*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomChaining*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZoomChaining*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollSnapType*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollSnapType*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomLimit*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZoomLimit*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomSnap*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZoomSnap*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomSnapPoints*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msContentZoomSnapPoints*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msContentZoomLimitMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msContentZoomLimitMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msContentZoomLimitMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msContentZoomLimitMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollSnapX*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollSnapX*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollSnapY*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollSnapY*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollSnapPointsX*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollSnapPointsX*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollSnapPointsY*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollSnapPointsY*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msGridColumn*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msGridColumn*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msGridColumnAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msGridColumnAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msGridColumns*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msGridColumns*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msGridColumnSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msGridColumnSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msGridRow*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msGridRow*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msGridRowAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msGridRowAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msGridRows*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msGridRows*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msGridRowSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msGridRowSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msWrapThrough*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msWrapThrough*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msWrapMargin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msWrapMargin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msWrapFlow*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msWrapFlow*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationName*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationName*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationPlayState*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationPlayState*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationIterationCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationIterationCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimation*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimation*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msAnimationFillMode*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msAnimationFillMode*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_colorInterpolationFilters*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_colorInterpolationFilters*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columnCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_columnCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_columnWidth*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_columnWidth*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_columnGap*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_columnGap*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_columnFill*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_columnFill*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columnSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_columnSpan*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columns*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_columns*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columnRule*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_columnRule*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columnRuleColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_columnRuleColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_columnRuleStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_columnRuleStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_columnRuleWidth*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_columnRuleWidth*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_breakBefore*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_breakBefore*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_breakAfter*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_breakAfter*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_breakInside*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_breakInside*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_floodColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_floodColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_floodOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_floodOpacity*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_lightingColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_lightingColor*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollLimitXMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msScrollLimitXMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollLimitYMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msScrollLimitYMin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollLimitXMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msScrollLimitXMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollLimitYMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msScrollLimitYMax*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msScrollLimit*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollLimit*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_textShadow*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_textShadow*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlowFrom*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlowFrom*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlowInto*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlowInto*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msHyphens*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msHyphens*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msHyphenateLimitZone*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msHyphenateLimitZone*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msHyphenateLimitChars*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msHyphenateLimitChars*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msHyphenateLimitLines*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msHyphenateLimitLines*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msHighContrastAdjust*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msHighContrastAdjust*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_enableBackground*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_enableBackground*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFontFeatureSettings*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFontFeatureSettings*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msUserSelect*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msUserSelect*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msOverflowStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msOverflowStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransformStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransformStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msBackfaceVisibility*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msBackfaceVisibility*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msPerspective*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msPerspective*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msPerspectiveOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msPerspectiveOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransitionProperty*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransitionProperty*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransitionDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransitionDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransitionTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransitionTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransitionDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransitionDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTransition*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTransition*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msTouchAction*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTouchAction*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msScrollTranslation*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msScrollTranslation*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlex*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlex*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexPositive*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msFlexPositive*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msFlexNegative*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msFlexNegative*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msFlexPreferredSize*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msFlexPreferredSize*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msFlexFlow*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexFlow*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexWrap*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexWrap*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexItemAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexItemAlign*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexPack*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexPack*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexLinePack*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msFlexLinePack*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_msFlexOrder*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_msFlexOrder*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_msTouchSelect*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_msTouchSelect*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transform*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transform*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transformOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transformOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transformStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transformStyle*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_backfaceVisibility*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_backfaceVisibility*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_perspective*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.stdcall.} + get_perspective*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.stdcall.} + put_perspectiveOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_perspectiveOrigin*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transitionProperty*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transitionProperty*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transitionDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transitionDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transitionTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transitionTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transitionDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transitionDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_transition*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_transition*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_fontFeatureSettings*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_fontFeatureSettings*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationName*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationName*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationDuration*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationTimingFunction*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationDelay*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationDirection*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationPlayState*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationPlayState*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationIterationCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationIterationCount*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animation*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animation*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + put_animationFillMode*: proc(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.stdcall.} + get_animationFillMode*: proc(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleEnabled* {.pure.} = object + lpVtbl*: ptr IHTMLStyleEnabledVtbl + IHTMLStyleEnabledVtbl* {.pure, inheritable.} = object of IDispatchVtbl + msGetPropertyEnabled*: proc(self: ptr IHTMLStyleEnabled, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + msPutPropertyEnabled*: proc(self: ptr IHTMLStyleEnabled, name: BSTR, b: VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLCSSStyleDeclaration* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSStyleDeclarationVtbl + DispHTMLCSSStyleDeclarationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyle2* {.pure.} = object + lpVtbl*: ptr IHTMLStyle2Vtbl + IHTMLStyle2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_tableLayout*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_tableLayout*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_borderCollapse*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_borderCollapse*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_direction*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_behavior*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_behavior*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + setExpression*: proc(self: ptr IHTMLStyle2, propname: BSTR, expression: BSTR, language: BSTR): HRESULT {.stdcall.} + getExpression*: proc(self: ptr IHTMLStyle2, propname: BSTR, expression: ptr VARIANT): HRESULT {.stdcall.} + removeExpression*: proc(self: ptr IHTMLStyle2, propname: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_position*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_unicodeBidi*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_unicodeBidi*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_bottom*: proc(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.stdcall.} + get_bottom*: proc(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_right*: proc(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.stdcall.} + get_right*: proc(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_pixelBottom*: proc(self: ptr IHTMLStyle2, v: LONG): HRESULT {.stdcall.} + get_pixelBottom*: proc(self: ptr IHTMLStyle2, p: ptr LONG): HRESULT {.stdcall.} + put_pixelRight*: proc(self: ptr IHTMLStyle2, v: LONG): HRESULT {.stdcall.} + get_pixelRight*: proc(self: ptr IHTMLStyle2, p: ptr LONG): HRESULT {.stdcall.} + put_posBottom*: proc(self: ptr IHTMLStyle2, v: float32): HRESULT {.stdcall.} + get_posBottom*: proc(self: ptr IHTMLStyle2, p: ptr float32): HRESULT {.stdcall.} + put_posRight*: proc(self: ptr IHTMLStyle2, v: float32): HRESULT {.stdcall.} + get_posRight*: proc(self: ptr IHTMLStyle2, p: ptr float32): HRESULT {.stdcall.} + put_imeMode*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_imeMode*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyAlign*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyAlign*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyPosition*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyPosition*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyOverhang*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyOverhang*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridChar*: proc(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridChar*: proc(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridLine*: proc(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridLine*: proc(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridMode*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGridMode*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridType*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGridType*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGrid*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGrid*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_wordBreak*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_wordBreak*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_lineBreak*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_lineBreak*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustify*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_textJustify*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustifyTrim*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_textJustifyTrim*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashida*: proc(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.stdcall.} + get_textKashida*: proc(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_textAutospace*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_textAutospace*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_overflowX*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_overflowX*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_overflowY*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_overflowY*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_accelerator*: proc(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.stdcall.} + get_accelerator*: proc(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyle3* {.pure.} = object + lpVtbl*: ptr IHTMLStyle3Vtbl + IHTMLStyle3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_layoutFlow*: proc(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.stdcall.} + get_layoutFlow*: proc(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_zoom*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_zoom*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordWrap*: proc(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.stdcall.} + get_wordWrap*: proc(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textUnderlinePosition*: proc(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.stdcall.} + get_textUnderlinePosition*: proc(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_scrollbarBaseColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarBaseColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarFaceColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarFaceColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbar3dLightColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbar3dLightColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarShadowColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarShadowColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarHighlightColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarHighlightColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarDarkShadowColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarDarkShadowColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarArrowColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarArrowColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarTrackColor*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarTrackColor*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_writingMode*: proc(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.stdcall.} + get_writingMode*: proc(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlignLast*: proc(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.stdcall.} + get_textAlignLast*: proc(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashidaSpace*: proc(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.stdcall.} + get_textKashidaSpace*: proc(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLStyle4* {.pure.} = object + lpVtbl*: ptr IHTMLStyle4Vtbl + IHTMLStyle4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_textOverflow*: proc(self: ptr IHTMLStyle4, v: BSTR): HRESULT {.stdcall.} + get_textOverflow*: proc(self: ptr IHTMLStyle4, p: ptr BSTR): HRESULT {.stdcall.} + put_minHeight*: proc(self: ptr IHTMLStyle4, v: VARIANT): HRESULT {.stdcall.} + get_minHeight*: proc(self: ptr IHTMLStyle4, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLStyle5* {.pure.} = object + lpVtbl*: ptr IHTMLStyle5Vtbl + IHTMLStyle5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_msInterpolationMode*: proc(self: ptr IHTMLStyle5, v: BSTR): HRESULT {.stdcall.} + get_msInterpolationMode*: proc(self: ptr IHTMLStyle5, p: ptr BSTR): HRESULT {.stdcall.} + put_maxHeight*: proc(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.stdcall.} + get_maxHeight*: proc(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + put_minWidth*: proc(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.stdcall.} + get_minWidth*: proc(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + put_maxWidth*: proc(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.stdcall.} + get_maxWidth*: proc(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLStyle6* {.pure.} = object + lpVtbl*: ptr IHTMLStyle6Vtbl + IHTMLStyle6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_content*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_content*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_captionSide*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_captionSide*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_counterIncrement*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_counterIncrement*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_counterReset*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_counterReset*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outline*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_outline*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineWidth*: proc(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.stdcall.} + get_outlineWidth*: proc(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_outlineStyle*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_outlineStyle*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineColor*: proc(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.stdcall.} + get_outlineColor*: proc(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_boxSizing*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_boxSizing*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_borderSpacing*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_borderSpacing*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_orphans*: proc(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.stdcall.} + get_orphans*: proc(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_widows*: proc(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.stdcall.} + get_widows*: proc(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_pageBreakInside*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_pageBreakInside*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_emptyCells*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_emptyCells*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_msBlockProgression*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_msBlockProgression*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_quotes*: proc(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.stdcall.} + get_quotes*: proc(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLRuleStyle2* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyle2Vtbl + IHTMLRuleStyle2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_tableLayout*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_tableLayout*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_borderCollapse*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_borderCollapse*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_direction*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_behavior*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_behavior*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_position*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_unicodeBidi*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_unicodeBidi*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_bottom*: proc(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.stdcall.} + get_bottom*: proc(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_right*: proc(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.stdcall.} + get_right*: proc(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_pixelBottom*: proc(self: ptr IHTMLRuleStyle2, v: LONG): HRESULT {.stdcall.} + get_pixelBottom*: proc(self: ptr IHTMLRuleStyle2, p: ptr LONG): HRESULT {.stdcall.} + put_pixelRight*: proc(self: ptr IHTMLRuleStyle2, v: LONG): HRESULT {.stdcall.} + get_pixelRight*: proc(self: ptr IHTMLRuleStyle2, p: ptr LONG): HRESULT {.stdcall.} + put_posBottom*: proc(self: ptr IHTMLRuleStyle2, v: float32): HRESULT {.stdcall.} + get_posBottom*: proc(self: ptr IHTMLRuleStyle2, p: ptr float32): HRESULT {.stdcall.} + put_posRight*: proc(self: ptr IHTMLRuleStyle2, v: float32): HRESULT {.stdcall.} + get_posRight*: proc(self: ptr IHTMLRuleStyle2, p: ptr float32): HRESULT {.stdcall.} + put_imeMode*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_imeMode*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyAlign*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyAlign*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyPosition*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyPosition*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_rubyOverhang*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_rubyOverhang*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridChar*: proc(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridChar*: proc(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridLine*: proc(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.stdcall.} + get_layoutGridLine*: proc(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_layoutGridMode*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGridMode*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGridType*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGridType*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_layoutGrid*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_layoutGrid*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textAutospace*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_textAutospace*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_wordBreak*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_wordBreak*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_lineBreak*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_lineBreak*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustify*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_textJustify*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textJustifyTrim*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_textJustifyTrim*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashida*: proc(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.stdcall.} + get_textKashida*: proc(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + put_overflowX*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_overflowX*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_overflowY*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_overflowY*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + put_accelerator*: proc(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.stdcall.} + get_accelerator*: proc(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLRuleStyle3* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyle3Vtbl + IHTMLRuleStyle3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_layoutFlow*: proc(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.stdcall.} + get_layoutFlow*: proc(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_zoom*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_zoom*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_wordWrap*: proc(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.stdcall.} + get_wordWrap*: proc(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textUnderlinePosition*: proc(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.stdcall.} + get_textUnderlinePosition*: proc(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_scrollbarBaseColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarBaseColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarFaceColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarFaceColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbar3dLightColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbar3dLightColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarShadowColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarShadowColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarHighlightColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarHighlightColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarDarkShadowColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarDarkShadowColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarArrowColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarArrowColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollbarTrackColor*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_scrollbarTrackColor*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + put_writingMode*: proc(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.stdcall.} + get_writingMode*: proc(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlignLast*: proc(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.stdcall.} + get_textAlignLast*: proc(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.stdcall.} + put_textKashidaSpace*: proc(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.stdcall.} + get_textKashidaSpace*: proc(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLRuleStyle4* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyle4Vtbl + IHTMLRuleStyle4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_textOverflow*: proc(self: ptr IHTMLRuleStyle4, v: BSTR): HRESULT {.stdcall.} + get_textOverflow*: proc(self: ptr IHTMLRuleStyle4, p: ptr BSTR): HRESULT {.stdcall.} + put_minHeight*: proc(self: ptr IHTMLRuleStyle4, v: VARIANT): HRESULT {.stdcall.} + get_minHeight*: proc(self: ptr IHTMLRuleStyle4, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLRuleStyle5* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyle5Vtbl + IHTMLRuleStyle5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_msInterpolationMode*: proc(self: ptr IHTMLRuleStyle5, v: BSTR): HRESULT {.stdcall.} + get_msInterpolationMode*: proc(self: ptr IHTMLRuleStyle5, p: ptr BSTR): HRESULT {.stdcall.} + put_maxHeight*: proc(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.stdcall.} + get_maxHeight*: proc(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + put_minWidth*: proc(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.stdcall.} + get_minWidth*: proc(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + put_maxWidth*: proc(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.stdcall.} + get_maxWidth*: proc(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLRuleStyle6* {.pure.} = object + lpVtbl*: ptr IHTMLRuleStyle6Vtbl + IHTMLRuleStyle6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_content*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_content*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_captionSide*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_captionSide*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_counterIncrement*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_counterIncrement*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_counterReset*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_counterReset*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outline*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_outline*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineWidth*: proc(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.stdcall.} + get_outlineWidth*: proc(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_outlineStyle*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_outlineStyle*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_outlineColor*: proc(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.stdcall.} + get_outlineColor*: proc(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_boxSizing*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_boxSizing*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_borderSpacing*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_borderSpacing*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_orphans*: proc(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.stdcall.} + get_orphans*: proc(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_widows*: proc(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.stdcall.} + get_widows*: proc(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.stdcall.} + put_pageBreakInside*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_pageBreakInside*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_emptyCells*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_emptyCells*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_msBlockProgression*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_msBlockProgression*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + put_quotes*: proc(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.stdcall.} + get_quotes*: proc(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLStyle* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleVtbl + DispHTMLStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLRuleStyle* {.pure.} = object + lpVtbl*: ptr DispHTMLRuleStyleVtbl + DispHTMLRuleStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLCSSRule* {.pure.} = object + lpVtbl*: ptr IHTMLCSSRuleVtbl + IHTMLCSSRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLCSSRule, p: ptr USHORT): HRESULT {.stdcall.} + put_cssText*: proc(self: ptr IHTMLCSSRule, v: BSTR): HRESULT {.stdcall.} + get_cssText*: proc(self: ptr IHTMLCSSRule, p: ptr BSTR): HRESULT {.stdcall.} + get_parentRule*: proc(self: ptr IHTMLCSSRule, p: ptr ptr IHTMLCSSRule): HRESULT {.stdcall.} + get_parentStyleSheet*: proc(self: ptr IHTMLCSSRule, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + IHTMLCSSImportRule* {.pure.} = object + lpVtbl*: ptr IHTMLCSSImportRuleVtbl + IHTMLCSSImportRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_href*: proc(self: ptr IHTMLCSSImportRule, p: ptr BSTR): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLCSSImportRule, v: VARIANT): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLCSSImportRule, p: ptr VARIANT): HRESULT {.stdcall.} + get_styleSheet*: proc(self: ptr IHTMLCSSImportRule, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + IHTMLCSSMediaRule* {.pure.} = object + lpVtbl*: ptr IHTMLCSSMediaRuleVtbl + IHTMLCSSMediaRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_media*: proc(self: ptr IHTMLCSSMediaRule, v: VARIANT): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLCSSMediaRule, p: ptr VARIANT): HRESULT {.stdcall.} + get_cssRules*: proc(self: ptr IHTMLCSSMediaRule, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.stdcall.} + insertRule*: proc(self: ptr IHTMLCSSMediaRule, bstrRule: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.stdcall.} + deleteRule*: proc(self: ptr IHTMLCSSMediaRule, lIndex: LONG): HRESULT {.stdcall.} + IHTMLCSSMediaList* {.pure.} = object + lpVtbl*: ptr IHTMLCSSMediaListVtbl + IHTMLCSSMediaListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_mediaText*: proc(self: ptr IHTMLCSSMediaList, v: BSTR): HRESULT {.stdcall.} + get_mediaText*: proc(self: ptr IHTMLCSSMediaList, p: ptr BSTR): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLCSSMediaList, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLCSSMediaList, index: LONG, pbstrMedium: ptr BSTR): HRESULT {.stdcall.} + appendMedium*: proc(self: ptr IHTMLCSSMediaList, bstrMedium: BSTR): HRESULT {.stdcall.} + deleteMedium*: proc(self: ptr IHTMLCSSMediaList, bstrMedium: BSTR): HRESULT {.stdcall.} + IHTMLCSSNamespaceRule* {.pure.} = object + lpVtbl*: ptr IHTMLCSSNamespaceRuleVtbl + IHTMLCSSNamespaceRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_namespaceURI*: proc(self: ptr IHTMLCSSNamespaceRule, p: ptr BSTR): HRESULT {.stdcall.} + get_prefix*: proc(self: ptr IHTMLCSSNamespaceRule, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLMSCSSKeyframeRule* {.pure.} = object + lpVtbl*: ptr IHTMLMSCSSKeyframeRuleVtbl + IHTMLMSCSSKeyframeRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_keyText*: proc(self: ptr IHTMLMSCSSKeyframeRule, v: BSTR): HRESULT {.stdcall.} + get_keyText*: proc(self: ptr IHTMLMSCSSKeyframeRule, p: ptr BSTR): HRESULT {.stdcall.} + get_style*: proc(self: ptr IHTMLMSCSSKeyframeRule, p: ptr ptr IHTMLRuleStyle): HRESULT {.stdcall.} + IHTMLMSCSSKeyframesRule* {.pure.} = object + lpVtbl*: ptr IHTMLMSCSSKeyframesRuleVtbl + IHTMLMSCSSKeyframesRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_name*: proc(self: ptr IHTMLMSCSSKeyframesRule, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLMSCSSKeyframesRule, p: ptr BSTR): HRESULT {.stdcall.} + get_cssRules*: proc(self: ptr IHTMLMSCSSKeyframesRule, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.stdcall.} + appendRule*: proc(self: ptr IHTMLMSCSSKeyframesRule, bstrRule: BSTR): HRESULT {.stdcall.} + deleteRule*: proc(self: ptr IHTMLMSCSSKeyframesRule, bstrKey: BSTR): HRESULT {.stdcall.} + findRule*: proc(self: ptr IHTMLMSCSSKeyframesRule, bstrKey: BSTR, ppMSKeyframeRule: ptr ptr IHTMLMSCSSKeyframeRule): HRESULT {.stdcall.} + DispHTMLCSSRule* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSRuleVtbl + DispHTMLCSSRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLCSSImportRule* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSImportRuleVtbl + DispHTMLCSSImportRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLCSSMediaRule* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSMediaRuleVtbl + DispHTMLCSSMediaRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLCSSMediaList* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSMediaListVtbl + DispHTMLCSSMediaListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLCSSNamespaceRule* {.pure.} = object + lpVtbl*: ptr DispHTMLCSSNamespaceRuleVtbl + DispHTMLCSSNamespaceRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLMSCSSKeyframeRule* {.pure.} = object + lpVtbl*: ptr DispHTMLMSCSSKeyframeRuleVtbl + DispHTMLMSCSSKeyframeRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLMSCSSKeyframesRule* {.pure.} = object + lpVtbl*: ptr DispHTMLMSCSSKeyframesRuleVtbl + DispHTMLMSCSSKeyframesRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLRenderStyle* {.pure.} = object + lpVtbl*: ptr IHTMLRenderStyleVtbl + IHTMLRenderStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_textLineThroughStyle*: proc(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.stdcall.} + get_textLineThroughStyle*: proc(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textUnderlineStyle*: proc(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.stdcall.} + get_textUnderlineStyle*: proc(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textEffect*: proc(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.stdcall.} + get_textEffect*: proc(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textColor*: proc(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.stdcall.} + get_textColor*: proc(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textBackgroundColor*: proc(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.stdcall.} + get_textBackgroundColor*: proc(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_textDecorationColor*: proc(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.stdcall.} + get_textDecorationColor*: proc(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.stdcall.} + put_renderingPriority*: proc(self: ptr IHTMLRenderStyle, v: LONG): HRESULT {.stdcall.} + get_renderingPriority*: proc(self: ptr IHTMLRenderStyle, p: ptr LONG): HRESULT {.stdcall.} + put_defaultTextSelection*: proc(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.stdcall.} + get_defaultTextSelection*: proc(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.stdcall.} + put_textDecoration*: proc(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.stdcall.} + get_textDecoration*: proc(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLRenderStyle* {.pure.} = object + lpVtbl*: ptr DispHTMLRenderStyleVtbl + DispHTMLRenderStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLCurrentStyle* {.pure.} = object + lpVtbl*: ptr IHTMLCurrentStyleVtbl + IHTMLCurrentStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_position*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_styleFloat*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_backgroundColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_fontFamily*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_fontStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_fontVariant*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_fontWeight*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_fontSize*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_backgroundImage*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_backgroundPositionX*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_backgroundPositionY*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_backgroundRepeat*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderLeftColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderTopColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderRightColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderBottomColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderTopStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderRightStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderBottomStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderLeftStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderTopWidth*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderRightWidth*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderBottomWidth*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_borderLeftWidth*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_left*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_paddingLeft*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_paddingTop*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_paddingRight*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_paddingBottom*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_textAlign*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textDecoration*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_display*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_visibility*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_zIndex*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_letterSpacing*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_lineHeight*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_textIndent*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_verticalAlign*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_backgroundAttachment*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_marginTop*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_marginRight*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_marginBottom*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_marginLeft*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_listStyleType*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_listStylePosition*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_listStyleImage*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_clipTop*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_clipRight*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_clipBottom*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_clipLeft*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_overflow*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_pageBreakBefore*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_pageBreakAfter*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_cursor*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_tableLayout*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderCollapse*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_behavior*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLCurrentStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + get_unicodeBidi*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_right*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_bottom*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_imeMode*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_rubyAlign*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_rubyPosition*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_rubyOverhang*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textAutospace*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_lineBreak*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_wordBreak*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textJustify*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textJustifyTrim*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textKashida*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_blockDirection*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_layoutGridChar*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_layoutGridLine*: proc(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.stdcall.} + get_layoutGridMode*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_layoutGridType*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderStyle*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_borderWidth*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_padding*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_margin*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_accelerator*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_overflowX*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_overflowY*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + get_textTransform*: proc(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLCurrentStyle2* {.pure.} = object + lpVtbl*: ptr IHTMLCurrentStyle2Vtbl + IHTMLCurrentStyle2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_layoutFlow*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_wordWrap*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_textUnderlinePosition*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_hasLayout*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_scrollbarBaseColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarFaceColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbar3dLightColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarShadowColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarHighlightColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarDarkShadowColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarArrowColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_scrollbarTrackColor*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_writingMode*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_zoom*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_textAlignLast*: proc(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.stdcall.} + get_textKashidaSpace*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.stdcall.} + get_isBlock*: proc(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLCurrentStyle3* {.pure.} = object + lpVtbl*: ptr IHTMLCurrentStyle3Vtbl + IHTMLCurrentStyle3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_textOverflow*: proc(self: ptr IHTMLCurrentStyle3, p: ptr BSTR): HRESULT {.stdcall.} + get_minHeight*: proc(self: ptr IHTMLCurrentStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + get_wordSpacing*: proc(self: ptr IHTMLCurrentStyle3, p: ptr VARIANT): HRESULT {.stdcall.} + get_whiteSpace*: proc(self: ptr IHTMLCurrentStyle3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLCurrentStyle4* {.pure.} = object + lpVtbl*: ptr IHTMLCurrentStyle4Vtbl + IHTMLCurrentStyle4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_msInterpolationMode*: proc(self: ptr IHTMLCurrentStyle4, p: ptr BSTR): HRESULT {.stdcall.} + get_maxHeight*: proc(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.stdcall.} + get_minWidth*: proc(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.stdcall.} + get_maxWidth*: proc(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLCurrentStyle5* {.pure.} = object + lpVtbl*: ptr IHTMLCurrentStyle5Vtbl + IHTMLCurrentStyle5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_captionSide*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_outline*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_outlineWidth*: proc(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + get_outlineStyle*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_outlineColor*: proc(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + get_boxSizing*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_borderSpacing*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_orphans*: proc(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + get_widows*: proc(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.stdcall.} + get_pageBreakInside*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_emptyCells*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_msBlockProgression*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + get_quotes*: proc(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLCurrentStyle* {.pure.} = object + lpVtbl*: ptr DispHTMLCurrentStyleVtbl + DispHTMLCurrentStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLRect* {.pure.} = object + lpVtbl*: ptr IHTMLRectVtbl + IHTMLRectVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_left*: proc(self: ptr IHTMLRect, v: LONG): HRESULT {.stdcall.} + get_left*: proc(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.stdcall.} + put_top*: proc(self: ptr IHTMLRect, v: LONG): HRESULT {.stdcall.} + get_top*: proc(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.stdcall.} + put_right*: proc(self: ptr IHTMLRect, v: LONG): HRESULT {.stdcall.} + get_right*: proc(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.stdcall.} + put_bottom*: proc(self: ptr IHTMLRect, v: LONG): HRESULT {.stdcall.} + get_bottom*: proc(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.stdcall.} + IHTMLRect2* {.pure.} = object + lpVtbl*: ptr IHTMLRect2Vtbl + IHTMLRect2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_width*: proc(self: ptr IHTMLRect2, p: ptr float32): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLRect2, p: ptr float32): HRESULT {.stdcall.} + IHTMLRectCollection* {.pure.} = object + lpVtbl*: ptr IHTMLRectCollectionVtbl + IHTMLRectCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLRectCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLRectCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLRectCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + IHTMLDOMNode* {.pure.} = object + lpVtbl*: ptr IHTMLDOMNodeVtbl + IHTMLDOMNodeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_nodeType*: proc(self: ptr IHTMLDOMNode, p: ptr LONG): HRESULT {.stdcall.} + get_parentNode*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + hasChildNodes*: proc(self: ptr IHTMLDOMNode, fChildren: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_attributes*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IDispatch): HRESULT {.stdcall.} + insertBefore*: proc(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + replaceChild*: proc(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + cloneNode*: proc(self: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, clonedNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + removeNode*: proc(self: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, removed: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + swapNode*: proc(self: ptr IHTMLDOMNode, otherNode: ptr IHTMLDOMNode, swappedNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + replaceNode*: proc(self: ptr IHTMLDOMNode, replacement: ptr IHTMLDOMNode, replaced: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + appendChild*: proc(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_nodeName*: proc(self: ptr IHTMLDOMNode, p: ptr BSTR): HRESULT {.stdcall.} + put_nodeValue*: proc(self: ptr IHTMLDOMNode, v: VARIANT): HRESULT {.stdcall.} + get_nodeValue*: proc(self: ptr IHTMLDOMNode, p: ptr VARIANT): HRESULT {.stdcall.} + get_firstChild*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_lastChild*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_previousSibling*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_nextSibling*: proc(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + IHTMLDOMNode2* {.pure.} = object + lpVtbl*: ptr IHTMLDOMNode2Vtbl + IHTMLDOMNode2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_ownerDocument*: proc(self: ptr IHTMLDOMNode2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLDOMNode3* {.pure.} = object + lpVtbl*: ptr IHTMLDOMNode3Vtbl + IHTMLDOMNode3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_prefix*: proc(self: ptr IHTMLDOMNode3, v: VARIANT): HRESULT {.stdcall.} + get_prefix*: proc(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.stdcall.} + get_localName*: proc(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.stdcall.} + get_namespaceURI*: proc(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.stdcall.} + put_textContent*: proc(self: ptr IHTMLDOMNode3, v: VARIANT): HRESULT {.stdcall.} + get_textContent*: proc(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.stdcall.} + isEqualNode*: proc(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode3, isEqual: ptr VARIANT_BOOL): HRESULT {.stdcall.} + lookupNamespaceURI*: proc(self: ptr IHTMLDOMNode3, pvarPrefix: ptr VARIANT, pvarNamespaceURI: ptr VARIANT): HRESULT {.stdcall.} + lookupPrefix*: proc(self: ptr IHTMLDOMNode3, pvarNamespaceURI: ptr VARIANT, pvarPrefix: ptr VARIANT): HRESULT {.stdcall.} + isDefaultNamespace*: proc(self: ptr IHTMLDOMNode3, pvarNamespace: ptr VARIANT, pfDefaultNamespace: ptr VARIANT_BOOL): HRESULT {.stdcall.} + appendChild*: proc(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + insertBefore*: proc(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IHTMLDOMNode3, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + replaceChild*: proc(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + isSameNode*: proc(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode3, isSame: ptr VARIANT_BOOL): HRESULT {.stdcall.} + compareDocumentPosition*: proc(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode, flags: ptr USHORT): HRESULT {.stdcall.} + isSupported*: proc(self: ptr IHTMLDOMNode3, feature: BSTR, version: VARIANT, pfisSupported: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLDOMAttribute* {.pure.} = object + lpVtbl*: ptr IHTMLDOMAttributeVtbl + IHTMLDOMAttributeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_nodeName*: proc(self: ptr IHTMLDOMAttribute, p: ptr BSTR): HRESULT {.stdcall.} + put_nodeValue*: proc(self: ptr IHTMLDOMAttribute, v: VARIANT): HRESULT {.stdcall.} + get_nodeValue*: proc(self: ptr IHTMLDOMAttribute, p: ptr VARIANT): HRESULT {.stdcall.} + get_specified*: proc(self: ptr IHTMLDOMAttribute, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLDOMAttribute2* {.pure.} = object + lpVtbl*: ptr IHTMLDOMAttribute2Vtbl + IHTMLDOMAttribute2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_name*: proc(self: ptr IHTMLDOMAttribute2, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLDOMAttribute2, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLDOMAttribute2, p: ptr BSTR): HRESULT {.stdcall.} + get_expando*: proc(self: ptr IHTMLDOMAttribute2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_nodeType*: proc(self: ptr IHTMLDOMAttribute2, p: ptr LONG): HRESULT {.stdcall.} + get_parentNode*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_firstChild*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_lastChild*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_previousSibling*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_nextSibling*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_attributes*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_ownerDocument*: proc(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + insertBefore*: proc(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + replaceChild*: proc(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IHTMLDOMAttribute2, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + appendChild*: proc(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + hasChildNodes*: proc(self: ptr IHTMLDOMAttribute2, fChildren: ptr VARIANT_BOOL): HRESULT {.stdcall.} + cloneNode*: proc(self: ptr IHTMLDOMAttribute2, fDeep: VARIANT_BOOL, clonedNode: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + IHTMLElement2* {.pure.} = object + lpVtbl*: ptr IHTMLElement2Vtbl + IHTMLElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_scopeName*: proc(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + setCapture*: proc(self: ptr IHTMLElement2, containerCapture: VARIANT_BOOL): HRESULT {.stdcall.} + releaseCapture*: proc(self: ptr IHTMLElement2): HRESULT {.stdcall.} + put_onlosecapture*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onlosecapture*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + componentFromPoint*: proc(self: ptr IHTMLElement2, x: LONG, y: LONG, component: ptr BSTR): HRESULT {.stdcall.} + doScroll*: proc(self: ptr IHTMLElement2, component: VARIANT): HRESULT {.stdcall.} + put_onscroll*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onscroll*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrag*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondrag*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragend*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondragend*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragenter*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondragenter*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragover*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondragover*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragleave*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondragleave*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrop*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_ondrop*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforecut*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforecut*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncut*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_oncut*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforecopy*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforecopy*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncopy*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_oncopy*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforepaste*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforepaste*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpaste*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onpaste*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + get_currentStyle*: proc(self: ptr IHTMLElement2, p: ptr ptr IHTMLCurrentStyle): HRESULT {.stdcall.} + put_onpropertychange*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onpropertychange*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + getClientRects*: proc(self: ptr IHTMLElement2, pRectCol: ptr ptr IHTMLRectCollection): HRESULT {.stdcall.} + getBoundingClientRect*: proc(self: ptr IHTMLElement2, pRect: ptr ptr IHTMLRect): HRESULT {.stdcall.} + setExpression*: proc(self: ptr IHTMLElement2, propname: BSTR, expression: BSTR, language: BSTR): HRESULT {.stdcall.} + getExpression*: proc(self: ptr IHTMLElement2, propname: BSTR, expression: ptr VARIANT): HRESULT {.stdcall.} + removeExpression*: proc(self: ptr IHTMLElement2, propname: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_tabIndex*: proc(self: ptr IHTMLElement2, v: int16): HRESULT {.stdcall.} + get_tabIndex*: proc(self: ptr IHTMLElement2, p: ptr int16): HRESULT {.stdcall.} + focus*: proc(self: ptr IHTMLElement2): HRESULT {.stdcall.} + put_accessKey*: proc(self: ptr IHTMLElement2, v: BSTR): HRESULT {.stdcall.} + get_accessKey*: proc(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onresize*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onresize*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + blur*: proc(self: ptr IHTMLElement2): HRESULT {.stdcall.} + addFilter*: proc(self: ptr IHTMLElement2, pUnk: ptr IUnknown): HRESULT {.stdcall.} + removeFilter*: proc(self: ptr IHTMLElement2, pUnk: ptr IUnknown): HRESULT {.stdcall.} + get_clientHeight*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + get_clientWidth*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + get_clientTop*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + get_clientLeft*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + attachEvent*: proc(self: ptr IHTMLElement2, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + detachEvent*: proc(self: ptr IHTMLElement2, event: BSTR, pDisp: ptr IDispatch): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowsdelete*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onrowsdelete*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowsinserted*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onrowsinserted*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncellchange*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_oncellchange*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_dir*: proc(self: ptr IHTMLElement2, v: BSTR): HRESULT {.stdcall.} + get_dir*: proc(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + createControlRange*: proc(self: ptr IHTMLElement2, range: ptr ptr IDispatch): HRESULT {.stdcall.} + get_scrollHeight*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + get_scrollWidth*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + put_scrollTop*: proc(self: ptr IHTMLElement2, v: LONG): HRESULT {.stdcall.} + get_scrollTop*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + put_scrollLeft*: proc(self: ptr IHTMLElement2, v: LONG): HRESULT {.stdcall.} + get_scrollLeft*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + clearAttributes*: proc(self: ptr IHTMLElement2): HRESULT {.stdcall.} + mergeAttributes*: proc(self: ptr IHTMLElement2, mergeThis: ptr IHTMLElement): HRESULT {.stdcall.} + put_oncontextmenu*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_oncontextmenu*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + insertAdjacentElement*: proc(self: ptr IHTMLElement2, where: BSTR, insertedElement: ptr IHTMLElement, inserted: ptr ptr IHTMLElement): HRESULT {.stdcall.} + applyElement*: proc(self: ptr IHTMLElement2, apply: ptr IHTMLElement, where: BSTR, applied: ptr ptr IHTMLElement): HRESULT {.stdcall.} + getAdjacentText*: proc(self: ptr IHTMLElement2, where: BSTR, text: ptr BSTR): HRESULT {.stdcall.} + replaceAdjacentText*: proc(self: ptr IHTMLElement2, where: BSTR, newText: BSTR, oldText: ptr BSTR): HRESULT {.stdcall.} + get_canHaveChildren*: proc(self: ptr IHTMLElement2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + addBehavior*: proc(self: ptr IHTMLElement2, bstrUrl: BSTR, pvarFactory: ptr VARIANT, pCookie: ptr LONG): HRESULT {.stdcall.} + removeBehavior*: proc(self: ptr IHTMLElement2, cookie: LONG, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_runtimeStyle*: proc(self: ptr IHTMLElement2, p: ptr ptr IHTMLStyle): HRESULT {.stdcall.} + get_behaviorUrns*: proc(self: ptr IHTMLElement2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_tagUrn*: proc(self: ptr IHTMLElement2, v: BSTR): HRESULT {.stdcall.} + get_tagUrn*: proc(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_onbeforeeditfocus*: proc(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeeditfocus*: proc(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.stdcall.} + get_readyStateValue*: proc(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.stdcall.} + getElementsByTagName*: proc(self: ptr IHTMLElement2, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + IHTMLDOMAttribute3* {.pure.} = object + lpVtbl*: ptr IHTMLDOMAttribute3Vtbl + IHTMLDOMAttribute3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_nodeValue*: proc(self: ptr IHTMLDOMAttribute3, v: VARIANT): HRESULT {.stdcall.} + get_nodeValue*: proc(self: ptr IHTMLDOMAttribute3, p: ptr VARIANT): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLDOMAttribute3, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLDOMAttribute3, p: ptr BSTR): HRESULT {.stdcall.} + get_specified*: proc(self: ptr IHTMLDOMAttribute3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_ownerElement*: proc(self: ptr IHTMLDOMAttribute3, p: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + IHTMLDOMAttribute4* {.pure.} = object + lpVtbl*: ptr IHTMLDOMAttribute4Vtbl + IHTMLDOMAttribute4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_nodeValue*: proc(self: ptr IHTMLDOMAttribute4, v: VARIANT): HRESULT {.stdcall.} + get_nodeValue*: proc(self: ptr IHTMLDOMAttribute4, p: ptr VARIANT): HRESULT {.stdcall.} + get_nodeName*: proc(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLDOMAttribute4, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.stdcall.} + get_firstChild*: proc(self: ptr IHTMLDOMAttribute4, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_lastChild*: proc(self: ptr IHTMLDOMAttribute4, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr IHTMLDOMAttribute4, p: ptr ptr IDispatch): HRESULT {.stdcall.} + hasAttributes*: proc(self: ptr IHTMLDOMAttribute4, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.stdcall.} + hasChildNodes*: proc(self: ptr IHTMLDOMAttribute4, fChildren: ptr VARIANT_BOOL): HRESULT {.stdcall.} + normalize*: proc(self: ptr IHTMLDOMAttribute4): HRESULT {.stdcall.} + get_specified*: proc(self: ptr IHTMLDOMAttribute4, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLDOMTextNode* {.pure.} = object + lpVtbl*: ptr IHTMLDOMTextNodeVtbl + IHTMLDOMTextNodeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_data*: proc(self: ptr IHTMLDOMTextNode, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLDOMTextNode, p: ptr BSTR): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLDOMTextNode, String: ptr BSTR): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLDOMTextNode, p: ptr LONG): HRESULT {.stdcall.} + splitText*: proc(self: ptr IHTMLDOMTextNode, offset: LONG, pRetNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + IHTMLDOMTextNode2* {.pure.} = object + lpVtbl*: ptr IHTMLDOMTextNode2Vtbl + IHTMLDOMTextNode2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + substringData*: proc(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.stdcall.} + appendData*: proc(self: ptr IHTMLDOMTextNode2, bstrstring: BSTR): HRESULT {.stdcall.} + insertData*: proc(self: ptr IHTMLDOMTextNode2, offset: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + deleteData*: proc(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG): HRESULT {.stdcall.} + replaceData*: proc(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + IHTMLDOMTextNode3* {.pure.} = object + lpVtbl*: ptr IHTMLDOMTextNode3Vtbl + IHTMLDOMTextNode3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + substringData*: proc(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.stdcall.} + insertData*: proc(self: ptr IHTMLDOMTextNode3, offset: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + deleteData*: proc(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG): HRESULT {.stdcall.} + replaceData*: proc(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + splitText*: proc(self: ptr IHTMLDOMTextNode3, offset: LONG, pRetNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_wholeText*: proc(self: ptr IHTMLDOMTextNode3, p: ptr BSTR): HRESULT {.stdcall.} + replaceWholeText*: proc(self: ptr IHTMLDOMTextNode3, bstrText: BSTR, ppRetNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + hasAttributes*: proc(self: ptr IHTMLDOMTextNode3, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.stdcall.} + normalize*: proc(self: ptr IHTMLDOMTextNode3): HRESULT {.stdcall.} + IHTMLDOMImplementation* {.pure.} = object + lpVtbl*: ptr IHTMLDOMImplementationVtbl + IHTMLDOMImplementationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + hasFeature*: proc(self: ptr IHTMLDOMImplementation, bstrfeature: BSTR, version: VARIANT, pfHasFeature: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IDOMDocumentType* {.pure.} = object + lpVtbl*: ptr IDOMDocumentTypeVtbl + IDOMDocumentTypeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_name*: proc(self: ptr IDOMDocumentType, p: ptr BSTR): HRESULT {.stdcall.} + get_entities*: proc(self: ptr IDOMDocumentType, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_notations*: proc(self: ptr IDOMDocumentType, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_publicId*: proc(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.stdcall.} + get_systemId*: proc(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.stdcall.} + get_internalSubset*: proc(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLDOMRange* {.pure.} = object + lpVtbl*: ptr IHTMLDOMRangeVtbl + IHTMLDOMRangeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_startContainer*: proc(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_startOffset*: proc(self: ptr IHTMLDOMRange, p: ptr LONG): HRESULT {.stdcall.} + get_endContainer*: proc(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_endOffset*: proc(self: ptr IHTMLDOMRange, p: ptr LONG): HRESULT {.stdcall.} + get_collapsed*: proc(self: ptr IHTMLDOMRange, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_commonAncestorContainer*: proc(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + setStart*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch, offset: LONG): HRESULT {.stdcall.} + setEnd*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch, offset: LONG): HRESULT {.stdcall.} + setStartBefore*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + setStartAfter*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + setEndBefore*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + setEndAfter*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + collapse*: proc(self: ptr IHTMLDOMRange, toStart: VARIANT_BOOL): HRESULT {.stdcall.} + selectNode*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + selectNodeContents*: proc(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.stdcall.} + compareBoundaryPoints*: proc(self: ptr IHTMLDOMRange, how: int16, sourceRange: ptr IDispatch, compareResult: ptr LONG): HRESULT {.stdcall.} + deleteContents*: proc(self: ptr IHTMLDOMRange): HRESULT {.stdcall.} + extractContents*: proc(self: ptr IHTMLDOMRange, ppDocumentFragment: ptr ptr IDispatch): HRESULT {.stdcall.} + cloneContents*: proc(self: ptr IHTMLDOMRange, ppDocumentFragment: ptr ptr IDispatch): HRESULT {.stdcall.} + insertNode*: proc(self: ptr IHTMLDOMRange, newNode: ptr IDispatch): HRESULT {.stdcall.} + surroundContents*: proc(self: ptr IHTMLDOMRange, newParent: ptr IDispatch): HRESULT {.stdcall.} + cloneRange*: proc(self: ptr IHTMLDOMRange, ppClonedRange: ptr ptr IHTMLDOMRange): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLDOMRange, pRangeString: ptr BSTR): HRESULT {.stdcall.} + detach*: proc(self: ptr IHTMLDOMRange): HRESULT {.stdcall.} + getClientRects*: proc(self: ptr IHTMLDOMRange, ppRectCol: ptr ptr IHTMLRectCollection): HRESULT {.stdcall.} + getBoundingClientRect*: proc(self: ptr IHTMLDOMRange, ppRect: ptr ptr IHTMLRect): HRESULT {.stdcall.} + IHTMLSelection* {.pure.} = object + lpVtbl*: ptr IHTMLSelectionVtbl + IHTMLSelectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_anchorNode*: proc(self: ptr IHTMLSelection, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_anchorOffset*: proc(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.stdcall.} + get_focusNode*: proc(self: ptr IHTMLSelection, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_focusOffset*: proc(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.stdcall.} + get_isCollapsed*: proc(self: ptr IHTMLSelection, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + collapse*: proc(self: ptr IHTMLSelection, parentNode: ptr IDispatch, offfset: LONG): HRESULT {.stdcall.} + collapseToStart*: proc(self: ptr IHTMLSelection): HRESULT {.stdcall.} + collapseToEnd*: proc(self: ptr IHTMLSelection): HRESULT {.stdcall.} + selectAllChildren*: proc(self: ptr IHTMLSelection, parentNode: ptr IDispatch): HRESULT {.stdcall.} + deleteFromDocument*: proc(self: ptr IHTMLSelection): HRESULT {.stdcall.} + get_rangeCount*: proc(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.stdcall.} + getRangeAt*: proc(self: ptr IHTMLSelection, index: LONG, ppRange: ptr ptr IHTMLDOMRange): HRESULT {.stdcall.} + addRange*: proc(self: ptr IHTMLSelection, range: ptr IDispatch): HRESULT {.stdcall.} + removeRange*: proc(self: ptr IHTMLSelection, range: ptr IDispatch): HRESULT {.stdcall.} + removeAllRanges*: proc(self: ptr IHTMLSelection): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLSelection, pSelectionString: ptr BSTR): HRESULT {.stdcall.} + IDOMProcessingInstruction* {.pure.} = object + lpVtbl*: ptr IDOMProcessingInstructionVtbl + IDOMProcessingInstructionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_target*: proc(self: ptr IDOMProcessingInstruction, p: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IDOMProcessingInstruction, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IDOMProcessingInstruction, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLDocument7* {.pure.} = object + lpVtbl*: ptr IHTMLDocument7Vtbl + IHTMLDocument7Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_defaultView*: proc(self: ptr IHTMLDocument7, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + createCDATASection*: proc(self: ptr IHTMLDocument7, text: BSTR, newCDATASectionNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + getSelection*: proc(self: ptr IHTMLDocument7, ppIHTMLSelection: ptr ptr IHTMLSelection): HRESULT {.stdcall.} + getElementsByTagNameNS*: proc(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrLocalName: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + createElementNS*: proc(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.stdcall.} + createAttributeNS*: proc(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrAttrName: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + put_onmsthumbnailclick*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onmsthumbnailclick*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + get_characterSet*: proc(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.stdcall.} + createElement*: proc(self: ptr IHTMLDocument7, bstrTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.stdcall.} + createAttribute*: proc(self: ptr IHTMLDocument7, bstrAttrName: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + getElementsByClassName*: proc(self: ptr IHTMLDocument7, v: BSTR, pel: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + createProcessingInstruction*: proc(self: ptr IHTMLDocument7, bstrTarget: BSTR, bstrData: BSTR, newProcessingInstruction: ptr ptr IDOMProcessingInstruction): HRESULT {.stdcall.} + adoptNode*: proc(self: ptr IHTMLDocument7, pNodeSource: ptr IHTMLDOMNode, ppNodeDest: ptr ptr IHTMLDOMNode3): HRESULT {.stdcall.} + put_onmssitemodejumplistitemremoved*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onmssitemodejumplistitemremoved*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + get_all*: proc(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_inputEncoding*: proc(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.stdcall.} + get_xmlEncoding*: proc(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.stdcall.} + put_xmlStandalone*: proc(self: ptr IHTMLDocument7, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_xmlStandalone*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_xmlVersion*: proc(self: ptr IHTMLDocument7, v: BSTR): HRESULT {.stdcall.} + get_xmlVersion*: proc(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.stdcall.} + hasAttributes*: proc(self: ptr IHTMLDocument7, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplay*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_oncanplay*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplaythrough*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_oncanplaythrough*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrag*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondrag*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragend*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondragend*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragenter*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondragenter*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragleave*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondragleave*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragover*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondragover*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrop*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondrop*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondurationchange*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ondurationchange*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onemptied*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onemptied*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onended*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onended*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oninput*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_oninput*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadeddata*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onloadeddata*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadedmetadata*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onloadedmetadata*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadstart*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onloadstart*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpause*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onpause*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplay*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onplay*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplaying*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onplaying*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onprogress*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onprogress*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onratechange*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onratechange*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreset*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onreset*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onscroll*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onscroll*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeked*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onseeked*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeking*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onseeking*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstalled*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onstalled*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsubmit*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onsubmit*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsuspend*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onsuspend*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ontimeupdate*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_ontimeupdate*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onvolumechange*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onvolumechange*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onwaiting*: proc(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.stdcall.} + get_onwaiting*: proc(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.stdcall.} + normalize*: proc(self: ptr IHTMLDocument7): HRESULT {.stdcall.} + importNode*: proc(self: ptr IHTMLDocument7, pNodeSource: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, ppNodeDest: ptr ptr IHTMLDOMNode3): HRESULT {.stdcall.} + get_parentWindow*: proc(self: ptr IHTMLDocument7, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + putref_body*: proc(self: ptr IHTMLDocument7, v: ptr IHTMLElement): HRESULT {.stdcall.} + get_body*: proc(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_head*: proc(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + IHTMLDOMImplementation2* {.pure.} = object + lpVtbl*: ptr IHTMLDOMImplementation2Vtbl + IHTMLDOMImplementation2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + createDocumentType*: proc(self: ptr IHTMLDOMImplementation2, bstrQualifiedName: BSTR, pvarPublicId: ptr VARIANT, pvarSystemId: ptr VARIANT, newDocumentType: ptr ptr IDOMDocumentType): HRESULT {.stdcall.} + createDocument*: proc(self: ptr IHTMLDOMImplementation2, pvarNS: ptr VARIANT, pvarTagName: ptr VARIANT, pDocumentType: ptr IDOMDocumentType, ppnewDocument: ptr ptr IHTMLDocument7): HRESULT {.stdcall.} + createHTMLDocument*: proc(self: ptr IHTMLDOMImplementation2, bstrTitle: BSTR, ppnewDocument: ptr ptr IHTMLDocument7): HRESULT {.stdcall.} + hasFeature*: proc(self: ptr IHTMLDOMImplementation2, bstrfeature: BSTR, version: VARIANT, pfHasFeature: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDOMAttribute* {.pure.} = object + lpVtbl*: ptr DispHTMLDOMAttributeVtbl + DispHTMLDOMAttributeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLDOMTextNode* {.pure.} = object + lpVtbl*: ptr DispHTMLDOMTextNodeVtbl + DispHTMLDOMTextNodeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLDOMImplementation* {.pure.} = object + lpVtbl*: ptr DispHTMLDOMImplementationVtbl + DispHTMLDOMImplementationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLAttributeCollection* {.pure.} = object + lpVtbl*: ptr IHTMLAttributeCollectionVtbl + IHTMLAttributeCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLAttributeCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLAttributeCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLAttributeCollection, name: ptr VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLAttributeCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLAttributeCollection2Vtbl + IHTMLAttributeCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getNamedItem*: proc(self: ptr IHTMLAttributeCollection2, bstrName: BSTR, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + setNamedItem*: proc(self: ptr IHTMLAttributeCollection2, ppNode: ptr IHTMLDOMAttribute, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + removeNamedItem*: proc(self: ptr IHTMLAttributeCollection2, bstrName: BSTR, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + IHTMLAttributeCollection3* {.pure.} = object + lpVtbl*: ptr IHTMLAttributeCollection3Vtbl + IHTMLAttributeCollection3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getNamedItem*: proc(self: ptr IHTMLAttributeCollection3, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + setNamedItem*: proc(self: ptr IHTMLAttributeCollection3, pNodeIn: ptr IHTMLDOMAttribute, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + removeNamedItem*: proc(self: ptr IHTMLAttributeCollection3, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLAttributeCollection3, index: LONG, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLAttributeCollection3, p: ptr LONG): HRESULT {.stdcall.} + IHTMLAttributeCollection4* {.pure.} = object + lpVtbl*: ptr IHTMLAttributeCollection4Vtbl + IHTMLAttributeCollection4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getNamedItemNS*: proc(self: ptr IHTMLAttributeCollection4, pvarNS: ptr VARIANT, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + setNamedItemNS*: proc(self: ptr IHTMLAttributeCollection4, pNodeIn: ptr IHTMLDOMAttribute2, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + removeNamedItemNS*: proc(self: ptr IHTMLAttributeCollection4, pvarNS: ptr VARIANT, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + getNamedItem*: proc(self: ptr IHTMLAttributeCollection4, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + setNamedItem*: proc(self: ptr IHTMLAttributeCollection4, pNodeIn: ptr IHTMLDOMAttribute2, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + removeNamedItem*: proc(self: ptr IHTMLAttributeCollection4, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLAttributeCollection4, index: LONG, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLAttributeCollection4, p: ptr LONG): HRESULT {.stdcall.} + IHTMLDOMChildrenCollection* {.pure.} = object + lpVtbl*: ptr IHTMLDOMChildrenCollectionVtbl + IHTMLDOMChildrenCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLDOMChildrenCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLDOMChildrenCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLDOMChildrenCollection, index: LONG, ppItem: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLDOMChildrenCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLDOMChildrenCollection2Vtbl + IHTMLDOMChildrenCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + item*: proc(self: ptr IHTMLDOMChildrenCollection2, index: LONG, ppItem: ptr ptr IDispatch): HRESULT {.stdcall.} + DispHTMLAttributeCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLAttributeCollectionVtbl + DispHTMLAttributeCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispStaticNodeList* {.pure.} = object + lpVtbl*: ptr DispStaticNodeListVtbl + DispStaticNodeListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispDOMChildrenCollection* {.pure.} = object + lpVtbl*: ptr DispDOMChildrenCollectionVtbl + DispDOMChildrenCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLElementEvents4* {.pure.} = object + lpVtbl*: ptr HTMLElementEvents4Vtbl + HTMLElementEvents4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLElementEvents3* {.pure.} = object + lpVtbl*: ptr HTMLElementEvents3Vtbl + HTMLElementEvents3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLElementEvents2Vtbl + HTMLElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLElementEventsVtbl + HTMLElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLElement3* {.pure.} = object + lpVtbl*: ptr IHTMLElement3Vtbl + IHTMLElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + mergeAttributes*: proc(self: ptr IHTMLElement3, mergeThis: ptr IHTMLElement, pvarFlags: ptr VARIANT): HRESULT {.stdcall.} + get_isMultiLine*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_canHaveHTML*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onlayoutcomplete*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onlayoutcomplete*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpage*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onpage*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_inflateBlock*: proc(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_inflateBlock*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onbeforedeactivate*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onbeforedeactivate*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + setActive*: proc(self: ptr IHTMLElement3): HRESULT {.stdcall.} + put_contentEditable*: proc(self: ptr IHTMLElement3, v: BSTR): HRESULT {.stdcall.} + get_contentEditable*: proc(self: ptr IHTMLElement3, p: ptr BSTR): HRESULT {.stdcall.} + get_isContentEditable*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_hideFocus*: proc(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_hideFocus*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_isDisabled*: proc(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onmove*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmove*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncontrolselect*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_oncontrolselect*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + fireEvent*: proc(self: ptr IHTMLElement3, bstrEventName: BSTR, pvarEventObject: ptr VARIANT, pfCancelled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onresizestart*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onresizestart*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onresizeend*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onresizeend*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmovestart*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmovestart*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmoveend*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmoveend*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseenter*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmouseenter*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseleave*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmouseleave*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onactivate*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_onactivate*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondeactivate*: proc(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.stdcall.} + get_ondeactivate*: proc(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.stdcall.} + dragDrop*: proc(self: ptr IHTMLElement3, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_glyphMode*: proc(self: ptr IHTMLElement3, p: ptr LONG): HRESULT {.stdcall.} + IHTMLElement4* {.pure.} = object + lpVtbl*: ptr IHTMLElement4Vtbl + IHTMLElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmousewheel*: proc(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.stdcall.} + get_onmousewheel*: proc(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.stdcall.} + normalize*: proc(self: ptr IHTMLElement4): HRESULT {.stdcall.} + getAttributeNode*: proc(self: ptr IHTMLElement4, bstrname: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + setAttributeNode*: proc(self: ptr IHTMLElement4, pattr: ptr IHTMLDOMAttribute, ppretAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + removeAttributeNode*: proc(self: ptr IHTMLElement4, pattr: ptr IHTMLDOMAttribute, ppretAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + put_onbeforeactivate*: proc(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeactivate*: proc(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocusin*: proc(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.stdcall.} + get_onfocusin*: proc(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocusout*: proc(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.stdcall.} + get_onfocusout*: proc(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.stdcall.} + IElementSelector* {.pure.} = object + lpVtbl*: ptr IElementSelectorVtbl + IElementSelectorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + querySelector*: proc(self: ptr IElementSelector, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.stdcall.} + querySelectorAll*: proc(self: ptr IElementSelector, v: BSTR, pel: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.stdcall.} + IHTMLElementRender* {.pure.} = object + lpVtbl*: ptr IHTMLElementRenderVtbl + IHTMLElementRenderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DrawToDC*: proc(self: ptr IHTMLElementRender, hDC: HDC): HRESULT {.stdcall.} + SetDocumentPrinter*: proc(self: ptr IHTMLElementRender, bstrPrinterName: BSTR, hDC: HDC): HRESULT {.stdcall.} + IHTMLUniqueName* {.pure.} = object + lpVtbl*: ptr IHTMLUniqueNameVtbl + IHTMLUniqueNameVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_uniqueNumber*: proc(self: ptr IHTMLUniqueName, p: ptr LONG): HRESULT {.stdcall.} + get_uniqueID*: proc(self: ptr IHTMLUniqueName, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLElement5* {.pure.} = object + lpVtbl*: ptr IHTMLElement5Vtbl + IHTMLElement5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getAttributeNode*: proc(self: ptr IHTMLElement5, bstrname: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + setAttributeNode*: proc(self: ptr IHTMLElement5, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + removeAttributeNode*: proc(self: ptr IHTMLElement5, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + hasAttribute*: proc(self: ptr IHTMLElement5, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_role*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_role*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaBusy*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaBusy*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaChecked*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaChecked*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaDisabled*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaDisabled*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaExpanded*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaExpanded*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaHaspopup*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaHaspopup*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaHidden*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaHidden*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaInvalid*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaInvalid*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaMultiselectable*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaMultiselectable*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaPressed*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaPressed*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaReadonly*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaReadonly*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaRequired*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaRequired*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaSecret*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaSecret*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaSelected*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaSelected*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLElement5, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IHTMLElement5, strAttributeName: BSTR, AttributeValue: VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLElement5, strAttributeName: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_attributes*: proc(self: ptr IHTMLElement5, p: ptr ptr IHTMLAttributeCollection3): HRESULT {.stdcall.} + put_ariaValuenow*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaValuenow*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaPosinset*: proc(self: ptr IHTMLElement5, v: int16): HRESULT {.stdcall.} + get_ariaPosinset*: proc(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.stdcall.} + put_ariaSetsize*: proc(self: ptr IHTMLElement5, v: int16): HRESULT {.stdcall.} + get_ariaSetsize*: proc(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.stdcall.} + put_ariaLevel*: proc(self: ptr IHTMLElement5, v: int16): HRESULT {.stdcall.} + get_ariaLevel*: proc(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.stdcall.} + put_ariaValuemin*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaValuemin*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaValuemax*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaValuemax*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaControls*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaControls*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaDescribedby*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaDescribedby*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaFlowto*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaFlowto*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaLabelledby*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaLabelledby*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaActivedescendant*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaActivedescendant*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaOwns*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaOwns*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + hasAttributes*: proc(self: ptr IHTMLElement5, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_ariaLive*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaLive*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + put_ariaRelevant*: proc(self: ptr IHTMLElement5, v: BSTR): HRESULT {.stdcall.} + get_ariaRelevant*: proc(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLElement6* {.pure.} = object + lpVtbl*: ptr IHTMLElement6Vtbl + IHTMLElement6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getAttributeNS*: proc(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + setAttributeNS*: proc(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR, pvarAttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttributeNS*: proc(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR): HRESULT {.stdcall.} + getAttributeNodeNS*: proc(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, bstrname: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + setAttributeNodeNS*: proc(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + hasAttributeNS*: proc(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLElement6, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IHTMLElement6, strAttributeName: BSTR, pvarAttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLElement6, strAttributeName: BSTR): HRESULT {.stdcall.} + getAttributeNode*: proc(self: ptr IHTMLElement6, strAttributeName: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + setAttributeNode*: proc(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + removeAttributeNode*: proc(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.stdcall.} + hasAttribute*: proc(self: ptr IHTMLElement6, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getElementsByTagNameNS*: proc(self: ptr IHTMLElement6, varNS: ptr VARIANT, bstrLocalName: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_tagName*: proc(self: ptr IHTMLElement6, p: ptr BSTR): HRESULT {.stdcall.} + get_nodeName*: proc(self: ptr IHTMLElement6, p: ptr BSTR): HRESULT {.stdcall.} + getElementsByClassName*: proc(self: ptr IHTMLElement6, v: BSTR, pel: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + msMatchesSelector*: proc(self: ptr IHTMLElement6, v: BSTR, pfMatches: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplay*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_oncanplay*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplaythrough*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_oncanplaythrough*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondurationchange*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_ondurationchange*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onemptied*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onemptied*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onended*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onended*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_oninput*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_oninput*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadeddata*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onloadeddata*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadedmetadata*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onloadedmetadata*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadstart*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onloadstart*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpause*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onpause*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplay*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onplay*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplaying*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onplaying*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onprogress*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onprogress*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onratechange*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onratechange*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreset*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onreset*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeked*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onseeked*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeking*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onseeking*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstalled*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onstalled*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsubmit*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onsubmit*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsuspend*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onsuspend*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_ontimeupdate*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_ontimeupdate*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onvolumechange*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onvolumechange*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onwaiting*: proc(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.stdcall.} + get_onwaiting*: proc(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.stdcall.} + hasAttributes*: proc(self: ptr IHTMLElement6, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLElement7* {.pure.} = object + lpVtbl*: ptr IHTMLElement7Vtbl + IHTMLElement7Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmspointerdown*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerdown*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointermove*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointermove*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerup*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerup*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerover*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerover*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerout*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerout*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointercancel*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointercancel*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerhover*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerhover*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmslostpointercapture*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmslostpointercapture*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgotpointercapture*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgotpointercapture*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturestart*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturestart*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturechange*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturechange*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgestureend*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgestureend*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturehold*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturehold*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturetap*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturetap*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturedoubletap*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturedoubletap*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsinertiastart*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsinertiastart*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + msSetPointerCapture*: proc(self: ptr IHTMLElement7, pointerId: LONG): HRESULT {.stdcall.} + msReleasePointerCapture*: proc(self: ptr IHTMLElement7, pointerId: LONG): HRESULT {.stdcall.} + put_onmstransitionstart*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmstransitionstart*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmstransitionend*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmstransitionend*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsanimationstart*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsanimationstart*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsanimationend*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsanimationend*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsanimationiteration*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsanimationiteration*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oninvalid*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_oninvalid*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_xmsAcceleratorKey*: proc(self: ptr IHTMLElement7, v: BSTR): HRESULT {.stdcall.} + get_xmsAcceleratorKey*: proc(self: ptr IHTMLElement7, p: ptr BSTR): HRESULT {.stdcall.} + put_spellcheck*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_spellcheck*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsmanipulationstatechanged*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_onmsmanipulationstatechanged*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncuechange*: proc(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.stdcall.} + get_oncuechange*: proc(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLStyleSheetRulesAppliedCollection* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRulesAppliedCollectionVtbl + IHTMLStyleSheetRulesAppliedCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + item*: proc(self: ptr IHTMLStyleSheetRulesAppliedCollection, index: LONG, ppHTMLStyleSheetRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLStyleSheetRulesAppliedCollection, p: ptr LONG): HRESULT {.stdcall.} + propertyAppliedBy*: proc(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, ppRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.stdcall.} + propertyAppliedTrace*: proc(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, index: LONG, ppRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.stdcall.} + propertyAppliedTraceLength*: proc(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, pLength: ptr LONG): HRESULT {.stdcall.} + IRulesApplied* {.pure.} = object + lpVtbl*: ptr IRulesAppliedVtbl + IRulesAppliedVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_element*: proc(self: ptr IRulesApplied, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_inlineStyles*: proc(self: ptr IRulesApplied, p: ptr ptr IHTMLStyle): HRESULT {.stdcall.} + get_appliedRules*: proc(self: ptr IRulesApplied, p: ptr ptr IHTMLStyleSheetRulesAppliedCollection): HRESULT {.stdcall.} + propertyIsInline*: proc(self: ptr IRulesApplied, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + propertyIsInheritable*: proc(self: ptr IRulesApplied, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + hasInheritableProperty*: proc(self: ptr IRulesApplied, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IRulesAppliedCollection* {.pure.} = object + lpVtbl*: ptr IRulesAppliedCollectionVtbl + IRulesAppliedCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + item*: proc(self: ptr IRulesAppliedCollection, index: LONG, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.stdcall.} + get_length*: proc(self: ptr IRulesAppliedCollection, p: ptr LONG): HRESULT {.stdcall.} + get_element*: proc(self: ptr IRulesAppliedCollection, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + propertyInheritedFrom*: proc(self: ptr IRulesAppliedCollection, name: BSTR, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.stdcall.} + get_propertyCount*: proc(self: ptr IRulesAppliedCollection, p: ptr LONG): HRESULT {.stdcall.} + property*: proc(self: ptr IRulesAppliedCollection, index: LONG, pbstrProperty: ptr BSTR): HRESULT {.stdcall.} + propertyInheritedTrace*: proc(self: ptr IRulesAppliedCollection, name: BSTR, index: LONG, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.stdcall.} + propertyInheritedTraceLength*: proc(self: ptr IRulesAppliedCollection, name: BSTR, pLength: ptr LONG): HRESULT {.stdcall.} + IHTMLElementAppliedStyles* {.pure.} = object + lpVtbl*: ptr IHTMLElementAppliedStylesVtbl + IHTMLElementAppliedStylesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + msGetRulesApplied*: proc(self: ptr IHTMLElementAppliedStyles, ppRulesAppliedCollection: ptr ptr IRulesAppliedCollection): HRESULT {.stdcall.} + msGetRulesAppliedWithAncestor*: proc(self: ptr IHTMLElementAppliedStyles, varContext: VARIANT, ppRulesAppliedCollection: ptr ptr IRulesAppliedCollection): HRESULT {.stdcall.} + IElementTraversal* {.pure.} = object + lpVtbl*: ptr IElementTraversalVtbl + IElementTraversalVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_firstElementChild*: proc(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_lastElementChild*: proc(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_previousElementSibling*: proc(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_nextElementSibling*: proc(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_childElementCount*: proc(self: ptr IElementTraversal, p: ptr LONG): HRESULT {.stdcall.} + IHTMLDatabinding* {.pure.} = object + lpVtbl*: ptr IHTMLDatabindingVtbl + IHTMLDatabindingVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_dataFld*: proc(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.stdcall.} + get_dataFld*: proc(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.stdcall.} + put_dataSrc*: proc(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.stdcall.} + get_dataSrc*: proc(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.stdcall.} + put_dataFormatAs*: proc(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.stdcall.} + get_dataFormatAs*: proc(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLElementDefaults* {.pure.} = object + lpVtbl*: ptr IHTMLElementDefaultsVtbl + IHTMLElementDefaultsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_style*: proc(self: ptr IHTMLElementDefaults, p: ptr ptr IHTMLStyle): HRESULT {.stdcall.} + put_tabStop*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_tabStop*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_viewInheritStyle*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_viewInheritStyle*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_viewMasterTab*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_viewMasterTab*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_scrollSegmentX*: proc(self: ptr IHTMLElementDefaults, v: LONG): HRESULT {.stdcall.} + get_scrollSegmentX*: proc(self: ptr IHTMLElementDefaults, p: ptr LONG): HRESULT {.stdcall.} + put_scrollSegmentY*: proc(self: ptr IHTMLElementDefaults, v: LONG): HRESULT {.stdcall.} + get_scrollSegmentY*: proc(self: ptr IHTMLElementDefaults, p: ptr LONG): HRESULT {.stdcall.} + put_isMultiLine*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_isMultiLine*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_contentEditable*: proc(self: ptr IHTMLElementDefaults, v: BSTR): HRESULT {.stdcall.} + get_contentEditable*: proc(self: ptr IHTMLElementDefaults, p: ptr BSTR): HRESULT {.stdcall.} + put_canHaveHTML*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_canHaveHTML*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + putref_viewLink*: proc(self: ptr IHTMLElementDefaults, v: ptr IHTMLDocument): HRESULT {.stdcall.} + get_viewLink*: proc(self: ptr IHTMLElementDefaults, p: ptr ptr IHTMLDocument): HRESULT {.stdcall.} + put_frozen*: proc(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_frozen*: proc(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDefaults* {.pure.} = object + lpVtbl*: ptr DispHTMLDefaultsVtbl + DispHTMLDefaultsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTCDefaultDispatch* {.pure.} = object + lpVtbl*: ptr IHTCDefaultDispatchVtbl + IHTCDefaultDispatchVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_element*: proc(self: ptr IHTCDefaultDispatch, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + createEventObject*: proc(self: ptr IHTCDefaultDispatch, eventObj: ptr ptr IHTMLEventObj): HRESULT {.stdcall.} + get_defaults*: proc(self: ptr IHTCDefaultDispatch, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_document*: proc(self: ptr IHTCDefaultDispatch, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTCPropertyBehavior* {.pure.} = object + lpVtbl*: ptr IHTCPropertyBehaviorVtbl + IHTCPropertyBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + fireChange*: proc(self: ptr IHTCPropertyBehavior): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTCPropertyBehavior, v: VARIANT): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTCPropertyBehavior, p: ptr VARIANT): HRESULT {.stdcall.} + IHTCMethodBehavior* {.pure.} = object + lpVtbl*: ptr IHTCMethodBehaviorVtbl + IHTCMethodBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTCEventBehavior* {.pure.} = object + lpVtbl*: ptr IHTCEventBehaviorVtbl + IHTCEventBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + fire*: proc(self: ptr IHTCEventBehavior, pvar: ptr IHTMLEventObj): HRESULT {.stdcall.} + IHTCAttachBehavior* {.pure.} = object + lpVtbl*: ptr IHTCAttachBehaviorVtbl + IHTCAttachBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + fireEvent*: proc(self: ptr IHTCAttachBehavior, evt: ptr IDispatch): HRESULT {.stdcall.} + detachEvent*: proc(self: ptr IHTCAttachBehavior): HRESULT {.stdcall.} + IHTCAttachBehavior2* {.pure.} = object + lpVtbl*: ptr IHTCAttachBehavior2Vtbl + IHTCAttachBehavior2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + fireEvent*: proc(self: ptr IHTCAttachBehavior2, evt: VARIANT): HRESULT {.stdcall.} + IHTCDescBehavior* {.pure.} = object + lpVtbl*: ptr IHTCDescBehaviorVtbl + IHTCDescBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_urn*: proc(self: ptr IHTCDescBehavior, p: ptr BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTCDescBehavior, p: ptr BSTR): HRESULT {.stdcall.} + DispHTCDefaultDispatch* {.pure.} = object + lpVtbl*: ptr DispHTCDefaultDispatchVtbl + DispHTCDefaultDispatchVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTCPropertyBehavior* {.pure.} = object + lpVtbl*: ptr DispHTCPropertyBehaviorVtbl + DispHTCPropertyBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTCMethodBehavior* {.pure.} = object + lpVtbl*: ptr DispHTCMethodBehaviorVtbl + DispHTCMethodBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTCEventBehavior* {.pure.} = object + lpVtbl*: ptr DispHTCEventBehaviorVtbl + DispHTCEventBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTCAttachBehavior* {.pure.} = object + lpVtbl*: ptr DispHTCAttachBehaviorVtbl + DispHTCAttachBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTCDescBehavior* {.pure.} = object + lpVtbl*: ptr DispHTCDescBehaviorVtbl + DispHTCDescBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLUrnCollection* {.pure.} = object + lpVtbl*: ptr IHTMLUrnCollectionVtbl + IHTMLUrnCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLUrnCollection, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLUrnCollection, index: LONG, ppUrn: ptr BSTR): HRESULT {.stdcall.} + DispHTMLUrnCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLUrnCollectionVtbl + DispHTMLUrnCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLGenericElement* {.pure.} = object + lpVtbl*: ptr IHTMLGenericElementVtbl + IHTMLGenericElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_recordset*: proc(self: ptr IHTMLGenericElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + namedRecordset*: proc(self: ptr IHTMLGenericElement, dataMember: BSTR, hierarchy: ptr VARIANT, ppRecordset: ptr ptr IDispatch): HRESULT {.stdcall.} + DispHTMLGenericElement* {.pure.} = object + lpVtbl*: ptr DispHTMLGenericElementVtbl + DispHTMLGenericElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleSheetRuleApplied* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRuleAppliedVtbl + IHTMLStyleSheetRuleAppliedVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_msSpecificity*: proc(self: ptr IHTMLStyleSheetRuleApplied, p: ptr LONG): HRESULT {.stdcall.} + msGetSpecificity*: proc(self: ptr IHTMLStyleSheetRuleApplied, index: LONG, p: ptr LONG): HRESULT {.stdcall.} + IHTMLStyleSheetRule2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRule2Vtbl + IHTMLStyleSheetRule2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selectorText*: proc(self: ptr IHTMLStyleSheetRule2, v: BSTR): HRESULT {.stdcall.} + get_selectorText*: proc(self: ptr IHTMLStyleSheetRule2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleSheetRulesCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetRulesCollection2Vtbl + IHTMLStyleSheetRulesCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLStyleSheetRulesCollection2, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLStyleSheetRulesCollection2, index: LONG, ppHTMLCSSRule: ptr ptr IHTMLCSSRule): HRESULT {.stdcall.} + DispHTMLStyleSheetRule* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetRuleVtbl + DispHTMLStyleSheetRuleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLStyleSheetRulesCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetRulesCollectionVtbl + DispHTMLStyleSheetRulesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleSheetPage* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetPageVtbl + IHTMLStyleSheetPageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_selector*: proc(self: ptr IHTMLStyleSheetPage, p: ptr BSTR): HRESULT {.stdcall.} + get_pseudoClass*: proc(self: ptr IHTMLStyleSheetPage, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleSheetPage2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetPage2Vtbl + IHTMLStyleSheetPage2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selectorText*: proc(self: ptr IHTMLStyleSheetPage2, v: BSTR): HRESULT {.stdcall.} + get_selectorText*: proc(self: ptr IHTMLStyleSheetPage2, p: ptr BSTR): HRESULT {.stdcall.} + get_style*: proc(self: ptr IHTMLStyleSheetPage2, p: ptr ptr IHTMLRuleStyle): HRESULT {.stdcall.} + IHTMLStyleSheetPagesCollection* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetPagesCollectionVtbl + IHTMLStyleSheetPagesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLStyleSheetPagesCollection, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLStyleSheetPagesCollection, index: LONG, ppHTMLStyleSheetPage: ptr ptr IHTMLStyleSheetPage): HRESULT {.stdcall.} + DispHTMLStyleSheetPage* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetPageVtbl + DispHTMLStyleSheetPageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLStyleSheetPagesCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetPagesCollectionVtbl + DispHTMLStyleSheetPagesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleSheet2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheet2Vtbl + IHTMLStyleSheet2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_pages*: proc(self: ptr IHTMLStyleSheet2, p: ptr ptr IHTMLStyleSheetPagesCollection): HRESULT {.stdcall.} + addPageRule*: proc(self: ptr IHTMLStyleSheet2, bstrSelector: BSTR, bstrStyle: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.stdcall.} + IHTMLStyleSheet3* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheet3Vtbl + IHTMLStyleSheet3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLStyleSheet3, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLStyleSheet3, p: ptr BSTR): HRESULT {.stdcall.} + get_isAlternate*: proc(self: ptr IHTMLStyleSheet3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_isPrefAlternate*: proc(self: ptr IHTMLStyleSheet3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLStyleSheet4* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheet4Vtbl + IHTMLStyleSheet4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLStyleSheet4, p: ptr BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLStyleSheet4, p: ptr VARIANT): HRESULT {.stdcall.} + get_title*: proc(self: ptr IHTMLStyleSheet4, p: ptr BSTR): HRESULT {.stdcall.} + get_ownerNode*: proc(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_ownerRule*: proc(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLCSSRule): HRESULT {.stdcall.} + get_cssRules*: proc(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLStyleSheet4, p: ptr VARIANT): HRESULT {.stdcall.} + insertRule*: proc(self: ptr IHTMLStyleSheet4, bstrRule: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.stdcall.} + deleteRule*: proc(self: ptr IHTMLStyleSheet4, lIndex: LONG): HRESULT {.stdcall.} + DispHTMLStyleSheet* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetVtbl + DispHTMLStyleSheetVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleSheetsCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleSheetsCollection2Vtbl + IHTMLStyleSheetsCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + item*: proc(self: ptr IHTMLStyleSheetsCollection2, index: LONG, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLStyleSheetsCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetsCollectionVtbl + DispHTMLStyleSheetsCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLLinkElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLLinkElementEvents2Vtbl + HTMLLinkElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLLinkElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLLinkElementEventsVtbl + HTMLLinkElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLLinkElement* {.pure.} = object + lpVtbl*: ptr IHTMLLinkElementVtbl + IHTMLLinkElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + put_rel*: proc(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.stdcall.} + get_rel*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + put_rev*: proc(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.stdcall.} + get_rev*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.stdcall.} + get_styleSheet*: proc(self: ptr IHTMLLinkElement, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLLinkElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLLinkElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLinkElement2* {.pure.} = object + lpVtbl*: ptr IHTMLLinkElement2Vtbl + IHTMLLinkElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_target*: proc(self: ptr IHTMLLinkElement2, v: BSTR): HRESULT {.stdcall.} + get_target*: proc(self: ptr IHTMLLinkElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLinkElement3* {.pure.} = object + lpVtbl*: ptr IHTMLLinkElement3Vtbl + IHTMLLinkElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_charset*: proc(self: ptr IHTMLLinkElement3, v: BSTR): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IHTMLLinkElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_hreflang*: proc(self: ptr IHTMLLinkElement3, v: BSTR): HRESULT {.stdcall.} + get_hreflang*: proc(self: ptr IHTMLLinkElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLinkElement4* {.pure.} = object + lpVtbl*: ptr IHTMLLinkElement4Vtbl + IHTMLLinkElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLLinkElement4, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLLinkElement4, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLinkElement5* {.pure.} = object + lpVtbl*: ptr IHTMLLinkElement5Vtbl + IHTMLLinkElement5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_sheet*: proc(self: ptr IHTMLLinkElement5, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + DispHTMLLinkElement* {.pure.} = object + lpVtbl*: ptr DispHTMLLinkElementVtbl + DispHTMLLinkElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLTxtRange* {.pure.} = object + lpVtbl*: ptr IHTMLTxtRangeVtbl + IHTMLTxtRangeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_htmlText*: proc(self: ptr IHTMLTxtRange, p: ptr BSTR): HRESULT {.stdcall.} + put_text*: proc(self: ptr IHTMLTxtRange, v: BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLTxtRange, p: ptr BSTR): HRESULT {.stdcall.} + parentElement*: proc(self: ptr IHTMLTxtRange, parent: ptr ptr IHTMLElement): HRESULT {.stdcall.} + duplicate*: proc(self: ptr IHTMLTxtRange, Duplicate: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + inRange*: proc(self: ptr IHTMLTxtRange, Range: ptr IHTMLTxtRange, InRange: ptr VARIANT_BOOL): HRESULT {.stdcall.} + isEqual*: proc(self: ptr IHTMLTxtRange, Range: ptr IHTMLTxtRange, IsEqual: ptr VARIANT_BOOL): HRESULT {.stdcall.} + scrollIntoView*: proc(self: ptr IHTMLTxtRange, fStart: VARIANT_BOOL): HRESULT {.stdcall.} + collapse*: proc(self: ptr IHTMLTxtRange, Start: VARIANT_BOOL): HRESULT {.stdcall.} + expand*: proc(self: ptr IHTMLTxtRange, Unit: BSTR, Success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + move*: proc(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.stdcall.} + moveStart*: proc(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.stdcall.} + moveEnd*: proc(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.stdcall.} + select*: proc(self: ptr IHTMLTxtRange): HRESULT {.stdcall.} + pasteHTML*: proc(self: ptr IHTMLTxtRange, html: BSTR): HRESULT {.stdcall.} + moveToElementText*: proc(self: ptr IHTMLTxtRange, element: ptr IHTMLElement): HRESULT {.stdcall.} + setEndPoint*: proc(self: ptr IHTMLTxtRange, how: BSTR, SourceRange: ptr IHTMLTxtRange): HRESULT {.stdcall.} + compareEndPoints*: proc(self: ptr IHTMLTxtRange, how: BSTR, SourceRange: ptr IHTMLTxtRange, ret: ptr LONG): HRESULT {.stdcall.} + findText*: proc(self: ptr IHTMLTxtRange, String: BSTR, count: LONG, Flags: LONG, Success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + moveToPoint*: proc(self: ptr IHTMLTxtRange, x: LONG, y: LONG): HRESULT {.stdcall.} + getBookmark*: proc(self: ptr IHTMLTxtRange, Boolmark: ptr BSTR): HRESULT {.stdcall.} + moveToBookmark*: proc(self: ptr IHTMLTxtRange, Bookmark: BSTR, Success: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandSupported*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandEnabled*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandState*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandIndeterm*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandText*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.stdcall.} + queryCommandValue*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.stdcall.} + execCommand*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + execCommandShowHelp*: proc(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLTextRangeMetrics* {.pure.} = object + lpVtbl*: ptr IHTMLTextRangeMetricsVtbl + IHTMLTextRangeMetricsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_offsetTop*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_offsetLeft*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_boundingTop*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_boundingLeft*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_boundingWidth*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_boundingHeight*: proc(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.stdcall.} + IHTMLTextRangeMetrics2* {.pure.} = object + lpVtbl*: ptr IHTMLTextRangeMetrics2Vtbl + IHTMLTextRangeMetrics2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getClientRects*: proc(self: ptr IHTMLTextRangeMetrics2, pRectCol: ptr ptr IHTMLRectCollection): HRESULT {.stdcall.} + getBoundingClientRect*: proc(self: ptr IHTMLTextRangeMetrics2, pRect: ptr ptr IHTMLRect): HRESULT {.stdcall.} + IHTMLTxtRangeCollection* {.pure.} = object + lpVtbl*: ptr IHTMLTxtRangeCollectionVtbl + IHTMLTxtRangeCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLTxtRangeCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLTxtRangeCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLTxtRangeCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLDOMRange* {.pure.} = object + lpVtbl*: ptr DispHTMLDOMRangeVtbl + DispHTMLDOMRangeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLFormElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLFormElementEvents2Vtbl + HTMLFormElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLFormElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLFormElementEventsVtbl + HTMLFormElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFormElement2* {.pure.} = object + lpVtbl*: ptr IHTMLFormElement2Vtbl + IHTMLFormElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_acceptCharset*: proc(self: ptr IHTMLFormElement2, v: BSTR): HRESULT {.stdcall.} + get_acceptCharset*: proc(self: ptr IHTMLFormElement2, p: ptr BSTR): HRESULT {.stdcall.} + urns*: proc(self: ptr IHTMLFormElement2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLFormElement3* {.pure.} = object + lpVtbl*: ptr IHTMLFormElement3Vtbl + IHTMLFormElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + namedItem*: proc(self: ptr IHTMLFormElement3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLSubmitData* {.pure.} = object + lpVtbl*: ptr IHTMLSubmitDataVtbl + IHTMLSubmitDataVtbl* {.pure, inheritable.} = object of IDispatchVtbl + appendNameValuePair*: proc(self: ptr IHTMLSubmitData, name: BSTR, value: BSTR): HRESULT {.stdcall.} + appendNameFilePair*: proc(self: ptr IHTMLSubmitData, name: BSTR, filename: BSTR): HRESULT {.stdcall.} + appendItemSeparator*: proc(self: ptr IHTMLSubmitData): HRESULT {.stdcall.} + IHTMLFormElement4* {.pure.} = object + lpVtbl*: ptr IHTMLFormElement4Vtbl + IHTMLFormElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_action*: proc(self: ptr IHTMLFormElement4, v: BSTR): HRESULT {.stdcall.} + get_action*: proc(self: ptr IHTMLFormElement4, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLFormElement* {.pure.} = object + lpVtbl*: ptr DispHTMLFormElementVtbl + DispHTMLFormElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLControlElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLControlElementEvents2Vtbl + HTMLControlElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLControlElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLControlElementEventsVtbl + HTMLControlElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLControlElement* {.pure.} = object + lpVtbl*: ptr IHTMLControlElementVtbl + IHTMLControlElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_tabIndex*: proc(self: ptr IHTMLControlElement, v: int16): HRESULT {.stdcall.} + get_tabIndex*: proc(self: ptr IHTMLControlElement, p: ptr int16): HRESULT {.stdcall.} + focus*: proc(self: ptr IHTMLControlElement): HRESULT {.stdcall.} + put_accessKey*: proc(self: ptr IHTMLControlElement, v: BSTR): HRESULT {.stdcall.} + get_accessKey*: proc(self: ptr IHTMLControlElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onresize*: proc(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.stdcall.} + get_onresize*: proc(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.stdcall.} + blur*: proc(self: ptr IHTMLControlElement): HRESULT {.stdcall.} + addFilter*: proc(self: ptr IHTMLControlElement, pUnk: ptr IUnknown): HRESULT {.stdcall.} + removeFilter*: proc(self: ptr IHTMLControlElement, pUnk: ptr IUnknown): HRESULT {.stdcall.} + get_clientHeight*: proc(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.stdcall.} + get_clientWidth*: proc(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.stdcall.} + get_clientTop*: proc(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.stdcall.} + get_clientLeft*: proc(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.stdcall.} + IHTMLTextElement* {.pure.} = object + lpVtbl*: ptr IHTMLTextElementVtbl + IHTMLTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTextElement* {.pure.} = object + lpVtbl*: ptr DispHTMLTextElementVtbl + DispHTMLTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLTextContainerEvents2* {.pure.} = object + lpVtbl*: ptr HTMLTextContainerEvents2Vtbl + HTMLTextContainerEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLTextContainerEvents* {.pure.} = object + lpVtbl*: ptr HTMLTextContainerEventsVtbl + HTMLTextContainerEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLTextContainer* {.pure.} = object + lpVtbl*: ptr IHTMLTextContainerVtbl + IHTMLTextContainerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + createControlRange*: proc(self: ptr IHTMLTextContainer, range: ptr ptr IDispatch): HRESULT {.stdcall.} + get_scrollHeight*: proc(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.stdcall.} + get_scrollWidth*: proc(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.stdcall.} + put_scrollTop*: proc(self: ptr IHTMLTextContainer, v: LONG): HRESULT {.stdcall.} + get_scrollTop*: proc(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.stdcall.} + put_scrollLeft*: proc(self: ptr IHTMLTextContainer, v: LONG): HRESULT {.stdcall.} + get_scrollLeft*: proc(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.stdcall.} + put_onscroll*: proc(self: ptr IHTMLTextContainer, v: VARIANT): HRESULT {.stdcall.} + get_onscroll*: proc(self: ptr IHTMLTextContainer, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLControlRange* {.pure.} = object + lpVtbl*: ptr IHTMLControlRangeVtbl + IHTMLControlRangeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + select*: proc(self: ptr IHTMLControlRange): HRESULT {.stdcall.} + add*: proc(self: ptr IHTMLControlRange, item: ptr IHTMLControlElement): HRESULT {.stdcall.} + remove*: proc(self: ptr IHTMLControlRange, index: LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLControlRange, index: LONG, pdisp: ptr ptr IHTMLElement): HRESULT {.stdcall.} + scrollIntoView*: proc(self: ptr IHTMLControlRange, varargStart: VARIANT): HRESULT {.stdcall.} + queryCommandSupported*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandEnabled*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandState*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandIndeterm*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + queryCommandText*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.stdcall.} + queryCommandValue*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.stdcall.} + execCommand*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + execCommandShowHelp*: proc(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.stdcall.} + commonParentElement*: proc(self: ptr IHTMLControlRange, parent: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLControlRange, p: ptr LONG): HRESULT {.stdcall.} + IHTMLControlRange2* {.pure.} = object + lpVtbl*: ptr IHTMLControlRange2Vtbl + IHTMLControlRange2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + addElement*: proc(self: ptr IHTMLControlRange2, item: ptr IHTMLElement): HRESULT {.stdcall.} + HTMLImgEvents2* {.pure.} = object + lpVtbl*: ptr HTMLImgEvents2Vtbl + HTMLImgEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLImgEvents* {.pure.} = object + lpVtbl*: ptr HTMLImgEventsVtbl + HTMLImgEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLImgElement2* {.pure.} = object + lpVtbl*: ptr IHTMLImgElement2Vtbl + IHTMLImgElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_longDesc*: proc(self: ptr IHTMLImgElement2, v: BSTR): HRESULT {.stdcall.} + get_longDesc*: proc(self: ptr IHTMLImgElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLImgElement3* {.pure.} = object + lpVtbl*: ptr IHTMLImgElement3Vtbl + IHTMLImgElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_longDesc*: proc(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.stdcall.} + get_longDesc*: proc(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_vrml*: proc(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.stdcall.} + get_vrml*: proc(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_lowsrc*: proc(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.stdcall.} + get_lowsrc*: proc(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_dynsrc*: proc(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.stdcall.} + get_dynsrc*: proc(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLImgElement4* {.pure.} = object + lpVtbl*: ptr IHTMLImgElement4Vtbl + IHTMLImgElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_naturalWidth*: proc(self: ptr IHTMLImgElement4, p: ptr LONG): HRESULT {.stdcall.} + get_naturalHeight*: proc(self: ptr IHTMLImgElement4, p: ptr LONG): HRESULT {.stdcall.} + IHTMLMSImgElement* {.pure.} = object + lpVtbl*: ptr IHTMLMSImgElementVtbl + IHTMLMSImgElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_msPlayToDisabled*: proc(self: ptr IHTMLMSImgElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_msPlayToDisabled*: proc(self: ptr IHTMLMSImgElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_msPlayToPrimary*: proc(self: ptr IHTMLMSImgElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_msPlayToPrimary*: proc(self: ptr IHTMLMSImgElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLImg* {.pure.} = object + lpVtbl*: ptr DispHTMLImgVtbl + DispHTMLImgVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBodyElement* {.pure.} = object + lpVtbl*: ptr IHTMLBodyElementVtbl + IHTMLBodyElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_background*: proc(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.stdcall.} + put_bgProperties*: proc(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.stdcall.} + get_bgProperties*: proc(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.stdcall.} + put_leftMargin*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_leftMargin*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_topMargin*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_topMargin*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_rightMargin*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_rightMargin*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_bottomMargin*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_bottomMargin*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_noWrap*: proc(self: ptr IHTMLBodyElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noWrap*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_text*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_link*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_link*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_vLink*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_vLink*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_aLink*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_aLink*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onunload*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_onunload*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_scroll*: proc(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.stdcall.} + get_scroll*: proc(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforeunload*: proc(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeunload*: proc(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLBodyElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLBodyElement2* {.pure.} = object + lpVtbl*: ptr IHTMLBodyElement2Vtbl + IHTMLBodyElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onbeforeprint*: proc(self: ptr IHTMLBodyElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeprint*: proc(self: ptr IHTMLBodyElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onafterprint*: proc(self: ptr IHTMLBodyElement2, v: VARIANT): HRESULT {.stdcall.} + get_onafterprint*: proc(self: ptr IHTMLBodyElement2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLBodyElement3* {.pure.} = object + lpVtbl*: ptr IHTMLBodyElement3Vtbl + IHTMLBodyElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_background*: proc(self: ptr IHTMLBodyElement3, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLBodyElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_ononline*: proc(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.stdcall.} + get_ononline*: proc(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onoffline*: proc(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.stdcall.} + get_onoffline*: proc(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onhashchange*: proc(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.stdcall.} + get_onhashchange*: proc(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLBodyElement4* {.pure.} = object + lpVtbl*: ptr IHTMLBodyElement4Vtbl + IHTMLBodyElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmessage*: proc(self: ptr IHTMLBodyElement4, v: VARIANT): HRESULT {.stdcall.} + get_onmessage*: proc(self: ptr IHTMLBodyElement4, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstorage*: proc(self: ptr IHTMLBodyElement4, v: VARIANT): HRESULT {.stdcall.} + get_onstorage*: proc(self: ptr IHTMLBodyElement4, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLBodyElement5* {.pure.} = object + lpVtbl*: ptr IHTMLBodyElement5Vtbl + IHTMLBodyElement5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onpopstate*: proc(self: ptr IHTMLBodyElement5, v: VARIANT): HRESULT {.stdcall.} + get_onpopstate*: proc(self: ptr IHTMLBodyElement5, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLBody* {.pure.} = object + lpVtbl*: ptr DispHTMLBodyVtbl + DispHTMLBodyVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFontElement* {.pure.} = object + lpVtbl*: ptr IHTMLFontElementVtbl + IHTMLFontElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_color*: proc(self: ptr IHTMLFontElement, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLFontElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_face*: proc(self: ptr IHTMLFontElement, v: BSTR): HRESULT {.stdcall.} + get_face*: proc(self: ptr IHTMLFontElement, p: ptr BSTR): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLFontElement, v: VARIANT): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLFontElement, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLFontElement* {.pure.} = object + lpVtbl*: ptr DispHTMLFontElementVtbl + DispHTMLFontElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLAnchorEvents2* {.pure.} = object + lpVtbl*: ptr HTMLAnchorEvents2Vtbl + HTMLAnchorEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLAnchorEvents* {.pure.} = object + lpVtbl*: ptr HTMLAnchorEventsVtbl + HTMLAnchorEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLAnchorElement* {.pure.} = object + lpVtbl*: ptr IHTMLAnchorElementVtbl + IHTMLAnchorElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_target*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_target*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_rel*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_rel*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_rev*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_rev*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_urn*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_urn*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_Methods*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_Methods*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_host*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_host*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_hostname*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_hostname*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_pathname*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_pathname*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_port*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_port*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_protocol*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_protocol*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_search*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_search*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_hash*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_hash*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLAnchorElement, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLAnchorElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLAnchorElement, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLAnchorElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_accessKey*: proc(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.stdcall.} + get_accessKey*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + get_protocolLong*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + get_mimeType*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + get_nameProp*: proc(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.stdcall.} + put_tabIndex*: proc(self: ptr IHTMLAnchorElement, v: int16): HRESULT {.stdcall.} + get_tabIndex*: proc(self: ptr IHTMLAnchorElement, p: ptr int16): HRESULT {.stdcall.} + focus*: proc(self: ptr IHTMLAnchorElement): HRESULT {.stdcall.} + blur*: proc(self: ptr IHTMLAnchorElement): HRESULT {.stdcall.} + IHTMLAnchorElement2* {.pure.} = object + lpVtbl*: ptr IHTMLAnchorElement2Vtbl + IHTMLAnchorElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_charset*: proc(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_coords*: proc(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.stdcall.} + get_coords*: proc(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_hreflang*: proc(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.stdcall.} + get_hreflang*: proc(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_shape*: proc(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.stdcall.} + get_shape*: proc(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLAnchorElement3* {.pure.} = object + lpVtbl*: ptr IHTMLAnchorElement3Vtbl + IHTMLAnchorElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_shape*: proc(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.stdcall.} + get_shape*: proc(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_coords*: proc(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.stdcall.} + get_coords*: proc(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_href*: proc(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLAnchorElement* {.pure.} = object + lpVtbl*: ptr DispHTMLAnchorElementVtbl + DispHTMLAnchorElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLLabelEvents2* {.pure.} = object + lpVtbl*: ptr HTMLLabelEvents2Vtbl + HTMLLabelEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLLabelEvents* {.pure.} = object + lpVtbl*: ptr HTMLLabelEventsVtbl + HTMLLabelEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLLabelElement* {.pure.} = object + lpVtbl*: ptr IHTMLLabelElementVtbl + IHTMLLabelElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_htmlFor*: proc(self: ptr IHTMLLabelElement, v: BSTR): HRESULT {.stdcall.} + get_htmlFor*: proc(self: ptr IHTMLLabelElement, p: ptr BSTR): HRESULT {.stdcall.} + put_accessKey*: proc(self: ptr IHTMLLabelElement, v: BSTR): HRESULT {.stdcall.} + get_accessKey*: proc(self: ptr IHTMLLabelElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLabelElement2* {.pure.} = object + lpVtbl*: ptr IHTMLLabelElement2Vtbl + IHTMLLabelElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_form*: proc(self: ptr IHTMLLabelElement2, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + DispHTMLLabelElement* {.pure.} = object + lpVtbl*: ptr DispHTMLLabelElementVtbl + DispHTMLLabelElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLListElement* {.pure.} = object + lpVtbl*: ptr IHTMLListElementVtbl + IHTMLListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLListElement2* {.pure.} = object + lpVtbl*: ptr IHTMLListElement2Vtbl + IHTMLListElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_compact*: proc(self: ptr IHTMLListElement2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_compact*: proc(self: ptr IHTMLListElement2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLListElement* {.pure.} = object + lpVtbl*: ptr DispHTMLListElementVtbl + DispHTMLListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLUListElement* {.pure.} = object + lpVtbl*: ptr IHTMLUListElementVtbl + IHTMLUListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_compact*: proc(self: ptr IHTMLUListElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_compact*: proc(self: ptr IHTMLUListElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLUListElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLUListElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLUListElement* {.pure.} = object + lpVtbl*: ptr DispHTMLUListElementVtbl + DispHTMLUListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLOListElement* {.pure.} = object + lpVtbl*: ptr IHTMLOListElementVtbl + IHTMLOListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_compact*: proc(self: ptr IHTMLOListElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_compact*: proc(self: ptr IHTMLOListElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_start*: proc(self: ptr IHTMLOListElement, v: LONG): HRESULT {.stdcall.} + get_start*: proc(self: ptr IHTMLOListElement, p: ptr LONG): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLOListElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLOListElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLOListElement* {.pure.} = object + lpVtbl*: ptr DispHTMLOListElementVtbl + DispHTMLOListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLLIElement* {.pure.} = object + lpVtbl*: ptr IHTMLLIElementVtbl + IHTMLLIElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr IHTMLLIElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLLIElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLLIElement, v: LONG): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLLIElement, p: ptr LONG): HRESULT {.stdcall.} + DispHTMLLIElement* {.pure.} = object + lpVtbl*: ptr DispHTMLLIElementVtbl + DispHTMLLIElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBlockElement* {.pure.} = object + lpVtbl*: ptr IHTMLBlockElementVtbl + IHTMLBlockElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_clear*: proc(self: ptr IHTMLBlockElement, v: BSTR): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLBlockElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLBlockElement2* {.pure.} = object + lpVtbl*: ptr IHTMLBlockElement2Vtbl + IHTMLBlockElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_cite*: proc(self: ptr IHTMLBlockElement2, v: BSTR): HRESULT {.stdcall.} + get_cite*: proc(self: ptr IHTMLBlockElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLBlockElement2, v: BSTR): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLBlockElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLBlockElement3* {.pure.} = object + lpVtbl*: ptr IHTMLBlockElement3Vtbl + IHTMLBlockElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_cite*: proc(self: ptr IHTMLBlockElement3, v: BSTR): HRESULT {.stdcall.} + get_cite*: proc(self: ptr IHTMLBlockElement3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLBlockElement* {.pure.} = object + lpVtbl*: ptr DispHTMLBlockElementVtbl + DispHTMLBlockElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDivElement* {.pure.} = object + lpVtbl*: ptr IHTMLDivElementVtbl + IHTMLDivElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLDivElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLDivElement, p: ptr BSTR): HRESULT {.stdcall.} + put_noWrap*: proc(self: ptr IHTMLDivElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noWrap*: proc(self: ptr IHTMLDivElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDivElement* {.pure.} = object + lpVtbl*: ptr DispHTMLDivElementVtbl + DispHTMLDivElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDDElement* {.pure.} = object + lpVtbl*: ptr IHTMLDDElementVtbl + IHTMLDDElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_noWrap*: proc(self: ptr IHTMLDDElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noWrap*: proc(self: ptr IHTMLDDElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDDElement* {.pure.} = object + lpVtbl*: ptr DispHTMLDDElementVtbl + DispHTMLDDElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDTElement* {.pure.} = object + lpVtbl*: ptr IHTMLDTElementVtbl + IHTMLDTElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_noWrap*: proc(self: ptr IHTMLDTElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noWrap*: proc(self: ptr IHTMLDTElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDTElement* {.pure.} = object + lpVtbl*: ptr DispHTMLDTElementVtbl + DispHTMLDTElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBRElement* {.pure.} = object + lpVtbl*: ptr IHTMLBRElementVtbl + IHTMLBRElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_clear*: proc(self: ptr IHTMLBRElement, v: BSTR): HRESULT {.stdcall.} + get_clear*: proc(self: ptr IHTMLBRElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLBRElement* {.pure.} = object + lpVtbl*: ptr DispHTMLBRElementVtbl + DispHTMLBRElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDListElement* {.pure.} = object + lpVtbl*: ptr IHTMLDListElementVtbl + IHTMLDListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_compact*: proc(self: ptr IHTMLDListElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_compact*: proc(self: ptr IHTMLDListElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLDListElement* {.pure.} = object + lpVtbl*: ptr DispHTMLDListElementVtbl + DispHTMLDListElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLHRElement* {.pure.} = object + lpVtbl*: ptr IHTMLHRElementVtbl + IHTMLHRElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLHRElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLHRElement, p: ptr BSTR): HRESULT {.stdcall.} + put_color*: proc(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_noShade*: proc(self: ptr IHTMLHRElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noShade*: proc(self: ptr IHTMLHRElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLHRElement* {.pure.} = object + lpVtbl*: ptr DispHTMLHRElementVtbl + DispHTMLHRElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLParaElement* {.pure.} = object + lpVtbl*: ptr IHTMLParaElementVtbl + IHTMLParaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLParaElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLParaElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLParaElement* {.pure.} = object + lpVtbl*: ptr DispHTMLParaElementVtbl + DispHTMLParaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLElementCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLElementCollection2Vtbl + IHTMLElementCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + urns*: proc(self: ptr IHTMLElementCollection2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLElementCollection3* {.pure.} = object + lpVtbl*: ptr IHTMLElementCollection3Vtbl + IHTMLElementCollection3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + namedItem*: proc(self: ptr IHTMLElementCollection3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLElementCollection4* {.pure.} = object + lpVtbl*: ptr IHTMLElementCollection4Vtbl + IHTMLElementCollection4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLElementCollection4, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLElementCollection4, index: LONG, pNode: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + namedItem*: proc(self: ptr IHTMLElementCollection4, name: BSTR, pNode: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + DispHTMLElementCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLElementCollectionVtbl + DispHTMLElementCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLHeaderElement* {.pure.} = object + lpVtbl*: ptr IHTMLHeaderElementVtbl + IHTMLHeaderElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLHeaderElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLHeaderElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLHeaderElement* {.pure.} = object + lpVtbl*: ptr DispHTMLHeaderElementVtbl + DispHTMLHeaderElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLSelectElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLSelectElementEvents2Vtbl + HTMLSelectElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLSelectElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLSelectElementEventsVtbl + HTMLSelectElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLSelectElementEx* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElementExVtbl + IHTMLSelectElementExVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowDropdown*: proc(self: ptr IHTMLSelectElementEx, fShow: WINBOOL): HRESULT {.stdcall.} + SetSelectExFlags*: proc(self: ptr IHTMLSelectElementEx, lFlags: DWORD): HRESULT {.stdcall.} + GetSelectExFlags*: proc(self: ptr IHTMLSelectElementEx, pFlags: ptr DWORD): HRESULT {.stdcall.} + GetDropdownOpen*: proc(self: ptr IHTMLSelectElementEx, pfOpen: ptr WINBOOL): HRESULT {.stdcall.} + IHTMLSelectElement* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElementVtbl + IHTMLSelectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_size*: proc(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.stdcall.} + put_multiple*: proc(self: ptr IHTMLSelectElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_multiple*: proc(self: ptr IHTMLSelectElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLSelectElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.stdcall.} + get_options*: proc(self: ptr IHTMLSelectElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLSelectElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLSelectElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_selectedIndex*: proc(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.stdcall.} + get_selectedIndex*: proc(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLSelectElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLSelectElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLSelectElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLSelectElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + add*: proc(self: ptr IHTMLSelectElement, element: ptr IHTMLElement, before: VARIANT): HRESULT {.stdcall.} + remove*: proc(self: ptr IHTMLSelectElement, index: LONG): HRESULT {.stdcall.} + put_length*: proc(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLSelectElement, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLSelectElement, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + tags*: proc(self: ptr IHTMLSelectElement, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLSelectElement2* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElement2Vtbl + IHTMLSelectElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + urns*: proc(self: ptr IHTMLSelectElement2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLSelectElement4* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElement4Vtbl + IHTMLSelectElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + namedItem*: proc(self: ptr IHTMLSelectElement4, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLSelectElement5* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElement5Vtbl + IHTMLSelectElement5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + add*: proc(self: ptr IHTMLSelectElement5, pElem: ptr IHTMLOptionElement, pvarBefore: ptr VARIANT): HRESULT {.stdcall.} + IHTMLSelectElement6* {.pure.} = object + lpVtbl*: ptr IHTMLSelectElement6Vtbl + IHTMLSelectElement6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + add*: proc(self: ptr IHTMLSelectElement6, pElem: ptr IHTMLOptionElement, pvarBefore: ptr VARIANT): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLSelectElement6, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLSelectElement6, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLSelectElement* {.pure.} = object + lpVtbl*: ptr DispHTMLSelectElementVtbl + DispHTMLSelectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLWndSelectElement* {.pure.} = object + lpVtbl*: ptr DispHTMLWndSelectElementVtbl + DispHTMLWndSelectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLSelectionObject2* {.pure.} = object + lpVtbl*: ptr IHTMLSelectionObject2Vtbl + IHTMLSelectionObject2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + createRangeCollection*: proc(self: ptr IHTMLSelectionObject2, rangeCollection: ptr ptr IDispatch): HRESULT {.stdcall.} + get_typeDetail*: proc(self: ptr IHTMLSelectionObject2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLOptionElement3* {.pure.} = object + lpVtbl*: ptr IHTMLOptionElement3Vtbl + IHTMLOptionElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_label*: proc(self: ptr IHTMLOptionElement3, v: BSTR): HRESULT {.stdcall.} + get_label*: proc(self: ptr IHTMLOptionElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLOptionElement4* {.pure.} = object + lpVtbl*: ptr IHTMLOptionElement4Vtbl + IHTMLOptionElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_value*: proc(self: ptr IHTMLOptionElement4, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLOptionElement4, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLOptionElement* {.pure.} = object + lpVtbl*: ptr DispHTMLOptionElementVtbl + DispHTMLOptionElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLWndOptionElement* {.pure.} = object + lpVtbl*: ptr DispHTMLWndOptionElementVtbl + DispHTMLWndOptionElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLButtonElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLButtonElementEvents2Vtbl + HTMLButtonElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLButtonElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLButtonElementEventsVtbl + HTMLButtonElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputTextElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLInputTextElementEvents2Vtbl + HTMLInputTextElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLOptionButtonElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLOptionButtonElementEvents2Vtbl + HTMLOptionButtonElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputFileElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLInputFileElementEvents2Vtbl + HTMLInputFileElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputImageEvents2* {.pure.} = object + lpVtbl*: ptr HTMLInputImageEvents2Vtbl + HTMLInputImageEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputTextElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLInputTextElementEventsVtbl + HTMLInputTextElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLOptionButtonElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLOptionButtonElementEventsVtbl + HTMLOptionButtonElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputFileElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLInputFileElementEventsVtbl + HTMLInputFileElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLInputImageEvents* {.pure.} = object + lpVtbl*: ptr HTMLInputImageEventsVtbl + HTMLInputImageEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLInputElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputElementVtbl + IHTMLInputElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLInputElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + put_maxLength*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_maxLength*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + select*: proc(self: ptr IHTMLInputElement): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_defaultValue*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_defaultValue*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_readOnly*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_readOnly*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLInputElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + put_indeterminate*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_indeterminate*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_defaultChecked*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_defaultChecked*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_checked*: proc(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_checked*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_vspace*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_lowsrc*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_lowsrc*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_vrml*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_vrml*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_dynsrc*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_dynsrc*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + get_complete*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLInputElement, v: LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.stdcall.} + put_start*: proc(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.stdcall.} + get_start*: proc(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLInputElement2* {.pure.} = object + lpVtbl*: ptr IHTMLInputElement2Vtbl + IHTMLInputElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_accept*: proc(self: ptr IHTMLInputElement2, v: BSTR): HRESULT {.stdcall.} + get_accept*: proc(self: ptr IHTMLInputElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_useMap*: proc(self: ptr IHTMLInputElement2, v: BSTR): HRESULT {.stdcall.} + get_useMap*: proc(self: ptr IHTMLInputElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLInputElement3* {.pure.} = object + lpVtbl*: ptr IHTMLInputElement3Vtbl + IHTMLInputElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_lowsrc*: proc(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.stdcall.} + get_lowsrc*: proc(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_vrml*: proc(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.stdcall.} + get_vrml*: proc(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_dynsrc*: proc(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.stdcall.} + get_dynsrc*: proc(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLInputButtonElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputButtonElementVtbl + IHTMLInputButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputButtonElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputButtonElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLInputButtonElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLInputButtonElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLInputButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLInputButtonElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLInputHiddenElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputHiddenElementVtbl + IHTMLInputHiddenElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputHiddenElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputHiddenElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLInputHiddenElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLInputHiddenElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputHiddenElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputHiddenElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLInputHiddenElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLInputHiddenElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLInputTextElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputTextElementVtbl + IHTMLInputTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputTextElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputTextElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLInputTextElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + put_defaultValue*: proc(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.stdcall.} + get_defaultValue*: proc(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLInputTextElement, v: LONG): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLInputTextElement, p: ptr LONG): HRESULT {.stdcall.} + put_maxLength*: proc(self: ptr IHTMLInputTextElement, v: LONG): HRESULT {.stdcall.} + get_maxLength*: proc(self: ptr IHTMLInputTextElement, p: ptr LONG): HRESULT {.stdcall.} + select*: proc(self: ptr IHTMLInputTextElement): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_readOnly*: proc(self: ptr IHTMLInputTextElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_readOnly*: proc(self: ptr IHTMLInputTextElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLInputTextElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLInputTextElement2* {.pure.} = object + lpVtbl*: ptr IHTMLInputTextElement2Vtbl + IHTMLInputTextElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selectionStart*: proc(self: ptr IHTMLInputTextElement2, v: LONG): HRESULT {.stdcall.} + get_selectionStart*: proc(self: ptr IHTMLInputTextElement2, p: ptr LONG): HRESULT {.stdcall.} + put_selectionEnd*: proc(self: ptr IHTMLInputTextElement2, v: LONG): HRESULT {.stdcall.} + get_selectionEnd*: proc(self: ptr IHTMLInputTextElement2, p: ptr LONG): HRESULT {.stdcall.} + setSelectionRange*: proc(self: ptr IHTMLInputTextElement2, start: LONG, `end`: LONG): HRESULT {.stdcall.} + IHTMLInputFileElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputFileElementVtbl + IHTMLInputFileElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputFileElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputFileElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputFileElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLInputFileElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLInputFileElement, v: LONG): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLInputFileElement, p: ptr LONG): HRESULT {.stdcall.} + put_maxLength*: proc(self: ptr IHTMLInputFileElement, v: LONG): HRESULT {.stdcall.} + get_maxLength*: proc(self: ptr IHTMLInputFileElement, p: ptr LONG): HRESULT {.stdcall.} + select*: proc(self: ptr IHTMLInputFileElement): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputFileElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLOptionButtonElement* {.pure.} = object + lpVtbl*: ptr IHTMLOptionButtonElementVtbl + IHTMLOptionButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_value*: proc(self: ptr IHTMLOptionButtonElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLOptionButtonElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_checked*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_checked*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_defaultChecked*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_defaultChecked*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_indeterminate*: proc(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_indeterminate*: proc(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLOptionButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + IHTMLInputImage* {.pure.} = object + lpVtbl*: ptr IHTMLInputImageVtbl + IHTMLInputImageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLInputImage, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.stdcall.} + put_vspace*: proc(self: ptr IHTMLInputImage, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLInputImage, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_lowsrc*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_lowsrc*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_vrml*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_vrml*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_dynsrc*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_dynsrc*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + get_complete*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLInputImage, v: LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLInputImage, v: LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.stdcall.} + put_start*: proc(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.stdcall.} + get_start*: proc(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLInputRangeElement* {.pure.} = object + lpVtbl*: ptr IHTMLInputRangeElementVtbl + IHTMLInputRangeElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_disabled*: proc(self: ptr IHTMLInputRangeElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLInputRangeElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_min*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_min*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_max*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_max*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_step*: proc(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.stdcall.} + get_step*: proc(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_valueAsNumber*: proc(self: ptr IHTMLInputRangeElement, v: float64): HRESULT {.stdcall.} + get_valueAsNumber*: proc(self: ptr IHTMLInputRangeElement, p: ptr float64): HRESULT {.stdcall.} + stepUp*: proc(self: ptr IHTMLInputRangeElement, n: LONG): HRESULT {.stdcall.} + stepDown*: proc(self: ptr IHTMLInputRangeElement, n: LONG): HRESULT {.stdcall.} + DispHTMLInputElement* {.pure.} = object + lpVtbl*: ptr DispHTMLInputElementVtbl + DispHTMLInputElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLTextAreaElement* {.pure.} = object + lpVtbl*: ptr IHTMLTextAreaElementVtbl + IHTMLTextAreaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLTextAreaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLTextAreaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLTextAreaElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + put_defaultValue*: proc(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.stdcall.} + get_defaultValue*: proc(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + select*: proc(self: ptr IHTMLTextAreaElement): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_readOnly*: proc(self: ptr IHTMLTextAreaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_readOnly*: proc(self: ptr IHTMLTextAreaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_rows*: proc(self: ptr IHTMLTextAreaElement, v: LONG): HRESULT {.stdcall.} + get_rows*: proc(self: ptr IHTMLTextAreaElement, p: ptr LONG): HRESULT {.stdcall.} + put_cols*: proc(self: ptr IHTMLTextAreaElement, v: LONG): HRESULT {.stdcall.} + get_cols*: proc(self: ptr IHTMLTextAreaElement, p: ptr LONG): HRESULT {.stdcall.} + put_wrap*: proc(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.stdcall.} + get_wrap*: proc(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLTextAreaElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLTextAreaElement2* {.pure.} = object + lpVtbl*: ptr IHTMLTextAreaElement2Vtbl + IHTMLTextAreaElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_selectionStart*: proc(self: ptr IHTMLTextAreaElement2, v: LONG): HRESULT {.stdcall.} + get_selectionStart*: proc(self: ptr IHTMLTextAreaElement2, p: ptr LONG): HRESULT {.stdcall.} + put_selectionEnd*: proc(self: ptr IHTMLTextAreaElement2, v: LONG): HRESULT {.stdcall.} + get_selectionEnd*: proc(self: ptr IHTMLTextAreaElement2, p: ptr LONG): HRESULT {.stdcall.} + setSelectionRange*: proc(self: ptr IHTMLTextAreaElement2, start: LONG, `end`: LONG): HRESULT {.stdcall.} + DispHTMLTextAreaElement* {.pure.} = object + lpVtbl*: ptr DispHTMLTextAreaElementVtbl + DispHTMLTextAreaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLRichtextElement* {.pure.} = object + lpVtbl*: ptr DispHTMLRichtextElementVtbl + DispHTMLRichtextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLButtonElement* {.pure.} = object + lpVtbl*: ptr IHTMLButtonElementVtbl + IHTMLButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLButtonElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLButtonElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.stdcall.} + put_status*: proc(self: ptr IHTMLButtonElement, v: VARIANT): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLButtonElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLButtonElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLButtonElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + createTextRange*: proc(self: ptr IHTMLButtonElement, range: ptr ptr IHTMLTxtRange): HRESULT {.stdcall.} + IHTMLButtonElement2* {.pure.} = object + lpVtbl*: ptr IHTMLButtonElement2Vtbl + IHTMLButtonElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr IHTMLButtonElement2, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLButtonElement2, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLButtonElement* {.pure.} = object + lpVtbl*: ptr DispHTMLButtonElementVtbl + DispHTMLButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLMarqueeElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLMarqueeElementEvents2Vtbl + HTMLMarqueeElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLMarqueeElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLMarqueeElementEventsVtbl + HTMLMarqueeElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLMarqueeElement* {.pure.} = object + lpVtbl*: ptr IHTMLMarqueeElementVtbl + IHTMLMarqueeElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_bgColor*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_scrollDelay*: proc(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.stdcall.} + get_scrollDelay*: proc(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.stdcall.} + put_direction*: proc(self: ptr IHTMLMarqueeElement, v: BSTR): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLMarqueeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_behavior*: proc(self: ptr IHTMLMarqueeElement, v: BSTR): HRESULT {.stdcall.} + get_behavior*: proc(self: ptr IHTMLMarqueeElement, p: ptr BSTR): HRESULT {.stdcall.} + put_scrollAmount*: proc(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.stdcall.} + get_scrollAmount*: proc(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.stdcall.} + put_vspace*: proc(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.stdcall.} + put_onfinish*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_onfinish*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstart*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_onstart*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbounce*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_onbounce*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_trueSpeed*: proc(self: ptr IHTMLMarqueeElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_trueSpeed*: proc(self: ptr IHTMLMarqueeElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + start*: proc(self: ptr IHTMLMarqueeElement): HRESULT {.stdcall.} + stop*: proc(self: ptr IHTMLMarqueeElement): HRESULT {.stdcall.} + DispHTMLMarqueeElement* {.pure.} = object + lpVtbl*: ptr DispHTMLMarqueeElementVtbl + DispHTMLMarqueeElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLHtmlElement* {.pure.} = object + lpVtbl*: ptr IHTMLHtmlElementVtbl + IHTMLHtmlElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_version*: proc(self: ptr IHTMLHtmlElement, v: BSTR): HRESULT {.stdcall.} + get_version*: proc(self: ptr IHTMLHtmlElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLHeadElement* {.pure.} = object + lpVtbl*: ptr IHTMLHeadElementVtbl + IHTMLHeadElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_profile*: proc(self: ptr IHTMLHeadElement, v: BSTR): HRESULT {.stdcall.} + get_profile*: proc(self: ptr IHTMLHeadElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLHeadElement2* {.pure.} = object + lpVtbl*: ptr IHTMLHeadElement2Vtbl + IHTMLHeadElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_profile*: proc(self: ptr IHTMLHeadElement2, v: BSTR): HRESULT {.stdcall.} + get_profile*: proc(self: ptr IHTMLHeadElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTitleElement* {.pure.} = object + lpVtbl*: ptr IHTMLTitleElementVtbl + IHTMLTitleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_text*: proc(self: ptr IHTMLTitleElement, v: BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLTitleElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLMetaElement* {.pure.} = object + lpVtbl*: ptr IHTMLMetaElementVtbl + IHTMLMetaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_httpEquiv*: proc(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.stdcall.} + get_httpEquiv*: proc(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_content*: proc(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.stdcall.} + get_content*: proc(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_url*: proc(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.stdcall.} + get_url*: proc(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_charset*: proc(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLMetaElement2* {.pure.} = object + lpVtbl*: ptr IHTMLMetaElement2Vtbl + IHTMLMetaElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_scheme*: proc(self: ptr IHTMLMetaElement2, v: BSTR): HRESULT {.stdcall.} + get_scheme*: proc(self: ptr IHTMLMetaElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLMetaElement3* {.pure.} = object + lpVtbl*: ptr IHTMLMetaElement3Vtbl + IHTMLMetaElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_url*: proc(self: ptr IHTMLMetaElement3, v: BSTR): HRESULT {.stdcall.} + get_url*: proc(self: ptr IHTMLMetaElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLBaseElement* {.pure.} = object + lpVtbl*: ptr IHTMLBaseElementVtbl + IHTMLBaseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLBaseElement, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLBaseElement, p: ptr BSTR): HRESULT {.stdcall.} + put_target*: proc(self: ptr IHTMLBaseElement, v: BSTR): HRESULT {.stdcall.} + get_target*: proc(self: ptr IHTMLBaseElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLBaseElement2* {.pure.} = object + lpVtbl*: ptr IHTMLBaseElement2Vtbl + IHTMLBaseElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_href*: proc(self: ptr IHTMLBaseElement2, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLBaseElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLIsIndexElement* {.pure.} = object + lpVtbl*: ptr IHTMLIsIndexElementVtbl + IHTMLIsIndexElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_prompt*: proc(self: ptr IHTMLIsIndexElement, v: BSTR): HRESULT {.stdcall.} + get_prompt*: proc(self: ptr IHTMLIsIndexElement, p: ptr BSTR): HRESULT {.stdcall.} + put_action*: proc(self: ptr IHTMLIsIndexElement, v: BSTR): HRESULT {.stdcall.} + get_action*: proc(self: ptr IHTMLIsIndexElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLIsIndexElement2* {.pure.} = object + lpVtbl*: ptr IHTMLIsIndexElement2Vtbl + IHTMLIsIndexElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_form*: proc(self: ptr IHTMLIsIndexElement2, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + IHTMLNextIdElement* {.pure.} = object + lpVtbl*: ptr IHTMLNextIdElementVtbl + IHTMLNextIdElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_n*: proc(self: ptr IHTMLNextIdElement, v: BSTR): HRESULT {.stdcall.} + get_n*: proc(self: ptr IHTMLNextIdElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLHtmlElement* {.pure.} = object + lpVtbl*: ptr DispHTMLHtmlElementVtbl + DispHTMLHtmlElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLHeadElement* {.pure.} = object + lpVtbl*: ptr DispHTMLHeadElementVtbl + DispHTMLHeadElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTitleElement* {.pure.} = object + lpVtbl*: ptr DispHTMLTitleElementVtbl + DispHTMLTitleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLMetaElement* {.pure.} = object + lpVtbl*: ptr DispHTMLMetaElementVtbl + DispHTMLMetaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLBaseElement* {.pure.} = object + lpVtbl*: ptr DispHTMLBaseElementVtbl + DispHTMLBaseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLIsIndexElement* {.pure.} = object + lpVtbl*: ptr DispHTMLIsIndexElementVtbl + DispHTMLIsIndexElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLNextIdElement* {.pure.} = object + lpVtbl*: ptr DispHTMLNextIdElementVtbl + DispHTMLNextIdElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBaseFontElement* {.pure.} = object + lpVtbl*: ptr IHTMLBaseFontElementVtbl + IHTMLBaseFontElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_color*: proc(self: ptr IHTMLBaseFontElement, v: VARIANT): HRESULT {.stdcall.} + get_color*: proc(self: ptr IHTMLBaseFontElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_face*: proc(self: ptr IHTMLBaseFontElement, v: BSTR): HRESULT {.stdcall.} + get_face*: proc(self: ptr IHTMLBaseFontElement, p: ptr BSTR): HRESULT {.stdcall.} + put_size*: proc(self: ptr IHTMLBaseFontElement, v: LONG): HRESULT {.stdcall.} + get_size*: proc(self: ptr IHTMLBaseFontElement, p: ptr LONG): HRESULT {.stdcall.} + DispHTMLBaseFontElement* {.pure.} = object + lpVtbl*: ptr DispHTMLBaseFontElementVtbl + DispHTMLBaseFontElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLUnknownElement* {.pure.} = object + lpVtbl*: ptr IHTMLUnknownElementVtbl + IHTMLUnknownElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLUnknownElement* {.pure.} = object + lpVtbl*: ptr DispHTMLUnknownElementVtbl + DispHTMLUnknownElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IWebGeolocation* {.pure.} = object + lpVtbl*: ptr IWebGeolocationVtbl + IWebGeolocationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + getCurrentPosition*: proc(self: ptr IWebGeolocation, successCallback: ptr IDispatch, errorCallback: ptr IDispatch, options: ptr IDispatch): HRESULT {.stdcall.} + watchPosition*: proc(self: ptr IWebGeolocation, successCallback: ptr IDispatch, errorCallback: ptr IDispatch, options: ptr IDispatch, watchId: ptr LONG): HRESULT {.stdcall.} + clearWatch*: proc(self: ptr IWebGeolocation, watchId: LONG): HRESULT {.stdcall.} + INavigatorGeolocation* {.pure.} = object + lpVtbl*: ptr INavigatorGeolocationVtbl + INavigatorGeolocationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_geolocation*: proc(self: ptr INavigatorGeolocation, p: ptr ptr IWebGeolocation): HRESULT {.stdcall.} + INavigatorDoNotTrack* {.pure.} = object + lpVtbl*: ptr INavigatorDoNotTrackVtbl + INavigatorDoNotTrackVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_msDoNotTrack*: proc(self: ptr INavigatorDoNotTrack, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLHistory* {.pure.} = object + lpVtbl*: ptr DispHTMLHistoryVtbl + DispHTMLHistoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispCPlugins* {.pure.} = object + lpVtbl*: ptr DispCPluginsVtbl + DispCPluginsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLNavigator* {.pure.} = object + lpVtbl*: ptr DispHTMLNavigatorVtbl + DispHTMLNavigatorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLLocation* {.pure.} = object + lpVtbl*: ptr DispHTMLLocationVtbl + DispHTMLLocationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBookmarkCollection* {.pure.} = object + lpVtbl*: ptr IHTMLBookmarkCollectionVtbl + IHTMLBookmarkCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLBookmarkCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLBookmarkCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLBookmarkCollection, index: LONG, pVarBookmark: ptr VARIANT): HRESULT {.stdcall.} + IHTMLDataTransfer* {.pure.} = object + lpVtbl*: ptr IHTMLDataTransferVtbl + IHTMLDataTransferVtbl* {.pure, inheritable.} = object of IDispatchVtbl + setData*: proc(self: ptr IHTMLDataTransfer, format: BSTR, data: ptr VARIANT, pret: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getData*: proc(self: ptr IHTMLDataTransfer, format: BSTR, pvarRet: ptr VARIANT): HRESULT {.stdcall.} + clearData*: proc(self: ptr IHTMLDataTransfer, format: BSTR, pret: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_dropEffect*: proc(self: ptr IHTMLDataTransfer, v: BSTR): HRESULT {.stdcall.} + get_dropEffect*: proc(self: ptr IHTMLDataTransfer, p: ptr BSTR): HRESULT {.stdcall.} + put_effectAllowed*: proc(self: ptr IHTMLDataTransfer, v: BSTR): HRESULT {.stdcall.} + get_effectAllowed*: proc(self: ptr IHTMLDataTransfer, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLEventObj2* {.pure.} = object + lpVtbl*: ptr IHTMLEventObj2Vtbl + IHTMLEventObj2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + setAttribute*: proc(self: ptr IHTMLEventObj2, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IHTMLEventObj2, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IHTMLEventObj2, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_propertyName*: proc(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.stdcall.} + get_propertyName*: proc(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.stdcall.} + putref_bookmarks*: proc(self: ptr IHTMLEventObj2, v: ptr IHTMLBookmarkCollection): HRESULT {.stdcall.} + get_bookmarks*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLBookmarkCollection): HRESULT {.stdcall.} + putref_recordset*: proc(self: ptr IHTMLEventObj2, v: ptr IDispatch): HRESULT {.stdcall.} + get_recordset*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_dataFld*: proc(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.stdcall.} + get_dataFld*: proc(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.stdcall.} + putref_boundElements*: proc(self: ptr IHTMLEventObj2, v: ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_boundElements*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + put_repeat*: proc(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_repeat*: proc(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_srcUrn*: proc(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.stdcall.} + get_srcUrn*: proc(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.stdcall.} + putref_srcElement*: proc(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.stdcall.} + get_srcElement*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_altKey*: proc(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_altKey*: proc(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_ctrlKey*: proc(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_ctrlKey*: proc(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_shiftKey*: proc(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_shiftKey*: proc(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + putref_fromElement*: proc(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.stdcall.} + get_fromElement*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + putref_toElement*: proc(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.stdcall.} + get_toElement*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + put_button*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_button*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.stdcall.} + put_qualifier*: proc(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.stdcall.} + get_qualifier*: proc(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.stdcall.} + put_reason*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_reason*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_x*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_x*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_y*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_y*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_clientX*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_clientX*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_clientY*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_clientY*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_offsetX*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_offsetX*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_offsetY*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_offsetY*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_screenX*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_screenX*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + put_screenY*: proc(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.stdcall.} + get_screenY*: proc(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.stdcall.} + putref_srcFilter*: proc(self: ptr IHTMLEventObj2, v: ptr IDispatch): HRESULT {.stdcall.} + get_srcFilter*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_dataTransfer*: proc(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLDataTransfer): HRESULT {.stdcall.} + IHTMLEventObj3* {.pure.} = object + lpVtbl*: ptr IHTMLEventObj3Vtbl + IHTMLEventObj3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_contentOverflow*: proc(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_shiftLeft*: proc(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_shiftLeft*: proc(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_altLeft*: proc(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_altLeft*: proc(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_ctrlLeft*: proc(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_ctrlLeft*: proc(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_imeCompositionChange*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_imeNotifyCommand*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_imeNotifyData*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_imeRequest*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_imeRequestData*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_keyboardLayout*: proc(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.stdcall.} + get_behaviorCookie*: proc(self: ptr IHTMLEventObj3, p: ptr LONG): HRESULT {.stdcall.} + get_behaviorPart*: proc(self: ptr IHTMLEventObj3, p: ptr LONG): HRESULT {.stdcall.} + get_nextPage*: proc(self: ptr IHTMLEventObj3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLEventObj4* {.pure.} = object + lpVtbl*: ptr IHTMLEventObj4Vtbl + IHTMLEventObj4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_wheelDelta*: proc(self: ptr IHTMLEventObj4, p: ptr LONG): HRESULT {.stdcall.} + IHTMLEventObj5* {.pure.} = object + lpVtbl*: ptr IHTMLEventObj5Vtbl + IHTMLEventObj5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_url*: proc(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.stdcall.} + get_url*: proc(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.stdcall.} + get_source*: proc(self: ptr IHTMLEventObj5, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_origin*: proc(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.stdcall.} + get_origin*: proc(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.stdcall.} + put_issession*: proc(self: ptr IHTMLEventObj5, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_issession*: proc(self: ptr IHTMLEventObj5, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLEventObj6* {.pure.} = object + lpVtbl*: ptr IHTMLEventObj6Vtbl + IHTMLEventObj6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_actionURL*: proc(self: ptr IHTMLEventObj6, p: ptr BSTR): HRESULT {.stdcall.} + get_buttonID*: proc(self: ptr IHTMLEventObj6, p: ptr LONG): HRESULT {.stdcall.} + DispCEventObj* {.pure.} = object + lpVtbl*: ptr DispCEventObjVtbl + DispCEventObjVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleMedia* {.pure.} = object + lpVtbl*: ptr IHTMLStyleMediaVtbl + IHTMLStyleMediaVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLStyleMedia, p: ptr BSTR): HRESULT {.stdcall.} + matchMedium*: proc(self: ptr IHTMLStyleMedia, mediaQuery: BSTR, matches: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLStyleMedia* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleMediaVtbl + DispHTMLStyleMediaVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLWindowEvents3* {.pure.} = object + lpVtbl*: ptr HTMLWindowEvents3Vtbl + HTMLWindowEvents3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLWindowEvents2* {.pure.} = object + lpVtbl*: ptr HTMLWindowEvents2Vtbl + HTMLWindowEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLWindowEvents* {.pure.} = object + lpVtbl*: ptr HTMLWindowEventsVtbl + HTMLWindowEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLScreen2* {.pure.} = object + lpVtbl*: ptr IHTMLScreen2Vtbl + IHTMLScreen2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_logicalXDPI*: proc(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.stdcall.} + get_logicalYDPI*: proc(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.stdcall.} + get_deviceXDPI*: proc(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.stdcall.} + get_deviceYDPI*: proc(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.stdcall.} + IHTMLScreen3* {.pure.} = object + lpVtbl*: ptr IHTMLScreen3Vtbl + IHTMLScreen3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_systemXDPI*: proc(self: ptr IHTMLScreen3, p: ptr LONG): HRESULT {.stdcall.} + get_systemYDPI*: proc(self: ptr IHTMLScreen3, p: ptr LONG): HRESULT {.stdcall.} + IHTMLScreen4* {.pure.} = object + lpVtbl*: ptr IHTMLScreen4Vtbl + IHTMLScreen4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_pixelDepth*: proc(self: ptr IHTMLScreen4, p: ptr LONG): HRESULT {.stdcall.} + IHTMLWindow3* {.pure.} = object + lpVtbl*: ptr IHTMLWindow3Vtbl + IHTMLWindow3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_screenLeft*: proc(self: ptr IHTMLWindow3, p: ptr LONG): HRESULT {.stdcall.} + get_screenTop*: proc(self: ptr IHTMLWindow3, p: ptr LONG): HRESULT {.stdcall.} + attachEvent*: proc(self: ptr IHTMLWindow3, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + detachEvent*: proc(self: ptr IHTMLWindow3, event: BSTR, pDisp: ptr IDispatch): HRESULT {.stdcall.} + setTimeout*: proc(self: ptr IHTMLWindow3, expression: ptr VARIANT, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.stdcall.} + setInterval*: proc(self: ptr IHTMLWindow3, expression: ptr VARIANT, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.stdcall.} + print*: proc(self: ptr IHTMLWindow3): HRESULT {.stdcall.} + put_onbeforeprint*: proc(self: ptr IHTMLWindow3, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeprint*: proc(self: ptr IHTMLWindow3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onafterprint*: proc(self: ptr IHTMLWindow3, v: VARIANT): HRESULT {.stdcall.} + get_onafterprint*: proc(self: ptr IHTMLWindow3, p: ptr VARIANT): HRESULT {.stdcall.} + get_clipboardData*: proc(self: ptr IHTMLWindow3, p: ptr ptr IHTMLDataTransfer): HRESULT {.stdcall.} + showModelessDialog*: proc(self: ptr IHTMLWindow3, url: BSTR, varArgIn: ptr VARIANT, options: ptr VARIANT, pDialog: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + IHTMLFrameBase* {.pure.} = object + lpVtbl*: ptr IHTMLFrameBaseVtbl + IHTMLFrameBaseVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.stdcall.} + put_frameBorder*: proc(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.stdcall.} + get_frameBorder*: proc(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.stdcall.} + put_frameSpacing*: proc(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.stdcall.} + get_frameSpacing*: proc(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginWidth*: proc(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.stdcall.} + get_marginWidth*: proc(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.stdcall.} + put_marginHeight*: proc(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.stdcall.} + get_marginHeight*: proc(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.stdcall.} + put_noResize*: proc(self: ptr IHTMLFrameBase, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noResize*: proc(self: ptr IHTMLFrameBase, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_scrolling*: proc(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.stdcall.} + get_scrolling*: proc(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLWindow4* {.pure.} = object + lpVtbl*: ptr IHTMLWindow4Vtbl + IHTMLWindow4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + createPopup*: proc(self: ptr IHTMLWindow4, varArgIn: ptr VARIANT, ppPopup: ptr ptr IDispatch): HRESULT {.stdcall.} + get_frameElement*: proc(self: ptr IHTMLWindow4, p: ptr ptr IHTMLFrameBase): HRESULT {.stdcall.} + IHTMLWindow5* {.pure.} = object + lpVtbl*: ptr IHTMLWindow5Vtbl + IHTMLWindow5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_XMLHttpRequest*: proc(self: ptr IHTMLWindow5, v: VARIANT): HRESULT {.stdcall.} + get_XMLHttpRequest*: proc(self: ptr IHTMLWindow5, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLStorage* {.pure.} = object + lpVtbl*: ptr IHTMLStorageVtbl + IHTMLStorageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLStorage, p: ptr LONG): HRESULT {.stdcall.} + get_remainingSpace*: proc(self: ptr IHTMLStorage, p: ptr LONG): HRESULT {.stdcall.} + key*: proc(self: ptr IHTMLStorage, lIndex: LONG, a: ptr BSTR): HRESULT {.stdcall.} + getItem*: proc(self: ptr IHTMLStorage, bstrKey: BSTR, a: ptr VARIANT): HRESULT {.stdcall.} + setItem*: proc(self: ptr IHTMLStorage, bstrKey: BSTR, bstrValue: BSTR): HRESULT {.stdcall.} + removeItem*: proc(self: ptr IHTMLStorage, bstrKey: BSTR): HRESULT {.stdcall.} + clear*: proc(self: ptr IHTMLStorage): HRESULT {.stdcall.} + IHTMLWindow6* {.pure.} = object + lpVtbl*: ptr IHTMLWindow6Vtbl + IHTMLWindow6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_XDomainRequest*: proc(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.stdcall.} + get_XDomainRequest*: proc(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.stdcall.} + get_sessionStorage*: proc(self: ptr IHTMLWindow6, p: ptr ptr IHTMLStorage): HRESULT {.stdcall.} + get_localStorage*: proc(self: ptr IHTMLWindow6, p: ptr ptr IHTMLStorage): HRESULT {.stdcall.} + put_onhashchange*: proc(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.stdcall.} + get_onhashchange*: proc(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.stdcall.} + get_maxConnectionsPerServer*: proc(self: ptr IHTMLWindow6, p: ptr LONG): HRESULT {.stdcall.} + postMessage*: proc(self: ptr IHTMLWindow6, msg: BSTR, targetOrigin: VARIANT): HRESULT {.stdcall.} + toStaticHTML*: proc(self: ptr IHTMLWindow6, bstrHTML: BSTR, pbstrStaticHTML: ptr BSTR): HRESULT {.stdcall.} + put_onmessage*: proc(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.stdcall.} + get_onmessage*: proc(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.stdcall.} + msWriteProfilerMark*: proc(self: ptr IHTMLWindow6, bstrProfilerMarkName: BSTR): HRESULT {.stdcall.} + IHTMLWindow7* {.pure.} = object + lpVtbl*: ptr IHTMLWindow7Vtbl + IHTMLWindow7Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + getSelection*: proc(self: ptr IHTMLWindow7, ppIHTMLSelection: ptr ptr IHTMLSelection): HRESULT {.stdcall.} + getComputedStyle*: proc(self: ptr IHTMLWindow7, varArgIn: ptr IHTMLDOMNode, bstrPseudoElt: BSTR, ppComputedStyle: ptr ptr IHTMLCSSStyleDeclaration): HRESULT {.stdcall.} + get_styleMedia*: proc(self: ptr IHTMLWindow7, p: ptr ptr IHTMLStyleMedia): HRESULT {.stdcall.} + put_performance*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_performance*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + get_innerWidth*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_innerHeight*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_pageXOffset*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_pageYOffset*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_screenX*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_screenY*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_outerWidth*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + get_outerHeight*: proc(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.stdcall.} + put_onabort*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onabort*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplay*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_oncanplay*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncanplaythrough*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_oncanplaythrough*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onchange*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onchange*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onclick*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onclick*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncontextmenu*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_oncontextmenu*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondblclick*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondblclick*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrag*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondrag*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragend*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondragend*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragenter*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondragenter*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragleave*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondragleave*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragover*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondragover*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondragstart*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondragstart*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondrop*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondrop*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondurationchange*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ondurationchange*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocusin*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onfocusin*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocusout*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onfocusout*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_oninput*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_oninput*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onemptied*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onemptied*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onended*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onended*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeydown*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onkeydown*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeypress*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onkeypress*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onkeyup*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onkeyup*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadeddata*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onloadeddata*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadedmetadata*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onloadedmetadata*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onloadstart*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onloadstart*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousedown*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmousedown*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseenter*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmouseenter*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseleave*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmouseleave*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousemove*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmousemove*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseout*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmouseout*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseover*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmouseover*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmouseup*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmouseup*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmousewheel*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onmousewheel*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onoffline*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onoffline*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ononline*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ononline*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onprogress*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onprogress*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onratechange*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onratechange*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreset*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onreset*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeked*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onseeked*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onseeking*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onseeking*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onselect*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onselect*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstalled*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onstalled*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstorage*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onstorage*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsubmit*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onsubmit*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onsuspend*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onsuspend*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_ontimeupdate*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_ontimeupdate*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpause*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onpause*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplay*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onplay*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onplaying*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onplaying*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onvolumechange*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onvolumechange*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + put_onwaiting*: proc(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.stdcall.} + get_onwaiting*: proc(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLApplicationCache* {.pure.} = object + lpVtbl*: ptr IHTMLApplicationCacheVtbl + IHTMLApplicationCacheVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_status*: proc(self: ptr IHTMLApplicationCache, p: ptr LONG): HRESULT {.stdcall.} + put_onchecking*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onchecking*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_onnoupdate*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onnoupdate*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondownloading*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_ondownloading*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_onprogress*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onprogress*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_onupdateready*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onupdateready*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncached*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_oncached*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + put_onobsolete*: proc(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.stdcall.} + get_onobsolete*: proc(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.stdcall.} + update*: proc(self: ptr IHTMLApplicationCache): HRESULT {.stdcall.} + swapCache*: proc(self: ptr IHTMLApplicationCache): HRESULT {.stdcall.} + abort*: proc(self: ptr IHTMLApplicationCache): HRESULT {.stdcall.} + IHTMLWindow8* {.pure.} = object + lpVtbl*: ptr IHTMLWindow8Vtbl + IHTMLWindow8Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmspointerdown*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerdown*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointermove*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointermove*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerup*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerup*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerover*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerover*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerout*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerout*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointercancel*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointercancel*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerhover*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerhover*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturestart*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturestart*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturechange*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturechange*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgestureend*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgestureend*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturehold*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturehold*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturetap*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturetap*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturedoubletap*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturedoubletap*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsinertiastart*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onmsinertiastart*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + get_applicationCache*: proc(self: ptr IHTMLWindow8, p: ptr ptr IHTMLApplicationCache): HRESULT {.stdcall.} + put_onpopstate*: proc(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.stdcall.} + get_onpopstate*: proc(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLScreen* {.pure.} = object + lpVtbl*: ptr DispHTMLScreenVtbl + DispHTMLScreenVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLWindow2* {.pure.} = object + lpVtbl*: ptr DispHTMLWindow2Vtbl + DispHTMLWindow2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLWindowProxy* {.pure.} = object + lpVtbl*: ptr DispHTMLWindowProxyVtbl + DispHTMLWindowProxyVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDocumentCompatibleInfo* {.pure.} = object + lpVtbl*: ptr IHTMLDocumentCompatibleInfoVtbl + IHTMLDocumentCompatibleInfoVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_userAgent*: proc(self: ptr IHTMLDocumentCompatibleInfo, p: ptr BSTR): HRESULT {.stdcall.} + get_version*: proc(self: ptr IHTMLDocumentCompatibleInfo, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLDocumentCompatibleInfoCollection* {.pure.} = object + lpVtbl*: ptr IHTMLDocumentCompatibleInfoCollectionVtbl + IHTMLDocumentCompatibleInfoCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLDocumentCompatibleInfoCollection, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLDocumentCompatibleInfoCollection, index: LONG, compatibleInfo: ptr ptr IHTMLDocumentCompatibleInfo): HRESULT {.stdcall.} + DispHTMLDocumentCompatibleInfo* {.pure.} = object + lpVtbl*: ptr DispHTMLDocumentCompatibleInfoVtbl + DispHTMLDocumentCompatibleInfoVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLDocumentCompatibleInfoCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLDocumentCompatibleInfoCollectionVtbl + DispHTMLDocumentCompatibleInfoCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLDocumentEvents4* {.pure.} = object + lpVtbl*: ptr HTMLDocumentEvents4Vtbl + HTMLDocumentEvents4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLDocumentEvents3* {.pure.} = object + lpVtbl*: ptr HTMLDocumentEvents3Vtbl + HTMLDocumentEvents3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLDocumentEvents2* {.pure.} = object + lpVtbl*: ptr HTMLDocumentEvents2Vtbl + HTMLDocumentEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLDocumentEvents* {.pure.} = object + lpVtbl*: ptr HTMLDocumentEventsVtbl + HTMLDocumentEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDocument3* {.pure.} = object + lpVtbl*: ptr IHTMLDocument3Vtbl + IHTMLDocument3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + releaseCapture*: proc(self: ptr IHTMLDocument3): HRESULT {.stdcall.} + recalc*: proc(self: ptr IHTMLDocument3, fForce: VARIANT_BOOL): HRESULT {.stdcall.} + createTextNode*: proc(self: ptr IHTMLDocument3, text: BSTR, newTextNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_documentElement*: proc(self: ptr IHTMLDocument3, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_uniqueID*: proc(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.stdcall.} + attachEvent*: proc(self: ptr IHTMLDocument3, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + detachEvent*: proc(self: ptr IHTMLDocument3, event: BSTR, pDisp: ptr IDispatch): HRESULT {.stdcall.} + put_onrowsdelete*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_onrowsdelete*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onrowsinserted*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_onrowsinserted*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_oncellchange*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_oncellchange*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondatasetchanged*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_ondatasetchanged*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondataavailable*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_ondataavailable*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondatasetcomplete*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_ondatasetcomplete*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onpropertychange*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_onpropertychange*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_dir*: proc(self: ptr IHTMLDocument3, v: BSTR): HRESULT {.stdcall.} + get_dir*: proc(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.stdcall.} + put_oncontextmenu*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_oncontextmenu*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstop*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_onstop*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + createDocumentFragment*: proc(self: ptr IHTMLDocument3, pNewDoc: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + get_parentDocument*: proc(self: ptr IHTMLDocument3, p: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + put_enableDownload*: proc(self: ptr IHTMLDocument3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_enableDownload*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_baseUrl*: proc(self: ptr IHTMLDocument3, v: BSTR): HRESULT {.stdcall.} + get_baseUrl*: proc(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr IHTMLDocument3, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_inheritStyleSheets*: proc(self: ptr IHTMLDocument3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_inheritStyleSheets*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onbeforeeditfocus*: proc(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeeditfocus*: proc(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.stdcall.} + getElementsByName*: proc(self: ptr IHTMLDocument3, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + getElementById*: proc(self: ptr IHTMLDocument3, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.stdcall.} + getElementsByTagName*: proc(self: ptr IHTMLDocument3, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + IHTMLDocument4* {.pure.} = object + lpVtbl*: ptr IHTMLDocument4Vtbl + IHTMLDocument4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + focus*: proc(self: ptr IHTMLDocument4): HRESULT {.stdcall.} + hasFocus*: proc(self: ptr IHTMLDocument4, pfFocus: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onselectionchange*: proc(self: ptr IHTMLDocument4, v: VARIANT): HRESULT {.stdcall.} + get_onselectionchange*: proc(self: ptr IHTMLDocument4, p: ptr VARIANT): HRESULT {.stdcall.} + get_namespaces*: proc(self: ptr IHTMLDocument4, p: ptr ptr IDispatch): HRESULT {.stdcall.} + createDocumentFromUrl*: proc(self: ptr IHTMLDocument4, bstrUrl: BSTR, bstrOptions: BSTR, newDoc: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLDocument4, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLDocument4, p: ptr BSTR): HRESULT {.stdcall.} + createEventObject*: proc(self: ptr IHTMLDocument4, pvarEventObject: ptr VARIANT, ppEventObj: ptr ptr IHTMLEventObj): HRESULT {.stdcall.} + fireEvent*: proc(self: ptr IHTMLDocument4, bstrEventName: BSTR, pvarEventObject: ptr VARIANT, pfCancelled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + createRenderStyle*: proc(self: ptr IHTMLDocument4, v: BSTR, ppIHTMLRenderStyle: ptr ptr IHTMLRenderStyle): HRESULT {.stdcall.} + put_oncontrolselect*: proc(self: ptr IHTMLDocument4, v: VARIANT): HRESULT {.stdcall.} + get_oncontrolselect*: proc(self: ptr IHTMLDocument4, p: ptr VARIANT): HRESULT {.stdcall.} + get_URLUnencoded*: proc(self: ptr IHTMLDocument4, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLDocument5* {.pure.} = object + lpVtbl*: ptr IHTMLDocument5Vtbl + IHTMLDocument5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmousewheel*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onmousewheel*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + get_doctype*: proc(self: ptr IHTMLDocument5, p: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + get_implementation*: proc(self: ptr IHTMLDocument5, p: ptr ptr IHTMLDOMImplementation): HRESULT {.stdcall.} + createAttribute*: proc(self: ptr IHTMLDocument5, bstrattrName: BSTR, ppattribute: ptr ptr IHTMLDOMAttribute): HRESULT {.stdcall.} + createComment*: proc(self: ptr IHTMLDocument5, bstrdata: BSTR, ppRetNode: ptr ptr IHTMLDOMNode): HRESULT {.stdcall.} + put_onfocusin*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onfocusin*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocusout*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onfocusout*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + put_onactivate*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onactivate*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + put_ondeactivate*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_ondeactivate*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforeactivate*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeactivate*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforedeactivate*: proc(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.stdcall.} + get_onbeforedeactivate*: proc(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.stdcall.} + get_compatMode*: proc(self: ptr IHTMLDocument5, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLDocument6* {.pure.} = object + lpVtbl*: ptr IHTMLDocument6Vtbl + IHTMLDocument6Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_compatible*: proc(self: ptr IHTMLDocument6, p: ptr ptr IHTMLDocumentCompatibleInfoCollection): HRESULT {.stdcall.} + get_documentMode*: proc(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstorage*: proc(self: ptr IHTMLDocument6, v: VARIANT): HRESULT {.stdcall.} + get_onstorage*: proc(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstoragecommit*: proc(self: ptr IHTMLDocument6, v: VARIANT): HRESULT {.stdcall.} + get_onstoragecommit*: proc(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.stdcall.} + getElementById*: proc(self: ptr IHTMLDocument6, bstrId: BSTR, ppRetElement: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + updateSettings*: proc(self: ptr IHTMLDocument6): HRESULT {.stdcall.} + IHTMLDocument8* {.pure.} = object + lpVtbl*: ptr IHTMLDocument8Vtbl + IHTMLDocument8Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onmscontentzoom*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmscontentzoom*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerdown*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerdown*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointermove*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointermove*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerup*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerup*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerover*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerover*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerout*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerout*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointercancel*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointercancel*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmspointerhover*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmspointerhover*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturestart*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturestart*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturechange*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturechange*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgestureend*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgestureend*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturehold*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturehold*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturetap*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturetap*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsgesturedoubletap*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsgesturedoubletap*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmsinertiastart*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsinertiastart*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + elementsFromPoint*: proc(self: ptr IHTMLDocument8, x: float32, y: float32, elementsHit: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.stdcall.} + elementsFromRect*: proc(self: ptr IHTMLDocument8, left: float32, top: float32, width: float32, height: float32, elementsHit: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.stdcall.} + put_onmsmanipulationstatechanged*: proc(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.stdcall.} + get_onmsmanipulationstatechanged*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.stdcall.} + put_msCapsLockWarningOff*: proc(self: ptr IHTMLDocument8, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_msCapsLockWarningOff*: proc(self: ptr IHTMLDocument8, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IEventTarget* {.pure.} = object + lpVtbl*: ptr IEventTargetVtbl + IEventTargetVtbl* {.pure, inheritable.} = object of IDispatchVtbl + addEventListener*: proc(self: ptr IEventTarget, `type`: BSTR, listener: ptr IDispatch, useCapture: VARIANT_BOOL): HRESULT {.stdcall.} + removeEventListener*: proc(self: ptr IEventTarget, `type`: BSTR, listener: ptr IDispatch, useCapture: VARIANT_BOOL): HRESULT {.stdcall.} + dispatchEvent*: proc(self: ptr IEventTarget, evt: ptr IDOMEvent, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IDOMEvent* {.pure.} = object + lpVtbl*: ptr IDOMEventVtbl + IDOMEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_bubbles*: proc(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_cancelable*: proc(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_currentTarget*: proc(self: ptr IDOMEvent, p: ptr ptr IEventTarget): HRESULT {.stdcall.} + get_defaultPrevented*: proc(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_eventPhase*: proc(self: ptr IDOMEvent, p: ptr USHORT): HRESULT {.stdcall.} + get_target*: proc(self: ptr IDOMEvent, p: ptr ptr IEventTarget): HRESULT {.stdcall.} + get_timeStamp*: proc(self: ptr IDOMEvent, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_type*: proc(self: ptr IDOMEvent, p: ptr BSTR): HRESULT {.stdcall.} + initEvent*: proc(self: ptr IDOMEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL): HRESULT {.stdcall.} + preventDefault*: proc(self: ptr IDOMEvent): HRESULT {.stdcall.} + stopPropagation*: proc(self: ptr IDOMEvent): HRESULT {.stdcall.} + stopImmediatePropagation*: proc(self: ptr IDOMEvent): HRESULT {.stdcall.} + get_isTrusted*: proc(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_cancelBubble*: proc(self: ptr IDOMEvent, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_cancelBubble*: proc(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_srcElement*: proc(self: ptr IDOMEvent, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + IDocumentEvent* {.pure.} = object + lpVtbl*: ptr IDocumentEventVtbl + IDocumentEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + createEvent*: proc(self: ptr IDocumentEvent, eventType: BSTR, ppEvent: ptr ptr IDOMEvent): HRESULT {.stdcall.} + IDocumentRange* {.pure.} = object + lpVtbl*: ptr IDocumentRangeVtbl + IDocumentRangeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + createRange*: proc(self: ptr IDocumentRange, ppIHTMLDOMRange: ptr ptr IHTMLDOMRange): HRESULT {.stdcall.} + IDocumentSelector* {.pure.} = object + lpVtbl*: ptr IDocumentSelectorVtbl + IDocumentSelectorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + querySelector*: proc(self: ptr IDocumentSelector, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.stdcall.} + querySelectorAll*: proc(self: ptr IDocumentSelector, v: BSTR, pel: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.stdcall.} + IDOMNodeIterator* {.pure.} = object + lpVtbl*: ptr IDOMNodeIteratorVtbl + IDOMNodeIteratorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_root*: proc(self: ptr IDOMNodeIterator, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_whatToShow*: proc(self: ptr IDOMNodeIterator, p: ptr ULONG): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IDOMNodeIterator, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_expandEntityReferences*: proc(self: ptr IDOMNodeIterator, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + nextNode*: proc(self: ptr IDOMNodeIterator, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + previousNode*: proc(self: ptr IDOMNodeIterator, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + detach*: proc(self: ptr IDOMNodeIterator): HRESULT {.stdcall.} + IDOMTreeWalker* {.pure.} = object + lpVtbl*: ptr IDOMTreeWalkerVtbl + IDOMTreeWalkerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_root*: proc(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_whatToShow*: proc(self: ptr IDOMTreeWalker, p: ptr ULONG): HRESULT {.stdcall.} + get_filter*: proc(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_expandEntityReferences*: proc(self: ptr IDOMTreeWalker, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + putref_currentNode*: proc(self: ptr IDOMTreeWalker, v: ptr IDispatch): HRESULT {.stdcall.} + get_currentNode*: proc(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.stdcall.} + parentNode*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + firstChild*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + lastChild*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + previousSibling*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + nextSibling*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + previousNode*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + nextNode*: proc(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.stdcall.} + IDocumentTraversal* {.pure.} = object + lpVtbl*: ptr IDocumentTraversalVtbl + IDocumentTraversalVtbl* {.pure, inheritable.} = object of IDispatchVtbl + createNodeIterator*: proc(self: ptr IDocumentTraversal, pRootNode: ptr IDispatch, ulWhatToShow: LONG, pFilter: ptr VARIANT, fEntityReferenceExpansion: VARIANT_BOOL, ppNodeIterator: ptr ptr IDOMNodeIterator): HRESULT {.stdcall.} + createTreeWalker*: proc(self: ptr IDocumentTraversal, pRootNode: ptr IDispatch, ulWhatToShow: LONG, pFilter: ptr VARIANT, fEntityReferenceExpansion: VARIANT_BOOL, ppTreeWalker: ptr ptr IDOMTreeWalker): HRESULT {.stdcall.} + DispHTMLDocument* {.pure.} = object + lpVtbl*: ptr DispHTMLDocumentVtbl + DispHTMLDocumentVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DWebBridgeEvents* {.pure.} = object + lpVtbl*: ptr DWebBridgeEventsVtbl + DWebBridgeEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IWebBridge* {.pure.} = object + lpVtbl*: ptr IWebBridgeVtbl + IWebBridgeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_URL*: proc(self: ptr IWebBridge, v: BSTR): HRESULT {.stdcall.} + get_URL*: proc(self: ptr IWebBridge, p: ptr BSTR): HRESULT {.stdcall.} + put_Scrollbar*: proc(self: ptr IWebBridge, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_Scrollbar*: proc(self: ptr IWebBridge, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_embed*: proc(self: ptr IWebBridge, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_embed*: proc(self: ptr IWebBridge, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_event*: proc(self: ptr IWebBridge, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IWebBridge, p: ptr LONG): HRESULT {.stdcall.} + AboutBox*: proc(self: ptr IWebBridge): HRESULT {.stdcall.} + IWBScriptControl* {.pure.} = object + lpVtbl*: ptr IWBScriptControlVtbl + IWBScriptControlVtbl* {.pure, inheritable.} = object of IDispatchVtbl + raiseEvent*: proc(self: ptr IWBScriptControl, name: BSTR, eventData: VARIANT): HRESULT {.stdcall.} + bubbleEvent*: proc(self: ptr IWBScriptControl): HRESULT {.stdcall.} + setContextMenu*: proc(self: ptr IWBScriptControl, menuItemPairs: VARIANT): HRESULT {.stdcall.} + put_selectableContent*: proc(self: ptr IWBScriptControl, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_selectableContent*: proc(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_frozen*: proc(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_scrollbar*: proc(self: ptr IWBScriptControl, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_scrollbar*: proc(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_version*: proc(self: ptr IWBScriptControl, p: ptr BSTR): HRESULT {.stdcall.} + get_visibility*: proc(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_onvisibilitychange*: proc(self: ptr IWBScriptControl, v: VARIANT): HRESULT {.stdcall.} + get_onvisibilitychange*: proc(self: ptr IWBScriptControl, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLEmbedElement* {.pure.} = object + lpVtbl*: ptr IHTMLEmbedElementVtbl + IHTMLEmbedElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_hidden*: proc(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.stdcall.} + get_hidden*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + get_palette*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + get_pluginspage*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + put_units*: proc(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.stdcall.} + get_units*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLEmbedElement, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLEmbedElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLEmbedElement, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLEmbedElement, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLEmbedElement2* {.pure.} = object + lpVtbl*: ptr IHTMLEmbedElement2Vtbl + IHTMLEmbedElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLEmbedElement2, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLEmbedElement2, p: ptr BSTR): HRESULT {.stdcall.} + get_pluginspage*: proc(self: ptr IHTMLEmbedElement2, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLEmbed* {.pure.} = object + lpVtbl*: ptr DispHTMLEmbedVtbl + DispHTMLEmbedVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLMapEvents2* {.pure.} = object + lpVtbl*: ptr HTMLMapEvents2Vtbl + HTMLMapEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLMapEvents* {.pure.} = object + lpVtbl*: ptr HTMLMapEventsVtbl + HTMLMapEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLAreasCollection* {.pure.} = object + lpVtbl*: ptr IHTMLAreasCollectionVtbl + IHTMLAreasCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_length*: proc(self: ptr IHTMLAreasCollection, v: LONG): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLAreasCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLAreasCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLAreasCollection, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + tags*: proc(self: ptr IHTMLAreasCollection, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + add*: proc(self: ptr IHTMLAreasCollection, element: ptr IHTMLElement, before: VARIANT): HRESULT {.stdcall.} + remove*: proc(self: ptr IHTMLAreasCollection, index: LONG): HRESULT {.stdcall.} + IHTMLAreasCollection2* {.pure.} = object + lpVtbl*: ptr IHTMLAreasCollection2Vtbl + IHTMLAreasCollection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + urns*: proc(self: ptr IHTMLAreasCollection2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLAreasCollection3* {.pure.} = object + lpVtbl*: ptr IHTMLAreasCollection3Vtbl + IHTMLAreasCollection3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + namedItem*: proc(self: ptr IHTMLAreasCollection3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLAreasCollection4* {.pure.} = object + lpVtbl*: ptr IHTMLAreasCollection4Vtbl + IHTMLAreasCollection4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLAreasCollection4, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLAreasCollection4, index: LONG, pNode: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + namedItem*: proc(self: ptr IHTMLAreasCollection4, name: BSTR, pNode: ptr ptr IHTMLElement2): HRESULT {.stdcall.} + IHTMLMapElement* {.pure.} = object + lpVtbl*: ptr IHTMLMapElementVtbl + IHTMLMapElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_areas*: proc(self: ptr IHTMLMapElement, p: ptr ptr IHTMLAreasCollection): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLMapElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLMapElement, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLAreasCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLAreasCollectionVtbl + DispHTMLAreasCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLMapElement* {.pure.} = object + lpVtbl*: ptr DispHTMLMapElementVtbl + DispHTMLMapElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLAreaEvents2* {.pure.} = object + lpVtbl*: ptr HTMLAreaEvents2Vtbl + HTMLAreaEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLAreaEvents* {.pure.} = object + lpVtbl*: ptr HTMLAreaEventsVtbl + HTMLAreaEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLAreaElement* {.pure.} = object + lpVtbl*: ptr IHTMLAreaElementVtbl + IHTMLAreaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_shape*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_shape*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_coords*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_coords*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_href*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_target*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_target*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_noHref*: proc(self: ptr IHTMLAreaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noHref*: proc(self: ptr IHTMLAreaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_host*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_host*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_hostname*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_hostname*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_pathname*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_pathname*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_port*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_port*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_protocol*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_protocol*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_search*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_search*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_hash*: proc(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.stdcall.} + get_hash*: proc(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onblur*: proc(self: ptr IHTMLAreaElement, v: VARIANT): HRESULT {.stdcall.} + get_onblur*: proc(self: ptr IHTMLAreaElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onfocus*: proc(self: ptr IHTMLAreaElement, v: VARIANT): HRESULT {.stdcall.} + get_onfocus*: proc(self: ptr IHTMLAreaElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_tabIndex*: proc(self: ptr IHTMLAreaElement, v: int16): HRESULT {.stdcall.} + get_tabIndex*: proc(self: ptr IHTMLAreaElement, p: ptr int16): HRESULT {.stdcall.} + focus*: proc(self: ptr IHTMLAreaElement): HRESULT {.stdcall.} + blur*: proc(self: ptr IHTMLAreaElement): HRESULT {.stdcall.} + IHTMLAreaElement2* {.pure.} = object + lpVtbl*: ptr IHTMLAreaElement2Vtbl + IHTMLAreaElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_shape*: proc(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.stdcall.} + get_shape*: proc(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_coords*: proc(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.stdcall.} + get_coords*: proc(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_href*: proc(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.stdcall.} + get_href*: proc(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLAreaElement* {.pure.} = object + lpVtbl*: ptr DispHTMLAreaElementVtbl + DispHTMLAreaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLTableCaption* {.pure.} = object + lpVtbl*: ptr IHTMLTableCaptionVtbl + IHTMLTableCaptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLTableCaption, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTableCaption, p: ptr BSTR): HRESULT {.stdcall.} + put_vAlign*: proc(self: ptr IHTMLTableCaption, v: BSTR): HRESULT {.stdcall.} + get_vAlign*: proc(self: ptr IHTMLTableCaption, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLTableCaption* {.pure.} = object + lpVtbl*: ptr DispHTMLTableCaptionVtbl + DispHTMLTableCaptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLCommentElement* {.pure.} = object + lpVtbl*: ptr IHTMLCommentElementVtbl + IHTMLCommentElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_text*: proc(self: ptr IHTMLCommentElement, v: BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLCommentElement, p: ptr BSTR): HRESULT {.stdcall.} + put_atomic*: proc(self: ptr IHTMLCommentElement, v: LONG): HRESULT {.stdcall.} + get_atomic*: proc(self: ptr IHTMLCommentElement, p: ptr LONG): HRESULT {.stdcall.} + IHTMLCommentElement2* {.pure.} = object + lpVtbl*: ptr IHTMLCommentElement2Vtbl + IHTMLCommentElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_data*: proc(self: ptr IHTMLCommentElement2, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLCommentElement2, p: ptr BSTR): HRESULT {.stdcall.} + get_length*: proc(self: ptr IHTMLCommentElement2, p: ptr LONG): HRESULT {.stdcall.} + substringData*: proc(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.stdcall.} + appendData*: proc(self: ptr IHTMLCommentElement2, bstrstring: BSTR): HRESULT {.stdcall.} + insertData*: proc(self: ptr IHTMLCommentElement2, offset: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + deleteData*: proc(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG): HRESULT {.stdcall.} + replaceData*: proc(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + IHTMLCommentElement3* {.pure.} = object + lpVtbl*: ptr IHTMLCommentElement3Vtbl + IHTMLCommentElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + substringData*: proc(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.stdcall.} + insertData*: proc(self: ptr IHTMLCommentElement3, offset: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + deleteData*: proc(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG): HRESULT {.stdcall.} + replaceData*: proc(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.stdcall.} + DispHTMLCommentElement* {.pure.} = object + lpVtbl*: ptr DispHTMLCommentElementVtbl + DispHTMLCommentElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLPhraseElement* {.pure.} = object + lpVtbl*: ptr IHTMLPhraseElementVtbl + IHTMLPhraseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLPhraseElement2* {.pure.} = object + lpVtbl*: ptr IHTMLPhraseElement2Vtbl + IHTMLPhraseElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_cite*: proc(self: ptr IHTMLPhraseElement2, v: BSTR): HRESULT {.stdcall.} + get_cite*: proc(self: ptr IHTMLPhraseElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_dateTime*: proc(self: ptr IHTMLPhraseElement2, v: BSTR): HRESULT {.stdcall.} + get_dateTime*: proc(self: ptr IHTMLPhraseElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLPhraseElement3* {.pure.} = object + lpVtbl*: ptr IHTMLPhraseElement3Vtbl + IHTMLPhraseElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_cite*: proc(self: ptr IHTMLPhraseElement3, v: BSTR): HRESULT {.stdcall.} + get_cite*: proc(self: ptr IHTMLPhraseElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLSpanElement* {.pure.} = object + lpVtbl*: ptr IHTMLSpanElementVtbl + IHTMLSpanElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLPhraseElement* {.pure.} = object + lpVtbl*: ptr DispHTMLPhraseElementVtbl + DispHTMLPhraseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLSpanElement* {.pure.} = object + lpVtbl*: ptr DispHTMLSpanElementVtbl + DispHTMLSpanElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLTableEvents2* {.pure.} = object + lpVtbl*: ptr HTMLTableEvents2Vtbl + HTMLTableEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLTableEvents* {.pure.} = object + lpVtbl*: ptr HTMLTableEventsVtbl + HTMLTableEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLTableSection* {.pure.} = object + lpVtbl*: ptr IHTMLTableSectionVtbl + IHTMLTableSectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLTableSection, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTableSection, p: ptr BSTR): HRESULT {.stdcall.} + put_vAlign*: proc(self: ptr IHTMLTableSection, v: BSTR): HRESULT {.stdcall.} + get_vAlign*: proc(self: ptr IHTMLTableSection, p: ptr BSTR): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLTableSection, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLTableSection, p: ptr VARIANT): HRESULT {.stdcall.} + get_rows*: proc(self: ptr IHTMLTableSection, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + insertRow*: proc(self: ptr IHTMLTableSection, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteRow*: proc(self: ptr IHTMLTableSection, index: LONG): HRESULT {.stdcall.} + IHTMLTable* {.pure.} = object + lpVtbl*: ptr IHTMLTableVtbl + IHTMLTableVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_cols*: proc(self: ptr IHTMLTable, v: LONG): HRESULT {.stdcall.} + get_cols*: proc(self: ptr IHTMLTable, p: ptr LONG): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_frame*: proc(self: ptr IHTMLTable, v: BSTR): HRESULT {.stdcall.} + get_frame*: proc(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.stdcall.} + put_rules*: proc(self: ptr IHTMLTable, v: BSTR): HRESULT {.stdcall.} + get_rules*: proc(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.stdcall.} + put_cellSpacing*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_cellSpacing*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_cellPadding*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_cellPadding*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_background*: proc(self: ptr IHTMLTable, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorLight*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_borderColorLight*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorDark*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_borderColorDark*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLTable, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.stdcall.} + refresh*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + get_rows*: proc(self: ptr IHTMLTable, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + put_dataPageSize*: proc(self: ptr IHTMLTable, v: LONG): HRESULT {.stdcall.} + get_dataPageSize*: proc(self: ptr IHTMLTable, p: ptr LONG): HRESULT {.stdcall.} + nextPage*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + previousPage*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + get_tHead*: proc(self: ptr IHTMLTable, p: ptr ptr IHTMLTableSection): HRESULT {.stdcall.} + get_tFoot*: proc(self: ptr IHTMLTable, p: ptr ptr IHTMLTableSection): HRESULT {.stdcall.} + get_tBodies*: proc(self: ptr IHTMLTable, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + get_caption*: proc(self: ptr IHTMLTable, p: ptr ptr IHTMLTableCaption): HRESULT {.stdcall.} + createTHead*: proc(self: ptr IHTMLTable, head: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteTHead*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + createTFoot*: proc(self: ptr IHTMLTable, foot: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteTFoot*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + createCaption*: proc(self: ptr IHTMLTable, caption: ptr ptr IHTMLTableCaption): HRESULT {.stdcall.} + deleteCaption*: proc(self: ptr IHTMLTable): HRESULT {.stdcall.} + insertRow*: proc(self: ptr IHTMLTable, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteRow*: proc(self: ptr IHTMLTable, index: LONG): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLTable, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLTable2* {.pure.} = object + lpVtbl*: ptr IHTMLTable2Vtbl + IHTMLTable2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + firstPage*: proc(self: ptr IHTMLTable2): HRESULT {.stdcall.} + lastPage*: proc(self: ptr IHTMLTable2): HRESULT {.stdcall.} + get_cells*: proc(self: ptr IHTMLTable2, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + moveRow*: proc(self: ptr IHTMLTable2, indexFrom: LONG, indexTo: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLTable3* {.pure.} = object + lpVtbl*: ptr IHTMLTable3Vtbl + IHTMLTable3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_summary*: proc(self: ptr IHTMLTable3, v: BSTR): HRESULT {.stdcall.} + get_summary*: proc(self: ptr IHTMLTable3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTable4* {.pure.} = object + lpVtbl*: ptr IHTMLTable4Vtbl + IHTMLTable4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_tHead*: proc(self: ptr IHTMLTable4, v: ptr IHTMLTableSection): HRESULT {.stdcall.} + get_tHead*: proc(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableSection): HRESULT {.stdcall.} + putref_tFoot*: proc(self: ptr IHTMLTable4, v: ptr IHTMLTableSection): HRESULT {.stdcall.} + get_tFoot*: proc(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableSection): HRESULT {.stdcall.} + putref_caption*: proc(self: ptr IHTMLTable4, v: ptr IHTMLTableCaption): HRESULT {.stdcall.} + get_caption*: proc(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableCaption): HRESULT {.stdcall.} + insertRow*: proc(self: ptr IHTMLTable4, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteRow*: proc(self: ptr IHTMLTable4, index: LONG): HRESULT {.stdcall.} + createTBody*: proc(self: ptr IHTMLTable4, tbody: ptr ptr IHTMLTableSection): HRESULT {.stdcall.} + IHTMLTableCol* {.pure.} = object + lpVtbl*: ptr IHTMLTableColVtbl + IHTMLTableColVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_span*: proc(self: ptr IHTMLTableCol, v: LONG): HRESULT {.stdcall.} + get_span*: proc(self: ptr IHTMLTableCol, p: ptr LONG): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLTableCol, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLTableCol, p: ptr VARIANT): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLTableCol, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTableCol, p: ptr BSTR): HRESULT {.stdcall.} + put_vAlign*: proc(self: ptr IHTMLTableCol, v: BSTR): HRESULT {.stdcall.} + get_vAlign*: proc(self: ptr IHTMLTableCol, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableCol2* {.pure.} = object + lpVtbl*: ptr IHTMLTableCol2Vtbl + IHTMLTableCol2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableCol2, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableCol2, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableCol2, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableCol2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableCol3* {.pure.} = object + lpVtbl*: ptr IHTMLTableCol3Vtbl + IHTMLTableCol3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableCol3, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableCol3, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableCol3, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableCol3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableSection2* {.pure.} = object + lpVtbl*: ptr IHTMLTableSection2Vtbl + IHTMLTableSection2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + moveRow*: proc(self: ptr IHTMLTableSection2, indexFrom: LONG, indexTo: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLTableSection3* {.pure.} = object + lpVtbl*: ptr IHTMLTableSection3Vtbl + IHTMLTableSection3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableSection3, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableSection3, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableSection3, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableSection3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableSection4* {.pure.} = object + lpVtbl*: ptr IHTMLTableSection4Vtbl + IHTMLTableSection4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableSection4, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableSection4, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableSection4, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableSection4, p: ptr BSTR): HRESULT {.stdcall.} + insertRow*: proc(self: ptr IHTMLTableSection4, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteRow*: proc(self: ptr IHTMLTableSection4, index: LONG): HRESULT {.stdcall.} + IHTMLTableRow* {.pure.} = object + lpVtbl*: ptr IHTMLTableRowVtbl + IHTMLTableRowVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLTableRow, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTableRow, p: ptr BSTR): HRESULT {.stdcall.} + put_vAlign*: proc(self: ptr IHTMLTableRow, v: BSTR): HRESULT {.stdcall.} + get_vAlign*: proc(self: ptr IHTMLTableRow, p: ptr BSTR): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorLight*: proc(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.stdcall.} + get_borderColorLight*: proc(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorDark*: proc(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.stdcall.} + get_borderColorDark*: proc(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.stdcall.} + get_rowIndex*: proc(self: ptr IHTMLTableRow, p: ptr LONG): HRESULT {.stdcall.} + get_sectionRowIndex*: proc(self: ptr IHTMLTableRow, p: ptr LONG): HRESULT {.stdcall.} + get_cells*: proc(self: ptr IHTMLTableRow, p: ptr ptr IHTMLElementCollection): HRESULT {.stdcall.} + insertCell*: proc(self: ptr IHTMLTableRow, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteCell*: proc(self: ptr IHTMLTableRow, index: LONG): HRESULT {.stdcall.} + IHTMLTableRow2* {.pure.} = object + lpVtbl*: ptr IHTMLTableRow2Vtbl + IHTMLTableRow2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_height*: proc(self: ptr IHTMLTableRow2, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLTableRow2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLTableRow3* {.pure.} = object + lpVtbl*: ptr IHTMLTableRow3Vtbl + IHTMLTableRow3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableRow3, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableRow3, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableRow3, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableRow3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableRow4* {.pure.} = object + lpVtbl*: ptr IHTMLTableRow4Vtbl + IHTMLTableRow4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableRow4, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableRow4, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableRow4, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableRow4, p: ptr BSTR): HRESULT {.stdcall.} + insertCell*: proc(self: ptr IHTMLTableRow4, index: LONG, row: ptr ptr IDispatch): HRESULT {.stdcall.} + deleteCell*: proc(self: ptr IHTMLTableRow4, index: LONG): HRESULT {.stdcall.} + IHTMLTableRowMetrics* {.pure.} = object + lpVtbl*: ptr IHTMLTableRowMetricsVtbl + IHTMLTableRowMetricsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_clientHeight*: proc(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_clientWidth*: proc(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_clientTop*: proc(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.stdcall.} + get_clientLeft*: proc(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.stdcall.} + IHTMLTableCell* {.pure.} = object + lpVtbl*: ptr IHTMLTableCellVtbl + IHTMLTableCellVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_rowSpan*: proc(self: ptr IHTMLTableCell, v: LONG): HRESULT {.stdcall.} + get_rowSpan*: proc(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.stdcall.} + put_colSpan*: proc(self: ptr IHTMLTableCell, v: LONG): HRESULT {.stdcall.} + get_colSpan*: proc(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.stdcall.} + put_vAlign*: proc(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.stdcall.} + get_vAlign*: proc(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.stdcall.} + put_bgColor*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_bgColor*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + put_noWrap*: proc(self: ptr IHTMLTableCell, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_noWrap*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_background*: proc(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.stdcall.} + get_background*: proc(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorLight*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_borderColorLight*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColorDark*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_borderColorDark*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.stdcall.} + get_cellIndex*: proc(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.stdcall.} + IHTMLTableCell2* {.pure.} = object + lpVtbl*: ptr IHTMLTableCell2Vtbl + IHTMLTableCell2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_abbr*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_abbr*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + put_axis*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_axis*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + put_ch*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + put_headers*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_headers*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + put_scope*: proc(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.stdcall.} + get_scope*: proc(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLTableCell3* {.pure.} = object + lpVtbl*: ptr IHTMLTableCell3Vtbl + IHTMLTableCell3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_ch*: proc(self: ptr IHTMLTableCell3, v: BSTR): HRESULT {.stdcall.} + get_ch*: proc(self: ptr IHTMLTableCell3, p: ptr BSTR): HRESULT {.stdcall.} + put_chOff*: proc(self: ptr IHTMLTableCell3, v: BSTR): HRESULT {.stdcall.} + get_chOff*: proc(self: ptr IHTMLTableCell3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLTable* {.pure.} = object + lpVtbl*: ptr DispHTMLTableVtbl + DispHTMLTableVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTableCol* {.pure.} = object + lpVtbl*: ptr DispHTMLTableColVtbl + DispHTMLTableColVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTableSection* {.pure.} = object + lpVtbl*: ptr DispHTMLTableSectionVtbl + DispHTMLTableSectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTableRow* {.pure.} = object + lpVtbl*: ptr DispHTMLTableRowVtbl + DispHTMLTableRowVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTableCell* {.pure.} = object + lpVtbl*: ptr DispHTMLTableCellVtbl + DispHTMLTableCellVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLScriptEvents2* {.pure.} = object + lpVtbl*: ptr HTMLScriptEvents2Vtbl + HTMLScriptEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLScriptEvents* {.pure.} = object + lpVtbl*: ptr HTMLScriptEventsVtbl + HTMLScriptEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLScriptElement* {.pure.} = object + lpVtbl*: ptr IHTMLScriptElementVtbl + IHTMLScriptElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + put_htmlFor*: proc(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.stdcall.} + get_htmlFor*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + put_event*: proc(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.stdcall.} + get_event*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + put_text*: proc(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + put_defer*: proc(self: ptr IHTMLScriptElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_defer*: proc(self: ptr IHTMLScriptElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLScriptElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLScriptElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLScriptElement2* {.pure.} = object + lpVtbl*: ptr IHTMLScriptElement2Vtbl + IHTMLScriptElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_charset*: proc(self: ptr IHTMLScriptElement2, v: BSTR): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IHTMLScriptElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLScriptElement3* {.pure.} = object + lpVtbl*: ptr IHTMLScriptElement3Vtbl + IHTMLScriptElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLScriptElement3, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLScriptElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLScriptElement4* {.pure.} = object + lpVtbl*: ptr IHTMLScriptElement4Vtbl + IHTMLScriptElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_usedCharset*: proc(self: ptr IHTMLScriptElement4, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLScriptElement* {.pure.} = object + lpVtbl*: ptr DispHTMLScriptElementVtbl + DispHTMLScriptElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLNoShowElement* {.pure.} = object + lpVtbl*: ptr IHTMLNoShowElementVtbl + IHTMLNoShowElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLNoShowElement* {.pure.} = object + lpVtbl*: ptr DispHTMLNoShowElementVtbl + DispHTMLNoShowElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLObjectElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLObjectElementEvents2Vtbl + HTMLObjectElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLObjectElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLObjectElementEventsVtbl + HTMLObjectElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLObjectElement* {.pure.} = object + lpVtbl*: ptr IHTMLObjectElementVtbl + IHTMLObjectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_object*: proc(self: ptr IHTMLObjectElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_classid*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + putref_recordset*: proc(self: ptr IHTMLObjectElement, v: ptr IDispatch): HRESULT {.stdcall.} + get_recordset*: proc(self: ptr IHTMLObjectElement, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_codeBase*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_codeBase*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_codeType*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_codeType*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_code*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_code*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + get_BaseHref*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLObjectElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_altHtml*: proc(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.stdcall.} + get_altHtml*: proc(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.stdcall.} + put_vspace*: proc(self: ptr IHTMLObjectElement, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLObjectElement, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.stdcall.} + IHTMLObjectElement2* {.pure.} = object + lpVtbl*: ptr IHTMLObjectElement2Vtbl + IHTMLObjectElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + namedRecordset*: proc(self: ptr IHTMLObjectElement2, dataMember: BSTR, hierarchy: ptr VARIANT, ppRecordset: ptr ptr IDispatch): HRESULT {.stdcall.} + put_classid*: proc(self: ptr IHTMLObjectElement2, v: BSTR): HRESULT {.stdcall.} + get_classid*: proc(self: ptr IHTMLObjectElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IHTMLObjectElement2, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLObjectElement2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLObjectElement3* {.pure.} = object + lpVtbl*: ptr IHTMLObjectElement3Vtbl + IHTMLObjectElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_archive*: proc(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.stdcall.} + get_archive*: proc(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_alt*: proc(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.stdcall.} + get_alt*: proc(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_declare*: proc(self: ptr IHTMLObjectElement3, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_declare*: proc(self: ptr IHTMLObjectElement3, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_standby*: proc(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.stdcall.} + get_standby*: proc(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLObjectElement3, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLObjectElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_useMap*: proc(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.stdcall.} + get_useMap*: proc(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLObjectElement4* {.pure.} = object + lpVtbl*: ptr IHTMLObjectElement4Vtbl + IHTMLObjectElement4Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_contentDocument*: proc(self: ptr IHTMLObjectElement4, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_codeBase*: proc(self: ptr IHTMLObjectElement4, v: BSTR): HRESULT {.stdcall.} + get_codeBase*: proc(self: ptr IHTMLObjectElement4, p: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IHTMLObjectElement4, v: BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IHTMLObjectElement4, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLObjectElement5* {.pure.} = object + lpVtbl*: ptr IHTMLObjectElement5Vtbl + IHTMLObjectElement5Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_object*: proc(self: ptr IHTMLObjectElement5, v: BSTR): HRESULT {.stdcall.} + get_object*: proc(self: ptr IHTMLObjectElement5, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLParamElement* {.pure.} = object + lpVtbl*: ptr IHTMLParamElementVtbl + IHTMLParamElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_name*: proc(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.stdcall.} + put_valueType*: proc(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.stdcall.} + get_valueType*: proc(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLParamElement2* {.pure.} = object + lpVtbl*: ptr IHTMLParamElement2Vtbl + IHTMLParamElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_name*: proc(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_value*: proc(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_valueType*: proc(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.stdcall.} + get_valueType*: proc(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLObjectElement* {.pure.} = object + lpVtbl*: ptr DispHTMLObjectElementVtbl + DispHTMLObjectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLParamElement* {.pure.} = object + lpVtbl*: ptr DispHTMLParamElementVtbl + DispHTMLParamElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLFrameSiteEvents2* {.pure.} = object + lpVtbl*: ptr HTMLFrameSiteEvents2Vtbl + HTMLFrameSiteEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLFrameSiteEvents* {.pure.} = object + lpVtbl*: ptr HTMLFrameSiteEventsVtbl + HTMLFrameSiteEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFrameBase2* {.pure.} = object + lpVtbl*: ptr IHTMLFrameBase2Vtbl + IHTMLFrameBase2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_contentWindow*: proc(self: ptr IHTMLFrameBase2, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLFrameBase2, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLFrameBase2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLFrameBase2, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLFrameBase2, p: ptr VARIANT): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLFrameBase2, p: ptr BSTR): HRESULT {.stdcall.} + put_allowTransparency*: proc(self: ptr IHTMLFrameBase2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_allowTransparency*: proc(self: ptr IHTMLFrameBase2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLFrameBase3* {.pure.} = object + lpVtbl*: ptr IHTMLFrameBase3Vtbl + IHTMLFrameBase3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_longDesc*: proc(self: ptr IHTMLFrameBase3, v: BSTR): HRESULT {.stdcall.} + get_longDesc*: proc(self: ptr IHTMLFrameBase3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLFrameBase* {.pure.} = object + lpVtbl*: ptr DispHTMLFrameBaseVtbl + DispHTMLFrameBaseVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFrameElement* {.pure.} = object + lpVtbl*: ptr IHTMLFrameElementVtbl + IHTMLFrameElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_borderColor*: proc(self: ptr IHTMLFrameElement, v: VARIANT): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLFrameElement, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLFrameElement2* {.pure.} = object + lpVtbl*: ptr IHTMLFrameElement2Vtbl + IHTMLFrameElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_height*: proc(self: ptr IHTMLFrameElement2, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLFrameElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLFrameElement2, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLFrameElement2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLFrameElement3* {.pure.} = object + lpVtbl*: ptr IHTMLFrameElement3Vtbl + IHTMLFrameElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_contentDocument*: proc(self: ptr IHTMLFrameElement3, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_longDesc*: proc(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_longDesc*: proc(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_frameBorder*: proc(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_frameBorder*: proc(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLFrameElement* {.pure.} = object + lpVtbl*: ptr DispHTMLFrameElementVtbl + DispHTMLFrameElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLIFrameElement* {.pure.} = object + lpVtbl*: ptr IHTMLIFrameElementVtbl + IHTMLIFrameElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_vspace*: proc(self: ptr IHTMLIFrameElement, v: LONG): HRESULT {.stdcall.} + get_vspace*: proc(self: ptr IHTMLIFrameElement, p: ptr LONG): HRESULT {.stdcall.} + put_hspace*: proc(self: ptr IHTMLIFrameElement, v: LONG): HRESULT {.stdcall.} + get_hspace*: proc(self: ptr IHTMLIFrameElement, p: ptr LONG): HRESULT {.stdcall.} + put_align*: proc(self: ptr IHTMLIFrameElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLIFrameElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLIFrameElement2* {.pure.} = object + lpVtbl*: ptr IHTMLIFrameElement2Vtbl + IHTMLIFrameElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_height*: proc(self: ptr IHTMLIFrameElement2, v: VARIANT): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLIFrameElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_width*: proc(self: ptr IHTMLIFrameElement2, v: VARIANT): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLIFrameElement2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLIFrameElement3* {.pure.} = object + lpVtbl*: ptr IHTMLIFrameElement3Vtbl + IHTMLIFrameElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_contentDocument*: proc(self: ptr IHTMLIFrameElement3, p: ptr ptr IDispatch): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_longDesc*: proc(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_longDesc*: proc(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + put_frameBorder*: proc(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.stdcall.} + get_frameBorder*: proc(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLIFrame* {.pure.} = object + lpVtbl*: ptr DispHTMLIFrameVtbl + DispHTMLIFrameVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLDivPosition* {.pure.} = object + lpVtbl*: ptr IHTMLDivPositionVtbl + IHTMLDivPositionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLDivPosition, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLDivPosition, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLFieldSetElement* {.pure.} = object + lpVtbl*: ptr IHTMLFieldSetElementVtbl + IHTMLFieldSetElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLFieldSetElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLFieldSetElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLFieldSetElement2* {.pure.} = object + lpVtbl*: ptr IHTMLFieldSetElement2Vtbl + IHTMLFieldSetElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_form*: proc(self: ptr IHTMLFieldSetElement2, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + IHTMLLegendElement* {.pure.} = object + lpVtbl*: ptr IHTMLLegendElementVtbl + IHTMLLegendElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLLegendElement, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLLegendElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLLegendElement2* {.pure.} = object + lpVtbl*: ptr IHTMLLegendElement2Vtbl + IHTMLLegendElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_form*: proc(self: ptr IHTMLLegendElement2, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + DispHTMLDivPosition* {.pure.} = object + lpVtbl*: ptr DispHTMLDivPositionVtbl + DispHTMLDivPositionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLFieldSetElement* {.pure.} = object + lpVtbl*: ptr DispHTMLFieldSetElementVtbl + DispHTMLFieldSetElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLLegendElement* {.pure.} = object + lpVtbl*: ptr DispHTMLLegendElementVtbl + DispHTMLLegendElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLSpanFlow* {.pure.} = object + lpVtbl*: ptr IHTMLSpanFlowVtbl + IHTMLSpanFlowVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr IHTMLSpanFlow, v: BSTR): HRESULT {.stdcall.} + get_align*: proc(self: ptr IHTMLSpanFlow, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLSpanFlow* {.pure.} = object + lpVtbl*: ptr DispHTMLSpanFlowVtbl + DispHTMLSpanFlowVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFrameSetElement* {.pure.} = object + lpVtbl*: ptr IHTMLFrameSetElementVtbl + IHTMLFrameSetElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_rows*: proc(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.stdcall.} + get_rows*: proc(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.stdcall.} + put_cols*: proc(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.stdcall.} + get_cols*: proc(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_borderColor*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_borderColor*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_frameBorder*: proc(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.stdcall.} + get_frameBorder*: proc(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.stdcall.} + put_frameSpacing*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_frameSpacing*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_name*: proc(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.stdcall.} + get_name*: proc(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onunload*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_onunload*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onbeforeunload*: proc(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeunload*: proc(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLFrameSetElement2* {.pure.} = object + lpVtbl*: ptr IHTMLFrameSetElement2Vtbl + IHTMLFrameSetElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onbeforeprint*: proc(self: ptr IHTMLFrameSetElement2, v: VARIANT): HRESULT {.stdcall.} + get_onbeforeprint*: proc(self: ptr IHTMLFrameSetElement2, p: ptr VARIANT): HRESULT {.stdcall.} + put_onafterprint*: proc(self: ptr IHTMLFrameSetElement2, v: VARIANT): HRESULT {.stdcall.} + get_onafterprint*: proc(self: ptr IHTMLFrameSetElement2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLFrameSetElement3* {.pure.} = object + lpVtbl*: ptr IHTMLFrameSetElement3Vtbl + IHTMLFrameSetElement3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_onhashchange*: proc(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.stdcall.} + get_onhashchange*: proc(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onmessage*: proc(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.stdcall.} + get_onmessage*: proc(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onoffline*: proc(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.stdcall.} + get_onoffline*: proc(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_ononline*: proc(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.stdcall.} + get_ononline*: proc(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.stdcall.} + put_onstorage*: proc(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.stdcall.} + get_onstorage*: proc(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLFrameSetSite* {.pure.} = object + lpVtbl*: ptr DispHTMLFrameSetSiteVtbl + DispHTMLFrameSetSiteVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLBGsound* {.pure.} = object + lpVtbl*: ptr IHTMLBGsoundVtbl + IHTMLBGsoundVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLBGsound, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLBGsound, p: ptr BSTR): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.stdcall.} + put_volume*: proc(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.stdcall.} + get_volume*: proc(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.stdcall.} + put_balance*: proc(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.stdcall.} + get_balance*: proc(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLBGsound* {.pure.} = object + lpVtbl*: ptr DispHTMLBGsoundVtbl + DispHTMLBGsoundVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLFontNamesCollection* {.pure.} = object + lpVtbl*: ptr IHTMLFontNamesCollectionVtbl + IHTMLFontNamesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLFontNamesCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLFontNamesCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLFontNamesCollection, index: LONG, pBstr: ptr BSTR): HRESULT {.stdcall.} + IHTMLFontSizesCollection* {.pure.} = object + lpVtbl*: ptr IHTMLFontSizesCollectionVtbl + IHTMLFontSizesCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLFontSizesCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLFontSizesCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + get_forFont*: proc(self: ptr IHTMLFontSizesCollection, p: ptr BSTR): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLFontSizesCollection, index: LONG, plSize: ptr LONG): HRESULT {.stdcall.} + IHTMLOptionsHolder* {.pure.} = object + lpVtbl*: ptr IHTMLOptionsHolderVtbl + IHTMLOptionsHolderVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_document*: proc(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + get_fonts*: proc(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLFontNamesCollection): HRESULT {.stdcall.} + put_execArg*: proc(self: ptr IHTMLOptionsHolder, v: VARIANT): HRESULT {.stdcall.} + get_execArg*: proc(self: ptr IHTMLOptionsHolder, p: ptr VARIANT): HRESULT {.stdcall.} + put_errorLine*: proc(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.stdcall.} + get_errorLine*: proc(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.stdcall.} + put_errorCharacter*: proc(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.stdcall.} + get_errorCharacter*: proc(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.stdcall.} + put_errorCode*: proc(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.stdcall.} + get_errorCode*: proc(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.stdcall.} + put_errorMessage*: proc(self: ptr IHTMLOptionsHolder, v: BSTR): HRESULT {.stdcall.} + get_errorMessage*: proc(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.stdcall.} + put_errorDebug*: proc(self: ptr IHTMLOptionsHolder, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_errorDebug*: proc(self: ptr IHTMLOptionsHolder, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_unsecuredWindowOfDocument*: proc(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + put_findText*: proc(self: ptr IHTMLOptionsHolder, v: BSTR): HRESULT {.stdcall.} + get_findText*: proc(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.stdcall.} + put_anythingAfterFrameset*: proc(self: ptr IHTMLOptionsHolder, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_anythingAfterFrameset*: proc(self: ptr IHTMLOptionsHolder, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + sizes*: proc(self: ptr IHTMLOptionsHolder, fontName: BSTR, pSizesCollection: ptr ptr IHTMLFontSizesCollection): HRESULT {.stdcall.} + openfiledlg*: proc(self: ptr IHTMLOptionsHolder, initFile: VARIANT, initDir: VARIANT, filter: VARIANT, title: VARIANT, pathName: ptr BSTR): HRESULT {.stdcall.} + savefiledlg*: proc(self: ptr IHTMLOptionsHolder, initFile: VARIANT, initDir: VARIANT, filter: VARIANT, title: VARIANT, pathName: ptr BSTR): HRESULT {.stdcall.} + choosecolordlg*: proc(self: ptr IHTMLOptionsHolder, initColor: VARIANT, rgbColor: ptr LONG): HRESULT {.stdcall.} + showSecurityInfo*: proc(self: ptr IHTMLOptionsHolder): HRESULT {.stdcall.} + isApartmentModel*: proc(self: ptr IHTMLOptionsHolder, `object`: ptr IHTMLObjectElement, fApartment: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getCharset*: proc(self: ptr IHTMLOptionsHolder, fontName: BSTR, charset: ptr LONG): HRESULT {.stdcall.} + get_secureConnectionInfo*: proc(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.stdcall.} + HTMLStyleElementEvents2* {.pure.} = object + lpVtbl*: ptr HTMLStyleElementEvents2Vtbl + HTMLStyleElementEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLStyleElementEvents* {.pure.} = object + lpVtbl*: ptr HTMLStyleElementEventsVtbl + HTMLStyleElementEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleElement* {.pure.} = object + lpVtbl*: ptr IHTMLStyleElementVtbl + IHTMLStyleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr IHTMLStyleElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.stdcall.} + get_styleSheet*: proc(self: ptr IHTMLStyleElement, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + put_disabled*: proc(self: ptr IHTMLStyleElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_disabled*: proc(self: ptr IHTMLStyleElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLStyleElement, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleElement2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleElement2Vtbl + IHTMLStyleElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_sheet*: proc(self: ptr IHTMLStyleElement2, p: ptr ptr IHTMLStyleSheet): HRESULT {.stdcall.} + DispHTMLStyleElement* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleElementVtbl + DispHTMLStyleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStyleFontFace* {.pure.} = object + lpVtbl*: ptr IHTMLStyleFontFaceVtbl + IHTMLStyleFontFaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_fontsrc*: proc(self: ptr IHTMLStyleFontFace, v: BSTR): HRESULT {.stdcall.} + get_fontsrc*: proc(self: ptr IHTMLStyleFontFace, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLStyleFontFace2* {.pure.} = object + lpVtbl*: ptr IHTMLStyleFontFace2Vtbl + IHTMLStyleFontFace2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_style*: proc(self: ptr IHTMLStyleFontFace2, p: ptr ptr IHTMLRuleStyle): HRESULT {.stdcall.} + DispHTMLStyleFontFace* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleFontFaceVtbl + DispHTMLStyleFontFaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLXDomainRequest* {.pure.} = object + lpVtbl*: ptr IHTMLXDomainRequestVtbl + IHTMLXDomainRequestVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_responseText*: proc(self: ptr IHTMLXDomainRequest, p: ptr BSTR): HRESULT {.stdcall.} + put_timeout*: proc(self: ptr IHTMLXDomainRequest, v: LONG): HRESULT {.stdcall.} + get_timeout*: proc(self: ptr IHTMLXDomainRequest, p: ptr LONG): HRESULT {.stdcall.} + get_contentType*: proc(self: ptr IHTMLXDomainRequest, p: ptr BSTR): HRESULT {.stdcall.} + put_onprogress*: proc(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.stdcall.} + get_onprogress*: proc(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.stdcall.} + put_onerror*: proc(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.stdcall.} + get_onerror*: proc(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.stdcall.} + put_ontimeout*: proc(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.stdcall.} + get_ontimeout*: proc(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.stdcall.} + put_onload*: proc(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.stdcall.} + get_onload*: proc(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.stdcall.} + abort*: proc(self: ptr IHTMLXDomainRequest): HRESULT {.stdcall.} + open*: proc(self: ptr IHTMLXDomainRequest, bstrMethod: BSTR, bstrUrl: BSTR): HRESULT {.stdcall.} + send*: proc(self: ptr IHTMLXDomainRequest, varBody: VARIANT): HRESULT {.stdcall.} + IHTMLXDomainRequestFactory* {.pure.} = object + lpVtbl*: ptr IHTMLXDomainRequestFactoryVtbl + IHTMLXDomainRequestFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IHTMLXDomainRequestFactory, a: ptr ptr IHTMLXDomainRequest): HRESULT {.stdcall.} + DispXDomainRequest* {.pure.} = object + lpVtbl*: ptr DispXDomainRequestVtbl + DispXDomainRequestVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLStorage2* {.pure.} = object + lpVtbl*: ptr IHTMLStorage2Vtbl + IHTMLStorage2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + setItem*: proc(self: ptr IHTMLStorage2, bstrKey: BSTR, bstrValue: BSTR): HRESULT {.stdcall.} + DispHTMLStorage* {.pure.} = object + lpVtbl*: ptr DispHTMLStorageVtbl + DispHTMLStorageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispDOMEvent* {.pure.} = object + lpVtbl*: ptr DispDOMEventVtbl + DispDOMEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMUIEvent* {.pure.} = object + lpVtbl*: ptr IDOMUIEventVtbl + IDOMUIEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_view*: proc(self: ptr IDOMUIEvent, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + get_detail*: proc(self: ptr IDOMUIEvent, p: ptr LONG): HRESULT {.stdcall.} + initUIEvent*: proc(self: ptr IDOMUIEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, view: ptr IHTMLWindow2, detail: LONG): HRESULT {.stdcall.} + DispDOMUIEvent* {.pure.} = object + lpVtbl*: ptr DispDOMUIEventVtbl + DispDOMUIEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMouseEvent* {.pure.} = object + lpVtbl*: ptr IDOMMouseEventVtbl + IDOMMouseEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_screenX*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_screenY*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_clientX*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_clientY*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_ctrlKey*: proc(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_shiftKey*: proc(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_altKey*: proc(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_metaKey*: proc(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_button*: proc(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.stdcall.} + get_relatedTarget*: proc(self: ptr IDOMMouseEvent, p: ptr ptr IEventTarget): HRESULT {.stdcall.} + initMouseEvent*: proc(self: ptr IDOMMouseEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, ctrlKeyArg: VARIANT_BOOL, altKeyArg: VARIANT_BOOL, shiftKeyArg: VARIANT_BOOL, metaKeyArg: VARIANT_BOOL, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget): HRESULT {.stdcall.} + getModifierState*: proc(self: ptr IDOMMouseEvent, keyArg: BSTR, activated: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_buttons*: proc(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.stdcall.} + get_fromElement*: proc(self: ptr IDOMMouseEvent, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_toElement*: proc(self: ptr IDOMMouseEvent, p: ptr ptr IHTMLElement): HRESULT {.stdcall.} + get_x*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_y*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_offsetX*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_offsetY*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_pageX*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_pageY*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_layerX*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_layerY*: proc(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.stdcall.} + get_which*: proc(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.stdcall.} + DispDOMMouseEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMouseEventVtbl + DispDOMMouseEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMDragEvent* {.pure.} = object + lpVtbl*: ptr IDOMDragEventVtbl + IDOMDragEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_dataTransfer*: proc(self: ptr IDOMDragEvent, p: ptr ptr IHTMLDataTransfer): HRESULT {.stdcall.} + initDragEvent*: proc(self: ptr IDOMDragEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, ctrlKeyArg: VARIANT_BOOL, altKeyArg: VARIANT_BOOL, shiftKeyArg: VARIANT_BOOL, metaKeyArg: VARIANT_BOOL, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, dataTransferArg: ptr IHTMLDataTransfer): HRESULT {.stdcall.} + DispDOMDragEvent* {.pure.} = object + lpVtbl*: ptr DispDOMDragEventVtbl + DispDOMDragEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMouseWheelEvent* {.pure.} = object + lpVtbl*: ptr IDOMMouseWheelEventVtbl + IDOMMouseWheelEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_wheelDelta*: proc(self: ptr IDOMMouseWheelEvent, p: ptr LONG): HRESULT {.stdcall.} + initMouseWheelEvent*: proc(self: ptr IDOMMouseWheelEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, modifiersListArg: BSTR, wheelDeltaArg: LONG): HRESULT {.stdcall.} + DispDOMMouseWheelEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMouseWheelEventVtbl + DispDOMMouseWheelEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMWheelEvent* {.pure.} = object + lpVtbl*: ptr IDOMWheelEventVtbl + IDOMWheelEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_deltaX*: proc(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.stdcall.} + get_deltaY*: proc(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.stdcall.} + get_deltaZ*: proc(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.stdcall.} + get_deltaMode*: proc(self: ptr IDOMWheelEvent, p: ptr ULONG): HRESULT {.stdcall.} + initWheelEvent*: proc(self: ptr IDOMWheelEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, modifiersListArg: BSTR, deltaX: LONG, deltaY: LONG, deltaZ: LONG, deltaMode: ULONG): HRESULT {.stdcall.} + DispDOMWheelEvent* {.pure.} = object + lpVtbl*: ptr DispDOMWheelEventVtbl + DispDOMWheelEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMTextEvent* {.pure.} = object + lpVtbl*: ptr IDOMTextEventVtbl + IDOMTextEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_data*: proc(self: ptr IDOMTextEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_inputMethod*: proc(self: ptr IDOMTextEvent, p: ptr ULONG): HRESULT {.stdcall.} + initTextEvent*: proc(self: ptr IDOMTextEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, dataArg: BSTR, inputMethod: ULONG, locale: BSTR): HRESULT {.stdcall.} + get_locale*: proc(self: ptr IDOMTextEvent, p: ptr BSTR): HRESULT {.stdcall.} + DispDOMTextEvent* {.pure.} = object + lpVtbl*: ptr DispDOMTextEventVtbl + DispDOMTextEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMKeyboardEvent* {.pure.} = object + lpVtbl*: ptr IDOMKeyboardEventVtbl + IDOMKeyboardEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_key*: proc(self: ptr IDOMKeyboardEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_location*: proc(self: ptr IDOMKeyboardEvent, p: ptr ULONG): HRESULT {.stdcall.} + get_ctrlKey*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_shiftKey*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_altKey*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_metaKey*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_repeat*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getModifierState*: proc(self: ptr IDOMKeyboardEvent, keyArg: BSTR, state: ptr VARIANT_BOOL): HRESULT {.stdcall.} + initKeyboardEvent*: proc(self: ptr IDOMKeyboardEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, keyArg: BSTR, locationArg: ULONG, modifiersListArg: BSTR, repeat: VARIANT_BOOL, locale: BSTR): HRESULT {.stdcall.} + get_keyCode*: proc(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.stdcall.} + get_charCode*: proc(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.stdcall.} + get_which*: proc(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.stdcall.} + get_ie9_char*: proc(self: ptr IDOMKeyboardEvent, p: ptr VARIANT): HRESULT {.stdcall.} + get_locale*: proc(self: ptr IDOMKeyboardEvent, p: ptr BSTR): HRESULT {.stdcall.} + DispDOMKeyboardEvent* {.pure.} = object + lpVtbl*: ptr DispDOMKeyboardEventVtbl + DispDOMKeyboardEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMCompositionEvent* {.pure.} = object + lpVtbl*: ptr IDOMCompositionEventVtbl + IDOMCompositionEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_data*: proc(self: ptr IDOMCompositionEvent, p: ptr BSTR): HRESULT {.stdcall.} + initCompositionEvent*: proc(self: ptr IDOMCompositionEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, data: BSTR, locale: BSTR): HRESULT {.stdcall.} + get_locale*: proc(self: ptr IDOMCompositionEvent, p: ptr BSTR): HRESULT {.stdcall.} + DispDOMCompositionEvent* {.pure.} = object + lpVtbl*: ptr DispDOMCompositionEventVtbl + DispDOMCompositionEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMutationEvent* {.pure.} = object + lpVtbl*: ptr IDOMMutationEventVtbl + IDOMMutationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_relatedNode*: proc(self: ptr IDOMMutationEvent, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_prevValue*: proc(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_newValue*: proc(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_attrName*: proc(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_attrChange*: proc(self: ptr IDOMMutationEvent, p: ptr USHORT): HRESULT {.stdcall.} + initMutationEvent*: proc(self: ptr IDOMMutationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, relatedNodeArg: ptr IDispatch, prevValueArg: BSTR, newValueArg: BSTR, attrNameArg: BSTR, attrChangeArg: USHORT): HRESULT {.stdcall.} + DispDOMMutationEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMutationEventVtbl + DispDOMMutationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMBeforeUnloadEvent* {.pure.} = object + lpVtbl*: ptr IDOMBeforeUnloadEventVtbl + IDOMBeforeUnloadEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_returnValue*: proc(self: ptr IDOMBeforeUnloadEvent, v: VARIANT): HRESULT {.stdcall.} + get_returnValue*: proc(self: ptr IDOMBeforeUnloadEvent, p: ptr VARIANT): HRESULT {.stdcall.} + DispDOMBeforeUnloadEvent* {.pure.} = object + lpVtbl*: ptr DispDOMBeforeUnloadEventVtbl + DispDOMBeforeUnloadEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMFocusEvent* {.pure.} = object + lpVtbl*: ptr IDOMFocusEventVtbl + IDOMFocusEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_relatedTarget*: proc(self: ptr IDOMFocusEvent, p: ptr ptr IEventTarget): HRESULT {.stdcall.} + initFocusEvent*: proc(self: ptr IDOMFocusEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, view: ptr IHTMLWindow2, detail: LONG, relatedTargetArg: ptr IEventTarget): HRESULT {.stdcall.} + DispDOMFocusEvent* {.pure.} = object + lpVtbl*: ptr DispDOMFocusEventVtbl + DispDOMFocusEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMCustomEvent* {.pure.} = object + lpVtbl*: ptr IDOMCustomEventVtbl + IDOMCustomEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_detail*: proc(self: ptr IDOMCustomEvent, p: ptr VARIANT): HRESULT {.stdcall.} + initCustomEvent*: proc(self: ptr IDOMCustomEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, detail: ptr VARIANT): HRESULT {.stdcall.} + DispDOMCustomEvent* {.pure.} = object + lpVtbl*: ptr DispDOMCustomEventVtbl + DispDOMCustomEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ICanvasGradient* {.pure.} = object + lpVtbl*: ptr ICanvasGradientVtbl + ICanvasGradientVtbl* {.pure, inheritable.} = object of IDispatchVtbl + addColorStop*: proc(self: ptr ICanvasGradient, offset: float32, color: BSTR): HRESULT {.stdcall.} + ICanvasPattern* {.pure.} = object + lpVtbl*: ptr ICanvasPatternVtbl + ICanvasPatternVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ICanvasTextMetrics* {.pure.} = object + lpVtbl*: ptr ICanvasTextMetricsVtbl + ICanvasTextMetricsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_width*: proc(self: ptr ICanvasTextMetrics, p: ptr float32): HRESULT {.stdcall.} + ICanvasImageData* {.pure.} = object + lpVtbl*: ptr ICanvasImageDataVtbl + ICanvasImageDataVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_width*: proc(self: ptr ICanvasImageData, p: ptr ULONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr ICanvasImageData, p: ptr ULONG): HRESULT {.stdcall.} + get_data*: proc(self: ptr ICanvasImageData, p: ptr VARIANT): HRESULT {.stdcall.} + ICanvasPixelArray* {.pure.} = object + lpVtbl*: ptr ICanvasPixelArrayVtbl + ICanvasPixelArrayVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr ICanvasPixelArray, p: ptr ULONG): HRESULT {.stdcall.} + IHTMLCanvasElement* {.pure.} = object + lpVtbl*: ptr IHTMLCanvasElementVtbl + IHTMLCanvasElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_width*: proc(self: ptr IHTMLCanvasElement, v: LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLCanvasElement, p: ptr LONG): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLCanvasElement, v: LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLCanvasElement, p: ptr LONG): HRESULT {.stdcall.} + getContext*: proc(self: ptr IHTMLCanvasElement, contextId: BSTR, ppContext: ptr ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + toDataURL*: proc(self: ptr IHTMLCanvasElement, `type`: BSTR, jpegquality: VARIANT, pUrl: ptr BSTR): HRESULT {.stdcall.} + ICanvasRenderingContext2D* {.pure.} = object + lpVtbl*: ptr ICanvasRenderingContext2DVtbl + ICanvasRenderingContext2DVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_canvas*: proc(self: ptr ICanvasRenderingContext2D, p: ptr ptr IHTMLCanvasElement): HRESULT {.stdcall.} + restore*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + save*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + rotate*: proc(self: ptr ICanvasRenderingContext2D, angle: float32): HRESULT {.stdcall.} + scale*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.stdcall.} + setTransform*: proc(self: ptr ICanvasRenderingContext2D, m11: float32, m12: float32, m21: float32, m22: float32, dx: float32, dy: float32): HRESULT {.stdcall.} + transform*: proc(self: ptr ICanvasRenderingContext2D, m11: float32, m12: float32, m21: float32, m22: float32, dx: float32, dy: float32): HRESULT {.stdcall.} + translate*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.stdcall.} + put_globalAlpha*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_globalAlpha*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + put_globalCompositeOperation*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_globalCompositeOperation*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_fillStyle*: proc(self: ptr ICanvasRenderingContext2D, v: VARIANT): HRESULT {.stdcall.} + get_fillStyle*: proc(self: ptr ICanvasRenderingContext2D, p: ptr VARIANT): HRESULT {.stdcall.} + put_strokeStyle*: proc(self: ptr ICanvasRenderingContext2D, v: VARIANT): HRESULT {.stdcall.} + get_strokeStyle*: proc(self: ptr ICanvasRenderingContext2D, p: ptr VARIANT): HRESULT {.stdcall.} + createLinearGradient*: proc(self: ptr ICanvasRenderingContext2D, x0: float32, y0: float32, x1: float32, y1: float32, ppCanvasGradient: ptr ptr ICanvasGradient): HRESULT {.stdcall.} + createRadialGradient*: proc(self: ptr ICanvasRenderingContext2D, x0: float32, y0: float32, r0: float32, x1: float32, y1: float32, r1: float32, ppCanvasGradient: ptr ptr ICanvasGradient): HRESULT {.stdcall.} + createPattern*: proc(self: ptr ICanvasRenderingContext2D, image: ptr IDispatch, repetition: VARIANT, ppCanvasPattern: ptr ptr ICanvasPattern): HRESULT {.stdcall.} + put_lineCap*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_lineCap*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_lineJoin*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_lineJoin*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_lineWidth*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_lineWidth*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + put_miterLimit*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_miterLimit*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + put_shadowBlur*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_shadowBlur*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + put_shadowColor*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_shadowColor*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_shadowOffsetX*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_shadowOffsetX*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + put_shadowOffsetY*: proc(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.stdcall.} + get_shadowOffsetY*: proc(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.stdcall.} + clearRect*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.stdcall.} + fillRect*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.stdcall.} + strokeRect*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.stdcall.} + arc*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, radius: float32, startAngle: float32, endAngle: float32, anticlockwise: WINBOOL): HRESULT {.stdcall.} + arcTo*: proc(self: ptr ICanvasRenderingContext2D, x1: float32, y1: float32, x2: float32, y2: float32, radius: float32): HRESULT {.stdcall.} + beginPath*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + bezierCurveTo*: proc(self: ptr ICanvasRenderingContext2D, cp1x: float32, cp1y: float32, cp2x: float32, cp2y: float32, x: float32, y: float32): HRESULT {.stdcall.} + clip*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + closePath*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + fill*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + lineTo*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.stdcall.} + moveTo*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.stdcall.} + quadraticCurveTo*: proc(self: ptr ICanvasRenderingContext2D, cpx: float32, cpy: float32, x: float32, y: float32): HRESULT {.stdcall.} + rect*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.stdcall.} + stroke*: proc(self: ptr ICanvasRenderingContext2D): HRESULT {.stdcall.} + isPointInPath*: proc(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_font*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_font*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_textAlign*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_textAlign*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + put_textBaseline*: proc(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.stdcall.} + get_textBaseline*: proc(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.stdcall.} + fillText*: proc(self: ptr ICanvasRenderingContext2D, text: BSTR, x: float32, y: float32, maxWidth: VARIANT): HRESULT {.stdcall.} + measureText*: proc(self: ptr ICanvasRenderingContext2D, text: BSTR, ppCanvasTextMetrics: ptr ptr ICanvasTextMetrics): HRESULT {.stdcall.} + strokeText*: proc(self: ptr ICanvasRenderingContext2D, text: BSTR, x: float32, y: float32, maxWidth: VARIANT): HRESULT {.stdcall.} + drawImage*: proc(self: ptr ICanvasRenderingContext2D, pSrc: ptr IDispatch, a1: VARIANT, a2: VARIANT, a3: VARIANT, a4: VARIANT, a5: VARIANT, a6: VARIANT, a7: VARIANT, a8: VARIANT): HRESULT {.stdcall.} + createImageData*: proc(self: ptr ICanvasRenderingContext2D, a1: VARIANT, a2: VARIANT, ppCanvasImageData: ptr ptr ICanvasImageData): HRESULT {.stdcall.} + getImageData*: proc(self: ptr ICanvasRenderingContext2D, sx: float32, sy: float32, sw: float32, sh: float32, ppCanvasImageData: ptr ptr ICanvasImageData): HRESULT {.stdcall.} + putImageData*: proc(self: ptr ICanvasRenderingContext2D, imagedata: ptr ICanvasImageData, dx: float32, dy: float32, dirtyX: VARIANT, dirtyY: VARIANT, dirtyWidth: VARIANT, dirtyHeight: VARIANT): HRESULT {.stdcall.} + DispCanvasGradient* {.pure.} = object + lpVtbl*: ptr DispCanvasGradientVtbl + DispCanvasGradientVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispCanvasPattern* {.pure.} = object + lpVtbl*: ptr DispCanvasPatternVtbl + DispCanvasPatternVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispCanvasTextMetrics* {.pure.} = object + lpVtbl*: ptr DispCanvasTextMetricsVtbl + DispCanvasTextMetricsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispCanvasImageData* {.pure.} = object + lpVtbl*: ptr DispCanvasImageDataVtbl + DispCanvasImageDataVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispCanvasRenderingContext2D* {.pure.} = object + lpVtbl*: ptr DispCanvasRenderingContext2DVtbl + DispCanvasRenderingContext2DVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLCanvasElement* {.pure.} = object + lpVtbl*: ptr DispHTMLCanvasElementVtbl + DispHTMLCanvasElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMProgressEvent* {.pure.} = object + lpVtbl*: ptr IDOMProgressEventVtbl + IDOMProgressEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_lengthComputable*: proc(self: ptr IDOMProgressEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_loaded*: proc(self: ptr IDOMProgressEvent, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_total*: proc(self: ptr IDOMProgressEvent, p: ptr ULONGLONG): HRESULT {.stdcall.} + initProgressEvent*: proc(self: ptr IDOMProgressEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, lengthComputableArg: VARIANT_BOOL, loadedArg: ULONGLONG, totalArg: ULONGLONG): HRESULT {.stdcall.} + DispDOMProgressEvent* {.pure.} = object + lpVtbl*: ptr DispDOMProgressEventVtbl + DispDOMProgressEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMessageEvent* {.pure.} = object + lpVtbl*: ptr IDOMMessageEventVtbl + IDOMMessageEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_data*: proc(self: ptr IDOMMessageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_origin*: proc(self: ptr IDOMMessageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_source*: proc(self: ptr IDOMMessageEvent, p: ptr ptr IHTMLWindow2): HRESULT {.stdcall.} + initMessageEvent*: proc(self: ptr IDOMMessageEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, data: BSTR, origin: BSTR, lastEventId: BSTR, source: ptr IHTMLWindow2): HRESULT {.stdcall.} + DispDOMMessageEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMessageEventVtbl + DispDOMMessageEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMSiteModeEvent* {.pure.} = object + lpVtbl*: ptr IDOMSiteModeEventVtbl + IDOMSiteModeEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_buttonID*: proc(self: ptr IDOMSiteModeEvent, p: ptr LONG): HRESULT {.stdcall.} + get_actionURL*: proc(self: ptr IDOMSiteModeEvent, p: ptr BSTR): HRESULT {.stdcall.} + DispDOMSiteModeEvent* {.pure.} = object + lpVtbl*: ptr DispDOMSiteModeEventVtbl + DispDOMSiteModeEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMStorageEvent* {.pure.} = object + lpVtbl*: ptr IDOMStorageEventVtbl + IDOMStorageEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_key*: proc(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_oldValue*: proc(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_newValue*: proc(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_url*: proc(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_storageArea*: proc(self: ptr IDOMStorageEvent, p: ptr ptr IHTMLStorage): HRESULT {.stdcall.} + initStorageEvent*: proc(self: ptr IDOMStorageEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, keyArg: BSTR, oldValueArg: BSTR, newValueArg: BSTR, urlArg: BSTR, storageAreaArg: ptr IHTMLStorage): HRESULT {.stdcall.} + DispDOMStorageEvent* {.pure.} = object + lpVtbl*: ptr DispDOMStorageEventVtbl + DispDOMStorageEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IXMLHttpRequestEventTarget* {.pure.} = object + lpVtbl*: ptr IXMLHttpRequestEventTargetVtbl + IXMLHttpRequestEventTargetVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispXMLHttpRequestEventTarget* {.pure.} = object + lpVtbl*: ptr DispXMLHttpRequestEventTargetVtbl + DispXMLHttpRequestEventTargetVtbl* {.pure, inheritable.} = object of IDispatchVtbl + HTMLXMLHttpRequestEvents* {.pure.} = object + lpVtbl*: ptr HTMLXMLHttpRequestEventsVtbl + HTMLXMLHttpRequestEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLXMLHttpRequest* {.pure.} = object + lpVtbl*: ptr IHTMLXMLHttpRequestVtbl + IHTMLXMLHttpRequestVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_readyState*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr LONG): HRESULT {.stdcall.} + get_responseBody*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr VARIANT): HRESULT {.stdcall.} + get_responseText*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr BSTR): HRESULT {.stdcall.} + get_responseXML*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr LONG): HRESULT {.stdcall.} + get_statusText*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr BSTR): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLXMLHttpRequest, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLXMLHttpRequest, p: ptr VARIANT): HRESULT {.stdcall.} + abort*: proc(self: ptr IHTMLXMLHttpRequest): HRESULT {.stdcall.} + open*: proc(self: ptr IHTMLXMLHttpRequest, bstrMethod: BSTR, bstrUrl: BSTR, varAsync: VARIANT, varUser: VARIANT, varPassword: VARIANT): HRESULT {.stdcall.} + send*: proc(self: ptr IHTMLXMLHttpRequest, varBody: VARIANT): HRESULT {.stdcall.} + getAllResponseHeaders*: proc(self: ptr IHTMLXMLHttpRequest, a: ptr BSTR): HRESULT {.stdcall.} + getResponseHeader*: proc(self: ptr IHTMLXMLHttpRequest, bstrHeader: BSTR, a: ptr BSTR): HRESULT {.stdcall.} + setRequestHeader*: proc(self: ptr IHTMLXMLHttpRequest, bstrHeader: BSTR, bstrValue: BSTR): HRESULT {.stdcall.} + IHTMLXMLHttpRequest2* {.pure.} = object + lpVtbl*: ptr IHTMLXMLHttpRequest2Vtbl + IHTMLXMLHttpRequest2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_timeout*: proc(self: ptr IHTMLXMLHttpRequest2, v: LONG): HRESULT {.stdcall.} + get_timeout*: proc(self: ptr IHTMLXMLHttpRequest2, p: ptr LONG): HRESULT {.stdcall.} + put_ontimeout*: proc(self: ptr IHTMLXMLHttpRequest2, v: VARIANT): HRESULT {.stdcall.} + get_ontimeout*: proc(self: ptr IHTMLXMLHttpRequest2, p: ptr VARIANT): HRESULT {.stdcall.} + IHTMLXMLHttpRequestFactory* {.pure.} = object + lpVtbl*: ptr IHTMLXMLHttpRequestFactoryVtbl + IHTMLXMLHttpRequestFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IHTMLXMLHttpRequestFactory, a: ptr ptr IHTMLXMLHttpRequest): HRESULT {.stdcall.} + DispHTMLXMLHttpRequest* {.pure.} = object + lpVtbl*: ptr DispHTMLXMLHttpRequestVtbl + DispHTMLXMLHttpRequestVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGAngle* {.pure.} = object + lpVtbl*: ptr ISVGAngleVtbl + ISVGAngleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_unitType*: proc(self: ptr ISVGAngle, v: int16): HRESULT {.stdcall.} + get_unitType*: proc(self: ptr ISVGAngle, p: ptr int16): HRESULT {.stdcall.} + put_value*: proc(self: ptr ISVGAngle, v: float32): HRESULT {.stdcall.} + get_value*: proc(self: ptr ISVGAngle, p: ptr float32): HRESULT {.stdcall.} + put_valueInSpecifiedUnits*: proc(self: ptr ISVGAngle, v: float32): HRESULT {.stdcall.} + get_valueInSpecifiedUnits*: proc(self: ptr ISVGAngle, p: ptr float32): HRESULT {.stdcall.} + put_valueAsString*: proc(self: ptr ISVGAngle, v: BSTR): HRESULT {.stdcall.} + get_valueAsString*: proc(self: ptr ISVGAngle, p: ptr BSTR): HRESULT {.stdcall.} + newValueSpecifiedUnits*: proc(self: ptr ISVGAngle, unitType: int16, valueInSpecifiedUnits: float32): HRESULT {.stdcall.} + convertToSpecifiedUnits*: proc(self: ptr ISVGAngle, unitType: int16): HRESULT {.stdcall.} + ISVGAnimatedString* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedStringVtbl + ISVGAnimatedStringVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_baseVal*: proc(self: ptr ISVGAnimatedString, v: BSTR): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedString, p: ptr BSTR): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedString, p: ptr BSTR): HRESULT {.stdcall.} + ISVGStylable* {.pure.} = object + lpVtbl*: ptr ISVGStylableVtbl + ISVGStylableVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_className*: proc(self: ptr ISVGStylable, p: ptr ptr ISVGAnimatedString): HRESULT {.stdcall.} + ISVGLength* {.pure.} = object + lpVtbl*: ptr ISVGLengthVtbl + ISVGLengthVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_unitType*: proc(self: ptr ISVGLength, v: int16): HRESULT {.stdcall.} + get_unitType*: proc(self: ptr ISVGLength, p: ptr int16): HRESULT {.stdcall.} + put_value*: proc(self: ptr ISVGLength, v: float32): HRESULT {.stdcall.} + get_value*: proc(self: ptr ISVGLength, p: ptr float32): HRESULT {.stdcall.} + put_valueInSpecifiedUnits*: proc(self: ptr ISVGLength, v: float32): HRESULT {.stdcall.} + get_valueInSpecifiedUnits*: proc(self: ptr ISVGLength, p: ptr float32): HRESULT {.stdcall.} + put_valueAsString*: proc(self: ptr ISVGLength, v: BSTR): HRESULT {.stdcall.} + get_valueAsString*: proc(self: ptr ISVGLength, p: ptr BSTR): HRESULT {.stdcall.} + newValueSpecifiedUnits*: proc(self: ptr ISVGLength, unitType: int16, valueInSpecifiedUnits: float32): HRESULT {.stdcall.} + convertToSpecifiedUnits*: proc(self: ptr ISVGLength, unitType: int16): HRESULT {.stdcall.} + ISVGAnimatedLength* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedLengthVtbl + ISVGAnimatedLengthVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedLength, v: ptr ISVGLength): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedLength, p: ptr ptr ISVGLength): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedLength, v: ptr ISVGLength): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedLength, p: ptr ptr ISVGLength): HRESULT {.stdcall.} + ISVGRect* {.pure.} = object + lpVtbl*: ptr ISVGRectVtbl + ISVGRectVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGRect, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGRect, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGRect, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGRect, p: ptr float32): HRESULT {.stdcall.} + put_width*: proc(self: ptr ISVGRect, v: float32): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGRect, p: ptr float32): HRESULT {.stdcall.} + put_height*: proc(self: ptr ISVGRect, v: float32): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGRect, p: ptr float32): HRESULT {.stdcall.} + ISVGViewSpec* {.pure.} = object + lpVtbl*: ptr ISVGViewSpecVtbl + ISVGViewSpecVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGMatrix* {.pure.} = object + lpVtbl*: ptr ISVGMatrixVtbl + ISVGMatrixVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_a*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_a*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + put_b*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_b*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + put_c*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_c*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + put_d*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_d*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + put_e*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_e*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + put_f*: proc(self: ptr ISVGMatrix, v: float32): HRESULT {.stdcall.} + get_f*: proc(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.stdcall.} + multiply*: proc(self: ptr ISVGMatrix, secondMatrix: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + inverse*: proc(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + translate*: proc(self: ptr ISVGMatrix, x: float32, y: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + scale*: proc(self: ptr ISVGMatrix, scaleFactor: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + scaleNonUniform*: proc(self: ptr ISVGMatrix, scaleFactorX: float32, scaleFactorY: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + rotate*: proc(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + rotateFromVector*: proc(self: ptr ISVGMatrix, x: float32, y: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + flipX*: proc(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + flipY*: proc(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + skewX*: proc(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + skewY*: proc(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + ISVGPoint* {.pure.} = object + lpVtbl*: ptr ISVGPointVtbl + ISVGPointVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPoint, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPoint, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPoint, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPoint, p: ptr float32): HRESULT {.stdcall.} + matrixTransform*: proc(self: ptr ISVGPoint, pMatrix: ptr ISVGMatrix, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + ISVGNumber* {.pure.} = object + lpVtbl*: ptr ISVGNumberVtbl + ISVGNumberVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_value*: proc(self: ptr ISVGNumber, v: float32): HRESULT {.stdcall.} + get_value*: proc(self: ptr ISVGNumber, p: ptr float32): HRESULT {.stdcall.} + ISVGTransform* {.pure.} = object + lpVtbl*: ptr ISVGTransformVtbl + ISVGTransformVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr ISVGTransform, v: int16): HRESULT {.stdcall.} + get_type*: proc(self: ptr ISVGTransform, p: ptr int16): HRESULT {.stdcall.} + putref_matrix*: proc(self: ptr ISVGTransform, v: ptr ISVGMatrix): HRESULT {.stdcall.} + get_matrix*: proc(self: ptr ISVGTransform, p: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + put_angle*: proc(self: ptr ISVGTransform, v: float32): HRESULT {.stdcall.} + get_angle*: proc(self: ptr ISVGTransform, p: ptr float32): HRESULT {.stdcall.} + setMatrix*: proc(self: ptr ISVGTransform, matrix: ptr ISVGMatrix): HRESULT {.stdcall.} + setTranslate*: proc(self: ptr ISVGTransform, tx: float32, ty: float32): HRESULT {.stdcall.} + setScale*: proc(self: ptr ISVGTransform, sx: float32, sy: float32): HRESULT {.stdcall.} + setRotate*: proc(self: ptr ISVGTransform, angle: float32, cx: float32, cy: float32): HRESULT {.stdcall.} + setSkewX*: proc(self: ptr ISVGTransform, angle: float32): HRESULT {.stdcall.} + setSkewY*: proc(self: ptr ISVGTransform, angle: float32): HRESULT {.stdcall.} + ISVGSVGElement* {.pure.} = object + lpVtbl*: ptr ISVGSVGElementVtbl + ISVGSVGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x*: proc(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + put_contentScriptType*: proc(self: ptr ISVGSVGElement, v: BSTR): HRESULT {.stdcall.} + get_contentScriptType*: proc(self: ptr ISVGSVGElement, p: ptr BSTR): HRESULT {.stdcall.} + put_contentStyleType*: proc(self: ptr ISVGSVGElement, v: BSTR): HRESULT {.stdcall.} + get_contentStyleType*: proc(self: ptr ISVGSVGElement, p: ptr BSTR): HRESULT {.stdcall.} + putref_viewport*: proc(self: ptr ISVGSVGElement, v: ptr ISVGRect): HRESULT {.stdcall.} + get_viewport*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGRect): HRESULT {.stdcall.} + put_pixelUnitToMillimeterX*: proc(self: ptr ISVGSVGElement, v: float32): HRESULT {.stdcall.} + get_pixelUnitToMillimeterX*: proc(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.stdcall.} + put_pixelUnitToMillimeterY*: proc(self: ptr ISVGSVGElement, v: float32): HRESULT {.stdcall.} + get_pixelUnitToMillimeterY*: proc(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.stdcall.} + put_screenPixelToMillimeterX*: proc(self: ptr ISVGSVGElement, v: float32): HRESULT {.stdcall.} + get_screenPixelToMillimeterX*: proc(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.stdcall.} + put_screenPixelToMillimeterY*: proc(self: ptr ISVGSVGElement, v: float32): HRESULT {.stdcall.} + get_screenPixelToMillimeterY*: proc(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.stdcall.} + put_useCurrentView*: proc(self: ptr ISVGSVGElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_useCurrentView*: proc(self: ptr ISVGSVGElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + putref_currentView*: proc(self: ptr ISVGSVGElement, v: ptr ISVGViewSpec): HRESULT {.stdcall.} + get_currentView*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGViewSpec): HRESULT {.stdcall.} + put_currentScale*: proc(self: ptr ISVGSVGElement, v: float32): HRESULT {.stdcall.} + get_currentScale*: proc(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.stdcall.} + putref_currentTranslate*: proc(self: ptr ISVGSVGElement, v: ptr ISVGPoint): HRESULT {.stdcall.} + get_currentTranslate*: proc(self: ptr ISVGSVGElement, p: ptr ptr ISVGPoint): HRESULT {.stdcall.} + suspendRedraw*: proc(self: ptr ISVGSVGElement, maxWaitMilliseconds: ULONG, pResult: ptr ULONG): HRESULT {.stdcall.} + unsuspendRedraw*: proc(self: ptr ISVGSVGElement, suspendHandeID: ULONG): HRESULT {.stdcall.} + unsuspendRedrawAll*: proc(self: ptr ISVGSVGElement): HRESULT {.stdcall.} + forceRedraw*: proc(self: ptr ISVGSVGElement): HRESULT {.stdcall.} + pauseAnimations*: proc(self: ptr ISVGSVGElement): HRESULT {.stdcall.} + unpauseAnimations*: proc(self: ptr ISVGSVGElement): HRESULT {.stdcall.} + animationsPaused*: proc(self: ptr ISVGSVGElement, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getCurrentTime*: proc(self: ptr ISVGSVGElement, pResult: ptr float32): HRESULT {.stdcall.} + setCurrentTime*: proc(self: ptr ISVGSVGElement, seconds: float32): HRESULT {.stdcall.} + getIntersectionList*: proc(self: ptr ISVGSVGElement, rect: ptr ISVGRect, referenceElement: ptr ISVGElement, pResult: ptr VARIANT): HRESULT {.stdcall.} + getEnclosureList*: proc(self: ptr ISVGSVGElement, rect: ptr ISVGRect, referenceElement: ptr ISVGElement, pResult: ptr VARIANT): HRESULT {.stdcall.} + checkIntersection*: proc(self: ptr ISVGSVGElement, element: ptr ISVGElement, rect: ptr ISVGRect, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + checkEnclosure*: proc(self: ptr ISVGSVGElement, element: ptr ISVGElement, rect: ptr ISVGRect, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + deselectAll*: proc(self: ptr ISVGSVGElement): HRESULT {.stdcall.} + createSVGNumber*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + createSVGLength*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + createSVGAngle*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGAngle): HRESULT {.stdcall.} + createSVGPoint*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + createSVGMatrix*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + createSVGRect*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGRect): HRESULT {.stdcall.} + createSVGTransform*: proc(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + createSVGTransformFromMatrix*: proc(self: ptr ISVGSVGElement, matrix: ptr ISVGMatrix, pResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + getElementById*: proc(self: ptr ISVGSVGElement, elementId: BSTR, pResult: ptr ptr IHTMLElement): HRESULT {.stdcall.} + ISVGAnimatedEnumeration* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedEnumerationVtbl + ISVGAnimatedEnumerationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_baseVal*: proc(self: ptr ISVGAnimatedEnumeration, v: USHORT): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedEnumeration, p: ptr USHORT): HRESULT {.stdcall.} + put_animVal*: proc(self: ptr ISVGAnimatedEnumeration, v: USHORT): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedEnumeration, p: ptr USHORT): HRESULT {.stdcall.} + ISVGElement* {.pure.} = object + lpVtbl*: ptr ISVGElementVtbl + ISVGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_xmlbase*: proc(self: ptr ISVGElement, v: BSTR): HRESULT {.stdcall.} + get_xmlbase*: proc(self: ptr ISVGElement, p: ptr BSTR): HRESULT {.stdcall.} + putref_ownerSVGElement*: proc(self: ptr ISVGElement, v: ptr ISVGSVGElement): HRESULT {.stdcall.} + get_ownerSVGElement*: proc(self: ptr ISVGElement, p: ptr ptr ISVGSVGElement): HRESULT {.stdcall.} + putref_viewportElement*: proc(self: ptr ISVGElement, v: ptr ISVGElement): HRESULT {.stdcall.} + get_viewportElement*: proc(self: ptr ISVGElement, p: ptr ptr ISVGElement): HRESULT {.stdcall.} + putref_focusable*: proc(self: ptr ISVGElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_focusable*: proc(self: ptr ISVGElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + ISVGLocatable* {.pure.} = object + lpVtbl*: ptr ISVGLocatableVtbl + ISVGLocatableVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_nearestViewportElement*: proc(self: ptr ISVGLocatable, p: ptr ptr ISVGElement): HRESULT {.stdcall.} + get_farthestViewportElement*: proc(self: ptr ISVGLocatable, p: ptr ptr ISVGElement): HRESULT {.stdcall.} + getBBox*: proc(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGRect): HRESULT {.stdcall.} + getCTM*: proc(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + getScreenCTM*: proc(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + getTransformToElement*: proc(self: ptr ISVGLocatable, pElement: ptr ISVGElement, ppResult: ptr ptr ISVGMatrix): HRESULT {.stdcall.} + ISVGTransformList* {.pure.} = object + lpVtbl*: ptr ISVGTransformListVtbl + ISVGTransformListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGTransformList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGTransformList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGTransformList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGTransformList, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGTransformList, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + createSVGTransformFromMatrix*: proc(self: ptr ISVGTransformList, newItem: ptr ISVGMatrix, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + consolidate*: proc(self: ptr ISVGTransformList, ppResult: ptr ptr ISVGTransform): HRESULT {.stdcall.} + ISVGAnimatedTransformList* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedTransformListVtbl + ISVGAnimatedTransformListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedTransformList, v: ptr ISVGTransformList): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedTransformList, p: ptr ptr ISVGTransformList): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedTransformList, v: ptr ISVGTransformList): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedTransformList, p: ptr ptr ISVGTransformList): HRESULT {.stdcall.} + ISVGTransformable* {.pure.} = object + lpVtbl*: ptr ISVGTransformableVtbl + ISVGTransformableVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_transform*: proc(self: ptr ISVGTransformable, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.stdcall.} + ISVGStringList* {.pure.} = object + lpVtbl*: ptr ISVGStringListVtbl + ISVGStringListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGStringList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGStringList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGStringList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGStringList, newItem: BSTR, ppResult: ptr BSTR): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGStringList, index: LONG, ppResult: ptr BSTR): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGStringList, newItem: BSTR, index: LONG, ppResult: ptr BSTR): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGStringList, newItem: BSTR, index: LONG, ppResult: ptr BSTR): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGStringList, index: LONG, ppResult: ptr BSTR): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGStringList, newItem: BSTR, ppResult: ptr BSTR): HRESULT {.stdcall.} + ISVGTests* {.pure.} = object + lpVtbl*: ptr ISVGTestsVtbl + ISVGTestsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_requiredFeatures*: proc(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.stdcall.} + get_requiredExtensions*: proc(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.stdcall.} + get_systemLanguage*: proc(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.stdcall.} + hasExtension*: proc(self: ptr ISVGTests, extension: BSTR, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + ISVGLangSpace* {.pure.} = object + lpVtbl*: ptr ISVGLangSpaceVtbl + ISVGLangSpaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_xmllang*: proc(self: ptr ISVGLangSpace, v: BSTR): HRESULT {.stdcall.} + get_xmllang*: proc(self: ptr ISVGLangSpace, p: ptr BSTR): HRESULT {.stdcall.} + put_xmlspace*: proc(self: ptr ISVGLangSpace, v: BSTR): HRESULT {.stdcall.} + get_xmlspace*: proc(self: ptr ISVGLangSpace, p: ptr BSTR): HRESULT {.stdcall.} + ISVGAnimatedBoolean* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedBooleanVtbl + ISVGAnimatedBooleanVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_baseVal*: proc(self: ptr ISVGAnimatedBoolean, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedBoolean, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_animVal*: proc(self: ptr ISVGAnimatedBoolean, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedBoolean, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + ISVGExternalResourcesRequired* {.pure.} = object + lpVtbl*: ptr ISVGExternalResourcesRequiredVtbl + ISVGExternalResourcesRequiredVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_externalResourcesRequired*: proc(self: ptr ISVGExternalResourcesRequired, p: ptr ptr ISVGAnimatedBoolean): HRESULT {.stdcall.} + ISVGAnimatedRect* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedRectVtbl + ISVGAnimatedRectVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedRect, v: ptr ISVGRect): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedRect, p: ptr ptr ISVGRect): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedRect, v: ptr ISVGRect): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedRect, p: ptr ptr ISVGRect): HRESULT {.stdcall.} + ISVGPreserveAspectRatio* {.pure.} = object + lpVtbl*: ptr ISVGPreserveAspectRatioVtbl + ISVGPreserveAspectRatioVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_align*: proc(self: ptr ISVGPreserveAspectRatio, v: int16): HRESULT {.stdcall.} + get_align*: proc(self: ptr ISVGPreserveAspectRatio, p: ptr int16): HRESULT {.stdcall.} + put_meetOrSlice*: proc(self: ptr ISVGPreserveAspectRatio, v: int16): HRESULT {.stdcall.} + get_meetOrSlice*: proc(self: ptr ISVGPreserveAspectRatio, p: ptr int16): HRESULT {.stdcall.} + ISVGAnimatedPreserveAspectRatio* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedPreserveAspectRatioVtbl + ISVGAnimatedPreserveAspectRatioVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedPreserveAspectRatio, v: ptr ISVGPreserveAspectRatio): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedPreserveAspectRatio, p: ptr ptr ISVGPreserveAspectRatio): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedPreserveAspectRatio, v: ptr ISVGPreserveAspectRatio): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedPreserveAspectRatio, p: ptr ptr ISVGPreserveAspectRatio): HRESULT {.stdcall.} + ISVGFitToViewBox* {.pure.} = object + lpVtbl*: ptr ISVGFitToViewBoxVtbl + ISVGFitToViewBoxVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_viewBox*: proc(self: ptr ISVGFitToViewBox, p: ptr ptr ISVGAnimatedRect): HRESULT {.stdcall.} + putref_preserveAspectRatio*: proc(self: ptr ISVGFitToViewBox, v: ptr ISVGAnimatedPreserveAspectRatio): HRESULT {.stdcall.} + get_preserveAspectRatio*: proc(self: ptr ISVGFitToViewBox, p: ptr ptr ISVGAnimatedPreserveAspectRatio): HRESULT {.stdcall.} + ISVGZoomAndPan* {.pure.} = object + lpVtbl*: ptr ISVGZoomAndPanVtbl + ISVGZoomAndPanVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_zoomAndPan*: proc(self: ptr ISVGZoomAndPan, p: ptr int16): HRESULT {.stdcall.} + ISVGURIReference* {.pure.} = object + lpVtbl*: ptr ISVGURIReferenceVtbl + ISVGURIReferenceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_href*: proc(self: ptr ISVGURIReference, p: ptr ptr ISVGAnimatedString): HRESULT {.stdcall.} + ISVGAnimatedAngle* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedAngleVtbl + ISVGAnimatedAngleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedAngle, v: ptr ISVGAngle): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedAngle, p: ptr ptr ISVGAngle): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedAngle, v: ptr ISVGAngle): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedAngle, p: ptr ptr ISVGAngle): HRESULT {.stdcall.} + ISVGAnimatedInteger* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedIntegerVtbl + ISVGAnimatedIntegerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_baseVal*: proc(self: ptr ISVGAnimatedInteger, v: LONG): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedInteger, p: ptr LONG): HRESULT {.stdcall.} + put_animVal*: proc(self: ptr ISVGAnimatedInteger, v: LONG): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedInteger, p: ptr LONG): HRESULT {.stdcall.} + ISVGLengthList* {.pure.} = object + lpVtbl*: ptr ISVGLengthListVtbl + ISVGLengthListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGLengthList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGLengthList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGLengthList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGLengthList, newItem: ptr ISVGLength, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGLengthList, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGLengthList, newItem: ptr ISVGLength, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGLengthList, newItem: ptr ISVGLength, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGLengthList, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGLengthList, newItem: ptr ISVGLength, ppResult: ptr ptr ISVGLength): HRESULT {.stdcall.} + ISVGAnimatedLengthList* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedLengthListVtbl + ISVGAnimatedLengthListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedLengthList, v: ptr ISVGLengthList): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedLengthList, p: ptr ptr ISVGLengthList): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedLengthList, v: ptr ISVGLengthList): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedLengthList, p: ptr ptr ISVGLengthList): HRESULT {.stdcall.} + ISVGAnimatedNumber* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedNumberVtbl + ISVGAnimatedNumberVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_baseVal*: proc(self: ptr ISVGAnimatedNumber, v: float32): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedNumber, p: ptr float32): HRESULT {.stdcall.} + put_animVal*: proc(self: ptr ISVGAnimatedNumber, v: float32): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedNumber, p: ptr float32): HRESULT {.stdcall.} + ISVGNumberList* {.pure.} = object + lpVtbl*: ptr ISVGNumberListVtbl + ISVGNumberListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGNumberList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGNumberList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGNumberList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGNumberList, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGNumberList, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, ppResult: ptr ptr ISVGNumber): HRESULT {.stdcall.} + ISVGAnimatedNumberList* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedNumberListVtbl + ISVGAnimatedNumberListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_baseVal*: proc(self: ptr ISVGAnimatedNumberList, v: ptr ISVGNumberList): HRESULT {.stdcall.} + get_baseVal*: proc(self: ptr ISVGAnimatedNumberList, p: ptr ptr ISVGNumberList): HRESULT {.stdcall.} + putref_animVal*: proc(self: ptr ISVGAnimatedNumberList, v: ptr ISVGNumberList): HRESULT {.stdcall.} + get_animVal*: proc(self: ptr ISVGAnimatedNumberList, p: ptr ptr ISVGNumberList): HRESULT {.stdcall.} + ISVGClipPathElement* {.pure.} = object + lpVtbl*: ptr ISVGClipPathElementVtbl + ISVGClipPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_clipPathUnits*: proc(self: ptr ISVGClipPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_clipPathUnits*: proc(self: ptr ISVGClipPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + DispSVGClipPathElement* {.pure.} = object + lpVtbl*: ptr DispSVGClipPathElementVtbl + DispSVGClipPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGDocument* {.pure.} = object + lpVtbl*: ptr ISVGDocumentVtbl + ISVGDocumentVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_rootElement*: proc(self: ptr ISVGDocument, p: ptr ptr ISVGSVGElement): HRESULT {.stdcall.} + IGetSVGDocument* {.pure.} = object + lpVtbl*: ptr IGetSVGDocumentVtbl + IGetSVGDocumentVtbl* {.pure, inheritable.} = object of IDispatchVtbl + getSVGDocument*: proc(self: ptr IGetSVGDocument, ppSVGDocument: ptr ptr IDispatch): HRESULT {.stdcall.} + DispSVGElement* {.pure.} = object + lpVtbl*: ptr DispSVGElementVtbl + DispSVGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IICCSVGColor* {.pure.} = object + lpVtbl*: ptr IICCSVGColorVtbl + IICCSVGColorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPaint* {.pure.} = object + lpVtbl*: ptr ISVGPaintVtbl + ISVGPaintVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPatternElement* {.pure.} = object + lpVtbl*: ptr ISVGPatternElementVtbl + ISVGPatternElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_patternUnits*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_patternUnits*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_patternContentUnits*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_patternContentUnits*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_patternTransform*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedTransformList): HRESULT {.stdcall.} + get_patternTransform*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.stdcall.} + putref_x*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + DispSVGPatternElement* {.pure.} = object + lpVtbl*: ptr DispSVGPatternElementVtbl + DispSVGPatternElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPathSeg* {.pure.} = object + lpVtbl*: ptr ISVGPathSegVtbl + ISVGPathSegVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_pathSegType*: proc(self: ptr ISVGPathSeg, v: int16): HRESULT {.stdcall.} + get_pathSegType*: proc(self: ptr ISVGPathSeg, p: ptr int16): HRESULT {.stdcall.} + get_pathSegTypeAsLetter*: proc(self: ptr ISVGPathSeg, p: ptr BSTR): HRESULT {.stdcall.} + ISVGPathSegArcAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegArcAbsVtbl + ISVGPathSegArcAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.stdcall.} + put_r1*: proc(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.stdcall.} + get_r1*: proc(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.stdcall.} + put_r2*: proc(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.stdcall.} + get_r2*: proc(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.stdcall.} + put_angle*: proc(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.stdcall.} + get_angle*: proc(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.stdcall.} + put_largeArcFlag*: proc(self: ptr ISVGPathSegArcAbs, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_largeArcFlag*: proc(self: ptr ISVGPathSegArcAbs, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_sweepFlag*: proc(self: ptr ISVGPathSegArcAbs, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_sweepFlag*: proc(self: ptr ISVGPathSegArcAbs, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + ISVGPathSegArcRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegArcRelVtbl + ISVGPathSegArcRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.stdcall.} + put_r1*: proc(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.stdcall.} + get_r1*: proc(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.stdcall.} + put_r2*: proc(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.stdcall.} + get_r2*: proc(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.stdcall.} + put_angle*: proc(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.stdcall.} + get_angle*: proc(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.stdcall.} + put_largeArcFlag*: proc(self: ptr ISVGPathSegArcRel, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_largeArcFlag*: proc(self: ptr ISVGPathSegArcRel, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_sweepFlag*: proc(self: ptr ISVGPathSegArcRel, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_sweepFlag*: proc(self: ptr ISVGPathSegArcRel, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + ISVGPathSegClosePath* {.pure.} = object + lpVtbl*: ptr ISVGPathSegClosePathVtbl + ISVGPathSegClosePathVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPathSegMovetoAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegMovetoAbsVtbl + ISVGPathSegMovetoAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegMovetoAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegMovetoAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegMovetoAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegMovetoAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegMovetoRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegMovetoRelVtbl + ISVGPathSegMovetoRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegMovetoRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegMovetoRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegMovetoRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegMovetoRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoAbsVtbl + ISVGPathSegLinetoAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegLinetoAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegLinetoAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegLinetoAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegLinetoAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoRelVtbl + ISVGPathSegLinetoRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegLinetoRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegLinetoRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegLinetoRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegLinetoRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoCubicAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoCubicAbsVtbl + ISVGPathSegCurvetoCubicAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + put_x1*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + put_y1*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + put_x2*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + put_y2*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoCubicRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoCubicRelVtbl + ISVGPathSegCurvetoCubicRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + put_x1*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + put_y1*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + put_x2*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + put_y2*: proc(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoCubicSmoothAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoCubicSmoothAbsVtbl + ISVGPathSegCurvetoCubicSmoothAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + put_x2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + put_y2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoCubicSmoothRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoCubicSmoothRelVtbl + ISVGPathSegCurvetoCubicSmoothRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.stdcall.} + put_x2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.stdcall.} + put_y2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoQuadraticAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoQuadraticAbsVtbl + ISVGPathSegCurvetoQuadraticAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.stdcall.} + put_x1*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.stdcall.} + put_y1*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoQuadraticRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoQuadraticRelVtbl + ISVGPathSegCurvetoQuadraticRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.stdcall.} + put_x1*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.stdcall.} + put_y1*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoQuadraticSmoothAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoQuadraticSmoothAbsVtbl + ISVGPathSegCurvetoQuadraticSmoothAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegCurvetoQuadraticSmoothRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegCurvetoQuadraticSmoothRelVtbl + ISVGPathSegCurvetoQuadraticSmoothRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, p: ptr float32): HRESULT {.stdcall.} + put_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoHorizontalAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoHorizontalAbsVtbl + ISVGPathSegLinetoHorizontalAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegLinetoHorizontalAbs, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegLinetoHorizontalAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoHorizontalRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoHorizontalRelVtbl + ISVGPathSegLinetoHorizontalRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_x*: proc(self: ptr ISVGPathSegLinetoHorizontalRel, v: float32): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGPathSegLinetoHorizontalRel, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoVerticalAbs* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoVerticalAbsVtbl + ISVGPathSegLinetoVerticalAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_y*: proc(self: ptr ISVGPathSegLinetoVerticalAbs, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegLinetoVerticalAbs, p: ptr float32): HRESULT {.stdcall.} + ISVGPathSegLinetoVerticalRel* {.pure.} = object + lpVtbl*: ptr ISVGPathSegLinetoVerticalRelVtbl + ISVGPathSegLinetoVerticalRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_y*: proc(self: ptr ISVGPathSegLinetoVerticalRel, v: float32): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGPathSegLinetoVerticalRel, p: ptr float32): HRESULT {.stdcall.} + DispSVGPathSegArcAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegArcAbsVtbl + DispSVGPathSegArcAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegArcRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegArcRelVtbl + DispSVGPathSegArcRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegClosePath* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegClosePathVtbl + DispSVGPathSegClosePathVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegMovetoAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegMovetoAbsVtbl + DispSVGPathSegMovetoAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegMovetoRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegMovetoRelVtbl + DispSVGPathSegMovetoRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoAbsVtbl + DispSVGPathSegLinetoAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoRelVtbl + DispSVGPathSegLinetoRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoCubicAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoCubicAbsVtbl + DispSVGPathSegCurvetoCubicAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoCubicRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoCubicRelVtbl + DispSVGPathSegCurvetoCubicRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoCubicSmoothAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoCubicSmoothAbsVtbl + DispSVGPathSegCurvetoCubicSmoothAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoCubicSmoothRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoCubicSmoothRelVtbl + DispSVGPathSegCurvetoCubicSmoothRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoQuadraticAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoQuadraticAbsVtbl + DispSVGPathSegCurvetoQuadraticAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoQuadraticRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoQuadraticRelVtbl + DispSVGPathSegCurvetoQuadraticRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoQuadraticSmoothAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoQuadraticSmoothAbsVtbl + DispSVGPathSegCurvetoQuadraticSmoothAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegCurvetoQuadraticSmoothRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegCurvetoQuadraticSmoothRelVtbl + DispSVGPathSegCurvetoQuadraticSmoothRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoHorizontalAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoHorizontalAbsVtbl + DispSVGPathSegLinetoHorizontalAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoHorizontalRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoHorizontalRelVtbl + DispSVGPathSegLinetoHorizontalRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoVerticalAbs* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoVerticalAbsVtbl + DispSVGPathSegLinetoVerticalAbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPathSegLinetoVerticalRel* {.pure.} = object + lpVtbl*: ptr DispSVGPathSegLinetoVerticalRelVtbl + DispSVGPathSegLinetoVerticalRelVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPathSegList* {.pure.} = object + lpVtbl*: ptr ISVGPathSegListVtbl + ISVGPathSegListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGPathSegList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGPathSegList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGPathSegList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGPathSegList, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGPathSegList, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, ppResult: ptr ptr ISVGPathSeg): HRESULT {.stdcall.} + ISVGPointList* {.pure.} = object + lpVtbl*: ptr ISVGPointListVtbl + ISVGPointListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_numberOfItems*: proc(self: ptr ISVGPointList, v: LONG): HRESULT {.stdcall.} + get_numberOfItems*: proc(self: ptr ISVGPointList, p: ptr LONG): HRESULT {.stdcall.} + clear*: proc(self: ptr ISVGPointList): HRESULT {.stdcall.} + initialize*: proc(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + getItem*: proc(self: ptr ISVGPointList, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + insertItemBefore*: proc(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + replaceItem*: proc(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + removeItem*: proc(self: ptr ISVGPointList, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + appendItem*: proc(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + DispSVGSVGElement* {.pure.} = object + lpVtbl*: ptr DispSVGSVGElementVtbl + DispSVGSVGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGElementInstanceList* {.pure.} = object + lpVtbl*: ptr ISVGElementInstanceListVtbl + ISVGElementInstanceListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr ISVGElementInstanceList, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr ISVGElementInstanceList, index: LONG, ppResult: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + ISVGElementInstance* {.pure.} = object + lpVtbl*: ptr ISVGElementInstanceVtbl + ISVGElementInstanceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_correspondingElement*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElement): HRESULT {.stdcall.} + get_correspondingUseElement*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGUseElement): HRESULT {.stdcall.} + get_parentNode*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstanceList): HRESULT {.stdcall.} + get_firstChild*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + get_lastChild*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + get_previousSibling*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + get_nextSibling*: proc(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + ISVGUseElement* {.pure.} = object + lpVtbl*: ptr ISVGUseElementVtbl + ISVGUseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x*: proc(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_instanceRoot*: proc(self: ptr ISVGUseElement, v: ptr ISVGElementInstance): HRESULT {.stdcall.} + get_instanceRoot*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + putref_animatedInstanceRoot*: proc(self: ptr ISVGUseElement, v: ptr ISVGElementInstance): HRESULT {.stdcall.} + get_animatedInstanceRoot*: proc(self: ptr ISVGUseElement, p: ptr ptr ISVGElementInstance): HRESULT {.stdcall.} + DispSVGUseElement* {.pure.} = object + lpVtbl*: ptr DispSVGUseElementVtbl + DispSVGUseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLStyleSheetRulesAppliedCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLStyleSheetRulesAppliedCollectionVtbl + DispHTMLStyleSheetRulesAppliedCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispRulesApplied* {.pure.} = object + lpVtbl*: ptr DispRulesAppliedVtbl + DispRulesAppliedVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispRulesAppliedCollection* {.pure.} = object + lpVtbl*: ptr DispRulesAppliedCollectionVtbl + DispRulesAppliedCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLW3CComputedStyle* {.pure.} = object + lpVtbl*: ptr DispHTMLW3CComputedStyleVtbl + DispHTMLW3CComputedStyleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGAnimatedPoints* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedPointsVtbl + ISVGAnimatedPointsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_points*: proc(self: ptr ISVGAnimatedPoints, v: ptr ISVGPointList): HRESULT {.stdcall.} + get_points*: proc(self: ptr ISVGAnimatedPoints, p: ptr ptr ISVGPointList): HRESULT {.stdcall.} + putref_animatedPoints*: proc(self: ptr ISVGAnimatedPoints, v: ptr ISVGPointList): HRESULT {.stdcall.} + get_animatedPoints*: proc(self: ptr ISVGAnimatedPoints, p: ptr ptr ISVGPointList): HRESULT {.stdcall.} + ISVGCircleElement* {.pure.} = object + lpVtbl*: ptr ISVGCircleElementVtbl + ISVGCircleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_cx*: proc(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cx*: proc(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_cy*: proc(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cy*: proc(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_r*: proc(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_r*: proc(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + ISVGEllipseElement* {.pure.} = object + lpVtbl*: ptr ISVGEllipseElementVtbl + ISVGEllipseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_cx*: proc(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cx*: proc(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_cy*: proc(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cy*: proc(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_rx*: proc(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_rx*: proc(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_ry*: proc(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_ry*: proc(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + ISVGLineElement* {.pure.} = object + lpVtbl*: ptr ISVGLineElementVtbl + ISVGLineElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x1*: proc(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y1*: proc(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_x2*: proc(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y2*: proc(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + ISVGRectElement* {.pure.} = object + lpVtbl*: ptr ISVGRectElementVtbl + ISVGRectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_rx*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_rx*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_ry*: proc(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_ry*: proc(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + ISVGPolygonElement* {.pure.} = object + lpVtbl*: ptr ISVGPolygonElementVtbl + ISVGPolygonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGPolylineElement* {.pure.} = object + lpVtbl*: ptr ISVGPolylineElementVtbl + ISVGPolylineElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGCircleElement* {.pure.} = object + lpVtbl*: ptr DispSVGCircleElementVtbl + DispSVGCircleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGEllipseElement* {.pure.} = object + lpVtbl*: ptr DispSVGEllipseElementVtbl + DispSVGEllipseElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGLineElement* {.pure.} = object + lpVtbl*: ptr DispSVGLineElementVtbl + DispSVGLineElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGRectElement* {.pure.} = object + lpVtbl*: ptr DispSVGRectElementVtbl + DispSVGRectElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPolygonElement* {.pure.} = object + lpVtbl*: ptr DispSVGPolygonElementVtbl + DispSVGPolygonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGPolylineElement* {.pure.} = object + lpVtbl*: ptr DispSVGPolylineElementVtbl + DispSVGPolylineElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGGElement* {.pure.} = object + lpVtbl*: ptr ISVGGElementVtbl + ISVGGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGGElement* {.pure.} = object + lpVtbl*: ptr DispSVGGElementVtbl + DispSVGGElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGSymbolElement* {.pure.} = object + lpVtbl*: ptr ISVGSymbolElementVtbl + ISVGSymbolElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGSymbolElement* {.pure.} = object + lpVtbl*: ptr DispSVGSymbolElementVtbl + DispSVGSymbolElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGDefsElement* {.pure.} = object + lpVtbl*: ptr ISVGDefsElementVtbl + ISVGDefsElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGDefsElement* {.pure.} = object + lpVtbl*: ptr DispSVGDefsElementVtbl + DispSVGDefsElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGAnimatedPathData* {.pure.} = object + lpVtbl*: ptr ISVGAnimatedPathDataVtbl + ISVGAnimatedPathDataVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_pathSegList*: proc(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.stdcall.} + get_pathSegList*: proc(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.stdcall.} + putref_normalizedPathSegList*: proc(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.stdcall.} + get_normalizedPathSegList*: proc(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.stdcall.} + putref_animatedPathSegList*: proc(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.stdcall.} + get_animatedPathSegList*: proc(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.stdcall.} + putref_animatedNormalizedPathSegList*: proc(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.stdcall.} + get_animatedNormalizedPathSegList*: proc(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.stdcall.} + ISVGPathElement* {.pure.} = object + lpVtbl*: ptr ISVGPathElementVtbl + ISVGPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_pathLength*: proc(self: ptr ISVGPathElement, v: ptr ISVGAnimatedNumber): HRESULT {.stdcall.} + get_pathLength*: proc(self: ptr ISVGPathElement, p: ptr ptr ISVGAnimatedNumber): HRESULT {.stdcall.} + getTotalLength*: proc(self: ptr ISVGPathElement, pfltResult: ptr float32): HRESULT {.stdcall.} + getPointAtLength*: proc(self: ptr ISVGPathElement, fltdistance: float32, ppPointResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + getPathSegAtLength*: proc(self: ptr ISVGPathElement, fltdistance: float32, plResult: ptr LONG): HRESULT {.stdcall.} + createSVGPathSegClosePath*: proc(self: ptr ISVGPathElement, ppResult: ptr ptr ISVGPathSegClosePath): HRESULT {.stdcall.} + createSVGPathSegMovetoAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegMovetoAbs): HRESULT {.stdcall.} + createSVGPathSegMovetoRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegMovetoRel): HRESULT {.stdcall.} + createSVGPathSegLinetoAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegLinetoAbs): HRESULT {.stdcall.} + createSVGPathSegLinetoRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegLinetoRel): HRESULT {.stdcall.} + createSVGPathSegCurvetoCubicAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicAbs): HRESULT {.stdcall.} + createSVGPathSegCurvetoCubicRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicRel): HRESULT {.stdcall.} + createSVGPathSegCurvetoQuadraticAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticAbs): HRESULT {.stdcall.} + createSVGPathSegCurvetoQuadraticRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticRel): HRESULT {.stdcall.} + createSVGPathSegArcAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, r1: float32, r2: float32, angle: float32, largeArcFlag: VARIANT_BOOL, sweepFlag: VARIANT_BOOL, ppResult: ptr ptr ISVGPathSegArcAbs): HRESULT {.stdcall.} + createSVGPathSegArcRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, r1: float32, r2: float32, angle: float32, largeArcFlag: VARIANT_BOOL, sweepFlag: VARIANT_BOOL, ppResult: ptr ptr ISVGPathSegArcRel): HRESULT {.stdcall.} + createSVGPathSegLinetoHorizontalAbs*: proc(self: ptr ISVGPathElement, x: float32, ppResult: ptr ptr ISVGPathSegLinetoHorizontalAbs): HRESULT {.stdcall.} + createSVGPathSegLinetoHorizontalRel*: proc(self: ptr ISVGPathElement, x: float32, ppResult: ptr ptr ISVGPathSegLinetoHorizontalRel): HRESULT {.stdcall.} + createSVGPathSegLinetoVerticalAbs*: proc(self: ptr ISVGPathElement, y: float32, ppResult: ptr ptr ISVGPathSegLinetoVerticalAbs): HRESULT {.stdcall.} + createSVGPathSegLinetoVerticalRel*: proc(self: ptr ISVGPathElement, y: float32, ppResult: ptr ptr ISVGPathSegLinetoVerticalRel): HRESULT {.stdcall.} + createSVGPathSegCurvetoCubicSmoothAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicSmoothAbs): HRESULT {.stdcall.} + createSVGPathSegCurvetoCubicSmoothRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicSmoothRel): HRESULT {.stdcall.} + createSVGPathSegCurvetoQuadraticSmoothAbs*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticSmoothAbs): HRESULT {.stdcall.} + createSVGPathSegCurvetoQuadraticSmoothRel*: proc(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticSmoothRel): HRESULT {.stdcall.} + DispSVGPathElement* {.pure.} = object + lpVtbl*: ptr DispSVGPathElementVtbl + DispSVGPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTextElement* {.pure.} = object + lpVtbl*: ptr ISVGTextElementVtbl + ISVGTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGTextElement* {.pure.} = object + lpVtbl*: ptr DispSVGTextElementVtbl + DispSVGTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGImageElement* {.pure.} = object + lpVtbl*: ptr ISVGImageElementVtbl + ISVGImageElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x*: proc(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + DispSVGImageElement* {.pure.} = object + lpVtbl*: ptr DispSVGImageElementVtbl + DispSVGImageElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGStopElement* {.pure.} = object + lpVtbl*: ptr ISVGStopElementVtbl + ISVGStopElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_offset*: proc(self: ptr ISVGStopElement, v: ptr ISVGAnimatedNumber): HRESULT {.stdcall.} + get_offset*: proc(self: ptr ISVGStopElement, p: ptr ptr ISVGAnimatedNumber): HRESULT {.stdcall.} + DispSVGStopElement* {.pure.} = object + lpVtbl*: ptr DispSVGStopElementVtbl + DispSVGStopElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGGradientElement* {.pure.} = object + lpVtbl*: ptr ISVGGradientElementVtbl + ISVGGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_gradientUnits*: proc(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_gradientUnits*: proc(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_gradientTransform*: proc(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedTransformList): HRESULT {.stdcall.} + get_gradientTransform*: proc(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.stdcall.} + putref_spreadMethod*: proc(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_spreadMethod*: proc(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + DispSVGGradientElement* {.pure.} = object + lpVtbl*: ptr DispSVGGradientElementVtbl + DispSVGGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGLinearGradientElement* {.pure.} = object + lpVtbl*: ptr ISVGLinearGradientElementVtbl + ISVGLinearGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x1*: proc(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x1*: proc(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y1*: proc(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y1*: proc(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_x2*: proc(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x2*: proc(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y2*: proc(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y2*: proc(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + DispSVGLinearGradientElement* {.pure.} = object + lpVtbl*: ptr DispSVGLinearGradientElementVtbl + DispSVGLinearGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGRadialGradientElement* {.pure.} = object + lpVtbl*: ptr ISVGRadialGradientElementVtbl + ISVGRadialGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_cx*: proc(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cx*: proc(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_cy*: proc(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_cy*: proc(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_r*: proc(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_r*: proc(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_fx*: proc(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_fx*: proc(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_fy*: proc(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_fy*: proc(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + DispSVGRadialGradientElement* {.pure.} = object + lpVtbl*: ptr DispSVGRadialGradientElementVtbl + DispSVGRadialGradientElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGMaskElement* {.pure.} = object + lpVtbl*: ptr ISVGMaskElementVtbl + ISVGMaskElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_maskUnits*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_maskUnits*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_maskContentUnits*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_maskContentUnits*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_x*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_width*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_width*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_height*: proc(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_height*: proc(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + DispSVGMaskElement* {.pure.} = object + lpVtbl*: ptr DispSVGMaskElementVtbl + DispSVGMaskElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGMarkerElement* {.pure.} = object + lpVtbl*: ptr ISVGMarkerElementVtbl + ISVGMarkerElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_refX*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_refX*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_refY*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_refY*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_markerUnits*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_markerUnits*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_markerWidth*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_markerWidth*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_markerHeight*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_markerHeight*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_orientType*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_orientType*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_orientAngle*: proc(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedAngle): HRESULT {.stdcall.} + get_orientAngle*: proc(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedAngle): HRESULT {.stdcall.} + setOrientToAuto*: proc(self: ptr ISVGMarkerElement): HRESULT {.stdcall.} + setOrientToAngle*: proc(self: ptr ISVGMarkerElement, pSVGAngle: ptr ISVGAngle): HRESULT {.stdcall.} + DispSVGMarkerElement* {.pure.} = object + lpVtbl*: ptr DispSVGMarkerElementVtbl + DispSVGMarkerElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGZoomEvent* {.pure.} = object + lpVtbl*: ptr ISVGZoomEventVtbl + ISVGZoomEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_zoomRectScreen*: proc(self: ptr ISVGZoomEvent, p: ptr ptr ISVGRect): HRESULT {.stdcall.} + get_previousScale*: proc(self: ptr ISVGZoomEvent, p: ptr float32): HRESULT {.stdcall.} + get_previousTranslate*: proc(self: ptr ISVGZoomEvent, p: ptr ptr ISVGPoint): HRESULT {.stdcall.} + get_newScale*: proc(self: ptr ISVGZoomEvent, p: ptr float32): HRESULT {.stdcall.} + get_newTranslate*: proc(self: ptr ISVGZoomEvent, p: ptr ptr ISVGPoint): HRESULT {.stdcall.} + DispSVGZoomEvent* {.pure.} = object + lpVtbl*: ptr DispSVGZoomEventVtbl + DispSVGZoomEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGAElement* {.pure.} = object + lpVtbl*: ptr ISVGAElementVtbl + ISVGAElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_target*: proc(self: ptr ISVGAElement, v: ptr ISVGAnimatedString): HRESULT {.stdcall.} + get_target*: proc(self: ptr ISVGAElement, p: ptr ptr ISVGAnimatedString): HRESULT {.stdcall.} + DispSVGAElement* {.pure.} = object + lpVtbl*: ptr DispSVGAElementVtbl + DispSVGAElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGViewElement* {.pure.} = object + lpVtbl*: ptr ISVGViewElementVtbl + ISVGViewElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_viewTarget*: proc(self: ptr ISVGViewElement, v: ptr ISVGStringList): HRESULT {.stdcall.} + get_viewTarget*: proc(self: ptr ISVGViewElement, p: ptr ptr ISVGStringList): HRESULT {.stdcall.} + DispSVGViewElement* {.pure.} = object + lpVtbl*: ptr DispSVGViewElementVtbl + DispSVGViewElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLMediaError* {.pure.} = object + lpVtbl*: ptr IHTMLMediaErrorVtbl + IHTMLMediaErrorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_code*: proc(self: ptr IHTMLMediaError, p: ptr int16): HRESULT {.stdcall.} + IHTMLTimeRanges* {.pure.} = object + lpVtbl*: ptr IHTMLTimeRangesVtbl + IHTMLTimeRangesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLTimeRanges, p: ptr LONG): HRESULT {.stdcall.} + start*: proc(self: ptr IHTMLTimeRanges, index: LONG, startTime: ptr float32): HRESULT {.stdcall.} + `end`*: proc(self: ptr IHTMLTimeRanges, index: LONG, endTime: ptr float32): HRESULT {.stdcall.} + IHTMLTimeRanges2* {.pure.} = object + lpVtbl*: ptr IHTMLTimeRanges2Vtbl + IHTMLTimeRanges2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + startDouble*: proc(self: ptr IHTMLTimeRanges2, index: LONG, startTime: ptr float64): HRESULT {.stdcall.} + endDouble*: proc(self: ptr IHTMLTimeRanges2, index: LONG, endTime: ptr float64): HRESULT {.stdcall.} + IHTMLMediaElement* {.pure.} = object + lpVtbl*: ptr IHTMLMediaElementVtbl + IHTMLMediaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_error*: proc(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLMediaError): HRESULT {.stdcall.} + put_src*: proc(self: ptr IHTMLMediaElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.stdcall.} + get_currentSrc*: proc(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.stdcall.} + get_networkState*: proc(self: ptr IHTMLMediaElement, p: ptr USHORT): HRESULT {.stdcall.} + put_preload*: proc(self: ptr IHTMLMediaElement, v: BSTR): HRESULT {.stdcall.} + get_preload*: proc(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.stdcall.} + get_buffered*: proc(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.stdcall.} + load*: proc(self: ptr IHTMLMediaElement): HRESULT {.stdcall.} + canPlayType*: proc(self: ptr IHTMLMediaElement, `type`: BSTR, canPlay: ptr BSTR): HRESULT {.stdcall.} + get_seeking*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_currentTime*: proc(self: ptr IHTMLMediaElement, v: float32): HRESULT {.stdcall.} + get_currentTime*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + get_initialTime*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + get_duration*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + get_paused*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_defaultPlaybackRate*: proc(self: ptr IHTMLMediaElement, v: float32): HRESULT {.stdcall.} + get_defaultPlaybackRate*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + put_playbackRate*: proc(self: ptr IHTMLMediaElement, v: float32): HRESULT {.stdcall.} + get_playbackRate*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + get_played*: proc(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.stdcall.} + get_seekable*: proc(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.stdcall.} + get_ended*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_autoplay*: proc(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_autoplay*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_loop*: proc(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_loop*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + play*: proc(self: ptr IHTMLMediaElement): HRESULT {.stdcall.} + pause*: proc(self: ptr IHTMLMediaElement): HRESULT {.stdcall.} + put_controls*: proc(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_controls*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_volume*: proc(self: ptr IHTMLMediaElement, v: float32): HRESULT {.stdcall.} + get_volume*: proc(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.stdcall.} + put_muted*: proc(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_muted*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_autobuffer*: proc(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_autobuffer*: proc(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLMediaElement2* {.pure.} = object + lpVtbl*: ptr IHTMLMediaElement2Vtbl + IHTMLMediaElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_currentTimeDouble*: proc(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.stdcall.} + get_currentTimeDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + get_initialTimeDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + get_durationDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + put_defaultPlaybackRateDouble*: proc(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.stdcall.} + get_defaultPlaybackRateDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + put_playbackRateDouble*: proc(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.stdcall.} + get_playbackRateDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + put_volumeDouble*: proc(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.stdcall.} + get_volumeDouble*: proc(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.stdcall.} + IHTMLMSMediaElement* {.pure.} = object + lpVtbl*: ptr IHTMLMSMediaElementVtbl + IHTMLMSMediaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_msPlayToDisabled*: proc(self: ptr IHTMLMSMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_msPlayToDisabled*: proc(self: ptr IHTMLMSMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_msPlayToPrimary*: proc(self: ptr IHTMLMSMediaElement, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_msPlayToPrimary*: proc(self: ptr IHTMLMSMediaElement, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLSourceElement* {.pure.} = object + lpVtbl*: ptr IHTMLSourceElementVtbl + IHTMLSourceElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_src*: proc(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.stdcall.} + get_src*: proc(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.stdcall.} + put_type*: proc(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.stdcall.} + put_media*: proc(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLAudioElement* {.pure.} = object + lpVtbl*: ptr IHTMLAudioElementVtbl + IHTMLAudioElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLVideoElement* {.pure.} = object + lpVtbl*: ptr IHTMLVideoElementVtbl + IHTMLVideoElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_width*: proc(self: ptr IHTMLVideoElement, v: LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IHTMLVideoElement, p: ptr LONG): HRESULT {.stdcall.} + put_height*: proc(self: ptr IHTMLVideoElement, v: LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IHTMLVideoElement, p: ptr LONG): HRESULT {.stdcall.} + get_videoWidth*: proc(self: ptr IHTMLVideoElement, p: ptr ULONG): HRESULT {.stdcall.} + get_videoHeight*: proc(self: ptr IHTMLVideoElement, p: ptr ULONG): HRESULT {.stdcall.} + put_poster*: proc(self: ptr IHTMLVideoElement, v: BSTR): HRESULT {.stdcall.} + get_poster*: proc(self: ptr IHTMLVideoElement, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLAudioElementFactory* {.pure.} = object + lpVtbl*: ptr IHTMLAudioElementFactoryVtbl + IHTMLAudioElementFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IHTMLAudioElementFactory, src: VARIANT, a: ptr ptr IHTMLAudioElement): HRESULT {.stdcall.} + DispHTMLMediaError* {.pure.} = object + lpVtbl*: ptr DispHTMLMediaErrorVtbl + DispHTMLMediaErrorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLTimeRanges* {.pure.} = object + lpVtbl*: ptr DispHTMLTimeRangesVtbl + DispHTMLTimeRangesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLMediaElement* {.pure.} = object + lpVtbl*: ptr DispHTMLMediaElementVtbl + DispHTMLMediaElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLSourceElement* {.pure.} = object + lpVtbl*: ptr DispHTMLSourceElementVtbl + DispHTMLSourceElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLAudioElement* {.pure.} = object + lpVtbl*: ptr DispHTMLAudioElementVtbl + DispHTMLAudioElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLVideoElement* {.pure.} = object + lpVtbl*: ptr DispHTMLVideoElementVtbl + DispHTMLVideoElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGSwitchElement* {.pure.} = object + lpVtbl*: ptr ISVGSwitchElementVtbl + ISVGSwitchElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGSwitchElement* {.pure.} = object + lpVtbl*: ptr DispSVGSwitchElementVtbl + DispSVGSwitchElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGDescElement* {.pure.} = object + lpVtbl*: ptr ISVGDescElementVtbl + ISVGDescElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGDescElement* {.pure.} = object + lpVtbl*: ptr DispSVGDescElementVtbl + DispSVGDescElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTitleElement* {.pure.} = object + lpVtbl*: ptr ISVGTitleElementVtbl + ISVGTitleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGTitleElement* {.pure.} = object + lpVtbl*: ptr DispSVGTitleElementVtbl + DispSVGTitleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGMetadataElement* {.pure.} = object + lpVtbl*: ptr ISVGMetadataElementVtbl + ISVGMetadataElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGMetadataElement* {.pure.} = object + lpVtbl*: ptr DispSVGMetadataElementVtbl + DispSVGMetadataElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGElementInstance* {.pure.} = object + lpVtbl*: ptr DispSVGElementInstanceVtbl + DispSVGElementInstanceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGElementInstanceList* {.pure.} = object + lpVtbl*: ptr DispSVGElementInstanceListVtbl + DispSVGElementInstanceListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMException* {.pure.} = object + lpVtbl*: ptr IDOMExceptionVtbl + IDOMExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_code*: proc(self: ptr IDOMException, v: LONG): HRESULT {.stdcall.} + get_code*: proc(self: ptr IDOMException, p: ptr LONG): HRESULT {.stdcall.} + get_message*: proc(self: ptr IDOMException, p: ptr BSTR): HRESULT {.stdcall.} + IRangeException* {.pure.} = object + lpVtbl*: ptr IRangeExceptionVtbl + IRangeExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_code*: proc(self: ptr IRangeException, v: LONG): HRESULT {.stdcall.} + get_code*: proc(self: ptr IRangeException, p: ptr LONG): HRESULT {.stdcall.} + get_message*: proc(self: ptr IRangeException, p: ptr BSTR): HRESULT {.stdcall.} + ISVGException* {.pure.} = object + lpVtbl*: ptr ISVGExceptionVtbl + ISVGExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_code*: proc(self: ptr ISVGException, v: LONG): HRESULT {.stdcall.} + get_code*: proc(self: ptr ISVGException, p: ptr LONG): HRESULT {.stdcall.} + get_message*: proc(self: ptr ISVGException, p: ptr BSTR): HRESULT {.stdcall.} + IEventException* {.pure.} = object + lpVtbl*: ptr IEventExceptionVtbl + IEventExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_code*: proc(self: ptr IEventException, v: LONG): HRESULT {.stdcall.} + get_code*: proc(self: ptr IEventException, p: ptr LONG): HRESULT {.stdcall.} + get_message*: proc(self: ptr IEventException, p: ptr BSTR): HRESULT {.stdcall.} + DispDOMException* {.pure.} = object + lpVtbl*: ptr DispDOMExceptionVtbl + DispDOMExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispRangeException* {.pure.} = object + lpVtbl*: ptr DispRangeExceptionVtbl + DispRangeExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGException* {.pure.} = object + lpVtbl*: ptr DispSVGExceptionVtbl + DispSVGExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispEventException* {.pure.} = object + lpVtbl*: ptr DispEventExceptionVtbl + DispEventExceptionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGScriptElement* {.pure.} = object + lpVtbl*: ptr ISVGScriptElementVtbl + ISVGScriptElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr ISVGScriptElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr ISVGScriptElement, p: ptr BSTR): HRESULT {.stdcall.} + DispSVGScriptElement* {.pure.} = object + lpVtbl*: ptr DispSVGScriptElementVtbl + DispSVGScriptElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGStyleElement* {.pure.} = object + lpVtbl*: ptr ISVGStyleElementVtbl + ISVGStyleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_type*: proc(self: ptr ISVGStyleElement, v: BSTR): HRESULT {.stdcall.} + get_type*: proc(self: ptr ISVGStyleElement, p: ptr BSTR): HRESULT {.stdcall.} + put_media*: proc(self: ptr ISVGStyleElement, v: BSTR): HRESULT {.stdcall.} + get_media*: proc(self: ptr ISVGStyleElement, p: ptr BSTR): HRESULT {.stdcall.} + DispSVGStyleElement* {.pure.} = object + lpVtbl*: ptr DispSVGStyleElementVtbl + DispSVGStyleElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTextContentElement* {.pure.} = object + lpVtbl*: ptr ISVGTextContentElementVtbl + ISVGTextContentElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_textLength*: proc(self: ptr ISVGTextContentElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_textLength*: proc(self: ptr ISVGTextContentElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_lengthAdjust*: proc(self: ptr ISVGTextContentElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_lengthAdjust*: proc(self: ptr ISVGTextContentElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + getNumberOfChars*: proc(self: ptr ISVGTextContentElement, pResult: ptr LONG): HRESULT {.stdcall.} + getComputedTextLength*: proc(self: ptr ISVGTextContentElement, pResult: ptr float32): HRESULT {.stdcall.} + getSubStringLength*: proc(self: ptr ISVGTextContentElement, charnum: LONG, nchars: LONG, pResult: ptr float32): HRESULT {.stdcall.} + getStartPositionOfChar*: proc(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + getEndPositionOfChar*: proc(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.stdcall.} + getExtentOfChar*: proc(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGRect): HRESULT {.stdcall.} + getRotationOfChar*: proc(self: ptr ISVGTextContentElement, charnum: LONG, pResult: ptr float32): HRESULT {.stdcall.} + getCharNumAtPosition*: proc(self: ptr ISVGTextContentElement, point: ptr ISVGPoint, pResult: ptr LONG): HRESULT {.stdcall.} + selectSubString*: proc(self: ptr ISVGTextContentElement, charnum: LONG, nchars: LONG): HRESULT {.stdcall.} + DispSVGTextContentElement* {.pure.} = object + lpVtbl*: ptr DispSVGTextContentElementVtbl + DispSVGTextContentElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTextPositioningElement* {.pure.} = object + lpVtbl*: ptr ISVGTextPositioningElementVtbl + ISVGTextPositioningElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_x*: proc(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + get_x*: proc(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + putref_y*: proc(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + get_y*: proc(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + putref_dx*: proc(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + get_dx*: proc(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + putref_dy*: proc(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + get_dy*: proc(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.stdcall.} + putref_rotate*: proc(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedNumberList): HRESULT {.stdcall.} + get_rotate*: proc(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedNumberList): HRESULT {.stdcall.} + DispSVGTextPositioningElement* {.pure.} = object + lpVtbl*: ptr DispSVGTextPositioningElementVtbl + DispSVGTextPositioningElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispDOMDocumentType* {.pure.} = object + lpVtbl*: ptr DispDOMDocumentTypeVtbl + DispDOMDocumentTypeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispNodeIterator* {.pure.} = object + lpVtbl*: ptr DispNodeIteratorVtbl + DispNodeIteratorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispTreeWalker* {.pure.} = object + lpVtbl*: ptr DispTreeWalkerVtbl + DispTreeWalkerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispDOMProcessingInstruction* {.pure.} = object + lpVtbl*: ptr DispDOMProcessingInstructionVtbl + DispDOMProcessingInstructionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLPerformanceNavigation* {.pure.} = object + lpVtbl*: ptr IHTMLPerformanceNavigationVtbl + IHTMLPerformanceNavigationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_type*: proc(self: ptr IHTMLPerformanceNavigation, p: ptr ULONG): HRESULT {.stdcall.} + get_redirectCount*: proc(self: ptr IHTMLPerformanceNavigation, p: ptr ULONG): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLPerformanceNavigation, string: ptr BSTR): HRESULT {.stdcall.} + toJSON*: proc(self: ptr IHTMLPerformanceNavigation, pVar: ptr VARIANT): HRESULT {.stdcall.} + IHTMLPerformanceTiming* {.pure.} = object + lpVtbl*: ptr IHTMLPerformanceTimingVtbl + IHTMLPerformanceTimingVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_navigationStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_unloadEventStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_unloadEventEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_redirectStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_redirectEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_fetchStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domainLookupStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domainLookupEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_connectStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_connectEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_requestStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_responseStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_responseEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domLoading*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domInteractive*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domContentLoadedEventStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domContentLoadedEventEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_domComplete*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_loadEventStart*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_loadEventEnd*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + get_msFirstPaint*: proc(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLPerformanceTiming, string: ptr BSTR): HRESULT {.stdcall.} + toJSON*: proc(self: ptr IHTMLPerformanceTiming, pVar: ptr VARIANT): HRESULT {.stdcall.} + IHTMLPerformance* {.pure.} = object + lpVtbl*: ptr IHTMLPerformanceVtbl + IHTMLPerformanceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_navigation*: proc(self: ptr IHTMLPerformance, p: ptr ptr IHTMLPerformanceNavigation): HRESULT {.stdcall.} + get_timing*: proc(self: ptr IHTMLPerformance, p: ptr ptr IHTMLPerformanceTiming): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLPerformance, string: ptr BSTR): HRESULT {.stdcall.} + toJSON*: proc(self: ptr IHTMLPerformance, pVar: ptr VARIANT): HRESULT {.stdcall.} + DispHTMLPerformance* {.pure.} = object + lpVtbl*: ptr DispHTMLPerformanceVtbl + DispHTMLPerformanceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLPerformanceNavigation* {.pure.} = object + lpVtbl*: ptr DispHTMLPerformanceNavigationVtbl + DispHTMLPerformanceNavigationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLPerformanceTiming* {.pure.} = object + lpVtbl*: ptr DispHTMLPerformanceTimingVtbl + DispHTMLPerformanceTimingVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTSpanElement* {.pure.} = object + lpVtbl*: ptr ISVGTSpanElementVtbl + ISVGTSpanElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispSVGTSpanElement* {.pure.} = object + lpVtbl*: ptr DispSVGTSpanElementVtbl + DispSVGTSpanElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ITemplatePrinter* {.pure.} = object + lpVtbl*: ptr ITemplatePrinterVtbl + ITemplatePrinterVtbl* {.pure, inheritable.} = object of IDispatchVtbl + startDoc*: proc(self: ptr ITemplatePrinter, bstrTitle: BSTR, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + stopDoc*: proc(self: ptr ITemplatePrinter): HRESULT {.stdcall.} + printBlankPage*: proc(self: ptr ITemplatePrinter): HRESULT {.stdcall.} + printPage*: proc(self: ptr ITemplatePrinter, pElemDisp: ptr IDispatch): HRESULT {.stdcall.} + ensurePrintDialogDefaults*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + showPrintDialog*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + showPageSetupDialog*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + printNonNative*: proc(self: ptr ITemplatePrinter, pMarkup: ptr IUnknown, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + printNonNativeFrames*: proc(self: ptr ITemplatePrinter, pMarkup: ptr IUnknown, fActiveFrame: VARIANT_BOOL): HRESULT {.stdcall.} + put_framesetDocument*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_framesetDocument*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_frameActive*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_frameActive*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_frameAsShown*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_frameAsShown*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_selection*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_selection*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_selectedPages*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_selectedPages*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_currentPage*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_currentPage*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_currentPageAvail*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_currentPageAvail*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_collate*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_collate*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_duplex*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_copies*: proc(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.stdcall.} + get_copies*: proc(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.stdcall.} + put_pageFrom*: proc(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.stdcall.} + get_pageFrom*: proc(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.stdcall.} + put_pageTo*: proc(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.stdcall.} + get_pageTo*: proc(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.stdcall.} + put_tableOfLinks*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_tableOfLinks*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_allLinkedDocuments*: proc(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_allLinkedDocuments*: proc(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_header*: proc(self: ptr ITemplatePrinter, v: BSTR): HRESULT {.stdcall.} + get_header*: proc(self: ptr ITemplatePrinter, p: ptr BSTR): HRESULT {.stdcall.} + put_footer*: proc(self: ptr ITemplatePrinter, v: BSTR): HRESULT {.stdcall.} + get_footer*: proc(self: ptr ITemplatePrinter, p: ptr BSTR): HRESULT {.stdcall.} + put_marginLeft*: proc(self: ptr ITemplatePrinter, v: LONG): HRESULT {.stdcall.} + get_marginLeft*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + put_marginRight*: proc(self: ptr ITemplatePrinter, v: LONG): HRESULT {.stdcall.} + get_marginRight*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + put_marginTop*: proc(self: ptr ITemplatePrinter, v: LONG): HRESULT {.stdcall.} + get_marginTop*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + put_marginBottom*: proc(self: ptr ITemplatePrinter, v: LONG): HRESULT {.stdcall.} + get_marginBottom*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_pageWidth*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_pageHeight*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_unprintableLeft*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_unprintableTop*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_unprintableRight*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + get_unprintableBottom*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + updatePageStatus*: proc(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.stdcall.} + ITemplatePrinter2* {.pure.} = object + lpVtbl*: ptr ITemplatePrinter2Vtbl + ITemplatePrinter2Vtbl* {.pure, inheritable.} = object of ITemplatePrinterVtbl + put_selectionEnabled*: proc(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_selectionEnabled*: proc(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_frameActiveEnabled*: proc(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_frameActiveEnabled*: proc(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_orientation*: proc(self: ptr ITemplatePrinter2, v: BSTR): HRESULT {.stdcall.} + get_orientation*: proc(self: ptr ITemplatePrinter2, p: ptr BSTR): HRESULT {.stdcall.} + put_usePrinterCopyCollate*: proc(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.stdcall.} + get_usePrinterCopyCollate*: proc(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + deviceSupports*: proc(self: ptr ITemplatePrinter2, bstrProperty: BSTR, pvar: ptr VARIANT): HRESULT {.stdcall.} + ITemplatePrinter3* {.pure.} = object + lpVtbl*: ptr ITemplatePrinter3Vtbl + ITemplatePrinter3Vtbl* {.pure, inheritable.} = object of ITemplatePrinter2Vtbl + put_headerFooterFont*: proc(self: ptr ITemplatePrinter3, v: BSTR): HRESULT {.stdcall.} + get_headerFooterFont*: proc(self: ptr ITemplatePrinter3, p: ptr BSTR): HRESULT {.stdcall.} + getPageMarginTop*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.stdcall.} + getPageMarginRight*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.stdcall.} + getPageMarginBottom*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.stdcall.} + getPageMarginLeft*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.stdcall.} + getPageMarginTopImportant*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getPageMarginRightImportant*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getPageMarginBottomImportant*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getPageMarginLeftImportant*: proc(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IPrintManagerTemplatePrinter* {.pure.} = object + lpVtbl*: ptr IPrintManagerTemplatePrinterVtbl + IPrintManagerTemplatePrinterVtbl* {.pure, inheritable.} = object of IDispatchVtbl + startPrint*: proc(self: ptr IPrintManagerTemplatePrinter): HRESULT {.stdcall.} + drawPreviewPage*: proc(self: ptr IPrintManagerTemplatePrinter, pElemDisp: ptr IDispatch, nPage: LONG): HRESULT {.stdcall.} + setPageCount*: proc(self: ptr IPrintManagerTemplatePrinter, nPage: LONG): HRESULT {.stdcall.} + invalidatePreview*: proc(self: ptr IPrintManagerTemplatePrinter): HRESULT {.stdcall.} + getPrintTaskOptionValue*: proc(self: ptr IPrintManagerTemplatePrinter, bstrKey: BSTR, pvarin: ptr VARIANT): HRESULT {.stdcall.} + endPrint*: proc(self: ptr IPrintManagerTemplatePrinter): HRESULT {.stdcall.} + DispCPrintManagerTemplatePrinter* {.pure.} = object + lpVtbl*: ptr DispCPrintManagerTemplatePrinterVtbl + DispCPrintManagerTemplatePrinterVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ISVGTextPathElement* {.pure.} = object + lpVtbl*: ptr ISVGTextPathElementVtbl + ISVGTextPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + putref_startOffset*: proc(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedLength): HRESULT {.stdcall.} + get_startOffset*: proc(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.stdcall.} + putref_method*: proc(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_method*: proc(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + putref_spacing*: proc(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + get_spacing*: proc(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.stdcall.} + DispSVGTextPathElement* {.pure.} = object + lpVtbl*: ptr DispSVGTextPathElementVtbl + DispSVGTextPathElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMXmlSerializer* {.pure.} = object + lpVtbl*: ptr IDOMXmlSerializerVtbl + IDOMXmlSerializerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + serializeToString*: proc(self: ptr IDOMXmlSerializer, pNode: ptr IHTMLDOMNode, pString: ptr BSTR): HRESULT {.stdcall.} + IDOMXmlSerializerFactory* {.pure.} = object + lpVtbl*: ptr IDOMXmlSerializerFactoryVtbl + IDOMXmlSerializerFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IDOMXmlSerializerFactory, a: ptr ptr IDOMXmlSerializer): HRESULT {.stdcall.} + IDOMParser* {.pure.} = object + lpVtbl*: ptr IDOMParserVtbl + IDOMParserVtbl* {.pure, inheritable.} = object of IDispatchVtbl + parseFromString*: proc(self: ptr IDOMParser, xmlSource: BSTR, mimeType: BSTR, ppNode: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + IDOMParserFactory* {.pure.} = object + lpVtbl*: ptr IDOMParserFactoryVtbl + IDOMParserFactoryVtbl* {.pure, inheritable.} = object of IDispatchVtbl + create*: proc(self: ptr IDOMParserFactory, a: ptr ptr IDOMParser): HRESULT {.stdcall.} + DispXMLSerializer* {.pure.} = object + lpVtbl*: ptr DispXMLSerializerVtbl + DispXMLSerializerVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispDOMParser* {.pure.} = object + lpVtbl*: ptr DispDOMParserVtbl + DispDOMParserVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLSemanticElement* {.pure.} = object + lpVtbl*: ptr DispHTMLSemanticElementVtbl + DispHTMLSemanticElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLProgressElement* {.pure.} = object + lpVtbl*: ptr IHTMLProgressElementVtbl + IHTMLProgressElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_value*: proc(self: ptr IHTMLProgressElement, v: float32): HRESULT {.stdcall.} + get_value*: proc(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.stdcall.} + put_max*: proc(self: ptr IHTMLProgressElement, v: float32): HRESULT {.stdcall.} + get_max*: proc(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.stdcall.} + get_position*: proc(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.stdcall.} + get_form*: proc(self: ptr IHTMLProgressElement, p: ptr ptr IHTMLFormElement): HRESULT {.stdcall.} + DispHTMLProgressElement* {.pure.} = object + lpVtbl*: ptr DispHTMLProgressElementVtbl + DispHTMLProgressElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMSTransitionEvent* {.pure.} = object + lpVtbl*: ptr IDOMMSTransitionEventVtbl + IDOMMSTransitionEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_propertyName*: proc(self: ptr IDOMMSTransitionEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_elapsedTime*: proc(self: ptr IDOMMSTransitionEvent, p: ptr float32): HRESULT {.stdcall.} + initMSTransitionEvent*: proc(self: ptr IDOMMSTransitionEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, propertyName: BSTR, elapsedTime: float32): HRESULT {.stdcall.} + DispDOMMSTransitionEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMSTransitionEventVtbl + DispDOMMSTransitionEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMMSAnimationEvent* {.pure.} = object + lpVtbl*: ptr IDOMMSAnimationEventVtbl + IDOMMSAnimationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_animationName*: proc(self: ptr IDOMMSAnimationEvent, p: ptr BSTR): HRESULT {.stdcall.} + get_elapsedTime*: proc(self: ptr IDOMMSAnimationEvent, p: ptr float32): HRESULT {.stdcall.} + initMSAnimationEvent*: proc(self: ptr IDOMMSAnimationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, animationName: BSTR, elapsedTime: float32): HRESULT {.stdcall.} + DispDOMMSAnimationEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMSAnimationEventVtbl + DispDOMMSAnimationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IWebGeocoordinates* {.pure.} = object + lpVtbl*: ptr IWebGeocoordinatesVtbl + IWebGeocoordinatesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_latitude*: proc(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.stdcall.} + get_longitude*: proc(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.stdcall.} + get_altitude*: proc(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.stdcall.} + get_accuracy*: proc(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.stdcall.} + get_altitudeAccuracy*: proc(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.stdcall.} + get_heading*: proc(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.stdcall.} + get_speed*: proc(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.stdcall.} + IWebGeopositionError* {.pure.} = object + lpVtbl*: ptr IWebGeopositionErrorVtbl + IWebGeopositionErrorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_code*: proc(self: ptr IWebGeopositionError, p: ptr LONG): HRESULT {.stdcall.} + get_message*: proc(self: ptr IWebGeopositionError, p: ptr BSTR): HRESULT {.stdcall.} + IWebGeoposition* {.pure.} = object + lpVtbl*: ptr IWebGeopositionVtbl + IWebGeopositionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_coords*: proc(self: ptr IWebGeoposition, p: ptr ptr IWebGeocoordinates): HRESULT {.stdcall.} + get_timestamp*: proc(self: ptr IWebGeoposition, p: ptr ULONGLONG): HRESULT {.stdcall.} + DispWebGeolocation* {.pure.} = object + lpVtbl*: ptr DispWebGeolocationVtbl + DispWebGeolocationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispWebGeocoordinates* {.pure.} = object + lpVtbl*: ptr DispWebGeocoordinatesVtbl + DispWebGeocoordinatesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispWebGeopositionError* {.pure.} = object + lpVtbl*: ptr DispWebGeopositionErrorVtbl + DispWebGeopositionErrorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispWebGeoposition* {.pure.} = object + lpVtbl*: ptr DispWebGeopositionVtbl + DispWebGeopositionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IClientCaps* {.pure.} = object + lpVtbl*: ptr IClientCapsVtbl + IClientCapsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_javaEnabled*: proc(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_cookieEnabled*: proc(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_cpuClass*: proc(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.stdcall.} + get_systemLanguage*: proc(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.stdcall.} + get_userLanguage*: proc(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.stdcall.} + get_platform*: proc(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.stdcall.} + get_connectionSpeed*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_onLine*: proc(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_colorDepth*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_bufferDepth*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_width*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_height*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_availHeight*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_availWidth*: proc(self: ptr IClientCaps, p: ptr LONG): HRESULT {.stdcall.} + get_connectionType*: proc(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.stdcall.} + isComponentInstalled*: proc(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, bStrVer: BSTR, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + getComponentVersion*: proc(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, pbstrVer: ptr BSTR): HRESULT {.stdcall.} + compareVersions*: proc(self: ptr IClientCaps, bstrVer1: BSTR, bstrVer2: BSTR, p: ptr LONG): HRESULT {.stdcall.} + addComponentRequest*: proc(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, bStrVer: BSTR): HRESULT {.stdcall.} + doComponentRequest*: proc(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + clearComponentRequest*: proc(self: ptr IClientCaps): HRESULT {.stdcall.} + IDOMMSManipulationEvent* {.pure.} = object + lpVtbl*: ptr IDOMMSManipulationEventVtbl + IDOMMSManipulationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_lastState*: proc(self: ptr IDOMMSManipulationEvent, p: ptr LONG): HRESULT {.stdcall.} + get_currentState*: proc(self: ptr IDOMMSManipulationEvent, p: ptr LONG): HRESULT {.stdcall.} + initMSManipulationEvent*: proc(self: ptr IDOMMSManipulationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, lastState: LONG, currentState: LONG): HRESULT {.stdcall.} + DispDOMMSManipulationEvent* {.pure.} = object + lpVtbl*: ptr DispDOMMSManipulationEventVtbl + DispDOMMSManipulationEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IDOMCloseEvent* {.pure.} = object + lpVtbl*: ptr IDOMCloseEventVtbl + IDOMCloseEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_wasClean*: proc(self: ptr IDOMCloseEvent, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + initCloseEvent*: proc(self: ptr IDOMCloseEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, wasClean: VARIANT_BOOL, code: LONG, reason: BSTR): HRESULT {.stdcall.} + DispDOMCloseEvent* {.pure.} = object + lpVtbl*: ptr DispDOMCloseEventVtbl + DispDOMCloseEventVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispApplicationCache* {.pure.} = object + lpVtbl*: ptr DispApplicationCacheVtbl + DispApplicationCacheVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ICSSFilterSite* {.pure.} = object + lpVtbl*: ptr ICSSFilterSiteVtbl + ICSSFilterSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetElement*: proc(self: ptr ICSSFilterSite, Element: ptr ptr IHTMLElement): HRESULT {.stdcall.} + FireOnFilterChangeEvent*: proc(self: ptr ICSSFilterSite): HRESULT {.stdcall.} + ICSSFilter* {.pure.} = object + lpVtbl*: ptr ICSSFilterVtbl + ICSSFilterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSite*: proc(self: ptr ICSSFilter, pSink: ptr ICSSFilterSite): HRESULT {.stdcall.} + OnAmbientPropertyChange*: proc(self: ptr ICSSFilter, dispid: LONG): HRESULT {.stdcall.} + ISecureUrlHost* {.pure.} = object + lpVtbl*: ptr ISecureUrlHostVtbl + ISecureUrlHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ValidateSecureUrl*: proc(self: ptr ISecureUrlHost, pfAllow: ptr WINBOOL, pchUrlInQuestion: ptr OLECHAR, dwFlags: DWORD): HRESULT {.stdcall.} + IMarkupContainer* {.pure.} = object + lpVtbl*: ptr IMarkupContainerVtbl + IMarkupContainerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OwningDoc*: proc(self: ptr IMarkupContainer, ppDoc: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + IMarkupPointer* {.pure.} = object + lpVtbl*: ptr IMarkupPointerVtbl + IMarkupPointerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OwningDoc*: proc(self: ptr IMarkupPointer, ppDoc: ptr ptr IHTMLDocument2): HRESULT {.stdcall.} + Gravity*: proc(self: ptr IMarkupPointer, pGravity: ptr POINTER_GRAVITY): HRESULT {.stdcall.} + SetGravity*: proc(self: ptr IMarkupPointer, Gravity: POINTER_GRAVITY): HRESULT {.stdcall.} + Cling*: proc(self: ptr IMarkupPointer, pfCling: ptr WINBOOL): HRESULT {.stdcall.} + SetCling*: proc(self: ptr IMarkupPointer, fCLing: WINBOOL): HRESULT {.stdcall.} + Unposition*: proc(self: ptr IMarkupPointer): HRESULT {.stdcall.} + IsPositioned*: proc(self: ptr IMarkupPointer, pfPositioned: ptr WINBOOL): HRESULT {.stdcall.} + GetContainer*: proc(self: ptr IMarkupPointer, ppContainer: ptr ptr IMarkupContainer): HRESULT {.stdcall.} + MoveAdjacentToElement*: proc(self: ptr IMarkupPointer, pElement: ptr IHTMLElement, eAdj: ELEMENT_ADJACENCY): HRESULT {.stdcall.} + MoveToPointer*: proc(self: ptr IMarkupPointer, pPointer: ptr IMarkupPointer): HRESULT {.stdcall.} + MoveToContainer*: proc(self: ptr IMarkupPointer, pContainer: ptr IMarkupContainer, fAtStart: WINBOOL): HRESULT {.stdcall.} + Left*: proc(self: ptr IMarkupPointer, fMove: WINBOOL, pContext: ptr MARKUP_CONTEXT_TYPE, ppElement: ptr ptr IHTMLElement, pcch: ptr LONG, pchText: ptr OLECHAR): HRESULT {.stdcall.} + Right*: proc(self: ptr IMarkupPointer, fMove: WINBOOL, pContext: ptr MARKUP_CONTEXT_TYPE, ppElement: ptr ptr IHTMLElement, pcch: ptr LONG, pchText: ptr OLECHAR): HRESULT {.stdcall.} + CurrentScope*: proc(self: ptr IMarkupPointer, ppElemCurrent: ptr ptr IHTMLElement): HRESULT {.stdcall.} + IsLeftOf*: proc(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.stdcall.} + IsLeftOfOrEqualTo*: proc(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.stdcall.} + IsRightOf*: proc(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.stdcall.} + IsRightOfOrEqualTo*: proc(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.stdcall.} + IsEqualTo*: proc(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfAreEqual: ptr WINBOOL): HRESULT {.stdcall.} + MoveUnit*: proc(self: ptr IMarkupPointer, muAction: MOVEUNIT_ACTION): HRESULT {.stdcall.} + FindText*: proc(self: ptr IMarkupPointer, pchFindText: ptr OLECHAR, dwFlags: DWORD, pIEndMatch: ptr IMarkupPointer, pIEndSearch: ptr IMarkupPointer): HRESULT {.stdcall.} + IMarkupServices* {.pure.} = object + lpVtbl*: ptr IMarkupServicesVtbl + IMarkupServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateMarkupPointer*: proc(self: ptr IMarkupServices, ppPointer: ptr ptr IMarkupPointer): HRESULT {.stdcall.} + CreateMarkupContainer*: proc(self: ptr IMarkupServices, ppMarkupContainer: ptr ptr IMarkupContainer): HRESULT {.stdcall.} + CreateElement*: proc(self: ptr IMarkupServices, tagID: ELEMENT_TAG_ID, pchAttributes: ptr OLECHAR, ppElement: ptr ptr IHTMLElement): HRESULT {.stdcall.} + CloneElement*: proc(self: ptr IMarkupServices, pElemCloneThis: ptr IHTMLElement, ppElementTheClone: ptr ptr IHTMLElement): HRESULT {.stdcall.} + InsertElement*: proc(self: ptr IMarkupServices, pElementInsert: ptr IHTMLElement, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + RemoveElement*: proc(self: ptr IMarkupServices, pElementRemove: ptr IHTMLElement): HRESULT {.stdcall.} + Remove*: proc(self: ptr IMarkupServices, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + Copy*: proc(self: ptr IMarkupServices, pPointerSourceStart: ptr IMarkupPointer, pPointerSourceFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer): HRESULT {.stdcall.} + Move*: proc(self: ptr IMarkupServices, pPointerSourceStart: ptr IMarkupPointer, pPointerSourceFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer): HRESULT {.stdcall.} + InsertText*: proc(self: ptr IMarkupServices, pchText: ptr OLECHAR, cch: LONG, pPointerTarget: ptr IMarkupPointer): HRESULT {.stdcall.} + ParseString*: proc(self: ptr IMarkupServices, pchHTML: ptr OLECHAR, dwFlags: DWORD, ppContainerResult: ptr ptr IMarkupContainer, ppPointerStart: ptr IMarkupPointer, ppPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + ParseGlobal*: proc(self: ptr IMarkupServices, hglobalHTML: HGLOBAL, dwFlags: DWORD, ppContainerResult: ptr ptr IMarkupContainer, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + IsScopedElement*: proc(self: ptr IMarkupServices, pElement: ptr IHTMLElement, pfScoped: ptr WINBOOL): HRESULT {.stdcall.} + GetElementTagId*: proc(self: ptr IMarkupServices, pElement: ptr IHTMLElement, ptagId: ptr ELEMENT_TAG_ID): HRESULT {.stdcall.} + GetTagIDForName*: proc(self: ptr IMarkupServices, bstrName: BSTR, ptagId: ptr ELEMENT_TAG_ID): HRESULT {.stdcall.} + GetNameForTagID*: proc(self: ptr IMarkupServices, tagId: ELEMENT_TAG_ID, pbstrName: ptr BSTR): HRESULT {.stdcall.} + MovePointersToRange*: proc(self: ptr IMarkupServices, pIRange: ptr IHTMLTxtRange, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + MoveRangeToPointers*: proc(self: ptr IMarkupServices, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer, pIRange: ptr IHTMLTxtRange): HRESULT {.stdcall.} + BeginUndoUnit*: proc(self: ptr IMarkupServices, pchTitle: ptr OLECHAR): HRESULT {.stdcall.} + EndUndoUnit*: proc(self: ptr IMarkupServices): HRESULT {.stdcall.} + ISegment* {.pure.} = object + lpVtbl*: ptr ISegmentVtbl + ISegmentVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPointers*: proc(self: ptr ISegment, pIStart: ptr IMarkupPointer, pIEnd: ptr IMarkupPointer): HRESULT {.stdcall.} + ISegmentListIterator* {.pure.} = object + lpVtbl*: ptr ISegmentListIteratorVtbl + ISegmentListIteratorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Current*: proc(self: ptr ISegmentListIterator, ppISegment: ptr ptr ISegment): HRESULT {.stdcall.} + First*: proc(self: ptr ISegmentListIterator): HRESULT {.stdcall.} + IsDone*: proc(self: ptr ISegmentListIterator): HRESULT {.stdcall.} + Advance*: proc(self: ptr ISegmentListIterator): HRESULT {.stdcall.} + ISegmentList* {.pure.} = object + lpVtbl*: ptr ISegmentListVtbl + ISegmentListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateIterator*: proc(self: ptr ISegmentList, ppIIter: ptr ptr ISegmentListIterator): HRESULT {.stdcall.} + GetType*: proc(self: ptr ISegmentList, peType: ptr SELECTION_TYPE): HRESULT {.stdcall.} + IsEmpty*: proc(self: ptr ISegmentList, pfEmpty: ptr WINBOOL): HRESULT {.stdcall.} + IMarkupServices2* {.pure.} = object + lpVtbl*: ptr IMarkupServices2Vtbl + IMarkupServices2Vtbl* {.pure, inheritable.} = object of IMarkupServicesVtbl + ParseGlobalEx*: proc(self: ptr IMarkupServices2, hglobalHTML: HGLOBAL, dwFlags: DWORD, pContext: ptr IMarkupContainer, ppContainerResult: ptr ptr IMarkupContainer, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.stdcall.} + ValidateElements*: proc(self: ptr IMarkupServices2, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer, pPointerStatus: ptr IMarkupPointer, ppElemFailBottom: ptr ptr IHTMLElement, ppElemFailTop: ptr ptr IHTMLElement): HRESULT {.stdcall.} + SaveSegmentsToClipboard*: proc(self: ptr IMarkupServices2, pSegmentList: ptr ISegmentList, dwFlags: DWORD): HRESULT {.stdcall.} + IHTMLChangeSink* {.pure.} = object + lpVtbl*: ptr IHTMLChangeSinkVtbl + IHTMLChangeSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Notify*: proc(self: ptr IHTMLChangeSink): HRESULT {.stdcall.} + IHTMLChangeLog* {.pure.} = object + lpVtbl*: ptr IHTMLChangeLogVtbl + IHTMLChangeLogVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNextChange*: proc(self: ptr IHTMLChangeLog, pbBuffer: ptr BYTE, nBufferSize: LONG, pnRecordLength: ptr LONG): HRESULT {.stdcall.} + IMarkupContainer2* {.pure.} = object + lpVtbl*: ptr IMarkupContainer2Vtbl + IMarkupContainer2Vtbl* {.pure, inheritable.} = object of IMarkupContainerVtbl + CreateChangeLog*: proc(self: ptr IMarkupContainer2, pChangeSink: ptr IHTMLChangeSink, ppChangeLog: ptr ptr IHTMLChangeLog, fForward: WINBOOL, fBackward: WINBOOL): HRESULT {.stdcall.} + RegisterForDirtyRange*: proc(self: ptr IMarkupContainer2, pChangeSink: ptr IHTMLChangeSink, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + UnRegisterForDirtyRange*: proc(self: ptr IMarkupContainer2, dwCookie: DWORD): HRESULT {.stdcall.} + GetAndClearDirtyRange*: proc(self: ptr IMarkupContainer2, dwCookie: DWORD, pIPointerBegin: ptr IMarkupPointer, pIPointerEnd: ptr IMarkupPointer): HRESULT {.stdcall.} + GetVersionNumber*: proc(self: ptr IMarkupContainer2): LONG {.stdcall.} + GetMasterElement*: proc(self: ptr IMarkupContainer2, ppElementMaster: ptr ptr IHTMLElement): HRESULT {.stdcall.} + IHTMLChangePlayback* {.pure.} = object + lpVtbl*: ptr IHTMLChangePlaybackVtbl + IHTMLChangePlaybackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ExecChange*: proc(self: ptr IHTMLChangePlayback, pbRecord: ptr BYTE, fForward: WINBOOL): HRESULT {.stdcall.} + IMarkupPointer2* {.pure.} = object + lpVtbl*: ptr IMarkupPointer2Vtbl + IMarkupPointer2Vtbl* {.pure, inheritable.} = object of IMarkupPointerVtbl + IsAtWordBreak*: proc(self: ptr IMarkupPointer2, pfAtBreak: ptr WINBOOL): HRESULT {.stdcall.} + GetMarkupPosition*: proc(self: ptr IMarkupPointer2, plMP: ptr LONG): HRESULT {.stdcall.} + MoveToMarkupPosition*: proc(self: ptr IMarkupPointer2, pContainer: ptr IMarkupContainer, lMP: LONG): HRESULT {.stdcall.} + MoveUnitBounded*: proc(self: ptr IMarkupPointer2, muAction: MOVEUNIT_ACTION, pIBoundary: ptr IMarkupPointer): HRESULT {.stdcall.} + IsInsideURL*: proc(self: ptr IMarkupPointer2, pRight: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.stdcall.} + MoveToContent*: proc(self: ptr IMarkupPointer2, pIElement: ptr IHTMLElement, fAtStart: WINBOOL): HRESULT {.stdcall.} + IMarkupTextFrags* {.pure.} = object + lpVtbl*: ptr IMarkupTextFragsVtbl + IMarkupTextFragsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTextFragCount*: proc(self: ptr IMarkupTextFrags, pcFrags: ptr LONG): HRESULT {.stdcall.} + GetTextFrag*: proc(self: ptr IMarkupTextFrags, iFrag: LONG, pbstrFrag: ptr BSTR, pPointerFrag: ptr IMarkupPointer): HRESULT {.stdcall.} + RemoveTextFrag*: proc(self: ptr IMarkupTextFrags, iFrag: LONG): HRESULT {.stdcall.} + InsertTextFrag*: proc(self: ptr IMarkupTextFrags, iFrag: LONG, bstrInsert: BSTR, pPointerInsert: ptr IMarkupPointer): HRESULT {.stdcall.} + FindTextFragFromMarkupPointer*: proc(self: ptr IMarkupTextFrags, pPointerFind: ptr IMarkupPointer, piFrag: ptr LONG, pfFragFound: ptr WINBOOL): HRESULT {.stdcall.} + IXMLGenericParse* {.pure.} = object + lpVtbl*: ptr IXMLGenericParseVtbl + IXMLGenericParseVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetGenericParse*: proc(self: ptr IXMLGenericParse, fDoGeneric: VARIANT_BOOL): HRESULT {.stdcall.} + IHTMLEditHost* {.pure.} = object + lpVtbl*: ptr IHTMLEditHostVtbl + IHTMLEditHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SnapRect*: proc(self: ptr IHTMLEditHost, pIElement: ptr IHTMLElement, prcNew: ptr RECT, eHandle: ELEMENT_CORNER): HRESULT {.stdcall.} + IHTMLEditHost2* {.pure.} = object + lpVtbl*: ptr IHTMLEditHost2Vtbl + IHTMLEditHost2Vtbl* {.pure, inheritable.} = object of IHTMLEditHostVtbl + PreDrag*: proc(self: ptr IHTMLEditHost2): HRESULT {.stdcall.} + ISequenceNumber* {.pure.} = object + lpVtbl*: ptr ISequenceNumberVtbl + ISequenceNumberVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSequenceNumber*: proc(self: ptr ISequenceNumber, nCurrent: LONG, pnNew: ptr LONG): HRESULT {.stdcall.} + IIMEServices* {.pure.} = object + lpVtbl*: ptr IIMEServicesVtbl + IIMEServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetActiveIMM*: proc(self: ptr IIMEServices, ppActiveIMM: ptr ptr IActiveIMMApp): HRESULT {.stdcall.} + ILineInfo* {.pure.} = object + lpVtbl*: ptr ILineInfoVtbl + ILineInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_x*: proc(self: ptr ILineInfo, p: ptr LONG): HRESULT {.stdcall.} + get_baseLine*: proc(self: ptr ILineInfo, p: ptr LONG): HRESULT {.stdcall.} + get_textDescent*: proc(self: ptr ILineInfo, p: ptr LONG): HRESULT {.stdcall.} + get_textHeight*: proc(self: ptr ILineInfo, p: ptr LONG): HRESULT {.stdcall.} + get_lineDirection*: proc(self: ptr ILineInfo, p: ptr LONG): HRESULT {.stdcall.} + IDisplayPointer* {.pure.} = object + lpVtbl*: ptr IDisplayPointerVtbl + IDisplayPointerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + MoveToPoint*: proc(self: ptr IDisplayPointer, ptPoint: POINT, eCoordSystem: COORD_SYSTEM, pElementContext: ptr IHTMLElement, dwHitTestOptions: DWORD, pdwHitTestResults: ptr DWORD): HRESULT {.stdcall.} + MoveUnit*: proc(self: ptr IDisplayPointer, eMoveUnit: DISPLAY_MOVEUNIT, lXPos: LONG): HRESULT {.stdcall.} + PositionMarkupPointer*: proc(self: ptr IDisplayPointer, pMarkupPointer: ptr IMarkupPointer): HRESULT {.stdcall.} + MoveToPointer*: proc(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer): HRESULT {.stdcall.} + SetPointerGravity*: proc(self: ptr IDisplayPointer, eGravity: POINTER_GRAVITY): HRESULT {.stdcall.} + GetPointerGravity*: proc(self: ptr IDisplayPointer, peGravity: ptr POINTER_GRAVITY): HRESULT {.stdcall.} + SetDisplayGravity*: proc(self: ptr IDisplayPointer, eGravity: DISPLAY_GRAVITY): HRESULT {.stdcall.} + GetDisplayGravity*: proc(self: ptr IDisplayPointer, peGravity: ptr DISPLAY_GRAVITY): HRESULT {.stdcall.} + IsPositioned*: proc(self: ptr IDisplayPointer, pfPositioned: ptr WINBOOL): HRESULT {.stdcall.} + Unposition*: proc(self: ptr IDisplayPointer): HRESULT {.stdcall.} + IsEqualTo*: proc(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsEqual: ptr WINBOOL): HRESULT {.stdcall.} + IsLeftOf*: proc(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsLeftOf: ptr WINBOOL): HRESULT {.stdcall.} + IsRightOf*: proc(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsRightOf: ptr WINBOOL): HRESULT {.stdcall.} + IsAtBOL*: proc(self: ptr IDisplayPointer, pfBOL: ptr WINBOOL): HRESULT {.stdcall.} + MoveToMarkupPointer*: proc(self: ptr IDisplayPointer, pPointer: ptr IMarkupPointer, pDispLineContext: ptr IDisplayPointer): HRESULT {.stdcall.} + ScrollIntoView*: proc(self: ptr IDisplayPointer): HRESULT {.stdcall.} + GetLineInfo*: proc(self: ptr IDisplayPointer, ppLineInfo: ptr ptr ILineInfo): HRESULT {.stdcall.} + GetFlowElement*: proc(self: ptr IDisplayPointer, ppLayoutElement: ptr ptr IHTMLElement): HRESULT {.stdcall.} + QueryBreaks*: proc(self: ptr IDisplayPointer, pdwBreaks: ptr DWORD): HRESULT {.stdcall.} + IHTMLCaret* {.pure.} = object + lpVtbl*: ptr IHTMLCaretVtbl + IHTMLCaretVtbl* {.pure, inheritable.} = object of IUnknownVtbl + MoveCaretToPointer*: proc(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer, fScrollIntoView: WINBOOL, eDir: CARET_DIRECTION): HRESULT {.stdcall.} + MoveCaretToPointerEx*: proc(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer, fVisible: WINBOOL, fScrollIntoView: WINBOOL, eDir: CARET_DIRECTION): HRESULT {.stdcall.} + MoveMarkupPointerToCaret*: proc(self: ptr IHTMLCaret, pIMarkupPointer: ptr IMarkupPointer): HRESULT {.stdcall.} + MoveDisplayPointerToCaret*: proc(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer): HRESULT {.stdcall.} + IsVisible*: proc(self: ptr IHTMLCaret, pIsVisible: ptr WINBOOL): HRESULT {.stdcall.} + Show*: proc(self: ptr IHTMLCaret, fScrollIntoView: WINBOOL): HRESULT {.stdcall.} + Hide*: proc(self: ptr IHTMLCaret): HRESULT {.stdcall.} + InsertText*: proc(self: ptr IHTMLCaret, pText: ptr OLECHAR, lLen: LONG): HRESULT {.stdcall.} + ScrollIntoView*: proc(self: ptr IHTMLCaret): HRESULT {.stdcall.} + GetLocation*: proc(self: ptr IHTMLCaret, pPoint: ptr POINT, fTranslate: WINBOOL): HRESULT {.stdcall.} + GetCaretDirection*: proc(self: ptr IHTMLCaret, peDir: ptr CARET_DIRECTION): HRESULT {.stdcall.} + SetCaretDirection*: proc(self: ptr IHTMLCaret, eDir: CARET_DIRECTION): HRESULT {.stdcall.} + IHighlightSegment* {.pure.} = object + lpVtbl*: ptr IHighlightSegmentVtbl + IHighlightSegmentVtbl* {.pure, inheritable.} = object of ISegmentVtbl + IHighlightRenderingServices* {.pure.} = object + lpVtbl*: ptr IHighlightRenderingServicesVtbl + IHighlightRenderingServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddSegment*: proc(self: ptr IHighlightRenderingServices, pDispPointerStart: ptr IDisplayPointer, pDispPointerEnd: ptr IDisplayPointer, pIRenderStyle: ptr IHTMLRenderStyle, ppISegment: ptr ptr IHighlightSegment): HRESULT {.stdcall.} + MoveSegmentToPointers*: proc(self: ptr IHighlightRenderingServices, pISegment: ptr IHighlightSegment, pDispPointerStart: ptr IDisplayPointer, pDispPointerEnd: ptr IDisplayPointer): HRESULT {.stdcall.} + RemoveSegment*: proc(self: ptr IHighlightRenderingServices, pISegment: ptr IHighlightSegment): HRESULT {.stdcall.} + ISelectionServicesListener* {.pure.} = object + lpVtbl*: ptr ISelectionServicesListenerVtbl + ISelectionServicesListenerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BeginSelectionUndo*: proc(self: ptr ISelectionServicesListener): HRESULT {.stdcall.} + EndSelectionUndo*: proc(self: ptr ISelectionServicesListener): HRESULT {.stdcall.} + OnSelectedElementExit*: proc(self: ptr ISelectionServicesListener, pIElementStart: ptr IMarkupPointer, pIElementEnd: ptr IMarkupPointer, pIElementContentStart: ptr IMarkupPointer, pIElementContentEnd: ptr IMarkupPointer): HRESULT {.stdcall.} + OnChangeType*: proc(self: ptr ISelectionServicesListener, eType: SELECTION_TYPE, pIListener: ptr ISelectionServicesListener): HRESULT {.stdcall.} + GetTypeDetail*: proc(self: ptr ISelectionServicesListener, pTypeDetail: ptr BSTR): HRESULT {.stdcall.} + IElementSegment* {.pure.} = object + lpVtbl*: ptr IElementSegmentVtbl + IElementSegmentVtbl* {.pure, inheritable.} = object of ISegmentVtbl + GetElement*: proc(self: ptr IElementSegment, ppIElement: ptr ptr IHTMLElement): HRESULT {.stdcall.} + SetPrimary*: proc(self: ptr IElementSegment, fPrimary: WINBOOL): HRESULT {.stdcall.} + IsPrimary*: proc(self: ptr IElementSegment, pfPrimary: ptr WINBOOL): HRESULT {.stdcall.} + ISelectionServices* {.pure.} = object + lpVtbl*: ptr ISelectionServicesVtbl + ISelectionServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSelectionType*: proc(self: ptr ISelectionServices, eType: SELECTION_TYPE, pIListener: ptr ISelectionServicesListener): HRESULT {.stdcall.} + GetMarkupContainer*: proc(self: ptr ISelectionServices, ppIContainer: ptr ptr IMarkupContainer): HRESULT {.stdcall.} + AddSegment*: proc(self: ptr ISelectionServices, pIStart: ptr IMarkupPointer, pIEnd: ptr IMarkupPointer, ppISegmentAdded: ptr ptr ISegment): HRESULT {.stdcall.} + AddElementSegment*: proc(self: ptr ISelectionServices, pIElement: ptr IHTMLElement, ppISegmentAdded: ptr ptr IElementSegment): HRESULT {.stdcall.} + RemoveSegment*: proc(self: ptr ISelectionServices, pISegment: ptr ISegment): HRESULT {.stdcall.} + GetSelectionServicesListener*: proc(self: ptr ISelectionServices, ppISelectionServicesListener: ptr ptr ISelectionServicesListener): HRESULT {.stdcall.} + IHTMLEditDesigner* {.pure.} = object + lpVtbl*: ptr IHTMLEditDesignerVtbl + IHTMLEditDesignerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PreHandleEvent*: proc(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.stdcall.} + PostHandleEvent*: proc(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.stdcall.} + PostEditorEventNotify*: proc(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.stdcall.} + IHTMLEditServices* {.pure.} = object + lpVtbl*: ptr IHTMLEditServicesVtbl + IHTMLEditServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddDesigner*: proc(self: ptr IHTMLEditServices, pIDesigner: ptr IHTMLEditDesigner): HRESULT {.stdcall.} + RemoveDesigner*: proc(self: ptr IHTMLEditServices, pIDesigner: ptr IHTMLEditDesigner): HRESULT {.stdcall.} + GetSelectionServices*: proc(self: ptr IHTMLEditServices, pIContainer: ptr IMarkupContainer, ppSelSvc: ptr ptr ISelectionServices): HRESULT {.stdcall.} + MoveToSelectionAnchor*: proc(self: ptr IHTMLEditServices, pIStartAnchor: ptr IMarkupPointer): HRESULT {.stdcall.} + MoveToSelectionEnd*: proc(self: ptr IHTMLEditServices, pIEndAnchor: ptr IMarkupPointer): HRESULT {.stdcall.} + SelectRange*: proc(self: ptr IHTMLEditServices, pStart: ptr IMarkupPointer, pEnd: ptr IMarkupPointer, eType: SELECTION_TYPE): HRESULT {.stdcall.} + IHTMLEditServices2* {.pure.} = object + lpVtbl*: ptr IHTMLEditServices2Vtbl + IHTMLEditServices2Vtbl* {.pure, inheritable.} = object of IHTMLEditServicesVtbl + MoveToSelectionAnchorEx*: proc(self: ptr IHTMLEditServices2, pIStartAnchor: ptr IDisplayPointer): HRESULT {.stdcall.} + MoveToSelectionEndEx*: proc(self: ptr IHTMLEditServices2, pIEndAnchor: ptr IDisplayPointer): HRESULT {.stdcall.} + FreezeVirtualCaretPos*: proc(self: ptr IHTMLEditServices2, fReCompute: WINBOOL): HRESULT {.stdcall.} + UnFreezeVirtualCaretPos*: proc(self: ptr IHTMLEditServices2, fReset: WINBOOL): HRESULT {.stdcall.} + IHTMLComputedStyle* {.pure.} = object + lpVtbl*: ptr IHTMLComputedStyleVtbl + IHTMLComputedStyleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_bold*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_italic*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_underline*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_overline*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_strikeOut*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_subScript*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_superScript*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_explicitFace*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_fontWeight*: proc(self: ptr IHTMLComputedStyle, p: ptr LONG): HRESULT {.stdcall.} + get_fontSize*: proc(self: ptr IHTMLComputedStyle, p: ptr LONG): HRESULT {.stdcall.} + get_fontName*: proc(self: ptr IHTMLComputedStyle, p: ptr TCHAR): HRESULT {.stdcall.} + get_hasBgColor*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_textColor*: proc(self: ptr IHTMLComputedStyle, p: ptr DWORD): HRESULT {.stdcall.} + get_backgroundColor*: proc(self: ptr IHTMLComputedStyle, p: ptr DWORD): HRESULT {.stdcall.} + get_preFormatted*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_direction*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_blockDirection*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_OL*: proc(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IsEqual*: proc(self: ptr IHTMLComputedStyle, pComputedStyle: ptr IHTMLComputedStyle, pfEqual: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IDisplayServices* {.pure.} = object + lpVtbl*: ptr IDisplayServicesVtbl + IDisplayServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateDisplayPointer*: proc(self: ptr IDisplayServices, ppDispPointer: ptr ptr IDisplayPointer): HRESULT {.stdcall.} + TransformRect*: proc(self: ptr IDisplayServices, pRect: ptr RECT, eSource: COORD_SYSTEM, eDestination: COORD_SYSTEM, pIElement: ptr IHTMLElement): HRESULT {.stdcall.} + TransformPoint*: proc(self: ptr IDisplayServices, pPoint: ptr POINT, eSource: COORD_SYSTEM, eDestination: COORD_SYSTEM, pIElement: ptr IHTMLElement): HRESULT {.stdcall.} + GetCaret*: proc(self: ptr IDisplayServices, ppCaret: ptr ptr IHTMLCaret): HRESULT {.stdcall.} + GetComputedStyle*: proc(self: ptr IDisplayServices, pPointer: ptr IMarkupPointer, ppComputedStyle: ptr ptr IHTMLComputedStyle): HRESULT {.stdcall.} + ScrollRectIntoView*: proc(self: ptr IDisplayServices, pIElement: ptr IHTMLElement, rect: RECT): HRESULT {.stdcall.} + HasFlowLayout*: proc(self: ptr IDisplayServices, pIElement: ptr IHTMLElement, pfHasFlowLayout: ptr WINBOOL): HRESULT {.stdcall.} + IHtmlDlgSafeHelper* {.pure.} = object + lpVtbl*: ptr IHtmlDlgSafeHelperVtbl + IHtmlDlgSafeHelperVtbl* {.pure, inheritable.} = object of IDispatchVtbl + choosecolordlg*: proc(self: ptr IHtmlDlgSafeHelper, initColor: VARIANT, rgbColor: ptr VARIANT): HRESULT {.stdcall.} + getCharset*: proc(self: ptr IHtmlDlgSafeHelper, fontName: BSTR, charset: ptr VARIANT): HRESULT {.stdcall.} + get_Fonts*: proc(self: ptr IHtmlDlgSafeHelper, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_BlockFormats*: proc(self: ptr IHtmlDlgSafeHelper, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IBlockFormats* {.pure.} = object + lpVtbl*: ptr IBlockFormatsVtbl + IBlockFormatsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_NewEnum*: proc(self: ptr IBlockFormats, p: ptr ptr IUnknown): HRESULT {.stdcall.} + get_Count*: proc(self: ptr IBlockFormats, p: ptr LONG): HRESULT {.stdcall.} + Item*: proc(self: ptr IBlockFormats, pvarIndex: ptr VARIANT, pbstrBlockFormat: ptr BSTR): HRESULT {.stdcall.} + IFontNames* {.pure.} = object + lpVtbl*: ptr IFontNamesVtbl + IFontNamesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_NewEnum*: proc(self: ptr IFontNames, p: ptr ptr IUnknown): HRESULT {.stdcall.} + get_Count*: proc(self: ptr IFontNames, p: ptr LONG): HRESULT {.stdcall.} + Item*: proc(self: ptr IFontNames, pvarIndex: ptr VARIANT, pbstrFontName: ptr BSTR): HRESULT {.stdcall.} + IDeveloperConsoleMessageReceiver* {.pure.} = object + lpVtbl*: ptr IDeveloperConsoleMessageReceiverVtbl + IDeveloperConsoleMessageReceiverVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Write*: proc(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR): HRESULT {.stdcall.} + WriteWithUrl*: proc(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR): HRESULT {.stdcall.} + WriteWithUrlAndLine*: proc(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR, line: ULONG): HRESULT {.stdcall.} + WriteWithUrlLineAndColumn*: proc(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR, line: ULONG, column: ULONG): HRESULT {.stdcall.} + IScriptEventHandler* {.pure.} = object + lpVtbl*: ptr IScriptEventHandlerVtbl + IScriptEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FunctionName*: proc(self: ptr IScriptEventHandler, pbstrFunctionName: ptr BSTR): HRESULT {.stdcall.} + DebugDocumentContext*: proc(self: ptr IScriptEventHandler, ppDebugDocumentContext: ptr ptr IUnknown): HRESULT {.stdcall.} + EventHandlerDispatch*: proc(self: ptr IScriptEventHandler, ppDispHandler: ptr ptr IDispatch): HRESULT {.stdcall.} + UsesCapture*: proc(self: ptr IScriptEventHandler, pfUsesCapture: ptr WINBOOL): HRESULT {.stdcall.} + Cookie*: proc(self: ptr IScriptEventHandler, pullCookie: ptr ULONGLONG): HRESULT {.stdcall.} + IDebugCallbackNotificationHandler* {.pure.} = object + lpVtbl*: ptr IDebugCallbackNotificationHandlerVtbl + IDebugCallbackNotificationHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RequestedCallbackTypes*: proc(self: ptr IDebugCallbackNotificationHandler, pCallbackMask: ptr DWORD): HRESULT {.stdcall.} + BeforeDispatchEvent*: proc(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown): HRESULT {.stdcall.} + DispatchEventComplete*: proc(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, propagationStatus: DWORD): HRESULT {.stdcall.} + BeforeInvokeDomCallback*: proc(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, pCallback: ptr IScriptEventHandler, eStage: DOM_EVENT_PHASE, propagationStatus: DWORD): HRESULT {.stdcall.} + InvokeDomCallbackComplete*: proc(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, pCallback: ptr IScriptEventHandler, eStage: DOM_EVENT_PHASE, propagationStatus: DWORD): HRESULT {.stdcall.} + BeforeInvokeCallback*: proc(self: ptr IDebugCallbackNotificationHandler, eCallbackType: SCRIPT_TIMER_TYPE, callbackCookie: DWORD, pDispHandler: ptr IDispatch, ullHandlerCookie: ULONGLONG, functionName: BSTR, line: UINT32, column: UINT32, cchLength: UINT32, pDebugDocumentContext: ptr IUnknown): HRESULT {.stdcall.} + InvokeCallbackComplete*: proc(self: ptr IDebugCallbackNotificationHandler, eCallbackType: SCRIPT_TIMER_TYPE, callbackCookie: DWORD, pDispHandler: ptr IDispatch, ullHandlerCookie: ULONGLONG, functionName: BSTR, line: UINT32, column: UINT32, cchLength: UINT32, pDebugDocumentContext: ptr IUnknown): HRESULT {.stdcall.} + IScriptEventHandlerSourceInfo* {.pure.} = object + lpVtbl*: ptr IScriptEventHandlerSourceInfoVtbl + IScriptEventHandlerSourceInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSourceInfo*: proc(self: ptr IScriptEventHandlerSourceInfo, pbstrFunctionName: ptr BSTR, line: ptr UINT32, column: ptr UINT32, cchLength: ptr UINT32): HRESULT {.stdcall.} + IDOMEventRegistrationCallback* {.pure.} = object + lpVtbl*: ptr IDOMEventRegistrationCallbackVtbl + IDOMEventRegistrationCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnDOMEventListenerAdded*: proc(self: ptr IDOMEventRegistrationCallback, pszEventType: LPCWSTR, pHandler: ptr IScriptEventHandler): HRESULT {.stdcall.} + OnDOMEventListenerRemoved*: proc(self: ptr IDOMEventRegistrationCallback, ullCookie: ULONGLONG): HRESULT {.stdcall.} + IEventTarget2* {.pure.} = object + lpVtbl*: ptr IEventTarget2Vtbl + IEventTarget2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRegisteredEventTypes*: proc(self: ptr IEventTarget2, ppEventTypeArray: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetListenersForType*: proc(self: ptr IEventTarget2, pszEventType: LPCWSTR, ppEventHandlerArray: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + RegisterForDOMEventListeners*: proc(self: ptr IEventTarget2, pCallback: ptr IDOMEventRegistrationCallback): HRESULT {.stdcall.} + UnregisterForDOMEventListeners*: proc(self: ptr IEventTarget2, pCallback: ptr IDOMEventRegistrationCallback): HRESULT {.stdcall.} + HTMLNamespaceEvents* {.pure.} = object + lpVtbl*: ptr HTMLNamespaceEventsVtbl + HTMLNamespaceEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLNamespace* {.pure.} = object + lpVtbl*: ptr IHTMLNamespaceVtbl + IHTMLNamespaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_name*: proc(self: ptr IHTMLNamespace, p: ptr BSTR): HRESULT {.stdcall.} + get_urn*: proc(self: ptr IHTMLNamespace, p: ptr BSTR): HRESULT {.stdcall.} + get_tagNames*: proc(self: ptr IHTMLNamespace, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IHTMLNamespace, p: ptr VARIANT): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IHTMLNamespace, v: VARIANT): HRESULT {.stdcall.} + get_onreadystatechange*: proc(self: ptr IHTMLNamespace, p: ptr VARIANT): HRESULT {.stdcall.} + doImport*: proc(self: ptr IHTMLNamespace, bstrImplementationUrl: BSTR): HRESULT {.stdcall.} + attachEvent*: proc(self: ptr IHTMLNamespace, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + detachEvent*: proc(self: ptr IHTMLNamespace, event: BSTR, pDisp: ptr IDispatch): HRESULT {.stdcall.} + IHTMLNamespaceCollection* {.pure.} = object + lpVtbl*: ptr IHTMLNamespaceCollectionVtbl + IHTMLNamespaceCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLNamespaceCollection, p: ptr LONG): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLNamespaceCollection, index: VARIANT, ppNamespace: ptr ptr IDispatch): HRESULT {.stdcall.} + add*: proc(self: ptr IHTMLNamespaceCollection, bstrNamespace: BSTR, bstrUrn: BSTR, implementationUrl: VARIANT, ppNamespace: ptr ptr IDispatch): HRESULT {.stdcall.} + DispHTMLNamespace* {.pure.} = object + lpVtbl*: ptr DispHTMLNamespaceVtbl + DispHTMLNamespaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispHTMLNamespaceCollection* {.pure.} = object + lpVtbl*: ptr DispHTMLNamespaceCollectionVtbl + DispHTMLNamespaceCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLPainter* {.pure.} = object + lpVtbl*: ptr IHTMLPainterVtbl + IHTMLPainterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Draw*: proc(self: ptr IHTMLPainter, rcBounds: RECT, rcUpdate: RECT, lDrawFlags: LONG, hdc: HDC, pvDrawObject: LPVOID): HRESULT {.stdcall.} + OnResize*: proc(self: ptr IHTMLPainter, size: SIZE): HRESULT {.stdcall.} + GetPainterInfo*: proc(self: ptr IHTMLPainter, pInfo: ptr HTML_PAINTER_INFO): HRESULT {.stdcall.} + HitTestPoint*: proc(self: ptr IHTMLPainter, pt: POINT, pbHit: ptr WINBOOL, plPartID: ptr LONG): HRESULT {.stdcall.} + IHTMLPainterEventInfo* {.pure.} = object + lpVtbl*: ptr IHTMLPainterEventInfoVtbl + IHTMLPainterEventInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetEventInfoFlags*: proc(self: ptr IHTMLPainterEventInfo, plEventInfoFlags: ptr LONG): HRESULT {.stdcall.} + GetEventTarget*: proc(self: ptr IHTMLPainterEventInfo, ppElement: ptr ptr IHTMLElement): HRESULT {.stdcall.} + SetCursor*: proc(self: ptr IHTMLPainterEventInfo, lPartID: LONG): HRESULT {.stdcall.} + StringFromPartID*: proc(self: ptr IHTMLPainterEventInfo, lPartID: LONG, pbstrPart: ptr BSTR): HRESULT {.stdcall.} + IHTMLPainterOverlay* {.pure.} = object + lpVtbl*: ptr IHTMLPainterOverlayVtbl + IHTMLPainterOverlayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnMove*: proc(self: ptr IHTMLPainterOverlay, rcDevice: RECT): HRESULT {.stdcall.} + IHTMLPaintSite* {.pure.} = object + lpVtbl*: ptr IHTMLPaintSiteVtbl + IHTMLPaintSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InvalidatePainterInfo*: proc(self: ptr IHTMLPaintSite): HRESULT {.stdcall.} + InvalidateRect*: proc(self: ptr IHTMLPaintSite, prcInvalid: ptr RECT): HRESULT {.stdcall.} + InvalidateRegion*: proc(self: ptr IHTMLPaintSite, rgnInvalid: HRGN): HRESULT {.stdcall.} + GetDrawInfo*: proc(self: ptr IHTMLPaintSite, lFlags: LONG, pDrawInfo: ptr HTML_PAINT_DRAW_INFO): HRESULT {.stdcall.} + TransformGlobalToLocal*: proc(self: ptr IHTMLPaintSite, ptGlobal: POINT, pptLocal: ptr POINT): HRESULT {.stdcall.} + TransformLocalToGlobal*: proc(self: ptr IHTMLPaintSite, ptLocal: POINT, pptGlobal: ptr POINT): HRESULT {.stdcall.} + GetHitTestCookie*: proc(self: ptr IHTMLPaintSite, plCookie: ptr LONG): HRESULT {.stdcall.} + IHTMLIPrintCollection* {.pure.} = object + lpVtbl*: ptr IHTMLIPrintCollectionVtbl + IHTMLIPrintCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_length*: proc(self: ptr IHTMLIPrintCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IHTMLIPrintCollection, p: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IHTMLIPrintCollection, index: LONG, ppIPrint: ptr ptr IUnknown): HRESULT {.stdcall.} + IEnumPrivacyRecords* {.pure.} = object + lpVtbl*: ptr IEnumPrivacyRecordsVtbl + IEnumPrivacyRecordsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Reset*: proc(self: ptr IEnumPrivacyRecords): HRESULT {.stdcall.} + GetSize*: proc(self: ptr IEnumPrivacyRecords, pSize: ptr ULONG): HRESULT {.stdcall.} + GetPrivacyImpacted*: proc(self: ptr IEnumPrivacyRecords, pState: ptr WINBOOL): HRESULT {.stdcall.} + Next*: proc(self: ptr IEnumPrivacyRecords, pbstrUrl: ptr BSTR, pbstrPolicyRef: ptr BSTR, pdwReserved: ptr LONG, pdwPrivacyFlags: ptr DWORD): HRESULT {.stdcall.} + IWPCBlockedUrls* {.pure.} = object + lpVtbl*: ptr IWPCBlockedUrlsVtbl + IWPCBlockedUrlsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IWPCBlockedUrls, pdwCount: ptr DWORD): HRESULT {.stdcall.} + GetUrl*: proc(self: ptr IWPCBlockedUrls, dwIdx: DWORD, pbstrUrl: ptr BSTR): HRESULT {.stdcall.} + IHTMLDOMConstructorCollection* {.pure.} = object + lpVtbl*: ptr IHTMLDOMConstructorCollectionVtbl + IHTMLDOMConstructorCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Attr*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_BehaviorUrnsCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_BookmarkCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CompatibleInfo*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CompatibleInfoCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_ControlRangeCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSCurrentStyleDeclaration*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSRuleList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSRuleStyleDeclaration*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSStyleDeclaration*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSStyleRule*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_CSSStyleSheet*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_DataTransfer*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_DOMImplementation*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Element*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Event*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_History*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTCElementBehaviorDefaults*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLAnchorElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLAreaElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLAreasCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBaseElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBaseFontElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBGSoundElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBlockElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBodyElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLBRElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLButtonElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLCommentElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLDDElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLDivElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLDocument*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLDListElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLDTElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLEmbedElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLFieldSetElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLFontElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLFormElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLFrameElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLFrameSetElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLGenericElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLHeadElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLHeadingElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLHRElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLHtmlElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLIFrameElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLImageElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLInputElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLIsIndexElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLLabelElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLLegendElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLLIElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLLinkElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLMapElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLMarqueeElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLMetaElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLModelessDialog*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLNamespaceInfo*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLNamespaceInfoCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLNextIdElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLNoShowElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLObjectElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLOListElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLOptionElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLParagraphElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLParamElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLPhraseElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLPluginsCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLPopup*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLScriptElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLSelectElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLSpanElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLStyleElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableCaptionElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableCellElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableColElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableRowElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTableSectionElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTextAreaElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTextElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLTitleElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLUListElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_HTMLUnknownElement*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Image*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Location*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_NamedNodeMap*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Navigator*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_NodeList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Option*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Screen*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Selection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_StaticNodeList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Storage*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_StyleSheetList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_StyleSheetPage*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_StyleSheetPageList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Text*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_TextRange*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_TextRangeCollection*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_TextRectangle*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_TextRectangleList*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Window*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_XDomainRequest*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + get_XMLHttpRequest*: proc(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.stdcall.} + IHTMLDialog* {.pure.} = object + lpVtbl*: ptr IHTMLDialogVtbl + IHTMLDialogVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_dialogTop*: proc(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.stdcall.} + get_dialogTop*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + put_dialogLeft*: proc(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.stdcall.} + get_dialogLeft*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + put_dialogWidth*: proc(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.stdcall.} + get_dialogWidth*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + put_dialogHeight*: proc(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.stdcall.} + get_dialogHeight*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + get_dialogArguments*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + get_menuArguments*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + put_returnValue*: proc(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.stdcall.} + get_returnValue*: proc(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.stdcall.} + close*: proc(self: ptr IHTMLDialog): HRESULT {.stdcall.} + toString*: proc(self: ptr IHTMLDialog, String: ptr BSTR): HRESULT {.stdcall.} + IHTMLDialog2* {.pure.} = object + lpVtbl*: ptr IHTMLDialog2Vtbl + IHTMLDialog2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_status*: proc(self: ptr IHTMLDialog2, v: BSTR): HRESULT {.stdcall.} + get_status*: proc(self: ptr IHTMLDialog2, p: ptr BSTR): HRESULT {.stdcall.} + put_resizable*: proc(self: ptr IHTMLDialog2, v: BSTR): HRESULT {.stdcall.} + get_resizable*: proc(self: ptr IHTMLDialog2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLDialog3* {.pure.} = object + lpVtbl*: ptr IHTMLDialog3Vtbl + IHTMLDialog3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_unadorned*: proc(self: ptr IHTMLDialog3, v: BSTR): HRESULT {.stdcall.} + get_unadorned*: proc(self: ptr IHTMLDialog3, p: ptr BSTR): HRESULT {.stdcall.} + put_dialogHide*: proc(self: ptr IHTMLDialog3, v: BSTR): HRESULT {.stdcall.} + get_dialogHide*: proc(self: ptr IHTMLDialog3, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLModelessInit* {.pure.} = object + lpVtbl*: ptr IHTMLModelessInitVtbl + IHTMLModelessInitVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_parameters*: proc(self: ptr IHTMLModelessInit, p: ptr VARIANT): HRESULT {.stdcall.} + get_optionString*: proc(self: ptr IHTMLModelessInit, p: ptr VARIANT): HRESULT {.stdcall.} + get_moniker*: proc(self: ptr IHTMLModelessInit, p: ptr ptr IUnknown): HRESULT {.stdcall.} + get_document*: proc(self: ptr IHTMLModelessInit, p: ptr ptr IUnknown): HRESULT {.stdcall.} + IHTMLPopup* {.pure.} = object + lpVtbl*: ptr IHTMLPopupVtbl + IHTMLPopupVtbl* {.pure, inheritable.} = object of IDispatchVtbl + show*: proc(self: ptr IHTMLPopup, x: LONG, y: LONG, w: LONG, h: LONG, pElement: ptr VARIANT): HRESULT {.stdcall.} + hide*: proc(self: ptr IHTMLPopup): HRESULT {.stdcall.} + get_document*: proc(self: ptr IHTMLPopup, p: ptr ptr IHTMLDocument): HRESULT {.stdcall.} + get_isOpen*: proc(self: ptr IHTMLPopup, p: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DispHTMLPopup* {.pure.} = object + lpVtbl*: ptr DispHTMLPopupVtbl + DispHTMLPopupVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IHTMLAppBehavior* {.pure.} = object + lpVtbl*: ptr IHTMLAppBehaviorVtbl + IHTMLAppBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_applicationName*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_applicationName*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_version*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_version*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_icon*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_icon*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_singleInstance*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_singleInstance*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_minimizeButton*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_minimizeButton*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_maximizeButton*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_maximizeButton*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_border*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_border*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_borderStyle*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_borderStyle*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_sysMenu*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_sysMenu*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_caption*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_caption*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_windowState*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_windowState*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + put_showInTaskBar*: proc(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.stdcall.} + get_showInTaskBar*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + get_commandLine*: proc(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLAppBehavior2* {.pure.} = object + lpVtbl*: ptr IHTMLAppBehavior2Vtbl + IHTMLAppBehavior2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_contextMenu*: proc(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.stdcall.} + get_contextMenu*: proc(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.stdcall.} + put_innerBorder*: proc(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.stdcall.} + get_innerBorder*: proc(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.stdcall.} + put_scroll*: proc(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.stdcall.} + get_scroll*: proc(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.stdcall.} + put_scrollFlat*: proc(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.stdcall.} + get_scrollFlat*: proc(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.stdcall.} + put_selection*: proc(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.stdcall.} + get_selection*: proc(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.stdcall.} + IHTMLAppBehavior3* {.pure.} = object + lpVtbl*: ptr IHTMLAppBehavior3Vtbl + IHTMLAppBehavior3Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_navigable*: proc(self: ptr IHTMLAppBehavior3, v: BSTR): HRESULT {.stdcall.} + get_navigable*: proc(self: ptr IHTMLAppBehavior3, p: ptr BSTR): HRESULT {.stdcall.} + DispHTMLAppBehavior* {.pure.} = object + lpVtbl*: ptr DispHTMLAppBehaviorVtbl + DispHTMLAppBehaviorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispIHTMLInputButtonElement* {.pure.} = object + lpVtbl*: ptr DispIHTMLInputButtonElementVtbl + DispIHTMLInputButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispIHTMLInputTextElement* {.pure.} = object + lpVtbl*: ptr DispIHTMLInputTextElementVtbl + DispIHTMLInputTextElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispIHTMLInputFileElement* {.pure.} = object + lpVtbl*: ptr DispIHTMLInputFileElementVtbl + DispIHTMLInputFileElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispIHTMLOptionButtonElement* {.pure.} = object + lpVtbl*: ptr DispIHTMLOptionButtonElementVtbl + DispIHTMLOptionButtonElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DispIHTMLInputImage* {.pure.} = object + lpVtbl*: ptr DispIHTMLInputImageVtbl + DispIHTMLInputImageVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IElementBehaviorSite* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteVtbl + IElementBehaviorSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetElement*: proc(self: ptr IElementBehaviorSite, ppElement: ptr ptr IHTMLElement): HRESULT {.stdcall.} + RegisterNotification*: proc(self: ptr IElementBehaviorSite, lEvent: LONG): HRESULT {.stdcall.} + IElementBehavior* {.pure.} = object + lpVtbl*: ptr IElementBehaviorVtbl + IElementBehaviorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Init*: proc(self: ptr IElementBehavior, pBehaviorSite: ptr IElementBehaviorSite): HRESULT {.stdcall.} + Notify*: proc(self: ptr IElementBehavior, lEvent: LONG, pVar: ptr VARIANT): HRESULT {.stdcall.} + Detach*: proc(self: ptr IElementBehavior): HRESULT {.stdcall.} + IElementBehaviorFactory* {.pure.} = object + lpVtbl*: ptr IElementBehaviorFactoryVtbl + IElementBehaviorFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FindBehavior*: proc(self: ptr IElementBehaviorFactory, bstrBehavior: BSTR, bstrBehaviorUrl: BSTR, pSite: ptr IElementBehaviorSite, ppBehavior: ptr ptr IElementBehavior): HRESULT {.stdcall.} + IElementNamespace* {.pure.} = object + lpVtbl*: ptr IElementNamespaceVtbl + IElementNamespaceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddTag*: proc(self: ptr IElementNamespace, bstrTagName: BSTR, lFlags: LONG): HRESULT {.stdcall.} + IElementNamespaceTable* {.pure.} = object + lpVtbl*: ptr IElementNamespaceTableVtbl + IElementNamespaceTableVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddNamespace*: proc(self: ptr IElementNamespaceTable, bstrNamespace: BSTR, bstrUrn: BSTR, lFlags: LONG, pvarFactory: ptr VARIANT): HRESULT {.stdcall.} + IElementNamespaceFactory* {.pure.} = object + lpVtbl*: ptr IElementNamespaceFactoryVtbl + IElementNamespaceFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Create*: proc(self: ptr IElementNamespaceFactory, pNamespace: ptr IElementNamespace): HRESULT {.stdcall.} + IElementNamespaceFactory2* {.pure.} = object + lpVtbl*: ptr IElementNamespaceFactory2Vtbl + IElementNamespaceFactory2Vtbl* {.pure, inheritable.} = object of IElementNamespaceFactoryVtbl + CreateWithImplementation*: proc(self: ptr IElementNamespaceFactory2, pNamespace: ptr IElementNamespace, bstrImplementation: BSTR): HRESULT {.stdcall.} + IElementNamespaceFactoryCallback* {.pure.} = object + lpVtbl*: ptr IElementNamespaceFactoryCallbackVtbl + IElementNamespaceFactoryCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Resolve*: proc(self: ptr IElementNamespaceFactoryCallback, bstrNamespace: BSTR, bstrTagName: BSTR, bstrAttrs: BSTR, pNamespace: ptr IElementNamespace): HRESULT {.stdcall.} + IElementBehaviorSiteOM* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteOMVtbl + IElementBehaviorSiteOMVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterEvent*: proc(self: ptr IElementBehaviorSiteOM, pchEvent: LPOLESTR, lFlags: LONG, plCookie: ptr LONG): HRESULT {.stdcall.} + GetEventCookie*: proc(self: ptr IElementBehaviorSiteOM, pchEvent: LPOLESTR, plCookie: ptr LONG): HRESULT {.stdcall.} + FireEvent*: proc(self: ptr IElementBehaviorSiteOM, lCookie: LONG, pEventObject: ptr IHTMLEventObj): HRESULT {.stdcall.} + CreateEventObject*: proc(self: ptr IElementBehaviorSiteOM, ppEventObject: ptr ptr IHTMLEventObj): HRESULT {.stdcall.} + RegisterName*: proc(self: ptr IElementBehaviorSiteOM, pchName: LPOLESTR): HRESULT {.stdcall.} + RegisterUrn*: proc(self: ptr IElementBehaviorSiteOM, pchUrn: LPOLESTR): HRESULT {.stdcall.} + IElementBehaviorSiteOM2* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteOM2Vtbl + IElementBehaviorSiteOM2Vtbl* {.pure, inheritable.} = object of IElementBehaviorSiteOMVtbl + GetDefaults*: proc(self: ptr IElementBehaviorSiteOM2, ppDefaults: ptr ptr IHTMLElementDefaults): HRESULT {.stdcall.} + IElementBehaviorRender* {.pure.} = object + lpVtbl*: ptr IElementBehaviorRenderVtbl + IElementBehaviorRenderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Draw*: proc(self: ptr IElementBehaviorRender, hdc: HDC, lLayer: LONG, pRect: ptr RECT, pReserved: ptr IUnknown): HRESULT {.stdcall.} + GetRenderInfo*: proc(self: ptr IElementBehaviorRender, plRenderInfo: ptr LONG): HRESULT {.stdcall.} + HitTestPoint*: proc(self: ptr IElementBehaviorRender, pPoint: ptr POINT, pReserved: ptr IUnknown, pbHit: ptr WINBOOL): HRESULT {.stdcall.} + IElementBehaviorSiteRender* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteRenderVtbl + IElementBehaviorSiteRenderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Invalidate*: proc(self: ptr IElementBehaviorSiteRender, pRect: ptr RECT): HRESULT {.stdcall.} + InvalidateRenderInfo*: proc(self: ptr IElementBehaviorSiteRender): HRESULT {.stdcall.} + InvalidateStyle*: proc(self: ptr IElementBehaviorSiteRender): HRESULT {.stdcall.} + IElementBehaviorCategory* {.pure.} = object + lpVtbl*: ptr IElementBehaviorCategoryVtbl + IElementBehaviorCategoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCategory*: proc(self: ptr IElementBehaviorCategory, ppchCategory: ptr LPOLESTR): HRESULT {.stdcall.} + IElementBehaviorSiteCategory* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteCategoryVtbl + IElementBehaviorSiteCategoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRelatedBehaviors*: proc(self: ptr IElementBehaviorSiteCategory, lDirection: LONG, pchCategory: LPOLESTR, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + IElementBehaviorSubmit* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSubmitVtbl + IElementBehaviorSubmitVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSubmitInfo*: proc(self: ptr IElementBehaviorSubmit, pSubmitData: ptr IHTMLSubmitData): HRESULT {.stdcall.} + Reset*: proc(self: ptr IElementBehaviorSubmit): HRESULT {.stdcall.} + IElementBehaviorFocus* {.pure.} = object + lpVtbl*: ptr IElementBehaviorFocusVtbl + IElementBehaviorFocusVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFocusRect*: proc(self: ptr IElementBehaviorFocus, pRect: ptr RECT): HRESULT {.stdcall.} + IElementBehaviorLayout* {.pure.} = object + lpVtbl*: ptr IElementBehaviorLayoutVtbl + IElementBehaviorLayoutVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSize*: proc(self: ptr IElementBehaviorLayout, dwFlags: LONG, sizeContent: SIZE, pptTranslateBy: ptr POINT, pptTopLeft: ptr POINT, psizeProposed: ptr SIZE): HRESULT {.stdcall.} + GetLayoutInfo*: proc(self: ptr IElementBehaviorLayout, plLayoutInfo: ptr LONG): HRESULT {.stdcall.} + GetPosition*: proc(self: ptr IElementBehaviorLayout, lFlags: LONG, pptTopLeft: ptr POINT): HRESULT {.stdcall.} + MapSize*: proc(self: ptr IElementBehaviorLayout, psizeIn: ptr SIZE, prcOut: ptr RECT): HRESULT {.stdcall.} + IElementBehaviorLayout2* {.pure.} = object + lpVtbl*: ptr IElementBehaviorLayout2Vtbl + IElementBehaviorLayout2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTextDescent*: proc(self: ptr IElementBehaviorLayout2, plDescent: ptr LONG): HRESULT {.stdcall.} + IElementBehaviorSiteLayout* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteLayoutVtbl + IElementBehaviorSiteLayoutVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InvalidateLayoutInfo*: proc(self: ptr IElementBehaviorSiteLayout): HRESULT {.stdcall.} + InvalidateSize*: proc(self: ptr IElementBehaviorSiteLayout): HRESULT {.stdcall.} + GetMediaResolution*: proc(self: ptr IElementBehaviorSiteLayout, psizeResolution: ptr SIZE): HRESULT {.stdcall.} + IElementBehaviorSiteLayout2* {.pure.} = object + lpVtbl*: ptr IElementBehaviorSiteLayout2Vtbl + IElementBehaviorSiteLayout2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFontInfo*: proc(self: ptr IElementBehaviorSiteLayout2, plf: ptr LOGFONTW): HRESULT {.stdcall.} + IHostBehaviorInit* {.pure.} = object + lpVtbl*: ptr IHostBehaviorInitVtbl + IHostBehaviorInitVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PopulateNamespaceTable*: proc(self: ptr IHostBehaviorInit): HRESULT {.stdcall.} + ISurfacePresenter* {.pure.} = object + lpVtbl*: ptr ISurfacePresenterVtbl + ISurfacePresenterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Present*: proc(self: ptr ISurfacePresenter, uBuffer: UINT, pDirty: ptr RECT): HRESULT {.stdcall.} + GetBuffer*: proc(self: ptr ISurfacePresenter, backBufferIndex: UINT, riid: REFIID, ppBuffer: ptr pointer): HRESULT {.stdcall.} + IsCurrent*: proc(self: ptr ISurfacePresenter, pIsCurrent: ptr WINBOOL): HRESULT {.stdcall.} + IViewObjectPresentSite* {.pure.} = object + lpVtbl*: ptr IViewObjectPresentSiteVtbl + IViewObjectPresentSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateSurfacePresenter*: proc(self: ptr IViewObjectPresentSite, pDevice: ptr IUnknown, width: UINT, height: UINT, backBufferCount: UINT, format: DXGI_FORMAT, mode: VIEW_OBJECT_ALPHA_MODE, ppQueue: ptr ptr ISurfacePresenter): HRESULT {.stdcall.} + IsHardwareComposition*: proc(self: ptr IViewObjectPresentSite, pIsHardwareComposition: ptr WINBOOL): HRESULT {.stdcall.} + SetCompositionMode*: proc(self: ptr IViewObjectPresentSite, mode: VIEW_OBJECT_COMPOSITION_MODE): HRESULT {.stdcall.} + ICanvasPixelArrayData* {.pure.} = object + lpVtbl*: ptr ICanvasPixelArrayDataVtbl + ICanvasPixelArrayDataVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetBufferPointer*: proc(self: ptr ICanvasPixelArrayData, ppBuffer: ptr ptr BYTE, pBufferLength: ptr ULONG): HRESULT {.stdcall.} + IViewObjectPrint* {.pure.} = object + lpVtbl*: ptr IViewObjectPrintVtbl + IViewObjectPrintVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPrintBitmap*: proc(self: ptr IViewObjectPrint, ppPrintBitmap: ptr ptr IUnknown): HRESULT {.stdcall.} + IViewObjectPresentNotifySite* {.pure.} = object + lpVtbl*: ptr IViewObjectPresentNotifySiteVtbl + IViewObjectPresentNotifySiteVtbl* {.pure, inheritable.} = object of IViewObjectPresentSiteVtbl + RequestFrame*: proc(self: ptr IViewObjectPresentNotifySite): HRESULT {.stdcall.} + IViewObjectPresentNotify* {.pure.} = object + lpVtbl*: ptr IViewObjectPresentNotifyVtbl + IViewObjectPresentNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnPreRender*: proc(self: ptr IViewObjectPresentNotify): HRESULT {.stdcall.} + ITrackingProtection* {.pure.} = object + lpVtbl*: ptr ITrackingProtectionVtbl + ITrackingProtectionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EvaluateUrl*: proc(self: ptr ITrackingProtection, bstrUrl: BSTR, pfAllowed: ptr WINBOOL): HRESULT {.stdcall.} + GetEnabled*: proc(self: ptr ITrackingProtection, pfEnabled: ptr WINBOOL): HRESULT {.stdcall.} + IHostDialogHelper* {.pure.} = object + lpVtbl*: ptr IHostDialogHelperVtbl + IHostDialogHelperVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowHTMLDialog*: proc(self: ptr IHostDialogHelper, hwndParent: HWND, pMk: ptr IMoniker, pvarArgIn: ptr VARIANT, pchOptions: ptr WCHAR, pvarArgOut: ptr VARIANT, punkHost: ptr IUnknown): HRESULT {.stdcall.} + IDocHostUIHandler* {.pure.} = object + lpVtbl*: ptr IDocHostUIHandlerVtbl + IDocHostUIHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowContextMenu*: proc(self: ptr IDocHostUIHandler, dwID: DWORD, ppt: ptr POINT, pcmdtReserved: ptr IUnknown, pdispReserved: ptr IDispatch): HRESULT {.stdcall.} + GetHostInfo*: proc(self: ptr IDocHostUIHandler, pInfo: ptr DOCHOSTUIINFO): HRESULT {.stdcall.} + ShowUI*: proc(self: ptr IDocHostUIHandler, dwID: DWORD, pActiveObject: ptr IOleInPlaceActiveObject, pCommandTarget: ptr IOleCommandTarget, pFrame: ptr IOleInPlaceFrame, pDoc: ptr IOleInPlaceUIWindow): HRESULT {.stdcall.} + HideUI*: proc(self: ptr IDocHostUIHandler): HRESULT {.stdcall.} + UpdateUI*: proc(self: ptr IDocHostUIHandler): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IDocHostUIHandler, fEnable: WINBOOL): HRESULT {.stdcall.} + OnDocWindowActivate*: proc(self: ptr IDocHostUIHandler, fActivate: WINBOOL): HRESULT {.stdcall.} + OnFrameWindowActivate*: proc(self: ptr IDocHostUIHandler, fActivate: WINBOOL): HRESULT {.stdcall.} + ResizeBorder*: proc(self: ptr IDocHostUIHandler, prcBorder: LPCRECT, pUIWindow: ptr IOleInPlaceUIWindow, fRameWindow: WINBOOL): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IDocHostUIHandler, lpMsg: LPMSG, pguidCmdGroup: ptr GUID, nCmdID: DWORD): HRESULT {.stdcall.} + GetOptionKeyPath*: proc(self: ptr IDocHostUIHandler, pchKey: ptr LPOLESTR, dw: DWORD): HRESULT {.stdcall.} + GetDropTarget*: proc(self: ptr IDocHostUIHandler, pDropTarget: ptr IDropTarget, ppDropTarget: ptr ptr IDropTarget): HRESULT {.stdcall.} + GetExternal*: proc(self: ptr IDocHostUIHandler, ppDispatch: ptr ptr IDispatch): HRESULT {.stdcall.} + TranslateUrl*: proc(self: ptr IDocHostUIHandler, dwTranslate: DWORD, pchURLIn: LPWSTR, ppchURLOut: ptr LPWSTR): HRESULT {.stdcall.} + FilterDataObject*: proc(self: ptr IDocHostUIHandler, pDO: ptr IDataObject, ppDORet: ptr ptr IDataObject): HRESULT {.stdcall.} + IDocHostUIHandler2* {.pure.} = object + lpVtbl*: ptr IDocHostUIHandler2Vtbl + IDocHostUIHandler2Vtbl* {.pure, inheritable.} = object of IDocHostUIHandlerVtbl + GetOverrideKeyPath*: proc(self: ptr IDocHostUIHandler2, pchKey: ptr LPOLESTR, dw: DWORD): HRESULT {.stdcall.} + ICustomDoc* {.pure.} = object + lpVtbl*: ptr ICustomDocVtbl + ICustomDocVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetUIHandler*: proc(self: ptr ICustomDoc, pUIHandler: ptr IDocHostUIHandler): HRESULT {.stdcall.} + IDocHostShowUI* {.pure.} = object + lpVtbl*: ptr IDocHostShowUIVtbl + IDocHostShowUIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowMessage*: proc(self: ptr IDocHostShowUI, hwnd: HWND, lpstrText: LPOLESTR, lpstrCaption: LPOLESTR, dwType: DWORD, lpstrHelpFile: LPOLESTR, dwHelpContext: DWORD, plResult: ptr LRESULT): HRESULT {.stdcall.} + ShowHelp*: proc(self: ptr IDocHostShowUI, hwnd: HWND, pszHelpFile: LPOLESTR, uCommand: UINT, dwData: DWORD, ptMouse: POINT, pDispatchObjectHit: ptr IDispatch): HRESULT {.stdcall.} + IHTMLOMWindowServices* {.pure.} = object + lpVtbl*: ptr IHTMLOMWindowServicesVtbl + IHTMLOMWindowServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + moveTo*: proc(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.stdcall.} + moveBy*: proc(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.stdcall.} + resizeTo*: proc(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.stdcall.} + resizeBy*: proc(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.stdcall.} +proc GetDispID*(self: ptr IDispatchEx, bstrName: BSTR, grfdex: DWORD, pid: ptr DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDispID(self, bstrName, grfdex, pid) +proc InvokeEx*(self: ptr IDispatchEx, id: DISPID, lcid: LCID, wFlags: WORD, pdp: ptr DISPPARAMS, pvarRes: ptr VARIANT, pei: ptr EXCEPINFO, pspCaller: ptr IServiceProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeEx(self, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller) +proc DeleteMemberByName*(self: ptr IDispatchEx, bstrName: BSTR, grfdex: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteMemberByName(self, bstrName, grfdex) +proc DeleteMemberByDispID*(self: ptr IDispatchEx, id: DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteMemberByDispID(self, id) +proc GetMemberProperties*(self: ptr IDispatchEx, id: DISPID, grfdexFetch: DWORD, pgrfdex: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMemberProperties(self, id, grfdexFetch, pgrfdex) +proc GetMemberName*(self: ptr IDispatchEx, id: DISPID, pbstrName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMemberName(self, id, pbstrName) +proc GetNextDispID*(self: ptr IDispatchEx, grfdex: DWORD, id: DISPID, pid: ptr DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextDispID(self, grfdex, id, pid) +proc GetNameSpaceParent*(self: ptr IDispatchEx, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNameSpaceParent(self, ppunk) +proc QueryErrorInfo*(self: ptr IDispError, guidErrorType: GUID, ppde: ptr ptr IDispError): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryErrorInfo(self, guidErrorType, ppde) +proc GetNext*(self: ptr IDispError, ppde: ptr ptr IDispError): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNext(self, ppde) +proc GetHresult*(self: ptr IDispError, phr: ptr HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHresult(self, phr) +proc GetSource*(self: ptr IDispError, pbstrSource: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSource(self, pbstrSource) +proc GetHelpInfo*(self: ptr IDispError, pbstrFileName: ptr BSTR, pdwContext: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHelpInfo(self, pbstrFileName, pdwContext) +proc GetDescription*(self: ptr IDispError, pbstrDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pbstrDescription) +proc ChangeType*(self: ptr IVariantChangeType, pvarDst: ptr VARIANT, pvarSrc: ptr VARIANT, lcid: LCID, vtNew: VARTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ChangeType(self, pvarDst, pvarSrc, lcid, vtNew) +proc IsEqualObject*(self: ptr IObjectIdentity, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqualObject(self, punk) +proc CanHandleException*(self: ptr ICanHandleException, pExcepInfo: ptr EXCEPINFO, pvar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanHandleException(self, pExcepInfo, pvar) +proc GetCurrentSourceContext*(self: ptr IProvideRuntimeContext, pdwContext: ptr DWORD_PTR, pfExecutingGlobalCode: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSourceContext(self, pdwContext, pfExecutingGlobalCode) +proc get_length*(self: ptr IHTMLFiltersCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLFiltersCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLFiltersCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, pvarIndex, pvarResult) +proc get_constructor*(self: ptr IHTMLDOMConstructor, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_constructor(self, p) +proc LookupGetter*(self: ptr IHTMLDOMConstructor, propname: BSTR, ppDispHandler: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LookupGetter(self, propname, ppDispHandler) +proc LookupSetter*(self: ptr IHTMLDOMConstructor, propname: BSTR, ppDispHandler: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LookupSetter(self, propname, ppDispHandler) +proc DefineGetter*(self: ptr IHTMLDOMConstructor, propname: BSTR, pdispHandler: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineGetter(self, propname, pdispHandler) +proc DefineSetter*(self: ptr IHTMLDOMConstructor, propname: BSTR, pdispHandler: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineSetter(self, propname, pdispHandler) +proc get_length*(self: ptr IHTMLCSSStyleDeclaration, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_parentRule*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentRule(self, p) +proc getPropertyValue*(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPropertyValue(self, bstrPropertyName, pbstrPropertyValue) +proc getPropertyPriority*(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyPriority: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPropertyPriority(self, bstrPropertyName, pbstrPropertyPriority) +proc removeProperty*(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pbstrPropertyValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeProperty(self, bstrPropertyName, pbstrPropertyValue) +proc setProperty*(self: ptr IHTMLCSSStyleDeclaration, bstrPropertyName: BSTR, pvarPropertyValue: ptr VARIANT, pvarPropertyPriority: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setProperty(self, bstrPropertyName, pvarPropertyValue, pvarPropertyPriority) +proc item*(self: ptr IHTMLCSSStyleDeclaration, index: LONG, pbstrPropertyName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pbstrPropertyName) +proc put_fontFamily*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontFamily(self, v) +proc get_fontFamily*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontFamily(self, p) +proc put_fontStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontStyle(self, v) +proc get_fontStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontStyle(self, p) +proc put_fontVariant*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontVariant(self, v) +proc get_fontVariant*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontVariant(self, p) +proc put_fontWeight*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontWeight(self, v) +proc get_fontWeight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontWeight(self, p) +proc put_fontSize*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontSize(self, v) +proc get_fontSize*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSize(self, p) +proc put_font*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_font(self, v) +proc get_font*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_font(self, p) +proc put_color*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_background*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_backgroundColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundColor(self, v) +proc get_backgroundColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundColor(self, p) +proc put_backgroundImage*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundImage(self, v) +proc get_backgroundImage*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundImage(self, p) +proc put_backgroundRepeat*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundRepeat(self, v) +proc get_backgroundRepeat*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundRepeat(self, p) +proc put_backgroundAttachment*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundAttachment(self, v) +proc get_backgroundAttachment*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundAttachment(self, p) +proc put_backgroundPosition*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPosition(self, v) +proc get_backgroundPosition*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPosition(self, p) +proc put_backgroundPositionX*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionX(self, v) +proc get_backgroundPositionX*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionX(self, p) +proc put_backgroundPositionY*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionY(self, v) +proc get_backgroundPositionY*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionY(self, p) +proc put_wordSpacing*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordSpacing(self, v) +proc get_wordSpacing*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordSpacing(self, p) +proc put_letterSpacing*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_letterSpacing(self, v) +proc get_letterSpacing*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_letterSpacing(self, p) +proc put_textDecoration*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecoration(self, v) +proc get_textDecoration*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecoration(self, p) +proc put_verticalAlign*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_verticalAlign(self, v) +proc get_verticalAlign*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_verticalAlign(self, p) +proc put_textTransform*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textTransform(self, v) +proc get_textTransform*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textTransform(self, p) +proc put_textAlign*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlign(self, v) +proc get_textAlign*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlign(self, p) +proc put_textIndent*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textIndent(self, v) +proc get_textIndent*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textIndent(self, p) +proc put_lineHeight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineHeight(self, v) +proc get_lineHeight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineHeight(self, p) +proc put_marginTop*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginTop(self, v) +proc get_marginTop*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginTop(self, p) +proc put_marginRight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginRight(self, v) +proc get_marginRight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginRight(self, p) +proc put_marginBottom*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginBottom(self, v) +proc get_marginBottom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginBottom(self, p) +proc put_marginLeft*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginLeft(self, v) +proc get_marginLeft*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginLeft(self, p) +proc put_margin*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_margin(self, v) +proc get_margin*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_margin(self, p) +proc put_paddingTop*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingTop(self, v) +proc get_paddingTop*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingTop(self, p) +proc put_paddingRight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingRight(self, v) +proc get_paddingRight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingRight(self, p) +proc put_paddingBottom*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingBottom(self, v) +proc get_paddingBottom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingBottom(self, p) +proc put_paddingLeft*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingLeft(self, v) +proc get_paddingLeft*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingLeft(self, p) +proc put_padding*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_padding(self, v) +proc get_padding*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_padding(self, p) +proc put_border*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_borderTop*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTop(self, v) +proc get_borderTop*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTop(self, p) +proc put_borderRight*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRight(self, v) +proc get_borderRight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRight(self, p) +proc put_borderBottom*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottom(self, v) +proc get_borderBottom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottom(self, p) +proc put_borderLeft*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeft(self, v) +proc get_borderLeft*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeft(self, p) +proc put_borderColor*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderTopColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopColor(self, v) +proc get_borderTopColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopColor(self, p) +proc put_borderRightColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightColor(self, v) +proc get_borderRightColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightColor(self, p) +proc put_borderBottomColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomColor(self, v) +proc get_borderBottomColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomColor(self, p) +proc put_borderLeftColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftColor(self, v) +proc get_borderLeftColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftColor(self, p) +proc put_borderWidth*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderWidth(self, v) +proc get_borderWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderWidth(self, p) +proc put_borderTopWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopWidth(self, v) +proc get_borderTopWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopWidth(self, p) +proc put_borderRightWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightWidth(self, v) +proc get_borderRightWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightWidth(self, p) +proc put_borderBottomWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomWidth(self, v) +proc get_borderBottomWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomWidth(self, p) +proc put_borderLeftWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftWidth(self, v) +proc get_borderLeftWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftWidth(self, p) +proc put_borderStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderStyle(self, v) +proc get_borderStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderStyle(self, p) +proc put_borderTopStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopStyle(self, v) +proc get_borderTopStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopStyle(self, p) +proc put_borderRightStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightStyle(self, v) +proc get_borderRightStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightStyle(self, p) +proc put_borderBottomStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomStyle(self, v) +proc get_borderBottomStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomStyle(self, p) +proc put_borderLeftStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftStyle(self, v) +proc get_borderLeftStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftStyle(self, p) +proc put_width*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_styleFloat*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_styleFloat(self, v) +proc get_styleFloat*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleFloat(self, p) +proc put_clear*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clear(self, v) +proc get_clear*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc put_display*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_display(self, v) +proc get_display*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_display(self, p) +proc put_visibility*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_visibility(self, v) +proc get_visibility*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_visibility(self, p) +proc put_listStyleType*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleType(self, v) +proc get_listStyleType*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleType(self, p) +proc put_listStylePosition*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStylePosition(self, v) +proc get_listStylePosition*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStylePosition(self, p) +proc put_listStyleImage*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleImage(self, v) +proc get_listStyleImage*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleImage(self, p) +proc put_listStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyle(self, v) +proc get_listStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyle(self, p) +proc put_whiteSpace*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_whiteSpace(self, v) +proc get_whiteSpace*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whiteSpace(self, p) +proc put_top*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_top(self, v) +proc get_top*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc put_left*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_left(self, v) +proc get_left*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_left(self, p) +proc put_zIndex*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zIndex(self, v) +proc get_zIndex*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zIndex(self, p) +proc put_overflow*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflow(self, v) +proc get_overflow*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflow(self, p) +proc put_pageBreakBefore*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakBefore(self, v) +proc get_pageBreakBefore*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakBefore(self, p) +proc put_pageBreakAfter*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakAfter(self, v) +proc get_pageBreakAfter*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakAfter(self, p) +proc put_cssText*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssText(self, v) +proc get_cssText*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssText(self, p) +proc put_cursor*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cursor(self, v) +proc get_cursor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cursor(self, p) +proc put_clip*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clip(self, v) +proc get_clip*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clip(self, p) +proc put_filter*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_filter(self, v) +proc get_filter*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc put_tableLayout*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tableLayout(self, v) +proc get_tableLayout*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tableLayout(self, p) +proc put_borderCollapse*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderCollapse(self, v) +proc get_borderCollapse*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderCollapse(self, p) +proc put_direction*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_direction(self, v) +proc get_direction*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc put_behavior*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_behavior(self, v) +proc get_behavior*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behavior(self, p) +proc put_position*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_position(self, v) +proc get_position*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc put_unicodeBidi*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unicodeBidi(self, v) +proc get_unicodeBidi*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unicodeBidi(self, p) +proc put_bottom*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bottom(self, v) +proc get_bottom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottom(self, p) +proc put_right*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_right(self, v) +proc get_right*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_right(self, p) +proc put_imeMode*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_imeMode(self, v) +proc get_imeMode*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeMode(self, p) +proc put_rubyAlign*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyAlign(self, v) +proc get_rubyAlign*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyAlign(self, p) +proc put_rubyPosition*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyPosition(self, v) +proc get_rubyPosition*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyPosition(self, p) +proc put_rubyOverhang*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyOverhang(self, v) +proc get_rubyOverhang*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyOverhang(self, p) +proc put_layoutGridChar*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridChar(self, v) +proc get_layoutGridChar*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridChar(self, p) +proc put_layoutGridLine*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridLine(self, v) +proc get_layoutGridLine*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridLine(self, p) +proc put_layoutGridMode*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridMode(self, v) +proc get_layoutGridMode*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridMode(self, p) +proc put_layoutGridType*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridType(self, v) +proc get_layoutGridType*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridType(self, p) +proc put_layoutGrid*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGrid(self, v) +proc get_layoutGrid*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGrid(self, p) +proc put_textAutospace*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAutospace(self, v) +proc get_textAutospace*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAutospace(self, p) +proc put_wordBreak*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordBreak(self, v) +proc get_wordBreak*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordBreak(self, p) +proc put_lineBreak*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineBreak(self, v) +proc get_lineBreak*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineBreak(self, p) +proc put_textJustify*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustify(self, v) +proc get_textJustify*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustify(self, p) +proc put_textJustifyTrim*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustifyTrim(self, v) +proc get_textJustifyTrim*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustifyTrim(self, p) +proc put_textKashida*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashida(self, v) +proc get_textKashida*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashida(self, p) +proc put_overflowX*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowX(self, v) +proc get_overflowX*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowX(self, p) +proc put_overflowY*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowY(self, v) +proc get_overflowY*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowY(self, p) +proc put_accelerator*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accelerator(self, v) +proc get_accelerator*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accelerator(self, p) +proc put_layoutFlow*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutFlow(self, v) +proc get_layoutFlow*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutFlow(self, p) +proc put_zoom*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zoom(self, v) +proc get_zoom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoom(self, p) +proc put_wordWrap*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordWrap(self, v) +proc get_wordWrap*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordWrap(self, p) +proc put_textUnderlinePosition*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textUnderlinePosition(self, v) +proc get_textUnderlinePosition*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textUnderlinePosition(self, p) +proc put_scrollbarBaseColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarBaseColor(self, v) +proc get_scrollbarBaseColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarBaseColor(self, p) +proc put_scrollbarFaceColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarFaceColor(self, v) +proc get_scrollbarFaceColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarFaceColor(self, p) +proc put_scrollbar3dLightColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbar3dLightColor(self, v) +proc get_scrollbar3dLightColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbar3dLightColor(self, p) +proc put_scrollbarShadowColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarShadowColor(self, v) +proc get_scrollbarShadowColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarShadowColor(self, p) +proc put_scrollbarHighlightColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarHighlightColor(self, v) +proc get_scrollbarHighlightColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarHighlightColor(self, p) +proc put_scrollbarDarkShadowColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarDarkShadowColor(self, v) +proc get_scrollbarDarkShadowColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarDarkShadowColor(self, p) +proc put_scrollbarArrowColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarArrowColor(self, v) +proc get_scrollbarArrowColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarArrowColor(self, p) +proc put_scrollbarTrackColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarTrackColor(self, v) +proc get_scrollbarTrackColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarTrackColor(self, p) +proc put_writingMode*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_writingMode(self, v) +proc get_writingMode*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_writingMode(self, p) +proc put_textAlignLast*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlignLast(self, v) +proc get_textAlignLast*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlignLast(self, p) +proc put_textKashidaSpace*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashidaSpace(self, v) +proc get_textKashidaSpace*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashidaSpace(self, p) +proc put_textOverflow*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textOverflow(self, v) +proc get_textOverflow*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textOverflow(self, p) +proc put_minHeight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minHeight(self, v) +proc get_minHeight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minHeight(self, p) +proc put_msInterpolationMode*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msInterpolationMode(self, v) +proc get_msInterpolationMode*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msInterpolationMode(self, p) +proc put_maxHeight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxHeight(self, v) +proc get_maxHeight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxHeight(self, p) +proc put_minWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minWidth(self, v) +proc get_minWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minWidth(self, p) +proc put_maxWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxWidth(self, v) +proc get_maxWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxWidth(self, p) +proc put_content*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_content(self, v) +proc get_content*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_content(self, p) +proc put_captionSide*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_captionSide(self, v) +proc get_captionSide*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_captionSide(self, p) +proc put_counterIncrement*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterIncrement(self, v) +proc get_counterIncrement*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterIncrement(self, p) +proc put_counterReset*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterReset(self, v) +proc get_counterReset*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterReset(self, p) +proc put_outline*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outline(self, v) +proc get_outline*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outline(self, p) +proc put_outlineWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineWidth(self, v) +proc get_outlineWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineWidth(self, p) +proc put_outlineStyle*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineStyle(self, v) +proc get_outlineStyle*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineStyle(self, p) +proc put_outlineColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineColor(self, v) +proc get_outlineColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineColor(self, p) +proc put_boxSizing*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_boxSizing(self, v) +proc get_boxSizing*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boxSizing(self, p) +proc put_borderSpacing*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderSpacing(self, v) +proc get_borderSpacing*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderSpacing(self, p) +proc put_orphans*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_orphans(self, v) +proc get_orphans*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orphans(self, p) +proc put_widows*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_widows(self, v) +proc get_widows*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_widows(self, p) +proc put_pageBreakInside*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakInside(self, v) +proc get_pageBreakInside*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakInside(self, p) +proc put_emptyCells*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_emptyCells(self, v) +proc get_emptyCells*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_emptyCells(self, p) +proc put_msBlockProgression*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msBlockProgression(self, v) +proc get_msBlockProgression*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msBlockProgression(self, p) +proc put_quotes*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_quotes(self, v) +proc get_quotes*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_quotes(self, p) +proc put_alignmentBaseline*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alignmentBaseline(self, v) +proc get_alignmentBaseline*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alignmentBaseline(self, p) +proc put_baselineShift*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baselineShift(self, v) +proc get_baselineShift*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baselineShift(self, p) +proc put_dominantBaseline*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dominantBaseline(self, v) +proc get_dominantBaseline*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dominantBaseline(self, p) +proc put_fontSizeAdjust*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontSizeAdjust(self, v) +proc get_fontSizeAdjust*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSizeAdjust(self, p) +proc put_fontStretch*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontStretch(self, v) +proc get_fontStretch*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontStretch(self, p) +proc put_opacity*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_opacity(self, v) +proc get_opacity*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_opacity(self, p) +proc put_clipPath*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clipPath(self, v) +proc get_clipPath*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipPath(self, p) +proc put_clipRule*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clipRule(self, v) +proc get_clipRule*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipRule(self, p) +proc put_fill*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fill(self, v) +proc get_fill*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fill(self, p) +proc put_fillOpacity*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fillOpacity(self, v) +proc get_fillOpacity*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fillOpacity(self, p) +proc put_fillRule*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fillRule(self, v) +proc get_fillRule*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fillRule(self, p) +proc put_kerning*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_kerning(self, v) +proc get_kerning*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_kerning(self, p) +proc put_marker*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marker(self, v) +proc get_marker*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marker(self, p) +proc put_markerEnd*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_markerEnd(self, v) +proc get_markerEnd*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerEnd(self, p) +proc put_markerMid*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_markerMid(self, v) +proc get_markerMid*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerMid(self, p) +proc put_markerStart*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_markerStart(self, v) +proc get_markerStart*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerStart(self, p) +proc put_mask*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_mask(self, v) +proc get_mask*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mask(self, p) +proc put_pointerEvents*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pointerEvents(self, v) +proc get_pointerEvents*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pointerEvents(self, p) +proc put_stopColor*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_stopColor(self, v) +proc get_stopColor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_stopColor(self, p) +proc put_stopOpacity*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_stopOpacity(self, v) +proc get_stopOpacity*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_stopOpacity(self, p) +proc put_stroke*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_stroke(self, v) +proc get_stroke*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_stroke(self, p) +proc put_strokeDasharray*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeDasharray(self, v) +proc get_strokeDasharray*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeDasharray(self, p) +proc put_strokeDashoffset*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeDashoffset(self, v) +proc get_strokeDashoffset*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeDashoffset(self, p) +proc put_strokeLinecap*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeLinecap(self, v) +proc get_strokeLinecap*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeLinecap(self, p) +proc put_strokeLinejoin*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeLinejoin(self, v) +proc get_strokeLinejoin*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeLinejoin(self, p) +proc put_strokeMiterlimit*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeMiterlimit(self, v) +proc get_strokeMiterlimit*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeMiterlimit(self, p) +proc put_strokeOpacity*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeOpacity(self, v) +proc get_strokeOpacity*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeOpacity(self, p) +proc put_strokeWidth*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeWidth(self, v) +proc get_strokeWidth*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeWidth(self, p) +proc put_textAnchor*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAnchor(self, v) +proc get_textAnchor*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAnchor(self, p) +proc put_glyphOrientationHorizontal*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_glyphOrientationHorizontal(self, v) +proc get_glyphOrientationHorizontal*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_glyphOrientationHorizontal(self, p) +proc put_glyphOrientationVertical*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_glyphOrientationVertical(self, v) +proc get_glyphOrientationVertical*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_glyphOrientationVertical(self, p) +proc put_borderRadius*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRadius(self, v) +proc get_borderRadius*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRadius(self, p) +proc put_borderTopLeftRadius*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopLeftRadius(self, v) +proc get_borderTopLeftRadius*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopLeftRadius(self, p) +proc put_borderTopRightRadius*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopRightRadius(self, v) +proc get_borderTopRightRadius*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopRightRadius(self, p) +proc put_borderBottomRightRadius*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomRightRadius(self, v) +proc get_borderBottomRightRadius*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomRightRadius(self, p) +proc put_borderBottomLeftRadius*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomLeftRadius(self, v) +proc get_borderBottomLeftRadius*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomLeftRadius(self, p) +proc put_clipTop*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clipTop(self, v) +proc get_clipTop*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipTop(self, p) +proc put_clipRight*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clipRight(self, v) +proc get_clipRight*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipRight(self, p) +proc get_clipBottom*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipBottom(self, p) +proc put_clipLeft*(self: ptr IHTMLCSSStyleDeclaration, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clipLeft(self, v) +proc get_clipLeft*(self: ptr IHTMLCSSStyleDeclaration, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipLeft(self, p) +proc put_cssFloat*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssFloat(self, v) +proc get_cssFloat*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssFloat(self, p) +proc put_backgroundClip*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundClip(self, v) +proc get_backgroundClip*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundClip(self, p) +proc put_backgroundOrigin*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundOrigin(self, v) +proc get_backgroundOrigin*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundOrigin(self, p) +proc put_backgroundSize*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundSize(self, v) +proc get_backgroundSize*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundSize(self, p) +proc put_boxShadow*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_boxShadow(self, v) +proc get_boxShadow*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boxShadow(self, p) +proc put_msTransform*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransform(self, v) +proc get_msTransform*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransform(self, p) +proc put_msTransformOrigin*(self: ptr IHTMLCSSStyleDeclaration, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransformOrigin(self, v) +proc get_msTransformOrigin*(self: ptr IHTMLCSSStyleDeclaration, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransformOrigin(self, p) +proc put_msScrollChaining*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollChaining(self, v) +proc get_msScrollChaining*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollChaining(self, p) +proc put_msContentZooming*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZooming(self, v) +proc get_msContentZooming*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZooming(self, p) +proc put_msContentZoomSnapType*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomSnapType(self, v) +proc get_msContentZoomSnapType*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomSnapType(self, p) +proc put_msScrollRails*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollRails(self, v) +proc get_msScrollRails*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollRails(self, p) +proc put_msContentZoomChaining*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomChaining(self, v) +proc get_msContentZoomChaining*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomChaining(self, p) +proc put_msScrollSnapType*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollSnapType(self, v) +proc get_msScrollSnapType*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollSnapType(self, p) +proc put_msContentZoomLimit*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomLimit(self, v) +proc get_msContentZoomLimit*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomLimit(self, p) +proc put_msContentZoomSnap*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomSnap(self, v) +proc get_msContentZoomSnap*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomSnap(self, p) +proc put_msContentZoomSnapPoints*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomSnapPoints(self, v) +proc get_msContentZoomSnapPoints*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomSnapPoints(self, p) +proc put_msContentZoomLimitMin*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomLimitMin(self, v) +proc get_msContentZoomLimitMin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomLimitMin(self, p) +proc put_msContentZoomLimitMax*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msContentZoomLimitMax(self, v) +proc get_msContentZoomLimitMax*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msContentZoomLimitMax(self, p) +proc put_msScrollSnapX*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollSnapX(self, v) +proc get_msScrollSnapX*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollSnapX(self, p) +proc put_msScrollSnapY*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollSnapY(self, v) +proc get_msScrollSnapY*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollSnapY(self, p) +proc put_msScrollSnapPointsX*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollSnapPointsX(self, v) +proc get_msScrollSnapPointsX*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollSnapPointsX(self, p) +proc put_msScrollSnapPointsY*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollSnapPointsY(self, v) +proc get_msScrollSnapPointsY*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollSnapPointsY(self, p) +proc put_msGridColumn*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridColumn(self, v) +proc get_msGridColumn*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridColumn(self, p) +proc put_msGridColumnAlign*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridColumnAlign(self, v) +proc get_msGridColumnAlign*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridColumnAlign(self, p) +proc put_msGridColumns*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridColumns(self, v) +proc get_msGridColumns*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridColumns(self, p) +proc put_msGridColumnSpan*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridColumnSpan(self, v) +proc get_msGridColumnSpan*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridColumnSpan(self, p) +proc put_msGridRow*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridRow(self, v) +proc get_msGridRow*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridRow(self, p) +proc put_msGridRowAlign*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridRowAlign(self, v) +proc get_msGridRowAlign*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridRowAlign(self, p) +proc put_msGridRows*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridRows(self, v) +proc get_msGridRows*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridRows(self, p) +proc put_msGridRowSpan*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msGridRowSpan(self, v) +proc get_msGridRowSpan*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msGridRowSpan(self, p) +proc put_msWrapThrough*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msWrapThrough(self, v) +proc get_msWrapThrough*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msWrapThrough(self, p) +proc put_msWrapMargin*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msWrapMargin(self, v) +proc get_msWrapMargin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msWrapMargin(self, p) +proc put_msWrapFlow*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msWrapFlow(self, v) +proc get_msWrapFlow*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msWrapFlow(self, p) +proc put_msAnimationName*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationName(self, v) +proc get_msAnimationName*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationName(self, p) +proc put_msAnimationDuration*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationDuration(self, v) +proc get_msAnimationDuration*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationDuration(self, p) +proc put_msAnimationTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationTimingFunction(self, v) +proc get_msAnimationTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationTimingFunction(self, p) +proc put_msAnimationDelay*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationDelay(self, v) +proc get_msAnimationDelay*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationDelay(self, p) +proc put_msAnimationDirection*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationDirection(self, v) +proc get_msAnimationDirection*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationDirection(self, p) +proc put_msAnimationPlayState*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationPlayState(self, v) +proc get_msAnimationPlayState*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationPlayState(self, p) +proc put_msAnimationIterationCount*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationIterationCount(self, v) +proc get_msAnimationIterationCount*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationIterationCount(self, p) +proc put_msAnimation*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimation(self, v) +proc get_msAnimation*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimation(self, p) +proc put_msAnimationFillMode*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msAnimationFillMode(self, v) +proc get_msAnimationFillMode*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msAnimationFillMode(self, p) +proc put_colorInterpolationFilters*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_colorInterpolationFilters(self, v) +proc get_colorInterpolationFilters*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_colorInterpolationFilters(self, p) +proc put_columnCount*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnCount(self, v) +proc get_columnCount*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnCount(self, p) +proc put_columnWidth*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnWidth(self, v) +proc get_columnWidth*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnWidth(self, p) +proc put_columnGap*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnGap(self, v) +proc get_columnGap*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnGap(self, p) +proc put_columnFill*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnFill(self, v) +proc get_columnFill*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnFill(self, p) +proc put_columnSpan*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnSpan(self, v) +proc get_columnSpan*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnSpan(self, p) +proc put_columns*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columns(self, v) +proc get_columns*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columns(self, p) +proc put_columnRule*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnRule(self, v) +proc get_columnRule*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnRule(self, p) +proc put_columnRuleColor*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnRuleColor(self, v) +proc get_columnRuleColor*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnRuleColor(self, p) +proc put_columnRuleStyle*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnRuleStyle(self, v) +proc get_columnRuleStyle*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnRuleStyle(self, p) +proc put_columnRuleWidth*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_columnRuleWidth(self, v) +proc get_columnRuleWidth*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_columnRuleWidth(self, p) +proc put_breakBefore*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_breakBefore(self, v) +proc get_breakBefore*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_breakBefore(self, p) +proc put_breakAfter*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_breakAfter(self, v) +proc get_breakAfter*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_breakAfter(self, p) +proc put_breakInside*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_breakInside(self, v) +proc get_breakInside*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_breakInside(self, p) +proc put_floodColor*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_floodColor(self, v) +proc get_floodColor*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_floodColor(self, p) +proc put_floodOpacity*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_floodOpacity(self, v) +proc get_floodOpacity*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_floodOpacity(self, p) +proc put_lightingColor*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lightingColor(self, v) +proc get_lightingColor*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lightingColor(self, p) +proc put_msScrollLimitXMin*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollLimitXMin(self, v) +proc get_msScrollLimitXMin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollLimitXMin(self, p) +proc put_msScrollLimitYMin*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollLimitYMin(self, v) +proc get_msScrollLimitYMin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollLimitYMin(self, p) +proc put_msScrollLimitXMax*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollLimitXMax(self, v) +proc get_msScrollLimitXMax*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollLimitXMax(self, p) +proc put_msScrollLimitYMax*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollLimitYMax(self, v) +proc get_msScrollLimitYMax*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollLimitYMax(self, p) +proc put_msScrollLimit*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollLimit(self, v) +proc get_msScrollLimit*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollLimit(self, p) +proc put_textShadow*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textShadow(self, v) +proc get_textShadow*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textShadow(self, p) +proc put_msFlowFrom*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlowFrom(self, v) +proc get_msFlowFrom*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlowFrom(self, p) +proc put_msFlowInto*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlowInto(self, v) +proc get_msFlowInto*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlowInto(self, p) +proc put_msHyphens*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msHyphens(self, v) +proc get_msHyphens*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msHyphens(self, p) +proc put_msHyphenateLimitZone*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msHyphenateLimitZone(self, v) +proc get_msHyphenateLimitZone*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msHyphenateLimitZone(self, p) +proc put_msHyphenateLimitChars*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msHyphenateLimitChars(self, v) +proc get_msHyphenateLimitChars*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msHyphenateLimitChars(self, p) +proc put_msHyphenateLimitLines*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msHyphenateLimitLines(self, v) +proc get_msHyphenateLimitLines*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msHyphenateLimitLines(self, p) +proc put_msHighContrastAdjust*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msHighContrastAdjust(self, v) +proc get_msHighContrastAdjust*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msHighContrastAdjust(self, p) +proc put_enableBackground*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_enableBackground(self, v) +proc get_enableBackground*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_enableBackground(self, p) +proc put_msFontFeatureSettings*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFontFeatureSettings(self, v) +proc get_msFontFeatureSettings*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFontFeatureSettings(self, p) +proc put_msUserSelect*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msUserSelect(self, v) +proc get_msUserSelect*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msUserSelect(self, p) +proc put_msOverflowStyle*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msOverflowStyle(self, v) +proc get_msOverflowStyle*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msOverflowStyle(self, p) +proc put_msTransformStyle*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransformStyle(self, v) +proc get_msTransformStyle*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransformStyle(self, p) +proc put_msBackfaceVisibility*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msBackfaceVisibility(self, v) +proc get_msBackfaceVisibility*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msBackfaceVisibility(self, p) +proc put_msPerspective*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPerspective(self, v) +proc get_msPerspective*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPerspective(self, p) +proc put_msPerspectiveOrigin*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPerspectiveOrigin(self, v) +proc get_msPerspectiveOrigin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPerspectiveOrigin(self, p) +proc put_msTransitionProperty*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransitionProperty(self, v) +proc get_msTransitionProperty*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransitionProperty(self, p) +proc put_msTransitionDuration*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransitionDuration(self, v) +proc get_msTransitionDuration*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransitionDuration(self, p) +proc put_msTransitionTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransitionTimingFunction(self, v) +proc get_msTransitionTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransitionTimingFunction(self, p) +proc put_msTransitionDelay*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransitionDelay(self, v) +proc get_msTransitionDelay*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransitionDelay(self, p) +proc put_msTransition*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTransition(self, v) +proc get_msTransition*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTransition(self, p) +proc put_msTouchAction*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTouchAction(self, v) +proc get_msTouchAction*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTouchAction(self, p) +proc put_msScrollTranslation*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msScrollTranslation(self, v) +proc get_msScrollTranslation*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msScrollTranslation(self, p) +proc put_msFlex*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlex(self, v) +proc get_msFlex*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlex(self, p) +proc put_msFlexPositive*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexPositive(self, v) +proc get_msFlexPositive*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexPositive(self, p) +proc put_msFlexNegative*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexNegative(self, v) +proc get_msFlexNegative*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexNegative(self, p) +proc put_msFlexPreferredSize*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexPreferredSize(self, v) +proc get_msFlexPreferredSize*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexPreferredSize(self, p) +proc put_msFlexFlow*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexFlow(self, v) +proc get_msFlexFlow*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexFlow(self, p) +proc put_msFlexDirection*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexDirection(self, v) +proc get_msFlexDirection*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexDirection(self, p) +proc put_msFlexWrap*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexWrap(self, v) +proc get_msFlexWrap*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexWrap(self, p) +proc put_msFlexAlign*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexAlign(self, v) +proc get_msFlexAlign*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexAlign(self, p) +proc put_msFlexItemAlign*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexItemAlign(self, v) +proc get_msFlexItemAlign*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexItemAlign(self, p) +proc put_msFlexPack*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexPack(self, v) +proc get_msFlexPack*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexPack(self, p) +proc put_msFlexLinePack*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexLinePack(self, v) +proc get_msFlexLinePack*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexLinePack(self, p) +proc put_msFlexOrder*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msFlexOrder(self, v) +proc get_msFlexOrder*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFlexOrder(self, p) +proc put_msTouchSelect*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msTouchSelect(self, v) +proc get_msTouchSelect*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msTouchSelect(self, p) +proc put_transform*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transform(self, v) +proc get_transform*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transform(self, p) +proc put_transformOrigin*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transformOrigin(self, v) +proc get_transformOrigin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transformOrigin(self, p) +proc put_transformStyle*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transformStyle(self, v) +proc get_transformStyle*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transformStyle(self, p) +proc put_backfaceVisibility*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backfaceVisibility(self, v) +proc get_backfaceVisibility*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backfaceVisibility(self, p) +proc put_perspective*(self: ptr IHTMLCSSStyleDeclaration2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_perspective(self, v) +proc get_perspective*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_perspective(self, p) +proc put_perspectiveOrigin*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_perspectiveOrigin(self, v) +proc get_perspectiveOrigin*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_perspectiveOrigin(self, p) +proc put_transitionProperty*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transitionProperty(self, v) +proc get_transitionProperty*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transitionProperty(self, p) +proc put_transitionDuration*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transitionDuration(self, v) +proc get_transitionDuration*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transitionDuration(self, p) +proc put_transitionTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transitionTimingFunction(self, v) +proc get_transitionTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transitionTimingFunction(self, p) +proc put_transitionDelay*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transitionDelay(self, v) +proc get_transitionDelay*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transitionDelay(self, p) +proc put_transition*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_transition(self, v) +proc get_transition*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transition(self, p) +proc put_fontFeatureSettings*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontFeatureSettings(self, v) +proc get_fontFeatureSettings*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontFeatureSettings(self, p) +proc put_animationName*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationName(self, v) +proc get_animationName*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationName(self, p) +proc put_animationDuration*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationDuration(self, v) +proc get_animationDuration*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationDuration(self, p) +proc put_animationTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationTimingFunction(self, v) +proc get_animationTimingFunction*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationTimingFunction(self, p) +proc put_animationDelay*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationDelay(self, v) +proc get_animationDelay*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationDelay(self, p) +proc put_animationDirection*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationDirection(self, v) +proc get_animationDirection*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationDirection(self, p) +proc put_animationPlayState*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationPlayState(self, v) +proc get_animationPlayState*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationPlayState(self, p) +proc put_animationIterationCount*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationIterationCount(self, v) +proc get_animationIterationCount*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationIterationCount(self, p) +proc put_animation*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animation(self, v) +proc get_animation*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animation(self, p) +proc put_animationFillMode*(self: ptr IHTMLCSSStyleDeclaration2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animationFillMode(self, v) +proc get_animationFillMode*(self: ptr IHTMLCSSStyleDeclaration2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationFillMode(self, p) +proc msGetPropertyEnabled*(self: ptr IHTMLStyleEnabled, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msGetPropertyEnabled(self, name, p) +proc msPutPropertyEnabled*(self: ptr IHTMLStyleEnabled, name: BSTR, b: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msPutPropertyEnabled(self, name, b) +proc put_fontFamily*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontFamily(self, v) +proc get_fontFamily*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontFamily(self, p) +proc put_fontStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontStyle(self, v) +proc get_fontStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontStyle(self, p) +proc put_fontVariant*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontVariant(self, v) +proc get_fontVariant*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontVariant(self, p) +proc put_fontWeight*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontWeight(self, v) +proc get_fontWeight*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontWeight(self, p) +proc put_fontSize*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontSize(self, v) +proc get_fontSize*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSize(self, p) +proc put_font*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_font(self, v) +proc get_font*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_font(self, p) +proc put_color*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_background*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_backgroundColor*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundColor(self, v) +proc get_backgroundColor*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundColor(self, p) +proc put_backgroundImage*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundImage(self, v) +proc get_backgroundImage*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundImage(self, p) +proc put_backgroundRepeat*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundRepeat(self, v) +proc get_backgroundRepeat*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundRepeat(self, p) +proc put_backgroundAttachment*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundAttachment(self, v) +proc get_backgroundAttachment*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundAttachment(self, p) +proc put_backgroundPosition*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPosition(self, v) +proc get_backgroundPosition*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPosition(self, p) +proc put_backgroundPositionX*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionX(self, v) +proc get_backgroundPositionX*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionX(self, p) +proc put_backgroundPositionY*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionY(self, v) +proc get_backgroundPositionY*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionY(self, p) +proc put_wordSpacing*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordSpacing(self, v) +proc get_wordSpacing*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordSpacing(self, p) +proc put_letterSpacing*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_letterSpacing(self, v) +proc get_letterSpacing*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_letterSpacing(self, p) +proc put_textDecoration*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecoration(self, v) +proc get_textDecoration*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecoration(self, p) +proc put_textDecorationNone*(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationNone(self, v) +proc get_textDecorationNone*(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationNone(self, p) +proc put_textDecorationUnderline*(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationUnderline(self, v) +proc get_textDecorationUnderline*(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationUnderline(self, p) +proc put_textDecorationOverline*(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationOverline(self, v) +proc get_textDecorationOverline*(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationOverline(self, p) +proc put_textDecorationLineThrough*(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationLineThrough(self, v) +proc get_textDecorationLineThrough*(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationLineThrough(self, p) +proc put_textDecorationBlink*(self: ptr IHTMLStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationBlink(self, v) +proc get_textDecorationBlink*(self: ptr IHTMLStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationBlink(self, p) +proc put_verticalAlign*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_verticalAlign(self, v) +proc get_verticalAlign*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_verticalAlign(self, p) +proc put_textTransform*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textTransform(self, v) +proc get_textTransform*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textTransform(self, p) +proc put_textAlign*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlign(self, v) +proc get_textAlign*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlign(self, p) +proc put_textIndent*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textIndent(self, v) +proc get_textIndent*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textIndent(self, p) +proc put_lineHeight*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineHeight(self, v) +proc get_lineHeight*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineHeight(self, p) +proc put_marginTop*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginTop(self, v) +proc get_marginTop*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginTop(self, p) +proc put_marginRight*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginRight(self, v) +proc get_marginRight*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginRight(self, p) +proc put_marginBottom*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginBottom(self, v) +proc get_marginBottom*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginBottom(self, p) +proc put_marginLeft*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginLeft(self, v) +proc get_marginLeft*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginLeft(self, p) +proc put_margin*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_margin(self, v) +proc get_margin*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_margin(self, p) +proc put_paddingTop*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingTop(self, v) +proc get_paddingTop*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingTop(self, p) +proc put_paddingRight*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingRight(self, v) +proc get_paddingRight*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingRight(self, p) +proc put_paddingBottom*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingBottom(self, v) +proc get_paddingBottom*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingBottom(self, p) +proc put_paddingLeft*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingLeft(self, v) +proc get_paddingLeft*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingLeft(self, p) +proc put_padding*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_padding(self, v) +proc get_padding*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_padding(self, p) +proc put_border*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_borderTop*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTop(self, v) +proc get_borderTop*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTop(self, p) +proc put_borderRight*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRight(self, v) +proc get_borderRight*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRight(self, p) +proc put_borderBottom*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottom(self, v) +proc get_borderBottom*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottom(self, p) +proc put_borderLeft*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeft(self, v) +proc get_borderLeft*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeft(self, p) +proc put_borderColor*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderTopColor*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopColor(self, v) +proc get_borderTopColor*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopColor(self, p) +proc put_borderRightColor*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightColor(self, v) +proc get_borderRightColor*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightColor(self, p) +proc put_borderBottomColor*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomColor(self, v) +proc get_borderBottomColor*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomColor(self, p) +proc put_borderLeftColor*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftColor(self, v) +proc get_borderLeftColor*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftColor(self, p) +proc put_borderWidth*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderWidth(self, v) +proc get_borderWidth*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderWidth(self, p) +proc put_borderTopWidth*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopWidth(self, v) +proc get_borderTopWidth*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopWidth(self, p) +proc put_borderRightWidth*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightWidth(self, v) +proc get_borderRightWidth*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightWidth(self, p) +proc put_borderBottomWidth*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomWidth(self, v) +proc get_borderBottomWidth*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomWidth(self, p) +proc put_borderLeftWidth*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftWidth(self, v) +proc get_borderLeftWidth*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftWidth(self, p) +proc put_borderStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderStyle(self, v) +proc get_borderStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderStyle(self, p) +proc put_borderTopStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopStyle(self, v) +proc get_borderTopStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopStyle(self, p) +proc put_borderRightStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightStyle(self, v) +proc get_borderRightStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightStyle(self, p) +proc put_borderBottomStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomStyle(self, v) +proc get_borderBottomStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomStyle(self, p) +proc put_borderLeftStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftStyle(self, v) +proc get_borderLeftStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftStyle(self, p) +proc put_width*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_styleFloat*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_styleFloat(self, v) +proc get_styleFloat*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleFloat(self, p) +proc put_clear*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clear(self, v) +proc get_clear*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc put_display*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_display(self, v) +proc get_display*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_display(self, p) +proc put_visibility*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_visibility(self, v) +proc get_visibility*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_visibility(self, p) +proc put_listStyleType*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleType(self, v) +proc get_listStyleType*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleType(self, p) +proc put_listStylePosition*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStylePosition(self, v) +proc get_listStylePosition*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStylePosition(self, p) +proc put_listStyleImage*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleImage(self, v) +proc get_listStyleImage*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleImage(self, p) +proc put_listStyle*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyle(self, v) +proc get_listStyle*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyle(self, p) +proc put_whiteSpace*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_whiteSpace(self, v) +proc get_whiteSpace*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whiteSpace(self, p) +proc put_top*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_top(self, v) +proc get_top*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc put_left*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_left(self, v) +proc get_left*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_left(self, p) +proc get_position*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc put_zIndex*(self: ptr IHTMLStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zIndex(self, v) +proc get_zIndex*(self: ptr IHTMLStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zIndex(self, p) +proc put_overflow*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflow(self, v) +proc get_overflow*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflow(self, p) +proc put_pageBreakBefore*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakBefore(self, v) +proc get_pageBreakBefore*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakBefore(self, p) +proc put_pageBreakAfter*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakAfter(self, v) +proc get_pageBreakAfter*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakAfter(self, p) +proc put_cssText*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssText(self, v) +proc get_cssText*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssText(self, p) +proc put_pixelTop*(self: ptr IHTMLStyle, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelTop(self, v) +proc get_pixelTop*(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelTop(self, p) +proc put_pixelLeft*(self: ptr IHTMLStyle, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelLeft(self, v) +proc get_pixelLeft*(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelLeft(self, p) +proc put_pixelWidth*(self: ptr IHTMLStyle, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelWidth(self, v) +proc get_pixelWidth*(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelWidth(self, p) +proc put_pixelHeight*(self: ptr IHTMLStyle, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelHeight(self, v) +proc get_pixelHeight*(self: ptr IHTMLStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelHeight(self, p) +proc put_posTop*(self: ptr IHTMLStyle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posTop(self, v) +proc get_posTop*(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posTop(self, p) +proc put_posLeft*(self: ptr IHTMLStyle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posLeft(self, v) +proc get_posLeft*(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posLeft(self, p) +proc put_posWidth*(self: ptr IHTMLStyle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posWidth(self, v) +proc get_posWidth*(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posWidth(self, p) +proc put_posHeight*(self: ptr IHTMLStyle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posHeight(self, v) +proc get_posHeight*(self: ptr IHTMLStyle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posHeight(self, p) +proc put_cursor*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cursor(self, v) +proc get_cursor*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cursor(self, p) +proc put_clip*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clip(self, v) +proc get_clip*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clip(self, p) +proc put_filter*(self: ptr IHTMLStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_filter(self, v) +proc get_filter*(self: ptr IHTMLStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc setAttribute*(self: ptr IHTMLStyle, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, AttributeValue, lFlags) +proc getAttribute*(self: ptr IHTMLStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, lFlags, AttributeValue) +proc removeAttribute*(self: ptr IHTMLStyle, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName, lFlags, pfSuccess) +proc toString*(self: ptr IHTMLStyle, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc put_tableLayout*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tableLayout(self, v) +proc get_tableLayout*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tableLayout(self, p) +proc put_borderCollapse*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderCollapse(self, v) +proc get_borderCollapse*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderCollapse(self, p) +proc put_direction*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_direction(self, v) +proc get_direction*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc put_behavior*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_behavior(self, v) +proc get_behavior*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behavior(self, p) +proc setExpression*(self: ptr IHTMLStyle2, propname: BSTR, expression: BSTR, language: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setExpression(self, propname, expression, language) +proc getExpression*(self: ptr IHTMLStyle2, propname: BSTR, expression: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getExpression(self, propname, expression) +proc removeExpression*(self: ptr IHTMLStyle2, propname: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeExpression(self, propname, pfSuccess) +proc put_position*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_position(self, v) +proc get_position*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc put_unicodeBidi*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unicodeBidi(self, v) +proc get_unicodeBidi*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unicodeBidi(self, p) +proc put_bottom*(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bottom(self, v) +proc get_bottom*(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottom(self, p) +proc put_right*(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_right(self, v) +proc get_right*(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_right(self, p) +proc put_pixelBottom*(self: ptr IHTMLStyle2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelBottom(self, v) +proc get_pixelBottom*(self: ptr IHTMLStyle2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelBottom(self, p) +proc put_pixelRight*(self: ptr IHTMLStyle2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelRight(self, v) +proc get_pixelRight*(self: ptr IHTMLStyle2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelRight(self, p) +proc put_posBottom*(self: ptr IHTMLStyle2, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posBottom(self, v) +proc get_posBottom*(self: ptr IHTMLStyle2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posBottom(self, p) +proc put_posRight*(self: ptr IHTMLStyle2, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posRight(self, v) +proc get_posRight*(self: ptr IHTMLStyle2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posRight(self, p) +proc put_imeMode*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_imeMode(self, v) +proc get_imeMode*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeMode(self, p) +proc put_rubyAlign*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyAlign(self, v) +proc get_rubyAlign*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyAlign(self, p) +proc put_rubyPosition*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyPosition(self, v) +proc get_rubyPosition*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyPosition(self, p) +proc put_rubyOverhang*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyOverhang(self, v) +proc get_rubyOverhang*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyOverhang(self, p) +proc put_layoutGridChar*(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridChar(self, v) +proc get_layoutGridChar*(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridChar(self, p) +proc put_layoutGridLine*(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridLine(self, v) +proc get_layoutGridLine*(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridLine(self, p) +proc put_layoutGridMode*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridMode(self, v) +proc get_layoutGridMode*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridMode(self, p) +proc put_layoutGridType*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridType(self, v) +proc get_layoutGridType*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridType(self, p) +proc put_layoutGrid*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGrid(self, v) +proc get_layoutGrid*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGrid(self, p) +proc put_wordBreak*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordBreak(self, v) +proc get_wordBreak*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordBreak(self, p) +proc put_lineBreak*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineBreak(self, v) +proc get_lineBreak*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineBreak(self, p) +proc put_textJustify*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustify(self, v) +proc get_textJustify*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustify(self, p) +proc put_textJustifyTrim*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustifyTrim(self, v) +proc get_textJustifyTrim*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustifyTrim(self, p) +proc put_textKashida*(self: ptr IHTMLStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashida(self, v) +proc get_textKashida*(self: ptr IHTMLStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashida(self, p) +proc put_textAutospace*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAutospace(self, v) +proc get_textAutospace*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAutospace(self, p) +proc put_overflowX*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowX(self, v) +proc get_overflowX*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowX(self, p) +proc put_overflowY*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowY(self, v) +proc get_overflowY*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowY(self, p) +proc put_accelerator*(self: ptr IHTMLStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accelerator(self, v) +proc get_accelerator*(self: ptr IHTMLStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accelerator(self, p) +proc put_layoutFlow*(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutFlow(self, v) +proc get_layoutFlow*(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutFlow(self, p) +proc put_zoom*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zoom(self, v) +proc get_zoom*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoom(self, p) +proc put_wordWrap*(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordWrap(self, v) +proc get_wordWrap*(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordWrap(self, p) +proc put_textUnderlinePosition*(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textUnderlinePosition(self, v) +proc get_textUnderlinePosition*(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textUnderlinePosition(self, p) +proc put_scrollbarBaseColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarBaseColor(self, v) +proc get_scrollbarBaseColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarBaseColor(self, p) +proc put_scrollbarFaceColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarFaceColor(self, v) +proc get_scrollbarFaceColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarFaceColor(self, p) +proc put_scrollbar3dLightColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbar3dLightColor(self, v) +proc get_scrollbar3dLightColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbar3dLightColor(self, p) +proc put_scrollbarShadowColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarShadowColor(self, v) +proc get_scrollbarShadowColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarShadowColor(self, p) +proc put_scrollbarHighlightColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarHighlightColor(self, v) +proc get_scrollbarHighlightColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarHighlightColor(self, p) +proc put_scrollbarDarkShadowColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarDarkShadowColor(self, v) +proc get_scrollbarDarkShadowColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarDarkShadowColor(self, p) +proc put_scrollbarArrowColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarArrowColor(self, v) +proc get_scrollbarArrowColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarArrowColor(self, p) +proc put_scrollbarTrackColor*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarTrackColor(self, v) +proc get_scrollbarTrackColor*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarTrackColor(self, p) +proc put_writingMode*(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_writingMode(self, v) +proc get_writingMode*(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_writingMode(self, p) +proc put_textAlignLast*(self: ptr IHTMLStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlignLast(self, v) +proc get_textAlignLast*(self: ptr IHTMLStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlignLast(self, p) +proc put_textKashidaSpace*(self: ptr IHTMLStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashidaSpace(self, v) +proc get_textKashidaSpace*(self: ptr IHTMLStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashidaSpace(self, p) +proc put_textOverflow*(self: ptr IHTMLStyle4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textOverflow(self, v) +proc get_textOverflow*(self: ptr IHTMLStyle4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textOverflow(self, p) +proc put_minHeight*(self: ptr IHTMLStyle4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minHeight(self, v) +proc get_minHeight*(self: ptr IHTMLStyle4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minHeight(self, p) +proc put_msInterpolationMode*(self: ptr IHTMLStyle5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msInterpolationMode(self, v) +proc get_msInterpolationMode*(self: ptr IHTMLStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msInterpolationMode(self, p) +proc put_maxHeight*(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxHeight(self, v) +proc get_maxHeight*(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxHeight(self, p) +proc put_minWidth*(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minWidth(self, v) +proc get_minWidth*(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minWidth(self, p) +proc put_maxWidth*(self: ptr IHTMLStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxWidth(self, v) +proc get_maxWidth*(self: ptr IHTMLStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxWidth(self, p) +proc put_content*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_content(self, v) +proc get_content*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_content(self, p) +proc put_captionSide*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_captionSide(self, v) +proc get_captionSide*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_captionSide(self, p) +proc put_counterIncrement*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterIncrement(self, v) +proc get_counterIncrement*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterIncrement(self, p) +proc put_counterReset*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterReset(self, v) +proc get_counterReset*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterReset(self, p) +proc put_outline*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outline(self, v) +proc get_outline*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outline(self, p) +proc put_outlineWidth*(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineWidth(self, v) +proc get_outlineWidth*(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineWidth(self, p) +proc put_outlineStyle*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineStyle(self, v) +proc get_outlineStyle*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineStyle(self, p) +proc put_outlineColor*(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineColor(self, v) +proc get_outlineColor*(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineColor(self, p) +proc put_boxSizing*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_boxSizing(self, v) +proc get_boxSizing*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boxSizing(self, p) +proc put_borderSpacing*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderSpacing(self, v) +proc get_borderSpacing*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderSpacing(self, p) +proc put_orphans*(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_orphans(self, v) +proc get_orphans*(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orphans(self, p) +proc put_widows*(self: ptr IHTMLStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_widows(self, v) +proc get_widows*(self: ptr IHTMLStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_widows(self, p) +proc put_pageBreakInside*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakInside(self, v) +proc get_pageBreakInside*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakInside(self, p) +proc put_emptyCells*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_emptyCells(self, v) +proc get_emptyCells*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_emptyCells(self, p) +proc put_msBlockProgression*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msBlockProgression(self, v) +proc get_msBlockProgression*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msBlockProgression(self, p) +proc put_quotes*(self: ptr IHTMLStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_quotes(self, v) +proc get_quotes*(self: ptr IHTMLStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_quotes(self, p) +proc put_fontFamily*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontFamily(self, v) +proc get_fontFamily*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontFamily(self, p) +proc put_fontStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontStyle(self, v) +proc get_fontStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontStyle(self, p) +proc put_fontVariant*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontVariant(self, v) +proc get_fontVariant*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontVariant(self, p) +proc put_fontWeight*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontWeight(self, v) +proc get_fontWeight*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontWeight(self, p) +proc put_fontSize*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontSize(self, v) +proc get_fontSize*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSize(self, p) +proc put_font*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_font(self, v) +proc get_font*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_font(self, p) +proc put_color*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_background*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_backgroundColor*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundColor(self, v) +proc get_backgroundColor*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundColor(self, p) +proc put_backgroundImage*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundImage(self, v) +proc get_backgroundImage*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundImage(self, p) +proc put_backgroundRepeat*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundRepeat(self, v) +proc get_backgroundRepeat*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundRepeat(self, p) +proc put_backgroundAttachment*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundAttachment(self, v) +proc get_backgroundAttachment*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundAttachment(self, p) +proc put_backgroundPosition*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPosition(self, v) +proc get_backgroundPosition*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPosition(self, p) +proc put_backgroundPositionX*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionX(self, v) +proc get_backgroundPositionX*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionX(self, p) +proc put_backgroundPositionY*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_backgroundPositionY(self, v) +proc get_backgroundPositionY*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionY(self, p) +proc put_wordSpacing*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordSpacing(self, v) +proc get_wordSpacing*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordSpacing(self, p) +proc put_letterSpacing*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_letterSpacing(self, v) +proc get_letterSpacing*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_letterSpacing(self, p) +proc put_textDecoration*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecoration(self, v) +proc get_textDecoration*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecoration(self, p) +proc put_textDecorationNone*(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationNone(self, v) +proc get_textDecorationNone*(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationNone(self, p) +proc put_textDecorationUnderline*(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationUnderline(self, v) +proc get_textDecorationUnderline*(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationUnderline(self, p) +proc put_textDecorationOverline*(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationOverline(self, v) +proc get_textDecorationOverline*(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationOverline(self, p) +proc put_textDecorationLineThrough*(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationLineThrough(self, v) +proc get_textDecorationLineThrough*(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationLineThrough(self, p) +proc put_textDecorationBlink*(self: ptr IHTMLRuleStyle, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationBlink(self, v) +proc get_textDecorationBlink*(self: ptr IHTMLRuleStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationBlink(self, p) +proc put_verticalAlign*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_verticalAlign(self, v) +proc get_verticalAlign*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_verticalAlign(self, p) +proc put_textTransform*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textTransform(self, v) +proc get_textTransform*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textTransform(self, p) +proc put_textAlign*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlign(self, v) +proc get_textAlign*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlign(self, p) +proc put_textIndent*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textIndent(self, v) +proc get_textIndent*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textIndent(self, p) +proc put_lineHeight*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineHeight(self, v) +proc get_lineHeight*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineHeight(self, p) +proc put_marginTop*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginTop(self, v) +proc get_marginTop*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginTop(self, p) +proc put_marginRight*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginRight(self, v) +proc get_marginRight*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginRight(self, p) +proc put_marginBottom*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginBottom(self, v) +proc get_marginBottom*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginBottom(self, p) +proc put_marginLeft*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginLeft(self, v) +proc get_marginLeft*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginLeft(self, p) +proc put_margin*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_margin(self, v) +proc get_margin*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_margin(self, p) +proc put_paddingTop*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingTop(self, v) +proc get_paddingTop*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingTop(self, p) +proc put_paddingRight*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingRight(self, v) +proc get_paddingRight*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingRight(self, p) +proc put_paddingBottom*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingBottom(self, v) +proc get_paddingBottom*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingBottom(self, p) +proc put_paddingLeft*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_paddingLeft(self, v) +proc get_paddingLeft*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingLeft(self, p) +proc put_padding*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_padding(self, v) +proc get_padding*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_padding(self, p) +proc put_border*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_borderTop*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTop(self, v) +proc get_borderTop*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTop(self, p) +proc put_borderRight*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRight(self, v) +proc get_borderRight*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRight(self, p) +proc put_borderBottom*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottom(self, v) +proc get_borderBottom*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottom(self, p) +proc put_borderLeft*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeft(self, v) +proc get_borderLeft*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeft(self, p) +proc put_borderColor*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderTopColor*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopColor(self, v) +proc get_borderTopColor*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopColor(self, p) +proc put_borderRightColor*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightColor(self, v) +proc get_borderRightColor*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightColor(self, p) +proc put_borderBottomColor*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomColor(self, v) +proc get_borderBottomColor*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomColor(self, p) +proc put_borderLeftColor*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftColor(self, v) +proc get_borderLeftColor*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftColor(self, p) +proc put_borderWidth*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderWidth(self, v) +proc get_borderWidth*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderWidth(self, p) +proc put_borderTopWidth*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopWidth(self, v) +proc get_borderTopWidth*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopWidth(self, p) +proc put_borderRightWidth*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightWidth(self, v) +proc get_borderRightWidth*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightWidth(self, p) +proc put_borderBottomWidth*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomWidth(self, v) +proc get_borderBottomWidth*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomWidth(self, p) +proc put_borderLeftWidth*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftWidth(self, v) +proc get_borderLeftWidth*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftWidth(self, p) +proc put_borderStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderStyle(self, v) +proc get_borderStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderStyle(self, p) +proc put_borderTopStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderTopStyle(self, v) +proc get_borderTopStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopStyle(self, p) +proc put_borderRightStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderRightStyle(self, v) +proc get_borderRightStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightStyle(self, p) +proc put_borderBottomStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderBottomStyle(self, v) +proc get_borderBottomStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomStyle(self, p) +proc put_borderLeftStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderLeftStyle(self, v) +proc get_borderLeftStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftStyle(self, p) +proc put_width*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_styleFloat*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_styleFloat(self, v) +proc get_styleFloat*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleFloat(self, p) +proc put_clear*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clear(self, v) +proc get_clear*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc put_display*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_display(self, v) +proc get_display*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_display(self, p) +proc put_visibility*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_visibility(self, v) +proc get_visibility*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_visibility(self, p) +proc put_listStyleType*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleType(self, v) +proc get_listStyleType*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleType(self, p) +proc put_listStylePosition*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStylePosition(self, v) +proc get_listStylePosition*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStylePosition(self, p) +proc put_listStyleImage*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyleImage(self, v) +proc get_listStyleImage*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleImage(self, p) +proc put_listStyle*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_listStyle(self, v) +proc get_listStyle*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyle(self, p) +proc put_whiteSpace*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_whiteSpace(self, v) +proc get_whiteSpace*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whiteSpace(self, p) +proc put_top*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_top(self, v) +proc get_top*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc put_left*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_left(self, v) +proc get_left*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_left(self, p) +proc get_position*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc put_zIndex*(self: ptr IHTMLRuleStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zIndex(self, v) +proc get_zIndex*(self: ptr IHTMLRuleStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zIndex(self, p) +proc put_overflow*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflow(self, v) +proc get_overflow*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflow(self, p) +proc put_pageBreakBefore*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakBefore(self, v) +proc get_pageBreakBefore*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakBefore(self, p) +proc put_pageBreakAfter*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakAfter(self, v) +proc get_pageBreakAfter*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakAfter(self, p) +proc put_cssText*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssText(self, v) +proc get_cssText*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssText(self, p) +proc put_cursor*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cursor(self, v) +proc get_cursor*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cursor(self, p) +proc put_clip*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clip(self, v) +proc get_clip*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clip(self, p) +proc put_filter*(self: ptr IHTMLRuleStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_filter(self, v) +proc get_filter*(self: ptr IHTMLRuleStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc setAttribute*(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, AttributeValue, lFlags) +proc getAttribute*(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, lFlags, AttributeValue) +proc removeAttribute*(self: ptr IHTMLRuleStyle, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName, lFlags, pfSuccess) +proc put_tableLayout*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tableLayout(self, v) +proc get_tableLayout*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tableLayout(self, p) +proc put_borderCollapse*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderCollapse(self, v) +proc get_borderCollapse*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderCollapse(self, p) +proc put_direction*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_direction(self, v) +proc get_direction*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc put_behavior*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_behavior(self, v) +proc get_behavior*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behavior(self, p) +proc put_position*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_position(self, v) +proc get_position*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc put_unicodeBidi*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unicodeBidi(self, v) +proc get_unicodeBidi*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unicodeBidi(self, p) +proc put_bottom*(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bottom(self, v) +proc get_bottom*(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottom(self, p) +proc put_right*(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_right(self, v) +proc get_right*(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_right(self, p) +proc put_pixelBottom*(self: ptr IHTMLRuleStyle2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelBottom(self, v) +proc get_pixelBottom*(self: ptr IHTMLRuleStyle2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelBottom(self, p) +proc put_pixelRight*(self: ptr IHTMLRuleStyle2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelRight(self, v) +proc get_pixelRight*(self: ptr IHTMLRuleStyle2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelRight(self, p) +proc put_posBottom*(self: ptr IHTMLRuleStyle2, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posBottom(self, v) +proc get_posBottom*(self: ptr IHTMLRuleStyle2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posBottom(self, p) +proc put_posRight*(self: ptr IHTMLRuleStyle2, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_posRight(self, v) +proc get_posRight*(self: ptr IHTMLRuleStyle2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_posRight(self, p) +proc put_imeMode*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_imeMode(self, v) +proc get_imeMode*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeMode(self, p) +proc put_rubyAlign*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyAlign(self, v) +proc get_rubyAlign*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyAlign(self, p) +proc put_rubyPosition*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyPosition(self, v) +proc get_rubyPosition*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyPosition(self, p) +proc put_rubyOverhang*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rubyOverhang(self, v) +proc get_rubyOverhang*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyOverhang(self, p) +proc put_layoutGridChar*(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridChar(self, v) +proc get_layoutGridChar*(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridChar(self, p) +proc put_layoutGridLine*(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridLine(self, v) +proc get_layoutGridLine*(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridLine(self, p) +proc put_layoutGridMode*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridMode(self, v) +proc get_layoutGridMode*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridMode(self, p) +proc put_layoutGridType*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGridType(self, v) +proc get_layoutGridType*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridType(self, p) +proc put_layoutGrid*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutGrid(self, v) +proc get_layoutGrid*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGrid(self, p) +proc put_textAutospace*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAutospace(self, v) +proc get_textAutospace*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAutospace(self, p) +proc put_wordBreak*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordBreak(self, v) +proc get_wordBreak*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordBreak(self, p) +proc put_lineBreak*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineBreak(self, v) +proc get_lineBreak*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineBreak(self, p) +proc put_textJustify*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustify(self, v) +proc get_textJustify*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustify(self, p) +proc put_textJustifyTrim*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textJustifyTrim(self, v) +proc get_textJustifyTrim*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustifyTrim(self, p) +proc put_textKashida*(self: ptr IHTMLRuleStyle2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashida(self, v) +proc get_textKashida*(self: ptr IHTMLRuleStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashida(self, p) +proc put_overflowX*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowX(self, v) +proc get_overflowX*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowX(self, p) +proc put_overflowY*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_overflowY(self, v) +proc get_overflowY*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowY(self, p) +proc put_accelerator*(self: ptr IHTMLRuleStyle2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accelerator(self, v) +proc get_accelerator*(self: ptr IHTMLRuleStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accelerator(self, p) +proc put_layoutFlow*(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_layoutFlow(self, v) +proc get_layoutFlow*(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutFlow(self, p) +proc put_zoom*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_zoom(self, v) +proc get_zoom*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoom(self, p) +proc put_wordWrap*(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wordWrap(self, v) +proc get_wordWrap*(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordWrap(self, p) +proc put_textUnderlinePosition*(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textUnderlinePosition(self, v) +proc get_textUnderlinePosition*(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textUnderlinePosition(self, p) +proc put_scrollbarBaseColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarBaseColor(self, v) +proc get_scrollbarBaseColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarBaseColor(self, p) +proc put_scrollbarFaceColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarFaceColor(self, v) +proc get_scrollbarFaceColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarFaceColor(self, p) +proc put_scrollbar3dLightColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbar3dLightColor(self, v) +proc get_scrollbar3dLightColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbar3dLightColor(self, p) +proc put_scrollbarShadowColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarShadowColor(self, v) +proc get_scrollbarShadowColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarShadowColor(self, p) +proc put_scrollbarHighlightColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarHighlightColor(self, v) +proc get_scrollbarHighlightColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarHighlightColor(self, p) +proc put_scrollbarDarkShadowColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarDarkShadowColor(self, v) +proc get_scrollbarDarkShadowColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarDarkShadowColor(self, p) +proc put_scrollbarArrowColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarArrowColor(self, v) +proc get_scrollbarArrowColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarArrowColor(self, p) +proc put_scrollbarTrackColor*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbarTrackColor(self, v) +proc get_scrollbarTrackColor*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarTrackColor(self, p) +proc put_writingMode*(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_writingMode(self, v) +proc get_writingMode*(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_writingMode(self, p) +proc put_textAlignLast*(self: ptr IHTMLRuleStyle3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlignLast(self, v) +proc get_textAlignLast*(self: ptr IHTMLRuleStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlignLast(self, p) +proc put_textKashidaSpace*(self: ptr IHTMLRuleStyle3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textKashidaSpace(self, v) +proc get_textKashidaSpace*(self: ptr IHTMLRuleStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashidaSpace(self, p) +proc put_textOverflow*(self: ptr IHTMLRuleStyle4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textOverflow(self, v) +proc get_textOverflow*(self: ptr IHTMLRuleStyle4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textOverflow(self, p) +proc put_minHeight*(self: ptr IHTMLRuleStyle4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minHeight(self, v) +proc get_minHeight*(self: ptr IHTMLRuleStyle4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minHeight(self, p) +proc put_msInterpolationMode*(self: ptr IHTMLRuleStyle5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msInterpolationMode(self, v) +proc get_msInterpolationMode*(self: ptr IHTMLRuleStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msInterpolationMode(self, p) +proc put_maxHeight*(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxHeight(self, v) +proc get_maxHeight*(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxHeight(self, p) +proc put_minWidth*(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minWidth(self, v) +proc get_minWidth*(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minWidth(self, p) +proc put_maxWidth*(self: ptr IHTMLRuleStyle5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxWidth(self, v) +proc get_maxWidth*(self: ptr IHTMLRuleStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxWidth(self, p) +proc put_content*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_content(self, v) +proc get_content*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_content(self, p) +proc put_captionSide*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_captionSide(self, v) +proc get_captionSide*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_captionSide(self, p) +proc put_counterIncrement*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterIncrement(self, v) +proc get_counterIncrement*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterIncrement(self, p) +proc put_counterReset*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_counterReset(self, v) +proc get_counterReset*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_counterReset(self, p) +proc put_outline*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outline(self, v) +proc get_outline*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outline(self, p) +proc put_outlineWidth*(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineWidth(self, v) +proc get_outlineWidth*(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineWidth(self, p) +proc put_outlineStyle*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineStyle(self, v) +proc get_outlineStyle*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineStyle(self, p) +proc put_outlineColor*(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outlineColor(self, v) +proc get_outlineColor*(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineColor(self, p) +proc put_boxSizing*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_boxSizing(self, v) +proc get_boxSizing*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boxSizing(self, p) +proc put_borderSpacing*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderSpacing(self, v) +proc get_borderSpacing*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderSpacing(self, p) +proc put_orphans*(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_orphans(self, v) +proc get_orphans*(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orphans(self, p) +proc put_widows*(self: ptr IHTMLRuleStyle6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_widows(self, v) +proc get_widows*(self: ptr IHTMLRuleStyle6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_widows(self, p) +proc put_pageBreakInside*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageBreakInside(self, v) +proc get_pageBreakInside*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakInside(self, p) +proc put_emptyCells*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_emptyCells(self, v) +proc get_emptyCells*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_emptyCells(self, p) +proc put_msBlockProgression*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msBlockProgression(self, v) +proc get_msBlockProgression*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msBlockProgression(self, p) +proc put_quotes*(self: ptr IHTMLRuleStyle6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_quotes(self, v) +proc get_quotes*(self: ptr IHTMLRuleStyle6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_quotes(self, p) +proc get_type*(self: ptr IHTMLCSSRule, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_cssText*(self: ptr IHTMLCSSRule, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssText(self, v) +proc get_cssText*(self: ptr IHTMLCSSRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssText(self, p) +proc get_parentRule*(self: ptr IHTMLCSSRule, p: ptr ptr IHTMLCSSRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentRule(self, p) +proc get_parentStyleSheet*(self: ptr IHTMLCSSRule, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentStyleSheet(self, p) +proc get_href*(self: ptr IHTMLCSSImportRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_media*(self: ptr IHTMLCSSImportRule, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLCSSImportRule, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc get_styleSheet*(self: ptr IHTMLCSSImportRule, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleSheet(self, p) +proc put_media*(self: ptr IHTMLCSSMediaRule, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLCSSMediaRule, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc get_cssRules*(self: ptr IHTMLCSSMediaRule, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssRules(self, p) +proc insertRule*(self: ptr IHTMLCSSMediaRule, bstrRule: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRule(self, bstrRule, lIndex, plNewIndex) +proc deleteRule*(self: ptr IHTMLCSSMediaRule, lIndex: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRule(self, lIndex) +proc put_mediaText*(self: ptr IHTMLCSSMediaList, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_mediaText(self, v) +proc get_mediaText*(self: ptr IHTMLCSSMediaList, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mediaText(self, p) +proc get_length*(self: ptr IHTMLCSSMediaList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLCSSMediaList, index: LONG, pbstrMedium: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pbstrMedium) +proc appendMedium*(self: ptr IHTMLCSSMediaList, bstrMedium: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendMedium(self, bstrMedium) +proc deleteMedium*(self: ptr IHTMLCSSMediaList, bstrMedium: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteMedium(self, bstrMedium) +proc get_namespaceURI*(self: ptr IHTMLCSSNamespaceRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_namespaceURI(self, p) +proc get_prefix*(self: ptr IHTMLCSSNamespaceRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_prefix(self, p) +proc put_keyText*(self: ptr IHTMLMSCSSKeyframeRule, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_keyText(self, v) +proc get_keyText*(self: ptr IHTMLMSCSSKeyframeRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_keyText(self, p) +proc get_style*(self: ptr IHTMLMSCSSKeyframeRule, p: ptr ptr IHTMLRuleStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc put_name*(self: ptr IHTMLMSCSSKeyframesRule, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLMSCSSKeyframesRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_cssRules*(self: ptr IHTMLMSCSSKeyframesRule, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssRules(self, p) +proc appendRule*(self: ptr IHTMLMSCSSKeyframesRule, bstrRule: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendRule(self, bstrRule) +proc deleteRule*(self: ptr IHTMLMSCSSKeyframesRule, bstrKey: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRule(self, bstrKey) +proc findRule*(self: ptr IHTMLMSCSSKeyframesRule, bstrKey: BSTR, ppMSKeyframeRule: ptr ptr IHTMLMSCSSKeyframeRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.findRule(self, bstrKey, ppMSKeyframeRule) +proc put_textLineThroughStyle*(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textLineThroughStyle(self, v) +proc get_textLineThroughStyle*(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textLineThroughStyle(self, p) +proc put_textUnderlineStyle*(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textUnderlineStyle(self, v) +proc get_textUnderlineStyle*(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textUnderlineStyle(self, p) +proc put_textEffect*(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textEffect(self, v) +proc get_textEffect*(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textEffect(self, p) +proc put_textColor*(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textColor(self, v) +proc get_textColor*(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textColor(self, p) +proc put_textBackgroundColor*(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textBackgroundColor(self, v) +proc get_textBackgroundColor*(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textBackgroundColor(self, p) +proc put_textDecorationColor*(self: ptr IHTMLRenderStyle, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecorationColor(self, v) +proc get_textDecorationColor*(self: ptr IHTMLRenderStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecorationColor(self, p) +proc put_renderingPriority*(self: ptr IHTMLRenderStyle, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_renderingPriority(self, v) +proc get_renderingPriority*(self: ptr IHTMLRenderStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_renderingPriority(self, p) +proc put_defaultTextSelection*(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultTextSelection(self, v) +proc get_defaultTextSelection*(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultTextSelection(self, p) +proc put_textDecoration*(self: ptr IHTMLRenderStyle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textDecoration(self, v) +proc get_textDecoration*(self: ptr IHTMLRenderStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecoration(self, p) +proc get_position*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc get_styleFloat*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleFloat(self, p) +proc get_color*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc get_backgroundColor*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundColor(self, p) +proc get_fontFamily*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontFamily(self, p) +proc get_fontStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontStyle(self, p) +proc get_fontVariant*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontVariant(self, p) +proc get_fontWeight*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontWeight(self, p) +proc get_fontSize*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSize(self, p) +proc get_backgroundImage*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundImage(self, p) +proc get_backgroundPositionX*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionX(self, p) +proc get_backgroundPositionY*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundPositionY(self, p) +proc get_backgroundRepeat*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundRepeat(self, p) +proc get_borderLeftColor*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftColor(self, p) +proc get_borderTopColor*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopColor(self, p) +proc get_borderRightColor*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightColor(self, p) +proc get_borderBottomColor*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomColor(self, p) +proc get_borderTopStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopStyle(self, p) +proc get_borderRightStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightStyle(self, p) +proc get_borderBottomStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomStyle(self, p) +proc get_borderLeftStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftStyle(self, p) +proc get_borderTopWidth*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderTopWidth(self, p) +proc get_borderRightWidth*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderRightWidth(self, p) +proc get_borderBottomWidth*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderBottomWidth(self, p) +proc get_borderLeftWidth*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderLeftWidth(self, p) +proc get_left*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_left(self, p) +proc get_top*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc get_width*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_height*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_paddingLeft*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingLeft(self, p) +proc get_paddingTop*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingTop(self, p) +proc get_paddingRight*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingRight(self, p) +proc get_paddingBottom*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paddingBottom(self, p) +proc get_textAlign*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlign(self, p) +proc get_textDecoration*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDecoration(self, p) +proc get_display*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_display(self, p) +proc get_visibility*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_visibility(self, p) +proc get_zIndex*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zIndex(self, p) +proc get_letterSpacing*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_letterSpacing(self, p) +proc get_lineHeight*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineHeight(self, p) +proc get_textIndent*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textIndent(self, p) +proc get_verticalAlign*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_verticalAlign(self, p) +proc get_backgroundAttachment*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundAttachment(self, p) +proc get_marginTop*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginTop(self, p) +proc get_marginRight*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginRight(self, p) +proc get_marginBottom*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginBottom(self, p) +proc get_marginLeft*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginLeft(self, p) +proc get_clear*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc get_listStyleType*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleType(self, p) +proc get_listStylePosition*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStylePosition(self, p) +proc get_listStyleImage*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_listStyleImage(self, p) +proc get_clipTop*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipTop(self, p) +proc get_clipRight*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipRight(self, p) +proc get_clipBottom*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipBottom(self, p) +proc get_clipLeft*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipLeft(self, p) +proc get_overflow*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflow(self, p) +proc get_pageBreakBefore*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakBefore(self, p) +proc get_pageBreakAfter*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakAfter(self, p) +proc get_cursor*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cursor(self, p) +proc get_tableLayout*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tableLayout(self, p) +proc get_borderCollapse*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderCollapse(self, p) +proc get_direction*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc get_behavior*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behavior(self, p) +proc getAttribute*(self: ptr IHTMLCurrentStyle, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, lFlags, AttributeValue) +proc get_unicodeBidi*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unicodeBidi(self, p) +proc get_right*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_right(self, p) +proc get_bottom*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottom(self, p) +proc get_imeMode*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeMode(self, p) +proc get_rubyAlign*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyAlign(self, p) +proc get_rubyPosition*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyPosition(self, p) +proc get_rubyOverhang*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rubyOverhang(self, p) +proc get_textAutospace*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAutospace(self, p) +proc get_lineBreak*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineBreak(self, p) +proc get_wordBreak*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordBreak(self, p) +proc get_textJustify*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustify(self, p) +proc get_textJustifyTrim*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textJustifyTrim(self, p) +proc get_textKashida*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashida(self, p) +proc get_blockDirection*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_blockDirection(self, p) +proc get_layoutGridChar*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridChar(self, p) +proc get_layoutGridLine*(self: ptr IHTMLCurrentStyle, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridLine(self, p) +proc get_layoutGridMode*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridMode(self, p) +proc get_layoutGridType*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutGridType(self, p) +proc get_borderStyle*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderStyle(self, p) +proc get_borderColor*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc get_borderWidth*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderWidth(self, p) +proc get_padding*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_padding(self, p) +proc get_margin*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_margin(self, p) +proc get_accelerator*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accelerator(self, p) +proc get_overflowX*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowX(self, p) +proc get_overflowY*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overflowY(self, p) +proc get_textTransform*(self: ptr IHTMLCurrentStyle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textTransform(self, p) +proc get_layoutFlow*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layoutFlow(self, p) +proc get_wordWrap*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordWrap(self, p) +proc get_textUnderlinePosition*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textUnderlinePosition(self, p) +proc get_hasLayout*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hasLayout(self, p) +proc get_scrollbarBaseColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarBaseColor(self, p) +proc get_scrollbarFaceColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarFaceColor(self, p) +proc get_scrollbar3dLightColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbar3dLightColor(self, p) +proc get_scrollbarShadowColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarShadowColor(self, p) +proc get_scrollbarHighlightColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarHighlightColor(self, p) +proc get_scrollbarDarkShadowColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarDarkShadowColor(self, p) +proc get_scrollbarArrowColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarArrowColor(self, p) +proc get_scrollbarTrackColor*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbarTrackColor(self, p) +proc get_writingMode*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_writingMode(self, p) +proc get_zoom*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoom(self, p) +proc get_filter*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc get_textAlignLast*(self: ptr IHTMLCurrentStyle2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlignLast(self, p) +proc get_textKashidaSpace*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textKashidaSpace(self, p) +proc get_isBlock*(self: ptr IHTMLCurrentStyle2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isBlock(self, p) +proc get_textOverflow*(self: ptr IHTMLCurrentStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textOverflow(self, p) +proc get_minHeight*(self: ptr IHTMLCurrentStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minHeight(self, p) +proc get_wordSpacing*(self: ptr IHTMLCurrentStyle3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wordSpacing(self, p) +proc get_whiteSpace*(self: ptr IHTMLCurrentStyle3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whiteSpace(self, p) +proc get_msInterpolationMode*(self: ptr IHTMLCurrentStyle4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msInterpolationMode(self, p) +proc get_maxHeight*(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxHeight(self, p) +proc get_minWidth*(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minWidth(self, p) +proc get_maxWidth*(self: ptr IHTMLCurrentStyle4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxWidth(self, p) +proc get_captionSide*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_captionSide(self, p) +proc get_outline*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outline(self, p) +proc get_outlineWidth*(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineWidth(self, p) +proc get_outlineStyle*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineStyle(self, p) +proc get_outlineColor*(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outlineColor(self, p) +proc get_boxSizing*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boxSizing(self, p) +proc get_borderSpacing*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderSpacing(self, p) +proc get_orphans*(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orphans(self, p) +proc get_widows*(self: ptr IHTMLCurrentStyle5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_widows(self, p) +proc get_pageBreakInside*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageBreakInside(self, p) +proc get_emptyCells*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_emptyCells(self, p) +proc get_msBlockProgression*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msBlockProgression(self, p) +proc get_quotes*(self: ptr IHTMLCurrentStyle5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_quotes(self, p) +proc put_left*(self: ptr IHTMLRect, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_left(self, v) +proc get_left*(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_left(self, p) +proc put_top*(self: ptr IHTMLRect, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_top(self, v) +proc get_top*(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc put_right*(self: ptr IHTMLRect, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_right(self, v) +proc get_right*(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_right(self, p) +proc put_bottom*(self: ptr IHTMLRect, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bottom(self, v) +proc get_bottom*(self: ptr IHTMLRect, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottom(self, p) +proc get_width*(self: ptr IHTMLRect2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_height*(self: ptr IHTMLRect2, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_length*(self: ptr IHTMLRectCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLRectCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLRectCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, pvarIndex, pvarResult) +proc get_nodeType*(self: ptr IHTMLDOMNode, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeType(self, p) +proc get_parentNode*(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentNode(self, p) +proc hasChildNodes*(self: ptr IHTMLDOMNode, fChildren: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasChildNodes(self, fChildren) +proc get_childNodes*(self: ptr IHTMLDOMNode, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, p) +proc get_attributes*(self: ptr IHTMLDOMNode, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attributes(self, p) +proc insertBefore*(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertBefore(self, newChild, refChild, node) +proc removeChild*(self: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, oldChild, node) +proc replaceChild*(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceChild(self, newChild, oldChild, node) +proc cloneNode*(self: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, clonedNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.cloneNode(self, fDeep, clonedNode) +proc removeNode*(self: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, removed: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNode(self, fDeep, removed) +proc swapNode*(self: ptr IHTMLDOMNode, otherNode: ptr IHTMLDOMNode, swappedNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.swapNode(self, otherNode, swappedNode) +proc replaceNode*(self: ptr IHTMLDOMNode, replacement: ptr IHTMLDOMNode, replaced: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceNode(self, replacement, replaced) +proc appendChild*(self: ptr IHTMLDOMNode, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendChild(self, newChild, node) +proc get_nodeName*(self: ptr IHTMLDOMNode, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeName(self, p) +proc put_nodeValue*(self: ptr IHTMLDOMNode, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeValue(self, v) +proc get_nodeValue*(self: ptr IHTMLDOMNode, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeValue(self, p) +proc get_firstChild*(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstChild(self, p) +proc get_lastChild*(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastChild(self, p) +proc get_previousSibling*(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousSibling(self, p) +proc get_nextSibling*(self: ptr IHTMLDOMNode, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextSibling(self, p) +proc get_ownerDocument*(self: ptr IHTMLDOMNode2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerDocument(self, p) +proc put_prefix*(self: ptr IHTMLDOMNode3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_prefix(self, v) +proc get_prefix*(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_prefix(self, p) +proc get_localName*(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_localName(self, p) +proc get_namespaceURI*(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_namespaceURI(self, p) +proc put_textContent*(self: ptr IHTMLDOMNode3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textContent(self, v) +proc get_textContent*(self: ptr IHTMLDOMNode3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textContent(self, p) +proc isEqualNode*(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode3, isEqual: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isEqualNode(self, otherNode, isEqual) +proc lookupNamespaceURI*(self: ptr IHTMLDOMNode3, pvarPrefix: ptr VARIANT, pvarNamespaceURI: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.lookupNamespaceURI(self, pvarPrefix, pvarNamespaceURI) +proc lookupPrefix*(self: ptr IHTMLDOMNode3, pvarNamespaceURI: ptr VARIANT, pvarPrefix: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.lookupPrefix(self, pvarNamespaceURI, pvarPrefix) +proc isDefaultNamespace*(self: ptr IHTMLDOMNode3, pvarNamespace: ptr VARIANT, pfDefaultNamespace: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isDefaultNamespace(self, pvarNamespace, pfDefaultNamespace) +proc appendChild*(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendChild(self, newChild, node) +proc insertBefore*(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertBefore(self, newChild, refChild, node) +proc removeChild*(self: ptr IHTMLDOMNode3, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, oldChild, node) +proc replaceChild*(self: ptr IHTMLDOMNode3, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceChild(self, newChild, oldChild, node) +proc isSameNode*(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode3, isSame: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isSameNode(self, otherNode, isSame) +proc compareDocumentPosition*(self: ptr IHTMLDOMNode3, otherNode: ptr IHTMLDOMNode, flags: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.compareDocumentPosition(self, otherNode, flags) +proc isSupported*(self: ptr IHTMLDOMNode3, feature: BSTR, version: VARIANT, pfisSupported: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isSupported(self, feature, version, pfisSupported) +proc get_nodeName*(self: ptr IHTMLDOMAttribute, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeName(self, p) +proc put_nodeValue*(self: ptr IHTMLDOMAttribute, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeValue(self, v) +proc get_nodeValue*(self: ptr IHTMLDOMAttribute, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeValue(self, p) +proc get_specified*(self: ptr IHTMLDOMAttribute, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_specified(self, p) +proc get_name*(self: ptr IHTMLDOMAttribute2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_value*(self: ptr IHTMLDOMAttribute2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLDOMAttribute2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc get_expando*(self: ptr IHTMLDOMAttribute2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_expando(self, p) +proc get_nodeType*(self: ptr IHTMLDOMAttribute2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeType(self, p) +proc get_parentNode*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentNode(self, p) +proc get_childNodes*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, p) +proc get_firstChild*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstChild(self, p) +proc get_lastChild*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastChild(self, p) +proc get_previousSibling*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousSibling(self, p) +proc get_nextSibling*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextSibling(self, p) +proc get_attributes*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attributes(self, p) +proc get_ownerDocument*(self: ptr IHTMLDOMAttribute2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerDocument(self, p) +proc insertBefore*(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, refChild: VARIANT, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertBefore(self, newChild, refChild, node) +proc replaceChild*(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceChild(self, newChild, oldChild, node) +proc removeChild*(self: ptr IHTMLDOMAttribute2, oldChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, oldChild, node) +proc appendChild*(self: ptr IHTMLDOMAttribute2, newChild: ptr IHTMLDOMNode, node: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendChild(self, newChild, node) +proc hasChildNodes*(self: ptr IHTMLDOMAttribute2, fChildren: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasChildNodes(self, fChildren) +proc cloneNode*(self: ptr IHTMLDOMAttribute2, fDeep: VARIANT_BOOL, clonedNode: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.cloneNode(self, fDeep, clonedNode) +proc put_nodeValue*(self: ptr IHTMLDOMAttribute3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeValue(self, v) +proc get_nodeValue*(self: ptr IHTMLDOMAttribute3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeValue(self, p) +proc put_value*(self: ptr IHTMLDOMAttribute3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLDOMAttribute3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc get_specified*(self: ptr IHTMLDOMAttribute3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_specified(self, p) +proc get_ownerElement*(self: ptr IHTMLDOMAttribute3, p: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerElement(self, p) +proc put_nodeValue*(self: ptr IHTMLDOMAttribute4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeValue(self, v) +proc get_nodeValue*(self: ptr IHTMLDOMAttribute4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeValue(self, p) +proc get_nodeName*(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeName(self, p) +proc get_name*(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_value*(self: ptr IHTMLDOMAttribute4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLDOMAttribute4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc get_firstChild*(self: ptr IHTMLDOMAttribute4, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstChild(self, p) +proc get_lastChild*(self: ptr IHTMLDOMAttribute4, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastChild(self, p) +proc get_childNodes*(self: ptr IHTMLDOMAttribute4, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, p) +proc hasAttributes*(self: ptr IHTMLDOMAttribute4, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributes(self, pfHasAttributes) +proc hasChildNodes*(self: ptr IHTMLDOMAttribute4, fChildren: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasChildNodes(self, fChildren) +proc normalize*(self: ptr IHTMLDOMAttribute4): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.normalize(self) +proc get_specified*(self: ptr IHTMLDOMAttribute4, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_specified(self, p) +proc put_data*(self: ptr IHTMLDOMTextNode, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IHTMLDOMTextNode, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc toString*(self: ptr IHTMLDOMTextNode, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc get_length*(self: ptr IHTMLDOMTextNode, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc splitText*(self: ptr IHTMLDOMTextNode, offset: LONG, pRetNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.splitText(self, offset, pRetNode) +proc substringData*(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.substringData(self, offset, Count, pbstrsubString) +proc appendData*(self: ptr IHTMLDOMTextNode2, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendData(self, bstrstring) +proc insertData*(self: ptr IHTMLDOMTextNode2, offset: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertData(self, offset, bstrstring) +proc deleteData*(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteData(self, offset, Count) +proc replaceData*(self: ptr IHTMLDOMTextNode2, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceData(self, offset, Count, bstrstring) +proc substringData*(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.substringData(self, offset, Count, pbstrsubString) +proc insertData*(self: ptr IHTMLDOMTextNode3, offset: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertData(self, offset, bstrstring) +proc deleteData*(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteData(self, offset, Count) +proc replaceData*(self: ptr IHTMLDOMTextNode3, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceData(self, offset, Count, bstrstring) +proc splitText*(self: ptr IHTMLDOMTextNode3, offset: LONG, pRetNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.splitText(self, offset, pRetNode) +proc get_wholeText*(self: ptr IHTMLDOMTextNode3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wholeText(self, p) +proc replaceWholeText*(self: ptr IHTMLDOMTextNode3, bstrText: BSTR, ppRetNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceWholeText(self, bstrText, ppRetNode) +proc hasAttributes*(self: ptr IHTMLDOMTextNode3, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributes(self, pfHasAttributes) +proc normalize*(self: ptr IHTMLDOMTextNode3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.normalize(self) +proc hasFeature*(self: ptr IHTMLDOMImplementation, bstrfeature: BSTR, version: VARIANT, pfHasFeature: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasFeature(self, bstrfeature, version, pfHasFeature) +proc createDocumentType*(self: ptr IHTMLDOMImplementation2, bstrQualifiedName: BSTR, pvarPublicId: ptr VARIANT, pvarSystemId: ptr VARIANT, newDocumentType: ptr ptr IDOMDocumentType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createDocumentType(self, bstrQualifiedName, pvarPublicId, pvarSystemId, newDocumentType) +proc createDocument*(self: ptr IHTMLDOMImplementation2, pvarNS: ptr VARIANT, pvarTagName: ptr VARIANT, pDocumentType: ptr IDOMDocumentType, ppnewDocument: ptr ptr IHTMLDocument7): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createDocument(self, pvarNS, pvarTagName, pDocumentType, ppnewDocument) +proc createHTMLDocument*(self: ptr IHTMLDOMImplementation2, bstrTitle: BSTR, ppnewDocument: ptr ptr IHTMLDocument7): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createHTMLDocument(self, bstrTitle, ppnewDocument) +proc hasFeature*(self: ptr IHTMLDOMImplementation2, bstrfeature: BSTR, version: VARIANT, pfHasFeature: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasFeature(self, bstrfeature, version, pfHasFeature) +proc get_length*(self: ptr IHTMLAttributeCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLAttributeCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLAttributeCollection, name: ptr VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, name, pdisp) +proc getNamedItem*(self: ptr IHTMLAttributeCollection2, bstrName: BSTR, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNamedItem(self, bstrName, newretNode) +proc setNamedItem*(self: ptr IHTMLAttributeCollection2, ppNode: ptr IHTMLDOMAttribute, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setNamedItem(self, ppNode, newretNode) +proc removeNamedItem*(self: ptr IHTMLAttributeCollection2, bstrName: BSTR, newretNode: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNamedItem(self, bstrName, newretNode) +proc getNamedItem*(self: ptr IHTMLAttributeCollection3, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNamedItem(self, bstrName, ppNodeOut) +proc setNamedItem*(self: ptr IHTMLAttributeCollection3, pNodeIn: ptr IHTMLDOMAttribute, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setNamedItem(self, pNodeIn, ppNodeOut) +proc removeNamedItem*(self: ptr IHTMLAttributeCollection3, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNamedItem(self, bstrName, ppNodeOut) +proc item*(self: ptr IHTMLAttributeCollection3, index: LONG, ppNodeOut: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppNodeOut) +proc get_length*(self: ptr IHTMLAttributeCollection3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc getNamedItemNS*(self: ptr IHTMLAttributeCollection4, pvarNS: ptr VARIANT, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNamedItemNS(self, pvarNS, bstrName, ppNodeOut) +proc setNamedItemNS*(self: ptr IHTMLAttributeCollection4, pNodeIn: ptr IHTMLDOMAttribute2, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setNamedItemNS(self, pNodeIn, ppNodeOut) +proc removeNamedItemNS*(self: ptr IHTMLAttributeCollection4, pvarNS: ptr VARIANT, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNamedItemNS(self, pvarNS, bstrName, ppNodeOut) +proc getNamedItem*(self: ptr IHTMLAttributeCollection4, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNamedItem(self, bstrName, ppNodeOut) +proc setNamedItem*(self: ptr IHTMLAttributeCollection4, pNodeIn: ptr IHTMLDOMAttribute2, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setNamedItem(self, pNodeIn, ppNodeOut) +proc removeNamedItem*(self: ptr IHTMLAttributeCollection4, bstrName: BSTR, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNamedItem(self, bstrName, ppNodeOut) +proc item*(self: ptr IHTMLAttributeCollection4, index: LONG, ppNodeOut: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppNodeOut) +proc get_length*(self: ptr IHTMLAttributeCollection4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_length*(self: ptr IHTMLDOMChildrenCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLDOMChildrenCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLDOMChildrenCollection, index: LONG, ppItem: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppItem) +proc item*(self: ptr IHTMLDOMChildrenCollection2, index: LONG, ppItem: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppItem) +proc setAttribute*(self: ptr IHTMLElement, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, AttributeValue, lFlags) +proc getAttribute*(self: ptr IHTMLElement, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, lFlags, AttributeValue) +proc removeAttribute*(self: ptr IHTMLElement, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName, lFlags, pfSuccess) +proc put_className*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_className(self, v) +proc get_className*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_className(self, p) +proc put_id*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_id(self, v) +proc get_id*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_id(self, p) +proc get_tagName*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagName(self, p) +proc get_parentElement*(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentElement(self, p) +proc get_style*(self: ptr IHTMLElement, p: ptr ptr IHTMLStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc put_onhelp*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhelp(self, v) +proc get_onhelp*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhelp(self, p) +proc put_onclick*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onclick(self, v) +proc get_onclick*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onclick(self, p) +proc put_ondblclick*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondblclick(self, v) +proc get_ondblclick*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondblclick(self, p) +proc put_onkeydown*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeydown(self, v) +proc get_onkeydown*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeydown(self, p) +proc put_onkeyup*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeyup(self, v) +proc get_onkeyup*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeyup(self, p) +proc put_onkeypress*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeypress(self, v) +proc get_onkeypress*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeypress(self, p) +proc put_onmouseout*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseout(self, v) +proc get_onmouseout*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseout(self, p) +proc put_onmouseover*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseover(self, v) +proc get_onmouseover*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseover(self, p) +proc put_onmousemove*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousemove(self, v) +proc get_onmousemove*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousemove(self, p) +proc put_onmousedown*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousedown(self, v) +proc get_onmousedown*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousedown(self, p) +proc put_onmouseup*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseup(self, v) +proc get_onmouseup*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseup(self, p) +proc get_document*(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc put_title*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_title(self, v) +proc get_title*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_title(self, p) +proc put_language*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_language(self, v) +proc get_language*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_language(self, p) +proc put_onselectstart*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselectstart(self, v) +proc get_onselectstart*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselectstart(self, p) +proc scrollIntoView*(self: ptr IHTMLElement, varargStart: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scrollIntoView(self, varargStart) +proc contains*(self: ptr IHTMLElement, pChild: ptr IHTMLElement, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.contains(self, pChild, pfResult) +proc get_sourceIndex*(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sourceIndex(self, p) +proc get_recordNumber*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_recordNumber(self, p) +proc put_lang*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lang(self, v) +proc get_lang*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lang(self, p) +proc get_offsetLeft*(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetLeft(self, p) +proc get_offsetTop*(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetTop(self, p) +proc get_offsetWidth*(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetWidth(self, p) +proc get_offsetHeight*(self: ptr IHTMLElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetHeight(self, p) +proc get_offsetParent*(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetParent(self, p) +proc put_innerHTML*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_innerHTML(self, v) +proc get_innerHTML*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_innerHTML(self, p) +proc put_innerText*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_innerText(self, v) +proc get_innerText*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_innerText(self, p) +proc put_outerHTML*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outerHTML(self, v) +proc get_outerHTML*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outerHTML(self, p) +proc put_outerText*(self: ptr IHTMLElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_outerText(self, v) +proc get_outerText*(self: ptr IHTMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outerText(self, p) +proc insertAdjacentHTML*(self: ptr IHTMLElement, where: BSTR, html: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertAdjacentHTML(self, where, html) +proc insertAdjacentText*(self: ptr IHTMLElement, where: BSTR, text: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertAdjacentText(self, where, text) +proc get_parentTextEdit*(self: ptr IHTMLElement, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentTextEdit(self, p) +proc get_isTextEdit*(self: ptr IHTMLElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isTextEdit(self, p) +proc click*(self: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.click(self) +proc get_filters*(self: ptr IHTMLElement, p: ptr ptr IHTMLFiltersCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filters(self, p) +proc put_ondragstart*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragstart(self, v) +proc get_ondragstart*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragstart(self, p) +proc toString*(self: ptr IHTMLElement, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc put_onbeforeupdate*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeupdate(self, v) +proc get_onbeforeupdate*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeupdate(self, p) +proc put_onafterupdate*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onafterupdate(self, v) +proc get_onafterupdate*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onafterupdate(self, p) +proc put_onerrorupdate*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerrorupdate(self, v) +proc get_onerrorupdate*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerrorupdate(self, p) +proc put_onrowexit*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowexit(self, v) +proc get_onrowexit*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowexit(self, p) +proc put_onrowenter*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowenter(self, v) +proc get_onrowenter*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowenter(self, p) +proc put_ondatasetchanged*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondatasetchanged(self, v) +proc get_ondatasetchanged*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondatasetchanged(self, p) +proc put_ondataavailable*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondataavailable(self, v) +proc get_ondataavailable*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondataavailable(self, p) +proc put_ondatasetcomplete*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondatasetcomplete(self, v) +proc get_ondatasetcomplete*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondatasetcomplete(self, p) +proc put_onfilterchange*(self: ptr IHTMLElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfilterchange(self, v) +proc get_onfilterchange*(self: ptr IHTMLElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfilterchange(self, p) +proc get_children*(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_children(self, p) +proc get_all*(self: ptr IHTMLElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_all(self, p) +proc get_scopeName*(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scopeName(self, p) +proc setCapture*(self: ptr IHTMLElement2, containerCapture: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setCapture(self, containerCapture) +proc releaseCapture*(self: ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.releaseCapture(self) +proc put_onlosecapture*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onlosecapture(self, v) +proc get_onlosecapture*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onlosecapture(self, p) +proc componentFromPoint*(self: ptr IHTMLElement2, x: LONG, y: LONG, component: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.componentFromPoint(self, x, y, component) +proc doScroll*(self: ptr IHTMLElement2, component: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doScroll(self, component) +proc put_onscroll*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onscroll(self, v) +proc get_onscroll*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onscroll(self, p) +proc put_ondrag*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrag(self, v) +proc get_ondrag*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrag(self, p) +proc put_ondragend*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragend(self, v) +proc get_ondragend*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragend(self, p) +proc put_ondragenter*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragenter(self, v) +proc get_ondragenter*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragenter(self, p) +proc put_ondragover*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragover(self, v) +proc get_ondragover*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragover(self, p) +proc put_ondragleave*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragleave(self, v) +proc get_ondragleave*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragleave(self, p) +proc put_ondrop*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrop(self, v) +proc get_ondrop*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrop(self, p) +proc put_onbeforecut*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforecut(self, v) +proc get_onbeforecut*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforecut(self, p) +proc put_oncut*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncut(self, v) +proc get_oncut*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncut(self, p) +proc put_onbeforecopy*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforecopy(self, v) +proc get_onbeforecopy*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforecopy(self, p) +proc put_oncopy*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncopy(self, v) +proc get_oncopy*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncopy(self, p) +proc put_onbeforepaste*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforepaste(self, v) +proc get_onbeforepaste*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforepaste(self, p) +proc put_onpaste*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpaste(self, v) +proc get_onpaste*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpaste(self, p) +proc get_currentStyle*(self: ptr IHTMLElement2, p: ptr ptr IHTMLCurrentStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentStyle(self, p) +proc put_onpropertychange*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpropertychange(self, v) +proc get_onpropertychange*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpropertychange(self, p) +proc getClientRects*(self: ptr IHTMLElement2, pRectCol: ptr ptr IHTMLRectCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getClientRects(self, pRectCol) +proc getBoundingClientRect*(self: ptr IHTMLElement2, pRect: ptr ptr IHTMLRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getBoundingClientRect(self, pRect) +proc setExpression*(self: ptr IHTMLElement2, propname: BSTR, expression: BSTR, language: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setExpression(self, propname, expression, language) +proc getExpression*(self: ptr IHTMLElement2, propname: BSTR, expression: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getExpression(self, propname, expression) +proc removeExpression*(self: ptr IHTMLElement2, propname: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeExpression(self, propname, pfSuccess) +proc put_tabIndex*(self: ptr IHTMLElement2, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tabIndex(self, v) +proc get_tabIndex*(self: ptr IHTMLElement2, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tabIndex(self, p) +proc focus*(self: ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc put_accessKey*(self: ptr IHTMLElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accessKey(self, v) +proc get_accessKey*(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accessKey(self, p) +proc put_onblur*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_onfocus*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_onresize*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onresize(self, v) +proc get_onresize*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onresize(self, p) +proc blur*(self: ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.blur(self) +proc addFilter*(self: ptr IHTMLElement2, pUnk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addFilter(self, pUnk) +proc removeFilter*(self: ptr IHTMLElement2, pUnk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeFilter(self, pUnk) +proc get_clientHeight*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientHeight(self, p) +proc get_clientWidth*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientWidth(self, p) +proc get_clientTop*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientTop(self, p) +proc get_clientLeft*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientLeft(self, p) +proc attachEvent*(self: ptr IHTMLElement2, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.attachEvent(self, event, pDisp, pfResult) +proc detachEvent*(self: ptr IHTMLElement2, event: BSTR, pDisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detachEvent(self, event, pDisp) +proc get_readyState*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onrowsdelete*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowsdelete(self, v) +proc get_onrowsdelete*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowsdelete(self, p) +proc put_onrowsinserted*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowsinserted(self, v) +proc get_onrowsinserted*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowsinserted(self, p) +proc put_oncellchange*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncellchange(self, v) +proc get_oncellchange*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncellchange(self, p) +proc put_dir*(self: ptr IHTMLElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dir(self, v) +proc get_dir*(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dir(self, p) +proc createControlRange*(self: ptr IHTMLElement2, range: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createControlRange(self, range) +proc get_scrollHeight*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollHeight(self, p) +proc get_scrollWidth*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollWidth(self, p) +proc put_scrollTop*(self: ptr IHTMLElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollTop(self, v) +proc get_scrollTop*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollTop(self, p) +proc put_scrollLeft*(self: ptr IHTMLElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollLeft(self, v) +proc get_scrollLeft*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollLeft(self, p) +proc clearAttributes*(self: ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearAttributes(self) +proc mergeAttributes*(self: ptr IHTMLElement2, mergeThis: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.mergeAttributes(self, mergeThis) +proc put_oncontextmenu*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncontextmenu(self, v) +proc get_oncontextmenu*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncontextmenu(self, p) +proc insertAdjacentElement*(self: ptr IHTMLElement2, where: BSTR, insertedElement: ptr IHTMLElement, inserted: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertAdjacentElement(self, where, insertedElement, inserted) +proc applyElement*(self: ptr IHTMLElement2, apply: ptr IHTMLElement, where: BSTR, applied: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.applyElement(self, apply, where, applied) +proc getAdjacentText*(self: ptr IHTMLElement2, where: BSTR, text: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAdjacentText(self, where, text) +proc replaceAdjacentText*(self: ptr IHTMLElement2, where: BSTR, newText: BSTR, oldText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceAdjacentText(self, where, newText, oldText) +proc get_canHaveChildren*(self: ptr IHTMLElement2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_canHaveChildren(self, p) +proc addBehavior*(self: ptr IHTMLElement2, bstrUrl: BSTR, pvarFactory: ptr VARIANT, pCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addBehavior(self, bstrUrl, pvarFactory, pCookie) +proc removeBehavior*(self: ptr IHTMLElement2, cookie: LONG, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeBehavior(self, cookie, pfResult) +proc get_runtimeStyle*(self: ptr IHTMLElement2, p: ptr ptr IHTMLStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_runtimeStyle(self, p) +proc get_behaviorUrns*(self: ptr IHTMLElement2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behaviorUrns(self, p) +proc put_tagUrn*(self: ptr IHTMLElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tagUrn(self, v) +proc get_tagUrn*(self: ptr IHTMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagUrn(self, p) +proc put_onbeforeeditfocus*(self: ptr IHTMLElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeeditfocus(self, v) +proc get_onbeforeeditfocus*(self: ptr IHTMLElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeeditfocus(self, p) +proc get_readyStateValue*(self: ptr IHTMLElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyStateValue(self, p) +proc getElementsByTagName*(self: ptr IHTMLElement2, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagName(self, v, pelColl) +proc mergeAttributes*(self: ptr IHTMLElement3, mergeThis: ptr IHTMLElement, pvarFlags: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.mergeAttributes(self, mergeThis, pvarFlags) +proc get_isMultiLine*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isMultiLine(self, p) +proc get_canHaveHTML*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_canHaveHTML(self, p) +proc put_onlayoutcomplete*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onlayoutcomplete(self, v) +proc get_onlayoutcomplete*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onlayoutcomplete(self, p) +proc put_onpage*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpage(self, v) +proc get_onpage*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpage(self, p) +proc put_inflateBlock*(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_inflateBlock(self, v) +proc get_inflateBlock*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_inflateBlock(self, p) +proc put_onbeforedeactivate*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforedeactivate(self, v) +proc get_onbeforedeactivate*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforedeactivate(self, p) +proc setActive*(self: ptr IHTMLElement3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setActive(self) +proc put_contentEditable*(self: ptr IHTMLElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_contentEditable(self, v) +proc get_contentEditable*(self: ptr IHTMLElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentEditable(self, p) +proc get_isContentEditable*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isContentEditable(self, p) +proc put_hideFocus*(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hideFocus(self, v) +proc get_hideFocus*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hideFocus(self, p) +proc put_disabled*(self: ptr IHTMLElement3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_isDisabled*(self: ptr IHTMLElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isDisabled(self, p) +proc put_onmove*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmove(self, v) +proc get_onmove*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmove(self, p) +proc put_oncontrolselect*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncontrolselect(self, v) +proc get_oncontrolselect*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncontrolselect(self, p) +proc fireEvent*(self: ptr IHTMLElement3, bstrEventName: BSTR, pvarEventObject: ptr VARIANT, pfCancelled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fireEvent(self, bstrEventName, pvarEventObject, pfCancelled) +proc put_onresizestart*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onresizestart(self, v) +proc get_onresizestart*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onresizestart(self, p) +proc put_onresizeend*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onresizeend(self, v) +proc get_onresizeend*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onresizeend(self, p) +proc put_onmovestart*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmovestart(self, v) +proc get_onmovestart*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmovestart(self, p) +proc put_onmoveend*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmoveend(self, v) +proc get_onmoveend*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmoveend(self, p) +proc put_onmouseenter*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseenter(self, v) +proc get_onmouseenter*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseenter(self, p) +proc put_onmouseleave*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseleave(self, v) +proc get_onmouseleave*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseleave(self, p) +proc put_onactivate*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onactivate(self, v) +proc get_onactivate*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onactivate(self, p) +proc put_ondeactivate*(self: ptr IHTMLElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondeactivate(self, v) +proc get_ondeactivate*(self: ptr IHTMLElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondeactivate(self, p) +proc dragDrop*(self: ptr IHTMLElement3, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.dragDrop(self, pfRet) +proc get_glyphMode*(self: ptr IHTMLElement3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_glyphMode(self, p) +proc put_onmousewheel*(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousewheel(self, v) +proc get_onmousewheel*(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousewheel(self, p) +proc normalize*(self: ptr IHTMLElement4): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.normalize(self) +proc getAttributeNode*(self: ptr IHTMLElement4, bstrname: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNode(self, bstrname, ppAttribute) +proc setAttributeNode*(self: ptr IHTMLElement4, pattr: ptr IHTMLDOMAttribute, ppretAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNode(self, pattr, ppretAttribute) +proc removeAttributeNode*(self: ptr IHTMLElement4, pattr: ptr IHTMLDOMAttribute, ppretAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttributeNode(self, pattr, ppretAttribute) +proc put_onbeforeactivate*(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeactivate(self, v) +proc get_onbeforeactivate*(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeactivate(self, p) +proc put_onfocusin*(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusin(self, v) +proc get_onfocusin*(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusin(self, p) +proc put_onfocusout*(self: ptr IHTMLElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusout(self, v) +proc get_onfocusout*(self: ptr IHTMLElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusout(self, p) +proc querySelector*(self: ptr IElementSelector, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.querySelector(self, v, pel) +proc querySelectorAll*(self: ptr IElementSelector, v: BSTR, pel: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.querySelectorAll(self, v, pel) +proc DrawToDC*(self: ptr IHTMLElementRender, hDC: HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DrawToDC(self, hDC) +proc SetDocumentPrinter*(self: ptr IHTMLElementRender, bstrPrinterName: BSTR, hDC: HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDocumentPrinter(self, bstrPrinterName, hDC) +proc get_uniqueNumber*(self: ptr IHTMLUniqueName, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_uniqueNumber(self, p) +proc get_uniqueID*(self: ptr IHTMLUniqueName, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_uniqueID(self, p) +proc getAttributeNode*(self: ptr IHTMLElement5, bstrname: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNode(self, bstrname, ppretAttribute) +proc setAttributeNode*(self: ptr IHTMLElement5, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNode(self, pattr, ppretAttribute) +proc removeAttributeNode*(self: ptr IHTMLElement5, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttributeNode(self, pattr, ppretAttribute) +proc hasAttribute*(self: ptr IHTMLElement5, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttribute(self, name, pfHasAttribute) +proc put_role*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_role(self, v) +proc get_role*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_role(self, p) +proc put_ariaBusy*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaBusy(self, v) +proc get_ariaBusy*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaBusy(self, p) +proc put_ariaChecked*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaChecked(self, v) +proc get_ariaChecked*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaChecked(self, p) +proc put_ariaDisabled*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaDisabled(self, v) +proc get_ariaDisabled*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaDisabled(self, p) +proc put_ariaExpanded*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaExpanded(self, v) +proc get_ariaExpanded*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaExpanded(self, p) +proc put_ariaHaspopup*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaHaspopup(self, v) +proc get_ariaHaspopup*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaHaspopup(self, p) +proc put_ariaHidden*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaHidden(self, v) +proc get_ariaHidden*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaHidden(self, p) +proc put_ariaInvalid*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaInvalid(self, v) +proc get_ariaInvalid*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaInvalid(self, p) +proc put_ariaMultiselectable*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaMultiselectable(self, v) +proc get_ariaMultiselectable*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaMultiselectable(self, p) +proc put_ariaPressed*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaPressed(self, v) +proc get_ariaPressed*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaPressed(self, p) +proc put_ariaReadonly*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaReadonly(self, v) +proc get_ariaReadonly*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaReadonly(self, p) +proc put_ariaRequired*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaRequired(self, v) +proc get_ariaRequired*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaRequired(self, p) +proc put_ariaSecret*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaSecret(self, v) +proc get_ariaSecret*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaSecret(self, p) +proc put_ariaSelected*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaSelected(self, v) +proc get_ariaSelected*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaSelected(self, p) +proc getAttribute*(self: ptr IHTMLElement5, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, AttributeValue) +proc setAttribute*(self: ptr IHTMLElement5, strAttributeName: BSTR, AttributeValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, AttributeValue) +proc removeAttribute*(self: ptr IHTMLElement5, strAttributeName: BSTR, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName, pfSuccess) +proc get_attributes*(self: ptr IHTMLElement5, p: ptr ptr IHTMLAttributeCollection3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attributes(self, p) +proc put_ariaValuenow*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaValuenow(self, v) +proc get_ariaValuenow*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaValuenow(self, p) +proc put_ariaPosinset*(self: ptr IHTMLElement5, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaPosinset(self, v) +proc get_ariaPosinset*(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaPosinset(self, p) +proc put_ariaSetsize*(self: ptr IHTMLElement5, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaSetsize(self, v) +proc get_ariaSetsize*(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaSetsize(self, p) +proc put_ariaLevel*(self: ptr IHTMLElement5, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaLevel(self, v) +proc get_ariaLevel*(self: ptr IHTMLElement5, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaLevel(self, p) +proc put_ariaValuemin*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaValuemin(self, v) +proc get_ariaValuemin*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaValuemin(self, p) +proc put_ariaValuemax*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaValuemax(self, v) +proc get_ariaValuemax*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaValuemax(self, p) +proc put_ariaControls*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaControls(self, v) +proc get_ariaControls*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaControls(self, p) +proc put_ariaDescribedby*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaDescribedby(self, v) +proc get_ariaDescribedby*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaDescribedby(self, p) +proc put_ariaFlowto*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaFlowto(self, v) +proc get_ariaFlowto*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaFlowto(self, p) +proc put_ariaLabelledby*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaLabelledby(self, v) +proc get_ariaLabelledby*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaLabelledby(self, p) +proc put_ariaActivedescendant*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaActivedescendant(self, v) +proc get_ariaActivedescendant*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaActivedescendant(self, p) +proc put_ariaOwns*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaOwns(self, v) +proc get_ariaOwns*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaOwns(self, p) +proc hasAttributes*(self: ptr IHTMLElement5, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributes(self, pfHasAttributes) +proc put_ariaLive*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaLive(self, v) +proc get_ariaLive*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaLive(self, p) +proc put_ariaRelevant*(self: ptr IHTMLElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ariaRelevant(self, v) +proc get_ariaRelevant*(self: ptr IHTMLElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ariaRelevant(self, p) +proc getAttributeNS*(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNS(self, pvarNS, strAttributeName, AttributeValue) +proc setAttributeNS*(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR, pvarAttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNS(self, pvarNS, strAttributeName, pvarAttributeValue) +proc removeAttributeNS*(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, strAttributeName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttributeNS(self, pvarNS, strAttributeName) +proc getAttributeNodeNS*(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, bstrname: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNodeNS(self, pvarNS, bstrname, ppretAttribute) +proc setAttributeNodeNS*(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNodeNS(self, pattr, ppretAttribute) +proc hasAttributeNS*(self: ptr IHTMLElement6, pvarNS: ptr VARIANT, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributeNS(self, pvarNS, name, pfHasAttribute) +proc getAttribute*(self: ptr IHTMLElement6, strAttributeName: BSTR, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, AttributeValue) +proc setAttribute*(self: ptr IHTMLElement6, strAttributeName: BSTR, pvarAttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, pvarAttributeValue) +proc removeAttribute*(self: ptr IHTMLElement6, strAttributeName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName) +proc getAttributeNode*(self: ptr IHTMLElement6, strAttributeName: BSTR, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNode(self, strAttributeName, ppretAttribute) +proc setAttributeNode*(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNode(self, pattr, ppretAttribute) +proc removeAttributeNode*(self: ptr IHTMLElement6, pattr: ptr IHTMLDOMAttribute2, ppretAttribute: ptr ptr IHTMLDOMAttribute2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttributeNode(self, pattr, ppretAttribute) +proc hasAttribute*(self: ptr IHTMLElement6, name: BSTR, pfHasAttribute: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttribute(self, name, pfHasAttribute) +proc getElementsByTagNameNS*(self: ptr IHTMLElement6, varNS: ptr VARIANT, bstrLocalName: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagNameNS(self, varNS, bstrLocalName, pelColl) +proc get_tagName*(self: ptr IHTMLElement6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagName(self, p) +proc get_nodeName*(self: ptr IHTMLElement6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeName(self, p) +proc getElementsByClassName*(self: ptr IHTMLElement6, v: BSTR, pel: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByClassName(self, v, pel) +proc msMatchesSelector*(self: ptr IHTMLElement6, v: BSTR, pfMatches: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msMatchesSelector(self, v, pfMatches) +proc put_onabort*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_oncanplay*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplay(self, v) +proc get_oncanplay*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplay(self, p) +proc put_oncanplaythrough*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplaythrough(self, v) +proc get_oncanplaythrough*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplaythrough(self, p) +proc put_onchange*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_ondurationchange*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondurationchange(self, v) +proc get_ondurationchange*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondurationchange(self, p) +proc put_onemptied*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onemptied(self, v) +proc get_onemptied*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onemptied(self, p) +proc put_onended*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onended(self, v) +proc get_onended*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onended(self, p) +proc put_onerror*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_oninput*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oninput(self, v) +proc get_oninput*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oninput(self, p) +proc put_onload*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onloadeddata*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadeddata(self, v) +proc get_onloadeddata*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadeddata(self, p) +proc put_onloadedmetadata*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadedmetadata(self, v) +proc get_onloadedmetadata*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadedmetadata(self, p) +proc put_onloadstart*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadstart(self, v) +proc get_onloadstart*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadstart(self, p) +proc put_onpause*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpause(self, v) +proc get_onpause*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpause(self, p) +proc put_onplay*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplay(self, v) +proc get_onplay*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplay(self, p) +proc put_onplaying*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplaying(self, v) +proc get_onplaying*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplaying(self, p) +proc put_onprogress*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onprogress(self, v) +proc get_onprogress*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onprogress(self, p) +proc put_onratechange*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onratechange(self, v) +proc get_onratechange*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onratechange(self, p) +proc put_onreset*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreset(self, v) +proc get_onreset*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreset(self, p) +proc put_onseeked*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeked(self, v) +proc get_onseeked*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeked(self, p) +proc put_onseeking*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeking(self, v) +proc get_onseeking*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeking(self, p) +proc put_onselect*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_onstalled*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstalled(self, v) +proc get_onstalled*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstalled(self, p) +proc put_onsubmit*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsubmit(self, v) +proc get_onsubmit*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsubmit(self, p) +proc put_onsuspend*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsuspend(self, v) +proc get_onsuspend*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsuspend(self, p) +proc put_ontimeupdate*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontimeupdate(self, v) +proc get_ontimeupdate*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ontimeupdate(self, p) +proc put_onvolumechange*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onvolumechange(self, v) +proc get_onvolumechange*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onvolumechange(self, p) +proc put_onwaiting*(self: ptr IHTMLElement6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onwaiting(self, v) +proc get_onwaiting*(self: ptr IHTMLElement6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onwaiting(self, p) +proc hasAttributes*(self: ptr IHTMLElement6, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributes(self, pfHasAttributes) +proc put_onmspointerdown*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerdown(self, v) +proc get_onmspointerdown*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerdown(self, p) +proc put_onmspointermove*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointermove(self, v) +proc get_onmspointermove*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointermove(self, p) +proc put_onmspointerup*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerup(self, v) +proc get_onmspointerup*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerup(self, p) +proc put_onmspointerover*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerover(self, v) +proc get_onmspointerover*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerover(self, p) +proc put_onmspointerout*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerout(self, v) +proc get_onmspointerout*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerout(self, p) +proc put_onmspointercancel*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointercancel(self, v) +proc get_onmspointercancel*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointercancel(self, p) +proc put_onmspointerhover*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerhover(self, v) +proc get_onmspointerhover*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerhover(self, p) +proc put_onmslostpointercapture*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmslostpointercapture(self, v) +proc get_onmslostpointercapture*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmslostpointercapture(self, p) +proc put_onmsgotpointercapture*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgotpointercapture(self, v) +proc get_onmsgotpointercapture*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgotpointercapture(self, p) +proc put_onmsgesturestart*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturestart(self, v) +proc get_onmsgesturestart*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturestart(self, p) +proc put_onmsgesturechange*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturechange(self, v) +proc get_onmsgesturechange*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturechange(self, p) +proc put_onmsgestureend*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgestureend(self, v) +proc get_onmsgestureend*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgestureend(self, p) +proc put_onmsgesturehold*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturehold(self, v) +proc get_onmsgesturehold*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturehold(self, p) +proc put_onmsgesturetap*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturetap(self, v) +proc get_onmsgesturetap*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturetap(self, p) +proc put_onmsgesturedoubletap*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturedoubletap(self, v) +proc get_onmsgesturedoubletap*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturedoubletap(self, p) +proc put_onmsinertiastart*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsinertiastart(self, v) +proc get_onmsinertiastart*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsinertiastart(self, p) +proc msSetPointerCapture*(self: ptr IHTMLElement7, pointerId: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msSetPointerCapture(self, pointerId) +proc msReleasePointerCapture*(self: ptr IHTMLElement7, pointerId: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msReleasePointerCapture(self, pointerId) +proc put_onmstransitionstart*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmstransitionstart(self, v) +proc get_onmstransitionstart*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmstransitionstart(self, p) +proc put_onmstransitionend*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmstransitionend(self, v) +proc get_onmstransitionend*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmstransitionend(self, p) +proc put_onmsanimationstart*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsanimationstart(self, v) +proc get_onmsanimationstart*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsanimationstart(self, p) +proc put_onmsanimationend*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsanimationend(self, v) +proc get_onmsanimationend*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsanimationend(self, p) +proc put_onmsanimationiteration*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsanimationiteration(self, v) +proc get_onmsanimationiteration*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsanimationiteration(self, p) +proc put_oninvalid*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oninvalid(self, v) +proc get_oninvalid*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oninvalid(self, p) +proc put_xmsAcceleratorKey*(self: ptr IHTMLElement7, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmsAcceleratorKey(self, v) +proc get_xmsAcceleratorKey*(self: ptr IHTMLElement7, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmsAcceleratorKey(self, p) +proc put_spellcheck*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_spellcheck(self, v) +proc get_spellcheck*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_spellcheck(self, p) +proc put_onmsmanipulationstatechanged*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsmanipulationstatechanged(self, v) +proc get_onmsmanipulationstatechanged*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsmanipulationstatechanged(self, p) +proc put_oncuechange*(self: ptr IHTMLElement7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncuechange(self, v) +proc get_oncuechange*(self: ptr IHTMLElement7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncuechange(self, p) +proc msGetRulesApplied*(self: ptr IHTMLElementAppliedStyles, ppRulesAppliedCollection: ptr ptr IRulesAppliedCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msGetRulesApplied(self, ppRulesAppliedCollection) +proc msGetRulesAppliedWithAncestor*(self: ptr IHTMLElementAppliedStyles, varContext: VARIANT, ppRulesAppliedCollection: ptr ptr IRulesAppliedCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msGetRulesAppliedWithAncestor(self, varContext, ppRulesAppliedCollection) +proc get_firstElementChild*(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstElementChild(self, p) +proc get_lastElementChild*(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastElementChild(self, p) +proc get_previousElementSibling*(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousElementSibling(self, p) +proc get_nextElementSibling*(self: ptr IElementTraversal, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextElementSibling(self, p) +proc get_childElementCount*(self: ptr IElementTraversal, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childElementCount(self, p) +proc put_dataFld*(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataFld(self, v) +proc get_dataFld*(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataFld(self, p) +proc put_dataSrc*(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataSrc(self, v) +proc get_dataSrc*(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataSrc(self, p) +proc put_dataFormatAs*(self: ptr IHTMLDatabinding, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataFormatAs(self, v) +proc get_dataFormatAs*(self: ptr IHTMLDatabinding, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataFormatAs(self, p) +proc get_style*(self: ptr IHTMLElementDefaults, p: ptr ptr IHTMLStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc put_tabStop*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tabStop(self, v) +proc get_tabStop*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tabStop(self, p) +proc put_viewInheritStyle*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_viewInheritStyle(self, v) +proc get_viewInheritStyle*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewInheritStyle(self, p) +proc put_viewMasterTab*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_viewMasterTab(self, v) +proc get_viewMasterTab*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewMasterTab(self, p) +proc put_scrollSegmentX*(self: ptr IHTMLElementDefaults, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollSegmentX(self, v) +proc get_scrollSegmentX*(self: ptr IHTMLElementDefaults, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollSegmentX(self, p) +proc put_scrollSegmentY*(self: ptr IHTMLElementDefaults, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollSegmentY(self, v) +proc get_scrollSegmentY*(self: ptr IHTMLElementDefaults, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollSegmentY(self, p) +proc put_isMultiLine*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_isMultiLine(self, v) +proc get_isMultiLine*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isMultiLine(self, p) +proc put_contentEditable*(self: ptr IHTMLElementDefaults, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_contentEditable(self, v) +proc get_contentEditable*(self: ptr IHTMLElementDefaults, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentEditable(self, p) +proc put_canHaveHTML*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_canHaveHTML(self, v) +proc get_canHaveHTML*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_canHaveHTML(self, p) +proc putref_viewLink*(self: ptr IHTMLElementDefaults, v: ptr IHTMLDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_viewLink(self, v) +proc get_viewLink*(self: ptr IHTMLElementDefaults, p: ptr ptr IHTMLDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewLink(self, p) +proc put_frozen*(self: ptr IHTMLElementDefaults, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frozen(self, v) +proc get_frozen*(self: ptr IHTMLElementDefaults, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frozen(self, p) +proc get_element*(self: ptr IHTCDefaultDispatch, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_element(self, p) +proc createEventObject*(self: ptr IHTCDefaultDispatch, eventObj: ptr ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createEventObject(self, eventObj) +proc get_defaults*(self: ptr IHTCDefaultDispatch, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaults(self, p) +proc get_document*(self: ptr IHTCDefaultDispatch, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc fireChange*(self: ptr IHTCPropertyBehavior): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fireChange(self) +proc put_value*(self: ptr IHTCPropertyBehavior, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTCPropertyBehavior, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc fire*(self: ptr IHTCEventBehavior, pvar: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fire(self, pvar) +proc fireEvent*(self: ptr IHTCAttachBehavior, evt: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fireEvent(self, evt) +proc detachEvent*(self: ptr IHTCAttachBehavior): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detachEvent(self) +proc fireEvent*(self: ptr IHTCAttachBehavior2, evt: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fireEvent(self, evt) +proc get_urn*(self: ptr IHTCDescBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_urn(self, p) +proc get_name*(self: ptr IHTCDescBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_length*(self: ptr IHTMLUrnCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLUrnCollection, index: LONG, ppUrn: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppUrn) +proc get_recordset*(self: ptr IHTMLGenericElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_recordset(self, p) +proc namedRecordset*(self: ptr IHTMLGenericElement, dataMember: BSTR, hierarchy: ptr VARIANT, ppRecordset: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedRecordset(self, dataMember, hierarchy, ppRecordset) +proc put_selectorText*(self: ptr IHTMLStyleSheetRule, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectorText(self, v) +proc get_selectorText*(self: ptr IHTMLStyleSheetRule, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectorText(self, p) +proc get_style*(self: ptr IHTMLStyleSheetRule, p: ptr ptr IHTMLRuleStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc get_readOnly*(self: ptr IHTMLStyleSheetRule, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readOnly(self, p) +proc get_msSpecificity*(self: ptr IHTMLStyleSheetRuleApplied, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msSpecificity(self, p) +proc msGetSpecificity*(self: ptr IHTMLStyleSheetRuleApplied, index: LONG, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msGetSpecificity(self, index, p) +proc put_selectorText*(self: ptr IHTMLStyleSheetRule2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectorText(self, v) +proc get_selectorText*(self: ptr IHTMLStyleSheetRule2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectorText(self, p) +proc get_length*(self: ptr IHTMLStyleSheetRulesCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLStyleSheetRulesCollection, index: LONG, ppHTMLStyleSheetRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppHTMLStyleSheetRule) +proc get_length*(self: ptr IHTMLStyleSheetRulesCollection2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLStyleSheetRulesCollection2, index: LONG, ppHTMLCSSRule: ptr ptr IHTMLCSSRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppHTMLCSSRule) +proc get_selector*(self: ptr IHTMLStyleSheetPage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selector(self, p) +proc get_pseudoClass*(self: ptr IHTMLStyleSheetPage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pseudoClass(self, p) +proc put_selectorText*(self: ptr IHTMLStyleSheetPage2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectorText(self, v) +proc get_selectorText*(self: ptr IHTMLStyleSheetPage2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectorText(self, p) +proc get_style*(self: ptr IHTMLStyleSheetPage2, p: ptr ptr IHTMLRuleStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc get_length*(self: ptr IHTMLStyleSheetPagesCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLStyleSheetPagesCollection, index: LONG, ppHTMLStyleSheetPage: ptr ptr IHTMLStyleSheetPage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppHTMLStyleSheetPage) +proc put_title*(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_title(self, v) +proc get_title*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_title(self, p) +proc get_parentStyleSheet*(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentStyleSheet(self, p) +proc get_owningElement*(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_owningElement(self, p) +proc put_disabled*(self: ptr IHTMLStyleSheet, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLStyleSheet, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_readOnly*(self: ptr IHTMLStyleSheet, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readOnly(self, p) +proc get_imports*(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheetsCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imports(self, p) +proc put_href*(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc get_type*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_id*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_id(self, p) +proc addImport*(self: ptr IHTMLStyleSheet, bstrURL: BSTR, lIndex: LONG, plIndex: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addImport(self, bstrURL, lIndex, plIndex) +proc addRule*(self: ptr IHTMLStyleSheet, bstrSelector: BSTR, bstrStyle: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addRule(self, bstrSelector, bstrStyle, lIndex, plNewIndex) +proc removeImport*(self: ptr IHTMLStyleSheet, lIndex: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeImport(self, lIndex) +proc removeRule*(self: ptr IHTMLStyleSheet, lIndex: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeRule(self, lIndex) +proc put_media*(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc put_cssText*(self: ptr IHTMLStyleSheet, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cssText(self, v) +proc get_cssText*(self: ptr IHTMLStyleSheet, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssText(self, p) +proc get_rules*(self: ptr IHTMLStyleSheet, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rules(self, p) +proc get_pages*(self: ptr IHTMLStyleSheet2, p: ptr ptr IHTMLStyleSheetPagesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pages(self, p) +proc addPageRule*(self: ptr IHTMLStyleSheet2, bstrSelector: BSTR, bstrStyle: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addPageRule(self, bstrSelector, bstrStyle, lIndex, plNewIndex) +proc put_href*(self: ptr IHTMLStyleSheet3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLStyleSheet3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc get_isAlternate*(self: ptr IHTMLStyleSheet3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isAlternate(self, p) +proc get_isPrefAlternate*(self: ptr IHTMLStyleSheet3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isPrefAlternate(self, p) +proc get_type*(self: ptr IHTMLStyleSheet4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_href*(self: ptr IHTMLStyleSheet4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc get_title*(self: ptr IHTMLStyleSheet4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_title(self, p) +proc get_ownerNode*(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerNode(self, p) +proc get_ownerRule*(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLCSSRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerRule(self, p) +proc get_cssRules*(self: ptr IHTMLStyleSheet4, p: ptr ptr IHTMLStyleSheetRulesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cssRules(self, p) +proc get_media*(self: ptr IHTMLStyleSheet4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc insertRule*(self: ptr IHTMLStyleSheet4, bstrRule: BSTR, lIndex: LONG, plNewIndex: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRule(self, bstrRule, lIndex, plNewIndex) +proc deleteRule*(self: ptr IHTMLStyleSheet4, lIndex: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRule(self, lIndex) +proc get_length*(self: ptr IHTMLStyleSheetsCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLStyleSheetsCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLStyleSheetsCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, pvarIndex, pvarResult) +proc item*(self: ptr IHTMLStyleSheetsCollection2, index: LONG, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pvarResult) +proc put_href*(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_rel*(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rel(self, v) +proc get_rel*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rel(self, p) +proc put_rev*(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rev(self, v) +proc get_rev*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rev(self, p) +proc put_type*(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_readyState*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onload*(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onerror*(self: ptr IHTMLLinkElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLLinkElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc get_styleSheet*(self: ptr IHTMLLinkElement, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleSheet(self, p) +proc put_disabled*(self: ptr IHTMLLinkElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLLinkElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc put_media*(self: ptr IHTMLLinkElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLLinkElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc put_target*(self: ptr IHTMLLinkElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_target(self, v) +proc get_target*(self: ptr IHTMLLinkElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_charset*(self: ptr IHTMLLinkElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, v) +proc get_charset*(self: ptr IHTMLLinkElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_hreflang*(self: ptr IHTMLLinkElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hreflang(self, v) +proc get_hreflang*(self: ptr IHTMLLinkElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hreflang(self, p) +proc put_href*(self: ptr IHTMLLinkElement4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLLinkElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc get_sheet*(self: ptr IHTMLLinkElement5, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sheet(self, p) +proc get_htmlText*(self: ptr IHTMLTxtRange, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_htmlText(self, p) +proc put_text*(self: ptr IHTMLTxtRange, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLTxtRange, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc parentElement*(self: ptr IHTMLTxtRange, parent: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.parentElement(self, parent) +proc duplicate*(self: ptr IHTMLTxtRange, Duplicate: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.duplicate(self, Duplicate) +proc inRange*(self: ptr IHTMLTxtRange, Range: ptr IHTMLTxtRange, InRange: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.inRange(self, Range, InRange) +proc isEqual*(self: ptr IHTMLTxtRange, Range: ptr IHTMLTxtRange, IsEqual: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isEqual(self, Range, IsEqual) +proc scrollIntoView*(self: ptr IHTMLTxtRange, fStart: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scrollIntoView(self, fStart) +proc collapse*(self: ptr IHTMLTxtRange, Start: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.collapse(self, Start) +proc expand*(self: ptr IHTMLTxtRange, Unit: BSTR, Success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.expand(self, Unit, Success) +proc move*(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.move(self, Unit, Count, ActualCount) +proc moveStart*(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveStart(self, Unit, Count, ActualCount) +proc moveEnd*(self: ptr IHTMLTxtRange, Unit: BSTR, Count: LONG, ActualCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveEnd(self, Unit, Count, ActualCount) +proc select*(self: ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc pasteHTML*(self: ptr IHTMLTxtRange, html: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.pasteHTML(self, html) +proc moveToElementText*(self: ptr IHTMLTxtRange, element: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveToElementText(self, element) +proc setEndPoint*(self: ptr IHTMLTxtRange, how: BSTR, SourceRange: ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setEndPoint(self, how, SourceRange) +proc compareEndPoints*(self: ptr IHTMLTxtRange, how: BSTR, SourceRange: ptr IHTMLTxtRange, ret: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.compareEndPoints(self, how, SourceRange, ret) +proc findText*(self: ptr IHTMLTxtRange, String: BSTR, count: LONG, Flags: LONG, Success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.findText(self, String, count, Flags, Success) +proc moveToPoint*(self: ptr IHTMLTxtRange, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveToPoint(self, x, y) +proc getBookmark*(self: ptr IHTMLTxtRange, Boolmark: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getBookmark(self, Boolmark) +proc moveToBookmark*(self: ptr IHTMLTxtRange, Bookmark: BSTR, Success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveToBookmark(self, Bookmark, Success) +proc queryCommandSupported*(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandSupported(self, cmdID, pfRet) +proc queryCommandEnabled*(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandEnabled(self, cmdID, pfRet) +proc queryCommandState*(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandState(self, cmdID, pfRet) +proc queryCommandIndeterm*(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandIndeterm(self, cmdID, pfRet) +proc queryCommandText*(self: ptr IHTMLTxtRange, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandText(self, cmdID, pcmdText) +proc queryCommandValue*(self: ptr IHTMLTxtRange, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandValue(self, cmdID, pcmdValue) +proc execCommand*(self: ptr IHTMLTxtRange, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommand(self, cmdID, showUI, value, pfRet) +proc execCommandShowHelp*(self: ptr IHTMLTxtRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommandShowHelp(self, cmdID, pfRet) +proc get_offsetTop*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetTop(self, p) +proc get_offsetLeft*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetLeft(self, p) +proc get_boundingTop*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boundingTop(self, p) +proc get_boundingLeft*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boundingLeft(self, p) +proc get_boundingWidth*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boundingWidth(self, p) +proc get_boundingHeight*(self: ptr IHTMLTextRangeMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boundingHeight(self, p) +proc getClientRects*(self: ptr IHTMLTextRangeMetrics2, pRectCol: ptr ptr IHTMLRectCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getClientRects(self, pRectCol) +proc getBoundingClientRect*(self: ptr IHTMLTextRangeMetrics2, pRect: ptr ptr IHTMLRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getBoundingClientRect(self, pRect) +proc get_length*(self: ptr IHTMLTxtRangeCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLTxtRangeCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLTxtRangeCollection, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, pvarIndex, pvarResult) +proc get_startContainer*(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_startContainer(self, p) +proc get_startOffset*(self: ptr IHTMLDOMRange, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_startOffset(self, p) +proc get_endContainer*(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_endContainer(self, p) +proc get_endOffset*(self: ptr IHTMLDOMRange, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_endOffset(self, p) +proc get_collapsed*(self: ptr IHTMLDOMRange, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_collapsed(self, p) +proc get_commonAncestorContainer*(self: ptr IHTMLDOMRange, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_commonAncestorContainer(self, p) +proc setStart*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch, offset: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setStart(self, refNode, offset) +proc setEnd*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch, offset: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setEnd(self, refNode, offset) +proc setStartBefore*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setStartBefore(self, refNode) +proc setStartAfter*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setStartAfter(self, refNode) +proc setEndBefore*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setEndBefore(self, refNode) +proc setEndAfter*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setEndAfter(self, refNode) +proc collapse*(self: ptr IHTMLDOMRange, toStart: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.collapse(self, toStart) +proc selectNode*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectNode(self, refNode) +proc selectNodeContents*(self: ptr IHTMLDOMRange, refNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectNodeContents(self, refNode) +proc compareBoundaryPoints*(self: ptr IHTMLDOMRange, how: int16, sourceRange: ptr IDispatch, compareResult: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.compareBoundaryPoints(self, how, sourceRange, compareResult) +proc deleteContents*(self: ptr IHTMLDOMRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteContents(self) +proc extractContents*(self: ptr IHTMLDOMRange, ppDocumentFragment: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.extractContents(self, ppDocumentFragment) +proc cloneContents*(self: ptr IHTMLDOMRange, ppDocumentFragment: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.cloneContents(self, ppDocumentFragment) +proc insertNode*(self: ptr IHTMLDOMRange, newNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertNode(self, newNode) +proc surroundContents*(self: ptr IHTMLDOMRange, newParent: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.surroundContents(self, newParent) +proc cloneRange*(self: ptr IHTMLDOMRange, ppClonedRange: ptr ptr IHTMLDOMRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.cloneRange(self, ppClonedRange) +proc toString*(self: ptr IHTMLDOMRange, pRangeString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, pRangeString) +proc detach*(self: ptr IHTMLDOMRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detach(self) +proc getClientRects*(self: ptr IHTMLDOMRange, ppRectCol: ptr ptr IHTMLRectCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getClientRects(self, ppRectCol) +proc getBoundingClientRect*(self: ptr IHTMLDOMRange, ppRect: ptr ptr IHTMLRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getBoundingClientRect(self, ppRect) +proc put_action*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_action(self, v) +proc get_action*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_action(self, p) +proc put_dir*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dir(self, v) +proc get_dir*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dir(self, p) +proc put_encoding*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_encoding(self, v) +proc get_encoding*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_encoding(self, p) +proc put_method*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_method(self, v) +proc get_method*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_method(self, p) +proc get_elements*(self: ptr IHTMLFormElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_elements(self, p) +proc put_target*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_target(self, v) +proc get_target*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_name*(self: ptr IHTMLFormElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLFormElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_onsubmit*(self: ptr IHTMLFormElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsubmit(self, v) +proc get_onsubmit*(self: ptr IHTMLFormElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsubmit(self, p) +proc put_onreset*(self: ptr IHTMLFormElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreset(self, v) +proc get_onreset*(self: ptr IHTMLFormElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreset(self, p) +proc submit*(self: ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.submit(self) +proc reset*(self: ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.reset(self) +proc put_length*(self: ptr IHTMLFormElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_length(self, v) +proc get_length*(self: ptr IHTMLFormElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLFormElement, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLFormElement, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, name, index, pdisp) +proc tags*(self: ptr IHTMLFormElement, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.tags(self, tagName, pdisp) +proc put_acceptCharset*(self: ptr IHTMLFormElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_acceptCharset(self, v) +proc get_acceptCharset*(self: ptr IHTMLFormElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_acceptCharset(self, p) +proc urns*(self: ptr IHTMLFormElement2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.urns(self, urn, pdisp) +proc namedItem*(self: ptr IHTMLFormElement3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pdisp) +proc appendNameValuePair*(self: ptr IHTMLSubmitData, name: BSTR, value: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendNameValuePair(self, name, value) +proc appendNameFilePair*(self: ptr IHTMLSubmitData, name: BSTR, filename: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendNameFilePair(self, name, filename) +proc appendItemSeparator*(self: ptr IHTMLSubmitData): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItemSeparator(self) +proc put_action*(self: ptr IHTMLFormElement4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_action(self, v) +proc get_action*(self: ptr IHTMLFormElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_action(self, p) +proc put_tabIndex*(self: ptr IHTMLControlElement, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tabIndex(self, v) +proc get_tabIndex*(self: ptr IHTMLControlElement, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tabIndex(self, p) +proc focus*(self: ptr IHTMLControlElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc put_accessKey*(self: ptr IHTMLControlElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accessKey(self, v) +proc get_accessKey*(self: ptr IHTMLControlElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accessKey(self, p) +proc put_onblur*(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_onfocus*(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_onresize*(self: ptr IHTMLControlElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onresize(self, v) +proc get_onresize*(self: ptr IHTMLControlElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onresize(self, p) +proc blur*(self: ptr IHTMLControlElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.blur(self) +proc addFilter*(self: ptr IHTMLControlElement, pUnk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addFilter(self, pUnk) +proc removeFilter*(self: ptr IHTMLControlElement, pUnk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeFilter(self, pUnk) +proc get_clientHeight*(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientHeight(self, p) +proc get_clientWidth*(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientWidth(self, p) +proc get_clientTop*(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientTop(self, p) +proc get_clientLeft*(self: ptr IHTMLControlElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientLeft(self, p) +proc createControlRange*(self: ptr IHTMLTextContainer, range: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createControlRange(self, range) +proc get_scrollHeight*(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollHeight(self, p) +proc get_scrollWidth*(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollWidth(self, p) +proc put_scrollTop*(self: ptr IHTMLTextContainer, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollTop(self, v) +proc get_scrollTop*(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollTop(self, p) +proc put_scrollLeft*(self: ptr IHTMLTextContainer, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollLeft(self, v) +proc get_scrollLeft*(self: ptr IHTMLTextContainer, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollLeft(self, p) +proc put_onscroll*(self: ptr IHTMLTextContainer, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onscroll(self, v) +proc get_onscroll*(self: ptr IHTMLTextContainer, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onscroll(self, p) +proc select*(self: ptr IHTMLControlRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc add*(self: ptr IHTMLControlRange, item: ptr IHTMLControlElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, item) +proc remove*(self: ptr IHTMLControlRange, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove(self, index) +proc item*(self: ptr IHTMLControlRange, index: LONG, pdisp: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pdisp) +proc scrollIntoView*(self: ptr IHTMLControlRange, varargStart: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scrollIntoView(self, varargStart) +proc queryCommandSupported*(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandSupported(self, cmdID, pfRet) +proc queryCommandEnabled*(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandEnabled(self, cmdID, pfRet) +proc queryCommandState*(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandState(self, cmdID, pfRet) +proc queryCommandIndeterm*(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandIndeterm(self, cmdID, pfRet) +proc queryCommandText*(self: ptr IHTMLControlRange, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandText(self, cmdID, pcmdText) +proc queryCommandValue*(self: ptr IHTMLControlRange, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandValue(self, cmdID, pcmdValue) +proc execCommand*(self: ptr IHTMLControlRange, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommand(self, cmdID, showUI, value, pfRet) +proc execCommandShowHelp*(self: ptr IHTMLControlRange, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommandShowHelp(self, cmdID, pfRet) +proc commonParentElement*(self: ptr IHTMLControlRange, parent: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.commonParentElement(self, parent) +proc get_length*(self: ptr IHTMLControlRange, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc addElement*(self: ptr IHTMLControlRange2, item: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addElement(self, item) +proc put_isMap*(self: ptr IHTMLImgElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_isMap(self, v) +proc get_isMap*(self: ptr IHTMLImgElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isMap(self, p) +proc put_useMap*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_useMap(self, v) +proc get_useMap*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_useMap(self, p) +proc get_mimeType*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeType(self, p) +proc get_fileSize*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileSize(self, p) +proc get_fileCreatedDate*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileCreatedDate(self, p) +proc get_fileModifiedDate*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileModifiedDate(self, p) +proc get_fileUpdatedDate*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileUpdatedDate(self, p) +proc get_protocol*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocol(self, p) +proc get_href*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc get_nameProp*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nameProp(self, p) +proc put_border*(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_vspace*(self: ptr IHTMLImgElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLImgElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc put_alt*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_src*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_lowsrc*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lowsrc(self, v) +proc get_lowsrc*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lowsrc(self, p) +proc put_vrml*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vrml(self, v) +proc get_vrml*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vrml(self, p) +proc put_dynsrc*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dynsrc(self, v) +proc get_dynsrc*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dynsrc(self, p) +proc get_readyState*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc get_complete*(self: ptr IHTMLImgElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_complete(self, p) +proc put_loop*(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc put_align*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_onload*(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onerror*(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onabort*(self: ptr IHTMLImgElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLImgElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_name*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_width*(self: ptr IHTMLImgElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLImgElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLImgElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_start*(self: ptr IHTMLImgElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_start(self, v) +proc get_start*(self: ptr IHTMLImgElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_start(self, p) +proc put_longDesc*(self: ptr IHTMLImgElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_longDesc(self, v) +proc get_longDesc*(self: ptr IHTMLImgElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longDesc(self, p) +proc put_longDesc*(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_longDesc(self, v) +proc get_longDesc*(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longDesc(self, p) +proc put_vrml*(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vrml(self, v) +proc get_vrml*(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vrml(self, p) +proc put_lowsrc*(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lowsrc(self, v) +proc get_lowsrc*(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lowsrc(self, p) +proc put_dynsrc*(self: ptr IHTMLImgElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dynsrc(self, v) +proc get_dynsrc*(self: ptr IHTMLImgElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dynsrc(self, p) +proc get_naturalWidth*(self: ptr IHTMLImgElement4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_naturalWidth(self, p) +proc get_naturalHeight*(self: ptr IHTMLImgElement4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_naturalHeight(self, p) +proc put_msPlayToDisabled*(self: ptr IHTMLMSImgElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPlayToDisabled(self, v) +proc get_msPlayToDisabled*(self: ptr IHTMLMSImgElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPlayToDisabled(self, p) +proc put_msPlayToPrimary*(self: ptr IHTMLMSImgElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPlayToPrimary(self, v) +proc get_msPlayToPrimary*(self: ptr IHTMLMSImgElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPlayToPrimary(self, p) +proc create*(self: ptr IHTMLImageElementFactory, width: VARIANT, height: VARIANT, a: ptr ptr IHTMLImgElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, width, height, a) +proc put_background*(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_bgProperties*(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgProperties(self, v) +proc get_bgProperties*(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgProperties(self, p) +proc put_leftMargin*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_leftMargin(self, v) +proc get_leftMargin*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_leftMargin(self, p) +proc put_topMargin*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_topMargin(self, v) +proc get_topMargin*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_topMargin(self, p) +proc put_rightMargin*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rightMargin(self, v) +proc get_rightMargin*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rightMargin(self, p) +proc put_bottomMargin*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bottomMargin(self, v) +proc get_bottomMargin*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bottomMargin(self, p) +proc put_noWrap*(self: ptr IHTMLBodyElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noWrap(self, v) +proc get_noWrap*(self: ptr IHTMLBodyElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noWrap(self, p) +proc put_bgColor*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_text*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_link*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_link(self, v) +proc get_link*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_link(self, p) +proc put_vLink*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vLink(self, v) +proc get_vLink*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vLink(self, p) +proc put_aLink*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_aLink(self, v) +proc get_aLink*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_aLink(self, p) +proc put_onload*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onunload*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onunload(self, v) +proc get_onunload*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onunload(self, p) +proc put_scroll*(self: ptr IHTMLBodyElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scroll(self, v) +proc get_scroll*(self: ptr IHTMLBodyElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scroll(self, p) +proc put_onselect*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_onbeforeunload*(self: ptr IHTMLBodyElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeunload(self, v) +proc get_onbeforeunload*(self: ptr IHTMLBodyElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeunload(self, p) +proc createTextRange*(self: ptr IHTMLBodyElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc put_onbeforeprint*(self: ptr IHTMLBodyElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeprint(self, v) +proc get_onbeforeprint*(self: ptr IHTMLBodyElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeprint(self, p) +proc put_onafterprint*(self: ptr IHTMLBodyElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onafterprint(self, v) +proc get_onafterprint*(self: ptr IHTMLBodyElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onafterprint(self, p) +proc put_background*(self: ptr IHTMLBodyElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLBodyElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_ononline*(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ononline(self, v) +proc get_ononline*(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ononline(self, p) +proc put_onoffline*(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onoffline(self, v) +proc get_onoffline*(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onoffline(self, p) +proc put_onhashchange*(self: ptr IHTMLBodyElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhashchange(self, v) +proc get_onhashchange*(self: ptr IHTMLBodyElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhashchange(self, p) +proc put_onmessage*(self: ptr IHTMLBodyElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmessage(self, v) +proc get_onmessage*(self: ptr IHTMLBodyElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmessage(self, p) +proc put_onstorage*(self: ptr IHTMLBodyElement4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstorage(self, v) +proc get_onstorage*(self: ptr IHTMLBodyElement4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstorage(self, p) +proc put_onpopstate*(self: ptr IHTMLBodyElement5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpopstate(self, v) +proc get_onpopstate*(self: ptr IHTMLBodyElement5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpopstate(self, p) +proc put_color*(self: ptr IHTMLFontElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLFontElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_face*(self: ptr IHTMLFontElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_face(self, v) +proc get_face*(self: ptr IHTMLFontElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_face(self, p) +proc put_size*(self: ptr IHTMLFontElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLFontElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_href*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_target*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_target(self, v) +proc get_target*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_rel*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rel(self, v) +proc get_rel*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rel(self, p) +proc put_rev*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rev(self, v) +proc get_rev*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rev(self, p) +proc put_urn*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_urn(self, v) +proc get_urn*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_urn(self, p) +proc put_Methods*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Methods(self, v) +proc get_Methods*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Methods(self, p) +proc put_name*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_host*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_host(self, v) +proc get_host*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_host(self, p) +proc put_hostname*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hostname(self, v) +proc get_hostname*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hostname(self, p) +proc put_pathname*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pathname(self, v) +proc get_pathname*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathname(self, p) +proc put_port*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_port(self, v) +proc get_port*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_port(self, p) +proc put_protocol*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_protocol(self, v) +proc get_protocol*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocol(self, p) +proc put_search*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_search(self, v) +proc get_search*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_search(self, p) +proc put_hash*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hash(self, v) +proc get_hash*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hash(self, p) +proc put_onblur*(self: ptr IHTMLAnchorElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLAnchorElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_onfocus*(self: ptr IHTMLAnchorElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLAnchorElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_accessKey*(self: ptr IHTMLAnchorElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accessKey(self, v) +proc get_accessKey*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accessKey(self, p) +proc get_protocolLong*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocolLong(self, p) +proc get_mimeType*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeType(self, p) +proc get_nameProp*(self: ptr IHTMLAnchorElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nameProp(self, p) +proc put_tabIndex*(self: ptr IHTMLAnchorElement, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tabIndex(self, v) +proc get_tabIndex*(self: ptr IHTMLAnchorElement, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tabIndex(self, p) +proc focus*(self: ptr IHTMLAnchorElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc blur*(self: ptr IHTMLAnchorElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.blur(self) +proc put_charset*(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, v) +proc get_charset*(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_coords*(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_coords(self, v) +proc get_coords*(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_coords(self, p) +proc put_hreflang*(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hreflang(self, v) +proc get_hreflang*(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hreflang(self, p) +proc put_shape*(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shape(self, v) +proc get_shape*(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shape(self, p) +proc put_type*(self: ptr IHTMLAnchorElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLAnchorElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_shape*(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shape(self, v) +proc get_shape*(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shape(self, p) +proc put_coords*(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_coords(self, v) +proc get_coords*(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_coords(self, p) +proc put_href*(self: ptr IHTMLAnchorElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLAnchorElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_htmlFor*(self: ptr IHTMLLabelElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_htmlFor(self, v) +proc get_htmlFor*(self: ptr IHTMLLabelElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_htmlFor(self, p) +proc put_accessKey*(self: ptr IHTMLLabelElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accessKey(self, v) +proc get_accessKey*(self: ptr IHTMLLabelElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accessKey(self, p) +proc get_form*(self: ptr IHTMLLabelElement2, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_compact*(self: ptr IHTMLListElement2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_compact(self, v) +proc get_compact*(self: ptr IHTMLListElement2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compact(self, p) +proc put_compact*(self: ptr IHTMLUListElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_compact(self, v) +proc get_compact*(self: ptr IHTMLUListElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compact(self, p) +proc put_type*(self: ptr IHTMLUListElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLUListElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_compact*(self: ptr IHTMLOListElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_compact(self, v) +proc get_compact*(self: ptr IHTMLOListElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compact(self, p) +proc put_start*(self: ptr IHTMLOListElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_start(self, v) +proc get_start*(self: ptr IHTMLOListElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_start(self, p) +proc put_type*(self: ptr IHTMLOListElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLOListElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_type*(self: ptr IHTMLLIElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLLIElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLLIElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLLIElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_clear*(self: ptr IHTMLBlockElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clear(self, v) +proc get_clear*(self: ptr IHTMLBlockElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc put_cite*(self: ptr IHTMLBlockElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cite(self, v) +proc get_cite*(self: ptr IHTMLBlockElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cite(self, p) +proc put_width*(self: ptr IHTMLBlockElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLBlockElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_cite*(self: ptr IHTMLBlockElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cite(self, v) +proc get_cite*(self: ptr IHTMLBlockElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cite(self, p) +proc put_align*(self: ptr IHTMLDivElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLDivElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_noWrap*(self: ptr IHTMLDivElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noWrap(self, v) +proc get_noWrap*(self: ptr IHTMLDivElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noWrap(self, p) +proc put_noWrap*(self: ptr IHTMLDDElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noWrap(self, v) +proc get_noWrap*(self: ptr IHTMLDDElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noWrap(self, p) +proc put_noWrap*(self: ptr IHTMLDTElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noWrap(self, v) +proc get_noWrap*(self: ptr IHTMLDTElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noWrap(self, p) +proc put_clear*(self: ptr IHTMLBRElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clear(self, v) +proc get_clear*(self: ptr IHTMLBRElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clear(self, p) +proc put_compact*(self: ptr IHTMLDListElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_compact(self, v) +proc get_compact*(self: ptr IHTMLDListElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compact(self, p) +proc put_align*(self: ptr IHTMLHRElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLHRElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_color*(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_noShade*(self: ptr IHTMLHRElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noShade(self, v) +proc get_noShade*(self: ptr IHTMLHRElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noShade(self, p) +proc put_width*(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_size*(self: ptr IHTMLHRElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLHRElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_align*(self: ptr IHTMLParaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLParaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc toString*(self: ptr IHTMLElementCollection, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc put_length*(self: ptr IHTMLElementCollection, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_length(self, v) +proc get_length*(self: ptr IHTMLElementCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLElementCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLElementCollection, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, name, index, pdisp) +proc tags*(self: ptr IHTMLElementCollection, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.tags(self, tagName, pdisp) +proc urns*(self: ptr IHTMLElementCollection2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.urns(self, urn, pdisp) +proc namedItem*(self: ptr IHTMLElementCollection3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pdisp) +proc get_length*(self: ptr IHTMLElementCollection4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLElementCollection4, index: LONG, pNode: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pNode) +proc namedItem*(self: ptr IHTMLElementCollection4, name: BSTR, pNode: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pNode) +proc put_align*(self: ptr IHTMLHeaderElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLHeaderElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc ShowDropdown*(self: ptr IHTMLSelectElementEx, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowDropdown(self, fShow) +proc SetSelectExFlags*(self: ptr IHTMLSelectElementEx, lFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSelectExFlags(self, lFlags) +proc GetSelectExFlags*(self: ptr IHTMLSelectElementEx, pFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectExFlags(self, pFlags) +proc GetDropdownOpen*(self: ptr IHTMLSelectElementEx, pfOpen: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDropdownOpen(self, pfOpen) +proc put_size*(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_multiple*(self: ptr IHTMLSelectElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_multiple(self, v) +proc get_multiple*(self: ptr IHTMLSelectElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_multiple(self, p) +proc put_name*(self: ptr IHTMLSelectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_options*(self: ptr IHTMLSelectElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_options(self, p) +proc put_onchange*(self: ptr IHTMLSelectElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLSelectElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_selectedIndex*(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectedIndex(self, v) +proc get_selectedIndex*(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectedIndex(self, p) +proc get_type*(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLSelectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLSelectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_disabled*(self: ptr IHTMLSelectElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLSelectElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLSelectElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc add*(self: ptr IHTMLSelectElement, element: ptr IHTMLElement, before: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, element, before) +proc remove*(self: ptr IHTMLSelectElement, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove(self, index) +proc put_length*(self: ptr IHTMLSelectElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_length(self, v) +proc get_length*(self: ptr IHTMLSelectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLSelectElement, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLSelectElement, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, name, index, pdisp) +proc tags*(self: ptr IHTMLSelectElement, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.tags(self, tagName, pdisp) +proc urns*(self: ptr IHTMLSelectElement2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.urns(self, urn, pdisp) +proc namedItem*(self: ptr IHTMLSelectElement4, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pdisp) +proc add*(self: ptr IHTMLSelectElement5, pElem: ptr IHTMLOptionElement, pvarBefore: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, pElem, pvarBefore) +proc add*(self: ptr IHTMLSelectElement6, pElem: ptr IHTMLOptionElement, pvarBefore: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, pElem, pvarBefore) +proc put_value*(self: ptr IHTMLSelectElement6, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLSelectElement6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc createRange*(self: ptr IHTMLSelectionObject, range: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createRange(self, range) +proc empty*(self: ptr IHTMLSelectionObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.empty(self) +proc clear*(self: ptr IHTMLSelectionObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc get_type*(self: ptr IHTMLSelectionObject, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc createRangeCollection*(self: ptr IHTMLSelectionObject2, rangeCollection: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createRangeCollection(self, rangeCollection) +proc get_typeDetail*(self: ptr IHTMLSelectionObject2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_typeDetail(self, p) +proc get_anchorNode*(self: ptr IHTMLSelection, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_anchorNode(self, p) +proc get_anchorOffset*(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_anchorOffset(self, p) +proc get_focusNode*(self: ptr IHTMLSelection, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_focusNode(self, p) +proc get_focusOffset*(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_focusOffset(self, p) +proc get_isCollapsed*(self: ptr IHTMLSelection, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isCollapsed(self, p) +proc collapse*(self: ptr IHTMLSelection, parentNode: ptr IDispatch, offfset: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.collapse(self, parentNode, offfset) +proc collapseToStart*(self: ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.collapseToStart(self) +proc collapseToEnd*(self: ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.collapseToEnd(self) +proc selectAllChildren*(self: ptr IHTMLSelection, parentNode: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectAllChildren(self, parentNode) +proc deleteFromDocument*(self: ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteFromDocument(self) +proc get_rangeCount*(self: ptr IHTMLSelection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rangeCount(self, p) +proc getRangeAt*(self: ptr IHTMLSelection, index: LONG, ppRange: ptr ptr IHTMLDOMRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getRangeAt(self, index, ppRange) +proc addRange*(self: ptr IHTMLSelection, range: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addRange(self, range) +proc removeRange*(self: ptr IHTMLSelection, range: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeRange(self, range) +proc removeAllRanges*(self: ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAllRanges(self) +proc toString*(self: ptr IHTMLSelection, pSelectionString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, pSelectionString) +proc put_selected*(self: ptr IHTMLOptionElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selected(self, v) +proc get_selected*(self: ptr IHTMLOptionElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selected(self, p) +proc put_value*(self: ptr IHTMLOptionElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLOptionElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_defaultSelected*(self: ptr IHTMLOptionElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultSelected(self, v) +proc get_defaultSelected*(self: ptr IHTMLOptionElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultSelected(self, p) +proc put_index*(self: ptr IHTMLOptionElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_index(self, v) +proc get_index*(self: ptr IHTMLOptionElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_index(self, p) +proc put_text*(self: ptr IHTMLOptionElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLOptionElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc get_form*(self: ptr IHTMLOptionElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_label*(self: ptr IHTMLOptionElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_label(self, v) +proc get_label*(self: ptr IHTMLOptionElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_label(self, p) +proc put_value*(self: ptr IHTMLOptionElement4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLOptionElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc create*(self: ptr IHTMLOptionElementFactory, text: VARIANT, value: VARIANT, defaultselected: VARIANT, selected: VARIANT, a: ptr ptr IHTMLOptionElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, text, value, defaultselected, selected, a) +proc put_type*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLInputElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_size*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_maxLength*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxLength(self, v) +proc get_maxLength*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxLength(self, p) +proc select*(self: ptr IHTMLInputElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc put_onchange*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_onselect*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_defaultValue*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultValue(self, v) +proc get_defaultValue*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultValue(self, p) +proc put_readOnly*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_readOnly(self, v) +proc get_readOnly*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readOnly(self, p) +proc createTextRange*(self: ptr IHTMLInputElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc put_indeterminate*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_indeterminate(self, v) +proc get_indeterminate*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_indeterminate(self, p) +proc put_defaultChecked*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultChecked(self, v) +proc get_defaultChecked*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultChecked(self, p) +proc put_checked*(self: ptr IHTMLInputElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_checked(self, v) +proc get_checked*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_checked(self, p) +proc put_border*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_vspace*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc put_alt*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_src*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_lowsrc*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lowsrc(self, v) +proc get_lowsrc*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lowsrc(self, p) +proc put_vrml*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vrml(self, v) +proc get_vrml*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vrml(self, p) +proc put_dynsrc*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dynsrc(self, v) +proc get_dynsrc*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dynsrc(self, p) +proc get_readyState*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc get_complete*(self: ptr IHTMLInputElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_complete(self, p) +proc put_loop*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc put_align*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_onload*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onerror*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onabort*(self: ptr IHTMLInputElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLInputElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_width*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLInputElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLInputElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_start*(self: ptr IHTMLInputElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_start(self, v) +proc get_start*(self: ptr IHTMLInputElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_start(self, p) +proc put_accept*(self: ptr IHTMLInputElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accept(self, v) +proc get_accept*(self: ptr IHTMLInputElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accept(self, p) +proc put_useMap*(self: ptr IHTMLInputElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_useMap(self, v) +proc get_useMap*(self: ptr IHTMLInputElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_useMap(self, p) +proc put_src*(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_lowsrc*(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lowsrc(self, v) +proc get_lowsrc*(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lowsrc(self, p) +proc put_vrml*(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vrml(self, v) +proc get_vrml*(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vrml(self, p) +proc put_dynsrc*(self: ptr IHTMLInputElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dynsrc(self, v) +proc get_dynsrc*(self: ptr IHTMLInputElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dynsrc(self, p) +proc get_type*(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLInputButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLInputButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLInputButtonElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLInputButtonElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLInputButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLInputButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc createTextRange*(self: ptr IHTMLInputButtonElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc get_type*(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLInputHiddenElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLInputHiddenElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputHiddenElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLInputHiddenElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLInputHiddenElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLInputHiddenElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputHiddenElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLInputHiddenElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc createTextRange*(self: ptr IHTMLInputHiddenElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc get_type*(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLInputTextElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputTextElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLInputTextElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_defaultValue*(self: ptr IHTMLInputTextElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultValue(self, v) +proc get_defaultValue*(self: ptr IHTMLInputTextElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultValue(self, p) +proc put_size*(self: ptr IHTMLInputTextElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLInputTextElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_maxLength*(self: ptr IHTMLInputTextElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxLength(self, v) +proc get_maxLength*(self: ptr IHTMLInputTextElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxLength(self, p) +proc select*(self: ptr IHTMLInputTextElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc put_onchange*(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_onselect*(self: ptr IHTMLInputTextElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLInputTextElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_readOnly*(self: ptr IHTMLInputTextElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_readOnly(self, v) +proc get_readOnly*(self: ptr IHTMLInputTextElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readOnly(self, p) +proc createTextRange*(self: ptr IHTMLInputTextElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc put_selectionStart*(self: ptr IHTMLInputTextElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectionStart(self, v) +proc get_selectionStart*(self: ptr IHTMLInputTextElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectionStart(self, p) +proc put_selectionEnd*(self: ptr IHTMLInputTextElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectionEnd(self, v) +proc get_selectionEnd*(self: ptr IHTMLInputTextElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectionEnd(self, p) +proc setSelectionRange*(self: ptr IHTMLInputTextElement2, start: LONG, `end`: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setSelectionRange(self, start, `end`) +proc get_type*(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_name*(self: ptr IHTMLInputFileElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLInputFileElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputFileElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLInputFileElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_size*(self: ptr IHTMLInputFileElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLInputFileElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc put_maxLength*(self: ptr IHTMLInputFileElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maxLength(self, v) +proc get_maxLength*(self: ptr IHTMLInputFileElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxLength(self, p) +proc select*(self: ptr IHTMLInputFileElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc put_onchange*(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_onselect*(self: ptr IHTMLInputFileElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLInputFileElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_value*(self: ptr IHTMLInputFileElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputFileElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_value*(self: ptr IHTMLOptionButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc get_type*(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_name*(self: ptr IHTMLOptionButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLOptionButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_checked*(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_checked(self, v) +proc get_checked*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_checked(self, p) +proc put_defaultChecked*(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultChecked(self, v) +proc get_defaultChecked*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultChecked(self, p) +proc put_onchange*(self: ptr IHTMLOptionButtonElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_disabled*(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc put_status*(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_indeterminate*(self: ptr IHTMLOptionButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_indeterminate(self, v) +proc get_indeterminate*(self: ptr IHTMLOptionButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_indeterminate(self, p) +proc get_form*(self: ptr IHTMLOptionButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc get_type*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_disabled*(self: ptr IHTMLInputImage, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputImage, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc put_border*(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_vspace*(self: ptr IHTMLInputImage, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLInputImage, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc put_alt*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_src*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_lowsrc*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lowsrc(self, v) +proc get_lowsrc*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lowsrc(self, p) +proc put_vrml*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vrml(self, v) +proc get_vrml*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vrml(self, p) +proc put_dynsrc*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dynsrc(self, v) +proc get_dynsrc*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dynsrc(self, p) +proc get_readyState*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc get_complete*(self: ptr IHTMLInputImage, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_complete(self, p) +proc put_loop*(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc put_align*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_onload*(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onerror*(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onabort*(self: ptr IHTMLInputImage, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLInputImage, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_name*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_width*(self: ptr IHTMLInputImage, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLInputImage, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLInputImage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_start*(self: ptr IHTMLInputImage, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_start(self, v) +proc get_start*(self: ptr IHTMLInputImage, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_start(self, p) +proc put_disabled*(self: ptr IHTMLInputRangeElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLInputRangeElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_type*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_alt*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_name*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_value*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_min*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_min(self, v) +proc get_min*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_min(self, p) +proc put_max*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_max(self, v) +proc get_max*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_max(self, p) +proc put_step*(self: ptr IHTMLInputRangeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_step(self, v) +proc get_step*(self: ptr IHTMLInputRangeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_step(self, p) +proc put_valueAsNumber*(self: ptr IHTMLInputRangeElement, v: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueAsNumber(self, v) +proc get_valueAsNumber*(self: ptr IHTMLInputRangeElement, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueAsNumber(self, p) +proc stepUp*(self: ptr IHTMLInputRangeElement, n: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stepUp(self, n) +proc stepDown*(self: ptr IHTMLInputRangeElement, n: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stepDown(self, n) +proc get_type*(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLTextAreaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLTextAreaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLTextAreaElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_defaultValue*(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultValue(self, v) +proc get_defaultValue*(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultValue(self, p) +proc select*(self: ptr IHTMLTextAreaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.select(self) +proc put_onchange*(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_onselect*(self: ptr IHTMLTextAreaElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLTextAreaElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_readOnly*(self: ptr IHTMLTextAreaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_readOnly(self, v) +proc get_readOnly*(self: ptr IHTMLTextAreaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readOnly(self, p) +proc put_rows*(self: ptr IHTMLTextAreaElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rows(self, v) +proc get_rows*(self: ptr IHTMLTextAreaElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rows(self, p) +proc put_cols*(self: ptr IHTMLTextAreaElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cols(self, v) +proc get_cols*(self: ptr IHTMLTextAreaElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cols(self, p) +proc put_wrap*(self: ptr IHTMLTextAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_wrap(self, v) +proc get_wrap*(self: ptr IHTMLTextAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wrap(self, p) +proc createTextRange*(self: ptr IHTMLTextAreaElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc put_selectionStart*(self: ptr IHTMLTextAreaElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectionStart(self, v) +proc get_selectionStart*(self: ptr IHTMLTextAreaElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectionStart(self, p) +proc put_selectionEnd*(self: ptr IHTMLTextAreaElement2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectionEnd(self, v) +proc get_selectionEnd*(self: ptr IHTMLTextAreaElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectionEnd(self, p) +proc setSelectionRange*(self: ptr IHTMLTextAreaElement2, start: LONG, `end`: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setSelectionRange(self, start, `end`) +proc get_type*(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_name*(self: ptr IHTMLButtonElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLButtonElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_status*(self: ptr IHTMLButtonElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLButtonElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_disabled*(self: ptr IHTMLButtonElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLButtonElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc get_form*(self: ptr IHTMLButtonElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc createTextRange*(self: ptr IHTMLButtonElement, range: ptr ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextRange(self, range) +proc put_type*(self: ptr IHTMLButtonElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLButtonElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_bgColor*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_scrollDelay*(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollDelay(self, v) +proc get_scrollDelay*(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollDelay(self, p) +proc put_direction*(self: ptr IHTMLMarqueeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_direction(self, v) +proc get_direction*(self: ptr IHTMLMarqueeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc put_behavior*(self: ptr IHTMLMarqueeElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_behavior(self, v) +proc get_behavior*(self: ptr IHTMLMarqueeElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behavior(self, p) +proc put_scrollAmount*(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollAmount(self, v) +proc get_scrollAmount*(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollAmount(self, p) +proc put_loop*(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc put_vspace*(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLMarqueeElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLMarqueeElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc put_onfinish*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfinish(self, v) +proc get_onfinish*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfinish(self, p) +proc put_onstart*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstart(self, v) +proc get_onstart*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstart(self, p) +proc put_onbounce*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbounce(self, v) +proc get_onbounce*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbounce(self, p) +proc put_width*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLMarqueeElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_trueSpeed*(self: ptr IHTMLMarqueeElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_trueSpeed(self, v) +proc get_trueSpeed*(self: ptr IHTMLMarqueeElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_trueSpeed(self, p) +proc start*(self: ptr IHTMLMarqueeElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.start(self) +proc stop*(self: ptr IHTMLMarqueeElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stop(self) +proc put_version*(self: ptr IHTMLHtmlElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_version(self, v) +proc get_version*(self: ptr IHTMLHtmlElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc put_profile*(self: ptr IHTMLHeadElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_profile(self, v) +proc get_profile*(self: ptr IHTMLHeadElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_profile(self, p) +proc put_profile*(self: ptr IHTMLHeadElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_profile(self, v) +proc get_profile*(self: ptr IHTMLHeadElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_profile(self, p) +proc put_text*(self: ptr IHTMLTitleElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLTitleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_httpEquiv*(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_httpEquiv(self, v) +proc get_httpEquiv*(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_httpEquiv(self, p) +proc put_content*(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_content(self, v) +proc get_content*(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_content(self, p) +proc put_name*(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_url*(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_url(self, v) +proc get_url*(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, p) +proc put_charset*(self: ptr IHTMLMetaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, v) +proc get_charset*(self: ptr IHTMLMetaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_scheme*(self: ptr IHTMLMetaElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scheme(self, v) +proc get_scheme*(self: ptr IHTMLMetaElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scheme(self, p) +proc put_url*(self: ptr IHTMLMetaElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_url(self, v) +proc get_url*(self: ptr IHTMLMetaElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, p) +proc put_href*(self: ptr IHTMLBaseElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLBaseElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_target*(self: ptr IHTMLBaseElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_target(self, v) +proc get_target*(self: ptr IHTMLBaseElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_href*(self: ptr IHTMLBaseElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLBaseElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_prompt*(self: ptr IHTMLIsIndexElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_prompt(self, v) +proc get_prompt*(self: ptr IHTMLIsIndexElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_prompt(self, p) +proc put_action*(self: ptr IHTMLIsIndexElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_action(self, v) +proc get_action*(self: ptr IHTMLIsIndexElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_action(self, p) +proc get_form*(self: ptr IHTMLIsIndexElement2, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_n*(self: ptr IHTMLNextIdElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_n(self, v) +proc get_n*(self: ptr IHTMLNextIdElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_n(self, p) +proc put_color*(self: ptr IHTMLBaseFontElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_color(self, v) +proc get_color*(self: ptr IHTMLBaseFontElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_color(self, p) +proc put_face*(self: ptr IHTMLBaseFontElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_face(self, v) +proc get_face*(self: ptr IHTMLBaseFontElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_face(self, p) +proc put_size*(self: ptr IHTMLBaseFontElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_size(self, v) +proc get_size*(self: ptr IHTMLBaseFontElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_size(self, p) +proc get_length*(self: ptr IOmHistory, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc back*(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.back(self, pvargdistance) +proc forward*(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.forward(self, pvargdistance) +proc go*(self: ptr IOmHistory, pvargdistance: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.go(self, pvargdistance) +proc get_length*(self: ptr IHTMLMimeTypesCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_length*(self: ptr IHTMLPluginsCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc refresh*(self: ptr IHTMLPluginsCollection, reload: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.refresh(self, reload) +proc addRequest*(self: ptr IHTMLOpsProfile, name: BSTR, reserved: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addRequest(self, name, reserved, success) +proc clearRequest*(self: ptr IHTMLOpsProfile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearRequest(self) +proc doRequest*(self: ptr IHTMLOpsProfile, usage: VARIANT, fname: VARIANT, domain: VARIANT, path: VARIANT, expire: VARIANT, reserved: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doRequest(self, usage, fname, domain, path, expire, reserved) +proc getAttribute*(self: ptr IHTMLOpsProfile, name: BSTR, value: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, name, value) +proc setAttribute*(self: ptr IHTMLOpsProfile, name: BSTR, value: BSTR, prefs: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, name, value, prefs, success) +proc commitChanges*(self: ptr IHTMLOpsProfile, success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.commitChanges(self, success) +proc addReadRequest*(self: ptr IHTMLOpsProfile, name: BSTR, reserved: VARIANT, success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addReadRequest(self, name, reserved, success) +proc doReadRequest*(self: ptr IHTMLOpsProfile, usage: VARIANT, fname: VARIANT, domain: VARIANT, path: VARIANT, expire: VARIANT, reserved: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doReadRequest(self, usage, fname, domain, path, expire, reserved) +proc doWriteRequest*(self: ptr IHTMLOpsProfile, success: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doWriteRequest(self, success) +proc get_appCodeName*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_appCodeName(self, p) +proc get_appName*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_appName(self, p) +proc get_appVersion*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_appVersion(self, p) +proc get_userAgent*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_userAgent(self, p) +proc javaEnabled*(self: ptr IOmNavigator, enabled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.javaEnabled(self, enabled) +proc taintEnabled*(self: ptr IOmNavigator, enabled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.taintEnabled(self, enabled) +proc get_mimeTypes*(self: ptr IOmNavigator, p: ptr ptr IHTMLMimeTypesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeTypes(self, p) +proc get_plugins*(self: ptr IOmNavigator, p: ptr ptr IHTMLPluginsCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_plugins(self, p) +proc get_cookieEnabled*(self: ptr IOmNavigator, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cookieEnabled(self, p) +proc get_opsProfile*(self: ptr IOmNavigator, p: ptr ptr IHTMLOpsProfile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_opsProfile(self, p) +proc toString*(self: ptr IOmNavigator, string: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, string) +proc get_cpuClass*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cpuClass(self, p) +proc get_systemLanguage*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemLanguage(self, p) +proc get_browserLanguage*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_browserLanguage(self, p) +proc get_userLanguage*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_userLanguage(self, p) +proc get_platform*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_platform(self, p) +proc get_appMinorVersion*(self: ptr IOmNavigator, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_appMinorVersion(self, p) +proc get_connectionSpeed*(self: ptr IOmNavigator, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_connectionSpeed(self, p) +proc get_onLine*(self: ptr IOmNavigator, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onLine(self, p) +proc get_userProfile*(self: ptr IOmNavigator, p: ptr ptr IHTMLOpsProfile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_userProfile(self, p) +proc get_geolocation*(self: ptr INavigatorGeolocation, p: ptr ptr IWebGeolocation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_geolocation(self, p) +proc get_msDoNotTrack*(self: ptr INavigatorDoNotTrack, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msDoNotTrack(self, p) +proc put_href*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_protocol*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_protocol(self, v) +proc get_protocol*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocol(self, p) +proc put_host*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_host(self, v) +proc get_host*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_host(self, p) +proc put_hostname*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hostname(self, v) +proc get_hostname*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hostname(self, p) +proc put_port*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_port(self, v) +proc get_port*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_port(self, p) +proc put_pathname*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pathname(self, v) +proc get_pathname*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathname(self, p) +proc put_search*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_search(self, v) +proc get_search*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_search(self, p) +proc put_hash*(self: ptr IHTMLLocation, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hash(self, v) +proc get_hash*(self: ptr IHTMLLocation, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hash(self, p) +proc reload*(self: ptr IHTMLLocation, flag: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.reload(self, flag) +proc replace*(self: ptr IHTMLLocation, bstr: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replace(self, bstr) +proc assign*(self: ptr IHTMLLocation, bstr: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.assign(self, bstr) +proc toString*(self: ptr IHTMLLocation, string: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, string) +proc get_length*(self: ptr IHTMLBookmarkCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLBookmarkCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLBookmarkCollection, index: LONG, pVarBookmark: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pVarBookmark) +proc setData*(self: ptr IHTMLDataTransfer, format: BSTR, data: ptr VARIANT, pret: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setData(self, format, data, pret) +proc getData*(self: ptr IHTMLDataTransfer, format: BSTR, pvarRet: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getData(self, format, pvarRet) +proc clearData*(self: ptr IHTMLDataTransfer, format: BSTR, pret: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearData(self, format, pret) +proc put_dropEffect*(self: ptr IHTMLDataTransfer, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dropEffect(self, v) +proc get_dropEffect*(self: ptr IHTMLDataTransfer, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dropEffect(self, p) +proc put_effectAllowed*(self: ptr IHTMLDataTransfer, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_effectAllowed(self, v) +proc get_effectAllowed*(self: ptr IHTMLDataTransfer, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_effectAllowed(self, p) +proc get_srcElement*(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcElement(self, p) +proc get_altKey*(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altKey(self, p) +proc get_ctrlKey*(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ctrlKey(self, p) +proc get_shiftKey*(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shiftKey(self, p) +proc put_returnValue*(self: ptr IHTMLEventObj, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_returnValue(self, v) +proc get_returnValue*(self: ptr IHTMLEventObj, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_returnValue(self, p) +proc put_cancelBubble*(self: ptr IHTMLEventObj, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cancelBubble(self, v) +proc get_cancelBubble*(self: ptr IHTMLEventObj, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cancelBubble(self, p) +proc get_fromElement*(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fromElement(self, p) +proc get_toElement*(self: ptr IHTMLEventObj, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_toElement(self, p) +proc put_keyCode*(self: ptr IHTMLEventObj, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_keyCode(self, v) +proc get_keyCode*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_keyCode(self, p) +proc get_button*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_button(self, p) +proc get_type*(self: ptr IHTMLEventObj, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_qualifier*(self: ptr IHTMLEventObj, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_qualifier(self, p) +proc get_reason*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_reason(self, p) +proc get_x*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc get_y*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc get_clientX*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientX(self, p) +proc get_clientY*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientY(self, p) +proc get_offsetX*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetX(self, p) +proc get_offsetY*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetY(self, p) +proc get_screenX*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenX(self, p) +proc get_screenY*(self: ptr IHTMLEventObj, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenY(self, p) +proc get_srcFilter*(self: ptr IHTMLEventObj, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcFilter(self, p) +proc setAttribute*(self: ptr IHTMLEventObj2, strAttributeName: BSTR, AttributeValue: VARIANT, lFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strAttributeName, AttributeValue, lFlags) +proc getAttribute*(self: ptr IHTMLEventObj2, strAttributeName: BSTR, lFlags: LONG, AttributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strAttributeName, lFlags, AttributeValue) +proc removeAttribute*(self: ptr IHTMLEventObj2, strAttributeName: BSTR, lFlags: LONG, pfSuccess: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strAttributeName, lFlags, pfSuccess) +proc put_propertyName*(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_propertyName(self, v) +proc get_propertyName*(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_propertyName(self, p) +proc putref_bookmarks*(self: ptr IHTMLEventObj2, v: ptr IHTMLBookmarkCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_bookmarks(self, v) +proc get_bookmarks*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLBookmarkCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bookmarks(self, p) +proc putref_recordset*(self: ptr IHTMLEventObj2, v: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_recordset(self, v) +proc get_recordset*(self: ptr IHTMLEventObj2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_recordset(self, p) +proc put_dataFld*(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataFld(self, v) +proc get_dataFld*(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataFld(self, p) +proc putref_boundElements*(self: ptr IHTMLEventObj2, v: ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_boundElements(self, v) +proc get_boundElements*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_boundElements(self, p) +proc put_repeat*(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_repeat(self, v) +proc get_repeat*(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_repeat(self, p) +proc put_srcUrn*(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_srcUrn(self, v) +proc get_srcUrn*(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcUrn(self, p) +proc putref_srcElement*(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_srcElement(self, v) +proc get_srcElement*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcElement(self, p) +proc put_altKey*(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_altKey(self, v) +proc get_altKey*(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altKey(self, p) +proc put_ctrlKey*(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ctrlKey(self, v) +proc get_ctrlKey*(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ctrlKey(self, p) +proc put_shiftKey*(self: ptr IHTMLEventObj2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shiftKey(self, v) +proc get_shiftKey*(self: ptr IHTMLEventObj2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shiftKey(self, p) +proc putref_fromElement*(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_fromElement(self, v) +proc get_fromElement*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fromElement(self, p) +proc putref_toElement*(self: ptr IHTMLEventObj2, v: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_toElement(self, v) +proc get_toElement*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_toElement(self, p) +proc put_button*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_button(self, v) +proc get_button*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_button(self, p) +proc put_type*(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_qualifier*(self: ptr IHTMLEventObj2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_qualifier(self, v) +proc get_qualifier*(self: ptr IHTMLEventObj2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_qualifier(self, p) +proc put_reason*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_reason(self, v) +proc get_reason*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_reason(self, p) +proc put_x*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_clientX*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clientX(self, v) +proc get_clientX*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientX(self, p) +proc put_clientY*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_clientY(self, v) +proc get_clientY*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientY(self, p) +proc put_offsetX*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_offsetX(self, v) +proc get_offsetX*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetX(self, p) +proc put_offsetY*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_offsetY(self, v) +proc get_offsetY*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetY(self, p) +proc put_screenX*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_screenX(self, v) +proc get_screenX*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenX(self, p) +proc put_screenY*(self: ptr IHTMLEventObj2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_screenY(self, v) +proc get_screenY*(self: ptr IHTMLEventObj2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenY(self, p) +proc putref_srcFilter*(self: ptr IHTMLEventObj2, v: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_srcFilter(self, v) +proc get_srcFilter*(self: ptr IHTMLEventObj2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcFilter(self, p) +proc get_dataTransfer*(self: ptr IHTMLEventObj2, p: ptr ptr IHTMLDataTransfer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataTransfer(self, p) +proc get_contentOverflow*(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentOverflow(self, p) +proc put_shiftLeft*(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shiftLeft(self, v) +proc get_shiftLeft*(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shiftLeft(self, p) +proc put_altLeft*(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_altLeft(self, v) +proc get_altLeft*(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altLeft(self, p) +proc put_ctrlLeft*(self: ptr IHTMLEventObj3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ctrlLeft(self, v) +proc get_ctrlLeft*(self: ptr IHTMLEventObj3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ctrlLeft(self, p) +proc get_imeCompositionChange*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeCompositionChange(self, p) +proc get_imeNotifyCommand*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeNotifyCommand(self, p) +proc get_imeNotifyData*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeNotifyData(self, p) +proc get_imeRequest*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeRequest(self, p) +proc get_imeRequestData*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_imeRequestData(self, p) +proc get_keyboardLayout*(self: ptr IHTMLEventObj3, p: ptr LONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_keyboardLayout(self, p) +proc get_behaviorCookie*(self: ptr IHTMLEventObj3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behaviorCookie(self, p) +proc get_behaviorPart*(self: ptr IHTMLEventObj3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_behaviorPart(self, p) +proc get_nextPage*(self: ptr IHTMLEventObj3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextPage(self, p) +proc get_wheelDelta*(self: ptr IHTMLEventObj4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wheelDelta(self, p) +proc put_url*(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_url(self, v) +proc get_url*(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, p) +proc put_data*(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_source*(self: ptr IHTMLEventObj5, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_source(self, p) +proc put_origin*(self: ptr IHTMLEventObj5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_origin(self, v) +proc get_origin*(self: ptr IHTMLEventObj5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_origin(self, p) +proc put_issession*(self: ptr IHTMLEventObj5, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_issession(self, v) +proc get_issession*(self: ptr IHTMLEventObj5, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_issession(self, p) +proc get_actionURL*(self: ptr IHTMLEventObj6, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_actionURL(self, p) +proc get_buttonID*(self: ptr IHTMLEventObj6, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_buttonID(self, p) +proc get_type*(self: ptr IHTMLStyleMedia, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc matchMedium*(self: ptr IHTMLStyleMedia, mediaQuery: BSTR, matches: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.matchMedium(self, mediaQuery, matches) +proc item*(self: ptr IHTMLFramesCollection2, pvarIndex: ptr VARIANT, pvarResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, pvarIndex, pvarResult) +proc get_length*(self: ptr IHTMLFramesCollection2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_colorDepth*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_colorDepth(self, p) +proc put_bufferDepth*(self: ptr IHTMLScreen, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bufferDepth(self, v) +proc get_bufferDepth*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bufferDepth(self, p) +proc get_width*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_height*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_updateInterval*(self: ptr IHTMLScreen, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_updateInterval(self, v) +proc get_updateInterval*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_updateInterval(self, p) +proc get_availHeight*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_availHeight(self, p) +proc get_availWidth*(self: ptr IHTMLScreen, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_availWidth(self, p) +proc get_fontSmoothingEnabled*(self: ptr IHTMLScreen, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSmoothingEnabled(self, p) +proc get_logicalXDPI*(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_logicalXDPI(self, p) +proc get_logicalYDPI*(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_logicalYDPI(self, p) +proc get_deviceXDPI*(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deviceXDPI(self, p) +proc get_deviceYDPI*(self: ptr IHTMLScreen2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deviceYDPI(self, p) +proc get_systemXDPI*(self: ptr IHTMLScreen3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemXDPI(self, p) +proc get_systemYDPI*(self: ptr IHTMLScreen3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemYDPI(self, p) +proc get_pixelDepth*(self: ptr IHTMLScreen4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelDepth(self, p) +proc get_frames*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLFramesCollection2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frames(self, p) +proc put_defaultStatus*(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultStatus(self, v) +proc get_defaultStatus*(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultStatus(self, p) +proc put_status*(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc setTimeout*(self: ptr IHTMLWindow2, expression: BSTR, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setTimeout(self, expression, msec, language, timerID) +proc clearTimeout*(self: ptr IHTMLWindow2, timerID: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearTimeout(self, timerID) +proc alert*(self: ptr IHTMLWindow2, message: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.alert(self, message) +proc confirm*(self: ptr IHTMLWindow2, message: BSTR, confirmed: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.confirm(self, message, confirmed) +proc prompt*(self: ptr IHTMLWindow2, message: BSTR, defstr: BSTR, textdata: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.prompt(self, message, defstr, textdata) +proc get_Image*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLImageElementFactory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Image(self, p) +proc get_location*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLLocation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_location(self, p) +proc get_history*(self: ptr IHTMLWindow2, p: ptr ptr IOmHistory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_history(self, p) +proc close*(self: ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.close(self) +proc put_opener*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_opener(self, v) +proc get_opener*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_opener(self, p) +proc get_navigator*(self: ptr IHTMLWindow2, p: ptr ptr IOmNavigator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_navigator(self, p) +proc put_name*(self: ptr IHTMLWindow2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLWindow2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_parent*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parent(self, p) +proc open*(self: ptr IHTMLWindow2, url: BSTR, name: BSTR, features: BSTR, replace: VARIANT_BOOL, pomWindowResult: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.open(self, url, name, features, replace, pomWindowResult) +proc get_self*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_self(self, p) +proc get_top*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_top(self, p) +proc get_window*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_window(self, p) +proc navigate*(self: ptr IHTMLWindow2, url: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.navigate(self, url) +proc put_onfocus*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_onblur*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_onload*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onbeforeunload*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeunload(self, v) +proc get_onbeforeunload*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeunload(self, p) +proc put_onunload*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onunload(self, v) +proc get_onunload*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onunload(self, p) +proc put_onhelp*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhelp(self, v) +proc get_onhelp*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhelp(self, p) +proc put_onerror*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onresize*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onresize(self, v) +proc get_onresize*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onresize(self, p) +proc put_onscroll*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onscroll(self, v) +proc get_onscroll*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onscroll(self, p) +proc get_document*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc get_event*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_event(self, p) +proc get_newEnum*(self: ptr IHTMLWindow2, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc showModalDialog*(self: ptr IHTMLWindow2, dialog: BSTR, varArgIn: ptr VARIANT, varOptions: ptr VARIANT, varArgOut: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showModalDialog(self, dialog, varArgIn, varOptions, varArgOut) +proc showHelp*(self: ptr IHTMLWindow2, helpURL: BSTR, helpArg: VARIANT, features: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showHelp(self, helpURL, helpArg, features) +proc get_screen*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLScreen): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screen(self, p) +proc get_Option*(self: ptr IHTMLWindow2, p: ptr ptr IHTMLOptionElementFactory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Option(self, p) +proc focus*(self: ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc get_closed*(self: ptr IHTMLWindow2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_closed(self, p) +proc blur*(self: ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.blur(self) +proc scroll*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scroll(self, x, y) +proc get_clientInformation*(self: ptr IHTMLWindow2, p: ptr ptr IOmNavigator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientInformation(self, p) +proc setInterval*(self: ptr IHTMLWindow2, expression: BSTR, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setInterval(self, expression, msec, language, timerID) +proc clearInterval*(self: ptr IHTMLWindow2, timerID: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearInterval(self, timerID) +proc put_offscreenBuffering*(self: ptr IHTMLWindow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_offscreenBuffering(self, v) +proc get_offscreenBuffering*(self: ptr IHTMLWindow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offscreenBuffering(self, p) +proc execScript*(self: ptr IHTMLWindow2, code: BSTR, language: BSTR, pvarRet: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execScript(self, code, language, pvarRet) +proc toString*(self: ptr IHTMLWindow2, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc scrollBy*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scrollBy(self, x, y) +proc scrollTo*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scrollTo(self, x, y) +proc moveTo*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveTo(self, x, y) +proc moveBy*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveBy(self, x, y) +proc resizeTo*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.resizeTo(self, x, y) +proc resizeBy*(self: ptr IHTMLWindow2, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.resizeBy(self, x, y) +proc get_external*(self: ptr IHTMLWindow2, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_external(self, p) +proc get_screenLeft*(self: ptr IHTMLWindow3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenLeft(self, p) +proc get_screenTop*(self: ptr IHTMLWindow3, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenTop(self, p) +proc attachEvent*(self: ptr IHTMLWindow3, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.attachEvent(self, event, pDisp, pfResult) +proc detachEvent*(self: ptr IHTMLWindow3, event: BSTR, pDisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detachEvent(self, event, pDisp) +proc setTimeout*(self: ptr IHTMLWindow3, expression: ptr VARIANT, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setTimeout(self, expression, msec, language, timerID) +proc setInterval*(self: ptr IHTMLWindow3, expression: ptr VARIANT, msec: LONG, language: ptr VARIANT, timerID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setInterval(self, expression, msec, language, timerID) +proc print*(self: ptr IHTMLWindow3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.print(self) +proc put_onbeforeprint*(self: ptr IHTMLWindow3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeprint(self, v) +proc get_onbeforeprint*(self: ptr IHTMLWindow3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeprint(self, p) +proc put_onafterprint*(self: ptr IHTMLWindow3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onafterprint(self, v) +proc get_onafterprint*(self: ptr IHTMLWindow3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onafterprint(self, p) +proc get_clipboardData*(self: ptr IHTMLWindow3, p: ptr ptr IHTMLDataTransfer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipboardData(self, p) +proc showModelessDialog*(self: ptr IHTMLWindow3, url: BSTR, varArgIn: ptr VARIANT, options: ptr VARIANT, pDialog: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showModelessDialog(self, url, varArgIn, options, pDialog) +proc createPopup*(self: ptr IHTMLWindow4, varArgIn: ptr VARIANT, ppPopup: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createPopup(self, varArgIn, ppPopup) +proc get_frameElement*(self: ptr IHTMLWindow4, p: ptr ptr IHTMLFrameBase): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameElement(self, p) +proc put_XMLHttpRequest*(self: ptr IHTMLWindow5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_XMLHttpRequest(self, v) +proc get_XMLHttpRequest*(self: ptr IHTMLWindow5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_XMLHttpRequest(self, p) +proc put_XDomainRequest*(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_XDomainRequest(self, v) +proc get_XDomainRequest*(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_XDomainRequest(self, p) +proc get_sessionStorage*(self: ptr IHTMLWindow6, p: ptr ptr IHTMLStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sessionStorage(self, p) +proc get_localStorage*(self: ptr IHTMLWindow6, p: ptr ptr IHTMLStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_localStorage(self, p) +proc put_onhashchange*(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhashchange(self, v) +proc get_onhashchange*(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhashchange(self, p) +proc get_maxConnectionsPerServer*(self: ptr IHTMLWindow6, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maxConnectionsPerServer(self, p) +proc postMessage*(self: ptr IHTMLWindow6, msg: BSTR, targetOrigin: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.postMessage(self, msg, targetOrigin) +proc toStaticHTML*(self: ptr IHTMLWindow6, bstrHTML: BSTR, pbstrStaticHTML: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toStaticHTML(self, bstrHTML, pbstrStaticHTML) +proc put_onmessage*(self: ptr IHTMLWindow6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmessage(self, v) +proc get_onmessage*(self: ptr IHTMLWindow6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmessage(self, p) +proc msWriteProfilerMark*(self: ptr IHTMLWindow6, bstrProfilerMarkName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.msWriteProfilerMark(self, bstrProfilerMarkName) +proc getSelection*(self: ptr IHTMLWindow7, ppIHTMLSelection: ptr ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getSelection(self, ppIHTMLSelection) +proc getComputedStyle*(self: ptr IHTMLWindow7, varArgIn: ptr IHTMLDOMNode, bstrPseudoElt: BSTR, ppComputedStyle: ptr ptr IHTMLCSSStyleDeclaration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getComputedStyle(self, varArgIn, bstrPseudoElt, ppComputedStyle) +proc get_styleMedia*(self: ptr IHTMLWindow7, p: ptr ptr IHTMLStyleMedia): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleMedia(self, p) +proc put_performance*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_performance(self, v) +proc get_performance*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_performance(self, p) +proc get_innerWidth*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_innerWidth(self, p) +proc get_innerHeight*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_innerHeight(self, p) +proc get_pageXOffset*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageXOffset(self, p) +proc get_pageYOffset*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageYOffset(self, p) +proc get_screenX*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenX(self, p) +proc get_screenY*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenY(self, p) +proc get_outerWidth*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outerWidth(self, p) +proc get_outerHeight*(self: ptr IHTMLWindow7, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_outerHeight(self, p) +proc put_onabort*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_oncanplay*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplay(self, v) +proc get_oncanplay*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplay(self, p) +proc put_oncanplaythrough*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplaythrough(self, v) +proc get_oncanplaythrough*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplaythrough(self, p) +proc put_onchange*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_onclick*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onclick(self, v) +proc get_onclick*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onclick(self, p) +proc put_oncontextmenu*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncontextmenu(self, v) +proc get_oncontextmenu*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncontextmenu(self, p) +proc put_ondblclick*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondblclick(self, v) +proc get_ondblclick*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondblclick(self, p) +proc put_ondrag*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrag(self, v) +proc get_ondrag*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrag(self, p) +proc put_ondragend*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragend(self, v) +proc get_ondragend*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragend(self, p) +proc put_ondragenter*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragenter(self, v) +proc get_ondragenter*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragenter(self, p) +proc put_ondragleave*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragleave(self, v) +proc get_ondragleave*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragleave(self, p) +proc put_ondragover*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragover(self, v) +proc get_ondragover*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragover(self, p) +proc put_ondragstart*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragstart(self, v) +proc get_ondragstart*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragstart(self, p) +proc put_ondrop*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrop(self, v) +proc get_ondrop*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrop(self, p) +proc put_ondurationchange*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondurationchange(self, v) +proc get_ondurationchange*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondurationchange(self, p) +proc put_onfocusin*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusin(self, v) +proc get_onfocusin*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusin(self, p) +proc put_onfocusout*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusout(self, v) +proc get_onfocusout*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusout(self, p) +proc put_oninput*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oninput(self, v) +proc get_oninput*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oninput(self, p) +proc put_onemptied*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onemptied(self, v) +proc get_onemptied*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onemptied(self, p) +proc put_onended*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onended(self, v) +proc get_onended*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onended(self, p) +proc put_onkeydown*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeydown(self, v) +proc get_onkeydown*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeydown(self, p) +proc put_onkeypress*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeypress(self, v) +proc get_onkeypress*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeypress(self, p) +proc put_onkeyup*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeyup(self, v) +proc get_onkeyup*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeyup(self, p) +proc put_onloadeddata*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadeddata(self, v) +proc get_onloadeddata*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadeddata(self, p) +proc put_onloadedmetadata*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadedmetadata(self, v) +proc get_onloadedmetadata*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadedmetadata(self, p) +proc put_onloadstart*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadstart(self, v) +proc get_onloadstart*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadstart(self, p) +proc put_onmousedown*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousedown(self, v) +proc get_onmousedown*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousedown(self, p) +proc put_onmouseenter*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseenter(self, v) +proc get_onmouseenter*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseenter(self, p) +proc put_onmouseleave*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseleave(self, v) +proc get_onmouseleave*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseleave(self, p) +proc put_onmousemove*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousemove(self, v) +proc get_onmousemove*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousemove(self, p) +proc put_onmouseout*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseout(self, v) +proc get_onmouseout*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseout(self, p) +proc put_onmouseover*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseover(self, v) +proc get_onmouseover*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseover(self, p) +proc put_onmouseup*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseup(self, v) +proc get_onmouseup*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseup(self, p) +proc put_onmousewheel*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousewheel(self, v) +proc get_onmousewheel*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousewheel(self, p) +proc put_onoffline*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onoffline(self, v) +proc get_onoffline*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onoffline(self, p) +proc put_ononline*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ononline(self, v) +proc get_ononline*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ononline(self, p) +proc put_onprogress*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onprogress(self, v) +proc get_onprogress*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onprogress(self, p) +proc put_onratechange*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onratechange(self, v) +proc get_onratechange*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onratechange(self, p) +proc put_onreadystatechange*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onreset*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreset(self, v) +proc get_onreset*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreset(self, p) +proc put_onseeked*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeked(self, v) +proc get_onseeked*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeked(self, p) +proc put_onseeking*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeking(self, v) +proc get_onseeking*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeking(self, p) +proc put_onselect*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_onstalled*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstalled(self, v) +proc get_onstalled*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstalled(self, p) +proc put_onstorage*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstorage(self, v) +proc get_onstorage*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstorage(self, p) +proc put_onsubmit*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsubmit(self, v) +proc get_onsubmit*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsubmit(self, p) +proc put_onsuspend*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsuspend(self, v) +proc get_onsuspend*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsuspend(self, p) +proc put_ontimeupdate*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontimeupdate(self, v) +proc get_ontimeupdate*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ontimeupdate(self, p) +proc put_onpause*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpause(self, v) +proc get_onpause*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpause(self, p) +proc put_onplay*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplay(self, v) +proc get_onplay*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplay(self, p) +proc put_onplaying*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplaying(self, v) +proc get_onplaying*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplaying(self, p) +proc put_onvolumechange*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onvolumechange(self, v) +proc get_onvolumechange*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onvolumechange(self, p) +proc put_onwaiting*(self: ptr IHTMLWindow7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onwaiting(self, v) +proc get_onwaiting*(self: ptr IHTMLWindow7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onwaiting(self, p) +proc put_onmspointerdown*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerdown(self, v) +proc get_onmspointerdown*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerdown(self, p) +proc put_onmspointermove*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointermove(self, v) +proc get_onmspointermove*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointermove(self, p) +proc put_onmspointerup*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerup(self, v) +proc get_onmspointerup*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerup(self, p) +proc put_onmspointerover*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerover(self, v) +proc get_onmspointerover*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerover(self, p) +proc put_onmspointerout*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerout(self, v) +proc get_onmspointerout*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerout(self, p) +proc put_onmspointercancel*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointercancel(self, v) +proc get_onmspointercancel*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointercancel(self, p) +proc put_onmspointerhover*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerhover(self, v) +proc get_onmspointerhover*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerhover(self, p) +proc put_onmsgesturestart*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturestart(self, v) +proc get_onmsgesturestart*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturestart(self, p) +proc put_onmsgesturechange*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturechange(self, v) +proc get_onmsgesturechange*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturechange(self, p) +proc put_onmsgestureend*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgestureend(self, v) +proc get_onmsgestureend*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgestureend(self, p) +proc put_onmsgesturehold*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturehold(self, v) +proc get_onmsgesturehold*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturehold(self, p) +proc put_onmsgesturetap*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturetap(self, v) +proc get_onmsgesturetap*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturetap(self, p) +proc put_onmsgesturedoubletap*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturedoubletap(self, v) +proc get_onmsgesturedoubletap*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturedoubletap(self, p) +proc put_onmsinertiastart*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsinertiastart(self, v) +proc get_onmsinertiastart*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsinertiastart(self, p) +proc get_applicationCache*(self: ptr IHTMLWindow8, p: ptr ptr IHTMLApplicationCache): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_applicationCache(self, p) +proc put_onpopstate*(self: ptr IHTMLWindow8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpopstate(self, v) +proc get_onpopstate*(self: ptr IHTMLWindow8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpopstate(self, p) +proc get_userAgent*(self: ptr IHTMLDocumentCompatibleInfo, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_userAgent(self, p) +proc get_version*(self: ptr IHTMLDocumentCompatibleInfo, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc get_length*(self: ptr IHTMLDocumentCompatibleInfoCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLDocumentCompatibleInfoCollection, index: LONG, compatibleInfo: ptr ptr IHTMLDocumentCompatibleInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, compatibleInfo) +proc get_Script*(self: ptr IHTMLDocument, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Script(self, p) +proc get_all*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_all(self, p) +proc get_body*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_body(self, p) +proc get_activeElement*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_activeElement(self, p) +proc get_images*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_images(self, p) +proc get_applets*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_applets(self, p) +proc get_links*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_links(self, p) +proc get_forms*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_forms(self, p) +proc get_anchors*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_anchors(self, p) +proc put_title*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_title(self, v) +proc get_title*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_title(self, p) +proc get_scripts*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scripts(self, p) +proc put_designMode*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_designMode(self, v) +proc get_designMode*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_designMode(self, p) +proc get_selection*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLSelectionObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selection(self, p) +proc get_readyState*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc get_frames*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLFramesCollection2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frames(self, p) +proc get_embeds*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_embeds(self, p) +proc get_plugins*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_plugins(self, p) +proc put_alinkColor*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alinkColor(self, v) +proc get_alinkColor*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alinkColor(self, p) +proc put_bgColor*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_fgColor*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fgColor(self, v) +proc get_fgColor*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fgColor(self, p) +proc put_linkColor*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_linkColor(self, v) +proc get_linkColor*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_linkColor(self, p) +proc put_vlinkColor*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vlinkColor(self, v) +proc get_vlinkColor*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vlinkColor(self, p) +proc get_referrer*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_referrer(self, p) +proc get_location*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLLocation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_location(self, p) +proc get_lastModified*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastModified(self, p) +proc put_URL*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_URL(self, v) +proc get_URL*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URL(self, p) +proc put_domain*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_domain(self, v) +proc get_domain*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domain(self, p) +proc put_cookie*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cookie(self, v) +proc get_cookie*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cookie(self, p) +proc put_expando*(self: ptr IHTMLDocument2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_expando(self, v) +proc get_expando*(self: ptr IHTMLDocument2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_expando(self, p) +proc put_charset*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, v) +proc get_charset*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_defaultCharset*(self: ptr IHTMLDocument2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultCharset(self, v) +proc get_defaultCharset*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultCharset(self, p) +proc get_mimeType*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeType(self, p) +proc get_fileSize*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileSize(self, p) +proc get_fileCreatedDate*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileCreatedDate(self, p) +proc get_fileModifiedDate*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileModifiedDate(self, p) +proc get_fileUpdatedDate*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileUpdatedDate(self, p) +proc get_security*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_security(self, p) +proc get_protocol*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocol(self, p) +proc get_nameProp*(self: ptr IHTMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nameProp(self, p) +proc write*(self: ptr IHTMLDocument2, psarray: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.write(self, psarray) +proc writeln*(self: ptr IHTMLDocument2, psarray: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.writeln(self, psarray) +proc open*(self: ptr IHTMLDocument2, url: BSTR, name: VARIANT, features: VARIANT, replace: VARIANT, pomWindowResult: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.open(self, url, name, features, replace, pomWindowResult) +proc close*(self: ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.close(self) +proc clear*(self: ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc queryCommandSupported*(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandSupported(self, cmdID, pfRet) +proc queryCommandEnabled*(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandEnabled(self, cmdID, pfRet) +proc queryCommandState*(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandState(self, cmdID, pfRet) +proc queryCommandIndeterm*(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandIndeterm(self, cmdID, pfRet) +proc queryCommandText*(self: ptr IHTMLDocument2, cmdID: BSTR, pcmdText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandText(self, cmdID, pcmdText) +proc queryCommandValue*(self: ptr IHTMLDocument2, cmdID: BSTR, pcmdValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.queryCommandValue(self, cmdID, pcmdValue) +proc execCommand*(self: ptr IHTMLDocument2, cmdID: BSTR, showUI: VARIANT_BOOL, value: VARIANT, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommand(self, cmdID, showUI, value, pfRet) +proc execCommandShowHelp*(self: ptr IHTMLDocument2, cmdID: BSTR, pfRet: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.execCommandShowHelp(self, cmdID, pfRet) +proc createElement*(self: ptr IHTMLDocument2, eTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElement(self, eTag, newElem) +proc put_onhelp*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhelp(self, v) +proc get_onhelp*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhelp(self, p) +proc put_onclick*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onclick(self, v) +proc get_onclick*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onclick(self, p) +proc put_ondblclick*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondblclick(self, v) +proc get_ondblclick*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondblclick(self, p) +proc put_onkeyup*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeyup(self, v) +proc get_onkeyup*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeyup(self, p) +proc put_onkeydown*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeydown(self, v) +proc get_onkeydown*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeydown(self, p) +proc put_onkeypress*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onkeypress(self, v) +proc get_onkeypress*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onkeypress(self, p) +proc put_onmouseup*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseup(self, v) +proc get_onmouseup*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseup(self, p) +proc put_onmousedown*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousedown(self, v) +proc get_onmousedown*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousedown(self, p) +proc put_onmousemove*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousemove(self, v) +proc get_onmousemove*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousemove(self, p) +proc put_onmouseout*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseout(self, v) +proc get_onmouseout*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseout(self, p) +proc put_onmouseover*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmouseover(self, v) +proc get_onmouseover*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmouseover(self, p) +proc put_onreadystatechange*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onafterupdate*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onafterupdate(self, v) +proc get_onafterupdate*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onafterupdate(self, p) +proc put_onrowexit*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowexit(self, v) +proc get_onrowexit*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowexit(self, p) +proc put_onrowenter*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowenter(self, v) +proc get_onrowenter*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowenter(self, p) +proc put_ondragstart*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragstart(self, v) +proc get_ondragstart*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragstart(self, p) +proc put_onselectstart*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselectstart(self, v) +proc get_onselectstart*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselectstart(self, p) +proc elementFromPoint*(self: ptr IHTMLDocument2, x: LONG, y: LONG, elementHit: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.elementFromPoint(self, x, y, elementHit) +proc get_parentWindow*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentWindow(self, p) +proc get_styleSheets*(self: ptr IHTMLDocument2, p: ptr ptr IHTMLStyleSheetsCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleSheets(self, p) +proc put_onbeforeupdate*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeupdate(self, v) +proc get_onbeforeupdate*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeupdate(self, p) +proc put_onerrorupdate*(self: ptr IHTMLDocument2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerrorupdate(self, v) +proc get_onerrorupdate*(self: ptr IHTMLDocument2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerrorupdate(self, p) +proc toString*(self: ptr IHTMLDocument2, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc createStyleSheet*(self: ptr IHTMLDocument2, bstrHref: BSTR, lIndex: LONG, ppnewStyleSheet: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createStyleSheet(self, bstrHref, lIndex, ppnewStyleSheet) +proc releaseCapture*(self: ptr IHTMLDocument3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.releaseCapture(self) +proc recalc*(self: ptr IHTMLDocument3, fForce: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.recalc(self, fForce) +proc createTextNode*(self: ptr IHTMLDocument3, text: BSTR, newTextNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextNode(self, text, newTextNode) +proc get_documentElement*(self: ptr IHTMLDocument3, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_documentElement(self, p) +proc get_uniqueID*(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_uniqueID(self, p) +proc attachEvent*(self: ptr IHTMLDocument3, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.attachEvent(self, event, pDisp, pfResult) +proc detachEvent*(self: ptr IHTMLDocument3, event: BSTR, pDisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detachEvent(self, event, pDisp) +proc put_onrowsdelete*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowsdelete(self, v) +proc get_onrowsdelete*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowsdelete(self, p) +proc put_onrowsinserted*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onrowsinserted(self, v) +proc get_onrowsinserted*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onrowsinserted(self, p) +proc put_oncellchange*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncellchange(self, v) +proc get_oncellchange*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncellchange(self, p) +proc put_ondatasetchanged*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondatasetchanged(self, v) +proc get_ondatasetchanged*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondatasetchanged(self, p) +proc put_ondataavailable*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondataavailable(self, v) +proc get_ondataavailable*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondataavailable(self, p) +proc put_ondatasetcomplete*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondatasetcomplete(self, v) +proc get_ondatasetcomplete*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondatasetcomplete(self, p) +proc put_onpropertychange*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpropertychange(self, v) +proc get_onpropertychange*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpropertychange(self, p) +proc put_dir*(self: ptr IHTMLDocument3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dir(self, v) +proc get_dir*(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dir(self, p) +proc put_oncontextmenu*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncontextmenu(self, v) +proc get_oncontextmenu*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncontextmenu(self, p) +proc put_onstop*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstop(self, v) +proc get_onstop*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstop(self, p) +proc createDocumentFragment*(self: ptr IHTMLDocument3, pNewDoc: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createDocumentFragment(self, pNewDoc) +proc get_parentDocument*(self: ptr IHTMLDocument3, p: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentDocument(self, p) +proc put_enableDownload*(self: ptr IHTMLDocument3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_enableDownload(self, v) +proc get_enableDownload*(self: ptr IHTMLDocument3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_enableDownload(self, p) +proc put_baseUrl*(self: ptr IHTMLDocument3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseUrl(self, v) +proc get_baseUrl*(self: ptr IHTMLDocument3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseUrl(self, p) +proc get_childNodes*(self: ptr IHTMLDocument3, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, p) +proc put_inheritStyleSheets*(self: ptr IHTMLDocument3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_inheritStyleSheets(self, v) +proc get_inheritStyleSheets*(self: ptr IHTMLDocument3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_inheritStyleSheets(self, p) +proc put_onbeforeeditfocus*(self: ptr IHTMLDocument3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeeditfocus(self, v) +proc get_onbeforeeditfocus*(self: ptr IHTMLDocument3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeeditfocus(self, p) +proc getElementsByName*(self: ptr IHTMLDocument3, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByName(self, v, pelColl) +proc getElementById*(self: ptr IHTMLDocument3, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementById(self, v, pel) +proc getElementsByTagName*(self: ptr IHTMLDocument3, v: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagName(self, v, pelColl) +proc focus*(self: ptr IHTMLDocument4): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc hasFocus*(self: ptr IHTMLDocument4, pfFocus: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasFocus(self, pfFocus) +proc put_onselectionchange*(self: ptr IHTMLDocument4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselectionchange(self, v) +proc get_onselectionchange*(self: ptr IHTMLDocument4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselectionchange(self, p) +proc get_namespaces*(self: ptr IHTMLDocument4, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_namespaces(self, p) +proc createDocumentFromUrl*(self: ptr IHTMLDocument4, bstrUrl: BSTR, bstrOptions: BSTR, newDoc: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createDocumentFromUrl(self, bstrUrl, bstrOptions, newDoc) +proc put_media*(self: ptr IHTMLDocument4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLDocument4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc createEventObject*(self: ptr IHTMLDocument4, pvarEventObject: ptr VARIANT, ppEventObj: ptr ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createEventObject(self, pvarEventObject, ppEventObj) +proc fireEvent*(self: ptr IHTMLDocument4, bstrEventName: BSTR, pvarEventObject: ptr VARIANT, pfCancelled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fireEvent(self, bstrEventName, pvarEventObject, pfCancelled) +proc createRenderStyle*(self: ptr IHTMLDocument4, v: BSTR, ppIHTMLRenderStyle: ptr ptr IHTMLRenderStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createRenderStyle(self, v, ppIHTMLRenderStyle) +proc put_oncontrolselect*(self: ptr IHTMLDocument4, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncontrolselect(self, v) +proc get_oncontrolselect*(self: ptr IHTMLDocument4, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncontrolselect(self, p) +proc get_URLUnencoded*(self: ptr IHTMLDocument4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URLUnencoded(self, p) +proc put_onmousewheel*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmousewheel(self, v) +proc get_onmousewheel*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmousewheel(self, p) +proc get_doctype*(self: ptr IHTMLDocument5, p: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_doctype(self, p) +proc get_implementation*(self: ptr IHTMLDocument5, p: ptr ptr IHTMLDOMImplementation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_implementation(self, p) +proc createAttribute*(self: ptr IHTMLDocument5, bstrattrName: BSTR, ppattribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createAttribute(self, bstrattrName, ppattribute) +proc createComment*(self: ptr IHTMLDocument5, bstrdata: BSTR, ppRetNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createComment(self, bstrdata, ppRetNode) +proc put_onfocusin*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusin(self, v) +proc get_onfocusin*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusin(self, p) +proc put_onfocusout*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocusout(self, v) +proc get_onfocusout*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocusout(self, p) +proc put_onactivate*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onactivate(self, v) +proc get_onactivate*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onactivate(self, p) +proc put_ondeactivate*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondeactivate(self, v) +proc get_ondeactivate*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondeactivate(self, p) +proc put_onbeforeactivate*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeactivate(self, v) +proc get_onbeforeactivate*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeactivate(self, p) +proc put_onbeforedeactivate*(self: ptr IHTMLDocument5, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforedeactivate(self, v) +proc get_onbeforedeactivate*(self: ptr IHTMLDocument5, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforedeactivate(self, p) +proc get_compatMode*(self: ptr IHTMLDocument5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compatMode(self, p) +proc get_compatible*(self: ptr IHTMLDocument6, p: ptr ptr IHTMLDocumentCompatibleInfoCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_compatible(self, p) +proc get_documentMode*(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_documentMode(self, p) +proc put_onstorage*(self: ptr IHTMLDocument6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstorage(self, v) +proc get_onstorage*(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstorage(self, p) +proc put_onstoragecommit*(self: ptr IHTMLDocument6, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstoragecommit(self, v) +proc get_onstoragecommit*(self: ptr IHTMLDocument6, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstoragecommit(self, p) +proc getElementById*(self: ptr IHTMLDocument6, bstrId: BSTR, ppRetElement: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementById(self, bstrId, ppRetElement) +proc updateSettings*(self: ptr IHTMLDocument6): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.updateSettings(self) +proc get_defaultView*(self: ptr IHTMLDocument7, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultView(self, p) +proc createCDATASection*(self: ptr IHTMLDocument7, text: BSTR, newCDATASectionNode: ptr ptr IHTMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createCDATASection(self, text, newCDATASectionNode) +proc getSelection*(self: ptr IHTMLDocument7, ppIHTMLSelection: ptr ptr IHTMLSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getSelection(self, ppIHTMLSelection) +proc getElementsByTagNameNS*(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrLocalName: BSTR, pelColl: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagNameNS(self, pvarNS, bstrLocalName, pelColl) +proc createElementNS*(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElementNS(self, pvarNS, bstrTag, newElem) +proc createAttributeNS*(self: ptr IHTMLDocument7, pvarNS: ptr VARIANT, bstrAttrName: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createAttributeNS(self, pvarNS, bstrAttrName, ppAttribute) +proc put_onmsthumbnailclick*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsthumbnailclick(self, v) +proc get_onmsthumbnailclick*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsthumbnailclick(self, p) +proc get_characterSet*(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_characterSet(self, p) +proc createElement*(self: ptr IHTMLDocument7, bstrTag: BSTR, newElem: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElement(self, bstrTag, newElem) +proc createAttribute*(self: ptr IHTMLDocument7, bstrAttrName: BSTR, ppAttribute: ptr ptr IHTMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createAttribute(self, bstrAttrName, ppAttribute) +proc getElementsByClassName*(self: ptr IHTMLDocument7, v: BSTR, pel: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByClassName(self, v, pel) +proc createProcessingInstruction*(self: ptr IHTMLDocument7, bstrTarget: BSTR, bstrData: BSTR, newProcessingInstruction: ptr ptr IDOMProcessingInstruction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createProcessingInstruction(self, bstrTarget, bstrData, newProcessingInstruction) +proc adoptNode*(self: ptr IHTMLDocument7, pNodeSource: ptr IHTMLDOMNode, ppNodeDest: ptr ptr IHTMLDOMNode3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.adoptNode(self, pNodeSource, ppNodeDest) +proc put_onmssitemodejumplistitemremoved*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmssitemodejumplistitemremoved(self, v) +proc get_onmssitemodejumplistitemremoved*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmssitemodejumplistitemremoved(self, p) +proc get_all*(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_all(self, p) +proc get_inputEncoding*(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_inputEncoding(self, p) +proc get_xmlEncoding*(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmlEncoding(self, p) +proc put_xmlStandalone*(self: ptr IHTMLDocument7, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmlStandalone(self, v) +proc get_xmlStandalone*(self: ptr IHTMLDocument7, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmlStandalone(self, p) +proc put_xmlVersion*(self: ptr IHTMLDocument7, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmlVersion(self, v) +proc get_xmlVersion*(self: ptr IHTMLDocument7, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmlVersion(self, p) +proc hasAttributes*(self: ptr IHTMLDocument7, pfHasAttributes: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasAttributes(self, pfHasAttributes) +proc put_onabort*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onabort(self, v) +proc get_onabort*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onabort(self, p) +proc put_onblur*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_oncanplay*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplay(self, v) +proc get_oncanplay*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplay(self, p) +proc put_oncanplaythrough*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncanplaythrough(self, v) +proc get_oncanplaythrough*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncanplaythrough(self, p) +proc put_onchange*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchange(self, v) +proc get_onchange*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchange(self, p) +proc put_ondrag*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrag(self, v) +proc get_ondrag*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrag(self, p) +proc put_ondragend*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragend(self, v) +proc get_ondragend*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragend(self, p) +proc put_ondragenter*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragenter(self, v) +proc get_ondragenter*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragenter(self, p) +proc put_ondragleave*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragleave(self, v) +proc get_ondragleave*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragleave(self, p) +proc put_ondragover*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondragover(self, v) +proc get_ondragover*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondragover(self, p) +proc put_ondrop*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondrop(self, v) +proc get_ondrop*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondrop(self, p) +proc put_ondurationchange*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondurationchange(self, v) +proc get_ondurationchange*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondurationchange(self, p) +proc put_onemptied*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onemptied(self, v) +proc get_onemptied*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onemptied(self, p) +proc put_onended*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onended(self, v) +proc get_onended*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onended(self, p) +proc put_onerror*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onfocus*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_oninput*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oninput(self, v) +proc get_oninput*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oninput(self, p) +proc put_onload*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onloadeddata*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadeddata(self, v) +proc get_onloadeddata*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadeddata(self, p) +proc put_onloadedmetadata*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadedmetadata(self, v) +proc get_onloadedmetadata*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadedmetadata(self, p) +proc put_onloadstart*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onloadstart(self, v) +proc get_onloadstart*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onloadstart(self, p) +proc put_onpause*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onpause(self, v) +proc get_onpause*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onpause(self, p) +proc put_onplay*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplay(self, v) +proc get_onplay*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplay(self, p) +proc put_onplaying*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onplaying(self, v) +proc get_onplaying*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onplaying(self, p) +proc put_onprogress*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onprogress(self, v) +proc get_onprogress*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onprogress(self, p) +proc put_onratechange*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onratechange(self, v) +proc get_onratechange*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onratechange(self, p) +proc put_onreset*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreset(self, v) +proc get_onreset*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreset(self, p) +proc put_onscroll*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onscroll(self, v) +proc get_onscroll*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onscroll(self, p) +proc put_onseeked*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeked(self, v) +proc get_onseeked*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeked(self, p) +proc put_onseeking*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onseeking(self, v) +proc get_onseeking*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onseeking(self, p) +proc put_onselect*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onselect(self, v) +proc get_onselect*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onselect(self, p) +proc put_onstalled*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstalled(self, v) +proc get_onstalled*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstalled(self, p) +proc put_onsubmit*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsubmit(self, v) +proc get_onsubmit*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsubmit(self, p) +proc put_onsuspend*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onsuspend(self, v) +proc get_onsuspend*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onsuspend(self, p) +proc put_ontimeupdate*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontimeupdate(self, v) +proc get_ontimeupdate*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ontimeupdate(self, p) +proc put_onvolumechange*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onvolumechange(self, v) +proc get_onvolumechange*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onvolumechange(self, p) +proc put_onwaiting*(self: ptr IHTMLDocument7, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onwaiting(self, v) +proc get_onwaiting*(self: ptr IHTMLDocument7, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onwaiting(self, p) +proc normalize*(self: ptr IHTMLDocument7): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.normalize(self) +proc importNode*(self: ptr IHTMLDocument7, pNodeSource: ptr IHTMLDOMNode, fDeep: VARIANT_BOOL, ppNodeDest: ptr ptr IHTMLDOMNode3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.importNode(self, pNodeSource, fDeep, ppNodeDest) +proc get_parentWindow*(self: ptr IHTMLDocument7, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentWindow(self, p) +proc putref_body*(self: ptr IHTMLDocument7, v: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_body(self, v) +proc get_body*(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_body(self, p) +proc get_head*(self: ptr IHTMLDocument7, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_head(self, p) +proc put_onmscontentzoom*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmscontentzoom(self, v) +proc get_onmscontentzoom*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmscontentzoom(self, p) +proc put_onmspointerdown*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerdown(self, v) +proc get_onmspointerdown*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerdown(self, p) +proc put_onmspointermove*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointermove(self, v) +proc get_onmspointermove*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointermove(self, p) +proc put_onmspointerup*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerup(self, v) +proc get_onmspointerup*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerup(self, p) +proc put_onmspointerover*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerover(self, v) +proc get_onmspointerover*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerover(self, p) +proc put_onmspointerout*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerout(self, v) +proc get_onmspointerout*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerout(self, p) +proc put_onmspointercancel*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointercancel(self, v) +proc get_onmspointercancel*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointercancel(self, p) +proc put_onmspointerhover*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmspointerhover(self, v) +proc get_onmspointerhover*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmspointerhover(self, p) +proc put_onmsgesturestart*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturestart(self, v) +proc get_onmsgesturestart*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturestart(self, p) +proc put_onmsgesturechange*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturechange(self, v) +proc get_onmsgesturechange*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturechange(self, p) +proc put_onmsgestureend*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgestureend(self, v) +proc get_onmsgestureend*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgestureend(self, p) +proc put_onmsgesturehold*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturehold(self, v) +proc get_onmsgesturehold*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturehold(self, p) +proc put_onmsgesturetap*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturetap(self, v) +proc get_onmsgesturetap*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturetap(self, p) +proc put_onmsgesturedoubletap*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsgesturedoubletap(self, v) +proc get_onmsgesturedoubletap*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsgesturedoubletap(self, p) +proc put_onmsinertiastart*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsinertiastart(self, v) +proc get_onmsinertiastart*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsinertiastart(self, p) +proc elementsFromPoint*(self: ptr IHTMLDocument8, x: float32, y: float32, elementsHit: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.elementsFromPoint(self, x, y, elementsHit) +proc elementsFromRect*(self: ptr IHTMLDocument8, left: float32, top: float32, width: float32, height: float32, elementsHit: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.elementsFromRect(self, left, top, width, height, elementsHit) +proc put_onmsmanipulationstatechanged*(self: ptr IHTMLDocument8, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmsmanipulationstatechanged(self, v) +proc get_onmsmanipulationstatechanged*(self: ptr IHTMLDocument8, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmsmanipulationstatechanged(self, p) +proc put_msCapsLockWarningOff*(self: ptr IHTMLDocument8, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msCapsLockWarningOff(self, v) +proc get_msCapsLockWarningOff*(self: ptr IHTMLDocument8, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msCapsLockWarningOff(self, p) +proc createEvent*(self: ptr IDocumentEvent, eventType: BSTR, ppEvent: ptr ptr IDOMEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createEvent(self, eventType, ppEvent) +proc createRange*(self: ptr IDocumentRange, ppIHTMLDOMRange: ptr ptr IHTMLDOMRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createRange(self, ppIHTMLDOMRange) +proc querySelector*(self: ptr IDocumentSelector, v: BSTR, pel: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.querySelector(self, v, pel) +proc querySelectorAll*(self: ptr IDocumentSelector, v: BSTR, pel: ptr ptr IHTMLDOMChildrenCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.querySelectorAll(self, v, pel) +proc createNodeIterator*(self: ptr IDocumentTraversal, pRootNode: ptr IDispatch, ulWhatToShow: LONG, pFilter: ptr VARIANT, fEntityReferenceExpansion: VARIANT_BOOL, ppNodeIterator: ptr ptr IDOMNodeIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createNodeIterator(self, pRootNode, ulWhatToShow, pFilter, fEntityReferenceExpansion, ppNodeIterator) +proc createTreeWalker*(self: ptr IDocumentTraversal, pRootNode: ptr IDispatch, ulWhatToShow: LONG, pFilter: ptr VARIANT, fEntityReferenceExpansion: VARIANT_BOOL, ppTreeWalker: ptr ptr IDOMTreeWalker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTreeWalker(self, pRootNode, ulWhatToShow, pFilter, fEntityReferenceExpansion, ppTreeWalker) +proc put_URL*(self: ptr IWebBridge, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_URL(self, v) +proc get_URL*(self: ptr IWebBridge, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URL(self, p) +proc put_Scrollbar*(self: ptr IWebBridge, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Scrollbar(self, v) +proc get_Scrollbar*(self: ptr IWebBridge, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Scrollbar(self, p) +proc put_embed*(self: ptr IWebBridge, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_embed(self, v) +proc get_embed*(self: ptr IWebBridge, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_embed(self, p) +proc get_event*(self: ptr IWebBridge, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_event(self, p) +proc get_readyState*(self: ptr IWebBridge, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc AboutBox*(self: ptr IWebBridge): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AboutBox(self) +proc raiseEvent*(self: ptr IWBScriptControl, name: BSTR, eventData: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.raiseEvent(self, name, eventData) +proc bubbleEvent*(self: ptr IWBScriptControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.bubbleEvent(self) +proc setContextMenu*(self: ptr IWBScriptControl, menuItemPairs: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setContextMenu(self, menuItemPairs) +proc put_selectableContent*(self: ptr IWBScriptControl, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectableContent(self, v) +proc get_selectableContent*(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectableContent(self, p) +proc get_frozen*(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frozen(self, p) +proc put_scrollbar*(self: ptr IWBScriptControl, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollbar(self, v) +proc get_scrollbar*(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollbar(self, p) +proc get_version*(self: ptr IWBScriptControl, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc get_visibility*(self: ptr IWBScriptControl, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_visibility(self, p) +proc put_onvisibilitychange*(self: ptr IWBScriptControl, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onvisibilitychange(self, v) +proc get_onvisibilitychange*(self: ptr IWBScriptControl, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onvisibilitychange(self, p) +proc put_hidden*(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hidden(self, v) +proc get_hidden*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hidden(self, p) +proc get_palette*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_palette(self, p) +proc get_pluginspage*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pluginspage(self, p) +proc put_src*(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_units*(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_units(self, v) +proc get_units*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_units(self, p) +proc put_name*(self: ptr IHTMLEmbedElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLEmbedElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_width*(self: ptr IHTMLEmbedElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLEmbedElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLEmbedElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLEmbedElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_src*(self: ptr IHTMLEmbedElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLEmbedElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc get_pluginspage*(self: ptr IHTMLEmbedElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pluginspage(self, p) +proc put_length*(self: ptr IHTMLAreasCollection, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_length(self, v) +proc get_length*(self: ptr IHTMLAreasCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLAreasCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLAreasCollection, name: VARIANT, index: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, name, index, pdisp) +proc tags*(self: ptr IHTMLAreasCollection, tagName: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.tags(self, tagName, pdisp) +proc add*(self: ptr IHTMLAreasCollection, element: ptr IHTMLElement, before: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, element, before) +proc remove*(self: ptr IHTMLAreasCollection, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.remove(self, index) +proc urns*(self: ptr IHTMLAreasCollection2, urn: VARIANT, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.urns(self, urn, pdisp) +proc namedItem*(self: ptr IHTMLAreasCollection3, name: BSTR, pdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pdisp) +proc get_length*(self: ptr IHTMLAreasCollection4, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLAreasCollection4, index: LONG, pNode: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pNode) +proc namedItem*(self: ptr IHTMLAreasCollection4, name: BSTR, pNode: ptr ptr IHTMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedItem(self, name, pNode) +proc get_areas*(self: ptr IHTMLMapElement, p: ptr ptr IHTMLAreasCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_areas(self, p) +proc put_name*(self: ptr IHTMLMapElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLMapElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_shape*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shape(self, v) +proc get_shape*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shape(self, p) +proc put_coords*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_coords(self, v) +proc get_coords*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_coords(self, p) +proc put_href*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_target*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_target(self, v) +proc get_target*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_alt*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_noHref*(self: ptr IHTMLAreaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noHref(self, v) +proc get_noHref*(self: ptr IHTMLAreaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noHref(self, p) +proc put_host*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_host(self, v) +proc get_host*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_host(self, p) +proc put_hostname*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hostname(self, v) +proc get_hostname*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hostname(self, p) +proc put_pathname*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pathname(self, v) +proc get_pathname*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathname(self, p) +proc put_port*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_port(self, v) +proc get_port*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_port(self, p) +proc put_protocol*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_protocol(self, v) +proc get_protocol*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_protocol(self, p) +proc put_search*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_search(self, v) +proc get_search*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_search(self, p) +proc put_hash*(self: ptr IHTMLAreaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hash(self, v) +proc get_hash*(self: ptr IHTMLAreaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hash(self, p) +proc put_onblur*(self: ptr IHTMLAreaElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onblur(self, v) +proc get_onblur*(self: ptr IHTMLAreaElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onblur(self, p) +proc put_onfocus*(self: ptr IHTMLAreaElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onfocus(self, v) +proc get_onfocus*(self: ptr IHTMLAreaElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onfocus(self, p) +proc put_tabIndex*(self: ptr IHTMLAreaElement, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tabIndex(self, v) +proc get_tabIndex*(self: ptr IHTMLAreaElement, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tabIndex(self, p) +proc focus*(self: ptr IHTMLAreaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.focus(self) +proc blur*(self: ptr IHTMLAreaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.blur(self) +proc put_shape*(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shape(self, v) +proc get_shape*(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shape(self, p) +proc put_coords*(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_coords(self, v) +proc get_coords*(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_coords(self, p) +proc put_href*(self: ptr IHTMLAreaElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_href(self, v) +proc get_href*(self: ptr IHTMLAreaElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc put_align*(self: ptr IHTMLTableCaption, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTableCaption, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_vAlign*(self: ptr IHTMLTableCaption, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vAlign(self, v) +proc get_vAlign*(self: ptr IHTMLTableCaption, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vAlign(self, p) +proc put_text*(self: ptr IHTMLCommentElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLCommentElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_atomic*(self: ptr IHTMLCommentElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_atomic(self, v) +proc get_atomic*(self: ptr IHTMLCommentElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_atomic(self, p) +proc put_data*(self: ptr IHTMLCommentElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IHTMLCommentElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_length*(self: ptr IHTMLCommentElement2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc substringData*(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.substringData(self, offset, Count, pbstrsubString) +proc appendData*(self: ptr IHTMLCommentElement2, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendData(self, bstrstring) +proc insertData*(self: ptr IHTMLCommentElement2, offset: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertData(self, offset, bstrstring) +proc deleteData*(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteData(self, offset, Count) +proc replaceData*(self: ptr IHTMLCommentElement2, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceData(self, offset, Count, bstrstring) +proc substringData*(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG, pbstrsubString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.substringData(self, offset, Count, pbstrsubString) +proc insertData*(self: ptr IHTMLCommentElement3, offset: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertData(self, offset, bstrstring) +proc deleteData*(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteData(self, offset, Count) +proc replaceData*(self: ptr IHTMLCommentElement3, offset: LONG, Count: LONG, bstrstring: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceData(self, offset, Count, bstrstring) +proc put_cite*(self: ptr IHTMLPhraseElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cite(self, v) +proc get_cite*(self: ptr IHTMLPhraseElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cite(self, p) +proc put_dateTime*(self: ptr IHTMLPhraseElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dateTime(self, v) +proc get_dateTime*(self: ptr IHTMLPhraseElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dateTime(self, p) +proc put_cite*(self: ptr IHTMLPhraseElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cite(self, v) +proc get_cite*(self: ptr IHTMLPhraseElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cite(self, p) +proc put_cols*(self: ptr IHTMLTable, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cols(self, v) +proc get_cols*(self: ptr IHTMLTable, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cols(self, p) +proc put_border*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_frame*(self: ptr IHTMLTable, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frame(self, v) +proc get_frame*(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frame(self, p) +proc put_rules*(self: ptr IHTMLTable, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rules(self, v) +proc get_rules*(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rules(self, p) +proc put_cellSpacing*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cellSpacing(self, v) +proc get_cellSpacing*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cellSpacing(self, p) +proc put_cellPadding*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cellPadding(self, v) +proc get_cellPadding*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cellPadding(self, p) +proc put_background*(self: ptr IHTMLTable, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_bgColor*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_borderColor*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderColorLight*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorLight(self, v) +proc get_borderColorLight*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorLight(self, p) +proc put_borderColorDark*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorDark(self, v) +proc get_borderColorDark*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorDark(self, p) +proc put_align*(self: ptr IHTMLTable, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc refresh*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.refresh(self) +proc get_rows*(self: ptr IHTMLTable, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rows(self, p) +proc put_width*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_dataPageSize*(self: ptr IHTMLTable, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataPageSize(self, v) +proc get_dataPageSize*(self: ptr IHTMLTable, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataPageSize(self, p) +proc nextPage*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextPage(self) +proc previousPage*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.previousPage(self) +proc get_tHead*(self: ptr IHTMLTable, p: ptr ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tHead(self, p) +proc get_tFoot*(self: ptr IHTMLTable, p: ptr ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tFoot(self, p) +proc get_tBodies*(self: ptr IHTMLTable, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tBodies(self, p) +proc get_caption*(self: ptr IHTMLTable, p: ptr ptr IHTMLTableCaption): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_caption(self, p) +proc createTHead*(self: ptr IHTMLTable, head: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTHead(self, head) +proc deleteTHead*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteTHead(self) +proc createTFoot*(self: ptr IHTMLTable, foot: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTFoot(self, foot) +proc deleteTFoot*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteTFoot(self) +proc createCaption*(self: ptr IHTMLTable, caption: ptr ptr IHTMLTableCaption): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createCaption(self, caption) +proc deleteCaption*(self: ptr IHTMLTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteCaption(self) +proc insertRow*(self: ptr IHTMLTable, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRow(self, index, row) +proc deleteRow*(self: ptr IHTMLTable, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRow(self, index) +proc get_readyState*(self: ptr IHTMLTable, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLTable, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLTable, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc firstPage*(self: ptr IHTMLTable2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.firstPage(self) +proc lastPage*(self: ptr IHTMLTable2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.lastPage(self) +proc get_cells*(self: ptr IHTMLTable2, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cells(self, p) +proc moveRow*(self: ptr IHTMLTable2, indexFrom: LONG, indexTo: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveRow(self, indexFrom, indexTo, row) +proc put_summary*(self: ptr IHTMLTable3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_summary(self, v) +proc get_summary*(self: ptr IHTMLTable3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_summary(self, p) +proc putref_tHead*(self: ptr IHTMLTable4, v: ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_tHead(self, v) +proc get_tHead*(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tHead(self, p) +proc putref_tFoot*(self: ptr IHTMLTable4, v: ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_tFoot(self, v) +proc get_tFoot*(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tFoot(self, p) +proc putref_caption*(self: ptr IHTMLTable4, v: ptr IHTMLTableCaption): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_caption(self, v) +proc get_caption*(self: ptr IHTMLTable4, p: ptr ptr IHTMLTableCaption): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_caption(self, p) +proc insertRow*(self: ptr IHTMLTable4, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRow(self, index, row) +proc deleteRow*(self: ptr IHTMLTable4, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRow(self, index) +proc createTBody*(self: ptr IHTMLTable4, tbody: ptr ptr IHTMLTableSection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTBody(self, tbody) +proc put_span*(self: ptr IHTMLTableCol, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_span(self, v) +proc get_span*(self: ptr IHTMLTableCol, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_span(self, p) +proc put_width*(self: ptr IHTMLTableCol, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLTableCol, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_align*(self: ptr IHTMLTableCol, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTableCol, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_vAlign*(self: ptr IHTMLTableCol, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vAlign(self, v) +proc get_vAlign*(self: ptr IHTMLTableCol, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vAlign(self, p) +proc put_ch*(self: ptr IHTMLTableCol2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableCol2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableCol2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableCol2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_ch*(self: ptr IHTMLTableCol3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableCol3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableCol3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableCol3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_align*(self: ptr IHTMLTableSection, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTableSection, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_vAlign*(self: ptr IHTMLTableSection, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vAlign(self, v) +proc get_vAlign*(self: ptr IHTMLTableSection, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vAlign(self, p) +proc put_bgColor*(self: ptr IHTMLTableSection, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLTableSection, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc get_rows*(self: ptr IHTMLTableSection, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rows(self, p) +proc insertRow*(self: ptr IHTMLTableSection, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRow(self, index, row) +proc deleteRow*(self: ptr IHTMLTableSection, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRow(self, index) +proc moveRow*(self: ptr IHTMLTableSection2, indexFrom: LONG, indexTo: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveRow(self, indexFrom, indexTo, row) +proc put_ch*(self: ptr IHTMLTableSection3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableSection3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableSection3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableSection3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_ch*(self: ptr IHTMLTableSection4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableSection4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableSection4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableSection4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc insertRow*(self: ptr IHTMLTableSection4, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertRow(self, index, row) +proc deleteRow*(self: ptr IHTMLTableSection4, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteRow(self, index) +proc put_align*(self: ptr IHTMLTableRow, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTableRow, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_vAlign*(self: ptr IHTMLTableRow, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vAlign(self, v) +proc get_vAlign*(self: ptr IHTMLTableRow, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vAlign(self, p) +proc put_bgColor*(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_borderColor*(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderColorLight*(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorLight(self, v) +proc get_borderColorLight*(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorLight(self, p) +proc put_borderColorDark*(self: ptr IHTMLTableRow, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorDark(self, v) +proc get_borderColorDark*(self: ptr IHTMLTableRow, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorDark(self, p) +proc get_rowIndex*(self: ptr IHTMLTableRow, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rowIndex(self, p) +proc get_sectionRowIndex*(self: ptr IHTMLTableRow, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sectionRowIndex(self, p) +proc get_cells*(self: ptr IHTMLTableRow, p: ptr ptr IHTMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cells(self, p) +proc insertCell*(self: ptr IHTMLTableRow, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertCell(self, index, row) +proc deleteCell*(self: ptr IHTMLTableRow, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteCell(self, index) +proc put_height*(self: ptr IHTMLTableRow2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLTableRow2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_ch*(self: ptr IHTMLTableRow3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableRow3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableRow3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableRow3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_ch*(self: ptr IHTMLTableRow4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableRow4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableRow4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableRow4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc insertCell*(self: ptr IHTMLTableRow4, index: LONG, row: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertCell(self, index, row) +proc deleteCell*(self: ptr IHTMLTableRow4, index: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteCell(self, index) +proc get_clientHeight*(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientHeight(self, p) +proc get_clientWidth*(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientWidth(self, p) +proc get_clientTop*(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientTop(self, p) +proc get_clientLeft*(self: ptr IHTMLTableRowMetrics, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientLeft(self, p) +proc put_rowSpan*(self: ptr IHTMLTableCell, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rowSpan(self, v) +proc get_rowSpan*(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rowSpan(self, p) +proc put_colSpan*(self: ptr IHTMLTableCell, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_colSpan(self, v) +proc get_colSpan*(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_colSpan(self, p) +proc put_align*(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_vAlign*(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vAlign(self, v) +proc get_vAlign*(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vAlign(self, p) +proc put_bgColor*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_bgColor(self, v) +proc get_bgColor*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bgColor(self, p) +proc put_noWrap*(self: ptr IHTMLTableCell, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noWrap(self, v) +proc get_noWrap*(self: ptr IHTMLTableCell, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noWrap(self, p) +proc put_background*(self: ptr IHTMLTableCell, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_background(self, v) +proc get_background*(self: ptr IHTMLTableCell, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_background(self, p) +proc put_borderColor*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_borderColorLight*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorLight(self, v) +proc get_borderColorLight*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorLight(self, p) +proc put_borderColorDark*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColorDark(self, v) +proc get_borderColorDark*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColorDark(self, p) +proc put_width*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLTableCell, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLTableCell, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_cellIndex*(self: ptr IHTMLTableCell, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cellIndex(self, p) +proc put_abbr*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_abbr(self, v) +proc get_abbr*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_abbr(self, p) +proc put_axis*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_axis(self, v) +proc get_axis*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_axis(self, p) +proc put_ch*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_headers*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_headers(self, v) +proc get_headers*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_headers(self, p) +proc put_scope*(self: ptr IHTMLTableCell2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scope(self, v) +proc get_scope*(self: ptr IHTMLTableCell2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scope(self, p) +proc put_ch*(self: ptr IHTMLTableCell3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ch(self, v) +proc get_ch*(self: ptr IHTMLTableCell3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ch(self, p) +proc put_chOff*(self: ptr IHTMLTableCell3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_chOff(self, v) +proc get_chOff*(self: ptr IHTMLTableCell3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_chOff(self, p) +proc put_src*(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_htmlFor*(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_htmlFor(self, v) +proc get_htmlFor*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_htmlFor(self, p) +proc put_event*(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_event(self, v) +proc get_event*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_event(self, p) +proc put_text*(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, v) +proc get_text*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_defer*(self: ptr IHTMLScriptElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defer(self, v) +proc get_defer*(self: ptr IHTMLScriptElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defer(self, p) +proc get_readyState*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onerror*(self: ptr IHTMLScriptElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLScriptElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_type*(self: ptr IHTMLScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_charset*(self: ptr IHTMLScriptElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, v) +proc get_charset*(self: ptr IHTMLScriptElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_src*(self: ptr IHTMLScriptElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLScriptElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc get_usedCharset*(self: ptr IHTMLScriptElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_usedCharset(self, p) +proc get_object*(self: ptr IHTMLObjectElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_object(self, p) +proc get_classid*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_classid(self, p) +proc get_data*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc putref_recordset*(self: ptr IHTMLObjectElement, v: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_recordset(self, v) +proc get_recordset*(self: ptr IHTMLObjectElement, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_recordset(self, p) +proc put_align*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_name*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_codeBase*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_codeBase(self, v) +proc get_codeBase*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_codeBase(self, p) +proc put_codeType*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_codeType(self, v) +proc get_codeType*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_codeType(self, p) +proc put_code*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_code(self, v) +proc get_code*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_BaseHref*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BaseHref(self, p) +proc put_type*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_form*(self: ptr IHTMLObjectElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_width*(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_readyState*(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onerror*(self: ptr IHTMLObjectElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLObjectElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_altHtml*(self: ptr IHTMLObjectElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_altHtml(self, v) +proc get_altHtml*(self: ptr IHTMLObjectElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altHtml(self, p) +proc put_vspace*(self: ptr IHTMLObjectElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLObjectElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLObjectElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc namedRecordset*(self: ptr IHTMLObjectElement2, dataMember: BSTR, hierarchy: ptr VARIANT, ppRecordset: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.namedRecordset(self, dataMember, hierarchy, ppRecordset) +proc put_classid*(self: ptr IHTMLObjectElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_classid(self, v) +proc get_classid*(self: ptr IHTMLObjectElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_classid(self, p) +proc put_data*(self: ptr IHTMLObjectElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IHTMLObjectElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc put_archive*(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_archive(self, v) +proc get_archive*(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_archive(self, p) +proc put_alt*(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_alt(self, v) +proc get_alt*(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_alt(self, p) +proc put_declare*(self: ptr IHTMLObjectElement3, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_declare(self, v) +proc get_declare*(self: ptr IHTMLObjectElement3, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_declare(self, p) +proc put_standby*(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_standby(self, v) +proc get_standby*(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_standby(self, p) +proc put_border*(self: ptr IHTMLObjectElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLObjectElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_useMap*(self: ptr IHTMLObjectElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_useMap(self, v) +proc get_useMap*(self: ptr IHTMLObjectElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_useMap(self, p) +proc get_contentDocument*(self: ptr IHTMLObjectElement4, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentDocument(self, p) +proc put_codeBase*(self: ptr IHTMLObjectElement4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_codeBase(self, v) +proc get_codeBase*(self: ptr IHTMLObjectElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_codeBase(self, p) +proc put_data*(self: ptr IHTMLObjectElement4, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IHTMLObjectElement4, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc put_object*(self: ptr IHTMLObjectElement5, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_object(self, v) +proc get_object*(self: ptr IHTMLObjectElement5, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_object(self, p) +proc put_name*(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_value*(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_type*(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_valueType*(self: ptr IHTMLParamElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueType(self, v) +proc get_valueType*(self: ptr IHTMLParamElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueType(self, p) +proc put_name*(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_type*(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_value*(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_valueType*(self: ptr IHTMLParamElement2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueType(self, v) +proc get_valueType*(self: ptr IHTMLParamElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueType(self, p) +proc put_src*(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_name*(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_border*(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_frameBorder*(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameBorder(self, v) +proc get_frameBorder*(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameBorder(self, p) +proc put_frameSpacing*(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameSpacing(self, v) +proc get_frameSpacing*(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameSpacing(self, p) +proc put_marginWidth*(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginWidth(self, v) +proc get_marginWidth*(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginWidth(self, p) +proc put_marginHeight*(self: ptr IHTMLFrameBase, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginHeight(self, v) +proc get_marginHeight*(self: ptr IHTMLFrameBase, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginHeight(self, p) +proc put_noResize*(self: ptr IHTMLFrameBase, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_noResize(self, v) +proc get_noResize*(self: ptr IHTMLFrameBase, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_noResize(self, p) +proc put_scrolling*(self: ptr IHTMLFrameBase, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrolling(self, v) +proc get_scrolling*(self: ptr IHTMLFrameBase, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrolling(self, p) +proc get_contentWindow*(self: ptr IHTMLFrameBase2, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentWindow(self, p) +proc put_onload*(self: ptr IHTMLFrameBase2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLFrameBase2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onreadystatechange*(self: ptr IHTMLFrameBase2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLFrameBase2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc get_readyState*(self: ptr IHTMLFrameBase2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_allowTransparency*(self: ptr IHTMLFrameBase2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_allowTransparency(self, v) +proc get_allowTransparency*(self: ptr IHTMLFrameBase2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_allowTransparency(self, p) +proc put_longDesc*(self: ptr IHTMLFrameBase3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_longDesc(self, v) +proc get_longDesc*(self: ptr IHTMLFrameBase3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longDesc(self, p) +proc put_borderColor*(self: ptr IHTMLFrameElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLFrameElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_height*(self: ptr IHTMLFrameElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLFrameElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_width*(self: ptr IHTMLFrameElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLFrameElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_contentDocument*(self: ptr IHTMLFrameElement3, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentDocument(self, p) +proc put_src*(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_longDesc*(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_longDesc(self, v) +proc get_longDesc*(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longDesc(self, p) +proc put_frameBorder*(self: ptr IHTMLFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameBorder(self, v) +proc get_frameBorder*(self: ptr IHTMLFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameBorder(self, p) +proc put_vspace*(self: ptr IHTMLIFrameElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_vspace(self, v) +proc get_vspace*(self: ptr IHTMLIFrameElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_vspace(self, p) +proc put_hspace*(self: ptr IHTMLIFrameElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_hspace(self, v) +proc get_hspace*(self: ptr IHTMLIFrameElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hspace(self, p) +proc put_align*(self: ptr IHTMLIFrameElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLIFrameElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_height*(self: ptr IHTMLIFrameElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLIFrameElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_width*(self: ptr IHTMLIFrameElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLIFrameElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_contentDocument*(self: ptr IHTMLIFrameElement3, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentDocument(self, p) +proc put_src*(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_longDesc*(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_longDesc(self, v) +proc get_longDesc*(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longDesc(self, p) +proc put_frameBorder*(self: ptr IHTMLIFrameElement3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameBorder(self, v) +proc get_frameBorder*(self: ptr IHTMLIFrameElement3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameBorder(self, p) +proc put_align*(self: ptr IHTMLDivPosition, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLDivPosition, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_align*(self: ptr IHTMLFieldSetElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLFieldSetElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc get_form*(self: ptr IHTMLFieldSetElement2, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_align*(self: ptr IHTMLLegendElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLLegendElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc get_form*(self: ptr IHTMLLegendElement2, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc put_align*(self: ptr IHTMLSpanFlow, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr IHTMLSpanFlow, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_rows*(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_rows(self, v) +proc get_rows*(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rows(self, p) +proc put_cols*(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cols(self, v) +proc get_cols*(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cols(self, p) +proc put_border*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_borderColor*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderColor(self, v) +proc get_borderColor*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderColor(self, p) +proc put_frameBorder*(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameBorder(self, v) +proc get_frameBorder*(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameBorder(self, p) +proc put_frameSpacing*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameSpacing(self, v) +proc get_frameSpacing*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameSpacing(self, p) +proc put_name*(self: ptr IHTMLFrameSetElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_name(self, v) +proc get_name*(self: ptr IHTMLFrameSetElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc put_onload*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onunload*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onunload(self, v) +proc get_onunload*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onunload(self, p) +proc put_onbeforeunload*(self: ptr IHTMLFrameSetElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeunload(self, v) +proc get_onbeforeunload*(self: ptr IHTMLFrameSetElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeunload(self, p) +proc put_onbeforeprint*(self: ptr IHTMLFrameSetElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onbeforeprint(self, v) +proc get_onbeforeprint*(self: ptr IHTMLFrameSetElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onbeforeprint(self, p) +proc put_onafterprint*(self: ptr IHTMLFrameSetElement2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onafterprint(self, v) +proc get_onafterprint*(self: ptr IHTMLFrameSetElement2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onafterprint(self, p) +proc put_onhashchange*(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onhashchange(self, v) +proc get_onhashchange*(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onhashchange(self, p) +proc put_onmessage*(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onmessage(self, v) +proc get_onmessage*(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onmessage(self, p) +proc put_onoffline*(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onoffline(self, v) +proc get_onoffline*(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onoffline(self, p) +proc put_ononline*(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ononline(self, v) +proc get_ononline*(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ononline(self, p) +proc put_onstorage*(self: ptr IHTMLFrameSetElement3, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onstorage(self, v) +proc get_onstorage*(self: ptr IHTMLFrameSetElement3, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onstorage(self, p) +proc put_src*(self: ptr IHTMLBGsound, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLBGsound, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_loop*(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc put_volume*(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_volume(self, v) +proc get_volume*(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_volume(self, p) +proc put_balance*(self: ptr IHTMLBGsound, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_balance(self, v) +proc get_balance*(self: ptr IHTMLBGsound, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_balance(self, p) +proc get_length*(self: ptr IHTMLFontNamesCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLFontNamesCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLFontNamesCollection, index: LONG, pBstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, pBstr) +proc get_length*(self: ptr IHTMLFontSizesCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLFontSizesCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc get_forFont*(self: ptr IHTMLFontSizesCollection, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_forFont(self, p) +proc item*(self: ptr IHTMLFontSizesCollection, index: LONG, plSize: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, plSize) +proc get_document*(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc get_fonts*(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLFontNamesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fonts(self, p) +proc put_execArg*(self: ptr IHTMLOptionsHolder, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_execArg(self, v) +proc get_execArg*(self: ptr IHTMLOptionsHolder, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_execArg(self, p) +proc put_errorLine*(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_errorLine(self, v) +proc get_errorLine*(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorLine(self, p) +proc put_errorCharacter*(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_errorCharacter(self, v) +proc get_errorCharacter*(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorCharacter(self, p) +proc put_errorCode*(self: ptr IHTMLOptionsHolder, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_errorCode(self, v) +proc get_errorCode*(self: ptr IHTMLOptionsHolder, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorCode(self, p) +proc put_errorMessage*(self: ptr IHTMLOptionsHolder, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_errorMessage(self, v) +proc get_errorMessage*(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorMessage(self, p) +proc put_errorDebug*(self: ptr IHTMLOptionsHolder, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_errorDebug(self, v) +proc get_errorDebug*(self: ptr IHTMLOptionsHolder, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorDebug(self, p) +proc get_unsecuredWindowOfDocument*(self: ptr IHTMLOptionsHolder, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unsecuredWindowOfDocument(self, p) +proc put_findText*(self: ptr IHTMLOptionsHolder, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_findText(self, v) +proc get_findText*(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_findText(self, p) +proc put_anythingAfterFrameset*(self: ptr IHTMLOptionsHolder, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_anythingAfterFrameset(self, v) +proc get_anythingAfterFrameset*(self: ptr IHTMLOptionsHolder, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_anythingAfterFrameset(self, p) +proc sizes*(self: ptr IHTMLOptionsHolder, fontName: BSTR, pSizesCollection: ptr ptr IHTMLFontSizesCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.sizes(self, fontName, pSizesCollection) +proc openfiledlg*(self: ptr IHTMLOptionsHolder, initFile: VARIANT, initDir: VARIANT, filter: VARIANT, title: VARIANT, pathName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.openfiledlg(self, initFile, initDir, filter, title, pathName) +proc savefiledlg*(self: ptr IHTMLOptionsHolder, initFile: VARIANT, initDir: VARIANT, filter: VARIANT, title: VARIANT, pathName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.savefiledlg(self, initFile, initDir, filter, title, pathName) +proc choosecolordlg*(self: ptr IHTMLOptionsHolder, initColor: VARIANT, rgbColor: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.choosecolordlg(self, initColor, rgbColor) +proc showSecurityInfo*(self: ptr IHTMLOptionsHolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showSecurityInfo(self) +proc isApartmentModel*(self: ptr IHTMLOptionsHolder, `object`: ptr IHTMLObjectElement, fApartment: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isApartmentModel(self, `object`, fApartment) +proc getCharset*(self: ptr IHTMLOptionsHolder, fontName: BSTR, charset: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCharset(self, fontName, charset) +proc get_secureConnectionInfo*(self: ptr IHTMLOptionsHolder, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_secureConnectionInfo(self, p) +proc put_type*(self: ptr IHTMLStyleElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_readyState*(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc put_onload*(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc put_onerror*(self: ptr IHTMLStyleElement, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLStyleElement, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc get_styleSheet*(self: ptr IHTMLStyleElement, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_styleSheet(self, p) +proc put_disabled*(self: ptr IHTMLStyleElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_disabled(self, v) +proc get_disabled*(self: ptr IHTMLStyleElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_disabled(self, p) +proc put_media*(self: ptr IHTMLStyleElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLStyleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc get_sheet*(self: ptr IHTMLStyleElement2, p: ptr ptr IHTMLStyleSheet): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sheet(self, p) +proc put_fontsrc*(self: ptr IHTMLStyleFontFace, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fontsrc(self, v) +proc get_fontsrc*(self: ptr IHTMLStyleFontFace, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontsrc(self, p) +proc get_style*(self: ptr IHTMLStyleFontFace2, p: ptr ptr IHTMLRuleStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_style(self, p) +proc get_responseText*(self: ptr IHTMLXDomainRequest, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseText(self, p) +proc put_timeout*(self: ptr IHTMLXDomainRequest, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_timeout(self, v) +proc get_timeout*(self: ptr IHTMLXDomainRequest, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_timeout(self, p) +proc get_contentType*(self: ptr IHTMLXDomainRequest, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentType(self, p) +proc put_onprogress*(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onprogress(self, v) +proc get_onprogress*(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onprogress(self, p) +proc put_onerror*(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_ontimeout*(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontimeout(self, v) +proc get_ontimeout*(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ontimeout(self, p) +proc put_onload*(self: ptr IHTMLXDomainRequest, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onload(self, v) +proc get_onload*(self: ptr IHTMLXDomainRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onload(self, p) +proc abort*(self: ptr IHTMLXDomainRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.abort(self) +proc open*(self: ptr IHTMLXDomainRequest, bstrMethod: BSTR, bstrUrl: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.open(self, bstrMethod, bstrUrl) +proc send*(self: ptr IHTMLXDomainRequest, varBody: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.send(self, varBody) +proc create*(self: ptr IHTMLXDomainRequestFactory, a: ptr ptr IHTMLXDomainRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, a) +proc get_length*(self: ptr IHTMLStorage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_remainingSpace*(self: ptr IHTMLStorage, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_remainingSpace(self, p) +proc key*(self: ptr IHTMLStorage, lIndex: LONG, a: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.key(self, lIndex, a) +proc getItem*(self: ptr IHTMLStorage, bstrKey: BSTR, a: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, bstrKey, a) +proc setItem*(self: ptr IHTMLStorage, bstrKey: BSTR, bstrValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setItem(self, bstrKey, bstrValue) +proc removeItem*(self: ptr IHTMLStorage, bstrKey: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, bstrKey) +proc clear*(self: ptr IHTMLStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc setItem*(self: ptr IHTMLStorage2, bstrKey: BSTR, bstrValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setItem(self, bstrKey, bstrValue) +proc addEventListener*(self: ptr IEventTarget, `type`: BSTR, listener: ptr IDispatch, useCapture: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addEventListener(self, `type`, listener, useCapture) +proc removeEventListener*(self: ptr IEventTarget, `type`: BSTR, listener: ptr IDispatch, useCapture: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeEventListener(self, `type`, listener, useCapture) +proc dispatchEvent*(self: ptr IEventTarget, evt: ptr IDOMEvent, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.dispatchEvent(self, evt, pfResult) +proc get_bubbles*(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bubbles(self, p) +proc get_cancelable*(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cancelable(self, p) +proc get_currentTarget*(self: ptr IDOMEvent, p: ptr ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentTarget(self, p) +proc get_defaultPrevented*(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultPrevented(self, p) +proc get_eventPhase*(self: ptr IDOMEvent, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_eventPhase(self, p) +proc get_target*(self: ptr IDOMEvent, p: ptr ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc get_timeStamp*(self: ptr IDOMEvent, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_timeStamp(self, p) +proc get_type*(self: ptr IDOMEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc initEvent*(self: ptr IDOMEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initEvent(self, eventType, canBubble, cancelable) +proc preventDefault*(self: ptr IDOMEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.preventDefault(self) +proc stopPropagation*(self: ptr IDOMEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stopPropagation(self) +proc stopImmediatePropagation*(self: ptr IDOMEvent): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stopImmediatePropagation(self) +proc get_isTrusted*(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isTrusted(self, p) +proc put_cancelBubble*(self: ptr IDOMEvent, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_cancelBubble(self, v) +proc get_cancelBubble*(self: ptr IDOMEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cancelBubble(self, p) +proc get_srcElement*(self: ptr IDOMEvent, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcElement(self, p) +proc get_view*(self: ptr IDOMUIEvent, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_view(self, p) +proc get_detail*(self: ptr IDOMUIEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_detail(self, p) +proc initUIEvent*(self: ptr IDOMUIEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, view: ptr IHTMLWindow2, detail: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initUIEvent(self, eventType, canBubble, cancelable, view, detail) +proc get_screenX*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenX(self, p) +proc get_screenY*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenY(self, p) +proc get_clientX*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientX(self, p) +proc get_clientY*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clientY(self, p) +proc get_ctrlKey*(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ctrlKey(self, p) +proc get_shiftKey*(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shiftKey(self, p) +proc get_altKey*(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altKey(self, p) +proc get_metaKey*(self: ptr IDOMMouseEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_metaKey(self, p) +proc get_button*(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_button(self, p) +proc get_relatedTarget*(self: ptr IDOMMouseEvent, p: ptr ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_relatedTarget(self, p) +proc initMouseEvent*(self: ptr IDOMMouseEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, ctrlKeyArg: VARIANT_BOOL, altKeyArg: VARIANT_BOOL, shiftKeyArg: VARIANT_BOOL, metaKeyArg: VARIANT_BOOL, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMouseEvent(self, eventType, canBubble, cancelable, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg) +proc getModifierState*(self: ptr IDOMMouseEvent, keyArg: BSTR, activated: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getModifierState(self, keyArg, activated) +proc get_buttons*(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_buttons(self, p) +proc get_fromElement*(self: ptr IDOMMouseEvent, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fromElement(self, p) +proc get_toElement*(self: ptr IDOMMouseEvent, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_toElement(self, p) +proc get_x*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc get_y*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc get_offsetX*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetX(self, p) +proc get_offsetY*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offsetY(self, p) +proc get_pageX*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageX(self, p) +proc get_pageY*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageY(self, p) +proc get_layerX*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layerX(self, p) +proc get_layerY*(self: ptr IDOMMouseEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_layerY(self, p) +proc get_which*(self: ptr IDOMMouseEvent, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_which(self, p) +proc get_dataTransfer*(self: ptr IDOMDragEvent, p: ptr ptr IHTMLDataTransfer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataTransfer(self, p) +proc initDragEvent*(self: ptr IDOMDragEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, ctrlKeyArg: VARIANT_BOOL, altKeyArg: VARIANT_BOOL, shiftKeyArg: VARIANT_BOOL, metaKeyArg: VARIANT_BOOL, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, dataTransferArg: ptr IHTMLDataTransfer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initDragEvent(self, eventType, canBubble, cancelable, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg, dataTransferArg) +proc get_wheelDelta*(self: ptr IDOMMouseWheelEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wheelDelta(self, p) +proc initMouseWheelEvent*(self: ptr IDOMMouseWheelEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, modifiersListArg: BSTR, wheelDeltaArg: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMouseWheelEvent(self, eventType, canBubble, cancelable, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, buttonArg, relatedTargetArg, modifiersListArg, wheelDeltaArg) +proc get_deltaX*(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deltaX(self, p) +proc get_deltaY*(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deltaY(self, p) +proc get_deltaZ*(self: ptr IDOMWheelEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deltaZ(self, p) +proc get_deltaMode*(self: ptr IDOMWheelEvent, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_deltaMode(self, p) +proc initWheelEvent*(self: ptr IDOMWheelEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, screenXArg: LONG, screenYArg: LONG, clientXArg: LONG, clientYArg: LONG, buttonArg: USHORT, relatedTargetArg: ptr IEventTarget, modifiersListArg: BSTR, deltaX: LONG, deltaY: LONG, deltaZ: LONG, deltaMode: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initWheelEvent(self, eventType, canBubble, cancelable, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, buttonArg, relatedTargetArg, modifiersListArg, deltaX, deltaY, deltaZ, deltaMode) +proc get_data*(self: ptr IDOMTextEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_inputMethod*(self: ptr IDOMTextEvent, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_inputMethod(self, p) +proc initTextEvent*(self: ptr IDOMTextEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, dataArg: BSTR, inputMethod: ULONG, locale: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initTextEvent(self, eventType, canBubble, cancelable, viewArg, dataArg, inputMethod, locale) +proc get_locale*(self: ptr IDOMTextEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_locale(self, p) +proc get_key*(self: ptr IDOMKeyboardEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_key(self, p) +proc get_location*(self: ptr IDOMKeyboardEvent, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_location(self, p) +proc get_ctrlKey*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ctrlKey(self, p) +proc get_shiftKey*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shiftKey(self, p) +proc get_altKey*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altKey(self, p) +proc get_metaKey*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_metaKey(self, p) +proc get_repeat*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_repeat(self, p) +proc getModifierState*(self: ptr IDOMKeyboardEvent, keyArg: BSTR, state: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getModifierState(self, keyArg, state) +proc initKeyboardEvent*(self: ptr IDOMKeyboardEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, keyArg: BSTR, locationArg: ULONG, modifiersListArg: BSTR, repeat: VARIANT_BOOL, locale: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initKeyboardEvent(self, eventType, canBubble, cancelable, viewArg, keyArg, locationArg, modifiersListArg, repeat, locale) +proc get_keyCode*(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_keyCode(self, p) +proc get_charCode*(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charCode(self, p) +proc get_which*(self: ptr IDOMKeyboardEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_which(self, p) +proc get_ie9_char*(self: ptr IDOMKeyboardEvent, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ie9_char(self, p) +proc get_locale*(self: ptr IDOMKeyboardEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_locale(self, p) +proc get_data*(self: ptr IDOMCompositionEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc initCompositionEvent*(self: ptr IDOMCompositionEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, data: BSTR, locale: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initCompositionEvent(self, eventType, canBubble, cancelable, viewArg, data, locale) +proc get_locale*(self: ptr IDOMCompositionEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_locale(self, p) +proc get_relatedNode*(self: ptr IDOMMutationEvent, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_relatedNode(self, p) +proc get_prevValue*(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_prevValue(self, p) +proc get_newValue*(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newValue(self, p) +proc get_attrName*(self: ptr IDOMMutationEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attrName(self, p) +proc get_attrChange*(self: ptr IDOMMutationEvent, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attrChange(self, p) +proc initMutationEvent*(self: ptr IDOMMutationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, relatedNodeArg: ptr IDispatch, prevValueArg: BSTR, newValueArg: BSTR, attrNameArg: BSTR, attrChangeArg: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMutationEvent(self, eventType, canBubble, cancelable, relatedNodeArg, prevValueArg, newValueArg, attrNameArg, attrChangeArg) +proc put_returnValue*(self: ptr IDOMBeforeUnloadEvent, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_returnValue(self, v) +proc get_returnValue*(self: ptr IDOMBeforeUnloadEvent, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_returnValue(self, p) +proc get_relatedTarget*(self: ptr IDOMFocusEvent, p: ptr ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_relatedTarget(self, p) +proc initFocusEvent*(self: ptr IDOMFocusEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, view: ptr IHTMLWindow2, detail: LONG, relatedTargetArg: ptr IEventTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initFocusEvent(self, eventType, canBubble, cancelable, view, detail, relatedTargetArg) +proc get_detail*(self: ptr IDOMCustomEvent, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_detail(self, p) +proc initCustomEvent*(self: ptr IDOMCustomEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, detail: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initCustomEvent(self, eventType, canBubble, cancelable, detail) +proc addColorStop*(self: ptr ICanvasGradient, offset: float32, color: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addColorStop(self, offset, color) +proc get_width*(self: ptr ICanvasTextMetrics, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_width*(self: ptr ICanvasImageData, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_height*(self: ptr ICanvasImageData, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_data*(self: ptr ICanvasImageData, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_length*(self: ptr ICanvasPixelArray, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_canvas*(self: ptr ICanvasRenderingContext2D, p: ptr ptr IHTMLCanvasElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_canvas(self, p) +proc restore*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.restore(self) +proc save*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.save(self) +proc rotate*(self: ptr ICanvasRenderingContext2D, angle: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.rotate(self, angle) +proc scale*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scale(self, x, y) +proc setTransform*(self: ptr ICanvasRenderingContext2D, m11: float32, m12: float32, m21: float32, m22: float32, dx: float32, dy: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setTransform(self, m11, m12, m21, m22, dx, dy) +proc transform*(self: ptr ICanvasRenderingContext2D, m11: float32, m12: float32, m21: float32, m22: float32, dx: float32, dy: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.transform(self, m11, m12, m21, m22, dx, dy) +proc translate*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.translate(self, x, y) +proc put_globalAlpha*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_globalAlpha(self, v) +proc get_globalAlpha*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_globalAlpha(self, p) +proc put_globalCompositeOperation*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_globalCompositeOperation(self, v) +proc get_globalCompositeOperation*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_globalCompositeOperation(self, p) +proc put_fillStyle*(self: ptr ICanvasRenderingContext2D, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_fillStyle(self, v) +proc get_fillStyle*(self: ptr ICanvasRenderingContext2D, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fillStyle(self, p) +proc put_strokeStyle*(self: ptr ICanvasRenderingContext2D, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_strokeStyle(self, v) +proc get_strokeStyle*(self: ptr ICanvasRenderingContext2D, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strokeStyle(self, p) +proc createLinearGradient*(self: ptr ICanvasRenderingContext2D, x0: float32, y0: float32, x1: float32, y1: float32, ppCanvasGradient: ptr ptr ICanvasGradient): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createLinearGradient(self, x0, y0, x1, y1, ppCanvasGradient) +proc createRadialGradient*(self: ptr ICanvasRenderingContext2D, x0: float32, y0: float32, r0: float32, x1: float32, y1: float32, r1: float32, ppCanvasGradient: ptr ptr ICanvasGradient): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createRadialGradient(self, x0, y0, r0, x1, y1, r1, ppCanvasGradient) +proc createPattern*(self: ptr ICanvasRenderingContext2D, image: ptr IDispatch, repetition: VARIANT, ppCanvasPattern: ptr ptr ICanvasPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createPattern(self, image, repetition, ppCanvasPattern) +proc put_lineCap*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineCap(self, v) +proc get_lineCap*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineCap(self, p) +proc put_lineJoin*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineJoin(self, v) +proc get_lineJoin*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineJoin(self, p) +proc put_lineWidth*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_lineWidth(self, v) +proc get_lineWidth*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineWidth(self, p) +proc put_miterLimit*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_miterLimit(self, v) +proc get_miterLimit*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_miterLimit(self, p) +proc put_shadowBlur*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shadowBlur(self, v) +proc get_shadowBlur*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shadowBlur(self, p) +proc put_shadowColor*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shadowColor(self, v) +proc get_shadowColor*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shadowColor(self, p) +proc put_shadowOffsetX*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shadowOffsetX(self, v) +proc get_shadowOffsetX*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shadowOffsetX(self, p) +proc put_shadowOffsetY*(self: ptr ICanvasRenderingContext2D, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_shadowOffsetY(self, v) +proc get_shadowOffsetY*(self: ptr ICanvasRenderingContext2D, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_shadowOffsetY(self, p) +proc clearRect*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearRect(self, x, y, w, h) +proc fillRect*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fillRect(self, x, y, w, h) +proc strokeRect*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.strokeRect(self, x, y, w, h) +proc arc*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, radius: float32, startAngle: float32, endAngle: float32, anticlockwise: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.arc(self, x, y, radius, startAngle, endAngle, anticlockwise) +proc arcTo*(self: ptr ICanvasRenderingContext2D, x1: float32, y1: float32, x2: float32, y2: float32, radius: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.arcTo(self, x1, y1, x2, y2, radius) +proc mBeginPath*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.beginPath(self) +proc bezierCurveTo*(self: ptr ICanvasRenderingContext2D, cp1x: float32, cp1y: float32, cp2x: float32, cp2y: float32, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.bezierCurveTo(self, cp1x, cp1y, cp2x, cp2y, x, y) +proc clip*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clip(self) +proc closePath*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.closePath(self) +proc fill*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fill(self) +proc lineTo*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.lineTo(self, x, y) +proc moveTo*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveTo(self, x, y) +proc quadraticCurveTo*(self: ptr ICanvasRenderingContext2D, cpx: float32, cpy: float32, x: float32, y: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.quadraticCurveTo(self, cpx, cpy, x, y) +proc rect*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, w: float32, h: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.rect(self, x, y, w, h) +proc stroke*(self: ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stroke(self) +proc isPointInPath*(self: ptr ICanvasRenderingContext2D, x: float32, y: float32, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isPointInPath(self, x, y, pResult) +proc put_font*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_font(self, v) +proc get_font*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_font(self, p) +proc put_textAlign*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textAlign(self, v) +proc get_textAlign*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textAlign(self, p) +proc put_textBaseline*(self: ptr ICanvasRenderingContext2D, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_textBaseline(self, v) +proc get_textBaseline*(self: ptr ICanvasRenderingContext2D, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textBaseline(self, p) +proc fillText*(self: ptr ICanvasRenderingContext2D, text: BSTR, x: float32, y: float32, maxWidth: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.fillText(self, text, x, y, maxWidth) +proc measureText*(self: ptr ICanvasRenderingContext2D, text: BSTR, ppCanvasTextMetrics: ptr ptr ICanvasTextMetrics): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.measureText(self, text, ppCanvasTextMetrics) +proc strokeText*(self: ptr ICanvasRenderingContext2D, text: BSTR, x: float32, y: float32, maxWidth: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.strokeText(self, text, x, y, maxWidth) +proc drawImage*(self: ptr ICanvasRenderingContext2D, pSrc: ptr IDispatch, a1: VARIANT, a2: VARIANT, a3: VARIANT, a4: VARIANT, a5: VARIANT, a6: VARIANT, a7: VARIANT, a8: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.drawImage(self, pSrc, a1, a2, a3, a4, a5, a6, a7, a8) +proc createImageData*(self: ptr ICanvasRenderingContext2D, a1: VARIANT, a2: VARIANT, ppCanvasImageData: ptr ptr ICanvasImageData): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createImageData(self, a1, a2, ppCanvasImageData) +proc getImageData*(self: ptr ICanvasRenderingContext2D, sx: float32, sy: float32, sw: float32, sh: float32, ppCanvasImageData: ptr ptr ICanvasImageData): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getImageData(self, sx, sy, sw, sh, ppCanvasImageData) +proc putImageData*(self: ptr ICanvasRenderingContext2D, imagedata: ptr ICanvasImageData, dx: float32, dy: float32, dirtyX: VARIANT, dirtyY: VARIANT, dirtyWidth: VARIANT, dirtyHeight: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putImageData(self, imagedata, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight) +proc put_width*(self: ptr IHTMLCanvasElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLCanvasElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLCanvasElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLCanvasElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc getContext*(self: ptr IHTMLCanvasElement, contextId: BSTR, ppContext: ptr ptr ICanvasRenderingContext2D): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getContext(self, contextId, ppContext) +proc toDataURL*(self: ptr IHTMLCanvasElement, `type`: BSTR, jpegquality: VARIANT, pUrl: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toDataURL(self, `type`, jpegquality, pUrl) +proc get_lengthComputable*(self: ptr IDOMProgressEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lengthComputable(self, p) +proc get_loaded*(self: ptr IDOMProgressEvent, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loaded(self, p) +proc get_total*(self: ptr IDOMProgressEvent, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_total(self, p) +proc initProgressEvent*(self: ptr IDOMProgressEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, lengthComputableArg: VARIANT_BOOL, loadedArg: ULONGLONG, totalArg: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initProgressEvent(self, eventType, canBubble, cancelable, lengthComputableArg, loadedArg, totalArg) +proc get_data*(self: ptr IDOMMessageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_origin*(self: ptr IDOMMessageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_origin(self, p) +proc get_source*(self: ptr IDOMMessageEvent, p: ptr ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_source(self, p) +proc initMessageEvent*(self: ptr IDOMMessageEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, data: BSTR, origin: BSTR, lastEventId: BSTR, source: ptr IHTMLWindow2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMessageEvent(self, eventType, canBubble, cancelable, data, origin, lastEventId, source) +proc get_buttonID*(self: ptr IDOMSiteModeEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_buttonID(self, p) +proc get_actionURL*(self: ptr IDOMSiteModeEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_actionURL(self, p) +proc get_key*(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_key(self, p) +proc get_oldValue*(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oldValue(self, p) +proc get_newValue*(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newValue(self, p) +proc get_url*(self: ptr IDOMStorageEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, p) +proc get_storageArea*(self: ptr IDOMStorageEvent, p: ptr ptr IHTMLStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_storageArea(self, p) +proc initStorageEvent*(self: ptr IDOMStorageEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, keyArg: BSTR, oldValueArg: BSTR, newValueArg: BSTR, urlArg: BSTR, storageAreaArg: ptr IHTMLStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initStorageEvent(self, eventType, canBubble, cancelable, keyArg, oldValueArg, newValueArg, urlArg, storageAreaArg) +proc get_readyState*(self: ptr IHTMLXMLHttpRequest, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc get_responseBody*(self: ptr IHTMLXMLHttpRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseBody(self, p) +proc get_responseText*(self: ptr IHTMLXMLHttpRequest, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseText(self, p) +proc get_responseXML*(self: ptr IHTMLXMLHttpRequest, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseXML(self, p) +proc get_status*(self: ptr IHTMLXMLHttpRequest, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc get_statusText*(self: ptr IHTMLXMLHttpRequest, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_statusText(self, p) +proc put_onreadystatechange*(self: ptr IHTMLXMLHttpRequest, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLXMLHttpRequest, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc abort*(self: ptr IHTMLXMLHttpRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.abort(self) +proc open*(self: ptr IHTMLXMLHttpRequest, bstrMethod: BSTR, bstrUrl: BSTR, varAsync: VARIANT, varUser: VARIANT, varPassword: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.open(self, bstrMethod, bstrUrl, varAsync, varUser, varPassword) +proc send*(self: ptr IHTMLXMLHttpRequest, varBody: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.send(self, varBody) +proc getAllResponseHeaders*(self: ptr IHTMLXMLHttpRequest, a: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAllResponseHeaders(self, a) +proc getResponseHeader*(self: ptr IHTMLXMLHttpRequest, bstrHeader: BSTR, a: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getResponseHeader(self, bstrHeader, a) +proc setRequestHeader*(self: ptr IHTMLXMLHttpRequest, bstrHeader: BSTR, bstrValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setRequestHeader(self, bstrHeader, bstrValue) +proc put_timeout*(self: ptr IHTMLXMLHttpRequest2, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_timeout(self, v) +proc get_timeout*(self: ptr IHTMLXMLHttpRequest2, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_timeout(self, p) +proc put_ontimeout*(self: ptr IHTMLXMLHttpRequest2, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontimeout(self, v) +proc get_ontimeout*(self: ptr IHTMLXMLHttpRequest2, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ontimeout(self, p) +proc create*(self: ptr IHTMLXMLHttpRequestFactory, a: ptr ptr IHTMLXMLHttpRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, a) +proc put_unitType*(self: ptr ISVGAngle, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unitType(self, v) +proc get_unitType*(self: ptr ISVGAngle, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unitType(self, p) +proc put_value*(self: ptr ISVGAngle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr ISVGAngle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_valueInSpecifiedUnits*(self: ptr ISVGAngle, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueInSpecifiedUnits(self, v) +proc get_valueInSpecifiedUnits*(self: ptr ISVGAngle, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueInSpecifiedUnits(self, p) +proc put_valueAsString*(self: ptr ISVGAngle, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueAsString(self, v) +proc get_valueAsString*(self: ptr ISVGAngle, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueAsString(self, p) +proc newValueSpecifiedUnits*(self: ptr ISVGAngle, unitType: int16, valueInSpecifiedUnits: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.newValueSpecifiedUnits(self, unitType, valueInSpecifiedUnits) +proc convertToSpecifiedUnits*(self: ptr ISVGAngle, unitType: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.convertToSpecifiedUnits(self, unitType) +proc get_className*(self: ptr ISVGStylable, p: ptr ptr ISVGAnimatedString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_className(self, p) +proc get_nearestViewportElement*(self: ptr ISVGLocatable, p: ptr ptr ISVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nearestViewportElement(self, p) +proc get_farthestViewportElement*(self: ptr ISVGLocatable, p: ptr ptr ISVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_farthestViewportElement(self, p) +proc getBBox*(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getBBox(self, ppResult) +proc getCTM*(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCTM(self, ppResult) +proc getScreenCTM*(self: ptr ISVGLocatable, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getScreenCTM(self, ppResult) +proc getTransformToElement*(self: ptr ISVGLocatable, pElement: ptr ISVGElement, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getTransformToElement(self, pElement, ppResult) +proc get_transform*(self: ptr ISVGTransformable, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_transform(self, p) +proc get_requiredFeatures*(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_requiredFeatures(self, p) +proc get_requiredExtensions*(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_requiredExtensions(self, p) +proc get_systemLanguage*(self: ptr ISVGTests, p: ptr ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemLanguage(self, p) +proc hasExtension*(self: ptr ISVGTests, extension: BSTR, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasExtension(self, extension, pResult) +proc put_xmllang*(self: ptr ISVGLangSpace, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmllang(self, v) +proc get_xmllang*(self: ptr ISVGLangSpace, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmllang(self, p) +proc put_xmlspace*(self: ptr ISVGLangSpace, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmlspace(self, v) +proc get_xmlspace*(self: ptr ISVGLangSpace, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmlspace(self, p) +proc get_externalResourcesRequired*(self: ptr ISVGExternalResourcesRequired, p: ptr ptr ISVGAnimatedBoolean): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_externalResourcesRequired(self, p) +proc get_viewBox*(self: ptr ISVGFitToViewBox, p: ptr ptr ISVGAnimatedRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewBox(self, p) +proc putref_preserveAspectRatio*(self: ptr ISVGFitToViewBox, v: ptr ISVGAnimatedPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_preserveAspectRatio(self, v) +proc get_preserveAspectRatio*(self: ptr ISVGFitToViewBox, p: ptr ptr ISVGAnimatedPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_preserveAspectRatio(self, p) +proc get_zoomAndPan*(self: ptr ISVGZoomAndPan, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoomAndPan(self, p) +proc get_href*(self: ptr ISVGURIReference, p: ptr ptr ISVGAnimatedString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_href(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedAngle, v: ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedAngle, p: ptr ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedAngle, v: ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedAngle, p: ptr ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedTransformList, v: ptr ISVGTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedTransformList, p: ptr ptr ISVGTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedTransformList, v: ptr ISVGTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedTransformList, p: ptr ptr ISVGTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc put_baseVal*(self: ptr ISVGAnimatedBoolean, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedBoolean, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc put_animVal*(self: ptr ISVGAnimatedBoolean, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedBoolean, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc put_baseVal*(self: ptr ISVGAnimatedEnumeration, v: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedEnumeration, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc put_animVal*(self: ptr ISVGAnimatedEnumeration, v: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedEnumeration, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc put_baseVal*(self: ptr ISVGAnimatedInteger, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedInteger, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc put_animVal*(self: ptr ISVGAnimatedInteger, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedInteger, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedLength, v: ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedLength, p: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedLength, v: ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedLength, p: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedLengthList, v: ptr ISVGLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedLengthList, p: ptr ptr ISVGLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedLengthList, v: ptr ISVGLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedLengthList, p: ptr ptr ISVGLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc put_baseVal*(self: ptr ISVGAnimatedNumber, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedNumber, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc put_animVal*(self: ptr ISVGAnimatedNumber, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedNumber, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedNumberList, v: ptr ISVGNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedNumberList, p: ptr ptr ISVGNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedNumberList, v: ptr ISVGNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedNumberList, p: ptr ptr ISVGNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedRect, v: ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedRect, p: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedRect, v: ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedRect, p: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc put_baseVal*(self: ptr ISVGAnimatedString, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedString, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc get_animVal*(self: ptr ISVGAnimatedString, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_clipPathUnits*(self: ptr ISVGClipPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_clipPathUnits(self, v) +proc get_clipPathUnits*(self: ptr ISVGClipPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_clipPathUnits(self, p) +proc get_rootElement*(self: ptr ISVGDocument, p: ptr ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rootElement(self, p) +proc getSVGDocument*(self: ptr IGetSVGDocument, ppSVGDocument: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getSVGDocument(self, ppSVGDocument) +proc put_xmlbase*(self: ptr ISVGElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_xmlbase(self, v) +proc get_xmlbase*(self: ptr ISVGElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xmlbase(self, p) +proc putref_ownerSVGElement*(self: ptr ISVGElement, v: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_ownerSVGElement(self, v) +proc get_ownerSVGElement*(self: ptr ISVGElement, p: ptr ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerSVGElement(self, p) +proc putref_viewportElement*(self: ptr ISVGElement, v: ptr ISVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_viewportElement(self, v) +proc get_viewportElement*(self: ptr ISVGElement, p: ptr ptr ISVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewportElement(self, p) +proc putref_focusable*(self: ptr ISVGElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_focusable(self, v) +proc get_focusable*(self: ptr ISVGElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_focusable(self, p) +proc put_unitType*(self: ptr ISVGLength, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unitType(self, v) +proc get_unitType*(self: ptr ISVGLength, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unitType(self, p) +proc put_value*(self: ptr ISVGLength, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr ISVGLength, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_valueInSpecifiedUnits*(self: ptr ISVGLength, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueInSpecifiedUnits(self, v) +proc get_valueInSpecifiedUnits*(self: ptr ISVGLength, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueInSpecifiedUnits(self, p) +proc put_valueAsString*(self: ptr ISVGLength, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_valueAsString(self, v) +proc get_valueAsString*(self: ptr ISVGLength, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_valueAsString(self, p) +proc newValueSpecifiedUnits*(self: ptr ISVGLength, unitType: int16, valueInSpecifiedUnits: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.newValueSpecifiedUnits(self, unitType, valueInSpecifiedUnits) +proc convertToSpecifiedUnits*(self: ptr ISVGLength, unitType: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.convertToSpecifiedUnits(self, unitType) +proc put_numberOfItems*(self: ptr ISVGLengthList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGLengthList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGLengthList, newItem: ptr ISVGLength, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, newItem, ppResult) +proc getItem*(self: ptr ISVGLengthList, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGLengthList, newItem: ptr ISVGLength, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, newItem, index, ppResult) +proc replaceItem*(self: ptr ISVGLengthList, newItem: ptr ISVGLength, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, newItem, index, ppResult) +proc removeItem*(self: ptr ISVGLengthList, index: LONG, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGLengthList, newItem: ptr ISVGLength, ppResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, newItem, ppResult) +proc put_a*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_a(self, v) +proc get_a*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_a(self, p) +proc put_b*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_b(self, v) +proc get_b*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_b(self, p) +proc put_c*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_c(self, v) +proc get_c*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_c(self, p) +proc put_d*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_d(self, v) +proc get_d*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_d(self, p) +proc put_e*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_e(self, v) +proc get_e*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_e(self, p) +proc put_f*(self: ptr ISVGMatrix, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_f(self, v) +proc get_f*(self: ptr ISVGMatrix, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_f(self, p) +proc multiply*(self: ptr ISVGMatrix, secondMatrix: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.multiply(self, secondMatrix, ppResult) +proc inverse*(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.inverse(self, ppResult) +proc translate*(self: ptr ISVGMatrix, x: float32, y: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.translate(self, x, y, ppResult) +proc scale*(self: ptr ISVGMatrix, scaleFactor: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scale(self, scaleFactor, ppResult) +proc scaleNonUniform*(self: ptr ISVGMatrix, scaleFactorX: float32, scaleFactorY: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.scaleNonUniform(self, scaleFactorX, scaleFactorY, ppResult) +proc rotate*(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.rotate(self, angle, ppResult) +proc rotateFromVector*(self: ptr ISVGMatrix, x: float32, y: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.rotateFromVector(self, x, y, ppResult) +proc flipX*(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.flipX(self, ppResult) +proc flipY*(self: ptr ISVGMatrix, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.flipY(self, ppResult) +proc skewX*(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.skewX(self, angle, ppResult) +proc skewY*(self: ptr ISVGMatrix, angle: float32, ppResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.skewY(self, angle, ppResult) +proc put_value*(self: ptr ISVGNumber, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr ISVGNumber, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_numberOfItems*(self: ptr ISVGNumberList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGNumberList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, newItem, ppResult) +proc getItem*(self: ptr ISVGNumberList, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, newItem, index, ppResult) +proc replaceItem*(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, newItem, index, ppResult) +proc removeItem*(self: ptr ISVGNumberList, index: LONG, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGNumberList, newItem: ptr ISVGNumber, ppResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, newItem, ppResult) +proc putref_patternUnits*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_patternUnits(self, v) +proc get_patternUnits*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_patternUnits(self, p) +proc putref_patternContentUnits*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_patternContentUnits(self, v) +proc get_patternContentUnits*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_patternContentUnits(self, p) +proc putref_patternTransform*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_patternTransform(self, v) +proc get_patternTransform*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_patternTransform(self, p) +proc putref_x*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGPatternElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGPatternElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_pathSegType*(self: ptr ISVGPathSeg, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pathSegType(self, v) +proc get_pathSegType*(self: ptr ISVGPathSeg, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathSegType(self, p) +proc get_pathSegTypeAsLetter*(self: ptr ISVGPathSeg, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathSegTypeAsLetter(self, p) +proc put_x*(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_r1*(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_r1(self, v) +proc get_r1*(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r1(self, p) +proc put_r2*(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_r2(self, v) +proc get_r2*(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r2(self, p) +proc put_angle*(self: ptr ISVGPathSegArcAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_angle(self, v) +proc get_angle*(self: ptr ISVGPathSegArcAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_angle(self, p) +proc put_largeArcFlag*(self: ptr ISVGPathSegArcAbs, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_largeArcFlag(self, v) +proc get_largeArcFlag*(self: ptr ISVGPathSegArcAbs, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_largeArcFlag(self, p) +proc put_sweepFlag*(self: ptr ISVGPathSegArcAbs, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_sweepFlag(self, v) +proc get_sweepFlag*(self: ptr ISVGPathSegArcAbs, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sweepFlag(self, p) +proc put_x*(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_r1*(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_r1(self, v) +proc get_r1*(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r1(self, p) +proc put_r2*(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_r2(self, v) +proc get_r2*(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r2(self, p) +proc put_angle*(self: ptr ISVGPathSegArcRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_angle(self, v) +proc get_angle*(self: ptr ISVGPathSegArcRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_angle(self, p) +proc put_largeArcFlag*(self: ptr ISVGPathSegArcRel, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_largeArcFlag(self, v) +proc get_largeArcFlag*(self: ptr ISVGPathSegArcRel, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_largeArcFlag(self, p) +proc put_sweepFlag*(self: ptr ISVGPathSegArcRel, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_sweepFlag(self, v) +proc get_sweepFlag*(self: ptr ISVGPathSegArcRel, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sweepFlag(self, p) +proc put_x*(self: ptr ISVGPathSegMovetoAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegMovetoAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegMovetoAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegMovetoAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegMovetoRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegMovetoRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegMovetoRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegMovetoRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegLinetoAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegLinetoAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegLinetoAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegLinetoAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegLinetoRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegLinetoRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegLinetoRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegLinetoRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x1*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x1(self, v) +proc get_x1*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc put_y1*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y1(self, v) +proc get_y1*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc put_x2*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x2(self, v) +proc get_x2*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc put_y2*(self: ptr ISVGPathSegCurvetoCubicAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y2(self, v) +proc get_y2*(self: ptr ISVGPathSegCurvetoCubicAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x1*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x1(self, v) +proc get_x1*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc put_y1*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y1(self, v) +proc get_y1*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc put_x2*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x2(self, v) +proc get_x2*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc put_y2*(self: ptr ISVGPathSegCurvetoCubicRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y2(self, v) +proc get_y2*(self: ptr ISVGPathSegCurvetoCubicRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x2*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x2(self, v) +proc get_x2*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc put_y2*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y2(self, v) +proc get_y2*(self: ptr ISVGPathSegCurvetoCubicSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x2*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x2(self, v) +proc get_x2*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc put_y2*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y2(self, v) +proc get_y2*(self: ptr ISVGPathSegCurvetoCubicSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x1*(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x1(self, v) +proc get_x1*(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc put_y1*(self: ptr ISVGPathSegCurvetoQuadraticAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y1(self, v) +proc get_y1*(self: ptr ISVGPathSegCurvetoQuadraticAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x1*(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x1(self, v) +proc get_x1*(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc put_y1*(self: ptr ISVGPathSegCurvetoQuadraticRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y1(self, v) +proc get_y1*(self: ptr ISVGPathSegCurvetoQuadraticRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoQuadraticSmoothAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegCurvetoQuadraticSmoothRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_x*(self: ptr ISVGPathSegLinetoHorizontalAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegLinetoHorizontalAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_x*(self: ptr ISVGPathSegLinetoHorizontalRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPathSegLinetoHorizontalRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPathSegLinetoVerticalAbs, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegLinetoVerticalAbs, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_y*(self: ptr ISVGPathSegLinetoVerticalRel, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPathSegLinetoVerticalRel, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_numberOfItems*(self: ptr ISVGPathSegList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGPathSegList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, newItem, ppResult) +proc getItem*(self: ptr ISVGPathSegList, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, newItem, index, ppResult) +proc replaceItem*(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, newItem, index, ppResult) +proc removeItem*(self: ptr ISVGPathSegList, index: LONG, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGPathSegList, newItem: ptr ISVGPathSeg, ppResult: ptr ptr ISVGPathSeg): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, newItem, ppResult) +proc put_x*(self: ptr ISVGPoint, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGPoint, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGPoint, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGPoint, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc matrixTransform*(self: ptr ISVGPoint, pMatrix: ptr ISVGMatrix, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.matrixTransform(self, pMatrix, ppResult) +proc put_numberOfItems*(self: ptr ISVGPointList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGPointList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGPointList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, pNewItem, ppResult) +proc getItem*(self: ptr ISVGPointList, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, pNewItem, index, ppResult) +proc replaceItem*(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, pNewItem, index, ppResult) +proc removeItem*(self: ptr ISVGPointList, index: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGPointList, pNewItem: ptr ISVGPoint, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, pNewItem, ppResult) +proc put_x*(self: ptr ISVGRect, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_x(self, v) +proc get_x*(self: ptr ISVGRect, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc put_y*(self: ptr ISVGRect, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_y(self, v) +proc get_y*(self: ptr ISVGRect, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc put_width*(self: ptr ISVGRect, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr ISVGRect, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr ISVGRect, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr ISVGRect, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_numberOfItems*(self: ptr ISVGStringList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGStringList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGStringList, newItem: BSTR, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, newItem, ppResult) +proc getItem*(self: ptr ISVGStringList, index: LONG, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGStringList, newItem: BSTR, index: LONG, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, newItem, index, ppResult) +proc replaceItem*(self: ptr ISVGStringList, newItem: BSTR, index: LONG, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, newItem, index, ppResult) +proc removeItem*(self: ptr ISVGStringList, index: LONG, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGStringList, newItem: BSTR, ppResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, newItem, ppResult) +proc put_type*(self: ptr ISVGTransform, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr ISVGTransform, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc putref_matrix*(self: ptr ISVGTransform, v: ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_matrix(self, v) +proc get_matrix*(self: ptr ISVGTransform, p: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_matrix(self, p) +proc put_angle*(self: ptr ISVGTransform, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_angle(self, v) +proc get_angle*(self: ptr ISVGTransform, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_angle(self, p) +proc setMatrix*(self: ptr ISVGTransform, matrix: ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setMatrix(self, matrix) +proc setTranslate*(self: ptr ISVGTransform, tx: float32, ty: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setTranslate(self, tx, ty) +proc setScale*(self: ptr ISVGTransform, sx: float32, sy: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setScale(self, sx, sy) +proc setRotate*(self: ptr ISVGTransform, angle: float32, cx: float32, cy: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setRotate(self, angle, cx, cy) +proc setSkewX*(self: ptr ISVGTransform, angle: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setSkewX(self, angle) +proc setSkewY*(self: ptr ISVGTransform, angle: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setSkewY(self, angle) +proc putref_x*(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGSVGElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGSVGElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc put_contentScriptType*(self: ptr ISVGSVGElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_contentScriptType(self, v) +proc get_contentScriptType*(self: ptr ISVGSVGElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentScriptType(self, p) +proc put_contentStyleType*(self: ptr ISVGSVGElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_contentStyleType(self, v) +proc get_contentStyleType*(self: ptr ISVGSVGElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contentStyleType(self, p) +proc putref_viewport*(self: ptr ISVGSVGElement, v: ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_viewport(self, v) +proc get_viewport*(self: ptr ISVGSVGElement, p: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewport(self, p) +proc put_pixelUnitToMillimeterX*(self: ptr ISVGSVGElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelUnitToMillimeterX(self, v) +proc get_pixelUnitToMillimeterX*(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelUnitToMillimeterX(self, p) +proc put_pixelUnitToMillimeterY*(self: ptr ISVGSVGElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pixelUnitToMillimeterY(self, v) +proc get_pixelUnitToMillimeterY*(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pixelUnitToMillimeterY(self, p) +proc put_screenPixelToMillimeterX*(self: ptr ISVGSVGElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_screenPixelToMillimeterX(self, v) +proc get_screenPixelToMillimeterX*(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenPixelToMillimeterX(self, p) +proc put_screenPixelToMillimeterY*(self: ptr ISVGSVGElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_screenPixelToMillimeterY(self, v) +proc get_screenPixelToMillimeterY*(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_screenPixelToMillimeterY(self, p) +proc put_useCurrentView*(self: ptr ISVGSVGElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_useCurrentView(self, v) +proc get_useCurrentView*(self: ptr ISVGSVGElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_useCurrentView(self, p) +proc putref_currentView*(self: ptr ISVGSVGElement, v: ptr ISVGViewSpec): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_currentView(self, v) +proc get_currentView*(self: ptr ISVGSVGElement, p: ptr ptr ISVGViewSpec): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentView(self, p) +proc put_currentScale*(self: ptr ISVGSVGElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_currentScale(self, v) +proc get_currentScale*(self: ptr ISVGSVGElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentScale(self, p) +proc putref_currentTranslate*(self: ptr ISVGSVGElement, v: ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_currentTranslate(self, v) +proc get_currentTranslate*(self: ptr ISVGSVGElement, p: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentTranslate(self, p) +proc suspendRedraw*(self: ptr ISVGSVGElement, maxWaitMilliseconds: ULONG, pResult: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.suspendRedraw(self, maxWaitMilliseconds, pResult) +proc unsuspendRedraw*(self: ptr ISVGSVGElement, suspendHandeID: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.unsuspendRedraw(self, suspendHandeID) +proc unsuspendRedrawAll*(self: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.unsuspendRedrawAll(self) +proc forceRedraw*(self: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.forceRedraw(self) +proc pauseAnimations*(self: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.pauseAnimations(self) +proc unpauseAnimations*(self: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.unpauseAnimations(self) +proc animationsPaused*(self: ptr ISVGSVGElement, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.animationsPaused(self, pResult) +proc getCurrentTime*(self: ptr ISVGSVGElement, pResult: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCurrentTime(self, pResult) +proc setCurrentTime*(self: ptr ISVGSVGElement, seconds: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setCurrentTime(self, seconds) +proc getIntersectionList*(self: ptr ISVGSVGElement, rect: ptr ISVGRect, referenceElement: ptr ISVGElement, pResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getIntersectionList(self, rect, referenceElement, pResult) +proc getEnclosureList*(self: ptr ISVGSVGElement, rect: ptr ISVGRect, referenceElement: ptr ISVGElement, pResult: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getEnclosureList(self, rect, referenceElement, pResult) +proc checkIntersection*(self: ptr ISVGSVGElement, element: ptr ISVGElement, rect: ptr ISVGRect, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.checkIntersection(self, element, rect, pResult) +proc checkEnclosure*(self: ptr ISVGSVGElement, element: ptr ISVGElement, rect: ptr ISVGRect, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.checkEnclosure(self, element, rect, pResult) +proc deselectAll*(self: ptr ISVGSVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deselectAll(self) +proc createSVGNumber*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGNumber(self, pResult) +proc createSVGLength*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGLength(self, pResult) +proc createSVGAngle*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGAngle(self, pResult) +proc createSVGPoint*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPoint(self, pResult) +proc createSVGMatrix*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGMatrix): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGMatrix(self, pResult) +proc createSVGRect*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGRect(self, pResult) +proc createSVGTransform*(self: ptr ISVGSVGElement, pResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGTransform(self, pResult) +proc createSVGTransformFromMatrix*(self: ptr ISVGSVGElement, matrix: ptr ISVGMatrix, pResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGTransformFromMatrix(self, matrix, pResult) +proc getElementById*(self: ptr ISVGSVGElement, elementId: BSTR, pResult: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementById(self, elementId, pResult) +proc putref_x*(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGUseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGUseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc putref_instanceRoot*(self: ptr ISVGUseElement, v: ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_instanceRoot(self, v) +proc get_instanceRoot*(self: ptr ISVGUseElement, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_instanceRoot(self, p) +proc putref_animatedInstanceRoot*(self: ptr ISVGUseElement, v: ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animatedInstanceRoot(self, v) +proc get_animatedInstanceRoot*(self: ptr ISVGUseElement, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animatedInstanceRoot(self, p) +proc item*(self: ptr IHTMLStyleSheetRulesAppliedCollection, index: LONG, ppHTMLStyleSheetRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppHTMLStyleSheetRule) +proc get_length*(self: ptr IHTMLStyleSheetRulesAppliedCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc propertyAppliedBy*(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, ppRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyAppliedBy(self, name, ppRule) +proc propertyAppliedTrace*(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, index: LONG, ppRule: ptr ptr IHTMLStyleSheetRule): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyAppliedTrace(self, name, index, ppRule) +proc propertyAppliedTraceLength*(self: ptr IHTMLStyleSheetRulesAppliedCollection, name: BSTR, pLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyAppliedTraceLength(self, name, pLength) +proc get_element*(self: ptr IRulesApplied, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_element(self, p) +proc get_inlineStyles*(self: ptr IRulesApplied, p: ptr ptr IHTMLStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_inlineStyles(self, p) +proc get_appliedRules*(self: ptr IRulesApplied, p: ptr ptr IHTMLStyleSheetRulesAppliedCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_appliedRules(self, p) +proc propertyIsInline*(self: ptr IRulesApplied, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyIsInline(self, name, p) +proc propertyIsInheritable*(self: ptr IRulesApplied, name: BSTR, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyIsInheritable(self, name, p) +proc hasInheritableProperty*(self: ptr IRulesApplied, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasInheritableProperty(self, p) +proc item*(self: ptr IRulesAppliedCollection, index: LONG, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppRulesApplied) +proc get_length*(self: ptr IRulesAppliedCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_element*(self: ptr IRulesAppliedCollection, p: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_element(self, p) +proc propertyInheritedFrom*(self: ptr IRulesAppliedCollection, name: BSTR, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyInheritedFrom(self, name, ppRulesApplied) +proc get_propertyCount*(self: ptr IRulesAppliedCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_propertyCount(self, p) +proc property*(self: ptr IRulesAppliedCollection, index: LONG, pbstrProperty: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.property(self, index, pbstrProperty) +proc propertyInheritedTrace*(self: ptr IRulesAppliedCollection, name: BSTR, index: LONG, ppRulesApplied: ptr ptr IRulesApplied): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyInheritedTrace(self, name, index, ppRulesApplied) +proc propertyInheritedTraceLength*(self: ptr IRulesAppliedCollection, name: BSTR, pLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.propertyInheritedTraceLength(self, name, pLength) +proc put_numberOfItems*(self: ptr ISVGTransformList, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_numberOfItems(self, v) +proc get_numberOfItems*(self: ptr ISVGTransformList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_numberOfItems(self, p) +proc clear*(self: ptr ISVGTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clear(self) +proc initialize*(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initialize(self, newItem, ppResult) +proc getItem*(self: ptr ISVGTransformList, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getItem(self, index, ppResult) +proc insertItemBefore*(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertItemBefore(self, newItem, index, ppResult) +proc replaceItem*(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceItem(self, newItem, index, ppResult) +proc removeItem*(self: ptr ISVGTransformList, index: LONG, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeItem(self, index, ppResult) +proc appendItem*(self: ptr ISVGTransformList, newItem: ptr ISVGTransform, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendItem(self, newItem, ppResult) +proc createSVGTransformFromMatrix*(self: ptr ISVGTransformList, newItem: ptr ISVGMatrix, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGTransformFromMatrix(self, newItem, ppResult) +proc consolidate*(self: ptr ISVGTransformList, ppResult: ptr ptr ISVGTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.consolidate(self, ppResult) +proc putref_points*(self: ptr ISVGAnimatedPoints, v: ptr ISVGPointList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_points(self, v) +proc get_points*(self: ptr ISVGAnimatedPoints, p: ptr ptr ISVGPointList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_points(self, p) +proc putref_animatedPoints*(self: ptr ISVGAnimatedPoints, v: ptr ISVGPointList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animatedPoints(self, v) +proc get_animatedPoints*(self: ptr ISVGAnimatedPoints, p: ptr ptr ISVGPointList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animatedPoints(self, p) +proc putref_cx*(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cx(self, v) +proc get_cx*(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cx(self, p) +proc putref_cy*(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cy(self, v) +proc get_cy*(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cy(self, p) +proc putref_r*(self: ptr ISVGCircleElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_r(self, v) +proc get_r*(self: ptr ISVGCircleElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r(self, p) +proc putref_cx*(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cx(self, v) +proc get_cx*(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cx(self, p) +proc putref_cy*(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cy(self, v) +proc get_cy*(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cy(self, p) +proc putref_rx*(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_rx(self, v) +proc get_rx*(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rx(self, p) +proc putref_ry*(self: ptr ISVGEllipseElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_ry(self, v) +proc get_ry*(self: ptr ISVGEllipseElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ry(self, p) +proc putref_x1*(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x1(self, v) +proc get_x1*(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc putref_y1*(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y1(self, v) +proc get_y1*(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc putref_x2*(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x2(self, v) +proc get_x2*(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc putref_y2*(self: ptr ISVGLineElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y2(self, v) +proc get_y2*(self: ptr ISVGLineElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc putref_x*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc putref_rx*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_rx(self, v) +proc get_rx*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rx(self, p) +proc putref_ry*(self: ptr ISVGRectElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_ry(self, v) +proc get_ry*(self: ptr ISVGRectElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ry(self, p) +proc putref_pathSegList*(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_pathSegList(self, v) +proc get_pathSegList*(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathSegList(self, p) +proc putref_normalizedPathSegList*(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_normalizedPathSegList(self, v) +proc get_normalizedPathSegList*(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_normalizedPathSegList(self, p) +proc putref_animatedPathSegList*(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animatedPathSegList(self, v) +proc get_animatedPathSegList*(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animatedPathSegList(self, p) +proc putref_animatedNormalizedPathSegList*(self: ptr ISVGAnimatedPathData, v: ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animatedNormalizedPathSegList(self, v) +proc get_animatedNormalizedPathSegList*(self: ptr ISVGAnimatedPathData, p: ptr ptr ISVGPathSegList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animatedNormalizedPathSegList(self, p) +proc putref_pathLength*(self: ptr ISVGPathElement, v: ptr ISVGAnimatedNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_pathLength(self, v) +proc get_pathLength*(self: ptr ISVGPathElement, p: ptr ptr ISVGAnimatedNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pathLength(self, p) +proc getTotalLength*(self: ptr ISVGPathElement, pfltResult: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getTotalLength(self, pfltResult) +proc getPointAtLength*(self: ptr ISVGPathElement, fltdistance: float32, ppPointResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPointAtLength(self, fltdistance, ppPointResult) +proc getPathSegAtLength*(self: ptr ISVGPathElement, fltdistance: float32, plResult: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPathSegAtLength(self, fltdistance, plResult) +proc createSVGPathSegClosePath*(self: ptr ISVGPathElement, ppResult: ptr ptr ISVGPathSegClosePath): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegClosePath(self, ppResult) +proc createSVGPathSegMovetoAbs*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegMovetoAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegMovetoAbs(self, x, y, ppResult) +proc createSVGPathSegMovetoRel*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegMovetoRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegMovetoRel(self, x, y, ppResult) +proc createSVGPathSegLinetoAbs*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegLinetoAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoAbs(self, x, y, ppResult) +proc createSVGPathSegLinetoRel*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegLinetoRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoRel(self, x, y, ppResult) +proc createSVGPathSegCurvetoCubicAbs*(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoCubicAbs(self, x, y, x1, y1, x2, y2, ppResult) +proc createSVGPathSegCurvetoCubicRel*(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoCubicRel(self, x, y, x1, y1, x2, y2, ppResult) +proc createSVGPathSegCurvetoQuadraticAbs*(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoQuadraticAbs(self, x, y, x1, y1, ppResult) +proc createSVGPathSegCurvetoQuadraticRel*(self: ptr ISVGPathElement, x: float32, y: float32, x1: float32, y1: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoQuadraticRel(self, x, y, x1, y1, ppResult) +proc createSVGPathSegArcAbs*(self: ptr ISVGPathElement, x: float32, y: float32, r1: float32, r2: float32, angle: float32, largeArcFlag: VARIANT_BOOL, sweepFlag: VARIANT_BOOL, ppResult: ptr ptr ISVGPathSegArcAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegArcAbs(self, x, y, r1, r2, angle, largeArcFlag, sweepFlag, ppResult) +proc createSVGPathSegArcRel*(self: ptr ISVGPathElement, x: float32, y: float32, r1: float32, r2: float32, angle: float32, largeArcFlag: VARIANT_BOOL, sweepFlag: VARIANT_BOOL, ppResult: ptr ptr ISVGPathSegArcRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegArcRel(self, x, y, r1, r2, angle, largeArcFlag, sweepFlag, ppResult) +proc createSVGPathSegLinetoHorizontalAbs*(self: ptr ISVGPathElement, x: float32, ppResult: ptr ptr ISVGPathSegLinetoHorizontalAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoHorizontalAbs(self, x, ppResult) +proc createSVGPathSegLinetoHorizontalRel*(self: ptr ISVGPathElement, x: float32, ppResult: ptr ptr ISVGPathSegLinetoHorizontalRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoHorizontalRel(self, x, ppResult) +proc createSVGPathSegLinetoVerticalAbs*(self: ptr ISVGPathElement, y: float32, ppResult: ptr ptr ISVGPathSegLinetoVerticalAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoVerticalAbs(self, y, ppResult) +proc createSVGPathSegLinetoVerticalRel*(self: ptr ISVGPathElement, y: float32, ppResult: ptr ptr ISVGPathSegLinetoVerticalRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegLinetoVerticalRel(self, y, ppResult) +proc createSVGPathSegCurvetoCubicSmoothAbs*(self: ptr ISVGPathElement, x: float32, y: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicSmoothAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoCubicSmoothAbs(self, x, y, x2, y2, ppResult) +proc createSVGPathSegCurvetoCubicSmoothRel*(self: ptr ISVGPathElement, x: float32, y: float32, x2: float32, y2: float32, ppResult: ptr ptr ISVGPathSegCurvetoCubicSmoothRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoCubicSmoothRel(self, x, y, x2, y2, ppResult) +proc createSVGPathSegCurvetoQuadraticSmoothAbs*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticSmoothAbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoQuadraticSmoothAbs(self, x, y, ppResult) +proc createSVGPathSegCurvetoQuadraticSmoothRel*(self: ptr ISVGPathElement, x: float32, y: float32, ppResult: ptr ptr ISVGPathSegCurvetoQuadraticSmoothRel): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createSVGPathSegCurvetoQuadraticSmoothRel(self, x, y, ppResult) +proc put_align*(self: ptr ISVGPreserveAspectRatio, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_align(self, v) +proc get_align*(self: ptr ISVGPreserveAspectRatio, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_align(self, p) +proc put_meetOrSlice*(self: ptr ISVGPreserveAspectRatio, v: int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_meetOrSlice(self, v) +proc get_meetOrSlice*(self: ptr ISVGPreserveAspectRatio, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_meetOrSlice(self, p) +proc putref_baseVal*(self: ptr ISVGAnimatedPreserveAspectRatio, v: ptr ISVGPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_baseVal(self, v) +proc get_baseVal*(self: ptr ISVGAnimatedPreserveAspectRatio, p: ptr ptr ISVGPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseVal(self, p) +proc putref_animVal*(self: ptr ISVGAnimatedPreserveAspectRatio, v: ptr ISVGPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_animVal(self, v) +proc get_animVal*(self: ptr ISVGAnimatedPreserveAspectRatio, p: ptr ptr ISVGPreserveAspectRatio): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animVal(self, p) +proc putref_x*(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGImageElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGImageElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc putref_offset*(self: ptr ISVGStopElement, v: ptr ISVGAnimatedNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_offset(self, v) +proc get_offset*(self: ptr ISVGStopElement, p: ptr ptr ISVGAnimatedNumber): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_offset(self, p) +proc putref_gradientUnits*(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_gradientUnits(self, v) +proc get_gradientUnits*(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_gradientUnits(self, p) +proc putref_gradientTransform*(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_gradientTransform(self, v) +proc get_gradientTransform*(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedTransformList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_gradientTransform(self, p) +proc putref_spreadMethod*(self: ptr ISVGGradientElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_spreadMethod(self, v) +proc get_spreadMethod*(self: ptr ISVGGradientElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_spreadMethod(self, p) +proc putref_x1*(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x1(self, v) +proc get_x1*(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x1(self, p) +proc putref_y1*(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y1(self, v) +proc get_y1*(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y1(self, p) +proc putref_x2*(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x2(self, v) +proc get_x2*(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x2(self, p) +proc putref_y2*(self: ptr ISVGLinearGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y2(self, v) +proc get_y2*(self: ptr ISVGLinearGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y2(self, p) +proc putref_cx*(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cx(self, v) +proc get_cx*(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cx(self, p) +proc putref_cy*(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_cy(self, v) +proc get_cy*(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cy(self, p) +proc putref_r*(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_r(self, v) +proc get_r*(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_r(self, p) +proc putref_fx*(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_fx(self, v) +proc get_fx*(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fx(self, p) +proc putref_fy*(self: ptr ISVGRadialGradientElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_fy(self, v) +proc get_fy*(self: ptr ISVGRadialGradientElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fy(self, p) +proc putref_maskUnits*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_maskUnits(self, v) +proc get_maskUnits*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maskUnits(self, p) +proc putref_maskContentUnits*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_maskContentUnits(self, v) +proc get_maskContentUnits*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maskContentUnits(self, p) +proc putref_x*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_width*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_width(self, v) +proc get_width*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc putref_height*(self: ptr ISVGMaskElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_height(self, v) +proc get_height*(self: ptr ISVGMaskElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc putref_refX*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_refX(self, v) +proc get_refX*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_refX(self, p) +proc putref_refY*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_refY(self, v) +proc get_refY*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_refY(self, p) +proc putref_markerUnits*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_markerUnits(self, v) +proc get_markerUnits*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerUnits(self, p) +proc putref_markerWidth*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_markerWidth(self, v) +proc get_markerWidth*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerWidth(self, p) +proc putref_markerHeight*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_markerHeight(self, v) +proc get_markerHeight*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_markerHeight(self, p) +proc putref_orientType*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_orientType(self, v) +proc get_orientType*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orientType(self, p) +proc putref_orientAngle*(self: ptr ISVGMarkerElement, v: ptr ISVGAnimatedAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_orientAngle(self, v) +proc get_orientAngle*(self: ptr ISVGMarkerElement, p: ptr ptr ISVGAnimatedAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orientAngle(self, p) +proc setOrientToAuto*(self: ptr ISVGMarkerElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setOrientToAuto(self) +proc setOrientToAngle*(self: ptr ISVGMarkerElement, pSVGAngle: ptr ISVGAngle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setOrientToAngle(self, pSVGAngle) +proc get_zoomRectScreen*(self: ptr ISVGZoomEvent, p: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_zoomRectScreen(self, p) +proc get_previousScale*(self: ptr ISVGZoomEvent, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousScale(self, p) +proc get_previousTranslate*(self: ptr ISVGZoomEvent, p: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousTranslate(self, p) +proc get_newScale*(self: ptr ISVGZoomEvent, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newScale(self, p) +proc get_newTranslate*(self: ptr ISVGZoomEvent, p: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newTranslate(self, p) +proc putref_target*(self: ptr ISVGAElement, v: ptr ISVGAnimatedString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_target(self, v) +proc get_target*(self: ptr ISVGAElement, p: ptr ptr ISVGAnimatedString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc putref_viewTarget*(self: ptr ISVGViewElement, v: ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_viewTarget(self, v) +proc get_viewTarget*(self: ptr ISVGViewElement, p: ptr ptr ISVGStringList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_viewTarget(self, p) +proc get_code*(self: ptr IHTMLMediaError, p: ptr int16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_length*(self: ptr IHTMLTimeRanges, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc start*(self: ptr IHTMLTimeRanges, index: LONG, startTime: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.start(self, index, startTime) +proc `end`*(self: ptr IHTMLTimeRanges, index: LONG, endTime: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.`end`(self, index, endTime) +proc startDouble*(self: ptr IHTMLTimeRanges2, index: LONG, startTime: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.startDouble(self, index, startTime) +proc endDouble*(self: ptr IHTMLTimeRanges2, index: LONG, endTime: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.endDouble(self, index, endTime) +proc get_error*(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLMediaError): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_error(self, p) +proc put_src*(self: ptr IHTMLMediaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc get_currentSrc*(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentSrc(self, p) +proc get_networkState*(self: ptr IHTMLMediaElement, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_networkState(self, p) +proc put_preload*(self: ptr IHTMLMediaElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_preload(self, v) +proc get_preload*(self: ptr IHTMLMediaElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_preload(self, p) +proc get_buffered*(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_buffered(self, p) +proc load*(self: ptr IHTMLMediaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.load(self) +proc canPlayType*(self: ptr IHTMLMediaElement, `type`: BSTR, canPlay: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.canPlayType(self, `type`, canPlay) +proc get_seeking*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_seeking(self, p) +proc put_currentTime*(self: ptr IHTMLMediaElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_currentTime(self, v) +proc get_currentTime*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentTime(self, p) +proc get_initialTime*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_initialTime(self, p) +proc get_duration*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_duration(self, p) +proc get_paused*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_paused(self, p) +proc put_defaultPlaybackRate*(self: ptr IHTMLMediaElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultPlaybackRate(self, v) +proc get_defaultPlaybackRate*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultPlaybackRate(self, p) +proc put_playbackRate*(self: ptr IHTMLMediaElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_playbackRate(self, v) +proc get_playbackRate*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_playbackRate(self, p) +proc get_played*(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_played(self, p) +proc get_seekable*(self: ptr IHTMLMediaElement, p: ptr ptr IHTMLTimeRanges): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_seekable(self, p) +proc get_ended*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ended(self, p) +proc put_autoplay*(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_autoplay(self, v) +proc get_autoplay*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_autoplay(self, p) +proc put_loop*(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_loop(self, v) +proc get_loop*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loop(self, p) +proc play*(self: ptr IHTMLMediaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.play(self) +proc pause*(self: ptr IHTMLMediaElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.pause(self) +proc put_controls*(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_controls(self, v) +proc get_controls*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_controls(self, p) +proc put_volume*(self: ptr IHTMLMediaElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_volume(self, v) +proc get_volume*(self: ptr IHTMLMediaElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_volume(self, p) +proc put_muted*(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_muted(self, v) +proc get_muted*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_muted(self, p) +proc put_autobuffer*(self: ptr IHTMLMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_autobuffer(self, v) +proc get_autobuffer*(self: ptr IHTMLMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_autobuffer(self, p) +proc put_currentTimeDouble*(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_currentTimeDouble(self, v) +proc get_currentTimeDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentTimeDouble(self, p) +proc get_initialTimeDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_initialTimeDouble(self, p) +proc get_durationDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_durationDouble(self, p) +proc put_defaultPlaybackRateDouble*(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_defaultPlaybackRateDouble(self, v) +proc get_defaultPlaybackRateDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_defaultPlaybackRateDouble(self, p) +proc put_playbackRateDouble*(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_playbackRateDouble(self, v) +proc get_playbackRateDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_playbackRateDouble(self, p) +proc put_volumeDouble*(self: ptr IHTMLMediaElement2, v: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_volumeDouble(self, v) +proc get_volumeDouble*(self: ptr IHTMLMediaElement2, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_volumeDouble(self, p) +proc put_msPlayToDisabled*(self: ptr IHTMLMSMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPlayToDisabled(self, v) +proc get_msPlayToDisabled*(self: ptr IHTMLMSMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPlayToDisabled(self, p) +proc put_msPlayToPrimary*(self: ptr IHTMLMSMediaElement, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_msPlayToPrimary(self, v) +proc get_msPlayToPrimary*(self: ptr IHTMLMSMediaElement, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msPlayToPrimary(self, p) +proc put_src*(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_src(self, v) +proc get_src*(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_src(self, p) +proc put_type*(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_media*(self: ptr IHTMLSourceElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr IHTMLSourceElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc put_width*(self: ptr IHTMLVideoElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_width(self, v) +proc get_width*(self: ptr IHTMLVideoElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc put_height*(self: ptr IHTMLVideoElement, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_height(self, v) +proc get_height*(self: ptr IHTMLVideoElement, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_videoWidth*(self: ptr IHTMLVideoElement, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_videoWidth(self, p) +proc get_videoHeight*(self: ptr IHTMLVideoElement, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_videoHeight(self, p) +proc put_poster*(self: ptr IHTMLVideoElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_poster(self, v) +proc get_poster*(self: ptr IHTMLVideoElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_poster(self, p) +proc create*(self: ptr IHTMLAudioElementFactory, src: VARIANT, a: ptr ptr IHTMLAudioElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, src, a) +proc get_correspondingElement*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_correspondingElement(self, p) +proc get_correspondingUseElement*(self: ptr ISVGElementInstance, p: ptr ptr ISVGUseElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_correspondingUseElement(self, p) +proc get_parentNode*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentNode(self, p) +proc get_childNodes*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstanceList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, p) +proc get_firstChild*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstChild(self, p) +proc get_lastChild*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastChild(self, p) +proc get_previousSibling*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousSibling(self, p) +proc get_nextSibling*(self: ptr ISVGElementInstance, p: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextSibling(self, p) +proc get_length*(self: ptr ISVGElementInstanceList, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr ISVGElementInstanceList, index: LONG, ppResult: ptr ptr ISVGElementInstance): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppResult) +proc put_code*(self: ptr IDOMException, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_code(self, v) +proc get_code*(self: ptr IDOMException, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_message*(self: ptr IDOMException, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_message(self, p) +proc put_code*(self: ptr IRangeException, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_code(self, v) +proc get_code*(self: ptr IRangeException, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_message*(self: ptr IRangeException, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_message(self, p) +proc put_code*(self: ptr ISVGException, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_code(self, v) +proc get_code*(self: ptr ISVGException, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_message*(self: ptr ISVGException, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_message(self, p) +proc put_code*(self: ptr IEventException, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_code(self, v) +proc get_code*(self: ptr IEventException, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_message*(self: ptr IEventException, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_message(self, p) +proc put_type*(self: ptr ISVGScriptElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr ISVGScriptElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_type*(self: ptr ISVGStyleElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_type(self, v) +proc get_type*(self: ptr ISVGStyleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc put_media*(self: ptr ISVGStyleElement, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_media(self, v) +proc get_media*(self: ptr ISVGStyleElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_media(self, p) +proc putref_textLength*(self: ptr ISVGTextContentElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_textLength(self, v) +proc get_textLength*(self: ptr ISVGTextContentElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textLength(self, p) +proc putref_lengthAdjust*(self: ptr ISVGTextContentElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_lengthAdjust(self, v) +proc get_lengthAdjust*(self: ptr ISVGTextContentElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lengthAdjust(self, p) +proc getNumberOfChars*(self: ptr ISVGTextContentElement, pResult: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNumberOfChars(self, pResult) +proc getComputedTextLength*(self: ptr ISVGTextContentElement, pResult: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getComputedTextLength(self, pResult) +proc getSubStringLength*(self: ptr ISVGTextContentElement, charnum: LONG, nchars: LONG, pResult: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getSubStringLength(self, charnum, nchars, pResult) +proc getStartPositionOfChar*(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getStartPositionOfChar(self, charnum, ppResult) +proc getEndPositionOfChar*(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getEndPositionOfChar(self, charnum, ppResult) +proc getExtentOfChar*(self: ptr ISVGTextContentElement, charnum: LONG, ppResult: ptr ptr ISVGRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getExtentOfChar(self, charnum, ppResult) +proc getRotationOfChar*(self: ptr ISVGTextContentElement, charnum: LONG, pResult: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getRotationOfChar(self, charnum, pResult) +proc getCharNumAtPosition*(self: ptr ISVGTextContentElement, point: ptr ISVGPoint, pResult: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCharNumAtPosition(self, point, pResult) +proc selectSubString*(self: ptr ISVGTextContentElement, charnum: LONG, nchars: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectSubString(self, charnum, nchars) +proc putref_x*(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_x(self, v) +proc get_x*(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc putref_y*(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_y(self, v) +proc get_y*(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_y(self, p) +proc putref_dx*(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_dx(self, v) +proc get_dx*(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dx(self, p) +proc putref_dy*(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_dy(self, v) +proc get_dy*(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedLengthList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dy(self, p) +proc putref_rotate*(self: ptr ISVGTextPositioningElement, v: ptr ISVGAnimatedNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_rotate(self, v) +proc get_rotate*(self: ptr ISVGTextPositioningElement, p: ptr ptr ISVGAnimatedNumberList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_rotate(self, p) +proc get_name*(self: ptr IDOMDocumentType, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_entities*(self: ptr IDOMDocumentType, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_entities(self, p) +proc get_notations*(self: ptr IDOMDocumentType, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_notations(self, p) +proc get_publicId*(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_publicId(self, p) +proc get_systemId*(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemId(self, p) +proc get_internalSubset*(self: ptr IDOMDocumentType, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_internalSubset(self, p) +proc get_root*(self: ptr IDOMNodeIterator, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_root(self, p) +proc get_whatToShow*(self: ptr IDOMNodeIterator, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whatToShow(self, p) +proc get_filter*(self: ptr IDOMNodeIterator, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc get_expandEntityReferences*(self: ptr IDOMNodeIterator, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_expandEntityReferences(self, p) +proc nextNode*(self: ptr IDOMNodeIterator, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextNode(self, ppRetNode) +proc previousNode*(self: ptr IDOMNodeIterator, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.previousNode(self, ppRetNode) +proc detach*(self: ptr IDOMNodeIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detach(self) +proc get_root*(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_root(self, p) +proc get_whatToShow*(self: ptr IDOMTreeWalker, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_whatToShow(self, p) +proc get_filter*(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filter(self, p) +proc get_expandEntityReferences*(self: ptr IDOMTreeWalker, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_expandEntityReferences(self, p) +proc putref_currentNode*(self: ptr IDOMTreeWalker, v: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_currentNode(self, v) +proc get_currentNode*(self: ptr IDOMTreeWalker, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentNode(self, p) +proc parentNode*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.parentNode(self, ppRetNode) +proc firstChild*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.firstChild(self, ppRetNode) +proc lastChild*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.lastChild(self, ppRetNode) +proc previousSibling*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.previousSibling(self, ppRetNode) +proc nextSibling*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextSibling(self, ppRetNode) +proc previousNode*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.previousNode(self, ppRetNode) +proc nextNode*(self: ptr IDOMTreeWalker, ppRetNode: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextNode(self, ppRetNode) +proc get_target*(self: ptr IDOMProcessingInstruction, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, p) +proc put_data*(self: ptr IDOMProcessingInstruction, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, v) +proc get_data*(self: ptr IDOMProcessingInstruction, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, p) +proc get_navigation*(self: ptr IHTMLPerformance, p: ptr ptr IHTMLPerformanceNavigation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_navigation(self, p) +proc get_timing*(self: ptr IHTMLPerformance, p: ptr ptr IHTMLPerformanceTiming): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_timing(self, p) +proc toString*(self: ptr IHTMLPerformance, string: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, string) +proc toJSON*(self: ptr IHTMLPerformance, pVar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toJSON(self, pVar) +proc get_type*(self: ptr IHTMLPerformanceNavigation, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, p) +proc get_redirectCount*(self: ptr IHTMLPerformanceNavigation, p: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_redirectCount(self, p) +proc toString*(self: ptr IHTMLPerformanceNavigation, string: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, string) +proc toJSON*(self: ptr IHTMLPerformanceNavigation, pVar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toJSON(self, pVar) +proc get_navigationStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_navigationStart(self, p) +proc get_unloadEventStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unloadEventStart(self, p) +proc get_unloadEventEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unloadEventEnd(self, p) +proc get_redirectStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_redirectStart(self, p) +proc get_redirectEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_redirectEnd(self, p) +proc get_fetchStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fetchStart(self, p) +proc get_domainLookupStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domainLookupStart(self, p) +proc get_domainLookupEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domainLookupEnd(self, p) +proc get_connectStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_connectStart(self, p) +proc get_connectEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_connectEnd(self, p) +proc get_requestStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_requestStart(self, p) +proc get_responseStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseStart(self, p) +proc get_responseEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseEnd(self, p) +proc get_domLoading*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domLoading(self, p) +proc get_domInteractive*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domInteractive(self, p) +proc get_domContentLoadedEventStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domContentLoadedEventStart(self, p) +proc get_domContentLoadedEventEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domContentLoadedEventEnd(self, p) +proc get_domComplete*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_domComplete(self, p) +proc get_loadEventStart*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loadEventStart(self, p) +proc get_loadEventEnd*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_loadEventEnd(self, p) +proc get_msFirstPaint*(self: ptr IHTMLPerformanceTiming, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_msFirstPaint(self, p) +proc toString*(self: ptr IHTMLPerformanceTiming, string: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, string) +proc toJSON*(self: ptr IHTMLPerformanceTiming, pVar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toJSON(self, pVar) +proc mStartDoc*(self: ptr ITemplatePrinter, bstrTitle: BSTR, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.startDoc(self, bstrTitle, p) +proc stopDoc*(self: ptr ITemplatePrinter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.stopDoc(self) +proc printBlankPage*(self: ptr ITemplatePrinter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.printBlankPage(self) +proc printPage*(self: ptr ITemplatePrinter, pElemDisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.printPage(self, pElemDisp) +proc ensurePrintDialogDefaults*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ensurePrintDialogDefaults(self, p) +proc showPrintDialog*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showPrintDialog(self, p) +proc showPageSetupDialog*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.showPageSetupDialog(self, p) +proc printNonNative*(self: ptr ITemplatePrinter, pMarkup: ptr IUnknown, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.printNonNative(self, pMarkup, p) +proc printNonNativeFrames*(self: ptr ITemplatePrinter, pMarkup: ptr IUnknown, fActiveFrame: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.printNonNativeFrames(self, pMarkup, fActiveFrame) +proc put_framesetDocument*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_framesetDocument(self, v) +proc get_framesetDocument*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_framesetDocument(self, p) +proc put_frameActive*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameActive(self, v) +proc get_frameActive*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameActive(self, p) +proc put_frameAsShown*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameAsShown(self, v) +proc get_frameAsShown*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameAsShown(self, p) +proc put_selection*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selection(self, v) +proc get_selection*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selection(self, p) +proc put_selectedPages*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectedPages(self, v) +proc get_selectedPages*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectedPages(self, p) +proc put_currentPage*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_currentPage(self, v) +proc get_currentPage*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentPage(self, p) +proc put_currentPageAvail*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_currentPageAvail(self, v) +proc get_currentPageAvail*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentPageAvail(self, p) +proc put_collate*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_collate(self, v) +proc get_collate*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_collate(self, p) +proc get_duplex*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_duplex(self, p) +proc put_copies*(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_copies(self, v) +proc get_copies*(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_copies(self, p) +proc put_pageFrom*(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageFrom(self, v) +proc get_pageFrom*(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageFrom(self, p) +proc put_pageTo*(self: ptr ITemplatePrinter, v: USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_pageTo(self, v) +proc get_pageTo*(self: ptr ITemplatePrinter, p: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageTo(self, p) +proc put_tableOfLinks*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tableOfLinks(self, v) +proc get_tableOfLinks*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tableOfLinks(self, p) +proc put_allLinkedDocuments*(self: ptr ITemplatePrinter, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_allLinkedDocuments(self, v) +proc get_allLinkedDocuments*(self: ptr ITemplatePrinter, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_allLinkedDocuments(self, p) +proc put_header*(self: ptr ITemplatePrinter, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_header(self, v) +proc get_header*(self: ptr ITemplatePrinter, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_header(self, p) +proc put_footer*(self: ptr ITemplatePrinter, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_footer(self, v) +proc get_footer*(self: ptr ITemplatePrinter, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_footer(self, p) +proc put_marginLeft*(self: ptr ITemplatePrinter, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginLeft(self, v) +proc get_marginLeft*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginLeft(self, p) +proc put_marginRight*(self: ptr ITemplatePrinter, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginRight(self, v) +proc get_marginRight*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginRight(self, p) +proc put_marginTop*(self: ptr ITemplatePrinter, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginTop(self, v) +proc get_marginTop*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginTop(self, p) +proc put_marginBottom*(self: ptr ITemplatePrinter, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_marginBottom(self, v) +proc get_marginBottom*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_marginBottom(self, p) +proc get_pageWidth*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageWidth(self, p) +proc get_pageHeight*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_pageHeight(self, p) +proc get_unprintableLeft*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unprintableLeft(self, p) +proc get_unprintableTop*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unprintableTop(self, p) +proc get_unprintableRight*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unprintableRight(self, p) +proc get_unprintableBottom*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unprintableBottom(self, p) +proc updatePageStatus*(self: ptr ITemplatePrinter, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.updatePageStatus(self, p) +proc put_selectionEnabled*(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selectionEnabled(self, v) +proc get_selectionEnabled*(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selectionEnabled(self, p) +proc put_frameActiveEnabled*(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_frameActiveEnabled(self, v) +proc get_frameActiveEnabled*(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_frameActiveEnabled(self, p) +proc put_orientation*(self: ptr ITemplatePrinter2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_orientation(self, v) +proc get_orientation*(self: ptr ITemplatePrinter2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_orientation(self, p) +proc put_usePrinterCopyCollate*(self: ptr ITemplatePrinter2, v: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_usePrinterCopyCollate(self, v) +proc get_usePrinterCopyCollate*(self: ptr ITemplatePrinter2, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_usePrinterCopyCollate(self, p) +proc deviceSupports*(self: ptr ITemplatePrinter2, bstrProperty: BSTR, pvar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deviceSupports(self, bstrProperty, pvar) +proc put_headerFooterFont*(self: ptr ITemplatePrinter3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_headerFooterFont(self, v) +proc get_headerFooterFont*(self: ptr ITemplatePrinter3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_headerFooterFont(self, p) +proc getPageMarginTop*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginTop(self, pageRule, pageWidth, pageHeight, pMargin) +proc getPageMarginRight*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginRight(self, pageRule, pageWidth, pageHeight, pMargin) +proc getPageMarginBottom*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginBottom(self, pageRule, pageWidth, pageHeight, pMargin) +proc getPageMarginLeft*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pageWidth: LONG, pageHeight: LONG, pMargin: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginLeft(self, pageRule, pageWidth, pageHeight, pMargin) +proc getPageMarginTopImportant*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginTopImportant(self, pageRule, pbImportant) +proc getPageMarginRightImportant*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginRightImportant(self, pageRule, pbImportant) +proc getPageMarginBottomImportant*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginBottomImportant(self, pageRule, pbImportant) +proc getPageMarginLeftImportant*(self: ptr ITemplatePrinter3, pageRule: ptr IDispatch, pbImportant: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPageMarginLeftImportant(self, pageRule, pbImportant) +proc startPrint*(self: ptr IPrintManagerTemplatePrinter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.startPrint(self) +proc drawPreviewPage*(self: ptr IPrintManagerTemplatePrinter, pElemDisp: ptr IDispatch, nPage: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.drawPreviewPage(self, pElemDisp, nPage) +proc setPageCount*(self: ptr IPrintManagerTemplatePrinter, nPage: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setPageCount(self, nPage) +proc invalidatePreview*(self: ptr IPrintManagerTemplatePrinter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.invalidatePreview(self) +proc getPrintTaskOptionValue*(self: ptr IPrintManagerTemplatePrinter, bstrKey: BSTR, pvarin: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPrintTaskOptionValue(self, bstrKey, pvarin) +proc endPrint*(self: ptr IPrintManagerTemplatePrinter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.endPrint(self) +proc putref_startOffset*(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_startOffset(self, v) +proc get_startOffset*(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedLength): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_startOffset(self, p) +proc putref_method*(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_method(self, v) +proc get_method*(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_method(self, p) +proc putref_spacing*(self: ptr ISVGTextPathElement, v: ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_spacing(self, v) +proc get_spacing*(self: ptr ISVGTextPathElement, p: ptr ptr ISVGAnimatedEnumeration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_spacing(self, p) +proc serializeToString*(self: ptr IDOMXmlSerializer, pNode: ptr IHTMLDOMNode, pString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.serializeToString(self, pNode, pString) +proc create*(self: ptr IDOMXmlSerializerFactory, a: ptr ptr IDOMXmlSerializer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, a) +proc parseFromString*(self: ptr IDOMParser, xmlSource: BSTR, mimeType: BSTR, ppNode: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.parseFromString(self, xmlSource, mimeType, ppNode) +proc create*(self: ptr IDOMParserFactory, a: ptr ptr IDOMParser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.create(self, a) +proc put_value*(self: ptr IHTMLProgressElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, v) +proc get_value*(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, p) +proc put_max*(self: ptr IHTMLProgressElement, v: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_max(self, v) +proc get_max*(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_max(self, p) +proc get_position*(self: ptr IHTMLProgressElement, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_position(self, p) +proc get_form*(self: ptr IHTMLProgressElement, p: ptr ptr IHTMLFormElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_form(self, p) +proc get_propertyName*(self: ptr IDOMMSTransitionEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_propertyName(self, p) +proc get_elapsedTime*(self: ptr IDOMMSTransitionEvent, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_elapsedTime(self, p) +proc initMSTransitionEvent*(self: ptr IDOMMSTransitionEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, propertyName: BSTR, elapsedTime: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMSTransitionEvent(self, eventType, canBubble, cancelable, propertyName, elapsedTime) +proc get_animationName*(self: ptr IDOMMSAnimationEvent, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_animationName(self, p) +proc get_elapsedTime*(self: ptr IDOMMSAnimationEvent, p: ptr float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_elapsedTime(self, p) +proc initMSAnimationEvent*(self: ptr IDOMMSAnimationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, animationName: BSTR, elapsedTime: float32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMSAnimationEvent(self, eventType, canBubble, cancelable, animationName, elapsedTime) +proc getCurrentPosition*(self: ptr IWebGeolocation, successCallback: ptr IDispatch, errorCallback: ptr IDispatch, options: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCurrentPosition(self, successCallback, errorCallback, options) +proc watchPosition*(self: ptr IWebGeolocation, successCallback: ptr IDispatch, errorCallback: ptr IDispatch, options: ptr IDispatch, watchId: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.watchPosition(self, successCallback, errorCallback, options, watchId) +proc clearWatch*(self: ptr IWebGeolocation, watchId: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearWatch(self, watchId) +proc get_latitude*(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_latitude(self, p) +proc get_longitude*(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_longitude(self, p) +proc get_altitude*(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altitude(self, p) +proc get_accuracy*(self: ptr IWebGeocoordinates, p: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accuracy(self, p) +proc get_altitudeAccuracy*(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_altitudeAccuracy(self, p) +proc get_heading*(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_heading(self, p) +proc get_speed*(self: ptr IWebGeocoordinates, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_speed(self, p) +proc get_code*(self: ptr IWebGeopositionError, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_code(self, p) +proc get_message*(self: ptr IWebGeopositionError, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_message(self, p) +proc get_coords*(self: ptr IWebGeoposition, p: ptr ptr IWebGeocoordinates): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_coords(self, p) +proc get_timestamp*(self: ptr IWebGeoposition, p: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_timestamp(self, p) +proc get_javaEnabled*(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_javaEnabled(self, p) +proc get_cookieEnabled*(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cookieEnabled(self, p) +proc get_cpuClass*(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_cpuClass(self, p) +proc get_systemLanguage*(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemLanguage(self, p) +proc get_userLanguage*(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_userLanguage(self, p) +proc get_platform*(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_platform(self, p) +proc get_connectionSpeed*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_connectionSpeed(self, p) +proc get_onLine*(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onLine(self, p) +proc get_colorDepth*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_colorDepth(self, p) +proc get_bufferDepth*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bufferDepth(self, p) +proc get_width*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_width(self, p) +proc get_height*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_height(self, p) +proc get_availHeight*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_availHeight(self, p) +proc get_availWidth*(self: ptr IClientCaps, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_availWidth(self, p) +proc get_connectionType*(self: ptr IClientCaps, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_connectionType(self, p) +proc isComponentInstalled*(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, bStrVer: BSTR, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.isComponentInstalled(self, bstrName, bstrUrl, bStrVer, p) +proc getComponentVersion*(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, pbstrVer: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getComponentVersion(self, bstrName, bstrUrl, pbstrVer) +proc compareVersions*(self: ptr IClientCaps, bstrVer1: BSTR, bstrVer2: BSTR, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.compareVersions(self, bstrVer1, bstrVer2, p) +proc addComponentRequest*(self: ptr IClientCaps, bstrName: BSTR, bstrUrl: BSTR, bStrVer: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addComponentRequest(self, bstrName, bstrUrl, bStrVer) +proc doComponentRequest*(self: ptr IClientCaps, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doComponentRequest(self, p) +proc clearComponentRequest*(self: ptr IClientCaps): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.clearComponentRequest(self) +proc get_lastState*(self: ptr IDOMMSManipulationEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastState(self, p) +proc get_currentState*(self: ptr IDOMMSManipulationEvent, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_currentState(self, p) +proc initMSManipulationEvent*(self: ptr IDOMMSManipulationEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, viewArg: ptr IHTMLWindow2, detailArg: LONG, lastState: LONG, currentState: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initMSManipulationEvent(self, eventType, canBubble, cancelable, viewArg, detailArg, lastState, currentState) +proc get_wasClean*(self: ptr IDOMCloseEvent, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_wasClean(self, p) +proc initCloseEvent*(self: ptr IDOMCloseEvent, eventType: BSTR, canBubble: VARIANT_BOOL, cancelable: VARIANT_BOOL, wasClean: VARIANT_BOOL, code: LONG, reason: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.initCloseEvent(self, eventType, canBubble, cancelable, wasClean, code, reason) +proc get_status*(self: ptr IHTMLApplicationCache, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_onchecking*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onchecking(self, v) +proc get_onchecking*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onchecking(self, p) +proc put_onerror*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onerror(self, v) +proc get_onerror*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onerror(self, p) +proc put_onnoupdate*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onnoupdate(self, v) +proc get_onnoupdate*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onnoupdate(self, p) +proc put_ondownloading*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondownloading(self, v) +proc get_ondownloading*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ondownloading(self, p) +proc put_onprogress*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onprogress(self, v) +proc get_onprogress*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onprogress(self, p) +proc put_onupdateready*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onupdateready(self, v) +proc get_onupdateready*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onupdateready(self, p) +proc put_oncached*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_oncached(self, v) +proc get_oncached*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_oncached(self, p) +proc put_onobsolete*(self: ptr IHTMLApplicationCache, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onobsolete(self, v) +proc get_onobsolete*(self: ptr IHTMLApplicationCache, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onobsolete(self, p) +proc update*(self: ptr IHTMLApplicationCache): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.update(self) +proc swapCache*(self: ptr IHTMLApplicationCache): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.swapCache(self) +proc abort*(self: ptr IHTMLApplicationCache): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.abort(self) +proc GetElement*(self: ptr ICSSFilterSite, Element: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElement(self, Element) +proc FireOnFilterChangeEvent*(self: ptr ICSSFilterSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FireOnFilterChangeEvent(self) +proc SetSite*(self: ptr ICSSFilter, pSink: ptr ICSSFilterSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSite(self, pSink) +proc OnAmbientPropertyChange*(self: ptr ICSSFilter, dispid: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnAmbientPropertyChange(self, dispid) +proc ValidateSecureUrl*(self: ptr ISecureUrlHost, pfAllow: ptr WINBOOL, pchUrlInQuestion: ptr OLECHAR, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ValidateSecureUrl(self, pfAllow, pchUrlInQuestion, dwFlags) +proc CreateMarkupPointer*(self: ptr IMarkupServices, ppPointer: ptr ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMarkupPointer(self, ppPointer) +proc CreateMarkupContainer*(self: ptr IMarkupServices, ppMarkupContainer: ptr ptr IMarkupContainer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMarkupContainer(self, ppMarkupContainer) +proc CreateElement*(self: ptr IMarkupServices, tagID: ELEMENT_TAG_ID, pchAttributes: ptr OLECHAR, ppElement: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateElement(self, tagID, pchAttributes, ppElement) +proc CloneElement*(self: ptr IMarkupServices, pElemCloneThis: ptr IHTMLElement, ppElementTheClone: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloneElement(self, pElemCloneThis, ppElementTheClone) +proc InsertElement*(self: ptr IMarkupServices, pElementInsert: ptr IHTMLElement, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertElement(self, pElementInsert, pPointerStart, pPointerFinish) +proc RemoveElement*(self: ptr IMarkupServices, pElementRemove: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveElement(self, pElementRemove) +proc Remove*(self: ptr IMarkupServices, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Remove(self, pPointerStart, pPointerFinish) +proc Copy*(self: ptr IMarkupServices, pPointerSourceStart: ptr IMarkupPointer, pPointerSourceFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Copy(self, pPointerSourceStart, pPointerSourceFinish, pPointerTarget) +proc Move*(self: ptr IMarkupServices, pPointerSourceStart: ptr IMarkupPointer, pPointerSourceFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, pPointerSourceStart, pPointerSourceFinish, pPointerTarget) +proc InsertText*(self: ptr IMarkupServices, pchText: ptr OLECHAR, cch: LONG, pPointerTarget: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertText(self, pchText, cch, pPointerTarget) +proc ParseString*(self: ptr IMarkupServices, pchHTML: ptr OLECHAR, dwFlags: DWORD, ppContainerResult: ptr ptr IMarkupContainer, ppPointerStart: ptr IMarkupPointer, ppPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseString(self, pchHTML, dwFlags, ppContainerResult, ppPointerStart, ppPointerFinish) +proc ParseGlobal*(self: ptr IMarkupServices, hglobalHTML: HGLOBAL, dwFlags: DWORD, ppContainerResult: ptr ptr IMarkupContainer, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseGlobal(self, hglobalHTML, dwFlags, ppContainerResult, pPointerStart, pPointerFinish) +proc IsScopedElement*(self: ptr IMarkupServices, pElement: ptr IHTMLElement, pfScoped: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsScopedElement(self, pElement, pfScoped) +proc GetElementTagId*(self: ptr IMarkupServices, pElement: ptr IHTMLElement, ptagId: ptr ELEMENT_TAG_ID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElementTagId(self, pElement, ptagId) +proc GetTagIDForName*(self: ptr IMarkupServices, bstrName: BSTR, ptagId: ptr ELEMENT_TAG_ID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTagIDForName(self, bstrName, ptagId) +proc GetNameForTagID*(self: ptr IMarkupServices, tagId: ELEMENT_TAG_ID, pbstrName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNameForTagID(self, tagId, pbstrName) +proc MovePointersToRange*(self: ptr IMarkupServices, pIRange: ptr IHTMLTxtRange, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MovePointersToRange(self, pIRange, pPointerStart, pPointerFinish) +proc MoveRangeToPointers*(self: ptr IMarkupServices, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer, pIRange: ptr IHTMLTxtRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveRangeToPointers(self, pPointerStart, pPointerFinish, pIRange) +proc BeginUndoUnit*(self: ptr IMarkupServices, pchTitle: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginUndoUnit(self, pchTitle) +proc EndUndoUnit*(self: ptr IMarkupServices): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndUndoUnit(self) +proc ParseGlobalEx*(self: ptr IMarkupServices2, hglobalHTML: HGLOBAL, dwFlags: DWORD, pContext: ptr IMarkupContainer, ppContainerResult: ptr ptr IMarkupContainer, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseGlobalEx(self, hglobalHTML, dwFlags, pContext, ppContainerResult, pPointerStart, pPointerFinish) +proc ValidateElements*(self: ptr IMarkupServices2, pPointerStart: ptr IMarkupPointer, pPointerFinish: ptr IMarkupPointer, pPointerTarget: ptr IMarkupPointer, pPointerStatus: ptr IMarkupPointer, ppElemFailBottom: ptr ptr IHTMLElement, ppElemFailTop: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ValidateElements(self, pPointerStart, pPointerFinish, pPointerTarget, pPointerStatus, ppElemFailBottom, ppElemFailTop) +proc SaveSegmentsToClipboard*(self: ptr IMarkupServices2, pSegmentList: ptr ISegmentList, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveSegmentsToClipboard(self, pSegmentList, dwFlags) +proc OwningDoc*(self: ptr IMarkupContainer, ppDoc: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OwningDoc(self, ppDoc) +proc CreateChangeLog*(self: ptr IMarkupContainer2, pChangeSink: ptr IHTMLChangeSink, ppChangeLog: ptr ptr IHTMLChangeLog, fForward: WINBOOL, fBackward: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateChangeLog(self, pChangeSink, ppChangeLog, fForward, fBackward) +proc RegisterForDirtyRange*(self: ptr IMarkupContainer2, pChangeSink: ptr IHTMLChangeSink, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterForDirtyRange(self, pChangeSink, pdwCookie) +proc UnRegisterForDirtyRange*(self: ptr IMarkupContainer2, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnRegisterForDirtyRange(self, dwCookie) +proc GetAndClearDirtyRange*(self: ptr IMarkupContainer2, dwCookie: DWORD, pIPointerBegin: ptr IMarkupPointer, pIPointerEnd: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAndClearDirtyRange(self, dwCookie, pIPointerBegin, pIPointerEnd) +proc GetVersionNumber*(self: ptr IMarkupContainer2): LONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVersionNumber(self) +proc GetMasterElement*(self: ptr IMarkupContainer2, ppElementMaster: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMasterElement(self, ppElementMaster) +proc ExecChange*(self: ptr IHTMLChangePlayback, pbRecord: ptr BYTE, fForward: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecChange(self, pbRecord, fForward) +proc OwningDoc*(self: ptr IMarkupPointer, ppDoc: ptr ptr IHTMLDocument2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OwningDoc(self, ppDoc) +proc Gravity*(self: ptr IMarkupPointer, pGravity: ptr POINTER_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Gravity(self, pGravity) +proc SetGravity*(self: ptr IMarkupPointer, Gravity: POINTER_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGravity(self, Gravity) +proc Cling*(self: ptr IMarkupPointer, pfCling: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cling(self, pfCling) +proc SetCling*(self: ptr IMarkupPointer, fCLing: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCling(self, fCLing) +proc Unposition*(self: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unposition(self) +proc IsPositioned*(self: ptr IMarkupPointer, pfPositioned: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsPositioned(self, pfPositioned) +proc GetContainer*(self: ptr IMarkupPointer, ppContainer: ptr ptr IMarkupContainer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainer(self, ppContainer) +proc MoveAdjacentToElement*(self: ptr IMarkupPointer, pElement: ptr IHTMLElement, eAdj: ELEMENT_ADJACENCY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveAdjacentToElement(self, pElement, eAdj) +proc MoveToPointer*(self: ptr IMarkupPointer, pPointer: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToPointer(self, pPointer) +proc MoveToContainer*(self: ptr IMarkupPointer, pContainer: ptr IMarkupContainer, fAtStart: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToContainer(self, pContainer, fAtStart) +proc Left*(self: ptr IMarkupPointer, fMove: WINBOOL, pContext: ptr MARKUP_CONTEXT_TYPE, ppElement: ptr ptr IHTMLElement, pcch: ptr LONG, pchText: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Left(self, fMove, pContext, ppElement, pcch, pchText) +proc Right*(self: ptr IMarkupPointer, fMove: WINBOOL, pContext: ptr MARKUP_CONTEXT_TYPE, ppElement: ptr ptr IHTMLElement, pcch: ptr LONG, pchText: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Right(self, fMove, pContext, ppElement, pcch, pchText) +proc CurrentScope*(self: ptr IMarkupPointer, ppElemCurrent: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CurrentScope(self, ppElemCurrent) +proc IsLeftOf*(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLeftOf(self, pPointerThat, pfResult) +proc IsLeftOfOrEqualTo*(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLeftOfOrEqualTo(self, pPointerThat, pfResult) +proc IsRightOf*(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRightOf(self, pPointerThat, pfResult) +proc IsRightOfOrEqualTo*(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRightOfOrEqualTo(self, pPointerThat, pfResult) +proc IsEqualTo*(self: ptr IMarkupPointer, pPointerThat: ptr IMarkupPointer, pfAreEqual: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqualTo(self, pPointerThat, pfAreEqual) +proc MoveUnit*(self: ptr IMarkupPointer, muAction: MOVEUNIT_ACTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveUnit(self, muAction) +proc FindText*(self: ptr IMarkupPointer, pchFindText: ptr OLECHAR, dwFlags: DWORD, pIEndMatch: ptr IMarkupPointer, pIEndSearch: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindText(self, pchFindText, dwFlags, pIEndMatch, pIEndSearch) +proc IsAtWordBreak*(self: ptr IMarkupPointer2, pfAtBreak: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsAtWordBreak(self, pfAtBreak) +proc GetMarkupPosition*(self: ptr IMarkupPointer2, plMP: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMarkupPosition(self, plMP) +proc MoveToMarkupPosition*(self: ptr IMarkupPointer2, pContainer: ptr IMarkupContainer, lMP: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToMarkupPosition(self, pContainer, lMP) +proc MoveUnitBounded*(self: ptr IMarkupPointer2, muAction: MOVEUNIT_ACTION, pIBoundary: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveUnitBounded(self, muAction, pIBoundary) +proc IsInsideURL*(self: ptr IMarkupPointer2, pRight: ptr IMarkupPointer, pfResult: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsInsideURL(self, pRight, pfResult) +proc MoveToContent*(self: ptr IMarkupPointer2, pIElement: ptr IHTMLElement, fAtStart: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToContent(self, pIElement, fAtStart) +proc GetTextFragCount*(self: ptr IMarkupTextFrags, pcFrags: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTextFragCount(self, pcFrags) +proc GetTextFrag*(self: ptr IMarkupTextFrags, iFrag: LONG, pbstrFrag: ptr BSTR, pPointerFrag: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTextFrag(self, iFrag, pbstrFrag, pPointerFrag) +proc RemoveTextFrag*(self: ptr IMarkupTextFrags, iFrag: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveTextFrag(self, iFrag) +proc InsertTextFrag*(self: ptr IMarkupTextFrags, iFrag: LONG, bstrInsert: BSTR, pPointerInsert: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertTextFrag(self, iFrag, bstrInsert, pPointerInsert) +proc FindTextFragFromMarkupPointer*(self: ptr IMarkupTextFrags, pPointerFind: ptr IMarkupPointer, piFrag: ptr LONG, pfFragFound: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindTextFragFromMarkupPointer(self, pPointerFind, piFrag, pfFragFound) +proc GetNextChange*(self: ptr IHTMLChangeLog, pbBuffer: ptr BYTE, nBufferSize: LONG, pnRecordLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextChange(self, pbBuffer, nBufferSize, pnRecordLength) +proc Notify*(self: ptr IHTMLChangeSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Notify(self) +proc SetGenericParse*(self: ptr IXMLGenericParse, fDoGeneric: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGenericParse(self, fDoGeneric) +proc SnapRect*(self: ptr IHTMLEditHost, pIElement: ptr IHTMLElement, prcNew: ptr RECT, eHandle: ELEMENT_CORNER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SnapRect(self, pIElement, prcNew, eHandle) +proc PreDrag*(self: ptr IHTMLEditHost2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreDrag(self) +proc GetPointers*(self: ptr ISegment, pIStart: ptr IMarkupPointer, pIEnd: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPointers(self, pIStart, pIEnd) +proc Current*(self: ptr ISegmentListIterator, ppISegment: ptr ptr ISegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Current(self, ppISegment) +proc First*(self: ptr ISegmentListIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.First(self) +proc IsDone*(self: ptr ISegmentListIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDone(self) +proc Advance*(self: ptr ISegmentListIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advance(self) +proc CreateIterator*(self: ptr ISegmentList, ppIIter: ptr ptr ISegmentListIterator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateIterator(self, ppIIter) +proc GetType*(self: ptr ISegmentList, peType: ptr SELECTION_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, peType) +proc IsEmpty*(self: ptr ISegmentList, pfEmpty: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEmpty(self, pfEmpty) +proc GetSequenceNumber*(self: ptr ISequenceNumber, nCurrent: LONG, pnNew: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSequenceNumber(self, nCurrent, pnNew) +proc GetActiveIMM*(self: ptr IIMEServices, ppActiveIMM: ptr ptr IActiveIMMApp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetActiveIMM(self, ppActiveIMM) +proc MoveCaretToPointer*(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer, fScrollIntoView: WINBOOL, eDir: CARET_DIRECTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveCaretToPointer(self, pDispPointer, fScrollIntoView, eDir) +proc MoveCaretToPointerEx*(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer, fVisible: WINBOOL, fScrollIntoView: WINBOOL, eDir: CARET_DIRECTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveCaretToPointerEx(self, pDispPointer, fVisible, fScrollIntoView, eDir) +proc MoveMarkupPointerToCaret*(self: ptr IHTMLCaret, pIMarkupPointer: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveMarkupPointerToCaret(self, pIMarkupPointer) +proc MoveDisplayPointerToCaret*(self: ptr IHTMLCaret, pDispPointer: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveDisplayPointerToCaret(self, pDispPointer) +proc IsVisible*(self: ptr IHTMLCaret, pIsVisible: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsVisible(self, pIsVisible) +proc Show*(self: ptr IHTMLCaret, fScrollIntoView: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, fScrollIntoView) +proc Hide*(self: ptr IHTMLCaret): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Hide(self) +proc InsertText*(self: ptr IHTMLCaret, pText: ptr OLECHAR, lLen: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertText(self, pText, lLen) +proc ScrollIntoView*(self: ptr IHTMLCaret): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self) +proc GetLocation*(self: ptr IHTMLCaret, pPoint: ptr POINT, fTranslate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLocation(self, pPoint, fTranslate) +proc GetCaretDirection*(self: ptr IHTMLCaret, peDir: ptr CARET_DIRECTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCaretDirection(self, peDir) +proc SetCaretDirection*(self: ptr IHTMLCaret, eDir: CARET_DIRECTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCaretDirection(self, eDir) +proc AddSegment*(self: ptr IHighlightRenderingServices, pDispPointerStart: ptr IDisplayPointer, pDispPointerEnd: ptr IDisplayPointer, pIRenderStyle: ptr IHTMLRenderStyle, ppISegment: ptr ptr IHighlightSegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSegment(self, pDispPointerStart, pDispPointerEnd, pIRenderStyle, ppISegment) +proc MoveSegmentToPointers*(self: ptr IHighlightRenderingServices, pISegment: ptr IHighlightSegment, pDispPointerStart: ptr IDisplayPointer, pDispPointerEnd: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveSegmentToPointers(self, pISegment, pDispPointerStart, pDispPointerEnd) +proc RemoveSegment*(self: ptr IHighlightRenderingServices, pISegment: ptr IHighlightSegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveSegment(self, pISegment) +proc BeginSelectionUndo*(self: ptr ISelectionServicesListener): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginSelectionUndo(self) +proc EndSelectionUndo*(self: ptr ISelectionServicesListener): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndSelectionUndo(self) +proc OnSelectedElementExit*(self: ptr ISelectionServicesListener, pIElementStart: ptr IMarkupPointer, pIElementEnd: ptr IMarkupPointer, pIElementContentStart: ptr IMarkupPointer, pIElementContentEnd: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSelectedElementExit(self, pIElementStart, pIElementEnd, pIElementContentStart, pIElementContentEnd) +proc OnChangeType*(self: ptr ISelectionServicesListener, eType: SELECTION_TYPE, pIListener: ptr ISelectionServicesListener): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnChangeType(self, eType, pIListener) +proc GetTypeDetail*(self: ptr ISelectionServicesListener, pTypeDetail: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeDetail(self, pTypeDetail) +proc SetSelectionType*(self: ptr ISelectionServices, eType: SELECTION_TYPE, pIListener: ptr ISelectionServicesListener): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSelectionType(self, eType, pIListener) +proc GetMarkupContainer*(self: ptr ISelectionServices, ppIContainer: ptr ptr IMarkupContainer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMarkupContainer(self, ppIContainer) +proc AddSegment*(self: ptr ISelectionServices, pIStart: ptr IMarkupPointer, pIEnd: ptr IMarkupPointer, ppISegmentAdded: ptr ptr ISegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSegment(self, pIStart, pIEnd, ppISegmentAdded) +proc AddElementSegment*(self: ptr ISelectionServices, pIElement: ptr IHTMLElement, ppISegmentAdded: ptr ptr IElementSegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddElementSegment(self, pIElement, ppISegmentAdded) +proc RemoveSegment*(self: ptr ISelectionServices, pISegment: ptr ISegment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveSegment(self, pISegment) +proc GetSelectionServicesListener*(self: ptr ISelectionServices, ppISelectionServicesListener: ptr ptr ISelectionServicesListener): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectionServicesListener(self, ppISelectionServicesListener) +proc GetElement*(self: ptr IElementSegment, ppIElement: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElement(self, ppIElement) +proc SetPrimary*(self: ptr IElementSegment, fPrimary: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPrimary(self, fPrimary) +proc IsPrimary*(self: ptr IElementSegment, pfPrimary: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsPrimary(self, pfPrimary) +proc PreHandleEvent*(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreHandleEvent(self, inEvtDispId, pIEventObj) +proc PostHandleEvent*(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostHandleEvent(self, inEvtDispId, pIEventObj) +proc TranslateAccelerator*(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, inEvtDispId, pIEventObj) +proc PostEditorEventNotify*(self: ptr IHTMLEditDesigner, inEvtDispId: DISPID, pIEventObj: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostEditorEventNotify(self, inEvtDispId, pIEventObj) +proc AddDesigner*(self: ptr IHTMLEditServices, pIDesigner: ptr IHTMLEditDesigner): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDesigner(self, pIDesigner) +proc RemoveDesigner*(self: ptr IHTMLEditServices, pIDesigner: ptr IHTMLEditDesigner): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveDesigner(self, pIDesigner) +proc GetSelectionServices*(self: ptr IHTMLEditServices, pIContainer: ptr IMarkupContainer, ppSelSvc: ptr ptr ISelectionServices): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectionServices(self, pIContainer, ppSelSvc) +proc MoveToSelectionAnchor*(self: ptr IHTMLEditServices, pIStartAnchor: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToSelectionAnchor(self, pIStartAnchor) +proc MoveToSelectionEnd*(self: ptr IHTMLEditServices, pIEndAnchor: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToSelectionEnd(self, pIEndAnchor) +proc SelectRange*(self: ptr IHTMLEditServices, pStart: ptr IMarkupPointer, pEnd: ptr IMarkupPointer, eType: SELECTION_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectRange(self, pStart, pEnd, eType) +proc MoveToSelectionAnchorEx*(self: ptr IHTMLEditServices2, pIStartAnchor: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToSelectionAnchorEx(self, pIStartAnchor) +proc MoveToSelectionEndEx*(self: ptr IHTMLEditServices2, pIEndAnchor: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToSelectionEndEx(self, pIEndAnchor) +proc FreezeVirtualCaretPos*(self: ptr IHTMLEditServices2, fReCompute: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FreezeVirtualCaretPos(self, fReCompute) +proc UnFreezeVirtualCaretPos*(self: ptr IHTMLEditServices2, fReset: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnFreezeVirtualCaretPos(self, fReset) +proc get_x*(self: ptr ILineInfo, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_x(self, p) +proc get_baseLine*(self: ptr ILineInfo, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseLine(self, p) +proc get_textDescent*(self: ptr ILineInfo, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textDescent(self, p) +proc get_textHeight*(self: ptr ILineInfo, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textHeight(self, p) +proc get_lineDirection*(self: ptr ILineInfo, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lineDirection(self, p) +proc get_bold*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_bold(self, p) +proc get_italic*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_italic(self, p) +proc get_underline*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_underline(self, p) +proc get_overline*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_overline(self, p) +proc get_strikeOut*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_strikeOut(self, p) +proc get_subScript*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_subScript(self, p) +proc get_superScript*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_superScript(self, p) +proc get_explicitFace*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_explicitFace(self, p) +proc get_fontWeight*(self: ptr IHTMLComputedStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontWeight(self, p) +proc get_fontSize*(self: ptr IHTMLComputedStyle, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontSize(self, p) +proc get_fontName*(self: ptr IHTMLComputedStyle, p: ptr TCHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fontName(self, p) +proc get_hasBgColor*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hasBgColor(self, p) +proc get_textColor*(self: ptr IHTMLComputedStyle, p: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_textColor(self, p) +proc get_backgroundColor*(self: ptr IHTMLComputedStyle, p: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_backgroundColor(self, p) +proc get_preFormatted*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_preFormatted(self, p) +proc get_direction*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_direction(self, p) +proc get_blockDirection*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_blockDirection(self, p) +proc get_OL*(self: ptr IHTMLComputedStyle, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_OL(self, p) +proc IsEqual*(self: ptr IHTMLComputedStyle, pComputedStyle: ptr IHTMLComputedStyle, pfEqual: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqual(self, pComputedStyle, pfEqual) +proc MoveToPoint*(self: ptr IDisplayPointer, ptPoint: POINT, eCoordSystem: COORD_SYSTEM, pElementContext: ptr IHTMLElement, dwHitTestOptions: DWORD, pdwHitTestResults: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToPoint(self, ptPoint, eCoordSystem, pElementContext, dwHitTestOptions, pdwHitTestResults) +proc MoveUnit*(self: ptr IDisplayPointer, eMoveUnit: DISPLAY_MOVEUNIT, lXPos: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveUnit(self, eMoveUnit, lXPos) +proc PositionMarkupPointer*(self: ptr IDisplayPointer, pMarkupPointer: ptr IMarkupPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PositionMarkupPointer(self, pMarkupPointer) +proc MoveToPointer*(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToPointer(self, pDispPointer) +proc SetPointerGravity*(self: ptr IDisplayPointer, eGravity: POINTER_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPointerGravity(self, eGravity) +proc GetPointerGravity*(self: ptr IDisplayPointer, peGravity: ptr POINTER_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPointerGravity(self, peGravity) +proc SetDisplayGravity*(self: ptr IDisplayPointer, eGravity: DISPLAY_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDisplayGravity(self, eGravity) +proc GetDisplayGravity*(self: ptr IDisplayPointer, peGravity: ptr DISPLAY_GRAVITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayGravity(self, peGravity) +proc IsPositioned*(self: ptr IDisplayPointer, pfPositioned: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsPositioned(self, pfPositioned) +proc Unposition*(self: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unposition(self) +proc IsEqualTo*(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsEqual: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqualTo(self, pDispPointer, pfIsEqual) +proc IsLeftOf*(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsLeftOf: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLeftOf(self, pDispPointer, pfIsLeftOf) +proc IsRightOf*(self: ptr IDisplayPointer, pDispPointer: ptr IDisplayPointer, pfIsRightOf: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRightOf(self, pDispPointer, pfIsRightOf) +proc IsAtBOL*(self: ptr IDisplayPointer, pfBOL: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsAtBOL(self, pfBOL) +proc MoveToMarkupPointer*(self: ptr IDisplayPointer, pPointer: ptr IMarkupPointer, pDispLineContext: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveToMarkupPointer(self, pPointer, pDispLineContext) +proc ScrollIntoView*(self: ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self) +proc GetLineInfo*(self: ptr IDisplayPointer, ppLineInfo: ptr ptr ILineInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLineInfo(self, ppLineInfo) +proc GetFlowElement*(self: ptr IDisplayPointer, ppLayoutElement: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFlowElement(self, ppLayoutElement) +proc QueryBreaks*(self: ptr IDisplayPointer, pdwBreaks: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryBreaks(self, pdwBreaks) +proc CreateDisplayPointer*(self: ptr IDisplayServices, ppDispPointer: ptr ptr IDisplayPointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDisplayPointer(self, ppDispPointer) +proc TransformRect*(self: ptr IDisplayServices, pRect: ptr RECT, eSource: COORD_SYSTEM, eDestination: COORD_SYSTEM, pIElement: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TransformRect(self, pRect, eSource, eDestination, pIElement) +proc TransformPoint*(self: ptr IDisplayServices, pPoint: ptr POINT, eSource: COORD_SYSTEM, eDestination: COORD_SYSTEM, pIElement: ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TransformPoint(self, pPoint, eSource, eDestination, pIElement) +proc GetCaret*(self: ptr IDisplayServices, ppCaret: ptr ptr IHTMLCaret): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCaret(self, ppCaret) +proc GetComputedStyle*(self: ptr IDisplayServices, pPointer: ptr IMarkupPointer, ppComputedStyle: ptr ptr IHTMLComputedStyle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetComputedStyle(self, pPointer, ppComputedStyle) +proc ScrollRectIntoView*(self: ptr IDisplayServices, pIElement: ptr IHTMLElement, rect: RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollRectIntoView(self, pIElement, rect) +proc HasFlowLayout*(self: ptr IDisplayServices, pIElement: ptr IHTMLElement, pfHasFlowLayout: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasFlowLayout(self, pIElement, pfHasFlowLayout) +proc choosecolordlg*(self: ptr IHtmlDlgSafeHelper, initColor: VARIANT, rgbColor: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.choosecolordlg(self, initColor, rgbColor) +proc getCharset*(self: ptr IHtmlDlgSafeHelper, fontName: BSTR, charset: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getCharset(self, fontName, charset) +proc get_Fonts*(self: ptr IHtmlDlgSafeHelper, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Fonts(self, p) +proc get_BlockFormats*(self: ptr IHtmlDlgSafeHelper, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BlockFormats(self, p) +proc get_NewEnum*(self: ptr IBlockFormats, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_NewEnum(self, p) +proc get_Count*(self: ptr IBlockFormats, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, p) +proc Item*(self: ptr IBlockFormats, pvarIndex: ptr VARIANT, pbstrBlockFormat: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, pvarIndex, pbstrBlockFormat) +proc get_NewEnum*(self: ptr IFontNames, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_NewEnum(self, p) +proc get_Count*(self: ptr IFontNames, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, p) +proc Item*(self: ptr IFontNames, pvarIndex: ptr VARIANT, pbstrFontName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, pvarIndex, pbstrFontName) +proc Write*(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Write(self, source, level, messageId, messageText) +proc WriteWithUrl*(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteWithUrl(self, source, level, messageId, messageText, fileUrl) +proc WriteWithUrlAndLine*(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR, line: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteWithUrlAndLine(self, source, level, messageId, messageText, fileUrl, line) +proc WriteWithUrlLineAndColumn*(self: ptr IDeveloperConsoleMessageReceiver, source: LPCWSTR, level: DEV_CONSOLE_MESSAGE_LEVEL, messageId: int32, messageText: LPCWSTR, fileUrl: LPCWSTR, line: ULONG, column: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteWithUrlLineAndColumn(self, source, level, messageId, messageText, fileUrl, line, column) +proc RequestedCallbackTypes*(self: ptr IDebugCallbackNotificationHandler, pCallbackMask: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestedCallbackTypes(self, pCallbackMask) +proc BeforeDispatchEvent*(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeforeDispatchEvent(self, pEvent) +proc DispatchEventComplete*(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, propagationStatus: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DispatchEventComplete(self, pEvent, propagationStatus) +proc BeforeInvokeDomCallback*(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, pCallback: ptr IScriptEventHandler, eStage: DOM_EVENT_PHASE, propagationStatus: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeforeInvokeDomCallback(self, pEvent, pCallback, eStage, propagationStatus) +proc InvokeDomCallbackComplete*(self: ptr IDebugCallbackNotificationHandler, pEvent: ptr IUnknown, pCallback: ptr IScriptEventHandler, eStage: DOM_EVENT_PHASE, propagationStatus: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeDomCallbackComplete(self, pEvent, pCallback, eStage, propagationStatus) +proc BeforeInvokeCallback*(self: ptr IDebugCallbackNotificationHandler, eCallbackType: SCRIPT_TIMER_TYPE, callbackCookie: DWORD, pDispHandler: ptr IDispatch, ullHandlerCookie: ULONGLONG, functionName: BSTR, line: UINT32, column: UINT32, cchLength: UINT32, pDebugDocumentContext: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeforeInvokeCallback(self, eCallbackType, callbackCookie, pDispHandler, ullHandlerCookie, functionName, line, column, cchLength, pDebugDocumentContext) +proc InvokeCallbackComplete*(self: ptr IDebugCallbackNotificationHandler, eCallbackType: SCRIPT_TIMER_TYPE, callbackCookie: DWORD, pDispHandler: ptr IDispatch, ullHandlerCookie: ULONGLONG, functionName: BSTR, line: UINT32, column: UINT32, cchLength: UINT32, pDebugDocumentContext: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeCallbackComplete(self, eCallbackType, callbackCookie, pDispHandler, ullHandlerCookie, functionName, line, column, cchLength, pDebugDocumentContext) +proc FunctionName*(self: ptr IScriptEventHandler, pbstrFunctionName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FunctionName(self, pbstrFunctionName) +proc DebugDocumentContext*(self: ptr IScriptEventHandler, ppDebugDocumentContext: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DebugDocumentContext(self, ppDebugDocumentContext) +proc EventHandlerDispatch*(self: ptr IScriptEventHandler, ppDispHandler: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EventHandlerDispatch(self, ppDispHandler) +proc UsesCapture*(self: ptr IScriptEventHandler, pfUsesCapture: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UsesCapture(self, pfUsesCapture) +proc Cookie*(self: ptr IScriptEventHandler, pullCookie: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cookie(self, pullCookie) +proc GetSourceInfo*(self: ptr IScriptEventHandlerSourceInfo, pbstrFunctionName: ptr BSTR, line: ptr UINT32, column: ptr UINT32, cchLength: ptr UINT32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourceInfo(self, pbstrFunctionName, line, column, cchLength) +proc OnDOMEventListenerAdded*(self: ptr IDOMEventRegistrationCallback, pszEventType: LPCWSTR, pHandler: ptr IScriptEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDOMEventListenerAdded(self, pszEventType, pHandler) +proc OnDOMEventListenerRemoved*(self: ptr IDOMEventRegistrationCallback, ullCookie: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDOMEventListenerRemoved(self, ullCookie) +proc GetRegisteredEventTypes*(self: ptr IEventTarget2, ppEventTypeArray: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRegisteredEventTypes(self, ppEventTypeArray) +proc GetListenersForType*(self: ptr IEventTarget2, pszEventType: LPCWSTR, ppEventHandlerArray: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetListenersForType(self, pszEventType, ppEventHandlerArray) +proc RegisterForDOMEventListeners*(self: ptr IEventTarget2, pCallback: ptr IDOMEventRegistrationCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterForDOMEventListeners(self, pCallback) +proc UnregisterForDOMEventListeners*(self: ptr IEventTarget2, pCallback: ptr IDOMEventRegistrationCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterForDOMEventListeners(self, pCallback) +proc get_name*(self: ptr IHTMLNamespace, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, p) +proc get_urn*(self: ptr IHTMLNamespace, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_urn(self, p) +proc get_tagNames*(self: ptr IHTMLNamespace, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagNames(self, p) +proc get_readyState*(self: ptr IHTMLNamespace, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, p) +proc put_onreadystatechange*(self: ptr IHTMLNamespace, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, v) +proc get_onreadystatechange*(self: ptr IHTMLNamespace, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_onreadystatechange(self, p) +proc doImport*(self: ptr IHTMLNamespace, bstrImplementationUrl: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.doImport(self, bstrImplementationUrl) +proc attachEvent*(self: ptr IHTMLNamespace, event: BSTR, pDisp: ptr IDispatch, pfResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.attachEvent(self, event, pDisp, pfResult) +proc detachEvent*(self: ptr IHTMLNamespace, event: BSTR, pDisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.detachEvent(self, event, pDisp) +proc get_length*(self: ptr IHTMLNamespaceCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc item*(self: ptr IHTMLNamespaceCollection, index: VARIANT, ppNamespace: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppNamespace) +proc add*(self: ptr IHTMLNamespaceCollection, bstrNamespace: BSTR, bstrUrn: BSTR, implementationUrl: VARIANT, ppNamespace: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.add(self, bstrNamespace, bstrUrn, implementationUrl, ppNamespace) +proc Draw*(self: ptr IHTMLPainter, rcBounds: RECT, rcUpdate: RECT, lDrawFlags: LONG, hdc: HDC, pvDrawObject: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Draw(self, rcBounds, rcUpdate, lDrawFlags, hdc, pvDrawObject) +proc OnResize*(self: ptr IHTMLPainter, size: SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnResize(self, size) +proc GetPainterInfo*(self: ptr IHTMLPainter, pInfo: ptr HTML_PAINTER_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPainterInfo(self, pInfo) +proc HitTestPoint*(self: ptr IHTMLPainter, pt: POINT, pbHit: ptr WINBOOL, plPartID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HitTestPoint(self, pt, pbHit, plPartID) +proc GetEventInfoFlags*(self: ptr IHTMLPainterEventInfo, plEventInfoFlags: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEventInfoFlags(self, plEventInfoFlags) +proc GetEventTarget*(self: ptr IHTMLPainterEventInfo, ppElement: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEventTarget(self, ppElement) +proc SetCursor*(self: ptr IHTMLPainterEventInfo, lPartID: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCursor(self, lPartID) +proc StringFromPartID*(self: ptr IHTMLPainterEventInfo, lPartID: LONG, pbstrPart: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StringFromPartID(self, lPartID, pbstrPart) +proc OnMove*(self: ptr IHTMLPainterOverlay, rcDevice: RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnMove(self, rcDevice) +proc InvalidatePainterInfo*(self: ptr IHTMLPaintSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidatePainterInfo(self) +proc InvalidateRect*(self: ptr IHTMLPaintSite, prcInvalid: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateRect(self, prcInvalid) +proc InvalidateRegion*(self: ptr IHTMLPaintSite, rgnInvalid: HRGN): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateRegion(self, rgnInvalid) +proc GetDrawInfo*(self: ptr IHTMLPaintSite, lFlags: LONG, pDrawInfo: ptr HTML_PAINT_DRAW_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDrawInfo(self, lFlags, pDrawInfo) +proc TransformGlobalToLocal*(self: ptr IHTMLPaintSite, ptGlobal: POINT, pptLocal: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TransformGlobalToLocal(self, ptGlobal, pptLocal) +proc TransformLocalToGlobal*(self: ptr IHTMLPaintSite, ptLocal: POINT, pptGlobal: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TransformLocalToGlobal(self, ptLocal, pptGlobal) +proc GetHitTestCookie*(self: ptr IHTMLPaintSite, plCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHitTestCookie(self, plCookie) +proc get_length*(self: ptr IHTMLIPrintCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IHTMLIPrintCollection, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, p) +proc item*(self: ptr IHTMLIPrintCollection, index: LONG, ppIPrint: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, index, ppIPrint) +proc Reset*(self: ptr IEnumPrivacyRecords): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc GetSize*(self: ptr IEnumPrivacyRecords, pSize: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, pSize) +proc GetPrivacyImpacted*(self: ptr IEnumPrivacyRecords, pState: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPrivacyImpacted(self, pState) +proc Next*(self: ptr IEnumPrivacyRecords, pbstrUrl: ptr BSTR, pbstrPolicyRef: ptr BSTR, pdwReserved: ptr LONG, pdwPrivacyFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, pbstrUrl, pbstrPolicyRef, pdwReserved, pdwPrivacyFlags) +proc GetCount*(self: ptr IWPCBlockedUrls, pdwCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pdwCount) +proc GetUrl*(self: ptr IWPCBlockedUrls, dwIdx: DWORD, pbstrUrl: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUrl(self, dwIdx, pbstrUrl) +proc get_Attr*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Attr(self, p) +proc get_BehaviorUrnsCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BehaviorUrnsCollection(self, p) +proc get_BookmarkCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BookmarkCollection(self, p) +proc get_CompatibleInfo*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CompatibleInfo(self, p) +proc get_CompatibleInfoCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CompatibleInfoCollection(self, p) +proc get_ControlRangeCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ControlRangeCollection(self, p) +proc get_CSSCurrentStyleDeclaration*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSCurrentStyleDeclaration(self, p) +proc get_CSSRuleList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSRuleList(self, p) +proc get_CSSRuleStyleDeclaration*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSRuleStyleDeclaration(self, p) +proc get_CSSStyleDeclaration*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSStyleDeclaration(self, p) +proc get_CSSStyleRule*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSStyleRule(self, p) +proc get_CSSStyleSheet*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CSSStyleSheet(self, p) +proc get_DataTransfer*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DataTransfer(self, p) +proc get_DOMImplementation*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DOMImplementation(self, p) +proc get_Element*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Element(self, p) +proc get_Event*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Event(self, p) +proc get_History*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_History(self, p) +proc get_HTCElementBehaviorDefaults*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTCElementBehaviorDefaults(self, p) +proc get_HTMLAnchorElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLAnchorElement(self, p) +proc get_HTMLAreaElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLAreaElement(self, p) +proc get_HTMLAreasCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLAreasCollection(self, p) +proc get_HTMLBaseElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBaseElement(self, p) +proc get_HTMLBaseFontElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBaseFontElement(self, p) +proc get_HTMLBGSoundElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBGSoundElement(self, p) +proc get_HTMLBlockElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBlockElement(self, p) +proc get_HTMLBodyElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBodyElement(self, p) +proc get_HTMLBRElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLBRElement(self, p) +proc get_HTMLButtonElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLButtonElement(self, p) +proc get_HTMLCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLCollection(self, p) +proc get_HTMLCommentElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLCommentElement(self, p) +proc get_HTMLDDElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLDDElement(self, p) +proc get_HTMLDivElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLDivElement(self, p) +proc get_HTMLDocument*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLDocument(self, p) +proc get_HTMLDListElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLDListElement(self, p) +proc get_HTMLDTElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLDTElement(self, p) +proc get_HTMLEmbedElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLEmbedElement(self, p) +proc get_HTMLFieldSetElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLFieldSetElement(self, p) +proc get_HTMLFontElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLFontElement(self, p) +proc get_HTMLFormElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLFormElement(self, p) +proc get_HTMLFrameElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLFrameElement(self, p) +proc get_HTMLFrameSetElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLFrameSetElement(self, p) +proc get_HTMLGenericElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLGenericElement(self, p) +proc get_HTMLHeadElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLHeadElement(self, p) +proc get_HTMLHeadingElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLHeadingElement(self, p) +proc get_HTMLHRElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLHRElement(self, p) +proc get_HTMLHtmlElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLHtmlElement(self, p) +proc get_HTMLIFrameElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLIFrameElement(self, p) +proc get_HTMLImageElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLImageElement(self, p) +proc get_HTMLInputElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLInputElement(self, p) +proc get_HTMLIsIndexElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLIsIndexElement(self, p) +proc get_HTMLLabelElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLLabelElement(self, p) +proc get_HTMLLegendElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLLegendElement(self, p) +proc get_HTMLLIElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLLIElement(self, p) +proc get_HTMLLinkElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLLinkElement(self, p) +proc get_HTMLMapElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLMapElement(self, p) +proc get_HTMLMarqueeElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLMarqueeElement(self, p) +proc get_HTMLMetaElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLMetaElement(self, p) +proc get_HTMLModelessDialog*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLModelessDialog(self, p) +proc get_HTMLNamespaceInfo*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLNamespaceInfo(self, p) +proc get_HTMLNamespaceInfoCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLNamespaceInfoCollection(self, p) +proc get_HTMLNextIdElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLNextIdElement(self, p) +proc get_HTMLNoShowElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLNoShowElement(self, p) +proc get_HTMLObjectElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLObjectElement(self, p) +proc get_HTMLOListElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLOListElement(self, p) +proc get_HTMLOptionElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLOptionElement(self, p) +proc get_HTMLParagraphElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLParagraphElement(self, p) +proc get_HTMLParamElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLParamElement(self, p) +proc get_HTMLPhraseElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLPhraseElement(self, p) +proc get_HTMLPluginsCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLPluginsCollection(self, p) +proc get_HTMLPopup*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLPopup(self, p) +proc get_HTMLScriptElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLScriptElement(self, p) +proc get_HTMLSelectElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLSelectElement(self, p) +proc get_HTMLSpanElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLSpanElement(self, p) +proc get_HTMLStyleElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLStyleElement(self, p) +proc get_HTMLTableCaptionElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableCaptionElement(self, p) +proc get_HTMLTableCellElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableCellElement(self, p) +proc get_HTMLTableColElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableColElement(self, p) +proc get_HTMLTableElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableElement(self, p) +proc get_HTMLTableRowElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableRowElement(self, p) +proc get_HTMLTableSectionElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTableSectionElement(self, p) +proc get_HTMLTextAreaElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTextAreaElement(self, p) +proc get_HTMLTextElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTextElement(self, p) +proc get_HTMLTitleElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLTitleElement(self, p) +proc get_HTMLUListElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLUListElement(self, p) +proc get_HTMLUnknownElement*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HTMLUnknownElement(self, p) +proc get_Image*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Image(self, p) +proc get_Location*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Location(self, p) +proc get_NamedNodeMap*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_NamedNodeMap(self, p) +proc get_Navigator*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Navigator(self, p) +proc get_NodeList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_NodeList(self, p) +proc get_Option*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Option(self, p) +proc get_Screen*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Screen(self, p) +proc get_Selection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Selection(self, p) +proc get_StaticNodeList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StaticNodeList(self, p) +proc get_Storage*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Storage(self, p) +proc get_StyleSheetList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StyleSheetList(self, p) +proc get_StyleSheetPage*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StyleSheetPage(self, p) +proc get_StyleSheetPageList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StyleSheetPageList(self, p) +proc get_Text*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Text(self, p) +proc get_TextRange*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRange(self, p) +proc get_TextRangeCollection*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRangeCollection(self, p) +proc get_TextRectangle*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRectangle(self, p) +proc get_TextRectangleList*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRectangleList(self, p) +proc get_Window*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Window(self, p) +proc get_XDomainRequest*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_XDomainRequest(self, p) +proc get_XMLHttpRequest*(self: ptr IHTMLDOMConstructorCollection, p: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_XMLHttpRequest(self, p) +proc put_dialogTop*(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dialogTop(self, v) +proc get_dialogTop*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogTop(self, p) +proc put_dialogLeft*(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dialogLeft(self, v) +proc get_dialogLeft*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogLeft(self, p) +proc put_dialogWidth*(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dialogWidth(self, v) +proc get_dialogWidth*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogWidth(self, p) +proc put_dialogHeight*(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dialogHeight(self, v) +proc get_dialogHeight*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogHeight(self, p) +proc get_dialogArguments*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogArguments(self, p) +proc get_menuArguments*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_menuArguments(self, p) +proc put_returnValue*(self: ptr IHTMLDialog, v: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_returnValue(self, v) +proc get_returnValue*(self: ptr IHTMLDialog, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_returnValue(self, p) +proc close*(self: ptr IHTMLDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.close(self) +proc toString*(self: ptr IHTMLDialog, String: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.toString(self, String) +proc put_status*(self: ptr IHTMLDialog2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_status(self, v) +proc get_status*(self: ptr IHTMLDialog2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, p) +proc put_resizable*(self: ptr IHTMLDialog2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_resizable(self, v) +proc get_resizable*(self: ptr IHTMLDialog2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_resizable(self, p) +proc put_unadorned*(self: ptr IHTMLDialog3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_unadorned(self, v) +proc get_unadorned*(self: ptr IHTMLDialog3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_unadorned(self, p) +proc put_dialogHide*(self: ptr IHTMLDialog3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dialogHide(self, v) +proc get_dialogHide*(self: ptr IHTMLDialog3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dialogHide(self, p) +proc get_parameters*(self: ptr IHTMLModelessInit, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parameters(self, p) +proc get_optionString*(self: ptr IHTMLModelessInit, p: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_optionString(self, p) +proc get_moniker*(self: ptr IHTMLModelessInit, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_moniker(self, p) +proc get_document*(self: ptr IHTMLModelessInit, p: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc show*(self: ptr IHTMLPopup, x: LONG, y: LONG, w: LONG, h: LONG, pElement: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.show(self, x, y, w, h, pElement) +proc hide*(self: ptr IHTMLPopup): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hide(self) +proc get_document*(self: ptr IHTMLPopup, p: ptr ptr IHTMLDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_document(self, p) +proc get_isOpen*(self: ptr IHTMLPopup, p: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_isOpen(self, p) +proc put_applicationName*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_applicationName(self, v) +proc get_applicationName*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_applicationName(self, p) +proc put_version*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_version(self, v) +proc get_version*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc put_icon*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_icon(self, v) +proc get_icon*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_icon(self, p) +proc put_singleInstance*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_singleInstance(self, v) +proc get_singleInstance*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_singleInstance(self, p) +proc put_minimizeButton*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_minimizeButton(self, v) +proc get_minimizeButton*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_minimizeButton(self, p) +proc put_maximizeButton*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_maximizeButton(self, v) +proc get_maximizeButton*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_maximizeButton(self, p) +proc put_border*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_border(self, v) +proc get_border*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_border(self, p) +proc put_borderStyle*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_borderStyle(self, v) +proc get_borderStyle*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_borderStyle(self, p) +proc put_sysMenu*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_sysMenu(self, v) +proc get_sysMenu*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_sysMenu(self, p) +proc put_caption*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_caption(self, v) +proc get_caption*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_caption(self, p) +proc put_windowState*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_windowState(self, v) +proc get_windowState*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_windowState(self, p) +proc put_showInTaskBar*(self: ptr IHTMLAppBehavior, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_showInTaskBar(self, v) +proc get_showInTaskBar*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_showInTaskBar(self, p) +proc get_commandLine*(self: ptr IHTMLAppBehavior, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_commandLine(self, p) +proc put_contextMenu*(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_contextMenu(self, v) +proc get_contextMenu*(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_contextMenu(self, p) +proc put_innerBorder*(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_innerBorder(self, v) +proc get_innerBorder*(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_innerBorder(self, p) +proc put_scroll*(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scroll(self, v) +proc get_scroll*(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scroll(self, p) +proc put_scrollFlat*(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_scrollFlat(self, v) +proc get_scrollFlat*(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_scrollFlat(self, p) +proc put_selection*(self: ptr IHTMLAppBehavior2, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_selection(self, v) +proc get_selection*(self: ptr IHTMLAppBehavior2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_selection(self, p) +proc put_navigable*(self: ptr IHTMLAppBehavior3, v: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_navigable(self, v) +proc get_navigable*(self: ptr IHTMLAppBehavior3, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_navigable(self, p) +proc FindBehavior*(self: ptr IElementBehaviorFactory, bstrBehavior: BSTR, bstrBehaviorUrl: BSTR, pSite: ptr IElementBehaviorSite, ppBehavior: ptr ptr IElementBehavior): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindBehavior(self, bstrBehavior, bstrBehaviorUrl, pSite, ppBehavior) +proc AddTag*(self: ptr IElementNamespace, bstrTagName: BSTR, lFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTag(self, bstrTagName, lFlags) +proc AddNamespace*(self: ptr IElementNamespaceTable, bstrNamespace: BSTR, bstrUrn: BSTR, lFlags: LONG, pvarFactory: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddNamespace(self, bstrNamespace, bstrUrn, lFlags, pvarFactory) +proc Create*(self: ptr IElementNamespaceFactory, pNamespace: ptr IElementNamespace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Create(self, pNamespace) +proc CreateWithImplementation*(self: ptr IElementNamespaceFactory2, pNamespace: ptr IElementNamespace, bstrImplementation: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateWithImplementation(self, pNamespace, bstrImplementation) +proc Resolve*(self: ptr IElementNamespaceFactoryCallback, bstrNamespace: BSTR, bstrTagName: BSTR, bstrAttrs: BSTR, pNamespace: ptr IElementNamespace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resolve(self, bstrNamespace, bstrTagName, bstrAttrs, pNamespace) +proc Init*(self: ptr IElementBehavior, pBehaviorSite: ptr IElementBehaviorSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Init(self, pBehaviorSite) +proc Notify*(self: ptr IElementBehavior, lEvent: LONG, pVar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Notify(self, lEvent, pVar) +proc Detach*(self: ptr IElementBehavior): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Detach(self) +proc GetElement*(self: ptr IElementBehaviorSite, ppElement: ptr ptr IHTMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElement(self, ppElement) +proc RegisterNotification*(self: ptr IElementBehaviorSite, lEvent: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterNotification(self, lEvent) +proc RegisterEvent*(self: ptr IElementBehaviorSiteOM, pchEvent: LPOLESTR, lFlags: LONG, plCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterEvent(self, pchEvent, lFlags, plCookie) +proc GetEventCookie*(self: ptr IElementBehaviorSiteOM, pchEvent: LPOLESTR, plCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEventCookie(self, pchEvent, plCookie) +proc FireEvent*(self: ptr IElementBehaviorSiteOM, lCookie: LONG, pEventObject: ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FireEvent(self, lCookie, pEventObject) +proc CreateEventObject*(self: ptr IElementBehaviorSiteOM, ppEventObject: ptr ptr IHTMLEventObj): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateEventObject(self, ppEventObject) +proc RegisterName*(self: ptr IElementBehaviorSiteOM, pchName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterName(self, pchName) +proc RegisterUrn*(self: ptr IElementBehaviorSiteOM, pchUrn: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterUrn(self, pchUrn) +proc GetDefaults*(self: ptr IElementBehaviorSiteOM2, ppDefaults: ptr ptr IHTMLElementDefaults): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaults(self, ppDefaults) +proc Draw*(self: ptr IElementBehaviorRender, hdc: HDC, lLayer: LONG, pRect: ptr RECT, pReserved: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Draw(self, hdc, lLayer, pRect, pReserved) +proc GetRenderInfo*(self: ptr IElementBehaviorRender, plRenderInfo: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRenderInfo(self, plRenderInfo) +proc HitTestPoint*(self: ptr IElementBehaviorRender, pPoint: ptr POINT, pReserved: ptr IUnknown, pbHit: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HitTestPoint(self, pPoint, pReserved, pbHit) +proc Invalidate*(self: ptr IElementBehaviorSiteRender, pRect: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invalidate(self, pRect) +proc InvalidateRenderInfo*(self: ptr IElementBehaviorSiteRender): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateRenderInfo(self) +proc InvalidateStyle*(self: ptr IElementBehaviorSiteRender): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateStyle(self) +proc GetCategory*(self: ptr IElementBehaviorCategory, ppchCategory: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategory(self, ppchCategory) +proc GetRelatedBehaviors*(self: ptr IElementBehaviorSiteCategory, lDirection: LONG, pchCategory: LPOLESTR, ppEnumerator: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRelatedBehaviors(self, lDirection, pchCategory, ppEnumerator) +proc GetSubmitInfo*(self: ptr IElementBehaviorSubmit, pSubmitData: ptr IHTMLSubmitData): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSubmitInfo(self, pSubmitData) +proc Reset*(self: ptr IElementBehaviorSubmit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc GetFocusRect*(self: ptr IElementBehaviorFocus, pRect: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocusRect(self, pRect) +proc GetSize*(self: ptr IElementBehaviorLayout, dwFlags: LONG, sizeContent: SIZE, pptTranslateBy: ptr POINT, pptTopLeft: ptr POINT, psizeProposed: ptr SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, dwFlags, sizeContent, pptTranslateBy, pptTopLeft, psizeProposed) +proc GetLayoutInfo*(self: ptr IElementBehaviorLayout, plLayoutInfo: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLayoutInfo(self, plLayoutInfo) +proc GetPosition*(self: ptr IElementBehaviorLayout, lFlags: LONG, pptTopLeft: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPosition(self, lFlags, pptTopLeft) +proc MapSize*(self: ptr IElementBehaviorLayout, psizeIn: ptr SIZE, prcOut: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapSize(self, psizeIn, prcOut) +proc GetTextDescent*(self: ptr IElementBehaviorLayout2, plDescent: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTextDescent(self, plDescent) +proc InvalidateLayoutInfo*(self: ptr IElementBehaviorSiteLayout): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateLayoutInfo(self) +proc InvalidateSize*(self: ptr IElementBehaviorSiteLayout): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateSize(self) +proc GetMediaResolution*(self: ptr IElementBehaviorSiteLayout, psizeResolution: ptr SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMediaResolution(self, psizeResolution) +proc GetFontInfo*(self: ptr IElementBehaviorSiteLayout2, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFontInfo(self, plf) +proc PopulateNamespaceTable*(self: ptr IHostBehaviorInit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PopulateNamespaceTable(self) +proc CreateSurfacePresenter*(self: ptr IViewObjectPresentSite, pDevice: ptr IUnknown, width: UINT, height: UINT, backBufferCount: UINT, format: DXGI_FORMAT, mode: VIEW_OBJECT_ALPHA_MODE, ppQueue: ptr ptr ISurfacePresenter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateSurfacePresenter(self, pDevice, width, height, backBufferCount, format, mode, ppQueue) +proc IsHardwareComposition*(self: ptr IViewObjectPresentSite, pIsHardwareComposition: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsHardwareComposition(self, pIsHardwareComposition) +proc SetCompositionMode*(self: ptr IViewObjectPresentSite, mode: VIEW_OBJECT_COMPOSITION_MODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionMode(self, mode) +proc Present*(self: ptr ISurfacePresenter, uBuffer: UINT, pDirty: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Present(self, uBuffer, pDirty) +proc GetBuffer*(self: ptr ISurfacePresenter, backBufferIndex: UINT, riid: REFIID, ppBuffer: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBuffer(self, backBufferIndex, riid, ppBuffer) +proc IsCurrent*(self: ptr ISurfacePresenter, pIsCurrent: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsCurrent(self, pIsCurrent) +proc GetBufferPointer*(self: ptr ICanvasPixelArrayData, ppBuffer: ptr ptr BYTE, pBufferLength: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBufferPointer(self, ppBuffer, pBufferLength) +proc GetPrintBitmap*(self: ptr IViewObjectPrint, ppPrintBitmap: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPrintBitmap(self, ppPrintBitmap) +proc RequestFrame*(self: ptr IViewObjectPresentNotifySite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestFrame(self) +proc OnPreRender*(self: ptr IViewObjectPresentNotify): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPreRender(self) +proc EvaluateUrl*(self: ptr ITrackingProtection, bstrUrl: BSTR, pfAllowed: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EvaluateUrl(self, bstrUrl, pfAllowed) +proc GetEnabled*(self: ptr ITrackingProtection, pfEnabled: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnabled(self, pfEnabled) +proc ShowHTMLDialog*(self: ptr IHostDialogHelper, hwndParent: HWND, pMk: ptr IMoniker, pvarArgIn: ptr VARIANT, pchOptions: ptr WCHAR, pvarArgOut: ptr VARIANT, punkHost: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowHTMLDialog(self, hwndParent, pMk, pvarArgIn, pchOptions, pvarArgOut, punkHost) +proc ShowContextMenu*(self: ptr IDocHostUIHandler, dwID: DWORD, ppt: ptr POINT, pcmdtReserved: ptr IUnknown, pdispReserved: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContextMenu(self, dwID, ppt, pcmdtReserved, pdispReserved) +proc GetHostInfo*(self: ptr IDocHostUIHandler, pInfo: ptr DOCHOSTUIINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHostInfo(self, pInfo) +proc ShowUI*(self: ptr IDocHostUIHandler, dwID: DWORD, pActiveObject: ptr IOleInPlaceActiveObject, pCommandTarget: ptr IOleCommandTarget, pFrame: ptr IOleInPlaceFrame, pDoc: ptr IOleInPlaceUIWindow): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowUI(self, dwID, pActiveObject, pCommandTarget, pFrame, pDoc) +proc HideUI*(self: ptr IDocHostUIHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HideUI(self) +proc UpdateUI*(self: ptr IDocHostUIHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateUI(self) +proc EnableModeless*(self: ptr IDocHostUIHandler, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc OnDocWindowActivate*(self: ptr IDocHostUIHandler, fActivate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDocWindowActivate(self, fActivate) +proc OnFrameWindowActivate*(self: ptr IDocHostUIHandler, fActivate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFrameWindowActivate(self, fActivate) +proc ResizeBorder*(self: ptr IDocHostUIHandler, prcBorder: LPCRECT, pUIWindow: ptr IOleInPlaceUIWindow, fRameWindow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResizeBorder(self, prcBorder, pUIWindow, fRameWindow) +proc TranslateAccelerator*(self: ptr IDocHostUIHandler, lpMsg: LPMSG, pguidCmdGroup: ptr GUID, nCmdID: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, lpMsg, pguidCmdGroup, nCmdID) +proc GetOptionKeyPath*(self: ptr IDocHostUIHandler, pchKey: ptr LPOLESTR, dw: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptionKeyPath(self, pchKey, dw) +proc GetDropTarget*(self: ptr IDocHostUIHandler, pDropTarget: ptr IDropTarget, ppDropTarget: ptr ptr IDropTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDropTarget(self, pDropTarget, ppDropTarget) +proc GetExternal*(self: ptr IDocHostUIHandler, ppDispatch: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExternal(self, ppDispatch) +proc TranslateUrl*(self: ptr IDocHostUIHandler, dwTranslate: DWORD, pchURLIn: LPWSTR, ppchURLOut: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateUrl(self, dwTranslate, pchURLIn, ppchURLOut) +proc FilterDataObject*(self: ptr IDocHostUIHandler, pDO: ptr IDataObject, ppDORet: ptr ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FilterDataObject(self, pDO, ppDORet) +proc GetOverrideKeyPath*(self: ptr IDocHostUIHandler2, pchKey: ptr LPOLESTR, dw: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverrideKeyPath(self, pchKey, dw) +proc SetUIHandler*(self: ptr ICustomDoc, pUIHandler: ptr IDocHostUIHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUIHandler(self, pUIHandler) +proc ShowMessage*(self: ptr IDocHostShowUI, hwnd: HWND, lpstrText: LPOLESTR, lpstrCaption: LPOLESTR, dwType: DWORD, lpstrHelpFile: LPOLESTR, dwHelpContext: DWORD, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowMessage(self, hwnd, lpstrText, lpstrCaption, dwType, lpstrHelpFile, dwHelpContext, plResult) +proc ShowHelp*(self: ptr IDocHostShowUI, hwnd: HWND, pszHelpFile: LPOLESTR, uCommand: UINT, dwData: DWORD, ptMouse: POINT, pDispatchObjectHit: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowHelp(self, hwnd, pszHelpFile, uCommand, dwData, ptMouse, pDispatchObjectHit) +proc CreateInstanceWithContext*(self: ptr IClassFactoryEx, punkContext: ptr IUnknown, punkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstanceWithContext(self, punkContext, punkOuter, riid, ppv) +proc moveTo*(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveTo(self, x, y) +proc moveBy*(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.moveBy(self, x, y) +proc resizeTo*(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.resizeTo(self, x, y) +proc resizeBy*(self: ptr IHTMLOMWindowServices, x: LONG, y: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.resizeBy(self, x, y) +converter winimConverterIDispatchExToIDispatch*(x: ptr IDispatchEx): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDispatchExToIUnknown*(x: ptr IDispatchEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDispErrorToIUnknown*(x: ptr IDispError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIVariantChangeTypeToIUnknown*(x: ptr IVariantChangeType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectIdentityToIUnknown*(x: ptr IObjectIdentity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanHandleExceptionToIUnknown*(x: ptr ICanHandleException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProvideRuntimeContextToIUnknown*(x: ptr IProvideRuntimeContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFiltersCollectionToIDispatch*(x: ptr IHTMLFiltersCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFiltersCollectionToIUnknown*(x: ptr IHTMLFiltersCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIIE70DispatchExToIDispatchEx*(x: ptr IIE70DispatchEx): ptr IDispatchEx = cast[ptr IDispatchEx](x) +converter winimConverterIIE70DispatchExToIDispatch*(x: ptr IIE70DispatchEx): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIIE70DispatchExToIUnknown*(x: ptr IIE70DispatchEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIIE80DispatchExToIDispatchEx*(x: ptr IIE80DispatchEx): ptr IDispatchEx = cast[ptr IDispatchEx](x) +converter winimConverterIIE80DispatchExToIDispatch*(x: ptr IIE80DispatchEx): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIIE80DispatchExToIUnknown*(x: ptr IIE80DispatchEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMConstructorToIDispatch*(x: ptr IHTMLDOMConstructor): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMConstructorToIUnknown*(x: ptr IHTMLDOMConstructor): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSStyleDeclarationToIDispatch*(x: ptr IHTMLCSSStyleDeclaration): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSStyleDeclarationToIUnknown*(x: ptr IHTMLCSSStyleDeclaration): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSStyleDeclaration2ToIDispatch*(x: ptr IHTMLCSSStyleDeclaration2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSStyleDeclaration2ToIUnknown*(x: ptr IHTMLCSSStyleDeclaration2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleEnabledToIDispatch*(x: ptr IHTMLStyleEnabled): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleEnabledToIUnknown*(x: ptr IHTMLStyleEnabled): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSStyleDeclarationToIDispatch*(x: ptr DispHTMLCSSStyleDeclaration): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSStyleDeclarationToIUnknown*(x: ptr DispHTMLCSSStyleDeclaration): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleToIDispatch*(x: ptr IHTMLStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleToIUnknown*(x: ptr IHTMLStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyle2ToIDispatch*(x: ptr IHTMLStyle2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyle2ToIUnknown*(x: ptr IHTMLStyle2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyle3ToIDispatch*(x: ptr IHTMLStyle3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyle3ToIUnknown*(x: ptr IHTMLStyle3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyle4ToIDispatch*(x: ptr IHTMLStyle4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyle4ToIUnknown*(x: ptr IHTMLStyle4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyle5ToIDispatch*(x: ptr IHTMLStyle5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyle5ToIUnknown*(x: ptr IHTMLStyle5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyle6ToIDispatch*(x: ptr IHTMLStyle6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyle6ToIUnknown*(x: ptr IHTMLStyle6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyleToIDispatch*(x: ptr IHTMLRuleStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyleToIUnknown*(x: ptr IHTMLRuleStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyle2ToIDispatch*(x: ptr IHTMLRuleStyle2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyle2ToIUnknown*(x: ptr IHTMLRuleStyle2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyle3ToIDispatch*(x: ptr IHTMLRuleStyle3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyle3ToIUnknown*(x: ptr IHTMLRuleStyle3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyle4ToIDispatch*(x: ptr IHTMLRuleStyle4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyle4ToIUnknown*(x: ptr IHTMLRuleStyle4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyle5ToIDispatch*(x: ptr IHTMLRuleStyle5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyle5ToIUnknown*(x: ptr IHTMLRuleStyle5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRuleStyle6ToIDispatch*(x: ptr IHTMLRuleStyle6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRuleStyle6ToIUnknown*(x: ptr IHTMLRuleStyle6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleToIDispatch*(x: ptr DispHTMLStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleToIUnknown*(x: ptr DispHTMLStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLRuleStyleToIDispatch*(x: ptr DispHTMLRuleStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLRuleStyleToIUnknown*(x: ptr DispHTMLRuleStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSRuleToIDispatch*(x: ptr IHTMLCSSRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSRuleToIUnknown*(x: ptr IHTMLCSSRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSImportRuleToIDispatch*(x: ptr IHTMLCSSImportRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSImportRuleToIUnknown*(x: ptr IHTMLCSSImportRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSMediaRuleToIDispatch*(x: ptr IHTMLCSSMediaRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSMediaRuleToIUnknown*(x: ptr IHTMLCSSMediaRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSMediaListToIDispatch*(x: ptr IHTMLCSSMediaList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSMediaListToIUnknown*(x: ptr IHTMLCSSMediaList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCSSNamespaceRuleToIDispatch*(x: ptr IHTMLCSSNamespaceRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCSSNamespaceRuleToIUnknown*(x: ptr IHTMLCSSNamespaceRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMSCSSKeyframeRuleToIDispatch*(x: ptr IHTMLMSCSSKeyframeRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMSCSSKeyframeRuleToIUnknown*(x: ptr IHTMLMSCSSKeyframeRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMSCSSKeyframesRuleToIDispatch*(x: ptr IHTMLMSCSSKeyframesRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMSCSSKeyframesRuleToIUnknown*(x: ptr IHTMLMSCSSKeyframesRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSRuleToIDispatch*(x: ptr DispHTMLCSSRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSRuleToIUnknown*(x: ptr DispHTMLCSSRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSImportRuleToIDispatch*(x: ptr DispHTMLCSSImportRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSImportRuleToIUnknown*(x: ptr DispHTMLCSSImportRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSMediaRuleToIDispatch*(x: ptr DispHTMLCSSMediaRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSMediaRuleToIUnknown*(x: ptr DispHTMLCSSMediaRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSMediaListToIDispatch*(x: ptr DispHTMLCSSMediaList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSMediaListToIUnknown*(x: ptr DispHTMLCSSMediaList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCSSNamespaceRuleToIDispatch*(x: ptr DispHTMLCSSNamespaceRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCSSNamespaceRuleToIUnknown*(x: ptr DispHTMLCSSNamespaceRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMSCSSKeyframeRuleToIDispatch*(x: ptr DispHTMLMSCSSKeyframeRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMSCSSKeyframeRuleToIUnknown*(x: ptr DispHTMLMSCSSKeyframeRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMSCSSKeyframesRuleToIDispatch*(x: ptr DispHTMLMSCSSKeyframesRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMSCSSKeyframesRuleToIUnknown*(x: ptr DispHTMLMSCSSKeyframesRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRenderStyleToIDispatch*(x: ptr IHTMLRenderStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRenderStyleToIUnknown*(x: ptr IHTMLRenderStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLRenderStyleToIDispatch*(x: ptr DispHTMLRenderStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLRenderStyleToIUnknown*(x: ptr DispHTMLRenderStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCurrentStyleToIDispatch*(x: ptr IHTMLCurrentStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCurrentStyleToIUnknown*(x: ptr IHTMLCurrentStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCurrentStyle2ToIDispatch*(x: ptr IHTMLCurrentStyle2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCurrentStyle2ToIUnknown*(x: ptr IHTMLCurrentStyle2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCurrentStyle3ToIDispatch*(x: ptr IHTMLCurrentStyle3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCurrentStyle3ToIUnknown*(x: ptr IHTMLCurrentStyle3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCurrentStyle4ToIDispatch*(x: ptr IHTMLCurrentStyle4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCurrentStyle4ToIUnknown*(x: ptr IHTMLCurrentStyle4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCurrentStyle5ToIDispatch*(x: ptr IHTMLCurrentStyle5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCurrentStyle5ToIUnknown*(x: ptr IHTMLCurrentStyle5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCurrentStyleToIDispatch*(x: ptr DispHTMLCurrentStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCurrentStyleToIUnknown*(x: ptr DispHTMLCurrentStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRectToIDispatch*(x: ptr IHTMLRect): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRectToIUnknown*(x: ptr IHTMLRect): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRect2ToIDispatch*(x: ptr IHTMLRect2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRect2ToIUnknown*(x: ptr IHTMLRect2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLRectCollectionToIDispatch*(x: ptr IHTMLRectCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLRectCollectionToIUnknown*(x: ptr IHTMLRectCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMNodeToIDispatch*(x: ptr IHTMLDOMNode): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMNodeToIUnknown*(x: ptr IHTMLDOMNode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMNode2ToIDispatch*(x: ptr IHTMLDOMNode2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMNode2ToIUnknown*(x: ptr IHTMLDOMNode2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMNode3ToIDispatch*(x: ptr IHTMLDOMNode3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMNode3ToIUnknown*(x: ptr IHTMLDOMNode3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMAttributeToIDispatch*(x: ptr IHTMLDOMAttribute): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMAttributeToIUnknown*(x: ptr IHTMLDOMAttribute): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMAttribute2ToIDispatch*(x: ptr IHTMLDOMAttribute2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMAttribute2ToIUnknown*(x: ptr IHTMLDOMAttribute2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMAttribute3ToIDispatch*(x: ptr IHTMLDOMAttribute3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMAttribute3ToIUnknown*(x: ptr IHTMLDOMAttribute3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMAttribute4ToIDispatch*(x: ptr IHTMLDOMAttribute4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMAttribute4ToIUnknown*(x: ptr IHTMLDOMAttribute4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMTextNodeToIDispatch*(x: ptr IHTMLDOMTextNode): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMTextNodeToIUnknown*(x: ptr IHTMLDOMTextNode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMTextNode2ToIDispatch*(x: ptr IHTMLDOMTextNode2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMTextNode2ToIUnknown*(x: ptr IHTMLDOMTextNode2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMTextNode3ToIDispatch*(x: ptr IHTMLDOMTextNode3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMTextNode3ToIUnknown*(x: ptr IHTMLDOMTextNode3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMImplementationToIDispatch*(x: ptr IHTMLDOMImplementation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMImplementationToIUnknown*(x: ptr IHTMLDOMImplementation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMImplementation2ToIDispatch*(x: ptr IHTMLDOMImplementation2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMImplementation2ToIUnknown*(x: ptr IHTMLDOMImplementation2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDOMAttributeToIDispatch*(x: ptr DispHTMLDOMAttribute): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDOMAttributeToIUnknown*(x: ptr DispHTMLDOMAttribute): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDOMTextNodeToIDispatch*(x: ptr DispHTMLDOMTextNode): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDOMTextNodeToIUnknown*(x: ptr DispHTMLDOMTextNode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDOMImplementationToIDispatch*(x: ptr DispHTMLDOMImplementation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDOMImplementationToIUnknown*(x: ptr DispHTMLDOMImplementation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAttributeCollectionToIDispatch*(x: ptr IHTMLAttributeCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAttributeCollectionToIUnknown*(x: ptr IHTMLAttributeCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAttributeCollection2ToIDispatch*(x: ptr IHTMLAttributeCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAttributeCollection2ToIUnknown*(x: ptr IHTMLAttributeCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAttributeCollection3ToIDispatch*(x: ptr IHTMLAttributeCollection3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAttributeCollection3ToIUnknown*(x: ptr IHTMLAttributeCollection3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAttributeCollection4ToIDispatch*(x: ptr IHTMLAttributeCollection4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAttributeCollection4ToIUnknown*(x: ptr IHTMLAttributeCollection4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMChildrenCollectionToIDispatch*(x: ptr IHTMLDOMChildrenCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMChildrenCollectionToIUnknown*(x: ptr IHTMLDOMChildrenCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMChildrenCollection2ToIDispatch*(x: ptr IHTMLDOMChildrenCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMChildrenCollection2ToIUnknown*(x: ptr IHTMLDOMChildrenCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAttributeCollectionToIDispatch*(x: ptr DispHTMLAttributeCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAttributeCollectionToIUnknown*(x: ptr DispHTMLAttributeCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispStaticNodeListToIDispatch*(x: ptr DispStaticNodeList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispStaticNodeListToIUnknown*(x: ptr DispStaticNodeList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMChildrenCollectionToIDispatch*(x: ptr DispDOMChildrenCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMChildrenCollectionToIUnknown*(x: ptr DispDOMChildrenCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLElementEvents4ToIDispatch*(x: ptr HTMLElementEvents4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLElementEvents4ToIUnknown*(x: ptr HTMLElementEvents4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLElementEvents3ToIDispatch*(x: ptr HTMLElementEvents3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLElementEvents3ToIUnknown*(x: ptr HTMLElementEvents3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLElementEvents2ToIDispatch*(x: ptr HTMLElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLElementEvents2ToIUnknown*(x: ptr HTMLElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLElementEventsToIDispatch*(x: ptr HTMLElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLElementEventsToIUnknown*(x: ptr HTMLElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementToIDispatch*(x: ptr IHTMLElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementToIUnknown*(x: ptr IHTMLElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement2ToIDispatch*(x: ptr IHTMLElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement2ToIUnknown*(x: ptr IHTMLElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement3ToIDispatch*(x: ptr IHTMLElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement3ToIUnknown*(x: ptr IHTMLElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement4ToIDispatch*(x: ptr IHTMLElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement4ToIUnknown*(x: ptr IHTMLElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementSelectorToIDispatch*(x: ptr IElementSelector): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIElementSelectorToIUnknown*(x: ptr IElementSelector): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementRenderToIUnknown*(x: ptr IHTMLElementRender): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLUniqueNameToIDispatch*(x: ptr IHTMLUniqueName): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLUniqueNameToIUnknown*(x: ptr IHTMLUniqueName): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement5ToIDispatch*(x: ptr IHTMLElement5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement5ToIUnknown*(x: ptr IHTMLElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement6ToIDispatch*(x: ptr IHTMLElement6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement6ToIUnknown*(x: ptr IHTMLElement6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElement7ToIDispatch*(x: ptr IHTMLElement7): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElement7ToIUnknown*(x: ptr IHTMLElement7): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementAppliedStylesToIDispatch*(x: ptr IHTMLElementAppliedStyles): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementAppliedStylesToIUnknown*(x: ptr IHTMLElementAppliedStyles): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementTraversalToIDispatch*(x: ptr IElementTraversal): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIElementTraversalToIUnknown*(x: ptr IElementTraversal): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDatabindingToIDispatch*(x: ptr IHTMLDatabinding): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDatabindingToIUnknown*(x: ptr IHTMLDatabinding): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementDefaultsToIDispatch*(x: ptr IHTMLElementDefaults): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementDefaultsToIUnknown*(x: ptr IHTMLElementDefaults): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDefaultsToIDispatch*(x: ptr DispHTMLDefaults): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDefaultsToIUnknown*(x: ptr DispHTMLDefaults): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCDefaultDispatchToIDispatch*(x: ptr IHTCDefaultDispatch): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCDefaultDispatchToIUnknown*(x: ptr IHTCDefaultDispatch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCPropertyBehaviorToIDispatch*(x: ptr IHTCPropertyBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCPropertyBehaviorToIUnknown*(x: ptr IHTCPropertyBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCMethodBehaviorToIDispatch*(x: ptr IHTCMethodBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCMethodBehaviorToIUnknown*(x: ptr IHTCMethodBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCEventBehaviorToIDispatch*(x: ptr IHTCEventBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCEventBehaviorToIUnknown*(x: ptr IHTCEventBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCAttachBehaviorToIDispatch*(x: ptr IHTCAttachBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCAttachBehaviorToIUnknown*(x: ptr IHTCAttachBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCAttachBehavior2ToIDispatch*(x: ptr IHTCAttachBehavior2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCAttachBehavior2ToIUnknown*(x: ptr IHTCAttachBehavior2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTCDescBehaviorToIDispatch*(x: ptr IHTCDescBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTCDescBehaviorToIUnknown*(x: ptr IHTCDescBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCDefaultDispatchToIDispatch*(x: ptr DispHTCDefaultDispatch): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCDefaultDispatchToIUnknown*(x: ptr DispHTCDefaultDispatch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCPropertyBehaviorToIDispatch*(x: ptr DispHTCPropertyBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCPropertyBehaviorToIUnknown*(x: ptr DispHTCPropertyBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCMethodBehaviorToIDispatch*(x: ptr DispHTCMethodBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCMethodBehaviorToIUnknown*(x: ptr DispHTCMethodBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCEventBehaviorToIDispatch*(x: ptr DispHTCEventBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCEventBehaviorToIUnknown*(x: ptr DispHTCEventBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCAttachBehaviorToIDispatch*(x: ptr DispHTCAttachBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCAttachBehaviorToIUnknown*(x: ptr DispHTCAttachBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTCDescBehaviorToIDispatch*(x: ptr DispHTCDescBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTCDescBehaviorToIUnknown*(x: ptr DispHTCDescBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLUrnCollectionToIDispatch*(x: ptr IHTMLUrnCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLUrnCollectionToIUnknown*(x: ptr IHTMLUrnCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLUrnCollectionToIDispatch*(x: ptr DispHTMLUrnCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLUrnCollectionToIUnknown*(x: ptr DispHTMLUrnCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLGenericElementToIDispatch*(x: ptr IHTMLGenericElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLGenericElementToIUnknown*(x: ptr IHTMLGenericElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLGenericElementToIDispatch*(x: ptr DispHTMLGenericElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLGenericElementToIUnknown*(x: ptr DispHTMLGenericElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRuleToIDispatch*(x: ptr IHTMLStyleSheetRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRuleToIUnknown*(x: ptr IHTMLStyleSheetRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRuleAppliedToIDispatch*(x: ptr IHTMLStyleSheetRuleApplied): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRuleAppliedToIUnknown*(x: ptr IHTMLStyleSheetRuleApplied): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRule2ToIDispatch*(x: ptr IHTMLStyleSheetRule2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRule2ToIUnknown*(x: ptr IHTMLStyleSheetRule2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRulesCollectionToIDispatch*(x: ptr IHTMLStyleSheetRulesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRulesCollectionToIUnknown*(x: ptr IHTMLStyleSheetRulesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRulesCollection2ToIDispatch*(x: ptr IHTMLStyleSheetRulesCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRulesCollection2ToIUnknown*(x: ptr IHTMLStyleSheetRulesCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetRuleToIDispatch*(x: ptr DispHTMLStyleSheetRule): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetRuleToIUnknown*(x: ptr DispHTMLStyleSheetRule): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetRulesCollectionToIDispatch*(x: ptr DispHTMLStyleSheetRulesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetRulesCollectionToIUnknown*(x: ptr DispHTMLStyleSheetRulesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetPageToIDispatch*(x: ptr IHTMLStyleSheetPage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetPageToIUnknown*(x: ptr IHTMLStyleSheetPage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetPage2ToIDispatch*(x: ptr IHTMLStyleSheetPage2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetPage2ToIUnknown*(x: ptr IHTMLStyleSheetPage2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetPagesCollectionToIDispatch*(x: ptr IHTMLStyleSheetPagesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetPagesCollectionToIUnknown*(x: ptr IHTMLStyleSheetPagesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetPageToIDispatch*(x: ptr DispHTMLStyleSheetPage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetPageToIUnknown*(x: ptr DispHTMLStyleSheetPage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetPagesCollectionToIDispatch*(x: ptr DispHTMLStyleSheetPagesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetPagesCollectionToIUnknown*(x: ptr DispHTMLStyleSheetPagesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetToIDispatch*(x: ptr IHTMLStyleSheet): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetToIUnknown*(x: ptr IHTMLStyleSheet): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheet2ToIDispatch*(x: ptr IHTMLStyleSheet2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheet2ToIUnknown*(x: ptr IHTMLStyleSheet2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheet3ToIDispatch*(x: ptr IHTMLStyleSheet3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheet3ToIUnknown*(x: ptr IHTMLStyleSheet3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheet4ToIDispatch*(x: ptr IHTMLStyleSheet4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheet4ToIUnknown*(x: ptr IHTMLStyleSheet4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetToIDispatch*(x: ptr DispHTMLStyleSheet): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetToIUnknown*(x: ptr DispHTMLStyleSheet): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetsCollectionToIDispatch*(x: ptr IHTMLStyleSheetsCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetsCollectionToIUnknown*(x: ptr IHTMLStyleSheetsCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetsCollection2ToIDispatch*(x: ptr IHTMLStyleSheetsCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetsCollection2ToIUnknown*(x: ptr IHTMLStyleSheetsCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetsCollectionToIDispatch*(x: ptr DispHTMLStyleSheetsCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetsCollectionToIUnknown*(x: ptr DispHTMLStyleSheetsCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLLinkElementEvents2ToIDispatch*(x: ptr HTMLLinkElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLLinkElementEvents2ToIUnknown*(x: ptr HTMLLinkElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLLinkElementEventsToIDispatch*(x: ptr HTMLLinkElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLLinkElementEventsToIUnknown*(x: ptr HTMLLinkElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLinkElementToIDispatch*(x: ptr IHTMLLinkElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLinkElementToIUnknown*(x: ptr IHTMLLinkElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLinkElement2ToIDispatch*(x: ptr IHTMLLinkElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLinkElement2ToIUnknown*(x: ptr IHTMLLinkElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLinkElement3ToIDispatch*(x: ptr IHTMLLinkElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLinkElement3ToIUnknown*(x: ptr IHTMLLinkElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLinkElement4ToIDispatch*(x: ptr IHTMLLinkElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLinkElement4ToIUnknown*(x: ptr IHTMLLinkElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLinkElement5ToIDispatch*(x: ptr IHTMLLinkElement5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLinkElement5ToIUnknown*(x: ptr IHTMLLinkElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLLinkElementToIDispatch*(x: ptr DispHTMLLinkElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLLinkElementToIUnknown*(x: ptr DispHTMLLinkElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTxtRangeToIDispatch*(x: ptr IHTMLTxtRange): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTxtRangeToIUnknown*(x: ptr IHTMLTxtRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextRangeMetricsToIDispatch*(x: ptr IHTMLTextRangeMetrics): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextRangeMetricsToIUnknown*(x: ptr IHTMLTextRangeMetrics): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextRangeMetrics2ToIDispatch*(x: ptr IHTMLTextRangeMetrics2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextRangeMetrics2ToIUnknown*(x: ptr IHTMLTextRangeMetrics2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTxtRangeCollectionToIDispatch*(x: ptr IHTMLTxtRangeCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTxtRangeCollectionToIUnknown*(x: ptr IHTMLTxtRangeCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMRangeToIDispatch*(x: ptr IHTMLDOMRange): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMRangeToIUnknown*(x: ptr IHTMLDOMRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDOMRangeToIDispatch*(x: ptr DispHTMLDOMRange): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDOMRangeToIUnknown*(x: ptr DispHTMLDOMRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLFormElementEvents2ToIDispatch*(x: ptr HTMLFormElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLFormElementEvents2ToIUnknown*(x: ptr HTMLFormElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLFormElementEventsToIDispatch*(x: ptr HTMLFormElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLFormElementEventsToIUnknown*(x: ptr HTMLFormElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFormElementToIDispatch*(x: ptr IHTMLFormElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFormElementToIUnknown*(x: ptr IHTMLFormElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFormElement2ToIDispatch*(x: ptr IHTMLFormElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFormElement2ToIUnknown*(x: ptr IHTMLFormElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFormElement3ToIDispatch*(x: ptr IHTMLFormElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFormElement3ToIUnknown*(x: ptr IHTMLFormElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSubmitDataToIDispatch*(x: ptr IHTMLSubmitData): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSubmitDataToIUnknown*(x: ptr IHTMLSubmitData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFormElement4ToIDispatch*(x: ptr IHTMLFormElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFormElement4ToIUnknown*(x: ptr IHTMLFormElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFormElementToIDispatch*(x: ptr DispHTMLFormElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFormElementToIUnknown*(x: ptr DispHTMLFormElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLControlElementEvents2ToIDispatch*(x: ptr HTMLControlElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLControlElementEvents2ToIUnknown*(x: ptr HTMLControlElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLControlElementEventsToIDispatch*(x: ptr HTMLControlElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLControlElementEventsToIUnknown*(x: ptr HTMLControlElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLControlElementToIDispatch*(x: ptr IHTMLControlElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLControlElementToIUnknown*(x: ptr IHTMLControlElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextElementToIDispatch*(x: ptr IHTMLTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextElementToIUnknown*(x: ptr IHTMLTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTextElementToIDispatch*(x: ptr DispHTMLTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTextElementToIUnknown*(x: ptr DispHTMLTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLTextContainerEvents2ToIDispatch*(x: ptr HTMLTextContainerEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLTextContainerEvents2ToIUnknown*(x: ptr HTMLTextContainerEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLTextContainerEventsToIDispatch*(x: ptr HTMLTextContainerEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLTextContainerEventsToIUnknown*(x: ptr HTMLTextContainerEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextContainerToIDispatch*(x: ptr IHTMLTextContainer): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextContainerToIUnknown*(x: ptr IHTMLTextContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLControlRangeToIDispatch*(x: ptr IHTMLControlRange): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLControlRangeToIUnknown*(x: ptr IHTMLControlRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLControlRange2ToIDispatch*(x: ptr IHTMLControlRange2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLControlRange2ToIUnknown*(x: ptr IHTMLControlRange2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLImgEvents2ToIDispatch*(x: ptr HTMLImgEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLImgEvents2ToIUnknown*(x: ptr HTMLImgEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLImgEventsToIDispatch*(x: ptr HTMLImgEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLImgEventsToIUnknown*(x: ptr HTMLImgEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLImgElementToIDispatch*(x: ptr IHTMLImgElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLImgElementToIUnknown*(x: ptr IHTMLImgElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLImgElement2ToIDispatch*(x: ptr IHTMLImgElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLImgElement2ToIUnknown*(x: ptr IHTMLImgElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLImgElement3ToIDispatch*(x: ptr IHTMLImgElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLImgElement3ToIUnknown*(x: ptr IHTMLImgElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLImgElement4ToIDispatch*(x: ptr IHTMLImgElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLImgElement4ToIUnknown*(x: ptr IHTMLImgElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMSImgElementToIDispatch*(x: ptr IHTMLMSImgElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMSImgElementToIUnknown*(x: ptr IHTMLMSImgElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLImageElementFactoryToIDispatch*(x: ptr IHTMLImageElementFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLImageElementFactoryToIUnknown*(x: ptr IHTMLImageElementFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLImgToIDispatch*(x: ptr DispHTMLImg): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLImgToIUnknown*(x: ptr DispHTMLImg): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBodyElementToIDispatch*(x: ptr IHTMLBodyElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBodyElementToIUnknown*(x: ptr IHTMLBodyElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBodyElement2ToIDispatch*(x: ptr IHTMLBodyElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBodyElement2ToIUnknown*(x: ptr IHTMLBodyElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBodyElement3ToIDispatch*(x: ptr IHTMLBodyElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBodyElement3ToIUnknown*(x: ptr IHTMLBodyElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBodyElement4ToIDispatch*(x: ptr IHTMLBodyElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBodyElement4ToIUnknown*(x: ptr IHTMLBodyElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBodyElement5ToIDispatch*(x: ptr IHTMLBodyElement5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBodyElement5ToIUnknown*(x: ptr IHTMLBodyElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBodyToIDispatch*(x: ptr DispHTMLBody): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBodyToIUnknown*(x: ptr DispHTMLBody): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFontElementToIDispatch*(x: ptr IHTMLFontElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFontElementToIUnknown*(x: ptr IHTMLFontElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFontElementToIDispatch*(x: ptr DispHTMLFontElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFontElementToIUnknown*(x: ptr DispHTMLFontElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLAnchorEvents2ToIDispatch*(x: ptr HTMLAnchorEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLAnchorEvents2ToIUnknown*(x: ptr HTMLAnchorEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLAnchorEventsToIDispatch*(x: ptr HTMLAnchorEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLAnchorEventsToIUnknown*(x: ptr HTMLAnchorEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAnchorElementToIDispatch*(x: ptr IHTMLAnchorElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAnchorElementToIUnknown*(x: ptr IHTMLAnchorElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAnchorElement2ToIDispatch*(x: ptr IHTMLAnchorElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAnchorElement2ToIUnknown*(x: ptr IHTMLAnchorElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAnchorElement3ToIDispatch*(x: ptr IHTMLAnchorElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAnchorElement3ToIUnknown*(x: ptr IHTMLAnchorElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAnchorElementToIDispatch*(x: ptr DispHTMLAnchorElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAnchorElementToIUnknown*(x: ptr DispHTMLAnchorElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLLabelEvents2ToIDispatch*(x: ptr HTMLLabelEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLLabelEvents2ToIUnknown*(x: ptr HTMLLabelEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLLabelEventsToIDispatch*(x: ptr HTMLLabelEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLLabelEventsToIUnknown*(x: ptr HTMLLabelEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLabelElementToIDispatch*(x: ptr IHTMLLabelElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLabelElementToIUnknown*(x: ptr IHTMLLabelElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLabelElement2ToIDispatch*(x: ptr IHTMLLabelElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLabelElement2ToIUnknown*(x: ptr IHTMLLabelElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLLabelElementToIDispatch*(x: ptr DispHTMLLabelElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLLabelElementToIUnknown*(x: ptr DispHTMLLabelElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLListElementToIDispatch*(x: ptr IHTMLListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLListElementToIUnknown*(x: ptr IHTMLListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLListElement2ToIDispatch*(x: ptr IHTMLListElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLListElement2ToIUnknown*(x: ptr IHTMLListElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLListElementToIDispatch*(x: ptr DispHTMLListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLListElementToIUnknown*(x: ptr DispHTMLListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLUListElementToIDispatch*(x: ptr IHTMLUListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLUListElementToIUnknown*(x: ptr IHTMLUListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLUListElementToIDispatch*(x: ptr DispHTMLUListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLUListElementToIUnknown*(x: ptr DispHTMLUListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOListElementToIDispatch*(x: ptr IHTMLOListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOListElementToIUnknown*(x: ptr IHTMLOListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLOListElementToIDispatch*(x: ptr DispHTMLOListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLOListElementToIUnknown*(x: ptr DispHTMLOListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLIElementToIDispatch*(x: ptr IHTMLLIElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLIElementToIUnknown*(x: ptr IHTMLLIElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLLIElementToIDispatch*(x: ptr DispHTMLLIElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLLIElementToIUnknown*(x: ptr DispHTMLLIElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBlockElementToIDispatch*(x: ptr IHTMLBlockElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBlockElementToIUnknown*(x: ptr IHTMLBlockElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBlockElement2ToIDispatch*(x: ptr IHTMLBlockElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBlockElement2ToIUnknown*(x: ptr IHTMLBlockElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBlockElement3ToIDispatch*(x: ptr IHTMLBlockElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBlockElement3ToIUnknown*(x: ptr IHTMLBlockElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBlockElementToIDispatch*(x: ptr DispHTMLBlockElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBlockElementToIUnknown*(x: ptr DispHTMLBlockElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDivElementToIDispatch*(x: ptr IHTMLDivElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDivElementToIUnknown*(x: ptr IHTMLDivElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDivElementToIDispatch*(x: ptr DispHTMLDivElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDivElementToIUnknown*(x: ptr DispHTMLDivElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDDElementToIDispatch*(x: ptr IHTMLDDElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDDElementToIUnknown*(x: ptr IHTMLDDElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDDElementToIDispatch*(x: ptr DispHTMLDDElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDDElementToIUnknown*(x: ptr DispHTMLDDElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDTElementToIDispatch*(x: ptr IHTMLDTElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDTElementToIUnknown*(x: ptr IHTMLDTElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDTElementToIDispatch*(x: ptr DispHTMLDTElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDTElementToIUnknown*(x: ptr DispHTMLDTElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBRElementToIDispatch*(x: ptr IHTMLBRElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBRElementToIUnknown*(x: ptr IHTMLBRElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBRElementToIDispatch*(x: ptr DispHTMLBRElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBRElementToIUnknown*(x: ptr DispHTMLBRElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDListElementToIDispatch*(x: ptr IHTMLDListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDListElementToIUnknown*(x: ptr IHTMLDListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDListElementToIDispatch*(x: ptr DispHTMLDListElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDListElementToIUnknown*(x: ptr DispHTMLDListElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLHRElementToIDispatch*(x: ptr IHTMLHRElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLHRElementToIUnknown*(x: ptr IHTMLHRElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLHRElementToIDispatch*(x: ptr DispHTMLHRElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLHRElementToIUnknown*(x: ptr DispHTMLHRElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLParaElementToIDispatch*(x: ptr IHTMLParaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLParaElementToIUnknown*(x: ptr IHTMLParaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLParaElementToIDispatch*(x: ptr DispHTMLParaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLParaElementToIUnknown*(x: ptr DispHTMLParaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementCollectionToIDispatch*(x: ptr IHTMLElementCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementCollectionToIUnknown*(x: ptr IHTMLElementCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementCollection2ToIDispatch*(x: ptr IHTMLElementCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementCollection2ToIUnknown*(x: ptr IHTMLElementCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementCollection3ToIDispatch*(x: ptr IHTMLElementCollection3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementCollection3ToIUnknown*(x: ptr IHTMLElementCollection3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLElementCollection4ToIDispatch*(x: ptr IHTMLElementCollection4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLElementCollection4ToIUnknown*(x: ptr IHTMLElementCollection4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLElementCollectionToIDispatch*(x: ptr DispHTMLElementCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLElementCollectionToIUnknown*(x: ptr DispHTMLElementCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLHeaderElementToIDispatch*(x: ptr IHTMLHeaderElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLHeaderElementToIUnknown*(x: ptr IHTMLHeaderElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLHeaderElementToIDispatch*(x: ptr DispHTMLHeaderElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLHeaderElementToIUnknown*(x: ptr DispHTMLHeaderElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLSelectElementEvents2ToIDispatch*(x: ptr HTMLSelectElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLSelectElementEvents2ToIUnknown*(x: ptr HTMLSelectElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLSelectElementEventsToIDispatch*(x: ptr HTMLSelectElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLSelectElementEventsToIUnknown*(x: ptr HTMLSelectElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElementExToIUnknown*(x: ptr IHTMLSelectElementEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElementToIDispatch*(x: ptr IHTMLSelectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectElementToIUnknown*(x: ptr IHTMLSelectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElement2ToIDispatch*(x: ptr IHTMLSelectElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectElement2ToIUnknown*(x: ptr IHTMLSelectElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElement4ToIDispatch*(x: ptr IHTMLSelectElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectElement4ToIUnknown*(x: ptr IHTMLSelectElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElement5ToIDispatch*(x: ptr IHTMLSelectElement5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectElement5ToIUnknown*(x: ptr IHTMLSelectElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectElement6ToIDispatch*(x: ptr IHTMLSelectElement6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectElement6ToIUnknown*(x: ptr IHTMLSelectElement6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLSelectElementToIDispatch*(x: ptr DispHTMLSelectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLSelectElementToIUnknown*(x: ptr DispHTMLSelectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLWndSelectElementToIDispatch*(x: ptr DispHTMLWndSelectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLWndSelectElementToIUnknown*(x: ptr DispHTMLWndSelectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectionObjectToIDispatch*(x: ptr IHTMLSelectionObject): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectionObjectToIUnknown*(x: ptr IHTMLSelectionObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectionObject2ToIDispatch*(x: ptr IHTMLSelectionObject2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectionObject2ToIUnknown*(x: ptr IHTMLSelectionObject2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSelectionToIDispatch*(x: ptr IHTMLSelection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSelectionToIUnknown*(x: ptr IHTMLSelection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionElementToIDispatch*(x: ptr IHTMLOptionElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionElementToIUnknown*(x: ptr IHTMLOptionElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionElement3ToIDispatch*(x: ptr IHTMLOptionElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionElement3ToIUnknown*(x: ptr IHTMLOptionElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionElement4ToIDispatch*(x: ptr IHTMLOptionElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionElement4ToIUnknown*(x: ptr IHTMLOptionElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionElementFactoryToIDispatch*(x: ptr IHTMLOptionElementFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionElementFactoryToIUnknown*(x: ptr IHTMLOptionElementFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLOptionElementToIDispatch*(x: ptr DispHTMLOptionElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLOptionElementToIUnknown*(x: ptr DispHTMLOptionElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLWndOptionElementToIDispatch*(x: ptr DispHTMLWndOptionElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLWndOptionElementToIUnknown*(x: ptr DispHTMLWndOptionElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLButtonElementEvents2ToIDispatch*(x: ptr HTMLButtonElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLButtonElementEvents2ToIUnknown*(x: ptr HTMLButtonElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLButtonElementEventsToIDispatch*(x: ptr HTMLButtonElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLButtonElementEventsToIUnknown*(x: ptr HTMLButtonElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputTextElementEvents2ToIDispatch*(x: ptr HTMLInputTextElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputTextElementEvents2ToIUnknown*(x: ptr HTMLInputTextElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLOptionButtonElementEvents2ToIDispatch*(x: ptr HTMLOptionButtonElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLOptionButtonElementEvents2ToIUnknown*(x: ptr HTMLOptionButtonElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputFileElementEvents2ToIDispatch*(x: ptr HTMLInputFileElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputFileElementEvents2ToIUnknown*(x: ptr HTMLInputFileElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputImageEvents2ToIDispatch*(x: ptr HTMLInputImageEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputImageEvents2ToIUnknown*(x: ptr HTMLInputImageEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputTextElementEventsToIDispatch*(x: ptr HTMLInputTextElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputTextElementEventsToIUnknown*(x: ptr HTMLInputTextElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLOptionButtonElementEventsToIDispatch*(x: ptr HTMLOptionButtonElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLOptionButtonElementEventsToIUnknown*(x: ptr HTMLOptionButtonElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputFileElementEventsToIDispatch*(x: ptr HTMLInputFileElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputFileElementEventsToIUnknown*(x: ptr HTMLInputFileElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLInputImageEventsToIDispatch*(x: ptr HTMLInputImageEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLInputImageEventsToIUnknown*(x: ptr HTMLInputImageEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputElementToIDispatch*(x: ptr IHTMLInputElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputElementToIUnknown*(x: ptr IHTMLInputElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputElement2ToIDispatch*(x: ptr IHTMLInputElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputElement2ToIUnknown*(x: ptr IHTMLInputElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputElement3ToIDispatch*(x: ptr IHTMLInputElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputElement3ToIUnknown*(x: ptr IHTMLInputElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputButtonElementToIDispatch*(x: ptr IHTMLInputButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputButtonElementToIUnknown*(x: ptr IHTMLInputButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputHiddenElementToIDispatch*(x: ptr IHTMLInputHiddenElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputHiddenElementToIUnknown*(x: ptr IHTMLInputHiddenElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputTextElementToIDispatch*(x: ptr IHTMLInputTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputTextElementToIUnknown*(x: ptr IHTMLInputTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputTextElement2ToIDispatch*(x: ptr IHTMLInputTextElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputTextElement2ToIUnknown*(x: ptr IHTMLInputTextElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputFileElementToIDispatch*(x: ptr IHTMLInputFileElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputFileElementToIUnknown*(x: ptr IHTMLInputFileElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionButtonElementToIDispatch*(x: ptr IHTMLOptionButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionButtonElementToIUnknown*(x: ptr IHTMLOptionButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputImageToIDispatch*(x: ptr IHTMLInputImage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputImageToIUnknown*(x: ptr IHTMLInputImage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLInputRangeElementToIDispatch*(x: ptr IHTMLInputRangeElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLInputRangeElementToIUnknown*(x: ptr IHTMLInputRangeElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLInputElementToIDispatch*(x: ptr DispHTMLInputElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLInputElementToIUnknown*(x: ptr DispHTMLInputElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextAreaElementToIDispatch*(x: ptr IHTMLTextAreaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextAreaElementToIUnknown*(x: ptr IHTMLTextAreaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTextAreaElement2ToIDispatch*(x: ptr IHTMLTextAreaElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTextAreaElement2ToIUnknown*(x: ptr IHTMLTextAreaElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTextAreaElementToIDispatch*(x: ptr DispHTMLTextAreaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTextAreaElementToIUnknown*(x: ptr DispHTMLTextAreaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLRichtextElementToIDispatch*(x: ptr DispHTMLRichtextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLRichtextElementToIUnknown*(x: ptr DispHTMLRichtextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLButtonElementToIDispatch*(x: ptr IHTMLButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLButtonElementToIUnknown*(x: ptr IHTMLButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLButtonElement2ToIDispatch*(x: ptr IHTMLButtonElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLButtonElement2ToIUnknown*(x: ptr IHTMLButtonElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLButtonElementToIDispatch*(x: ptr DispHTMLButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLButtonElementToIUnknown*(x: ptr DispHTMLButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLMarqueeElementEvents2ToIDispatch*(x: ptr HTMLMarqueeElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLMarqueeElementEvents2ToIUnknown*(x: ptr HTMLMarqueeElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLMarqueeElementEventsToIDispatch*(x: ptr HTMLMarqueeElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLMarqueeElementEventsToIUnknown*(x: ptr HTMLMarqueeElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMarqueeElementToIDispatch*(x: ptr IHTMLMarqueeElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMarqueeElementToIUnknown*(x: ptr IHTMLMarqueeElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMarqueeElementToIDispatch*(x: ptr DispHTMLMarqueeElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMarqueeElementToIUnknown*(x: ptr DispHTMLMarqueeElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLHtmlElementToIDispatch*(x: ptr IHTMLHtmlElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLHtmlElementToIUnknown*(x: ptr IHTMLHtmlElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLHeadElementToIDispatch*(x: ptr IHTMLHeadElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLHeadElementToIUnknown*(x: ptr IHTMLHeadElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLHeadElement2ToIDispatch*(x: ptr IHTMLHeadElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLHeadElement2ToIUnknown*(x: ptr IHTMLHeadElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTitleElementToIDispatch*(x: ptr IHTMLTitleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTitleElementToIUnknown*(x: ptr IHTMLTitleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMetaElementToIDispatch*(x: ptr IHTMLMetaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMetaElementToIUnknown*(x: ptr IHTMLMetaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMetaElement2ToIDispatch*(x: ptr IHTMLMetaElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMetaElement2ToIUnknown*(x: ptr IHTMLMetaElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMetaElement3ToIDispatch*(x: ptr IHTMLMetaElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMetaElement3ToIUnknown*(x: ptr IHTMLMetaElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBaseElementToIDispatch*(x: ptr IHTMLBaseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBaseElementToIUnknown*(x: ptr IHTMLBaseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBaseElement2ToIDispatch*(x: ptr IHTMLBaseElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBaseElement2ToIUnknown*(x: ptr IHTMLBaseElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIsIndexElementToIDispatch*(x: ptr IHTMLIsIndexElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIsIndexElementToIUnknown*(x: ptr IHTMLIsIndexElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIsIndexElement2ToIDispatch*(x: ptr IHTMLIsIndexElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIsIndexElement2ToIUnknown*(x: ptr IHTMLIsIndexElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLNextIdElementToIDispatch*(x: ptr IHTMLNextIdElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLNextIdElementToIUnknown*(x: ptr IHTMLNextIdElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLHtmlElementToIDispatch*(x: ptr DispHTMLHtmlElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLHtmlElementToIUnknown*(x: ptr DispHTMLHtmlElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLHeadElementToIDispatch*(x: ptr DispHTMLHeadElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLHeadElementToIUnknown*(x: ptr DispHTMLHeadElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTitleElementToIDispatch*(x: ptr DispHTMLTitleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTitleElementToIUnknown*(x: ptr DispHTMLTitleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMetaElementToIDispatch*(x: ptr DispHTMLMetaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMetaElementToIUnknown*(x: ptr DispHTMLMetaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBaseElementToIDispatch*(x: ptr DispHTMLBaseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBaseElementToIUnknown*(x: ptr DispHTMLBaseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLIsIndexElementToIDispatch*(x: ptr DispHTMLIsIndexElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLIsIndexElementToIUnknown*(x: ptr DispHTMLIsIndexElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLNextIdElementToIDispatch*(x: ptr DispHTMLNextIdElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLNextIdElementToIUnknown*(x: ptr DispHTMLNextIdElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBaseFontElementToIDispatch*(x: ptr IHTMLBaseFontElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBaseFontElementToIUnknown*(x: ptr IHTMLBaseFontElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBaseFontElementToIDispatch*(x: ptr DispHTMLBaseFontElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBaseFontElementToIUnknown*(x: ptr DispHTMLBaseFontElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLUnknownElementToIDispatch*(x: ptr IHTMLUnknownElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLUnknownElementToIUnknown*(x: ptr IHTMLUnknownElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLUnknownElementToIDispatch*(x: ptr DispHTMLUnknownElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLUnknownElementToIUnknown*(x: ptr DispHTMLUnknownElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOmHistoryToIDispatch*(x: ptr IOmHistory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIOmHistoryToIUnknown*(x: ptr IOmHistory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMimeTypesCollectionToIDispatch*(x: ptr IHTMLMimeTypesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMimeTypesCollectionToIUnknown*(x: ptr IHTMLMimeTypesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPluginsCollectionToIDispatch*(x: ptr IHTMLPluginsCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPluginsCollectionToIUnknown*(x: ptr IHTMLPluginsCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOpsProfileToIDispatch*(x: ptr IHTMLOpsProfile): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOpsProfileToIUnknown*(x: ptr IHTMLOpsProfile): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOmNavigatorToIDispatch*(x: ptr IOmNavigator): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIOmNavigatorToIUnknown*(x: ptr IOmNavigator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINavigatorGeolocationToIDispatch*(x: ptr INavigatorGeolocation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterINavigatorGeolocationToIUnknown*(x: ptr INavigatorGeolocation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINavigatorDoNotTrackToIDispatch*(x: ptr INavigatorDoNotTrack): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterINavigatorDoNotTrackToIUnknown*(x: ptr INavigatorDoNotTrack): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLocationToIDispatch*(x: ptr IHTMLLocation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLocationToIUnknown*(x: ptr IHTMLLocation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLHistoryToIDispatch*(x: ptr DispHTMLHistory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLHistoryToIUnknown*(x: ptr DispHTMLHistory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCPluginsToIDispatch*(x: ptr DispCPlugins): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCPluginsToIUnknown*(x: ptr DispCPlugins): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLNavigatorToIDispatch*(x: ptr DispHTMLNavigator): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLNavigatorToIUnknown*(x: ptr DispHTMLNavigator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLLocationToIDispatch*(x: ptr DispHTMLLocation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLLocationToIUnknown*(x: ptr DispHTMLLocation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBookmarkCollectionToIDispatch*(x: ptr IHTMLBookmarkCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBookmarkCollectionToIUnknown*(x: ptr IHTMLBookmarkCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDataTransferToIDispatch*(x: ptr IHTMLDataTransfer): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDataTransferToIUnknown*(x: ptr IHTMLDataTransfer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObjToIDispatch*(x: ptr IHTMLEventObj): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObjToIUnknown*(x: ptr IHTMLEventObj): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObj2ToIDispatch*(x: ptr IHTMLEventObj2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObj2ToIUnknown*(x: ptr IHTMLEventObj2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObj3ToIDispatch*(x: ptr IHTMLEventObj3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObj3ToIUnknown*(x: ptr IHTMLEventObj3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObj4ToIDispatch*(x: ptr IHTMLEventObj4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObj4ToIUnknown*(x: ptr IHTMLEventObj4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObj5ToIDispatch*(x: ptr IHTMLEventObj5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObj5ToIUnknown*(x: ptr IHTMLEventObj5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEventObj6ToIDispatch*(x: ptr IHTMLEventObj6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEventObj6ToIUnknown*(x: ptr IHTMLEventObj6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCEventObjToIDispatch*(x: ptr DispCEventObj): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCEventObjToIUnknown*(x: ptr DispCEventObj): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleMediaToIDispatch*(x: ptr IHTMLStyleMedia): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleMediaToIUnknown*(x: ptr IHTMLStyleMedia): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleMediaToIDispatch*(x: ptr DispHTMLStyleMedia): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleMediaToIUnknown*(x: ptr DispHTMLStyleMedia): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLWindowEvents3ToIDispatch*(x: ptr HTMLWindowEvents3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLWindowEvents3ToIUnknown*(x: ptr HTMLWindowEvents3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLWindowEvents2ToIDispatch*(x: ptr HTMLWindowEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLWindowEvents2ToIUnknown*(x: ptr HTMLWindowEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLWindowEventsToIDispatch*(x: ptr HTMLWindowEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLWindowEventsToIUnknown*(x: ptr HTMLWindowEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFramesCollection2ToIDispatch*(x: ptr IHTMLFramesCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFramesCollection2ToIUnknown*(x: ptr IHTMLFramesCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScreenToIDispatch*(x: ptr IHTMLScreen): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScreenToIUnknown*(x: ptr IHTMLScreen): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScreen2ToIDispatch*(x: ptr IHTMLScreen2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScreen2ToIUnknown*(x: ptr IHTMLScreen2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScreen3ToIDispatch*(x: ptr IHTMLScreen3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScreen3ToIUnknown*(x: ptr IHTMLScreen3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScreen4ToIDispatch*(x: ptr IHTMLScreen4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScreen4ToIUnknown*(x: ptr IHTMLScreen4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow2ToIHTMLFramesCollection2*(x: ptr IHTMLWindow2): ptr IHTMLFramesCollection2 = cast[ptr IHTMLFramesCollection2](x) +converter winimConverterIHTMLWindow2ToIDispatch*(x: ptr IHTMLWindow2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow2ToIUnknown*(x: ptr IHTMLWindow2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow3ToIDispatch*(x: ptr IHTMLWindow3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow3ToIUnknown*(x: ptr IHTMLWindow3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow4ToIDispatch*(x: ptr IHTMLWindow4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow4ToIUnknown*(x: ptr IHTMLWindow4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow5ToIDispatch*(x: ptr IHTMLWindow5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow5ToIUnknown*(x: ptr IHTMLWindow5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow6ToIDispatch*(x: ptr IHTMLWindow6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow6ToIUnknown*(x: ptr IHTMLWindow6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow7ToIDispatch*(x: ptr IHTMLWindow7): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow7ToIUnknown*(x: ptr IHTMLWindow7): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLWindow8ToIDispatch*(x: ptr IHTMLWindow8): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLWindow8ToIUnknown*(x: ptr IHTMLWindow8): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLScreenToIDispatch*(x: ptr DispHTMLScreen): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLScreenToIUnknown*(x: ptr DispHTMLScreen): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLWindow2ToIDispatch*(x: ptr DispHTMLWindow2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLWindow2ToIUnknown*(x: ptr DispHTMLWindow2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLWindowProxyToIDispatch*(x: ptr DispHTMLWindowProxy): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLWindowProxyToIUnknown*(x: ptr DispHTMLWindowProxy): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocumentCompatibleInfoToIDispatch*(x: ptr IHTMLDocumentCompatibleInfo): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocumentCompatibleInfoToIUnknown*(x: ptr IHTMLDocumentCompatibleInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocumentCompatibleInfoCollectionToIDispatch*(x: ptr IHTMLDocumentCompatibleInfoCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocumentCompatibleInfoCollectionToIUnknown*(x: ptr IHTMLDocumentCompatibleInfoCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDocumentCompatibleInfoToIDispatch*(x: ptr DispHTMLDocumentCompatibleInfo): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDocumentCompatibleInfoToIUnknown*(x: ptr DispHTMLDocumentCompatibleInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDocumentCompatibleInfoCollectionToIDispatch*(x: ptr DispHTMLDocumentCompatibleInfoCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDocumentCompatibleInfoCollectionToIUnknown*(x: ptr DispHTMLDocumentCompatibleInfoCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLDocumentEvents4ToIDispatch*(x: ptr HTMLDocumentEvents4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLDocumentEvents4ToIUnknown*(x: ptr HTMLDocumentEvents4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLDocumentEvents3ToIDispatch*(x: ptr HTMLDocumentEvents3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLDocumentEvents3ToIUnknown*(x: ptr HTMLDocumentEvents3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLDocumentEvents2ToIDispatch*(x: ptr HTMLDocumentEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLDocumentEvents2ToIUnknown*(x: ptr HTMLDocumentEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLDocumentEventsToIDispatch*(x: ptr HTMLDocumentEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLDocumentEventsToIUnknown*(x: ptr HTMLDocumentEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocumentToIDispatch*(x: ptr IHTMLDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocumentToIUnknown*(x: ptr IHTMLDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument2ToIHTMLDocument*(x: ptr IHTMLDocument2): ptr IHTMLDocument = cast[ptr IHTMLDocument](x) +converter winimConverterIHTMLDocument2ToIDispatch*(x: ptr IHTMLDocument2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument2ToIUnknown*(x: ptr IHTMLDocument2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument3ToIDispatch*(x: ptr IHTMLDocument3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument3ToIUnknown*(x: ptr IHTMLDocument3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument4ToIDispatch*(x: ptr IHTMLDocument4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument4ToIUnknown*(x: ptr IHTMLDocument4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument5ToIDispatch*(x: ptr IHTMLDocument5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument5ToIUnknown*(x: ptr IHTMLDocument5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument6ToIDispatch*(x: ptr IHTMLDocument6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument6ToIUnknown*(x: ptr IHTMLDocument6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument7ToIDispatch*(x: ptr IHTMLDocument7): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument7ToIUnknown*(x: ptr IHTMLDocument7): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDocument8ToIDispatch*(x: ptr IHTMLDocument8): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDocument8ToIUnknown*(x: ptr IHTMLDocument8): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocumentEventToIDispatch*(x: ptr IDocumentEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDocumentEventToIUnknown*(x: ptr IDocumentEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocumentRangeToIDispatch*(x: ptr IDocumentRange): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDocumentRangeToIUnknown*(x: ptr IDocumentRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocumentSelectorToIDispatch*(x: ptr IDocumentSelector): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDocumentSelectorToIUnknown*(x: ptr IDocumentSelector): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocumentTraversalToIDispatch*(x: ptr IDocumentTraversal): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDocumentTraversalToIUnknown*(x: ptr IDocumentTraversal): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDocumentToIDispatch*(x: ptr DispHTMLDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDocumentToIUnknown*(x: ptr DispHTMLDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDWebBridgeEventsToIDispatch*(x: ptr DWebBridgeEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDWebBridgeEventsToIUnknown*(x: ptr DWebBridgeEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebBridgeToIDispatch*(x: ptr IWebBridge): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebBridgeToIUnknown*(x: ptr IWebBridge): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWBScriptControlToIDispatch*(x: ptr IWBScriptControl): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWBScriptControlToIUnknown*(x: ptr IWBScriptControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEmbedElementToIDispatch*(x: ptr IHTMLEmbedElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEmbedElementToIUnknown*(x: ptr IHTMLEmbedElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEmbedElement2ToIDispatch*(x: ptr IHTMLEmbedElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLEmbedElement2ToIUnknown*(x: ptr IHTMLEmbedElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLEmbedToIDispatch*(x: ptr DispHTMLEmbed): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLEmbedToIUnknown*(x: ptr DispHTMLEmbed): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLMapEvents2ToIDispatch*(x: ptr HTMLMapEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLMapEvents2ToIUnknown*(x: ptr HTMLMapEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLMapEventsToIDispatch*(x: ptr HTMLMapEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLMapEventsToIUnknown*(x: ptr HTMLMapEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreasCollectionToIDispatch*(x: ptr IHTMLAreasCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreasCollectionToIUnknown*(x: ptr IHTMLAreasCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreasCollection2ToIDispatch*(x: ptr IHTMLAreasCollection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreasCollection2ToIUnknown*(x: ptr IHTMLAreasCollection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreasCollection3ToIDispatch*(x: ptr IHTMLAreasCollection3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreasCollection3ToIUnknown*(x: ptr IHTMLAreasCollection3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreasCollection4ToIDispatch*(x: ptr IHTMLAreasCollection4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreasCollection4ToIUnknown*(x: ptr IHTMLAreasCollection4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMapElementToIDispatch*(x: ptr IHTMLMapElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMapElementToIUnknown*(x: ptr IHTMLMapElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAreasCollectionToIDispatch*(x: ptr DispHTMLAreasCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAreasCollectionToIUnknown*(x: ptr DispHTMLAreasCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMapElementToIDispatch*(x: ptr DispHTMLMapElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMapElementToIUnknown*(x: ptr DispHTMLMapElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLAreaEvents2ToIDispatch*(x: ptr HTMLAreaEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLAreaEvents2ToIUnknown*(x: ptr HTMLAreaEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLAreaEventsToIDispatch*(x: ptr HTMLAreaEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLAreaEventsToIUnknown*(x: ptr HTMLAreaEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreaElementToIDispatch*(x: ptr IHTMLAreaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreaElementToIUnknown*(x: ptr IHTMLAreaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAreaElement2ToIDispatch*(x: ptr IHTMLAreaElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAreaElement2ToIUnknown*(x: ptr IHTMLAreaElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAreaElementToIDispatch*(x: ptr DispHTMLAreaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAreaElementToIUnknown*(x: ptr DispHTMLAreaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCaptionToIDispatch*(x: ptr IHTMLTableCaption): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCaptionToIUnknown*(x: ptr IHTMLTableCaption): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableCaptionToIDispatch*(x: ptr DispHTMLTableCaption): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableCaptionToIUnknown*(x: ptr DispHTMLTableCaption): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCommentElementToIDispatch*(x: ptr IHTMLCommentElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCommentElementToIUnknown*(x: ptr IHTMLCommentElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCommentElement2ToIDispatch*(x: ptr IHTMLCommentElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCommentElement2ToIUnknown*(x: ptr IHTMLCommentElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCommentElement3ToIDispatch*(x: ptr IHTMLCommentElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCommentElement3ToIUnknown*(x: ptr IHTMLCommentElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCommentElementToIDispatch*(x: ptr DispHTMLCommentElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCommentElementToIUnknown*(x: ptr DispHTMLCommentElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPhraseElementToIDispatch*(x: ptr IHTMLPhraseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPhraseElementToIUnknown*(x: ptr IHTMLPhraseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPhraseElement2ToIDispatch*(x: ptr IHTMLPhraseElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPhraseElement2ToIUnknown*(x: ptr IHTMLPhraseElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPhraseElement3ToIDispatch*(x: ptr IHTMLPhraseElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPhraseElement3ToIUnknown*(x: ptr IHTMLPhraseElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSpanElementToIDispatch*(x: ptr IHTMLSpanElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSpanElementToIUnknown*(x: ptr IHTMLSpanElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLPhraseElementToIDispatch*(x: ptr DispHTMLPhraseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLPhraseElementToIUnknown*(x: ptr DispHTMLPhraseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLSpanElementToIDispatch*(x: ptr DispHTMLSpanElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLSpanElementToIUnknown*(x: ptr DispHTMLSpanElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLTableEvents2ToIDispatch*(x: ptr HTMLTableEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLTableEvents2ToIUnknown*(x: ptr HTMLTableEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLTableEventsToIDispatch*(x: ptr HTMLTableEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLTableEventsToIUnknown*(x: ptr HTMLTableEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableToIDispatch*(x: ptr IHTMLTable): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableToIUnknown*(x: ptr IHTMLTable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTable2ToIDispatch*(x: ptr IHTMLTable2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTable2ToIUnknown*(x: ptr IHTMLTable2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTable3ToIDispatch*(x: ptr IHTMLTable3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTable3ToIUnknown*(x: ptr IHTMLTable3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTable4ToIDispatch*(x: ptr IHTMLTable4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTable4ToIUnknown*(x: ptr IHTMLTable4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableColToIDispatch*(x: ptr IHTMLTableCol): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableColToIUnknown*(x: ptr IHTMLTableCol): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCol2ToIDispatch*(x: ptr IHTMLTableCol2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCol2ToIUnknown*(x: ptr IHTMLTableCol2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCol3ToIDispatch*(x: ptr IHTMLTableCol3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCol3ToIUnknown*(x: ptr IHTMLTableCol3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableSectionToIDispatch*(x: ptr IHTMLTableSection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableSectionToIUnknown*(x: ptr IHTMLTableSection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableSection2ToIDispatch*(x: ptr IHTMLTableSection2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableSection2ToIUnknown*(x: ptr IHTMLTableSection2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableSection3ToIDispatch*(x: ptr IHTMLTableSection3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableSection3ToIUnknown*(x: ptr IHTMLTableSection3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableSection4ToIDispatch*(x: ptr IHTMLTableSection4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableSection4ToIUnknown*(x: ptr IHTMLTableSection4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableRowToIDispatch*(x: ptr IHTMLTableRow): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableRowToIUnknown*(x: ptr IHTMLTableRow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableRow2ToIDispatch*(x: ptr IHTMLTableRow2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableRow2ToIUnknown*(x: ptr IHTMLTableRow2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableRow3ToIDispatch*(x: ptr IHTMLTableRow3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableRow3ToIUnknown*(x: ptr IHTMLTableRow3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableRow4ToIDispatch*(x: ptr IHTMLTableRow4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableRow4ToIUnknown*(x: ptr IHTMLTableRow4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableRowMetricsToIDispatch*(x: ptr IHTMLTableRowMetrics): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableRowMetricsToIUnknown*(x: ptr IHTMLTableRowMetrics): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCellToIDispatch*(x: ptr IHTMLTableCell): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCellToIUnknown*(x: ptr IHTMLTableCell): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCell2ToIDispatch*(x: ptr IHTMLTableCell2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCell2ToIUnknown*(x: ptr IHTMLTableCell2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTableCell3ToIDispatch*(x: ptr IHTMLTableCell3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTableCell3ToIUnknown*(x: ptr IHTMLTableCell3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableToIDispatch*(x: ptr DispHTMLTable): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableToIUnknown*(x: ptr DispHTMLTable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableColToIDispatch*(x: ptr DispHTMLTableCol): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableColToIUnknown*(x: ptr DispHTMLTableCol): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableSectionToIDispatch*(x: ptr DispHTMLTableSection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableSectionToIUnknown*(x: ptr DispHTMLTableSection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableRowToIDispatch*(x: ptr DispHTMLTableRow): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableRowToIUnknown*(x: ptr DispHTMLTableRow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTableCellToIDispatch*(x: ptr DispHTMLTableCell): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTableCellToIUnknown*(x: ptr DispHTMLTableCell): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLScriptEvents2ToIDispatch*(x: ptr HTMLScriptEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLScriptEvents2ToIUnknown*(x: ptr HTMLScriptEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLScriptEventsToIDispatch*(x: ptr HTMLScriptEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLScriptEventsToIUnknown*(x: ptr HTMLScriptEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScriptElementToIDispatch*(x: ptr IHTMLScriptElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScriptElementToIUnknown*(x: ptr IHTMLScriptElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScriptElement2ToIDispatch*(x: ptr IHTMLScriptElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScriptElement2ToIUnknown*(x: ptr IHTMLScriptElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScriptElement3ToIDispatch*(x: ptr IHTMLScriptElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScriptElement3ToIUnknown*(x: ptr IHTMLScriptElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLScriptElement4ToIDispatch*(x: ptr IHTMLScriptElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLScriptElement4ToIUnknown*(x: ptr IHTMLScriptElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLScriptElementToIDispatch*(x: ptr DispHTMLScriptElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLScriptElementToIUnknown*(x: ptr DispHTMLScriptElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLNoShowElementToIDispatch*(x: ptr IHTMLNoShowElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLNoShowElementToIUnknown*(x: ptr IHTMLNoShowElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLNoShowElementToIDispatch*(x: ptr DispHTMLNoShowElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLNoShowElementToIUnknown*(x: ptr DispHTMLNoShowElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLObjectElementEvents2ToIDispatch*(x: ptr HTMLObjectElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLObjectElementEvents2ToIUnknown*(x: ptr HTMLObjectElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLObjectElementEventsToIDispatch*(x: ptr HTMLObjectElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLObjectElementEventsToIUnknown*(x: ptr HTMLObjectElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLObjectElementToIDispatch*(x: ptr IHTMLObjectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLObjectElementToIUnknown*(x: ptr IHTMLObjectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLObjectElement2ToIDispatch*(x: ptr IHTMLObjectElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLObjectElement2ToIUnknown*(x: ptr IHTMLObjectElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLObjectElement3ToIDispatch*(x: ptr IHTMLObjectElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLObjectElement3ToIUnknown*(x: ptr IHTMLObjectElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLObjectElement4ToIDispatch*(x: ptr IHTMLObjectElement4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLObjectElement4ToIUnknown*(x: ptr IHTMLObjectElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLObjectElement5ToIDispatch*(x: ptr IHTMLObjectElement5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLObjectElement5ToIUnknown*(x: ptr IHTMLObjectElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLParamElementToIDispatch*(x: ptr IHTMLParamElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLParamElementToIUnknown*(x: ptr IHTMLParamElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLParamElement2ToIDispatch*(x: ptr IHTMLParamElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLParamElement2ToIUnknown*(x: ptr IHTMLParamElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLObjectElementToIDispatch*(x: ptr DispHTMLObjectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLObjectElementToIUnknown*(x: ptr DispHTMLObjectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLParamElementToIDispatch*(x: ptr DispHTMLParamElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLParamElementToIUnknown*(x: ptr DispHTMLParamElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLFrameSiteEvents2ToIDispatch*(x: ptr HTMLFrameSiteEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLFrameSiteEvents2ToIUnknown*(x: ptr HTMLFrameSiteEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLFrameSiteEventsToIDispatch*(x: ptr HTMLFrameSiteEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLFrameSiteEventsToIUnknown*(x: ptr HTMLFrameSiteEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameBaseToIDispatch*(x: ptr IHTMLFrameBase): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameBaseToIUnknown*(x: ptr IHTMLFrameBase): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameBase2ToIDispatch*(x: ptr IHTMLFrameBase2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameBase2ToIUnknown*(x: ptr IHTMLFrameBase2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameBase3ToIDispatch*(x: ptr IHTMLFrameBase3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameBase3ToIUnknown*(x: ptr IHTMLFrameBase3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFrameBaseToIDispatch*(x: ptr DispHTMLFrameBase): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFrameBaseToIUnknown*(x: ptr DispHTMLFrameBase): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameElementToIDispatch*(x: ptr IHTMLFrameElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameElementToIUnknown*(x: ptr IHTMLFrameElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameElement2ToIDispatch*(x: ptr IHTMLFrameElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameElement2ToIUnknown*(x: ptr IHTMLFrameElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameElement3ToIDispatch*(x: ptr IHTMLFrameElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameElement3ToIUnknown*(x: ptr IHTMLFrameElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFrameElementToIDispatch*(x: ptr DispHTMLFrameElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFrameElementToIUnknown*(x: ptr DispHTMLFrameElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIFrameElementToIDispatch*(x: ptr IHTMLIFrameElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIFrameElementToIUnknown*(x: ptr IHTMLIFrameElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIFrameElement2ToIDispatch*(x: ptr IHTMLIFrameElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIFrameElement2ToIUnknown*(x: ptr IHTMLIFrameElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIFrameElement3ToIDispatch*(x: ptr IHTMLIFrameElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIFrameElement3ToIUnknown*(x: ptr IHTMLIFrameElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLIFrameToIDispatch*(x: ptr DispHTMLIFrame): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLIFrameToIUnknown*(x: ptr DispHTMLIFrame): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDivPositionToIDispatch*(x: ptr IHTMLDivPosition): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDivPositionToIUnknown*(x: ptr IHTMLDivPosition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFieldSetElementToIDispatch*(x: ptr IHTMLFieldSetElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFieldSetElementToIUnknown*(x: ptr IHTMLFieldSetElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFieldSetElement2ToIDispatch*(x: ptr IHTMLFieldSetElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFieldSetElement2ToIUnknown*(x: ptr IHTMLFieldSetElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLegendElementToIDispatch*(x: ptr IHTMLLegendElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLegendElementToIUnknown*(x: ptr IHTMLLegendElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLLegendElement2ToIDispatch*(x: ptr IHTMLLegendElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLLegendElement2ToIUnknown*(x: ptr IHTMLLegendElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLDivPositionToIDispatch*(x: ptr DispHTMLDivPosition): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLDivPositionToIUnknown*(x: ptr DispHTMLDivPosition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFieldSetElementToIDispatch*(x: ptr DispHTMLFieldSetElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFieldSetElementToIUnknown*(x: ptr DispHTMLFieldSetElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLLegendElementToIDispatch*(x: ptr DispHTMLLegendElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLLegendElementToIUnknown*(x: ptr DispHTMLLegendElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSpanFlowToIDispatch*(x: ptr IHTMLSpanFlow): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSpanFlowToIUnknown*(x: ptr IHTMLSpanFlow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLSpanFlowToIDispatch*(x: ptr DispHTMLSpanFlow): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLSpanFlowToIUnknown*(x: ptr DispHTMLSpanFlow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameSetElementToIDispatch*(x: ptr IHTMLFrameSetElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameSetElementToIUnknown*(x: ptr IHTMLFrameSetElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameSetElement2ToIDispatch*(x: ptr IHTMLFrameSetElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameSetElement2ToIUnknown*(x: ptr IHTMLFrameSetElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFrameSetElement3ToIDispatch*(x: ptr IHTMLFrameSetElement3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFrameSetElement3ToIUnknown*(x: ptr IHTMLFrameSetElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLFrameSetSiteToIDispatch*(x: ptr DispHTMLFrameSetSite): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLFrameSetSiteToIUnknown*(x: ptr DispHTMLFrameSetSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLBGsoundToIDispatch*(x: ptr IHTMLBGsound): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLBGsoundToIUnknown*(x: ptr IHTMLBGsound): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLBGsoundToIDispatch*(x: ptr DispHTMLBGsound): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLBGsoundToIUnknown*(x: ptr DispHTMLBGsound): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFontNamesCollectionToIDispatch*(x: ptr IHTMLFontNamesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFontNamesCollectionToIUnknown*(x: ptr IHTMLFontNamesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLFontSizesCollectionToIDispatch*(x: ptr IHTMLFontSizesCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLFontSizesCollectionToIUnknown*(x: ptr IHTMLFontSizesCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOptionsHolderToIDispatch*(x: ptr IHTMLOptionsHolder): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLOptionsHolderToIUnknown*(x: ptr IHTMLOptionsHolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLStyleElementEvents2ToIDispatch*(x: ptr HTMLStyleElementEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLStyleElementEvents2ToIUnknown*(x: ptr HTMLStyleElementEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLStyleElementEventsToIDispatch*(x: ptr HTMLStyleElementEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLStyleElementEventsToIUnknown*(x: ptr HTMLStyleElementEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleElementToIDispatch*(x: ptr IHTMLStyleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleElementToIUnknown*(x: ptr IHTMLStyleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleElement2ToIDispatch*(x: ptr IHTMLStyleElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleElement2ToIUnknown*(x: ptr IHTMLStyleElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleElementToIDispatch*(x: ptr DispHTMLStyleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleElementToIUnknown*(x: ptr DispHTMLStyleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleFontFaceToIDispatch*(x: ptr IHTMLStyleFontFace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleFontFaceToIUnknown*(x: ptr IHTMLStyleFontFace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleFontFace2ToIDispatch*(x: ptr IHTMLStyleFontFace2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleFontFace2ToIUnknown*(x: ptr IHTMLStyleFontFace2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleFontFaceToIDispatch*(x: ptr DispHTMLStyleFontFace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleFontFaceToIUnknown*(x: ptr DispHTMLStyleFontFace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLXDomainRequestToIDispatch*(x: ptr IHTMLXDomainRequest): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLXDomainRequestToIUnknown*(x: ptr IHTMLXDomainRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLXDomainRequestFactoryToIDispatch*(x: ptr IHTMLXDomainRequestFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLXDomainRequestFactoryToIUnknown*(x: ptr IHTMLXDomainRequestFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispXDomainRequestToIDispatch*(x: ptr DispXDomainRequest): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispXDomainRequestToIUnknown*(x: ptr DispXDomainRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStorageToIDispatch*(x: ptr IHTMLStorage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStorageToIUnknown*(x: ptr IHTMLStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStorage2ToIDispatch*(x: ptr IHTMLStorage2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStorage2ToIUnknown*(x: ptr IHTMLStorage2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStorageToIDispatch*(x: ptr DispHTMLStorage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStorageToIUnknown*(x: ptr DispHTMLStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEventTargetToIDispatch*(x: ptr IEventTarget): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIEventTargetToIUnknown*(x: ptr IEventTarget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMEventToIDispatch*(x: ptr IDOMEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMEventToIUnknown*(x: ptr IDOMEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMEventToIDispatch*(x: ptr DispDOMEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMEventToIUnknown*(x: ptr DispDOMEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMUIEventToIDispatch*(x: ptr IDOMUIEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMUIEventToIUnknown*(x: ptr IDOMUIEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMUIEventToIDispatch*(x: ptr DispDOMUIEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMUIEventToIUnknown*(x: ptr DispDOMUIEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMouseEventToIDispatch*(x: ptr IDOMMouseEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMouseEventToIUnknown*(x: ptr IDOMMouseEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMouseEventToIDispatch*(x: ptr DispDOMMouseEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMouseEventToIUnknown*(x: ptr DispDOMMouseEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMDragEventToIDispatch*(x: ptr IDOMDragEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMDragEventToIUnknown*(x: ptr IDOMDragEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMDragEventToIDispatch*(x: ptr DispDOMDragEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMDragEventToIUnknown*(x: ptr DispDOMDragEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMouseWheelEventToIDispatch*(x: ptr IDOMMouseWheelEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMouseWheelEventToIUnknown*(x: ptr IDOMMouseWheelEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMouseWheelEventToIDispatch*(x: ptr DispDOMMouseWheelEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMouseWheelEventToIUnknown*(x: ptr DispDOMMouseWheelEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMWheelEventToIDispatch*(x: ptr IDOMWheelEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMWheelEventToIUnknown*(x: ptr IDOMWheelEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMWheelEventToIDispatch*(x: ptr DispDOMWheelEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMWheelEventToIUnknown*(x: ptr DispDOMWheelEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMTextEventToIDispatch*(x: ptr IDOMTextEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMTextEventToIUnknown*(x: ptr IDOMTextEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMTextEventToIDispatch*(x: ptr DispDOMTextEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMTextEventToIUnknown*(x: ptr DispDOMTextEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMKeyboardEventToIDispatch*(x: ptr IDOMKeyboardEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMKeyboardEventToIUnknown*(x: ptr IDOMKeyboardEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMKeyboardEventToIDispatch*(x: ptr DispDOMKeyboardEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMKeyboardEventToIUnknown*(x: ptr DispDOMKeyboardEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMCompositionEventToIDispatch*(x: ptr IDOMCompositionEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMCompositionEventToIUnknown*(x: ptr IDOMCompositionEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMCompositionEventToIDispatch*(x: ptr DispDOMCompositionEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMCompositionEventToIUnknown*(x: ptr DispDOMCompositionEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMutationEventToIDispatch*(x: ptr IDOMMutationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMutationEventToIUnknown*(x: ptr IDOMMutationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMutationEventToIDispatch*(x: ptr DispDOMMutationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMutationEventToIUnknown*(x: ptr DispDOMMutationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMBeforeUnloadEventToIDispatch*(x: ptr IDOMBeforeUnloadEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMBeforeUnloadEventToIUnknown*(x: ptr IDOMBeforeUnloadEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMBeforeUnloadEventToIDispatch*(x: ptr DispDOMBeforeUnloadEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMBeforeUnloadEventToIUnknown*(x: ptr DispDOMBeforeUnloadEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMFocusEventToIDispatch*(x: ptr IDOMFocusEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMFocusEventToIUnknown*(x: ptr IDOMFocusEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMFocusEventToIDispatch*(x: ptr DispDOMFocusEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMFocusEventToIUnknown*(x: ptr DispDOMFocusEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMCustomEventToIDispatch*(x: ptr IDOMCustomEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMCustomEventToIUnknown*(x: ptr IDOMCustomEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMCustomEventToIDispatch*(x: ptr DispDOMCustomEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMCustomEventToIUnknown*(x: ptr DispDOMCustomEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasGradientToIDispatch*(x: ptr ICanvasGradient): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasGradientToIUnknown*(x: ptr ICanvasGradient): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasPatternToIDispatch*(x: ptr ICanvasPattern): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasPatternToIUnknown*(x: ptr ICanvasPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasTextMetricsToIDispatch*(x: ptr ICanvasTextMetrics): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasTextMetricsToIUnknown*(x: ptr ICanvasTextMetrics): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasImageDataToIDispatch*(x: ptr ICanvasImageData): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasImageDataToIUnknown*(x: ptr ICanvasImageData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasPixelArrayToIDispatch*(x: ptr ICanvasPixelArray): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasPixelArrayToIUnknown*(x: ptr ICanvasPixelArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasRenderingContext2DToIDispatch*(x: ptr ICanvasRenderingContext2D): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterICanvasRenderingContext2DToIUnknown*(x: ptr ICanvasRenderingContext2D): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCanvasElementToIDispatch*(x: ptr IHTMLCanvasElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLCanvasElementToIUnknown*(x: ptr IHTMLCanvasElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCanvasGradientToIDispatch*(x: ptr DispCanvasGradient): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCanvasGradientToIUnknown*(x: ptr DispCanvasGradient): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCanvasPatternToIDispatch*(x: ptr DispCanvasPattern): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCanvasPatternToIUnknown*(x: ptr DispCanvasPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCanvasTextMetricsToIDispatch*(x: ptr DispCanvasTextMetrics): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCanvasTextMetricsToIUnknown*(x: ptr DispCanvasTextMetrics): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCanvasImageDataToIDispatch*(x: ptr DispCanvasImageData): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCanvasImageDataToIUnknown*(x: ptr DispCanvasImageData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCanvasRenderingContext2DToIDispatch*(x: ptr DispCanvasRenderingContext2D): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCanvasRenderingContext2DToIUnknown*(x: ptr DispCanvasRenderingContext2D): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLCanvasElementToIDispatch*(x: ptr DispHTMLCanvasElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLCanvasElementToIUnknown*(x: ptr DispHTMLCanvasElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMProgressEventToIDispatch*(x: ptr IDOMProgressEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMProgressEventToIUnknown*(x: ptr IDOMProgressEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMProgressEventToIDispatch*(x: ptr DispDOMProgressEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMProgressEventToIUnknown*(x: ptr DispDOMProgressEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMessageEventToIDispatch*(x: ptr IDOMMessageEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMessageEventToIUnknown*(x: ptr IDOMMessageEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMessageEventToIDispatch*(x: ptr DispDOMMessageEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMessageEventToIUnknown*(x: ptr DispDOMMessageEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMSiteModeEventToIDispatch*(x: ptr IDOMSiteModeEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMSiteModeEventToIUnknown*(x: ptr IDOMSiteModeEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMSiteModeEventToIDispatch*(x: ptr DispDOMSiteModeEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMSiteModeEventToIUnknown*(x: ptr DispDOMSiteModeEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMStorageEventToIDispatch*(x: ptr IDOMStorageEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMStorageEventToIUnknown*(x: ptr IDOMStorageEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMStorageEventToIDispatch*(x: ptr DispDOMStorageEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMStorageEventToIUnknown*(x: ptr DispDOMStorageEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLHttpRequestEventTargetToIDispatch*(x: ptr IXMLHttpRequestEventTarget): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLHttpRequestEventTargetToIUnknown*(x: ptr IXMLHttpRequestEventTarget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispXMLHttpRequestEventTargetToIDispatch*(x: ptr DispXMLHttpRequestEventTarget): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispXMLHttpRequestEventTargetToIUnknown*(x: ptr DispXMLHttpRequestEventTarget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLXMLHttpRequestEventsToIDispatch*(x: ptr HTMLXMLHttpRequestEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLXMLHttpRequestEventsToIUnknown*(x: ptr HTMLXMLHttpRequestEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLXMLHttpRequestToIDispatch*(x: ptr IHTMLXMLHttpRequest): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLXMLHttpRequestToIUnknown*(x: ptr IHTMLXMLHttpRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLXMLHttpRequest2ToIDispatch*(x: ptr IHTMLXMLHttpRequest2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLXMLHttpRequest2ToIUnknown*(x: ptr IHTMLXMLHttpRequest2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLXMLHttpRequestFactoryToIDispatch*(x: ptr IHTMLXMLHttpRequestFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLXMLHttpRequestFactoryToIUnknown*(x: ptr IHTMLXMLHttpRequestFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLXMLHttpRequestToIDispatch*(x: ptr DispHTMLXMLHttpRequest): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLXMLHttpRequestToIUnknown*(x: ptr DispHTMLXMLHttpRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAngleToIDispatch*(x: ptr ISVGAngle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAngleToIUnknown*(x: ptr ISVGAngle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGStylableToIDispatch*(x: ptr ISVGStylable): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGStylableToIUnknown*(x: ptr ISVGStylable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLocatableToIDispatch*(x: ptr ISVGLocatable): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLocatableToIUnknown*(x: ptr ISVGLocatable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTransformableToIDispatch*(x: ptr ISVGTransformable): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTransformableToIUnknown*(x: ptr ISVGTransformable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTestsToIDispatch*(x: ptr ISVGTests): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTestsToIUnknown*(x: ptr ISVGTests): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLangSpaceToIDispatch*(x: ptr ISVGLangSpace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLangSpaceToIUnknown*(x: ptr ISVGLangSpace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGExternalResourcesRequiredToIDispatch*(x: ptr ISVGExternalResourcesRequired): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGExternalResourcesRequiredToIUnknown*(x: ptr ISVGExternalResourcesRequired): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGFitToViewBoxToIDispatch*(x: ptr ISVGFitToViewBox): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGFitToViewBoxToIUnknown*(x: ptr ISVGFitToViewBox): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGZoomAndPanToIDispatch*(x: ptr ISVGZoomAndPan): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGZoomAndPanToIUnknown*(x: ptr ISVGZoomAndPan): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGURIReferenceToIDispatch*(x: ptr ISVGURIReference): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGURIReferenceToIUnknown*(x: ptr ISVGURIReference): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedAngleToIDispatch*(x: ptr ISVGAnimatedAngle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedAngleToIUnknown*(x: ptr ISVGAnimatedAngle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedTransformListToIDispatch*(x: ptr ISVGAnimatedTransformList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedTransformListToIUnknown*(x: ptr ISVGAnimatedTransformList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedBooleanToIDispatch*(x: ptr ISVGAnimatedBoolean): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedBooleanToIUnknown*(x: ptr ISVGAnimatedBoolean): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedEnumerationToIDispatch*(x: ptr ISVGAnimatedEnumeration): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedEnumerationToIUnknown*(x: ptr ISVGAnimatedEnumeration): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedIntegerToIDispatch*(x: ptr ISVGAnimatedInteger): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedIntegerToIUnknown*(x: ptr ISVGAnimatedInteger): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedLengthToIDispatch*(x: ptr ISVGAnimatedLength): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedLengthToIUnknown*(x: ptr ISVGAnimatedLength): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedLengthListToIDispatch*(x: ptr ISVGAnimatedLengthList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedLengthListToIUnknown*(x: ptr ISVGAnimatedLengthList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedNumberToIDispatch*(x: ptr ISVGAnimatedNumber): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedNumberToIUnknown*(x: ptr ISVGAnimatedNumber): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedNumberListToIDispatch*(x: ptr ISVGAnimatedNumberList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedNumberListToIUnknown*(x: ptr ISVGAnimatedNumberList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedRectToIDispatch*(x: ptr ISVGAnimatedRect): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedRectToIUnknown*(x: ptr ISVGAnimatedRect): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedStringToIDispatch*(x: ptr ISVGAnimatedString): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedStringToIUnknown*(x: ptr ISVGAnimatedString): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGClipPathElementToIDispatch*(x: ptr ISVGClipPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGClipPathElementToIUnknown*(x: ptr ISVGClipPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGClipPathElementToIDispatch*(x: ptr DispSVGClipPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGClipPathElementToIUnknown*(x: ptr DispSVGClipPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGDocumentToIDispatch*(x: ptr ISVGDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGDocumentToIUnknown*(x: ptr ISVGDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGetSVGDocumentToIDispatch*(x: ptr IGetSVGDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIGetSVGDocumentToIUnknown*(x: ptr IGetSVGDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGElementToIDispatch*(x: ptr ISVGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGElementToIUnknown*(x: ptr ISVGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGElementToIDispatch*(x: ptr DispSVGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGElementToIUnknown*(x: ptr DispSVGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIICCSVGColorToIDispatch*(x: ptr IICCSVGColor): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIICCSVGColorToIUnknown*(x: ptr IICCSVGColor): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLengthToIDispatch*(x: ptr ISVGLength): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLengthToIUnknown*(x: ptr ISVGLength): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLengthListToIDispatch*(x: ptr ISVGLengthList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLengthListToIUnknown*(x: ptr ISVGLengthList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGMatrixToIDispatch*(x: ptr ISVGMatrix): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGMatrixToIUnknown*(x: ptr ISVGMatrix): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGNumberToIDispatch*(x: ptr ISVGNumber): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGNumberToIUnknown*(x: ptr ISVGNumber): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGNumberListToIDispatch*(x: ptr ISVGNumberList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGNumberListToIUnknown*(x: ptr ISVGNumberList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPaintToIDispatch*(x: ptr ISVGPaint): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPaintToIUnknown*(x: ptr ISVGPaint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPatternElementToIDispatch*(x: ptr ISVGPatternElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPatternElementToIUnknown*(x: ptr ISVGPatternElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPatternElementToIDispatch*(x: ptr DispSVGPatternElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPatternElementToIUnknown*(x: ptr DispSVGPatternElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegToIDispatch*(x: ptr ISVGPathSeg): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegToIUnknown*(x: ptr ISVGPathSeg): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegArcAbsToIDispatch*(x: ptr ISVGPathSegArcAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegArcAbsToIUnknown*(x: ptr ISVGPathSegArcAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegArcRelToIDispatch*(x: ptr ISVGPathSegArcRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegArcRelToIUnknown*(x: ptr ISVGPathSegArcRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegClosePathToIDispatch*(x: ptr ISVGPathSegClosePath): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegClosePathToIUnknown*(x: ptr ISVGPathSegClosePath): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegMovetoAbsToIDispatch*(x: ptr ISVGPathSegMovetoAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegMovetoAbsToIUnknown*(x: ptr ISVGPathSegMovetoAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegMovetoRelToIDispatch*(x: ptr ISVGPathSegMovetoRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegMovetoRelToIUnknown*(x: ptr ISVGPathSegMovetoRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoAbsToIDispatch*(x: ptr ISVGPathSegLinetoAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoAbsToIUnknown*(x: ptr ISVGPathSegLinetoAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoRelToIDispatch*(x: ptr ISVGPathSegLinetoRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoRelToIUnknown*(x: ptr ISVGPathSegLinetoRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoCubicAbsToIDispatch*(x: ptr ISVGPathSegCurvetoCubicAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoCubicAbsToIUnknown*(x: ptr ISVGPathSegCurvetoCubicAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoCubicRelToIDispatch*(x: ptr ISVGPathSegCurvetoCubicRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoCubicRelToIUnknown*(x: ptr ISVGPathSegCurvetoCubicRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoCubicSmoothAbsToIDispatch*(x: ptr ISVGPathSegCurvetoCubicSmoothAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoCubicSmoothAbsToIUnknown*(x: ptr ISVGPathSegCurvetoCubicSmoothAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoCubicSmoothRelToIDispatch*(x: ptr ISVGPathSegCurvetoCubicSmoothRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoCubicSmoothRelToIUnknown*(x: ptr ISVGPathSegCurvetoCubicSmoothRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoQuadraticAbsToIDispatch*(x: ptr ISVGPathSegCurvetoQuadraticAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoQuadraticAbsToIUnknown*(x: ptr ISVGPathSegCurvetoQuadraticAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoQuadraticRelToIDispatch*(x: ptr ISVGPathSegCurvetoQuadraticRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoQuadraticRelToIUnknown*(x: ptr ISVGPathSegCurvetoQuadraticRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoQuadraticSmoothAbsToIDispatch*(x: ptr ISVGPathSegCurvetoQuadraticSmoothAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoQuadraticSmoothAbsToIUnknown*(x: ptr ISVGPathSegCurvetoQuadraticSmoothAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegCurvetoQuadraticSmoothRelToIDispatch*(x: ptr ISVGPathSegCurvetoQuadraticSmoothRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegCurvetoQuadraticSmoothRelToIUnknown*(x: ptr ISVGPathSegCurvetoQuadraticSmoothRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoHorizontalAbsToIDispatch*(x: ptr ISVGPathSegLinetoHorizontalAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoHorizontalAbsToIUnknown*(x: ptr ISVGPathSegLinetoHorizontalAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoHorizontalRelToIDispatch*(x: ptr ISVGPathSegLinetoHorizontalRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoHorizontalRelToIUnknown*(x: ptr ISVGPathSegLinetoHorizontalRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoVerticalAbsToIDispatch*(x: ptr ISVGPathSegLinetoVerticalAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoVerticalAbsToIUnknown*(x: ptr ISVGPathSegLinetoVerticalAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegLinetoVerticalRelToIDispatch*(x: ptr ISVGPathSegLinetoVerticalRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegLinetoVerticalRelToIUnknown*(x: ptr ISVGPathSegLinetoVerticalRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegArcAbsToIDispatch*(x: ptr DispSVGPathSegArcAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegArcAbsToIUnknown*(x: ptr DispSVGPathSegArcAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegArcRelToIDispatch*(x: ptr DispSVGPathSegArcRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegArcRelToIUnknown*(x: ptr DispSVGPathSegArcRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegClosePathToIDispatch*(x: ptr DispSVGPathSegClosePath): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegClosePathToIUnknown*(x: ptr DispSVGPathSegClosePath): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegMovetoAbsToIDispatch*(x: ptr DispSVGPathSegMovetoAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegMovetoAbsToIUnknown*(x: ptr DispSVGPathSegMovetoAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegMovetoRelToIDispatch*(x: ptr DispSVGPathSegMovetoRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegMovetoRelToIUnknown*(x: ptr DispSVGPathSegMovetoRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoAbsToIDispatch*(x: ptr DispSVGPathSegLinetoAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoAbsToIUnknown*(x: ptr DispSVGPathSegLinetoAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoRelToIDispatch*(x: ptr DispSVGPathSegLinetoRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoRelToIUnknown*(x: ptr DispSVGPathSegLinetoRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoCubicAbsToIDispatch*(x: ptr DispSVGPathSegCurvetoCubicAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoCubicAbsToIUnknown*(x: ptr DispSVGPathSegCurvetoCubicAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoCubicRelToIDispatch*(x: ptr DispSVGPathSegCurvetoCubicRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoCubicRelToIUnknown*(x: ptr DispSVGPathSegCurvetoCubicRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoCubicSmoothAbsToIDispatch*(x: ptr DispSVGPathSegCurvetoCubicSmoothAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoCubicSmoothAbsToIUnknown*(x: ptr DispSVGPathSegCurvetoCubicSmoothAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoCubicSmoothRelToIDispatch*(x: ptr DispSVGPathSegCurvetoCubicSmoothRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoCubicSmoothRelToIUnknown*(x: ptr DispSVGPathSegCurvetoCubicSmoothRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticAbsToIDispatch*(x: ptr DispSVGPathSegCurvetoQuadraticAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticAbsToIUnknown*(x: ptr DispSVGPathSegCurvetoQuadraticAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticRelToIDispatch*(x: ptr DispSVGPathSegCurvetoQuadraticRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticRelToIUnknown*(x: ptr DispSVGPathSegCurvetoQuadraticRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticSmoothAbsToIDispatch*(x: ptr DispSVGPathSegCurvetoQuadraticSmoothAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticSmoothAbsToIUnknown*(x: ptr DispSVGPathSegCurvetoQuadraticSmoothAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticSmoothRelToIDispatch*(x: ptr DispSVGPathSegCurvetoQuadraticSmoothRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegCurvetoQuadraticSmoothRelToIUnknown*(x: ptr DispSVGPathSegCurvetoQuadraticSmoothRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoHorizontalAbsToIDispatch*(x: ptr DispSVGPathSegLinetoHorizontalAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoHorizontalAbsToIUnknown*(x: ptr DispSVGPathSegLinetoHorizontalAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoHorizontalRelToIDispatch*(x: ptr DispSVGPathSegLinetoHorizontalRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoHorizontalRelToIUnknown*(x: ptr DispSVGPathSegLinetoHorizontalRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoVerticalAbsToIDispatch*(x: ptr DispSVGPathSegLinetoVerticalAbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoVerticalAbsToIUnknown*(x: ptr DispSVGPathSegLinetoVerticalAbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathSegLinetoVerticalRelToIDispatch*(x: ptr DispSVGPathSegLinetoVerticalRel): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathSegLinetoVerticalRelToIUnknown*(x: ptr DispSVGPathSegLinetoVerticalRel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathSegListToIDispatch*(x: ptr ISVGPathSegList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathSegListToIUnknown*(x: ptr ISVGPathSegList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPointToIDispatch*(x: ptr ISVGPoint): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPointToIUnknown*(x: ptr ISVGPoint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPointListToIDispatch*(x: ptr ISVGPointList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPointListToIUnknown*(x: ptr ISVGPointList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGRectToIDispatch*(x: ptr ISVGRect): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGRectToIUnknown*(x: ptr ISVGRect): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGStringListToIDispatch*(x: ptr ISVGStringList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGStringListToIUnknown*(x: ptr ISVGStringList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGViewSpecToIDispatch*(x: ptr ISVGViewSpec): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGViewSpecToIUnknown*(x: ptr ISVGViewSpec): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTransformToIDispatch*(x: ptr ISVGTransform): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTransformToIUnknown*(x: ptr ISVGTransform): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGSVGElementToIDispatch*(x: ptr ISVGSVGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGSVGElementToIUnknown*(x: ptr ISVGSVGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGSVGElementToIDispatch*(x: ptr DispSVGSVGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGSVGElementToIUnknown*(x: ptr DispSVGSVGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGUseElementToIDispatch*(x: ptr ISVGUseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGUseElementToIUnknown*(x: ptr ISVGUseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGUseElementToIDispatch*(x: ptr DispSVGUseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGUseElementToIUnknown*(x: ptr DispSVGUseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLStyleSheetRulesAppliedCollectionToIDispatch*(x: ptr IHTMLStyleSheetRulesAppliedCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLStyleSheetRulesAppliedCollectionToIUnknown*(x: ptr IHTMLStyleSheetRulesAppliedCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRulesAppliedToIDispatch*(x: ptr IRulesApplied): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIRulesAppliedToIUnknown*(x: ptr IRulesApplied): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRulesAppliedCollectionToIDispatch*(x: ptr IRulesAppliedCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIRulesAppliedCollectionToIUnknown*(x: ptr IRulesAppliedCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLStyleSheetRulesAppliedCollectionToIDispatch*(x: ptr DispHTMLStyleSheetRulesAppliedCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLStyleSheetRulesAppliedCollectionToIUnknown*(x: ptr DispHTMLStyleSheetRulesAppliedCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispRulesAppliedToIDispatch*(x: ptr DispRulesApplied): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispRulesAppliedToIUnknown*(x: ptr DispRulesApplied): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispRulesAppliedCollectionToIDispatch*(x: ptr DispRulesAppliedCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispRulesAppliedCollectionToIUnknown*(x: ptr DispRulesAppliedCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLW3CComputedStyleToIDispatch*(x: ptr DispHTMLW3CComputedStyle): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLW3CComputedStyleToIUnknown*(x: ptr DispHTMLW3CComputedStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTransformListToIDispatch*(x: ptr ISVGTransformList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTransformListToIUnknown*(x: ptr ISVGTransformList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedPointsToIDispatch*(x: ptr ISVGAnimatedPoints): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedPointsToIUnknown*(x: ptr ISVGAnimatedPoints): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGCircleElementToIDispatch*(x: ptr ISVGCircleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGCircleElementToIUnknown*(x: ptr ISVGCircleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGEllipseElementToIDispatch*(x: ptr ISVGEllipseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGEllipseElementToIUnknown*(x: ptr ISVGEllipseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLineElementToIDispatch*(x: ptr ISVGLineElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLineElementToIUnknown*(x: ptr ISVGLineElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGRectElementToIDispatch*(x: ptr ISVGRectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGRectElementToIUnknown*(x: ptr ISVGRectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPolygonElementToIDispatch*(x: ptr ISVGPolygonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPolygonElementToIUnknown*(x: ptr ISVGPolygonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPolylineElementToIDispatch*(x: ptr ISVGPolylineElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPolylineElementToIUnknown*(x: ptr ISVGPolylineElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGCircleElementToIDispatch*(x: ptr DispSVGCircleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGCircleElementToIUnknown*(x: ptr DispSVGCircleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGEllipseElementToIDispatch*(x: ptr DispSVGEllipseElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGEllipseElementToIUnknown*(x: ptr DispSVGEllipseElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGLineElementToIDispatch*(x: ptr DispSVGLineElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGLineElementToIUnknown*(x: ptr DispSVGLineElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGRectElementToIDispatch*(x: ptr DispSVGRectElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGRectElementToIUnknown*(x: ptr DispSVGRectElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPolygonElementToIDispatch*(x: ptr DispSVGPolygonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPolygonElementToIUnknown*(x: ptr DispSVGPolygonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPolylineElementToIDispatch*(x: ptr DispSVGPolylineElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPolylineElementToIUnknown*(x: ptr DispSVGPolylineElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGGElementToIDispatch*(x: ptr ISVGGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGGElementToIUnknown*(x: ptr ISVGGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGGElementToIDispatch*(x: ptr DispSVGGElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGGElementToIUnknown*(x: ptr DispSVGGElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGSymbolElementToIDispatch*(x: ptr ISVGSymbolElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGSymbolElementToIUnknown*(x: ptr ISVGSymbolElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGSymbolElementToIDispatch*(x: ptr DispSVGSymbolElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGSymbolElementToIUnknown*(x: ptr DispSVGSymbolElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGDefsElementToIDispatch*(x: ptr ISVGDefsElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGDefsElementToIUnknown*(x: ptr ISVGDefsElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGDefsElementToIDispatch*(x: ptr DispSVGDefsElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGDefsElementToIUnknown*(x: ptr DispSVGDefsElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedPathDataToIDispatch*(x: ptr ISVGAnimatedPathData): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedPathDataToIUnknown*(x: ptr ISVGAnimatedPathData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPathElementToIDispatch*(x: ptr ISVGPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPathElementToIUnknown*(x: ptr ISVGPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGPathElementToIDispatch*(x: ptr DispSVGPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGPathElementToIUnknown*(x: ptr DispSVGPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGPreserveAspectRatioToIDispatch*(x: ptr ISVGPreserveAspectRatio): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGPreserveAspectRatioToIUnknown*(x: ptr ISVGPreserveAspectRatio): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTextElementToIDispatch*(x: ptr ISVGTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTextElementToIUnknown*(x: ptr ISVGTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTextElementToIDispatch*(x: ptr DispSVGTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTextElementToIUnknown*(x: ptr DispSVGTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAnimatedPreserveAspectRatioToIDispatch*(x: ptr ISVGAnimatedPreserveAspectRatio): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAnimatedPreserveAspectRatioToIUnknown*(x: ptr ISVGAnimatedPreserveAspectRatio): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGImageElementToIDispatch*(x: ptr ISVGImageElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGImageElementToIUnknown*(x: ptr ISVGImageElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGImageElementToIDispatch*(x: ptr DispSVGImageElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGImageElementToIUnknown*(x: ptr DispSVGImageElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGStopElementToIDispatch*(x: ptr ISVGStopElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGStopElementToIUnknown*(x: ptr ISVGStopElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGStopElementToIDispatch*(x: ptr DispSVGStopElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGStopElementToIUnknown*(x: ptr DispSVGStopElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGGradientElementToIDispatch*(x: ptr ISVGGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGGradientElementToIUnknown*(x: ptr ISVGGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGGradientElementToIDispatch*(x: ptr DispSVGGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGGradientElementToIUnknown*(x: ptr DispSVGGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGLinearGradientElementToIDispatch*(x: ptr ISVGLinearGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGLinearGradientElementToIUnknown*(x: ptr ISVGLinearGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGLinearGradientElementToIDispatch*(x: ptr DispSVGLinearGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGLinearGradientElementToIUnknown*(x: ptr DispSVGLinearGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGRadialGradientElementToIDispatch*(x: ptr ISVGRadialGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGRadialGradientElementToIUnknown*(x: ptr ISVGRadialGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGRadialGradientElementToIDispatch*(x: ptr DispSVGRadialGradientElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGRadialGradientElementToIUnknown*(x: ptr DispSVGRadialGradientElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGMaskElementToIDispatch*(x: ptr ISVGMaskElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGMaskElementToIUnknown*(x: ptr ISVGMaskElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGMaskElementToIDispatch*(x: ptr DispSVGMaskElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGMaskElementToIUnknown*(x: ptr DispSVGMaskElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGMarkerElementToIDispatch*(x: ptr ISVGMarkerElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGMarkerElementToIUnknown*(x: ptr ISVGMarkerElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGMarkerElementToIDispatch*(x: ptr DispSVGMarkerElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGMarkerElementToIUnknown*(x: ptr DispSVGMarkerElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGZoomEventToIDispatch*(x: ptr ISVGZoomEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGZoomEventToIUnknown*(x: ptr ISVGZoomEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGZoomEventToIDispatch*(x: ptr DispSVGZoomEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGZoomEventToIUnknown*(x: ptr DispSVGZoomEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGAElementToIDispatch*(x: ptr ISVGAElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGAElementToIUnknown*(x: ptr ISVGAElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGAElementToIDispatch*(x: ptr DispSVGAElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGAElementToIUnknown*(x: ptr DispSVGAElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGViewElementToIDispatch*(x: ptr ISVGViewElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGViewElementToIUnknown*(x: ptr ISVGViewElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGViewElementToIDispatch*(x: ptr DispSVGViewElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGViewElementToIUnknown*(x: ptr DispSVGViewElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMediaErrorToIDispatch*(x: ptr IHTMLMediaError): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMediaErrorToIUnknown*(x: ptr IHTMLMediaError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTimeRangesToIDispatch*(x: ptr IHTMLTimeRanges): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTimeRangesToIUnknown*(x: ptr IHTMLTimeRanges): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLTimeRanges2ToIDispatch*(x: ptr IHTMLTimeRanges2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLTimeRanges2ToIUnknown*(x: ptr IHTMLTimeRanges2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMediaElementToIDispatch*(x: ptr IHTMLMediaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMediaElementToIUnknown*(x: ptr IHTMLMediaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMediaElement2ToIDispatch*(x: ptr IHTMLMediaElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMediaElement2ToIUnknown*(x: ptr IHTMLMediaElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLMSMediaElementToIDispatch*(x: ptr IHTMLMSMediaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLMSMediaElementToIUnknown*(x: ptr IHTMLMSMediaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLSourceElementToIDispatch*(x: ptr IHTMLSourceElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLSourceElementToIUnknown*(x: ptr IHTMLSourceElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAudioElementToIDispatch*(x: ptr IHTMLAudioElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAudioElementToIUnknown*(x: ptr IHTMLAudioElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLVideoElementToIDispatch*(x: ptr IHTMLVideoElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLVideoElementToIUnknown*(x: ptr IHTMLVideoElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAudioElementFactoryToIDispatch*(x: ptr IHTMLAudioElementFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAudioElementFactoryToIUnknown*(x: ptr IHTMLAudioElementFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMediaErrorToIDispatch*(x: ptr DispHTMLMediaError): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMediaErrorToIUnknown*(x: ptr DispHTMLMediaError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLTimeRangesToIDispatch*(x: ptr DispHTMLTimeRanges): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLTimeRangesToIUnknown*(x: ptr DispHTMLTimeRanges): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLMediaElementToIDispatch*(x: ptr DispHTMLMediaElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLMediaElementToIUnknown*(x: ptr DispHTMLMediaElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLSourceElementToIDispatch*(x: ptr DispHTMLSourceElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLSourceElementToIUnknown*(x: ptr DispHTMLSourceElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAudioElementToIDispatch*(x: ptr DispHTMLAudioElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAudioElementToIUnknown*(x: ptr DispHTMLAudioElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLVideoElementToIDispatch*(x: ptr DispHTMLVideoElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLVideoElementToIUnknown*(x: ptr DispHTMLVideoElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGSwitchElementToIDispatch*(x: ptr ISVGSwitchElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGSwitchElementToIUnknown*(x: ptr ISVGSwitchElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGSwitchElementToIDispatch*(x: ptr DispSVGSwitchElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGSwitchElementToIUnknown*(x: ptr DispSVGSwitchElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGDescElementToIDispatch*(x: ptr ISVGDescElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGDescElementToIUnknown*(x: ptr ISVGDescElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGDescElementToIDispatch*(x: ptr DispSVGDescElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGDescElementToIUnknown*(x: ptr DispSVGDescElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTitleElementToIDispatch*(x: ptr ISVGTitleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTitleElementToIUnknown*(x: ptr ISVGTitleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTitleElementToIDispatch*(x: ptr DispSVGTitleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTitleElementToIUnknown*(x: ptr DispSVGTitleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGMetadataElementToIDispatch*(x: ptr ISVGMetadataElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGMetadataElementToIUnknown*(x: ptr ISVGMetadataElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGMetadataElementToIDispatch*(x: ptr DispSVGMetadataElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGMetadataElementToIUnknown*(x: ptr DispSVGMetadataElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGElementInstanceToIDispatch*(x: ptr ISVGElementInstance): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGElementInstanceToIUnknown*(x: ptr ISVGElementInstance): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGElementInstanceToIDispatch*(x: ptr DispSVGElementInstance): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGElementInstanceToIUnknown*(x: ptr DispSVGElementInstance): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGElementInstanceListToIDispatch*(x: ptr ISVGElementInstanceList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGElementInstanceListToIUnknown*(x: ptr ISVGElementInstanceList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGElementInstanceListToIDispatch*(x: ptr DispSVGElementInstanceList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGElementInstanceListToIUnknown*(x: ptr DispSVGElementInstanceList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMExceptionToIDispatch*(x: ptr IDOMException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMExceptionToIUnknown*(x: ptr IDOMException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRangeExceptionToIDispatch*(x: ptr IRangeException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIRangeExceptionToIUnknown*(x: ptr IRangeException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGExceptionToIDispatch*(x: ptr ISVGException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGExceptionToIUnknown*(x: ptr ISVGException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEventExceptionToIDispatch*(x: ptr IEventException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIEventExceptionToIUnknown*(x: ptr IEventException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMExceptionToIDispatch*(x: ptr DispDOMException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMExceptionToIUnknown*(x: ptr DispDOMException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispRangeExceptionToIDispatch*(x: ptr DispRangeException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispRangeExceptionToIUnknown*(x: ptr DispRangeException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGExceptionToIDispatch*(x: ptr DispSVGException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGExceptionToIUnknown*(x: ptr DispSVGException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispEventExceptionToIDispatch*(x: ptr DispEventException): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispEventExceptionToIUnknown*(x: ptr DispEventException): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGScriptElementToIDispatch*(x: ptr ISVGScriptElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGScriptElementToIUnknown*(x: ptr ISVGScriptElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGScriptElementToIDispatch*(x: ptr DispSVGScriptElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGScriptElementToIUnknown*(x: ptr DispSVGScriptElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGStyleElementToIDispatch*(x: ptr ISVGStyleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGStyleElementToIUnknown*(x: ptr ISVGStyleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGStyleElementToIDispatch*(x: ptr DispSVGStyleElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGStyleElementToIUnknown*(x: ptr DispSVGStyleElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTextContentElementToIDispatch*(x: ptr ISVGTextContentElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTextContentElementToIUnknown*(x: ptr ISVGTextContentElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTextContentElementToIDispatch*(x: ptr DispSVGTextContentElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTextContentElementToIUnknown*(x: ptr DispSVGTextContentElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTextPositioningElementToIDispatch*(x: ptr ISVGTextPositioningElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTextPositioningElementToIUnknown*(x: ptr ISVGTextPositioningElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTextPositioningElementToIDispatch*(x: ptr DispSVGTextPositioningElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTextPositioningElementToIUnknown*(x: ptr DispSVGTextPositioningElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMDocumentTypeToIDispatch*(x: ptr IDOMDocumentType): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMDocumentTypeToIUnknown*(x: ptr IDOMDocumentType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMDocumentTypeToIDispatch*(x: ptr DispDOMDocumentType): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMDocumentTypeToIUnknown*(x: ptr DispDOMDocumentType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMNodeIteratorToIDispatch*(x: ptr IDOMNodeIterator): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMNodeIteratorToIUnknown*(x: ptr IDOMNodeIterator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMTreeWalkerToIDispatch*(x: ptr IDOMTreeWalker): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMTreeWalkerToIUnknown*(x: ptr IDOMTreeWalker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispNodeIteratorToIDispatch*(x: ptr DispNodeIterator): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispNodeIteratorToIUnknown*(x: ptr DispNodeIterator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispTreeWalkerToIDispatch*(x: ptr DispTreeWalker): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispTreeWalkerToIUnknown*(x: ptr DispTreeWalker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMProcessingInstructionToIDispatch*(x: ptr IDOMProcessingInstruction): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMProcessingInstructionToIUnknown*(x: ptr IDOMProcessingInstruction): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMProcessingInstructionToIDispatch*(x: ptr DispDOMProcessingInstruction): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMProcessingInstructionToIUnknown*(x: ptr DispDOMProcessingInstruction): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPerformanceToIDispatch*(x: ptr IHTMLPerformance): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPerformanceToIUnknown*(x: ptr IHTMLPerformance): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPerformanceNavigationToIDispatch*(x: ptr IHTMLPerformanceNavigation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPerformanceNavigationToIUnknown*(x: ptr IHTMLPerformanceNavigation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPerformanceTimingToIDispatch*(x: ptr IHTMLPerformanceTiming): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPerformanceTimingToIUnknown*(x: ptr IHTMLPerformanceTiming): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLPerformanceToIDispatch*(x: ptr DispHTMLPerformance): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLPerformanceToIUnknown*(x: ptr DispHTMLPerformance): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLPerformanceNavigationToIDispatch*(x: ptr DispHTMLPerformanceNavigation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLPerformanceNavigationToIUnknown*(x: ptr DispHTMLPerformanceNavigation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLPerformanceTimingToIDispatch*(x: ptr DispHTMLPerformanceTiming): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLPerformanceTimingToIUnknown*(x: ptr DispHTMLPerformanceTiming): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTSpanElementToIDispatch*(x: ptr ISVGTSpanElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTSpanElementToIUnknown*(x: ptr ISVGTSpanElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTSpanElementToIDispatch*(x: ptr DispSVGTSpanElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTSpanElementToIUnknown*(x: ptr DispSVGTSpanElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITemplatePrinterToIDispatch*(x: ptr ITemplatePrinter): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterITemplatePrinterToIUnknown*(x: ptr ITemplatePrinter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITemplatePrinter2ToITemplatePrinter*(x: ptr ITemplatePrinter2): ptr ITemplatePrinter = cast[ptr ITemplatePrinter](x) +converter winimConverterITemplatePrinter2ToIDispatch*(x: ptr ITemplatePrinter2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterITemplatePrinter2ToIUnknown*(x: ptr ITemplatePrinter2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITemplatePrinter3ToITemplatePrinter2*(x: ptr ITemplatePrinter3): ptr ITemplatePrinter2 = cast[ptr ITemplatePrinter2](x) +converter winimConverterITemplatePrinter3ToITemplatePrinter*(x: ptr ITemplatePrinter3): ptr ITemplatePrinter = cast[ptr ITemplatePrinter](x) +converter winimConverterITemplatePrinter3ToIDispatch*(x: ptr ITemplatePrinter3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterITemplatePrinter3ToIUnknown*(x: ptr ITemplatePrinter3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPrintManagerTemplatePrinterToIDispatch*(x: ptr IPrintManagerTemplatePrinter): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIPrintManagerTemplatePrinterToIUnknown*(x: ptr IPrintManagerTemplatePrinter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispCPrintManagerTemplatePrinterToIDispatch*(x: ptr DispCPrintManagerTemplatePrinter): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispCPrintManagerTemplatePrinterToIUnknown*(x: ptr DispCPrintManagerTemplatePrinter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISVGTextPathElementToIDispatch*(x: ptr ISVGTextPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISVGTextPathElementToIUnknown*(x: ptr ISVGTextPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispSVGTextPathElementToIDispatch*(x: ptr DispSVGTextPathElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispSVGTextPathElementToIUnknown*(x: ptr DispSVGTextPathElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMXmlSerializerToIDispatch*(x: ptr IDOMXmlSerializer): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMXmlSerializerToIUnknown*(x: ptr IDOMXmlSerializer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMXmlSerializerFactoryToIDispatch*(x: ptr IDOMXmlSerializerFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMXmlSerializerFactoryToIUnknown*(x: ptr IDOMXmlSerializerFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMParserToIDispatch*(x: ptr IDOMParser): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMParserToIUnknown*(x: ptr IDOMParser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMParserFactoryToIDispatch*(x: ptr IDOMParserFactory): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMParserFactoryToIUnknown*(x: ptr IDOMParserFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispXMLSerializerToIDispatch*(x: ptr DispXMLSerializer): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispXMLSerializerToIUnknown*(x: ptr DispXMLSerializer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMParserToIDispatch*(x: ptr DispDOMParser): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMParserToIUnknown*(x: ptr DispDOMParser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLSemanticElementToIDispatch*(x: ptr DispHTMLSemanticElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLSemanticElementToIUnknown*(x: ptr DispHTMLSemanticElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLProgressElementToIDispatch*(x: ptr IHTMLProgressElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLProgressElementToIUnknown*(x: ptr IHTMLProgressElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLProgressElementToIDispatch*(x: ptr DispHTMLProgressElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLProgressElementToIUnknown*(x: ptr DispHTMLProgressElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMSTransitionEventToIDispatch*(x: ptr IDOMMSTransitionEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMSTransitionEventToIUnknown*(x: ptr IDOMMSTransitionEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMSTransitionEventToIDispatch*(x: ptr DispDOMMSTransitionEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMSTransitionEventToIUnknown*(x: ptr DispDOMMSTransitionEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMSAnimationEventToIDispatch*(x: ptr IDOMMSAnimationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMSAnimationEventToIUnknown*(x: ptr IDOMMSAnimationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMSAnimationEventToIDispatch*(x: ptr DispDOMMSAnimationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMSAnimationEventToIUnknown*(x: ptr DispDOMMSAnimationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebGeolocationToIDispatch*(x: ptr IWebGeolocation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebGeolocationToIUnknown*(x: ptr IWebGeolocation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebGeocoordinatesToIDispatch*(x: ptr IWebGeocoordinates): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebGeocoordinatesToIUnknown*(x: ptr IWebGeocoordinates): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebGeopositionErrorToIDispatch*(x: ptr IWebGeopositionError): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebGeopositionErrorToIUnknown*(x: ptr IWebGeopositionError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebGeopositionToIDispatch*(x: ptr IWebGeoposition): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebGeopositionToIUnknown*(x: ptr IWebGeoposition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispWebGeolocationToIDispatch*(x: ptr DispWebGeolocation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispWebGeolocationToIUnknown*(x: ptr DispWebGeolocation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispWebGeocoordinatesToIDispatch*(x: ptr DispWebGeocoordinates): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispWebGeocoordinatesToIUnknown*(x: ptr DispWebGeocoordinates): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispWebGeopositionErrorToIDispatch*(x: ptr DispWebGeopositionError): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispWebGeopositionErrorToIUnknown*(x: ptr DispWebGeopositionError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispWebGeopositionToIDispatch*(x: ptr DispWebGeoposition): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispWebGeopositionToIUnknown*(x: ptr DispWebGeoposition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClientCapsToIDispatch*(x: ptr IClientCaps): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIClientCapsToIUnknown*(x: ptr IClientCaps): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMMSManipulationEventToIDispatch*(x: ptr IDOMMSManipulationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMMSManipulationEventToIUnknown*(x: ptr IDOMMSManipulationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMMSManipulationEventToIDispatch*(x: ptr DispDOMMSManipulationEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMMSManipulationEventToIUnknown*(x: ptr DispDOMMSManipulationEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMCloseEventToIDispatch*(x: ptr IDOMCloseEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIDOMCloseEventToIUnknown*(x: ptr IDOMCloseEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispDOMCloseEventToIDispatch*(x: ptr DispDOMCloseEvent): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispDOMCloseEventToIUnknown*(x: ptr DispDOMCloseEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLApplicationCacheToIDispatch*(x: ptr IHTMLApplicationCache): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLApplicationCacheToIUnknown*(x: ptr IHTMLApplicationCache): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispApplicationCacheToIDispatch*(x: ptr DispApplicationCache): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispApplicationCacheToIUnknown*(x: ptr DispApplicationCache): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICSSFilterSiteToIUnknown*(x: ptr ICSSFilterSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICSSFilterToIUnknown*(x: ptr ICSSFilter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISecureUrlHostToIUnknown*(x: ptr ISecureUrlHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupServicesToIUnknown*(x: ptr IMarkupServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupServices2ToIMarkupServices*(x: ptr IMarkupServices2): ptr IMarkupServices = cast[ptr IMarkupServices](x) +converter winimConverterIMarkupServices2ToIUnknown*(x: ptr IMarkupServices2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupContainerToIUnknown*(x: ptr IMarkupContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupContainer2ToIMarkupContainer*(x: ptr IMarkupContainer2): ptr IMarkupContainer = cast[ptr IMarkupContainer](x) +converter winimConverterIMarkupContainer2ToIUnknown*(x: ptr IMarkupContainer2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLChangePlaybackToIUnknown*(x: ptr IHTMLChangePlayback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupPointerToIUnknown*(x: ptr IMarkupPointer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupPointer2ToIMarkupPointer*(x: ptr IMarkupPointer2): ptr IMarkupPointer = cast[ptr IMarkupPointer](x) +converter winimConverterIMarkupPointer2ToIUnknown*(x: ptr IMarkupPointer2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarkupTextFragsToIUnknown*(x: ptr IMarkupTextFrags): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLChangeLogToIUnknown*(x: ptr IHTMLChangeLog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLChangeSinkToIUnknown*(x: ptr IHTMLChangeSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLGenericParseToIUnknown*(x: ptr IXMLGenericParse): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEditHostToIUnknown*(x: ptr IHTMLEditHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEditHost2ToIHTMLEditHost*(x: ptr IHTMLEditHost2): ptr IHTMLEditHost = cast[ptr IHTMLEditHost](x) +converter winimConverterIHTMLEditHost2ToIUnknown*(x: ptr IHTMLEditHost2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISegmentToIUnknown*(x: ptr ISegment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISegmentListIteratorToIUnknown*(x: ptr ISegmentListIterator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISegmentListToIUnknown*(x: ptr ISegmentList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISequenceNumberToIUnknown*(x: ptr ISequenceNumber): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIIMEServicesToIUnknown*(x: ptr IIMEServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLCaretToIUnknown*(x: ptr IHTMLCaret): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHighlightRenderingServicesToIUnknown*(x: ptr IHighlightRenderingServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISelectionServicesListenerToIUnknown*(x: ptr ISelectionServicesListener): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISelectionServicesToIUnknown*(x: ptr ISelectionServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementSegmentToISegment*(x: ptr IElementSegment): ptr ISegment = cast[ptr ISegment](x) +converter winimConverterIElementSegmentToIUnknown*(x: ptr IElementSegment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHighlightSegmentToISegment*(x: ptr IHighlightSegment): ptr ISegment = cast[ptr ISegment](x) +converter winimConverterIHighlightSegmentToIUnknown*(x: ptr IHighlightSegment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEditDesignerToIUnknown*(x: ptr IHTMLEditDesigner): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEditServicesToIUnknown*(x: ptr IHTMLEditServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLEditServices2ToIHTMLEditServices*(x: ptr IHTMLEditServices2): ptr IHTMLEditServices = cast[ptr IHTMLEditServices](x) +converter winimConverterIHTMLEditServices2ToIUnknown*(x: ptr IHTMLEditServices2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterILineInfoToIUnknown*(x: ptr ILineInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLComputedStyleToIUnknown*(x: ptr IHTMLComputedStyle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDisplayPointerToIUnknown*(x: ptr IDisplayPointer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDisplayServicesToIUnknown*(x: ptr IDisplayServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHtmlDlgSafeHelperToIDispatch*(x: ptr IHtmlDlgSafeHelper): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHtmlDlgSafeHelperToIUnknown*(x: ptr IHtmlDlgSafeHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBlockFormatsToIDispatch*(x: ptr IBlockFormats): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIBlockFormatsToIUnknown*(x: ptr IBlockFormats): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFontNamesToIDispatch*(x: ptr IFontNames): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIFontNamesToIUnknown*(x: ptr IFontNames): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeveloperConsoleMessageReceiverToIUnknown*(x: ptr IDeveloperConsoleMessageReceiver): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDebugCallbackNotificationHandlerToIUnknown*(x: ptr IDebugCallbackNotificationHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIScriptEventHandlerToIUnknown*(x: ptr IScriptEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIScriptEventHandlerSourceInfoToIUnknown*(x: ptr IScriptEventHandlerSourceInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDOMEventRegistrationCallbackToIUnknown*(x: ptr IDOMEventRegistrationCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEventTarget2ToIUnknown*(x: ptr IEventTarget2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterHTMLNamespaceEventsToIDispatch*(x: ptr HTMLNamespaceEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterHTMLNamespaceEventsToIUnknown*(x: ptr HTMLNamespaceEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLNamespaceToIDispatch*(x: ptr IHTMLNamespace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLNamespaceToIUnknown*(x: ptr IHTMLNamespace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLNamespaceCollectionToIDispatch*(x: ptr IHTMLNamespaceCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLNamespaceCollectionToIUnknown*(x: ptr IHTMLNamespaceCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLNamespaceToIDispatch*(x: ptr DispHTMLNamespace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLNamespaceToIUnknown*(x: ptr DispHTMLNamespace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLNamespaceCollectionToIDispatch*(x: ptr DispHTMLNamespaceCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLNamespaceCollectionToIUnknown*(x: ptr DispHTMLNamespaceCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPainterToIUnknown*(x: ptr IHTMLPainter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPainterEventInfoToIUnknown*(x: ptr IHTMLPainterEventInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPainterOverlayToIUnknown*(x: ptr IHTMLPainterOverlay): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPaintSiteToIUnknown*(x: ptr IHTMLPaintSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLIPrintCollectionToIDispatch*(x: ptr IHTMLIPrintCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLIPrintCollectionToIUnknown*(x: ptr IHTMLIPrintCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumPrivacyRecordsToIUnknown*(x: ptr IEnumPrivacyRecords): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWPCBlockedUrlsToIUnknown*(x: ptr IWPCBlockedUrls): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDOMConstructorCollectionToIDispatch*(x: ptr IHTMLDOMConstructorCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDOMConstructorCollectionToIUnknown*(x: ptr IHTMLDOMConstructorCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDialogToIDispatch*(x: ptr IHTMLDialog): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDialogToIUnknown*(x: ptr IHTMLDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDialog2ToIDispatch*(x: ptr IHTMLDialog2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDialog2ToIUnknown*(x: ptr IHTMLDialog2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLDialog3ToIDispatch*(x: ptr IHTMLDialog3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLDialog3ToIUnknown*(x: ptr IHTMLDialog3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLModelessInitToIDispatch*(x: ptr IHTMLModelessInit): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLModelessInitToIUnknown*(x: ptr IHTMLModelessInit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLPopupToIDispatch*(x: ptr IHTMLPopup): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLPopupToIUnknown*(x: ptr IHTMLPopup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLPopupToIDispatch*(x: ptr DispHTMLPopup): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLPopupToIUnknown*(x: ptr DispHTMLPopup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAppBehaviorToIDispatch*(x: ptr IHTMLAppBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAppBehaviorToIUnknown*(x: ptr IHTMLAppBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAppBehavior2ToIDispatch*(x: ptr IHTMLAppBehavior2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAppBehavior2ToIUnknown*(x: ptr IHTMLAppBehavior2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLAppBehavior3ToIDispatch*(x: ptr IHTMLAppBehavior3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIHTMLAppBehavior3ToIUnknown*(x: ptr IHTMLAppBehavior3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispHTMLAppBehaviorToIDispatch*(x: ptr DispHTMLAppBehavior): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispHTMLAppBehaviorToIUnknown*(x: ptr DispHTMLAppBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispIHTMLInputButtonElementToIDispatch*(x: ptr DispIHTMLInputButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispIHTMLInputButtonElementToIUnknown*(x: ptr DispIHTMLInputButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispIHTMLInputTextElementToIDispatch*(x: ptr DispIHTMLInputTextElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispIHTMLInputTextElementToIUnknown*(x: ptr DispIHTMLInputTextElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispIHTMLInputFileElementToIDispatch*(x: ptr DispIHTMLInputFileElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispIHTMLInputFileElementToIUnknown*(x: ptr DispIHTMLInputFileElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispIHTMLOptionButtonElementToIDispatch*(x: ptr DispIHTMLOptionButtonElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispIHTMLOptionButtonElementToIUnknown*(x: ptr DispIHTMLOptionButtonElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDispIHTMLInputImageToIDispatch*(x: ptr DispIHTMLInputImage): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDispIHTMLInputImageToIUnknown*(x: ptr DispIHTMLInputImage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorFactoryToIUnknown*(x: ptr IElementBehaviorFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementNamespaceToIUnknown*(x: ptr IElementNamespace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementNamespaceTableToIUnknown*(x: ptr IElementNamespaceTable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementNamespaceFactoryToIUnknown*(x: ptr IElementNamespaceFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementNamespaceFactory2ToIElementNamespaceFactory*(x: ptr IElementNamespaceFactory2): ptr IElementNamespaceFactory = cast[ptr IElementNamespaceFactory](x) +converter winimConverterIElementNamespaceFactory2ToIUnknown*(x: ptr IElementNamespaceFactory2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementNamespaceFactoryCallbackToIUnknown*(x: ptr IElementNamespaceFactoryCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorToIUnknown*(x: ptr IElementBehavior): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteToIUnknown*(x: ptr IElementBehaviorSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteOMToIUnknown*(x: ptr IElementBehaviorSiteOM): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteOM2ToIElementBehaviorSiteOM*(x: ptr IElementBehaviorSiteOM2): ptr IElementBehaviorSiteOM = cast[ptr IElementBehaviorSiteOM](x) +converter winimConverterIElementBehaviorSiteOM2ToIUnknown*(x: ptr IElementBehaviorSiteOM2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorRenderToIUnknown*(x: ptr IElementBehaviorRender): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteRenderToIUnknown*(x: ptr IElementBehaviorSiteRender): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorCategoryToIUnknown*(x: ptr IElementBehaviorCategory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteCategoryToIUnknown*(x: ptr IElementBehaviorSiteCategory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSubmitToIUnknown*(x: ptr IElementBehaviorSubmit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorFocusToIUnknown*(x: ptr IElementBehaviorFocus): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorLayoutToIUnknown*(x: ptr IElementBehaviorLayout): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorLayout2ToIUnknown*(x: ptr IElementBehaviorLayout2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteLayoutToIUnknown*(x: ptr IElementBehaviorSiteLayout): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIElementBehaviorSiteLayout2ToIUnknown*(x: ptr IElementBehaviorSiteLayout2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostBehaviorInitToIUnknown*(x: ptr IHostBehaviorInit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectPresentSiteToIUnknown*(x: ptr IViewObjectPresentSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISurfacePresenterToIUnknown*(x: ptr ISurfacePresenter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICanvasPixelArrayDataToIUnknown*(x: ptr ICanvasPixelArrayData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectPrintToIUnknown*(x: ptr IViewObjectPrint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectPresentNotifySiteToIViewObjectPresentSite*(x: ptr IViewObjectPresentNotifySite): ptr IViewObjectPresentSite = cast[ptr IViewObjectPresentSite](x) +converter winimConverterIViewObjectPresentNotifySiteToIUnknown*(x: ptr IViewObjectPresentNotifySite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectPresentNotifyToIUnknown*(x: ptr IViewObjectPresentNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITrackingProtectionToIUnknown*(x: ptr ITrackingProtection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHostDialogHelperToIUnknown*(x: ptr IHostDialogHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocHostUIHandlerToIUnknown*(x: ptr IDocHostUIHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocHostUIHandler2ToIDocHostUIHandler*(x: ptr IDocHostUIHandler2): ptr IDocHostUIHandler = cast[ptr IDocHostUIHandler](x) +converter winimConverterIDocHostUIHandler2ToIUnknown*(x: ptr IDocHostUIHandler2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICustomDocToIUnknown*(x: ptr ICustomDoc): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocHostShowUIToIUnknown*(x: ptr IDocHostShowUI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClassFactoryExToIClassFactory*(x: ptr IClassFactoryEx): ptr IClassFactory = cast[ptr IClassFactory](x) +converter winimConverterIClassFactoryExToIUnknown*(x: ptr IClassFactoryEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHTMLOMWindowServicesToIUnknown*(x: ptr IHTMLOMWindowServices): ptr IUnknown = cast[ptr IUnknown](x) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/msi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/msi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,579 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wincrypt +#include +type + MSIHANDLE* = int32 + INSTALLMESSAGE* = int32 + INSTALLUILEVEL* = int32 + INSTALLSTATE* = int32 + USERINFOSTATE* = int32 + INSTALLLEVEL* = int32 + REINSTALLMODE* = int32 + INSTALLLOGMODE* = int32 + INSTALLLOGATTRIBUTES* = int32 + INSTALLFEATUREATTRIBUTE* = int32 + INSTALLMODE* = int32 + MSIPATCHSTATE* = int32 + MSIINSTALLCONTEXT* = int32 + MSIPATCHDATATYPE* = int32 + PMSIPATCHDATATYPE* = ptr int32 + SCRIPTFLAGS* = int32 + ADVERTISEFLAGS* = int32 + INSTALLTYPE* = int32 + MSIARCHITECTUREFLAGS* = int32 + MSIOPENPACKAGEFLAGS* = int32 + MSIADVERTISEOPTIONFLAGS* = int32 + MSISOURCETYPE* = int32 + MSICODE* = int32 + MSITRANSACTION* = int32 + MSITRANSACTIONSTATE* = int32 + INSTALLUI_HANDLER_RECORD* = proc (pvContext: LPVOID, iMessageType: UINT, hRecord: MSIHANDLE): int32 {.stdcall.} + PINSTALLUI_HANDLER_RECORD* = ptr INSTALLUI_HANDLER_RECORD + MSIPATCHSEQUENCEINFOA* {.pure.} = object + szPatchData*: LPCSTR + ePatchDataType*: MSIPATCHDATATYPE + dwOrder*: DWORD + uStatus*: UINT + PMSIPATCHSEQUENCEINFOA* = ptr MSIPATCHSEQUENCEINFOA + MSIPATCHSEQUENCEINFOW* {.pure.} = object + szPatchData*: LPCWSTR + ePatchDataType*: MSIPATCHDATATYPE + dwOrder*: DWORD + uStatus*: UINT + PMSIPATCHSEQUENCEINFOW* = ptr MSIPATCHSEQUENCEINFOW + MSIFILEHASHINFO* {.pure.} = object + dwFileHashInfoSize*: ULONG + dwData*: array[4, ULONG] + PMSIFILEHASHINFO* = ptr MSIFILEHASHINFO +const + NTDDI_WIN2K* = 0x05000000 + NTDDI_WINXP* = 0x05010000 + NTDDI_WINXPSP2* = 0x05010200 + NTDDI_WS03SP1* = 0x05020100 + NTDDI_VISTA* = 0x06000000 + NTDDI_VISTASP1* = 0x06000100 + MAX_GUID_CHARS* = 38 + INSTALLMESSAGE_FATALEXIT* = 0x00000000 + INSTALLMESSAGE_ERROR* = 0x01000000 + INSTALLMESSAGE_WARNING* = 0x02000000 + INSTALLMESSAGE_USER* = 0x03000000 + INSTALLMESSAGE_INFO* = 0x04000000 + INSTALLMESSAGE_FILESINUSE* = 0x05000000 + INSTALLMESSAGE_RESOLVESOURCE* = 0x06000000 + INSTALLMESSAGE_OUTOFDISKSPACE* = 0x07000000 + INSTALLMESSAGE_ACTIONSTART* = 0x08000000 + INSTALLMESSAGE_ACTIONDATA* = 0x09000000 + INSTALLMESSAGE_PROGRESS* = 0x0A000000 + INSTALLMESSAGE_COMMONDATA* = 0x0B000000 + INSTALLMESSAGE_INITIALIZE* = 0x0C000000 + INSTALLMESSAGE_TERMINATE* = 0x0D000000 + INSTALLMESSAGE_SHOWDIALOG* = 0x0E000000 + INSTALLMESSAGE_RMFILESINUSE* = 0x19000000 + INSTALLMESSAGE_INSTALLSTART* = 0x1A000000 + INSTALLMESSAGE_INSTALLEND* = 0x1B000000 + INSTALLUILEVEL_NOCHANGE* = 0 + INSTALLUILEVEL_DEFAULT* = 1 + INSTALLUILEVEL_NONE* = 2 + INSTALLUILEVEL_BASIC* = 3 + INSTALLUILEVEL_REDUCED* = 4 + INSTALLUILEVEL_FULL* = 5 + INSTALLUILEVEL_ENDDIALOG* = 0x80 + INSTALLUILEVEL_PROGRESSONLY* = 0x40 + INSTALLUILEVEL_HIDECANCEL* = 0x20 + INSTALLUILEVEL_SOURCERESONLY* = 0x100 + INSTALLSTATE_NOTUSED* = -7 + INSTALLSTATE_BADCONFIG* = -6 + INSTALLSTATE_INCOMPLETE* = -5 + INSTALLSTATE_SOURCEABSENT* = -4 + INSTALLSTATE_MOREDATA* = -3 + INSTALLSTATE_INVALIDARG* = -2 + INSTALLSTATE_UNKNOWN* = -1 + INSTALLSTATE_BROKEN* = 0 + INSTALLSTATE_ADVERTISED* = 1 + INSTALLSTATE_REMOVED* = 1 + INSTALLSTATE_ABSENT* = 2 + INSTALLSTATE_LOCAL* = 3 + INSTALLSTATE_SOURCE* = 4 + INSTALLSTATE_DEFAULT* = 5 + USERINFOSTATE_MOREDATA* = -3 + USERINFOSTATE_INVALIDARG* = -2 + USERINFOSTATE_UNKNOWN* = -1 + USERINFOSTATE_ABSENT* = 0 + USERINFOSTATE_PRESENT* = 1 + INSTALLLEVEL_DEFAULT* = 0 + INSTALLLEVEL_MINIMUM* = 1 + INSTALLLEVEL_MAXIMUM* = 0xffff + REINSTALLMODE_REPAIR* = 0x00000001 + REINSTALLMODE_FILEMISSING* = 0x00000002 + REINSTALLMODE_FILEOLDERVERSION* = 0x00000004 + REINSTALLMODE_FILEEQUALVERSION* = 0x00000008 + REINSTALLMODE_FILEEXACT* = 0x00000010 + REINSTALLMODE_FILEVERIFY* = 0x00000020 + REINSTALLMODE_FILEREPLACE* = 0x00000040 + REINSTALLMODE_MACHINEDATA* = 0x00000080 + REINSTALLMODE_USERDATA* = 0x00000100 + REINSTALLMODE_SHORTCUT* = 0x00000200 + REINSTALLMODE_PACKAGE* = 0x00000400 + INSTALLLOGMODE_FATALEXIT* = 1 shl (INSTALLMESSAGE_FATALEXIT shr 24) + INSTALLLOGMODE_ERROR* = 1 shl (INSTALLMESSAGE_ERROR shr 24) + INSTALLLOGMODE_WARNING* = 1 shl (INSTALLMESSAGE_WARNING shr 24) + INSTALLLOGMODE_USER* = 1 shl (INSTALLMESSAGE_USER shr 24) + INSTALLLOGMODE_INFO* = 1 shl (INSTALLMESSAGE_INFO shr 24) + INSTALLLOGMODE_RESOLVESOURCE* = 1 shl (INSTALLMESSAGE_RESOLVESOURCE shr 24) + INSTALLLOGMODE_OUTOFDISKSPACE* = 1 shl (INSTALLMESSAGE_OUTOFDISKSPACE shr 24) + INSTALLLOGMODE_ACTIONSTART* = 1 shl (INSTALLMESSAGE_ACTIONSTART shr 24) + INSTALLLOGMODE_ACTIONDATA* = 1 shl (INSTALLMESSAGE_ACTIONDATA shr 24) + INSTALLLOGMODE_COMMONDATA* = 1 shl (INSTALLMESSAGE_COMMONDATA shr 24) + INSTALLLOGMODE_PROPERTYDUMP* = 1 shl (INSTALLMESSAGE_PROGRESS shr 24) + INSTALLLOGMODE_VERBOSE* = 1 shl (INSTALLMESSAGE_INITIALIZE shr 24) + INSTALLLOGMODE_EXTRADEBUG* = 1 shl (INSTALLMESSAGE_TERMINATE shr 24) + INSTALLLOGMODE_LOGONLYONERROR* = 1 shl (INSTALLMESSAGE_SHOWDIALOG shr 24) + INSTALLLOGMODE_PROGRESS* = 1 shl (INSTALLMESSAGE_PROGRESS shr 24) + INSTALLLOGMODE_INITIALIZE* = 1 shl (INSTALLMESSAGE_INITIALIZE shr 24) + INSTALLLOGMODE_TERMINATE* = 1 shl (INSTALLMESSAGE_TERMINATE shr 24) + INSTALLLOGMODE_SHOWDIALOG* = 1 shl (INSTALLMESSAGE_SHOWDIALOG shr 24) + INSTALLLOGMODE_FILESINUSE* = 1 shl (INSTALLMESSAGE_FILESINUSE shr 24) + INSTALLLOGMODE_RMFILESINUSE* = 1 shl (INSTALLMESSAGE_RMFILESINUSE shr 24) + INSTALLLOGMODE_INSTALLSTART* = 1 shl (INSTALLMESSAGE_INSTALLSTART shr 24) + INSTALLLOGMODE_INSTALLEND* = 1 shl (INSTALLMESSAGE_INSTALLEND shr 24) + INSTALLLOGATTRIBUTES_APPEND* = 1 shl 0 + INSTALLLOGATTRIBUTES_FLUSHEACHLINE* = 1 shl 1 + INSTALLFEATUREATTRIBUTE_FAVORLOCAL* = 1 shl 0 + INSTALLFEATUREATTRIBUTE_FAVORSOURCE* = 1 shl 1 + INSTALLFEATUREATTRIBUTE_FOLLOWPARENT* = 1 shl 2 + INSTALLFEATUREATTRIBUTE_FAVORADVERTISE* = 1 shl 3 + INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE* = 1 shl 4 + INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE* = 1 shl 5 + INSTALLMODE_NODETECTION_ANY* = -4 + INSTALLMODE_NOSOURCERESOLUTION* = -3 + INSTALLMODE_NODETECTION* = -2 + INSTALLMODE_EXISTING* = -1 + INSTALLMODE_DEFAULT* = 0 + MSIPATCHSTATE_INVALID* = 0 + MSIPATCHSTATE_APPLIED* = 1 + MSIPATCHSTATE_SUPERSEDED* = 2 + MSIPATCHSTATE_OBSOLETED* = 4 + MSIPATCHSTATE_REGISTERED* = 8 + MSIPATCHSTATE_ALL* = MSIPATCHSTATE_APPLIED or MSIPATCHSTATE_SUPERSEDED or MSIPATCHSTATE_OBSOLETED or MSIPATCHSTATE_REGISTERED + MSIINSTALLCONTEXT_FIRSTVISIBLE* = 0 + MSIINSTALLCONTEXT_NONE* = 0 + MSIINSTALLCONTEXT_USERMANAGED* = 1 + MSIINSTALLCONTEXT_USERUNMANAGED* = 2 + MSIINSTALLCONTEXT_MACHINE* = 4 + MSIINSTALLCONTEXT_ALL* = MSIINSTALLCONTEXT_USERMANAGED or MSIINSTALLCONTEXT_USERUNMANAGED or MSIINSTALLCONTEXT_MACHINE + MSIINSTALLCONTEXT_ALLUSERMANAGED* = 8 + MSIPATCH_DATATYPE_PATCHFILE* = 0 + MSIPATCH_DATATYPE_XMLPATH* = 1 + MSIPATCH_DATATYPE_XMLBLOB* = 2 + MAX_FEATURE_CHARS* = 38 + INSTALLPROPERTY_PACKAGENAME* = "PackageName" + INSTALLPROPERTY_TRANSFORMS* = "Transforms" + INSTALLPROPERTY_LANGUAGE* = "Language" + INSTALLPROPERTY_PRODUCTNAME* = "ProductName" + INSTALLPROPERTY_ASSIGNMENTTYPE* = "AssignmentType" + INSTALLPROPERTY_INSTANCETYPE* = "InstanceType" + INSTALLPROPERTY_AUTHORIZED_LUA_APP* = "AuthorizedLUAApp" + INSTALLPROPERTY_PACKAGECODE* = "PackageCode" + INSTALLPROPERTY_VERSION* = "Version" + INSTALLPROPERTY_PRODUCTICON* = "ProductIcon" + INSTALLPROPERTY_INSTALLEDPRODUCTNAME* = "InstalledProductName" + INSTALLPROPERTY_VERSIONSTRING* = "VersionString" + INSTALLPROPERTY_HELPLINK* = "HelpLink" + INSTALLPROPERTY_HELPTELEPHONE* = "HelpTelephone" + INSTALLPROPERTY_INSTALLLOCATION* = "InstallLocation" + INSTALLPROPERTY_INSTALLSOURCE* = "InstallSource" + INSTALLPROPERTY_INSTALLDATE* = "InstallDate" + INSTALLPROPERTY_PUBLISHER* = "Publisher" + INSTALLPROPERTY_LOCALPACKAGE* = "LocalPackage" + INSTALLPROPERTY_URLINFOABOUT* = "URLInfoAbout" + INSTALLPROPERTY_URLUPDATEINFO* = "URLUpdateInfo" + INSTALLPROPERTY_VERSIONMINOR* = "VersionMinor" + INSTALLPROPERTY_VERSIONMAJOR* = "VersionMajor" + INSTALLPROPERTY_PRODUCTID* = "ProductID" + INSTALLPROPERTY_REGCOMPANY* = "RegCompany" + INSTALLPROPERTY_REGOWNER* = "RegOwner" + INSTALLPROPERTY_UNINSTALLABLE* = "Uninstallable" + INSTALLPROPERTY_PRODUCTSTATE* = "State" + INSTALLPROPERTY_PATCHSTATE* = "State" + INSTALLPROPERTY_PATCHTYPE* = "PatchType" + INSTALLPROPERTY_LUAENABLED* = "LUAEnabled" + INSTALLPROPERTY_DISPLAYNAME* = "DisplayName" + INSTALLPROPERTY_MOREINFOURL* = "MoreInfoUR" + INSTALLPROPERTY_LASTUSEDSOURCE* = "LastUsedSource" + INSTALLPROPERTY_LASTUSEDTYPE* = "LastUsedType" + INSTALLPROPERTY_MEDIAPACKAGEPATH* = "MediaPackagePath" + INSTALLPROPERTY_DISKPROMPT* = "DiskPrompt" + SCRIPTFLAGS_CACHEINFO* = 0x00000001 + SCRIPTFLAGS_SHORTCUTS* = 0x00000004 + SCRIPTFLAGS_MACHINEASSIGN* = 0x00000008 + SCRIPTFLAGS_REGDATA_CNFGINFO* = 0x00000020 + SCRIPTFLAGS_VALIDATE_TRANSFORMS_LIST* = 0x00000040 + SCRIPTFLAGS_REGDATA_CLASSINFO* = 0x00000080 + SCRIPTFLAGS_REGDATA_EXTENSIONINFO* = 0x00000100 + SCRIPTFLAGS_REGDATA_APPINFO* = SCRIPTFLAGS_REGDATA_CLASSINFO or SCRIPTFLAGS_REGDATA_EXTENSIONINFO + SCRIPTFLAGS_REGDATA* = SCRIPTFLAGS_REGDATA_APPINFO or SCRIPTFLAGS_REGDATA_CNFGINFO + ADVERTISEFLAGS_MACHINEASSIGN* = 0 + ADVERTISEFLAGS_USERASSIGN* = 1 + INSTALLTYPE_DEFAULT* = 0 + INSTALLTYPE_NETWORK_IMAGE* = 1 + INSTALLTYPE_SINGLE_INSTANCE* = 2 + MSIARCHITECTUREFLAGS_X86* = 0x00000001 + MSIARCHITECTUREFLAGS_IA64* = 0x00000002 + MSIARCHITECTUREFLAGS_AMD64* = 0x00000004 + MSIOPENPACKAGEFLAGS_IGNOREMACHINESTATE* = 0x00000001 + MSIADVERTISEOPTIONFLAGS_INSTANCE* = 0x00000001 + MSISOURCETYPE_UNKNOWN* = 0x00000000 + MSISOURCETYPE_NETWORK* = 0x00000001 + MSISOURCETYPE_URL* = 0x00000002 + MSISOURCETYPE_MEDIA* = 0x00000004 + MSICODE_PRODUCT* = 0x00000000 + MSICODE_PATCH* = 0x40000000 + MSITRANSACTION_CHAIN_EMBEDDEDUI* = 0x00000001 + MSITRANSACTION_JOIN_EXISTING_EMBEDDEDUI* = 0x00000002 + MSITRANSACTIONSTATE_ROLLBACK* = 0x00000000 + MSITRANSACTIONSTATE_COMMIT* = 0x00000001 + MSIASSEMBLYINFO_NETASSEMBLY* = 0 + MSIASSEMBLYINFO_WIN32ASSEMBLY* = 1 + MSI_INVALID_HASH_IS_FATAL* = 0x1 + ERROR_PATCH_REMOVAL_UNSUPPORTED* = 1646 + ERROR_UNKNOWN_PATCH* = 1647 + ERROR_PATCH_NO_SEQUENCE* = 1648 + ERROR_PATCH_REMOVAL_DISALLOWED* = 1649 + ERROR_INVALID_PATCH_XML* = 1650 + ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT* = 1651 + ERROR_INSTALL_SERVICE_SAFEBOOT* = 1652 + ERROR_ROLLBACK_DISABLED* = 1653 +type + INSTALLUI_HANDLERA* = proc (pvContext: LPVOID, iMessageType: UINT, szMessage: LPCSTR): int32 {.stdcall.} + INSTALLUI_HANDLERW* = proc (pvContext: LPVOID, iMessageType: UINT, szMessage: LPCWSTR): int32 {.stdcall.} +proc MsiCloseHandle*(hAny: MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiCloseAllHandles*(): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSetInternalUI*(dwUILevel: INSTALLUILEVEL, phWnd: ptr HWND): INSTALLUILEVEL {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSetExternalUIA*(puiHandler: INSTALLUI_HANDLERA, dwMessageFilter: DWORD, pvContext: LPVOID): INSTALLUI_HANDLERA {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSetExternalUIW*(puiHandler: INSTALLUI_HANDLERW, dwMessageFilter: DWORD, pvContext: LPVOID): INSTALLUI_HANDLERW {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSetExternalUIRecord*(puiHandler: INSTALLUI_HANDLER_RECORD, dwMessageFilter: DWORD, pvContext: LPVOID, ppuiPrevHandler: PINSTALLUI_HANDLER_RECORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnableLogA*(dwLogMode: DWORD, szLogFile: LPCSTR, dwLogAttributes: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnableLogW*(dwLogMode: DWORD, szLogFile: LPCWSTR, dwLogAttributes: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryProductStateA*(szProduct: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryProductStateW*(szProduct: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoA*(szProduct: LPCSTR, szAttribute: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoW*(szProduct: LPCWSTR, szAttribute: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoExA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCSTR, szValue: LPSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoExW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCWSTR, szValue: LPWSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallProductA*(szPackagePath: LPCSTR, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallProductW*(szPackagePath: LPCWSTR, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureProductA*(szProduct: LPCSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureProductW*(szProduct: LPCWSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureProductExA*(szProduct: LPCSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureProductExW*(szProduct: LPCWSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiReinstallProductA*(szProduct: LPCSTR, szReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiReinstallProductW*(szProduct: LPCWSTR, szReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseProductExA*(szPackagePath: LPCSTR, szScriptfilePath: LPCSTR, szTransforms: LPCSTR, lgidLanguage: LANGID, dwPlatform: DWORD, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseProductExW*(szPackagePath: LPCWSTR, szScriptfilePath: LPCWSTR, szTransforms: LPCWSTR, lgidLanguage: LANGID, dwPlatform: DWORD, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseProductA*(szPackagePath: LPCSTR, szScriptfilePath: LPCSTR, szTransforms: LPCSTR, lgidLanguage: LANGID): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseProductW*(szPackagePath: LPCWSTR, szScriptfilePath: LPCWSTR, szTransforms: LPCWSTR, lgidLanguage: LANGID): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProcessAdvertiseScriptA*(szScriptFile: LPCSTR, szIconFolder: LPCSTR, hRegData: HKEY, fShortcuts: WINBOOL, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProcessAdvertiseScriptW*(szScriptFile: LPCWSTR, szIconFolder: LPCWSTR, hRegData: HKEY, fShortcuts: WINBOOL, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseScriptA*(szScriptFile: LPCSTR, dwFlags: DWORD, phRegData: PHKEY, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiAdvertiseScriptW*(szScriptFile: LPCWSTR, dwFlags: DWORD, phRegData: PHKEY, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoFromScriptA*(szScriptFile: LPCSTR, lpProductBuf39: LPSTR, plgidLanguage: ptr LANGID, pdwVersion: ptr DWORD, lpNameBuf: LPSTR, pcchNameBuf: ptr DWORD, lpPackageBuf: LPSTR, pcchPackageBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductInfoFromScriptW*(szScriptFile: LPCWSTR, lpProductBuf39: LPWSTR, plgidLanguage: ptr LANGID, pdwVersion: ptr DWORD, lpNameBuf: LPWSTR, pcchNameBuf: ptr DWORD, lpPackageBuf: LPWSTR, pcchPackageBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductCodeA*(szComponent: LPCSTR, lpBuf39: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductCodeW*(szComponent: LPCWSTR, lpBuf39: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetUserInfoA*(szProduct: LPCSTR, lpUserNameBuf: LPSTR, pcchUserNameBuf: ptr DWORD, lpOrgNameBuf: LPSTR, pcchOrgNameBuf: ptr DWORD, lpSerialBuf: LPSTR, pcchSerialBuf: ptr DWORD): USERINFOSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetUserInfoW*(szProduct: LPCWSTR, lpUserNameBuf: LPWSTR, pcchUserNameBuf: ptr DWORD, lpOrgNameBuf: LPWSTR, pcchOrgNameBuf: ptr DWORD, lpSerialBuf: LPWSTR, pcchSerialBuf: ptr DWORD): USERINFOSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiCollectUserInfoA*(szProduct: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiCollectUserInfoW*(szProduct: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiApplyPatchA*(szPatchPackage: LPCSTR, szInstallPackage: LPCSTR, eInstallType: INSTALLTYPE, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiApplyPatchW*(szPatchPackage: LPCWSTR, szInstallPackage: LPCWSTR, eInstallType: INSTALLTYPE, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchInfoA*(szPatch: LPCSTR, szAttribute: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchInfoW*(szPatch: LPCWSTR, szAttribute: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumPatchesA*(szProduct: LPCSTR, iPatchIndex: DWORD, lpPatchBuf: LPSTR, lpTransformsBuf: LPSTR, pcchTransformsBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumPatchesW*(szProduct: LPCWSTR, iPatchIndex: DWORD, lpPatchBuf: LPWSTR, lpTransformsBuf: LPWSTR, pcchTransformsBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiRemovePatchesA*(szPatchList: LPCSTR, szProductCode: LPCSTR, eUninstallType: INSTALLTYPE, szPropertyList: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiRemovePatchesW*(szPatchList: LPCWSTR, szProductCode: LPCWSTR, eUninstallType: INSTALLTYPE, szPropertyList: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiExtractPatchXMLDataA*(szPatchPath: LPCSTR, dwReserved: DWORD, szXMLData: LPSTR, pcchXMLData: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiExtractPatchXMLDataW*(szPatchPath: LPCWSTR, dwReserved: DWORD, szXMLData: LPWSTR, pcchXMLData: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchInfoExA*(szPatchCode: LPCSTR, szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCSTR, lpValue: LPSTR, pcchValue: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchInfoExW*(szPatchCode: LPCWSTR, szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCWSTR, lpValue: LPWSTR, pcchValue: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiApplyMultiplePatchesA*(szPatchPackages: LPCSTR, szProductCode: LPCSTR, szPropertiesList: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiApplyMultiplePatchesW*(szPatchPackages: LPCWSTR, szProductCode: LPCWSTR, szPropertiesList: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiDeterminePatchSequenceA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOA): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiDeterminePatchSequenceW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOW): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiDetermineApplicablePatchesA*(szProductPackagePath: LPCSTR, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOA): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiDetermineApplicablePatchesW*(szProductPackagePath: LPCWSTR, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOW): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumPatchesExA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: DWORD, dwFilter: DWORD, dwIndex: DWORD, szPatchCode: ptr CHAR, szTargetProductCode: ptr CHAR, pdwTargetProductContext: ptr MSIINSTALLCONTEXT, szTargetUserSid: LPSTR, pcchTargetUserSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumPatchesExW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: DWORD, dwFilter: DWORD, dwIndex: DWORD, szPatchCode: ptr WCHAR, szTargetProductCode: ptr WCHAR, pdwTargetProductContext: ptr MSIINSTALLCONTEXT, szTargetUserSid: LPWSTR, pcchTargetUserSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryFeatureStateA*(szProduct: LPCSTR, szFeature: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryFeatureStateW*(szProduct: LPCWSTR, szFeature: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryFeatureStateExA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szFeature: LPCSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryFeatureStateExW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szFeature: LPCWSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiUseFeatureA*(szProduct: LPCSTR, szFeature: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiUseFeatureW*(szProduct: LPCWSTR, szFeature: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiUseFeatureExA*(szProduct: LPCSTR, szFeature: LPCSTR, dwInstallMode: DWORD, dwReserved: DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiUseFeatureExW*(szProduct: LPCWSTR, szFeature: LPCWSTR, dwInstallMode: DWORD, dwReserved: DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFeatureUsageA*(szProduct: LPCSTR, szFeature: LPCSTR, pdwUseCount: ptr DWORD, pwDateUsed: ptr WORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFeatureUsageW*(szProduct: LPCWSTR, szFeature: LPCWSTR, pdwUseCount: ptr DWORD, pwDateUsed: ptr WORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureFeatureA*(szProduct: LPCSTR, szFeature: LPCSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiConfigureFeatureW*(szProduct: LPCWSTR, szFeature: LPCWSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiReinstallFeatureA*(szProduct: LPCSTR, szFeature: LPCSTR, dwReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiReinstallFeatureW*(szProduct: LPCWSTR, szFeature: LPCWSTR, dwReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideComponentA*(szProduct: LPCSTR, szFeature: LPCSTR, szComponent: LPCSTR, dwInstallMode: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideComponentW*(szProduct: LPCWSTR, szFeature: LPCWSTR, szComponent: LPCWSTR, dwInstallMode: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideQualifiedComponentA*(szCategory: LPCSTR, szQualifier: LPCSTR, dwInstallMode: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideQualifiedComponentW*(szCategory: LPCWSTR, szQualifier: LPCWSTR, dwInstallMode: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideQualifiedComponentExA*(szCategory: LPCSTR, szQualifier: LPCSTR, dwInstallMode: DWORD, szProduct: LPCSTR, dwUnused1: DWORD, dwUnused2: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideQualifiedComponentExW*(szCategory: LPCWSTR, szQualifier: LPCWSTR, dwInstallMode: DWORD, szProduct: LPCWSTR, dwUnused1: DWORD, dwUnused2: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetComponentPathA*(szProduct: LPCSTR, szComponent: LPCSTR, lpPathBuf: LPSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetComponentPathW*(szProduct: LPCWSTR, szComponent: LPCWSTR, lpPathBuf: LPWSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideAssemblyA*(szAssemblyName: LPCSTR, szAppContext: LPCSTR, dwInstallMode: DWORD, dwAssemblyInfo: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiProvideAssemblyW*(szAssemblyName: LPCWSTR, szAppContext: LPCWSTR, dwInstallMode: DWORD, dwAssemblyInfo: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryComponentStateA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szComponentCode: LPCSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiQueryComponentStateW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szComponentCode: LPCWSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumProductsA*(iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumProductsW*(iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumProductsExA*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: DWORD, dwIndex: DWORD, szInstalledProductCode: ptr CHAR, pdwInstalledContext: ptr MSIINSTALLCONTEXT, szSid: LPSTR, pcchSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumProductsExW*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: DWORD, dwIndex: DWORD, szInstalledProductCode: ptr WCHAR, pdwInstalledContext: ptr MSIINSTALLCONTEXT, szSid: LPWSTR, pcchSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumRelatedProductsA*(lpUpgradeCode: LPCSTR, dwReserved: DWORD, iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumRelatedProductsW*(lpUpgradeCode: LPCWSTR, dwReserved: DWORD, iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumFeaturesA*(szProduct: LPCSTR, iFeatureIndex: DWORD, lpFeatureBuf: LPSTR, lpParentBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumFeaturesW*(szProduct: LPCWSTR, iFeatureIndex: DWORD, lpFeatureBuf: LPWSTR, lpParentBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumComponentsA*(iComponentIndex: DWORD, lpComponentBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumComponentsW*(iComponentIndex: DWORD, lpComponentBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumClientsA*(szComponent: LPCSTR, iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumClientsW*(szComponent: LPCWSTR, iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumComponentQualifiersA*(szComponent: LPCSTR, iIndex: DWORD, lpQualifierBuf: LPSTR, pcchQualifierBuf: ptr DWORD, lpApplicationDataBuf: LPSTR, pcchApplicationDataBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEnumComponentQualifiersW*(szComponent: LPCWSTR, iIndex: DWORD, lpQualifierBuf: LPWSTR, pcchQualifierBuf: ptr DWORD, lpApplicationDataBuf: LPWSTR, pcchApplicationDataBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenProductA*(szProduct: LPCSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenProductW*(szProduct: LPCWSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenPackageA*(szPackagePath: LPCSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenPackageW*(szPackagePath: LPCWSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenPackageExA*(szPackagePath: LPCSTR, dwOptions: DWORD, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiOpenPackageExW*(szPackagePath: LPCWSTR, dwOptions: DWORD, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchFileListA*(szProductCode: LPCSTR, szPatchPackages: LPCSTR, pcFiles: LPDWORD, pphFileRecords: ptr ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetPatchFileListW*(szProductCode: LPCWSTR, szPatchPackages: LPCWSTR, pcFiles: LPDWORD, pphFileRecords: ptr ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductPropertyA*(hProduct: MSIHANDLE, szProperty: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetProductPropertyW*(hProduct: MSIHANDLE, szProperty: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiVerifyPackageA*(szPackagePath: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiVerifyPackageW*(szPackagePath: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFeatureInfoA*(hProduct: MSIHANDLE, szFeature: LPCSTR, lpAttributes: ptr DWORD, lpTitleBuf: LPSTR, pcchTitleBuf: ptr DWORD, lpHelpBuf: LPSTR, pcchHelpBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFeatureInfoW*(hProduct: MSIHANDLE, szFeature: LPCWSTR, lpAttributes: ptr DWORD, lpTitleBuf: LPWSTR, pcchTitleBuf: ptr DWORD, lpHelpBuf: LPWSTR, pcchHelpBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallMissingComponentA*(szProduct: LPCSTR, szComponent: LPCSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallMissingComponentW*(szProduct: LPCWSTR, szComponent: LPCWSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallMissingFileA*(szProduct: LPCSTR, szFile: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiInstallMissingFileW*(szProduct: LPCWSTR, szFile: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiLocateComponentA*(szComponent: LPCSTR, lpPathBuf: LPSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiLocateComponentW*(szComponent: LPCWSTR, lpPathBuf: LPWSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearAllA*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearAllW*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddSourceA*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD, szSource: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddSourceW*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD, szSource: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListForceResolutionA*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListForceResolutionW*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddSourceExA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCSTR, dwIndex: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddSourceExW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCWSTR, dwIndex: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddMediaDiskA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD, szVolumeLabel: LPCSTR, szDiskPrompt: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListAddMediaDiskW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD, szVolumeLabel: LPCWSTR, szDiskPrompt: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearSourceA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearSourceW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearMediaDiskA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearMediaDiskW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearAllExA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListClearAllExW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListForceResolutionExA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListForceResolutionExW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListSetInfoA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCSTR, szValue: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListSetInfoW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCWSTR, szValue: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListGetInfoA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCSTR, szValue: LPSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListGetInfoW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCWSTR, szValue: LPWSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListEnumSourcesA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, szSource: LPSTR, pcchSource: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListEnumSourcesW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, szSource: LPWSTR, pcchSource: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListEnumMediaDisksA*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, pdwDiskId: LPDWORD, szVolumeLabel: LPSTR, pcchVolumeLabel: LPDWORD, szDiskPrompt: LPSTR, pcchDiskPrompt: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiSourceListEnumMediaDisksW*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, pdwDiskId: LPDWORD, szVolumeLabel: LPWSTR, pcchVolumeLabel: LPDWORD, szDiskPrompt: LPWSTR, pcchDiskPrompt: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileVersionA*(szFilePath: LPCSTR, lpVersionBuf: LPSTR, pcchVersionBuf: ptr DWORD, lpLangBuf: LPSTR, pcchLangBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileVersionW*(szFilePath: LPCWSTR, lpVersionBuf: LPWSTR, pcchVersionBuf: ptr DWORD, lpLangBuf: LPWSTR, pcchLangBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileHashA*(szFilePath: LPCSTR, dwOptions: DWORD, pHash: PMSIFILEHASHINFO): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileHashW*(szFilePath: LPCWSTR, dwOptions: DWORD, pHash: PMSIFILEHASHINFO): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileSignatureInformationA*(szSignedObjectPath: LPCSTR, dwFlags: DWORD, ppcCertContext: ptr PCCERT_CONTEXT, pbHashData: ptr BYTE, pcbHashData: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetFileSignatureInformationW*(szSignedObjectPath: LPCWSTR, dwFlags: DWORD, ppcCertContext: ptr PCCERT_CONTEXT, pbHashData: ptr BYTE, pcbHashData: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetShortcutTargetA*(szShortcutPath: LPCSTR, szProductCode: LPSTR, szFeatureId: LPSTR, szComponentCode: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiGetShortcutTargetW*(szShortcutPath: LPCWSTR, szProductCode: LPWSTR, szFeatureId: LPWSTR, szComponentCode: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiIsProductElevatedA*(szProduct: LPCSTR, pfElevated: ptr WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiIsProductElevatedW*(szProduct: LPCWSTR, pfElevated: ptr WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiNotifySidChangeA*(pOldSid: LPCSTR, pNewSid: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiNotifySidChangeW*(pOldSid: LPCWSTR, pNewSid: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiBeginTransactionA*(szName: LPCSTR, dwTransactionAttributes: DWORD, phTransactionHandle: ptr MSIHANDLE, phChangeOfOwnerEvent: ptr HANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiBeginTransactionW*(szName: LPCWSTR, dwTransactionAttributes: DWORD, phTransactionHandle: ptr MSIHANDLE, phChangeOfOwnerEvent: ptr HANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiEndTransaction*(dwTransactionState: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc.} +proc MsiJoinTransaction*(hTransactionHandle: MSIHANDLE, dwTransactionAttributes: DWORD, phChangeOfOwnerEvent: ptr HANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc.} +when winimUnicode: + type + INSTALLUI_HANDLER* = INSTALLUI_HANDLERW + MSIPATCHSEQUENCEINFO* = MSIPATCHSEQUENCEINFOW + PMSIPATCHSEQUENCEINFO* = PMSIPATCHSEQUENCEINFOW + proc MsiSetExternalUI*(puiHandler: INSTALLUI_HANDLERW, dwMessageFilter: DWORD, pvContext: LPVOID): INSTALLUI_HANDLERW {.winapi, stdcall, dynlib: "msi", importc: "MsiSetExternalUIW".} + proc MsiEnableLog*(dwLogMode: DWORD, szLogFile: LPCWSTR, dwLogAttributes: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnableLogW".} + proc MsiQueryProductState*(szProduct: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryProductStateW".} + proc MsiGetProductInfo*(szProduct: LPCWSTR, szAttribute: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoW".} + proc MsiGetProductInfoEx*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCWSTR, szValue: LPWSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoExW".} + proc MsiInstallProduct*(szPackagePath: LPCWSTR, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallProductW".} + proc MsiConfigureProduct*(szProduct: LPCWSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureProductW".} + proc MsiConfigureProductEx*(szProduct: LPCWSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureProductExW".} + proc MsiReinstallProduct*(szProduct: LPCWSTR, szReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiReinstallProductW".} + proc MsiAdvertiseProductEx*(szPackagePath: LPCWSTR, szScriptfilePath: LPCWSTR, szTransforms: LPCWSTR, lgidLanguage: LANGID, dwPlatform: DWORD, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseProductExW".} + proc MsiAdvertiseProduct*(szPackagePath: LPCWSTR, szScriptfilePath: LPCWSTR, szTransforms: LPCWSTR, lgidLanguage: LANGID): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseProductW".} + proc MsiProcessAdvertiseScript*(szScriptFile: LPCWSTR, szIconFolder: LPCWSTR, hRegData: HKEY, fShortcuts: WINBOOL, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProcessAdvertiseScriptW".} + proc MsiAdvertiseScript*(szScriptFile: LPCWSTR, dwFlags: DWORD, phRegData: PHKEY, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseScriptW".} + proc MsiGetProductInfoFromScript*(szScriptFile: LPCWSTR, lpProductBuf39: LPWSTR, plgidLanguage: ptr LANGID, pdwVersion: ptr DWORD, lpNameBuf: LPWSTR, pcchNameBuf: ptr DWORD, lpPackageBuf: LPWSTR, pcchPackageBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoFromScriptW".} + proc MsiGetProductCode*(szComponent: LPCWSTR, lpBuf39: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductCodeW".} + proc MsiGetUserInfo*(szProduct: LPCWSTR, lpUserNameBuf: LPWSTR, pcchUserNameBuf: ptr DWORD, lpOrgNameBuf: LPWSTR, pcchOrgNameBuf: ptr DWORD, lpSerialBuf: LPWSTR, pcchSerialBuf: ptr DWORD): USERINFOSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiGetUserInfoW".} + proc MsiCollectUserInfo*(szProduct: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiCollectUserInfoW".} + proc MsiApplyPatch*(szPatchPackage: LPCWSTR, szInstallPackage: LPCWSTR, eInstallType: INSTALLTYPE, szCommandLine: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiApplyPatchW".} + proc MsiGetPatchInfo*(szPatch: LPCWSTR, szAttribute: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchInfoW".} + proc MsiEnumPatches*(szProduct: LPCWSTR, iPatchIndex: DWORD, lpPatchBuf: LPWSTR, lpTransformsBuf: LPWSTR, pcchTransformsBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumPatchesW".} + proc MsiRemovePatches*(szPatchList: LPCWSTR, szProductCode: LPCWSTR, eUninstallType: INSTALLTYPE, szPropertyList: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiRemovePatchesW".} + proc MsiExtractPatchXMLData*(szPatchPath: LPCWSTR, dwReserved: DWORD, szXMLData: LPWSTR, pcchXMLData: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiExtractPatchXMLDataW".} + proc MsiGetPatchInfoEx*(szPatchCode: LPCWSTR, szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCWSTR, lpValue: LPWSTR, pcchValue: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchInfoExW".} + proc MsiApplyMultiplePatches*(szPatchPackages: LPCWSTR, szProductCode: LPCWSTR, szPropertiesList: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiApplyMultiplePatchesW".} + proc MsiDeterminePatchSequence*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOW): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiDeterminePatchSequenceW".} + proc MsiDetermineApplicablePatches*(szProductPackagePath: LPCWSTR, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOW): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiDetermineApplicablePatchesW".} + proc MsiEnumPatchesEx*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: DWORD, dwFilter: DWORD, dwIndex: DWORD, szPatchCode: ptr WCHAR, szTargetProductCode: ptr WCHAR, pdwTargetProductContext: ptr MSIINSTALLCONTEXT, szTargetUserSid: LPWSTR, pcchTargetUserSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumPatchesExW".} + proc MsiQueryFeatureState*(szProduct: LPCWSTR, szFeature: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryFeatureStateW".} + proc MsiQueryFeatureStateEx*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szFeature: LPCWSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryFeatureStateExW".} + proc MsiUseFeature*(szProduct: LPCWSTR, szFeature: LPCWSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiUseFeatureW".} + proc MsiUseFeatureEx*(szProduct: LPCWSTR, szFeature: LPCWSTR, dwInstallMode: DWORD, dwReserved: DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiUseFeatureExW".} + proc MsiGetFeatureUsage*(szProduct: LPCWSTR, szFeature: LPCWSTR, pdwUseCount: ptr DWORD, pwDateUsed: ptr WORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFeatureUsageW".} + proc MsiConfigureFeature*(szProduct: LPCWSTR, szFeature: LPCWSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureFeatureW".} + proc MsiReinstallFeature*(szProduct: LPCWSTR, szFeature: LPCWSTR, dwReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiReinstallFeatureW".} + proc MsiProvideComponent*(szProduct: LPCWSTR, szFeature: LPCWSTR, szComponent: LPCWSTR, dwInstallMode: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideComponentW".} + proc MsiProvideQualifiedComponent*(szCategory: LPCWSTR, szQualifier: LPCWSTR, dwInstallMode: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideQualifiedComponentW".} + proc MsiProvideQualifiedComponentEx*(szCategory: LPCWSTR, szQualifier: LPCWSTR, dwInstallMode: DWORD, szProduct: LPCWSTR, dwUnused1: DWORD, dwUnused2: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideQualifiedComponentExW".} + proc MsiGetComponentPath*(szProduct: LPCWSTR, szComponent: LPCWSTR, lpPathBuf: LPWSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiGetComponentPathW".} + proc MsiProvideAssembly*(szAssemblyName: LPCWSTR, szAppContext: LPCWSTR, dwInstallMode: DWORD, dwAssemblyInfo: DWORD, lpPathBuf: LPWSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideAssemblyW".} + proc MsiQueryComponentState*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, szComponentCode: LPCWSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryComponentStateW".} + proc MsiEnumProducts*(iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumProductsW".} + proc MsiEnumProductsEx*(szProductCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: DWORD, dwIndex: DWORD, szInstalledProductCode: ptr WCHAR, pdwInstalledContext: ptr MSIINSTALLCONTEXT, szSid: LPWSTR, pcchSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumProductsExW".} + proc MsiEnumRelatedProducts*(lpUpgradeCode: LPCWSTR, dwReserved: DWORD, iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumRelatedProductsW".} + proc MsiEnumFeatures*(szProduct: LPCWSTR, iFeatureIndex: DWORD, lpFeatureBuf: LPWSTR, lpParentBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumFeaturesW".} + proc MsiEnumComponents*(iComponentIndex: DWORD, lpComponentBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumComponentsW".} + proc MsiEnumClients*(szComponent: LPCWSTR, iProductIndex: DWORD, lpProductBuf: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumClientsW".} + proc MsiEnumComponentQualifiers*(szComponent: LPCWSTR, iIndex: DWORD, lpQualifierBuf: LPWSTR, pcchQualifierBuf: ptr DWORD, lpApplicationDataBuf: LPWSTR, pcchApplicationDataBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumComponentQualifiersW".} + proc MsiOpenProduct*(szProduct: LPCWSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenProductW".} + proc MsiOpenPackage*(szPackagePath: LPCWSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenPackageW".} + proc MsiOpenPackageEx*(szPackagePath: LPCWSTR, dwOptions: DWORD, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenPackageExW".} + proc MsiGetPatchFileList*(szProductCode: LPCWSTR, szPatchPackages: LPCWSTR, pcFiles: LPDWORD, pphFileRecords: ptr ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchFileListW".} + proc MsiGetProductProperty*(hProduct: MSIHANDLE, szProperty: LPCWSTR, lpValueBuf: LPWSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductPropertyW".} + proc MsiVerifyPackage*(szPackagePath: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiVerifyPackageW".} + proc MsiGetFeatureInfo*(hProduct: MSIHANDLE, szFeature: LPCWSTR, lpAttributes: ptr DWORD, lpTitleBuf: LPWSTR, pcchTitleBuf: ptr DWORD, lpHelpBuf: LPWSTR, pcchHelpBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFeatureInfoW".} + proc MsiInstallMissingComponent*(szProduct: LPCWSTR, szComponent: LPCWSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallMissingComponentW".} + proc MsiInstallMissingFile*(szProduct: LPCWSTR, szFile: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallMissingFileW".} + proc MsiLocateComponent*(szComponent: LPCWSTR, lpPathBuf: LPWSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiLocateComponentW".} + proc MsiSourceListClearAll*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearAllW".} + proc MsiSourceListAddSource*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD, szSource: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddSourceW".} + proc MsiSourceListForceResolution*(szProduct: LPCWSTR, szUserName: LPCWSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListForceResolutionW".} + proc MsiSourceListAddSourceEx*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCWSTR, dwIndex: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddSourceExW".} + proc MsiSourceListAddMediaDisk*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD, szVolumeLabel: LPCWSTR, szDiskPrompt: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddMediaDiskW".} + proc MsiSourceListClearSource*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearSourceW".} + proc MsiSourceListClearMediaDisk*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearMediaDiskW".} + proc MsiSourceListClearAllEx*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearAllExW".} + proc MsiSourceListForceResolutionEx*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListForceResolutionExW".} + proc MsiSourceListSetInfo*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCWSTR, szValue: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListSetInfoW".} + proc MsiSourceListGetInfo*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCWSTR, szValue: LPWSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListGetInfoW".} + proc MsiSourceListEnumSources*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, szSource: LPWSTR, pcchSource: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListEnumSourcesW".} + proc MsiSourceListEnumMediaDisks*(szProductCodeOrPatchCode: LPCWSTR, szUserSid: LPCWSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, pdwDiskId: LPDWORD, szVolumeLabel: LPWSTR, pcchVolumeLabel: LPDWORD, szDiskPrompt: LPWSTR, pcchDiskPrompt: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListEnumMediaDisksW".} + proc MsiGetFileVersion*(szFilePath: LPCWSTR, lpVersionBuf: LPWSTR, pcchVersionBuf: ptr DWORD, lpLangBuf: LPWSTR, pcchLangBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileVersionW".} + proc MsiGetFileHash*(szFilePath: LPCWSTR, dwOptions: DWORD, pHash: PMSIFILEHASHINFO): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileHashW".} + proc MsiGetFileSignatureInformation*(szSignedObjectPath: LPCWSTR, dwFlags: DWORD, ppcCertContext: ptr PCCERT_CONTEXT, pbHashData: ptr BYTE, pcbHashData: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileSignatureInformationW".} + proc MsiGetShortcutTarget*(szShortcutPath: LPCWSTR, szProductCode: LPWSTR, szFeatureId: LPWSTR, szComponentCode: LPWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetShortcutTargetW".} + proc MsiIsProductElevated*(szProduct: LPCWSTR, pfElevated: ptr WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiIsProductElevatedW".} + proc MsiNotifySidChange*(pOldSid: LPCWSTR, pNewSid: LPCWSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiNotifySidChangeW".} + proc MsiBeginTransaction*(szName: LPCWSTR, dwTransactionAttributes: DWORD, phTransactionHandle: ptr MSIHANDLE, phChangeOfOwnerEvent: ptr HANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiBeginTransactionW".} +when winimAnsi: + type + INSTALLUI_HANDLER* = INSTALLUI_HANDLERA + MSIPATCHSEQUENCEINFO* = MSIPATCHSEQUENCEINFOA + PMSIPATCHSEQUENCEINFO* = PMSIPATCHSEQUENCEINFOA + proc MsiSetExternalUI*(puiHandler: INSTALLUI_HANDLERA, dwMessageFilter: DWORD, pvContext: LPVOID): INSTALLUI_HANDLERA {.winapi, stdcall, dynlib: "msi", importc: "MsiSetExternalUIA".} + proc MsiEnableLog*(dwLogMode: DWORD, szLogFile: LPCSTR, dwLogAttributes: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnableLogA".} + proc MsiQueryProductState*(szProduct: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryProductStateA".} + proc MsiGetProductInfo*(szProduct: LPCSTR, szAttribute: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoA".} + proc MsiGetProductInfoEx*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCSTR, szValue: LPSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoExA".} + proc MsiInstallProduct*(szPackagePath: LPCSTR, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallProductA".} + proc MsiConfigureProduct*(szProduct: LPCSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureProductA".} + proc MsiConfigureProductEx*(szProduct: LPCSTR, iInstallLevel: int32, eInstallState: INSTALLSTATE, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureProductExA".} + proc MsiReinstallProduct*(szProduct: LPCSTR, szReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiReinstallProductA".} + proc MsiAdvertiseProductEx*(szPackagePath: LPCSTR, szScriptfilePath: LPCSTR, szTransforms: LPCSTR, lgidLanguage: LANGID, dwPlatform: DWORD, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseProductExA".} + proc MsiAdvertiseProduct*(szPackagePath: LPCSTR, szScriptfilePath: LPCSTR, szTransforms: LPCSTR, lgidLanguage: LANGID): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseProductA".} + proc MsiProcessAdvertiseScript*(szScriptFile: LPCSTR, szIconFolder: LPCSTR, hRegData: HKEY, fShortcuts: WINBOOL, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProcessAdvertiseScriptA".} + proc MsiAdvertiseScript*(szScriptFile: LPCSTR, dwFlags: DWORD, phRegData: PHKEY, fRemoveItems: WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiAdvertiseScriptA".} + proc MsiGetProductInfoFromScript*(szScriptFile: LPCSTR, lpProductBuf39: LPSTR, plgidLanguage: ptr LANGID, pdwVersion: ptr DWORD, lpNameBuf: LPSTR, pcchNameBuf: ptr DWORD, lpPackageBuf: LPSTR, pcchPackageBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductInfoFromScriptA".} + proc MsiGetProductCode*(szComponent: LPCSTR, lpBuf39: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductCodeA".} + proc MsiGetUserInfo*(szProduct: LPCSTR, lpUserNameBuf: LPSTR, pcchUserNameBuf: ptr DWORD, lpOrgNameBuf: LPSTR, pcchOrgNameBuf: ptr DWORD, lpSerialBuf: LPSTR, pcchSerialBuf: ptr DWORD): USERINFOSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiGetUserInfoA".} + proc MsiCollectUserInfo*(szProduct: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiCollectUserInfoA".} + proc MsiApplyPatch*(szPatchPackage: LPCSTR, szInstallPackage: LPCSTR, eInstallType: INSTALLTYPE, szCommandLine: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiApplyPatchA".} + proc MsiGetPatchInfo*(szPatch: LPCSTR, szAttribute: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchInfoA".} + proc MsiEnumPatches*(szProduct: LPCSTR, iPatchIndex: DWORD, lpPatchBuf: LPSTR, lpTransformsBuf: LPSTR, pcchTransformsBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumPatchesA".} + proc MsiRemovePatches*(szPatchList: LPCSTR, szProductCode: LPCSTR, eUninstallType: INSTALLTYPE, szPropertyList: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiRemovePatchesA".} + proc MsiExtractPatchXMLData*(szPatchPath: LPCSTR, dwReserved: DWORD, szXMLData: LPSTR, pcchXMLData: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiExtractPatchXMLDataA".} + proc MsiGetPatchInfoEx*(szPatchCode: LPCSTR, szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szProperty: LPCSTR, lpValue: LPSTR, pcchValue: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchInfoExA".} + proc MsiApplyMultiplePatches*(szPatchPackages: LPCSTR, szProductCode: LPCSTR, szPropertiesList: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiApplyMultiplePatchesA".} + proc MsiDeterminePatchSequence*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOA): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiDeterminePatchSequenceA".} + proc MsiDetermineApplicablePatches*(szProductPackagePath: LPCSTR, cPatchInfo: DWORD, pPatchInfo: PMSIPATCHSEQUENCEINFOA): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiDetermineApplicablePatchesA".} + proc MsiEnumPatchesEx*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: DWORD, dwFilter: DWORD, dwIndex: DWORD, szPatchCode: ptr CHAR, szTargetProductCode: ptr CHAR, pdwTargetProductContext: ptr MSIINSTALLCONTEXT, szTargetUserSid: LPSTR, pcchTargetUserSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumPatchesExA".} + proc MsiQueryFeatureState*(szProduct: LPCSTR, szFeature: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryFeatureStateA".} + proc MsiQueryFeatureStateEx*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szFeature: LPCSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryFeatureStateExA".} + proc MsiUseFeature*(szProduct: LPCSTR, szFeature: LPCSTR): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiUseFeatureA".} + proc MsiUseFeatureEx*(szProduct: LPCSTR, szFeature: LPCSTR, dwInstallMode: DWORD, dwReserved: DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiUseFeatureExA".} + proc MsiGetFeatureUsage*(szProduct: LPCSTR, szFeature: LPCSTR, pdwUseCount: ptr DWORD, pwDateUsed: ptr WORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFeatureUsageA".} + proc MsiConfigureFeature*(szProduct: LPCSTR, szFeature: LPCSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiConfigureFeatureA".} + proc MsiReinstallFeature*(szProduct: LPCSTR, szFeature: LPCSTR, dwReinstallMode: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiReinstallFeatureA".} + proc MsiProvideComponent*(szProduct: LPCSTR, szFeature: LPCSTR, szComponent: LPCSTR, dwInstallMode: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideComponentA".} + proc MsiProvideQualifiedComponent*(szCategory: LPCSTR, szQualifier: LPCSTR, dwInstallMode: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideQualifiedComponentA".} + proc MsiProvideQualifiedComponentEx*(szCategory: LPCSTR, szQualifier: LPCSTR, dwInstallMode: DWORD, szProduct: LPCSTR, dwUnused1: DWORD, dwUnused2: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideQualifiedComponentExA".} + proc MsiGetComponentPath*(szProduct: LPCSTR, szComponent: LPCSTR, lpPathBuf: LPSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiGetComponentPathA".} + proc MsiProvideAssembly*(szAssemblyName: LPCSTR, szAppContext: LPCSTR, dwInstallMode: DWORD, dwAssemblyInfo: DWORD, lpPathBuf: LPSTR, pcchPathBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiProvideAssemblyA".} + proc MsiQueryComponentState*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, szComponentCode: LPCSTR, pdwState: ptr INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiQueryComponentStateA".} + proc MsiEnumProducts*(iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumProductsA".} + proc MsiEnumProductsEx*(szProductCode: LPCSTR, szUserSid: LPCSTR, dwContext: DWORD, dwIndex: DWORD, szInstalledProductCode: ptr CHAR, pdwInstalledContext: ptr MSIINSTALLCONTEXT, szSid: LPSTR, pcchSid: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumProductsExA".} + proc MsiEnumRelatedProducts*(lpUpgradeCode: LPCSTR, dwReserved: DWORD, iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumRelatedProductsA".} + proc MsiEnumFeatures*(szProduct: LPCSTR, iFeatureIndex: DWORD, lpFeatureBuf: LPSTR, lpParentBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumFeaturesA".} + proc MsiEnumComponents*(iComponentIndex: DWORD, lpComponentBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumComponentsA".} + proc MsiEnumClients*(szComponent: LPCSTR, iProductIndex: DWORD, lpProductBuf: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumClientsA".} + proc MsiEnumComponentQualifiers*(szComponent: LPCSTR, iIndex: DWORD, lpQualifierBuf: LPSTR, pcchQualifierBuf: ptr DWORD, lpApplicationDataBuf: LPSTR, pcchApplicationDataBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiEnumComponentQualifiersA".} + proc MsiOpenProduct*(szProduct: LPCSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenProductA".} + proc MsiOpenPackage*(szPackagePath: LPCSTR, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenPackageA".} + proc MsiOpenPackageEx*(szPackagePath: LPCSTR, dwOptions: DWORD, hProduct: ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiOpenPackageExA".} + proc MsiGetPatchFileList*(szProductCode: LPCSTR, szPatchPackages: LPCSTR, pcFiles: LPDWORD, pphFileRecords: ptr ptr MSIHANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetPatchFileListA".} + proc MsiGetProductProperty*(hProduct: MSIHANDLE, szProperty: LPCSTR, lpValueBuf: LPSTR, pcchValueBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetProductPropertyA".} + proc MsiVerifyPackage*(szPackagePath: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiVerifyPackageA".} + proc MsiGetFeatureInfo*(hProduct: MSIHANDLE, szFeature: LPCSTR, lpAttributes: ptr DWORD, lpTitleBuf: LPSTR, pcchTitleBuf: ptr DWORD, lpHelpBuf: LPSTR, pcchHelpBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFeatureInfoA".} + proc MsiInstallMissingComponent*(szProduct: LPCSTR, szComponent: LPCSTR, eInstallState: INSTALLSTATE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallMissingComponentA".} + proc MsiInstallMissingFile*(szProduct: LPCSTR, szFile: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiInstallMissingFileA".} + proc MsiLocateComponent*(szComponent: LPCSTR, lpPathBuf: LPSTR, pcchBuf: ptr DWORD): INSTALLSTATE {.winapi, stdcall, dynlib: "msi", importc: "MsiLocateComponentA".} + proc MsiSourceListClearAll*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearAllA".} + proc MsiSourceListAddSource*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD, szSource: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddSourceA".} + proc MsiSourceListForceResolution*(szProduct: LPCSTR, szUserName: LPCSTR, dwReserved: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListForceResolutionA".} + proc MsiSourceListAddSourceEx*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCSTR, dwIndex: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddSourceExA".} + proc MsiSourceListAddMediaDisk*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD, szVolumeLabel: LPCSTR, szDiskPrompt: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListAddMediaDiskA".} + proc MsiSourceListClearSource*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szSource: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearSourceA".} + proc MsiSourceListClearMediaDisk*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwDiskId: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearMediaDiskA".} + proc MsiSourceListClearAllEx*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListClearAllExA".} + proc MsiSourceListForceResolutionEx*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListForceResolutionExA".} + proc MsiSourceListSetInfo*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCSTR, szValue: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListSetInfoA".} + proc MsiSourceListGetInfo*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, szProperty: LPCSTR, szValue: LPSTR, pcchValue: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListGetInfoA".} + proc MsiSourceListEnumSources*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, szSource: LPSTR, pcchSource: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListEnumSourcesA".} + proc MsiSourceListEnumMediaDisks*(szProductCodeOrPatchCode: LPCSTR, szUserSid: LPCSTR, dwContext: MSIINSTALLCONTEXT, dwOptions: DWORD, dwIndex: DWORD, pdwDiskId: LPDWORD, szVolumeLabel: LPSTR, pcchVolumeLabel: LPDWORD, szDiskPrompt: LPSTR, pcchDiskPrompt: LPDWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiSourceListEnumMediaDisksA".} + proc MsiGetFileVersion*(szFilePath: LPCSTR, lpVersionBuf: LPSTR, pcchVersionBuf: ptr DWORD, lpLangBuf: LPSTR, pcchLangBuf: ptr DWORD): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileVersionA".} + proc MsiGetFileHash*(szFilePath: LPCSTR, dwOptions: DWORD, pHash: PMSIFILEHASHINFO): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileHashA".} + proc MsiGetFileSignatureInformation*(szSignedObjectPath: LPCSTR, dwFlags: DWORD, ppcCertContext: ptr PCCERT_CONTEXT, pbHashData: ptr BYTE, pcbHashData: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetFileSignatureInformationA".} + proc MsiGetShortcutTarget*(szShortcutPath: LPCSTR, szProductCode: LPSTR, szFeatureId: LPSTR, szComponentCode: LPSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiGetShortcutTargetA".} + proc MsiIsProductElevated*(szProduct: LPCSTR, pfElevated: ptr WINBOOL): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiIsProductElevatedA".} + proc MsiNotifySidChange*(pOldSid: LPCSTR, pNewSid: LPCSTR): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiNotifySidChangeA".} + proc MsiBeginTransaction*(szName: LPCSTR, dwTransactionAttributes: DWORD, phTransactionHandle: ptr MSIHANDLE, phChangeOfOwnerEvent: ptr HANDLE): UINT {.winapi, stdcall, dynlib: "msi", importc: "MsiBeginTransactionA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/nb30.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/nb30.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,192 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +const + NCBNAMSZ* = 16 +when winimCpu64: + type + NCB_RESERVE* = array[18, UCHAR] +when winimCpu32: + type + NCB_RESERVE* = array[10, UCHAR] +type + NCB* {.pure.} = object + ncb_command*: UCHAR + ncb_retcode*: UCHAR + ncb_lsn*: UCHAR + ncb_num*: UCHAR + ncb_buffer*: PUCHAR + ncb_length*: WORD + ncb_callname*: array[NCBNAMSZ, UCHAR] + ncb_name*: array[NCBNAMSZ, UCHAR] + ncb_rto*: UCHAR + ncb_sto*: UCHAR + ncb_post*: proc (P1: ptr NCB): void {.stdcall.} + ncb_lana_num*: UCHAR + ncb_cmd_cplt*: UCHAR + ncb_reserve*: NCB_RESERVE + ncb_event*: HANDLE + PNCB* = ptr NCB + ADAPTER_STATUS* {.pure.} = object + adapter_address*: array[6, UCHAR] + rev_major*: UCHAR + reserved0*: UCHAR + adapter_type*: UCHAR + rev_minor*: UCHAR + duration*: WORD + frmr_recv*: WORD + frmr_xmit*: WORD + iframe_recv_err*: WORD + xmit_aborts*: WORD + xmit_success*: DWORD + recv_success*: DWORD + iframe_xmit_err*: WORD + recv_buff_unavail*: WORD + t1_timeouts*: WORD + ti_timeouts*: WORD + reserved1*: DWORD + free_ncbs*: WORD + max_cfg_ncbs*: WORD + max_ncbs*: WORD + xmit_buf_unavail*: WORD + max_dgram_size*: WORD + pending_sess*: WORD + max_cfg_sess*: WORD + max_sess*: WORD + max_sess_pkt_size*: WORD + name_count*: WORD + PADAPTER_STATUS* = ptr ADAPTER_STATUS + NAME_BUFFER* {.pure.} = object + name*: array[NCBNAMSZ, UCHAR] + name_num*: UCHAR + name_flags*: UCHAR + PNAME_BUFFER* = ptr NAME_BUFFER + SESSION_HEADER* {.pure.} = object + sess_name*: UCHAR + num_sess*: UCHAR + rcv_dg_outstanding*: UCHAR + rcv_any_outstanding*: UCHAR + PSESSION_HEADER* = ptr SESSION_HEADER + SESSION_BUFFER* {.pure.} = object + lsn*: UCHAR + state*: UCHAR + local_name*: array[NCBNAMSZ, UCHAR] + remote_name*: array[NCBNAMSZ, UCHAR] + rcvs_outstanding*: UCHAR + sends_outstanding*: UCHAR + PSESSION_BUFFER* = ptr SESSION_BUFFER +const + MAX_LANA* = 254 +type + LANA_ENUM* {.pure.} = object + length*: UCHAR + lana*: array[MAX_LANA+1, UCHAR] + PLANA_ENUM* = ptr LANA_ENUM + FIND_NAME_HEADER* {.pure.} = object + node_count*: WORD + reserved*: UCHAR + unique_group*: UCHAR + PFIND_NAME_HEADER* = ptr FIND_NAME_HEADER + FIND_NAME_BUFFER* {.pure.} = object + length*: UCHAR + access_control*: UCHAR + frame_control*: UCHAR + destination_addr*: array[6, UCHAR] + source_addr*: array[6, UCHAR] + routing_info*: array[18, UCHAR] + PFIND_NAME_BUFFER* = ptr FIND_NAME_BUFFER + ACTION_HEADER* {.pure.} = object + transport_id*: ULONG + action_code*: USHORT + reserved*: USHORT + PACTION_HEADER* = ptr ACTION_HEADER +const + NAME_FLAGS_MASK* = 0x87 + GROUP_NAME* = 0x80 + UNIQUE_NAME* = 0x00 + REGISTERING* = 0x00 + REGISTERED* = 0x04 + DEREGISTERED* = 0x05 + DUPLICATE* = 0x06 + DUPLICATE_DEREG* = 0x07 + LISTEN_OUTSTANDING* = 0x01 + CALL_PENDING* = 0x02 + SESSION_ESTABLISHED* = 0x03 + HANGUP_PENDING* = 0x04 + HANGUP_COMPLETE* = 0x05 + SESSION_ABORTED* = 0x06 + ALL_TRANSPORTS* = "M\0\0\0" + MS_NBF* = "MNBF" + NCBCALL* = 0x10 + NCBLISTEN* = 0x11 + NCBHANGUP* = 0x12 + NCBSEND* = 0x14 + NCBRECV* = 0x15 + NCBRECVANY* = 0x16 + NCBCHAINSEND* = 0x17 + NCBDGSEND* = 0x20 + NCBDGRECV* = 0x21 + NCBDGSENDBC* = 0x22 + NCBDGRECVBC* = 0x23 + NCBADDNAME* = 0x30 + NCBDELNAME* = 0x31 + NCBRESET* = 0x32 + NCBASTAT* = 0x33 + NCBSSTAT* = 0x34 + NCBCANCEL* = 0x35 + NCBADDGRNAME* = 0x36 + NCBENUM* = 0x37 + NCBUNLINK* = 0x70 + NCBSENDNA* = 0x71 + NCBCHAINSENDNA* = 0x72 + NCBLANSTALERT* = 0x73 + NCBACTION* = 0x77 + NCBFINDNAME* = 0x78 + NCBTRACE* = 0x79 + ASYNCH* = 0x80 + NRC_GOODRET* = 0x00 + NRC_BUFLEN* = 0x01 + NRC_ILLCMD* = 0x03 + NRC_CMDTMO* = 0x05 + NRC_INCOMP* = 0x06 + NRC_BADDR* = 0x07 + NRC_SNUMOUT* = 0x08 + NRC_NORES* = 0x09 + NRC_SCLOSED* = 0x0a + NRC_CMDCAN* = 0x0b + NRC_DUPNAME* = 0x0d + NRC_NAMTFUL* = 0x0e + NRC_ACTSES* = 0x0f + NRC_LOCTFUL* = 0x11 + NRC_REMTFUL* = 0x12 + NRC_ILLNN* = 0x13 + NRC_NOCALL* = 0x14 + NRC_NOWILD* = 0x15 + NRC_INUSE* = 0x16 + NRC_NAMERR* = 0x17 + NRC_SABORT* = 0x18 + NRC_NAMCONF* = 0x19 + NRC_IFBUSY* = 0x21 + NRC_TOOMANY* = 0x22 + NRC_BRIDGE* = 0x23 + NRC_CANOCCR* = 0x24 + NRC_CANCEL* = 0x26 + NRC_DUPENV* = 0x30 + NRC_ENVNOTDEF* = 0x34 + NRC_OSRESNOTAV* = 0x35 + NRC_MAXAPPS* = 0x36 + NRC_NOSAPS* = 0x37 + NRC_NORESOURCES* = 0x38 + NRC_INVADDRESS* = 0x39 + NRC_INVDDID* = 0x3B + NRC_LOCKFAIL* = 0x3C + NRC_OPENERR* = 0x3f + NRC_SYSTEM* = 0x40 + NRC_PENDING* = 0xff +proc Netbios*(pncb: PNCB): UCHAR {.winapi, stdcall, dynlib: "netapi32", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/objbase.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/objbase.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,10091 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import winbase +import wingdi +import winuser +import winsock +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + REGCLS* = int32 + COINITBASE* = int32 + DVASPECT* = int32 + STGC* = int32 + STGMOVE* = int32 + STATFLAG* = int32 + VARTYPE* = uint16 + VARENUM* = int32 + TYSPEC* = int32 + EXTCONN* = int32 + STGTY* = int32 + STREAM_SEEK* = int32 + LOCKTYPE* = int32 + EOLE_AUTHENTICATION_CAPABILITIES* = int32 + RPCOPT_PROPERTIES* = int32 + RPCOPT_SERVER_LOCALITY_VALUES* = int32 + GLOBALOPT_PROPERTIES* = int32 + GLOBALOPT_EH_VALUES* = int32 + GLOBALOPT_RPCTP_VALUES* = int32 + GLOBALOPT_RO_FLAGS* = int32 + GLOBALOPT_UNMARSHALING_POLICY_VALUES* = int32 + DCOM_CALL_STATE* = int32 + APTTYPEQUALIFIER* = int32 + APTTYPE* = int32 + THDTYPE* = int32 + CO_MARSHALING_CONTEXT_ATTRIBUTES* = int32 + BIND_FLAGS* = int32 + MKSYS* = int32 + MKRREDUCE* = int32 + ADVF* = int32 + TYMED* = int32 + DATADIR* = int32 + CALLTYPE* = int32 + SERVERCALL* = int32 + PENDINGTYPE* = int32 + PENDINGMSG* = int32 + ApplicationType* = int32 + ShutdownType* = int32 + SF_TYPE* = int32 + TYPEKIND* = int32 + CALLCONV* = int32 + FUNCKIND* = int32 + INVOKEKIND* = int32 + VARKIND* = int32 + TYPEFLAGS* = int32 + FUNCFLAGS* = int32 + VARFLAGS* = int32 + DESCKIND* = int32 + SYSKIND* = int32 + LIBFLAGS* = int32 + CHANGEKIND* = int32 + REGKIND* = int32 + OLEGETMONIKER* = int32 + OLEWHICHMK* = int32 + USERCLASSTYPE* = int32 + OLEMISC* = int32 + OLECLOSE* = int32 + OLERENDER* = int32 + OLEUPDATE* = int32 + OLELINKBIND* = int32 + BINDSPEED* = int32 + OLECONTF* = int32 + OLEVERBATTRIB* = int32 + MEMCTX* = int32 + CLSCTX* = int32 + MSHLFLAGS* = int32 + MSHCTX* = int32 + STDMSHLFLAGS* = int32 + COWAIT_FLAGS* = int32 + CWMO_FLAGS* = int32 + COINIT* = int32 + COMSD* = int32 + DOMNodeType* = int32 + XMLELEM_TYPE* = int32 + MONIKERPROPERTY* = int32 + BINDVERB* = int32 + BINDINFOF* = int32 + BINDF* = int32 + URL_ENCODING* = int32 + BINDINFO_OPTIONS* = int32 + BSCF* = int32 + BINDSTATUS* = int32 + BINDF2* = int32 + AUTHENTICATEF* = int32 + CIP_STATUS* = int32 + Uri_PROPERTY* = int32 + Uri_HOST_TYPE* = int32 + BINDSTRING* = int32 + PI_FLAGS* = int32 + OIBDG_FLAGS* = int32 + PARSEACTION* = int32 + PSUACTION* = int32 + QUERYOPTION* = int32 + INTERNETFEATURELIST* = int32 + PUAF* = int32 + PUAFOUT* = int32 + SZM_FLAGS* = int32 + URLZONE* = int32 + URLTEMPLATE* = int32 + ZAFLAGS* = int32 + URLZONEREG* = int32 + BINDHANDLETYPES* = int32 + PIDMSI_STATUS_VALUE* = int32 + UASFLAGS* = int32 + READYSTATE* = int32 + GUIDKIND* = int32 + CTRLINFO* = int32 + XFORMCOORDS* = int32 + PROPPAGESTATUS* = int32 + PICTUREATTRIBUTES* = int32 + ACTIVATEFLAGS* = int32 + OLEDCFLAGS* = int32 + VIEWSTATUS* = int32 + HITRESULT* = int32 + DVASPECT2* = int32 + DVEXTENTMODE* = int32 + DVASPECTINFOFLAG* = int32 + POINTERINACTIVE* = int32 + PROPBAG2_TYPE* = int32 + QACONTAINERFLAGS* = int32 + STRRET_TYPE* = int32 + PERCEIVED* = int32 + SHCOLSTATE* = int32 + DEVICE_SCALE_FACTOR* = int32 + DOCMISC* = int32 + PRINTFLAG* = int32 + OLECMDF* = int32 + OLECMDTEXTF* = int32 + OLECMDEXECOPT* = int32 + OLECMDID* = int32 + MEDIAPLAYBACK_STATE* = int32 + IGNOREMIME* = int32 + WPCSETTING* = int32 + OLECMDID_REFRESHFLAG* = int32 + OLECMDID_PAGEACTIONFLAG* = int32 + OLECMDID_BROWSERSTATEFLAG* = int32 + OLECMDID_OPTICAL_ZOOMFLAG* = int32 + PAGEACTION_UI* = int32 + OLECMDID_WINDOWSTATE_FLAG* = int32 + OLECMDID_VIEWPORT_MODE_FLAG* = int32 + BrowserNavConstants* = int32 + RefreshConstants* = int32 + CommandStateChangeConstants* = int32 + SecureLockIconConstants* = int32 + ShellWindowTypeConstants* = int32 + ShellWindowFindWindowOptions* = int32 + CONDITION_TYPE* = int32 + CONDITION_OPERATION* = int32 + GETPROPERTYSTOREFLAGS* = int32 + PKA_FLAGS* = int32 + PSC_STATE* = int32 + PROPENUMTYPE* = int32 + PROPDESC_TYPE_FLAGS* = int32 + PROPDESC_VIEW_FLAGS* = int32 + PROPDESC_DISPLAYTYPE* = int32 + PROPDESC_GROUPING_RANGE* = int32 + PROPDESC_FORMAT_FLAGS* = int32 + PROPDESC_SORTDESCRIPTION* = int32 + PROPDESC_RELATIVEDESCRIPTION_TYPE* = int32 + PROPDESC_AGGREGATION_TYPE* = int32 + PROPDESC_CONDITION_TYPE* = int32 + PROPDESC_SEARCHINFO_FLAGS* = int32 + PROPDESC_COLUMNINDEX_TYPE* = int32 + PROPDESC_ENUMFILTER* = int32 + PERSIST_SPROPSTORE_FLAGS* = int32 + hyper* = int64 + CLIPFORMAT* = WORD + PROPID* = ULONG + RPCOLEDATAREP* = ULONG + CPFLAGS* = DWORD + APARTMENTID* = DWORD + DISPID* = LONG + HREFTYPE* = DWORD + SCODE* = LONG + CO_MTA_USAGE_COOKIE* = HANDLE + STGFMT* = DWORD + PROPVAR_PAD1* = WORD + PROPVAR_PAD2* = WORD + PROPVAR_PAD3* = WORD + OLE_XPOS_HIMETRIC* = LONG + OLE_YPOS_HIMETRIC* = LONG + OLE_XSIZE_HIMETRIC* = LONG + OLE_YSIZE_HIMETRIC* = LONG + HHANDLE* = UINT_PTR + OLE_COLOR* = DWORD + PERCEIVEDFLAG* = DWORD + KF_REDIRECT_FLAGS* = DWORD + SHCOLSTATEF* = DWORD + RPC_AUTH_IDENTITY_HANDLE* = HANDLE + RPC_AUTHZ_HANDLE* = HANDLE + HCONTEXT* = HANDLE + HMETAFILEPICT* = HANDLE + userCLIPFORMAT_u* {.pure, union.} = object + dwValue*: DWORD + pwszName*: ptr uint16 + userCLIPFORMAT* {.pure.} = object + fContext*: LONG + u*: userCLIPFORMAT_u + wireCLIPFORMAT* = ptr userCLIPFORMAT + FLAGGED_BYTE_BLOB* {.pure.} = object + fFlags*: ULONG + clSize*: ULONG + abData*: array[1, uint8] + userHGLOBAL_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr FLAGGED_BYTE_BLOB + hInproc64*: INT64 + userHGLOBAL* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHGLOBAL_u + wireHGLOBAL* = ptr userHGLOBAL + RemotableHandle_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: LONG + RemotableHandle* {.pure.} = object + fContext*: LONG + u*: RemotableHandle_u + wireHWND* = ptr RemotableHandle + wireHMENU* = ptr RemotableHandle + wireHACCEL* = ptr RemotableHandle + wireHBRUSH* = ptr RemotableHandle + wireHFONT* = ptr RemotableHandle + wireHDC* = ptr RemotableHandle + wireHICON* = ptr RemotableHandle + wireHRGN* = ptr RemotableHandle + wireHMONITOR* = ptr RemotableHandle + userBITMAP* {.pure.} = object + bmType*: LONG + bmWidth*: LONG + bmHeight*: LONG + bmWidthBytes*: LONG + bmPlanes*: WORD + bmBitsPixel*: WORD + cbSize*: ULONG + pBuffer*: array[1, uint8] + userHBITMAP_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr userBITMAP + hInproc64*: INT64 + userHBITMAP* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHBITMAP_u + wireHBITMAP* = ptr userHBITMAP + userHPALETTE_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr LOGPALETTE + hInproc64*: INT64 + userHPALETTE* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHPALETTE_u + wireHPALETTE* = ptr userHPALETTE + BYTE_BLOB* {.pure.} = object + clSize*: ULONG + abData*: array[1, uint8] + userHENHMETAFILE_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr BYTE_BLOB + hInproc64*: INT64 + userHENHMETAFILE* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHENHMETAFILE_u + wireHENHMETAFILE* = ptr userHENHMETAFILE + userHMETAFILE_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr BYTE_BLOB + hInproc64*: INT64 + userHMETAFILE* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHMETAFILE_u + wireHMETAFILE* = ptr userHMETAFILE + remoteMETAFILEPICT* {.pure.} = object + mm*: LONG + xExt*: LONG + yExt*: LONG + hMF*: ptr userHMETAFILE + userHMETAFILEPICT_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr remoteMETAFILEPICT + hInproc64*: INT64 + userHMETAFILEPICT* {.pure.} = object + fContext*: LONG + padding*: array[4, byte] + u*: userHMETAFILEPICT_u + wireHMETAFILEPICT* = ptr userHMETAFILEPICT + DATE* = float64 + CY_STRUCT1* {.pure.} = object + Lo*: int32 + Hi*: int32 + CY* {.pure, union.} = object + struct1*: CY_STRUCT1 + int64*: LONGLONG + LPCY* = ptr CY + DECIMAL_UNION1_STRUCT1* {.pure.} = object + scale*: BYTE + sign*: BYTE + DECIMAL_UNION1* {.pure, union.} = object + struct1*: DECIMAL_UNION1_STRUCT1 + signscale*: USHORT + DECIMAL_UNION2_STRUCT1* {.pure.} = object + Lo32*: ULONG + Mid32*: ULONG + DECIMAL_UNION2* {.pure, union.} = object + struct1*: DECIMAL_UNION2_STRUCT1 + Lo64*: ULONGLONG + DECIMAL* {.pure.} = object + wReserved*: USHORT + union1*: DECIMAL_UNION1 + Hi32*: ULONG + union2*: DECIMAL_UNION2 + LPDECIMAL* = ptr DECIMAL + FLAGGED_WORD_BLOB* {.pure.} = object + fFlags*: ULONG + clSize*: ULONG + asData*: array[1, uint16] + wireBSTR* = ptr FLAGGED_WORD_BLOB + LPBSTR* = ptr BSTR + VARIANT_BOOL* = int16 + BSTRBLOB* {.pure.} = object + cbSize*: ULONG + pData*: ptr BYTE + LPBSTRBLOB* = ptr BSTRBLOB + IUnknown* {.pure.} = object + lpVtbl*: ptr IUnknownVtbl + IUnknownVtbl* {.pure, inheritable.} = object + QueryInterface*: proc(self: ptr IUnknown, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + AddRef*: proc(self: ptr IUnknown): ULONG {.stdcall.} + Release*: proc(self: ptr IUnknown): ULONG {.stdcall.} + LPUNKNOWN* = ptr IUnknown + IClassFactory* {.pure.} = object + lpVtbl*: ptr IClassFactoryVtbl + IClassFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateInstance*: proc(self: ptr IClassFactory, pUnkOuter: ptr IUnknown, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + LockServer*: proc(self: ptr IClassFactory, fLock: WINBOOL): HRESULT {.stdcall.} + LPCLASSFACTORY* = ptr IClassFactory + ISequentialStream* {.pure.} = object + lpVtbl*: ptr ISequentialStreamVtbl + ISequentialStreamVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Read*: proc(self: ptr ISequentialStream, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.stdcall.} + Write*: proc(self: ptr ISequentialStream, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.stdcall.} + LPOLESTR* = ptr OLECHAR + STATSTG* {.pure.} = object + pwcsName*: LPOLESTR + `type`*: DWORD + cbSize*: ULARGE_INTEGER + mtime*: FILETIME + ctime*: FILETIME + atime*: FILETIME + grfMode*: DWORD + grfLocksSupported*: DWORD + clsid*: CLSID + grfStateBits*: DWORD + reserved*: DWORD + IStream* {.pure.} = object + lpVtbl*: ptr IStreamVtbl + IStreamVtbl* {.pure, inheritable.} = object of ISequentialStreamVtbl + Seek*: proc(self: ptr IStream, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ptr ULARGE_INTEGER): HRESULT {.stdcall.} + SetSize*: proc(self: ptr IStream, libNewSize: ULARGE_INTEGER): HRESULT {.stdcall.} + CopyTo*: proc(self: ptr IStream, pstm: ptr IStream, cb: ULARGE_INTEGER, pcbRead: ptr ULARGE_INTEGER, pcbWritten: ptr ULARGE_INTEGER): HRESULT {.stdcall.} + Commit*: proc(self: ptr IStream, grfCommitFlags: DWORD): HRESULT {.stdcall.} + Revert*: proc(self: ptr IStream): HRESULT {.stdcall.} + LockRegion*: proc(self: ptr IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.stdcall.} + UnlockRegion*: proc(self: ptr IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.stdcall.} + Stat*: proc(self: ptr IStream, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.stdcall.} + Clone*: proc(self: ptr IStream, ppstm: ptr ptr IStream): HRESULT {.stdcall.} + IMarshal* {.pure.} = object + lpVtbl*: ptr IMarshalVtbl + IMarshalVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetUnmarshalClass*: proc(self: ptr IMarshal, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD, pCid: ptr CLSID): HRESULT {.stdcall.} + GetMarshalSizeMax*: proc(self: ptr IMarshal, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD, pSize: ptr DWORD): HRESULT {.stdcall.} + MarshalInterface*: proc(self: ptr IMarshal, pStm: ptr IStream, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD): HRESULT {.stdcall.} + UnmarshalInterface*: proc(self: ptr IMarshal, pStm: ptr IStream, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + ReleaseMarshalData*: proc(self: ptr IMarshal, pStm: ptr IStream): HRESULT {.stdcall.} + DisconnectObject*: proc(self: ptr IMarshal, dwReserved: DWORD): HRESULT {.stdcall.} + LPMARSHAL* = ptr IMarshal + IMarshal2* {.pure.} = object + lpVtbl*: ptr IMarshal2Vtbl + IMarshal2Vtbl* {.pure, inheritable.} = object of IMarshalVtbl + LPMARSHAL2* = ptr IMarshal2 + IMalloc* {.pure.} = object + lpVtbl*: ptr IMallocVtbl + IMallocVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Alloc*: proc(self: ptr IMalloc, cb: SIZE_T): pointer {.stdcall.} + Realloc*: proc(self: ptr IMalloc, pv: pointer, cb: SIZE_T): pointer {.stdcall.} + Free*: proc(self: ptr IMalloc, pv: pointer): void {.stdcall.} + GetSize*: proc(self: ptr IMalloc, pv: pointer): SIZE_T {.stdcall.} + DidAlloc*: proc(self: ptr IMalloc, pv: pointer): int32 {.stdcall.} + HeapMinimize*: proc(self: ptr IMalloc): void {.stdcall.} + LPMALLOC* = ptr IMalloc + IStdMarshalInfo* {.pure.} = object + lpVtbl*: ptr IStdMarshalInfoVtbl + IStdMarshalInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClassForHandler*: proc(self: ptr IStdMarshalInfo, dwDestContext: DWORD, pvDestContext: pointer, pClsid: ptr CLSID): HRESULT {.stdcall.} + LPSTDMARSHALINFO* = ptr IStdMarshalInfo + IExternalConnection* {.pure.} = object + lpVtbl*: ptr IExternalConnectionVtbl + IExternalConnectionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddConnection*: proc(self: ptr IExternalConnection, extconn: DWORD, reserved: DWORD): DWORD {.stdcall.} + ReleaseConnection*: proc(self: ptr IExternalConnection, extconn: DWORD, reserved: DWORD, fLastReleaseCloses: WINBOOL): DWORD {.stdcall.} + LPEXTERNALCONNECTION* = ptr IExternalConnection + MULTI_QI* {.pure.} = object + pIID*: ptr IID + pItf*: ptr IUnknown + hr*: HRESULT + IMultiQI* {.pure.} = object + lpVtbl*: ptr IMultiQIVtbl + IMultiQIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryMultipleInterfaces*: proc(self: ptr IMultiQI, cMQIs: ULONG, pMQIs: ptr MULTI_QI): HRESULT {.stdcall.} + LPMULTIQI* = ptr IMultiQI + IEnumUnknown* {.pure.} = object + lpVtbl*: ptr IEnumUnknownVtbl + IEnumUnknownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumUnknown, celt: ULONG, rgelt: ptr ptr IUnknown, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumUnknown, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumUnknown): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumUnknown, ppenum: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + LPENUMUNKNOWN* = ptr IEnumUnknown + IEnumString* {.pure.} = object + lpVtbl*: ptr IEnumStringVtbl + IEnumStringVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumString, celt: ULONG, rgelt: ptr LPOLESTR, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumString, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumString): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumString, ppenum: ptr ptr IEnumString): HRESULT {.stdcall.} + LPENUMSTRING* = ptr IEnumString + LPSTREAM* = ptr IStream + RPCOLEMESSAGE* {.pure.} = object + reserved1*: pointer + dataRepresentation*: RPCOLEDATAREP + Buffer*: pointer + cbBuffer*: ULONG + iMethod*: ULONG + reserved2*: array[5, pointer] + rpcFlags*: ULONG + PRPCOLEMESSAGE* = ptr RPCOLEMESSAGE + SOLE_AUTHENTICATION_SERVICE* {.pure.} = object + dwAuthnSvc*: DWORD + dwAuthzSvc*: DWORD + pPrincipalName*: ptr OLECHAR + hr*: HRESULT + PSOLE_AUTHENTICATION_SERVICE* = ptr SOLE_AUTHENTICATION_SERVICE + SOLE_AUTHENTICATION_INFO* {.pure.} = object + dwAuthnSvc*: DWORD + dwAuthzSvc*: DWORD + pAuthInfo*: pointer + PSOLE_AUTHENTICATION_INFO* = ptr SOLE_AUTHENTICATION_INFO + SOLE_AUTHENTICATION_LIST* {.pure.} = object + cAuthInfo*: DWORD + aAuthInfo*: ptr SOLE_AUTHENTICATION_INFO + PSOLE_AUTHENTICATION_LIST* = ptr SOLE_AUTHENTICATION_LIST + ISurrogate* {.pure.} = object + lpVtbl*: ptr ISurrogateVtbl + ISurrogateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + LoadDllServer*: proc(self: ptr ISurrogate, Clsid: REFCLSID): HRESULT {.stdcall.} + FreeSurrogate*: proc(self: ptr ISurrogate): HRESULT {.stdcall.} + LPSURROGATE* = ptr ISurrogate + IGlobalInterfaceTable* {.pure.} = object + lpVtbl*: ptr IGlobalInterfaceTableVtbl + IGlobalInterfaceTableVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterInterfaceInGlobal*: proc(self: ptr IGlobalInterfaceTable, pUnk: ptr IUnknown, riid: REFIID, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + RevokeInterfaceFromGlobal*: proc(self: ptr IGlobalInterfaceTable, dwCookie: DWORD): HRESULT {.stdcall.} + GetInterfaceFromGlobal*: proc(self: ptr IGlobalInterfaceTable, dwCookie: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + LPGLOBALINTERFACETABLE* = ptr IGlobalInterfaceTable + ICancelMethodCalls* {.pure.} = object + lpVtbl*: ptr ICancelMethodCallsVtbl + ICancelMethodCallsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Cancel*: proc(self: ptr ICancelMethodCalls, ulSeconds: ULONG): HRESULT {.stdcall.} + TestCancel*: proc(self: ptr ICancelMethodCalls): HRESULT {.stdcall.} + LPCANCELMETHODCALLS* = ptr ICancelMethodCalls + IAddrTrackingControl* {.pure.} = object + lpVtbl*: ptr IAddrTrackingControlVtbl + IAddrTrackingControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnableCOMDynamicAddrTracking*: proc(self: ptr IAddrTrackingControl): HRESULT {.stdcall.} + DisableCOMDynamicAddrTracking*: proc(self: ptr IAddrTrackingControl): HRESULT {.stdcall.} + LPADDRTRACKINGCONTROL* = ptr IAddrTrackingControl + IAddrExclusionControl* {.pure.} = object + lpVtbl*: ptr IAddrExclusionControlVtbl + IAddrExclusionControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentAddrExclusionList*: proc(self: ptr IAddrExclusionControl, riid: REFIID, ppEnumerator: ptr pointer): HRESULT {.stdcall.} + UpdateAddrExclusionList*: proc(self: ptr IAddrExclusionControl, pEnumerator: ptr IUnknown): HRESULT {.stdcall.} + LPADDREXCLUSIONCONTROL* = ptr IAddrExclusionControl + ContextProperty* {.pure.} = object + policyId*: GUID + flags*: CPFLAGS + pUnk*: ptr IUnknown + IEnumContextProps* {.pure.} = object + lpVtbl*: ptr IEnumContextPropsVtbl + IEnumContextPropsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumContextProps, celt: ULONG, pContextProperties: ptr ContextProperty, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumContextProps, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumContextProps): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumContextProps, ppEnumContextProps: ptr ptr IEnumContextProps): HRESULT {.stdcall.} + Count*: proc(self: ptr IEnumContextProps, pcelt: ptr ULONG): HRESULT {.stdcall.} + LPENUMCONTEXTPROPS* = ptr IEnumContextProps + IMallocSpy* {.pure.} = object + lpVtbl*: ptr IMallocSpyVtbl + IMallocSpyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PreAlloc*: proc(self: ptr IMallocSpy, cbRequest: SIZE_T): SIZE_T {.stdcall.} + PostAlloc*: proc(self: ptr IMallocSpy, pActual: pointer): pointer {.stdcall.} + PreFree*: proc(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.stdcall.} + PostFree*: proc(self: ptr IMallocSpy, fSpyed: WINBOOL): void {.stdcall.} + PreRealloc*: proc(self: ptr IMallocSpy, pRequest: pointer, cbRequest: SIZE_T, ppNewRequest: ptr pointer, fSpyed: WINBOOL): SIZE_T {.stdcall.} + PostRealloc*: proc(self: ptr IMallocSpy, pActual: pointer, fSpyed: WINBOOL): pointer {.stdcall.} + PreGetSize*: proc(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.stdcall.} + PostGetSize*: proc(self: ptr IMallocSpy, cbActual: SIZE_T, fSpyed: WINBOOL): SIZE_T {.stdcall.} + PreDidAlloc*: proc(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.stdcall.} + PostDidAlloc*: proc(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL, fActual: int32): int32 {.stdcall.} + PreHeapMinimize*: proc(self: ptr IMallocSpy): void {.stdcall.} + PostHeapMinimize*: proc(self: ptr IMallocSpy): void {.stdcall.} + LPMALLOCSPY* = ptr IMallocSpy + BIND_OPTS* {.pure.} = object + cbStruct*: DWORD + grfFlags*: DWORD + grfMode*: DWORD + dwTickCountDeadline*: DWORD + IPersist* {.pure.} = object + lpVtbl*: ptr IPersistVtbl + IPersistVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClassID*: proc(self: ptr IPersist, pClassID: ptr CLSID): HRESULT {.stdcall.} + IPersistStream* {.pure.} = object + lpVtbl*: ptr IPersistStreamVtbl + IPersistStreamVtbl* {.pure, inheritable.} = object of IPersistVtbl + IsDirty*: proc(self: ptr IPersistStream): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistStream, pStm: ptr IStream): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistStream, pStm: ptr IStream, fClearDirty: WINBOOL): HRESULT {.stdcall.} + GetSizeMax*: proc(self: ptr IPersistStream, pcbSize: ptr ULARGE_INTEGER): HRESULT {.stdcall.} + IEnumMoniker* {.pure.} = object + lpVtbl*: ptr IEnumMonikerVtbl + IEnumMonikerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumMoniker, celt: ULONG, rgelt: ptr ptr IMoniker, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumMoniker, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumMoniker): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumMoniker, ppenum: ptr ptr IEnumMoniker): HRESULT {.stdcall.} + IMoniker* {.pure.} = object + lpVtbl*: ptr IMonikerVtbl + IMonikerVtbl* {.pure, inheritable.} = object of IPersistStreamVtbl + BindToObject*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, riidResult: REFIID, ppvResult: ptr pointer): HRESULT {.stdcall.} + BindToStorage*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, riid: REFIID, ppvObj: ptr pointer): HRESULT {.stdcall.} + Reduce*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, dwReduceHowFar: DWORD, ppmkToLeft: ptr ptr IMoniker, ppmkReduced: ptr ptr IMoniker): HRESULT {.stdcall.} + ComposeWith*: proc(self: ptr IMoniker, pmkRight: ptr IMoniker, fOnlyIfNotGeneric: WINBOOL, ppmkComposite: ptr ptr IMoniker): HRESULT {.stdcall.} + Enum*: proc(self: ptr IMoniker, fForward: WINBOOL, ppenumMoniker: ptr ptr IEnumMoniker): HRESULT {.stdcall.} + IsEqual*: proc(self: ptr IMoniker, pmkOtherMoniker: ptr IMoniker): HRESULT {.stdcall.} + Hash*: proc(self: ptr IMoniker, pdwHash: ptr DWORD): HRESULT {.stdcall.} + IsRunning*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pmkNewlyRunning: ptr IMoniker): HRESULT {.stdcall.} + GetTimeOfLastChange*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pFileTime: ptr FILETIME): HRESULT {.stdcall.} + Inverse*: proc(self: ptr IMoniker, ppmk: ptr ptr IMoniker): HRESULT {.stdcall.} + CommonPrefixWith*: proc(self: ptr IMoniker, pmkOther: ptr IMoniker, ppmkPrefix: ptr ptr IMoniker): HRESULT {.stdcall.} + RelativePathTo*: proc(self: ptr IMoniker, pmkOther: ptr IMoniker, ppmkRelPath: ptr ptr IMoniker): HRESULT {.stdcall.} + GetDisplayName*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, ppszDisplayName: ptr LPOLESTR): HRESULT {.stdcall.} + ParseDisplayName*: proc(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pszDisplayName: LPOLESTR, pchEaten: ptr ULONG, ppmkOut: ptr ptr IMoniker): HRESULT {.stdcall.} + IsSystemMoniker*: proc(self: ptr IMoniker, pdwMksys: ptr DWORD): HRESULT {.stdcall.} + IRunningObjectTable* {.pure.} = object + lpVtbl*: ptr IRunningObjectTableVtbl + IRunningObjectTableVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Register*: proc(self: ptr IRunningObjectTable, grfFlags: DWORD, punkObject: ptr IUnknown, pmkObjectName: ptr IMoniker, pdwRegister: ptr DWORD): HRESULT {.stdcall.} + Revoke*: proc(self: ptr IRunningObjectTable, dwRegister: DWORD): HRESULT {.stdcall.} + IsRunning*: proc(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker): HRESULT {.stdcall.} + GetObject*: proc(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker, ppunkObject: ptr ptr IUnknown): HRESULT {.stdcall.} + NoteChangeTime*: proc(self: ptr IRunningObjectTable, dwRegister: DWORD, pfiletime: ptr FILETIME): HRESULT {.stdcall.} + GetTimeOfLastChange*: proc(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker, pfiletime: ptr FILETIME): HRESULT {.stdcall.} + EnumRunning*: proc(self: ptr IRunningObjectTable, ppenumMoniker: ptr ptr IEnumMoniker): HRESULT {.stdcall.} + IBindCtx* {.pure.} = object + lpVtbl*: ptr IBindCtxVtbl + IBindCtxVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterObjectBound*: proc(self: ptr IBindCtx, punk: ptr IUnknown): HRESULT {.stdcall.} + RevokeObjectBound*: proc(self: ptr IBindCtx, punk: ptr IUnknown): HRESULT {.stdcall.} + ReleaseBoundObjects*: proc(self: ptr IBindCtx): HRESULT {.stdcall.} + SetBindOptions*: proc(self: ptr IBindCtx, pbindopts: ptr BIND_OPTS): HRESULT {.stdcall.} + GetBindOptions*: proc(self: ptr IBindCtx, pbindopts: ptr BIND_OPTS): HRESULT {.stdcall.} + GetRunningObjectTable*: proc(self: ptr IBindCtx, pprot: ptr ptr IRunningObjectTable): HRESULT {.stdcall.} + RegisterObjectParam*: proc(self: ptr IBindCtx, pszKey: LPOLESTR, punk: ptr IUnknown): HRESULT {.stdcall.} + GetObjectParam*: proc(self: ptr IBindCtx, pszKey: LPOLESTR, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + EnumObjectParam*: proc(self: ptr IBindCtx, ppenum: ptr ptr IEnumString): HRESULT {.stdcall.} + RevokeObjectParam*: proc(self: ptr IBindCtx, pszKey: LPOLESTR): HRESULT {.stdcall.} + LPBC* = ptr IBindCtx + LPBINDCTX* = ptr IBindCtx + LPBIND_OPTS* = ptr BIND_OPTS + COAUTHIDENTITY* {.pure.} = object + User*: ptr USHORT + UserLength*: ULONG + Domain*: ptr USHORT + DomainLength*: ULONG + Password*: ptr USHORT + PasswordLength*: ULONG + Flags*: ULONG + COAUTHINFO* {.pure.} = object + dwAuthnSvc*: DWORD + dwAuthzSvc*: DWORD + pwszServerPrincName*: LPWSTR + dwAuthnLevel*: DWORD + dwImpersonationLevel*: DWORD + pAuthIdentityData*: ptr COAUTHIDENTITY + dwCapabilities*: DWORD + COSERVERINFO* {.pure.} = object + dwReserved1*: DWORD + pwszName*: LPWSTR + pAuthInfo*: ptr COAUTHINFO + dwReserved2*: DWORD + BIND_OPTS2* {.pure.} = object + cbStruct*: DWORD + grfFlags*: DWORD + grfMode*: DWORD + dwTickCountDeadline*: DWORD + dwTrackFlags*: DWORD + dwClassContext*: DWORD + locale*: LCID + pServerInfo*: ptr COSERVERINFO + LPBIND_OPTS2* = ptr BIND_OPTS2 + BIND_OPTS3* {.pure.} = object + cbStruct*: DWORD + grfFlags*: DWORD + grfMode*: DWORD + dwTickCountDeadline*: DWORD + dwTrackFlags*: DWORD + dwClassContext*: DWORD + locale*: LCID + pServerInfo*: ptr COSERVERINFO + hwnd*: HWND + LPBIND_OPTS3* = ptr BIND_OPTS3 + LPENUMMONIKER* = ptr IEnumMoniker + IRunnableObject* {.pure.} = object + lpVtbl*: ptr IRunnableObjectVtbl + IRunnableObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRunningClass*: proc(self: ptr IRunnableObject, lpClsid: LPCLSID): HRESULT {.stdcall.} + Run*: proc(self: ptr IRunnableObject, pbc: LPBINDCTX): HRESULT {.stdcall.} + IsRunning*: proc(self: ptr IRunnableObject): WINBOOL {.stdcall.} + LockRunning*: proc(self: ptr IRunnableObject, fLock: WINBOOL, fLastUnlockCloses: WINBOOL): HRESULT {.stdcall.} + SetContainedObject*: proc(self: ptr IRunnableObject, fContained: WINBOOL): HRESULT {.stdcall.} + LPRUNNABLEOBJECT* = ptr IRunnableObject + LPRUNNINGOBJECTTABLE* = ptr IRunningObjectTable + LPPERSIST* = ptr IPersist + LPPERSISTSTREAM* = ptr IPersistStream + LPMONIKER* = ptr IMoniker + IEnumSTATSTG* {.pure.} = object + lpVtbl*: ptr IEnumSTATSTGVtbl + IEnumSTATSTGVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumSTATSTG, celt: ULONG, rgelt: ptr STATSTG, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumSTATSTG, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumSTATSTG): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumSTATSTG, ppenum: ptr ptr IEnumSTATSTG): HRESULT {.stdcall.} + LPENUMSTATSTG* = ptr IEnumSTATSTG + SNB* = ptr LPOLESTR + IStorage* {.pure.} = object + lpVtbl*: ptr IStorageVtbl + IStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateStream*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, grfMode: DWORD, reserved1: DWORD, reserved2: DWORD, ppstm: ptr ptr IStream): HRESULT {.stdcall.} + OpenStream*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, reserved1: pointer, grfMode: DWORD, reserved2: DWORD, ppstm: ptr ptr IStream): HRESULT {.stdcall.} + CreateStorage*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, grfMode: DWORD, reserved1: DWORD, reserved2: DWORD, ppstg: ptr ptr IStorage): HRESULT {.stdcall.} + OpenStorage*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, pstgPriority: ptr IStorage, grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstg: ptr ptr IStorage): HRESULT {.stdcall.} + CopyTo*: proc(self: ptr IStorage, ciidExclude: DWORD, rgiidExclude: ptr IID, snbExclude: SNB, pstgDest: ptr IStorage): HRESULT {.stdcall.} + MoveElementTo*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, pstgDest: ptr IStorage, pwcsNewName: ptr OLECHAR, grfFlags: DWORD): HRESULT {.stdcall.} + Commit*: proc(self: ptr IStorage, grfCommitFlags: DWORD): HRESULT {.stdcall.} + Revert*: proc(self: ptr IStorage): HRESULT {.stdcall.} + EnumElements*: proc(self: ptr IStorage, reserved1: DWORD, reserved2: pointer, reserved3: DWORD, ppenum: ptr ptr IEnumSTATSTG): HRESULT {.stdcall.} + DestroyElement*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR): HRESULT {.stdcall.} + RenameElement*: proc(self: ptr IStorage, pwcsOldName: ptr OLECHAR, pwcsNewName: ptr OLECHAR): HRESULT {.stdcall.} + SetElementTimes*: proc(self: ptr IStorage, pwcsName: ptr OLECHAR, pctime: ptr FILETIME, patime: ptr FILETIME, pmtime: ptr FILETIME): HRESULT {.stdcall.} + SetClass*: proc(self: ptr IStorage, clsid: REFCLSID): HRESULT {.stdcall.} + SetStateBits*: proc(self: ptr IStorage, grfStateBits: DWORD, grfMask: DWORD): HRESULT {.stdcall.} + Stat*: proc(self: ptr IStorage, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.stdcall.} + LPSTORAGE* = ptr IStorage + RemSNB* {.pure.} = object + ulCntStr*: ULONG + ulCntChar*: ULONG + rgString*: array[1, OLECHAR] + wireSNB* = ptr RemSNB + LPCOLESTR* = ptr OLECHAR + IPersistFile* {.pure.} = object + lpVtbl*: ptr IPersistFileVtbl + IPersistFileVtbl* {.pure, inheritable.} = object of IPersistVtbl + IsDirty*: proc(self: ptr IPersistFile): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistFile, pszFileName: LPCOLESTR, dwMode: DWORD): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistFile, pszFileName: LPCOLESTR, fRemember: WINBOOL): HRESULT {.stdcall.} + SaveCompleted*: proc(self: ptr IPersistFile, pszFileName: LPCOLESTR): HRESULT {.stdcall.} + GetCurFile*: proc(self: ptr IPersistFile, ppszFileName: ptr LPOLESTR): HRESULT {.stdcall.} + LPPERSISTFILE* = ptr IPersistFile + IPersistStorage* {.pure.} = object + lpVtbl*: ptr IPersistStorageVtbl + IPersistStorageVtbl* {.pure, inheritable.} = object of IPersistVtbl + IsDirty*: proc(self: ptr IPersistStorage): HRESULT {.stdcall.} + InitNew*: proc(self: ptr IPersistStorage, pStg: ptr IStorage): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistStorage, pStg: ptr IStorage): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistStorage, pStgSave: ptr IStorage, fSameAsLoad: WINBOOL): HRESULT {.stdcall.} + SaveCompleted*: proc(self: ptr IPersistStorage, pStgNew: ptr IStorage): HRESULT {.stdcall.} + HandsOffStorage*: proc(self: ptr IPersistStorage): HRESULT {.stdcall.} + LPPERSISTSTORAGE* = ptr IPersistStorage + ILockBytes* {.pure.} = object + lpVtbl*: ptr ILockBytesVtbl + ILockBytesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ReadAt*: proc(self: ptr ILockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.stdcall.} + WriteAt*: proc(self: ptr ILockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.stdcall.} + Flush*: proc(self: ptr ILockBytes): HRESULT {.stdcall.} + SetSize*: proc(self: ptr ILockBytes, cb: ULARGE_INTEGER): HRESULT {.stdcall.} + LockRegion*: proc(self: ptr ILockBytes, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.stdcall.} + UnlockRegion*: proc(self: ptr ILockBytes, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.stdcall.} + Stat*: proc(self: ptr ILockBytes, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.stdcall.} + LPLOCKBYTES* = ptr ILockBytes + DVTARGETDEVICE* {.pure.} = object + tdSize*: DWORD + tdDriverNameOffset*: WORD + tdDeviceNameOffset*: WORD + tdPortNameOffset*: WORD + tdExtDevmodeOffset*: WORD + tdData*: array[1, BYTE] + FORMATETC* {.pure.} = object + cfFormat*: CLIPFORMAT + ptd*: ptr DVTARGETDEVICE + dwAspect*: DWORD + lindex*: LONG + tymed*: DWORD + IEnumFORMATETC* {.pure.} = object + lpVtbl*: ptr IEnumFORMATETCVtbl + IEnumFORMATETCVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumFORMATETC, celt: ULONG, rgelt: ptr FORMATETC, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumFORMATETC, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumFORMATETC): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumFORMATETC, ppenum: ptr ptr IEnumFORMATETC): HRESULT {.stdcall.} + LPENUMFORMATETC* = ptr IEnumFORMATETC + LPCLIPFORMAT* = ptr CLIPFORMAT + LPFORMATETC* = ptr FORMATETC + uSTGMEDIUM_u* {.pure, union.} = object + hBitmap*: HBITMAP + hMetaFilePict*: HMETAFILEPICT + hEnhMetaFile*: HENHMETAFILE + hGlobal*: HGLOBAL + lpszFileName*: LPOLESTR + pstm*: ptr IStream + pstg*: ptr IStorage + uSTGMEDIUM* {.pure.} = object + tymed*: DWORD + u*: uSTGMEDIUM_u + pUnkForRelease*: ptr IUnknown + STGMEDIUM* = uSTGMEDIUM + IAdviseSink* {.pure.} = object + lpVtbl*: ptr IAdviseSinkVtbl + IAdviseSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnDataChange*: proc(self: ptr IAdviseSink, pFormatetc: ptr FORMATETC, pStgmed: ptr STGMEDIUM): void {.stdcall.} + OnViewChange*: proc(self: ptr IAdviseSink, dwAspect: DWORD, lindex: LONG): void {.stdcall.} + OnRename*: proc(self: ptr IAdviseSink, pmk: ptr IMoniker): void {.stdcall.} + OnSave*: proc(self: ptr IAdviseSink): void {.stdcall.} + OnClose*: proc(self: ptr IAdviseSink): void {.stdcall.} + STATDATA* {.pure.} = object + formatetc*: FORMATETC + advf*: DWORD + pAdvSink*: ptr IAdviseSink + dwConnection*: DWORD + IEnumSTATDATA* {.pure.} = object + lpVtbl*: ptr IEnumSTATDATAVtbl + IEnumSTATDATAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumSTATDATA, celt: ULONG, rgelt: ptr STATDATA, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumSTATDATA, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumSTATDATA): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumSTATDATA, ppenum: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + LPENUMSTATDATA* = ptr IEnumSTATDATA + LPSTATDATA* = ptr STATDATA + IRootStorage* {.pure.} = object + lpVtbl*: ptr IRootStorageVtbl + IRootStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SwitchToFile*: proc(self: ptr IRootStorage, pszFile: LPOLESTR): HRESULT {.stdcall.} + LPROOTSTORAGE* = ptr IRootStorage + LPADVISESINK* = ptr IAdviseSink + GDI_OBJECT_u* {.pure, union.} = object + hBitmap*: wireHBITMAP + hPalette*: wireHPALETTE + hGeneric*: wireHGLOBAL + GDI_OBJECT* {.pure.} = object + ObjectType*: DWORD + u*: GDI_OBJECT_u + userSTGMEDIUM_STRUCT1_u* {.pure, union.} = object + hMetaFilePict*: wireHMETAFILEPICT + hHEnhMetaFile*: wireHENHMETAFILE + hGdiHandle*: ptr GDI_OBJECT + hGlobal*: wireHGLOBAL + lpszFileName*: LPOLESTR + pstm*: ptr BYTE_BLOB + pstg*: ptr BYTE_BLOB + userSTGMEDIUM_STRUCT1* {.pure.} = object + tymed*: DWORD + u*: userSTGMEDIUM_STRUCT1_u + userSTGMEDIUM* {.pure.} = object + struct1*: userSTGMEDIUM_STRUCT1 + pUnkForRelease*: ptr IUnknown + wireSTGMEDIUM* = ptr userSTGMEDIUM + wireASYNC_STGMEDIUM* = ptr userSTGMEDIUM + ASYNC_STGMEDIUM* = STGMEDIUM + LPSTGMEDIUM* = ptr STGMEDIUM + userFLAG_STGMEDIUM* {.pure.} = object + ContextFlags*: LONG + fPassOwnership*: LONG + Stgmed*: userSTGMEDIUM + wireFLAG_STGMEDIUM* = ptr userFLAG_STGMEDIUM + IAdviseSink2* {.pure.} = object + lpVtbl*: ptr IAdviseSink2Vtbl + IAdviseSink2Vtbl* {.pure, inheritable.} = object of IAdviseSinkVtbl + OnLinkSrcChange*: proc(self: ptr IAdviseSink2, pmk: ptr IMoniker): void {.stdcall.} + LPADVISESINK2* = ptr IAdviseSink2 + IDataObject* {.pure.} = object + lpVtbl*: ptr IDataObjectVtbl + IDataObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetData*: proc(self: ptr IDataObject, pformatetcIn: ptr FORMATETC, pmedium: ptr STGMEDIUM): HRESULT {.stdcall.} + GetDataHere*: proc(self: ptr IDataObject, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM): HRESULT {.stdcall.} + QueryGetData*: proc(self: ptr IDataObject, pformatetc: ptr FORMATETC): HRESULT {.stdcall.} + GetCanonicalFormatEtc*: proc(self: ptr IDataObject, pformatectIn: ptr FORMATETC, pformatetcOut: ptr FORMATETC): HRESULT {.stdcall.} + SetData*: proc(self: ptr IDataObject, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM, fRelease: WINBOOL): HRESULT {.stdcall.} + EnumFormatEtc*: proc(self: ptr IDataObject, dwDirection: DWORD, ppenumFormatEtc: ptr ptr IEnumFORMATETC): HRESULT {.stdcall.} + DAdvise*: proc(self: ptr IDataObject, pformatetc: ptr FORMATETC, advf: DWORD, pAdvSink: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.stdcall.} + DUnadvise*: proc(self: ptr IDataObject, dwConnection: DWORD): HRESULT {.stdcall.} + EnumDAdvise*: proc(self: ptr IDataObject, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + LPDATAOBJECT* = ptr IDataObject + IDataAdviseHolder* {.pure.} = object + lpVtbl*: ptr IDataAdviseHolderVtbl + IDataAdviseHolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr IDataAdviseHolder, pDataObject: ptr IDataObject, pFetc: ptr FORMATETC, advf: DWORD, pAdvise: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IDataAdviseHolder, dwConnection: DWORD): HRESULT {.stdcall.} + EnumAdvise*: proc(self: ptr IDataAdviseHolder, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + SendOnDataChange*: proc(self: ptr IDataAdviseHolder, pDataObject: ptr IDataObject, dwReserved: DWORD, advf: DWORD): HRESULT {.stdcall.} + LPDATAADVISEHOLDER* = ptr IDataAdviseHolder + INTERFACEINFO* {.pure.} = object + pUnk*: ptr IUnknown + iid*: IID + wMethod*: WORD + LPINTERFACEINFO* = ptr INTERFACEINFO + IMessageFilter* {.pure.} = object + lpVtbl*: ptr IMessageFilterVtbl + IMessageFilterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleInComingCall*: proc(self: ptr IMessageFilter, dwCallType: DWORD, htaskCaller: HTASK, dwTickCount: DWORD, lpInterfaceInfo: LPINTERFACEINFO): DWORD {.stdcall.} + RetryRejectedCall*: proc(self: ptr IMessageFilter, htaskCallee: HTASK, dwTickCount: DWORD, dwRejectType: DWORD): DWORD {.stdcall.} + MessagePending*: proc(self: ptr IMessageFilter, htaskCallee: HTASK, dwTickCount: DWORD, dwPendingType: DWORD): DWORD {.stdcall.} + LPMESSAGEFILTER* = ptr IMessageFilter + IInitializeSpy* {.pure.} = object + lpVtbl*: ptr IInitializeSpyVtbl + IInitializeSpyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PreInitialize*: proc(self: ptr IInitializeSpy, dwCoInit: DWORD, dwCurThreadAptRefs: DWORD): HRESULT {.stdcall.} + PostInitialize*: proc(self: ptr IInitializeSpy, hrCoInit: HRESULT, dwCoInit: DWORD, dwNewThreadAptRefs: DWORD): HRESULT {.stdcall.} + PreUninitialize*: proc(self: ptr IInitializeSpy, dwCurThreadAptRefs: DWORD): HRESULT {.stdcall.} + PostUninitialize*: proc(self: ptr IInitializeSpy, dwNewThreadAptRefs: DWORD): HRESULT {.stdcall.} + LPINITIALIZESPY* = ptr IInitializeSpy + CURRENCY* = CY + SAFEARRAYBOUND* {.pure.} = object + cElements*: ULONG + lLbound*: LONG + LPSAFEARRAYBOUND* = ptr SAFEARRAYBOUND + SAFEARR_BSTR* {.pure.} = object + Size*: ULONG + aBstr*: ptr wireBSTR + SAFEARR_UNKNOWN* {.pure.} = object + Size*: ULONG + apUnknown*: ptr ptr IUnknown + MEMBERID* = DISPID + ARRAYDESC* {.pure.} = object + tdescElem*: TYPEDESC + cDims*: USHORT + rgbounds*: array[1, SAFEARRAYBOUND] + TYPEDESC_UNION1* {.pure, union.} = object + lptdesc*: ptr TYPEDESC + lpadesc*: ptr ARRAYDESC + hreftype*: HREFTYPE + TYPEDESC* {.pure.} = object + union1*: TYPEDESC_UNION1 + vt*: VARTYPE + IDLDESC* {.pure.} = object + dwReserved*: ULONG_PTR + wIDLFlags*: USHORT + TYPEATTR* {.pure.} = object + guid*: GUID + lcid*: LCID + dwReserved*: DWORD + memidConstructor*: MEMBERID + memidDestructor*: MEMBERID + lpstrSchema*: LPOLESTR + cbSizeInstance*: ULONG + typekind*: TYPEKIND + cFuncs*: WORD + cVars*: WORD + cImplTypes*: WORD + cbSizeVft*: WORD + cbAlignment*: WORD + wTypeFlags*: WORD + wMajorVerNum*: WORD + wMinorVerNum*: WORD + tdescAlias*: TYPEDESC + idldescType*: IDLDESC + SAFEARRAY* {.pure.} = object + cDims*: USHORT + fFeatures*: USHORT + cbElements*: ULONG + cLocks*: ULONG + pvData*: PVOID + rgsabound*: array[1, SAFEARRAYBOUND] + IRecordInfo* {.pure.} = object + lpVtbl*: ptr IRecordInfoVtbl + IRecordInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RecordInit*: proc(self: ptr IRecordInfo, pvNew: PVOID): HRESULT {.stdcall.} + RecordClear*: proc(self: ptr IRecordInfo, pvExisting: PVOID): HRESULT {.stdcall.} + RecordCopy*: proc(self: ptr IRecordInfo, pvExisting: PVOID, pvNew: PVOID): HRESULT {.stdcall.} + GetGuid*: proc(self: ptr IRecordInfo, pguid: ptr GUID): HRESULT {.stdcall.} + GetName*: proc(self: ptr IRecordInfo, pbstrName: ptr BSTR): HRESULT {.stdcall.} + GetSize*: proc(self: ptr IRecordInfo, pcbSize: ptr ULONG): HRESULT {.stdcall.} + GetTypeInfo*: proc(self: ptr IRecordInfo, ppTypeInfo: ptr ptr ITypeInfo): HRESULT {.stdcall.} + GetField*: proc(self: ptr IRecordInfo, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.stdcall.} + GetFieldNoCopy*: proc(self: ptr IRecordInfo, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT, ppvDataCArray: ptr PVOID): HRESULT {.stdcall.} + PutField*: proc(self: ptr IRecordInfo, wFlags: ULONG, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.stdcall.} + PutFieldNoCopy*: proc(self: ptr IRecordInfo, wFlags: ULONG, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.stdcall.} + GetFieldNames*: proc(self: ptr IRecordInfo, pcNames: ptr ULONG, rgBstrNames: ptr BSTR): HRESULT {.stdcall.} + IsMatchingType*: proc(self: ptr IRecordInfo, pRecordInfo: ptr IRecordInfo): WINBOOL {.stdcall.} + RecordCreate*: proc(self: ptr IRecordInfo): PVOID {.stdcall.} + RecordCreateCopy*: proc(self: ptr IRecordInfo, pvSource: PVOID, ppvDest: ptr PVOID): HRESULT {.stdcall.} + RecordDestroy*: proc(self: ptr IRecordInfo, pvRecord: PVOID): HRESULT {.stdcall.} + VARIANT_UNION1_STRUCT1_UNION1_STRUCT1* {.pure.} = object + pvRecord*: PVOID + pRecInfo*: ptr IRecordInfo + VARIANT_UNION1_STRUCT1_UNION1* {.pure, union.} = object + llVal*: LONGLONG + lVal*: LONG + bVal*: BYTE + iVal*: SHORT + fltVal*: FLOAT + dblVal*: DOUBLE + boolVal*: VARIANT_BOOL + scode*: SCODE + cyVal*: CY + date*: DATE + bstrVal*: BSTR + punkVal*: ptr IUnknown + pdispVal*: ptr IDispatch + parray*: ptr SAFEARRAY + pbVal*: ptr BYTE + piVal*: ptr SHORT + plVal*: ptr LONG + pllVal*: ptr LONGLONG + pfltVal*: ptr FLOAT + pdblVal*: ptr DOUBLE + pboolVal*: ptr VARIANT_BOOL + pscode*: ptr SCODE + pcyVal*: ptr CY + pdate*: ptr DATE + pbstrVal*: ptr BSTR + ppunkVal*: ptr ptr IUnknown + ppdispVal*: ptr ptr IDispatch + pparray*: ptr ptr SAFEARRAY + pvarVal*: ptr VARIANT + byref*: PVOID + cVal*: CHAR + uiVal*: USHORT + ulVal*: ULONG + ullVal*: ULONGLONG + intVal*: INT + uintVal*: UINT + pdecVal*: ptr DECIMAL + pcVal*: ptr CHAR + puiVal*: ptr USHORT + pulVal*: ptr ULONG + pullVal*: ptr ULONGLONG + pintVal*: ptr INT + puintVal*: ptr UINT + struct1*: VARIANT_UNION1_STRUCT1_UNION1_STRUCT1 + VARIANT_UNION1_STRUCT1* {.pure.} = object + vt*: VARTYPE + wReserved1*: WORD + wReserved2*: WORD + wReserved3*: WORD + union1*: VARIANT_UNION1_STRUCT1_UNION1 + VARIANT_UNION1* {.pure, union.} = object + struct1*: VARIANT_UNION1_STRUCT1 + decVal*: DECIMAL + VARIANT* {.pure.} = object + union1*: VARIANT_UNION1 + VARIANTARG* = VARIANT + PARAMDESCEX* {.pure.} = object + cBytes*: ULONG + varDefaultValue*: VARIANTARG + LPPARAMDESCEX* = ptr PARAMDESCEX + PARAMDESC* {.pure.} = object + pparamdescex*: LPPARAMDESCEX + wParamFlags*: USHORT + ELEMDESC_UNION1* {.pure, union.} = object + idldesc*: IDLDESC + paramdesc*: PARAMDESC + ELEMDESC* {.pure.} = object + tdesc*: TYPEDESC + union1*: ELEMDESC_UNION1 + FUNCDESC* {.pure.} = object + memid*: MEMBERID + lprgscode*: ptr SCODE + lprgelemdescParam*: ptr ELEMDESC + funckind*: FUNCKIND + invkind*: INVOKEKIND + callconv*: CALLCONV + cParams*: SHORT + cParamsOpt*: SHORT + oVft*: SHORT + cScodes*: SHORT + elemdescFunc*: ELEMDESC + wFuncFlags*: WORD + VARDESC_UNION1* {.pure, union.} = object + oInst*: ULONG + lpvarValue*: ptr VARIANT + VARDESC* {.pure.} = object + memid*: MEMBERID + lpstrSchema*: LPOLESTR + union1*: VARDESC_UNION1 + elemdescVar*: ELEMDESC + wVarFlags*: WORD + varkind*: VARKIND + BINDPTR* {.pure, union.} = object + lpfuncdesc*: ptr FUNCDESC + lpvardesc*: ptr VARDESC + lptcomp*: ptr ITypeComp + ITypeComp* {.pure.} = object + lpVtbl*: ptr ITypeCompVtbl + ITypeCompVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Bind*: proc(self: ptr ITypeComp, szName: LPOLESTR, lHashVal: ULONG, wFlags: WORD, ppTInfo: ptr ptr ITypeInfo, pDescKind: ptr DESCKIND, pBindPtr: ptr BINDPTR): HRESULT {.stdcall.} + BindType*: proc(self: ptr ITypeComp, szName: LPOLESTR, lHashVal: ULONG, ppTInfo: ptr ptr ITypeInfo, ppTComp: ptr ptr ITypeComp): HRESULT {.stdcall.} + DISPPARAMS* {.pure.} = object + rgvarg*: ptr VARIANTARG + rgdispidNamedArgs*: ptr DISPID + cArgs*: UINT + cNamedArgs*: UINT + EXCEPINFO* {.pure.} = object + wCode*: WORD + wReserved*: WORD + bstrSource*: BSTR + bstrDescription*: BSTR + bstrHelpFile*: BSTR + dwHelpContext*: DWORD + pvReserved*: PVOID + pfnDeferredFillIn*: proc(P1: ptr EXCEPINFO): HRESULT {.stdcall.} + scode*: SCODE + TLIBATTR* {.pure.} = object + guid*: GUID + lcid*: LCID + syskind*: SYSKIND + wMajorVerNum*: WORD + wMinorVerNum*: WORD + wLibFlags*: WORD + ITypeLib* {.pure.} = object + lpVtbl*: ptr ITypeLibVtbl + ITypeLibVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTypeInfoCount*: proc(self: ptr ITypeLib): UINT {.stdcall.} + GetTypeInfo*: proc(self: ptr ITypeLib, index: UINT, ppTInfo: ptr ptr ITypeInfo): HRESULT {.stdcall.} + GetTypeInfoType*: proc(self: ptr ITypeLib, index: UINT, pTKind: ptr TYPEKIND): HRESULT {.stdcall.} + GetTypeInfoOfGuid*: proc(self: ptr ITypeLib, guid: REFGUID, ppTinfo: ptr ptr ITypeInfo): HRESULT {.stdcall.} + GetLibAttr*: proc(self: ptr ITypeLib, ppTLibAttr: ptr ptr TLIBATTR): HRESULT {.stdcall.} + GetTypeComp*: proc(self: ptr ITypeLib, ppTComp: ptr ptr ITypeComp): HRESULT {.stdcall.} + GetDocumentation*: proc(self: ptr ITypeLib, index: INT, pBstrName: ptr BSTR, pBstrDocString: ptr BSTR, pdwHelpContext: ptr DWORD, pBstrHelpFile: ptr BSTR): HRESULT {.stdcall.} + IsName*: proc(self: ptr ITypeLib, szNameBuf: LPOLESTR, lHashVal: ULONG, pfName: ptr WINBOOL): HRESULT {.stdcall.} + FindName*: proc(self: ptr ITypeLib, szNameBuf: LPOLESTR, lHashVal: ULONG, ppTInfo: ptr ptr ITypeInfo, rgMemId: ptr MEMBERID, pcFound: ptr USHORT): HRESULT {.stdcall.} + ReleaseTLibAttr*: proc(self: ptr ITypeLib, pTLibAttr: ptr TLIBATTR): void {.stdcall.} + ITypeInfo* {.pure.} = object + lpVtbl*: ptr ITypeInfoVtbl + ITypeInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTypeAttr*: proc(self: ptr ITypeInfo, ppTypeAttr: ptr ptr TYPEATTR): HRESULT {.stdcall.} + GetTypeComp*: proc(self: ptr ITypeInfo, ppTComp: ptr ptr ITypeComp): HRESULT {.stdcall.} + GetFuncDesc*: proc(self: ptr ITypeInfo, index: UINT, ppFuncDesc: ptr ptr FUNCDESC): HRESULT {.stdcall.} + GetVarDesc*: proc(self: ptr ITypeInfo, index: UINT, ppVarDesc: ptr ptr VARDESC): HRESULT {.stdcall.} + GetNames*: proc(self: ptr ITypeInfo, memid: MEMBERID, rgBstrNames: ptr BSTR, cMaxNames: UINT, pcNames: ptr UINT): HRESULT {.stdcall.} + GetRefTypeOfImplType*: proc(self: ptr ITypeInfo, index: UINT, pRefType: ptr HREFTYPE): HRESULT {.stdcall.} + GetImplTypeFlags*: proc(self: ptr ITypeInfo, index: UINT, pImplTypeFlags: ptr INT): HRESULT {.stdcall.} + GetIDsOfNames*: proc(self: ptr ITypeInfo, rgszNames: ptr LPOLESTR, cNames: UINT, pMemId: ptr MEMBERID): HRESULT {.stdcall.} + Invoke*: proc(self: ptr ITypeInfo, pvInstance: PVOID, memid: MEMBERID, wFlags: WORD, pDispParams: ptr DISPPARAMS, pVarResult: ptr VARIANT, pExcepInfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.stdcall.} + GetDocumentation*: proc(self: ptr ITypeInfo, memid: MEMBERID, pBstrName: ptr BSTR, pBstrDocString: ptr BSTR, pdwHelpContext: ptr DWORD, pBstrHelpFile: ptr BSTR): HRESULT {.stdcall.} + GetDllEntry*: proc(self: ptr ITypeInfo, memid: MEMBERID, invKind: INVOKEKIND, pBstrDllName: ptr BSTR, pBstrName: ptr BSTR, pwOrdinal: ptr WORD): HRESULT {.stdcall.} + GetRefTypeInfo*: proc(self: ptr ITypeInfo, hRefType: HREFTYPE, ppTInfo: ptr ptr ITypeInfo): HRESULT {.stdcall.} + AddressOfMember*: proc(self: ptr ITypeInfo, memid: MEMBERID, invKind: INVOKEKIND, ppv: ptr PVOID): HRESULT {.stdcall.} + CreateInstance*: proc(self: ptr ITypeInfo, pUnkOuter: ptr IUnknown, riid: REFIID, ppvObj: ptr PVOID): HRESULT {.stdcall.} + GetMops*: proc(self: ptr ITypeInfo, memid: MEMBERID, pBstrMops: ptr BSTR): HRESULT {.stdcall.} + GetContainingTypeLib*: proc(self: ptr ITypeInfo, ppTLib: ptr ptr ITypeLib, pIndex: ptr UINT): HRESULT {.stdcall.} + ReleaseTypeAttr*: proc(self: ptr ITypeInfo, pTypeAttr: ptr TYPEATTR): void {.stdcall.} + ReleaseFuncDesc*: proc(self: ptr ITypeInfo, pFuncDesc: ptr FUNCDESC): void {.stdcall.} + ReleaseVarDesc*: proc(self: ptr ITypeInfo, pVarDesc: ptr VARDESC): void {.stdcall.} + IDispatch* {.pure.} = object + lpVtbl*: ptr IDispatchVtbl + IDispatchVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTypeInfoCount*: proc(self: ptr IDispatch, pctinfo: ptr UINT): HRESULT {.stdcall.} + GetTypeInfo*: proc(self: ptr IDispatch, iTInfo: UINT, lcid: LCID, ppTInfo: ptr ptr ITypeInfo): HRESULT {.stdcall.} + GetIDsOfNames*: proc(self: ptr IDispatch, riid: REFIID, rgszNames: ptr LPOLESTR, cNames: UINT, lcid: LCID, rgDispId: ptr DISPID): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IDispatch, dispIdMember: DISPID, riid: REFIID, lcid: LCID, wFlags: WORD, pDispParams: ptr DISPPARAMS, pVarResult: ptr VARIANT, pExcepInfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.stdcall.} + SAFEARR_DISPATCH* {.pure.} = object + Size*: ULONG + apDispatch*: ptr ptr IDispatch + wireBRECORD* {.pure.} = ref object + fFlags*: ULONG + clSize*: ULONG + pRecInfo*: ptr IRecordInfo + pRecord*: ptr uint8 + wireVARIANT_UNION1* {.pure, union.} = object + llVal*: LONGLONG + lVal*: LONG + bVal*: BYTE + iVal*: SHORT + fltVal*: FLOAT + dblVal*: DOUBLE + boolVal*: VARIANT_BOOL + scode*: SCODE + cyVal*: CY + date*: DATE + bstrVal*: wireBSTR + punkVal*: ptr IUnknown + pdispVal*: ptr IDispatch + parray*: wirePSAFEARRAY + brecVal*: wireBRECORD + pbVal*: ptr BYTE + piVal*: ptr SHORT + plVal*: ptr LONG + pllVal*: ptr LONGLONG + pfltVal*: ptr FLOAT + pdblVal*: ptr DOUBLE + pboolVal*: ptr VARIANT_BOOL + pscode*: ptr SCODE + pcyVal*: ptr CY + pdate*: ptr DATE + pbstrVal*: ptr wireBSTR + ppunkVal*: ptr ptr IUnknown + ppdispVal*: ptr ptr IDispatch + pparray*: ptr wirePSAFEARRAY + pvarVal*: ptr wireVARIANT + cVal*: CHAR + uiVal*: USHORT + ulVal*: ULONG + ullVal*: ULONGLONG + intVal*: INT + uintVal*: UINT + decVal*: DECIMAL + pdecVal*: ptr DECIMAL + pcVal*: ptr CHAR + puiVal*: ptr USHORT + pulVal*: ptr ULONG + pullVal*: ptr ULONGLONG + pintVal*: ptr INT + puintVal*: ptr UINT + wireVARIANT* {.pure.} = ref object + clSize*: DWORD + rpcReserved*: DWORD + vt*: USHORT + wReserved1*: USHORT + wReserved2*: USHORT + wReserved3*: USHORT + union1*: wireVARIANT_UNION1 + SAFEARR_VARIANT* {.pure.} = object + Size*: ULONG + aVariant*: ptr wireVARIANT + SAFEARR_BRECORD* {.pure.} = object + Size*: ULONG + aRecord*: ptr wireBRECORD + SAFEARR_HAVEIID* {.pure.} = object + Size*: ULONG + apUnknown*: ptr ptr IUnknown + iid*: IID + BYTE_SIZEDARR* {.pure.} = object + clSize*: ULONG + pData*: ptr uint8 + WORD_SIZEDARR* {.pure.} = object + clSize*: ULONG + pData*: ptr uint16 + DWORD_SIZEDARR* {.pure.} = object + clSize*: ULONG + pData*: ptr ULONG + HYPER_SIZEDARR* {.pure.} = object + clSize*: ULONG + pData*: ptr hyper + SAFEARRAYUNION_u* {.pure, union.} = object + BstrStr*: SAFEARR_BSTR + UnknownStr*: SAFEARR_UNKNOWN + DispatchStr*: SAFEARR_DISPATCH + VariantStr*: SAFEARR_VARIANT + RecordStr*: SAFEARR_BRECORD + HaveIidStr*: SAFEARR_HAVEIID + ByteStr*: BYTE_SIZEDARR + WordStr*: WORD_SIZEDARR + LongStr*: DWORD_SIZEDARR + HyperStr*: HYPER_SIZEDARR + SAFEARRAYUNION* {.pure.} = object + sfType*: ULONG + u*: SAFEARRAYUNION_u + wireSAFEARRAY* {.pure.} = ref object + cDims*: USHORT + fFeatures*: USHORT + cbElements*: ULONG + cLocks*: ULONG + uArrayStructs*: SAFEARRAYUNION + rgsabound*: array[1, SAFEARRAYBOUND] + wirePSAFEARRAY* = ptr wireSAFEARRAY + LPSAFEARRAY* = ptr SAFEARRAY + LPVARIANT* = ptr VARIANT + LPVARIANTARG* = ptr VARIANT + REFVARIANT* = ptr VARIANT + LPPARAMDESC* = ptr PARAMDESC + LPIDLDESC* = ptr IDLDESC + LPELEMDESC* = ptr ELEMDESC + LPTYPEATTR* = ptr TYPEATTR + LPEXCEPINFO* = ptr EXCEPINFO + LPFUNCDESC* = ptr FUNCDESC + LPVARDESC* = ptr VARDESC + CUSTDATAITEM* {.pure.} = object + guid*: GUID + varValue*: VARIANTARG + LPCUSTDATAITEM* = ptr CUSTDATAITEM + CUSTDATA* {.pure.} = object + cCustData*: DWORD + prgCustData*: LPCUSTDATAITEM + LPCUSTDATA* = ptr CUSTDATA + ICreateTypeInfo* {.pure.} = object + lpVtbl*: ptr ICreateTypeInfoVtbl + ICreateTypeInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetGuid*: proc(self: ptr ICreateTypeInfo, guid: REFGUID): HRESULT {.stdcall.} + SetTypeFlags*: proc(self: ptr ICreateTypeInfo, uTypeFlags: UINT): HRESULT {.stdcall.} + SetDocString*: proc(self: ptr ICreateTypeInfo, pStrDoc: LPOLESTR): HRESULT {.stdcall.} + SetHelpContext*: proc(self: ptr ICreateTypeInfo, dwHelpContext: DWORD): HRESULT {.stdcall.} + SetVersion*: proc(self: ptr ICreateTypeInfo, wMajorVerNum: WORD, wMinorVerNum: WORD): HRESULT {.stdcall.} + AddRefTypeInfo*: proc(self: ptr ICreateTypeInfo, pTInfo: ptr ITypeInfo, phRefType: ptr HREFTYPE): HRESULT {.stdcall.} + AddFuncDesc*: proc(self: ptr ICreateTypeInfo, index: UINT, pFuncDesc: ptr FUNCDESC): HRESULT {.stdcall.} + AddImplType*: proc(self: ptr ICreateTypeInfo, index: UINT, hRefType: HREFTYPE): HRESULT {.stdcall.} + SetImplTypeFlags*: proc(self: ptr ICreateTypeInfo, index: UINT, implTypeFlags: INT): HRESULT {.stdcall.} + SetAlignment*: proc(self: ptr ICreateTypeInfo, cbAlignment: WORD): HRESULT {.stdcall.} + SetSchema*: proc(self: ptr ICreateTypeInfo, pStrSchema: LPOLESTR): HRESULT {.stdcall.} + AddVarDesc*: proc(self: ptr ICreateTypeInfo, index: UINT, pVarDesc: ptr VARDESC): HRESULT {.stdcall.} + SetFuncAndParamNames*: proc(self: ptr ICreateTypeInfo, index: UINT, rgszNames: ptr LPOLESTR, cNames: UINT): HRESULT {.stdcall.} + SetVarName*: proc(self: ptr ICreateTypeInfo, index: UINT, szName: LPOLESTR): HRESULT {.stdcall.} + SetTypeDescAlias*: proc(self: ptr ICreateTypeInfo, pTDescAlias: ptr TYPEDESC): HRESULT {.stdcall.} + DefineFuncAsDllEntry*: proc(self: ptr ICreateTypeInfo, index: UINT, szDllName: LPOLESTR, szProcName: LPOLESTR): HRESULT {.stdcall.} + SetFuncDocString*: proc(self: ptr ICreateTypeInfo, index: UINT, szDocString: LPOLESTR): HRESULT {.stdcall.} + SetVarDocString*: proc(self: ptr ICreateTypeInfo, index: UINT, szDocString: LPOLESTR): HRESULT {.stdcall.} + SetFuncHelpContext*: proc(self: ptr ICreateTypeInfo, index: UINT, dwHelpContext: DWORD): HRESULT {.stdcall.} + SetVarHelpContext*: proc(self: ptr ICreateTypeInfo, index: UINT, dwHelpContext: DWORD): HRESULT {.stdcall.} + SetMops*: proc(self: ptr ICreateTypeInfo, index: UINT, bstrMops: BSTR): HRESULT {.stdcall.} + SetTypeIdldesc*: proc(self: ptr ICreateTypeInfo, pIdlDesc: ptr IDLDESC): HRESULT {.stdcall.} + LayOut*: proc(self: ptr ICreateTypeInfo): HRESULT {.stdcall.} + LPCREATETYPEINFO* = ptr ICreateTypeInfo + ICreateTypeInfo2* {.pure.} = object + lpVtbl*: ptr ICreateTypeInfo2Vtbl + ICreateTypeInfo2Vtbl* {.pure, inheritable.} = object of ICreateTypeInfoVtbl + DeleteFuncDesc*: proc(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.stdcall.} + DeleteFuncDescByMemId*: proc(self: ptr ICreateTypeInfo2, memid: MEMBERID, invKind: INVOKEKIND): HRESULT {.stdcall.} + DeleteVarDesc*: proc(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.stdcall.} + DeleteVarDescByMemId*: proc(self: ptr ICreateTypeInfo2, memid: MEMBERID): HRESULT {.stdcall.} + DeleteImplType*: proc(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.stdcall.} + SetCustData*: proc(self: ptr ICreateTypeInfo2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetFuncCustData*: proc(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetParamCustData*: proc(self: ptr ICreateTypeInfo2, indexFunc: UINT, indexParam: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetVarCustData*: proc(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetImplTypeCustData*: proc(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetHelpStringContext*: proc(self: ptr ICreateTypeInfo2, dwHelpStringContext: ULONG): HRESULT {.stdcall.} + SetFuncHelpStringContext*: proc(self: ptr ICreateTypeInfo2, index: UINT, dwHelpStringContext: ULONG): HRESULT {.stdcall.} + SetVarHelpStringContext*: proc(self: ptr ICreateTypeInfo2, index: UINT, dwHelpStringContext: ULONG): HRESULT {.stdcall.} + Invalidate*: proc(self: ptr ICreateTypeInfo2): HRESULT {.stdcall.} + SetName*: proc(self: ptr ICreateTypeInfo2, szName: LPOLESTR): HRESULT {.stdcall.} + LPCREATETYPEINFO2* = ptr ICreateTypeInfo2 + ICreateTypeLib* {.pure.} = object + lpVtbl*: ptr ICreateTypeLibVtbl + ICreateTypeLibVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateTypeInfo*: proc(self: ptr ICreateTypeLib, szName: LPOLESTR, tkind: TYPEKIND, ppCTInfo: ptr ptr ICreateTypeInfo): HRESULT {.stdcall.} + SetName*: proc(self: ptr ICreateTypeLib, szName: LPOLESTR): HRESULT {.stdcall.} + SetVersion*: proc(self: ptr ICreateTypeLib, wMajorVerNum: WORD, wMinorVerNum: WORD): HRESULT {.stdcall.} + SetGuid*: proc(self: ptr ICreateTypeLib, guid: REFGUID): HRESULT {.stdcall.} + SetDocString*: proc(self: ptr ICreateTypeLib, szDoc: LPOLESTR): HRESULT {.stdcall.} + SetHelpFileName*: proc(self: ptr ICreateTypeLib, szHelpFileName: LPOLESTR): HRESULT {.stdcall.} + SetHelpContext*: proc(self: ptr ICreateTypeLib, dwHelpContext: DWORD): HRESULT {.stdcall.} + SetLcid*: proc(self: ptr ICreateTypeLib, lcid: LCID): HRESULT {.stdcall.} + SetLibFlags*: proc(self: ptr ICreateTypeLib, uLibFlags: UINT): HRESULT {.stdcall.} + SaveAllChanges*: proc(self: ptr ICreateTypeLib): HRESULT {.stdcall.} + LPCREATETYPELIB* = ptr ICreateTypeLib + ICreateTypeLib2* {.pure.} = object + lpVtbl*: ptr ICreateTypeLib2Vtbl + ICreateTypeLib2Vtbl* {.pure, inheritable.} = object of ICreateTypeLibVtbl + DeleteTypeInfo*: proc(self: ptr ICreateTypeLib2, szName: LPOLESTR): HRESULT {.stdcall.} + SetCustData*: proc(self: ptr ICreateTypeLib2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + SetHelpStringContext*: proc(self: ptr ICreateTypeLib2, dwHelpStringContext: ULONG): HRESULT {.stdcall.} + SetHelpStringDll*: proc(self: ptr ICreateTypeLib2, szFileName: LPOLESTR): HRESULT {.stdcall.} + LPCREATETYPELIB2* = ptr ICreateTypeLib2 + LPDISPATCH* = ptr IDispatch + IEnumVARIANT* {.pure.} = object + lpVtbl*: ptr IEnumVARIANTVtbl + IEnumVARIANTVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumVARIANT, celt: ULONG, rgVar: ptr VARIANT, pCeltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumVARIANT, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumVARIANT): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumVARIANT, ppEnum: ptr ptr IEnumVARIANT): HRESULT {.stdcall.} + LPENUMVARIANT* = ptr IEnumVARIANT + LPTYPECOMP* = ptr ITypeComp + LPTYPEINFO* = ptr ITypeInfo + ITypeInfo2* {.pure.} = object + lpVtbl*: ptr ITypeInfo2Vtbl + ITypeInfo2Vtbl* {.pure, inheritable.} = object of ITypeInfoVtbl + GetTypeKind*: proc(self: ptr ITypeInfo2, pTypeKind: ptr TYPEKIND): HRESULT {.stdcall.} + GetTypeFlags*: proc(self: ptr ITypeInfo2, pTypeFlags: ptr ULONG): HRESULT {.stdcall.} + GetFuncIndexOfMemId*: proc(self: ptr ITypeInfo2, memid: MEMBERID, invKind: INVOKEKIND, pFuncIndex: ptr UINT): HRESULT {.stdcall.} + GetVarIndexOfMemId*: proc(self: ptr ITypeInfo2, memid: MEMBERID, pVarIndex: ptr UINT): HRESULT {.stdcall.} + GetCustData*: proc(self: ptr ITypeInfo2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetFuncCustData*: proc(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetParamCustData*: proc(self: ptr ITypeInfo2, indexFunc: UINT, indexParam: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetVarCustData*: proc(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetImplTypeCustData*: proc(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetDocumentation2*: proc(self: ptr ITypeInfo2, memid: MEMBERID, lcid: LCID, pbstrHelpString: ptr BSTR, pdwHelpStringContext: ptr DWORD, pbstrHelpStringDll: ptr BSTR): HRESULT {.stdcall.} + GetAllCustData*: proc(self: ptr ITypeInfo2, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + GetAllFuncCustData*: proc(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + GetAllParamCustData*: proc(self: ptr ITypeInfo2, indexFunc: UINT, indexParam: UINT, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + GetAllVarCustData*: proc(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + GetAllImplTypeCustData*: proc(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + LPTYPEINFO2* = ptr ITypeInfo2 + LPTYPELIB* = ptr ITypeLib + LPTLIBATTR* = ptr TLIBATTR + ITypeLib2* {.pure.} = object + lpVtbl*: ptr ITypeLib2Vtbl + ITypeLib2Vtbl* {.pure, inheritable.} = object of ITypeLibVtbl + GetCustData*: proc(self: ptr ITypeLib2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.stdcall.} + GetLibStatistics*: proc(self: ptr ITypeLib2, pcUniqueNames: ptr ULONG, pcchUniqueNames: ptr ULONG): HRESULT {.stdcall.} + GetDocumentation2*: proc(self: ptr ITypeLib2, index: INT, lcid: LCID, pbstrHelpString: ptr BSTR, pdwHelpStringContext: ptr DWORD, pbstrHelpStringDll: ptr BSTR): HRESULT {.stdcall.} + GetAllCustData*: proc(self: ptr ITypeLib2, pCustData: ptr CUSTDATA): HRESULT {.stdcall.} + LPTYPELIB2* = ptr ITypeLib2 + ITypeChangeEvents* {.pure.} = object + lpVtbl*: ptr ITypeChangeEventsVtbl + ITypeChangeEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RequestTypeChange*: proc(self: ptr ITypeChangeEvents, changeKind: CHANGEKIND, pTInfoBefore: ptr ITypeInfo, pStrName: LPOLESTR, pfCancel: ptr INT): HRESULT {.stdcall.} + AfterTypeChange*: proc(self: ptr ITypeChangeEvents, changeKind: CHANGEKIND, pTInfoAfter: ptr ITypeInfo, pStrName: LPOLESTR): HRESULT {.stdcall.} + LPTYPECHANGEEVENTS* = ptr ITypeChangeEvents + IErrorInfo* {.pure.} = object + lpVtbl*: ptr IErrorInfoVtbl + IErrorInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetGUID*: proc(self: ptr IErrorInfo, pGUID: ptr GUID): HRESULT {.stdcall.} + GetSource*: proc(self: ptr IErrorInfo, pBstrSource: ptr BSTR): HRESULT {.stdcall.} + GetDescription*: proc(self: ptr IErrorInfo, pBstrDescription: ptr BSTR): HRESULT {.stdcall.} + GetHelpFile*: proc(self: ptr IErrorInfo, pBstrHelpFile: ptr BSTR): HRESULT {.stdcall.} + GetHelpContext*: proc(self: ptr IErrorInfo, pdwHelpContext: ptr DWORD): HRESULT {.stdcall.} + LPERRORINFO* = ptr IErrorInfo + ICreateErrorInfo* {.pure.} = object + lpVtbl*: ptr ICreateErrorInfoVtbl + ICreateErrorInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetGUID*: proc(self: ptr ICreateErrorInfo, rguid: REFGUID): HRESULT {.stdcall.} + SetSource*: proc(self: ptr ICreateErrorInfo, szSource: LPOLESTR): HRESULT {.stdcall.} + SetDescription*: proc(self: ptr ICreateErrorInfo, szDescription: LPOLESTR): HRESULT {.stdcall.} + SetHelpFile*: proc(self: ptr ICreateErrorInfo, szHelpFile: LPOLESTR): HRESULT {.stdcall.} + SetHelpContext*: proc(self: ptr ICreateErrorInfo, dwHelpContext: DWORD): HRESULT {.stdcall.} + LPCREATEERRORINFO* = ptr ICreateErrorInfo + ISupportErrorInfo* {.pure.} = object + lpVtbl*: ptr ISupportErrorInfoVtbl + ISupportErrorInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InterfaceSupportsErrorInfo*: proc(self: ptr ISupportErrorInfo, riid: REFIID): HRESULT {.stdcall.} + LPSUPPORTERRORINFO* = ptr ISupportErrorInfo + LPRECORDINFO* = ptr IRecordInfo + IErrorLog* {.pure.} = object + lpVtbl*: ptr IErrorLogVtbl + IErrorLogVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddError*: proc(self: ptr IErrorLog, pszPropName: LPCOLESTR, pExcepInfo: ptr EXCEPINFO): HRESULT {.stdcall.} + LPERRORLOG* = ptr IErrorLog + IPropertyBag* {.pure.} = object + lpVtbl*: ptr IPropertyBagVtbl + IPropertyBagVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Read*: proc(self: ptr IPropertyBag, pszPropName: LPCOLESTR, pVar: ptr VARIANT, pErrorLog: ptr IErrorLog): HRESULT {.stdcall.} + Write*: proc(self: ptr IPropertyBag, pszPropName: LPCOLESTR, pVar: ptr VARIANT): HRESULT {.stdcall.} + LPPROPERTYBAG* = ptr IPropertyBag + PARAMDATA* {.pure.} = object + szName*: ptr OLECHAR + vt*: VARTYPE + LPPARAMDATA* = ptr PARAMDATA + METHODDATA* {.pure.} = object + szName*: ptr OLECHAR + ppdata*: ptr PARAMDATA + dispid*: DISPID + iMeth*: UINT + cc*: CALLCONV + cArgs*: UINT + wFlags*: WORD + vtReturn*: VARTYPE + LPMETHODDATA* = ptr METHODDATA + INTERFACEDATA* {.pure.} = object + pmethdata*: ptr METHODDATA + cMembers*: UINT + LPINTERFACEDATA* = ptr INTERFACEDATA + IOleAdviseHolder* {.pure.} = object + lpVtbl*: ptr IOleAdviseHolderVtbl + IOleAdviseHolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr IOleAdviseHolder, pAdvise: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IOleAdviseHolder, dwConnection: DWORD): HRESULT {.stdcall.} + EnumAdvise*: proc(self: ptr IOleAdviseHolder, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + SendOnRename*: proc(self: ptr IOleAdviseHolder, pmk: ptr IMoniker): HRESULT {.stdcall.} + SendOnSave*: proc(self: ptr IOleAdviseHolder): HRESULT {.stdcall.} + SendOnClose*: proc(self: ptr IOleAdviseHolder): HRESULT {.stdcall.} + LPOLEADVISEHOLDER* = ptr IOleAdviseHolder + IOleCache* {.pure.} = object + lpVtbl*: ptr IOleCacheVtbl + IOleCacheVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Cache*: proc(self: ptr IOleCache, pformatetc: ptr FORMATETC, advf: DWORD, pdwConnection: ptr DWORD): HRESULT {.stdcall.} + Uncache*: proc(self: ptr IOleCache, dwConnection: DWORD): HRESULT {.stdcall.} + EnumCache*: proc(self: ptr IOleCache, ppenumSTATDATA: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + InitCache*: proc(self: ptr IOleCache, pDataObject: ptr IDataObject): HRESULT {.stdcall.} + SetData*: proc(self: ptr IOleCache, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM, fRelease: WINBOOL): HRESULT {.stdcall.} + LPOLECACHE* = ptr IOleCache + IOleCache2* {.pure.} = object + lpVtbl*: ptr IOleCache2Vtbl + IOleCache2Vtbl* {.pure, inheritable.} = object of IOleCacheVtbl + UpdateCache*: proc(self: ptr IOleCache2, pDataObject: LPDATAOBJECT, grfUpdf: DWORD, pReserved: LPVOID): HRESULT {.stdcall.} + DiscardCache*: proc(self: ptr IOleCache2, dwDiscardOptions: DWORD): HRESULT {.stdcall.} + LPOLECACHE2* = ptr IOleCache2 + IOleCacheControl* {.pure.} = object + lpVtbl*: ptr IOleCacheControlVtbl + IOleCacheControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnRun*: proc(self: ptr IOleCacheControl, pDataObject: LPDATAOBJECT): HRESULT {.stdcall.} + OnStop*: proc(self: ptr IOleCacheControl): HRESULT {.stdcall.} + LPOLECACHECONTROL* = ptr IOleCacheControl + IParseDisplayName* {.pure.} = object + lpVtbl*: ptr IParseDisplayNameVtbl + IParseDisplayNameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseDisplayName*: proc(self: ptr IParseDisplayName, pbc: ptr IBindCtx, pszDisplayName: LPOLESTR, pchEaten: ptr ULONG, ppmkOut: ptr ptr IMoniker): HRESULT {.stdcall.} + LPPARSEDISPLAYNAME* = ptr IParseDisplayName + IOleContainer* {.pure.} = object + lpVtbl*: ptr IOleContainerVtbl + IOleContainerVtbl* {.pure, inheritable.} = object of IParseDisplayNameVtbl + EnumObjects*: proc(self: ptr IOleContainer, grfFlags: DWORD, ppenum: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + LockContainer*: proc(self: ptr IOleContainer, fLock: WINBOOL): HRESULT {.stdcall.} + LPOLECONTAINER* = ptr IOleContainer + IOleClientSite* {.pure.} = object + lpVtbl*: ptr IOleClientSiteVtbl + IOleClientSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SaveObject*: proc(self: ptr IOleClientSite): HRESULT {.stdcall.} + GetMoniker*: proc(self: ptr IOleClientSite, dwAssign: DWORD, dwWhichMoniker: DWORD, ppmk: ptr ptr IMoniker): HRESULT {.stdcall.} + GetContainer*: proc(self: ptr IOleClientSite, ppContainer: ptr ptr IOleContainer): HRESULT {.stdcall.} + ShowObject*: proc(self: ptr IOleClientSite): HRESULT {.stdcall.} + OnShowWindow*: proc(self: ptr IOleClientSite, fShow: WINBOOL): HRESULT {.stdcall.} + RequestNewObjectLayout*: proc(self: ptr IOleClientSite): HRESULT {.stdcall.} + LPOLECLIENTSITE* = ptr IOleClientSite + OLEVERB* {.pure.} = object + lVerb*: LONG + lpszVerbName*: LPOLESTR + fuFlags*: DWORD + grfAttribs*: DWORD + LPOLEVERB* = ptr OLEVERB + IEnumOLEVERB* {.pure.} = object + lpVtbl*: ptr IEnumOLEVERBVtbl + IEnumOLEVERBVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumOLEVERB, celt: ULONG, rgelt: LPOLEVERB, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumOLEVERB, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumOLEVERB): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumOLEVERB, ppenum: ptr ptr IEnumOLEVERB): HRESULT {.stdcall.} + IOleObject* {.pure.} = object + lpVtbl*: ptr IOleObjectVtbl + IOleObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetClientSite*: proc(self: ptr IOleObject, pClientSite: ptr IOleClientSite): HRESULT {.stdcall.} + GetClientSite*: proc(self: ptr IOleObject, ppClientSite: ptr ptr IOleClientSite): HRESULT {.stdcall.} + SetHostNames*: proc(self: ptr IOleObject, szContainerApp: LPCOLESTR, szContainerObj: LPCOLESTR): HRESULT {.stdcall.} + Close*: proc(self: ptr IOleObject, dwSaveOption: DWORD): HRESULT {.stdcall.} + SetMoniker*: proc(self: ptr IOleObject, dwWhichMoniker: DWORD, pmk: ptr IMoniker): HRESULT {.stdcall.} + GetMoniker*: proc(self: ptr IOleObject, dwAssign: DWORD, dwWhichMoniker: DWORD, ppmk: ptr ptr IMoniker): HRESULT {.stdcall.} + InitFromData*: proc(self: ptr IOleObject, pDataObject: ptr IDataObject, fCreation: WINBOOL, dwReserved: DWORD): HRESULT {.stdcall.} + GetClipboardData*: proc(self: ptr IOleObject, dwReserved: DWORD, ppDataObject: ptr ptr IDataObject): HRESULT {.stdcall.} + DoVerb*: proc(self: ptr IOleObject, iVerb: LONG, lpmsg: LPMSG, pActiveSite: ptr IOleClientSite, lindex: LONG, hwndParent: HWND, lprcPosRect: LPCRECT): HRESULT {.stdcall.} + EnumVerbs*: proc(self: ptr IOleObject, ppEnumOleVerb: ptr ptr IEnumOLEVERB): HRESULT {.stdcall.} + Update*: proc(self: ptr IOleObject): HRESULT {.stdcall.} + IsUpToDate*: proc(self: ptr IOleObject): HRESULT {.stdcall.} + GetUserClassID*: proc(self: ptr IOleObject, pClsid: ptr CLSID): HRESULT {.stdcall.} + GetUserType*: proc(self: ptr IOleObject, dwFormOfType: DWORD, pszUserType: ptr LPOLESTR): HRESULT {.stdcall.} + SetExtent*: proc(self: ptr IOleObject, dwDrawAspect: DWORD, psizel: ptr SIZEL): HRESULT {.stdcall.} + GetExtent*: proc(self: ptr IOleObject, dwDrawAspect: DWORD, psizel: ptr SIZEL): HRESULT {.stdcall.} + Advise*: proc(self: ptr IOleObject, pAdvSink: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IOleObject, dwConnection: DWORD): HRESULT {.stdcall.} + EnumAdvise*: proc(self: ptr IOleObject, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.stdcall.} + GetMiscStatus*: proc(self: ptr IOleObject, dwAspect: DWORD, pdwStatus: ptr DWORD): HRESULT {.stdcall.} + SetColorScheme*: proc(self: ptr IOleObject, pLogpal: ptr LOGPALETTE): HRESULT {.stdcall.} + LPOLEOBJECT* = ptr IOleObject + LPOLERENDER* = ptr OLERENDER + OBJECTDESCRIPTOR* {.pure.} = object + cbSize*: ULONG + clsid*: CLSID + dwDrawAspect*: DWORD + sizel*: SIZEL + pointl*: POINTL + dwStatus*: DWORD + dwFullUserTypeName*: DWORD + dwSrcOfCopy*: DWORD + POBJECTDESCRIPTOR* = ptr OBJECTDESCRIPTOR + LPOBJECTDESCRIPTOR* = ptr OBJECTDESCRIPTOR + LINKSRCDESCRIPTOR* = OBJECTDESCRIPTOR + PLINKSRCDESCRIPTOR* = ptr OBJECTDESCRIPTOR + LPLINKSRCDESCRIPTOR* = ptr OBJECTDESCRIPTOR + IOleWindow* {.pure.} = object + lpVtbl*: ptr IOleWindowVtbl + IOleWindowVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindow*: proc(self: ptr IOleWindow, phwnd: ptr HWND): HRESULT {.stdcall.} + ContextSensitiveHelp*: proc(self: ptr IOleWindow, fEnterMode: WINBOOL): HRESULT {.stdcall.} + LPOLEWINDOW* = ptr IOleWindow + IOleLink* {.pure.} = object + lpVtbl*: ptr IOleLinkVtbl + IOleLinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetUpdateOptions*: proc(self: ptr IOleLink, dwUpdateOpt: DWORD): HRESULT {.stdcall.} + GetUpdateOptions*: proc(self: ptr IOleLink, pdwUpdateOpt: ptr DWORD): HRESULT {.stdcall.} + SetSourceMoniker*: proc(self: ptr IOleLink, pmk: ptr IMoniker, rclsid: REFCLSID): HRESULT {.stdcall.} + GetSourceMoniker*: proc(self: ptr IOleLink, ppmk: ptr ptr IMoniker): HRESULT {.stdcall.} + SetSourceDisplayName*: proc(self: ptr IOleLink, pszStatusText: LPCOLESTR): HRESULT {.stdcall.} + GetSourceDisplayName*: proc(self: ptr IOleLink, ppszDisplayName: ptr LPOLESTR): HRESULT {.stdcall.} + BindToSource*: proc(self: ptr IOleLink, bindflags: DWORD, pbc: ptr IBindCtx): HRESULT {.stdcall.} + BindIfRunning*: proc(self: ptr IOleLink): HRESULT {.stdcall.} + GetBoundSource*: proc(self: ptr IOleLink, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + UnbindSource*: proc(self: ptr IOleLink): HRESULT {.stdcall.} + Update*: proc(self: ptr IOleLink, pbc: ptr IBindCtx): HRESULT {.stdcall.} + LPOLELINK* = ptr IOleLink + LPOLEUPDATE* = ptr OLEUPDATE + POLEUPDATE* = ptr OLEUPDATE + IOleItemContainer* {.pure.} = object + lpVtbl*: ptr IOleItemContainerVtbl + IOleItemContainerVtbl* {.pure, inheritable.} = object of IOleContainerVtbl + GetObject*: proc(self: ptr IOleItemContainer, pszItem: LPOLESTR, dwSpeedNeeded: DWORD, pbc: ptr IBindCtx, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + GetObjectStorage*: proc(self: ptr IOleItemContainer, pszItem: LPOLESTR, pbc: ptr IBindCtx, riid: REFIID, ppvStorage: ptr pointer): HRESULT {.stdcall.} + IsRunning*: proc(self: ptr IOleItemContainer, pszItem: LPOLESTR): HRESULT {.stdcall.} + LPOLEITEMCONTAINER* = ptr IOleItemContainer + LPCBORDERWIDTHS* = LPCRECT + IOleInPlaceActiveObject* {.pure.} = object + lpVtbl*: ptr IOleInPlaceActiveObjectVtbl + IOleInPlaceActiveObjectVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + TranslateAccelerator*: proc(self: ptr IOleInPlaceActiveObject, lpmsg: LPMSG): HRESULT {.stdcall.} + OnFrameWindowActivate*: proc(self: ptr IOleInPlaceActiveObject, fActivate: WINBOOL): HRESULT {.stdcall.} + OnDocWindowActivate*: proc(self: ptr IOleInPlaceActiveObject, fActivate: WINBOOL): HRESULT {.stdcall.} + ResizeBorder*: proc(self: ptr IOleInPlaceActiveObject, prcBorder: LPCRECT, pUIWindow: ptr IOleInPlaceUIWindow, fFrameWindow: WINBOOL): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IOleInPlaceActiveObject, fEnable: WINBOOL): HRESULT {.stdcall.} + IOleInPlaceUIWindow* {.pure.} = object + lpVtbl*: ptr IOleInPlaceUIWindowVtbl + IOleInPlaceUIWindowVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + GetBorder*: proc(self: ptr IOleInPlaceUIWindow, lprectBorder: LPRECT): HRESULT {.stdcall.} + RequestBorderSpace*: proc(self: ptr IOleInPlaceUIWindow, pborderwidths: LPCBORDERWIDTHS): HRESULT {.stdcall.} + SetBorderSpace*: proc(self: ptr IOleInPlaceUIWindow, pborderwidths: LPCBORDERWIDTHS): HRESULT {.stdcall.} + SetActiveObject*: proc(self: ptr IOleInPlaceUIWindow, pActiveObject: ptr IOleInPlaceActiveObject, pszObjName: LPCOLESTR): HRESULT {.stdcall.} + LPOLEINPLACEUIWINDOW* = ptr IOleInPlaceUIWindow + BORDERWIDTHS* = RECT + LPBORDERWIDTHS* = LPRECT + LPOLEINPLACEACTIVEOBJECT* = ptr IOleInPlaceActiveObject + OLEMENUGROUPWIDTHS* {.pure.} = object + width*: array[6, LONG] + LPOLEMENUGROUPWIDTHS* = ptr OLEMENUGROUPWIDTHS + HOLEMENU* = HGLOBAL + IOleInPlaceFrame* {.pure.} = object + lpVtbl*: ptr IOleInPlaceFrameVtbl + IOleInPlaceFrameVtbl* {.pure, inheritable.} = object of IOleInPlaceUIWindowVtbl + InsertMenus*: proc(self: ptr IOleInPlaceFrame, hmenuShared: HMENU, lpMenuWidths: LPOLEMENUGROUPWIDTHS): HRESULT {.stdcall.} + SetMenu*: proc(self: ptr IOleInPlaceFrame, hmenuShared: HMENU, holemenu: HOLEMENU, hwndActiveObject: HWND): HRESULT {.stdcall.} + RemoveMenus*: proc(self: ptr IOleInPlaceFrame, hmenuShared: HMENU): HRESULT {.stdcall.} + SetStatusText*: proc(self: ptr IOleInPlaceFrame, pszStatusText: LPCOLESTR): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IOleInPlaceFrame, fEnable: WINBOOL): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IOleInPlaceFrame, lpmsg: LPMSG, wID: WORD): HRESULT {.stdcall.} + LPOLEINPLACEFRAME* = ptr IOleInPlaceFrame + IOleInPlaceObject* {.pure.} = object + lpVtbl*: ptr IOleInPlaceObjectVtbl + IOleInPlaceObjectVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + InPlaceDeactivate*: proc(self: ptr IOleInPlaceObject): HRESULT {.stdcall.} + UIDeactivate*: proc(self: ptr IOleInPlaceObject): HRESULT {.stdcall.} + SetObjectRects*: proc(self: ptr IOleInPlaceObject, lprcPosRect: LPCRECT, lprcClipRect: LPCRECT): HRESULT {.stdcall.} + ReactivateAndUndo*: proc(self: ptr IOleInPlaceObject): HRESULT {.stdcall.} + LPOLEINPLACEOBJECT* = ptr IOleInPlaceObject + OLEINPLACEFRAMEINFO* {.pure.} = object + cb*: UINT + fMDIApp*: WINBOOL + hwndFrame*: HWND + haccel*: HACCEL + cAccelEntries*: UINT + LPOLEINPLACEFRAMEINFO* = ptr OLEINPLACEFRAMEINFO + IOleInPlaceSite* {.pure.} = object + lpVtbl*: ptr IOleInPlaceSiteVtbl + IOleInPlaceSiteVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + CanInPlaceActivate*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + OnInPlaceActivate*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + OnUIActivate*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + GetWindowContext*: proc(self: ptr IOleInPlaceSite, ppFrame: ptr ptr IOleInPlaceFrame, ppDoc: ptr ptr IOleInPlaceUIWindow, lprcPosRect: LPRECT, lprcClipRect: LPRECT, lpFrameInfo: LPOLEINPLACEFRAMEINFO): HRESULT {.stdcall.} + Scroll*: proc(self: ptr IOleInPlaceSite, scrollExtant: SIZE): HRESULT {.stdcall.} + OnUIDeactivate*: proc(self: ptr IOleInPlaceSite, fUndoable: WINBOOL): HRESULT {.stdcall.} + OnInPlaceDeactivate*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + DiscardUndoState*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + DeactivateAndUndo*: proc(self: ptr IOleInPlaceSite): HRESULT {.stdcall.} + OnPosRectChange*: proc(self: ptr IOleInPlaceSite, lprcPosRect: LPCRECT): HRESULT {.stdcall.} + LPOLEINPLACESITE* = ptr IOleInPlaceSite + IViewObject* {.pure.} = object + lpVtbl*: ptr IViewObjectVtbl + IViewObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Draw*: proc(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, ptd: ptr DVTARGETDEVICE, hdcTargetDev: HDC, hdcDraw: HDC, lprcBounds: LPCRECTL, lprcWBounds: LPCRECTL, pfnContinue: proc (dwContinue: ULONG_PTR): WINBOOL {.stdcall.}, dwContinue: ULONG_PTR): HRESULT {.stdcall.} + GetColorSet*: proc(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, ptd: ptr DVTARGETDEVICE, hicTargetDev: HDC, ppColorSet: ptr ptr LOGPALETTE): HRESULT {.stdcall.} + Freeze*: proc(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, pdwFreeze: ptr DWORD): HRESULT {.stdcall.} + Unfreeze*: proc(self: ptr IViewObject, dwFreeze: DWORD): HRESULT {.stdcall.} + SetAdvise*: proc(self: ptr IViewObject, aspects: DWORD, advf: DWORD, pAdvSink: ptr IAdviseSink): HRESULT {.stdcall.} + GetAdvise*: proc(self: ptr IViewObject, pAspects: ptr DWORD, pAdvf: ptr DWORD, ppAdvSink: ptr ptr IAdviseSink): HRESULT {.stdcall.} + LPVIEWOBJECT* = ptr IViewObject + IViewObject2* {.pure.} = object + lpVtbl*: ptr IViewObject2Vtbl + IViewObject2Vtbl* {.pure, inheritable.} = object of IViewObjectVtbl + GetExtent*: proc(self: ptr IViewObject2, dwDrawAspect: DWORD, lindex: LONG, ptd: ptr DVTARGETDEVICE, lpsizel: LPSIZEL): HRESULT {.stdcall.} + LPVIEWOBJECT2* = ptr IViewObject2 + IDropSource* {.pure.} = object + lpVtbl*: ptr IDropSourceVtbl + IDropSourceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryContinueDrag*: proc(self: ptr IDropSource, fEscapePressed: WINBOOL, grfKeyState: DWORD): HRESULT {.stdcall.} + GiveFeedback*: proc(self: ptr IDropSource, dwEffect: DWORD): HRESULT {.stdcall.} + LPDROPSOURCE* = ptr IDropSource + IDropTarget* {.pure.} = object + lpVtbl*: ptr IDropTargetVtbl + IDropTargetVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DragEnter*: proc(self: ptr IDropTarget, pDataObj: ptr IDataObject, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + DragOver*: proc(self: ptr IDropTarget, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + DragLeave*: proc(self: ptr IDropTarget): HRESULT {.stdcall.} + Drop*: proc(self: ptr IDropTarget, pDataObj: ptr IDataObject, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + LPDROPTARGET* = ptr IDropTarget + LPENUMOLEVERB* = ptr IEnumOLEVERB + OLESTREAMVTBL* {.pure.} = object + Get*: proc(P1: LPOLESTREAM, P2: pointer, P3: DWORD): DWORD {.stdcall.} + Put*: proc(P1: LPOLESTREAM, P2: pointer, P3: DWORD): DWORD {.stdcall.} + LPOLESTREAMVTBL* = ptr OLESTREAMVTBL + OLESTREAM* {.pure.} = object + lpstbl*: LPOLESTREAMVTBL + LPOLESTREAM* = ptr OLESTREAM + PSCODE* = ptr SCODE + UP_BYTE_BLOB* = ptr BYTE_BLOB + WORD_BLOB* {.pure.} = object + clSize*: ULONG + asData*: array[1, uint16] + UP_WORD_BLOB* = ptr WORD_BLOB + DWORD_BLOB* {.pure.} = object + clSize*: ULONG + alData*: array[1, ULONG] + UP_DWORD_BLOB* = ptr DWORD_BLOB + UP_FLAGGED_BYTE_BLOB* = ptr FLAGGED_BYTE_BLOB + UP_FLAGGED_WORD_BLOB* = ptr FLAGGED_WORD_BLOB + ServerInformation* {.pure.} = object + dwServerPid*: DWORD + dwServerTid*: DWORD + ui64ServerAddress*: UINT64 + PServerInformation* = ptr ServerInformation + IServiceProvider* {.pure.} = object + lpVtbl*: ptr IServiceProviderVtbl + IServiceProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryService*: proc(self: ptr IServiceProvider, guidService: REFGUID, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + LPSERVICEPROVIDER* = ptr IServiceProvider + IPersistMoniker* {.pure.} = object + lpVtbl*: ptr IPersistMonikerVtbl + IPersistMonikerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClassID*: proc(self: ptr IPersistMoniker, pClassID: ptr CLSID): HRESULT {.stdcall.} + IsDirty*: proc(self: ptr IPersistMoniker): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistMoniker, fFullyAvailable: WINBOOL, pimkName: ptr IMoniker, pibc: LPBC, grfMode: DWORD): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistMoniker, pimkName: ptr IMoniker, pbc: LPBC, fRemember: WINBOOL): HRESULT {.stdcall.} + SaveCompleted*: proc(self: ptr IPersistMoniker, pimkName: ptr IMoniker, pibc: LPBC): HRESULT {.stdcall.} + GetCurMoniker*: proc(self: ptr IPersistMoniker, ppimkName: ptr ptr IMoniker): HRESULT {.stdcall.} + LPPERSISTMONIKER* = ptr IPersistMoniker + IMonikerProp* {.pure.} = object + lpVtbl*: ptr IMonikerPropVtbl + IMonikerPropVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PutProperty*: proc(self: ptr IMonikerProp, mkp: MONIKERPROPERTY, val: LPCWSTR): HRESULT {.stdcall.} + LPMONIKERPROP* = ptr IMonikerProp + IBinding* {.pure.} = object + lpVtbl*: ptr IBindingVtbl + IBindingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Abort*: proc(self: ptr IBinding): HRESULT {.stdcall.} + Suspend*: proc(self: ptr IBinding): HRESULT {.stdcall.} + Resume*: proc(self: ptr IBinding): HRESULT {.stdcall.} + SetPriority*: proc(self: ptr IBinding, nPriority: LONG): HRESULT {.stdcall.} + GetPriority*: proc(self: ptr IBinding, pnPriority: ptr LONG): HRESULT {.stdcall.} + GetBindResult*: proc(self: ptr IBinding, pclsidProtocol: ptr CLSID, pdwResult: ptr DWORD, pszResult: ptr LPOLESTR, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + IBindProtocol* {.pure.} = object + lpVtbl*: ptr IBindProtocolVtbl + IBindProtocolVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateBinding*: proc(self: ptr IBindProtocol, szUrl: LPCWSTR, pbc: ptr IBindCtx, ppb: ptr ptr IBinding): HRESULT {.stdcall.} + LPBINDPROTOCOL* = ptr IBindProtocol + LPBINDING* = ptr IBinding + BINDINFO* {.pure.} = object + cbSize*: ULONG + szExtraInfo*: LPWSTR + stgmedData*: STGMEDIUM + grfBindInfoF*: DWORD + dwBindVerb*: DWORD + szCustomVerb*: LPWSTR + cbstgmedData*: DWORD + dwOptions*: DWORD + dwOptionsFlags*: DWORD + dwCodePage*: DWORD + securityAttributes*: SECURITY_ATTRIBUTES + iid*: IID + pUnk*: ptr IUnknown + dwReserved*: DWORD + IBindStatusCallback* {.pure.} = object + lpVtbl*: ptr IBindStatusCallbackVtbl + IBindStatusCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnStartBinding*: proc(self: ptr IBindStatusCallback, dwReserved: DWORD, pib: ptr IBinding): HRESULT {.stdcall.} + GetPriority*: proc(self: ptr IBindStatusCallback, pnPriority: ptr LONG): HRESULT {.stdcall.} + OnLowResource*: proc(self: ptr IBindStatusCallback, reserved: DWORD): HRESULT {.stdcall.} + OnProgress*: proc(self: ptr IBindStatusCallback, ulProgress: ULONG, ulProgressMax: ULONG, ulStatusCode: ULONG, szStatusText: LPCWSTR): HRESULT {.stdcall.} + OnStopBinding*: proc(self: ptr IBindStatusCallback, hresult: HRESULT, szError: LPCWSTR): HRESULT {.stdcall.} + GetBindInfo*: proc(self: ptr IBindStatusCallback, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO): HRESULT {.stdcall.} + OnDataAvailable*: proc(self: ptr IBindStatusCallback, grfBSCF: DWORD, dwSize: DWORD, pformatetc: ptr FORMATETC, pstgmed: ptr STGMEDIUM): HRESULT {.stdcall.} + OnObjectAvailable*: proc(self: ptr IBindStatusCallback, riid: REFIID, punk: ptr IUnknown): HRESULT {.stdcall.} + LPBINDSTATUSCALLBACK* = ptr IBindStatusCallback + REMSECURITY_ATTRIBUTES* {.pure.} = object + nLength*: DWORD + lpSecurityDescriptor*: DWORD + bInheritHandle*: WINBOOL + PREMSECURITY_ATTRIBUTES* = ptr REMSECURITY_ATTRIBUTES + LPREMSECURITY_ATTRIBUTES* = ptr REMSECURITY_ATTRIBUTES + RemFORMATETC* {.pure.} = object + cfFormat*: DWORD + ptd*: DWORD + dwAspect*: DWORD + lindex*: LONG + tymed*: DWORD + LPREMFORMATETC* = ptr RemFORMATETC + IBindStatusCallbackEx* {.pure.} = object + lpVtbl*: ptr IBindStatusCallbackExVtbl + IBindStatusCallbackExVtbl* {.pure, inheritable.} = object of IBindStatusCallbackVtbl + GetBindInfoEx*: proc(self: ptr IBindStatusCallbackEx, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO, grfBINDF2: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + LPBINDSTATUSCALLBACKEX* = ptr IBindStatusCallbackEx + IAuthenticate* {.pure.} = object + lpVtbl*: ptr IAuthenticateVtbl + IAuthenticateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Authenticate*: proc(self: ptr IAuthenticate, phwnd: ptr HWND, pszUsername: ptr LPWSTR, pszPassword: ptr LPWSTR): HRESULT {.stdcall.} + LPAUTHENTICATION* = ptr IAuthenticate + AUTHENTICATEINFO* {.pure.} = object + dwFlags*: DWORD + dwReserved*: DWORD + IAuthenticateEx* {.pure.} = object + lpVtbl*: ptr IAuthenticateExVtbl + IAuthenticateExVtbl* {.pure, inheritable.} = object of IAuthenticateVtbl + AuthenticateEx*: proc(self: ptr IAuthenticateEx, phwnd: ptr HWND, pszUsername: ptr LPWSTR, pszPassword: ptr LPWSTR, pauthinfo: ptr AUTHENTICATEINFO): HRESULT {.stdcall.} + LPAUTHENTICATIONEX* = ptr IAuthenticateEx + IHttpNegotiate* {.pure.} = object + lpVtbl*: ptr IHttpNegotiateVtbl + IHttpNegotiateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BeginningTransaction*: proc(self: ptr IHttpNegotiate, szURL: LPCWSTR, szHeaders: LPCWSTR, dwReserved: DWORD, pszAdditionalHeaders: ptr LPWSTR): HRESULT {.stdcall.} + OnResponse*: proc(self: ptr IHttpNegotiate, dwResponseCode: DWORD, szResponseHeaders: LPCWSTR, szRequestHeaders: LPCWSTR, pszAdditionalRequestHeaders: ptr LPWSTR): HRESULT {.stdcall.} + LPHTTPNEGOTIATE* = ptr IHttpNegotiate + IHttpNegotiate2* {.pure.} = object + lpVtbl*: ptr IHttpNegotiate2Vtbl + IHttpNegotiate2Vtbl* {.pure, inheritable.} = object of IHttpNegotiateVtbl + GetRootSecurityId*: proc(self: ptr IHttpNegotiate2, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + LPHTTPNEGOTIATE2* = ptr IHttpNegotiate2 + IHttpNegotiate3* {.pure.} = object + lpVtbl*: ptr IHttpNegotiate3Vtbl + IHttpNegotiate3Vtbl* {.pure, inheritable.} = object of IHttpNegotiate2Vtbl + GetSerializedClientCertContext*: proc(self: ptr IHttpNegotiate3, ppbCert: ptr ptr BYTE, pcbCert: ptr DWORD): HRESULT {.stdcall.} + LPHTTPNEGOTIATE3* = ptr IHttpNegotiate3 + IWinInetFileStream* {.pure.} = object + lpVtbl*: ptr IWinInetFileStreamVtbl + IWinInetFileStreamVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetHandleForUnlock*: proc(self: ptr IWinInetFileStream, hWinInetLockHandle: DWORD_PTR, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + SetDeleteFile*: proc(self: ptr IWinInetFileStream, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + LPWININETFILESTREAM* = ptr IWinInetFileStream + IWindowForBindingUI* {.pure.} = object + lpVtbl*: ptr IWindowForBindingUIVtbl + IWindowForBindingUIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindow*: proc(self: ptr IWindowForBindingUI, rguidReason: REFGUID, phwnd: ptr HWND): HRESULT {.stdcall.} + LPWINDOWFORBINDINGUI* = ptr IWindowForBindingUI + ICodeInstall* {.pure.} = object + lpVtbl*: ptr ICodeInstallVtbl + ICodeInstallVtbl* {.pure, inheritable.} = object of IWindowForBindingUIVtbl + OnCodeInstallProblem*: proc(self: ptr ICodeInstall, ulStatusCode: ULONG, szDestination: LPCWSTR, szSource: LPCWSTR, dwReserved: DWORD): HRESULT {.stdcall.} + LPCODEINSTALL* = ptr ICodeInstall + IWinInetInfo* {.pure.} = object + lpVtbl*: ptr IWinInetInfoVtbl + IWinInetInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryOption*: proc(self: ptr IWinInetInfo, dwOption: DWORD, pBuffer: LPVOID, pcbBuf: ptr DWORD): HRESULT {.stdcall.} + LPWININETINFO* = ptr IWinInetInfo + IHttpSecurity* {.pure.} = object + lpVtbl*: ptr IHttpSecurityVtbl + IHttpSecurityVtbl* {.pure, inheritable.} = object of IWindowForBindingUIVtbl + OnSecurityProblem*: proc(self: ptr IHttpSecurity, dwProblem: DWORD): HRESULT {.stdcall.} + LPHTTPSECURITY* = ptr IHttpSecurity + IWinInetHttpInfo* {.pure.} = object + lpVtbl*: ptr IWinInetHttpInfoVtbl + IWinInetHttpInfoVtbl* {.pure, inheritable.} = object of IWinInetInfoVtbl + QueryInfo*: proc(self: ptr IWinInetHttpInfo, dwOption: DWORD, pBuffer: LPVOID, pcbBuf: ptr DWORD, pdwFlags: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + LPWININETHTTPINFO* = ptr IWinInetHttpInfo + IWinInetCacheHints* {.pure.} = object + lpVtbl*: ptr IWinInetCacheHintsVtbl + IWinInetCacheHintsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetCacheExtension*: proc(self: ptr IWinInetCacheHints, pwzExt: LPCWSTR, pszCacheFile: LPVOID, pcbCacheFile: ptr DWORD, pdwWinInetError: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + LPWININETCACHEHINTS* = ptr IWinInetCacheHints + IWinInetCacheHints2* {.pure.} = object + lpVtbl*: ptr IWinInetCacheHints2Vtbl + IWinInetCacheHints2Vtbl* {.pure, inheritable.} = object of IWinInetCacheHintsVtbl + SetCacheExtension2*: proc(self: ptr IWinInetCacheHints2, pwzExt: LPCWSTR, pwzCacheFile: ptr WCHAR, pcchCacheFile: ptr DWORD, pdwWinInetError: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + LPWININETCACHEHINTS2* = ptr IWinInetCacheHints2 + IBindHost* {.pure.} = object + lpVtbl*: ptr IBindHostVtbl + IBindHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateMoniker*: proc(self: ptr IBindHost, szName: LPOLESTR, pBC: ptr IBindCtx, ppmk: ptr ptr IMoniker, dwReserved: DWORD): HRESULT {.stdcall.} + MonikerBindToStorage*: proc(self: ptr IBindHost, pMk: ptr IMoniker, pBC: ptr IBindCtx, pBSC: ptr IBindStatusCallback, riid: REFIID, ppvObj: ptr pointer): HRESULT {.stdcall.} + MonikerBindToObject*: proc(self: ptr IBindHost, pMk: ptr IMoniker, pBC: ptr IBindCtx, pBSC: ptr IBindStatusCallback, riid: REFIID, ppvObj: ptr pointer): HRESULT {.stdcall.} + LPBINDHOST* = ptr IBindHost + IInternet* {.pure.} = object + lpVtbl*: ptr IInternetVtbl + IInternetVtbl* {.pure, inheritable.} = object of IUnknownVtbl + LPIINTERNET* = ptr IInternet + IInternetBindInfo* {.pure.} = object + lpVtbl*: ptr IInternetBindInfoVtbl + IInternetBindInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetBindInfo*: proc(self: ptr IInternetBindInfo, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO): HRESULT {.stdcall.} + GetBindString*: proc(self: ptr IInternetBindInfo, ulStringType: ULONG, ppwzStr: ptr LPOLESTR, cEl: ULONG, pcElFetched: ptr ULONG): HRESULT {.stdcall.} + LPIINTERNETBINDINFO* = ptr IInternetBindInfo + IInternetBindInfoEx* {.pure.} = object + lpVtbl*: ptr IInternetBindInfoExVtbl + IInternetBindInfoExVtbl* {.pure, inheritable.} = object of IInternetBindInfoVtbl + GetBindInfoEx*: proc(self: ptr IInternetBindInfoEx, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO, grfBINDF2: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.stdcall.} + LPIINTERNETBINDINFOEX* = ptr IInternetBindInfoEx + PROTOCOLDATA* {.pure.} = object + grfFlags*: DWORD + dwState*: DWORD + pData*: LPVOID + cbData*: ULONG + IInternetProtocolSink* {.pure.} = object + lpVtbl*: ptr IInternetProtocolSinkVtbl + IInternetProtocolSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Switch*: proc(self: ptr IInternetProtocolSink, pProtocolData: ptr PROTOCOLDATA): HRESULT {.stdcall.} + ReportProgress*: proc(self: ptr IInternetProtocolSink, ulStatusCode: ULONG, szStatusText: LPCWSTR): HRESULT {.stdcall.} + ReportData*: proc(self: ptr IInternetProtocolSink, grfBSCF: DWORD, ulProgress: ULONG, ulProgressMax: ULONG): HRESULT {.stdcall.} + ReportResult*: proc(self: ptr IInternetProtocolSink, hrResult: HRESULT, dwError: DWORD, szResult: LPCWSTR): HRESULT {.stdcall.} + IInternetProtocolRoot* {.pure.} = object + lpVtbl*: ptr IInternetProtocolRootVtbl + IInternetProtocolRootVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Start*: proc(self: ptr IInternetProtocolRoot, szUrl: LPCWSTR, pOIProtSink: ptr IInternetProtocolSink, pOIBindInfo: ptr IInternetBindInfo, grfPI: DWORD, dwReserved: HANDLE_PTR): HRESULT {.stdcall.} + Continue*: proc(self: ptr IInternetProtocolRoot, pProtocolData: ptr PROTOCOLDATA): HRESULT {.stdcall.} + Abort*: proc(self: ptr IInternetProtocolRoot, hrReason: HRESULT, dwOptions: DWORD): HRESULT {.stdcall.} + Terminate*: proc(self: ptr IInternetProtocolRoot, dwOptions: DWORD): HRESULT {.stdcall.} + Suspend*: proc(self: ptr IInternetProtocolRoot): HRESULT {.stdcall.} + Resume*: proc(self: ptr IInternetProtocolRoot): HRESULT {.stdcall.} + LPIINTERNETPROTOCOLROOT* = ptr IInternetProtocolRoot + IInternetProtocol* {.pure.} = object + lpVtbl*: ptr IInternetProtocolVtbl + IInternetProtocolVtbl* {.pure, inheritable.} = object of IInternetProtocolRootVtbl + Read*: proc(self: ptr IInternetProtocol, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.stdcall.} + Seek*: proc(self: ptr IInternetProtocol, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ptr ULARGE_INTEGER): HRESULT {.stdcall.} + LockRequest*: proc(self: ptr IInternetProtocol, dwOptions: DWORD): HRESULT {.stdcall.} + UnlockRequest*: proc(self: ptr IInternetProtocol): HRESULT {.stdcall.} + LPIINTERNETPROTOCOL* = ptr IInternetProtocol + LPIINTERNETPROTOCOLSINK* = ptr IInternetProtocolSink + IInternetProtocolSinkStackable* {.pure.} = object + lpVtbl*: ptr IInternetProtocolSinkStackableVtbl + IInternetProtocolSinkStackableVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SwitchSink*: proc(self: ptr IInternetProtocolSinkStackable, pOIProtSink: ptr IInternetProtocolSink): HRESULT {.stdcall.} + CommitSwitch*: proc(self: ptr IInternetProtocolSinkStackable): HRESULT {.stdcall.} + RollbackSwitch*: proc(self: ptr IInternetProtocolSinkStackable): HRESULT {.stdcall.} + LPIINTERNETPROTOCOLSINKStackable* = ptr IInternetProtocolSinkStackable + IInternetSession* {.pure.} = object + lpVtbl*: ptr IInternetSessionVtbl + IInternetSessionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterNameSpace*: proc(self: ptr IInternetSession, pCF: ptr IClassFactory, rclsid: REFCLSID, pwzProtocol: LPCWSTR, cPatterns: ULONG, ppwzPatterns: ptr LPCWSTR, dwReserved: DWORD): HRESULT {.stdcall.} + UnregisterNameSpace*: proc(self: ptr IInternetSession, pCF: ptr IClassFactory, pszProtocol: LPCWSTR): HRESULT {.stdcall.} + RegisterMimeFilter*: proc(self: ptr IInternetSession, pCF: ptr IClassFactory, rclsid: REFCLSID, pwzType: LPCWSTR): HRESULT {.stdcall.} + UnregisterMimeFilter*: proc(self: ptr IInternetSession, pCF: ptr IClassFactory, pwzType: LPCWSTR): HRESULT {.stdcall.} + CreateBinding*: proc(self: ptr IInternetSession, pBC: LPBC, szUrl: LPCWSTR, pUnkOuter: ptr IUnknown, ppUnk: ptr ptr IUnknown, ppOInetProt: ptr ptr IInternetProtocol, dwOption: DWORD): HRESULT {.stdcall.} + SetSessionOption*: proc(self: ptr IInternetSession, dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + GetSessionOption*: proc(self: ptr IInternetSession, dwOption: DWORD, pBuffer: LPVOID, pdwBufferLength: ptr DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + LPIINTERNETSESSION* = ptr IInternetSession + IInternetThreadSwitch* {.pure.} = object + lpVtbl*: ptr IInternetThreadSwitchVtbl + IInternetThreadSwitchVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Prepare*: proc(self: ptr IInternetThreadSwitch): HRESULT {.stdcall.} + Continue*: proc(self: ptr IInternetThreadSwitch): HRESULT {.stdcall.} + LPIINTERNETTHREADSWITCH* = ptr IInternetThreadSwitch + IInternetPriority* {.pure.} = object + lpVtbl*: ptr IInternetPriorityVtbl + IInternetPriorityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetPriority*: proc(self: ptr IInternetPriority, nPriority: LONG): HRESULT {.stdcall.} + GetPriority*: proc(self: ptr IInternetPriority, pnPriority: ptr LONG): HRESULT {.stdcall.} + LPIINTERNETPRIORITY* = ptr IInternetPriority + IInternetProtocolInfo* {.pure.} = object + lpVtbl*: ptr IInternetProtocolInfoVtbl + IInternetProtocolInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseUrl*: proc(self: ptr IInternetProtocolInfo, pwzUrl: LPCWSTR, ParseAction: PARSEACTION, dwParseFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + CombineUrl*: proc(self: ptr IInternetProtocolInfo, pwzBaseUrl: LPCWSTR, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + CompareUrl*: proc(self: ptr IInternetProtocolInfo, pwzUrl1: LPCWSTR, pwzUrl2: LPCWSTR, dwCompareFlags: DWORD): HRESULT {.stdcall.} + QueryInfo*: proc(self: ptr IInternetProtocolInfo, pwzUrl: LPCWSTR, OueryOption: QUERYOPTION, dwQueryFlags: DWORD, pBuffer: LPVOID, cbBuffer: DWORD, pcbBuf: ptr DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + LPIINTERNETPROTOCOLINFO* = ptr IInternetProtocolInfo + IOInet* = IInternet + IOInetBindInfo* = IInternetBindInfo + IOInetBindInfoEx* = IInternetBindInfoEx + IOInetProtocolRoot* = IInternetProtocolRoot + IOInetProtocol* = IInternetProtocol + IUri* {.pure.} = object + lpVtbl*: ptr IUriVtbl + IUriVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPropertyBSTR*: proc(self: ptr IUri, uriProp: Uri_PROPERTY, pbstrProperty: ptr BSTR, dwFlags: DWORD): HRESULT {.stdcall.} + GetPropertyLength*: proc(self: ptr IUri, uriProp: Uri_PROPERTY, pcchProperty: ptr DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + GetPropertyDWORD*: proc(self: ptr IUri, uriProp: Uri_PROPERTY, pdwProperty: ptr DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + HasProperty*: proc(self: ptr IUri, uriProp: Uri_PROPERTY, pfHasProperty: ptr WINBOOL): HRESULT {.stdcall.} + GetAbsoluteUri*: proc(self: ptr IUri, pbstrAbsoluteUri: ptr BSTR): HRESULT {.stdcall.} + GetAuthority*: proc(self: ptr IUri, pbstrAuthority: ptr BSTR): HRESULT {.stdcall.} + GetDisplayUri*: proc(self: ptr IUri, pbstrDisplayString: ptr BSTR): HRESULT {.stdcall.} + GetDomain*: proc(self: ptr IUri, pbstrDomain: ptr BSTR): HRESULT {.stdcall.} + GetExtension*: proc(self: ptr IUri, pbstrExtension: ptr BSTR): HRESULT {.stdcall.} + GetFragment*: proc(self: ptr IUri, pbstrFragment: ptr BSTR): HRESULT {.stdcall.} + GetHost*: proc(self: ptr IUri, pbstrHost: ptr BSTR): HRESULT {.stdcall.} + GetPassword*: proc(self: ptr IUri, pbstrPassword: ptr BSTR): HRESULT {.stdcall.} + GetPath*: proc(self: ptr IUri, pbstrPath: ptr BSTR): HRESULT {.stdcall.} + GetPathAndQuery*: proc(self: ptr IUri, pbstrPathAndQuery: ptr BSTR): HRESULT {.stdcall.} + GetQuery*: proc(self: ptr IUri, pbstrQuery: ptr BSTR): HRESULT {.stdcall.} + GetRawUri*: proc(self: ptr IUri, pbstrRawUri: ptr BSTR): HRESULT {.stdcall.} + GetSchemeName*: proc(self: ptr IUri, pbstrSchemeName: ptr BSTR): HRESULT {.stdcall.} + GetUserInfo*: proc(self: ptr IUri, pbstrUserInfo: ptr BSTR): HRESULT {.stdcall.} + GetUserName*: proc(self: ptr IUri, pbstrUserName: ptr BSTR): HRESULT {.stdcall.} + GetHostType*: proc(self: ptr IUri, pdwHostType: ptr DWORD): HRESULT {.stdcall.} + GetPort*: proc(self: ptr IUri, pdwPort: ptr DWORD): HRESULT {.stdcall.} + GetScheme*: proc(self: ptr IUri, pdwScheme: ptr DWORD): HRESULT {.stdcall.} + GetZone*: proc(self: ptr IUri, pdwZone: ptr DWORD): HRESULT {.stdcall.} + GetProperties*: proc(self: ptr IUri, pdwFlags: LPDWORD): HRESULT {.stdcall.} + IsEqual*: proc(self: ptr IUri, pUri: ptr IUri, pfEqual: ptr WINBOOL): HRESULT {.stdcall.} + IInternetProtocolEx* {.pure.} = object + lpVtbl*: ptr IInternetProtocolExVtbl + IInternetProtocolExVtbl* {.pure, inheritable.} = object of IInternetProtocolVtbl + StartEx*: proc(self: ptr IInternetProtocolEx, pUri: ptr IUri, pOIProtSink: ptr IInternetProtocolSink, pOIBindInfo: ptr IInternetBindInfo, grfPI: DWORD, dwReserved: HANDLE_PTR): HRESULT {.stdcall.} + IOInetProtocolEx* = IInternetProtocolEx + IOInetProtocolSink* = IInternetProtocolSink + IOInetProtocolInfo* = IInternetProtocolInfo + IOInetSession* = IInternetSession + IOInetPriority* = IInternetPriority + IOInetThreadSwitch* = IInternetThreadSwitch + IOInetProtocolSinkStackable* = IInternetProtocolSinkStackable + LPOINET* = LPIINTERNET + LPOINETPROTOCOLINFO* = LPIINTERNETPROTOCOLINFO + LPOINETBINDINFO* = LPIINTERNETBINDINFO + LPOINETPROTOCOLROOT* = LPIINTERNETPROTOCOLROOT + LPOINETPROTOCOL* = LPIINTERNETPROTOCOL + LPOINETPROTOCOLSINK* = LPIINTERNETPROTOCOLSINK + LPOINETSESSION* = LPIINTERNETSESSION + LPOINETTHREADSWITCH* = LPIINTERNETTHREADSWITCH + LPOINETPRIORITY* = LPIINTERNETPRIORITY + LPOINETPROTOCOLSINKSTACKABLE* = LPIINTERNETPROTOCOLSINKSTACKABLE + ZONEATTRIBUTES* {.pure.} = object + cbSize*: ULONG + szDisplayName*: array[260, WCHAR] + szDescription*: array[200, WCHAR] + szIconPath*: array[260, WCHAR] + dwTemplateMinLevel*: DWORD + dwTemplateRecommended*: DWORD + dwTemplateCurrentLevel*: DWORD + dwFlags*: DWORD + IInternetZoneManager* {.pure.} = object + lpVtbl*: ptr IInternetZoneManagerVtbl + IInternetZoneManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetZoneAttributes*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES): HRESULT {.stdcall.} + SetZoneAttributes*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES): HRESULT {.stdcall.} + GetZoneCustomPolicy*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, urlZoneReg: URLZONEREG): HRESULT {.stdcall.} + SetZoneCustomPolicy*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, guidKey: REFGUID, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.stdcall.} + GetZoneActionPolicy*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.stdcall.} + SetZoneActionPolicy*: proc(self: ptr IInternetZoneManager, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.stdcall.} + PromptAction*: proc(self: ptr IInternetZoneManager, dwAction: DWORD, hwndParent: HWND, pwszUrl: LPCWSTR, pwszText: LPCWSTR, dwPromptFlags: DWORD): HRESULT {.stdcall.} + LogAction*: proc(self: ptr IInternetZoneManager, dwAction: DWORD, pwszUrl: LPCWSTR, pwszText: LPCWSTR, dwLogFlags: DWORD): HRESULT {.stdcall.} + CreateZoneEnumerator*: proc(self: ptr IInternetZoneManager, pdwEnum: ptr DWORD, pdwCount: ptr DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + GetZoneAt*: proc(self: ptr IInternetZoneManager, dwEnum: DWORD, dwIndex: DWORD, pdwZone: ptr DWORD): HRESULT {.stdcall.} + DestroyZoneEnumerator*: proc(self: ptr IInternetZoneManager, dwEnum: DWORD): HRESULT {.stdcall.} + CopyTemplatePoliciesToZone*: proc(self: ptr IInternetZoneManager, dwTemplate: DWORD, dwZone: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + LPURLZONEMANAGER* = ptr IInternetZoneManager + LPZONEATTRIBUTES* = ptr ZONEATTRIBUTES + ICatalogFileInfo* {.pure.} = object + lpVtbl*: ptr ICatalogFileInfoVtbl + ICatalogFileInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCatalogFile*: proc(self: ptr ICatalogFileInfo, ppszCatalogFile: ptr LPSTR): HRESULT {.stdcall.} + GetJavaTrust*: proc(self: ptr ICatalogFileInfo, ppJavaTrust: ptr pointer): HRESULT {.stdcall.} + LPCATALOGFILEINFO* = ptr ICatalogFileInfo + IDataFilter* {.pure.} = object + lpVtbl*: ptr IDataFilterVtbl + IDataFilterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DoEncode*: proc(self: ptr IDataFilter, dwFlags: DWORD, lInBufferSize: LONG, pbInBuffer: ptr BYTE, lOutBufferSize: LONG, pbOutBuffer: ptr BYTE, lInBytesAvailable: LONG, plInBytesRead: ptr LONG, plOutBytesWritten: ptr LONG, dwReserved: DWORD): HRESULT {.stdcall.} + DoDecode*: proc(self: ptr IDataFilter, dwFlags: DWORD, lInBufferSize: LONG, pbInBuffer: ptr BYTE, lOutBufferSize: LONG, pbOutBuffer: ptr BYTE, lInBytesAvailable: LONG, plInBytesRead: ptr LONG, plOutBytesWritten: ptr LONG, dwReserved: DWORD): HRESULT {.stdcall.} + SetEncodingLevel*: proc(self: ptr IDataFilter, dwEncLevel: DWORD): HRESULT {.stdcall.} + LPDATAFILTER* = ptr IDataFilter + DATAINFO* {.pure.} = object + ulTotalSize*: ULONG + ulavrPacketSize*: ULONG + ulConnectSpeed*: ULONG + ulProcessorSpeed*: ULONG + IEncodingFilterFactory* {.pure.} = object + lpVtbl*: ptr IEncodingFilterFactoryVtbl + IEncodingFilterFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FindBestFilter*: proc(self: ptr IEncodingFilterFactory, pwzCodeIn: LPCWSTR, pwzCodeOut: LPCWSTR, info: DATAINFO, ppDF: ptr ptr IDataFilter): HRESULT {.stdcall.} + GetDefaultFilter*: proc(self: ptr IEncodingFilterFactory, pwzCodeIn: LPCWSTR, pwzCodeOut: LPCWSTR, ppDF: ptr ptr IDataFilter): HRESULT {.stdcall.} + LPENCODINGFILTERFACTORY* = ptr IEncodingFilterFactory + IWrappedProtocol* {.pure.} = object + lpVtbl*: ptr IWrappedProtocolVtbl + IWrappedProtocolVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWrapperCode*: proc(self: ptr IWrappedProtocol, pnCode: ptr LONG, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + LPIWRAPPEDPROTOCOL* = ptr IWrappedProtocol + IGetBindHandle* {.pure.} = object + lpVtbl*: ptr IGetBindHandleVtbl + IGetBindHandleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetBindHandle*: proc(self: ptr IGetBindHandle, enumRequestedHandle: BINDHANDLETYPES, pRetHandle: ptr HANDLE): HRESULT {.stdcall.} + LPGETBINDHANDLE* = ptr IGetBindHandle + IBindCallbackRedirect* {.pure.} = object + lpVtbl*: ptr IBindCallbackRedirectVtbl + IBindCallbackRedirectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Redirect*: proc(self: ptr IBindCallbackRedirect, lpcUrl: LPCWSTR, vbCancel: ptr VARIANT_BOOL): HRESULT {.stdcall.} + LPBINDCALLBACKREDIRECT* = ptr IBindCallbackRedirect + CLIPDATA* {.pure.} = object + cbSize*: ULONG + ulClipFmt*: LONG + pClipData*: ptr BYTE + VERSIONEDSTREAM* {.pure.} = object + guidVersion*: GUID + pStream*: ptr IStream + LPVERSIONEDSTREAM* = ptr VERSIONEDSTREAM + CAC* {.pure.} = object + cElems*: ULONG + pElems*: ptr CHAR + CAUB* {.pure.} = object + cElems*: ULONG + pElems*: ptr UCHAR + CAI* {.pure.} = object + cElems*: ULONG + pElems*: ptr SHORT + CAUI* {.pure.} = object + cElems*: ULONG + pElems*: ptr USHORT + CAL* {.pure.} = object + cElems*: ULONG + pElems*: ptr LONG + CAUL* {.pure.} = object + cElems*: ULONG + pElems*: ptr ULONG + CAH* {.pure.} = object + cElems*: ULONG + pElems*: ptr LARGE_INTEGER + CAUH* {.pure.} = object + cElems*: ULONG + pElems*: ptr ULARGE_INTEGER + CAFLT* {.pure.} = object + cElems*: ULONG + pElems*: ptr FLOAT + CADBL* {.pure.} = object + cElems*: ULONG + pElems*: ptr DOUBLE + CABOOL* {.pure.} = object + cElems*: ULONG + pElems*: ptr VARIANT_BOOL + CASCODE* {.pure.} = object + cElems*: ULONG + pElems*: ptr SCODE + CACY* {.pure.} = object + cElems*: ULONG + pElems*: ptr CY + CADATE* {.pure.} = object + cElems*: ULONG + pElems*: ptr DATE + CAFILETIME* {.pure.} = object + cElems*: ULONG + pElems*: ptr FILETIME + CACLSID* {.pure.} = object + cElems*: ULONG + pElems*: ptr CLSID + CACLIPDATA* {.pure.} = object + cElems*: ULONG + pElems*: ptr CLIPDATA + CABSTR* {.pure.} = object + cElems*: ULONG + pElems*: ptr BSTR + CABSTRBLOB* {.pure.} = object + cElems*: ULONG + pElems*: ptr BSTRBLOB + CALPSTR* {.pure.} = object + cElems*: ULONG + pElems*: ptr LPSTR + CALPWSTR* {.pure.} = object + cElems*: ULONG + pElems*: ptr LPWSTR + CAPROPVARIANT* {.pure.} = object + cElems*: ULONG + pElems*: ptr PROPVARIANT + PROPVARIANT_UNION1_STRUCT1_UNION1* {.pure, union.} = object + cVal*: CHAR + bVal*: UCHAR + iVal*: SHORT + uiVal*: USHORT + lVal*: LONG + ulVal*: ULONG + intVal*: INT + uintVal*: UINT + hVal*: LARGE_INTEGER + uhVal*: ULARGE_INTEGER + fltVal*: FLOAT + dblVal*: DOUBLE + boolVal*: VARIANT_BOOL + scode*: SCODE + cyVal*: CY + date*: DATE + filetime*: FILETIME + puuid*: ptr CLSID + pclipdata*: ptr CLIPDATA + bstrVal*: BSTR + bstrblobVal*: BSTRBLOB + blob*: BLOB + pszVal*: LPSTR + pwszVal*: LPWSTR + punkVal*: ptr IUnknown + pdispVal*: ptr IDispatch + pStream*: ptr IStream + pStorage*: ptr IStorage + pVersionedStream*: LPVERSIONEDSTREAM + parray*: LPSAFEARRAY + cac*: CAC + caub*: CAUB + cai*: CAI + caui*: CAUI + cal*: CAL + caul*: CAUL + cah*: CAH + cauh*: CAUH + caflt*: CAFLT + cadbl*: CADBL + cabool*: CABOOL + cascode*: CASCODE + cacy*: CACY + cadate*: CADATE + cafiletime*: CAFILETIME + cauuid*: CACLSID + caclipdata*: CACLIPDATA + cabstr*: CABSTR + cabstrblob*: CABSTRBLOB + calpstr*: CALPSTR + calpwstr*: CALPWSTR + capropvar*: CAPROPVARIANT + pcVal*: ptr CHAR + pbVal*: ptr UCHAR + piVal*: ptr SHORT + puiVal*: ptr USHORT + plVal*: ptr LONG + pulVal*: ptr ULONG + pintVal*: ptr INT + puintVal*: ptr UINT + pfltVal*: ptr FLOAT + pdblVal*: ptr DOUBLE + pboolVal*: ptr VARIANT_BOOL + pdecVal*: ptr DECIMAL + pscode*: ptr SCODE + pcyVal*: ptr CY + pdate*: ptr DATE + pbstrVal*: ptr BSTR + ppunkVal*: ptr ptr IUnknown + ppdispVal*: ptr ptr IDispatch + pparray*: ptr LPSAFEARRAY + pvarVal*: ptr PROPVARIANT + PROPVARIANT_UNION1_STRUCT1* {.pure.} = object + vt*: VARTYPE + wReserved1*: PROPVAR_PAD1 + wReserved2*: PROPVAR_PAD2 + wReserved3*: PROPVAR_PAD3 + union1*: PROPVARIANT_UNION1_STRUCT1_UNION1 + PROPVARIANT_UNION1* {.pure, union.} = object + struct1*: PROPVARIANT_UNION1_STRUCT1 + decVal*: DECIMAL + PROPVARIANT* {.pure.} = object + union1*: PROPVARIANT_UNION1 + LPPROPVARIANT* = ptr PROPVARIANT + REFPROPVARIANT* = ptr PROPVARIANT + PROPSPEC_UNION1* {.pure, union.} = object + propid*: PROPID + lpwstr*: LPOLESTR + PROPSPEC* {.pure.} = object + ulKind*: ULONG + union1*: PROPSPEC_UNION1 + STATPROPSTG* {.pure.} = object + lpwstrName*: LPOLESTR + propid*: PROPID + vt*: VARTYPE + IEnumSTATPROPSTG* {.pure.} = object + lpVtbl*: ptr IEnumSTATPROPSTGVtbl + IEnumSTATPROPSTGVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumSTATPROPSTG, celt: ULONG, rgelt: ptr STATPROPSTG, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumSTATPROPSTG, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumSTATPROPSTG): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumSTATPROPSTG, ppenum: ptr ptr IEnumSTATPROPSTG): HRESULT {.stdcall.} + STATPROPSETSTG* {.pure.} = object + fmtid*: FMTID + clsid*: CLSID + grfFlags*: DWORD + mtime*: FILETIME + ctime*: FILETIME + atime*: FILETIME + dwOSVersion*: DWORD + IPropertyStorage* {.pure.} = object + lpVtbl*: ptr IPropertyStorageVtbl + IPropertyStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ReadMultiple*: proc(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgpropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + WriteMultiple*: proc(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgpropvar: ptr PROPVARIANT, propidNameFirst: PROPID): HRESULT {.stdcall.} + DeleteMultiple*: proc(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC): HRESULT {.stdcall.} + ReadPropertyNames*: proc(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID, rglpwstrName: ptr LPOLESTR): HRESULT {.stdcall.} + WritePropertyNames*: proc(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID, rglpwstrName: ptr LPOLESTR): HRESULT {.stdcall.} + DeletePropertyNames*: proc(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID): HRESULT {.stdcall.} + Commit*: proc(self: ptr IPropertyStorage, grfCommitFlags: DWORD): HRESULT {.stdcall.} + Revert*: proc(self: ptr IPropertyStorage): HRESULT {.stdcall.} + Enum*: proc(self: ptr IPropertyStorage, ppenum: ptr ptr IEnumSTATPROPSTG): HRESULT {.stdcall.} + SetTimes*: proc(self: ptr IPropertyStorage, pctime: ptr FILETIME, patime: ptr FILETIME, pmtime: ptr FILETIME): HRESULT {.stdcall.} + SetClass*: proc(self: ptr IPropertyStorage, clsid: REFCLSID): HRESULT {.stdcall.} + Stat*: proc(self: ptr IPropertyStorage, pstatpsstg: ptr STATPROPSETSTG): HRESULT {.stdcall.} + IEnumSTATPROPSETSTG* {.pure.} = object + lpVtbl*: ptr IEnumSTATPROPSETSTGVtbl + IEnumSTATPROPSETSTGVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumSTATPROPSETSTG, celt: ULONG, rgelt: ptr STATPROPSETSTG, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumSTATPROPSETSTG, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumSTATPROPSETSTG): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumSTATPROPSETSTG, ppenum: ptr ptr IEnumSTATPROPSETSTG): HRESULT {.stdcall.} + IPropertySetStorage* {.pure.} = object + lpVtbl*: ptr IPropertySetStorageVtbl + IPropertySetStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Create*: proc(self: ptr IPropertySetStorage, rfmtid: REFFMTID, pclsid: ptr CLSID, grfFlags: DWORD, grfMode: DWORD, ppprstg: ptr ptr IPropertyStorage): HRESULT {.stdcall.} + Open*: proc(self: ptr IPropertySetStorage, rfmtid: REFFMTID, grfMode: DWORD, ppprstg: ptr ptr IPropertyStorage): HRESULT {.stdcall.} + Delete*: proc(self: ptr IPropertySetStorage, rfmtid: REFFMTID): HRESULT {.stdcall.} + Enum*: proc(self: ptr IPropertySetStorage, ppenum: ptr ptr IEnumSTATPROPSETSTG): HRESULT {.stdcall.} + LPPROPERTYSETSTORAGE* = ptr IPropertySetStorage + LPENUMSTATPROPSTG* = ptr IEnumSTATPROPSTG + LPENUMSTATPROPSETSTG* = ptr IEnumSTATPROPSETSTG + LPPROPERTYSTORAGE* = ptr IPropertyStorage + CONNECTDATA* {.pure.} = object + pUnk*: ptr IUnknown + dwCookie*: DWORD + LPCONNECTDATA* = ptr CONNECTDATA + IEnumConnections* {.pure.} = object + lpVtbl*: ptr IEnumConnectionsVtbl + IEnumConnectionsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumConnections, cConnections: ULONG, rgcd: LPCONNECTDATA, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumConnections, cConnections: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumConnections): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumConnections, ppEnum: ptr ptr IEnumConnections): HRESULT {.stdcall.} + PENUMCONNECTIONS* = ptr IEnumConnections + LPENUMCONNECTIONS* = ptr IEnumConnections + PCONNECTDATA* = ptr CONNECTDATA + LPCONNECTIONPOINT* = ptr IConnectionPoint + IEnumConnectionPoints* {.pure.} = object + lpVtbl*: ptr IEnumConnectionPointsVtbl + IEnumConnectionPointsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumConnectionPoints, cConnections: ULONG, ppCP: ptr LPCONNECTIONPOINT, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumConnectionPoints, cConnections: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumConnectionPoints): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumConnectionPoints, ppEnum: ptr ptr IEnumConnectionPoints): HRESULT {.stdcall.} + IConnectionPointContainer* {.pure.} = object + lpVtbl*: ptr IConnectionPointContainerVtbl + IConnectionPointContainerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnumConnectionPoints*: proc(self: ptr IConnectionPointContainer, ppEnum: ptr ptr IEnumConnectionPoints): HRESULT {.stdcall.} + FindConnectionPoint*: proc(self: ptr IConnectionPointContainer, riid: REFIID, ppCP: ptr ptr IConnectionPoint): HRESULT {.stdcall.} + IConnectionPoint* {.pure.} = object + lpVtbl*: ptr IConnectionPointVtbl + IConnectionPointVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetConnectionInterface*: proc(self: ptr IConnectionPoint, pIID: ptr IID): HRESULT {.stdcall.} + GetConnectionPointContainer*: proc(self: ptr IConnectionPoint, ppCPC: ptr ptr IConnectionPointContainer): HRESULT {.stdcall.} + Advise*: proc(self: ptr IConnectionPoint, pUnkSink: ptr IUnknown, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IConnectionPoint, dwCookie: DWORD): HRESULT {.stdcall.} + EnumConnections*: proc(self: ptr IConnectionPoint, ppEnum: ptr ptr IEnumConnections): HRESULT {.stdcall.} + PCONNECTIONPOINT* = ptr IConnectionPoint + PENUMCONNECTIONPOINTS* = ptr IEnumConnectionPoints + LPENUMCONNECTIONPOINTS* = ptr IEnumConnectionPoints + PCONNECTIONPOINTCONTAINER* = ptr IConnectionPointContainer + LPCONNECTIONPOINTCONTAINER* = ptr IConnectionPointContainer + LICINFO* {.pure.} = object + cbLicInfo*: LONG + fRuntimeKeyAvail*: WINBOOL + fLicVerified*: WINBOOL + IClassFactory2* {.pure.} = object + lpVtbl*: ptr IClassFactory2Vtbl + IClassFactory2Vtbl* {.pure, inheritable.} = object of IClassFactoryVtbl + GetLicInfo*: proc(self: ptr IClassFactory2, pLicInfo: ptr LICINFO): HRESULT {.stdcall.} + RequestLicKey*: proc(self: ptr IClassFactory2, dwReserved: DWORD, pBstrKey: ptr BSTR): HRESULT {.stdcall.} + CreateInstanceLic*: proc(self: ptr IClassFactory2, pUnkOuter: ptr IUnknown, pUnkReserved: ptr IUnknown, riid: REFIID, bstrKey: BSTR, ppvObj: ptr PVOID): HRESULT {.stdcall.} + LPCLASSFACTORY2* = ptr IClassFactory2 + LPLICINFO* = ptr LICINFO + IProvideClassInfo* {.pure.} = object + lpVtbl*: ptr IProvideClassInfoVtbl + IProvideClassInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClassInfo*: proc(self: ptr IProvideClassInfo, ppTI: ptr ptr ITypeInfo): HRESULT {.stdcall.} + LPPROVIDECLASSINFO* = ptr IProvideClassInfo + IProvideClassInfo2* {.pure.} = object + lpVtbl*: ptr IProvideClassInfo2Vtbl + IProvideClassInfo2Vtbl* {.pure, inheritable.} = object of IProvideClassInfoVtbl + GetGUID*: proc(self: ptr IProvideClassInfo2, dwGuidKind: DWORD, pGUID: ptr GUID): HRESULT {.stdcall.} + LPPROVIDECLASSINFO2* = ptr IProvideClassInfo2 + IProvideMultipleClassInfo* {.pure.} = object + lpVtbl*: ptr IProvideMultipleClassInfoVtbl + IProvideMultipleClassInfoVtbl* {.pure, inheritable.} = object of IProvideClassInfo2Vtbl + GetMultiTypeInfoCount*: proc(self: ptr IProvideMultipleClassInfo, pcti: ptr ULONG): HRESULT {.stdcall.} + GetInfoOfIndex*: proc(self: ptr IProvideMultipleClassInfo, iti: ULONG, dwFlags: DWORD, pptiCoClass: ptr ptr ITypeInfo, pdwTIFlags: ptr DWORD, pcdispidReserved: ptr ULONG, piidPrimary: ptr IID, piidSource: ptr IID): HRESULT {.stdcall.} + LPPROVIDEMULTIPLECLASSINFO* = ptr IProvideMultipleClassInfo + CONTROLINFO* {.pure.} = object + cb*: ULONG + hAccel*: HACCEL + cAccel*: USHORT + dwFlags*: DWORD + IOleControl* {.pure.} = object + lpVtbl*: ptr IOleControlVtbl + IOleControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetControlInfo*: proc(self: ptr IOleControl, pCI: ptr CONTROLINFO): HRESULT {.stdcall.} + OnMnemonic*: proc(self: ptr IOleControl, pMsg: ptr MSG): HRESULT {.stdcall.} + OnAmbientPropertyChange*: proc(self: ptr IOleControl, dispID: DISPID): HRESULT {.stdcall.} + FreezeEvents*: proc(self: ptr IOleControl, bFreeze: WINBOOL): HRESULT {.stdcall.} + LPOLECONTROL* = ptr IOleControl + LPCONTROLINFO* = ptr CONTROLINFO + POINTF* {.pure.} = object + x*: FLOAT + y*: FLOAT + IOleControlSite* {.pure.} = object + lpVtbl*: ptr IOleControlSiteVtbl + IOleControlSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnControlInfoChanged*: proc(self: ptr IOleControlSite): HRESULT {.stdcall.} + LockInPlaceActive*: proc(self: ptr IOleControlSite, fLock: WINBOOL): HRESULT {.stdcall.} + GetExtendedControl*: proc(self: ptr IOleControlSite, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + TransformCoords*: proc(self: ptr IOleControlSite, pPtlHimetric: ptr POINTL, pPtfContainer: ptr POINTF, dwFlags: DWORD): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IOleControlSite, pMsg: ptr MSG, grfModifiers: DWORD): HRESULT {.stdcall.} + OnFocus*: proc(self: ptr IOleControlSite, fGotFocus: WINBOOL): HRESULT {.stdcall.} + ShowPropertyFrame*: proc(self: ptr IOleControlSite): HRESULT {.stdcall.} + LPOLECONTROLSITE* = ptr IOleControlSite + LPPOINTF* = ptr POINTF + IPropertyPageSite* {.pure.} = object + lpVtbl*: ptr IPropertyPageSiteVtbl + IPropertyPageSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnStatusChange*: proc(self: ptr IPropertyPageSite, dwFlags: DWORD): HRESULT {.stdcall.} + GetLocaleID*: proc(self: ptr IPropertyPageSite, pLocaleID: ptr LCID): HRESULT {.stdcall.} + GetPageContainer*: proc(self: ptr IPropertyPageSite, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IPropertyPageSite, pMsg: ptr MSG): HRESULT {.stdcall.} + PROPPAGEINFO* {.pure.} = object + cb*: ULONG + pszTitle*: LPOLESTR + size*: SIZE + pszDocString*: LPOLESTR + pszHelpFile*: LPOLESTR + dwHelpContext*: DWORD + IPropertyPage* {.pure.} = object + lpVtbl*: ptr IPropertyPageVtbl + IPropertyPageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetPageSite*: proc(self: ptr IPropertyPage, pPageSite: ptr IPropertyPageSite): HRESULT {.stdcall.} + Activate*: proc(self: ptr IPropertyPage, hWndParent: HWND, pRect: LPCRECT, bModal: WINBOOL): HRESULT {.stdcall.} + Deactivate*: proc(self: ptr IPropertyPage): HRESULT {.stdcall.} + GetPageInfo*: proc(self: ptr IPropertyPage, pPageInfo: ptr PROPPAGEINFO): HRESULT {.stdcall.} + SetObjects*: proc(self: ptr IPropertyPage, cObjects: ULONG, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + Show*: proc(self: ptr IPropertyPage, nCmdShow: UINT): HRESULT {.stdcall.} + Move*: proc(self: ptr IPropertyPage, pRect: LPCRECT): HRESULT {.stdcall.} + IsPageDirty*: proc(self: ptr IPropertyPage): HRESULT {.stdcall.} + Apply*: proc(self: ptr IPropertyPage): HRESULT {.stdcall.} + Help*: proc(self: ptr IPropertyPage, pszHelpDir: LPCOLESTR): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IPropertyPage, pMsg: ptr MSG): HRESULT {.stdcall.} + LPPROPERTYPAGE* = ptr IPropertyPage + LPPROPPAGEINFO* = ptr PROPPAGEINFO + IPropertyPage2* {.pure.} = object + lpVtbl*: ptr IPropertyPage2Vtbl + IPropertyPage2Vtbl* {.pure, inheritable.} = object of IPropertyPageVtbl + EditProperty*: proc(self: ptr IPropertyPage2, dispID: DISPID): HRESULT {.stdcall.} + LPPROPERTYPAGE2* = ptr IPropertyPage2 + LPPROPERTYPAGESITE* = ptr IPropertyPageSite + IPropertyNotifySink* {.pure.} = object + lpVtbl*: ptr IPropertyNotifySinkVtbl + IPropertyNotifySinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnChanged*: proc(self: ptr IPropertyNotifySink, dispID: DISPID): HRESULT {.stdcall.} + OnRequestEdit*: proc(self: ptr IPropertyNotifySink, dispID: DISPID): HRESULT {.stdcall.} + LPPROPERTYNOTIFYSINK* = ptr IPropertyNotifySink + CAUUID* {.pure.} = object + cElems*: ULONG + pElems*: ptr GUID + ISpecifyPropertyPages* {.pure.} = object + lpVtbl*: ptr ISpecifyPropertyPagesVtbl + ISpecifyPropertyPagesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPages*: proc(self: ptr ISpecifyPropertyPages, pPages: ptr CAUUID): HRESULT {.stdcall.} + LPSPECIFYPROPERTYPAGES* = ptr ISpecifyPropertyPages + LPCAUUID* = ptr CAUUID + IPersistMemory* {.pure.} = object + lpVtbl*: ptr IPersistMemoryVtbl + IPersistMemoryVtbl* {.pure, inheritable.} = object of IPersistVtbl + IsDirty*: proc(self: ptr IPersistMemory): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistMemory, pMem: LPVOID, cbSize: ULONG): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistMemory, pMem: LPVOID, fClearDirty: WINBOOL, cbSize: ULONG): HRESULT {.stdcall.} + GetSizeMax*: proc(self: ptr IPersistMemory, pCbSize: ptr ULONG): HRESULT {.stdcall.} + InitNew*: proc(self: ptr IPersistMemory): HRESULT {.stdcall.} + LPPERSISTMEMORY* = ptr IPersistMemory + IPersistStreamInit* {.pure.} = object + lpVtbl*: ptr IPersistStreamInitVtbl + IPersistStreamInitVtbl* {.pure, inheritable.} = object of IPersistVtbl + IsDirty*: proc(self: ptr IPersistStreamInit): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistStreamInit, pStm: LPSTREAM): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistStreamInit, pStm: LPSTREAM, fClearDirty: WINBOOL): HRESULT {.stdcall.} + GetSizeMax*: proc(self: ptr IPersistStreamInit, pCbSize: ptr ULARGE_INTEGER): HRESULT {.stdcall.} + InitNew*: proc(self: ptr IPersistStreamInit): HRESULT {.stdcall.} + LPPERSISTSTREAMINIT* = ptr IPersistStreamInit + IPersistPropertyBag* {.pure.} = object + lpVtbl*: ptr IPersistPropertyBagVtbl + IPersistPropertyBagVtbl* {.pure, inheritable.} = object of IPersistVtbl + InitNew*: proc(self: ptr IPersistPropertyBag): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistPropertyBag, pPropBag: ptr IPropertyBag, pErrorLog: ptr IErrorLog): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistPropertyBag, pPropBag: ptr IPropertyBag, fClearDirty: WINBOOL, fSaveAllProperties: WINBOOL): HRESULT {.stdcall.} + LPPERSISTPROPERTYBAG* = ptr IPersistPropertyBag + ISimpleFrameSite* {.pure.} = object + lpVtbl*: ptr ISimpleFrameSiteVtbl + ISimpleFrameSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PreMessageFilter*: proc(self: ptr ISimpleFrameSite, hWnd: HWND, msg: UINT, wp: WPARAM, lp: LPARAM, plResult: ptr LRESULT, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + PostMessageFilter*: proc(self: ptr ISimpleFrameSite, hWnd: HWND, msg: UINT, wp: WPARAM, lp: LPARAM, plResult: ptr LRESULT, dwCookie: DWORD): HRESULT {.stdcall.} + LPSIMPLEFRAMESITE* = ptr ISimpleFrameSite + TEXTMETRICOLE* = TEXTMETRICW + IFont* {.pure.} = object + lpVtbl*: ptr IFontVtbl + IFontVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Name*: proc(self: ptr IFont, pName: ptr BSTR): HRESULT {.stdcall.} + put_Name*: proc(self: ptr IFont, name: BSTR): HRESULT {.stdcall.} + get_Size*: proc(self: ptr IFont, pSize: ptr CY): HRESULT {.stdcall.} + put_Size*: proc(self: ptr IFont, size: CY): HRESULT {.stdcall.} + get_Bold*: proc(self: ptr IFont, pBold: ptr WINBOOL): HRESULT {.stdcall.} + put_Bold*: proc(self: ptr IFont, bold: WINBOOL): HRESULT {.stdcall.} + get_Italic*: proc(self: ptr IFont, pItalic: ptr WINBOOL): HRESULT {.stdcall.} + put_Italic*: proc(self: ptr IFont, italic: WINBOOL): HRESULT {.stdcall.} + get_Underline*: proc(self: ptr IFont, pUnderline: ptr WINBOOL): HRESULT {.stdcall.} + put_Underline*: proc(self: ptr IFont, underline: WINBOOL): HRESULT {.stdcall.} + get_Strikethrough*: proc(self: ptr IFont, pStrikethrough: ptr WINBOOL): HRESULT {.stdcall.} + put_Strikethrough*: proc(self: ptr IFont, strikethrough: WINBOOL): HRESULT {.stdcall.} + get_Weight*: proc(self: ptr IFont, pWeight: ptr SHORT): HRESULT {.stdcall.} + put_Weight*: proc(self: ptr IFont, weight: SHORT): HRESULT {.stdcall.} + get_Charset*: proc(self: ptr IFont, pCharset: ptr SHORT): HRESULT {.stdcall.} + put_Charset*: proc(self: ptr IFont, charset: SHORT): HRESULT {.stdcall.} + get_hFont*: proc(self: ptr IFont, phFont: ptr HFONT): HRESULT {.stdcall.} + Clone*: proc(self: ptr IFont, ppFont: ptr ptr IFont): HRESULT {.stdcall.} + IsEqual*: proc(self: ptr IFont, pFontOther: ptr IFont): HRESULT {.stdcall.} + SetRatio*: proc(self: ptr IFont, cyLogical: LONG, cyHimetric: LONG): HRESULT {.stdcall.} + QueryTextMetrics*: proc(self: ptr IFont, pTM: ptr TEXTMETRICOLE): HRESULT {.stdcall.} + AddRefHfont*: proc(self: ptr IFont, hFont: HFONT): HRESULT {.stdcall.} + ReleaseHfont*: proc(self: ptr IFont, hFont: HFONT): HRESULT {.stdcall.} + SetHdc*: proc(self: ptr IFont, hDC: HDC): HRESULT {.stdcall.} + LPFONT* = ptr IFont + LPTEXTMETRICOLE* = ptr TEXTMETRICOLE + OLE_HANDLE* = UINT + IPicture* {.pure.} = object + lpVtbl*: ptr IPictureVtbl + IPictureVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Handle*: proc(self: ptr IPicture, pHandle: ptr OLE_HANDLE): HRESULT {.stdcall.} + get_hPal*: proc(self: ptr IPicture, phPal: ptr OLE_HANDLE): HRESULT {.stdcall.} + get_Type*: proc(self: ptr IPicture, pType: ptr SHORT): HRESULT {.stdcall.} + get_Width*: proc(self: ptr IPicture, pWidth: ptr OLE_XSIZE_HIMETRIC): HRESULT {.stdcall.} + get_Height*: proc(self: ptr IPicture, pHeight: ptr OLE_YSIZE_HIMETRIC): HRESULT {.stdcall.} + Render*: proc(self: ptr IPicture, hDC: HDC, x: LONG, y: LONG, cx: LONG, cy: LONG, xSrc: OLE_XPOS_HIMETRIC, ySrc: OLE_YPOS_HIMETRIC, cxSrc: OLE_XSIZE_HIMETRIC, cySrc: OLE_YSIZE_HIMETRIC, pRcWBounds: LPCRECT): HRESULT {.stdcall.} + set_hPal*: proc(self: ptr IPicture, hPal: OLE_HANDLE): HRESULT {.stdcall.} + get_CurDC*: proc(self: ptr IPicture, phDC: ptr HDC): HRESULT {.stdcall.} + SelectPicture*: proc(self: ptr IPicture, hDCIn: HDC, phDCOut: ptr HDC, phBmpOut: ptr OLE_HANDLE): HRESULT {.stdcall.} + get_KeepOriginalFormat*: proc(self: ptr IPicture, pKeep: ptr WINBOOL): HRESULT {.stdcall.} + put_KeepOriginalFormat*: proc(self: ptr IPicture, keep: WINBOOL): HRESULT {.stdcall.} + PictureChanged*: proc(self: ptr IPicture): HRESULT {.stdcall.} + SaveAsFile*: proc(self: ptr IPicture, pStream: LPSTREAM, fSaveMemCopy: WINBOOL, pCbSize: ptr LONG): HRESULT {.stdcall.} + get_Attributes*: proc(self: ptr IPicture, pDwAttr: ptr DWORD): HRESULT {.stdcall.} + LPPICTURE* = ptr IPicture + IPicture2* {.pure.} = object + lpVtbl*: ptr IPicture2Vtbl + IPicture2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Handle*: proc(self: ptr IPicture2, pHandle: ptr HHANDLE): HRESULT {.stdcall.} + get_hPal*: proc(self: ptr IPicture2, phPal: ptr HHANDLE): HRESULT {.stdcall.} + get_Type*: proc(self: ptr IPicture2, pType: ptr SHORT): HRESULT {.stdcall.} + get_Width*: proc(self: ptr IPicture2, pWidth: ptr OLE_XSIZE_HIMETRIC): HRESULT {.stdcall.} + get_Height*: proc(self: ptr IPicture2, pHeight: ptr OLE_YSIZE_HIMETRIC): HRESULT {.stdcall.} + Render*: proc(self: ptr IPicture2, hDC: HDC, x: LONG, y: LONG, cx: LONG, cy: LONG, xSrc: OLE_XPOS_HIMETRIC, ySrc: OLE_YPOS_HIMETRIC, cxSrc: OLE_XSIZE_HIMETRIC, cySrc: OLE_YSIZE_HIMETRIC, pRcWBounds: LPCRECT): HRESULT {.stdcall.} + set_hPal*: proc(self: ptr IPicture2, hPal: HHANDLE): HRESULT {.stdcall.} + get_CurDC*: proc(self: ptr IPicture2, phDC: ptr HDC): HRESULT {.stdcall.} + SelectPicture*: proc(self: ptr IPicture2, hDCIn: HDC, phDCOut: ptr HDC, phBmpOut: ptr HHANDLE): HRESULT {.stdcall.} + get_KeepOriginalFormat*: proc(self: ptr IPicture2, pKeep: ptr WINBOOL): HRESULT {.stdcall.} + put_KeepOriginalFormat*: proc(self: ptr IPicture2, keep: WINBOOL): HRESULT {.stdcall.} + PictureChanged*: proc(self: ptr IPicture2): HRESULT {.stdcall.} + SaveAsFile*: proc(self: ptr IPicture2, pStream: LPSTREAM, fSaveMemCopy: WINBOOL, pCbSize: ptr LONG): HRESULT {.stdcall.} + get_Attributes*: proc(self: ptr IPicture2, pDwAttr: ptr DWORD): HRESULT {.stdcall.} + LPPICTURE2* = ptr IPicture2 + IFontEventsDisp* {.pure.} = object + lpVtbl*: ptr IFontEventsDispVtbl + IFontEventsDispVtbl* {.pure, inheritable.} = object of IDispatchVtbl + LPFONTEVENTS* = ptr IFontEventsDisp + IFontDisp* {.pure.} = object + lpVtbl*: ptr IFontDispVtbl + IFontDispVtbl* {.pure, inheritable.} = object of IDispatchVtbl + LPFONTDISP* = ptr IFontDisp + IPictureDisp* {.pure.} = object + lpVtbl*: ptr IPictureDispVtbl + IPictureDispVtbl* {.pure, inheritable.} = object of IDispatchVtbl + LPPICTUREDISP* = ptr IPictureDisp + IOleInPlaceObjectWindowless* {.pure.} = object + lpVtbl*: ptr IOleInPlaceObjectWindowlessVtbl + IOleInPlaceObjectWindowlessVtbl* {.pure, inheritable.} = object of IOleInPlaceObjectVtbl + OnWindowMessage*: proc(self: ptr IOleInPlaceObjectWindowless, msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + GetDropTarget*: proc(self: ptr IOleInPlaceObjectWindowless, ppDropTarget: ptr ptr IDropTarget): HRESULT {.stdcall.} + LPOLEINPLACEOBJECTWINDOWLESS* = ptr IOleInPlaceObjectWindowless + IOleInPlaceSiteEx* {.pure.} = object + lpVtbl*: ptr IOleInPlaceSiteExVtbl + IOleInPlaceSiteExVtbl* {.pure, inheritable.} = object of IOleInPlaceSiteVtbl + OnInPlaceActivateEx*: proc(self: ptr IOleInPlaceSiteEx, pfNoRedraw: ptr WINBOOL, dwFlags: DWORD): HRESULT {.stdcall.} + OnInPlaceDeactivateEx*: proc(self: ptr IOleInPlaceSiteEx, fNoRedraw: WINBOOL): HRESULT {.stdcall.} + RequestUIActivate*: proc(self: ptr IOleInPlaceSiteEx): HRESULT {.stdcall.} + LPOLEINPLACESITEEX* = ptr IOleInPlaceSiteEx + IOleInPlaceSiteWindowless* {.pure.} = object + lpVtbl*: ptr IOleInPlaceSiteWindowlessVtbl + IOleInPlaceSiteWindowlessVtbl* {.pure, inheritable.} = object of IOleInPlaceSiteExVtbl + CanWindowlessActivate*: proc(self: ptr IOleInPlaceSiteWindowless): HRESULT {.stdcall.} + GetCapture*: proc(self: ptr IOleInPlaceSiteWindowless): HRESULT {.stdcall.} + SetCapture*: proc(self: ptr IOleInPlaceSiteWindowless, fCapture: WINBOOL): HRESULT {.stdcall.} + GetFocus*: proc(self: ptr IOleInPlaceSiteWindowless): HRESULT {.stdcall.} + SetFocus*: proc(self: ptr IOleInPlaceSiteWindowless, fFocus: WINBOOL): HRESULT {.stdcall.} + GetDC*: proc(self: ptr IOleInPlaceSiteWindowless, pRect: LPCRECT, grfFlags: DWORD, phDC: ptr HDC): HRESULT {.stdcall.} + ReleaseDC*: proc(self: ptr IOleInPlaceSiteWindowless, hDC: HDC): HRESULT {.stdcall.} + InvalidateRect*: proc(self: ptr IOleInPlaceSiteWindowless, pRect: LPCRECT, fErase: WINBOOL): HRESULT {.stdcall.} + InvalidateRgn*: proc(self: ptr IOleInPlaceSiteWindowless, hRGN: HRGN, fErase: WINBOOL): HRESULT {.stdcall.} + ScrollRect*: proc(self: ptr IOleInPlaceSiteWindowless, dx: INT, dy: INT, pRectScroll: LPCRECT, pRectClip: LPCRECT): HRESULT {.stdcall.} + AdjustRect*: proc(self: ptr IOleInPlaceSiteWindowless, prc: LPRECT): HRESULT {.stdcall.} + OnDefWindowMessage*: proc(self: ptr IOleInPlaceSiteWindowless, msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + LPOLEINPLACESITEWINDOWLESS* = ptr IOleInPlaceSiteWindowless + DVEXTENTINFO* {.pure.} = object + cb*: ULONG + dwExtentMode*: DWORD + sizelProposed*: SIZEL + IViewObjectEx* {.pure.} = object + lpVtbl*: ptr IViewObjectExVtbl + IViewObjectExVtbl* {.pure, inheritable.} = object of IViewObject2Vtbl + GetRect*: proc(self: ptr IViewObjectEx, dwAspect: DWORD, pRect: LPRECTL): HRESULT {.stdcall.} + GetViewStatus*: proc(self: ptr IViewObjectEx, pdwStatus: ptr DWORD): HRESULT {.stdcall.} + QueryHitPoint*: proc(self: ptr IViewObjectEx, dwAspect: DWORD, pRectBounds: LPCRECT, ptlLoc: POINT, lCloseHint: LONG, pHitResult: ptr DWORD): HRESULT {.stdcall.} + QueryHitRect*: proc(self: ptr IViewObjectEx, dwAspect: DWORD, pRectBounds: LPCRECT, pRectLoc: LPCRECT, lCloseHint: LONG, pHitResult: ptr DWORD): HRESULT {.stdcall.} + GetNaturalExtent*: proc(self: ptr IViewObjectEx, dwAspect: DWORD, lindex: LONG, ptd: ptr DVTARGETDEVICE, hicTargetDev: HDC, pExtentInfo: ptr DVEXTENTINFO, pSizel: LPSIZEL): HRESULT {.stdcall.} + LPVIEWOBJECTEX* = ptr IViewObjectEx + IOleUndoUnit* {.pure.} = object + lpVtbl*: ptr IOleUndoUnitVtbl + IOleUndoUnitVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Do*: proc(self: ptr IOleUndoUnit, pUndoManager: ptr IOleUndoManager): HRESULT {.stdcall.} + GetDescription*: proc(self: ptr IOleUndoUnit, pBstr: ptr BSTR): HRESULT {.stdcall.} + GetUnitType*: proc(self: ptr IOleUndoUnit, pClsid: ptr CLSID, plID: ptr LONG): HRESULT {.stdcall.} + OnNextAdd*: proc(self: ptr IOleUndoUnit): HRESULT {.stdcall.} + IEnumOleUndoUnits* {.pure.} = object + lpVtbl*: ptr IEnumOleUndoUnitsVtbl + IEnumOleUndoUnitsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumOleUndoUnits, cElt: ULONG, rgElt: ptr ptr IOleUndoUnit, pcEltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumOleUndoUnits, cElt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumOleUndoUnits): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumOleUndoUnits, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.stdcall.} + IOleUndoManager* {.pure.} = object + lpVtbl*: ptr IOleUndoManagerVtbl + IOleUndoManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Open*: proc(self: ptr IOleUndoManager, pPUU: ptr IOleParentUndoUnit): HRESULT {.stdcall.} + Close*: proc(self: ptr IOleUndoManager, pPUU: ptr IOleParentUndoUnit, fCommit: WINBOOL): HRESULT {.stdcall.} + Add*: proc(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + GetOpenParentState*: proc(self: ptr IOleUndoManager, pdwState: ptr DWORD): HRESULT {.stdcall.} + DiscardFrom*: proc(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + UndoTo*: proc(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + RedoTo*: proc(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + EnumUndoable*: proc(self: ptr IOleUndoManager, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.stdcall.} + EnumRedoable*: proc(self: ptr IOleUndoManager, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.stdcall.} + GetLastUndoDescription*: proc(self: ptr IOleUndoManager, pBstr: ptr BSTR): HRESULT {.stdcall.} + GetLastRedoDescription*: proc(self: ptr IOleUndoManager, pBstr: ptr BSTR): HRESULT {.stdcall.} + Enable*: proc(self: ptr IOleUndoManager, fEnable: WINBOOL): HRESULT {.stdcall.} + IOleParentUndoUnit* {.pure.} = object + lpVtbl*: ptr IOleParentUndoUnitVtbl + IOleParentUndoUnitVtbl* {.pure, inheritable.} = object of IOleUndoUnitVtbl + Open*: proc(self: ptr IOleParentUndoUnit, pPUU: ptr IOleParentUndoUnit): HRESULT {.stdcall.} + Close*: proc(self: ptr IOleParentUndoUnit, pPUU: ptr IOleParentUndoUnit, fCommit: WINBOOL): HRESULT {.stdcall.} + Add*: proc(self: ptr IOleParentUndoUnit, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + FindUnit*: proc(self: ptr IOleParentUndoUnit, pUU: ptr IOleUndoUnit): HRESULT {.stdcall.} + GetParentState*: proc(self: ptr IOleParentUndoUnit, pdwState: ptr DWORD): HRESULT {.stdcall.} + LPOLEUNDOUNIT* = ptr IOleUndoUnit + LPOLEPARENTUNDOUNIT* = ptr IOleParentUndoUnit + LPENUMOLEUNDOUNITS* = ptr IEnumOleUndoUnits + LPOLEUNDOMANAGER* = ptr IOleUndoManager + IPointerInactive* {.pure.} = object + lpVtbl*: ptr IPointerInactiveVtbl + IPointerInactiveVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetActivationPolicy*: proc(self: ptr IPointerInactive, pdwPolicy: ptr DWORD): HRESULT {.stdcall.} + OnInactiveMouseMove*: proc(self: ptr IPointerInactive, pRectBounds: LPCRECT, x: LONG, y: LONG, grfKeyState: DWORD): HRESULT {.stdcall.} + OnInactiveSetCursor*: proc(self: ptr IPointerInactive, pRectBounds: LPCRECT, x: LONG, y: LONG, dwMouseMsg: DWORD, fSetAlways: WINBOOL): HRESULT {.stdcall.} + LPPOINTERINACTIVE* = ptr IPointerInactive + IObjectWithSite* {.pure.} = object + lpVtbl*: ptr IObjectWithSiteVtbl + IObjectWithSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSite*: proc(self: ptr IObjectWithSite, pUnkSite: ptr IUnknown): HRESULT {.stdcall.} + GetSite*: proc(self: ptr IObjectWithSite, riid: REFIID, ppvSite: ptr pointer): HRESULT {.stdcall.} + LPOBJECTWITHSITE* = ptr IObjectWithSite + CALPOLESTR* {.pure.} = object + cElems*: ULONG + pElems*: ptr LPOLESTR + CADWORD* {.pure.} = object + cElems*: ULONG + pElems*: ptr DWORD + IPerPropertyBrowsing* {.pure.} = object + lpVtbl*: ptr IPerPropertyBrowsingVtbl + IPerPropertyBrowsingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDisplayString*: proc(self: ptr IPerPropertyBrowsing, dispID: DISPID, pBstr: ptr BSTR): HRESULT {.stdcall.} + MapPropertyToPage*: proc(self: ptr IPerPropertyBrowsing, dispID: DISPID, pClsid: ptr CLSID): HRESULT {.stdcall.} + GetPredefinedStrings*: proc(self: ptr IPerPropertyBrowsing, dispID: DISPID, pCaStringsOut: ptr CALPOLESTR, pCaCookiesOut: ptr CADWORD): HRESULT {.stdcall.} + GetPredefinedValue*: proc(self: ptr IPerPropertyBrowsing, dispID: DISPID, dwCookie: DWORD, pVarOut: ptr VARIANT): HRESULT {.stdcall.} + LPPERPROPERTYBROWSING* = ptr IPerPropertyBrowsing + LPCALPOLESTR* = ptr CALPOLESTR + LPCADWORD* = ptr CADWORD + PROPBAG2* {.pure.} = object + dwType*: DWORD + vt*: VARTYPE + cfType*: CLIPFORMAT + dwHint*: DWORD + pstrName*: LPOLESTR + clsid*: CLSID + IPropertyBag2* {.pure.} = object + lpVtbl*: ptr IPropertyBag2Vtbl + IPropertyBag2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + Read*: proc(self: ptr IPropertyBag2, cProperties: ULONG, pPropBag: ptr PROPBAG2, pErrLog: ptr IErrorLog, pvarValue: ptr VARIANT, phrError: ptr HRESULT): HRESULT {.stdcall.} + Write*: proc(self: ptr IPropertyBag2, cProperties: ULONG, pPropBag: ptr PROPBAG2, pvarValue: ptr VARIANT): HRESULT {.stdcall.} + CountProperties*: proc(self: ptr IPropertyBag2, pcProperties: ptr ULONG): HRESULT {.stdcall.} + GetPropertyInfo*: proc(self: ptr IPropertyBag2, iProperty: ULONG, cProperties: ULONG, pPropBag: ptr PROPBAG2, pcProperties: ptr ULONG): HRESULT {.stdcall.} + LoadObject*: proc(self: ptr IPropertyBag2, pstrName: LPCOLESTR, dwHint: DWORD, pUnkObject: ptr IUnknown, pErrLog: ptr IErrorLog): HRESULT {.stdcall.} + LPPROPERTYBAG2* = ptr IPropertyBag2 + IPersistPropertyBag2* {.pure.} = object + lpVtbl*: ptr IPersistPropertyBag2Vtbl + IPersistPropertyBag2Vtbl* {.pure, inheritable.} = object of IPersistVtbl + InitNew*: proc(self: ptr IPersistPropertyBag2): HRESULT {.stdcall.} + Load*: proc(self: ptr IPersistPropertyBag2, pPropBag: ptr IPropertyBag2, pErrLog: ptr IErrorLog): HRESULT {.stdcall.} + Save*: proc(self: ptr IPersistPropertyBag2, pPropBag: ptr IPropertyBag2, fClearDirty: WINBOOL, fSaveAllProperties: WINBOOL): HRESULT {.stdcall.} + IsDirty*: proc(self: ptr IPersistPropertyBag2): HRESULT {.stdcall.} + LPPERSISTPROPERTYBAG2* = ptr IPersistPropertyBag2 + IAdviseSinkEx* {.pure.} = object + lpVtbl*: ptr IAdviseSinkExVtbl + IAdviseSinkExVtbl* {.pure, inheritable.} = object of IAdviseSinkVtbl + OnViewStatusChange*: proc(self: ptr IAdviseSinkEx, dwViewStatus: DWORD): void {.stdcall.} + LPADVISESINKEX* = ptr IAdviseSinkEx + QACONTAINER* {.pure.} = object + cbSize*: ULONG + pClientSite*: ptr IOleClientSite + pAdviseSink*: ptr IAdviseSinkEx + pPropertyNotifySink*: ptr IPropertyNotifySink + pUnkEventSink*: ptr IUnknown + dwAmbientFlags*: DWORD + colorFore*: OLE_COLOR + colorBack*: OLE_COLOR + pFont*: ptr IFont + pUndoMgr*: ptr IOleUndoManager + dwAppearance*: DWORD + lcid*: LONG + hpal*: HPALETTE + pBindHost*: ptr IBindHost + pOleControlSite*: ptr IOleControlSite + pServiceProvider*: ptr IServiceProvider + QACONTROL* {.pure.} = object + cbSize*: ULONG + dwMiscStatus*: DWORD + dwViewStatus*: DWORD + dwEventCookie*: DWORD + dwPropNotifyCookie*: DWORD + dwPointerActivationPolicy*: DWORD + IQuickActivate* {.pure.} = object + lpVtbl*: ptr IQuickActivateVtbl + IQuickActivateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QuickActivate*: proc(self: ptr IQuickActivate, pQaContainer: ptr QACONTAINER, pQaControl: ptr QACONTROL): HRESULT {.stdcall.} + SetContentExtent*: proc(self: ptr IQuickActivate, pSizel: LPSIZEL): HRESULT {.stdcall.} + GetContentExtent*: proc(self: ptr IQuickActivate, pSizel: LPSIZEL): HRESULT {.stdcall.} + LPQUICKACTIVATE* = ptr IQuickActivate + CATID* = GUID + REFCATID* = REFGUID + IEnumGUID* {.pure.} = object + lpVtbl*: ptr IEnumGUIDVtbl + IEnumGUIDVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumGUID, celt: ULONG, rgelt: ptr GUID, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumGUID, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumGUID): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumGUID, ppenum: ptr ptr IEnumGUID): HRESULT {.stdcall.} + IEnumCLSID* = IEnumGUID + LPENUMGUID* = ptr IEnumGUID + LPENUMCLSID* = LPENUMGUID + IEnumCATID* = IEnumGUID + CATEGORYINFO* {.pure.} = object + catid*: CATID + lcid*: LCID + szDescription*: array[128, OLECHAR] + IEnumCATEGORYINFO* {.pure.} = object + lpVtbl*: ptr IEnumCATEGORYINFOVtbl + IEnumCATEGORYINFOVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumCATEGORYINFO, celt: ULONG, rgelt: ptr CATEGORYINFO, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumCATEGORYINFO, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumCATEGORYINFO): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumCATEGORYINFO, ppenum: ptr ptr IEnumCATEGORYINFO): HRESULT {.stdcall.} + LPENUMCATEGORYINFO* = ptr IEnumCATEGORYINFO + LPCATEGORYINFO* = ptr CATEGORYINFO + ICatRegister* {.pure.} = object + lpVtbl*: ptr ICatRegisterVtbl + ICatRegisterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterCategories*: proc(self: ptr ICatRegister, cCategories: ULONG, rgCategoryInfo: ptr CATEGORYINFO): HRESULT {.stdcall.} + UnRegisterCategories*: proc(self: ptr ICatRegister, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.stdcall.} + RegisterClassImplCategories*: proc(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.stdcall.} + UnRegisterClassImplCategories*: proc(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.stdcall.} + RegisterClassReqCategories*: proc(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.stdcall.} + UnRegisterClassReqCategories*: proc(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.stdcall.} + LPCATREGISTER* = ptr ICatRegister + ICatInformation* {.pure.} = object + lpVtbl*: ptr ICatInformationVtbl + ICatInformationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnumCategories*: proc(self: ptr ICatInformation, lcid: LCID, ppenumCategoryInfo: ptr ptr IEnumCATEGORYINFO): HRESULT {.stdcall.} + GetCategoryDesc*: proc(self: ptr ICatInformation, rcatid: REFCATID, lcid: LCID, pszDesc: ptr LPWSTR): HRESULT {.stdcall.} + EnumClassesOfCategories*: proc(self: ptr ICatInformation, cImplemented: ULONG, rgcatidImpl: ptr CATID, cRequired: ULONG, rgcatidReq: ptr CATID, ppenumClsid: ptr ptr IEnumGUID): HRESULT {.stdcall.} + IsClassOfCategories*: proc(self: ptr ICatInformation, rclsid: REFCLSID, cImplemented: ULONG, rgcatidImpl: ptr CATID, cRequired: ULONG, rgcatidReq: ptr CATID): HRESULT {.stdcall.} + EnumImplCategoriesOfClass*: proc(self: ptr ICatInformation, rclsid: REFCLSID, ppenumCatid: ptr ptr IEnumGUID): HRESULT {.stdcall.} + EnumReqCategoriesOfClass*: proc(self: ptr ICatInformation, rclsid: REFCLSID, ppenumCatid: ptr ptr IEnumGUID): HRESULT {.stdcall.} + LPCATINFORMATION* = ptr ICatInformation + SHITEMID* {.pure, packed.} = object + cb*: USHORT + abID*: array[1, BYTE] + LPSHITEMID* = ptr SHITEMID + LPCSHITEMID* = ptr SHITEMID + ITEMIDLIST* {.pure, packed.} = object + mkid*: SHITEMID + ITEMIDLIST_RELATIVE* = ITEMIDLIST + ITEMID_CHILD* = ITEMIDLIST + ITEMIDLIST_ABSOLUTE* = ITEMIDLIST + wirePIDL* = ptr BYTE_BLOB + LPITEMIDLIST* = ptr ITEMIDLIST + LPCITEMIDLIST* = ptr ITEMIDLIST + PIDLIST_ABSOLUTE* = ptr ITEMIDLIST_ABSOLUTE + PCIDLIST_ABSOLUTE* = ptr ITEMIDLIST_ABSOLUTE + PCUIDLIST_ABSOLUTE* = ptr ITEMIDLIST_ABSOLUTE + PIDLIST_RELATIVE* = ptr ITEMIDLIST_RELATIVE + PCIDLIST_RELATIVE* = ptr ITEMIDLIST_RELATIVE + PUIDLIST_RELATIVE* = ptr ITEMIDLIST_RELATIVE + PCUIDLIST_RELATIVE* = ptr ITEMIDLIST_RELATIVE + PITEMID_CHILD* = ptr ITEMID_CHILD + PCITEMID_CHILD* = ptr ITEMID_CHILD + PUITEMID_CHILD* = ptr ITEMID_CHILD + PCUITEMID_CHILD* = ptr ITEMID_CHILD + PCUITEMID_CHILD_ARRAY* = ptr PCUITEMID_CHILD + PCUIDLIST_RELATIVE_ARRAY* = ptr PCUIDLIST_RELATIVE + PCIDLIST_ABSOLUTE_ARRAY* = ptr PCIDLIST_ABSOLUTE + PCUIDLIST_ABSOLUTE_ARRAY* = ptr PCUIDLIST_ABSOLUTE + STRRET_UNION1* {.pure, union.} = object + pOleStr*: LPWSTR + uOffset*: UINT + cStr*: array[260, char] + STRRET* {.pure.} = object + uType*: UINT + union1*: STRRET_UNION1 + LPSTRRET* = ptr STRRET + SHELLDETAILS* {.pure.} = object + fmt*: int32 + cxChar*: int32 + str*: STRRET + LPSHELLDETAILS* = ptr SHELLDETAILS + KNOWNFOLDERID* = GUID + REFKNOWNFOLDERID* = ptr KNOWNFOLDERID + FOLDERTYPEID* = GUID + REFFOLDERTYPEID* = ptr FOLDERTYPEID + TASKOWNERID* = GUID + REFTASKOWNERID* = ptr TASKOWNERID + ELEMENTID* = GUID + REFELEMENTID* = ptr ELEMENTID + PROPERTYKEY* {.pure.} = object + fmtid*: GUID + pid*: DWORD + SHCOLUMNID* = PROPERTYKEY + LPCSHCOLUMNID* = ptr SHCOLUMNID + IOleDocumentView* {.pure.} = object + lpVtbl*: ptr IOleDocumentViewVtbl + IOleDocumentViewVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetInPlaceSite*: proc(self: ptr IOleDocumentView, pIPSite: ptr IOleInPlaceSite): HRESULT {.stdcall.} + GetInPlaceSite*: proc(self: ptr IOleDocumentView, ppIPSite: ptr ptr IOleInPlaceSite): HRESULT {.stdcall.} + GetDocument*: proc(self: ptr IOleDocumentView, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + SetRect*: proc(self: ptr IOleDocumentView, prcView: LPRECT): HRESULT {.stdcall.} + GetRect*: proc(self: ptr IOleDocumentView, prcView: LPRECT): HRESULT {.stdcall.} + SetRectComplex*: proc(self: ptr IOleDocumentView, prcView: LPRECT, prcHScroll: LPRECT, prcVScroll: LPRECT, prcSizeBox: LPRECT): HRESULT {.stdcall.} + Show*: proc(self: ptr IOleDocumentView, fShow: WINBOOL): HRESULT {.stdcall.} + UIActivate*: proc(self: ptr IOleDocumentView, fUIActivate: WINBOOL): HRESULT {.stdcall.} + Open*: proc(self: ptr IOleDocumentView): HRESULT {.stdcall.} + CloseView*: proc(self: ptr IOleDocumentView, dwReserved: DWORD): HRESULT {.stdcall.} + SaveViewState*: proc(self: ptr IOleDocumentView, pstm: LPSTREAM): HRESULT {.stdcall.} + ApplyViewState*: proc(self: ptr IOleDocumentView, pstm: LPSTREAM): HRESULT {.stdcall.} + Clone*: proc(self: ptr IOleDocumentView, pIPSiteNew: ptr IOleInPlaceSite, ppViewNew: ptr ptr IOleDocumentView): HRESULT {.stdcall.} + IEnumOleDocumentViews* {.pure.} = object + lpVtbl*: ptr IEnumOleDocumentViewsVtbl + IEnumOleDocumentViewsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumOleDocumentViews, cViews: ULONG, rgpView: ptr ptr IOleDocumentView, pcFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumOleDocumentViews, cViews: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumOleDocumentViews): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumOleDocumentViews, ppEnum: ptr ptr IEnumOleDocumentViews): HRESULT {.stdcall.} + IOleDocument* {.pure.} = object + lpVtbl*: ptr IOleDocumentVtbl + IOleDocumentVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateView*: proc(self: ptr IOleDocument, pIPSite: ptr IOleInPlaceSite, pstm: ptr IStream, dwReserved: DWORD, ppView: ptr ptr IOleDocumentView): HRESULT {.stdcall.} + GetDocMiscStatus*: proc(self: ptr IOleDocument, pdwStatus: ptr DWORD): HRESULT {.stdcall.} + EnumViews*: proc(self: ptr IOleDocument, ppEnum: ptr ptr IEnumOleDocumentViews, ppView: ptr ptr IOleDocumentView): HRESULT {.stdcall.} + LPOLEDOCUMENT* = ptr IOleDocument + IOleDocumentSite* {.pure.} = object + lpVtbl*: ptr IOleDocumentSiteVtbl + IOleDocumentSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ActivateMe*: proc(self: ptr IOleDocumentSite, pViewToActivate: ptr IOleDocumentView): HRESULT {.stdcall.} + LPOLEDOCUMENTSITE* = ptr IOleDocumentSite + LPOLEDOCUMENTVIEW* = ptr IOleDocumentView + LPENUMOLEDOCUMENTVIEWS* = ptr IEnumOleDocumentViews + IContinueCallback* {.pure.} = object + lpVtbl*: ptr IContinueCallbackVtbl + IContinueCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FContinue*: proc(self: ptr IContinueCallback): HRESULT {.stdcall.} + FContinuePrinting*: proc(self: ptr IContinueCallback, nCntPrinted: LONG, nCurPage: LONG, pwszPrintStatus: ptr uint16): HRESULT {.stdcall.} + LPCONTINUECALLBACK* = ptr IContinueCallback + PAGERANGE* {.pure.} = object + nFromPage*: LONG + nToPage*: LONG + PAGESET* {.pure.} = object + cbStruct*: ULONG + fOddPages*: WINBOOL + fEvenPages*: WINBOOL + cPageRange*: ULONG + rgPages*: array[1, PAGERANGE] + IPrint* {.pure.} = object + lpVtbl*: ptr IPrintVtbl + IPrintVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetInitialPageNum*: proc(self: ptr IPrint, nFirstPage: LONG): HRESULT {.stdcall.} + GetPageInfo*: proc(self: ptr IPrint, pnFirstPage: ptr LONG, pcPages: ptr LONG): HRESULT {.stdcall.} + Print*: proc(self: ptr IPrint, grfFlags: DWORD, pptd: ptr ptr DVTARGETDEVICE, ppPageSet: ptr ptr PAGESET, pstgmOptions: ptr STGMEDIUM, pcallback: ptr IContinueCallback, nFirstPage: LONG, pcPagesPrinted: ptr LONG, pnLastPage: ptr LONG): HRESULT {.stdcall.} + LPPRINT* = ptr IPrint + OLECMD* {.pure.} = object + cmdID*: ULONG + cmdf*: DWORD + OLECMDTEXT* {.pure.} = object + cmdtextf*: DWORD + cwActual*: ULONG + cwBuf*: ULONG + rgwz*: array[1, uint16] + IOleCommandTarget* {.pure.} = object + lpVtbl*: ptr IOleCommandTargetVtbl + IOleCommandTargetVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryStatus*: proc(self: ptr IOleCommandTarget, pguidCmdGroup: ptr GUID, cCmds: ULONG, prgCmds: ptr OLECMD, pCmdText: ptr OLECMDTEXT): HRESULT {.stdcall.} + Exec*: proc(self: ptr IOleCommandTarget, pguidCmdGroup: ptr GUID, nCmdID: DWORD, nCmdexecopt: DWORD, pvaIn: ptr VARIANT, pvaOut: ptr VARIANT): HRESULT {.stdcall.} + LPOLECOMMANDTARGET* = ptr IOleCommandTarget + IMsoDocument* = IOleDocument + IMsoDocumentSite* = IOleDocumentSite + IMsoView* = IOleDocumentView + IEnumMsoView* = IEnumOleDocumentViews + IMsoCommandTarget* = IOleCommandTarget + LPMSODOCUMENT* = LPOLEDOCUMENT + LPMSODOCUMENTSITE* = LPOLEDOCUMENTSITE + LPMSOVIEW* = LPOLEDOCUMENTVIEW + LPENUMMSOVIEW* = LPENUMOLEDOCUMENTVIEWS + LPMSOCOMMANDTARGET* = LPOLECOMMANDTARGET + MSOCMD* = OLECMD + MSOCMDTEXT* = OLECMDTEXT + REFPROPERTYKEY* = ptr PROPERTYKEY + IPropertyStore* {.pure.} = object + lpVtbl*: ptr IPropertyStoreVtbl + IPropertyStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IPropertyStore, cProps: ptr DWORD): HRESULT {.stdcall.} + GetAt*: proc(self: ptr IPropertyStore, iProp: DWORD, pkey: ptr PROPERTYKEY): HRESULT {.stdcall.} + GetValue*: proc(self: ptr IPropertyStore, key: REFPROPERTYKEY, pv: ptr PROPVARIANT): HRESULT {.stdcall.} + SetValue*: proc(self: ptr IPropertyStore, key: REFPROPERTYKEY, propvar: REFPROPVARIANT): HRESULT {.stdcall.} + Commit*: proc(self: ptr IPropertyStore): HRESULT {.stdcall.} + LPPROPERTYSTORE* = ptr IPropertyStore + SERIALIZEDPROPSTORAGE* {.pure.} = object + PUSERIALIZEDPROPSTORAGE* = ptr SERIALIZEDPROPSTORAGE + PCUSERIALIZEDPROPSTORAGE* = ptr SERIALIZEDPROPSTORAGE + LPBINDPTR* = ptr BINDPTR + CODEBASEHOLD* {.pure.} = object + cbSize*: ULONG + szDistUnit*: LPWSTR + szCodeBase*: LPWSTR + dwVersionMS*: DWORD + dwVersionLS*: DWORD + dwStyle*: DWORD + LPCODEBASEHOLD* = ptr CODEBASEHOLD + SOFTDISTINFO* {.pure.} = object + cbSize*: ULONG + dwFlags*: DWORD + dwAdState*: DWORD + szTitle*: LPWSTR + szAbstract*: LPWSTR + szHREF*: LPWSTR + dwInstalledVersionMS*: DWORD + dwInstalledVersionLS*: DWORD + dwUpdateVersionMS*: DWORD + dwUpdateVersionLS*: DWORD + dwAdvertisedVersionMS*: DWORD + dwAdvertisedVersionLS*: DWORD + dwReserved*: DWORD + LPSOFTDISTINFO* = ptr SOFTDISTINFO + HIT_LOGGING_INFO* {.pure.} = object + dwStructSize*: DWORD + lpszLoggedUrlName*: LPSTR + StartTime*: SYSTEMTIME + EndTime*: SYSTEMTIME + lpszExtendedInfo*: LPSTR + LPHIT_LOGGING_INFO* = ptr HIT_LOGGING_INFO + PROTOCOL_ARGUMENT* {.pure.} = object + szMethod*: LPCWSTR + szTargetUrl*: LPCWSTR + LPPROTOCOL_ARGUMENT* = ptr PROTOCOL_ARGUMENT +const + CLSCTX_INPROC_SERVER* = 0x1 + CLSCTX_INPROC_HANDLER* = 0x2 + CLSCTX_INPROC* = CLSCTX_INPROC_SERVER or CLSCTX_INPROC_HANDLER + CLSCTX_LOCAL_SERVER* = 0x4 + CLSCTX_REMOTE_SERVER* = 0x10 + CLSCTX_ALL* = CLSCTX_INPROC_SERVER or CLSCTX_INPROC_HANDLER or CLSCTX_LOCAL_SERVER or CLSCTX_REMOTE_SERVER + CLSCTX_SERVER* = CLSCTX_INPROC_SERVER or CLSCTX_LOCAL_SERVER or CLSCTX_REMOTE_SERVER + REGCLS_SINGLEUSE* = 0 + REGCLS_MULTIPLEUSE* = 1 + REGCLS_MULTI_SEPARATE* = 2 + REGCLS_SUSPENDED* = 4 + REGCLS_SURROGATE* = 8 + COINITBASE_MULTITHREADED* = 0x0 + WIN32* = 100 + STDOLE_MAJORVERNUM* = 0x1 + STDOLE_MINORVERNUM* = 0x0 + STDOLE_LCID* = 0x0000 + STDOLE2_MAJORVERNUM* = 0x2 + STDOLE2_MINORVERNUM* = 0x0 + STDOLE2_LCID* = 0x0000 + ROTFLAGS_REGISTRATIONKEEPSALIVE* = 0x1 + ROTFLAGS_ALLOWANYCLIENT* = 0x2 + ROT_COMPARE_MAX* = 2048 + DVASPECT_CONTENT* = 1 + DVASPECT_THUMBNAIL* = 2 + DVASPECT_ICON* = 4 + DVASPECT_DOCPRINT* = 8 + STGC_DEFAULT* = 0 + STGC_OVERWRITE* = 1 + STGC_ONLYIFCURRENT* = 2 + STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE* = 4 + STGC_CONSOLIDATE* = 8 + STGMOVE_MOVE* = 0 + STGMOVE_COPY* = 1 + STGMOVE_SHALLOWCOPY* = 2 + STATFLAG_DEFAULT* = 0 + STATFLAG_NONAME* = 1 + STATFLAG_NOOPEN* = 2 + WDT_INPROC_CALL* = 0x48746457 + WDT_REMOTE_CALL* = 0x52746457 + WDT_INPROC64_CALL* = 0x50746457 + DECIMAL_NEG* = BYTE 0x80 + VARIANT_TRUE* = VARIANT_BOOL(-1) + VARIANT_FALSE* = VARIANT_BOOL 0 + VT_EMPTY* = 0 + VT_NULL* = 1 + VT_I2* = 2 + VT_I4* = 3 + VT_R4* = 4 + VT_R8* = 5 + VT_CY* = 6 + VT_DATE* = 7 + VT_BSTR* = 8 + VT_DISPATCH* = 9 + VT_ERROR* = 10 + VT_BOOL* = 11 + VT_VARIANT* = 12 + VT_UNKNOWN* = 13 + VT_DECIMAL* = 14 + VT_I1* = 16 + VT_UI1* = 17 + VT_UI2* = 18 + VT_UI4* = 19 + VT_I8* = 20 + VT_UI8* = 21 + VT_INT* = 22 + VT_UINT* = 23 + VT_VOID* = 24 + VT_HRESULT* = 25 + VT_PTR* = 26 + VT_SAFEARRAY* = 27 + VT_CARRAY* = 28 + VT_USERDEFINED* = 29 + VT_LPSTR* = 30 + VT_LPWSTR* = 31 + VT_RECORD* = 36 + VT_INT_PTR* = 37 + VT_UINT_PTR* = 38 + VT_FILETIME* = 64 + VT_BLOB* = 65 + VT_STREAM* = 66 + VT_STORAGE* = 67 + VT_STREAMED_OBJECT* = 68 + VT_STORED_OBJECT* = 69 + VT_BLOB_OBJECT* = 70 + VT_CF* = 71 + VT_CLSID* = 72 + VT_VERSIONED_STREAM* = 73 + VT_BSTR_BLOB* = 0xfff + VT_VECTOR* = 0x1000 + VT_ARRAY* = 0x2000 + VT_BYREF* = 0x4000 + VT_RESERVED* = 0x8000 + VT_ILLEGAL* = 0xffff + VT_ILLEGALMASKED* = 0xfff + VT_TYPEMASK* = 0xfff + TYSPEC_CLSID* = 0 + TYSPEC_FILEEXT* = 1 + TYSPEC_MIMETYPE* = 2 + TYSPEC_FILENAME* = 3 + TYSPEC_PROGID* = 4 + TYSPEC_PACKAGENAME* = 5 + TYSPEC_OBJECTID* = 6 + IID_IUnknown* = DEFINE_GUID("00000000-0000-0000-c000-000000000046") + IID_AsyncIUnknown* = DEFINE_GUID("000e0000-0000-0000-c000-000000000046") + IID_IClassFactory* = DEFINE_GUID("00000001-0000-0000-c000-000000000046") + IID_IMarshal* = DEFINE_GUID("00000003-0000-0000-c000-000000000046") + IID_INoMarshal* = DEFINE_GUID("ecc8691b-c1db-4dc0-855e-65f6c551af49") + IID_IAgileObject* = DEFINE_GUID("94ea2b94-e9cc-49e0-c0ff-ee64ca8f5b90") + IID_IMarshal2* = DEFINE_GUID("000001cf-0000-0000-c000-000000000046") + IID_IMalloc* = DEFINE_GUID("00000002-0000-0000-c000-000000000046") + IID_IStdMarshalInfo* = DEFINE_GUID("00000018-0000-0000-c000-000000000046") + EXTCONN_STRONG* = 0x1 + EXTCONN_WEAK* = 0x2 + EXTCONN_CALLABLE* = 0x4 + IID_IExternalConnection* = DEFINE_GUID("00000019-0000-0000-c000-000000000046") + IID_IMultiQI* = DEFINE_GUID("00000020-0000-0000-c000-000000000046") + IID_AsyncIMultiQI* = DEFINE_GUID("000e0020-0000-0000-c000-000000000046") + IID_IInternalUnknown* = DEFINE_GUID("00000021-0000-0000-c000-000000000046") + IID_IEnumUnknown* = DEFINE_GUID("00000100-0000-0000-c000-000000000046") + IID_IEnumString* = DEFINE_GUID("00000101-0000-0000-c000-000000000046") + IID_ISequentialStream* = DEFINE_GUID("0c733a30-2a1c-11ce-ade5-00aa0044773d") + STGTY_STORAGE* = 1 + STGTY_STREAM* = 2 + STGTY_LOCKBYTES* = 3 + STGTY_PROPERTY* = 4 + STREAM_SEEK_SET* = 0 + STREAM_SEEK_CUR* = 1 + STREAM_SEEK_END* = 2 + LOCK_WRITE* = 1 + LOCK_EXCLUSIVE* = 2 + LOCK_ONLYONCE* = 4 + IID_IStream* = DEFINE_GUID("0000000c-0000-0000-c000-000000000046") + IID_IRpcChannelBuffer* = DEFINE_GUID("d5f56b60-593b-101a-b569-08002b2dbf7a") + IID_IRpcChannelBuffer2* = DEFINE_GUID("594f31d0-7f19-11d0-b194-00a0c90dc8bf") + IID_IAsyncRpcChannelBuffer* = DEFINE_GUID("a5029fb6-3c34-11d1-9c99-00c04fb998aa") + IID_IRpcChannelBuffer3* = DEFINE_GUID("25b15600-0115-11d0-bf0d-00aa00b8dfd2") + IID_IRpcSyntaxNegotiate* = DEFINE_GUID("58a08519-24c8-4935-b482-3fd823333a4f") + IID_IRpcProxyBuffer* = DEFINE_GUID("d5f56a34-593b-101a-b569-08002b2dbf7a") + IID_IRpcStubBuffer* = DEFINE_GUID("d5f56afc-593b-101a-b569-08002b2dbf7a") + IID_IPSFactoryBuffer* = DEFINE_GUID("d5f569d0-593b-101a-b569-08002b2dbf7a") + IID_IChannelHook* = DEFINE_GUID("1008c4a0-7613-11cf-9af1-0020af6e72f4") + EOAC_NONE* = 0x0 + EOAC_MUTUAL_AUTH* = 0x1 + EOAC_STATIC_CLOAKING* = 0x20 + EOAC_DYNAMIC_CLOAKING* = 0x40 + EOAC_ANY_AUTHORITY* = 0x80 + EOAC_MAKE_FULLSIC* = 0x100 + EOAC_DEFAULT* = 0x800 + EOAC_SECURE_REFS* = 0x2 + EOAC_ACCESS_CONTROL* = 0x4 + EOAC_APPID* = 0x8 + EOAC_DYNAMIC* = 0x10 + EOAC_REQUIRE_FULLSIC* = 0x200 + EOAC_AUTO_IMPERSONATE* = 0x400 + EOAC_NO_CUSTOM_MARSHAL* = 0x2000 + EOAC_DISABLE_AAA* = 0x1000 + IID_IClientSecurity* = DEFINE_GUID("0000013d-0000-0000-c000-000000000046") + IID_IServerSecurity* = DEFINE_GUID("0000013e-0000-0000-c000-000000000046") + COMBND_RPCTIMEOUT* = 0x1 + COMBND_SERVER_LOCALITY* = 0x2 + COMBND_RESERVED1* = 0x4 + SERVER_LOCALITY_PROCESS_LOCAL* = 0 + SERVER_LOCALITY_MACHINE_LOCAL* = 1 + SERVER_LOCALITY_REMOTE* = 2 + IID_IRpcOptions* = DEFINE_GUID("00000144-0000-0000-c000-000000000046") + COMGLB_EXCEPTION_HANDLING* = 1 + COMGLB_APPID* = 2 + COMGLB_RPC_THREADPOOL_SETTING* = 3 + COMGLB_RO_SETTINGS* = 4 + COMGLB_UNMARSHALING_POLICY* = 5 + COMGLB_EXCEPTION_HANDLE* = 0 + COMGLB_EXCEPTION_DONOT_HANDLE_FATAL* = 1 + COMGLB_EXCEPTION_DONOT_HANDLE* = COMGLB_EXCEPTION_DONOT_HANDLE_FATAL + COMGLB_EXCEPTION_DONOT_HANDLE_ANY* = 2 + COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL* = 0 + COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL* = 1 + COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES* = 0x1 + COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES* = 0x2 + COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES* = 0x4 + COMGLB_FAST_RUNDOWN* = 0x8 + COMGLB_RESERVED1* = 0x10 + COMGLB_RESERVED2* = 0x20 + COMGLB_RESERVED3* = 0x40 + COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES* = 0x80 + COMGLB_UNMARSHALING_POLICY_NORMAL* = 0 + COMGLB_UNMARSHALING_POLICY_STRONG* = 1 + COMGLB_UNMARSHALING_POLICY_HYBRID* = 2 + IID_IGlobalOptions* = DEFINE_GUID("0000015b-0000-0000-c000-000000000046") + IID_ISurrogate* = DEFINE_GUID("00000022-0000-0000-c000-000000000046") + IID_IGlobalInterfaceTable* = DEFINE_GUID("00000146-0000-0000-c000-000000000046") + IID_ISynchronize* = DEFINE_GUID("00000030-0000-0000-c000-000000000046") + IID_ISynchronizeHandle* = DEFINE_GUID("00000031-0000-0000-c000-000000000046") + IID_ISynchronizeEvent* = DEFINE_GUID("00000032-0000-0000-c000-000000000046") + IID_ISynchronizeContainer* = DEFINE_GUID("00000033-0000-0000-c000-000000000046") + IID_ISynchronizeMutex* = DEFINE_GUID("00000025-0000-0000-c000-000000000046") + IID_ICancelMethodCalls* = DEFINE_GUID("00000029-0000-0000-c000-000000000046") + DCOM_NONE* = 0x0 + DCOM_CALL_COMPLETE* = 0x1 + DCOM_CALL_CANCELED* = 0x2 + IID_IAsyncManager* = DEFINE_GUID("0000002a-0000-0000-c000-000000000046") + IID_ICallFactory* = DEFINE_GUID("1c733a30-2a1c-11ce-ade5-00aa0044773d") + IID_IRpcHelper* = DEFINE_GUID("00000149-0000-0000-c000-000000000046") + IID_IReleaseMarshalBuffers* = DEFINE_GUID("eb0cb9e8-7996-11d2-872e-0000f8080859") + IID_IWaitMultiple* = DEFINE_GUID("0000002b-0000-0000-c000-000000000046") + IID_IAddrTrackingControl* = DEFINE_GUID("00000147-0000-0000-c000-000000000046") + IID_IAddrExclusionControl* = DEFINE_GUID("00000148-0000-0000-c000-000000000046") + IID_IPipeByte* = DEFINE_GUID("db2f3aca-2f86-11d1-8e04-00c04fb9989a") + IID_IPipeLong* = DEFINE_GUID("db2f3acc-2f86-11d1-8e04-00c04fb9989a") + IID_IPipeDouble* = DEFINE_GUID("db2f3ace-2f86-11d1-8e04-00c04fb9989a") + IID_IEnumContextProps* = DEFINE_GUID("000001c1-0000-0000-c000-000000000046") + IID_IContext* = DEFINE_GUID("000001c0-0000-0000-c000-000000000046") + APTTYPEQUALIFIER_NONE* = 0 + APTTYPEQUALIFIER_IMPLICIT_MTA* = 1 + APTTYPEQUALIFIER_NA_ON_MTA* = 2 + APTTYPEQUALIFIER_NA_ON_STA* = 3 + APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA* = 4 + APTTYPEQUALIFIER_NA_ON_MAINSTA* = 5 + APTTYPEQUALIFIER_APPLICATION_STA* = 6 + APTTYPE_CURRENT* = -1 + APTTYPE_STA* = 0 + APTTYPE_MTA* = 1 + APTTYPE_NA* = 2 + APTTYPE_MAINSTA* = 3 + THDTYPE_BLOCKMESSAGES* = 0 + THDTYPE_PROCESSMESSAGES* = 1 + IID_IComThreadingInfo* = DEFINE_GUID("000001ce-0000-0000-c000-000000000046") + IID_IProcessInitControl* = DEFINE_GUID("72380d55-8d2b-43a3-8513-2b6ef31434e9") + IID_IFastRundown* = DEFINE_GUID("00000040-0000-0000-c000-000000000046") + CO_MARSHALING_SOURCE_IS_APP_CONTAINER* = 0 + IID_IMarshalingStream* = DEFINE_GUID("d8f2f5e6-6102-4863-9f26-389a4676efde") + IID_IMallocSpy* = DEFINE_GUID("0000001d-0000-0000-c000-000000000046") + BIND_MAYBOTHERUSER* = 1 + BIND_JUSTTESTEXISTENCE* = 2 + IID_IBindCtx* = DEFINE_GUID("0000000e-0000-0000-c000-000000000046") + IID_IEnumMoniker* = DEFINE_GUID("00000102-0000-0000-c000-000000000046") + IID_IRunnableObject* = DEFINE_GUID("00000126-0000-0000-c000-000000000046") + IID_IRunningObjectTable* = DEFINE_GUID("00000010-0000-0000-c000-000000000046") + IID_IPersist* = DEFINE_GUID("0000010c-0000-0000-c000-000000000046") + IID_IPersistStream* = DEFINE_GUID("00000109-0000-0000-c000-000000000046") + MKSYS_NONE* = 0 + MKSYS_GENERICCOMPOSITE* = 1 + MKSYS_FILEMONIKER* = 2 + MKSYS_ANTIMONIKER* = 3 + MKSYS_ITEMMONIKER* = 4 + MKSYS_POINTERMONIKER* = 5 + MKSYS_CLASSMONIKER* = 7 + MKSYS_OBJREFMONIKER* = 8 + MKSYS_SESSIONMONIKER* = 9 + MKSYS_LUAMONIKER* = 10 + MKRREDUCE_ONE* = 3 shl 16 + MKRREDUCE_TOUSER* = 2 shl 16 + MKRREDUCE_THROUGHUSER* = 1 shl 16 + MKRREDUCE_ALL* = 0 + IID_IMoniker* = DEFINE_GUID("0000000f-0000-0000-c000-000000000046") + IID_IROTData* = DEFINE_GUID("f29f6bc0-5021-11ce-aa15-00006901293f") + IID_IEnumSTATSTG* = DEFINE_GUID("0000000d-0000-0000-c000-000000000046") + IID_IStorage* = DEFINE_GUID("0000000b-0000-0000-c000-000000000046") + IID_IPersistFile* = DEFINE_GUID("0000010b-0000-0000-c000-000000000046") + IID_IPersistStorage* = DEFINE_GUID("0000010a-0000-0000-c000-000000000046") + IID_ILockBytes* = DEFINE_GUID("0000000a-0000-0000-c000-000000000046") + IID_IEnumFORMATETC* = DEFINE_GUID("00000103-0000-0000-c000-000000000046") + ADVF_NODATA* = 1 + ADVF_PRIMEFIRST* = 2 + ADVF_ONLYONCE* = 4 + ADVF_DATAONSTOP* = 64 + ADVFCACHE_NOHANDLER* = 8 + ADVFCACHE_FORCEBUILTIN* = 16 + ADVFCACHE_ONSAVE* = 32 + IID_IEnumSTATDATA* = DEFINE_GUID("00000105-0000-0000-c000-000000000046") + IID_IRootStorage* = DEFINE_GUID("00000012-0000-0000-c000-000000000046") + TYMED_HGLOBAL* = 1 + TYMED_FILE* = 2 + TYMED_ISTREAM* = 4 + TYMED_ISTORAGE* = 8 + TYMED_GDI* = 16 + TYMED_MFPICT* = 32 + TYMED_ENHMF* = 64 + TYMED_NULL* = 0 + IID_IAdviseSink* = DEFINE_GUID("0000010f-0000-0000-c000-000000000046") + IID_AsyncIAdviseSink* = DEFINE_GUID("00000150-0000-0000-c000-000000000046") + IID_IAdviseSink2* = DEFINE_GUID("00000125-0000-0000-c000-000000000046") + IID_AsyncIAdviseSink2* = DEFINE_GUID("00000151-0000-0000-c000-000000000046") + DATADIR_GET* = 1 + DATADIR_SET* = 2 + IID_IDataObject* = DEFINE_GUID("0000010e-0000-0000-c000-000000000046") + IID_IDataAdviseHolder* = DEFINE_GUID("00000110-0000-0000-c000-000000000046") + CALLTYPE_TOPLEVEL* = 1 + CALLTYPE_NESTED* = 2 + CALLTYPE_ASYNC* = 3 + CALLTYPE_TOPLEVEL_CALLPENDING* = 4 + CALLTYPE_ASYNC_CALLPENDING* = 5 + SERVERCALL_ISHANDLED* = 0 + SERVERCALL_REJECTED* = 1 + SERVERCALL_RETRYLATER* = 2 + PENDINGTYPE_TOPLEVEL* = 1 + PENDINGTYPE_NESTED* = 2 + PENDINGMSG_CANCELCALL* = 0 + PENDINGMSG_WAITNOPROCESS* = 1 + PENDINGMSG_WAITDEFPROCESS* = 2 + IID_IMessageFilter* = DEFINE_GUID("00000016-0000-0000-c000-000000000046") + IID_IClassActivator* = DEFINE_GUID("00000140-0000-0000-c000-000000000046") + IID_IFillLockBytes* = DEFINE_GUID("99caf010-415e-11cf-8814-00aa00b569f5") + IID_IProgressNotify* = DEFINE_GUID("a9d758a0-4617-11cf-95fc-00aa00680db4") + IID_ILayoutStorage* = DEFINE_GUID("0e6d4d90-6738-11cf-9608-00aa00680db4") + IID_IBlockingLock* = DEFINE_GUID("30f3d47a-6447-11d1-8e3c-00c04fb9386d") + IID_ITimeAndNoticeControl* = DEFINE_GUID("bc0bf6ae-8878-11d1-83e9-00c04fc2c6d4") + IID_IOplockStorage* = DEFINE_GUID("8d19c834-8879-11d1-83e9-00c04fc2c6d4") + IID_IDirectWriterLock* = DEFINE_GUID("0e6d4d92-6738-11cf-9608-00aa00680db4") + IID_IUrlMon* = DEFINE_GUID("00000026-0000-0000-c000-000000000046") + IID_IForegroundTransfer* = DEFINE_GUID("00000145-0000-0000-c000-000000000046") + IID_IThumbnailExtractor* = DEFINE_GUID("969dc708-5c76-11d1-8d86-0000f804b057") + IID_IDummyHICONIncluder* = DEFINE_GUID("947990de-cc28-11d2-a0f7-00805f858fb1") + serverApplication* = 0 + libraryApplication* = 1 + idleShutdown* = 0 + forcedShutdown* = 1 + IID_IProcessLock* = DEFINE_GUID("000001d5-0000-0000-c000-000000000046") + IID_ISurrogateService* = DEFINE_GUID("000001d4-0000-0000-c000-000000000046") + IID_IInitializeSpy* = DEFINE_GUID("00000034-0000-0000-c000-000000000046") + IID_IApartmentShutdown* = DEFINE_GUID("a2f05a09-27a2-42b5-bc0e-ac163ef49d9b") + SF_ERROR* = VT_ERROR + SF_I1* = VT_I1 + SF_I2* = VT_I2 + SF_I4* = VT_I4 + SF_I8* = VT_I8 + SF_BSTR* = VT_BSTR + SF_UNKNOWN* = VT_UNKNOWN + SF_DISPATCH* = VT_DISPATCH + SF_VARIANT* = VT_VARIANT + SF_RECORD* = VT_RECORD + SF_HAVEIID* = VT_UNKNOWN or VT_RESERVED + FADF_AUTO* = 0x1 + FADF_STATIC* = 0x2 + FADF_EMBEDDED* = 0x4 + FADF_FIXEDSIZE* = 0x10 + FADF_RECORD* = 0x20 + FADF_HAVEIID* = 0x40 + FADF_HAVEVARTYPE* = 0x80 + FADF_BSTR* = 0x100 + FADF_UNKNOWN* = 0x200 + FADF_DISPATCH* = 0x400 + FADF_VARIANT* = 0x800 + FADF_RESERVED* = 0xf008 + FORCENAMELESSUNION* = 1 + TKIND_ENUM* = 0 + TKIND_RECORD* = 1 + TKIND_MODULE* = 2 + TKIND_INTERFACE* = 3 + TKIND_DISPATCH* = 4 + TKIND_COCLASS* = 5 + TKIND_ALIAS* = 6 + TKIND_UNION* = 7 + TKIND_MAX* = 8 + PARAMFLAG_NONE* = 0x0 + PARAMFLAG_FIN* = 0x1 + PARAMFLAG_FOUT* = 0x2 + PARAMFLAG_FLCID* = 0x4 + PARAMFLAG_FRETVAL* = 0x8 + PARAMFLAG_FOPT* = 0x10 + PARAMFLAG_FHASDEFAULT* = 0x20 + PARAMFLAG_FHASCUSTDATA* = 0x40 + IDLFLAG_NONE* = PARAMFLAG_NONE + IDLFLAG_FIN* = PARAMFLAG_FIN + IDLFLAG_FOUT* = PARAMFLAG_FOUT + IDLFLAG_FLCID* = PARAMFLAG_FLCID + IDLFLAG_FRETVAL* = PARAMFLAG_FRETVAL + CC_FASTCALL* = 0 + CC_CDECL* = 1 + CC_MSCPASCAL* = 2 + CC_PASCAL* = CC_MSCPASCAL + CC_MACPASCAL* = 3 + CC_STDCALL* = 4 + CC_FPFASTCALL* = 5 + CC_SYSCALL* = 6 + CC_MPWCDECL* = 7 + CC_MPWPASCAL* = 8 + CC_MAX* = 9 + FUNC_VIRTUAL* = 0 + FUNC_PUREVIRTUAL* = 1 + FUNC_NONVIRTUAL* = 2 + FUNC_STATIC* = 3 + FUNC_DISPATCH* = 4 + INVOKE_FUNC* = 1 + INVOKE_PROPERTYGET* = 2 + INVOKE_PROPERTYPUT* = 4 + INVOKE_PROPERTYPUTREF* = 8 + VAR_PERINSTANCE* = 0 + VAR_STATIC* = 1 + VAR_CONST* = 2 + VAR_DISPATCH* = 3 + IMPLTYPEFLAG_FDEFAULT* = 0x1 + IMPLTYPEFLAG_FSOURCE* = 0x2 + IMPLTYPEFLAG_FRESTRICTED* = 0x4 + IMPLTYPEFLAG_FDEFAULTVTABLE* = 0x8 + TYPEFLAG_FAPPOBJECT* = 0x1 + TYPEFLAG_FCANCREATE* = 0x2 + TYPEFLAG_FLICENSED* = 0x4 + TYPEFLAG_FPREDECLID* = 0x8 + TYPEFLAG_FHIDDEN* = 0x10 + TYPEFLAG_FCONTROL* = 0x20 + TYPEFLAG_FDUAL* = 0x40 + TYPEFLAG_FNONEXTENSIBLE* = 0x80 + TYPEFLAG_FOLEAUTOMATION* = 0x100 + TYPEFLAG_FRESTRICTED* = 0x200 + TYPEFLAG_FAGGREGATABLE* = 0x400 + TYPEFLAG_FREPLACEABLE* = 0x800 + TYPEFLAG_FDISPATCHABLE* = 0x1000 + TYPEFLAG_FREVERSEBIND* = 0x2000 + TYPEFLAG_FPROXY* = 0x4000 + FUNCFLAG_FRESTRICTED* = 0x1 + FUNCFLAG_FSOURCE* = 0x2 + FUNCFLAG_FBINDABLE* = 0x4 + FUNCFLAG_FREQUESTEDIT* = 0x8 + FUNCFLAG_FDISPLAYBIND* = 0x10 + FUNCFLAG_FDEFAULTBIND* = 0x20 + FUNCFLAG_FHIDDEN* = 0x40 + FUNCFLAG_FUSESGETLASTERROR* = 0x80 + FUNCFLAG_FDEFAULTCOLLELEM* = 0x100 + FUNCFLAG_FUIDEFAULT* = 0x200 + FUNCFLAG_FNONBROWSABLE* = 0x400 + FUNCFLAG_FREPLACEABLE* = 0x800 + FUNCFLAG_FIMMEDIATEBIND* = 0x1000 + VARFLAG_FREADONLY* = 0x1 + VARFLAG_FSOURCE* = 0x2 + VARFLAG_FBINDABLE* = 0x4 + VARFLAG_FREQUESTEDIT* = 0x8 + VARFLAG_FDISPLAYBIND* = 0x10 + VARFLAG_FDEFAULTBIND* = 0x20 + VARFLAG_FHIDDEN* = 0x40 + VARFLAG_FRESTRICTED* = 0x80 + VARFLAG_FDEFAULTCOLLELEM* = 0x100 + VARFLAG_FUIDEFAULT* = 0x200 + VARFLAG_FNONBROWSABLE* = 0x400 + VARFLAG_FREPLACEABLE* = 0x800 + VARFLAG_FIMMEDIATEBIND* = 0x1000 + IID_ICreateTypeInfo* = DEFINE_GUID("00020405-0000-0000-c000-000000000046") + IID_ICreateTypeInfo2* = DEFINE_GUID("0002040e-0000-0000-c000-000000000046") + IID_ICreateTypeLib* = DEFINE_GUID("00020406-0000-0000-c000-000000000046") + IID_ICreateTypeLib2* = DEFINE_GUID("0002040f-0000-0000-c000-000000000046") + DISPID_UNKNOWN* = -1 + DISPID_VALUE* = 0 + DISPID_PROPERTYPUT* = -3 + DISPID_NEWENUM* = -4 + DISPID_EVALUATE* = -5 + DISPID_CONSTRUCTOR* = -6 + DISPID_DESTRUCTOR* = -7 + DISPID_COLLECT* = -8 + IID_IDispatch* = DEFINE_GUID("00020400-0000-0000-c000-000000000046") + IID_IEnumVARIANT* = DEFINE_GUID("00020404-0000-0000-c000-000000000046") + DESCKIND_NONE* = 0 + DESCKIND_FUNCDESC* = 1 + DESCKIND_VARDESC* = 2 + DESCKIND_TYPECOMP* = 3 + DESCKIND_IMPLICITAPPOBJ* = 4 + DESCKIND_MAX* = 5 + IID_ITypeComp* = DEFINE_GUID("00020403-0000-0000-c000-000000000046") + IID_ITypeInfo* = DEFINE_GUID("00020401-0000-0000-c000-000000000046") + IID_ITypeInfo2* = DEFINE_GUID("00020412-0000-0000-c000-000000000046") + SYS_WIN16* = 0 + SYS_WIN32* = 1 + SYS_MAC* = 2 + SYS_WIN64* = 3 + LIBFLAG_FRESTRICTED* = 0x1 + LIBFLAG_FCONTROL* = 0x2 + LIBFLAG_FHIDDEN* = 0x4 + LIBFLAG_FHASDISKIMAGE* = 0x8 + IID_ITypeLib* = DEFINE_GUID("00020402-0000-0000-c000-000000000046") + IID_ITypeLib2* = DEFINE_GUID("00020411-0000-0000-c000-000000000046") + CHANGEKIND_ADDMEMBER* = 0 + CHANGEKIND_DELETEMEMBER* = 1 + CHANGEKIND_SETNAMES* = 2 + CHANGEKIND_SETDOCUMENTATION* = 3 + CHANGEKIND_GENERAL* = 4 + CHANGEKIND_INVALIDATE* = 5 + CHANGEKIND_CHANGEFAILED* = 6 + CHANGEKIND_MAX* = 7 + IID_ITypeChangeEvents* = DEFINE_GUID("00020410-0000-0000-c000-000000000046") + IID_IErrorInfo* = DEFINE_GUID("1cf2b120-547d-101b-8e65-08002b2bd119") + IID_ICreateErrorInfo* = DEFINE_GUID("22f03340-547d-101b-8e65-08002b2bd119") + IID_ISupportErrorInfo* = DEFINE_GUID("df0b3d60-548f-101b-8e65-08002b2bd119") + IID_ITypeFactory* = DEFINE_GUID("0000002e-0000-0000-c000-000000000046") + IID_ITypeMarshal* = DEFINE_GUID("0000002d-0000-0000-c000-000000000046") + IID_IRecordInfo* = DEFINE_GUID("0000002f-0000-0000-c000-000000000046") + IID_IErrorLog* = DEFINE_GUID("3127ca40-446e-11ce-8135-00aa004bb851") + IID_IPropertyBag* = DEFINE_GUID("55272a00-42cb-11ce-8135-00aa004bb851") + VARIANT_NOVALUEPROP* = 0x01 + VARIANT_ALPHABOOL* = 0x02 + VARIANT_NOUSEROVERRIDE* = 0x04 + VARIANT_CALENDAR_HIJRI* = 0x08 + VARIANT_LOCALBOOL* = 0x10 + VARIANT_CALENDAR_THAI* = 0x20 + VARIANT_CALENDAR_GREGORIAN* = 0x40 + VARIANT_USE_NLS* = 0x80 + VAR_TIMEVALUEONLY* = DWORD 0x00000001 + VAR_DATEVALUEONLY* = DWORD 0x00000002 + VAR_VALIDDATE* = DWORD 0x00000004 + VAR_CALENDAR_HIJRI* = DWORD 0x00000008 + VAR_LOCALBOOL* = DWORD 0x00000010 + VAR_FORMAT_NOSUBSTITUTE* = DWORD 0x00000020 + VAR_FOURDIGITYEARS* = DWORD 0x00000040 + LOCALE_USE_NLS* = 0x10000000 + VAR_CALENDAR_THAI* = DWORD 0x00000080 + VAR_CALENDAR_GREGORIAN* = DWORD 0x00000100 + VTDATEGRE_MAX* = 2958465 + VTDATEGRE_MIN* = -657434 + NUMPRS_LEADING_WHITE* = 0x0001 + NUMPRS_TRAILING_WHITE* = 0x0002 + NUMPRS_LEADING_PLUS* = 0x0004 + NUMPRS_TRAILING_PLUS* = 0x0008 + NUMPRS_LEADING_MINUS* = 0x0010 + NUMPRS_TRAILING_MINUS* = 0x0020 + NUMPRS_HEX_OCT* = 0x0040 + NUMPRS_PARENS* = 0x0080 + NUMPRS_DECIMAL* = 0x0100 + NUMPRS_THOUSANDS* = 0x0200 + NUMPRS_CURRENCY* = 0x0400 + NUMPRS_EXPONENT* = 0x0800 + NUMPRS_USE_ALL* = 0x1000 + NUMPRS_STD* = 0x1FFF + NUMPRS_NEG* = 0x10000 + NUMPRS_INEXACT* = 0x20000 + VTBIT_I1* = 1 shl VT_I1 + VTBIT_UI1* = 1 shl VT_UI1 + VTBIT_I2* = 1 shl VT_I2 + VTBIT_UI2* = 1 shl VT_UI2 + VTBIT_I4* = 1 shl VT_I4 + VTBIT_UI4* = 1 shl VT_UI4 + VTBIT_I8* = 1 shl VT_I8 + VTBIT_UI8* = 1 shl VT_UI8 + VTBIT_R4* = 1 shl VT_R4 + VTBIT_R8* = 1 shl VT_R8 + VTBIT_CY* = 1 shl VT_CY + VTBIT_DECIMAL* = 1 shl VT_DECIMAL + VARCMP_LT* = 0 + VARCMP_EQ* = 1 + VARCMP_GT* = 2 + VARCMP_NULL* = 3 + VT_HARDTYPE* = VT_RESERVED + MEMBERID_NIL* = DISPID_UNKNOWN + ID_DEFAULTINST* = -2 + DISPATCH_METHOD* = 0x1 + DISPATCH_PROPERTYGET* = 0x2 + DISPATCH_PROPERTYPUT* = 0x4 + DISPATCH_PROPERTYPUTREF* = 0x8 + REGKIND_DEFAULT* = 0 + REGKIND_REGISTER* = 1 + REGKIND_NONE* = 2 + LOAD_TLB_AS_32BIT* = 0x20 + LOAD_TLB_AS_64BIT* = 0x40 + MASK_TO_RESET_TLB_BITS* = not (LOAD_TLB_AS_32BIT or LOAD_TLB_AS_64BIT) + ACTIVEOBJECT_STRONG* = 0x0 + ACTIVEOBJECT_WEAK* = 0x1 + E_DRAW* = VIEW_E_DRAW + DATA_E_FORMATETC* = DV_E_FORMATETC + OLEIVERB_PRIMARY* = 0 + OLEIVERB_SHOW* = -1 + OLEIVERB_OPEN* = -2 + OLEIVERB_HIDE* = -3 + OLEIVERB_UIACTIVATE* = -4 + OLEIVERB_INPLACEACTIVATE* = -5 + OLEIVERB_DISCARDUNDOSTATE* = -6 + EMBDHLP_INPROC_HANDLER* = 0x0000 + EMBDHLP_INPROC_SERVER* = 0x0001 + EMBDHLP_CREATENOW* = 0x00000000 + EMBDHLP_DELAYCREATE* = 0x00010000 + OLECREATE_LEAVERUNNING* = 0x1 + IID_IOleAdviseHolder* = DEFINE_GUID("00000111-0000-0000-c000-000000000046") + IID_IOleCache* = DEFINE_GUID("0000011e-0000-0000-c000-000000000046") + UPDFCACHE_NODATACACHE* = 0x1 + UPDFCACHE_ONSAVECACHE* = 0x2 + UPDFCACHE_ONSTOPCACHE* = 0x4 + UPDFCACHE_NORMALCACHE* = 0x8 + UPDFCACHE_IFBLANK* = 0x10 + UPDFCACHE_ONLYIFBLANK* = 0x80000000'i32 + UPDFCACHE_IFBLANKORONSAVECACHE* = UPDFCACHE_IFBLANK or UPDFCACHE_ONSAVECACHE + DISCARDCACHE_SAVEIFDIRTY* = 0 + DISCARDCACHE_NOSAVE* = 1 + IID_IOleCache2* = DEFINE_GUID("00000128-0000-0000-c000-000000000046") + IID_IOleCacheControl* = DEFINE_GUID("00000129-0000-0000-c000-000000000046") + IID_IParseDisplayName* = DEFINE_GUID("0000011a-0000-0000-c000-000000000046") + IID_IOleContainer* = DEFINE_GUID("0000011b-0000-0000-c000-000000000046") + IID_IOleClientSite* = DEFINE_GUID("00000118-0000-0000-c000-000000000046") + OLEGETMONIKER_ONLYIFTHERE* = 1 + OLEGETMONIKER_FORCEASSIGN* = 2 + OLEGETMONIKER_UNASSIGN* = 3 + OLEGETMONIKER_TEMPFORUSER* = 4 + OLEWHICHMK_CONTAINER* = 1 + OLEWHICHMK_OBJREL* = 2 + OLEWHICHMK_OBJFULL* = 3 + USERCLASSTYPE_FULL* = 1 + USERCLASSTYPE_SHORT* = 2 + USERCLASSTYPE_APPNAME* = 3 + OLEMISC_RECOMPOSEONRESIZE* = 0x1 + OLEMISC_ONLYICONIC* = 0x2 + OLEMISC_INSERTNOTREPLACE* = 0x4 + OLEMISC_STATIC* = 0x8 + OLEMISC_CANTLINKINSIDE* = 0x10 + OLEMISC_CANLINKBYOLE1* = 0x20 + OLEMISC_ISLINKOBJECT* = 0x40 + OLEMISC_INSIDEOUT* = 0x80 + OLEMISC_ACTIVATEWHENVISIBLE* = 0x100 + OLEMISC_RENDERINGISDEVICEINDEPENDENT* = 0x200 + OLEMISC_INVISIBLEATRUNTIME* = 0x400 + OLEMISC_ALWAYSRUN* = 0x800 + OLEMISC_ACTSLIKEBUTTON* = 0x1000 + OLEMISC_ACTSLIKELABEL* = 0x2000 + OLEMISC_NOUIACTIVATE* = 0x4000 + OLEMISC_ALIGNABLE* = 0x8000 + OLEMISC_SIMPLEFRAME* = 0x10000 + OLEMISC_SETCLIENTSITEFIRST* = 0x20000 + OLEMISC_IMEMODE* = 0x40000 + OLEMISC_IGNOREACTIVATEWHENVISIBLE* = 0x80000 + OLEMISC_WANTSTOMENUMERGE* = 0x100000 + OLEMISC_SUPPORTSMULTILEVELUNDO* = 0x200000 + OLECLOSE_SAVEIFDIRTY* = 0 + OLECLOSE_NOSAVE* = 1 + OLECLOSE_PROMPTSAVE* = 2 + IID_IOleObject* = DEFINE_GUID("00000112-0000-0000-c000-000000000046") + OLERENDER_NONE* = 0 + OLERENDER_DRAW* = 1 + OLERENDER_FORMAT* = 2 + OLERENDER_ASIS* = 3 + IID_IOleWindow* = DEFINE_GUID("00000114-0000-0000-c000-000000000046") + OLEUPDATE_ALWAYS* = 1 + OLEUPDATE_ONCALL* = 3 + OLELINKBIND_EVENIFCLASSDIFF* = 1 + IID_IOleLink* = DEFINE_GUID("0000011d-0000-0000-c000-000000000046") + BINDSPEED_INDEFINITE* = 1 + BINDSPEED_MODERATE* = 2 + BINDSPEED_IMMEDIATE* = 3 + OLECONTF_EMBEDDINGS* = 1 + OLECONTF_LINKS* = 2 + OLECONTF_OTHERS* = 4 + OLECONTF_ONLYUSER* = 8 + OLECONTF_ONLYIFRUNNING* = 16 + IID_IOleItemContainer* = DEFINE_GUID("0000011c-0000-0000-c000-000000000046") + IID_IOleInPlaceUIWindow* = DEFINE_GUID("00000115-0000-0000-c000-000000000046") + IID_IOleInPlaceActiveObject* = DEFINE_GUID("00000117-0000-0000-c000-000000000046") + IID_IOleInPlaceFrame* = DEFINE_GUID("00000116-0000-0000-c000-000000000046") + IID_IOleInPlaceObject* = DEFINE_GUID("00000113-0000-0000-c000-000000000046") + IID_IOleInPlaceSite* = DEFINE_GUID("00000119-0000-0000-c000-000000000046") + IID_IContinue* = DEFINE_GUID("0000012a-0000-0000-c000-000000000046") + IID_IViewObject* = DEFINE_GUID("0000010d-0000-0000-c000-000000000046") + IID_IViewObject2* = DEFINE_GUID("00000127-0000-0000-c000-000000000046") + IID_IDropSource* = DEFINE_GUID("00000121-0000-0000-c000-000000000046") + MK_ALT* = 0x20 + DROPEFFECT_NONE* = 0 + DROPEFFECT_COPY* = 1 + DROPEFFECT_MOVE* = 2 + DROPEFFECT_LINK* = 4 + DROPEFFECT_SCROLL* = 0x80000000'i32 + DD_DEFSCROLLINSET* = 11 + DD_DEFSCROLLDELAY* = 50 + DD_DEFSCROLLINTERVAL* = 50 + DD_DEFDRAGDELAY* = 200 + DD_DEFDRAGMINDIST* = 2 + IID_IDropTarget* = DEFINE_GUID("00000122-0000-0000-c000-000000000046") + IID_IDropSourceNotify* = DEFINE_GUID("0000012b-0000-0000-c000-000000000046") + OLEVERBATTRIB_NEVERDIRTIES* = 1 + OLEVERBATTRIB_ONCONTAINERMENU* = 2 + IID_IEnumOLEVERB* = DEFINE_GUID("00000104-0000-0000-c000-000000000046") + MEMCTX_TASK* = 1 + MEMCTX_SHARED* = 2 + MEMCTX_MACSYSTEM* = 3 + MEMCTX_UNKNOWN* = -1 + MEMCTX_SAME* = -2 + ROTREGFLAGS_ALLOWANYCLIENT* = 0x1 + APPIDREGFLAGS_ACTIVATE_IUSERVER_INDESKTOP* = 0x1 + APPIDREGFLAGS_SECURE_SERVER_PROCESS_SD_AND_BIND* = 0x2 + APPIDREGFLAGS_ISSUE_ACTIVATION_RPC_AT_IDENTIFY* = 0x4 + APPIDREGFLAGS_IUSERVER_UNMODIFIED_LOGON_TOKEN* = 0x8 + APPIDREGFLAGS_IUSERVER_SELF_SID_IN_LAUNCH_PERMISSION* = 0x10 + APPIDREGFLAGS_IUSERVER_ACTIVATE_IN_CLIENT_SESSION_ONLY* = 0x20 + APPIDREGFLAGS_RESERVED1* = 0x40 + DCOMSCM_ACTIVATION_USE_ALL_AUTHNSERVICES* = 0x1 + DCOMSCM_ACTIVATION_DISALLOW_UNSECURE_CALL* = 0x2 + DCOMSCM_RESOLVE_USE_ALL_AUTHNSERVICES* = 0x4 + DCOMSCM_RESOLVE_DISALLOW_UNSECURE_CALL* = 0x8 + DCOMSCM_PING_USE_MID_AUTHNSERVICE* = 0x10 + DCOMSCM_PING_DISALLOW_UNSECURE_CALL* = 0x20 + CLSCTX_INPROC_SERVER16* = 0x8 + CLSCTX_INPROC_HANDLER16* = 0x20 + CLSCTX_RESERVED1* = 0x40 + CLSCTX_RESERVED2* = 0x80 + CLSCTX_RESERVED3* = 0x100 + CLSCTX_RESERVED4* = 0x200 + CLSCTX_NO_CODE_DOWNLOAD* = 0x400 + CLSCTX_RESERVED5* = 0x800 + CLSCTX_NO_CUSTOM_MARSHAL* = 0x1000 + CLSCTX_ENABLE_CODE_DOWNLOAD* = 0x2000 + CLSCTX_NO_FAILURE_LOG* = 0x4000 + CLSCTX_DISABLE_AAA* = 0x8000 + CLSCTX_ENABLE_AAA* = 0x10000 + CLSCTX_FROM_DEFAULT_CONTEXT* = 0x20000 + CLSCTX_ACTIVATE_32_BIT_SERVER* = 0x40000 + CLSCTX_ACTIVATE_64_BIT_SERVER* = 0x80000 + CLSCTX_ENABLE_CLOAKING* = 0x100000 + CLSCTX_APPCONTAINER* = 0x400000 + CLSCTX_ACTIVATE_AAA_AS_IU* = 0x800000 + CLSCTX_PS_DLL* = int32 0x80000000'i32 + CLSCTX_VALID_MASK* = CLSCTX_INPROC_SERVER or CLSCTX_INPROC_HANDLER or CLSCTX_LOCAL_SERVER or CLSCTX_INPROC_SERVER16 or CLSCTX_REMOTE_SERVER or CLSCTX_NO_CODE_DOWNLOAD or CLSCTX_NO_CUSTOM_MARSHAL or CLSCTX_ENABLE_CODE_DOWNLOAD or CLSCTX_NO_FAILURE_LOG or CLSCTX_DISABLE_AAA or CLSCTX_ENABLE_AAA or CLSCTX_FROM_DEFAULT_CONTEXT or CLSCTX_ACTIVATE_32_BIT_SERVER or CLSCTX_ACTIVATE_64_BIT_SERVER or CLSCTX_ENABLE_CLOAKING or CLSCTX_APPCONTAINER or CLSCTX_ACTIVATE_AAA_AS_IU or CLSCTX_PS_DLL + MSHLFLAGS_NORMAL* = 0 + MSHLFLAGS_TABLESTRONG* = 1 + MSHLFLAGS_TABLEWEAK* = 2 + MSHLFLAGS_NOPING* = 4 + MSHLFLAGS_RESERVED1* = 8 + MSHLFLAGS_RESERVED2* = 16 + MSHLFLAGS_RESERVED3* = 32 + MSHLFLAGS_RESERVED4* = 64 + MSHCTX_LOCAL* = 0 + MSHCTX_NOSHAREDMEM* = 1 + MSHCTX_DIFFERENTMACHINE* = 2 + MSHCTX_INPROC* = 3 + MSHCTX_CROSSCTX* = 4 + SMEXF_SERVER* = 0x01 + SMEXF_HANDLER* = 0x02 + COM_RIGHTS_EXECUTE* = 1 + COM_RIGHTS_EXECUTE_LOCAL* = 2 + COM_RIGHTS_EXECUTE_REMOTE* = 4 + COM_RIGHTS_ACTIVATE_LOCAL* = 8 + COM_RIGHTS_ACTIVATE_REMOTE* = 16 + COWAIT_DEFAULT* = 0 + COWAIT_WAITALL* = 1 + COWAIT_ALERTABLE* = 2 + COWAIT_INPUTAVAILABLE* = 4 + COWAIT_DISPATCH_CALLS* = 8 + COWAIT_DISPATCH_WINDOW_MESSAGES* = 0x10 + CWMO_DEFAULT* = 0 + CWMO_DISPATCH_CALLS* = 1 + CWMO_DISPATCH_WINDOW_MESSAGES* = 2 + CWMO_MAX_HANDLES* = 56 + COINIT_APARTMENTTHREADED* = 0x2 + COINIT_MULTITHREADED* = COINITBASE_MULTITHREADED + COINIT_DISABLE_OLE1DDE* = 0x4 + COINIT_SPEED_OVER_MEMORY* = 0x8 + MARSHALINTERFACE_MIN* = 500 + CWCSTORAGENAME* = 32 + STGM_DIRECT* = 0x00000000 + STGM_TRANSACTED* = 0x00010000 + STGM_SIMPLE* = 0x08000000 + STGM_READ* = 0x00000000 + STGM_WRITE* = 0x00000001 + STGM_READWRITE* = 0x00000002 + STGM_SHARE_DENY_NONE* = 0x00000040 + STGM_SHARE_DENY_READ* = 0x00000030 + STGM_SHARE_DENY_WRITE* = 0x00000020 + STGM_SHARE_EXCLUSIVE* = 0x00000010 + STGM_PRIORITY* = 0x00040000 + STGM_DELETEONRELEASE* = 0x04000000 + STGM_NOSCRATCH* = 0x00100000 + STGM_CREATE* = 0x00001000 + STGM_CONVERT* = 0x00020000 + STGM_FAILIFTHERE* = 0x00000000 + STGM_NOSNAPSHOT* = 0x00200000 + STGM_DIRECT_SWMR* = 0x00400000 + ASYNC_MODE_COMPATIBILITY* = 0x00000001 + ASYNC_MODE_DEFAULT* = 0x00000000 + STGTY_REPEAT* = 0x00000100 + STG_TOEND* = 0xffffffff'i32 + STG_LAYOUT_SEQUENTIAL* = 0x00000000 + STG_LAYOUT_INTERLEAVED* = 0x00000001 + STGFMT_STORAGE* = 0 + STGFMT_NATIVE* = 1 + STGFMT_FILE* = 3 + STGFMT_ANY* = 4 + STGFMT_DOCFILE* = 5 + STGFMT_DOCUMENT* = 0 + SD_LAUNCHPERMISSIONS* = 0 + SD_ACCESSPERMISSIONS* = 1 + SD_LAUNCHRESTRICTIONS* = 2 + SD_ACCESSRESTRICTIONS* = 3 + STGOPTIONS_VERSION* = 2 + IID_IServiceProvider* = DEFINE_GUID("6d5140c1-7436-11ce-8034-00aa006009fa") + NODE_INVALID* = 0 + NODE_ELEMENT* = 1 + NODE_ATTRIBUTE* = 2 + NODE_TEXT* = 3 + NODE_CDATA_SECTION* = 4 + NODE_ENTITY_REFERENCE* = 5 + NODE_ENTITY* = 6 + NODE_PROCESSING_INSTRUCTION* = 7 + NODE_COMMENT* = 8 + NODE_DOCUMENT* = 9 + NODE_DOCUMENT_TYPE* = 10 + NODE_DOCUMENT_FRAGMENT* = 11 + NODE_NOTATION* = 12 + XMLELEMTYPE_ELEMENT* = 0 + XMLELEMTYPE_TEXT* = 1 + XMLELEMTYPE_COMMENT* = 2 + XMLELEMTYPE_DOCUMENT* = 3 + XMLELEMTYPE_DTD* = 4 + XMLELEMTYPE_PI* = 5 + XMLELEMTYPE_OTHER* = 6 + BINDF_GETNEWESTVERSION* = 0x10 + BINDF_DONTUSECACHE* = BINDF_GETNEWESTVERSION + BINDF_NOWRITECACHE* = 0x20 + BINDF_DONTPUTINCACHE* = BINDF_NOWRITECACHE + BINDF_PULLDATA* = 0x80 + BINDF_NOCOPYDATA* = BINDF_PULLDATA + PI_CLSIDLOOKUP* = 0x20 + PI_DOCFILECLSIDLOOKUP* = PI_CLSIDLOOKUP + MKSYS_URLMONIKER* = 6 + URL_MK_LEGACY* = 0 + URL_MK_UNIFORM* = 1 + URL_MK_NO_CANONICALIZE* = 2 + FIEF_FLAG_FORCE_JITUI* = 0x1 + FIEF_FLAG_PEEK* = 0x2 + FIEF_FLAG_SKIP_INSTALLED_VERSION_CHECK* = 0x4 + FMFD_DEFAULT* = 0x0 + FMFD_URLASFILENAME* = 0x1 + FMFD_ENABLEMIMESNIFFING* = 0x2 + FMFD_IGNOREMIMETEXTPLAIN* = 0x4 + FMFD_SERVERMIME* = 0x8 + FMFD_RESPECTTEXTPLAIN* = 0x10 + FMFD_RETURNUPDATEDIMGMIMES* = 0x20 + UAS_EXACTLEGACY* = 0x1000 + URLMON_OPTION_USERAGENT* = 0x10000001 + URLMON_OPTION_USERAGENT_REFRESH* = 0x10000002 + URLMON_OPTION_URL_ENCODING* = 0x10000004 + URLMON_OPTION_USE_BINDSTRINGCREDS* = 0x10000008 + URLMON_OPTION_USE_BROWSERAPPSDOCUMENTS* = 0x10000010 + CF_NULL* = 0 + CFSTR_MIME_NULL* = NULL + CFSTR_MIME_TEXT* = "text/plain" + CFSTR_MIME_RICHTEXT* = "text/richtext" + CFSTR_MIME_MANIFEST* = "text/cache-manifest" + CFSTR_MIME_WEBVTT* = "text/vtt" + CFSTR_MIME_X_BITMAP* = "image/x-xbitmap" + CFSTR_MIME_POSTSCRIPT* = "application/postscript" + CFSTR_MIME_AIFF* = "audio/aiff" + CFSTR_MIME_BASICAUDIO* = "audio/basic" + CFSTR_MIME_WAV* = "audio/wav" + CFSTR_MIME_X_WAV* = "audio/x-wav" + CFSTR_MIME_GIF* = "image/gif" + CFSTR_MIME_PJPEG* = "image/pjpeg" + CFSTR_MIME_JPEG* = "image/jpeg" + CFSTR_MIME_TIFF* = "image/tiff" + CFSTR_MIME_JPEG_XR* = "image/vnd.ms-photo" + CFSTR_MIME_PNG* = "image/png" + CFSTR_MIME_X_PNG* = "image/x-png" + CFSTR_MIME_X_ICON* = "image/x-icon" + CFSTR_MIME_SVG_XML* = "image/svg+xml" + CFSTR_MIME_BMP* = "image/bmp" + CFSTR_MIME_X_EMF* = "image/x-emf" + CFSTR_MIME_X_WMF* = "image/x-wmf" + CFSTR_MIME_AVI* = "video/avi" + CFSTR_MIME_MPEG* = "video/mpeg" + CFSTR_MIME_FRACTALS* = "application/fractals" + CFSTR_MIME_RAWDATA* = "application/octet-stream" + CFSTR_MIME_RAWDATASTRM* = "application/octet-stream" + CFSTR_MIME_PDF* = "application/pdf" + CFSTR_MIME_HTA* = "application/hta" + CFSTR_MIME_APP_XML* = "application/xml" + CFSTR_MIME_XHTML* = "application/xhtml+xml" + CFSTR_MIME_X_AIFF* = "audio/x-aiff" + CFSTR_MIME_X_REALAUDIO* = "audio/x-pn-realaudio" + CFSTR_MIME_XBM* = "image/xbm" + CFSTR_MIME_QUICKTIME* = "video/quicktime" + CFSTR_MIME_X_MSVIDEO* = "video/x-msvideo" + CFSTR_MIME_X_SGI_MOVIE* = "video/x-sgi-movie" + CFSTR_MIME_HTML* = "text/html" + CFSTR_MIME_XML* = "text/xml" + CFSTR_MIME_TTML* = "application/ttml+xml" + CFSTR_MIME_TTAF* = "application/ttaf+xml" + MK_S_ASYNCHRONOUS* = HRESULT 0x401E8 + S_ASYNCHRONOUS* = MK_S_ASYNCHRONOUS + INET_E_INVALID_URL* = HRESULT 0x800C0002'i32 + INET_E_NO_SESSION* = HRESULT 0x800C0003'i32 + INET_E_CANNOT_CONNECT* = HRESULT 0x800C0004'i32 + INET_E_RESOURCE_NOT_FOUND* = HRESULT 0x800C0005'i32 + INET_E_OBJECT_NOT_FOUND* = HRESULT 0x800C0006'i32 + INET_E_DATA_NOT_AVAILABLE* = HRESULT 0x800C0007'i32 + INET_E_DOWNLOAD_FAILURE* = HRESULT 0x800C0008'i32 + INET_E_AUTHENTICATION_REQUIRED* = HRESULT 0x800C0009'i32 + INET_E_NO_VALID_MEDIA* = HRESULT 0x800C000A'i32 + INET_E_CONNECTION_TIMEOUT* = HRESULT 0x800C000B'i32 + INET_E_INVALID_REQUEST* = HRESULT 0x800C000C'i32 + INET_E_UNKNOWN_PROTOCOL* = HRESULT 0x800C000D'i32 + INET_E_SECURITY_PROBLEM* = HRESULT 0x800C000E'i32 + INET_E_CANNOT_LOAD_DATA* = HRESULT 0x800C000F'i32 + INET_E_CANNOT_INSTANTIATE_OBJECT* = HRESULT 0x800C0010'i32 + INET_E_INVALID_CERTIFICATE* = HRESULT 0x800C0019'i32 + INET_E_REDIRECT_FAILED* = HRESULT 0x800C0014'i32 + INET_E_REDIRECT_TO_DIR* = HRESULT 0x800C0015'i32 + INET_E_CANNOT_LOCK_REQUEST* = HRESULT 0x800C0016'i32 + INET_E_USE_EXTEND_BINDING* = HRESULT 0x800C0017'i32 + INET_E_TERMINATED_BIND* = HRESULT 0x800C0018'i32 + INET_E_RESERVED_1* = HRESULT 0x800C001A'i32 + INET_E_BLOCKED_REDIRECT_XSECURITYID* = HRESULT 0x800C001B'i32 + INET_E_DOMINJECTIONVALIDATION* = HRESULT 0x800C001C'i32 + INET_E_ERROR_FIRST* = HRESULT 0x800C0002'i32 + INET_E_CODE_DOWNLOAD_DECLINED* = HRESULT 0x800C0100'i32 + INET_E_RESULT_DISPATCHED* = HRESULT 0x800C0200'i32 + INET_E_CANNOT_REPLACE_SFP_FILE* = HRESULT 0x800C0300'i32 + INET_E_CODE_INSTALL_SUPPRESSED* = HRESULT 0x800C0400'i32 + INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY* = HRESULT 0x800C0500'i32 + INET_E_DOWNLOAD_BLOCKED_BY_INPRIVATE* = HRESULT 0x800C0501'i32 + INET_E_CODE_INSTALL_BLOCKED_IMMERSIVE* = HRESULT 0x800C0502'i32 + INET_E_FORBIDFRAMING* = HRESULT 0x800C0503'i32 + INET_E_CODE_INSTALL_BLOCKED_ARM* = HRESULT 0x800C0504'i32 + INET_E_BLOCKED_PLUGGABLE_PROTOCOL* = HRESULT 0x800C0505'i32 + INET_E_ERROR_LAST* = INET_E_BLOCKED_PLUGGABLE_PROTOCOL + IID_IPersistMoniker* = DEFINE_GUID("79eac9c9-baf9-11ce-8c82-00aa004ba90b") + MIMETYPEPROP* = 0x0 + USE_SRC_URL* = 0x1 + CLASSIDPROP* = 0x2 + TRUSTEDDOWNLOADPROP* = 0x3 + POPUPLEVELPROP* = 0x4 + IID_IMonikerProp* = DEFINE_GUID("a5ca5f7f-1847-4d87-9c5b-918509f7511d") + IID_IBindProtocol* = DEFINE_GUID("79eac9cd-baf9-11ce-8c82-00aa004ba90b") + IID_IBinding* = DEFINE_GUID("79eac9c0-baf9-11ce-8c82-00aa004ba90b") + BINDVERB_GET* = 0x0 + BINDVERB_POST* = 0x1 + BINDVERB_PUT* = 0x2 + BINDVERB_CUSTOM* = 0x3 + BINDVERB_RESERVED1* = 0x4 + BINDINFOF_URLENCODESTGMEDDATA* = 0x1 + BINDINFOF_URLENCODEDEXTRAINFO* = 0x2 + BINDF_ASYNCHRONOUS* = 0x1 + BINDF_ASYNCSTORAGE* = 0x2 + BINDF_NOPROGRESSIVERENDERING* = 0x4 + BINDF_OFFLINEOPERATION* = 0x8 + BINDF_NEEDFILE* = 0x40 + BINDF_IGNORESECURITYPROBLEM* = 0x100 + BINDF_RESYNCHRONIZE* = 0x200 + BINDF_HYPERLINK* = 0x400 + BINDF_NO_UI* = 0x800 + BINDF_SILENTOPERATION* = 0x1000 + BINDF_PRAGMA_NO_CACHE* = 0x2000 + BINDF_GETCLASSOBJECT* = 0x4000 + BINDF_RESERVED_1* = 0x8000 + BINDF_FREE_THREADED* = 0x10000 + BINDF_DIRECT_READ* = 0x20000 + BINDF_FORMS_SUBMIT* = 0x40000 + BINDF_GETFROMCACHE_IF_NET_FAIL* = 0x80000 + BINDF_FROMURLMON* = 0x100000 + BINDF_FWD_BACK* = 0x200000 + BINDF_PREFERDEFAULTHANDLER* = 0x400000 + BINDF_ENFORCERESTRICTED* = 0x800000 + BINDF_RESERVED_2* = 0x80000000'i32 + BINDF_RESERVED_3* = 0x1000000 + BINDF_RESERVED_4* = 0x2000000 + BINDF_RESERVED_5* = 0x4000000 + BINDF_RESERVED_6* = 0x8000000 + BINDF_RESERVED_7* = 0x40000000 + BINDF_RESERVED_8* = 0x20000000 + URL_ENCODING_NONE* = 0x0 + URL_ENCODING_ENABLE_UTF8* = 0x10000000 + URL_ENCODING_DISABLE_UTF8* = 0x20000000 + BINDINFO_OPTIONS_WININETFLAG* = 0x10000 + BINDINFO_OPTIONS_ENABLE_UTF8* = 0x20000 + BINDINFO_OPTIONS_DISABLE_UTF8* = 0x40000 + BINDINFO_OPTIONS_USE_IE_ENCODING* = 0x80000 + BINDINFO_OPTIONS_BINDTOOBJECT* = 0x100000 + BINDINFO_OPTIONS_SECURITYOPTOUT* = 0x200000 + BINDINFO_OPTIONS_IGNOREMIMETEXTPLAIN* = 0x400000 + BINDINFO_OPTIONS_USEBINDSTRINGCREDS* = 0x800000 + BINDINFO_OPTIONS_IGNOREHTTPHTTPSREDIRECTS* = 0x1000000 + BINDINFO_OPTIONS_IGNORE_SSLERRORS_ONCE* = 0x2000000 + BINDINFO_WPC_DOWNLOADBLOCKED* = 0x8000000 + BINDINFO_WPC_LOGGING_ENABLED* = 0x10000000 + BINDINFO_OPTIONS_ALLOWCONNECTDATA* = 0x20000000 + BINDINFO_OPTIONS_DISABLEAUTOREDIRECTS* = 0x40000000 + BINDINFO_OPTIONS_SHDOCVW_NAVIGATE* = int32 0x80000000'i32 + BSCF_FIRSTDATANOTIFICATION* = 0x1 + BSCF_INTERMEDIATEDATANOTIFICATION* = 0x2 + BSCF_LASTDATANOTIFICATION* = 0x4 + BSCF_DATAFULLYAVAILABLE* = 0x8 + BSCF_AVAILABLEDATASIZEUNKNOWN* = 0x10 + BSCF_SKIPDRAINDATAFORFILEURLS* = 0x20 + BSCF_64BITLENGTHDOWNLOAD* = 0x40 + BINDSTATUS_FINDINGRESOURCE* = 1 + BINDSTATUS_CONNECTING* = 2 + BINDSTATUS_REDIRECTING* = 3 + BINDSTATUS_BEGINDOWNLOADDATA* = 4 + BINDSTATUS_DOWNLOADINGDATA* = 5 + BINDSTATUS_ENDDOWNLOADDATA* = 6 + BINDSTATUS_BEGINDOWNLOADCOMPONENTS* = 7 + BINDSTATUS_INSTALLINGCOMPONENTS* = 8 + BINDSTATUS_ENDDOWNLOADCOMPONENTS* = 9 + BINDSTATUS_USINGCACHEDCOPY* = 10 + BINDSTATUS_SENDINGREQUEST* = 11 + BINDSTATUS_CLASSIDAVAILABLE* = 12 + BINDSTATUS_MIMETYPEAVAILABLE* = 13 + BINDSTATUS_CACHEFILENAMEAVAILABLE* = 14 + BINDSTATUS_BEGINSYNCOPERATION* = 15 + BINDSTATUS_ENDSYNCOPERATION* = 16 + BINDSTATUS_BEGINUPLOADDATA* = 17 + BINDSTATUS_UPLOADINGDATA* = 18 + BINDSTATUS_ENDUPLOADDATA* = 19 + BINDSTATUS_PROTOCOLCLASSID* = 20 + BINDSTATUS_ENCODING* = 21 + BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE* = 22 + BINDSTATUS_CLASSINSTALLLOCATION* = 23 + BINDSTATUS_DECODING* = 24 + BINDSTATUS_LOADINGMIMEHANDLER* = 25 + BINDSTATUS_CONTENTDISPOSITIONATTACH* = 26 + BINDSTATUS_FILTERREPORTMIMETYPE* = 27 + BINDSTATUS_CLSIDCANINSTANTIATE* = 28 + BINDSTATUS_IUNKNOWNAVAILABLE* = 29 + BINDSTATUS_DIRECTBIND* = 30 + BINDSTATUS_RAWMIMETYPE* = 31 + BINDSTATUS_PROXYDETECTING* = 32 + BINDSTATUS_ACCEPTRANGES* = 33 + BINDSTATUS_COOKIE_SENT* = 34 + BINDSTATUS_COMPACT_POLICY_RECEIVED* = 35 + BINDSTATUS_COOKIE_SUPPRESSED* = 36 + BINDSTATUS_COOKIE_STATE_UNKNOWN* = 37 + BINDSTATUS_COOKIE_STATE_ACCEPT* = 38 + BINDSTATUS_COOKIE_STATE_REJECT* = 39 + BINDSTATUS_COOKIE_STATE_PROMPT* = 40 + BINDSTATUS_COOKIE_STATE_LEASH* = 41 + BINDSTATUS_COOKIE_STATE_DOWNGRADE* = 42 + BINDSTATUS_POLICY_HREF* = 43 + BINDSTATUS_P3P_HEADER* = 44 + BINDSTATUS_SESSION_COOKIE_RECEIVED* = 45 + BINDSTATUS_PERSISTENT_COOKIE_RECEIVED* = 46 + BINDSTATUS_SESSION_COOKIES_ALLOWED* = 47 + BINDSTATUS_CACHECONTROL* = 48 + BINDSTATUS_CONTENTDISPOSITIONFILENAME* = 49 + BINDSTATUS_MIMETEXTPLAINMISMATCH* = 50 + BINDSTATUS_PUBLISHERAVAILABLE* = 51 + BINDSTATUS_DISPLAYNAMEAVAILABLE* = 52 + BINDSTATUS_SSLUX_NAVBLOCKED* = 53 + BINDSTATUS_SERVER_MIMETYPEAVAILABLE* = 54 + BINDSTATUS_SNIFFED_CLASSIDAVAILABLE* = 55 + BINDSTATUS_64BIT_PROGRESS* = 56 + BINDSTATUS_LAST* = BINDSTATUS_64BIT_PROGRESS + BINDSTATUS_RESERVED_0* = 57 + BINDSTATUS_RESERVED_1* = 58 + BINDSTATUS_RESERVED_2* = 59 + BINDSTATUS_RESERVED_3* = 60 + BINDSTATUS_RESERVED_4* = 61 + BINDSTATUS_RESERVED_5* = 62 + BINDSTATUS_RESERVED_6* = 63 + BINDSTATUS_RESERVED_7* = 64 + BINDSTATUS_RESERVED_8* = 65 + BINDSTATUS_RESERVED_9* = 66 + BINDSTATUS_LAST_PRIVATE* = BINDSTATUS_RESERVED_9 + IID_IBindStatusCallback* = DEFINE_GUID("79eac9c1-baf9-11ce-8c82-00aa004ba90b") + BINDF2_DISABLEBASICOVERHTTP* = 0x1 + BINDF2_DISABLEAUTOCOOKIEHANDLING* = 0x2 + BINDF2_READ_DATA_GREATER_THAN_4GB* = 0x4 + BINDF2_DISABLE_HTTP_REDIRECT_XSECURITYID* = 0x8 + BINDF2_SETDOWNLOADMODE* = 0x20 + BINDF2_DISABLE_HTTP_REDIRECT_CACHING* = 0x40 + BINDF2_KEEP_CALLBACK_MODULE_LOADED* = 0x80 + BINDF2_ALLOW_PROXY_CRED_PROMPT* = 0x100 + BINDF2_RESERVED_F* = 0x20000 + BINDF2_RESERVED_E* = 0x40000 + BINDF2_RESERVED_D* = 0x80000 + BINDF2_RESERVED_C* = 0x100000 + BINDF2_RESERVED_B* = 0x200000 + BINDF2_RESERVED_A* = 0x400000 + BINDF2_RESERVED_9* = 0x800000 + BINDF2_RESERVED_8* = 0x1000000 + BINDF2_RESERVED_7* = 0x2000000 + BINDF2_RESERVED_6* = 0x4000000 + BINDF2_RESERVED_5* = 0x8000000 + BINDF2_RESERVED_4* = 0x10000000 + BINDF2_RESERVED_3* = 0x20000000 + BINDF2_RESERVED_2* = 0x40000000 + BINDF2_RESERVED_1* = 0x80000000'i32 + IID_IBindStatusCallbackEx* = DEFINE_GUID("aaa74ef9-8ee7-4659-88d9-f8c504da73cc") + IID_IAuthenticate* = DEFINE_GUID("79eac9d0-baf9-11ce-8c82-00aa004ba90b") + AUTHENTICATEF_PROXY* = 0x1 + AUTHENTICATEF_BASIC* = 0x2 + AUTHENTICATEF_HTTP* = 0x4 + IID_IAuthenticateEx* = DEFINE_GUID("2ad1edaf-d83d-48b5-9adf-03dbe19f53bd") + IID_IHttpNegotiate* = DEFINE_GUID("79eac9d2-baf9-11ce-8c82-00aa004ba90b") + IID_IHttpNegotiate2* = DEFINE_GUID("4f9f9fcb-e0f4-48eb-b7ab-fa2ea9365cb4") + IID_IHttpNegotiate3* = DEFINE_GUID("57b6c80a-34c2-4602-bc26-66a02fc57153") + IID_IWinInetFileStream* = DEFINE_GUID("f134c4b7-b1f8-4e75-b886-74b90943becb") + IID_IWindowForBindingUI* = DEFINE_GUID("79eac9d5-bafa-11ce-8c82-00aa004ba90b") + CIP_DISK_FULL* = 0 + CIP_ACCESS_DENIED* = 1 + CIP_NEWER_VERSION_EXISTS* = 2 + CIP_OLDER_VERSION_EXISTS* = 3 + CIP_NAME_CONFLICT* = 4 + CIP_TRUST_VERIFICATION_COMPONENT_MISSING* = 5 + CIP_EXE_SELF_REGISTERATION_TIMEOUT* = 6 + CIP_UNSAFE_TO_ABORT* = 7 + CIP_NEED_REBOOT* = 8 + CIP_NEED_REBOOT_UI_PERMISSION* = 9 + IID_ICodeInstall* = DEFINE_GUID("79eac9d1-baf9-11ce-8c82-00aa004ba90b") + Uri_PROPERTY_ABSOLUTE_URI* = 0 + Uri_PROPERTY_STRING_START* = Uri_PROPERTY_ABSOLUTE_URI + Uri_PROPERTY_AUTHORITY* = 1 + Uri_PROPERTY_DISPLAY_URI* = 2 + Uri_PROPERTY_DOMAIN* = 3 + Uri_PROPERTY_EXTENSION* = 4 + Uri_PROPERTY_FRAGMENT* = 5 + Uri_PROPERTY_HOST* = 6 + Uri_PROPERTY_PASSWORD* = 7 + Uri_PROPERTY_PATH* = 8 + Uri_PROPERTY_PATH_AND_QUERY* = 9 + Uri_PROPERTY_QUERY* = 10 + Uri_PROPERTY_RAW_URI* = 11 + Uri_PROPERTY_SCHEME_NAME* = 12 + Uri_PROPERTY_USER_INFO* = 13 + Uri_PROPERTY_USER_NAME* = 14 + Uri_PROPERTY_STRING_LAST* = Uri_PROPERTY_USER_NAME + Uri_PROPERTY_HOST_TYPE* = 15 + Uri_PROPERTY_DWORD_START* = Uri_PROPERTY_HOST_TYPE + Uri_PROPERTY_PORT* = 16 + Uri_PROPERTY_SCHEME* = 17 + Uri_PROPERTY_ZONE* = 18 + Uri_PROPERTY_DWORD_LAST* = Uri_PROPERTY_ZONE + Uri_HOST_UNKNOWN* = 0 + Uri_HOST_DNS* = 1 + Uri_HOST_IPV4* = 2 + Uri_HOST_IPV6* = 3 + Uri_HOST_IDN* = 4 + IID_IUri* = DEFINE_GUID("a39ee748-6a27-4817-a6f2-13914bef5890") + Uri_HAS_ABSOLUTE_URI* = 1 shl Uri_PROPERTY_ABSOLUTE_URI + Uri_HAS_AUTHORITY* = 1 shl Uri_PROPERTY_AUTHORITY + Uri_HAS_DISPLAY_URI* = 1 shl Uri_PROPERTY_DISPLAY_URI + Uri_HAS_DOMAIN* = 1 shl Uri_PROPERTY_DOMAIN + Uri_HAS_EXTENSION* = 1 shl Uri_PROPERTY_EXTENSION + Uri_HAS_FRAGMENT* = 1 shl Uri_PROPERTY_FRAGMENT + Uri_HAS_HOST* = 1 shl Uri_PROPERTY_HOST + Uri_HAS_PASSWORD* = 1 shl Uri_PROPERTY_PASSWORD + Uri_HAS_PATH* = 1 shl Uri_PROPERTY_PATH + Uri_HAS_QUERY* = 1 shl Uri_PROPERTY_QUERY + Uri_HAS_RAW_URI* = 1 shl Uri_PROPERTY_RAW_URI + Uri_HAS_SCHEME_NAME* = 1 shl Uri_PROPERTY_SCHEME_NAME + Uri_HAS_USER_NAME* = 1 shl Uri_PROPERTY_USER_NAME + Uri_HAS_PATH_AND_QUERY* = 1 shl Uri_PROPERTY_PATH_AND_QUERY + Uri_HAS_USER_INFO* = 1 shl Uri_PROPERTY_USER_INFO + Uri_HAS_HOST_TYPE* = 1 shl Uri_PROPERTY_HOST_TYPE + Uri_HAS_PORT* = 1 shl Uri_PROPERTY_PORT + Uri_HAS_SCHEME* = 1 shl Uri_PROPERTY_SCHEME + Uri_HAS_ZONE* = 1 shl Uri_PROPERTY_ZONE + Uri_CREATE_ALLOW_RELATIVE* = 0x1 + Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME* = 0x2 + Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME* = 0x4 + Uri_CREATE_NOFRAG* = 0x8 + Uri_CREATE_NO_CANONICALIZE* = 0x10 + Uri_CREATE_CANONICALIZE* = 0x100 + Uri_CREATE_FILE_USE_DOS_PATH* = 0x20 + Uri_CREATE_DECODE_EXTRA_INFO* = 0x40 + Uri_CREATE_NO_DECODE_EXTRA_INFO* = 0x80 + Uri_CREATE_CRACK_UNKNOWN_SCHEMES* = 0x200 + Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES* = 0x400 + Uri_CREATE_PRE_PROCESS_HTML_URI* = 0x800 + Uri_CREATE_NO_PRE_PROCESS_HTML_URI* = 0x1000 + Uri_CREATE_IE_SETTINGS* = 0x2000 + Uri_CREATE_NO_IE_SETTINGS* = 0x4000 + Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS* = 0x8000 + Uri_CREATE_NORMALIZE_INTL_CHARACTERS* = 0x10000 + Uri_CREATE_CANONICALIZE_ABSOLUTE* = 0x20000 + Uri_DISPLAY_NO_FRAGMENT* = 0x1 + Uri_PUNYCODE_IDN_HOST* = 0x2 + Uri_DISPLAY_IDN_HOST* = 0x4 + Uri_DISPLAY_NO_PUNYCODE* = 0x8 + Uri_ENCODING_USER_INFO_AND_PATH_IS_PERCENT_ENCODED_UTF8* = 0x1 + Uri_ENCODING_USER_INFO_AND_PATH_IS_CP* = 0x2 + Uri_ENCODING_HOST_IS_IDN* = 0x4 + Uri_ENCODING_HOST_IS_PERCENT_ENCODED_UTF8* = 0x8 + Uri_ENCODING_HOST_IS_PERCENT_ENCODED_CP* = 0x10 + Uri_ENCODING_QUERY_AND_FRAGMENT_IS_PERCENT_ENCODED_UTF8* = 0x20 + Uri_ENCODING_QUERY_AND_FRAGMENT_IS_CP* = 0x40 + Uri_ENCODING_RFC* = Uri_ENCODING_USER_INFO_AND_PATH_IS_PERCENT_ENCODED_UTF8 or Uri_ENCODING_HOST_IS_PERCENT_ENCODED_UTF8 or Uri_ENCODING_QUERY_AND_FRAGMENT_IS_PERCENT_ENCODED_UTF8 + UriBuilder_USE_ORIGINAL_FLAGS* = 0x1 + IID_IUriContainer* = DEFINE_GUID("a158a630-ed6f-45fb-b987-f68676f57752") + IID_IUriBuilder* = DEFINE_GUID("4221b2e1-8955-46c0-bd5b-de9897565de7") + IID_IUriBuilderFactory* = DEFINE_GUID("e982ce48-0b96-440c-bc37-0c869b27a29e") + IID_IWinInetInfo* = DEFINE_GUID("79eac9d6-bafa-11ce-8c82-00aa004ba90b") + WININETINFO_OPTION_LOCK_HANDLE* = 65534 + IID_IHttpSecurity* = DEFINE_GUID("79eac9d7-bafa-11ce-8c82-00aa004ba90b") + IID_IWinInetHttpInfo* = DEFINE_GUID("79eac9d8-bafa-11ce-8c82-00aa004ba90b") + IID_IWinInetHttpTimeouts* = DEFINE_GUID("f286fa56-c1fd-4270-8e67-b3eb790a81e8") + IID_IWinInetCacheHints* = DEFINE_GUID("dd1ec3b3-8391-4fdb-a9e6-347c3caaa7dd") + IID_IWinInetCacheHints2* = DEFINE_GUID("7857aeac-d31f-49bf-884e-dd46df36780a") + IID_IBindHost* = DEFINE_GUID("fc4801a1-2ba9-11cf-a229-00aa003d7352") + SID_IBindHost* = IID_IBindHost + SID_SBindHost* = IID_IBindHost + URLOSTRM_USECACHEDCOPY_ONLY* = 0x1 + URLOSTRM_USECACHEDCOPY* = 0x2 + URLOSTRM_GETNEWESTVERSION* = 0x3 + IID_IInternet* = DEFINE_GUID("79eac9e0-baf9-11ce-8c82-00aa004ba90b") + BINDSTRING_HEADERS* = 1 + BINDSTRING_ACCEPT_MIMES* = 2 + BINDSTRING_EXTRA_URL* = 3 + BINDSTRING_LANGUAGE* = 4 + BINDSTRING_USERNAME* = 5 + BINDSTRING_PASSWORD* = 6 + BINDSTRING_UA_PIXELS* = 7 + BINDSTRING_UA_COLOR* = 8 + BINDSTRING_OS* = 9 + BINDSTRING_USER_AGENT* = 10 + BINDSTRING_ACCEPT_ENCODINGS* = 11 + BINDSTRING_POST_COOKIE* = 12 + BINDSTRING_POST_DATA_MIME* = 13 + BINDSTRING_URL* = 14 + BINDSTRING_IID* = 15 + BINDSTRING_FLAG_BIND_TO_OBJECT* = 16 + BINDSTRING_PTR_BIND_CONTEXT* = 17 + BINDSTRING_XDR_ORIGIN* = 18 + BINDSTRING_DOWNLOADPATH* = 19 + BINDSTRING_ROOTDOC_URL* = 20 + BINDSTRING_INITIAL_FILENAME* = 21 + BINDSTRING_PROXY_USERNAME* = 22 + BINDSTRING_PROXY_PASSWORD* = 23 + IID_IInternetBindInfo* = DEFINE_GUID("79eac9e1-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetBindInfoEx* = DEFINE_GUID("a3e015b7-a82c-4dcd-a150-569aeeed36ab") + PI_PARSE_URL* = 0x1 + PI_FILTER_MODE* = 0x2 + PI_FORCE_ASYNC* = 0x4 + PI_USE_WORKERTHREAD* = 0x8 + PI_MIMEVERIFICATION* = 0x10 + PI_DATAPROGRESS* = 0x40 + PI_SYNCHRONOUS* = 0x80 + PI_APARTMENTTHREADED* = 0x100 + PI_CLASSINSTALL* = 0x200 + PI_PASSONBINDCTX* = 0x2000 + PI_NOMIMEHANDLER* = 0x8000 + PI_LOADAPPDIRECT* = 0x4000 + PD_FORCE_SWITCH* = 0x10000 + PI_PREFERDEFAULTHANDLER* = 0x20000 + IID_IInternetProtocolRoot* = DEFINE_GUID("79eac9e3-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetProtocol* = DEFINE_GUID("79eac9e4-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetProtocolEx* = DEFINE_GUID("c7a98e66-1010-492c-a1c8-c809e1f75905") + IID_IInternetProtocolSink* = DEFINE_GUID("79eac9e5-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetProtocolSinkStackable* = DEFINE_GUID("79eac9f0-baf9-11ce-8c82-00aa004ba90b") + OIBDG_APARTMENTTHREADED* = 0x100 + OIBDG_DATAONLY* = 0x1000 + IID_IInternetSession* = DEFINE_GUID("79eac9e7-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetThreadSwitch* = DEFINE_GUID("79eac9e8-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetPriority* = DEFINE_GUID("79eac9eb-baf9-11ce-8c82-00aa004ba90b") + PARSE_CANONICALIZE* = 1 + PARSE_FRIENDLY* = 2 + PARSE_SECURITY_URL* = 3 + PARSE_ROOTDOCUMENT* = 4 + PARSE_DOCUMENT* = 5 + PARSE_ANCHOR* = 6 + PARSE_ENCODE_IS_UNESCAPE* = 7 + PARSE_DECODE_IS_ESCAPE* = 8 + PARSE_PATH_FROM_URL* = 9 + PARSE_URL_FROM_PATH* = 10 + PARSE_MIME* = 11 + PARSE_SERVER* = 12 + PARSE_SCHEMA* = 13 + PARSE_SITE* = 14 + PARSE_DOMAIN* = 15 + PARSE_LOCATION* = 16 + PARSE_SECURITY_DOMAIN* = 17 + PARSE_ESCAPE* = 18 + PARSE_UNESCAPE* = 19 + PSU_DEFAULT* = 1 + PSU_SECURITY_URL_ONLY* = 2 + QUERY_EXPIRATION_DATE* = 1 + QUERY_TIME_OF_LAST_CHANGE* = 2 + QUERY_CONTENT_ENCODING* = 3 + QUERY_CONTENT_TYPE* = 4 + QUERY_REFRESH* = 5 + QUERY_RECOMBINE* = 6 + QUERY_CAN_NAVIGATE* = 7 + QUERY_USES_NETWORK* = 8 + QUERY_IS_CACHED* = 9 + QUERY_IS_INSTALLEDENTRY* = 10 + QUERY_IS_CACHED_OR_MAPPED* = 11 + QUERY_USES_CACHE* = 12 + QUERY_IS_SECURE* = 13 + QUERY_IS_SAFE* = 14 + QUERY_USES_HISTORYFOLDER* = 15 + QUERY_IS_CACHED_AND_USABLE_OFFLINE* = 16 + IID_IInternetProtocolInfo* = DEFINE_GUID("79eac9ec-baf9-11ce-8c82-00aa004ba90b") + PARSE_ENCODE* = PARSE_ENCODE_IS_UNESCAPE + PARSE_DECODE* = PARSE_DECODE_IS_ESCAPE + IID_IOInet* = IID_IInternet + IID_IOInetBindInfo* = IID_IInternetBindInfo + IID_IOInetBindInfoEx* = IID_IInternetBindInfoEx + IID_IOInetProtocolRoot* = IID_IInternetProtocolRoot + IID_IOInetProtocol* = IID_IInternetProtocol + IID_IOInetProtocolEx* = IID_IInternetProtocolEx + IID_IOInetProtocolSink* = IID_IInternetProtocolSink + IID_IOInetProtocolInfo* = IID_IInternetProtocolInfo + IID_IOInetSession* = IID_IInternetSession + IID_IOInetPriority* = IID_IInternetPriority + IID_IOInetThreadSwitch* = IID_IInternetThreadSwitch + IID_IOInetProtocolSinkStackable* = IID_IInternetProtocolSinkStackable + FEATURE_OBJECT_CACHING* = 0 + FEATURE_ZONE_ELEVATION* = 1 + FEATURE_MIME_HANDLING* = 2 + FEATURE_MIME_SNIFFING* = 3 + FEATURE_WINDOW_RESTRICTIONS* = 4 + FEATURE_WEBOC_POPUPMANAGEMENT* = 5 + FEATURE_BEHAVIORS* = 6 + FEATURE_DISABLE_MK_PROTOCOL* = 7 + FEATURE_LOCALMACHINE_LOCKDOWN* = 8 + FEATURE_SECURITYBAND* = 9 + FEATURE_RESTRICT_ACTIVEXINSTALL* = 10 + FEATURE_VALIDATE_NAVIGATE_URL* = 11 + FEATURE_RESTRICT_FILEDOWNLOAD* = 12 + FEATURE_ADDON_MANAGEMENT* = 13 + FEATURE_PROTOCOL_LOCKDOWN* = 14 + FEATURE_HTTP_USERNAME_PASSWORD_DISABLE* = 15 + FEATURE_SAFE_BINDTOOBJECT* = 16 + FEATURE_UNC_SAVEDFILECHECK* = 17 + FEATURE_GET_URL_DOM_FILEPATH_UNENCODED* = 18 + FEATURE_TABBED_BROWSING* = 19 + FEATURE_SSLUX* = 20 + FEATURE_DISABLE_NAVIGATION_SOUNDS* = 21 + FEATURE_DISABLE_LEGACY_COMPRESSION* = 22 + FEATURE_FORCE_ADDR_AND_STATUS* = 23 + FEATURE_XMLHTTP* = 24 + FEATURE_DISABLE_TELNET_PROTOCOL* = 25 + FEATURE_FEEDS* = 26 + FEATURE_BLOCK_INPUT_PROMPTS* = 27 + FEATURE_ENTRY_COUNT* = 28 + SET_FEATURE_ON_THREAD* = 0x1 + SET_FEATURE_ON_PROCESS* = 0x2 + SET_FEATURE_IN_REGISTRY* = 0x4 + SET_FEATURE_ON_THREAD_LOCALMACHINE* = 0x8 + SET_FEATURE_ON_THREAD_INTRANET* = 0x10 + SET_FEATURE_ON_THREAD_TRUSTED* = 0x20 + SET_FEATURE_ON_THREAD_INTERNET* = 0x40 + SET_FEATURE_ON_THREAD_RESTRICTED* = 0x80 + GET_FEATURE_FROM_THREAD* = 0x1 + GET_FEATURE_FROM_PROCESS* = 0x2 + GET_FEATURE_FROM_REGISTRY* = 0x4 + GET_FEATURE_FROM_THREAD_LOCALMACHINE* = 0x8 + GET_FEATURE_FROM_THREAD_INTRANET* = 0x10 + GET_FEATURE_FROM_THREAD_TRUSTED* = 0x20 + GET_FEATURE_FROM_THREAD_INTERNET* = 0x40 + GET_FEATURE_FROM_THREAD_RESTRICTED* = 0x80 + INET_E_USE_DEFAULT_PROTOCOLHANDLER* = HRESULT 0x800C0011'i32 + INET_E_USE_DEFAULT_SETTING* = HRESULT 0x800C0012'i32 + INET_E_DEFAULT_ACTION* = INET_E_USE_DEFAULT_PROTOCOLHANDLER + INET_E_QUERYOPTION_UNKNOWN* = HRESULT 0x800C0013'i32 + INET_E_REDIRECTING* = HRESULT 0x800C0014'i32 + PROTOCOLFLAG_NO_PICS_CHECK* = 0x1 + IID_IInternetSecurityManager* = DEFINE_GUID("79eac9ee-baf9-11ce-8c82-00aa004ba90b") + SID_SInternetSecurityManager* = IID_IInternetSecurityManager + IID_IInternetSecurityManagerEx* = DEFINE_GUID("f164edf1-cc7c-4f0d-9a94-34222625c393") + SID_SInternetSecurityManagerEx* = IID_IInternetSecurityManagerEx + IID_IInternetSecurityManagerEx2* = DEFINE_GUID("f1e50292-a795-4117-8e09-2b560a72ac60") + SID_SInternetSecurityManagerEx2* = IID_IInternetSecurityManagerEx2 + IID_IInternetHostSecurityManager* = DEFINE_GUID("3af280b6-cb3f-11d0-891e-00c04fb6bfc4") + SID_SInternetHostSecurityManager* = IID_IInternetHostSecurityManager + IID_IInternetSecurityMgrSite* = DEFINE_GUID("79eac9ed-baf9-11ce-8c82-00aa004ba90b") + MUTZ_NOSAVEDFILECHECK* = 0x1 + MUTZ_ISFILE* = 0x2 + MUTZ_ACCEPT_WILDCARD_SCHEME* = 0x80 + MUTZ_ENFORCERESTRICTED* = 0x100 + MUTZ_RESERVED* = 0x200 + MUTZ_REQUIRESAVEDFILECHECK* = 0x400 + MUTZ_DONT_UNESCAPE* = 0x800 + MUTZ_DONT_USE_CACHE* = 0x1000 + MUTZ_FORCE_INTRANET_FLAGS* = 0x2000 + MUTZ_IGNORE_ZONE_MAPPINGS* = 0x4000 + MAX_SIZE_SECURITY_ID* = 512 + PUAF_DEFAULT* = 0x0 + PUAF_NOUI* = 0x1 + PUAF_ISFILE* = 0x2 + PUAF_WARN_IF_DENIED* = 0x4 + PUAF_FORCEUI_FOREGROUND* = 0x8 + PUAF_CHECK_TIFS* = 0x10 + PUAF_DONTCHECKBOXINDIALOG* = 0x20 + PUAF_TRUSTED* = 0x40 + PUAF_ACCEPT_WILDCARD_SCHEME* = 0x80 + PUAF_ENFORCERESTRICTED* = 0x100 + PUAF_NOSAVEDFILECHECK* = 0x200 + PUAF_REQUIRESAVEDFILECHECK* = 0x400 + PUAF_DONT_USE_CACHE* = 0x1000 + PUAF_RESERVED1* = 0x2000 + PUAF_RESERVED2* = 0x4000 + PUAF_LMZ_UNLOCKED* = 0x10000 + PUAF_LMZ_LOCKED* = 0x20000 + PUAF_DEFAULTZONEPOL* = 0x40000 + PUAF_NPL_USE_LOCKED_IF_RESTRICTED* = 0x80000 + PUAF_NOUIIFLOCKED* = 0x100000 + PUAF_DRAGPROTOCOLCHECK* = 0x200000 + PUAFOUT_DEFAULT* = 0x0 + PUAFOUT_ISLOCKZONEPOLICY* = 0x1 + SZM_CREATE* = 0x0 + SZM_DELETE* = 0x1 + IID_IZoneIdentifier* = DEFINE_GUID("cd45f185-1b21-48e2-967b-ead743a8914e") + URLACTION_MIN* = 0x1000 + URLACTION_DOWNLOAD_MIN* = 0x1000 + URLACTION_DOWNLOAD_SIGNED_ACTIVEX* = 0x1001 + URLACTION_DOWNLOAD_UNSIGNED_ACTIVEX* = 0x1004 + URLACTION_DOWNLOAD_CURR_MAX* = 0x1004 + URLACTION_DOWNLOAD_MAX* = 0x11FF + URLACTION_ACTIVEX_MIN* = 0x1200 + URLACTION_ACTIVEX_RUN* = 0x1200 + URLPOLICY_ACTIVEX_CHECK_LIST* = 0x10000 + URLACTION_ACTIVEX_OVERRIDE_OBJECT_SAFETY* = 0x1201 + URLACTION_ACTIVEX_OVERRIDE_DATA_SAFETY* = 0x1202 + URLACTION_ACTIVEX_OVERRIDE_SCRIPT_SAFETY* = 0x1203 + URLACTION_SCRIPT_OVERRIDE_SAFETY* = 0x1401 + URLACTION_ACTIVEX_CONFIRM_NOOBJECTSAFETY* = 0x1204 + URLACTION_ACTIVEX_TREATASUNTRUSTED* = 0x1205 + URLACTION_ACTIVEX_NO_WEBOC_SCRIPT* = 0x1206 + URLACTION_ACTIVEX_OVERRIDE_REPURPOSEDETECTION* = 0x1207 + URLACTION_ACTIVEX_OVERRIDE_OPTIN* = 0x1208 + URLACTION_ACTIVEX_SCRIPTLET_RUN* = 0x1209 + URLACTION_ACTIVEX_DYNSRC_VIDEO_AND_ANIMATION* = 0x120A + URLACTION_ACTIVEX_OVERRIDE_DOMAINLIST* = 0x120B + URLACTION_ACTIVEX_CURR_MAX* = 0x120B + URLACTION_ACTIVEX_MAX* = 0x13ff + URLACTION_SCRIPT_MIN* = 0x1400 + URLACTION_SCRIPT_RUN* = 0x1400 + URLACTION_SCRIPT_JAVA_USE* = 0x1402 + URLACTION_SCRIPT_SAFE_ACTIVEX* = 0x1405 + URLACTION_CROSS_DOMAIN_DATA* = 0x1406 + URLACTION_SCRIPT_PASTE* = 0x1407 + URLACTION_ALLOW_XDOMAIN_SUBFRAME_RESIZE* = 0x1408 + URLACTION_SCRIPT_XSSFILTER* = 0x1409 + URLACTION_SCRIPT_NAVIGATE* = 0x140A + URLACTION_PLUGGABLE_PROTOCOL_XHR* = 0x140B + URLACTION_SCRIPT_CURR_MAX* = 0x140B + URLACTION_SCRIPT_MAX* = 0x15ff + URLACTION_HTML_MIN* = 0x1600 + URLACTION_HTML_SUBMIT_FORMS* = 0x1601 + URLACTION_HTML_SUBMIT_FORMS_FROM* = 0x1602 + URLACTION_HTML_SUBMIT_FORMS_TO* = 0x1603 + URLACTION_HTML_FONT_DOWNLOAD* = 0x1604 + URLACTION_HTML_JAVA_RUN* = 0x1605 + URLACTION_HTML_USERDATA_SAVE* = 0x1606 + URLACTION_HTML_SUBFRAME_NAVIGATE* = 0x1607 + URLACTION_HTML_META_REFRESH* = 0x1608 + URLACTION_HTML_MIXED_CONTENT* = 0x1609 + URLACTION_HTML_INCLUDE_FILE_PATH* = 0x160A + URLACTION_HTML_ALLOW_INJECTED_DYNAMIC_HTML* = 0x160B + URLACTION_HTML_REQUIRE_UTF8_DOCUMENT_CODEPAGE* = 0x160C + URLACTION_HTML_ALLOW_CROSS_DOMAIN_CANVAS* = 0x160D + URLACTION_HTML_ALLOW_WINDOW_CLOSE* = 0x160E + URLACTION_HTML_ALLOW_CROSS_DOMAIN_WEBWORKER* = 0x160F + URLACTION_HTML_ALLOW_CROSS_DOMAIN_TEXTTRACK* = 0x1610 + URLACTION_HTML_ALLOW_INDEXEDDB* = 0x1611 + URLACTION_HTML_MAX* = 0x17ff + URLACTION_SHELL_MIN* = 0x1800 + URLACTION_SHELL_INSTALL_DTITEMS* = 0x1800 + URLACTION_SHELL_MOVE_OR_COPY* = 0x1802 + URLACTION_SHELL_FILE_DOWNLOAD* = 0x1803 + URLACTION_SHELL_VERB* = 0x1804 + URLACTION_SHELL_WEBVIEW_VERB* = 0x1805 + URLACTION_SHELL_SHELLEXECUTE* = 0x1806 + URLACTION_SHELL_EXECUTE_HIGHRISK* = 0x1806 + URLACTION_SHELL_EXECUTE_MODRISK* = 0x1807 + URLACTION_SHELL_EXECUTE_LOWRISK* = 0x1808 + URLACTION_SHELL_POPUPMGR* = 0x1809 + URLACTION_SHELL_RTF_OBJECTS_LOAD* = 0x180A + URLACTION_SHELL_ENHANCED_DRAGDROP_SECURITY* = 0x180B + URLACTION_SHELL_EXTENSIONSECURITY* = 0x180C + URLACTION_SHELL_SECURE_DRAGSOURCE* = 0x180D + URLACTION_SHELL_REMOTEQUERY* = 0x180E + URLACTION_SHELL_PREVIEW* = 0x180F + URLACTION_SHELL_SHARE* = 0x1810 + URLACTION_SHELL_ALLOW_CROSS_SITE_SHARE* = 0x1811 + URLACTION_SHELL_CURR_MAX* = 0x1811 + URLACTION_SHELL_MAX* = 0x19ff + URLACTION_NETWORK_MIN* = 0x1A00 + URLACTION_CREDENTIALS_USE* = 0x1A00 + URLPOLICY_CREDENTIALS_SILENT_LOGON_OK* = 0x0 + URLPOLICY_CREDENTIALS_MUST_PROMPT_USER* = 0x10000 + URLPOLICY_CREDENTIALS_CONDITIONAL_PROMPT* = 0x20000 + URLPOLICY_CREDENTIALS_ANONYMOUS_ONLY* = 0x30000 + URLACTION_AUTHENTICATE_CLIENT* = 0x1A01 + URLPOLICY_AUTHENTICATE_CLEARTEXT_OK* = 0x0 + URLPOLICY_AUTHENTICATE_CHALLENGE_RESPONSE* = 0x10000 + URLPOLICY_AUTHENTICATE_MUTUAL_ONLY* = 0x30000 + URLACTION_COOKIES* = 0x1A02 + URLACTION_COOKIES_SESSION* = 0x1A03 + URLACTION_CLIENT_CERT_PROMPT* = 0x1A04 + URLACTION_COOKIES_THIRD_PARTY* = 0x1A05 + URLACTION_COOKIES_SESSION_THIRD_PARTY* = 0x1A06 + URLACTION_COOKIES_ENABLED* = 0x1A10 + URLACTION_NETWORK_CURR_MAX* = 0x1A10 + URLACTION_NETWORK_MAX* = 0x1Bff + URLACTION_JAVA_MIN* = 0x1C00 + URLACTION_JAVA_PERMISSIONS* = 0x1C00 + URLPOLICY_JAVA_PROHIBIT* = 0x0 + URLPOLICY_JAVA_HIGH* = 0x10000 + URLPOLICY_JAVA_MEDIUM* = 0x20000 + URLPOLICY_JAVA_LOW* = 0x30000 + URLPOLICY_JAVA_CUSTOM* = 0x800000 + URLACTION_JAVA_CURR_MAX* = 0x1C00 + URLACTION_JAVA_MAX* = 0x1Cff + URLACTION_INFODELIVERY_MIN* = 0x1D00 + URLACTION_INFODELIVERY_NO_ADDING_CHANNELS* = 0x1D00 + URLACTION_INFODELIVERY_NO_EDITING_CHANNELS* = 0x1D01 + URLACTION_INFODELIVERY_NO_REMOVING_CHANNELS* = 0x1D02 + URLACTION_INFODELIVERY_NO_ADDING_SUBSCRIPTIONS* = 0x1D03 + URLACTION_INFODELIVERY_NO_EDITING_SUBSCRIPTIONS* = 0x1D04 + URLACTION_INFODELIVERY_NO_REMOVING_SUBSCRIPTIONS* = 0x1D05 + URLACTION_INFODELIVERY_NO_CHANNEL_LOGGING* = 0x1D06 + URLACTION_INFODELIVERY_CURR_MAX* = 0x1D06 + URLACTION_INFODELIVERY_MAX* = 0x1Dff + URLACTION_CHANNEL_SOFTDIST_MIN* = 0x1E00 + URLACTION_CHANNEL_SOFTDIST_PERMISSIONS* = 0x1E05 + URLPOLICY_CHANNEL_SOFTDIST_PROHIBIT* = 0x10000 + URLPOLICY_CHANNEL_SOFTDIST_PRECACHE* = 0x20000 + URLPOLICY_CHANNEL_SOFTDIST_AUTOINSTALL* = 0x30000 + URLACTION_CHANNEL_SOFTDIST_MAX* = 0x1Eff + URLACTION_DOTNET_USERCONTROLS* = 0x2005 + URLACTION_BEHAVIOR_MIN* = 0x2000 + URLACTION_BEHAVIOR_RUN* = 0x2000 + URLPOLICY_BEHAVIOR_CHECK_LIST* = 0x10000 + URLACTION_FEATURE_MIN* = 0x2100 + URLACTION_FEATURE_MIME_SNIFFING* = 0x2100 + URLACTION_FEATURE_ZONE_ELEVATION* = 0x2101 + URLACTION_FEATURE_WINDOW_RESTRICTIONS* = 0x2102 + URLACTION_FEATURE_SCRIPT_STATUS_BAR* = 0x2103 + URLACTION_FEATURE_FORCE_ADDR_AND_STATUS* = 0x2104 + URLACTION_FEATURE_BLOCK_INPUT_PROMPTS* = 0x2105 + URLACTION_FEATURE_DATA_BINDING* = 0x2106 + URLACTION_FEATURE_CROSSDOMAIN_FOCUS_CHANGE* = 0x2107 + URLACTION_AUTOMATIC_DOWNLOAD_UI_MIN* = 0x2200 + URLACTION_AUTOMATIC_DOWNLOAD_UI* = 0x2200 + URLACTION_AUTOMATIC_ACTIVEX_UI* = 0x2201 + URLACTION_ALLOW_RESTRICTEDPROTOCOLS* = 0x2300 + URLACTION_ALLOW_APEVALUATION* = 0x2301 + URLACTION_ALLOW_XHR_EVALUATION* = 0x2302 + URLACTION_WINDOWS_BROWSER_APPLICATIONS* = 0x2400 + URLACTION_XPS_DOCUMENTS* = 0x2401 + URLACTION_LOOSE_XAML* = 0x2402 + URLACTION_LOWRIGHTS* = 0x2500 + URLACTION_WINFX_SETUP* = 0x2600 + URLACTION_INPRIVATE_BLOCKING* = 0x2700 + URLACTION_ALLOW_AUDIO_VIDEO* = 0x2701 + URLACTION_ALLOW_ACTIVEX_FILTERING* = 0x2702 + URLACTION_ALLOW_STRUCTURED_STORAGE_SNIFFING* = 0x2703 + URLACTION_ALLOW_AUDIO_VIDEO_PLUGINS* = 0x2704 + URLACTION_ALLOW_ZONE_ELEVATION_VIA_OPT_OUT* = 0x2705 + URLACTION_ALLOW_ZONE_ELEVATION_OPT_OUT_ADDITION* = 0x2706 + URLACTION_ALLOW_CROSSDOMAIN_DROP_WITHIN_WINDOW* = 0x2708 + URLACTION_ALLOW_CROSSDOMAIN_DROP_ACROSS_WINDOWS* = 0x2709 + URLACTION_ALLOW_CROSSDOMAIN_APPCACHE_MANIFEST* = 0x270A + URLACTION_ALLOW_RENDER_LEGACY_DXTFILTERS* = 0x270B + URLPOLICY_ALLOW* = 0x0 + URLPOLICY_QUERY* = 0x1 + URLPOLICY_DISALLOW* = 0x3 + URLPOLICY_NOTIFY_ON_ALLOW* = 0x10 + URLPOLICY_NOTIFY_ON_DISALLOW* = 0x20 + URLPOLICY_LOG_ON_ALLOW* = 0x40 + URLPOLICY_LOG_ON_DISALLOW* = 0x80 + URLPOLICY_MASK_PERMISSIONS* = 0x0f + URLPOLICY_DONTCHECKDLGBOX* = 0x100 + URLZONE_INVALID* = -1 + URLZONE_PREDEFINED_MIN* = 0 + URLZONE_LOCAL_MACHINE* = 0 + URLZONE_INTRANET* = 1 + URLZONE_TRUSTED* = 2 + URLZONE_INTERNET* = 3 + URLZONE_UNTRUSTED* = 4 + URLZONE_PREDEFINED_MAX* = 999 + URLZONE_USER_MIN* = 1000 + URLZONE_USER_MAX* = 10000 + URLZONE_ESC_FLAG* = 0x100 + URLTEMPLATE_CUSTOM* = 0x0 + URLTEMPLATE_PREDEFINED_MIN* = 0x10000 + URLTEMPLATE_LOW* = 0x10000 + URLTEMPLATE_MEDLOW* = 0x10500 + URLTEMPLATE_MEDIUM* = 0x11000 + URLTEMPLATE_MEDHIGH* = 0x11500 + URLTEMPLATE_HIGH* = 0x12000 + URLTEMPLATE_PREDEFINED_MAX* = 0x20000 + MAX_ZONE_PATH* = 260 + MAX_ZONE_DESCRIPTION* = 200 + ZAFLAGS_CUSTOM_EDIT* = 0x1 + ZAFLAGS_ADD_SITES* = 0x2 + ZAFLAGS_REQUIRE_VERIFICATION* = 0x4 + ZAFLAGS_INCLUDE_PROXY_OVERRIDE* = 0x8 + ZAFLAGS_INCLUDE_INTRANET_SITES* = 0x10 + ZAFLAGS_NO_UI* = 0x20 + ZAFLAGS_SUPPORTS_VERIFICATION* = 0x40 + ZAFLAGS_UNC_AS_INTRANET* = 0x80 + ZAFLAGS_DETECT_INTRANET* = 0x100 + ZAFLAGS_USE_LOCKED_ZONES* = 0x10000 + ZAFLAGS_VERIFY_TEMPLATE_SETTINGS* = 0x20000 + ZAFLAGS_NO_CACHE* = 0x40000 + URLZONEREG_DEFAULT* = 0 + URLZONEREG_HKLM* = 1 + URLZONEREG_HKCU* = 2 + IID_IInternetZoneManager* = DEFINE_GUID("79eac9ef-baf9-11ce-8c82-00aa004ba90b") + IID_IInternetZoneManagerEx* = DEFINE_GUID("a4c23339-8e06-431e-9bf4-7e711c085648") + SECURITY_IE_STATE_GREEN* = 0x0 + SECURITY_IE_STATE_RED* = 0x1 + IID_IInternetZoneManagerEx2* = DEFINE_GUID("edc17559-dd5d-4846-8eef-8becba5a4abf") + SOFTDIST_FLAG_USAGE_EMAIL* = 0x1 + SOFTDIST_FLAG_USAGE_PRECACHE* = 0x2 + SOFTDIST_FLAG_USAGE_AUTOINSTALL* = 0x4 + SOFTDIST_FLAG_DELETE_SUBSCRIPTION* = 0x8 + SOFTDIST_ADSTATE_NONE* = 0x0 + SOFTDIST_ADSTATE_AVAILABLE* = 0x1 + SOFTDIST_ADSTATE_DOWNLOADED* = 0x2 + SOFTDIST_ADSTATE_INSTALLED* = 0x3 + IID_ISoftDistExt* = DEFINE_GUID("b15b8dc1-c7e1-11d0-8680-00aa00bdcb71") + IID_ICatalogFileInfo* = DEFINE_GUID("711c7600-6b48-11d1-b403-00aa00b92af1") + IID_IDataFilter* = DEFINE_GUID("69d14c80-c18e-11d0-a9ce-006097942311") + IID_IEncodingFilterFactory* = DEFINE_GUID("70bdde00-c18e-11d0-a9ce-006097942311") + CONFIRMSAFETYACTION_LOADOBJECT* = 0x1 + IID_IWrappedProtocol* = DEFINE_GUID("53c84785-8425-4dc5-971b-e58d9c19f9b6") + BINDHANDLETYPES_APPCACHE* = 0x0 + BINDHANDLETYPES_DEPENDENCY* = 0x1 + BINDHANDLETYPES_COUNT* = 0x2 + IID_IGetBindHandle* = DEFINE_GUID("af0ff408-129d-4b20-91f0-02bd23d88352") + IID_IBindCallbackRedirect* = DEFINE_GUID("11c81bc2-121e-4ed5-b9c4-b430bd54f2c0") + PROPSETFLAG_DEFAULT* = 0 + PROPSETFLAG_NONSIMPLE* = 1 + PROPSETFLAG_ANSI* = 2 + PROPSETFLAG_UNBUFFERED* = 4 + PROPSETFLAG_CASE_SENSITIVE* = 8 + PROPSET_BEHAVIOR_CASE_SENSITIVE* = 1 + PID_DICTIONARY* = 0x0 + PID_CODEPAGE* = 0x1 + PID_FIRST_USABLE* = 0x2 + PID_FIRST_NAME_DEFAULT* = 0xfff + PID_LOCALE* = 0x80000000'i32 + PID_MODIFY_TIME* = 0x80000001'i32 + PID_SECURITY* = 0x80000002'i32 + PID_BEHAVIOR* = 0x80000003'i32 + PID_ILLEGAL* = 0xffffffff'i32 + PID_MIN_READONLY* = 0x80000000'i32 + PID_MAX_READONLY* = 0xbfffffff'i32 + PIDDI_THUMBNAIL* = 0x2 + PIDSI_TITLE* = 0x2 + PIDSI_SUBJECT* = 0x3 + PIDSI_AUTHOR* = 0x4 + PIDSI_KEYWORDS* = 0x5 + PIDSI_COMMENTS* = 0x6 + PIDSI_TEMPLATE* = 0x7 + PIDSI_LASTAUTHOR* = 0x8 + PIDSI_REVNUMBER* = 0x9 + PIDSI_EDITTIME* = 0xa + PIDSI_LASTPRINTED* = 0xb + PIDSI_CREATE_DTM* = 0xc + PIDSI_LASTSAVE_DTM* = 0xd + PIDSI_PAGECOUNT* = 0xe + PIDSI_WORDCOUNT* = 0xf + PIDSI_CHARCOUNT* = 0x10 + PIDSI_THUMBNAIL* = 0x11 + PIDSI_APPNAME* = 0x12 + PIDSI_DOC_SECURITY* = 0x13 + PIDDSI_CATEGORY* = 0x00000002 + PIDDSI_PRESFORMAT* = 0x00000003 + PIDDSI_BYTECOUNT* = 0x00000004 + PIDDSI_LINECOUNT* = 0x00000005 + PIDDSI_PARCOUNT* = 0x00000006 + PIDDSI_SLIDECOUNT* = 0x00000007 + PIDDSI_NOTECOUNT* = 0x00000008 + PIDDSI_HIDDENCOUNT* = 0x00000009 + PIDDSI_MMCLIPCOUNT* = 0x0000000A + PIDDSI_SCALE* = 0x0000000B + PIDDSI_HEADINGPAIR* = 0x0000000C + PIDDSI_DOCPARTS* = 0x0000000D + PIDDSI_MANAGER* = 0x0000000E + PIDDSI_COMPANY* = 0x0000000F + PIDDSI_LINKSDIRTY* = 0x00000010 + PIDMSI_EDITOR* = 0x2 + PIDMSI_SUPPLIER* = 0x3 + PIDMSI_SOURCE* = 0x4 + PIDMSI_SEQUENCE_NO* = 0x5 + PIDMSI_PROJECT* = 0x6 + PIDMSI_STATUS* = 0x7 + PIDMSI_OWNER* = 0x8 + PIDMSI_RATING* = 0x9 + PIDMSI_PRODUCTION* = 0xa + PIDMSI_COPYRIGHT* = 0xb + PIDMSI_STATUS_NORMAL* = 0 + PIDMSI_STATUS_NEW* = 1 + PIDMSI_STATUS_PRELIM* = 2 + PIDMSI_STATUS_DRAFT* = 3 + PIDMSI_STATUS_INPROGRESS* = 4 + PIDMSI_STATUS_EDIT* = 5 + PIDMSI_STATUS_REVIEW* = 6 + PIDMSI_STATUS_PROOF* = 7 + PIDMSI_STATUS_FINAL* = 8 + PIDMSI_STATUS_OTHER* = 0x7fff + PRSPEC_INVALID* = 0xffffffff'i32 + PRSPEC_LPWSTR* = 0 + PRSPEC_PROPID* = 1 + PROPSETHDR_OSVERSION_UNKNOWN* = 0xffffffff'i32 + IID_IPropertyStorage* = DEFINE_GUID("00000138-0000-0000-c000-000000000046") + IID_IPropertySetStorage* = DEFINE_GUID("0000013a-0000-0000-c000-000000000046") + IID_IEnumSTATPROPSTG* = DEFINE_GUID("00000139-0000-0000-c000-000000000046") + IID_IEnumSTATPROPSETSTG* = DEFINE_GUID("0000013b-0000-0000-c000-000000000046") + CCH_MAX_PROPSTG_NAME* = 31 + UAS_NORMAL* = 0x0 + UAS_BLOCKED* = 0x1 + UAS_NOPARENTENABLE* = 0x2 + UAS_MASK* = 0x3 + READYSTATE_UNINITIALIZED* = 0 + READYSTATE_LOADING* = 1 + READYSTATE_LOADED* = 2 + READYSTATE_INTERACTIVE* = 3 + READYSTATE_COMPLETE* = 4 + IID_IEnumConnections* = DEFINE_GUID("b196b287-bab4-101a-b69c-00aa00341d07") + IID_IConnectionPoint* = DEFINE_GUID("b196b286-bab4-101a-b69c-00aa00341d07") + IID_IEnumConnectionPoints* = DEFINE_GUID("b196b285-bab4-101a-b69c-00aa00341d07") + IID_IConnectionPointContainer* = DEFINE_GUID("b196b284-bab4-101a-b69c-00aa00341d07") + IID_IClassFactory2* = DEFINE_GUID("b196b28f-bab4-101a-b69c-00aa00341d07") + IID_IProvideClassInfo* = DEFINE_GUID("b196b283-bab4-101a-b69c-00aa00341d07") + GUIDKIND_DEFAULT_SOURCE_DISP_IID* = 1 + IID_IProvideClassInfo2* = DEFINE_GUID("a6bc3ac0-dbaa-11ce-9de3-00aa004bb851") + MULTICLASSINFO_GETTYPEINFO* = 0x1 + MULTICLASSINFO_GETNUMRESERVEDDISPIDS* = 0x2 + MULTICLASSINFO_GETIIDPRIMARY* = 0x4 + MULTICLASSINFO_GETIIDSOURCE* = 0x8 + TIFLAGS_EXTENDDISPATCHONLY* = 0x1 + IID_IProvideMultipleClassInfo* = DEFINE_GUID("a7aba9c1-8983-11cf-8f20-00805f2cd064") + CTRLINFO_EATS_RETURN* = 1 + CTRLINFO_EATS_ESCAPE* = 2 + IID_IOleControl* = DEFINE_GUID("b196b288-bab4-101a-b69c-00aa00341d07") + XFORMCOORDS_POSITION* = 0x1 + XFORMCOORDS_SIZE* = 0x2 + XFORMCOORDS_HIMETRICTOCONTAINER* = 0x4 + XFORMCOORDS_CONTAINERTOHIMETRIC* = 0x8 + XFORMCOORDS_EVENTCOMPAT* = 0x10 + IID_IOleControlSite* = DEFINE_GUID("b196b289-bab4-101a-b69c-00aa00341d07") + IID_IPropertyPage* = DEFINE_GUID("b196b28d-bab4-101a-b69c-00aa00341d07") + IID_IPropertyPage2* = DEFINE_GUID("01e44665-24ac-101b-84ed-08002b2ec713") + PROPPAGESTATUS_DIRTY* = 0x1 + PROPPAGESTATUS_VALIDATE* = 0x2 + PROPPAGESTATUS_CLEAN* = 0x4 + IID_IPropertyPageSite* = DEFINE_GUID("b196b28c-bab4-101a-b69c-00aa00341d07") + IID_IPropertyNotifySink* = DEFINE_GUID("9bfbbc02-eff1-101a-84ed-00aa00341d07") + IID_ISpecifyPropertyPages* = DEFINE_GUID("b196b28b-bab4-101a-b69c-00aa00341d07") + IID_IPersistMemory* = DEFINE_GUID("bd1ae5e0-a6ae-11ce-bd37-504200c10000") + IID_IPersistStreamInit* = DEFINE_GUID("7fd52380-4e07-101b-ae2d-08002b2ec713") + IID_IPersistPropertyBag* = DEFINE_GUID("37d84f60-42cb-11ce-8135-00aa004bb851") + IID_ISimpleFrameSite* = DEFINE_GUID("742b0e01-14e6-101b-914e-00aa00300cab") + IID_IFont* = DEFINE_GUID("bef6e002-a874-101a-8bba-00aa00300cab") + PICTURE_SCALABLE* = 0x1 + PICTURE_TRANSPARENT* = 0x2 + IID_IPicture* = DEFINE_GUID("7bf80980-bf32-101a-8bbb-00aa00300cab") + IID_IPicture2* = DEFINE_GUID("f5185dd8-2012-4b0b-aad9-f052c6bd482b") + IID_IFontEventsDisp* = DEFINE_GUID("4ef6100a-af88-11d0-9846-00c04fc29993") + IID_IFontDisp* = DEFINE_GUID("bef6e003-a874-101a-8bba-00aa00300cab") + IID_IPictureDisp* = DEFINE_GUID("7bf80981-bf32-101a-8bbb-00aa00300cab") + IID_IOleInPlaceObjectWindowless* = DEFINE_GUID("1c2056cc-5ef4-101b-8bc8-00aa003e3b29") + ACTIVATE_WINDOWLESS* = 1 + IID_IOleInPlaceSiteEx* = DEFINE_GUID("9c2cad80-3424-11cf-b670-00aa004cd6d8") + OLEDC_NODRAW* = 0x1 + OLEDC_PAINTBKGND* = 0x2 + OLEDC_OFFSCREEN* = 0x4 + IID_IOleInPlaceSiteWindowless* = DEFINE_GUID("922eada0-3424-11cf-b670-00aa004cd6d8") + VIEWSTATUS_OPAQUE* = 1 + VIEWSTATUS_SOLIDBKGND* = 2 + VIEWSTATUS_DVASPECTOPAQUE* = 4 + VIEWSTATUS_DVASPECTTRANSPARENT* = 8 + VIEWSTATUS_SURFACE* = 16 + VIEWSTATUS_3DSURFACE* = 32 + HITRESULT_OUTSIDE* = 0 + HITRESULT_TRANSPARENT* = 1 + HITRESULT_CLOSE* = 2 + HITRESULT_HIT* = 3 + DVASPECT_OPAQUE* = 16 + DVASPECT_TRANSPARENT* = 32 + DVEXTENT_CONTENT* = 0 + DVEXTENT_INTEGRAL* = 1 + DVASPECTINFOFLAG_CANOPTIMIZE* = 1 + IID_IViewObjectEx* = DEFINE_GUID("3af24292-0c96-11ce-a0cf-00aa00600ab8") + IID_IOleUndoUnit* = DEFINE_GUID("894ad3b0-ef97-11ce-9bc9-00aa00608e01") + IID_IOleParentUndoUnit* = DEFINE_GUID("a1faf330-ef97-11ce-9bc9-00aa00608e01") + IID_IEnumOleUndoUnits* = DEFINE_GUID("b3e7c340-ef97-11ce-9bc9-00aa00608e01") + IID_IOleUndoManager* = DEFINE_GUID("d001f200-ef97-11ce-9bc9-00aa00608e01") + SID_SOleUndoManager* = IID_IOleUndoManager + POINTERINACTIVE_ACTIVATEONENTRY* = 1 + POINTERINACTIVE_DEACTIVATEONLEAVE* = 2 + POINTERINACTIVE_ACTIVATEONDRAG* = 4 + IID_IPointerInactive* = DEFINE_GUID("55980ba0-35aa-11cf-b671-00aa004cd6d8") + IID_IObjectWithSite* = DEFINE_GUID("fc4801a3-2ba9-11cf-a229-00aa003d7352") + IID_IPerPropertyBrowsing* = DEFINE_GUID("376bd3aa-3845-101b-84ed-08002b2ec713") + PROPBAG2_TYPE_UNDEFINED* = 0 + PROPBAG2_TYPE_DATA* = 1 + PROPBAG2_TYPE_URL* = 2 + PROPBAG2_TYPE_OBJECT* = 3 + PROPBAG2_TYPE_STREAM* = 4 + PROPBAG2_TYPE_STORAGE* = 5 + PROPBAG2_TYPE_MONIKER* = 6 + IID_IPropertyBag2* = DEFINE_GUID("22f55882-280b-11d0-a8a9-00a0c90c2004") + IID_IPersistPropertyBag2* = DEFINE_GUID("22f55881-280b-11d0-a8a9-00a0c90c2004") + IID_IAdviseSinkEx* = DEFINE_GUID("3af24290-0c96-11ce-a0cf-00aa00600ab8") + QACONTAINER_SHOWHATCHING* = 0x1 + QACONTAINER_SHOWGRABHANDLES* = 0x2 + QACONTAINER_USERMODE* = 0x4 + QACONTAINER_DISPLAYASDEFAULT* = 0x8 + QACONTAINER_UIDEAD* = 0x10 + QACONTAINER_AUTOCLIP* = 0x20 + QACONTAINER_MESSAGEREFLECT* = 0x40 + QACONTAINER_SUPPORTSMNEMONICS* = 0x80 + IID_IQuickActivate* = DEFINE_GUID("cf51ed10-62fe-11cf-bf86-00a0c9034836") + IID_IEnumGUID* = DEFINE_GUID("0002e000-0000-0000-c000-000000000046") + IID_IEnumCLSID* = IID_IEnumGUID + CATID_NULL* = GUID_NULL + IID_IEnumCATID* = IID_IEnumGUID + IID_IEnumCATEGORYINFO* = DEFINE_GUID("0002e011-0000-0000-c000-000000000046") + IID_ICatRegister* = DEFINE_GUID("0002e012-0000-0000-c000-000000000046") + IID_ICatInformation* = DEFINE_GUID("0002e013-0000-0000-c000-000000000046") + STRRET_WSTR* = 0x0 + STRRET_OFFSET* = 0x1 + STRRET_CSTR* = 0x2 + PERCEIVED_TYPE_FIRST* = -3 + PERCEIVED_TYPE_CUSTOM* = -3 + PERCEIVED_TYPE_UNSPECIFIED* = -2 + PERCEIVED_TYPE_FOLDER* = -1 + PERCEIVED_TYPE_UNKNOWN* = 0 + PERCEIVED_TYPE_TEXT* = 1 + PERCEIVED_TYPE_IMAGE* = 2 + PERCEIVED_TYPE_AUDIO* = 3 + PERCEIVED_TYPE_VIDEO* = 4 + PERCEIVED_TYPE_COMPRESSED* = 5 + PERCEIVED_TYPE_DOCUMENT* = 6 + PERCEIVED_TYPE_SYSTEM* = 7 + PERCEIVED_TYPE_APPLICATION* = 8 + PERCEIVED_TYPE_GAMEMEDIA* = 9 + PERCEIVED_TYPE_CONTACTS* = 10 + PERCEIVED_TYPE_LAST* = 10 + PERCEIVEDFLAG_UNDEFINED* = 0x0000 + PERCEIVEDFLAG_SOFTCODED* = 0x0001 + PERCEIVEDFLAG_HARDCODED* = 0x0002 + PERCEIVEDFLAG_NATIVESUPPORT* = 0x0004 + PERCEIVEDFLAG_GDIPLUS* = 0x0010 + PERCEIVEDFLAG_WMSDK* = 0x0020 + PERCEIVEDFLAG_ZIPFOLDER* = 0x0040 + SHCOLSTATE_DEFAULT* = 0x0 + SHCOLSTATE_TYPE_STR* = 0x1 + SHCOLSTATE_TYPE_INT* = 0x2 + SHCOLSTATE_TYPE_DATE* = 0x3 + SHCOLSTATE_TYPEMASK* = 0xf + SHCOLSTATE_ONBYDEFAULT* = 0x10 + SHCOLSTATE_SLOW* = 0x20 + SHCOLSTATE_EXTENDED* = 0x40 + SHCOLSTATE_SECONDARYUI* = 0x80 + SHCOLSTATE_HIDDEN* = 0x100 + SHCOLSTATE_PREFER_VARCMP* = 0x200 + SHCOLSTATE_PREFER_FMTCMP* = 0x400 + SHCOLSTATE_NOSORTBYFOLDERNESS* = 0x800 + SHCOLSTATE_VIEWONLY* = 0x10000 + SHCOLSTATE_BATCHREAD* = 0x20000 + SHCOLSTATE_NO_GROUPBY* = 0x40000 + SHCOLSTATE_FIXED_WIDTH* = 0x1000 + SHCOLSTATE_NODPISCALE* = 0x2000 + SHCOLSTATE_FIXED_RATIO* = 0x4000 + SHCOLSTATE_DISPLAYMASK* = 0xf000 + SCALE_100_PERCENT* = 100 + SCALE_140_PERCENT* = 140 + SCALE_180_PERCENT* = 180 + DOCMISC_CANCREATEMULTIPLEVIEWS* = 1 + DOCMISC_SUPPORTCOMPLEXRECTANGLES* = 2 + DOCMISC_CANTOPENEDIT* = 4 + DOCMISC_NOFILESUPPORT* = 8 + IID_IOleDocument* = DEFINE_GUID("b722bcc5-4e68-101b-a2bc-00aa00404770") + IID_IOleDocumentSite* = DEFINE_GUID("b722bcc7-4e68-101b-a2bc-00aa00404770") + IID_IOleDocumentView* = DEFINE_GUID("b722bcc6-4e68-101b-a2bc-00aa00404770") + IID_IEnumOleDocumentViews* = DEFINE_GUID("b722bcc8-4e68-101b-a2bc-00aa00404770") + IID_IContinueCallback* = DEFINE_GUID("b722bcca-4e68-101b-a2bc-00aa00404770") + PRINTFLAG_MAYBOTHERUSER* = 1 + PRINTFLAG_PROMPTUSER* = 2 + PRINTFLAG_USERMAYCHANGEPRINTER* = 4 + PRINTFLAG_RECOMPOSETODEVICE* = 8 + PRINTFLAG_DONTACTUALLYPRINT* = 16 + PRINTFLAG_FORCEPROPERTIES* = 32 + PRINTFLAG_PRINTTOFILE* = 64 + IID_IPrint* = DEFINE_GUID("b722bcc9-4e68-101b-a2bc-00aa00404770") + OLECMDF_SUPPORTED* = 0x1 + OLECMDF_ENABLED* = 0x2 + OLECMDF_LATCHED* = 0x4 + OLECMDF_NINCHED* = 0x8 + OLECMDF_INVISIBLE* = 0x10 + OLECMDF_DEFHIDEONCTXTMENU* = 0x20 + OLECMDTEXTF_NONE* = 0 + OLECMDTEXTF_NAME* = 1 + OLECMDTEXTF_STATUS* = 2 + OLECMDEXECOPT_DODEFAULT* = 0 + OLECMDEXECOPT_PROMPTUSER* = 1 + OLECMDEXECOPT_DONTPROMPTUSER* = 2 + OLECMDEXECOPT_SHOWHELP* = 3 + OLECMDID_OPEN* = 1 + OLECMDID_NEW* = 2 + OLECMDID_SAVE* = 3 + OLECMDID_SAVEAS* = 4 + OLECMDID_SAVECOPYAS* = 5 + OLECMDID_PRINT* = 6 + OLECMDID_PRINTPREVIEW* = 7 + OLECMDID_PAGESETUP* = 8 + OLECMDID_SPELL* = 9 + OLECMDID_PROPERTIES* = 10 + OLECMDID_CUT* = 11 + OLECMDID_COPY* = 12 + OLECMDID_PASTE* = 13 + OLECMDID_PASTESPECIAL* = 14 + OLECMDID_UNDO* = 15 + OLECMDID_REDO* = 16 + OLECMDID_SELECTALL* = 17 + OLECMDID_CLEARSELECTION* = 18 + OLECMDID_ZOOM* = 19 + OLECMDID_GETZOOMRANGE* = 20 + OLECMDID_UPDATECOMMANDS* = 21 + OLECMDID_REFRESH* = 22 + OLECMDID_STOP* = 23 + OLECMDID_HIDETOOLBARS* = 24 + OLECMDID_SETPROGRESSMAX* = 25 + OLECMDID_SETPROGRESSPOS* = 26 + OLECMDID_SETPROGRESSTEXT* = 27 + OLECMDID_SETTITLE* = 28 + OLECMDID_SETDOWNLOADSTATE* = 29 + OLECMDID_STOPDOWNLOAD* = 30 + OLECMDID_ONTOOLBARACTIVATED* = 31 + OLECMDID_FIND* = 32 + OLECMDID_DELETE* = 33 + OLECMDID_HTTPEQUIV* = 34 + OLECMDID_HTTPEQUIV_DONE* = 35 + OLECMDID_ENABLE_INTERACTION* = 36 + OLECMDID_ONUNLOAD* = 37 + OLECMDID_PROPERTYBAG2* = 38 + OLECMDID_PREREFRESH* = 39 + OLECMDID_SHOWSCRIPTERROR* = 40 + OLECMDID_SHOWMESSAGE* = 41 + OLECMDID_SHOWFIND* = 42 + OLECMDID_SHOWPAGESETUP* = 43 + OLECMDID_SHOWPRINT* = 44 + OLECMDID_CLOSE* = 45 + OLECMDID_ALLOWUILESSSAVEAS* = 46 + OLECMDID_DONTDOWNLOADCSS* = 47 + OLECMDID_UPDATEPAGESTATUS* = 48 + OLECMDID_PRINT2* = 49 + OLECMDID_PRINTPREVIEW2* = 50 + OLECMDID_SETPRINTTEMPLATE* = 51 + OLECMDID_GETPRINTTEMPLATE* = 52 + OLECMDID_PAGEACTIONBLOCKED* = 55 + OLECMDID_PAGEACTIONUIQUERY* = 56 + OLECMDID_FOCUSVIEWCONTROLS* = 57 + OLECMDID_FOCUSVIEWCONTROLSQUERY* = 58 + OLECMDID_SHOWPAGEACTIONMENU* = 59 + OLECMDID_ADDTRAVELENTRY* = 60 + OLECMDID_UPDATETRAVELENTRY* = 61 + OLECMDID_UPDATEBACKFORWARDSTATE* = 62 + OLECMDID_OPTICAL_ZOOM* = 63 + OLECMDID_OPTICAL_GETZOOMRANGE* = 64 + OLECMDID_WINDOWSTATECHANGED* = 65 + OLECMDID_ACTIVEXINSTALLSCOPE* = 66 + OLECMDID_UPDATETRAVELENTRY_DATARECOVERY* = 67 + OLECMDID_SHOWTASKDLG* = 68 + OLECMDID_POPSTATEEVENT* = 69 + OLECMDID_VIEWPORT_MODE* = 70 + OLECMDID_LAYOUT_VIEWPORT_WIDTH* = 71 + OLECMDID_VISUAL_VIEWPORT_EXCLUDE_BOTTOM* = 72 + OLECMDID_USER_OPTICAL_ZOOM* = 73 + OLECMDID_PAGEAVAILABLE* = 74 + OLECMDID_GETUSERSCALABLE* = 75 + OLECMDID_UPDATE_CARET* = 76 + OLECMDID_ENABLE_VISIBILITY* = 77 + OLECMDID_MEDIA_PLAYBACK* = 78 + MEDIAPLAYBACK_RESUME* = 0 + MEDIAPLAYBACK_PAUSE* = 1 + OLECMDERR_E_FIRST* = OLE_E_LAST+1 + OLECMDERR_E_NOTSUPPORTED* = OLECMDERR_E_FIRST + OLECMDERR_E_DISABLED* = OLECMDERR_E_FIRST+1 + OLECMDERR_E_NOHELP* = OLECMDERR_E_FIRST+2 + OLECMDERR_E_CANCELED* = OLECMDERR_E_FIRST+3 + OLECMDERR_E_UNKNOWNGROUP* = OLECMDERR_E_FIRST+4 + MSOCMDERR_E_FIRST* = OLECMDERR_E_FIRST + MSOCMDERR_E_NOTSUPPORTED* = OLECMDERR_E_NOTSUPPORTED + MSOCMDERR_E_DISABLED* = OLECMDERR_E_DISABLED + MSOCMDERR_E_NOHELP* = OLECMDERR_E_NOHELP + MSOCMDERR_E_CANCELED* = OLECMDERR_E_CANCELED + MSOCMDERR_E_UNKNOWNGROUP* = OLECMDERR_E_UNKNOWNGROUP + OLECMD_TASKDLGID_ONBEFOREUNLOAD* = 1 + OLECMDARGINDEX_SHOWPAGEACTIONMENU_HWND* = 0 + OLECMDARGINDEX_SHOWPAGEACTIONMENU_X* = 1 + OLECMDARGINDEX_SHOWPAGEACTIONMENU_Y* = 2 + OLECMDARGINDEX_ACTIVEXINSTALL_PUBLISHER* = 0 + OLECMDARGINDEX_ACTIVEXINSTALL_DISPLAYNAME* = 1 + OLECMDARGINDEX_ACTIVEXINSTALL_CLSID* = 2 + OLECMDARGINDEX_ACTIVEXINSTALL_INSTALLSCOPE* = 3 + OLECMDARGINDEX_ACTIVEXINSTALL_SOURCEURL* = 4 + INSTALL_SCOPE_INVALID* = 0 + INSTALL_SCOPE_MACHINE* = 1 + INSTALL_SCOPE_USER* = 2 + IGNOREMIME_PROMPT* = 0x1 + IGNOREMIME_TEXT* = 0x2 + WPCSETTING_LOGGING_ENABLED* = 0x1 + WPCSETTING_FILEDOWNLOAD_BLOCKED* = 0x2 + IID_IOleCommandTarget* = DEFINE_GUID("b722bccb-4e68-101b-a2bc-00aa00404770") + OLECMDIDF_REFRESH_NORMAL* = 0 + OLECMDIDF_REFRESH_IFEXPIRED* = 1 + OLECMDIDF_REFRESH_CONTINUE* = 2 + OLECMDIDF_REFRESH_COMPLETELY* = 3 + OLECMDIDF_REFRESH_NO_CACHE* = 4 + OLECMDIDF_REFRESH_RELOAD* = 5 + OLECMDIDF_REFRESH_LEVELMASK* = 0x00FF + OLECMDIDF_REFRESH_CLEARUSERINPUT* = 0x1000 + OLECMDIDF_REFRESH_PROMPTIFOFFLINE* = 0x2000 + OLECMDIDF_REFRESH_THROUGHSCRIPT* = 0x4000 + OLECMDIDF_REFRESH_SKIPBEFOREUNLOADEVENT* = 0x8000 + OLECMDIDF_REFRESH_PAGEACTION_ACTIVEXINSTALL* = 0x00010000 + OLECMDIDF_REFRESH_PAGEACTION_FILEDOWNLOAD* = 0x00020000 + OLECMDIDF_REFRESH_PAGEACTION_LOCALMACHINE* = 0x00040000 + OLECMDIDF_REFRESH_PAGEACTION_POPUPWINDOW* = 0x00080000 + OLECMDIDF_REFRESH_PAGEACTION_PROTLOCKDOWNLOCALMACHINE* = 0x00100000 + OLECMDIDF_REFRESH_PAGEACTION_PROTLOCKDOWNTRUSTED* = 0x00200000 + OLECMDIDF_REFRESH_PAGEACTION_PROTLOCKDOWNINTRANET* = 0x00400000 + OLECMDIDF_REFRESH_PAGEACTION_PROTLOCKDOWNINTERNET* = 0x00800000 + OLECMDIDF_REFRESH_PAGEACTION_PROTLOCKDOWNRESTRICTED* = 0x01000000 + OLECMDIDF_REFRESH_PAGEACTION_MIXEDCONTENT* = 0x02000000 + OLECMDIDF_REFRESH_PAGEACTION_INVALID_CERT* = 0x04000000 + OLECMDIDF_PAGEACTION_FILEDOWNLOAD* = 0x00000001 + OLECMDIDF_PAGEACTION_ACTIVEXINSTALL* = 0x00000002 + OLECMDIDF_PAGEACTION_ACTIVEXTRUSTFAIL* = 0x00000004 + OLECMDIDF_PAGEACTION_ACTIVEXUSERDISABLE* = 0x00000008 + OLECMDIDF_PAGEACTION_ACTIVEXDISALLOW* = 0x00000010 + OLECMDIDF_PAGEACTION_ACTIVEXUNSAFE* = 0x00000020 + OLECMDIDF_PAGEACTION_POPUPWINDOW* = 0x00000040 + OLECMDIDF_PAGEACTION_LOCALMACHINE* = 0x00000080 + OLECMDIDF_PAGEACTION_MIMETEXTPLAIN* = 0x00000100 + OLECMDIDF_PAGEACTION_SCRIPTNAVIGATE* = 0x00000200 + OLECMDIDF_PAGEACTION_SCRIPTNAVIGATE_ACTIVEXINSTALL* = 0x00000200 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNLOCALMACHINE* = 0x00000400 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNTRUSTED* = 0x00000800 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNINTRANET* = 0x00001000 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNINTERNET* = 0x00002000 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNRESTRICTED* = 0x00004000 + OLECMDIDF_PAGEACTION_PROTLOCKDOWNDENY* = 0x00008000 + OLECMDIDF_PAGEACTION_POPUPALLOWED* = 0x00010000 + OLECMDIDF_PAGEACTION_SCRIPTPROMPT* = 0x00020000 + OLECMDIDF_PAGEACTION_ACTIVEXUSERAPPROVAL* = 0x00040000 + OLECMDIDF_PAGEACTION_MIXEDCONTENT* = 0x00080000 + OLECMDIDF_PAGEACTION_INVALID_CERT* = 0x00100000 + OLECMDIDF_PAGEACTION_INTRANETZONEREQUEST* = 0x00200000 + OLECMDIDF_PAGEACTION_XSSFILTERED* = 0x00400000 + OLECMDIDF_PAGEACTION_SPOOFABLEIDNHOST* = 0x00800000 + OLECMDIDF_PAGEACTION_ACTIVEX_EPM_INCOMPATIBLE* = 0x01000000 + OLECMDIDF_PAGEACTION_SCRIPTNAVIGATE_ACTIVEXUSERAPPROVAL* = 0x02000000 + OLECMDIDF_PAGEACTION_WPCBLOCKED* = 0x04000000 + OLECMDIDF_PAGEACTION_WPCBLOCKED_ACTIVEX* = 0x08000000 + OLECMDIDF_PAGEACTION_EXTENSION_COMPAT_BLOCKED* = 0x10000000 + OLECMDIDF_PAGEACTION_NORESETACTIVEX* = 0x20000000 + OLECMDIDF_PAGEACTION_GENERIC_STATE* = 0x40000000 + OLECMDIDF_PAGEACTION_RESET* = int32 0x80000000'i32 + OLECMDIDF_BROWSERSTATE_EXTENSIONSOFF* = 0x00000001 + OLECMDIDF_BROWSERSTATE_IESECURITY* = 0x00000002 + OLECMDIDF_BROWSERSTATE_PROTECTEDMODE_OFF* = 0x00000004 + OLECMDIDF_BROWSERSTATE_RESET* = 0x00000008 + OLECMDIDF_BROWSERSTATE_REQUIRESACTIVEX* = 0x00000010 + OLECMDIDF_OPTICAL_ZOOM_NOPERSIST* = 0x00000001 + OLECMDIDF_OPTICAL_ZOOM_NOLAYOUT* = 0x00000010 + PAGEACTION_UI_DEFAULT* = 0 + PAGEACTION_UI_MODAL* = 1 + PAGEACTION_UI_MODELESS* = 2 + PAGEACTION_UI_SILENT* = 3 + OLECMDIDF_WINDOWSTATE_USERVISIBLE* = 0x00000001 + OLECMDIDF_WINDOWSTATE_ENABLED* = 0x00000002 + OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID* = 0x00010000 + OLECMDIDF_WINDOWSTATE_ENABLED_VALID* = 0x00020000 + OLECMDIDF_VIEWPORTMODE_FIXED_LAYOUT_WIDTH* = 0x00000001 + OLECMDIDF_VIEWPORTMODE_EXCLUDE_VISUAL_BOTTOM* = 0x00000002 + OLECMDIDF_VIEWPORTMODE_FIXED_LAYOUT_WIDTH_VALID* = 0x00010000 + OLECMDIDF_VIEWPORTMODE_EXCLUDE_VISUAL_BOTTOM_VALID* = 0x00020000 + IID_IMsoDocument* = IID_IOleDocument + IID_IMsoDocumentSite* = IID_IOleDocumentSite + IID_IMsoView* = IID_IOleDocumentView + IID_IEnumMsoView* = IID_IEnumOleDocumentViews + IID_IMsoCommandTarget* = IID_IOleCommandTarget + MSOCMDF_SUPPORTED* = OLECMDF_SUPPORTED + MSOCMDF_ENABLED* = OLECMDF_ENABLED + MSOCMDF_LATCHED* = OLECMDF_LATCHED + MSOCMDF_NINCHED* = OLECMDF_NINCHED + MSOCMDTEXTF_NONE* = OLECMDTEXTF_NONE + MSOCMDTEXTF_NAME* = OLECMDTEXTF_NAME + MSOCMDTEXTF_STATUS* = OLECMDTEXTF_STATUS + MSOCMDEXECOPT_DODEFAULT* = OLECMDEXECOPT_DODEFAULT + MSOCMDEXECOPT_PROMPTUSER* = OLECMDEXECOPT_PROMPTUSER + MSOCMDEXECOPT_DONTPROMPTUSER* = OLECMDEXECOPT_DONTPROMPTUSER + MSOCMDEXECOPT_SHOWHELP* = OLECMDEXECOPT_SHOWHELP + MSOCMDID_OPEN* = OLECMDID_OPEN + MSOCMDID_NEW* = OLECMDID_NEW + MSOCMDID_SAVE* = OLECMDID_SAVE + MSOCMDID_SAVEAS* = OLECMDID_SAVEAS + MSOCMDID_SAVECOPYAS* = OLECMDID_SAVECOPYAS + MSOCMDID_PRINT* = OLECMDID_PRINT + MSOCMDID_PRINTPREVIEW* = OLECMDID_PRINTPREVIEW + MSOCMDID_PAGESETUP* = OLECMDID_PAGESETUP + MSOCMDID_SPELL* = OLECMDID_SPELL + MSOCMDID_PROPERTIES* = OLECMDID_PROPERTIES + MSOCMDID_CUT* = OLECMDID_CUT + MSOCMDID_COPY* = OLECMDID_COPY + MSOCMDID_PASTE* = OLECMDID_PASTE + MSOCMDID_PASTESPECIAL* = OLECMDID_PASTESPECIAL + MSOCMDID_UNDO* = OLECMDID_UNDO + MSOCMDID_REDO* = OLECMDID_REDO + MSOCMDID_SELECTALL* = OLECMDID_SELECTALL + MSOCMDID_CLEARSELECTION* = OLECMDID_CLEARSELECTION + MSOCMDID_ZOOM* = OLECMDID_ZOOM + MSOCMDID_GETZOOMRANGE* = OLECMDID_GETZOOMRANGE + IID_IZoomEvents* = DEFINE_GUID("41b68150-904c-4e17-a0ba-a438182e359d") + IID_IProtectFocus* = DEFINE_GUID("d81f90a3-8156-44f7-ad28-5abb87003274") + SID_SProtectFocus* = IID_IProtectFocus + IID_IProtectedModeMenuServices* = DEFINE_GUID("73c105ee-9dff-4a07-b83c-7eff290c266e") + LIBID_SHDocVw* = DEFINE_GUID("eab22ac0-30c1-11cf-a7eb-0000c05bae0b") + navOpenInNewWindow* = 0x1 + navNoHistory* = 0x2 + navNoReadFromCache* = 0x4 + navNoWriteToCache* = 0x8 + navAllowAutosearch* = 0x10 + navBrowserBar* = 0x20 + navHyperlink* = 0x40 + navEnforceRestricted* = 0x80 + REFRESH_NORMAL* = 0 + REFRESH_IFEXPIRED* = 1 + REFRESH_COMPLETELY* = 3 + IID_IWebBrowser* = DEFINE_GUID("eab22ac1-30c1-11cf-a7eb-0000c05bae0b") + DIID_DWebBrowserEvents* = DEFINE_GUID("eab22ac2-30c1-11cf-a7eb-0000c05bae0b") + IID_DWebBrowserEvents* = DEFINE_GUID("eab22ac2-30c1-11cf-a7eb-0000c05bae0b") + CSC_UPDATECOMMANDS* = -1 + CSC_NAVIGATEFORWARD* = 1 + CSC_NAVIGATEBACK* = 2 + IID_IWebBrowserApp* = DEFINE_GUID("0002df05-0000-0000-c000-000000000046") + IID_IWebBrowser2* = DEFINE_GUID("d30c1661-cdaf-11d0-8a3e-00c04fc9e26e") + secureLockIconUnsecure* = 0 + secureLockIconMixed* = 1 + secureLockIconSecureUnknownBits* = 2 + secureLockIconSecure40Bit* = 3 + secureLockIconSecure56Bit* = 4 + secureLockIconSecureFortezza* = 5 + secureLockIconSecure128Bit* = 6 + DIID_DWebBrowserEvents2* = DEFINE_GUID("34a715a0-6587-11d0-924a-0020afc7ac4d") + IID_DWebBrowserEvents2* = DEFINE_GUID("34a715a0-6587-11d0-924a-0020afc7ac4d") + CLSID_WebBrowser_V1* = DEFINE_GUID("eab22ac3-30c1-11cf-a7eb-0000c05bae0b") + CLSID_WebBrowser* = DEFINE_GUID("8856f961-340a-11d0-a96b-00c04fd705a2") + CLSID_InternetExplorer* = DEFINE_GUID("0002df01-0000-0000-c000-000000000046") + CLSID_ShellBrowserWindow* = DEFINE_GUID("c08afd90-f2a1-11d1-8455-00a0c91f3880") + SWC_EXPLORER* = 0 + SWC_BROWSER* = 1 + SWC_3RDPARTY* = 2 + SWC_CALLBACK* = 4 + SWC_DESKTOP* = 8 + SWFO_NEEDDISPATCH* = 1 + SWFO_INCLUDEPENDING* = 2 + SWFO_COOKIEPASSED* = 4 + DIID_DShellWindowsEvents* = DEFINE_GUID("fe4106e0-399a-11d0-a48c-00a0c90a8f39") + IID_DShellWindowsEvents* = DEFINE_GUID("fe4106e0-399a-11d0-a48c-00a0c90a8f39") + IID_IShellWindows* = DEFINE_GUID("85cb6900-4d95-11cf-960c-0080c7f4ee85") + CLSID_ShellWindows* = DEFINE_GUID("9ba05972-f6a8-11cf-a442-00a0c90a8f39") + IID_IShellUIHelper* = DEFINE_GUID("729fe2f8-1ea8-11d1-8f85-00c04fc2fbe1") + IID_IShellUIHelper2* = DEFINE_GUID("a7fe6eda-1932-4281-b881-87b31b8bc52c") + CLSID_ShellUIHelper* = DEFINE_GUID("64ab4bb7-111e-11d1-8f79-00c04fc2fbe1") + DIID_DShellNameSpaceEvents* = DEFINE_GUID("55136806-b2de-11d1-b9f2-00a0c98bc547") + IID_DShellNameSpaceEvents* = DEFINE_GUID("55136806-b2de-11d1-b9f2-00a0c98bc547") + IID_IShellFavoritesNameSpace* = DEFINE_GUID("55136804-b2de-11d1-b9f2-00a0c98bc547") + IID_IShellNameSpace* = DEFINE_GUID("e572d3c9-37be-4ae2-825d-d521763e3108") + CLSID_ShellShellNameSpace* = DEFINE_GUID("2f2f1f96-2bc1-4b1c-be28-ea3774f4676a") + CLSID_ShellNameSpace* = DEFINE_GUID("55136805-b2de-11d1-b9f2-00a0c98bc547") + IID_IScriptErrorList* = DEFINE_GUID("f3470f24-15fd-11d2-bb2e-00805ff7efca") + CLSID_CScriptErrorList* = DEFINE_GUID("efd01300-160f-11d2-bb2e-00805ff7efca") + IID_ISearch* = DEFINE_GUID("ba9239a4-3dd5-11d2-bf8b-00c04fb93661") + IID_ISearches* = DEFINE_GUID("47c922a2-3dd5-11d2-bf8b-00c04fb93661") + IID_ISearchAssistantOC* = DEFINE_GUID("72423e8f-8011-11d2-be79-00a0c9a83da1") + IID_ISearchAssistantOC2* = DEFINE_GUID("72423e8f-8011-11d2-be79-00a0c9a83da2") + IID_ISearchAssistantOC3* = DEFINE_GUID("72423e8f-8011-11d2-be79-00a0c9a83da3") + DIID_SearchAssistantEvents* = DEFINE_GUID("1611fdda-445b-11d2-85de-00c04fa35c89") + IID_SearchAssistantEvents* = DEFINE_GUID("1611fdda-445b-11d2-85de-00c04fa35c89") + CLSID_ShellSearchAssistantOC* = DEFINE_GUID("2e71fd0f-aab1-42c0-9146-6d2c4edcf07d") + CLSID_SearchAssistantOC* = DEFINE_GUID("b45ff030-4447-11d2-85de-00c04fa35c89") + DISPID_BEFORENAVIGATE* = 100 + DISPID_NAVIGATECOMPLETE* = 101 + DISPID_STATUSTEXTCHANGE* = 102 + DISPID_QUIT* = 103 + DISPID_DOWNLOADCOMPLETE* = 104 + DISPID_COMMANDSTATECHANGE* = 105 + DISPID_DOWNLOADBEGIN* = 106 + DISPID_NEWWINDOW* = 107 + DISPID_PROGRESSCHANGE* = 108 + DISPID_WINDOWMOVE* = 109 + DISPID_WINDOWRESIZE* = 110 + DISPID_WINDOWACTIVATE* = 111 + DISPID_PROPERTYCHANGE* = 112 + DISPID_TITLECHANGE* = 113 + DISPID_TITLEICONCHANGE* = 114 + DISPID_FRAMEBEFORENAVIGATE* = 200 + DISPID_FRAMENAVIGATECOMPLETE* = 201 + DISPID_FRAMENEWWINDOW* = 204 + DISPID_BEFORENAVIGATE2* = 250 + DISPID_NEWWINDOW2* = 251 + DISPID_NAVIGATECOMPLETE2* = 252 + DISPID_ONQUIT* = 253 + DISPID_ONVISIBLE* = 254 + DISPID_ONTOOLBAR* = 255 + DISPID_ONMENUBAR* = 256 + DISPID_ONSTATUSBAR* = 257 + DISPID_ONFULLSCREEN* = 258 + DISPID_DOCUMENTCOMPLETE* = 259 + DISPID_ONTHEATERMODE* = 260 + DISPID_ONADDRESSBAR* = 261 + DISPID_WINDOWSETRESIZABLE* = 262 + DISPID_WINDOWCLOSING* = 263 + DISPID_WINDOWSETLEFT* = 264 + DISPID_WINDOWSETTOP* = 265 + DISPID_WINDOWSETWIDTH* = 266 + DISPID_WINDOWSETHEIGHT* = 267 + DISPID_CLIENTTOHOSTWINDOW* = 268 + DISPID_SETSECURELOCKICON* = 269 + DISPID_FILEDOWNLOAD* = 270 + DISPID_NAVIGATEERROR* = 271 + DISPID_PRIVACYIMPACTEDSTATECHANGE* = 272 + DISPID_NEWWINDOW3* = 273 + DISPID_VIEWUPDATE* = 281 + DISPID_SETPHISHINGFILTERSTATUS* = 282 + DISPID_WINDOWSTATECHANGED* = 283 + DISPID_NEWPROCESS* = 284 + DISPID_THIRDPARTYURLBLOCKED* = 285 + DISPID_REDIRECTXDOMAINBLOCKED* = 286 + DISPID_PRINTTEMPLATEINSTANTIATION* = 225 + DISPID_PRINTTEMPLATETEARDOWN* = 226 + DISPID_UPDATEPAGESTATUS* = 227 + DISPID_WINDOWREGISTERED* = 200 + DISPID_WINDOWREVOKED* = 201 + DISPID_RESETFIRSTBOOTMODE* = 1 + DISPID_RESETSAFEMODE* = 2 + DISPID_REFRESHOFFLINEDESKTOP* = 3 + DISPID_ADDFAVORITE* = 4 + DISPID_ADDCHANNEL* = 5 + DISPID_ADDDESKTOPCOMPONENT* = 6 + DISPID_ISSUBSCRIBED* = 7 + DISPID_NAVIGATEANDFIND* = 8 + DISPID_IMPORTEXPORTFAVORITES* = 9 + DISPID_AUTOCOMPLETESAVEFORM* = 10 + DISPID_AUTOSCAN* = 11 + DISPID_AUTOCOMPLETEATTACH* = 12 + DISPID_SHOWBROWSERUI* = 13 + DISPID_ADDSEARCHPROVIDER* = 14 + DISPID_RUNONCESHOWN* = 15 + DISPID_SKIPRUNONCE* = 16 + DISPID_CUSTOMIZESETTINGS* = 17 + DISPID_SQMENABLED* = 18 + DISPID_PHISHINGENABLED* = 19 + DISPID_BRANDIMAGEURI* = 20 + DISPID_SKIPTABSWELCOME* = 21 + DISPID_DIAGNOSECONNECTION* = 22 + DISPID_CUSTOMIZECLEARTYPE* = 23 + DISPID_ISSEARCHPROVIDERINSTALLED* = 24 + DISPID_ISSEARCHMIGRATED* = 25 + DISPID_DEFAULTSEARCHPROVIDER* = 26 + DISPID_RUNONCEREQUIREDSETTINGSCOMPLETE* = 27 + DISPID_RUNONCEHASSHOWN* = 28 + DISPID_SEARCHGUIDEURL* = 29 + DISPID_ADDSERVICE* = 30 + DISPID_ISSERVICEINSTALLED* = 31 + DISPID_ADDTOFAVORITESBAR* = 32 + DISPID_BUILDNEWTABPAGE* = 33 + DISPID_SETRECENTLYCLOSEDVISIBLE* = 34 + DISPID_SETACTIVITIESVISIBLE* = 35 + DISPID_CONTENTDISCOVERYRESET* = 36 + DISPID_INPRIVATEFILTERINGENABLED* = 37 + DISPID_SUGGESTEDSITESENABLED* = 38 + DISPID_ENABLESUGGESTEDSITES* = 39 + DISPID_NAVIGATETOSUGGESTEDSITES* = 40 + DISPID_SHOWTABSHELP* = 41 + DISPID_SHOWINPRIVATEHELP* = 42 + DISPID_SHELLUIHELPERLAST* = 43 + DISPID_ADVANCEERROR* = 10 + DISPID_RETREATERROR* = 11 + DISPID_CANADVANCEERROR* = 12 + DISPID_CANRETREATERROR* = 13 + DISPID_GETERRORLINE* = 14 + DISPID_GETERRORCHAR* = 15 + DISPID_GETERRORCODE* = 16 + DISPID_GETERRORMSG* = 17 + DISPID_GETERRORURL* = 18 + DISPID_GETDETAILSSTATE* = 19 + DISPID_SETDETAILSSTATE* = 20 + DISPID_GETPERERRSTATE* = 21 + DISPID_SETPERERRSTATE* = 22 + DISPID_GETALWAYSSHOWLOCKSTATE* = 23 + DISPID_FAVSELECTIONCHANGE* = 1 + DISPID_SELECTIONCHANGE* = 2 + DISPID_DOUBLECLICK* = 3 + DISPID_INITIALIZED* = 4 + DISPID_MOVESELECTIONUP* = 1 + DISPID_MOVESELECTIONDOWN* = 2 + DISPID_RESETSORT* = 3 + DISPID_NEWFOLDER* = 4 + DISPID_SYNCHRONIZE* = 5 + DISPID_IMPORT* = 6 + DISPID_EXPORT* = 7 + DISPID_INVOKECONTEXTMENU* = 8 + DISPID_MOVESELECTIONTO* = 9 + DISPID_SUBSCRIPTIONSENABLED* = 10 + DISPID_CREATESUBSCRIPTION* = 11 + DISPID_DELETESUBSCRIPTION* = 12 + DISPID_SETROOT* = 13 + DISPID_ENUMOPTIONS* = 14 + DISPID_SELECTEDITEM* = 15 + DISPID_ROOT* = 16 + DISPID_DEPTH* = 17 + DISPID_MODE* = 18 + DISPID_FLAGS* = 19 + DISPID_TVFLAGS* = 20 + DISPID_NSCOLUMNS* = 21 + DISPID_COUNTVIEWTYPES* = 22 + DISPID_SETVIEWTYPE* = 23 + DISPID_SELECTEDITEMS* = 24 + DISPID_EXPAND* = 25 + DISPID_UNSELECTALL* = 26 + CT_AND_CONDITION* = 0 + CT_OR_CONDITION* = 1 + CT_NOT_CONDITION* = 2 + CT_LEAF_CONDITION* = 3 + COP_IMPLICIT* = 0 + COP_EQUAL* = 1 + COP_NOTEQUAL* = 2 + COP_LESSTHAN* = 3 + COP_GREATERTHAN* = 4 + COP_LESSTHANOREQUAL* = 5 + COP_GREATERTHANOREQUAL* = 6 + COP_VALUE_STARTSWITH* = 7 + COP_VALUE_ENDSWITH* = 8 + COP_VALUE_CONTAINS* = 9 + COP_VALUE_NOTCONTAINS* = 10 + COP_DOSWILDCARDS* = 11 + COP_WORD_EQUAL* = 12 + COP_WORD_STARTSWITH* = 13 + COP_APPLICATION_SPECIFIC* = 14 + IID_IRichChunk* = DEFINE_GUID("4fdef69c-dbc9-454e-9910-b34f3c64b510") + IID_ICondition* = DEFINE_GUID("0fc988d4-c935-4b97-a973-46282ea175c8") + IID_ICondition2* = DEFINE_GUID("0db8851d-2e5b-47eb-9208-d28c325a01d7") + IID_IInitializeWithFile* = DEFINE_GUID("b7d14566-0509-4cce-a71f-0a554233bd9b") + IID_IInitializeWithStream* = DEFINE_GUID("b824b49d-22ac-4161-ac8a-9916e8fa3f7f") + IID_IPropertyStore* = DEFINE_GUID("886d8eeb-8cf2-4446-8d02-cdba1dbdcf99") + IID_INamedPropertyStore* = DEFINE_GUID("71604b0f-97b0-4764-8577-2f13e98a1422") + GPS_DEFAULT* = 0x0 + GPS_HANDLERPROPERTIESONLY* = 0x1 + GPS_READWRITE* = 0x2 + GPS_TEMPORARY* = 0x4 + GPS_FASTPROPERTIESONLY* = 0x8 + GPS_OPENSLOWITEM* = 0x10 + GPS_DELAYCREATION* = 0x20 + GPS_BESTEFFORT* = 0x40 + GPS_NO_OPLOCK* = 0x80 + GPS_PREFERQUERYPROPERTIES* = 0x100 + GPS_MASK_VALID* = 0x1ff + IID_IObjectWithPropertyKey* = DEFINE_GUID("fc0ca0a7-c316-4fd2-9031-3e628e6d4f23") + PKA_SET* = 0 + PKA_APPEND* = 1 + PKA_DELETE* = 2 + IID_IPropertyChange* = DEFINE_GUID("f917bc8a-1bba-4478-a245-1bde03eb9431") + IID_IPropertyChangeArray* = DEFINE_GUID("380f5cad-1b5e-42f2-805d-637fd392d31e") + IID_IPropertyStoreCapabilities* = DEFINE_GUID("c8e2d566-186e-4d49-bf41-6909ead56acc") + PSC_NORMAL* = 0 + PSC_NOTINSOURCE* = 1 + PSC_DIRTY* = 2 + PSC_READONLY* = 3 + IID_IPropertyStoreCache* = DEFINE_GUID("3017056d-9a91-4e90-937d-746c72abbf4f") + PET_DISCRETEVALUE* = 0 + PET_RANGEDVALUE* = 1 + PET_DEFAULTVALUE* = 2 + PET_ENDRANGE* = 3 + IID_IPropertyEnumType* = DEFINE_GUID("11e1fbf9-2d56-4a6b-8db3-7cd193a471f2") + IID_IPropertyEnumType2* = DEFINE_GUID("9b6e051c-5ddd-4321-9070-fe2acb55e794") + IID_IPropertyEnumTypeList* = DEFINE_GUID("a99400f4-3d84-4557-94ba-1242fb2cc9a6") + PDTF_DEFAULT* = 0x0 + PDTF_MULTIPLEVALUES* = 0x1 + PDTF_ISINNATE* = 0x2 + PDTF_ISGROUP* = 0x4 + PDTF_CANGROUPBY* = 0x8 + PDTF_CANSTACKBY* = 0x10 + PDTF_ISTREEPROPERTY* = 0x20 + PDTF_INCLUDEINFULLTEXTQUERY* = 0x40 + PDTF_ISVIEWABLE* = 0x80 + PDTF_ISQUERYABLE* = 0x100 + PDTF_CANBEPURGED* = 0x200 + PDTF_SEARCHRAWVALUE* = 0x400 + PDTF_ISSYSTEMPROPERTY* = 0x80000000'i32 + PDTF_MASK_ALL* = 0x800007ff'i32 + PDVF_DEFAULT* = 0x0 + PDVF_CENTERALIGN* = 0x1 + PDVF_RIGHTALIGN* = 0x2 + PDVF_BEGINNEWGROUP* = 0x4 + PDVF_FILLAREA* = 0x8 + PDVF_SORTDESCENDING* = 0x10 + PDVF_SHOWONLYIFPRESENT* = 0x20 + PDVF_SHOWBYDEFAULT* = 0x40 + PDVF_SHOWINPRIMARYLIST* = 0x80 + PDVF_SHOWINSECONDARYLIST* = 0x100 + PDVF_HIDELABEL* = 0x200 + PDVF_HIDDEN* = 0x800 + PDVF_CANWRAP* = 0x1000 + PDVF_MASK_ALL* = 0x1bff + PDDT_STRING* = 0 + PDDT_NUMBER* = 1 + PDDT_BOOLEAN* = 2 + PDDT_DATETIME* = 3 + PDDT_ENUMERATED* = 4 + PDGR_DISCRETE* = 0 + PDGR_ALPHANUMERIC* = 1 + PDGR_SIZE* = 2 + PDGR_DYNAMIC* = 3 + PDGR_DATE* = 4 + PDGR_PERCENT* = 5 + PDGR_ENUMERATED* = 6 + PDFF_DEFAULT* = 0x0 + PDFF_PREFIXNAME* = 0x1 + PDFF_FILENAME* = 0x2 + PDFF_ALWAYSKB* = 0x4 + PDFF_RESERVED_RIGHTTOLEFT* = 0x8 + PDFF_SHORTTIME* = 0x10 + PDFF_LONGTIME* = 0x20 + PDFF_HIDETIME* = 0x40 + PDFF_SHORTDATE* = 0x80 + PDFF_LONGDATE* = 0x100 + PDFF_HIDEDATE* = 0x200 + PDFF_RELATIVEDATE* = 0x400 + PDFF_USEEDITINVITATION* = 0x800 + PDFF_READONLY* = 0x1000 + PDFF_NOAUTOREADINGORDER* = 0x2000 + PDSD_GENERAL* = 0 + PDSD_A_Z* = 1 + PDSD_LOWEST_HIGHEST* = 2 + PDSD_SMALLEST_BIGGEST* = 3 + PDSD_OLDEST_NEWEST* = 4 + PDRDT_GENERAL* = 0 + PDRDT_DATE* = 1 + PDRDT_SIZE* = 2 + PDRDT_COUNT* = 3 + PDRDT_REVISION* = 4 + PDRDT_LENGTH* = 5 + PDRDT_DURATION* = 6 + PDRDT_SPEED* = 7 + PDRDT_RATE* = 8 + PDRDT_RATING* = 9 + PDRDT_PRIORITY* = 10 + PDAT_DEFAULT* = 0 + PDAT_FIRST* = 1 + PDAT_SUM* = 2 + PDAT_AVERAGE* = 3 + PDAT_DATERANGE* = 4 + PDAT_UNION* = 5 + PDAT_MAX* = 6 + PDAT_MIN* = 7 + PDCOT_NONE* = 0 + PDCOT_STRING* = 1 + PDCOT_SIZE* = 2 + PDCOT_DATETIME* = 3 + PDCOT_BOOLEAN* = 4 + PDCOT_NUMBER* = 5 + IID_IPropertyDescription* = DEFINE_GUID("6f79d558-3e96-4549-a1d1-7d75d2288814") + IID_IPropertyDescription2* = DEFINE_GUID("57d2eded-5062-400e-b107-5dae79fe57a6") + IID_IPropertyDescriptionAliasInfo* = DEFINE_GUID("f67104fc-2af9-46fd-b32d-243c1404f3d1") + PDSIF_DEFAULT* = 0x0 + PDSIF_ININVERTEDINDEX* = 0x1 + PDSIF_ISCOLUMN* = 0x2 + PDSIF_ISCOLUMNSPARSE* = 0x4 + PDSIF_ALWAYSINCLUDE* = 0x8 + PDSIF_USEFORTYPEAHEAD* = 0x10 + PDCIT_NONE* = 0 + PDCIT_ONDISK* = 1 + PDCIT_INMEMORY* = 2 + PDCIT_ONDEMAND* = 3 + PDCIT_ONDISKALL* = 4 + PDCIT_ONDISKVECTOR* = 5 + IID_IPropertyDescriptionSearchInfo* = DEFINE_GUID("078f91bd-29a2-440f-924e-46a291524520") + IID_IPropertyDescriptionRelatedPropertyInfo* = DEFINE_GUID("507393f4-2a3d-4a60-b59e-d9c75716c2dd") + PDEF_ALL* = 0 + PDEF_SYSTEM* = 1 + PDEF_NONSYSTEM* = 2 + PDEF_VIEWABLE* = 3 + PDEF_QUERYABLE* = 4 + PDEF_INFULLTEXTQUERY* = 5 + PDEF_COLUMN* = 6 + IID_IPropertySystem* = DEFINE_GUID("ca724e8a-c3e6-442b-88a4-6fb0db8035a3") + IID_IPropertyDescriptionList* = DEFINE_GUID("1f9fc1d0-c39b-4b26-817f-011967d3440e") + IID_IPropertyStoreFactory* = DEFINE_GUID("bc110b6d-57e8-4148-a9c6-91015ab2f3a5") + IID_IDelayedPropertyStoreFactory* = DEFINE_GUID("40d4577f-e237-4bdb-bd69-58f089431b6a") + FPSPS_DEFAULT* = 0x0 + FPSPS_READONLY* = 0x1 + FPSPS_TREAT_NEW_VALUES_AS_DIRTY* = 0x2 + IID_IPersistSerializedPropStorage* = DEFINE_GUID("e318ad57-0aa0-450f-aca5-6fab7103d917") + IID_IPersistSerializedPropStorage2* = DEFINE_GUID("77effa68-4f98-4366-ba72-573b3d880571") + IID_IPropertySystemChangeNotify* = DEFINE_GUID("fa955fd9-38be-4879-a6ce-824cf52d609f") + IID_ICreateObject* = DEFINE_GUID("75121952-e0d0-43e5-9380-1d80483acf72") + PKEY_PIDSTR_MAX* = 10 + GUIDSTRING_MAX* = 39 + PKEYSTR_MAX* = GUIDSTRING_MAX+1+PKEY_PIDSTR_MAX + LIBID_PropSysObjects* = DEFINE_GUID("2cda3294-6c4f-4020-b161-27c530c81fa6") + CLSID_InMemoryPropertyStore* = DEFINE_GUID("9a02e012-6303-4e1e-b9a1-630f802592c5") + CLSID_PropertySystem* = DEFINE_GUID("b8967f85-58ae-4f46-9fb2-5d7904798f4b") + COLE_DEFAULT_PRINCIPAL* = cast[ptr OLECHAR](-1) + COLE_DEFAULT_AUTHINFO* = cast[pointer](-1) + UPDFCACHE_ALL* = DWORD(not UPDFCACHE_ONLYIFBLANK) + UPDFCACHE_ALLBUTNODATACACHE* = UPDFCACHE_ALL and (DWORD)(not UPDFCACHE_NODATACACHE) + INVALID_P_ROOT_SECURITY_ID* = cast[ptr BYTE](-1) + SZ_URLCONTEXT* = "URL Context" + SZ_ASYNC_CALLEE* = "AsyncCallee" + CLSID_DOMDocument* = DEFINE_GUID("2933bf90-7b36-11d2-b20e-00c04f983e60") + CLSID_DOMFreeThreadedDocument* = DEFINE_GUID("2933bf91-7b36-11d2-b20e-00c04f983e60") + CLSID_XMLHTTPRequest* = DEFINE_GUID("ed8c108e-4349-11d2-91a4-00c04f7969e8") + DIID_XMLDOMDocumentEvents* = DEFINE_GUID("3efaa427-272f-11d2-836f-0000f87a7782") + IID_IXMLDOMAttribute* = DEFINE_GUID("2933bf85-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMCharacterData* = DEFINE_GUID("2933bf84-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMCDATASection* = DEFINE_GUID("2933bf8a-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMComment* = DEFINE_GUID("2933bf88-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMDocument* = DEFINE_GUID("2933bf81-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMDocumentFragment* = DEFINE_GUID("3efaa413-272f-11d2-836f-0000f87a7782") + IID_IXMLDOMDocumentType* = DEFINE_GUID("2933bf8b-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMElement* = DEFINE_GUID("2933bf86-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMEntity* = DEFINE_GUID("2933bf8d-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMEntityReference* = DEFINE_GUID("2933bf8e-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMImplementation* = DEFINE_GUID("2933bf8e-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMNamedNodeMap* = DEFINE_GUID("2933bf83-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMNode* = DEFINE_GUID("2933bf80-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMNodeList* = DEFINE_GUID("2933bf82-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMNotation* = DEFINE_GUID("2933bf8c-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMParseError* = DEFINE_GUID("3efaa426-272f-11d2-836f-0000f87a7782") + IID_IXMLDOMProcessingInstruction* = DEFINE_GUID("2933bf89-7b36-11d2-b20e-00c04f983e60") + IID_IXMLDOMText* = DEFINE_GUID("2933bf87-7b36-11d2-b20e-00c04f983e60") + IID_IXMLHttpRequest* = DEFINE_GUID("ed8c108d-4349-11d2-91a4-00c04f7969e8") + IID_IXTLRuntime* = DEFINE_GUID("3efaa425-272f-11d2-836f-0000f87a7782") + PAGESET_TOLASTPAGE* = not WORD(0) +type + LPFNGETCLASSOBJECT* = proc (P1: REFCLSID, P2: REFIID, P3: ptr LPVOID): HRESULT {.stdcall.} + LPFNCANUNLOADNOW* = proc (): HRESULT {.stdcall.} + RemHGLOBAL* {.pure.} = object + fNullHGlobal*: LONG + cbData*: ULONG + data*: array[1, uint8] + RemHMETAFILEPICT* {.pure.} = object + mm*: LONG + xExt*: LONG + yExt*: LONG + cbData*: ULONG + data*: array[1, uint8] + RemHENHMETAFILE* {.pure.} = object + cbData*: ULONG + data*: array[1, uint8] + RemHBITMAP* {.pure.} = object + cbData*: ULONG + data*: array[1, uint8] + RemHPALETTE* {.pure.} = object + cbData*: ULONG + data*: array[1, uint8] + RemHBRUSH* {.pure.} = object + cbData*: ULONG + data*: array[1, uint8] + GDI_NONREMOTE_u* {.pure, union.} = object + hInproc*: LONG + hRemote*: ptr DWORD_BLOB + GDI_NONREMOTE* {.pure.} = object + fContext*: LONG + u*: GDI_NONREMOTE_u + CSPLATFORM* {.pure.} = object + dwPlatformId*: DWORD + dwVersionHi*: DWORD + dwVersionLo*: DWORD + dwProcessorArch*: DWORD + QUERYCONTEXT* {.pure.} = object + dwContext*: DWORD + Platform*: CSPLATFORM + Locale*: LCID + dwVersionHi*: DWORD + dwVersionLo*: DWORD + uCLSSPEC_tagged_union_ByName* {.pure.} = object + pPackageName*: LPOLESTR + PolicyId*: GUID + uCLSSPEC_tagged_union_ByObjectId* {.pure.} = object + ObjectId*: GUID + PolicyId*: GUID + uCLSSPEC_tagged_union* {.pure, union.} = object + clsid*: CLSID + pFileExt*: LPOLESTR + pMimeType*: LPOLESTR + pProgId*: LPOLESTR + pFileName*: LPOLESTR + ByName*: uCLSSPEC_tagged_union_ByName + ByObjectId*: uCLSSPEC_tagged_union_ByObjectId + uCLSSPEC* {.pure.} = object + tyspec*: DWORD + tagged_union*: uCLSSPEC_tagged_union + SChannelHookCallInfo* {.pure.} = object + iid*: IID + cbSize*: DWORD + uCausality*: GUID + dwServerPid*: DWORD + iMethod*: DWORD + pObject*: pointer + RemSTGMEDIUM* {.pure.} = object + tymed*: DWORD + dwHandleType*: DWORD + pData*: ULONG + pUnkForRelease*: ULONG + cbData*: ULONG + data*: array[1, uint8] + FLAG_STGMEDIUM* {.pure.} = object + ContextFlags*: LONG + fPassOwnership*: LONG + Stgmed*: STGMEDIUM + StorageLayout* {.pure.} = object + LayoutType*: DWORD + pwcsElementName*: ptr OLECHAR + cOffset*: LARGE_INTEGER + cBytes*: LARGE_INTEGER + CLEANLOCALSTORAGE* {.pure.} = object + pInterface*: ptr IUnknown + pStorage*: PVOID + flags*: DWORD + NUMPARSE* {.pure.} = object + cDig*: INT + dwInFlags*: ULONG + dwOutFlags*: ULONG + cchUsed*: INT + nBaseShift*: INT + nPwr10*: INT + UDATE* {.pure.} = object + st*: SYSTEMTIME + wDayOfYear*: USHORT + STGOPTIONS* {.pure.} = object + usVersion*: USHORT + reserved*: USHORT + ulSectorSize*: ULONG + pwcsTemplateFile*: ptr WCHAR + XML_ERROR* {.pure.} = object + nLine*: int32 + pchBuf*: BSTR + cchBuf*: int32 + ich*: int32 + pszFound*: BSTR + pszExpected*: BSTR + reserved1*: DWORD + reserved2*: DWORD + RemBINDINFO* {.pure.} = object + cbSize*: ULONG + szExtraInfo*: LPWSTR + grfBindInfoF*: DWORD + dwBindVerb*: DWORD + szCustomVerb*: LPWSTR + cbstgmedData*: DWORD + dwOptions*: DWORD + dwOptionsFlags*: DWORD + dwCodePage*: DWORD + securityAttributes*: REMSECURITY_ATTRIBUTES + iid*: IID + pUnk*: ptr IUnknown + dwReserved*: DWORD + StartParam* {.pure.} = object + iid*: IID + pIBindCtx*: ptr IBindCtx + pItf*: ptr IUnknown + PROTOCOLFILTERDATA* {.pure.} = object + cbSize*: DWORD + pProtocolSink*: ptr IInternetProtocolSink + pProtocol*: ptr IInternetProtocol + pUnk*: ptr IUnknown + dwFilterFlags*: DWORD + CONFIRMSAFETY* {.pure.} = object + clsid*: CLSID + pUnk*: ptr IUnknown + dwFlags*: DWORD + SERIALIZEDPROPERTYVALUE* {.pure.} = object + dwType*: DWORD + rgb*: array[1, BYTE] + DVASPECTINFO* {.pure.} = object + cb*: ULONG + dwFlags*: DWORD + COMDLG_FILTERSPEC* {.pure.} = object + pszName*: LPCWSTR + pszSpec*: LPCWSTR + AsyncIUnknown* {.pure.} = object + lpVtbl*: ptr AsyncIUnknownVtbl + AsyncIUnknownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Begin_QueryInterface*: proc(self: ptr AsyncIUnknown, riid: REFIID): HRESULT {.stdcall.} + Finish_QueryInterface*: proc(self: ptr AsyncIUnknown, ppvObject: ptr pointer): HRESULT {.stdcall.} + Begin_AddRef*: proc(self: ptr AsyncIUnknown): HRESULT {.stdcall.} + Finish_AddRef*: proc(self: ptr AsyncIUnknown): ULONG {.stdcall.} + Begin_Release*: proc(self: ptr AsyncIUnknown): HRESULT {.stdcall.} + Finish_Release*: proc(self: ptr AsyncIUnknown): ULONG {.stdcall.} + INoMarshal* {.pure.} = object + lpVtbl*: ptr INoMarshalVtbl + INoMarshalVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IAgileObject* {.pure.} = object + lpVtbl*: ptr IAgileObjectVtbl + IAgileObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AsyncIMultiQI* {.pure.} = object + lpVtbl*: ptr AsyncIMultiQIVtbl + AsyncIMultiQIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Begin_QueryMultipleInterfaces*: proc(self: ptr AsyncIMultiQI, cMQIs: ULONG, pMQIs: ptr MULTI_QI): void {.stdcall.} + Finish_QueryMultipleInterfaces*: proc(self: ptr AsyncIMultiQI, pMQIs: ptr MULTI_QI): HRESULT {.stdcall.} + IInternalUnknown* {.pure.} = object + lpVtbl*: ptr IInternalUnknownVtbl + IInternalUnknownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryInternalInterface*: proc(self: ptr IInternalUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IRpcChannelBuffer* {.pure.} = object + lpVtbl*: ptr IRpcChannelBufferVtbl + IRpcChannelBufferVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetBuffer*: proc(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE, riid: REFIID): HRESULT {.stdcall.} + SendReceive*: proc(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE, pStatus: ptr ULONG): HRESULT {.stdcall.} + FreeBuffer*: proc(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE): HRESULT {.stdcall.} + GetDestCtx*: proc(self: ptr IRpcChannelBuffer, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.stdcall.} + IsConnected*: proc(self: ptr IRpcChannelBuffer): HRESULT {.stdcall.} + IRpcChannelBuffer2* {.pure.} = object + lpVtbl*: ptr IRpcChannelBuffer2Vtbl + IRpcChannelBuffer2Vtbl* {.pure, inheritable.} = object of IRpcChannelBufferVtbl + GetProtocolVersion*: proc(self: ptr IRpcChannelBuffer2, pdwVersion: ptr DWORD): HRESULT {.stdcall.} + ISynchronize* {.pure.} = object + lpVtbl*: ptr ISynchronizeVtbl + ISynchronizeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Wait*: proc(self: ptr ISynchronize, dwFlags: DWORD, dwMilliseconds: DWORD): HRESULT {.stdcall.} + Signal*: proc(self: ptr ISynchronize): HRESULT {.stdcall.} + Reset*: proc(self: ptr ISynchronize): HRESULT {.stdcall.} + IAsyncRpcChannelBuffer* {.pure.} = object + lpVtbl*: ptr IAsyncRpcChannelBufferVtbl + IAsyncRpcChannelBufferVtbl* {.pure, inheritable.} = object of IRpcChannelBuffer2Vtbl + Send*: proc(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pSync: ptr ISynchronize, pulStatus: ptr ULONG): HRESULT {.stdcall.} + Receive*: proc(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pulStatus: ptr ULONG): HRESULT {.stdcall.} + GetDestCtxEx*: proc(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.stdcall.} + IAsyncManager* {.pure.} = object + lpVtbl*: ptr IAsyncManagerVtbl + IAsyncManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CompleteCall*: proc(self: ptr IAsyncManager, Result: HRESULT): HRESULT {.stdcall.} + GetCallContext*: proc(self: ptr IAsyncManager, riid: REFIID, pInterface: ptr pointer): HRESULT {.stdcall.} + GetState*: proc(self: ptr IAsyncManager, pulStateFlags: ptr ULONG): HRESULT {.stdcall.} + IRpcChannelBuffer3* {.pure.} = object + lpVtbl*: ptr IRpcChannelBuffer3Vtbl + IRpcChannelBuffer3Vtbl* {.pure, inheritable.} = object of IRpcChannelBuffer2Vtbl + Send*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pulStatus: ptr ULONG): HRESULT {.stdcall.} + Receive*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, ulSize: ULONG, pulStatus: ptr ULONG): HRESULT {.stdcall.} + Cancel*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE): HRESULT {.stdcall.} + GetCallContext*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, riid: REFIID, pInterface: ptr pointer): HRESULT {.stdcall.} + GetDestCtxEx*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.stdcall.} + GetState*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pState: ptr DWORD): HRESULT {.stdcall.} + RegisterAsync*: proc(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pAsyncMgr: ptr IAsyncManager): HRESULT {.stdcall.} + IRpcSyntaxNegotiate* {.pure.} = object + lpVtbl*: ptr IRpcSyntaxNegotiateVtbl + IRpcSyntaxNegotiateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + NegotiateSyntax*: proc(self: ptr IRpcSyntaxNegotiate, pMsg: ptr RPCOLEMESSAGE): HRESULT {.stdcall.} + IRpcProxyBuffer* {.pure.} = object + lpVtbl*: ptr IRpcProxyBufferVtbl + IRpcProxyBufferVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Connect*: proc(self: ptr IRpcProxyBuffer, pRpcChannelBuffer: ptr IRpcChannelBuffer): HRESULT {.stdcall.} + Disconnect*: proc(self: ptr IRpcProxyBuffer): void {.stdcall.} + IRpcStubBuffer* {.pure.} = object + lpVtbl*: ptr IRpcStubBufferVtbl + IRpcStubBufferVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Connect*: proc(self: ptr IRpcStubBuffer, pUnkServer: ptr IUnknown): HRESULT {.stdcall.} + Disconnect*: proc(self: ptr IRpcStubBuffer): void {.stdcall.} + Invoke*: proc(self: ptr IRpcStubBuffer, prpcmsg: ptr RPCOLEMESSAGE, pRpcChannelBuffer: ptr IRpcChannelBuffer): HRESULT {.stdcall.} + IsIIDSupported*: proc(self: ptr IRpcStubBuffer, riid: REFIID): ptr IRpcStubBuffer {.stdcall.} + CountRefs*: proc(self: ptr IRpcStubBuffer): ULONG {.stdcall.} + DebugServerQueryInterface*: proc(self: ptr IRpcStubBuffer, ppv: ptr pointer): HRESULT {.stdcall.} + DebugServerRelease*: proc(self: ptr IRpcStubBuffer, pv: pointer): void {.stdcall.} + IPSFactoryBuffer* {.pure.} = object + lpVtbl*: ptr IPSFactoryBufferVtbl + IPSFactoryBufferVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateProxy*: proc(self: ptr IPSFactoryBuffer, pUnkOuter: ptr IUnknown, riid: REFIID, ppProxy: ptr ptr IRpcProxyBuffer, ppv: ptr pointer): HRESULT {.stdcall.} + CreateStub*: proc(self: ptr IPSFactoryBuffer, riid: REFIID, pUnkServer: ptr IUnknown, ppStub: ptr ptr IRpcStubBuffer): HRESULT {.stdcall.} + IChannelHook* {.pure.} = object + lpVtbl*: ptr IChannelHookVtbl + IChannelHookVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ClientGetSize*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG): void {.stdcall.} + ClientFillBuffer*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG, pDataBuffer: pointer): void {.stdcall.} + ClientNotify*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, cbDataSize: ULONG, pDataBuffer: pointer, lDataRep: DWORD, hrFault: HRESULT): void {.stdcall.} + ServerNotify*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, cbDataSize: ULONG, pDataBuffer: pointer, lDataRep: DWORD): void {.stdcall.} + ServerGetSize*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, hrFault: HRESULT, pDataSize: ptr ULONG): void {.stdcall.} + ServerFillBuffer*: proc(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG, pDataBuffer: pointer, hrFault: HRESULT): void {.stdcall.} + IClientSecurity* {.pure.} = object + lpVtbl*: ptr IClientSecurityVtbl + IClientSecurityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryBlanket*: proc(self: ptr IClientSecurity, pProxy: ptr IUnknown, pAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr ptr OLECHAR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pAuthInfo: ptr pointer, pCapabilites: ptr DWORD): HRESULT {.stdcall.} + SetBlanket*: proc(self: ptr IClientSecurity, pProxy: ptr IUnknown, dwAuthnSvc: DWORD, dwAuthzSvc: DWORD, pServerPrincName: ptr OLECHAR, dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthInfo: pointer, dwCapabilities: DWORD): HRESULT {.stdcall.} + CopyProxy*: proc(self: ptr IClientSecurity, pProxy: ptr IUnknown, ppCopy: ptr ptr IUnknown): HRESULT {.stdcall.} + IServerSecurity* {.pure.} = object + lpVtbl*: ptr IServerSecurityVtbl + IServerSecurityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryBlanket*: proc(self: ptr IServerSecurity, pAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr ptr OLECHAR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pPrivs: ptr pointer, pCapabilities: ptr DWORD): HRESULT {.stdcall.} + ImpersonateClient*: proc(self: ptr IServerSecurity): HRESULT {.stdcall.} + RevertToSelf*: proc(self: ptr IServerSecurity): HRESULT {.stdcall.} + IsImpersonating*: proc(self: ptr IServerSecurity): WINBOOL {.stdcall.} + IRpcOptions* {.pure.} = object + lpVtbl*: ptr IRpcOptionsVtbl + IRpcOptionsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Set*: proc(self: ptr IRpcOptions, pPrx: ptr IUnknown, dwProperty: RPCOPT_PROPERTIES, dwValue: ULONG_PTR): HRESULT {.stdcall.} + Query*: proc(self: ptr IRpcOptions, pPrx: ptr IUnknown, dwProperty: RPCOPT_PROPERTIES, pdwValue: ptr ULONG_PTR): HRESULT {.stdcall.} + IGlobalOptions* {.pure.} = object + lpVtbl*: ptr IGlobalOptionsVtbl + IGlobalOptionsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Set*: proc(self: ptr IGlobalOptions, dwProperty: GLOBALOPT_PROPERTIES, dwValue: ULONG_PTR): HRESULT {.stdcall.} + Query*: proc(self: ptr IGlobalOptions, dwProperty: GLOBALOPT_PROPERTIES, pdwValue: ptr ULONG_PTR): HRESULT {.stdcall.} + ISynchronizeHandle* {.pure.} = object + lpVtbl*: ptr ISynchronizeHandleVtbl + ISynchronizeHandleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetHandle*: proc(self: ptr ISynchronizeHandle, ph: ptr HANDLE): HRESULT {.stdcall.} + ISynchronizeEvent* {.pure.} = object + lpVtbl*: ptr ISynchronizeEventVtbl + ISynchronizeEventVtbl* {.pure, inheritable.} = object of ISynchronizeHandleVtbl + SetEventHandle*: proc(self: ptr ISynchronizeEvent, ph: ptr HANDLE): HRESULT {.stdcall.} + ISynchronizeContainer* {.pure.} = object + lpVtbl*: ptr ISynchronizeContainerVtbl + ISynchronizeContainerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddSynchronize*: proc(self: ptr ISynchronizeContainer, pSync: ptr ISynchronize): HRESULT {.stdcall.} + WaitMultiple*: proc(self: ptr ISynchronizeContainer, dwFlags: DWORD, dwTimeOut: DWORD, ppSync: ptr ptr ISynchronize): HRESULT {.stdcall.} + ISynchronizeMutex* {.pure.} = object + lpVtbl*: ptr ISynchronizeMutexVtbl + ISynchronizeMutexVtbl* {.pure, inheritable.} = object of ISynchronizeVtbl + ReleaseMutex*: proc(self: ptr ISynchronizeMutex): HRESULT {.stdcall.} + ICallFactory* {.pure.} = object + lpVtbl*: ptr ICallFactoryVtbl + ICallFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateCall*: proc(self: ptr ICallFactory, riid: REFIID, pCtrlUnk: ptr IUnknown, riid2: REFIID, ppv: ptr ptr IUnknown): HRESULT {.stdcall.} + IRpcHelper* {.pure.} = object + lpVtbl*: ptr IRpcHelperVtbl + IRpcHelperVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDCOMProtocolVersion*: proc(self: ptr IRpcHelper, pComVersion: ptr DWORD): HRESULT {.stdcall.} + GetIIDFromOBJREF*: proc(self: ptr IRpcHelper, pObjRef: pointer, piid: ptr ptr IID): HRESULT {.stdcall.} + IReleaseMarshalBuffers* {.pure.} = object + lpVtbl*: ptr IReleaseMarshalBuffersVtbl + IReleaseMarshalBuffersVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ReleaseMarshalBuffer*: proc(self: ptr IReleaseMarshalBuffers, pMsg: ptr RPCOLEMESSAGE, dwFlags: DWORD, pChnl: ptr IUnknown): HRESULT {.stdcall.} + IWaitMultiple* {.pure.} = object + lpVtbl*: ptr IWaitMultipleVtbl + IWaitMultipleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + WaitMultiple*: proc(self: ptr IWaitMultiple, timeout: DWORD, pSync: ptr ptr ISynchronize): HRESULT {.stdcall.} + AddSynchronize*: proc(self: ptr IWaitMultiple, pSync: ptr ISynchronize): HRESULT {.stdcall.} + IPipeByte* {.pure.} = object + lpVtbl*: ptr IPipeByteVtbl + IPipeByteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Pull*: proc(self: ptr IPipeByte, buf: ptr BYTE, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.stdcall.} + Push*: proc(self: ptr IPipeByte, buf: ptr BYTE, cSent: ULONG): HRESULT {.stdcall.} + IPipeLong* {.pure.} = object + lpVtbl*: ptr IPipeLongVtbl + IPipeLongVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Pull*: proc(self: ptr IPipeLong, buf: ptr LONG, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.stdcall.} + Push*: proc(self: ptr IPipeLong, buf: ptr LONG, cSent: ULONG): HRESULT {.stdcall.} + IPipeDouble* {.pure.} = object + lpVtbl*: ptr IPipeDoubleVtbl + IPipeDoubleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Pull*: proc(self: ptr IPipeDouble, buf: ptr DOUBLE, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.stdcall.} + Push*: proc(self: ptr IPipeDouble, buf: ptr DOUBLE, cSent: ULONG): HRESULT {.stdcall.} + IContext* {.pure.} = object + lpVtbl*: ptr IContextVtbl + IContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetProperty*: proc(self: ptr IContext, rpolicyId: REFGUID, flags: CPFLAGS, pUnk: ptr IUnknown): HRESULT {.stdcall.} + RemoveProperty*: proc(self: ptr IContext, rPolicyId: REFGUID): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IContext, rGuid: REFGUID, pFlags: ptr CPFLAGS, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + EnumContextProps*: proc(self: ptr IContext, ppEnumContextProps: ptr ptr IEnumContextProps): HRESULT {.stdcall.} + IComThreadingInfo* {.pure.} = object + lpVtbl*: ptr IComThreadingInfoVtbl + IComThreadingInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentApartmentType*: proc(self: ptr IComThreadingInfo, pAptType: ptr APTTYPE): HRESULT {.stdcall.} + GetCurrentThreadType*: proc(self: ptr IComThreadingInfo, pThreadType: ptr THDTYPE): HRESULT {.stdcall.} + GetCurrentLogicalThreadId*: proc(self: ptr IComThreadingInfo, pguidLogicalThreadId: ptr GUID): HRESULT {.stdcall.} + SetCurrentLogicalThreadId*: proc(self: ptr IComThreadingInfo, rguid: REFGUID): HRESULT {.stdcall.} + IProcessInitControl* {.pure.} = object + lpVtbl*: ptr IProcessInitControlVtbl + IProcessInitControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ResetInitializerTimeout*: proc(self: ptr IProcessInitControl, dwSecondsRemaining: DWORD): HRESULT {.stdcall.} + IFastRundown* {.pure.} = object + lpVtbl*: ptr IFastRundownVtbl + IFastRundownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IMarshalingStream* {.pure.} = object + lpVtbl*: ptr IMarshalingStreamVtbl + IMarshalingStreamVtbl* {.pure, inheritable.} = object of IStreamVtbl + GetMarshalingContextAttribute*: proc(self: ptr IMarshalingStream, attribute: CO_MARSHALING_CONTEXT_ATTRIBUTES, pAttributeValue: ptr ULONG_PTR): HRESULT {.stdcall.} + IROTData* {.pure.} = object + lpVtbl*: ptr IROTDataVtbl + IROTDataVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetComparisonData*: proc(self: ptr IROTData, pbData: ptr uint8, cbMax: ULONG, pcbData: ptr ULONG): HRESULT {.stdcall.} + AsyncIAdviseSink* {.pure.} = object + lpVtbl*: ptr AsyncIAdviseSinkVtbl + AsyncIAdviseSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Begin_OnDataChange*: proc(self: ptr AsyncIAdviseSink, pFormatetc: ptr FORMATETC, pStgmed: ptr STGMEDIUM): void {.stdcall.} + Finish_OnDataChange*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Begin_OnViewChange*: proc(self: ptr AsyncIAdviseSink, dwAspect: DWORD, lindex: LONG): void {.stdcall.} + Finish_OnViewChange*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Begin_OnRename*: proc(self: ptr AsyncIAdviseSink, pmk: ptr IMoniker): void {.stdcall.} + Finish_OnRename*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Begin_OnSave*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Finish_OnSave*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Begin_OnClose*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + Finish_OnClose*: proc(self: ptr AsyncIAdviseSink): void {.stdcall.} + AsyncIAdviseSink2* {.pure.} = object + lpVtbl*: ptr AsyncIAdviseSink2Vtbl + AsyncIAdviseSink2Vtbl* {.pure, inheritable.} = object of IAdviseSinkVtbl + Begin_OnLinkSrcChange*: proc(self: ptr AsyncIAdviseSink2, pmk: ptr IMoniker): void {.stdcall.} + Finish_OnLinkSrcChange*: proc(self: ptr AsyncIAdviseSink2): void {.stdcall.} + IClassActivator* {.pure.} = object + lpVtbl*: ptr IClassActivatorVtbl + IClassActivatorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClassObject*: proc(self: ptr IClassActivator, rclsid: REFCLSID, dwClassContext: DWORD, locale: LCID, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IFillLockBytes* {.pure.} = object + lpVtbl*: ptr IFillLockBytesVtbl + IFillLockBytesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FillAppend*: proc(self: ptr IFillLockBytes, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.stdcall.} + FillAt*: proc(self: ptr IFillLockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.stdcall.} + SetFillSize*: proc(self: ptr IFillLockBytes, ulSize: ULARGE_INTEGER): HRESULT {.stdcall.} + Terminate*: proc(self: ptr IFillLockBytes, bCanceled: WINBOOL): HRESULT {.stdcall.} + IProgressNotify* {.pure.} = object + lpVtbl*: ptr IProgressNotifyVtbl + IProgressNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnProgress*: proc(self: ptr IProgressNotify, dwProgressCurrent: DWORD, dwProgressMaximum: DWORD, fAccurate: WINBOOL, fOwner: WINBOOL): HRESULT {.stdcall.} + ILayoutStorage* {.pure.} = object + lpVtbl*: ptr ILayoutStorageVtbl + ILayoutStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + LayoutScript*: proc(self: ptr ILayoutStorage, pStorageLayout: ptr StorageLayout, nEntries: DWORD, glfInterleavedFlag: DWORD): HRESULT {.stdcall.} + BeginMonitor*: proc(self: ptr ILayoutStorage): HRESULT {.stdcall.} + EndMonitor*: proc(self: ptr ILayoutStorage): HRESULT {.stdcall.} + ReLayoutDocfile*: proc(self: ptr ILayoutStorage, pwcsNewDfName: ptr OLECHAR): HRESULT {.stdcall.} + ReLayoutDocfileOnILockBytes*: proc(self: ptr ILayoutStorage, pILockBytes: ptr ILockBytes): HRESULT {.stdcall.} + IBlockingLock* {.pure.} = object + lpVtbl*: ptr IBlockingLockVtbl + IBlockingLockVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Lock*: proc(self: ptr IBlockingLock, dwTimeout: DWORD): HRESULT {.stdcall.} + Unlock*: proc(self: ptr IBlockingLock): HRESULT {.stdcall.} + ITimeAndNoticeControl* {.pure.} = object + lpVtbl*: ptr ITimeAndNoticeControlVtbl + ITimeAndNoticeControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SuppressChanges*: proc(self: ptr ITimeAndNoticeControl, res1: DWORD, res2: DWORD): HRESULT {.stdcall.} + IOplockStorage* {.pure.} = object + lpVtbl*: ptr IOplockStorageVtbl + IOplockStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateStorageEx*: proc(self: ptr IOplockStorage, pwcsName: LPCWSTR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, riid: REFIID, ppstgOpen: ptr pointer): HRESULT {.stdcall.} + OpenStorageEx*: proc(self: ptr IOplockStorage, pwcsName: LPCWSTR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, riid: REFIID, ppstgOpen: ptr pointer): HRESULT {.stdcall.} + IDirectWriterLock* {.pure.} = object + lpVtbl*: ptr IDirectWriterLockVtbl + IDirectWriterLockVtbl* {.pure, inheritable.} = object of IUnknownVtbl + WaitForWriteAccess*: proc(self: ptr IDirectWriterLock, dwTimeout: DWORD): HRESULT {.stdcall.} + ReleaseWriteAccess*: proc(self: ptr IDirectWriterLock): HRESULT {.stdcall.} + HaveWriteAccess*: proc(self: ptr IDirectWriterLock): HRESULT {.stdcall.} + IUrlMon* {.pure.} = object + lpVtbl*: ptr IUrlMonVtbl + IUrlMonVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AsyncGetClassBits*: proc(self: ptr IUrlMon, rclsid: REFCLSID, pszTYPE: LPCWSTR, pszExt: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, pszCodeBase: LPCWSTR, pbc: ptr IBindCtx, dwClassContext: DWORD, riid: REFIID, flags: DWORD): HRESULT {.stdcall.} + IForegroundTransfer* {.pure.} = object + lpVtbl*: ptr IForegroundTransferVtbl + IForegroundTransferVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AllowForegroundTransfer*: proc(self: ptr IForegroundTransfer, lpvReserved: pointer): HRESULT {.stdcall.} + IThumbnailExtractor* {.pure.} = object + lpVtbl*: ptr IThumbnailExtractorVtbl + IThumbnailExtractorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ExtractThumbnail*: proc(self: ptr IThumbnailExtractor, pStg: ptr IStorage, ulLength: ULONG, ulHeight: ULONG, pulOutputLength: ptr ULONG, pulOutputHeight: ptr ULONG, phOutputBitmap: ptr HBITMAP): HRESULT {.stdcall.} + OnFileUpdated*: proc(self: ptr IThumbnailExtractor, pStg: ptr IStorage): HRESULT {.stdcall.} + IDummyHICONIncluder* {.pure.} = object + lpVtbl*: ptr IDummyHICONIncluderVtbl + IDummyHICONIncluderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Dummy*: proc(self: ptr IDummyHICONIncluder, h1: HICON, h2: HDC): HRESULT {.stdcall.} + IProcessLock* {.pure.} = object + lpVtbl*: ptr IProcessLockVtbl + IProcessLockVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddRefOnProcess*: proc(self: ptr IProcessLock): ULONG {.stdcall.} + ReleaseRefOnProcess*: proc(self: ptr IProcessLock): ULONG {.stdcall.} + ISurrogateService* {.pure.} = object + lpVtbl*: ptr ISurrogateServiceVtbl + ISurrogateServiceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Init*: proc(self: ptr ISurrogateService, rguidProcessID: REFGUID, pProcessLock: ptr IProcessLock, pfApplicationAware: ptr WINBOOL): HRESULT {.stdcall.} + ApplicationLaunch*: proc(self: ptr ISurrogateService, rguidApplID: REFGUID, appType: ApplicationType): HRESULT {.stdcall.} + ApplicationFree*: proc(self: ptr ISurrogateService, rguidApplID: REFGUID): HRESULT {.stdcall.} + CatalogRefresh*: proc(self: ptr ISurrogateService, ulReserved: ULONG): HRESULT {.stdcall.} + ProcessShutdown*: proc(self: ptr ISurrogateService, shutdownType: ShutdownType): HRESULT {.stdcall.} + IApartmentShutdown* {.pure.} = object + lpVtbl*: ptr IApartmentShutdownVtbl + IApartmentShutdownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnUninitialize*: proc(self: ptr IApartmentShutdown, ui64ApartmentIdentifier: UINT64): void {.stdcall.} + ITypeFactory* {.pure.} = object + lpVtbl*: ptr ITypeFactoryVtbl + ITypeFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateFromTypeInfo*: proc(self: ptr ITypeFactory, pTypeInfo: ptr ITypeInfo, riid: REFIID, ppv: ptr ptr IUnknown): HRESULT {.stdcall.} + ITypeMarshal* {.pure.} = object + lpVtbl*: ptr ITypeMarshalVtbl + ITypeMarshalVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Size*: proc(self: ptr ITypeMarshal, pvType: PVOID, dwDestContext: DWORD, pvDestContext: PVOID, pSize: ptr ULONG): HRESULT {.stdcall.} + Marshal*: proc(self: ptr ITypeMarshal, pvType: PVOID, dwDestContext: DWORD, pvDestContext: PVOID, cbBufferLength: ULONG, pBuffer: ptr BYTE, pcbWritten: ptr ULONG): HRESULT {.stdcall.} + Unmarshal*: proc(self: ptr ITypeMarshal, pvType: PVOID, dwFlags: DWORD, cbBufferLength: ULONG, pBuffer: ptr BYTE, pcbRead: ptr ULONG): HRESULT {.stdcall.} + Free*: proc(self: ptr ITypeMarshal, pvType: PVOID): HRESULT {.stdcall.} + IContinue* {.pure.} = object + lpVtbl*: ptr IContinueVtbl + IContinueVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FContinue*: proc(self: ptr IContinue): HRESULT {.stdcall.} + IDropSourceNotify* {.pure.} = object + lpVtbl*: ptr IDropSourceNotifyVtbl + IDropSourceNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DragEnterTarget*: proc(self: ptr IDropSourceNotify, hwndTarget: HWND): HRESULT {.stdcall.} + DragLeaveTarget*: proc(self: ptr IDropSourceNotify): HRESULT {.stdcall.} + IXMLDOMImplementation* {.pure.} = object + lpVtbl*: ptr IXMLDOMImplementationVtbl + IXMLDOMImplementationVtbl* {.pure, inheritable.} = object of IDispatchVtbl + hasFeature*: proc(self: ptr IXMLDOMImplementation, feature: BSTR, version: BSTR, hasFeature: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IXMLDOMNodeList* {.pure.} = object + lpVtbl*: ptr IXMLDOMNodeListVtbl + IXMLDOMNodeListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_item*: proc(self: ptr IXMLDOMNodeList, index: LONG, listItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_length*: proc(self: ptr IXMLDOMNodeList, listLength: ptr LONG): HRESULT {.stdcall.} + nextNode*: proc(self: ptr IXMLDOMNodeList, nextItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + reset*: proc(self: ptr IXMLDOMNodeList): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IXMLDOMNodeList, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + IXMLDOMNode* {.pure.} = object + lpVtbl*: ptr IXMLDOMNodeVtbl + IXMLDOMNodeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_nodeName*: proc(self: ptr IXMLDOMNode, name: ptr BSTR): HRESULT {.stdcall.} + get_nodeValue*: proc(self: ptr IXMLDOMNode, value: ptr VARIANT): HRESULT {.stdcall.} + put_nodeValue*: proc(self: ptr IXMLDOMNode, value: VARIANT): HRESULT {.stdcall.} + get_nodeType*: proc(self: ptr IXMLDOMNode, `type`: ptr DOMNodeType): HRESULT {.stdcall.} + get_parentNode*: proc(self: ptr IXMLDOMNode, parent: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_childNodes*: proc(self: ptr IXMLDOMNode, childList: ptr ptr IXMLDOMNodeList): HRESULT {.stdcall.} + get_firstChild*: proc(self: ptr IXMLDOMNode, firstChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_lastChild*: proc(self: ptr IXMLDOMNode, lastChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_previousSibling*: proc(self: ptr IXMLDOMNode, previousSibling: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_nextSibling*: proc(self: ptr IXMLDOMNode, nextSibling: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_attributes*: proc(self: ptr IXMLDOMNode, attributeMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.stdcall.} + insertBefore*: proc(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, refChild: VARIANT, outNewChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + replaceChild*: proc(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, oldChild: ptr IXMLDOMNode, outOldChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IXMLDOMNode, childNode: ptr IXMLDOMNode, oldChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + appendChild*: proc(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, outNewChild: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + hasChildNodes*: proc(self: ptr IXMLDOMNode, hasChild: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_ownerDocument*: proc(self: ptr IXMLDOMNode, DOMDocument: ptr ptr IXMLDOMDocument): HRESULT {.stdcall.} + cloneNode*: proc(self: ptr IXMLDOMNode, deep: VARIANT_BOOL, cloneRoot: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_nodeTypeString*: proc(self: ptr IXMLDOMNode, nodeType: ptr BSTR): HRESULT {.stdcall.} + get_text*: proc(self: ptr IXMLDOMNode, text: ptr BSTR): HRESULT {.stdcall.} + put_text*: proc(self: ptr IXMLDOMNode, text: BSTR): HRESULT {.stdcall.} + get_specified*: proc(self: ptr IXMLDOMNode, isSpecified: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_definition*: proc(self: ptr IXMLDOMNode, definitionNode: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_nodeTypedValue*: proc(self: ptr IXMLDOMNode, typedValue: ptr VARIANT): HRESULT {.stdcall.} + put_nodeTypedValue*: proc(self: ptr IXMLDOMNode, typedValue: VARIANT): HRESULT {.stdcall.} + get_dataType*: proc(self: ptr IXMLDOMNode, dataTypeName: ptr VARIANT): HRESULT {.stdcall.} + put_dataType*: proc(self: ptr IXMLDOMNode, dataTypeName: BSTR): HRESULT {.stdcall.} + get_xml*: proc(self: ptr IXMLDOMNode, xmlString: ptr BSTR): HRESULT {.stdcall.} + transformNode*: proc(self: ptr IXMLDOMNode, stylesheet: ptr IXMLDOMNode, xmlString: ptr BSTR): HRESULT {.stdcall.} + selectNodes*: proc(self: ptr IXMLDOMNode, queryString: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.stdcall.} + selectSingleNode*: proc(self: ptr IXMLDOMNode, queryString: BSTR, resultNode: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_parsed*: proc(self: ptr IXMLDOMNode, isParsed: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_namespaceURI*: proc(self: ptr IXMLDOMNode, namespaceURI: ptr BSTR): HRESULT {.stdcall.} + get_prefix*: proc(self: ptr IXMLDOMNode, prefixString: ptr BSTR): HRESULT {.stdcall.} + get_baseName*: proc(self: ptr IXMLDOMNode, nameString: ptr BSTR): HRESULT {.stdcall.} + transformNodeToObject*: proc(self: ptr IXMLDOMNode, stylesheet: ptr IXMLDOMNode, outputObject: VARIANT): HRESULT {.stdcall.} + IXMLDOMDocumentType* {.pure.} = object + lpVtbl*: ptr IXMLDOMDocumentTypeVtbl + IXMLDOMDocumentTypeVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_name*: proc(self: ptr IXMLDOMDocumentType, rootName: ptr BSTR): HRESULT {.stdcall.} + get_entities*: proc(self: ptr IXMLDOMDocumentType, entityMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.stdcall.} + get_notations*: proc(self: ptr IXMLDOMDocumentType, notationMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.stdcall.} + IXMLDOMAttribute* {.pure.} = object + lpVtbl*: ptr IXMLDOMAttributeVtbl + IXMLDOMAttributeVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_name*: proc(self: ptr IXMLDOMAttribute, attributeName: ptr BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IXMLDOMAttribute, attributeValue: ptr VARIANT): HRESULT {.stdcall.} + put_value*: proc(self: ptr IXMLDOMAttribute, attributeValue: VARIANT): HRESULT {.stdcall.} + IXMLDOMElement* {.pure.} = object + lpVtbl*: ptr IXMLDOMElementVtbl + IXMLDOMElementVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_tagName*: proc(self: ptr IXMLDOMElement, tagName: ptr BSTR): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IXMLDOMElement, name: BSTR, value: ptr VARIANT): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IXMLDOMElement, name: BSTR, value: VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IXMLDOMElement, name: BSTR): HRESULT {.stdcall.} + getAttributeNode*: proc(self: ptr IXMLDOMElement, name: BSTR, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.stdcall.} + setAttributeNode*: proc(self: ptr IXMLDOMElement, DOMAttribute: ptr IXMLDOMAttribute, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.stdcall.} + removeAttributeNode*: proc(self: ptr IXMLDOMElement, DOMAttribute: ptr IXMLDOMAttribute, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.stdcall.} + getElementsByTagName*: proc(self: ptr IXMLDOMElement, tagName: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.stdcall.} + normalize*: proc(self: ptr IXMLDOMElement): HRESULT {.stdcall.} + IXMLDOMDocumentFragment* {.pure.} = object + lpVtbl*: ptr IXMLDOMDocumentFragmentVtbl + IXMLDOMDocumentFragmentVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + IXMLDOMCharacterData* {.pure.} = object + lpVtbl*: ptr IXMLDOMCharacterDataVtbl + IXMLDOMCharacterDataVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_data*: proc(self: ptr IXMLDOMCharacterData, data: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IXMLDOMCharacterData, data: BSTR): HRESULT {.stdcall.} + get_length*: proc(self: ptr IXMLDOMCharacterData, dataLength: ptr LONG): HRESULT {.stdcall.} + substringData*: proc(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG, data: ptr BSTR): HRESULT {.stdcall.} + appendData*: proc(self: ptr IXMLDOMCharacterData, data: BSTR): HRESULT {.stdcall.} + insertData*: proc(self: ptr IXMLDOMCharacterData, offset: LONG, data: BSTR): HRESULT {.stdcall.} + deleteData*: proc(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG): HRESULT {.stdcall.} + replaceData*: proc(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG, data: BSTR): HRESULT {.stdcall.} + IXMLDOMText* {.pure.} = object + lpVtbl*: ptr IXMLDOMTextVtbl + IXMLDOMTextVtbl* {.pure, inheritable.} = object of IXMLDOMCharacterDataVtbl + splitText*: proc(self: ptr IXMLDOMText, offset: LONG, rightHandTextNode: ptr ptr IXMLDOMText): HRESULT {.stdcall.} + IXMLDOMComment* {.pure.} = object + lpVtbl*: ptr IXMLDOMCommentVtbl + IXMLDOMCommentVtbl* {.pure, inheritable.} = object of IXMLDOMCharacterDataVtbl + IXMLDOMCDATASection* {.pure.} = object + lpVtbl*: ptr IXMLDOMCDATASectionVtbl + IXMLDOMCDATASectionVtbl* {.pure, inheritable.} = object of IXMLDOMTextVtbl + IXMLDOMProcessingInstruction* {.pure.} = object + lpVtbl*: ptr IXMLDOMProcessingInstructionVtbl + IXMLDOMProcessingInstructionVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_target*: proc(self: ptr IXMLDOMProcessingInstruction, name: ptr BSTR): HRESULT {.stdcall.} + get_data*: proc(self: ptr IXMLDOMProcessingInstruction, value: ptr BSTR): HRESULT {.stdcall.} + put_data*: proc(self: ptr IXMLDOMProcessingInstruction, value: BSTR): HRESULT {.stdcall.} + IXMLDOMEntityReference* {.pure.} = object + lpVtbl*: ptr IXMLDOMEntityReferenceVtbl + IXMLDOMEntityReferenceVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + IXMLDOMParseError* {.pure.} = object + lpVtbl*: ptr IXMLDOMParseErrorVtbl + IXMLDOMParseErrorVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_errorCode*: proc(self: ptr IXMLDOMParseError, errorCode: ptr LONG): HRESULT {.stdcall.} + get_url*: proc(self: ptr IXMLDOMParseError, urlString: ptr BSTR): HRESULT {.stdcall.} + get_reason*: proc(self: ptr IXMLDOMParseError, reasonString: ptr BSTR): HRESULT {.stdcall.} + get_srcText*: proc(self: ptr IXMLDOMParseError, sourceString: ptr BSTR): HRESULT {.stdcall.} + get_line*: proc(self: ptr IXMLDOMParseError, lineNumber: ptr LONG): HRESULT {.stdcall.} + get_linepos*: proc(self: ptr IXMLDOMParseError, linePosition: ptr LONG): HRESULT {.stdcall.} + get_filepos*: proc(self: ptr IXMLDOMParseError, filePosition: ptr LONG): HRESULT {.stdcall.} + IXMLDOMDocument* {.pure.} = object + lpVtbl*: ptr IXMLDOMDocumentVtbl + IXMLDOMDocumentVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_doctype*: proc(self: ptr IXMLDOMDocument, documentType: ptr ptr IXMLDOMDocumentType): HRESULT {.stdcall.} + get_implementation*: proc(self: ptr IXMLDOMDocument, impl: ptr ptr IXMLDOMImplementation): HRESULT {.stdcall.} + get_documentElement*: proc(self: ptr IXMLDOMDocument, DOMElement: ptr ptr IXMLDOMElement): HRESULT {.stdcall.} + putref_documentElement*: proc(self: ptr IXMLDOMDocument, DOMElement: ptr IXMLDOMElement): HRESULT {.stdcall.} + createElement*: proc(self: ptr IXMLDOMDocument, tagName: BSTR, element: ptr ptr IXMLDOMElement): HRESULT {.stdcall.} + createDocumentFragment*: proc(self: ptr IXMLDOMDocument, docFrag: ptr ptr IXMLDOMDocumentFragment): HRESULT {.stdcall.} + createTextNode*: proc(self: ptr IXMLDOMDocument, data: BSTR, text: ptr ptr IXMLDOMText): HRESULT {.stdcall.} + createComment*: proc(self: ptr IXMLDOMDocument, data: BSTR, comment: ptr ptr IXMLDOMComment): HRESULT {.stdcall.} + createCDATASection*: proc(self: ptr IXMLDOMDocument, data: BSTR, cdata: ptr ptr IXMLDOMCDATASection): HRESULT {.stdcall.} + createProcessingInstruction*: proc(self: ptr IXMLDOMDocument, target: BSTR, data: BSTR, pi: ptr ptr IXMLDOMProcessingInstruction): HRESULT {.stdcall.} + createAttribute*: proc(self: ptr IXMLDOMDocument, name: BSTR, attribute: ptr ptr IXMLDOMAttribute): HRESULT {.stdcall.} + createEntityReference*: proc(self: ptr IXMLDOMDocument, name: BSTR, entityRef: ptr ptr IXMLDOMEntityReference): HRESULT {.stdcall.} + getElementsByTagName*: proc(self: ptr IXMLDOMDocument, tagName: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.stdcall.} + createNode*: proc(self: ptr IXMLDOMDocument, Type: VARIANT, name: BSTR, namespaceURI: BSTR, node: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + nodeFromID*: proc(self: ptr IXMLDOMDocument, idString: BSTR, node: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + load*: proc(self: ptr IXMLDOMDocument, xmlSource: VARIANT, isSuccessful: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IXMLDOMDocument, value: ptr LONG): HRESULT {.stdcall.} + get_parseError*: proc(self: ptr IXMLDOMDocument, errorObj: ptr ptr IXMLDOMParseError): HRESULT {.stdcall.} + get_url*: proc(self: ptr IXMLDOMDocument, urlString: ptr BSTR): HRESULT {.stdcall.} + get_async*: proc(self: ptr IXMLDOMDocument, isAsync: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_async*: proc(self: ptr IXMLDOMDocument, isAsync: VARIANT_BOOL): HRESULT {.stdcall.} + abort*: proc(self: ptr IXMLDOMDocument): HRESULT {.stdcall.} + loadXML*: proc(self: ptr IXMLDOMDocument, bstrXML: BSTR, isSuccessful: ptr VARIANT_BOOL): HRESULT {.stdcall.} + save*: proc(self: ptr IXMLDOMDocument, destination: VARIANT): HRESULT {.stdcall.} + get_validateOnParse*: proc(self: ptr IXMLDOMDocument, isValidating: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_validateOnParse*: proc(self: ptr IXMLDOMDocument, isValidating: VARIANT_BOOL): HRESULT {.stdcall.} + get_resolveExternals*: proc(self: ptr IXMLDOMDocument, isResolving: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_resolveExternals*: proc(self: ptr IXMLDOMDocument, isResolving: VARIANT_BOOL): HRESULT {.stdcall.} + get_preserveWhiteSpace*: proc(self: ptr IXMLDOMDocument, isPreserving: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_preserveWhiteSpace*: proc(self: ptr IXMLDOMDocument, isPreserving: VARIANT_BOOL): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IXMLDOMDocument, readystatechangeSink: VARIANT): HRESULT {.stdcall.} + put_ondataavailable*: proc(self: ptr IXMLDOMDocument, ondataavailableSink: VARIANT): HRESULT {.stdcall.} + put_ontransformnode*: proc(self: ptr IXMLDOMDocument, ontransformnodeSink: VARIANT): HRESULT {.stdcall.} + IXMLDOMNamedNodeMap* {.pure.} = object + lpVtbl*: ptr IXMLDOMNamedNodeMapVtbl + IXMLDOMNamedNodeMapVtbl* {.pure, inheritable.} = object of IDispatchVtbl + getNamedItem*: proc(self: ptr IXMLDOMNamedNodeMap, name: BSTR, namedItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + setNamedItem*: proc(self: ptr IXMLDOMNamedNodeMap, newItem: ptr IXMLDOMNode, nameItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + removeNamedItem*: proc(self: ptr IXMLDOMNamedNodeMap, name: BSTR, namedItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_item*: proc(self: ptr IXMLDOMNamedNodeMap, index: LONG, listItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + get_length*: proc(self: ptr IXMLDOMNamedNodeMap, listLength: ptr LONG): HRESULT {.stdcall.} + getQualifiedItem*: proc(self: ptr IXMLDOMNamedNodeMap, baseName: BSTR, namespaceURI: BSTR, qualifiedItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + removeQualifiedItem*: proc(self: ptr IXMLDOMNamedNodeMap, baseName: BSTR, namespaceURI: BSTR, qualifiedItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + nextNode*: proc(self: ptr IXMLDOMNamedNodeMap, nextItem: ptr ptr IXMLDOMNode): HRESULT {.stdcall.} + reset*: proc(self: ptr IXMLDOMNamedNodeMap): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IXMLDOMNamedNodeMap, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + IXMLDOMNotation* {.pure.} = object + lpVtbl*: ptr IXMLDOMNotationVtbl + IXMLDOMNotationVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_publicId*: proc(self: ptr IXMLDOMNotation, publicID: ptr VARIANT): HRESULT {.stdcall.} + get_systemId*: proc(self: ptr IXMLDOMNotation, systemID: ptr VARIANT): HRESULT {.stdcall.} + IXMLDOMEntity* {.pure.} = object + lpVtbl*: ptr IXMLDOMEntityVtbl + IXMLDOMEntityVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + get_publicId*: proc(self: ptr IXMLDOMEntity, publicID: ptr VARIANT): HRESULT {.stdcall.} + get_systemId*: proc(self: ptr IXMLDOMEntity, systemID: ptr VARIANT): HRESULT {.stdcall.} + get_notationName*: proc(self: ptr IXMLDOMEntity, name: ptr BSTR): HRESULT {.stdcall.} + IXTLRuntime* {.pure.} = object + lpVtbl*: ptr IXTLRuntimeVtbl + IXTLRuntimeVtbl* {.pure, inheritable.} = object of IXMLDOMNodeVtbl + uniqueID*: proc(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pID: ptr LONG): HRESULT {.stdcall.} + depth*: proc(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pDepth: ptr LONG): HRESULT {.stdcall.} + childNumber*: proc(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.stdcall.} + ancestorChildNumber*: proc(self: ptr IXTLRuntime, bstrNodeName: BSTR, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.stdcall.} + absoluteChildNumber*: proc(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.stdcall.} + formatIndex*: proc(self: ptr IXTLRuntime, lIndex: LONG, bstrFormat: BSTR, pbstrFormattedString: ptr BSTR): HRESULT {.stdcall.} + formatNumber*: proc(self: ptr IXTLRuntime, dblNumber: float64, bstrFormat: BSTR, pbstrFormattedString: ptr BSTR): HRESULT {.stdcall.} + formatDate*: proc(self: ptr IXTLRuntime, varDate: VARIANT, bstrFormat: BSTR, varDestLocale: VARIANT, pbstrFormattedString: ptr BSTR): HRESULT {.stdcall.} + formatTime*: proc(self: ptr IXTLRuntime, varTime: VARIANT, bstrFormat: BSTR, varDestLocale: VARIANT, pbstrFormattedString: ptr BSTR): HRESULT {.stdcall.} + XMLDOMDocumentEvents* {.pure.} = object + lpVtbl*: ptr XMLDOMDocumentEventsVtbl + XMLDOMDocumentEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IXMLHttpRequest* {.pure.} = object + lpVtbl*: ptr IXMLHttpRequestVtbl + IXMLHttpRequestVtbl* {.pure, inheritable.} = object of IDispatchVtbl + open*: proc(self: ptr IXMLHttpRequest, bstrMethod: BSTR, bstrUrl: BSTR, varAsync: VARIANT, bstrUser: VARIANT, bstrPassword: VARIANT): HRESULT {.stdcall.} + setRequestHeader*: proc(self: ptr IXMLHttpRequest, bstrHeader: BSTR, bstrValue: BSTR): HRESULT {.stdcall.} + getResponseHeader*: proc(self: ptr IXMLHttpRequest, bstrHeader: BSTR, pbstrValue: ptr BSTR): HRESULT {.stdcall.} + getAllResponseHeaders*: proc(self: ptr IXMLHttpRequest, pbstrHeaders: ptr BSTR): HRESULT {.stdcall.} + send*: proc(self: ptr IXMLHttpRequest, varBody: VARIANT): HRESULT {.stdcall.} + abort*: proc(self: ptr IXMLHttpRequest): HRESULT {.stdcall.} + get_status*: proc(self: ptr IXMLHttpRequest, plStatus: ptr LONG): HRESULT {.stdcall.} + get_statusText*: proc(self: ptr IXMLHttpRequest, pbstrStatus: ptr BSTR): HRESULT {.stdcall.} + get_responseXML*: proc(self: ptr IXMLHttpRequest, ppBody: ptr ptr IDispatch): HRESULT {.stdcall.} + get_responseText*: proc(self: ptr IXMLHttpRequest, pbstrBody: ptr BSTR): HRESULT {.stdcall.} + get_responseBody*: proc(self: ptr IXMLHttpRequest, pvarBody: ptr VARIANT): HRESULT {.stdcall.} + get_responseStream*: proc(self: ptr IXMLHttpRequest, pvarBody: ptr VARIANT): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IXMLHttpRequest, plState: ptr LONG): HRESULT {.stdcall.} + put_onreadystatechange*: proc(self: ptr IXMLHttpRequest, pReadyStateSink: ptr IDispatch): HRESULT {.stdcall.} + IXMLDSOControl* {.pure.} = object + lpVtbl*: ptr IXMLDSOControlVtbl + IXMLDSOControlVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_XMLDocument*: proc(self: ptr IXMLDSOControl, ppDoc: ptr ptr IXMLDOMDocument): HRESULT {.stdcall.} + put_XMLDocument*: proc(self: ptr IXMLDSOControl, ppDoc: ptr IXMLDOMDocument): HRESULT {.stdcall.} + get_JavaDSOCompatible*: proc(self: ptr IXMLDSOControl, fJavaDSOCompatible: ptr WINBOOL): HRESULT {.stdcall.} + put_JavaDSOCompatible*: proc(self: ptr IXMLDSOControl, fJavaDSOCompatible: WINBOOL): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IXMLDSOControl, state: ptr LONG): HRESULT {.stdcall.} + IXMLElementCollection* {.pure.} = object + lpVtbl*: ptr IXMLElementCollectionVtbl + IXMLElementCollectionVtbl* {.pure, inheritable.} = object of IDispatchVtbl + put_length*: proc(self: ptr IXMLElementCollection, v: LONG): HRESULT {.stdcall.} + get_length*: proc(self: ptr IXMLElementCollection, p: ptr LONG): HRESULT {.stdcall.} + get_newEnum*: proc(self: ptr IXMLElementCollection, ppUnk: ptr ptr IUnknown): HRESULT {.stdcall.} + item*: proc(self: ptr IXMLElementCollection, var1: VARIANT, var2: VARIANT, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + IXMLElement* {.pure.} = object + lpVtbl*: ptr IXMLElementVtbl + IXMLElementVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_tagName*: proc(self: ptr IXMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_tagName*: proc(self: ptr IXMLElement, p: BSTR): HRESULT {.stdcall.} + get_parent*: proc(self: ptr IXMLElement, ppParent: ptr ptr IXMLElement): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IXMLElement, strPropertyName: BSTR, PropertyValue: VARIANT): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IXMLElement, strPropertyName: BSTR, PropertyValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IXMLElement, strPropertyName: BSTR): HRESULT {.stdcall.} + get_children*: proc(self: ptr IXMLElement, pp: ptr ptr IXMLElementCollection): HRESULT {.stdcall.} + get_type*: proc(self: ptr IXMLElement, plType: ptr LONG): HRESULT {.stdcall.} + get_text*: proc(self: ptr IXMLElement, p: ptr BSTR): HRESULT {.stdcall.} + put_text*: proc(self: ptr IXMLElement, p: BSTR): HRESULT {.stdcall.} + addChild*: proc(self: ptr IXMLElement, pChildElem: ptr IXMLElement, lIndex: LONG, lReserved: LONG): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IXMLElement, pChildElem: ptr IXMLElement): HRESULT {.stdcall.} + IXMLDocument* {.pure.} = object + lpVtbl*: ptr IXMLDocumentVtbl + IXMLDocumentVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_root*: proc(self: ptr IXMLDocument, p: ptr ptr IXMLElement): HRESULT {.stdcall.} + get_fileSize*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_fileModifiedDate*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_fileUpdatedDate*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_URL*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + put_URL*: proc(self: ptr IXMLDocument, p: BSTR): HRESULT {.stdcall.} + get_mimeType*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IXMLDocument, pl: ptr LONG): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + put_charset*: proc(self: ptr IXMLDocument, p: BSTR): HRESULT {.stdcall.} + get_version*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_doctype*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + get_dtdURL*: proc(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.stdcall.} + createElement*: proc(self: ptr IXMLDocument, vType: VARIANT, var1: VARIANT, ppElem: ptr ptr IXMLElement): HRESULT {.stdcall.} + IXMLElement2* {.pure.} = object + lpVtbl*: ptr IXMLElement2Vtbl + IXMLElement2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_tagName*: proc(self: ptr IXMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_tagName*: proc(self: ptr IXMLElement2, p: BSTR): HRESULT {.stdcall.} + get_parent*: proc(self: ptr IXMLElement2, ppParent: ptr ptr IXMLElement2): HRESULT {.stdcall.} + setAttribute*: proc(self: ptr IXMLElement2, strPropertyName: BSTR, PropertyValue: VARIANT): HRESULT {.stdcall.} + getAttribute*: proc(self: ptr IXMLElement2, strPropertyName: BSTR, PropertyValue: ptr VARIANT): HRESULT {.stdcall.} + removeAttribute*: proc(self: ptr IXMLElement2, strPropertyName: BSTR): HRESULT {.stdcall.} + get_children*: proc(self: ptr IXMLElement2, pp: ptr ptr IXMLElementCollection): HRESULT {.stdcall.} + get_type*: proc(self: ptr IXMLElement2, plType: ptr LONG): HRESULT {.stdcall.} + get_text*: proc(self: ptr IXMLElement2, p: ptr BSTR): HRESULT {.stdcall.} + put_text*: proc(self: ptr IXMLElement2, p: BSTR): HRESULT {.stdcall.} + addChild*: proc(self: ptr IXMLElement2, pChildElem: ptr IXMLElement2, lIndex: LONG, lReserved: LONG): HRESULT {.stdcall.} + removeChild*: proc(self: ptr IXMLElement2, pChildElem: ptr IXMLElement2): HRESULT {.stdcall.} + get_attributes*: proc(self: ptr IXMLElement2, pp: ptr ptr IXMLElementCollection): HRESULT {.stdcall.} + IXMLDocument2* {.pure.} = object + lpVtbl*: ptr IXMLDocument2Vtbl + IXMLDocument2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_root*: proc(self: ptr IXMLDocument2, p: ptr ptr IXMLElement2): HRESULT {.stdcall.} + get_fileSize*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileModifiedDate*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_fileUpdatedDate*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_URL*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_URL*: proc(self: ptr IXMLDocument2, p: BSTR): HRESULT {.stdcall.} + get_mimeType*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_readyState*: proc(self: ptr IXMLDocument2, pl: ptr LONG): HRESULT {.stdcall.} + get_charset*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + put_charset*: proc(self: ptr IXMLDocument2, p: BSTR): HRESULT {.stdcall.} + get_version*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_doctype*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + get_dtdURL*: proc(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.stdcall.} + createElement*: proc(self: ptr IXMLDocument2, vType: VARIANT, var1: VARIANT, ppElem: ptr ptr IXMLElement2): HRESULT {.stdcall.} + get_async*: proc(self: ptr IXMLDocument2, pf: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_async*: proc(self: ptr IXMLDocument2, f: VARIANT_BOOL): HRESULT {.stdcall.} + IXMLAttribute* {.pure.} = object + lpVtbl*: ptr IXMLAttributeVtbl + IXMLAttributeVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_name*: proc(self: ptr IXMLAttribute, n: ptr BSTR): HRESULT {.stdcall.} + get_value*: proc(self: ptr IXMLAttribute, v: ptr BSTR): HRESULT {.stdcall.} + IXMLError* {.pure.} = object + lpVtbl*: ptr IXMLErrorVtbl + IXMLErrorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetErrorInfo*: proc(self: ptr IXMLError, pErrorReturn: ptr XML_ERROR): HRESULT {.stdcall.} + IUriContainer* {.pure.} = object + lpVtbl*: ptr IUriContainerVtbl + IUriContainerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetIUri*: proc(self: ptr IUriContainer, ppIUri: ptr ptr IUri): HRESULT {.stdcall.} + IUriBuilder* {.pure.} = object + lpVtbl*: ptr IUriBuilderVtbl + IUriBuilderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateUriSimple*: proc(self: ptr IUriBuilder, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.stdcall.} + CreateUri*: proc(self: ptr IUriBuilder, dwCreateFlags: DWORD, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.stdcall.} + CreateUriWithFlags*: proc(self: ptr IUriBuilder, dwCreateFlags: DWORD, dwUriBuilderFlags: DWORD, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.stdcall.} + GetIUri*: proc(self: ptr IUriBuilder, ppIUri: ptr ptr IUri): HRESULT {.stdcall.} + SetIUri*: proc(self: ptr IUriBuilder, pIUri: ptr IUri): HRESULT {.stdcall.} + GetFragment*: proc(self: ptr IUriBuilder, pcchFragment: ptr DWORD, ppwzFragment: ptr LPCWSTR): HRESULT {.stdcall.} + GetHost*: proc(self: ptr IUriBuilder, pcchHost: ptr DWORD, ppwzHost: ptr LPCWSTR): HRESULT {.stdcall.} + GetPassword*: proc(self: ptr IUriBuilder, pcchPassword: ptr DWORD, ppwzPassword: ptr LPCWSTR): HRESULT {.stdcall.} + GetPath*: proc(self: ptr IUriBuilder, pcchPath: ptr DWORD, ppwzPath: ptr LPCWSTR): HRESULT {.stdcall.} + GetPort*: proc(self: ptr IUriBuilder, pfHasPort: ptr WINBOOL, pdwPort: ptr DWORD): HRESULT {.stdcall.} + GetQuery*: proc(self: ptr IUriBuilder, pcchQuery: ptr DWORD, ppwzQuery: ptr LPCWSTR): HRESULT {.stdcall.} + GetSchemeName*: proc(self: ptr IUriBuilder, pcchSchemeName: ptr DWORD, ppwzSchemeName: ptr LPCWSTR): HRESULT {.stdcall.} + GetUserName*: proc(self: ptr IUriBuilder, pcchUserName: ptr DWORD, ppwzUserName: ptr LPCWSTR): HRESULT {.stdcall.} + SetFragment*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetHost*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetPassword*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetPath*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetPort*: proc(self: ptr IUriBuilder, fHasPort: WINBOOL, dwNewValue: DWORD): HRESULT {.stdcall.} + SetQuery*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetSchemeName*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + SetUserName*: proc(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.stdcall.} + RemoveProperties*: proc(self: ptr IUriBuilder, dwPropertyMask: DWORD): HRESULT {.stdcall.} + HasBeenModified*: proc(self: ptr IUriBuilder, pfModified: ptr WINBOOL): HRESULT {.stdcall.} + IUriBuilderFactory* {.pure.} = object + lpVtbl*: ptr IUriBuilderFactoryVtbl + IUriBuilderFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateIUriBuilder*: proc(self: ptr IUriBuilderFactory, dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: ptr ptr IUriBuilder): HRESULT {.stdcall.} + CreateInitializedIUriBuilder*: proc(self: ptr IUriBuilderFactory, dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: ptr ptr IUriBuilder): HRESULT {.stdcall.} + IWinInetHttpTimeouts* {.pure.} = object + lpVtbl*: ptr IWinInetHttpTimeoutsVtbl + IWinInetHttpTimeoutsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRequestTimeouts*: proc(self: ptr IWinInetHttpTimeouts, pdwConnectTimeout: ptr DWORD, pdwSendTimeout: ptr DWORD, pdwReceiveTimeout: ptr DWORD): HRESULT {.stdcall.} + IInternetSecurityMgrSite* {.pure.} = object + lpVtbl*: ptr IInternetSecurityMgrSiteVtbl + IInternetSecurityMgrSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindow*: proc(self: ptr IInternetSecurityMgrSite, phwnd: ptr HWND): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IInternetSecurityMgrSite, fEnable: WINBOOL): HRESULT {.stdcall.} + IInternetSecurityManager* {.pure.} = object + lpVtbl*: ptr IInternetSecurityManagerVtbl + IInternetSecurityManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSecuritySite*: proc(self: ptr IInternetSecurityManager, pSite: ptr IInternetSecurityMgrSite): HRESULT {.stdcall.} + GetSecuritySite*: proc(self: ptr IInternetSecurityManager, ppSite: ptr ptr IInternetSecurityMgrSite): HRESULT {.stdcall.} + MapUrlToZone*: proc(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, pdwZone: ptr DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + GetSecurityId*: proc(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + ProcessUrlAction*: proc(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + QueryCustomPolicy*: proc(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + SetZoneMapping*: proc(self: ptr IInternetSecurityManager, dwZone: DWORD, lpszPattern: LPCWSTR, dwFlags: DWORD): HRESULT {.stdcall.} + GetZoneMappings*: proc(self: ptr IInternetSecurityManager, dwZone: DWORD, ppenumString: ptr ptr IEnumString, dwFlags: DWORD): HRESULT {.stdcall.} + IInternetSecurityManagerEx* {.pure.} = object + lpVtbl*: ptr IInternetSecurityManagerExVtbl + IInternetSecurityManagerExVtbl* {.pure, inheritable.} = object of IInternetSecurityManagerVtbl + ProcessUrlActionEx*: proc(self: ptr IInternetSecurityManagerEx, pwszUrl: LPCWSTR, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.stdcall.} + IInternetSecurityManagerEx2* {.pure.} = object + lpVtbl*: ptr IInternetSecurityManagerEx2Vtbl + IInternetSecurityManagerEx2Vtbl* {.pure, inheritable.} = object of IInternetSecurityManagerExVtbl + MapUrlToZoneEx2*: proc(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, pdwZone: ptr DWORD, dwFlags: DWORD, ppwszMappedUrl: ptr LPWSTR, pdwOutFlags: ptr DWORD): HRESULT {.stdcall.} + ProcessUrlActionEx2*: proc(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD_PTR, pdwOutFlags: ptr DWORD): HRESULT {.stdcall.} + GetSecurityIdEx2*: proc(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + QueryCustomPolicyEx2*: proc(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + IZoneIdentifier* {.pure.} = object + lpVtbl*: ptr IZoneIdentifierVtbl + IZoneIdentifierVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetId*: proc(self: ptr IZoneIdentifier, pdwZone: ptr DWORD): HRESULT {.stdcall.} + SetId*: proc(self: ptr IZoneIdentifier, dwZone: DWORD): HRESULT {.stdcall.} + Remove*: proc(self: ptr IZoneIdentifier): HRESULT {.stdcall.} + IInternetHostSecurityManager* {.pure.} = object + lpVtbl*: ptr IInternetHostSecurityManagerVtbl + IInternetHostSecurityManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSecurityId*: proc(self: ptr IInternetHostSecurityManager, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.stdcall.} + ProcessUrlAction*: proc(self: ptr IInternetHostSecurityManager, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + QueryCustomPolicy*: proc(self: ptr IInternetHostSecurityManager, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD): HRESULT {.stdcall.} + IInternetZoneManagerEx* {.pure.} = object + lpVtbl*: ptr IInternetZoneManagerExVtbl + IInternetZoneManagerExVtbl* {.pure, inheritable.} = object of IInternetZoneManagerVtbl + GetZoneActionPolicyEx*: proc(self: ptr IInternetZoneManagerEx, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG, dwFlags: DWORD): HRESULT {.stdcall.} + SetZoneActionPolicyEx*: proc(self: ptr IInternetZoneManagerEx, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG, dwFlags: DWORD): HRESULT {.stdcall.} + IInternetZoneManagerEx2* {.pure.} = object + lpVtbl*: ptr IInternetZoneManagerEx2Vtbl + IInternetZoneManagerEx2Vtbl* {.pure, inheritable.} = object of IInternetZoneManagerExVtbl + GetZoneAttributesEx*: proc(self: ptr IInternetZoneManagerEx2, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES, dwFlags: DWORD): HRESULT {.stdcall.} + GetZoneSecurityState*: proc(self: ptr IInternetZoneManagerEx2, dwZoneIndex: DWORD, fRespectPolicy: WINBOOL, pdwState: LPDWORD, pfPolicyEncountered: ptr WINBOOL): HRESULT {.stdcall.} + GetIESecurityState*: proc(self: ptr IInternetZoneManagerEx2, fRespectPolicy: WINBOOL, pdwState: LPDWORD, pfPolicyEncountered: ptr WINBOOL, fNoCache: WINBOOL): HRESULT {.stdcall.} + FixUnsecureSettings*: proc(self: ptr IInternetZoneManagerEx2): HRESULT {.stdcall.} + ISoftDistExt* {.pure.} = object + lpVtbl*: ptr ISoftDistExtVtbl + ISoftDistExtVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ProcessSoftDist*: proc(self: ptr ISoftDistExt, szCDFURL: LPCWSTR, pSoftDistElement: ptr IXMLElement, lpsdi: LPSOFTDISTINFO): HRESULT {.stdcall.} + GetFirstCodeBase*: proc(self: ptr ISoftDistExt, szCodeBase: ptr LPWSTR, dwMaxSize: LPDWORD): HRESULT {.stdcall.} + GetNextCodeBase*: proc(self: ptr ISoftDistExt, szCodeBase: ptr LPWSTR, dwMaxSize: LPDWORD): HRESULT {.stdcall.} + AsyncInstallDistributionUnit*: proc(self: ptr ISoftDistExt, pbc: ptr IBindCtx, pvReserved: LPVOID, flags: DWORD, lpcbh: LPCODEBASEHOLD): HRESULT {.stdcall.} + IZoomEvents* {.pure.} = object + lpVtbl*: ptr IZoomEventsVtbl + IZoomEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnZoomPercentChanged*: proc(self: ptr IZoomEvents, ulZoomPercent: ULONG): HRESULT {.stdcall.} + IProtectFocus* {.pure.} = object + lpVtbl*: ptr IProtectFocusVtbl + IProtectFocusVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AllowFocusChange*: proc(self: ptr IProtectFocus, pfAllow: ptr WINBOOL): HRESULT {.stdcall.} + IProtectedModeMenuServices* {.pure.} = object + lpVtbl*: ptr IProtectedModeMenuServicesVtbl + IProtectedModeMenuServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateMenu*: proc(self: ptr IProtectedModeMenuServices, phMenu: ptr HMENU): HRESULT {.stdcall.} + LoadMenu*: proc(self: ptr IProtectedModeMenuServices, pszModuleName: LPCWSTR, pszMenuName: LPCWSTR, phMenu: ptr HMENU): HRESULT {.stdcall.} + LoadMenuID*: proc(self: ptr IProtectedModeMenuServices, pszModuleName: LPCWSTR, wResourceID: WORD, phMenu: ptr HMENU): HRESULT {.stdcall.} + IWebBrowser* {.pure.} = object + lpVtbl*: ptr IWebBrowserVtbl + IWebBrowserVtbl* {.pure, inheritable.} = object of IDispatchVtbl + GoBack*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + GoForward*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + GoHome*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + GoSearch*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + Navigate*: proc(self: ptr IWebBrowser, URL: BSTR, Flags: ptr VARIANT, TargetFrameName: ptr VARIANT, PostData: ptr VARIANT, Headers: ptr VARIANT): HRESULT {.stdcall.} + Refresh*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + Refresh2*: proc(self: ptr IWebBrowser, Level: ptr VARIANT): HRESULT {.stdcall.} + Stop*: proc(self: ptr IWebBrowser): HRESULT {.stdcall.} + get_Application*: proc(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Container*: proc(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Document*: proc(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + get_TopLevelContainer*: proc(self: ptr IWebBrowser, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_Type*: proc(self: ptr IWebBrowser, Type: ptr BSTR): HRESULT {.stdcall.} + get_Left*: proc(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.stdcall.} + put_Left*: proc(self: ptr IWebBrowser, Left: LONG): HRESULT {.stdcall.} + get_Top*: proc(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.stdcall.} + put_Top*: proc(self: ptr IWebBrowser, Top: LONG): HRESULT {.stdcall.} + get_Width*: proc(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.stdcall.} + put_Width*: proc(self: ptr IWebBrowser, Width: LONG): HRESULT {.stdcall.} + get_Height*: proc(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.stdcall.} + put_Height*: proc(self: ptr IWebBrowser, Height: LONG): HRESULT {.stdcall.} + get_LocationName*: proc(self: ptr IWebBrowser, LocationName: ptr BSTR): HRESULT {.stdcall.} + get_LocationURL*: proc(self: ptr IWebBrowser, LocationURL: ptr BSTR): HRESULT {.stdcall.} + get_Busy*: proc(self: ptr IWebBrowser, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DWebBrowserEvents* {.pure.} = object + lpVtbl*: ptr DWebBrowserEventsVtbl + DWebBrowserEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IWebBrowserApp* {.pure.} = object + lpVtbl*: ptr IWebBrowserAppVtbl + IWebBrowserAppVtbl* {.pure, inheritable.} = object of IWebBrowserVtbl + Quit*: proc(self: ptr IWebBrowserApp): HRESULT {.stdcall.} + ClientToWindow*: proc(self: ptr IWebBrowserApp, pcx: ptr int32, pcy: ptr int32): HRESULT {.stdcall.} + PutProperty*: proc(self: ptr IWebBrowserApp, Property: BSTR, vtValue: VARIANT): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IWebBrowserApp, Property: BSTR, pvtValue: ptr VARIANT): HRESULT {.stdcall.} + get_Name*: proc(self: ptr IWebBrowserApp, Name: ptr BSTR): HRESULT {.stdcall.} + get_HWND*: proc(self: ptr IWebBrowserApp, pHWND: ptr SHANDLE_PTR): HRESULT {.stdcall.} + get_FullName*: proc(self: ptr IWebBrowserApp, FullName: ptr BSTR): HRESULT {.stdcall.} + get_Path*: proc(self: ptr IWebBrowserApp, Path: ptr BSTR): HRESULT {.stdcall.} + get_Visible*: proc(self: ptr IWebBrowserApp, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_Visible*: proc(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.stdcall.} + get_StatusBar*: proc(self: ptr IWebBrowserApp, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_StatusBar*: proc(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.stdcall.} + get_StatusText*: proc(self: ptr IWebBrowserApp, StatusText: ptr BSTR): HRESULT {.stdcall.} + put_StatusText*: proc(self: ptr IWebBrowserApp, StatusText: BSTR): HRESULT {.stdcall.} + get_ToolBar*: proc(self: ptr IWebBrowserApp, Value: ptr int32): HRESULT {.stdcall.} + put_ToolBar*: proc(self: ptr IWebBrowserApp, Value: int32): HRESULT {.stdcall.} + get_MenuBar*: proc(self: ptr IWebBrowserApp, Value: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_MenuBar*: proc(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.stdcall.} + get_FullScreen*: proc(self: ptr IWebBrowserApp, pbFullScreen: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_FullScreen*: proc(self: ptr IWebBrowserApp, bFullScreen: VARIANT_BOOL): HRESULT {.stdcall.} + IWebBrowser2* {.pure.} = object + lpVtbl*: ptr IWebBrowser2Vtbl + IWebBrowser2Vtbl* {.pure, inheritable.} = object of IWebBrowserAppVtbl + Navigate2*: proc(self: ptr IWebBrowser2, URL: ptr VARIANT, Flags: ptr VARIANT, TargetFrameName: ptr VARIANT, PostData: ptr VARIANT, Headers: ptr VARIANT): HRESULT {.stdcall.} + QueryStatusWB*: proc(self: ptr IWebBrowser2, cmdID: OLECMDID, pcmdf: ptr OLECMDF): HRESULT {.stdcall.} + ExecWB*: proc(self: ptr IWebBrowser2, cmdID: OLECMDID, cmdexecopt: OLECMDEXECOPT, pvaIn: ptr VARIANT, pvaOut: ptr VARIANT): HRESULT {.stdcall.} + ShowBrowserBar*: proc(self: ptr IWebBrowser2, pvaClsid: ptr VARIANT, pvarShow: ptr VARIANT, pvarSize: ptr VARIANT): HRESULT {.stdcall.} + get_ReadyState*: proc(self: ptr IWebBrowser2, plReadyState: ptr READYSTATE): HRESULT {.stdcall.} + get_Offline*: proc(self: ptr IWebBrowser2, pbOffline: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_Offline*: proc(self: ptr IWebBrowser2, bOffline: VARIANT_BOOL): HRESULT {.stdcall.} + get_Silent*: proc(self: ptr IWebBrowser2, pbSilent: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_Silent*: proc(self: ptr IWebBrowser2, bSilent: VARIANT_BOOL): HRESULT {.stdcall.} + get_RegisterAsBrowser*: proc(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_RegisterAsBrowser*: proc(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.stdcall.} + get_RegisterAsDropTarget*: proc(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_RegisterAsDropTarget*: proc(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.stdcall.} + get_TheaterMode*: proc(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_TheaterMode*: proc(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.stdcall.} + get_AddressBar*: proc(self: ptr IWebBrowser2, Value: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_AddressBar*: proc(self: ptr IWebBrowser2, Value: VARIANT_BOOL): HRESULT {.stdcall.} + get_Resizable*: proc(self: ptr IWebBrowser2, Value: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_Resizable*: proc(self: ptr IWebBrowser2, Value: VARIANT_BOOL): HRESULT {.stdcall.} + DWebBrowserEvents2* {.pure.} = object + lpVtbl*: ptr DWebBrowserEvents2Vtbl + DWebBrowserEvents2Vtbl* {.pure, inheritable.} = object of IDispatchVtbl + DShellWindowsEvents* {.pure.} = object + lpVtbl*: ptr DShellWindowsEventsVtbl + DShellWindowsEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IShellWindows* {.pure.} = object + lpVtbl*: ptr IShellWindowsVtbl + IShellWindowsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Count*: proc(self: ptr IShellWindows, Count: ptr LONG): HRESULT {.stdcall.} + Item*: proc(self: ptr IShellWindows, index: VARIANT, Folder: ptr ptr IDispatch): HRESULT {.stdcall.} + NewEnum*: proc(self: ptr IShellWindows, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + Register*: proc(self: ptr IShellWindows, pid: ptr IDispatch, hWnd: LONG, swClass: int32, plCookie: ptr LONG): HRESULT {.stdcall.} + RegisterPending*: proc(self: ptr IShellWindows, lThreadId: LONG, pvarloc: ptr VARIANT, pvarlocRoot: ptr VARIANT, swClass: int32, plCookie: ptr LONG): HRESULT {.stdcall.} + Revoke*: proc(self: ptr IShellWindows, lCookie: LONG): HRESULT {.stdcall.} + OnNavigate*: proc(self: ptr IShellWindows, lCookie: LONG, pvarLoc: ptr VARIANT): HRESULT {.stdcall.} + OnActivated*: proc(self: ptr IShellWindows, lCookie: LONG, fActive: VARIANT_BOOL): HRESULT {.stdcall.} + FindWindowSW*: proc(self: ptr IShellWindows, pvarLoc: ptr VARIANT, pvarLocRoot: ptr VARIANT, swClass: int32, phwnd: ptr LONG, swfwOptions: int32, ppdispOut: ptr ptr IDispatch): HRESULT {.stdcall.} + OnCreated*: proc(self: ptr IShellWindows, lCookie: LONG, punk: ptr IUnknown): HRESULT {.stdcall.} + ProcessAttachDetach*: proc(self: ptr IShellWindows, fAttach: VARIANT_BOOL): HRESULT {.stdcall.} + IShellUIHelper* {.pure.} = object + lpVtbl*: ptr IShellUIHelperVtbl + IShellUIHelperVtbl* {.pure, inheritable.} = object of IDispatchVtbl + ResetFirstBootMode*: proc(self: ptr IShellUIHelper): HRESULT {.stdcall.} + ResetSafeMode*: proc(self: ptr IShellUIHelper): HRESULT {.stdcall.} + RefreshOfflineDesktop*: proc(self: ptr IShellUIHelper): HRESULT {.stdcall.} + AddFavorite*: proc(self: ptr IShellUIHelper, URL: BSTR, Title: ptr VARIANT): HRESULT {.stdcall.} + AddChannel*: proc(self: ptr IShellUIHelper, URL: BSTR): HRESULT {.stdcall.} + AddDesktopComponent*: proc(self: ptr IShellUIHelper, URL: BSTR, Type: BSTR, Left: ptr VARIANT, Top: ptr VARIANT, Width: ptr VARIANT, Height: ptr VARIANT): HRESULT {.stdcall.} + IsSubscribed*: proc(self: ptr IShellUIHelper, URL: BSTR, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + NavigateAndFind*: proc(self: ptr IShellUIHelper, URL: BSTR, strQuery: BSTR, varTargetFrame: ptr VARIANT): HRESULT {.stdcall.} + ImportExportFavorites*: proc(self: ptr IShellUIHelper, fImport: VARIANT_BOOL, strImpExpPath: BSTR): HRESULT {.stdcall.} + AutoCompleteSaveForm*: proc(self: ptr IShellUIHelper, Form: ptr VARIANT): HRESULT {.stdcall.} + AutoScan*: proc(self: ptr IShellUIHelper, strSearch: BSTR, strFailureUrl: BSTR, pvarTargetFrame: ptr VARIANT): HRESULT {.stdcall.} + AutoCompleteAttach*: proc(self: ptr IShellUIHelper, Reserved: ptr VARIANT): HRESULT {.stdcall.} + ShowBrowserUI*: proc(self: ptr IShellUIHelper, bstrName: BSTR, pvarIn: ptr VARIANT, pvarOut: ptr VARIANT): HRESULT {.stdcall.} + IShellUIHelper2* {.pure.} = object + lpVtbl*: ptr IShellUIHelper2Vtbl + IShellUIHelper2Vtbl* {.pure, inheritable.} = object of IShellUIHelperVtbl + AddSearchProvider*: proc(self: ptr IShellUIHelper2, URL: BSTR): HRESULT {.stdcall.} + RunOnceShown*: proc(self: ptr IShellUIHelper2): HRESULT {.stdcall.} + SkipRunOnce*: proc(self: ptr IShellUIHelper2): HRESULT {.stdcall.} + CustomizeSettings*: proc(self: ptr IShellUIHelper2, fSQM: VARIANT_BOOL, fPhishing: VARIANT_BOOL, bstrLocale: BSTR): HRESULT {.stdcall.} + SqmEnabled*: proc(self: ptr IShellUIHelper2, pfEnabled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + PhishingEnabled*: proc(self: ptr IShellUIHelper2, pfEnabled: ptr VARIANT_BOOL): HRESULT {.stdcall.} + BrandImageUri*: proc(self: ptr IShellUIHelper2, pbstrUri: ptr BSTR): HRESULT {.stdcall.} + SkipTabsWelcome*: proc(self: ptr IShellUIHelper2): HRESULT {.stdcall.} + DiagnoseConnection*: proc(self: ptr IShellUIHelper2): HRESULT {.stdcall.} + CustomizeClearType*: proc(self: ptr IShellUIHelper2, fSet: VARIANT_BOOL): HRESULT {.stdcall.} + IsSearchProviderInstalled*: proc(self: ptr IShellUIHelper2, URL: BSTR, pdwResult: ptr DWORD): HRESULT {.stdcall.} + IsSearchMigrated*: proc(self: ptr IShellUIHelper2, pfMigrated: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DefaultSearchProvider*: proc(self: ptr IShellUIHelper2, pbstrName: ptr BSTR): HRESULT {.stdcall.} + RunOnceRequiredSettingsComplete*: proc(self: ptr IShellUIHelper2, fComplete: VARIANT_BOOL): HRESULT {.stdcall.} + RunOnceHasShown*: proc(self: ptr IShellUIHelper2, pfShown: ptr VARIANT_BOOL): HRESULT {.stdcall.} + SearchGuideUrl*: proc(self: ptr IShellUIHelper2, pbstrUrl: ptr BSTR): HRESULT {.stdcall.} + DShellNameSpaceEvents* {.pure.} = object + lpVtbl*: ptr DShellNameSpaceEventsVtbl + DShellNameSpaceEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IShellFavoritesNameSpace* {.pure.} = object + lpVtbl*: ptr IShellFavoritesNameSpaceVtbl + IShellFavoritesNameSpaceVtbl* {.pure, inheritable.} = object of IDispatchVtbl + MoveSelectionUp*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + MoveSelectionDown*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + ResetSort*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + NewFolder*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + Synchronize*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + Import*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + Export*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + InvokeContextMenuCommand*: proc(self: ptr IShellFavoritesNameSpace, strCommand: BSTR): HRESULT {.stdcall.} + MoveSelectionTo*: proc(self: ptr IShellFavoritesNameSpace): HRESULT {.stdcall.} + get_SubscriptionsEnabled*: proc(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + CreateSubscriptionForSelection*: proc(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DeleteSubscriptionForSelection*: proc(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.stdcall.} + SetRoot*: proc(self: ptr IShellFavoritesNameSpace, bstrFullPath: BSTR): HRESULT {.stdcall.} + IShellNameSpace* {.pure.} = object + lpVtbl*: ptr IShellNameSpaceVtbl + IShellNameSpaceVtbl* {.pure, inheritable.} = object of IShellFavoritesNameSpaceVtbl + get_EnumOptions*: proc(self: ptr IShellNameSpace, pgrfEnumFlags: ptr LONG): HRESULT {.stdcall.} + put_EnumOptions*: proc(self: ptr IShellNameSpace, pgrfEnumFlags: LONG): HRESULT {.stdcall.} + get_SelectedItem*: proc(self: ptr IShellNameSpace, pItem: ptr ptr IDispatch): HRESULT {.stdcall.} + put_SelectedItem*: proc(self: ptr IShellNameSpace, pItem: ptr IDispatch): HRESULT {.stdcall.} + get_Root*: proc(self: ptr IShellNameSpace, pvar: ptr VARIANT): HRESULT {.stdcall.} + put_Root*: proc(self: ptr IShellNameSpace, pvar: VARIANT): HRESULT {.stdcall.} + get_Depth*: proc(self: ptr IShellNameSpace, piDepth: ptr int32): HRESULT {.stdcall.} + put_Depth*: proc(self: ptr IShellNameSpace, piDepth: int32): HRESULT {.stdcall.} + get_Mode*: proc(self: ptr IShellNameSpace, puMode: ptr int32): HRESULT {.stdcall.} + put_Mode*: proc(self: ptr IShellNameSpace, puMode: int32): HRESULT {.stdcall.} + get_Flags*: proc(self: ptr IShellNameSpace, pdwFlags: ptr ULONG): HRESULT {.stdcall.} + put_Flags*: proc(self: ptr IShellNameSpace, pdwFlags: ULONG): HRESULT {.stdcall.} + put_TVFlags*: proc(self: ptr IShellNameSpace, dwFlags: ULONG): HRESULT {.stdcall.} + get_TVFlags*: proc(self: ptr IShellNameSpace, dwFlags: ptr ULONG): HRESULT {.stdcall.} + get_Columns*: proc(self: ptr IShellNameSpace, bstrColumns: ptr BSTR): HRESULT {.stdcall.} + put_Columns*: proc(self: ptr IShellNameSpace, bstrColumns: BSTR): HRESULT {.stdcall.} + get_CountViewTypes*: proc(self: ptr IShellNameSpace, piTypes: ptr int32): HRESULT {.stdcall.} + SetViewType*: proc(self: ptr IShellNameSpace, iType: int32): HRESULT {.stdcall.} + SelectedItems*: proc(self: ptr IShellNameSpace, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + Expand*: proc(self: ptr IShellNameSpace, `var`: VARIANT, iDepth: int32): HRESULT {.stdcall.} + UnselectAll*: proc(self: ptr IShellNameSpace): HRESULT {.stdcall.} + IScriptErrorList* {.pure.} = object + lpVtbl*: ptr IScriptErrorListVtbl + IScriptErrorListVtbl* {.pure, inheritable.} = object of IDispatchVtbl + advanceError*: proc(self: ptr IScriptErrorList): HRESULT {.stdcall.} + retreatError*: proc(self: ptr IScriptErrorList): HRESULT {.stdcall.} + canAdvanceError*: proc(self: ptr IScriptErrorList, pfCanAdvance: ptr LONG): HRESULT {.stdcall.} + canRetreatError*: proc(self: ptr IScriptErrorList, pfCanRetreat: ptr LONG): HRESULT {.stdcall.} + getErrorLine*: proc(self: ptr IScriptErrorList, plLine: ptr LONG): HRESULT {.stdcall.} + getErrorChar*: proc(self: ptr IScriptErrorList, plChar: ptr LONG): HRESULT {.stdcall.} + getErrorCode*: proc(self: ptr IScriptErrorList, plCode: ptr LONG): HRESULT {.stdcall.} + getErrorMsg*: proc(self: ptr IScriptErrorList, pstr: ptr BSTR): HRESULT {.stdcall.} + getErrorUrl*: proc(self: ptr IScriptErrorList, pstr: ptr BSTR): HRESULT {.stdcall.} + getAlwaysShowLockState*: proc(self: ptr IScriptErrorList, pfAlwaysShowLocked: ptr LONG): HRESULT {.stdcall.} + getDetailsPaneOpen*: proc(self: ptr IScriptErrorList, pfDetailsPaneOpen: ptr LONG): HRESULT {.stdcall.} + setDetailsPaneOpen*: proc(self: ptr IScriptErrorList, fDetailsPaneOpen: LONG): HRESULT {.stdcall.} + getPerErrorDisplay*: proc(self: ptr IScriptErrorList, pfPerErrorDisplay: ptr LONG): HRESULT {.stdcall.} + setPerErrorDisplay*: proc(self: ptr IScriptErrorList, fPerErrorDisplay: LONG): HRESULT {.stdcall.} + ISearch* {.pure.} = object + lpVtbl*: ptr ISearchVtbl + ISearchVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Title*: proc(self: ptr ISearch, pbstrTitle: ptr BSTR): HRESULT {.stdcall.} + get_Id*: proc(self: ptr ISearch, pbstrId: ptr BSTR): HRESULT {.stdcall.} + get_URL*: proc(self: ptr ISearch, pbstrUrl: ptr BSTR): HRESULT {.stdcall.} + ISearches* {.pure.} = object + lpVtbl*: ptr ISearchesVtbl + ISearchesVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Count*: proc(self: ptr ISearches, plCount: ptr LONG): HRESULT {.stdcall.} + get_Default*: proc(self: ptr ISearches, pbstrDefault: ptr BSTR): HRESULT {.stdcall.} + Item*: proc(self: ptr ISearches, index: VARIANT, ppid: ptr ptr ISearch): HRESULT {.stdcall.} + NewEnum*: proc(self: ptr ISearches, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + ISearchAssistantOC* {.pure.} = object + lpVtbl*: ptr ISearchAssistantOCVtbl + ISearchAssistantOCVtbl* {.pure, inheritable.} = object of IDispatchVtbl + AddNextMenuItem*: proc(self: ptr ISearchAssistantOC, bstrText: BSTR, idItem: LONG): HRESULT {.stdcall.} + SetDefaultSearchUrl*: proc(self: ptr ISearchAssistantOC, bstrUrl: BSTR): HRESULT {.stdcall.} + NavigateToDefaultSearch*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + IsRestricted*: proc(self: ptr ISearchAssistantOC, bstrGuid: BSTR, pVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_ShellFeaturesEnabled*: proc(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_SearchAssistantDefault*: proc(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_Searches*: proc(self: ptr ISearchAssistantOC, ppid: ptr ptr ISearches): HRESULT {.stdcall.} + get_InWebFolder*: proc(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.stdcall.} + PutProperty*: proc(self: ptr ISearchAssistantOC, bPerLocale: VARIANT_BOOL, bstrName: BSTR, bstrValue: BSTR): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr ISearchAssistantOC, bPerLocale: VARIANT_BOOL, bstrName: BSTR, pbstrValue: ptr BSTR): HRESULT {.stdcall.} + put_EventHandled*: proc(self: ptr ISearchAssistantOC, rhs: VARIANT_BOOL): HRESULT {.stdcall.} + ResetNextMenu*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + FindOnWeb*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + FindFilesOrFolders*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + FindComputer*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + FindPrinter*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + FindPeople*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + GetSearchAssistantURL*: proc(self: ptr ISearchAssistantOC, bSubstitute: VARIANT_BOOL, bCustomize: VARIANT_BOOL, pbstrValue: ptr BSTR): HRESULT {.stdcall.} + NotifySearchSettingsChanged*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + put_ASProvider*: proc(self: ptr ISearchAssistantOC, pProvider: BSTR): HRESULT {.stdcall.} + get_ASProvider*: proc(self: ptr ISearchAssistantOC, pProvider: ptr BSTR): HRESULT {.stdcall.} + put_ASSetting*: proc(self: ptr ISearchAssistantOC, pSetting: int32): HRESULT {.stdcall.} + get_ASSetting*: proc(self: ptr ISearchAssistantOC, pSetting: ptr int32): HRESULT {.stdcall.} + NETDetectNextNavigate*: proc(self: ptr ISearchAssistantOC): HRESULT {.stdcall.} + PutFindText*: proc(self: ptr ISearchAssistantOC, FindText: BSTR): HRESULT {.stdcall.} + get_Version*: proc(self: ptr ISearchAssistantOC, pVersion: ptr int32): HRESULT {.stdcall.} + EncodeString*: proc(self: ptr ISearchAssistantOC, bstrValue: BSTR, bstrCharSet: BSTR, bUseUTF8: VARIANT_BOOL, pbstrResult: ptr BSTR): HRESULT {.stdcall.} + ISearchAssistantOC2* {.pure.} = object + lpVtbl*: ptr ISearchAssistantOC2Vtbl + ISearchAssistantOC2Vtbl* {.pure, inheritable.} = object of ISearchAssistantOCVtbl + get_ShowFindPrinter*: proc(self: ptr ISearchAssistantOC2, pbShowFindPrinter: ptr VARIANT_BOOL): HRESULT {.stdcall.} + ISearchAssistantOC3* {.pure.} = object + lpVtbl*: ptr ISearchAssistantOC3Vtbl + ISearchAssistantOC3Vtbl* {.pure, inheritable.} = object of ISearchAssistantOC2Vtbl + get_SearchCompanionAvailable*: proc(self: ptr ISearchAssistantOC3, pbAvailable: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_UseSearchCompanion*: proc(self: ptr ISearchAssistantOC3, pbUseSC: VARIANT_BOOL): HRESULT {.stdcall.} + get_UseSearchCompanion*: proc(self: ptr ISearchAssistantOC3, pbUseSC: ptr VARIANT_BOOL): HRESULT {.stdcall.} + SearchAssistantEvents* {.pure.} = object + lpVtbl*: ptr SearchAssistantEventsVtbl + SearchAssistantEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + IRichChunk* {.pure.} = object + lpVtbl*: ptr IRichChunkVtbl + IRichChunkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetData*: proc(self: ptr IRichChunk, pFirstPos: ptr ULONG, pLength: ptr ULONG, ppsz: ptr LPWSTR, pValue: ptr PROPVARIANT): HRESULT {.stdcall.} + ICondition* {.pure.} = object + lpVtbl*: ptr IConditionVtbl + IConditionVtbl* {.pure, inheritable.} = object of IPersistStreamVtbl + GetConditionType*: proc(self: ptr ICondition, pNodeType: ptr CONDITION_TYPE): HRESULT {.stdcall.} + GetSubConditions*: proc(self: ptr ICondition, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetComparisonInfo*: proc(self: ptr ICondition, ppszPropertyName: ptr LPWSTR, pcop: ptr CONDITION_OPERATION, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + GetValueType*: proc(self: ptr ICondition, ppszValueTypeName: ptr LPWSTR): HRESULT {.stdcall.} + GetValueNormalization*: proc(self: ptr ICondition, ppszNormalization: ptr LPWSTR): HRESULT {.stdcall.} + GetInputTerms*: proc(self: ptr ICondition, ppPropertyTerm: ptr ptr IRichChunk, ppOperationTerm: ptr ptr IRichChunk, ppValueTerm: ptr ptr IRichChunk): HRESULT {.stdcall.} + Clone*: proc(self: ptr ICondition, ppc: ptr ptr ICondition): HRESULT {.stdcall.} + ICondition2* {.pure.} = object + lpVtbl*: ptr ICondition2Vtbl + ICondition2Vtbl* {.pure, inheritable.} = object of IConditionVtbl + GetLocale*: proc(self: ptr ICondition2, ppszLocaleName: ptr LPWSTR): HRESULT {.stdcall.} + GetLeafConditionInfo*: proc(self: ptr ICondition2, ppropkey: ptr PROPERTYKEY, pcop: ptr CONDITION_OPERATION, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + IInitializeWithFile* {.pure.} = object + lpVtbl*: ptr IInitializeWithFileVtbl + IInitializeWithFileVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithFile, pszFilePath: LPCWSTR, grfMode: DWORD): HRESULT {.stdcall.} + IInitializeWithStream* {.pure.} = object + lpVtbl*: ptr IInitializeWithStreamVtbl + IInitializeWithStreamVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithStream, pstream: ptr IStream, grfMode: DWORD): HRESULT {.stdcall.} + INamedPropertyStore* {.pure.} = object + lpVtbl*: ptr INamedPropertyStoreVtbl + INamedPropertyStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNamedValue*: proc(self: ptr INamedPropertyStore, pszName: LPCWSTR, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + SetNamedValue*: proc(self: ptr INamedPropertyStore, pszName: LPCWSTR, propvar: REFPROPVARIANT): HRESULT {.stdcall.} + GetNameCount*: proc(self: ptr INamedPropertyStore, pdwCount: ptr DWORD): HRESULT {.stdcall.} + GetNameAt*: proc(self: ptr INamedPropertyStore, iProp: DWORD, pbstrName: ptr BSTR): HRESULT {.stdcall.} + IObjectWithPropertyKey* {.pure.} = object + lpVtbl*: ptr IObjectWithPropertyKeyVtbl + IObjectWithPropertyKeyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetPropertyKey*: proc(self: ptr IObjectWithPropertyKey, key: REFPROPERTYKEY): HRESULT {.stdcall.} + GetPropertyKey*: proc(self: ptr IObjectWithPropertyKey, pkey: ptr PROPERTYKEY): HRESULT {.stdcall.} + IPropertyChange* {.pure.} = object + lpVtbl*: ptr IPropertyChangeVtbl + IPropertyChangeVtbl* {.pure, inheritable.} = object of IObjectWithPropertyKeyVtbl + ApplyToPropVariant*: proc(self: ptr IPropertyChange, propvarIn: REFPROPVARIANT, ppropvarOut: ptr PROPVARIANT): HRESULT {.stdcall.} + IPropertyChangeArray* {.pure.} = object + lpVtbl*: ptr IPropertyChangeArrayVtbl + IPropertyChangeArrayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IPropertyChangeArray, pcOperations: ptr UINT): HRESULT {.stdcall.} + GetAt*: proc(self: ptr IPropertyChangeArray, iIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + InsertAt*: proc(self: ptr IPropertyChangeArray, iIndex: UINT, ppropChange: ptr IPropertyChange): HRESULT {.stdcall.} + Append*: proc(self: ptr IPropertyChangeArray, ppropChange: ptr IPropertyChange): HRESULT {.stdcall.} + AppendOrReplace*: proc(self: ptr IPropertyChangeArray, ppropChange: ptr IPropertyChange): HRESULT {.stdcall.} + RemoveAt*: proc(self: ptr IPropertyChangeArray, iIndex: UINT): HRESULT {.stdcall.} + IsKeyInArray*: proc(self: ptr IPropertyChangeArray, key: REFPROPERTYKEY): HRESULT {.stdcall.} + IPropertyStoreCapabilities* {.pure.} = object + lpVtbl*: ptr IPropertyStoreCapabilitiesVtbl + IPropertyStoreCapabilitiesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsPropertyWritable*: proc(self: ptr IPropertyStoreCapabilities, key: REFPROPERTYKEY): HRESULT {.stdcall.} + IPropertyStoreCache* {.pure.} = object + lpVtbl*: ptr IPropertyStoreCacheVtbl + IPropertyStoreCacheVtbl* {.pure, inheritable.} = object of IPropertyStoreVtbl + GetState*: proc(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, pstate: ptr PSC_STATE): HRESULT {.stdcall.} + GetValueAndState*: proc(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT, pstate: ptr PSC_STATE): HRESULT {.stdcall.} + SetState*: proc(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, state: PSC_STATE): HRESULT {.stdcall.} + SetValueAndState*: proc(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT, state: PSC_STATE): HRESULT {.stdcall.} + IPropertyEnumType* {.pure.} = object + lpVtbl*: ptr IPropertyEnumTypeVtbl + IPropertyEnumTypeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetEnumType*: proc(self: ptr IPropertyEnumType, penumtype: ptr PROPENUMTYPE): HRESULT {.stdcall.} + GetValue*: proc(self: ptr IPropertyEnumType, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + GetRangeMinValue*: proc(self: ptr IPropertyEnumType, ppropvarMin: ptr PROPVARIANT): HRESULT {.stdcall.} + GetRangeSetValue*: proc(self: ptr IPropertyEnumType, ppropvarSet: ptr PROPVARIANT): HRESULT {.stdcall.} + GetDisplayText*: proc(self: ptr IPropertyEnumType, ppszDisplay: ptr LPWSTR): HRESULT {.stdcall.} + IPropertyEnumType2* {.pure.} = object + lpVtbl*: ptr IPropertyEnumType2Vtbl + IPropertyEnumType2Vtbl* {.pure, inheritable.} = object of IPropertyEnumTypeVtbl + GetImageReference*: proc(self: ptr IPropertyEnumType2, ppszImageRes: ptr LPWSTR): HRESULT {.stdcall.} + IPropertyEnumTypeList* {.pure.} = object + lpVtbl*: ptr IPropertyEnumTypeListVtbl + IPropertyEnumTypeListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IPropertyEnumTypeList, pctypes: ptr UINT): HRESULT {.stdcall.} + GetAt*: proc(self: ptr IPropertyEnumTypeList, itype: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetConditionAt*: proc(self: ptr IPropertyEnumTypeList, nIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + FindMatchingIndex*: proc(self: ptr IPropertyEnumTypeList, propvarCmp: REFPROPVARIANT, pnIndex: ptr UINT): HRESULT {.stdcall.} + IPropertyDescription* {.pure.} = object + lpVtbl*: ptr IPropertyDescriptionVtbl + IPropertyDescriptionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPropertyKey*: proc(self: ptr IPropertyDescription, pkey: ptr PROPERTYKEY): HRESULT {.stdcall.} + GetCanonicalName*: proc(self: ptr IPropertyDescription, ppszName: ptr LPWSTR): HRESULT {.stdcall.} + GetPropertyType*: proc(self: ptr IPropertyDescription, pvartype: ptr VARTYPE): HRESULT {.stdcall.} + GetDisplayName*: proc(self: ptr IPropertyDescription, ppszName: ptr LPWSTR): HRESULT {.stdcall.} + GetEditInvitation*: proc(self: ptr IPropertyDescription, ppszInvite: ptr LPWSTR): HRESULT {.stdcall.} + GetTypeFlags*: proc(self: ptr IPropertyDescription, mask: PROPDESC_TYPE_FLAGS, ppdtFlags: ptr PROPDESC_TYPE_FLAGS): HRESULT {.stdcall.} + GetViewFlags*: proc(self: ptr IPropertyDescription, ppdvFlags: ptr PROPDESC_VIEW_FLAGS): HRESULT {.stdcall.} + GetDefaultColumnWidth*: proc(self: ptr IPropertyDescription, pcxChars: ptr UINT): HRESULT {.stdcall.} + GetDisplayType*: proc(self: ptr IPropertyDescription, pdisplaytype: ptr PROPDESC_DISPLAYTYPE): HRESULT {.stdcall.} + GetColumnState*: proc(self: ptr IPropertyDescription, pcsFlags: ptr SHCOLSTATEF): HRESULT {.stdcall.} + GetGroupingRange*: proc(self: ptr IPropertyDescription, pgr: ptr PROPDESC_GROUPING_RANGE): HRESULT {.stdcall.} + GetRelativeDescriptionType*: proc(self: ptr IPropertyDescription, prdt: ptr PROPDESC_RELATIVEDESCRIPTION_TYPE): HRESULT {.stdcall.} + GetRelativeDescription*: proc(self: ptr IPropertyDescription, propvar1: REFPROPVARIANT, propvar2: REFPROPVARIANT, ppszDesc1: ptr LPWSTR, ppszDesc2: ptr LPWSTR): HRESULT {.stdcall.} + GetSortDescription*: proc(self: ptr IPropertyDescription, psd: ptr PROPDESC_SORTDESCRIPTION): HRESULT {.stdcall.} + GetSortDescriptionLabel*: proc(self: ptr IPropertyDescription, fDescending: WINBOOL, ppszDescription: ptr LPWSTR): HRESULT {.stdcall.} + GetAggregationType*: proc(self: ptr IPropertyDescription, paggtype: ptr PROPDESC_AGGREGATION_TYPE): HRESULT {.stdcall.} + GetConditionType*: proc(self: ptr IPropertyDescription, pcontype: ptr PROPDESC_CONDITION_TYPE, popDefault: ptr CONDITION_OPERATION): HRESULT {.stdcall.} + GetEnumTypeList*: proc(self: ptr IPropertyDescription, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + CoerceToCanonicalValue*: proc(self: ptr IPropertyDescription, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + FormatForDisplay*: proc(self: ptr IPropertyDescription, propvar: REFPROPVARIANT, pdfFlags: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr LPWSTR): HRESULT {.stdcall.} + IsValueCanonical*: proc(self: ptr IPropertyDescription, propvar: REFPROPVARIANT): HRESULT {.stdcall.} + IPropertyDescription2* {.pure.} = object + lpVtbl*: ptr IPropertyDescription2Vtbl + IPropertyDescription2Vtbl* {.pure, inheritable.} = object of IPropertyDescriptionVtbl + GetImageReferenceForValue*: proc(self: ptr IPropertyDescription2, propvar: REFPROPVARIANT, ppszImageRes: ptr LPWSTR): HRESULT {.stdcall.} + IPropertyDescriptionAliasInfo* {.pure.} = object + lpVtbl*: ptr IPropertyDescriptionAliasInfoVtbl + IPropertyDescriptionAliasInfoVtbl* {.pure, inheritable.} = object of IPropertyDescriptionVtbl + GetSortByAlias*: proc(self: ptr IPropertyDescriptionAliasInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetAdditionalSortByAliases*: proc(self: ptr IPropertyDescriptionAliasInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IPropertyDescriptionSearchInfo* {.pure.} = object + lpVtbl*: ptr IPropertyDescriptionSearchInfoVtbl + IPropertyDescriptionSearchInfoVtbl* {.pure, inheritable.} = object of IPropertyDescriptionVtbl + GetSearchInfoFlags*: proc(self: ptr IPropertyDescriptionSearchInfo, ppdsiFlags: ptr PROPDESC_SEARCHINFO_FLAGS): HRESULT {.stdcall.} + GetColumnIndexType*: proc(self: ptr IPropertyDescriptionSearchInfo, ppdciType: ptr PROPDESC_COLUMNINDEX_TYPE): HRESULT {.stdcall.} + GetProjectionString*: proc(self: ptr IPropertyDescriptionSearchInfo, ppszProjection: ptr LPWSTR): HRESULT {.stdcall.} + GetMaxSize*: proc(self: ptr IPropertyDescriptionSearchInfo, pcbMaxSize: ptr UINT): HRESULT {.stdcall.} + IPropertyDescriptionRelatedPropertyInfo* {.pure.} = object + lpVtbl*: ptr IPropertyDescriptionRelatedPropertyInfoVtbl + IPropertyDescriptionRelatedPropertyInfoVtbl* {.pure, inheritable.} = object of IPropertyDescriptionVtbl + GetRelatedProperty*: proc(self: ptr IPropertyDescriptionRelatedPropertyInfo, pszRelationshipName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IPropertySystem* {.pure.} = object + lpVtbl*: ptr IPropertySystemVtbl + IPropertySystemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPropertyDescription*: proc(self: ptr IPropertySystem, propkey: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyDescriptionByName*: proc(self: ptr IPropertySystem, pszCanonicalName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyDescriptionListFromString*: proc(self: ptr IPropertySystem, pszPropList: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + EnumeratePropertyDescriptions*: proc(self: ptr IPropertySystem, filterOn: PROPDESC_ENUMFILTER, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + FormatForDisplay*: proc(self: ptr IPropertySystem, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, pszText: LPWSTR, cchText: DWORD): HRESULT {.stdcall.} + FormatForDisplayAlloc*: proc(self: ptr IPropertySystem, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr LPWSTR): HRESULT {.stdcall.} + RegisterPropertySchema*: proc(self: ptr IPropertySystem, pszPath: LPCWSTR): HRESULT {.stdcall.} + UnregisterPropertySchema*: proc(self: ptr IPropertySystem, pszPath: LPCWSTR): HRESULT {.stdcall.} + RefreshPropertySchema*: proc(self: ptr IPropertySystem): HRESULT {.stdcall.} + IPropertyDescriptionList* {.pure.} = object + lpVtbl*: ptr IPropertyDescriptionListVtbl + IPropertyDescriptionListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IPropertyDescriptionList, pcElem: ptr UINT): HRESULT {.stdcall.} + GetAt*: proc(self: ptr IPropertyDescriptionList, iElem: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IPropertyStoreFactory* {.pure.} = object + lpVtbl*: ptr IPropertyStoreFactoryVtbl + IPropertyStoreFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPropertyStore*: proc(self: ptr IPropertyStoreFactory, flags: GETPROPERTYSTOREFLAGS, pUnkFactory: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyStoreForKeys*: proc(self: ptr IPropertyStoreFactory, rgKeys: ptr PROPERTYKEY, cKeys: UINT, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IDelayedPropertyStoreFactory* {.pure.} = object + lpVtbl*: ptr IDelayedPropertyStoreFactoryVtbl + IDelayedPropertyStoreFactoryVtbl* {.pure, inheritable.} = object of IPropertyStoreFactoryVtbl + GetDelayedPropertyStore*: proc(self: ptr IDelayedPropertyStoreFactory, flags: GETPROPERTYSTOREFLAGS, dwStoreId: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IPersistSerializedPropStorage* {.pure.} = object + lpVtbl*: ptr IPersistSerializedPropStorageVtbl + IPersistSerializedPropStorageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFlags*: proc(self: ptr IPersistSerializedPropStorage, flags: PERSIST_SPROPSTORE_FLAGS): HRESULT {.stdcall.} + SetPropertyStorage*: proc(self: ptr IPersistSerializedPropStorage, psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD): HRESULT {.stdcall.} + GetPropertyStorage*: proc(self: ptr IPersistSerializedPropStorage, ppsps: ptr ptr SERIALIZEDPROPSTORAGE, pcb: ptr DWORD): HRESULT {.stdcall.} + IPersistSerializedPropStorage2* {.pure.} = object + lpVtbl*: ptr IPersistSerializedPropStorage2Vtbl + IPersistSerializedPropStorage2Vtbl* {.pure, inheritable.} = object of IPersistSerializedPropStorageVtbl + GetPropertyStorageSize*: proc(self: ptr IPersistSerializedPropStorage2, pcb: ptr DWORD): HRESULT {.stdcall.} + GetPropertyStorageBuffer*: proc(self: ptr IPersistSerializedPropStorage2, psps: ptr SERIALIZEDPROPSTORAGE, cb: DWORD, pcbWritten: ptr DWORD): HRESULT {.stdcall.} + IPropertySystemChangeNotify* {.pure.} = object + lpVtbl*: ptr IPropertySystemChangeNotifyVtbl + IPropertySystemChangeNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SchemaRefreshed*: proc(self: ptr IPropertySystemChangeNotify): HRESULT {.stdcall.} + ICreateObject* {.pure.} = object + lpVtbl*: ptr ICreateObjectVtbl + ICreateObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateObject*: proc(self: ptr ICreateObject, clsid: REFCLSID, pUnkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} +proc SysAllocString*(P1: ptr OLECHAR): BSTR {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysReAllocString*(P1: ptr BSTR, P2: ptr OLECHAR): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysAllocStringLen*(P1: ptr OLECHAR, P2: UINT): BSTR {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysReAllocStringLen*(P1: ptr BSTR, P2: ptr OLECHAR, P3: UINT): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysFreeString*(P1: BSTR): void {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysStringLen*(P1: BSTR): UINT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysStringByteLen*(bstr: BSTR): UINT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SysAllocStringByteLen*(psz: LPCSTR, len: UINT): BSTR {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc DosDateTimeToVariantTime*(wDosDate: USHORT, wDosTime: USHORT, pvtime: ptr DOUBLE): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantTimeToDosDateTime*(vtime: DOUBLE, pwDosDate: ptr USHORT, pwDosTime: ptr USHORT): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SystemTimeToVariantTime*(lpSystemTime: LPSYSTEMTIME, pvtime: ptr DOUBLE): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantTimeToSystemTime*(vtime: DOUBLE, lpSystemTime: LPSYSTEMTIME): INT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayAllocDescriptor*(cDims: UINT, ppsaOut: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayAllocDescriptorEx*(vt: VARTYPE, cDims: UINT, ppsaOut: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayAllocData*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCreate*(vt: VARTYPE, cDims: UINT, rgsabound: ptr SAFEARRAYBOUND): ptr SAFEARRAY {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCreateEx*(vt: VARTYPE, cDims: UINT, rgsabound: ptr SAFEARRAYBOUND, pvExtra: PVOID): ptr SAFEARRAY {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCopyData*(psaSource: ptr SAFEARRAY, psaTarget: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayDestroyDescriptor*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayDestroyData*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayDestroy*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayRedim*(psa: ptr SAFEARRAY, psaboundNew: ptr SAFEARRAYBOUND): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetDim*(psa: ptr SAFEARRAY): UINT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetElemsize*(psa: ptr SAFEARRAY): UINT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetUBound*(psa: ptr SAFEARRAY, nDim: UINT, plUbound: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetLBound*(psa: ptr SAFEARRAY, nDim: UINT, plLbound: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayLock*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayUnlock*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayAccessData*(psa: ptr SAFEARRAY, ppvData: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayUnaccessData*(psa: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetElement*(psa: ptr SAFEARRAY, rgIndices: ptr LONG, pv: pointer): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayPutElement*(psa: ptr SAFEARRAY, rgIndices: ptr LONG, pv: pointer): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCopy*(psa: ptr SAFEARRAY, ppsaOut: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayPtrOfIndex*(psa: ptr SAFEARRAY, rgIndices: ptr LONG, ppvData: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArraySetRecordInfo*(psa: ptr SAFEARRAY, prinfo: ptr IRecordInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetRecordInfo*(psa: ptr SAFEARRAY, prinfo: ptr ptr IRecordInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArraySetIID*(psa: ptr SAFEARRAY, guid: REFGUID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetIID*(psa: ptr SAFEARRAY, pguid: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayGetVartype*(psa: ptr SAFEARRAY, pvt: ptr VARTYPE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCreateVector*(vt: VARTYPE, lLbound: LONG, cElements: ULONG): ptr SAFEARRAY {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SafeArrayCreateVectorEx*(vt: VARTYPE, lLbound: LONG, cElements: ULONG, pvExtra: PVOID): ptr SAFEARRAY {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantInit*(pvarg: ptr VARIANTARG): void {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantClear*(pvarg: ptr VARIANTARG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantCopy*(pvargDest: ptr VARIANTARG, pvargSrc: ptr VARIANTARG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantCopyInd*(pvarDest: ptr VARIANT, pvargSrc: ptr VARIANTARG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantChangeType*(pvargDest: ptr VARIANTARG, pvarSrc: ptr VARIANTARG, wFlags: USHORT, vt: VARTYPE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VariantChangeTypeEx*(pvargDest: ptr VARIANTARG, pvarSrc: ptr VARIANTARG, lcid: LCID, wFlags: USHORT, vt: VARTYPE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VectorFromBstr*(bstr: BSTR, ppsa: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc BstrFromVector*(psa: ptr SAFEARRAY, pbstr: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromI2*(sIn: SHORT, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromI4*(lIn: LONG, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromI8*(i64In: LONG64, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromR4*(fltIn: FLOAT, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromR8*(dblIn: DOUBLE, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromCy*(cyIn: CY, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromDate*(dateIn: DATE, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromBool*(boolIn: VARIANT_BOOL, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromI1*(cIn: CHAR, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromUI2*(uiIn: USHORT, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromUI4*(ulIn: ULONG, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromUI8*(ui64In: ULONG64, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromDec*(pdecIn: ptr DECIMAL, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromUI1*(bIn: BYTE, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromI4*(lIn: LONG, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromI8*(i64In: LONG64, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromR4*(fltIn: FLOAT, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromR8*(dblIn: DOUBLE, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromCy*(cyIn: CY, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromDate*(dateIn: DATE, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromBool*(boolIn: VARIANT_BOOL, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromI1*(cIn: CHAR, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromUI2*(uiIn: USHORT, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromUI4*(ulIn: ULONG, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromUI8*(ui64In: ULONG64, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI2FromDec*(pdecIn: ptr DECIMAL, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromUI1*(bIn: BYTE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromI2*(sIn: SHORT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromI8*(i64In: LONG64, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromR4*(fltIn: FLOAT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromR8*(dblIn: DOUBLE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromCy*(cyIn: CY, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromDate*(dateIn: DATE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromBool*(boolIn: VARIANT_BOOL, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromI1*(cIn: CHAR, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromUI2*(uiIn: USHORT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromUI4*(ulIn: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromUI8*(ui64In: ULONG64, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI4FromDec*(pdecIn: ptr DECIMAL, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromUI1*(bIn: BYTE, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromI2*(sIn: SHORT, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromR4*(fltIn: FLOAT, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromR8*(dblIn: DOUBLE, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromCy*(cyIn: CY, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromDate*(dateIn: DATE, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: int32, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromBool*(boolIn: VARIANT_BOOL, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromI1*(cIn: CHAR, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromUI2*(uiIn: USHORT, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromUI4*(ulIn: ULONG, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromUI8*(ui64In: ULONG64, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI8FromDec*(pdecIn: ptr DECIMAL, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromUI1*(bIn: BYTE, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromI2*(sIn: SHORT, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromI4*(lIn: LONG, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromI8*(i64In: LONG64, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromR8*(dblIn: DOUBLE, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromCy*(cyIn: CY, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromDate*(dateIn: DATE, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromBool*(boolIn: VARIANT_BOOL, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromI1*(cIn: CHAR, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromUI2*(uiIn: USHORT, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromUI4*(ulIn: ULONG, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromUI8*(ui64In: ULONG64, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4FromDec*(pdecIn: ptr DECIMAL, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromUI1*(bIn: BYTE, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromI2*(sIn: SHORT, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromI4*(lIn: LONG, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromI8*(i64In: LONG64, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromR4*(fltIn: FLOAT, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromCy*(cyIn: CY, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromDate*(dateIn: DATE, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromBool*(boolIn: VARIANT_BOOL, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromI1*(cIn: CHAR, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromUI2*(uiIn: USHORT, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromUI4*(ulIn: ULONG, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromUI8*(ui64In: ULONG64, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8FromDec*(pdecIn: ptr DECIMAL, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUI1*(bIn: BYTE, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromI2*(sIn: SHORT, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromI4*(lIn: LONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromI8*(i64In: LONG64, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromR4*(fltIn: FLOAT, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromR8*(dblIn: DOUBLE, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromCy*(cyIn: CY, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromBool*(boolIn: VARIANT_BOOL, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromI1*(cIn: CHAR, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUI2*(uiIn: USHORT, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUI4*(ulIn: ULONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUI8*(ui64In: ULONG64, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromDec*(pdecIn: ptr DECIMAL, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromUI1*(bIn: BYTE, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromI2*(sIn: SHORT, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromI4*(lIn: LONG, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromI8*(i64In: LONG64, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromR4*(fltIn: FLOAT, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromR8*(dblIn: DOUBLE, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromDate*(dateIn: DATE, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromBool*(boolIn: VARIANT_BOOL, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromI1*(cIn: CHAR, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromUI2*(uiIn: USHORT, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromUI4*(ulIn: ULONG, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromUI8*(ui64In: ULONG64, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFromDec*(pdecIn: ptr DECIMAL, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromUI1*(bVal: BYTE, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromI2*(iVal: SHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromI4*(lIn: LONG, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromI8*(i64In: LONG64, lcid: LCID, dwFlags: int32, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromR4*(fltIn: FLOAT, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromR8*(dblIn: DOUBLE, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromCy*(cyIn: CY, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromDate*(dateIn: DATE, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromBool*(boolIn: VARIANT_BOOL, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromI1*(cIn: CHAR, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromUI2*(uiIn: USHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromUI4*(ulIn: ULONG, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromUI8*(ui64In: ULONG64, lcid: LCID, dwFlags: int32, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrFromDec*(pdecIn: ptr DECIMAL, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromUI1*(bIn: BYTE, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromI2*(sIn: SHORT, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromI4*(lIn: LONG, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromI8*(i64In: LONG64, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromR4*(fltIn: FLOAT, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromR8*(dblIn: DOUBLE, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromDate*(dateIn: DATE, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromCy*(cyIn: CY, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromI1*(cIn: CHAR, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromUI2*(uiIn: USHORT, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromUI4*(ulIn: ULONG, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromUI8*(i64In: ULONG64, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBoolFromDec*(pdecIn: ptr DECIMAL, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromUI1*(bIn: BYTE, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromI2*(uiIn: SHORT, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromI4*(lIn: LONG, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromI8*(i64In: LONG64, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromR4*(fltIn: FLOAT, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromR8*(dblIn: DOUBLE, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromDate*(dateIn: DATE, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromCy*(cyIn: CY, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromBool*(boolIn: VARIANT_BOOL, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromUI2*(uiIn: USHORT, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromUI4*(ulIn: ULONG, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromUI8*(i64In: ULONG64, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarI1FromDec*(pdecIn: ptr DECIMAL, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromUI1*(bIn: BYTE, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromI2*(uiIn: SHORT, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromI4*(lIn: LONG, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromI8*(i64In: LONG64, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromR4*(fltIn: FLOAT, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromR8*(dblIn: DOUBLE, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromDate*(dateIn: DATE, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromCy*(cyIn: CY, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromBool*(boolIn: VARIANT_BOOL, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromI1*(cIn: CHAR, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromUI4*(ulIn: ULONG, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromUI8*(i64In: ULONG64, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI2FromDec*(pdecIn: ptr DECIMAL, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromUI1*(bIn: BYTE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromI2*(uiIn: SHORT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromI4*(lIn: LONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromI8*(i64In: LONG64, plOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromR4*(fltIn: FLOAT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromR8*(dblIn: DOUBLE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromDate*(dateIn: DATE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromCy*(cyIn: CY, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromBool*(boolIn: VARIANT_BOOL, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromI1*(cIn: CHAR, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromUI2*(uiIn: USHORT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromUI8*(ui64In: ULONG64, plOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI4FromDec*(pdecIn: ptr DECIMAL, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromUI1*(bIn: BYTE, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromI2*(sIn: SHORT, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromI8*(ui64In: LONG64, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromR4*(fltIn: FLOAT, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromR8*(dblIn: DOUBLE, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromCy*(cyIn: CY, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromDate*(dateIn: DATE, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: int32, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromBool*(boolIn: VARIANT_BOOL, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromI1*(cIn: CHAR, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromUI2*(uiIn: USHORT, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromUI4*(ulIn: ULONG, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI8FromDec*(pdecIn: ptr DECIMAL, pi64Out: ptr ULONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromUI1*(bIn: BYTE, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromI2*(uiIn: SHORT, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromI4*(lIn: LONG, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromI8*(i64In: LONG64, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromR4*(fltIn: FLOAT, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromR8*(dblIn: DOUBLE, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromDate*(dateIn: DATE, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromCy*(cyIn: CY, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromBool*(boolIn: VARIANT_BOOL, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromI1*(cIn: CHAR, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromUI2*(uiIn: USHORT, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromUI4*(ulIn: ULONG, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFromUI8*(ui64In: ULONG64, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUI1FromInt*(lIn: LONG, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI1FromI4".} +proc VarUI1FromUint*(ulIn: ULONG, pbOut: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI1FromUI4".} +proc VarI2FromInt*(lIn: LONG, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI2FromI4".} +proc VarI2FromUint*(ulIn: ULONG, psOut: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI2FromUI4".} +proc VarI4FromUint*(ulIn: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI4".} +proc VarI8FromUint*(ulIn: ULONG, pi64Out: ptr LONG64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI8FromUI4".} +proc VarR4FromInt*(lIn: LONG, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarR4FromI4".} +proc VarR4FromUint*(ulIn: ULONG, pfltOut: ptr FLOAT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarR4FromUI4".} +proc VarR8FromInt*(lIn: LONG, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarR8FromI4".} +proc VarR8FromUint*(ulIn: ULONG, pdblOut: ptr DOUBLE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarR8FromUI4".} +proc VarDateFromInt*(lIn: LONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarDateFromI4".} +proc VarDateFromUint*(ulIn: ULONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarDateFromUI4".} +proc VarCyFromInt*(lIn: LONG, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarCyFromI4".} +proc VarCyFromUint*(ulIn: ULONG, pcyOut: ptr CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarCyFromUI4".} +proc VarBstrFromInt*(lIn: LONG, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarBstrFromI4".} +proc VarBstrFromUint*(ulIn: ULONG, lcid: LCID, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarBstrFromUI4".} +proc VarBoolFromInt*(lIn: LONG, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarBoolFromI4".} +proc VarBoolFromUint*(ulIn: ULONG, pboolOut: ptr VARIANT_BOOL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarBoolFromUI4".} +proc VarI1FromInt*(lIn: LONG, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI1FromI4".} +proc VarI1FromUint*(ulIn: ULONG, pcOut: ptr CHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI1FromUI4".} +proc VarUI2FromInt*(lIn: LONG, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI2FromI4".} +proc VarUI2FromUint*(ulIn: ULONG, puiOut: ptr USHORT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI2FromUI4".} +proc VarUI4FromInt*(lIn: LONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI4".} +proc VarDecFromInt*(lIn: LONG, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarDecFromI4".} +proc VarDecFromUint*(ulIn: ULONG, pdecOut: ptr DECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarDecFromUI4".} +proc VarIntFromUI1*(bIn: BYTE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI1".} +proc VarIntFromI2*(sIn: SHORT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromI2".} +proc VarIntFromI8*(i64In: LONG64, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromI8".} +proc VarIntFromR4*(fltIn: FLOAT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromR4".} +proc VarIntFromR8*(dblIn: DOUBLE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromR8".} +proc VarIntFromDate*(dateIn: DATE, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromDate".} +proc VarIntFromCy*(cyIn: CY, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromCy".} +proc VarIntFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromStr".} +proc VarIntFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromDisp".} +proc VarIntFromBool*(boolIn: VARIANT_BOOL, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromBool".} +proc VarIntFromI1*(cIn: CHAR, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromI1".} +proc VarIntFromUI2*(uiIn: USHORT, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI2".} +proc VarIntFromUI4*(ulIn: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI4".} +proc VarIntFromUI8*(ui64In: ULONG64, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI8".} +proc VarIntFromDec*(pdecIn: ptr DECIMAL, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromDec".} +proc VarIntFromUint*(ulIn: ULONG, plOut: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarI4FromUI4".} +proc VarUintFromUI1*(bIn: BYTE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromUI1".} +proc VarUintFromI2*(uiIn: SHORT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI2".} +proc VarUintFromI4*(lIn: LONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI4".} +proc VarUintFromI8*(i64In: LONG64, plOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI8".} +proc VarUintFromR4*(fltIn: FLOAT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromR4".} +proc VarUintFromR8*(dblIn: DOUBLE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromR8".} +proc VarUintFromDate*(dateIn: DATE, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromDate".} +proc VarUintFromCy*(cyIn: CY, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromCy".} +proc VarUintFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromStr".} +proc VarUintFromDisp*(pdispIn: ptr IDispatch, lcid: LCID, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromDisp".} +proc VarUintFromBool*(boolIn: VARIANT_BOOL, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromBool".} +proc VarUintFromI1*(cIn: CHAR, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI1".} +proc VarUintFromUI2*(uiIn: USHORT, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromUI2".} +proc VarUintFromUI8*(ui64In: ULONG64, plOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromUI8".} +proc VarUintFromDec*(pdecIn: ptr DECIMAL, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromDec".} +proc VarUintFromInt*(lIn: LONG, pulOut: ptr ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc: "VarUI4FromI4".} +proc VarParseNumFromStr*(strIn: ptr OLECHAR, lcid: LCID, dwFlags: ULONG, pnumprs: ptr NUMPARSE, rgbDig: ptr BYTE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarNumFromParseNum*(pnumprs: ptr NUMPARSE, rgbDig: ptr BYTE, dwVtBits: ULONG, pvar: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarAdd*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarAnd*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCat*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDiv*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarEqv*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarIdiv*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarImp*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarMod*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarMul*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarOr*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarPow*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarSub*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarXor*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarAbs*(pvarIn: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFix*(pvarIn: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarInt*(pvarIn: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarNeg*(pvarIn: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarNot*(pvarIn: LPVARIANT, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarRound*(pvarIn: LPVARIANT, cDecimals: int32, pvarResult: LPVARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCmp*(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, lcid: LCID, dwFlags: ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecAdd*(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecDiv*(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecMul*(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecSub*(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecAbs*(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecFix*(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecInt*(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecNeg*(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecRound*(pdecIn: LPDECIMAL, cDecimals: int32, pdecResult: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecCmp*(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDecCmpR8*(pdecLeft: LPDECIMAL, dblRight: float64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyAdd*(cyLeft: CY, cyRight: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyMul*(cyLeft: CY, cyRight: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyMulI4*(cyLeft: CY, lRight: int32, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyMulI8*(cyLeft: CY, lRight: LONG64, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCySub*(cyLeft: CY, cyRight: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyAbs*(cyIn: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyFix*(cyIn: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyInt*(cyIn: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyNeg*(cyIn: CY, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyRound*(cyIn: CY, cDecimals: int32, pcyResult: LPCY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyCmp*(cyLeft: CY, cyRight: CY): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarCyCmpR8*(cyLeft: CY, dblRight: float64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrCat*(bstrLeft: BSTR, bstrRight: BSTR, pbstrResult: LPBSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarBstrCmp*(bstrLeft: BSTR, bstrRight: BSTR, lcid: LCID, dwFlags: ULONG): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8Pow*(dblLeft: float64, dblRight: float64, pdblResult: ptr float64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR4CmpR8*(fltLeft: float32, dblRight: float64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarR8Round*(dblIn: float64, cDecimals: int32, pdblResult: ptr float64): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUdate*(pudateIn: ptr UDATE, dwFlags: ULONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarDateFromUdateEx*(pudateIn: ptr UDATE, lcid: LCID, dwFlags: ULONG, pdateOut: ptr DATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarUdateFromDate*(dateIn: DATE, dwFlags: ULONG, pudateOut: ptr UDATE): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc GetAltMonthNames*(lcid: LCID, prgp: ptr ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormat*(pvarIn: LPVARIANT, pstrFormat: LPOLESTR, iFirstDay: int32, iFirstWeek: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormatDateTime*(pvarIn: LPVARIANT, iNamedFormat: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormatNumber*(pvarIn: LPVARIANT, iNumDig: int32, iIncLead: int32, iUseParens: int32, iGroup: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormatPercent*(pvarIn: LPVARIANT, iNumDig: int32, iIncLead: int32, iUseParens: int32, iGroup: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormatCurrency*(pvarIn: LPVARIANT, iNumDig: int32, iIncLead: int32, iUseParens: int32, iGroup: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarWeekdayName*(iWeekday: int32, fAbbrev: int32, iFirstDay: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarMonthName*(iMonth: int32, fAbbrev: int32, dwFlags: ULONG, pbstrOut: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarFormatFromTokens*(pvarIn: LPVARIANT, pstrFormat: LPOLESTR, pbTokCur: LPBYTE, dwFlags: ULONG, pbstrOut: ptr BSTR, lcid: LCID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc VarTokenizeFormatString*(pstrFormat: LPOLESTR, rgbTok: LPBYTE, cbTok: int32, iFirstDay: int32, iFirstWeek: int32, lcid: LCID, pcbActual: ptr int32): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc LHashValOfNameSysA*(syskind: SYSKIND, lcid: LCID, szName: LPCSTR): ULONG {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc LHashValOfNameSys*(syskind: SYSKIND, lcid: LCID, szName: ptr OLECHAR): ULONG {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc LoadTypeLib*(szFile: ptr OLECHAR, pptlib: ptr ptr ITypeLib): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc LoadTypeLibEx*(szFile: LPCOLESTR, regkind: REGKIND, pptlib: ptr ptr ITypeLib): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc LoadRegTypeLib*(rguid: REFGUID, wVerMajor: WORD, wVerMinor: WORD, lcid: LCID, pptlib: ptr ptr ITypeLib): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc QueryPathOfRegTypeLib*(guid: REFGUID, wMaj: USHORT, wMin: USHORT, lcid: LCID, lpbstrPathName: LPBSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc RegisterTypeLib*(ptlib: ptr ITypeLib, szFullPath: ptr OLECHAR, szHelpDir: ptr OLECHAR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc UnRegisterTypeLib*(libID: REFGUID, wVerMajor: WORD, wVerMinor: WORD, lcid: LCID, syskind: SYSKIND): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc CreateTypeLib*(syskind: SYSKIND, szFile: ptr OLECHAR, ppctlib: ptr ptr ICreateTypeLib): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc CreateTypeLib2*(syskind: SYSKIND, szFile: LPCOLESTR, ppctlib: ptr ptr ICreateTypeLib2): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc DispGetParam*(pdispparams: ptr DISPPARAMS, position: UINT, vtTarg: VARTYPE, pvarResult: ptr VARIANT, puArgErr: ptr UINT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc DispGetIDsOfNames*(ptinfo: ptr ITypeInfo, rgszNames: ptr ptr OLECHAR, cNames: UINT, rgdispid: ptr DISPID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc DispInvoke*(this: pointer, ptinfo: ptr ITypeInfo, dispidMember: DISPID, wFlags: WORD, pparams: ptr DISPPARAMS, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc CreateDispTypeInfo*(pidata: ptr INTERFACEDATA, lcid: LCID, pptinfo: ptr ptr ITypeInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc CreateStdDispatch*(punkOuter: ptr IUnknown, pvThis: pointer, ptinfo: ptr ITypeInfo, ppunkStdDisp: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc DispCallFunc*(pvInstance: pointer, oVft: ULONG_PTR, cc: CALLCONV, vtReturn: VARTYPE, cActuals: UINT, prgvt: ptr VARTYPE, prgpvarg: ptr ptr VARIANTARG, pvargResult: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc RegisterActiveObject*(punk: ptr IUnknown, rclsid: REFCLSID, dwFlags: DWORD, pdwRegister: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc RevokeActiveObject*(dwRegister: DWORD, pvReserved: pointer): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc GetActiveObject*(rclsid: REFCLSID, pvReserved: pointer, ppunk: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc SetErrorInfo*(dwReserved: ULONG, perrinfo: ptr IErrorInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc GetErrorInfo*(dwReserved: ULONG, pperrinfo: ptr ptr IErrorInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc CreateErrorInfo*(pperrinfo: ptr ptr ICreateErrorInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc GetRecordInfoFromTypeInfo*(pTypeInfo: ptr ITypeInfo, ppRecInfo: ptr ptr IRecordInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc GetRecordInfoFromGuids*(rGuidTypeLib: REFGUID, uVerMajor: ULONG, uVerMinor: ULONG, lcid: LCID, rGuidTypeInfo: REFGUID, ppRecInfo: ptr ptr IRecordInfo): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OaBuildVersion*(): ULONG {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc ClearCustData*(pCustData: LPCUSTDATA): void {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleBuildVersion*(): DWORD {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateDataAdviseHolder*(ppDAHolder: ptr LPDATAADVISEHOLDER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc ReadClassStg*(pStg: LPSTORAGE, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc WriteClassStg*(pStg: LPSTORAGE, rclsid: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc ReadClassStm*(pStm: LPSTREAM, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc WriteClassStm*(pStm: LPSTREAM, rclsid: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc WriteFmtUserTypeStg*(pstg: LPSTORAGE, cf: CLIPFORMAT, lpszUserType: LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc ReadFmtUserTypeStg*(pstg: LPSTORAGE, pcf: ptr CLIPFORMAT, lplpszUserType: ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleInitialize*(pvReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleUninitialize*(): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleQueryLinkFromData*(pSrcDataObject: LPDATAOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleQueryCreateFromData*(pSrcDataObject: LPDATAOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreate*(rclsid: REFCLSID, riid: REFIID, renderopt: DWORD, pFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateEx*(rclsid: REFCLSID, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateFromData*(pSrcDataObj: LPDATAOBJECT, riid: REFIID, renderopt: DWORD, pFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateFromDataEx*(pSrcDataObj: LPDATAOBJECT, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLinkFromData*(pSrcDataObj: LPDATAOBJECT, riid: REFIID, renderopt: DWORD, pFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLinkFromDataEx*(pSrcDataObj: LPDATAOBJECT, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateStaticFromData*(pSrcDataObj: LPDATAOBJECT, iid: REFIID, renderopt: DWORD, pFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLink*(pmkLinkSrc: LPMONIKER, riid: REFIID, renderopt: DWORD, lpFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLinkEx*(pmkLinkSrc: LPMONIKER, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLinkToFile*(lpszFileName: LPCOLESTR, riid: REFIID, renderopt: DWORD, lpFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateLinkToFileEx*(lpszFileName: LPCOLESTR, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateFromFile*(rclsid: REFCLSID, lpszFileName: LPCOLESTR, riid: REFIID, renderopt: DWORD, lpFormatEtc: LPFORMATETC, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateFromFileEx*(rclsid: REFCLSID, lpszFileName: LPCOLESTR, riid: REFIID, dwFlags: DWORD, renderopt: DWORD, cFormats: ULONG, rgAdvf: ptr DWORD, rgFormatEtc: LPFORMATETC, lpAdviseSink: ptr IAdviseSink, rgdwConnection: ptr DWORD, pClientSite: LPOLECLIENTSITE, pStg: LPSTORAGE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleLoad*(pStg: LPSTORAGE, riid: REFIID, pClientSite: LPOLECLIENTSITE, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSave*(pPS: LPPERSISTSTORAGE, pStg: LPSTORAGE, fSameAsLoad: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleLoadFromStream*(pStm: LPSTREAM, iidInterface: REFIID, ppvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSaveToStream*(pPStm: LPPERSISTSTREAM, pStm: LPSTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSetContainedObject*(pUnknown: LPUNKNOWN, fContained: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleNoteObjectVisible*(pUnknown: LPUNKNOWN, fVisible: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc RegisterDragDrop*(hwnd: HWND, pDropTarget: LPDROPTARGET): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc RevokeDragDrop*(hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc DoDragDrop*(pDataObj: LPDATAOBJECT, pDropSource: LPDROPSOURCE, dwOKEffects: DWORD, pdwEffect: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSetClipboard*(pDataObj: LPDATAOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleGetClipboard*(ppDataObj: ptr LPDATAOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleFlushClipboard*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleIsCurrentClipboard*(pDataObj: LPDATAOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateMenuDescriptor*(hmenuCombined: HMENU, lpMenuWidths: LPOLEMENUGROUPWIDTHS): HOLEMENU {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSetMenuDescriptor*(holemenu: HOLEMENU, hwndFrame: HWND, hwndActiveObject: HWND, lpFrame: LPOLEINPLACEFRAME, lpActiveObj: LPOLEINPLACEACTIVEOBJECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleDestroyMenuDescriptor*(holemenu: HOLEMENU): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleTranslateAccelerator*(lpFrame: LPOLEINPLACEFRAME, lpFrameInfo: LPOLEINPLACEFRAMEINFO, lpmsg: LPMSG): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleDuplicateData*(hSrc: HANDLE, cfFormat: CLIPFORMAT, uiFlags: UINT): HANDLE {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleDraw*(pUnknown: LPUNKNOWN, dwAspect: DWORD, hdcDraw: HDC, lprcBounds: LPCRECT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleRun*(pUnknown: LPUNKNOWN): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleIsRunning*(pObject: LPOLEOBJECT): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleLockRunning*(pUnknown: LPUNKNOWN, fLock: WINBOOL, fLastUnlockCloses: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc ReleaseStgMedium*(P1: LPSTGMEDIUM): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateOleAdviseHolder*(ppOAHolder: ptr LPOLEADVISEHOLDER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateDefaultHandler*(clsid: REFCLSID, pUnkOuter: LPUNKNOWN, riid: REFIID, lplpObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleCreateEmbeddingHelper*(clsid: REFCLSID, pUnkOuter: LPUNKNOWN, flags: DWORD, pCF: LPCLASSFACTORY, riid: REFIID, lplpObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc IsAccelerator*(hAccel: HACCEL, cAccelEntries: int32, lpMsg: LPMSG, lpwCmd: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleGetIconOfFile*(lpszPath: LPOLESTR, fUseFileAsLabel: WINBOOL): HGLOBAL {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleGetIconOfClass*(rclsid: REFCLSID, lpszLabel: LPOLESTR, fUseTypeAsLabel: WINBOOL): HGLOBAL {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleMetafilePictFromIconAndLabel*(hIcon: HICON, lpszLabel: LPOLESTR, lpszSourceFile: LPOLESTR, iIconIndex: UINT): HGLOBAL {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleRegGetUserType*(clsid: REFCLSID, dwFormOfType: DWORD, pszUserType: ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleRegGetMiscStatus*(clsid: REFCLSID, dwAspect: DWORD, pdwStatus: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleRegEnumFormatEtc*(clsid: REFCLSID, dwDirection: DWORD, ppenum: ptr LPENUMFORMATETC): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleRegEnumVerbs*(clsid: REFCLSID, ppenum: ptr LPENUMOLEVERB): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleConvertOLESTREAMToIStorage*(lpolestream: LPOLESTREAM, pstg: LPSTORAGE, ptd: ptr DVTARGETDEVICE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleConvertIStorageToOLESTREAM*(pstg: LPSTORAGE, lpolestream: LPOLESTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc GetHGlobalFromILockBytes*(plkbyt: LPLOCKBYTES, phglobal: ptr HGLOBAL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateILockBytesOnHGlobal*(hGlobal: HGLOBAL, fDeleteOnRelease: WINBOOL, pplkbyt: ptr LPLOCKBYTES): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleDoAutoConvert*(pStg: LPSTORAGE, pClsidNew: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleGetAutoConvert*(clsidOld: REFCLSID, pClsidNew: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleSetAutoConvert*(clsidOld: REFCLSID, clsidNew: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc GetConvertStg*(pStg: LPSTORAGE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc SetConvertStg*(pStg: LPSTORAGE, fConvert: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleConvertIStorageToOLESTREAMEx*(pstg: LPSTORAGE, cfFormat: CLIPFORMAT, lWidth: LONG, lHeight: LONG, dwSize: DWORD, pmedium: LPSTGMEDIUM, polestm: LPOLESTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc OleConvertOLESTREAMToIStorageEx*(polestm: LPOLESTREAM, pstg: LPSTORAGE, pcfFormat: ptr CLIPFORMAT, plwWidth: ptr LONG, plHeight: ptr LONG, pdwSize: ptr DWORD, pmedium: LPSTGMEDIUM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateStreamOnHGlobal*(hGlobal: HGLOBAL, fDeleteOnRelease: WINBOOL, ppstm: ptr LPSTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc GetHGlobalFromStream*(pstm: LPSTREAM, phglobal: ptr HGLOBAL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoUninitialize*(): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoInitializeEx*(pvReserved: LPVOID, dwCoInit: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetCurrentLogicalThreadId*(pguid: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetContextToken*(pToken: ptr ULONG_PTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetApartmentType*(pAptType: ptr APTTYPE, pAptQualifier: ptr APTTYPEQUALIFIER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetObjectContext*(riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterClassObject*(rclsid: REFCLSID, pUnk: LPUNKNOWN, dwClsContext: DWORD, flags: DWORD, lpdwRegister: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRevokeClassObject*(dwRegister: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoResumeClassObjects*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoSuspendClassObjects*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetMalloc*(dwMemContext: DWORD, ppMalloc: ptr LPMALLOC): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetCurrentProcess*(): DWORD {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetCallerTID*(lpdwTID: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetDefaultContext*(aptType: APTTYPE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDecodeProxy*(dwClientPid: DWORD, ui64ProxyAddress: UINT64, pServerInformation: PServerInformation): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoIncrementMTAUsage*(pCookie: ptr CO_MTA_USAGE_COOKIE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDecrementMTAUsage*(Cookie: CO_MTA_USAGE_COOKIE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoWaitForMultipleObjects*(dwFlags: DWORD, dwTimeout: DWORD, cHandles: ULONG, pHandles: ptr HANDLE, lpdwindex: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoAllowUnmarshalerCLSID*(clsid: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetClassObject*(rclsid: REFCLSID, dwClsContext: DWORD, pvReserved: LPVOID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoAddRefServerProcess*(): ULONG {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoReleaseServerProcess*(): ULONG {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetPSClsid*(riid: REFIID, pClsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterPSClsid*(riid: REFIID, rclsid: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterSurrogate*(pSurrogate: LPSURROGATE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoMarshalHresult*(pstm: LPSTREAM, hresult: HRESULT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoUnmarshalHresult*(pstm: LPSTREAM, phresult: ptr HRESULT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoLockObjectExternal*(pUnk: LPUNKNOWN, fLock: WINBOOL, fLastUnlockReleases: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetStdMarshalEx*(pUnkOuter: LPUNKNOWN, smexflags: DWORD, ppUnkInner: ptr LPUNKNOWN): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetMarshalSizeMax*(pulSize: ptr ULONG, riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoMarshalInterface*(pStm: LPSTREAM, riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoUnmarshalInterface*(pStm: LPSTREAM, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoReleaseMarshalData*(pStm: LPSTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDisconnectObject*(pUnk: LPUNKNOWN, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetStandardMarshal*(riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD, ppMarshal: ptr LPMARSHAL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoMarshalInterThreadInterfaceInStream*(riid: REFIID, pUnk: LPUNKNOWN, ppStm: ptr LPSTREAM): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetInterfaceAndReleaseStream*(pStm: LPSTREAM, iid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCreateFreeThreadedMarshaler*(punkOuter: LPUNKNOWN, ppunkMarshal: ptr LPUNKNOWN): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFreeUnusedLibraries*(): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFreeUnusedLibrariesEx*(dwUnloadDelay: DWORD, dwReserved: DWORD): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoInitializeSecurity*(pSecDesc: PSECURITY_DESCRIPTOR, cAuthSvc: LONG, asAuthSvc: ptr SOLE_AUTHENTICATION_SERVICE, pReserved1: pointer, dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthList: pointer, dwCapabilities: DWORD, pReserved3: pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoSwitchCallContext*(pNewObject: ptr IUnknown, ppOldObject: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCreateInstanceFromApp*(Clsid: REFCLSID, punkOuter: ptr IUnknown, dwClsCtx: DWORD, reserved: PVOID, dwCount: DWORD, pResults: ptr MULTI_QI): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoIsHandlerConnected*(pUnk: LPUNKNOWN): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDisconnectContext*(dwTimeout: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetCallContext*(riid: REFIID, ppInterface: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoQueryProxyBlanket*(pProxy: ptr IUnknown, pwAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr LPOLESTR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pAuthInfo: ptr RPC_AUTH_IDENTITY_HANDLE, pCapabilites: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoSetProxyBlanket*(pProxy: ptr IUnknown, dwAuthnSvc: DWORD, dwAuthzSvc: DWORD, pServerPrincName: ptr OLECHAR, dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthInfo: RPC_AUTH_IDENTITY_HANDLE, dwCapabilities: DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCopyProxy*(pProxy: ptr IUnknown, ppCopy: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoQueryClientBlanket*(pAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr LPOLESTR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pPrivs: ptr RPC_AUTHZ_HANDLE, pCapabilities: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoImpersonateClient*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRevertToSelf*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoQueryAuthenticationServices*(pcAuthSvc: ptr DWORD, asAuthSvc: ptr ptr SOLE_AUTHENTICATION_SERVICE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCreateInstance*(rclsid: REFCLSID, pUnkOuter: LPUNKNOWN, dwClsContext: DWORD, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCreateInstanceEx*(Clsid: REFCLSID, punkOuter: ptr IUnknown, dwClsCtx: DWORD, pServerInfo: ptr COSERVERINFO, dwCount: DWORD, pResults: ptr MULTI_QI): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetCancelObject*(dwThreadId: DWORD, iid: REFIID, ppUnk: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoSetCancelObject*(pUnk: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCancelCall*(dwThreadId: DWORD, ulTimeout: ULONG): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoTestCancel*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoEnableCallCancellation*(pReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDisableCallCancellation*(pReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StringFromCLSID*(rclsid: REFCLSID, lplpsz: ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CLSIDFromString*(lpsz: LPCOLESTR, pclsid: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StringFromIID*(rclsid: REFIID, lplpsz: ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc IIDFromString*(lpsz: LPCOLESTR, lpiid: LPIID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc ProgIDFromCLSID*(clsid: REFCLSID, lplpszProgID: ptr LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CLSIDFromProgID*(lpszProgID: LPCOLESTR, lpclsid: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StringFromGUID2*(rguid: REFGUID, lpsz: LPOLESTR, cchMax: int32): int32 {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoCreateGuid*(pguid: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc PropVariantCopy*(pvarDest: ptr PROPVARIANT, pvarSrc: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc PropVariantClear*(pvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc FreePropVariantArray*(cVariants: ULONG, rgvars: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoWaitForMultipleHandles*(dwFlags: DWORD, dwTimeout: DWORD, cHandles: ULONG, pHandles: LPHANDLE, lpdwindex: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetTreatAsClass*(clsidOld: REFCLSID, pClsidNew: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoInvalidateRemoteMachineBindings*(pszMachineName: LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc DllGetClassObject*(rclsid: REFCLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DllCanUnloadNow*(): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc CoTaskMemAlloc*(cb: SIZE_T): LPVOID {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoTaskMemRealloc*(pv: LPVOID, cb: SIZE_T): LPVOID {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoTaskMemFree*(pv: LPVOID): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoBuildVersion*(): DWORD {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoInitialize*(pvReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterMallocSpy*(pMallocSpy: LPMALLOCSPY): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRevokeMallocSpy*(): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterInitializeSpy*(pSpy: LPINITIALIZESPY, puliCookie: ptr ULARGE_INTEGER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRevokeInitializeSpy*(uliCookie: ULARGE_INTEGER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetSystemSecurityPermissions*(comSDType: COMSD, ppSD: ptr PSECURITY_DESCRIPTOR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoLoadLibrary*(lpszLibName: LPOLESTR, bAutoFree: WINBOOL): HINSTANCE {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFreeLibrary*(hInst: HINSTANCE): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFreeAllLibraries*(): void {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetInstanceFromFile*(pServerInfo: ptr COSERVERINFO, pClsid: ptr CLSID, punkOuter: ptr IUnknown, dwClsCtx: DWORD, grfMode: DWORD, pwszName: ptr OLECHAR, dwCount: DWORD, pResults: ptr MULTI_QI): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetInstanceFromIStorage*(pServerInfo: ptr COSERVERINFO, pClsid: ptr CLSID, punkOuter: ptr IUnknown, dwClsCtx: DWORD, pstg: ptr IStorage, dwCount: DWORD, pResults: ptr MULTI_QI): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoAllowSetForegroundWindow*(pUnk: ptr IUnknown, lpvReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc DcomChannelSetHResult*(pvReserved: LPVOID, pulReserved: ptr ULONG, appsHR: HRESULT): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoIsOle1Class*(rclsid: REFCLSID): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc CLSIDFromProgIDEx*(lpszProgID: LPCOLESTR, lpclsid: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFileTimeToDosDateTime*(lpFileTime: ptr FILETIME, lpDosDate: LPWORD, lpDosTime: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoDosDateTimeToFileTime*(nDosDate: WORD, nDosTime: WORD, lpFileTime: ptr FILETIME): WINBOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoFileTimeNow*(lpFileTime: ptr FILETIME): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterMessageFilter*(lpMessageFilter: LPMESSAGEFILTER, lplpMessageFilter: ptr LPMESSAGEFILTER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoRegisterChannelHook*(ExtensionUuid: REFGUID, pChannelHook: ptr IChannelHook): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoTreatAsClass*(clsidOld: REFCLSID, clsidNew: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateDataCache*(pUnkOuter: LPUNKNOWN, rclsid: REFCLSID, iid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgCreateDocfile*(pwcsName: ptr WCHAR, grfMode: DWORD, reserved: DWORD, ppstgOpen: ptr ptr IStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgCreateDocfileOnILockBytes*(plkbyt: ptr ILockBytes, grfMode: DWORD, reserved: DWORD, ppstgOpen: ptr ptr IStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgOpenStorage*(pwcsName: ptr WCHAR, pstgPriority: ptr IStorage, grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstgOpen: ptr ptr IStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgOpenStorageOnILockBytes*(plkbyt: ptr ILockBytes, pstgPriority: ptr IStorage, grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstgOpen: ptr ptr IStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgIsStorageFile*(pwcsName: ptr WCHAR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgIsStorageILockBytes*(plkbyt: ptr ILockBytes): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgSetTimes*(lpszName: ptr WCHAR, pctime: ptr FILETIME, patime: ptr FILETIME, pmtime: ptr FILETIME): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgOpenAsyncDocfileOnIFillLockBytes*(pflb: ptr IFillLockBytes, grfMode: DWORD, asyncFlags: DWORD, ppstgOpen: ptr ptr IStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgGetIFillLockBytesOnILockBytes*(pilb: ptr ILockBytes, ppflb: ptr ptr IFillLockBytes): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgGetIFillLockBytesOnFile*(pwcsName: ptr OLECHAR, ppflb: ptr ptr IFillLockBytes): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgCreateStorageEx*(pwcsName: ptr WCHAR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, pStgOptions: ptr STGOPTIONS, pSecurityDescriptor: PSECURITY_DESCRIPTOR, riid: REFIID, ppObjectOpen: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgOpenStorageEx*(pwcsName: ptr WCHAR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, pStgOptions: ptr STGOPTIONS, pSecurityDescriptor: PSECURITY_DESCRIPTOR, riid: REFIID, ppObjectOpen: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc BindMoniker*(pmk: LPMONIKER, grfOpt: DWORD, iidResult: REFIID, ppvResult: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoGetObject*(pszName: LPCWSTR, pBindOptions: ptr BIND_OPTS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc MkParseDisplayName*(pbc: LPBC, szUserName: LPCOLESTR, pchEaten: ptr ULONG, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc MonikerRelativePathTo*(pmkSrc: LPMONIKER, pmkDest: LPMONIKER, ppmkRelPath: ptr LPMONIKER, dwReserved: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc MonikerCommonPrefixWith*(pmkThis: LPMONIKER, pmkOther: LPMONIKER, ppmkCommon: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateBindCtx*(reserved: DWORD, ppbc: ptr LPBC): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateGenericComposite*(pmkFirst: LPMONIKER, pmkRest: LPMONIKER, ppmkComposite: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc GetClassFile*(szFilename: LPCOLESTR, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateClassMoniker*(rclsid: REFCLSID, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateFileMoniker*(lpszPathName: LPCOLESTR, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateItemMoniker*(lpszDelim: LPCOLESTR, lpszItem: LPCOLESTR, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateAntiMoniker*(ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreatePointerMoniker*(punk: LPUNKNOWN, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateObjrefMoniker*(punk: LPUNKNOWN, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CoInstall*(pbc: ptr IBindCtx, dwFlags: DWORD, pClassSpec: ptr uCLSSPEC, pQuery: ptr QUERYCONTEXT, pszCodeBase: LPWSTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc GetRunningObjectTable*(reserved: DWORD, pprot: ptr LPRUNNINGOBJECTTABLE): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateURLMoniker*(pMkCtx: LPMONIKER, szURL: LPCWSTR, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateURLMonikerEx*(pMkCtx: LPMONIKER, szURL: LPCWSTR, ppmk: ptr LPMONIKER, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc GetClassURL*(szURL: LPCWSTR, pClsID: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateAsyncBindCtx*(reserved: DWORD, pBSCb: ptr IBindStatusCallback, pEFetc: ptr IEnumFORMATETC, ppBC: ptr ptr IBindCtx): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateURLMonikerEx2*(pMkCtx: LPMONIKER, pUri: ptr IUri, ppmk: ptr LPMONIKER, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateAsyncBindCtxEx*(pbc: ptr IBindCtx, dwOptions: DWORD, pBSCb: ptr IBindStatusCallback, pEnum: ptr IEnumFORMATETC, ppBC: ptr ptr IBindCtx, reserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc MkParseDisplayNameEx*(pbc: ptr IBindCtx, szDisplayName: LPCWSTR, pchEaten: ptr ULONG, ppmk: ptr LPMONIKER): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RegisterBindStatusCallback*(pBC: LPBC, pBSCb: ptr IBindStatusCallback, ppBSCBPrev: ptr ptr IBindStatusCallback, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RevokeBindStatusCallback*(pBC: LPBC, pBSCb: ptr IBindStatusCallback): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc GetClassFileOrMime*(pBC: LPBC, szFilename: LPCWSTR, pBuffer: LPVOID, cbSize: DWORD, szMime: LPCWSTR, dwReserved: DWORD, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc IsValidURL*(pBC: LPBC, szURL: LPCWSTR, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoGetClassObjectFromURL*(rCLASSID: REFCLSID, szCODE: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, szTYPE: LPCWSTR, pBindCtx: LPBINDCTX, dwClsContext: DWORD, pvReserved: LPVOID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc IEInstallScope*(pdwScope: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc FaultInIEFeature*(hWnd: HWND, pClassSpec: ptr uCLSSPEC, pQuery: ptr QUERYCONTEXT, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc GetComponentIDFromCLSSPEC*(pClassspec: ptr uCLSSPEC, ppszComponentID: ptr LPSTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc IsAsyncMoniker*(pmk: ptr IMoniker): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RegisterMediaTypes*(ctypes: UINT, rgszTypes: ptr LPCSTR, rgcfTypes: ptr CLIPFORMAT): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc FindMediaType*(rgszTypes: LPCSTR, rgcfTypes: ptr CLIPFORMAT): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateFormatEnumerator*(cfmtetc: UINT, rgfmtetc: ptr FORMATETC, ppenumfmtetc: ptr ptr IEnumFORMATETC): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RegisterFormatEnumerator*(pBC: LPBC, pEFetc: ptr IEnumFORMATETC, reserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RevokeFormatEnumerator*(pBC: LPBC, pEFetc: ptr IEnumFORMATETC): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc RegisterMediaTypeClass*(pBC: LPBC, ctypes: UINT, rgszTypes: ptr LPCSTR, rgclsID: ptr CLSID, reserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc FindMediaTypeClass*(pBC: LPBC, szType: LPCSTR, pclsID: ptr CLSID, reserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc UrlMkSetSessionOption*(dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc UrlMkGetSessionOption*(dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, pdwBufferLengthOut: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc FindMimeFromData*(pBC: LPBC, pwzUrl: LPCWSTR, pBuffer: LPVOID, cbSize: DWORD, pwzMimeProposed: LPCWSTR, dwMimeFlags: DWORD, ppwzMimeOut: ptr LPWSTR, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc ObtainUserAgentString*(dwOption: DWORD, pszUAOut: LPSTR, cbSize: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CompareSecurityIds*(pbSecurityId1: ptr BYTE, dwLen1: DWORD, pbSecurityId2: ptr BYTE, dwLen2: DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CompatFlagsFromClsid*(pclsid: ptr CLSID, pdwCompatFlags: LPDWORD, pdwMiscStatusFlags: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateUri*(pwzURI: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR, ppURI: ptr ptr IUri): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateUriWithFragment*(pwzURI: LPCWSTR, pwzFragment: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR, ppURI: ptr ptr IUri): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateUriFromMultiByteString*(pszANSIInputUri: LPCSTR, dwEncodingFlags: DWORD, dwCodePage: DWORD, dwCreateFlags: DWORD, dwReserved: DWORD_PTR, ppUri: ptr ptr IUri): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CreateIUriBuilder*(pIUri: ptr IUri, dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: ptr ptr IUriBuilder): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkSimpleNavigateToString*(szTarget: LPCWSTR, szLocation: LPCWSTR, szTargetFrameName: LPCWSTR, pUnk: ptr IUnknown, pbc: ptr IBindCtx, P6: ptr IBindStatusCallback, grfHLNF: DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkSimpleNavigateToMoniker*(pmkTarget: ptr IMoniker, szLocation: LPCWSTR, szTargetFrameName: LPCWSTR, pUnk: ptr IUnknown, pbc: ptr IBindCtx, P6: ptr IBindStatusCallback, grfHLNF: DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenStreamA*(P1: LPUNKNOWN, P2: LPCSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenStreamW*(P1: LPUNKNOWN, P2: LPCWSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenPullStreamA*(P1: LPUNKNOWN, P2: LPCSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenPullStreamW*(P1: LPUNKNOWN, P2: LPCWSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLDownloadToFileA*(P1: LPUNKNOWN, P2: LPCSTR, P3: LPCSTR, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLDownloadToFileW*(P1: LPUNKNOWN, P2: LPCWSTR, P3: LPCWSTR, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLDownloadToCacheFileA*(P1: LPUNKNOWN, P2: LPCSTR, P3: LPSTR, P4: DWORD, P5: DWORD, P6: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLDownloadToCacheFileW*(P1: LPUNKNOWN, P2: LPCWSTR, P3: LPWSTR, P4: DWORD, P5: DWORD, P6: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenBlockingStreamA*(P1: LPUNKNOWN, P2: LPCSTR, P3: ptr LPSTREAM, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc URLOpenBlockingStreamW*(P1: LPUNKNOWN, P2: LPCWSTR, P3: ptr LPSTREAM, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkGoBack*(pUnk: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkGoForward*(pUnk: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkNavigateString*(pUnk: ptr IUnknown, szTarget: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc HlinkNavigateMoniker*(pUnk: ptr IUnknown, pmkTarget: ptr IMoniker): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetParseUrl*(pwzUrl: LPCWSTR, ParseAction: PARSEACTION, dwFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetParseIUri*(pIUri: ptr IUri, ParseAction: PARSEACTION, dwFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetCombineUrl*(pwzBaseUrl: LPCWSTR, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetCombineUrlEx*(pBaseUri: ptr IUri, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, ppCombinedUri: ptr ptr IUri, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetCombineIUri*(pBaseUri: ptr IUri, pRelativeUri: ptr IUri, dwCombineFlags: DWORD, ppCombinedUri: ptr ptr IUri, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetCompareUrl*(pwzUrl1: LPCWSTR, pwzUrl2: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetGetProtocolFlags*(pwzUrl: LPCWSTR, pdwFlags: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetQueryInfo*(pwzUrl: LPCWSTR, QueryOptions: QUERYOPTION, dwQueryFlags: DWORD, pvBuffer: LPVOID, cbBuffer: DWORD, pcbBuffer: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetGetSession*(dwSessionMode: DWORD, ppIInternetSession: ptr ptr IInternetSession, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetGetSecurityUrl*(pwszUrl: LPCWSTR, ppwszSecUrl: ptr LPWSTR, psuAction: PSUACTION, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc AsyncInstallDistributionUnit*(szDistUnit: LPCWSTR, szTYPE: LPCWSTR, szExt: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, szURL: LPCWSTR, pbc: ptr IBindCtx, pvReserved: LPVOID, flags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetGetSecurityUrlEx*(pUri: ptr IUri, ppSecUri: ptr ptr IUri, psuAction: PSUACTION, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetSetFeatureEnabled*(FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, fEnable: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetIsFeatureEnabled*(FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetIsFeatureEnabledForUrl*(FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, szURL: LPCWSTR, pSecMgr: ptr IInternetSecurityManager): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetIsFeatureEnabledForIUri*(FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, pIUri: ptr IUri, pSecMgr: ptr IInternetSecurityManagerEx2): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetIsFeatureZoneElevationEnabled*(szFromURL: LPCWSTR, szToURL: LPCWSTR, pSecMgr: ptr IInternetSecurityManager, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CopyStgMedium*(pcstgmedSrc: ptr STGMEDIUM, pstgmedDest: ptr STGMEDIUM): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CopyBindInfo*(pcbiSrc: ptr BINDINFO, pbiDest: ptr BINDINFO): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc ReleaseBindInfo*(pbindinfo: ptr BINDINFO): void {.winapi, stdcall, dynlib: "urlmon", importc.} +proc OInetParseUrl*(pwzUrl: LPCWSTR, ParseAction: PARSEACTION, dwFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetParseUrl".} +proc OInetCombineUrl*(pwzBaseUrl: LPCWSTR, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetCombineUrl".} +proc OInetCombineUrlEx*(pBaseUri: ptr IUri, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, ppCombinedUri: ptr ptr IUri, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetCombineUrlEx".} +proc OInetCombineIUri*(pBaseUri: ptr IUri, pRelativeUri: ptr IUri, dwCombineFlags: DWORD, ppCombinedUri: ptr ptr IUri, dwReserved: DWORD_PTR): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetCombineIUri".} +proc OInetCompareUrl*(pwzUrl1: LPCWSTR, pwzUrl2: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetCompareUrl".} +proc OInetQueryInfo*(pwzUrl: LPCWSTR, QueryOptions: QUERYOPTION, dwQueryFlags: DWORD, pvBuffer: LPVOID, cbBuffer: DWORD, pcbBuffer: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetQueryInfo".} +proc OInetGetSession*(dwSessionMode: DWORD, ppIInternetSession: ptr ptr IInternetSession, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "CoInternetGetSession".} +proc CoInternetCreateSecurityManager*(pSP: ptr IServiceProvider, ppSM: ptr ptr IInternetSecurityManager, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc CoInternetCreateZoneManager*(pSP: ptr IServiceProvider, ppZM: ptr ptr IInternetZoneManager, dwReserved: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc GetSoftwareUpdateInfo*(szDistUnit: LPCWSTR, psdi: LPSOFTDISTINFO): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc SetSoftwareUpdateAdvertisementState*(szDistUnit: LPCWSTR, dwAdState: DWORD, dwAdvertisedVersionMS: DWORD, dwAdvertisedVersionLS: DWORD): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc.} +proc IsLoggingEnabledA*(pszUrl: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "urlmon", importc.} +proc IsLoggingEnabledW*(pwszUrl: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "urlmon", importc.} +proc WriteHitLogging*(lpLogginginfo: LPHIT_LOGGING_INFO): WINBOOL {.winapi, stdcall, dynlib: "urlmon", importc.} +proc StgCreatePropStg*(pUnk: ptr IUnknown, fmtid: REFFMTID, pclsid: ptr CLSID, grfFlags: DWORD, dwReserved: DWORD, ppPropStg: ptr ptr IPropertyStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgOpenPropStg*(pUnk: ptr IUnknown, fmtid: REFFMTID, grfFlags: DWORD, dwReserved: DWORD, ppPropStg: ptr ptr IPropertyStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc StgCreatePropSetStg*(pStorage: ptr IStorage, dwReserved: DWORD, ppPropSetStg: ptr ptr IPropertySetStorage): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc FmtIdToPropStgName*(pfmtid: ptr FMTID, oszName: LPOLESTR): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc PropStgNameToFmtId*(oszName: LPOLESTR, pfmtid: ptr FMTID): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc CreateStdProgressIndicator*(hwndParent: HWND, pszTitle: LPCOLESTR, pIbscCaller: ptr IBindStatusCallback, ppIbsc: ptr ptr IBindStatusCallback): HRESULT {.winapi, stdcall, dynlib: "ole32", importc.} +proc PSCoerceToCanonicalValue*(key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreateAdapterFromPropertyStore*(pps: ptr IPropertyStore, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreateDelayedMultiplexPropertyStore*(flags: GETPROPERTYSTOREFLAGS, pdpsf: ptr IDelayedPropertyStoreFactory, rgStoreIds: ptr DWORD, cStores: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreateMemoryPropertyStore*(riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreateMultiplexPropertyStore*(prgpunkStores: ptr ptr IUnknown, cStores: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreatePropertyChangeArray*(rgpropkey: ptr PROPERTYKEY, rgflags: ptr PKA_FLAGS, rgpropvar: ptr PROPVARIANT, cChanges: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreatePropertyStoreFromObject*(punk: ptr IUnknown, grfMode: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreatePropertyStoreFromPropertySetStorage*(ppss: ptr IPropertySetStorage, grfMode: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSCreateSimplePropertyChange*(flags: PKA_FLAGS, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSEnumeratePropertyDescriptions*(filterOn: PROPDESC_ENUMFILTER, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSFormatForDisplay*(propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdfFlags: PROPDESC_FORMAT_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSFormatForDisplayAlloc*(key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSFormatPropertyValue*(pps: ptr IPropertyStore, ppd: ptr IPropertyDescription, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr LPWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetImageReferenceForValue*(propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT, ppszImageRes: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetItemPropertyHandler*(punkItem: ptr IUnknown, fReadWrite: BOOL, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetItemPropertyHandlerWithCreateObject*(punkItem: ptr IUnknown, fReadWrite: BOOL, punkCreateObject: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetNamedPropertyFromPropertyStorage*(psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD, pszName: LPCWSTR, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetNameFromPropertyKey*(propkey: REFPROPERTYKEY, ppszCanonicalName: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyDescription*(propkey: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyDescriptionByName*(pszCanonicalName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyDescriptionListFromString*(pszPropList: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyFromPropertyStorage*(psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD, rpkey: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyKeyFromName*(pszName: PCWSTR, ppropkey: ptr PROPERTYKEY): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertySystem*(riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSGetPropertyValue*(pps: ptr IPropertyStore, ppd: ptr IPropertyDescription, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSLookupPropertyHandlerCLSID*(pszFilePath: PCWSTR, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_Delete*(propBag: ptr IPropertyBag, propName: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadBOOL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr BOOL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadBSTR*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadDWORD*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadGUID*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadInt*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr INT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadLONG*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadPOINTL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr POINTL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadPOINTS*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr POINTS): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadPropertyKey*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr PROPERTYKEY): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadRECTL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr RECTL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadSHORT*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr SHORT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadStr*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: LPWSTR, characterCount: int32): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadStrAlloc*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadStream*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadType*(propBag: ptr IPropertyBag, propName: LPCWSTR, `var`: ptr VARIANT, `type`: VARTYPE): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadULONGLONG*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr ULONGLONG): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_ReadUnknown*(propBag: ptr IPropertyBag, propName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteBOOL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: BOOL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteBSTR*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: BSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteDWORD*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: DWORD): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteGUID*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr GUID): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteInt*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: INT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteLONG*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: LONG): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WritePOINTL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr POINTL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WritePOINTS*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr POINTS): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WritePropertyKey*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: REFPROPERTYKEY): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteRECTL*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr RECTL): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteSHORT*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: SHORT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteStr*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteStream*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ptr IStream): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteULONGLONG*(propBag: ptr IPropertyBag, propName: LPCWSTR, value: ULONGLONG): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyBag_WriteUnknown*(propBag: ptr IPropertyBag, propName: LPCWSTR, punk: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSPropertyKeyFromString*(pszString: LPCWSTR, pkey: ptr PROPERTYKEY): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSRefreshPropertySchema*(): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSRegisterPropertySchema*(pszPath: PCWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSSetPropertyValue*(pps: ptr IPropertyStore, ppd: ptr IPropertyDescription, propvar: REFPROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSStringFromPropertyKey*(pkey: REFPROPERTYKEY, psz: LPWSTR, cch: UINT): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc PSUnregisterPropertySchema*(pszPath: PCWSTR): HRESULT {.winapi, stdcall, dynlib: "propsys", importc.} +proc VarUI4FromUI4*(ulIn: ULONG, pulOut: ptr ULONG): HRESULT {.winapi, inline.} = pulOut[] = ulIn +proc VarI4FromI4*(lIn: LONG, plOut: ptr LONG): HRESULT {.winapi, inline.} = plOut[] = lIn +proc VarUI8FromUI8*(ui64In: ULONG64, pi64Out: ptr ULONG64): HRESULT {.winapi, inline.} = pi64Out[] = ui64In +proc VarI8FromI8*(i64In: LONG64, pi64Out: ptr LONG64): HRESULT {.winapi, inline.} = pi64Out[] = i64In +proc `Lo=`*(self: var CY, x: int32) {.inline.} = self.struct1.Lo = x +proc Lo*(self: CY): int32 {.inline.} = self.struct1.Lo +proc Lo*(self: var CY): var int32 {.inline.} = self.struct1.Lo +proc `Hi=`*(self: var CY, x: int32) {.inline.} = self.struct1.Hi = x +proc Hi*(self: CY): int32 {.inline.} = self.struct1.Hi +proc Hi*(self: var CY): var int32 {.inline.} = self.struct1.Hi +proc `scale=`*(self: var DECIMAL, x: BYTE) {.inline.} = self.union1.struct1.scale = x +proc scale*(self: DECIMAL): BYTE {.inline.} = self.union1.struct1.scale +proc scale*(self: var DECIMAL): var BYTE {.inline.} = self.union1.struct1.scale +proc `sign=`*(self: var DECIMAL, x: BYTE) {.inline.} = self.union1.struct1.sign = x +proc sign*(self: DECIMAL): BYTE {.inline.} = self.union1.struct1.sign +proc sign*(self: var DECIMAL): var BYTE {.inline.} = self.union1.struct1.sign +proc `signscale=`*(self: var DECIMAL, x: USHORT) {.inline.} = self.union1.signscale = x +proc signscale*(self: DECIMAL): USHORT {.inline.} = self.union1.signscale +proc signscale*(self: var DECIMAL): var USHORT {.inline.} = self.union1.signscale +proc `Lo32=`*(self: var DECIMAL, x: ULONG) {.inline.} = self.union2.struct1.Lo32 = x +proc Lo32*(self: DECIMAL): ULONG {.inline.} = self.union2.struct1.Lo32 +proc Lo32*(self: var DECIMAL): var ULONG {.inline.} = self.union2.struct1.Lo32 +proc `Mid32=`*(self: var DECIMAL, x: ULONG) {.inline.} = self.union2.struct1.Mid32 = x +proc Mid32*(self: DECIMAL): ULONG {.inline.} = self.union2.struct1.Mid32 +proc Mid32*(self: var DECIMAL): var ULONG {.inline.} = self.union2.struct1.Mid32 +proc `Lo64=`*(self: var DECIMAL, x: ULONGLONG) {.inline.} = self.union2.Lo64 = x +proc Lo64*(self: DECIMAL): ULONGLONG {.inline.} = self.union2.Lo64 +proc Lo64*(self: var DECIMAL): var ULONGLONG {.inline.} = self.union2.Lo64 +proc `tymed=`*(self: var userSTGMEDIUM, x: DWORD) {.inline.} = self.struct1.tymed = x +proc tymed*(self: userSTGMEDIUM): DWORD {.inline.} = self.struct1.tymed +proc tymed*(self: var userSTGMEDIUM): var DWORD {.inline.} = self.struct1.tymed +proc `u=`*(self: var userSTGMEDIUM, x: userSTGMEDIUM_STRUCT1_u) {.inline.} = self.struct1.u = x +proc u*(self: userSTGMEDIUM): userSTGMEDIUM_STRUCT1_u {.inline.} = self.struct1.u +proc u*(self: var userSTGMEDIUM): var userSTGMEDIUM_STRUCT1_u {.inline.} = self.struct1.u +proc `vt=`*(self: var VARIANT, x: VARTYPE) {.inline.} = self.union1.struct1.vt = x +proc vt*(self: VARIANT): VARTYPE {.inline.} = self.union1.struct1.vt +proc vt*(self: var VARIANT): var VARTYPE {.inline.} = self.union1.struct1.vt +proc `wReserved1=`*(self: var VARIANT, x: WORD) {.inline.} = self.union1.struct1.wReserved1 = x +proc wReserved1*(self: VARIANT): WORD {.inline.} = self.union1.struct1.wReserved1 +proc wReserved1*(self: var VARIANT): var WORD {.inline.} = self.union1.struct1.wReserved1 +proc `wReserved2=`*(self: var VARIANT, x: WORD) {.inline.} = self.union1.struct1.wReserved2 = x +proc wReserved2*(self: VARIANT): WORD {.inline.} = self.union1.struct1.wReserved2 +proc wReserved2*(self: var VARIANT): var WORD {.inline.} = self.union1.struct1.wReserved2 +proc `wReserved3=`*(self: var VARIANT, x: WORD) {.inline.} = self.union1.struct1.wReserved3 = x +proc wReserved3*(self: VARIANT): WORD {.inline.} = self.union1.struct1.wReserved3 +proc wReserved3*(self: var VARIANT): var WORD {.inline.} = self.union1.struct1.wReserved3 +proc `llVal=`*(self: var VARIANT, x: LONGLONG) {.inline.} = self.union1.struct1.union1.llVal = x +proc llVal*(self: VARIANT): LONGLONG {.inline.} = self.union1.struct1.union1.llVal +proc llVal*(self: var VARIANT): var LONGLONG {.inline.} = self.union1.struct1.union1.llVal +proc `lVal=`*(self: var VARIANT, x: LONG) {.inline.} = self.union1.struct1.union1.lVal = x +proc lVal*(self: VARIANT): LONG {.inline.} = self.union1.struct1.union1.lVal +proc lVal*(self: var VARIANT): var LONG {.inline.} = self.union1.struct1.union1.lVal +proc `bVal=`*(self: var VARIANT, x: BYTE) {.inline.} = self.union1.struct1.union1.bVal = x +proc bVal*(self: VARIANT): BYTE {.inline.} = self.union1.struct1.union1.bVal +proc bVal*(self: var VARIANT): var BYTE {.inline.} = self.union1.struct1.union1.bVal +proc `iVal=`*(self: var VARIANT, x: SHORT) {.inline.} = self.union1.struct1.union1.iVal = x +proc iVal*(self: VARIANT): SHORT {.inline.} = self.union1.struct1.union1.iVal +proc iVal*(self: var VARIANT): var SHORT {.inline.} = self.union1.struct1.union1.iVal +proc `fltVal=`*(self: var VARIANT, x: FLOAT) {.inline.} = self.union1.struct1.union1.fltVal = x +proc fltVal*(self: VARIANT): FLOAT {.inline.} = self.union1.struct1.union1.fltVal +proc fltVal*(self: var VARIANT): var FLOAT {.inline.} = self.union1.struct1.union1.fltVal +proc `dblVal=`*(self: var VARIANT, x: DOUBLE) {.inline.} = self.union1.struct1.union1.dblVal = x +proc dblVal*(self: VARIANT): DOUBLE {.inline.} = self.union1.struct1.union1.dblVal +proc dblVal*(self: var VARIANT): var DOUBLE {.inline.} = self.union1.struct1.union1.dblVal +proc `boolVal=`*(self: var VARIANT, x: VARIANT_BOOL) {.inline.} = self.union1.struct1.union1.boolVal = x +proc boolVal*(self: VARIANT): VARIANT_BOOL {.inline.} = self.union1.struct1.union1.boolVal +proc boolVal*(self: var VARIANT): var VARIANT_BOOL {.inline.} = self.union1.struct1.union1.boolVal +proc `scode=`*(self: var VARIANT, x: SCODE) {.inline.} = self.union1.struct1.union1.scode = x +proc scode*(self: VARIANT): SCODE {.inline.} = self.union1.struct1.union1.scode +proc scode*(self: var VARIANT): var SCODE {.inline.} = self.union1.struct1.union1.scode +proc `cyVal=`*(self: var VARIANT, x: CY) {.inline.} = self.union1.struct1.union1.cyVal = x +proc cyVal*(self: VARIANT): CY {.inline.} = self.union1.struct1.union1.cyVal +proc cyVal*(self: var VARIANT): var CY {.inline.} = self.union1.struct1.union1.cyVal +proc `date=`*(self: var VARIANT, x: DATE) {.inline.} = self.union1.struct1.union1.date = x +proc date*(self: VARIANT): DATE {.inline.} = self.union1.struct1.union1.date +proc date*(self: var VARIANT): var DATE {.inline.} = self.union1.struct1.union1.date +proc `bstrVal=`*(self: var VARIANT, x: BSTR) {.inline.} = self.union1.struct1.union1.bstrVal = x +proc bstrVal*(self: VARIANT): BSTR {.inline.} = self.union1.struct1.union1.bstrVal +proc bstrVal*(self: var VARIANT): var BSTR {.inline.} = self.union1.struct1.union1.bstrVal +proc `punkVal=`*(self: var VARIANT, x: ptr IUnknown) {.inline.} = self.union1.struct1.union1.punkVal = x +proc punkVal*(self: VARIANT): ptr IUnknown {.inline.} = self.union1.struct1.union1.punkVal +proc punkVal*(self: var VARIANT): var ptr IUnknown {.inline.} = self.union1.struct1.union1.punkVal +proc `pdispVal=`*(self: var VARIANT, x: ptr IDispatch) {.inline.} = self.union1.struct1.union1.pdispVal = x +proc pdispVal*(self: VARIANT): ptr IDispatch {.inline.} = self.union1.struct1.union1.pdispVal +proc pdispVal*(self: var VARIANT): var ptr IDispatch {.inline.} = self.union1.struct1.union1.pdispVal +proc `parray=`*(self: var VARIANT, x: ptr SAFEARRAY) {.inline.} = self.union1.struct1.union1.parray = x +proc parray*(self: VARIANT): ptr SAFEARRAY {.inline.} = self.union1.struct1.union1.parray +proc parray*(self: var VARIANT): var ptr SAFEARRAY {.inline.} = self.union1.struct1.union1.parray +proc `pbVal=`*(self: var VARIANT, x: ptr BYTE) {.inline.} = self.union1.struct1.union1.pbVal = x +proc pbVal*(self: VARIANT): ptr BYTE {.inline.} = self.union1.struct1.union1.pbVal +proc pbVal*(self: var VARIANT): var ptr BYTE {.inline.} = self.union1.struct1.union1.pbVal +proc `piVal=`*(self: var VARIANT, x: ptr SHORT) {.inline.} = self.union1.struct1.union1.piVal = x +proc piVal*(self: VARIANT): ptr SHORT {.inline.} = self.union1.struct1.union1.piVal +proc piVal*(self: var VARIANT): var ptr SHORT {.inline.} = self.union1.struct1.union1.piVal +proc `plVal=`*(self: var VARIANT, x: ptr LONG) {.inline.} = self.union1.struct1.union1.plVal = x +proc plVal*(self: VARIANT): ptr LONG {.inline.} = self.union1.struct1.union1.plVal +proc plVal*(self: var VARIANT): var ptr LONG {.inline.} = self.union1.struct1.union1.plVal +proc `pllVal=`*(self: var VARIANT, x: ptr LONGLONG) {.inline.} = self.union1.struct1.union1.pllVal = x +proc pllVal*(self: VARIANT): ptr LONGLONG {.inline.} = self.union1.struct1.union1.pllVal +proc pllVal*(self: var VARIANT): var ptr LONGLONG {.inline.} = self.union1.struct1.union1.pllVal +proc `pfltVal=`*(self: var VARIANT, x: ptr FLOAT) {.inline.} = self.union1.struct1.union1.pfltVal = x +proc pfltVal*(self: VARIANT): ptr FLOAT {.inline.} = self.union1.struct1.union1.pfltVal +proc pfltVal*(self: var VARIANT): var ptr FLOAT {.inline.} = self.union1.struct1.union1.pfltVal +proc `pdblVal=`*(self: var VARIANT, x: ptr DOUBLE) {.inline.} = self.union1.struct1.union1.pdblVal = x +proc pdblVal*(self: VARIANT): ptr DOUBLE {.inline.} = self.union1.struct1.union1.pdblVal +proc pdblVal*(self: var VARIANT): var ptr DOUBLE {.inline.} = self.union1.struct1.union1.pdblVal +proc `pboolVal=`*(self: var VARIANT, x: ptr VARIANT_BOOL) {.inline.} = self.union1.struct1.union1.pboolVal = x +proc pboolVal*(self: VARIANT): ptr VARIANT_BOOL {.inline.} = self.union1.struct1.union1.pboolVal +proc pboolVal*(self: var VARIANT): var ptr VARIANT_BOOL {.inline.} = self.union1.struct1.union1.pboolVal +proc `pscode=`*(self: var VARIANT, x: ptr SCODE) {.inline.} = self.union1.struct1.union1.pscode = x +proc pscode*(self: VARIANT): ptr SCODE {.inline.} = self.union1.struct1.union1.pscode +proc pscode*(self: var VARIANT): var ptr SCODE {.inline.} = self.union1.struct1.union1.pscode +proc `pcyVal=`*(self: var VARIANT, x: ptr CY) {.inline.} = self.union1.struct1.union1.pcyVal = x +proc pcyVal*(self: VARIANT): ptr CY {.inline.} = self.union1.struct1.union1.pcyVal +proc pcyVal*(self: var VARIANT): var ptr CY {.inline.} = self.union1.struct1.union1.pcyVal +proc `pdate=`*(self: var VARIANT, x: ptr DATE) {.inline.} = self.union1.struct1.union1.pdate = x +proc pdate*(self: VARIANT): ptr DATE {.inline.} = self.union1.struct1.union1.pdate +proc pdate*(self: var VARIANT): var ptr DATE {.inline.} = self.union1.struct1.union1.pdate +proc `pbstrVal=`*(self: var VARIANT, x: ptr BSTR) {.inline.} = self.union1.struct1.union1.pbstrVal = x +proc pbstrVal*(self: VARIANT): ptr BSTR {.inline.} = self.union1.struct1.union1.pbstrVal +proc pbstrVal*(self: var VARIANT): var ptr BSTR {.inline.} = self.union1.struct1.union1.pbstrVal +proc `ppunkVal=`*(self: var VARIANT, x: ptr ptr IUnknown) {.inline.} = self.union1.struct1.union1.ppunkVal = x +proc ppunkVal*(self: VARIANT): ptr ptr IUnknown {.inline.} = self.union1.struct1.union1.ppunkVal +proc ppunkVal*(self: var VARIANT): var ptr ptr IUnknown {.inline.} = self.union1.struct1.union1.ppunkVal +proc `ppdispVal=`*(self: var VARIANT, x: ptr ptr IDispatch) {.inline.} = self.union1.struct1.union1.ppdispVal = x +proc ppdispVal*(self: VARIANT): ptr ptr IDispatch {.inline.} = self.union1.struct1.union1.ppdispVal +proc ppdispVal*(self: var VARIANT): var ptr ptr IDispatch {.inline.} = self.union1.struct1.union1.ppdispVal +proc `pparray=`*(self: var VARIANT, x: ptr ptr SAFEARRAY) {.inline.} = self.union1.struct1.union1.pparray = x +proc pparray*(self: VARIANT): ptr ptr SAFEARRAY {.inline.} = self.union1.struct1.union1.pparray +proc pparray*(self: var VARIANT): var ptr ptr SAFEARRAY {.inline.} = self.union1.struct1.union1.pparray +proc `pvarVal=`*(self: var VARIANT, x: ptr VARIANT) {.inline.} = self.union1.struct1.union1.pvarVal = x +proc pvarVal*(self: VARIANT): ptr VARIANT {.inline.} = self.union1.struct1.union1.pvarVal +proc pvarVal*(self: var VARIANT): var ptr VARIANT {.inline.} = self.union1.struct1.union1.pvarVal +proc `byref=`*(self: var VARIANT, x: PVOID) {.inline.} = self.union1.struct1.union1.byref = x +proc byref*(self: VARIANT): PVOID {.inline.} = self.union1.struct1.union1.byref +proc byref*(self: var VARIANT): var PVOID {.inline.} = self.union1.struct1.union1.byref +proc `cVal=`*(self: var VARIANT, x: CHAR) {.inline.} = self.union1.struct1.union1.cVal = x +proc cVal*(self: VARIANT): CHAR {.inline.} = self.union1.struct1.union1.cVal +proc cVal*(self: var VARIANT): var CHAR {.inline.} = self.union1.struct1.union1.cVal +proc `uiVal=`*(self: var VARIANT, x: USHORT) {.inline.} = self.union1.struct1.union1.uiVal = x +proc uiVal*(self: VARIANT): USHORT {.inline.} = self.union1.struct1.union1.uiVal +proc uiVal*(self: var VARIANT): var USHORT {.inline.} = self.union1.struct1.union1.uiVal +proc `ulVal=`*(self: var VARIANT, x: ULONG) {.inline.} = self.union1.struct1.union1.ulVal = x +proc ulVal*(self: VARIANT): ULONG {.inline.} = self.union1.struct1.union1.ulVal +proc ulVal*(self: var VARIANT): var ULONG {.inline.} = self.union1.struct1.union1.ulVal +proc `ullVal=`*(self: var VARIANT, x: ULONGLONG) {.inline.} = self.union1.struct1.union1.ullVal = x +proc ullVal*(self: VARIANT): ULONGLONG {.inline.} = self.union1.struct1.union1.ullVal +proc ullVal*(self: var VARIANT): var ULONGLONG {.inline.} = self.union1.struct1.union1.ullVal +proc `intVal=`*(self: var VARIANT, x: INT) {.inline.} = self.union1.struct1.union1.intVal = x +proc intVal*(self: VARIANT): INT {.inline.} = self.union1.struct1.union1.intVal +proc intVal*(self: var VARIANT): var INT {.inline.} = self.union1.struct1.union1.intVal +proc `uintVal=`*(self: var VARIANT, x: UINT) {.inline.} = self.union1.struct1.union1.uintVal = x +proc uintVal*(self: VARIANT): UINT {.inline.} = self.union1.struct1.union1.uintVal +proc uintVal*(self: var VARIANT): var UINT {.inline.} = self.union1.struct1.union1.uintVal +proc `pdecVal=`*(self: var VARIANT, x: ptr DECIMAL) {.inline.} = self.union1.struct1.union1.pdecVal = x +proc pdecVal*(self: VARIANT): ptr DECIMAL {.inline.} = self.union1.struct1.union1.pdecVal +proc pdecVal*(self: var VARIANT): var ptr DECIMAL {.inline.} = self.union1.struct1.union1.pdecVal +proc `pcVal=`*(self: var VARIANT, x: ptr CHAR) {.inline.} = self.union1.struct1.union1.pcVal = x +proc pcVal*(self: VARIANT): ptr CHAR {.inline.} = self.union1.struct1.union1.pcVal +proc pcVal*(self: var VARIANT): var ptr CHAR {.inline.} = self.union1.struct1.union1.pcVal +proc `puiVal=`*(self: var VARIANT, x: ptr USHORT) {.inline.} = self.union1.struct1.union1.puiVal = x +proc puiVal*(self: VARIANT): ptr USHORT {.inline.} = self.union1.struct1.union1.puiVal +proc puiVal*(self: var VARIANT): var ptr USHORT {.inline.} = self.union1.struct1.union1.puiVal +proc `pulVal=`*(self: var VARIANT, x: ptr ULONG) {.inline.} = self.union1.struct1.union1.pulVal = x +proc pulVal*(self: VARIANT): ptr ULONG {.inline.} = self.union1.struct1.union1.pulVal +proc pulVal*(self: var VARIANT): var ptr ULONG {.inline.} = self.union1.struct1.union1.pulVal +proc `pullVal=`*(self: var VARIANT, x: ptr ULONGLONG) {.inline.} = self.union1.struct1.union1.pullVal = x +proc pullVal*(self: VARIANT): ptr ULONGLONG {.inline.} = self.union1.struct1.union1.pullVal +proc pullVal*(self: var VARIANT): var ptr ULONGLONG {.inline.} = self.union1.struct1.union1.pullVal +proc `pintVal=`*(self: var VARIANT, x: ptr INT) {.inline.} = self.union1.struct1.union1.pintVal = x +proc pintVal*(self: VARIANT): ptr INT {.inline.} = self.union1.struct1.union1.pintVal +proc pintVal*(self: var VARIANT): var ptr INT {.inline.} = self.union1.struct1.union1.pintVal +proc `puintVal=`*(self: var VARIANT, x: ptr UINT) {.inline.} = self.union1.struct1.union1.puintVal = x +proc puintVal*(self: VARIANT): ptr UINT {.inline.} = self.union1.struct1.union1.puintVal +proc puintVal*(self: var VARIANT): var ptr UINT {.inline.} = self.union1.struct1.union1.puintVal +proc `pvRecord=`*(self: var VARIANT, x: PVOID) {.inline.} = self.union1.struct1.union1.struct1.pvRecord = x +proc pvRecord*(self: VARIANT): PVOID {.inline.} = self.union1.struct1.union1.struct1.pvRecord +proc pvRecord*(self: var VARIANT): var PVOID {.inline.} = self.union1.struct1.union1.struct1.pvRecord +proc `pRecInfo=`*(self: var VARIANT, x: ptr IRecordInfo) {.inline.} = self.union1.struct1.union1.struct1.pRecInfo = x +proc pRecInfo*(self: VARIANT): ptr IRecordInfo {.inline.} = self.union1.struct1.union1.struct1.pRecInfo +proc pRecInfo*(self: var VARIANT): var ptr IRecordInfo {.inline.} = self.union1.struct1.union1.struct1.pRecInfo +proc `decVal=`*(self: var VARIANT, x: DECIMAL) {.inline.} = self.union1.decVal = x +proc decVal*(self: VARIANT): DECIMAL {.inline.} = self.union1.decVal +proc decVal*(self: var VARIANT): var DECIMAL {.inline.} = self.union1.decVal +proc `llVal=`*(self: var wireVARIANT, x: LONGLONG) {.inline.} = self.union1.llVal = x +proc llVal*(self: wireVARIANT): LONGLONG {.inline.} = self.union1.llVal +proc llVal*(self: var wireVARIANT): var LONGLONG {.inline.} = self.union1.llVal +proc `lVal=`*(self: var wireVARIANT, x: LONG) {.inline.} = self.union1.lVal = x +proc lVal*(self: wireVARIANT): LONG {.inline.} = self.union1.lVal +proc lVal*(self: var wireVARIANT): var LONG {.inline.} = self.union1.lVal +proc `bVal=`*(self: var wireVARIANT, x: BYTE) {.inline.} = self.union1.bVal = x +proc bVal*(self: wireVARIANT): BYTE {.inline.} = self.union1.bVal +proc bVal*(self: var wireVARIANT): var BYTE {.inline.} = self.union1.bVal +proc `iVal=`*(self: var wireVARIANT, x: SHORT) {.inline.} = self.union1.iVal = x +proc iVal*(self: wireVARIANT): SHORT {.inline.} = self.union1.iVal +proc iVal*(self: var wireVARIANT): var SHORT {.inline.} = self.union1.iVal +proc `fltVal=`*(self: var wireVARIANT, x: FLOAT) {.inline.} = self.union1.fltVal = x +proc fltVal*(self: wireVARIANT): FLOAT {.inline.} = self.union1.fltVal +proc fltVal*(self: var wireVARIANT): var FLOAT {.inline.} = self.union1.fltVal +proc `dblVal=`*(self: var wireVARIANT, x: DOUBLE) {.inline.} = self.union1.dblVal = x +proc dblVal*(self: wireVARIANT): DOUBLE {.inline.} = self.union1.dblVal +proc dblVal*(self: var wireVARIANT): var DOUBLE {.inline.} = self.union1.dblVal +proc `boolVal=`*(self: var wireVARIANT, x: VARIANT_BOOL) {.inline.} = self.union1.boolVal = x +proc boolVal*(self: wireVARIANT): VARIANT_BOOL {.inline.} = self.union1.boolVal +proc boolVal*(self: var wireVARIANT): var VARIANT_BOOL {.inline.} = self.union1.boolVal +proc `scode=`*(self: var wireVARIANT, x: SCODE) {.inline.} = self.union1.scode = x +proc scode*(self: wireVARIANT): SCODE {.inline.} = self.union1.scode +proc scode*(self: var wireVARIANT): var SCODE {.inline.} = self.union1.scode +proc `cyVal=`*(self: var wireVARIANT, x: CY) {.inline.} = self.union1.cyVal = x +proc cyVal*(self: wireVARIANT): CY {.inline.} = self.union1.cyVal +proc cyVal*(self: var wireVARIANT): var CY {.inline.} = self.union1.cyVal +proc `date=`*(self: var wireVARIANT, x: DATE) {.inline.} = self.union1.date = x +proc date*(self: wireVARIANT): DATE {.inline.} = self.union1.date +proc date*(self: var wireVARIANT): var DATE {.inline.} = self.union1.date +proc `bstrVal=`*(self: var wireVARIANT, x: wireBSTR) {.inline.} = self.union1.bstrVal = x +proc bstrVal*(self: wireVARIANT): wireBSTR {.inline.} = self.union1.bstrVal +proc bstrVal*(self: var wireVARIANT): var wireBSTR {.inline.} = self.union1.bstrVal +proc `punkVal=`*(self: var wireVARIANT, x: ptr IUnknown) {.inline.} = self.union1.punkVal = x +proc punkVal*(self: wireVARIANT): ptr IUnknown {.inline.} = self.union1.punkVal +proc punkVal*(self: var wireVARIANT): var ptr IUnknown {.inline.} = self.union1.punkVal +proc `pdispVal=`*(self: var wireVARIANT, x: ptr IDispatch) {.inline.} = self.union1.pdispVal = x +proc pdispVal*(self: wireVARIANT): ptr IDispatch {.inline.} = self.union1.pdispVal +proc pdispVal*(self: var wireVARIANT): var ptr IDispatch {.inline.} = self.union1.pdispVal +proc `parray=`*(self: var wireVARIANT, x: wirePSAFEARRAY) {.inline.} = self.union1.parray = x +proc parray*(self: wireVARIANT): wirePSAFEARRAY {.inline.} = self.union1.parray +proc parray*(self: var wireVARIANT): var wirePSAFEARRAY {.inline.} = self.union1.parray +proc `brecVal=`*(self: var wireVARIANT, x: wireBRECORD) {.inline.} = self.union1.brecVal = x +proc brecVal*(self: wireVARIANT): wireBRECORD {.inline.} = self.union1.brecVal +proc brecVal*(self: var wireVARIANT): var wireBRECORD {.inline.} = self.union1.brecVal +proc `pbVal=`*(self: var wireVARIANT, x: ptr BYTE) {.inline.} = self.union1.pbVal = x +proc pbVal*(self: wireVARIANT): ptr BYTE {.inline.} = self.union1.pbVal +proc pbVal*(self: var wireVARIANT): var ptr BYTE {.inline.} = self.union1.pbVal +proc `piVal=`*(self: var wireVARIANT, x: ptr SHORT) {.inline.} = self.union1.piVal = x +proc piVal*(self: wireVARIANT): ptr SHORT {.inline.} = self.union1.piVal +proc piVal*(self: var wireVARIANT): var ptr SHORT {.inline.} = self.union1.piVal +proc `plVal=`*(self: var wireVARIANT, x: ptr LONG) {.inline.} = self.union1.plVal = x +proc plVal*(self: wireVARIANT): ptr LONG {.inline.} = self.union1.plVal +proc plVal*(self: var wireVARIANT): var ptr LONG {.inline.} = self.union1.plVal +proc `pllVal=`*(self: var wireVARIANT, x: ptr LONGLONG) {.inline.} = self.union1.pllVal = x +proc pllVal*(self: wireVARIANT): ptr LONGLONG {.inline.} = self.union1.pllVal +proc pllVal*(self: var wireVARIANT): var ptr LONGLONG {.inline.} = self.union1.pllVal +proc `pfltVal=`*(self: var wireVARIANT, x: ptr FLOAT) {.inline.} = self.union1.pfltVal = x +proc pfltVal*(self: wireVARIANT): ptr FLOAT {.inline.} = self.union1.pfltVal +proc pfltVal*(self: var wireVARIANT): var ptr FLOAT {.inline.} = self.union1.pfltVal +proc `pdblVal=`*(self: var wireVARIANT, x: ptr DOUBLE) {.inline.} = self.union1.pdblVal = x +proc pdblVal*(self: wireVARIANT): ptr DOUBLE {.inline.} = self.union1.pdblVal +proc pdblVal*(self: var wireVARIANT): var ptr DOUBLE {.inline.} = self.union1.pdblVal +proc `pboolVal=`*(self: var wireVARIANT, x: ptr VARIANT_BOOL) {.inline.} = self.union1.pboolVal = x +proc pboolVal*(self: wireVARIANT): ptr VARIANT_BOOL {.inline.} = self.union1.pboolVal +proc pboolVal*(self: var wireVARIANT): var ptr VARIANT_BOOL {.inline.} = self.union1.pboolVal +proc `pscode=`*(self: var wireVARIANT, x: ptr SCODE) {.inline.} = self.union1.pscode = x +proc pscode*(self: wireVARIANT): ptr SCODE {.inline.} = self.union1.pscode +proc pscode*(self: var wireVARIANT): var ptr SCODE {.inline.} = self.union1.pscode +proc `pcyVal=`*(self: var wireVARIANT, x: ptr CY) {.inline.} = self.union1.pcyVal = x +proc pcyVal*(self: wireVARIANT): ptr CY {.inline.} = self.union1.pcyVal +proc pcyVal*(self: var wireVARIANT): var ptr CY {.inline.} = self.union1.pcyVal +proc `pdate=`*(self: var wireVARIANT, x: ptr DATE) {.inline.} = self.union1.pdate = x +proc pdate*(self: wireVARIANT): ptr DATE {.inline.} = self.union1.pdate +proc pdate*(self: var wireVARIANT): var ptr DATE {.inline.} = self.union1.pdate +proc `pbstrVal=`*(self: var wireVARIANT, x: ptr wireBSTR) {.inline.} = self.union1.pbstrVal = x +proc pbstrVal*(self: wireVARIANT): ptr wireBSTR {.inline.} = self.union1.pbstrVal +proc pbstrVal*(self: var wireVARIANT): var ptr wireBSTR {.inline.} = self.union1.pbstrVal +proc `ppunkVal=`*(self: var wireVARIANT, x: ptr ptr IUnknown) {.inline.} = self.union1.ppunkVal = x +proc ppunkVal*(self: wireVARIANT): ptr ptr IUnknown {.inline.} = self.union1.ppunkVal +proc ppunkVal*(self: var wireVARIANT): var ptr ptr IUnknown {.inline.} = self.union1.ppunkVal +proc `ppdispVal=`*(self: var wireVARIANT, x: ptr ptr IDispatch) {.inline.} = self.union1.ppdispVal = x +proc ppdispVal*(self: wireVARIANT): ptr ptr IDispatch {.inline.} = self.union1.ppdispVal +proc ppdispVal*(self: var wireVARIANT): var ptr ptr IDispatch {.inline.} = self.union1.ppdispVal +proc `pparray=`*(self: var wireVARIANT, x: ptr wirePSAFEARRAY) {.inline.} = self.union1.pparray = x +proc pparray*(self: wireVARIANT): ptr wirePSAFEARRAY {.inline.} = self.union1.pparray +proc pparray*(self: var wireVARIANT): var ptr wirePSAFEARRAY {.inline.} = self.union1.pparray +proc `pvarVal=`*(self: var wireVARIANT, x: ptr wireVARIANT) {.inline.} = self.union1.pvarVal = x +proc pvarVal*(self: wireVARIANT): ptr wireVARIANT {.inline.} = self.union1.pvarVal +proc pvarVal*(self: var wireVARIANT): var ptr wireVARIANT {.inline.} = self.union1.pvarVal +proc `cVal=`*(self: var wireVARIANT, x: CHAR) {.inline.} = self.union1.cVal = x +proc cVal*(self: wireVARIANT): CHAR {.inline.} = self.union1.cVal +proc cVal*(self: var wireVARIANT): var CHAR {.inline.} = self.union1.cVal +proc `uiVal=`*(self: var wireVARIANT, x: USHORT) {.inline.} = self.union1.uiVal = x +proc uiVal*(self: wireVARIANT): USHORT {.inline.} = self.union1.uiVal +proc uiVal*(self: var wireVARIANT): var USHORT {.inline.} = self.union1.uiVal +proc `ulVal=`*(self: var wireVARIANT, x: ULONG) {.inline.} = self.union1.ulVal = x +proc ulVal*(self: wireVARIANT): ULONG {.inline.} = self.union1.ulVal +proc ulVal*(self: var wireVARIANT): var ULONG {.inline.} = self.union1.ulVal +proc `ullVal=`*(self: var wireVARIANT, x: ULONGLONG) {.inline.} = self.union1.ullVal = x +proc ullVal*(self: wireVARIANT): ULONGLONG {.inline.} = self.union1.ullVal +proc ullVal*(self: var wireVARIANT): var ULONGLONG {.inline.} = self.union1.ullVal +proc `intVal=`*(self: var wireVARIANT, x: INT) {.inline.} = self.union1.intVal = x +proc intVal*(self: wireVARIANT): INT {.inline.} = self.union1.intVal +proc intVal*(self: var wireVARIANT): var INT {.inline.} = self.union1.intVal +proc `uintVal=`*(self: var wireVARIANT, x: UINT) {.inline.} = self.union1.uintVal = x +proc uintVal*(self: wireVARIANT): UINT {.inline.} = self.union1.uintVal +proc uintVal*(self: var wireVARIANT): var UINT {.inline.} = self.union1.uintVal +proc `decVal=`*(self: var wireVARIANT, x: DECIMAL) {.inline.} = self.union1.decVal = x +proc decVal*(self: wireVARIANT): DECIMAL {.inline.} = self.union1.decVal +proc decVal*(self: var wireVARIANT): var DECIMAL {.inline.} = self.union1.decVal +proc `pdecVal=`*(self: var wireVARIANT, x: ptr DECIMAL) {.inline.} = self.union1.pdecVal = x +proc pdecVal*(self: wireVARIANT): ptr DECIMAL {.inline.} = self.union1.pdecVal +proc pdecVal*(self: var wireVARIANT): var ptr DECIMAL {.inline.} = self.union1.pdecVal +proc `pcVal=`*(self: var wireVARIANT, x: ptr CHAR) {.inline.} = self.union1.pcVal = x +proc pcVal*(self: wireVARIANT): ptr CHAR {.inline.} = self.union1.pcVal +proc pcVal*(self: var wireVARIANT): var ptr CHAR {.inline.} = self.union1.pcVal +proc `puiVal=`*(self: var wireVARIANT, x: ptr USHORT) {.inline.} = self.union1.puiVal = x +proc puiVal*(self: wireVARIANT): ptr USHORT {.inline.} = self.union1.puiVal +proc puiVal*(self: var wireVARIANT): var ptr USHORT {.inline.} = self.union1.puiVal +proc `pulVal=`*(self: var wireVARIANT, x: ptr ULONG) {.inline.} = self.union1.pulVal = x +proc pulVal*(self: wireVARIANT): ptr ULONG {.inline.} = self.union1.pulVal +proc pulVal*(self: var wireVARIANT): var ptr ULONG {.inline.} = self.union1.pulVal +proc `pullVal=`*(self: var wireVARIANT, x: ptr ULONGLONG) {.inline.} = self.union1.pullVal = x +proc pullVal*(self: wireVARIANT): ptr ULONGLONG {.inline.} = self.union1.pullVal +proc pullVal*(self: var wireVARIANT): var ptr ULONGLONG {.inline.} = self.union1.pullVal +proc `pintVal=`*(self: var wireVARIANT, x: ptr INT) {.inline.} = self.union1.pintVal = x +proc pintVal*(self: wireVARIANT): ptr INT {.inline.} = self.union1.pintVal +proc pintVal*(self: var wireVARIANT): var ptr INT {.inline.} = self.union1.pintVal +proc `puintVal=`*(self: var wireVARIANT, x: ptr UINT) {.inline.} = self.union1.puintVal = x +proc puintVal*(self: wireVARIANT): ptr UINT {.inline.} = self.union1.puintVal +proc puintVal*(self: var wireVARIANT): var ptr UINT {.inline.} = self.union1.puintVal +proc `lptdesc=`*(self: var TYPEDESC, x: ptr TYPEDESC) {.inline.} = self.union1.lptdesc = x +proc lptdesc*(self: TYPEDESC): ptr TYPEDESC {.inline.} = self.union1.lptdesc +proc lptdesc*(self: var TYPEDESC): var ptr TYPEDESC {.inline.} = self.union1.lptdesc +proc `lpadesc=`*(self: var TYPEDESC, x: ptr ARRAYDESC) {.inline.} = self.union1.lpadesc = x +proc lpadesc*(self: TYPEDESC): ptr ARRAYDESC {.inline.} = self.union1.lpadesc +proc lpadesc*(self: var TYPEDESC): var ptr ARRAYDESC {.inline.} = self.union1.lpadesc +proc `hreftype=`*(self: var TYPEDESC, x: HREFTYPE) {.inline.} = self.union1.hreftype = x +proc hreftype*(self: TYPEDESC): HREFTYPE {.inline.} = self.union1.hreftype +proc hreftype*(self: var TYPEDESC): var HREFTYPE {.inline.} = self.union1.hreftype +proc `idldesc=`*(self: var ELEMDESC, x: IDLDESC) {.inline.} = self.union1.idldesc = x +proc idldesc*(self: ELEMDESC): IDLDESC {.inline.} = self.union1.idldesc +proc idldesc*(self: var ELEMDESC): var IDLDESC {.inline.} = self.union1.idldesc +proc `paramdesc=`*(self: var ELEMDESC, x: PARAMDESC) {.inline.} = self.union1.paramdesc = x +proc paramdesc*(self: ELEMDESC): PARAMDESC {.inline.} = self.union1.paramdesc +proc paramdesc*(self: var ELEMDESC): var PARAMDESC {.inline.} = self.union1.paramdesc +proc `oInst=`*(self: var VARDESC, x: ULONG) {.inline.} = self.union1.oInst = x +proc oInst*(self: VARDESC): ULONG {.inline.} = self.union1.oInst +proc oInst*(self: var VARDESC): var ULONG {.inline.} = self.union1.oInst +proc `lpvarValue=`*(self: var VARDESC, x: ptr VARIANT) {.inline.} = self.union1.lpvarValue = x +proc lpvarValue*(self: VARDESC): ptr VARIANT {.inline.} = self.union1.lpvarValue +proc lpvarValue*(self: var VARDESC): var ptr VARIANT {.inline.} = self.union1.lpvarValue +proc `vt=`*(self: var PROPVARIANT, x: VARTYPE) {.inline.} = self.union1.struct1.vt = x +proc vt*(self: PROPVARIANT): VARTYPE {.inline.} = self.union1.struct1.vt +proc vt*(self: var PROPVARIANT): var VARTYPE {.inline.} = self.union1.struct1.vt +proc `wReserved1=`*(self: var PROPVARIANT, x: PROPVAR_PAD1) {.inline.} = self.union1.struct1.wReserved1 = x +proc wReserved1*(self: PROPVARIANT): PROPVAR_PAD1 {.inline.} = self.union1.struct1.wReserved1 +proc wReserved1*(self: var PROPVARIANT): var PROPVAR_PAD1 {.inline.} = self.union1.struct1.wReserved1 +proc `wReserved2=`*(self: var PROPVARIANT, x: PROPVAR_PAD2) {.inline.} = self.union1.struct1.wReserved2 = x +proc wReserved2*(self: PROPVARIANT): PROPVAR_PAD2 {.inline.} = self.union1.struct1.wReserved2 +proc wReserved2*(self: var PROPVARIANT): var PROPVAR_PAD2 {.inline.} = self.union1.struct1.wReserved2 +proc `wReserved3=`*(self: var PROPVARIANT, x: PROPVAR_PAD3) {.inline.} = self.union1.struct1.wReserved3 = x +proc wReserved3*(self: PROPVARIANT): PROPVAR_PAD3 {.inline.} = self.union1.struct1.wReserved3 +proc wReserved3*(self: var PROPVARIANT): var PROPVAR_PAD3 {.inline.} = self.union1.struct1.wReserved3 +proc `cVal=`*(self: var PROPVARIANT, x: CHAR) {.inline.} = self.union1.struct1.union1.cVal = x +proc cVal*(self: PROPVARIANT): CHAR {.inline.} = self.union1.struct1.union1.cVal +proc cVal*(self: var PROPVARIANT): var CHAR {.inline.} = self.union1.struct1.union1.cVal +proc `bVal=`*(self: var PROPVARIANT, x: UCHAR) {.inline.} = self.union1.struct1.union1.bVal = x +proc bVal*(self: PROPVARIANT): UCHAR {.inline.} = self.union1.struct1.union1.bVal +proc bVal*(self: var PROPVARIANT): var UCHAR {.inline.} = self.union1.struct1.union1.bVal +proc `iVal=`*(self: var PROPVARIANT, x: SHORT) {.inline.} = self.union1.struct1.union1.iVal = x +proc iVal*(self: PROPVARIANT): SHORT {.inline.} = self.union1.struct1.union1.iVal +proc iVal*(self: var PROPVARIANT): var SHORT {.inline.} = self.union1.struct1.union1.iVal +proc `uiVal=`*(self: var PROPVARIANT, x: USHORT) {.inline.} = self.union1.struct1.union1.uiVal = x +proc uiVal*(self: PROPVARIANT): USHORT {.inline.} = self.union1.struct1.union1.uiVal +proc uiVal*(self: var PROPVARIANT): var USHORT {.inline.} = self.union1.struct1.union1.uiVal +proc `lVal=`*(self: var PROPVARIANT, x: LONG) {.inline.} = self.union1.struct1.union1.lVal = x +proc lVal*(self: PROPVARIANT): LONG {.inline.} = self.union1.struct1.union1.lVal +proc lVal*(self: var PROPVARIANT): var LONG {.inline.} = self.union1.struct1.union1.lVal +proc `ulVal=`*(self: var PROPVARIANT, x: ULONG) {.inline.} = self.union1.struct1.union1.ulVal = x +proc ulVal*(self: PROPVARIANT): ULONG {.inline.} = self.union1.struct1.union1.ulVal +proc ulVal*(self: var PROPVARIANT): var ULONG {.inline.} = self.union1.struct1.union1.ulVal +proc `intVal=`*(self: var PROPVARIANT, x: INT) {.inline.} = self.union1.struct1.union1.intVal = x +proc intVal*(self: PROPVARIANT): INT {.inline.} = self.union1.struct1.union1.intVal +proc intVal*(self: var PROPVARIANT): var INT {.inline.} = self.union1.struct1.union1.intVal +proc `uintVal=`*(self: var PROPVARIANT, x: UINT) {.inline.} = self.union1.struct1.union1.uintVal = x +proc uintVal*(self: PROPVARIANT): UINT {.inline.} = self.union1.struct1.union1.uintVal +proc uintVal*(self: var PROPVARIANT): var UINT {.inline.} = self.union1.struct1.union1.uintVal +proc `hVal=`*(self: var PROPVARIANT, x: LARGE_INTEGER) {.inline.} = self.union1.struct1.union1.hVal = x +proc hVal*(self: PROPVARIANT): LARGE_INTEGER {.inline.} = self.union1.struct1.union1.hVal +proc hVal*(self: var PROPVARIANT): var LARGE_INTEGER {.inline.} = self.union1.struct1.union1.hVal +proc `uhVal=`*(self: var PROPVARIANT, x: ULARGE_INTEGER) {.inline.} = self.union1.struct1.union1.uhVal = x +proc uhVal*(self: PROPVARIANT): ULARGE_INTEGER {.inline.} = self.union1.struct1.union1.uhVal +proc uhVal*(self: var PROPVARIANT): var ULARGE_INTEGER {.inline.} = self.union1.struct1.union1.uhVal +proc `fltVal=`*(self: var PROPVARIANT, x: FLOAT) {.inline.} = self.union1.struct1.union1.fltVal = x +proc fltVal*(self: PROPVARIANT): FLOAT {.inline.} = self.union1.struct1.union1.fltVal +proc fltVal*(self: var PROPVARIANT): var FLOAT {.inline.} = self.union1.struct1.union1.fltVal +proc `dblVal=`*(self: var PROPVARIANT, x: DOUBLE) {.inline.} = self.union1.struct1.union1.dblVal = x +proc dblVal*(self: PROPVARIANT): DOUBLE {.inline.} = self.union1.struct1.union1.dblVal +proc dblVal*(self: var PROPVARIANT): var DOUBLE {.inline.} = self.union1.struct1.union1.dblVal +proc `boolVal=`*(self: var PROPVARIANT, x: VARIANT_BOOL) {.inline.} = self.union1.struct1.union1.boolVal = x +proc boolVal*(self: PROPVARIANT): VARIANT_BOOL {.inline.} = self.union1.struct1.union1.boolVal +proc boolVal*(self: var PROPVARIANT): var VARIANT_BOOL {.inline.} = self.union1.struct1.union1.boolVal +proc `scode=`*(self: var PROPVARIANT, x: SCODE) {.inline.} = self.union1.struct1.union1.scode = x +proc scode*(self: PROPVARIANT): SCODE {.inline.} = self.union1.struct1.union1.scode +proc scode*(self: var PROPVARIANT): var SCODE {.inline.} = self.union1.struct1.union1.scode +proc `cyVal=`*(self: var PROPVARIANT, x: CY) {.inline.} = self.union1.struct1.union1.cyVal = x +proc cyVal*(self: PROPVARIANT): CY {.inline.} = self.union1.struct1.union1.cyVal +proc cyVal*(self: var PROPVARIANT): var CY {.inline.} = self.union1.struct1.union1.cyVal +proc `date=`*(self: var PROPVARIANT, x: DATE) {.inline.} = self.union1.struct1.union1.date = x +proc date*(self: PROPVARIANT): DATE {.inline.} = self.union1.struct1.union1.date +proc date*(self: var PROPVARIANT): var DATE {.inline.} = self.union1.struct1.union1.date +proc `filetime=`*(self: var PROPVARIANT, x: FILETIME) {.inline.} = self.union1.struct1.union1.filetime = x +proc filetime*(self: PROPVARIANT): FILETIME {.inline.} = self.union1.struct1.union1.filetime +proc filetime*(self: var PROPVARIANT): var FILETIME {.inline.} = self.union1.struct1.union1.filetime +proc `puuid=`*(self: var PROPVARIANT, x: ptr CLSID) {.inline.} = self.union1.struct1.union1.puuid = x +proc puuid*(self: PROPVARIANT): ptr CLSID {.inline.} = self.union1.struct1.union1.puuid +proc puuid*(self: var PROPVARIANT): var ptr CLSID {.inline.} = self.union1.struct1.union1.puuid +proc `pclipdata=`*(self: var PROPVARIANT, x: ptr CLIPDATA) {.inline.} = self.union1.struct1.union1.pclipdata = x +proc pclipdata*(self: PROPVARIANT): ptr CLIPDATA {.inline.} = self.union1.struct1.union1.pclipdata +proc pclipdata*(self: var PROPVARIANT): var ptr CLIPDATA {.inline.} = self.union1.struct1.union1.pclipdata +proc `bstrVal=`*(self: var PROPVARIANT, x: BSTR) {.inline.} = self.union1.struct1.union1.bstrVal = x +proc bstrVal*(self: PROPVARIANT): BSTR {.inline.} = self.union1.struct1.union1.bstrVal +proc bstrVal*(self: var PROPVARIANT): var BSTR {.inline.} = self.union1.struct1.union1.bstrVal +proc `bstrblobVal=`*(self: var PROPVARIANT, x: BSTRBLOB) {.inline.} = self.union1.struct1.union1.bstrblobVal = x +proc bstrblobVal*(self: PROPVARIANT): BSTRBLOB {.inline.} = self.union1.struct1.union1.bstrblobVal +proc bstrblobVal*(self: var PROPVARIANT): var BSTRBLOB {.inline.} = self.union1.struct1.union1.bstrblobVal +proc `blob=`*(self: var PROPVARIANT, x: BLOB) {.inline.} = self.union1.struct1.union1.blob = x +proc blob*(self: PROPVARIANT): BLOB {.inline.} = self.union1.struct1.union1.blob +proc blob*(self: var PROPVARIANT): var BLOB {.inline.} = self.union1.struct1.union1.blob +proc `pszVal=`*(self: var PROPVARIANT, x: LPSTR) {.inline.} = self.union1.struct1.union1.pszVal = x +proc pszVal*(self: PROPVARIANT): LPSTR {.inline.} = self.union1.struct1.union1.pszVal +proc pszVal*(self: var PROPVARIANT): var LPSTR {.inline.} = self.union1.struct1.union1.pszVal +proc `pwszVal=`*(self: var PROPVARIANT, x: LPWSTR) {.inline.} = self.union1.struct1.union1.pwszVal = x +proc pwszVal*(self: PROPVARIANT): LPWSTR {.inline.} = self.union1.struct1.union1.pwszVal +proc pwszVal*(self: var PROPVARIANT): var LPWSTR {.inline.} = self.union1.struct1.union1.pwszVal +proc `punkVal=`*(self: var PROPVARIANT, x: ptr IUnknown) {.inline.} = self.union1.struct1.union1.punkVal = x +proc punkVal*(self: PROPVARIANT): ptr IUnknown {.inline.} = self.union1.struct1.union1.punkVal +proc punkVal*(self: var PROPVARIANT): var ptr IUnknown {.inline.} = self.union1.struct1.union1.punkVal +proc `pdispVal=`*(self: var PROPVARIANT, x: ptr IDispatch) {.inline.} = self.union1.struct1.union1.pdispVal = x +proc pdispVal*(self: PROPVARIANT): ptr IDispatch {.inline.} = self.union1.struct1.union1.pdispVal +proc pdispVal*(self: var PROPVARIANT): var ptr IDispatch {.inline.} = self.union1.struct1.union1.pdispVal +proc `pStream=`*(self: var PROPVARIANT, x: ptr IStream) {.inline.} = self.union1.struct1.union1.pStream = x +proc pStream*(self: PROPVARIANT): ptr IStream {.inline.} = self.union1.struct1.union1.pStream +proc pStream*(self: var PROPVARIANT): var ptr IStream {.inline.} = self.union1.struct1.union1.pStream +proc `pStorage=`*(self: var PROPVARIANT, x: ptr IStorage) {.inline.} = self.union1.struct1.union1.pStorage = x +proc pStorage*(self: PROPVARIANT): ptr IStorage {.inline.} = self.union1.struct1.union1.pStorage +proc pStorage*(self: var PROPVARIANT): var ptr IStorage {.inline.} = self.union1.struct1.union1.pStorage +proc `pVersionedStream=`*(self: var PROPVARIANT, x: LPVERSIONEDSTREAM) {.inline.} = self.union1.struct1.union1.pVersionedStream = x +proc pVersionedStream*(self: PROPVARIANT): LPVERSIONEDSTREAM {.inline.} = self.union1.struct1.union1.pVersionedStream +proc pVersionedStream*(self: var PROPVARIANT): var LPVERSIONEDSTREAM {.inline.} = self.union1.struct1.union1.pVersionedStream +proc `parray=`*(self: var PROPVARIANT, x: LPSAFEARRAY) {.inline.} = self.union1.struct1.union1.parray = x +proc parray*(self: PROPVARIANT): LPSAFEARRAY {.inline.} = self.union1.struct1.union1.parray +proc parray*(self: var PROPVARIANT): var LPSAFEARRAY {.inline.} = self.union1.struct1.union1.parray +proc `cac=`*(self: var PROPVARIANT, x: CAC) {.inline.} = self.union1.struct1.union1.cac = x +proc cac*(self: PROPVARIANT): CAC {.inline.} = self.union1.struct1.union1.cac +proc cac*(self: var PROPVARIANT): var CAC {.inline.} = self.union1.struct1.union1.cac +proc `caub=`*(self: var PROPVARIANT, x: CAUB) {.inline.} = self.union1.struct1.union1.caub = x +proc caub*(self: PROPVARIANT): CAUB {.inline.} = self.union1.struct1.union1.caub +proc caub*(self: var PROPVARIANT): var CAUB {.inline.} = self.union1.struct1.union1.caub +proc `cai=`*(self: var PROPVARIANT, x: CAI) {.inline.} = self.union1.struct1.union1.cai = x +proc cai*(self: PROPVARIANT): CAI {.inline.} = self.union1.struct1.union1.cai +proc cai*(self: var PROPVARIANT): var CAI {.inline.} = self.union1.struct1.union1.cai +proc `caui=`*(self: var PROPVARIANT, x: CAUI) {.inline.} = self.union1.struct1.union1.caui = x +proc caui*(self: PROPVARIANT): CAUI {.inline.} = self.union1.struct1.union1.caui +proc caui*(self: var PROPVARIANT): var CAUI {.inline.} = self.union1.struct1.union1.caui +proc `cal=`*(self: var PROPVARIANT, x: CAL) {.inline.} = self.union1.struct1.union1.cal = x +proc cal*(self: PROPVARIANT): CAL {.inline.} = self.union1.struct1.union1.cal +proc cal*(self: var PROPVARIANT): var CAL {.inline.} = self.union1.struct1.union1.cal +proc `caul=`*(self: var PROPVARIANT, x: CAUL) {.inline.} = self.union1.struct1.union1.caul = x +proc caul*(self: PROPVARIANT): CAUL {.inline.} = self.union1.struct1.union1.caul +proc caul*(self: var PROPVARIANT): var CAUL {.inline.} = self.union1.struct1.union1.caul +proc `cah=`*(self: var PROPVARIANT, x: CAH) {.inline.} = self.union1.struct1.union1.cah = x +proc cah*(self: PROPVARIANT): CAH {.inline.} = self.union1.struct1.union1.cah +proc cah*(self: var PROPVARIANT): var CAH {.inline.} = self.union1.struct1.union1.cah +proc `cauh=`*(self: var PROPVARIANT, x: CAUH) {.inline.} = self.union1.struct1.union1.cauh = x +proc cauh*(self: PROPVARIANT): CAUH {.inline.} = self.union1.struct1.union1.cauh +proc cauh*(self: var PROPVARIANT): var CAUH {.inline.} = self.union1.struct1.union1.cauh +proc `caflt=`*(self: var PROPVARIANT, x: CAFLT) {.inline.} = self.union1.struct1.union1.caflt = x +proc caflt*(self: PROPVARIANT): CAFLT {.inline.} = self.union1.struct1.union1.caflt +proc caflt*(self: var PROPVARIANT): var CAFLT {.inline.} = self.union1.struct1.union1.caflt +proc `cadbl=`*(self: var PROPVARIANT, x: CADBL) {.inline.} = self.union1.struct1.union1.cadbl = x +proc cadbl*(self: PROPVARIANT): CADBL {.inline.} = self.union1.struct1.union1.cadbl +proc cadbl*(self: var PROPVARIANT): var CADBL {.inline.} = self.union1.struct1.union1.cadbl +proc `cabool=`*(self: var PROPVARIANT, x: CABOOL) {.inline.} = self.union1.struct1.union1.cabool = x +proc cabool*(self: PROPVARIANT): CABOOL {.inline.} = self.union1.struct1.union1.cabool +proc cabool*(self: var PROPVARIANT): var CABOOL {.inline.} = self.union1.struct1.union1.cabool +proc `cascode=`*(self: var PROPVARIANT, x: CASCODE) {.inline.} = self.union1.struct1.union1.cascode = x +proc cascode*(self: PROPVARIANT): CASCODE {.inline.} = self.union1.struct1.union1.cascode +proc cascode*(self: var PROPVARIANT): var CASCODE {.inline.} = self.union1.struct1.union1.cascode +proc `cacy=`*(self: var PROPVARIANT, x: CACY) {.inline.} = self.union1.struct1.union1.cacy = x +proc cacy*(self: PROPVARIANT): CACY {.inline.} = self.union1.struct1.union1.cacy +proc cacy*(self: var PROPVARIANT): var CACY {.inline.} = self.union1.struct1.union1.cacy +proc `cadate=`*(self: var PROPVARIANT, x: CADATE) {.inline.} = self.union1.struct1.union1.cadate = x +proc cadate*(self: PROPVARIANT): CADATE {.inline.} = self.union1.struct1.union1.cadate +proc cadate*(self: var PROPVARIANT): var CADATE {.inline.} = self.union1.struct1.union1.cadate +proc `cafiletime=`*(self: var PROPVARIANT, x: CAFILETIME) {.inline.} = self.union1.struct1.union1.cafiletime = x +proc cafiletime*(self: PROPVARIANT): CAFILETIME {.inline.} = self.union1.struct1.union1.cafiletime +proc cafiletime*(self: var PROPVARIANT): var CAFILETIME {.inline.} = self.union1.struct1.union1.cafiletime +proc `cauuid=`*(self: var PROPVARIANT, x: CACLSID) {.inline.} = self.union1.struct1.union1.cauuid = x +proc cauuid*(self: PROPVARIANT): CACLSID {.inline.} = self.union1.struct1.union1.cauuid +proc cauuid*(self: var PROPVARIANT): var CACLSID {.inline.} = self.union1.struct1.union1.cauuid +proc `caclipdata=`*(self: var PROPVARIANT, x: CACLIPDATA) {.inline.} = self.union1.struct1.union1.caclipdata = x +proc caclipdata*(self: PROPVARIANT): CACLIPDATA {.inline.} = self.union1.struct1.union1.caclipdata +proc caclipdata*(self: var PROPVARIANT): var CACLIPDATA {.inline.} = self.union1.struct1.union1.caclipdata +proc `cabstr=`*(self: var PROPVARIANT, x: CABSTR) {.inline.} = self.union1.struct1.union1.cabstr = x +proc cabstr*(self: PROPVARIANT): CABSTR {.inline.} = self.union1.struct1.union1.cabstr +proc cabstr*(self: var PROPVARIANT): var CABSTR {.inline.} = self.union1.struct1.union1.cabstr +proc `cabstrblob=`*(self: var PROPVARIANT, x: CABSTRBLOB) {.inline.} = self.union1.struct1.union1.cabstrblob = x +proc cabstrblob*(self: PROPVARIANT): CABSTRBLOB {.inline.} = self.union1.struct1.union1.cabstrblob +proc cabstrblob*(self: var PROPVARIANT): var CABSTRBLOB {.inline.} = self.union1.struct1.union1.cabstrblob +proc `calpstr=`*(self: var PROPVARIANT, x: CALPSTR) {.inline.} = self.union1.struct1.union1.calpstr = x +proc calpstr*(self: PROPVARIANT): CALPSTR {.inline.} = self.union1.struct1.union1.calpstr +proc calpstr*(self: var PROPVARIANT): var CALPSTR {.inline.} = self.union1.struct1.union1.calpstr +proc `calpwstr=`*(self: var PROPVARIANT, x: CALPWSTR) {.inline.} = self.union1.struct1.union1.calpwstr = x +proc calpwstr*(self: PROPVARIANT): CALPWSTR {.inline.} = self.union1.struct1.union1.calpwstr +proc calpwstr*(self: var PROPVARIANT): var CALPWSTR {.inline.} = self.union1.struct1.union1.calpwstr +proc `capropvar=`*(self: var PROPVARIANT, x: CAPROPVARIANT) {.inline.} = self.union1.struct1.union1.capropvar = x +proc capropvar*(self: PROPVARIANT): CAPROPVARIANT {.inline.} = self.union1.struct1.union1.capropvar +proc capropvar*(self: var PROPVARIANT): var CAPROPVARIANT {.inline.} = self.union1.struct1.union1.capropvar +proc `pcVal=`*(self: var PROPVARIANT, x: ptr CHAR) {.inline.} = self.union1.struct1.union1.pcVal = x +proc pcVal*(self: PROPVARIANT): ptr CHAR {.inline.} = self.union1.struct1.union1.pcVal +proc pcVal*(self: var PROPVARIANT): var ptr CHAR {.inline.} = self.union1.struct1.union1.pcVal +proc `pbVal=`*(self: var PROPVARIANT, x: ptr UCHAR) {.inline.} = self.union1.struct1.union1.pbVal = x +proc pbVal*(self: PROPVARIANT): ptr UCHAR {.inline.} = self.union1.struct1.union1.pbVal +proc pbVal*(self: var PROPVARIANT): var ptr UCHAR {.inline.} = self.union1.struct1.union1.pbVal +proc `piVal=`*(self: var PROPVARIANT, x: ptr SHORT) {.inline.} = self.union1.struct1.union1.piVal = x +proc piVal*(self: PROPVARIANT): ptr SHORT {.inline.} = self.union1.struct1.union1.piVal +proc piVal*(self: var PROPVARIANT): var ptr SHORT {.inline.} = self.union1.struct1.union1.piVal +proc `puiVal=`*(self: var PROPVARIANT, x: ptr USHORT) {.inline.} = self.union1.struct1.union1.puiVal = x +proc puiVal*(self: PROPVARIANT): ptr USHORT {.inline.} = self.union1.struct1.union1.puiVal +proc puiVal*(self: var PROPVARIANT): var ptr USHORT {.inline.} = self.union1.struct1.union1.puiVal +proc `plVal=`*(self: var PROPVARIANT, x: ptr LONG) {.inline.} = self.union1.struct1.union1.plVal = x +proc plVal*(self: PROPVARIANT): ptr LONG {.inline.} = self.union1.struct1.union1.plVal +proc plVal*(self: var PROPVARIANT): var ptr LONG {.inline.} = self.union1.struct1.union1.plVal +proc `pulVal=`*(self: var PROPVARIANT, x: ptr ULONG) {.inline.} = self.union1.struct1.union1.pulVal = x +proc pulVal*(self: PROPVARIANT): ptr ULONG {.inline.} = self.union1.struct1.union1.pulVal +proc pulVal*(self: var PROPVARIANT): var ptr ULONG {.inline.} = self.union1.struct1.union1.pulVal +proc `pintVal=`*(self: var PROPVARIANT, x: ptr INT) {.inline.} = self.union1.struct1.union1.pintVal = x +proc pintVal*(self: PROPVARIANT): ptr INT {.inline.} = self.union1.struct1.union1.pintVal +proc pintVal*(self: var PROPVARIANT): var ptr INT {.inline.} = self.union1.struct1.union1.pintVal +proc `puintVal=`*(self: var PROPVARIANT, x: ptr UINT) {.inline.} = self.union1.struct1.union1.puintVal = x +proc puintVal*(self: PROPVARIANT): ptr UINT {.inline.} = self.union1.struct1.union1.puintVal +proc puintVal*(self: var PROPVARIANT): var ptr UINT {.inline.} = self.union1.struct1.union1.puintVal +proc `pfltVal=`*(self: var PROPVARIANT, x: ptr FLOAT) {.inline.} = self.union1.struct1.union1.pfltVal = x +proc pfltVal*(self: PROPVARIANT): ptr FLOAT {.inline.} = self.union1.struct1.union1.pfltVal +proc pfltVal*(self: var PROPVARIANT): var ptr FLOAT {.inline.} = self.union1.struct1.union1.pfltVal +proc `pdblVal=`*(self: var PROPVARIANT, x: ptr DOUBLE) {.inline.} = self.union1.struct1.union1.pdblVal = x +proc pdblVal*(self: PROPVARIANT): ptr DOUBLE {.inline.} = self.union1.struct1.union1.pdblVal +proc pdblVal*(self: var PROPVARIANT): var ptr DOUBLE {.inline.} = self.union1.struct1.union1.pdblVal +proc `pboolVal=`*(self: var PROPVARIANT, x: ptr VARIANT_BOOL) {.inline.} = self.union1.struct1.union1.pboolVal = x +proc pboolVal*(self: PROPVARIANT): ptr VARIANT_BOOL {.inline.} = self.union1.struct1.union1.pboolVal +proc pboolVal*(self: var PROPVARIANT): var ptr VARIANT_BOOL {.inline.} = self.union1.struct1.union1.pboolVal +proc `pdecVal=`*(self: var PROPVARIANT, x: ptr DECIMAL) {.inline.} = self.union1.struct1.union1.pdecVal = x +proc pdecVal*(self: PROPVARIANT): ptr DECIMAL {.inline.} = self.union1.struct1.union1.pdecVal +proc pdecVal*(self: var PROPVARIANT): var ptr DECIMAL {.inline.} = self.union1.struct1.union1.pdecVal +proc `pscode=`*(self: var PROPVARIANT, x: ptr SCODE) {.inline.} = self.union1.struct1.union1.pscode = x +proc pscode*(self: PROPVARIANT): ptr SCODE {.inline.} = self.union1.struct1.union1.pscode +proc pscode*(self: var PROPVARIANT): var ptr SCODE {.inline.} = self.union1.struct1.union1.pscode +proc `pcyVal=`*(self: var PROPVARIANT, x: ptr CY) {.inline.} = self.union1.struct1.union1.pcyVal = x +proc pcyVal*(self: PROPVARIANT): ptr CY {.inline.} = self.union1.struct1.union1.pcyVal +proc pcyVal*(self: var PROPVARIANT): var ptr CY {.inline.} = self.union1.struct1.union1.pcyVal +proc `pdate=`*(self: var PROPVARIANT, x: ptr DATE) {.inline.} = self.union1.struct1.union1.pdate = x +proc pdate*(self: PROPVARIANT): ptr DATE {.inline.} = self.union1.struct1.union1.pdate +proc pdate*(self: var PROPVARIANT): var ptr DATE {.inline.} = self.union1.struct1.union1.pdate +proc `pbstrVal=`*(self: var PROPVARIANT, x: ptr BSTR) {.inline.} = self.union1.struct1.union1.pbstrVal = x +proc pbstrVal*(self: PROPVARIANT): ptr BSTR {.inline.} = self.union1.struct1.union1.pbstrVal +proc pbstrVal*(self: var PROPVARIANT): var ptr BSTR {.inline.} = self.union1.struct1.union1.pbstrVal +proc `ppunkVal=`*(self: var PROPVARIANT, x: ptr ptr IUnknown) {.inline.} = self.union1.struct1.union1.ppunkVal = x +proc ppunkVal*(self: PROPVARIANT): ptr ptr IUnknown {.inline.} = self.union1.struct1.union1.ppunkVal +proc ppunkVal*(self: var PROPVARIANT): var ptr ptr IUnknown {.inline.} = self.union1.struct1.union1.ppunkVal +proc `ppdispVal=`*(self: var PROPVARIANT, x: ptr ptr IDispatch) {.inline.} = self.union1.struct1.union1.ppdispVal = x +proc ppdispVal*(self: PROPVARIANT): ptr ptr IDispatch {.inline.} = self.union1.struct1.union1.ppdispVal +proc ppdispVal*(self: var PROPVARIANT): var ptr ptr IDispatch {.inline.} = self.union1.struct1.union1.ppdispVal +proc `pparray=`*(self: var PROPVARIANT, x: ptr LPSAFEARRAY) {.inline.} = self.union1.struct1.union1.pparray = x +proc pparray*(self: PROPVARIANT): ptr LPSAFEARRAY {.inline.} = self.union1.struct1.union1.pparray +proc pparray*(self: var PROPVARIANT): var ptr LPSAFEARRAY {.inline.} = self.union1.struct1.union1.pparray +proc `pvarVal=`*(self: var PROPVARIANT, x: ptr PROPVARIANT) {.inline.} = self.union1.struct1.union1.pvarVal = x +proc pvarVal*(self: PROPVARIANT): ptr PROPVARIANT {.inline.} = self.union1.struct1.union1.pvarVal +proc pvarVal*(self: var PROPVARIANT): var ptr PROPVARIANT {.inline.} = self.union1.struct1.union1.pvarVal +proc `decVal=`*(self: var PROPVARIANT, x: DECIMAL) {.inline.} = self.union1.decVal = x +proc decVal*(self: PROPVARIANT): DECIMAL {.inline.} = self.union1.decVal +proc decVal*(self: var PROPVARIANT): var DECIMAL {.inline.} = self.union1.decVal +proc `propid=`*(self: var PROPSPEC, x: PROPID) {.inline.} = self.union1.propid = x +proc propid*(self: PROPSPEC): PROPID {.inline.} = self.union1.propid +proc propid*(self: var PROPSPEC): var PROPID {.inline.} = self.union1.propid +proc `lpwstr=`*(self: var PROPSPEC, x: LPOLESTR) {.inline.} = self.union1.lpwstr = x +proc lpwstr*(self: PROPSPEC): LPOLESTR {.inline.} = self.union1.lpwstr +proc lpwstr*(self: var PROPSPEC): var LPOLESTR {.inline.} = self.union1.lpwstr +proc `pOleStr=`*(self: var STRRET, x: LPWSTR) {.inline.} = self.union1.pOleStr = x +proc pOleStr*(self: STRRET): LPWSTR {.inline.} = self.union1.pOleStr +proc pOleStr*(self: var STRRET): var LPWSTR {.inline.} = self.union1.pOleStr +proc `uOffset=`*(self: var STRRET, x: UINT) {.inline.} = self.union1.uOffset = x +proc uOffset*(self: STRRET): UINT {.inline.} = self.union1.uOffset +proc uOffset*(self: var STRRET): var UINT {.inline.} = self.union1.uOffset +proc `cStr=`*(self: var STRRET, x: array[260, char]) {.inline.} = self.union1.cStr = x +proc cStr*(self: STRRET): array[260, char] {.inline.} = self.union1.cStr +proc cStr*(self: var STRRET): var array[260, char] {.inline.} = self.union1.cStr +proc QueryInterface*(self: ptr IUnknown, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryInterface(self, riid, ppvObject) +proc AddRef*(self: ptr IUnknown): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddRef(self) +proc Release*(self: ptr IUnknown): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Release(self) +proc Begin_QueryInterface*(self: ptr AsyncIUnknown, riid: REFIID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_QueryInterface(self, riid) +proc Finish_QueryInterface*(self: ptr AsyncIUnknown, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_QueryInterface(self, ppvObject) +proc Begin_AddRef*(self: ptr AsyncIUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_AddRef(self) +proc Finish_AddRef*(self: ptr AsyncIUnknown): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_AddRef(self) +proc Begin_Release*(self: ptr AsyncIUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_Release(self) +proc Finish_Release*(self: ptr AsyncIUnknown): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_Release(self) +proc CreateInstance*(self: ptr IClassFactory, pUnkOuter: ptr IUnknown, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, pUnkOuter, riid, ppvObject) +proc LockServer*(self: ptr IClassFactory, fLock: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockServer(self, fLock) +proc GetUnmarshalClass*(self: ptr IMarshal, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD, pCid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUnmarshalClass(self, riid, pv, dwDestContext, pvDestContext, mshlflags, pCid) +proc GetMarshalSizeMax*(self: ptr IMarshal, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD, pSize: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMarshalSizeMax(self, riid, pv, dwDestContext, pvDestContext, mshlflags, pSize) +proc MarshalInterface*(self: ptr IMarshal, pStm: ptr IStream, riid: REFIID, pv: pointer, dwDestContext: DWORD, pvDestContext: pointer, mshlflags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MarshalInterface(self, pStm, riid, pv, dwDestContext, pvDestContext, mshlflags) +proc UnmarshalInterface*(self: ptr IMarshal, pStm: ptr IStream, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnmarshalInterface(self, pStm, riid, ppv) +proc ReleaseMarshalData*(self: ptr IMarshal, pStm: ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseMarshalData(self, pStm) +proc DisconnectObject*(self: ptr IMarshal, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DisconnectObject(self, dwReserved) +proc Alloc*(self: ptr IMalloc, cb: SIZE_T): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Alloc(self, cb) +proc Realloc*(self: ptr IMalloc, pv: pointer, cb: SIZE_T): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Realloc(self, pv, cb) +proc Free*(self: ptr IMalloc, pv: pointer): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Free(self, pv) +proc GetSize*(self: ptr IMalloc, pv: pointer): SIZE_T {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, pv) +proc DidAlloc*(self: ptr IMalloc, pv: pointer): int32 {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DidAlloc(self, pv) +proc HeapMinimize*(self: ptr IMalloc): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HeapMinimize(self) +proc GetClassForHandler*(self: ptr IStdMarshalInfo, dwDestContext: DWORD, pvDestContext: pointer, pClsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClassForHandler(self, dwDestContext, pvDestContext, pClsid) +proc AddConnection*(self: ptr IExternalConnection, extconn: DWORD, reserved: DWORD): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddConnection(self, extconn, reserved) +proc ReleaseConnection*(self: ptr IExternalConnection, extconn: DWORD, reserved: DWORD, fLastReleaseCloses: WINBOOL): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseConnection(self, extconn, reserved, fLastReleaseCloses) +proc QueryMultipleInterfaces*(self: ptr IMultiQI, cMQIs: ULONG, pMQIs: ptr MULTI_QI): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryMultipleInterfaces(self, cMQIs, pMQIs) +proc Begin_QueryMultipleInterfaces*(self: ptr AsyncIMultiQI, cMQIs: ULONG, pMQIs: ptr MULTI_QI): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_QueryMultipleInterfaces(self, cMQIs, pMQIs) +proc Finish_QueryMultipleInterfaces*(self: ptr AsyncIMultiQI, pMQIs: ptr MULTI_QI): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_QueryMultipleInterfaces(self, pMQIs) +proc QueryInternalInterface*(self: ptr IInternalUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryInternalInterface(self, riid, ppv) +proc Next*(self: ptr IEnumUnknown, celt: ULONG, rgelt: ptr ptr IUnknown, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumUnknown, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumUnknown, ppenum: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumString, celt: ULONG, rgelt: ptr LPOLESTR, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumString, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumString, ppenum: ptr ptr IEnumString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Read*(self: ptr ISequentialStream, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Read(self, pv, cb, pcbRead) +proc Write*(self: ptr ISequentialStream, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Write(self, pv, cb, pcbWritten) +proc Seek*(self: ptr IStream, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ptr ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Seek(self, dlibMove, dwOrigin, plibNewPosition) +proc SetSize*(self: ptr IStream, libNewSize: ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSize(self, libNewSize) +proc CopyTo*(self: ptr IStream, pstm: ptr IStream, cb: ULARGE_INTEGER, pcbRead: ptr ULARGE_INTEGER, pcbWritten: ptr ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyTo(self, pstm, cb, pcbRead, pcbWritten) +proc Commit*(self: ptr IStream, grfCommitFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self, grfCommitFlags) +proc Revert*(self: ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Revert(self) +proc LockRegion*(self: ptr IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockRegion(self, libOffset, cb, dwLockType) +proc UnlockRegion*(self: ptr IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockRegion(self, libOffset, cb, dwLockType) +proc Stat*(self: ptr IStream, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stat(self, pstatstg, grfStatFlag) +proc Clone*(self: ptr IStream, ppstm: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppstm) +proc GetBuffer*(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE, riid: REFIID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBuffer(self, pMessage, riid) +proc SendReceive*(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE, pStatus: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendReceive(self, pMessage, pStatus) +proc FreeBuffer*(self: ptr IRpcChannelBuffer, pMessage: ptr RPCOLEMESSAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FreeBuffer(self, pMessage) +proc GetDestCtx*(self: ptr IRpcChannelBuffer, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDestCtx(self, pdwDestContext, ppvDestContext) +proc IsConnected*(self: ptr IRpcChannelBuffer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsConnected(self) +proc GetProtocolVersion*(self: ptr IRpcChannelBuffer2, pdwVersion: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProtocolVersion(self, pdwVersion) +proc Send*(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pSync: ptr ISynchronize, pulStatus: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Send(self, pMsg, pSync, pulStatus) +proc Receive*(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pulStatus: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Receive(self, pMsg, pulStatus) +proc GetDestCtxEx*(self: ptr IAsyncRpcChannelBuffer, pMsg: ptr RPCOLEMESSAGE, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDestCtxEx(self, pMsg, pdwDestContext, ppvDestContext) +proc Send*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pulStatus: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Send(self, pMsg, pulStatus) +proc Receive*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, ulSize: ULONG, pulStatus: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Receive(self, pMsg, ulSize, pulStatus) +proc Cancel*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cancel(self, pMsg) +proc GetCallContext*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, riid: REFIID, pInterface: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCallContext(self, pMsg, riid, pInterface) +proc GetDestCtxEx*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pdwDestContext: ptr DWORD, ppvDestContext: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDestCtxEx(self, pMsg, pdwDestContext, ppvDestContext) +proc GetState*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, pMsg, pState) +proc RegisterAsync*(self: ptr IRpcChannelBuffer3, pMsg: ptr RPCOLEMESSAGE, pAsyncMgr: ptr IAsyncManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterAsync(self, pMsg, pAsyncMgr) +proc NegotiateSyntax*(self: ptr IRpcSyntaxNegotiate, pMsg: ptr RPCOLEMESSAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NegotiateSyntax(self, pMsg) +proc Connect*(self: ptr IRpcProxyBuffer, pRpcChannelBuffer: ptr IRpcChannelBuffer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Connect(self, pRpcChannelBuffer) +proc Disconnect*(self: ptr IRpcProxyBuffer): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Disconnect(self) +proc Connect*(self: ptr IRpcStubBuffer, pUnkServer: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Connect(self, pUnkServer) +proc Disconnect*(self: ptr IRpcStubBuffer): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Disconnect(self) +proc Invoke*(self: ptr IRpcStubBuffer, prpcmsg: ptr RPCOLEMESSAGE, pRpcChannelBuffer: ptr IRpcChannelBuffer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, prpcmsg, pRpcChannelBuffer) +proc IsIIDSupported*(self: ptr IRpcStubBuffer, riid: REFIID): ptr IRpcStubBuffer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsIIDSupported(self, riid) +proc CountRefs*(self: ptr IRpcStubBuffer): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CountRefs(self) +proc DebugServerQueryInterface*(self: ptr IRpcStubBuffer, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DebugServerQueryInterface(self, ppv) +proc DebugServerRelease*(self: ptr IRpcStubBuffer, pv: pointer): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DebugServerRelease(self, pv) +proc CreateProxy*(self: ptr IPSFactoryBuffer, pUnkOuter: ptr IUnknown, riid: REFIID, ppProxy: ptr ptr IRpcProxyBuffer, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateProxy(self, pUnkOuter, riid, ppProxy, ppv) +proc CreateStub*(self: ptr IPSFactoryBuffer, riid: REFIID, pUnkServer: ptr IUnknown, ppStub: ptr ptr IRpcStubBuffer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStub(self, riid, pUnkServer, ppStub) +proc ClientGetSize*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClientGetSize(self, uExtent, riid, pDataSize) +proc ClientFillBuffer*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG, pDataBuffer: pointer): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClientFillBuffer(self, uExtent, riid, pDataSize, pDataBuffer) +proc ClientNotify*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, cbDataSize: ULONG, pDataBuffer: pointer, lDataRep: DWORD, hrFault: HRESULT): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClientNotify(self, uExtent, riid, cbDataSize, pDataBuffer, lDataRep, hrFault) +proc ServerNotify*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, cbDataSize: ULONG, pDataBuffer: pointer, lDataRep: DWORD): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ServerNotify(self, uExtent, riid, cbDataSize, pDataBuffer, lDataRep) +proc ServerGetSize*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, hrFault: HRESULT, pDataSize: ptr ULONG): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ServerGetSize(self, uExtent, riid, hrFault, pDataSize) +proc ServerFillBuffer*(self: ptr IChannelHook, uExtent: REFGUID, riid: REFIID, pDataSize: ptr ULONG, pDataBuffer: pointer, hrFault: HRESULT): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ServerFillBuffer(self, uExtent, riid, pDataSize, pDataBuffer, hrFault) +proc QueryBlanket*(self: ptr IClientSecurity, pProxy: ptr IUnknown, pAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr ptr OLECHAR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pAuthInfo: ptr pointer, pCapabilites: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryBlanket(self, pProxy, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel, pAuthInfo, pCapabilites) +proc SetBlanket*(self: ptr IClientSecurity, pProxy: ptr IUnknown, dwAuthnSvc: DWORD, dwAuthzSvc: DWORD, pServerPrincName: ptr OLECHAR, dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthInfo: pointer, dwCapabilities: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBlanket(self, pProxy, dwAuthnSvc, dwAuthzSvc, pServerPrincName, dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities) +proc CopyProxy*(self: ptr IClientSecurity, pProxy: ptr IUnknown, ppCopy: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyProxy(self, pProxy, ppCopy) +proc QueryBlanket*(self: ptr IServerSecurity, pAuthnSvc: ptr DWORD, pAuthzSvc: ptr DWORD, pServerPrincName: ptr ptr OLECHAR, pAuthnLevel: ptr DWORD, pImpLevel: ptr DWORD, pPrivs: ptr pointer, pCapabilities: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryBlanket(self, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel, pPrivs, pCapabilities) +proc ImpersonateClient*(self: ptr IServerSecurity): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ImpersonateClient(self) +proc RevertToSelf*(self: ptr IServerSecurity): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevertToSelf(self) +proc IsImpersonating*(self: ptr IServerSecurity): WINBOOL {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsImpersonating(self) +proc Set*(self: ptr IRpcOptions, pPrx: ptr IUnknown, dwProperty: RPCOPT_PROPERTIES, dwValue: ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Set(self, pPrx, dwProperty, dwValue) +proc Query*(self: ptr IRpcOptions, pPrx: ptr IUnknown, dwProperty: RPCOPT_PROPERTIES, pdwValue: ptr ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Query(self, pPrx, dwProperty, pdwValue) +proc Set*(self: ptr IGlobalOptions, dwProperty: GLOBALOPT_PROPERTIES, dwValue: ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Set(self, dwProperty, dwValue) +proc Query*(self: ptr IGlobalOptions, dwProperty: GLOBALOPT_PROPERTIES, pdwValue: ptr ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Query(self, dwProperty, pdwValue) +proc LoadDllServer*(self: ptr ISurrogate, Clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadDllServer(self, Clsid) +proc FreeSurrogate*(self: ptr ISurrogate): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FreeSurrogate(self) +proc RegisterInterfaceInGlobal*(self: ptr IGlobalInterfaceTable, pUnk: ptr IUnknown, riid: REFIID, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterInterfaceInGlobal(self, pUnk, riid, pdwCookie) +proc RevokeInterfaceFromGlobal*(self: ptr IGlobalInterfaceTable, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevokeInterfaceFromGlobal(self, dwCookie) +proc GetInterfaceFromGlobal*(self: ptr IGlobalInterfaceTable, dwCookie: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterfaceFromGlobal(self, dwCookie, riid, ppv) +proc Wait*(self: ptr ISynchronize, dwFlags: DWORD, dwMilliseconds: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Wait(self, dwFlags, dwMilliseconds) +proc Signal*(self: ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Signal(self) +proc Reset*(self: ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc GetHandle*(self: ptr ISynchronizeHandle, ph: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHandle(self, ph) +proc SetEventHandle*(self: ptr ISynchronizeEvent, ph: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEventHandle(self, ph) +proc AddSynchronize*(self: ptr ISynchronizeContainer, pSync: ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSynchronize(self, pSync) +proc WaitMultiple*(self: ptr ISynchronizeContainer, dwFlags: DWORD, dwTimeOut: DWORD, ppSync: ptr ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WaitMultiple(self, dwFlags, dwTimeOut, ppSync) +proc ReleaseMutex*(self: ptr ISynchronizeMutex): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseMutex(self) +proc Cancel*(self: ptr ICancelMethodCalls, ulSeconds: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cancel(self, ulSeconds) +proc TestCancel*(self: ptr ICancelMethodCalls): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TestCancel(self) +proc CompleteCall*(self: ptr IAsyncManager, Result: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompleteCall(self, Result) +proc GetCallContext*(self: ptr IAsyncManager, riid: REFIID, pInterface: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCallContext(self, riid, pInterface) +proc GetState*(self: ptr IAsyncManager, pulStateFlags: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, pulStateFlags) +proc CreateCall*(self: ptr ICallFactory, riid: REFIID, pCtrlUnk: ptr IUnknown, riid2: REFIID, ppv: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateCall(self, riid, pCtrlUnk, riid2, ppv) +proc GetDCOMProtocolVersion*(self: ptr IRpcHelper, pComVersion: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDCOMProtocolVersion(self, pComVersion) +proc GetIIDFromOBJREF*(self: ptr IRpcHelper, pObjRef: pointer, piid: ptr ptr IID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIIDFromOBJREF(self, pObjRef, piid) +proc ReleaseMarshalBuffer*(self: ptr IReleaseMarshalBuffers, pMsg: ptr RPCOLEMESSAGE, dwFlags: DWORD, pChnl: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseMarshalBuffer(self, pMsg, dwFlags, pChnl) +proc WaitMultiple*(self: ptr IWaitMultiple, timeout: DWORD, pSync: ptr ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WaitMultiple(self, timeout, pSync) +proc AddSynchronize*(self: ptr IWaitMultiple, pSync: ptr ISynchronize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSynchronize(self, pSync) +proc EnableCOMDynamicAddrTracking*(self: ptr IAddrTrackingControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableCOMDynamicAddrTracking(self) +proc DisableCOMDynamicAddrTracking*(self: ptr IAddrTrackingControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DisableCOMDynamicAddrTracking(self) +proc GetCurrentAddrExclusionList*(self: ptr IAddrExclusionControl, riid: REFIID, ppEnumerator: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentAddrExclusionList(self, riid, ppEnumerator) +proc UpdateAddrExclusionList*(self: ptr IAddrExclusionControl, pEnumerator: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateAddrExclusionList(self, pEnumerator) +proc Pull*(self: ptr IPipeByte, buf: ptr BYTE, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Pull(self, buf, cRequest, pcReturned) +proc Push*(self: ptr IPipeByte, buf: ptr BYTE, cSent: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Push(self, buf, cSent) +proc Pull*(self: ptr IPipeLong, buf: ptr LONG, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Pull(self, buf, cRequest, pcReturned) +proc Push*(self: ptr IPipeLong, buf: ptr LONG, cSent: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Push(self, buf, cSent) +proc Pull*(self: ptr IPipeDouble, buf: ptr DOUBLE, cRequest: ULONG, pcReturned: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Pull(self, buf, cRequest, pcReturned) +proc Push*(self: ptr IPipeDouble, buf: ptr DOUBLE, cSent: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Push(self, buf, cSent) +proc Next*(self: ptr IEnumContextProps, celt: ULONG, pContextProperties: ptr ContextProperty, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, pContextProperties, pceltFetched) +proc Skip*(self: ptr IEnumContextProps, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumContextProps): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumContextProps, ppEnumContextProps: ptr ptr IEnumContextProps): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnumContextProps) +proc Count*(self: ptr IEnumContextProps, pcelt: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Count(self, pcelt) +proc SetProperty*(self: ptr IContext, rpolicyId: REFGUID, flags: CPFLAGS, pUnk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProperty(self, rpolicyId, flags, pUnk) +proc RemoveProperty*(self: ptr IContext, rPolicyId: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveProperty(self, rPolicyId) +proc GetProperty*(self: ptr IContext, rGuid: REFGUID, pFlags: ptr CPFLAGS, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, rGuid, pFlags, ppUnk) +proc EnumContextProps*(self: ptr IContext, ppEnumContextProps: ptr ptr IEnumContextProps): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumContextProps(self, ppEnumContextProps) +proc GetCurrentApartmentType*(self: ptr IComThreadingInfo, pAptType: ptr APTTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentApartmentType(self, pAptType) +proc GetCurrentThreadType*(self: ptr IComThreadingInfo, pThreadType: ptr THDTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentThreadType(self, pThreadType) +proc GetCurrentLogicalThreadId*(self: ptr IComThreadingInfo, pguidLogicalThreadId: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentLogicalThreadId(self, pguidLogicalThreadId) +proc SetCurrentLogicalThreadId*(self: ptr IComThreadingInfo, rguid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCurrentLogicalThreadId(self, rguid) +proc ResetInitializerTimeout*(self: ptr IProcessInitControl, dwSecondsRemaining: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetInitializerTimeout(self, dwSecondsRemaining) +proc GetMarshalingContextAttribute*(self: ptr IMarshalingStream, attribute: CO_MARSHALING_CONTEXT_ATTRIBUTES, pAttributeValue: ptr ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMarshalingContextAttribute(self, attribute, pAttributeValue) +proc PreAlloc*(self: ptr IMallocSpy, cbRequest: SIZE_T): SIZE_T {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreAlloc(self, cbRequest) +proc PostAlloc*(self: ptr IMallocSpy, pActual: pointer): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostAlloc(self, pActual) +proc PreFree*(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreFree(self, pRequest, fSpyed) +proc PostFree*(self: ptr IMallocSpy, fSpyed: WINBOOL): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostFree(self, fSpyed) +proc PreRealloc*(self: ptr IMallocSpy, pRequest: pointer, cbRequest: SIZE_T, ppNewRequest: ptr pointer, fSpyed: WINBOOL): SIZE_T {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreRealloc(self, pRequest, cbRequest, ppNewRequest, fSpyed) +proc PostRealloc*(self: ptr IMallocSpy, pActual: pointer, fSpyed: WINBOOL): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostRealloc(self, pActual, fSpyed) +proc PreGetSize*(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreGetSize(self, pRequest, fSpyed) +proc PostGetSize*(self: ptr IMallocSpy, cbActual: SIZE_T, fSpyed: WINBOOL): SIZE_T {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostGetSize(self, cbActual, fSpyed) +proc PreDidAlloc*(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL): pointer {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreDidAlloc(self, pRequest, fSpyed) +proc PostDidAlloc*(self: ptr IMallocSpy, pRequest: pointer, fSpyed: WINBOOL, fActual: int32): int32 {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostDidAlloc(self, pRequest, fSpyed, fActual) +proc PreHeapMinimize*(self: ptr IMallocSpy): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreHeapMinimize(self) +proc PostHeapMinimize*(self: ptr IMallocSpy): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostHeapMinimize(self) +proc RegisterObjectBound*(self: ptr IBindCtx, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterObjectBound(self, punk) +proc RevokeObjectBound*(self: ptr IBindCtx, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevokeObjectBound(self, punk) +proc ReleaseBoundObjects*(self: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseBoundObjects(self) +proc SetBindOptions*(self: ptr IBindCtx, pbindopts: ptr BIND_OPTS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBindOptions(self, pbindopts) +proc GetBindOptions*(self: ptr IBindCtx, pbindopts: ptr BIND_OPTS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindOptions(self, pbindopts) +proc GetRunningObjectTable*(self: ptr IBindCtx, pprot: ptr ptr IRunningObjectTable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRunningObjectTable(self, pprot) +proc RegisterObjectParam*(self: ptr IBindCtx, pszKey: LPOLESTR, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterObjectParam(self, pszKey, punk) +proc GetObjectParam*(self: ptr IBindCtx, pszKey: LPOLESTR, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectParam(self, pszKey, ppunk) +proc EnumObjectParam*(self: ptr IBindCtx, ppenum: ptr ptr IEnumString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumObjectParam(self, ppenum) +proc RevokeObjectParam*(self: ptr IBindCtx, pszKey: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevokeObjectParam(self, pszKey) +proc Next*(self: ptr IEnumMoniker, celt: ULONG, rgelt: ptr ptr IMoniker, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumMoniker, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumMoniker, ppenum: ptr ptr IEnumMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc GetRunningClass*(self: ptr IRunnableObject, lpClsid: LPCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRunningClass(self, lpClsid) +proc Run*(self: ptr IRunnableObject, pbc: LPBINDCTX): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Run(self, pbc) +proc IsRunning*(self: ptr IRunnableObject): WINBOOL {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRunning(self) +proc LockRunning*(self: ptr IRunnableObject, fLock: WINBOOL, fLastUnlockCloses: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockRunning(self, fLock, fLastUnlockCloses) +proc SetContainedObject*(self: ptr IRunnableObject, fContained: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetContainedObject(self, fContained) +proc Register*(self: ptr IRunningObjectTable, grfFlags: DWORD, punkObject: ptr IUnknown, pmkObjectName: ptr IMoniker, pdwRegister: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Register(self, grfFlags, punkObject, pmkObjectName, pdwRegister) +proc Revoke*(self: ptr IRunningObjectTable, dwRegister: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Revoke(self, dwRegister) +proc IsRunning*(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRunning(self, pmkObjectName) +proc GetObject*(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker, ppunkObject: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObject(self, pmkObjectName, ppunkObject) +proc NoteChangeTime*(self: ptr IRunningObjectTable, dwRegister: DWORD, pfiletime: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NoteChangeTime(self, dwRegister, pfiletime) +proc GetTimeOfLastChange*(self: ptr IRunningObjectTable, pmkObjectName: ptr IMoniker, pfiletime: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTimeOfLastChange(self, pmkObjectName, pfiletime) +proc EnumRunning*(self: ptr IRunningObjectTable, ppenumMoniker: ptr ptr IEnumMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRunning(self, ppenumMoniker) +proc GetClassID*(self: ptr IPersist, pClassID: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClassID(self, pClassID) +proc IsDirty*(self: ptr IPersistStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc Load*(self: ptr IPersistStream, pStm: ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pStm) +proc Save*(self: ptr IPersistStream, pStm: ptr IStream, fClearDirty: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pStm, fClearDirty) +proc GetSizeMax*(self: ptr IPersistStream, pcbSize: ptr ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSizeMax(self, pcbSize) +proc BindToObject*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, riidResult: REFIID, ppvResult: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToObject(self, pbc, pmkToLeft, riidResult, ppvResult) +proc BindToStorage*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, riid: REFIID, ppvObj: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToStorage(self, pbc, pmkToLeft, riid, ppvObj) +proc Reduce*(self: ptr IMoniker, pbc: ptr IBindCtx, dwReduceHowFar: DWORD, ppmkToLeft: ptr ptr IMoniker, ppmkReduced: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reduce(self, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced) +proc ComposeWith*(self: ptr IMoniker, pmkRight: ptr IMoniker, fOnlyIfNotGeneric: WINBOOL, ppmkComposite: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComposeWith(self, pmkRight, fOnlyIfNotGeneric, ppmkComposite) +proc Enum*(self: ptr IMoniker, fForward: WINBOOL, ppenumMoniker: ptr ptr IEnumMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enum(self, fForward, ppenumMoniker) +proc IsEqual*(self: ptr IMoniker, pmkOtherMoniker: ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqual(self, pmkOtherMoniker) +proc Hash*(self: ptr IMoniker, pdwHash: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Hash(self, pdwHash) +proc IsRunning*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pmkNewlyRunning: ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRunning(self, pbc, pmkToLeft, pmkNewlyRunning) +proc GetTimeOfLastChange*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pFileTime: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTimeOfLastChange(self, pbc, pmkToLeft, pFileTime) +proc Inverse*(self: ptr IMoniker, ppmk: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Inverse(self, ppmk) +proc CommonPrefixWith*(self: ptr IMoniker, pmkOther: ptr IMoniker, ppmkPrefix: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CommonPrefixWith(self, pmkOther, ppmkPrefix) +proc RelativePathTo*(self: ptr IMoniker, pmkOther: ptr IMoniker, ppmkRelPath: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RelativePathTo(self, pmkOther, ppmkRelPath) +proc GetDisplayName*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, ppszDisplayName: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayName(self, pbc, pmkToLeft, ppszDisplayName) +proc ParseDisplayName*(self: ptr IMoniker, pbc: ptr IBindCtx, pmkToLeft: ptr IMoniker, pszDisplayName: LPOLESTR, pchEaten: ptr ULONG, ppmkOut: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseDisplayName(self, pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut) +proc IsSystemMoniker*(self: ptr IMoniker, pdwMksys: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSystemMoniker(self, pdwMksys) +proc GetComparisonData*(self: ptr IROTData, pbData: ptr uint8, cbMax: ULONG, pcbData: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetComparisonData(self, pbData, cbMax, pcbData) +proc Next*(self: ptr IEnumSTATSTG, celt: ULONG, rgelt: ptr STATSTG, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumSTATSTG, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumSTATSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumSTATSTG, ppenum: ptr ptr IEnumSTATSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc CreateStream*(self: ptr IStorage, pwcsName: ptr OLECHAR, grfMode: DWORD, reserved1: DWORD, reserved2: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStream(self, pwcsName, grfMode, reserved1, reserved2, ppstm) +proc OpenStream*(self: ptr IStorage, pwcsName: ptr OLECHAR, reserved1: pointer, grfMode: DWORD, reserved2: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenStream(self, pwcsName, reserved1, grfMode, reserved2, ppstm) +proc CreateStorage*(self: ptr IStorage, pwcsName: ptr OLECHAR, grfMode: DWORD, reserved1: DWORD, reserved2: DWORD, ppstg: ptr ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStorage(self, pwcsName, grfMode, reserved1, reserved2, ppstg) +proc OpenStorage*(self: ptr IStorage, pwcsName: ptr OLECHAR, pstgPriority: ptr IStorage, grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstg: ptr ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenStorage(self, pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg) +proc CopyTo*(self: ptr IStorage, ciidExclude: DWORD, rgiidExclude: ptr IID, snbExclude: SNB, pstgDest: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyTo(self, ciidExclude, rgiidExclude, snbExclude, pstgDest) +proc MoveElementTo*(self: ptr IStorage, pwcsName: ptr OLECHAR, pstgDest: ptr IStorage, pwcsNewName: ptr OLECHAR, grfFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveElementTo(self, pwcsName, pstgDest, pwcsNewName, grfFlags) +proc Commit*(self: ptr IStorage, grfCommitFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self, grfCommitFlags) +proc Revert*(self: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Revert(self) +proc EnumElements*(self: ptr IStorage, reserved1: DWORD, reserved2: pointer, reserved3: DWORD, ppenum: ptr ptr IEnumSTATSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumElements(self, reserved1, reserved2, reserved3, ppenum) +proc DestroyElement*(self: ptr IStorage, pwcsName: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyElement(self, pwcsName) +proc RenameElement*(self: ptr IStorage, pwcsOldName: ptr OLECHAR, pwcsNewName: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RenameElement(self, pwcsOldName, pwcsNewName) +proc SetElementTimes*(self: ptr IStorage, pwcsName: ptr OLECHAR, pctime: ptr FILETIME, patime: ptr FILETIME, pmtime: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetElementTimes(self, pwcsName, pctime, patime, pmtime) +proc SetClass*(self: ptr IStorage, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClass(self, clsid) +proc SetStateBits*(self: ptr IStorage, grfStateBits: DWORD, grfMask: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStateBits(self, grfStateBits, grfMask) +proc Stat*(self: ptr IStorage, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stat(self, pstatstg, grfStatFlag) +proc IsDirty*(self: ptr IPersistFile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc Load*(self: ptr IPersistFile, pszFileName: LPCOLESTR, dwMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pszFileName, dwMode) +proc Save*(self: ptr IPersistFile, pszFileName: LPCOLESTR, fRemember: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pszFileName, fRemember) +proc SaveCompleted*(self: ptr IPersistFile, pszFileName: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveCompleted(self, pszFileName) +proc GetCurFile*(self: ptr IPersistFile, ppszFileName: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurFile(self, ppszFileName) +proc IsDirty*(self: ptr IPersistStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc InitNew*(self: ptr IPersistStorage, pStg: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self, pStg) +proc Load*(self: ptr IPersistStorage, pStg: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pStg) +proc Save*(self: ptr IPersistStorage, pStgSave: ptr IStorage, fSameAsLoad: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pStgSave, fSameAsLoad) +proc SaveCompleted*(self: ptr IPersistStorage, pStgNew: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveCompleted(self, pStgNew) +proc HandsOffStorage*(self: ptr IPersistStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandsOffStorage(self) +proc ReadAt*(self: ptr ILockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadAt(self, ulOffset, pv, cb, pcbRead) +proc WriteAt*(self: ptr ILockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteAt(self, ulOffset, pv, cb, pcbWritten) +proc Flush*(self: ptr ILockBytes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Flush(self) +proc SetSize*(self: ptr ILockBytes, cb: ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSize(self, cb) +proc LockRegion*(self: ptr ILockBytes, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockRegion(self, libOffset, cb, dwLockType) +proc UnlockRegion*(self: ptr ILockBytes, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockRegion(self, libOffset, cb, dwLockType) +proc Stat*(self: ptr ILockBytes, pstatstg: ptr STATSTG, grfStatFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stat(self, pstatstg, grfStatFlag) +proc Next*(self: ptr IEnumFORMATETC, celt: ULONG, rgelt: ptr FORMATETC, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumFORMATETC, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumFORMATETC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumFORMATETC, ppenum: ptr ptr IEnumFORMATETC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumSTATDATA, celt: ULONG, rgelt: ptr STATDATA, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumSTATDATA, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumSTATDATA, ppenum: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc SwitchToFile*(self: ptr IRootStorage, pszFile: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchToFile(self, pszFile) +proc OnDataChange*(self: ptr IAdviseSink, pFormatetc: ptr FORMATETC, pStgmed: ptr STGMEDIUM): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDataChange(self, pFormatetc, pStgmed) +proc OnViewChange*(self: ptr IAdviseSink, dwAspect: DWORD, lindex: LONG): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnViewChange(self, dwAspect, lindex) +proc OnRename*(self: ptr IAdviseSink, pmk: ptr IMoniker): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnRename(self, pmk) +proc OnSave*(self: ptr IAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSave(self) +proc OnClose*(self: ptr IAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnClose(self) +proc Begin_OnDataChange*(self: ptr AsyncIAdviseSink, pFormatetc: ptr FORMATETC, pStgmed: ptr STGMEDIUM): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnDataChange(self, pFormatetc, pStgmed) +proc Finish_OnDataChange*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnDataChange(self) +proc Begin_OnViewChange*(self: ptr AsyncIAdviseSink, dwAspect: DWORD, lindex: LONG): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnViewChange(self, dwAspect, lindex) +proc Finish_OnViewChange*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnViewChange(self) +proc Begin_OnRename*(self: ptr AsyncIAdviseSink, pmk: ptr IMoniker): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnRename(self, pmk) +proc Finish_OnRename*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnRename(self) +proc Begin_OnSave*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnSave(self) +proc Finish_OnSave*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnSave(self) +proc Begin_OnClose*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnClose(self) +proc Finish_OnClose*(self: ptr AsyncIAdviseSink): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnClose(self) +proc OnLinkSrcChange*(self: ptr IAdviseSink2, pmk: ptr IMoniker): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnLinkSrcChange(self, pmk) +proc Begin_OnLinkSrcChange*(self: ptr AsyncIAdviseSink2, pmk: ptr IMoniker): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin_OnLinkSrcChange(self, pmk) +proc Finish_OnLinkSrcChange*(self: ptr AsyncIAdviseSink2): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Finish_OnLinkSrcChange(self) +proc GetData*(self: ptr IDataObject, pformatetcIn: ptr FORMATETC, pmedium: ptr STGMEDIUM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetData(self, pformatetcIn, pmedium) +proc GetDataHere*(self: ptr IDataObject, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDataHere(self, pformatetc, pmedium) +proc QueryGetData*(self: ptr IDataObject, pformatetc: ptr FORMATETC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryGetData(self, pformatetc) +proc GetCanonicalFormatEtc*(self: ptr IDataObject, pformatectIn: ptr FORMATETC, pformatetcOut: ptr FORMATETC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCanonicalFormatEtc(self, pformatectIn, pformatetcOut) +proc SetData*(self: ptr IDataObject, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM, fRelease: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetData(self, pformatetc, pmedium, fRelease) +proc EnumFormatEtc*(self: ptr IDataObject, dwDirection: DWORD, ppenumFormatEtc: ptr ptr IEnumFORMATETC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumFormatEtc(self, dwDirection, ppenumFormatEtc) +proc DAdvise*(self: ptr IDataObject, pformatetc: ptr FORMATETC, advf: DWORD, pAdvSink: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DAdvise(self, pformatetc, advf, pAdvSink, pdwConnection) +proc DUnadvise*(self: ptr IDataObject, dwConnection: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DUnadvise(self, dwConnection) +proc EnumDAdvise*(self: ptr IDataObject, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumDAdvise(self, ppenumAdvise) +proc Advise*(self: ptr IDataAdviseHolder, pDataObject: ptr IDataObject, pFetc: ptr FORMATETC, advf: DWORD, pAdvise: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pDataObject, pFetc, advf, pAdvise, pdwConnection) +proc Unadvise*(self: ptr IDataAdviseHolder, dwConnection: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwConnection) +proc EnumAdvise*(self: ptr IDataAdviseHolder, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumAdvise(self, ppenumAdvise) +proc SendOnDataChange*(self: ptr IDataAdviseHolder, pDataObject: ptr IDataObject, dwReserved: DWORD, advf: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendOnDataChange(self, pDataObject, dwReserved, advf) +proc HandleInComingCall*(self: ptr IMessageFilter, dwCallType: DWORD, htaskCaller: HTASK, dwTickCount: DWORD, lpInterfaceInfo: LPINTERFACEINFO): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleInComingCall(self, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo) +proc RetryRejectedCall*(self: ptr IMessageFilter, htaskCallee: HTASK, dwTickCount: DWORD, dwRejectType: DWORD): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RetryRejectedCall(self, htaskCallee, dwTickCount, dwRejectType) +proc MessagePending*(self: ptr IMessageFilter, htaskCallee: HTASK, dwTickCount: DWORD, dwPendingType: DWORD): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MessagePending(self, htaskCallee, dwTickCount, dwPendingType) +proc GetClassObject*(self: ptr IClassActivator, rclsid: REFCLSID, dwClassContext: DWORD, locale: LCID, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClassObject(self, rclsid, dwClassContext, locale, riid, ppv) +proc FillAppend*(self: ptr IFillLockBytes, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FillAppend(self, pv, cb, pcbWritten) +proc FillAt*(self: ptr IFillLockBytes, ulOffset: ULARGE_INTEGER, pv: pointer, cb: ULONG, pcbWritten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FillAt(self, ulOffset, pv, cb, pcbWritten) +proc SetFillSize*(self: ptr IFillLockBytes, ulSize: ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFillSize(self, ulSize) +proc Terminate*(self: ptr IFillLockBytes, bCanceled: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Terminate(self, bCanceled) +proc OnProgress*(self: ptr IProgressNotify, dwProgressCurrent: DWORD, dwProgressMaximum: DWORD, fAccurate: WINBOOL, fOwner: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnProgress(self, dwProgressCurrent, dwProgressMaximum, fAccurate, fOwner) +proc LayoutScript*(self: ptr ILayoutStorage, pStorageLayout: ptr StorageLayout, nEntries: DWORD, glfInterleavedFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LayoutScript(self, pStorageLayout, nEntries, glfInterleavedFlag) +proc BeginMonitor*(self: ptr ILayoutStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginMonitor(self) +proc EndMonitor*(self: ptr ILayoutStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndMonitor(self) +proc ReLayoutDocfile*(self: ptr ILayoutStorage, pwcsNewDfName: ptr OLECHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReLayoutDocfile(self, pwcsNewDfName) +proc ReLayoutDocfileOnILockBytes*(self: ptr ILayoutStorage, pILockBytes: ptr ILockBytes): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReLayoutDocfileOnILockBytes(self, pILockBytes) +proc Lock*(self: ptr IBlockingLock, dwTimeout: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Lock(self, dwTimeout) +proc Unlock*(self: ptr IBlockingLock): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unlock(self) +proc SuppressChanges*(self: ptr ITimeAndNoticeControl, res1: DWORD, res2: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SuppressChanges(self, res1, res2) +proc CreateStorageEx*(self: ptr IOplockStorage, pwcsName: LPCWSTR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, riid: REFIID, ppstgOpen: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStorageEx(self, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen) +proc OpenStorageEx*(self: ptr IOplockStorage, pwcsName: LPCWSTR, grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, riid: REFIID, ppstgOpen: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenStorageEx(self, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen) +proc WaitForWriteAccess*(self: ptr IDirectWriterLock, dwTimeout: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WaitForWriteAccess(self, dwTimeout) +proc ReleaseWriteAccess*(self: ptr IDirectWriterLock): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseWriteAccess(self) +proc HaveWriteAccess*(self: ptr IDirectWriterLock): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HaveWriteAccess(self) +proc AsyncGetClassBits*(self: ptr IUrlMon, rclsid: REFCLSID, pszTYPE: LPCWSTR, pszExt: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, pszCodeBase: LPCWSTR, pbc: ptr IBindCtx, dwClassContext: DWORD, riid: REFIID, flags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AsyncGetClassBits(self, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags) +proc AllowForegroundTransfer*(self: ptr IForegroundTransfer, lpvReserved: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AllowForegroundTransfer(self, lpvReserved) +proc ExtractThumbnail*(self: ptr IThumbnailExtractor, pStg: ptr IStorage, ulLength: ULONG, ulHeight: ULONG, pulOutputLength: ptr ULONG, pulOutputHeight: ptr ULONG, phOutputBitmap: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExtractThumbnail(self, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap) +proc OnFileUpdated*(self: ptr IThumbnailExtractor, pStg: ptr IStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFileUpdated(self, pStg) +proc Dummy*(self: ptr IDummyHICONIncluder, h1: HICON, h2: HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Dummy(self, h1, h2) +proc AddRefOnProcess*(self: ptr IProcessLock): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddRefOnProcess(self) +proc ReleaseRefOnProcess*(self: ptr IProcessLock): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseRefOnProcess(self) +proc Init*(self: ptr ISurrogateService, rguidProcessID: REFGUID, pProcessLock: ptr IProcessLock, pfApplicationAware: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Init(self, rguidProcessID, pProcessLock, pfApplicationAware) +proc ApplicationLaunch*(self: ptr ISurrogateService, rguidApplID: REFGUID, appType: ApplicationType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplicationLaunch(self, rguidApplID, appType) +proc ApplicationFree*(self: ptr ISurrogateService, rguidApplID: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplicationFree(self, rguidApplID) +proc CatalogRefresh*(self: ptr ISurrogateService, ulReserved: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CatalogRefresh(self, ulReserved) +proc ProcessShutdown*(self: ptr ISurrogateService, shutdownType: ShutdownType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessShutdown(self, shutdownType) +proc PreInitialize*(self: ptr IInitializeSpy, dwCoInit: DWORD, dwCurThreadAptRefs: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreInitialize(self, dwCoInit, dwCurThreadAptRefs) +proc PostInitialize*(self: ptr IInitializeSpy, hrCoInit: HRESULT, dwCoInit: DWORD, dwNewThreadAptRefs: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostInitialize(self, hrCoInit, dwCoInit, dwNewThreadAptRefs) +proc PreUninitialize*(self: ptr IInitializeSpy, dwCurThreadAptRefs: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreUninitialize(self, dwCurThreadAptRefs) +proc PostUninitialize*(self: ptr IInitializeSpy, dwNewThreadAptRefs: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostUninitialize(self, dwNewThreadAptRefs) +proc OnUninitialize*(self: ptr IApartmentShutdown, ui64ApartmentIdentifier: UINT64): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnUninitialize(self, ui64ApartmentIdentifier) +proc SetGuid*(self: ptr ICreateTypeInfo, guid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGuid(self, guid) +proc SetTypeFlags*(self: ptr ICreateTypeInfo, uTypeFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTypeFlags(self, uTypeFlags) +proc SetDocString*(self: ptr ICreateTypeInfo, pStrDoc: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDocString(self, pStrDoc) +proc SetHelpContext*(self: ptr ICreateTypeInfo, dwHelpContext: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpContext(self, dwHelpContext) +proc SetVersion*(self: ptr ICreateTypeInfo, wMajorVerNum: WORD, wMinorVerNum: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVersion(self, wMajorVerNum, wMinorVerNum) +proc AddRefTypeInfo*(self: ptr ICreateTypeInfo, pTInfo: ptr ITypeInfo, phRefType: ptr HREFTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddRefTypeInfo(self, pTInfo, phRefType) +proc AddFuncDesc*(self: ptr ICreateTypeInfo, index: UINT, pFuncDesc: ptr FUNCDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddFuncDesc(self, index, pFuncDesc) +proc AddImplType*(self: ptr ICreateTypeInfo, index: UINT, hRefType: HREFTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddImplType(self, index, hRefType) +proc SetImplTypeFlags*(self: ptr ICreateTypeInfo, index: UINT, implTypeFlags: INT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetImplTypeFlags(self, index, implTypeFlags) +proc SetAlignment*(self: ptr ICreateTypeInfo, cbAlignment: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAlignment(self, cbAlignment) +proc SetSchema*(self: ptr ICreateTypeInfo, pStrSchema: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSchema(self, pStrSchema) +proc AddVarDesc*(self: ptr ICreateTypeInfo, index: UINT, pVarDesc: ptr VARDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddVarDesc(self, index, pVarDesc) +proc SetFuncAndParamNames*(self: ptr ICreateTypeInfo, index: UINT, rgszNames: ptr LPOLESTR, cNames: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFuncAndParamNames(self, index, rgszNames, cNames) +proc SetVarName*(self: ptr ICreateTypeInfo, index: UINT, szName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVarName(self, index, szName) +proc SetTypeDescAlias*(self: ptr ICreateTypeInfo, pTDescAlias: ptr TYPEDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTypeDescAlias(self, pTDescAlias) +proc DefineFuncAsDllEntry*(self: ptr ICreateTypeInfo, index: UINT, szDllName: LPOLESTR, szProcName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefineFuncAsDllEntry(self, index, szDllName, szProcName) +proc SetFuncDocString*(self: ptr ICreateTypeInfo, index: UINT, szDocString: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFuncDocString(self, index, szDocString) +proc SetVarDocString*(self: ptr ICreateTypeInfo, index: UINT, szDocString: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVarDocString(self, index, szDocString) +proc SetFuncHelpContext*(self: ptr ICreateTypeInfo, index: UINT, dwHelpContext: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFuncHelpContext(self, index, dwHelpContext) +proc SetVarHelpContext*(self: ptr ICreateTypeInfo, index: UINT, dwHelpContext: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVarHelpContext(self, index, dwHelpContext) +proc SetMops*(self: ptr ICreateTypeInfo, index: UINT, bstrMops: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMops(self, index, bstrMops) +proc SetTypeIdldesc*(self: ptr ICreateTypeInfo, pIdlDesc: ptr IDLDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTypeIdldesc(self, pIdlDesc) +proc LayOut*(self: ptr ICreateTypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LayOut(self) +proc DeleteFuncDesc*(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteFuncDesc(self, index) +proc DeleteFuncDescByMemId*(self: ptr ICreateTypeInfo2, memid: MEMBERID, invKind: INVOKEKIND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteFuncDescByMemId(self, memid, invKind) +proc DeleteVarDesc*(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteVarDesc(self, index) +proc DeleteVarDescByMemId*(self: ptr ICreateTypeInfo2, memid: MEMBERID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteVarDescByMemId(self, memid) +proc DeleteImplType*(self: ptr ICreateTypeInfo2, index: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteImplType(self, index) +proc SetCustData*(self: ptr ICreateTypeInfo2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCustData(self, guid, pVarVal) +proc SetFuncCustData*(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFuncCustData(self, index, guid, pVarVal) +proc SetParamCustData*(self: ptr ICreateTypeInfo2, indexFunc: UINT, indexParam: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetParamCustData(self, indexFunc, indexParam, guid, pVarVal) +proc SetVarCustData*(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVarCustData(self, index, guid, pVarVal) +proc SetImplTypeCustData*(self: ptr ICreateTypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetImplTypeCustData(self, index, guid, pVarVal) +proc SetHelpStringContext*(self: ptr ICreateTypeInfo2, dwHelpStringContext: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpStringContext(self, dwHelpStringContext) +proc SetFuncHelpStringContext*(self: ptr ICreateTypeInfo2, index: UINT, dwHelpStringContext: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFuncHelpStringContext(self, index, dwHelpStringContext) +proc SetVarHelpStringContext*(self: ptr ICreateTypeInfo2, index: UINT, dwHelpStringContext: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVarHelpStringContext(self, index, dwHelpStringContext) +proc Invalidate*(self: ptr ICreateTypeInfo2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invalidate(self) +proc SetName*(self: ptr ICreateTypeInfo2, szName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetName(self, szName) +proc CreateTypeInfo*(self: ptr ICreateTypeLib, szName: LPOLESTR, tkind: TYPEKIND, ppCTInfo: ptr ptr ICreateTypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateTypeInfo(self, szName, tkind, ppCTInfo) +proc SetName*(self: ptr ICreateTypeLib, szName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetName(self, szName) +proc SetVersion*(self: ptr ICreateTypeLib, wMajorVerNum: WORD, wMinorVerNum: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVersion(self, wMajorVerNum, wMinorVerNum) +proc SetGuid*(self: ptr ICreateTypeLib, guid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGuid(self, guid) +proc SetDocString*(self: ptr ICreateTypeLib, szDoc: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDocString(self, szDoc) +proc SetHelpFileName*(self: ptr ICreateTypeLib, szHelpFileName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpFileName(self, szHelpFileName) +proc SetHelpContext*(self: ptr ICreateTypeLib, dwHelpContext: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpContext(self, dwHelpContext) +proc SetLcid*(self: ptr ICreateTypeLib, lcid: LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLcid(self, lcid) +proc SetLibFlags*(self: ptr ICreateTypeLib, uLibFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLibFlags(self, uLibFlags) +proc SaveAllChanges*(self: ptr ICreateTypeLib): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveAllChanges(self) +proc DeleteTypeInfo*(self: ptr ICreateTypeLib2, szName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteTypeInfo(self, szName) +proc SetCustData*(self: ptr ICreateTypeLib2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCustData(self, guid, pVarVal) +proc SetHelpStringContext*(self: ptr ICreateTypeLib2, dwHelpStringContext: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpStringContext(self, dwHelpStringContext) +proc SetHelpStringDll*(self: ptr ICreateTypeLib2, szFileName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpStringDll(self, szFileName) +proc GetTypeInfoCount*(self: ptr IDispatch, pctinfo: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoCount(self, pctinfo) +proc GetTypeInfo*(self: ptr IDispatch, iTInfo: UINT, lcid: LCID, ppTInfo: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfo(self, iTInfo, lcid, ppTInfo) +proc GetIDsOfNames*(self: ptr IDispatch, riid: REFIID, rgszNames: ptr LPOLESTR, cNames: UINT, lcid: LCID, rgDispId: ptr DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDsOfNames(self, riid, rgszNames, cNames, lcid, rgDispId) +proc Invoke*(self: ptr IDispatch, dispIdMember: DISPID, riid: REFIID, lcid: LCID, wFlags: WORD, pDispParams: ptr DISPPARAMS, pVarResult: ptr VARIANT, pExcepInfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr) +proc Next*(self: ptr IEnumVARIANT, celt: ULONG, rgVar: ptr VARIANT, pCeltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgVar, pCeltFetched) +proc Skip*(self: ptr IEnumVARIANT, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumVARIANT, ppEnum: ptr ptr IEnumVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Bind*(self: ptr ITypeComp, szName: LPOLESTR, lHashVal: ULONG, wFlags: WORD, ppTInfo: ptr ptr ITypeInfo, pDescKind: ptr DESCKIND, pBindPtr: ptr BINDPTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Bind(self, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr) +proc BindType*(self: ptr ITypeComp, szName: LPOLESTR, lHashVal: ULONG, ppTInfo: ptr ptr ITypeInfo, ppTComp: ptr ptr ITypeComp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindType(self, szName, lHashVal, ppTInfo, ppTComp) +proc GetTypeAttr*(self: ptr ITypeInfo, ppTypeAttr: ptr ptr TYPEATTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeAttr(self, ppTypeAttr) +proc GetTypeComp*(self: ptr ITypeInfo, ppTComp: ptr ptr ITypeComp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeComp(self, ppTComp) +proc GetFuncDesc*(self: ptr ITypeInfo, index: UINT, ppFuncDesc: ptr ptr FUNCDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFuncDesc(self, index, ppFuncDesc) +proc GetVarDesc*(self: ptr ITypeInfo, index: UINT, ppVarDesc: ptr ptr VARDESC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVarDesc(self, index, ppVarDesc) +proc GetNames*(self: ptr ITypeInfo, memid: MEMBERID, rgBstrNames: ptr BSTR, cMaxNames: UINT, pcNames: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNames(self, memid, rgBstrNames, cMaxNames, pcNames) +proc GetRefTypeOfImplType*(self: ptr ITypeInfo, index: UINT, pRefType: ptr HREFTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRefTypeOfImplType(self, index, pRefType) +proc GetImplTypeFlags*(self: ptr ITypeInfo, index: UINT, pImplTypeFlags: ptr INT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImplTypeFlags(self, index, pImplTypeFlags) +proc GetIDsOfNames*(self: ptr ITypeInfo, rgszNames: ptr LPOLESTR, cNames: UINT, pMemId: ptr MEMBERID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDsOfNames(self, rgszNames, cNames, pMemId) +proc Invoke*(self: ptr ITypeInfo, pvInstance: PVOID, memid: MEMBERID, wFlags: WORD, pDispParams: ptr DISPPARAMS, pVarResult: ptr VARIANT, pExcepInfo: ptr EXCEPINFO, puArgErr: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr) +proc GetDocumentation*(self: ptr ITypeInfo, memid: MEMBERID, pBstrName: ptr BSTR, pBstrDocString: ptr BSTR, pdwHelpContext: ptr DWORD, pBstrHelpFile: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocumentation(self, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile) +proc GetDllEntry*(self: ptr ITypeInfo, memid: MEMBERID, invKind: INVOKEKIND, pBstrDllName: ptr BSTR, pBstrName: ptr BSTR, pwOrdinal: ptr WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDllEntry(self, memid, invKind, pBstrDllName, pBstrName, pwOrdinal) +proc GetRefTypeInfo*(self: ptr ITypeInfo, hRefType: HREFTYPE, ppTInfo: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRefTypeInfo(self, hRefType, ppTInfo) +proc AddressOfMember*(self: ptr ITypeInfo, memid: MEMBERID, invKind: INVOKEKIND, ppv: ptr PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddressOfMember(self, memid, invKind, ppv) +proc CreateInstance*(self: ptr ITypeInfo, pUnkOuter: ptr IUnknown, riid: REFIID, ppvObj: ptr PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, pUnkOuter, riid, ppvObj) +proc GetMops*(self: ptr ITypeInfo, memid: MEMBERID, pBstrMops: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMops(self, memid, pBstrMops) +proc GetContainingTypeLib*(self: ptr ITypeInfo, ppTLib: ptr ptr ITypeLib, pIndex: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainingTypeLib(self, ppTLib, pIndex) +proc ReleaseTypeAttr*(self: ptr ITypeInfo, pTypeAttr: ptr TYPEATTR): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseTypeAttr(self, pTypeAttr) +proc ReleaseFuncDesc*(self: ptr ITypeInfo, pFuncDesc: ptr FUNCDESC): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseFuncDesc(self, pFuncDesc) +proc ReleaseVarDesc*(self: ptr ITypeInfo, pVarDesc: ptr VARDESC): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseVarDesc(self, pVarDesc) +proc GetTypeKind*(self: ptr ITypeInfo2, pTypeKind: ptr TYPEKIND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeKind(self, pTypeKind) +proc GetTypeFlags*(self: ptr ITypeInfo2, pTypeFlags: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeFlags(self, pTypeFlags) +proc GetFuncIndexOfMemId*(self: ptr ITypeInfo2, memid: MEMBERID, invKind: INVOKEKIND, pFuncIndex: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFuncIndexOfMemId(self, memid, invKind, pFuncIndex) +proc GetVarIndexOfMemId*(self: ptr ITypeInfo2, memid: MEMBERID, pVarIndex: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVarIndexOfMemId(self, memid, pVarIndex) +proc GetCustData*(self: ptr ITypeInfo2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustData(self, guid, pVarVal) +proc GetFuncCustData*(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFuncCustData(self, index, guid, pVarVal) +proc GetParamCustData*(self: ptr ITypeInfo2, indexFunc: UINT, indexParam: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParamCustData(self, indexFunc, indexParam, guid, pVarVal) +proc GetVarCustData*(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVarCustData(self, index, guid, pVarVal) +proc GetImplTypeCustData*(self: ptr ITypeInfo2, index: UINT, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImplTypeCustData(self, index, guid, pVarVal) +proc GetDocumentation2*(self: ptr ITypeInfo2, memid: MEMBERID, lcid: LCID, pbstrHelpString: ptr BSTR, pdwHelpStringContext: ptr DWORD, pbstrHelpStringDll: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocumentation2(self, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll) +proc GetAllCustData*(self: ptr ITypeInfo2, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllCustData(self, pCustData) +proc GetAllFuncCustData*(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllFuncCustData(self, index, pCustData) +proc GetAllParamCustData*(self: ptr ITypeInfo2, indexFunc: UINT, indexParam: UINT, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllParamCustData(self, indexFunc, indexParam, pCustData) +proc GetAllVarCustData*(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllVarCustData(self, index, pCustData) +proc GetAllImplTypeCustData*(self: ptr ITypeInfo2, index: UINT, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllImplTypeCustData(self, index, pCustData) +proc GetTypeInfoCount*(self: ptr ITypeLib): UINT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoCount(self) +proc GetTypeInfo*(self: ptr ITypeLib, index: UINT, ppTInfo: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfo(self, index, ppTInfo) +proc GetTypeInfoType*(self: ptr ITypeLib, index: UINT, pTKind: ptr TYPEKIND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoType(self, index, pTKind) +proc GetTypeInfoOfGuid*(self: ptr ITypeLib, guid: REFGUID, ppTinfo: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfoOfGuid(self, guid, ppTinfo) +proc GetLibAttr*(self: ptr ITypeLib, ppTLibAttr: ptr ptr TLIBATTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLibAttr(self, ppTLibAttr) +proc GetTypeComp*(self: ptr ITypeLib, ppTComp: ptr ptr ITypeComp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeComp(self, ppTComp) +proc GetDocumentation*(self: ptr ITypeLib, index: INT, pBstrName: ptr BSTR, pBstrDocString: ptr BSTR, pdwHelpContext: ptr DWORD, pBstrHelpFile: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocumentation(self, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile) +proc IsName*(self: ptr ITypeLib, szNameBuf: LPOLESTR, lHashVal: ULONG, pfName: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsName(self, szNameBuf, lHashVal, pfName) +proc FindName*(self: ptr ITypeLib, szNameBuf: LPOLESTR, lHashVal: ULONG, ppTInfo: ptr ptr ITypeInfo, rgMemId: ptr MEMBERID, pcFound: ptr USHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindName(self, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound) +proc ReleaseTLibAttr*(self: ptr ITypeLib, pTLibAttr: ptr TLIBATTR): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseTLibAttr(self, pTLibAttr) +proc GetCustData*(self: ptr ITypeLib2, guid: REFGUID, pVarVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCustData(self, guid, pVarVal) +proc GetLibStatistics*(self: ptr ITypeLib2, pcUniqueNames: ptr ULONG, pcchUniqueNames: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLibStatistics(self, pcUniqueNames, pcchUniqueNames) +proc GetDocumentation2*(self: ptr ITypeLib2, index: INT, lcid: LCID, pbstrHelpString: ptr BSTR, pdwHelpStringContext: ptr DWORD, pbstrHelpStringDll: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocumentation2(self, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll) +proc GetAllCustData*(self: ptr ITypeLib2, pCustData: ptr CUSTDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAllCustData(self, pCustData) +proc RequestTypeChange*(self: ptr ITypeChangeEvents, changeKind: CHANGEKIND, pTInfoBefore: ptr ITypeInfo, pStrName: LPOLESTR, pfCancel: ptr INT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestTypeChange(self, changeKind, pTInfoBefore, pStrName, pfCancel) +proc AfterTypeChange*(self: ptr ITypeChangeEvents, changeKind: CHANGEKIND, pTInfoAfter: ptr ITypeInfo, pStrName: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AfterTypeChange(self, changeKind, pTInfoAfter, pStrName) +proc GetGUID*(self: ptr IErrorInfo, pGUID: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGUID(self, pGUID) +proc GetSource*(self: ptr IErrorInfo, pBstrSource: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSource(self, pBstrSource) +proc GetDescription*(self: ptr IErrorInfo, pBstrDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pBstrDescription) +proc GetHelpFile*(self: ptr IErrorInfo, pBstrHelpFile: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHelpFile(self, pBstrHelpFile) +proc GetHelpContext*(self: ptr IErrorInfo, pdwHelpContext: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHelpContext(self, pdwHelpContext) +proc SetGUID*(self: ptr ICreateErrorInfo, rguid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGUID(self, rguid) +proc SetSource*(self: ptr ICreateErrorInfo, szSource: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSource(self, szSource) +proc SetDescription*(self: ptr ICreateErrorInfo, szDescription: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDescription(self, szDescription) +proc SetHelpFile*(self: ptr ICreateErrorInfo, szHelpFile: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpFile(self, szHelpFile) +proc SetHelpContext*(self: ptr ICreateErrorInfo, dwHelpContext: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHelpContext(self, dwHelpContext) +proc InterfaceSupportsErrorInfo*(self: ptr ISupportErrorInfo, riid: REFIID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InterfaceSupportsErrorInfo(self, riid) +proc CreateFromTypeInfo*(self: ptr ITypeFactory, pTypeInfo: ptr ITypeInfo, riid: REFIID, ppv: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateFromTypeInfo(self, pTypeInfo, riid, ppv) +proc mSize*(self: ptr ITypeMarshal, pvType: PVOID, dwDestContext: DWORD, pvDestContext: PVOID, pSize: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Size(self, pvType, dwDestContext, pvDestContext, pSize) +proc Marshal*(self: ptr ITypeMarshal, pvType: PVOID, dwDestContext: DWORD, pvDestContext: PVOID, cbBufferLength: ULONG, pBuffer: ptr BYTE, pcbWritten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Marshal(self, pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten) +proc Unmarshal*(self: ptr ITypeMarshal, pvType: PVOID, dwFlags: DWORD, cbBufferLength: ULONG, pBuffer: ptr BYTE, pcbRead: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unmarshal(self, pvType, dwFlags, cbBufferLength, pBuffer, pcbRead) +proc Free*(self: ptr ITypeMarshal, pvType: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Free(self, pvType) +proc RecordInit*(self: ptr IRecordInfo, pvNew: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordInit(self, pvNew) +proc RecordClear*(self: ptr IRecordInfo, pvExisting: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordClear(self, pvExisting) +proc RecordCopy*(self: ptr IRecordInfo, pvExisting: PVOID, pvNew: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordCopy(self, pvExisting, pvNew) +proc GetGuid*(self: ptr IRecordInfo, pguid: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGuid(self, pguid) +proc GetName*(self: ptr IRecordInfo, pbstrName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName(self, pbstrName) +proc GetSize*(self: ptr IRecordInfo, pcbSize: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, pcbSize) +proc GetTypeInfo*(self: ptr IRecordInfo, ppTypeInfo: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeInfo(self, ppTypeInfo) +proc GetField*(self: ptr IRecordInfo, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetField(self, pvData, szFieldName, pvarField) +proc GetFieldNoCopy*(self: ptr IRecordInfo, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT, ppvDataCArray: ptr PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFieldNoCopy(self, pvData, szFieldName, pvarField, ppvDataCArray) +proc PutField*(self: ptr IRecordInfo, wFlags: ULONG, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutField(self, wFlags, pvData, szFieldName, pvarField) +proc PutFieldNoCopy*(self: ptr IRecordInfo, wFlags: ULONG, pvData: PVOID, szFieldName: LPCOLESTR, pvarField: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutFieldNoCopy(self, wFlags, pvData, szFieldName, pvarField) +proc GetFieldNames*(self: ptr IRecordInfo, pcNames: ptr ULONG, rgBstrNames: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFieldNames(self, pcNames, rgBstrNames) +proc IsMatchingType*(self: ptr IRecordInfo, pRecordInfo: ptr IRecordInfo): WINBOOL {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsMatchingType(self, pRecordInfo) +proc RecordCreate*(self: ptr IRecordInfo): PVOID {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordCreate(self) +proc RecordCreateCopy*(self: ptr IRecordInfo, pvSource: PVOID, ppvDest: ptr PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordCreateCopy(self, pvSource, ppvDest) +proc RecordDestroy*(self: ptr IRecordInfo, pvRecord: PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecordDestroy(self, pvRecord) +proc AddError*(self: ptr IErrorLog, pszPropName: LPCOLESTR, pExcepInfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddError(self, pszPropName, pExcepInfo) +proc Read*(self: ptr IPropertyBag, pszPropName: LPCOLESTR, pVar: ptr VARIANT, pErrorLog: ptr IErrorLog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Read(self, pszPropName, pVar, pErrorLog) +proc Write*(self: ptr IPropertyBag, pszPropName: LPCOLESTR, pVar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Write(self, pszPropName, pVar) +proc Advise*(self: ptr IOleAdviseHolder, pAdvise: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pAdvise, pdwConnection) +proc Unadvise*(self: ptr IOleAdviseHolder, dwConnection: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwConnection) +proc EnumAdvise*(self: ptr IOleAdviseHolder, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumAdvise(self, ppenumAdvise) +proc SendOnRename*(self: ptr IOleAdviseHolder, pmk: ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendOnRename(self, pmk) +proc SendOnSave*(self: ptr IOleAdviseHolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendOnSave(self) +proc SendOnClose*(self: ptr IOleAdviseHolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendOnClose(self) +proc Cache*(self: ptr IOleCache, pformatetc: ptr FORMATETC, advf: DWORD, pdwConnection: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cache(self, pformatetc, advf, pdwConnection) +proc Uncache*(self: ptr IOleCache, dwConnection: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Uncache(self, dwConnection) +proc EnumCache*(self: ptr IOleCache, ppenumSTATDATA: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumCache(self, ppenumSTATDATA) +proc InitCache*(self: ptr IOleCache, pDataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitCache(self, pDataObject) +proc SetData*(self: ptr IOleCache, pformatetc: ptr FORMATETC, pmedium: ptr STGMEDIUM, fRelease: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetData(self, pformatetc, pmedium, fRelease) +proc UpdateCache*(self: ptr IOleCache2, pDataObject: LPDATAOBJECT, grfUpdf: DWORD, pReserved: LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateCache(self, pDataObject, grfUpdf, pReserved) +proc DiscardCache*(self: ptr IOleCache2, dwDiscardOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DiscardCache(self, dwDiscardOptions) +proc OnRun*(self: ptr IOleCacheControl, pDataObject: LPDATAOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnRun(self, pDataObject) +proc OnStop*(self: ptr IOleCacheControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStop(self) +proc ParseDisplayName*(self: ptr IParseDisplayName, pbc: ptr IBindCtx, pszDisplayName: LPOLESTR, pchEaten: ptr ULONG, ppmkOut: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseDisplayName(self, pbc, pszDisplayName, pchEaten, ppmkOut) +proc EnumObjects*(self: ptr IOleContainer, grfFlags: DWORD, ppenum: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumObjects(self, grfFlags, ppenum) +proc LockContainer*(self: ptr IOleContainer, fLock: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockContainer(self, fLock) +proc SaveObject*(self: ptr IOleClientSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveObject(self) +proc GetMoniker*(self: ptr IOleClientSite, dwAssign: DWORD, dwWhichMoniker: DWORD, ppmk: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMoniker(self, dwAssign, dwWhichMoniker, ppmk) +proc GetContainer*(self: ptr IOleClientSite, ppContainer: ptr ptr IOleContainer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainer(self, ppContainer) +proc ShowObject*(self: ptr IOleClientSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowObject(self) +proc OnShowWindow*(self: ptr IOleClientSite, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnShowWindow(self, fShow) +proc RequestNewObjectLayout*(self: ptr IOleClientSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestNewObjectLayout(self) +proc SetClientSite*(self: ptr IOleObject, pClientSite: ptr IOleClientSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClientSite(self, pClientSite) +proc GetClientSite*(self: ptr IOleObject, ppClientSite: ptr ptr IOleClientSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClientSite(self, ppClientSite) +proc SetHostNames*(self: ptr IOleObject, szContainerApp: LPCOLESTR, szContainerObj: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHostNames(self, szContainerApp, szContainerObj) +proc Close*(self: ptr IOleObject, dwSaveOption: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self, dwSaveOption) +proc SetMoniker*(self: ptr IOleObject, dwWhichMoniker: DWORD, pmk: ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMoniker(self, dwWhichMoniker, pmk) +proc GetMoniker*(self: ptr IOleObject, dwAssign: DWORD, dwWhichMoniker: DWORD, ppmk: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMoniker(self, dwAssign, dwWhichMoniker, ppmk) +proc InitFromData*(self: ptr IOleObject, pDataObject: ptr IDataObject, fCreation: WINBOOL, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitFromData(self, pDataObject, fCreation, dwReserved) +proc GetClipboardData*(self: ptr IOleObject, dwReserved: DWORD, ppDataObject: ptr ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClipboardData(self, dwReserved, ppDataObject) +proc DoVerb*(self: ptr IOleObject, iVerb: LONG, lpmsg: LPMSG, pActiveSite: ptr IOleClientSite, lindex: LONG, hwndParent: HWND, lprcPosRect: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoVerb(self, iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect) +proc EnumVerbs*(self: ptr IOleObject, ppEnumOleVerb: ptr ptr IEnumOLEVERB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumVerbs(self, ppEnumOleVerb) +proc Update*(self: ptr IOleObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Update(self) +proc IsUpToDate*(self: ptr IOleObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsUpToDate(self) +proc GetUserClassID*(self: ptr IOleObject, pClsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUserClassID(self, pClsid) +proc GetUserType*(self: ptr IOleObject, dwFormOfType: DWORD, pszUserType: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUserType(self, dwFormOfType, pszUserType) +proc SetExtent*(self: ptr IOleObject, dwDrawAspect: DWORD, psizel: ptr SIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetExtent(self, dwDrawAspect, psizel) +proc GetExtent*(self: ptr IOleObject, dwDrawAspect: DWORD, psizel: ptr SIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtent(self, dwDrawAspect, psizel) +proc Advise*(self: ptr IOleObject, pAdvSink: ptr IAdviseSink, pdwConnection: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pAdvSink, pdwConnection) +proc Unadvise*(self: ptr IOleObject, dwConnection: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwConnection) +proc EnumAdvise*(self: ptr IOleObject, ppenumAdvise: ptr ptr IEnumSTATDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumAdvise(self, ppenumAdvise) +proc GetMiscStatus*(self: ptr IOleObject, dwAspect: DWORD, pdwStatus: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMiscStatus(self, dwAspect, pdwStatus) +proc SetColorScheme*(self: ptr IOleObject, pLogpal: ptr LOGPALETTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColorScheme(self, pLogpal) +proc GetWindow*(self: ptr IOleWindow, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindow(self, phwnd) +proc ContextSensitiveHelp*(self: ptr IOleWindow, fEnterMode: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ContextSensitiveHelp(self, fEnterMode) +proc SetUpdateOptions*(self: ptr IOleLink, dwUpdateOpt: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUpdateOptions(self, dwUpdateOpt) +proc GetUpdateOptions*(self: ptr IOleLink, pdwUpdateOpt: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUpdateOptions(self, pdwUpdateOpt) +proc SetSourceMoniker*(self: ptr IOleLink, pmk: ptr IMoniker, rclsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSourceMoniker(self, pmk, rclsid) +proc GetSourceMoniker*(self: ptr IOleLink, ppmk: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourceMoniker(self, ppmk) +proc SetSourceDisplayName*(self: ptr IOleLink, pszStatusText: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSourceDisplayName(self, pszStatusText) +proc GetSourceDisplayName*(self: ptr IOleLink, ppszDisplayName: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourceDisplayName(self, ppszDisplayName) +proc BindToSource*(self: ptr IOleLink, bindflags: DWORD, pbc: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToSource(self, bindflags, pbc) +proc BindIfRunning*(self: ptr IOleLink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindIfRunning(self) +proc GetBoundSource*(self: ptr IOleLink, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBoundSource(self, ppunk) +proc UnbindSource*(self: ptr IOleLink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnbindSource(self) +proc Update*(self: ptr IOleLink, pbc: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Update(self, pbc) +proc GetObject*(self: ptr IOleItemContainer, pszItem: LPOLESTR, dwSpeedNeeded: DWORD, pbc: ptr IBindCtx, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObject(self, pszItem, dwSpeedNeeded, pbc, riid, ppvObject) +proc GetObjectStorage*(self: ptr IOleItemContainer, pszItem: LPOLESTR, pbc: ptr IBindCtx, riid: REFIID, ppvStorage: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectStorage(self, pszItem, pbc, riid, ppvStorage) +proc IsRunning*(self: ptr IOleItemContainer, pszItem: LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRunning(self, pszItem) +proc GetBorder*(self: ptr IOleInPlaceUIWindow, lprectBorder: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBorder(self, lprectBorder) +proc RequestBorderSpace*(self: ptr IOleInPlaceUIWindow, pborderwidths: LPCBORDERWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestBorderSpace(self, pborderwidths) +proc SetBorderSpace*(self: ptr IOleInPlaceUIWindow, pborderwidths: LPCBORDERWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBorderSpace(self, pborderwidths) +proc SetActiveObject*(self: ptr IOleInPlaceUIWindow, pActiveObject: ptr IOleInPlaceActiveObject, pszObjName: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetActiveObject(self, pActiveObject, pszObjName) +proc TranslateAccelerator*(self: ptr IOleInPlaceActiveObject, lpmsg: LPMSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, lpmsg) +proc OnFrameWindowActivate*(self: ptr IOleInPlaceActiveObject, fActivate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFrameWindowActivate(self, fActivate) +proc OnDocWindowActivate*(self: ptr IOleInPlaceActiveObject, fActivate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDocWindowActivate(self, fActivate) +proc ResizeBorder*(self: ptr IOleInPlaceActiveObject, prcBorder: LPCRECT, pUIWindow: ptr IOleInPlaceUIWindow, fFrameWindow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResizeBorder(self, prcBorder, pUIWindow, fFrameWindow) +proc EnableModeless*(self: ptr IOleInPlaceActiveObject, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc InsertMenus*(self: ptr IOleInPlaceFrame, hmenuShared: HMENU, lpMenuWidths: LPOLEMENUGROUPWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertMenus(self, hmenuShared, lpMenuWidths) +proc SetMenu*(self: ptr IOleInPlaceFrame, hmenuShared: HMENU, holemenu: HOLEMENU, hwndActiveObject: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMenu(self, hmenuShared, holemenu, hwndActiveObject) +proc RemoveMenus*(self: ptr IOleInPlaceFrame, hmenuShared: HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveMenus(self, hmenuShared) +proc SetStatusText*(self: ptr IOleInPlaceFrame, pszStatusText: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStatusText(self, pszStatusText) +proc EnableModeless*(self: ptr IOleInPlaceFrame, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc TranslateAccelerator*(self: ptr IOleInPlaceFrame, lpmsg: LPMSG, wID: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, lpmsg, wID) +proc InPlaceDeactivate*(self: ptr IOleInPlaceObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InPlaceDeactivate(self) +proc UIDeactivate*(self: ptr IOleInPlaceObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UIDeactivate(self) +proc SetObjectRects*(self: ptr IOleInPlaceObject, lprcPosRect: LPCRECT, lprcClipRect: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetObjectRects(self, lprcPosRect, lprcClipRect) +proc ReactivateAndUndo*(self: ptr IOleInPlaceObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReactivateAndUndo(self) +proc CanInPlaceActivate*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanInPlaceActivate(self) +proc OnInPlaceActivate*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInPlaceActivate(self) +proc OnUIActivate*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnUIActivate(self) +proc GetWindowContext*(self: ptr IOleInPlaceSite, ppFrame: ptr ptr IOleInPlaceFrame, ppDoc: ptr ptr IOleInPlaceUIWindow, lprcPosRect: LPRECT, lprcClipRect: LPRECT, lpFrameInfo: LPOLEINPLACEFRAMEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindowContext(self, ppFrame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo) +proc Scroll*(self: ptr IOleInPlaceSite, scrollExtant: SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Scroll(self, scrollExtant) +proc OnUIDeactivate*(self: ptr IOleInPlaceSite, fUndoable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnUIDeactivate(self, fUndoable) +proc OnInPlaceDeactivate*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInPlaceDeactivate(self) +proc DiscardUndoState*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DiscardUndoState(self) +proc DeactivateAndUndo*(self: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeactivateAndUndo(self) +proc OnPosRectChange*(self: ptr IOleInPlaceSite, lprcPosRect: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPosRectChange(self, lprcPosRect) +proc FContinue*(self: ptr IContinue): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FContinue(self) +proc Draw*(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, ptd: ptr DVTARGETDEVICE, hdcTargetDev: HDC, hdcDraw: HDC, lprcBounds: LPCRECTL, lprcWBounds: LPCRECTL, pfnContinue: proc (dwContinue: ULONG_PTR): WINBOOL {.stdcall.}, dwContinue: ULONG_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Draw(self, dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue) +proc GetColorSet*(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, ptd: ptr DVTARGETDEVICE, hicTargetDev: HDC, ppColorSet: ptr ptr LOGPALETTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorSet(self, dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet) +proc Freeze*(self: ptr IViewObject, dwDrawAspect: DWORD, lindex: LONG, pvAspect: pointer, pdwFreeze: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Freeze(self, dwDrawAspect, lindex, pvAspect, pdwFreeze) +proc Unfreeze*(self: ptr IViewObject, dwFreeze: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unfreeze(self, dwFreeze) +proc SetAdvise*(self: ptr IViewObject, aspects: DWORD, advf: DWORD, pAdvSink: ptr IAdviseSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAdvise(self, aspects, advf, pAdvSink) +proc GetAdvise*(self: ptr IViewObject, pAspects: ptr DWORD, pAdvf: ptr DWORD, ppAdvSink: ptr ptr IAdviseSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAdvise(self, pAspects, pAdvf, ppAdvSink) +proc GetExtent*(self: ptr IViewObject2, dwDrawAspect: DWORD, lindex: LONG, ptd: ptr DVTARGETDEVICE, lpsizel: LPSIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtent(self, dwDrawAspect, lindex, ptd, lpsizel) +proc QueryContinueDrag*(self: ptr IDropSource, fEscapePressed: WINBOOL, grfKeyState: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryContinueDrag(self, fEscapePressed, grfKeyState) +proc GiveFeedback*(self: ptr IDropSource, dwEffect: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GiveFeedback(self, dwEffect) +proc DragEnter*(self: ptr IDropTarget, pDataObj: ptr IDataObject, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragEnter(self, pDataObj, grfKeyState, pt, pdwEffect) +proc DragOver*(self: ptr IDropTarget, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragOver(self, grfKeyState, pt, pdwEffect) +proc DragLeave*(self: ptr IDropTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragLeave(self) +proc Drop*(self: ptr IDropTarget, pDataObj: ptr IDataObject, grfKeyState: DWORD, pt: POINTL, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Drop(self, pDataObj, grfKeyState, pt, pdwEffect) +proc DragEnterTarget*(self: ptr IDropSourceNotify, hwndTarget: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragEnterTarget(self, hwndTarget) +proc DragLeaveTarget*(self: ptr IDropSourceNotify): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragLeaveTarget(self) +proc Next*(self: ptr IEnumOLEVERB, celt: ULONG, rgelt: LPOLEVERB, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumOLEVERB, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumOLEVERB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumOLEVERB, ppenum: ptr ptr IEnumOLEVERB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc QueryService*(self: ptr IServiceProvider, guidService: REFGUID, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryService(self, guidService, riid, ppvObject) +proc hasFeature*(self: ptr IXMLDOMImplementation, feature: BSTR, version: BSTR, hasFeature: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasFeature(self, feature, version, hasFeature) +proc get_nodeName*(self: ptr IXMLDOMNode, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeName(self, name) +proc get_nodeValue*(self: ptr IXMLDOMNode, value: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeValue(self, value) +proc put_nodeValue*(self: ptr IXMLDOMNode, value: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeValue(self, value) +proc get_nodeType*(self: ptr IXMLDOMNode, `type`: ptr DOMNodeType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeType(self, `type`) +proc get_parentNode*(self: ptr IXMLDOMNode, parent: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parentNode(self, parent) +proc get_childNodes*(self: ptr IXMLDOMNode, childList: ptr ptr IXMLDOMNodeList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_childNodes(self, childList) +proc get_firstChild*(self: ptr IXMLDOMNode, firstChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_firstChild(self, firstChild) +proc get_lastChild*(self: ptr IXMLDOMNode, lastChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_lastChild(self, lastChild) +proc get_previousSibling*(self: ptr IXMLDOMNode, previousSibling: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_previousSibling(self, previousSibling) +proc get_nextSibling*(self: ptr IXMLDOMNode, nextSibling: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nextSibling(self, nextSibling) +proc get_attributes*(self: ptr IXMLDOMNode, attributeMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attributes(self, attributeMap) +proc insertBefore*(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, refChild: VARIANT, outNewChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertBefore(self, newChild, refChild, outNewChild) +proc replaceChild*(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, oldChild: ptr IXMLDOMNode, outOldChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceChild(self, newChild, oldChild, outOldChild) +proc removeChild*(self: ptr IXMLDOMNode, childNode: ptr IXMLDOMNode, oldChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, childNode, oldChild) +proc appendChild*(self: ptr IXMLDOMNode, newChild: ptr IXMLDOMNode, outNewChild: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendChild(self, newChild, outNewChild) +proc hasChildNodes*(self: ptr IXMLDOMNode, hasChild: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.hasChildNodes(self, hasChild) +proc get_ownerDocument*(self: ptr IXMLDOMNode, DOMDocument: ptr ptr IXMLDOMDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ownerDocument(self, DOMDocument) +proc cloneNode*(self: ptr IXMLDOMNode, deep: VARIANT_BOOL, cloneRoot: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.cloneNode(self, deep, cloneRoot) +proc get_nodeTypeString*(self: ptr IXMLDOMNode, nodeType: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeTypeString(self, nodeType) +proc get_text*(self: ptr IXMLDOMNode, text: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, text) +proc put_text*(self: ptr IXMLDOMNode, text: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, text) +proc get_specified*(self: ptr IXMLDOMNode, isSpecified: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_specified(self, isSpecified) +proc get_definition*(self: ptr IXMLDOMNode, definitionNode: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_definition(self, definitionNode) +proc get_nodeTypedValue*(self: ptr IXMLDOMNode, typedValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_nodeTypedValue(self, typedValue) +proc put_nodeTypedValue*(self: ptr IXMLDOMNode, typedValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_nodeTypedValue(self, typedValue) +proc get_dataType*(self: ptr IXMLDOMNode, dataTypeName: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dataType(self, dataTypeName) +proc put_dataType*(self: ptr IXMLDOMNode, dataTypeName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_dataType(self, dataTypeName) +proc get_xml*(self: ptr IXMLDOMNode, xmlString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_xml(self, xmlString) +proc transformNode*(self: ptr IXMLDOMNode, stylesheet: ptr IXMLDOMNode, xmlString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.transformNode(self, stylesheet, xmlString) +proc selectNodes*(self: ptr IXMLDOMNode, queryString: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectNodes(self, queryString, resultList) +proc selectSingleNode*(self: ptr IXMLDOMNode, queryString: BSTR, resultNode: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.selectSingleNode(self, queryString, resultNode) +proc get_parsed*(self: ptr IXMLDOMNode, isParsed: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parsed(self, isParsed) +proc get_namespaceURI*(self: ptr IXMLDOMNode, namespaceURI: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_namespaceURI(self, namespaceURI) +proc get_prefix*(self: ptr IXMLDOMNode, prefixString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_prefix(self, prefixString) +proc get_baseName*(self: ptr IXMLDOMNode, nameString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_baseName(self, nameString) +proc transformNodeToObject*(self: ptr IXMLDOMNode, stylesheet: ptr IXMLDOMNode, outputObject: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.transformNodeToObject(self, stylesheet, outputObject) +proc get_doctype*(self: ptr IXMLDOMDocument, documentType: ptr ptr IXMLDOMDocumentType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_doctype(self, documentType) +proc get_implementation*(self: ptr IXMLDOMDocument, impl: ptr ptr IXMLDOMImplementation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_implementation(self, impl) +proc get_documentElement*(self: ptr IXMLDOMDocument, DOMElement: ptr ptr IXMLDOMElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_documentElement(self, DOMElement) +proc putref_documentElement*(self: ptr IXMLDOMDocument, DOMElement: ptr IXMLDOMElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.putref_documentElement(self, DOMElement) +proc createElement*(self: ptr IXMLDOMDocument, tagName: BSTR, element: ptr ptr IXMLDOMElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElement(self, tagName, element) +proc createDocumentFragment*(self: ptr IXMLDOMDocument, docFrag: ptr ptr IXMLDOMDocumentFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createDocumentFragment(self, docFrag) +proc createTextNode*(self: ptr IXMLDOMDocument, data: BSTR, text: ptr ptr IXMLDOMText): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createTextNode(self, data, text) +proc createComment*(self: ptr IXMLDOMDocument, data: BSTR, comment: ptr ptr IXMLDOMComment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createComment(self, data, comment) +proc createCDATASection*(self: ptr IXMLDOMDocument, data: BSTR, cdata: ptr ptr IXMLDOMCDATASection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createCDATASection(self, data, cdata) +proc createProcessingInstruction*(self: ptr IXMLDOMDocument, target: BSTR, data: BSTR, pi: ptr ptr IXMLDOMProcessingInstruction): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createProcessingInstruction(self, target, data, pi) +proc createAttribute*(self: ptr IXMLDOMDocument, name: BSTR, attribute: ptr ptr IXMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createAttribute(self, name, attribute) +proc createEntityReference*(self: ptr IXMLDOMDocument, name: BSTR, entityRef: ptr ptr IXMLDOMEntityReference): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createEntityReference(self, name, entityRef) +proc getElementsByTagName*(self: ptr IXMLDOMDocument, tagName: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagName(self, tagName, resultList) +proc createNode*(self: ptr IXMLDOMDocument, Type: VARIANT, name: BSTR, namespaceURI: BSTR, node: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createNode(self, Type, name, namespaceURI, node) +proc nodeFromID*(self: ptr IXMLDOMDocument, idString: BSTR, node: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nodeFromID(self, idString, node) +proc load*(self: ptr IXMLDOMDocument, xmlSource: VARIANT, isSuccessful: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.load(self, xmlSource, isSuccessful) +proc get_readyState*(self: ptr IXMLDOMDocument, value: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, value) +proc get_parseError*(self: ptr IXMLDOMDocument, errorObj: ptr ptr IXMLDOMParseError): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parseError(self, errorObj) +proc get_url*(self: ptr IXMLDOMDocument, urlString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, urlString) +proc get_async*(self: ptr IXMLDOMDocument, isAsync: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_async(self, isAsync) +proc put_async*(self: ptr IXMLDOMDocument, isAsync: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_async(self, isAsync) +proc abort*(self: ptr IXMLDOMDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.abort(self) +proc loadXML*(self: ptr IXMLDOMDocument, bstrXML: BSTR, isSuccessful: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.loadXML(self, bstrXML, isSuccessful) +proc save*(self: ptr IXMLDOMDocument, destination: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.save(self, destination) +proc get_validateOnParse*(self: ptr IXMLDOMDocument, isValidating: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_validateOnParse(self, isValidating) +proc put_validateOnParse*(self: ptr IXMLDOMDocument, isValidating: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_validateOnParse(self, isValidating) +proc get_resolveExternals*(self: ptr IXMLDOMDocument, isResolving: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_resolveExternals(self, isResolving) +proc put_resolveExternals*(self: ptr IXMLDOMDocument, isResolving: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_resolveExternals(self, isResolving) +proc get_preserveWhiteSpace*(self: ptr IXMLDOMDocument, isPreserving: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_preserveWhiteSpace(self, isPreserving) +proc put_preserveWhiteSpace*(self: ptr IXMLDOMDocument, isPreserving: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_preserveWhiteSpace(self, isPreserving) +proc put_onreadystatechange*(self: ptr IXMLDOMDocument, readystatechangeSink: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, readystatechangeSink) +proc put_ondataavailable*(self: ptr IXMLDOMDocument, ondataavailableSink: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ondataavailable(self, ondataavailableSink) +proc put_ontransformnode*(self: ptr IXMLDOMDocument, ontransformnodeSink: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ontransformnode(self, ontransformnodeSink) +proc get_item*(self: ptr IXMLDOMNodeList, index: LONG, listItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_item(self, index, listItem) +proc get_length*(self: ptr IXMLDOMNodeList, listLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, listLength) +proc nextNode*(self: ptr IXMLDOMNodeList, nextItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextNode(self, nextItem) +proc reset*(self: ptr IXMLDOMNodeList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.reset(self) +proc get_newEnum*(self: ptr IXMLDOMNodeList, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, ppUnk) +proc getNamedItem*(self: ptr IXMLDOMNamedNodeMap, name: BSTR, namedItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getNamedItem(self, name, namedItem) +proc setNamedItem*(self: ptr IXMLDOMNamedNodeMap, newItem: ptr IXMLDOMNode, nameItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setNamedItem(self, newItem, nameItem) +proc removeNamedItem*(self: ptr IXMLDOMNamedNodeMap, name: BSTR, namedItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeNamedItem(self, name, namedItem) +proc get_item*(self: ptr IXMLDOMNamedNodeMap, index: LONG, listItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_item(self, index, listItem) +proc get_length*(self: ptr IXMLDOMNamedNodeMap, listLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, listLength) +proc getQualifiedItem*(self: ptr IXMLDOMNamedNodeMap, baseName: BSTR, namespaceURI: BSTR, qualifiedItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getQualifiedItem(self, baseName, namespaceURI, qualifiedItem) +proc removeQualifiedItem*(self: ptr IXMLDOMNamedNodeMap, baseName: BSTR, namespaceURI: BSTR, qualifiedItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeQualifiedItem(self, baseName, namespaceURI, qualifiedItem) +proc nextNode*(self: ptr IXMLDOMNamedNodeMap, nextItem: ptr ptr IXMLDOMNode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.nextNode(self, nextItem) +proc reset*(self: ptr IXMLDOMNamedNodeMap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.reset(self) +proc get_newEnum*(self: ptr IXMLDOMNamedNodeMap, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, ppUnk) +proc get_data*(self: ptr IXMLDOMCharacterData, data: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, data) +proc put_data*(self: ptr IXMLDOMCharacterData, data: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, data) +proc get_length*(self: ptr IXMLDOMCharacterData, dataLength: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, dataLength) +proc substringData*(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG, data: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.substringData(self, offset, count, data) +proc appendData*(self: ptr IXMLDOMCharacterData, data: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.appendData(self, data) +proc insertData*(self: ptr IXMLDOMCharacterData, offset: LONG, data: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.insertData(self, offset, data) +proc deleteData*(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.deleteData(self, offset, count) +proc replaceData*(self: ptr IXMLDOMCharacterData, offset: LONG, count: LONG, data: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.replaceData(self, offset, count, data) +proc get_name*(self: ptr IXMLDOMAttribute, attributeName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, attributeName) +proc get_value*(self: ptr IXMLDOMAttribute, attributeValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, attributeValue) +proc put_value*(self: ptr IXMLDOMAttribute, attributeValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_value(self, attributeValue) +proc get_tagName*(self: ptr IXMLDOMElement, tagName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagName(self, tagName) +proc getAttribute*(self: ptr IXMLDOMElement, name: BSTR, value: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, name, value) +proc setAttribute*(self: ptr IXMLDOMElement, name: BSTR, value: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, name, value) +proc removeAttribute*(self: ptr IXMLDOMElement, name: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, name) +proc getAttributeNode*(self: ptr IXMLDOMElement, name: BSTR, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttributeNode(self, name, attributeNode) +proc setAttributeNode*(self: ptr IXMLDOMElement, DOMAttribute: ptr IXMLDOMAttribute, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttributeNode(self, DOMAttribute, attributeNode) +proc removeAttributeNode*(self: ptr IXMLDOMElement, DOMAttribute: ptr IXMLDOMAttribute, attributeNode: ptr ptr IXMLDOMAttribute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttributeNode(self, DOMAttribute, attributeNode) +proc getElementsByTagName*(self: ptr IXMLDOMElement, tagName: BSTR, resultList: ptr ptr IXMLDOMNodeList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getElementsByTagName(self, tagName, resultList) +proc normalize*(self: ptr IXMLDOMElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.normalize(self) +proc splitText*(self: ptr IXMLDOMText, offset: LONG, rightHandTextNode: ptr ptr IXMLDOMText): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.splitText(self, offset, rightHandTextNode) +proc get_target*(self: ptr IXMLDOMProcessingInstruction, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_target(self, name) +proc get_data*(self: ptr IXMLDOMProcessingInstruction, value: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_data(self, value) +proc put_data*(self: ptr IXMLDOMProcessingInstruction, value: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_data(self, value) +proc get_name*(self: ptr IXMLDOMDocumentType, rootName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, rootName) +proc get_entities*(self: ptr IXMLDOMDocumentType, entityMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_entities(self, entityMap) +proc get_notations*(self: ptr IXMLDOMDocumentType, notationMap: ptr ptr IXMLDOMNamedNodeMap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_notations(self, notationMap) +proc get_publicId*(self: ptr IXMLDOMNotation, publicID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_publicId(self, publicID) +proc get_systemId*(self: ptr IXMLDOMNotation, systemID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemId(self, systemID) +proc get_publicId*(self: ptr IXMLDOMEntity, publicID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_publicId(self, publicID) +proc get_systemId*(self: ptr IXMLDOMEntity, systemID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_systemId(self, systemID) +proc get_notationName*(self: ptr IXMLDOMEntity, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_notationName(self, name) +proc get_errorCode*(self: ptr IXMLDOMParseError, errorCode: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_errorCode(self, errorCode) +proc get_url*(self: ptr IXMLDOMParseError, urlString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_url(self, urlString) +proc get_reason*(self: ptr IXMLDOMParseError, reasonString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_reason(self, reasonString) +proc get_srcText*(self: ptr IXMLDOMParseError, sourceString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_srcText(self, sourceString) +proc get_line*(self: ptr IXMLDOMParseError, lineNumber: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_line(self, lineNumber) +proc get_linepos*(self: ptr IXMLDOMParseError, linePosition: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_linepos(self, linePosition) +proc get_filepos*(self: ptr IXMLDOMParseError, filePosition: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_filepos(self, filePosition) +proc uniqueID*(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.uniqueID(self, pNode, pID) +proc depth*(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pDepth: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.depth(self, pNode, pDepth) +proc childNumber*(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.childNumber(self, pNode, pNumber) +proc ancestorChildNumber*(self: ptr IXTLRuntime, bstrNodeName: BSTR, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ancestorChildNumber(self, bstrNodeName, pNode, pNumber) +proc absoluteChildNumber*(self: ptr IXTLRuntime, pNode: ptr IXMLDOMNode, pNumber: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.absoluteChildNumber(self, pNode, pNumber) +proc formatIndex*(self: ptr IXTLRuntime, lIndex: LONG, bstrFormat: BSTR, pbstrFormattedString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.formatIndex(self, lIndex, bstrFormat, pbstrFormattedString) +proc formatNumber*(self: ptr IXTLRuntime, dblNumber: float64, bstrFormat: BSTR, pbstrFormattedString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.formatNumber(self, dblNumber, bstrFormat, pbstrFormattedString) +proc formatDate*(self: ptr IXTLRuntime, varDate: VARIANT, bstrFormat: BSTR, varDestLocale: VARIANT, pbstrFormattedString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.formatDate(self, varDate, bstrFormat, varDestLocale, pbstrFormattedString) +proc formatTime*(self: ptr IXTLRuntime, varTime: VARIANT, bstrFormat: BSTR, varDestLocale: VARIANT, pbstrFormattedString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.formatTime(self, varTime, bstrFormat, varDestLocale, pbstrFormattedString) +proc open*(self: ptr IXMLHttpRequest, bstrMethod: BSTR, bstrUrl: BSTR, varAsync: VARIANT, bstrUser: VARIANT, bstrPassword: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.open(self, bstrMethod, bstrUrl, varAsync, bstrUser, bstrPassword) +proc setRequestHeader*(self: ptr IXMLHttpRequest, bstrHeader: BSTR, bstrValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setRequestHeader(self, bstrHeader, bstrValue) +proc getResponseHeader*(self: ptr IXMLHttpRequest, bstrHeader: BSTR, pbstrValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getResponseHeader(self, bstrHeader, pbstrValue) +proc getAllResponseHeaders*(self: ptr IXMLHttpRequest, pbstrHeaders: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAllResponseHeaders(self, pbstrHeaders) +proc send*(self: ptr IXMLHttpRequest, varBody: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.send(self, varBody) +proc abort*(self: ptr IXMLHttpRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.abort(self) +proc get_status*(self: ptr IXMLHttpRequest, plStatus: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_status(self, plStatus) +proc get_statusText*(self: ptr IXMLHttpRequest, pbstrStatus: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_statusText(self, pbstrStatus) +proc get_responseXML*(self: ptr IXMLHttpRequest, ppBody: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseXML(self, ppBody) +proc get_responseText*(self: ptr IXMLHttpRequest, pbstrBody: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseText(self, pbstrBody) +proc get_responseBody*(self: ptr IXMLHttpRequest, pvarBody: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseBody(self, pvarBody) +proc get_responseStream*(self: ptr IXMLHttpRequest, pvarBody: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_responseStream(self, pvarBody) +proc get_readyState*(self: ptr IXMLHttpRequest, plState: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, plState) +proc put_onreadystatechange*(self: ptr IXMLHttpRequest, pReadyStateSink: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_onreadystatechange(self, pReadyStateSink) +proc get_XMLDocument*(self: ptr IXMLDSOControl, ppDoc: ptr ptr IXMLDOMDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_XMLDocument(self, ppDoc) +proc put_XMLDocument*(self: ptr IXMLDSOControl, ppDoc: ptr IXMLDOMDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_XMLDocument(self, ppDoc) +proc get_JavaDSOCompatible*(self: ptr IXMLDSOControl, fJavaDSOCompatible: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_JavaDSOCompatible(self, fJavaDSOCompatible) +proc put_JavaDSOCompatible*(self: ptr IXMLDSOControl, fJavaDSOCompatible: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_JavaDSOCompatible(self, fJavaDSOCompatible) +proc get_readyState*(self: ptr IXMLDSOControl, state: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, state) +proc put_length*(self: ptr IXMLElementCollection, v: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_length(self, v) +proc get_length*(self: ptr IXMLElementCollection, p: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_length(self, p) +proc get_newEnum*(self: ptr IXMLElementCollection, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_newEnum(self, ppUnk) +proc item*(self: ptr IXMLElementCollection, var1: VARIANT, var2: VARIANT, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.item(self, var1, var2, ppDisp) +proc get_root*(self: ptr IXMLDocument, p: ptr ptr IXMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_root(self, p) +proc get_fileSize*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileSize(self, p) +proc get_fileModifiedDate*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileModifiedDate(self, p) +proc get_fileUpdatedDate*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileUpdatedDate(self, p) +proc get_URL*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URL(self, p) +proc put_URL*(self: ptr IXMLDocument, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_URL(self, p) +proc get_mimeType*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeType(self, p) +proc get_readyState*(self: ptr IXMLDocument, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, pl) +proc get_charset*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_charset*(self: ptr IXMLDocument, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, p) +proc get_version*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc get_doctype*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_doctype(self, p) +proc get_dtdURL*(self: ptr IXMLDocument, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dtdURL(self, p) +proc createElement*(self: ptr IXMLDocument, vType: VARIANT, var1: VARIANT, ppElem: ptr ptr IXMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElement(self, vType, var1, ppElem) +proc get_root*(self: ptr IXMLDocument2, p: ptr ptr IXMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_root(self, p) +proc get_fileSize*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileSize(self, p) +proc get_fileModifiedDate*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileModifiedDate(self, p) +proc get_fileUpdatedDate*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_fileUpdatedDate(self, p) +proc get_URL*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URL(self, p) +proc put_URL*(self: ptr IXMLDocument2, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_URL(self, p) +proc get_mimeType*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_mimeType(self, p) +proc get_readyState*(self: ptr IXMLDocument2, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_readyState(self, pl) +proc get_charset*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_charset(self, p) +proc put_charset*(self: ptr IXMLDocument2, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_charset(self, p) +proc get_version*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_version(self, p) +proc get_doctype*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_doctype(self, p) +proc get_dtdURL*(self: ptr IXMLDocument2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_dtdURL(self, p) +proc createElement*(self: ptr IXMLDocument2, vType: VARIANT, var1: VARIANT, ppElem: ptr ptr IXMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.createElement(self, vType, var1, ppElem) +proc get_async*(self: ptr IXMLDocument2, pf: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_async(self, pf) +proc put_async*(self: ptr IXMLDocument2, f: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_async(self, f) +proc get_tagName*(self: ptr IXMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagName(self, p) +proc put_tagName*(self: ptr IXMLElement, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tagName(self, p) +proc get_parent*(self: ptr IXMLElement, ppParent: ptr ptr IXMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parent(self, ppParent) +proc setAttribute*(self: ptr IXMLElement, strPropertyName: BSTR, PropertyValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strPropertyName, PropertyValue) +proc getAttribute*(self: ptr IXMLElement, strPropertyName: BSTR, PropertyValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strPropertyName, PropertyValue) +proc removeAttribute*(self: ptr IXMLElement, strPropertyName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strPropertyName) +proc get_children*(self: ptr IXMLElement, pp: ptr ptr IXMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_children(self, pp) +proc get_type*(self: ptr IXMLElement, plType: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, plType) +proc get_text*(self: ptr IXMLElement, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_text*(self: ptr IXMLElement, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, p) +proc addChild*(self: ptr IXMLElement, pChildElem: ptr IXMLElement, lIndex: LONG, lReserved: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addChild(self, pChildElem, lIndex, lReserved) +proc removeChild*(self: ptr IXMLElement, pChildElem: ptr IXMLElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, pChildElem) +proc get_tagName*(self: ptr IXMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_tagName(self, p) +proc put_tagName*(self: ptr IXMLElement2, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_tagName(self, p) +proc get_parent*(self: ptr IXMLElement2, ppParent: ptr ptr IXMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_parent(self, ppParent) +proc setAttribute*(self: ptr IXMLElement2, strPropertyName: BSTR, PropertyValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setAttribute(self, strPropertyName, PropertyValue) +proc getAttribute*(self: ptr IXMLElement2, strPropertyName: BSTR, PropertyValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAttribute(self, strPropertyName, PropertyValue) +proc removeAttribute*(self: ptr IXMLElement2, strPropertyName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeAttribute(self, strPropertyName) +proc get_children*(self: ptr IXMLElement2, pp: ptr ptr IXMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_children(self, pp) +proc get_type*(self: ptr IXMLElement2, plType: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_type(self, plType) +proc get_text*(self: ptr IXMLElement2, p: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_text(self, p) +proc put_text*(self: ptr IXMLElement2, p: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_text(self, p) +proc addChild*(self: ptr IXMLElement2, pChildElem: ptr IXMLElement2, lIndex: LONG, lReserved: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.addChild(self, pChildElem, lIndex, lReserved) +proc removeChild*(self: ptr IXMLElement2, pChildElem: ptr IXMLElement2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.removeChild(self, pChildElem) +proc get_attributes*(self: ptr IXMLElement2, pp: ptr ptr IXMLElementCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_attributes(self, pp) +proc get_name*(self: ptr IXMLAttribute, n: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_name(self, n) +proc get_value*(self: ptr IXMLAttribute, v: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_value(self, v) +proc GetErrorInfo*(self: ptr IXMLError, pErrorReturn: ptr XML_ERROR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetErrorInfo(self, pErrorReturn) +proc GetClassID*(self: ptr IPersistMoniker, pClassID: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClassID(self, pClassID) +proc IsDirty*(self: ptr IPersistMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc Load*(self: ptr IPersistMoniker, fFullyAvailable: WINBOOL, pimkName: ptr IMoniker, pibc: LPBC, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, fFullyAvailable, pimkName, pibc, grfMode) +proc Save*(self: ptr IPersistMoniker, pimkName: ptr IMoniker, pbc: LPBC, fRemember: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pimkName, pbc, fRemember) +proc SaveCompleted*(self: ptr IPersistMoniker, pimkName: ptr IMoniker, pibc: LPBC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveCompleted(self, pimkName, pibc) +proc GetCurMoniker*(self: ptr IPersistMoniker, ppimkName: ptr ptr IMoniker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurMoniker(self, ppimkName) +proc PutProperty*(self: ptr IMonikerProp, mkp: MONIKERPROPERTY, val: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutProperty(self, mkp, val) +proc CreateBinding*(self: ptr IBindProtocol, szUrl: LPCWSTR, pbc: ptr IBindCtx, ppb: ptr ptr IBinding): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBinding(self, szUrl, pbc, ppb) +proc Abort*(self: ptr IBinding): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Abort(self) +proc Suspend*(self: ptr IBinding): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Suspend(self) +proc Resume*(self: ptr IBinding): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resume(self) +proc SetPriority*(self: ptr IBinding, nPriority: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPriority(self, nPriority) +proc GetPriority*(self: ptr IBinding, pnPriority: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPriority(self, pnPriority) +proc GetBindResult*(self: ptr IBinding, pclsidProtocol: ptr CLSID, pdwResult: ptr DWORD, pszResult: ptr LPOLESTR, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindResult(self, pclsidProtocol, pdwResult, pszResult, pdwReserved) +proc OnStartBinding*(self: ptr IBindStatusCallback, dwReserved: DWORD, pib: ptr IBinding): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStartBinding(self, dwReserved, pib) +proc GetPriority*(self: ptr IBindStatusCallback, pnPriority: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPriority(self, pnPriority) +proc OnLowResource*(self: ptr IBindStatusCallback, reserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnLowResource(self, reserved) +proc OnProgress*(self: ptr IBindStatusCallback, ulProgress: ULONG, ulProgressMax: ULONG, ulStatusCode: ULONG, szStatusText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnProgress(self, ulProgress, ulProgressMax, ulStatusCode, szStatusText) +proc OnStopBinding*(self: ptr IBindStatusCallback, hresult: HRESULT, szError: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStopBinding(self, hresult, szError) +proc GetBindInfo*(self: ptr IBindStatusCallback, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindInfo(self, grfBINDF, pbindinfo) +proc OnDataAvailable*(self: ptr IBindStatusCallback, grfBSCF: DWORD, dwSize: DWORD, pformatetc: ptr FORMATETC, pstgmed: ptr STGMEDIUM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDataAvailable(self, grfBSCF, dwSize, pformatetc, pstgmed) +proc OnObjectAvailable*(self: ptr IBindStatusCallback, riid: REFIID, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnObjectAvailable(self, riid, punk) +proc GetBindInfoEx*(self: ptr IBindStatusCallbackEx, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO, grfBINDF2: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindInfoEx(self, grfBINDF, pbindinfo, grfBINDF2, pdwReserved) +proc Authenticate*(self: ptr IAuthenticate, phwnd: ptr HWND, pszUsername: ptr LPWSTR, pszPassword: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Authenticate(self, phwnd, pszUsername, pszPassword) +proc AuthenticateEx*(self: ptr IAuthenticateEx, phwnd: ptr HWND, pszUsername: ptr LPWSTR, pszPassword: ptr LPWSTR, pauthinfo: ptr AUTHENTICATEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AuthenticateEx(self, phwnd, pszUsername, pszPassword, pauthinfo) +proc BeginningTransaction*(self: ptr IHttpNegotiate, szURL: LPCWSTR, szHeaders: LPCWSTR, dwReserved: DWORD, pszAdditionalHeaders: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginningTransaction(self, szURL, szHeaders, dwReserved, pszAdditionalHeaders) +proc OnResponse*(self: ptr IHttpNegotiate, dwResponseCode: DWORD, szResponseHeaders: LPCWSTR, szRequestHeaders: LPCWSTR, pszAdditionalRequestHeaders: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnResponse(self, dwResponseCode, szResponseHeaders, szRequestHeaders, pszAdditionalRequestHeaders) +proc GetRootSecurityId*(self: ptr IHttpNegotiate2, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRootSecurityId(self, pbSecurityId, pcbSecurityId, dwReserved) +proc GetSerializedClientCertContext*(self: ptr IHttpNegotiate3, ppbCert: ptr ptr BYTE, pcbCert: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSerializedClientCertContext(self, ppbCert, pcbCert) +proc SetHandleForUnlock*(self: ptr IWinInetFileStream, hWinInetLockHandle: DWORD_PTR, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHandleForUnlock(self, hWinInetLockHandle, dwReserved) +proc SetDeleteFile*(self: ptr IWinInetFileStream, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDeleteFile(self, dwReserved) +proc GetWindow*(self: ptr IWindowForBindingUI, rguidReason: REFGUID, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindow(self, rguidReason, phwnd) +proc OnCodeInstallProblem*(self: ptr ICodeInstall, ulStatusCode: ULONG, szDestination: LPCWSTR, szSource: LPCWSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnCodeInstallProblem(self, ulStatusCode, szDestination, szSource, dwReserved) +proc GetPropertyBSTR*(self: ptr IUri, uriProp: Uri_PROPERTY, pbstrProperty: ptr BSTR, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyBSTR(self, uriProp, pbstrProperty, dwFlags) +proc GetPropertyLength*(self: ptr IUri, uriProp: Uri_PROPERTY, pcchProperty: ptr DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyLength(self, uriProp, pcchProperty, dwFlags) +proc GetPropertyDWORD*(self: ptr IUri, uriProp: Uri_PROPERTY, pdwProperty: ptr DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDWORD(self, uriProp, pdwProperty, dwFlags) +proc HasProperty*(self: ptr IUri, uriProp: Uri_PROPERTY, pfHasProperty: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasProperty(self, uriProp, pfHasProperty) +proc GetAbsoluteUri*(self: ptr IUri, pbstrAbsoluteUri: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAbsoluteUri(self, pbstrAbsoluteUri) +proc GetAuthority*(self: ptr IUri, pbstrAuthority: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAuthority(self, pbstrAuthority) +proc GetDisplayUri*(self: ptr IUri, pbstrDisplayString: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayUri(self, pbstrDisplayString) +proc GetDomain*(self: ptr IUri, pbstrDomain: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDomain(self, pbstrDomain) +proc GetExtension*(self: ptr IUri, pbstrExtension: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtension(self, pbstrExtension) +proc GetFragment*(self: ptr IUri, pbstrFragment: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFragment(self, pbstrFragment) +proc GetHost*(self: ptr IUri, pbstrHost: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHost(self, pbstrHost) +proc GetPassword*(self: ptr IUri, pbstrPassword: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPassword(self, pbstrPassword) +proc GetPath*(self: ptr IUri, pbstrPath: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, pbstrPath) +proc GetPathAndQuery*(self: ptr IUri, pbstrPathAndQuery: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPathAndQuery(self, pbstrPathAndQuery) +proc GetQuery*(self: ptr IUri, pbstrQuery: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetQuery(self, pbstrQuery) +proc GetRawUri*(self: ptr IUri, pbstrRawUri: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRawUri(self, pbstrRawUri) +proc GetSchemeName*(self: ptr IUri, pbstrSchemeName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSchemeName(self, pbstrSchemeName) +proc GetUserInfo*(self: ptr IUri, pbstrUserInfo: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUserInfo(self, pbstrUserInfo) +proc GetUserName*(self: ptr IUri, pbstrUserName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUserName(self, pbstrUserName) +proc GetHostType*(self: ptr IUri, pdwHostType: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHostType(self, pdwHostType) +proc GetPort*(self: ptr IUri, pdwPort: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPort(self, pdwPort) +proc GetScheme*(self: ptr IUri, pdwScheme: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScheme(self, pdwScheme) +proc GetZone*(self: ptr IUri, pdwZone: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZone(self, pdwZone) +proc GetProperties*(self: ptr IUri, pdwFlags: LPDWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperties(self, pdwFlags) +proc IsEqual*(self: ptr IUri, pUri: ptr IUri, pfEqual: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqual(self, pUri, pfEqual) +proc GetIUri*(self: ptr IUriContainer, ppIUri: ptr ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIUri(self, ppIUri) +proc CreateUriSimple*(self: ptr IUriBuilder, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateUriSimple(self, dwAllowEncodingPropertyMask, dwReserved, ppIUri) +proc CreateUri*(self: ptr IUriBuilder, dwCreateFlags: DWORD, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateUri(self, dwCreateFlags, dwAllowEncodingPropertyMask, dwReserved, ppIUri) +proc CreateUriWithFlags*(self: ptr IUriBuilder, dwCreateFlags: DWORD, dwUriBuilderFlags: DWORD, dwAllowEncodingPropertyMask: DWORD, dwReserved: DWORD_PTR, ppIUri: ptr ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateUriWithFlags(self, dwCreateFlags, dwUriBuilderFlags, dwAllowEncodingPropertyMask, dwReserved, ppIUri) +proc GetIUri*(self: ptr IUriBuilder, ppIUri: ptr ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIUri(self, ppIUri) +proc SetIUri*(self: ptr IUriBuilder, pIUri: ptr IUri): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIUri(self, pIUri) +proc GetFragment*(self: ptr IUriBuilder, pcchFragment: ptr DWORD, ppwzFragment: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFragment(self, pcchFragment, ppwzFragment) +proc GetHost*(self: ptr IUriBuilder, pcchHost: ptr DWORD, ppwzHost: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHost(self, pcchHost, ppwzHost) +proc GetPassword*(self: ptr IUriBuilder, pcchPassword: ptr DWORD, ppwzPassword: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPassword(self, pcchPassword, ppwzPassword) +proc GetPath*(self: ptr IUriBuilder, pcchPath: ptr DWORD, ppwzPath: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, pcchPath, ppwzPath) +proc GetPort*(self: ptr IUriBuilder, pfHasPort: ptr WINBOOL, pdwPort: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPort(self, pfHasPort, pdwPort) +proc GetQuery*(self: ptr IUriBuilder, pcchQuery: ptr DWORD, ppwzQuery: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetQuery(self, pcchQuery, ppwzQuery) +proc GetSchemeName*(self: ptr IUriBuilder, pcchSchemeName: ptr DWORD, ppwzSchemeName: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSchemeName(self, pcchSchemeName, ppwzSchemeName) +proc GetUserName*(self: ptr IUriBuilder, pcchUserName: ptr DWORD, ppwzUserName: ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUserName(self, pcchUserName, ppwzUserName) +proc SetFragment*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFragment(self, pwzNewValue) +proc SetHost*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHost(self, pwzNewValue) +proc SetPassword*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPassword(self, pwzNewValue) +proc SetPath*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPath(self, pwzNewValue) +proc SetPort*(self: ptr IUriBuilder, fHasPort: WINBOOL, dwNewValue: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPort(self, fHasPort, dwNewValue) +proc SetQuery*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetQuery(self, pwzNewValue) +proc SetSchemeName*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSchemeName(self, pwzNewValue) +proc SetUserName*(self: ptr IUriBuilder, pwzNewValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetUserName(self, pwzNewValue) +proc RemoveProperties*(self: ptr IUriBuilder, dwPropertyMask: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveProperties(self, dwPropertyMask) +proc HasBeenModified*(self: ptr IUriBuilder, pfModified: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasBeenModified(self, pfModified) +proc CreateIUriBuilder*(self: ptr IUriBuilderFactory, dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: ptr ptr IUriBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateIUriBuilder(self, dwFlags, dwReserved, ppIUriBuilder) +proc CreateInitializedIUriBuilder*(self: ptr IUriBuilderFactory, dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: ptr ptr IUriBuilder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInitializedIUriBuilder(self, dwFlags, dwReserved, ppIUriBuilder) +proc mQueryOption*(self: ptr IWinInetInfo, dwOption: DWORD, pBuffer: LPVOID, pcbBuf: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryOption(self, dwOption, pBuffer, pcbBuf) +proc OnSecurityProblem*(self: ptr IHttpSecurity, dwProblem: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSecurityProblem(self, dwProblem) +proc QueryInfo*(self: ptr IWinInetHttpInfo, dwOption: DWORD, pBuffer: LPVOID, pcbBuf: ptr DWORD, pdwFlags: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryInfo(self, dwOption, pBuffer, pcbBuf, pdwFlags, pdwReserved) +proc GetRequestTimeouts*(self: ptr IWinInetHttpTimeouts, pdwConnectTimeout: ptr DWORD, pdwSendTimeout: ptr DWORD, pdwReceiveTimeout: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRequestTimeouts(self, pdwConnectTimeout, pdwSendTimeout, pdwReceiveTimeout) +proc SetCacheExtension*(self: ptr IWinInetCacheHints, pwzExt: LPCWSTR, pszCacheFile: LPVOID, pcbCacheFile: ptr DWORD, pdwWinInetError: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCacheExtension(self, pwzExt, pszCacheFile, pcbCacheFile, pdwWinInetError, pdwReserved) +proc SetCacheExtension2*(self: ptr IWinInetCacheHints2, pwzExt: LPCWSTR, pwzCacheFile: ptr WCHAR, pcchCacheFile: ptr DWORD, pdwWinInetError: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCacheExtension2(self, pwzExt, pwzCacheFile, pcchCacheFile, pdwWinInetError, pdwReserved) +proc CreateMoniker*(self: ptr IBindHost, szName: LPOLESTR, pBC: ptr IBindCtx, ppmk: ptr ptr IMoniker, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMoniker(self, szName, pBC, ppmk, dwReserved) +proc MonikerBindToStorage*(self: ptr IBindHost, pMk: ptr IMoniker, pBC: ptr IBindCtx, pBSC: ptr IBindStatusCallback, riid: REFIID, ppvObj: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MonikerBindToStorage(self, pMk, pBC, pBSC, riid, ppvObj) +proc MonikerBindToObject*(self: ptr IBindHost, pMk: ptr IMoniker, pBC: ptr IBindCtx, pBSC: ptr IBindStatusCallback, riid: REFIID, ppvObj: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MonikerBindToObject(self, pMk, pBC, pBSC, riid, ppvObj) +proc GetBindInfo*(self: ptr IInternetBindInfo, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindInfo(self, grfBINDF, pbindinfo) +proc GetBindString*(self: ptr IInternetBindInfo, ulStringType: ULONG, ppwzStr: ptr LPOLESTR, cEl: ULONG, pcElFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindString(self, ulStringType, ppwzStr, cEl, pcElFetched) +proc GetBindInfoEx*(self: ptr IInternetBindInfoEx, grfBINDF: ptr DWORD, pbindinfo: ptr BINDINFO, grfBINDF2: ptr DWORD, pdwReserved: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindInfoEx(self, grfBINDF, pbindinfo, grfBINDF2, pdwReserved) +proc Start*(self: ptr IInternetProtocolRoot, szUrl: LPCWSTR, pOIProtSink: ptr IInternetProtocolSink, pOIBindInfo: ptr IInternetBindInfo, grfPI: DWORD, dwReserved: HANDLE_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Start(self, szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved) +proc Continue*(self: ptr IInternetProtocolRoot, pProtocolData: ptr PROTOCOLDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Continue(self, pProtocolData) +proc Abort*(self: ptr IInternetProtocolRoot, hrReason: HRESULT, dwOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Abort(self, hrReason, dwOptions) +proc Terminate*(self: ptr IInternetProtocolRoot, dwOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Terminate(self, dwOptions) +proc Suspend*(self: ptr IInternetProtocolRoot): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Suspend(self) +proc Resume*(self: ptr IInternetProtocolRoot): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resume(self) +proc Read*(self: ptr IInternetProtocol, pv: pointer, cb: ULONG, pcbRead: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Read(self, pv, cb, pcbRead) +proc Seek*(self: ptr IInternetProtocol, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ptr ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Seek(self, dlibMove, dwOrigin, plibNewPosition) +proc LockRequest*(self: ptr IInternetProtocol, dwOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockRequest(self, dwOptions) +proc UnlockRequest*(self: ptr IInternetProtocol): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnlockRequest(self) +proc StartEx*(self: ptr IInternetProtocolEx, pUri: ptr IUri, pOIProtSink: ptr IInternetProtocolSink, pOIBindInfo: ptr IInternetBindInfo, grfPI: DWORD, dwReserved: HANDLE_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartEx(self, pUri, pOIProtSink, pOIBindInfo, grfPI, dwReserved) +proc Switch*(self: ptr IInternetProtocolSink, pProtocolData: ptr PROTOCOLDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Switch(self, pProtocolData) +proc ReportProgress*(self: ptr IInternetProtocolSink, ulStatusCode: ULONG, szStatusText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReportProgress(self, ulStatusCode, szStatusText) +proc ReportData*(self: ptr IInternetProtocolSink, grfBSCF: DWORD, ulProgress: ULONG, ulProgressMax: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReportData(self, grfBSCF, ulProgress, ulProgressMax) +proc ReportResult*(self: ptr IInternetProtocolSink, hrResult: HRESULT, dwError: DWORD, szResult: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReportResult(self, hrResult, dwError, szResult) +proc SwitchSink*(self: ptr IInternetProtocolSinkStackable, pOIProtSink: ptr IInternetProtocolSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SwitchSink(self, pOIProtSink) +proc CommitSwitch*(self: ptr IInternetProtocolSinkStackable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CommitSwitch(self) +proc RollbackSwitch*(self: ptr IInternetProtocolSinkStackable): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RollbackSwitch(self) +proc RegisterNameSpace*(self: ptr IInternetSession, pCF: ptr IClassFactory, rclsid: REFCLSID, pwzProtocol: LPCWSTR, cPatterns: ULONG, ppwzPatterns: ptr LPCWSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterNameSpace(self, pCF, rclsid, pwzProtocol, cPatterns, ppwzPatterns, dwReserved) +proc UnregisterNameSpace*(self: ptr IInternetSession, pCF: ptr IClassFactory, pszProtocol: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterNameSpace(self, pCF, pszProtocol) +proc RegisterMimeFilter*(self: ptr IInternetSession, pCF: ptr IClassFactory, rclsid: REFCLSID, pwzType: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterMimeFilter(self, pCF, rclsid, pwzType) +proc UnregisterMimeFilter*(self: ptr IInternetSession, pCF: ptr IClassFactory, pwzType: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterMimeFilter(self, pCF, pwzType) +proc CreateBinding*(self: ptr IInternetSession, pBC: LPBC, szUrl: LPCWSTR, pUnkOuter: ptr IUnknown, ppUnk: ptr ptr IUnknown, ppOInetProt: ptr ptr IInternetProtocol, dwOption: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBinding(self, pBC, szUrl, pUnkOuter, ppUnk, ppOInetProt, dwOption) +proc SetSessionOption*(self: ptr IInternetSession, dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSessionOption(self, dwOption, pBuffer, dwBufferLength, dwReserved) +proc GetSessionOption*(self: ptr IInternetSession, dwOption: DWORD, pBuffer: LPVOID, pdwBufferLength: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSessionOption(self, dwOption, pBuffer, pdwBufferLength, dwReserved) +proc Prepare*(self: ptr IInternetThreadSwitch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Prepare(self) +proc Continue*(self: ptr IInternetThreadSwitch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Continue(self) +proc SetPriority*(self: ptr IInternetPriority, nPriority: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPriority(self, nPriority) +proc GetPriority*(self: ptr IInternetPriority, pnPriority: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPriority(self, pnPriority) +proc ParseUrl*(self: ptr IInternetProtocolInfo, pwzUrl: LPCWSTR, ParseAction: PARSEACTION, dwParseFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseUrl(self, pwzUrl, ParseAction, dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved) +proc CombineUrl*(self: ptr IInternetProtocolInfo, pwzBaseUrl: LPCWSTR, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CombineUrl(self, pwzBaseUrl, pwzRelativeUrl, dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved) +proc CompareUrl*(self: ptr IInternetProtocolInfo, pwzUrl1: LPCWSTR, pwzUrl2: LPCWSTR, dwCompareFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareUrl(self, pwzUrl1, pwzUrl2, dwCompareFlags) +proc QueryInfo*(self: ptr IInternetProtocolInfo, pwzUrl: LPCWSTR, OueryOption: QUERYOPTION, dwQueryFlags: DWORD, pBuffer: LPVOID, cbBuffer: DWORD, pcbBuf: ptr DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryInfo(self, pwzUrl, OueryOption, dwQueryFlags, pBuffer, cbBuffer, pcbBuf, dwReserved) +proc GetWindow*(self: ptr IInternetSecurityMgrSite, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindow(self, phwnd) +proc EnableModeless*(self: ptr IInternetSecurityMgrSite, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc SetSecuritySite*(self: ptr IInternetSecurityManager, pSite: ptr IInternetSecurityMgrSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSecuritySite(self, pSite) +proc GetSecuritySite*(self: ptr IInternetSecurityManager, ppSite: ptr ptr IInternetSecurityMgrSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecuritySite(self, ppSite) +proc MapUrlToZone*(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, pdwZone: ptr DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapUrlToZone(self, pwszUrl, pdwZone, dwFlags) +proc GetSecurityId*(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecurityId(self, pwszUrl, pbSecurityId, pcbSecurityId, dwReserved) +proc ProcessUrlAction*(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessUrlAction(self, pwszUrl, dwAction, pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved) +proc QueryCustomPolicy*(self: ptr IInternetSecurityManager, pwszUrl: LPCWSTR, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCustomPolicy(self, pwszUrl, guidKey, ppPolicy, pcbPolicy, pContext, cbContext, dwReserved) +proc SetZoneMapping*(self: ptr IInternetSecurityManager, dwZone: DWORD, lpszPattern: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetZoneMapping(self, dwZone, lpszPattern, dwFlags) +proc GetZoneMappings*(self: ptr IInternetSecurityManager, dwZone: DWORD, ppenumString: ptr ptr IEnumString, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneMappings(self, dwZone, ppenumString, dwFlags) +proc ProcessUrlActionEx*(self: ptr IInternetSecurityManagerEx, pwszUrl: LPCWSTR, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD, pdwOutFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessUrlActionEx(self, pwszUrl, dwAction, pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved, pdwOutFlags) +proc MapUrlToZoneEx2*(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, pdwZone: ptr DWORD, dwFlags: DWORD, ppwszMappedUrl: ptr LPWSTR, pdwOutFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapUrlToZoneEx2(self, pUri, pdwZone, dwFlags, ppwszMappedUrl, pdwOutFlags) +proc ProcessUrlActionEx2*(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD_PTR, pdwOutFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessUrlActionEx2(self, pUri, dwAction, pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved, pdwOutFlags) +proc GetSecurityIdEx2*(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecurityIdEx2(self, pUri, pbSecurityId, pcbSecurityId, dwReserved) +proc QueryCustomPolicyEx2*(self: ptr IInternetSecurityManagerEx2, pUri: ptr IUri, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCustomPolicyEx2(self, pUri, guidKey, ppPolicy, pcbPolicy, pContext, cbContext, dwReserved) +proc GetId*(self: ptr IZoneIdentifier, pdwZone: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetId(self, pdwZone) +proc SetId*(self: ptr IZoneIdentifier, dwZone: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetId(self, dwZone) +proc Remove*(self: ptr IZoneIdentifier): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Remove(self) +proc GetSecurityId*(self: ptr IInternetHostSecurityManager, pbSecurityId: ptr BYTE, pcbSecurityId: ptr DWORD, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSecurityId(self, pbSecurityId, pcbSecurityId, dwReserved) +proc ProcessUrlAction*(self: ptr IInternetHostSecurityManager, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, pContext: ptr BYTE, cbContext: DWORD, dwFlags: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessUrlAction(self, dwAction, pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved) +proc QueryCustomPolicy*(self: ptr IInternetHostSecurityManager, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, pContext: ptr BYTE, cbContext: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCustomPolicy(self, guidKey, ppPolicy, pcbPolicy, pContext, cbContext, dwReserved) +proc GetZoneAttributes*(self: ptr IInternetZoneManager, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneAttributes(self, dwZone, pZoneAttributes) +proc SetZoneAttributes*(self: ptr IInternetZoneManager, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetZoneAttributes(self, dwZone, pZoneAttributes) +proc GetZoneCustomPolicy*(self: ptr IInternetZoneManager, dwZone: DWORD, guidKey: REFGUID, ppPolicy: ptr ptr BYTE, pcbPolicy: ptr DWORD, urlZoneReg: URLZONEREG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneCustomPolicy(self, dwZone, guidKey, ppPolicy, pcbPolicy, urlZoneReg) +proc SetZoneCustomPolicy*(self: ptr IInternetZoneManager, dwZone: DWORD, guidKey: REFGUID, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetZoneCustomPolicy(self, dwZone, guidKey, pPolicy, cbPolicy, urlZoneReg) +proc GetZoneActionPolicy*(self: ptr IInternetZoneManager, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneActionPolicy(self, dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg) +proc SetZoneActionPolicy*(self: ptr IInternetZoneManager, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetZoneActionPolicy(self, dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg) +proc PromptAction*(self: ptr IInternetZoneManager, dwAction: DWORD, hwndParent: HWND, pwszUrl: LPCWSTR, pwszText: LPCWSTR, dwPromptFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PromptAction(self, dwAction, hwndParent, pwszUrl, pwszText, dwPromptFlags) +proc LogAction*(self: ptr IInternetZoneManager, dwAction: DWORD, pwszUrl: LPCWSTR, pwszText: LPCWSTR, dwLogFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LogAction(self, dwAction, pwszUrl, pwszText, dwLogFlags) +proc CreateZoneEnumerator*(self: ptr IInternetZoneManager, pdwEnum: ptr DWORD, pdwCount: ptr DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateZoneEnumerator(self, pdwEnum, pdwCount, dwFlags) +proc GetZoneAt*(self: ptr IInternetZoneManager, dwEnum: DWORD, dwIndex: DWORD, pdwZone: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneAt(self, dwEnum, dwIndex, pdwZone) +proc DestroyZoneEnumerator*(self: ptr IInternetZoneManager, dwEnum: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyZoneEnumerator(self, dwEnum) +proc CopyTemplatePoliciesToZone*(self: ptr IInternetZoneManager, dwTemplate: DWORD, dwZone: DWORD, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyTemplatePoliciesToZone(self, dwTemplate, dwZone, dwReserved) +proc GetZoneActionPolicyEx*(self: ptr IInternetZoneManagerEx, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneActionPolicyEx(self, dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg, dwFlags) +proc SetZoneActionPolicyEx*(self: ptr IInternetZoneManagerEx, dwZone: DWORD, dwAction: DWORD, pPolicy: ptr BYTE, cbPolicy: DWORD, urlZoneReg: URLZONEREG, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetZoneActionPolicyEx(self, dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg, dwFlags) +proc GetZoneAttributesEx*(self: ptr IInternetZoneManagerEx2, dwZone: DWORD, pZoneAttributes: ptr ZONEATTRIBUTES, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneAttributesEx(self, dwZone, pZoneAttributes, dwFlags) +proc GetZoneSecurityState*(self: ptr IInternetZoneManagerEx2, dwZoneIndex: DWORD, fRespectPolicy: WINBOOL, pdwState: LPDWORD, pfPolicyEncountered: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetZoneSecurityState(self, dwZoneIndex, fRespectPolicy, pdwState, pfPolicyEncountered) +proc GetIESecurityState*(self: ptr IInternetZoneManagerEx2, fRespectPolicy: WINBOOL, pdwState: LPDWORD, pfPolicyEncountered: ptr WINBOOL, fNoCache: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIESecurityState(self, fRespectPolicy, pdwState, pfPolicyEncountered, fNoCache) +proc FixUnsecureSettings*(self: ptr IInternetZoneManagerEx2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FixUnsecureSettings(self) +proc ProcessSoftDist*(self: ptr ISoftDistExt, szCDFURL: LPCWSTR, pSoftDistElement: ptr IXMLElement, lpsdi: LPSOFTDISTINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessSoftDist(self, szCDFURL, pSoftDistElement, lpsdi) +proc GetFirstCodeBase*(self: ptr ISoftDistExt, szCodeBase: ptr LPWSTR, dwMaxSize: LPDWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFirstCodeBase(self, szCodeBase, dwMaxSize) +proc GetNextCodeBase*(self: ptr ISoftDistExt, szCodeBase: ptr LPWSTR, dwMaxSize: LPDWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextCodeBase(self, szCodeBase, dwMaxSize) +proc AsyncInstallDistributionUnit*(self: ptr ISoftDistExt, pbc: ptr IBindCtx, pvReserved: LPVOID, flags: DWORD, lpcbh: LPCODEBASEHOLD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AsyncInstallDistributionUnit(self, pbc, pvReserved, flags, lpcbh) +proc GetCatalogFile*(self: ptr ICatalogFileInfo, ppszCatalogFile: ptr LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCatalogFile(self, ppszCatalogFile) +proc GetJavaTrust*(self: ptr ICatalogFileInfo, ppJavaTrust: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetJavaTrust(self, ppJavaTrust) +proc DoEncode*(self: ptr IDataFilter, dwFlags: DWORD, lInBufferSize: LONG, pbInBuffer: ptr BYTE, lOutBufferSize: LONG, pbOutBuffer: ptr BYTE, lInBytesAvailable: LONG, plInBytesRead: ptr LONG, plOutBytesWritten: ptr LONG, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoEncode(self, dwFlags, lInBufferSize, pbInBuffer, lOutBufferSize, pbOutBuffer, lInBytesAvailable, plInBytesRead, plOutBytesWritten, dwReserved) +proc DoDecode*(self: ptr IDataFilter, dwFlags: DWORD, lInBufferSize: LONG, pbInBuffer: ptr BYTE, lOutBufferSize: LONG, pbOutBuffer: ptr BYTE, lInBytesAvailable: LONG, plInBytesRead: ptr LONG, plOutBytesWritten: ptr LONG, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoDecode(self, dwFlags, lInBufferSize, pbInBuffer, lOutBufferSize, pbOutBuffer, lInBytesAvailable, plInBytesRead, plOutBytesWritten, dwReserved) +proc SetEncodingLevel*(self: ptr IDataFilter, dwEncLevel: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEncodingLevel(self, dwEncLevel) +proc FindBestFilter*(self: ptr IEncodingFilterFactory, pwzCodeIn: LPCWSTR, pwzCodeOut: LPCWSTR, info: DATAINFO, ppDF: ptr ptr IDataFilter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindBestFilter(self, pwzCodeIn, pwzCodeOut, info, ppDF) +proc GetDefaultFilter*(self: ptr IEncodingFilterFactory, pwzCodeIn: LPCWSTR, pwzCodeOut: LPCWSTR, ppDF: ptr ptr IDataFilter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultFilter(self, pwzCodeIn, pwzCodeOut, ppDF) +proc GetWrapperCode*(self: ptr IWrappedProtocol, pnCode: ptr LONG, dwReserved: DWORD_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWrapperCode(self, pnCode, dwReserved) +proc GetBindHandle*(self: ptr IGetBindHandle, enumRequestedHandle: BINDHANDLETYPES, pRetHandle: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBindHandle(self, enumRequestedHandle, pRetHandle) +proc Redirect*(self: ptr IBindCallbackRedirect, lpcUrl: LPCWSTR, vbCancel: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Redirect(self, lpcUrl, vbCancel) +proc ReadMultiple*(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgpropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadMultiple(self, cpspec, rgpspec, rgpropvar) +proc WriteMultiple*(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgpropvar: ptr PROPVARIANT, propidNameFirst: PROPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteMultiple(self, cpspec, rgpspec, rgpropvar, propidNameFirst) +proc DeleteMultiple*(self: ptr IPropertyStorage, cpspec: ULONG, rgpspec: ptr PROPSPEC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteMultiple(self, cpspec, rgpspec) +proc ReadPropertyNames*(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID, rglpwstrName: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadPropertyNames(self, cpropid, rgpropid, rglpwstrName) +proc WritePropertyNames*(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID, rglpwstrName: ptr LPOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WritePropertyNames(self, cpropid, rgpropid, rglpwstrName) +proc DeletePropertyNames*(self: ptr IPropertyStorage, cpropid: ULONG, rgpropid: ptr PROPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeletePropertyNames(self, cpropid, rgpropid) +proc Commit*(self: ptr IPropertyStorage, grfCommitFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self, grfCommitFlags) +proc Revert*(self: ptr IPropertyStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Revert(self) +proc Enum*(self: ptr IPropertyStorage, ppenum: ptr ptr IEnumSTATPROPSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enum(self, ppenum) +proc SetTimes*(self: ptr IPropertyStorage, pctime: ptr FILETIME, patime: ptr FILETIME, pmtime: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTimes(self, pctime, patime, pmtime) +proc SetClass*(self: ptr IPropertyStorage, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClass(self, clsid) +proc Stat*(self: ptr IPropertyStorage, pstatpsstg: ptr STATPROPSETSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stat(self, pstatpsstg) +proc Create*(self: ptr IPropertySetStorage, rfmtid: REFFMTID, pclsid: ptr CLSID, grfFlags: DWORD, grfMode: DWORD, ppprstg: ptr ptr IPropertyStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Create(self, rfmtid, pclsid, grfFlags, grfMode, ppprstg) +proc Open*(self: ptr IPropertySetStorage, rfmtid: REFFMTID, grfMode: DWORD, ppprstg: ptr ptr IPropertyStorage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, rfmtid, grfMode, ppprstg) +proc mDelete*(self: ptr IPropertySetStorage, rfmtid: REFFMTID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Delete(self, rfmtid) +proc Enum*(self: ptr IPropertySetStorage, ppenum: ptr ptr IEnumSTATPROPSETSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enum(self, ppenum) +proc Next*(self: ptr IEnumSTATPROPSTG, celt: ULONG, rgelt: ptr STATPROPSTG, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumSTATPROPSTG, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumSTATPROPSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumSTATPROPSTG, ppenum: ptr ptr IEnumSTATPROPSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumSTATPROPSETSTG, celt: ULONG, rgelt: ptr STATPROPSETSTG, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumSTATPROPSETSTG, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumSTATPROPSETSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumSTATPROPSETSTG, ppenum: ptr ptr IEnumSTATPROPSETSTG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumConnections, cConnections: ULONG, rgcd: LPCONNECTDATA, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, cConnections, rgcd, pcFetched) +proc Skip*(self: ptr IEnumConnections, cConnections: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, cConnections) +proc Reset*(self: ptr IEnumConnections): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumConnections, ppEnum: ptr ptr IEnumConnections): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc GetConnectionInterface*(self: ptr IConnectionPoint, pIID: ptr IID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConnectionInterface(self, pIID) +proc GetConnectionPointContainer*(self: ptr IConnectionPoint, ppCPC: ptr ptr IConnectionPointContainer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConnectionPointContainer(self, ppCPC) +proc Advise*(self: ptr IConnectionPoint, pUnkSink: ptr IUnknown, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pUnkSink, pdwCookie) +proc Unadvise*(self: ptr IConnectionPoint, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc EnumConnections*(self: ptr IConnectionPoint, ppEnum: ptr ptr IEnumConnections): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumConnections(self, ppEnum) +proc Next*(self: ptr IEnumConnectionPoints, cConnections: ULONG, ppCP: ptr LPCONNECTIONPOINT, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, cConnections, ppCP, pcFetched) +proc Skip*(self: ptr IEnumConnectionPoints, cConnections: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, cConnections) +proc Reset*(self: ptr IEnumConnectionPoints): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumConnectionPoints, ppEnum: ptr ptr IEnumConnectionPoints): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc EnumConnectionPoints*(self: ptr IConnectionPointContainer, ppEnum: ptr ptr IEnumConnectionPoints): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumConnectionPoints(self, ppEnum) +proc FindConnectionPoint*(self: ptr IConnectionPointContainer, riid: REFIID, ppCP: ptr ptr IConnectionPoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindConnectionPoint(self, riid, ppCP) +proc GetLicInfo*(self: ptr IClassFactory2, pLicInfo: ptr LICINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLicInfo(self, pLicInfo) +proc RequestLicKey*(self: ptr IClassFactory2, dwReserved: DWORD, pBstrKey: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestLicKey(self, dwReserved, pBstrKey) +proc CreateInstanceLic*(self: ptr IClassFactory2, pUnkOuter: ptr IUnknown, pUnkReserved: ptr IUnknown, riid: REFIID, bstrKey: BSTR, ppvObj: ptr PVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstanceLic(self, pUnkOuter, pUnkReserved, riid, bstrKey, ppvObj) +proc GetClassInfo*(self: ptr IProvideClassInfo, ppTI: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClassInfo(self, ppTI) +proc GetGUID*(self: ptr IProvideClassInfo2, dwGuidKind: DWORD, pGUID: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGUID(self, dwGuidKind, pGUID) +proc GetMultiTypeInfoCount*(self: ptr IProvideMultipleClassInfo, pcti: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMultiTypeInfoCount(self, pcti) +proc GetInfoOfIndex*(self: ptr IProvideMultipleClassInfo, iti: ULONG, dwFlags: DWORD, pptiCoClass: ptr ptr ITypeInfo, pdwTIFlags: ptr DWORD, pcdispidReserved: ptr ULONG, piidPrimary: ptr IID, piidSource: ptr IID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInfoOfIndex(self, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource) +proc GetControlInfo*(self: ptr IOleControl, pCI: ptr CONTROLINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlInfo(self, pCI) +proc OnMnemonic*(self: ptr IOleControl, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnMnemonic(self, pMsg) +proc OnAmbientPropertyChange*(self: ptr IOleControl, dispID: DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnAmbientPropertyChange(self, dispID) +proc FreezeEvents*(self: ptr IOleControl, bFreeze: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FreezeEvents(self, bFreeze) +proc OnControlInfoChanged*(self: ptr IOleControlSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnControlInfoChanged(self) +proc LockInPlaceActive*(self: ptr IOleControlSite, fLock: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LockInPlaceActive(self, fLock) +proc GetExtendedControl*(self: ptr IOleControlSite, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtendedControl(self, ppDisp) +proc TransformCoords*(self: ptr IOleControlSite, pPtlHimetric: ptr POINTL, pPtfContainer: ptr POINTF, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TransformCoords(self, pPtlHimetric, pPtfContainer, dwFlags) +proc TranslateAccelerator*(self: ptr IOleControlSite, pMsg: ptr MSG, grfModifiers: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pMsg, grfModifiers) +proc OnFocus*(self: ptr IOleControlSite, fGotFocus: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFocus(self, fGotFocus) +proc ShowPropertyFrame*(self: ptr IOleControlSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowPropertyFrame(self) +proc SetPageSite*(self: ptr IPropertyPage, pPageSite: ptr IPropertyPageSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPageSite(self, pPageSite) +proc Activate*(self: ptr IPropertyPage, hWndParent: HWND, pRect: LPCRECT, bModal: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Activate(self, hWndParent, pRect, bModal) +proc Deactivate*(self: ptr IPropertyPage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Deactivate(self) +proc GetPageInfo*(self: ptr IPropertyPage, pPageInfo: ptr PROPPAGEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPageInfo(self, pPageInfo) +proc SetObjects*(self: ptr IPropertyPage, cObjects: ULONG, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetObjects(self, cObjects, ppUnk) +proc Show*(self: ptr IPropertyPage, nCmdShow: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, nCmdShow) +proc Move*(self: ptr IPropertyPage, pRect: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, pRect) +proc IsPageDirty*(self: ptr IPropertyPage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsPageDirty(self) +proc Apply*(self: ptr IPropertyPage): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Apply(self) +proc Help*(self: ptr IPropertyPage, pszHelpDir: LPCOLESTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Help(self, pszHelpDir) +proc TranslateAccelerator*(self: ptr IPropertyPage, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pMsg) +proc EditProperty*(self: ptr IPropertyPage2, dispID: DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EditProperty(self, dispID) +proc OnStatusChange*(self: ptr IPropertyPageSite, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStatusChange(self, dwFlags) +proc GetLocaleID*(self: ptr IPropertyPageSite, pLocaleID: ptr LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLocaleID(self, pLocaleID) +proc GetPageContainer*(self: ptr IPropertyPageSite, ppUnk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPageContainer(self, ppUnk) +proc TranslateAccelerator*(self: ptr IPropertyPageSite, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pMsg) +proc OnChanged*(self: ptr IPropertyNotifySink, dispID: DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnChanged(self, dispID) +proc OnRequestEdit*(self: ptr IPropertyNotifySink, dispID: DISPID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnRequestEdit(self, dispID) +proc GetPages*(self: ptr ISpecifyPropertyPages, pPages: ptr CAUUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPages(self, pPages) +proc IsDirty*(self: ptr IPersistMemory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc Load*(self: ptr IPersistMemory, pMem: LPVOID, cbSize: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pMem, cbSize) +proc Save*(self: ptr IPersistMemory, pMem: LPVOID, fClearDirty: WINBOOL, cbSize: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pMem, fClearDirty, cbSize) +proc GetSizeMax*(self: ptr IPersistMemory, pCbSize: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSizeMax(self, pCbSize) +proc InitNew*(self: ptr IPersistMemory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc IsDirty*(self: ptr IPersistStreamInit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc Load*(self: ptr IPersistStreamInit, pStm: LPSTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pStm) +proc Save*(self: ptr IPersistStreamInit, pStm: LPSTREAM, fClearDirty: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pStm, fClearDirty) +proc GetSizeMax*(self: ptr IPersistStreamInit, pCbSize: ptr ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSizeMax(self, pCbSize) +proc InitNew*(self: ptr IPersistStreamInit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc InitNew*(self: ptr IPersistPropertyBag): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc Load*(self: ptr IPersistPropertyBag, pPropBag: ptr IPropertyBag, pErrorLog: ptr IErrorLog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pPropBag, pErrorLog) +proc Save*(self: ptr IPersistPropertyBag, pPropBag: ptr IPropertyBag, fClearDirty: WINBOOL, fSaveAllProperties: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pPropBag, fClearDirty, fSaveAllProperties) +proc PreMessageFilter*(self: ptr ISimpleFrameSite, hWnd: HWND, msg: UINT, wp: WPARAM, lp: LPARAM, plResult: ptr LRESULT, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreMessageFilter(self, hWnd, msg, wp, lp, plResult, pdwCookie) +proc PostMessageFilter*(self: ptr ISimpleFrameSite, hWnd: HWND, msg: UINT, wp: WPARAM, lp: LPARAM, plResult: ptr LRESULT, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostMessageFilter(self, hWnd, msg, wp, lp, plResult, dwCookie) +proc get_Name*(self: ptr IFont, pName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, pName) +proc put_Name*(self: ptr IFont, name: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Name(self, name) +proc get_Size*(self: ptr IFont, pSize: ptr CY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Size(self, pSize) +proc put_Size*(self: ptr IFont, size: CY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Size(self, size) +proc get_Bold*(self: ptr IFont, pBold: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Bold(self, pBold) +proc put_Bold*(self: ptr IFont, bold: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Bold(self, bold) +proc get_Italic*(self: ptr IFont, pItalic: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Italic(self, pItalic) +proc put_Italic*(self: ptr IFont, italic: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Italic(self, italic) +proc get_Underline*(self: ptr IFont, pUnderline: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Underline(self, pUnderline) +proc put_Underline*(self: ptr IFont, underline: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Underline(self, underline) +proc get_Strikethrough*(self: ptr IFont, pStrikethrough: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Strikethrough(self, pStrikethrough) +proc put_Strikethrough*(self: ptr IFont, strikethrough: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Strikethrough(self, strikethrough) +proc get_Weight*(self: ptr IFont, pWeight: ptr SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Weight(self, pWeight) +proc put_Weight*(self: ptr IFont, weight: SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Weight(self, weight) +proc get_Charset*(self: ptr IFont, pCharset: ptr SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Charset(self, pCharset) +proc put_Charset*(self: ptr IFont, charset: SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Charset(self, charset) +proc get_hFont*(self: ptr IFont, phFont: ptr HFONT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hFont(self, phFont) +proc Clone*(self: ptr IFont, ppFont: ptr ptr IFont): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppFont) +proc IsEqual*(self: ptr IFont, pFontOther: ptr IFont): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEqual(self, pFontOther) +proc SetRatio*(self: ptr IFont, cyLogical: LONG, cyHimetric: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRatio(self, cyLogical, cyHimetric) +proc QueryTextMetrics*(self: ptr IFont, pTM: ptr TEXTMETRICOLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryTextMetrics(self, pTM) +proc AddRefHfont*(self: ptr IFont, hFont: HFONT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddRefHfont(self, hFont) +proc ReleaseHfont*(self: ptr IFont, hFont: HFONT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseHfont(self, hFont) +proc SetHdc*(self: ptr IFont, hDC: HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHdc(self, hDC) +proc get_Handle*(self: ptr IPicture, pHandle: ptr OLE_HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Handle(self, pHandle) +proc get_hPal*(self: ptr IPicture, phPal: ptr OLE_HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hPal(self, phPal) +proc get_Type*(self: ptr IPicture, pType: ptr SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Type(self, pType) +proc get_Width*(self: ptr IPicture, pWidth: ptr OLE_XSIZE_HIMETRIC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Width(self, pWidth) +proc get_Height*(self: ptr IPicture, pHeight: ptr OLE_YSIZE_HIMETRIC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Height(self, pHeight) +proc Render*(self: ptr IPicture, hDC: HDC, x: LONG, y: LONG, cx: LONG, cy: LONG, xSrc: OLE_XPOS_HIMETRIC, ySrc: OLE_YPOS_HIMETRIC, cxSrc: OLE_XSIZE_HIMETRIC, cySrc: OLE_YSIZE_HIMETRIC, pRcWBounds: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Render(self, hDC, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, pRcWBounds) +proc set_hPal*(self: ptr IPicture, hPal: OLE_HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.set_hPal(self, hPal) +proc get_CurDC*(self: ptr IPicture, phDC: ptr HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurDC(self, phDC) +proc SelectPicture*(self: ptr IPicture, hDCIn: HDC, phDCOut: ptr HDC, phBmpOut: ptr OLE_HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectPicture(self, hDCIn, phDCOut, phBmpOut) +proc get_KeepOriginalFormat*(self: ptr IPicture, pKeep: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_KeepOriginalFormat(self, pKeep) +proc put_KeepOriginalFormat*(self: ptr IPicture, keep: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_KeepOriginalFormat(self, keep) +proc PictureChanged*(self: ptr IPicture): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PictureChanged(self) +proc SaveAsFile*(self: ptr IPicture, pStream: LPSTREAM, fSaveMemCopy: WINBOOL, pCbSize: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveAsFile(self, pStream, fSaveMemCopy, pCbSize) +proc get_Attributes*(self: ptr IPicture, pDwAttr: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Attributes(self, pDwAttr) +proc get_Handle*(self: ptr IPicture2, pHandle: ptr HHANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Handle(self, pHandle) +proc get_hPal*(self: ptr IPicture2, phPal: ptr HHANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_hPal(self, phPal) +proc get_Type*(self: ptr IPicture2, pType: ptr SHORT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Type(self, pType) +proc get_Width*(self: ptr IPicture2, pWidth: ptr OLE_XSIZE_HIMETRIC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Width(self, pWidth) +proc get_Height*(self: ptr IPicture2, pHeight: ptr OLE_YSIZE_HIMETRIC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Height(self, pHeight) +proc Render*(self: ptr IPicture2, hDC: HDC, x: LONG, y: LONG, cx: LONG, cy: LONG, xSrc: OLE_XPOS_HIMETRIC, ySrc: OLE_YPOS_HIMETRIC, cxSrc: OLE_XSIZE_HIMETRIC, cySrc: OLE_YSIZE_HIMETRIC, pRcWBounds: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Render(self, hDC, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, pRcWBounds) +proc set_hPal*(self: ptr IPicture2, hPal: HHANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.set_hPal(self, hPal) +proc get_CurDC*(self: ptr IPicture2, phDC: ptr HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurDC(self, phDC) +proc SelectPicture*(self: ptr IPicture2, hDCIn: HDC, phDCOut: ptr HDC, phBmpOut: ptr HHANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectPicture(self, hDCIn, phDCOut, phBmpOut) +proc get_KeepOriginalFormat*(self: ptr IPicture2, pKeep: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_KeepOriginalFormat(self, pKeep) +proc put_KeepOriginalFormat*(self: ptr IPicture2, keep: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_KeepOriginalFormat(self, keep) +proc PictureChanged*(self: ptr IPicture2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PictureChanged(self) +proc SaveAsFile*(self: ptr IPicture2, pStream: LPSTREAM, fSaveMemCopy: WINBOOL, pCbSize: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveAsFile(self, pStream, fSaveMemCopy, pCbSize) +proc get_Attributes*(self: ptr IPicture2, pDwAttr: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Attributes(self, pDwAttr) +proc OnWindowMessage*(self: ptr IOleInPlaceObjectWindowless, msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnWindowMessage(self, msg, wParam, lParam, plResult) +proc GetDropTarget*(self: ptr IOleInPlaceObjectWindowless, ppDropTarget: ptr ptr IDropTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDropTarget(self, ppDropTarget) +proc OnInPlaceActivateEx*(self: ptr IOleInPlaceSiteEx, pfNoRedraw: ptr WINBOOL, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInPlaceActivateEx(self, pfNoRedraw, dwFlags) +proc OnInPlaceDeactivateEx*(self: ptr IOleInPlaceSiteEx, fNoRedraw: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInPlaceDeactivateEx(self, fNoRedraw) +proc RequestUIActivate*(self: ptr IOleInPlaceSiteEx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestUIActivate(self) +proc CanWindowlessActivate*(self: ptr IOleInPlaceSiteWindowless): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanWindowlessActivate(self) +proc GetCapture*(self: ptr IOleInPlaceSiteWindowless): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCapture(self) +proc SetCapture*(self: ptr IOleInPlaceSiteWindowless, fCapture: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCapture(self, fCapture) +proc GetFocus*(self: ptr IOleInPlaceSiteWindowless): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocus(self) +proc SetFocus*(self: ptr IOleInPlaceSiteWindowless, fFocus: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFocus(self, fFocus) +proc GetDC*(self: ptr IOleInPlaceSiteWindowless, pRect: LPCRECT, grfFlags: DWORD, phDC: ptr HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDC(self, pRect, grfFlags, phDC) +proc ReleaseDC*(self: ptr IOleInPlaceSiteWindowless, hDC: HDC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseDC(self, hDC) +proc InvalidateRect*(self: ptr IOleInPlaceSiteWindowless, pRect: LPCRECT, fErase: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateRect(self, pRect, fErase) +proc InvalidateRgn*(self: ptr IOleInPlaceSiteWindowless, hRGN: HRGN, fErase: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateRgn(self, hRGN, fErase) +proc ScrollRect*(self: ptr IOleInPlaceSiteWindowless, dx: INT, dy: INT, pRectScroll: LPCRECT, pRectClip: LPCRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollRect(self, dx, dy, pRectScroll, pRectClip) +proc AdjustRect*(self: ptr IOleInPlaceSiteWindowless, prc: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AdjustRect(self, prc) +proc OnDefWindowMessage*(self: ptr IOleInPlaceSiteWindowless, msg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDefWindowMessage(self, msg, wParam, lParam, plResult) +proc GetRect*(self: ptr IViewObjectEx, dwAspect: DWORD, pRect: LPRECTL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRect(self, dwAspect, pRect) +proc GetViewStatus*(self: ptr IViewObjectEx, pdwStatus: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewStatus(self, pdwStatus) +proc QueryHitPoint*(self: ptr IViewObjectEx, dwAspect: DWORD, pRectBounds: LPCRECT, ptlLoc: POINT, lCloseHint: LONG, pHitResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryHitPoint(self, dwAspect, pRectBounds, ptlLoc, lCloseHint, pHitResult) +proc QueryHitRect*(self: ptr IViewObjectEx, dwAspect: DWORD, pRectBounds: LPCRECT, pRectLoc: LPCRECT, lCloseHint: LONG, pHitResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryHitRect(self, dwAspect, pRectBounds, pRectLoc, lCloseHint, pHitResult) +proc GetNaturalExtent*(self: ptr IViewObjectEx, dwAspect: DWORD, lindex: LONG, ptd: ptr DVTARGETDEVICE, hicTargetDev: HDC, pExtentInfo: ptr DVEXTENTINFO, pSizel: LPSIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNaturalExtent(self, dwAspect, lindex, ptd, hicTargetDev, pExtentInfo, pSizel) +proc Do*(self: ptr IOleUndoUnit, pUndoManager: ptr IOleUndoManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Do(self, pUndoManager) +proc GetDescription*(self: ptr IOleUndoUnit, pBstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pBstr) +proc GetUnitType*(self: ptr IOleUndoUnit, pClsid: ptr CLSID, plID: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUnitType(self, pClsid, plID) +proc OnNextAdd*(self: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnNextAdd(self) +proc Open*(self: ptr IOleParentUndoUnit, pPUU: ptr IOleParentUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, pPUU) +proc Close*(self: ptr IOleParentUndoUnit, pPUU: ptr IOleParentUndoUnit, fCommit: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self, pPUU, fCommit) +proc Add*(self: ptr IOleParentUndoUnit, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Add(self, pUU) +proc FindUnit*(self: ptr IOleParentUndoUnit, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindUnit(self, pUU) +proc GetParentState*(self: ptr IOleParentUndoUnit, pdwState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParentState(self, pdwState) +proc Next*(self: ptr IEnumOleUndoUnits, cElt: ULONG, rgElt: ptr ptr IOleUndoUnit, pcEltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, cElt, rgElt, pcEltFetched) +proc Skip*(self: ptr IEnumOleUndoUnits, cElt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, cElt) +proc Reset*(self: ptr IEnumOleUndoUnits): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumOleUndoUnits, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Open*(self: ptr IOleUndoManager, pPUU: ptr IOleParentUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, pPUU) +proc Close*(self: ptr IOleUndoManager, pPUU: ptr IOleParentUndoUnit, fCommit: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self, pPUU, fCommit) +proc Add*(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Add(self, pUU) +proc GetOpenParentState*(self: ptr IOleUndoManager, pdwState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOpenParentState(self, pdwState) +proc DiscardFrom*(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DiscardFrom(self, pUU) +proc UndoTo*(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UndoTo(self, pUU) +proc RedoTo*(self: ptr IOleUndoManager, pUU: ptr IOleUndoUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RedoTo(self, pUU) +proc EnumUndoable*(self: ptr IOleUndoManager, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumUndoable(self, ppEnum) +proc EnumRedoable*(self: ptr IOleUndoManager, ppEnum: ptr ptr IEnumOleUndoUnits): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumRedoable(self, ppEnum) +proc GetLastUndoDescription*(self: ptr IOleUndoManager, pBstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastUndoDescription(self, pBstr) +proc GetLastRedoDescription*(self: ptr IOleUndoManager, pBstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastRedoDescription(self, pBstr) +proc Enable*(self: ptr IOleUndoManager, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enable(self, fEnable) +proc GetActivationPolicy*(self: ptr IPointerInactive, pdwPolicy: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetActivationPolicy(self, pdwPolicy) +proc OnInactiveMouseMove*(self: ptr IPointerInactive, pRectBounds: LPCRECT, x: LONG, y: LONG, grfKeyState: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInactiveMouseMove(self, pRectBounds, x, y, grfKeyState) +proc OnInactiveSetCursor*(self: ptr IPointerInactive, pRectBounds: LPCRECT, x: LONG, y: LONG, dwMouseMsg: DWORD, fSetAlways: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnInactiveSetCursor(self, pRectBounds, x, y, dwMouseMsg, fSetAlways) +proc SetSite*(self: ptr IObjectWithSite, pUnkSite: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSite(self, pUnkSite) +proc GetSite*(self: ptr IObjectWithSite, riid: REFIID, ppvSite: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSite(self, riid, ppvSite) +proc GetDisplayString*(self: ptr IPerPropertyBrowsing, dispID: DISPID, pBstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayString(self, dispID, pBstr) +proc MapPropertyToPage*(self: ptr IPerPropertyBrowsing, dispID: DISPID, pClsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapPropertyToPage(self, dispID, pClsid) +proc GetPredefinedStrings*(self: ptr IPerPropertyBrowsing, dispID: DISPID, pCaStringsOut: ptr CALPOLESTR, pCaCookiesOut: ptr CADWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPredefinedStrings(self, dispID, pCaStringsOut, pCaCookiesOut) +proc GetPredefinedValue*(self: ptr IPerPropertyBrowsing, dispID: DISPID, dwCookie: DWORD, pVarOut: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPredefinedValue(self, dispID, dwCookie, pVarOut) +proc Read*(self: ptr IPropertyBag2, cProperties: ULONG, pPropBag: ptr PROPBAG2, pErrLog: ptr IErrorLog, pvarValue: ptr VARIANT, phrError: ptr HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Read(self, cProperties, pPropBag, pErrLog, pvarValue, phrError) +proc Write*(self: ptr IPropertyBag2, cProperties: ULONG, pPropBag: ptr PROPBAG2, pvarValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Write(self, cProperties, pPropBag, pvarValue) +proc CountProperties*(self: ptr IPropertyBag2, pcProperties: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CountProperties(self, pcProperties) +proc GetPropertyInfo*(self: ptr IPropertyBag2, iProperty: ULONG, cProperties: ULONG, pPropBag: ptr PROPBAG2, pcProperties: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyInfo(self, iProperty, cProperties, pPropBag, pcProperties) +proc LoadObject*(self: ptr IPropertyBag2, pstrName: LPCOLESTR, dwHint: DWORD, pUnkObject: ptr IUnknown, pErrLog: ptr IErrorLog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadObject(self, pstrName, dwHint, pUnkObject, pErrLog) +proc InitNew*(self: ptr IPersistPropertyBag2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc Load*(self: ptr IPersistPropertyBag2, pPropBag: ptr IPropertyBag2, pErrLog: ptr IErrorLog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Load(self, pPropBag, pErrLog) +proc Save*(self: ptr IPersistPropertyBag2, pPropBag: ptr IPropertyBag2, fClearDirty: WINBOOL, fSaveAllProperties: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, pPropBag, fClearDirty, fSaveAllProperties) +proc IsDirty*(self: ptr IPersistPropertyBag2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDirty(self) +proc OnViewStatusChange*(self: ptr IAdviseSinkEx, dwViewStatus: DWORD): void {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnViewStatusChange(self, dwViewStatus) +proc QuickActivate*(self: ptr IQuickActivate, pQaContainer: ptr QACONTAINER, pQaControl: ptr QACONTROL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QuickActivate(self, pQaContainer, pQaControl) +proc SetContentExtent*(self: ptr IQuickActivate, pSizel: LPSIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetContentExtent(self, pSizel) +proc GetContentExtent*(self: ptr IQuickActivate, pSizel: LPSIZEL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContentExtent(self, pSizel) +proc Next*(self: ptr IEnumGUID, celt: ULONG, rgelt: ptr GUID, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumGUID, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumGUID, ppenum: ptr ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumCATEGORYINFO, celt: ULONG, rgelt: ptr CATEGORYINFO, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumCATEGORYINFO, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumCATEGORYINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumCATEGORYINFO, ppenum: ptr ptr IEnumCATEGORYINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc RegisterCategories*(self: ptr ICatRegister, cCategories: ULONG, rgCategoryInfo: ptr CATEGORYINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterCategories(self, cCategories, rgCategoryInfo) +proc UnRegisterCategories*(self: ptr ICatRegister, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnRegisterCategories(self, cCategories, rgcatid) +proc RegisterClassImplCategories*(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterClassImplCategories(self, rclsid, cCategories, rgcatid) +proc UnRegisterClassImplCategories*(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnRegisterClassImplCategories(self, rclsid, cCategories, rgcatid) +proc RegisterClassReqCategories*(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterClassReqCategories(self, rclsid, cCategories, rgcatid) +proc UnRegisterClassReqCategories*(self: ptr ICatRegister, rclsid: REFCLSID, cCategories: ULONG, rgcatid: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnRegisterClassReqCategories(self, rclsid, cCategories, rgcatid) +proc EnumCategories*(self: ptr ICatInformation, lcid: LCID, ppenumCategoryInfo: ptr ptr IEnumCATEGORYINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumCategories(self, lcid, ppenumCategoryInfo) +proc GetCategoryDesc*(self: ptr ICatInformation, rcatid: REFCATID, lcid: LCID, pszDesc: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategoryDesc(self, rcatid, lcid, pszDesc) +proc EnumClassesOfCategories*(self: ptr ICatInformation, cImplemented: ULONG, rgcatidImpl: ptr CATID, cRequired: ULONG, rgcatidReq: ptr CATID, ppenumClsid: ptr ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumClassesOfCategories(self, cImplemented, rgcatidImpl, cRequired, rgcatidReq, ppenumClsid) +proc IsClassOfCategories*(self: ptr ICatInformation, rclsid: REFCLSID, cImplemented: ULONG, rgcatidImpl: ptr CATID, cRequired: ULONG, rgcatidReq: ptr CATID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsClassOfCategories(self, rclsid, cImplemented, rgcatidImpl, cRequired, rgcatidReq) +proc EnumImplCategoriesOfClass*(self: ptr ICatInformation, rclsid: REFCLSID, ppenumCatid: ptr ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumImplCategoriesOfClass(self, rclsid, ppenumCatid) +proc EnumReqCategoriesOfClass*(self: ptr ICatInformation, rclsid: REFCLSID, ppenumCatid: ptr ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumReqCategoriesOfClass(self, rclsid, ppenumCatid) +proc CreateView*(self: ptr IOleDocument, pIPSite: ptr IOleInPlaceSite, pstm: ptr IStream, dwReserved: DWORD, ppView: ptr ptr IOleDocumentView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateView(self, pIPSite, pstm, dwReserved, ppView) +proc GetDocMiscStatus*(self: ptr IOleDocument, pdwStatus: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocMiscStatus(self, pdwStatus) +proc EnumViews*(self: ptr IOleDocument, ppEnum: ptr ptr IEnumOleDocumentViews, ppView: ptr ptr IOleDocumentView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumViews(self, ppEnum, ppView) +proc ActivateMe*(self: ptr IOleDocumentSite, pViewToActivate: ptr IOleDocumentView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateMe(self, pViewToActivate) +proc SetInPlaceSite*(self: ptr IOleDocumentView, pIPSite: ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInPlaceSite(self, pIPSite) +proc GetInPlaceSite*(self: ptr IOleDocumentView, ppIPSite: ptr ptr IOleInPlaceSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInPlaceSite(self, ppIPSite) +proc GetDocument*(self: ptr IOleDocumentView, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocument(self, ppunk) +proc SetRect*(self: ptr IOleDocumentView, prcView: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRect(self, prcView) +proc GetRect*(self: ptr IOleDocumentView, prcView: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRect(self, prcView) +proc SetRectComplex*(self: ptr IOleDocumentView, prcView: LPRECT, prcHScroll: LPRECT, prcVScroll: LPRECT, prcSizeBox: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRectComplex(self, prcView, prcHScroll, prcVScroll, prcSizeBox) +proc Show*(self: ptr IOleDocumentView, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, fShow) +proc UIActivate*(self: ptr IOleDocumentView, fUIActivate: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UIActivate(self, fUIActivate) +proc Open*(self: ptr IOleDocumentView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self) +proc CloseView*(self: ptr IOleDocumentView, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseView(self, dwReserved) +proc SaveViewState*(self: ptr IOleDocumentView, pstm: LPSTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveViewState(self, pstm) +proc ApplyViewState*(self: ptr IOleDocumentView, pstm: LPSTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyViewState(self, pstm) +proc Clone*(self: ptr IOleDocumentView, pIPSiteNew: ptr IOleInPlaceSite, ppViewNew: ptr ptr IOleDocumentView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, pIPSiteNew, ppViewNew) +proc Next*(self: ptr IEnumOleDocumentViews, cViews: ULONG, rgpView: ptr ptr IOleDocumentView, pcFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, cViews, rgpView, pcFetched) +proc Skip*(self: ptr IEnumOleDocumentViews, cViews: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, cViews) +proc Reset*(self: ptr IEnumOleDocumentViews): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumOleDocumentViews, ppEnum: ptr ptr IEnumOleDocumentViews): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc FContinue*(self: ptr IContinueCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FContinue(self) +proc FContinuePrinting*(self: ptr IContinueCallback, nCntPrinted: LONG, nCurPage: LONG, pwszPrintStatus: ptr uint16): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FContinuePrinting(self, nCntPrinted, nCurPage, pwszPrintStatus) +proc SetInitialPageNum*(self: ptr IPrint, nFirstPage: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInitialPageNum(self, nFirstPage) +proc GetPageInfo*(self: ptr IPrint, pnFirstPage: ptr LONG, pcPages: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPageInfo(self, pnFirstPage, pcPages) +proc Print*(self: ptr IPrint, grfFlags: DWORD, pptd: ptr ptr DVTARGETDEVICE, ppPageSet: ptr ptr PAGESET, pstgmOptions: ptr STGMEDIUM, pcallback: ptr IContinueCallback, nFirstPage: LONG, pcPagesPrinted: ptr LONG, pnLastPage: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Print(self, grfFlags, pptd, ppPageSet, pstgmOptions, pcallback, nFirstPage, pcPagesPrinted, pnLastPage) +proc QueryStatus*(self: ptr IOleCommandTarget, pguidCmdGroup: ptr GUID, cCmds: ULONG, prgCmds: ptr OLECMD, pCmdText: ptr OLECMDTEXT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryStatus(self, pguidCmdGroup, cCmds, prgCmds, pCmdText) +proc Exec*(self: ptr IOleCommandTarget, pguidCmdGroup: ptr GUID, nCmdID: DWORD, nCmdexecopt: DWORD, pvaIn: ptr VARIANT, pvaOut: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Exec(self, pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) +proc OnZoomPercentChanged*(self: ptr IZoomEvents, ulZoomPercent: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnZoomPercentChanged(self, ulZoomPercent) +proc AllowFocusChange*(self: ptr IProtectFocus, pfAllow: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AllowFocusChange(self, pfAllow) +proc CreateMenu*(self: ptr IProtectedModeMenuServices, phMenu: ptr HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateMenu(self, phMenu) +proc LoadMenu*(self: ptr IProtectedModeMenuServices, pszModuleName: LPCWSTR, pszMenuName: LPCWSTR, phMenu: ptr HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadMenu(self, pszModuleName, pszMenuName, phMenu) +proc LoadMenuID*(self: ptr IProtectedModeMenuServices, pszModuleName: LPCWSTR, wResourceID: WORD, phMenu: ptr HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadMenuID(self, pszModuleName, wResourceID, phMenu) +proc GoBack*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GoBack(self) +proc GoForward*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GoForward(self) +proc GoHome*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GoHome(self) +proc GoSearch*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GoSearch(self) +proc Navigate*(self: ptr IWebBrowser, URL: BSTR, Flags: ptr VARIANT, TargetFrameName: ptr VARIANT, PostData: ptr VARIANT, Headers: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Navigate(self, URL, Flags, TargetFrameName, PostData, Headers) +proc Refresh*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Refresh(self) +proc Refresh2*(self: ptr IWebBrowser, Level: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Refresh2(self, Level) +proc Stop*(self: ptr IWebBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stop(self) +proc get_Application*(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppDisp) +proc get_Parent*(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppDisp) +proc get_Container*(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Container(self, ppDisp) +proc get_Document*(self: ptr IWebBrowser, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Document(self, ppDisp) +proc get_TopLevelContainer*(self: ptr IWebBrowser, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TopLevelContainer(self, pBool) +proc get_Type*(self: ptr IWebBrowser, Type: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Type(self, Type) +proc get_Left*(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Left(self, pl) +proc put_Left*(self: ptr IWebBrowser, Left: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Left(self, Left) +proc get_Top*(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Top(self, pl) +proc put_Top*(self: ptr IWebBrowser, Top: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Top(self, Top) +proc get_Width*(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Width(self, pl) +proc put_Width*(self: ptr IWebBrowser, Width: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Width(self, Width) +proc get_Height*(self: ptr IWebBrowser, pl: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Height(self, pl) +proc put_Height*(self: ptr IWebBrowser, Height: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Height(self, Height) +proc get_LocationName*(self: ptr IWebBrowser, LocationName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_LocationName(self, LocationName) +proc get_LocationURL*(self: ptr IWebBrowser, LocationURL: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_LocationURL(self, LocationURL) +proc get_Busy*(self: ptr IWebBrowser, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Busy(self, pBool) +proc Quit*(self: ptr IWebBrowserApp): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Quit(self) +proc ClientToWindow*(self: ptr IWebBrowserApp, pcx: ptr int32, pcy: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClientToWindow(self, pcx, pcy) +proc PutProperty*(self: ptr IWebBrowserApp, Property: BSTR, vtValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutProperty(self, Property, vtValue) +proc GetProperty*(self: ptr IWebBrowserApp, Property: BSTR, pvtValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, Property, pvtValue) +proc get_Name*(self: ptr IWebBrowserApp, Name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, Name) +proc get_HWND*(self: ptr IWebBrowserApp, pHWND: ptr SHANDLE_PTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HWND(self, pHWND) +proc get_FullName*(self: ptr IWebBrowserApp, FullName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FullName(self, FullName) +proc get_Path*(self: ptr IWebBrowserApp, Path: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Path(self, Path) +proc get_Visible*(self: ptr IWebBrowserApp, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Visible(self, pBool) +proc put_Visible*(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Visible(self, Value) +proc get_StatusBar*(self: ptr IWebBrowserApp, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StatusBar(self, pBool) +proc put_StatusBar*(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_StatusBar(self, Value) +proc get_StatusText*(self: ptr IWebBrowserApp, StatusText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StatusText(self, StatusText) +proc put_StatusText*(self: ptr IWebBrowserApp, StatusText: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_StatusText(self, StatusText) +proc get_ToolBar*(self: ptr IWebBrowserApp, Value: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToolBar(self, Value) +proc put_ToolBar*(self: ptr IWebBrowserApp, Value: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ToolBar(self, Value) +proc get_MenuBar*(self: ptr IWebBrowserApp, Value: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_MenuBar(self, Value) +proc put_MenuBar*(self: ptr IWebBrowserApp, Value: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_MenuBar(self, Value) +proc get_FullScreen*(self: ptr IWebBrowserApp, pbFullScreen: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FullScreen(self, pbFullScreen) +proc put_FullScreen*(self: ptr IWebBrowserApp, bFullScreen: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_FullScreen(self, bFullScreen) +proc Navigate2*(self: ptr IWebBrowser2, URL: ptr VARIANT, Flags: ptr VARIANT, TargetFrameName: ptr VARIANT, PostData: ptr VARIANT, Headers: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Navigate2(self, URL, Flags, TargetFrameName, PostData, Headers) +proc QueryStatusWB*(self: ptr IWebBrowser2, cmdID: OLECMDID, pcmdf: ptr OLECMDF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryStatusWB(self, cmdID, pcmdf) +proc ExecWB*(self: ptr IWebBrowser2, cmdID: OLECMDID, cmdexecopt: OLECMDEXECOPT, pvaIn: ptr VARIANT, pvaOut: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExecWB(self, cmdID, cmdexecopt, pvaIn, pvaOut) +proc ShowBrowserBar*(self: ptr IWebBrowser2, pvaClsid: ptr VARIANT, pvarShow: ptr VARIANT, pvarSize: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowBrowserBar(self, pvaClsid, pvarShow, pvarSize) +proc get_ReadyState*(self: ptr IWebBrowser2, plReadyState: ptr READYSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReadyState(self, plReadyState) +proc get_Offline*(self: ptr IWebBrowser2, pbOffline: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Offline(self, pbOffline) +proc put_Offline*(self: ptr IWebBrowser2, bOffline: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Offline(self, bOffline) +proc get_Silent*(self: ptr IWebBrowser2, pbSilent: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Silent(self, pbSilent) +proc put_Silent*(self: ptr IWebBrowser2, bSilent: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Silent(self, bSilent) +proc get_RegisterAsBrowser*(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RegisterAsBrowser(self, pbRegister) +proc put_RegisterAsBrowser*(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_RegisterAsBrowser(self, bRegister) +proc get_RegisterAsDropTarget*(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RegisterAsDropTarget(self, pbRegister) +proc put_RegisterAsDropTarget*(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_RegisterAsDropTarget(self, bRegister) +proc get_TheaterMode*(self: ptr IWebBrowser2, pbRegister: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TheaterMode(self, pbRegister) +proc put_TheaterMode*(self: ptr IWebBrowser2, bRegister: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_TheaterMode(self, bRegister) +proc get_AddressBar*(self: ptr IWebBrowser2, Value: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AddressBar(self, Value) +proc put_AddressBar*(self: ptr IWebBrowser2, Value: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_AddressBar(self, Value) +proc get_Resizable*(self: ptr IWebBrowser2, Value: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Resizable(self, Value) +proc put_Resizable*(self: ptr IWebBrowser2, Value: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Resizable(self, Value) +proc get_Count*(self: ptr IShellWindows, Count: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, Count) +proc Item*(self: ptr IShellWindows, index: VARIANT, Folder: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, index, Folder) +proc NewEnum*(self: ptr IShellWindows, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewEnum(self, ppunk) +proc Register*(self: ptr IShellWindows, pid: ptr IDispatch, hWnd: LONG, swClass: int32, plCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Register(self, pid, hWnd, swClass, plCookie) +proc RegisterPending*(self: ptr IShellWindows, lThreadId: LONG, pvarloc: ptr VARIANT, pvarlocRoot: ptr VARIANT, swClass: int32, plCookie: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterPending(self, lThreadId, pvarloc, pvarlocRoot, swClass, plCookie) +proc Revoke*(self: ptr IShellWindows, lCookie: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Revoke(self, lCookie) +proc OnNavigate*(self: ptr IShellWindows, lCookie: LONG, pvarLoc: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnNavigate(self, lCookie, pvarLoc) +proc OnActivated*(self: ptr IShellWindows, lCookie: LONG, fActive: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnActivated(self, lCookie, fActive) +proc FindWindowSW*(self: ptr IShellWindows, pvarLoc: ptr VARIANT, pvarLocRoot: ptr VARIANT, swClass: int32, phwnd: ptr LONG, swfwOptions: int32, ppdispOut: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindWindowSW(self, pvarLoc, pvarLocRoot, swClass, phwnd, swfwOptions, ppdispOut) +proc OnCreated*(self: ptr IShellWindows, lCookie: LONG, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnCreated(self, lCookie, punk) +proc ProcessAttachDetach*(self: ptr IShellWindows, fAttach: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProcessAttachDetach(self, fAttach) +proc ResetFirstBootMode*(self: ptr IShellUIHelper): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetFirstBootMode(self) +proc ResetSafeMode*(self: ptr IShellUIHelper): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetSafeMode(self) +proc RefreshOfflineDesktop*(self: ptr IShellUIHelper): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RefreshOfflineDesktop(self) +proc AddFavorite*(self: ptr IShellUIHelper, URL: BSTR, Title: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddFavorite(self, URL, Title) +proc AddChannel*(self: ptr IShellUIHelper, URL: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddChannel(self, URL) +proc AddDesktopComponent*(self: ptr IShellUIHelper, URL: BSTR, Type: BSTR, Left: ptr VARIANT, Top: ptr VARIANT, Width: ptr VARIANT, Height: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDesktopComponent(self, URL, Type, Left, Top, Width, Height) +proc IsSubscribed*(self: ptr IShellUIHelper, URL: BSTR, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSubscribed(self, URL, pBool) +proc NavigateAndFind*(self: ptr IShellUIHelper, URL: BSTR, strQuery: BSTR, varTargetFrame: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NavigateAndFind(self, URL, strQuery, varTargetFrame) +proc ImportExportFavorites*(self: ptr IShellUIHelper, fImport: VARIANT_BOOL, strImpExpPath: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ImportExportFavorites(self, fImport, strImpExpPath) +proc AutoCompleteSaveForm*(self: ptr IShellUIHelper, Form: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AutoCompleteSaveForm(self, Form) +proc AutoScan*(self: ptr IShellUIHelper, strSearch: BSTR, strFailureUrl: BSTR, pvarTargetFrame: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AutoScan(self, strSearch, strFailureUrl, pvarTargetFrame) +proc AutoCompleteAttach*(self: ptr IShellUIHelper, Reserved: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AutoCompleteAttach(self, Reserved) +proc ShowBrowserUI*(self: ptr IShellUIHelper, bstrName: BSTR, pvarIn: ptr VARIANT, pvarOut: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowBrowserUI(self, bstrName, pvarIn, pvarOut) +proc AddSearchProvider*(self: ptr IShellUIHelper2, URL: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSearchProvider(self, URL) +proc RunOnceShown*(self: ptr IShellUIHelper2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RunOnceShown(self) +proc SkipRunOnce*(self: ptr IShellUIHelper2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SkipRunOnce(self) +proc CustomizeSettings*(self: ptr IShellUIHelper2, fSQM: VARIANT_BOOL, fPhishing: VARIANT_BOOL, bstrLocale: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CustomizeSettings(self, fSQM, fPhishing, bstrLocale) +proc SqmEnabled*(self: ptr IShellUIHelper2, pfEnabled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SqmEnabled(self, pfEnabled) +proc PhishingEnabled*(self: ptr IShellUIHelper2, pfEnabled: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PhishingEnabled(self, pfEnabled) +proc BrandImageUri*(self: ptr IShellUIHelper2, pbstrUri: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BrandImageUri(self, pbstrUri) +proc SkipTabsWelcome*(self: ptr IShellUIHelper2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SkipTabsWelcome(self) +proc DiagnoseConnection*(self: ptr IShellUIHelper2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DiagnoseConnection(self) +proc CustomizeClearType*(self: ptr IShellUIHelper2, fSet: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CustomizeClearType(self, fSet) +proc IsSearchProviderInstalled*(self: ptr IShellUIHelper2, URL: BSTR, pdwResult: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSearchProviderInstalled(self, URL, pdwResult) +proc IsSearchMigrated*(self: ptr IShellUIHelper2, pfMigrated: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsSearchMigrated(self, pfMigrated) +proc DefaultSearchProvider*(self: ptr IShellUIHelper2, pbstrName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DefaultSearchProvider(self, pbstrName) +proc RunOnceRequiredSettingsComplete*(self: ptr IShellUIHelper2, fComplete: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RunOnceRequiredSettingsComplete(self, fComplete) +proc RunOnceHasShown*(self: ptr IShellUIHelper2, pfShown: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RunOnceHasShown(self, pfShown) +proc SearchGuideUrl*(self: ptr IShellUIHelper2, pbstrUrl: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SearchGuideUrl(self, pbstrUrl) +proc MoveSelectionUp*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveSelectionUp(self) +proc MoveSelectionDown*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveSelectionDown(self) +proc ResetSort*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetSort(self) +proc NewFolder*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewFolder(self) +proc mSynchronize*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Synchronize(self) +proc Import*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Import(self) +proc Export*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Export(self) +proc InvokeContextMenuCommand*(self: ptr IShellFavoritesNameSpace, strCommand: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeContextMenuCommand(self, strCommand) +proc MoveSelectionTo*(self: ptr IShellFavoritesNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveSelectionTo(self) +proc get_SubscriptionsEnabled*(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SubscriptionsEnabled(self, pBool) +proc CreateSubscriptionForSelection*(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateSubscriptionForSelection(self, pBool) +proc DeleteSubscriptionForSelection*(self: ptr IShellFavoritesNameSpace, pBool: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteSubscriptionForSelection(self, pBool) +proc SetRoot*(self: ptr IShellFavoritesNameSpace, bstrFullPath: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRoot(self, bstrFullPath) +proc get_EnumOptions*(self: ptr IShellNameSpace, pgrfEnumFlags: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_EnumOptions(self, pgrfEnumFlags) +proc put_EnumOptions*(self: ptr IShellNameSpace, pgrfEnumFlags: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_EnumOptions(self, pgrfEnumFlags) +proc get_SelectedItem*(self: ptr IShellNameSpace, pItem: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SelectedItem(self, pItem) +proc put_SelectedItem*(self: ptr IShellNameSpace, pItem: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_SelectedItem(self, pItem) +proc get_Root*(self: ptr IShellNameSpace, pvar: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Root(self, pvar) +proc put_Root*(self: ptr IShellNameSpace, pvar: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Root(self, pvar) +proc get_Depth*(self: ptr IShellNameSpace, piDepth: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Depth(self, piDepth) +proc put_Depth*(self: ptr IShellNameSpace, piDepth: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Depth(self, piDepth) +proc get_Mode*(self: ptr IShellNameSpace, puMode: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Mode(self, puMode) +proc put_Mode*(self: ptr IShellNameSpace, puMode: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Mode(self, puMode) +proc get_Flags*(self: ptr IShellNameSpace, pdwFlags: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Flags(self, pdwFlags) +proc put_Flags*(self: ptr IShellNameSpace, pdwFlags: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Flags(self, pdwFlags) +proc put_TVFlags*(self: ptr IShellNameSpace, dwFlags: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_TVFlags(self, dwFlags) +proc get_TVFlags*(self: ptr IShellNameSpace, dwFlags: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TVFlags(self, dwFlags) +proc get_Columns*(self: ptr IShellNameSpace, bstrColumns: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Columns(self, bstrColumns) +proc put_Columns*(self: ptr IShellNameSpace, bstrColumns: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Columns(self, bstrColumns) +proc get_CountViewTypes*(self: ptr IShellNameSpace, piTypes: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CountViewTypes(self, piTypes) +proc SetViewType*(self: ptr IShellNameSpace, iType: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetViewType(self, iType) +proc SelectedItems*(self: ptr IShellNameSpace, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectedItems(self, ppid) +proc Expand*(self: ptr IShellNameSpace, `var`: VARIANT, iDepth: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Expand(self, `var`, iDepth) +proc UnselectAll*(self: ptr IShellNameSpace): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnselectAll(self) +proc advanceError*(self: ptr IScriptErrorList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.advanceError(self) +proc retreatError*(self: ptr IScriptErrorList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.retreatError(self) +proc canAdvanceError*(self: ptr IScriptErrorList, pfCanAdvance: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.canAdvanceError(self, pfCanAdvance) +proc canRetreatError*(self: ptr IScriptErrorList, pfCanRetreat: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.canRetreatError(self, pfCanRetreat) +proc getErrorLine*(self: ptr IScriptErrorList, plLine: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getErrorLine(self, plLine) +proc getErrorChar*(self: ptr IScriptErrorList, plChar: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getErrorChar(self, plChar) +proc getErrorCode*(self: ptr IScriptErrorList, plCode: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getErrorCode(self, plCode) +proc getErrorMsg*(self: ptr IScriptErrorList, pstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getErrorMsg(self, pstr) +proc getErrorUrl*(self: ptr IScriptErrorList, pstr: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getErrorUrl(self, pstr) +proc getAlwaysShowLockState*(self: ptr IScriptErrorList, pfAlwaysShowLocked: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getAlwaysShowLockState(self, pfAlwaysShowLocked) +proc getDetailsPaneOpen*(self: ptr IScriptErrorList, pfDetailsPaneOpen: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getDetailsPaneOpen(self, pfDetailsPaneOpen) +proc setDetailsPaneOpen*(self: ptr IScriptErrorList, fDetailsPaneOpen: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setDetailsPaneOpen(self, fDetailsPaneOpen) +proc getPerErrorDisplay*(self: ptr IScriptErrorList, pfPerErrorDisplay: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.getPerErrorDisplay(self, pfPerErrorDisplay) +proc setPerErrorDisplay*(self: ptr IScriptErrorList, fPerErrorDisplay: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.setPerErrorDisplay(self, fPerErrorDisplay) +proc get_Title*(self: ptr ISearch, pbstrTitle: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Title(self, pbstrTitle) +proc get_Id*(self: ptr ISearch, pbstrId: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Id(self, pbstrId) +proc get_URL*(self: ptr ISearch, pbstrUrl: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_URL(self, pbstrUrl) +proc get_Count*(self: ptr ISearches, plCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, plCount) +proc get_Default*(self: ptr ISearches, pbstrDefault: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Default(self, pbstrDefault) +proc Item*(self: ptr ISearches, index: VARIANT, ppid: ptr ptr ISearch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, index, ppid) +proc NewEnum*(self: ptr ISearches, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewEnum(self, ppunk) +proc AddNextMenuItem*(self: ptr ISearchAssistantOC, bstrText: BSTR, idItem: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddNextMenuItem(self, bstrText, idItem) +proc SetDefaultSearchUrl*(self: ptr ISearchAssistantOC, bstrUrl: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultSearchUrl(self, bstrUrl) +proc NavigateToDefaultSearch*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NavigateToDefaultSearch(self) +proc IsRestricted*(self: ptr ISearchAssistantOC, bstrGuid: BSTR, pVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRestricted(self, bstrGuid, pVal) +proc get_ShellFeaturesEnabled*(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShellFeaturesEnabled(self, pVal) +proc get_SearchAssistantDefault*(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SearchAssistantDefault(self, pVal) +proc get_Searches*(self: ptr ISearchAssistantOC, ppid: ptr ptr ISearches): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Searches(self, ppid) +proc get_InWebFolder*(self: ptr ISearchAssistantOC, pVal: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_InWebFolder(self, pVal) +proc PutProperty*(self: ptr ISearchAssistantOC, bPerLocale: VARIANT_BOOL, bstrName: BSTR, bstrValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutProperty(self, bPerLocale, bstrName, bstrValue) +proc GetProperty*(self: ptr ISearchAssistantOC, bPerLocale: VARIANT_BOOL, bstrName: BSTR, pbstrValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, bPerLocale, bstrName, pbstrValue) +proc put_EventHandled*(self: ptr ISearchAssistantOC, rhs: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_EventHandled(self, rhs) +proc ResetNextMenu*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetNextMenu(self) +proc FindOnWeb*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindOnWeb(self) +proc FindFilesOrFolders*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFilesOrFolders(self) +proc FindComputer*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindComputer(self) +proc FindPrinter*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindPrinter(self) +proc FindPeople*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindPeople(self) +proc GetSearchAssistantURL*(self: ptr ISearchAssistantOC, bSubstitute: VARIANT_BOOL, bCustomize: VARIANT_BOOL, pbstrValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchAssistantURL(self, bSubstitute, bCustomize, pbstrValue) +proc NotifySearchSettingsChanged*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NotifySearchSettingsChanged(self) +proc put_ASProvider*(self: ptr ISearchAssistantOC, pProvider: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ASProvider(self, pProvider) +proc get_ASProvider*(self: ptr ISearchAssistantOC, pProvider: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ASProvider(self, pProvider) +proc put_ASSetting*(self: ptr ISearchAssistantOC, pSetting: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ASSetting(self, pSetting) +proc get_ASSetting*(self: ptr ISearchAssistantOC, pSetting: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ASSetting(self, pSetting) +proc NETDetectNextNavigate*(self: ptr ISearchAssistantOC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NETDetectNextNavigate(self) +proc PutFindText*(self: ptr ISearchAssistantOC, FindText: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PutFindText(self, FindText) +proc get_Version*(self: ptr ISearchAssistantOC, pVersion: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Version(self, pVersion) +proc EncodeString*(self: ptr ISearchAssistantOC, bstrValue: BSTR, bstrCharSet: BSTR, bUseUTF8: VARIANT_BOOL, pbstrResult: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EncodeString(self, bstrValue, bstrCharSet, bUseUTF8, pbstrResult) +proc get_ShowFindPrinter*(self: ptr ISearchAssistantOC2, pbShowFindPrinter: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShowFindPrinter(self, pbShowFindPrinter) +proc get_SearchCompanionAvailable*(self: ptr ISearchAssistantOC3, pbAvailable: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SearchCompanionAvailable(self, pbAvailable) +proc put_UseSearchCompanion*(self: ptr ISearchAssistantOC3, pbUseSC: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_UseSearchCompanion(self, pbUseSC) +proc get_UseSearchCompanion*(self: ptr ISearchAssistantOC3, pbUseSC: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_UseSearchCompanion(self, pbUseSC) +proc GetData*(self: ptr IRichChunk, pFirstPos: ptr ULONG, pLength: ptr ULONG, ppsz: ptr LPWSTR, pValue: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetData(self, pFirstPos, pLength, ppsz, pValue) +proc GetConditionType*(self: ptr ICondition, pNodeType: ptr CONDITION_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConditionType(self, pNodeType) +proc GetSubConditions*(self: ptr ICondition, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSubConditions(self, riid, ppv) +proc GetComparisonInfo*(self: ptr ICondition, ppszPropertyName: ptr LPWSTR, pcop: ptr CONDITION_OPERATION, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetComparisonInfo(self, ppszPropertyName, pcop, ppropvar) +proc GetValueType*(self: ptr ICondition, ppszValueTypeName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValueType(self, ppszValueTypeName) +proc GetValueNormalization*(self: ptr ICondition, ppszNormalization: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValueNormalization(self, ppszNormalization) +proc GetInputTerms*(self: ptr ICondition, ppPropertyTerm: ptr ptr IRichChunk, ppOperationTerm: ptr ptr IRichChunk, ppValueTerm: ptr ptr IRichChunk): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInputTerms(self, ppPropertyTerm, ppOperationTerm, ppValueTerm) +proc Clone*(self: ptr ICondition, ppc: ptr ptr ICondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppc) +proc GetLocale*(self: ptr ICondition2, ppszLocaleName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLocale(self, ppszLocaleName) +proc GetLeafConditionInfo*(self: ptr ICondition2, ppropkey: ptr PROPERTYKEY, pcop: ptr CONDITION_OPERATION, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLeafConditionInfo(self, ppropkey, pcop, ppropvar) +proc Initialize*(self: ptr IInitializeWithFile, pszFilePath: LPCWSTR, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pszFilePath, grfMode) +proc Initialize*(self: ptr IInitializeWithStream, pstream: ptr IStream, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pstream, grfMode) +proc GetCount*(self: ptr IPropertyStore, cProps: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, cProps) +proc GetAt*(self: ptr IPropertyStore, iProp: DWORD, pkey: ptr PROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAt(self, iProp, pkey) +proc GetValue*(self: ptr IPropertyStore, key: REFPROPERTYKEY, pv: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValue(self, key, pv) +proc SetValue*(self: ptr IPropertyStore, key: REFPROPERTYKEY, propvar: REFPROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, key, propvar) +proc Commit*(self: ptr IPropertyStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self) +proc GetNamedValue*(self: ptr INamedPropertyStore, pszName: LPCWSTR, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNamedValue(self, pszName, ppropvar) +proc SetNamedValue*(self: ptr INamedPropertyStore, pszName: LPCWSTR, propvar: REFPROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNamedValue(self, pszName, propvar) +proc GetNameCount*(self: ptr INamedPropertyStore, pdwCount: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNameCount(self, pdwCount) +proc GetNameAt*(self: ptr INamedPropertyStore, iProp: DWORD, pbstrName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNameAt(self, iProp, pbstrName) +proc SetPropertyKey*(self: ptr IObjectWithPropertyKey, key: REFPROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropertyKey(self, key) +proc GetPropertyKey*(self: ptr IObjectWithPropertyKey, pkey: ptr PROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyKey(self, pkey) +proc ApplyToPropVariant*(self: ptr IPropertyChange, propvarIn: REFPROPVARIANT, ppropvarOut: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyToPropVariant(self, propvarIn, ppropvarOut) +proc GetCount*(self: ptr IPropertyChangeArray, pcOperations: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pcOperations) +proc GetAt*(self: ptr IPropertyChangeArray, iIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAt(self, iIndex, riid, ppv) +proc InsertAt*(self: ptr IPropertyChangeArray, iIndex: UINT, ppropChange: ptr IPropertyChange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertAt(self, iIndex, ppropChange) +proc Append*(self: ptr IPropertyChangeArray, ppropChange: ptr IPropertyChange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Append(self, ppropChange) +proc AppendOrReplace*(self: ptr IPropertyChangeArray, ppropChange: ptr IPropertyChange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppendOrReplace(self, ppropChange) +proc RemoveAt*(self: ptr IPropertyChangeArray, iIndex: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAt(self, iIndex) +proc IsKeyInArray*(self: ptr IPropertyChangeArray, key: REFPROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsKeyInArray(self, key) +proc IsPropertyWritable*(self: ptr IPropertyStoreCapabilities, key: REFPROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsPropertyWritable(self, key) +proc GetState*(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, pstate: ptr PSC_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, key, pstate) +proc GetValueAndState*(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT, pstate: ptr PSC_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValueAndState(self, key, ppropvar, pstate) +proc SetState*(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, state: PSC_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetState(self, key, state) +proc SetValueAndState*(self: ptr IPropertyStoreCache, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT, state: PSC_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValueAndState(self, key, ppropvar, state) +proc GetEnumType*(self: ptr IPropertyEnumType, penumtype: ptr PROPENUMTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumType(self, penumtype) +proc GetValue*(self: ptr IPropertyEnumType, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValue(self, ppropvar) +proc GetRangeMinValue*(self: ptr IPropertyEnumType, ppropvarMin: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRangeMinValue(self, ppropvarMin) +proc GetRangeSetValue*(self: ptr IPropertyEnumType, ppropvarSet: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRangeSetValue(self, ppropvarSet) +proc GetDisplayText*(self: ptr IPropertyEnumType, ppszDisplay: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayText(self, ppszDisplay) +proc GetImageReference*(self: ptr IPropertyEnumType2, ppszImageRes: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImageReference(self, ppszImageRes) +proc GetCount*(self: ptr IPropertyEnumTypeList, pctypes: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pctypes) +proc GetAt*(self: ptr IPropertyEnumTypeList, itype: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAt(self, itype, riid, ppv) +proc GetConditionAt*(self: ptr IPropertyEnumTypeList, nIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConditionAt(self, nIndex, riid, ppv) +proc FindMatchingIndex*(self: ptr IPropertyEnumTypeList, propvarCmp: REFPROPVARIANT, pnIndex: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindMatchingIndex(self, propvarCmp, pnIndex) +proc GetPropertyKey*(self: ptr IPropertyDescription, pkey: ptr PROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyKey(self, pkey) +proc GetCanonicalName*(self: ptr IPropertyDescription, ppszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCanonicalName(self, ppszName) +proc GetPropertyType*(self: ptr IPropertyDescription, pvartype: ptr VARTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyType(self, pvartype) +proc GetDisplayName*(self: ptr IPropertyDescription, ppszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayName(self, ppszName) +proc GetEditInvitation*(self: ptr IPropertyDescription, ppszInvite: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEditInvitation(self, ppszInvite) +proc GetTypeFlags*(self: ptr IPropertyDescription, mask: PROPDESC_TYPE_FLAGS, ppdtFlags: ptr PROPDESC_TYPE_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTypeFlags(self, mask, ppdtFlags) +proc GetViewFlags*(self: ptr IPropertyDescription, ppdvFlags: ptr PROPDESC_VIEW_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewFlags(self, ppdvFlags) +proc GetDefaultColumnWidth*(self: ptr IPropertyDescription, pcxChars: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultColumnWidth(self, pcxChars) +proc GetDisplayType*(self: ptr IPropertyDescription, pdisplaytype: ptr PROPDESC_DISPLAYTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayType(self, pdisplaytype) +proc GetColumnState*(self: ptr IPropertyDescription, pcsFlags: ptr SHCOLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnState(self, pcsFlags) +proc GetGroupingRange*(self: ptr IPropertyDescription, pgr: ptr PROPDESC_GROUPING_RANGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGroupingRange(self, pgr) +proc GetRelativeDescriptionType*(self: ptr IPropertyDescription, prdt: ptr PROPDESC_RELATIVEDESCRIPTION_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRelativeDescriptionType(self, prdt) +proc GetRelativeDescription*(self: ptr IPropertyDescription, propvar1: REFPROPVARIANT, propvar2: REFPROPVARIANT, ppszDesc1: ptr LPWSTR, ppszDesc2: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRelativeDescription(self, propvar1, propvar2, ppszDesc1, ppszDesc2) +proc GetSortDescription*(self: ptr IPropertyDescription, psd: ptr PROPDESC_SORTDESCRIPTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortDescription(self, psd) +proc GetSortDescriptionLabel*(self: ptr IPropertyDescription, fDescending: WINBOOL, ppszDescription: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortDescriptionLabel(self, fDescending, ppszDescription) +proc GetAggregationType*(self: ptr IPropertyDescription, paggtype: ptr PROPDESC_AGGREGATION_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAggregationType(self, paggtype) +proc GetConditionType*(self: ptr IPropertyDescription, pcontype: ptr PROPDESC_CONDITION_TYPE, popDefault: ptr CONDITION_OPERATION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConditionType(self, pcontype, popDefault) +proc GetEnumTypeList*(self: ptr IPropertyDescription, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumTypeList(self, riid, ppv) +proc CoerceToCanonicalValue*(self: ptr IPropertyDescription, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CoerceToCanonicalValue(self, ppropvar) +proc FormatForDisplay*(self: ptr IPropertyDescription, propvar: REFPROPVARIANT, pdfFlags: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatForDisplay(self, propvar, pdfFlags, ppszDisplay) +proc IsValueCanonical*(self: ptr IPropertyDescription, propvar: REFPROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsValueCanonical(self, propvar) +proc GetImageReferenceForValue*(self: ptr IPropertyDescription2, propvar: REFPROPVARIANT, ppszImageRes: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImageReferenceForValue(self, propvar, ppszImageRes) +proc GetSortByAlias*(self: ptr IPropertyDescriptionAliasInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortByAlias(self, riid, ppv) +proc GetAdditionalSortByAliases*(self: ptr IPropertyDescriptionAliasInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAdditionalSortByAliases(self, riid, ppv) +proc GetSearchInfoFlags*(self: ptr IPropertyDescriptionSearchInfo, ppdsiFlags: ptr PROPDESC_SEARCHINFO_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchInfoFlags(self, ppdsiFlags) +proc GetColumnIndexType*(self: ptr IPropertyDescriptionSearchInfo, ppdciType: ptr PROPDESC_COLUMNINDEX_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnIndexType(self, ppdciType) +proc GetProjectionString*(self: ptr IPropertyDescriptionSearchInfo, ppszProjection: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProjectionString(self, ppszProjection) +proc GetMaxSize*(self: ptr IPropertyDescriptionSearchInfo, pcbMaxSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMaxSize(self, pcbMaxSize) +proc GetRelatedProperty*(self: ptr IPropertyDescriptionRelatedPropertyInfo, pszRelationshipName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRelatedProperty(self, pszRelationshipName, riid, ppv) +proc GetPropertyDescription*(self: ptr IPropertySystem, propkey: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescription(self, propkey, riid, ppv) +proc GetPropertyDescriptionByName*(self: ptr IPropertySystem, pszCanonicalName: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescriptionByName(self, pszCanonicalName, riid, ppv) +proc GetPropertyDescriptionListFromString*(self: ptr IPropertySystem, pszPropList: LPCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescriptionListFromString(self, pszPropList, riid, ppv) +proc EnumeratePropertyDescriptions*(self: ptr IPropertySystem, filterOn: PROPDESC_ENUMFILTER, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumeratePropertyDescriptions(self, filterOn, riid, ppv) +proc FormatForDisplay*(self: ptr IPropertySystem, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, pszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatForDisplay(self, key, propvar, pdff, pszText, cchText) +proc FormatForDisplayAlloc*(self: ptr IPropertySystem, key: REFPROPERTYKEY, propvar: REFPROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszDisplay: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatForDisplayAlloc(self, key, propvar, pdff, ppszDisplay) +proc RegisterPropertySchema*(self: ptr IPropertySystem, pszPath: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterPropertySchema(self, pszPath) +proc UnregisterPropertySchema*(self: ptr IPropertySystem, pszPath: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterPropertySchema(self, pszPath) +proc RefreshPropertySchema*(self: ptr IPropertySystem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RefreshPropertySchema(self) +proc GetCount*(self: ptr IPropertyDescriptionList, pcElem: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pcElem) +proc GetAt*(self: ptr IPropertyDescriptionList, iElem: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAt(self, iElem, riid, ppv) +proc GetPropertyStore*(self: ptr IPropertyStoreFactory, flags: GETPROPERTYSTOREFLAGS, pUnkFactory: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStore(self, flags, pUnkFactory, riid, ppv) +proc GetPropertyStoreForKeys*(self: ptr IPropertyStoreFactory, rgKeys: ptr PROPERTYKEY, cKeys: UINT, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStoreForKeys(self, rgKeys, cKeys, flags, riid, ppv) +proc GetDelayedPropertyStore*(self: ptr IDelayedPropertyStoreFactory, flags: GETPROPERTYSTOREFLAGS, dwStoreId: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDelayedPropertyStore(self, flags, dwStoreId, riid, ppv) +proc SetFlags*(self: ptr IPersistSerializedPropStorage, flags: PERSIST_SPROPSTORE_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFlags(self, flags) +proc SetPropertyStorage*(self: ptr IPersistSerializedPropStorage, psps: PCUSERIALIZEDPROPSTORAGE, cb: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropertyStorage(self, psps, cb) +proc GetPropertyStorage*(self: ptr IPersistSerializedPropStorage, ppsps: ptr ptr SERIALIZEDPROPSTORAGE, pcb: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStorage(self, ppsps, pcb) +proc GetPropertyStorageSize*(self: ptr IPersistSerializedPropStorage2, pcb: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStorageSize(self, pcb) +proc GetPropertyStorageBuffer*(self: ptr IPersistSerializedPropStorage2, psps: ptr SERIALIZEDPROPSTORAGE, cb: DWORD, pcbWritten: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStorageBuffer(self, psps, cb, pcbWritten) +proc SchemaRefreshed*(self: ptr IPropertySystemChangeNotify): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SchemaRefreshed(self) +proc CreateObject*(self: ptr ICreateObject, clsid: REFCLSID, pUnkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateObject(self, clsid, pUnkOuter, riid, ppv) +converter winimConverterAsyncIUnknownToIUnknown*(x: ptr AsyncIUnknown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClassFactoryToIUnknown*(x: ptr IClassFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarshalToIUnknown*(x: ptr IMarshal): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINoMarshalToIUnknown*(x: ptr INoMarshal): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAgileObjectToIUnknown*(x: ptr IAgileObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarshal2ToIMarshal*(x: ptr IMarshal2): ptr IMarshal = cast[ptr IMarshal](x) +converter winimConverterIMarshal2ToIUnknown*(x: ptr IMarshal2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMallocToIUnknown*(x: ptr IMalloc): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStdMarshalInfoToIUnknown*(x: ptr IStdMarshalInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExternalConnectionToIUnknown*(x: ptr IExternalConnection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMultiQIToIUnknown*(x: ptr IMultiQI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterAsyncIMultiQIToIUnknown*(x: ptr AsyncIMultiQI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternalUnknownToIUnknown*(x: ptr IInternalUnknown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumUnknownToIUnknown*(x: ptr IEnumUnknown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumStringToIUnknown*(x: ptr IEnumString): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISequentialStreamToIUnknown*(x: ptr ISequentialStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStreamToISequentialStream*(x: ptr IStream): ptr ISequentialStream = cast[ptr ISequentialStream](x) +converter winimConverterIStreamToIUnknown*(x: ptr IStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcChannelBufferToIUnknown*(x: ptr IRpcChannelBuffer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcChannelBuffer2ToIRpcChannelBuffer*(x: ptr IRpcChannelBuffer2): ptr IRpcChannelBuffer = cast[ptr IRpcChannelBuffer](x) +converter winimConverterIRpcChannelBuffer2ToIUnknown*(x: ptr IRpcChannelBuffer2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAsyncRpcChannelBufferToIRpcChannelBuffer2*(x: ptr IAsyncRpcChannelBuffer): ptr IRpcChannelBuffer2 = cast[ptr IRpcChannelBuffer2](x) +converter winimConverterIAsyncRpcChannelBufferToIRpcChannelBuffer*(x: ptr IAsyncRpcChannelBuffer): ptr IRpcChannelBuffer = cast[ptr IRpcChannelBuffer](x) +converter winimConverterIAsyncRpcChannelBufferToIUnknown*(x: ptr IAsyncRpcChannelBuffer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcChannelBuffer3ToIRpcChannelBuffer2*(x: ptr IRpcChannelBuffer3): ptr IRpcChannelBuffer2 = cast[ptr IRpcChannelBuffer2](x) +converter winimConverterIRpcChannelBuffer3ToIRpcChannelBuffer*(x: ptr IRpcChannelBuffer3): ptr IRpcChannelBuffer = cast[ptr IRpcChannelBuffer](x) +converter winimConverterIRpcChannelBuffer3ToIUnknown*(x: ptr IRpcChannelBuffer3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcSyntaxNegotiateToIUnknown*(x: ptr IRpcSyntaxNegotiate): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcProxyBufferToIUnknown*(x: ptr IRpcProxyBuffer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcStubBufferToIUnknown*(x: ptr IRpcStubBuffer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPSFactoryBufferToIUnknown*(x: ptr IPSFactoryBuffer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIChannelHookToIUnknown*(x: ptr IChannelHook): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClientSecurityToIUnknown*(x: ptr IClientSecurity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIServerSecurityToIUnknown*(x: ptr IServerSecurity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcOptionsToIUnknown*(x: ptr IRpcOptions): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGlobalOptionsToIUnknown*(x: ptr IGlobalOptions): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISurrogateToIUnknown*(x: ptr ISurrogate): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGlobalInterfaceTableToIUnknown*(x: ptr IGlobalInterfaceTable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizeToIUnknown*(x: ptr ISynchronize): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizeHandleToIUnknown*(x: ptr ISynchronizeHandle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizeEventToISynchronizeHandle*(x: ptr ISynchronizeEvent): ptr ISynchronizeHandle = cast[ptr ISynchronizeHandle](x) +converter winimConverterISynchronizeEventToIUnknown*(x: ptr ISynchronizeEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizeContainerToIUnknown*(x: ptr ISynchronizeContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizeMutexToISynchronize*(x: ptr ISynchronizeMutex): ptr ISynchronize = cast[ptr ISynchronize](x) +converter winimConverterISynchronizeMutexToIUnknown*(x: ptr ISynchronizeMutex): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICancelMethodCallsToIUnknown*(x: ptr ICancelMethodCalls): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAsyncManagerToIUnknown*(x: ptr IAsyncManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICallFactoryToIUnknown*(x: ptr ICallFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRpcHelperToIUnknown*(x: ptr IRpcHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIReleaseMarshalBuffersToIUnknown*(x: ptr IReleaseMarshalBuffers): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWaitMultipleToIUnknown*(x: ptr IWaitMultiple): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAddrTrackingControlToIUnknown*(x: ptr IAddrTrackingControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAddrExclusionControlToIUnknown*(x: ptr IAddrExclusionControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPipeByteToIUnknown*(x: ptr IPipeByte): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPipeLongToIUnknown*(x: ptr IPipeLong): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPipeDoubleToIUnknown*(x: ptr IPipeDouble): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumContextPropsToIUnknown*(x: ptr IEnumContextProps): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextToIUnknown*(x: ptr IContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIComThreadingInfoToIUnknown*(x: ptr IComThreadingInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProcessInitControlToIUnknown*(x: ptr IProcessInitControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFastRundownToIUnknown*(x: ptr IFastRundown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMarshalingStreamToIStream*(x: ptr IMarshalingStream): ptr IStream = cast[ptr IStream](x) +converter winimConverterIMarshalingStreamToISequentialStream*(x: ptr IMarshalingStream): ptr ISequentialStream = cast[ptr ISequentialStream](x) +converter winimConverterIMarshalingStreamToIUnknown*(x: ptr IMarshalingStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMallocSpyToIUnknown*(x: ptr IMallocSpy): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindCtxToIUnknown*(x: ptr IBindCtx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumMonikerToIUnknown*(x: ptr IEnumMoniker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRunnableObjectToIUnknown*(x: ptr IRunnableObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRunningObjectTableToIUnknown*(x: ptr IRunningObjectTable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistToIUnknown*(x: ptr IPersist): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistStreamToIPersist*(x: ptr IPersistStream): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistStreamToIUnknown*(x: ptr IPersistStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMonikerToIPersistStream*(x: ptr IMoniker): ptr IPersistStream = cast[ptr IPersistStream](x) +converter winimConverterIMonikerToIPersist*(x: ptr IMoniker): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIMonikerToIUnknown*(x: ptr IMoniker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIROTDataToIUnknown*(x: ptr IROTData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumSTATSTGToIUnknown*(x: ptr IEnumSTATSTG): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStorageToIUnknown*(x: ptr IStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistFileToIPersist*(x: ptr IPersistFile): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistFileToIUnknown*(x: ptr IPersistFile): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistStorageToIPersist*(x: ptr IPersistStorage): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistStorageToIUnknown*(x: ptr IPersistStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterILockBytesToIUnknown*(x: ptr ILockBytes): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumFORMATETCToIUnknown*(x: ptr IEnumFORMATETC): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumSTATDATAToIUnknown*(x: ptr IEnumSTATDATA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRootStorageToIUnknown*(x: ptr IRootStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAdviseSinkToIUnknown*(x: ptr IAdviseSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterAsyncIAdviseSinkToIUnknown*(x: ptr AsyncIAdviseSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAdviseSink2ToIAdviseSink*(x: ptr IAdviseSink2): ptr IAdviseSink = cast[ptr IAdviseSink](x) +converter winimConverterIAdviseSink2ToIUnknown*(x: ptr IAdviseSink2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterAsyncIAdviseSink2ToIAdviseSink*(x: ptr AsyncIAdviseSink2): ptr IAdviseSink = cast[ptr IAdviseSink](x) +converter winimConverterAsyncIAdviseSink2ToIUnknown*(x: ptr AsyncIAdviseSink2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataObjectToIUnknown*(x: ptr IDataObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataAdviseHolderToIUnknown*(x: ptr IDataAdviseHolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMessageFilterToIUnknown*(x: ptr IMessageFilter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClassActivatorToIUnknown*(x: ptr IClassActivator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFillLockBytesToIUnknown*(x: ptr IFillLockBytes): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProgressNotifyToIUnknown*(x: ptr IProgressNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterILayoutStorageToIUnknown*(x: ptr ILayoutStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBlockingLockToIUnknown*(x: ptr IBlockingLock): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITimeAndNoticeControlToIUnknown*(x: ptr ITimeAndNoticeControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOplockStorageToIUnknown*(x: ptr IOplockStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDirectWriterLockToIUnknown*(x: ptr IDirectWriterLock): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUrlMonToIUnknown*(x: ptr IUrlMon): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIForegroundTransferToIUnknown*(x: ptr IForegroundTransfer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIThumbnailExtractorToIUnknown*(x: ptr IThumbnailExtractor): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDummyHICONIncluderToIUnknown*(x: ptr IDummyHICONIncluder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProcessLockToIUnknown*(x: ptr IProcessLock): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISurrogateServiceToIUnknown*(x: ptr ISurrogateService): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeSpyToIUnknown*(x: ptr IInitializeSpy): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApartmentShutdownToIUnknown*(x: ptr IApartmentShutdown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateTypeInfoToIUnknown*(x: ptr ICreateTypeInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateTypeInfo2ToICreateTypeInfo*(x: ptr ICreateTypeInfo2): ptr ICreateTypeInfo = cast[ptr ICreateTypeInfo](x) +converter winimConverterICreateTypeInfo2ToIUnknown*(x: ptr ICreateTypeInfo2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateTypeLibToIUnknown*(x: ptr ICreateTypeLib): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateTypeLib2ToICreateTypeLib*(x: ptr ICreateTypeLib2): ptr ICreateTypeLib = cast[ptr ICreateTypeLib](x) +converter winimConverterICreateTypeLib2ToIUnknown*(x: ptr ICreateTypeLib2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDispatchToIUnknown*(x: ptr IDispatch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumVARIANTToIUnknown*(x: ptr IEnumVARIANT): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeCompToIUnknown*(x: ptr ITypeComp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeInfoToIUnknown*(x: ptr ITypeInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeInfo2ToITypeInfo*(x: ptr ITypeInfo2): ptr ITypeInfo = cast[ptr ITypeInfo](x) +converter winimConverterITypeInfo2ToIUnknown*(x: ptr ITypeInfo2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeLibToIUnknown*(x: ptr ITypeLib): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeLib2ToITypeLib*(x: ptr ITypeLib2): ptr ITypeLib = cast[ptr ITypeLib](x) +converter winimConverterITypeLib2ToIUnknown*(x: ptr ITypeLib2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeChangeEventsToIUnknown*(x: ptr ITypeChangeEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIErrorInfoToIUnknown*(x: ptr IErrorInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateErrorInfoToIUnknown*(x: ptr ICreateErrorInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISupportErrorInfoToIUnknown*(x: ptr ISupportErrorInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeFactoryToIUnknown*(x: ptr ITypeFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITypeMarshalToIUnknown*(x: ptr ITypeMarshal): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRecordInfoToIUnknown*(x: ptr IRecordInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIErrorLogToIUnknown*(x: ptr IErrorLog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyBagToIUnknown*(x: ptr IPropertyBag): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleAdviseHolderToIUnknown*(x: ptr IOleAdviseHolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleCacheToIUnknown*(x: ptr IOleCache): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleCache2ToIOleCache*(x: ptr IOleCache2): ptr IOleCache = cast[ptr IOleCache](x) +converter winimConverterIOleCache2ToIUnknown*(x: ptr IOleCache2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleCacheControlToIUnknown*(x: ptr IOleCacheControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIParseDisplayNameToIUnknown*(x: ptr IParseDisplayName): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleContainerToIParseDisplayName*(x: ptr IOleContainer): ptr IParseDisplayName = cast[ptr IParseDisplayName](x) +converter winimConverterIOleContainerToIUnknown*(x: ptr IOleContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleClientSiteToIUnknown*(x: ptr IOleClientSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleObjectToIUnknown*(x: ptr IOleObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleWindowToIUnknown*(x: ptr IOleWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleLinkToIUnknown*(x: ptr IOleLink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleItemContainerToIOleContainer*(x: ptr IOleItemContainer): ptr IOleContainer = cast[ptr IOleContainer](x) +converter winimConverterIOleItemContainerToIParseDisplayName*(x: ptr IOleItemContainer): ptr IParseDisplayName = cast[ptr IParseDisplayName](x) +converter winimConverterIOleItemContainerToIUnknown*(x: ptr IOleItemContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceUIWindowToIOleWindow*(x: ptr IOleInPlaceUIWindow): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceUIWindowToIUnknown*(x: ptr IOleInPlaceUIWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceActiveObjectToIOleWindow*(x: ptr IOleInPlaceActiveObject): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceActiveObjectToIUnknown*(x: ptr IOleInPlaceActiveObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceFrameToIOleInPlaceUIWindow*(x: ptr IOleInPlaceFrame): ptr IOleInPlaceUIWindow = cast[ptr IOleInPlaceUIWindow](x) +converter winimConverterIOleInPlaceFrameToIOleWindow*(x: ptr IOleInPlaceFrame): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceFrameToIUnknown*(x: ptr IOleInPlaceFrame): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceObjectToIOleWindow*(x: ptr IOleInPlaceObject): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceObjectToIUnknown*(x: ptr IOleInPlaceObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceSiteToIOleWindow*(x: ptr IOleInPlaceSite): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceSiteToIUnknown*(x: ptr IOleInPlaceSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContinueToIUnknown*(x: ptr IContinue): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectToIUnknown*(x: ptr IViewObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObject2ToIViewObject*(x: ptr IViewObject2): ptr IViewObject = cast[ptr IViewObject](x) +converter winimConverterIViewObject2ToIUnknown*(x: ptr IViewObject2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDropSourceToIUnknown*(x: ptr IDropSource): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDropTargetToIUnknown*(x: ptr IDropTarget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDropSourceNotifyToIUnknown*(x: ptr IDropSourceNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumOLEVERBToIUnknown*(x: ptr IEnumOLEVERB): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIServiceProviderToIUnknown*(x: ptr IServiceProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMImplementationToIDispatch*(x: ptr IXMLDOMImplementation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMImplementationToIUnknown*(x: ptr IXMLDOMImplementation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMNodeToIDispatch*(x: ptr IXMLDOMNode): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMNodeToIUnknown*(x: ptr IXMLDOMNode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMDocumentFragmentToIXMLDOMNode*(x: ptr IXMLDOMDocumentFragment): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMDocumentFragmentToIDispatch*(x: ptr IXMLDOMDocumentFragment): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMDocumentFragmentToIUnknown*(x: ptr IXMLDOMDocumentFragment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMDocumentToIXMLDOMNode*(x: ptr IXMLDOMDocument): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMDocumentToIDispatch*(x: ptr IXMLDOMDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMDocumentToIUnknown*(x: ptr IXMLDOMDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMNodeListToIDispatch*(x: ptr IXMLDOMNodeList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMNodeListToIUnknown*(x: ptr IXMLDOMNodeList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMNamedNodeMapToIDispatch*(x: ptr IXMLDOMNamedNodeMap): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMNamedNodeMapToIUnknown*(x: ptr IXMLDOMNamedNodeMap): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMCharacterDataToIXMLDOMNode*(x: ptr IXMLDOMCharacterData): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMCharacterDataToIDispatch*(x: ptr IXMLDOMCharacterData): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMCharacterDataToIUnknown*(x: ptr IXMLDOMCharacterData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMAttributeToIXMLDOMNode*(x: ptr IXMLDOMAttribute): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMAttributeToIDispatch*(x: ptr IXMLDOMAttribute): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMAttributeToIUnknown*(x: ptr IXMLDOMAttribute): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMElementToIXMLDOMNode*(x: ptr IXMLDOMElement): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMElementToIDispatch*(x: ptr IXMLDOMElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMElementToIUnknown*(x: ptr IXMLDOMElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMTextToIXMLDOMCharacterData*(x: ptr IXMLDOMText): ptr IXMLDOMCharacterData = cast[ptr IXMLDOMCharacterData](x) +converter winimConverterIXMLDOMTextToIXMLDOMNode*(x: ptr IXMLDOMText): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMTextToIDispatch*(x: ptr IXMLDOMText): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMTextToIUnknown*(x: ptr IXMLDOMText): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMCommentToIXMLDOMCharacterData*(x: ptr IXMLDOMComment): ptr IXMLDOMCharacterData = cast[ptr IXMLDOMCharacterData](x) +converter winimConverterIXMLDOMCommentToIXMLDOMNode*(x: ptr IXMLDOMComment): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMCommentToIDispatch*(x: ptr IXMLDOMComment): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMCommentToIUnknown*(x: ptr IXMLDOMComment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMProcessingInstructionToIXMLDOMNode*(x: ptr IXMLDOMProcessingInstruction): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMProcessingInstructionToIDispatch*(x: ptr IXMLDOMProcessingInstruction): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMProcessingInstructionToIUnknown*(x: ptr IXMLDOMProcessingInstruction): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMCDATASectionToIXMLDOMText*(x: ptr IXMLDOMCDATASection): ptr IXMLDOMText = cast[ptr IXMLDOMText](x) +converter winimConverterIXMLDOMCDATASectionToIXMLDOMCharacterData*(x: ptr IXMLDOMCDATASection): ptr IXMLDOMCharacterData = cast[ptr IXMLDOMCharacterData](x) +converter winimConverterIXMLDOMCDATASectionToIXMLDOMNode*(x: ptr IXMLDOMCDATASection): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMCDATASectionToIDispatch*(x: ptr IXMLDOMCDATASection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMCDATASectionToIUnknown*(x: ptr IXMLDOMCDATASection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMDocumentTypeToIXMLDOMNode*(x: ptr IXMLDOMDocumentType): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMDocumentTypeToIDispatch*(x: ptr IXMLDOMDocumentType): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMDocumentTypeToIUnknown*(x: ptr IXMLDOMDocumentType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMNotationToIXMLDOMNode*(x: ptr IXMLDOMNotation): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMNotationToIDispatch*(x: ptr IXMLDOMNotation): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMNotationToIUnknown*(x: ptr IXMLDOMNotation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMEntityToIXMLDOMNode*(x: ptr IXMLDOMEntity): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMEntityToIDispatch*(x: ptr IXMLDOMEntity): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMEntityToIUnknown*(x: ptr IXMLDOMEntity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMEntityReferenceToIXMLDOMNode*(x: ptr IXMLDOMEntityReference): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXMLDOMEntityReferenceToIDispatch*(x: ptr IXMLDOMEntityReference): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMEntityReferenceToIUnknown*(x: ptr IXMLDOMEntityReference): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDOMParseErrorToIDispatch*(x: ptr IXMLDOMParseError): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDOMParseErrorToIUnknown*(x: ptr IXMLDOMParseError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXTLRuntimeToIXMLDOMNode*(x: ptr IXTLRuntime): ptr IXMLDOMNode = cast[ptr IXMLDOMNode](x) +converter winimConverterIXTLRuntimeToIDispatch*(x: ptr IXTLRuntime): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXTLRuntimeToIUnknown*(x: ptr IXTLRuntime): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterXMLDOMDocumentEventsToIDispatch*(x: ptr XMLDOMDocumentEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterXMLDOMDocumentEventsToIUnknown*(x: ptr XMLDOMDocumentEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLHttpRequestToIDispatch*(x: ptr IXMLHttpRequest): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLHttpRequestToIUnknown*(x: ptr IXMLHttpRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDSOControlToIDispatch*(x: ptr IXMLDSOControl): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDSOControlToIUnknown*(x: ptr IXMLDSOControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLElementCollectionToIDispatch*(x: ptr IXMLElementCollection): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLElementCollectionToIUnknown*(x: ptr IXMLElementCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDocumentToIDispatch*(x: ptr IXMLDocument): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDocumentToIUnknown*(x: ptr IXMLDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLDocument2ToIDispatch*(x: ptr IXMLDocument2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLDocument2ToIUnknown*(x: ptr IXMLDocument2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLElementToIDispatch*(x: ptr IXMLElement): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLElementToIUnknown*(x: ptr IXMLElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLElement2ToIDispatch*(x: ptr IXMLElement2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLElement2ToIUnknown*(x: ptr IXMLElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLAttributeToIDispatch*(x: ptr IXMLAttribute): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIXMLAttributeToIUnknown*(x: ptr IXMLAttribute): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIXMLErrorToIUnknown*(x: ptr IXMLError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistMonikerToIUnknown*(x: ptr IPersistMoniker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMonikerPropToIUnknown*(x: ptr IMonikerProp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindProtocolToIUnknown*(x: ptr IBindProtocol): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindingToIUnknown*(x: ptr IBinding): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindStatusCallbackToIUnknown*(x: ptr IBindStatusCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindStatusCallbackExToIBindStatusCallback*(x: ptr IBindStatusCallbackEx): ptr IBindStatusCallback = cast[ptr IBindStatusCallback](x) +converter winimConverterIBindStatusCallbackExToIUnknown*(x: ptr IBindStatusCallbackEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAuthenticateToIUnknown*(x: ptr IAuthenticate): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAuthenticateExToIAuthenticate*(x: ptr IAuthenticateEx): ptr IAuthenticate = cast[ptr IAuthenticate](x) +converter winimConverterIAuthenticateExToIUnknown*(x: ptr IAuthenticateEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHttpNegotiateToIUnknown*(x: ptr IHttpNegotiate): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHttpNegotiate2ToIHttpNegotiate*(x: ptr IHttpNegotiate2): ptr IHttpNegotiate = cast[ptr IHttpNegotiate](x) +converter winimConverterIHttpNegotiate2ToIUnknown*(x: ptr IHttpNegotiate2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHttpNegotiate3ToIHttpNegotiate2*(x: ptr IHttpNegotiate3): ptr IHttpNegotiate2 = cast[ptr IHttpNegotiate2](x) +converter winimConverterIHttpNegotiate3ToIHttpNegotiate*(x: ptr IHttpNegotiate3): ptr IHttpNegotiate = cast[ptr IHttpNegotiate](x) +converter winimConverterIHttpNegotiate3ToIUnknown*(x: ptr IHttpNegotiate3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetFileStreamToIUnknown*(x: ptr IWinInetFileStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWindowForBindingUIToIUnknown*(x: ptr IWindowForBindingUI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICodeInstallToIWindowForBindingUI*(x: ptr ICodeInstall): ptr IWindowForBindingUI = cast[ptr IWindowForBindingUI](x) +converter winimConverterICodeInstallToIUnknown*(x: ptr ICodeInstall): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUriToIUnknown*(x: ptr IUri): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUriContainerToIUnknown*(x: ptr IUriContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUriBuilderToIUnknown*(x: ptr IUriBuilder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUriBuilderFactoryToIUnknown*(x: ptr IUriBuilderFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetInfoToIUnknown*(x: ptr IWinInetInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHttpSecurityToIWindowForBindingUI*(x: ptr IHttpSecurity): ptr IWindowForBindingUI = cast[ptr IWindowForBindingUI](x) +converter winimConverterIHttpSecurityToIUnknown*(x: ptr IHttpSecurity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetHttpInfoToIWinInetInfo*(x: ptr IWinInetHttpInfo): ptr IWinInetInfo = cast[ptr IWinInetInfo](x) +converter winimConverterIWinInetHttpInfoToIUnknown*(x: ptr IWinInetHttpInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetHttpTimeoutsToIUnknown*(x: ptr IWinInetHttpTimeouts): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetCacheHintsToIUnknown*(x: ptr IWinInetCacheHints): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWinInetCacheHints2ToIWinInetCacheHints*(x: ptr IWinInetCacheHints2): ptr IWinInetCacheHints = cast[ptr IWinInetCacheHints](x) +converter winimConverterIWinInetCacheHints2ToIUnknown*(x: ptr IWinInetCacheHints2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindHostToIUnknown*(x: ptr IBindHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetToIUnknown*(x: ptr IInternet): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetBindInfoToIUnknown*(x: ptr IInternetBindInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetBindInfoExToIInternetBindInfo*(x: ptr IInternetBindInfoEx): ptr IInternetBindInfo = cast[ptr IInternetBindInfo](x) +converter winimConverterIInternetBindInfoExToIUnknown*(x: ptr IInternetBindInfoEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolRootToIUnknown*(x: ptr IInternetProtocolRoot): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolToIInternetProtocolRoot*(x: ptr IInternetProtocol): ptr IInternetProtocolRoot = cast[ptr IInternetProtocolRoot](x) +converter winimConverterIInternetProtocolToIUnknown*(x: ptr IInternetProtocol): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolExToIInternetProtocol*(x: ptr IInternetProtocolEx): ptr IInternetProtocol = cast[ptr IInternetProtocol](x) +converter winimConverterIInternetProtocolExToIInternetProtocolRoot*(x: ptr IInternetProtocolEx): ptr IInternetProtocolRoot = cast[ptr IInternetProtocolRoot](x) +converter winimConverterIInternetProtocolExToIUnknown*(x: ptr IInternetProtocolEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolSinkToIUnknown*(x: ptr IInternetProtocolSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolSinkStackableToIUnknown*(x: ptr IInternetProtocolSinkStackable): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetSessionToIUnknown*(x: ptr IInternetSession): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetThreadSwitchToIUnknown*(x: ptr IInternetThreadSwitch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetPriorityToIUnknown*(x: ptr IInternetPriority): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetProtocolInfoToIUnknown*(x: ptr IInternetProtocolInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetSecurityMgrSiteToIUnknown*(x: ptr IInternetSecurityMgrSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetSecurityManagerToIUnknown*(x: ptr IInternetSecurityManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetSecurityManagerExToIInternetSecurityManager*(x: ptr IInternetSecurityManagerEx): ptr IInternetSecurityManager = cast[ptr IInternetSecurityManager](x) +converter winimConverterIInternetSecurityManagerExToIUnknown*(x: ptr IInternetSecurityManagerEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetSecurityManagerEx2ToIInternetSecurityManagerEx*(x: ptr IInternetSecurityManagerEx2): ptr IInternetSecurityManagerEx = cast[ptr IInternetSecurityManagerEx](x) +converter winimConverterIInternetSecurityManagerEx2ToIInternetSecurityManager*(x: ptr IInternetSecurityManagerEx2): ptr IInternetSecurityManager = cast[ptr IInternetSecurityManager](x) +converter winimConverterIInternetSecurityManagerEx2ToIUnknown*(x: ptr IInternetSecurityManagerEx2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIZoneIdentifierToIUnknown*(x: ptr IZoneIdentifier): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetHostSecurityManagerToIUnknown*(x: ptr IInternetHostSecurityManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetZoneManagerToIUnknown*(x: ptr IInternetZoneManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetZoneManagerExToIInternetZoneManager*(x: ptr IInternetZoneManagerEx): ptr IInternetZoneManager = cast[ptr IInternetZoneManager](x) +converter winimConverterIInternetZoneManagerExToIUnknown*(x: ptr IInternetZoneManagerEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInternetZoneManagerEx2ToIInternetZoneManagerEx*(x: ptr IInternetZoneManagerEx2): ptr IInternetZoneManagerEx = cast[ptr IInternetZoneManagerEx](x) +converter winimConverterIInternetZoneManagerEx2ToIInternetZoneManager*(x: ptr IInternetZoneManagerEx2): ptr IInternetZoneManager = cast[ptr IInternetZoneManager](x) +converter winimConverterIInternetZoneManagerEx2ToIUnknown*(x: ptr IInternetZoneManagerEx2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISoftDistExtToIUnknown*(x: ptr ISoftDistExt): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICatalogFileInfoToIUnknown*(x: ptr ICatalogFileInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataFilterToIUnknown*(x: ptr IDataFilter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEncodingFilterFactoryToIUnknown*(x: ptr IEncodingFilterFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWrappedProtocolToIUnknown*(x: ptr IWrappedProtocol): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGetBindHandleToIUnknown*(x: ptr IGetBindHandle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindCallbackRedirectToIUnknown*(x: ptr IBindCallbackRedirect): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyStorageToIUnknown*(x: ptr IPropertyStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertySetStorageToIUnknown*(x: ptr IPropertySetStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumSTATPROPSTGToIUnknown*(x: ptr IEnumSTATPROPSTG): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumSTATPROPSETSTGToIUnknown*(x: ptr IEnumSTATPROPSETSTG): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumConnectionsToIUnknown*(x: ptr IEnumConnections): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIConnectionPointToIUnknown*(x: ptr IConnectionPoint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumConnectionPointsToIUnknown*(x: ptr IEnumConnectionPoints): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIConnectionPointContainerToIUnknown*(x: ptr IConnectionPointContainer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIClassFactory2ToIClassFactory*(x: ptr IClassFactory2): ptr IClassFactory = cast[ptr IClassFactory](x) +converter winimConverterIClassFactory2ToIUnknown*(x: ptr IClassFactory2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProvideClassInfoToIUnknown*(x: ptr IProvideClassInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProvideClassInfo2ToIProvideClassInfo*(x: ptr IProvideClassInfo2): ptr IProvideClassInfo = cast[ptr IProvideClassInfo](x) +converter winimConverterIProvideClassInfo2ToIUnknown*(x: ptr IProvideClassInfo2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProvideMultipleClassInfoToIProvideClassInfo2*(x: ptr IProvideMultipleClassInfo): ptr IProvideClassInfo2 = cast[ptr IProvideClassInfo2](x) +converter winimConverterIProvideMultipleClassInfoToIProvideClassInfo*(x: ptr IProvideMultipleClassInfo): ptr IProvideClassInfo = cast[ptr IProvideClassInfo](x) +converter winimConverterIProvideMultipleClassInfoToIUnknown*(x: ptr IProvideMultipleClassInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleControlToIUnknown*(x: ptr IOleControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleControlSiteToIUnknown*(x: ptr IOleControlSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyPageToIUnknown*(x: ptr IPropertyPage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyPage2ToIPropertyPage*(x: ptr IPropertyPage2): ptr IPropertyPage = cast[ptr IPropertyPage](x) +converter winimConverterIPropertyPage2ToIUnknown*(x: ptr IPropertyPage2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyPageSiteToIUnknown*(x: ptr IPropertyPageSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyNotifySinkToIUnknown*(x: ptr IPropertyNotifySink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISpecifyPropertyPagesToIUnknown*(x: ptr ISpecifyPropertyPages): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistMemoryToIPersist*(x: ptr IPersistMemory): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistMemoryToIUnknown*(x: ptr IPersistMemory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistStreamInitToIPersist*(x: ptr IPersistStreamInit): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistStreamInitToIUnknown*(x: ptr IPersistStreamInit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistPropertyBagToIPersist*(x: ptr IPersistPropertyBag): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistPropertyBagToIUnknown*(x: ptr IPersistPropertyBag): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISimpleFrameSiteToIUnknown*(x: ptr ISimpleFrameSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFontToIUnknown*(x: ptr IFont): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPictureToIUnknown*(x: ptr IPicture): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPicture2ToIUnknown*(x: ptr IPicture2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFontEventsDispToIDispatch*(x: ptr IFontEventsDisp): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIFontEventsDispToIUnknown*(x: ptr IFontEventsDisp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFontDispToIDispatch*(x: ptr IFontDisp): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIFontDispToIUnknown*(x: ptr IFontDisp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPictureDispToIDispatch*(x: ptr IPictureDisp): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIPictureDispToIUnknown*(x: ptr IPictureDisp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceObjectWindowlessToIOleInPlaceObject*(x: ptr IOleInPlaceObjectWindowless): ptr IOleInPlaceObject = cast[ptr IOleInPlaceObject](x) +converter winimConverterIOleInPlaceObjectWindowlessToIOleWindow*(x: ptr IOleInPlaceObjectWindowless): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceObjectWindowlessToIUnknown*(x: ptr IOleInPlaceObjectWindowless): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceSiteExToIOleInPlaceSite*(x: ptr IOleInPlaceSiteEx): ptr IOleInPlaceSite = cast[ptr IOleInPlaceSite](x) +converter winimConverterIOleInPlaceSiteExToIOleWindow*(x: ptr IOleInPlaceSiteEx): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceSiteExToIUnknown*(x: ptr IOleInPlaceSiteEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleInPlaceSiteWindowlessToIOleInPlaceSiteEx*(x: ptr IOleInPlaceSiteWindowless): ptr IOleInPlaceSiteEx = cast[ptr IOleInPlaceSiteEx](x) +converter winimConverterIOleInPlaceSiteWindowlessToIOleInPlaceSite*(x: ptr IOleInPlaceSiteWindowless): ptr IOleInPlaceSite = cast[ptr IOleInPlaceSite](x) +converter winimConverterIOleInPlaceSiteWindowlessToIOleWindow*(x: ptr IOleInPlaceSiteWindowless): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIOleInPlaceSiteWindowlessToIUnknown*(x: ptr IOleInPlaceSiteWindowless): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewObjectExToIViewObject2*(x: ptr IViewObjectEx): ptr IViewObject2 = cast[ptr IViewObject2](x) +converter winimConverterIViewObjectExToIViewObject*(x: ptr IViewObjectEx): ptr IViewObject = cast[ptr IViewObject](x) +converter winimConverterIViewObjectExToIUnknown*(x: ptr IViewObjectEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUndoUnitToIUnknown*(x: ptr IOleUndoUnit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleParentUndoUnitToIOleUndoUnit*(x: ptr IOleParentUndoUnit): ptr IOleUndoUnit = cast[ptr IOleUndoUnit](x) +converter winimConverterIOleParentUndoUnitToIUnknown*(x: ptr IOleParentUndoUnit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumOleUndoUnitsToIUnknown*(x: ptr IEnumOleUndoUnits): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUndoManagerToIUnknown*(x: ptr IOleUndoManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPointerInactiveToIUnknown*(x: ptr IPointerInactive): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithSiteToIUnknown*(x: ptr IObjectWithSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPerPropertyBrowsingToIUnknown*(x: ptr IPerPropertyBrowsing): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyBag2ToIUnknown*(x: ptr IPropertyBag2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistPropertyBag2ToIPersist*(x: ptr IPersistPropertyBag2): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistPropertyBag2ToIUnknown*(x: ptr IPersistPropertyBag2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAdviseSinkExToIAdviseSink*(x: ptr IAdviseSinkEx): ptr IAdviseSink = cast[ptr IAdviseSink](x) +converter winimConverterIAdviseSinkExToIUnknown*(x: ptr IAdviseSinkEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIQuickActivateToIUnknown*(x: ptr IQuickActivate): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumGUIDToIUnknown*(x: ptr IEnumGUID): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumCATEGORYINFOToIUnknown*(x: ptr IEnumCATEGORYINFO): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICatRegisterToIUnknown*(x: ptr ICatRegister): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICatInformationToIUnknown*(x: ptr ICatInformation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleDocumentToIUnknown*(x: ptr IOleDocument): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleDocumentSiteToIUnknown*(x: ptr IOleDocumentSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleDocumentViewToIUnknown*(x: ptr IOleDocumentView): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumOleDocumentViewsToIUnknown*(x: ptr IEnumOleDocumentViews): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContinueCallbackToIUnknown*(x: ptr IContinueCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPrintToIUnknown*(x: ptr IPrint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleCommandTargetToIUnknown*(x: ptr IOleCommandTarget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIZoomEventsToIUnknown*(x: ptr IZoomEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProtectFocusToIUnknown*(x: ptr IProtectFocus): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProtectedModeMenuServicesToIUnknown*(x: ptr IProtectedModeMenuServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebBrowserToIDispatch*(x: ptr IWebBrowser): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebBrowserToIUnknown*(x: ptr IWebBrowser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDWebBrowserEventsToIDispatch*(x: ptr DWebBrowserEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDWebBrowserEventsToIUnknown*(x: ptr DWebBrowserEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebBrowserAppToIWebBrowser*(x: ptr IWebBrowserApp): ptr IWebBrowser = cast[ptr IWebBrowser](x) +converter winimConverterIWebBrowserAppToIDispatch*(x: ptr IWebBrowserApp): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebBrowserAppToIUnknown*(x: ptr IWebBrowserApp): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebBrowser2ToIWebBrowserApp*(x: ptr IWebBrowser2): ptr IWebBrowserApp = cast[ptr IWebBrowserApp](x) +converter winimConverterIWebBrowser2ToIWebBrowser*(x: ptr IWebBrowser2): ptr IWebBrowser = cast[ptr IWebBrowser](x) +converter winimConverterIWebBrowser2ToIDispatch*(x: ptr IWebBrowser2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebBrowser2ToIUnknown*(x: ptr IWebBrowser2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDWebBrowserEvents2ToIDispatch*(x: ptr DWebBrowserEvents2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDWebBrowserEvents2ToIUnknown*(x: ptr DWebBrowserEvents2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDShellWindowsEventsToIDispatch*(x: ptr DShellWindowsEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDShellWindowsEventsToIUnknown*(x: ptr DShellWindowsEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellWindowsToIDispatch*(x: ptr IShellWindows): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellWindowsToIUnknown*(x: ptr IShellWindows): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellUIHelperToIDispatch*(x: ptr IShellUIHelper): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellUIHelperToIUnknown*(x: ptr IShellUIHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellUIHelper2ToIShellUIHelper*(x: ptr IShellUIHelper2): ptr IShellUIHelper = cast[ptr IShellUIHelper](x) +converter winimConverterIShellUIHelper2ToIDispatch*(x: ptr IShellUIHelper2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellUIHelper2ToIUnknown*(x: ptr IShellUIHelper2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDShellNameSpaceEventsToIDispatch*(x: ptr DShellNameSpaceEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDShellNameSpaceEventsToIUnknown*(x: ptr DShellNameSpaceEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFavoritesNameSpaceToIDispatch*(x: ptr IShellFavoritesNameSpace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellFavoritesNameSpaceToIUnknown*(x: ptr IShellFavoritesNameSpace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellNameSpaceToIShellFavoritesNameSpace*(x: ptr IShellNameSpace): ptr IShellFavoritesNameSpace = cast[ptr IShellFavoritesNameSpace](x) +converter winimConverterIShellNameSpaceToIDispatch*(x: ptr IShellNameSpace): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellNameSpaceToIUnknown*(x: ptr IShellNameSpace): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIScriptErrorListToIDispatch*(x: ptr IScriptErrorList): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIScriptErrorListToIUnknown*(x: ptr IScriptErrorList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchToIDispatch*(x: ptr ISearch): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISearchToIUnknown*(x: ptr ISearch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchesToIDispatch*(x: ptr ISearches): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISearchesToIUnknown*(x: ptr ISearches): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchAssistantOCToIDispatch*(x: ptr ISearchAssistantOC): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISearchAssistantOCToIUnknown*(x: ptr ISearchAssistantOC): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchAssistantOC2ToISearchAssistantOC*(x: ptr ISearchAssistantOC2): ptr ISearchAssistantOC = cast[ptr ISearchAssistantOC](x) +converter winimConverterISearchAssistantOC2ToIDispatch*(x: ptr ISearchAssistantOC2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISearchAssistantOC2ToIUnknown*(x: ptr ISearchAssistantOC2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchAssistantOC3ToISearchAssistantOC2*(x: ptr ISearchAssistantOC3): ptr ISearchAssistantOC2 = cast[ptr ISearchAssistantOC2](x) +converter winimConverterISearchAssistantOC3ToISearchAssistantOC*(x: ptr ISearchAssistantOC3): ptr ISearchAssistantOC = cast[ptr ISearchAssistantOC](x) +converter winimConverterISearchAssistantOC3ToIDispatch*(x: ptr ISearchAssistantOC3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterISearchAssistantOC3ToIUnknown*(x: ptr ISearchAssistantOC3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterSearchAssistantEventsToIDispatch*(x: ptr SearchAssistantEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterSearchAssistantEventsToIUnknown*(x: ptr SearchAssistantEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRichChunkToIUnknown*(x: ptr IRichChunk): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIConditionToIPersistStream*(x: ptr ICondition): ptr IPersistStream = cast[ptr IPersistStream](x) +converter winimConverterIConditionToIPersist*(x: ptr ICondition): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIConditionToIUnknown*(x: ptr ICondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICondition2ToICondition*(x: ptr ICondition2): ptr ICondition = cast[ptr ICondition](x) +converter winimConverterICondition2ToIPersistStream*(x: ptr ICondition2): ptr IPersistStream = cast[ptr IPersistStream](x) +converter winimConverterICondition2ToIPersist*(x: ptr ICondition2): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterICondition2ToIUnknown*(x: ptr ICondition2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithFileToIUnknown*(x: ptr IInitializeWithFile): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithStreamToIUnknown*(x: ptr IInitializeWithStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyStoreToIUnknown*(x: ptr IPropertyStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINamedPropertyStoreToIUnknown*(x: ptr INamedPropertyStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithPropertyKeyToIUnknown*(x: ptr IObjectWithPropertyKey): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyChangeToIObjectWithPropertyKey*(x: ptr IPropertyChange): ptr IObjectWithPropertyKey = cast[ptr IObjectWithPropertyKey](x) +converter winimConverterIPropertyChangeToIUnknown*(x: ptr IPropertyChange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyChangeArrayToIUnknown*(x: ptr IPropertyChangeArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyStoreCapabilitiesToIUnknown*(x: ptr IPropertyStoreCapabilities): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyStoreCacheToIPropertyStore*(x: ptr IPropertyStoreCache): ptr IPropertyStore = cast[ptr IPropertyStore](x) +converter winimConverterIPropertyStoreCacheToIUnknown*(x: ptr IPropertyStoreCache): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyEnumTypeToIUnknown*(x: ptr IPropertyEnumType): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyEnumType2ToIPropertyEnumType*(x: ptr IPropertyEnumType2): ptr IPropertyEnumType = cast[ptr IPropertyEnumType](x) +converter winimConverterIPropertyEnumType2ToIUnknown*(x: ptr IPropertyEnumType2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyEnumTypeListToIUnknown*(x: ptr IPropertyEnumTypeList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescriptionToIUnknown*(x: ptr IPropertyDescription): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescription2ToIPropertyDescription*(x: ptr IPropertyDescription2): ptr IPropertyDescription = cast[ptr IPropertyDescription](x) +converter winimConverterIPropertyDescription2ToIUnknown*(x: ptr IPropertyDescription2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescriptionAliasInfoToIPropertyDescription*(x: ptr IPropertyDescriptionAliasInfo): ptr IPropertyDescription = cast[ptr IPropertyDescription](x) +converter winimConverterIPropertyDescriptionAliasInfoToIUnknown*(x: ptr IPropertyDescriptionAliasInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescriptionSearchInfoToIPropertyDescription*(x: ptr IPropertyDescriptionSearchInfo): ptr IPropertyDescription = cast[ptr IPropertyDescription](x) +converter winimConverterIPropertyDescriptionSearchInfoToIUnknown*(x: ptr IPropertyDescriptionSearchInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescriptionRelatedPropertyInfoToIPropertyDescription*(x: ptr IPropertyDescriptionRelatedPropertyInfo): ptr IPropertyDescription = cast[ptr IPropertyDescription](x) +converter winimConverterIPropertyDescriptionRelatedPropertyInfoToIUnknown*(x: ptr IPropertyDescriptionRelatedPropertyInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertySystemToIUnknown*(x: ptr IPropertySystem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyDescriptionListToIUnknown*(x: ptr IPropertyDescriptionList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyStoreFactoryToIUnknown*(x: ptr IPropertyStoreFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDelayedPropertyStoreFactoryToIPropertyStoreFactory*(x: ptr IDelayedPropertyStoreFactory): ptr IPropertyStoreFactory = cast[ptr IPropertyStoreFactory](x) +converter winimConverterIDelayedPropertyStoreFactoryToIUnknown*(x: ptr IDelayedPropertyStoreFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistSerializedPropStorageToIUnknown*(x: ptr IPersistSerializedPropStorage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistSerializedPropStorage2ToIPersistSerializedPropStorage*(x: ptr IPersistSerializedPropStorage2): ptr IPersistSerializedPropStorage = cast[ptr IPersistSerializedPropStorage](x) +converter winimConverterIPersistSerializedPropStorage2ToIUnknown*(x: ptr IPersistSerializedPropStorage2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertySystemChangeNotifyToIUnknown*(x: ptr IPropertySystemChangeNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICreateObjectToIUnknown*(x: ptr ICreateObject): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + proc URLOpenStream*(P1: LPUNKNOWN, P2: LPCWSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenStreamW".} + proc URLOpenPullStream*(P1: LPUNKNOWN, P2: LPCWSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenPullStreamW".} + proc URLDownloadToFile*(P1: LPUNKNOWN, P2: LPCWSTR, P3: LPCWSTR, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLDownloadToFileW".} + proc URLDownloadToCacheFile*(P1: LPUNKNOWN, P2: LPCWSTR, P3: LPWSTR, P4: DWORD, P5: DWORD, P6: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLDownloadToCacheFileW".} + proc URLOpenBlockingStream*(P1: LPUNKNOWN, P2: LPCWSTR, P3: ptr LPSTREAM, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenBlockingStreamW".} + proc IsLoggingEnabled*(pwszUrl: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "urlmon", importc: "IsLoggingEnabledW".} +when winimAnsi: + proc URLOpenStream*(P1: LPUNKNOWN, P2: LPCSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenStreamA".} + proc URLOpenPullStream*(P1: LPUNKNOWN, P2: LPCSTR, P3: DWORD, P4: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenPullStreamA".} + proc URLDownloadToFile*(P1: LPUNKNOWN, P2: LPCSTR, P3: LPCSTR, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLDownloadToFileA".} + proc URLDownloadToCacheFile*(P1: LPUNKNOWN, P2: LPCSTR, P3: LPSTR, P4: DWORD, P5: DWORD, P6: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLDownloadToCacheFileA".} + proc URLOpenBlockingStream*(P1: LPUNKNOWN, P2: LPCSTR, P3: ptr LPSTREAM, P4: DWORD, P5: LPBINDSTATUSCALLBACK): HRESULT {.winapi, stdcall, dynlib: "urlmon", importc: "URLOpenBlockingStreamA".} + proc IsLoggingEnabled*(pszUrl: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "urlmon", importc: "IsLoggingEnabledA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/objext.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/objext.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1932 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import winuser +import objbase +import commctrl +import commdlg +#include +#include +#include +#include +#include +type + AnnoScope* = int32 + OLE_XPOS_PIXELS* = int32 + OLE_YPOS_PIXELS* = int32 + OLE_XSIZE_PIXELS* = int32 + OLE_YSIZE_PIXELS* = int32 + OLE_TRISTATE* = int32 + SCRIPTLANGUAGEVERSION* = int32 + TSCRIPTSTATE* = int32 + SCRIPTTRACEINFO* = int32 + SCRIPTTHREADSTATE* = int32 + SCRIPTGCTYPE* = int32 + SCRIPTUICITEM* = int32 + SCRIPTUICHANDLING* = int32 + OLEUIPASTEFLAG* = int32 + SCRIPTTHREADID* = DWORD + MSAAMENUINFO* {.pure.} = object + dwMSAASignature*: DWORD + cchWText*: DWORD + pszWText*: LPWSTR + LPMSAAMENUINFO* = ptr MSAAMENUINFO + IAccessible* {.pure.} = object + lpVtbl*: ptr IAccessibleVtbl + IAccessibleVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_accParent*: proc(self: ptr IAccessible, ppdispParent: ptr ptr IDispatch): HRESULT {.stdcall.} + get_accChildCount*: proc(self: ptr IAccessible, pcountChildren: ptr LONG): HRESULT {.stdcall.} + get_accChild*: proc(self: ptr IAccessible, varChildID: VARIANT, ppdispChild: ptr ptr IDispatch): HRESULT {.stdcall.} + get_accName*: proc(self: ptr IAccessible, varID: VARIANT, pszName: ptr BSTR): HRESULT {.stdcall.} + get_accValue*: proc(self: ptr IAccessible, varID: VARIANT, pszValue: ptr BSTR): HRESULT {.stdcall.} + get_accDescription*: proc(self: ptr IAccessible, varID: VARIANT, pszDescription: ptr BSTR): HRESULT {.stdcall.} + get_accRole*: proc(self: ptr IAccessible, varID: VARIANT, pvarRole: ptr VARIANT): HRESULT {.stdcall.} + get_accState*: proc(self: ptr IAccessible, varID: VARIANT, pvarState: ptr VARIANT): HRESULT {.stdcall.} + get_accHelp*: proc(self: ptr IAccessible, varID: VARIANT, pszHelp: ptr BSTR): HRESULT {.stdcall.} + get_accHelpTopic*: proc(self: ptr IAccessible, pszHelpFile: ptr BSTR, varID: VARIANT, pidTopic: ptr LONG): HRESULT {.stdcall.} + get_accKeyboardShortcut*: proc(self: ptr IAccessible, varID: VARIANT, pszKeyboardShortcut: ptr BSTR): HRESULT {.stdcall.} + get_accFocus*: proc(self: ptr IAccessible, pvarID: ptr VARIANT): HRESULT {.stdcall.} + get_accSelection*: proc(self: ptr IAccessible, pvarID: ptr VARIANT): HRESULT {.stdcall.} + get_accDefaultAction*: proc(self: ptr IAccessible, varID: VARIANT, pszDefaultAction: ptr BSTR): HRESULT {.stdcall.} + accSelect*: proc(self: ptr IAccessible, flagsSelect: LONG, varID: VARIANT): HRESULT {.stdcall.} + accLocation*: proc(self: ptr IAccessible, pxLeft: ptr LONG, pyTop: ptr LONG, pcxWidth: ptr LONG, pcyHeight: ptr LONG, varID: VARIANT): HRESULT {.stdcall.} + accNavigate*: proc(self: ptr IAccessible, navDir: LONG, varStart: VARIANT, pvarEnd: ptr VARIANT): HRESULT {.stdcall.} + accHitTest*: proc(self: ptr IAccessible, xLeft: LONG, yTop: LONG, pvarID: ptr VARIANT): HRESULT {.stdcall.} + accDoDefaultAction*: proc(self: ptr IAccessible, varID: VARIANT): HRESULT {.stdcall.} + put_accName*: proc(self: ptr IAccessible, varID: VARIANT, pszName: BSTR): HRESULT {.stdcall.} + put_accValue*: proc(self: ptr IAccessible, varID: VARIANT, pszValue: BSTR): HRESULT {.stdcall.} + LPACCESSIBLE* = ptr IAccessible + IAccessibleHandler* {.pure.} = object + lpVtbl*: ptr IAccessibleHandlerVtbl + IAccessibleHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AccessibleObjectFromID*: proc(self: ptr IAccessibleHandler, hwnd: LONG, lObjectID: LONG, pIAccessible: ptr LPACCESSIBLE): HRESULT {.stdcall.} + LPACCESSIBLEHANDLER* = ptr IAccessibleHandler + MSAAPROPID* = GUID + IObjectSafety* {.pure.} = object + lpVtbl*: ptr IObjectSafetyVtbl + IObjectSafetyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetInterfaceSafetyOptions*: proc(self: ptr IObjectSafety, riid: REFIID, pdwSupportedOptions: ptr DWORD, pdwEnabledOptions: ptr DWORD): HRESULT {.stdcall.} + SetInterfaceSafetyOptions*: proc(self: ptr IObjectSafety, riid: REFIID, dwOptionSetMask: DWORD, dwEnabledOptions: DWORD): HRESULT {.stdcall.} + LPOBJECTSAFETY* = ptr IObjectSafety + OCPFIPARAMS* {.pure.} = object + cbStructSize*: ULONG + hWndOwner*: HWND + x*: int32 + y*: int32 + lpszCaption*: LPCOLESTR + cObjects*: ULONG + lplpUnk*: ptr LPUNKNOWN + cPages*: ULONG + lpPages*: ptr CLSID + lcid*: LCID + dispidInitialProperty*: DISPID + LPOCPFIPARAMS* = ptr OCPFIPARAMS + FONTDESC* {.pure.} = object + cbSizeofstruct*: UINT + lpstrName*: LPOLESTR + cySize*: CY + sWeight*: SHORT + sCharset*: SHORT + fItalic*: WINBOOL + fUnderline*: WINBOOL + fStrikethrough*: WINBOOL + LPFONTDESC* = ptr FONTDESC + PICTDESC_UNION1_bmp* {.pure.} = object + hbitmap*: HBITMAP + hpal*: HPALETTE + PICTDESC_UNION1_wmf* {.pure.} = object + hmeta*: HMETAFILE + xExt*: int32 + yExt*: int32 + PICTDESC_UNION1_icon* {.pure.} = object + hicon*: HICON + PICTDESC_UNION1_emf* {.pure.} = object + hemf*: HENHMETAFILE + PICTDESC_UNION1* {.pure, union.} = object + bmp*: PICTDESC_UNION1_bmp + wmf*: PICTDESC_UNION1_wmf + icon*: PICTDESC_UNION1_icon + emf*: PICTDESC_UNION1_emf + PICTDESC* {.pure.} = object + cbSizeofstruct*: UINT + picType*: UINT + union1*: PICTDESC_UNION1 + LPPICTDESC* = ptr PICTDESC + OLE_XPOS_CONTAINER* = float32 + OLE_YPOS_CONTAINER* = float32 + OLE_XSIZE_CONTAINER* = float32 + OLE_YSIZE_CONTAINER* = float32 + OLE_OPTEXCLUSIVE* = VARIANT_BOOL + OLE_CANCELBOOL* = VARIANT_BOOL + OLE_ENABLEDEFAULTBOOL* = VARIANT_BOOL + IActiveScriptParse64* {.pure.} = object + lpVtbl*: ptr IActiveScriptParse64Vtbl + IActiveScriptParse64Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitNew*: proc(self: ptr IActiveScriptParse64): HRESULT {.stdcall.} + AddScriptlet*: proc(self: ptr IActiveScriptParse64, pstrDefaultName: LPCOLESTR, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, pstrSubItemName: LPCOLESTR, pstrEventName: LPCOLESTR, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, pbstrName: ptr BSTR, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} + ParseScriptText*: proc(self: ptr IActiveScriptParse64, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} +when winimCpu64: + type + IActiveScriptParse* = IActiveScriptParse64 +type + IActiveScriptParse32* {.pure.} = object + lpVtbl*: ptr IActiveScriptParse32Vtbl + IActiveScriptParse32Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitNew*: proc(self: ptr IActiveScriptParse32): HRESULT {.stdcall.} + AddScriptlet*: proc(self: ptr IActiveScriptParse32, pstrDefaultName: LPCOLESTR, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, pstrSubItemName: LPCOLESTR, pstrEventName: LPCOLESTR, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, pbstrName: ptr BSTR, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} + ParseScriptText*: proc(self: ptr IActiveScriptParse32, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} +when winimCpu32: + type + IActiveScriptParse* = IActiveScriptParse32 +type + PIActiveScriptParse* = ptr IActiveScriptParse + IActiveScriptParseProcedureOld64* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedureOld64Vtbl + IActiveScriptParseProcedureOld64Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseProcedureText*: proc(self: ptr IActiveScriptParseProcedureOld64, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.stdcall.} +when winimCpu64: + type + IActiveScriptParseProcedureOld* = IActiveScriptParseProcedureOld64 +type + IActiveScriptParseProcedureOld32* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedureOld32Vtbl + IActiveScriptParseProcedureOld32Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseProcedureText*: proc(self: ptr IActiveScriptParseProcedureOld32, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.stdcall.} +when winimCpu32: + type + IActiveScriptParseProcedureOld* = IActiveScriptParseProcedureOld32 +type + PIActiveScriptParseProcedureOld* = ptr IActiveScriptParseProcedureOld + IActiveScriptParseProcedure64* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedure64Vtbl + IActiveScriptParseProcedure64Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseProcedureText*: proc(self: ptr IActiveScriptParseProcedure64, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrProcedureName: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.stdcall.} +when winimCpu64: + type + IActiveScriptParseProcedure* = IActiveScriptParseProcedure64 +type + IActiveScriptParseProcedure32* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedure32Vtbl + IActiveScriptParseProcedure32Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseProcedureText*: proc(self: ptr IActiveScriptParseProcedure32, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrProcedureName: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.stdcall.} +when winimCpu32: + type + IActiveScriptParseProcedure* = IActiveScriptParseProcedure32 +type + PIActiveScriptParseProcedure* = ptr IActiveScriptParseProcedure + IActiveScriptParseProcedure2_64* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedure2_64Vtbl + IActiveScriptParseProcedure2_64Vtbl* {.pure, inheritable.} = object of IActiveScriptParseProcedure64Vtbl +when winimCpu64: + type + IActiveScriptParseProcedure2* = IActiveScriptParseProcedure2_64 +type + IActiveScriptParseProcedure2_32* {.pure.} = object + lpVtbl*: ptr IActiveScriptParseProcedure2_32Vtbl + IActiveScriptParseProcedure2_32Vtbl* {.pure, inheritable.} = object of IActiveScriptParseProcedure32Vtbl +when winimCpu32: + type + IActiveScriptParseProcedure2* = IActiveScriptParseProcedure2_32 +type + PIActiveScriptParseProcedure2* = ptr IActiveScriptParseProcedure2 + LPFNOLEUIHOOK* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): UINT {.stdcall.} + TOLEUIINSERTOBJECTW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + clsid*: CLSID + lpszFile*: LPWSTR + cchFile*: UINT + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + iid*: IID + oleRender*: DWORD + lpFormatEtc*: LPFORMATETC + lpIOleClientSite*: LPOLECLIENTSITE + lpIStorage*: LPSTORAGE + ppvObj*: ptr LPVOID + sc*: SCODE + hMetaPict*: HGLOBAL + POLEUIINSERTOBJECTW* = ptr TOLEUIINSERTOBJECTW + LPOLEUIINSERTOBJECTW* = ptr TOLEUIINSERTOBJECTW + TOLEUIINSERTOBJECTA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + clsid*: CLSID + lpszFile*: LPSTR + cchFile*: UINT + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + iid*: IID + oleRender*: DWORD + lpFormatEtc*: LPFORMATETC + lpIOleClientSite*: LPOLECLIENTSITE + lpIStorage*: LPSTORAGE + ppvObj*: ptr LPVOID + sc*: SCODE + hMetaPict*: HGLOBAL + POLEUIINSERTOBJECTA* = ptr TOLEUIINSERTOBJECTA + LPOLEUIINSERTOBJECTA* = ptr TOLEUIINSERTOBJECTA + OLEUIPASTEENTRYW* {.pure.} = object + fmtetc*: FORMATETC + lpstrFormatName*: LPCWSTR + lpstrResultText*: LPCWSTR + dwFlags*: DWORD + dwScratchSpace*: DWORD + POLEUIPASTEENTRYW* = ptr OLEUIPASTEENTRYW + LPOLEUIPASTEENTRYW* = ptr OLEUIPASTEENTRYW + OLEUIPASTEENTRYA* {.pure.} = object + fmtetc*: FORMATETC + lpstrFormatName*: LPCSTR + lpstrResultText*: LPCSTR + dwFlags*: DWORD + dwScratchSpace*: DWORD + POLEUIPASTEENTRYA* = ptr OLEUIPASTEENTRYA + LPOLEUIPASTEENTRYA* = ptr OLEUIPASTEENTRYA + TOLEUIPASTESPECIALW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + lpSrcDataObj*: LPDATAOBJECT + arrPasteEntries*: LPOLEUIPASTEENTRYW + cPasteEntries*: int32 + arrLinkTypes*: ptr UINT + cLinkTypes*: int32 + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + nSelectedIndex*: int32 + fLink*: WINBOOL + hMetaPict*: HGLOBAL + sizel*: SIZEL + POLEUIPASTESPECIALW* = ptr TOLEUIPASTESPECIALW + LPOLEUIPASTESPECIALW* = ptr TOLEUIPASTESPECIALW + TOLEUIPASTESPECIALA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + lpSrcDataObj*: LPDATAOBJECT + arrPasteEntries*: LPOLEUIPASTEENTRYA + cPasteEntries*: int32 + arrLinkTypes*: ptr UINT + cLinkTypes*: int32 + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + nSelectedIndex*: int32 + fLink*: WINBOOL + hMetaPict*: HGLOBAL + sizel*: SIZEL + POLEUIPASTESPECIALA* = ptr TOLEUIPASTESPECIALA + LPOLEUIPASTESPECIALA* = ptr TOLEUIPASTESPECIALA + IOleUILinkContainerW* {.pure.} = object + lpVtbl*: ptr IOleUILinkContainerWVtbl + IOleUILinkContainerWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNextLink*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD): DWORD {.stdcall.} + SetLinkUpdateOptions*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD, dwUpdateOpt: DWORD): HRESULT {.stdcall.} + GetLinkUpdateOptions*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD, lpdwUpdateOpt: ptr DWORD): HRESULT {.stdcall.} + SetLinkSource*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD, lpszDisplayName: LPWSTR, lenFileName: ULONG, pchEaten: ptr ULONG, fValidateSource: WINBOOL): HRESULT {.stdcall.} + GetLinkSource*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD, lplpszDisplayName: ptr LPWSTR, lplenFileName: ptr ULONG, lplpszFullLinkType: ptr LPWSTR, lplpszShortLinkType: ptr LPWSTR, lpfSourceAvailable: ptr WINBOOL, lpfIsSelected: ptr WINBOOL): HRESULT {.stdcall.} + OpenLinkSource*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD): HRESULT {.stdcall.} + UpdateLink*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD, fErrorMessage: WINBOOL, fReserved: WINBOOL): HRESULT {.stdcall.} + CancelLink*: proc(self: ptr IOleUILinkContainerW, dwLink: DWORD): HRESULT {.stdcall.} + LPOLEUILINKCONTAINERW* = ptr IOleUILinkContainerW + IOleUILinkContainerA* {.pure.} = object + lpVtbl*: ptr IOleUILinkContainerAVtbl + IOleUILinkContainerAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNextLink*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD): DWORD {.stdcall.} + SetLinkUpdateOptions*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD, dwUpdateOpt: DWORD): HRESULT {.stdcall.} + GetLinkUpdateOptions*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD, lpdwUpdateOpt: ptr DWORD): HRESULT {.stdcall.} + SetLinkSource*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD, lpszDisplayName: LPSTR, lenFileName: ULONG, pchEaten: ptr ULONG, fValidateSource: WINBOOL): HRESULT {.stdcall.} + GetLinkSource*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD, lplpszDisplayName: ptr LPSTR, lplenFileName: ptr ULONG, lplpszFullLinkType: ptr LPSTR, lplpszShortLinkType: ptr LPSTR, lpfSourceAvailable: ptr WINBOOL, lpfIsSelected: ptr WINBOOL): HRESULT {.stdcall.} + OpenLinkSource*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD): HRESULT {.stdcall.} + UpdateLink*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD, fErrorMessage: WINBOOL, fReserved: WINBOOL): HRESULT {.stdcall.} + CancelLink*: proc(self: ptr IOleUILinkContainerA, dwLink: DWORD): HRESULT {.stdcall.} + LPOLEUILINKCONTAINERA* = ptr IOleUILinkContainerA + TOLEUIEDITLINKSW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + lpOleUILinkContainer*: LPOLEUILINKCONTAINERW + POLEUIEDITLINKSW* = ptr TOLEUIEDITLINKSW + LPOLEUIEDITLINKSW* = ptr TOLEUIEDITLINKSW + TOLEUIEDITLINKSA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + lpOleUILinkContainer*: LPOLEUILINKCONTAINERA + POLEUIEDITLINKSA* = ptr TOLEUIEDITLINKSA + LPOLEUIEDITLINKSA* = ptr TOLEUIEDITLINKSA + TOLEUICHANGEICONW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + hMetaPict*: HGLOBAL + clsid*: CLSID + szIconExe*: array[MAX_PATH, WCHAR] + cchIconExe*: int32 + POLEUICHANGEICONW* = ptr TOLEUICHANGEICONW + LPOLEUICHANGEICONW* = ptr TOLEUICHANGEICONW + TOLEUICHANGEICONA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + hMetaPict*: HGLOBAL + clsid*: CLSID + szIconExe*: array[MAX_PATH, CHAR] + cchIconExe*: int32 + POLEUICHANGEICONA* = ptr TOLEUICHANGEICONA + LPOLEUICHANGEICONA* = ptr TOLEUICHANGEICONA + TOLEUICONVERTW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + clsid*: CLSID + clsidConvertDefault*: CLSID + clsidActivateDefault*: CLSID + clsidNew*: CLSID + dvAspect*: DWORD + wFormat*: WORD + fIsLinkedObject*: WINBOOL + hMetaPict*: HGLOBAL + lpszUserType*: LPWSTR + fObjectsIconChanged*: WINBOOL + lpszDefLabel*: LPWSTR + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + POLEUICONVERTW* = ptr TOLEUICONVERTW + LPOLEUICONVERTW* = ptr TOLEUICONVERTW + TOLEUICONVERTA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + clsid*: CLSID + clsidConvertDefault*: CLSID + clsidActivateDefault*: CLSID + clsidNew*: CLSID + dvAspect*: DWORD + wFormat*: WORD + fIsLinkedObject*: WINBOOL + hMetaPict*: HGLOBAL + lpszUserType*: LPSTR + fObjectsIconChanged*: WINBOOL + lpszDefLabel*: LPSTR + cClsidExclude*: UINT + lpClsidExclude*: LPCLSID + POLEUICONVERTA* = ptr TOLEUICONVERTA + LPOLEUICONVERTA* = ptr TOLEUICONVERTA + TOLEUIBUSYW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + hTask*: HTASK + lphWndDialog*: ptr HWND + POLEUIBUSYW* = ptr TOLEUIBUSYW + LPOLEUIBUSYW* = ptr TOLEUIBUSYW + TOLEUIBUSYA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + hTask*: HTASK + lphWndDialog*: ptr HWND + POLEUIBUSYA* = ptr TOLEUIBUSYA + LPOLEUIBUSYA* = ptr TOLEUIBUSYA + TOLEUICHANGESOURCEW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCWSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCWSTR + hResource*: HRSRC + lpOFN*: ptr OPENFILENAMEW + dwReserved1*: array[4, DWORD] + lpOleUILinkContainer*: LPOLEUILINKCONTAINERW + dwLink*: DWORD + lpszDisplayName*: LPWSTR + nFileLength*: ULONG + lpszFrom*: LPWSTR + lpszTo*: LPWSTR + POLEUICHANGESOURCEW* = ptr TOLEUICHANGESOURCEW + LPOLEUICHANGESOURCEW* = ptr TOLEUICHANGESOURCEW + TOLEUICHANGESOURCEA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + hWndOwner*: HWND + lpszCaption*: LPCSTR + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + hInstance*: HINSTANCE + lpszTemplate*: LPCSTR + hResource*: HRSRC + lpOFN*: ptr OPENFILENAMEA + dwReserved1*: array[4, DWORD] + lpOleUILinkContainer*: LPOLEUILINKCONTAINERA + dwLink*: DWORD + lpszDisplayName*: LPSTR + nFileLength*: ULONG + lpszFrom*: LPSTR + lpszTo*: LPSTR + POLEUICHANGESOURCEA* = ptr TOLEUICHANGESOURCEA + LPOLEUICHANGESOURCEA* = ptr TOLEUICHANGESOURCEA + IOleUIObjInfoW* {.pure.} = object + lpVtbl*: ptr IOleUIObjInfoWVtbl + IOleUIObjInfoWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetObjectInfo*: proc(self: ptr IOleUIObjInfoW, dwObject: DWORD, lpdwObjSize: ptr DWORD, lplpszLabel: ptr LPWSTR, lplpszType: ptr LPWSTR, lplpszShortType: ptr LPWSTR, lplpszLocation: ptr LPWSTR): HRESULT {.stdcall.} + GetConvertInfo*: proc(self: ptr IOleUIObjInfoW, dwObject: DWORD, lpClassID: ptr CLSID, lpwFormat: ptr WORD, lpConvertDefaultClassID: ptr CLSID, lplpClsidExclude: ptr LPCLSID, lpcClsidExclude: ptr UINT): HRESULT {.stdcall.} + ConvertObject*: proc(self: ptr IOleUIObjInfoW, dwObject: DWORD, clsidNew: REFCLSID): HRESULT {.stdcall.} + GetViewInfo*: proc(self: ptr IOleUIObjInfoW, dwObject: DWORD, phMetaPict: ptr HGLOBAL, pdvAspect: ptr DWORD, pnCurrentScale: ptr int32): HRESULT {.stdcall.} + SetViewInfo*: proc(self: ptr IOleUIObjInfoW, dwObject: DWORD, hMetaPict: HGLOBAL, dvAspect: DWORD, nCurrentScale: int32, bRelativeToOrig: WINBOOL): HRESULT {.stdcall.} + LPOLEUIOBJINFOW* = ptr IOleUIObjInfoW + IOleUIObjInfoA* {.pure.} = object + lpVtbl*: ptr IOleUIObjInfoAVtbl + IOleUIObjInfoAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetObjectInfo*: proc(self: ptr IOleUIObjInfoA, dwObject: DWORD, lpdwObjSize: ptr DWORD, lplpszLabel: ptr LPSTR, lplpszType: ptr LPSTR, lplpszShortType: ptr LPSTR, lplpszLocation: ptr LPSTR): HRESULT {.stdcall.} + GetConvertInfo*: proc(self: ptr IOleUIObjInfoA, dwObject: DWORD, lpClassID: ptr CLSID, lpwFormat: ptr WORD, lpConvertDefaultClassID: ptr CLSID, lplpClsidExclude: ptr LPCLSID, lpcClsidExclude: ptr UINT): HRESULT {.stdcall.} + ConvertObject*: proc(self: ptr IOleUIObjInfoA, dwObject: DWORD, clsidNew: REFCLSID): HRESULT {.stdcall.} + GetViewInfo*: proc(self: ptr IOleUIObjInfoA, dwObject: DWORD, phMetaPict: ptr HGLOBAL, pdvAspect: ptr DWORD, pnCurrentScale: ptr int32): HRESULT {.stdcall.} + SetViewInfo*: proc(self: ptr IOleUIObjInfoA, dwObject: DWORD, hMetaPict: HGLOBAL, dvAspect: DWORD, nCurrentScale: int32, bRelativeToOrig: WINBOOL): HRESULT {.stdcall.} + LPOLEUIOBJINFOA* = ptr IOleUIObjInfoA + IOleUILinkInfoW* {.pure.} = object + lpVtbl*: ptr IOleUILinkInfoWVtbl + IOleUILinkInfoWVtbl* {.pure, inheritable.} = object of IOleUILinkContainerWVtbl + GetLastUpdate*: proc(self: ptr IOleUILinkInfoW, dwLink: DWORD, lpLastUpdate: ptr FILETIME): HRESULT {.stdcall.} + LPOLEUILINKINFOW* = ptr IOleUILinkInfoW + IOleUILinkInfoA* {.pure.} = object + lpVtbl*: ptr IOleUILinkInfoAVtbl + IOleUILinkInfoAVtbl* {.pure, inheritable.} = object of IOleUILinkContainerAVtbl + GetLastUpdate*: proc(self: ptr IOleUILinkInfoA, dwLink: DWORD, lpLastUpdate: ptr FILETIME): HRESULT {.stdcall.} + LPOLEUILINKINFOA* = ptr IOleUILinkInfoA + LPOLEUIGNRLPROPSW* = ptr OLEUIGNRLPROPSW + OLEUIVIEWPROPSW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSW + nScaleMin*: int32 + nScaleMax*: int32 + LPOLEUIVIEWPROPSW* = ptr OLEUIVIEWPROPSW + OLEUILINKPROPSW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSW + LPOLEUILINKPROPSW* = ptr OLEUILINKPROPSW + OLEUIOBJECTPROPSW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + lpPS*: LPPROPSHEETHEADERW + dwObject*: DWORD + lpObjInfo*: LPOLEUIOBJINFOW + dwLink*: DWORD + lpLinkInfo*: LPOLEUILINKINFOW + lpGP*: LPOLEUIGNRLPROPSW + lpVP*: LPOLEUIVIEWPROPSW + lpLP*: LPOLEUILINKPROPSW + OLEUIGNRLPROPSW* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSW + POLEUIGNRLPROPSW* = ptr OLEUIGNRLPROPSW + LPOLEUIGNRLPROPSA* = ptr OLEUIGNRLPROPSA + OLEUIVIEWPROPSA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSA + nScaleMin*: int32 + nScaleMax*: int32 + LPOLEUIVIEWPROPSA* = ptr OLEUIVIEWPROPSA + OLEUILINKPROPSA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSA + LPOLEUILINKPROPSA* = ptr OLEUILINKPROPSA + OLEUIOBJECTPROPSA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + lpPS*: LPPROPSHEETHEADERA + dwObject*: DWORD + lpObjInfo*: LPOLEUIOBJINFOA + dwLink*: DWORD + lpLinkInfo*: LPOLEUILINKINFOA + lpGP*: LPOLEUIGNRLPROPSA + lpVP*: LPOLEUIVIEWPROPSA + lpLP*: LPOLEUILINKPROPSA + OLEUIGNRLPROPSA* {.pure.} = object + cbStruct*: DWORD + dwFlags*: DWORD + dwReserved1*: array[2, DWORD] + lpfnHook*: LPFNOLEUIHOOK + lCustData*: LPARAM + dwReserved2*: array[3, DWORD] + lpOP*: ptr OLEUIOBJECTPROPSA + POLEUIGNRLPROPSA* = ptr OLEUIGNRLPROPSA + POLEUIVIEWPROPSW* = ptr OLEUIVIEWPROPSW + POLEUIVIEWPROPSA* = ptr OLEUIVIEWPROPSA + POLEUILINKPROPSW* = ptr OLEUILINKPROPSW + POLEUILINKPROPSA* = ptr OLEUILINKPROPSA + POLEUIOBJECTPROPSW* = ptr OLEUIOBJECTPROPSW + LPOLEUIOBJECTPROPSW* = ptr OLEUIOBJECTPROPSW + POLEUIOBJECTPROPSA* = ptr OLEUIOBJECTPROPSA + LPOLEUIOBJECTPROPSA* = ptr OLEUIOBJECTPROPSA +const + LIBID_Accessibility* = DEFINE_GUID("1ea4dbf0-3c3b-11cf-810c-00aa00389b71") + IID_IAccessibleHandler* = DEFINE_GUID("03022430-abc4-11d0-bde2-00aa001a1953") + IID_IAccIdentity* = DEFINE_GUID("7852b78d-1cfd-41c1-a615-9c0c85960b5f") + IID_IAccPropServer* = DEFINE_GUID("76c0dbbb-15e0-4e7b-b61b-20eeea2001e0") + IID_IAccPropServices* = DEFINE_GUID("6e26e776-04f0-495d-80e4-3330352e3169") + IID_IAccPropMgrInternal* = DEFINE_GUID("2bd370a9-3e7f-4edd-8a85-f8fed1f8e51f") + CLSID_AccPropServices* = DEFINE_GUID("b5f8350b-0548-48b1-a6ee-88bd00b4a5e7") + IIS_IsOleaccProxy* = DEFINE_GUID("902697fa-80e4-4560-802a-a13f22a64709") + MSAA_MENU_SIG* = 0xAA0DF00D'i32 + PROPID_ACC_NAME* = DEFINE_GUID("608d3df8-8128-4aa7-a428-f55e49267291") + PROPID_ACC_VALUE* = DEFINE_GUID("123fe443-211a-4615-9527-c45a7e93717a") + PROPID_ACC_DESCRIPTION* = DEFINE_GUID("4d48dfe4-bd3f-491f-a648-492d6f20c588") + PROPID_ACC_ROLE* = DEFINE_GUID("cb905ff2-7bd1-4c05-b3c8-e6c241364d70") + PROPID_ACC_STATE* = DEFINE_GUID("a8d4d5b0-0a21-42d0-a5c0-514e984f457b") + PROPID_ACC_HELP* = DEFINE_GUID("c831e11f-44db-4a99-9768-cb8f978b7231") + PROPID_ACC_KEYBOARDSHORTCUT* = DEFINE_GUID("7d9bceee-7d1e-4979-9382-5180f4172c34") + PROPID_ACC_DEFAULTACTION* = DEFINE_GUID("180c072b-c27f-43c7-9922-f63562a4632b") + PROPID_ACC_HELPTOPIC* = DEFINE_GUID("787d1379-8ede-440b-8aec-11f7bf9030b3") + PROPID_ACC_FOCUS* = DEFINE_GUID("6eb335df-1c29-4127-b12c-dee9fd157f2b") + PROPID_ACC_SELECTION* = DEFINE_GUID("b99d073c-d731-405b-9061-d95e8f842984") + PROPID_ACC_PARENT* = DEFINE_GUID("474c22b6-ffc2-467a-b1b5-e958b4657330") + PROPID_ACC_NAV_UP* = DEFINE_GUID("016e1a2b-1a4e-4767-8612-3386f66935ec") + PROPID_ACC_NAV_DOWN* = DEFINE_GUID("031670ed-3cdf-48d2-9613-138f2dd8a668") + PROPID_ACC_NAV_LEFT* = DEFINE_GUID("228086cb-82f1-4a39-8705-dcdc0fff92f5") + PROPID_ACC_NAV_RIGHT* = DEFINE_GUID("cd211d9f-e1cb-4fe5-a77c-920b884d095b") + PROPID_ACC_NAV_PREV* = DEFINE_GUID("776d3891-c73b-4480-b3f6-076a16a15af6") + PROPID_ACC_NAV_NEXT* = DEFINE_GUID("1cdc5455-8cd9-4c92-a371-3939a2fe3eee") + PROPID_ACC_NAV_FIRSTCHILD* = DEFINE_GUID("cfd02558-557b-4c67-84f9-2a09fce40749") + PROPID_ACC_NAV_LASTCHILD* = DEFINE_GUID("302ecaa5-48d5-4f8d-b671-1a8d20a77832") + PROPID_ACC_ROLEMAP* = DEFINE_GUID("f79acda2-140d-4fe6-8914-208476328269") + PROPID_ACC_VALUEMAP* = DEFINE_GUID("da1c3d79-fc5c-420e-b399-9d1533549e75") + PROPID_ACC_STATEMAP* = DEFINE_GUID("43946c5e-0ac0-4042-b525-07bbdbe17fa7") + PROPID_ACC_DESCRIPTIONMAP* = DEFINE_GUID("1ff1435f-8a14-477b-b226-a0abe279975d") + PROPID_ACC_DODEFAULTACTION* = DEFINE_GUID("1ba09523-2e3b-49a6-a059-59682a3c48fd") + NAVDIR_MIN* = 0 + NAVDIR_UP* = 0x1 + NAVDIR_DOWN* = 0x2 + NAVDIR_LEFT* = 0x3 + NAVDIR_RIGHT* = 0x4 + NAVDIR_NEXT* = 0x5 + NAVDIR_PREVIOUS* = 0x6 + NAVDIR_FIRSTCHILD* = 0x7 + NAVDIR_LASTCHILD* = 0x8 + NAVDIR_MAX* = 0x9 + SELFLAG_NONE* = 0 + SELFLAG_TAKEFOCUS* = 0x1 + SELFLAG_TAKESELECTION* = 0x2 + SELFLAG_EXTENDSELECTION* = 0x4 + SELFLAG_ADDSELECTION* = 0x8 + SELFLAG_REMOVESELECTION* = 0x10 + SELFLAG_VALID* = 0x1f + STATE_SYSTEM_NORMAL* = 0 + STATE_SYSTEM_HASPOPUP* = 0x40000000 + ROLE_SYSTEM_TITLEBAR* = 0x1 + ROLE_SYSTEM_MENUBAR* = 0x2 + ROLE_SYSTEM_SCROLLBAR* = 0x3 + ROLE_SYSTEM_GRIP* = 0x4 + ROLE_SYSTEM_SOUND* = 0x5 + ROLE_SYSTEM_CURSOR* = 0x6 + ROLE_SYSTEM_CARET* = 0x7 + ROLE_SYSTEM_ALERT* = 0x8 + ROLE_SYSTEM_WINDOW* = 0x9 + ROLE_SYSTEM_CLIENT* = 0xa + ROLE_SYSTEM_MENUPOPUP* = 0xb + ROLE_SYSTEM_MENUITEM* = 0xc + ROLE_SYSTEM_TOOLTIP* = 0xd + ROLE_SYSTEM_APPLICATION* = 0xe + ROLE_SYSTEM_DOCUMENT* = 0xf + ROLE_SYSTEM_PANE* = 0x10 + ROLE_SYSTEM_CHART* = 0x11 + ROLE_SYSTEM_DIALOG* = 0x12 + ROLE_SYSTEM_BORDER* = 0x13 + ROLE_SYSTEM_GROUPING* = 0x14 + ROLE_SYSTEM_SEPARATOR* = 0x15 + ROLE_SYSTEM_TOOLBAR* = 0x16 + ROLE_SYSTEM_STATUSBAR* = 0x17 + ROLE_SYSTEM_TABLE* = 0x18 + ROLE_SYSTEM_COLUMNHEADER* = 0x19 + ROLE_SYSTEM_ROWHEADER* = 0x1a + ROLE_SYSTEM_COLUMN* = 0x1b + ROLE_SYSTEM_ROW* = 0x1c + ROLE_SYSTEM_CELL* = 0x1d + ROLE_SYSTEM_LINK* = 0x1e + ROLE_SYSTEM_HELPBALLOON* = 0x1f + ROLE_SYSTEM_CHARACTER* = 0x20 + ROLE_SYSTEM_LIST* = 0x21 + ROLE_SYSTEM_LISTITEM* = 0x22 + ROLE_SYSTEM_OUTLINE* = 0x23 + ROLE_SYSTEM_OUTLINEITEM* = 0x24 + ROLE_SYSTEM_PAGETAB* = 0x25 + ROLE_SYSTEM_PROPERTYPAGE* = 0x26 + ROLE_SYSTEM_INDICATOR* = 0x27 + ROLE_SYSTEM_GRAPHIC* = 0x28 + ROLE_SYSTEM_STATICTEXT* = 0x29 + ROLE_SYSTEM_TEXT* = 0x2a + ROLE_SYSTEM_PUSHBUTTON* = 0x2b + ROLE_SYSTEM_CHECKBUTTON* = 0x2c + ROLE_SYSTEM_RADIOBUTTON* = 0x2d + ROLE_SYSTEM_COMBOBOX* = 0x2e + ROLE_SYSTEM_DROPLIST* = 0x2f + ROLE_SYSTEM_PROGRESSBAR* = 0x30 + ROLE_SYSTEM_DIAL* = 0x31 + ROLE_SYSTEM_HOTKEYFIELD* = 0x32 + ROLE_SYSTEM_SLIDER* = 0x33 + ROLE_SYSTEM_SPINBUTTON* = 0x34 + ROLE_SYSTEM_DIAGRAM* = 0x35 + ROLE_SYSTEM_ANIMATION* = 0x36 + ROLE_SYSTEM_EQUATION* = 0x37 + ROLE_SYSTEM_BUTTONDROPDOWN* = 0x38 + ROLE_SYSTEM_BUTTONMENU* = 0x39 + ROLE_SYSTEM_BUTTONDROPDOWNGRID* = 0x3a + ROLE_SYSTEM_WHITESPACE* = 0x3b + ROLE_SYSTEM_PAGETABLIST* = 0x3c + ROLE_SYSTEM_CLOCK* = 0x3d + ROLE_SYSTEM_SPLITBUTTON* = 0x3e + ROLE_SYSTEM_IPADDRESS* = 0x3f + ROLE_SYSTEM_OUTLINEBUTTON* = 0x40 + DISPID_ACC_PARENT* = -5000 + DISPID_ACC_CHILDCOUNT* = -5001 + DISPID_ACC_CHILD* = -5002 + DISPID_ACC_NAME* = -5003 + DISPID_ACC_VALUE* = -5004 + DISPID_ACC_DESCRIPTION* = -5005 + DISPID_ACC_ROLE* = -5006 + DISPID_ACC_STATE* = -5007 + DISPID_ACC_HELP* = -5008 + DISPID_ACC_HELPTOPIC* = -5009 + DISPID_ACC_KEYBOARDSHORTCUT* = -5010 + DISPID_ACC_FOCUS* = -5011 + DISPID_ACC_SELECTION* = -5012 + DISPID_ACC_DEFAULTACTION* = -5013 + DISPID_ACC_SELECT* = -5014 + DISPID_ACC_LOCATION* = -5015 + DISPID_ACC_NAVIGATE* = -5016 + DISPID_ACC_HITTEST* = -5017 + DISPID_ACC_DODEFAULTACTION* = -5018 + IID_IAccessible* = DEFINE_GUID("618736e0-3c3d-11cf-810c-00aa00389b71") + ANNO_THIS* = 0 + ANNO_CONTAINER* = 1 + INTERFACESAFE_FOR_UNTRUSTED_CALLER* = 0x00000001 + INTERFACESAFE_FOR_UNTRUSTED_DATA* = 0x00000002 + INTERFACE_USES_DISPEX* = 0x00000004 + INTERFACE_USES_SECURITY_MANAGER* = 0x00000008 + IID_IObjectSafety* = DEFINE_GUID("cb5bdc81-93c1-11cf-8f20-00805f2cd064") + CLSID_CFontPropPage* = DEFINE_GUID("0be35200-8f91-11ce-9de3-00aa004bb851") + CLSID_CColorPropPage* = DEFINE_GUID("0be35201-8f91-11ce-9de3-00aa004bb851") + CLSID_CPicturePropPage* = DEFINE_GUID("0be35202-8f91-11ce-9de3-00aa004bb851") + CLSID_PersistPropset* = DEFINE_GUID("fb8f0821-0164-101b-84ed-08002b2ec713") + CLSID_ConvertVBX* = DEFINE_GUID("fb8f0822-0164-101b-84ed-08002b2ec713") + CLSID_StdFont* = DEFINE_GUID("0be35203-8f91-11ce-9de3-00aa004bb851") + CLSID_StdPicture* = DEFINE_GUID("0be35204-8f91-11ce-9de3-00aa004bb851") + GUID_HIMETRIC* = DEFINE_GUID("66504300-be0f-101a-8bbb-00aa00300cab") + GUID_COLOR* = DEFINE_GUID("66504301-be0f-101a-8bbb-00aa00300cab") + GUID_XPOSPIXEL* = DEFINE_GUID("66504302-be0f-101a-8bbb-00aa00300cab") + GUID_YPOSPIXEL* = DEFINE_GUID("66504303-be0f-101a-8bbb-00aa00300cab") + GUID_XSIZEPIXEL* = DEFINE_GUID("66504304-be0f-101a-8bbb-00aa00300cab") + GUID_YSIZEPIXEL* = DEFINE_GUID("66504305-be0f-101a-8bbb-00aa00300cab") + GUID_XPOS* = DEFINE_GUID("66504306-be0f-101a-8bbb-00aa00300cab") + GUID_YPOS* = DEFINE_GUID("66504307-be0f-101a-8bbb-00aa00300cab") + GUID_XSIZE* = DEFINE_GUID("66504308-be0f-101a-8bbb-00aa00300cab") + GUID_YSIZE* = DEFINE_GUID("66504309-be0f-101a-8bbb-00aa00300cab") + GUID_TRISTATE* = DEFINE_GUID("6650430a-be0f-101a-8bbb-00aa00300cab") + GUID_OPTIONVALUEEXCLUSIVE* = DEFINE_GUID("6650430b-be0f-101a-8bbb-00aa00300cab") + GUID_CHECKVALUEEXCLUSIVE* = DEFINE_GUID("6650430c-be0f-101a-8bbb-00aa00300cab") + GUID_FONTNAME* = DEFINE_GUID("6650430d-be0f-101a-8bbb-00aa00300cab") + GUID_FONTSIZE* = DEFINE_GUID("6650430e-be0f-101a-8bbb-00aa00300cab") + GUID_FONTBOLD* = DEFINE_GUID("6650430f-be0f-101a-8bbb-00aa00300cab") + GUID_FONTITALIC* = DEFINE_GUID("66504310-be0f-101a-8bbb-00aa00300cab") + GUID_FONTUNDERSCORE* = DEFINE_GUID("66504311-be0f-101a-8bbb-00aa00300cab") + GUID_FONTSTRIKETHROUGH* = DEFINE_GUID("66504312-be0f-101a-8bbb-00aa00300cab") + GUID_HANDLE* = DEFINE_GUID("66504313-be0f-101a-8bbb-00aa00300cab") + PICTYPE_UNINITIALIZED* = -1 + PICTYPE_NONE* = 0 + PICTYPE_BITMAP* = 1 + PICTYPE_METAFILE* = 2 + PICTYPE_ICON* = 3 + PICTYPE_ENHMETAFILE* = 4 + triUnchecked* = 0 + triChecked* = 1 + triGray* = 2 +template STD_CTL_SCODE*(n: untyped): HRESULT = MAKE_SCODE(SEVERITY_ERROR, FACILITY_CONTROL, n) +const + CTL_E_ILLEGALFUNCTIONCALL* = STD_CTL_SCODE(5) + CTL_E_OVERFLOW* = STD_CTL_SCODE(6) + CTL_E_OUTOFMEMORY* = STD_CTL_SCODE(7) + CTL_E_DIVISIONBYZERO* = STD_CTL_SCODE(11) + CTL_E_OUTOFSTRINGSPACE* = STD_CTL_SCODE(14) + CTL_E_OUTOFSTACKSPACE* = STD_CTL_SCODE(28) + CTL_E_BADFILENAMEORNUMBER* = STD_CTL_SCODE(52) + CTL_E_FILENOTFOUND* = STD_CTL_SCODE(53) + CTL_E_BADFILEMODE* = STD_CTL_SCODE(54) + CTL_E_FILEALREADYOPEN* = STD_CTL_SCODE(55) + CTL_E_DEVICEIOERROR* = STD_CTL_SCODE(57) + CTL_E_FILEALREADYEXISTS* = STD_CTL_SCODE(58) + CTL_E_BADRECORDLENGTH* = STD_CTL_SCODE(59) + CTL_E_DISKFULL* = STD_CTL_SCODE(61) + CTL_E_BADRECORDNUMBER* = STD_CTL_SCODE(63) + CTL_E_BADFILENAME* = STD_CTL_SCODE(64) + CTL_E_TOOMANYFILES* = STD_CTL_SCODE(67) + CTL_E_DEVICEUNAVAILABLE* = STD_CTL_SCODE(68) + CTL_E_PERMISSIONDENIED* = STD_CTL_SCODE(70) + CTL_E_DISKNOTREADY* = STD_CTL_SCODE(71) + CTL_E_PATHFILEACCESSERROR* = STD_CTL_SCODE(75) + CTL_E_PATHNOTFOUND* = STD_CTL_SCODE(76) + CTL_E_INVALIDPATTERNSTRING* = STD_CTL_SCODE(93) + CTL_E_INVALIDUSEOFNULL* = STD_CTL_SCODE(94) + CTL_E_INVALIDFILEFORMAT* = STD_CTL_SCODE(321) + CTL_E_INVALIDPROPERTYVALUE* = STD_CTL_SCODE(380) + CTL_E_INVALIDPROPERTYARRAYINDEX* = STD_CTL_SCODE(381) + CTL_E_SETNOTSUPPORTEDATRUNTIME* = STD_CTL_SCODE(382) + CTL_E_SETNOTSUPPORTED* = STD_CTL_SCODE(383) + CTL_E_NEEDPROPERTYARRAYINDEX* = STD_CTL_SCODE(385) + CTL_E_SETNOTPERMITTED* = STD_CTL_SCODE(387) + CTL_E_GETNOTSUPPORTEDATRUNTIME* = STD_CTL_SCODE(393) + CTL_E_GETNOTSUPPORTED* = STD_CTL_SCODE(394) + CTL_E_PROPERTYNOTFOUND* = STD_CTL_SCODE(422) + CTL_E_INVALIDCLIPBOARDFORMAT* = STD_CTL_SCODE(460) + CTL_E_INVALIDPICTURE* = STD_CTL_SCODE(481) + CTL_E_PRINTERERROR* = STD_CTL_SCODE(482) + CTL_E_CANTSAVEFILETOTEMP* = STD_CTL_SCODE(735) + CTL_E_SEARCHTEXTNOTFOUND* = STD_CTL_SCODE(744) + CTL_E_REPLACEMENTSTOOLONG* = STD_CTL_SCODE(746) +template CUSTOM_CTL_SCODE*(n: untyped): HRESULT = MAKE_SCODE(SEVERITY_ERROR, FACILITY_CONTROL, n) +const + CTL_E_CUSTOM_FIRST* = CUSTOM_CTL_SCODE(600) + CONNECT_E_FIRST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x0200) + CONNECT_E_LAST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x020F) + CONNECT_S_FIRST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0200) + CONNECT_S_LAST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x020F) + CONNECT_E_NOCONNECTION* = CONNECT_E_FIRST+0 + CONNECT_E_ADVISELIMIT* = CONNECT_E_FIRST+1 + CONNECT_E_CANNOTCONNECT* = CONNECT_E_FIRST+2 + CONNECT_E_OVERRIDDEN* = CONNECT_E_FIRST+3 + SELFREG_E_FIRST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x0200) + SELFREG_E_LAST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x020F) + SELFREG_S_FIRST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0200) + SELFREG_S_LAST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x020F) + SELFREG_E_TYPELIB* = SELFREG_E_FIRST+0 + SELFREG_E_CLASS* = SELFREG_E_FIRST+1 + PERPROP_E_FIRST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x0200) + PERPROP_E_LAST* = MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x020F) + PERPROP_S_FIRST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0200) + PERPROP_S_LAST* = MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x020F) + PERPROP_E_NOPAGEAVAILABLE* = PERPROP_E_FIRST+0 + OLEIVERB_PROPERTIES* = -7 + VT_STREAMED_PROPSET* = 73 + VT_STORED_PROPSET* = 74 + VT_BLOB_PROPSET* = 75 + VT_VERBOSE_ENUM* = 76 + VT_COLOR* = VT_I4 + VT_XPOS_PIXELS* = VT_I4 + VT_YPOS_PIXELS* = VT_I4 + VT_XSIZE_PIXELS* = VT_I4 + VT_YSIZE_PIXELS* = VT_I4 + VT_XPOS_HIMETRIC* = VT_I4 + VT_YPOS_HIMETRIC* = VT_I4 + VT_XSIZE_HIMETRIC* = VT_I4 + VT_YSIZE_HIMETRIC* = VT_I4 + VT_TRISTATE* = VT_I2 + VT_OPTEXCLUSIVE* = VT_BOOL + VT_FONT* = VT_DISPATCH + VT_PICTURE* = VT_DISPATCH + VT_HANDLE* = VT_I4 + OCM_BASE* = WM_USER+0x1c00 + OCM_COMMAND* = OCM_BASE+WM_COMMAND + OCM_CTLCOLORBTN* = OCM_BASE+WM_CTLCOLORBTN + OCM_CTLCOLOREDIT* = OCM_BASE+WM_CTLCOLOREDIT + OCM_CTLCOLORDLG* = OCM_BASE+WM_CTLCOLORDLG + OCM_CTLCOLORLISTBOX* = OCM_BASE+WM_CTLCOLORLISTBOX + OCM_CTLCOLORMSGBOX* = OCM_BASE+WM_CTLCOLORMSGBOX + OCM_CTLCOLORSCROLLBAR* = OCM_BASE+WM_CTLCOLORSCROLLBAR + OCM_CTLCOLORSTATIC* = OCM_BASE+WM_CTLCOLORSTATIC + OCM_DRAWITEM* = OCM_BASE+WM_DRAWITEM + OCM_MEASUREITEM* = OCM_BASE+WM_MEASUREITEM + OCM_DELETEITEM* = OCM_BASE+WM_DELETEITEM + OCM_VKEYTOITEM* = OCM_BASE+WM_VKEYTOITEM + OCM_CHARTOITEM* = OCM_BASE+WM_CHARTOITEM + OCM_COMPAREITEM* = OCM_BASE+WM_COMPAREITEM + OCM_HSCROLL* = OCM_BASE+WM_HSCROLL + OCM_VSCROLL* = OCM_BASE+WM_VSCROLL + OCM_PARENTNOTIFY* = OCM_BASE+WM_PARENTNOTIFY + OCM_NOTIFY* = OCM_BASE+WM_NOTIFY + LP_DEFAULT* = 0x00 + LP_MONOCHROME* = 0x01 + LP_VGACOLOR* = 0x02 + LP_COLOR* = 0x04 + DISPID_AUTOSIZE* = -500 + DISPID_BACKCOLOR* = -501 + DISPID_BACKSTYLE* = -502 + DISPID_BORDERCOLOR* = -503 + DISPID_BORDERSTYLE* = -504 + DISPID_BORDERWIDTH* = -505 + DISPID_DRAWMODE* = -507 + DISPID_DRAWSTYLE* = -508 + DISPID_DRAWWIDTH* = -509 + DISPID_FILLCOLOR* = -510 + DISPID_FILLSTYLE* = -511 + DISPID_FONT* = -512 + DISPID_FORECOLOR* = -513 + DISPID_ENABLED* = -514 + DISPID_HWND* = -515 + DISPID_TABSTOP* = -516 + DISPID_TEXT* = -517 + DISPID_CAPTION* = -518 + DISPID_BORDERVISIBLE* = -519 + DISPID_APPEARANCE* = -520 + DISPID_MOUSEPOINTER* = -521 + DISPID_MOUSEICON* = -522 + DISPID_PICTURE* = -523 + DISPID_VALID* = -524 + DISPID_READYSTATE* = -525 + DISPID_LISTINDEX* = -526 + DISPID_SELECTED* = -527 + DISPID_LIST* = -528 + DISPID_COLUMN* = -529 + DISPID_LISTCOUNT* = -531 + DISPID_MULTISELECT* = -532 + DISPID_MAXLENGTH* = -533 + DISPID_PASSWORDCHAR* = -534 + DISPID_SCROLLBARS* = -535 + DISPID_WORDWRAP* = -536 + DISPID_MULTILINE* = -537 + DISPID_NUMBEROFROWS* = -538 + DISPID_NUMBEROFCOLUMNS* = -539 + DISPID_DISPLAYSTYLE* = -540 + DISPID_GROUPNAME* = -541 + DISPID_IMEMODE* = -542 + DISPID_ACCELERATOR* = -543 + DISPID_ENTERKEYBEHAVIOR* = -544 + DISPID_TABKEYBEHAVIOR* = -545 + DISPID_SELTEXT* = -546 + DISPID_SELSTART* = -547 + DISPID_SELLENGTH* = -548 + DISPID_REFRESH* = -550 + DISPID_DOCLICK* = -551 + DISPID_ABOUTBOX* = -552 + DISPID_ADDITEM* = -553 + DISPID_CLEAR* = -554 + DISPID_REMOVEITEM* = -555 + DISPID_CLICK* = -600 + DISPID_DBLCLICK* = -601 + DISPID_KEYDOWN* = -602 + DISPID_KEYPRESS* = -603 + DISPID_KEYUP* = -604 + DISPID_MOUSEDOWN* = -605 + DISPID_MOUSEMOVE* = -606 + DISPID_MOUSEUP* = -607 + DISPID_ERROREVENT* = -608 + DISPID_READYSTATECHANGE* = -609 + DISPID_CLICK_VALUE* = -610 + DISPID_RIGHTTOLEFT* = -611 + DISPID_TOPTOBOTTOM* = -612 + DISPID_THIS* = -613 + DISPID_AMBIENT_BACKCOLOR* = -701 + DISPID_AMBIENT_DISPLAYNAME* = -702 + DISPID_AMBIENT_FONT* = -703 + DISPID_AMBIENT_FORECOLOR* = -704 + DISPID_AMBIENT_LOCALEID* = -705 + DISPID_AMBIENT_MESSAGEREFLECT* = -706 + DISPID_AMBIENT_SCALEUNITS* = -707 + DISPID_AMBIENT_TEXTALIGN* = -708 + DISPID_AMBIENT_USERMODE* = -709 + DISPID_AMBIENT_UIDEAD* = -710 + DISPID_AMBIENT_SHOWGRABHANDLES* = -711 + DISPID_AMBIENT_SHOWHATCHING* = -712 + DISPID_AMBIENT_DISPLAYASDEFAULT* = -713 + DISPID_AMBIENT_SUPPORTSMNEMONICS* = -714 + DISPID_AMBIENT_AUTOCLIP* = -715 + DISPID_AMBIENT_APPEARANCE* = -716 + DISPID_AMBIENT_CODEPAGE* = -725 + DISPID_AMBIENT_PALETTE* = -726 + DISPID_AMBIENT_CHARSET* = -727 + DISPID_AMBIENT_TRANSFERPRIORITY* = -728 + DISPID_AMBIENT_RIGHTTOLEFT* = -732 + DISPID_AMBIENT_TOPTOBOTTOM* = -733 + DISPID_Name* = -800 + DISPID_Delete* = -801 + DISPID_Object* = -802 + DISPID_Parent* = -803 + DISPID_FONT_NAME* = 0 + DISPID_FONT_SIZE* = 2 + DISPID_FONT_BOLD* = 3 + DISPID_FONT_ITALIC* = 4 + DISPID_FONT_UNDER* = 5 + DISPID_FONT_STRIKE* = 6 + DISPID_FONT_WEIGHT* = 7 + DISPID_FONT_CHARSET* = 8 + DISPID_FONT_CHANGED* = 9 + DISPID_PICT_HANDLE* = 0 + DISPID_PICT_HPAL* = 2 + DISPID_PICT_TYPE* = 3 + DISPID_PICT_WIDTH* = 4 + DISPID_PICT_HEIGHT* = 5 + DISPID_PICT_RENDER* = 6 + CATID_ActiveScript* = DEFINE_GUID("f0b7a1a1-9847-11cf-8f20-00805f2cd064") + CATID_ActiveScriptParse* = DEFINE_GUID("f0b7a1a2-9847-11cf-8f20-00805f2cd064") + CATID_ActiveScriptEncode* = DEFINE_GUID("f0b7a1a3-9847-11cf-8f20-00805f2cd064") + OID_VBSSIP* = DEFINE_GUID("1629f04e-2799-4db5-8fe5-ace10f17ebab") + OID_JSSIP* = DEFINE_GUID("06c9e010-38ce-11d4-a2a3-00104bd35090") + OID_WSFSIP* = DEFINE_GUID("1a610570-38ce-11d4-a2a3-00104bd35090") + SCRIPTITEM_ISVISIBLE* = 0x00000002 + SCRIPTITEM_ISSOURCE* = 0x00000004 + SCRIPTITEM_GLOBALMEMBERS* = 0x00000008 + SCRIPTITEM_ISPERSISTENT* = 0x00000040 + SCRIPTITEM_CODEONLY* = 0x00000200 + SCRIPTITEM_NOCODE* = 0x00000400 + SCRIPTITEM_ALL_FLAGS* = SCRIPTITEM_ISSOURCE or SCRIPTITEM_ISVISIBLE or SCRIPTITEM_ISPERSISTENT or SCRIPTITEM_GLOBALMEMBERS or SCRIPTITEM_NOCODE or SCRIPTITEM_CODEONLY + SCRIPTTYPELIB_ISCONTROL* = 0x00000010 + SCRIPTTYPELIB_ISPERSISTENT* = 0x00000040 + SCRIPTTYPELIB_ALL_FLAGS* = SCRIPTTYPELIB_ISCONTROL or SCRIPTTYPELIB_ISPERSISTENT + SCRIPTTEXT_DELAYEXECUTION* = 0x00000001 + SCRIPTTEXT_ISVISIBLE* = 0x00000002 + SCRIPTTEXT_ISEXPRESSION* = 0x00000020 + SCRIPTTEXT_ISPERSISTENT* = 0x00000040 + SCRIPTTEXT_HOSTMANAGESSOURCE* = 0x00000080 + SCRIPTTEXT_ISXDOMAIN* = 0x00000100 + SCRIPTTEXT_ALL_FLAGS* = SCRIPTTEXT_DELAYEXECUTION or SCRIPTTEXT_ISVISIBLE or SCRIPTTEXT_ISEXPRESSION or SCRIPTTEXT_ISPERSISTENT or SCRIPTTEXT_HOSTMANAGESSOURCE or SCRIPTTEXT_ISXDOMAIN + SCRIPTPROC_ISEXPRESSION* = 0x00000020 + SCRIPTPROC_HOSTMANAGESSOURCE* = 0x00000080 + SCRIPTPROC_IMPLICIT_THIS* = 0x00000100 + SCRIPTPROC_IMPLICIT_PARENTS* = 0x00000200 + SCRIPTPROC_ISXDOMAIN* = 0x00000400 + SCRIPTPROC_ALL_FLAGS* = SCRIPTPROC_HOSTMANAGESSOURCE or SCRIPTPROC_ISEXPRESSION or SCRIPTPROC_IMPLICIT_THIS or SCRIPTPROC_IMPLICIT_PARENTS or SCRIPTPROC_ISXDOMAIN + SCRIPTINFO_IUNKNOWN* = 0x00000001 + SCRIPTINFO_ITYPEINFO* = 0x00000002 + SCRIPTINFO_ALL_FLAGS* = SCRIPTINFO_IUNKNOWN or SCRIPTINFO_ITYPEINFO + SCRIPTINTERRUPT_DEBUG* = 0x00000001 + SCRIPTINTERRUPT_RAISEEXCEPTION* = 0x00000002 + SCRIPTINTERRUPT_ALL_FLAGS* = SCRIPTINTERRUPT_DEBUG or SCRIPTINTERRUPT_RAISEEXCEPTION + SCRIPTSTAT_STATEMENT_COUNT* = 0x1 + SCRIPTSTAT_INSTRUCTION_COUNT* = 0x2 + SCRIPTSTAT_INTSTRUCTION_TIME* = 0x3 + SCRIPTSTAT_TOTAL_TIME* = 0x4 + SCRIPT_ENCODE_SECTION* = 0x1 + SCRIPT_ENCODE_DEFAULT_LANGUAGE* = 0x1 + SCRIPT_ENCODE_NO_ASP_LANGUAGE* = 0x2 + SCRIPTPROP_NAME* = 0x0 + SCRIPTPROP_MAJORVERSION* = 0x1 + SCRIPTPROP_MINORVERSION* = 0x2 + SCRIPTPROP_BUILDNUMBER* = 0x3 + SCRIPTPROP_DELAYEDEVENTSINKING* = 0x1000 + SCRIPTPROP_CATCHEXCEPTION* = 0x1001 + SCRIPTPROP_CONVERSIONLCID* = 0x1002 + SCRIPTPROP_HOSTSTACKREQUIRED* = 0x1003 + SCRIPTPROP_DEBUGGER* = 0x1100 + SCRIPTPROP_JITDEBUG* = 0x1101 + SCRIPTPROP_GCCONTROLSOFTCLOSE* = 0x2000 + SCRIPTPROP_INTEGERMODE* = 0x3000 + SCRIPTPROP_STRINGCOMPAREINSTANCE* = 0x3001 + SCRIPTPROP_INVOKEVERSIONING* = 0x4000 + SCRIPTPROP_HACK_FIBERSUPPORT* = 0x70000000 + SCRIPTPROP_HACK_TRIDENTEVENTSINK* = 0x70000001 + SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION* = 0x70000002 + SCRIPTPROP_HOSTKEEPALIVE* = 0x70000004 + SCRIPT_E_RECORDED* = 0x86664004'i32 + SCRIPT_E_REPORTED* = 0x80020101'i32 + SCRIPT_E_PROPAGATE* = 0x80020102'i32 + SCRIPTLANGUAGEVERSION_DEFAULT* = 0 + SCRIPTLANGUAGEVERSION_5_7* = 1 + SCRIPTLANGUAGEVERSION_5_8* = 2 + SCRIPTLANGUAGEVERSION_MAX* = 255 + SCRIPTSTATE_UNINITIALIZED* = 0 + SCRIPTSTATE_INITIALIZED* = 5 + SCRIPTSTATE_STARTED* = 1 + SCRIPTSTATE_CONNECTED* = 2 + SCRIPTSTATE_DISCONNECTED* = 3 + SCRIPTSTATE_CLOSED* = 4 + SCRIPTTRACEINFO_SCRIPTSTART* = 0 + SCRIPTTRACEINFO_SCRIPTEND* = 1 + SCRIPTTRACEINFO_COMCALLSTART* = 2 + SCRIPTTRACEINFO_COMCALLEND* = 3 + SCRIPTTRACEINFO_CREATEOBJSTART* = 4 + SCRIPTTRACEINFO_CREATEOBJEND* = 5 + SCRIPTTRACEINFO_GETOBJSTART* = 6 + SCRIPTTRACEINFO_GETOBJEND* = 7 + SCRIPTTHREADSTATE_NOTINSCRIPT* = 0 + SCRIPTTHREADSTATE_RUNNING* = 1 + SCRIPTGCTYPE_NORMAL* = 0 + SCRIPTGCTYPE_EXHAUSTIVE* = 1 + SCRIPTUICITEM_INPUTBOX* = 1 + SCRIPTUICITEM_MSGBOX* = 2 + SCRIPTUICHANDLING_ALLOW* = 0 + SCRIPTUICHANDLING_NOUIERROR* = 1 + SCRIPTUICHANDLING_NOUIDEFAULT* = 2 + SCRIPTTHREADID_CURRENT* = SCRIPTTHREADID(-1) + SCRIPTTHREADID_BASE* = SCRIPTTHREADID(-2) + SCRIPTTHREADID_ALL* = SCRIPTTHREADID(-3) + IID_IActiveScriptSite* = DEFINE_GUID("db01a1e3-a42b-11cf-8f20-00805f2cd064") + IID_IActiveScriptError* = DEFINE_GUID("eae1ba61-a4ed-11cf-8f20-00805f2cd064") + IID_IActiveScriptError64* = DEFINE_GUID("b21fb2a1-5b8f-4963-8c21-21450f84ed7f") + IID_IActiveScriptSiteWindow* = DEFINE_GUID("d10f6761-83e9-11cf-8f20-00805f2cd064") + IID_IActiveScriptSiteUIControl* = DEFINE_GUID("aedae97e-d7ee-4796-b960-7f092ae844ab") + IID_IActiveScriptSiteInterruptPoll* = DEFINE_GUID("539698a0-cdca-11cf-a5eb-00aa0047a063") + IID_IActiveScript* = DEFINE_GUID("bb1a2ae1-a4f9-11cf-8f20-00805f2cd064") + IID_IActiveScriptParse32* = DEFINE_GUID("bb1a2ae2-a4f9-11cf-8f20-00805f2cd064") + IID_IActiveScriptParse64* = DEFINE_GUID("c7ef7658-e1ee-480e-97ea-d52cb4d76d17") + IID_IActiveScriptParseProcedureOld32* = DEFINE_GUID("1cff0050-6fdd-11d0-9328-00a0c90dcaa9") + IID_IActiveScriptParseProcedureOld64* = DEFINE_GUID("21f57128-08c9-4638-ba12-22d15d88dc5c") + IID_IActiveScriptParseProcedure32* = DEFINE_GUID("aa5b6a80-b834-11d0-932f-00a0c90dcaa9") + IID_IActiveScriptParseProcedure64* = DEFINE_GUID("c64713b6-e029-4cc5-9200-438b72890b6a") + IID_IActiveScriptParseProcedure2_32* = DEFINE_GUID("71ee5b20-fb04-11d1-b3a8-00a0c911e8b2") + IID_IActiveScriptParseProcedure2_64* = DEFINE_GUID("fe7c4271-210c-448d-9f54-76dab7047b28") + IID_IActiveScriptEncode* = DEFINE_GUID("bb1a2ae3-a4f9-11cf-8f20-00805f2cd064") + IID_IActiveScriptHostEncode* = DEFINE_GUID("bee9b76e-cfe3-11d1-b747-00c04fc2b085") + IID_IBindEventHandler* = DEFINE_GUID("63cdbcb0-c1b1-11d0-9336-00a0c90dcaa9") + IID_IActiveScriptStats* = DEFINE_GUID("b8da6310-e19b-11d0-933c-00a0c90dcaa9") + IID_IActiveScriptProperty* = DEFINE_GUID("4954e0d0-fbc7-11d1-8410-006008c3fbfc") + IID_ITridentEventSink* = DEFINE_GUID("1dc9ca50-06ef-11d2-8415-006008c3fbfc") + IID_IActiveScriptGarbageCollector* = DEFINE_GUID("6aa2c4a0-2b53-11d4-a2a0-00104bd35090") + IID_IActiveScriptSIPInfo* = DEFINE_GUID("764651d0-38de-11d4-a2a3-00104bd35090") + IID_IActiveScriptSiteTraceInfo* = DEFINE_GUID("4b7272ae-1955-4bfe-98b0-780621888569") + IID_IActiveScriptTraceInfo* = DEFINE_GUID("c35456e7-bebf-4a1b-86a9-24d56be8b369") + IID_IActiveScriptStringCompare* = DEFINE_GUID("58562769-ed52-42f7-8403-4963514e1f11") + IDC_OLEUIHELP* = 99 + IDC_IO_CREATENEW* = 2100 + IDC_IO_CREATEFROMFILE* = 2101 + IDC_IO_LINKFILE* = 2102 + IDC_IO_OBJECTTYPELIST* = 2103 + IDC_IO_DISPLAYASICON* = 2104 + IDC_IO_CHANGEICON* = 2105 + IDC_IO_FILE* = 2106 + IDC_IO_FILEDISPLAY* = 2107 + IDC_IO_RESULTIMAGE* = 2108 + IDC_IO_RESULTTEXT* = 2109 + IDC_IO_ICONDISPLAY* = 2110 + IDC_IO_OBJECTTYPETEXT* = 2111 + IDC_IO_FILETEXT* = 2112 + IDC_IO_FILETYPE* = 2113 + IDC_IO_INSERTCONTROL* = 2114 + IDC_IO_ADDCONTROL* = 2115 + IDC_IO_CONTROLTYPELIST* = 2116 + IDC_PS_PASTE* = 500 + IDC_PS_PASTELINK* = 501 + IDC_PS_SOURCETEXT* = 502 + IDC_PS_PASTELIST* = 503 + IDC_PS_PASTELINKLIST* = 504 + IDC_PS_DISPLAYLIST* = 505 + IDC_PS_DISPLAYASICON* = 506 + IDC_PS_ICONDISPLAY* = 507 + IDC_PS_CHANGEICON* = 508 + IDC_PS_RESULTIMAGE* = 509 + IDC_PS_RESULTTEXT* = 510 + IDC_CI_GROUP* = 120 + IDC_CI_CURRENT* = 121 + IDC_CI_CURRENTICON* = 122 + IDC_CI_DEFAULT* = 123 + IDC_CI_DEFAULTICON* = 124 + IDC_CI_FROMFILE* = 125 + IDC_CI_FROMFILEEDIT* = 126 + IDC_CI_ICONLIST* = 127 + IDC_CI_LABEL* = 128 + IDC_CI_LABELEDIT* = 129 + IDC_CI_BROWSE* = 130 + IDC_CI_ICONDISPLAY* = 131 + IDC_CV_OBJECTTYPE* = 150 + IDC_CV_DISPLAYASICON* = 152 + IDC_CV_CHANGEICON* = 153 + IDC_CV_ACTIVATELIST* = 154 + IDC_CV_CONVERTTO* = 155 + IDC_CV_ACTIVATEAS* = 156 + IDC_CV_RESULTTEXT* = 157 + IDC_CV_CONVERTLIST* = 158 + IDC_CV_ICONDISPLAY* = 165 + IDC_EL_CHANGESOURCE* = 201 + IDC_EL_AUTOMATIC* = 202 + IDC_EL_CANCELLINK* = 209 + IDC_EL_UPDATENOW* = 210 + IDC_EL_OPENSOURCE* = 211 + IDC_EL_MANUAL* = 212 + IDC_EL_LINKSOURCE* = 216 + IDC_EL_LINKTYPE* = 217 + IDC_EL_LINKSLISTBOX* = 206 + IDC_EL_COL1* = 220 + IDC_EL_COL2* = 221 + IDC_EL_COL3* = 222 + IDC_BZ_RETRY* = 600 + IDC_BZ_ICON* = 601 + IDC_BZ_MESSAGE1* = 602 + IDC_BZ_SWITCHTO* = 604 + IDC_UL_METER* = 1029 + IDC_UL_STOP* = 1030 + IDC_UL_PERCENT* = 1031 + IDC_UL_PROGRESS* = 1032 + IDC_PU_LINKS* = 900 + IDC_PU_TEXT* = 901 + IDC_PU_CONVERT* = 902 + IDC_PU_ICON* = 908 + IDC_GP_OBJECTNAME* = 1009 + IDC_GP_OBJECTTYPE* = 1010 + IDC_GP_OBJECTSIZE* = 1011 + IDC_GP_CONVERT* = 1013 + IDC_GP_OBJECTICON* = 1014 + IDC_GP_OBJECTLOCATION* = 1022 + IDC_VP_PERCENT* = 1000 + IDC_VP_CHANGEICON* = 1001 + IDC_VP_EDITABLE* = 1002 + IDC_VP_ASICON* = 1003 + IDC_VP_RELATIVE* = 1005 + IDC_VP_SPIN* = 1006 + IDC_VP_SCALETXT* = 1034 + IDC_VP_ICONDISPLAY* = 1021 + IDC_VP_RESULTIMAGE* = 1033 + IDC_LP_OPENSOURCE* = 1006 + IDC_LP_UPDATENOW* = 1007 + IDC_LP_BREAKLINK* = 1008 + IDC_LP_LINKSOURCE* = 1012 + IDC_LP_CHANGESOURCE* = 1015 + IDC_LP_AUTOMATIC* = 1016 + IDC_LP_MANUAL* = 1017 + IDC_LP_DATE* = 1018 + IDC_LP_TIME* = 1019 + IDD_INSERTOBJECT* = 1000 + IDD_CHANGEICON* = 1001 + IDD_CONVERT* = 1002 + IDD_PASTESPECIAL* = 1003 + IDD_EDITLINKS* = 1004 + IDD_BUSY* = 1006 + IDD_UPDATELINKS* = 1007 + IDD_CHANGESOURCE* = 1009 + IDD_INSERTFILEBROWSE* = 1010 + IDD_CHANGEICONBROWSE* = 1011 + IDD_CONVERTONLY* = 1012 + IDD_CHANGESOURCE4* = 1013 + IDD_GNRLPROPS* = 1100 + IDD_VIEWPROPS* = 1101 + IDD_LINKPROPS* = 1102 + IDD_CONVERT4* = 1103 + IDD_CONVERTONLY4* = 1104 + IDD_EDITLINKS4* = 1105 + IDD_GNRLPROPS4* = 1106 + IDD_LINKPROPS4* = 1107 + IDD_PASTESPECIAL4* = 1108 + IDD_CANNOTUPDATELINK* = 1008 + IDD_LINKSOURCEUNAVAILABLE* = 1020 + IDD_SERVERNOTFOUND* = 1023 + IDD_OUTOFMEMORY* = 1024 + IDD_SERVERNOTREGW* = 1021 + IDD_LINKTYPECHANGEDW* = 1022 + IDD_SERVERNOTREGA* = 1025 + IDD_LINKTYPECHANGEDA* = 1026 + OLESTDDELIM* = "\\" + SZOLEUI_MSG_HELP* = "OLEUI_MSG_HELP" + SZOLEUI_MSG_ENDDIALOG* = "OLEUI_MSG_ENDDIALOG" + SZOLEUI_MSG_BROWSE* = "OLEUI_MSG_BROWSE" + SZOLEUI_MSG_CHANGEICON* = "OLEUI_MSG_CHANGEICON" + SZOLEUI_MSG_CLOSEBUSYDIALOG* = "OLEUI_MSG_CLOSEBUSYDIALOG" + SZOLEUI_MSG_CONVERT* = "OLEUI_MSG_CONVERT" + SZOLEUI_MSG_CHANGESOURCE* = "OLEUI_MSG_CHANGESOURCE" + SZOLEUI_MSG_ADDCONTROL* = "OLEUI_MSG_ADDCONTRO" + SZOLEUI_MSG_BROWSE_OFN* = "OLEUI_MSG_BROWSE_OFN" + ID_BROWSE_CHANGEICON* = 1 + ID_BROWSE_INSERTFILE* = 2 + ID_BROWSE_ADDCONTROL* = 3 + ID_BROWSE_CHANGESOURCE* = 4 + OLEUI_FALSE* = 0 + OLEUI_SUCCESS* = 1 + OLEUI_OK* = 1 + OLEUI_CANCEL* = 2 + OLEUI_ERR_STANDARDMIN* = 100 + OLEUI_ERR_OLEMEMALLOC* = 100 + OLEUI_ERR_STRUCTURENULL* = 101 + OLEUI_ERR_STRUCTUREINVALID* = 102 + OLEUI_ERR_CBSTRUCTINCORRECT* = 103 + OLEUI_ERR_HWNDOWNERINVALID* = 104 + OLEUI_ERR_LPSZCAPTIONINVALID* = 105 + OLEUI_ERR_LPFNHOOKINVALID* = 106 + OLEUI_ERR_HINSTANCEINVALID* = 107 + OLEUI_ERR_LPSZTEMPLATEINVALID* = 108 + OLEUI_ERR_HRESOURCEINVALID* = 109 + OLEUI_ERR_FINDTEMPLATEFAILURE* = 110 + OLEUI_ERR_LOADTEMPLATEFAILURE* = 111 + OLEUI_ERR_DIALOGFAILURE* = 112 + OLEUI_ERR_LOCALMEMALLOC* = 113 + OLEUI_ERR_GLOBALMEMALLOC* = 114 + OLEUI_ERR_LOADSTRING* = 115 + OLEUI_ERR_STANDARDMAX* = 116 + IOF_SHOWHELP* = 0x00000001 + IOF_SELECTCREATENEW* = 0x00000002 + IOF_SELECTCREATEFROMFILE* = 0x00000004 + IOF_CHECKLINK* = 0x00000008 + IOF_CHECKDISPLAYASICON* = 0x00000010 + IOF_CREATENEWOBJECT* = 0x00000020 + IOF_CREATEFILEOBJECT* = 0x00000040 + IOF_CREATELINKOBJECT* = 0x00000080 + IOF_DISABLELINK* = 0x00000100 + IOF_VERIFYSERVERSEXIST* = 0x00000200 + IOF_DISABLEDISPLAYASICON* = 0x00000400 + IOF_HIDECHANGEICON* = 0x00000800 + IOF_SHOWINSERTCONTROL* = 0x00001000 + IOF_SELECTCREATECONTROL* = 0x00002000 + OLEUI_IOERR_LPSZFILEINVALID* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_IOERR_LPSZLABELINVALID* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_IOERR_HICONINVALID* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_IOERR_LPFORMATETCINVALID* = OLEUI_ERR_STANDARDMAX+3 + OLEUI_IOERR_PPVOBJINVALID* = OLEUI_ERR_STANDARDMAX+4 + OLEUI_IOERR_LPIOLECLIENTSITEINVALID* = OLEUI_ERR_STANDARDMAX+5 + OLEUI_IOERR_LPISTORAGEINVALID* = OLEUI_ERR_STANDARDMAX+6 + OLEUI_IOERR_SCODEHASERROR* = OLEUI_ERR_STANDARDMAX+7 + OLEUI_IOERR_LPCLSIDEXCLUDEINVALID* = OLEUI_ERR_STANDARDMAX+8 + OLEUI_IOERR_CCHFILEINVALID* = OLEUI_ERR_STANDARDMAX+9 + OLEUIPASTE_ENABLEICON* = 2048 + OLEUIPASTE_PASTEONLY* = 0 + OLEUIPASTE_PASTE* = 512 + OLEUIPASTE_LINKANYTYPE* = 1024 + OLEUIPASTE_LINKTYPE1* = 1 + OLEUIPASTE_LINKTYPE2* = 2 + OLEUIPASTE_LINKTYPE3* = 4 + OLEUIPASTE_LINKTYPE4* = 8 + OLEUIPASTE_LINKTYPE5* = 16 + OLEUIPASTE_LINKTYPE6* = 32 + OLEUIPASTE_LINKTYPE7* = 64 + OLEUIPASTE_LINKTYPE8* = 128 + PS_MAXLINKTYPES* = 8 + PSF_SHOWHELP* = 0x00000001 + PSF_SELECTPASTE* = 0x00000002 + PSF_SELECTPASTELINK* = 0x00000004 + PSF_CHECKDISPLAYASICON* = 0x00000008 + PSF_DISABLEDISPLAYASICON* = 0x00000010 + PSF_HIDECHANGEICON* = 0x00000020 + PSF_STAYONCLIPBOARDCHANGE* = 0x00000040 + PSF_NOREFRESHDATAOBJECT* = 0x00000080 + OLEUI_IOERR_SRCDATAOBJECTINVALID* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_IOERR_ARRPASTEENTRIESINVALID* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_IOERR_ARRLINKTYPESINVALID* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_PSERR_CLIPBOARDCHANGED* = OLEUI_ERR_STANDARDMAX+3 + OLEUI_PSERR_GETCLIPBOARDFAILED* = OLEUI_ERR_STANDARDMAX+4 + OLEUI_ELERR_LINKCNTRNULL* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_ELERR_LINKCNTRINVALID* = OLEUI_ERR_STANDARDMAX+1 + ELF_SHOWHELP* = 0x00000001 + ELF_DISABLEUPDATENOW* = 0x00000002 + ELF_DISABLEOPENSOURCE* = 0x00000004 + ELF_DISABLECHANGESOURCE* = 0x00000008 + ELF_DISABLECANCELLINK* = 0x00000010 + CIF_SHOWHELP* = 0x00000001 + CIF_SELECTCURRENT* = 0x00000002 + CIF_SELECTDEFAULT* = 0x00000004 + CIF_SELECTFROMFILE* = 0x00000008 + CIF_USEICONEXE* = 0x00000010 + OLEUI_CIERR_MUSTHAVECLSID* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_CIERR_MUSTHAVECURRENTMETAFILE* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_CIERR_SZICONEXEINVALID* = OLEUI_ERR_STANDARDMAX+2 + PROP_HWND_CHGICONDLG* = "HWND_CIDLG" + CF_SHOWHELPBUTTON* = 0x00000001 + CF_SETCONVERTDEFAULT* = 0x00000002 + CF_SETACTIVATEDEFAULT* = 0x00000004 + CF_SELECTCONVERTTO* = 0x00000008 + CF_SELECTACTIVATEAS* = 0x00000010 + CF_DISABLEDISPLAYASICON* = 0x00000020 + CF_DISABLEACTIVATEAS* = 0x00000040 + CF_HIDECHANGEICON* = 0x00000080 + CF_CONVERTONLY* = 0x00000100 + OLEUI_CTERR_CLASSIDINVALID* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_CTERR_DVASPECTINVALID* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_CTERR_CBFORMATINVALID* = OLEUI_ERR_STANDARDMAX+3 + OLEUI_CTERR_HMETAPICTINVALID* = OLEUI_ERR_STANDARDMAX+4 + OLEUI_CTERR_STRINGINVALID* = OLEUI_ERR_STANDARDMAX+5 + BZ_DISABLECANCELBUTTON* = 0x00000001 + BZ_DISABLESWITCHTOBUTTON* = 0x00000002 + BZ_DISABLERETRYBUTTON* = 0x00000004 + BZ_NOTRESPONDINGDIALOG* = 0x00000008 + OLEUI_BZERR_HTASKINVALID* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_BZ_SWITCHTOSELECTED* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_BZ_RETRYSELECTED* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_BZ_CALLUNBLOCKED* = OLEUI_ERR_STANDARDMAX+3 + CSF_SHOWHELP* = 0x00000001 + CSF_VALIDSOURCE* = 0x00000002 + CSF_ONLYGETSOURCE* = 0x00000004 + CSF_EXPLORER* = 0x00000008 + OLEUI_CSERR_LINKCNTRNULL* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_CSERR_LINKCNTRINVALID* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_CSERR_FROMNOTNULL* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_CSERR_TONOTNULL* = OLEUI_ERR_STANDARDMAX+3 + OLEUI_CSERR_SOURCENULL* = OLEUI_ERR_STANDARDMAX+4 + OLEUI_CSERR_SOURCEINVALID* = OLEUI_ERR_STANDARDMAX+5 + OLEUI_CSERR_SOURCEPARSERROR* = OLEUI_ERR_STANDARDMAX+6 + OLEUI_CSERR_SOURCEPARSEERROR* = OLEUI_ERR_STANDARDMAX+6 + VPF_SELECTRELATIVE* = 0x00000001 + VPF_DISABLERELATIVE* = 0x00000002 + VPF_DISABLESCALE* = 0x00000004 + OPF_OBJECTISLINK* = 0x00000001 + OPF_NOFILLDEFAULT* = 0x00000002 + OPF_SHOWHELP* = 0x00000004 + OPF_DISABLECONVERT* = 0x00000008 + OLEUI_OPERR_SUBPROPNULL* = OLEUI_ERR_STANDARDMAX+0 + OLEUI_OPERR_SUBPROPINVALID* = OLEUI_ERR_STANDARDMAX+1 + OLEUI_OPERR_PROPSHEETNULL* = OLEUI_ERR_STANDARDMAX+2 + OLEUI_OPERR_PROPSHEETINVALID* = OLEUI_ERR_STANDARDMAX+3 + OLEUI_OPERR_SUPPROP* = OLEUI_ERR_STANDARDMAX+4 + OLEUI_OPERR_PROPSINVALID* = OLEUI_ERR_STANDARDMAX+5 + OLEUI_OPERR_PAGESINCORRECT* = OLEUI_ERR_STANDARDMAX+6 + OLEUI_OPERR_INVALIDPAGES* = OLEUI_ERR_STANDARDMAX+7 + OLEUI_OPERR_NOTSUPPORTED* = OLEUI_ERR_STANDARDMAX+8 + OLEUI_OPERR_DLGPROCNOTNULL* = OLEUI_ERR_STANDARDMAX+9 + OLEUI_OPERR_LPARAMNOTZERO* = OLEUI_ERR_STANDARDMAX+10 + OLEUI_GPERR_STRINGINVALID* = OLEUI_ERR_STANDARDMAX+11 + OLEUI_GPERR_CLASSIDINVALID* = OLEUI_ERR_STANDARDMAX+12 + OLEUI_GPERR_LPCLSIDEXCLUDEINVALID* = OLEUI_ERR_STANDARDMAX+13 + OLEUI_GPERR_CBFORMATINVALID* = OLEUI_ERR_STANDARDMAX+14 + OLEUI_VPERR_METAPICTINVALID* = OLEUI_ERR_STANDARDMAX+15 + OLEUI_VPERR_DVASPECTINVALID* = OLEUI_ERR_STANDARDMAX+16 + OLEUI_LPERR_LINKCNTRNULL* = OLEUI_ERR_STANDARDMAX+17 + OLEUI_LPERR_LINKCNTRINVALID* = OLEUI_ERR_STANDARDMAX+18 + OLEUI_OPERR_PROPERTYSHEET* = OLEUI_ERR_STANDARDMAX+19 + OLEUI_OPERR_OBJINFOINVALID* = OLEUI_ERR_STANDARDMAX+20 + OLEUI_OPERR_LINKINFOINVALID* = OLEUI_ERR_STANDARDMAX+21 + OLEUI_QUERY_GETCLASSID* = 0xFF00 + OLEUI_QUERY_LINKBROKEN* = 0xFF01 +type + LPFNLRESULTFROMOBJECT* = proc (riid: REFIID, wParam: WPARAM, punk: LPUNKNOWN): LRESULT {.stdcall.} + LPFNOBJECTFROMLRESULT* = proc (lResult: LRESULT, riid: REFIID, wParam: WPARAM, ppvObject: ptr pointer): HRESULT {.stdcall.} + LPFNACCESSIBLEOBJECTFROMWINDOW* = proc (hwnd: HWND, dwId: DWORD, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + LPFNACCESSIBLEOBJECTFROMPOINT* = proc (ptScreen: POINT, ppacc: ptr ptr IAccessible, pvarChild: ptr VARIANT): HRESULT {.stdcall.} + LPFNCREATESTDACCESSIBLEOBJECT* = proc (hwnd: HWND, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + LPFNACCESSIBLECHILDREN* = proc (paccContainer: ptr IAccessible, iChildStart: LONG, cChildren: LONG, rgvarChildren: ptr VARIANT, pcObtained: ptr LONG): HRESULT {.stdcall.} + IAccIdentity* {.pure.} = object + lpVtbl*: ptr IAccIdentityVtbl + IAccIdentityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetIdentityString*: proc(self: ptr IAccIdentity, dwIDChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.stdcall.} + IAccPropServer* {.pure.} = object + lpVtbl*: ptr IAccPropServerVtbl + IAccPropServerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPropValue*: proc(self: ptr IAccPropServer, pIDString: ptr BYTE, dwIDStringLen: DWORD, idProp: MSAAPROPID, pvarValue: ptr VARIANT, pfHasProp: ptr WINBOOL): HRESULT {.stdcall.} + IAccPropServices* {.pure.} = object + lpVtbl*: ptr IAccPropServicesVtbl + IAccPropServicesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetPropValue*: proc(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.stdcall.} + SetPropServer*: proc(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.stdcall.} + ClearProps*: proc(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.stdcall.} + SetHwndProp*: proc(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.stdcall.} + SetHwndPropStr*: proc(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, idProp: MSAAPROPID, str: LPCWSTR): HRESULT {.stdcall.} + SetHwndPropServer*: proc(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.stdcall.} + ClearHwndProps*: proc(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.stdcall.} + ComposeHwndIdentityString*: proc(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.stdcall.} + DecomposeHwndIdentityString*: proc(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, phwnd: ptr HWND, pidObject: ptr DWORD, pidChild: ptr DWORD): HRESULT {.stdcall.} + SetHmenuProp*: proc(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.stdcall.} + SetHmenuPropStr*: proc(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, idProp: MSAAPROPID, str: LPCWSTR): HRESULT {.stdcall.} + SetHmenuPropServer*: proc(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.stdcall.} + ClearHmenuProps*: proc(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.stdcall.} + ComposeHmenuIdentityString*: proc(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.stdcall.} + DecomposeHmenuIdentityString*: proc(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, phmenu: ptr HMENU, pidChild: ptr DWORD): HRESULT {.stdcall.} + IActiveScriptError* {.pure.} = object + lpVtbl*: ptr IActiveScriptErrorVtbl + IActiveScriptErrorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetExceptionInfo*: proc(self: ptr IActiveScriptError, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} + GetSourcePosition*: proc(self: ptr IActiveScriptError, pdwSourceContext: ptr DWORD, pulLineNumber: ptr ULONG, plCharacterPosition: ptr LONG): HRESULT {.stdcall.} + GetSourceLineText*: proc(self: ptr IActiveScriptError, pbstrSourceLine: ptr BSTR): HRESULT {.stdcall.} + IActiveScriptSite* {.pure.} = object + lpVtbl*: ptr IActiveScriptSiteVtbl + IActiveScriptSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetLCID*: proc(self: ptr IActiveScriptSite, plcid: ptr LCID): HRESULT {.stdcall.} + GetItemInfo*: proc(self: ptr IActiveScriptSite, pstrName: LPCOLESTR, dwReturnMask: DWORD, ppiunkItem: ptr ptr IUnknown, ppti: ptr ptr ITypeInfo): HRESULT {.stdcall.} + GetDocVersionString*: proc(self: ptr IActiveScriptSite, pbstrVersion: ptr BSTR): HRESULT {.stdcall.} + OnScriptTerminate*: proc(self: ptr IActiveScriptSite, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.stdcall.} + OnStateChange*: proc(self: ptr IActiveScriptSite, ssScriptState: TSCRIPTSTATE): HRESULT {.stdcall.} + OnScriptError*: proc(self: ptr IActiveScriptSite, pscripterror: ptr IActiveScriptError): HRESULT {.stdcall.} + OnEnterScript*: proc(self: ptr IActiveScriptSite): HRESULT {.stdcall.} + OnLeaveScript*: proc(self: ptr IActiveScriptSite): HRESULT {.stdcall.} + IActiveScriptError64* {.pure.} = object + lpVtbl*: ptr IActiveScriptError64Vtbl + IActiveScriptError64Vtbl* {.pure, inheritable.} = object of IActiveScriptErrorVtbl + GetSourcePosition64*: proc(self: ptr IActiveScriptError64, pdwSourceContext: ptr DWORDLONG, pulLineNumber: ptr ULONG, plCharacterPosition: ptr LONG): HRESULT {.stdcall.} + IActiveScriptSiteWindow* {.pure.} = object + lpVtbl*: ptr IActiveScriptSiteWindowVtbl + IActiveScriptSiteWindowVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindow*: proc(self: ptr IActiveScriptSiteWindow, phwnd: ptr HWND): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IActiveScriptSiteWindow, fEnable: WINBOOL): HRESULT {.stdcall.} + IActiveScriptSiteUIControl* {.pure.} = object + lpVtbl*: ptr IActiveScriptSiteUIControlVtbl + IActiveScriptSiteUIControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetUIBehavior*: proc(self: ptr IActiveScriptSiteUIControl, UicItem: SCRIPTUICITEM, pUicHandling: ptr SCRIPTUICHANDLING): HRESULT {.stdcall.} + IActiveScriptSiteInterruptPoll* {.pure.} = object + lpVtbl*: ptr IActiveScriptSiteInterruptPollVtbl + IActiveScriptSiteInterruptPollVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryContinue*: proc(self: ptr IActiveScriptSiteInterruptPoll): HRESULT {.stdcall.} + IActiveScript* {.pure.} = object + lpVtbl*: ptr IActiveScriptVtbl + IActiveScriptVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetScriptSite*: proc(self: ptr IActiveScript, pass: ptr IActiveScriptSite): HRESULT {.stdcall.} + GetScriptSite*: proc(self: ptr IActiveScript, riid: REFIID, ppvObject: ptr pointer): HRESULT {.stdcall.} + SetScriptState*: proc(self: ptr IActiveScript, ss: TSCRIPTSTATE): HRESULT {.stdcall.} + GetScriptState*: proc(self: ptr IActiveScript, pssState: ptr TSCRIPTSTATE): HRESULT {.stdcall.} + Close*: proc(self: ptr IActiveScript): HRESULT {.stdcall.} + AddNamedItem*: proc(self: ptr IActiveScript, pstrName: LPCOLESTR, dwFlags: DWORD): HRESULT {.stdcall.} + AddTypeLib*: proc(self: ptr IActiveScript, rguidTypeLib: REFGUID, dwMajor: DWORD, dwMinor: DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + GetScriptDispatch*: proc(self: ptr IActiveScript, pstrItemName: LPCOLESTR, ppdisp: ptr ptr IDispatch): HRESULT {.stdcall.} + GetCurrentScriptThreadID*: proc(self: ptr IActiveScript, pstidThread: ptr SCRIPTTHREADID): HRESULT {.stdcall.} + GetScriptThreadID*: proc(self: ptr IActiveScript, dwWin32ThreadId: DWORD, pstidThread: ptr SCRIPTTHREADID): HRESULT {.stdcall.} + GetScriptThreadState*: proc(self: ptr IActiveScript, stidThread: SCRIPTTHREADID, pstsState: ptr SCRIPTTHREADSTATE): HRESULT {.stdcall.} + InterruptScriptThread*: proc(self: ptr IActiveScript, stidThread: SCRIPTTHREADID, pexcepinfo: ptr EXCEPINFO, dwFlags: DWORD): HRESULT {.stdcall.} + Clone*: proc(self: ptr IActiveScript, ppscript: ptr ptr IActiveScript): HRESULT {.stdcall.} + IActiveScriptEncode* {.pure.} = object + lpVtbl*: ptr IActiveScriptEncodeVtbl + IActiveScriptEncodeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EncodeSection*: proc(self: ptr IActiveScriptEncode, pchIn: LPCOLESTR, cchIn: DWORD, pchOut: LPOLESTR, cchOut: DWORD, pcchRet: ptr DWORD): HRESULT {.stdcall.} + DecodeScript*: proc(self: ptr IActiveScriptEncode, pchIn: LPCOLESTR, cchIn: DWORD, pchOut: LPOLESTR, cchOut: DWORD, pcchRet: ptr DWORD): HRESULT {.stdcall.} + GetEncodeProgId*: proc(self: ptr IActiveScriptEncode, pbstrOut: ptr BSTR): HRESULT {.stdcall.} + IActiveScriptHostEncode* {.pure.} = object + lpVtbl*: ptr IActiveScriptHostEncodeVtbl + IActiveScriptHostEncodeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EncodeScriptHostFile*: proc(self: ptr IActiveScriptHostEncode, bstrInFile: BSTR, pbstrOutFile: ptr BSTR, cFlags: ULONG, bstrDefaultLang: BSTR): HRESULT {.stdcall.} + IBindEventHandler* {.pure.} = object + lpVtbl*: ptr IBindEventHandlerVtbl + IBindEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BindHandler*: proc(self: ptr IBindEventHandler, pstrEvent: LPCOLESTR, pdisp: ptr IDispatch): HRESULT {.stdcall.} + IActiveScriptStats* {.pure.} = object + lpVtbl*: ptr IActiveScriptStatsVtbl + IActiveScriptStatsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetStat*: proc(self: ptr IActiveScriptStats, stid: DWORD, pluHi: ptr ULONG, pluLo: ptr ULONG): HRESULT {.stdcall.} + GetStatEx*: proc(self: ptr IActiveScriptStats, guid: REFGUID, pluHi: ptr ULONG, pluLo: ptr ULONG): HRESULT {.stdcall.} + ResetStats*: proc(self: ptr IActiveScriptStats): HRESULT {.stdcall.} + IActiveScriptProperty* {.pure.} = object + lpVtbl*: ptr IActiveScriptPropertyVtbl + IActiveScriptPropertyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetProperty*: proc(self: ptr IActiveScriptProperty, dwProperty: DWORD, pvarIndex: ptr VARIANT, pvarValue: ptr VARIANT): HRESULT {.stdcall.} + SetProperty*: proc(self: ptr IActiveScriptProperty, dwProperty: DWORD, pvarIndex: ptr VARIANT, pvarValue: ptr VARIANT): HRESULT {.stdcall.} + ITridentEventSink* {.pure.} = object + lpVtbl*: ptr ITridentEventSinkVtbl + ITridentEventSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FireEvent*: proc(self: ptr ITridentEventSink, pstrEvent: LPCOLESTR, pdp: ptr DISPPARAMS, pvarRes: ptr VARIANT, pei: ptr EXCEPINFO): HRESULT {.stdcall.} + IActiveScriptGarbageCollector* {.pure.} = object + lpVtbl*: ptr IActiveScriptGarbageCollectorVtbl + IActiveScriptGarbageCollectorVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CollectGarbage*: proc(self: ptr IActiveScriptGarbageCollector, scriptgctype: SCRIPTGCTYPE): HRESULT {.stdcall.} + IActiveScriptSIPInfo* {.pure.} = object + lpVtbl*: ptr IActiveScriptSIPInfoVtbl + IActiveScriptSIPInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSIPOID*: proc(self: ptr IActiveScriptSIPInfo, poid_sip: ptr GUID): HRESULT {.stdcall.} + IActiveScriptSiteTraceInfo* {.pure.} = object + lpVtbl*: ptr IActiveScriptSiteTraceInfoVtbl + IActiveScriptSiteTraceInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SendScriptTraceInfo*: proc(self: ptr IActiveScriptSiteTraceInfo, stiEventType: SCRIPTTRACEINFO, guidContextID: GUID, dwScriptContextCookie: DWORD, lScriptStatementStart: LONG, lScriptStatementEnd: LONG, dwReserved: DWORD64): HRESULT {.stdcall.} + IActiveScriptTraceInfo* {.pure.} = object + lpVtbl*: ptr IActiveScriptTraceInfoVtbl + IActiveScriptTraceInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartScriptTracing*: proc(self: ptr IActiveScriptTraceInfo, pSiteTraceInfo: ptr IActiveScriptSiteTraceInfo, guidContextID: GUID): HRESULT {.stdcall.} + StopScriptTracing*: proc(self: ptr IActiveScriptTraceInfo): HRESULT {.stdcall.} + IActiveScriptStringCompare* {.pure.} = object + lpVtbl*: ptr IActiveScriptStringCompareVtbl + IActiveScriptStringCompareVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StrComp*: proc(self: ptr IActiveScriptStringCompare, bszStr1: BSTR, bszStr2: BSTR, iRet: ptr LONG): HRESULT {.stdcall.} +proc LresultFromObject*(riid: REFIID, wParam: WPARAM, punk: LPUNKNOWN): LRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc ObjectFromLresult*(lResult: LRESULT, riid: REFIID, wParam: WPARAM, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc WindowFromAccessibleObject*(P1: ptr IAccessible, phwnd: ptr HWND): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc AccessibleObjectFromWindow*(hwnd: HWND, dwId: DWORD, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc AccessibleObjectFromEvent*(hwnd: HWND, dwId: DWORD, dwChildId: DWORD, ppacc: ptr ptr IAccessible, pvarChild: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc AccessibleObjectFromPoint*(ptScreen: POINT, ppacc: ptr ptr IAccessible, pvarChild: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc AccessibleChildren*(paccContainer: ptr IAccessible, iChildStart: LONG, cChildren: LONG, rgvarChildren: ptr VARIANT, pcObtained: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc GetRoleTextA*(lRole: DWORD, lpszRole: LPSTR, cchRoleMax: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc GetRoleTextW*(lRole: DWORD, lpszRole: LPWSTR, cchRoleMax: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc GetStateTextA*(lStateBit: DWORD, lpszState: LPSTR, cchState: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc GetStateTextW*(lStateBit: DWORD, lpszState: LPWSTR, cchState: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc GetOleaccVersionInfo*(pVer: ptr DWORD, pBuild: ptr DWORD): VOID {.winapi, stdcall, dynlib: "oleacc", importc.} +proc CreateStdAccessibleObject*(hwnd: HWND, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc CreateStdAccessibleProxyA*(hwnd: HWND, pClassName: LPCSTR, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc CreateStdAccessibleProxyW*(hwnd: HWND, pClassName: LPCWSTR, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc.} +proc DllRegisterServer*(): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DllUnregisterServer*(): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc OleCreatePropertyFrame*(hwndOwner: HWND, x: UINT, y: UINT, lpszCaption: LPCOLESTR, cObjects: ULONG, ppUnk: ptr LPUNKNOWN, cPages: ULONG, pPageClsID: LPCLSID, lcid: LCID, dwReserved: DWORD, pvReserved: LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleCreatePropertyFrameIndirect*(lpParams: LPOCPFIPARAMS): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleTranslateColor*(clr: OLE_COLOR, hpal: HPALETTE, lpcolorref: ptr COLORREF): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleCreateFontIndirect*(lpFontDesc: LPFONTDESC, riid: REFIID, lplpvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleCreatePictureIndirect*(lpPictDesc: LPPICTDESC, riid: REFIID, fOwn: WINBOOL, lplpvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleLoadPicture*(lpstream: LPSTREAM, lSize: LONG, fRunmode: WINBOOL, riid: REFIID, lplpvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleLoadPictureEx*(lpstream: LPSTREAM, lSize: LONG, fRunmode: WINBOOL, riid: REFIID, xSizeDesired: DWORD, ySizeDesired: DWORD, dwFlags: DWORD, lplpvObj: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleLoadPicturePath*(szURLorPath: LPOLESTR, punkCaller: LPUNKNOWN, dwReserved: DWORD, clrReserved: OLE_COLOR, riid: REFIID, ppvRet: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleLoadPictureFile*(varFileName: VARIANT, lplpdispPicture: ptr LPDISPATCH): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleLoadPictureFileEx*(varFileName: VARIANT, xSizeDesired: DWORD, ySizeDesired: DWORD, dwFlags: DWORD, lplpdispPicture: ptr LPDISPATCH): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleSavePictureFile*(lpdispPicture: LPDISPATCH, bstrFileName: BSTR): HRESULT {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleIconToCursor*(hinstExe: HINSTANCE, hIcon: HICON): HCURSOR {.winapi, stdcall, dynlib: "oleaut32", importc.} +proc OleUIAddVerbMenuW*(lpOleObj: LPOLEOBJECT, lpszShortType: LPCWSTR, hMenu: HMENU, uPos: UINT, uIDVerbMin: UINT, uIDVerbMax: UINT, bAddConvert: WINBOOL, idConvert: UINT, lphMenu: ptr HMENU): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIAddVerbMenuA*(lpOleObj: LPOLEOBJECT, lpszShortType: LPCSTR, hMenu: HMENU, uPos: UINT, uIDVerbMin: UINT, uIDVerbMax: UINT, bAddConvert: WINBOOL, idConvert: UINT, lphMenu: ptr HMENU): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIInsertObjectW*(P1: LPOLEUIINSERTOBJECTW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIInsertObjectA*(P1: LPOLEUIINSERTOBJECTA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIPasteSpecialW*(P1: LPOLEUIPASTESPECIALW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIPasteSpecialA*(P1: LPOLEUIPASTESPECIALA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIEditLinksW*(P1: LPOLEUIEDITLINKSW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIEditLinksA*(P1: LPOLEUIEDITLINKSA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIChangeIconW*(P1: LPOLEUICHANGEICONW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIChangeIconA*(P1: LPOLEUICHANGEICONA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIConvertW*(P1: LPOLEUICONVERTW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIConvertA*(P1: LPOLEUICONVERTA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUICanConvertOrActivateAs*(rClsid: REFCLSID, fIsLinkedObject: WINBOOL, wFormat: WORD): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIBusyW*(P1: LPOLEUIBUSYW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIBusyA*(P1: LPOLEUIBUSYA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIChangeSourceW*(P1: LPOLEUICHANGESOURCEW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIChangeSourceA*(P1: LPOLEUICHANGESOURCEA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIObjectPropertiesW*(P1: LPOLEUIOBJECTPROPSW): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIObjectPropertiesA*(P1: LPOLEUIOBJECTPROPSA): UINT {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIUpdateLinksW*(lpOleUILinkCntr: LPOLEUILINKCONTAINERW, hwndParent: HWND, lpszTitle: LPWSTR, cLinks: int32): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc.} +proc OleUIUpdateLinksA*(lpOleUILinkCntr: LPOLEUILINKCONTAINERA, hwndParent: HWND, lpszTitle: LPSTR, cLinks: int32): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc.} +proc `bmp=`*(self: var PICTDESC, x: PICTDESC_UNION1_bmp) {.inline.} = self.union1.bmp = x +proc bmp*(self: PICTDESC): PICTDESC_UNION1_bmp {.inline.} = self.union1.bmp +proc bmp*(self: var PICTDESC): var PICTDESC_UNION1_bmp {.inline.} = self.union1.bmp +proc `wmf=`*(self: var PICTDESC, x: PICTDESC_UNION1_wmf) {.inline.} = self.union1.wmf = x +proc wmf*(self: PICTDESC): PICTDESC_UNION1_wmf {.inline.} = self.union1.wmf +proc wmf*(self: var PICTDESC): var PICTDESC_UNION1_wmf {.inline.} = self.union1.wmf +proc `icon=`*(self: var PICTDESC, x: PICTDESC_UNION1_icon) {.inline.} = self.union1.icon = x +proc icon*(self: PICTDESC): PICTDESC_UNION1_icon {.inline.} = self.union1.icon +proc icon*(self: var PICTDESC): var PICTDESC_UNION1_icon {.inline.} = self.union1.icon +proc `emf=`*(self: var PICTDESC, x: PICTDESC_UNION1_emf) {.inline.} = self.union1.emf = x +proc emf*(self: PICTDESC): PICTDESC_UNION1_emf {.inline.} = self.union1.emf +proc emf*(self: var PICTDESC): var PICTDESC_UNION1_emf {.inline.} = self.union1.emf +proc get_accParent*(self: ptr IAccessible, ppdispParent: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accParent(self, ppdispParent) +proc get_accChildCount*(self: ptr IAccessible, pcountChildren: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accChildCount(self, pcountChildren) +proc get_accChild*(self: ptr IAccessible, varChildID: VARIANT, ppdispChild: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accChild(self, varChildID, ppdispChild) +proc get_accName*(self: ptr IAccessible, varID: VARIANT, pszName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accName(self, varID, pszName) +proc get_accValue*(self: ptr IAccessible, varID: VARIANT, pszValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accValue(self, varID, pszValue) +proc get_accDescription*(self: ptr IAccessible, varID: VARIANT, pszDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accDescription(self, varID, pszDescription) +proc get_accRole*(self: ptr IAccessible, varID: VARIANT, pvarRole: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accRole(self, varID, pvarRole) +proc get_accState*(self: ptr IAccessible, varID: VARIANT, pvarState: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accState(self, varID, pvarState) +proc get_accHelp*(self: ptr IAccessible, varID: VARIANT, pszHelp: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accHelp(self, varID, pszHelp) +proc get_accHelpTopic*(self: ptr IAccessible, pszHelpFile: ptr BSTR, varID: VARIANT, pidTopic: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accHelpTopic(self, pszHelpFile, varID, pidTopic) +proc get_accKeyboardShortcut*(self: ptr IAccessible, varID: VARIANT, pszKeyboardShortcut: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accKeyboardShortcut(self, varID, pszKeyboardShortcut) +proc get_accFocus*(self: ptr IAccessible, pvarID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accFocus(self, pvarID) +proc get_accSelection*(self: ptr IAccessible, pvarID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accSelection(self, pvarID) +proc get_accDefaultAction*(self: ptr IAccessible, varID: VARIANT, pszDefaultAction: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_accDefaultAction(self, varID, pszDefaultAction) +proc accSelect*(self: ptr IAccessible, flagsSelect: LONG, varID: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.accSelect(self, flagsSelect, varID) +proc accLocation*(self: ptr IAccessible, pxLeft: ptr LONG, pyTop: ptr LONG, pcxWidth: ptr LONG, pcyHeight: ptr LONG, varID: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.accLocation(self, pxLeft, pyTop, pcxWidth, pcyHeight, varID) +proc accNavigate*(self: ptr IAccessible, navDir: LONG, varStart: VARIANT, pvarEnd: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.accNavigate(self, navDir, varStart, pvarEnd) +proc accHitTest*(self: ptr IAccessible, xLeft: LONG, yTop: LONG, pvarID: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.accHitTest(self, xLeft, yTop, pvarID) +proc accDoDefaultAction*(self: ptr IAccessible, varID: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.accDoDefaultAction(self, varID) +proc put_accName*(self: ptr IAccessible, varID: VARIANT, pszName: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accName(self, varID, pszName) +proc put_accValue*(self: ptr IAccessible, varID: VARIANT, pszValue: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_accValue(self, varID, pszValue) +proc AccessibleObjectFromID*(self: ptr IAccessibleHandler, hwnd: LONG, lObjectID: LONG, pIAccessible: ptr LPACCESSIBLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AccessibleObjectFromID(self, hwnd, lObjectID, pIAccessible) +proc GetIdentityString*(self: ptr IAccIdentity, dwIDChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIdentityString(self, dwIDChild, ppIDString, pdwIDStringLen) +proc GetPropValue*(self: ptr IAccPropServer, pIDString: ptr BYTE, dwIDStringLen: DWORD, idProp: MSAAPROPID, pvarValue: ptr VARIANT, pfHasProp: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropValue(self, pIDString, dwIDStringLen, idProp, pvarValue, pfHasProp) +proc SetPropValue*(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropValue(self, pIDString, dwIDStringLen, idProp, `var`) +proc SetPropServer*(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropServer(self, pIDString, dwIDStringLen, paProps, cProps, pServer, annoScope) +proc ClearProps*(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearProps(self, pIDString, dwIDStringLen, paProps, cProps) +proc SetHwndProp*(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHwndProp(self, hwnd, idObject, idChild, idProp, `var`) +proc SetHwndPropStr*(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, idProp: MSAAPROPID, str: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHwndPropStr(self, hwnd, idObject, idChild, idProp, str) +proc SetHwndPropServer*(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHwndPropServer(self, hwnd, idObject, idChild, paProps, cProps, pServer, annoScope) +proc ClearHwndProps*(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearHwndProps(self, hwnd, idObject, idChild, paProps, cProps) +proc ComposeHwndIdentityString*(self: ptr IAccPropServices, hwnd: HWND, idObject: DWORD, idChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComposeHwndIdentityString(self, hwnd, idObject, idChild, ppIDString, pdwIDStringLen) +proc DecomposeHwndIdentityString*(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, phwnd: ptr HWND, pidObject: ptr DWORD, pidChild: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DecomposeHwndIdentityString(self, pIDString, dwIDStringLen, phwnd, pidObject, pidChild) +proc SetHmenuProp*(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, idProp: MSAAPROPID, `var`: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHmenuProp(self, hmenu, idChild, idProp, `var`) +proc SetHmenuPropStr*(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, idProp: MSAAPROPID, str: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHmenuPropStr(self, hmenu, idChild, idProp, str) +proc SetHmenuPropServer*(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32, pServer: ptr IAccPropServer, annoScope: AnnoScope): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHmenuPropServer(self, hmenu, idChild, paProps, cProps, pServer, annoScope) +proc ClearHmenuProps*(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, paProps: ptr MSAAPROPID, cProps: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearHmenuProps(self, hmenu, idChild, paProps, cProps) +proc ComposeHmenuIdentityString*(self: ptr IAccPropServices, hmenu: HMENU, idChild: DWORD, ppIDString: ptr ptr BYTE, pdwIDStringLen: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComposeHmenuIdentityString(self, hmenu, idChild, ppIDString, pdwIDStringLen) +proc DecomposeHmenuIdentityString*(self: ptr IAccPropServices, pIDString: ptr BYTE, dwIDStringLen: DWORD, phmenu: ptr HMENU, pidChild: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DecomposeHmenuIdentityString(self, pIDString, dwIDStringLen, phmenu, pidChild) +proc GetInterfaceSafetyOptions*(self: ptr IObjectSafety, riid: REFIID, pdwSupportedOptions: ptr DWORD, pdwEnabledOptions: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInterfaceSafetyOptions(self, riid, pdwSupportedOptions, pdwEnabledOptions) +proc SetInterfaceSafetyOptions*(self: ptr IObjectSafety, riid: REFIID, dwOptionSetMask: DWORD, dwEnabledOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInterfaceSafetyOptions(self, riid, dwOptionSetMask, dwEnabledOptions) +proc GetLCID*(self: ptr IActiveScriptSite, plcid: ptr LCID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLCID(self, plcid) +proc GetItemInfo*(self: ptr IActiveScriptSite, pstrName: LPCOLESTR, dwReturnMask: DWORD, ppiunkItem: ptr ptr IUnknown, ppti: ptr ptr ITypeInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemInfo(self, pstrName, dwReturnMask, ppiunkItem, ppti) +proc GetDocVersionString*(self: ptr IActiveScriptSite, pbstrVersion: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDocVersionString(self, pbstrVersion) +proc OnScriptTerminate*(self: ptr IActiveScriptSite, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnScriptTerminate(self, pvarResult, pexcepinfo) +proc OnStateChange*(self: ptr IActiveScriptSite, ssScriptState: TSCRIPTSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStateChange(self, ssScriptState) +proc OnScriptError*(self: ptr IActiveScriptSite, pscripterror: ptr IActiveScriptError): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnScriptError(self, pscripterror) +proc OnEnterScript*(self: ptr IActiveScriptSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnEnterScript(self) +proc OnLeaveScript*(self: ptr IActiveScriptSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnLeaveScript(self) +proc GetExceptionInfo*(self: ptr IActiveScriptError, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExceptionInfo(self, pexcepinfo) +proc GetSourcePosition*(self: ptr IActiveScriptError, pdwSourceContext: ptr DWORD, pulLineNumber: ptr ULONG, plCharacterPosition: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourcePosition(self, pdwSourceContext, pulLineNumber, plCharacterPosition) +proc GetSourceLineText*(self: ptr IActiveScriptError, pbstrSourceLine: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourceLineText(self, pbstrSourceLine) +proc GetSourcePosition64*(self: ptr IActiveScriptError64, pdwSourceContext: ptr DWORDLONG, pulLineNumber: ptr ULONG, plCharacterPosition: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSourcePosition64(self, pdwSourceContext, pulLineNumber, plCharacterPosition) +proc GetWindow*(self: ptr IActiveScriptSiteWindow, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindow(self, phwnd) +proc EnableModeless*(self: ptr IActiveScriptSiteWindow, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc GetUIBehavior*(self: ptr IActiveScriptSiteUIControl, UicItem: SCRIPTUICITEM, pUicHandling: ptr SCRIPTUICHANDLING): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUIBehavior(self, UicItem, pUicHandling) +proc QueryContinue*(self: ptr IActiveScriptSiteInterruptPoll): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryContinue(self) +proc SetScriptSite*(self: ptr IActiveScript, pass: ptr IActiveScriptSite): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScriptSite(self, pass) +proc GetScriptSite*(self: ptr IActiveScript, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScriptSite(self, riid, ppvObject) +proc SetScriptState*(self: ptr IActiveScript, ss: TSCRIPTSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScriptState(self, ss) +proc GetScriptState*(self: ptr IActiveScript, pssState: ptr TSCRIPTSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScriptState(self, pssState) +proc Close*(self: ptr IActiveScript): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self) +proc AddNamedItem*(self: ptr IActiveScript, pstrName: LPCOLESTR, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddNamedItem(self, pstrName, dwFlags) +proc AddTypeLib*(self: ptr IActiveScript, rguidTypeLib: REFGUID, dwMajor: DWORD, dwMinor: DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTypeLib(self, rguidTypeLib, dwMajor, dwMinor, dwFlags) +proc GetScriptDispatch*(self: ptr IActiveScript, pstrItemName: LPCOLESTR, ppdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScriptDispatch(self, pstrItemName, ppdisp) +proc GetCurrentScriptThreadID*(self: ptr IActiveScript, pstidThread: ptr SCRIPTTHREADID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentScriptThreadID(self, pstidThread) +proc GetScriptThreadID*(self: ptr IActiveScript, dwWin32ThreadId: DWORD, pstidThread: ptr SCRIPTTHREADID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScriptThreadID(self, dwWin32ThreadId, pstidThread) +proc GetScriptThreadState*(self: ptr IActiveScript, stidThread: SCRIPTTHREADID, pstsState: ptr SCRIPTTHREADSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScriptThreadState(self, stidThread, pstsState) +proc InterruptScriptThread*(self: ptr IActiveScript, stidThread: SCRIPTTHREADID, pexcepinfo: ptr EXCEPINFO, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InterruptScriptThread(self, stidThread, pexcepinfo, dwFlags) +proc Clone*(self: ptr IActiveScript, ppscript: ptr ptr IActiveScript): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppscript) +proc InitNew*(self: ptr IActiveScriptParse32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc AddScriptlet*(self: ptr IActiveScriptParse32, pstrDefaultName: LPCOLESTR, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, pstrSubItemName: LPCOLESTR, pstrEventName: LPCOLESTR, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, pbstrName: ptr BSTR, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddScriptlet(self, pstrDefaultName, pstrCode, pstrItemName, pstrSubItemName, pstrEventName, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, pbstrName, pexcepinfo) +proc ParseScriptText*(self: ptr IActiveScriptParse32, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseScriptText(self, pstrCode, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, pvarResult, pexcepinfo) +proc InitNew*(self: ptr IActiveScriptParse64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitNew(self) +proc AddScriptlet*(self: ptr IActiveScriptParse64, pstrDefaultName: LPCOLESTR, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, pstrSubItemName: LPCOLESTR, pstrEventName: LPCOLESTR, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, pbstrName: ptr BSTR, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddScriptlet(self, pstrDefaultName, pstrCode, pstrItemName, pstrSubItemName, pstrEventName, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, pbstrName, pexcepinfo) +proc ParseScriptText*(self: ptr IActiveScriptParse64, pstrCode: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, pvarResult: ptr VARIANT, pexcepinfo: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseScriptText(self, pstrCode, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, pvarResult, pexcepinfo) +proc ParseProcedureText*(self: ptr IActiveScriptParseProcedureOld32, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseProcedureText(self, pstrCode, pstrFormalParams, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, ppdisp) +proc ParseProcedureText*(self: ptr IActiveScriptParseProcedureOld64, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseProcedureText(self, pstrCode, pstrFormalParams, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, ppdisp) +proc ParseProcedureText*(self: ptr IActiveScriptParseProcedure32, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrProcedureName: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORD, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseProcedureText(self, pstrCode, pstrFormalParams, pstrProcedureName, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, ppdisp) +proc ParseProcedureText*(self: ptr IActiveScriptParseProcedure64, pstrCode: LPCOLESTR, pstrFormalParams: LPCOLESTR, pstrProcedureName: LPCOLESTR, pstrItemName: LPCOLESTR, punkContext: ptr IUnknown, pstrDelimiter: LPCOLESTR, dwSourceContextCookie: DWORDLONG, ulStartingLineNumber: ULONG, dwFlags: DWORD, ppdisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseProcedureText(self, pstrCode, pstrFormalParams, pstrProcedureName, pstrItemName, punkContext, pstrDelimiter, dwSourceContextCookie, ulStartingLineNumber, dwFlags, ppdisp) +proc EncodeSection*(self: ptr IActiveScriptEncode, pchIn: LPCOLESTR, cchIn: DWORD, pchOut: LPOLESTR, cchOut: DWORD, pcchRet: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EncodeSection(self, pchIn, cchIn, pchOut, cchOut, pcchRet) +proc DecodeScript*(self: ptr IActiveScriptEncode, pchIn: LPCOLESTR, cchIn: DWORD, pchOut: LPOLESTR, cchOut: DWORD, pcchRet: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DecodeScript(self, pchIn, cchIn, pchOut, cchOut, pcchRet) +proc GetEncodeProgId*(self: ptr IActiveScriptEncode, pbstrOut: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEncodeProgId(self, pbstrOut) +proc EncodeScriptHostFile*(self: ptr IActiveScriptHostEncode, bstrInFile: BSTR, pbstrOutFile: ptr BSTR, cFlags: ULONG, bstrDefaultLang: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EncodeScriptHostFile(self, bstrInFile, pbstrOutFile, cFlags, bstrDefaultLang) +proc BindHandler*(self: ptr IBindEventHandler, pstrEvent: LPCOLESTR, pdisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindHandler(self, pstrEvent, pdisp) +proc GetStat*(self: ptr IActiveScriptStats, stid: DWORD, pluHi: ptr ULONG, pluLo: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStat(self, stid, pluHi, pluLo) +proc GetStatEx*(self: ptr IActiveScriptStats, guid: REFGUID, pluHi: ptr ULONG, pluLo: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStatEx(self, guid, pluHi, pluLo) +proc ResetStats*(self: ptr IActiveScriptStats): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetStats(self) +proc GetProperty*(self: ptr IActiveScriptProperty, dwProperty: DWORD, pvarIndex: ptr VARIANT, pvarValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, dwProperty, pvarIndex, pvarValue) +proc SetProperty*(self: ptr IActiveScriptProperty, dwProperty: DWORD, pvarIndex: ptr VARIANT, pvarValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProperty(self, dwProperty, pvarIndex, pvarValue) +proc FireEvent*(self: ptr ITridentEventSink, pstrEvent: LPCOLESTR, pdp: ptr DISPPARAMS, pvarRes: ptr VARIANT, pei: ptr EXCEPINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FireEvent(self, pstrEvent, pdp, pvarRes, pei) +proc CollectGarbage*(self: ptr IActiveScriptGarbageCollector, scriptgctype: SCRIPTGCTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CollectGarbage(self, scriptgctype) +proc GetSIPOID*(self: ptr IActiveScriptSIPInfo, poid_sip: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSIPOID(self, poid_sip) +proc SendScriptTraceInfo*(self: ptr IActiveScriptSiteTraceInfo, stiEventType: SCRIPTTRACEINFO, guidContextID: GUID, dwScriptContextCookie: DWORD, lScriptStatementStart: LONG, lScriptStatementEnd: LONG, dwReserved: DWORD64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendScriptTraceInfo(self, stiEventType, guidContextID, dwScriptContextCookie, lScriptStatementStart, lScriptStatementEnd, dwReserved) +proc StartScriptTracing*(self: ptr IActiveScriptTraceInfo, pSiteTraceInfo: ptr IActiveScriptSiteTraceInfo, guidContextID: GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartScriptTracing(self, pSiteTraceInfo, guidContextID) +proc StopScriptTracing*(self: ptr IActiveScriptTraceInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopScriptTracing(self) +proc StrComp*(self: ptr IActiveScriptStringCompare, bszStr1: BSTR, bszStr2: BSTR, iRet: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StrComp(self, bszStr1, bszStr2, iRet) +proc GetNextLink*(self: ptr IOleUILinkContainerW, dwLink: DWORD): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextLink(self, dwLink) +proc SetLinkUpdateOptions*(self: ptr IOleUILinkContainerW, dwLink: DWORD, dwUpdateOpt: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLinkUpdateOptions(self, dwLink, dwUpdateOpt) +proc GetLinkUpdateOptions*(self: ptr IOleUILinkContainerW, dwLink: DWORD, lpdwUpdateOpt: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLinkUpdateOptions(self, dwLink, lpdwUpdateOpt) +proc SetLinkSource*(self: ptr IOleUILinkContainerW, dwLink: DWORD, lpszDisplayName: LPWSTR, lenFileName: ULONG, pchEaten: ptr ULONG, fValidateSource: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLinkSource(self, dwLink, lpszDisplayName, lenFileName, pchEaten, fValidateSource) +proc GetLinkSource*(self: ptr IOleUILinkContainerW, dwLink: DWORD, lplpszDisplayName: ptr LPWSTR, lplenFileName: ptr ULONG, lplpszFullLinkType: ptr LPWSTR, lplpszShortLinkType: ptr LPWSTR, lpfSourceAvailable: ptr WINBOOL, lpfIsSelected: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLinkSource(self, dwLink, lplpszDisplayName, lplenFileName, lplpszFullLinkType, lplpszShortLinkType, lpfSourceAvailable, lpfIsSelected) +proc OpenLinkSource*(self: ptr IOleUILinkContainerW, dwLink: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenLinkSource(self, dwLink) +proc UpdateLink*(self: ptr IOleUILinkContainerW, dwLink: DWORD, fErrorMessage: WINBOOL, fReserved: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateLink(self, dwLink, fErrorMessage, fReserved) +proc CancelLink*(self: ptr IOleUILinkContainerW, dwLink: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CancelLink(self, dwLink) +proc GetNextLink*(self: ptr IOleUILinkContainerA, dwLink: DWORD): DWORD {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextLink(self, dwLink) +proc SetLinkUpdateOptions*(self: ptr IOleUILinkContainerA, dwLink: DWORD, dwUpdateOpt: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLinkUpdateOptions(self, dwLink, dwUpdateOpt) +proc GetLinkUpdateOptions*(self: ptr IOleUILinkContainerA, dwLink: DWORD, lpdwUpdateOpt: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLinkUpdateOptions(self, dwLink, lpdwUpdateOpt) +proc SetLinkSource*(self: ptr IOleUILinkContainerA, dwLink: DWORD, lpszDisplayName: LPSTR, lenFileName: ULONG, pchEaten: ptr ULONG, fValidateSource: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLinkSource(self, dwLink, lpszDisplayName, lenFileName, pchEaten, fValidateSource) +proc GetLinkSource*(self: ptr IOleUILinkContainerA, dwLink: DWORD, lplpszDisplayName: ptr LPSTR, lplenFileName: ptr ULONG, lplpszFullLinkType: ptr LPSTR, lplpszShortLinkType: ptr LPSTR, lpfSourceAvailable: ptr WINBOOL, lpfIsSelected: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLinkSource(self, dwLink, lplpszDisplayName, lplenFileName, lplpszFullLinkType, lplpszShortLinkType, lpfSourceAvailable, lpfIsSelected) +proc OpenLinkSource*(self: ptr IOleUILinkContainerA, dwLink: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenLinkSource(self, dwLink) +proc UpdateLink*(self: ptr IOleUILinkContainerA, dwLink: DWORD, fErrorMessage: WINBOOL, fReserved: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateLink(self, dwLink, fErrorMessage, fReserved) +proc CancelLink*(self: ptr IOleUILinkContainerA, dwLink: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CancelLink(self, dwLink) +proc GetObjectInfo*(self: ptr IOleUIObjInfoW, dwObject: DWORD, lpdwObjSize: ptr DWORD, lplpszLabel: ptr LPWSTR, lplpszType: ptr LPWSTR, lplpszShortType: ptr LPWSTR, lplpszLocation: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectInfo(self, dwObject, lpdwObjSize, lplpszLabel, lplpszType, lplpszShortType, lplpszLocation) +proc GetConvertInfo*(self: ptr IOleUIObjInfoW, dwObject: DWORD, lpClassID: ptr CLSID, lpwFormat: ptr WORD, lpConvertDefaultClassID: ptr CLSID, lplpClsidExclude: ptr LPCLSID, lpcClsidExclude: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConvertInfo(self, dwObject, lpClassID, lpwFormat, lpConvertDefaultClassID, lplpClsidExclude, lpcClsidExclude) +proc ConvertObject*(self: ptr IOleUIObjInfoW, dwObject: DWORD, clsidNew: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConvertObject(self, dwObject, clsidNew) +proc GetViewInfo*(self: ptr IOleUIObjInfoW, dwObject: DWORD, phMetaPict: ptr HGLOBAL, pdvAspect: ptr DWORD, pnCurrentScale: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewInfo(self, dwObject, phMetaPict, pdvAspect, pnCurrentScale) +proc SetViewInfo*(self: ptr IOleUIObjInfoW, dwObject: DWORD, hMetaPict: HGLOBAL, dvAspect: DWORD, nCurrentScale: int32, bRelativeToOrig: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetViewInfo(self, dwObject, hMetaPict, dvAspect, nCurrentScale, bRelativeToOrig) +proc GetObjectInfo*(self: ptr IOleUIObjInfoA, dwObject: DWORD, lpdwObjSize: ptr DWORD, lplpszLabel: ptr LPSTR, lplpszType: ptr LPSTR, lplpszShortType: ptr LPSTR, lplpszLocation: ptr LPSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectInfo(self, dwObject, lpdwObjSize, lplpszLabel, lplpszType, lplpszShortType, lplpszLocation) +proc GetConvertInfo*(self: ptr IOleUIObjInfoA, dwObject: DWORD, lpClassID: ptr CLSID, lpwFormat: ptr WORD, lpConvertDefaultClassID: ptr CLSID, lplpClsidExclude: ptr LPCLSID, lpcClsidExclude: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConvertInfo(self, dwObject, lpClassID, lpwFormat, lpConvertDefaultClassID, lplpClsidExclude, lpcClsidExclude) +proc ConvertObject*(self: ptr IOleUIObjInfoA, dwObject: DWORD, clsidNew: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConvertObject(self, dwObject, clsidNew) +proc GetViewInfo*(self: ptr IOleUIObjInfoA, dwObject: DWORD, phMetaPict: ptr HGLOBAL, pdvAspect: ptr DWORD, pnCurrentScale: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewInfo(self, dwObject, phMetaPict, pdvAspect, pnCurrentScale) +proc SetViewInfo*(self: ptr IOleUIObjInfoA, dwObject: DWORD, hMetaPict: HGLOBAL, dvAspect: DWORD, nCurrentScale: int32, bRelativeToOrig: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetViewInfo(self, dwObject, hMetaPict, dvAspect, nCurrentScale, bRelativeToOrig) +proc GetLastUpdate*(self: ptr IOleUILinkInfoW, dwLink: DWORD, lpLastUpdate: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastUpdate(self, dwLink, lpLastUpdate) +proc GetLastUpdate*(self: ptr IOleUILinkInfoA, dwLink: DWORD, lpLastUpdate: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastUpdate(self, dwLink, lpLastUpdate) +converter winimConverterIAccessibleToIDispatch*(x: ptr IAccessible): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIAccessibleToIUnknown*(x: ptr IAccessible): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibleHandlerToIUnknown*(x: ptr IAccessibleHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccIdentityToIUnknown*(x: ptr IAccIdentity): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccPropServerToIUnknown*(x: ptr IAccPropServer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccPropServicesToIUnknown*(x: ptr IAccPropServices): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectSafetyToIUnknown*(x: ptr IObjectSafety): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSiteToIUnknown*(x: ptr IActiveScriptSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptErrorToIUnknown*(x: ptr IActiveScriptError): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptError64ToIActiveScriptError*(x: ptr IActiveScriptError64): ptr IActiveScriptError = cast[ptr IActiveScriptError](x) +converter winimConverterIActiveScriptError64ToIUnknown*(x: ptr IActiveScriptError64): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSiteWindowToIUnknown*(x: ptr IActiveScriptSiteWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSiteUIControlToIUnknown*(x: ptr IActiveScriptSiteUIControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSiteInterruptPollToIUnknown*(x: ptr IActiveScriptSiteInterruptPoll): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptToIUnknown*(x: ptr IActiveScript): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParse32ToIUnknown*(x: ptr IActiveScriptParse32): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParse64ToIUnknown*(x: ptr IActiveScriptParse64): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedureOld32ToIUnknown*(x: ptr IActiveScriptParseProcedureOld32): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedureOld64ToIUnknown*(x: ptr IActiveScriptParseProcedureOld64): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedure32ToIUnknown*(x: ptr IActiveScriptParseProcedure32): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedure64ToIUnknown*(x: ptr IActiveScriptParseProcedure64): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedure2_32ToIActiveScriptParseProcedure32*(x: ptr IActiveScriptParseProcedure2_32): ptr IActiveScriptParseProcedure32 = cast[ptr IActiveScriptParseProcedure32](x) +converter winimConverterIActiveScriptParseProcedure2_32ToIUnknown*(x: ptr IActiveScriptParseProcedure2_32): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptParseProcedure2_64ToIActiveScriptParseProcedure64*(x: ptr IActiveScriptParseProcedure2_64): ptr IActiveScriptParseProcedure64 = cast[ptr IActiveScriptParseProcedure64](x) +converter winimConverterIActiveScriptParseProcedure2_64ToIUnknown*(x: ptr IActiveScriptParseProcedure2_64): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptEncodeToIUnknown*(x: ptr IActiveScriptEncode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptHostEncodeToIUnknown*(x: ptr IActiveScriptHostEncode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBindEventHandlerToIUnknown*(x: ptr IBindEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptStatsToIUnknown*(x: ptr IActiveScriptStats): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptPropertyToIUnknown*(x: ptr IActiveScriptProperty): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITridentEventSinkToIUnknown*(x: ptr ITridentEventSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptGarbageCollectorToIUnknown*(x: ptr IActiveScriptGarbageCollector): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSIPInfoToIUnknown*(x: ptr IActiveScriptSIPInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptSiteTraceInfoToIUnknown*(x: ptr IActiveScriptSiteTraceInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptTraceInfoToIUnknown*(x: ptr IActiveScriptTraceInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveScriptStringCompareToIUnknown*(x: ptr IActiveScriptStringCompare): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUILinkContainerWToIUnknown*(x: ptr IOleUILinkContainerW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUILinkContainerAToIUnknown*(x: ptr IOleUILinkContainerA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUIObjInfoWToIUnknown*(x: ptr IOleUIObjInfoW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUIObjInfoAToIUnknown*(x: ptr IOleUIObjInfoA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUILinkInfoWToIOleUILinkContainerW*(x: ptr IOleUILinkInfoW): ptr IOleUILinkContainerW = cast[ptr IOleUILinkContainerW](x) +converter winimConverterIOleUILinkInfoWToIUnknown*(x: ptr IOleUILinkInfoW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOleUILinkInfoAToIOleUILinkContainerA*(x: ptr IOleUILinkInfoA): ptr IOleUILinkContainerA = cast[ptr IOleUILinkContainerA](x) +converter winimConverterIOleUILinkInfoAToIUnknown*(x: ptr IOleUILinkInfoA): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + TOLEUIINSERTOBJECT* = TOLEUIINSERTOBJECTW + POLEUIINSERTOBJECT* = POLEUIINSERTOBJECTW + LPOLEUIINSERTOBJECT* = LPOLEUIINSERTOBJECTW + OLEUIPASTEENTRY* = OLEUIPASTEENTRYW + POLEUIPASTEENTRY* = POLEUIPASTEENTRYW + LPOLEUIPASTEENTRY* = LPOLEUIPASTEENTRYW + TOLEUIPASTESPECIAL* = TOLEUIPASTESPECIALW + POLEUIPASTESPECIAL* = POLEUIPASTESPECIALW + LPOLEUIPASTESPECIAL* = LPOLEUIPASTESPECIALW + IOleUILinkContainer* = IOleUILinkContainerW + LPOLEUILINKCONTAINER* = LPOLEUILINKCONTAINERW + TOLEUIEDITLINKS* = TOLEUIEDITLINKSW + POLEUIEDITLINKS* = POLEUIEDITLINKSW + LPOLEUIEDITLINKS* = LPOLEUIEDITLINKSW + TOLEUICHANGEICON* = TOLEUICHANGEICONW + POLEUICHANGEICON* = POLEUICHANGEICONW + LPOLEUICHANGEICON* = LPOLEUICHANGEICONW + TOLEUICONVERT* = TOLEUICONVERTW + POLEUICONVERT* = POLEUICONVERTW + LPOLEUICONVERT* = LPOLEUICONVERTW + TOLEUIBUSY* = TOLEUIBUSYW + POLEUIBUSY* = POLEUIBUSYW + LPOLEUIBUSY* = LPOLEUIBUSYW + TOLEUICHANGESOURCE* = TOLEUICHANGESOURCEW + POLEUICHANGESOURCE* = POLEUICHANGESOURCEW + LPOLEUICHANGESOURCE* = LPOLEUICHANGESOURCEW + IOleUIObjInfo* = IOleUIObjInfoW + LPOLEUIOBJINFO* = LPOLEUIOBJINFOW + IOleUILinkInfo* = IOleUILinkInfoW + LPOLEUILINKINFO* = LPOLEUILINKINFOW + OLEUIGNRLPROPS* = OLEUIGNRLPROPSW + POLEUIGNRLPROPS* = POLEUIGNRLPROPSW + LPOLEUIGNRLPROPS* = LPOLEUIGNRLPROPSW + OLEUIVIEWPROPS* = OLEUIVIEWPROPSW + POLEUIVIEWPROPS* = POLEUIVIEWPROPSW + LPOLEUIVIEWPROPS* = LPOLEUIVIEWPROPSW + OLEUILINKPROPS* = OLEUILINKPROPSW + POLEUILINKPROPS* = POLEUILINKPROPSW + LPOLEUILINKPROPS* = LPOLEUILINKPROPSW + OLEUIOBJECTPROPS* = OLEUIOBJECTPROPSW + POLEUIOBJECTPROPS* = POLEUIOBJECTPROPSW + LPOLEUIOBJECTPROPS* = LPOLEUIOBJECTPROPSW + const + IDD_SERVERNOTREG* = IDD_SERVERNOTREGW + IDD_LINKTYPECHANGED* = IDD_LINKTYPECHANGEDW + proc GetRoleText*(lRole: DWORD, lpszRole: LPWSTR, cchRoleMax: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc: "GetRoleTextW".} + proc GetStateText*(lStateBit: DWORD, lpszState: LPWSTR, cchState: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc: "GetStateTextW".} + proc CreateStdAccessibleProxy*(hwnd: HWND, pClassName: LPCWSTR, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc: "CreateStdAccessibleProxyW".} + proc OleUIAddVerbMenu*(lpOleObj: LPOLEOBJECT, lpszShortType: LPCWSTR, hMenu: HMENU, uPos: UINT, uIDVerbMin: UINT, uIDVerbMax: UINT, bAddConvert: WINBOOL, idConvert: UINT, lphMenu: ptr HMENU): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIAddVerbMenuW".} + proc OleUIInsertObject*(P1: LPOLEUIINSERTOBJECTW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIInsertObjectW".} + proc OleUIPasteSpecial*(P1: LPOLEUIPASTESPECIALW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIPasteSpecialW".} + proc OleUIEditLinks*(P1: LPOLEUIEDITLINKSW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIEditLinksW".} + proc OleUIChangeIcon*(P1: LPOLEUICHANGEICONW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIChangeIconW".} + proc OleUIConvert*(P1: LPOLEUICONVERTW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIConvertW".} + proc OleUIBusy*(P1: LPOLEUIBUSYW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIBusyW".} + proc OleUIChangeSource*(P1: LPOLEUICHANGESOURCEW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIChangeSourceW".} + proc OleUIObjectProperties*(P1: LPOLEUIOBJECTPROPSW): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIObjectPropertiesW".} + proc OleUIUpdateLinks*(lpOleUILinkCntr: LPOLEUILINKCONTAINERW, hwndParent: HWND, lpszTitle: LPWSTR, cLinks: int32): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIUpdateLinksW".} +when winimAnsi: + type + TOLEUIINSERTOBJECT* = TOLEUIINSERTOBJECTA + POLEUIINSERTOBJECT* = POLEUIINSERTOBJECTA + LPOLEUIINSERTOBJECT* = LPOLEUIINSERTOBJECTA + OLEUIPASTEENTRY* = OLEUIPASTEENTRYA + POLEUIPASTEENTRY* = POLEUIPASTEENTRYA + LPOLEUIPASTEENTRY* = LPOLEUIPASTEENTRYA + TOLEUIPASTESPECIAL* = TOLEUIPASTESPECIALA + POLEUIPASTESPECIAL* = POLEUIPASTESPECIALA + LPOLEUIPASTESPECIAL* = LPOLEUIPASTESPECIALA + IOleUILinkContainer* = IOleUILinkContainerA + LPOLEUILINKCONTAINER* = LPOLEUILINKCONTAINERA + TOLEUIEDITLINKS* = TOLEUIEDITLINKSA + POLEUIEDITLINKS* = POLEUIEDITLINKSA + LPOLEUIEDITLINKS* = LPOLEUIEDITLINKSA + TOLEUICHANGEICON* = TOLEUICHANGEICONA + POLEUICHANGEICON* = POLEUICHANGEICONA + LPOLEUICHANGEICON* = LPOLEUICHANGEICONA + TOLEUICONVERT* = TOLEUICONVERTA + POLEUICONVERT* = POLEUICONVERTA + LPOLEUICONVERT* = LPOLEUICONVERTA + TOLEUIBUSY* = TOLEUIBUSYA + POLEUIBUSY* = POLEUIBUSYA + LPOLEUIBUSY* = LPOLEUIBUSYA + TOLEUICHANGESOURCE* = TOLEUICHANGESOURCEA + POLEUICHANGESOURCE* = POLEUICHANGESOURCEA + LPOLEUICHANGESOURCE* = LPOLEUICHANGESOURCEA + IOleUIObjInfo* = IOleUIObjInfoA + LPOLEUIOBJINFO* = LPOLEUIOBJINFOA + IOleUILinkInfo* = IOleUILinkInfoA + LPOLEUILINKINFO* = LPOLEUILINKINFOA + OLEUIGNRLPROPS* = OLEUIGNRLPROPSA + POLEUIGNRLPROPS* = POLEUIGNRLPROPSA + LPOLEUIGNRLPROPS* = LPOLEUIGNRLPROPSA + OLEUIVIEWPROPS* = OLEUIVIEWPROPSA + POLEUIVIEWPROPS* = POLEUIVIEWPROPSA + LPOLEUIVIEWPROPS* = LPOLEUIVIEWPROPSA + OLEUILINKPROPS* = OLEUILINKPROPSA + POLEUILINKPROPS* = POLEUILINKPROPSA + LPOLEUILINKPROPS* = LPOLEUILINKPROPSA + OLEUIOBJECTPROPS* = OLEUIOBJECTPROPSA + POLEUIOBJECTPROPS* = POLEUIOBJECTPROPSA + LPOLEUIOBJECTPROPS* = LPOLEUIOBJECTPROPSA + const + IDD_SERVERNOTREG* = IDD_SERVERNOTREGA + IDD_LINKTYPECHANGED* = IDD_LINKTYPECHANGEDA + proc GetRoleText*(lRole: DWORD, lpszRole: LPSTR, cchRoleMax: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc: "GetRoleTextA".} + proc GetStateText*(lStateBit: DWORD, lpszState: LPSTR, cchState: UINT): UINT {.winapi, stdcall, dynlib: "oleacc", importc: "GetStateTextA".} + proc CreateStdAccessibleProxy*(hwnd: HWND, pClassName: LPCSTR, idObject: LONG, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "oleacc", importc: "CreateStdAccessibleProxyA".} + proc OleUIAddVerbMenu*(lpOleObj: LPOLEOBJECT, lpszShortType: LPCSTR, hMenu: HMENU, uPos: UINT, uIDVerbMin: UINT, uIDVerbMax: UINT, bAddConvert: WINBOOL, idConvert: UINT, lphMenu: ptr HMENU): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIAddVerbMenuA".} + proc OleUIInsertObject*(P1: LPOLEUIINSERTOBJECTA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIInsertObjectA".} + proc OleUIPasteSpecial*(P1: LPOLEUIPASTESPECIALA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIPasteSpecialA".} + proc OleUIEditLinks*(P1: LPOLEUIEDITLINKSA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIEditLinksA".} + proc OleUIChangeIcon*(P1: LPOLEUICHANGEICONA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIChangeIconA".} + proc OleUIConvert*(P1: LPOLEUICONVERTA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIConvertA".} + proc OleUIBusy*(P1: LPOLEUIBUSYA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIBusyA".} + proc OleUIChangeSource*(P1: LPOLEUICHANGESOURCEA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIChangeSourceA".} + proc OleUIObjectProperties*(P1: LPOLEUIOBJECTPROPSA): UINT {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIObjectPropertiesA".} + proc OleUIUpdateLinks*(lpOleUILinkCntr: LPOLEUILINKCONTAINERA, hwndParent: HWND, lpszTitle: LPSTR, cLinks: int32): WINBOOL {.winapi, stdcall, dynlib: "oledlg", importc: "OleUIUpdateLinksA".} +when winimCpu64: + const + IID_IActiveScriptParse* = IID_IActiveScriptParse64 + IID_IActiveScriptParseProcedureOld* = IID_IActiveScriptParseProcedureOld64 + IID_IActiveScriptParseProcedure* = IID_IActiveScriptParseProcedure64 + IID_IActiveScriptParseProcedure2* = IID_IActiveScriptParseProcedure2_64 +when winimCpu32: + const + IID_IActiveScriptParse* = IID_IActiveScriptParse32 + IID_IActiveScriptParseProcedureOld* = IID_IActiveScriptParseProcedureOld32 + IID_IActiveScriptParseProcedure* = IID_IActiveScriptParseProcedure32 + IID_IActiveScriptParseProcedure2* = IID_IActiveScriptParseProcedure2_32 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/odbc.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/odbc.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1870 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +#include +#include +#include +#include +type + TSQLCHAR* = uint8 + TSQLSCHAR* = int8 + TSQLDATE* = uint8 + TSQLDECIMAL* = uint8 + TSQLINTEGER* = int32 + TSQLUINTEGER* = int32 + TSQLNUMERIC* = uint8 + TSQLPOINTER* = pointer + TSQLUSMALLINT* = uint16 + TSQLTIME* = uint8 + TSQLTIMESTAMP* = uint8 + TSQLVARCHAR* = uint8 + SDWORD* = int32 + UDWORD* = int32 + UWORD* = uint16 + SLONG* = int32 + PTR* = pointer + TSQLINTERVAL* = int32 + ODBCINT64* = int64 + TSQLWCHAR* = uint16 + TSQLUBIGINT* = int64 + TSQLHANDLE* = HANDLE + TSQLHENV* = HANDLE + TSQLHDBC* = HANDLE + TSQLHSTMT* = HANDLE + HENV* = HANDLE + HDBC* = HANDLE + HSTMT* = HANDLE + TSQLDOUBLE* = float64 + TSQLFLOAT* = float64 +when winimCpu64: + type + TSQLULEN* = UINT64 +when winimCpu32: + type + TSQLULEN* = TSQLUINTEGER +type + TSQLROWCOUNT* = TSQLULEN + TSQLROWSETSIZE* = TSQLULEN + TSQLTRANSID* = TSQLULEN +when winimCpu64: + type + TSQLLEN* = INT64 +when winimCpu32: + type + TSQLLEN* = TSQLINTEGER +type + TSQLROWOFFSET* = TSQLLEN + TSQLREAL* = float32 + TSQLSMALLINT* = int16 + TSQLRETURN* = TSQLSMALLINT + TSQLHDESC* = TSQLHANDLE + SWORD* = int16 + SSHORT* = int16 + SDOUBLE* = float64 + LDOUBLE* = float64 + SFLOAT* = float32 + RETCODE* = int16 + TSQLHWND* = HWND + DATE_STRUCT* {.pure.} = object + year*: TSQLSMALLINT + month*: TSQLUSMALLINT + day*: TSQLUSMALLINT + TSQL_DATE_STRUCT* = DATE_STRUCT + TIME_STRUCT* {.pure.} = object + hour*: TSQLUSMALLINT + minute*: TSQLUSMALLINT + second*: TSQLUSMALLINT + TSQL_TIME_STRUCT* = TIME_STRUCT + TIMESTAMP_STRUCT* {.pure.} = object + year*: TSQLSMALLINT + month*: TSQLUSMALLINT + day*: TSQLUSMALLINT + hour*: TSQLUSMALLINT + minute*: TSQLUSMALLINT + second*: TSQLUSMALLINT + fraction*: TSQLUINTEGER + TSQL_TIMESTAMP_STRUCT* = TIMESTAMP_STRUCT + TSQLBIGINT* = ODBCINT64 + TSQLGUID* = GUID + BOOKMARK* = TSQLULEN + ODBC_VS_ARGS_UNION1* {.pure, union.} = object + wszArg*: ptr WCHAR + szArg*: ptr CHAR + ODBC_VS_ARGS_UNION2* {.pure, union.} = object + wszCorrelation*: ptr WCHAR + szCorrelation*: ptr CHAR + ODBC_VS_ARGS* {.pure.} = object + pguidEvent*: ptr GUID + dwFlags*: DWORD + union1*: ODBC_VS_ARGS_UNION1 + union2*: ODBC_VS_ARGS_UNION2 + RetCode*: RETCODE + PODBC_VS_ARGS* = ptr ODBC_VS_ARGS +const + ODBCVER* = 0x0351 + SQL_IS_YEAR* = 1 + SQL_IS_MONTH* = 2 + SQL_IS_DAY* = 3 + SQL_IS_HOUR* = 4 + SQL_IS_MINUTE* = 5 + SQL_IS_SECOND* = 6 + SQL_IS_YEAR_TO_MONTH* = 7 + SQL_IS_DAY_TO_HOUR* = 8 + SQL_IS_DAY_TO_MINUTE* = 9 + SQL_IS_DAY_TO_SECOND* = 10 + SQL_IS_HOUR_TO_MINUTE* = 11 + SQL_IS_HOUR_TO_SECOND* = 12 + SQL_IS_MINUTE_TO_SECOND* = 13 + SQL_MAX_NUMERIC_LEN* = 16 + SQL_NULL_DATA* = -1 + SQL_DATA_AT_EXEC* = -2 + SQL_SUCCESS* = 0 + SQL_SUCCESS_WITH_INFO* = 1 + SQL_NO_DATA* = 100 + SQL_INVALID_HANDLE* = -2 + SQL_STILL_EXECUTING* = 2 + SQL_NEED_DATA* = 99 + SQL_NTS* = -3 + SQL_NTSL* = -3 + SQL_MAX_MESSAGE_LENGTH* = 512 + SQL_DATE_LEN* = 10 + SQL_TIME_LEN* = 8 + SQL_TIMESTAMP_LEN* = 19 + SQL_HANDLE_ENV* = 1 + SQL_HANDLE_DBC* = 2 + SQL_HANDLE_STMT* = 3 + SQL_HANDLE_DESC* = 4 + SQL_ATTR_OUTPUT_NTS* = 10001 + SQL_ATTR_AUTO_IPD* = 10001 + SQL_ATTR_METADATA_ID* = 10014 + SQL_ATTR_APP_ROW_DESC* = 10010 + SQL_ATTR_APP_PARAM_DESC* = 10011 + SQL_ATTR_IMP_ROW_DESC* = 10012 + SQL_ATTR_IMP_PARAM_DESC* = 10013 + SQL_ATTR_CURSOR_SCROLLABLE* = -1 + SQL_ATTR_CURSOR_SENSITIVITY* = -2 + SQL_NONSCROLLABLE* = 0 + SQL_SCROLLABLE* = 1 + SQL_DESC_COUNT* = 1001 + SQL_DESC_TYPE* = 1002 + SQL_DESC_LENGTH* = 1003 + SQL_DESC_OCTET_LENGTH_PTR* = 1004 + SQL_DESC_PRECISION* = 1005 + SQL_DESC_SCALE* = 1006 + SQL_DESC_DATETIME_INTERVAL_CODE* = 1007 + SQL_DESC_NULLABLE* = 1008 + SQL_DESC_INDICATOR_PTR* = 1009 + SQL_DESC_DATA_PTR* = 1010 + SQL_DESC_NAME* = 1011 + SQL_DESC_UNNAMED* = 1012 + SQL_DESC_OCTET_LENGTH* = 1013 + SQL_DESC_ALLOC_TYPE* = 1099 + SQL_DIAG_RETURNCODE* = 1 + SQL_DIAG_NUMBER* = 2 + SQL_DIAG_ROW_COUNT* = 3 + SQL_DIAG_SQLSTATE* = 4 + SQL_DIAG_NATIVE* = 5 + SQL_DIAG_MESSAGE_TEXT* = 6 + SQL_DIAG_DYNAMIC_FUNCTION* = 7 + SQL_DIAG_CLASS_ORIGIN* = 8 + SQL_DIAG_SUBCLASS_ORIGIN* = 9 + SQL_DIAG_CONNECTION_NAME* = 10 + SQL_DIAG_SERVER_NAME* = 11 + SQL_DIAG_DYNAMIC_FUNCTION_CODE* = 12 + SQL_DIAG_ALTER_DOMAIN* = 3 + SQL_DIAG_ALTER_TABLE* = 4 + SQL_DIAG_CALL* = 7 + SQL_DIAG_CREATE_ASSERTION* = 6 + SQL_DIAG_CREATE_CHARACTER_SET* = 8 + SQL_DIAG_CREATE_COLLATION* = 10 + SQL_DIAG_CREATE_DOMAIN* = 23 + SQL_DIAG_CREATE_INDEX* = -1 + SQL_DIAG_CREATE_SCHEMA* = 64 + SQL_DIAG_CREATE_TABLE* = 77 + SQL_DIAG_CREATE_TRANSLATION* = 79 + SQL_DIAG_CREATE_VIEW* = 84 + SQL_DIAG_DELETE_WHERE* = 19 + SQL_DIAG_DROP_ASSERTION* = 24 + SQL_DIAG_DROP_CHARACTER_SET* = 25 + SQL_DIAG_DROP_COLLATION* = 26 + SQL_DIAG_DROP_DOMAIN* = 27 + SQL_DIAG_DROP_INDEX* = -2 + SQL_DIAG_DROP_SCHEMA* = 31 + SQL_DIAG_DROP_TABLE* = 32 + SQL_DIAG_DROP_TRANSLATION* = 33 + SQL_DIAG_DROP_VIEW* = 36 + SQL_DIAG_DYNAMIC_DELETE_CURSOR* = 38 + SQL_DIAG_DYNAMIC_UPDATE_CURSOR* = 81 + SQL_DIAG_GRANT* = 48 + SQL_DIAG_INSERT* = 50 + SQL_DIAG_REVOKE* = 59 + SQL_DIAG_SELECT_CURSOR* = 85 + SQL_DIAG_UNKNOWN_STATEMENT* = 0 + SQL_DIAG_UPDATE_WHERE* = 82 + SQL_UNKNOWN_TYPE* = 0 + SQL_CHAR* = 1 + SQL_NUMERIC* = 2 + SQL_DECIMAL* = 3 + SQL_INTEGER* = 4 + SQL_SMALLINT* = 5 + SQL_FLOAT* = 6 + SQL_REAL* = 7 + SQL_DOUBLE* = 8 + SQL_DATETIME* = 9 + SQL_VARCHAR* = 12 + SQL_TYPE_DATE* = 91 + SQL_TYPE_TIME* = 92 + SQL_TYPE_TIMESTAMP* = 93 + SQL_UNSPECIFIED* = 0 + SQL_INSENSITIVE* = 1 + SQL_SENSITIVE* = 2 + SQL_ALL_TYPES* = 0 + SQL_DEFAULT* = 99 + SQL_ARD_TYPE* = -99 + SQL_CODE_DATE* = 1 + SQL_CODE_TIME* = 2 + SQL_CODE_TIMESTAMP* = 3 + SQL_FALSE* = 0 + SQL_TRUE* = 1 + SQL_NO_NULLS* = 0 + SQL_NULLABLE* = 1 + SQL_NULLABLE_UNKNOWN* = 2 + SQL_PRED_NONE* = 0 + SQL_PRED_CHAR* = 1 + SQL_PRED_BASIC* = 2 + SQL_NAMED* = 0 + SQL_UNNAMED* = 1 + SQL_DESC_ALLOC_AUTO* = 1 + SQL_DESC_ALLOC_USER* = 2 + SQL_CLOSE* = 0 + SQL_DROP* = 1 + SQL_UNBIND* = 2 + SQL_RESET_PARAMS* = 3 + SQL_FETCH_NEXT* = 1 + SQL_FETCH_FIRST* = 2 + SQL_FETCH_LAST* = 3 + SQL_FETCH_PRIOR* = 4 + SQL_FETCH_ABSOLUTE* = 5 + SQL_FETCH_RELATIVE* = 6 + SQL_COMMIT* = 0 + SQL_ROLLBACK* = 1 + SQL_NULL_HENV* = 0 + SQL_NULL_HDBC* = 0 + SQL_NULL_HSTMT* = 0 + SQL_NULL_HDESC* = 0 + SQL_NULL_HANDLE* = 0 + SQL_SCOPE_CURROW* = 0 + SQL_SCOPE_TRANSACTION* = 1 + SQL_SCOPE_SESSION* = 2 + SQL_PC_UNKNOWN* = 0 + SQL_PC_NON_PSEUDO* = 1 + SQL_PC_PSEUDO* = 2 + SQL_ROW_IDENTIFIER* = 1 + SQL_INDEX_UNIQUE* = 0 + SQL_INDEX_ALL* = 1 + SQL_INDEX_CLUSTERED* = 1 + SQL_INDEX_HASHED* = 2 + SQL_INDEX_OTHER* = 3 + SQL_API_SQLALLOCCONNECT* = 1 + SQL_API_SQLALLOCENV* = 2 + SQL_API_SQLALLOCHANDLE* = 1001 + SQL_API_SQLALLOCSTMT* = 3 + SQL_API_SQLBINDCOL* = 4 + SQL_API_SQLBINDPARAM* = 1002 + SQL_API_SQLCANCEL* = 5 + SQL_API_SQLCLOSECURSOR* = 1003 + SQL_API_SQLCOLATTRIBUTE* = 6 + SQL_API_SQLCOLUMNS* = 40 + SQL_API_SQLCONNECT* = 7 + SQL_API_SQLCOPYDESC* = 1004 + SQL_API_SQLDATASOURCES* = 57 + SQL_API_SQLDESCRIBECOL* = 8 + SQL_API_SQLDISCONNECT* = 9 + SQL_API_SQLENDTRAN* = 1005 + SQL_API_SQLERROR* = 10 + SQL_API_SQLEXECDIRECT* = 11 + SQL_API_SQLEXECUTE* = 12 + SQL_API_SQLFETCH* = 13 + SQL_API_SQLFETCHSCROLL* = 1021 + SQL_API_SQLFREECONNECT* = 14 + SQL_API_SQLFREEENV* = 15 + SQL_API_SQLFREEHANDLE* = 1006 + SQL_API_SQLFREESTMT* = 16 + SQL_API_SQLGETCONNECTATTR* = 1007 + SQL_API_SQLGETCONNECTOPTION* = 42 + SQL_API_SQLGETCURSORNAME* = 17 + SQL_API_SQLGETDATA* = 43 + SQL_API_SQLGETDESCFIELD* = 1008 + SQL_API_SQLGETDESCREC* = 1009 + SQL_API_SQLGETDIAGFIELD* = 1010 + SQL_API_SQLGETDIAGREC* = 1011 + SQL_API_SQLGETENVATTR* = 1012 + SQL_API_SQLGETFUNCTIONS* = 44 + SQL_API_SQLGETINFO* = 45 + SQL_API_SQLGETSTMTATTR* = 1014 + SQL_API_SQLGETSTMTOPTION* = 46 + SQL_API_SQLGETTYPEINFO* = 47 + SQL_API_SQLNUMRESULTCOLS* = 18 + SQL_API_SQLPARAMDATA* = 48 + SQL_API_SQLPREPARE* = 19 + SQL_API_SQLPUTDATA* = 49 + SQL_API_SQLROWCOUNT* = 20 + SQL_API_SQLSETCONNECTATTR* = 1016 + SQL_API_SQLSETCONNECTOPTION* = 50 + SQL_API_SQLSETCURSORNAME* = 21 + SQL_API_SQLSETDESCFIELD* = 1017 + SQL_API_SQLSETDESCREC* = 1018 + SQL_API_SQLSETENVATTR* = 1019 + SQL_API_SQLSETPARAM* = 22 + SQL_API_SQLSETSTMTATTR* = 1020 + SQL_API_SQLSETSTMTOPTION* = 51 + SQL_API_SQLSPECIALCOLUMNS* = 52 + SQL_API_SQLSTATISTICS* = 53 + SQL_API_SQLTABLES* = 54 + SQL_API_SQLTRANSACT* = 23 + SQL_MAX_DRIVER_CONNECTIONS* = 0 + SQL_MAXIMUM_DRIVER_CONNECTIONS* = SQL_MAX_DRIVER_CONNECTIONS + SQL_MAX_CONCURRENT_ACTIVITIES* = 1 + SQL_MAXIMUM_CONCURRENT_ACTIVITIES* = SQL_MAX_CONCURRENT_ACTIVITIES + SQL_DATA_SOURCE_NAME* = 2 + SQL_FETCH_DIRECTION* = 8 + SQL_SERVER_NAME* = 13 + SQL_SEARCH_PATTERN_ESCAPE* = 14 + SQL_DBMS_NAME* = 17 + SQL_DBMS_VER* = 18 + SQL_ACCESSIBLE_TABLES* = 19 + SQL_ACCESSIBLE_PROCEDURES* = 20 + SQL_CURSOR_COMMIT_BEHAVIOR* = 23 + SQL_DATA_SOURCE_READ_ONLY* = 25 + SQL_DEFAULT_TXN_ISOLATION* = 26 + SQL_IDENTIFIER_CASE* = 28 + SQL_IDENTIFIER_QUOTE_CHAR* = 29 + SQL_MAX_COLUMN_NAME_LEN* = 30 + SQL_MAXIMUM_COLUMN_NAME_LENGTH* = SQL_MAX_COLUMN_NAME_LEN + SQL_MAX_CURSOR_NAME_LEN* = 31 + SQL_MAXIMUM_CURSOR_NAME_LENGTH* = SQL_MAX_CURSOR_NAME_LEN + SQL_MAX_SCHEMA_NAME_LEN* = 32 + SQL_MAXIMUM_SCHEMA_NAME_LENGTH* = SQL_MAX_SCHEMA_NAME_LEN + SQL_MAX_CATALOG_NAME_LEN* = 34 + SQL_MAXIMUM_CATALOG_NAME_LENGTH* = SQL_MAX_CATALOG_NAME_LEN + SQL_MAX_TABLE_NAME_LEN* = 35 + SQL_SCROLL_CONCURRENCY* = 43 + SQL_TXN_CAPABLE* = 46 + SQL_TRANSACTION_CAPABLE* = SQL_TXN_CAPABLE + SQL_USER_NAME* = 47 + SQL_TXN_ISOLATION_OPTION* = 72 + SQL_TRANSACTION_ISOLATION_OPTION* = SQL_TXN_ISOLATION_OPTION + SQL_INTEGRITY* = 73 + SQL_GETDATA_EXTENSIONS* = 81 + SQL_NULL_COLLATION* = 85 + SQL_ALTER_TABLE* = 86 + SQL_ORDER_BY_COLUMNS_IN_SELECT* = 90 + SQL_SPECIAL_CHARACTERS* = 94 + SQL_MAX_COLUMNS_IN_GROUP_BY* = 97 + SQL_MAXIMUM_COLUMNS_IN_GROUP_BY* = SQL_MAX_COLUMNS_IN_GROUP_BY + SQL_MAX_COLUMNS_IN_INDEX* = 98 + SQL_MAXIMUM_COLUMNS_IN_INDEX* = SQL_MAX_COLUMNS_IN_INDEX + SQL_MAX_COLUMNS_IN_ORDER_BY* = 99 + SQL_MAXIMUM_COLUMNS_IN_ORDER_BY* = SQL_MAX_COLUMNS_IN_ORDER_BY + SQL_MAX_COLUMNS_IN_SELECT* = 100 + SQL_MAXIMUM_COLUMNS_IN_SELECT* = SQL_MAX_COLUMNS_IN_SELECT + SQL_MAX_COLUMNS_IN_TABLE* = 101 + SQL_MAX_INDEX_SIZE* = 102 + SQL_MAXIMUM_INDEX_SIZE* = SQL_MAX_INDEX_SIZE + SQL_MAX_ROW_SIZE* = 104 + SQL_MAXIMUM_ROW_SIZE* = SQL_MAX_ROW_SIZE + SQL_MAX_STATEMENT_LEN* = 105 + SQL_MAXIMUM_STATEMENT_LENGTH* = SQL_MAX_STATEMENT_LEN + SQL_MAX_TABLES_IN_SELECT* = 106 + SQL_MAXIMUM_TABLES_IN_SELECT* = SQL_MAX_TABLES_IN_SELECT + SQL_MAX_USER_NAME_LEN* = 107 + SQL_MAXIMUM_USER_NAME_LENGTH* = SQL_MAX_USER_NAME_LEN + SQL_OJ_CAPABILITIES* = 115 + SQL_OUTER_JOIN_CAPABILITIES* = SQL_OJ_CAPABILITIES + SQL_XOPEN_CLI_YEAR* = 10000 + SQL_CURSOR_SENSITIVITY* = 10001 + SQL_DESCRIBE_PARAMETER* = 10002 + SQL_CATALOG_NAME* = 10003 + SQL_COLLATION_SEQ* = 10004 + SQL_MAX_IDENTIFIER_LEN* = 10005 + SQL_MAXIMUM_IDENTIFIER_LENGTH* = SQL_MAX_IDENTIFIER_LEN + SQL_AT_ADD_COLUMN* = 0x00000001 + SQL_AT_DROP_COLUMN* = 0x00000002 + SQL_AT_ADD_CONSTRAINT* = 0x00000008 + SQL_AM_NONE* = 0 + SQL_AM_CONNECTION* = 1 + SQL_AM_STATEMENT* = 2 + SQL_CB_DELETE* = 0 + SQL_CB_CLOSE* = 1 + SQL_CB_PRESERVE* = 2 + SQL_FD_FETCH_NEXT* = 0x00000001 + SQL_FD_FETCH_FIRST* = 0x00000002 + SQL_FD_FETCH_LAST* = 0x00000004 + SQL_FD_FETCH_PRIOR* = 0x00000008 + SQL_FD_FETCH_ABSOLUTE* = 0x00000010 + SQL_FD_FETCH_RELATIVE* = 0x00000020 + SQL_GD_ANY_COLUMN* = 0x00000001 + SQL_GD_ANY_ORDER* = 0x00000002 + SQL_IC_UPPER* = 1 + SQL_IC_LOWER* = 2 + SQL_IC_SENSITIVE* = 3 + SQL_IC_MIXED* = 4 + SQL_OJ_LEFT* = 0x00000001 + SQL_OJ_RIGHT* = 0x00000002 + SQL_OJ_FULL* = 0x00000004 + SQL_OJ_NESTED* = 0x00000008 + SQL_OJ_NOT_ORDERED* = 0x00000010 + SQL_OJ_INNER* = 0x00000020 + SQL_OJ_ALL_COMPARISON_OPS* = 0x00000040 + SQL_SCCO_READ_ONLY* = 0x00000001 + SQL_SCCO_LOCK* = 0x00000002 + SQL_SCCO_OPT_ROWVER* = 0x00000004 + SQL_SCCO_OPT_VALUES* = 0x00000008 + SQL_TC_NONE* = 0 + SQL_TC_DML* = 1 + SQL_TC_ALL* = 2 + SQL_TC_DDL_COMMIT* = 3 + SQL_TC_DDL_IGNORE* = 4 + SQL_TXN_READ_UNCOMMITTED* = 0x00000001 + SQL_TRANSACTION_READ_UNCOMMITTED* = SQL_TXN_READ_UNCOMMITTED + SQL_TXN_READ_COMMITTED* = 0x00000002 + SQL_TRANSACTION_READ_COMMITTED* = SQL_TXN_READ_COMMITTED + SQL_TXN_REPEATABLE_READ* = 0x00000004 + SQL_TRANSACTION_REPEATABLE_READ* = SQL_TXN_REPEATABLE_READ + SQL_TXN_SERIALIZABLE* = 0x00000008 + SQL_TRANSACTION_SERIALIZABLE* = SQL_TXN_SERIALIZABLE + SQL_NC_HIGH* = 0 + SQL_NC_LOW* = 1 + SQL_SPEC_MAJOR* = 3 + SQL_SPEC_MINOR* = 52 + SQL_SPEC_STRING* = "03.52" + SQL_SQLSTATE_SIZE* = 5 + SQL_MAX_DSN_LENGTH* = 32 + SQL_MAX_OPTION_STRING_LENGTH* = 256 + SQL_HANDLE_SENV* = 5 + SQL_ATTR_ODBC_VERSION* = 200 + SQL_ATTR_CONNECTION_POOLING* = 201 + SQL_ATTR_CP_MATCH* = 202 + SQL_CP_OFF* = 0 + SQL_CP_ONE_PER_DRIVER* = 1 + SQL_CP_ONE_PER_HENV* = 2 + SQL_CP_DEFAULT* = SQL_CP_OFF + SQL_CP_STRICT_MATCH* = 0 + SQL_CP_RELAXED_MATCH* = 1 + SQL_CP_MATCH_DEFAULT* = SQL_CP_STRICT_MATCH + SQL_OV_ODBC2* = 2 + SQL_OV_ODBC3* = 3 + SQL_ACCESS_MODE* = 101 + SQL_AUTOCOMMIT* = 102 + SQL_LOGIN_TIMEOUT* = 103 + SQL_OPT_TRACE* = 104 + SQL_OPT_TRACEFILE* = 105 + SQL_TRANSLATE_DLL* = 106 + SQL_TRANSLATE_OPTION* = 107 + SQL_TXN_ISOLATION* = 108 + SQL_CURRENT_QUALIFIER* = 109 + SQL_ODBC_CURSORS* = 110 + SQL_QUIET_MODE* = 111 + SQL_PACKET_SIZE* = 112 + SQL_ATTR_ACCESS_MODE* = SQL_ACCESS_MODE + SQL_ATTR_AUTOCOMMIT* = SQL_AUTOCOMMIT + SQL_ATTR_CONNECTION_TIMEOUT* = 113 + SQL_ATTR_CURRENT_CATALOG* = SQL_CURRENT_QUALIFIER + SQL_ATTR_DISCONNECT_BEHAVIOR* = 114 + SQL_ATTR_ENLIST_IN_DTC* = 1207 + SQL_ATTR_ENLIST_IN_XA* = 1208 + SQL_ATTR_LOGIN_TIMEOUT* = SQL_LOGIN_TIMEOUT + SQL_ATTR_ODBC_CURSORS* = SQL_ODBC_CURSORS + SQL_ATTR_PACKET_SIZE* = SQL_PACKET_SIZE + SQL_ATTR_QUIET_MODE* = SQL_QUIET_MODE + SQL_ATTR_TRACE* = SQL_OPT_TRACE + SQL_ATTR_TRACEFILE* = SQL_OPT_TRACEFILE + SQL_ATTR_TRANSLATE_LIB* = SQL_TRANSLATE_DLL + SQL_ATTR_TRANSLATE_OPTION* = SQL_TRANSLATE_OPTION + SQL_ATTR_TXN_ISOLATION* = SQL_TXN_ISOLATION + SQL_ATTR_CONNECTION_DEAD* = 1209 + SQL_ATTR_ANSI_APP* = 115 + SQL_MODE_READ_WRITE* = 0 + SQL_MODE_READ_ONLY* = 1 + SQL_MODE_DEFAULT* = SQL_MODE_READ_WRITE + SQL_AUTOCOMMIT_OFF* = 0 + SQL_AUTOCOMMIT_ON* = 1 + SQL_AUTOCOMMIT_DEFAULT* = SQL_AUTOCOMMIT_ON + SQL_LOGIN_TIMEOUT_DEFAULT* = 15 + SQL_OPT_TRACE_OFF* = 0 + SQL_OPT_TRACE_ON* = 1 + SQL_OPT_TRACE_DEFAULT* = SQL_OPT_TRACE_OFF + SQL_OPT_TRACE_FILE_DEFAULT* = "\\SQL.LOG" + SQL_CUR_USE_IF_NEEDED* = 0 + SQL_CUR_USE_ODBC* = 1 + SQL_CUR_USE_DRIVER* = 2 + SQL_CUR_DEFAULT* = SQL_CUR_USE_DRIVER + SQL_DB_RETURN_TO_POOL* = 0 + SQL_DB_DISCONNECT* = 1 + SQL_DB_DEFAULT* = SQL_DB_RETURN_TO_POOL + SQL_DTC_DONE* = 0 + SQL_CD_TRUE* = 1 + SQL_CD_FALSE* = 0 + SQL_AA_TRUE* = 1 + SQL_AA_FALSE* = 0 + SQL_QUERY_TIMEOUT* = 0 + SQL_MAX_ROWS* = 1 + SQL_NOSCAN* = 2 + SQL_MAX_LENGTH* = 3 + SQL_ASYNC_ENABLE* = 4 + SQL_BIND_TYPE* = 5 + SQL_CURSOR_TYPE* = 6 + SQL_CONCURRENCY* = 7 + SQL_KEYSET_SIZE* = 8 + SQL_ROWSET_SIZE* = 9 + SQL_SIMULATE_CURSOR* = 10 + SQL_RETRIEVE_DATA* = 11 + SQL_USE_BOOKMARKS* = 12 + SQL_GET_BOOKMARK* = 13 + SQL_ROW_NUMBER* = 14 + SQL_ATTR_ASYNC_ENABLE* = 4 + SQL_ATTR_CONCURRENCY* = SQL_CONCURRENCY + SQL_ATTR_CURSOR_TYPE* = SQL_CURSOR_TYPE + SQL_ATTR_ENABLE_AUTO_IPD* = 15 + SQL_ATTR_FETCH_BOOKMARK_PTR* = 16 + SQL_ATTR_KEYSET_SIZE* = SQL_KEYSET_SIZE + SQL_ATTR_MAX_LENGTH* = SQL_MAX_LENGTH + SQL_ATTR_MAX_ROWS* = SQL_MAX_ROWS + SQL_ATTR_NOSCAN* = SQL_NOSCAN + SQL_ATTR_PARAM_BIND_OFFSET_PTR* = 17 + SQL_ATTR_PARAM_BIND_TYPE* = 18 + SQL_ATTR_PARAM_OPERATION_PTR* = 19 + SQL_ATTR_PARAM_STATUS_PTR* = 20 + SQL_ATTR_PARAMS_PROCESSED_PTR* = 21 + SQL_ATTR_PARAMSET_SIZE* = 22 + SQL_ATTR_QUERY_TIMEOUT* = SQL_QUERY_TIMEOUT + SQL_ATTR_RETRIEVE_DATA* = SQL_RETRIEVE_DATA + SQL_ATTR_ROW_BIND_OFFSET_PTR* = 23 + SQL_ATTR_ROW_BIND_TYPE* = SQL_BIND_TYPE + SQL_ATTR_ROW_NUMBER* = SQL_ROW_NUMBER + SQL_ATTR_ROW_OPERATION_PTR* = 24 + SQL_ATTR_ROW_STATUS_PTR* = 25 + SQL_ATTR_ROWS_FETCHED_PTR* = 26 + SQL_ATTR_ROW_ARRAY_SIZE* = 27 + SQL_ATTR_SIMULATE_CURSOR* = SQL_SIMULATE_CURSOR + SQL_ATTR_USE_BOOKMARKS* = SQL_USE_BOOKMARKS + SQL_LIKE_ONLY* = 1 + SQL_COL_PRED_CHAR* = SQL_LIKE_ONLY + SQL_ALL_EXCEPT_LIKE* = 2 + SQL_COL_PRED_BASIC* = SQL_ALL_EXCEPT_LIKE + SQL_IS_POINTER* = -4 + SQL_IS_UINTEGER* = -5 + SQL_IS_INTEGER* = -6 + SQL_IS_USMALLINT* = -7 + SQL_IS_SMALLINT* = -8 + SQL_PARAM_BIND_BY_COLUMN* = 0 + SQL_PARAM_BIND_TYPE_DEFAULT* = SQL_PARAM_BIND_BY_COLUMN + SQL_QUERY_TIMEOUT_DEFAULT* = 0 + SQL_MAX_ROWS_DEFAULT* = 0 + SQL_NOSCAN_OFF* = 0 + SQL_NOSCAN_ON* = 1 + SQL_NOSCAN_DEFAULT* = SQL_NOSCAN_OFF + SQL_MAX_LENGTH_DEFAULT* = 0 + SQL_ASYNC_ENABLE_OFF* = 0 + SQL_ASYNC_ENABLE_ON* = 1 + SQL_ASYNC_ENABLE_DEFAULT* = SQL_ASYNC_ENABLE_OFF + SQL_BIND_BY_COLUMN* = 0 + SQL_BIND_TYPE_DEFAULT* = SQL_BIND_BY_COLUMN + SQL_CONCUR_READ_ONLY* = 1 + SQL_CONCUR_LOCK* = 2 + SQL_CONCUR_ROWVER* = 3 + SQL_CONCUR_VALUES* = 4 + SQL_CONCUR_DEFAULT* = SQL_CONCUR_READ_ONLY + SQL_CURSOR_FORWARD_ONLY* = 0 + SQL_CURSOR_KEYSET_DRIVEN* = 1 + SQL_CURSOR_DYNAMIC* = 2 + SQL_CURSOR_STATIC* = 3 + SQL_CURSOR_TYPE_DEFAULT* = SQL_CURSOR_FORWARD_ONLY + SQL_ROWSET_SIZE_DEFAULT* = 1 + SQL_KEYSET_SIZE_DEFAULT* = 0 + SQL_SC_NON_UNIQUE* = 0 + SQL_SC_TRY_UNIQUE* = 1 + SQL_SC_UNIQUE* = 2 + SQL_RD_OFF* = 0 + SQL_RD_ON* = 1 + SQL_RD_DEFAULT* = SQL_RD_ON + SQL_UB_OFF* = 0 + SQL_UB_ON* = 01 + SQL_UB_DEFAULT* = SQL_UB_OFF + SQL_UB_FIXED* = SQL_UB_ON + SQL_UB_VARIABLE* = 2 + SQL_DESC_ARRAY_SIZE* = 20 + SQL_DESC_ARRAY_STATUS_PTR* = 21 + SQL_COLUMN_AUTO_INCREMENT* = 11 + SQL_DESC_AUTO_UNIQUE_VALUE* = SQL_COLUMN_AUTO_INCREMENT + SQL_DESC_BASE_COLUMN_NAME* = 22 + SQL_DESC_BASE_TABLE_NAME* = 23 + SQL_DESC_BIND_OFFSET_PTR* = 24 + SQL_DESC_BIND_TYPE* = 25 + SQL_COLUMN_CASE_SENSITIVE* = 12 + SQL_DESC_CASE_SENSITIVE* = SQL_COLUMN_CASE_SENSITIVE + SQL_COLUMN_QUALIFIER_NAME* = 17 + SQL_DESC_CATALOG_NAME* = SQL_COLUMN_QUALIFIER_NAME + SQL_COLUMN_TYPE* = 2 + SQL_DESC_CONCISE_TYPE* = SQL_COLUMN_TYPE + SQL_DESC_DATETIME_INTERVAL_PRECISION* = 26 + SQL_COLUMN_DISPLAY_SIZE* = 6 + SQL_DESC_DISPLAY_SIZE* = SQL_COLUMN_DISPLAY_SIZE + SQL_COLUMN_MONEY* = 9 + SQL_DESC_FIXED_PREC_SCALE* = SQL_COLUMN_MONEY + SQL_COLUMN_LABEL* = 18 + SQL_DESC_LABEL* = SQL_COLUMN_LABEL + SQL_DESC_LITERAL_PREFIX* = 27 + SQL_DESC_LITERAL_SUFFIX* = 28 + SQL_DESC_LOCAL_TYPE_NAME* = 29 + SQL_DESC_MAXIMUM_SCALE* = 30 + SQL_DESC_MINIMUM_SCALE* = 31 + SQL_DESC_NUM_PREC_RADIX* = 32 + SQL_DESC_PARAMETER_TYPE* = 33 + SQL_DESC_ROWS_PROCESSED_PTR* = 34 + SQL_COLUMN_OWNER_NAME* = 16 + SQL_DESC_SCHEMA_NAME* = SQL_COLUMN_OWNER_NAME + SQL_COLUMN_SEARCHABLE* = 13 + SQL_DESC_SEARCHABLE* = SQL_COLUMN_SEARCHABLE + SQL_COLUMN_TYPE_NAME* = 14 + SQL_DESC_TYPE_NAME* = SQL_COLUMN_TYPE_NAME + SQL_COLUMN_TABLE_NAME* = 15 + SQL_DESC_TABLE_NAME* = SQL_COLUMN_TABLE_NAME + SQL_COLUMN_UNSIGNED* = 8 + SQL_DESC_UNSIGNED* = SQL_COLUMN_UNSIGNED + SQL_COLUMN_UPDATABLE* = 10 + SQL_DESC_UPDATABLE* = SQL_COLUMN_UPDATABLE + SQL_DIAG_CURSOR_ROW_COUNT* = -1249 + SQL_DIAG_ROW_NUMBER* = -1248 + SQL_DIAG_COLUMN_NUMBER* = -1247 + SQL_DATE* = 9 + SQL_INTERVAL* = 10 + SQL_TIME* = 10 + SQL_TIMESTAMP* = 11 + SQL_LONGVARCHAR* = -1 + SQL_BINARY* = -2 + SQL_VARBINARY* = -3 + SQL_LONGVARBINARY* = -4 + SQL_BIGINT* = -5 + SQL_TINYINT* = -6 + SQL_BIT* = -7 + SQL_GUID* = -11 + SQL_CODE_YEAR* = 1 + SQL_CODE_MONTH* = 2 + SQL_CODE_DAY* = 3 + SQL_CODE_HOUR* = 4 + SQL_CODE_MINUTE* = 5 + SQL_CODE_SECOND* = 6 + SQL_CODE_YEAR_TO_MONTH* = 7 + SQL_CODE_DAY_TO_HOUR* = 8 + SQL_CODE_DAY_TO_MINUTE* = 9 + SQL_CODE_DAY_TO_SECOND* = 10 + SQL_CODE_HOUR_TO_MINUTE* = 11 + SQL_CODE_HOUR_TO_SECOND* = 12 + SQL_CODE_MINUTE_TO_SECOND* = 13 + SQL_INTERVAL_YEAR* = 100+SQL_CODE_YEAR + SQL_INTERVAL_MONTH* = 100+SQL_CODE_MONTH + SQL_INTERVAL_DAY* = 100+SQL_CODE_DAY + SQL_INTERVAL_HOUR* = 100+SQL_CODE_HOUR + SQL_INTERVAL_MINUTE* = 100+SQL_CODE_MINUTE + SQL_INTERVAL_SECOND* = 100+SQL_CODE_SECOND + SQL_INTERVAL_YEAR_TO_MONTH* = 100+SQL_CODE_YEAR_TO_MONTH + SQL_INTERVAL_DAY_TO_HOUR* = 100+SQL_CODE_DAY_TO_HOUR + SQL_INTERVAL_DAY_TO_MINUTE* = 100+SQL_CODE_DAY_TO_MINUTE + SQL_INTERVAL_DAY_TO_SECOND* = 100+SQL_CODE_DAY_TO_SECOND + SQL_INTERVAL_HOUR_TO_MINUTE* = 100+SQL_CODE_HOUR_TO_MINUTE + SQL_INTERVAL_HOUR_TO_SECOND* = 100+SQL_CODE_HOUR_TO_SECOND + SQL_INTERVAL_MINUTE_TO_SECOND* = 100+SQL_CODE_MINUTE_TO_SECOND + SQL_WCHAR* = -8 + SQL_UNICODE* = SQL_WCHAR + SQL_WVARCHAR* = -9 + SQL_UNICODE_VARCHAR* = SQL_WVARCHAR + SQL_WLONGVARCHAR* = -10 + SQL_UNICODE_LONGVARCHAR* = SQL_WLONGVARCHAR + SQL_UNICODE_CHAR* = SQL_WCHAR + SQL_C_CHAR* = SQL_CHAR + SQL_C_LONG* = SQL_INTEGER + SQL_C_SHORT* = SQL_SMALLINT + SQL_C_FLOAT* = SQL_REAL + SQL_C_DOUBLE* = SQL_DOUBLE + SQL_C_NUMERIC* = SQL_NUMERIC + SQL_C_DEFAULT* = 99 + SQL_SIGNED_OFFSET* = -20 + SQL_UNSIGNED_OFFSET* = -22 + SQL_C_DATE* = SQL_DATE + SQL_C_TIME* = SQL_TIME + SQL_C_TIMESTAMP* = SQL_TIMESTAMP + SQL_C_TYPE_DATE* = SQL_TYPE_DATE + SQL_C_TYPE_TIME* = SQL_TYPE_TIME + SQL_C_TYPE_TIMESTAMP* = SQL_TYPE_TIMESTAMP + SQL_C_INTERVAL_YEAR* = SQL_INTERVAL_YEAR + SQL_C_INTERVAL_MONTH* = SQL_INTERVAL_MONTH + SQL_C_INTERVAL_DAY* = SQL_INTERVAL_DAY + SQL_C_INTERVAL_HOUR* = SQL_INTERVAL_HOUR + SQL_C_INTERVAL_MINUTE* = SQL_INTERVAL_MINUTE + SQL_C_INTERVAL_SECOND* = SQL_INTERVAL_SECOND + SQL_C_INTERVAL_YEAR_TO_MONTH* = SQL_INTERVAL_YEAR_TO_MONTH + SQL_C_INTERVAL_DAY_TO_HOUR* = SQL_INTERVAL_DAY_TO_HOUR + SQL_C_INTERVAL_DAY_TO_MINUTE* = SQL_INTERVAL_DAY_TO_MINUTE + SQL_C_INTERVAL_DAY_TO_SECOND* = SQL_INTERVAL_DAY_TO_SECOND + SQL_C_INTERVAL_HOUR_TO_MINUTE* = SQL_INTERVAL_HOUR_TO_MINUTE + SQL_C_INTERVAL_HOUR_TO_SECOND* = SQL_INTERVAL_HOUR_TO_SECOND + SQL_C_INTERVAL_MINUTE_TO_SECOND* = SQL_INTERVAL_MINUTE_TO_SECOND + SQL_C_BINARY* = SQL_BINARY + SQL_C_BIT* = SQL_BIT + SQL_C_SBIGINT* = SQL_BIGINT+SQL_SIGNED_OFFSET + SQL_C_UBIGINT* = SQL_BIGINT+SQL_UNSIGNED_OFFSET + SQL_C_TINYINT* = SQL_TINYINT + SQL_C_SLONG* = SQL_C_LONG+SQL_SIGNED_OFFSET + SQL_C_SSHORT* = SQL_C_SHORT+SQL_SIGNED_OFFSET + SQL_C_STINYINT* = SQL_TINYINT+SQL_SIGNED_OFFSET + SQL_C_ULONG* = SQL_C_LONG+SQL_UNSIGNED_OFFSET + SQL_C_USHORT* = SQL_C_SHORT+SQL_UNSIGNED_OFFSET + SQL_C_UTINYINT* = SQL_TINYINT+SQL_UNSIGNED_OFFSET + SQL_C_GUID* = SQL_GUID + SQL_TYPE_NULL* = 0 + SQL_C_VARBOOKMARK* = SQL_C_BINARY + SQL_NO_ROW_NUMBER* = -1 + SQL_NO_COLUMN_NUMBER* = -1 + SQL_ROW_NUMBER_UNKNOWN* = -2 + SQL_COLUMN_NUMBER_UNKNOWN* = -2 + SQL_DEFAULT_PARAM* = -5 + SQL_IGNORE* = -6 + SQL_COLUMN_IGNORE* = SQL_IGNORE + SQL_LEN_DATA_AT_EXEC_OFFSET* = -100 + SQL_LEN_BINARY_ATTR_OFFSET* = -100 + SQL_PARAM_INPUT_OUTPUT* = 2 + SQL_PARAM_TYPE_DEFAULT* = SQL_PARAM_INPUT_OUTPUT + SQL_SETPARAM_VALUE_MAX* = -1 + SQL_COLUMN_COUNT* = 0 + SQL_COLUMN_NAME* = 1 + SQL_COLUMN_LENGTH* = 3 + SQL_COLUMN_PRECISION* = 4 + SQL_COLUMN_SCALE* = 5 + SQL_COLUMN_NULLABLE* = 7 + SQL_COLATT_OPT_MAX* = SQL_COLUMN_LABEL + SQL_COLATT_OPT_MIN* = SQL_COLUMN_COUNT + SQL_ATTR_READONLY* = 0 + SQL_ATTR_WRITE* = 1 + SQL_ATTR_READWRITE_UNKNOWN* = 2 + SQL_UNSEARCHABLE* = 0 + SQL_SEARCHABLE* = 3 + SQL_PRED_SEARCHABLE* = SQL_SEARCHABLE + SQL_NO_TOTAL* = -4 + SQL_API_SQLALLOCHANDLESTD* = 73 + SQL_API_SQLBULKOPERATIONS* = 24 + SQL_API_SQLBINDPARAMETER* = 72 + SQL_API_SQLBROWSECONNECT* = 55 + SQL_API_SQLCOLATTRIBUTES* = 6 + SQL_API_SQLCOLUMNPRIVILEGES* = 56 + SQL_API_SQLDESCRIBEPARAM* = 58 + SQL_API_SQLDRIVERCONNECT* = 41 + SQL_API_SQLDRIVERS* = 71 + SQL_API_SQLEXTENDEDFETCH* = 59 + SQL_API_SQLFOREIGNKEYS* = 60 + SQL_API_SQLMORERESULTS* = 61 + SQL_API_SQLNATIVESQL* = 62 + SQL_API_SQLNUMPARAMS* = 63 + SQL_API_SQLPARAMOPTIONS* = 64 + SQL_API_SQLPRIMARYKEYS* = 65 + SQL_API_SQLPROCEDURECOLUMNS* = 66 + SQL_API_SQLPROCEDURES* = 67 + SQL_API_SQLSETPOS* = 68 + SQL_API_SQLSETSCROLLOPTIONS* = 69 + SQL_API_SQLTABLEPRIVILEGES* = 70 + SQL_API_ALL_FUNCTIONS* = 0 + SQL_API_LOADBYORDINAL* = 199 + SQL_API_ODBC3_ALL_FUNCTIONS* = 999 + SQL_API_ODBC3_ALL_FUNCTIONS_SIZE* = 250 + SQL_INFO_FIRST* = 0 + SQL_ACTIVE_CONNECTIONS* = 0 + SQL_ACTIVE_STATEMENTS* = 1 + SQL_DRIVER_HDBC* = 3 + SQL_DRIVER_HENV* = 4 + SQL_DRIVER_HSTMT* = 5 + SQL_DRIVER_NAME* = 6 + SQL_DRIVER_VER* = 7 + SQL_ODBC_API_CONFORMANCE* = 9 + SQL_ODBC_VER* = 10 + SQL_ROW_UPDATES* = 11 + SQL_ODBC_SAG_CLI_CONFORMANCE* = 12 + SQL_ODBC_SQL_CONFORMANCE* = 15 + sqlProcedures* = 21 + SQL_CONCAT_NULL_BEHAVIOR* = 22 + SQL_CURSOR_ROLLBACK_BEHAVIOR* = 24 + SQL_EXPRESSIONS_IN_ORDERBY* = 27 + SQL_MAX_OWNER_NAME_LEN* = 32 + SQL_MAX_PROCEDURE_NAME_LEN* = 33 + SQL_MAX_QUALIFIER_NAME_LEN* = 34 + SQL_MULT_RESULT_SETS* = 36 + SQL_MULTIPLE_ACTIVE_TXN* = 37 + SQL_OUTER_JOINS* = 38 + SQL_OWNER_TERM* = 39 + SQL_PROCEDURE_TERM* = 40 + SQL_QUALIFIER_NAME_SEPARATOR* = 41 + SQL_QUALIFIER_TERM* = 42 + SQL_SCROLL_OPTIONS* = 44 + SQL_TABLE_TERM* = 45 + SQL_CONVERT_FUNCTIONS* = 48 + SQL_NUMERIC_FUNCTIONS* = 49 + SQL_STRING_FUNCTIONS* = 50 + SQL_SYSTEM_FUNCTIONS* = 51 + SQL_TIMEDATE_FUNCTIONS* = 52 + SQL_CONVERT_BIGINT* = 53 + SQL_CONVERT_BINARY* = 54 + SQL_CONVERT_BIT* = 55 + SQL_CONVERT_CHAR* = 56 + SQL_CONVERT_DATE* = 57 + SQL_CONVERT_DECIMAL* = 58 + SQL_CONVERT_DOUBLE* = 59 + SQL_CONVERT_FLOAT* = 60 + SQL_CONVERT_INTEGER* = 61 + SQL_CONVERT_LONGVARCHAR* = 62 + SQL_CONVERT_NUMERIC* = 63 + SQL_CONVERT_REAL* = 64 + SQL_CONVERT_SMALLINT* = 65 + SQL_CONVERT_TIME* = 66 + SQL_CONVERT_TIMESTAMP* = 67 + SQL_CONVERT_TINYINT* = 68 + SQL_CONVERT_VARBINARY* = 69 + SQL_CONVERT_VARCHAR* = 70 + SQL_CONVERT_LONGVARBINARY* = 71 + SQL_ODBC_SQL_OPT_IEF* = 73 + SQL_CORRELATION_NAME* = 74 + SQL_NON_NULLABLE_COLUMNS* = 75 + SQL_DRIVER_HLIB* = 76 + SQL_DRIVER_ODBC_VER* = 77 + SQL_LOCK_TYPES* = 78 + SQL_POS_OPERATIONS* = 79 + SQL_POSITIONED_STATEMENTS* = 80 + SQL_BOOKMARK_PERSISTENCE* = 82 + SQL_STATIC_SENSITIVITY* = 83 + SQL_FILE_USAGE* = 84 + SQL_COLUMN_ALIAS* = 87 + SQL_GROUP_BY* = 88 + SQL_KEYWORDS* = 89 + SQL_OWNER_USAGE* = 91 + SQL_QUALIFIER_USAGE* = 92 + SQL_QUOTED_IDENTIFIER_CASE* = 93 + SQL_SUBQUERIES* = 95 + SQL_UNION* = 96 + SQL_MAX_ROW_SIZE_INCLUDES_LONG* = 103 + SQL_MAX_CHAR_LITERAL_LEN* = 108 + SQL_TIMEDATE_ADD_INTERVALS* = 109 + SQL_TIMEDATE_DIFF_INTERVALS* = 110 + SQL_NEED_LONG_DATA_LEN* = 111 + SQL_MAX_BINARY_LITERAL_LEN* = 112 + SQL_LIKE_ESCAPE_CLAUSE* = 113 + SQL_QUALIFIER_LOCATION* = 114 + SQL_ACTIVE_ENVIRONMENTS* = 116 + SQL_ALTER_DOMAIN* = 117 + SQL_SQL_CONFORMANCE* = 118 + SQL_DATETIME_LITERALS* = 119 + SQL_ASYNC_MODE* = 10021 + SQL_BATCH_ROW_COUNT* = 120 + SQL_BATCH_SUPPORT* = 121 + SQL_CATALOG_LOCATION* = SQL_QUALIFIER_LOCATION + SQL_CATALOG_NAME_SEPARATOR* = SQL_QUALIFIER_NAME_SEPARATOR + SQL_CATALOG_TERM* = SQL_QUALIFIER_TERM + SQL_CATALOG_USAGE* = SQL_QUALIFIER_USAGE + SQL_CONVERT_WCHAR* = 122 + SQL_CONVERT_INTERVAL_DAY_TIME* = 123 + SQL_CONVERT_INTERVAL_YEAR_MONTH* = 124 + SQL_CONVERT_WLONGVARCHAR* = 125 + SQL_CONVERT_WVARCHAR* = 126 + SQL_CREATE_ASSERTION* = 127 + SQL_CREATE_CHARACTER_SET* = 128 + SQL_CREATE_COLLATION* = 129 + SQL_CREATE_DOMAIN* = 130 + SQL_CREATE_SCHEMA* = 131 + SQL_CREATE_TABLE* = 132 + SQL_CREATE_TRANSLATION* = 133 + SQL_CREATE_VIEW* = 134 + SQL_DRIVER_HDESC* = 135 + SQL_DROP_ASSERTION* = 136 + SQL_DROP_CHARACTER_SET* = 137 + SQL_DROP_COLLATION* = 138 + SQL_DROP_DOMAIN* = 139 + SQL_DROP_SCHEMA* = 140 + SQL_DROP_TABLE* = 141 + SQL_DROP_TRANSLATION* = 142 + SQL_DROP_VIEW* = 143 + SQL_DYNAMIC_CURSOR_ATTRIBUTES1* = 144 + SQL_DYNAMIC_CURSOR_ATTRIBUTES2* = 145 + SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1* = 146 + SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2* = 147 + SQL_INDEX_KEYWORDS* = 148 + SQL_INFO_SCHEMA_VIEWS* = 149 + SQL_KEYSET_CURSOR_ATTRIBUTES1* = 150 + SQL_KEYSET_CURSOR_ATTRIBUTES2* = 151 + SQL_MAX_ASYNC_CONCURRENT_STATEMENTS* = 10022 + SQL_ODBC_INTERFACE_CONFORMANCE* = 152 + SQL_PARAM_ARRAY_ROW_COUNTS* = 153 + SQL_PARAM_ARRAY_SELECTS* = 154 + SQL_SCHEMA_TERM* = SQL_OWNER_TERM + SQL_SCHEMA_USAGE* = SQL_OWNER_USAGE + SQL_SQL92_DATETIME_FUNCTIONS* = 155 + SQL_SQL92_FOREIGN_KEY_DELETE_RULE* = 156 + SQL_SQL92_FOREIGN_KEY_UPDATE_RULE* = 157 + SQL_SQL92_GRANT* = 158 + SQL_SQL92_NUMERIC_VALUE_FUNCTIONS* = 159 + SQL_SQL92_PREDICATES* = 160 + SQL_SQL92_RELATIONAL_JOIN_OPERATORS* = 161 + SQL_SQL92_REVOKE* = 162 + SQL_SQL92_ROW_VALUE_CONSTRUCTOR* = 163 + SQL_SQL92_STRING_FUNCTIONS* = 164 + SQL_SQL92_VALUE_EXPRESSIONS* = 165 + SQL_STANDARD_CLI_CONFORMANCE* = 166 + SQL_STATIC_CURSOR_ATTRIBUTES1* = 167 + SQL_STATIC_CURSOR_ATTRIBUTES2* = 168 + SQL_AGGREGATE_FUNCTIONS* = 169 + SQL_DDL_INDEX* = 170 + SQL_DM_VER* = 171 + SQL_INSERT_STATEMENT* = 172 + SQL_CONVERT_GUID* = 173 + SQL_UNION_STATEMENT* = SQL_UNION + SQL_DTC_TRANSITION_COST* = 1750 + SQL_AT_ADD_COLUMN_SINGLE* = 0x00000020 + SQL_AT_ADD_COLUMN_DEFAULT* = 0x00000040 + SQL_AT_ADD_COLUMN_COLLATION* = 0x00000080 + SQL_AT_SET_COLUMN_DEFAULT* = 0x00000100 + SQL_AT_DROP_COLUMN_DEFAULT* = 0x00000200 + SQL_AT_DROP_COLUMN_CASCADE* = 0x00000400 + SQL_AT_DROP_COLUMN_RESTRICT* = 0x00000800 + SQL_AT_ADD_TABLE_CONSTRAINT* = 0x00001000 + SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE* = 0x00002000 + SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT* = 0x00004000 + SQL_AT_CONSTRAINT_NAME_DEFINITION* = 0x00008000 + SQL_AT_CONSTRAINT_INITIALLY_DEFERRED* = 0x00010000 + SQL_AT_CONSTRAINT_INITIALLY_IMMEDIATE* = 0x00020000 + SQL_AT_CONSTRAINT_DEFERRABLE* = 0x00040000 + SQL_AT_CONSTRAINT_NON_DEFERRABLE* = 0x00080000 + SQL_CVT_CHAR* = 0x00000001 + SQL_CVT_NUMERIC* = 0x00000002 + SQL_CVT_DECIMAL* = 0x00000004 + SQL_CVT_INTEGER* = 0x00000008 + SQL_CVT_SMALLINT* = 0x00000010 + SQL_CVT_FLOAT* = 0x00000020 + SQL_CVT_REAL* = 0x00000040 + SQL_CVT_DOUBLE* = 0x00000080 + SQL_CVT_VARCHAR* = 0x00000100 + SQL_CVT_LONGVARCHAR* = 0x00000200 + SQL_CVT_BINARY* = 0x00000400 + SQL_CVT_VARBINARY* = 0x00000800 + SQL_CVT_BIT* = 0x00001000 + SQL_CVT_TINYINT* = 0x00002000 + SQL_CVT_BIGINT* = 0x00004000 + SQL_CVT_DATE* = 0x00008000 + SQL_CVT_TIME* = 0x00010000 + SQL_CVT_TIMESTAMP* = 0x00020000 + SQL_CVT_LONGVARBINARY* = 0x00040000 + SQL_CVT_INTERVAL_YEAR_MONTH* = 0x00080000 + SQL_CVT_INTERVAL_DAY_TIME* = 0x00100000 + SQL_CVT_WCHAR* = 0x00200000 + SQL_CVT_WLONGVARCHAR* = 0x00400000 + SQL_CVT_WVARCHAR* = 0x00800000 + SQL_CVT_GUID* = 0x01000000 + SQL_FN_CVT_CONVERT* = 0x00000001 + SQL_FN_CVT_CAST* = 0x00000002 + SQL_FN_STR_CONCAT* = 0x00000001 + SQL_FN_STR_INSERT* = 0x00000002 + SQL_FN_STR_LEFT* = 0x00000004 + SQL_FN_STR_LTRIM* = 0x00000008 + SQL_FN_STR_LENGTH* = 0x00000010 + SQL_FN_STR_LOCATE* = 0x00000020 + SQL_FN_STR_LCASE* = 0x00000040 + SQL_FN_STR_REPEAT* = 0x00000080 + SQL_FN_STR_REPLACE* = 0x00000100 + SQL_FN_STR_RIGHT* = 0x00000200 + SQL_FN_STR_RTRIM* = 0x00000400 + SQL_FN_STR_SUBSTRING* = 0x00000800 + SQL_FN_STR_UCASE* = 0x00001000 + SQL_FN_STR_ASCII* = 0x00002000 + SQL_FN_STR_CHAR* = 0x00004000 + SQL_FN_STR_DIFFERENCE* = 0x00008000 + SQL_FN_STR_LOCATE_2* = 0x00010000 + SQL_FN_STR_SOUNDEX* = 0x00020000 + SQL_FN_STR_SPACE* = 0x00040000 + SQL_FN_STR_BIT_LENGTH* = 0x00080000 + SQL_FN_STR_CHAR_LENGTH* = 0x00100000 + SQL_FN_STR_CHARACTER_LENGTH* = 0x00200000 + SQL_FN_STR_OCTET_LENGTH* = 0x00400000 + SQL_FN_STR_POSITION* = 0x00800000 + SQL_SSF_CONVERT* = 0x00000001 + SQL_SSF_LOWER* = 0x00000002 + SQL_SSF_UPPER* = 0x00000004 + SQL_SSF_SUBSTRING* = 0x00000008 + SQL_SSF_TRANSLATE* = 0x00000010 + SQL_SSF_TRIM_BOTH* = 0x00000020 + SQL_SSF_TRIM_LEADING* = 0x00000040 + SQL_SSF_TRIM_TRAILING* = 0x00000080 + SQL_FN_NUM_ABS* = 0x00000001 + SQL_FN_NUM_ACOS* = 0x00000002 + SQL_FN_NUM_ASIN* = 0x00000004 + SQL_FN_NUM_ATAN* = 0x00000008 + SQL_FN_NUM_ATAN2* = 0x00000010 + SQL_FN_NUM_CEILING* = 0x00000020 + SQL_FN_NUM_COS* = 0x00000040 + SQL_FN_NUM_COT* = 0x00000080 + SQL_FN_NUM_EXP* = 0x00000100 + SQL_FN_NUM_FLOOR* = 0x00000200 + SQL_FN_NUM_LOG* = 0x00000400 + SQL_FN_NUM_MOD* = 0x00000800 + SQL_FN_NUM_SIGN* = 0x00001000 + SQL_FN_NUM_SIN* = 0x00002000 + SQL_FN_NUM_SQRT* = 0x00004000 + SQL_FN_NUM_TAN* = 0x00008000 + SQL_FN_NUM_PI* = 0x00010000 + SQL_FN_NUM_RAND* = 0x00020000 + SQL_FN_NUM_DEGREES* = 0x00040000 + SQL_FN_NUM_LOG10* = 0x00080000 + SQL_FN_NUM_POWER* = 0x00100000 + SQL_FN_NUM_RADIANS* = 0x00200000 + SQL_FN_NUM_ROUND* = 0x00400000 + SQL_FN_NUM_TRUNCATE* = 0x00800000 + SQL_SNVF_BIT_LENGTH* = 0x00000001 + SQL_SNVF_CHAR_LENGTH* = 0x00000002 + SQL_SNVF_CHARACTER_LENGTH* = 0x00000004 + SQL_SNVF_EXTRACT* = 0x00000008 + SQL_SNVF_OCTET_LENGTH* = 0x00000010 + SQL_SNVF_POSITION* = 0x00000020 + SQL_FN_TD_NOW* = 0x00000001 + SQL_FN_TD_CURDATE* = 0x00000002 + SQL_FN_TD_DAYOFMONTH* = 0x00000004 + SQL_FN_TD_DAYOFWEEK* = 0x00000008 + SQL_FN_TD_DAYOFYEAR* = 0x00000010 + SQL_FN_TD_MONTH* = 0x00000020 + SQL_FN_TD_QUARTER* = 0x00000040 + SQL_FN_TD_WEEK* = 0x00000080 + SQL_FN_TD_YEAR* = 0x00000100 + SQL_FN_TD_CURTIME* = 0x00000200 + SQL_FN_TD_HOUR* = 0x00000400 + SQL_FN_TD_MINUTE* = 0x00000800 + SQL_FN_TD_SECOND* = 0x00001000 + SQL_FN_TD_TIMESTAMPADD* = 0x00002000 + SQL_FN_TD_TIMESTAMPDIFF* = 0x00004000 + SQL_FN_TD_DAYNAME* = 0x00008000 + SQL_FN_TD_MONTHNAME* = 0x00010000 + SQL_FN_TD_CURRENT_DATE* = 0x00020000 + SQL_FN_TD_CURRENT_TIME* = 0x00040000 + SQL_FN_TD_CURRENT_TIMESTAMP* = 0x00080000 + SQL_FN_TD_EXTRACT* = 0x00100000 + SQL_SDF_CURRENT_DATE* = 0x00000001 + SQL_SDF_CURRENT_TIME* = 0x00000002 + SQL_SDF_CURRENT_TIMESTAMP* = 0x00000004 + SQL_FN_SYS_USERNAME* = 0x00000001 + SQL_FN_SYS_DBNAME* = 0x00000002 + SQL_FN_SYS_IFNULL* = 0x00000004 + SQL_FN_TSI_FRAC_SECOND* = 0x00000001 + SQL_FN_TSI_SECOND* = 0x00000002 + SQL_FN_TSI_MINUTE* = 0x00000004 + SQL_FN_TSI_HOUR* = 0x00000008 + SQL_FN_TSI_DAY* = 0x00000010 + SQL_FN_TSI_WEEK* = 0x00000020 + SQL_FN_TSI_MONTH* = 0x00000040 + SQL_FN_TSI_QUARTER* = 0x00000080 + SQL_FN_TSI_YEAR* = 0x00000100 + SQL_CA1_NEXT* = 0x00000001 + SQL_CA1_ABSOLUTE* = 0x00000002 + SQL_CA1_RELATIVE* = 0x00000004 + SQL_CA1_BOOKMARK* = 0x00000008 + SQL_CA1_LOCK_NO_CHANGE* = 0x00000040 + SQL_CA1_LOCK_EXCLUSIVE* = 0x00000080 + SQL_CA1_LOCK_UNLOCK* = 0x00000100 + SQL_CA1_POS_POSITION* = 0x00000200 + SQL_CA1_POS_UPDATE* = 0x00000400 + SQL_CA1_POS_DELETE* = 0x00000800 + SQL_CA1_POS_REFRESH* = 0x00001000 + SQL_CA1_POSITIONED_UPDATE* = 0x00002000 + SQL_CA1_POSITIONED_DELETE* = 0x00004000 + SQL_CA1_SELECT_FOR_UPDATE* = 0x00008000 + SQL_CA1_BULK_ADD* = 0x00010000 + SQL_CA1_BULK_UPDATE_BY_BOOKMARK* = 0x00020000 + SQL_CA1_BULK_DELETE_BY_BOOKMARK* = 0x00040000 + SQL_CA1_BULK_FETCH_BY_BOOKMARK* = 0x00080000 + SQL_CA2_READ_ONLY_CONCURRENCY* = 0x00000001 + SQL_CA2_LOCK_CONCURRENCY* = 0x00000002 + SQL_CA2_OPT_ROWVER_CONCURRENCY* = 0x00000004 + SQL_CA2_OPT_VALUES_CONCURRENCY* = 0x00000008 + SQL_CA2_SENSITIVITY_ADDITIONS* = 0x00000010 + SQL_CA2_SENSITIVITY_DELETIONS* = 0x00000020 + SQL_CA2_SENSITIVITY_UPDATES* = 0x00000040 + SQL_CA2_MAX_ROWS_SELECT* = 0x00000080 + SQL_CA2_MAX_ROWS_INSERT* = 0x00000100 + SQL_CA2_MAX_ROWS_DELETE* = 0x00000200 + SQL_CA2_MAX_ROWS_UPDATE* = 0x00000400 + SQL_CA2_MAX_ROWS_CATALOG* = 0x00000800 + SQL_CA2_MAX_ROWS_AFFECTS_ALL* = SQL_CA2_MAX_ROWS_SELECT or SQL_CA2_MAX_ROWS_INSERT or SQL_CA2_MAX_ROWS_DELETE or SQL_CA2_MAX_ROWS_UPDATE or SQL_CA2_MAX_ROWS_CATALOG + SQL_CA2_CRC_EXACT* = 0x00001000 + SQL_CA2_CRC_APPROXIMATE* = 0x00002000 + SQL_CA2_SIMULATE_NON_UNIQUE* = 0x00004000 + SQL_CA2_SIMULATE_TRY_UNIQUE* = 0x00008000 + SQL_CA2_SIMULATE_UNIQUE* = 0x00010000 + SQL_OAC_NONE* = 0x0000 + SQL_OAC_LEVEL1* = 0x0001 + SQL_OAC_LEVEL2* = 0x0002 + SQL_OSCC_NOT_COMPLIANT* = 0x0000 + SQL_OSCC_COMPLIANT* = 0x0001 + SQL_OSC_MINIMUM* = 0x0000 + SQL_OSC_CORE* = 0x0001 + SQL_OSC_EXTENDED* = 0x0002 + SQL_CB_NULL* = 0x0000 + SQL_CB_NON_NULL* = 0x0001 + SQL_SO_FORWARD_ONLY* = 0x00000001 + SQL_SO_KEYSET_DRIVEN* = 0x00000002 + SQL_SO_DYNAMIC* = 0x00000004 + SQL_SO_MIXED* = 0x00000008 + SQL_SO_STATIC* = 0x00000010 + SQL_FD_FETCH_BOOKMARK* = 0x00000080 + SQL_CN_NONE* = 0x0000 + SQL_CN_DIFFERENT* = 0x0001 + SQL_CN_ANY* = 0x0002 + SQL_NNC_NULL* = 0x0000 + SQL_NNC_NON_NULL* = 0x0001 + SQL_NC_START* = 0x0002 + SQL_NC_END* = 0x0004 + SQL_FILE_NOT_SUPPORTED* = 0x0000 + SQL_FILE_TABLE* = 0x0001 + SQL_FILE_QUALIFIER* = 0x0002 + SQL_FILE_CATALOG* = SQL_FILE_QUALIFIER + SQL_GD_BLOCK* = 0x00000004 + SQL_GD_BOUND* = 0x00000008 + SQL_PS_POSITIONED_DELETE* = 0x00000001 + SQL_PS_POSITIONED_UPDATE* = 0x00000002 + SQL_PS_SELECT_FOR_UPDATE* = 0x00000004 + SQL_GB_NOT_SUPPORTED* = 0x0000 + SQL_GB_GROUP_BY_EQUALS_SELECT* = 0x0001 + SQL_GB_GROUP_BY_CONTAINS_SELECT* = 0x0002 + SQL_GB_NO_RELATION* = 0x0003 + SQL_GB_COLLATE* = 0x0004 + SQL_OU_DML_STATEMENTS* = 0x00000001 + SQL_OU_PROCEDURE_INVOCATION* = 0x00000002 + SQL_OU_TABLE_DEFINITION* = 0x00000004 + SQL_OU_INDEX_DEFINITION* = 0x00000008 + SQL_OU_PRIVILEGE_DEFINITION* = 0x00000010 + SQL_SU_DML_STATEMENTS* = SQL_OU_DML_STATEMENTS + SQL_SU_PROCEDURE_INVOCATION* = SQL_OU_PROCEDURE_INVOCATION + SQL_SU_TABLE_DEFINITION* = SQL_OU_TABLE_DEFINITION + SQL_SU_INDEX_DEFINITION* = SQL_OU_INDEX_DEFINITION + SQL_SU_PRIVILEGE_DEFINITION* = SQL_OU_PRIVILEGE_DEFINITION + SQL_QU_DML_STATEMENTS* = 0x00000001 + SQL_QU_PROCEDURE_INVOCATION* = 0x00000002 + SQL_QU_TABLE_DEFINITION* = 0x00000004 + SQL_QU_INDEX_DEFINITION* = 0x00000008 + SQL_QU_PRIVILEGE_DEFINITION* = 0x00000010 + SQL_CU_DML_STATEMENTS* = SQL_QU_DML_STATEMENTS + SQL_CU_PROCEDURE_INVOCATION* = SQL_QU_PROCEDURE_INVOCATION + SQL_CU_TABLE_DEFINITION* = SQL_QU_TABLE_DEFINITION + SQL_CU_INDEX_DEFINITION* = SQL_QU_INDEX_DEFINITION + SQL_CU_PRIVILEGE_DEFINITION* = SQL_QU_PRIVILEGE_DEFINITION + SQL_SQ_COMPARISON* = 0x00000001 + SQL_SQ_EXISTS* = 0x00000002 + SQL_SQ_IN* = 0x00000004 + SQL_SQ_QUANTIFIED* = 0x00000008 + SQL_SQ_CORRELATED_SUBQUERIES* = 0x00000010 + SQL_U_UNION* = 0x00000001 + SQL_U_UNION_ALL* = 0x00000002 + SQL_BP_CLOSE* = 0x00000001 + SQL_BP_DELETE* = 0x00000002 + SQL_BP_DROP* = 0x00000004 + SQL_BP_TRANSACTION* = 0x00000008 + SQL_BP_UPDATE* = 0x00000010 + SQL_BP_OTHER_HSTMT* = 0x00000020 + SQL_BP_SCROLL* = 0x00000040 + SQL_SS_ADDITIONS* = 0x00000001 + SQL_SS_DELETIONS* = 0x00000002 + SQL_SS_UPDATES* = 0x00000004 + SQL_CV_CREATE_VIEW* = 0x00000001 + SQL_CV_CHECK_OPTION* = 0x00000002 + SQL_CV_CASCADED* = 0x00000004 + SQL_CV_LOCAL* = 0x00000008 + SQL_LCK_NO_CHANGE* = 0x00000001 + SQL_LCK_EXCLUSIVE* = 0x00000002 + SQL_LCK_UNLOCK* = 0x00000004 + SQL_POS_POSITION* = 0x00000001 + SQL_POS_REFRESH* = 0x00000002 + SQL_POS_UPDATE* = 0x00000004 + SQL_POS_DELETE* = 0x00000008 + SQL_POS_ADD* = 0x00000010 + SQL_QL_START* = 0x0001 + SQL_QL_END* = 0x0002 + SQL_AF_AVG* = 0x00000001 + SQL_AF_COUNT* = 0x00000002 + SQL_AF_MAX* = 0x00000004 + SQL_AF_MIN* = 0x00000008 + SQL_AF_SUM* = 0x00000010 + SQL_AF_DISTINCT* = 0x00000020 + SQL_AF_ALL* = 0x00000040 + SQL_SC_SQL92_ENTRY* = 0x00000001 + SQL_SC_FIPS127_2_TRANSITIONAL* = 0x00000002 + SQL_SC_SQL92_INTERMEDIATE* = 0x00000004 + SQL_SC_SQL92_FULL* = 0x00000008 + SQL_DL_SQL92_DATE* = 0x00000001 + SQL_DL_SQL92_TIME* = 0x00000002 + SQL_DL_SQL92_TIMESTAMP* = 0x00000004 + SQL_DL_SQL92_INTERVAL_YEAR* = 0x00000008 + SQL_DL_SQL92_INTERVAL_MONTH* = 0x00000010 + SQL_DL_SQL92_INTERVAL_DAY* = 0x00000020 + SQL_DL_SQL92_INTERVAL_HOUR* = 0x00000040 + SQL_DL_SQL92_INTERVAL_MINUTE* = 0x00000080 + SQL_DL_SQL92_INTERVAL_SECOND* = 0x00000100 + SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH* = 0x00000200 + SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR* = 0x00000400 + SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE* = 0x00000800 + SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND* = 0x00001000 + SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE* = 0x00002000 + SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND* = 0x00004000 + SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND* = 0x00008000 + SQL_CL_START* = SQL_QL_START + SQL_CL_END* = SQL_QL_END + SQL_BRC_PROCEDURES* = 0x0000001 + SQL_BRC_EXPLICIT* = 0x0000002 + SQL_BRC_ROLLED_UP* = 0x0000004 + SQL_BS_SELECT_EXPLICIT* = 0x00000001 + SQL_BS_ROW_COUNT_EXPLICIT* = 0x00000002 + SQL_BS_SELECT_PROC* = 0x00000004 + SQL_BS_ROW_COUNT_PROC* = 0x00000008 + SQL_PARC_BATCH* = 1 + SQL_PARC_NO_BATCH* = 2 + SQL_PAS_BATCH* = 1 + SQL_PAS_NO_BATCH* = 2 + SQL_PAS_NO_SELECT* = 3 + SQL_IK_NONE* = 0x00000000 + SQL_IK_ASC* = 0x00000001 + SQL_IK_DESC* = 0x00000002 + SQL_IK_ALL* = SQL_IK_ASC or SQL_IK_DESC + SQL_ISV_ASSERTIONS* = 0x00000001 + SQL_ISV_CHARACTER_SETS* = 0x00000002 + SQL_ISV_CHECK_CONSTRAINTS* = 0x00000004 + SQL_ISV_COLLATIONS* = 0x00000008 + SQL_ISV_COLUMN_DOMAIN_USAGE* = 0x00000010 + SQL_ISV_COLUMN_PRIVILEGES* = 0x00000020 + SQL_ISV_COLUMNS* = 0x00000040 + SQL_ISV_CONSTRAINT_COLUMN_USAGE* = 0x00000080 + SQL_ISV_CONSTRAINT_TABLE_USAGE* = 0x00000100 + SQL_ISV_DOMAIN_CONSTRAINTS* = 0x00000200 + SQL_ISV_DOMAINS* = 0x00000400 + SQL_ISV_KEY_COLUMN_USAGE* = 0x00000800 + SQL_ISV_REFERENTIAL_CONSTRAINTS* = 0x00001000 + SQL_ISV_SCHEMATA* = 0x00002000 + SQL_ISV_SQL_LANGUAGES* = 0x00004000 + SQL_ISV_TABLE_CONSTRAINTS* = 0x00008000 + SQL_ISV_TABLE_PRIVILEGES* = 0x00010000 + SQL_ISV_TABLES* = 0x00020000 + SQL_ISV_TRANSLATIONS* = 0x00040000 + SQL_ISV_USAGE_PRIVILEGES* = 0x00080000 + SQL_ISV_VIEW_COLUMN_USAGE* = 0x00100000 + SQL_ISV_VIEW_TABLE_USAGE* = 0x00200000 + SQL_ISV_VIEWS* = 0x00400000 + SQL_AD_CONSTRAINT_NAME_DEFINITION* = 0x00000001 + SQL_AD_ADD_DOMAIN_CONSTRAINT* = 0x00000002 + SQL_AD_DROP_DOMAIN_CONSTRAINT* = 0x00000004 + SQL_AD_ADD_DOMAIN_DEFAULT* = 0x00000008 + SQL_AD_DROP_DOMAIN_DEFAULT* = 0x00000010 + SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED* = 0x00000020 + SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE* = 0x00000040 + SQL_AD_ADD_CONSTRAINT_DEFERRABLE* = 0x00000080 + SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE* = 0x00000100 + SQL_CS_CREATE_SCHEMA* = 0x00000001 + SQL_CS_AUTHORIZATION* = 0x00000002 + SQL_CS_DEFAULT_CHARACTER_SET* = 0x00000004 + SQL_CTR_CREATE_TRANSLATION* = 0x00000001 + SQL_CA_CREATE_ASSERTION* = 0x00000001 + SQL_CA_CONSTRAINT_INITIALLY_DEFERRED* = 0x00000010 + SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE* = 0x00000020 + SQL_CA_CONSTRAINT_DEFERRABLE* = 0x00000040 + SQL_CA_CONSTRAINT_NON_DEFERRABLE* = 0x00000080 + SQL_CCS_CREATE_CHARACTER_SET* = 0x00000001 + SQL_CCS_COLLATE_CLAUSE* = 0x00000002 + SQL_CCS_LIMITED_COLLATION* = 0x00000004 + SQL_CCOL_CREATE_COLLATION* = 0x00000001 + SQL_CDO_CREATE_DOMAIN* = 0x00000001 + SQL_CDO_DEFAULT* = 0x00000002 + SQL_CDO_CONSTRAINT* = 0x00000004 + SQL_CDO_COLLATION* = 0x00000008 + SQL_CDO_CONSTRAINT_NAME_DEFINITION* = 0x00000010 + SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED* = 0x00000020 + SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE* = 0x00000040 + SQL_CDO_CONSTRAINT_DEFERRABLE* = 0x00000080 + SQL_CDO_CONSTRAINT_NON_DEFERRABLE* = 0x00000100 + SQL_CT_CREATE_TABLE* = 0x00000001 + SQL_CT_COMMIT_PRESERVE* = 0x00000002 + SQL_CT_COMMIT_DELETE* = 0x00000004 + SQL_CT_GLOBAL_TEMPORARY* = 0x00000008 + SQL_CT_LOCAL_TEMPORARY* = 0x00000010 + SQL_CT_CONSTRAINT_INITIALLY_DEFERRED* = 0x00000020 + SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE* = 0x00000040 + SQL_CT_CONSTRAINT_DEFERRABLE* = 0x00000080 + SQL_CT_CONSTRAINT_NON_DEFERRABLE* = 0x00000100 + SQL_CT_COLUMN_CONSTRAINT* = 0x00000200 + SQL_CT_COLUMN_DEFAULT* = 0x00000400 + SQL_CT_COLUMN_COLLATION* = 0x00000800 + SQL_CT_TABLE_CONSTRAINT* = 0x00001000 + SQL_CT_CONSTRAINT_NAME_DEFINITION* = 0x00002000 + SQL_DI_CREATE_INDEX* = 0x00000001 + SQL_DI_DROP_INDEX* = 0x00000002 + SQL_DC_DROP_COLLATION* = 0x00000001 + SQL_DD_DROP_DOMAIN* = 0x00000001 + SQL_DD_RESTRICT* = 0x00000002 + SQL_DD_CASCADE* = 0x00000004 + SQL_DS_DROP_SCHEMA* = 0x00000001 + SQL_DS_RESTRICT* = 0x00000002 + SQL_DS_CASCADE* = 0x00000004 + SQL_DCS_DROP_CHARACTER_SET* = 0x00000001 + SQL_DA_DROP_ASSERTION* = 0x00000001 + SQL_DT_DROP_TABLE* = 0x00000001 + SQL_DT_RESTRICT* = 0x00000002 + SQL_DT_CASCADE* = 0x00000004 + SQL_DTR_DROP_TRANSLATION* = 0x00000001 + SQL_DV_DROP_VIEW* = 0x00000001 + SQL_DV_RESTRICT* = 0x00000002 + SQL_DV_CASCADE* = 0x00000004 + SQL_IS_INSERT_LITERALS* = 0x00000001 + SQL_IS_INSERT_SEARCHED* = 0x00000002 + SQL_IS_SELECT_INTO* = 0x00000004 + SQL_OIC_CORE* = 1 + SQL_OIC_LEVEL1* = 2 + SQL_OIC_LEVEL2* = 3 + SQL_SFKD_CASCADE* = 0x00000001 + SQL_SFKD_NO_ACTION* = 0x00000002 + SQL_SFKD_SET_DEFAULT* = 0x00000004 + SQL_SFKD_SET_NULL* = 0x00000008 + SQL_SFKU_CASCADE* = 0x00000001 + SQL_SFKU_NO_ACTION* = 0x00000002 + SQL_SFKU_SET_DEFAULT* = 0x00000004 + SQL_SFKU_SET_NULL* = 0x00000008 + SQL_SG_USAGE_ON_DOMAIN* = 0x00000001 + SQL_SG_USAGE_ON_CHARACTER_SET* = 0x00000002 + SQL_SG_USAGE_ON_COLLATION* = 0x00000004 + SQL_SG_USAGE_ON_TRANSLATION* = 0x00000008 + SQL_SG_WITH_GRANT_OPTION* = 0x00000010 + SQL_SG_DELETE_TABLE* = 0x00000020 + SQL_SG_INSERT_TABLE* = 0x00000040 + SQL_SG_INSERT_COLUMN* = 0x00000080 + SQL_SG_REFERENCES_TABLE* = 0x00000100 + SQL_SG_REFERENCES_COLUMN* = 0x00000200 + SQL_SG_SELECT_TABLE* = 0x00000400 + SQL_SG_UPDATE_TABLE* = 0x00000800 + SQL_SG_UPDATE_COLUMN* = 0x00001000 + SQL_SP_EXISTS* = 0x00000001 + SQL_SP_ISNOTNULL* = 0x00000002 + SQL_SP_ISNULL* = 0x00000004 + SQL_SP_MATCH_FULL* = 0x00000008 + SQL_SP_MATCH_PARTIAL* = 0x00000010 + SQL_SP_MATCH_UNIQUE_FULL* = 0x00000020 + SQL_SP_MATCH_UNIQUE_PARTIAL* = 0x00000040 + SQL_SP_OVERLAPS* = 0x00000080 + SQL_SP_UNIQUE* = 0x00000100 + SQL_SP_LIKE* = 0x00000200 + SQL_SP_IN* = 0x00000400 + SQL_SP_BETWEEN* = 0x00000800 + SQL_SP_COMPARISON* = 0x00001000 + SQL_SP_QUANTIFIED_COMPARISON* = 0x00002000 + SQL_SRJO_CORRESPONDING_CLAUSE* = 0x00000001 + SQL_SRJO_CROSS_JOIN* = 0x00000002 + SQL_SRJO_EXCEPT_JOIN* = 0x00000004 + SQL_SRJO_FULL_OUTER_JOIN* = 0x00000008 + SQL_SRJO_INNER_JOIN* = 0x00000010 + SQL_SRJO_INTERSECT_JOIN* = 0x00000020 + SQL_SRJO_LEFT_OUTER_JOIN* = 0x00000040 + SQL_SRJO_NATURAL_JOIN* = 0x00000080 + SQL_SRJO_RIGHT_OUTER_JOIN* = 0x00000100 + SQL_SRJO_UNION_JOIN* = 0x00000200 + SQL_SR_USAGE_ON_DOMAIN* = 0x00000001 + SQL_SR_USAGE_ON_CHARACTER_SET* = 0x00000002 + SQL_SR_USAGE_ON_COLLATION* = 0x00000004 + SQL_SR_USAGE_ON_TRANSLATION* = 0x00000008 + SQL_SR_GRANT_OPTION_FOR* = 0x00000010 + SQL_SR_CASCADE* = 0x00000020 + SQL_SR_RESTRICT* = 0x00000040 + SQL_SR_DELETE_TABLE* = 0x00000080 + SQL_SR_INSERT_TABLE* = 0x00000100 + SQL_SR_INSERT_COLUMN* = 0x00000200 + SQL_SR_REFERENCES_TABLE* = 0x00000400 + SQL_SR_REFERENCES_COLUMN* = 0x00000800 + SQL_SR_SELECT_TABLE* = 0x00001000 + SQL_SR_UPDATE_TABLE* = 0x00002000 + SQL_SR_UPDATE_COLUMN* = 0x00004000 + SQL_SRVC_VALUE_EXPRESSION* = 0x00000001 + SQL_SRVC_NULL* = 0x00000002 + SQL_SRVC_DEFAULT* = 0x00000004 + SQL_SRVC_ROW_SUBQUERY* = 0x00000008 + SQL_SVE_CASE* = 0x00000001 + SQL_SVE_CAST* = 0x00000002 + SQL_SVE_COALESCE* = 0x00000004 + SQL_SVE_NULLIF* = 0x00000008 + SQL_SCC_XOPEN_CLI_VERSION1* = 0x00000001 + SQL_SCC_ISO92_CLI* = 0x00000002 + SQL_US_UNION* = SQL_U_UNION + SQL_US_UNION_ALL* = SQL_U_UNION_ALL + SQL_DTC_ENLIST_EXPENSIVE* = 0x00000001 + SQL_DTC_UNENLIST_EXPENSIVE* = 0x00000002 + SQL_FETCH_FIRST_USER* = 31 + SQL_FETCH_FIRST_SYSTEM* = 32 + SQL_ENTIRE_ROWSET* = 0 + SQL_POSITION* = 0 + SQL_REFRESH* = 1 + SQL_UPDATE* = 2 + SQL_DELETE* = 3 + SQL_ADD* = 4 + SQL_SETPOS_MAX_OPTION_VALUE* = SQL_ADD + SQL_UPDATE_BY_BOOKMARK* = 5 + SQL_DELETE_BY_BOOKMARK* = 6 + SQL_FETCH_BY_BOOKMARK* = 7 + SQL_LOCK_NO_CHANGE* = 0 + SQL_LOCK_EXCLUSIVE* = 1 + SQL_LOCK_UNLOCK* = 2 + SQL_SETPOS_MAX_LOCK_VALUE* = SQL_LOCK_UNLOCK + SQL_BEST_ROWID* = 1 + SQL_ROWVER* = 2 + SQL_PC_NOT_PSEUDO* = 1 + SQL_QUICK* = 0 + SQL_ENSURE* = 1 + SQL_TABLE_STAT* = 0 + SQL_ALL_CATALOGS* = "%" + SQL_ALL_SCHEMAS* = "%" + SQL_ALL_TABLE_TYPES* = "%" + SQL_DRIVER_NOPROMPT* = 0 + SQL_DRIVER_COMPLETE* = 1 + SQL_DRIVER_PROMPT* = 2 + SQL_DRIVER_COMPLETE_REQUIRED* = 3 + SQL_FETCH_BOOKMARK* = 8 + SQL_ROW_SUCCESS* = 0 + SQL_ROW_DELETED* = 1 + SQL_ROW_UPDATED* = 2 + SQL_ROW_NOROW* = 3 + SQL_ROW_ADDED* = 4 + SQL_ROW_ERROR* = 5 + SQL_ROW_SUCCESS_WITH_INFO* = 6 + SQL_ROW_PROCEED* = 0 + SQL_ROW_IGNORE* = 1 + SQL_PARAM_SUCCESS* = 0 + SQL_PARAM_SUCCESS_WITH_INFO* = 6 + SQL_PARAM_ERROR* = 5 + SQL_PARAM_UNUSED* = 7 + SQL_PARAM_DIAG_UNAVAILABLE* = 1 + SQL_PARAM_PROCEED* = 0 + SQL_PARAM_IGNORE* = 1 + SQL_CASCADE* = 0 + SQL_RESTRICT* = 1 + SQL_SET_NULL* = 2 + SQL_NO_ACTION* = 3 + SQL_SET_DEFAULT* = 4 + SQL_INITIALLY_DEFERRED* = 5 + SQL_INITIALLY_IMMEDIATE* = 6 + SQL_NOT_DEFERRABLE* = 7 + SQL_PARAM_TYPE_UNKNOWN* = 0 + SQL_PARAM_INPUT* = 1 + SQL_RESULT_COL* = 3 + SQL_PARAM_OUTPUT* = 4 + SQL_RETURN_VALUE* = 5 + SQL_PT_UNKNOWN* = 0 + SQL_PT_PROCEDURE* = 1 + SQL_PT_FUNCTION* = 2 + SQL_YEAR* = SQL_CODE_YEAR + SQL_MONTH* = SQL_CODE_MONTH + SQL_DAY* = SQL_CODE_DAY + SQL_HOUR* = SQL_CODE_HOUR + SQL_MINUTE* = SQL_CODE_MINUTE + SQL_SECOND* = SQL_CODE_SECOND + SQL_YEAR_TO_MONTH* = SQL_CODE_YEAR_TO_MONTH + SQL_DAY_TO_HOUR* = SQL_CODE_DAY_TO_HOUR + SQL_DAY_TO_MINUTE* = SQL_CODE_DAY_TO_MINUTE + SQL_DAY_TO_SECOND* = SQL_CODE_DAY_TO_SECOND + SQL_HOUR_TO_MINUTE* = SQL_CODE_HOUR_TO_MINUTE + SQL_HOUR_TO_SECOND* = SQL_CODE_HOUR_TO_SECOND + SQL_MINUTE_TO_SECOND* = SQL_CODE_MINUTE_TO_SECOND + SQL_DATABASE_NAME* = 16 + SQL_FD_FETCH_PREV* = SQL_FD_FETCH_PRIOR + SQL_FETCH_PREV* = SQL_FETCH_PRIOR + SQL_CONCUR_TIMESTAMP* = SQL_CONCUR_ROWVER + SQL_SCCO_OPT_TIMESTAMP* = SQL_SCCO_OPT_ROWVER + SQL_CC_DELETE* = SQL_CB_DELETE + SQL_CR_DELETE* = SQL_CB_DELETE + SQL_CC_CLOSE* = SQL_CB_CLOSE + SQL_CR_CLOSE* = SQL_CB_CLOSE + SQL_CC_PRESERVE* = SQL_CB_PRESERVE + SQL_CR_PRESERVE* = SQL_CB_PRESERVE + SQL_SCROLL_FORWARD_ONLY* = 0 + SQL_SCROLL_KEYSET_DRIVEN* = -1 + SQL_SCROLL_DYNAMIC* = -2 + SQL_SCROLL_STATIC* = -3 + traceVersion* = 1000 + TRACE_ON* = 0x00000001 + TRACE_VS_EVENT_ON* = 0x00000002 + ODBC_VS_FLAG_UNICODE_ARG* = 0x00000001 + ODBC_VS_FLAG_UNICODE_COR* = 0x00000002 + ODBC_VS_FLAG_RETCODE* = 0x00000004 + ODBC_VS_FLAG_STOP* = 0x00000008 + SQL_C_WCHAR* = SQL_WCHAR + SQL_SQLSTATE_SIZEW* = 10 + ODBC_ADD_DSN* = 1 + ODBC_CONFIG_DSN* = 2 + ODBC_REMOVE_DSN* = 3 + ODBC_ADD_SYS_DSN* = 4 + ODBC_CONFIG_SYS_DSN* = 5 + ODBC_REMOVE_SYS_DSN* = 6 + ODBC_REMOVE_DEFAULT_DSN* = 7 + ODBC_INSTALL_INQUIRY* = 1 + ODBC_INSTALL_COMPLETE* = 2 + ODBC_INSTALL_DRIVER* = 1 + ODBC_REMOVE_DRIVER* = 2 + ODBC_CONFIG_DRIVER* = 3 + ODBC_CONFIG_DRIVER_MAX* = 100 + ODBC_BOTH_DSN* = 0 + ODBC_USER_DSN* = 1 + ODBC_SYSTEM_DSN* = 2 + ODBC_ERROR_GENERAL_ERR* = 1 + ODBC_ERROR_INVALID_BUFF_LEN* = 2 + ODBC_ERROR_INVALID_HWND* = 3 + ODBC_ERROR_INVALID_STR* = 4 + ODBC_ERROR_INVALID_REQUEST_TYPE* = 5 + ODBC_ERROR_COMPONENT_NOT_FOUND* = 6 + ODBC_ERROR_INVALID_NAME* = 7 + ODBC_ERROR_INVALID_KEYWORD_VALUE* = 8 + ODBC_ERROR_INVALID_DSN* = 9 + ODBC_ERROR_INVALID_INF* = 10 + ODBC_ERROR_REQUEST_FAILED* = 11 + ODBC_ERROR_INVALID_PATH* = 12 + ODBC_ERROR_LOAD_LIB_FAILED* = 13 + ODBC_ERROR_INVALID_PARAM_SEQUENCE* = 14 + ODBC_ERROR_INVALID_LOG_FILE* = 15 + ODBC_ERROR_USER_CANCELED* = 16 + ODBC_ERROR_USAGE_UPDATE_FAILED* = 17 + ODBC_ERROR_CREATE_DSN_FAILED* = 18 + ODBC_ERROR_WRITING_SYSINFO_FAILED* = 19 + ODBC_ERROR_REMOVE_DSN_FAILED* = 20 + ODBC_ERROR_OUT_OF_MEM* = 21 + ODBC_ERROR_OUTPUT_STRING_TRUNCATED* = 22 + SQL_ODBC_KEYWORDS* = "ABSOLUTE,ACTION,ADA,ADD,ALL,ALLOCATE,ALTER,AND,ANY,ARE,AS,ASC,ASSERTION,AT,AUTHORIZATION,AVG,BEGIN,BETWEEN,BIT,BIT_LENGTH,BOTH,BY,CASCADE,CASCADED,CASE,CAST,CATALOG,CHAR,CHAR_LENGTH,CHARACTER,CHARACTER_LENGTH,CHECK,CLOSE,COALESCE,COLLATE,COLLATION,COLUMN,COMMIT,CONNECT,CONNECTION,CONSTRAINT,CONSTRAINTS,CONTINUE,CONVERT,CORRESPONDING,COUNT,CREATE,CROSS,CURRENT,CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP,CURRENT_USER,CURSOR,DATE,DAY,DEALLOCATE,DEC,DECIMAL,DECLARE,DEFAULT,DEFERRABLE,DEFERRED,DELETE,DESC,DESCRIBE,DESCRIPTOR,DIAGNOSTICS,DISCONNECT,DISTINCT,DOMAIN,DOUBLE,DROP,ELSE,END,END-EXEC,ESCAPE,EXCEPT,EXCEPTION,EXEC,EXECUTE,EXISTS,EXTERNAL,EXTRACT,FALSE,FETCH,FIRST,FLOAT,FOR,FOREIGN,FORTRAN,FOUND,FROM,FULL,GET,GLOBAL,GO,GOTO,GRANT,GROUP,HAVING,HOUR,IDENTITY,IMMEDIATE,IN,INCLUDE,INDEX,INDICATOR,INITIALLY,INNER,INPUT,INSENSITIVE,INSERT,INT,INTEGER,INTERSECT,INTERVAL,INTO,IS,ISOLATION,JOIN,KEY,LANGUAGE,LAST,LEADING,LEFT,LEVEL,LIKE,LOCAL,LOWER,MATCH,MAX,MIN,MINUTE,MODULE,MONTH,NAMES,NATIONAL,NATURAL,NCHAR,NEXT,NO,NONE,NOT,NULL,NULLIF,NUMERIC,OCTET_LENGTH,OF,ON,ONLY,OPEN,OPTION,OR,ORDER,OUTER,OUTPUT,OVERLAPS,PAD,PARTIAL,PASCAL,PLI,POSITION,PRECISION,PREPARE,PRESERVE,PRIMARY,PRIOR,PRIVILEGES,PROCEDURE,PUBLIC,READ,REAL,REFERENCES,RELATIVE,RESTRICT,REVOKE,RIGHT,ROLLBACK,ROWSSCHEMA,SCROLL,SECOND,SECTION,SELECT,SESSION,SESSION_USER,SET,SIZE,SMALLINT,SOME,SPACE,SQL,SQLCA,SQLCODE,SQLERROR,SQLSTATE,SQLWARNING,SUBSTRING,SUM,SYSTEM_USER,TABLE,TEMPORARY,THEN,TIME,TIMESTAMP,TIMEZONE_HOUR,TIMEZONE_MINUTE,TO,TRAILING,TRANSACTION,TRANSLATE,TRANSLATION,TRIM,TRUE,UNION,UNIQUE,UNKNOWN,UPDATE,UPPER,USAGE,USER,USING,VALUE,VALUES,VARCHAR,VARYING,VIEW,WHEN,WHENEVER,WHERE,WITH,WORK,WRITE,YEAR,ZONE" +type + TSQL_YEAR_MONTH_STRUCT* {.pure.} = object + year*: TSQLUINTEGER + month*: TSQLUINTEGER + TSQL_DAY_SECOND_STRUCT* {.pure.} = object + day*: TSQLUINTEGER + hour*: TSQLUINTEGER + minute*: TSQLUINTEGER + second*: TSQLUINTEGER + fraction*: TSQLUINTEGER + SQL_INTERVAL_STRUCT_intval* {.pure, union.} = object + year_month*: TSQL_YEAR_MONTH_STRUCT + day_second*: TSQL_DAY_SECOND_STRUCT + TSQL_INTERVAL_STRUCT* {.pure.} = object + interval_type*: TSQLINTERVAL + interval_sign*: TSQLSMALLINT + intval*: SQL_INTERVAL_STRUCT_intval + TSQL_NUMERIC_STRUCT* {.pure.} = object + precision*: TSQLCHAR + scale*: TSQLSCHAR + sign*: TSQLCHAR + val*: array[SQL_MAX_NUMERIC_LEN, TSQLCHAR] +proc SQLAllocConnect*(EnvironmentHandle: TSQLHENV, ConnectionHandle: ptr TSQLHDBC): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLAllocEnv*(EnvironmentHandle: ptr TSQLHENV): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLAllocHandle*(HandleType: TSQLSMALLINT, InputHandle: TSQLHANDLE, OutputHandle: ptr TSQLHANDLE): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLAllocStmt*(ConnectionHandle: TSQLHDBC, StatementHandle: ptr TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBindCol*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, TargetType: TSQLSMALLINT, TargetValue: TSQLPOINTER, BufferLength: TSQLLEN, StrLen_or_Ind: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBindParam*(StatementHandle: TSQLHSTMT, ParameterNumber: TSQLUSMALLINT, ValueType: TSQLSMALLINT, ParameterType: TSQLSMALLINT, LengthPrecision: TSQLULEN, ParameterScale: TSQLSMALLINT, ParameterValue: TSQLPOINTER, StrLen_or_Ind: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLCancel*(StatementHandle: TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLCloseCursor*(StatementHandle: TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLCopyDesc*(SourceDescHandle: TSQLHDESC, TargetDescHandle: TSQLHDESC): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDisconnect*(ConnectionHandle: TSQLHDBC): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLEndTran*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, CompletionType: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLExecute*(StatementHandle: TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFetch*(StatementHandle: TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFetchScroll*(StatementHandle: TSQLHSTMT, FetchOrientation: TSQLSMALLINT, FetchOffset: TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFreeConnect*(ConnectionHandle: TSQLHDBC): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFreeEnv*(EnvironmentHandle: TSQLHENV): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFreeHandle*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLFreeStmt*(StatementHandle: TSQLHSTMT, Option: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetData*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, TargetType: TSQLSMALLINT, TargetValue: TSQLPOINTER, BufferLength: TSQLLEN, StrLen_or_Ind: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetEnvAttr*(EnvironmentHandle: TSQLHENV, Attribute: TSQLINTEGER, Value: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLength: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetFunctions*(ConnectionHandle: TSQLHDBC, FunctionId: TSQLUSMALLINT, Supported: ptr TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetStmtOption*(StatementHandle: TSQLHSTMT, Option: TSQLUSMALLINT, Value: TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLNumResultCols*(StatementHandle: TSQLHSTMT, ColumnCount: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLParamData*(StatementHandle: TSQLHSTMT, Value: ptr TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLPutData*(StatementHandle: TSQLHSTMT, Data: TSQLPOINTER, StrLen_or_Ind: TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLRowCount*(StatementHandle: TSQLHSTMT, RowCount: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetDescRec*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, Type: TSQLSMALLINT, SubType: TSQLSMALLINT, Length: TSQLLEN, Precision: TSQLSMALLINT, Scale: TSQLSMALLINT, Data: TSQLPOINTER, StringLength: ptr TSQLLEN, Indicator: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetEnvAttr*(EnvironmentHandle: TSQLHENV, Attribute: TSQLINTEGER, Value: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetParam*(StatementHandle: TSQLHSTMT, ParameterNumber: TSQLUSMALLINT, ValueType: TSQLSMALLINT, ParameterType: TSQLSMALLINT, LengthPrecision: TSQLULEN, ParameterScale: TSQLSMALLINT, ParameterValue: TSQLPOINTER, StrLen_or_Ind: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetStmtOption*(StatementHandle: TSQLHSTMT, Option: TSQLUSMALLINT, Value: TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLTransact*(EnvironmentHandle: TSQLHENV, ConnectionHandle: TSQLHDBC, CompletionType: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBulkOperations*(StatementHandle: TSQLHSTMT, Operation: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDescribeParam*(StatementHandle: TSQLHSTMT, ParameterNumber: TSQLUSMALLINT, DataTypePtr: ptr TSQLSMALLINT, ParameterSizePtr: ptr TSQLULEN, DecimalDigitsPtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLExtendedFetch*(StatementHandle: TSQLHSTMT, FetchOrientation: TSQLUSMALLINT, FetchOffset: TSQLLEN, RowCountPtr: ptr TSQLULEN, RowStatusArray: ptr TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLMoreResults*(StatementHandle: TSQLHSTMT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLNumParams*(StatementHandle: TSQLHSTMT, ParameterCountPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLParamOptions*(hstmt: TSQLHSTMT, crow: TSQLULEN, pirow: ptr TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +when winimCpu64: + type + TSQLSETPOSIROW* = UINT64 +when winimCpu32: + type + TSQLSETPOSIROW* = TSQLUSMALLINT +proc SQLSetPos*(StatementHandle: TSQLHSTMT, RowNumber: TSQLSETPOSIROW, Operation: TSQLUSMALLINT, LockType: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBindParameter*(StatementHandle: TSQLHSTMT, ParameterNumber: TSQLUSMALLINT, InputOutputType: TSQLSMALLINT, ValueType: TSQLSMALLINT, ParameterType: TSQLSMALLINT, ColumnSize: TSQLULEN, DecimalDigits: TSQLSMALLINT, ParameterValuePtr: TSQLPOINTER, BufferLength: TSQLLEN, StrLen_or_IndPtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLAllocHandleStd*(fHandleType: TSQLSMALLINT, hInput: TSQLHANDLE, phOutput: ptr TSQLHANDLE): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetScrollOptions*(hstmt: TSQLHSTMT, fConcurrency: TSQLUSMALLINT, crowKeyset: TSQLLEN, crowRowset: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc TraceOpenLogFile*(P1: LPWSTR, P2: LPWSTR, P3: DWORD): RETCODE {.winapi, stdcall, dynlib: "odbctrac", importc.} +proc TraceCloseLogFile*(): RETCODE {.winapi, stdcall, dynlib: "odbctrac", importc.} +proc TraceReturn*(P1: RETCODE, P2: RETCODE): VOID {.winapi, stdcall, dynlib: "odbctrac", importc.} +proc TraceVersion*(): DWORD {.winapi, stdcall, dynlib: "odbctrac", importc.} +proc TraceVSControl*(P1: DWORD): RETCODE {.winapi, stdcall, dynlib: "odbctrac", importc.} +proc ODBCSetTryWaitValue*(dwValue: DWORD): WINBOOL {.winapi, stdcall, dynlib: "odbc32", importc.} +proc ODBCGetTryWaitValue*(): DWORD {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColAttributeW*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColAttributesW*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLConnectW*(ConnectionHandle: TSQLHDBC, ServerName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, UserName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, Authentication: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDescribeColW*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, ColumnName: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT, DataTypePtr: ptr TSQLSMALLINT, ColumnSizePtr: ptr TSQLULEN, DecimalDigitsPtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLErrorW*(EnvironmentHandle: TSQLHENV, ConnectionHandle: TSQLHDBC, StatementHandle: TSQLHSTMT, Sqlstate: ptr TSQLWCHAR, NativeError: ptr TSQLINTEGER, MessageText: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, TextLength: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLExecDirectW*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLWCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetConnectAttrW*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetCursorNameW*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetDescFieldW*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, Value: TSQLPOINTER, BufferLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDescFieldW*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDescRecW*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, Name: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, TypePtr: ptr TSQLSMALLINT, SubTypePtr: ptr TSQLSMALLINT, LengthPtr: ptr TSQLLEN, PrecisionPtr: ptr TSQLSMALLINT, ScalePtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDiagFieldW*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, DiagIdentifier: TSQLSMALLINT, DiagInfoPtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDiagRecW*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, SQLState: ptr TSQLWCHAR, NativeErrorPtr: ptr TSQLINTEGER, MessageText: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, TextLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLPrepareW*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLWCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetConnectAttrW*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetCursorNameW*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLWCHAR, NameLength: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColumnsW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetConnectOptionW*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetInfoW*(ConnectionHandle: TSQLHDBC, InfoType: TSQLUSMALLINT, InfoValuePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetTypeInfoW*(StatementHandle: TSQLHSTMT, DataType: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetConnectOptionW*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSpecialColumnsW*(StatementHandle: TSQLHSTMT, IdentifierType: TSQLUSMALLINT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, Scope: TSQLUSMALLINT, Nullable: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLStatisticsW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, Unique: TSQLUSMALLINT, Reserved: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLTablesW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, TableType: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDataSourcesW*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, ServerName: ptr TSQLWCHAR, BufferLength1: TSQLSMALLINT, NameLength1Ptr: ptr TSQLSMALLINT, Description: ptr TSQLWCHAR, BufferLength2: TSQLSMALLINT, NameLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDriverConnectW*(ConnectionHandle: TSQLHDBC, WindowHandle: TSQLHWND, InConnectionString: ptr TSQLWCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT, DriverCompletion: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBrowseConnectW*(ConnectionHandle: TSQLHDBC, InConnectionString: ptr TSQLWCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColumnPrivilegesW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetStmtAttrW*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetStmtAttrW*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLForeignKeysW*(StatementHandle: TSQLHSTMT, PKCatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, PKSchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, PKTableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, FKCatalogName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT, FKSchemaName: ptr TSQLWCHAR, NameLength5: TSQLSMALLINT, FKTableName: ptr TSQLWCHAR, NameLength6: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLNativeSqlW*(ConnectionHandle: TSQLHDBC, InStatementText: ptr TSQLWCHAR, TextLength1: TSQLINTEGER, OutStatementText: ptr TSQLWCHAR, BufferLength: TSQLINTEGER, TextLength2Ptr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLPrimaryKeysW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLProcedureColumnsW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLProceduresW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLTablePrivilegesW*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDriversW*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, DriverDescription: ptr TSQLWCHAR, BufferLength1: TSQLSMALLINT, DescriptionLengthPtr: ptr TSQLSMALLINT, DriverAttributes: ptr TSQLWCHAR, BufferLength2: TSQLSMALLINT, AttributesLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColAttributeA*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColAttributesA*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLConnectA*(ConnectionHandle: TSQLHDBC, ServerName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, UserName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, Authentication: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDescribeColA*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, ColumnName: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT, DataTypePtr: ptr TSQLSMALLINT, ColumnSizePtr: ptr TSQLUINTEGER, DecimalDigitsPtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLErrorA*(EnvironmentHandle: TSQLHENV, ConnectionHandle: TSQLHDBC, StatementHandle: TSQLHSTMT, Sqlstate: ptr TSQLCHAR, NativeError: ptr TSQLINTEGER, MessageText: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, TextLength: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLExecDirectA*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetConnectAttrA*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetCursorNameA*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDescFieldA*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDescRecA*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, Name: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, TypePtr: ptr TSQLSMALLINT, SubTypePtr: ptr TSQLSMALLINT, LengthPtr: ptr TSQLINTEGER, PrecisionPtr: ptr TSQLSMALLINT, ScalePtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDiagFieldA*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, DiagIdentifier: TSQLSMALLINT, DiagInfoPtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetDiagRecA*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, SQLState: ptr TSQLCHAR, NativeErrorPtr: ptr TSQLINTEGER, MessageText: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, TextLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetStmtAttrA*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetTypeInfoA*(StatementHandle: TSQLHSTMT, DataTyoe: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLPrepareA*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetConnectAttrA*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetCursorNameA*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLCHAR, NameLength: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColumnsA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetConnectOptionA*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLGetInfoA*(ConnectionHandle: TSQLHDBC, InfoType: TSQLUSMALLINT, InfoValuePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSetConnectOptionA*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLSpecialColumnsA*(StatementHandle: TSQLHSTMT, IdentifierType: TSQLUSMALLINT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, Scope: TSQLUSMALLINT, Nullable: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLStatisticsA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, Unique: TSQLUSMALLINT, Reserved: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLTablesA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, TableType: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDataSourcesA*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, ServerName: ptr TSQLCHAR, BufferLength1: TSQLSMALLINT, NameLength1Ptr: ptr TSQLSMALLINT, Description: ptr TSQLCHAR, BufferLength2: TSQLSMALLINT, NameLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDriverConnectA*(ConnectionHandle: TSQLHDBC, WindowHandle: TSQLHWND, InConnectionString: ptr TSQLCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT, DriverCompletion: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLBrowseConnectA*(ConnectionHandle: TSQLHDBC, InConnectionString: ptr TSQLCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLColumnPrivilegesA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLForeignKeysA*(StatementHandle: TSQLHSTMT, PKCatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, PKSchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, PKTableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, FKCatalogName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT, FKSchemaName: ptr TSQLCHAR, NameLength5: TSQLSMALLINT, FKTableName: ptr TSQLCHAR, NameLength6: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLNativeSqlA*(ConnectionHandle: TSQLHDBC, InStatementText: ptr TSQLCHAR, TextLength1: TSQLINTEGER, OutStatementText: ptr TSQLCHAR, BufferLength: TSQLINTEGER, TextLength2Ptr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLPrimaryKeysA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLProcedureColumnsA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLProceduresA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLTablePrivilegesA*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLDriversA*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, DriverDescription: ptr TSQLCHAR, BufferLength1: TSQLSMALLINT, DescriptionLengthPtr: ptr TSQLSMALLINT, DriverAttributes: ptr TSQLCHAR, BufferLength2: TSQLSMALLINT, AttributesLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc.} +proc SQLInstallODBC*(hwndParent: HWND, lpszInfFile: LPCSTR, lpszSrcPath: LPCSTR, lpszDrivers: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLManageDataSources*(hwndParent: HWND): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLCreateDataSource*(hwndParent: HWND, lpszDSN: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetTranslator*(hwnd: HWND, lpszName: LPSTR, cbNameMax: WORD, pcbNameOut: ptr WORD, lpszPath: LPSTR, cbPathMax: WORD, pcbPathOut: ptr WORD, pvOption: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriver*(lpszInfFile: LPCSTR, lpszDriver: LPCSTR, lpszPath: LPSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriverManager*(lpszPath: LPSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetInstalledDrivers*(lpszBuf: LPSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetAvailableDrivers*(lpszInfFile: LPCSTR, lpszBuf: LPSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLConfigDataSource*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCSTR, lpszAttributes: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDefaultDataSource*(): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWriteDSNToIni*(lpszDSN: LPCSTR, lpszDriver: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDSNFromIni*(lpszDSN: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLValidDSN*(lpszDSN: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWritePrivateProfileString*(lpszSection: LPCSTR, lpszEntry: LPCSTR, lpszString: LPCSTR, lpszFilename: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetPrivateProfileString*(lpszSection: LPCSTR, lpszEntry: LPCSTR, lpszDefault: LPCSTR, lpszRetBuffer: LPSTR, cbRetBuffer: int32, lpszFilename: LPCSTR): int32 {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDriverManager*(lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallTranslator*(lpszInfFile: LPCSTR, lpszTranslator: LPCSTR, lpszPathIn: LPCSTR, lpszPathOut: LPSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveTranslator*(lpszTranslator: LPCSTR, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDriver*(lpszDriver: LPCSTR, fRemoveDSN: WINBOOL, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLConfigDriver*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCSTR, lpszArgs: LPCSTR, lpszMsg: LPSTR, cbMsgMax: WORD, pcbMsgOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallerError*(iError: WORD, pfErrorCode: ptr DWORD, lpszErrorMsg: LPSTR, cbErrorMsgMax: WORD, pcbErrorMsg: ptr WORD): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLPostInstallerError*(dwErrorCode: DWORD, lpszErrMsg: LPCSTR): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWriteFileDSN*(lpszFileName: LPCSTR, lpszAppName: LPCSTR, lpszKeyName: LPCSTR, lpszString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLReadFileDSN*(lpszFileName: LPCSTR, lpszAppName: LPCSTR, lpszKeyName: LPCSTR, lpszString: LPSTR, cbString: WORD, pcbString: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriverEx*(lpszDriver: LPCSTR, lpszPathIn: LPCSTR, lpszPathOut: LPSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallTranslatorEx*(lpszTranslator: LPCSTR, lpszPathIn: LPCSTR, lpszPathOut: LPSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetConfigMode*(pwConfigMode: ptr UWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLSetConfigMode*(wConfigMode: UWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallODBCW*(hwndParent: HWND, lpszInfFile: LPCWSTR, lpszSrcPath: LPCWSTR, lpszDrivers: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLCreateDataSourceW*(hwndParent: HWND, lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetTranslatorW*(hwnd: HWND, lpszName: LPWSTR, cbNameMax: WORD, pcbNameOut: ptr WORD, lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD, pvOption: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriverW*(lpszInfFile: LPCWSTR, lpszDriver: LPCWSTR, lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriverManagerW*(lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetInstalledDriversW*(lpszBuf: LPWSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetAvailableDriversW*(lpszInfFile: LPCWSTR, lpszBuf: LPWSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLConfigDataSourceW*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCWSTR, lpszAttributes: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWriteDSNToIniW*(lpszDSN: LPCWSTR, lpszDriver: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDSNFromIniW*(lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLValidDSNW*(lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWritePrivateProfileStringW*(lpszSection: LPCWSTR, lpszEntry: LPCWSTR, lpszString: LPCWSTR, lpszFilename: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLGetPrivateProfileStringW*(lpszSection: LPCWSTR, lpszEntry: LPCWSTR, lpszDefault: LPCWSTR, lpszRetBuffer: LPWSTR, cbRetBuffer: int32, lpszFilename: LPCWSTR): int32 {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallTranslatorW*(lpszInfFile: LPCWSTR, lpszTranslator: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveTranslatorW*(lpszTranslator: LPCWSTR, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLRemoveDriverW*(lpszDriver: LPCWSTR, fRemoveDSN: WINBOOL, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLConfigDriverW*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCWSTR, lpszArgs: LPCWSTR, lpszMsg: LPWSTR, cbMsgMax: WORD, pcbMsgOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallerErrorW*(iError: WORD, pfErrorCode: ptr DWORD, lpszErrorMsg: LPWSTR, cbErrorMsgMax: WORD, pcbErrorMsg: ptr WORD): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLPostInstallerErrorW*(dwErrorCode: DWORD, lpszErrorMsg: LPCWSTR): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLWriteFileDSNW*(lpszFileName: LPCWSTR, lpszAppName: LPCWSTR, lpszKeyName: LPCWSTR, lpszString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLReadFileDSNW*(lpszFileName: LPCWSTR, lpszAppName: LPCWSTR, lpszKeyName: LPCWSTR, lpszString: LPWSTR, cbString: WORD, pcbString: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallDriverExW*(lpszDriver: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLInstallTranslatorExW*(lpszTranslator: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc.} +proc SQLAllocHandle*(fHandleType: TSQLSMALLINT, hInput: TSQLHANDLE, phOutput: ptr TSQLHANDLE): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLAllocHandleStd".} +proc `wszArg=`*(self: var ODBC_VS_ARGS, x: ptr WCHAR) {.inline.} = self.union1.wszArg = x +proc wszArg*(self: ODBC_VS_ARGS): ptr WCHAR {.inline.} = self.union1.wszArg +proc wszArg*(self: var ODBC_VS_ARGS): var ptr WCHAR {.inline.} = self.union1.wszArg +proc `szArg=`*(self: var ODBC_VS_ARGS, x: ptr CHAR) {.inline.} = self.union1.szArg = x +proc szArg*(self: ODBC_VS_ARGS): ptr CHAR {.inline.} = self.union1.szArg +proc szArg*(self: var ODBC_VS_ARGS): var ptr CHAR {.inline.} = self.union1.szArg +proc `wszCorrelation=`*(self: var ODBC_VS_ARGS, x: ptr WCHAR) {.inline.} = self.union2.wszCorrelation = x +proc wszCorrelation*(self: ODBC_VS_ARGS): ptr WCHAR {.inline.} = self.union2.wszCorrelation +proc wszCorrelation*(self: var ODBC_VS_ARGS): var ptr WCHAR {.inline.} = self.union2.wszCorrelation +proc `szCorrelation=`*(self: var ODBC_VS_ARGS, x: ptr CHAR) {.inline.} = self.union2.szCorrelation = x +proc szCorrelation*(self: ODBC_VS_ARGS): ptr CHAR {.inline.} = self.union2.szCorrelation +proc szCorrelation*(self: var ODBC_VS_ARGS): var ptr CHAR {.inline.} = self.union2.szCorrelation +when winimUnicode: + type + TSQLTCHAR* = TSQLWCHAR + const + SQL_C_TCHAR* = SQL_C_WCHAR + proc SQLColAttribute*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColAttributeW".} + proc SQLColAttributes*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColAttributesW".} + proc SQLConnect*(ConnectionHandle: TSQLHDBC, ServerName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, UserName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, Authentication: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLConnectW".} + proc SQLDescribeCol*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, ColumnName: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT, DataTypePtr: ptr TSQLSMALLINT, ColumnSizePtr: ptr TSQLULEN, DecimalDigitsPtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDescribeColW".} + proc SQLError*(EnvironmentHandle: TSQLHENV, ConnectionHandle: TSQLHDBC, StatementHandle: TSQLHSTMT, Sqlstate: ptr TSQLWCHAR, NativeError: ptr TSQLINTEGER, MessageText: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, TextLength: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLErrorW".} + proc SQLExecDirect*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLWCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLExecDirectW".} + proc SQLGetConnectAttr*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetConnectAttrW".} + proc SQLGetCursorName*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetCursorNameW".} + proc SQLGetDescField*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDescFieldW".} + proc SQLGetDescRec*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, Name: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, TypePtr: ptr TSQLSMALLINT, SubTypePtr: ptr TSQLSMALLINT, LengthPtr: ptr TSQLLEN, PrecisionPtr: ptr TSQLSMALLINT, ScalePtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDescRecW".} + proc SQLGetDiagField*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, DiagIdentifier: TSQLSMALLINT, DiagInfoPtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDiagFieldW".} + proc SQLGetDiagRec*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, SQLState: ptr TSQLWCHAR, NativeErrorPtr: ptr TSQLINTEGER, MessageText: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, TextLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDiagRecW".} + proc SQLPrepare*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLWCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLPrepareW".} + proc SQLSetConnectAttr*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetConnectAttrW".} + proc SQLSetCursorName*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLWCHAR, NameLength: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetCursorNameW".} + proc SQLSetDescField*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, Value: TSQLPOINTER, BufferLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetDescFieldW".} + proc SQLSetStmtAttr*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetStmtAttrW".} + proc SQLGetStmtAttr*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetStmtAttrW".} + proc SQLColumns*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColumnsW".} + proc SQLGetConnectOption*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetConnectOptionW".} + proc SQLGetInfo*(ConnectionHandle: TSQLHDBC, InfoType: TSQLUSMALLINT, InfoValuePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetInfoW".} + proc SQLGetTypeInfo*(StatementHandle: TSQLHSTMT, DataType: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetTypeInfoW".} + proc SQLSetConnectOption*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetConnectOptionW".} + proc SQLSpecialColumns*(StatementHandle: TSQLHSTMT, IdentifierType: TSQLUSMALLINT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, Scope: TSQLUSMALLINT, Nullable: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSpecialColumnsW".} + proc SQLStatistics*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, Unique: TSQLUSMALLINT, Reserved: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLStatisticsW".} + proc SQLTables*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, TableType: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLTablesW".} + proc SQLDataSources*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, ServerName: ptr TSQLWCHAR, BufferLength1: TSQLSMALLINT, NameLength1Ptr: ptr TSQLSMALLINT, Description: ptr TSQLWCHAR, BufferLength2: TSQLSMALLINT, NameLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDataSourcesW".} + proc SQLDriverConnect*(ConnectionHandle: TSQLHDBC, WindowHandle: TSQLHWND, InConnectionString: ptr TSQLWCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT, DriverCompletion: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDriverConnectW".} + proc SQLBrowseConnect*(ConnectionHandle: TSQLHDBC, InConnectionString: ptr TSQLWCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLWCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLBrowseConnectW".} + proc SQLColumnPrivileges*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColumnPrivilegesW".} + proc SQLForeignKeys*(StatementHandle: TSQLHSTMT, PKCatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, PKSchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, PKTableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, FKCatalogName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT, FKSchemaName: ptr TSQLWCHAR, NameLength5: TSQLSMALLINT, FKTableName: ptr TSQLWCHAR, NameLength6: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLForeignKeysW".} + proc SQLNativeSql*(ConnectionHandle: TSQLHDBC, InStatementText: ptr TSQLWCHAR, TextLength1: TSQLINTEGER, OutStatementText: ptr TSQLWCHAR, BufferLength: TSQLINTEGER, TextLength2Ptr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLNativeSqlW".} + proc SQLPrimaryKeys*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLPrimaryKeysW".} + proc SQLProcedureColumns*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLWCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLProcedureColumnsW".} + proc SQLProcedures*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLProceduresW".} + proc SQLTablePrivileges*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLWCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLWCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLWCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLTablePrivilegesW".} + proc SQLDrivers*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, DriverDescription: ptr TSQLWCHAR, BufferLength1: TSQLSMALLINT, DescriptionLengthPtr: ptr TSQLSMALLINT, DriverAttributes: ptr TSQLWCHAR, BufferLength2: TSQLSMALLINT, AttributesLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDriversW".} + proc SQLInstallODBC*(hwndParent: HWND, lpszInfFile: LPCWSTR, lpszSrcPath: LPCWSTR, lpszDrivers: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallODBCW".} + proc SQLCreateDataSource*(hwndParent: HWND, lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLCreateDataSourceW".} + proc SQLGetTranslator*(hwnd: HWND, lpszName: LPWSTR, cbNameMax: WORD, pcbNameOut: ptr WORD, lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD, pvOption: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLGetTranslatorW".} + proc SQLInstallDriver*(lpszInfFile: LPCWSTR, lpszDriver: LPCWSTR, lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallDriverW".} + proc SQLInstallDriverManager*(lpszPath: LPWSTR, cbPathMax: WORD, pcbPathOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallDriverManagerW".} + proc SQLGetInstalledDrivers*(lpszBuf: LPWSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLGetInstalledDriversW".} + proc SQLGetAvailableDrivers*(lpszInfFile: LPCWSTR, lpszBuf: LPWSTR, cbBufMax: WORD, pcbBufOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLGetAvailableDriversW".} + proc SQLConfigDataSource*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCWSTR, lpszAttributes: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLConfigDataSourceW".} + proc SQLWriteDSNToIni*(lpszDSN: LPCWSTR, lpszDriver: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLWriteDSNToIniW".} + proc SQLRemoveDSNFromIni*(lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLRemoveDSNFromIniW".} + proc SQLValidDSN*(lpszDSN: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLValidDSNW".} + proc SQLWritePrivateProfileString*(lpszSection: LPCWSTR, lpszEntry: LPCWSTR, lpszString: LPCWSTR, lpszFilename: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLWritePrivateProfileStringW".} + proc SQLGetPrivateProfileString*(lpszSection: LPCWSTR, lpszEntry: LPCWSTR, lpszDefault: LPCWSTR, lpszRetBuffer: LPWSTR, cbRetBuffer: int32, lpszFilename: LPCWSTR): int32 {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLGetPrivateProfileStringW".} + proc SQLInstallTranslator*(lpszInfFile: LPCWSTR, lpszTranslator: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallTranslatorW".} + proc SQLRemoveTranslator*(lpszTranslator: LPCWSTR, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLRemoveTranslatorW".} + proc SQLRemoveDriver*(lpszDriver: LPCWSTR, fRemoveDSN: WINBOOL, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLRemoveDriverW".} + proc SQLConfigDriver*(hwndParent: HWND, fRequest: WORD, lpszDriver: LPCWSTR, lpszArgs: LPCWSTR, lpszMsg: LPWSTR, cbMsgMax: WORD, pcbMsgOut: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLConfigDriverW".} + proc SQLInstallerError*(iError: WORD, pfErrorCode: ptr DWORD, lpszErrorMsg: LPWSTR, cbErrorMsgMax: WORD, pcbErrorMsg: ptr WORD): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallerErrorW".} + proc SQLPostInstallerError*(dwErrorCode: DWORD, lpszErrorMsg: LPCWSTR): TSQLRETURN {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLPostInstallerErrorW".} + proc SQLReadFileDSN*(lpszFileName: LPCWSTR, lpszAppName: LPCWSTR, lpszKeyName: LPCWSTR, lpszString: LPWSTR, cbString: WORD, pcbString: ptr WORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLReadFileDSNW".} + proc SQLWriteFileDSN*(lpszFileName: LPCWSTR, lpszAppName: LPCWSTR, lpszKeyName: LPCWSTR, lpszString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLWriteFileDSNW".} + proc SQLInstallDriverEx*(lpszDriver: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallDriverExW".} + proc SQLInstallTranslatorEx*(lpszTranslator: LPCWSTR, lpszPathIn: LPCWSTR, lpszPathOut: LPWSTR, cbPathOutMax: WORD, pcbPathOut: ptr WORD, fRequest: WORD, lpdwUsageCount: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "odbccp32", importc: "SQLInstallTranslatorExW".} +when winimAnsi: + type + TSQLTCHAR* = TSQLCHAR + const + SQL_C_TCHAR* = SQL_C_CHAR + proc SQLColAttribute*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColAttributeA".} + proc SQLColumns*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColumnsA".} + proc SQLConnect*(ConnectionHandle: TSQLHDBC, ServerName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, UserName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, Authentication: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLConnectA".} + proc SQLDataSources*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, ServerName: ptr TSQLCHAR, BufferLength1: TSQLSMALLINT, NameLength1Ptr: ptr TSQLSMALLINT, Description: ptr TSQLCHAR, BufferLength2: TSQLSMALLINT, NameLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDataSourcesA".} + proc SQLDescribeCol*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, ColumnName: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT, DataTypePtr: ptr TSQLSMALLINT, ColumnSizePtr: ptr TSQLULEN, DecimalDigitsPtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDescribeColA".} + proc SQLError*(EnvironmentHandle: TSQLHENV, ConnectionHandle: TSQLHDBC, StatementHandle: TSQLHSTMT, Sqlstate: ptr TSQLCHAR, NativeError: ptr TSQLINTEGER, MessageText: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, TextLength: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLErrorA".} + proc SQLExecDirect*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLExecDirectA".} + proc SQLGetConnectAttr*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetConnectAttrA".} + proc SQLGetConnectOption*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLPOINTER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetConnectOptionA".} + proc SQLGetCursorName*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, NameLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetCursorNameA".} + proc SQLGetDescField*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDescFieldA".} + proc SQLGetDescRec*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, Name: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, TypePtr: ptr TSQLSMALLINT, SubTypePtr: ptr TSQLSMALLINT, LengthPtr: ptr TSQLLEN, PrecisionPtr: ptr TSQLSMALLINT, ScalePtr: ptr TSQLSMALLINT, NullablePtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDescRecA".} + proc SQLGetDiagField*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, DiagIdentifier: TSQLSMALLINT, DiagInfoPtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDiagFieldA".} + proc SQLGetDiagRec*(HandleType: TSQLSMALLINT, Handle: TSQLHANDLE, RecNumber: TSQLSMALLINT, SQLState: ptr TSQLCHAR, NativeErrorPtr: ptr TSQLINTEGER, MessageText: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, TextLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetDiagRecA".} + proc SQLGetInfo*(ConnectionHandle: TSQLHDBC, InfoType: TSQLUSMALLINT, InfoValuePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetInfoA".} + proc SQLGetStmtAttr*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, BufferLength: TSQLINTEGER, StringLengthPtr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetStmtAttrA".} + proc SQLGetTypeInfo*(StatementHandle: TSQLHSTMT, DataType: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLGetTypeInfoA".} + proc SQLPrepare*(StatementHandle: TSQLHSTMT, StatementText: ptr TSQLCHAR, TextLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLPrepareA".} + proc SQLSetConnectAttr*(ConnectionHandle: TSQLHDBC, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetConnectAttrA".} + proc SQLSetConnectOption*(ConnectionHandle: TSQLHDBC, Option: TSQLUSMALLINT, Value: TSQLULEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetConnectOptionA".} + proc SQLSetCursorName*(StatementHandle: TSQLHSTMT, CursorName: ptr TSQLCHAR, NameLength: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetCursorNameA".} + proc SQLSetDescField*(DescriptorHandle: TSQLHDESC, RecNumber: TSQLSMALLINT, FieldIdentifier: TSQLSMALLINT, Value: TSQLPOINTER, BufferLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetDescFieldA".} + proc SQLSetStmtAttr*(StatementHandle: TSQLHSTMT, Attribute: TSQLINTEGER, ValuePtr: TSQLPOINTER, StringLength: TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSetStmtAttrA".} + proc SQLSpecialColumns*(StatementHandle: TSQLHSTMT, IdentifierType: TSQLUSMALLINT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, Scope: TSQLUSMALLINT, Nullable: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLSpecialColumnsA".} + proc SQLStatistics*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, Unique: TSQLUSMALLINT, Reserved: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLStatisticsA".} + proc SQLTables*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, TableType: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLTablesA".} + proc SQLDriverConnect*(ConnectionHandle: TSQLHDBC, WindowHandle: TSQLHWND, InConnectionString: ptr TSQLCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT, DriverCompletion: TSQLUSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDriverConnectA".} + proc SQLBrowseConnect*(ConnectionHandle: TSQLHDBC, InConnectionString: ptr TSQLCHAR, StringLength1: TSQLSMALLINT, OutConnectionString: ptr TSQLCHAR, BufferLength: TSQLSMALLINT, StringLength2Ptr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLBrowseConnectA".} + proc SQLColAttributes*(StatementHandle: TSQLHSTMT, ColumnNumber: TSQLUSMALLINT, FieldIdentifier: TSQLUSMALLINT, CharacterAttributePtr: TSQLPOINTER, BufferLength: TSQLSMALLINT, StringLengthPtr: ptr TSQLSMALLINT, NumericAttributePtr: ptr TSQLLEN): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColAttributesA".} + proc SQLColumnPrivileges*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLColumnPrivilegesA".} + proc SQLForeignKeys*(StatementHandle: TSQLHSTMT, PKCatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, PKSchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, PKTableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, FKCatalogName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT, FKSchemaName: ptr TSQLCHAR, NameLength5: TSQLSMALLINT, FKTableName: ptr TSQLCHAR, NameLength6: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLForeignKeysA".} + proc SQLNativeSql*(ConnectionHandle: TSQLHDBC, InStatementText: ptr TSQLCHAR, TextLength1: TSQLINTEGER, OutStatementText: ptr TSQLCHAR, BufferLength: TSQLINTEGER, TextLength2Ptr: ptr TSQLINTEGER): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLNativeSqlA".} + proc SQLPrimaryKeys*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLPrimaryKeysA".} + proc SQLProcedureColumns*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT, ColumnName: ptr TSQLCHAR, NameLength4: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLProcedureColumnsA".} + proc SQLProcedures*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, ProcName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLProceduresA".} + proc SQLTablePrivileges*(StatementHandle: TSQLHSTMT, CatalogName: ptr TSQLCHAR, NameLength1: TSQLSMALLINT, SchemaName: ptr TSQLCHAR, NameLength2: TSQLSMALLINT, TableName: ptr TSQLCHAR, NameLength3: TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLTablePrivilegesA".} + proc SQLDrivers*(EnvironmentHandle: TSQLHENV, Direction: TSQLUSMALLINT, DriverDescription: ptr TSQLCHAR, BufferLength1: TSQLSMALLINT, DescriptionLengthPtr: ptr TSQLSMALLINT, DriverAttributes: ptr TSQLCHAR, BufferLength2: TSQLSMALLINT, AttributesLengthPtr: ptr TSQLSMALLINT): TSQLRETURN {.winapi, stdcall, dynlib: "odbc32", importc: "SQLDriversA".} +when winimCpu64: + const + SQL_C_BOOKMARK* = SQL_C_UBIGINT +when winimCpu32: + const + SQL_C_BOOKMARK* = SQL_C_ULONG diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/powrprof.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/powrprof.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,189 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + POWER_DATA_ACCESSOR* = int32 + PPOWER_DATA_ACCESSOR* = ptr int32 + GLOBAL_MACHINE_POWER_POLICY* {.pure.} = object + Revision*: ULONG + LidOpenWakeAc*: SYSTEM_POWER_STATE + LidOpenWakeDc*: SYSTEM_POWER_STATE + BroadcastCapacityResolution*: ULONG + PGLOBAL_MACHINE_POWER_POLICY* = ptr GLOBAL_MACHINE_POWER_POLICY + GLOBAL_USER_POWER_POLICY* {.pure.} = object + Revision*: ULONG + PowerButtonAc*: POWER_ACTION_POLICY + PowerButtonDc*: POWER_ACTION_POLICY + SleepButtonAc*: POWER_ACTION_POLICY + SleepButtonDc*: POWER_ACTION_POLICY + LidCloseAc*: POWER_ACTION_POLICY + LidCloseDc*: POWER_ACTION_POLICY + DischargePolicy*: array[NUM_DISCHARGE_POLICIES, SYSTEM_POWER_LEVEL] + GlobalFlags*: ULONG + PGLOBAL_USER_POWER_POLICY* = ptr GLOBAL_USER_POWER_POLICY + GLOBAL_POWER_POLICY* {.pure.} = object + user*: GLOBAL_USER_POWER_POLICY + mach*: GLOBAL_MACHINE_POWER_POLICY + PGLOBAL_POWER_POLICY* = ptr GLOBAL_POWER_POLICY + MACHINE_POWER_POLICY* {.pure.} = object + Revision*: ULONG + MinSleepAc*: SYSTEM_POWER_STATE + MinSleepDc*: SYSTEM_POWER_STATE + ReducedLatencySleepAc*: SYSTEM_POWER_STATE + ReducedLatencySleepDc*: SYSTEM_POWER_STATE + DozeTimeoutAc*: ULONG + DozeTimeoutDc*: ULONG + DozeS4TimeoutAc*: ULONG + DozeS4TimeoutDc*: ULONG + MinThrottleAc*: UCHAR + MinThrottleDc*: UCHAR + pad1*: array[2, UCHAR] + OverThrottledAc*: POWER_ACTION_POLICY + OverThrottledDc*: POWER_ACTION_POLICY + PMACHINE_POWER_POLICY* = ptr MACHINE_POWER_POLICY + MACHINE_PROCESSOR_POWER_POLICY* {.pure.} = object + Revision*: ULONG + ProcessorPolicyAc*: PROCESSOR_POWER_POLICY + ProcessorPolicyDc*: PROCESSOR_POWER_POLICY + PMACHINE_PROCESSOR_POWER_POLICY* = ptr MACHINE_PROCESSOR_POWER_POLICY + USER_POWER_POLICY* {.pure.} = object + Revision*: ULONG + IdleAc*: POWER_ACTION_POLICY + IdleDc*: POWER_ACTION_POLICY + IdleTimeoutAc*: ULONG + IdleTimeoutDc*: ULONG + IdleSensitivityAc*: UCHAR + IdleSensitivityDc*: UCHAR + ThrottlePolicyAc*: UCHAR + ThrottlePolicyDc*: UCHAR + MaxSleepAc*: SYSTEM_POWER_STATE + MaxSleepDc*: SYSTEM_POWER_STATE + Reserved*: array[2, ULONG] + VideoTimeoutAc*: ULONG + VideoTimeoutDc*: ULONG + SpindownTimeoutAc*: ULONG + SpindownTimeoutDc*: ULONG + OptimizeForPowerAc*: BOOLEAN + OptimizeForPowerDc*: BOOLEAN + FanThrottleToleranceAc*: UCHAR + FanThrottleToleranceDc*: UCHAR + ForcedThrottleAc*: UCHAR + ForcedThrottleDc*: UCHAR + PUSER_POWER_POLICY* = ptr USER_POWER_POLICY + POWER_POLICY* {.pure.} = object + user*: USER_POWER_POLICY + mach*: MACHINE_POWER_POLICY + PPOWER_POLICY* = ptr POWER_POLICY +const + enableSysTrayBatteryMeter* = 0x01 + enableMultiBatteryDisplay* = 0x02 + enablePasswordLogon* = 0x04 + enableWakeOnRing* = 0x08 + enableVideoDimDisplay* = 0x10 + NEWSCHEME* = UINT(-1) + DEVICEPOWER_HARDWAREID* = 0x80000000'i32 + DEVICEPOWER_FILTER_DEVICES_PRESENT* = 0x20000000 + DEVICEPOWER_AND_OPERATION* = 0x40000000 + DEVICEPOWER_FILTER_WAKEENABLED* = 0x08000000 + DEVICEPOWER_FILTER_ON_NAME* = 0x02000000 + PDCAP_S0_SUPPORTED* = 0x00010000 + PDCAP_S1_SUPPORTED* = 0x00020000 + PDCAP_S2_SUPPORTED* = 0x00040000 + PDCAP_S3_SUPPORTED* = 0x00080000 + PDCAP_S4_SUPPORTED* = 0x01000000 + PDCAP_S5_SUPPORTED* = 0x02000000 + PDCAP_WAKE_FROM_S0_SUPPORTED* = 0x00100000 + PDCAP_WAKE_FROM_S1_SUPPORTED* = 0x00200000 + PDCAP_WAKE_FROM_S2_SUPPORTED* = 0x00400000 + PDCAP_WAKE_FROM_S3_SUPPORTED* = 0x00800000 + DEVICEPOWER_SET_WAKEENABLED* = 0x00000001 + DEVICEPOWER_CLEAR_WAKEENABLED* = 0x00000002 + ACCESS_AC_POWER_SETTING_INDEX* = 0 + ACCESS_DC_POWER_SETTING_INDEX* = 1 + ACCESS_SCHEME* = 16 + ACCESS_SUBGROUP* = 17 + ACCESS_INDIVIDUAL_SETTING* = 18 + ACCESS_ACTIVE_SCHEME* = 19 + ACCESS_CREATE_SCHEME* = 20 + POWER_ATTRIBUTE_HIDE* = 1 +type + PWRSCHEMESENUMPROC* = proc (P1: UINT, P2: DWORD, P3: LPTSTR, P4: DWORD, P5: LPTSTR, P6: PPOWER_POLICY, P7: LPARAM): BOOLEAN {.stdcall.} + PFNNTINITIATEPWRACTION* = proc (P1: POWER_ACTION, P2: SYSTEM_POWER_STATE, P3: ULONG, P4: BOOLEAN): BOOLEAN {.stdcall.} +proc GetPwrDiskSpindownRange*(P1: PUINT, P2: PUINT): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc EnumPwrSchemes*(P1: PWRSCHEMESENUMPROC, P2: LPARAM): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc ReadGlobalPwrPolicy*(P1: PGLOBAL_POWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc ReadPwrScheme*(P1: UINT, P2: PPOWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc WritePwrScheme*(P1: PUINT, P2: LPTSTR, P3: LPTSTR, P4: PPOWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc WriteGlobalPwrPolicy*(P1: PGLOBAL_POWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc DeletePwrScheme*(P1: UINT): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc GetActivePwrScheme*(P1: PUINT): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc SetActivePwrScheme*(P1: UINT, P2: PGLOBAL_POWER_POLICY, P3: PPOWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc GetPwrCapabilities*(P1: PSYSTEM_POWER_CAPABILITIES): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc IsPwrSuspendAllowed*(): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc IsPwrHibernateAllowed*(): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc IsPwrShutdownAllowed*(): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc IsAdminOverrideActive*(P1: PADMINISTRATOR_POWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc SetSuspendState*(P1: BOOLEAN, P2: BOOLEAN, P3: BOOLEAN): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc GetCurrentPowerPolicies*(P1: PGLOBAL_POWER_POLICY, P2: PPOWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc CanUserWritePwrScheme*(): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc ReadProcessorPwrScheme*(P1: UINT, P2: PMACHINE_PROCESSOR_POWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc WriteProcessorPwrScheme*(P1: UINT, P2: PMACHINE_PROCESSOR_POWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc ValidatePowerPolicies*(P1: PGLOBAL_POWER_POLICY, P2: PPOWER_POLICY): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc DevicePowerClose*(): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc DevicePowerEnumDevices*(QueryIndex: ULONG, QueryInterpretationFlags: ULONG, QueryFlags: ULONG, pReturnBuffer: PBYTE, pBufferSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc DevicePowerOpen*(Flags: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "powrprof", importc.} +proc DevicePowerSetDeviceState*(DeviceDescription: LPCWSTR, SetFlags: ULONG, SetData: LPCVOID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerCanRestoreIndividualDefaultPowerScheme*(SchemeGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerCreatePossibleSetting*(RootSystemPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, PossibleSettingIndex: ULONG): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerCreateSetting*(RootSystemPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerDeleteScheme*(RootPowerKey: HKEY, SchemeGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerDeterminePlatformRole*(): POWER_PLATFORM_ROLE {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerDuplicateScheme*(RootPowerKey: HKEY, SourceSchemeGuid: ptr GUID, DestinationSchemeGuid: ptr ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerEnumerate*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, AccessFlags: POWER_DATA_ACCESSOR, Index: ULONG, Buffer: ptr UCHAR, BufferSize: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerGetActiveScheme*(UserRootPowerKey: HKEY, ActivePolicyGuid: ptr ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerImportPowerScheme*(RootPowerKey: HKEY, ImportFileNamePath: LPCWSTR, DestinationSchemeGuid: ptr ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadACDefaultIndex*(RootPowerKey: HKEY, SchemePersonalityGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, AcDefaultIndex: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadACValue*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Type: PULONG, Buffer: LPBYTE, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadACValueIndex*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, AcValueIndex: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadDCDefaultIndex*(RootPowerKey: HKEY, SchemePersonalityGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, DcDefaultIndex: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadDCValue*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Type: PULONG, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadDCValueIndex*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, DcValueIndex: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadDescription*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadFriendlyName*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadIconResourceSpecifier*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadPossibleDescription*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadPossibleFriendlyName*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadPossibleValue*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Type: PULONG, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadSettingAttributes*(SubGroupGuid: ptr GUID, PowerSettingGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadValueIncrement*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueIncrement: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadValueMax*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueMaximum: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadValueMin*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueMinimum: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReadValueUnitsSpecifier*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: ptr UCHAR, BufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerRemovePowerSetting*(PowerSettingSubKeyGuid: ptr GUID, PowerSettingGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerReplaceDefaultPowerSchemes*(): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerRestoreDefaultPowerSchemes*(): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerRestoreIndividualDefaultPowerScheme*(SchemeGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerSetActiveScheme*(UserRootPowerKey: HKEY, SchemeGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerSettingAccessCheck*(AccessFlags: POWER_DATA_ACCESSOR, PowerGuid: ptr GUID): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteACDefaultIndex*(RootSystemPowerKey: HKEY, SchemePersonalityGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, DefaultAcIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteACValueIndex*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, AcValueIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteDCDefaultIndex*(RootSystemPowerKey: HKEY, SchemePersonalityGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, DefaultDcIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteDCValueIndex*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, DcValueIndex: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteDescription*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteFriendlyName*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteIconResourceSpecifier*(RootPowerKey: HKEY, SchemeGuid: ptr GUID, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWritePossibleDescription*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, PossibleSettingIndex: ULONG, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWritePossibleFriendlyName*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, PossibleSettingIndex: ULONG, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWritePossibleValue*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Type: ULONG, PossibleSettingIndex: ULONG, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteSettingAttributes*(SubGroupGuid: ptr GUID, PowerSettingGuid: ptr GUID, Attributes: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteValueIncrement*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueIncrement: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteValueMax*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueMaximum: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteValueMin*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, ValueMinimum: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc PowerWriteValueUnitsSpecifier*(RootPowerKey: HKEY, SubGroupOfPowerSettingsGuid: ptr GUID, PowerSettingGuid: ptr GUID, Buffer: ptr UCHAR, BufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "powrprof", importc.} +proc CallNtPowerInformation*(P1: POWER_INFORMATION_LEVEL, P2: PVOID, P3: ULONG, P4: PVOID, P5: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "powrprof", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/psapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/psapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,216 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + MODULEINFO* {.pure.} = object + lpBaseOfDll*: LPVOID + SizeOfImage*: DWORD + EntryPoint*: LPVOID + LPMODULEINFO* = ptr MODULEINFO + PSAPI_WS_WATCH_INFORMATION* {.pure.} = object + FaultingPc*: LPVOID + FaultingVa*: LPVOID + PPSAPI_WS_WATCH_INFORMATION* = ptr PSAPI_WS_WATCH_INFORMATION + PROCESS_MEMORY_COUNTERS* {.pure.} = object + cb*: DWORD + PageFaultCount*: DWORD + PeakWorkingSetSize*: SIZE_T + WorkingSetSize*: SIZE_T + QuotaPeakPagedPoolUsage*: SIZE_T + QuotaPagedPoolUsage*: SIZE_T + QuotaPeakNonPagedPoolUsage*: SIZE_T + QuotaNonPagedPoolUsage*: SIZE_T + PagefileUsage*: SIZE_T + PeakPagefileUsage*: SIZE_T + PPROCESS_MEMORY_COUNTERS* = ptr PROCESS_MEMORY_COUNTERS + PROCESS_MEMORY_COUNTERS_EX* {.pure.} = object + cb*: DWORD + PageFaultCount*: DWORD + PeakWorkingSetSize*: SIZE_T + WorkingSetSize*: SIZE_T + QuotaPeakPagedPoolUsage*: SIZE_T + QuotaPagedPoolUsage*: SIZE_T + QuotaPeakNonPagedPoolUsage*: SIZE_T + QuotaNonPagedPoolUsage*: SIZE_T + PagefileUsage*: SIZE_T + PeakPagefileUsage*: SIZE_T + PrivateUsage*: SIZE_T + PPROCESS_MEMORY_COUNTERS_EX* = ptr PROCESS_MEMORY_COUNTERS_EX + PERFORMANCE_INFORMATION* {.pure.} = object + cb*: DWORD + CommitTotal*: SIZE_T + CommitLimit*: SIZE_T + CommitPeak*: SIZE_T + PhysicalTotal*: SIZE_T + PhysicalAvailable*: SIZE_T + SystemCache*: SIZE_T + KernelTotal*: SIZE_T + KernelPaged*: SIZE_T + KernelNonpaged*: SIZE_T + PageSize*: SIZE_T + HandleCount*: DWORD + ProcessCount*: DWORD + ThreadCount*: DWORD + PPERFORMANCE_INFORMATION* = ptr PERFORMANCE_INFORMATION + PERFORMACE_INFORMATION* = PERFORMANCE_INFORMATION + PPERFORMACE_INFORMATION* = ptr PERFORMANCE_INFORMATION + ENUM_PAGE_FILE_INFORMATION* {.pure.} = object + cb*: DWORD + Reserved*: DWORD + TotalSize*: SIZE_T + TotalInUse*: SIZE_T + PeakUsage*: SIZE_T + PENUM_PAGE_FILE_INFORMATION* = ptr ENUM_PAGE_FILE_INFORMATION + PSAPI_WS_WATCH_INFORMATION_EX* {.pure.} = object + BasicInfo*: PSAPI_WS_WATCH_INFORMATION + FaultingThreadId*: ULONG_PTR + Flags*: ULONG_PTR + PPSAPI_WS_WATCH_INFORMATION_EX* = ptr PSAPI_WS_WATCH_INFORMATION_EX +when winimCpu64: + type + PSAPI_WORKING_SET_BLOCK_STRUCT1* {.pure.} = object + Protection* {.bitsize:5.}: ULONG_PTR + ShareCount* {.bitsize:3.}: ULONG_PTR + Shared* {.bitsize:1.}: ULONG_PTR + Reserved* {.bitsize:3.}: ULONG_PTR + VirtualPage* {.bitsize:52.}: ULONG_PTR +when winimCpu32: + type + PSAPI_WORKING_SET_BLOCK_STRUCT1* {.pure.} = object + Protection* {.bitsize:5.}: ULONG_PTR + ShareCount* {.bitsize:3.}: ULONG_PTR + Shared* {.bitsize:1.}: ULONG_PTR + Reserved* {.bitsize:3.}: ULONG_PTR + VirtualPage* {.bitsize:20.}: ULONG_PTR +when winimCpu64: + type + PSAPI_WORKING_SET_BLOCK* {.pure, union.} = object + Flags*: ULONG_PTR + struct1*: PSAPI_WORKING_SET_BLOCK_STRUCT1 +when winimCpu32: + type + PSAPI_WORKING_SET_BLOCK* {.pure, union.} = object + Flags*: ULONG_PTR + struct1*: PSAPI_WORKING_SET_BLOCK_STRUCT1 +type + PSAPI_WORKING_SET_INFORMATION* {.pure.} = object + NumberOfEntries*: ULONG_PTR + WorkingSetInfo*: array[1, PSAPI_WORKING_SET_BLOCK] + PPSAPI_WORKING_SET_INFORMATION* = ptr PSAPI_WORKING_SET_INFORMATION + PSAPI_WORKING_SET_EX_BLOCK_STRUCT1* {.pure.} = object + Valid* {.bitsize:1.}: ULONG_PTR + ShareCount* {.bitsize:3.}: ULONG_PTR + Win32Protection* {.bitsize:11.}: ULONG_PTR + Shared* {.bitsize:1.}: ULONG_PTR + Node* {.bitsize:6.}: ULONG_PTR + Locked* {.bitsize:1.}: ULONG_PTR + LargePage* {.bitsize:1.}: ULONG_PTR + PSAPI_WORKING_SET_EX_BLOCK* {.pure, union.} = object + Flags*: ULONG_PTR + struct1*: PSAPI_WORKING_SET_EX_BLOCK_STRUCT1 + PPSAPI_WORKING_SET_EX_BLOCK* = ptr PSAPI_WORKING_SET_EX_BLOCK + PSAPI_WORKING_SET_EX_INFORMATION* {.pure.} = object + VirtualAddress*: PVOID + VirtualAttributes*: PSAPI_WORKING_SET_EX_BLOCK + PPSAPI_WORKING_SET_EX_INFORMATION* = ptr PSAPI_WORKING_SET_EX_INFORMATION +const + LIST_MODULES_DEFAULT* = 0x0 + LIST_MODULES_32BIT* = 0x01 + LIST_MODULES_64BIT* = 0x02 + LIST_MODULES_ALL* = LIST_MODULES_32BIT or LIST_MODULES_64BIT +type + PENUM_PAGE_FILE_CALLBACKW* = proc (pContext: LPVOID, pPageFileInfo: PENUM_PAGE_FILE_INFORMATION, lpFilename: LPCWSTR): WINBOOL {.stdcall.} + PENUM_PAGE_FILE_CALLBACKA* = proc (pContext: LPVOID, pPageFileInfo: PENUM_PAGE_FILE_INFORMATION, lpFilename: LPCSTR): WINBOOL {.stdcall.} +proc EnumProcesses*(lpidProcess: ptr DWORD, cb: DWORD, cbNeeded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc EnumProcessModules*(hProcess: HANDLE, lphModule: ptr HMODULE, cb: DWORD, lpcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetModuleBaseNameA*(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetModuleBaseNameW*(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetModuleFileNameExA*(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetModuleFileNameExW*(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetModuleInformation*(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc EmptyWorkingSet*(hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc QueryWorkingSet*(hProcess: HANDLE, pv: PVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc QueryWorkingSetEx*(hProcess: HANDLE, pv: PVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc InitializeProcessForWsWatch*(hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetWsChanges*(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetMappedFileNameW*(hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetMappedFileNameA*(hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc EnumDeviceDrivers*(lpImageBase: ptr LPVOID, cb: DWORD, lpcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetDeviceDriverBaseNameA*(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetDeviceDriverBaseNameW*(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetDeviceDriverFileNameA*(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetDeviceDriverFileNameW*(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetProcessMemoryInfo*(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetPerformanceInfo*(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc EnumPageFilesW*(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc EnumPageFilesA*(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetProcessImageFileNameA*(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetProcessImageFileNameW*(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc.} +proc GetWsChangesEx*(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc EnumProcessModulesEx*(hProcess: HANDLE, lphModule: ptr HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc.} +proc `Valid=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Valid = x +proc Valid*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.Valid +proc `ShareCount=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.ShareCount = x +proc ShareCount*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.ShareCount +proc `Win32Protection=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Win32Protection = x +proc Win32Protection*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.Win32Protection +proc `Shared=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Shared = x +proc Shared*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.Shared +proc `Node=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Node = x +proc Node*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.Node +proc `Locked=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Locked = x +proc Locked*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.Locked +proc `LargePage=`*(self: var PSAPI_WORKING_SET_EX_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.LargePage = x +proc LargePage*(self: PSAPI_WORKING_SET_EX_BLOCK): ULONG_PTR {.inline.} = self.struct1.LargePage +when winimUnicode: + type + PENUM_PAGE_FILE_CALLBACK* = PENUM_PAGE_FILE_CALLBACKW + proc GetModuleBaseName*(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetModuleBaseNameW".} + proc GetModuleFileNameEx*(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetModuleFileNameExW".} + proc GetMappedFileName*(hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetMappedFileNameW".} + proc GetDeviceDriverBaseName*(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetDeviceDriverBaseNameW".} + proc GetDeviceDriverFileName*(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetDeviceDriverFileNameW".} + proc EnumPageFiles*(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc: "EnumPageFilesW".} + proc GetProcessImageFileName*(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetProcessImageFileNameW".} +when winimAnsi: + type + PENUM_PAGE_FILE_CALLBACK* = PENUM_PAGE_FILE_CALLBACKA + proc GetModuleBaseName*(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetModuleBaseNameA".} + proc GetModuleFileNameEx*(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetModuleFileNameExA".} + proc GetMappedFileName*(hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetMappedFileNameA".} + proc GetDeviceDriverBaseName*(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetDeviceDriverBaseNameA".} + proc GetDeviceDriverFileName*(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetDeviceDriverFileNameA".} + proc EnumPageFiles*(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "psapi", importc: "EnumPageFilesA".} + proc GetProcessImageFileName*(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "psapi", importc: "GetProcessImageFileNameA".} +when winimCpu64: + type + PPSAPI_WORKING_SET_BLOCK* = ptr PSAPI_WORKING_SET_BLOCK + proc `Protection=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Protection = x + proc Protection*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Protection + proc `ShareCount=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.ShareCount = x + proc ShareCount*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.ShareCount + proc `Shared=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Shared = x + proc Shared*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Shared + proc `Reserved=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Reserved = x + proc Reserved*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Reserved + proc `VirtualPage=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.VirtualPage = x + proc VirtualPage*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.VirtualPage +when winimCpu32: + type + PPSAPI_WORKING_SET_BLOCK* = ptr PSAPI_WORKING_SET_BLOCK + proc `Protection=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Protection = x + proc Protection*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Protection + proc `ShareCount=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.ShareCount = x + proc ShareCount*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.ShareCount + proc `Shared=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Shared = x + proc Shared*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Shared + proc `Reserved=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.Reserved = x + proc Reserved*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.Reserved + proc `VirtualPage=`*(self: var PSAPI_WORKING_SET_BLOCK, x: ULONG_PTR) {.inline.} = self.struct1.VirtualPage = x + proc VirtualPage*(self: PSAPI_WORKING_SET_BLOCK): ULONG_PTR {.inline.} = self.struct1.VirtualPage diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/ras.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/ras.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,2653 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winsock +import wincrypt +import lm +#include +#include +#include +#include +#include +#include +#include +#include +type + IsolationState* = int32 + ExtendedIsolationState* = int32 + NapTracingLevel* = int32 + FailureCategory* = int32 + FixupState* = int32 + NapNotifyType* = int32 + RemoteConfigurationType* = int32 + RASCONNSTATE* = int32 + RASPROJECTION* = int32 + RASAPIVERSION* = int32 + RAS_AUTH_ATTRIBUTE_TYPE* = int32 + PPP_EAP_ACTION* = int32 + ROUTER_INTERFACE_TYPE* = int32 + ROUTER_CONNECTION_STATE* = int32 + RAS_PORT_CONDITION* = int32 + RAS_HARDWARE_CONDITION* = int32 + RAS_QUARANTINE_STATE* = int32 + MPRAPI_OBJECT_TYPE* = int32 + RAS_PARAMS_FORMAT* = int32 + HRASCONN* = HANDLE + RAS_SERVER_HANDLE* = HANDLE + MPR_SERVER_HANDLE* = HANDLE + MIB_SERVER_HANDLE* = HANDLE + HPORT* = HANDLE + ProbationTime* = FILETIME + MessageId* = UINT32 + NapComponentId* = UINT32 + SystemHealthEntityId* = NapComponentId + EnforcementEntityId* = NapComponentId + CountedString* {.pure.} = object + length*: UINT16 + string*: ptr WCHAR + StringCorrelationId* = CountedString + SystemHealthEntityCount* = UINT16 + EnforcementEntityCount* = UINT16 + Percentage* = UINT8 + SoHAttribute* {.pure.} = object + `type`*: UINT16 + size*: UINT16 + value*: ptr BYTE + SoH* {.pure.} = object + count*: UINT16 + attributes*: ptr SoHAttribute + SoHRequest* = SoH + SoHResponse* = SoH + NetworkSoH* {.pure.} = object + size*: UINT16 + data*: ptr BYTE + NetworkSoHRequest* = NetworkSoH + NetworkSoHResponse* = NetworkSoH + LPHRASCONN* = ptr HRASCONN +const + RAS_MaxEntryName* = 256 + RAS_MaxDeviceType* = 16 + RAS_MaxDeviceName* = 128 +type + RASCONNW* {.pure, packed.} = object + dwSize*: DWORD + hrasconn*: HRASCONN + szEntryName*: array[RAS_MaxEntryName + 1 , WCHAR] + szDeviceType*: array[RAS_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , WCHAR] + szPhonebook*: array[MAX_PATH , WCHAR] + padding*: array[2, byte] + dwSubEntry*: DWORD + guidEntry*: GUID + dwFlags*: DWORD + luid*: LUID + LPRASCONNW* = ptr RASCONNW + RASCONNA* {.pure, packed.} = object + dwSize*: DWORD + hrasconn*: HRASCONN + szEntryName*: array[RAS_MaxEntryName + 1 , CHAR] + szDeviceType*: array[RAS_MaxDeviceType + 1 , CHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , CHAR] + szPhonebook*: array[MAX_PATH , CHAR] + padding*: array[1, byte] + dwSubEntry*: DWORD + guidEntry*: GUID + dwFlags*: DWORD + luid*: LUID + LPRASCONNA* = ptr RASCONNA +when winimUnicode: + type + RASCONN* = RASCONNW +when winimAnsi: + type + RASCONN* = RASCONNA +type + LPRASCONN* = ptr RASCONN + LPRASCONNSTATE* = ptr RASCONNSTATE +const + RAS_MaxPhoneNumber* = 128 +type + RASCONNSTATUSW* {.pure.} = object + dwSize*: DWORD + rasconnstate*: RASCONNSTATE + dwError*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , WCHAR] + szPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , WCHAR] + LPRASCONNSTATUSW* = ptr RASCONNSTATUSW + RASCONNSTATUSA* {.pure.} = object + dwSize*: DWORD + rasconnstate*: RASCONNSTATE + dwError*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , CHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , CHAR] + szPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , CHAR] + LPRASCONNSTATUSA* = ptr RASCONNSTATUSA +when winimUnicode: + type + RASCONNSTATUS* = RASCONNSTATUSW +when winimAnsi: + type + RASCONNSTATUS* = RASCONNSTATUSA +type + LPRASCONNSTATUS* = ptr RASCONNSTATUS +const + RAS_MaxCallbackNumber* = RAS_MaxPhoneNumber +type + RASDIALPARAMSW* {.pure, packed.} = object + dwSize*: DWORD + szEntryName*: array[RAS_MaxEntryName + 1 , WCHAR] + szPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , WCHAR] + szCallbackNumber*: array[RAS_MaxCallbackNumber + 1 , WCHAR] + szUserName*: array[UNLEN + 1 , WCHAR] + szPassword*: array[PWLEN + 1 , WCHAR] + szDomain*: array[DNLEN + 1 , WCHAR] + padding*: array[2, byte] + dwSubEntry*: DWORD + dwCallbackId*: ULONG_PTR + dwIfIndex*: DWORD + LPRASDIALPARAMSW* = ptr RASDIALPARAMSW + RASDIALPARAMSA* {.pure, packed.} = object + dwSize*: DWORD + szEntryName*: array[RAS_MaxEntryName + 1 , CHAR] + szPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , CHAR] + szCallbackNumber*: array[RAS_MaxCallbackNumber + 1 , CHAR] + szUserName*: array[UNLEN + 1 , CHAR] + szPassword*: array[PWLEN + 1 , CHAR] + szDomain*: array[DNLEN + 1 , CHAR] + padding*: array[3, byte] + dwSubEntry*: DWORD + dwCallbackId*: ULONG_PTR + dwIfIndex*: DWORD + LPRASDIALPARAMSA* = ptr RASDIALPARAMSA +when winimUnicode: + type + RASDIALPARAMS* = RASDIALPARAMSW +when winimAnsi: + type + RASDIALPARAMS* = RASDIALPARAMSA +type + LPRASDIALPARAMS* = ptr RASDIALPARAMS + RASEAPINFO* {.pure, packed.} = object + dwSizeofEapInfo*: DWORD + pbEapInfo*: ptr BYTE + RASDIALEXTENSIONS* {.pure, packed.} = object + dwSize*: DWORD + dwfOptions*: DWORD + hwndParent*: HWND + reserved*: ULONG_PTR + reserved1*: ULONG_PTR + RasEapInfo*: RASEAPINFO + LPRASDIALEXTENSIONS* = ptr RASDIALEXTENSIONS + RASENTRYNAMEW* {.pure.} = object + dwSize*: DWORD + szEntryName*: array[RAS_MaxEntryName + 1 , WCHAR] + dwFlags*: DWORD + szPhonebookPath*: array[MAX_PATH + 1, WCHAR] + LPRASENTRYNAMEW* = ptr RASENTRYNAMEW + RASENTRYNAMEA* {.pure.} = object + dwSize*: DWORD + szEntryName*: array[RAS_MaxEntryName + 1 , CHAR] + dwFlags*: DWORD + szPhonebookPath*: array[MAX_PATH + 1, CHAR] + LPRASENTRYNAMEA* = ptr RASENTRYNAMEA +when winimUnicode: + type + RASENTRYNAME* = RASENTRYNAMEW +when winimAnsi: + type + RASENTRYNAME* = RASENTRYNAMEA +type + LPRASENTRYNAME* = ptr RASENTRYNAME + LPRASPROJECTION* = ptr RASPROJECTION + RASAMBW* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szNetBiosError*: array[NETBIOS_NAME_LEN + 1 , WCHAR] + bLana*: BYTE + LPRASAMBW* = ptr RASAMBW + RASAMBA* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szNetBiosError*: array[NETBIOS_NAME_LEN + 1 , CHAR] + bLana*: BYTE + LPRASAMBA* = ptr RASAMBA +when winimUnicode: + type + RASAMB* = RASAMBW +when winimAnsi: + type + RASAMB* = RASAMBA +type + LPRASAMB* = ptr RASAMB + RASPPPNBFW* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + dwNetBiosError*: DWORD + szNetBiosError*: array[NETBIOS_NAME_LEN + 1 , WCHAR] + szWorkstationName*: array[NETBIOS_NAME_LEN + 1 , WCHAR] + bLana*: BYTE + LPRASPPPNBFW* = ptr RASPPPNBFW + RASPPPNBFA* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + dwNetBiosError*: DWORD + szNetBiosError*: array[NETBIOS_NAME_LEN + 1 , CHAR] + szWorkstationName*: array[NETBIOS_NAME_LEN + 1 , CHAR] + bLana*: BYTE + LPRASPPPNBFA* = ptr RASPPPNBFA +when winimUnicode: + type + RASPPPNBF* = RASPPPNBFW +when winimAnsi: + type + RASPPPNBF* = RASPPPNBFA +type + LPRASPPPNBF* = ptr RASPPPNBF +const + RAS_MaxIpxAddress* = 21 +type + RASPPPIPXW* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpxAddress*: array[RAS_MaxIpxAddress + 1 , WCHAR] + LPRASPPPIPXW* = ptr RASPPPIPXW + RASPPPIPXA* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpxAddress*: array[RAS_MaxIpxAddress + 1 , CHAR] + LPRASPPPIPXA* = ptr RASPPPIPXA +when winimUnicode: + type + RASPPPIPX* = RASPPPIPXW +when winimAnsi: + type + RASPPPIPX* = RASPPPIPXA +type + LPRASPPPIPX* = ptr RASPPPIPX +const + RAS_MaxIpAddress* = 15 +type + RASPPPIPW* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpAddress*: array[RAS_MaxIpAddress + 1 , WCHAR] + szServerIpAddress*: array[RAS_MaxIpAddress + 1 , WCHAR] + dwOptions*: DWORD + dwServerOptions*: DWORD + LPRASPPPIPW* = ptr RASPPPIPW + RASPPPIPA* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpAddress*: array[RAS_MaxIpAddress + 1 , CHAR] + szServerIpAddress*: array[RAS_MaxIpAddress + 1 , CHAR] + dwOptions*: DWORD + dwServerOptions*: DWORD + LPRASPPPIPA* = ptr RASPPPIPA +when winimUnicode: + type + RASPPPIP* = RASPPPIPW +when winimAnsi: + type + RASPPPIP* = RASPPPIPA +type + LPRASPPPIP* = ptr RASPPPIP +const + RAS_MaxReplyMessage* = 1024 +type + RASPPPLCPW* {.pure.} = object + dwSize*: DWORD + fBundled*: WINBOOL + dwError*: DWORD + dwAuthenticationProtocol*: DWORD + dwAuthenticationData*: DWORD + dwEapTypeId*: DWORD + dwServerAuthenticationProtocol*: DWORD + dwServerAuthenticationData*: DWORD + dwServerEapTypeId*: DWORD + fMultilink*: WINBOOL + dwTerminateReason*: DWORD + dwServerTerminateReason*: DWORD + szReplyMessage*: array[RAS_MaxReplyMessage, WCHAR] + dwOptions*: DWORD + dwServerOptions*: DWORD + LPRASPPPLCPW* = ptr RASPPPLCPW + RASPPPLCPA* {.pure.} = object + dwSize*: DWORD + fBundled*: WINBOOL + dwError*: DWORD + dwAuthenticationProtocol*: DWORD + dwAuthenticationData*: DWORD + dwEapTypeId*: DWORD + dwServerAuthenticationProtocol*: DWORD + dwServerAuthenticationData*: DWORD + dwServerEapTypeId*: DWORD + fMultilink*: WINBOOL + dwTerminateReason*: DWORD + dwServerTerminateReason*: DWORD + szReplyMessage*: array[RAS_MaxReplyMessage, CHAR] + dwOptions*: DWORD + dwServerOptions*: DWORD + LPRASPPPLCPA* = ptr RASPPPLCPA +when winimUnicode: + type + RASPPPLCP* = RASPPPLCPW +when winimAnsi: + type + RASPPPLCP* = RASPPPLCPA +type + LPRASPPPLCP* = ptr RASPPPLCP + RASSLIPW* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpAddress*: array[RAS_MaxIpAddress + 1 , WCHAR] + LPRASSLIPW* = ptr RASSLIPW + RASSLIPA* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + szIpAddress*: array[RAS_MaxIpAddress + 1 , CHAR] + LPRASSLIPA* = ptr RASSLIPA +when winimUnicode: + type + RASSLIP* = RASSLIPW +when winimAnsi: + type + RASSLIP* = RASSLIPA +type + LPRASSLIP* = ptr RASSLIP + RASPPPCCP* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + dwCompressionAlgorithm*: DWORD + dwOptions*: DWORD + dwServerCompressionAlgorithm*: DWORD + dwServerOptions*: DWORD + LPRASPPPCCP* = ptr RASPPPCCP + RASDEVINFOW* {.pure.} = object + dwSize*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , WCHAR] + LPRASDEVINFOW* = ptr RASDEVINFOW + RASDEVINFOA* {.pure.} = object + dwSize*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , CHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , CHAR] + LPRASDEVINFOA* = ptr RASDEVINFOA +when winimUnicode: + type + RASDEVINFO* = RASDEVINFOW +when winimAnsi: + type + RASDEVINFO* = RASDEVINFOA +type + LPRASDEVINFO* = ptr RASDEVINFO + RASCTRYINFO* {.pure.} = object + dwSize*: DWORD + dwCountryID*: DWORD + dwNextCountryID*: DWORD + dwCountryCode*: DWORD + dwCountryNameOffset*: DWORD + RASCTRYINFOW* = RASCTRYINFO + RASCTRYINFOA* = RASCTRYINFO + LPRASCTRYINFOW* = ptr RASCTRYINFOW + LPRASCTRYINFOA* = ptr RASCTRYINFOW + LPRASCTRYINFO* = ptr RASCTRYINFO +const + RAS_MaxAreaCode* = 10 +type + RASIPADDR* {.pure.} = object + a*: BYTE + b*: BYTE + c*: BYTE + d*: BYTE +const + RAS_MaxPadType* = 32 + RAS_MaxX25Address* = 200 + RAS_MaxFacilities* = 200 + RAS_MaxUserData* = 200 + RAS_MaxDnsSuffix* = 256 +type + RASENTRYW* {.pure.} = object + dwSize*: DWORD + dwfOptions*: DWORD + dwCountryID*: DWORD + dwCountryCode*: DWORD + szAreaCode*: array[RAS_MaxAreaCode + 1 , WCHAR] + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , WCHAR] + dwAlternateOffset*: DWORD + ipaddr*: RASIPADDR + ipaddrDns*: RASIPADDR + ipaddrDnsAlt*: RASIPADDR + ipaddrWins*: RASIPADDR + ipaddrWinsAlt*: RASIPADDR + dwFrameSize*: DWORD + dwfNetProtocols*: DWORD + dwFramingProtocol*: DWORD + szScript*: array[MAX_PATH , WCHAR] + szAutodialDll*: array[MAX_PATH , WCHAR] + szAutodialFunc*: array[MAX_PATH , WCHAR] + szDeviceType*: array[RAS_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , WCHAR] + szX25PadType*: array[RAS_MaxPadType + 1 , WCHAR] + szX25Address*: array[RAS_MaxX25Address + 1 , WCHAR] + szX25Facilities*: array[RAS_MaxFacilities + 1 , WCHAR] + szX25UserData*: array[RAS_MaxUserData + 1 , WCHAR] + dwChannels*: DWORD + dwReserved1*: DWORD + dwReserved2*: DWORD + dwSubEntries*: DWORD + dwDialMode*: DWORD + dwDialExtraPercent*: DWORD + dwDialExtraSampleSeconds*: DWORD + dwHangUpExtraPercent*: DWORD + dwHangUpExtraSampleSeconds*: DWORD + dwIdleDisconnectSeconds*: DWORD + dwType*: DWORD + dwEncryptionType*: DWORD + dwCustomAuthKey*: DWORD + guidId*: GUID + szCustomDialDll*: array[MAX_PATH, WCHAR] + dwVpnStrategy*: DWORD + dwfOptions2*: DWORD + dwfOptions3*: DWORD + szDnsSuffix*: array[RAS_MaxDnsSuffix, WCHAR] + dwTcpWindowSize*: DWORD + szPrerequisitePbk*: array[MAX_PATH, WCHAR] + szPrerequisiteEntry*: array[RAS_MaxEntryName + 1, WCHAR] + dwRedialCount*: DWORD + dwRedialPause*: DWORD + LPRASENTRYW* = ptr RASENTRYW + RASENTRYA* {.pure.} = object + dwSize*: DWORD + dwfOptions*: DWORD + dwCountryID*: DWORD + dwCountryCode*: DWORD + szAreaCode*: array[RAS_MaxAreaCode + 1 , CHAR] + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , CHAR] + dwAlternateOffset*: DWORD + ipaddr*: RASIPADDR + ipaddrDns*: RASIPADDR + ipaddrDnsAlt*: RASIPADDR + ipaddrWins*: RASIPADDR + ipaddrWinsAlt*: RASIPADDR + dwFrameSize*: DWORD + dwfNetProtocols*: DWORD + dwFramingProtocol*: DWORD + szScript*: array[MAX_PATH , CHAR] + szAutodialDll*: array[MAX_PATH , CHAR] + szAutodialFunc*: array[MAX_PATH , CHAR] + szDeviceType*: array[RAS_MaxDeviceType + 1 , CHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , CHAR] + szX25PadType*: array[RAS_MaxPadType + 1 , CHAR] + szX25Address*: array[RAS_MaxX25Address + 1 , CHAR] + szX25Facilities*: array[RAS_MaxFacilities + 1 , CHAR] + szX25UserData*: array[RAS_MaxUserData + 1 , CHAR] + dwChannels*: DWORD + dwReserved1*: DWORD + dwReserved2*: DWORD + dwSubEntries*: DWORD + dwDialMode*: DWORD + dwDialExtraPercent*: DWORD + dwDialExtraSampleSeconds*: DWORD + dwHangUpExtraPercent*: DWORD + dwHangUpExtraSampleSeconds*: DWORD + dwIdleDisconnectSeconds*: DWORD + dwType*: DWORD + dwEncryptionType*: DWORD + dwCustomAuthKey*: DWORD + guidId*: GUID + szCustomDialDll*: array[MAX_PATH, CHAR] + dwVpnStrategy*: DWORD + dwfOptions2*: DWORD + dwfOptions3*: DWORD + szDnsSuffix*: array[RAS_MaxDnsSuffix, CHAR] + dwTcpWindowSize*: DWORD + szPrerequisitePbk*: array[MAX_PATH, CHAR] + szPrerequisiteEntry*: array[RAS_MaxEntryName + 1, CHAR] + dwRedialCount*: DWORD + dwRedialPause*: DWORD + LPRASENTRYA* = ptr RASENTRYA +when winimUnicode: + type + RASENTRY* = RASENTRYW +when winimAnsi: + type + RASENTRY* = RASENTRYA +type + LPRASENTRY* = ptr RASENTRY + RASADPARAMS* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + LPRASADPARAMS* = ptr RASADPARAMS + RASSUBENTRYW* {.pure.} = object + dwSize*: DWORD + dwfFlags*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , WCHAR] + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , WCHAR] + dwAlternateOffset*: DWORD + LPRASSUBENTRYW* = ptr RASSUBENTRYW + RASSUBENTRYA* {.pure.} = object + dwSize*: DWORD + dwfFlags*: DWORD + szDeviceType*: array[RAS_MaxDeviceType + 1 , CHAR] + szDeviceName*: array[RAS_MaxDeviceName + 1 , CHAR] + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , CHAR] + dwAlternateOffset*: DWORD + LPRASSUBENTRYA* = ptr RASSUBENTRYA +when winimUnicode: + type + RASSUBENTRY* = RASSUBENTRYW +when winimAnsi: + type + RASSUBENTRY* = RASSUBENTRYA +type + LPRASSUBENTRY* = ptr RASSUBENTRY + RASCREDENTIALSW* {.pure.} = object + dwSize*: DWORD + dwMask*: DWORD + szUserName*: array[UNLEN + 1 , WCHAR] + szPassword*: array[PWLEN + 1 , WCHAR] + szDomain*: array[DNLEN + 1 , WCHAR] + LPRASCREDENTIALSW* = ptr RASCREDENTIALSW + RASCREDENTIALSA* {.pure.} = object + dwSize*: DWORD + dwMask*: DWORD + szUserName*: array[UNLEN + 1 , CHAR] + szPassword*: array[PWLEN + 1 , CHAR] + szDomain*: array[DNLEN + 1 , CHAR] + LPRASCREDENTIALSA* = ptr RASCREDENTIALSA +when winimUnicode: + type + RASCREDENTIALS* = RASCREDENTIALSW +when winimAnsi: + type + RASCREDENTIALS* = RASCREDENTIALSA +type + LPRASCREDENTIALS* = ptr RASCREDENTIALS + RASAUTODIALENTRYW* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + dwDialingLocation*: DWORD + szEntry*: array[RAS_MaxEntryName + 1, WCHAR] + LPRASAUTODIALENTRYW* = ptr RASAUTODIALENTRYW + RASAUTODIALENTRYA* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + dwDialingLocation*: DWORD + szEntry*: array[RAS_MaxEntryName + 1, CHAR] + LPRASAUTODIALENTRYA* = ptr RASAUTODIALENTRYA +when winimUnicode: + type + RASAUTODIALENTRY* = RASAUTODIALENTRYW +when winimAnsi: + type + RASAUTODIALENTRY* = RASAUTODIALENTRYA +type + LPRASAUTODIALENTRY* = ptr RASAUTODIALENTRY + RASEAPUSERIDENTITYW* {.pure.} = object + szUserName*: array[UNLEN + 1 , WCHAR] + dwSizeofEapInfo*: DWORD + pbEapInfo*: array[1 , BYTE] + LPRASEAPUSERIDENTITYW* = ptr RASEAPUSERIDENTITYW + RASEAPUSERIDENTITYA* {.pure.} = object + szUserName*: array[UNLEN + 1 , CHAR] + dwSizeofEapInfo*: DWORD + pbEapInfo*: array[1 , BYTE] + LPRASEAPUSERIDENTITYA* = ptr RASEAPUSERIDENTITYA + RAS_STATS* {.pure.} = object + dwSize*: DWORD + dwBytesXmited*: DWORD + dwBytesRcved*: DWORD + dwFramesXmited*: DWORD + dwFramesRcved*: DWORD + dwCrcErr*: DWORD + dwTimeoutErr*: DWORD + dwAlignmentErr*: DWORD + dwHardwareOverrunErr*: DWORD + dwFramingErr*: DWORD + dwBufferOverrunErr*: DWORD + dwCompressionRatioIn*: DWORD + dwCompressionRatioOut*: DWORD + dwBps*: DWORD + dwConnectDuration*: DWORD + PRAS_STATS* = ptr RAS_STATS + RASNAPSTATE* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + isolationState*: IsolationState + probationTime*: ProbationTime + LPRASNAPSTATE* = ptr RASNAPSTATE + RASPPPIPV6* {.pure.} = object + dwSize*: DWORD + dwError*: DWORD + bLocalInterfaceIdentifier*: array[8, BYTE] + bPeerInterfaceIdentifier*: array[8, BYTE] + bLocalCompressionProtocol*: array[2, BYTE] + bPeerCompressionProtocol*: array[2, BYTE] + LPRASPPPIPV6* = ptr RASPPPIPV6 + RASIPV4ADDR* = IN_ADDR + RASIPV6ADDR* = IN6_ADDR + RASTUNNELENDPOINT_UNION1* {.pure, union.} = object + ipv4*: RASIPV4ADDR + ipv6*: RASIPV6ADDR + RASTUNNELENDPOINT* {.pure.} = object + dwType*: DWORD + union1*: RASTUNNELENDPOINT_UNION1 + PRASTUNNELENDPOINT* = ptr RASTUNNELENDPOINT + RASUPDATECONN* {.pure.} = object + version*: RASAPIVERSION + dwSize*: DWORD + dwFlags*: DWORD + dwIfIndex*: DWORD + localEndPoint*: RASTUNNELENDPOINT + remoteEndPoint*: RASTUNNELENDPOINT + LPRASUPDATECONN* = ptr RASUPDATECONN + RASNOUSERW* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + dwTimeoutMs*: DWORD + szUserName*: array[UNLEN + 1, WCHAR] + szPassword*: array[PWLEN + 1, WCHAR] + szDomain*: array[DNLEN + 1, WCHAR] + LPRASNOUSERW* = ptr RASNOUSERW + RASNOUSERA* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + dwTimeoutMs*: DWORD + szUserName*: array[UNLEN + 1, CHAR] + szPassword*: array[PWLEN + 1, CHAR] + szDomain*: array[DNLEN + 1, CHAR] + LPRASNOUSERA* = ptr RASNOUSERA +when winimUnicode: + type + RASNOUSER* = RASNOUSERW +when winimAnsi: + type + RASNOUSER* = RASNOUSERA +type + LPRASNOUSER* = ptr RASNOUSER + RASPBDLGFUNCW* = proc (P1: ULONG_PTR, P2: DWORD, P3: LPWSTR, P4: LPVOID): VOID {.stdcall.} + RASPBDLGW* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + dwCallbackId*: ULONG_PTR + pCallback*: RASPBDLGFUNCW + dwError*: DWORD + reserved*: ULONG_PTR + reserved2*: ULONG_PTR + LPRASPBDLGW* = ptr RASPBDLGW + RASPBDLGFUNCA* = proc (P1: ULONG_PTR, P2: DWORD, P3: LPSTR, P4: LPVOID): VOID {.stdcall.} + RASPBDLGA* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + dwCallbackId*: ULONG_PTR + pCallback*: RASPBDLGFUNCA + dwError*: DWORD + reserved*: ULONG_PTR + reserved2*: ULONG_PTR + LPRASPBDLGA* = ptr RASPBDLGA +when winimUnicode: + type + RASPBDLG* = RASPBDLGW +when winimAnsi: + type + RASPBDLG* = RASPBDLGA +type + LPRASPBDLG* = ptr RASPBDLG + TRASENTRYDLGW* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + szEntry*: array[RAS_MaxEntryName + 1, WCHAR] + padding*: array[2, byte] + dwError*: DWORD + reserved*: ULONG_PTR + reserved2*: ULONG_PTR + LPRASENTRYDLGW* = ptr TRASENTRYDLGW + TRASENTRYDLGA* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + szEntry*: array[RAS_MaxEntryName + 1, CHAR] + padding*: array[3, byte] + dwError*: DWORD + reserved*: ULONG_PTR + reserved2*: ULONG_PTR + LPRASENTRYDLGA* = ptr TRASENTRYDLGA +when winimUnicode: + type + TRASENTRYDLG* = TRASENTRYDLGW +when winimAnsi: + type + TRASENTRYDLG* = TRASENTRYDLGA +type + LPRASENTRYDLG* = ptr TRASENTRYDLG + TRASDIALDLG* {.pure, packed.} = object + dwSize*: DWORD + hwndOwner*: HWND + dwFlags*: DWORD + xDlg*: LONG + yDlg*: LONG + dwSubEntry*: DWORD + dwError*: DWORD + reserved*: ULONG_PTR + reserved2*: ULONG_PTR + LPRASDIALDLG* = ptr TRASDIALDLG + RAS_AUTH_ATTRIBUTE* {.pure.} = object + raaType*: RAS_AUTH_ATTRIBUTE_TYPE + dwLength*: DWORD + Value*: PVOID + PRAS_AUTH_ATTRIBUTE* = ptr RAS_AUTH_ATTRIBUTE + PPP_EAP_PACKET* {.pure.} = object + Code*: BYTE + Id*: BYTE + Length*: array[2, BYTE] + Data*: array[1, BYTE] + PPPP_EAP_PACKET* = ptr PPP_EAP_PACKET + PPP_EAP_INPUT* {.pure.} = object + dwSizeInBytes*: DWORD + fFlags*: DWORD + fAuthenticator*: WINBOOL + pwszIdentity*: ptr WCHAR + pwszPassword*: ptr WCHAR + bInitialId*: BYTE + pUserAttributes*: ptr RAS_AUTH_ATTRIBUTE + fAuthenticationComplete*: WINBOOL + dwAuthResultCode*: DWORD + hTokenImpersonateUser*: HANDLE + fSuccessPacketReceived*: WINBOOL + fDataReceivedFromInteractiveUI*: WINBOOL + pDataFromInteractiveUI*: PBYTE + dwSizeOfDataFromInteractiveUI*: DWORD + pConnectionData*: PBYTE + dwSizeOfConnectionData*: DWORD + pUserData*: PBYTE + dwSizeOfUserData*: DWORD + hReserved*: HANDLE + PPPP_EAP_INPUT* = ptr PPP_EAP_INPUT + PPP_EAP_OUTPUT* {.pure.} = object + dwSizeInBytes*: DWORD + Action*: PPP_EAP_ACTION + dwAuthResultCode*: DWORD + pUserAttributes*: ptr RAS_AUTH_ATTRIBUTE + fInvokeInteractiveUI*: WINBOOL + pUIContextData*: PBYTE + dwSizeOfUIContextData*: DWORD + fSaveConnectionData*: WINBOOL + pConnectionData*: PBYTE + dwSizeOfConnectionData*: DWORD + fSaveUserData*: WINBOOL + pUserData*: PBYTE + dwSizeOfUserData*: DWORD + PPPP_EAP_OUTPUT* = ptr PPP_EAP_OUTPUT + PPP_EAP_INFO* {.pure.} = object + dwSizeInBytes*: DWORD + dwEapTypeId*: DWORD + RasEapInitialize*: proc(fInitialize: WINBOOL): DWORD {.stdcall.} + RasEapBegin*: proc(ppWorkBuffer: ptr pointer, pPppEapInput: ptr PPP_EAP_INPUT): DWORD {.stdcall.} + RasEapEnd*: proc(pWorkBuffer: pointer): DWORD {.stdcall.} + RasEapMakeMessage*: proc(pWorkBuf: pointer, pReceivePacket: ptr PPP_EAP_PACKET, pSendPacket: ptr PPP_EAP_PACKET, cbSendPacket: DWORD, pEapOutput: ptr PPP_EAP_OUTPUT, pEapInput: ptr PPP_EAP_INPUT): DWORD {.stdcall.} + PPPP_EAP_INFO* = ptr PPP_EAP_INFO +const + MAX_PHONE_NUMBER_LEN* = 128 +type + RAS_USER_0* {.pure.} = object + bfPrivilege*: BYTE + wszPhoneNumber*: array[MAX_PHONE_NUMBER_LEN + 1, WCHAR] + PRAS_USER_0* = ptr RAS_USER_0 +const + MAX_PORT_NAME* = 16 + MAX_MEDIA_NAME* = 16 + MAX_DEVICE_NAME* = 128 + MAX_DEVICETYPE_NAME* = 16 +type + RAS_PORT_0* {.pure.} = object + hPort*: HANDLE + hConnection*: HANDLE + dwPortCondition*: RAS_PORT_CONDITION + dwTotalNumberOfCalls*: DWORD + dwConnectDuration*: DWORD + wszPortName*: array[MAX_PORT_NAME + 1 , WCHAR] + wszMediaName*: array[MAX_MEDIA_NAME + 1 , WCHAR] + wszDeviceName*: array[MAX_DEVICE_NAME + 1 , WCHAR] + wszDeviceType*: array[MAX_DEVICETYPE_NAME + 1 , WCHAR] + PRAS_PORT_0* = ptr RAS_PORT_0 + RAS_PORT_1* {.pure.} = object + hPort*: HANDLE + hConnection*: HANDLE + dwHardwareCondition*: RAS_HARDWARE_CONDITION + dwLineSpeed*: DWORD + dwBytesXmited*: DWORD + dwBytesRcved*: DWORD + dwFramesXmited*: DWORD + dwFramesRcved*: DWORD + dwCrcErr*: DWORD + dwTimeoutErr*: DWORD + dwAlignmentErr*: DWORD + dwHardwareOverrunErr*: DWORD + dwFramingErr*: DWORD + dwBufferOverrunErr*: DWORD + dwCompressionRatioIn*: DWORD + dwCompressionRatioOut*: DWORD + PRAS_PORT_1* = ptr RAS_PORT_1 + RAS_PORT_STATISTICS* {.pure.} = object + dwBytesXmited*: DWORD + dwBytesRcved*: DWORD + dwFramesXmited*: DWORD + dwFramesRcved*: DWORD + dwCrcErr*: DWORD + dwTimeoutErr*: DWORD + dwAlignmentErr*: DWORD + dwHardwareOverrunErr*: DWORD + dwFramingErr*: DWORD + dwBufferOverrunErr*: DWORD + dwBytesXmitedUncompressed*: DWORD + dwBytesRcvedUncompressed*: DWORD + dwBytesXmitedCompressed*: DWORD + dwBytesRcvedCompressed*: DWORD + dwPortBytesXmited*: DWORD + dwPortBytesRcved*: DWORD + dwPortFramesXmited*: DWORD + dwPortFramesRcved*: DWORD + dwPortCrcErr*: DWORD + dwPortTimeoutErr*: DWORD + dwPortAlignmentErr*: DWORD + dwPortHardwareOverrunErr*: DWORD + dwPortFramingErr*: DWORD + dwPortBufferOverrunErr*: DWORD + dwPortBytesXmitedUncompressed*: DWORD + dwPortBytesRcvedUncompressed*: DWORD + dwPortBytesXmitedCompressed*: DWORD + dwPortBytesRcvedCompressed*: DWORD + PRAS_PORT_STATISTICS* = ptr RAS_PORT_STATISTICS + RAS_SERVER_0* {.pure.} = object + TotalPorts*: WORD + PortsInUse*: WORD + RasVersion*: DWORD + PRAS_SERVER_0* = ptr RAS_SERVER_0 +const + MAX_INTERFACE_NAME_LEN* = 256 +type + MPR_INTERFACE_0* {.pure.} = object + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN+1, WCHAR] + hInterface*: HANDLE + fEnabled*: WINBOOL + dwIfType*: ROUTER_INTERFACE_TYPE + dwConnectionState*: ROUTER_CONNECTION_STATE + fUnReachabilityReasons*: DWORD + dwLastError*: DWORD + PMPR_INTERFACE_0* = ptr MPR_INTERFACE_0 + MPR_IPINIP_INTERFACE_0* {.pure.} = object + wszFriendlyName*: array[MAX_INTERFACE_NAME_LEN+1, WCHAR] + Guid*: GUID + PMPR_IPINIP_INTERFACE_0* = ptr MPR_IPINIP_INTERFACE_0 + MPR_INTERFACE_1* {.pure.} = object + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN+1, WCHAR] + hInterface*: HANDLE + fEnabled*: WINBOOL + dwIfType*: ROUTER_INTERFACE_TYPE + dwConnectionState*: ROUTER_CONNECTION_STATE + fUnReachabilityReasons*: DWORD + dwLastError*: DWORD + lpwsDialoutHoursRestriction*: LPWSTR + PMPR_INTERFACE_1* = ptr MPR_INTERFACE_1 +const + MPR_MaxDeviceType* = RAS_MaxDeviceType + MPR_MaxDeviceName* = RAS_MaxDeviceName + MPR_MaxPadType* = RAS_MaxPadType + MPR_MaxX25Address* = RAS_MaxX25Address + MPR_MaxFacilities* = RAS_MaxFacilities + MPR_MaxUserData* = RAS_MaxUserData +type + MPR_INTERFACE_2* {.pure.} = object + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN+1, WCHAR] + hInterface*: HANDLE + fEnabled*: WINBOOL + dwIfType*: ROUTER_INTERFACE_TYPE + dwConnectionState*: ROUTER_CONNECTION_STATE + fUnReachabilityReasons*: DWORD + dwLastError*: DWORD + dwfOptions*: DWORD + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1 , WCHAR] + szAlternates*: PWCHAR + ipaddr*: DWORD + ipaddrDns*: DWORD + ipaddrDnsAlt*: DWORD + ipaddrWins*: DWORD + ipaddrWinsAlt*: DWORD + dwfNetProtocols*: DWORD + szDeviceType*: array[MPR_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[MPR_MaxDeviceName + 1 , WCHAR] + szX25PadType*: array[MPR_MaxPadType + 1 , WCHAR] + szX25Address*: array[MPR_MaxX25Address + 1 , WCHAR] + szX25Facilities*: array[MPR_MaxFacilities + 1 , WCHAR] + szX25UserData*: array[MPR_MaxUserData + 1 , WCHAR] + dwChannels*: DWORD + dwSubEntries*: DWORD + dwDialMode*: DWORD + dwDialExtraPercent*: DWORD + dwDialExtraSampleSeconds*: DWORD + dwHangUpExtraPercent*: DWORD + dwHangUpExtraSampleSeconds*: DWORD + dwIdleDisconnectSeconds*: DWORD + dwType*: DWORD + dwEncryptionType*: DWORD + dwCustomAuthKey*: DWORD + dwCustomAuthDataSize*: DWORD + lpbCustomAuthData*: LPBYTE + guidId*: GUID + dwVpnStrategy*: DWORD + PMPR_INTERFACE_2* = ptr MPR_INTERFACE_2 + MPR_INTERFACE_3* {.pure.} = object + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN+1, WCHAR] + hInterface*: HANDLE + fEnabled*: WINBOOL + dwIfType*: ROUTER_INTERFACE_TYPE + dwConnectionState*: ROUTER_CONNECTION_STATE + fUnReachabilityReasons*: DWORD + dwLastError*: DWORD + dwfOptions*: DWORD + szLocalPhoneNumber*: array[RAS_MaxPhoneNumber + 1, WCHAR] + szAlternates*: PWCHAR + ipaddr*: DWORD + ipaddrDns*: DWORD + ipaddrDnsAlt*: DWORD + ipaddrWins*: DWORD + ipaddrWinsAlt*: DWORD + dwfNetProtocols*: DWORD + szDeviceType*: array[MPR_MaxDeviceType + 1, WCHAR] + szDeviceName*: array[MPR_MaxDeviceName + 1, WCHAR] + szX25PadType*: array[MPR_MaxPadType + 1, WCHAR] + szX25Address*: array[MPR_MaxX25Address + 1, WCHAR] + szX25Facilities*: array[MPR_MaxFacilities + 1, WCHAR] + szX25UserData*: array[MPR_MaxUserData + 1, WCHAR] + dwChannels*: DWORD + dwSubEntries*: DWORD + dwDialMode*: DWORD + dwDialExtraPercent*: DWORD + dwDialExtraSampleSeconds*: DWORD + dwHangUpExtraPercent*: DWORD + dwHangUpExtraSampleSeconds*: DWORD + dwIdleDisconnectSeconds*: DWORD + dwType*: DWORD + dwEncryptionType*: DWORD + dwCustomAuthKey*: DWORD + dwCustomAuthDataSize*: DWORD + lpbCustomAuthData*: LPBYTE + guidId*: GUID + dwVpnStrategy*: DWORD + AddressCount*: ULONG + ipv6addrDns*: IN6_ADDR + ipv6addrDnsAlt*: IN6_ADDR + ipv6addr*: ptr IN6_ADDR + PMPR_INTERFACE_3* = ptr MPR_INTERFACE_3 + MPR_DEVICE_0* {.pure.} = object + szDeviceType*: array[MPR_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[MPR_MaxDeviceName + 1 , WCHAR] + PMPR_DEVICE_0* = ptr MPR_DEVICE_0 +const + MPR_MaxPhoneNumber* = RAS_MaxPhoneNumber +type + MPR_DEVICE_1* {.pure.} = object + szDeviceType*: array[MPR_MaxDeviceType + 1 , WCHAR] + szDeviceName*: array[MPR_MaxDeviceName + 1 , WCHAR] + szLocalPhoneNumber*: array[MPR_MaxPhoneNumber + 1 , WCHAR] + szAlternates*: PWCHAR + PMPR_DEVICE_1* = ptr MPR_DEVICE_1 + MPR_CREDENTIALSEX_0* {.pure.} = object + dwSize*: DWORD + lpbCredentialsInfo*: LPBYTE + PMPR_CREDENTIALSEX_0* = ptr MPR_CREDENTIALSEX_0 + MPR_CREDENTIALSEX_1* {.pure.} = object + dwSize*: DWORD + lpbCredentialsInfo*: LPBYTE + PMPR_CREDENTIALSEX_1* = ptr MPR_CREDENTIALSEX_1 +const + MAX_TRANSPORT_NAME_LEN* = 40 +type + MPR_TRANSPORT_0* {.pure.} = object + dwTransportId*: DWORD + hTransport*: HANDLE + wszTransportName*: array[MAX_TRANSPORT_NAME_LEN+1, WCHAR] + PMPR_TRANSPORT_0* = ptr MPR_TRANSPORT_0 + MPR_IFTRANSPORT_0* {.pure.} = object + dwTransportId*: DWORD + hIfTransport*: HANDLE + wszIfTransportName*: array[MAX_TRANSPORT_NAME_LEN+1, WCHAR] + PMPR_IFTRANSPORT_0* = ptr MPR_IFTRANSPORT_0 + MPR_SERVER_0* {.pure.} = object + fLanOnlyMode*: WINBOOL + dwUpTime*: DWORD + dwTotalPorts*: DWORD + dwPortsInUse*: DWORD + PMPR_SERVER_0* = ptr MPR_SERVER_0 + MPR_SERVER_1* {.pure.} = object + dwNumPptpPorts*: DWORD + dwPptpPortFlags*: DWORD + dwNumL2tpPorts*: DWORD + dwL2tpPortFlags*: DWORD + PMPR_SERVER_1* = ptr MPR_SERVER_1 + RAS_CONNECTION_0* {.pure.} = object + hConnection*: HANDLE + hInterface*: HANDLE + dwConnectDuration*: DWORD + dwInterfaceType*: ROUTER_INTERFACE_TYPE + dwConnectionFlags*: DWORD + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN + 1 , WCHAR] + wszUserName*: array[UNLEN + 1 , WCHAR] + wszLogonDomain*: array[DNLEN + 1 , WCHAR] + wszRemoteComputer*: array[NETBIOS_NAME_LEN + 1 , WCHAR] + PRAS_CONNECTION_0* = ptr RAS_CONNECTION_0 + PPP_NBFCP_INFO* {.pure.} = object + dwError*: DWORD + wszWksta*: array[NETBIOS_NAME_LEN + 1 , WCHAR] +const + IPADDRESSLEN* = 15 +type + PPP_IPCP_INFO* {.pure.} = object + dwError*: DWORD + wszAddress*: array[IPADDRESSLEN + 1 , WCHAR] + wszRemoteAddress*: array[IPADDRESSLEN + 1 , WCHAR] +const + IPXADDRESSLEN* = 22 +type + PPP_IPXCP_INFO* {.pure.} = object + dwError*: DWORD + wszAddress*: array[IPXADDRESSLEN + 1 , WCHAR] +const + ATADDRESSLEN* = 32 +type + PPP_ATCP_INFO* {.pure.} = object + dwError*: DWORD + wszAddress*: array[ATADDRESSLEN + 1 , WCHAR] + PPP_INFO* {.pure.} = object + nbf*: PPP_NBFCP_INFO + ip*: PPP_IPCP_INFO + ipx*: PPP_IPXCP_INFO + at*: PPP_ATCP_INFO + RAS_CONNECTION_1* {.pure.} = object + hConnection*: HANDLE + hInterface*: HANDLE + PppInfo*: PPP_INFO + dwBytesXmited*: DWORD + dwBytesRcved*: DWORD + dwFramesXmited*: DWORD + dwFramesRcved*: DWORD + dwCrcErr*: DWORD + dwTimeoutErr*: DWORD + dwAlignmentErr*: DWORD + dwHardwareOverrunErr*: DWORD + dwFramingErr*: DWORD + dwBufferOverrunErr*: DWORD + dwCompressionRatioIn*: DWORD + dwCompressionRatioOut*: DWORD + PRAS_CONNECTION_1* = ptr RAS_CONNECTION_1 + PPP_IPCP_INFO2* {.pure.} = object + dwError*: DWORD + wszAddress*: array[IPADDRESSLEN + 1 , WCHAR] + wszRemoteAddress*: array[IPADDRESSLEN + 1 , WCHAR] + dwOptions*: DWORD + dwRemoteOptions*: DWORD + PPP_CCP_INFO* {.pure.} = object + dwError*: DWORD + dwCompressionAlgorithm*: DWORD + dwOptions*: DWORD + dwRemoteCompressionAlgorithm*: DWORD + dwRemoteOptions*: DWORD + PPP_LCP_INFO* {.pure.} = object + dwError*: DWORD + dwAuthenticationProtocol*: DWORD + dwAuthenticationData*: DWORD + dwRemoteAuthenticationProtocol*: DWORD + dwRemoteAuthenticationData*: DWORD + dwTerminateReason*: DWORD + dwRemoteTerminateReason*: DWORD + dwOptions*: DWORD + dwRemoteOptions*: DWORD + dwEapTypeId*: DWORD + dwRemoteEapTypeId*: DWORD + PPP_INFO_2* {.pure.} = object + nbf*: PPP_NBFCP_INFO + ip*: PPP_IPCP_INFO2 + ipx*: PPP_IPXCP_INFO + at*: PPP_ATCP_INFO + ccp*: PPP_CCP_INFO + lcp*: PPP_LCP_INFO + RAS_CONNECTION_2* {.pure.} = object + hConnection*: HANDLE + wszUserName*: array[UNLEN + 1 , WCHAR] + dwInterfaceType*: ROUTER_INTERFACE_TYPE + guid*: GUID + PppInfo2*: PPP_INFO_2 + PRAS_CONNECTION_2* = ptr RAS_CONNECTION_2 + RAS_USER_1* {.pure.} = object + bfPrivilege*: BYTE + wszPhoneNumber*: array[MAX_PHONE_NUMBER_LEN + 1, WCHAR] + bfPrivilege2*: BYTE + PRAS_USER_1* = ptr RAS_USER_1 + MPR_FILTER_0* {.pure.} = object + fEnabled*: WINBOOL + PMPR_FILTER_0* = ptr MPR_FILTER_0 + MPR_SERVER_2* {.pure.} = object + dwNumPptpPorts*: DWORD + dwPptpPortFlags*: DWORD + dwNumL2tpPorts*: DWORD + dwL2tpPortFlags*: DWORD + dwNumSstpPorts*: DWORD + dwSstpPortFlags*: DWORD + PMPR_SERVER_2* = ptr MPR_SERVER_2 + PPP_IPV6_CP_INFO* {.pure.} = object + dwVersion*: DWORD + dwSize*: DWORD + dwError*: DWORD + bInterfaceIdentifier*: array[8, BYTE] + bRemoteInterfaceIdentifier*: array[8, BYTE] + dwOptions*: DWORD + dwRemoteOptions*: DWORD + bPrefix*: array[8, BYTE] + dwPrefixLength*: DWORD + PPPP_IPV6_CP_INFO* = ptr PPP_IPV6_CP_INFO + PPP_INFO_3* {.pure.} = object + nbf*: PPP_NBFCP_INFO + ip*: PPP_IPCP_INFO2 + ipv6*: PPP_IPV6_CP_INFO + ccp*: PPP_CCP_INFO + lcp*: PPP_LCP_INFO + RAS_CONNECTION_3* {.pure.} = object + dwVersion*: DWORD + dwSize*: DWORD + hConnection*: HANDLE + wszUserName*: array[UNLEN + 1, WCHAR] + dwInterfaceType*: ROUTER_INTERFACE_TYPE + guid*: GUID + PppInfo3*: PPP_INFO_3 + rasQuarState*: RAS_QUARANTINE_STATE + timer*: FILETIME + PRAS_CONNECTION_3* = ptr RAS_CONNECTION_3 + MPRAPI_OBJECT_HEADER* {.pure.} = object + revision*: UCHAR + `type`*: UCHAR + size*: USHORT + PMPRAPI_OBJECT_HEADER* = ptr MPRAPI_OBJECT_HEADER + AUTH_VALIDATION_EX* {.pure.} = object + Header*: MPRAPI_OBJECT_HEADER + hRasConnection*: HANDLE + wszUserName*: array[UNLEN + 1 , WCHAR] + wszLogonDomain*: array[DNLEN + 1 , WCHAR] + AuthInfoSize*: DWORD + AuthInfo*: array[1, BYTE] + PAUTH_VALIDATION_EX* = ptr AUTH_VALIDATION_EX + PPP_PROJECTION_INFO* {.pure.} = object + dwIPv4NegotiationError*: DWORD + wszAddress*: array[IPADDRESSLEN + 1, WCHAR] + wszRemoteAddress*: array[IPADDRESSLEN + 1, WCHAR] + dwIPv4Options*: DWORD + dwIPv4RemoteOptions*: DWORD + IPv4SubInterfaceIndex*: ULONG64 + dwIPv6NegotiationError*: DWORD + bInterfaceIdentifier*: array[8, BYTE] + bRemoteInterfaceIdentifier*: array[8, BYTE] + bPrefix*: array[8, BYTE] + dwPrefixLength*: DWORD + IPv6SubInterfaceIndex*: ULONG64 + dwLcpError*: DWORD + dwAuthenticationProtocol*: DWORD + dwAuthenticationData*: DWORD + dwRemoteAuthenticationProtocol*: DWORD + dwRemoteAuthenticationData*: DWORD + dwLcpTerminateReason*: DWORD + dwLcpRemoteTerminateReason*: DWORD + dwLcpOptions*: DWORD + dwLcpRemoteOptions*: DWORD + dwEapTypeId*: DWORD + dwRemoteEapTypeId*: DWORD + dwCcpError*: DWORD + dwCompressionAlgorithm*: DWORD + dwCcpOptions*: DWORD + dwRemoteCompressionAlgorithm*: DWORD + dwCcpRemoteOptions*: DWORD + PPPP_PROJECTION_INFO* = ptr PPP_PROJECTION_INFO + IKEV2_PROJECTION_INFO* {.pure.} = object + dwIPv4NegotiationError*: DWORD + wszAddress*: array[IPADDRESSLEN + 1, WCHAR] + wszRemoteAddress*: array[IPADDRESSLEN + 1, WCHAR] + IPv4SubInterfaceIndex*: ULONG64 + dwIPv6NegotiationError*: DWORD + bInterfaceIdentifier*: array[8, BYTE] + bRemoteInterfaceIdentifier*: array[8, BYTE] + bPrefix*: array[8, BYTE] + dwPrefixLength*: DWORD + IPv6SubInterfaceIndex*: ULONG64 + dwOptions*: DWORD + dwAuthenticationProtocol*: DWORD + dwEapTypeId*: DWORD + dwCompressionAlgorithm*: DWORD + dwEncryptionMethod*: DWORD + PIKEV2_PROJECTION_INFO* = ptr IKEV2_PROJECTION_INFO + PROJECTION_INFO_UNION1* {.pure, union.} = object + Ikev2ProjectionInfo*: IKEV2_PROJECTION_INFO + PppProjectionInfo*: PPP_PROJECTION_INFO + PROJECTION_INFO* {.pure.} = object + projectionInfoType*: UCHAR + union1*: PROJECTION_INFO_UNION1 + PPROJECTION_INFO* = ptr PROJECTION_INFO +const + MAXIPADRESSLEN* = 64 +type + RAS_CONNECTION_EX* {.pure.} = object + Header*: MPRAPI_OBJECT_HEADER + dwConnectDuration*: DWORD + dwInterfaceType*: ROUTER_INTERFACE_TYPE + dwConnectionFlags*: DWORD + wszInterfaceName*: array[MAX_INTERFACE_NAME_LEN + 1, WCHAR] + wszUserName*: array[UNLEN + 1, WCHAR] + wszLogonDomain*: array[DNLEN + 1, WCHAR] + wszRemoteComputer*: array[NETBIOS_NAME_LEN + 1, WCHAR] + guid*: GUID + rasQuarState*: RAS_QUARANTINE_STATE + probationTime*: FILETIME + dwBytesXmited*: DWORD + dwBytesRcved*: DWORD + dwFramesXmited*: DWORD + dwFramesRcved*: DWORD + dwCrcErr*: DWORD + dwTimeoutErr*: DWORD + dwAlignmentErr*: DWORD + dwHardwareOverrunErr*: DWORD + dwFramingErr*: DWORD + dwBufferOverrunErr*: DWORD + dwCompressionRatioIn*: DWORD + dwCompressionRatioOut*: DWORD + dwNumSwitchOvers*: DWORD + wszRemoteEndpointAddress*: array[MAXIPADRESSLEN+1, WCHAR] + wszLocalEndpointAddress*: array[MAXIPADRESSLEN+1, WCHAR] + ProjectionInfo*: PROJECTION_INFO + hConnection*: HANDLE + hInterface*: HANDLE + PRAS_CONNECTION_EX* = ptr RAS_CONNECTION_EX + RAS_UPDATE_CONNECTION* {.pure.} = object + Header*: MPRAPI_OBJECT_HEADER + dwIfIndex*: DWORD + wszLocalEndpointAddress*: array[MAXIPADRESSLEN+1, WCHAR] + wszRemoteEndpointAddress*: array[MAXIPADRESSLEN+1, WCHAR] + PRAS_UPDATE_CONNECTION* = ptr RAS_UPDATE_CONNECTION + IKEV2_TUNNEL_CONFIG_PARAMS* {.pure.} = object + dwIdleTimeout*: DWORD + dwNetworkBlackoutTime*: DWORD + dwSaLifeTime*: DWORD + dwSaDataSizeForRenegotiation*: DWORD + dwConfigOptions*: DWORD + dwTotalCertificates*: DWORD + certificateNames*: ptr CERT_NAME_BLOB + PIKEV2_TUNNEL_CONFIG_PARAMS* = ptr IKEV2_TUNNEL_CONFIG_PARAMS + IKEV2_CONFIG_PARAMS* {.pure.} = object + dwNumPorts*: DWORD + dwPortFlags*: DWORD + dwTunnelConfigParamFlags*: DWORD + TunnelConfigParams*: IKEV2_TUNNEL_CONFIG_PARAMS + PIKEV2_CONFIG_PARAMS* = ptr IKEV2_CONFIG_PARAMS + PPTP_CONFIG_PARAMS* {.pure.} = object + dwNumPorts*: DWORD + dwPortFlags*: DWORD + PPPTP_CONFIG_PARAMS* = ptr PPTP_CONFIG_PARAMS + L2TP_CONFIG_PARAMS* {.pure.} = object + dwNumPorts*: DWORD + dwPortFlags*: DWORD + PL2TP_CONFIG_PARAMS* = ptr L2TP_CONFIG_PARAMS + SSTP_CERT_INFO* {.pure.} = object + isDefault*: BOOL + certBlob*: CRYPT_HASH_BLOB + PSSTP_CERT_INFO* = ptr SSTP_CERT_INFO + SSTP_CONFIG_PARAMS* {.pure.} = object + dwNumPorts*: DWORD + dwPortFlags*: DWORD + isUseHttps*: BOOL + certAlgorithm*: DWORD + sstpCertDetails*: SSTP_CERT_INFO + PSSTP_CONFIG_PARAMS* = ptr SSTP_CONFIG_PARAMS + MPRAPI_TUNNEL_CONFIG_PARAMS* {.pure.} = object + IkeConfigParams*: IKEV2_CONFIG_PARAMS + PptpConfigParams*: PPTP_CONFIG_PARAMS + L2tpConfigParams*: L2TP_CONFIG_PARAMS + SstpConfigParams*: SSTP_CONFIG_PARAMS + PMPRAPI_TUNNEL_CONFIG_PARAMS* = ptr MPRAPI_TUNNEL_CONFIG_PARAMS + MPR_SERVER_SET_CONFIG_EX* {.pure.} = object + Header*: MPRAPI_OBJECT_HEADER + setConfigForProtocols*: DWORD + ConfigParams*: MPRAPI_TUNNEL_CONFIG_PARAMS + PMPR_SERVER_SET_CONFIG_EX* = ptr MPR_SERVER_SET_CONFIG_EX + MPR_SERVER_EX* {.pure.} = object + Header*: MPRAPI_OBJECT_HEADER + fLanOnlyMode*: DWORD + dwUpTime*: DWORD + dwTotalPorts*: DWORD + dwPortsInUse*: DWORD + Reserved*: DWORD + ConfigParams*: MPRAPI_TUNNEL_CONFIG_PARAMS + PMPR_SERVER_EX* = ptr MPR_SERVER_EX + PMPRADMINGETIPADDRESSFORUSER* = proc (P1: ptr WCHAR, P2: ptr WCHAR, P3: ptr DWORD, P4: ptr WINBOOL): DWORD {.stdcall.} + PMPRADMINRELEASEIPADRESS* = proc (P1: ptr WCHAR, P2: ptr WCHAR, P3: ptr DWORD): VOID {.stdcall.} + PMPRADMINGETIPV6ADDRESSFORUSER* = proc (P1: ptr WCHAR, P2: ptr WCHAR, P3: ptr IN6_ADDR, P4: ptr WINBOOL): DWORD {.stdcall.} + PMPRADMINRELEASEIPV6ADDRESSFORUSER* = proc (P1: ptr WCHAR, P2: ptr WCHAR, P3: ptr IN6_ADDR): VOID {.stdcall.} + PMPRADMINACCEPTNEWLINK* = proc (P1: ptr RAS_PORT_0, P2: ptr RAS_PORT_1): WINBOOL {.stdcall.} + PMPRADMINLINKHANGUPNOTIFICATION* = proc (P1: ptr RAS_PORT_0, P2: ptr RAS_PORT_1): VOID {.stdcall.} + PMPRADMINTERMINATEDLL* = proc (): DWORD {.stdcall.} + PMPRADMINACCEPTNEWCONNECTIONEX* = proc (P1: ptr RAS_CONNECTION_EX): BOOL {.stdcall.} + PMPRADMINACCEPTREAUTHENTICATIONEX* = proc (P1: ptr RAS_CONNECTION_EX): BOOL {.stdcall.} + PMPRADMINCONNECTIONHANGUPNOTIFICATIONEX* = proc (P1: ptr RAS_CONNECTION_EX): VOID {.stdcall.} + MPRAPI_ADMIN_DLL_CALLBACKS* {.pure.} = object + revision*: UCHAR + lpfnMprAdminGetIpAddressForUser*: PMPRADMINGETIPADDRESSFORUSER + lpfnMprAdminReleaseIpAddress*: PMPRADMINRELEASEIPADRESS + lpfnMprAdminGetIpv6AddressForUser*: PMPRADMINGETIPV6ADDRESSFORUSER + lpfnMprAdminReleaseIpV6AddressForUser*: PMPRADMINRELEASEIPV6ADDRESSFORUSER + lpfnRasAdminAcceptNewLink*: PMPRADMINACCEPTNEWLINK + lpfnRasAdminLinkHangupNotification*: PMPRADMINLINKHANGUPNOTIFICATION + lpfnRasAdminTerminateDll*: PMPRADMINTERMINATEDLL + lpfnRasAdminAcceptNewConnectionEx*: PMPRADMINACCEPTNEWCONNECTIONEX + lpfnRasAdminAcceptReauthenticationEx*: PMPRADMINACCEPTREAUTHENTICATIONEX + lpfnRasAdminConnectionHangupNotificationEx*: PMPRADMINCONNECTIONHANGUPNOTIFICATIONEX + PMPRAPI_ADMIN_DLL_CALLBACKS* = ptr MPRAPI_ADMIN_DLL_CALLBACKS + SECURITY_MESSAGE* {.pure.} = object + dwMsgId*: DWORD + hPort*: HPORT + dwError*: DWORD + UserName*: array[UNLEN+1, CHAR] + Domain*: array[DNLEN+1, CHAR] + PSECURITY_MESSAGE* = ptr SECURITY_MESSAGE + RAS_SECURITY_INFO* {.pure.} = object + LastError*: DWORD + BytesReceived*: DWORD + DeviceName*: array[MAX_DEVICE_NAME+1, CHAR] + PRAS_SECURITY_INFO* = ptr RAS_SECURITY_INFO +const + freshSoHRequest* = 0x1 + shaFixup* = 0x1 + percentageNotSupported* = 101 + maxSoHAttributeCount* = 100 + maxSoHAttributeSize* = 4000 + minNetworkSoHSize* = 12 + maxNetworkSoHSize* = 4000 + maxDwordCountPerSoHAttribute* = maxSoHAttributeSize/sizeof(DWORD) + maxIpv4CountPerSoHAttribute* = maxSoHAttributeSize/4 + maxIpv6CountPerSoHAttribute* = maxSoHAttributeSize/16 + maxStringLength* = 1024 + maxStringLengthInBytes* = (maxStringLength+1)*sizeof(WCHAR) + maxSystemHealthEntityCount* = 20 + maxEnforcerCount* = 20 + maxPrivateDataSize* = 200 + maxConnectionCountPerEnforcer* = 20 + maxCachedSoHCount* = (maxSystemHealthEntityCount*maxEnforcerCount)*maxConnectionCountPerEnforcer + failureCategoryCount* = 5 + componentTypeEnforcementClientSoH* = 0x1 + componentTypeEnforcementClientRp* = 0x2 + isolationStateNotRestricted* = 1 + isolationStateInProbation* = 2 + isolationStateRestrictedAccess* = 3 + extendedIsolationStateNoData* = 0x0 + extendedIsolationStateTransition* = 0x1 + extendedIsolationStateInfected* = 0x2 + extendedIsolationStateUnknown* = 0x3 + tracingLevelUndefined* = 0 + tracingLevelBasic* = 1 + tracingLevelAdvanced* = 2 + tracingLevelDebug* = 3 + failureCategoryNone* = 0 + failureCategoryOther* = 1 + failureCategoryClientComponent* = 2 + failureCategoryClientCommunication* = 3 + failureCategoryServerComponent* = 4 + failureCategoryServerCommunication* = 5 + fixupStateSuccess* = 0 + fixupStateInProgress* = 1 + fixupStateCouldNotUpdate* = 2 + napNotifyTypeUnknown* = 0 + napNotifyTypeServiceState* = 1 + napNotifyTypeQuarState* = 2 + remoteConfigTypeMachine* = 1 + remoteConfigTypeConfigBlob* = 2 + RASCF_AllUsers* = 0x00000001 + RASCF_GlobalCreds* = 0x00000002 + RASCS_PAUSED* = 0x1000 + RASCS_DONE* = 0x2000 + RASCS_OpenPort* = 0 + RASCS_PortOpened* = 1 + RASCS_ConnectDevice* = 2 + RASCS_DeviceConnected* = 3 + RASCS_AllDevicesConnected* = 4 + RASCS_Authenticate* = 5 + RASCS_AuthNotify* = 6 + RASCS_AuthRetry* = 7 + RASCS_AuthCallback* = 8 + RASCS_AuthChangePassword* = 9 + RASCS_AuthProject* = 10 + RASCS_AuthLinkSpeed* = 11 + RASCS_AuthAck* = 12 + RASCS_ReAuthenticate* = 13 + RASCS_Authenticated* = 14 + RASCS_PrepareForCallback* = 15 + RASCS_WaitForModemReset* = 16 + RASCS_WaitForCallback* = 17 + RASCS_Projected* = 18 + RASCS_StartAuthentication* = 19 + RASCS_CallbackComplete* = 20 + RASCS_LogonNetwork* = 21 + RASCS_SubEntryConnected* = 22 + RASCS_SubEntryDisconnected* = 23 + RASCS_Interactive* = RASCS_PAUSED + RASCS_RetryAuthentication* = RASCS_PAUSED+1 + RASCS_CallbackSetByCaller* = RASCS_PAUSED+2 + RASCS_PasswordExpired* = RASCS_PAUSED+3 + RASCS_InvokeEapUI* = RASCS_PAUSED+4 + RASCS_Connected* = RASCS_DONE + RASCS_Disconnected* = RASCS_DONE+1 + RDEOPT_UsePrefixSuffix* = 0x00000001 + RDEOPT_PausedStates* = 0x00000002 + RDEOPT_IgnoreModemSpeaker* = 0x00000004 + RDEOPT_SetModemSpeaker* = 0x00000008 + RDEOPT_IgnoreSoftwareCompression* = 0x00000010 + RDEOPT_SetSoftwareCompression* = 0x00000020 + RDEOPT_DisableConnectedUI* = 0x00000040 + RDEOPT_DisableReconnectUI* = 0x00000080 + RDEOPT_DisableReconnect* = 0x00000100 + RDEOPT_NoUser* = 0x00000200 + RDEOPT_PauseOnScript* = 0x00000400 + RDEOPT_Router* = 0x00000800 + RDEOPT_CustomDial* = 0x00001000 + RDEOPT_UseCustomScripting* = 0x00002000 + REN_User* = 0x00000000 + REN_AllUsers* = 0x00000001 + RASP_Amb* = 0x10000 + RASP_PppNbf* = 0x803F + RASP_PppIpx* = 0x802B + RASP_PppIp* = 0x8021 + RASP_PppCcp* = 0x80FD + RASP_PppLcp* = 0xC021 + RASP_Slip* = 0x20000 + RASIPO_VJ* = 0x00000001 + RASLCPAP_PAP* = 0xC023 + RASLCPAP_SPAP* = 0xC027 + RASLCPAP_CHAP* = 0xC223 + RASLCPAP_EAP* = 0xC227 + RASLCPAD_CHAP_MD5* = 0x05 + RASLCPAD_CHAP_MS* = 0x80 + RASLCPAD_CHAP_MSV2* = 0x81 + RASLCPO_PFC* = 0x00000001 + RASLCPO_ACFC* = 0x00000002 + RASLCPO_SSHF* = 0x00000004 + RASLCPO_DES_56* = 0x00000008 + RASLCPO_3_DES* = 0x00000010 + RASCCPCA_MPPC* = 0x00000006 + RASCCPCA_STAC* = 0x00000005 + RASCCPO_Compression* = 0x00000001 + RASCCPO_HistoryLess* = 0x00000002 + RASCCPO_Encryption56bit* = 0x00000010 + RASCCPO_Encryption40bit* = 0x00000020 + RASCCPO_Encryption128bit* = 0x00000040 + RASDIALEVENT* = "RasDialEvent" + WM_RASDIALEVENT* = 0xCCCD + ET_None* = 0 + ET_Require* = 1 + ET_RequireMax* = 2 + ET_Optional* = 3 + VS_Default* = 0 + VS_PptpOnly* = 1 + VS_PptpFirst* = 2 + VS_L2tpOnly* = 3 + VS_L2tpFirst* = 4 + RASEO_UseCountryAndAreaCodes* = 0x00000001 + RASEO_SpecificIpAddr* = 0x00000002 + RASEO_SpecificNameServers* = 0x00000004 + RASEO_IpHeaderCompression* = 0x00000008 + RASEO_RemoteDefaultGateway* = 0x00000010 + RASEO_DisableLcpExtensions* = 0x00000020 + RASEO_TerminalBeforeDial* = 0x00000040 + RASEO_TerminalAfterDial* = 0x00000080 + RASEO_ModemLights* = 0x00000100 + RASEO_SwCompression* = 0x00000200 + RASEO_RequireEncryptedPw* = 0x00000400 + RASEO_RequireMsEncryptedPw* = 0x00000800 + RASEO_RequireDataEncryption* = 0x00001000 + RASEO_NetworkLogon* = 0x00002000 + RASEO_UseLogonCredentials* = 0x00004000 + RASEO_PromoteAlternates* = 0x00008000 + RASEO_SecureLocalFiles* = 0x00010000 + RASEO_RequireEAP* = 0x00020000 + RASEO_RequirePAP* = 0x00040000 + RASEO_RequireSPAP* = 0x00080000 + RASEO_Custom* = 0x00100000 + RASEO_PreviewPhoneNumber* = 0x00200000 + RASEO_SharedPhoneNumbers* = 0x00800000 + RASEO_PreviewUserPw* = 0x01000000 + RASEO_PreviewDomain* = 0x02000000 + RASEO_ShowDialingProgress* = 0x04000000 + RASEO_RequireCHAP* = 0x08000000 + RASEO_RequireMsCHAP* = 0x10000000 + RASEO_RequireMsCHAP2* = 0x20000000 + RASEO_RequireW95MSCHAP* = 0x40000000 + RASEO_CustomScript* = 0x80000000'i32 + RASEO2_SecureFileAndPrint* = 0x00000001 + RASEO2_SecureClientForMSNet* = 0x00000002 + RASEO2_DontNegotiateMultilink* = 0x00000004 + RASEO2_DontUseRasCredentials* = 0x00000008 + RASEO2_UsePreSharedKey* = 0x00000010 + RASEO2_Internet* = 0x00000020 + RASEO2_DisableNbtOverIP* = 0x00000040 + RASEO2_UseGlobalDeviceSettings* = 0x00000080 + RASEO2_ReconnectIfDropped* = 0x00000100 + RASEO2_SharePhoneNumbers* = 0x00000200 + RASNP_NetBEUI* = 0x00000001 + RASNP_Ipx* = 0x00000002 + RASNP_Ip* = 0x00000004 + RASFP_Ppp* = 0x00000001 + RASFP_Slip* = 0x00000002 + RASFP_Ras* = 0x00000004 + RASDT_Modem* = "modem" + RASDT_Isdn* = "isdn" + RASDT_X25* = "x25" + RASDT_Vpn* = "vpn" + RASDT_Pad* = "pad" + RASDT_Generic* = "GENERIC" + RASDT_Serial* = "SERIA" + RASDT_FrameRelay* = "FRAMERELAY" + RASDT_Atm* = "ATM" + RASDT_Sonet* = "SONET" + RASDT_SW56* = "SW56" + RASDT_Irda* = "IRDA" + RASDT_Parallel* = "PARALLE" + RASDT_PPPoE* = "PPPoE" + RASET_Phone* = 1 + RASET_Vpn* = 2 + RASET_Direct* = 3 + RASET_Internet* = 4 + RASET_Broadband* = 5 + RASCN_Connection* = 0x00000001 + RASCN_Disconnection* = 0x00000002 + RASCN_BandwidthAdded* = 0x00000004 + RASCN_BandwidthRemoved* = 0x00000008 + RASEDM_DialAll* = 1 + RASEDM_DialAsNeeded* = 2 + RASIDS_Disabled* = 0xffffffff'i32 + RASIDS_UseGlobalValue* = 0 + RASADFLG_PositionDlg* = 0x00000001 + RASCM_UserName* = 0x00000001 + RASCM_Password* = 0x00000002 + RASCM_Domain* = 0x00000004 + RASCM_DefaultCreds* = 0x00000008 + RASCM_PreSharedKey* = 0x00000010 + RASCM_ServerPreSharedKey* = 0x00000020 + RASCM_DDMPreSharedKey* = 0x00000040 + RASADP_DisableConnectionQuery* = 0 + RASADP_LoginSessionDisable* = 1 + RASADP_SavedAddressesLimit* = 2 + RASADP_FailedConnectionTimeout* = 3 + RASADP_ConnectionQueryTimeout* = 4 + RASEAPF_NonInteractive* = 0x00000002 + RASEAPF_Logon* = 0x00000004 + RASEAPF_Preview* = 0x00000008 + RCD_SingleUser* = 0 + RCD_AllUsers* = 0x00000001 + RCD_Eap* = 0x00000002 + RCD_Logon* = 0x00000004 + RASAPIVERSION_500* = 1 + RASAPIVERSION_501* = 2 + RASAPIVERSION_600* = 3 + RASAPIVERSION_601* = 4 + RASPBDEVENT_AddEntry* = 1 + RASPBDEVENT_EditEntry* = 2 + RASPBDEVENT_RemoveEntry* = 3 + RASPBDEVENT_DialEntry* = 4 + RASPBDEVENT_EditGlobals* = 5 + RASPBDEVENT_NoUser* = 6 + RASPBDEVENT_NoUserEdit* = 7 + RASNOUSER_SmartCard* = 0x00000001 + RASPBDFLAG_PositionDlg* = 0x00000001 + RASPBDFLAG_ForceCloseOnDial* = 0x00000002 + RASPBDFLAG_NoUser* = 0x00000010 + RASPBDFLAG_UpdateDefaults* = 0x80000000'i32 + RASEDFLAG_PositionDlg* = 0x00000001 + RASEDFLAG_NewEntry* = 0x00000002 + RASEDFLAG_CloneEntry* = 0x00000004 + RASEDFLAG_NoRename* = 0x00000008 + RASEDFLAG_ShellOwned* = 0x40000000 + RASEDFLAG_NewPhoneEntry* = 0x00000010 + RASEDFLAG_NewTunnelEntry* = 0x00000020 + RASEDFLAG_NewDirectEntry* = 0x00000040 + RASEDFLAG_NewBroadbandEntry* = 0x00000080 + RASEDFLAG_InternetEntry* = 0x00000100 + RASEDFLAG_NAT* = 0x00000200 + RASEDFLAG_IncomingConnection* = 0x00000400 + RASDDFLAG_PositionDlg* = 0x00000001 + RASDDFLAG_NoPrompt* = 0x00000002 + RASDDFLAG_LinkFailure* = 0x80000000'i32 + RAS_EAP_REGISTRY_LOCATION* = "System\\CurrentControlSet\\Services\\Rasman\\PPP\\EAP" + RAS_EAP_VALUENAME_PATH* = "Path" + RAS_EAP_VALUENAME_CONFIGUI* = "ConfigUIPath" + RAS_EAP_VALUENAME_INTERACTIVEUI* = "InteractiveUIPath" + RAS_EAP_VALUENAME_IDENTITY* = "IdentityPath" + RAS_EAP_VALUENAME_FRIENDLY_NAME* = "FriendlyName" + RAS_EAP_VALUENAME_DEFAULT_DATA* = "ConfigData" + RAS_EAP_VALUENAME_REQUIRE_CONFIGUI* = "RequireConfigUI" + RAS_EAP_VALUENAME_ENCRYPTION* = "MPPEEncryptionSupported" + RAS_EAP_VALUENAME_INVOKE_NAMEDLG* = "InvokeUsernameDialog" + RAS_EAP_VALUENAME_INVOKE_PWDDLG* = "InvokePasswordDialog" + RAS_EAP_VALUENAME_CONFIG_CLSID* = "ConfigCLSID" + RAS_EAP_VALUENAME_STANDALONE_SUPPORTED* = "StandaloneSupported" + RAS_EAP_VALUENAME_ROLES_SUPPORTED* = "RolesSupported" + RAS_EAP_VALUENAME_PER_POLICY_CONFIG* = "PerPolicyConfig" + RAS_EAP_VALUENAME_ISTUNNEL_METHOD* = "IsTunnelMethod" + RAS_EAP_VALUENAME_FILTER_INNERMETHODS* = "FilterInnerMethods" + RAS_EAP_ROLE_AUTHENTICATOR* = 0x00000001 + RAS_EAP_ROLE_AUTHENTICATEE* = 0x00000002 + RAS_EAP_ROLE_EXCLUDE_IN_EAP* = 0x00000004 + RAS_EAP_ROLE_EXCLUDE_IN_PEAP* = 0x00000008 + RAS_EAP_ROLE_EXCLUDE_IN_VPN* = 0x00000010 + raatMinimum* = 0 + raatUserName* = 1 + raatUserPassword* = 2 + raatMD5CHAPPassword* = 3 + raatNASIPAddress* = 4 + raatNASPort* = 5 + raatServiceType* = 6 + raatFramedProtocol* = 7 + raatFramedIPAddress* = 8 + raatFramedIPNetmask* = 9 + raatFramedRouting* = 10 + raatFilterId* = 11 + raatFramedMTU* = 12 + raatFramedCompression* = 13 + raatLoginIPHost* = 14 + raatLoginService* = 15 + raatLoginTCPPort* = 16 + raatUnassigned17* = 17 + raatReplyMessage* = 18 + raatCallbackNumber* = 19 + raatCallbackId* = 20 + raatUnassigned21* = 21 + raatFramedRoute* = 22 + raatFramedIPXNetwork* = 23 + raatState* = 24 + raatClass* = 25 + raatVendorSpecific* = 26 + raatSessionTimeout* = 27 + raatIdleTimeout* = 28 + raatTerminationAction* = 29 + raatCalledStationId* = 30 + raatCallingStationId* = 31 + raatNASIdentifier* = 32 + raatProxyState* = 33 + raatLoginLATService* = 34 + raatLoginLATNode* = 35 + raatLoginLATGroup* = 36 + raatFramedAppleTalkLink* = 37 + raatFramedAppleTalkNetwork* = 38 + raatFramedAppleTalkZone* = 39 + raatAcctStatusType* = 40 + raatAcctDelayTime* = 41 + raatAcctInputOctets* = 42 + raatAcctOutputOctets* = 43 + raatAcctSessionId* = 44 + raatAcctAuthentic* = 45 + raatAcctSessionTime* = 46 + raatAcctInputPackets* = 47 + raatAcctOutputPackets* = 48 + raatAcctTerminateCause* = 49 + raatAcctMultiSessionId* = 50 + raatAcctLinkCount* = 51 + raatAcctEventTimeStamp* = 55 + raatMD5CHAPChallenge* = 60 + raatNASPortType* = 61 + raatPortLimit* = 62 + raatLoginLATPort* = 63 + raatTunnelType* = 64 + raatTunnelMediumType* = 65 + raatTunnelClientEndpoint* = 66 + raatTunnelServerEndpoint* = 67 + raatARAPPassword* = 70 + raatARAPFeatures* = 71 + raatARAPZoneAccess* = 72 + raatARAPSecurity* = 73 + raatARAPSecurityData* = 74 + raatPasswordRetry* = 75 + raatPrompt* = 76 + raatConnectInfo* = 77 + raatConfigurationToken* = 78 + raatEAPMessage* = 79 + raatSignature* = 80 + raatARAPChallengeResponse* = 84 + raatAcctInterimInterval* = 85 + raatNASIPv6Address* = 95 + raatFramedInterfaceId* = 96 + raatFramedIPv6Prefix* = 97 + raatLoginIPv6Host* = 98 + raatFramedIPv6Route* = 99 + raatFramedIPv6Pool* = 100 + raatARAPGuestLogon* = 8096 + raatCertificateOID* = 8097 + raatEAPConfiguration* = 8098 + raatPEAPEmbeddedEAPTypeId* = 8099 + raatInnerEAPTypeId* = 8099 + raatPEAPFastRoamedSession* = 8100 + raatFastRoamedSession* = 8100 + raatEAPTLV* = 8102 + raatCredentialsChanged* = 8103 + raatPeerId* = 9000 + raatServerId* = 9001 + raatMethodId* = 9002 + raatEMSK* = 9003 + raatSessionId* = 9004 + raatReserved* = 0xffffffff'i32 + raatARAPChallenge* = 33 + raatARAPOldPassword* = 19 + raatARAPNewPassword* = 20 + raatARAPPasswordChangeReason* = 21 + EAPCODE_Request* = 1 + EAPCODE_Response* = 2 + EAPCODE_Success* = 3 + EAPCODE_Failure* = 4 + MAXEAPCODE* = 4 + RAS_EAP_FLAG_ROUTER* = 0x00000001 + RAS_EAP_FLAG_NON_INTERACTIVE* = 0x00000002 + RAS_EAP_FLAG_LOGON* = 0x00000004 + RAS_EAP_FLAG_PREVIEW* = 0x00000008 + RAS_EAP_FLAG_FIRST_LINK* = 0x00000010 + RAS_EAP_FLAG_MACHINE_AUTH* = 0x00000020 + RAS_EAP_FLAG_GUEST_ACCESS* = 0x00000040 + RAS_EAP_FLAG_8021X_AUTH* = 0x00000080 + RAS_EAP_FLAG_HOSTED_IN_PEAP* = 0x00000100 + RAS_EAP_FLAG_RESUME_FROM_HIBERNATE* = 0x00000200 + RAS_EAP_FLAG_PEAP_UPFRONT* = 0x00000400 + RAS_EAP_FLAG_ALTERNATIVE_USER_DB* = 0x00000800 + RAS_EAP_FLAG_PEAP_FORCE_FULL_AUTH* = 0x00001000 + RAS_EAP_FLAG_PRE_LOGON* = 0x00020000 + RAS_EAP_FLAG_CONFG_READONLY* = 0x00080000 + RAS_EAP_FLAG_RESERVED* = 0x00100000 + RAS_EAP_FLAG_SAVE_CREDMAN* = 0x00200000 + EAPACTION_NoAction* = 0 + EAPACTION_Authenticate* = 1 + EAPACTION_Done* = 2 + EAPACTION_SendAndDone* = 3 + EAPACTION_Send* = 4 + EAPACTION_SendWithTimeout* = 5 + EAPACTION_SendWithTimeoutInteractive* = 6 + EAPACTION_IndicateTLV* = 7 + EAPACTION_IndicateIdentity* = 8 + RASBASE* = 600 + SUCCESS* = 0 + PENDING* = RASBASE+0 + ERROR_INVALID_PORT_HANDLE* = RASBASE+1 + ERROR_PORT_ALREADY_OPEN* = RASBASE+2 + ERROR_BUFFER_TOO_SMALL* = RASBASE+3 + ERROR_WRONG_INFO_SPECIFIED* = RASBASE+4 + ERROR_PORT_NOT_CONNECTED* = RASBASE+6 + ERROR_DEVICE_DOES_NOT_EXIST* = RASBASE+8 + ERROR_DEVICETYPE_DOES_NOT_EXIST* = RASBASE+9 + ERROR_BUFFER_INVALID* = RASBASE+10 + ERROR_ROUTE_NOT_ALLOCATED* = RASBASE+12 + ERROR_PORT_NOT_FOUND* = RASBASE+15 + ERROR_ASYNC_REQUEST_PENDING* = RASBASE+16 + ERROR_ALREADY_DISCONNECTING* = RASBASE+17 + ERROR_PORT_NOT_OPEN* = RASBASE+18 + ERROR_PORT_DISCONNECTED* = RASBASE+19 + ERROR_CANNOT_OPEN_PHONEBOOK* = RASBASE+21 + ERROR_CANNOT_LOAD_PHONEBOOK* = RASBASE+22 + ERROR_CANNOT_FIND_PHONEBOOK_ENTRY* = RASBASE+23 + ERROR_CANNOT_WRITE_PHONEBOOK* = RASBASE+24 + ERROR_CORRUPT_PHONEBOOK* = RASBASE+25 + ERROR_KEY_NOT_FOUND* = RASBASE+27 + ERROR_DISCONNECTION* = RASBASE+28 + ERROR_REMOTE_DISCONNECTION* = RASBASE+29 + ERROR_HARDWARE_FAILURE* = RASBASE+30 + ERROR_USER_DISCONNECTION* = RASBASE+31 + ERROR_INVALID_SIZE* = RASBASE+32 + ERROR_PORT_NOT_AVAILABLE* = RASBASE+33 + ERROR_UNKNOWN* = RASBASE+35 + ERROR_WRONG_DEVICE_ATTACHED* = RASBASE+36 + ERROR_REQUEST_TIMEOUT* = RASBASE+38 + ERROR_AUTH_INTERNAL* = RASBASE+45 + ERROR_RESTRICTED_LOGON_HOURS* = RASBASE+46 + ERROR_ACCT_DISABLED* = RASBASE+47 + ERROR_PASSWD_EXPIRED* = RASBASE+48 + ERROR_NO_DIALIN_PERMISSION* = RASBASE+49 + ERROR_FROM_DEVICE* = RASBASE+51 + ERROR_UNRECOGNIZED_RESPONSE* = RASBASE+52 + ERROR_MACRO_NOT_FOUND* = RASBASE+53 + ERROR_MACRO_NOT_DEFINED* = RASBASE+54 + ERROR_MESSAGE_MACRO_NOT_FOUND* = RASBASE+55 + ERROR_DEFAULTOFF_MACRO_NOT_FOUND* = RASBASE+56 + ERROR_FILE_COULD_NOT_BE_OPENED* = RASBASE+57 + ERROR_DEVICENAME_TOO_LONG* = RASBASE+58 + ERROR_DEVICENAME_NOT_FOUND* = RASBASE+59 + ERROR_NO_RESPONSES* = RASBASE+60 + ERROR_NO_COMMAND_FOUND* = RASBASE+61 + ERROR_WRONG_KEY_SPECIFIED* = RASBASE+62 + ERROR_UNKNOWN_DEVICE_TYPE* = RASBASE+63 + ERROR_ALLOCATING_MEMORY* = RASBASE+64 + ERROR_PORT_NOT_CONFIGURED* = RASBASE+65 + ERROR_DEVICE_NOT_READY* = RASBASE+66 + ERROR_READING_INI_FILE* = RASBASE+67 + ERROR_NO_CONNECTION* = RASBASE+68 + ERROR_BAD_USAGE_IN_INI_FILE* = RASBASE+69 + ERROR_READING_SECTIONNAME* = RASBASE+70 + ERROR_READING_DEVICETYPE* = RASBASE+71 + ERROR_READING_DEVICENAME* = RASBASE+72 + ERROR_READING_USAGE* = RASBASE+73 + ERROR_LINE_BUSY* = RASBASE+76 + ERROR_VOICE_ANSWER* = RASBASE+77 + ERROR_NO_ANSWER* = RASBASE+78 + ERROR_NO_CARRIER* = RASBASE+79 + ERROR_NO_DIALTONE* = RASBASE+80 + ERROR_AUTHENTICATION_FAILURE* = RASBASE+91 + ERROR_PORT_OR_DEVICE* = RASBASE+92 + ERROR_NOT_BINARY_MACRO* = RASBASE+93 + ERROR_DCB_NOT_FOUND* = RASBASE+94 + ERROR_STATE_MACHINES_NOT_STARTED* = RASBASE+95 + ERROR_STATE_MACHINES_ALREADY_STARTED* = RASBASE+96 + ERROR_PARTIAL_RESPONSE_LOOPING* = RASBASE+97 + ERROR_UNKNOWN_RESPONSE_KEY* = RASBASE+98 + ERROR_RECV_BUF_FULL* = RASBASE+99 + ERROR_CMD_TOO_LONG* = RASBASE+100 + ERROR_UNSUPPORTED_BPS* = RASBASE+101 + ERROR_UNEXPECTED_RESPONSE* = RASBASE+102 + ERROR_INTERACTIVE_MODE* = RASBASE+103 + ERROR_BAD_CALLBACK_NUMBER* = RASBASE+104 + ERROR_INVALID_AUTH_STATE* = RASBASE+105 + ERROR_X25_DIAGNOSTIC* = RASBASE+107 + ERROR_ACCT_EXPIRED* = RASBASE+108 + ERROR_CHANGING_PASSWORD* = RASBASE+109 + ERROR_OVERRUN* = RASBASE+110 + ERROR_RASMAN_CANNOT_INITIALIZE* = RASBASE+111 + ERROR_NO_ACTIVE_ISDN_LINES* = RASBASE+113 + ERROR_IP_CONFIGURATION* = RASBASE+116 + ERROR_NO_IP_ADDRESSES* = RASBASE+117 + ERROR_PPP_TIMEOUT* = RASBASE+118 + ERROR_PPP_NO_PROTOCOLS_CONFIGURED* = RASBASE+120 + ERROR_PPP_NO_RESPONSE* = RASBASE+121 + ERROR_PPP_INVALID_PACKET* = RASBASE+122 + ERROR_PHONE_NUMBER_TOO_LONG* = RASBASE+123 + ERROR_IPXCP_DIALOUT_ALREADY_ACTIVE* = RASBASE+126 + ERROR_NO_IP_RAS_ADAPTER* = RASBASE+128 + ERROR_SLIP_REQUIRES_IP* = RASBASE+129 + ERROR_PROTOCOL_NOT_CONFIGURED* = RASBASE+131 + ERROR_PPP_NOT_CONVERGING* = RASBASE+132 + ERROR_PPP_CP_REJECTED* = RASBASE+133 + ERROR_PPP_LCP_TERMINATED* = RASBASE+134 + ERROR_PPP_REQUIRED_ADDRESS_REJECTED* = RASBASE+135 + ERROR_PPP_NCP_TERMINATED* = RASBASE+136 + ERROR_PPP_LOOPBACK_DETECTED* = RASBASE+137 + ERROR_PPP_NO_ADDRESS_ASSIGNED* = RASBASE+138 + ERROR_CANNOT_USE_LOGON_CREDENTIALS* = RASBASE+139 + ERROR_TAPI_CONFIGURATION* = RASBASE+140 + ERROR_NO_LOCAL_ENCRYPTION* = RASBASE+141 + ERROR_NO_REMOTE_ENCRYPTION* = RASBASE+142 + ERROR_BAD_PHONE_NUMBER* = RASBASE+149 + ERROR_SCRIPT_SYNTAX* = RASBASE+152 + ERROR_HANGUP_FAILED* = RASBASE+153 + ERROR_BUNDLE_NOT_FOUND* = RASBASE+154 + ERROR_CANNOT_DO_CUSTOMDIAL* = RASBASE+155 + ERROR_DIAL_ALREADY_IN_PROGRESS* = RASBASE+156 + ERROR_RASAUTO_CANNOT_INITIALIZE* = RASBASE+157 + ERROR_NO_SMART_CARD_READER* = RASBASE+164 + ERROR_SHARING_ADDRESS_EXISTS* = RASBASE+165 + ERROR_NO_CERTIFICATE* = RASBASE+166 + ERROR_SHARING_MULTIPLE_ADDRESSES* = RASBASE+167 + ERROR_FAILED_TO_ENCRYPT* = RASBASE+168 + ERROR_BAD_ADDRESS_SPECIFIED* = RASBASE+169 + ERROR_CONNECTION_REJECT* = RASBASE+170 + ERROR_CONGESTION* = RASBASE+171 + ERROR_INCOMPATIBLE* = RASBASE+172 + ERROR_NUMBERCHANGED* = RASBASE+173 + ERROR_TEMPFAILURE* = RASBASE+174 + ERROR_BLOCKED* = RASBASE+175 + ERROR_DONOTDISTURB* = RASBASE+176 + ERROR_OUTOFORDER* = RASBASE+177 + ERROR_UNABLE_TO_AUTHENTICATE_SERVER* = RASBASE+178 + ERROR_INVALID_FUNCTION_FOR_ENTRY* = RASBASE+180 + ERROR_SHARING_RRAS_CONFLICT* = RASBASE+182 + ERROR_SHARING_NO_PRIVATE_LAN* = RASBASE+183 + ERROR_NO_DIFF_USER_AT_LOGON* = RASBASE+184 + ERROR_NO_REG_CERT_AT_LOGON* = RASBASE+185 + ERROR_OAKLEY_NO_CERT* = RASBASE+186 + ERROR_OAKLEY_AUTH_FAIL* = RASBASE+187 + ERROR_OAKLEY_ATTRIB_FAIL* = RASBASE+188 + ERROR_OAKLEY_GENERAL_PROCESSING* = RASBASE+189 + ERROR_OAKLEY_NO_PEER_CERT* = RASBASE+190 + ERROR_OAKLEY_NO_POLICY* = RASBASE+191 + ERROR_OAKLEY_TIMED_OUT* = RASBASE+192 + ERROR_OAKLEY_ERROR* = RASBASE+193 + ERROR_UNKNOWN_FRAMED_PROTOCOL* = RASBASE+194 + ERROR_WRONG_TUNNEL_TYPE* = RASBASE+195 + ERROR_UNKNOWN_SERVICE_TYPE* = RASBASE+196 + ERROR_CONNECTING_DEVICE_NOT_FOUND* = RASBASE+197 + ERROR_NO_EAPTLS_CERTIFICATE* = RASBASE+198 + ERROR_SHARING_HOST_ADDRESS_CONFLICT* = RASBASE+199 + ERROR_AUTOMATIC_VPN_FAILED* = RASBASE+200 + ERROR_VALIDATING_SERVER_CERT* = RASBASE+201 + ERROR_READING_SCARD* = RASBASE+202 + ERROR_INVALID_PEAP_COOKIE_CONFIG* = RASBASE+203 + ERROR_INVALID_PEAP_COOKIE_USER* = RASBASE+204 + ERROR_INVALID_MSCHAPV2_CONFIG* = RASBASE+205 + ERROR_VPN_GRE_BLOCKED* = RASBASE+206 + ERROR_VPN_DISCONNECT* = RASBASE+207 + ERROR_VPN_REFUSED* = RASBASE+208 + ERROR_VPN_TIMEOUT* = RASBASE+209 + ERROR_VPN_BAD_CERT* = RASBASE+210 + ERROR_VPN_BAD_PSK* = RASBASE+211 + ERROR_SERVER_POLICY* = RASBASE+212 + ERROR_BROADBAND_ACTIVE* = RASBASE+213 + ERROR_BROADBAND_NO_NIC* = RASBASE+214 + ERROR_BROADBAND_TIMEOUT* = RASBASE+215 + ERROR_FEATURE_DEPRECATED* = RASBASE+216 + ERROR_CANNOT_DELETE* = RASBASE+217 + ERROR_PEAP_CRYPTOBINDING_INVALID* = RASBASE+223 + ERROR_PEAP_CRYPTOBINDING_NOTRECEIVED* = RASBASE+224 + ERROR_EAPTLS_CACHE_CREDENTIALS_INVALID* = RASBASE+226 + ERROR_IPSEC_SERVICE_STOPPED* = RASBASE+227 + ERROR_CANNOT_SET_PORT_INFO* = RASBASE+5 + ERROR_EVENT_INVALID* = RASBASE+7 + ERROR_ROUTE_NOT_AVAILABLE* = RASBASE+11 + ERROR_INVALID_COMPRESSION_SPECIFIED* = RASBASE+13 + ERROR_OUT_OF_BUFFERS* = RASBASE+14 + ERROR_NO_ENDPOINTS* = RASBASE+20 + ERROR_CANNOT_LOAD_STRING* = RASBASE+26 + ERROR_CANNOT_PROJECT_CLIENT* = RASBASE+34 + ERROR_BAD_STRING* = RASBASE+37 + ERROR_CANNOT_GET_LANA* = RASBASE+39 + ERROR_NETBIOS_ERROR* = RASBASE+40 + ERROR_SERVER_OUT_OF_RESOURCES* = RASBASE+41 + ERROR_NAME_EXISTS_ON_NET* = RASBASE+42 + ERROR_SERVER_GENERAL_NET_FAILURE* = RASBASE+43 + WARNING_MSG_ALIAS_NOT_ADDED* = RASBASE+44 + ERROR_SERVER_NOT_RESPONDING* = RASBASE+50 + ERROR_READING_MAXCONNECTBPS* = RASBASE+74 + ERROR_READING_MAXCARRIERBPS* = RASBASE+75 + ERROR_IN_COMMAND* = RASBASE+81 + ERROR_WRITING_SECTIONNAME* = RASBASE+82 + ERROR_WRITING_DEVICETYPE* = RASBASE+83 + ERROR_WRITING_DEVICENAME* = RASBASE+84 + ERROR_WRITING_MAXCONNECTBPS* = RASBASE+85 + ERROR_WRITING_MAXCARRIERBPS* = RASBASE+86 + ERROR_WRITING_USAGE* = RASBASE+87 + ERROR_WRITING_DEFAULTOFF* = RASBASE+88 + ERROR_READING_DEFAULTOFF* = RASBASE+89 + ERROR_EMPTY_INI_FILE* = RASBASE+90 + ERROR_WRITING_INITBPS* = RASBASE+106 + ERROR_BIPLEX_PORT_NOT_AVAILABLE* = RASBASE+112 + ERROR_NO_ISDN_CHANNELS_AVAILABLE* = RASBASE+114 + ERROR_TOO_MANY_LINE_ERRORS* = RASBASE+115 + ERROR_PPP_REMOTE_TERMINATED* = RASBASE+119 + ERROR_IPXCP_NO_DIALOUT_CONFIGURED* = RASBASE+124 + ERROR_IPXCP_NO_DIALIN_CONFIGURED* = RASBASE+125 + ERROR_ACCESSING_TCPCFGDLL* = RASBASE+127 + ERROR_PROJECTION_NOT_COMPLETE* = RASBASE+130 + ERROR_REMOTE_REQUIRES_ENCRYPTION* = RASBASE+143 + ERROR_IPXCP_NET_NUMBER_CONFLICT* = RASBASE+144 + ERROR_INVALID_SMM* = RASBASE+145 + ERROR_SMM_UNINITIALIZED* = RASBASE+146 + ERROR_NO_MAC_FOR_PORT* = RASBASE+147 + ERROR_SMM_TIMEOUT* = RASBASE+148 + ERROR_WRONG_MODULE* = RASBASE+150 + ERROR_INVALID_CALLBACK_NUMBER* = RASBASE+151 + ERROR_CONNECTION_ALREADY_SHARED* = RASBASE+158 + ERROR_SHARING_CHANGE_FAILED* = RASBASE+159 + ERROR_SHARING_ROUTER_INSTALL* = RASBASE+160 + ERROR_SHARE_CONNECTION_FAILED* = RASBASE+161 + ERROR_SHARING_PRIVATE_INSTALL* = RASBASE+162 + ERROR_CANNOT_SHARE_CONNECTION* = RASBASE+163 + ERROR_SMART_CARD_REQUIRED* = RASBASE+179 + ERROR_CERT_FOR_ENCRYPTION_NOT_FOUND* = RASBASE+181 + ERROR_RASQEC_RESOURCE_CREATION_FAILED* = RASBASE+218 + ERROR_RASQEC_NAPAGENT_NOT_ENABLED* = RASBASE+219 + ERROR_RASQEC_NAPAGENT_NOT_CONNECTED* = RASBASE+220 + ERROR_RASQEC_CONN_DOESNOTEXIST* = RASBASE+221 + ERROR_RASQEC_TIMEOUT* = RASBASE+222 + ERROR_INVALID_VPNSTRATEGY* = RASBASE+225 + ERROR_IDLE_TIMEOUT* = RASBASE+228 + ERROR_LINK_FAILURE* = RASBASE+229 + ERROR_USER_LOGOFF* = RASBASE+230 + ERROR_FAST_USER_SWITCH* = RASBASE+231 + ERROR_HIBERNATION* = RASBASE+232 + ERROR_SYSTEM_SUSPENDED* = RASBASE+233 + ERROR_RASMAN_SERVICE_STOPPED* = RASBASE+234 + ERROR_INVALID_SERVER_CERT* = RASBASE+235 + ERROR_NOT_NAP_CAPABLE* = RASBASE+236 + ERROR_INVALID_TUNNELID* = RASBASE+237 + ERROR_UPDATECONNECTION_REQUEST_IN_PROCESS* = RASBASE+238 + ERROR_PROTOCOL_ENGINE_DISABLED* = RASBASE+239 + ERROR_INTERNAL_ADDRESS_FAILURE* = RASBASE+240 + ERROR_FAILED_CP_REQUIRED* = RASBASE+241 + ERROR_TS_UNACCEPTABLE* = RASBASE+242 + ERROR_MOBIKE_DISABLED* = RASBASE+243 + ERROR_CANNOT_INITIATE_MOBIKE_UPDATE* = RASBASE+244 + ERROR_PEAP_SERVER_REJECTED_CLIENT_TLV* = RASBASE+245 + ERROR_INVALID_PREFERENCES* = RASBASE+246 + ERROR_EAPTLS_SCARD_CACHE_CREDENTIALS_INVALID* = RASBASE+247 + ERROR_SSTP_COOKIE_SET_FAILURE* = RASBASE+248 + ERROR_INVALID_PEAP_COOKIE_ATTRIBUTES* = RASBASE+249 + ERROR_EAP_METHOD_NOT_INSTALLED* = RASBASE+250 + ERROR_EAP_METHOD_DOES_NOT_SUPPORT_SSO* = RASBASE+251 + ERROR_EAP_METHOD_OPERATION_NOT_SUPPORTED* = RASBASE+252 + ERROR_EAP_USER_CERT_INVALID* = RASBASE+253 + ERROR_EAP_USER_CERT_EXPIRED* = RASBASE+254 + ERROR_EAP_USER_CERT_REVOKED* = RASBASE+255 + ERROR_EAP_USER_CERT_OTHER_ERROR* = RASBASE+256 + ERROR_EAP_SERVER_CERT_INVALID* = RASBASE+257 + ERROR_EAP_SERVER_CERT_EXPIRED* = RASBASE+258 + ERROR_EAP_SERVER_CERT_REVOKED* = RASBASE+259 + ERROR_EAP_SERVER_CERT_OTHER_ERROR* = RASBASE+260 + ERROR_EAP_USER_ROOT_CERT_NOT_FOUND* = RASBASE+261 + ERROR_EAP_USER_ROOT_CERT_INVALID* = RASBASE+262 + ERROR_EAP_USER_ROOT_CERT_EXPIRED* = RASBASE+263 + ERROR_EAP_SERVER_ROOT_CERT_NOT_FOUND* = RASBASE+264 + ERROR_EAP_SERVER_ROOT_CERT_INVALID* = RASBASE+265 + ERROR_EAP_SERVER_ROOT_CERT_NAME_REQUIRED* = RASBASE+266 + ERROR_PEAP_IDENTITY_MISMATCH* = RASBASE+267 + ERROR_DNSNAME_NOT_RESOLVABLE* = RASBASE+268 + ERROR_EAPTLS_PASSWD_INVALID* = RASBASE+269 + ERROR_IKEV2_PSK_INTERFACE_ALREADY_EXISTS* = RASBASE+270 + RASBASEEND* = RASBASE+270 + RASSAPI_MAX_PHONENUMBER_SIZE* = 128 + RASSAPI_MAX_MEDIA_NAME* = 16 + RASSAPI_MAX_PORT_NAME* = 16 + RASSAPI_MAX_DEVICE_NAME* = 128 + RASSAPI_MAX_DEVICETYPE_NAME* = 16 + RASSAPI_MAX_PARAM_KEY_SIZE* = 32 + RASPRIV_NoCallback* = 0x01 + RASPRIV_AdminSetCallback* = 0x02 + RASPRIV_CallerSetCallback* = 0x04 + RASPRIV_DialinPrivilege* = 0x08 + RASPRIV_CallbackType* = RASPRIV_AdminSetCallback or RASPRIV_CallerSetCallback or RASPRIV_NoCallback + RAS_MODEM_OPERATIONAL* = 1 + RAS_MODEM_NOT_RESPONDING* = 2 + RAS_MODEM_HARDWARE_FAILURE* = 3 + RAS_MODEM_INCORRECT_RESPONSE* = 4 + RAS_MODEM_UNKNOWN* = 5 + paramNumber* = 0 + paramString* = 1 + MEDIA_UNKNOWN* = 0 + MEDIA_SERIAL* = 1 + MEDIA_RAS10_SERIAL* = 2 + MEDIA_X25* = 3 + MEDIA_ISDN* = 4 + USER_AUTHENTICATED* = 0x0001 + MESSENGER_PRESENT* = 0x0002 + PPP_CLIENT* = 0x0004 + GATEWAY_ACTIVE* = 0x0008 + REMOTE_LISTEN* = 0x0010 + PORT_MULTILINKED* = 0x0020 + RAS_IPADDRESSLEN* = 15 + RAS_IPXADDRESSLEN* = 22 + RAS_ATADDRESSLEN* = 32 + RASDOWNLEVEL* = 10 + RASADMIN_35* = 35 + RASADMIN_CURRENT* = 40 + RRAS_SERVICE_NAME* = "RemoteAccess" + PID_IPX* = 0x0000002B + PID_IP* = 0x00000021 + PID_NBF* = 0x0000003F + PID_ATALK* = 0x00000029 + ROUTER_IF_TYPE_CLIENT* = 0 + ROUTER_IF_TYPE_HOME_ROUTER* = 1 + ROUTER_IF_TYPE_FULL_ROUTER* = 2 + ROUTER_IF_TYPE_DEDICATED* = 3 + ROUTER_IF_TYPE_INTERNAL* = 4 + ROUTER_IF_TYPE_LOOPBACK* = 5 + ROUTER_IF_TYPE_TUNNEL1* = 6 + ROUTER_IF_TYPE_DIALOUT* = 7 + ROUTER_IF_STATE_UNREACHABLE* = 0 + ROUTER_IF_STATE_DISCONNECTED* = 1 + ROUTER_IF_STATE_CONNECTING* = 2 + ROUTER_IF_STATE_CONNECTED* = 3 + MPR_INTERFACE_OUT_OF_RESOURCES* = 0x00000001 + MPR_INTERFACE_ADMIN_DISABLED* = 0x00000002 + MPR_INTERFACE_CONNECTION_FAILURE* = 0x00000004 + MPR_INTERFACE_SERVICE_PAUSED* = 0x00000008 + MPR_INTERFACE_DIALOUT_HOURS_RESTRICTION* = 0x00000010 + MPR_INTERFACE_NO_MEDIA_SENSE* = 0x00000020 + MPR_INTERFACE_NO_DEVICE* = 0x00000040 + MPR_MaxIpAddress* = RAS_MaxIpAddress + MPR_MaxIpxAddress* = RAS_MaxIpxAddress + MPR_MaxEntryName* = RAS_MaxEntryName + MPR_MaxCallbackNumber* = RAS_MaxCallbackNumber + MPR_MaxAreaCode* = RAS_MaxAreaCode + MPRIO_SpecificIpAddr* = RASEO_SpecificIpAddr + MPRIO_SpecificNameServers* = RASEO_SpecificNameServers + MPRIO_IpHeaderCompression* = RASEO_IpHeaderCompression + MPRIO_RemoteDefaultGateway* = RASEO_RemoteDefaultGateway + MPRIO_DisableLcpExtensions* = RASEO_DisableLcpExtensions + MPRIO_SwCompression* = RASEO_SwCompression + MPRIO_RequireEncryptedPw* = RASEO_RequireEncryptedPw + MPRIO_RequireMsEncryptedPw* = RASEO_RequireMsEncryptedPw + MPRIO_RequireDataEncryption* = RASEO_RequireDataEncryption + MPRIO_NetworkLogon* = RASEO_NetworkLogon + MPRIO_PromoteAlternates* = RASEO_PromoteAlternates + MPRIO_SecureLocalFiles* = RASEO_SecureLocalFiles + MPRIO_RequireEAP* = RASEO_RequireEAP + MPRIO_RequirePAP* = RASEO_RequirePAP + MPRIO_RequireSPAP* = RASEO_RequireSPAP + MPRIO_SharedPhoneNumbers* = RASEO_SharedPhoneNumbers + MPRIO_RequireCHAP* = RASEO_RequireCHAP + MPRIO_RequireMsCHAP* = RASEO_RequireMsCHAP + MPRIO_RequireMsCHAP2* = RASEO_RequireMsCHAP2 + MPRIO_IpSecPreSharedKey* = 0x80000000'i32 + MPRNP_Ipx* = RASNP_Ipx + MPRNP_Ip* = RASNP_Ip + MPRDT_Modem* = RASDT_Modem + MPRDT_Isdn* = RASDT_Isdn + MPRDT_X25* = RASDT_X25 + MPRDT_Vpn* = RASDT_Vpn + MPRDT_Pad* = RASDT_Pad + MPRDT_Generic* = RASDT_Generic + MPRDT_Serial* = RASDT_Serial + MPRDT_FrameRelay* = RASDT_FrameRelay + MPRDT_Atm* = RASDT_Atm + MPRDT_Sonet* = RASDT_Sonet + MPRDT_SW56* = RASDT_SW56 + MPRDT_Irda* = RASDT_Irda + MPRDT_Parallel* = RASDT_Parallel + MPRET_Phone* = RASET_Phone + MPRET_Vpn* = RASET_Vpn + MPRET_Direct* = RASET_Direct + MPRDM_DialFirst* = 0 + MPRDM_DialAll* = RASEDM_DialAll + MPRDM_DialAsNeeded* = RASEDM_DialAsNeeded + MPRIDS_Disabled* = RASIDS_Disabled + MPRIDS_UseGlobalValue* = RASIDS_UseGlobalValue + MPR_ET_None* = ET_None + MPR_ET_Require* = ET_Require + MPR_ET_RequireMax* = ET_RequireMax + MPR_ET_Optional* = ET_Optional + MPR_VS_Default* = VS_Default + MPR_VS_PptpOnly* = VS_PptpOnly + MPR_VS_PptpFirst* = VS_PptpFirst + MPR_VS_L2tpOnly* = VS_L2tpOnly + MPR_VS_L2tpFirst* = VS_L2tpFirst + MPR_ENABLE_RAS_ON_DEVICE* = 0x00000001 + MPR_ENABLE_ROUTING_ON_DEVICE* = 0x00000002 + RAS_PORT_NON_OPERATIONAL* = 0 + RAS_PORT_DISCONNECTED* = 1 + RAS_PORT_CALLING_BACK* = 2 + RAS_PORT_LISTENING* = 3 + RAS_PORT_AUTHENTICATING* = 4 + RAS_PORT_AUTHENTICATED* = 5 + RAS_PORT_INITIALIZING* = 6 + RAS_HARDWARE_OPERATIONAL* = 0 + RAS_HARDWARE_FAILURE* = 1 + PPP_IPCP_VJ* = 0x00000001 + PPP_CCP_COMPRESSION* = 0x00000001 + PPP_CCP_ENCRYPTION40BITOLD* = 0x00000010 + PPP_CCP_ENCRYPTION40BIT* = 0x00000020 + PPP_CCP_ENCRYPTION128BIT* = 0x00000040 + PPP_CCP_ENCRYPTION56BIT* = 0x00000080 + PPP_CCP_HISTORYLESS* = 0x01000000 + PPP_LCP_PAP* = 0xC023 + PPP_LCP_SPAP* = 0xC027 + PPP_LCP_CHAP* = 0xC223 + PPP_LCP_EAP* = 0xC227 + PPP_LCP_CHAP_MD5* = 0x05 + PPP_LCP_CHAP_MS* = 0x80 + PPP_LCP_CHAP_MSV2* = 0x81 + PPP_LCP_MULTILINK_FRAMING* = 0x00000001 + PPP_LCP_PFC* = 0x00000002 + PPP_LCP_ACFC* = 0x00000004 + PPP_LCP_SSHF* = 0x00000008 + PPP_LCP_DES_56* = 0x00000010 + PPP_LCP_3_DES* = 0x00000020 + RAS_FLAGS_PPP_CONNECTION* = 0x00000001 + RAS_FLAGS_MESSENGER_PRESENT* = 0x00000002 + RAS_FLAGS_QUARANTINE_PRESENT* = 0x00000008 + RASPRIV2_DialinPolicy* = 0x1 + RAS_QUAR_STATE_NORMAL* = 0 + RAS_QUAR_STATE_QUARANTINE* = 1 + RAS_QUAR_STATE_PROBATION* = 2 + RAS_QUAR_STATE_NOT_CAPABLE* = 3 + MPRAPI_RAS_CONNECTION_OBJECT_REVISION_1* = 0x01 + MPRAPI_MPR_SERVER_OBJECT_REVISION_1* = 0x01 + MPRAPI_MPR_SERVER_SET_CONFIG_OBJECT_REVISION_1* = 0x01 + MPRAPI_OBJECT_TYPE_RAS_CONNECTION_OBJECT* = 0x1 + MPRAPI_OBJECT_TYPE_MPR_SERVER_OBJECT* = 0x2 + MPRAPI_OBJECT_TYPE_MPR_SERVER_SET_CONFIG_OBJECT* = 0x3 + MPRAPI_OBJECT_TYPE_AUTH_VALIDATION_OBJECT* = 0x4 + MPRAPI_OBJECT_TYPE_UPDATE_CONNECTION_OBJECT* = 0x5 + RAS_FLAGS_ARAP_CONNECTION* = 0x00000010 + RAS_FLAGS_IKEV2_CONNECTION* = 0x00000010 + RAS_FLAGS_DORMANT* = 0x00000020 + MPRAPI_IKEV2_SET_TUNNEL_CONFIG_PARAMS* = 0x01 + SECURITYMSG_SUCCESS* = 1 + SECURITYMSG_FAILURE* = 2 + SECURITYMSG_ERROR* = 3 + PPP_EAP_PACKET_HDR_LEN* = 4 +type + RASDIALFUNC* = proc (P1: UINT, P2: RASCONNSTATE, P3: DWORD): VOID {.stdcall.} + RASDIALFUNC1* = proc (P1: HRASCONN, P2: UINT, P3: RASCONNSTATE, P4: DWORD, P5: DWORD): VOID {.stdcall.} + RASDIALFUNC2* = proc (P1: ULONG_PTR, P2: DWORD, P3: HRASCONN, P4: UINT, P5: RASCONNSTATE, P6: DWORD, P7: DWORD): DWORD {.stdcall.} + ORASADFUNC* = proc (P1: HWND, P2: LPSTR, P3: DWORD, P4: LPDWORD): WINBOOL {.stdcall.} + RASADFUNCA* = proc (P1: LPSTR, P2: LPSTR, P3: LPRASADPARAMS, P4: LPDWORD): WINBOOL {.stdcall.} + RASADFUNCW* = proc (P1: LPWSTR, P2: LPWSTR, P3: LPRASADPARAMS, P4: LPDWORD): WINBOOL {.stdcall.} + PFNRASGETBUFFER* = proc (ppBuffer: ptr PBYTE, pdwSize: PDWORD): DWORD {.stdcall.} + PFNRASFREEBUFFER* = proc (pBufer: PBYTE): DWORD {.stdcall.} + PFNRASSENDBUFFER* = proc (hPort: HANDLE, pBuffer: PBYTE, dwSize: DWORD): DWORD {.stdcall.} + PFNRASRECEIVEBUFFER* = proc (hPort: HANDLE, pBuffer: PBYTE, pdwSize: PDWORD, dwTimeOut: DWORD, hEvent: HANDLE): DWORD {.stdcall.} + PFNRASRETRIEVEBUFFER* = proc (hPort: HANDLE, pBuffer: PBYTE, pdwSize: PDWORD): DWORD {.stdcall.} + RasCustomScriptExecuteFn* = proc (hPort: HANDLE, lpszPhonebook: LPCWSTR, lpszEntryName: LPCWSTR, pfnRasGetBuffer: PFNRASGETBUFFER, pfnRasFreeBuffer: PFNRASFREEBUFFER, pfnRasSendBuffer: PFNRASSENDBUFFER, pfnRasReceiveBuffer: PFNRASRECEIVEBUFFER, pfnRasRetrieveBuffer: PFNRASRETRIEVEBUFFER, hWnd: HWND, pRasDialParams: ptr RASDIALPARAMS, pvReserved: PVOID): DWORD {.stdcall.} + RASCOMMSETTINGS* {.pure.} = object + dwSize*: DWORD + bParity*: BYTE + bStop*: BYTE + bByteSize*: BYTE + bAlign*: BYTE + PFNRASSETCOMMSETTINGS* = proc (hPort: HANDLE, pRasCommSettings: ptr RASCOMMSETTINGS, pvReserved: PVOID): DWORD {.stdcall.} + RasCustomHangUpFn* = proc (hRasConn: HRASCONN): DWORD {.stdcall.} + RasCustomDialFn* = proc (hInstDll: HINSTANCE, lpRasDialExtensions: LPRASDIALEXTENSIONS, lpszPhonebook: LPCWSTR, lpRasDialParams: LPRASDIALPARAMS, dwNotifierType: DWORD, lpvNotifier: LPVOID, lphRasConn: LPHRASCONN, dwFlags: DWORD): DWORD {.stdcall.} + RasCustomDeleteEntryNotifyFn* = proc (lpszPhonebook: LPCWSTR, lpszEntry: LPCWSTR, dwFlags: DWORD): DWORD {.stdcall.} + RasCustomDialDlgFn* = proc (hInstDll: HINSTANCE, dwFlags: DWORD, lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpszPhoneNumber: LPWSTR, lpInfo: LPRASDIALDLG, pvInfo: PVOID): WINBOOL {.stdcall.} + RasCustomEntryDlgFn* = proc (hInstDll: HINSTANCE, lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpInfo: LPRASENTRYDLG, dwFlags: DWORD): WINBOOL {.stdcall.} + RASSECURITYPROC* = proc (): DWORD {.stdcall.} + IsolationInfo* {.pure.} = object + isolationState*: IsolationState + probEndTime*: ProbationTime + failureUrl*: CountedString + IsolationInfoEx* {.pure.} = object + isolationState*: IsolationState + extendedIsolationState*: ExtendedIsolationState + probEndTime*: ProbationTime + failureUrl*: CountedString + FailureCategoryMapping* {.pure.} = object + mappingCompliance*: array[5, WINBOOL] + CorrelationId* {.pure.} = object + connId*: GUID + timeStamp*: FILETIME + ResultCodes* {.pure.} = object + count*: UINT16 + results*: ptr HRESULT + Ipv4Address* {.pure.} = object + `addr`*: array[4, BYTE] + Ipv6Address* {.pure.} = object + `addr`*: array[16, BYTE] + FixupInfo* {.pure.} = object + state*: FixupState + percentage*: Percentage + resultCodes*: ResultCodes + fixupMsgId*: MessageId + SystemHealthAgentState* {.pure.} = object + id*: SystemHealthEntityId + shaResultCodes*: ResultCodes + failureCategory*: FailureCategory + fixupInfo*: FixupInfo + PrivateData* {.pure.} = object + size*: UINT16 + data*: ptr BYTE + NapComponentRegistrationInfo* {.pure.} = object + id*: NapComponentId + friendlyName*: CountedString + description*: CountedString + version*: CountedString + vendorName*: CountedString + infoClsid*: CLSID + configClsid*: CLSID + registrationDate*: FILETIME + componentType*: UINT32 + RASCUSTOMSCRIPTEXTENSIONS* {.pure, packed.} = object + dwSize*: DWORD + pfnRasSetCommSettings*: PFNRASSETCOMMSETTINGS + LEGACY_IDENTITY_UI_PARAMS* {.pure.} = object + eapType*: DWORD + dwFlags*: DWORD + dwSizeofConnectionData*: DWORD + pConnectionData*: ptr BYTE + dwSizeofUserData*: DWORD + pUserData*: ptr BYTE + dwSizeofUserDataOut*: DWORD + pUserDataOut*: ptr BYTE + pwszIdentity*: LPWSTR + dwError*: DWORD + LEGACY_INTERACTIVE_UI_PARAMS* {.pure.} = object + eapType*: DWORD + dwSizeofContextData*: DWORD + pContextData*: ptr BYTE + dwSizeofInteractiveUIData*: DWORD + pInteractiveUIData*: ptr BYTE + dwError*: DWORD + RAS_PARAMS_VALUE_String* {.pure.} = object + Length*: DWORD + Data*: PCHAR + RAS_PARAMS_VALUE* {.pure, union.} = object + Number*: DWORD + String*: RAS_PARAMS_VALUE_String + RAS_PARAMETERS* {.pure.} = object + P_Key*: array[RASSAPI_MAX_PARAM_KEY_SIZE, CHAR] + P_Type*: RAS_PARAMS_FORMAT + P_Attributes*: BYTE + P_Value*: RAS_PARAMS_VALUE + RAS_PPP_NBFCP_RESULT* {.pure.} = object + dwError*: DWORD + dwNetBiosError*: DWORD + szName*: array[NETBIOS_NAME_LEN + 1, CHAR] + wszWksta*: array[NETBIOS_NAME_LEN + 1, WCHAR] + RAS_PPP_IPCP_RESULT* {.pure.} = object + dwError*: DWORD + wszAddress*: array[RAS_IPADDRESSLEN + 1, WCHAR] + RAS_PPP_IPXCP_RESULT* {.pure.} = object + dwError*: DWORD + wszAddress*: array[RAS_IPXADDRESSLEN + 1, WCHAR] + RAS_PPP_ATCP_RESULT* {.pure.} = object + dwError*: DWORD + wszAddress*: array[RAS_ATADDRESSLEN + 1, WCHAR] + RAS_PPP_PROJECTION_RESULT* {.pure.} = object + nbf*: RAS_PPP_NBFCP_RESULT + ip*: RAS_PPP_IPCP_RESULT + ipx*: RAS_PPP_IPXCP_RESULT + at*: RAS_PPP_ATCP_RESULT +proc RasDialA*(P1: LPRASDIALEXTENSIONS, P2: LPCSTR, P3: LPRASDIALPARAMSA, P4: DWORD, P5: LPVOID, P6: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasDialW*(P1: LPRASDIALEXTENSIONS, P2: LPCWSTR, P3: LPRASDIALPARAMSW, P4: DWORD, P5: LPVOID, P6: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumConnectionsA*(P1: LPRASCONNA, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumConnectionsW*(P1: LPRASCONNW, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumEntriesA*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYNAMEA, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumEntriesW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYNAMEW, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetConnectStatusA*(P1: HRASCONN, P2: LPRASCONNSTATUSA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetConnectStatusW*(P1: HRASCONN, P2: LPRASCONNSTATUSW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetErrorStringA*(P1: UINT, P2: LPSTR, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetErrorStringW*(P1: UINT, P2: LPWSTR, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasHangUpA*(P1: HRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasHangUpW*(P1: HRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetProjectionInfoA*(P1: HRASCONN, P2: RASPROJECTION, P3: LPVOID, P4: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetProjectionInfoW*(P1: HRASCONN, P2: RASPROJECTION, P3: LPVOID, P4: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasCreatePhonebookEntryA*(P1: HWND, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasCreatePhonebookEntryW*(P1: HWND, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEditPhonebookEntryA*(P1: HWND, P2: LPCSTR, P3: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEditPhonebookEntryW*(P1: HWND, P2: LPCWSTR, P3: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEntryDialParamsA*(P1: LPCSTR, P2: LPRASDIALPARAMSA, P3: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEntryDialParamsW*(P1: LPCWSTR, P2: LPRASDIALPARAMSW, P3: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEntryDialParamsA*(P1: LPCSTR, P2: LPRASDIALPARAMSA, P3: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEntryDialParamsW*(P1: LPCWSTR, P2: LPRASDIALPARAMSW, P3: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumDevicesA*(P1: LPRASDEVINFOA, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumDevicesW*(P1: LPRASDEVINFOW, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCountryInfoA*(P1: LPRASCTRYINFOA, P2: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCountryInfoW*(P1: LPRASCTRYINFOW, P2: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEntryPropertiesA*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYA, P4: LPDWORD, P5: LPBYTE, P6: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEntryPropertiesW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYW, P4: LPDWORD, P5: LPBYTE, P6: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEntryPropertiesA*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYA, P4: DWORD, P5: LPBYTE, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEntryPropertiesW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYW, P4: DWORD, P5: LPBYTE, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasRenameEntryA*(P1: LPCSTR, P2: LPCSTR, P3: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasRenameEntryW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasDeleteEntryA*(P1: LPCSTR, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasDeleteEntryW*(P1: LPCWSTR, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasValidateEntryNameA*(P1: LPCSTR, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasValidateEntryNameW*(P1: LPCWSTR, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasConnectionNotificationA*(P1: HRASCONN, P2: HANDLE, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasConnectionNotificationW*(P1: HRASCONN, P2: HANDLE, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetSubEntryHandleA*(P1: HRASCONN, P2: DWORD, P3: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetSubEntryHandleW*(P1: HRASCONN, P2: DWORD, P3: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCredentialsA*(P1: LPCSTR, P2: LPCSTR, P3: LPRASCREDENTIALSA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCredentialsW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASCREDENTIALSW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetCredentialsA*(P1: LPCSTR, P2: LPCSTR, P3: LPRASCREDENTIALSA, P4: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetCredentialsW*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASCREDENTIALSW, P4: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetSubEntryPropertiesA*(P1: LPCSTR, P2: LPCSTR, P3: DWORD, P4: LPRASSUBENTRYA, P5: LPDWORD, P6: LPBYTE, P7: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetSubEntryPropertiesW*(P1: LPCWSTR, P2: LPCWSTR, P3: DWORD, P4: LPRASSUBENTRYW, P5: LPDWORD, P6: LPBYTE, P7: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetSubEntryPropertiesA*(P1: LPCSTR, P2: LPCSTR, P3: DWORD, P4: LPRASSUBENTRYA, P5: DWORD, P6: LPBYTE, P7: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetSubEntryPropertiesW*(P1: LPCWSTR, P2: LPCWSTR, P3: DWORD, P4: LPRASSUBENTRYW, P5: DWORD, P6: LPBYTE, P7: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialAddressA*(P1: LPCSTR, P2: LPDWORD, P3: LPRASAUTODIALENTRYA, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialAddressW*(P1: LPCWSTR, P2: LPDWORD, P3: LPRASAUTODIALENTRYW, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialAddressA*(P1: LPCSTR, P2: DWORD, P3: LPRASAUTODIALENTRYA, P4: DWORD, P5: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialAddressW*(P1: LPCWSTR, P2: DWORD, P3: LPRASAUTODIALENTRYW, P4: DWORD, P5: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumAutodialAddressesA*(P1: ptr LPSTR, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasEnumAutodialAddressesW*(P1: ptr LPWSTR, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialEnableA*(P1: DWORD, P2: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialEnableW*(P1: DWORD, P2: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialEnableA*(P1: DWORD, P2: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialEnableW*(P1: DWORD, P2: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialParamA*(P1: DWORD, P2: LPVOID, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetAutodialParamW*(P1: DWORD, P2: LPVOID, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialParamA*(P1: DWORD, P2: LPVOID, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetAutodialParamW*(P1: DWORD, P2: LPVOID, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasInvokeEapUI*(P1: HRASCONN, P2: DWORD, P3: LPRASDIALEXTENSIONS, P4: HWND): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetLinkStatistics*(hRasConn: HRASCONN, dwSubEntry: DWORD, lpStatistics: ptr RAS_STATS): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetConnectionStatistics*(hRasConn: HRASCONN, lpStatistics: ptr RAS_STATS): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasClearLinkStatistics*(hRasConn: HRASCONN, dwSubEntry: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasClearConnectionStatistics*(hRasConn: HRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEapUserDataA*(hToken: HANDLE, pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbEapData: ptr BYTE, pdwSizeofEapData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEapUserDataW*(hToken: HANDLE, pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbEapData: ptr BYTE, pdwSizeofEapData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEapUserDataA*(hToken: HANDLE, pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbEapData: ptr BYTE, dwSizeofEapData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetEapUserDataW*(hToken: HANDLE, pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbEapData: ptr BYTE, dwSizeofEapData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCustomAuthDataA*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbCustomAuthData: ptr BYTE, pdwSizeofCustomAuthData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetCustomAuthDataW*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbCustomAuthData: ptr BYTE, pdwSizeofCustomAuthData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetCustomAuthDataA*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbCustomAuthData: ptr BYTE, dwSizeofCustomAuthData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasSetCustomAuthDataW*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbCustomAuthData: ptr BYTE, dwSizeofCustomAuthData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEapUserIdentityW*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, dwFlags: DWORD, hwnd: HWND, ppRasEapUserIdentity: ptr LPRASEAPUSERIDENTITYW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasGetEapUserIdentityA*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, dwFlags: DWORD, hwnd: HWND, ppRasEapUserIdentity: ptr LPRASEAPUSERIDENTITYA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasFreeEapUserIdentityW*(pRasEapUserIdentity: LPRASEAPUSERIDENTITYW): VOID {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasFreeEapUserIdentityA*(pRasEapUserIdentity: LPRASEAPUSERIDENTITYA): VOID {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasDeleteSubEntryA*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, dwSubentryId: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasDeleteSubEntryW*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, dwSubEntryId: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc.} +proc RasPhonebookDlgA*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpInfo: LPRASPBDLGA): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc RasPhonebookDlgW*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpInfo: LPRASPBDLGW): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc RasEntryDlgA*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpInfo: LPRASENTRYDLGA): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc RasEntryDlgW*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpInfo: LPRASENTRYDLGW): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc RasDialDlgA*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpszPhoneNumber: LPSTR, lpInfo: LPRASDIALDLG): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc RasDialDlgW*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpszPhoneNumber: LPWSTR, lpInfo: LPRASDIALDLG): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc.} +proc MprAdminConnectionEnum*(hRasServer: RAS_SERVER_HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminPortEnum*(hRasServer: RAS_SERVER_HANDLE, dwLevel: DWORD, hConnection: HANDLE, lplpbBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminConnectionGetInfo*(hRasServer: RAS_SERVER_HANDLE, dwLevel: DWORD, hConnection: HANDLE, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminPortGetInfo*(hRasServer: RAS_SERVER_HANDLE, dwLevel: DWORD, hPort: HANDLE, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminConnectionClearStats*(hRasServer: RAS_SERVER_HANDLE, hConnection: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminPortClearStats*(hRasServer: RAS_SERVER_HANDLE, hPort: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminPortReset*(hRasServer: RAS_SERVER_HANDLE, hPort: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminPortDisconnect*(hRasServer: RAS_SERVER_HANDLE, hPort: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminConnectionRemoveQuarantine*(hRasServer: HANDLE, hRasConnection: HANDLE, fIsIpAddress: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminUserGetInfo*(lpszServer: ptr WCHAR, lpszUser: ptr WCHAR, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminUserSetInfo*(lpszServer: ptr WCHAR, lpszUser: ptr WCHAR, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminSendUserMessage*(hMprServer: MPR_SERVER_HANDLE, hConnection: HANDLE, lpwszMessage: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminGetPDCServer*(lpszDomain: ptr WCHAR, lpszServer: ptr WCHAR, lpszPDCServer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminIsServiceRunning*(lpwsServerName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerConnect*(lpwsServerName: LPWSTR, phMprServer: ptr MPR_SERVER_HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerDisconnect*(hMprServer: MPR_SERVER_HANDLE): VOID {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerGetCredentials*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerSetCredentials*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminBufferFree*(pBuffer: LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminGetErrorString*(dwError: DWORD, lpwsErrorString: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerGetInfo*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminServerSetInfo*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminEstablishDomainRasServer*(pszDomain: PWCHAR, pszMachine: PWCHAR, bEnable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminIsDomainRasServer*(pszDomain: PWCHAR, pszMachine: PWCHAR, pbIsRasServer: PBOOL): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminTransportCreate*(hMprServer: MPR_SERVER_HANDLE, dwTransportId: DWORD, lpwsTransportName: LPWSTR, pGlobalInfo: LPBYTE, dwGlobalInfoSize: DWORD, pClientInterfaceInfo: LPBYTE, dwClientInterfaceInfoSize: DWORD, lpwsDLLPath: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminTransportSetInfo*(hMprServer: MPR_SERVER_HANDLE, dwTransportId: DWORD, pGlobalInfo: LPBYTE, dwGlobalInfoSize: DWORD, pClientInterfaceInfo: LPBYTE, dwClientInterfaceInfoSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminTransportGetInfo*(hMprServer: MPR_SERVER_HANDLE, dwTransportId: DWORD, ppGlobalInfo: ptr LPBYTE, lpdwGlobalInfoSize: LPDWORD, ppClientInterfaceInfo: ptr LPBYTE, lpdwClientInterfaceInfoSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminDeviceEnum*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE, lpdwTotalEntries: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceGetHandle*(hMprServer: MPR_SERVER_HANDLE, lpwsInterfaceName: LPWSTR, phInterface: ptr HANDLE, fIncludeClientInterfaces: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceCreate*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE, phInterface: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceGetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceSetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceDelete*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceDeviceGetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwIndex: DWORD, dwLevel: DWORD, lplpBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceDeviceSetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwIndex: DWORD, dwLevel: DWORD, lplpBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceTransportRemove*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwTransportId: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceTransportAdd*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwTransportId: DWORD, pInterfaceInfo: LPBYTE, dwInterfaceInfoSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceTransportGetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwTransportId: DWORD, ppInterfaceInfo: ptr LPBYTE, lpdwpInterfaceInfoSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceTransportSetInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwTransportId: DWORD, pInterfaceInfo: LPBYTE, dwInterfaceInfoSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceEnum*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceSetCredentials*(lpwsServer: LPWSTR, lpwsInterfaceName: LPWSTR, lpwsUserName: LPWSTR, lpwsDomainName: LPWSTR, lpwsPassword: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceGetCredentials*(lpwsServer: LPWSTR, lpwsInterfaceName: LPWSTR, lpwsUserName: LPWSTR, lpwsPassword: LPWSTR, lpwsDomainName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceSetCredentialsEx*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceGetCredentialsEx*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceConnect*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, hEvent: HANDLE, fSynchronous: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceDisconnect*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceUpdateRoutes*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwProtocolId: DWORD, hEvent: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceQueryUpdateResult*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE, dwProtocolId: DWORD, lpdwUpdateResult: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminInterfaceUpdatePhonebookInfo*(hMprServer: MPR_SERVER_HANDLE, hInterface: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminRegisterConnectionNotification*(hMprServer: MPR_SERVER_HANDLE, hEventNotification: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminDeregisterConnectionNotification*(hMprServer: MPR_SERVER_HANDLE, hEventNotification: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBServerConnect*(lpwsServerName: LPWSTR, phMibServer: ptr MIB_SERVER_HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBServerDisconnect*(hMibServer: MIB_SERVER_HANDLE): VOID {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntryCreate*(hMibServer: MIB_SERVER_HANDLE, dwPid: DWORD, dwRoutingPid: DWORD, lpEntry: LPVOID, dwEntrySize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntryDelete*(hMibServer: MIB_SERVER_HANDLE, dwProtocolId: DWORD, dwRoutingPid: DWORD, lpEntry: LPVOID, dwEntrySize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntrySet*(hMibServer: MIB_SERVER_HANDLE, dwProtocolId: DWORD, dwRoutingPid: DWORD, lpEntry: LPVOID, dwEntrySize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntryGet*(hMibServer: MIB_SERVER_HANDLE, dwProtocolId: DWORD, dwRoutingPid: DWORD, lpInEntry: LPVOID, dwInEntrySize: DWORD, lplpOutEntry: ptr LPVOID, lpOutEntrySize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntryGetFirst*(hMibServer: MIB_SERVER_HANDLE, dwProtocolId: DWORD, dwRoutingPid: DWORD, lpInEntry: LPVOID, dwInEntrySize: DWORD, lplpOutEntry: ptr LPVOID, lpOutEntrySize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBEntryGetNext*(hMibServer: MIB_SERVER_HANDLE, dwProtocolId: DWORD, dwRoutingPid: DWORD, lpInEntry: LPVOID, dwInEntrySize: DWORD, lplpOutEntry: ptr LPVOID, lpOutEntrySize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprAdminMIBBufferFree*(pBuffer: LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerInstall*(dwLevel: DWORD, pBuffer: PVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerConnect*(lpwsServerName: LPWSTR, phMprConfig: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerDisconnect*(hMprConfig: HANDLE): VOID {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerRefresh*(hMprConfig: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigBufferFree*(pBuffer: LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerGetInfo*(hMprConfig: HANDLE, dwLevel: DWORD, lplpbBuffer: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerSetInfo*(hMprServer: MPR_SERVER_HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerBackup*(hMprConfig: HANDLE, lpwsPath: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigServerRestore*(hMprConfig: HANDLE, lpwsPath: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportCreate*(hMprConfig: HANDLE, dwTransportId: DWORD, lpwsTransportName: LPWSTR, pGlobalInfo: LPBYTE, dwGlobalInfoSize: DWORD, pClientInterfaceInfo: LPBYTE, dwClientInterfaceInfoSize: DWORD, lpwsDLLPath: LPWSTR, phRouterTransport: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportDelete*(hMprConfig: HANDLE, hRouterTransport: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportGetHandle*(hMprConfig: HANDLE, dwTransportId: DWORD, phRouterTransport: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportSetInfo*(hMprConfig: HANDLE, hRouterTransport: HANDLE, pGlobalInfo: LPBYTE, dwGlobalInfoSize: DWORD, pClientInterfaceInfo: LPBYTE, dwClientInterfaceInfoSize: DWORD, lpwsDLLPath: LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportGetInfo*(hMprConfig: HANDLE, hRouterTransport: HANDLE, ppGlobalInfo: ptr LPBYTE, lpdwGlobalInfoSize: LPDWORD, ppClientInterfaceInfo: ptr LPBYTE, lpdwClientInterfaceInfoSize: LPDWORD, lplpwsDLLPath: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigTransportEnum*(hMprConfig: HANDLE, dwLevel: DWORD, lplpBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceCreate*(hMprConfig: HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE, phRouterInterface: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceDelete*(hMprConfig: HANDLE, hRouterInterface: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceGetHandle*(hMprConfig: HANDLE, lpwsInterfaceName: LPWSTR, phRouterInterface: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceGetInfo*(hMprConfig: HANDLE, hRouterInterface: HANDLE, dwLevel: DWORD, lplpBuffer: ptr LPBYTE, lpdwBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceSetInfo*(hMprConfig: HANDLE, hRouterInterface: HANDLE, dwLevel: DWORD, lpbBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceEnum*(hMprConfig: HANDLE, dwLevel: DWORD, lplpBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportAdd*(hMprConfig: HANDLE, hRouterInterface: HANDLE, dwTransportId: DWORD, lpwsTransportName: LPWSTR, pInterfaceInfo: LPBYTE, dwInterfaceInfoSize: DWORD, phRouterIfTransport: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportRemove*(hMprConfig: HANDLE, hRouterInterface: HANDLE, hRouterIfTransport: HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportGetHandle*(hMprConfig: HANDLE, hRouterInterface: HANDLE, dwTransportId: DWORD, phRouterIfTransport: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportGetInfo*(hMprConfig: HANDLE, hRouterInterface: HANDLE, hRouterIfTransport: HANDLE, ppInterfaceInfo: ptr LPBYTE, lpdwInterfaceInfoSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportSetInfo*(hMprConfig: HANDLE, hRouterInterface: HANDLE, hRouterIfTransport: HANDLE, pInterfaceInfo: LPBYTE, dwInterfaceInfoSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigInterfaceTransportEnum*(hMprConfig: HANDLE, hRouterInterface: HANDLE, dwLevel: DWORD, lplpBuffer: ptr LPBYTE, dwPrefMaxLen: DWORD, lpdwEntriesRead: LPDWORD, lpdwTotalEntries: LPDWORD, lpdwResumeHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigGetFriendlyName*(hMprConfig: HANDLE, pszGuidName: PWCHAR, pszBuffer: PWCHAR, dwBufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigGetGuidName*(hMprConfig: HANDLE, pszFriendlyName: PWCHAR, pszBuffer: PWCHAR, dwBufferSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoCreate*(dwVersion: DWORD, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoDelete*(lpHeader: LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoRemoveAll*(lpHeader: LPVOID, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoDuplicate*(lpHeader: LPVOID, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoBlockAdd*(lpHeader: LPVOID, dwInfoType: DWORD, dwItemSize: DWORD, dwItemCount: DWORD, lpItemData: LPBYTE, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoBlockRemove*(lpHeader: LPVOID, dwInfoType: DWORD, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoBlockSet*(lpHeader: LPVOID, dwInfoType: DWORD, dwItemSize: DWORD, dwItemCount: DWORD, lpItemData: LPBYTE, lplpNewHeader: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoBlockFind*(lpHeader: LPVOID, dwInfoType: DWORD, lpdwItemSize: LPDWORD, lpdwItemCount: LPDWORD, lplpItemData: ptr LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprInfoBlockQuerySize*(lpHeader: LPVOID): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigFilterGetInfo*(hMprConfig: HANDLE, dwLevel: DWORD, dwTransportId: DWORD, lpBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc MprConfigFilterSetInfo*(hMprConfig: HANDLE, dwLevel: DWORD, dwTransportId: DWORD, lpBuffer: LPBYTE): DWORD {.winapi, stdcall, dynlib: "mprapi", importc.} +proc RasSecurityDialogSend*(hPort: HPORT, pBuffer: PBYTE, BufferLength: WORD): DWORD {.winapi, stdcall, dynlib: "rasman", importc.} +proc RasSecurityDialogReceive*(hPort: HPORT, pBuffer: PBYTE, pBufferLength: PWORD, Timeout: DWORD, hEvent: HANDLE): DWORD {.winapi, stdcall, dynlib: "rasman", importc.} +proc RasSecurityDialogGetInfo*(hPort: HPORT, pBuffer: ptr RAS_SECURITY_INFO): DWORD {.winapi, stdcall, dynlib: "rasman", importc.} +proc `ipv4=`*(self: var RASTUNNELENDPOINT, x: RASIPV4ADDR) {.inline.} = self.union1.ipv4 = x +proc ipv4*(self: RASTUNNELENDPOINT): RASIPV4ADDR {.inline.} = self.union1.ipv4 +proc ipv4*(self: var RASTUNNELENDPOINT): var RASIPV4ADDR {.inline.} = self.union1.ipv4 +proc `ipv6=`*(self: var RASTUNNELENDPOINT, x: RASIPV6ADDR) {.inline.} = self.union1.ipv6 = x +proc ipv6*(self: RASTUNNELENDPOINT): RASIPV6ADDR {.inline.} = self.union1.ipv6 +proc ipv6*(self: var RASTUNNELENDPOINT): var RASIPV6ADDR {.inline.} = self.union1.ipv6 +proc `Ikev2ProjectionInfo=`*(self: var PROJECTION_INFO, x: IKEV2_PROJECTION_INFO) {.inline.} = self.union1.Ikev2ProjectionInfo = x +proc ikev2ProjectionInfo*(self: PROJECTION_INFO): IKEV2_PROJECTION_INFO {.inline.} = self.union1.Ikev2ProjectionInfo +proc ikev2ProjectionInfo*(self: var PROJECTION_INFO): var IKEV2_PROJECTION_INFO {.inline.} = self.union1.Ikev2ProjectionInfo +proc `PppProjectionInfo=`*(self: var PROJECTION_INFO, x: PPP_PROJECTION_INFO) {.inline.} = self.union1.PppProjectionInfo = x +proc pppProjectionInfo*(self: PROJECTION_INFO): PPP_PROJECTION_INFO {.inline.} = self.union1.PppProjectionInfo +proc pppProjectionInfo*(self: var PROJECTION_INFO): var PPP_PROJECTION_INFO {.inline.} = self.union1.PppProjectionInfo +when winimUnicode: + type + RASADFUNC* = RASADFUNCW + RASEAPUSERIDENTITY* = RASEAPUSERIDENTITYW + RASPBDLGFUNC* = RASPBDLGFUNCW + proc RasDial*(P1: LPRASDIALEXTENSIONS, P2: LPCWSTR, P3: LPRASDIALPARAMSW, P4: DWORD, P5: LPVOID, P6: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDialW".} + proc RasEnumConnections*(P1: LPRASCONNW, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumConnectionsW".} + proc RasEnumEntries*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYNAMEW, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumEntriesW".} + proc RasGetConnectStatus*(P1: HRASCONN, P2: LPRASCONNSTATUSW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetConnectStatusW".} + proc RasGetErrorString*(P1: UINT, P2: LPWSTR, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetErrorStringW".} + proc RasHangUp*(P1: HRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasHangUpW".} + proc RasGetProjectionInfo*(P1: HRASCONN, P2: RASPROJECTION, P3: LPVOID, P4: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetProjectionInfoW".} + proc RasCreatePhonebookEntry*(P1: HWND, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasCreatePhonebookEntryW".} + proc RasEditPhonebookEntry*(P1: HWND, P2: LPCWSTR, P3: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEditPhonebookEntryW".} + proc RasSetEntryDialParams*(P1: LPCWSTR, P2: LPRASDIALPARAMSW, P3: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEntryDialParamsW".} + proc RasGetEntryDialParams*(P1: LPCWSTR, P2: LPRASDIALPARAMSW, P3: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEntryDialParamsW".} + proc RasEnumDevices*(P1: LPRASDEVINFOW, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumDevicesW".} + proc RasGetCountryInfo*(P1: LPRASCTRYINFOW, P2: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCountryInfoW".} + proc RasGetEntryProperties*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYW, P4: LPDWORD, P5: LPBYTE, P6: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEntryPropertiesW".} + proc RasSetEntryProperties*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASENTRYW, P4: DWORD, P5: LPBYTE, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEntryPropertiesW".} + proc RasRenameEntry*(P1: LPCWSTR, P2: LPCWSTR, P3: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasRenameEntryW".} + proc RasDeleteEntry*(P1: LPCWSTR, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDeleteEntryW".} + proc RasValidateEntryName*(P1: LPCWSTR, P2: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasValidateEntryNameW".} + proc RasGetSubEntryHandle*(P1: HRASCONN, P2: DWORD, P3: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetSubEntryHandleW".} + proc RasConnectionNotification*(P1: HRASCONN, P2: HANDLE, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasConnectionNotificationW".} + proc RasGetSubEntryProperties*(P1: LPCWSTR, P2: LPCWSTR, P3: DWORD, P4: LPRASSUBENTRYW, P5: LPDWORD, P6: LPBYTE, P7: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetSubEntryPropertiesW".} + proc RasSetSubEntryProperties*(P1: LPCWSTR, P2: LPCWSTR, P3: DWORD, P4: LPRASSUBENTRYW, P5: DWORD, P6: LPBYTE, P7: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetSubEntryPropertiesW".} + proc RasGetCredentials*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASCREDENTIALSW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCredentialsW".} + proc RasSetCredentials*(P1: LPCWSTR, P2: LPCWSTR, P3: LPRASCREDENTIALSW, P4: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetCredentialsW".} + proc RasGetAutodialAddress*(P1: LPCWSTR, P2: LPDWORD, P3: LPRASAUTODIALENTRYW, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialAddressW".} + proc RasSetAutodialAddress*(P1: LPCWSTR, P2: DWORD, P3: LPRASAUTODIALENTRYW, P4: DWORD, P5: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialAddressW".} + proc RasEnumAutodialAddresses*(P1: ptr LPWSTR, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumAutodialAddressesW".} + proc RasGetAutodialEnable*(P1: DWORD, P2: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialEnableW".} + proc RasSetAutodialEnable*(P1: DWORD, P2: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialEnableW".} + proc RasGetAutodialParam*(P1: DWORD, P2: LPVOID, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialParamW".} + proc RasSetAutodialParam*(P1: DWORD, P2: LPVOID, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialParamW".} + proc RasGetEapUserData*(hToken: HANDLE, pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbEapData: ptr BYTE, pdwSizeofEapData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEapUserDataW".} + proc RasSetEapUserData*(hToken: HANDLE, pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbEapData: ptr BYTE, dwSizeofEapData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEapUserDataW".} + proc RasGetCustomAuthData*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbCustomAuthData: ptr BYTE, pdwSizeofCustomAuthData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCustomAuthDataW".} + proc RasSetCustomAuthData*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, pbCustomAuthData: ptr BYTE, dwSizeofCustomAuthData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetCustomAuthDataW".} + proc RasGetEapUserIdentity*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, dwFlags: DWORD, hwnd: HWND, ppRasEapUserIdentity: ptr LPRASEAPUSERIDENTITYW): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEapUserIdentityW".} + proc RasFreeEapUserIdentity*(pRasEapUserIdentity: LPRASEAPUSERIDENTITYW): VOID {.winapi, stdcall, dynlib: "rasapi32", importc: "RasFreeEapUserIdentityW".} + proc RasDeleteSubEntry*(pszPhonebook: LPCWSTR, pszEntry: LPCWSTR, dwSubEntryId: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDeleteSubEntryW".} + proc RasPhonebookDlg*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpInfo: LPRASPBDLGW): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasPhonebookDlgW".} + proc RasEntryDlg*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpInfo: LPRASENTRYDLGW): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasEntryDlgW".} + proc RasDialDlg*(lpszPhonebook: LPWSTR, lpszEntry: LPWSTR, lpszPhoneNumber: LPWSTR, lpInfo: LPRASDIALDLG): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasDialDlgW".} +when winimAnsi: + type + RASADFUNC* = RASADFUNCA + RASEAPUSERIDENTITY* = RASEAPUSERIDENTITYA + RASPBDLGFUNC* = RASPBDLGFUNCA + proc RasDial*(P1: LPRASDIALEXTENSIONS, P2: LPCSTR, P3: LPRASDIALPARAMSA, P4: DWORD, P5: LPVOID, P6: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDialA".} + proc RasEnumConnections*(P1: LPRASCONNA, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumConnectionsA".} + proc RasEnumEntries*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYNAMEA, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumEntriesA".} + proc RasGetConnectStatus*(P1: HRASCONN, P2: LPRASCONNSTATUSA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetConnectStatusA".} + proc RasGetErrorString*(P1: UINT, P2: LPSTR, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetErrorStringA".} + proc RasHangUp*(P1: HRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasHangUpA".} + proc RasGetProjectionInfo*(P1: HRASCONN, P2: RASPROJECTION, P3: LPVOID, P4: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetProjectionInfoA".} + proc RasCreatePhonebookEntry*(P1: HWND, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasCreatePhonebookEntryA".} + proc RasEditPhonebookEntry*(P1: HWND, P2: LPCSTR, P3: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEditPhonebookEntryA".} + proc RasSetEntryDialParams*(P1: LPCSTR, P2: LPRASDIALPARAMSA, P3: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEntryDialParamsA".} + proc RasGetEntryDialParams*(P1: LPCSTR, P2: LPRASDIALPARAMSA, P3: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEntryDialParamsA".} + proc RasEnumDevices*(P1: LPRASDEVINFOA, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumDevicesA".} + proc RasGetCountryInfo*(P1: LPRASCTRYINFOA, P2: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCountryInfoA".} + proc RasGetEntryProperties*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYA, P4: LPDWORD, P5: LPBYTE, P6: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEntryPropertiesA".} + proc RasSetEntryProperties*(P1: LPCSTR, P2: LPCSTR, P3: LPRASENTRYA, P4: DWORD, P5: LPBYTE, P6: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEntryPropertiesA".} + proc RasRenameEntry*(P1: LPCSTR, P2: LPCSTR, P3: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasRenameEntryA".} + proc RasDeleteEntry*(P1: LPCSTR, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDeleteEntryA".} + proc RasValidateEntryName*(P1: LPCSTR, P2: LPCSTR): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasValidateEntryNameA".} + proc RasGetSubEntryHandle*(P1: HRASCONN, P2: DWORD, P3: LPHRASCONN): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetSubEntryHandleA".} + proc RasConnectionNotification*(P1: HRASCONN, P2: HANDLE, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasConnectionNotificationA".} + proc RasGetSubEntryProperties*(P1: LPCSTR, P2: LPCSTR, P3: DWORD, P4: LPRASSUBENTRYA, P5: LPDWORD, P6: LPBYTE, P7: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetSubEntryPropertiesA".} + proc RasSetSubEntryProperties*(P1: LPCSTR, P2: LPCSTR, P3: DWORD, P4: LPRASSUBENTRYA, P5: DWORD, P6: LPBYTE, P7: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetSubEntryPropertiesA".} + proc RasGetCredentials*(P1: LPCSTR, P2: LPCSTR, P3: LPRASCREDENTIALSA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCredentialsA".} + proc RasSetCredentials*(P1: LPCSTR, P2: LPCSTR, P3: LPRASCREDENTIALSA, P4: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetCredentialsA".} + proc RasGetAutodialAddress*(P1: LPCSTR, P2: LPDWORD, P3: LPRASAUTODIALENTRYA, P4: LPDWORD, P5: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialAddressA".} + proc RasSetAutodialAddress*(P1: LPCSTR, P2: DWORD, P3: LPRASAUTODIALENTRYA, P4: DWORD, P5: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialAddressA".} + proc RasEnumAutodialAddresses*(P1: ptr LPSTR, P2: LPDWORD, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasEnumAutodialAddressesA".} + proc RasGetAutodialEnable*(P1: DWORD, P2: LPBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialEnableA".} + proc RasSetAutodialEnable*(P1: DWORD, P2: WINBOOL): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialEnableA".} + proc RasGetAutodialParam*(P1: DWORD, P2: LPVOID, P3: LPDWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetAutodialParamA".} + proc RasSetAutodialParam*(P1: DWORD, P2: LPVOID, P3: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetAutodialParamA".} + proc RasGetEapUserData*(hToken: HANDLE, pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbEapData: ptr BYTE, pdwSizeofEapData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEapUserDataA".} + proc RasSetEapUserData*(hToken: HANDLE, pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbEapData: ptr BYTE, dwSizeofEapData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetEapUserDataA".} + proc RasGetCustomAuthData*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbCustomAuthData: ptr BYTE, pdwSizeofCustomAuthData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetCustomAuthDataA".} + proc RasSetCustomAuthData*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, pbCustomAuthData: ptr BYTE, dwSizeofCustomAuthData: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasSetCustomAuthDataA".} + proc RasGetEapUserIdentity*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, dwFlags: DWORD, hwnd: HWND, ppRasEapUserIdentity: ptr LPRASEAPUSERIDENTITYA): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasGetEapUserIdentityA".} + proc RasFreeEapUserIdentity*(pRasEapUserIdentity: LPRASEAPUSERIDENTITYA): VOID {.winapi, stdcall, dynlib: "rasapi32", importc: "RasFreeEapUserIdentityA".} + proc RasDeleteSubEntry*(pszPhonebook: LPCSTR, pszEntry: LPCSTR, dwSubentryId: DWORD): DWORD {.winapi, stdcall, dynlib: "rasapi32", importc: "RasDeleteSubEntryA".} + proc RasPhonebookDlg*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpInfo: LPRASPBDLGA): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasPhonebookDlgA".} + proc RasEntryDlg*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpInfo: LPRASENTRYDLGA): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasEntryDlgA".} + proc RasDialDlg*(lpszPhonebook: LPSTR, lpszEntry: LPSTR, lpszPhoneNumber: LPSTR, lpInfo: LPRASDIALDLG): WINBOOL {.winapi, stdcall, dynlib: "rasdlg", importc: "RasDialDlgA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/regstr.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/regstr.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,943 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import windef +#include +type + DSKTLSYSTEMTIME* {.pure.} = object + wYear*: WORD + wMonth*: WORD + wDayOfWeek*: WORD + wDay*: WORD + wHour*: WORD + wMinute*: WORD + wSecond*: WORD + wMilliseconds*: WORD + wResult*: WORD + PDSKTLSYSTEMTIME* = ptr DSKTLSYSTEMTIME + LPDSKTLSYSTEMTIME* = ptr DSKTLSYSTEMTIME +const + REGSTR_KEY_CLASS* = "Class" + REGSTR_KEY_CONFIG* = "Config" + REGSTR_KEY_ENUM* = "Enum" + REGSTR_KEY_ROOTENUM* = "Root" + REGSTR_KEY_BIOSENUM* = "BIOS" + REGSTR_KEY_ACPIENUM* = "ACPI" + REGSTR_KEY_PCMCIAENUM* = "PCMCIA" + REGSTR_KEY_PCIENUM* = "PCI" + REGSTR_KEY_VPOWERDENUM* = "VPOWERD" + REGSTR_KEY_ISAENUM* = "ISAPnP" + REGSTR_KEY_EISAENUM* = "EISA" + REGSTR_KEY_LOGCONFIG* = "LogConfig" + REGSTR_KEY_SYSTEMBOARD* = "*PNP0C01" + REGSTR_KEY_APM* = "*PNP0C05" + REGSTR_KEY_INIUPDATE* = "IniUpdate" + REG_KEY_INSTDEV* = "Installed" + REGSTR_KEY_DOSOPTCDROM* = "CD-ROM" + REGSTR_KEY_DOSOPTMOUSE* = "MOUSE" + REGSTR_KEY_KNOWNDOCKINGSTATES* = "Hardware Profiles" + REGSTR_KEY_DEVICEPARAMETERS* = "Device Parameters" + REGSTR_DEFAULT_INSTANCE* = "0000" + REGSTR_PATH_MOTHERBOARD* = REGSTR_KEY_SYSTEMBOARD & "\\" + REGSTR_PATH_SETUP* = "Software\\Microsoft\\Windows\\CurrentVersion" + REGSTR_PATH_DRIVERSIGN* = "Software\\Microsoft\\Driver Signing" + REGSTR_PATH_NONDRIVERSIGN* = "Software\\Microsoft\\Non-Driver Signing" + REGSTR_PATH_DRIVERSIGN_POLICY* = "Software\\Policies\\Microsoft\\Windows NT\\Driver Signing" + REGSTR_PATH_NONDRIVERSIGN_POLICY* = "Software\\Policies\\Microsoft\\Windows NT\\Non-Driver Signing" + REGSTR_PATH_PIFCONVERT* = "Software\\Microsoft\\Windows\\CurrentVersion\\PIFConvert" + REGSTR_PATH_MSDOSOPTS* = "Software\\Microsoft\\Windows\\CurrentVersion\\MS-DOSOptions" + REGSTR_PATH_NOSUGGMSDOS* = "Software\\Microsoft\\Windows\\CurrentVersion\\NoMSDOSWarn" + REGSTR_PATH_NEWDOSBOX* = "Software\\Microsoft\\Windows\\CurrentVersion\\MS-DOSSpecialConfig" + REGSTR_PATH_RUNONCE* = "Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce" + REGSTR_PATH_RUNONCEEX* = "Software\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx" + REGSTR_PATH_RUN* = "Software\\Microsoft\\Windows\\CurrentVersion\\Run" + REGSTR_PATH_RUNSERVICESONCE* = "Software\\Microsoft\\Windows\\CurrentVersion\\RunServicesOnce" + REGSTR_PATH_RUNSERVICES* = "Software\\Microsoft\\Windows\\CurrentVersion\\RunServices" + REGSTR_PATH_EXPLORER* = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer" + REGSTR_PATH_PROPERTYSYSTEM* = "Software\\Microsoft\\Windows\\CurrentVersion\\PropertySystem" + REGSTR_PATH_DETECT* = "Software\\Microsoft\\Windows\\CurrentVersion\\Detect" + REGSTR_PATH_APPPATHS* = "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths" + REGSTR_PATH_UNINSTALL* = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall" + REGSTR_PATH_REALMODENET* = "Software\\Microsoft\\Windows\\CurrentVersion\\Network\\Real Mode Net" + REGSTR_PATH_NETEQUIV* = "Software\\Microsoft\\Windows\\CurrentVersion\\Network\\Equivalent" + REGSTR_PATH_CVNETWORK* = "Software\\Microsoft\\Windows\\CurrentVersion\\Network" + REGSTR_PATH_WMI_SECURITY* = "System\\CurrentControlSet\\Control\\Wmi\\Security" + REGSTR_PATH_RELIABILITY* = "Software\\Microsoft\\Windows\\CurrentVersion\\Reliability" + REGSTR_PATH_RELIABILITY_POLICY* = "Software\\Policies\\Microsoft\\Windows NT\\Reliability" + REGSTR_PATH_RELIABILITY_POLICY_SHUTDOWNREASONUI* = "ShutdownReasonUI" + REGSTR_PATH_RELIABILITY_POLICY_SNAPSHOT* = "Snapshot" + REGSTR_PATH_RELIABILITY_POLICY_REPORTSNAPSHOT* = "ReportSnapshot" + REGSTR_PATH_REINSTALL* = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Reinstall" + REGSTR_PATH_NT_CURRENTVERSION* = "Software\\Microsoft\\Windows NT\\CurrentVersion" + REGSTR_PATH_VOLUMECACHE* = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\VolumeCaches" + REGSTR_VAL_DISPLAY* = "display" + REGSTR_PATH_IDCONFIGDB* = "System\\CurrentControlSet\\Control\\IDConfigDB" + REGSTR_PATH_CRITICALDEVICEDATABASE* = "System\\CurrentControlSet\\Control\\CriticalDeviceDatabase" + REGSTR_PATH_CLASS* = "System\\CurrentControlSet\\Services\\Class" + REGSTR_PATH_DISPLAYSETTINGS* = "Display\\Settings" + REGSTR_PATH_FONTS* = "Display\\Fonts" + REGSTR_PATH_ENUM* = "Enum" + REGSTR_PATH_ROOT* = "Enum\\Root" + REGSTR_PATH_CURRENTCONTROLSET* = "System\\CurrentControlSet" + REGSTR_PATH_SYSTEMENUM* = "System\\CurrentControlSet\\Enum" + REGSTR_PATH_HWPROFILES* = "System\\CurrentControlSet\\Hardware Profiles" + REGSTR_PATH_HWPROFILESCURRENT* = "System\\CurrentControlSet\\Hardware Profiles\\Current" + REGSTR_PATH_CLASS_NT* = "System\\CurrentControlSet\\Control\\Class" + REGSTR_PATH_PER_HW_ID_STORAGE* = "Software\\Microsoft\\Windows NT\\CurrentVersion\\PerHwIdStorage" + REGSTR_PATH_DEVICE_CLASSES* = "System\\CurrentControlSet\\Control\\DeviceClasses" + REGSTR_PATH_CODEVICEINSTALLERS* = "System\\CurrentControlSet\\Control\\CoDeviceInstallers" + REGSTR_PATH_BUSINFORMATION* = "System\\CurrentControlSet\\Control\\PnP\\BusInformation" + REGSTR_PATH_SERVICES* = "System\\CurrentControlSet\\Services" + REGSTR_PATH_VXD* = "System\\CurrentControlSet\\Services\\VxD" + REGSTR_PATH_IOS* = "System\\CurrentControlSet\\Services\\VxD\\IOS" + REGSTR_PATH_VMM* = "System\\CurrentControlSet\\Services\\VxD\\VMM" + REGSTR_PATH_VPOWERD* = "System\\CurrentControlSet\\Services\\VxD\\VPOWERD" + REGSTR_PATH_VNETSUP* = "System\\CurrentControlSet\\Services\\VxD\\VNETSUP" + REGSTR_PATH_NWREDIR* = "System\\CurrentControlSet\\Services\\VxD\\NWREDIR" + REGSTR_PATH_NCPSERVER* = "System\\CurrentControlSet\\Services\\NcpServer\\Parameters" + REGSTR_PATH_VCOMM* = "System\\CurrentControlSet\\Services\\VxD\\VCOMM" + REGSTR_PATH_IOARB* = "System\\CurrentControlSet\\Services\\Arbitrators\\IOArb" + REGSTR_PATH_ADDRARB* = "System\\CurrentControlSet\\Services\\Arbitrators\\AddrArb" + REGSTR_PATH_DMAARB* = "System\\CurrentControlSet\\Services\\Arbitrators\\DMAArb" + REGSTR_PATH_IRQARB* = "System\\CurrentControlSet\\Services\\Arbitrators\\IRQArb" + REGSTR_PATH_CODEPAGE* = "System\\CurrentControlSet\\Control\\Nls\\Codepage" + REGSTR_PATH_FILESYSTEM* = "System\\CurrentControlSet\\Control\\FileSystem" + REGSTR_PATH_FILESYSTEM_NOVOLTRACK* = "System\\CurrentControlSet\\Control\\FileSystem\\NoVolTrack" + REGSTR_PATH_CDFS* = "System\\CurrentControlSet\\Control\\FileSystem\\CDFS" + REGSTR_PATH_WINBOOT* = "System\\CurrentControlSet\\Control\\WinBoot" + REGSTR_PATH_INSTALLEDFILES* = "System\\CurrentControlSet\\Control\\InstalledFiles" + REGSTR_PATH_VMM32FILES* = "System\\CurrentControlSet\\Control\\VMM32Files" + REGSTR_MAX_VALUE_LENGTH* = 256 + REGSTR_KEY_DEVICE_PROPERTIES* = "Properties" + REGSTR_VAL_SLOTNUMBER* = "SlotNumber" + REGSTR_VAL_ATTACHEDCOMPONENTS* = "AttachedComponents" + REGSTR_VAL_BASEDEVICEPATH* = "BaseDevicePath" + REGSTR_VAL_SYSTEMBUSNUMBER* = "SystemBusNumber" + REGSTR_VAL_BUSDATATYPE* = "BusDataType" + REGSTR_VAL_INTERFACETYPE* = "InterfaceType" + REGSTR_VAL_SERVICE* = "Service" + REGSTR_VAL_DETECTSIGNATURE* = "DetectSignature" + REGSTR_VAL_CLASSGUID* = "ClassGUID" + REGSTR_VAL_INSTANCEIDENTIFIER* = "InstanceIdentifier" + REGSTR_VAL_DUPLICATEOF* = "DuplicateOf" + REGSTR_VAL_STATUSFLAGS* = "StatusFlags" + REGSTR_VAL_DISABLECOUNT* = "DisableCount" + REGSTR_VAL_UNKNOWNPROBLEMS* = "UnknownProblem" + REGSTR_VAL_DOCKSTATE* = "DockState" + REGSTR_VAL_PREFERENCEORDER* = "PreferenceOrder" + REGSTR_VAL_USERWAITINTERVAL* = "UserWaitInterval" + REGSTR_VAL_DEVICE_INSTANCE* = "DeviceInstance" + REGSTR_VAL_SYMBOLIC_LINK* = "SymbolicLink" + REGSTR_VAL_DEFAULT* = "Default" + REGSTR_VAL_LOWERFILTERS* = "LowerFilters" + REGSTR_VAL_UPPERFILTERS* = "UpperFilters" + REGSTR_VAL_LOCATION_INFORMATION* = "LocationInformation" + REGSTR_VAL_UI_NUMBER* = "UINumber" + REGSTR_VAL_UI_NUMBER_DESC_FORMAT* = "UINumberDescFormat" + REGSTR_VAL_CAPABILITIES* = "Capabilities" + REGSTR_VAL_DEVICE_TYPE* = "DeviceType" + REGSTR_VAL_DEVICE_CHARACTERISTICS* = "DeviceCharacteristics" + REGSTR_VAL_DEVICE_SECURITY_DESCRIPTOR* = "Security" + REGSTR_VAL_DEVICE_EXCLUSIVE* = "Exclusive" + REGSTR_VAL_RESOURCE_PICKER_TAGS* = "ResourcePickerTags" + REGSTR_VAL_RESOURCE_PICKER_EXCEPTIONS* = "ResourcePickerExceptions" + REGSTR_VAL_CUSTOM_PROPERTY_CACHE_DATE* = "CustomPropertyCacheDate" + REGSTR_VAL_CUSTOM_PROPERTY_HW_ID_KEY* = "CustomPropertyHwIdKey" + REGSTR_VAL_LAST_UPDATE_TIME* = "LastUpdateTime" + REGSTR_VAL_CONTAINERID* = "ContainerID" + REGSTR_VAL_EJECT_PRIORITY* = "EjectPriority" + REGSTR_KEY_CONTROL* = "Control" + REGSTR_VAL_ACTIVESERVICE* = "ActiveService" + REGSTR_VAL_LINKED* = "Linked" + REGSTR_VAL_PHYSICALDEVICEOBJECT* = "PhysicalDeviceObject" + REGSTR_VAL_REMOVAL_POLICY* = "RemovalPolicy" + REGSTR_VAL_CURRENT_VERSION* = "CurrentVersion" + REGSTR_VAL_CURRENT_BUILD* = "CurrentBuildNumber" + REGSTR_VAL_CURRENT_CSDVERSION* = "CSDVersion" + REGSTR_VAL_CURRENT_TYPE* = "CurrentType" + REGSTR_VAL_BITSPERPIXEL* = "BitsPerPixel" + REGSTR_VAL_RESOLUTION* = "Resolution" + REGSTR_VAL_DPILOGICALX* = "DPILogicalX" + REGSTR_VAL_DPILOGICALY* = "DPILogicalY" + REGSTR_VAL_DPIPHYSICALX* = "DPIPhysicalX" + REGSTR_VAL_DPIPHYSICALY* = "DPIPhysicalY" + REGSTR_VAL_REFRESHRATE* = "RefreshRate" + REGSTR_VAL_DISPLAYFLAGS* = "DisplayFlags" + REGSTR_PATH_CONTROLPANEL* = "Control Panel" + REGSTR_PATH_CONTROLSFOLDER* = "Software\\Microsoft\\Windows\\CurrentVersion\\Controls Folder" + REGSTR_VAL_DOSCP* = "OEMCP" + REGSTR_VAL_WINCP* = "ACP" + REGSTR_PATH_DYNA_ENUM* = "Config Manager\\Enum" + REGSTR_VAL_HARDWARE_KEY* = "HardWareKey" + REGSTR_VAL_ALLOCATION* = "Allocation" + REGSTR_VAL_PROBLEM* = "Problem" + REGSTR_VAL_STATUS* = "Status" + REGSTR_VAL_DONTUSEMEM* = "DontAllocLastMem" + REGSTR_VAL_SYSTEMROOT* = "SystemRoot" + REGSTR_VAL_BOOTCOUNT* = "BootCount" + REGSTR_VAL_REALNETSTART* = "RealNetStart" + REGSTR_VAL_MEDIA* = "MediaPath" + REGSTR_VAL_CONFIG* = "ConfigPath" + REGSTR_VAL_DEVICEPATH* = "DevicePath" + REGSTR_VAL_SRCPATH* = "SourcePath" + REGSTR_VAL_SVCPAKSRCPATH* = "ServicePackSourcePath" + REGSTR_VAL_DRIVERCACHEPATH* = "DriverCachePath" + REGSTR_VAL_OLDWINDIR* = "OldWinDir" + REGSTR_VAL_SETUPFLAGS* = "SetupFlags" + REGSTR_VAL_REGOWNER* = "RegisteredOwner" + REGSTR_VAL_REGORGANIZATION* = "RegisteredOrganization" + REGSTR_VAL_LICENSINGINFO* = "LicensingInfo" + REGSTR_VAL_OLDMSDOSVER* = "OldMSDOSVer" + REGSTR_VAL_FIRSTINSTALLDATETIME* = "FirstInstallDateTime" + REGSTR_VAL_INSTALLTYPE* = "InstallType" + IT_COMPACT* = 0x0000 + IT_TYPICAL* = 0x0001 + IT_PORTABLE* = 0x0002 + IT_CUSTOM* = 0x0003 + REGSTR_VAL_WRAPPER* = "Wrapper" + REGSTR_KEY_RUNHISTORY* = "RunHistory" + REGSTR_VAL_LASTALIVEINTERVAL* = "TimeStampInterval" + REGSTR_VAL_DIRTYSHUTDOWN* = "DirtyShutdown" + REGSTR_VAL_DIRTYSHUTDOWNTIME* = "DirtyShutdownTime" + REGSTR_VAL_BT* = "6005BT" + REGSTR_VAL_LASTCOMPUTERNAME* = "LastComputerName" + REGSTR_VAL_LASTALIVEBT* = "LastAliveBT" + REGSTR_VAL_LASTALIVESTAMP* = "LastAliveStamp" + REGSTR_VAL_LASTALIVESTAMPFORCED* = "LastAliveStampForced" + REGSTR_VAL_LASTALIVESTAMPINTERVAL* = "LastAliveStampInterval" + REGSTR_VAL_LASTALIVESTAMPPOLICYINTERVAL* = "LastAliveStampPolicyInterval" + REGSTR_VAL_LASTALIVEUPTIME* = "LastAliveUptime" + REGSTR_VAL_LASTALIVEPMPOLICY* = "LastAlivePMPolicy" + REGSTR_VAL_REASONCODE* = "ReasonCode" + REGSTR_VAL_COMMENT* = "Comment" + REGSTR_VAL_SHUTDOWNREASON* = "ShutdownReason" + REGSTR_VAL_SHUTDOWNREASON_CODE* = "ShutdownReasonCode" + REGSTR_VAL_SHUTDOWNREASON_COMMENT* = "ShutdownReasonComment" + REGSTR_VAL_SHUTDOWNREASON_PROCESS* = "ShutdownReasonProcess" + REGSTR_VAL_SHUTDOWNREASON_USERNAME* = "ShutdownReasonUserName" + REGSTR_VAL_SHOWREASONUI* = "ShutdownReasonUI" + REGSTR_VAL_SHUTDOWN_IGNORE_PREDEFINED* = "ShutdownIgnorePredefinedReasons" + REGSTR_VAL_SHUTDOWN_STATE_SNAPSHOT* = "ShutdownStateSnapshot" + REGSTR_KEY_SETUP* = "\\Setup" + REGSTR_VAL_BOOTDIR* = "BootDir" + REGSTR_VAL_WINBOOTDIR* = "WinbootDir" + REGSTR_VAL_WINDIR* = "WinDir" + REGSTR_VAL_APPINSTPATH* = "AppInstallPath" + REGSTR_KEY_EBDFILESLOCAL* = "EBDFilesLocale" + REGSTR_KEY_EBDFILESKEYBOARD* = "EBDFilesKeyboard" + REGSTR_KEY_EBDAUTOEXECBATLOCAL* = "EBDAutoexecBatLocale" + REGSTR_KEY_EBDAUTOEXECBATKEYBOARD* = "EBDAutoexecBatKeyboard" + REGSTR_KEY_EBDCONFIGSYSLOCAL* = "EBDConfigSysLocale" + REGSTR_KEY_EBDCONFIGSYSKEYBOARD* = "EBDConfigSysKeyboard" + REGSTR_VAL_POLICY* = "Policy" + REGSTR_VAL_BEHAVIOR_ON_FAILED_VERIFY* = "BehaviorOnFailedVerify" + DRIVERSIGN_NONE* = 0x00000000 + DRIVERSIGN_WARNING* = 0x00000001 + DRIVERSIGN_BLOCKING* = 0x00000002 + REGSTR_VAL_MSDOSMODE* = "MSDOSMode" + REGSTR_VAL_MSDOSMODEDISCARD* = "Discard" + REGSTR_VAL_DOSOPTGLOBALFLAGS* = "GlobalFlags" + DOSOPTGF_DEFCLEAN* = 0x00000001 + REGSTR_VAL_DOSOPTFLAGS* = "Flags" + REGSTR_VAL_OPTORDER* = "Order" + REGSTR_VAL_CONFIGSYS* = "Config.Sys" + REGSTR_VAL_AUTOEXEC* = "Autoexec.Bat" + REGSTR_VAL_STDDOSOPTION* = "StdOption" + REGSTR_VAL_DOSOPTTIP* = "TipText" + DOSOPTF_DEFAULT* = 0x00000001 + DOSOPTF_SUPPORTED* = 0x00000002 + DOSOPTF_ALWAYSUSE* = 0x00000004 + DOSOPTF_USESPMODE* = 0x00000008 + DOSOPTF_PROVIDESUMB* = 0x00000010 + DOSOPTF_NEEDSETUP* = 0x00000020 + DOSOPTF_INDOSSTART* = 0x00000040 + DOSOPTF_MULTIPLE* = 0x00000080 + SUF_FIRSTTIME* = 0x00000001 + SUF_EXPRESS* = 0x00000002 + SUF_BATCHINF* = 0x00000004 + SUF_CLEAN* = 0x00000008 + SUF_INSETUP* = 0x00000010 + SUF_NETSETUP* = 0x00000020 + SUF_NETHDBOOT* = 0x00000040 + SUF_NETRPLBOOT* = 0x00000080 + SUF_SBSCOPYOK* = 0x00000100 + REGSTR_VAL_DOSPAGER* = "DOSPager" + REGSTR_VAL_VXDGROUPS* = "VXDGroups" + REGSTR_VAL_VPOWERDFLAGS* = "Flags" + VPDF_DISABLEPWRMGMT* = 0x00000001 + VPDF_FORCEAPM10MODE* = 0x00000002 + VPDF_SKIPINTELSLCHECK* = 0x00000004 + VPDF_DISABLEPWRSTATUSPOLL* = 0x00000008 + VPDF_DISABLERINGRESUME* = 0x00000010 + VPDF_SHOWMULTIBATT* = 0x00000020 + BIF_SHOWSIMILARDRIVERS* = 0x00000001 + BIF_RAWDEVICENEEDSDRIVER* = 0x00000002 + REGSTR_VAL_WORKGROUP* = "Workgroup" + REGSTR_VAL_DIRECTHOST* = "DirectHost" + REGSTR_VAL_FILESHARING* = "FileSharing" + REGSTR_VAL_PRINTSHARING* = "PrintSharing" + REGSTR_VAL_FIRSTNETDRIVE* = "FirstNetworkDrive" + REGSTR_VAL_MAXCONNECTIONS* = "MaxConnections" + REGSTR_VAL_APISUPPORT* = "APISupport" + REGSTR_VAL_MAXRETRY* = "MaxRetry" + REGSTR_VAL_MINRETRY* = "MinRetry" + REGSTR_VAL_SUPPORTLFN* = "SupportLFN" + REGSTR_VAL_SUPPORTBURST* = "SupportBurst" + REGSTR_VAL_SUPPORTTUNNELLING* = "SupportTunnelling" + REGSTR_VAL_FULLTRACE* = "FullTrace" + REGSTR_VAL_READCACHING* = "ReadCaching" + REGSTR_VAL_SHOWDOTS* = "ShowDots" + REGSTR_VAL_GAPTIME* = "GapTime" + REGSTR_VAL_SEARCHMODE* = "SearchMode" + REGSTR_VAL_SHELLVERSION* = "ShellVersion" + REGSTR_VAL_MAXLIP* = "MaxLIP" + REGSTR_VAL_PRESERVECASE* = "PreserveCase" + REGSTR_VAL_OPTIMIZESFN* = "OptimizeSFN" + REGSTR_VAL_NCP_BROWSEMASTER* = "BrowseMaster" + REGSTR_VAL_NCP_USEPEERBROWSING* = "Use_PeerBrowsing" + REGSTR_VAL_NCP_USESAP* = "Use_Sap" + REGSTR_VAL_PCCARD_POWER* = "EnablePowerManagement" + REGSTR_VAL_WIN31FILESYSTEM* = "Win31FileSystem" + REGSTR_VAL_PRESERVELONGNAMES* = "PreserveLongNames" + REGSTR_VAL_DRIVEWRITEBEHIND* = "DriveWriteBehind" + REGSTR_VAL_ASYNCFILECOMMIT* = "AsyncFileCommit" + REGSTR_VAL_PATHCACHECOUNT* = "PathCache" + REGSTR_VAL_NAMECACHECOUNT* = "NameCache" + REGSTR_VAL_CONTIGFILEALLOC* = "ContigFileAllocSize" + REGSTR_VAL_FREESPACERATIO* = "FreeSpaceRatio" + REGSTR_VAL_VOLIDLETIMEOUT* = "VolumeIdleTimeout" + REGSTR_VAL_BUFFIDLETIMEOUT* = "BufferIdleTimeout" + REGSTR_VAL_BUFFAGETIMEOUT* = "BufferAgeTimeout" + REGSTR_VAL_NAMENUMERICTAIL* = "NameNumericTail" + REGSTR_VAL_READAHEADTHRESHOLD* = "ReadAheadThreshold" + REGSTR_VAL_DOUBLEBUFFER* = "DoubleBuffer" + REGSTR_VAL_SOFTCOMPATMODE* = "SoftCompatMode" + REGSTR_VAL_DRIVESPINDOWN* = "DriveSpinDown" + REGSTR_VAL_FORCEPMIO* = "ForcePMIO" + REGSTR_VAL_FORCERMIO* = "ForceRMIO" + REGSTR_VAL_LASTBOOTPMDRVS* = "LastBootPMDrvs" + REGSTR_VAL_ACSPINDOWNPREVIOUS* = "ACSpinDownPrevious" + REGSTR_VAL_BATSPINDOWNPREVIOUS* = "BatSpinDownPrevious" + REGSTR_VAL_VIRTUALHDIRQ* = "VirtualHDIRQ" + REGSTR_VAL_SRVNAMECACHECOUNT* = "ServerNameCacheMax" + REGSTR_VAL_SRVNAMECACHE* = "ServerNameCache" + REGSTR_VAL_SRVNAMECACHENETPROV* = "ServerNameCacheNumNets" + REGSTR_VAL_AUTOMOUNT* = "AutoMountDrives" + REGSTR_VAL_COMPRESSIONMETHOD* = "CompressionAlgorithm" + REGSTR_VAL_COMPRESSIONTHRESHOLD* = "CompressionThreshold" + REGSTR_VAL_ACDRIVESPINDOWN* = "ACDriveSpinDown" + REGSTR_VAL_BATDRIVESPINDOWN* = "BatDriveSpinDown" + REGSTR_VAL_CDCACHESIZE* = "CacheSize" + REGSTR_VAL_CDPREFETCH* = "Prefetch" + REGSTR_VAL_CDPREFETCHTAIL* = "PrefetchTail" + REGSTR_VAL_CDRAWCACHE* = "RawCache" + REGSTR_VAL_CDEXTERRORS* = "ExtendedErrors" + REGSTR_VAL_CDSVDSENSE* = "SVDSense" + REGSTR_VAL_CDSHOWVERSIONS* = "ShowVersions" + REGSTR_VAL_CDCOMPATNAMES* = "MSCDEXCompatNames" + REGSTR_VAL_CDNOREADAHEAD* = "NoReadAhead" + REGSTR_VAL_SCSI* = "SCSI\\" + REGSTR_VAL_ESDI* = "ESDI\\" + REGSTR_VAL_FLOP* = "FLOP\\" + REGSTR_VAL_DISK* = "GenDisk" + REGSTR_VAL_CDROM* = "GenCD" + REGSTR_VAL_TAPE* = "TAPE" + REGSTR_VAL_SCANNER* = "SCANNER" + REGSTR_VAL_FLOPPY* = "FLOPPY" + REGSTR_VAL_SCSITID* = "SCSITargetID" + REGSTR_VAL_SCSILUN* = "SCSILUN" + REGSTR_VAL_REVLEVEL* = "RevisionLevel" + REGSTR_VAL_PRODUCTID* = "ProductId" + REGSTR_VAL_PRODUCTTYPE* = "ProductType" + REGSTR_VAL_DEVTYPE* = "DeviceType" + REGSTR_VAL_REMOVABLE* = "Removable" + REGSTR_VAL_CURDRVLET* = "CurrentDriveLetterAssignment" + REGSTR_VAL_USRDRVLET* = "UserDriveLetterAssignment" + REGSTR_VAL_SYNCDATAXFER* = "SyncDataXfer" + REGSTR_VAL_AUTOINSNOTE* = "AutoInsertNotification" + REGSTR_VAL_DISCONNECT* = "Disconnect" + REGSTR_VAL_INT13* = "Int13" + REGSTR_VAL_PMODE_INT13* = "PModeInt13" + REGSTR_VAL_USERSETTINGS* = "AdapterSettings" + REGSTR_VAL_NOIDE* = "NoIDE" + REGSTR_VAL_DISKCLASSNAME* = "DiskDrive" + REGSTR_VAL_CDROMCLASSNAME* = "CDROM" + REGSTR_VAL_FORCELOAD* = "ForceLoadPD" + REGSTR_VAL_FORCEFIFO* = "ForceFIFO" + REGSTR_VAL_FORCECL* = "ForceChangeLine" + REGSTR_VAL_NOUSECLASS* = "NoUseClass" + REGSTR_VAL_NOINSTALLCLASS* = "NoInstallClass" + REGSTR_VAL_NODISPLAYCLASS* = "NoDisplayClass" + REGSTR_VAL_SILENTINSTALL* = "SilentInstall" + REGSTR_KEY_PCMCIA_CLASS* = "PCMCIA" + REGSTR_KEY_SCSI_CLASS* = "SCSIAdapter" + REGSTR_KEY_PORTS_CLASS* = "ports" + REGSTR_KEY_MEDIA_CLASS* = "MEDIA" + REGSTR_KEY_DISPLAY_CLASS* = "Display" + REGSTR_KEY_KEYBOARD_CLASS* = "Keyboard" + REGSTR_KEY_MOUSE_CLASS* = "Mouse" + REGSTR_KEY_MONITOR_CLASS* = "Monitor" + REGSTR_KEY_MODEM_CLASS* = "Modem" + REGSTR_VAL_PCMCIA_OPT* = "Options" + PCMCIA_OPT_HAVE_SOCKET* = 0x00000001 + PCMCIA_OPT_AUTOMEM* = 0x00000004 + PCMCIA_OPT_NO_SOUND* = 0x00000008 + PCMCIA_OPT_NO_AUDIO* = 0x00000010 + PCMCIA_OPT_NO_APMREMOVE* = 0x00000020 + REGSTR_VAL_PCMCIA_MEM* = "Memory" + PCMCIA_DEF_MEMBEGIN* = 0x000c0000 + PCMCIA_DEF_MEMEND* = 0x00ffffff + PCMCIA_DEF_MEMLEN* = 0x00001000 + REGSTR_VAL_PCMCIA_ALLOC* = "AllocMemWin" + REGSTR_VAL_PCMCIA_ATAD* = "ATADelay" + REGSTR_VAL_PCMCIA_SIZ* = "MinRegionSize" + PCMCIA_DEF_MIN_REGION* = 0x00010000 + REGSTR_VAL_P1284MDL* = "Model" + REGSTR_VAL_P1284MFG* = "Manufacturer" + REGSTR_VAL_ISAPNP* = "ISAPNP" + REGSTR_VAL_ISAPNP_RDP_OVERRIDE* = "RDPOverRide" + REGSTR_VAL_PCI* = "PCI" + REGSTR_PCI_OPTIONS* = "Options" + REGSTR_PCI_DUAL_IDE* = "PCIDualIDE" + PCI_OPTIONS_USE_BIOS* = 0x00000001 + PCI_OPTIONS_USE_IRQ_STEERING* = 0x00000002 + AGP_FLAG_NO_1X_RATE* = 0x00000001 + AGP_FLAG_NO_2X_RATE* = 0x00000002 + AGP_FLAG_NO_4X_RATE* = 0x00000004 + AGP_FLAG_NO_8X_RATE* = 0x00000008 + AGP_FLAG_REVERSE_INITIALIZATION* = 0x00000080 + AGP_FLAG_NO_SBA_ENABLE* = 0x00000100 + AGP_FLAG_NO_FW_ENABLE* = 0x00000200 + AGP_FLAG_SPECIAL_TARGET* = 0x000fffff + AGP_FLAG_SPECIAL_RESERVE* = 0x000f8000 + REGSTR_KEY_CRASHES* = "Crashes" + REGSTR_KEY_DANGERS* = "Dangers" + REGSTR_KEY_DETMODVARS* = "DetModVars" + REGSTR_KEY_NDISINFO* = "NDISInfo" + REGSTR_VAL_PROTINIPATH* = "ProtIniPath" + REGSTR_VAL_RESOURCES* = "Resources" + REGSTR_VAL_CRASHFUNCS* = "CrashFuncs" + REGSTR_VAL_CLASS* = "Class" + REGSTR_VAL_CLASSDESC* = "ClassDesc" + REGSTR_VAL_DEVDESC* = "DeviceDesc" + REGSTR_VAL_BOOTCONFIG* = "BootConfig" + REGSTR_VAL_DETFUNC* = "DetFunc" + REGSTR_VAL_DETFLAGS* = "DetFlags" + REGSTR_VAL_COMPATIBLEIDS* = "CompatibleIDs" + REGSTR_VAL_DETCONFIG* = "DetConfig" + REGSTR_VAL_VERIFYKEY* = "VerifyKey" + REGSTR_VAL_COMINFO* = "ComInfo" + REGSTR_VAL_INFNAME* = "InfName" + REGSTR_VAL_CARDSPECIFIC* = "CardSpecific" + REGSTR_VAL_NETOSTYPE* = "NetOSType" + REGSTR_DATA_NETOS_NDIS* = "NDIS" + REGSTR_DATA_NETOS_ODI* = "ODI" + REGSTR_DATA_NETOS_IPX* = "IPX" + REGSTR_VAL_MFG* = "Mfg" + REGSTR_VAL_SCAN_ONLY_FIRST* = "ScanOnlyFirstDrive" + REGSTR_VAL_SHARE_IRQ* = "ForceIRQSharing" + REGSTR_VAL_NONSTANDARD_ATAPI* = "NonStandardATAPI" + REGSTR_VAL_IDE_FORCE_SERIALIZE* = "ForceSerialization" + REGSTR_VAL_MAX_HCID_LEN* = 1024 + REGSTR_VAL_HWREV* = "HWRevision" + REGSTR_VAL_ENABLEINTS* = "EnableInts" + REGDF_NOTDETIO* = 0x00000001 + REGDF_NOTDETMEM* = 0x00000002 + REGDF_NOTDETIRQ* = 0x00000004 + REGDF_NOTDETDMA* = 0x00000008 + REGDF_NOTDETALL* = REGDF_NOTDETIO or REGDF_NOTDETMEM or REGDF_NOTDETIRQ or REGDF_NOTDETDMA + REGDF_NEEDFULLCONFIG* = 0x00000010 + REGDF_GENFORCEDCONFIG* = 0x00000020 + REGDF_NODETCONFIG* = 0x00008000 + REGDF_CONFLICTIO* = 0x00010000 + REGDF_CONFLICTMEM* = 0x00020000 + REGDF_CONFLICTIRQ* = 0x00040000 + REGDF_CONFLICTDMA* = 0x00080000 + REGDF_CONFLICTALL* = REGDF_CONFLICTIO or REGDF_CONFLICTMEM or REGDF_CONFLICTIRQ or REGDF_CONFLICTDMA + REGDF_MAPIRQ2TO9* = 0x00100000 + REGDF_NOTVERIFIED* = 0x80000000'i32 + REGSTR_VAL_APMBIOSVER* = "APMBiosVer" + REGSTR_VAL_APMFLAGS* = "APMFlags" + REGSTR_VAL_SLSUPPORT* = "SLSupport" + REGSTR_VAL_MACHINETYPE* = "MachineType" + REGSTR_VAL_SETUPMACHINETYPE* = "SetupMachineType" + REGSTR_MACHTYPE_UNKNOWN* = "Unknown" + REGSTR_MACHTYPE_IBMPC* = "IBM PC" + REGSTR_MACHTYPE_IBMPCJR* = "IBM PCjr" + REGSTR_MACHTYPE_IBMPCCONV* = "IBM PC Convertible" + REGSTR_MACHTYPE_IBMPCXT* = "IBM PC/XT" + REGSTR_MACHTYPE_IBMPCXT_286* = "IBM PC/XT 286" + REGSTR_MACHTYPE_IBMPCAT* = "IBM PC/AT" + REGSTR_MACHTYPE_IBMPS2_25* = "IBM PS/2-25" + REGSTR_MACHTYPE_IBMPS2_30_286* = "IBM PS/2-30 286" + REGSTR_MACHTYPE_IBMPS2_30* = "IBM PS/2-30" + REGSTR_MACHTYPE_IBMPS2_50* = "IBM PS/2-50" + REGSTR_MACHTYPE_IBMPS2_50Z* = "IBM PS/2-50Z" + REGSTR_MACHTYPE_IBMPS2_55SX* = "IBM PS/2-55SX" + REGSTR_MACHTYPE_IBMPS2_60* = "IBM PS/2-60" + REGSTR_MACHTYPE_IBMPS2_65SX* = "IBM PS/2-65SX" + REGSTR_MACHTYPE_IBMPS2_70* = "IBM PS/2-70" + REGSTR_MACHTYPE_IBMPS2_P70* = "IBM PS/2-P70" + REGSTR_MACHTYPE_IBMPS2_70_80* = "IBM PS/2-70/80" + REGSTR_MACHTYPE_IBMPS2_80* = "IBM PS/2-80" + REGSTR_MACHTYPE_IBMPS2_90* = "IBM PS/2-90" + REGSTR_MACHTYPE_IBMPS1* = "IBM PS/1" + REGSTR_MACHTYPE_PHOENIX_PCAT* = "Phoenix PC/AT Compatible" + REGSTR_MACHTYPE_HP_VECTRA* = "HP Vectra" + REGSTR_MACHTYPE_ATT_PC* = "AT and T PC" + REGSTR_MACHTYPE_ZENITH_PC* = "Zenith PC" + REGSTR_VAL_APMMENUSUSPEND* = "APMMenuSuspend" + APMMENUSUSPEND_DISABLED* = 0 + APMMENUSUSPEND_ENABLED* = 1 + APMMENUSUSPEND_UNDOCKED* = 2 + APMMENUSUSPEND_NOCHANGE* = 0x80 + REGSTR_VAL_APMACTIMEOUT* = "APMACTimeout" + REGSTR_VAL_APMBATTIMEOUT* = "APMBatTimeout" + APMTIMEOUT_DISABLED* = 0 + REGSTR_VAL_APMSHUTDOWNPOWER* = "APMShutDownPower" + REGSTR_VAL_BUSTYPE* = "BusType" + REGSTR_VAL_CPU* = "CPU" + REGSTR_VAL_NDP* = "NDP" + REGSTR_VAL_PNPBIOSVER* = "PnPBIOSVer" + REGSTR_VAL_PNPSTRUCOFFSET* = "PnPStrucOffset" + REGSTR_VAL_PCIBIOSVER* = "PCIBIOSVer" + REGSTR_VAL_HWMECHANISM* = "HWMechanism" + REGSTR_VAL_LASTPCIBUSNUM* = "LastPCIBusNum" + REGSTR_VAL_CONVMEM* = "ConvMem" + REGSTR_VAL_EXTMEM* = "ExtMem" + REGSTR_VAL_COMPUTERNAME* = "ComputerName" + REGSTR_VAL_BIOSNAME* = "BIOSName" + REGSTR_VAL_BIOSVERSION* = "BIOSVersion" + REGSTR_VAL_BIOSDATE* = "BIOSDate" + REGSTR_VAL_MODEL* = "Model" + REGSTR_VAL_SUBMODEL* = "Submodel" + REGSTR_VAL_REVISION* = "Revision" + REGSTR_VAL_FIFODEPTH* = "FIFODepth" + REGSTR_VAL_RDINTTHRESHOLD* = "RDIntThreshold" + REGSTR_VAL_WRINTTHRESHOLD* = "WRIntThreshold" + REGSTR_VAL_PRIORITY* = "Priority" + REGSTR_VAL_DRIVER* = "Driver" + REGSTR_VAL_FUNCDESC* = "FunctionDesc" + REGSTR_VAL_FORCEDCONFIG* = "ForcedConfig" + REGSTR_VAL_CONFIGFLAGS* = "ConfigFlags" + REGSTR_VAL_CSCONFIGFLAGS* = "CSConfigFlags" + CONFIGFLAG_DISABLED* = 0x00000001 + CONFIGFLAG_REMOVED* = 0x00000002 + CONFIGFLAG_MANUAL_INSTALL* = 0x00000004 + CONFIGFLAG_IGNORE_BOOT_LC* = 0x00000008 + CONFIGFLAG_NET_BOOT* = 0x00000010 + CONFIGFLAG_REINSTALL* = 0x00000020 + CONFIGFLAG_FAILEDINSTALL* = 0x00000040 + CONFIGFLAG_CANTSTOPACHILD* = 0x00000080 + CONFIGFLAG_OKREMOVEROM* = 0x00000100 + CONFIGFLAG_NOREMOVEEXIT* = 0x00000200 + CONFIGFLAG_FINISH_INSTALL* = 0x00000400 + CONFIGFLAG_NEEDS_FORCED_CONFIG* = 0x00000800 + CONFIGFLAG_NETBOOT_CARD* = 0x00001000 + CONFIGFLAG_PARTIAL_LOG_CONF* = 0x00002000 + CONFIGFLAG_SUPPRESS_SURPRISE* = 0x00004000 + CONFIGFLAG_VERIFY_HARDWARE* = 0x00008000 + CONFIGFLAG_FINISHINSTALL_UI* = 0x00010000 + CONFIGFLAG_FINISHINSTALL_ACTION* = 0x00020000 + CONFIGFLAG_BOOT_DEVICE* = 0x00040000 + CSCONFIGFLAG_BITS* = 0x00000007 + CSCONFIGFLAG_DISABLED* = 0x00000001 + CSCONFIGFLAG_DO_NOT_CREATE* = 0x00000002 + CSCONFIGFLAG_DO_NOT_START* = 0x00000004 + DMSTATEFLAG_APPLYTOALL* = 0x00000001 + REGSTR_VAL_ROOT_DEVNODE* = "HTREE\\ROOT\\0" + REGSTR_VAL_RESERVED_DEVNODE* = "HTREE\\RESERVED\\0" + REGSTR_PATH_READDATAPORT* = REGSTR_KEY_ISAENUM & "\\ReadDataPort\\0" + REGSTR_PATH_MULTI_FUNCTION* = "MF" + REGSTR_VAL_RESOURCE_MAP* = "ResourceMap" + REGSTR_PATH_CHILD_PREFIX* = "Child" + NUM_RESOURCE_MAP* = 256 + REGSTR_VAL_MF_FLAGS* = "MFFlags" + MF_FLAGS_EVEN_IF_NO_RESOURCE* = 0x00000001 + MF_FLAGS_NO_CREATE_IF_NO_RESOURCE* = 0x00000002 + MF_FLAGS_FILL_IN_UNKNOWN_RESOURCE* = 0x00000004 + MF_FLAGS_CREATE_BUT_NO_SHOW_DISABLED* = 0x00000008 + REGSTR_VAL_EISA_RANGES* = "EISARanges" + REGSTR_VAL_EISA_FUNCTIONS* = "EISAFunctions" + REGSTR_VAL_EISA_FUNCTIONS_MASK* = "EISAFunctionsMask" + REGSTR_VAL_EISA_FLAGS* = "EISAFlags" + REGSTR_VAL_EISA_SIMULATE_INT15* = "EISASimulateInt15" + EISAFLAG_NO_IO_MERGE* = 0x00000001 + EISAFLAG_SLOT_IO_FIRST* = 0x00000002 + EISA_NO_MAX_FUNCTION* = 0xff + NUM_EISA_RANGES* = 4 + REGSTR_VAL_DRVDESC* = "DriverDesc" + REGSTR_VAL_DEVLOADER* = "DevLoader" + REGSTR_VAL_STATICVXD* = "StaticVxD" + REGSTR_VAL_PROPERTIES* = "Properties" + REGSTR_VAL_MANUFACTURER* = "Manufacturer" + REGSTR_VAL_EXISTS* = "Exists" + REGSTR_VAL_CMENUMFLAGS* = "CMEnumFlags" + REGSTR_VAL_CMDRIVFLAGS* = "CMDrivFlags" + REGSTR_VAL_ENUMERATOR* = "Enumerator" + REGSTR_VAL_DEVICEDRIVER* = "DeviceDriver" + REGSTR_VAL_PORTNAME* = "PortName" + REGSTR_VAL_INFPATH* = "InfPath" + REGSTR_VAL_INFSECTION* = "InfSection" + REGSTR_VAL_INFSECTIONEXT* = "InfSectionExt" + REGSTR_VAL_POLLING* = "Polling" + REGSTR_VAL_DONTLOADIFCONFLICT* = "DontLoadIfConflict" + REGSTR_VAL_PORTSUBCLASS* = "PortSubClass" + REGSTR_VAL_NETCLEAN* = "NetClean" + REGSTR_VAL_IDE_NO_SERIALIZE* = "IDENoSerialize" + REGSTR_VAL_NOCMOSORFDPT* = "NoCMOSorFDPT" + REGSTR_VAL_COMVERIFYBASE* = "COMVerifyBase" + REGSTR_VAL_MATCHINGDEVID* = "MatchingDeviceId" + REGSTR_VAL_DRIVERDATE* = "DriverDate" + REGSTR_VAL_DRIVERDATEDATA* = "DriverDateData" + REGSTR_VAL_DRIVERVERSION* = "DriverVersion" + REGSTR_VAL_LOCATION_INFORMATION_OVERRIDE* = "LocationInformationOverride" + REGSTR_KEY_OVERRIDE* = "Override" + REGSTR_VAL_CONFIGMG* = "CONFIGMG" + REGSTR_VAL_SYSDM* = "SysDM" + REGSTR_VAL_SYSDMFUNC* = "SysDMFunc" + REGSTR_VAL_PRIVATE* = "Private" + REGSTR_VAL_PRIVATEFUNC* = "PrivateFunc" + REGSTR_VAL_DETECT* = "Detect" + REGSTR_VAL_DETECTFUNC* = "DetectFunc" + REGSTR_VAL_ASKFORCONFIG* = "AskForConfig" + REGSTR_VAL_ASKFORCONFIGFUNC* = "AskForConfigFunc" + REGSTR_VAL_WAITFORUNDOCK* = "WaitForUndock" + REGSTR_VAL_WAITFORUNDOCKFUNC* = "WaitForUndockFunc" + REGSTR_VAL_REMOVEROMOKAY* = "RemoveRomOkay" + REGSTR_VAL_REMOVEROMOKAYFUNC* = "RemoveRomOkayFunc" + REGSTR_VAL_CURCONFIG* = "CurrentConfig" + REGSTR_VAL_FRIENDLYNAME* = "FriendlyName" + REGSTR_VAL_CURRENTCONFIG* = "CurrentConfig" + REGSTR_VAL_MAP* = "Map" + REGSTR_VAL_ID* = "CurrentID" + REGSTR_VAL_DOCKED* = "CurrentDockedState" + REGSTR_VAL_CHECKSUM* = "CurrentChecksum" + REGSTR_VAL_HWDETECT* = "HardwareDetect" + REGSTR_VAL_INHIBITRESULTS* = "InhibitResults" + REGSTR_VAL_PROFILEFLAGS* = "ProfileFlags" + REGSTR_KEY_PCMCIA* = "PCMCIA\\" + REGSTR_KEY_PCUNKNOWN* = "UNKNOWN_MANUFACTURER" + REGSTR_VAL_PCSSDRIVER* = "Driver" + REGSTR_KEY_PCMTD* = "MTD-" + REGSTR_VAL_PCMTDRIVER* = "MTD" + REGSTR_VAL_HARDWAREID* = "HardwareID" + REGSTR_VAL_INSTALLER* = "Installer" + REGSTR_VAL_INSTALLER_32* = "Installer32" + REGSTR_VAL_INSICON* = "Icon" + REGSTR_VAL_ENUMPROPPAGES* = "EnumPropPages" + REGSTR_VAL_ENUMPROPPAGES_32* = "EnumPropPages32" + REGSTR_VAL_BASICPROPERTIES* = "BasicProperties" + REGSTR_VAL_BASICPROPERTIES_32* = "BasicProperties32" + REGSTR_VAL_COINSTALLERS_32* = "CoInstallers32" + REGSTR_VAL_PRIVATEPROBLEM* = "PrivateProblem" + REGSTR_KEY_CURRENT* = "Current" + REGSTR_KEY_DEFAULT* = "Default" + REGSTR_KEY_MODES* = "Modes" + REGSTR_VAL_MODE* = "Mode" + REGSTR_VAL_BPP* = "BPP" + REGSTR_VAL_HRES* = "HRes" + REGSTR_VAL_VRES* = "VRes" + REGSTR_VAL_FONTSIZE* = "FontSize" + REGSTR_VAL_DRV* = "drv" + REGSTR_VAL_GRB* = "grb" + REGSTR_VAL_VDD* = "vdd" + REGSTR_VAL_VER* = "Ver" + REGSTR_VAL_MAXRES* = "MaxResolution" + REGSTR_VAL_DPMS* = "DPMS" + REGSTR_VAL_RESUMERESET* = "ResumeReset" + REGSTR_VAL_DESCRIPTION* = "Description" + REGSTR_KEY_SYSTEM* = "System" + REGSTR_KEY_USER* = "User" + REGSTR_VAL_DPI* = "dpi" + REGSTR_VAL_PCICOPTIONS* = "PCICOptions" + PCIC_DEFAULT_IRQMASK* = 0x4eb8 + PCIC_DEFAULT_NUMSOCKETS* = 0 + REGSTR_VAL_PCICIRQMAP* = "PCICIRQMap" + REGSTR_PATH_APPEARANCE* = "Control Panel\\Appearance" + REGSTR_PATH_LOOKSCHEMES* = "Control Panel\\Appearance\\Schemes" + REGSTR_VAL_CUSTOMCOLORS* = "CustomColors" + REGSTR_PATH_SCREENSAVE* = "Control Panel\\Desktop" + REGSTR_VALUE_USESCRPASSWORD* = "ScreenSaveUsePassword" + REGSTR_VALUE_SCRPASSWORD* = "ScreenSave_Data" + REGSTR_VALUE_LOWPOWERTIMEOUT* = "ScreenSaveLowPowerTimeout" + REGSTR_VALUE_POWEROFFTIMEOUT* = "ScreenSavePowerOffTimeout" + REGSTR_VALUE_LOWPOWERACTIVE* = "ScreenSaveLowPowerActive" + REGSTR_VALUE_POWEROFFACTIVE* = "ScreenSavePowerOffActive" + REGSTR_PATH_WINDOWSAPPLETS* = "Software\\Microsoft\\Windows\\CurrentVersion\\Applets" + REGSTR_PATH_SYSTRAY* = "Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\SysTray" + REGSTR_VAL_SYSTRAYSVCS* = "Services" + REGSTR_VAL_SYSTRAYBATFLAGS* = "PowerFlags" + REGSTR_VAL_SYSTRAYPCCARDFLAGS* = "PCMCIAFlags" + REGSTR_PATH_NETWORK_USERSETTINGS* = "Network" + REGSTR_KEY_NETWORK_PERSISTENT* = "\\Persistent" + REGSTR_KEY_NETWORK_RECENT* = "\\Recent" + REGSTR_VAL_REMOTE_PATH* = "RemotePath" + REGSTR_VAL_USER_NAME* = "UserName" + REGSTR_VAL_PROVIDER_NAME* = "ProviderName" + REGSTR_VAL_CONNECTION_TYPE* = "ConnectionType" + REGSTR_VAL_UPGRADE* = "Upgrade" + REGSTR_KEY_LOGON* = "\\Logon" + REGSTR_VAL_MUSTBEVALIDATED* = "MustBeValidated" + REGSTR_VAL_RUNLOGINSCRIPT* = "ProcessLoginScript" + REGSTR_KEY_NETWORKPROVIDER* = "\\NetworkProvider" + REGSTR_PATH_NW32NETPROVIDER* = REGSTR_PATH_SERVICES & "\\NWNP32" + REGSTR_PATH_MS32NETPROVIDER* = REGSTR_PATH_SERVICES & "\\MSNP32" + REGSTR_VAL_AUTHENT_AGENT* = "AuthenticatingAgent" + REGSTR_VAL_PREFREDIR* = "PreferredRedir" + REGSTR_VAL_AUTOSTART* = "AutoStart" + REGSTR_VAL_AUTOLOGON* = "AutoLogon" + REGSTR_VAL_NETCARD* = "Netcard" + REGSTR_VAL_TRANSPORT* = "Transport" + REGSTR_VAL_DYNAMIC* = "Dynamic" + REGSTR_VAL_TRANSITION* = "Transition" + REGSTR_VAL_STATICDRIVE* = "StaticDrive" + REGSTR_VAL_LOADHI* = "LoadHi" + REGSTR_VAL_LOADRMDRIVERS* = "LoadRMDrivers" + REGSTR_VAL_SETUPN* = "SetupN" + REGSTR_VAL_SETUPNPATH* = "SetupNPath" + REGSTR_VAL_WRKGRP_FORCEMAPPING* = "WrkgrpForceMapping" + REGSTR_VAL_WRKGRP_REQUIRED* = "WrkgrpRequired" + REGSTR_VAL_CURRENT_USER* = "Current User" + REGSTR_PATH_PWDPROVIDER* = "System\\CurrentControlSet\\Control\\PwdProvider" + REGSTR_VAL_PWDPROVIDER_PATH* = "ProviderPath" + REGSTR_VAL_PWDPROVIDER_DESC* = "Description" + REGSTR_VAL_PWDPROVIDER_CHANGEPWD* = "ChangePassword" + REGSTR_VAL_PWDPROVIDER_CHANGEPWDHWND* = "ChangePasswordHwnd" + REGSTR_VAL_PWDPROVIDER_GETPWDSTATUS* = "GetPasswordStatus" + REGSTR_VAL_PWDPROVIDER_ISNP* = "NetworkProvider" + REGSTR_VAL_PWDPROVIDER_CHANGEORDER* = "ChangeOrder" + REGSTR_PATH_POLICIES* = "Software\\Microsoft\\Windows\\CurrentVersion\\Policies" + REGSTR_PATH_UPDATE* = "System\\CurrentControlSet\\Control\\Update" + REGSTR_VALUE_ENABLE* = "Enable" + REGSTR_VALUE_VERBOSE* = "Verbose" + REGSTR_VALUE_NETPATH* = "NetworkPath" + REGSTR_VALUE_DEFAULTLOC* = "UseDefaultNetLocation" + REGSTR_KEY_NETWORK* = "Network" + REGSTR_KEY_PRINTERS* = "Printers" + REGSTR_KEY_WINOLDAPP* = "WinOldApp" + REGSTR_KEY_EXPLORER* = "Explorer" + REGSTR_PATH_RUN_POLICY* = REGSTR_PATH_POLICIES & "\\Explorer\\Run" + REGSTR_VAL_NOFILESHARING* = "NoFileSharing" + REGSTR_VAL_NOPRINTSHARING* = "NoPrintSharing" + REGSTR_VAL_NOFILESHARINGCTRL* = "NoFileSharingControl" + REGSTR_VAL_NOPRINTSHARINGCTRL* = "NoPrintSharingControl" + REGSTR_VAL_HIDESHAREPWDS* = "HideSharePwds" + REGSTR_VAL_DISABLEPWDCACHING* = "DisablePwdCaching" + REGSTR_VAL_ALPHANUMPWDS* = "AlphanumPwds" + REGSTR_VAL_NETSETUP_DISABLE* = "NoNetSetup" + REGSTR_VAL_NETSETUP_NOCONFIGPAGE* = "NoNetSetupConfigPage" + REGSTR_VAL_NETSETUP_NOIDPAGE* = "NoNetSetupIDPage" + REGSTR_VAL_NETSETUP_NOSECURITYPAGE* = "NoNetSetupSecurityPage" + REGSTR_VAL_SYSTEMCPL_NOVIRTMEMPAGE* = "NoVirtMemPage" + REGSTR_VAL_SYSTEMCPL_NODEVMGRPAGE* = "NoDevMgrPage" + REGSTR_VAL_SYSTEMCPL_NOCONFIGPAGE* = "NoConfigPage" + REGSTR_VAL_SYSTEMCPL_NOFILESYSPAGE* = "NoFileSysPage" + REGSTR_VAL_DISPCPL_NODISPCPL* = "NoDispCP" + REGSTR_VAL_DISPCPL_NOBACKGROUNDPAGE* = "NoDispBackgroundPage" + REGSTR_VAL_DISPCPL_NOSCRSAVPAGE* = "NoDispScrSavPage" + REGSTR_VAL_DISPCPL_NOAPPEARANCEPAGE* = "NoDispAppearancePage" + REGSTR_VAL_DISPCPL_NOSETTINGSPAGE* = "NoDispSettingsPage" + REGSTR_VAL_SECCPL_NOSECCPL* = "NoSecCP" + REGSTR_VAL_SECCPL_NOPWDPAGE* = "NoPwdPage" + REGSTR_VAL_SECCPL_NOADMINPAGE* = "NoAdminPage" + REGSTR_VAL_SECCPL_NOPROFILEPAGE* = "NoProfilePage" + REGSTR_VAL_PRINTERS_HIDETABS* = "NoPrinterTabs" + REGSTR_VAL_PRINTERS_NODELETE* = "NoDeletePrinter" + REGSTR_VAL_PRINTERS_NOADD* = "NoAddPrinter" + REGSTR_VAL_WINOLDAPP_DISABLED* = "Disabled" + REGSTR_VAL_WINOLDAPP_NOREALMODE* = "NoRealMode" + REGSTR_VAL_NOENTIRENETWORK* = "NoEntireNetwork" + REGSTR_VAL_NOWORKGROUPCONTENTS* = "NoWorkgroupContents" + REGSTR_VAL_UNDOCK_WITHOUT_LOGON* = "UndockWithoutLogon" + REGSTR_VAL_MINPWDLEN* = "MinPwdLen" + REGSTR_VAL_PWDEXPIRATION* = "PwdExpiration" + REGSTR_VAL_WIN31PROVIDER* = "Win31Provider" + REGSTR_VAL_DISABLEREGTOOLS* = "DisableRegistryTools" + REGSTR_PATH_WINLOGON* = "Software\\Microsoft\\Windows\\CurrentVersion\\Winlogon" + REGSTR_VAL_LEGALNOTICECAPTION* = "LegalNoticeCaption" + REGSTR_VAL_LEGALNOTICETEXT* = "LegalNoticeText" + REGSTR_VAL_SHUTDOWN_FLAGS* = "ShutdownFlags" + REGSTR_VAL_RESTRICTRUN* = "RestrictRun" + REGSTR_KEY_POL_USERS* = "Users" + REGSTR_KEY_POL_COMPUTERS* = "Computers" + REGSTR_KEY_POL_USERGROUPS* = "UserGroups" + REGSTR_KEY_POL_DEFAULT* = ".default" + REGSTR_KEY_POL_USERGROUPDATA* = "GroupData\\UserGroups\\Priority" + REGSTR_PATH_TIMEZONE* = "System\\CurrentControlSet\\Control\\TimeZoneInformation" + REGSTR_VAL_TZBIAS* = "Bias" + REGSTR_VAL_TZDLTBIAS* = "DaylightBias" + REGSTR_VAL_TZSTDBIAS* = "StandardBias" + REGSTR_VAL_TZACTBIAS* = "ActiveTimeBias" + REGSTR_VAL_TZDLTFLAG* = "DaylightFlag" + REGSTR_VAL_TZSTDSTART* = "StandardStart" + REGSTR_VAL_TZDLTSTART* = "DaylightStart" + REGSTR_VAL_TZDLTNAME* = "DaylightName" + REGSTR_VAL_TZSTDNAME* = "StandardName" + REGSTR_VAL_TZNOCHANGESTART* = "NoChangeStart" + REGSTR_VAL_TZNOCHANGEEND* = "NoChangeEnd" + REGSTR_VAL_TZNOAUTOTIME* = "DisableAutoDaylightTimeSet" + REGSTR_PATH_FLOATINGPOINTPROCESSOR* = "HARDWARE\\DESCRIPTION\\System\\FloatingPointProcessor" + REGSTR_PATH_FLOATINGPOINTPROCESSOR0* = "HARDWARE\\DESCRIPTION\\System\\FloatingPointProcessor\\0" + REGSTR_PATH_COMPUTRNAME* = "System\\CurrentControlSet\\Control\\ComputerName\\ComputerName" + REGSTR_VAL_COMPUTRNAME* = "ComputerName" + REGSTR_PATH_SHUTDOWN* = "System\\CurrentControlSet\\Control\\Shutdown" + REGSTR_VAL_FORCEREBOOT* = "ForceReboot" + REGSTR_VAL_SETUPPROGRAMRAN* = "SetupProgramRan" + REGSTR_VAL_DOES_POLLING* = "PollingSupportNeeded" + REGSTR_PATH_KNOWNDLLS* = "System\\CurrentControlSet\\Control\\SessionManager\\KnownDLLs" + REGSTR_PATH_KNOWN16DLLS* = "System\\CurrentControlSet\\Control\\SessionManager\\Known16DLLs" + REGSTR_PATH_CHECKVERDLLS* = "System\\CurrentControlSet\\Control\\SessionManager\\CheckVerDLLs" + REGSTR_PATH_WARNVERDLLS* = "System\\CurrentControlSet\\Control\\SessionManager\\WarnVerDLLs" + REGSTR_PATH_HACKINIFILE* = "System\\CurrentControlSet\\Control\\SessionManager\\HackIniFiles" + REGSTR_PATH_CHECKBADAPPS* = "System\\CurrentControlSet\\Control\\SessionManager\\CheckBadApps" + REGSTR_PATH_APPPATCH* = "System\\CurrentControlSet\\Control\\SessionManager\\AppPatches" + REGSTR_PATH_CHECKBADAPPS400* = "System\\CurrentControlSet\\Control\\SessionManager\\CheckBadApps400" + REGSTR_PATH_SHELLSERVICEOBJECT* = "Software\\Microsoft\\Windows\\CurrentVersion\\ShellServiceObject" + REGSTR_PATH_SHELLSERVICEOBJECTDELAYED* = "Software\\Microsoft\\Windows\\CurrentVersion\\ShellServiceObjectDelayLoad" + REGSTR_PATH_KNOWNVXDS* = "System\\CurrentControlSet\\Control\\SessionManager\\KnownVxDs" + REGSTR_VAL_UNINSTALLER_DISPLAYNAME* = "DisplayName" + REGSTR_VAL_UNINSTALLER_COMMANDLINE* = "UninstallString" + REGSTR_VAL_REINSTALL_DISPLAYNAME* = "DisplayName" + REGSTR_VAL_REINSTALL_STRING* = "ReinstallString" + REGSTR_VAL_REINSTALL_DEVICEINSTANCEIDS* = "DeviceInstanceIds" + REGSTR_PATH_DESKTOP* = REGSTR_PATH_SCREENSAVE + REGSTR_PATH_MOUSE* = "Control Panel\\Mouse" + REGSTR_PATH_KEYBOARD* = "Control Panel\\Keyboard" + REGSTR_PATH_COLORS* = "Control Panel\\Colors" + REGSTR_PATH_SOUND* = "Control Panel\\Sound" + REGSTR_PATH_METRICS* = "Control Panel\\Desktop\\WindowMetrics" + REGSTR_PATH_ICONS* = "Control Panel\\Icons" + REGSTR_PATH_CURSORS* = "Control Panel\\Cursors" + REGSTR_PATH_CHECKDISK* = "Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Check Drive" + REGSTR_PATH_CHECKDISKSET* = "Settings" + REGSTR_PATH_CHECKDISKUDRVS* = "NoUnknownDDErrDrvs" + REGSTR_PATH_FAULT* = "Software\\Microsoft\\Windows\\CurrentVersion\\Fault" + REGSTR_VAL_FAULT_LOGFILE* = "LogFile" + REGSTR_PATH_AEDEBUG* = "Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug" + REGSTR_VAL_AEDEBUG_DEBUGGER* = "Debugger" + REGSTR_VAL_AEDEBUG_AUTO* = "Auto" + REGSTR_PATH_GRPCONV* = "Software\\Microsoft\\Windows\\CurrentVersion\\GrpConv" + REGSTR_VAL_REGITEMDELETEMESSAGE* = "Removal Message" + REGSTR_PATH_LASTCHECK* = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\LastCheck" + REGSTR_PATH_LASTOPTIMIZE* = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\LastOptimize" + REGSTR_PATH_LASTBACKUP* = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\LastBackup" + REGSTR_PATH_CHKLASTCHECK* = "Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Check Drive\\LastCheck" + REGSTR_PATH_CHKLASTSURFAN* = "Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Check Drive\\LastSurfaceAnalysis" + DTRESULTOK* = 0 + DTRESULTFIX* = 1 + DTRESULTPROB* = 2 + DTRESULTPART* = 3 + REGSTR_KEY_SHARES* = "Software\\Microsoft\\Windows\\CurrentVersion\\Network\\LanMan" + REGSTR_VAL_SHARES_FLAGS* = "Flags" + REGSTR_VAL_SHARES_TYPE* = "Type" + REGSTR_VAL_SHARES_PATH* = "Path" + REGSTR_VAL_SHARES_REMARK* = "Remark" + REGSTR_VAL_SHARES_RW_PASS* = "Parm1" + REGSTR_VAL_SHARES_RO_PASS* = "Parm2" + REGSTR_PATH_PRINT* = "System\\CurrentControlSet\\Control\\Print" + REGSTR_PATH_PRINTERS* = "System\\CurrentControlSet\\Control\\Print\\Printers" + REGSTR_PATH_PROVIDERS* = "System\\CurrentControlSet\\Control\\Print\\Providers" + REGSTR_PATH_MONITORS* = "System\\CurrentControlSet\\Control\\Print\\Monitors" + REGSTR_PATH_ENVIRONMENTS* = "System\\CurrentControlSet\\Control\\Print\\Environments" + REGSTR_VAL_START_ON_BOOT* = "StartOnBoot" + REGSTR_VAL_PRINTERS_MASK* = "PrintersMask" + REGSTR_VAL_DOS_SPOOL_MASK* = "DOSSpoolMask" + REGSTR_KEY_CURRENT_ENV* = "\\Windows 4.0" + REGSTR_KEY_DRIVERS* = "\\Drivers" + REGSTR_KEY_PRINT_PROC* = "\\Print Processors" + REGSTR_PATH_EVENTLABELS* = "AppEvents\\EventLabels" + REGSTR_PATH_SCHEMES* = "AppEvents\\Schemes" + REGSTR_PATH_APPS* = REGSTR_PATH_SCHEMES & "\\Apps" + REGSTR_PATH_APPS_DEFAULT* = REGSTR_PATH_SCHEMES & "\\Apps\\.Default" + REGSTR_PATH_NAMES* = REGSTR_PATH_SCHEMES & "\\Names" + REGSTR_PATH_MULTIMEDIA* = REGSTR_PATH_SETUP & "\\Multimedia" + REGSTR_PATH_MULTIMEDIA_AUDIO* = "Software\\Microsoft\\Multimedia\\Audio" + REGSTR_PATH_MULTIMEDIA_AUDIO_IMAGES* = REGSTR_PATH_MULTIMEDIA_AUDIO & "\\Images" + REGSTR_PATH_MEDIARESOURCES* = REGSTR_PATH_CURRENT_CONTROL_SET & "\\MediaResources" + REGSTR_PATH_MEDIAPROPERTIES* = REGSTR_PATH_CURRENT_CONTROL_SET & "\\MediaProperties" + REGSTR_PATH_PRIVATEPROPERTIES* = REGSTR_PATH_MEDIAPROPERTIES & "\\PrivateProperties" + REGSTR_PATH_PUBLICPROPERTIES* = REGSTR_PATH_MEDIAPROPERTIES & "\\PublicProperties" + REGSTR_PATH_JOYOEM* = REGSTR_PATH_PRIVATEPROPERTIES & "\\Joystick\\OEM" + REGSTR_PATH_JOYCONFIG* = REGSTR_PATH_MEDIARESOURCES & "\\Joystick" + REGSTR_KEY_JOYCURR* = "CurrentJoystickSettings" + REGSTR_KEY_JOYSETTINGS* = "JoystickSettings" + REGSTR_VAL_JOYUSERVALUES* = "JoystickUserValues" + REGSTR_VAL_JOYCALLOUT* = "JoystickCallout" + REGSTR_VAL_JOYNCONFIG* = "Joystick%dConfiguration" + REGSTR_VAL_JOYNOEMNAME* = "Joystick%dOEMName" + REGSTR_VAL_JOYNOEMCALLOUT* = "Joystick%dOEMCallout" + REGSTR_VAL_JOYOEMCALLOUT* = "OEMCallout" + REGSTR_VAL_JOYOEMNAME* = "OEMName" + REGSTR_VAL_JOYOEMDATA* = "OEMData" + REGSTR_VAL_JOYOEMXYLABEL* = "OEMXYLabel" + REGSTR_VAL_JOYOEMZLABEL* = "OEMZLabel" + REGSTR_VAL_JOYOEMRLABEL* = "OEMRLabel" + REGSTR_VAL_JOYOEMPOVLABEL* = "OEMPOVLabel" + REGSTR_VAL_JOYOEMULABEL* = "OEMULabel" + REGSTR_VAL_JOYOEMVLABEL* = "OEMVLabel" + REGSTR_VAL_JOYOEMTESTMOVEDESC* = "OEMTestMoveDesc" + REGSTR_VAL_JOYOEMTESTBUTTONDESC* = "OEMTestButtonDesc" + REGSTR_VAL_JOYOEMTESTMOVECAP* = "OEMTestMoveCap" + REGSTR_VAL_JOYOEMTESTBUTTONCAP* = "OEMTestButtonCap" + REGSTR_VAL_JOYOEMTESTWINCAP* = "OEMTestWinCap" + REGSTR_VAL_JOYOEMCALCAP* = "OEMCalCap" + REGSTR_VAL_JOYOEMCALWINCAP* = "OEMCalWinCap" + REGSTR_VAL_JOYOEMCAL1* = "OEMCal1" + REGSTR_VAL_JOYOEMCAL2* = "OEMCal2" + REGSTR_VAL_JOYOEMCAL3* = "OEMCal3" + REGSTR_VAL_JOYOEMCAL4* = "OEMCal4" + REGSTR_VAL_JOYOEMCAL5* = "OEMCal5" + REGSTR_VAL_JOYOEMCAL6* = "OEMCal6" + REGSTR_VAL_JOYOEMCAL7* = "OEMCal7" + REGSTR_VAL_JOYOEMCAL8* = "OEMCal8" + REGSTR_VAL_JOYOEMCAL9* = "OEMCal9" + REGSTR_VAL_JOYOEMCAL10* = "OEMCal10" + REGSTR_VAL_JOYOEMCAL11* = "OEMCal11" + REGSTR_VAL_JOYOEMCAL12* = "OEMCal12" + REGSTR_VAL_AUDIO_BITMAP* = "bitmap" + REGSTR_VAL_AUDIO_ICON* = "icon" + REGSTR_PATH_DEVICEINSTALLER* = "Software\\Microsoft\\Windows\\CurrentVersion\\Device Installer" + REGSTR_PATH_DIFX* = "Software\\Microsoft\\Windows\\CurrentVersion\\DIFX" + REGSTR_VAL_SEARCHOPTIONS* = "SearchOptions" + REGSTR_PATH_BIOSINFO* = "System\\CurrentControlSet\\Control\\BiosInfo" + REGSTR_PATH_PCIIR* = "System\\CurrentControlSet\\Control\\Pnp\\PciIrqRouting" + REGSTR_VAL_OPTIONS* = "Options" + REGSTR_VAL_STAT* = "Status" + REGSTR_VAL_TABLE_STAT* = "TableStatus" + REGSTR_VAL_MINIPORT_STAT* = "MiniportStatus" + PIR_OPTION_ENABLED* = 0x00000001 + PIR_OPTION_REGISTRY* = 0x00000002 + PIR_OPTION_MSSPEC* = 0x00000004 + PIR_OPTION_REALMODE* = 0x00000008 + PIR_OPTION_DEFAULT* = 0x0000000f + PIR_STATUS_ERROR* = 0x00000000 + PIR_STATUS_ENABLED* = 0x00000001 + PIR_STATUS_DISABLED* = 0x00000002 + PIR_STATUS_MAX* = 0x00000003 + PIR_STATUS_TABLE_REGISTRY* = 0x00000000 + PIR_STATUS_TABLE_MSSPEC* = 0x00000001 + PIR_STATUS_TABLE_REALMODE* = 0x00000002 + PIR_STATUS_TABLE_NONE* = 0x00000003 + PIR_STATUS_TABLE_ERROR* = 0x00000004 + PIR_STATUS_TABLE_BAD* = 0x00000005 + PIR_STATUS_TABLE_SUCCESS* = 0x00000006 + PIR_STATUS_TABLE_MAX* = 0x00000007 + PIR_STATUS_MINIPORT_NORMAL* = 0x00000000 + PIR_STATUS_MINIPORT_COMPATIBLE* = 0x00000001 + PIR_STATUS_MINIPORT_OVERRIDE* = 0x00000002 + PIR_STATUS_MINIPORT_NONE* = 0x00000003 + PIR_STATUS_MINIPORT_ERROR* = 0x00000004 + PIR_STATUS_MINIPORT_NOKEY* = 0x00000005 + PIR_STATUS_MINIPORT_SUCCESS* = 0x00000006 + PIR_STATUS_MINIPORT_INVALID* = 0x00000007 + PIR_STATUS_MINIPORT_MAX* = 0x00000008 + REGSTR_PATH_LASTGOOD* = "System\\LastKnownGoodRecovery\\LastGood" + REGSTR_PATH_LASTGOODTMP* = "System\\LastKnownGoodRecovery\\LastGood.Tmp" + LASTGOOD_OPERATION* = 0x000000ff + LASTGOOD_OPERATION_NOPOSTPROC* = 0x00000000 + LASTGOOD_OPERATION_DELETE* = 0x00000001 + REGSTR_PATH_EBD* = REGSTR_PATH_SETUP & REGSTR_KEY_SETUP & "\\EBD" diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/richedit.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/richedit.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1051 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import winuser +import objbase +#include +#include +type + TEXTMODE* = int32 + UNDONAMEID* = int32 + KHYPH* = int32 + REOBJECT* {.pure.} = object + cbStruct*: DWORD + cp*: LONG + clsid*: CLSID + poleobj*: LPOLEOBJECT + pstg*: LPSTORAGE + polesite*: LPOLECLIENTSITE + sizel*: SIZEL + dvaspect*: DWORD + dwFlags*: DWORD + dwUser*: DWORD + CHARRANGE* {.pure.} = object + cpMin*: LONG + cpMax*: LONG + IRichEditOle* {.pure.} = object + lpVtbl*: ptr IRichEditOleVtbl + IRichEditOleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetClientSite*: proc(self: ptr IRichEditOle, lplpolesite: ptr LPOLECLIENTSITE): HRESULT {.stdcall.} + GetObjectCount*: proc(self: ptr IRichEditOle): LONG {.stdcall.} + GetLinkCount*: proc(self: ptr IRichEditOle): LONG {.stdcall.} + GetObject*: proc(self: ptr IRichEditOle, iob: LONG, lpreobject: ptr REOBJECT, dwFlags: DWORD): HRESULT {.stdcall.} + InsertObject*: proc(self: ptr IRichEditOle, lpreobject: ptr REOBJECT): HRESULT {.stdcall.} + ConvertObject*: proc(self: ptr IRichEditOle, iob: LONG, rclsidNew: REFCLSID, lpstrUserTypeNew: LPCSTR): HRESULT {.stdcall.} + ActivateAs*: proc(self: ptr IRichEditOle, rclsid: REFCLSID, rclsidAs: REFCLSID): HRESULT {.stdcall.} + SetHostNames*: proc(self: ptr IRichEditOle, lpstrContainerApp: LPCSTR, lpstrContainerObj: LPCSTR): HRESULT {.stdcall.} + SetLinkAvailable*: proc(self: ptr IRichEditOle, iob: LONG, fAvailable: WINBOOL): HRESULT {.stdcall.} + SetDvaspect*: proc(self: ptr IRichEditOle, iob: LONG, dvaspect: DWORD): HRESULT {.stdcall.} + HandsOffStorage*: proc(self: ptr IRichEditOle, iob: LONG): HRESULT {.stdcall.} + SaveCompleted*: proc(self: ptr IRichEditOle, iob: LONG, lpstg: LPSTORAGE): HRESULT {.stdcall.} + InPlaceDeactivate*: proc(self: ptr IRichEditOle): HRESULT {.stdcall.} + ContextSensitiveHelp*: proc(self: ptr IRichEditOle, fEnterMode: WINBOOL): HRESULT {.stdcall.} + GetClipboardData*: proc(self: ptr IRichEditOle, lpchrg: ptr CHARRANGE, reco: DWORD, lplpdataobj: ptr LPDATAOBJECT): HRESULT {.stdcall.} + ImportDataObject*: proc(self: ptr IRichEditOle, lpdataobj: LPDATAOBJECT, cf: CLIPFORMAT, hMetaPict: HGLOBAL): HRESULT {.stdcall.} + LPRICHEDITOLE* = ptr IRichEditOle + IRichEditOleCallback* {.pure.} = object + lpVtbl*: ptr IRichEditOleCallbackVtbl + IRichEditOleCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetNewStorage*: proc(self: ptr IRichEditOleCallback, lplpstg: ptr LPSTORAGE): HRESULT {.stdcall.} + GetInPlaceContext*: proc(self: ptr IRichEditOleCallback, lplpFrame: ptr LPOLEINPLACEFRAME, lplpDoc: ptr LPOLEINPLACEUIWINDOW, lpFrameInfo: LPOLEINPLACEFRAMEINFO): HRESULT {.stdcall.} + ShowContainerUI*: proc(self: ptr IRichEditOleCallback, fShow: WINBOOL): HRESULT {.stdcall.} + QueryInsertObject*: proc(self: ptr IRichEditOleCallback, lpclsid: LPCLSID, lpstg: LPSTORAGE, cp: LONG): HRESULT {.stdcall.} + DeleteObject*: proc(self: ptr IRichEditOleCallback, lpoleobj: LPOLEOBJECT): HRESULT {.stdcall.} + QueryAcceptData*: proc(self: ptr IRichEditOleCallback, lpdataobj: LPDATAOBJECT, lpcfFormat: ptr CLIPFORMAT, reco: DWORD, fReally: WINBOOL, hMetaPict: HGLOBAL): HRESULT {.stdcall.} + ContextSensitiveHelp*: proc(self: ptr IRichEditOleCallback, fEnterMode: WINBOOL): HRESULT {.stdcall.} + GetClipboardData*: proc(self: ptr IRichEditOleCallback, lpchrg: ptr CHARRANGE, reco: DWORD, lplpdataobj: ptr LPDATAOBJECT): HRESULT {.stdcall.} + GetDragDropEffect*: proc(self: ptr IRichEditOleCallback, fDrag: WINBOOL, grfKeyState: DWORD, pdwEffect: LPDWORD): HRESULT {.stdcall.} + GetContextMenu*: proc(self: ptr IRichEditOleCallback, seltype: WORD, lpoleobj: LPOLEOBJECT, lpchrg: ptr CHARRANGE, lphmenu: ptr HMENU): HRESULT {.stdcall.} + LPRICHEDITOLECALLBACK* = ptr IRichEditOleCallback +const + RICHEDIT_VER* = 0x0800 + cchTextLimitDefault* = 32767 + MSFTEDIT_CLASS* = "RICHEDIT50W" + CERICHEDIT_CLASSA* = "RichEditCEA" + CERICHEDIT_CLASSW* = "RichEditCEW" + RICHEDIT_CLASSA* = "RichEdit20A" + RICHEDIT_CLASS10A* = "RICHEDIT" + RICHEDIT_CLASSW* = "RichEdit20W" + EM_CANPASTE* = WM_USER+50 + EM_DISPLAYBAND* = WM_USER+51 + EM_EXGETSEL* = WM_USER+52 + EM_EXLIMITTEXT* = WM_USER+53 + EM_EXLINEFROMCHAR* = WM_USER+54 + EM_EXSETSEL* = WM_USER+55 + EM_FINDTEXT* = WM_USER+56 + EM_FORMATRANGE* = WM_USER+57 + EM_GETCHARFORMAT* = WM_USER+58 + EM_GETEVENTMASK* = WM_USER+59 + EM_GETOLEINTERFACE* = WM_USER+60 + EM_GETPARAFORMAT* = WM_USER+61 + EM_GETSELTEXT* = WM_USER+62 + EM_HIDESELECTION* = WM_USER+63 + EM_PASTESPECIAL* = WM_USER+64 + EM_REQUESTRESIZE* = WM_USER+65 + EM_SELECTIONTYPE* = WM_USER+66 + EM_SETBKGNDCOLOR* = WM_USER+67 + EM_SETCHARFORMAT* = WM_USER+68 + EM_SETEVENTMASK* = WM_USER+69 + EM_SETOLECALLBACK* = WM_USER+70 + EM_SETPARAFORMAT* = WM_USER+71 + EM_SETTARGETDEVICE* = WM_USER+72 + EM_STREAMIN* = WM_USER+73 + EM_STREAMOUT* = WM_USER+74 + EM_GETTEXTRANGE* = WM_USER+75 + EM_FINDWORDBREAK* = WM_USER+76 + EM_SETOPTIONS* = WM_USER+77 + EM_GETOPTIONS* = WM_USER+78 + EM_FINDTEXTEX* = WM_USER+79 + EM_GETWORDBREAKPROCEX* = WM_USER+80 + EM_SETWORDBREAKPROCEX* = WM_USER+81 + EM_SETUNDOLIMIT* = WM_USER+82 + EM_REDO* = WM_USER+84 + EM_CANREDO* = WM_USER+85 + EM_GETUNDONAME* = WM_USER+86 + EM_GETREDONAME* = WM_USER+87 + EM_STOPGROUPTYPING* = WM_USER+88 + EM_SETTEXTMODE* = WM_USER+89 + EM_GETTEXTMODE* = WM_USER+90 + TM_PLAINTEXT* = 1 + TM_RICHTEXT* = 2 + TM_SINGLELEVELUNDO* = 4 + TM_MULTILEVELUNDO* = 8 + TM_SINGLECODEPAGE* = 16 + TM_MULTICODEPAGE* = 32 + EM_AUTOURLDETECT* = WM_USER+91 + AURL_ENABLEURL* = 1 + AURL_ENABLEEMAILADDR* = 2 + AURL_ENABLETELNO* = 4 + AURL_ENABLEEAURLS* = 8 + AURL_ENABLEDRIVELETTERS* = 16 + AURL_DISABLEMIXEDLGC* = 32 + EM_GETAUTOURLDETECT* = WM_USER+92 + EM_SETPALETTE* = WM_USER+93 + EM_GETTEXTEX* = WM_USER+94 + EM_GETTEXTLENGTHEX* = WM_USER+95 + EM_SHOWSCROLLBAR* = WM_USER+96 + EM_SETTEXTEX* = WM_USER+97 + EM_SETPUNCTUATION* = WM_USER+100 + EM_GETPUNCTUATION* = WM_USER+101 + EM_SETWORDWRAPMODE* = WM_USER+102 + EM_GETWORDWRAPMODE* = WM_USER+103 + EM_SETIMECOLOR* = WM_USER+104 + EM_GETIMECOLOR* = WM_USER+105 + EM_SETIMEOPTIONS* = WM_USER+106 + EM_GETIMEOPTIONS* = WM_USER+107 + EM_CONVPOSITION* = WM_USER+108 + EM_SETLANGOPTIONS* = WM_USER+120 + EM_GETLANGOPTIONS* = WM_USER+121 + EM_GETIMECOMPMODE* = WM_USER+122 + EM_FINDTEXTW* = WM_USER+123 + EM_FINDTEXTEXW* = WM_USER+124 + EM_RECONVERSION* = WM_USER+125 + EM_SETIMEMODEBIAS* = WM_USER+126 + EM_GETIMEMODEBIAS* = WM_USER+127 + EM_SETBIDIOPTIONS* = WM_USER+200 + EM_GETBIDIOPTIONS* = WM_USER+201 + EM_SETTYPOGRAPHYOPTIONS* = WM_USER+202 + EM_GETTYPOGRAPHYOPTIONS* = WM_USER+203 + EM_SETEDITSTYLE* = WM_USER+204 + EM_GETEDITSTYLE* = WM_USER+205 + SES_EMULATESYSEDIT* = 1 + SES_BEEPONMAXTEXT* = 2 + SES_EXTENDBACKCOLOR* = 4 + SES_MAPCPS* = 8 + SES_HYPERLINKTOOLTIPS* = 8 + SES_EMULATE10* = 16 + SES_DEFAULTLATINLIGA* = 16 + SES_USECRLF* = 32 + SES_USEAIMM* = 64 + SES_NOIME* = 128 + SES_ALLOWBEEPS* = 256 + SES_UPPERCASE* = 512 + SES_LOWERCASE* = 1024 + SES_NOINPUTSEQUENCECHK* = 2048 + SES_BIDI* = 4096 + SES_SCROLLONKILLFOCUS* = 8192 + SES_XLTCRCRLFTOCR* = 16384 + SES_DRAFTMODE* = 32768 + SES_USECTF* = 0x00010000 + SES_HIDEGRIDLINES* = 0x00020000 + SES_USEATFONT* = 0x00040000 + SES_CUSTOMLOOK* = 0x00080000 + SES_LBSCROLLNOTIFY* = 0x00100000 + SES_CTFALLOWEMBED* = 0x00200000 + SES_CTFALLOWSMARTTAG* = 0x00400000 + SES_CTFALLOWPROOFING* = 0x00800000 + SES_LOGICALCARET* = 0x01000000 + SES_WORDDRAGDROP* = 0x02000000 + SES_SMARTDRAGDROP* = 0x04000000 + SES_MULTISELECT* = 0x08000000 + SES_CTFNOLOCK* = 0x10000000 + SES_NOEALINEHEIGHTADJUST* = 0x20000000 + SES_MAX* = 0x20000000 + IMF_AUTOKEYBOARD* = 0x0001 + IMF_AUTOFONT* = 0x0002 + IMF_IMECANCELCOMPLETE* = 0x0004 + IMF_IMEALWAYSSENDNOTIFY* = 0x0008 + IMF_AUTOFONTSIZEADJUST* = 0x0010 + IMF_UIFONTS* = 0x0020 + IMF_NOIMPLICITLANG* = 0x0040 + IMF_DUALFONT* = 0x0080 + IMF_NOKBDLIDFIXUP* = 0x0200 + IMF_NORTFFONTSUBSTITUTE* = 0x0400 + IMF_SPELLCHECKING* = 0x0800 + IMF_TKBPREDICTION* = 0x1000 + ICM_NOTOPEN* = 0x0000 + ICM_LEVEL3* = 0x0001 + ICM_LEVEL2* = 0x0002 + ICM_LEVEL2_5* = 0x0003 + ICM_LEVEL2_SUI* = 0x0004 + ICM_CTF* = 0x0005 + TO_ADVANCEDTYPOGRAPHY* = 0x0001 + TO_SIMPLELINEBREAK* = 0x0002 + TO_DISABLECUSTOMTEXTOUT* = 0x0004 + TO_ADVANCEDLAYOUT* = 0x0008 + EM_OUTLINE* = WM_USER+220 + EM_GETSCROLLPOS* = WM_USER+221 + EM_SETSCROLLPOS* = WM_USER+222 + EM_SETFONTSIZE* = WM_USER+223 + EM_GETZOOM* = WM_USER+224 + EM_SETZOOM* = WM_USER+225 + EM_GETVIEWKIND* = WM_USER+226 + EM_SETVIEWKIND* = WM_USER+227 + EM_GETPAGE* = WM_USER+228 + EM_SETPAGE* = WM_USER+229 + EM_GETHYPHENATEINFO* = WM_USER+230 + EM_SETHYPHENATEINFO* = WM_USER+231 + EM_GETPAGEROTATE* = WM_USER+235 + EM_SETPAGEROTATE* = WM_USER+236 + EM_GETCTFMODEBIAS* = WM_USER+237 + EM_SETCTFMODEBIAS* = WM_USER+238 + EM_GETCTFOPENSTATUS* = WM_USER+240 + EM_SETCTFOPENSTATUS* = WM_USER+241 + EM_GETIMECOMPTEXT* = WM_USER+242 + EM_ISIME* = WM_USER+243 + EM_GETIMEPROPERTY* = WM_USER+244 + EM_GETQUERYRTFOBJ* = WM_USER+269 + EM_SETQUERYRTFOBJ* = WM_USER+270 + EPR_0* = 0 + EPR_270* = 1 + EPR_180* = 2 + EPR_90* = 3 + EPR_SE* = 5 + CTFMODEBIAS_DEFAULT* = 0x0000 + CTFMODEBIAS_FILENAME* = 0x0001 + CTFMODEBIAS_NAME* = 0x0002 + CTFMODEBIAS_READING* = 0x0003 + CTFMODEBIAS_DATETIME* = 0x0004 + CTFMODEBIAS_CONVERSATION* = 0x0005 + CTFMODEBIAS_NUMERIC* = 0x0006 + CTFMODEBIAS_HIRAGANA* = 0x0007 + CTFMODEBIAS_KATAKANA* = 0x0008 + CTFMODEBIAS_HANGUL* = 0x0009 + CTFMODEBIAS_HALFWIDTHKATAKANA* = 0x000a + CTFMODEBIAS_FULLWIDTHALPHANUMERIC* = 0x000b + CTFMODEBIAS_HALFWIDTHALPHANUMERIC* = 0x000c + IMF_SMODE_PLAURALCLAUSE* = 0x0001 + IMF_SMODE_NONE* = 0x0002 + ICT_RESULTREADSTR* = 1 + EMO_EXIT* = 0 + EMO_ENTER* = 1 + EMO_PROMOTE* = 2 + EMO_EXPAND* = 3 + EMO_MOVESELECTION* = 4 + EMO_GETVIEWMODE* = 5 + EMO_EXPANDSELECTION* = 0 + EMO_EXPANDDOCUMENT* = 1 + VM_NORMAL* = 4 + VM_OUTLINE* = 2 + VM_PAGE* = 9 + EM_INSERTTABLE* = WM_USER+232 + EM_GETAUTOCORRECTPROC* = WM_USER+233 + EM_SETAUTOCORRECTPROC* = WM_USER+234 + EM_CALLAUTOCORRECTPROC* = WM_USER+255 + ATP_NOCHANGE* = 0 + ATP_CHANGE* = 1 + ATP_NODELIMITER* = 2 + ATP_REPLACEALLTEXT* = 4 + EM_GETTABLEPARMS* = WM_USER+265 + EM_SETEDITSTYLEEX* = WM_USER+275 + EM_GETEDITSTYLEEX* = WM_USER+276 + SES_EX_NOTABLE* = 0x00000004 + SES_EX_HANDLEFRIENDLYURL* = 0x00000100 + SES_EX_NOTHEMING* = 0x00080000 + SES_EX_NOACETATESELECTION* = 0x00100000 + SES_EX_USESINGLELINE* = 0x00200000 + SES_EX_MULTITOUCH* = 0x08000000 + SES_EX_HIDETEMPFORMAT* = 0x10000000 + SES_EX_USEMOUSEWPARAM* = 0x20000000 + EM_GETSTORYTYPE* = WM_USER+290 + EM_SETSTORYTYPE* = WM_USER+291 + EM_GETELLIPSISMODE* = WM_USER+305 + EM_SETELLIPSISMODE* = WM_USER+306 + ELLIPSIS_MASK* = 0x00000003 + ELLIPSIS_NONE* = 0x00000000 + ELLIPSIS_END* = 0x00000001 + ELLIPSIS_WORD* = 0x00000003 + EM_SETTABLEPARMS* = WM_USER+307 + EM_GETTOUCHOPTIONS* = WM_USER+310 + EM_SETTOUCHOPTIONS* = WM_USER+311 + EM_INSERTIMAGE* = WM_USER+314 + EM_SETUIANAME* = WM_USER+320 + EM_GETELLIPSISSTATE* = WM_USER+322 + RTO_SHOWHANDLES* = 1 + RTO_DISABLEHANDLES* = 2 + RTO_READINGMODE* = 3 + EN_MSGFILTER* = 0x0700 + EN_REQUESTRESIZE* = 0x0701 + EN_SELCHANGE* = 0x0702 + EN_DROPFILES* = 0x0703 + EN_PROTECTED* = 0x0704 + EN_CORRECTTEXT* = 0x0705 + EN_STOPNOUNDO* = 0x0706 + EN_IMECHANGE* = 0x0707 + EN_SAVECLIPBOARD* = 0x0708 + EN_OLEOPFAILED* = 0x0709 + EN_OBJECTPOSITIONS* = 0x070a + EN_LINK* = 0x070b + EN_DRAGDROPDONE* = 0x070c + EN_PARAGRAPHEXPANDED* = 0x070d + EN_PAGECHANGE* = 0x070e + EN_LOWFIRTF* = 0x070f + EN_ALIGNLTR* = 0x0710 + EN_ALIGNRTL* = 0x0711 + EN_CLIPFORMAT* = 0x0712 + EN_STARTCOMPOSITION* = 0x0713 + EN_ENDCOMPOSITION* = 0x0714 + ECN_ENDCOMPOSITION* = 0x0001 + ECN_NEWTEXT* = 0x0002 + ENM_NONE* = 0x00000000 + ENM_CHANGE* = 0x00000001 + ENM_UPDATE* = 0x00000002 + ENM_SCROLL* = 0x00000004 + ENM_SCROLLEVENTS* = 0x00000008 + ENM_DRAGDROPDONE* = 0x00000010 + ENM_PARAGRAPHEXPANDED* = 0x00000020 + ENM_PAGECHANGE* = 0x00000040 + ENM_CLIPFORMAT* = 0x00000080 + ENM_KEYEVENTS* = 0x00010000 + ENM_MOUSEEVENTS* = 0x00020000 + ENM_REQUESTRESIZE* = 0x00040000 + ENM_SELCHANGE* = 0x00080000 + ENM_DROPFILES* = 0x00100000 + ENM_PROTECTED* = 0x00200000 + ENM_CORRECTTEXT* = 0x00400000 + ENM_IMECHANGE* = 0x00800000 + ENM_LANGCHANGE* = 0x01000000 + ENM_OBJECTPOSITIONS* = 0x02000000 + ENM_LINK* = 0x04000000 + ENM_LOWFIRTF* = 0x08000000 + ENM_STARTCOMPOSITION* = 0x10000000 + ENM_ENDCOMPOSITION* = 0x20000000 + ENM_GROUPTYPINGCHANGE* = 0x40000000 + ENM_HIDELINKTOOLTIP* = 0x80000000'i32 + ES_SAVESEL* = 0x00008000 + ES_SUNKEN* = 0x00004000 + ES_DISABLENOSCROLL* = 0x00002000 + ES_SELECTIONBAR* = 0x01000000 + ES_NOOLEDRAGDROP* = 0x00000008 + ES_EX_NOCALLOLEINIT* = 0x00000000 + ES_VERTICAL* = 0x00400000 + ES_NOIME* = 0x00080000 + ES_SELFIME* = 0x00040000 + ECO_AUTOWORDSELECTION* = 0x00000001 + ECO_AUTOVSCROLL* = 0x00000040 + ECO_AUTOHSCROLL* = 0x00000080 + ECO_NOHIDESEL* = 0x00000100 + ECO_READONLY* = 0x00000800 + ECO_WANTRETURN* = 0x00001000 + ECO_SAVESEL* = 0x00008000 + ECO_SELECTIONBAR* = 0x01000000 + ECO_VERTICAL* = 0x00400000 + ECOOP_SET* = 0x0001 + ECOOP_OR* = 0x0002 + ECOOP_AND* = 0x0003 + ECOOP_XOR* = 0x0004 + WB_CLASSIFY* = 3 + WB_MOVEWORDLEFT* = 4 + WB_MOVEWORDRIGHT* = 5 + WB_LEFTBREAK* = 6 + WB_RIGHTBREAK* = 7 + WB_MOVEWORDPREV* = 4 + WB_MOVEWORDNEXT* = 5 + WB_PREVBREAK* = 6 + WB_NEXTBREAK* = 7 + PC_FOLLOWING* = 1 + PC_LEADING* = 2 + PC_OVERFLOW* = 3 + PC_DELIMITER* = 4 + WBF_WORDWRAP* = 0x010 + WBF_WORDBREAK* = 0x020 + WBF_OVERFLOW* = 0x040 + WBF_LEVEL1* = 0x080 + WBF_LEVEL2* = 0x100 + WBF_CUSTOM* = 0x200 + IMF_FORCENONE* = 0x0001 + IMF_FORCEENABLE* = 0x0002 + IMF_FORCEDISABLE* = 0x0004 + IMF_CLOSESTATUSWINDOW* = 0x0008 + IMF_VERTICAL* = 0x0020 + IMF_FORCEACTIVE* = 0x0040 + IMF_FORCEINACTIVE* = 0x0080 + IMF_FORCEREMEMBER* = 0x0100 + IMF_MULTIPLEEDIT* = 0x0400 + WBF_CLASS* = BYTE 0x0f + WBF_ISWHITE* = BYTE 0x10 + WBF_BREAKLINE* = BYTE 0x20 + WBF_BREAKAFTER* = BYTE 0x40 + CFM_BOLD* = 0x00000001 + CFM_ITALIC* = 0x00000002 + CFM_UNDERLINE* = 0x00000004 + CFM_STRIKEOUT* = 0x00000008 + CFM_PROTECTED* = 0x00000010 + CFM_LINK* = 0x00000020 + CFM_SIZE* = 0x80000000'i32 + CFM_COLOR* = 0x40000000 + CFM_FACE* = 0x20000000 + CFM_OFFSET* = 0x10000000 + CFM_CHARSET* = 0x08000000 + CFE_BOLD* = 0x00000001 + CFE_ITALIC* = 0x00000002 + CFE_UNDERLINE* = 0x00000004 + CFE_STRIKEOUT* = 0x00000008 + CFE_PROTECTED* = 0x00000010 + CFE_LINK* = 0x00000020 + CFE_AUTOCOLOR* = 0x40000000 + CFM_SMALLCAPS* = 0x00000040 + CFM_ALLCAPS* = 0x00000080 + CFM_HIDDEN* = 0x00000100 + CFM_OUTLINE* = 0x00000200 + CFM_SHADOW* = 0x00000400 + CFM_EMBOSS* = 0x00000800 + CFM_IMPRINT* = 0x00001000 + CFM_DISABLED* = 0x00002000 + CFM_REVISED* = 0x00004000 + CFM_REVAUTHOR* = 0x00008000 + CFE_SUBSCRIPT* = 0x00010000 + CFE_SUPERSCRIPT* = 0x00020000 + CFM_ANIMATION* = 0x00040000 + CFM_STYLE* = 0x00080000 + CFM_KERNING* = 0x00100000 + CFM_SPACING* = 0x00200000 + CFM_WEIGHT* = 0x00400000 + CFM_UNDERLINETYPE* = 0x00800000 + CFM_COOKIE* = 0x01000000 + CFM_LCID* = 0x02000000 + CFM_BACKCOLOR* = 0x04000000 + CFM_SUBSCRIPT* = CFE_SUBSCRIPT or CFE_SUPERSCRIPT + CFM_SUPERSCRIPT* = CFM_SUBSCRIPT + CFM_EFFECTS* = CFM_BOLD or CFM_ITALIC or CFM_UNDERLINE or CFM_COLOR or CFM_STRIKEOUT or CFE_PROTECTED or CFM_LINK + CFM_ALL* = CFM_EFFECTS or CFM_SIZE or CFM_FACE or CFM_OFFSET or CFM_CHARSET + CFM_EFFECTS2* = CFM_EFFECTS or CFM_DISABLED or CFM_SMALLCAPS or CFM_ALLCAPS or CFM_HIDDEN or CFM_OUTLINE or CFM_SHADOW or CFM_EMBOSS or CFM_IMPRINT or CFM_REVISED or CFM_SUBSCRIPT or CFM_SUPERSCRIPT or CFM_BACKCOLOR + CFM_ALL2* = CFM_ALL or CFM_EFFECTS2 or CFM_BACKCOLOR or CFM_LCID or CFM_UNDERLINETYPE or CFM_WEIGHT or CFM_REVAUTHOR or CFM_SPACING or CFM_KERNING or CFM_STYLE or CFM_ANIMATION or CFM_COOKIE + CFE_SMALLCAPS* = CFM_SMALLCAPS + CFE_ALLCAPS* = CFM_ALLCAPS + CFE_HIDDEN* = CFM_HIDDEN + CFE_OUTLINE* = CFM_OUTLINE + CFE_SHADOW* = CFM_SHADOW + CFE_EMBOSS* = CFM_EMBOSS + CFE_IMPRINT* = CFM_IMPRINT + CFE_DISABLED* = CFM_DISABLED + CFE_REVISED* = CFM_REVISED + CFE_AUTOBACKCOLOR* = CFM_BACKCOLOR + CFM_FONTBOUND* = 0x00100000 + CFM_LINKPROTECTED* = 0x00800000 + CFM_EXTENDED* = 0x02000000 + CFM_MATHNOBUILDUP* = 0x08000000 + CFM_MATH* = 0x10000000 + CFM_MATHORDINARY* = 0x20000000 + CFM_ALLEFFECTS* = CFM_EFFECTS2 or CFM_FONTBOUND or CFM_EXTENDED or CFM_MATHNOBUILDUP or CFM_MATH or CFM_MATHORDINARY + CFE_FONTBOUND* = 0x00100000 + CFE_LINKPROTECTED* = 0x00800000 + CFE_EXTENDED* = 0x02000000 + CFE_MATHNOBUILDUP* = 0x08000000 + CFE_MATH* = 0x10000000 + CFE_MATHORDINARY* = 0x20000000 + CFU_CF1UNDERLINE* = 0xff + CFU_INVERT* = 0xfe + CFU_UNDERLINETHICKLONGDASH* = 18 + CFU_UNDERLINETHICKDOTTED* = 17 + CFU_UNDERLINETHICKDASHDOTDOT* = 16 + CFU_UNDERLINETHICKDASHDOT* = 15 + CFU_UNDERLINETHICKDASH* = 14 + CFU_UNDERLINELONGDASH* = 13 + CFU_UNDERLINEHEAVYWAVE* = 12 + CFU_UNDERLINEDOUBLEWAVE* = 11 + CFU_UNDERLINEHAIRLINE* = 10 + CFU_UNDERLINETHICK* = 9 + CFU_UNDERLINEWAVE* = 8 + CFU_UNDERLINEDASHDOTDOT* = 7 + CFU_UNDERLINEDASHDOT* = 6 + CFU_UNDERLINEDASH* = 5 + CFU_UNDERLINEDOTTED* = 4 + CFU_UNDERLINEDOUBLE* = 3 + CFU_UNDERLINEWORD* = 2 + CFU_UNDERLINE* = 1 + CFU_UNDERLINENONE* = 0 + yHeightCharPtsMost* = 1638 + SCF_SELECTION* = 0x0001 + SCF_WORD* = 0x0002 + SCF_DEFAULT* = 0x0000 + SCF_ALL* = 0x0004 + SCF_USEUIRULES* = 0x0008 + SCF_ASSOCIATEFONT* = 0x0010 + SCF_NOKBUPDATE* = 0x0020 + SCF_ASSOCIATEFONT2* = 0x0040 + SCF_SMARTFONT* = 0x0080 + SCF_CHARREPFROMLCID* = 0x0100 + SPF_DONTSETDEFAULT* = 0x0002 + SPF_SETDEFAULT* = 0x0004 + SF_TEXT* = 0x0001 + SF_RTF* = 0x0002 + SF_RTFNOOBJS* = 0x0003 + SF_TEXTIZED* = 0x0004 + SF_UNICODE* = 0x0010 + SF_USECODEPAGE* = 0x0020 + SF_NCRFORNONASCII* = 0x40 + SFF_WRITEXTRAPAR* = 0x80 + SFF_SELECTION* = 0x8000 + SFF_PLAINRTF* = 0x4000 + SFF_PERSISTVIEWSCALE* = 0x2000 + SFF_KEEPDOCINFO* = 0x1000 + SFF_PWD* = 0x0800 + SF_RTFVAL* = 0x0700 + MAX_TAB_STOPS* = 32 + lDefaultTab* = 720 + MAX_TABLE_CELLS* = 63 + PFM_STARTINDENT* = 0x00000001 + PFM_RIGHTINDENT* = 0x00000002 + PFM_OFFSET* = 0x00000004 + PFM_ALIGNMENT* = 0x00000008 + PFM_TABSTOPS* = 0x00000010 + PFM_NUMBERING* = 0x00000020 + PFM_OFFSETINDENT* = 0x80000000'i32 + PFM_SPACEBEFORE* = 0x00000040 + PFM_SPACEAFTER* = 0x00000080 + PFM_LINESPACING* = 0x00000100 + PFM_STYLE* = 0x00000400 + PFM_BORDER* = 0x00000800 + PFM_SHADING* = 0x00001000 + PFM_NUMBERINGSTYLE* = 0x00002000 + PFM_NUMBERINGTAB* = 0x00004000 + PFM_NUMBERINGSTART* = 0x00008000 + PFM_RTLPARA* = 0x00010000 + PFM_KEEP* = 0x00020000 + PFM_KEEPNEXT* = 0x00040000 + PFM_PAGEBREAKBEFORE* = 0x00080000 + PFM_NOLINENUMBER* = 0x00100000 + PFM_NOWIDOWCONTROL* = 0x00200000 + PFM_DONOTHYPHEN* = 0x00400000 + PFM_SIDEBYSIDE* = 0x00800000 + PFM_COLLAPSED* = 0x01000000 + PFM_OUTLINELEVEL* = 0x02000000 + PFM_BOX* = 0x04000000 + PFM_RESERVED2* = 0x08000000 + PFM_TABLEROWDELIMITER* = 0x10000000 + PFM_TEXTWRAPPINGBREAK* = 0x20000000 + PFM_TABLE* = 0x40000000 + PFM_ALL* = PFM_STARTINDENT or PFM_RIGHTINDENT or PFM_OFFSET or PFM_ALIGNMENT or PFM_TABSTOPS or PFM_NUMBERING or PFM_OFFSETINDENT or PFM_RTLPARA + PFM_EFFECTS* = PFM_RTLPARA or PFM_KEEP or PFM_KEEPNEXT or PFM_TABLE or PFM_PAGEBREAKBEFORE or PFM_NOLINENUMBER or PFM_NOWIDOWCONTROL or PFM_DONOTHYPHEN or PFM_SIDEBYSIDE or PFM_TABLE or PFM_TABLEROWDELIMITER + PFM_ALL2* = PFM_ALL or PFM_EFFECTS or PFM_SPACEBEFORE or PFM_SPACEAFTER or PFM_LINESPACING or PFM_STYLE or PFM_SHADING or PFM_BORDER or PFM_NUMBERINGTAB or PFM_NUMBERINGSTART or PFM_NUMBERINGSTYLE + PFE_RTLPARA* = PFM_RTLPARA shr 16 + PFE_KEEP* = PFM_KEEP shr 16 + PFE_KEEPNEXT* = PFM_KEEPNEXT shr 16 + PFE_PAGEBREAKBEFORE* = PFM_PAGEBREAKBEFORE shr 16 + PFE_NOLINENUMBER* = PFM_NOLINENUMBER shr 16 + PFE_NOWIDOWCONTROL* = PFM_NOWIDOWCONTROL shr 16 + PFE_DONOTHYPHEN* = PFM_DONOTHYPHEN shr 16 + PFE_SIDEBYSIDE* = PFM_SIDEBYSIDE shr 16 + PFE_TEXTWRAPPINGBREAK* = PFM_TEXTWRAPPINGBREAK shr 16 + PFE_COLLAPSED* = PFM_COLLAPSED shr 16 + PFE_BOX* = PFM_BOX shr 16 + PFE_TABLE* = PFM_TABLE shr 16 + PFE_TABLEROWDELIMITER* = PFM_TABLEROWDELIMITER shr 16 + PFN_BULLET* = 1 + PFN_ARABIC* = 2 + PFN_LCLETTER* = 3 + PFN_UCLETTER* = 4 + PFN_LCROMAN* = 5 + PFN_UCROMAN* = 6 + PFNS_PAREN* = 0x000 + PFNS_PARENS* = 0x100 + PFNS_PERIOD* = 0x200 + PFNS_PLAIN* = 0x300 + PFNS_NONUMBER* = 0x400 + PFNS_NEWNUMBER* = 0x8000 + PFA_LEFT* = 1 + PFA_RIGHT* = 2 + PFA_CENTER* = 3 + PFA_JUSTIFY* = 4 + PFA_FULL_INTERWORD* = 4 + SEL_EMPTY* = 0x0000 + SEL_TEXT* = 0x0001 + SEL_OBJECT* = 0x0002 + SEL_MULTICHAR* = 0x0004 + SEL_MULTIOBJECT* = 0x0008 + GCM_RIGHTMOUSEDROP* = 0x8000 + GCMF_GRIPPER* = 0x00000001 + GCMF_SPELLING* = 0x00000002 + GCMF_TOUCHMENU* = 0x00004000 + GCMF_MOUSEMENU* = 0x00002000 + OLEOP_DOVERB* = 1 + CF_RTF* = "Rich Text Format" + CF_RTFNOOBJS* = "Rich Text Format Without Objects" + CF_RETEXTOBJ* = "RichEdit Text and Objects" + UID_UNKNOWN* = 0 + UID_TYPING* = 1 + UID_DELETE* = 2 + UID_DRAGDROP* = 3 + UID_CUT* = 4 + UID_PASTE* = 5 + UID_AUTOTABLE* = 6 + ST_DEFAULT* = 0 + ST_KEEPUNDO* = 1 + ST_SELECTION* = 2 + ST_NEWCHARS* = 4 + ST_UNICODE* = 8 + GT_DEFAULT* = 0 + GT_USECRLF* = 1 + GT_SELECTION* = 2 + GT_RAWTEXT* = 4 + GT_NOHIDDENTEXT* = 8 + GTL_DEFAULT* = 0 + GTL_USECRLF* = 1 + GTL_PRECISE* = 2 + GTL_CLOSE* = 4 + GTL_NUMCHARS* = 8 + GTL_NUMBYTES* = 16 + BOM_DEFPARADIR* = 0x0001 + BOM_PLAINTEXT* = 0x0002 + BOM_NEUTRALOVERRIDE* = 0x0004 + BOM_CONTEXTREADING* = 0x0008 + BOM_CONTEXTALIGNMENT* = 0x0010 + BOM_LEGACYBIDICLASS* = 0x0040 + BOM_UNICODEBIDI* = 0x0080 + BOE_RTLDIR* = 0x0001 + BOE_PLAINTEXT* = 0x0002 + BOE_NEUTRALOVERRIDE* = 0x0004 + BOE_CONTEXTREADING* = 0x0008 + BOE_CONTEXTALIGNMENT* = 0x0010 + BOE_FORCERECALC* = 0x0020 + BOE_LEGACYBIDICLASS* = 0x0040 + BOE_UNICODEBIDI* = 0x0080 + WCH_EMBEDDING* = WCHAR 0xfffc + khyphNil* = 0 + khyphNormal* = 1 + khyphAddBefore* = 2 + khyphChangeBefore* = 3 + khyphDeleteBefore* = 4 + khyphChangeAfter* = 5 + khyphDelAndChange* = 6 + RICHEDIT60_CLASS* = "RICHEDIT60W" + PFA_FULL_NEWSPAPER* = 5 + PFA_FULL_INTERLETTER* = 6 + PFA_FULL_SCALED* = 7 + PFA_FULL_GLYPHS* = 8 + AURL_ENABLEEA* = 1 + GCM_TOUCHMENU* = 0x4000 + GCM_MOUSEMENU* = 0x2000 + REO_GETOBJ_NO_INTERFACES* = 0x00000000 + REO_GETOBJ_POLEOBJ* = 0x00000001 + REO_GETOBJ_PSTG* = 0x00000002 + REO_GETOBJ_POLESITE* = 0x00000004 + REO_GETOBJ_ALL_INTERFACES* = 0x00000007 + REO_CP_SELECTION* = ULONG(-1) + REO_IOB_SELECTION* = ULONG(-1) + REO_IOB_USE_CP* = ULONG(-2) + REO_NULL* = 0x00000000 + REO_READWRITEMASK* = 0x000007ff + REO_CANROTATE* = 0x00000080 + REO_OWNERDRAWSELECT* = 0x00000040 + REO_DONTNEEDPALETTE* = 0x00000020 + REO_BLANK* = 0x00000010 + REO_DYNAMICSIZE* = 0x00000008 + REO_INVERTEDSELECT* = 0x00000004 + REO_BELOWBASELINE* = 0x00000002 + REO_RESIZABLE* = 0x00000001 + REO_USEASBACKGROUND* = 0x00000400 + REO_WRAPTEXTAROUND* = 0x00000200 + REO_ALIGNTORIGHT* = 0x00000100 + REO_LINK* = 0x80000000'i32 + REO_STATIC* = 0x40000000 + REO_SELECTED* = 0x08000000 + REO_OPEN* = 0x04000000 + REO_INPLACEACTIVE* = 0x02000000 + REO_HILITED* = 0x01000000 + REO_LINKAVAILABLE* = 0x00800000 + REO_GETMETAFILE* = 0x00400000 + RECO_PASTE* = 0x00000000 + RECO_DROP* = 0x00000001 + RECO_COPY* = 0x00000002 + RECO_CUT* = 0x00000003 + RECO_DRAG* = 0x00000004 + IID_IRichEditOle* = DEFINE_GUID("00020d00-0000-0000-c000-000000000046") + IID_IRichEditOleCallback* = DEFINE_GUID("00020d03-0000-0000-c000-000000000046") +type + AutoCorrectProc* = proc (langid: LANGID, pszBefore: ptr WCHAR, pszAfter: ptr WCHAR, cchAfter: LONG, pcchReplaced: ptr LONG): int32 {.stdcall.} + EDITWORDBREAKPROCEX* = proc (pchText: ptr char, cchText: LONG, bCharSet: BYTE, action: INT): LONG {.stdcall.} + EDITSTREAMCALLBACK* = proc (dwCookie: DWORD_PTR, pbBuff: LPBYTE, cb: LONG, pcb: ptr LONG): DWORD {.stdcall.} + IMECOMPTEXT* {.pure.} = object + cb*: LONG + flags*: DWORD + TABLEROWPARMS* {.pure.} = object + cbRow*: BYTE + cbCell*: BYTE + cCell*: BYTE + cRow*: BYTE + dxCellMargin*: LONG + dxIndent*: LONG + dyHeight*: LONG + nAlignment* {.bitsize:3.}: DWORD + fRTL* {.bitsize:1.}: DWORD + fKeep* {.bitsize:1.}: DWORD + fKeepFollow* {.bitsize:1.}: DWORD + fWrap* {.bitsize:1.}: DWORD + fIdentCells* {.bitsize:1.}: DWORD + cpStartRow*: LONG + bTableLevel*: BYTE + iCell*: BYTE + TABLECELLPARMS* {.pure.} = object + dxWidth*: LONG + nVertAlign* {.bitsize:2.}: WORD + fMergeTop* {.bitsize:1.}: WORD + fMergePrev* {.bitsize:1.}: WORD + fVertical* {.bitsize:1.}: WORD + fMergeStart* {.bitsize:1.}: WORD + fMergeCont* {.bitsize:1.}: WORD + wShading*: WORD + dxBrdrLeft*: SHORT + dyBrdrTop*: SHORT + dxBrdrRight*: SHORT + dyBrdrBottom*: SHORT + crBrdrLeft*: COLORREF + crBrdrTop*: COLORREF + crBrdrRight*: COLORREF + crBrdrBottom*: COLORREF + crBackPat*: COLORREF + crForePat*: COLORREF + RICHEDIT_IMAGE_PARAMETERS* {.pure.} = object + xWidth*: LONG + yHeight*: LONG + Ascent*: LONG + Type*: LONG + pwszAlternateText*: LPCWSTR + pIStream*: ptr IStream + ENDCOMPOSITIONNOTIFY* {.pure, packed.} = object + nmhdr*: NMHDR + dwCode*: DWORD + CHARFORMATA* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + dwEffects*: DWORD + yHeight*: LONG + yOffset*: LONG + crTextColor*: COLORREF + bCharSet*: BYTE + bPitchAndFamily*: BYTE + szFaceName*: array[LF_FACESIZE, char] + CHARFORMATW* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + dwEffects*: DWORD + yHeight*: LONG + yOffset*: LONG + crTextColor*: COLORREF + bCharSet*: BYTE + bPitchAndFamily*: BYTE + szFaceName*: array[LF_FACESIZE, WCHAR] + CHARFORMAT2W_UNION1* {.pure, union.} = object + dwReserved*: DWORD + dwCookie*: DWORD + CHARFORMAT2W* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + dwEffects*: DWORD + yHeight*: LONG + yOffset*: LONG + crTextColor*: COLORREF + bCharSet*: BYTE + bPitchAndFamily*: BYTE + szFaceName*: array[LF_FACESIZE, WCHAR] + wWeight*: WORD + sSpacing*: SHORT + crBackColor*: COLORREF + lcid*: LCID + union1*: CHARFORMAT2W_UNION1 + sStyle*: SHORT + wKerning*: WORD + bUnderlineType*: BYTE + bAnimation*: BYTE + bRevAuthor*: BYTE + bUnderlineColor*: BYTE + CHARFORMAT2A_UNION1* {.pure, union.} = object + dwReserved*: DWORD + dwCookie*: DWORD + CHARFORMAT2A* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + dwEffects*: DWORD + yHeight*: LONG + yOffset*: LONG + crTextColor*: COLORREF + bCharSet*: BYTE + bPitchAndFamily*: BYTE + szFaceName*: array[LF_FACESIZE, char] + wWeight*: WORD + sSpacing*: SHORT + crBackColor*: COLORREF + lcid*: LCID + union1*: CHARFORMAT2A_UNION1 + sStyle*: SHORT + wKerning*: WORD + bUnderlineType*: BYTE + bAnimation*: BYTE + bRevAuthor*: BYTE + bUnderlineColor*: BYTE + TEXTRANGEA* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPSTR + TEXTRANGEW* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPWSTR + EDITSTREAM* {.pure, packed.} = object + dwCookie*: DWORD_PTR + dwError*: DWORD + pfnCallback*: EDITSTREAMCALLBACK + TFINDTEXTA* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPCSTR + TFINDTEXTW* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPCWSTR + FINDTEXTEXA* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPCSTR + chrgText*: CHARRANGE + FINDTEXTEXW* {.pure.} = object + chrg*: CHARRANGE + lpstrText*: LPCWSTR + chrgText*: CHARRANGE + FORMATRANGE* {.pure.} = object + hdc*: HDC + hdcTarget*: HDC + rc*: RECT + rcPage*: RECT + chrg*: CHARRANGE + PARAFORMAT_UNION1* {.pure, union.} = object + wReserved*: WORD + wEffects*: WORD + PARAFORMAT* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + wNumbering*: WORD + union1*: PARAFORMAT_UNION1 + dxStartIndent*: LONG + dxRightIndent*: LONG + dxOffset*: LONG + wAlignment*: WORD + cTabCount*: SHORT + rgxTabs*: array[MAX_TAB_STOPS, LONG] + PARAFORMAT2_UNION1* {.pure, union.} = object + wReserved*: WORD + wEffects*: WORD + PARAFORMAT2* {.pure.} = object + cbSize*: UINT + dwMask*: DWORD + wNumbering*: WORD + union1*: PARAFORMAT2_UNION1 + dxStartIndent*: LONG + dxRightIndent*: LONG + dxOffset*: LONG + wAlignment*: WORD + cTabCount*: SHORT + rgxTabs*: array[MAX_TAB_STOPS, LONG] + dySpaceBefore*: LONG + dySpaceAfter*: LONG + dyLineSpacing*: LONG + sStyle*: SHORT + bLineSpacingRule*: BYTE + bOutlineLevel*: BYTE + wShadingWeight*: WORD + wShadingStyle*: WORD + wNumberingStart*: WORD + wNumberingStyle*: WORD + wNumberingTab*: WORD + wBorderSpace*: WORD + wBorderWidth*: WORD + wBorders*: WORD + MSGFILTER* {.pure, packed.} = object + nmhdr*: NMHDR + msg*: UINT + wParam*: WPARAM + lParam*: LPARAM + REQRESIZE* {.pure.} = object + nmhdr*: NMHDR + rc*: RECT + SELCHANGE* {.pure, packed.} = object + nmhdr*: NMHDR + chrg*: CHARRANGE + seltyp*: WORD + padding*: array[2, byte] + GROUPTYPINGCHANGE* {.pure, packed.} = object + nmhdr*: NMHDR + fGroupTyping*: WINBOOL + CLIPBOARDFORMAT* {.pure, packed.} = object + nmhdr*: NMHDR + cf*: CLIPFORMAT + padding*: array[2, byte] + GETCONTEXTMENUEX* {.pure, packed.} = object + chrg*: CHARRANGE + dwFlags*: DWORD + pt*: POINT + pvReserved*: pointer + TENDROPFILES* {.pure.} = object + nmhdr*: NMHDR + hDrop*: HANDLE + cp*: LONG + fProtected*: WINBOOL + TENPROTECTED* {.pure, packed.} = object + nmhdr*: NMHDR + msg*: UINT + wParam*: WPARAM + lParam*: LPARAM + chrg*: CHARRANGE + TENSAVECLIPBOARD* {.pure.} = object + nmhdr*: NMHDR + cObjectCount*: LONG + cch*: LONG + TENOLEOPFAILED* {.pure, packed.} = object + nmhdr*: NMHDR + iob*: LONG + lOper*: LONG + hr*: HRESULT + OBJECTPOSITIONS* {.pure, packed.} = object + nmhdr*: NMHDR + cObjectCount*: LONG + pcpPositions*: ptr LONG + TENLINK* {.pure, packed.} = object + nmhdr*: NMHDR + msg*: UINT + wParam*: WPARAM + lParam*: LPARAM + chrg*: CHARRANGE + TENLOWFIRTF* {.pure.} = object + nmhdr*: NMHDR + szControl*: ptr char + TENCORRECTTEXT* {.pure, packed.} = object + nmhdr*: NMHDR + chrg*: CHARRANGE + seltyp*: WORD + padding*: array[2, byte] + PUNCTUATION* {.pure, packed.} = object + iSize*: UINT + szPunctuation*: LPSTR + COMPCOLOR* {.pure.} = object + crText*: COLORREF + crBackground*: COLORREF + dwEffects*: DWORD + REPASTESPECIAL* {.pure, packed.} = object + dwAspect*: DWORD + dwParam*: DWORD_PTR + SETTEXTEX* {.pure.} = object + flags*: DWORD + codepage*: UINT + GETTEXTEX* {.pure, packed.} = object + cb*: DWORD + flags*: DWORD + codepage*: UINT + lpDefaultChar*: LPCSTR + lpUsedDefChar*: LPBOOL + GETTEXTLENGTHEX* {.pure.} = object + flags*: DWORD + codepage*: UINT + BIDIOPTIONS* {.pure.} = object + cbSize*: UINT + wMask*: WORD + wEffects*: WORD + HYPHRESULT* {.pure.} = object + khyph*: KHYPH + ichHyph*: int32 + chHyph*: WCHAR + HYPHENATEINFO* {.pure, packed.} = object + cbSize*: SHORT + dxHyphenateZone*: SHORT + pfnHyphenate*: proc(P1: ptr WCHAR, P2: LANGID, P3: int32, P4: ptr HYPHRESULT): void {.stdcall.} +proc `dwReserved=`*(self: var CHARFORMAT2W, x: DWORD) {.inline.} = self.union1.dwReserved = x +proc dwReserved*(self: CHARFORMAT2W): DWORD {.inline.} = self.union1.dwReserved +proc dwReserved*(self: var CHARFORMAT2W): var DWORD {.inline.} = self.union1.dwReserved +proc `dwCookie=`*(self: var CHARFORMAT2W, x: DWORD) {.inline.} = self.union1.dwCookie = x +proc dwCookie*(self: CHARFORMAT2W): DWORD {.inline.} = self.union1.dwCookie +proc dwCookie*(self: var CHARFORMAT2W): var DWORD {.inline.} = self.union1.dwCookie +proc `dwReserved=`*(self: var CHARFORMAT2A, x: DWORD) {.inline.} = self.union1.dwReserved = x +proc dwReserved*(self: CHARFORMAT2A): DWORD {.inline.} = self.union1.dwReserved +proc dwReserved*(self: var CHARFORMAT2A): var DWORD {.inline.} = self.union1.dwReserved +proc `dwCookie=`*(self: var CHARFORMAT2A, x: DWORD) {.inline.} = self.union1.dwCookie = x +proc dwCookie*(self: CHARFORMAT2A): DWORD {.inline.} = self.union1.dwCookie +proc dwCookie*(self: var CHARFORMAT2A): var DWORD {.inline.} = self.union1.dwCookie +proc `wReserved=`*(self: var PARAFORMAT, x: WORD) {.inline.} = self.union1.wReserved = x +proc wReserved*(self: PARAFORMAT): WORD {.inline.} = self.union1.wReserved +proc wReserved*(self: var PARAFORMAT): var WORD {.inline.} = self.union1.wReserved +proc `wEffects=`*(self: var PARAFORMAT, x: WORD) {.inline.} = self.union1.wEffects = x +proc wEffects*(self: PARAFORMAT): WORD {.inline.} = self.union1.wEffects +proc wEffects*(self: var PARAFORMAT): var WORD {.inline.} = self.union1.wEffects +proc `wReserved=`*(self: var PARAFORMAT2, x: WORD) {.inline.} = self.union1.wReserved = x +proc wReserved*(self: PARAFORMAT2): WORD {.inline.} = self.union1.wReserved +proc wReserved*(self: var PARAFORMAT2): var WORD {.inline.} = self.union1.wReserved +proc `wEffects=`*(self: var PARAFORMAT2, x: WORD) {.inline.} = self.union1.wEffects = x +proc wEffects*(self: PARAFORMAT2): WORD {.inline.} = self.union1.wEffects +proc wEffects*(self: var PARAFORMAT2): var WORD {.inline.} = self.union1.wEffects +proc GetClientSite*(self: ptr IRichEditOle, lplpolesite: ptr LPOLECLIENTSITE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClientSite(self, lplpolesite) +proc GetObjectCount*(self: ptr IRichEditOle): LONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectCount(self) +proc GetLinkCount*(self: ptr IRichEditOle): LONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLinkCount(self) +proc GetObject*(self: ptr IRichEditOle, iob: LONG, lpreobject: ptr REOBJECT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObject(self, iob, lpreobject, dwFlags) +proc InsertObject*(self: ptr IRichEditOle, lpreobject: ptr REOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertObject(self, lpreobject) +proc ConvertObject*(self: ptr IRichEditOle, iob: LONG, rclsidNew: REFCLSID, lpstrUserTypeNew: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConvertObject(self, iob, rclsidNew, lpstrUserTypeNew) +proc ActivateAs*(self: ptr IRichEditOle, rclsid: REFCLSID, rclsidAs: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateAs(self, rclsid, rclsidAs) +proc SetHostNames*(self: ptr IRichEditOle, lpstrContainerApp: LPCSTR, lpstrContainerObj: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHostNames(self, lpstrContainerApp, lpstrContainerObj) +proc SetLinkAvailable*(self: ptr IRichEditOle, iob: LONG, fAvailable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLinkAvailable(self, iob, fAvailable) +proc SetDvaspect*(self: ptr IRichEditOle, iob: LONG, dvaspect: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDvaspect(self, iob, dvaspect) +proc HandsOffStorage*(self: ptr IRichEditOle, iob: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandsOffStorage(self, iob) +proc SaveCompleted*(self: ptr IRichEditOle, iob: LONG, lpstg: LPSTORAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveCompleted(self, iob, lpstg) +proc InPlaceDeactivate*(self: ptr IRichEditOle): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InPlaceDeactivate(self) +proc ContextSensitiveHelp*(self: ptr IRichEditOle, fEnterMode: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ContextSensitiveHelp(self, fEnterMode) +proc GetClipboardData*(self: ptr IRichEditOle, lpchrg: ptr CHARRANGE, reco: DWORD, lplpdataobj: ptr LPDATAOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClipboardData(self, lpchrg, reco, lplpdataobj) +proc ImportDataObject*(self: ptr IRichEditOle, lpdataobj: LPDATAOBJECT, cf: CLIPFORMAT, hMetaPict: HGLOBAL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ImportDataObject(self, lpdataobj, cf, hMetaPict) +proc GetNewStorage*(self: ptr IRichEditOleCallback, lplpstg: ptr LPSTORAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNewStorage(self, lplpstg) +proc GetInPlaceContext*(self: ptr IRichEditOleCallback, lplpFrame: ptr LPOLEINPLACEFRAME, lplpDoc: ptr LPOLEINPLACEUIWINDOW, lpFrameInfo: LPOLEINPLACEFRAMEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInPlaceContext(self, lplpFrame, lplpDoc, lpFrameInfo) +proc ShowContainerUI*(self: ptr IRichEditOleCallback, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContainerUI(self, fShow) +proc QueryInsertObject*(self: ptr IRichEditOleCallback, lpclsid: LPCLSID, lpstg: LPSTORAGE, cp: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryInsertObject(self, lpclsid, lpstg, cp) +proc DeleteObject*(self: ptr IRichEditOleCallback, lpoleobj: LPOLEOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteObject(self, lpoleobj) +proc QueryAcceptData*(self: ptr IRichEditOleCallback, lpdataobj: LPDATAOBJECT, lpcfFormat: ptr CLIPFORMAT, reco: DWORD, fReally: WINBOOL, hMetaPict: HGLOBAL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryAcceptData(self, lpdataobj, lpcfFormat, reco, fReally, hMetaPict) +proc ContextSensitiveHelp*(self: ptr IRichEditOleCallback, fEnterMode: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ContextSensitiveHelp(self, fEnterMode) +proc GetClipboardData*(self: ptr IRichEditOleCallback, lpchrg: ptr CHARRANGE, reco: DWORD, lplpdataobj: ptr LPDATAOBJECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClipboardData(self, lpchrg, reco, lplpdataobj) +proc GetDragDropEffect*(self: ptr IRichEditOleCallback, fDrag: WINBOOL, grfKeyState: DWORD, pdwEffect: LPDWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDragDropEffect(self, fDrag, grfKeyState, pdwEffect) +proc GetContextMenu*(self: ptr IRichEditOleCallback, seltype: WORD, lpoleobj: LPOLEOBJECT, lpchrg: ptr CHARRANGE, lphmenu: ptr HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContextMenu(self, seltype, lpoleobj, lpchrg, lphmenu) +converter winimConverterIRichEditOleToIUnknown*(x: ptr IRichEditOle): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRichEditOleCallbackToIUnknown*(x: ptr IRichEditOleCallback): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + CHARFORMAT* = CHARFORMATW + CHARFORMAT2* = CHARFORMAT2W + TEXTRANGE* = TEXTRANGEW + TFINDTEXT* = TFINDTEXTW + FINDTEXTEX* = FINDTEXTEXW + const + RICHEDIT_CLASS* = RICHEDIT_CLASSW +when winimAnsi: + type + CHARFORMAT* = CHARFORMATA + CHARFORMAT2* = CHARFORMAT2A + TEXTRANGE* = TEXTRANGEA + TFINDTEXT* = TFINDTEXTA + FINDTEXTEX* = FINDTEXTEXA + const + RICHEDIT_CLASS* = RICHEDIT_CLASSA diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/rpc.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/rpc.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1665 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import winbase +import wincrypt +import security +import objbase +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + cs_byte* = uint8 + boolean* = uint8 + wchar_t* = uint16 + NDR_CCONTEXT* = pointer + error_status_t* = int32 + RPC_BUFPTR* = ptr uint8 + RPC_LENGTH* = int32 + PFORMAT_STRING* = ptr uint8 + USER_MARSHAL_CB_TYPE* = int32 + IDL_CS_CONVERT* = int32 + PMIDL_XMIT_TYPE* = pointer + PARAM_OFFSETTABLE* = ptr uint16 + PPARAM_OFFSETTABLE* = ptr uint16 + XLAT_SIDE* = int32 + STUB_PHASE* = int32 + PROXY_PHASE* = int32 + RPC_SS_THREAD_HANDLE* = pointer + RPC_CSTR* = ptr uint8 + RPC_WSTR* = ptr uint16 + RPC_HTTP_REDIRECTOR_STAGE* = int32 + RPC_ADDRESS_CHANGE_TYPE* = int32 + I_RPC_MUTEX* = pointer + RPC_NS_HANDLE* = pointer + RPC_NOTIFICATION_TYPES* = int32 + RPC_ASYNC_EVENT* = int32 + ExtendedErrorParamTypes* = int32 + RpcCallType* = int32 + RpcLocalAddressFormat* = int32 + RPC_NOTIFICATIONS* = int32 + RpcCallClientLocality* = int32 + PCInterfaceName* = ptr char + RPC_STATUS* = int32 + MIDL_uhyper* = int64 +when winimCpu64: + type + size_t* = int64 + ssize_t* = int64 +when winimCpu32: + type + size_t* = int32 + ssize_t* = int32 +type + I_RPC_HANDLE* = HANDLE + RPC_IF_HANDLE* = HANDLE + RPC_BINDING_HANDLE* = I_RPC_HANDLE + RPC_BINDING_VECTOR* {.pure.} = object + Count*: int32 + BindingH*: array[1, RPC_BINDING_HANDLE] + RPC_IMPORT_CONTEXT_P* {.pure.} = object + LookupContext*: RPC_NS_HANDLE + ProposedHandle*: RPC_BINDING_HANDLE + Bindings*: ptr RPC_BINDING_VECTOR + PRPC_IMPORT_CONTEXT_P* = ptr RPC_IMPORT_CONTEXT_P + NDR_SCONTEXT* {.pure.} = ref object + pad*: array[2, pointer] + userContext*: pointer + SCONTEXT_QUEUE* {.pure.} = object + NumberOfObjects*: int32 + ArrayOfObjects*: ptr NDR_SCONTEXT + PSCONTEXT_QUEUE* = ptr SCONTEXT_QUEUE + ARRAY_INFO* {.pure.} = object + Dimension*: int32 + BufferConformanceMark*: ptr int32 + BufferVarianceMark*: ptr int32 + MaxCountArray*: ptr int32 + OffsetArray*: ptr int32 + ActualCountArray*: ptr int32 + PARRAY_INFO* = ptr ARRAY_INFO + NDR_ASYNC_MESSAGE* {.pure.} = object + PNDR_ASYNC_MESSAGE* = ptr NDR_ASYNC_MESSAGE + NDR_CORRELATION_INFO* {.pure.} = object + PNDR_CORRELATION_INFO* = ptr NDR_CORRELATION_INFO + RPC_VERSION* {.pure.} = object + MajorVersion*: uint16 + MinorVersion*: uint16 + RPC_SYNTAX_IDENTIFIER* {.pure.} = object + SyntaxGUID*: GUID + SyntaxVersion*: RPC_VERSION + PRPC_SYNTAX_IDENTIFIER* = ptr RPC_SYNTAX_IDENTIFIER + RPC_MGR_EPV* {.pure.} = object + RPC_MESSAGE* {.pure.} = object + Handle*: RPC_BINDING_HANDLE + DataRepresentation*: int32 + Buffer*: pointer + BufferLength*: int32 + ProcNum*: int32 + TransferSyntax*: PRPC_SYNTAX_IDENTIFIER + RpcInterfaceInformation*: pointer + ReservedForRuntime*: pointer + ManagerEpv*: ptr RPC_MGR_EPV + ImportContext*: pointer + RpcFlags*: int32 + PRPC_MESSAGE* = ptr RPC_MESSAGE + RPC_DISPATCH_FUNCTION* = proc (Message: PRPC_MESSAGE): void {.stdcall.} + RPC_DISPATCH_TABLE* {.pure.} = object + DispatchTableCount*: int32 + DispatchTable*: ptr RPC_DISPATCH_FUNCTION + Reserved*: LONG_PTR + MIDL_SYNTAX_INFO* {.pure.} = object + TransferSyntax*: RPC_SYNTAX_IDENTIFIER + DispatchTable*: ptr RPC_DISPATCH_TABLE + ProcString*: PFORMAT_STRING + FmtStringOffset*: ptr uint16 + TypeString*: PFORMAT_STRING + aUserMarshalQuadruple*: pointer + pReserved1*: ULONG_PTR + pReserved2*: ULONG_PTR + PMIDL_SYNTAX_INFO* = ptr MIDL_SYNTAX_INFO + NDR_ALLOC_ALL_NODES_CONTEXT* {.pure.} = object + NDR_POINTER_QUEUE_STATE* {.pure.} = object + handle_t* = RPC_BINDING_HANDLE + GENERIC_BINDING_ROUTINE* = proc (P1: pointer): pointer {.stdcall.} + GENERIC_UNBIND_ROUTINE* = proc (P1: pointer, P2: ptr uint8): void {.stdcall.} + GENERIC_BINDING_INFO* {.pure.} = object + pObj*: pointer + Size*: int32 + pfnBind*: GENERIC_BINDING_ROUTINE + pfnUnbind*: GENERIC_UNBIND_ROUTINE + PGENERIC_BINDING_INFO* = ptr GENERIC_BINDING_INFO + MIDL_STUB_DESC_IMPLICIT_HANDLE_INFO* {.pure, union.} = object + pAutoHandle*: ptr handle_t + pPrimitiveHandle*: ptr handle_t + pGenericBindingInfo*: PGENERIC_BINDING_INFO + NDR_RUNDOWN* = proc (context: pointer): void {.stdcall.} + GENERIC_BINDING_ROUTINE_PAIR* {.pure.} = object + pfnBind*: GENERIC_BINDING_ROUTINE + pfnUnbind*: GENERIC_UNBIND_ROUTINE + EXPR_EVAL* = proc (P1: ptr MIDL_STUB_MESSAGE): void {.stdcall.} + XMIT_HELPER_ROUTINE* = proc (P1: PMIDL_STUB_MESSAGE): void {.stdcall.} + XMIT_ROUTINE_QUINTUPLE* {.pure.} = object + pfnTranslateToXmit*: XMIT_HELPER_ROUTINE + pfnTranslateFromXmit*: XMIT_HELPER_ROUTINE + pfnFreeXmit*: XMIT_HELPER_ROUTINE + pfnFreeInst*: XMIT_HELPER_ROUTINE + MALLOC_FREE_STRUCT* {.pure.} = object + pfnAllocate*: proc(P1: int): pointer {.stdcall.} + pfnFree*: proc(P1: pointer): void {.stdcall.} + COMM_FAULT_OFFSETS* {.pure.} = object + CommOffset*: int16 + FaultOffset*: int16 + USER_MARSHAL_SIZING_ROUTINE* = proc (P1: ptr ULONG, P2: ULONG, P3: pointer): ULONG {.stdcall.} + USER_MARSHAL_MARSHALLING_ROUTINE* = proc (P1: ptr ULONG, P2: ptr uint8, P3: pointer): ptr uint8 {.stdcall.} + USER_MARSHAL_UNMARSHALLING_ROUTINE* = proc (P1: ptr ULONG, P2: ptr uint8, P3: pointer): ptr uint8 {.stdcall.} + USER_MARSHAL_FREEING_ROUTINE* = proc (P1: ptr ULONG, P2: pointer): void {.stdcall.} + USER_MARSHAL_ROUTINE_QUADRUPLE* {.pure.} = object + pfnBufferSize*: USER_MARSHAL_SIZING_ROUTINE + pfnMarshall*: USER_MARSHAL_MARSHALLING_ROUTINE + pfnUnmarshall*: USER_MARSHAL_UNMARSHALLING_ROUTINE + pfnFree*: USER_MARSHAL_FREEING_ROUTINE + NDR_NOTIFY_ROUTINE* = proc (): void {.stdcall.} + CS_TYPE_NET_SIZE_ROUTINE* = proc (hBinding: RPC_BINDING_HANDLE, ulNetworkCodeSet: int32, ulLocalBufferSize: int32, conversionType: ptr IDL_CS_CONVERT, pulNetworkBufferSize: ptr int32, pStatus: ptr error_status_t): void {.stdcall.} + CS_TYPE_TO_NETCS_ROUTINE* = proc (hBinding: RPC_BINDING_HANDLE, ulNetworkCodeSet: int32, pLocalData: pointer, ulLocalDataLength: int32, pNetworkData: ptr uint8, pulNetworkDataLength: ptr int32, pStatus: ptr error_status_t): void {.stdcall.} + CS_TYPE_LOCAL_SIZE_ROUTINE* = proc (hBinding: RPC_BINDING_HANDLE, ulNetworkCodeSet: int32, ulNetworkBufferSize: int32, conversionType: ptr IDL_CS_CONVERT, pulLocalBufferSize: ptr int32, pStatus: ptr error_status_t): void {.stdcall.} + CS_TYPE_FROM_NETCS_ROUTINE* = proc (hBinding: RPC_BINDING_HANDLE, ulNetworkCodeSet: int32, pNetworkData: ptr uint8, ulNetworkDataLength: int32, ulLocalBufferSize: int32, pLocalData: pointer, pulLocalDataLength: ptr int32, pStatus: ptr error_status_t): void {.stdcall.} + NDR_CS_SIZE_CONVERT_ROUTINES* {.pure.} = object + pfnNetSize*: CS_TYPE_NET_SIZE_ROUTINE + pfnToNetCs*: CS_TYPE_TO_NETCS_ROUTINE + pfnLocalSize*: CS_TYPE_LOCAL_SIZE_ROUTINE + pfnFromNetCs*: CS_TYPE_FROM_NETCS_ROUTINE + CS_TAG_GETTING_ROUTINE* = proc (hBinding: RPC_BINDING_HANDLE, fServerSide: int32, pulSendingTag: ptr int32, pulDesiredReceivingTag: ptr int32, pulReceivingTag: ptr int32, pStatus: ptr error_status_t): void {.stdcall.} + NDR_CS_ROUTINES* {.pure.} = object + pSizeConvertRoutines*: ptr NDR_CS_SIZE_CONVERT_ROUTINES + pTagGettingRoutines*: ptr CS_TAG_GETTING_ROUTINE + MIDL_STUB_DESC* {.pure.} = object + RpcInterfaceInformation*: pointer + pfnAllocate*: proc(P1: int): pointer {.stdcall.} + pfnFree*: proc(P1: pointer): void {.stdcall.} + IMPLICIT_HANDLE_INFO*: MIDL_STUB_DESC_IMPLICIT_HANDLE_INFO + apfnNdrRundownRoutines*: ptr NDR_RUNDOWN + aGenericBindingRoutinePairs*: ptr GENERIC_BINDING_ROUTINE_PAIR + apfnExprEval*: ptr EXPR_EVAL + aXmitQuintuple*: ptr XMIT_ROUTINE_QUINTUPLE + pFormatTypes*: ptr uint8 + fCheckBounds*: int32 + Version*: int32 + pMallocFreeStruct*: ptr MALLOC_FREE_STRUCT + MIDLVersion*: int32 + CommFaultOffsets*: ptr COMM_FAULT_OFFSETS + aUserMarshalQuadruple*: ptr USER_MARSHAL_ROUTINE_QUADRUPLE + NotifyRoutineTable*: ptr NDR_NOTIFY_ROUTINE + mFlags*: ULONG_PTR + CsRoutineTables*: ptr NDR_CS_ROUTINES + Reserved4*: pointer + Reserved5*: ULONG_PTR + FULL_PTR_XLAT_TABLES_RefIdToPointer* {.pure.} = object + XlatTable*: ptr pointer + StateTable*: ptr uint8 + NumberOfEntries*: int32 + FULL_PTR_TO_REFID_ELEMENT* {.pure.} = object + Next*: ptr FULL_PTR_TO_REFID_ELEMENT + Pointer*: pointer + RefId*: int32 + State*: uint8 + PFULL_PTR_TO_REFID_ELEMENT* = ptr FULL_PTR_TO_REFID_ELEMENT + FULL_PTR_XLAT_TABLES_PointerToRefId* {.pure.} = object + XlatTable*: ptr PFULL_PTR_TO_REFID_ELEMENT + NumberOfBuckets*: int32 + HashMask*: int32 + FULL_PTR_XLAT_TABLES* {.pure.} = object + RefIdToPointer*: FULL_PTR_XLAT_TABLES_RefIdToPointer + PointerToRefId*: FULL_PTR_XLAT_TABLES_PointerToRefId + NextRefId*: int32 + XlatSide*: XLAT_SIDE + CS_STUB_INFO* {.pure.} = object + WireCodeset*: int32 + DesiredReceivingCodeset*: int32 + CSArrayInfo*: pointer + NDR_PROC_CONTEXT* {.pure.} = object + MIDL_STUB_MESSAGE* {.pure.} = object + RpcMsg*: PRPC_MESSAGE + Buffer*: ptr uint8 + BufferStart*: ptr uint8 + BufferEnd*: ptr uint8 + BufferMark*: ptr uint8 + BufferLength*: int32 + MemorySize*: int32 + Memory*: ptr uint8 + IsClient*: uint8 + Pad*: uint8 + uFlags2*: uint16 + ReuseBuffer*: int32 + pAllocAllNodesContext*: ptr NDR_ALLOC_ALL_NODES_CONTEXT + pPointerQueueState*: ptr NDR_POINTER_QUEUE_STATE + IgnoreEmbeddedPointers*: int32 + PointerBufferMark*: ptr uint8 + fBufferValid*: uint8 + uFlags*: uint8 + UniquePtrCount*: uint16 + MaxCount*: ULONG_PTR + Offset*: int32 + ActualCount*: int32 + pfnAllocate*: proc(P1: int): pointer {.stdcall.} + pfnFree*: proc(P1: pointer): void {.stdcall.} + StackTop*: ptr uint8 + pPresentedType*: ptr uint8 + pTransmitType*: ptr uint8 + SavedHandle*: handle_t + StubDesc*: ptr MIDL_STUB_DESC + FullPtrXlatTables*: ptr FULL_PTR_XLAT_TABLES + FullPtrRefId*: int32 + PointerLength*: int32 + fInDontFree* {.bitsize:1.}: int32 + fDontCallFreeInst* {.bitsize:1.}: int32 + fInOnlyParam* {.bitsize:1.}: int32 + fHasReturn* {.bitsize:1.}: int32 + fHasExtensions* {.bitsize:1.}: int32 + fHasNewCorrDesc* {.bitsize:1.}: int32 + fIsOicfServer* {.bitsize:1.}: int32 + fHasMemoryValidateCallback* {.bitsize:1.}: int32 + fUnused* {.bitsize:8.}: int32 + fUnused2* {.bitsize:16.}: int32 + dwDestContext*: int32 + pvDestContext*: pointer + SavedContextHandles*: ptr NDR_SCONTEXT + ParamNumber*: int32 + pRpcChannelBuffer*: ptr IRpcChannelBuffer + pArrayInfo*: PARRAY_INFO + SizePtrCountArray*: ptr int32 + SizePtrOffsetArray*: ptr int32 + SizePtrLengthArray*: ptr int32 + pArgQueue*: pointer + dwStubPhase*: int32 + LowStackMark*: pointer + pAsyncMsg*: PNDR_ASYNC_MESSAGE + pCorrInfo*: PNDR_CORRELATION_INFO + pCorrMemory*: ptr uint8 + pMemoryList*: pointer + pCSInfo*: ptr CS_STUB_INFO + ConformanceMark*: ptr uint8 + VarianceMark*: ptr uint8 + BackingStoreLowMark*: pointer + pContext*: ptr NDR_PROC_CONTEXT + pUserMarshalList*: pointer + Reserved51_2*: INT_PTR + Reserved51_3*: INT_PTR + Reserved51_4*: INT_PTR + Reserved51_5*: INT_PTR + PMIDL_STUB_MESSAGE* = ptr MIDL_STUB_MESSAGE + PGENERIC_BINDING_ROUTINE_PAIR* = ptr GENERIC_BINDING_ROUTINE_PAIR + PXMIT_ROUTINE_QUINTUPLE* = ptr XMIT_ROUTINE_QUINTUPLE + PMIDL_STUB_DESC* = ptr MIDL_STUB_DESC + SERVER_ROUTINE* = proc (): int32 {.stdcall.} + STUB_THUNK* = proc (P1: PMIDL_STUB_MESSAGE): void {.stdcall.} + MIDL_SERVER_INFO* {.pure.} = object + pStubDesc*: PMIDL_STUB_DESC + DispatchTable*: ptr SERVER_ROUTINE + ProcString*: PFORMAT_STRING + FmtStringOffset*: ptr uint16 + ThunkTable*: ptr STUB_THUNK + pTransferSyntax*: PRPC_SYNTAX_IDENTIFIER + nCount*: ULONG_PTR + pSyntaxInfo*: PMIDL_SYNTAX_INFO + PMIDL_SERVER_INFO* = ptr MIDL_SERVER_INFO + MIDL_STUBLESS_PROXY_INFO* {.pure.} = object + pStubDesc*: PMIDL_STUB_DESC + ProcFormatString*: PFORMAT_STRING + FormatStringOffset*: ptr uint16 + pTransferSyntax*: PRPC_SYNTAX_IDENTIFIER + nCount*: ULONG_PTR + pSyntaxInfo*: PMIDL_SYNTAX_INFO + PMIDL_STUBLESS_PROXY_INFO* = ptr MIDL_STUBLESS_PROXY_INFO + PFULL_PTR_XLAT_TABLES* = ptr FULL_PTR_XLAT_TABLES + rpc_binding_handle_t* = RPC_BINDING_HANDLE + UUID* = GUID + uuid_t* = UUID + rpc_binding_vector_t* = RPC_BINDING_VECTOR + UUID_VECTOR* {.pure.} = object + Count*: int32 + Uuid*: array[1, ptr UUID] + uuid_vector_t* = UUID_VECTOR + RPC_POLICY* {.pure.} = object + Length*: int32 + EndpointFlags*: int32 + NICFlags*: int32 + PRPC_POLICY* = ptr RPC_POLICY + RPC_SECURITY_QOS* {.pure.} = object + Version*: int32 + Capabilities*: int32 + IdentityTracking*: int32 + ImpersonationType*: int32 + PRPC_SECURITY_QOS* = ptr RPC_SECURITY_QOS + RPC_HTTP_TRANSPORT_CREDENTIALS_W* {.pure.} = object + TransportCredentials*: ptr SEC_WINNT_AUTH_IDENTITY_W + Flags*: int32 + AuthenticationTarget*: int32 + NumberOfAuthnSchemes*: int32 + AuthnSchemes*: ptr int32 + ServerCertificateSubject*: ptr uint16 + PRPC_HTTP_TRANSPORT_CREDENTIALS_W* = ptr RPC_HTTP_TRANSPORT_CREDENTIALS_W + RPC_HTTP_TRANSPORT_CREDENTIALS_A* {.pure.} = object + TransportCredentials*: ptr SEC_WINNT_AUTH_IDENTITY_A + Flags*: int32 + AuthenticationTarget*: int32 + NumberOfAuthnSchemes*: int32 + AuthnSchemes*: ptr int32 + ServerCertificateSubject*: ptr uint8 + PRPC_HTTP_TRANSPORT_CREDENTIALS_A* = ptr RPC_HTTP_TRANSPORT_CREDENTIALS_A + RPC_SECURITY_QOS_V2_W_u* {.pure, union.} = object + HttpCredentials*: ptr RPC_HTTP_TRANSPORT_CREDENTIALS_W + RPC_SECURITY_QOS_V2_W* {.pure.} = object + Version*: int32 + Capabilities*: int32 + IdentityTracking*: int32 + ImpersonationType*: int32 + AdditionalSecurityInfoType*: int32 + u*: RPC_SECURITY_QOS_V2_W_u + PRPC_SECURITY_QOS_V2_W* = ptr RPC_SECURITY_QOS_V2_W + RPC_SECURITY_QOS_V2_A_u* {.pure, union.} = object + HttpCredentials*: ptr RPC_HTTP_TRANSPORT_CREDENTIALS_A + RPC_SECURITY_QOS_V2_A* {.pure.} = object + Version*: int32 + Capabilities*: int32 + IdentityTracking*: int32 + ImpersonationType*: int32 + AdditionalSecurityInfoType*: int32 + u*: RPC_SECURITY_QOS_V2_A_u + PRPC_SECURITY_QOS_V2_A* = ptr RPC_SECURITY_QOS_V2_A + RPC_SECURITY_QOS_V3_W_u* {.pure, union.} = object + HttpCredentials*: ptr RPC_HTTP_TRANSPORT_CREDENTIALS_W + RPC_SECURITY_QOS_V3_W* {.pure.} = object + Version*: int32 + Capabilities*: int32 + IdentityTracking*: int32 + ImpersonationType*: int32 + AdditionalSecurityInfoType*: int32 + u*: RPC_SECURITY_QOS_V3_W_u + Sid*: pointer + PRPC_SECURITY_QOS_V3_W* = ptr RPC_SECURITY_QOS_V3_W + RPC_SECURITY_QOS_V3_A_u* {.pure, union.} = object + HttpCredentials*: ptr RPC_HTTP_TRANSPORT_CREDENTIALS_A + RPC_SECURITY_QOS_V3_A* {.pure.} = object + Version*: int32 + Capabilities*: int32 + IdentityTracking*: int32 + ImpersonationType*: int32 + AdditionalSecurityInfoType*: int32 + u*: RPC_SECURITY_QOS_V3_A_u + Sid*: pointer + PRPC_SECURITY_QOS_V3_A* = ptr RPC_SECURITY_QOS_V3_A + RPC_CLIENT_INFORMATION1* {.pure.} = object + UserName*: ptr uint8 + ComputerName*: ptr uint8 + Privilege*: uint16 + AuthFlags*: int32 + PRPC_CLIENT_INFORMATION1* = ptr RPC_CLIENT_INFORMATION1 + RPC_EP_INQ_HANDLE* = ptr I_RPC_HANDLE + RPC_BINDING_HANDLE_OPTIONS_V1* {.pure.} = object + Version*: int32 + Flags*: int32 + ComTimeout*: int32 + CallTimeout*: int32 + RPC_BINDING_HANDLE_OPTIONS* = RPC_BINDING_HANDLE_OPTIONS_V1 + RPC_BINDING_HANDLE_SECURITY_V1* {.pure.} = object + Version*: int32 + ServerPrincName*: ptr uint16 + AuthnLevel*: int32 + AuthnSvc*: int32 + AuthIdentity*: ptr SEC_WINNT_AUTH_IDENTITY + SecurityQos*: ptr RPC_SECURITY_QOS + RPC_BINDING_HANDLE_SECURITY* = RPC_BINDING_HANDLE_SECURITY_V1 + RPC_BINDING_HANDLE_TEMPLATE_V1_u1* {.pure, union.} = object + Reserved*: ptr uint16 + RPC_BINDING_HANDLE_TEMPLATE_V1* {.pure.} = object + Version*: int32 + Flags*: int32 + ProtocolSequence*: int32 + NetworkAddress*: ptr uint16 + StringEndpoint*: ptr uint16 + u1*: RPC_BINDING_HANDLE_TEMPLATE_V1_u1 + ObjectUuid*: UUID + RPC_BINDING_HANDLE_TEMPLATE* = RPC_BINDING_HANDLE_TEMPLATE_V1 + PRPC_DISPATCH_TABLE* = ptr RPC_DISPATCH_TABLE + RPC_PROTSEQ_ENDPOINT* {.pure.} = object + RpcProtocolSequence*: ptr uint8 + Endpoint*: ptr uint8 + PRPC_PROTSEQ_ENDPOINT* = ptr RPC_PROTSEQ_ENDPOINT + RPC_SERVER_INTERFACE* {.pure.} = object + Length*: int32 + InterfaceId*: RPC_SYNTAX_IDENTIFIER + TransferSyntax*: RPC_SYNTAX_IDENTIFIER + DispatchTable*: PRPC_DISPATCH_TABLE + RpcProtseqEndpointCount*: int32 + RpcProtseqEndpoint*: PRPC_PROTSEQ_ENDPOINT + DefaultManagerEpv*: ptr RPC_MGR_EPV + InterpreterInfo*: pointer + Flags*: int32 + PRPC_SERVER_INTERFACE* = ptr RPC_SERVER_INTERFACE + RPC_CLIENT_INTERFACE* {.pure.} = object + Length*: int32 + InterfaceId*: RPC_SYNTAX_IDENTIFIER + TransferSyntax*: RPC_SYNTAX_IDENTIFIER + DispatchTable*: PRPC_DISPATCH_TABLE + RpcProtseqEndpointCount*: int32 + RpcProtseqEndpoint*: PRPC_PROTSEQ_ENDPOINT + Reserved*: ULONG_PTR + InterpreterInfo*: pointer + Flags*: int32 + PRPC_CLIENT_INTERFACE* = ptr RPC_CLIENT_INTERFACE + PFN_RPCNOTIFICATION_ROUTINE* = proc (pAsync: ptr RPC_ASYNC_STATE, Context: pointer, Event: RPC_ASYNC_EVENT): void {.stdcall.} + RPC_ASYNC_STATE_u_APC* {.pure.} = object + NotificationRoutine*: PFN_RPCNOTIFICATION_ROUTINE + hThread*: HANDLE + RPC_ASYNC_STATE_u_IOC* {.pure.} = object + hIOPort*: HANDLE + dwNumberOfBytesTransferred*: DWORD + dwCompletionKey*: DWORD_PTR + lpOverlapped*: LPOVERLAPPED + RPC_ASYNC_STATE_u_HWND* {.pure.} = object + hWnd*: HWND + Msg*: UINT + RPC_ASYNC_STATE_u* {.pure, union.} = object + APC*: RPC_ASYNC_STATE_u_APC + IOC*: RPC_ASYNC_STATE_u_IOC + HWND*: RPC_ASYNC_STATE_u_HWND + hEvent*: HANDLE + NotificationRoutine*: PFN_RPCNOTIFICATION_ROUTINE + RPC_ASYNC_STATE* {.pure.} = object + Size*: int32 + Signature*: int32 + Lock*: int32 + Flags*: int32 + StubInfo*: pointer + UserInfo*: pointer + RuntimeInfo*: pointer + Event*: RPC_ASYNC_EVENT + NotificationType*: RPC_NOTIFICATION_TYPES + u*: RPC_ASYNC_STATE_u + Reserved*: array[4, LONG_PTR] + PRPC_ASYNC_STATE* = ptr RPC_ASYNC_STATE + RPC_CALL_ATTRIBUTES_V1_W* {.pure.} = object + Version*: int32 + Flags*: int32 + ServerPrincipalNameBufferLength*: int32 + ServerPrincipalName*: ptr uint16 + ClientPrincipalNameBufferLength*: int32 + ClientPrincipalName*: ptr uint16 + AuthenticationLevel*: int32 + AuthenticationService*: int32 + NullSession*: WINBOOL +when winimUnicode: + type + RPC_CALL_ATTRIBUTES_V1* = RPC_CALL_ATTRIBUTES_V1_W +type + RPC_CALL_ATTRIBUTES_V1_A* {.pure.} = object + Version*: int32 + Flags*: int32 + ServerPrincipalNameBufferLength*: int32 + ServerPrincipalName*: ptr uint8 + ClientPrincipalNameBufferLength*: int32 + ClientPrincipalName*: ptr uint8 + AuthenticationLevel*: int32 + AuthenticationService*: int32 + NullSession*: WINBOOL +when winimAnsi: + type + RPC_CALL_ATTRIBUTES_V1* = RPC_CALL_ATTRIBUTES_V1_A +type + RPC_CALL_ATTRIBUTES* = RPC_CALL_ATTRIBUTES_V1 + RPC_ASYNC_NOTIFICATION_INFO_APC* {.pure.} = object + NotificationRoutine*: PFN_RPCNOTIFICATION_ROUTINE + hThread*: HANDLE + RPC_ASYNC_NOTIFICATION_INFO_IOC* {.pure.} = object + hIOPort*: HANDLE + dwNumberOfBytesTransferred*: DWORD + dwCompletionKey*: DWORD_PTR + lpOverlapped*: LPOVERLAPPED + RPC_ASYNC_NOTIFICATION_INFO_HWND* {.pure.} = object + hWnd*: HWND + Msg*: UINT + RPC_ASYNC_NOTIFICATION_INFO* {.pure, union.} = object + APC*: RPC_ASYNC_NOTIFICATION_INFO_APC + IOC*: RPC_ASYNC_NOTIFICATION_INFO_IOC + HWND*: RPC_ASYNC_NOTIFICATION_INFO_HWND + hEvent*: HANDLE + NotificationRoutine*: PFN_RPCNOTIFICATION_ROUTINE + PRPC_ASYNC_NOTIFICATION_INFO* = ptr RPC_ASYNC_NOTIFICATION_INFO + RPC_CALL_LOCAL_ADDRESS_V1_A* {.pure.} = object + Version*: int32 + Buffer*: pointer + BufferSize*: int32 + AddressFormat*: RpcLocalAddressFormat + RPC_CALL_LOCAL_ADDRESS_A* = RPC_CALL_LOCAL_ADDRESS_V1_A + RPC_CALL_LOCAL_ADDRESS_V1_W* {.pure.} = object + Version*: int32 + Buffer*: pointer + BufferSize*: int32 + AddressFormat*: RpcLocalAddressFormat + RPC_CALL_LOCAL_ADDRESS_W* = RPC_CALL_LOCAL_ADDRESS_V1_W + RPC_CALL_ATTRIBUTES_V2_A* {.pure.} = object + Version*: int32 + Flags*: int32 + ServerPrincipalNameBufferLength*: int32 + ServerPrincipalName*: ptr uint16 + ClientPrincipalNameBufferLength*: int32 + ClientPrincipalName*: ptr uint16 + AuthenticationLevel*: int32 + AuthenticationService*: int32 + NullSession*: WINBOOL + KernelMode*: WINBOOL + ProtocolSequence*: int32 + IsClientLocal*: RpcCallClientLocality + ClientPID*: HANDLE + CallStatus*: int32 + CallType*: RpcCallType + CallLocalAddress*: ptr RPC_CALL_LOCAL_ADDRESS_A + OpNum*: uint16 + InterfaceUuid*: UUID + RPC_CALL_ATTRIBUTES_A* = RPC_CALL_ATTRIBUTES_V2_A + RPC_CALL_ATTRIBUTES_V2_W* {.pure.} = object + Version*: int32 + Flags*: int32 + ServerPrincipalNameBufferLength*: int32 + ServerPrincipalName*: ptr uint16 + ClientPrincipalNameBufferLength*: int32 + ClientPrincipalName*: ptr uint16 + AuthenticationLevel*: int32 + AuthenticationService*: int32 + NullSession*: WINBOOL + KernelMode*: WINBOOL + ProtocolSequence*: int32 + IsClientLocal*: RpcCallClientLocality + ClientPID*: HANDLE + CallStatus*: int32 + CallType*: RpcCallType + CallLocalAddress*: ptr RPC_CALL_LOCAL_ADDRESS_W + OpNum*: uint16 + InterfaceUuid*: UUID + RPC_CALL_ATTRIBUTES_W* = RPC_CALL_ATTRIBUTES_V2_W + PRPC_STUB_FUNCTION* = proc (This: ptr IRpcStubBuffer, pRpcChannelBuffer: ptr IRpcChannelBuffer, pRpcMessage: PRPC_MESSAGE, pdwStubPhase: ptr DWORD): void {.stdcall.} + CInterfaceStubHeader* {.pure.} = object + piid*: ptr IID + pServerInfo*: ptr MIDL_SERVER_INFO + DispatchTableCount*: int32 + pDispatchTable*: ptr PRPC_STUB_FUNCTION + CInterfaceStubVtbl* {.pure.} = object + header*: CInterfaceStubHeader + Vtbl*: IRpcStubBufferVtbl + PCInterfaceStubVtblList* = ptr CInterfaceStubVtbl + CInterfaceProxyHeader* {.pure.} = object + pStublessProxyInfo*: pointer + piid*: ptr IID + CInterfaceProxyVtbl* {.pure.} = object + header*: CInterfaceProxyHeader + Vtbl*: UncheckedArray[pointer] + PCInterfaceProxyVtblList* = ptr CInterfaceProxyVtbl + IIDLookupRtn* = proc (pIID: ptr IID, pIndex: ptr int32): int32 {.stdcall.} + PIIDLookup* = IIDLookupRtn + ProxyFileInfo* {.pure.} = object + pProxyVtblList*: ptr PCInterfaceProxyVtblList + pStubVtblList*: ptr PCInterfaceStubVtblList + pNamesArray*: ptr PCInterfaceName + pDelegatedIIDs*: ptr ptr IID + pIIDLookupRtn*: PIIDLookup + TableSize*: uint16 + TableVersion*: uint16 + pAsyncIIDLookup*: ptr ptr IID + Filler2*: LONG_PTR + Filler3*: LONG_PTR + Filler4*: LONG_PTR + ExtendedProxyFileInfo* = ProxyFileInfo +const + RPCNDR_H_VERSION* = 475 + NDR_CHAR_REP_MASK* = 0X0000000F + NDR_INT_REP_MASK* = 0X000000F0 + NDR_FLOAT_REP_MASK* = 0X0000FF00 + NDR_LITTLE_ENDIAN* = 0X00000010 + NDR_BIG_ENDIAN* = 0X00000000 + NDR_IEEE_FLOAT* = 0X00000000 + NDR_VAX_FLOAT* = 0X00000100 + NDR_IBM_FLOAT* = 0X00000300 + NDR_ASCII_CHAR* = 0X00000000 + NDR_EBCDIC_CHAR* = 0X00000001 + NDR_LOCAL_DATA_REPRESENTATION* = 0X00000010 + NDR_LOCAL_ENDIAN* = NDR_LITTLE_ENDIAN + cbNDRContext* = 20 + USER_MARSHAL_CB_SIGNATURE* = 0x55535243 + USER_MARSHAL_CB_BUFFER_SIZE* = 0 + USER_MARSHAL_CB_MARSHALL* = 1 + USER_MARSHAL_CB_UNMARSHALL* = 2 + USER_MARSHAL_CB_FREE* = 3 + USER_CALL_IS_ASYNC* = 0x0100 + USER_CALL_NEW_CORRELATION_DESC* = 0x0200 + IDL_CS_NO_CONVERT* = 0 + IDL_CS_IN_PLACE_CONVERT* = 1 + IDL_CS_NEW_BUFFER_CONVERT* = 2 + XLAT_SERVER* = 1 + XLAT_CLIENT* = 2 + USER_MARSHAL_FC_BYTE* = 1 + USER_MARSHAL_FC_CHAR* = 2 + USER_MARSHAL_FC_SMALL* = 3 + USER_MARSHAL_FC_USMALL* = 4 + USER_MARSHAL_FC_WCHAR* = 5 + USER_MARSHAL_FC_SHORT* = 6 + USER_MARSHAL_FC_USHORT* = 7 + USER_MARSHAL_FC_LONG* = 8 + USER_MARSHAL_FC_ULONG* = 9 + USER_MARSHAL_FC_FLOAT* = 10 + USER_MARSHAL_FC_HYPER* = 11 + USER_MARSHAL_FC_DOUBLE* = 12 + STUB_UNMARSHAL* = 0 + STUB_CALL_SERVER* = 1 + STUB_MARSHAL* = 2 + STUB_CALL_SERVER_NO_HRESULT* = 3 + PROXY_CALCSIZE* = 0 + PROXY_GETBUFFER* = 1 + PROXY_MARSHAL* = 2 + PROXY_SENDRECEIVE* = 3 + PROXY_UNMARSHAL* = 4 + RPC_C_BINDING_INFINITE_TIMEOUT* = 10 + RPC_C_BINDING_MIN_TIMEOUT* = 0 + RPC_C_BINDING_DEFAULT_TIMEOUT* = 5 + RPC_C_BINDING_MAX_TIMEOUT* = 9 + RPC_C_CANCEL_INFINITE_TIMEOUT* = -1 + RPC_C_LISTEN_MAX_CALLS_DEFAULT* = 1234 + RPC_C_PROTSEQ_MAX_REQS_DEFAULT* = 10 + RPC_C_BIND_TO_ALL_NICS* = 1 + RPC_C_USE_INTERNET_PORT* = 0x1 + RPC_C_USE_INTRANET_PORT* = 0x2 + RPC_C_DONT_FAIL* = 0x4 + RPC_C_MQ_TEMPORARY* = 0x0000 + RPC_C_MQ_PERMANENT* = 0x0001 + RPC_C_MQ_CLEAR_ON_OPEN* = 0x0002 + RPC_C_MQ_USE_EXISTING_SECURITY* = 0x0004 + RPC_C_MQ_AUTHN_LEVEL_NONE* = 0x0000 + RPC_C_MQ_AUTHN_LEVEL_PKT_INTEGRITY* = 0x0008 + RPC_C_MQ_AUTHN_LEVEL_PKT_PRIVACY* = 0x0010 + RPC_C_OPT_MQ_DELIVERY* = 1 + RPC_C_OPT_MQ_PRIORITY* = 2 + RPC_C_OPT_MQ_JOURNAL* = 3 + RPC_C_OPT_MQ_ACKNOWLEDGE* = 4 + RPC_C_OPT_MQ_AUTHN_SERVICE* = 5 + RPC_C_OPT_MQ_AUTHN_LEVEL* = 6 + RPC_C_OPT_MQ_TIME_TO_REACH_QUEUE* = 7 + RPC_C_OPT_MQ_TIME_TO_BE_RECEIVED* = 8 + RPC_C_OPT_BINDING_NONCAUSAL* = 9 + RPC_C_OPT_SECURITY_CALLBACK* = 10 + RPC_C_OPT_UNIQUE_BINDING* = 11 + RPC_C_OPT_CALL_TIMEOUT* = 12 + RPC_C_OPT_DONT_LINGER* = 13 + RPC_C_OPT_MAX_OPTIONS* = 14 + RPC_C_MQ_EXPRESS* = 0 + RPC_C_MQ_RECOVERABLE* = 1 + RPC_C_MQ_JOURNAL_NONE* = 0 + RPC_C_MQ_JOURNAL_DEADLETTER* = 1 + RPC_C_MQ_JOURNAL_ALWAYS* = 2 + RPC_C_FULL_CERT_CHAIN* = 0x0001 + RPC_C_STATS_CALLS_IN* = 0 + RPC_C_STATS_CALLS_OUT* = 1 + RPC_C_STATS_PKTS_IN* = 2 + RPC_C_STATS_PKTS_OUT* = 3 + RPC_C_AUTHN_LEVEL_DEFAULT* = 0 + RPC_C_AUTHN_LEVEL_NONE* = 1 + RPC_C_AUTHN_LEVEL_CONNECT* = 2 + RPC_C_AUTHN_LEVEL_CALL* = 3 + RPC_C_AUTHN_LEVEL_PKT* = 4 + RPC_C_AUTHN_LEVEL_PKT_INTEGRITY* = 5 + RPC_C_AUTHN_LEVEL_PKT_PRIVACY* = 6 + RPC_C_IMP_LEVEL_DEFAULT* = 0 + RPC_C_IMP_LEVEL_ANONYMOUS* = 1 + RPC_C_IMP_LEVEL_IDENTIFY* = 2 + RPC_C_IMP_LEVEL_IMPERSONATE* = 3 + RPC_C_IMP_LEVEL_DELEGATE* = 4 + RPC_C_QOS_IDENTITY_STATIC* = 0 + RPC_C_QOS_IDENTITY_DYNAMIC* = 1 + RPC_C_QOS_CAPABILITIES_DEFAULT* = 0x0 + RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH* = 0x1 + RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC* = 0x2 + RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY* = 0x4 + RPC_C_QOS_CAPABILITIES_IGNORE_DELEGATE_FAILURE* = 0x8 + RPC_C_QOS_CAPABILITIES_LOCAL_MA_HINT* = 0x10 + RPC_C_PROTECT_LEVEL_DEFAULT* = RPC_C_AUTHN_LEVEL_DEFAULT + RPC_C_PROTECT_LEVEL_NONE* = RPC_C_AUTHN_LEVEL_NONE + RPC_C_PROTECT_LEVEL_CONNECT* = RPC_C_AUTHN_LEVEL_CONNECT + RPC_C_PROTECT_LEVEL_CALL* = RPC_C_AUTHN_LEVEL_CALL + RPC_C_PROTECT_LEVEL_PKT* = RPC_C_AUTHN_LEVEL_PKT + RPC_C_PROTECT_LEVEL_PKT_INTEGRITY* = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY + RPC_C_PROTECT_LEVEL_PKT_PRIVACY* = RPC_C_AUTHN_LEVEL_PKT_PRIVACY + RPC_C_AUTHN_NONE* = 0 + RPC_C_AUTHN_DCE_PRIVATE* = 1 + RPC_C_AUTHN_DCE_PUBLIC* = 2 + RPC_C_AUTHN_DEC_PUBLIC* = 4 + RPC_C_AUTHN_GSS_NEGOTIATE* = 9 + RPC_C_AUTHN_WINNT* = 10 + RPC_C_AUTHN_GSS_SCHANNEL* = 14 + RPC_C_AUTHN_GSS_KERBEROS* = 16 + RPC_C_AUTHN_DPA* = 17 + RPC_C_AUTHN_MSN* = 18 + RPC_C_AUTHN_DIGEST* = 21 + RPC_C_AUTHN_MQ* = 100 + RPC_C_AUTHN_DEFAULT* = 0xFFFFFFFF'i32 + RPC_C_SECURITY_QOS_VERSION* = 1 + RPC_C_SECURITY_QOS_VERSION_1* = 1 + RPC_C_SECURITY_QOS_VERSION_2* = 2 + RPC_C_AUTHN_INFO_TYPE_HTTP* = 1 + RPC_C_HTTP_AUTHN_TARGET_SERVER* = 1 + RPC_C_HTTP_AUTHN_TARGET_PROXY* = 2 + RPC_C_HTTP_AUTHN_SCHEME_BASIC* = 0x00000001 + RPC_C_HTTP_AUTHN_SCHEME_NTLM* = 0x00000002 + RPC_C_HTTP_AUTHN_SCHEME_PASSPORT* = 0x00000004 + RPC_C_HTTP_AUTHN_SCHEME_DIGEST* = 0x00000008 + RPC_C_HTTP_AUTHN_SCHEME_NEGOTIATE* = 0x00000010 + RPC_C_HTTP_AUTHN_SCHEME_CERT* = 0x00010000 + RPC_C_HTTP_FLAG_USE_SSL* = 1 + RPC_C_HTTP_FLAG_USE_FIRST_AUTH_SCHEME* = 2 + RPC_C_HTTP_FLAG_IGNORE_CERT_CN_INVALID* = 8 + RPC_C_SECURITY_QOS_VERSION_3* = 3 + RPCHTTP_RS_REDIRECT* = 1 + RPCHTTP_RS_ACCESS_1* = 2 + RPCHTTP_RS_SESSION* = 3 + RPCHTTP_RS_ACCESS_2* = 4 + RPCHTTP_RS_INTERFACE* = 5 + RPC_C_AUTHZ_NONE* = 0 + RPC_C_AUTHZ_NAME* = 1 + RPC_C_AUTHZ_DCE* = 2 + RPC_C_AUTHZ_DEFAULT* = 0xffffffff'i32 + DCE_C_ERROR_STRING_LEN* = 256 + RPC_C_EP_ALL_ELTS* = 0 + RPC_C_EP_MATCH_BY_IF* = 1 + RPC_C_EP_MATCH_BY_OBJ* = 2 + RPC_C_EP_MATCH_BY_BOTH* = 3 + RPC_C_VERS_ALL* = 1 + RPC_C_VERS_COMPATIBLE* = 2 + RPC_C_VERS_EXACT* = 3 + RPC_C_VERS_MAJOR_ONLY* = 4 + RPC_C_VERS_UPTO* = 5 + RPC_C_MGMT_INQ_IF_IDS* = 0 + RPC_C_MGMT_INQ_PRINC_NAME* = 1 + RPC_C_MGMT_INQ_STATS* = 2 + RPC_C_MGMT_IS_SERVER_LISTEN* = 3 + RPC_C_MGMT_STOP_SERVER_LISTEN* = 4 + RPC_C_PARM_MAX_PACKET_LENGTH* = 1 + RPC_C_PARM_BUFFER_LENGTH* = 2 + RPC_IF_AUTOLISTEN* = 0x0001 + RPC_IF_OLE* = 0x0002 + RPC_IF_ALLOW_UNKNOWN_AUTHORITY* = 0x0004 + RPC_IF_ALLOW_SECURE_ONLY* = 0x0008 + RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH* = 0x0010 + RPC_IF_ALLOW_LOCAL_ONLY* = 0x0020 + RPC_IF_SEC_NO_CACHE* = 0x0040 + RPC_CALL_STATUS_IN_PROGRESS* = 0x01 + RPC_CALL_STATUS_CANCELLED* = 0x02 + RPC_CALL_STATUS_DISCONNECTED* = 0x03 + PROTOCOL_NOT_LOADED* = 1 + PROTOCOL_LOADED* = 2 + PROTOCOL_ADDRESS_CHANGE* = 3 + RPC_CONTEXT_HANDLE_DEFAULT_FLAGS* = 0x00000000 + RPC_CONTEXT_HANDLE_FLAGS* = 0x30000000 + RPC_CONTEXT_HANDLE_SERIALIZE* = 0x10000000 + RPC_CONTEXT_HANDLE_DONT_SERIALIZE* = 0x20000000 + RPC_NCA_FLAGS_DEFAULT* = 0x00000000 + RPC_NCA_FLAGS_IDEMPOTENT* = 0x00000001 + RPC_NCA_FLAGS_BROADCAST* = 0x00000002 + RPC_NCA_FLAGS_MAYBE* = 0x00000004 + RPC_BUFFER_COMPLETE* = 0x00001000 + RPC_BUFFER_PARTIAL* = 0x00002000 + RPC_BUFFER_EXTRA* = 0x00004000 + RPC_BUFFER_ASYNC* = 0x00008000 + RPC_BUFFER_NONOTIFY* = 0x00010000 + RPCFLG_MESSAGE* = 0x01000000 + RPCFLG_AUTO_COMPLETE* = 0x08000000 + RPCFLG_LOCAL_CALL* = 0x10000000 + RPCFLG_INPUT_SYNCHRONOUS* = 0x20000000 + RPCFLG_ASYNCHRONOUS* = 0x40000000 + RPCFLG_NON_NDR* = 0x80000000'i32 + RPCFLG_HAS_MULTI_SYNTAXES* = 0x02000000 + RPCFLG_HAS_CALLBACK* = 0x04000000 + RPC_FLAGS_VALID_BIT* = 0x00008000 + NT351_INTERFACE_SIZE* = 0x40 + RPC_INTERFACE_HAS_PIPES* = 0x0001 + TRANSPORT_TYPE_CN* = 0x01 + TRANSPORT_TYPE_DG* = 0x02 + TRANSPORT_TYPE_LPC* = 0x04 + TRANSPORT_TYPE_WMSG* = 0x08 + RPC_P_ADDR_FORMAT_TCP_IPV4* = 1 + RPC_P_ADDR_FORMAT_TCP_IPV6* = 2 + RPC_PROXY_CONNECTION_TYPE_IN_PROXY* = 0 + RPC_PROXY_CONNECTION_TYPE_OUT_PROXY* = 1 + RPC_C_NS_SYNTAX_DEFAULT* = 0 + RPC_C_NS_SYNTAX_DCE* = 3 + RPC_C_PROFILE_DEFAULT_ELT* = 0 + RPC_C_PROFILE_ALL_ELT* = 1 + RPC_C_PROFILE_ALL_ELTS* = RPC_C_PROFILE_ALL_ELT + RPC_C_PROFILE_MATCH_BY_IF* = 2 + RPC_C_PROFILE_MATCH_BY_MBR* = 3 + RPC_C_PROFILE_MATCH_BY_BOTH* = 4 + RPC_C_NS_DEFAULT_EXP_AGE* = -1 + RPC_S_OK* = ERROR_SUCCESS + RPC_S_INVALID_ARG* = ERROR_INVALID_PARAMETER + RPC_S_OUT_OF_MEMORY* = ERROR_OUTOFMEMORY + RPC_S_OUT_OF_THREADS* = ERROR_MAX_THRDS_REACHED + RPC_S_INVALID_LEVEL* = ERROR_INVALID_PARAMETER + RPC_S_BUFFER_TOO_SMALL* = ERROR_INSUFFICIENT_BUFFER + RPC_S_INVALID_SECURITY_DESC* = ERROR_INVALID_SECURITY_DESCR + RPC_S_ACCESS_DENIED* = ERROR_ACCESS_DENIED + RPC_S_SERVER_OUT_OF_MEMORY* = ERROR_NOT_ENOUGH_SERVER_MEMORY + RPC_S_ASYNC_CALL_PENDING* = ERROR_IO_PENDING + RPC_S_UNKNOWN_PRINCIPAL* = ERROR_NONE_MAPPED + RPC_S_TIMEOUT* = ERROR_TIMEOUT + RPC_X_NO_MEMORY* = RPC_S_OUT_OF_MEMORY + RPC_X_INVALID_BOUND* = RPC_S_INVALID_BOUND + RPC_X_INVALID_TAG* = RPC_S_INVALID_TAG + RPC_X_ENUM_VALUE_TOO_LARGE* = RPC_X_ENUM_VALUE_OUT_OF_RANGE + RPC_X_SS_CONTEXT_MISMATCH* = ERROR_INVALID_HANDLE + RPC_X_INVALID_BUFFER* = ERROR_INVALID_USER_BUFFER + RPC_X_PIPE_APP_MEMORY* = ERROR_OUTOFMEMORY + RPC_X_INVALID_PIPE_OPERATION* = RPC_X_WRONG_PIPE_ORDER + rpcNotificationTypeNone* = 0 + rpcNotificationTypeEvent* = 1 + rpcNotificationTypeApc* = 2 + rpcNotificationTypeIoc* = 3 + rpcNotificationTypeHwnd* = 4 + rpcNotificationTypeCallback* = 5 + rpcCallComplete* = 0 + rpcSendComplete* = 1 + rpcReceiveComplete* = 2 + RPC_C_NOTIFY_ON_SEND_COMPLETE* = 0x1 + RPC_C_INFINITE_TIMEOUT* = INFINITE + eeptAnsiString* = 1 + eeptUnicodeString* = 2 + eeptLongVal* = 3 + eeptShortVal* = 4 + eeptPointerVal* = 5 + eeptNone* = 6 + eeptBinary* = 7 + maxNumberOfEEInfoParams* = 4 + RPC_EEINFO_VERSION* = 1 + eEInfoPreviousRecordsMissing* = 1 + eEInfoNextRecordsMissing* = 2 + eEInfoUseFileTime* = 4 + eEInfoGCCOM* = 11 + eEInfoGCFRS* = 12 + RPC_CALL_ATTRIBUTES_VERSION* = 1 + RPC_QUERY_SERVER_PRINCIPAL_NAME* = 2 + RPC_QUERY_CLIENT_PRINCIPAL_NAME* = 4 + rctInvalid* = 0 + rctNormal* = 1 + rctTraining* = 2 + rctGuaranteed* = 3 + rlafInvalid* = 0 + rlafIPv4* = 1 + rlafIPv6* = 2 + rpcNotificationCallNone* = 0 + rpcNotificationClientDisconnect* = 1 + rpcNotificationCallCancel* = 2 + rcclInvalid* = 0 + rcclLocal* = 1 + rcclRemote* = 2 + rcclClientUnknownLocality* = 3 + RPCPROXY_H_VERSION* = 475 + RPC_C_NO_CREDENTIALS* = RPC_AUTH_IDENTITY_HANDLE(-1) + RPC_CONTEXT_HANDLE_DEFAULT_GUARD* = HANDLE(-4083) +type + NDR_NOTIFY2_ROUTINE* = proc (flag: boolean): void {.stdcall.} + RPC_CLIENT_ALLOC* = proc (Size: int): pointer {.stdcall.} + RPC_CLIENT_FREE* = proc (Ptr: pointer): void {.stdcall.} + RPC_OBJECT_INQ_FN* = proc (ObjectUuid: ptr UUID, TypeUuid: ptr UUID, Status: ptr RPC_STATUS): void {.stdcall.} + RPC_IF_CALLBACK_FN* = proc (InterfaceUuid: RPC_IF_HANDLE, Context: pointer): RPC_STATUS {.stdcall.} + RPC_SECURITY_CALLBACK_FN* = proc (Context: pointer): void {.stdcall.} + RPC_NEW_HTTP_PROXY_CHANNEL* = proc (RedirectorStage: RPC_HTTP_REDIRECTOR_STAGE, ServerName: ptr uint16, ServerPort: ptr uint16, RemoteUser: ptr uint16, AuthType: ptr uint16, ResourceUuid: pointer, Metadata: pointer, SessionId: pointer, Interface: pointer, Reserved: pointer, Flags: int32, NewServerName: ptr ptr uint16, NewServerPort: ptr ptr uint16): RPC_STATUS {.stdcall.} + RPC_HTTP_PROXY_FREE_STRING* = proc (String: ptr uint16): void {.stdcall.} + RPC_AUTH_KEY_RETRIEVAL_FN* = proc (Arg: pointer, ServerPrincName: ptr uint16, KeyVer: int32, Key: ptr pointer, Status: ptr RPC_STATUS): void {.stdcall.} + RPC_MGMT_AUTHORIZATION_FN* = proc (ClientBinding: RPC_BINDING_HANDLE, RequestedMgmtOperation: int32, Status: ptr RPC_STATUS): int32 {.stdcall.} + RPC_FORWARD_FUNCTION* = proc (InterfaceId: ptr UUID, InterfaceVersion: ptr RPC_VERSION, ObjectId: ptr UUID, Rpcpro: ptr uint8, ppDestEndpoint: ptr pointer): RPC_STATUS {.stdcall.} + RPC_ADDRESS_CHANGE_FN* = proc (arg: pointer): void {.stdcall.} + PRPC_RUNDOWN* = proc (AssociationContext: pointer): void {.stdcall.} + RPCLT_PDU_FILTER_FUNC* = proc (Buffer: pointer, BufferLength: int32, fDatagram: int32): void {.stdcall.} + RPC_SETFILTER_FUNC* = proc (pfnFilter: RPCLT_PDU_FILTER_FUNC): void {.stdcall.} + RPC_BLOCKING_FN* = proc (hWnd: pointer, Context: pointer, hSyncEvent: pointer): RPC_STATUS {.stdcall.} + I_RpcProxyIsValidMachineFn* = proc (pszMachine: ptr char, pszDotMachine: ptr char, dwPortNumber: int32): RPC_STATUS {.stdcall.} + I_RpcProxyGetClientAddressFn* = proc (Context: pointer, Buffer: ptr char, BufferLength: ptr int32): RPC_STATUS {.stdcall.} + I_RpcProxyGetConnectionTimeoutFn* = proc (ConnectionTimeout: ptr int32): RPC_STATUS {.stdcall.} + RPC_C_OPT_METADATA_DESCRIPTOR* {.pure.} = object + BufferSize*: int32 + Buffer*: ptr char + RDR_CALLOUT_STATE* {.pure.} = object + LastError*: RPC_STATUS + LastEEInfo*: pointer + LastCalledStage*: RPC_HTTP_REDIRECTOR_STAGE + ServerName*: ptr uint16 + ServerPort*: ptr uint16 + RemoteUser*: ptr uint16 + AuthType*: ptr uint16 + ResourceTypePresent*: uint8 + MetadataPresent*: uint8 + SessionIdPresent*: uint8 + InterfacePresent*: uint8 + ResourceType*: UUID + Metadata*: RPC_C_OPT_METADATA_DESCRIPTOR + SessionId*: UUID + Interface*: RPC_SYNTAX_IDENTIFIER + CertContext*: pointer + I_RpcPerformCalloutFn* = proc (Context: pointer, CallOutState: ptr RDR_CALLOUT_STATE, Stage: RPC_HTTP_REDIRECTOR_STAGE): RPC_STATUS {.stdcall.} + I_RpcFreeCalloutStateFn* = proc (CallOutState: ptr RDR_CALLOUT_STATE): void {.stdcall.} + RPCNOTIFICATION_ROUTINE* = proc (pAsync: ptr RPC_ASYNC_STATE, Context: pointer, Event: RPC_ASYNC_EVENT): void {.stdcall.} + USER_MARSHAL_CB* {.pure.} = object + Flags*: int32 + pStubMsg*: PMIDL_STUB_MESSAGE + pReserve*: PFORMAT_STRING + Signature*: int32 + CBType*: USER_MARSHAL_CB_TYPE + pFormat*: PFORMAT_STRING + pTypeFormat*: PFORMAT_STRING + MIDL_FORMAT_STRING* {.pure.} = object + Pad*: int16 + Format*: UncheckedArray[uint8] + CLIENT_CALL_RETURN* {.pure, union.} = object + Pointer*: pointer + Simple*: LONG_PTR + NDR_USER_MARSHAL_INFO_LEVEL1* {.pure.} = object + Buffer*: pointer + BufferSize*: int32 + pfnAllocate*: proc(P1: int): pointer {.stdcall.} + pfnFree*: proc(P1: pointer): void {.stdcall.} + pRpcChannelBuffer*: ptr IRpcChannelBuffer + Reserved*: array[5, ULONG_PTR] + NDR_USER_MARSHAL_INFO_UNION1* {.pure, union.} = object + Level1*: NDR_USER_MARSHAL_INFO_LEVEL1 + NDR_USER_MARSHAL_INFO* {.pure.} = object + InformationLevel*: int32 + union1*: NDR_USER_MARSHAL_INFO_UNION1 + RPC_IF_ID* {.pure.} = object + Uuid*: UUID + VersMajor*: uint16 + VersMinor*: uint16 + RPC_PROTSEQ_VECTORA* {.pure.} = object + Count*: int32 + Protseq*: array[1, ptr uint8] + RPC_PROTSEQ_VECTORW* {.pure.} = object + Count*: int32 + Protseq*: array[1, ptr uint16] + RPC_STATS_VECTOR* {.pure.} = object + Count*: int32 + Stats*: array[1, int32] + RPC_IF_ID_VECTOR* {.pure.} = object + Count*: int32 + IfId*: array[1, ptr RPC_IF_ID] + RPC_TRANSFER_SYNTAX* {.pure.} = object + Uuid*: UUID + VersMajor*: uint16 + VersMinor*: uint16 + I_RpcProxyCallbackInterface* {.pure.} = object + IsValidMachineFn*: I_RpcProxyIsValidMachineFn + GetClientAddressFn*: I_RpcProxyGetClientAddressFn + GetConnectionTimeoutFn*: I_RpcProxyGetConnectionTimeoutFn + PerformCalloutFn*: I_RpcPerformCalloutFn + FreeCalloutStateFn*: I_RpcFreeCalloutStateFn + BinaryParam* {.pure.} = object + Buffer*: pointer + Size*: int16 + RPC_EE_INFO_PARAM_u* {.pure, union.} = object + AnsiString*: LPSTR + UnicodeString*: LPWSTR + LVal*: int32 + SVal*: int16 + PVal*: ULONGLONG + BVal*: BinaryParam + RPC_EE_INFO_PARAM* {.pure.} = object + ParameterType*: ExtendedErrorParamTypes + padding*: array[4, byte] + u*: RPC_EE_INFO_PARAM_u + RPC_EXTENDED_ERROR_INFO_u* {.pure, union.} = object + SystemTime*: SYSTEMTIME + FileTime*: FILETIME + RPC_EXTENDED_ERROR_INFO* {.pure.} = object + Version*: ULONG + ComputerName*: LPWSTR + ProcessID*: ULONG + u*: RPC_EXTENDED_ERROR_INFO_u + GeneratingComponent*: ULONG + Status*: ULONG + DetectionLocation*: USHORT + Flags*: USHORT + NumberOfParameters*: int32 + padding*: array[4, byte] + Parameters*: array[maxNumberOfEEInfoParams, RPC_EE_INFO_PARAM] + RPC_ERROR_ENUM_HANDLE* {.pure.} = object + Signature*: ULONG + CurrentPos*: pointer + Head*: pointer + CStdStubBuffer* {.pure.} = object + lpVtbl*: ptr IRpcStubBufferVtbl + RefCount*: int32 + pvServerObject*: ptr IUnknown + pCallFactoryVtbl*: ptr ICallFactoryVtbl + pAsyncIID*: ptr IID + pPSFactory*: ptr IPSFactoryBuffer + pRMBVtbl*: ptr IReleaseMarshalBuffersVtbl + CStdPSFactoryBuffer* {.pure.} = object + lpVtbl*: ptr IPSFactoryBufferVtbl + RefCount*: int32 + pProxyFileList*: ptr ptr ProxyFileInfo + Filler1*: int32 +proc I_RpcNsGetBuffer*(Message: PRPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc I_RpcNsSendReceive*(Message: PRPC_MESSAGE, Handle: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc I_RpcNsRaiseException*(Message: PRPC_MESSAGE, Status: RPC_STATUS): void {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc I_RpcReBindBuffer*(Message: PRPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc NDRCContextBinding*(CContext: NDR_CCONTEXT): RPC_BINDING_HANDLE {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRCContextMarshall*(CContext: NDR_CCONTEXT, pBuff: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRCContextUnmarshall*(pCContext: ptr NDR_CCONTEXT, hBinding: RPC_BINDING_HANDLE, pBuff: pointer, DataRepresentation: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextMarshall*(CContext: NDR_SCONTEXT, pBuff: pointer, userRunDownIn: NDR_RUNDOWN): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextUnmarshall*(pBuff: pointer, DataRepresentation: int32): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextMarshallEx*(BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: pointer, userRunDownIn: NDR_RUNDOWN): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextMarshall2*(BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: pointer, userRunDownIn: NDR_RUNDOWN, CtxGuard: pointer, Flags: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextUnmarshallEx*(BindingHandle: RPC_BINDING_HANDLE, pBuff: pointer, DataRepresentation: int32): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NDRSContextUnmarshall2*(BindingHandle: RPC_BINDING_HANDLE, pBuff: pointer, DataRepresentation: int32, CtxGuard: pointer, Flags: int32): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsDestroyClientContext*(ContextHandle: ptr pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleTypeMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, FormatChar: uint8): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPointerMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleStructMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStructMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingStructMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexStructMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFixedArrayMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantArrayMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingArrayMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrVaryingArrayMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexArrayMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonConformantStringMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStringMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrEncapsulatedUnionMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonEncapsulatedUnionMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrByteCountPointerMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrXmitOrRepAsMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrInterfacePointerMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrClientContextMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_CCONTEXT, fCheck: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerContextMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerContextNewMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleTypeUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, FormatChar: uint8): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRangeUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCorrelationInitialize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: pointer, CacheSize: int32, flags: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCorrelationPass*(pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCorrelationFree*(pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPointerUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleStructUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStructUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingStructUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexStructUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFixedArrayUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantArrayUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingArrayUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrVaryingArrayUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexArrayUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonConformantStringUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStringUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrEncapsulatedUnionUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonEncapsulatedUnionUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrByteCountPointerUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrXmitOrRepAsUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrInterfacePointerUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr ptr uint8, pFormat: PFORMAT_STRING, fMustAlloc: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrClientContextUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pContextHandle: ptr NDR_CCONTEXT, BindHandle: RPC_BINDING_HANDLE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerContextUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrContextHandleInitialize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerContextNewUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): NDR_SCONTEXT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPointerBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleStructBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStructBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingStructBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexStructBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFixedArrayBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantArrayBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingArrayBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrVaryingArrayBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexArrayBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStringBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonConformantStringBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrEncapsulatedUnionBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonEncapsulatedUnionBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrByteCountPointerBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrXmitOrRepAsBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrInterfacePointerBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrContextHandleSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPointerMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleStructMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStructMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingStructMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexStructMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFixedArrayMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantArrayMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingArrayMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrVaryingArrayMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexArrayMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStringMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonConformantStringMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrEncapsulatedUnionMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonEncapsulatedUnionMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrXmitOrRepAsMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrInterfacePointerMemorySize*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPointerFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSimpleStructFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantStructFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingStructFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexStructFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFixedArrayFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantArrayFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConformantVaryingArrayFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrVaryingArrayFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrComplexArrayFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrEncapsulatedUnionFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNonEncapsulatedUnionFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrByteCountPointerFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrXmitOrRepAsFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrInterfacePointerFree*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: ptr uint8, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConvert2*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, NumberParams: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrConvert*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrUserMarshalSimpleTypeConvert*(pFlags: ptr int32, pBuffer: ptr uint8, FormatChar: uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrClientInitializeNew*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerInitializeNew*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerInitializePartial*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, RequestedBufferSize: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrClientInitialize*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerInitialize*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerInitializeUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pRpcMsg: PRPC_MESSAGE): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerInitializeMarshall*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrGetBuffer*(pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: int32, Handle: RPC_BINDING_HANDLE): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNsGetBuffer*(pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: int32, Handle: RPC_BINDING_HANDLE): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrSendReceive*(pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: ptr uint8): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrNsSendReceive*(pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: ptr uint8, pAutoHandle: ptr RPC_BINDING_HANDLE): ptr uint8 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFreeBuffer*(pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrGetDcomProtocolVersion*(pStubMsg: PMIDL_STUB_MESSAGE, pVersion: ptr RPC_VERSION): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrAsyncServerCall*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrDcomAsyncStubCall*(pThis: ptr IRpcStubBuffer, pChannel: ptr IRpcChannelBuffer, pRpcMsg: PRPC_MESSAGE, pdwStubPhase: ptr int32): LONG32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrStubCall2*(pThis: ptr IRpcStubBuffer, pChannel: ptr IRpcChannelBuffer, pRpcMsg: PRPC_MESSAGE, pdwStubPhase: ptr int32): LONG32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrServerCall2*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrMapCommAndFaultStatus*(pStubMsg: PMIDL_STUB_MESSAGE, pCommStatus: ptr int32, pFaultStatus: ptr int32, Status: RPC_STATUS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsAllocate*(Size: int): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsDisableAllocate*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsEnableAllocate*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsFree*(NodeToFree: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsGetThreadHandle*(): RPC_SS_THREAD_HANDLE {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsSetClientAllocFree*(ClientAlloc: RPC_CLIENT_ALLOC, ClientFree: RPC_CLIENT_FREE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsSetThreadHandle*(Id: RPC_SS_THREAD_HANDLE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsSwapClientAllocFree*(ClientAlloc: RPC_CLIENT_ALLOC, ClientFree: RPC_CLIENT_FREE, OldClientAlloc: RPC_CLIENT_ALLOC, OldClientFree: RPC_CLIENT_FREE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmAllocate*(Size: int, pStatus: ptr RPC_STATUS): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmClientFree*(pNodeToFree: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmDestroyClientContext*(ContextHandle: ptr pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmDisableAllocate*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmEnableAllocate*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmFree*(NodeToFree: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmGetThreadHandle*(pStatus: ptr RPC_STATUS): RPC_SS_THREAD_HANDLE {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmSetClientAllocFree*(ClientAlloc: RPC_CLIENT_ALLOC, ClientFree: RPC_CLIENT_FREE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmSetThreadHandle*(Id: RPC_SS_THREAD_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSmSwapClientAllocFree*(ClientAlloc: RPC_CLIENT_ALLOC, ClientFree: RPC_CLIENT_FREE, OldClientAlloc: RPC_CLIENT_ALLOC, OldClientFree: RPC_CLIENT_FREE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSsEnableAllocate*(pMessage: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSsDisableAllocate*(pMessage: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSmSetClientToOsf*(pMessage: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSmClientAllocate*(Size: int): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSmClientFree*(NodeToFree: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSsDefaultAllocate*(Size: int): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrRpcSsDefaultFree*(NodeToFree: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerXlatInit*(NumberOfPointers: int32, XlatSide: XLAT_SIDE): PFULL_PTR_XLAT_TABLES {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerXlatFree*(pXlatTables: PFULL_PTR_XLAT_TABLES): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerQueryPointer*(pXlatTables: PFULL_PTR_XLAT_TABLES, pPointer: pointer, QueryType: uint8, pRefId: ptr int32): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerQueryRefId*(pXlatTables: PFULL_PTR_XLAT_TABLES, RefId: int32, QueryType: uint8, ppPointer: ptr pointer): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerInsertRefId*(pXlatTables: PFULL_PTR_XLAT_TABLES, RefId: int32, pPointer: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrFullPointerFree*(pXlatTables: PFULL_PTR_XLAT_TABLES, Pointer: pointer): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrAllocate*(pStubMsg: PMIDL_STUB_MESSAGE, Len: int): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrClearOutParameters*(pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, ArgAddr: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrOleAllocate*(Size: int): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrOleFree*(NodeToFree: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrGetUserMarshalInfo*(pFlags: ptr int32, InformationLevel: int32, pMarshalInfo: ptr NDR_USER_MARSHAL_INFO): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCreateServerInterfaceFromStub*(pStub: ptr IRpcStubBuffer, pServerIf: ptr RPC_SERVER_INTERFACE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPartialIgnoreClientMarshall*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPartialIgnoreServerUnmarshall*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPartialIgnoreClientBufferSize*(pStubMsg: PMIDL_STUB_MESSAGE, pMemory: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrPartialIgnoreServerInitialize*(pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: ptr pointer, pFormat: PFORMAT_STRING): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcUserFree*(AsyncHandle: handle_t, pBuffer: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingCopy*(SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingFree*(Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetOption*(hBinding: RPC_BINDING_HANDLE, option: int32, optionValue: ULONG_PTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqOption*(hBinding: RPC_BINDING_HANDLE, option: int32, pOptionValue: ptr ULONG_PTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingFromStringBindingA*(StringBinding: RPC_CSTR, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingFromStringBindingW*(StringBinding: RPC_WSTR, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsGetContextBinding*(ContextHandle: pointer, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqObject*(Binding: RPC_BINDING_HANDLE, ObjectUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingReset*(Binding: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetObject*(Binding: RPC_BINDING_HANDLE, ObjectUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqDefaultProtectLevel*(AuthnSvc: int32, AuthnLevel: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingToStringBindingA*(Binding: RPC_BINDING_HANDLE, StringBinding: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingToStringBindingW*(Binding: RPC_BINDING_HANDLE, StringBinding: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingVectorFree*(BindingVector: ptr ptr RPC_BINDING_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringBindingComposeA*(ObjUuid: RPC_CSTR, Protseq: RPC_CSTR, NetworkAddr: RPC_CSTR, Endpoint: RPC_CSTR, Options: RPC_CSTR, StringBinding: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringBindingComposeW*(ObjUuid: RPC_WSTR, Protseq: RPC_WSTR, NetworkAddr: RPC_WSTR, Endpoint: RPC_WSTR, Options: RPC_WSTR, StringBinding: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringBindingParseA*(StringBinding: RPC_CSTR, ObjUuid: ptr RPC_CSTR, Protseq: ptr RPC_CSTR, NetworkAddr: ptr RPC_CSTR, Endpoint: ptr RPC_CSTR, NetworkOptions: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringBindingParseW*(StringBinding: RPC_WSTR, ObjUuid: ptr RPC_WSTR, Protseq: ptr RPC_WSTR, NetworkAddr: ptr RPC_WSTR, Endpoint: ptr RPC_WSTR, NetworkOptions: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringFreeA*(String: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcStringFreeW*(String: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcIfInqId*(RpcIfHandle: RPC_IF_HANDLE, RpcIfId: ptr RPC_IF_ID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNetworkIsProtseqValidA*(Protseq: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNetworkIsProtseqValidW*(Protseq: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqComTimeout*(Binding: RPC_BINDING_HANDLE, Timeout: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtSetComTimeout*(Binding: RPC_BINDING_HANDLE, Timeout: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtSetCancelTimeout*(Timeout: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNetworkInqProtseqsA*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORA): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNetworkInqProtseqsW*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORW): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcObjectInqType*(ObjUuid: ptr UUID, TypeUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcObjectSetInqFn*(InquiryFn: RPC_OBJECT_INQ_FN): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcObjectSetType*(ObjUuid: ptr UUID, TypeUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcProtseqVectorFreeA*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORA): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcProtseqVectorFreeW*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORW): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqBindings*(BindingVector: ptr ptr RPC_BINDING_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqIf*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, MgrEpv: ptr ptr RPC_MGR_EPV): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerListen*(MinimumCallThreads: int32, MaxCalls: int32, DontWait: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerRegisterIf*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, MgrEpv: ptr RPC_MGR_EPV): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerRegisterIfEx*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, MgrEpv: ptr RPC_MGR_EPV, Flags: int32, MaxCalls: int32, IfCallback: RPC_IF_CALLBACK_FN): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerRegisterIf2*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, MgrEpv: ptr RPC_MGR_EPV, Flags: int32, MaxCalls: int32, MaxRpcSize: int32, IfCallbackFn: RPC_IF_CALLBACK_FN): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUnregisterIf*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, WaitForCallsToComplete: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUnregisterIfEx*(IfSpec: RPC_IF_HANDLE, MgrTypeUuid: ptr UUID, RundownContextHandles: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseAllProtseqs*(MaxCalls: int32, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseAllProtseqsEx*(MaxCalls: int32, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseAllProtseqsIf*(MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseAllProtseqsIfEx*(MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqA*(Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqExA*(Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqW*(Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqExW*(Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqEpA*(Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqEpExA*(Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqEpW*(Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqEpExW*(Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqIfA*(Protseq: RPC_CSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqIfExA*(Protseq: RPC_CSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqIfW*(Protseq: RPC_WSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUseProtseqIfExW*(Protseq: RPC_WSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerYield*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtStatsVectorFree*(StatsVector: ptr ptr RPC_STATS_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqStats*(Binding: RPC_BINDING_HANDLE, Statistics: ptr ptr RPC_STATS_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtIsServerListening*(Binding: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtStopServerListening*(Binding: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtWaitServerListen*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtSetServerStackSize*(ThreadStackSize: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsDontSerializeContext*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEnableIdleCleanup*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqIfIds*(Binding: RPC_BINDING_HANDLE, IfIdVector: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcIfIdVectorFree*(IfIdVector: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqServerPrincNameA*(Binding: RPC_BINDING_HANDLE, AuthnSvc: int32, ServerPrincName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtInqServerPrincNameW*(Binding: RPC_BINDING_HANDLE, AuthnSvc: int32, ServerPrincName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqDefaultPrincNameA*(AuthnSvc: int32, PrincName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqDefaultPrincNameW*(AuthnSvc: int32, PrincName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpResolveBinding*(Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNsBindingInqEntryNameA*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNsBindingInqEntryNameW*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcImpersonateClient*(BindingHandle: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcRevertToSelfEx*(BindingHandle: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcRevertToSelf*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthClientA*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthClientW*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthClientExA*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32, Flags: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthClientExW*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32, Flags: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthInfoA*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthInfoW*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetAuthInfoA*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetAuthInfoExA*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32, SecurityQos: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetAuthInfoW*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingSetAuthInfoExW*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthInfoExA*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32, RpcQosVersion: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingInqAuthInfoExW*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32, RpcQosVersion: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerRegisterAuthInfoA*(ServerPrincName: RPC_CSTR, AuthnSvc: int32, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerRegisterAuthInfoW*(ServerPrincName: RPC_WSTR, AuthnSvc: int32, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingServerFromClient*(ClientBinding: RPC_BINDING_HANDLE, ServerBinding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcTestCancel*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerTestCancel*(BindingHandle: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcCancelThread*(Thread: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcCancelThreadEx*(Thread: pointer, Timeout: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidCreate*(Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidCreateSequential*(Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidToStringA*(Uuid: ptr UUID, StringUuid: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidFromStringA*(StringUuid: RPC_CSTR, Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidToStringW*(Uuid: ptr UUID, StringUuid: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidFromStringW*(StringUuid: RPC_WSTR, Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidCreateNil*(NilUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidEqual*(Uuid1: ptr UUID, Uuid2: ptr UUID, Status: ptr RPC_STATUS): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidHash*(Uuid: ptr UUID, Status: ptr RPC_STATUS): uint16 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc UuidIsNil*(Uuid: ptr UUID, Status: ptr RPC_STATUS): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpRegisterNoReplaceA*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpRegisterNoReplaceW*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpRegisterA*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpRegisterW*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcEpUnregister*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc DceErrorInqTextA*(RpcStatus: RPC_STATUS, ErrorText: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc DceErrorInqTextW*(RpcStatus: RPC_STATUS, ErrorText: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEpEltInqBegin*(EpBinding: RPC_BINDING_HANDLE, InquiryType: int32, IfId: ptr RPC_IF_ID, VersOption: int32, ObjectUuid: ptr UUID, InquiryContext: ptr RPC_EP_INQ_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEpEltInqDone*(InquiryContext: ptr RPC_EP_INQ_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEpEltInqNextA*(InquiryContext: RPC_EP_INQ_HANDLE, IfId: ptr RPC_IF_ID, Binding: ptr RPC_BINDING_HANDLE, ObjectUuid: ptr UUID, Annotation: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEpEltInqNextW*(InquiryContext: RPC_EP_INQ_HANDLE, IfId: ptr RPC_IF_ID, Binding: ptr RPC_BINDING_HANDLE, ObjectUuid: ptr UUID, Annotation: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtEpUnregister*(EpBinding: RPC_BINDING_HANDLE, IfId: ptr RPC_IF_ID, Binding: RPC_BINDING_HANDLE, ObjectUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcMgmtSetAuthorizationFn*(AuthorizationFn: RPC_MGMT_AUTHORIZATION_FN): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingCreateA*(Template: ptr RPC_BINDING_HANDLE_TEMPLATE, Security: ptr RPC_BINDING_HANDLE_SECURITY, Options: ptr RPC_BINDING_HANDLE_OPTIONS, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingCreateW*(Template: ptr RPC_BINDING_HANDLE_TEMPLATE, Security: ptr RPC_BINDING_HANDLE_SECURITY, Options: ptr RPC_BINDING_HANDLE_OPTIONS, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqBindingHandle*(Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcNegotiateTransferSyntax*(Message: ptr RPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcGetBuffer*(Message: ptr RPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcGetBufferWithObject*(Message: ptr RPC_MESSAGE, ObjectUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcSendReceive*(Message: ptr RPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcFreeBuffer*(Message: ptr RPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcSend*(Message: PRPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcReceive*(Message: PRPC_MESSAGE, Size: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcFreePipeBuffer*(Message: ptr RPC_MESSAGE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcReallocPipeBuffer*(Message: PRPC_MESSAGE, NewSize: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcRequestMutex*(Mutex: ptr I_RPC_MUTEX): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcClearMutex*(Mutex: I_RPC_MUTEX): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcDeleteMutex*(Mutex: I_RPC_MUTEX): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcAllocate*(Size: int32): pointer {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcFree*(Object: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcPauseExecution*(Milliseconds: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcGetExtendedError*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcGetCurrentCallHandle*(): RPC_BINDING_HANDLE {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcNsInterfaceExported*(EntryNameSyntax: int32, EntryName: ptr uint16, RpcInterfaceInformation: ptr RPC_SERVER_INTERFACE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcNsInterfaceUnexported*(EntryNameSyntax: int32, EntryName: ptr uint16, RpcInterfaceInformation: ptr RPC_SERVER_INTERFACE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingToStaticStringBindingW*(Binding: RPC_BINDING_HANDLE, StringBinding: ptr ptr uint16): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqSecurityContext*(Binding: RPC_BINDING_HANDLE, SecurityContextHandle: ptr pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqWireIdForSnego*(Binding: RPC_BINDING_HANDLE, WireId: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqMarshalledTargetInfo*(Binding: RPC_BINDING_HANDLE, MarshalledTargetInfoLength: ptr int32, MarshalledTargetInfo: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqLocalClientPID*(Binding: RPC_BINDING_HANDLE, Pid: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingHandleToAsyncHandle*(Binding: RPC_BINDING_HANDLE, AsyncHandle: ptr pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcNsBindingSetEntryNameW*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcNsBindingSetEntryNameA*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerUseProtseqEp2A*(NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerUseProtseqEp2W*(NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerUseProtseq2W*(NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerUseProtseq2A*(NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqDynamicEndpointW*(Binding: RPC_BINDING_HANDLE, DynamicEndpoint: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqDynamicEndpointA*(Binding: RPC_BINDING_HANDLE, DynamicEndpoint: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerCheckClientRestriction*(Context: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingInqTransportType*(Binding: RPC_BINDING_HANDLE, Type: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcIfInqTransferSyntaxes*(RpcIfHandle: RPC_IF_HANDLE, TransferSyntaxes: ptr RPC_TRANSFER_SYNTAX, TransferSyntaxSize: int32, TransferSyntaxCount: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_UuidCreate*(Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingCopy*(SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcBindingIsClientLocal*(BindingHandle: RPC_BINDING_HANDLE, ClientLocalFlag: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcSsDontSerializeContext*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerRegisterForwardFunction*(pForwardFunction: RPC_FORWARD_FUNCTION): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerInqAddressChangeFn*(): RPC_ADDRESS_CHANGE_FN {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerSetAddressChangeFn*(pAddressChangeFn: RPC_ADDRESS_CHANGE_FN): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerInqLocalConnAddress*(Binding: RPC_BINDING_HANDLE, Buffer: pointer, BufferSize: ptr int32, AddressFormat: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcSessionStrictContextHandle*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcTurnOnEEInfoPropagation*(): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcServerInqTransportType*(Type: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcMapWin32Status*(Status: RPC_STATUS): LONG32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcRecordCalloutFailure*(RpcStatus: RPC_STATUS, CallOutState: ptr RDR_CALLOUT_STATE, DllName: ptr uint16): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcNsBindingExportA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, BindingVec: ptr RPC_BINDING_VECTOR, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingUnexportA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingExportW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, BindingVec: ptr RPC_BINDING_VECTOR, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingUnexportW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingExportPnPA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingUnexportPnPA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingExportPnPW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingUnexportPnPW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingLookupBeginA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, BindingMaxCount: int32, LookupContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingLookupBeginW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, BindingMaxCount: int32, LookupContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingLookupNext*(LookupContext: RPC_NS_HANDLE, BindingVec: ptr ptr RPC_BINDING_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingLookupDone*(LookupContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupDeleteA*(GroupNameSyntax: int32, GroupName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrAddA*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrRemoveA*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrInqBeginA*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrInqNextA*(InquiryContext: RPC_NS_HANDLE, MemberName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupDeleteW*(GroupNameSyntax: int32, GroupName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrAddW*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrRemoveW*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrInqBeginW*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrInqNextW*(InquiryContext: RPC_NS_HANDLE, MemberName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsGroupMbrInqDone*(InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileDeleteA*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltAddA*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_CSTR, Priority: int32, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltRemoveA*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltInqBeginA*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, InquiryType: int32, IfId: ptr RPC_IF_ID, VersOption: int32, MemberNameSyntax: int32, MemberName: RPC_CSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltInqNextA*(InquiryContext: RPC_NS_HANDLE, IfId: ptr RPC_IF_ID, MemberName: ptr RPC_CSTR, Priority: ptr int32, Annotation: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileDeleteW*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltAddW*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_WSTR, Priority: int32, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltRemoveW*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltInqBeginW*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, InquiryType: int32, IfId: ptr RPC_IF_ID, VersOption: int32, MemberNameSyntax: int32, MemberName: RPC_WSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltInqNextW*(InquiryContext: RPC_NS_HANDLE, IfId: ptr RPC_IF_ID, MemberName: ptr RPC_WSTR, Priority: ptr int32, Annotation: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsProfileEltInqDone*(InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryObjectInqBeginA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryObjectInqBeginW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryObjectInqNext*(InquiryContext: RPC_NS_HANDLE, ObjUuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryObjectInqDone*(InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryExpandNameA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, ExpandedName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtBindingUnexportA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfId: ptr RPC_IF_ID, VersOption: int32, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryCreateA*(EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryDeleteA*(EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryInqIfIdsA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfIdVec: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtHandleSetExpAge*(NsHandle: RPC_NS_HANDLE, ExpirationAge: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtInqExpAge*(ExpirationAge: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtSetExpAge*(ExpirationAge: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsEntryExpandNameW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, ExpandedName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtBindingUnexportW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfId: ptr RPC_IF_ID, VersOption: int32, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryCreateW*(EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryDeleteW*(EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsMgmtEntryInqIfIdsW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfIdVec: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingImportBeginA*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, ImportContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingImportBeginW*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, ImportContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingImportNext*(ImportContext: RPC_NS_HANDLE, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingImportDone*(ImportContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcNsBindingSelect*(BindingVec: ptr RPC_BINDING_VECTOR, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc.} +proc RpcAsyncInitializeHandle*(pAsync: PRPC_ASYNC_STATE, Size: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcAsyncRegisterInfo*(pAsync: PRPC_ASYNC_STATE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcAsyncGetCallStatus*(pAsync: PRPC_ASYNC_STATE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcAsyncCompleteCall*(pAsync: PRPC_ASYNC_STATE, Reply: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcAsyncAbortCall*(pAsync: PRPC_ASYNC_STATE, ExceptionCode: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcAsyncCancelCall*(pAsync: PRPC_ASYNC_STATE, fAbort: WINBOOL): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorStartEnumeration*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorGetNextRecord*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE, CopyStrings: WINBOOL, ErrorInfo: ptr RPC_EXTENDED_ERROR_INFO): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorEndEnumeration*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorResetEnumeration*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorGetNumberOfRecords*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE, Records: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorSaveErrorInfo*(EnumHandle: ptr RPC_ERROR_ENUM_HANDLE, ErrorBlob: ptr PVOID, BlobSize: ptr int): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorLoadErrorInfo*(ErrorBlob: PVOID, BlobSize: int, EnumHandle: ptr RPC_ERROR_ENUM_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorAddRecord*(ErrorInfo: ptr RPC_EXTENDED_ERROR_INFO): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcErrorClearInformation*(): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcGetAuthorizationContextForClient*(ClientBinding: RPC_BINDING_HANDLE, ImpersonateOnReturn: WINBOOL, Reserved1: PVOID, pExpirationTime: PLARGE_INTEGER, Reserved2: LUID, Reserved3: DWORD, Reserved4: PVOID, pAuthzClientContext: ptr PVOID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcFreeAuthorizationContext*(pAuthzClientContext: ptr PVOID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsContextLockExclusive*(ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcSsContextLockShared*(ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqCallAttributesW*(ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerInqCallAttributesA*(ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcAsyncSetHandle*(Message: PRPC_MESSAGE, pAsync: PRPC_ASYNC_STATE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcAsyncAbortCall*(pAsync: PRPC_ASYNC_STATE, ExceptionCode: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc I_RpcExceptionFilter*(ExceptionCode: int32): int32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingBind*(pAsync: PRPC_ASYNC_STATE, Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcBindingUnbind*(Binding: RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerSubscribeForNotification*(Binding: RPC_BINDING_HANDLE, Notification: DWORD, NotificationType: RPC_NOTIFICATION_TYPES, NotificationInfo: ptr RPC_ASYNC_NOTIFICATION_INFO): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcServerUnsubscribeForNotification*(Binding: RPC_BINDING_HANDLE, Notification: RPC_NOTIFICATIONS, NotificationsQueued: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrProxyInitialize*(This: pointer, pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: int32): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrProxyGetBuffer*(This: pointer, pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrProxySendReceive*(This: pointer, pStubMsg: ptr MIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrProxyFreeBuffer*(This: pointer, pStubMsg: ptr MIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrProxyErrorHandler*(dwExceptionCode: DWORD): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrStubInitialize*(pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pRpcChannelBuffer: ptr IRpcChannelBuffer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrStubGetBuffer*(This: ptr IRpcStubBuffer, pRpcChannelBuffer: ptr IRpcChannelBuffer, pStubMsg: PMIDL_STUB_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_QueryInterface*(This: ptr IRpcStubBuffer, riid: REFIID, ppvObject: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_AddRef*(This: ptr IRpcStubBuffer): ULONG {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCStdStubBuffer_Release*(This: ptr IRpcStubBuffer, pPSF: ptr IPSFactoryBuffer): ULONG {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_Connect*(This: ptr IRpcStubBuffer, pUnkServer: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_Disconnect*(This: ptr IRpcStubBuffer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_Invoke*(This: ptr IRpcStubBuffer, pRpcMsg: ptr RPCOLEMESSAGE, pRpcChannelBuffer: ptr IRpcChannelBuffer): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_CountRefs*(This: ptr IRpcStubBuffer): ULONG {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_DebugServerQueryInterface*(This: ptr IRpcStubBuffer, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc CStdStubBuffer_DebugServerRelease*(This: ptr IRpcStubBuffer, pv: pointer): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrDllGetClassObject*(rclsid: REFCLSID, riid: REFIID, ppv: ptr pointer, pProxyFileList: ptr ptr ProxyFileInfo, pclsid: ptr CLSID, pPSFactoryBuffer: ptr CStdPSFactoryBuffer): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrDllCanUnloadNow*(pPSFactoryBuffer: ptr CStdPSFactoryBuffer): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrDllRegisterProxy*(hDll: HMODULE, pProxyFileList: ptr ptr ProxyFileInfo, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrDllUnregisterProxy*(hDll: HMODULE, pProxyFileList: ptr ptr ProxyFileInfo, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc NdrCStdStubBuffer2_Release*(This: ptr IRpcStubBuffer, pPSF: ptr IPSFactoryBuffer): ULONG {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcCertGeneratePrincipalNameW*(Context: PCCERT_CONTEXT, Flags: DWORD, pBuffer: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc RpcCertGeneratePrincipalNameA*(Context: PCCERT_CONTEXT, Flags: DWORD, pBuffer: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc.} +proc `Level1=`*(self: var NDR_USER_MARSHAL_INFO, x: NDR_USER_MARSHAL_INFO_LEVEL1) {.inline.} = self.union1.Level1 = x +proc Level1*(self: NDR_USER_MARSHAL_INFO): NDR_USER_MARSHAL_INFO_LEVEL1 {.inline.} = self.union1.Level1 +proc Level1*(self: var NDR_USER_MARSHAL_INFO): var NDR_USER_MARSHAL_INFO_LEVEL1 {.inline.} = self.union1.Level1 +when winimUnicode: + type + RPC_PROTSEQ_VECTOR* = RPC_PROTSEQ_VECTORW + RPC_SECURITY_QOS_V2* = RPC_SECURITY_QOS_V2_W + PRPC_SECURITY_QOS_V2* = PRPC_SECURITY_QOS_V2_W + RPC_HTTP_TRANSPORT_CREDENTIALS* = RPC_HTTP_TRANSPORT_CREDENTIALS_W + PRPC_HTTP_TRANSPORT_CREDENTIALS* = PRPC_HTTP_TRANSPORT_CREDENTIALS_W + RPC_SECURITY_QOS_V3* = RPC_SECURITY_QOS_V3_W + PRPC_SECURITY_QOS_V3* = PRPC_SECURITY_QOS_V3_W + RPC_CALL_LOCAL_ADDRESS_V1* = RPC_CALL_LOCAL_ADDRESS_V1_W + RPC_CALL_LOCAL_ADDRESS* = RPC_CALL_LOCAL_ADDRESS_W + RPC_CALL_ATTRIBUTES_V2* = RPC_CALL_ATTRIBUTES_V2_W + proc RpcBindingFromStringBinding*(StringBinding: RPC_WSTR, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingFromStringBindingW".} + proc RpcBindingToStringBinding*(Binding: RPC_BINDING_HANDLE, StringBinding: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingToStringBindingW".} + proc RpcStringBindingCompose*(ObjUuid: RPC_WSTR, Protseq: RPC_WSTR, NetworkAddr: RPC_WSTR, Endpoint: RPC_WSTR, Options: RPC_WSTR, StringBinding: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringBindingComposeW".} + proc RpcStringBindingParse*(StringBinding: RPC_WSTR, ObjUuid: ptr RPC_WSTR, Protseq: ptr RPC_WSTR, NetworkAddr: ptr RPC_WSTR, Endpoint: ptr RPC_WSTR, NetworkOptions: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringBindingParseW".} + proc RpcStringFree*(String: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringFreeW".} + proc RpcNetworkIsProtseqValid*(Protseq: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNetworkIsProtseqValidW".} + proc RpcNetworkInqProtseqs*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORW): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNetworkInqProtseqsW".} + proc RpcProtseqVectorFree*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORW): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcProtseqVectorFreeW".} + proc RpcServerUseProtseq*(Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqW".} + proc RpcServerUseProtseqEx*(Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqExW".} + proc RpcServerUseProtseqEp*(Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqEpW".} + proc RpcServerUseProtseqEpEx*(Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqEpExW".} + proc RpcServerUseProtseqIf*(Protseq: RPC_WSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqIfW".} + proc RpcServerUseProtseqIfEx*(Protseq: RPC_WSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqIfExW".} + proc RpcMgmtInqServerPrincName*(Binding: RPC_BINDING_HANDLE, AuthnSvc: int32, ServerPrincName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcMgmtInqServerPrincNameW".} + proc RpcServerInqDefaultPrincName*(AuthnSvc: int32, PrincName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerInqDefaultPrincNameW".} + proc RpcNsBindingInqEntryName*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNsBindingInqEntryNameW".} + proc RpcBindingInqAuthClient*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthClientW".} + proc RpcBindingInqAuthClientEx*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32, Flags: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthClientExW".} + proc RpcBindingInqAuthInfo*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthInfoW".} + proc RpcBindingSetAuthInfo*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingSetAuthInfoW".} + proc RpcServerRegisterAuthInfo*(ServerPrincName: RPC_WSTR, AuthnSvc: int32, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerRegisterAuthInfoW".} + proc RpcBindingInqAuthInfoEx*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_WSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32, RpcQosVersion: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthInfoExW".} + proc RpcBindingSetAuthInfoEx*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingSetAuthInfoExW".} + proc UuidFromString*(StringUuid: RPC_WSTR, Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "UuidFromStringW".} + proc UuidToString*(Uuid: ptr UUID, StringUuid: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "UuidToStringW".} + proc RpcEpRegisterNoReplace*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcEpRegisterNoReplaceW".} + proc RpcEpRegister*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcEpRegisterW".} + proc DceErrorInqText*(RpcStatus: RPC_STATUS, ErrorText: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "DceErrorInqTextW".} + proc RpcMgmtEpEltInqNext*(InquiryContext: RPC_EP_INQ_HANDLE, IfId: ptr RPC_IF_ID, Binding: ptr RPC_BINDING_HANDLE, ObjectUuid: ptr UUID, Annotation: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcMgmtEpEltInqNextW".} + proc RpcBindingCreate*(Template: ptr RPC_BINDING_HANDLE_TEMPLATE, Security: ptr RPC_BINDING_HANDLE_SECURITY, Options: ptr RPC_BINDING_HANDLE_OPTIONS, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingCreateW".} + proc I_RpcNsBindingSetEntryName*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcNsBindingSetEntryNameW".} + proc I_RpcServerUseProtseqEp2*(NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: int32, Endpoint: RPC_WSTR, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcServerUseProtseqEp2W".} + proc I_RpcServerUseProtseq2*(NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcServerUseProtseq2W".} + proc I_RpcBindingInqDynamicEndpoint*(Binding: RPC_BINDING_HANDLE, DynamicEndpoint: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcBindingInqDynamicEndpointW".} + proc RpcNsBindingLookupBegin*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, BindingMaxCount: int32, LookupContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingLookupBeginW".} + proc RpcNsBindingImportBegin*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, ImportContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingImportBeginW".} + proc RpcNsBindingExport*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, BindingVec: ptr RPC_BINDING_VECTOR, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingExportW".} + proc RpcNsBindingUnexport*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingUnexportW".} + proc RpcNsGroupDelete*(GroupNameSyntax: int32, GroupName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupDeleteW".} + proc RpcNsGroupMbrAdd*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrAddW".} + proc RpcNsGroupMbrRemove*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrRemoveW".} + proc RpcNsGroupMbrInqBegin*(GroupNameSyntax: int32, GroupName: RPC_WSTR, MemberNameSyntax: int32, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrInqBeginW".} + proc RpcNsGroupMbrInqNext*(InquiryContext: RPC_NS_HANDLE, MemberName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrInqNextW".} + proc RpcNsEntryExpandName*(EntryNameSyntax: int32, EntryName: RPC_WSTR, ExpandedName: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsEntryExpandNameW".} + proc RpcNsEntryObjectInqBegin*(EntryNameSyntax: int32, EntryName: RPC_WSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsEntryObjectInqBeginW".} + proc RpcNsMgmtBindingUnexport*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfId: ptr RPC_IF_ID, VersOption: int32, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtBindingUnexportW".} + proc RpcNsMgmtEntryCreate*(EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryCreateW".} + proc RpcNsMgmtEntryDelete*(EntryNameSyntax: int32, EntryName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryDeleteW".} + proc RpcNsMgmtEntryInqIfIds*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfIdVec: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryInqIfIdsW".} + proc RpcNsProfileDelete*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileDeleteW".} + proc RpcNsProfileEltAdd*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_WSTR, Priority: int32, Annotation: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltAddW".} + proc RpcNsProfileEltRemove*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltRemoveW".} + proc RpcNsProfileEltInqBegin*(ProfileNameSyntax: int32, ProfileName: RPC_WSTR, InquiryType: int32, IfId: ptr RPC_IF_ID, VersOption: int32, MemberNameSyntax: int32, MemberName: RPC_WSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltInqBeginW".} + proc RpcNsProfileEltInqNext*(InquiryContext: RPC_NS_HANDLE, IfId: ptr RPC_IF_ID, MemberName: ptr RPC_WSTR, Priority: ptr int32, Annotation: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltInqNextW".} + proc RpcNsBindingExportPnP*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingExportPnPW".} + proc RpcNsBindingUnexportPnP*(EntryNameSyntax: int32, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingUnexportPnPW".} + proc RpcServerInqCallAttributes*(ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerInqCallAttributesW".} + proc RpcCertGeneratePrincipalName*(Context: PCCERT_CONTEXT, Flags: DWORD, pBuffer: ptr RPC_WSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcCertGeneratePrincipalNameW".} +when winimAnsi: + type + RPC_PROTSEQ_VECTOR* = RPC_PROTSEQ_VECTORA + RPC_SECURITY_QOS_V2* = RPC_SECURITY_QOS_V2_A + PRPC_SECURITY_QOS_V2* = PRPC_SECURITY_QOS_V2_A + RPC_HTTP_TRANSPORT_CREDENTIALS* = RPC_HTTP_TRANSPORT_CREDENTIALS_A + PRPC_HTTP_TRANSPORT_CREDENTIALS* = PRPC_HTTP_TRANSPORT_CREDENTIALS_A + RPC_SECURITY_QOS_V3* = RPC_SECURITY_QOS_V3_A + PRPC_SECURITY_QOS_V3* = PRPC_SECURITY_QOS_V3_A + RPC_CALL_LOCAL_ADDRESS_V1* = RPC_CALL_LOCAL_ADDRESS_V1_A + RPC_CALL_LOCAL_ADDRESS* = RPC_CALL_LOCAL_ADDRESS_A + RPC_CALL_ATTRIBUTES_V2* = RPC_CALL_ATTRIBUTES_V2_A + proc RpcBindingFromStringBinding*(StringBinding: RPC_CSTR, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingFromStringBindingA".} + proc RpcBindingToStringBinding*(Binding: RPC_BINDING_HANDLE, StringBinding: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingToStringBindingA".} + proc RpcStringBindingCompose*(ObjUuid: RPC_CSTR, Protseq: RPC_CSTR, NetworkAddr: RPC_CSTR, Endpoint: RPC_CSTR, Options: RPC_CSTR, StringBinding: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringBindingComposeA".} + proc RpcStringBindingParse*(StringBinding: RPC_CSTR, ObjUuid: ptr RPC_CSTR, Protseq: ptr RPC_CSTR, NetworkAddr: ptr RPC_CSTR, Endpoint: ptr RPC_CSTR, NetworkOptions: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringBindingParseA".} + proc RpcStringFree*(String: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcStringFreeA".} + proc RpcNetworkIsProtseqValid*(Protseq: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNetworkIsProtseqValidA".} + proc RpcNetworkInqProtseqs*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORA): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNetworkInqProtseqsA".} + proc RpcProtseqVectorFree*(ProtseqVector: ptr ptr RPC_PROTSEQ_VECTORA): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcProtseqVectorFreeA".} + proc RpcServerUseProtseq*(Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqA".} + proc RpcServerUseProtseqEx*(Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqExA".} + proc RpcServerUseProtseqEp*(Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqEpA".} + proc RpcServerUseProtseqEpEx*(Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqEpExA".} + proc RpcServerUseProtseqIf*(Protseq: RPC_CSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqIfA".} + proc RpcServerUseProtseqIfEx*(Protseq: RPC_CSTR, MaxCalls: int32, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: pointer, Policy: PRPC_POLICY): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerUseProtseqIfExA".} + proc RpcMgmtInqServerPrincName*(Binding: RPC_BINDING_HANDLE, AuthnSvc: int32, ServerPrincName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcMgmtInqServerPrincNameA".} + proc RpcServerInqDefaultPrincName*(AuthnSvc: int32, PrincName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerInqDefaultPrincNameA".} + proc RpcNsBindingInqEntryName*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcNsBindingInqEntryNameA".} + proc RpcBindingInqAuthClient*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthClientA".} + proc RpcBindingInqAuthClientEx*(ClientBinding: RPC_BINDING_HANDLE, Privs: ptr RPC_AUTHZ_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthzSvc: ptr int32, Flags: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthClientExA".} + proc RpcBindingInqAuthInfo*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthInfoA".} + proc RpcBindingSetAuthInfo*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingSetAuthInfoA".} + proc RpcServerRegisterAuthInfo*(ServerPrincName: RPC_CSTR, AuthnSvc: int32, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerRegisterAuthInfoA".} + proc RpcBindingInqAuthInfoEx*(Binding: RPC_BINDING_HANDLE, ServerPrincName: ptr RPC_CSTR, AuthnLevel: ptr int32, AuthnSvc: ptr int32, AuthIdentity: ptr RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ptr int32, RpcQosVersion: int32, SecurityQOS: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingInqAuthInfoExA".} + proc RpcBindingSetAuthInfoEx*(Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: int32, AuthnSvc: int32, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: int32, SecurityQos: ptr RPC_SECURITY_QOS): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingSetAuthInfoExA".} + proc UuidFromString*(StringUuid: RPC_CSTR, Uuid: ptr UUID): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "UuidFromStringA".} + proc UuidToString*(Uuid: ptr UUID, StringUuid: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "UuidToStringA".} + proc RpcEpRegisterNoReplace*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcEpRegisterNoReplaceA".} + proc RpcEpRegister*(IfSpec: RPC_IF_HANDLE, BindingVector: ptr RPC_BINDING_VECTOR, UuidVector: ptr UUID_VECTOR, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcEpRegisterA".} + proc DceErrorInqText*(RpcStatus: RPC_STATUS, ErrorText: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "DceErrorInqTextA".} + proc RpcMgmtEpEltInqNext*(InquiryContext: RPC_EP_INQ_HANDLE, IfId: ptr RPC_IF_ID, Binding: ptr RPC_BINDING_HANDLE, ObjectUuid: ptr UUID, Annotation: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcMgmtEpEltInqNextA".} + proc RpcBindingCreate*(Template: ptr RPC_BINDING_HANDLE_TEMPLATE, Security: ptr RPC_BINDING_HANDLE_SECURITY, Options: ptr RPC_BINDING_HANDLE_OPTIONS, Binding: ptr RPC_BINDING_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcBindingCreateA".} + proc I_RpcNsBindingSetEntryName*(Binding: RPC_BINDING_HANDLE, EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcNsBindingSetEntryNameA".} + proc I_RpcServerUseProtseqEp2*(NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: int32, Endpoint: RPC_CSTR, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcServerUseProtseqEp2A".} + proc I_RpcServerUseProtseq2*(NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: int32, SecurityDescriptor: pointer, Policy: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcServerUseProtseq2A".} + proc I_RpcBindingInqDynamicEndpoint*(Binding: RPC_BINDING_HANDLE, DynamicEndpoint: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "I_RpcBindingInqDynamicEndpointA".} + proc RpcNsBindingLookupBegin*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, BindingMaxCount: int32, LookupContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingLookupBeginA".} + proc RpcNsBindingImportBegin*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: ptr UUID, ImportContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingImportBeginA".} + proc RpcNsBindingExport*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, BindingVec: ptr RPC_BINDING_VECTOR, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingExportA".} + proc RpcNsBindingUnexport*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingUnexportA".} + proc RpcNsGroupDelete*(GroupNameSyntax: int32, GroupName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupDeleteA".} + proc RpcNsGroupMbrAdd*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrAddA".} + proc RpcNsGroupMbrRemove*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrRemoveA".} + proc RpcNsGroupMbrInqBegin*(GroupNameSyntax: int32, GroupName: RPC_CSTR, MemberNameSyntax: int32, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrInqBeginA".} + proc RpcNsGroupMbrInqNext*(InquiryContext: RPC_NS_HANDLE, MemberName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsGroupMbrInqNextA".} + proc RpcNsEntryExpandName*(EntryNameSyntax: int32, EntryName: RPC_CSTR, ExpandedName: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsEntryExpandNameA".} + proc RpcNsEntryObjectInqBegin*(EntryNameSyntax: int32, EntryName: RPC_CSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsEntryObjectInqBeginA".} + proc RpcNsMgmtBindingUnexport*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfId: ptr RPC_IF_ID, VersOption: int32, ObjectUuidVec: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtBindingUnexportA".} + proc RpcNsMgmtEntryCreate*(EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryCreateA".} + proc RpcNsMgmtEntryDelete*(EntryNameSyntax: int32, EntryName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryDeleteA".} + proc RpcNsMgmtEntryInqIfIds*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfIdVec: ptr ptr RPC_IF_ID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsMgmtEntryInqIfIdsA".} + proc RpcNsProfileDelete*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileDeleteA".} + proc RpcNsProfileEltAdd*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_CSTR, Priority: int32, Annotation: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltAddA".} + proc RpcNsProfileEltRemove*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, IfId: ptr RPC_IF_ID, MemberNameSyntax: int32, MemberName: RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltRemoveA".} + proc RpcNsProfileEltInqBegin*(ProfileNameSyntax: int32, ProfileName: RPC_CSTR, InquiryType: int32, IfId: ptr RPC_IF_ID, VersOption: int32, MemberNameSyntax: int32, MemberName: RPC_CSTR, InquiryContext: ptr RPC_NS_HANDLE): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltInqBeginA".} + proc RpcNsProfileEltInqNext*(InquiryContext: RPC_NS_HANDLE, IfId: ptr RPC_IF_ID, MemberName: ptr RPC_CSTR, Priority: ptr int32, Annotation: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsProfileEltInqNextA".} + proc RpcNsBindingExportPnP*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingExportPnPA".} + proc RpcNsBindingUnexportPnP*(EntryNameSyntax: int32, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: ptr UUID_VECTOR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcns4", importc: "RpcNsBindingUnexportPnPA".} + proc RpcServerInqCallAttributes*(ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: pointer): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcServerInqCallAttributesA".} + proc RpcCertGeneratePrincipalName*(Context: PCCERT_CONTEXT, Flags: DWORD, pBuffer: ptr RPC_CSTR): RPC_STATUS {.winapi, stdcall, dynlib: "rpcrt4", importc: "RpcCertGeneratePrincipalNameA".} +when winimCpu64: + proc Ndr64AsyncServerCall64*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} + proc Ndr64AsyncServerCallAll*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} + proc Ndr64DcomAsyncStubCall*(pThis: ptr IRpcStubBuffer, pChannel: ptr IRpcChannelBuffer, pRpcMsg: PRPC_MESSAGE, pdwStubPhase: ptr int32): LONG32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} + proc NdrStubCall3*(pThis: ptr IRpcStubBuffer, pChannel: ptr IRpcChannelBuffer, pRpcMsg: PRPC_MESSAGE, pdwStubPhase: ptr int32): LONG32 {.winapi, stdcall, dynlib: "rpcrt4", importc.} + proc NdrServerCallAll*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} + proc NdrServerCallNdr64*(pRpcMsg: PRPC_MESSAGE): void {.winapi, stdcall, dynlib: "rpcrt4", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/security.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/security.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1988 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wincrypt +#include +#include +#include +#include +type + SECURITY_LOGON_TYPE* = int32 + PSECURITY_LOGON_TYPE* = ptr int32 + SE_ADT_PARAMETER_TYPE* = int32 + PSE_ADT_PARAMETER_TYPE* = ptr int32 + POLICY_AUDIT_EVENT_TYPE* = int32 + PPOLICY_AUDIT_EVENT_TYPE* = ptr int32 + POLICY_LSA_SERVER_ROLE* = int32 + PPOLICY_LSA_SERVER_ROLE* = ptr int32 + POLICY_INFORMATION_CLASS* = int32 + PPOLICY_INFORMATION_CLASS* = ptr int32 + POLICY_DOMAIN_INFORMATION_CLASS* = int32 + PPOLICY_DOMAIN_INFORMATION_CLASS* = ptr int32 + POLICY_NOTIFICATION_INFORMATION_CLASS* = int32 + PPOLICY_NOTIFICATION_INFORMATION_CLASS* = ptr int32 + TRUSTED_INFORMATION_CLASS* = int32 + PTRUSTED_INFORMATION_CLASS* = ptr int32 + LSA_FOREST_TRUST_RECORD_TYPE* = int32 + LSA_FOREST_TRUST_COLLISION_RECORD_TYPE* = int32 + NEGOTIATE_MESSAGES* = int32 + MSV1_0_LOGON_SUBMIT_TYPE* = int32 + PMSV1_0_LOGON_SUBMIT_TYPE* = ptr int32 + MSV1_0_PROFILE_BUFFER_TYPE* = int32 + PMSV1_0_PROFILE_BUFFER_TYPE* = ptr int32 + MSV1_0_AVID* = int32 + MSV1_0_PROTOCOL_MESSAGE_TYPE* = int32 + PMSV1_0_PROTOCOL_MESSAGE_TYPE* = ptr int32 + KERB_LOGON_SUBMIT_TYPE* = int32 + PKERB_LOGON_SUBMIT_TYPE* = ptr int32 + KERB_PROFILE_BUFFER_TYPE* = int32 + PKERB_PROFILE_BUFFER_TYPE* = ptr int32 + KERB_PROTOCOL_MESSAGE_TYPE* = int32 + PKERB_PROTOCOL_MESSAGE_TYPE* = ptr int32 + SecDelegationType* = int32 + PSecDelegationType* = ptr int32 + SASL_AUTHZID_STATE* = int32 + EXTENDED_NAME_FORMAT* = int32 + PEXTENDED_NAME_FORMAT* = ptr int32 + LSA_OPERATIONAL_MODE* = ULONG + PLSA_OPERATIONAL_MODE* = ptr ULONG + POLICY_AUDIT_EVENT_OPTIONS* = ULONG + PPOLICY_AUDIT_EVENT_OPTIONS* = ptr ULONG + LSA_HANDLE* = PVOID + PLSA_HANDLE* = ptr PVOID + LSA_ENUMERATION_HANDLE* = ULONG + PLSA_ENUMERATION_HANDLE* = ptr ULONG + SEC_WCHAR* = WCHAR + SEC_CHAR* = CHAR + SE_ADT_OBJECT_TYPE* {.pure.} = object + ObjectType*: GUID + Flags*: USHORT + Level*: USHORT + AccessMask*: ACCESS_MASK + PSE_ADT_OBJECT_TYPE* = ptr SE_ADT_OBJECT_TYPE + SE_ADT_PARAMETER_ARRAY_ENTRY* {.pure.} = object + Type*: SE_ADT_PARAMETER_TYPE + Length*: ULONG + Data*: array[2, ULONG_PTR] + Address*: PVOID + PSE_ADT_PARAMETER_ARRAY_ENTRY* = ptr SE_ADT_PARAMETER_ARRAY_ENTRY +const + SE_MAX_AUDIT_PARAMETERS* = 32 +type + SE_ADT_PARAMETER_ARRAY* {.pure.} = object + CategoryId*: ULONG + AuditId*: ULONG + ParameterCount*: ULONG + Length*: ULONG + Type*: USHORT + Flags*: ULONG + Parameters*: array[SE_MAX_AUDIT_PARAMETERS , SE_ADT_PARAMETER_ARRAY_ENTRY] + PSE_ADT_PARAMETER_ARRAY* = ptr SE_ADT_PARAMETER_ARRAY + LSA_UNICODE_STRING* = UNICODE_STRING + PLSA_UNICODE_STRING* = ptr UNICODE_STRING + LSA_STRING* = STRING + PLSA_STRING* = ptr STRING + LSA_OBJECT_ATTRIBUTES* = OBJECT_ATTRIBUTES + PLSA_OBJECT_ATTRIBUTES* = ptr OBJECT_ATTRIBUTES + LSA_TRUST_INFORMATION* {.pure.} = object + Name*: LSA_UNICODE_STRING + Sid*: PSID + PLSA_TRUST_INFORMATION* = ptr LSA_TRUST_INFORMATION + LSA_REFERENCED_DOMAIN_LIST* {.pure.} = object + Entries*: ULONG + Domains*: PLSA_TRUST_INFORMATION + PLSA_REFERENCED_DOMAIN_LIST* = ptr LSA_REFERENCED_DOMAIN_LIST + LSA_TRANSLATED_SID* {.pure.} = object + Use*: SID_NAME_USE + RelativeId*: ULONG + DomainIndex*: LONG + PLSA_TRANSLATED_SID* = ptr LSA_TRANSLATED_SID + LSA_TRANSLATED_SID2* {.pure.} = object + Use*: SID_NAME_USE + Sid*: PSID + DomainIndex*: LONG + Flags*: ULONG + PLSA_TRANSLATED_SID2* = ptr LSA_TRANSLATED_SID2 + LSA_TRANSLATED_NAME* {.pure.} = object + Use*: SID_NAME_USE + Name*: LSA_UNICODE_STRING + DomainIndex*: LONG + PLSA_TRANSLATED_NAME* = ptr LSA_TRANSLATED_NAME + POLICY_AUDIT_LOG_INFO* {.pure.} = object + AuditLogPercentFull*: ULONG + MaximumLogSize*: ULONG + AuditRetentionPeriod*: LARGE_INTEGER + AuditLogFullShutdownInProgress*: BOOLEAN + TimeToShutdown*: LARGE_INTEGER + NextAuditRecordId*: ULONG + PPOLICY_AUDIT_LOG_INFO* = ptr POLICY_AUDIT_LOG_INFO + POLICY_AUDIT_EVENTS_INFO* {.pure.} = object + AuditingMode*: BOOLEAN + EventAuditingOptions*: PPOLICY_AUDIT_EVENT_OPTIONS + MaximumAuditEventCount*: ULONG + PPOLICY_AUDIT_EVENTS_INFO* = ptr POLICY_AUDIT_EVENTS_INFO + POLICY_ACCOUNT_DOMAIN_INFO* {.pure.} = object + DomainName*: LSA_UNICODE_STRING + DomainSid*: PSID + PPOLICY_ACCOUNT_DOMAIN_INFO* = ptr POLICY_ACCOUNT_DOMAIN_INFO + POLICY_PRIMARY_DOMAIN_INFO* {.pure.} = object + Name*: LSA_UNICODE_STRING + Sid*: PSID + PPOLICY_PRIMARY_DOMAIN_INFO* = ptr POLICY_PRIMARY_DOMAIN_INFO + POLICY_DNS_DOMAIN_INFO* {.pure.} = object + Name*: LSA_UNICODE_STRING + DnsDomainName*: LSA_UNICODE_STRING + DnsForestName*: LSA_UNICODE_STRING + DomainGuid*: GUID + Sid*: PSID + PPOLICY_DNS_DOMAIN_INFO* = ptr POLICY_DNS_DOMAIN_INFO + POLICY_PD_ACCOUNT_INFO* {.pure.} = object + Name*: LSA_UNICODE_STRING + PPOLICY_PD_ACCOUNT_INFO* = ptr POLICY_PD_ACCOUNT_INFO + POLICY_LSA_SERVER_ROLE_INFO* {.pure.} = object + LsaServerRole*: POLICY_LSA_SERVER_ROLE + PPOLICY_LSA_SERVER_ROLE_INFO* = ptr POLICY_LSA_SERVER_ROLE_INFO + POLICY_REPLICA_SOURCE_INFO* {.pure.} = object + ReplicaSource*: LSA_UNICODE_STRING + ReplicaAccountName*: LSA_UNICODE_STRING + PPOLICY_REPLICA_SOURCE_INFO* = ptr POLICY_REPLICA_SOURCE_INFO + POLICY_DEFAULT_QUOTA_INFO* {.pure.} = object + QuotaLimits*: QUOTA_LIMITS + PPOLICY_DEFAULT_QUOTA_INFO* = ptr POLICY_DEFAULT_QUOTA_INFO + POLICY_MODIFICATION_INFO* {.pure.} = object + ModifiedId*: LARGE_INTEGER + DatabaseCreationTime*: LARGE_INTEGER + PPOLICY_MODIFICATION_INFO* = ptr POLICY_MODIFICATION_INFO + POLICY_AUDIT_FULL_SET_INFO* {.pure.} = object + ShutDownOnFull*: BOOLEAN + PPOLICY_AUDIT_FULL_SET_INFO* = ptr POLICY_AUDIT_FULL_SET_INFO + POLICY_AUDIT_FULL_QUERY_INFO* {.pure.} = object + ShutDownOnFull*: BOOLEAN + LogIsFull*: BOOLEAN + PPOLICY_AUDIT_FULL_QUERY_INFO* = ptr POLICY_AUDIT_FULL_QUERY_INFO + POLICY_DOMAIN_EFS_INFO* {.pure.} = object + InfoLength*: ULONG + EfsBlob*: PUCHAR + PPOLICY_DOMAIN_EFS_INFO* = ptr POLICY_DOMAIN_EFS_INFO + POLICY_DOMAIN_KERBEROS_TICKET_INFO* {.pure.} = object + AuthenticationOptions*: ULONG + MaxServiceTicketAge*: LARGE_INTEGER + MaxTicketAge*: LARGE_INTEGER + MaxRenewAge*: LARGE_INTEGER + MaxClockSkew*: LARGE_INTEGER + Reserved*: LARGE_INTEGER + PPOLICY_DOMAIN_KERBEROS_TICKET_INFO* = ptr POLICY_DOMAIN_KERBEROS_TICKET_INFO + TRUSTED_DOMAIN_NAME_INFO* {.pure.} = object + Name*: LSA_UNICODE_STRING + PTRUSTED_DOMAIN_NAME_INFO* = ptr TRUSTED_DOMAIN_NAME_INFO + TRUSTED_CONTROLLERS_INFO* {.pure.} = object + Entries*: ULONG + Names*: PLSA_UNICODE_STRING + PTRUSTED_CONTROLLERS_INFO* = ptr TRUSTED_CONTROLLERS_INFO + TRUSTED_POSIX_OFFSET_INFO* {.pure.} = object + Offset*: ULONG + PTRUSTED_POSIX_OFFSET_INFO* = ptr TRUSTED_POSIX_OFFSET_INFO + TRUSTED_PASSWORD_INFO* {.pure.} = object + Password*: LSA_UNICODE_STRING + OldPassword*: LSA_UNICODE_STRING + PTRUSTED_PASSWORD_INFO* = ptr TRUSTED_PASSWORD_INFO + TRUSTED_DOMAIN_INFORMATION_BASIC* = LSA_TRUST_INFORMATION + PTRUSTED_DOMAIN_INFORMATION_BASIC* = PLSA_TRUST_INFORMATION + TRUSTED_DOMAIN_INFORMATION_EX* {.pure.} = object + Name*: LSA_UNICODE_STRING + FlatName*: LSA_UNICODE_STRING + Sid*: PSID + TrustDirection*: ULONG + TrustType*: ULONG + TrustAttributes*: ULONG + PTRUSTED_DOMAIN_INFORMATION_EX* = ptr TRUSTED_DOMAIN_INFORMATION_EX + TRUSTED_DOMAIN_INFORMATION_EX2* {.pure.} = object + Name*: LSA_UNICODE_STRING + FlatName*: LSA_UNICODE_STRING + Sid*: PSID + TrustDirection*: ULONG + TrustType*: ULONG + TrustAttributes*: ULONG + ForestTrustLength*: ULONG + ForestTrustInfo*: PUCHAR + PTRUSTED_DOMAIN_INFORMATION_EX2* = ptr TRUSTED_DOMAIN_INFORMATION_EX2 + LSA_AUTH_INFORMATION* {.pure.} = object + LastUpdateTime*: LARGE_INTEGER + AuthType*: ULONG + AuthInfoLength*: ULONG + AuthInfo*: PUCHAR + PLSA_AUTH_INFORMATION* = ptr LSA_AUTH_INFORMATION + TRUSTED_DOMAIN_AUTH_INFORMATION* {.pure.} = object + IncomingAuthInfos*: ULONG + IncomingAuthenticationInformation*: PLSA_AUTH_INFORMATION + IncomingPreviousAuthenticationInformation*: PLSA_AUTH_INFORMATION + OutgoingAuthInfos*: ULONG + OutgoingAuthenticationInformation*: PLSA_AUTH_INFORMATION + OutgoingPreviousAuthenticationInformation*: PLSA_AUTH_INFORMATION + PTRUSTED_DOMAIN_AUTH_INFORMATION* = ptr TRUSTED_DOMAIN_AUTH_INFORMATION + TRUSTED_DOMAIN_FULL_INFORMATION* {.pure.} = object + Information*: TRUSTED_DOMAIN_INFORMATION_EX + PosixOffset*: TRUSTED_POSIX_OFFSET_INFO + AuthInformation*: TRUSTED_DOMAIN_AUTH_INFORMATION + PTRUSTED_DOMAIN_FULL_INFORMATION* = ptr TRUSTED_DOMAIN_FULL_INFORMATION + TRUSTED_DOMAIN_FULL_INFORMATION2* {.pure.} = object + Information*: TRUSTED_DOMAIN_INFORMATION_EX2 + PosixOffset*: TRUSTED_POSIX_OFFSET_INFO + AuthInformation*: TRUSTED_DOMAIN_AUTH_INFORMATION + PTRUSTED_DOMAIN_FULL_INFORMATION2* = ptr TRUSTED_DOMAIN_FULL_INFORMATION2 + LSA_FOREST_TRUST_DOMAIN_INFO* {.pure.} = object + Sid*: PSID + DnsName*: LSA_UNICODE_STRING + NetbiosName*: LSA_UNICODE_STRING + PLSA_FOREST_TRUST_DOMAIN_INFO* = ptr LSA_FOREST_TRUST_DOMAIN_INFO + LSA_FOREST_TRUST_BINARY_DATA* {.pure.} = object + Length*: ULONG + Buffer*: PUCHAR + PLSA_FOREST_TRUST_BINARY_DATA* = ptr LSA_FOREST_TRUST_BINARY_DATA + LSA_FOREST_TRUST_RECORD_ForestTrustData* {.pure, union.} = object + TopLevelName*: LSA_UNICODE_STRING + DomainInfo*: LSA_FOREST_TRUST_DOMAIN_INFO + Data*: LSA_FOREST_TRUST_BINARY_DATA + LSA_FOREST_TRUST_RECORD* {.pure.} = object + Flags*: ULONG + ForestTrustType*: LSA_FOREST_TRUST_RECORD_TYPE + Time*: LARGE_INTEGER + ForestTrustData*: LSA_FOREST_TRUST_RECORD_ForestTrustData + PLSA_FOREST_TRUST_RECORD* = ptr LSA_FOREST_TRUST_RECORD + LSA_FOREST_TRUST_INFORMATION* {.pure.} = object + RecordCount*: ULONG + Entries*: ptr PLSA_FOREST_TRUST_RECORD + PLSA_FOREST_TRUST_INFORMATION* = ptr LSA_FOREST_TRUST_INFORMATION + LSA_FOREST_TRUST_COLLISION_RECORD* {.pure.} = object + Index*: ULONG + Type*: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE + Flags*: ULONG + Name*: LSA_UNICODE_STRING + PLSA_FOREST_TRUST_COLLISION_RECORD* = ptr LSA_FOREST_TRUST_COLLISION_RECORD + LSA_FOREST_TRUST_COLLISION_INFORMATION* {.pure.} = object + RecordCount*: ULONG + Entries*: ptr PLSA_FOREST_TRUST_COLLISION_RECORD + PLSA_FOREST_TRUST_COLLISION_INFORMATION* = ptr LSA_FOREST_TRUST_COLLISION_INFORMATION + LSA_ENUMERATION_INFORMATION* {.pure.} = object + Sid*: PSID + PLSA_ENUMERATION_INFORMATION* = ptr LSA_ENUMERATION_INFORMATION + LSA_LAST_INTER_LOGON_INFO* {.pure.} = object + LastSuccessfulLogon*: LARGE_INTEGER + LastFailedLogon*: LARGE_INTEGER + FailedAttemptCountSinceLastSuccessfulLogon*: ULONG + PLSA_LAST_INTER_LOGON_INFO* = ptr LSA_LAST_INTER_LOGON_INFO + SECURITY_LOGON_SESSION_DATA* {.pure.} = object + Size*: ULONG + LogonId*: LUID + UserName*: LSA_UNICODE_STRING + LogonDomain*: LSA_UNICODE_STRING + AuthenticationPackage*: LSA_UNICODE_STRING + LogonType*: ULONG + Session*: ULONG + Sid*: PSID + LogonTime*: LARGE_INTEGER + LogonServer*: LSA_UNICODE_STRING + DnsDomainName*: LSA_UNICODE_STRING + Upn*: LSA_UNICODE_STRING + UserFlags*: ULONG + LastLogonInfo*: LSA_LAST_INTER_LOGON_INFO + LogonScript*: LSA_UNICODE_STRING + ProfilePath*: LSA_UNICODE_STRING + HomeDirectory*: LSA_UNICODE_STRING + HomeDirectoryDrive*: LSA_UNICODE_STRING + LogoffTime*: LARGE_INTEGER + KickOffTime*: LARGE_INTEGER + PasswordLastSet*: LARGE_INTEGER + PasswordCanChange*: LARGE_INTEGER + PasswordMustChange*: LARGE_INTEGER + PSECURITY_LOGON_SESSION_DATA* = ptr SECURITY_LOGON_SESSION_DATA +const + NEGOTIATE_MAX_PREFIX* = 32 +type + NEGOTIATE_PACKAGE_PREFIX* {.pure.} = object + PackageId*: ULONG_PTR + PackageDataA*: PVOID + PackageDataW*: PVOID + PrefixLen*: ULONG_PTR + Prefix*: array[NEGOTIATE_MAX_PREFIX , UCHAR] + PNEGOTIATE_PACKAGE_PREFIX* = ptr NEGOTIATE_PACKAGE_PREFIX + NEGOTIATE_PACKAGE_PREFIXES* {.pure.} = object + MessageType*: ULONG + PrefixCount*: ULONG + Offset*: ULONG + Pad*: ULONG + PNEGOTIATE_PACKAGE_PREFIXES* = ptr NEGOTIATE_PACKAGE_PREFIXES + NEGOTIATE_CALLER_NAME_REQUEST* {.pure.} = object + MessageType*: ULONG + LogonId*: LUID + PNEGOTIATE_CALLER_NAME_REQUEST* = ptr NEGOTIATE_CALLER_NAME_REQUEST + NEGOTIATE_CALLER_NAME_RESPONSE* {.pure.} = object + MessageType*: ULONG + CallerName*: PWSTR + PNEGOTIATE_CALLER_NAME_RESPONSE* = ptr NEGOTIATE_CALLER_NAME_RESPONSE + DOMAIN_PASSWORD_INFORMATION* {.pure.} = object + MinPasswordLength*: USHORT + PasswordHistoryLength*: USHORT + PasswordProperties*: ULONG + MaxPasswordAge*: LARGE_INTEGER + MinPasswordAge*: LARGE_INTEGER + PDOMAIN_PASSWORD_INFORMATION* = ptr DOMAIN_PASSWORD_INFORMATION + TMSV1_0_INTERACTIVE_LOGON* {.pure.} = object + MessageType*: MSV1_0_LOGON_SUBMIT_TYPE + LogonDomainName*: UNICODE_STRING + UserName*: UNICODE_STRING + Password*: UNICODE_STRING + PMSV1_0_INTERACTIVE_LOGON* = ptr TMSV1_0_INTERACTIVE_LOGON + TMSV1_0_INTERACTIVE_PROFILE* {.pure.} = object + MessageType*: MSV1_0_PROFILE_BUFFER_TYPE + LogonCount*: USHORT + BadPasswordCount*: USHORT + LogonTime*: LARGE_INTEGER + LogoffTime*: LARGE_INTEGER + KickOffTime*: LARGE_INTEGER + PasswordLastSet*: LARGE_INTEGER + PasswordCanChange*: LARGE_INTEGER + PasswordMustChange*: LARGE_INTEGER + LogonScript*: UNICODE_STRING + HomeDirectory*: UNICODE_STRING + FullName*: UNICODE_STRING + ProfilePath*: UNICODE_STRING + HomeDirectoryDrive*: UNICODE_STRING + LogonServer*: UNICODE_STRING + UserFlags*: ULONG + PMSV1_0_INTERACTIVE_PROFILE* = ptr TMSV1_0_INTERACTIVE_PROFILE +const + MSV1_0_CHALLENGE_LENGTH* = 8 +type + TMSV1_0_LM20_LOGON* {.pure.} = object + MessageType*: MSV1_0_LOGON_SUBMIT_TYPE + LogonDomainName*: UNICODE_STRING + UserName*: UNICODE_STRING + Workstation*: UNICODE_STRING + ChallengeToClient*: array[MSV1_0_CHALLENGE_LENGTH, UCHAR] + CaseSensitiveChallengeResponse*: STRING + CaseInsensitiveChallengeResponse*: STRING + ParameterControl*: ULONG + PMSV1_0_LM20_LOGON* = ptr TMSV1_0_LM20_LOGON + TMSV1_0_SUBAUTH_LOGON* {.pure.} = object + MessageType*: MSV1_0_LOGON_SUBMIT_TYPE + LogonDomainName*: UNICODE_STRING + UserName*: UNICODE_STRING + Workstation*: UNICODE_STRING + ChallengeToClient*: array[MSV1_0_CHALLENGE_LENGTH, UCHAR] + AuthenticationInfo1*: STRING + AuthenticationInfo2*: STRING + ParameterControl*: ULONG + SubAuthPackageId*: ULONG + PMSV1_0_SUBAUTH_LOGON* = ptr TMSV1_0_SUBAUTH_LOGON +const + MSV1_0_USER_SESSION_KEY_LENGTH* = 16 + MSV1_0_LANMAN_SESSION_KEY_LENGTH* = 8 +type + TMSV1_0_LM20_LOGON_PROFILE* {.pure.} = object + MessageType*: MSV1_0_PROFILE_BUFFER_TYPE + KickOffTime*: LARGE_INTEGER + LogoffTime*: LARGE_INTEGER + UserFlags*: ULONG + UserSessionKey*: array[MSV1_0_USER_SESSION_KEY_LENGTH, UCHAR] + LogonDomainName*: UNICODE_STRING + LanmanSessionKey*: array[MSV1_0_LANMAN_SESSION_KEY_LENGTH, UCHAR] + LogonServer*: UNICODE_STRING + UserParameters*: UNICODE_STRING + PMSV1_0_LM20_LOGON_PROFILE* = ptr TMSV1_0_LM20_LOGON_PROFILE +const + MSV1_0_OWF_PASSWORD_LENGTH* = 16 +type + MSV1_0_SUPPLEMENTAL_CREDENTIAL* {.pure.} = object + Version*: ULONG + Flags*: ULONG + LmPassword*: array[MSV1_0_OWF_PASSWORD_LENGTH, UCHAR] + NtPassword*: array[MSV1_0_OWF_PASSWORD_LENGTH, UCHAR] + PMSV1_0_SUPPLEMENTAL_CREDENTIAL* = ptr MSV1_0_SUPPLEMENTAL_CREDENTIAL +const + MSV1_0_NTLM3_RESPONSE_LENGTH* = 16 +type + MSV1_0_NTLM3_RESPONSE* {.pure.} = object + Response*: array[MSV1_0_NTLM3_RESPONSE_LENGTH, UCHAR] + RespType*: UCHAR + HiRespType*: UCHAR + Flags*: USHORT + MsgWord*: ULONG + TimeStamp*: ULONGLONG + ChallengeFromClient*: array[MSV1_0_CHALLENGE_LENGTH, UCHAR] + AvPairsOff*: ULONG + Buffer*: array[1, UCHAR] + PMSV1_0_NTLM3_RESPONSE* = ptr MSV1_0_NTLM3_RESPONSE + MSV1_0_AV_PAIR* {.pure.} = object + AvId*: USHORT + AvLen*: USHORT + PMSV1_0_AV_PAIR* = ptr MSV1_0_AV_PAIR + MSV1_0_CHANGEPASSWORD_REQUEST* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + DomainName*: UNICODE_STRING + AccountName*: UNICODE_STRING + OldPassword*: UNICODE_STRING + NewPassword*: UNICODE_STRING + Impersonating*: BOOLEAN + PMSV1_0_CHANGEPASSWORD_REQUEST* = ptr MSV1_0_CHANGEPASSWORD_REQUEST + MSV1_0_CHANGEPASSWORD_RESPONSE* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + PasswordInfoValid*: BOOLEAN + DomainPasswordInfo*: DOMAIN_PASSWORD_INFORMATION + PMSV1_0_CHANGEPASSWORD_RESPONSE* = ptr MSV1_0_CHANGEPASSWORD_RESPONSE + MSV1_0_PASSTHROUGH_REQUEST* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + DomainName*: UNICODE_STRING + PackageName*: UNICODE_STRING + DataLength*: ULONG + LogonData*: PUCHAR + Pad*: ULONG + PMSV1_0_PASSTHROUGH_REQUEST* = ptr MSV1_0_PASSTHROUGH_REQUEST + MSV1_0_PASSTHROUGH_RESPONSE* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + Pad*: ULONG + DataLength*: ULONG + ValidationData*: PUCHAR + PMSV1_0_PASSTHROUGH_RESPONSE* = ptr MSV1_0_PASSTHROUGH_RESPONSE + MSV1_0_SUBAUTH_REQUEST* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + SubAuthPackageId*: ULONG + SubAuthInfoLength*: ULONG + SubAuthSubmitBuffer*: PUCHAR + PMSV1_0_SUBAUTH_REQUEST* = ptr MSV1_0_SUBAUTH_REQUEST + MSV1_0_SUBAUTH_RESPONSE* {.pure.} = object + MessageType*: MSV1_0_PROTOCOL_MESSAGE_TYPE + SubAuthInfoLength*: ULONG + SubAuthReturnBuffer*: PUCHAR + PMSV1_0_SUBAUTH_RESPONSE* = ptr MSV1_0_SUBAUTH_RESPONSE + KERB_INTERACTIVE_LOGON* {.pure.} = object + MessageType*: KERB_LOGON_SUBMIT_TYPE + LogonDomainName*: UNICODE_STRING + UserName*: UNICODE_STRING + Password*: UNICODE_STRING + PKERB_INTERACTIVE_LOGON* = ptr KERB_INTERACTIVE_LOGON + KERB_INTERACTIVE_UNLOCK_LOGON* {.pure.} = object + Logon*: KERB_INTERACTIVE_LOGON + LogonId*: LUID + PKERB_INTERACTIVE_UNLOCK_LOGON* = ptr KERB_INTERACTIVE_UNLOCK_LOGON + KERB_SMART_CARD_LOGON* {.pure.} = object + MessageType*: KERB_LOGON_SUBMIT_TYPE + Pin*: UNICODE_STRING + CspDataLength*: ULONG + CspData*: PUCHAR + PKERB_SMART_CARD_LOGON* = ptr KERB_SMART_CARD_LOGON + KERB_SMART_CARD_UNLOCK_LOGON* {.pure.} = object + Logon*: KERB_SMART_CARD_LOGON + LogonId*: LUID + PKERB_SMART_CARD_UNLOCK_LOGON* = ptr KERB_SMART_CARD_UNLOCK_LOGON + KERB_TICKET_LOGON* {.pure.} = object + MessageType*: KERB_LOGON_SUBMIT_TYPE + Flags*: ULONG + ServiceTicketLength*: ULONG + TicketGrantingTicketLength*: ULONG + ServiceTicket*: PUCHAR + TicketGrantingTicket*: PUCHAR + PKERB_TICKET_LOGON* = ptr KERB_TICKET_LOGON + KERB_TICKET_UNLOCK_LOGON* {.pure.} = object + Logon*: KERB_TICKET_LOGON + LogonId*: LUID + PKERB_TICKET_UNLOCK_LOGON* = ptr KERB_TICKET_UNLOCK_LOGON + KERB_S4U_LOGON* {.pure.} = object + MessageType*: KERB_LOGON_SUBMIT_TYPE + Flags*: ULONG + ClientUpn*: UNICODE_STRING + ClientRealm*: UNICODE_STRING + PKERB_S4U_LOGON* = ptr KERB_S4U_LOGON + KERB_INTERACTIVE_PROFILE* {.pure.} = object + MessageType*: KERB_PROFILE_BUFFER_TYPE + LogonCount*: USHORT + BadPasswordCount*: USHORT + LogonTime*: LARGE_INTEGER + LogoffTime*: LARGE_INTEGER + KickOffTime*: LARGE_INTEGER + PasswordLastSet*: LARGE_INTEGER + PasswordCanChange*: LARGE_INTEGER + PasswordMustChange*: LARGE_INTEGER + LogonScript*: UNICODE_STRING + HomeDirectory*: UNICODE_STRING + FullName*: UNICODE_STRING + ProfilePath*: UNICODE_STRING + HomeDirectoryDrive*: UNICODE_STRING + LogonServer*: UNICODE_STRING + UserFlags*: ULONG + PKERB_INTERACTIVE_PROFILE* = ptr KERB_INTERACTIVE_PROFILE + KERB_SMART_CARD_PROFILE* {.pure.} = object + Profile*: KERB_INTERACTIVE_PROFILE + CertificateSize*: ULONG + CertificateData*: PUCHAR + PKERB_SMART_CARD_PROFILE* = ptr KERB_SMART_CARD_PROFILE + KERB_CRYPTO_KEY* {.pure.} = object + KeyType*: LONG + Length*: ULONG + Value*: PUCHAR + PKERB_CRYPTO_KEY* = ptr KERB_CRYPTO_KEY + KERB_TICKET_PROFILE* {.pure.} = object + Profile*: KERB_INTERACTIVE_PROFILE + SessionKey*: KERB_CRYPTO_KEY + PKERB_TICKET_PROFILE* = ptr KERB_TICKET_PROFILE + KERB_QUERY_TKT_CACHE_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + PKERB_QUERY_TKT_CACHE_REQUEST* = ptr KERB_QUERY_TKT_CACHE_REQUEST + KERB_TICKET_CACHE_INFO* {.pure.} = object + ServerName*: UNICODE_STRING + RealmName*: UNICODE_STRING + StartTime*: LARGE_INTEGER + EndTime*: LARGE_INTEGER + RenewTime*: LARGE_INTEGER + EncryptionType*: LONG + TicketFlags*: ULONG + PKERB_TICKET_CACHE_INFO* = ptr KERB_TICKET_CACHE_INFO + KERB_TICKET_CACHE_INFO_EX* {.pure.} = object + ClientName*: UNICODE_STRING + ClientRealm*: UNICODE_STRING + ServerName*: UNICODE_STRING + ServerRealm*: UNICODE_STRING + StartTime*: LARGE_INTEGER + EndTime*: LARGE_INTEGER + RenewTime*: LARGE_INTEGER + EncryptionType*: LONG + TicketFlags*: ULONG + PKERB_TICKET_CACHE_INFO_EX* = ptr KERB_TICKET_CACHE_INFO_EX + KERB_TICKET_CACHE_INFO_EX2* {.pure.} = object + ClientName*: UNICODE_STRING + ClientRealm*: UNICODE_STRING + ServerName*: UNICODE_STRING + ServerRealm*: UNICODE_STRING + StartTime*: LARGE_INTEGER + EndTime*: LARGE_INTEGER + RenewTime*: LARGE_INTEGER + EncryptionType*: LONG + TicketFlags*: ULONG + SessionKeyType*: ULONG + PKERB_TICKET_CACHE_INFO_EX2* = ptr KERB_TICKET_CACHE_INFO_EX2 + KERB_QUERY_TKT_CACHE_RESPONSE* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + CountOfTickets*: ULONG + Tickets*: array[ANYSIZE_ARRAY, KERB_TICKET_CACHE_INFO] + PKERB_QUERY_TKT_CACHE_RESPONSE* = ptr KERB_QUERY_TKT_CACHE_RESPONSE + KERB_QUERY_TKT_CACHE_EX_RESPONSE* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + CountOfTickets*: ULONG + Tickets*: array[ANYSIZE_ARRAY, KERB_TICKET_CACHE_INFO_EX] + PKERB_QUERY_TKT_CACHE_EX_RESPONSE* = ptr KERB_QUERY_TKT_CACHE_EX_RESPONSE + KERB_QUERY_TKT_CACHE_EX2_RESPONSE* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + CountOfTickets*: ULONG + Tickets*: array[ANYSIZE_ARRAY, KERB_TICKET_CACHE_INFO_EX2] + PKERB_QUERY_TKT_CACHE_EX2_RESPONSE* = ptr KERB_QUERY_TKT_CACHE_EX2_RESPONSE + SecHandle* {.pure.} = object + dwLower*: ULONG_PTR + dwUpper*: ULONG_PTR + PSecHandle* = ptr SecHandle + KERB_AUTH_DATA* {.pure.} = object + Type*: ULONG + Length*: ULONG + Data*: PUCHAR + PKERB_AUTH_DATA* = ptr KERB_AUTH_DATA + KERB_NET_ADDRESS* {.pure.} = object + Family*: ULONG + Length*: ULONG + Address*: PCHAR + PKERB_NET_ADDRESS* = ptr KERB_NET_ADDRESS + KERB_NET_ADDRESSES* {.pure.} = object + Number*: ULONG + Addresses*: array[ANYSIZE_ARRAY, KERB_NET_ADDRESS] + PKERB_NET_ADDRESSES* = ptr KERB_NET_ADDRESSES + KERB_EXTERNAL_NAME* {.pure.} = object + NameType*: SHORT + NameCount*: USHORT + Names*: array[ANYSIZE_ARRAY, UNICODE_STRING] + PKERB_EXTERNAL_NAME* = ptr KERB_EXTERNAL_NAME + KERB_EXTERNAL_TICKET* {.pure.} = object + ServiceName*: PKERB_EXTERNAL_NAME + TargetName*: PKERB_EXTERNAL_NAME + ClientName*: PKERB_EXTERNAL_NAME + DomainName*: UNICODE_STRING + TargetDomainName*: UNICODE_STRING + AltTargetDomainName*: UNICODE_STRING + SessionKey*: KERB_CRYPTO_KEY + TicketFlags*: ULONG + Flags*: ULONG + KeyExpirationTime*: LARGE_INTEGER + StartTime*: LARGE_INTEGER + EndTime*: LARGE_INTEGER + RenewUntil*: LARGE_INTEGER + TimeSkew*: LARGE_INTEGER + EncodedTicketSize*: ULONG + EncodedTicket*: PUCHAR + PKERB_EXTERNAL_TICKET* = ptr KERB_EXTERNAL_TICKET + KERB_RETRIEVE_TKT_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + TargetName*: UNICODE_STRING + TicketFlags*: ULONG + CacheOptions*: ULONG + EncryptionType*: LONG + CredentialsHandle*: SecHandle + PKERB_RETRIEVE_TKT_REQUEST* = ptr KERB_RETRIEVE_TKT_REQUEST + KERB_RETRIEVE_TKT_RESPONSE* {.pure.} = object + Ticket*: KERB_EXTERNAL_TICKET + PKERB_RETRIEVE_TKT_RESPONSE* = ptr KERB_RETRIEVE_TKT_RESPONSE + KERB_PURGE_TKT_CACHE_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + ServerName*: UNICODE_STRING + RealmName*: UNICODE_STRING + PKERB_PURGE_TKT_CACHE_REQUEST* = ptr KERB_PURGE_TKT_CACHE_REQUEST + KERB_PURGE_TKT_CACHE_EX_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + Flags*: ULONG + TicketTemplate*: KERB_TICKET_CACHE_INFO_EX + PKERB_PURGE_TKT_CACHE_EX_REQUEST* = ptr KERB_PURGE_TKT_CACHE_EX_REQUEST + KERB_CHANGEPASSWORD_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + DomainName*: UNICODE_STRING + AccountName*: UNICODE_STRING + OldPassword*: UNICODE_STRING + NewPassword*: UNICODE_STRING + Impersonating*: BOOLEAN + PKERB_CHANGEPASSWORD_REQUEST* = ptr KERB_CHANGEPASSWORD_REQUEST + KERB_SETPASSWORD_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + CredentialsHandle*: SecHandle + Flags*: ULONG + DomainName*: UNICODE_STRING + AccountName*: UNICODE_STRING + Password*: UNICODE_STRING + PKERB_SETPASSWORD_REQUEST* = ptr KERB_SETPASSWORD_REQUEST + KERB_SETPASSWORD_EX_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + CredentialsHandle*: SecHandle + Flags*: ULONG + AccountRealm*: UNICODE_STRING + AccountName*: UNICODE_STRING + Password*: UNICODE_STRING + ClientRealm*: UNICODE_STRING + ClientName*: UNICODE_STRING + Impersonating*: BOOLEAN + KdcAddress*: UNICODE_STRING + KdcAddressType*: ULONG + PKERB_SETPASSWORD_EX_REQUEST* = ptr KERB_SETPASSWORD_EX_REQUEST + KERB_DECRYPT_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + LogonId*: LUID + Flags*: ULONG + CryptoType*: LONG + KeyUsage*: LONG + Key*: KERB_CRYPTO_KEY + EncryptedDataSize*: ULONG + InitialVectorSize*: ULONG + InitialVector*: PUCHAR + EncryptedData*: PUCHAR + PKERB_DECRYPT_REQUEST* = ptr KERB_DECRYPT_REQUEST + KERB_DECRYPT_RESPONSE* {.pure.} = object + DecryptedData*: array[ANYSIZE_ARRAY, UCHAR] + PKERB_DECRYPT_RESPONSE* = ptr KERB_DECRYPT_RESPONSE + KERB_ADD_BINDING_CACHE_ENTRY_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + RealmName*: UNICODE_STRING + KdcAddress*: UNICODE_STRING + AddressType*: ULONG + PKERB_ADD_BINDING_CACHE_ENTRY_REQUEST* = ptr KERB_ADD_BINDING_CACHE_ENTRY_REQUEST + KERB_REFRESH_SCCRED_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + CredentialBlob*: UNICODE_STRING + LogonId*: LUID + Flags*: ULONG + PKERB_REFRESH_SCCRED_REQUEST* = ptr KERB_REFRESH_SCCRED_REQUEST + KERB_ADD_CREDENTIALS_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + UserName*: UNICODE_STRING + DomainName*: UNICODE_STRING + Password*: UNICODE_STRING + LogonId*: LUID + Flags*: ULONG + PKERB_ADD_CREDENTIALS_REQUEST* = ptr KERB_ADD_CREDENTIALS_REQUEST + KERB_TRANSFER_CRED_REQUEST* {.pure.} = object + MessageType*: KERB_PROTOCOL_MESSAGE_TYPE + OriginLogonId*: LUID + DestinationLogonId*: LUID + Flags*: ULONG + PKERB_TRANSFER_CRED_REQUEST* = ptr KERB_TRANSFER_CRED_REQUEST + AUDIT_POLICY_INFORMATION* {.pure.} = object + AuditSubCategoryGuid*: GUID + AuditingInformation*: ULONG + AuditCategoryGuid*: GUID + PAUDIT_POLICY_INFORMATION* = ptr AUDIT_POLICY_INFORMATION + PCAUDIT_POLICY_INFORMATION* = ptr AUDIT_POLICY_INFORMATION + POLICY_AUDIT_SID_ARRAY* {.pure.} = object + UsersCount*: ULONG + UserSidArray*: ptr PSID + PPOLICY_AUDIT_SID_ARRAY* = ptr POLICY_AUDIT_SID_ARRAY + KERB_CERTIFICATE_LOGON* {.pure.} = object + MessageType*: KERB_LOGON_SUBMIT_TYPE + DomainName*: UNICODE_STRING + UserName*: UNICODE_STRING + Pin*: UNICODE_STRING + Flags*: ULONG + CspDataLength*: ULONG + CspData*: PUCHAR + PKERB_CERTIFICATE_LOGON* = ptr KERB_CERTIFICATE_LOGON + KERB_CERTIFICATE_UNLOCK_LOGON* {.pure.} = object + Logon*: KERB_CERTIFICATE_LOGON + LogonId*: LUID + PKERB_CERTIFICATE_UNLOCK_LOGON* = ptr KERB_CERTIFICATE_UNLOCK_LOGON + KERB_SMARTCARD_CSP_INFO_UNION1* {.pure, union.} = object + ContextInformation*: PVOID + SpaceHolderForWow64*: ULONG64 + KERB_SMARTCARD_CSP_INFO* {.pure.} = object + dwCspInfoLen*: DWORD + MessageType*: DWORD + union1*: KERB_SMARTCARD_CSP_INFO_UNION1 + flags*: DWORD + KeySpec*: DWORD + nCardNameOffset*: ULONG + nReaderNameOffset*: ULONG + nContainerNameOffset*: ULONG + nCSPNameOffset*: ULONG + bBuffer*: TCHAR + PKERB_SMARTCARD_CSP_INFO* = ptr KERB_SMARTCARD_CSP_INFO + CredHandle* = SecHandle + PCredHandle* = PSecHandle + CtxtHandle* = SecHandle + PCtxtHandle* = PSecHandle + SECURITY_INTEGER* = LARGE_INTEGER + TimeStamp* = SECURITY_INTEGER + PTimeStamp* = ptr SECURITY_INTEGER + SECURITY_STRING* = UNICODE_STRING + PSECURITY_STRING* = ptr UNICODE_STRING + SecPkgInfoW* {.pure.} = object + fCapabilities*: int32 + wVersion*: uint16 + wRPCID*: uint16 + cbMaxToken*: int32 + Name*: ptr SEC_WCHAR + Comment*: ptr SEC_WCHAR + PSecPkgInfoW* = ptr SecPkgInfoW + SecPkgInfoA* {.pure.} = object + fCapabilities*: int32 + wVersion*: uint16 + wRPCID*: uint16 + cbMaxToken*: int32 + Name*: ptr SEC_CHAR + Comment*: ptr SEC_CHAR + PSecPkgInfoA* = ptr SecPkgInfoA + SecBuffer* {.pure.} = object + cbBuffer*: int32 + BufferType*: int32 + pvBuffer*: pointer + PSecBuffer* = ptr SecBuffer + SecBufferDesc* {.pure.} = object + ulVersion*: int32 + cBuffers*: int32 + pBuffers*: PSecBuffer + PSecBufferDesc* = ptr SecBufferDesc + SEC_NEGOTIATION_INFO* {.pure.} = object + Size*: int32 + NameLength*: int32 + Name*: ptr SEC_WCHAR + Reserved*: pointer + PSEC_NEGOTIATION_INFO* = ptr SEC_NEGOTIATION_INFO + SEC_CHANNEL_BINDINGS* {.pure.} = object + dwInitiatorAddrType*: int32 + cbInitiatorLength*: int32 + dwInitiatorOffset*: int32 + dwAcceptorAddrType*: int32 + cbAcceptorLength*: int32 + dwAcceptorOffset*: int32 + cbApplicationDataLength*: int32 + dwApplicationDataOffset*: int32 + PSEC_CHANNEL_BINDINGS* = ptr SEC_CHANNEL_BINDINGS + SecPkgCredentials_NamesW* {.pure.} = object + sUserName*: ptr SEC_WCHAR + PSecPkgCredentials_NamesW* = ptr SecPkgCredentials_NamesW + SecPkgCredentials_NamesA* {.pure.} = object + sUserName*: ptr SEC_CHAR + PSecPkgCredentials_NamesA* = ptr SecPkgCredentials_NamesA + SecPkgCredentials_SSIProviderW* {.pure.} = object + sProviderName*: ptr SEC_WCHAR + ProviderInfoLength*: int32 + ProviderInfo*: ptr char + PSecPkgCredentials_SSIProviderW* = ptr SecPkgCredentials_SSIProviderW + SecPkgCredentials_SSIProviderA* {.pure.} = object + sProviderName*: ptr SEC_CHAR + ProviderInfoLength*: int32 + ProviderInfo*: ptr char + PSecPkgCredentials_SSIProviderA* = ptr SecPkgCredentials_SSIProviderA + SecPkgContext_Sizes* {.pure.} = object + cbMaxToken*: int32 + cbMaxSignature*: int32 + cbBlockSize*: int32 + cbSecurityTrailer*: int32 + PSecPkgContext_Sizes* = ptr SecPkgContext_Sizes + SecPkgContext_StreamSizes* {.pure.} = object + cbHeader*: int32 + cbTrailer*: int32 + cbMaximumMessage*: int32 + cBuffers*: int32 + cbBlockSize*: int32 + PSecPkgContext_StreamSizes* = ptr SecPkgContext_StreamSizes + SecPkgContext_NamesW* {.pure.} = object + sUserName*: ptr SEC_WCHAR + PSecPkgContext_NamesW* = ptr SecPkgContext_NamesW + SecPkgContext_NamesA* {.pure.} = object + sUserName*: ptr SEC_CHAR + PSecPkgContext_NamesA* = ptr SecPkgContext_NamesA + SecPkgContext_Lifespan* {.pure.} = object + tsStart*: TimeStamp + tsExpiry*: TimeStamp + PSecPkgContext_Lifespan* = ptr SecPkgContext_Lifespan + SecPkgContext_DceInfo* {.pure.} = object + AuthzSvc*: int32 + pPac*: pointer + PSecPkgContext_DceInfo* = ptr SecPkgContext_DceInfo + SecPkgContext_KeyInfoA* {.pure.} = object + sSignatureAlgorithmName*: ptr SEC_CHAR + sEncryptAlgorithmName*: ptr SEC_CHAR + KeySize*: int32 + SignatureAlgorithm*: int32 + EncryptAlgorithm*: int32 + PSecPkgContext_KeyInfoA* = ptr SecPkgContext_KeyInfoA + SecPkgContext_KeyInfoW* {.pure.} = object + sSignatureAlgorithmName*: ptr SEC_WCHAR + sEncryptAlgorithmName*: ptr SEC_WCHAR + KeySize*: int32 + SignatureAlgorithm*: int32 + EncryptAlgorithm*: int32 + PSecPkgContext_KeyInfoW* = ptr SecPkgContext_KeyInfoW + SecPkgContext_AuthorityA* {.pure.} = object + sAuthorityName*: ptr SEC_CHAR + PSecPkgContext_AuthorityA* = ptr SecPkgContext_AuthorityA + SecPkgContext_AuthorityW* {.pure.} = object + sAuthorityName*: ptr SEC_WCHAR + PSecPkgContext_AuthorityW* = ptr SecPkgContext_AuthorityW + SecPkgContext_ProtoInfoA* {.pure.} = object + sProtocolName*: ptr SEC_CHAR + majorVersion*: int32 + minorVersion*: int32 + PSecPkgContext_ProtoInfoA* = ptr SecPkgContext_ProtoInfoA + SecPkgContext_ProtoInfoW* {.pure.} = object + sProtocolName*: ptr SEC_WCHAR + majorVersion*: int32 + minorVersion*: int32 + PSecPkgContext_ProtoInfoW* = ptr SecPkgContext_ProtoInfoW + SecPkgContext_PasswordExpiry* {.pure.} = object + tsPasswordExpires*: TimeStamp + PSecPkgContext_PasswordExpiry* = ptr SecPkgContext_PasswordExpiry + SecPkgContext_LogoffTime* {.pure.} = object + tsLogoffTime*: TimeStamp + PSecPkgContext_LogoffTime* = ptr SecPkgContext_LogoffTime + SecPkgContext_SessionKey* {.pure.} = object + SessionKeyLength*: int32 + SessionKey*: ptr uint8 + PSecPkgContext_SessionKey* = ptr SecPkgContext_SessionKey + SecPkgContext_PackageInfoW* {.pure.} = object + PackageInfo*: PSecPkgInfoW + PSecPkgContext_PackageInfoW* = ptr SecPkgContext_PackageInfoW + SecPkgContext_PackageInfoA* {.pure.} = object + PackageInfo*: PSecPkgInfoA + PSecPkgContext_PackageInfoA* = ptr SecPkgContext_PackageInfoA + SecPkgContext_UserFlags* {.pure.} = object + UserFlags*: int32 + PSecPkgContext_UserFlags* = ptr SecPkgContext_UserFlags + SecPkgContext_Flags* {.pure.} = object + Flags*: int32 + PSecPkgContext_Flags* = ptr SecPkgContext_Flags + SecPkgContext_NegotiationInfoA* {.pure.} = object + PackageInfo*: PSecPkgInfoA + NegotiationState*: int32 + PSecPkgContext_NegotiationInfoA* = ptr SecPkgContext_NegotiationInfoA + SecPkgContext_NegotiationInfoW* {.pure.} = object + PackageInfo*: PSecPkgInfoW + NegotiationState*: int32 + PSecPkgContext_NegotiationInfoW* = ptr SecPkgContext_NegotiationInfoW + SecPkgContext_NativeNamesW* {.pure.} = object + sClientName*: ptr SEC_WCHAR + sServerName*: ptr SEC_WCHAR + PSecPkgContext_NativeNamesW* = ptr SecPkgContext_NativeNamesW + SecPkgContext_NativeNamesA* {.pure.} = object + sClientName*: ptr SEC_CHAR + sServerName*: ptr SEC_CHAR + PSecPkgContext_NativeNamesA* = ptr SecPkgContext_NativeNamesA + SecPkgContext_CredentialNameW* {.pure.} = object + CredentialType*: int32 + sCredentialName*: ptr SEC_WCHAR + PSecPkgContext_CredentialNameW* = ptr SecPkgContext_CredentialNameW + SecPkgContext_CredentialNameA* {.pure.} = object + CredentialType*: int32 + sCredentialName*: ptr SEC_CHAR + PSecPkgContext_CredentialNameA* = ptr SecPkgContext_CredentialNameA + SecPkgContext_AccessToken* {.pure.} = object + AccessToken*: pointer + PSecPkgContext_AccessToken* = ptr SecPkgContext_AccessToken + SecPkgContext_TargetInformation* {.pure.} = object + MarshalledTargetInfoLength*: int32 + MarshalledTargetInfo*: ptr uint8 + PSecPkgContext_TargetInformation* = ptr SecPkgContext_TargetInformation + SecPkgContext_AuthzID* {.pure.} = object + AuthzIDLength*: int32 + AuthzID*: ptr char + PSecPkgContext_AuthzID* = ptr SecPkgContext_AuthzID + SecPkgContext_Target* {.pure.} = object + TargetLength*: int32 + Target*: ptr char + PSecPkgContext_Target* = ptr SecPkgContext_Target + ENUMERATE_SECURITY_PACKAGES_FN_W* = proc (P1: ptr int32, P2: ptr PSecPkgInfoW): SECURITY_STATUS {.stdcall.} + QUERY_CREDENTIALS_ATTRIBUTES_FN_W* = proc (P1: PCredHandle, P2: int32, P3: pointer): SECURITY_STATUS {.stdcall.} + SEC_GET_KEY_FN* = proc (Arg: pointer, Principal: pointer, KeyVer: int32, Key: ptr pointer, Status: ptr SECURITY_STATUS): void {.stdcall.} + ACQUIRE_CREDENTIALS_HANDLE_FN_W* = proc (P1: ptr SEC_WCHAR, P2: ptr SEC_WCHAR, P3: int32, P4: pointer, P5: pointer, P6: SEC_GET_KEY_FN, P7: pointer, P8: PCredHandle, P9: PTimeStamp): SECURITY_STATUS {.stdcall.} + FREE_CREDENTIALS_HANDLE_FN* = proc (P1: PCredHandle): SECURITY_STATUS {.stdcall.} + INITIALIZE_SECURITY_CONTEXT_FN_W* = proc (P1: PCredHandle, P2: PCtxtHandle, P3: ptr SEC_WCHAR, P4: int32, P5: int32, P6: int32, P7: PSecBufferDesc, P8: int32, P9: PCtxtHandle, P10: PSecBufferDesc, P11: ptr int32, P12: PTimeStamp): SECURITY_STATUS {.stdcall.} + ACCEPT_SECURITY_CONTEXT_FN* = proc (P1: PCredHandle, P2: PCtxtHandle, P3: PSecBufferDesc, P4: int32, P5: int32, P6: PCtxtHandle, P7: PSecBufferDesc, P8: ptr int32, P9: PTimeStamp): SECURITY_STATUS {.stdcall.} + COMPLETE_AUTH_TOKEN_FN* = proc (P1: PCtxtHandle, P2: PSecBufferDesc): SECURITY_STATUS {.stdcall.} + DELETE_SECURITY_CONTEXT_FN* = proc (P1: PCtxtHandle): SECURITY_STATUS {.stdcall.} + APPLY_CONTROL_TOKEN_FN* = proc (P1: PCtxtHandle, P2: PSecBufferDesc): SECURITY_STATUS {.stdcall.} + QUERY_CONTEXT_ATTRIBUTES_FN_W* = proc (P1: PCtxtHandle, P2: int32, P3: pointer): SECURITY_STATUS {.stdcall.} + IMPERSONATE_SECURITY_CONTEXT_FN* = proc (P1: PCtxtHandle): SECURITY_STATUS {.stdcall.} + REVERT_SECURITY_CONTEXT_FN* = proc (P1: PCtxtHandle): SECURITY_STATUS {.stdcall.} + MAKE_SIGNATURE_FN* = proc (P1: PCtxtHandle, P2: int32, P3: PSecBufferDesc, P4: int32): SECURITY_STATUS {.stdcall.} + VERIFY_SIGNATURE_FN* = proc (P1: PCtxtHandle, P2: PSecBufferDesc, P3: int32, P4: ptr int32): SECURITY_STATUS {.stdcall.} + FREE_CONTEXT_BUFFER_FN* = proc (P1: pointer): SECURITY_STATUS {.stdcall.} + QUERY_SECURITY_PACKAGE_INFO_FN_W* = proc (P1: ptr SEC_WCHAR, P2: ptr PSecPkgInfoW): SECURITY_STATUS {.stdcall.} + EXPORT_SECURITY_CONTEXT_FN* = proc (P1: PCtxtHandle, P2: ULONG, P3: PSecBuffer, P4: ptr pointer): SECURITY_STATUS {.stdcall.} + IMPORT_SECURITY_CONTEXT_FN_W* = proc (P1: ptr SEC_WCHAR, P2: PSecBuffer, P3: pointer, P4: PCtxtHandle): SECURITY_STATUS {.stdcall.} + ADD_CREDENTIALS_FN_W* = proc (P1: PCredHandle, P2: ptr SEC_WCHAR, P3: ptr SEC_WCHAR, P4: int32, P5: pointer, P6: SEC_GET_KEY_FN, P7: pointer, P8: PTimeStamp): SECURITY_STATUS {.stdcall.} + QUERY_SECURITY_CONTEXT_TOKEN_FN* = proc (P1: PCtxtHandle, P2: ptr HANDLE): SECURITY_STATUS {.stdcall.} + ENCRYPT_MESSAGE_FN* = proc (P1: PCtxtHandle, P2: int32, P3: PSecBufferDesc, P4: int32): SECURITY_STATUS {.stdcall.} + DECRYPT_MESSAGE_FN* = proc (P1: PCtxtHandle, P2: PSecBufferDesc, P3: int32, P4: ptr int32): SECURITY_STATUS {.stdcall.} + SET_CONTEXT_ATTRIBUTES_FN_W* = proc (P1: PCtxtHandle, P2: int32, P3: pointer, P4: int32): SECURITY_STATUS {.stdcall.} + SET_CREDENTIALS_ATTRIBUTES_FN_W* = proc (P1: PCredHandle, P2: int32, P3: pointer, P4: int32): SECURITY_STATUS {.stdcall.} + SecurityFunctionTableW* {.pure.} = object + dwVersion*: int32 + EnumerateSecurityPackagesW*: ENUMERATE_SECURITY_PACKAGES_FN_W + QueryCredentialsAttributesW*: QUERY_CREDENTIALS_ATTRIBUTES_FN_W + AcquireCredentialsHandleW*: ACQUIRE_CREDENTIALS_HANDLE_FN_W + FreeCredentialsHandle*: FREE_CREDENTIALS_HANDLE_FN + Reserved2*: pointer + InitializeSecurityContextW*: INITIALIZE_SECURITY_CONTEXT_FN_W + AcceptSecurityContext*: ACCEPT_SECURITY_CONTEXT_FN + CompleteAuthToken*: COMPLETE_AUTH_TOKEN_FN + DeleteSecurityContext*: DELETE_SECURITY_CONTEXT_FN + ApplyControlToken*: APPLY_CONTROL_TOKEN_FN + QueryContextAttributesW*: QUERY_CONTEXT_ATTRIBUTES_FN_W + ImpersonateSecurityContext*: IMPERSONATE_SECURITY_CONTEXT_FN + RevertSecurityContext*: REVERT_SECURITY_CONTEXT_FN + MakeSignature*: MAKE_SIGNATURE_FN + VerifySignature*: VERIFY_SIGNATURE_FN + FreeContextBuffer*: FREE_CONTEXT_BUFFER_FN + QuerySecurityPackageInfoW*: QUERY_SECURITY_PACKAGE_INFO_FN_W + Reserved3*: pointer + Reserved4*: pointer + ExportSecurityContext*: EXPORT_SECURITY_CONTEXT_FN + ImportSecurityContextW*: IMPORT_SECURITY_CONTEXT_FN_W + AddCredentialsW*: ADD_CREDENTIALS_FN_W + Reserved8*: pointer + QuerySecurityContextToken*: QUERY_SECURITY_CONTEXT_TOKEN_FN + EncryptMessage*: ENCRYPT_MESSAGE_FN + DecryptMessage*: DECRYPT_MESSAGE_FN + SetContextAttributesW*: SET_CONTEXT_ATTRIBUTES_FN_W + SetCredentialsAttributesW*: SET_CREDENTIALS_ATTRIBUTES_FN_W + PSecurityFunctionTableW* = ptr SecurityFunctionTableW + ENUMERATE_SECURITY_PACKAGES_FN_A* = proc (P1: ptr int32, P2: ptr PSecPkgInfoA): SECURITY_STATUS {.stdcall.} + QUERY_CREDENTIALS_ATTRIBUTES_FN_A* = proc (P1: PCredHandle, P2: int32, P3: pointer): SECURITY_STATUS {.stdcall.} + ACQUIRE_CREDENTIALS_HANDLE_FN_A* = proc (P1: ptr SEC_CHAR, P2: ptr SEC_CHAR, P3: int32, P4: pointer, P5: pointer, P6: SEC_GET_KEY_FN, P7: pointer, P8: PCredHandle, P9: PTimeStamp): SECURITY_STATUS {.stdcall.} + INITIALIZE_SECURITY_CONTEXT_FN_A* = proc (P1: PCredHandle, P2: PCtxtHandle, P3: ptr SEC_CHAR, P4: int32, P5: int32, P6: int32, P7: PSecBufferDesc, P8: int32, P9: PCtxtHandle, P10: PSecBufferDesc, P11: ptr int32, P12: PTimeStamp): SECURITY_STATUS {.stdcall.} + QUERY_CONTEXT_ATTRIBUTES_FN_A* = proc (P1: PCtxtHandle, P2: int32, P3: pointer): SECURITY_STATUS {.stdcall.} + QUERY_SECURITY_PACKAGE_INFO_FN_A* = proc (P1: ptr SEC_CHAR, P2: ptr PSecPkgInfoA): SECURITY_STATUS {.stdcall.} + IMPORT_SECURITY_CONTEXT_FN_A* = proc (P1: ptr SEC_CHAR, P2: PSecBuffer, P3: pointer, P4: PCtxtHandle): SECURITY_STATUS {.stdcall.} + ADD_CREDENTIALS_FN_A* = proc (P1: PCredHandle, P2: ptr SEC_CHAR, P3: ptr SEC_CHAR, P4: int32, P5: pointer, P6: SEC_GET_KEY_FN, P7: pointer, P8: PTimeStamp): SECURITY_STATUS {.stdcall.} + SET_CONTEXT_ATTRIBUTES_FN_A* = proc (P1: PCtxtHandle, P2: int32, P3: pointer, P4: int32): SECURITY_STATUS {.stdcall.} + SET_CREDENTIALS_ATTRIBUTES_FN_A* = proc (P1: PCredHandle, P2: int32, P3: pointer, P4: int32): SECURITY_STATUS {.stdcall.} + SecurityFunctionTableA* {.pure.} = object + dwVersion*: int32 + EnumerateSecurityPackagesA*: ENUMERATE_SECURITY_PACKAGES_FN_A + QueryCredentialsAttributesA*: QUERY_CREDENTIALS_ATTRIBUTES_FN_A + AcquireCredentialsHandleA*: ACQUIRE_CREDENTIALS_HANDLE_FN_A + FreeCredentialHandle*: FREE_CREDENTIALS_HANDLE_FN + Reserved2*: pointer + InitializeSecurityContextA*: INITIALIZE_SECURITY_CONTEXT_FN_A + AcceptSecurityContext*: ACCEPT_SECURITY_CONTEXT_FN + CompleteAuthToken*: COMPLETE_AUTH_TOKEN_FN + DeleteSecurityContext*: DELETE_SECURITY_CONTEXT_FN + ApplyControlToken*: APPLY_CONTROL_TOKEN_FN + QueryContextAttributesA*: QUERY_CONTEXT_ATTRIBUTES_FN_A + ImpersonateSecurityContext*: IMPERSONATE_SECURITY_CONTEXT_FN + RevertSecurityContext*: REVERT_SECURITY_CONTEXT_FN + MakeSignature*: MAKE_SIGNATURE_FN + VerifySignature*: VERIFY_SIGNATURE_FN + FreeContextBuffer*: FREE_CONTEXT_BUFFER_FN + QuerySecurityPackageInfoA*: QUERY_SECURITY_PACKAGE_INFO_FN_A + Reserved3*: pointer + Reserved4*: pointer + ExportSecurityContext*: EXPORT_SECURITY_CONTEXT_FN + ImportSecurityContextA*: IMPORT_SECURITY_CONTEXT_FN_A + AddCredentialsA*: ADD_CREDENTIALS_FN_A + Reserved8*: pointer + QuerySecurityContextToken*: QUERY_SECURITY_CONTEXT_TOKEN_FN + EncryptMessage*: ENCRYPT_MESSAGE_FN + DecryptMessage*: DECRYPT_MESSAGE_FN + SetContextAttributesA*: SET_CONTEXT_ATTRIBUTES_FN_A + SetCredentialsAttributesA*: SET_CREDENTIALS_ATTRIBUTES_FN_A + PSecurityFunctionTableA* = ptr SecurityFunctionTableA + SEC_WINNT_AUTH_IDENTITY_W* {.pure.} = object + User*: ptr uint16 + UserLength*: int32 + Domain*: ptr uint16 + DomainLength*: int32 + Password*: ptr uint16 + PasswordLength*: int32 + Flags*: int32 + PSEC_WINNT_AUTH_IDENTITY_W* = ptr SEC_WINNT_AUTH_IDENTITY_W + SEC_WINNT_AUTH_IDENTITY_A* {.pure.} = object + User*: ptr uint8 + UserLength*: int32 + Domain*: ptr uint8 + DomainLength*: int32 + Password*: ptr uint8 + PasswordLength*: int32 + Flags*: int32 + PSEC_WINNT_AUTH_IDENTITY_A* = ptr SEC_WINNT_AUTH_IDENTITY_A + SEC_WINNT_AUTH_IDENTITY_EXW* {.pure.} = object + Version*: int32 + Length*: int32 + User*: ptr uint16 + UserLength*: int32 + Domain*: ptr uint16 + DomainLength*: int32 + Password*: ptr uint16 + PasswordLength*: int32 + Flags*: int32 + PackageList*: ptr uint16 + PackageListLength*: int32 + PSEC_WINNT_AUTH_IDENTITY_EXW* = ptr SEC_WINNT_AUTH_IDENTITY_EXW + SEC_WINNT_AUTH_IDENTITY_EXA* {.pure.} = object + Version*: int32 + Length*: int32 + User*: ptr uint8 + UserLength*: int32 + Domain*: ptr uint8 + DomainLength*: int32 + Password*: ptr uint8 + PasswordLength*: int32 + Flags*: int32 + PackageList*: ptr uint8 + PackageListLength*: int32 + PSEC_WINNT_AUTH_IDENTITY_EXA* = ptr SEC_WINNT_AUTH_IDENTITY_EXA + SECURITY_PACKAGE_OPTIONS* {.pure.} = object + Size*: int32 + Type*: int32 + Flags*: int32 + SignatureSize*: int32 + Signature*: pointer + PSECURITY_PACKAGE_OPTIONS* = ptr SECURITY_PACKAGE_OPTIONS + CREDUIWIN_MARSHALED_CONTEXT* {.pure.} = object + StructureType*: GUID + cbHeaderLength*: USHORT + LogonId*: LUID + MarshaledDataType*: GUID + MarshaledDataOffset*: ULONG + MarshaledDataLength*: USHORT + PCREDUIWIN_MARSHALED_CONTEXT* = ptr CREDUIWIN_MARSHALED_CONTEXT + PSECURITY_INTEGER* = ptr LARGE_INTEGER +const + NTLMSP_NAME_A* = "NTLM" + NTLMSP_NAME* = "NTLM" + MICROSOFT_KERBEROS_NAME_A* = "Kerberos" + MICROSOFT_KERBEROS_NAME_W* = "Kerberos" + NEGOSSP_NAME_W* = "Negotiate" + NEGOSSP_NAME_A* = "Negotiate" + LSA_MODE_PASSWORD_PROTECTED* = 0x00000001 + LSA_MODE_INDIVIDUAL_ACCOUNTS* = 0x00000002 + LSA_MODE_MANDATORY_ACCESS* = 0x00000004 + LSA_MODE_LOG_FULL* = 0x00000008 + interactive* = 2 + network* = 3 + batch* = 4 + service* = 5 + proxy* = 6 + unlock* = 7 + networkCleartext* = 8 + newCredentials* = 9 + remoteInteractive* = 10 + cachedInteractive* = 11 + cachedRemoteInteractive* = 12 + cachedUnlock* = 13 + seAdtParmTypeNone* = 0 + seAdtParmTypeString* = 1 + seAdtParmTypeFileSpec* = 2 + seAdtParmTypeUlong* = 3 + seAdtParmTypeSid* = 4 + seAdtParmTypeLogonId* = 5 + seAdtParmTypeNoLogonId* = 6 + seAdtParmTypeAccessMask* = 7 + seAdtParmTypePrivs* = 8 + seAdtParmTypeObjectTypes* = 9 + seAdtParmTypeHexUlong* = 10 + seAdtParmTypePtr* = 11 + seAdtParmTypeTime* = 12 + seAdtParmTypeGuid* = 13 + seAdtParmTypeLuid* = 14 + seAdtParmTypeHexInt64* = 15 + seAdtParmTypeStringList* = 16 + seAdtParmTypeSidList* = 17 + seAdtParmTypeDuration* = 18 + seAdtParmTypeUserAccountControl* = 19 + seAdtParmTypeNoUac* = 20 + seAdtParmTypeMessage* = 21 + seAdtParmTypeDateTime* = 22 + seAdtParmTypeSockAddr* = 23 + SE_ADT_OBJECT_ONLY* = 0x1 + SE_MAX_GENERIC_AUDIT_PARAMETERS* = 28 + SE_ADT_PARAMETERS_SELF_RELATIVE* = 0x00000001 + auditCategorySystem* = 0 + auditCategoryLogon* = 1 + auditCategoryObjectAccess* = 2 + auditCategoryPrivilegeUse* = 3 + auditCategoryDetailedTracking* = 4 + auditCategoryPolicyChange* = 5 + auditCategoryAccountManagement* = 6 + auditCategoryDirectoryServiceAccess* = 7 + auditCategoryAccountLogon* = 8 + POLICY_AUDIT_EVENT_UNCHANGED* = 0x00000000 + POLICY_AUDIT_EVENT_SUCCESS* = 0x00000001 + POLICY_AUDIT_EVENT_FAILURE* = 0x00000002 + POLICY_AUDIT_EVENT_NONE* = 0x00000004 + POLICY_AUDIT_EVENT_MASK* = POLICY_AUDIT_EVENT_SUCCESS or POLICY_AUDIT_EVENT_FAILURE or POLICY_AUDIT_EVENT_UNCHANGED or POLICY_AUDIT_EVENT_NONE + POLICY_VIEW_LOCAL_INFORMATION* = 0x00000001 + POLICY_VIEW_AUDIT_INFORMATION* = 0x00000002 + POLICY_GET_PRIVATE_INFORMATION* = 0x00000004 + POLICY_TRUST_ADMIN* = 0x00000008 + POLICY_CREATE_ACCOUNT* = 0x00000010 + POLICY_CREATE_SECRET* = 0x00000020 + POLICY_CREATE_PRIVILEGE* = 0x00000040 + POLICY_SET_DEFAULT_QUOTA_LIMITS* = 0x00000080 + POLICY_SET_AUDIT_REQUIREMENTS* = 0x00000100 + POLICY_AUDIT_LOG_ADMIN* = 0x00000200 + POLICY_SERVER_ADMIN* = 0x00000400 + POLICY_LOOKUP_NAMES* = 0x00000800 + POLICY_NOTIFICATION* = 0x00001000 + POLICY_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or POLICY_VIEW_LOCAL_INFORMATION or POLICY_VIEW_AUDIT_INFORMATION or POLICY_GET_PRIVATE_INFORMATION or POLICY_TRUST_ADMIN or POLICY_CREATE_ACCOUNT or POLICY_CREATE_SECRET or POLICY_CREATE_PRIVILEGE or POLICY_SET_DEFAULT_QUOTA_LIMITS or POLICY_SET_AUDIT_REQUIREMENTS or POLICY_AUDIT_LOG_ADMIN or POLICY_SERVER_ADMIN or POLICY_LOOKUP_NAMES + POLICY_READ* = STANDARD_RIGHTS_READ or POLICY_VIEW_AUDIT_INFORMATION or POLICY_GET_PRIVATE_INFORMATION + POLICY_WRITE* = STANDARD_RIGHTS_WRITE or POLICY_TRUST_ADMIN or POLICY_CREATE_ACCOUNT or POLICY_CREATE_SECRET or POLICY_CREATE_PRIVILEGE or POLICY_SET_DEFAULT_QUOTA_LIMITS or POLICY_SET_AUDIT_REQUIREMENTS or POLICY_AUDIT_LOG_ADMIN or POLICY_SERVER_ADMIN + POLICY_EXECUTE* = STANDARD_RIGHTS_EXECUTE or POLICY_VIEW_LOCAL_INFORMATION or POLICY_LOOKUP_NAMES + policyServerRoleBackup* = 2 + policyServerRolePrimary* = 3 + policyAuditLogInformation* = 1 + policyAuditEventsInformation* = 2 + policyPrimaryDomainInformation* = 3 + policyPdAccountInformation* = 4 + policyAccountDomainInformation* = 5 + policyLsaServerRoleInformation* = 6 + policyReplicaSourceInformation* = 7 + policyDefaultQuotaInformation* = 8 + policyModificationInformation* = 9 + policyAuditFullSetInformation* = 10 + policyAuditFullQueryInformation* = 11 + policyDnsDomainInformation* = 12 + policyDnsDomainInformationInt* = 13 + policyDomainEfsInformation* = 2 + policyDomainKerberosTicketInformation* = 3 + POLICY_KERBEROS_VALIDATE_CLIENT* = 0x00000080 + policyNotifyAuditEventsInformation* = 1 + policyNotifyAccountDomainInformation* = 2 + policyNotifyServerRoleInformation* = 3 + policyNotifyDnsDomainInformation* = 4 + policyNotifyDomainEfsInformation* = 5 + policyNotifyDomainKerberosTicketInformation* = 6 + policyNotifyMachineAccountPasswordInformation* = 7 + trustedDomainNameInformation* = 1 + trustedControllersInformation* = 2 + trustedPosixOffsetInformation* = 3 + trustedPasswordInformation* = 4 + trustedDomainInformationBasic* = 5 + trustedDomainInformationEx* = 6 + trustedDomainAuthInformation* = 7 + trustedDomainFullInformation* = 8 + trustedDomainAuthInformationInternal* = 9 + trustedDomainFullInformationInternal* = 10 + trustedDomainInformationEx2Internal* = 11 + trustedDomainFullInformation2Internal* = 12 + TRUST_DIRECTION_DISABLED* = 0x00000000 + TRUST_DIRECTION_INBOUND* = 0x00000001 + TRUST_DIRECTION_OUTBOUND* = 0x00000002 + TRUST_DIRECTION_BIDIRECTIONAL* = TRUST_DIRECTION_INBOUND or TRUST_DIRECTION_OUTBOUND + TRUST_TYPE_DOWNLEVEL* = 0x00000001 + TRUST_TYPE_UPLEVEL* = 0x00000002 + TRUST_TYPE_MIT* = 0x00000003 + TRUST_ATTRIBUTE_NON_TRANSITIVE* = 0x00000001 + TRUST_ATTRIBUTE_UPLEVEL_ONLY* = 0x00000002 + TRUST_ATTRIBUTE_QUARANTINED_DOMAIN* = 0x00000004 + TRUST_ATTRIBUTE_FOREST_TRANSITIVE* = 0x00000008 + TRUST_ATTRIBUTE_CROSS_ORGANIZATION* = 0x00000010 + TRUST_ATTRIBUTE_WITHIN_FOREST* = 0x00000020 + TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL* = 0x00000040 + TRUST_ATTRIBUTE_TRUST_USES_RC4_ENCRYPTION* = 0x00000080 + TRUST_ATTRIBUTES_VALID* = 0xFF03FFFF'i32 + TRUST_ATTRIBUTES_USER* = 0xFF000000'i32 + TRUST_AUTH_TYPE_NONE* = 0 + TRUST_AUTH_TYPE_NT4OWF* = 1 + TRUST_AUTH_TYPE_CLEAR* = 2 + TRUST_AUTH_TYPE_VERSION* = 3 + forestTrustTopLevelName* = 0 + forestTrustTopLevelNameEx* = 1 + forestTrustDomainInfo* = 2 + forestTrustRecordTypeLast* = forestTrustDomainInfo + LSA_FTRECORD_DISABLED_REASONS* = 0x0000FFFF + LSA_TLN_DISABLED_NEW* = 0x00000001 + LSA_TLN_DISABLED_ADMIN* = 0x00000002 + LSA_TLN_DISABLED_CONFLICT* = 0x00000004 + LSA_SID_DISABLED_ADMIN* = 0x00000001 + LSA_SID_DISABLED_CONFLICT* = 0x00000002 + LSA_NB_DISABLED_ADMIN* = 0x00000004 + LSA_NB_DISABLED_CONFLICT* = 0x00000008 + MAX_FOREST_TRUST_BINARY_DATA_SIZE* = 128*1024 + MAX_RECORDS_IN_FOREST_TRUST_INFO* = 4000 + collisionTdo* = 0 + collisionXref* = 1 + collisionOther* = 2 + SE_INTERACTIVE_LOGON_NAME* = "SeInteractiveLogonRight" + SE_NETWORK_LOGON_NAME* = "SeNetworkLogonRight" + SE_BATCH_LOGON_NAME* = "SeBatchLogonRight" + SE_SERVICE_LOGON_NAME* = "SeServiceLogonRight" + SE_DENY_INTERACTIVE_LOGON_NAME* = "SeDenyInteractiveLogonRight" + SE_DENY_NETWORK_LOGON_NAME* = "SeDenyNetworkLogonRight" + SE_DENY_BATCH_LOGON_NAME* = "SeDenyBatchLogonRight" + SE_DENY_SERVICE_LOGON_NAME* = "SeDenyServiceLogonRight" + SE_REMOTE_INTERACTIVE_LOGON_NAME* = "SeRemoteInteractiveLogonRight" + SE_DENY_REMOTE_INTERACTIVE_LOGON_NAME* = "SeDenyRemoteInteractiveLogonRight" + negEnumPackagePrefixes* = 0 + negGetCallerName* = 1 + negCallPackageMax* = 2 + DOMAIN_PASSWORD_COMPLEX* = 0x00000001 + DOMAIN_PASSWORD_NO_ANON_CHANGE* = 0x00000002 + DOMAIN_PASSWORD_NO_CLEAR_CHANGE* = 0x00000004 + DOMAIN_LOCKOUT_ADMINS* = 0x00000008 + DOMAIN_PASSWORD_STORE_CLEARTEXT* = 0x00000010 + DOMAIN_REFUSE_PASSWORD_CHANGE* = 0x00000020 + SAM_PASSWORD_CHANGE_NOTIFY_ROUTINE* = "PasswordChangeNotify" + SAM_INIT_NOTIFICATION_ROUTINE* = "InitializeChangeNotify" + SAM_PASSWORD_FILTER_ROUTINE* = "PasswordFilter" + MSV1_0_PACKAGE_NAME* = "MICROSOFT_AUTHENTICATION_PACKAGE_V1_0" + MSV1_0_PACKAGE_NAMEW* = "MICROSOFT_AUTHENTICATION_PACKAGE_V1_0" + MSV1_0_SUBAUTHENTICATION_KEY* = "SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0" + MSV1_0_SUBAUTHENTICATION_VALUE* = "Auth" + MsV1_0InteractiveLogon* = 2 + MsV1_0Lm20Logon* = 3 + MsV1_0NetworkLogon* = 4 + MsV1_0SubAuthLogon* = 5 + MsV1_0WorkstationUnlockLogon* = 7 + MsV1_0InteractiveProfile* = 2 + MsV1_0Lm20LogonProfile* = 3 + MsV1_0SmartCardProfile* = 4 + MSV1_0_CLEARTEXT_PASSWORD_ALLOWED* = 0x02 + MSV1_0_UPDATE_LOGON_STATISTICS* = 0x04 + MSV1_0_RETURN_USER_PARAMETERS* = 0x08 + MSV1_0_DONT_TRY_GUEST_ACCOUNT* = 0x10 + MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT* = 0x20 + MSV1_0_RETURN_PASSWORD_EXPIRY* = 0x40 + MSV1_0_USE_CLIENT_CHALLENGE* = 0x80 + MSV1_0_TRY_GUEST_ACCOUNT_ONLY* = 0x100 + MSV1_0_RETURN_PROFILE_PATH* = 0x200 + MSV1_0_TRY_SPECIFIED_DOMAIN_ONLY* = 0x400 + MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT* = 0x800 + MSV1_0_DISABLE_PERSONAL_FALLBACK* = 0x00001000 + MSV1_0_ALLOW_FORCE_GUEST* = 0x00002000 + MSV1_0_CLEARTEXT_PASSWORD_SUPPLIED* = 0x00004000 + MSV1_0_USE_DOMAIN_FOR_ROUTING_ONLY* = 0x00008000 + MSV1_0_SUBAUTHENTICATION_DLL_EX* = 0x00100000 + MSV1_0_ALLOW_MSVCHAPV2* = 0x00010000 + MSV1_0_SUBAUTHENTICATION_DLL* = 0xFF000000'i32 + MSV1_0_SUBAUTHENTICATION_DLL_SHIFT* = 24 + MSV1_0_MNS_LOGON* = 0x01000000 + MSV1_0_SUBAUTHENTICATION_DLL_RAS* = 2 + MSV1_0_SUBAUTHENTICATION_DLL_IIS* = 132 + LOGON_GUEST* = 0x01 + LOGON_NOENCRYPTION* = 0x02 + LOGON_CACHED_ACCOUNT* = 0x04 + LOGON_USED_LM_PASSWORD* = 0x08 + LOGON_EXTRA_SIDS* = 0x20 + LOGON_SUBAUTH_SESSION_KEY* = 0x40 + LOGON_SERVER_TRUST_ACCOUNT* = 0x80 + LOGON_NTLMV2_ENABLED* = 0x100 + LOGON_RESOURCE_GROUPS* = 0x200 + LOGON_PROFILE_PATH_RETURNED* = 0x400 + MSV1_0_SUBAUTHENTICATION_FLAGS* = 0xFF000000'i32 + LOGON_GRACE_LOGON* = 0x01000000 + MSV1_0_CRED_LM_PRESENT* = 0x1 + MSV1_0_CRED_NT_PRESENT* = 0x2 + MSV1_0_CRED_VERSION* = 0 + MSV1_0_NTLM3_OWF_LENGTH* = 16 + MSV1_0_MAX_NTLM3_LIFE* = 129600 + MSV1_0_MAX_AVL_SIZE* = 64000 + MSV1_0_AV_FLAG_FORCE_GUEST* = 0x00000001 + msvAvEOL* = 0 + msvAvNbComputerName* = 1 + msvAvNbDomainName* = 2 + msvAvDnsComputerName* = 3 + msvAvDnsDomainName* = 4 + msvAvDnsTreeName* = 5 + msvAvFlags* = 6 + MsV1_0Lm20ChallengeRequest* = 0 + MsV1_0Lm20GetChallengeResponse* = 1 + MsV1_0EnumerateUsers* = 2 + MsV1_0GetUserInfo* = 3 + MsV1_0ReLogonUsers* = 4 + MsV1_0ChangePassword* = 5 + MsV1_0ChangeCachedPassword* = 6 + MsV1_0GenericPassthrough* = 7 + MsV1_0CacheLogon* = 8 + MsV1_0SubAuth* = 9 + MsV1_0DeriveCredential* = 10 + MsV1_0CacheLookup* = 11 + MsV1_0SetProcessOption* = 12 + RTL_ENCRYPT_MEMORY_SIZE* = 8 + RTL_ENCRYPT_OPTION_CROSS_PROCESS* = 0x01 + RTL_ENCRYPT_OPTION_SAME_LOGON* = 0x02 + KERBEROS_VERSION* = 5 + KERBEROS_REVISION* = 6 + KERB_ETYPE_NULL* = 0 + KERB_ETYPE_DES_CBC_CRC* = 1 + KERB_ETYPE_DES_CBC_MD4* = 2 + KERB_ETYPE_DES_CBC_MD5* = 3 + KERB_ETYPE_RC4_MD4* = -128 + KERB_ETYPE_RC4_PLAIN2* = -129 + KERB_ETYPE_RC4_LM* = -130 + KERB_ETYPE_RC4_SHA* = -131 + KERB_ETYPE_DES_PLAIN* = -132 + KERB_ETYPE_RC4_HMAC_OLD* = -133 + KERB_ETYPE_RC4_PLAIN_OLD* = -134 + KERB_ETYPE_RC4_HMAC_OLD_EXP* = -135 + KERB_ETYPE_RC4_PLAIN_OLD_EXP* = -136 + KERB_ETYPE_RC4_PLAIN* = -140 + KERB_ETYPE_RC4_PLAIN_EXP* = -141 + KERB_ETYPE_DSA_SHA1_CMS* = 9 + KERB_ETYPE_RSA_MD5_CMS* = 10 + KERB_ETYPE_RSA_SHA1_CMS* = 11 + KERB_ETYPE_RC2_CBC_ENV* = 12 + KERB_ETYPE_RSA_ENV* = 13 + KERB_ETYPE_RSA_ES_OEAP_ENV* = 14 + KERB_ETYPE_DES_EDE3_CBC_ENV* = 15 + KERB_ETYPE_DSA_SIGN* = 8 + KERB_ETYPE_RSA_PRIV* = 9 + KERB_ETYPE_RSA_PUB* = 10 + KERB_ETYPE_RSA_PUB_MD5* = 11 + KERB_ETYPE_RSA_PUB_SHA1* = 12 + KERB_ETYPE_PKCS7_PUB* = 13 + KERB_ETYPE_DES3_CBC_MD5* = 5 + KERB_ETYPE_DES3_CBC_SHA1* = 7 + KERB_ETYPE_DES3_CBC_SHA1_KD* = 16 + KERB_ETYPE_DES_CBC_MD5_NT* = 20 + KERB_ETYPE_RC4_HMAC_NT* = 23 + KERB_ETYPE_RC4_HMAC_NT_EXP* = 24 + KERB_CHECKSUM_NONE* = 0 + KERB_CHECKSUM_CRC32* = 1 + KERB_CHECKSUM_MD4* = 2 + KERB_CHECKSUM_KRB_DES_MAC* = 4 + KERB_CHECKSUM_KRB_DES_MAC_K* = 5 + KERB_CHECKSUM_MD5* = 7 + KERB_CHECKSUM_MD5_DES* = 8 + KERB_CHECKSUM_LM* = -130 + KERB_CHECKSUM_SHA1* = -131 + KERB_CHECKSUM_REAL_CRC32* = -132 + KERB_CHECKSUM_DES_MAC* = -133 + KERB_CHECKSUM_DES_MAC_MD5* = -134 + KERB_CHECKSUM_MD25* = -135 + KERB_CHECKSUM_RC4_MD5* = -136 + KERB_CHECKSUM_MD5_HMAC* = -137 + KERB_CHECKSUM_HMAC_MD5* = -138 + AUTH_REQ_ALLOW_FORWARDABLE* = 0x00000001 + AUTH_REQ_ALLOW_PROXIABLE* = 0x00000002 + AUTH_REQ_ALLOW_POSTDATE* = 0x00000004 + AUTH_REQ_ALLOW_RENEWABLE* = 0x00000008 + AUTH_REQ_ALLOW_NOADDRESS* = 0x00000010 + AUTH_REQ_ALLOW_ENC_TKT_IN_SKEY* = 0x00000020 + AUTH_REQ_ALLOW_VALIDATE* = 0x00000040 + AUTH_REQ_VALIDATE_CLIENT* = 0x00000080 + AUTH_REQ_OK_AS_DELEGATE* = 0x00000100 + AUTH_REQ_PREAUTH_REQUIRED* = 0x00000200 + AUTH_REQ_TRANSITIVE_TRUST* = 0x00000400 + AUTH_REQ_ALLOW_S4U_DELEGATE* = 0x00000800 + AUTH_REQ_PER_USER_FLAGS* = AUTH_REQ_ALLOW_FORWARDABLE or AUTH_REQ_ALLOW_PROXIABLE or AUTH_REQ_ALLOW_POSTDATE or AUTH_REQ_ALLOW_RENEWABLE or AUTH_REQ_ALLOW_VALIDATE + KERB_TICKET_FLAGS_reserved* = 0x80000000'i32 + KERB_TICKET_FLAGS_forwardable* = 0x40000000 + KERB_TICKET_FLAGS_forwarded* = 0x20000000 + KERB_TICKET_FLAGS_proxiable* = 0x10000000 + KERB_TICKET_FLAGS_proxy* = 0x08000000 + KERB_TICKET_FLAGS_may_postdate* = 0x04000000 + KERB_TICKET_FLAGS_postdated* = 0x02000000 + KERB_TICKET_FLAGS_invalid* = 0x01000000 + KERB_TICKET_FLAGS_renewable* = 0x00800000 + KERB_TICKET_FLAGS_initial* = 0x00400000 + KERB_TICKET_FLAGS_pre_authent* = 0x00200000 + KERB_TICKET_FLAGS_hw_authent* = 0x00100000 + KERB_TICKET_FLAGS_ok_as_delegate* = 0x00040000 + KERB_TICKET_FLAGS_name_canonicalize* = 0x00010000 + KERB_TICKET_FLAGS_reserved1* = 0x00000001 + KRB_NT_UNKNOWN* = 0 + KRB_NT_PRINCIPAL* = 1 + KRB_NT_PRINCIPAL_AND_ID* = -131 + KRB_NT_SRV_INST* = 2 + KRB_NT_SRV_INST_AND_ID* = -132 + KRB_NT_SRV_HST* = 3 + KRB_NT_SRV_XHST* = 4 + KRB_NT_UID* = 5 + KRB_NT_ENTERPRISE_PRINCIPAL* = 10 + KRB_NT_ENT_PRINCIPAL_AND_ID* = -130 + KRB_NT_MS_PRINCIPAL* = -128 + KRB_NT_MS_PRINCIPAL_AND_ID* = -129 + KERB_WRAP_NO_ENCRYPT* = 0x80000001'i32 + kerbInteractiveLogon* = 2 + kerbSmartCardLogon* = 6 + kerbWorkstationUnlockLogon* = 7 + kerbSmartCardUnlockLogon* = 8 + kerbProxyLogon* = 9 + kerbTicketLogon* = 10 + kerbTicketUnlockLogon* = 11 + kerbS4ULogon* = 12 + kerbCertificateLogon* = 13 + kerbCertificateS4ULogon* = 14 + kerbCertificateUnlockLogon* = 15 + KERB_LOGON_FLAG_ALLOW_EXPIRED_TICKET* = 0x1 + kerbInteractiveProfile* = 2 + kerbSmartCardProfile* = 4 + kerbTicketProfile* = 6 + kerbDebugRequestMessage* = 0 + kerbQueryTicketCacheMessage* = 1 + kerbChangeMachinePasswordMessage* = 2 + kerbVerifyPacMessage* = 3 + kerbRetrieveTicketMessage* = 4 + kerbUpdateAddressesMessage* = 5 + kerbPurgeTicketCacheMessage* = 6 + kerbChangePasswordMessage* = 7 + kerbRetrieveEncodedTicketMessage* = 8 + kerbDecryptDataMessage* = 9 + kerbAddBindingCacheEntryMessage* = 10 + kerbSetPasswordMessage* = 11 + kerbSetPasswordExMessage* = 12 + kerbVerifyCredentialsMessage* = 13 + kerbQueryTicketCacheExMessage* = 14 + kerbPurgeTicketCacheExMessage* = 15 + kerbRefreshSmartcardCredentialsMessage* = 16 + kerbAddExtraCredentialsMessage* = 17 + kerbQuerySupplementalCredentialsMessage* = 18 + kerbTransferCredentialsMessage* = 19 + kerbQueryTicketCacheEx2Message* = 20 + KERB_USE_DEFAULT_TICKET_FLAGS* = 0x0 + KERB_RETRIEVE_TICKET_DEFAULT* = 0x0 + KERB_RETRIEVE_TICKET_DONT_USE_CACHE* = 0x1 + KERB_RETRIEVE_TICKET_USE_CACHE_ONLY* = 0x2 + KERB_RETRIEVE_TICKET_USE_CREDHANDLE* = 0x4 + KERB_RETRIEVE_TICKET_AS_KERB_CRED* = 0x8 + KERB_RETRIEVE_TICKET_WITH_SEC_CRED* = 0x10 + KERB_RETRIEVE_TICKET_CACHE_TICKET* = 0x20 + KERB_ETYPE_DEFAULT* = 0x0 + KERB_PURGE_ALL_TICKETS* = 1 + DS_UNKNOWN_ADDRESS_TYPE* = 0 + KERB_SETPASS_USE_LOGONID* = 1 + KERB_SETPASS_USE_CREDHANDLE* = 2 + KERB_DECRYPT_FLAG_DEFAULT_KEY* = 0x00000001 + KERB_REFRESH_SCCRED_RELEASE* = 0x0 + KERB_REFRESH_SCCRED_GETTGT* = 0x1 + KERB_REQUEST_ADD_CREDENTIAL* = 1 + KERB_REQUEST_REPLACE_CREDENTIAL* = 2 + KERB_REQUEST_REMOVE_CREDENTIAL* = 4 + PER_USER_POLICY_UNCHANGED* = 0x00 + PER_USER_AUDIT_SUCCESS_INCLUDE* = 0x01 + PER_USER_AUDIT_SUCCESS_EXCLUDE* = 0x02 + PER_USER_AUDIT_FAILURE_INCLUDE* = 0x04 + PER_USER_AUDIT_FAILURE_EXCLUDE* = 0x08 + PER_USER_AUDIT_NONE* = 0x10 + SECPKG_FLAG_INTEGRITY* = 0x00000001 + SECPKG_FLAG_PRIVACY* = 0x00000002 + SECPKG_FLAG_TOKEN_ONLY* = 0x00000004 + SECPKG_FLAG_DATAGRAM* = 0x00000008 + SECPKG_FLAG_CONNECTION* = 0x00000010 + SECPKG_FLAG_MULTI_REQUIRED* = 0x00000020 + SECPKG_FLAG_CLIENT_ONLY* = 0x00000040 + SECPKG_FLAG_EXTENDED_ERROR* = 0x00000080 + SECPKG_FLAG_IMPERSONATION* = 0x00000100 + SECPKG_FLAG_ACCEPT_WIN32_NAME* = 0x00000200 + SECPKG_FLAG_STREAM* = 0x00000400 + SECPKG_FLAG_NEGOTIABLE* = 0x00000800 + SECPKG_FLAG_GSS_COMPATIBLE* = 0x00001000 + SECPKG_FLAG_LOGON* = 0x00002000 + SECPKG_FLAG_ASCII_BUFFERS* = 0x00004000 + SECPKG_FLAG_FRAGMENT* = 0x00008000 + SECPKG_FLAG_MUTUAL_AUTH* = 0x00010000 + SECPKG_FLAG_DELEGATION* = 0x00020000 + SECPKG_FLAG_READONLY_WITH_CHECKSUM* = 0x00040000 + SECPKG_ID_NONE* = 0xFFFF + SECBUFFER_VERSION* = 0 + SECBUFFER_EMPTY* = 0 + SECBUFFER_DATA* = 1 + SECBUFFER_TOKEN* = 2 + SECBUFFER_PKG_PARAMS* = 3 + SECBUFFER_MISSING* = 4 + SECBUFFER_EXTRA* = 5 + SECBUFFER_STREAM_TRAILER* = 6 + SECBUFFER_STREAM_HEADER* = 7 + SECBUFFER_NEGOTIATION_INFO* = 8 + SECBUFFER_PADDING* = 9 + SECBUFFER_STREAM* = 10 + SECBUFFER_MECHLIST* = 11 + SECBUFFER_MECHLIST_SIGNATURE* = 12 + SECBUFFER_TARGET* = 13 + SECBUFFER_CHANNEL_BINDINGS* = 14 + SECBUFFER_ATTRMASK* = 0xF0000000'i32 + SECBUFFER_READONLY* = 0x80000000'i32 + SECBUFFER_READONLY_WITH_CHECKSUM* = 0x10000000 + SECBUFFER_RESERVED* = 0x60000000 + SECURITY_NATIVE_DREP* = 0x00000010 + SECURITY_NETWORK_DREP* = 0x00000000 + SECPKG_CRED_INBOUND* = 0x00000001 + SECPKG_CRED_OUTBOUND* = 0x00000002 + SECPKG_CRED_BOTH* = 0x00000003 + SECPKG_CRED_DEFAULT* = 0x00000004 + SECPKG_CRED_RESERVED* = 0xF0000000'i32 + ISC_REQ_DELEGATE* = 0x00000001 + ISC_REQ_MUTUAL_AUTH* = 0x00000002 + ISC_REQ_REPLAY_DETECT* = 0x00000004 + ISC_REQ_SEQUENCE_DETECT* = 0x00000008 + ISC_REQ_CONFIDENTIALITY* = 0x00000010 + ISC_REQ_USE_SESSION_KEY* = 0x00000020 + ISC_REQ_PROMPT_FOR_CREDS* = 0x00000040 + ISC_REQ_USE_SUPPLIED_CREDS* = 0x00000080 + ISC_REQ_ALLOCATE_MEMORY* = 0x00000100 + ISC_REQ_USE_DCE_STYLE* = 0x00000200 + ISC_REQ_DATAGRAM* = 0x00000400 + ISC_REQ_CONNECTION* = 0x00000800 + ISC_REQ_CALL_LEVEL* = 0x00001000 + ISC_REQ_FRAGMENT_SUPPLIED* = 0x00002000 + ISC_REQ_EXTENDED_ERROR* = 0x00004000 + ISC_REQ_STREAM* = 0x00008000 + ISC_REQ_INTEGRITY* = 0x00010000 + ISC_REQ_IDENTIFY* = 0x00020000 + ISC_REQ_NULL_SESSION* = 0x00040000 + ISC_REQ_MANUAL_CRED_VALIDATION* = 0x00080000 + ISC_REQ_RESERVED1* = 0x00100000 + ISC_REQ_FRAGMENT_TO_FIT* = 0x00200000 + ISC_RET_DELEGATE* = 0x00000001 + ISC_RET_MUTUAL_AUTH* = 0x00000002 + ISC_RET_REPLAY_DETECT* = 0x00000004 + ISC_RET_SEQUENCE_DETECT* = 0x00000008 + ISC_RET_CONFIDENTIALITY* = 0x00000010 + ISC_RET_USE_SESSION_KEY* = 0x00000020 + ISC_RET_USED_COLLECTED_CREDS* = 0x00000040 + ISC_RET_USED_SUPPLIED_CREDS* = 0x00000080 + ISC_RET_ALLOCATED_MEMORY* = 0x00000100 + ISC_RET_USED_DCE_STYLE* = 0x00000200 + ISC_RET_DATAGRAM* = 0x00000400 + ISC_RET_CONNECTION* = 0x00000800 + ISC_RET_INTERMEDIATE_RETURN* = 0x00001000 + ISC_RET_CALL_LEVEL* = 0x00002000 + ISC_RET_EXTENDED_ERROR* = 0x00004000 + ISC_RET_STREAM* = 0x00008000 + ISC_RET_INTEGRITY* = 0x00010000 + ISC_RET_IDENTIFY* = 0x00020000 + ISC_RET_NULL_SESSION* = 0x00040000 + ISC_RET_MANUAL_CRED_VALIDATION* = 0x00080000 + ISC_RET_RESERVED1* = 0x00100000 + ISC_RET_FRAGMENT_ONLY* = 0x00200000 + ASC_REQ_DELEGATE* = 0x00000001 + ASC_REQ_MUTUAL_AUTH* = 0x00000002 + ASC_REQ_REPLAY_DETECT* = 0x00000004 + ASC_REQ_SEQUENCE_DETECT* = 0x00000008 + ASC_REQ_CONFIDENTIALITY* = 0x00000010 + ASC_REQ_USE_SESSION_KEY* = 0x00000020 + ASC_REQ_ALLOCATE_MEMORY* = 0x00000100 + ASC_REQ_USE_DCE_STYLE* = 0x00000200 + ASC_REQ_DATAGRAM* = 0x00000400 + ASC_REQ_CONNECTION* = 0x00000800 + ASC_REQ_CALL_LEVEL* = 0x00001000 + ASC_REQ_EXTENDED_ERROR* = 0x00008000 + ASC_REQ_STREAM* = 0x00010000 + ASC_REQ_INTEGRITY* = 0x00020000 + ASC_REQ_LICENSING* = 0x00040000 + ASC_REQ_IDENTIFY* = 0x00080000 + ASC_REQ_ALLOW_NULL_SESSION* = 0x00100000 + ASC_REQ_ALLOW_NON_USER_LOGONS* = 0x00200000 + ASC_REQ_ALLOW_CONTEXT_REPLAY* = 0x00400000 + ASC_REQ_FRAGMENT_TO_FIT* = 0x00800000 + ASC_REQ_FRAGMENT_SUPPLIED* = 0x00002000 + ASC_REQ_NO_TOKEN* = 0x01000000 + ASC_RET_DELEGATE* = 0x00000001 + ASC_RET_MUTUAL_AUTH* = 0x00000002 + ASC_RET_REPLAY_DETECT* = 0x00000004 + ASC_RET_SEQUENCE_DETECT* = 0x00000008 + ASC_RET_CONFIDENTIALITY* = 0x00000010 + ASC_RET_USE_SESSION_KEY* = 0x00000020 + ASC_RET_ALLOCATED_MEMORY* = 0x00000100 + ASC_RET_USED_DCE_STYLE* = 0x00000200 + ASC_RET_DATAGRAM* = 0x00000400 + ASC_RET_CONNECTION* = 0x00000800 + ASC_RET_CALL_LEVEL* = 0x00002000 + ASC_RET_THIRD_LEG_FAILED* = 0x00004000 + ASC_RET_EXTENDED_ERROR* = 0x00008000 + ASC_RET_STREAM* = 0x00010000 + ASC_RET_INTEGRITY* = 0x00020000 + ASC_RET_LICENSING* = 0x00040000 + ASC_RET_IDENTIFY* = 0x00080000 + ASC_RET_NULL_SESSION* = 0x00100000 + ASC_RET_ALLOW_NON_USER_LOGONS* = 0x00200000 + ASC_RET_ALLOW_CONTEXT_REPLAY* = 0x00400000 + ASC_RET_FRAGMENT_ONLY* = 0x00800000 + ASC_RET_NO_TOKEN* = 0x01000000 + SECPKG_CRED_ATTR_NAMES* = 1 + SECPKG_CRED_ATTR_SSI_PROVIDER* = 2 + SECPKG_ATTR_SIZES* = 0 + SECPKG_ATTR_NAMES* = 1 + SECPKG_ATTR_LIFESPAN* = 2 + SECPKG_ATTR_DCE_INFO* = 3 + SECPKG_ATTR_STREAM_SIZES* = 4 + SECPKG_ATTR_KEY_INFO* = 5 + SECPKG_ATTR_AUTHORITY* = 6 + SECPKG_ATTR_PROTO_INFO* = 7 + SECPKG_ATTR_PASSWORD_EXPIRY* = 8 + SECPKG_ATTR_SESSION_KEY* = 9 + SECPKG_ATTR_PACKAGE_INFO* = 10 + SECPKG_ATTR_USER_FLAGS* = 11 + SECPKG_ATTR_NEGOTIATION_INFO* = 12 + SECPKG_ATTR_NATIVE_NAMES* = 13 + SECPKG_ATTR_FLAGS* = 14 + SECPKG_ATTR_USE_VALIDATED* = 15 + SECPKG_ATTR_CREDENTIAL_NAME* = 16 + SECPKG_ATTR_TARGET_INFORMATION* = 17 + SECPKG_ATTR_ACCESS_TOKEN* = 18 + SECPKG_ATTR_TARGET* = 19 + SECPKG_ATTR_AUTHENTICATION_ID* = 20 + SECPKG_ATTR_LOGOFF_TIME* = 21 + SECPKG_NEGOTIATION_COMPLETE* = 0 + SECPKG_NEGOTIATION_OPTIMISTIC* = 1 + SECPKG_NEGOTIATION_IN_PROGRESS* = 2 + SECPKG_NEGOTIATION_DIRECT* = 3 + SECPKG_NEGOTIATION_TRY_MULTICRED* = 4 + SECPKG_CONTEXT_EXPORT_RESET_NEW* = 0x00000001 + SECPKG_CONTEXT_EXPORT_DELETE_OLD* = 0x00000002 + SECPKG_CONTEXT_EXPORT_TO_KERNEL* = 0x00000004 + SECQOP_WRAP_NO_ENCRYPT* = 0x80000001'i32 + SECQOP_WRAP_OOB_DATA* = 0x40000000 + secFull* = 0 + secService* = 1 + secTree* = 2 + secDirectory* = 3 + secObject* = 4 + SECURITY_ENTRYPOINT_ANSIW* = "InitSecurityInterfaceW" + SECURITY_ENTRYPOINT_ANSIA* = "InitSecurityInterfaceA" + SECURITY_ENTRYPOINTW* = "InitSecurityInterfaceW" + SECURITY_ENTRYPOINTA* = "InitSecurityInterfaceA" + SECURITY_ENTRYPOINT16* = "INITSECURITYINTERFACEA" + SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION* = 1 + SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_2* = 2 + SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_3* = 3 + SASL_OPTION_SEND_SIZE* = 1 + SASL_OPTION_RECV_SIZE* = 2 + SASL_OPTION_AUTHZ_STRING* = 3 + SASL_OPTION_AUTHZ_PROCESSING* = 4 + Sasl_AuthZIDForbidden* = 0 + Sasl_AuthZIDProcessed* = 1 + SEC_WINNT_AUTH_IDENTITY_ANSI* = 0x1 + SEC_WINNT_AUTH_IDENTITY_UNICODE* = 0x2 + SEC_WINNT_AUTH_IDENTITY_VERSION* = 0x200 + SEC_WINNT_AUTH_IDENTITY_MARSHALLED* = 0x4 + SEC_WINNT_AUTH_IDENTITY_ONLY* = 0x8 + SECPKG_OPTIONS_TYPE_UNKNOWN* = 0 + SECPKG_OPTIONS_TYPE_LSA* = 1 + SECPKG_OPTIONS_TYPE_SSPI* = 2 + SECPKG_OPTIONS_PERMANENT* = 0x00000001 + nameUnknown* = 0 + nameFullyQualifiedDN* = 1 + nameSamCompatible* = 2 + nameDisplay* = 3 + nameUniqueId* = 6 + nameCanonical* = 7 + nameUserPrincipal* = 8 + nameCanonicalEx* = 9 + nameServicePrincipal* = 10 + nameDnsDomain* = 12 + nameGivenName* = 13 + nameSurname* = 14 + MSV1_0_NTLM3_INPUT_LENGTH* = 0x00000020 + MSV1_0_NTLM3_MIN_NT_RESPONSE_LENGTH* = 0x0000002C + MICROSOFT_KERBEROS_NAME* = "Kerberos" + MSV1_0_PACKAGE_NAMEW_LENGTH* = (len(MSV1_0_PACKAGE_NAMEW)+1)-sizeof(WCHAR) +type + PSAM_PASSWORD_NOTIFICATION_ROUTINE* = proc (UserName: PUNICODE_STRING, RelativeId: ULONG, NewPassword: PUNICODE_STRING): NTSTATUS {.stdcall.} + PSAM_INIT_NOTIFICATION_ROUTINE* = proc (): BOOLEAN {.stdcall.} + PSAM_PASSWORD_FILTER_ROUTINE* = proc (AccountName: PUNICODE_STRING, FullName: PUNICODE_STRING, Password: PUNICODE_STRING, SetOperation: BOOLEAN): BOOLEAN {.stdcall.} +proc LsaRegisterLogonProcess*(LogonProcessName: PLSA_STRING, LsaHandle: PHANDLE, SecurityMode: PLSA_OPERATIONAL_MODE): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaLogonUser*(LsaHandle: HANDLE, OriginName: PLSA_STRING, LogonType: SECURITY_LOGON_TYPE, AuthenticationPackage: ULONG, AuthenticationInformation: PVOID, AuthenticationInformationLength: ULONG, LocalGroups: PTOKEN_GROUPS, SourceContext: PTOKEN_SOURCE, ProfileBuffer: ptr PVOID, ProfileBufferLength: PULONG, LogonId: PLUID, Token: PHANDLE, Quotas: PQUOTA_LIMITS, SubStatus: PNTSTATUS): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaLookupAuthenticationPackage*(LsaHandle: HANDLE, PackageName: PLSA_STRING, AuthenticationPackage: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaFreeReturnBuffer*(Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaCallAuthenticationPackage*(LsaHandle: HANDLE, AuthenticationPackage: ULONG, ProtocolSubmitBuffer: PVOID, SubmitBufferLength: ULONG, ProtocolReturnBuffer: ptr PVOID, ReturnBufferLength: PULONG, ProtocolStatus: PNTSTATUS): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaDeregisterLogonProcess*(LsaHandle: HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaConnectUntrusted*(LsaHandle: PHANDLE): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaFreeMemory*(Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaClose*(ObjectHandle: LSA_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaEnumerateLogonSessions*(LogonSessionCount: PULONG, LogonSessionList: ptr PLUID): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaGetLogonSessionData*(LogonId: PLUID, ppLogonSessionData: ptr PSECURITY_LOGON_SESSION_DATA): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaOpenPolicy*(SystemName: PLSA_UNICODE_STRING, ObjectAttributes: PLSA_OBJECT_ATTRIBUTES, DesiredAccess: ACCESS_MASK, PolicyHandle: PLSA_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaQueryInformationPolicy*(PolicyHandle: LSA_HANDLE, InformationClass: POLICY_INFORMATION_CLASS, Buffer: ptr PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaSetInformationPolicy*(PolicyHandle: LSA_HANDLE, InformationClass: POLICY_INFORMATION_CLASS, Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaQueryDomainInformationPolicy*(PolicyHandle: LSA_HANDLE, InformationClass: POLICY_DOMAIN_INFORMATION_CLASS, Buffer: ptr PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaSetDomainInformationPolicy*(PolicyHandle: LSA_HANDLE, InformationClass: POLICY_DOMAIN_INFORMATION_CLASS, Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaRegisterPolicyChangeNotification*(InformationClass: POLICY_NOTIFICATION_INFORMATION_CLASS, NotificationEventHandle: HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaUnregisterPolicyChangeNotification*(InformationClass: POLICY_NOTIFICATION_INFORMATION_CLASS, NotificationEventHandle: HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc LsaEnumerateTrustedDomains*(PolicyHandle: LSA_HANDLE, EnumerationContext: PLSA_ENUMERATION_HANDLE, Buffer: ptr PVOID, PreferedMaximumLength: ULONG, CountReturned: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaLookupNames*(PolicyHandle: LSA_HANDLE, Count: ULONG, Names: PLSA_UNICODE_STRING, ReferencedDomains: ptr PLSA_REFERENCED_DOMAIN_LIST, Sids: ptr PLSA_TRANSLATED_SID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaLookupNames2*(PolicyHandle: LSA_HANDLE, Flags: ULONG, Count: ULONG, Names: PLSA_UNICODE_STRING, ReferencedDomains: ptr PLSA_REFERENCED_DOMAIN_LIST, Sids: ptr PLSA_TRANSLATED_SID2): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaLookupSids*(PolicyHandle: LSA_HANDLE, Count: ULONG, Sids: ptr PSID, ReferencedDomains: ptr PLSA_REFERENCED_DOMAIN_LIST, Names: ptr PLSA_TRANSLATED_NAME): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaEnumerateAccountsWithUserRight*(PolicyHandle: LSA_HANDLE, UserRight: PLSA_UNICODE_STRING, Buffer: ptr PVOID, CountReturned: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaEnumerateAccountRights*(PolicyHandle: LSA_HANDLE, AccountSid: PSID, UserRights: ptr PLSA_UNICODE_STRING, CountOfRights: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaAddAccountRights*(PolicyHandle: LSA_HANDLE, AccountSid: PSID, UserRights: PLSA_UNICODE_STRING, CountOfRights: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaRemoveAccountRights*(PolicyHandle: LSA_HANDLE, AccountSid: PSID, AllRights: BOOLEAN, UserRights: PLSA_UNICODE_STRING, CountOfRights: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaOpenTrustedDomainByName*(PolicyHandle: LSA_HANDLE, TrustedDomainName: PLSA_UNICODE_STRING, DesiredAccess: ACCESS_MASK, TrustedDomainHandle: PLSA_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaQueryTrustedDomainInfo*(PolicyHandle: LSA_HANDLE, TrustedDomainSid: PSID, InformationClass: TRUSTED_INFORMATION_CLASS, Buffer: ptr PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaSetTrustedDomainInformation*(PolicyHandle: LSA_HANDLE, TrustedDomainSid: PSID, InformationClass: TRUSTED_INFORMATION_CLASS, Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaDeleteTrustedDomain*(PolicyHandle: LSA_HANDLE, TrustedDomainSid: PSID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaQueryTrustedDomainInfoByName*(PolicyHandle: LSA_HANDLE, TrustedDomainName: PLSA_UNICODE_STRING, InformationClass: TRUSTED_INFORMATION_CLASS, Buffer: ptr PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaSetTrustedDomainInfoByName*(PolicyHandle: LSA_HANDLE, TrustedDomainName: PLSA_UNICODE_STRING, InformationClass: TRUSTED_INFORMATION_CLASS, Buffer: PVOID): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaEnumerateTrustedDomainsEx*(PolicyHandle: LSA_HANDLE, EnumerationContext: PLSA_ENUMERATION_HANDLE, Buffer: ptr PVOID, PreferedMaximumLength: ULONG, CountReturned: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaCreateTrustedDomainEx*(PolicyHandle: LSA_HANDLE, TrustedDomainInformation: PTRUSTED_DOMAIN_INFORMATION_EX, AuthenticationInformation: PTRUSTED_DOMAIN_AUTH_INFORMATION, DesiredAccess: ACCESS_MASK, TrustedDomainHandle: PLSA_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaQueryForestTrustInformation*(PolicyHandle: LSA_HANDLE, TrustedDomainName: PLSA_UNICODE_STRING, ForestTrustInfo: ptr PLSA_FOREST_TRUST_INFORMATION): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaSetForestTrustInformation*(PolicyHandle: LSA_HANDLE, TrustedDomainName: PLSA_UNICODE_STRING, ForestTrustInfo: PLSA_FOREST_TRUST_INFORMATION, CheckOnly: BOOLEAN, CollisionInfo: ptr PLSA_FOREST_TRUST_COLLISION_INFORMATION): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaStorePrivateData*(PolicyHandle: LSA_HANDLE, KeyName: PLSA_UNICODE_STRING, PrivateData: PLSA_UNICODE_STRING): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaRetrievePrivateData*(PolicyHandle: LSA_HANDLE, KeyName: PLSA_UNICODE_STRING, PrivateData: ptr PLSA_UNICODE_STRING): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LsaNtStatusToWinError*(Status: NTSTATUS): ULONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SystemFunction036*(RandomBuffer: PVOID, RandomBufferLength: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SystemFunction040*(Memory: PVOID, MemorySize: ULONG, OptionFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SystemFunction041*(Memory: PVOID, MemorySize: ULONG, OptionFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditComputeEffectivePolicyBySid*(pSid: PSID, pSubCategoryGuids: ptr GUID, PolicyCount: ULONG, ppAuditPolicy: ptr PAUDIT_POLICY_INFORMATION): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditFree*(Buffer: PVOID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditSetSystemPolicy*(pAuditPolicy: PCAUDIT_POLICY_INFORMATION, PolicyCount: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditQuerySystemPolicy*(pSubCategoryGuids: ptr GUID, PolicyCount: ULONG, ppAuditPolicy: ptr PAUDIT_POLICY_INFORMATION): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditSetPerUserPolicy*(pSid: PSID, pAuditPolicy: PCAUDIT_POLICY_INFORMATION, PolicyCount: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditQueryPerUserPolicy*(pSid: PSID, pSubCategoryGuids: ptr GUID, PolicyCount: ULONG, ppAuditPolicy: ptr PAUDIT_POLICY_INFORMATION): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditComputeEffectivePolicyByToken*(hTokenHandle: HANDLE, pSubCategoryGuids: ptr GUID, PolicyCount: ULONG, ppAuditPolicy: ptr PAUDIT_POLICY_INFORMATION): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditEnumerateCategories*(ppAuditCategoriesArray: ptr ptr GUID, pCountReturned: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditEnumeratePerUserPolicy*(ppAuditSidArray: ptr PPOLICY_AUDIT_SID_ARRAY): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditEnumerateSubCategories*(pAuditCategoryGuid: ptr GUID, bRetrieveAllSubCategories: BOOLEAN, ppAuditSubCategoriesArray: ptr ptr GUID, pCountReturned: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupCategoryGuidFromCategoryId*(AuditCategoryId: POLICY_AUDIT_EVENT_TYPE, pAuditCategoryGuid: ptr GUID): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditQuerySecurity*(SecurityInformation: SECURITY_INFORMATION, ppSecurityDescriptor: ptr PSECURITY_DESCRIPTOR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupSubCategoryNameA*(pAuditSubCategoryGuid: ptr GUID, ppszSubCategoryName: ptr LPSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupSubCategoryNameW*(pAuditSubCategoryGuid: ptr GUID, ppszSubCategoryName: ptr LPWSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupCategoryNameA*(pAuditCategoryGuid: ptr GUID, ppszCategoryName: ptr LPSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupCategoryNameW*(pAuditCategoryGuid: ptr GUID, ppszCategoryName: ptr LPWSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditLookupCategoryIdFromCategoryGuid*(pAuditCategoryGuid: ptr GUID, pAuditCategoryId: PPOLICY_AUDIT_EVENT_TYPE): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AuditSetSecurity*(SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AcquireCredentialsHandleW*(pszPrincipal: ptr SEC_WCHAR, pszPackage: ptr SEC_WCHAR, fCredentialUse: int32, pvLogonId: pointer, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, phCredential: PCredHandle, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AcquireCredentialsHandleA*(pszPrincipal: ptr SEC_CHAR, pszPackage: ptr SEC_CHAR, fCredentialUse: int32, pvLogonId: pointer, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, phCredential: PCredHandle, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc FreeCredentialsHandle*(phCredential: PCredHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AddCredentialsW*(hCredentials: PCredHandle, pszPrincipal: ptr SEC_WCHAR, pszPackage: ptr SEC_WCHAR, fCredentialUse: int32, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AddCredentialsA*(hCredentials: PCredHandle, pszPrincipal: ptr SEC_CHAR, pszPackage: ptr SEC_CHAR, fCredentialUse: int32, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc InitializeSecurityContextW*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: ptr SEC_WCHAR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc InitializeSecurityContextA*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: ptr SEC_CHAR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AcceptSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pInput: PSecBufferDesc, fContextReq: int32, TargetDataRep: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc CompleteAuthToken*(phContext: PCtxtHandle, pToken: PSecBufferDesc): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc ImpersonateSecurityContext*(phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc RevertSecurityContext*(phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QuerySecurityContextToken*(phContext: PCtxtHandle, Token: ptr HANDLE): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc DeleteSecurityContext*(phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc ApplyControlToken*(phContext: PCtxtHandle, pInput: PSecBufferDesc): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QueryContextAttributesW*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QueryContextAttributesA*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SetContextAttributesW*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SetContextAttributesA*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QueryCredentialsAttributesW*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QueryCredentialsAttributesA*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SetCredentialsAttributesW*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SetCredentialsAttributesA*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc FreeContextBuffer*(pvContextBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc MakeSignature*(phContext: PCtxtHandle, fQOP: int32, pMessage: PSecBufferDesc, MessageSeqNo: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc VerifySignature*(phContext: PCtxtHandle, pMessage: PSecBufferDesc, MessageSeqNo: int32, pfQOP: ptr int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc EncryptMessage*(phContext: PCtxtHandle, fQOP: int32, pMessage: PSecBufferDesc, MessageSeqNo: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc DecryptMessage*(phContext: PCtxtHandle, pMessage: PSecBufferDesc, MessageSeqNo: int32, pfQOP: ptr int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc EnumerateSecurityPackagesW*(pcPackages: ptr int32, ppPackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "sspicli", importc.} +proc EnumerateSecurityPackagesA*(pcPackages: ptr int32, ppPackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "sspicli", importc.} +proc QuerySecurityPackageInfoW*(pszPackageName: ptr SEC_WCHAR, ppPackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc QuerySecurityPackageInfoA*(pszPackageName: ptr SEC_CHAR, ppPackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc ExportSecurityContext*(phContext: PCtxtHandle, fFlags: ULONG, pPackedContext: PSecBuffer, pToken: ptr pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc ImportSecurityContextW*(pszPackage: ptr SEC_WCHAR, pPackedContext: PSecBuffer, Token: pointer, phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc ImportSecurityContextA*(pszPackage: ptr SEC_CHAR, pPackedContext: PSecBuffer, Token: pointer, phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc FreeCredentialHandle*(phCredential: PCredHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "FreeCredentialsHandle".} +proc InitSecurityInterfaceA*(): PSecurityFunctionTableA {.winapi, stdcall, dynlib: "secur32", importc.} +proc InitSecurityInterfaceW*(): PSecurityFunctionTableW {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslEnumerateProfilesA*(ProfileList: ptr LPSTR, ProfileCount: ptr ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslEnumerateProfilesW*(ProfileList: ptr LPWSTR, ProfileCount: ptr ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslGetProfilePackageA*(ProfileName: LPSTR, PackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslGetProfilePackageW*(ProfileName: LPWSTR, PackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslIdentifyPackageA*(pInput: PSecBufferDesc, PackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslIdentifyPackageW*(pInput: PSecBufferDesc, PackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslInitializeSecurityContextW*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: LPWSTR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslInitializeSecurityContextA*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: LPSTR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslAcceptSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pInput: PSecBufferDesc, fContextReq: int32, TargetDataRep: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslSetContextOption*(ContextHandle: PCtxtHandle, Option: ULONG, Value: PVOID, Size: ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc SaslGetContextOption*(ContextHandle: PCtxtHandle, Option: ULONG, Value: PVOID, Size: ULONG, Needed: PULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AddSecurityPackageA*(pszPackageName: LPSTR, pOptions: PSECURITY_PACKAGE_OPTIONS): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc AddSecurityPackageW*(pszPackageName: LPWSTR, pOptions: PSECURITY_PACKAGE_OPTIONS): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc DeleteSecurityPackageA*(pszPackageName: ptr SEC_CHAR): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc DeleteSecurityPackageW*(pszPackageName: ptr SEC_WCHAR): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc.} +proc GetUserNameExA*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc GetUserNameExW*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc GetComputerObjectNameA*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc GetComputerObjectNameW*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc TranslateNameA*(lpAccountName: LPCSTR, AccountNameFormat: EXTENDED_NAME_FORMAT, DesiredNameFormat: EXTENDED_NAME_FORMAT, lpTranslatedName: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc TranslateNameW*(lpAccountName: LPCWSTR, AccountNameFormat: EXTENDED_NAME_FORMAT, DesiredNameFormat: EXTENDED_NAME_FORMAT, lpTranslatedName: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc.} +proc RtlGenRandom*(RandomBuffer: PVOID, RandomBufferLength: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc: "SystemFunction036".} +proc RtlEncryptMemory*(Memory: PVOID, MemorySize: ULONG, OptionFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc: "SystemFunction040".} +proc RtlDecryptMemory*(Memory: PVOID, MemorySize: ULONG, OptionFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "advapi32", importc: "SystemFunction041".} +proc `ContextInformation=`*(self: var KERB_SMARTCARD_CSP_INFO, x: PVOID) {.inline.} = self.union1.ContextInformation = x +proc ContextInformation*(self: KERB_SMARTCARD_CSP_INFO): PVOID {.inline.} = self.union1.ContextInformation +proc ContextInformation*(self: var KERB_SMARTCARD_CSP_INFO): var PVOID {.inline.} = self.union1.ContextInformation +proc `SpaceHolderForWow64=`*(self: var KERB_SMARTCARD_CSP_INFO, x: ULONG64) {.inline.} = self.union1.SpaceHolderForWow64 = x +proc SpaceHolderForWow64*(self: KERB_SMARTCARD_CSP_INFO): ULONG64 {.inline.} = self.union1.SpaceHolderForWow64 +proc SpaceHolderForWow64*(self: var KERB_SMARTCARD_CSP_INFO): var ULONG64 {.inline.} = self.union1.SpaceHolderForWow64 +when winimUnicode: + type + SECURITY_PSTR* = ptr SEC_WCHAR + SECURITY_PCSTR* = ptr SEC_WCHAR + SecPkgInfo* = SecPkgInfoW + PSecPkgInfo* = PSecPkgInfoW + SecPkgCredentials_Names* = SecPkgCredentials_NamesW + PSecPkgCredentials_Names* = PSecPkgCredentials_NamesW + SecPkgCredentials_SSIProvider* = SecPkgCredentials_SSIProviderW + PSecPkgCredentials_SSIProvider* = PSecPkgCredentials_SSIProviderW + SecPkgContext_Names* = SecPkgContext_NamesW + PSecPkgContext_Names* = PSecPkgContext_NamesW + SecPkgContext_KeyInfo* = SecPkgContext_KeyInfoW + PSecPkgContext_KeyInfo* = PSecPkgContext_KeyInfoW + SecPkgContext_Authority* = SecPkgContext_AuthorityW + PSecPkgContext_Authority* = PSecPkgContext_AuthorityW + SecPkgContext_ProtoInfo* = SecPkgContext_ProtoInfoW + PSecPkgContext_ProtoInfo* = PSecPkgContext_ProtoInfoW + SecPkgContext_PackageInfo* = SecPkgContext_PackageInfoW + PSecPkgContext_PackageInfo* = PSecPkgContext_PackageInfoW + SecPkgContext_NegotiationInfo* = SecPkgContext_NegotiationInfoW + PSecPkgContext_NegotiationInfo* = PSecPkgContext_NegotiationInfoW + SecPkgContext_NativeNames* = SecPkgContext_NativeNamesW + PSecPkgContext_NativeNames* = PSecPkgContext_NativeNamesW + SecPkgContext_CredentialName* = SecPkgContext_CredentialNameW + PSecPkgContext_CredentialName* = PSecPkgContext_CredentialNameW + ACQUIRE_CREDENTIALS_HANDLE_FN* = ACQUIRE_CREDENTIALS_HANDLE_FN_W + ADD_CREDENTIALS_FN* = ADD_CREDENTIALS_FN_W + INITIALIZE_SECURITY_CONTEXT_FN* = INITIALIZE_SECURITY_CONTEXT_FN_W + QUERY_CONTEXT_ATTRIBUTES_FN* = QUERY_CONTEXT_ATTRIBUTES_FN_W + SET_CONTEXT_ATTRIBUTES_FN* = SET_CONTEXT_ATTRIBUTES_FN_W + QUERY_CREDENTIALS_ATTRIBUTES_FN* = QUERY_CREDENTIALS_ATTRIBUTES_FN_W + SET_CREDENTIALS_ATTRIBUTES_FN* = SET_CREDENTIALS_ATTRIBUTES_FN_W + ENUMERATE_SECURITY_PACKAGES_FN* = ENUMERATE_SECURITY_PACKAGES_FN_W + QUERY_SECURITY_PACKAGE_INFO_FN* = QUERY_SECURITY_PACKAGE_INFO_FN_W + IMPORT_SECURITY_CONTEXT_FN* = IMPORT_SECURITY_CONTEXT_FN_W + SecurityFunctionTable* = SecurityFunctionTableW + PSecurityFunctionTable* = PSecurityFunctionTableW + SEC_WINNT_AUTH_IDENTITY* = SEC_WINNT_AUTH_IDENTITY_W + PSEC_WINNT_AUTH_IDENTITY* = PSEC_WINNT_AUTH_IDENTITY_W + SEC_WINNT_AUTH_IDENTITY_EX* = SEC_WINNT_AUTH_IDENTITY_EXW + PSEC_WINNT_AUTH_IDENTITY_EX* = PSEC_WINNT_AUTH_IDENTITY_EXW + const + NEGOSSP_NAME* = NEGOSSP_NAME_W + SECURITY_ENTRYPOINT* = SECURITY_ENTRYPOINTW + SECURITY_ENTRYPOINT_ANSI* = SECURITY_ENTRYPOINT_ANSIW + proc AuditLookupSubCategoryName*(pAuditSubCategoryGuid: ptr GUID, ppszSubCategoryName: ptr LPWSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc: "AuditLookupSubCategoryNameW".} + proc AuditLookupCategoryName*(pAuditCategoryGuid: ptr GUID, ppszCategoryName: ptr LPWSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc: "AuditLookupCategoryNameW".} + proc AcquireCredentialsHandle*(pszPrincipal: ptr SEC_WCHAR, pszPackage: ptr SEC_WCHAR, fCredentialUse: int32, pvLogonId: pointer, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, phCredential: PCredHandle, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AcquireCredentialsHandleW".} + proc AddCredentials*(hCredentials: PCredHandle, pszPrincipal: ptr SEC_WCHAR, pszPackage: ptr SEC_WCHAR, fCredentialUse: int32, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AddCredentialsW".} + proc InitializeSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: ptr SEC_WCHAR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "InitializeSecurityContextW".} + proc QueryContextAttributes*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QueryContextAttributesW".} + proc SetContextAttributes*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SetContextAttributesW".} + proc QueryCredentialsAttributes*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QueryCredentialsAttributesW".} + proc SetCredentialsAttributes*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SetCredentialsAttributesW".} + proc EnumerateSecurityPackages*(pcPackages: ptr int32, ppPackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "sspicli", importc: "EnumerateSecurityPackagesW".} + proc QuerySecurityPackageInfo*(pszPackageName: ptr SEC_WCHAR, ppPackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QuerySecurityPackageInfoW".} + proc ImportSecurityContext*(pszPackage: ptr SEC_WCHAR, pPackedContext: PSecBuffer, Token: pointer, phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "ImportSecurityContextW".} + proc InitSecurityInterface*(): PSecurityFunctionTableW {.winapi, stdcall, dynlib: "secur32", importc: "InitSecurityInterfaceW".} + proc SaslEnumerateProfiles*(ProfileList: ptr LPWSTR, ProfileCount: ptr ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslEnumerateProfilesW".} + proc SaslGetProfilePackage*(ProfileName: LPWSTR, PackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslGetProfilePackageW".} + proc SaslIdentifyPackage*(pInput: PSecBufferDesc, PackageInfo: ptr PSecPkgInfoW): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslIdentifyPackageW".} + proc SaslInitializeSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: LPWSTR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslInitializeSecurityContextW".} + proc AddSecurityPackage*(pszPackageName: LPWSTR, pOptions: PSECURITY_PACKAGE_OPTIONS): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AddSecurityPackageW".} + proc DeleteSecurityPackage*(pszPackageName: ptr SEC_WCHAR): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "DeleteSecurityPackageW".} + proc GetUserNameEx*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "GetUserNameExW".} + proc GetComputerObjectName*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "GetComputerObjectNameW".} + proc TranslateName*(lpAccountName: LPCWSTR, AccountNameFormat: EXTENDED_NAME_FORMAT, DesiredNameFormat: EXTENDED_NAME_FORMAT, lpTranslatedName: LPWSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "TranslateNameW".} +when winimAnsi: + type + SECURITY_PSTR* = ptr SEC_CHAR + SECURITY_PCSTR* = ptr SEC_CHAR + SecPkgInfo* = SecPkgInfoA + PSecPkgInfo* = PSecPkgInfoA + SecPkgCredentials_Names* = SecPkgCredentials_NamesA + PSecPkgCredentials_Names* = PSecPkgCredentials_NamesA + SecPkgCredentials_SSIProvider* = SecPkgCredentials_SSIProviderA + PSecPkgCredentials_SSIProvider* = PSecPkgCredentials_SSIProviderA + SecPkgContext_Names* = SecPkgContext_NamesA + PSecPkgContext_Names* = PSecPkgContext_NamesA + SecPkgContext_KeyInfo* = SecPkgContext_KeyInfoA + PSecPkgContext_KeyInfo* = PSecPkgContext_KeyInfoA + SecPkgContext_Authority* = SecPkgContext_AuthorityA + PSecPkgContext_Authority* = PSecPkgContext_AuthorityA + SecPkgContext_ProtoInfo* = SecPkgContext_ProtoInfoA + PSecPkgContext_ProtoInfo* = PSecPkgContext_ProtoInfoA + SecPkgContext_PackageInfo* = SecPkgContext_PackageInfoA + PSecPkgContext_PackageInfo* = PSecPkgContext_PackageInfoA + SecPkgContext_NegotiationInfo* = SecPkgContext_NegotiationInfoA + PSecPkgContext_NegotiationInfo* = PSecPkgContext_NegotiationInfoA + SecPkgContext_NativeNames* = SecPkgContext_NativeNamesA + PSecPkgContext_NativeNames* = PSecPkgContext_NativeNamesA + SecPkgContext_CredentialName* = SecPkgContext_CredentialNameA + PSecPkgContext_CredentialName* = PSecPkgContext_CredentialNameA + ACQUIRE_CREDENTIALS_HANDLE_FN* = ACQUIRE_CREDENTIALS_HANDLE_FN_A + ADD_CREDENTIALS_FN* = ADD_CREDENTIALS_FN_A + INITIALIZE_SECURITY_CONTEXT_FN* = INITIALIZE_SECURITY_CONTEXT_FN_A + QUERY_CONTEXT_ATTRIBUTES_FN* = QUERY_CONTEXT_ATTRIBUTES_FN_A + SET_CONTEXT_ATTRIBUTES_FN* = SET_CONTEXT_ATTRIBUTES_FN_A + QUERY_CREDENTIALS_ATTRIBUTES_FN* = QUERY_CREDENTIALS_ATTRIBUTES_FN_A + SET_CREDENTIALS_ATTRIBUTES_FN* = SET_CREDENTIALS_ATTRIBUTES_FN_A + ENUMERATE_SECURITY_PACKAGES_FN* = ENUMERATE_SECURITY_PACKAGES_FN_A + QUERY_SECURITY_PACKAGE_INFO_FN* = QUERY_SECURITY_PACKAGE_INFO_FN_A + IMPORT_SECURITY_CONTEXT_FN* = IMPORT_SECURITY_CONTEXT_FN_A + SecurityFunctionTable* = SecurityFunctionTableA + PSecurityFunctionTable* = PSecurityFunctionTableA + SEC_WINNT_AUTH_IDENTITY* = SEC_WINNT_AUTH_IDENTITY_A + PSEC_WINNT_AUTH_IDENTITY* = PSEC_WINNT_AUTH_IDENTITY_A + SEC_WINNT_AUTH_IDENTITY_EX* = SEC_WINNT_AUTH_IDENTITY_EXA + PSEC_WINNT_AUTH_IDENTITY_EX* = PSEC_WINNT_AUTH_IDENTITY_EXA + const + NEGOSSP_NAME* = NEGOSSP_NAME_A + SECURITY_ENTRYPOINT* = SECURITY_ENTRYPOINTA + SECURITY_ENTRYPOINT_ANSI* = SECURITY_ENTRYPOINT_ANSIA + proc AuditLookupSubCategoryName*(pAuditSubCategoryGuid: ptr GUID, ppszSubCategoryName: ptr LPSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc: "AuditLookupSubCategoryNameA".} + proc AuditLookupCategoryName*(pAuditCategoryGuid: ptr GUID, ppszCategoryName: ptr LPSTR): BOOLEAN {.winapi, stdcall, dynlib: "advapi32", importc: "AuditLookupCategoryNameA".} + proc AcquireCredentialsHandle*(pszPrincipal: ptr SEC_CHAR, pszPackage: ptr SEC_CHAR, fCredentialUse: int32, pvLogonId: pointer, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, phCredential: PCredHandle, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AcquireCredentialsHandleA".} + proc AddCredentials*(hCredentials: PCredHandle, pszPrincipal: ptr SEC_CHAR, pszPackage: ptr SEC_CHAR, fCredentialUse: int32, pAuthData: pointer, pGetKeyFn: SEC_GET_KEY_FN, pvGetKeyArgument: pointer, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AddCredentialsA".} + proc InitializeSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: ptr SEC_CHAR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "InitializeSecurityContextA".} + proc QueryContextAttributes*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QueryContextAttributesA".} + proc SetContextAttributes*(phContext: PCtxtHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SetContextAttributesA".} + proc QueryCredentialsAttributes*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QueryCredentialsAttributesA".} + proc SetCredentialsAttributes*(phCredential: PCredHandle, ulAttribute: int32, pBuffer: pointer, cbBuffer: int32): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SetCredentialsAttributesA".} + proc EnumerateSecurityPackages*(pcPackages: ptr int32, ppPackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "sspicli", importc: "EnumerateSecurityPackagesA".} + proc QuerySecurityPackageInfo*(pszPackageName: ptr SEC_CHAR, ppPackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "QuerySecurityPackageInfoA".} + proc ImportSecurityContext*(pszPackage: ptr SEC_CHAR, pPackedContext: PSecBuffer, Token: pointer, phContext: PCtxtHandle): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "ImportSecurityContextA".} + proc InitSecurityInterface*(): PSecurityFunctionTableA {.winapi, stdcall, dynlib: "secur32", importc: "InitSecurityInterfaceA".} + proc SaslEnumerateProfiles*(ProfileList: ptr LPSTR, ProfileCount: ptr ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslEnumerateProfilesA".} + proc SaslGetProfilePackage*(ProfileName: LPSTR, PackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslGetProfilePackageA".} + proc SaslIdentifyPackage*(pInput: PSecBufferDesc, PackageInfo: ptr PSecPkgInfoA): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslIdentifyPackageA".} + proc SaslInitializeSecurityContext*(phCredential: PCredHandle, phContext: PCtxtHandle, pszTargetName: LPSTR, fContextReq: int32, Reserved1: int32, TargetDataRep: int32, pInput: PSecBufferDesc, Reserved2: int32, phNewContext: PCtxtHandle, pOutput: PSecBufferDesc, pfContextAttr: ptr int32, ptsExpiry: PTimeStamp): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "SaslInitializeSecurityContextA".} + proc AddSecurityPackage*(pszPackageName: LPSTR, pOptions: PSECURITY_PACKAGE_OPTIONS): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "AddSecurityPackageA".} + proc DeleteSecurityPackage*(pszPackageName: ptr SEC_CHAR): SECURITY_STATUS {.winapi, stdcall, dynlib: "secur32", importc: "DeleteSecurityPackageA".} + proc GetUserNameEx*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "GetUserNameExA".} + proc GetComputerObjectName*(NameFormat: EXTENDED_NAME_FORMAT, lpNameBuffer: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "GetComputerObjectNameA".} + proc TranslateName*(lpAccountName: LPCSTR, AccountNameFormat: EXTENDED_NAME_FORMAT, DesiredNameFormat: EXTENDED_NAME_FORMAT, lpTranslatedName: LPSTR, nSize: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "secur32", importc: "TranslateNameA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/setupapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/setupapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1914 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winreg +import commctrl +#include +type + SetupFileLogInfo* = int32 + HINF* = PVOID + HSPFILEQ* = PVOID + HDSKSPC* = PVOID + HDEVINFO* = PVOID + HSPFILELOG* = PVOID + LogSeverity* = DWORD + INFCONTEXT* {.pure.} = object + Inf*: PVOID + CurrentInf*: PVOID + Section*: UINT + Line*: UINT + PINFCONTEXT* = ptr INFCONTEXT +when winimCpu64: + type + SP_INF_INFORMATION* {.pure.} = object + InfStyle*: DWORD + InfCount*: DWORD + VersionData*: array[ANYSIZE_ARRAY, BYTE] +when winimCpu32: + type + SP_INF_INFORMATION* {.pure, packed.} = object + InfStyle*: DWORD + InfCount*: DWORD + VersionData*: array[ANYSIZE_ARRAY, BYTE] +type + PSP_INF_INFORMATION* = ptr SP_INF_INFORMATION + SP_ALTPLATFORM_INFO_V2_UNION1* {.pure, union.} = object + Reserved*: WORD + Flags*: WORD + SP_ALTPLATFORM_INFO_V2* {.pure.} = object + cbSize*: DWORD + Platform*: DWORD + MajorVersion*: DWORD + MinorVersion*: DWORD + ProcessorArchitecture*: WORD + union1*: SP_ALTPLATFORM_INFO_V2_UNION1 + FirstValidatedMajorVersion*: DWORD + FirstValidatedMinorVersion*: DWORD + PSP_ALTPLATFORM_INFO_V2* = ptr SP_ALTPLATFORM_INFO_V2 + SP_ALTPLATFORM_INFO_V1* {.pure.} = object + cbSize*: DWORD + Platform*: DWORD + MajorVersion*: DWORD + MinorVersion*: DWORD + ProcessorArchitecture*: WORD + Reserved*: WORD + PSP_ALTPLATFORM_INFO_V1* = ptr SP_ALTPLATFORM_INFO_V1 + SP_ALTPLATFORM_INFO* = SP_ALTPLATFORM_INFO_V2 + PSP_ALTPLATFORM_INFO* = PSP_ALTPLATFORM_INFO_V2 + SP_ORIGINAL_FILE_INFO_A* {.pure.} = object + cbSize*: DWORD + OriginalInfName*: array[MAX_PATH, CHAR] + OriginalCatalogName*: array[MAX_PATH, CHAR] + PSP_ORIGINAL_FILE_INFO_A* = ptr SP_ORIGINAL_FILE_INFO_A + SP_ORIGINAL_FILE_INFO_W* {.pure.} = object + cbSize*: DWORD + OriginalInfName*: array[MAX_PATH, WCHAR] + OriginalCatalogName*: array[MAX_PATH, WCHAR] + PSP_ORIGINAL_FILE_INFO_W* = ptr SP_ORIGINAL_FILE_INFO_W + FILEPATHS_A* {.pure.} = object + Target*: PCSTR + Source*: PCSTR + Win32Error*: UINT + Flags*: DWORD + PFILEPATHS_A* = ptr FILEPATHS_A + FILEPATHS_W* {.pure.} = object + Target*: PCWSTR + Source*: PCWSTR + Win32Error*: UINT + Flags*: DWORD + PFILEPATHS_W* = ptr FILEPATHS_W + FILEPATHS_SIGNERINFO_A* {.pure.} = object + Target*: PCSTR + Source*: PCSTR + Win32Error*: UINT + Flags*: DWORD + DigitalSigner*: PCSTR + Version*: PCSTR + CatalogFile*: PCSTR + PFILEPATHS_SIGNERINFO_A* = ptr FILEPATHS_SIGNERINFO_A + FILEPATHS_SIGNERINFO_W* {.pure.} = object + Target*: PCWSTR + Source*: PCWSTR + Win32Error*: UINT + Flags*: DWORD + DigitalSigner*: PCWSTR + Version*: PCWSTR + CatalogFile*: PCWSTR + PFILEPATHS_SIGNERINFO_W* = ptr FILEPATHS_SIGNERINFO_W + SOURCE_MEDIA_A* {.pure.} = object + Reserved*: PCSTR + Tagfile*: PCSTR + Description*: PCSTR + SourcePath*: PCSTR + SourceFile*: PCSTR + Flags*: DWORD + PSOURCE_MEDIA_A* = ptr SOURCE_MEDIA_A + SOURCE_MEDIA_W* {.pure.} = object + Reserved*: PCWSTR + Tagfile*: PCWSTR + Description*: PCWSTR + SourcePath*: PCWSTR + SourceFile*: PCWSTR + Flags*: DWORD + PSOURCE_MEDIA_W* = ptr SOURCE_MEDIA_W + CABINET_INFO_A* {.pure.} = object + CabinetPath*: PCSTR + CabinetFile*: PCSTR + DiskName*: PCSTR + SetId*: USHORT + CabinetNumber*: USHORT + PCABINET_INFO_A* = ptr CABINET_INFO_A + CABINET_INFO_W* {.pure.} = object + CabinetPath*: PCWSTR + CabinetFile*: PCWSTR + DiskName*: PCWSTR + SetId*: USHORT + CabinetNumber*: USHORT + PCABINET_INFO_W* = ptr CABINET_INFO_W +when winimCpu64: + type + FILE_IN_CABINET_INFO_A* {.pure.} = object + NameInCabinet*: PCSTR + FileSize*: DWORD + Win32Error*: DWORD + DosDate*: WORD + DosTime*: WORD + DosAttribs*: WORD + FullTargetName*: array[MAX_PATH, CHAR] +when winimCpu32: + type + FILE_IN_CABINET_INFO_A* {.pure, packed.} = object + NameInCabinet*: PCSTR + FileSize*: DWORD + Win32Error*: DWORD + DosDate*: WORD + DosTime*: WORD + DosAttribs*: WORD + FullTargetName*: array[MAX_PATH, CHAR] +type + PFILE_IN_CABINET_INFO_A* = ptr FILE_IN_CABINET_INFO_A +when winimCpu64: + type + FILE_IN_CABINET_INFO_W* {.pure.} = object + NameInCabinet*: PCWSTR + FileSize*: DWORD + Win32Error*: DWORD + DosDate*: WORD + DosTime*: WORD + DosAttribs*: WORD + FullTargetName*: array[MAX_PATH, WCHAR] +when winimCpu32: + type + FILE_IN_CABINET_INFO_W* {.pure, packed.} = object + NameInCabinet*: PCWSTR + FileSize*: DWORD + Win32Error*: DWORD + DosDate*: WORD + DosTime*: WORD + DosAttribs*: WORD + FullTargetName*: array[MAX_PATH, WCHAR] +type + PFILE_IN_CABINET_INFO_W* = ptr FILE_IN_CABINET_INFO_W + SP_REGISTER_CONTROL_STATUSA* {.pure.} = object + cbSize*: DWORD + FileName*: PCSTR + Win32Error*: DWORD + FailureCode*: DWORD + PSP_REGISTER_CONTROL_STATUSA* = ptr SP_REGISTER_CONTROL_STATUSA + SP_REGISTER_CONTROL_STATUSW* {.pure.} = object + cbSize*: DWORD + FileName*: PCWSTR + Win32Error*: DWORD + FailureCode*: DWORD + PSP_REGISTER_CONTROL_STATUSW* = ptr SP_REGISTER_CONTROL_STATUSW + SP_FILE_COPY_PARAMS_A* {.pure.} = object + cbSize*: DWORD + QueueHandle*: HSPFILEQ + SourceRootPath*: PCSTR + SourcePath*: PCSTR + SourceFilename*: PCSTR + SourceDescription*: PCSTR + SourceTagfile*: PCSTR + TargetDirectory*: PCSTR + TargetFilename*: PCSTR + CopyStyle*: DWORD + LayoutInf*: HINF + SecurityDescriptor*: PCSTR + PSP_FILE_COPY_PARAMS_A* = ptr SP_FILE_COPY_PARAMS_A + SP_FILE_COPY_PARAMS_W* {.pure.} = object + cbSize*: DWORD + QueueHandle*: HSPFILEQ + SourceRootPath*: PCWSTR + SourcePath*: PCWSTR + SourceFilename*: PCWSTR + SourceDescription*: PCWSTR + SourceTagfile*: PCWSTR + TargetDirectory*: PCWSTR + TargetFilename*: PCWSTR + CopyStyle*: DWORD + LayoutInf*: HINF + SecurityDescriptor*: PCWSTR + PSP_FILE_COPY_PARAMS_W* = ptr SP_FILE_COPY_PARAMS_W + SP_DEVINFO_DATA* {.pure.} = object + cbSize*: DWORD + ClassGuid*: GUID + DevInst*: DWORD + Reserved*: ULONG_PTR + PSP_DEVINFO_DATA* = ptr SP_DEVINFO_DATA + SP_DEVICE_INTERFACE_DATA* {.pure.} = object + cbSize*: DWORD + InterfaceClassGuid*: GUID + Flags*: DWORD + Reserved*: ULONG_PTR + PSP_DEVICE_INTERFACE_DATA* = ptr SP_DEVICE_INTERFACE_DATA + SP_INTERFACE_DEVICE_DATA* = SP_DEVICE_INTERFACE_DATA + PSP_INTERFACE_DEVICE_DATA* = PSP_DEVICE_INTERFACE_DATA +when winimCpu64: + type + SP_DEVICE_INTERFACE_DETAIL_DATA_A* {.pure.} = object + cbSize*: DWORD + DevicePath*: array[ANYSIZE_ARRAY, CHAR] +when winimCpu32: + type + SP_DEVICE_INTERFACE_DETAIL_DATA_A* {.pure, packed.} = object + cbSize*: DWORD + DevicePath*: array[ANYSIZE_ARRAY, CHAR] +type + PSP_DEVICE_INTERFACE_DETAIL_DATA_A* = ptr SP_DEVICE_INTERFACE_DETAIL_DATA_A +when winimCpu64: + type + SP_DEVICE_INTERFACE_DETAIL_DATA_W* {.pure.} = object + cbSize*: DWORD + DevicePath*: array[ANYSIZE_ARRAY, WCHAR] +when winimCpu32: + type + SP_DEVICE_INTERFACE_DETAIL_DATA_W* {.pure, packed.} = object + cbSize*: DWORD + DevicePath*: array[ANYSIZE_ARRAY, WCHAR] +type + PSP_DEVICE_INTERFACE_DETAIL_DATA_W* = ptr SP_DEVICE_INTERFACE_DETAIL_DATA_W + SP_INTERFACE_DEVICE_DETAIL_DATA_W* = SP_DEVICE_INTERFACE_DETAIL_DATA_W + PSP_INTERFACE_DEVICE_DETAIL_DATA_W* = PSP_DEVICE_INTERFACE_DETAIL_DATA_W + SP_INTERFACE_DEVICE_DETAIL_DATA_A* = SP_DEVICE_INTERFACE_DETAIL_DATA_A + PSP_INTERFACE_DEVICE_DETAIL_DATA_A* = PSP_DEVICE_INTERFACE_DETAIL_DATA_A +const + SP_MAX_MACHINENAME_LENGTH* = MAX_PATH+3 +when winimCpu64: + type + SP_DEVINFO_LIST_DETAIL_DATA_A* {.pure.} = object + cbSize*: DWORD + ClassGuid*: GUID + RemoteMachineHandle*: HANDLE + RemoteMachineName*: array[SP_MAX_MACHINENAME_LENGTH, CHAR] +when winimCpu32: + type + SP_DEVINFO_LIST_DETAIL_DATA_A* {.pure, packed.} = object + cbSize*: DWORD + ClassGuid*: GUID + RemoteMachineHandle*: HANDLE + RemoteMachineName*: array[SP_MAX_MACHINENAME_LENGTH, CHAR] +type + PSP_DEVINFO_LIST_DETAIL_DATA_A* = ptr SP_DEVINFO_LIST_DETAIL_DATA_A +when winimCpu64: + type + SP_DEVINFO_LIST_DETAIL_DATA_W* {.pure.} = object + cbSize*: DWORD + ClassGuid*: GUID + RemoteMachineHandle*: HANDLE + RemoteMachineName*: array[SP_MAX_MACHINENAME_LENGTH, WCHAR] +when winimCpu32: + type + SP_DEVINFO_LIST_DETAIL_DATA_W* {.pure, packed.} = object + cbSize*: DWORD + ClassGuid*: GUID + RemoteMachineHandle*: HANDLE + RemoteMachineName*: array[SP_MAX_MACHINENAME_LENGTH, WCHAR] +type + PSP_DEVINFO_LIST_DETAIL_DATA_W* = ptr SP_DEVINFO_LIST_DETAIL_DATA_W + DI_FUNCTION* = UINT + PSP_FILE_CALLBACK_W* = proc (Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.stdcall.} +when winimUnicode: + type + PSP_FILE_CALLBACK* = PSP_FILE_CALLBACK_W +type + PSP_FILE_CALLBACK_A* = proc (Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.stdcall.} +when winimAnsi: + type + PSP_FILE_CALLBACK* = PSP_FILE_CALLBACK_A +type + SP_DEVINSTALL_PARAMS_A* {.pure.} = object + cbSize*: DWORD + Flags*: DWORD + FlagsEx*: DWORD + hwndParent*: HWND + InstallMsgHandler*: PSP_FILE_CALLBACK + InstallMsgHandlerContext*: PVOID + FileQueue*: HSPFILEQ + ClassInstallReserved*: ULONG_PTR + Reserved*: DWORD + DriverPath*: array[MAX_PATH, CHAR] + PSP_DEVINSTALL_PARAMS_A* = ptr SP_DEVINSTALL_PARAMS_A + SP_DEVINSTALL_PARAMS_W* {.pure.} = object + cbSize*: DWORD + Flags*: DWORD + FlagsEx*: DWORD + hwndParent*: HWND + InstallMsgHandler*: PSP_FILE_CALLBACK + InstallMsgHandlerContext*: PVOID + FileQueue*: HSPFILEQ + ClassInstallReserved*: ULONG_PTR + Reserved*: DWORD + DriverPath*: array[MAX_PATH, WCHAR] + PSP_DEVINSTALL_PARAMS_W* = ptr SP_DEVINSTALL_PARAMS_W + SP_CLASSINSTALL_HEADER* {.pure.} = object + cbSize*: DWORD + InstallFunction*: DI_FUNCTION + PSP_CLASSINSTALL_HEADER* = ptr SP_CLASSINSTALL_HEADER + SP_ENABLECLASS_PARAMS* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + ClassGuid*: GUID + EnableMessage*: DWORD + PSP_ENABLECLASS_PARAMS* = ptr SP_ENABLECLASS_PARAMS + SP_PROPCHANGE_PARAMS* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + StateChange*: DWORD + Scope*: DWORD + HwProfile*: DWORD + PSP_PROPCHANGE_PARAMS* = ptr SP_PROPCHANGE_PARAMS + SP_REMOVEDEVICE_PARAMS* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Scope*: DWORD + HwProfile*: DWORD + PSP_REMOVEDEVICE_PARAMS* = ptr SP_REMOVEDEVICE_PARAMS + SP_UNREMOVEDEVICE_PARAMS* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Scope*: DWORD + HwProfile*: DWORD + PSP_UNREMOVEDEVICE_PARAMS* = ptr SP_UNREMOVEDEVICE_PARAMS +const + MAX_TITLE_LEN* = 60 + MAX_INSTRUCTION_LEN* = 256 + MAX_LABEL_LEN* = 30 + MAX_SUBTITLE_LEN* = 256 +type + SP_SELECTDEVICE_PARAMS_A* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Title*: array[MAX_TITLE_LEN, CHAR] + Instructions*: array[MAX_INSTRUCTION_LEN, CHAR] + ListLabel*: array[MAX_LABEL_LEN, CHAR] + SubTitle*: array[MAX_SUBTITLE_LEN, CHAR] + Reserved*: array[2, BYTE] + PSP_SELECTDEVICE_PARAMS_A* = ptr SP_SELECTDEVICE_PARAMS_A + SP_SELECTDEVICE_PARAMS_W* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Title*: array[MAX_TITLE_LEN, WCHAR] + Instructions*: array[MAX_INSTRUCTION_LEN, WCHAR] + ListLabel*: array[MAX_LABEL_LEN, WCHAR] + SubTitle*: array[MAX_SUBTITLE_LEN, WCHAR] + PSP_SELECTDEVICE_PARAMS_W* = ptr SP_SELECTDEVICE_PARAMS_W + PDETECT_PROGRESS_NOTIFY* = proc (ProgressNotifyParam: PVOID, DetectComplete: DWORD): WINBOOL {.stdcall.} + SP_DETECTDEVICE_PARAMS* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + DetectProgressNotify*: PDETECT_PROGRESS_NOTIFY + ProgressNotifyParam*: PVOID + PSP_DETECTDEVICE_PARAMS* = ptr SP_DETECTDEVICE_PARAMS +const + MAX_INSTALLWIZARD_DYNAPAGES* = 20 +type + SP_INSTALLWIZARD_DATA* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Flags*: DWORD + DynamicPages*: array[MAX_INSTALLWIZARD_DYNAPAGES, HPROPSHEETPAGE] + NumDynamicPages*: DWORD + DynamicPageFlags*: DWORD + PrivateFlags*: DWORD + PrivateData*: LPARAM + hwndWizardDlg*: HWND + PSP_INSTALLWIZARD_DATA* = ptr SP_INSTALLWIZARD_DATA + SP_NEWDEVICEWIZARD_DATA* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + Flags*: DWORD + DynamicPages*: array[MAX_INSTALLWIZARD_DYNAPAGES, HPROPSHEETPAGE] + NumDynamicPages*: DWORD + hwndWizardDlg*: HWND + PSP_NEWDEVICEWIZARD_DATA* = ptr SP_NEWDEVICEWIZARD_DATA + SP_ADDPROPERTYPAGE_DATA* = SP_NEWDEVICEWIZARD_DATA + PSP_ADDPROPERTYPAGE_DATA* = PSP_NEWDEVICEWIZARD_DATA + SP_TROUBLESHOOTER_PARAMS_A* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + ChmFile*: array[MAX_PATH, CHAR] + HtmlTroubleShooter*: array[MAX_PATH, CHAR] + PSP_TROUBLESHOOTER_PARAMS_A* = ptr SP_TROUBLESHOOTER_PARAMS_A + SP_TROUBLESHOOTER_PARAMS_W* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + ChmFile*: array[MAX_PATH, WCHAR] + HtmlTroubleShooter*: array[MAX_PATH, WCHAR] + PSP_TROUBLESHOOTER_PARAMS_W* = ptr SP_TROUBLESHOOTER_PARAMS_W +const + LINE_LEN* = 256 +type + SP_POWERMESSAGEWAKE_PARAMS_A* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + PowerMessageWake*: array[LINE_LEN*2, CHAR] + PSP_POWERMESSAGEWAKE_PARAMS_A* = ptr SP_POWERMESSAGEWAKE_PARAMS_A + SP_POWERMESSAGEWAKE_PARAMS_W* {.pure.} = object + ClassInstallHeader*: SP_CLASSINSTALL_HEADER + PowerMessageWake*: array[LINE_LEN*2, WCHAR] + PSP_POWERMESSAGEWAKE_PARAMS_W* = ptr SP_POWERMESSAGEWAKE_PARAMS_W + SP_DRVINFO_DATA_V2_A* {.pure, packed.} = object + cbSize*: DWORD + DriverType*: DWORD + Reserved*: ULONG_PTR + Description*: array[LINE_LEN, CHAR] + MfgName*: array[LINE_LEN, CHAR] + ProviderName*: array[LINE_LEN, CHAR] + DriverDate*: FILETIME + DriverVersion*: DWORDLONG + PSP_DRVINFO_DATA_V2_A* = ptr SP_DRVINFO_DATA_V2_A + SP_DRVINFO_DATA_V2_W* {.pure, packed.} = object + cbSize*: DWORD + DriverType*: DWORD + Reserved*: ULONG_PTR + Description*: array[LINE_LEN, WCHAR] + MfgName*: array[LINE_LEN, WCHAR] + ProviderName*: array[LINE_LEN, WCHAR] + DriverDate*: FILETIME + DriverVersion*: DWORDLONG + PSP_DRVINFO_DATA_V2_W* = ptr SP_DRVINFO_DATA_V2_W + SP_DRVINFO_DATA_V1_A* {.pure.} = object + cbSize*: DWORD + DriverType*: DWORD + Reserved*: ULONG_PTR + Description*: array[LINE_LEN, CHAR] + MfgName*: array[LINE_LEN, CHAR] + ProviderName*: array[LINE_LEN, CHAR] + PSP_DRVINFO_DATA_V1_A* = ptr SP_DRVINFO_DATA_V1_A + SP_DRVINFO_DATA_V1_W* {.pure.} = object + cbSize*: DWORD + DriverType*: DWORD + Reserved*: ULONG_PTR + Description*: array[LINE_LEN, WCHAR] + MfgName*: array[LINE_LEN, WCHAR] + ProviderName*: array[LINE_LEN, WCHAR] + PSP_DRVINFO_DATA_V1_W* = ptr SP_DRVINFO_DATA_V1_W + SP_DRVINFO_DATA_A* = SP_DRVINFO_DATA_V2_A + PSP_DRVINFO_DATA_A* = PSP_DRVINFO_DATA_V2_A + SP_DRVINFO_DATA_W* = SP_DRVINFO_DATA_V2_W + PSP_DRVINFO_DATA_W* = PSP_DRVINFO_DATA_V2_W +when winimUnicode: + type + SP_DRVINFO_DATA_V2* = SP_DRVINFO_DATA_V2_W +when winimAnsi: + type + SP_DRVINFO_DATA_V2* = SP_DRVINFO_DATA_V2_A +type + SP_DRVINFO_DATA* = SP_DRVINFO_DATA_V2 +when winimUnicode: + type + PSP_DRVINFO_DATA_V2* = PSP_DRVINFO_DATA_V2_W +when winimAnsi: + type + PSP_DRVINFO_DATA_V2* = PSP_DRVINFO_DATA_V2_A +type + PSP_DRVINFO_DATA* = PSP_DRVINFO_DATA_V2 +when winimCpu64: + type + SP_DRVINFO_DETAIL_DATA_A* {.pure.} = object + cbSize*: DWORD + InfDate*: FILETIME + CompatIDsOffset*: DWORD + CompatIDsLength*: DWORD + Reserved*: ULONG_PTR + SectionName*: array[LINE_LEN, CHAR] + InfFileName*: array[MAX_PATH, CHAR] + DrvDescription*: array[LINE_LEN, CHAR] + HardwareID*: array[ANYSIZE_ARRAY, CHAR] +when winimCpu32: + type + SP_DRVINFO_DETAIL_DATA_A* {.pure, packed.} = object + cbSize*: DWORD + InfDate*: FILETIME + CompatIDsOffset*: DWORD + CompatIDsLength*: DWORD + Reserved*: ULONG_PTR + SectionName*: array[LINE_LEN, CHAR] + InfFileName*: array[MAX_PATH, CHAR] + DrvDescription*: array[LINE_LEN, CHAR] + HardwareID*: array[ANYSIZE_ARRAY, CHAR] +type + PSP_DRVINFO_DETAIL_DATA_A* = ptr SP_DRVINFO_DETAIL_DATA_A +when winimCpu64: + type + SP_DRVINFO_DETAIL_DATA_W* {.pure.} = object + cbSize*: DWORD + InfDate*: FILETIME + CompatIDsOffset*: DWORD + CompatIDsLength*: DWORD + Reserved*: ULONG_PTR + SectionName*: array[LINE_LEN, WCHAR] + InfFileName*: array[MAX_PATH, WCHAR] + DrvDescription*: array[LINE_LEN, WCHAR] + HardwareID*: array[ANYSIZE_ARRAY, WCHAR] +when winimCpu32: + type + SP_DRVINFO_DETAIL_DATA_W* {.pure, packed.} = object + cbSize*: DWORD + InfDate*: FILETIME + CompatIDsOffset*: DWORD + CompatIDsLength*: DWORD + Reserved*: ULONG_PTR + SectionName*: array[LINE_LEN, WCHAR] + InfFileName*: array[MAX_PATH, WCHAR] + DrvDescription*: array[LINE_LEN, WCHAR] + HardwareID*: array[ANYSIZE_ARRAY, WCHAR] +type + PSP_DRVINFO_DETAIL_DATA_W* = ptr SP_DRVINFO_DETAIL_DATA_W + SP_DRVINSTALL_PARAMS* {.pure.} = object + cbSize*: DWORD + Rank*: DWORD + Flags*: DWORD + PrivateData*: DWORD_PTR + Reserved*: DWORD + PSP_DRVINSTALL_PARAMS* = ptr SP_DRVINSTALL_PARAMS + COINSTALLER_CONTEXT_DATA* {.pure.} = object + PostProcessing*: WINBOOL + InstallResult*: DWORD + PrivateData*: PVOID + PCOINSTALLER_CONTEXT_DATA* = ptr COINSTALLER_CONTEXT_DATA + SP_CLASSIMAGELIST_DATA* {.pure.} = object + cbSize*: DWORD + ImageList*: HIMAGELIST + Reserved*: ULONG_PTR + PSP_CLASSIMAGELIST_DATA* = ptr SP_CLASSIMAGELIST_DATA + SP_PROPSHEETPAGE_REQUEST* {.pure.} = object + cbSize*: DWORD + PageRequested*: DWORD + DeviceInfoSet*: HDEVINFO + DeviceInfoData*: PSP_DEVINFO_DATA + PSP_PROPSHEETPAGE_REQUEST* = ptr SP_PROPSHEETPAGE_REQUEST + SP_BACKUP_QUEUE_PARAMS_V2_A* {.pure.} = object + cbSize*: DWORD + FullInfPath*: array[MAX_PATH, CHAR] + FilenameOffset*: INT + ReinstallInstance*: array[MAX_PATH, CHAR] + PSP_BACKUP_QUEUE_PARAMS_V2_A* = ptr SP_BACKUP_QUEUE_PARAMS_V2_A + SP_BACKUP_QUEUE_PARAMS_V2_W* {.pure.} = object + cbSize*: DWORD + FullInfPath*: array[MAX_PATH, WCHAR] + FilenameOffset*: INT + ReinstallInstance*: array[MAX_PATH, WCHAR] + PSP_BACKUP_QUEUE_PARAMS_V2_W* = ptr SP_BACKUP_QUEUE_PARAMS_V2_W + SP_BACKUP_QUEUE_PARAMS_V1_A* {.pure.} = object + cbSize*: DWORD + FullInfPath*: array[MAX_PATH, CHAR] + FilenameOffset*: INT + PSP_BACKUP_QUEUE_PARAMS_V1_A* = ptr SP_BACKUP_QUEUE_PARAMS_V1_A + SP_BACKUP_QUEUE_PARAMS_V1_W* {.pure.} = object + cbSize*: DWORD + FullInfPath*: array[MAX_PATH, WCHAR] + FilenameOffset*: INT + PSP_BACKUP_QUEUE_PARAMS_V1_W* = ptr SP_BACKUP_QUEUE_PARAMS_V1_W + SP_BACKUP_QUEUE_PARAMS_A* = SP_BACKUP_QUEUE_PARAMS_V2_A + PSP_BACKUP_QUEUE_PARAMS_A* = PSP_BACKUP_QUEUE_PARAMS_V2_A + SP_BACKUP_QUEUE_PARAMS_W* = SP_BACKUP_QUEUE_PARAMS_V2_W + PSP_BACKUP_QUEUE_PARAMS_W* = PSP_BACKUP_QUEUE_PARAMS_V2_W +when winimUnicode: + type + SP_BACKUP_QUEUE_PARAMS_V2* = SP_BACKUP_QUEUE_PARAMS_V2_W +when winimAnsi: + type + SP_BACKUP_QUEUE_PARAMS_V2* = SP_BACKUP_QUEUE_PARAMS_V2_A +type + SP_BACKUP_QUEUE_PARAMS* = SP_BACKUP_QUEUE_PARAMS_V2 +when winimUnicode: + type + PSP_BACKUP_QUEUE_PARAMS_V2* = PSP_BACKUP_QUEUE_PARAMS_V2_W +when winimAnsi: + type + PSP_BACKUP_QUEUE_PARAMS_V2* = PSP_BACKUP_QUEUE_PARAMS_V2_A +type + PSP_BACKUP_QUEUE_PARAMS* = PSP_BACKUP_QUEUE_PARAMS_V2 + SP_INF_SIGNER_INFO_A* {.pure.} = object + cbSize*: DWORD + CatalogFile*: array[MAX_PATH, CHAR] + DigitalSigner*: array[MAX_PATH, CHAR] + DigitalSignerVersion*: array[MAX_PATH, CHAR] + PSP_INF_SIGNER_INFO_A* = ptr SP_INF_SIGNER_INFO_A + SP_INF_SIGNER_INFO_W* {.pure.} = object + cbSize*: DWORD + CatalogFile*: array[MAX_PATH, WCHAR] + DigitalSigner*: array[MAX_PATH, WCHAR] + DigitalSignerVersion*: array[MAX_PATH, WCHAR] + PSP_INF_SIGNER_INFO_W* = ptr SP_INF_SIGNER_INFO_W +const + SETUPAPI_VER* = 0x0502 + MAX_INF_STRING_LENGTH* = 4096 + MAX_INF_SECTION_NAME_LENGTH* = 255 + MAX_SERVICE_NAME_LEN* = 256 + SP_ALTPLATFORM_FLAGS_VERSION_RANGE* = 0x0001 + INF_STYLE_NONE* = 0x00000000 + INF_STYLE_OLDNT* = 0x00000001 + INF_STYLE_WIN4* = 0x00000002 + INF_STYLE_CACHE_ENABLE* = 0x00000010 + INF_STYLE_CACHE_DISABLE* = 0x00000020 + INF_STYLE_CACHE_IGNORE* = 0x00000040 + DIRID_ABSOLUTE* = -1 + DIRID_ABSOLUTE_16BIT* = 0xffff + DIRID_NULL* = 0 + DIRID_SRCPATH* = 1 + DIRID_WINDOWS* = 10 + DIRID_SYSTEM* = 11 + DIRID_DRIVERS* = 12 + DIRID_IOSUBSYS* = DIRID_DRIVERS + DIRID_INF* = 17 + DIRID_HELP* = 18 + DIRID_FONTS* = 20 + DIRID_VIEWERS* = 21 + DIRID_COLOR* = 23 + DIRID_APPS* = 24 + DIRID_SHARED* = 25 + DIRID_BOOT* = 30 + DIRID_SYSTEM16* = 50 + DIRID_SPOOL* = 51 + DIRID_SPOOLDRIVERS* = 52 + DIRID_USERPROFILE* = 53 + DIRID_LOADER* = 54 + DIRID_PRINTPROCESSOR* = 55 + DIRID_DEFAULT* = DIRID_SYSTEM + DIRID_COMMON_STARTMENU* = 16406 + DIRID_COMMON_PROGRAMS* = 16407 + DIRID_COMMON_STARTUP* = 16408 + DIRID_COMMON_DESKTOPDIRECTORY* = 16409 + DIRID_COMMON_FAVORITES* = 16415 + DIRID_COMMON_APPDATA* = 16419 + DIRID_PROGRAM_FILES* = 16422 + DIRID_SYSTEM_X86* = 16425 + DIRID_PROGRAM_FILES_X86* = 16426 + DIRID_PROGRAM_FILES_COMMON* = 16427 + DIRID_PROGRAM_FILES_COMMONX86* = 16428 + DIRID_COMMON_TEMPLATES* = 16429 + DIRID_COMMON_DOCUMENTS* = 16430 + DIRID_USER* = 0x8000 + SPFILENOTIFY_STARTQUEUE* = 0x00000001 + SPFILENOTIFY_ENDQUEUE* = 0x00000002 + SPFILENOTIFY_STARTSUBQUEUE* = 0x00000003 + SPFILENOTIFY_ENDSUBQUEUE* = 0x00000004 + SPFILENOTIFY_STARTDELETE* = 0x00000005 + SPFILENOTIFY_ENDDELETE* = 0x00000006 + SPFILENOTIFY_DELETEERROR* = 0x00000007 + SPFILENOTIFY_STARTRENAME* = 0x00000008 + SPFILENOTIFY_ENDRENAME* = 0x00000009 + SPFILENOTIFY_RENAMEERROR* = 0x0000000a + SPFILENOTIFY_STARTCOPY* = 0x0000000b + SPFILENOTIFY_ENDCOPY* = 0x0000000c + SPFILENOTIFY_COPYERROR* = 0x0000000d + SPFILENOTIFY_NEEDMEDIA* = 0x0000000e + SPFILENOTIFY_QUEUESCAN* = 0x0000000f + SPFILENOTIFY_CABINETINFO* = 0x00000010 + SPFILENOTIFY_FILEINCABINET* = 0x00000011 + SPFILENOTIFY_NEEDNEWCABINET* = 0x00000012 + SPFILENOTIFY_FILEEXTRACTED* = 0x00000013 + SPFILENOTIFY_FILEOPDELAYED* = 0x00000014 + SPFILENOTIFY_STARTBACKUP* = 0x00000015 + SPFILENOTIFY_BACKUPERROR* = 0x00000016 + SPFILENOTIFY_ENDBACKUP* = 0x00000017 + SPFILENOTIFY_QUEUESCAN_EX* = 0x00000018 + SPFILENOTIFY_STARTREGISTRATION* = 0x00000019 + SPFILENOTIFY_ENDREGISTRATION* = 0x00000020 + SPFILENOTIFY_QUEUESCAN_SIGNERINFO* = 0x00000040 + SPFILENOTIFY_LANGMISMATCH* = 0x00010000 + SPFILENOTIFY_TARGETEXISTS* = 0x00020000 + SPFILENOTIFY_TARGETNEWER* = 0x00040000 + FILEOP_COPY* = 0 + FILEOP_RENAME* = 1 + FILEOP_DELETE* = 2 + FILEOP_BACKUP* = 3 + FILEOP_ABORT* = 0 + FILEOP_DOIT* = 1 + FILEOP_SKIP* = 2 + FILEOP_RETRY* = FILEOP_DOIT + FILEOP_NEWPATH* = 4 + COPYFLG_WARN_IF_SKIP* = 0x00000001 + COPYFLG_NOSKIP* = 0x00000002 + COPYFLG_NOVERSIONCHECK* = 0x00000004 + COPYFLG_FORCE_FILE_IN_USE* = 0x00000008 + COPYFLG_NO_OVERWRITE* = 0x00000010 + COPYFLG_NO_VERSION_DIALOG* = 0x00000020 + COPYFLG_OVERWRITE_OLDER_ONLY* = 0x00000040 + COPYFLG_REPLACEONLY* = 0x00000400 + COPYFLG_NODECOMP* = 0x00000800 + COPYFLG_REPLACE_BOOT_FILE* = 0x00001000 + COPYFLG_NOPRUNE* = 0x00002000 + DELFLG_IN_USE* = 0x00000001 + DELFLG_IN_USE1* = 0x00010000 + SPREG_SUCCESS* = 0x00000000 + SPREG_LOADLIBRARY* = 0x00000001 + SPREG_GETPROCADDR* = 0x00000002 + SPREG_REGSVR* = 0x00000003 + SPREG_DLLINSTALL* = 0x00000004 + SPREG_TIMEOUT* = 0x00000005 + SPREG_UNKNOWN* = 0xFFFFFFFF'i32 + SPINT_ACTIVE* = 0x00000001 + SPINT_DEFAULT* = 0x00000002 + SPINT_REMOVED* = 0x00000004 + SPID_ACTIVE* = SPINT_ACTIVE + SPID_DEFAULT* = SPINT_DEFAULT + SPID_REMOVED* = SPINT_REMOVED + DIF_SELECTDEVICE* = 0x00000001 + DIF_INSTALLDEVICE* = 0x00000002 + DIF_ASSIGNRESOURCES* = 0x00000003 + DIF_PROPERTIES* = 0x00000004 + DIF_REMOVE* = 0x00000005 + DIF_FIRSTTIMESETUP* = 0x00000006 + DIF_FOUNDDEVICE* = 0x00000007 + DIF_SELECTCLASSDRIVERS* = 0x00000008 + DIF_VALIDATECLASSDRIVERS* = 0x00000009 + DIF_INSTALLCLASSDRIVERS* = 0x0000000A + DIF_CALCDISKSPACE* = 0x0000000B + DIF_DESTROYPRIVATEDATA* = 0x0000000C + DIF_VALIDATEDRIVER* = 0x0000000D + DIF_DETECT* = 0x0000000F + DIF_INSTALLWIZARD* = 0x00000010 + DIF_DESTROYWIZARDDATA* = 0x00000011 + DIF_PROPERTYCHANGE* = 0x00000012 + DIF_ENABLECLASS* = 0x00000013 + DIF_DETECTVERIFY* = 0x00000014 + DIF_INSTALLDEVICEFILES* = 0x00000015 + DIF_UNREMOVE* = 0x00000016 + DIF_SELECTBESTCOMPATDRV* = 0x00000017 + DIF_ALLOW_INSTALL* = 0x00000018 + DIF_REGISTERDEVICE* = 0x00000019 + DIF_NEWDEVICEWIZARD_PRESELECT* = 0x0000001A + DIF_NEWDEVICEWIZARD_SELECT* = 0x0000001B + DIF_NEWDEVICEWIZARD_PREANALYZE* = 0x0000001C + DIF_NEWDEVICEWIZARD_POSTANALYZE* = 0x0000001D + DIF_NEWDEVICEWIZARD_FINISHINSTALL* = 0x0000001E + DIF_UNUSED1* = 0x0000001F + DIF_INSTALLINTERFACES* = 0x00000020 + DIF_DETECTCANCEL* = 0x00000021 + DIF_REGISTER_COINSTALLERS* = 0x00000022 + DIF_ADDPROPERTYPAGE_ADVANCED* = 0x00000023 + DIF_ADDPROPERTYPAGE_BASIC* = 0x00000024 + DIF_RESERVED1* = 0x00000025 + DIF_TROUBLESHOOTER* = 0x00000026 + DIF_POWERMESSAGEWAKE* = 0x00000027 + DIF_ADDREMOTEPROPERTYPAGE_ADVANCED* = 0x00000028 + DIF_UPDATEDRIVER_UI* = 0x00000029 + DIF_RESERVED2* = 0x00000030 + DIF_MOVEDEVICE* = 0x0000000E + DI_SHOWOEM* = 0x00000001 + DI_SHOWCOMPAT* = 0x00000002 + DI_SHOWCLASS* = 0x00000004 + DI_SHOWALL* = 0x00000007 + DI_NOVCP* = 0x00000008 + DI_DIDCOMPAT* = 0x00000010 + DI_DIDCLASS* = 0x00000020 + DI_AUTOASSIGNRES* = 0x00000040 + DI_NEEDRESTART* = 0x00000080 + DI_NEEDREBOOT* = 0x00000100 + DI_NOBROWSE* = 0x00000200 + DI_MULTMFGS* = 0x00000400 + DI_DISABLED* = 0x00000800 + DI_GENERALPAGE_ADDED* = 0x00001000 + DI_RESOURCEPAGE_ADDED* = 0x00002000 + DI_PROPERTIES_CHANGE* = 0x00004000 + DI_INF_IS_SORTED* = 0x00008000 + DI_ENUMSINGLEINF* = 0x00010000 + DI_DONOTCALLCONFIGMG* = 0x00020000 + DI_INSTALLDISABLED* = 0x00040000 + DI_COMPAT_FROM_CLASS* = 0x00080000 + DI_CLASSINSTALLPARAMS* = 0x00100000 + DI_NODI_DEFAULTACTION* = 0x00200000 + DI_QUIETINSTALL* = 0x00800000 + DI_NOFILECOPY* = 0x01000000 + DI_FORCECOPY* = 0x02000000 + DI_DRIVERPAGE_ADDED* = 0x04000000 + DI_USECI_SELECTSTRINGS* = 0x08000000 + DI_OVERRIDE_INFFLAGS* = 0x10000000 + DI_PROPS_NOCHANGEUSAGE* = 0x20000000 + DI_NOSELECTICONS* = 0x40000000 + DI_NOWRITE_IDS* = 0x80000000'i32 + DI_FLAGSEX_USEOLDINFSEARCH* = 0x00000001 + DI_FLAGSEX_RESERVED2* = 0x00000002 + DI_FLAGSEX_CI_FAILED* = 0x00000004 + DI_FLAGSEX_DIDINFOLIST* = 0x00000010 + DI_FLAGSEX_DIDCOMPATINFO* = 0x00000020 + DI_FLAGSEX_FILTERCLASSES* = 0x00000040 + DI_FLAGSEX_SETFAILEDINSTALL* = 0x00000080 + DI_FLAGSEX_DEVICECHANGE* = 0x00000100 + DI_FLAGSEX_ALWAYSWRITEIDS* = 0x00000200 + DI_FLAGSEX_PROPCHANGE_PENDING* = 0x00000400 + DI_FLAGSEX_ALLOWEXCLUDEDDRVS* = 0x00000800 + DI_FLAGSEX_NOUIONQUERYREMOVE* = 0x00001000 + DI_FLAGSEX_USECLASSFORCOMPAT* = 0x00002000 + DI_FLAGSEX_RESERVED3* = 0x00004000 + DI_FLAGSEX_NO_DRVREG_MODIFY* = 0x00008000 + DI_FLAGSEX_IN_SYSTEM_SETUP* = 0x00010000 + DI_FLAGSEX_INET_DRIVER* = 0x00020000 + DI_FLAGSEX_APPENDDRIVERLIST* = 0x00040000 + DI_FLAGSEX_PREINSTALLBACKUP* = 0x00080000 + DI_FLAGSEX_BACKUPONREPLACE* = 0x00100000 + DI_FLAGSEX_DRIVERLIST_FROM_URL* = 0x00200000 + DI_FLAGSEX_RESERVED1* = 0x00400000 + DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS* = 0x00800000 + DI_FLAGSEX_POWERPAGE_ADDED* = 0x01000000 + DI_FLAGSEX_FILTERSIMILARDRIVERS* = 0x02000000 + DI_FLAGSEX_INSTALLEDDRIVER* = 0x04000000 + DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE* = 0x08000000 + DI_FLAGSEX_ALTPLATFORM_DRVSEARCH* = 0x10000000 + DI_FLAGSEX_RESTART_DEVICE_ONLY* = 0x20000000 + ENABLECLASS_QUERY* = 0 + ENABLECLASS_SUCCESS* = 1 + ENABLECLASS_FAILURE* = 2 + DICS_ENABLE* = 0x00000001 + DICS_DISABLE* = 0x00000002 + DICS_PROPCHANGE* = 0x00000003 + DICS_START* = 0x00000004 + DICS_STOP* = 0x00000005 + DICS_FLAG_GLOBAL* = 0x00000001 + DICS_FLAG_CONFIGSPECIFIC* = 0x00000002 + DICS_FLAG_CONFIGGENERAL* = 0x00000004 + DI_REMOVEDEVICE_GLOBAL* = 0x00000001 + DI_REMOVEDEVICE_CONFIGSPECIFIC* = 0x00000002 + DI_UNREMOVEDEVICE_CONFIGSPECIFIC* = 0x00000002 + NDW_INSTALLFLAG_DIDFACTDEFS* = 0x00000001 + NDW_INSTALLFLAG_HARDWAREALLREADYIN* = 0x00000002 + NDW_INSTALLFLAG_NEEDRESTART* = DI_NEEDRESTART + NDW_INSTALLFLAG_NEEDREBOOT* = DI_NEEDREBOOT + NDW_INSTALLFLAG_NEEDSHUTDOWN* = 0x00000200 + NDW_INSTALLFLAG_EXPRESSINTRO* = 0x00000400 + NDW_INSTALLFLAG_SKIPISDEVINSTALLED* = 0x00000800 + NDW_INSTALLFLAG_NODETECTEDDEVS* = 0x00001000 + NDW_INSTALLFLAG_INSTALLSPECIFIC* = 0x00002000 + NDW_INSTALLFLAG_SKIPCLASSLIST* = 0x00004000 + NDW_INSTALLFLAG_CI_PICKED_OEM* = 0x00008000 + NDW_INSTALLFLAG_PCMCIAMODE* = 0x00010000 + NDW_INSTALLFLAG_PCMCIADEVICE* = 0x00020000 + NDW_INSTALLFLAG_USERCANCEL* = 0x00040000 + NDW_INSTALLFLAG_KNOWNCLASS* = 0x00080000 + DYNAWIZ_FLAG_PAGESADDED* = 0x00000001 + DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT* = 0x00000008 + DYNAWIZ_FLAG_INSTALLDET_NEXT* = 0x00000002 + DYNAWIZ_FLAG_INSTALLDET_PREV* = 0x00000004 + MIN_IDD_DYNAWIZ_RESOURCE_ID* = 10000 + MAX_IDD_DYNAWIZ_RESOURCE_ID* = 11000 + IDD_DYNAWIZ_FIRSTPAGE* = 10000 + IDD_DYNAWIZ_SELECT_PREVPAGE* = 10001 + IDD_DYNAWIZ_SELECT_NEXTPAGE* = 10002 + IDD_DYNAWIZ_ANALYZE_PREVPAGE* = 10003 + IDD_DYNAWIZ_ANALYZE_NEXTPAGE* = 10004 + IDD_DYNAWIZ_SELECTDEV_PAGE* = 10009 + IDD_DYNAWIZ_ANALYZEDEV_PAGE* = 10010 + IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE* = 10011 + IDD_DYNAWIZ_SELECTCLASS_PAGE* = 10012 + IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE* = 10006 + IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE* = 10007 + IDD_DYNAWIZ_INSTALLDETECTED_NODEVS* = 10008 + DNF_DUPDESC* = 0x00000001 + DNF_OLDDRIVER* = 0x00000002 + DNF_EXCLUDEFROMLIST* = 0x00000004 + DNF_NODRIVER* = 0x00000008 + DNF_LEGACYINF* = 0x00000010 + DNF_CLASS_DRIVER* = 0x00000020 + DNF_COMPATIBLE_DRIVER* = 0x00000040 + DNF_INET_DRIVER* = 0x00000080 + DNF_UNUSED1* = 0x00000100 + DNF_INDEXED_DRIVER* = 0x00000200 + DNF_OLD_INET_DRIVER* = 0x00000400 + DNF_BAD_DRIVER* = 0x00000800 + DNF_DUPPROVIDER* = 0x00001000 + DNF_INF_IS_SIGNED* = 0x00002000 + DNF_OEM_F6_INF* = 0x00004000 + DNF_DUPDRIVERVER* = 0x00008000 + DNF_BASIC_DRIVER* = 0x00010000 + DNF_AUTHENTICODE_SIGNED* = 0x00020000 + DRIVER_HARDWAREID_RANK* = 0x00000FFF + DRIVER_COMPATID_RANK* = 0x00003FFF + DRIVER_UNTRUSTED_RANK* = 0x00008000 + DRIVER_UNTRUSTED_HARDWAREID_RANK* = 0x00008FFF + DRIVER_UNTRUSTED_COMPATID_RANK* = 0x0000BFFF + DRIVER_W9X_SUSPECT_RANK* = 0x0000C000 + DRIVER_W9X_SUSPECT_HARDWAREID_RANK* = 0x0000CFFF + DRIVER_W9X_SUSPECT_COMPATID_RANK* = 0x0000FFFF + SPPSR_SELECT_DEVICE_RESOURCES* = 1 + SPPSR_ENUM_BASIC_DEVICE_PROPERTIES* = 2 + SPPSR_ENUM_ADV_DEVICE_PROPERTIES* = 3 + ERROR_EXPECTED_SECTION_NAME* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0 + ERROR_BAD_SECTION_NAME_LINE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 1 + ERROR_SECTION_NAME_TOO_LONG* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 2 + ERROR_GENERAL_SYNTAX* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 3 + ERROR_WRONG_INF_STYLE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x100 + ERROR_SECTION_NOT_FOUND* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x101 + ERROR_LINE_NOT_FOUND* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x102 + ERROR_NO_BACKUP* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x103 + ERROR_NO_ASSOCIATED_CLASS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x200 + ERROR_CLASS_MISMATCH* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x201 + ERROR_DUPLICATE_FOUND* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x202 + ERROR_NO_DRIVER_SELECTED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x203 + ERROR_KEY_DOES_NOT_EXIST* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x204 + ERROR_INVALID_DEVINST_NAME* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x205 + ERROR_INVALID_CLASS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x206 + ERROR_DEVINST_ALREADY_EXISTS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x207 + ERROR_DEVINFO_NOT_REGISTERED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x208 + ERROR_INVALID_REG_PROPERTY* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x209 + ERROR_NO_INF* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20A + ERROR_NO_SUCH_DEVINST* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20B + ERROR_CANT_LOAD_CLASS_ICON* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20C + ERROR_INVALID_CLASS_INSTALLER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20D + ERROR_DI_DO_DEFAULT* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20E + ERROR_DI_NOFILECOPY* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x20F + ERROR_INVALID_HWPROFILE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x210 + ERROR_NO_DEVICE_SELECTED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x211 + ERROR_DEVINFO_LIST_LOCKED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x212 + ERROR_DEVINFO_DATA_LOCKED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x213 + ERROR_DI_BAD_PATH* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x214 + ERROR_NO_CLASSINSTALL_PARAMS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x215 + ERROR_FILEQUEUE_LOCKED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x216 + ERROR_BAD_SERVICE_INSTALLSECT* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x217 + ERROR_NO_CLASS_DRIVER_LIST* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x218 + ERROR_NO_ASSOCIATED_SERVICE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x219 + ERROR_NO_DEFAULT_DEVICE_INTERFACE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21A + ERROR_DEVICE_INTERFACE_ACTIVE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21B + ERROR_DEVICE_INTERFACE_REMOVED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21C + ERROR_BAD_INTERFACE_INSTALLSECT* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21D + ERROR_NO_SUCH_INTERFACE_CLASS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21E + ERROR_INVALID_REFERENCE_STRING* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x21F + ERROR_INVALID_MACHINENAME* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x220 + ERROR_REMOTE_COMM_FAILURE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x221 + ERROR_MACHINE_UNAVAILABLE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x222 + ERROR_NO_CONFIGMGR_SERVICES* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x223 + ERROR_INVALID_PROPPAGE_PROVIDER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x224 + ERROR_NO_SUCH_DEVICE_INTERFACE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x225 + ERROR_DI_POSTPROCESSING_REQUIRED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x226 + ERROR_INVALID_COINSTALLER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x227 + ERROR_NO_COMPAT_DRIVERS* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x228 + ERROR_NO_DEVICE_ICON* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x229 + ERROR_INVALID_INF_LOGCONFIG* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22A + ERROR_DI_DONT_INSTALL* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22B + ERROR_INVALID_FILTER_DRIVER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22C + ERROR_NON_WINDOWS_NT_DRIVER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22D + ERROR_NON_WINDOWS_DRIVER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22E + ERROR_NO_CATALOG_FOR_OEM_INF* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x22F + ERROR_DEVINSTALL_QUEUE_NONNATIVE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x230 + ERROR_NOT_DISABLEABLE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x231 + ERROR_CANT_REMOVE_DEVINST* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x232 + ERROR_INVALID_TARGET* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x233 + ERROR_DRIVER_NONNATIVE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x234 + ERROR_IN_WOW64* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x235 + ERROR_SET_SYSTEM_RESTORE_POINT* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x236 + ERROR_INCORRECTLY_COPIED_INF* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x237 + ERROR_SCE_DISABLED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x238 + ERROR_UNKNOWN_EXCEPTION* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x239 + ERROR_PNP_REGISTRY_ERROR* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23A + ERROR_REMOTE_REQUEST_UNSUPPORTED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23B + ERROR_NOT_AN_INSTALLED_OEM_INF* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23C + ERROR_INF_IN_USE_BY_DEVICES* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23D + ERROR_DI_FUNCTION_OBSOLETE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23E + ERROR_NO_AUTHENTICODE_CATALOG* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x23F + ERROR_AUTHENTICODE_DISALLOWED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x240 + ERROR_AUTHENTICODE_TRUSTED_PUBLISHER* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x241 + ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x242 + ERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x243 + ERROR_SIGNATURE_OSATTRIBUTE_MISMATCH* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x244 + ERROR_ONLY_VALIDATE_VIA_AUTHENTICODE* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x245 + ERROR_UNRECOVERABLE_STACK_OVERFLOW* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x300 + EXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOW* = ERROR_UNRECOVERABLE_STACK_OVERFLOW + ERROR_NO_DEFAULT_INTERFACE_DEVICE* = ERROR_NO_DEFAULT_DEVICE_INTERFACE + ERROR_INTERFACE_DEVICE_ACTIVE* = ERROR_DEVICE_INTERFACE_ACTIVE + ERROR_INTERFACE_DEVICE_REMOVED* = ERROR_DEVICE_INTERFACE_REMOVED + ERROR_NO_SUCH_INTERFACE_DEVICE* = ERROR_NO_SUCH_DEVICE_INTERFACE + ERROR_NOT_INSTALLED* = APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0x1000 + INFINFO_INF_SPEC_IS_HINF* = 1 + INFINFO_INF_NAME_IS_ABSOLUTE* = 2 + INFINFO_DEFAULT_SEARCH* = 3 + INFINFO_REVERSE_DEFAULT_SEARCH* = 4 + INFINFO_INF_PATH_LIST_SEARCH* = 5 + SRCLIST_TEMPORARY* = 0x00000001 + SRCLIST_NOBROWSE* = 0x00000002 + SRCLIST_SYSTEM* = 0x00000010 + SRCLIST_USER* = 0x00000020 + SRCLIST_SYSIFADMIN* = 0x00000040 + SRCLIST_SUBDIRS* = 0x00000100 + SRCLIST_APPEND* = 0x00000200 + SRCLIST_NOSTRIPPLATFORM* = 0x00000400 + FILE_COMPRESSION_NONE* = 0 + FILE_COMPRESSION_WINLZA* = 1 + FILE_COMPRESSION_MSZIP* = 2 + FILE_COMPRESSION_NTCAB* = 3 + IDF_NOBROWSE* = 0x00000001 + IDF_NOSKIP* = 0x00000002 + IDF_NODETAILS* = 0x00000004 + IDF_NOCOMPRESSED* = 0x00000008 + IDF_CHECKFIRST* = 0x00000100 + IDF_NOBEEP* = 0x00000200 + IDF_NOFOREGROUND* = 0x00000400 + IDF_WARNIFSKIP* = 0x00000800 + IDF_NOREMOVABLEMEDIAPROMPT* = 0x00001000 + IDF_USEDISKNAMEASPROMPT* = 0x00002000 + IDF_OEMDISK* = 0x80000000'i32 + DPROMPT_SUCCESS* = 0 + DPROMPT_CANCEL* = 1 + DPROMPT_SKIPFILE* = 2 + DPROMPT_BUFFERTOOSMALL* = 3 + DPROMPT_OUTOFMEMORY* = 4 + SETDIRID_NOT_FULL_PATH* = 0x00000001 + SRCINFO_PATH* = 1 + SRCINFO_TAGFILE* = 2 + SRCINFO_DESCRIPTION* = 3 + SRCINFO_FLAGS* = 4 + SRCINFO_TAGFILE2* = 5 + SRC_FLAGS_CABFILE* = 0x0010 + SP_COPY_DELETESOURCE* = 0x0000001 + SP_COPY_REPLACEONLY* = 0x0000002 + SP_COPY_NEWER* = 0x0000004 + SP_COPY_NEWER_OR_SAME* = SP_COPY_NEWER + SP_COPY_NOOVERWRITE* = 0x0000008 + SP_COPY_NODECOMP* = 0x0000010 + SP_COPY_LANGUAGEAWARE* = 0x0000020 + SP_COPY_SOURCE_ABSOLUTE* = 0x0000040 + SP_COPY_SOURCEPATH_ABSOLUTE* = 0x0000080 + SP_COPY_IN_USE_NEEDS_REBOOT* = 0x0000100 + SP_COPY_FORCE_IN_USE* = 0x0000200 + SP_COPY_NOSKIP* = 0x0000400 + SP_FLAG_CABINETCONTINUATION* = 0x0000800 + SP_COPY_FORCE_NOOVERWRITE* = 0x0001000 + SP_COPY_FORCE_NEWER* = 0x0002000 + SP_COPY_WARNIFSKIP* = 0x0004000 + SP_COPY_NOBROWSE* = 0x0008000 + SP_COPY_NEWER_ONLY* = 0x0010000 + SP_COPY_SOURCE_SIS_MASTER* = 0x0020000 + SP_COPY_OEMINF_CATALOG_ONLY* = 0x0040000 + SP_COPY_REPLACE_BOOT_FILE* = 0x0080000 + SP_COPY_NOPRUNE* = 0x0100000 + SP_COPY_OEM_F6_INF* = 0x0200000 + SP_BACKUP_BACKUPPASS* = 0x00000001 + SP_BACKUP_DEMANDPASS* = 0x00000002 + SP_BACKUP_SPECIAL* = 0x00000004 + SP_BACKUP_BOOTFILE* = 0x00000008 + SPQ_SCAN_FILE_PRESENCE* = 0x00000001 + SPQ_SCAN_FILE_VALIDITY* = 0x00000002 + SPQ_SCAN_USE_CALLBACK* = 0x00000004 + SPQ_SCAN_USE_CALLBACKEX* = 0x00000008 + SPQ_SCAN_INFORM_USER* = 0x00000010 + SPQ_SCAN_PRUNE_COPY_QUEUE* = 0x00000020 + SPQ_SCAN_USE_CALLBACK_SIGNERINFO* = 0x00000040 + SPQ_SCAN_PRUNE_DELREN* = 0x00000080 + SPQ_DELAYED_COPY* = 0x00000001 + SPQ_FLAG_BACKUP_AWARE* = 0x00000001 + SPQ_FLAG_ABORT_IF_UNSIGNED* = 0x00000002 + SPQ_FLAG_FILES_MODIFIED* = 0x00000004 + SPQ_FLAG_VALID* = 0x00000007 + SPOST_NONE* = 0 + SPOST_PATH* = 1 + SPOST_URL* = 2 + SPOST_MAX* = 3 + SUOI_FORCEDELETE* = 0x00000001 + SPDSL_IGNORE_DISK* = 0x00000001 + SPDSL_DISALLOW_NEGATIVE_ADJUST* = 0x00000002 + SPFILEQ_FILE_IN_USE* = 0x00000001 + SPFILEQ_REBOOT_RECOMMENDED* = 0x00000002 + SPFILEQ_REBOOT_IN_PROGRESS* = 0x00000004 + FLG_ADDREG_DELREG_BIT* = 0x00008000 + FLG_ADDREG_BINVALUETYPE* = 0x00000001 + FLG_ADDREG_NOCLOBBER* = 0x00000002 + FLG_ADDREG_DELVAL* = 0x00000004 + FLG_ADDREG_APPEND* = 0x00000008 + FLG_ADDREG_KEYONLY* = 0x00000010 + FLG_ADDREG_OVERWRITEONLY* = 0x00000020 + FLG_ADDREG_64BITKEY* = 0x00001000 + FLG_ADDREG_KEYONLY_COMMON* = 0x00002000 + FLG_ADDREG_32BITKEY* = 0x00004000 + FLG_ADDREG_TYPE_MASK* = 0xFFFF0000'i32 or FLG_ADDREG_BINVALUETYPE + FLG_ADDREG_TYPE_SZ* = 0x00000000 + FLG_ADDREG_TYPE_MULTI_SZ* = 0x00010000 + FLG_ADDREG_TYPE_EXPAND_SZ* = 0x00020000 + FLG_ADDREG_TYPE_BINARY* = 0x00000000 or FLG_ADDREG_BINVALUETYPE + FLG_ADDREG_TYPE_DWORD* = 0x00010000 or FLG_ADDREG_BINVALUETYPE + FLG_ADDREG_TYPE_NONE* = 0x00020000 or FLG_ADDREG_BINVALUETYPE + FLG_DELREG_VALUE* = 0x00000000 + FLG_DELREG_TYPE_MASK* = FLG_ADDREG_TYPE_MASK + FLG_DELREG_TYPE_SZ* = FLG_ADDREG_TYPE_SZ + FLG_DELREG_TYPE_MULTI_SZ* = FLG_ADDREG_TYPE_MULTI_SZ + FLG_DELREG_TYPE_EXPAND_SZ* = FLG_ADDREG_TYPE_EXPAND_SZ + FLG_DELREG_TYPE_BINARY* = FLG_ADDREG_TYPE_BINARY + FLG_DELREG_TYPE_DWORD* = FLG_ADDREG_TYPE_DWORD + FLG_DELREG_TYPE_NONE* = FLG_ADDREG_TYPE_NONE + FLG_DELREG_64BITKEY* = FLG_ADDREG_64BITKEY + FLG_DELREG_KEYONLY_COMMON* = FLG_ADDREG_KEYONLY_COMMON + FLG_DELREG_32BITKEY* = FLG_ADDREG_32BITKEY + FLG_DELREG_OPERATION_MASK* = 0x000000FE + FLG_DELREG_MULTI_SZ_DELSTRING* = FLG_DELREG_TYPE_MULTI_SZ or FLG_ADDREG_DELREG_BIT or 0x00000002 + FLG_BITREG_CLEARBITS* = 0x00000000 + FLG_BITREG_SETBITS* = 0x00000001 + FLG_BITREG_64BITKEY* = 0x00001000 + FLG_BITREG_32BITKEY* = 0x00004000 + FLG_INI2REG_64BITKEY* = 0x00001000 + FLG_INI2REG_32BITKEY* = 0x00004000 + FLG_REGSVR_DLLREGISTER* = 0x00000001 + FLG_REGSVR_DLLINSTALL* = 0x00000002 + FLG_PROFITEM_CURRENTUSER* = 0x00000001 + FLG_PROFITEM_DELETE* = 0x00000002 + FLG_PROFITEM_GROUP* = 0x00000004 + FLG_PROFITEM_CSIDL* = 0x00000008 + SPINST_LOGCONFIG* = 0x00000001 + SPINST_INIFILES* = 0x00000002 + SPINST_REGISTRY* = 0x00000004 + SPINST_INI2REG* = 0x00000008 + SPINST_FILES* = 0x00000010 + SPINST_BITREG* = 0x00000020 + SPINST_REGSVR* = 0x00000040 + SPINST_UNREGSVR* = 0x00000080 + SPINST_PROFILEITEMS* = 0x00000100 + SPINST_COPYINF* = 0x00000200 + SPINST_ALL* = 0x000003ff + SPINST_SINGLESECTION* = 0x00010000 + SPINST_LOGCONFIG_IS_FORCED* = 0x00020000 + SPINST_LOGCONFIGS_ARE_OVERRIDES* = 0x00040000 + SPINST_REGISTERCALLBACKAWARE* = 0x00080000 + SPSVCINST_TAGTOFRONT* = 0x00000001 + SPSVCINST_ASSOCSERVICE* = 0x00000002 + SPSVCINST_DELETEEVENTLOGENTRY* = 0x00000004 + SPSVCINST_NOCLOBBER_DISPLAYNAME* = 0x00000008 + SPSVCINST_NOCLOBBER_STARTTYPE* = 0x00000010 + SPSVCINST_NOCLOBBER_ERRORCONTROL* = 0x00000020 + SPSVCINST_NOCLOBBER_LOADORDERGROUP* = 0x00000040 + SPSVCINST_NOCLOBBER_DEPENDENCIES* = 0x00000080 + SPSVCINST_NOCLOBBER_DESCRIPTION* = 0x00000100 + SPSVCINST_STOPSERVICE* = 0x00000200 + SPSVCINST_CLOBBER_SECURITY* = 0x00000400 + SPFILELOG_SYSTEMLOG* = 0x00000001 + SPFILELOG_FORCENEW* = 0x00000002 + SPFILELOG_QUERYONLY* = 0x00000004 + SPFILELOG_OEMFILE* = 0x00000001 + setupFileLogSourceFilename* = 0 + setupFileLogChecksum* = 1 + setupFileLogDiskTagfile* = 2 + setupFileLogDiskDescription* = 3 + setupFileLogOtherInfo* = 4 + setupFileLogMax* = 5 + logSevInformation* = 0x00000000 + logSevWarning* = 0x00000001 + logSevError* = 0x00000002 + logSevFatalError* = 0x00000003 + logSevMaximum* = 0x00000004 + DICD_GENERATE_ID* = 0x00000001 + DICD_INHERIT_CLASSDRVS* = 0x00000002 + DIOD_INHERIT_CLASSDRVS* = 0x00000002 + DIOD_CANCEL_REMOVE* = 0x00000004 + DIODI_NO_ADD* = 0x00000001 + SPRDI_FIND_DUPS* = 0x00000001 + SPDIT_NODRIVER* = 0x00000000 + SPDIT_CLASSDRIVER* = 0x00000001 + SPDIT_COMPATDRIVER* = 0x00000002 + DIGCF_DEFAULT* = 0x00000001 + DIGCF_PRESENT* = 0x00000002 + DIGCF_ALLCLASSES* = 0x00000004 + DIGCF_PROFILE* = 0x00000008 + DIGCF_DEVICEINTERFACE* = 0x00000010 + DIGCF_INTERFACEDEVICE* = DIGCF_DEVICEINTERFACE + DIBCI_NOINSTALLCLASS* = 0x00000001 + DIBCI_NODISPLAYCLASS* = 0x00000002 + DIOCR_INSTALLER* = 0x00000001 + DIOCR_INTERFACE* = 0x00000002 + DIREG_DEV* = 0x00000001 + DIREG_DRV* = 0x00000002 + DIREG_BOTH* = 0x00000004 + SPDRP_DEVICEDESC* = 0x00000000 + SPDRP_HARDWAREID* = 0x00000001 + SPDRP_COMPATIBLEIDS* = 0x00000002 + SPDRP_UNUSED0* = 0x00000003 + SPDRP_SERVICE* = 0x00000004 + SPDRP_UNUSED1* = 0x00000005 + SPDRP_UNUSED2* = 0x00000006 + SPDRP_CLASS* = 0x00000007 + SPDRP_CLASSGUID* = 0x00000008 + SPDRP_DRIVER* = 0x00000009 + SPDRP_CONFIGFLAGS* = 0x0000000A + SPDRP_MFG* = 0x0000000B + SPDRP_FRIENDLYNAME* = 0x0000000C + SPDRP_LOCATION_INFORMATION* = 0x0000000D + SPDRP_PHYSICAL_DEVICE_OBJECT_NAME* = 0x0000000E + SPDRP_CAPABILITIES* = 0x0000000F + SPDRP_UI_NUMBER* = 0x00000010 + SPDRP_UPPERFILTERS* = 0x00000011 + SPDRP_LOWERFILTERS* = 0x00000012 + SPDRP_BUSTYPEGUID* = 0x00000013 + SPDRP_LEGACYBUSTYPE* = 0x00000014 + SPDRP_BUSNUMBER* = 0x00000015 + SPDRP_ENUMERATOR_NAME* = 0x00000016 + SPDRP_SECURITY* = 0x00000017 + SPDRP_SECURITY_SDS* = 0x00000018 + SPDRP_DEVTYPE* = 0x00000019 + SPDRP_EXCLUSIVE* = 0x0000001A + SPDRP_CHARACTERISTICS* = 0x0000001B + SPDRP_ADDRESS* = 0x0000001C + SPDRP_UI_NUMBER_DESC_FORMAT* = 0X0000001D + SPDRP_DEVICE_POWER_DATA* = 0x0000001E + SPDRP_REMOVAL_POLICY* = 0x0000001F + SPDRP_REMOVAL_POLICY_HW_DEFAULT* = 0x00000020 + SPDRP_REMOVAL_POLICY_OVERRIDE* = 0x00000021 + SPDRP_INSTALL_STATE* = 0x00000022 + SPDRP_LOCATION_PATHS* = 0x00000023 + SPDRP_MAXIMUM_PROPERTY* = 0x00000024 + SPCRP_SECURITY* = 0x00000017 + SPCRP_SECURITY_SDS* = 0x00000018 + SPCRP_DEVTYPE* = 0x00000019 + SPCRP_EXCLUSIVE* = 0x0000001A + SPCRP_CHARACTERISTICS* = 0x0000001B + SPCRP_MAXIMUM_PROPERTY* = 0x0000001C + DMI_MASK* = 0x00000001 + DMI_BKCOLOR* = 0x00000002 + DMI_USERECT* = 0x00000004 + DIGCDP_FLAG_BASIC* = 0x00000001 + DIGCDP_FLAG_ADVANCED* = 0x00000002 + DIGCDP_FLAG_REMOTE_BASIC* = 0x00000003 + DIGCDP_FLAG_REMOTE_ADVANCED* = 0x00000004 + IDI_RESOURCEFIRST* = 159 + IDI_RESOURCE* = 159 + IDI_RESOURCELAST* = 161 + IDI_RESOURCEOVERLAYFIRST* = 161 + IDI_RESOURCEOVERLAYLAST* = 161 + IDI_CONFLICT* = 161 + IDI_CLASSICON_OVERLAYFIRST* = 500 + IDI_CLASSICON_OVERLAYLAST* = 502 + IDI_PROBLEM_OVL* = 500 + IDI_DISABLED_OVL* = 501 + IDI_FORCED_OVL* = 502 + SPWPT_SELECTDEVICE* = 0x00000001 + SPWP_USE_DEVINFO_DATA* = 0x00000001 + DICUSTOMDEVPROP_MERGE_MULTISZ* = 0x00000001 + SCWMI_CLOBBER_SECURITY* = 0x00000001 +type + PSP_DETSIG_CMPPROC* = proc (DeviceInfoSet: HDEVINFO, NewDeviceData: PSP_DEVINFO_DATA, ExistingDeviceData: PSP_DEVINFO_DATA, CompareContext: PVOID): DWORD {.stdcall.} +proc SetupGetInfInformationA*(InfSpec: LPCVOID, SearchControl: DWORD, ReturnBuffer: PSP_INF_INFORMATION, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetInfInformationW*(InfSpec: LPCVOID, SearchControl: DWORD, ReturnBuffer: PSP_INF_INFORMATION, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfFileInformationA*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfFileInformationW*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfOriginalFileInformationA*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfOriginalFileInformationW*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfVersionInformationA*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, Key: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryInfVersionInformationW*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, Key: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetInfFileListA*(DirectoryPath: PCSTR, InfStyle: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetInfFileListW*(DirectoryPath: PCWSTR, InfStyle: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenInfFileW*(FileName: PCWSTR, InfClass: PCWSTR, InfStyle: DWORD, ErrorLine: PUINT): HINF {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenInfFileA*(FileName: PCSTR, InfClass: PCSTR, InfStyle: DWORD, ErrorLine: PUINT): HINF {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenMasterInf*(): HINF {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenAppendInfFileW*(FileName: PCWSTR, InfHandle: HINF, ErrorLine: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenAppendInfFileA*(FileName: PCSTR, InfHandle: HINF, ErrorLine: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCloseInfFile*(InfHandle: HINF): VOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFindFirstLineA*(InfHandle: HINF, Section: PCSTR, Key: PCSTR, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFindFirstLineW*(InfHandle: HINF, Section: PCWSTR, Key: PCWSTR, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFindNextLine*(ContextIn: PINFCONTEXT, ContextOut: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFindNextMatchLineA*(ContextIn: PINFCONTEXT, Key: PCSTR, ContextOut: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFindNextMatchLineW*(ContextIn: PINFCONTEXT, Key: PCWSTR, ContextOut: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineByIndexA*(InfHandle: HINF, Section: PCSTR, Index: DWORD, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineByIndexW*(InfHandle: HINF, Section: PCWSTR, Index: DWORD, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineCountA*(InfHandle: HINF, Section: PCSTR): LONG {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineCountW*(InfHandle: HINF, Section: PCWSTR): LONG {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineTextA*(Context: PINFCONTEXT, InfHandle: HINF, Section: PCSTR, Key: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetLineTextW*(Context: PINFCONTEXT, InfHandle: HINF, Section: PCWSTR, Key: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFieldCount*(Context: PINFCONTEXT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetStringFieldA*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetStringFieldW*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetIntField*(Context: PINFCONTEXT, FieldIndex: DWORD, IntegerValue: PINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetMultiSzFieldA*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetMultiSzFieldW*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetBinaryField*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PBYTE, ReturnBufferSize: DWORD, RequiredSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileCompressionInfoA*(SourceFileName: PCSTR, ActualSourceFileName: ptr PSTR, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileCompressionInfoW*(SourceFileName: PCWSTR, ActualSourceFileName: ptr PWSTR, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileCompressionInfoExA*(SourceFileName: PCSTR, ActualSourceFileNameBuffer: PSTR, ActualSourceFileNameBufferLen: DWORD, RequiredBufferLen: PDWORD, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileCompressionInfoExW*(SourceFileName: PCWSTR, ActualSourceFileNameBuffer: PWSTR, ActualSourceFileNameBufferLen: DWORD, RequiredBufferLen: PDWORD, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDecompressOrCopyFileA*(SourceFileName: PCSTR, TargetFileName: PCSTR, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDecompressOrCopyFileW*(SourceFileName: PCWSTR, TargetFileName: PCWSTR, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceFileLocationA*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCSTR, SourceId: PUINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceFileLocationW*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCWSTR, SourceId: PUINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceFileSizeA*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCSTR, Section: PCSTR, FileSize: PDWORD, RoundingFactor: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceFileSizeW*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCWSTR, Section: PCWSTR, FileSize: PDWORD, RoundingFactor: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetTargetPathA*(InfHandle: HINF, InfContext: PINFCONTEXT, Section: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetTargetPathW*(InfHandle: HINF, InfContext: PINFCONTEXT, Section: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetSourceListA*(Flags: DWORD, SourceList: ptr PCSTR, SourceCount: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetSourceListW*(Flags: DWORD, SourceList: ptr PCWSTR, SourceCount: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCancelTemporarySourceList*(): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddToSourceListA*(Flags: DWORD, Source: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddToSourceListW*(Flags: DWORD, Source: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFromSourceListA*(Flags: DWORD, Source: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFromSourceListW*(Flags: DWORD, Source: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQuerySourceListA*(Flags: DWORD, List: ptr ptr PCSTR, Count: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQuerySourceListW*(Flags: DWORD, List: ptr ptr PCWSTR, Count: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFreeSourceListA*(List: ptr ptr PCSTR, Count: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupFreeSourceListW*(List: ptr ptr PCWSTR, Count: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupPromptForDiskA*(hwndParent: HWND, DialogTitle: PCSTR, DiskName: PCSTR, PathToSource: PCSTR, FileSought: PCSTR, TagFile: PCSTR, DiskPromptStyle: DWORD, PathBuffer: PSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupPromptForDiskW*(hwndParent: HWND, DialogTitle: PCWSTR, DiskName: PCWSTR, PathToSource: PCWSTR, FileSought: PCWSTR, TagFile: PCWSTR, DiskPromptStyle: DWORD, PathBuffer: PWSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCopyErrorA*(hwndParent: HWND, DialogTitle: PCSTR, DiskName: PCSTR, PathToSource: PCSTR, SourceFile: PCSTR, TargetPathFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD, PathBuffer: PSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCopyErrorW*(hwndParent: HWND, DialogTitle: PCWSTR, DiskName: PCWSTR, PathToSource: PCWSTR, SourceFile: PCWSTR, TargetPathFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD, PathBuffer: PWSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRenameErrorA*(hwndParent: HWND, DialogTitle: PCSTR, SourceFile: PCSTR, TargetFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRenameErrorW*(hwndParent: HWND, DialogTitle: PCWSTR, SourceFile: PCWSTR, TargetFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDeleteErrorA*(hwndParent: HWND, DialogTitle: PCSTR, File: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDeleteErrorW*(hwndParent: HWND, DialogTitle: PCWSTR, File: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupBackupErrorA*(hwndParent: HWND, DialogTitle: PCSTR, SourceFile: PCSTR, TargetFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupBackupErrorW*(hwndParent: HWND, DialogTitle: PCWSTR, SourceFile: PCWSTR, TargetFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetDirectoryIdA*(InfHandle: HINF, Id: DWORD, Directory: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetDirectoryIdW*(InfHandle: HINF, Id: DWORD, Directory: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetDirectoryIdExA*(InfHandle: HINF, Id: DWORD, Directory: PCSTR, Flags: DWORD, Reserved1: DWORD, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetDirectoryIdExW*(InfHandle: HINF, Id: DWORD, Directory: PCWSTR, Flags: DWORD, Reserved1: DWORD, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceInfoA*(InfHandle: HINF, SourceId: UINT, InfoDesired: UINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetSourceInfoW*(InfHandle: HINF, SourceId: UINT, InfoDesired: UINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFileA*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCSTR, SourcePathRoot: PCSTR, DestinationName: PCSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFileW*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCWSTR, SourcePathRoot: PCWSTR, DestinationName: PCWSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFileExA*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCSTR, SourcePathRoot: PCSTR, DestinationName: PCSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID, FileWasInUse: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFileExW*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCWSTR, SourcePathRoot: PCWSTR, DestinationName: PCWSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID, FileWasInUse: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenFileQueue*(): HSPFILEQ {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCloseFileQueue*(QueueHandle: HSPFILEQ): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetFileQueueAlternatePlatformA*(QueueHandle: HSPFILEQ, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, AlternateDefaultCatalogFile: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetFileQueueAlternatePlatformW*(QueueHandle: HSPFILEQ, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, AlternateDefaultCatalogFile: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetPlatformPathOverrideA*(Override: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetPlatformPathOverrideW*(Override: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopyA*(QueueHandle: HSPFILEQ, SourceRootPath: PCSTR, SourcePath: PCSTR, SourceFilename: PCSTR, SourceDescription: PCSTR, SourceTagfile: PCSTR, TargetDirectory: PCSTR, TargetFilename: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopyW*(QueueHandle: HSPFILEQ, SourceRootPath: PCWSTR, SourcePath: PCWSTR, SourceFilename: PCWSTR, SourceDescription: PCWSTR, SourceTagfile: PCWSTR, TargetDirectory: PCWSTR, TargetFilename: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopyIndirectA*(CopyParams: PSP_FILE_COPY_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopyIndirectW*(CopyParams: PSP_FILE_COPY_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDefaultCopyA*(QueueHandle: HSPFILEQ, InfHandle: HINF, SourceRootPath: PCSTR, SourceFilename: PCSTR, TargetFilename: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDefaultCopyW*(QueueHandle: HSPFILEQ, InfHandle: HINF, SourceRootPath: PCWSTR, SourceFilename: PCWSTR, TargetFilename: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopySectionA*(QueueHandle: HSPFILEQ, SourceRootPath: PCSTR, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueCopySectionW*(QueueHandle: HSPFILEQ, SourceRootPath: PCWSTR, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDeleteA*(QueueHandle: HSPFILEQ, PathPart1: PCSTR, PathPart2: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDeleteW*(QueueHandle: HSPFILEQ, PathPart1: PCWSTR, PathPart2: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDeleteSectionA*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueDeleteSectionW*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueRenameA*(QueueHandle: HSPFILEQ, SourcePath: PCSTR, SourceFilename: PCSTR, TargetPath: PCSTR, TargetFilename: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueRenameW*(QueueHandle: HSPFILEQ, SourcePath: PCWSTR, SourceFilename: PCWSTR, TargetPath: PCWSTR, TargetFilename: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueRenameSectionA*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueueRenameSectionW*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCommitFileQueueA*(Owner: HWND, QueueHandle: HSPFILEQ, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCommitFileQueueW*(Owner: HWND, QueueHandle: HSPFILEQ, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupScanFileQueueA*(FileQueue: HSPFILEQ, Flags: DWORD, Window: HWND, CallbackRoutine: PSP_FILE_CALLBACK_A, CallbackContext: PVOID, Result: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupScanFileQueueW*(FileQueue: HSPFILEQ, Flags: DWORD, Window: HWND, CallbackRoutine: PSP_FILE_CALLBACK_W, CallbackContext: PVOID, Result: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileQueueCount*(FileQueue: HSPFILEQ, SubQueueFileOp: UINT, NumOperations: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetFileQueueFlags*(FileQueue: HSPFILEQ, Flags: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetFileQueueFlags*(FileQueue: HSPFILEQ, FlagMask: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCopyOEMInfA*(SourceInfFileName: PCSTR, OEMSourceMediaLocation: PCSTR, OEMSourceMediaType: DWORD, CopyStyle: DWORD, DestinationInfFileName: PSTR, DestinationInfFileNameSize: DWORD, RequiredSize: PDWORD, DestinationInfFileNameComponent: ptr PSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCopyOEMInfW*(SourceInfFileName: PCWSTR, OEMSourceMediaLocation: PCWSTR, OEMSourceMediaType: DWORD, CopyStyle: DWORD, DestinationInfFileName: PWSTR, DestinationInfFileNameSize: DWORD, RequiredSize: PDWORD, DestinationInfFileNameComponent: ptr PWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupUninstallOEMInfA*(InfFileName: PCSTR, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupUninstallOEMInfW*(InfFileName: PCWSTR, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupUninstallNewlyCopiedInfs*(FileQueue: HSPFILEQ, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCreateDiskSpaceListA*(Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCreateDiskSpaceListW*(Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDuplicateDiskSpaceListA*(DiskSpace: HDSKSPC, Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDuplicateDiskSpaceListW*(DiskSpace: HDSKSPC, Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDestroyDiskSpaceList*(DiskSpace: HDSKSPC): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryDrivesInDiskSpaceListA*(DiskSpace: HDSKSPC, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryDrivesInDiskSpaceListW*(DiskSpace: HDSKSPC, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQuerySpaceRequiredOnDriveA*(DiskSpace: HDSKSPC, DriveSpec: PCSTR, SpaceRequired: ptr LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQuerySpaceRequiredOnDriveW*(DiskSpace: HDSKSPC, DriveSpec: PCWSTR, SpaceRequired: ptr LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAdjustDiskSpaceListA*(DiskSpace: HDSKSPC, DriveRoot: LPCSTR, Amount: LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAdjustDiskSpaceListW*(DiskSpace: HDSKSPC, DriveRoot: LPCWSTR, Amount: LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddToDiskSpaceListA*(DiskSpace: HDSKSPC, TargetFilespec: PCSTR, FileSize: LONGLONG, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddToDiskSpaceListW*(DiskSpace: HDSKSPC, TargetFilespec: PCWSTR, FileSize: LONGLONG, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddSectionToDiskSpaceListA*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddSectionToDiskSpaceListW*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddInstallSectionToDiskSpaceListA*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupAddInstallSectionToDiskSpaceListW*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCWSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFromDiskSpaceListA*(DiskSpace: HDSKSPC, TargetFilespec: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFromDiskSpaceListW*(DiskSpace: HDSKSPC, TargetFilespec: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveSectionFromDiskSpaceListA*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveSectionFromDiskSpaceListW*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveInstallSectionFromDiskSpaceListA*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveInstallSectionFromDiskSpaceListW*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCWSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupIterateCabinetA*(CabinetFile: PCSTR, Reserved: DWORD, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupIterateCabinetW*(CabinetFile: PCWSTR, Reserved: DWORD, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupPromptReboot*(FileQueue: HSPFILEQ, Owner: HWND, ScanOnly: WINBOOL): INT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInitDefaultQueueCallback*(OwnerWindow: HWND): PVOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInitDefaultQueueCallbackEx*(OwnerWindow: HWND, AlternateProgressWindow: HWND, ProgressMessage: UINT, Reserved1: DWORD, Reserved2: PVOID): PVOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupTermDefaultQueueCallback*(Context: PVOID): VOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDefaultQueueCallbackA*(Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDefaultQueueCallbackW*(Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFromInfSectionA*(Owner: HWND, InfHandle: HINF, SectionName: PCSTR, Flags: UINT, RelativeKeyRoot: HKEY, SourceRootPath: PCSTR, CopyFlags: UINT, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFromInfSectionW*(Owner: HWND, InfHandle: HINF, SectionName: PCWSTR, Flags: UINT, RelativeKeyRoot: HKEY, SourceRootPath: PCWSTR, CopyFlags: UINT, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFilesFromInfSectionA*(InfHandle: HINF, LayoutInfHandle: HINF, FileQueue: HSPFILEQ, SectionName: PCSTR, SourceRootPath: PCSTR, CopyFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallFilesFromInfSectionW*(InfHandle: HINF, LayoutInfHandle: HINF, FileQueue: HSPFILEQ, SectionName: PCWSTR, SourceRootPath: PCWSTR, CopyFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallServicesFromInfSectionA*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallServicesFromInfSectionW*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallServicesFromInfSectionExA*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInstallServicesFromInfSectionExW*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc InstallHinfSectionA*(Window: HWND, ModuleHandle: HINSTANCE, CommandLine: PCSTR, ShowCommand: INT): VOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc InstallHinfSectionW*(Window: HWND, ModuleHandle: HINSTANCE, CommandLine: PCWSTR, ShowCommand: INT): VOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInitializeFileLogA*(LogFileName: PCSTR, Flags: DWORD): HSPFILELOG {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupInitializeFileLogW*(LogFileName: PCWSTR, Flags: DWORD): HSPFILELOG {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupTerminateFileLog*(FileLogHandle: HSPFILELOG): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupLogFileA*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, SourceFilename: PCSTR, TargetFilename: PCSTR, Checksum: DWORD, DiskTagfile: PCSTR, DiskDescription: PCSTR, OtherInfo: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupLogFileW*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, SourceFilename: PCWSTR, TargetFilename: PCWSTR, Checksum: DWORD, DiskTagfile: PCWSTR, DiskDescription: PCWSTR, OtherInfo: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFileLogEntryA*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, TargetFilename: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupRemoveFileLogEntryW*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, TargetFilename: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryFileLogA*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, TargetFilename: PCSTR, DesiredInfo: SetupFileLogInfo, DataOut: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupQueryFileLogW*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, TargetFilename: PCWSTR, DesiredInfo: SetupFileLogInfo, DataOut: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupOpenLog*(Erase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupLogErrorA*(MessageString: LPCSTR, Severity: LogSeverity): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupLogErrorW*(MessageString: LPCWSTR, Severity: LogSeverity): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupCloseLog*(): VOID {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetBackupInformationA*(QueueHandle: HSPFILEQ, BackupParams: PSP_BACKUP_QUEUE_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetBackupInformationW*(QueueHandle: HSPFILEQ, BackupParams: PSP_BACKUP_QUEUE_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupPrepareQueueForRestoreA*(QueueHandle: HSPFILEQ, BackupPath: PCSTR, RestoreFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupPrepareQueueForRestoreW*(QueueHandle: HSPFILEQ, BackupPath: PCWSTR, RestoreFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupSetNonInteractiveMode*(NonInteractiveFlag: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupGetNonInteractiveMode*(): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInfoList*(ClassGuid: ptr GUID, hwndParent: HWND): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInfoListExA*(ClassGuid: ptr GUID, hwndParent: HWND, MachineName: PCSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInfoListExW*(ClassGuid: ptr GUID, hwndParent: HWND, MachineName: PCWSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInfoListClass*(DeviceInfoSet: HDEVINFO, ClassGuid: LPGUID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInfoListDetailA*(DeviceInfoSet: HDEVINFO, DeviceInfoSetDetailData: PSP_DEVINFO_LIST_DETAIL_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInfoListDetailW*(DeviceInfoSet: HDEVINFO, DeviceInfoSetDetailData: PSP_DEVINFO_LIST_DETAIL_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInfoA*(DeviceInfoSet: HDEVINFO, DeviceName: PCSTR, ClassGuid: ptr GUID, DeviceDescription: PCSTR, hwndParent: HWND, CreationFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInfoW*(DeviceInfoSet: HDEVINFO, DeviceName: PCWSTR, ClassGuid: ptr GUID, DeviceDescription: PCWSTR, hwndParent: HWND, CreationFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenDeviceInfoA*(DeviceInfoSet: HDEVINFO, DeviceInstanceId: PCSTR, hwndParent: HWND, OpenFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenDeviceInfoW*(DeviceInfoSet: HDEVINFO, DeviceInstanceId: PCWSTR, hwndParent: HWND, OpenFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInstanceIdA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstanceId: PSTR, DeviceInstanceIdSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInstanceIdW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstanceId: PWSTR, DeviceInstanceIdSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDeleteDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiEnumDeviceInfo*(DeviceInfoSet: HDEVINFO, MemberIndex: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDestroyDeviceInfoList*(DeviceInfoSet: HDEVINFO): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiEnumDeviceInterfaces*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, MemberIndex: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiEnumInterfaceDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, MemberIndex: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiEnumDeviceInterfaces".} +proc SetupDiCreateDeviceInterfaceA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInterfaceW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCWSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateInterfaceDeviceW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCWSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceW".} +proc SetupDiCreateInterfaceDeviceA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceA".} +proc SetupDiOpenDeviceInterfaceA*(DeviceInfoSet: HDEVINFO, DevicePath: PCSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenDeviceInterfaceW*(DeviceInfoSet: HDEVINFO, DevicePath: PCWSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenInterfaceDeviceW*(DeviceInfoSet: HDEVINFO, DevicePath: PCWSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceW".} +proc SetupDiOpenInterfaceDeviceA*(DeviceInfoSet: HDEVINFO, DevicePath: PCSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceA".} +proc SetupDiGetDeviceInterfaceAlias*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, AliasInterfaceClassGuid: ptr GUID, AliasDeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetInterfaceDeviceAlias*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, AliasInterfaceClassGuid: ptr GUID, AliasDeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceAlias".} +proc SetupDiDeleteDeviceInterfaceData*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDeleteInterfaceDeviceData*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiDeleteDeviceInterfaceData".} +proc SetupDiRemoveDeviceInterface*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiRemoveInterfaceDevice*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiRemoveDeviceInterface".} +proc SetupDiGetDeviceInterfaceDetailA*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInterfaceDetailW*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_W, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetInterfaceDeviceDetailW*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_W, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailW".} +proc SetupDiGetInterfaceDeviceDetailA*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailA".} +proc SetupDiInstallDeviceInterfaces*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallInterfaceDevices*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiInstallDeviceInterfaces".} +proc SetupDiSetDeviceInterfaceDefault*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiRegisterDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Flags: DWORD, CompareProc: PSP_DETSIG_CMPPROC, CompareContext: PVOID, DupDeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiBuildDriverInfoList*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCancelDriverInfoSearch*(DeviceInfoSet: HDEVINFO): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiEnumDriverInfoA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD, MemberIndex: DWORD, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiEnumDriverInfoW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD, MemberIndex: DWORD, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetSelectedDriverA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetSelectedDriverW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetSelectedDriverA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetSelectedDriverW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDriverInfoDetailA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInfoDetailData: PSP_DRVINFO_DETAIL_DATA_A, DriverInfoDetailDataSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDriverInfoDetailW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInfoDetailData: PSP_DRVINFO_DETAIL_DATA_W, DriverInfoDetailDataSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDestroyDriverInfoList*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevsA*(ClassGuid: ptr GUID, Enumerator: PCSTR, hwndParent: HWND, Flags: DWORD): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevsW*(ClassGuid: ptr GUID, Enumerator: PCWSTR, hwndParent: HWND, Flags: DWORD): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevsExA*(ClassGuid: ptr GUID, Enumerator: PCSTR, hwndParent: HWND, Flags: DWORD, DeviceInfoSet: HDEVINFO, MachineName: PCSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevsExW*(ClassGuid: ptr GUID, Enumerator: PCWSTR, hwndParent: HWND, Flags: DWORD, DeviceInfoSet: HDEVINFO, MachineName: PCWSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetINFClassA*(InfName: PCSTR, ClassGuid: LPGUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetINFClassW*(InfName: PCWSTR, ClassGuid: LPGUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiBuildClassInfoList*(Flags: DWORD, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiBuildClassInfoListExA*(Flags: DWORD, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiBuildClassInfoListExW*(Flags: DWORD, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDescriptionA*(ClassGuid: ptr GUID, ClassDescription: PSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDescriptionW*(ClassGuid: ptr GUID, ClassDescription: PWSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDescriptionExA*(ClassGuid: ptr GUID, ClassDescription: PSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDescriptionExW*(ClassGuid: ptr GUID, ClassDescription: PWSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCallClassInstaller*(InstallFunction: DI_FUNCTION, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSelectDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSelectBestCompatDrv*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallDriverFiles*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiRegisterCoDeviceInstallers*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiRemoveDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiUnremoveDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiRestartDevices*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiChangeState*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallClassA*(hwndParent: HWND, InfFileName: PCSTR, Flags: DWORD, FileQueue: HSPFILEQ): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallClassW*(hwndParent: HWND, InfFileName: PCWSTR, Flags: DWORD, FileQueue: HSPFILEQ): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallClassExA*(hwndParent: HWND, InfFileName: PCSTR, Flags: DWORD, FileQueue: HSPFILEQ, InterfaceClassGuid: ptr GUID, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiInstallClassExW*(hwndParent: HWND, InfFileName: PCWSTR, Flags: DWORD, FileQueue: HSPFILEQ, InterfaceClassGuid: ptr GUID, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenClassRegKey*(ClassGuid: ptr GUID, samDesired: REGSAM): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenClassRegKeyExA*(ClassGuid: ptr GUID, samDesired: REGSAM, Flags: DWORD, MachineName: PCSTR, Reserved: PVOID): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenClassRegKeyExW*(ClassGuid: ptr GUID, samDesired: REGSAM, Flags: DWORD, MachineName: PCWSTR, Reserved: PVOID): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInterfaceRegKeyA*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDeviceInterfaceRegKeyW*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateInterfaceDeviceRegKeyW*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyW".} +proc SetupDiCreateInterfaceDeviceRegKeyA*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyA".} +proc SetupDiOpenDeviceInterfaceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenInterfaceDeviceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceRegKey".} +proc SetupDiDeleteDeviceInterfaceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDeleteInterfaceDeviceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiDeleteDeviceInterfaceRegKey".} +proc SetupDiCreateDevRegKeyA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiCreateDevRegKeyW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiOpenDevRegKey*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD, samDesired: REGSAM): HKEY {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDeleteDevRegKey*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileList*(HwProfileList: PDWORD, HwProfileListSize: DWORD, RequiredSize: PDWORD, CurrentlyActiveIndex: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileListExA*(HwProfileList: PDWORD, HwProfileListSize: DWORD, RequiredSize: PDWORD, CurrentlyActiveIndex: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileListExW*(HwProfileList: PDWORD, HwProfileListSize: DWORD, RequiredSize: PDWORD, CurrentlyActiveIndex: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceRegistryPropertyA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceRegistryPropertyW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassRegistryPropertyA*(ClassGuid: ptr GUID, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassRegistryPropertyW*(ClassGuid: ptr GUID, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDeviceRegistryPropertyA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDeviceRegistryPropertyW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetClassRegistryPropertyA*(ClassGuid: ptr GUID, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetClassRegistryPropertyW*(ClassGuid: ptr GUID, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDeviceInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDeviceInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDeviceInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetClassInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetClassInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDriverInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetDriverInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDriverInstallParamsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetDriverInstallParamsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiLoadClassIcon*(ClassGuid: ptr GUID, LargeIcon: ptr HICON, MiniIconIndex: PINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDrawMiniIcon*(hdc: HDC, rc: RECT, MiniIconIndex: INT, Flags: DWORD): INT {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassBitmapIndex*(ClassGuid: ptr GUID, MiniIconIndex: PINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassImageList*(ClassImageListData: PSP_CLASSIMAGELIST_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassImageListExA*(ClassImageListData: PSP_CLASSIMAGELIST_DATA, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassImageListExW*(ClassImageListData: PSP_CLASSIMAGELIST_DATA, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassImageIndex*(ClassImageListData: PSP_CLASSIMAGELIST_DATA, ClassGuid: ptr GUID, ImageIndex: PINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiDestroyClassImageList*(ClassImageListData: PSP_CLASSIMAGELIST_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevPropertySheetsA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, PropertySheetHeader: LPPROPSHEETHEADERA, PropertySheetHeaderPageListSize: DWORD, RequiredSize: PDWORD, PropertySheetType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetClassDevPropertySheetsW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, PropertySheetHeader: LPPROPSHEETHEADERW, PropertySheetHeaderPageListSize: DWORD, RequiredSize: PDWORD, PropertySheetType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiAskForOEMDisk*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSelectOEMDrv*(hwndParent: HWND, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassNameFromGuidA*(ClassGuid: ptr GUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassNameFromGuidW*(ClassGuid: ptr GUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassNameFromGuidExA*(ClassGuid: ptr GUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassNameFromGuidExW*(ClassGuid: ptr GUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassGuidsFromNameA*(ClassName: PCSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassGuidsFromNameW*(ClassName: PCWSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassGuidsFromNameExA*(ClassName: PCSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiClassGuidsFromNameExW*(ClassName: PCWSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileFriendlyNameA*(HwProfile: DWORD, FriendlyName: PSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileFriendlyNameW*(HwProfile: DWORD, FriendlyName: PWSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileFriendlyNameExA*(HwProfile: DWORD, FriendlyName: PSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetHwProfileFriendlyNameExW*(HwProfile: DWORD, FriendlyName: PWSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetWizardPage*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InstallWizardData: PSP_INSTALLWIZARD_DATA, PageType: DWORD, Flags: DWORD): HPROPSHEETPAGE {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetSelectedDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiSetSelectedDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualModelsSectionA*(Context: PINFCONTEXT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualModelsSectionW*(Context: PINFCONTEXT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualSectionToInstallA*(InfHandle: HINF, InfSectionName: PCSTR, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualSectionToInstallW*(InfHandle: HINF, InfSectionName: PCWSTR, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualSectionToInstallExA*(InfHandle: HINF, InfSectionName: PCSTR, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetActualSectionToInstallExW*(InfHandle: HINF, InfSectionName: PCWSTR, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupEnumInfSectionsA*(InfHandle: HINF, Index: UINT, Buffer: PSTR, Size: UINT, SizeNeeded: ptr UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupEnumInfSectionsW*(InfHandle: HINF, Index: UINT, Buffer: PWSTR, Size: UINT, SizeNeeded: ptr UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupVerifyInfFileA*(InfName: PCSTR, AltPlatformInfo: PSP_ALTPLATFORM_INFO, InfSignerInfo: PSP_INF_SIGNER_INFO_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupVerifyInfFileW*(InfName: PCWSTR, AltPlatformInfo: PSP_ALTPLATFORM_INFO, InfSignerInfo: PSP_INF_SIGNER_INFO_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetCustomDevicePropertyA*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, CustomPropertyName: PCSTR, Flags: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupDiGetCustomDevicePropertyW*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, CustomPropertyName: PCWSTR, Flags: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupConfigureWmiFromInfSectionA*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc SetupConfigureWmiFromInfSectionW*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc.} +proc `Reserved=`*(self: var SP_ALTPLATFORM_INFO_V2, x: WORD) {.inline.} = self.union1.Reserved = x +proc Reserved*(self: SP_ALTPLATFORM_INFO_V2): WORD {.inline.} = self.union1.Reserved +proc Reserved*(self: var SP_ALTPLATFORM_INFO_V2): var WORD {.inline.} = self.union1.Reserved +proc `Flags=`*(self: var SP_ALTPLATFORM_INFO_V2, x: WORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: SP_ALTPLATFORM_INFO_V2): WORD {.inline.} = self.union1.Flags +proc Flags*(self: var SP_ALTPLATFORM_INFO_V2): var WORD {.inline.} = self.union1.Flags +when winimUnicode: + type + SP_ORIGINAL_FILE_INFO* = SP_ORIGINAL_FILE_INFO_W + PSP_ORIGINAL_FILE_INFO* = PSP_ORIGINAL_FILE_INFO_W + FILEPATHS* = FILEPATHS_W + PFILEPATHS* = PFILEPATHS_W + FILEPATHS_SIGNERINFO* = FILEPATHS_SIGNERINFO_W + PFILEPATHS_SIGNERINFO* = PFILEPATHS_SIGNERINFO_W + SOURCE_MEDIA* = SOURCE_MEDIA_W + PSOURCE_MEDIA* = PSOURCE_MEDIA_W + CABINET_INFO* = CABINET_INFO_W + PCABINET_INFO* = PCABINET_INFO_W + FILE_IN_CABINET_INFO* = FILE_IN_CABINET_INFO_W + PFILE_IN_CABINET_INFO* = PFILE_IN_CABINET_INFO_W + SP_REGISTER_CONTROL_STATUS* = SP_REGISTER_CONTROL_STATUSW + PSP_REGISTER_CONTROL_STATUS* = PSP_REGISTER_CONTROL_STATUSW + SP_FILE_COPY_PARAMS* = SP_FILE_COPY_PARAMS_W + PSP_FILE_COPY_PARAMS* = PSP_FILE_COPY_PARAMS_W + SP_DEVICE_INTERFACE_DETAIL_DATA* = SP_DEVICE_INTERFACE_DETAIL_DATA_W + PSP_DEVICE_INTERFACE_DETAIL_DATA* = PSP_DEVICE_INTERFACE_DETAIL_DATA_W + SP_INTERFACE_DEVICE_DETAIL_DATA* = SP_INTERFACE_DEVICE_DETAIL_DATA_W + PSP_INTERFACE_DEVICE_DETAIL_DATA* = PSP_INTERFACE_DEVICE_DETAIL_DATA_W + SP_DEVINFO_LIST_DETAIL_DATA* = SP_DEVINFO_LIST_DETAIL_DATA_W + PSP_DEVINFO_LIST_DETAIL_DATA* = PSP_DEVINFO_LIST_DETAIL_DATA_W + SP_DEVINSTALL_PARAMS* = SP_DEVINSTALL_PARAMS_W + PSP_DEVINSTALL_PARAMS* = PSP_DEVINSTALL_PARAMS_W + SP_SELECTDEVICE_PARAMS* = SP_SELECTDEVICE_PARAMS_W + PSP_SELECTDEVICE_PARAMS* = PSP_SELECTDEVICE_PARAMS_W + SP_TROUBLESHOOTER_PARAMS* = SP_TROUBLESHOOTER_PARAMS_W + PSP_TROUBLESHOOTER_PARAMS* = PSP_TROUBLESHOOTER_PARAMS_W + SP_POWERMESSAGEWAKE_PARAMS* = SP_POWERMESSAGEWAKE_PARAMS_W + PSP_POWERMESSAGEWAKE_PARAMS* = PSP_POWERMESSAGEWAKE_PARAMS_W + SP_DRVINFO_DATA_V1* = SP_DRVINFO_DATA_V1_W + PSP_DRVINFO_DATA_V1* = PSP_DRVINFO_DATA_V1_W + SP_DRVINFO_DETAIL_DATA* = SP_DRVINFO_DETAIL_DATA_W + PSP_DRVINFO_DETAIL_DATA* = PSP_DRVINFO_DETAIL_DATA_W + SP_BACKUP_QUEUE_PARAMS_V1* = SP_BACKUP_QUEUE_PARAMS_V1_W + PSP_BACKUP_QUEUE_PARAMS_V1* = PSP_BACKUP_QUEUE_PARAMS_V1_W + SP_INF_SIGNER_INFO* = SP_INF_SIGNER_INFO_W + PSP_INF_SIGNER_INFO* = PSP_INF_SIGNER_INFO_W + proc SetupGetInfInformation*(InfSpec: LPCVOID, SearchControl: DWORD, ReturnBuffer: PSP_INF_INFORMATION, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetInfInformationW".} + proc SetupQueryInfFileInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfFileInformationW".} + proc SetupQueryInfOriginalFileInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfOriginalFileInformationW".} + proc SetupQueryInfVersionInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, Key: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfVersionInformationW".} + proc SetupGetInfFileList*(DirectoryPath: PCWSTR, InfStyle: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetInfFileListW".} + proc SetupOpenInfFile*(FileName: PCWSTR, InfClass: PCWSTR, InfStyle: DWORD, ErrorLine: PUINT): HINF {.winapi, stdcall, dynlib: "setupapi", importc: "SetupOpenInfFileW".} + proc SetupOpenAppendInfFile*(FileName: PCWSTR, InfHandle: HINF, ErrorLine: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupOpenAppendInfFileW".} + proc SetupFindFirstLine*(InfHandle: HINF, Section: PCWSTR, Key: PCWSTR, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFindFirstLineW".} + proc SetupFindNextMatchLine*(ContextIn: PINFCONTEXT, Key: PCWSTR, ContextOut: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFindNextMatchLineW".} + proc SetupGetLineByIndex*(InfHandle: HINF, Section: PCWSTR, Index: DWORD, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineByIndexW".} + proc SetupGetLineCount*(InfHandle: HINF, Section: PCWSTR): LONG {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineCountW".} + proc SetupGetLineText*(Context: PINFCONTEXT, InfHandle: HINF, Section: PCWSTR, Key: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineTextW".} + proc SetupGetStringField*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetStringFieldW".} + proc SetupGetMultiSzField*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetMultiSzFieldW".} + proc SetupGetFileCompressionInfo*(SourceFileName: PCWSTR, ActualSourceFileName: ptr PWSTR, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetFileCompressionInfoW".} + proc SetupGetFileCompressionInfoEx*(SourceFileName: PCWSTR, ActualSourceFileNameBuffer: PWSTR, ActualSourceFileNameBufferLen: DWORD, RequiredBufferLen: PDWORD, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetFileCompressionInfoExW".} + proc SetupDecompressOrCopyFile*(SourceFileName: PCWSTR, TargetFileName: PCWSTR, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDecompressOrCopyFileW".} + proc SetupGetSourceFileLocation*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCWSTR, SourceId: PUINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceFileLocationW".} + proc SetupGetSourceFileSize*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCWSTR, Section: PCWSTR, FileSize: PDWORD, RoundingFactor: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceFileSizeW".} + proc SetupGetTargetPath*(InfHandle: HINF, InfContext: PINFCONTEXT, Section: PCWSTR, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetTargetPathW".} + proc SetupSetSourceList*(Flags: DWORD, SourceList: ptr PCWSTR, SourceCount: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetSourceListW".} + proc SetupAddToSourceList*(Flags: DWORD, Source: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddToSourceListW".} + proc SetupRemoveFromSourceList*(Flags: DWORD, Source: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFromSourceListW".} + proc SetupQuerySourceList*(Flags: DWORD, List: ptr ptr PCWSTR, Count: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQuerySourceListW".} + proc SetupFreeSourceList*(List: ptr ptr PCWSTR, Count: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFreeSourceListW".} + proc SetupPromptForDisk*(hwndParent: HWND, DialogTitle: PCWSTR, DiskName: PCWSTR, PathToSource: PCWSTR, FileSought: PCWSTR, TagFile: PCWSTR, DiskPromptStyle: DWORD, PathBuffer: PWSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupPromptForDiskW".} + proc SetupCopyError*(hwndParent: HWND, DialogTitle: PCWSTR, DiskName: PCWSTR, PathToSource: PCWSTR, SourceFile: PCWSTR, TargetPathFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD, PathBuffer: PWSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCopyErrorW".} + proc SetupRenameError*(hwndParent: HWND, DialogTitle: PCWSTR, SourceFile: PCWSTR, TargetFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRenameErrorW".} + proc SetupDeleteError*(hwndParent: HWND, DialogTitle: PCWSTR, File: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDeleteErrorW".} + proc SetupBackupError*(hwndParent: HWND, DialogTitle: PCWSTR, SourceFile: PCWSTR, TargetFile: PCWSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupBackupErrorW".} + proc SetupSetDirectoryId*(InfHandle: HINF, Id: DWORD, Directory: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetDirectoryIdW".} + proc SetupSetDirectoryIdEx*(InfHandle: HINF, Id: DWORD, Directory: PCWSTR, Flags: DWORD, Reserved1: DWORD, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetDirectoryIdExW".} + proc SetupGetSourceInfo*(InfHandle: HINF, SourceId: UINT, InfoDesired: UINT, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceInfoW".} + proc SetupInstallFile*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCWSTR, SourcePathRoot: PCWSTR, DestinationName: PCWSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFileW".} + proc SetupInstallFileEx*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCWSTR, SourcePathRoot: PCWSTR, DestinationName: PCWSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID, FileWasInUse: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFileExW".} + proc SetupSetFileQueueAlternatePlatform*(QueueHandle: HSPFILEQ, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, AlternateDefaultCatalogFile: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetFileQueueAlternatePlatformW".} + proc SetupQueueDeleteSection*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDeleteSectionW".} + proc SetupQueueRename*(QueueHandle: HSPFILEQ, SourcePath: PCWSTR, SourceFilename: PCWSTR, TargetPath: PCWSTR, TargetFilename: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueRenameW".} + proc SetupQueueRenameSection*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueRenameSectionW".} + proc SetupCommitFileQueue*(Owner: HWND, QueueHandle: HSPFILEQ, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCommitFileQueueW".} + proc SetupScanFileQueue*(FileQueue: HSPFILEQ, Flags: DWORD, Window: HWND, CallbackRoutine: PSP_FILE_CALLBACK_W, CallbackContext: PVOID, Result: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupScanFileQueueW".} + proc SetupSetPlatformPathOverride*(Override: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetPlatformPathOverrideW".} + proc SetupQueueCopy*(QueueHandle: HSPFILEQ, SourceRootPath: PCWSTR, SourcePath: PCWSTR, SourceFilename: PCWSTR, SourceDescription: PCWSTR, SourceTagfile: PCWSTR, TargetDirectory: PCWSTR, TargetFilename: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopyW".} + proc SetupQueueCopyIndirect*(CopyParams: PSP_FILE_COPY_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopyIndirectW".} + proc SetupQueueDefaultCopy*(QueueHandle: HSPFILEQ, InfHandle: HINF, SourceRootPath: PCWSTR, SourceFilename: PCWSTR, TargetFilename: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDefaultCopyW".} + proc SetupQueueCopySection*(QueueHandle: HSPFILEQ, SourceRootPath: PCWSTR, InfHandle: HINF, ListInfHandle: HINF, Section: PCWSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopySectionW".} + proc SetupQueueDelete*(QueueHandle: HSPFILEQ, PathPart1: PCWSTR, PathPart2: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDeleteW".} + proc SetupCopyOEMInf*(SourceInfFileName: PCWSTR, OEMSourceMediaLocation: PCWSTR, OEMSourceMediaType: DWORD, CopyStyle: DWORD, DestinationInfFileName: PWSTR, DestinationInfFileNameSize: DWORD, RequiredSize: PDWORD, DestinationInfFileNameComponent: ptr PWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCopyOEMInfW".} + proc SetupUninstallOEMInf*(InfFileName: PCWSTR, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupUninstallOEMInfW".} + proc SetupCreateDiskSpaceList*(Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCreateDiskSpaceListW".} + proc SetupDuplicateDiskSpaceList*(DiskSpace: HDSKSPC, Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDuplicateDiskSpaceListW".} + proc SetupQueryDrivesInDiskSpaceList*(DiskSpace: HDSKSPC, ReturnBuffer: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryDrivesInDiskSpaceListW".} + proc SetupQuerySpaceRequiredOnDrive*(DiskSpace: HDSKSPC, DriveSpec: PCWSTR, SpaceRequired: ptr LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQuerySpaceRequiredOnDriveW".} + proc SetupAdjustDiskSpaceList*(DiskSpace: HDSKSPC, DriveRoot: LPCWSTR, Amount: LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAdjustDiskSpaceListW".} + proc SetupAddToDiskSpaceList*(DiskSpace: HDSKSPC, TargetFilespec: PCWSTR, FileSize: LONGLONG, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddToDiskSpaceListW".} + proc SetupAddSectionToDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddSectionToDiskSpaceListW".} + proc SetupAddInstallSectionToDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCWSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddInstallSectionToDiskSpaceListW".} + proc SetupRemoveFromDiskSpaceList*(DiskSpace: HDSKSPC, TargetFilespec: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFromDiskSpaceListW".} + proc SetupRemoveSectionFromDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCWSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveSectionFromDiskSpaceListW".} + proc SetupRemoveInstallSectionFromDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCWSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveInstallSectionFromDiskSpaceListW".} + proc SetupIterateCabinet*(CabinetFile: PCWSTR, Reserved: DWORD, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupIterateCabinetW".} + proc SetupDefaultQueueCallback*(Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDefaultQueueCallbackW".} + proc SetupInstallFromInfSection*(Owner: HWND, InfHandle: HINF, SectionName: PCWSTR, Flags: UINT, RelativeKeyRoot: HKEY, SourceRootPath: PCWSTR, CopyFlags: UINT, MsgHandler: PSP_FILE_CALLBACK_W, Context: PVOID, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFromInfSectionW".} + proc SetupInstallFilesFromInfSection*(InfHandle: HINF, LayoutInfHandle: HINF, FileQueue: HSPFILEQ, SectionName: PCWSTR, SourceRootPath: PCWSTR, CopyFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFilesFromInfSectionW".} + proc SetupInstallServicesFromInfSection*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallServicesFromInfSectionW".} + proc SetupInstallServicesFromInfSectionEx*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallServicesFromInfSectionExW".} + proc InstallHinfSection*(Window: HWND, ModuleHandle: HINSTANCE, CommandLine: PCWSTR, ShowCommand: INT): VOID {.winapi, stdcall, dynlib: "setupapi", importc: "InstallHinfSectionW".} + proc SetupInitializeFileLog*(LogFileName: PCWSTR, Flags: DWORD): HSPFILELOG {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInitializeFileLogW".} + proc SetupLogFile*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, SourceFilename: PCWSTR, TargetFilename: PCWSTR, Checksum: DWORD, DiskTagfile: PCWSTR, DiskDescription: PCWSTR, OtherInfo: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupLogFileW".} + proc SetupRemoveFileLogEntry*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, TargetFilename: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFileLogEntryW".} + proc SetupQueryFileLog*(FileLogHandle: HSPFILELOG, LogSectionName: PCWSTR, TargetFilename: PCWSTR, DesiredInfo: SetupFileLogInfo, DataOut: PWSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryFileLogW".} + proc SetupLogError*(MessageString: LPCWSTR, Severity: LogSeverity): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupLogErrorW".} + proc SetupGetBackupInformation*(QueueHandle: HSPFILEQ, BackupParams: PSP_BACKUP_QUEUE_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetBackupInformationW".} + proc SetupPrepareQueueForRestore*(QueueHandle: HSPFILEQ, BackupPath: PCWSTR, RestoreFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupPrepareQueueForRestoreW".} + proc SetupDiCreateDeviceInfoListEx*(ClassGuid: ptr GUID, hwndParent: HWND, MachineName: PCWSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInfoListExW".} + proc SetupDiGetDeviceInfoListDetail*(DeviceInfoSet: HDEVINFO, DeviceInfoSetDetailData: PSP_DEVINFO_LIST_DETAIL_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInfoListDetailW".} + proc SetupDiCreateDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceName: PCWSTR, ClassGuid: ptr GUID, DeviceDescription: PCWSTR, hwndParent: HWND, CreationFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInfoW".} + proc SetupDiOpenDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceInstanceId: PCWSTR, hwndParent: HWND, OpenFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInfoW".} + proc SetupDiGetDeviceInstanceId*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstanceId: PWSTR, DeviceInstanceIdSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInstanceIdW".} + proc SetupDiCreateDeviceInterface*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCWSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceW".} + proc SetupDiCreateInterfaceDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCWSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceW".} + proc SetupDiOpenDeviceInterface*(DeviceInfoSet: HDEVINFO, DevicePath: PCWSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceW".} + proc SetupDiOpenInterfaceDevice*(DeviceInfoSet: HDEVINFO, DevicePath: PCWSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceW".} + proc SetupDiGetDeviceInterfaceDetail*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_W, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailW".} + proc SetupDiGetInterfaceDeviceDetail*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_W, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailW".} + proc SetupDiEnumDriverInfo*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD, MemberIndex: DWORD, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiEnumDriverInfoW".} + proc SetupDiGetSelectedDriver*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetSelectedDriverW".} + proc SetupDiSetSelectedDriver*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetSelectedDriverW".} + proc SetupDiGetDriverInfoDetail*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInfoDetailData: PSP_DRVINFO_DETAIL_DATA_W, DriverInfoDetailDataSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDriverInfoDetailW".} + proc SetupDiGetClassDevs*(ClassGuid: ptr GUID, Enumerator: PCWSTR, hwndParent: HWND, Flags: DWORD): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevsW".} + proc SetupDiGetClassDevsEx*(ClassGuid: ptr GUID, Enumerator: PCWSTR, hwndParent: HWND, Flags: DWORD, DeviceInfoSet: HDEVINFO, MachineName: PCWSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevsExW".} + proc SetupDiGetINFClass*(InfName: PCWSTR, ClassGuid: LPGUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetINFClassW".} + proc SetupDiBuildClassInfoListEx*(Flags: DWORD, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiBuildClassInfoListExW".} + proc SetupDiGetClassDescription*(ClassGuid: ptr GUID, ClassDescription: PWSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDescriptionW".} + proc SetupDiGetClassDescriptionEx*(ClassGuid: ptr GUID, ClassDescription: PWSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDescriptionExW".} + proc SetupDiInstallClass*(hwndParent: HWND, InfFileName: PCWSTR, Flags: DWORD, FileQueue: HSPFILEQ): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiInstallClassW".} + proc SetupDiInstallClassEx*(hwndParent: HWND, InfFileName: PCWSTR, Flags: DWORD, FileQueue: HSPFILEQ, InterfaceClassGuid: ptr GUID, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiInstallClassExW".} + proc SetupDiOpenClassRegKeyEx*(ClassGuid: ptr GUID, samDesired: REGSAM, Flags: DWORD, MachineName: PCWSTR, Reserved: PVOID): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenClassRegKeyExW".} + proc SetupDiCreateDeviceInterfaceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyW".} + proc SetupDiCreateInterfaceDeviceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyW".} + proc SetupDiCreateDevRegKey*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD, InfHandle: HINF, InfSectionName: PCWSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDevRegKeyW".} + proc SetupDiGetHwProfileListEx*(HwProfileList: PDWORD, HwProfileListSize: DWORD, RequiredSize: PDWORD, CurrentlyActiveIndex: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileListExW".} + proc SetupDiGetDeviceRegistryProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceRegistryPropertyW".} + proc SetupDiGetClassRegistryProperty*(ClassGuid: ptr GUID, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassRegistryPropertyW".} + proc SetupDiSetDeviceRegistryProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDeviceRegistryPropertyW".} + proc SetupDiSetClassRegistryProperty*(ClassGuid: ptr GUID, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetClassRegistryPropertyW".} + proc SetupDiGetDeviceInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInstallParamsW".} + proc SetupDiGetClassInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassInstallParamsW".} + proc SetupDiSetDeviceInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDeviceInstallParamsW".} + proc SetupDiSetClassInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetClassInstallParamsW".} + proc SetupDiGetDriverInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDriverInstallParamsW".} + proc SetupDiSetDriverInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_W, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDriverInstallParamsW".} + proc SetupDiGetClassImageListEx*(ClassImageListData: PSP_CLASSIMAGELIST_DATA, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassImageListExW".} + proc SetupDiGetClassDevPropertySheets*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, PropertySheetHeader: LPPROPSHEETHEADERW, PropertySheetHeaderPageListSize: DWORD, RequiredSize: PDWORD, PropertySheetType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevPropertySheetsW".} + proc SetupDiClassNameFromGuid*(ClassGuid: ptr GUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassNameFromGuidW".} + proc SetupDiClassNameFromGuidEx*(ClassGuid: ptr GUID, ClassName: PWSTR, ClassNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassNameFromGuidExW".} + proc SetupDiClassGuidsFromName*(ClassName: PCWSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassGuidsFromNameW".} + proc SetupDiClassGuidsFromNameEx*(ClassName: PCWSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassGuidsFromNameExW".} + proc SetupDiGetHwProfileFriendlyName*(HwProfile: DWORD, FriendlyName: PWSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileFriendlyNameW".} + proc SetupDiGetHwProfileFriendlyNameEx*(HwProfile: DWORD, FriendlyName: PWSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileFriendlyNameExW".} + proc SetupDiGetActualModelsSection*(Context: PINFCONTEXT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualModelsSectionW".} + proc SetupDiGetActualSectionToInstall*(InfHandle: HINF, InfSectionName: PCWSTR, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PWSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualSectionToInstallW".} + proc SetupDiGetActualSectionToInstallEx*(InfHandle: HINF, InfSectionName: PCWSTR, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PWSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PWSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualSectionToInstallExW".} + proc SetupEnumInfSections*(InfHandle: HINF, Index: UINT, Buffer: PWSTR, Size: UINT, SizeNeeded: ptr UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupEnumInfSectionsW".} + proc SetupVerifyInfFile*(InfName: PCWSTR, AltPlatformInfo: PSP_ALTPLATFORM_INFO, InfSignerInfo: PSP_INF_SIGNER_INFO_W): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupVerifyInfFileW".} + proc SetupDiGetCustomDeviceProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, CustomPropertyName: PCWSTR, Flags: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetCustomDevicePropertyW".} + proc SetupConfigureWmiFromInfSection*(InfHandle: HINF, SectionName: PCWSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupConfigureWmiFromInfSectionW".} +when winimAnsi: + type + SP_ORIGINAL_FILE_INFO* = SP_ORIGINAL_FILE_INFO_A + PSP_ORIGINAL_FILE_INFO* = PSP_ORIGINAL_FILE_INFO_A + FILEPATHS* = FILEPATHS_A + PFILEPATHS* = PFILEPATHS_A + FILEPATHS_SIGNERINFO* = FILEPATHS_SIGNERINFO_A + PFILEPATHS_SIGNERINFO* = PFILEPATHS_SIGNERINFO_A + SOURCE_MEDIA* = SOURCE_MEDIA_A + PSOURCE_MEDIA* = PSOURCE_MEDIA_A + CABINET_INFO* = CABINET_INFO_A + PCABINET_INFO* = PCABINET_INFO_A + FILE_IN_CABINET_INFO* = FILE_IN_CABINET_INFO_A + PFILE_IN_CABINET_INFO* = PFILE_IN_CABINET_INFO_A + SP_REGISTER_CONTROL_STATUS* = SP_REGISTER_CONTROL_STATUSA + PSP_REGISTER_CONTROL_STATUS* = PSP_REGISTER_CONTROL_STATUSA + SP_FILE_COPY_PARAMS* = SP_FILE_COPY_PARAMS_A + PSP_FILE_COPY_PARAMS* = PSP_FILE_COPY_PARAMS_A + SP_DEVICE_INTERFACE_DETAIL_DATA* = SP_DEVICE_INTERFACE_DETAIL_DATA_A + PSP_DEVICE_INTERFACE_DETAIL_DATA* = PSP_DEVICE_INTERFACE_DETAIL_DATA_A + SP_INTERFACE_DEVICE_DETAIL_DATA* = SP_INTERFACE_DEVICE_DETAIL_DATA_A + PSP_INTERFACE_DEVICE_DETAIL_DATA* = PSP_INTERFACE_DEVICE_DETAIL_DATA_A + SP_DEVINFO_LIST_DETAIL_DATA* = SP_DEVINFO_LIST_DETAIL_DATA_A + PSP_DEVINFO_LIST_DETAIL_DATA* = PSP_DEVINFO_LIST_DETAIL_DATA_A + SP_DEVINSTALL_PARAMS* = SP_DEVINSTALL_PARAMS_A + PSP_DEVINSTALL_PARAMS* = PSP_DEVINSTALL_PARAMS_A + SP_SELECTDEVICE_PARAMS* = SP_SELECTDEVICE_PARAMS_A + PSP_SELECTDEVICE_PARAMS* = PSP_SELECTDEVICE_PARAMS_A + SP_TROUBLESHOOTER_PARAMS* = SP_TROUBLESHOOTER_PARAMS_A + PSP_TROUBLESHOOTER_PARAMS* = PSP_TROUBLESHOOTER_PARAMS_A + SP_POWERMESSAGEWAKE_PARAMS* = SP_POWERMESSAGEWAKE_PARAMS_A + PSP_POWERMESSAGEWAKE_PARAMS* = PSP_POWERMESSAGEWAKE_PARAMS_A + SP_DRVINFO_DATA_V1* = SP_DRVINFO_DATA_V1_A + PSP_DRVINFO_DATA_V1* = PSP_DRVINFO_DATA_V1_A + SP_DRVINFO_DETAIL_DATA* = SP_DRVINFO_DETAIL_DATA_A + PSP_DRVINFO_DETAIL_DATA* = PSP_DRVINFO_DETAIL_DATA_A + SP_BACKUP_QUEUE_PARAMS_V1* = SP_BACKUP_QUEUE_PARAMS_V1_A + PSP_BACKUP_QUEUE_PARAMS_V1* = PSP_BACKUP_QUEUE_PARAMS_V1_A + SP_INF_SIGNER_INFO* = SP_INF_SIGNER_INFO_A + PSP_INF_SIGNER_INFO* = PSP_INF_SIGNER_INFO_A + proc SetupGetInfInformation*(InfSpec: LPCVOID, SearchControl: DWORD, ReturnBuffer: PSP_INF_INFORMATION, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetInfInformationA".} + proc SetupQueryInfFileInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfFileInformationA".} + proc SetupQueryInfOriginalFileInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfOriginalFileInformationA".} + proc SetupQueryInfVersionInformation*(InfInformation: PSP_INF_INFORMATION, InfIndex: UINT, Key: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryInfVersionInformationA".} + proc SetupGetInfFileList*(DirectoryPath: PCSTR, InfStyle: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetInfFileListA".} + proc SetupOpenInfFile*(FileName: PCSTR, InfClass: PCSTR, InfStyle: DWORD, ErrorLine: PUINT): HINF {.winapi, stdcall, dynlib: "setupapi", importc: "SetupOpenInfFileA".} + proc SetupOpenAppendInfFile*(FileName: PCSTR, InfHandle: HINF, ErrorLine: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupOpenAppendInfFileA".} + proc SetupFindFirstLine*(InfHandle: HINF, Section: PCSTR, Key: PCSTR, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFindFirstLineA".} + proc SetupFindNextMatchLine*(ContextIn: PINFCONTEXT, Key: PCSTR, ContextOut: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFindNextMatchLineA".} + proc SetupGetLineByIndex*(InfHandle: HINF, Section: PCSTR, Index: DWORD, Context: PINFCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineByIndexA".} + proc SetupGetLineCount*(InfHandle: HINF, Section: PCSTR): LONG {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineCountA".} + proc SetupGetLineText*(Context: PINFCONTEXT, InfHandle: HINF, Section: PCSTR, Key: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetLineTextA".} + proc SetupGetStringField*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetStringFieldA".} + proc SetupGetMultiSzField*(Context: PINFCONTEXT, FieldIndex: DWORD, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetMultiSzFieldA".} + proc SetupGetFileCompressionInfo*(SourceFileName: PCSTR, ActualSourceFileName: ptr PSTR, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetFileCompressionInfoA".} + proc SetupGetFileCompressionInfoEx*(SourceFileName: PCSTR, ActualSourceFileNameBuffer: PSTR, ActualSourceFileNameBufferLen: DWORD, RequiredBufferLen: PDWORD, SourceFileSize: PDWORD, TargetFileSize: PDWORD, CompressionType: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetFileCompressionInfoExA".} + proc SetupDecompressOrCopyFile*(SourceFileName: PCSTR, TargetFileName: PCSTR, CompressionType: PUINT): DWORD {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDecompressOrCopyFileA".} + proc SetupGetSourceFileLocation*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCSTR, SourceId: PUINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceFileLocationA".} + proc SetupGetSourceFileSize*(InfHandle: HINF, InfContext: PINFCONTEXT, FileName: PCSTR, Section: PCSTR, FileSize: PDWORD, RoundingFactor: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceFileSizeA".} + proc SetupGetTargetPath*(InfHandle: HINF, InfContext: PINFCONTEXT, Section: PCSTR, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetTargetPathA".} + proc SetupSetSourceList*(Flags: DWORD, SourceList: ptr PCSTR, SourceCount: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetSourceListA".} + proc SetupAddToSourceList*(Flags: DWORD, Source: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddToSourceListA".} + proc SetupRemoveFromSourceList*(Flags: DWORD, Source: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFromSourceListA".} + proc SetupQuerySourceList*(Flags: DWORD, List: ptr ptr PCSTR, Count: PUINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQuerySourceListA".} + proc SetupFreeSourceList*(List: ptr ptr PCSTR, Count: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupFreeSourceListA".} + proc SetupPromptForDisk*(hwndParent: HWND, DialogTitle: PCSTR, DiskName: PCSTR, PathToSource: PCSTR, FileSought: PCSTR, TagFile: PCSTR, DiskPromptStyle: DWORD, PathBuffer: PSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupPromptForDiskA".} + proc SetupCopyError*(hwndParent: HWND, DialogTitle: PCSTR, DiskName: PCSTR, PathToSource: PCSTR, SourceFile: PCSTR, TargetPathFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD, PathBuffer: PSTR, PathBufferSize: DWORD, PathRequiredSize: PDWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCopyErrorA".} + proc SetupRenameError*(hwndParent: HWND, DialogTitle: PCSTR, SourceFile: PCSTR, TargetFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRenameErrorA".} + proc SetupDeleteError*(hwndParent: HWND, DialogTitle: PCSTR, File: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDeleteErrorA".} + proc SetupBackupError*(hwndParent: HWND, DialogTitle: PCSTR, SourceFile: PCSTR, TargetFile: PCSTR, Win32ErrorCode: UINT, Style: DWORD): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupBackupErrorA".} + proc SetupSetDirectoryId*(InfHandle: HINF, Id: DWORD, Directory: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetDirectoryIdA".} + proc SetupSetDirectoryIdEx*(InfHandle: HINF, Id: DWORD, Directory: PCSTR, Flags: DWORD, Reserved1: DWORD, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetDirectoryIdExA".} + proc SetupGetSourceInfo*(InfHandle: HINF, SourceId: UINT, InfoDesired: UINT, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetSourceInfoA".} + proc SetupInstallFile*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCSTR, SourcePathRoot: PCSTR, DestinationName: PCSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFileA".} + proc SetupInstallFileEx*(InfHandle: HINF, InfContext: PINFCONTEXT, SourceFile: PCSTR, SourcePathRoot: PCSTR, DestinationName: PCSTR, CopyStyle: DWORD, CopyMsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID, FileWasInUse: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFileExA".} + proc SetupSetFileQueueAlternatePlatform*(QueueHandle: HSPFILEQ, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, AlternateDefaultCatalogFile: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetFileQueueAlternatePlatformA".} + proc SetupQueueDeleteSection*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDeleteSectionA".} + proc SetupQueueRename*(QueueHandle: HSPFILEQ, SourcePath: PCSTR, SourceFilename: PCSTR, TargetPath: PCSTR, TargetFilename: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueRenameA".} + proc SetupQueueRenameSection*(QueueHandle: HSPFILEQ, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueRenameSectionA".} + proc SetupCommitFileQueue*(Owner: HWND, QueueHandle: HSPFILEQ, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCommitFileQueueA".} + proc SetupScanFileQueue*(FileQueue: HSPFILEQ, Flags: DWORD, Window: HWND, CallbackRoutine: PSP_FILE_CALLBACK_A, CallbackContext: PVOID, Result: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupScanFileQueueA".} + proc SetupSetPlatformPathOverride*(Override: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupSetPlatformPathOverrideA".} + proc SetupQueueCopy*(QueueHandle: HSPFILEQ, SourceRootPath: PCSTR, SourcePath: PCSTR, SourceFilename: PCSTR, SourceDescription: PCSTR, SourceTagfile: PCSTR, TargetDirectory: PCSTR, TargetFilename: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopyA".} + proc SetupQueueCopyIndirect*(CopyParams: PSP_FILE_COPY_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopyIndirectA".} + proc SetupQueueDefaultCopy*(QueueHandle: HSPFILEQ, InfHandle: HINF, SourceRootPath: PCSTR, SourceFilename: PCSTR, TargetFilename: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDefaultCopyA".} + proc SetupQueueCopySection*(QueueHandle: HSPFILEQ, SourceRootPath: PCSTR, InfHandle: HINF, ListInfHandle: HINF, Section: PCSTR, CopyStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueCopySectionA".} + proc SetupQueueDelete*(QueueHandle: HSPFILEQ, PathPart1: PCSTR, PathPart2: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueueDeleteA".} + proc SetupCopyOEMInf*(SourceInfFileName: PCSTR, OEMSourceMediaLocation: PCSTR, OEMSourceMediaType: DWORD, CopyStyle: DWORD, DestinationInfFileName: PSTR, DestinationInfFileNameSize: DWORD, RequiredSize: PDWORD, DestinationInfFileNameComponent: ptr PSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCopyOEMInfA".} + proc SetupUninstallOEMInf*(InfFileName: PCSTR, Flags: DWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupUninstallOEMInfA".} + proc SetupCreateDiskSpaceList*(Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc: "SetupCreateDiskSpaceListA".} + proc SetupDuplicateDiskSpaceList*(DiskSpace: HDSKSPC, Reserved1: PVOID, Reserved2: DWORD, Flags: UINT): HDSKSPC {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDuplicateDiskSpaceListA".} + proc SetupQueryDrivesInDiskSpaceList*(DiskSpace: HDSKSPC, ReturnBuffer: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryDrivesInDiskSpaceListA".} + proc SetupQuerySpaceRequiredOnDrive*(DiskSpace: HDSKSPC, DriveSpec: PCSTR, SpaceRequired: ptr LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQuerySpaceRequiredOnDriveA".} + proc SetupAdjustDiskSpaceList*(DiskSpace: HDSKSPC, DriveRoot: LPCSTR, Amount: LONGLONG, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAdjustDiskSpaceListA".} + proc SetupAddToDiskSpaceList*(DiskSpace: HDSKSPC, TargetFilespec: PCSTR, FileSize: LONGLONG, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddToDiskSpaceListA".} + proc SetupAddSectionToDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddSectionToDiskSpaceListA".} + proc SetupAddInstallSectionToDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupAddInstallSectionToDiskSpaceListA".} + proc SetupRemoveFromDiskSpaceList*(DiskSpace: HDSKSPC, TargetFilespec: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFromDiskSpaceListA".} + proc SetupRemoveSectionFromDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, ListInfHandle: HINF, SectionName: PCSTR, Operation: UINT, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveSectionFromDiskSpaceListA".} + proc SetupRemoveInstallSectionFromDiskSpaceList*(DiskSpace: HDSKSPC, InfHandle: HINF, LayoutInfHandle: HINF, SectionName: PCSTR, Reserved1: PVOID, Reserved2: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveInstallSectionFromDiskSpaceListA".} + proc SetupIterateCabinet*(CabinetFile: PCSTR, Reserved: DWORD, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupIterateCabinetA".} + proc SetupDefaultQueueCallback*(Context: PVOID, Notification: UINT, Param1: UINT_PTR, Param2: UINT_PTR): UINT {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDefaultQueueCallbackA".} + proc SetupInstallFromInfSection*(Owner: HWND, InfHandle: HINF, SectionName: PCSTR, Flags: UINT, RelativeKeyRoot: HKEY, SourceRootPath: PCSTR, CopyFlags: UINT, MsgHandler: PSP_FILE_CALLBACK_A, Context: PVOID, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFromInfSectionA".} + proc SetupInstallFilesFromInfSection*(InfHandle: HINF, LayoutInfHandle: HINF, FileQueue: HSPFILEQ, SectionName: PCSTR, SourceRootPath: PCSTR, CopyFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallFilesFromInfSectionA".} + proc SetupInstallServicesFromInfSection*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallServicesFromInfSectionA".} + proc SetupInstallServicesFromInfSectionEx*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD, DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInstallServicesFromInfSectionExA".} + proc InstallHinfSection*(Window: HWND, ModuleHandle: HINSTANCE, CommandLine: PCSTR, ShowCommand: INT): VOID {.winapi, stdcall, dynlib: "setupapi", importc: "InstallHinfSectionA".} + proc SetupInitializeFileLog*(LogFileName: PCSTR, Flags: DWORD): HSPFILELOG {.winapi, stdcall, dynlib: "setupapi", importc: "SetupInitializeFileLogA".} + proc SetupLogFile*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, SourceFilename: PCSTR, TargetFilename: PCSTR, Checksum: DWORD, DiskTagfile: PCSTR, DiskDescription: PCSTR, OtherInfo: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupLogFileA".} + proc SetupRemoveFileLogEntry*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, TargetFilename: PCSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupRemoveFileLogEntryA".} + proc SetupQueryFileLog*(FileLogHandle: HSPFILELOG, LogSectionName: PCSTR, TargetFilename: PCSTR, DesiredInfo: SetupFileLogInfo, DataOut: PSTR, ReturnBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupQueryFileLogA".} + proc SetupLogError*(MessageString: LPCSTR, Severity: LogSeverity): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupLogErrorA".} + proc SetupGetBackupInformation*(QueueHandle: HSPFILEQ, BackupParams: PSP_BACKUP_QUEUE_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupGetBackupInformationA".} + proc SetupPrepareQueueForRestore*(QueueHandle: HSPFILEQ, BackupPath: PCSTR, RestoreFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupPrepareQueueForRestoreA".} + proc SetupDiCreateDeviceInfoListEx*(ClassGuid: ptr GUID, hwndParent: HWND, MachineName: PCSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInfoListExA".} + proc SetupDiGetDeviceInfoListDetail*(DeviceInfoSet: HDEVINFO, DeviceInfoSetDetailData: PSP_DEVINFO_LIST_DETAIL_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInfoListDetailA".} + proc SetupDiCreateDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceName: PCSTR, ClassGuid: ptr GUID, DeviceDescription: PCSTR, hwndParent: HWND, CreationFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInfoA".} + proc SetupDiOpenDeviceInfo*(DeviceInfoSet: HDEVINFO, DeviceInstanceId: PCSTR, hwndParent: HWND, OpenFlags: DWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInfoA".} + proc SetupDiGetDeviceInstanceId*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstanceId: PSTR, DeviceInstanceIdSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInstanceIdA".} + proc SetupDiCreateDeviceInterface*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceA".} + proc SetupDiCreateInterfaceDevice*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, InterfaceClassGuid: ptr GUID, ReferenceString: PCSTR, CreationFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceA".} + proc SetupDiOpenDeviceInterface*(DeviceInfoSet: HDEVINFO, DevicePath: PCSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceA".} + proc SetupDiOpenInterfaceDevice*(DeviceInfoSet: HDEVINFO, DevicePath: PCSTR, OpenFlags: DWORD, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenDeviceInterfaceA".} + proc SetupDiGetDeviceInterfaceDetail*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailA".} + proc SetupDiGetInterfaceDeviceDetail*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DeviceInterfaceDetailDataSize: DWORD, RequiredSize: PDWORD, DeviceInfoData: PSP_DEVINFO_DATA): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInterfaceDetailA".} + proc SetupDiEnumDriverInfo*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverType: DWORD, MemberIndex: DWORD, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiEnumDriverInfoA".} + proc SetupDiGetSelectedDriver*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetSelectedDriverA".} + proc SetupDiSetSelectedDriver*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetSelectedDriverA".} + proc SetupDiGetDriverInfoDetail*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInfoDetailData: PSP_DRVINFO_DETAIL_DATA_A, DriverInfoDetailDataSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDriverInfoDetailA".} + proc SetupDiGetClassDevs*(ClassGuid: ptr GUID, Enumerator: PCSTR, hwndParent: HWND, Flags: DWORD): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevsA".} + proc SetupDiGetClassDevsEx*(ClassGuid: ptr GUID, Enumerator: PCSTR, hwndParent: HWND, Flags: DWORD, DeviceInfoSet: HDEVINFO, MachineName: PCSTR, Reserved: PVOID): HDEVINFO {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevsExA".} + proc SetupDiGetINFClass*(InfName: PCSTR, ClassGuid: LPGUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetINFClassA".} + proc SetupDiBuildClassInfoListEx*(Flags: DWORD, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiBuildClassInfoListExA".} + proc SetupDiGetClassDescription*(ClassGuid: ptr GUID, ClassDescription: PSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDescriptionA".} + proc SetupDiGetClassDescriptionEx*(ClassGuid: ptr GUID, ClassDescription: PSTR, ClassDescriptionSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDescriptionExA".} + proc SetupDiInstallClass*(hwndParent: HWND, InfFileName: PCSTR, Flags: DWORD, FileQueue: HSPFILEQ): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiInstallClassA".} + proc SetupDiInstallClassEx*(hwndParent: HWND, InfFileName: PCSTR, Flags: DWORD, FileQueue: HSPFILEQ, InterfaceClassGuid: ptr GUID, Reserved1: PVOID, Reserved2: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiInstallClassExA".} + proc SetupDiOpenClassRegKeyEx*(ClassGuid: ptr GUID, samDesired: REGSAM, Flags: DWORD, MachineName: PCSTR, Reserved: PVOID): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiOpenClassRegKeyExA".} + proc SetupDiCreateDeviceInterfaceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyA".} + proc SetupDiCreateInterfaceDeviceRegKey*(DeviceInfoSet: HDEVINFO, DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA, Reserved: DWORD, samDesired: REGSAM, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDeviceInterfaceRegKeyA".} + proc SetupDiCreateDevRegKey*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Scope: DWORD, HwProfile: DWORD, KeyType: DWORD, InfHandle: HINF, InfSectionName: PCSTR): HKEY {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiCreateDevRegKeyA".} + proc SetupDiGetHwProfileListEx*(HwProfileList: PDWORD, HwProfileListSize: DWORD, RequiredSize: PDWORD, CurrentlyActiveIndex: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileListExA".} + proc SetupDiGetDeviceRegistryProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceRegistryPropertyA".} + proc SetupDiGetClassRegistryProperty*(ClassGuid: ptr GUID, Property: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassRegistryPropertyA".} + proc SetupDiSetDeviceRegistryProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDeviceRegistryPropertyA".} + proc SetupDiSetClassRegistryProperty*(ClassGuid: ptr GUID, Property: DWORD, PropertyBuffer: ptr BYTE, PropertyBufferSize: DWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetClassRegistryPropertyA".} + proc SetupDiGetDeviceInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDeviceInstallParamsA".} + proc SetupDiGetClassInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassInstallParamsA".} + proc SetupDiSetDeviceInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DeviceInstallParams: PSP_DEVINSTALL_PARAMS_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDeviceInstallParamsA".} + proc SetupDiSetClassInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, ClassInstallParams: PSP_CLASSINSTALL_HEADER, ClassInstallParamsSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetClassInstallParamsA".} + proc SetupDiGetDriverInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetDriverInstallParamsA".} + proc SetupDiSetDriverInstallParams*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, DriverInfoData: PSP_DRVINFO_DATA_A, DriverInstallParams: PSP_DRVINSTALL_PARAMS): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiSetDriverInstallParamsA".} + proc SetupDiGetClassImageListEx*(ClassImageListData: PSP_CLASSIMAGELIST_DATA, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassImageListExA".} + proc SetupDiGetClassDevPropertySheets*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, PropertySheetHeader: LPPROPSHEETHEADERA, PropertySheetHeaderPageListSize: DWORD, RequiredSize: PDWORD, PropertySheetType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetClassDevPropertySheetsA".} + proc SetupDiClassNameFromGuid*(ClassGuid: ptr GUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassNameFromGuidA".} + proc SetupDiClassNameFromGuidEx*(ClassGuid: ptr GUID, ClassName: PSTR, ClassNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassNameFromGuidExA".} + proc SetupDiClassGuidsFromName*(ClassName: PCSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassGuidsFromNameA".} + proc SetupDiClassGuidsFromNameEx*(ClassName: PCSTR, ClassGuidList: LPGUID, ClassGuidListSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiClassGuidsFromNameExA".} + proc SetupDiGetHwProfileFriendlyName*(HwProfile: DWORD, FriendlyName: PSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileFriendlyNameA".} + proc SetupDiGetHwProfileFriendlyNameEx*(HwProfile: DWORD, FriendlyName: PSTR, FriendlyNameSize: DWORD, RequiredSize: PDWORD, MachineName: PCSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetHwProfileFriendlyNameExA".} + proc SetupDiGetActualModelsSection*(Context: PINFCONTEXT, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualModelsSectionA".} + proc SetupDiGetActualSectionToInstall*(InfHandle: HINF, InfSectionName: PCSTR, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PSTR): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualSectionToInstallA".} + proc SetupDiGetActualSectionToInstallEx*(InfHandle: HINF, InfSectionName: PCSTR, AlternatePlatformInfo: PSP_ALTPLATFORM_INFO, InfSectionWithExt: PSTR, InfSectionWithExtSize: DWORD, RequiredSize: PDWORD, Extension: ptr PSTR, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetActualSectionToInstallExA".} + proc SetupEnumInfSections*(InfHandle: HINF, Index: UINT, Buffer: PSTR, Size: UINT, SizeNeeded: ptr UINT): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupEnumInfSectionsA".} + proc SetupVerifyInfFile*(InfName: PCSTR, AltPlatformInfo: PSP_ALTPLATFORM_INFO, InfSignerInfo: PSP_INF_SIGNER_INFO_A): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupVerifyInfFileA".} + proc SetupDiGetCustomDeviceProperty*(DeviceInfoSet: HDEVINFO, DeviceInfoData: PSP_DEVINFO_DATA, CustomPropertyName: PCSTR, Flags: DWORD, PropertyRegDataType: PDWORD, PropertyBuffer: PBYTE, PropertyBufferSize: DWORD, RequiredSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupDiGetCustomDevicePropertyA".} + proc SetupConfigureWmiFromInfSection*(InfHandle: HINF, SectionName: PCSTR, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "setupapi", importc: "SetupConfigureWmiFromInfSectionA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/shellapi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/shellapi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,9366 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import wingdi +import winuser +import wincon +import winreg +import winnetwk +import objbase +import iphlpapi +import commctrl +import regstr +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + ASSOCCLASS* = int32 + QUERY_USER_NOTIFICATION_STATE* = int32 + SHSTOCKICONID* = int32 + URL_SCHEME* = int32 + URL_PART* = int32 + TURLIS* = int32 + SHREGDEL_FLAGS* = int32 + SHREGENUM_FLAGS* = int32 + ASSOCSTR* = int32 + ASSOCKEY* = int32 + ASSOCDATA* = int32 + ASSOCENUM* = int32 + SHGFP_TYPE* = int32 + OfflineFolderStatus* = int32 + ShellFolderViewOptions* = int32 + ShellSpecialFolderConstants* = int32 + AUTOCOMPLETEOPTIONS* = int32 + ACENUMOPTION* = int32 + FOLDER_ENUM_MODE* = int32 + LPVIEWSETTINGS* = ptr char + FOLDERFLAGS* = int32 + FOLDERVIEWMODE* = int32 + FOLDERLOGICALVIEWMODE* = int32 + FOLDERVIEWOPTIONS* = int32 + SVSIF* = int32 + SVGIO* = int32 + SVUIA_STATUS* = int32 + SORTDIRECTION* = int32 + FVTEXTTYPE* = int32 + VPWATERMARKFLAGS* = int32 + VPCOLORFLAGS* = int32 + CM_MASK* = int32 + CM_STATE* = int32 + CM_ENUM_FLAGS* = int32 + CM_SET_WIDTH_VALUE* = int32 + SIGDN* = int32 + DATAOBJ_GET_ITEM_FLAGS* = int32 + SIIGBF* = int32 + STGOP* = int32 + SIATTRIBFLAGS* = int32 + CATEGORYINFO_FLAGS* = int32 + CATSORT_FLAGS* = int32 + DSH_FLAGS* = int32 + SLR_FLAGS* = int32 + SLGP_FLAGS* = int32 + SPACTION* = int32 + SPTEXT* = int32 + THUMBBUTTONFLAGS* = int32 + THUMBBUTTONMASK* = int32 + TBPFLAG* = int32 + STPFLAG* = int32 + EXPLORER_BROWSER_OPTIONS* = int32 + EXPLORER_BROWSER_FILL_FLAGS* = int32 + PDOPSTATUS* = int32 + NAMESPACEWALKFLAG* = int32 + MP_POPUPFLAGS* = int32 + FILE_USAGE_TYPE* = int32 + FDE_OVERWRITE_RESPONSE* = int32 + FDE_SHAREVIOLATION_RESPONSE* = int32 + FDAP* = int32 + CDCONTROLSTATEF* = int32 + ASSOCIATIONLEVEL* = int32 + ASSOCIATIONTYPE* = int32 + NWMF* = int32 + ATTACHMENT_PROMPT* = int32 + ATTACHMENT_ACTION* = int32 + KF_CATEGORY* = int32 + FFFP_MODE* = int32 + SHARE_ROLE* = int32 + DEF_SHARE_ID* = int32 + NMCII_FLAGS* = int32 + NMCSAEI_FLAGS* = int32 + NSTCGNI* = int32 + NSTCSTYLE2* = int32 + NSTCFOLDERCAPABILITIES* = int32 + CPVIEW* = int32 + KNOWNDESTCATEGORY* = int32 + APPDOCLISTTYPE* = int32 + DESKTOP_SLIDESHOW_OPTIONS* = int32 + DESKTOP_SLIDESHOW_STATE* = int32 + DESKTOP_SLIDESHOW_DIRECTION* = int32 + DESKTOP_WALLPAPER_POSITION* = int32 + HOMEGROUPSHARINGCHOICES* = int32 + LIBRARYFOLDERFILTER* = int32 + LIBRARYOPTIONFLAGS* = int32 + DEFAULTSAVEFOLDERTYPE* = int32 + LIBRARYSAVEFLAGS* = int32 + PBM_EVENT* = int32 + PBM_SESSION_TYPE* = int32 + PBM_PLAY_STATE* = int32 + PBM_MUTE_STATE* = int32 + DEFAULT_FOLDER_MENU_RESTRICTIONS* = int32 + ACTIVATEOPTIONS* = int32 + LIBRARYMANAGEDIALOGOPTIONS* = int32 + ASSOC_FILTER* = int32 + UNDOCK_REASON* = int32 + MONITOR_APP_VISIBILITY* = int32 + PACKAGE_EXECUTION_STATE* = int32 + AHE_TYPE* = int32 + EC_HOST_UI_MODE* = int32 + APPLICATION_VIEW_STATE* = int32 + EDGE_GESTURE_KIND* = int32 + SHELL_LINK_DATA_FLAGS* = int32 + GPFIDL_FLAGS* = int32 + KNOWN_FOLDER_FLAG* = int32 + AUTOCOMPLETELISTOPTIONS* = int32 + FD_FLAGS* = int32 + DROPIMAGETYPE* = int32 + SHARD* = int32 + SCNRT_STATUS* = int32 + RESTRICTIONS* = int32 + OPEN_AS_INFO_FLAGS* = int32 + IESHORTCUTFLAGS* = int32 + HDROP* = HANDLE + FILEOP_FLAGS* = WORD + PRINTEROP_FLAGS* = WORD + SRRF* = DWORD + HUSKEY* = HANDLE + ASSOCF* = DWORD + SHGDNF* = DWORD + SHCONTF* = DWORD + SFGAOF* = ULONG + SV3CVW3_FLAGS* = DWORD + SICHINTF* = DWORD + TRANSFER_SOURCE_FLAGS* = DWORD + TRANSFER_ADVISE_STATE* = DWORD + PROPERTYUI_NAME_FLAGS* = DWORD + PROPERTYUI_FLAGS* = DWORD + PROPERTYUI_FORMAT_FLAGS* = DWORD + SPINITF* = DWORD + SPBEGINF* = DWORD + OPPROGDLGF* = DWORD + PDMODE* = DWORD + CDBE_ACTIONS* = DWORD + FILEOPENDIALOGOPTIONS* = DWORD + BROWSERFRAMEOPTIONS* = DWORD + KF_DEFINITION_FLAGS* = DWORD + KF_REDIRECTION_CAPABILITIES* = DWORD + NSTCSTYLE* = DWORD + NSTCROOTSTYLE* = DWORD + NSTCITEMSTATE* = DWORD + NSTCEHITTEST* = DWORD + NSTCECLICKTYPE* = DWORD + EXPLORERPANESTATE* = DWORD + EXPCMDSTATE* = DWORD + EXPCMDFLAGS* = DWORD + HTHEME* = HANDLE + HPSXA* = HANDLE + DRAGINFOA* {.pure.} = object + uSize*: UINT + pt*: POINT + fNC*: WINBOOL + lpFileList*: LPSTR + grfKeyState*: DWORD + LPDRAGINFOA* = ptr DRAGINFOA + DRAGINFOW* {.pure.} = object + uSize*: UINT + pt*: POINT + fNC*: WINBOOL + lpFileList*: LPWSTR + grfKeyState*: DWORD + LPDRAGINFOW* = ptr DRAGINFOW + APPBARDATA* {.pure.} = object + cbSize*: DWORD + hWnd*: HWND + uCallbackMessage*: UINT + uEdge*: UINT + rc*: RECT + lParam*: LPARAM + PAPPBARDATA* = ptr APPBARDATA +when winimCpu64: + type + SHFILEOPSTRUCTA* {.pure.} = object + hwnd*: HWND + wFunc*: UINT + pFrom*: LPCSTR + pTo*: LPCSTR + fFlags*: FILEOP_FLAGS + fAnyOperationsAborted*: WINBOOL + hNameMappings*: LPVOID + lpszProgressTitle*: PCSTR +when winimCpu32: + type + SHFILEOPSTRUCTA* {.pure, packed.} = object + hwnd*: HWND + wFunc*: UINT + pFrom*: LPCSTR + pTo*: LPCSTR + fFlags*: FILEOP_FLAGS + fAnyOperationsAborted*: WINBOOL + hNameMappings*: LPVOID + lpszProgressTitle*: PCSTR +type + LPSHFILEOPSTRUCTA* = ptr SHFILEOPSTRUCTA +when winimCpu64: + type + SHFILEOPSTRUCTW* {.pure.} = object + hwnd*: HWND + wFunc*: UINT + pFrom*: LPCWSTR + pTo*: LPCWSTR + fFlags*: FILEOP_FLAGS + fAnyOperationsAborted*: WINBOOL + hNameMappings*: LPVOID + lpszProgressTitle*: PCWSTR +when winimCpu32: + type + SHFILEOPSTRUCTW* {.pure, packed.} = object + hwnd*: HWND + wFunc*: UINT + pFrom*: LPCWSTR + pTo*: LPCWSTR + fFlags*: FILEOP_FLAGS + fAnyOperationsAborted*: WINBOOL + hNameMappings*: LPVOID + lpszProgressTitle*: PCWSTR +type + LPSHFILEOPSTRUCTW* = ptr SHFILEOPSTRUCTW + SHNAMEMAPPINGA* {.pure.} = object + pszOldPath*: LPSTR + pszNewPath*: LPSTR + cchOldPath*: int32 + cchNewPath*: int32 + LPSHNAMEMAPPINGA* = ptr SHNAMEMAPPINGA + SHNAMEMAPPINGW* {.pure.} = object + pszOldPath*: LPWSTR + pszNewPath*: LPWSTR + cchOldPath*: int32 + cchNewPath*: int32 + LPSHNAMEMAPPINGW* = ptr SHNAMEMAPPINGW + SHELLEXECUTEINFOA_UNION1* {.pure, union.} = object + hIcon*: HANDLE + hMonitor*: HANDLE + SHELLEXECUTEINFOA* {.pure.} = object + cbSize*: DWORD + fMask*: ULONG + hwnd*: HWND + lpVerb*: LPCSTR + lpFile*: LPCSTR + lpParameters*: LPCSTR + lpDirectory*: LPCSTR + nShow*: int32 + hInstApp*: HINSTANCE + lpIDList*: pointer + lpClass*: LPCSTR + hkeyClass*: HKEY + dwHotKey*: DWORD + union1*: SHELLEXECUTEINFOA_UNION1 + hProcess*: HANDLE + LPSHELLEXECUTEINFOA* = ptr SHELLEXECUTEINFOA + SHELLEXECUTEINFOW_UNION1* {.pure, union.} = object + hIcon*: HANDLE + hMonitor*: HANDLE + SHELLEXECUTEINFOW* {.pure.} = object + cbSize*: DWORD + fMask*: ULONG + hwnd*: HWND + lpVerb*: LPCWSTR + lpFile*: LPCWSTR + lpParameters*: LPCWSTR + lpDirectory*: LPCWSTR + nShow*: int32 + hInstApp*: HINSTANCE + lpIDList*: pointer + lpClass*: LPCWSTR + hkeyClass*: HKEY + dwHotKey*: DWORD + union1*: SHELLEXECUTEINFOW_UNION1 + hProcess*: HANDLE + LPSHELLEXECUTEINFOW* = ptr SHELLEXECUTEINFOW + SHCREATEPROCESSINFOW* {.pure.} = object + cbSize*: DWORD + fMask*: ULONG + hwnd*: HWND + pszFile*: LPCWSTR + pszParameters*: LPCWSTR + pszCurrentDirectory*: LPCWSTR + hUserToken*: HANDLE + lpProcessAttributes*: LPSECURITY_ATTRIBUTES + lpThreadAttributes*: LPSECURITY_ATTRIBUTES + bInheritHandles*: WINBOOL + dwCreationFlags*: DWORD + lpStartupInfo*: LPSTARTUPINFOW + lpProcessInformation*: LPPROCESS_INFORMATION + PSHCREATEPROCESSINFOW* = ptr SHCREATEPROCESSINFOW +when winimCpu64: + type + SHQUERYRBINFO* {.pure.} = object + cbSize*: DWORD + i64Size*: int64 + i64NumItems*: int64 +when winimCpu32: + type + SHQUERYRBINFO* {.pure, packed.} = object + cbSize*: DWORD + i64Size*: int64 + i64NumItems*: int64 +type + LPSHQUERYRBINFO* = ptr SHQUERYRBINFO + NOTIFYICONDATAA_UNION1* {.pure, union.} = object + uTimeout*: UINT + uVersion*: UINT + NOTIFYICONDATAA* {.pure.} = object + cbSize*: DWORD + hWnd*: HWND + uID*: UINT + uFlags*: UINT + uCallbackMessage*: UINT + hIcon*: HICON + szTip*: array[128, CHAR] + dwState*: DWORD + dwStateMask*: DWORD + szInfo*: array[256, CHAR] + union1*: NOTIFYICONDATAA_UNION1 + szInfoTitle*: array[64, CHAR] + dwInfoFlags*: DWORD + guidItem*: GUID + hBalloonIcon*: HICON + PNOTIFYICONDATAA* = ptr NOTIFYICONDATAA + NOTIFYICONDATAW_UNION1* {.pure, union.} = object + uTimeout*: UINT + uVersion*: UINT + NOTIFYICONDATAW* {.pure.} = object + cbSize*: DWORD + hWnd*: HWND + uID*: UINT + uFlags*: UINT + uCallbackMessage*: UINT + hIcon*: HICON + szTip*: array[128, WCHAR] + dwState*: DWORD + dwStateMask*: DWORD + szInfo*: array[256, WCHAR] + union1*: NOTIFYICONDATAW_UNION1 + szInfoTitle*: array[64, WCHAR] + dwInfoFlags*: DWORD + guidItem*: GUID + hBalloonIcon*: HICON + PNOTIFYICONDATAW* = ptr NOTIFYICONDATAW + NOTIFYICONIDENTIFIER* {.pure.} = object + cbSize*: DWORD + hWnd*: HWND + uID*: UINT + guidItem*: GUID + PNOTIFYICONIDENTIFIER* = ptr NOTIFYICONIDENTIFIER + OPEN_PRINTER_PROPS_INFOA* {.pure.} = object + dwSize*: DWORD + pszSheetName*: LPSTR + uSheetIndex*: UINT + dwFlags*: DWORD + bModal*: WINBOOL + POPEN_PRINTER_PROPS_INFOA* = ptr OPEN_PRINTER_PROPS_INFOA + OPEN_PRINTER_PROPS_INFOW* {.pure.} = object + dwSize*: DWORD + pszSheetName*: LPWSTR + uSheetIndex*: UINT + dwFlags*: DWORD + bModal*: WINBOOL + POPEN_PRINTER_PROPS_INFOW* = ptr OPEN_PRINTER_PROPS_INFOW + NC_ADDRESS* {.pure.} = object + pAddrInfo*: ptr NET_ADDRESS_INFO + PortNumber*: USHORT + PrefixLength*: BYTE + PNC_ADDRESS* = ptr NC_ADDRESS + PHUSKEY* = ptr HUSKEY + IDefViewID* = IUnknown + FolderItemVerb* {.pure.} = object + lpVtbl*: ptr FolderItemVerbVtbl + FolderItemVerbVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Application*: proc(self: ptr FolderItemVerb, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr FolderItemVerb, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Name*: proc(self: ptr FolderItemVerb, pbs: ptr BSTR): HRESULT {.stdcall.} + DoIt*: proc(self: ptr FolderItemVerb): HRESULT {.stdcall.} + FolderItemVerbs* {.pure.} = object + lpVtbl*: ptr FolderItemVerbsVtbl + FolderItemVerbsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Count*: proc(self: ptr FolderItemVerbs, plCount: ptr LONG): HRESULT {.stdcall.} + get_Application*: proc(self: ptr FolderItemVerbs, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr FolderItemVerbs, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + Item*: proc(self: ptr FolderItemVerbs, index: VARIANT, ppid: ptr ptr FolderItemVerb): HRESULT {.stdcall.} + NewEnum*: proc(self: ptr FolderItemVerbs, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + FolderItem* {.pure.} = object + lpVtbl*: ptr FolderItemVtbl + FolderItemVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Application*: proc(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Name*: proc(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.stdcall.} + put_Name*: proc(self: ptr FolderItem, bs: BSTR): HRESULT {.stdcall.} + get_Path*: proc(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.stdcall.} + get_GetLink*: proc(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_GetFolder*: proc(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_IsLink*: proc(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFolder*: proc(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsFileSystem*: proc(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_IsBrowsable*: proc(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.stdcall.} + get_ModifyDate*: proc(self: ptr FolderItem, pdt: ptr DATE): HRESULT {.stdcall.} + put_ModifyDate*: proc(self: ptr FolderItem, dt: DATE): HRESULT {.stdcall.} + get_Size*: proc(self: ptr FolderItem, pul: ptr LONG): HRESULT {.stdcall.} + get_Type*: proc(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.stdcall.} + Verbs*: proc(self: ptr FolderItem, ppfic: ptr ptr FolderItemVerbs): HRESULT {.stdcall.} + InvokeVerb*: proc(self: ptr FolderItem, vVerb: VARIANT): HRESULT {.stdcall.} + LPFOLDERITEM* = ptr FolderItem + IAutoComplete* {.pure.} = object + lpVtbl*: ptr IAutoCompleteVtbl + IAutoCompleteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Init*: proc(self: ptr IAutoComplete, hwndEdit: HWND, punkACL: ptr IUnknown, pwszRegKeyPath: LPCWSTR, pwszQuickComplete: LPCWSTR): HRESULT {.stdcall.} + Enable*: proc(self: ptr IAutoComplete, fEnable: WINBOOL): HRESULT {.stdcall.} + LPAUTOCOMPLETE* = ptr IAutoComplete + IAutoComplete2* {.pure.} = object + lpVtbl*: ptr IAutoComplete2Vtbl + IAutoComplete2Vtbl* {.pure, inheritable.} = object of IAutoCompleteVtbl + SetOptions*: proc(self: ptr IAutoComplete2, dwFlag: DWORD): HRESULT {.stdcall.} + GetOptions*: proc(self: ptr IAutoComplete2, pdwFlag: ptr DWORD): HRESULT {.stdcall.} + LPAUTOCOMPLETE2* = ptr IAutoComplete2 + IEnumACString* {.pure.} = object + lpVtbl*: ptr IEnumACStringVtbl + IEnumACStringVtbl* {.pure, inheritable.} = object of IEnumStringVtbl + NextItem*: proc(self: ptr IEnumACString, pszUrl: LPWSTR, cchMax: ULONG, pulSortIndex: ptr ULONG): HRESULT {.stdcall.} + SetEnumOptions*: proc(self: ptr IEnumACString, dwOptions: DWORD): HRESULT {.stdcall.} + GetEnumOptions*: proc(self: ptr IEnumACString, pdwOptions: ptr DWORD): HRESULT {.stdcall.} + PENUMACSTRING* = ptr IEnumACString + LPENUMACSTRING* = ptr IEnumACString + CMINVOKECOMMANDINFO* {.pure.} = object + cbSize*: DWORD + fMask*: DWORD + hwnd*: HWND + lpVerb*: LPCSTR + lpParameters*: LPCSTR + lpDirectory*: LPCSTR + nShow*: int32 + dwHotKey*: DWORD + hIcon*: HANDLE + LPCMINVOKECOMMANDINFO* = ptr CMINVOKECOMMANDINFO + PCCMINVOKECOMMANDINFO* = ptr CMINVOKECOMMANDINFO + CMINVOKECOMMANDINFOEX* {.pure.} = object + cbSize*: DWORD + fMask*: DWORD + hwnd*: HWND + lpVerb*: LPCSTR + lpParameters*: LPCSTR + lpDirectory*: LPCSTR + nShow*: int32 + dwHotKey*: DWORD + hIcon*: HANDLE + lpTitle*: LPCSTR + lpVerbW*: LPCWSTR + lpParametersW*: LPCWSTR + lpDirectoryW*: LPCWSTR + lpTitleW*: LPCWSTR + ptInvoke*: POINT + LPCMINVOKECOMMANDINFOEX* = ptr CMINVOKECOMMANDINFOEX + PCCMINVOKECOMMANDINFOEX* = ptr CMINVOKECOMMANDINFOEX + IContextMenu* {.pure.} = object + lpVtbl*: ptr IContextMenuVtbl + IContextMenuVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryContextMenu*: proc(self: ptr IContextMenu, hmenu: HMENU, indexMenu: UINT, idCmdFirst: UINT, idCmdLast: UINT, uFlags: UINT): HRESULT {.stdcall.} + InvokeCommand*: proc(self: ptr IContextMenu, pici: ptr CMINVOKECOMMANDINFO): HRESULT {.stdcall.} + GetCommandString*: proc(self: ptr IContextMenu, idCmd: UINT_PTR, uType: UINT, pReserved: ptr UINT, pszName: ptr CHAR, cchMax: UINT): HRESULT {.stdcall.} + LPCONTEXTMENU* = ptr IContextMenu + IContextMenu2* {.pure.} = object + lpVtbl*: ptr IContextMenu2Vtbl + IContextMenu2Vtbl* {.pure, inheritable.} = object of IContextMenuVtbl + HandleMenuMsg*: proc(self: ptr IContextMenu2, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + LPCONTEXTMENU2* = ptr IContextMenu2 + IContextMenu3* {.pure.} = object + lpVtbl*: ptr IContextMenu3Vtbl + IContextMenu3Vtbl* {.pure, inheritable.} = object of IContextMenu2Vtbl + HandleMenuMsg2*: proc(self: ptr IContextMenu3, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.stdcall.} + LPCONTEXTMENU3* = ptr IContextMenu3 + IPersistFolder* {.pure.} = object + lpVtbl*: ptr IPersistFolderVtbl + IPersistFolderVtbl* {.pure, inheritable.} = object of IPersistVtbl + Initialize*: proc(self: ptr IPersistFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + LPPERSISTFOLDER* = ptr IPersistFolder + IEnumIDList* {.pure.} = object + lpVtbl*: ptr IEnumIDListVtbl + IEnumIDListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumIDList, celt: ULONG, rgelt: ptr PITEMID_CHILD, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumIDList, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumIDList): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumIDList, ppenum: ptr ptr IEnumIDList): HRESULT {.stdcall.} + LPENUMIDLIST* = ptr IEnumIDList + IShellFolder* {.pure.} = object + lpVtbl*: ptr IShellFolderVtbl + IShellFolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParseDisplayName*: proc(self: ptr IShellFolder, hwnd: HWND, pbc: ptr IBindCtx, pszDisplayName: LPWSTR, pchEaten: ptr ULONG, ppidl: ptr PIDLIST_RELATIVE, pdwAttributes: ptr ULONG): HRESULT {.stdcall.} + EnumObjects*: proc(self: ptr IShellFolder, hwnd: HWND, grfFlags: SHCONTF, ppenumIDList: ptr ptr IEnumIDList): HRESULT {.stdcall.} + BindToObject*: proc(self: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + BindToStorage*: proc(self: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + CompareIDs*: proc(self: ptr IShellFolder, lParam: LPARAM, pidl1: PCUIDLIST_RELATIVE, pidl2: PCUIDLIST_RELATIVE): HRESULT {.stdcall.} + CreateViewObject*: proc(self: ptr IShellFolder, hwndOwner: HWND, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetAttributesOf*: proc(self: ptr IShellFolder, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, rgfInOut: ptr SFGAOF): HRESULT {.stdcall.} + GetUIObjectOf*: proc(self: ptr IShellFolder, hwndOwner: HWND, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, riid: REFIID, rgfReserved: ptr UINT, ppv: ptr pointer): HRESULT {.stdcall.} + GetDisplayNameOf*: proc(self: ptr IShellFolder, pidl: PCUITEMID_CHILD, uFlags: SHGDNF, pName: ptr STRRET): HRESULT {.stdcall.} + SetNameOf*: proc(self: ptr IShellFolder, hwnd: HWND, pidl: PCUITEMID_CHILD, pszName: LPCWSTR, uFlags: SHGDNF, ppidlOut: ptr PITEMID_CHILD): HRESULT {.stdcall.} + LPSHELLFOLDER* = ptr IShellFolder + EXTRASEARCH* {.pure.} = object + guidSearch*: GUID + wszFriendlyName*: array[80, WCHAR] + wszUrl*: array[2084, WCHAR] + LPEXTRASEARCH* = ptr EXTRASEARCH + IEnumExtraSearch* {.pure.} = object + lpVtbl*: ptr IEnumExtraSearchVtbl + IEnumExtraSearchVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumExtraSearch, celt: ULONG, rgelt: ptr EXTRASEARCH, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumExtraSearch, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumExtraSearch): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumExtraSearch, ppenum: ptr ptr IEnumExtraSearch): HRESULT {.stdcall.} + LPENUMEXTRASEARCH* = ptr IEnumExtraSearch + FOLDERSETTINGS* {.pure.} = object + ViewMode*: UINT + fFlags*: UINT + LPFOLDERSETTINGS* = ptr FOLDERSETTINGS + LPCFOLDERSETTINGS* = ptr FOLDERSETTINGS + PFOLDERSETTINGS* = ptr FOLDERSETTINGS + LPFNSVADDPROPSHEETPAGE* = LPFNADDPROPSHEETPAGE + LPTBBUTTONSB* = LPTBBUTTON + IShellBrowser* {.pure.} = object + lpVtbl*: ptr IShellBrowserVtbl + IShellBrowserVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + InsertMenusSB*: proc(self: ptr IShellBrowser, hmenuShared: HMENU, lpMenuWidths: LPOLEMENUGROUPWIDTHS): HRESULT {.stdcall.} + SetMenuSB*: proc(self: ptr IShellBrowser, hmenuShared: HMENU, holemenuRes: HOLEMENU, hwndActiveObject: HWND): HRESULT {.stdcall.} + RemoveMenusSB*: proc(self: ptr IShellBrowser, hmenuShared: HMENU): HRESULT {.stdcall.} + SetStatusTextSB*: proc(self: ptr IShellBrowser, pszStatusText: LPCWSTR): HRESULT {.stdcall.} + EnableModelessSB*: proc(self: ptr IShellBrowser, fEnable: WINBOOL): HRESULT {.stdcall.} + TranslateAcceleratorSB*: proc(self: ptr IShellBrowser, pmsg: ptr MSG, wID: WORD): HRESULT {.stdcall.} + BrowseObject*: proc(self: ptr IShellBrowser, pidl: PCUIDLIST_RELATIVE, wFlags: UINT): HRESULT {.stdcall.} + GetViewStateStream*: proc(self: ptr IShellBrowser, grfMode: DWORD, ppStrm: ptr ptr IStream): HRESULT {.stdcall.} + GetControlWindow*: proc(self: ptr IShellBrowser, id: UINT, phwnd: ptr HWND): HRESULT {.stdcall.} + SendControlMsg*: proc(self: ptr IShellBrowser, id: UINT, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, pret: ptr LRESULT): HRESULT {.stdcall.} + QueryActiveShellView*: proc(self: ptr IShellBrowser, ppshv: ptr ptr IShellView): HRESULT {.stdcall.} + OnViewWindowActive*: proc(self: ptr IShellBrowser, pshv: ptr IShellView): HRESULT {.stdcall.} + SetToolbarItems*: proc(self: ptr IShellBrowser, lpButtons: LPTBBUTTONSB, nButtons: UINT, uFlags: UINT): HRESULT {.stdcall.} + IShellView* {.pure.} = object + lpVtbl*: ptr IShellViewVtbl + IShellViewVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + TranslateAccelerator*: proc(self: ptr IShellView, pmsg: ptr MSG): HRESULT {.stdcall.} + EnableModeless*: proc(self: ptr IShellView, fEnable: WINBOOL): HRESULT {.stdcall.} + UIActivate*: proc(self: ptr IShellView, uState: UINT): HRESULT {.stdcall.} + Refresh*: proc(self: ptr IShellView): HRESULT {.stdcall.} + CreateViewWindow*: proc(self: ptr IShellView, psvPrevious: ptr IShellView, pfs: LPCFOLDERSETTINGS, psb: ptr IShellBrowser, prcView: ptr RECT, phWnd: ptr HWND): HRESULT {.stdcall.} + DestroyViewWindow*: proc(self: ptr IShellView): HRESULT {.stdcall.} + GetCurrentInfo*: proc(self: ptr IShellView, pfs: LPFOLDERSETTINGS): HRESULT {.stdcall.} + AddPropertySheetPages*: proc(self: ptr IShellView, dwReserved: DWORD, pfn: LPFNSVADDPROPSHEETPAGE, lparam: LPARAM): HRESULT {.stdcall.} + SaveViewState*: proc(self: ptr IShellView): HRESULT {.stdcall.} + SelectItem*: proc(self: ptr IShellView, pidlItem: PCUITEMID_CHILD, uFlags: SVSIF): HRESULT {.stdcall.} + GetItemObject*: proc(self: ptr IShellView, uItem: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + LPSHELLVIEW* = ptr IShellView + SHELLVIEWID* = GUID + SV2CVW2_PARAMS* {.pure.} = object + cbSize*: DWORD + psvPrev*: ptr IShellView + pfs*: LPCFOLDERSETTINGS + psbOwner*: ptr IShellBrowser + prcView*: ptr RECT + pvid*: ptr SHELLVIEWID + hwndView*: HWND + LPSV2CVW2_PARAMS* = ptr SV2CVW2_PARAMS + DEPRECATED_HRESULT* = HRESULT + ICommDlgBrowser* {.pure.} = object + lpVtbl*: ptr ICommDlgBrowserVtbl + ICommDlgBrowserVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnDefaultCommand*: proc(self: ptr ICommDlgBrowser, ppshv: ptr IShellView): HRESULT {.stdcall.} + OnStateChange*: proc(self: ptr ICommDlgBrowser, ppshv: ptr IShellView, uChange: ULONG): HRESULT {.stdcall.} + IncludeObject*: proc(self: ptr ICommDlgBrowser, ppshv: ptr IShellView, pidl: PCUITEMID_CHILD): HRESULT {.stdcall.} + LPCOMMDLGBROWSER* = ptr ICommDlgBrowser + ICommDlgBrowser2* {.pure.} = object + lpVtbl*: ptr ICommDlgBrowser2Vtbl + ICommDlgBrowser2Vtbl* {.pure, inheritable.} = object of ICommDlgBrowserVtbl + Notify*: proc(self: ptr ICommDlgBrowser2, ppshv: ptr IShellView, dwNotifyType: DWORD): HRESULT {.stdcall.} + GetDefaultMenuText*: proc(self: ptr ICommDlgBrowser2, ppshv: ptr IShellView, pszText: LPWSTR, cchMax: int32): HRESULT {.stdcall.} + GetViewFlags*: proc(self: ptr ICommDlgBrowser2, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + LPCOMMDLGBROWSER2* = ptr ICommDlgBrowser2 + LPSHELLBROWSER* = ptr IShellBrowser + STGTRANSCONFIRMATION* = GUID + LPSTGTRANSCONFIRMATION* = ptr GUID + SHDRAGIMAGE* {.pure.} = object + sizeDragImage*: SIZE + ptOffset*: POINT + hbmpDragImage*: HBITMAP + crColorKey*: COLORREF + LPSHDRAGIMAGE* = ptr SHDRAGIMAGE + IShellExtInit* {.pure.} = object + lpVtbl*: ptr IShellExtInitVtbl + IShellExtInitVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IShellExtInit, pidlFolder: PCIDLIST_ABSOLUTE, pdtobj: ptr IDataObject, hkeyProgID: HKEY): HRESULT {.stdcall.} + LPSHELLEXTINIT* = ptr IShellExtInit + EXPPS* = UINT + IShellPropSheetExt* {.pure.} = object + lpVtbl*: ptr IShellPropSheetExtVtbl + IShellPropSheetExtVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddPages*: proc(self: ptr IShellPropSheetExt, pfnAddPage: LPFNSVADDPROPSHEETPAGE, lParam: LPARAM): HRESULT {.stdcall.} + ReplacePage*: proc(self: ptr IShellPropSheetExt, uPageID: EXPPS, pfnReplaceWith: LPFNSVADDPROPSHEETPAGE, lParam: LPARAM): HRESULT {.stdcall.} + LPSHELLPROPSHEETEXT* = ptr IShellPropSheetExt + IExtractImage* {.pure.} = object + lpVtbl*: ptr IExtractImageVtbl + IExtractImageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetLocation*: proc(self: ptr IExtractImage, pszPathBuffer: LPWSTR, cch: DWORD, pdwPriority: ptr DWORD, prgSize: ptr SIZE, dwRecClrDepth: DWORD, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + Extract*: proc(self: ptr IExtractImage, phBmpThumbnail: ptr HBITMAP): HRESULT {.stdcall.} + LPEXTRACTIMAGE* = ptr IExtractImage + IExtractImage2* {.pure.} = object + lpVtbl*: ptr IExtractImage2Vtbl + IExtractImage2Vtbl* {.pure, inheritable.} = object of IExtractImageVtbl + GetDateStamp*: proc(self: ptr IExtractImage2, pDateStamp: ptr FILETIME): HRESULT {.stdcall.} + LPEXTRACTIMAGE2* = ptr IExtractImage2 + THUMBBUTTON* {.pure.} = object + dwMask*: THUMBBUTTONMASK + iId*: UINT + iBitmap*: UINT + hIcon*: HICON + szTip*: array[260, WCHAR] + dwFlags*: THUMBBUTTONFLAGS + LPTHUMBBUTTON* = ptr THUMBBUTTON + DELEGATEITEMID* {.pure, packed.} = object + cbSize*: WORD + wOuter*: WORD + cbInner*: WORD + rgb*: array[1, BYTE] + PCDELEGATEITEMID* = ptr DELEGATEITEMID + PDELEGATEITEMID* = ptr DELEGATEITEMID + IBrowserFrameOptions* {.pure.} = object + lpVtbl*: ptr IBrowserFrameOptionsVtbl + IBrowserFrameOptionsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFrameOptions*: proc(self: ptr IBrowserFrameOptions, dwMask: BROWSERFRAMEOPTIONS, pdwOptions: ptr BROWSERFRAMEOPTIONS): HRESULT {.stdcall.} + LPBROWSERFRAMEOPTIONS* = ptr IBrowserFrameOptions + SMDATA* {.pure.} = object + dwMask*: DWORD + dwFlags*: DWORD + hmenu*: HMENU + hwnd*: HWND + uId*: UINT + uIdParent*: UINT + uIdAncestor*: UINT + punk*: ptr IUnknown + pidlFolder*: PIDLIST_ABSOLUTE + pidlItem*: PUITEMID_CHILD + psf*: ptr IShellFolder + pvUserData*: pointer + LPSMDATA* = ptr SMDATA + SMINFO* {.pure.} = object + dwMask*: DWORD + dwType*: DWORD + dwFlags*: DWORD + iIcon*: int32 + PSMINFO* = ptr SMINFO + EXPLORERPANE* = GUID + REFEXPLORERPANE* = ptr EXPLORERPANE + IExtractIconA* {.pure.} = object + lpVtbl*: ptr IExtractIconAVtbl + IExtractIconAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetIconLocation*: proc(self: ptr IExtractIconA, uFlags: UINT, pszIconFile: PSTR, cchMax: UINT, piIndex: ptr int32, pwFlags: ptr UINT): HRESULT {.stdcall.} + Extract*: proc(self: ptr IExtractIconA, pszFile: PCSTR, nIconIndex: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.stdcall.} + LPEXTRACTICONA* = ptr IExtractIconA + IExtractIconW* {.pure.} = object + lpVtbl*: ptr IExtractIconWVtbl + IExtractIconWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetIconLocation*: proc(self: ptr IExtractIconW, uFlags: UINT, pszIconFile: PWSTR, cchMax: UINT, piIndex: ptr int32, pwFlags: ptr UINT): HRESULT {.stdcall.} + Extract*: proc(self: ptr IExtractIconW, pszFile: PCWSTR, nIconIndex: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.stdcall.} + LPEXTRACTICONW* = ptr IExtractIconW + DATABLOCK_HEADER* {.pure.} = object + cbSize*: DWORD + dwSignature*: DWORD + LPDATABLOCK_HEADER* = ptr DATABLOCK_HEADER + LPDBLIST* = ptr DATABLOCK_HEADER + NT_CONSOLE_PROPS* {.pure.} = object + dbh*: DATABLOCK_HEADER + wFillAttribute*: WORD + wPopupFillAttribute*: WORD + dwScreenBufferSize*: COORD + dwWindowSize*: COORD + dwWindowOrigin*: COORD + nFont*: DWORD + nInputBufferSize*: DWORD + dwFontSize*: COORD + uFontFamily*: UINT + uFontWeight*: UINT + FaceName*: array[LF_FACESIZE, WCHAR] + uCursorSize*: UINT + bFullScreen*: WINBOOL + bQuickEdit*: WINBOOL + bInsertMode*: WINBOOL + bAutoPosition*: WINBOOL + uHistoryBufferSize*: UINT + uNumberOfHistoryBuffers*: UINT + bHistoryNoDup*: WINBOOL + ColorTable*: array[16, COLORREF] + LPNT_CONSOLE_PROPS* = ptr NT_CONSOLE_PROPS + NT_FE_CONSOLE_PROPS* {.pure.} = object + dbh*: DATABLOCK_HEADER + uCodePage*: UINT + LPNT_FE_CONSOLE_PROPS* = ptr NT_FE_CONSOLE_PROPS + EXP_DARWIN_LINK* {.pure.} = object + dbh*: DATABLOCK_HEADER + szDarwinID*: array[MAX_PATH, CHAR] + szwDarwinID*: array[MAX_PATH, WCHAR] + LPEXP_DARWIN_LINK* = ptr EXP_DARWIN_LINK + EXP_SPECIAL_FOLDER* {.pure.} = object + cbSize*: DWORD + dwSignature*: DWORD + idSpecialFolder*: DWORD + cbOffset*: DWORD + LPEXP_SPECIAL_FOLDER* = ptr EXP_SPECIAL_FOLDER + EXP_SZ_LINK* {.pure.} = object + cbSize*: DWORD + dwSignature*: DWORD + szTarget*: array[MAX_PATH, CHAR] + swzTarget*: array[MAX_PATH, WCHAR] + LPEXP_SZ_LINK* = ptr EXP_SZ_LINK + ICopyHookA* {.pure.} = object + lpVtbl*: ptr ICopyHookAVtbl + ICopyHookAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CopyCallback*: proc(self: ptr ICopyHookA, hwnd: HWND, wFunc: UINT, wFlags: UINT, pszSrcFile: PCSTR, dwSrcAttribs: DWORD, pszDestFile: PCSTR, dwDestAttribs: DWORD): UINT {.stdcall.} + LPCOPYHOOKA* = ptr ICopyHookA + ICopyHookW* {.pure.} = object + lpVtbl*: ptr ICopyHookWVtbl + ICopyHookWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CopyCallback*: proc(self: ptr ICopyHookW, hwnd: HWND, wFunc: UINT, wFlags: UINT, pszSrcFile: PCWSTR, dwSrcAttribs: DWORD, pszDestFile: PCWSTR, dwDestAttribs: DWORD): UINT {.stdcall.} + LPCOPYHOOKW* = ptr ICopyHookW + IFileViewerSite* {.pure.} = object + lpVtbl*: ptr IFileViewerSiteVtbl + IFileViewerSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetPinnedWindow*: proc(self: ptr IFileViewerSite, hwnd: HWND): HRESULT {.stdcall.} + GetPinnedWindow*: proc(self: ptr IFileViewerSite, phwnd: ptr HWND): HRESULT {.stdcall.} + LPFILEVIEWERSITE* = ptr IFileViewerSite + FVSHOWINFO* {.pure.} = object + cbSize*: DWORD + hwndOwner*: HWND + iShow*: int32 + dwFlags*: DWORD + rect*: RECT + punkRel*: ptr IUnknown + strNewFile*: array[MAX_PATH, OLECHAR] + LPFVSHOWINFO* = ptr FVSHOWINFO + IFileViewerA* {.pure.} = object + lpVtbl*: ptr IFileViewerAVtbl + IFileViewerAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowInitialize*: proc(self: ptr IFileViewerA, lpfsi: LPFILEVIEWERSITE): HRESULT {.stdcall.} + Show*: proc(self: ptr IFileViewerA, pvsi: LPFVSHOWINFO): HRESULT {.stdcall.} + PrintTo*: proc(self: ptr IFileViewerA, pszDriver: PSTR, fSuppressUI: WINBOOL): HRESULT {.stdcall.} + LPFILEVIEWERA* = ptr IFileViewerA + IFileViewerW* {.pure.} = object + lpVtbl*: ptr IFileViewerWVtbl + IFileViewerWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowInitialize*: proc(self: ptr IFileViewerW, lpfsi: LPFILEVIEWERSITE): HRESULT {.stdcall.} + Show*: proc(self: ptr IFileViewerW, pvsi: LPFVSHOWINFO): HRESULT {.stdcall.} + PrintTo*: proc(self: ptr IFileViewerW, pszDriver: PWSTR, fSuppressUI: WINBOOL): HRESULT {.stdcall.} + LPFILEVIEWERW* = ptr IFileViewerW + SHFOLDERCUSTOMSETTINGS* {.pure.} = object + dwSize*: DWORD + dwMask*: DWORD + pvid*: ptr SHELLVIEWID + pszWebViewTemplate*: LPWSTR + cchWebViewTemplate*: DWORD + pszWebViewTemplateVersion*: LPWSTR + pszInfoTip*: LPWSTR + cchInfoTip*: DWORD + pclsid*: ptr CLSID + dwFlags*: DWORD + pszIconFile*: LPWSTR + cchIconFile*: DWORD + iIconIndex*: int32 + pszLogo*: LPWSTR + cchLogo*: DWORD + LPSHFOLDERCUSTOMSETTINGS* = ptr SHFOLDERCUSTOMSETTINGS + BFFCALLBACK* = proc (hwnd: HWND, uMsg: UINT, lParam: LPARAM, lpData: LPARAM): int32 {.stdcall.} + BROWSEINFOA* {.pure.} = object + hwndOwner*: HWND + pidlRoot*: PCIDLIST_ABSOLUTE + pszDisplayName*: LPSTR + lpszTitle*: LPCSTR + ulFlags*: UINT + lpfn*: BFFCALLBACK + lParam*: LPARAM + iImage*: int32 + PBROWSEINFOA* = ptr BROWSEINFOA + LPBROWSEINFOA* = ptr BROWSEINFOA + BROWSEINFOW* {.pure.} = object + hwndOwner*: HWND + pidlRoot*: PCIDLIST_ABSOLUTE + pszDisplayName*: LPWSTR + lpszTitle*: LPCWSTR + ulFlags*: UINT + lpfn*: BFFCALLBACK + lParam*: LPARAM + iImage*: int32 + PBROWSEINFOW* = ptr BROWSEINFOW + LPBROWSEINFOW* = ptr BROWSEINFOW + IThumbnailCapture* {.pure.} = object + lpVtbl*: ptr IThumbnailCaptureVtbl + IThumbnailCaptureVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CaptureThumbnail*: proc(self: ptr IThumbnailCapture, pMaxSize: ptr SIZE, pHTMLDoc2: ptr IUnknown, phbmThumbnail: ptr HBITMAP): HRESULT {.stdcall.} + LPTHUMBNAILCAPTURE* = ptr IThumbnailCapture + ENUMSHELLIMAGESTOREDATA* {.pure.} = object + szPath*: array[MAX_PATH, WCHAR] + ftTimeStamp*: FILETIME + PENUMSHELLIMAGESTOREDATA* = ptr ENUMSHELLIMAGESTOREDATA + IEnumShellImageStore* {.pure.} = object + lpVtbl*: ptr IEnumShellImageStoreVtbl + IEnumShellImageStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Reset*: proc(self: ptr IEnumShellImageStore): HRESULT {.stdcall.} + Next*: proc(self: ptr IEnumShellImageStore, celt: ULONG, prgElt: ptr PENUMSHELLIMAGESTOREDATA, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumShellImageStore, celt: ULONG): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumShellImageStore, ppEnum: ptr ptr IEnumShellImageStore): HRESULT {.stdcall.} + LPENUMSHELLIMAGESTORE* = ptr IEnumShellImageStore + IShellImageStore* {.pure.} = object + lpVtbl*: ptr IShellImageStoreVtbl + IShellImageStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Open*: proc(self: ptr IShellImageStore, dwMode: DWORD, pdwLock: ptr DWORD): HRESULT {.stdcall.} + Create*: proc(self: ptr IShellImageStore, dwMode: DWORD, pdwLock: ptr DWORD): HRESULT {.stdcall.} + ReleaseLock*: proc(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.stdcall.} + Close*: proc(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.stdcall.} + Commit*: proc(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.stdcall.} + IsLocked*: proc(self: ptr IShellImageStore): HRESULT {.stdcall.} + GetMode*: proc(self: ptr IShellImageStore, pdwMode: ptr DWORD): HRESULT {.stdcall.} + GetCapabilities*: proc(self: ptr IShellImageStore, pdwCapMask: ptr DWORD): HRESULT {.stdcall.} + AddEntry*: proc(self: ptr IShellImageStore, pszName: PCWSTR, pftTimeStamp: ptr FILETIME, dwMode: DWORD, hImage: HBITMAP): HRESULT {.stdcall.} + GetEntry*: proc(self: ptr IShellImageStore, pszName: PCWSTR, dwMode: DWORD, phImage: ptr HBITMAP): HRESULT {.stdcall.} + DeleteEntry*: proc(self: ptr IShellImageStore, pszName: PCWSTR): HRESULT {.stdcall.} + IsEntryInStore*: proc(self: ptr IShellImageStore, pszName: PCWSTR, pftTimeStamp: ptr FILETIME): HRESULT {.stdcall.} + Enum*: proc(self: ptr IShellImageStore, ppEnum: ptr LPENUMSHELLIMAGESTORE): HRESULT {.stdcall.} + LPSHELLIMAGESTORE* = ptr IShellImageStore + BANDINFOSFB* {.pure.} = object + dwMask*: DWORD + dwStateMask*: DWORD + dwState*: DWORD + crBkgnd*: COLORREF + crBtnLt*: COLORREF + crBtnDk*: COLORREF + wViewMode*: WORD + wAlign*: WORD + psf*: ptr IShellFolder + pidl*: PIDLIST_ABSOLUTE + PBANDINFOSFB* = ptr BANDINFOSFB + WALLPAPEROPT* {.pure.} = object + dwSize*: DWORD + dwStyle*: DWORD + LPWALLPAPEROPT* = ptr WALLPAPEROPT + LPCWALLPAPEROPT* = ptr WALLPAPEROPT + COMPONENTSOPT* {.pure.} = object + dwSize*: DWORD + fEnableComponents*: WINBOOL + fActiveDesktop*: WINBOOL + LPCOMPONENTSOPT* = ptr COMPONENTSOPT + LPCCOMPONENTSOPT* = ptr COMPONENTSOPT + COMPPOS* {.pure.} = object + dwSize*: DWORD + iLeft*: int32 + iTop*: int32 + dwWidth*: DWORD + dwHeight*: DWORD + izIndex*: int32 + fCanResize*: WINBOOL + fCanResizeX*: WINBOOL + fCanResizeY*: WINBOOL + iPreferredLeftPercent*: int32 + iPreferredTopPercent*: int32 + LPCOMPPOS* = ptr COMPPOS + LPCCOMPPOS* = ptr COMPPOS + COMPSTATEINFO* {.pure.} = object + dwSize*: DWORD + iLeft*: int32 + iTop*: int32 + dwWidth*: DWORD + dwHeight*: DWORD + dwItemState*: DWORD + LPCOMPSTATEINFO* = ptr COMPSTATEINFO + LPCCOMPSTATEINFO* = ptr COMPSTATEINFO + IE4COMPONENT* {.pure.} = object + dwSize*: DWORD + dwID*: DWORD + iComponentType*: int32 + fChecked*: WINBOOL + fDirty*: WINBOOL + fNoScroll*: WINBOOL + cpPos*: COMPPOS + wszFriendlyName*: array[MAX_PATH, WCHAR] + wszSource*: array[2084, WCHAR] + wszSubscribedURL*: array[2084, WCHAR] + LPIE4COMPONENT* = ptr IE4COMPONENT + LPCIE4COMPONENT* = ptr IE4COMPONENT + COMPONENT* {.pure.} = object + dwSize*: DWORD + dwID*: DWORD + iComponentType*: int32 + fChecked*: WINBOOL + fDirty*: WINBOOL + fNoScroll*: WINBOOL + cpPos*: COMPPOS + wszFriendlyName*: array[MAX_PATH, WCHAR] + wszSource*: array[2084, WCHAR] + wszSubscribedURL*: array[2084, WCHAR] + dwCurItemState*: DWORD + csiOriginal*: COMPSTATEINFO + csiRestored*: COMPSTATEINFO + LPCOMPONENT* = ptr COMPONENT + LPCCOMPONENT* = ptr COMPONENT + IActiveDesktop* {.pure.} = object + lpVtbl*: ptr IActiveDesktopVtbl + IActiveDesktopVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ApplyChanges*: proc(self: ptr IActiveDesktop, dwFlags: DWORD): HRESULT {.stdcall.} + GetWallpaper*: proc(self: ptr IActiveDesktop, pwszWallpaper: PWSTR, cchWallpaper: UINT, dwFlags: DWORD): HRESULT {.stdcall.} + SetWallpaper*: proc(self: ptr IActiveDesktop, pwszWallpaper: PCWSTR, dwReserved: DWORD): HRESULT {.stdcall.} + GetWallpaperOptions*: proc(self: ptr IActiveDesktop, pwpo: LPWALLPAPEROPT, dwReserved: DWORD): HRESULT {.stdcall.} + SetWallpaperOptions*: proc(self: ptr IActiveDesktop, pwpo: LPCWALLPAPEROPT, dwReserved: DWORD): HRESULT {.stdcall.} + GetPattern*: proc(self: ptr IActiveDesktop, pwszPattern: PWSTR, cchPattern: UINT, dwReserved: DWORD): HRESULT {.stdcall.} + SetPattern*: proc(self: ptr IActiveDesktop, pwszPattern: PCWSTR, dwReserved: DWORD): HRESULT {.stdcall.} + GetDesktopItemOptions*: proc(self: ptr IActiveDesktop, pco: LPCOMPONENTSOPT, dwReserved: DWORD): HRESULT {.stdcall.} + SetDesktopItemOptions*: proc(self: ptr IActiveDesktop, pco: LPCCOMPONENTSOPT, dwReserved: DWORD): HRESULT {.stdcall.} + AddDesktopItem*: proc(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + AddDesktopItemWithUI*: proc(self: ptr IActiveDesktop, hwnd: HWND, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + ModifyDesktopItem*: proc(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwFlags: DWORD): HRESULT {.stdcall.} + RemoveDesktopItem*: proc(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + GetDesktopItemCount*: proc(self: ptr IActiveDesktop, pcItems: ptr int32, dwReserved: DWORD): HRESULT {.stdcall.} + GetDesktopItem*: proc(self: ptr IActiveDesktop, nComponent: int32, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + GetDesktopItemByID*: proc(self: ptr IActiveDesktop, dwID: ULONG_PTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + GenerateDesktopItemHtml*: proc(self: ptr IActiveDesktop, pwszFileName: PCWSTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + AddUrl*: proc(self: ptr IActiveDesktop, hwnd: HWND, pszSource: PCWSTR, pcomp: LPCOMPONENT, dwFlags: DWORD): HRESULT {.stdcall.} + GetDesktopItemBySource*: proc(self: ptr IActiveDesktop, pwszSource: PCWSTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.stdcall.} + LPACTIVEDESKTOP* = ptr IActiveDesktop + IActiveDesktopP* {.pure.} = object + lpVtbl*: ptr IActiveDesktopPVtbl + IActiveDesktopPVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSafeMode*: proc(self: ptr IActiveDesktopP, dwFlags: DWORD): HRESULT {.stdcall.} + EnsureUpdateHTML*: proc(self: ptr IActiveDesktopP): HRESULT {.stdcall.} + SetScheme*: proc(self: ptr IActiveDesktopP, pwszSchemeName: PCWSTR, dwFlags: DWORD): HRESULT {.stdcall.} + GetScheme*: proc(self: ptr IActiveDesktopP, pwszSchemeName: PWSTR, pdwcchBuffer: ptr DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + LPACTIVEDESKTOPP* = ptr IActiveDesktopP + IADesktopP2* {.pure.} = object + lpVtbl*: ptr IADesktopP2Vtbl + IADesktopP2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + ReReadWallpaper*: proc(self: ptr IADesktopP2): HRESULT {.stdcall.} + GetADObjectFlags*: proc(self: ptr IADesktopP2, pdwFlags: ptr DWORD, dwMask: DWORD): HRESULT {.stdcall.} + UpdateAllDesktopSubscriptions*: proc(self: ptr IADesktopP2): HRESULT {.stdcall.} + MakeDynamicChanges*: proc(self: ptr IADesktopP2, pOleObj: ptr IOleObject): HRESULT {.stdcall.} + LPADESKTOPP2* = ptr IADesktopP2 +const + MAX_COLUMN_NAME_LEN* = 80 + MAX_COLUMN_DESC_LEN* = 128 +type + SHCOLUMNINFO* {.pure, packed.} = object + scid*: SHCOLUMNID + vt*: VARTYPE + fmt*: DWORD + cChars*: UINT + csFlags*: DWORD + wszTitle*: array[MAX_COLUMN_NAME_LEN, WCHAR] + wszDescription*: array[MAX_COLUMN_DESC_LEN, WCHAR] + LPSHCOLUMNINFO* = ptr SHCOLUMNINFO + LPCSHCOLUMNINFO* = ptr SHCOLUMNINFO + SHCOLUMNINIT* {.pure.} = object + dwFlags*: ULONG + dwReserved*: ULONG + wszFolder*: array[MAX_PATH, WCHAR] + LPSHCOLUMNINIT* = ptr SHCOLUMNINIT + LPCSHCOLUMNINIT* = ptr SHCOLUMNINIT + SHCOLUMNDATA* {.pure.} = object + dwFlags*: ULONG + dwFileAttributes*: DWORD + dwReserved*: ULONG + pwszExt*: ptr WCHAR + wszFile*: array[MAX_PATH, WCHAR] + LPSHCOLUMNDATA* = ptr SHCOLUMNDATA + LPCSHCOLUMNDATA* = ptr SHCOLUMNDATA + NRESARRAY* {.pure.} = object + cItems*: UINT + nr*: array[1, NETRESOURCE] + LPNRESARRAY* = ptr NRESARRAY + CIDA* {.pure.} = object + cidl*: UINT + aoffset*: array[1, UINT] + LPIDA* = ptr CIDA + FILEDESCRIPTORA* {.pure.} = object + dwFlags*: DWORD + clsid*: CLSID + sizel*: SIZEL + pointl*: POINTL + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + cFileName*: array[MAX_PATH, CHAR] + LPFILEDESCRIPTORA* = ptr FILEDESCRIPTORA + FILEDESCRIPTORW* {.pure.} = object + dwFlags*: DWORD + clsid*: CLSID + sizel*: SIZEL + pointl*: POINTL + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + cFileName*: array[MAX_PATH, WCHAR] + LPFILEDESCRIPTORW* = ptr FILEDESCRIPTORW + FILEGROUPDESCRIPTORA* {.pure.} = object + cItems*: UINT + fgd*: array[1, FILEDESCRIPTORA] + LPFILEGROUPDESCRIPTORA* = ptr FILEGROUPDESCRIPTORA + FILEGROUPDESCRIPTORW* {.pure.} = object + cItems*: UINT + fgd*: array[1, FILEDESCRIPTORW] + LPFILEGROUPDESCRIPTORW* = ptr FILEGROUPDESCRIPTORW + DROPFILES* {.pure.} = object + pFiles*: DWORD + pt*: POINT + fNC*: WINBOOL + fWide*: WINBOOL + LPDROPFILES* = ptr DROPFILES + SHChangeDWORDAsIDList* {.pure, packed.} = object + cb*: USHORT + dwItem1*: DWORD + dwItem2*: DWORD + cbZero*: USHORT + LPSHChangeDWORDAsIDList* = ptr SHChangeDWORDAsIDList + SHChangeUpdateImageIDList* {.pure, packed.} = object + cb*: USHORT + iIconIndex*: int32 + iCurIndex*: int32 + uFlags*: UINT + dwProcessID*: DWORD + szName*: array[MAX_PATH, WCHAR] + cbZero*: USHORT + LPSHChangeUpdateImageIDList* = ptr SHChangeUpdateImageIDList + SHChangeProductKeyAsIDList* {.pure.} = object + cb*: USHORT + wszProductKey*: array[39, WCHAR] + cbZero*: USHORT + LPSHChangeProductKeyAsIDList* = ptr SHChangeProductKeyAsIDList + SHDESCRIPTIONID* {.pure.} = object + dwDescriptionId*: DWORD + clsid*: CLSID + LPSHDESCRIPTIONID* = ptr SHDESCRIPTIONID + CABINETSTATE* {.pure.} = object + cLength*: WORD + nVersion*: WORD + fFullPathTitle* {.bitsize:1.}: WINBOOL + fSaveLocalView* {.bitsize:1.}: WINBOOL + fNotShell* {.bitsize:1.}: WINBOOL + fSimpleDefault* {.bitsize:1.}: WINBOOL + fDontShowDescBar* {.bitsize:1.}: WINBOOL + fNewWindowMode* {.bitsize:1.}: WINBOOL + fShowCompColor* {.bitsize:1.}: WINBOOL + fDontPrettyNames* {.bitsize:1.}: WINBOOL + fAdminsCreateCommonGroups* {.bitsize:1.}: WINBOOL + fUnusedFlags* {.bitsize:7.}: UINT + fMenuEnumFilter*: UINT + LPCABINETSTATE* = ptr CABINETSTATE + OPENASINFO* {.pure.} = object + pcszFile*: LPCWSTR + pcszClass*: LPCWSTR + oaifInFlags*: OPEN_AS_INFO_FLAGS + POPENASINFO* = ptr OPENASINFO +const + PIFNAMESIZE* = 30 + PIFSTARTLOCSIZE* = 63 + PIFPARAMSSIZE* = 64 + PIFDEFPATHSIZE* = 64 + PIFDEFFILESIZE* = 80 + PIFMAXFILEPATH* = 260 +type + PROPPRG* {.pure, packed.} = object + flPrg*: WORD + flPrgInit*: WORD + achTitle*: array[PIFNAMESIZE, CHAR] + achCmdLine*: array[PIFSTARTLOCSIZE+PIFPARAMSSIZE+1, CHAR] + achWorkDir*: array[PIFDEFPATHSIZE, CHAR] + wHotKey*: WORD + achIconFile*: array[PIFDEFFILESIZE, CHAR] + wIconIndex*: WORD + dwEnhModeFlags*: DWORD + dwRealModeFlags*: DWORD + achOtherFile*: array[PIFDEFFILESIZE, CHAR] + achPIFFile*: array[PIFMAXFILEPATH, CHAR] + PPROPPRG* = ptr PROPPRG + LPPROPPRG* = ptr PROPPRG + LPCPROPPRG* = ptr PROPPRG + QCMINFO_IDMAP_PLACEMENT* {.pure.} = object + id*: UINT + fFlags*: UINT + QCMINFO_IDMAP* {.pure.} = object + nMaxIds*: UINT + pIdList*: array[1, QCMINFO_IDMAP_PLACEMENT] + QCMINFO* {.pure.} = object + hmenu*: HMENU + indexMenu*: UINT + idCmdFirst*: UINT + idCmdLast*: UINT + pIdMap*: ptr QCMINFO_IDMAP + LPQCMINFO* = ptr QCMINFO + TBINFO* {.pure.} = object + cbuttons*: UINT + uFlags*: UINT + LPTBINFO* = ptr TBINFO + DETAILSINFO* {.pure.} = object + pidl*: PCUITEMID_CHILD + fmt*: int32 + cxChar*: int32 + str*: STRRET + iImage*: int32 + PDETAILSINFO* = ptr DETAILSINFO + DFMICS* {.pure.} = object + cbSize*: DWORD + fMask*: DWORD + lParam*: LPARAM + idCmdFirst*: UINT + idDefMax*: UINT + pici*: LPCMINVOKECOMMANDINFO + punkSite*: ptr IUnknown + PDFMICS* = ptr DFMICS + LPFNVIEWCALLBACK* = proc (psvOuter: ptr IShellView, psf: ptr IShellFolder, hwndMain: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + CSFV* {.pure.} = object + cbSize*: UINT + pshf*: ptr IShellFolder + psvOuter*: ptr IShellView + pidl*: PCIDLIST_ABSOLUTE + lEvents*: LONG + pfnCallback*: LPFNVIEWCALLBACK + fvm*: FOLDERVIEWMODE + LPCSFV* = ptr CSFV + SFV_SETITEMPOS* {.pure.} = object + pidl*: PCUITEMID_CHILD + pt*: POINT + LPSFV_SETITEMPOS* = ptr SFV_SETITEMPOS + PCSFV_SETITEMPOS* = ptr SFV_SETITEMPOS + SHELLSTATEA* {.pure, packed.} = object + fShowAllObjects* {.bitsize:1.}: WINBOOL + fShowExtensions* {.bitsize:1.}: WINBOOL + fNoConfirmRecycle* {.bitsize:1.}: WINBOOL + fShowSysFiles* {.bitsize:1.}: WINBOOL + fShowCompColor* {.bitsize:1.}: WINBOOL + fDoubleClickInWebView* {.bitsize:1.}: WINBOOL + fDesktopHTML* {.bitsize:1.}: WINBOOL + fWin95Classic* {.bitsize:1.}: WINBOOL + fDontPrettyPath* {.bitsize:1.}: WINBOOL + fShowAttribCol* {.bitsize:1.}: WINBOOL + fMapNetDrvBtn* {.bitsize:1.}: WINBOOL + fShowInfoTip* {.bitsize:1.}: WINBOOL + fHideIcons* {.bitsize:1.}: WINBOOL + fWebView* {.bitsize:1.}: WINBOOL + fFilter* {.bitsize:1.}: WINBOOL + fShowSuperHidden* {.bitsize:1.}: WINBOOL + fNoNetCrawling* {.bitsize:1.}: WINBOOL + dwWin95Unused*: DWORD + uWin95Unused*: UINT + lParamSort*: LONG + iSortDirection*: int32 + version*: UINT + uNotUsed*: UINT + fSepProcess* {.bitsize:1.}: WINBOOL + fStartPanelOn* {.bitsize:1.}: WINBOOL + fShowStartPage* {.bitsize:1.}: WINBOOL + fAutoCheckSelect* {.bitsize:1.}: WINBOOL + fIconsOnly* {.bitsize:1.}: WINBOOL + fShowTypeOverlay* {.bitsize:1.}: WINBOOL + fShowStatusBar* {.bitsize:1.}: WINBOOL + fSpareFlags* {.bitsize:9.}: UINT + padding*: array[2, byte] + LPSHELLSTATEA* = ptr SHELLSTATEA + SHELLSTATEW* {.pure, packed.} = object + fShowAllObjects* {.bitsize:1.}: WINBOOL + fShowExtensions* {.bitsize:1.}: WINBOOL + fNoConfirmRecycle* {.bitsize:1.}: WINBOOL + fShowSysFiles* {.bitsize:1.}: WINBOOL + fShowCompColor* {.bitsize:1.}: WINBOOL + fDoubleClickInWebView* {.bitsize:1.}: WINBOOL + fDesktopHTML* {.bitsize:1.}: WINBOOL + fWin95Classic* {.bitsize:1.}: WINBOOL + fDontPrettyPath* {.bitsize:1.}: WINBOOL + fShowAttribCol* {.bitsize:1.}: WINBOOL + fMapNetDrvBtn* {.bitsize:1.}: WINBOOL + fShowInfoTip* {.bitsize:1.}: WINBOOL + fHideIcons* {.bitsize:1.}: WINBOOL + fWebView* {.bitsize:1.}: WINBOOL + fFilter* {.bitsize:1.}: WINBOOL + fShowSuperHidden* {.bitsize:1.}: WINBOOL + fNoNetCrawling* {.bitsize:1.}: WINBOOL + dwWin95Unused*: DWORD + uWin95Unused*: UINT + lParamSort*: LONG + iSortDirection*: int32 + version*: UINT + uNotUsed*: UINT + fSepProcess* {.bitsize:1.}: WINBOOL + fStartPanelOn* {.bitsize:1.}: WINBOOL + fShowStartPage* {.bitsize:1.}: WINBOOL + fAutoCheckSelect* {.bitsize:1.}: WINBOOL + fIconsOnly* {.bitsize:1.}: WINBOOL + fShowTypeOverlay* {.bitsize:1.}: WINBOOL + fShowStatusBar* {.bitsize:1.}: WINBOOL + fSpareFlags* {.bitsize:9.}: UINT + padding*: array[2, byte] + LPSHELLSTATEW* = ptr SHELLSTATEW + SHELLFLAGSTATE* {.pure.} = object + fShowAllObjects* {.bitsize:1.}: WINBOOL + fShowExtensions* {.bitsize:1.}: WINBOOL + fNoConfirmRecycle* {.bitsize:1.}: WINBOOL + fShowSysFiles* {.bitsize:1.}: WINBOOL + fShowCompColor* {.bitsize:1.}: WINBOOL + fDoubleClickInWebView* {.bitsize:1.}: WINBOOL + fDesktopHTML* {.bitsize:1.}: WINBOOL + fWin95Classic* {.bitsize:1.}: WINBOOL + fDontPrettyPath* {.bitsize:1.}: WINBOOL + fShowAttribCol* {.bitsize:1.}: WINBOOL + fMapNetDrvBtn* {.bitsize:1.}: WINBOOL + fShowInfoTip* {.bitsize:1.}: WINBOOL + fHideIcons* {.bitsize:1.}: WINBOOL + fAutoCheckSelect* {.bitsize:1.}: WINBOOL + fIconsOnly* {.bitsize:1.}: WINBOOL + fRestFlags* {.bitsize:1.}: UINT + LPSHELLFLAGSTATE* = ptr SHELLFLAGSTATE + AASHELLMENUFILENAME* {.pure.} = object + cbTotal*: SHORT + rgbReserved*: array[12, BYTE] + szFileName*: array[1, WCHAR] + LPAASHELLMENUFILENAME* = ptr AASHELLMENUFILENAME + AASHELLMENUITEM* {.pure.} = object + lpReserved1*: pointer + iReserved*: int32 + uiReserved*: UINT + lpName*: LPAASHELLMENUFILENAME + psz*: LPWSTR + LPAASHELLMENUITEM* = ptr AASHELLMENUITEM + SMCSHCHANGENOTIFYSTRUCT* {.pure.} = object + lEvent*: LONG + pidl1*: PCIDLIST_ABSOLUTE + pidl2*: PCIDLIST_ABSOLUTE + PSMCSHCHANGENOTIFYSTRUCT* = ptr SMCSHCHANGENOTIFYSTRUCT +const + ABM_NEW* = 0x00000000 + ABM_REMOVE* = 0x00000001 + ABM_QUERYPOS* = 0x00000002 + ABM_SETPOS* = 0x00000003 + ABM_GETSTATE* = 0x00000004 + ABM_GETTASKBARPOS* = 0x00000005 + ABM_ACTIVATE* = 0x00000006 + ABM_GETAUTOHIDEBAR* = 0x00000007 + ABM_SETAUTOHIDEBAR* = 0x00000008 + ABM_WINDOWPOSCHANGED* = 0x0000009 + ABM_SETSTATE* = 0x0000000a + ABM_GETAUTOHIDEBAREX* = 0x0000000b + ABM_SETAUTOHIDEBAREX* = 0x0000000c + ABN_STATECHANGE* = 0x0000000 + ABN_POSCHANGED* = 0x0000001 + ABN_FULLSCREENAPP* = 0x0000002 + ABN_WINDOWARRANGE* = 0x0000003 + ABS_AUTOHIDE* = 0x0000001 + ABS_ALWAYSONTOP* = 0x0000002 + ABE_LEFT* = 0 + ABE_TOP* = 1 + ABE_RIGHT* = 2 + ABE_BOTTOM* = 3 + FO_MOVE* = 0x1 + FO_COPY* = 0x2 + FO_DELETE* = 0x3 + FO_RENAME* = 0x4 + FOF_MULTIDESTFILES* = 0x1 + FOF_CONFIRMMOUSE* = 0x2 + FOF_SILENT* = 0x4 + FOF_RENAMEONCOLLISION* = 0x8 + FOF_NOCONFIRMATION* = 0x10 + FOF_WANTMAPPINGHANDLE* = 0x20 + FOF_ALLOWUNDO* = 0x40 + FOF_FILESONLY* = 0x80 + FOF_SIMPLEPROGRESS* = 0x100 + FOF_NOCONFIRMMKDIR* = 0x200 + FOF_NOERRORUI* = 0x400 + FOF_NOCOPYSECURITYATTRIBS* = 0x800 + FOF_NORECURSION* = 0x1000 + FOF_NO_CONNECTED_ELEMENTS* = 0x2000 + FOF_WANTNUKEWARNING* = 0x4000 + FOF_NORECURSEREPARSE* = 0x8000 + FOF_NO_UI* = FOF_SILENT or FOF_NOCONFIRMATION or FOF_NOERRORUI or FOF_NOCONFIRMMKDIR + PO_DELETE* = 0x0013 + PO_RENAME* = 0x0014 + PO_PORTCHANGE* = 0x0020 + PO_REN_PORT* = 0x0034 + SE_ERR_FNF* = 2 + SE_ERR_PNF* = 3 + SE_ERR_ACCESSDENIED* = 5 + SE_ERR_OOM* = 8 + SE_ERR_DLLNOTFOUND* = 32 + SE_ERR_SHARE* = 26 + SE_ERR_ASSOCINCOMPLETE* = 27 + SE_ERR_DDETIMEOUT* = 28 + SE_ERR_DDEFAIL* = 29 + SE_ERR_DDEBUSY* = 30 + SE_ERR_NOASSOC* = 31 + SEE_MASK_DEFAULT* = 0x0 + SEE_MASK_CLASSNAME* = 0x1 + SEE_MASK_CLASSKEY* = 0x3 + SEE_MASK_IDLIST* = 0x4 + SEE_MASK_INVOKEIDLIST* = 0xc + SEE_MASK_ICON* = 0x10 + SEE_MASK_HOTKEY* = 0x20 + SEE_MASK_NOCLOSEPROCESS* = 0x40 + SEE_MASK_CONNECTNETDRV* = 0x80 + SEE_MASK_NOASYNC* = 0x100 + SEE_MASK_FLAG_DDEWAIT* = SEE_MASK_NOASYNC + SEE_MASK_DOENVSUBST* = 0x200 + SEE_MASK_FLAG_NO_UI* = 0x400 + SEE_MASK_UNICODE* = 0x4000 + SEE_MASK_NO_CONSOLE* = 0x8000 + SEE_MASK_ASYNCOK* = 0x100000 + SEE_MASK_HMONITOR* = 0x200000 + SEE_MASK_NOZONECHECKS* = 0x800000 + SEE_MASK_NOQUERYCLASSSTORE* = 0x1000000 + SEE_MASK_WAITFORINPUTIDLE* = 0x2000000 + SEE_MASK_FLAG_LOG_USAGE* = 0x4000000 + SEE_MASK_FLAG_HINST_IS_SITE* = 0x8000000 + ASSOCCLASS_SHELL_KEY* = 0 + ASSOCCLASS_PROGID_KEY* = 1 + ASSOCCLASS_PROGID_STR* = 2 + ASSOCCLASS_CLSID_KEY* = 3 + ASSOCCLASS_CLSID_STR* = 4 + ASSOCCLASS_APP_KEY* = 5 + ASSOCCLASS_APP_STR* = 6 + ASSOCCLASS_SYSTEM_STR* = 7 + ASSOCCLASS_FOLDER* = 8 + ASSOCCLASS_STAR* = 9 + ASSOCCLASS_FIXED_PROGID_STR* = 10 + ASSOCCLASS_PROTOCOL_STR* = 11 + SHERB_NOCONFIRMATION* = 0x00000001 + SHERB_NOPROGRESSUI* = 0x00000002 + SHERB_NOSOUND* = 0x00000004 + QUNS_NOT_PRESENT* = 1 + QUNS_BUSY* = 2 + QUNS_RUNNING_D3D_FULL_SCREEN* = 3 + QUNS_PRESENTATION_MODE* = 4 + QUNS_ACCEPTS_NOTIFICATIONS* = 5 + QUNS_QUIET_TIME* = 6 + QUNS_APP* = 7 + NIN_SELECT* = WM_USER+0 + NINF_KEY* = 0x1 + NIN_KEYSELECT* = NIN_SELECT or NINF_KEY + NIN_BALLOONSHOW* = WM_USER+2 + NIN_BALLOONHIDE* = WM_USER+3 + NIN_BALLOONTIMEOUT* = WM_USER+4 + NIN_BALLOONUSERCLICK* = WM_USER+5 + NIN_POPUPOPEN* = WM_USER+6 + NIN_POPUPCLOSE* = WM_USER+7 + NIM_ADD* = 0x00000000 + NIM_MODIFY* = 0x00000001 + NIM_DELETE* = 0x00000002 + NIM_SETFOCUS* = 0x00000003 + NIM_SETVERSION* = 0x00000004 + NOTIFYICON_VERSION* = 3 + NOTIFYICON_VERSION_4* = 4 + NIF_MESSAGE* = 0x00000001 + NIF_ICON* = 0x00000002 + NIF_TIP* = 0x00000004 + NIF_STATE* = 0x00000008 + NIF_INFO* = 0x00000010 + NIF_GUID* = 0x00000020 + NIF_REALTIME* = 0x00000040 + NIF_SHOWTIP* = 0x00000080 + NIS_HIDDEN* = 0x00000001 + NIS_SHAREDICON* = 0x00000002 + NIIF_NONE* = 0x00000000 + NIIF_INFO* = 0x00000001 + NIIF_WARNING* = 0x00000002 + NIIF_ERROR* = 0x00000003 + NIIF_USER* = 0x00000004 + NIIF_ICON_MASK* = 0x0000000f + NIIF_NOSOUND* = 0x00000010 + NIIF_LARGE_ICON* = 0x00000020 + NIIF_RESPECT_QUIET_TIME* = 0x00000080 + SHGFI_ICON* = 0x000000100 + SHGFI_DISPLAYNAME* = 0x000000200 + SHGFI_TYPENAME* = 0x000000400 + SHGFI_ATTRIBUTES* = 0x000000800 + SHGFI_ICONLOCATION* = 0x000001000 + SHGFI_EXETYPE* = 0x000002000 + SHGFI_SYSICONINDEX* = 0x000004000 + SHGFI_LINKOVERLAY* = 0x000008000 + SHGFI_SELECTED* = 0x000010000 + SHGFI_ATTR_SPECIFIED* = 0x000020000 + SHGFI_LARGEICON* = 0x000000000 + SHGFI_SMALLICON* = 0x000000001 + SHGFI_OPENICON* = 0x000000002 + SHGFI_SHELLICONSIZE* = 0x000000004 + SHGFI_PIDL* = 0x000000008 + SHGFI_USEFILEATTRIBUTES* = 0x000000010 + SHGFI_ADDOVERLAYS* = 0x000000020 + SHGFI_OVERLAYINDEX* = 0x000000040 + SHGSI_ICONLOCATION* = 0 + SHGSI_ICON* = SHGFI_ICON + SHGSI_SYSICONINDEX* = SHGFI_SYSICONINDEX + SHGSI_LINKOVERLAY* = SHGFI_LINKOVERLAY + SHGSI_SELECTED* = SHGFI_SELECTED + SHGSI_LARGEICON* = SHGFI_LARGEICON + SHGSI_SMALLICON* = SHGFI_SMALLICON + SHGSI_SHELLICONSIZE* = SHGFI_SHELLICONSIZE + SIID_DOCNOASSOC* = 0 + SIID_DOCASSOC* = 1 + SIID_APPLICATION* = 2 + SIID_FOLDER* = 3 + SIID_FOLDEROPEN* = 4 + SIID_DRIVE525* = 5 + SIID_DRIVE35* = 6 + SIID_DRIVEREMOVE* = 7 + SIID_DRIVEFIXED* = 8 + SIID_DRIVENET* = 9 + SIID_DRIVENETDISABLED* = 10 + SIID_DRIVECD* = 11 + SIID_DRIVERAM* = 12 + SIID_WORLD* = 13 + SIID_SERVER* = 15 + SIID_PRINTER* = 16 + SIID_MYNETWORK* = 17 + SIID_FIND* = 22 + SIID_HELP* = 23 + SIID_SHARE* = 28 + SIID_LINK* = 29 + SIID_SLOWFILE* = 30 + SIID_RECYCLER* = 31 + SIID_RECYCLERFULL* = 32 + SIID_MEDIACDAUDIO* = 40 + SIID_LOCK* = 47 + SIID_AUTOLIST* = 49 + SIID_PRINTERNET* = 50 + SIID_SERVERSHARE* = 51 + SIID_PRINTERFAX* = 52 + SIID_PRINTERFAXNET* = 53 + SIID_PRINTERFILE* = 54 + SIID_STACK* = 55 + SIID_MEDIASVCD* = 56 + SIID_STUFFEDFOLDER* = 57 + SIID_DRIVEUNKNOWN* = 58 + SIID_DRIVEDVD* = 59 + SIID_MEDIADVD* = 60 + SIID_MEDIADVDRAM* = 61 + SIID_MEDIADVDRW* = 62 + SIID_MEDIADVDR* = 63 + SIID_MEDIADVDROM* = 64 + SIID_MEDIACDAUDIOPLUS* = 65 + SIID_MEDIACDRW* = 66 + SIID_MEDIACDR* = 67 + SIID_MEDIACDBURN* = 68 + SIID_MEDIABLANKCD* = 69 + SIID_MEDIACDROM* = 70 + SIID_AUDIOFILES* = 71 + SIID_IMAGEFILES* = 72 + SIID_VIDEOFILES* = 73 + SIID_MIXEDFILES* = 74 + SIID_FOLDERBACK* = 75 + SIID_FOLDERFRONT* = 76 + SIID_SHIELD* = 77 + SIID_WARNING* = 78 + SIID_INFO* = 79 + SIID_ERROR* = 80 + SIID_KEY* = 81 + SIID_SOFTWARE* = 82 + SIID_RENAME* = 83 + SIID_DELETE* = 84 + SIID_MEDIAAUDIODVD* = 85 + SIID_MEDIAMOVIEDVD* = 86 + SIID_MEDIAENHANCEDCD* = 87 + SIID_MEDIAENHANCEDDVD* = 88 + SIID_MEDIAHDDVD* = 89 + SIID_MEDIABLURAY* = 90 + SIID_MEDIAVCD* = 91 + SIID_MEDIADVDPLUSR* = 92 + SIID_MEDIADVDPLUSRW* = 93 + SIID_DESKTOPPC* = 94 + SIID_MOBILEPC* = 95 + SIID_USERS* = 96 + SIID_MEDIASMARTMEDIA* = 97 + SIID_MEDIACOMPACTFLASH* = 98 + SIID_DEVICECELLPHONE* = 99 + SIID_DEVICECAMERA* = 100 + SIID_DEVICEVIDEOCAMERA* = 101 + SIID_DEVICEAUDIOPLAYER* = 102 + SIID_NETWORKCONNECT* = 103 + SIID_INTERNET* = 104 + SIID_ZIPFILE* = 105 + SIID_SETTINGS* = 106 + SIID_DRIVEHDDVD* = 132 + SIID_DRIVEBD* = 133 + SIID_MEDIAHDDVDROM* = 134 + SIID_MEDIAHDDVDR* = 135 + SIID_MEDIAHDDVDRAM* = 136 + SIID_MEDIABDROM* = 137 + SIID_MEDIABDR* = 138 + SIID_MEDIABDRE* = 139 + SIID_CLUSTEREDDRIVE* = 140 + SIID_MAX_ICONS* = 175 + SIID_INVALID* = SHSTOCKICONID(-1) + SHGNLI_PIDL* = 0x000000001 + SHGNLI_PREFIXNAME* = 0x000000002 + SHGNLI_NOUNIQUE* = 0x000000004 + SHGNLI_NOLNK* = 0x000000008 + SHGNLI_NOLOCNAME* = 0x000000010 + SHGNLI_USEURLEXT* = 0x000000020 + PRINTACTION_OPEN* = 0 + PRINTACTION_PROPERTIES* = 1 + PRINTACTION_NETINSTALL* = 2 + PRINTACTION_NETINSTALLLINK* = 3 + PRINTACTION_TESTPAGE* = 4 + PRINTACTION_OPENNETPRN* = 5 + PRINTACTION_DOCUMENTDEFAULTS* = 6 + PRINTACTION_SERVERPROPERTIES* = 7 + PRINT_PROP_FORCE_NAME* = 0x01 + OFFLINE_STATUS_LOCAL* = 0x0001 + OFFLINE_STATUS_REMOTE* = 0x0002 + OFFLINE_STATUS_INCOMPLETE* = 0x0004 + SHIL_LARGE* = 0 + SHIL_SMALL* = 1 + SHIL_EXTRALARGE* = 2 + SHIL_SYSSMALL* = 3 + SHIL_JUMBO* = 4 + SHIL_LAST* = SHIL_JUMBO + WC_NETADDRESS* = "msctls_netaddress" + NCM_GETADDRESS* = WM_USER+1 + NCM_SETALLOWTYPE* = WM_USER+2 + NCM_GETALLOWTYPE* = WM_USER+3 + NCM_DISPLAYERRORTIP* = WM_USER+4 + SZ_CONTENTTYPE_HTMLA* = "text/html" + SZ_CONTENTTYPE_HTMLW* = "text/html" + SZ_CONTENTTYPE_CDFA* = "application/x-cdf" + SZ_CONTENTTYPE_CDFW* = "application/x-cdf" + STIF_DEFAULT* = 0x00000000 + STIF_SUPPORT_HEX* = 0x00000001 + GCT_INVALID* = 0x0000 + GCT_LFNCHAR* = 0x0001 + GCT_SHORTCHAR* = 0x0002 + GCT_WILD* = 0x0004 + GCT_SEPARATOR* = 0x0008 + URL_SCHEME_INVALID* = -1 + URL_SCHEME_UNKNOWN* = 0 + URL_SCHEME_FTP* = 1 + URL_SCHEME_HTTP* = 2 + URL_SCHEME_GOPHER* = 3 + URL_SCHEME_MAILTO* = 4 + URL_SCHEME_NEWS* = 5 + URL_SCHEME_NNTP* = 6 + URL_SCHEME_TELNET* = 7 + URL_SCHEME_WAIS* = 8 + URL_SCHEME_FILE* = 9 + URL_SCHEME_MK* = 10 + URL_SCHEME_HTTPS* = 11 + URL_SCHEME_SHELL* = 12 + URL_SCHEME_SNEWS* = 13 + URL_SCHEME_LOCAL* = 14 + URL_SCHEME_JAVASCRIPT* = 15 + URL_SCHEME_VBSCRIPT* = 16 + URL_SCHEME_ABOUT* = 17 + URL_SCHEME_RES* = 18 + URL_SCHEME_MSSHELLROOTED* = 19 + URL_SCHEME_MSSHELLIDLIST* = 20 + URL_SCHEME_MSHELP* = 21 + URL_SCHEME_MAXVALUE* = 22 + URL_PART_NONE* = 0 + URL_PART_SCHEME* = 1 + URL_PART_HOSTNAME* = 2 + URL_PART_USERNAME* = 3 + URL_PART_PASSWORD* = 4 + URL_PART_PORT* = 5 + URL_PART_QUERY* = 6 + urlIsUrl* = 0 + urlIsOpaque* = 1 + urlIsNohistory* = 2 + urlIsFileurl* = 3 + urlIsAppliable* = 4 + urlIsDirectory* = 5 + urlIsHasquery* = 6 + urlUnescape* = 0x10000000 + URL_ESCAPE_UNSAFE* = 0x20000000 + URL_PLUGGABLE_PROTOCOL* = 0x40000000 + URL_WININET_COMPATIBILITY* = 0x80000000'i32 + URL_DONT_ESCAPE_EXTRA_INFO* = 0x02000000 + URL_DONT_UNESCAPE_EXTRA_INFO* = URL_DONT_ESCAPE_EXTRA_INFO + URL_BROWSER_MODE* = URL_DONT_ESCAPE_EXTRA_INFO + URL_ESCAPE_SPACES_ONLY* = 0x04000000 + URL_DONT_SIMPLIFY* = 0x08000000 + URL_NO_META* = URL_DONT_SIMPLIFY + URL_UNESCAPE_INPLACE* = 0x00100000 + URL_CONVERT_IF_DOSPATH* = 0x00200000 + URL_UNESCAPE_HIGH_ANSI_ONLY* = 0x00400000 + URL_INTERNAL_PATH* = 0x00800000 + URL_FILE_USE_PATHURL* = 0x00010000 + URL_DONT_UNESCAPE* = 0x00020000 + URL_ESCAPE_PERCENT* = 0x00001000 + URL_ESCAPE_SEGMENT_ONLY* = 0x00002000 + URL_PARTFLAG_KEEPSCHEME* = 0x00000001 + URL_APPLY_DEFAULT* = 0x00000001 + URL_APPLY_GUESSSCHEME* = 0x00000002 + URL_APPLY_GUESSFILE* = 0x00000004 + URL_APPLY_FORCEAPPLY* = 0x00000008 + SRRF_RT_REG_NONE* = 0x00000001 + SRRF_RT_REG_SZ* = 0x00000002 + SRRF_RT_REG_EXPAND_SZ* = 0x00000004 + SRRF_RT_REG_BINARY* = 0x00000008 + SRRF_RT_REG_DWORD* = 0x00000010 + SRRF_RT_REG_MULTI_SZ* = 0x00000020 + SRRF_RT_REG_QWORD* = 0x00000040 + SRRF_RT_DWORD* = SRRF_RT_REG_BINARY or SRRF_RT_REG_DWORD + SRRF_RT_QWORD* = SRRF_RT_REG_BINARY or SRRF_RT_REG_QWORD + SRRF_RT_ANY* = 0x0000ffff + SRRF_RM_ANY* = 0x00000000 + SRRF_RM_NORMAL* = 0x00010000 + SRRF_RM_SAFE* = 0x00020000 + SRRF_RM_SAFENETWORK* = 0x00040000 + SRRF_NOEXPAND* = 0x10000000 + SRRF_ZEROONFAILURE* = 0x20000000 + SHREGDEL_DEFAULT* = 0x00000000 + SHREGDEL_HKCU* = 0x00000001 + SHREGDEL_HKLM* = 0x00000010 + SHREGDEL_BOTH* = 0x00000011 + SHREGENUM_DEFAULT* = 0x00000000 + SHREGENUM_HKCU* = 0x00000001 + SHREGENUM_HKLM* = 0x00000010 + SHREGENUM_BOTH* = 0x00000011 + SHREGSET_HKCU* = 0x00000001 + SHREGSET_FORCE_HKCU* = 0x00000002 + SHREGSET_HKLM* = 0x00000004 + SHREGSET_FORCE_HKLM* = 0x00000008 + SHREGSET_DEFAULT* = SHREGSET_FORCE_HKCU or SHREGSET_HKLM + ASSOCF_INIT_NOREMAPCLSID* = 0x00000001 + ASSOCF_INIT_BYEXENAME* = 0x00000002 + ASSOCF_OPEN_BYEXENAME* = 0x00000002 + ASSOCF_INIT_DEFAULTTOSTAR* = 0x00000004 + ASSOCF_INIT_DEFAULTTOFOLDER* = 0x00000008 + ASSOCF_NOUSERSETTINGS* = 0x00000010 + ASSOCF_NOTRUNCATE* = 0x00000020 + ASSOCF_VERIFY* = 0x00000040 + ASSOCF_REMAPRUNDLL* = 0x00000080 + ASSOCF_NOFIXUPS* = 0x00000100 + ASSOCF_IGNOREBASECLASS* = 0x00000200 + ASSOCF_INIT_IGNOREUNKNOWN* = 0x00000400 + ASSOCSTR_COMMAND* = 1 + ASSOCSTR_EXECUTABLE* = 2 + ASSOCSTR_FRIENDLYDOCNAME* = 3 + ASSOCSTR_FRIENDLYAPPNAME* = 4 + ASSOCSTR_NOOPEN* = 5 + ASSOCSTR_SHELLNEWVALUE* = 6 + ASSOCSTR_DDECOMMAND* = 7 + ASSOCSTR_DDEIFEXEC* = 8 + ASSOCSTR_DDEAPPLICATION* = 9 + ASSOCSTR_DDETOPIC* = 10 + ASSOCSTR_INFOTIP* = 11 + ASSOCSTR_QUICKTIP* = 12 + ASSOCSTR_TILEINFO* = 13 + ASSOCSTR_CONTENTTYPE* = 14 + ASSOCSTR_DEFAULTICON* = 15 + ASSOCSTR_SHELLEXTENSION* = 16 + ASSOCSTR_DROPTARGET* = 17 + ASSOCSTR_DELEGATEEXECUTE* = 18 + ASSOCSTR_MAX* = 19 + ASSOCKEY_SHELLEXECCLASS* = 1 + ASSOCKEY_APP* = 2 + ASSOCKEY_CLASS* = 3 + ASSOCKEY_BASECLASS* = 4 + ASSOCKEY_MAX* = 5 + ASSOCDATA_MSIDESCRIPTOR* = 1 + ASSOCDATA_NOACTIVATEHANDLER* = 2 + ASSOCDATA_QUERYCLASSSTORE* = 3 + ASSOCDATA_HASPERUSERASSOC* = 4 + ASSOCDATA_EDITFLAGS* = 5 + ASSOCDATA_VALUE* = 6 + ASSOCDATA_MAX* = 7 + ASSOCENUM_NONE* = 0 + SHGVSPB_PERUSER* = 0x00000001 + SHGVSPB_ALLUSERS* = 0x00000002 + SHGVSPB_PERFOLDER* = 0x00000004 + SHGVSPB_ALLFOLDERS* = 0x00000008 + SHGVSPB_INHERIT* = 0x00000010 + SHGVSPB_ROAM* = 0x00000020 + SHGVSPB_NOAUTODEFAULTS* = 0x80000000'i32 + SHGVSPB_FOLDER* = SHGVSPB_PERUSER or SHGVSPB_PERFOLDER + SHGVSPB_FOLDERNODEFAULTS* = SHGVSPB_PERUSER or SHGVSPB_PERFOLDER or SHGVSPB_NOAUTODEFAULTS + SHGVSPB_USERDEFAULTS* = SHGVSPB_PERUSER or SHGVSPB_ALLFOLDERS + SHGVSPB_GLOBALDEAFAULTS* = SHGVSPB_ALLUSERS or SHGVSPB_ALLFOLDERS + SHACF_DEFAULT* = 0x00000000 + SHACF_FILESYSTEM* = 0x00000001 + SHACF_URLHISTORY* = 0x00000002 + SHACF_URLMRU* = 0x00000004 + SHACF_URLALL* = SHACF_URLHISTORY or SHACF_URLMRU + SHACF_USETAB* = 0x00000008 + SHACF_FILESYS_ONLY* = 0x00000010 + SHACF_FILESYS_DIRS* = 0x00000020 + SHACF_AUTOSUGGEST_FORCE_ON* = 0x10000000 + SHACF_AUTOSUGGEST_FORCE_OFF* = 0x20000000 + SHACF_AUTOAPPEND_FORCE_ON* = 0x40000000 + SHACF_AUTOAPPEND_FORCE_OFF* = 0x80000000'i32 + CTF_INSIST* = 0x00000001 + CTF_THREAD_REF* = 0x00000002 + CTF_PROCESS_REF* = 0x00000004 + CTF_COINIT* = 0x00000008 + CTF_FREELIBANDEXIT* = 0x00000010 + CTF_REF_COUNTED* = 0x00000020 + CTF_WAIT_ALLOWCOM* = 0x00000040 + DLLVER_PLATFORM_WINDOWS* = 0x00000001 + DLLVER_PLATFORM_NT* = 0x00000002 + DLLVER_MAJOR_MASK* = 0xFFFF000000000000 + DLLVER_MINOR_MASK* = 0x0000FFFF00000000 + DLLVER_BUILD_MASK* = 0x00000000FFFF0000'i32 + DLLVER_QFE_MASK* = 0x000000000000FFFF + CSIDL_FLAG_CREATE* = 0x8000 + CSIDL_PERSONAL* = 0x0005 + CSIDL_MYPICTURES* = 0x0027 + CSIDL_APPDATA* = 0x001a + CSIDL_MYMUSIC* = 0x000d + CSIDL_MYVIDEO* = 0x000e + SHGFP_TYPE_CURRENT* = 0 + SHGFP_TYPE_DEFAULT* = 1 + STR_MYDOCS_CLSID* = "{450D8FBA-AD25-11D0-98A8-0800361B1103}" + PSGUID_INTERNETSHORTCUT* = DEFINE_GUID("000214a0-0000-0000-c000-000000000046") + PSGUID_INTERNETSITE* = DEFINE_GUID("000214a1-0000-0000-c000-000000000046") + IID_ICopyHookA* = DEFINE_GUID("000214ef-0000-0000-c000-000000000046") + IID_IShellCopyHookA* = IID_ICopyHookA + IID_ICopyHookW* = DEFINE_GUID("000214fc-0000-0000-c000-000000000046") + IID_IShellCopyHookW* = IID_ICopyHookW + IID_IShellLinkW* = DEFINE_GUID("000214f9-0000-0000-c000-000000000046") + SID_LinkSite* = IID_IShellLinkW + IID_IShellFolderViewCB* = DEFINE_GUID("2047e320-f2a9-11ce-ae65-08002b2e1262") + SID_ShellFolderViewCB* = IID_IShellFolderViewCB + IID_IShellBrowser* = DEFINE_GUID("000214e2-0000-0000-c000-000000000046") + SID_SShellBrowser* = IID_IShellBrowser + CLSID_ShellDesktop* = DEFINE_GUID("00021400-0000-0000-c000-000000000046") + SID_SShellDesktop* = CLSID_ShellDesktop + CLSID_NetworkDomain* = DEFINE_GUID("46e06680-4bf0-11d1-83ee-00a0c90dc849") + CLSID_NetworkServer* = DEFINE_GUID("c0542a90-4bf0-11d1-83ee-00a0c90dc849") + CLSID_NetworkShare* = DEFINE_GUID("54a754c0-4bf0-11d1-83ee-00a0c90dc849") + CLSID_MyComputer* = DEFINE_GUID("20d04fe0-3aea-1069-a2d8-08002b30309d") + CLSID_Internet* = DEFINE_GUID("871c5380-42a0-1069-a2ea-08002b30309d") + CLSID_RecycleBin* = DEFINE_GUID("645ff040-5081-101b-9f08-00aa002f954e") + CLSID_ControlPanel* = DEFINE_GUID("21ec2020-3aea-1069-a2dd-08002b30309d") + CLSID_Printers* = DEFINE_GUID("2227a280-3aea-1069-a2de-08002b30309d") + CLSID_MyDocuments* = DEFINE_GUID("450d8fba-ad25-11d0-98a8-0800361b1103") + CATID_BrowsableShellExt* = DEFINE_GUID("00021490-0000-0000-c000-000000000046") + CATID_BrowseInPlace* = DEFINE_GUID("00021491-0000-0000-c000-000000000046") + CATID_DeskBand* = DEFINE_GUID("00021492-0000-0000-c000-000000000046") + CATID_InfoBand* = DEFINE_GUID("00021493-0000-0000-c000-000000000046") + CATID_CommBand* = DEFINE_GUID("00021494-0000-0000-c000-000000000046") + FMTID_Intshcut* = DEFINE_GUID("000214a0-0000-0000-c000-000000000046") + FMTID_InternetSite* = DEFINE_GUID("000214a1-0000-0000-c000-000000000046") + CGID_Explorer* = DEFINE_GUID("000214d0-0000-0000-c000-000000000046") + CGID_ShellDocView* = DEFINE_GUID("000214d1-0000-0000-c000-000000000046") + CGID_ShellServiceObject* = DEFINE_GUID("000214d2-0000-0000-c000-000000000046") + CGID_ExplorerBarDoc* = DEFINE_GUID("000214d3-0000-0000-c000-000000000046") + IID_INewShortcutHookA* = DEFINE_GUID("000214e1-0000-0000-c000-000000000046") + IID_IExtractIconA* = DEFINE_GUID("000214eb-0000-0000-c000-000000000046") + IID_IShellDetails* = DEFINE_GUID("000214ec-0000-0000-c000-000000000046") + IID_IFileViewerA* = DEFINE_GUID("000214f0-0000-0000-c000-000000000046") + IID_IFileViewerSite* = DEFINE_GUID("000214f3-0000-0000-c000-000000000046") + IID_IShellExecuteHookA* = DEFINE_GUID("000214f5-0000-0000-c000-000000000046") + IID_IPropSheetPage* = DEFINE_GUID("000214f6-0000-0000-c000-000000000046") + IID_INewShortcutHookW* = DEFINE_GUID("000214f7-0000-0000-c000-000000000046") + IID_IFileViewerW* = DEFINE_GUID("000214f8-0000-0000-c000-000000000046") + IID_IExtractIconW* = DEFINE_GUID("000214fa-0000-0000-c000-000000000046") + IID_IShellExecuteHookW* = DEFINE_GUID("000214fb-0000-0000-c000-000000000046") + IID_IQueryInfo* = DEFINE_GUID("00021500-0000-0000-c000-000000000046") + IID_IBriefcaseStg* = DEFINE_GUID("8bce1fa1-0921-101b-b1ff-00dd010ccc48") + IID_IURLSearchHook* = DEFINE_GUID("ac60f6a0-0fd9-11d0-99cb-00c04fd64497") + IID_ISearchContext* = DEFINE_GUID("09f656a2-41af-480c-88f7-16cc0d164615") + IID_IURLSearchHook2* = DEFINE_GUID("5ee44da4-6d32-46e3-86bc-07540dedd0e0") + IID_IDefViewID* = DEFINE_GUID("985f64f0-d410-4e02-be22-da07f2b5c5e1") + CLSID_FolderShortcut* = DEFINE_GUID("0afaced1-e828-11d1-9187-b532f1e9575d") + IID_IDockingWindowSite* = DEFINE_GUID("2a342fc2-7b26-11d0-8ca9-00a0c92dbfe8") + IID_IDockingWindowFrame* = DEFINE_GUID("47d2657a-7b27-11d0-8ca9-00a0c92dbfe8") + IID_IShellIconOverlay* = DEFINE_GUID("7d688a70-c613-11d0-999b-00c04fd655e1") + IID_IShellIconOverlayIdentifier* = DEFINE_GUID("0c6c4200-c589-11d0-999a-00c04fd655e1") + CLSID_CFSIconOverlayManager* = DEFINE_GUID("63b51f81-c868-11d0-999c-00c04fd655e1") + IID_IShellIconOverlayManager* = DEFINE_GUID("f10b5e34-dd3b-42a7-aa7d-2f4ec54bb09b") + IID_IThumbnailCapture* = DEFINE_GUID("4ea39266-7211-409f-b622-f63dbd16c533") + IID_IShellImageStore* = DEFINE_GUID("48c8118c-b924-11d1-98d5-00c04fb687da") + CLSID_ShellThumbnailDiskCache* = DEFINE_GUID("1ebdcf80-a200-11d0-a3a4-00c04fd706ec") + SID_DefView* = DEFINE_GUID("6d12fe80-7911-11cf-9534-0000c05bae0b") + CGID_DefView* = DEFINE_GUID("4af07f10-d231-11d0-b942-00a0c90312e1") + CLSID_MenuBand* = DEFINE_GUID("5b4dae26-b807-11d0-9815-00c04fd91972") + IID_IShellFolderBand* = DEFINE_GUID("7fe80cc8-c247-11d0-b93a-00a0c90312e1") + IID_IDefViewFrame* = DEFINE_GUID("710eb7a0-45ed-11d0-924a-0020afc7ac4d") + VID_LargeIcons* = DEFINE_GUID("0057d0e0-3573-11cf-ae69-08002b2e1262") + VID_SmallIcons* = DEFINE_GUID("089000c0-3573-11cf-ae69-08002b2e1262") + VID_List* = DEFINE_GUID("0e1fa5e0-3573-11cf-ae69-08002b2e1262") + VID_Details* = DEFINE_GUID("137e7700-3573-11cf-ae69-08002b2e1262") + VID_Tile* = DEFINE_GUID("65f125e5-7be1-4810-ba9d-d271c8432ce3") + VID_Content* = DEFINE_GUID("30c2c434-0889-4c8d-985d-a9f71830b0a9") + VID_Thumbnails* = DEFINE_GUID("8bebb290-52d0-11d0-b7f4-00c04fd706ec") + VID_ThumbStrip* = DEFINE_GUID("8eefa624-d1e9-445b-94b7-74fbce2ea11a") + SID_SInPlaceBrowser* = DEFINE_GUID("1d2ae02b-3655-46cc-b63a-285988153bca") + SID_SSearchBoxInfo* = DEFINE_GUID("142daa61-516b-4713-b49c-fb985ef82998") + SID_CommandsPropertyBag* = DEFINE_GUID("6e043250-4416-485c-b143-e62a760d9fe5") + IID_IDiscardableBrowserProperty* = DEFINE_GUID("49c3de7c-d329-11d0-ab73-00c04fc33e80") + IID_IShellChangeNotify* = DEFINE_GUID("d82be2b1-5764-11d0-a96e-00c04fd705a2") + CLSID_InternetShortcut* = DEFINE_GUID("fbf23b40-e3f0-101b-8488-00aa003e56f8") + IID_IUniformResourceLocatorA* = DEFINE_GUID("fbf23b80-e3f0-101b-8488-00aa003e56f8") + IID_IUniformResourceLocatorW* = DEFINE_GUID("cabb0da0-da57-11cf-9974-0020afd79762") + LIBID_Shell32* = DEFINE_GUID("50a7e9b0-70ef-11d1-b75a-00a0c90564fe") + IID_IFolderViewOC* = DEFINE_GUID("9ba05970-f6a8-11cf-a442-00a0c90a8f39") + DIID_DShellFolderViewEvents* = DEFINE_GUID("62112aa2-ebe4-11cf-a5fb-0020afe7292d") + IID_DShellFolderViewEvents* = DEFINE_GUID("62112aa2-ebe4-11cf-a5fb-0020afe7292d") + CLSID_ShellFolderViewOC* = DEFINE_GUID("9ba05971-f6a8-11cf-a442-00a0c90a8f39") + IID_DFConstraint* = DEFINE_GUID("4a3df050-23bd-11d2-939f-00a0c91eedba") + IID_Folder* = DEFINE_GUID("bbcbde60-c3ff-11ce-8350-444553540000") + IID_Folder2* = DEFINE_GUID("f0d2d8ef-3890-11d2-bf8b-00c04fb93661") + OFS_INACTIVE* = -1 + OFS_ONLINE* = 0 + OFS_OFFLINE* = 1 + OFS_SERVERBACK* = 2 + OFS_DIRTYCACHE* = 3 + IID_Folder3* = DEFINE_GUID("a7ae5f64-c4d7-4d7f-9307-4d24ee54b841") + IID_FolderItem* = DEFINE_GUID("fac32c80-cbe4-11ce-8350-444553540000") + IID_FolderItem2* = DEFINE_GUID("edc817aa-92b8-11d1-b075-00c04fc33aa5") + CLSID_ShellFolderItem* = DEFINE_GUID("2fe352ea-fd1f-11d2-b1f4-00c04f8eeb3e") + IID_FolderItems* = DEFINE_GUID("744129e0-cbe5-11ce-8350-444553540000") + IID_FolderItems2* = DEFINE_GUID("c94f0ad0-f363-11d2-a327-00c04f8eec7f") + IID_FolderItems3* = DEFINE_GUID("eaa7c309-bbec-49d5-821d-64d966cb667f") + IID_FolderItemVerb* = DEFINE_GUID("08ec3e00-50b0-11cf-960c-0080c7f4ee85") + IID_FolderItemVerbs* = DEFINE_GUID("1f8352c0-50b0-11cf-960c-0080c7f4ee85") + IID_IShellLinkDual* = DEFINE_GUID("88a05c00-f000-11ce-8350-444553540000") + IID_IShellLinkDual2* = DEFINE_GUID("317ee249-f12e-11d2-b1e4-00c04f8eeb3e") + CLSID_ShellLinkObject* = DEFINE_GUID("11219420-1768-11d1-95be-00609797ea4f") + IID_IShellFolderViewDual* = DEFINE_GUID("e7a1af80-4d96-11cf-960c-0080c7f4ee85") + IID_IShellFolderViewDual2* = DEFINE_GUID("31c147b6-0ade-4a3c-b514-ddf932ef6d17") + IID_IShellFolderViewDual3* = DEFINE_GUID("29ec8e6c-46d3-411f-baaa-611a6c9cac66") + CLSID_ShellFolderView* = DEFINE_GUID("62112aa1-ebe4-11cf-a5fb-0020afe7292d") + SFVVO_SHOWALLOBJECTS* = 0x1 + SFVVO_SHOWEXTENSIONS* = 0x2 + SFVVO_SHOWCOMPCOLOR* = 0x8 + SFVVO_SHOWSYSFILES* = 0x20 + SFVVO_WIN95CLASSIC* = 0x40 + SFVVO_DOUBLECLICKINWEBVIEW* = 0x80 + SFVVO_DESKTOPHTML* = 0x200 + IID_IShellDispatch* = DEFINE_GUID("d8f015c0-c278-11ce-a49e-444553540000") + IID_IShellDispatch2* = DEFINE_GUID("a4c6892c-3ba9-11d2-9dea-00c04fb16162") + IID_IShellDispatch3* = DEFINE_GUID("177160ca-bb5a-411c-841d-bd38facdeaa0") + IID_IShellDispatch4* = DEFINE_GUID("efd84b2d-4bcf-4298-be25-eb542a59fbda") + IID_IShellDispatch5* = DEFINE_GUID("866738b9-6cf2-4de8-8767-f794ebe74f4e") + IID_IShellDispatch6* = DEFINE_GUID("286e6f1b-7113-4355-9562-96b7e9d64c54") + CLSID_Shell* = DEFINE_GUID("13709620-c279-11ce-a49e-444553540000") + CLSID_ShellDispatchInproc* = DEFINE_GUID("0a89a860-d7b1-11ce-8350-444553540000") + ssfDESKTOP* = 0x0 + ssfPROGRAMS* = 0x2 + ssfCONTROLS* = 0x3 + ssfPRINTERS* = 0x4 + ssfPERSONAL* = 0x5 + ssfFAVORITES* = 0x6 + ssfSTARTUP* = 0x7 + ssfRECENT* = 0x8 + ssfSENDTO* = 0x9 + ssfBITBUCKET* = 0xa + ssfSTARTMENU* = 0xb + ssfDESKTOPDIRECTORY* = 0x10 + ssfDRIVES* = 0x11 + ssfNETWORK* = 0x12 + ssfNETHOOD* = 0x13 + ssfFONTS* = 0x14 + ssfTEMPLATES* = 0x15 + ssfCOMMONSTARTMENU* = 0x16 + ssfCOMMONPROGRAMS* = 0x17 + ssfCOMMONSTARTUP* = 0x18 + ssfCOMMONDESKTOPDIR* = 0x19 + ssfAPPDATA* = 0x1a + ssfPRINTHOOD* = 0x1b + ssfLOCALAPPDATA* = 0x1c + ssfALTSTARTUP* = 0x1d + ssfCOMMONALTSTARTUP* = 0x1e + ssfCOMMONFAVORITES* = 0x1f + ssfINTERNETCACHE* = 0x20 + ssfCOOKIES* = 0x21 + ssfHISTORY* = 0x22 + ssfCOMMONAPPDATA* = 0x23 + ssfWINDOWS* = 0x24 + ssfSYSTEM* = 0x25 + ssfPROGRAMFILES* = 0x26 + ssfMYPICTURES* = 0x27 + ssfPROFILE* = 0x28 + ssfSYSTEMx86* = 0x29 + ssfPROGRAMFILESx86* = 0x30 + IID_IFileSearchBand* = DEFINE_GUID("2d91eea1-9932-11d2-be86-00a0c9a83da1") + CLSID_FileSearchBand* = DEFINE_GUID("c4ee31f3-4768-11d2-be5c-00a0c9a83da1") + IID_IWebWizardHost* = DEFINE_GUID("18bcc359-4990-4bfb-b951-3c83702be5f9") + IID_INewWDEvents* = DEFINE_GUID("0751c551-7568-41c9-8e5b-e22e38919236") + IID_IAutoComplete* = DEFINE_GUID("00bb2762-6a77-11d0-a535-00c04fd7d062") + ACO_NONE* = 0x0 + ACO_AUTOSUGGEST* = 0x1 + ACO_AUTOAPPEND* = 0x2 + ACO_SEARCH* = 0x4 + ACO_FILTERPREFIXES* = 0x8 + ACO_USETAB* = 0x10 + ACO_UPDOWNKEYDROPSLIST* = 0x20 + ACO_RTLREADING* = 0x40 + ACO_WORD_FILTER* = 0x80 + ACO_NOPREFIXFILTERING* = 0x100 + IID_IAutoComplete2* = DEFINE_GUID("eac04bc0-3791-11d2-bb95-0060977b464c") + ACEO_NONE* = 0x0 + ACEO_MOSTRECENTFIRST* = 0x1 + ACEO_FIRSTUNUSED* = 0x10000 + IID_IEnumACString* = DEFINE_GUID("8e74c210-cf9d-4eaf-a403-7356428f0a5a") + IID_IDataObjectAsyncCapability* = DEFINE_GUID("3d8b0590-f691-11d2-8ea9-006097df5bd4") + SID_SInternetExplorer* = IID_IWebBrowserApp + CLSID_ProgressDialog* = DEFINE_GUID("f8383852-fcd3-11d1-a6b9-006097df5bd4") + SID_SProgressUI* = CLSID_ProgressDialog + CLSID_CUrlHistory* = DEFINE_GUID("3c374a40-bae4-11cf-bf7d-00aa006946ee") + SID_SUrlHistory* = CLSID_CUrlHistory + SID_SWebBrowserApp* = IID_IWebBrowserApp + CLSID_CURLSearchHook* = DEFINE_GUID("cfbfae00-17a6-11d0-99cb-00c04fd64497") + IID_IObjMgr* = DEFINE_GUID("00bb2761-6a77-11d0-a535-00c04fd7d062") + IID_IACList* = DEFINE_GUID("77a130b0-94fd-11d0-a544-00c04fd7d062") + IID_IACList2* = DEFINE_GUID("470141a0-5186-11d2-bbb6-0060977b464c") + IID_ICurrentWorkingDirectory* = DEFINE_GUID("91956d21-9276-11d1-921a-006097df5bd4") + CLSID_AutoComplete* = DEFINE_GUID("00bb2763-6a77-11d0-a535-00c04fd7d062") + CLSID_ACLHistory* = DEFINE_GUID("00bb2764-6a77-11d0-a535-00c04fd7d062") + CLSID_ACListISF* = DEFINE_GUID("03c036f1-a186-11d0-824a-00aa005b4383") + CLSID_ACLMRU* = DEFINE_GUID("6756a641-de71-11d0-831b-00aa005b4383") + CLSID_ACLMulti* = DEFINE_GUID("00bb2765-6a77-11d0-a535-00c04fd7d062") + CLSID_ACLCustomMRU* = DEFINE_GUID("6935db93-21e8-4ccc-beb9-9fe3c77a297a") + IID_IProgressDialog* = DEFINE_GUID("ebbc7c04-315e-11d2-b62f-006097df5bd4") + SID_STopLevelBrowser* = DEFINE_GUID("4c96be40-915c-11cf-99d3-00aa004ae837") + PSGUID_SHELLDETAILS* = DEFINE_GUID("28636aa6-953d-11d2-b5d6-00c04fd918d0") + PID_FINDDATA* = 0 + PID_NETRESOURCE* = 1 + PID_DESCRIPTIONID* = 2 + PID_WHICHFOLDER* = 3 + PID_NETWORKLOCATION* = 4 + PID_COMPUTERNAME* = 5 + PID_DISPLAY_PROPERTIES* = 0 + PID_INTROTEXT* = 1 + PID_SYNC_COPY_IN* = 2 + PIDSI_ARTIST* = 2 + PIDSI_SONGTITLE* = 3 + PIDSI_ALBUM* = 4 + PIDSI_YEAR* = 5 + PIDSI_COMMENT* = 6 + PIDSI_TRACK* = 7 + PIDSI_GENRE* = 11 + PIDSI_LYRICS* = 12 + PID_MISC_STATUS* = 2 + PID_MISC_ACCESSCOUNT* = 3 + PID_MISC_OWNER* = 4 + PID_HTMLINFOTIPFILE* = 5 + PID_MISC_PICS* = 6 + PIDDRSI_PROTECTED* = 2 + PIDDRSI_DESCRIPTION* = 3 + PIDDRSI_PLAYCOUNT* = 4 + PIDDRSI_PLAYSTARTS* = 5 + PIDDRSI_PLAYEXPIRES* = 6 + PID_DISPLACED_FROM* = 2 + PID_DISPLACED_DATE* = 3 + PSGUID_BRIEFCASE* = DEFINE_GUID("328d8b21-7729-4bfc-954c-902b329d56b0") + PSGUID_MISC* = DEFINE_GUID("9b174b34-40ff-11d2-a27e-00c04fc30871") + PSGUID_WEBVIEW* = DEFINE_GUID("f2275480-f782-4291-bd94-f13693513aec") + PSGUID_MUSIC* = DEFINE_GUID("56a3372e-ce9c-11d2-9f0e-006097c686f6") + PSGUID_DRM* = DEFINE_GUID("aeac19e4-89ae-4508-b9b7-bb867abee2ed") + PSGUID_VIDEO* = DEFINE_GUID("64440491-4c8b-11d1-8b70-080036b11a03") + PSGUID_IMAGEPROPERTIES* = DEFINE_GUID("14b81da1-0135-4d31-96d9-6cbfc9671a99") + PSGUID_CUSTOMIMAGEPROPERTIES* = DEFINE_GUID("7ecd8b0e-c136-4a9b-9411-4ebd6673ccc3") + PSGUID_LIBRARYPROPERTIES* = DEFINE_GUID("5d76b67f-9b3d-44bb-b6ae-25da4f638a67") + PSGUID_DISPLACED* = DEFINE_GUID("9b174b33-40ff-11d2-a27e-00c04fc30871") + CLSID_FileTypes* = DEFINE_GUID("b091e540-83e3-11cf-a713-0020afd79762") + CLSID_ActiveDesktop* = DEFINE_GUID("75048700-ef1f-11d0-9888-006097deacf9") + IID_IActiveDesktop* = DEFINE_GUID("f490eb00-1240-11d1-9888-006097deacf9") + IID_IActiveDesktopP* = DEFINE_GUID("52502ee0-ec80-11d0-89ab-00c04fc2972d") + IID_IADesktopP2* = DEFINE_GUID("b22754e2-4574-11d1-9888-006097deacf9") + IID_ISynchronizedCallBack* = DEFINE_GUID("74c26041-70d1-11d1-b75a-00a0c90564fe") + IID_IQueryAssociations* = DEFINE_GUID("c46ca590-3c3f-11d2-bee6-0000f805ca57") + CLSID_QueryAssociations* = DEFINE_GUID("a07034fd-6caa-4954-ac3f-97a27216f98a") + IID_IColumnProvider* = DEFINE_GUID("e8025004-1c42-11d2-be2c-00a0c9a83da1") + CLSID_LinkColumnProvider* = DEFINE_GUID("24f14f02-7b1c-11d1-838f-0000f80461cf") + CGID_ShortCut* = DEFINE_GUID("93a68750-951a-11d1-946f-000000000000") + IID_INamedPropertyBag* = DEFINE_GUID("fb700430-952c-11d1-946f-000000000000") + CLSID_InternetButtons* = DEFINE_GUID("1e796980-9cc5-11d1-a83f-00c04fc99d61") + CLSID_MSOButtons* = DEFINE_GUID("178f34b8-a282-11d2-86c5-00c04f8eea99") + CLSID_ToolbarExtButtons* = DEFINE_GUID("2ce4b5d8-a28f-11d2-86c5-00c04f8eea99") + CLSID_DarwinAppPublisher* = DEFINE_GUID("cfccc7a0-a282-11d1-9082-006008059382") + CLSID_DocHostUIHandler* = DEFINE_GUID("7057e952-bd1b-11d1-8919-00c04fc2c836") + FMTID_ShellDetails* = DEFINE_GUID("28636aa6-953d-11d2-b5d6-00c04fd918d0") + FMTID_Storage* = DEFINE_GUID("b725f130-47ef-101a-a5f1-02608c9eebac") + FMTID_ImageProperties* = DEFINE_GUID("14b81da1-0135-4d31-96d9-6cbfc9671a99") + FMTID_CustomImageProperties* = DEFINE_GUID("7ecd8b0e-c136-4a9b-9411-4ebd6673ccc3") + FMTID_LibraryProperties* = DEFINE_GUID("5d76b67f-9b3d-44bb-b6ae-25da4f638a67") + FMTID_Displaced* = DEFINE_GUID("9b174b33-40ff-11d2-a27e-00c04fc30871") + FMTID_Briefcase* = DEFINE_GUID("328d8b21-7729-4bfc-954c-902b329d56b0") + FMTID_Misc* = DEFINE_GUID("9b174b34-40ff-11d2-a27e-00c04fc30871") + FMTID_WebView* = DEFINE_GUID("f2275480-f782-4291-bd94-f13693513aec") + FMTID_MUSIC* = DEFINE_GUID("56a3372e-ce9c-11d2-9f0e-006097c686f6") + FMTID_DRM* = DEFINE_GUID("aeac19e4-89ae-4508-b9b7-bb867abee2ed") + PIDVSI_STREAM_NAME* = 0x00000002 + PIDVSI_FRAME_WIDTH* = 0x00000003 + PIDVSI_FRAME_HEIGHT* = 0x00000004 + PIDVSI_TIMELENGTH* = 0x00000007 + PIDVSI_FRAME_COUNT* = 0x00000005 + PIDVSI_FRAME_RATE* = 0x00000006 + PIDVSI_DATA_RATE* = 0x00000008 + PIDVSI_SAMPLE_SIZE* = 0x00000009 + PIDVSI_COMPRESSION* = 0x0000000a + PIDVSI_STREAM_NUMBER* = 0x0000000b + PSGUID_AUDIO* = DEFINE_GUID("64440490-4c8b-11d1-8b70-080036b11a03") + PIDASI_FORMAT* = 0x00000002 + PIDASI_TIMELENGTH* = 0x00000003 + PIDASI_AVG_DATA_RATE* = 0x00000004 + PIDASI_SAMPLE_RATE* = 0x00000005 + PIDASI_SAMPLE_SIZE* = 0x00000006 + PIDASI_CHANNEL_COUNT* = 0x00000007 + PIDASI_STREAM_NUMBER* = 0x00000008 + PIDASI_STREAM_NAME* = 0x00000009 + PIDASI_COMPRESSION* = 0x0000000a + PSGUID_CONTROLPANEL* = DEFINE_GUID("305ca226-d286-468e-b848-2b2e8e697b74") + PID_CONTROLPANEL_CATEGORY* = 2 + PSGUID_VOLUME* = DEFINE_GUID("9b174b35-40ff-11d2-a27e-00c04fc30871") + PSGUID_SHARE* = DEFINE_GUID("d8c3986f-813b-449c-845d-87b95d674ade") + PSGUID_LINK* = DEFINE_GUID("b9b4b3fc-2b51-4a42-b5d8-324146afcf25") + PSGUID_QUERY_D* = DEFINE_GUID("49691c90-7e17-101a-a91c-08002b2ecda9") + PSGUID_SUMMARYINFORMATION* = DEFINE_GUID("f29f85e0-4ff9-1068-ab91-08002b27b3d9") + PSGUID_DOCUMENTSUMMARYINFORMATION* = DEFINE_GUID("d5cdd502-2e9c-101b-9397-08002b2cf9ae") + PSGUID_MEDIAFILESUMMARYINFORMATION* = DEFINE_GUID("64440492-4c8b-11d1-8b70-080036b11a03") + PSGUID_IMAGESUMMARYINFORMATION* = DEFINE_GUID("6444048f-4c8b-11d1-8b70-080036b11a03") + PID_VOLUME_FREE* = 2 + PID_VOLUME_CAPACITY* = 3 + PID_VOLUME_FILESYSTEM* = 4 + PID_SHARE_CSC_STATUS* = 2 + PID_LINK_TARGET* = 2 + PID_LINK_TARGET_TYPE* = 3 + PID_QUERY_RANK* = 2 + FMTID_Volume* = DEFINE_GUID("9b174b35-40ff-11d2-a27e-00c04fc30871") + FMTID_Query* = DEFINE_GUID("49691c90-7e17-101a-a91c-08002b2ecda9") + CLSID_HWShellExecute* = DEFINE_GUID("ffb8655f-81b9-4fce-b89c-9a6ba76d13e7") + CLSID_DragDropHelper* = DEFINE_GUID("4657278a-411b-11d2-839a-00c04fd918d0") + CLSID_CAnchorBrowsePropertyPage* = DEFINE_GUID("3050f3bb-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CImageBrowsePropertyPage* = DEFINE_GUID("3050f3b3-98b5-11cf-bb82-00aa00bdce0b") + CLSID_CDocBrowsePropertyPage* = DEFINE_GUID("3050f3b4-98b5-11cf-bb82-00aa00bdce0b") + SID_STopWindow* = DEFINE_GUID("49e1b500-4636-11d3-97f7-00c04f45d0b3") + SID_SGetViewFromViewDual* = DEFINE_GUID("889a935d-971e-4b12-b90c-24dfc9e1e5e8") + CLSID_FolderItem* = DEFINE_GUID("fef10fa2-355e-4e06-9381-9b24d7f7cc88") + CLSID_FolderItemsMultiLevel* = DEFINE_GUID("53c74826-ab99-4d33-aca4-3117f51d3788") + CLSID_NewMenu* = DEFINE_GUID("d969a300-e7ff-11d0-a93b-00a0c90f2719") + BHID_SFObject* = DEFINE_GUID("3981e224-f559-11d3-8e3a-00c04f6837d5") + BHID_SFUIObject* = DEFINE_GUID("3981e225-f559-11d3-8e3a-00c04f6837d5") + BHID_SFViewObject* = DEFINE_GUID("3981e226-f559-11d3-8e3a-00c04f6837d5") + BHID_Storage* = DEFINE_GUID("3981e227-f559-11d3-8e3a-00c04f6837d5") + BHID_Stream* = DEFINE_GUID("1cebb3ab-7c10-499a-a417-92ca16c4cb83") + BHID_RandomAccessStream* = DEFINE_GUID("f16fc93b-77ae-4cfe-bda7-a866eea6878d") + BHID_LinkTargetItem* = DEFINE_GUID("3981e228-f559-11d3-8e3a-00c04f6837d5") + BHID_StorageEnum* = DEFINE_GUID("4621a4e3-f0d6-4773-8a9c-46e77b174840") + BHID_Transfer* = DEFINE_GUID("d5e346a1-f753-4932-b403-4574800e2498") + BHID_PropertyStore* = DEFINE_GUID("0384e1a4-1523-439c-a4c8-ab911052f586") + BHID_ThumbnailHandler* = DEFINE_GUID("7b2e650a-8e20-4f4a-b09e-6597afc72fb0") + BHID_EnumItems* = DEFINE_GUID("94f60519-2850-4924-aa5a-d15e84868039") + BHID_DataObject* = DEFINE_GUID("b8c0bd9f-ed24-455c-83e6-d5390c4fe8c4") + BHID_AssociationArray* = DEFINE_GUID("bea9ef17-82f1-4f60-9284-4f8db75c3be9") + BHID_Filter* = DEFINE_GUID("38d08778-f557-4690-9ebf-ba54706ad8f7") + BHID_EnumAssocHandlers* = DEFINE_GUID("b8ab0b9c-c2ec-4f7a-918d-314900e6280a") + SID_CtxQueryAssociations* = DEFINE_GUID("faadfc40-b777-4b69-aa81-77035ef0e6e8") + IID_IDocViewSite* = DEFINE_GUID("87d605e0-c511-11cf-89a9-00a0c9054129") + CLSID_QuickLinks* = DEFINE_GUID("0e5cbf21-d15f-11d0-8301-00aa005b4383") + CLSID_ISFBand* = DEFINE_GUID("d82be2b0-5764-11d0-a96e-00c04fd705a2") + IID_CDefView* = DEFINE_GUID("4434ff80-ef4c-11ce-ae65-08002b2e1262") + CLSID_ShellFldSetExt* = DEFINE_GUID("6d5313c0-8c62-11d1-b2cd-006097df8c11") + SID_SMenuBandChild* = DEFINE_GUID("ed9cc020-08b9-11d1-9823-00c04fd91972") + SID_SMenuBandParent* = DEFINE_GUID("8c278eec-3eab-11d1-8cb0-00c04fd918d0") + SID_SMenuPopup* = DEFINE_GUID("d1e7afeb-6a2e-11d0-8c78-00c04fd918b4") + SID_SMenuBandBottomSelected* = DEFINE_GUID("165ebaf4-6d51-11d2-83ad-00c04fd918d0") + SID_SMenuBandBottom* = DEFINE_GUID("743ca664-0deb-11d1-9825-00c04fd91972") + SID_MenuShellFolder* = DEFINE_GUID("a6c17eb4-2d65-11d2-838f-00c04fd918d0") + SID_SMenuBandContextMenuModifier* = DEFINE_GUID("39545874-7162-465e-b783-2aa1874fef81") + SID_SMenuBandBKContextMenu* = DEFINE_GUID("164bbd86-1d0d-4de0-9a3b-d9729647c2b8") + CGID_MENUDESKBAR* = DEFINE_GUID("5c9f0a12-959e-11d0-a3a4-00a0c9082636") + SID_SMenuBandTop* = DEFINE_GUID("9493a810-ec38-11d0-bc46-00aa006ce2f5") + CLSID_MenuToolbarBase* = DEFINE_GUID("40b96610-b522-11d1-b3b4-00aa006efde7") + IID_IBanneredBar* = DEFINE_GUID("596a9a94-013e-11d1-8d34-00a0c90f2719") + CLSID_MenuBandSite* = DEFINE_GUID("e13ef4e4-d2f2-11d0-9816-00c04fd91972") + SID_SCommDlgBrowser* = DEFINE_GUID("80f30233-b7df-11d2-a33b-006097df5bd4") + CPFG_LOGON_USERNAME* = DEFINE_GUID("da15bbe8-954d-4fd3-b0f4-1fb5b90b174b") + CPFG_LOGON_PASSWORD* = DEFINE_GUID("60624cfa-a477-47b1-8a8e-3a4a19981827") + CPFG_SMARTCARD_USERNAME* = DEFINE_GUID("3e1ecf69-568c-4d96-9d59-46444174e2d6") + CPFG_SMARTCARD_PIN* = DEFINE_GUID("4fe5263b-9181-46c1-b0a4-9dedd4db7dea") + CPFG_CREDENTIAL_PROVIDER_LOGO* = DEFINE_GUID("2d837775-f6cd-464e-a745-482fd0b47493") + CPFG_CREDENTIAL_PROVIDER_LABEL* = DEFINE_GUID("286bbff3-bad4-438f-b007-79b7267c3d48") + FOLDERID_AccountPictures* = DEFINE_GUID("008ca0b1-55b4-4c56-b8a8-4de4b299d3be") + FOLDERID_AddNewPrograms* = DEFINE_GUID("de61d971-5ebc-4f02-a3a9-6c82895e5c04") + FOLDERID_AdminTools* = DEFINE_GUID("724ef170-a42d-4fef-9f26-b60e846fba4f") + FOLDERID_AppsFolder* = DEFINE_GUID("1e87508d-89c2-42f0-8a7e-645a0f50ca58") + FOLDERID_ApplicationShortcuts* = DEFINE_GUID("a3918781-e5f2-4890-b3d9-a7e54332328c") + FOLDERID_AppUpdates* = DEFINE_GUID("a305ce99-f527-492b-8b1a-7e76fa98d6e4") + FOLDERID_CDBurning* = DEFINE_GUID("9e52ab10-f80d-49df-acb8-4330f5687855") + FOLDERID_ChangeRemovePrograms* = DEFINE_GUID("df7266ac-9274-4867-8d55-3bd661de872d") + FOLDERID_CommonAdminTools* = DEFINE_GUID("d0384e7d-bac3-4797-8f14-cba229b392b5") + FOLDERID_CommonOEMLinks* = DEFINE_GUID("c1bae2d0-10df-4334-bedd-7aa20b227a9d") + FOLDERID_CommonPrograms* = DEFINE_GUID("0139d44e-6afe-49f2-8690-3dafcae6ffb8") + FOLDERID_CommonStartMenu* = DEFINE_GUID("a4115719-d62e-491d-aa7c-e74b8be3b067") + FOLDERID_CommonStartup* = DEFINE_GUID("82a5ea35-d9cd-47c5-9629-e15d2f714e6e") + FOLDERID_CommonTemplates* = DEFINE_GUID("b94237e7-57ac-4347-9151-b08c6c32d1f7") + FOLDERID_ComputerFolder* = DEFINE_GUID("0ac0837c-bbf8-452a-850d-79d08e667ca7") + FOLDERID_ConflictFolder* = DEFINE_GUID("4bfefb45-347d-4006-a5be-ac0cb0567192") + FOLDERID_ConnectionsFolder* = DEFINE_GUID("6f0cd92b-2e97-45d1-88ff-b0d186b8dedd") + FOLDERID_Contacts* = DEFINE_GUID("56784854-c6cb-462b-8169-88e350acb882") + FOLDERID_ControlPanelFolder* = DEFINE_GUID("82a74aeb-aeb4-465c-a014-d097ee346d63") + FOLDERID_Cookies* = DEFINE_GUID("2b0f765d-c0e9-4171-908e-08a611b84ff6") + FOLDERID_Desktop* = DEFINE_GUID("b4bfcc3a-db2c-424c-b029-7fe99a87c641") + FOLDERID_DeviceMetadataStore* = DEFINE_GUID("5ce4a5e9-e4eb-479d-b89f-130c02886155") + FOLDERID_Documents* = DEFINE_GUID("fdd39ad0-238f-46af-adb4-6c85480369c7") + FOLDERID_DocumentsLibrary* = DEFINE_GUID("7b0db17d-9cd2-4a93-9733-46cc89022e7c") + FOLDERID_Downloads* = DEFINE_GUID("374de290-123f-4565-9164-39c4925e467b") + FOLDERID_Favorites* = DEFINE_GUID("1777f761-68ad-4d8a-87bd-30b759fa33dd") + FOLDERID_Fonts* = DEFINE_GUID("fd228cb7-ae11-4ae3-864c-16f3910ab8fe") + FOLDERID_Games* = DEFINE_GUID("cac52c1a-b53d-4edc-92d7-6b2e8ac19434") + FOLDERID_GameTasks* = DEFINE_GUID("054fae61-4dd8-4787-80b6-090220c4b700") + FOLDERID_History* = DEFINE_GUID("d9dc8a3b-b784-432e-a781-5a1130a75963") + FOLDERID_HomeGroup* = DEFINE_GUID("52528a6b-b9e3-4add-b60d-588c2dba842d") + FOLDERID_HomeGroupCurrentUser* = DEFINE_GUID("9b74b6a3-0dfd-4f11-9e78-5f7800f2e772") + FOLDERID_ImplicitAppShortcuts* = DEFINE_GUID("bcb5256f-79f6-4cee-b725-dc34e402fd46") + FOLDERID_InternetCache* = DEFINE_GUID("352481e8-33be-4251-ba85-6007caedcf9d") + FOLDERID_InternetFolder* = DEFINE_GUID("4d9f7874-4e0c-4904-967b-40b0d20c3e4b") + FOLDERID_Libraries* = DEFINE_GUID("1b3ea5dc-b587-4786-b4ef-bd1dc332aeae") + FOLDERID_Links* = DEFINE_GUID("bfb9d5e0-c6a9-404c-b2b2-ae6db6af4968") + FOLDERID_LocalAppData* = DEFINE_GUID("f1b32785-6fba-4fcf-9d55-7b8e7f157091") + FOLDERID_LocalAppDataLow* = DEFINE_GUID("a520a1a4-1780-4ff6-bd18-167343c5af16") + FOLDERID_LocalizedResourcesDir* = DEFINE_GUID("2a00375e-224c-49de-b8d1-440df7ef3ddc") + FOLDERID_Music* = DEFINE_GUID("4bd8d571-6d19-48d3-be97-422220080e43") + FOLDERID_MusicLibrary* = DEFINE_GUID("2112ab0a-c86a-4ffe-a368-0de96e47012e") + FOLDERID_NetHood* = DEFINE_GUID("c5abbf53-e17f-4121-8900-86626fc2c973") + FOLDERID_NetworkFolder* = DEFINE_GUID("d20beec4-5ca8-4905-ae3b-bf251ea09b53") + FOLDERID_OriginalImages* = DEFINE_GUID("2c36c0aa-5812-4b87-bfd0-4cd0dfb19b39") + FOLDERID_PhotoAlbums* = DEFINE_GUID("69d2cf90-fc33-4fb7-9a0c-ebb0f0fcb43c") + FOLDERID_Pictures* = DEFINE_GUID("33e28130-4e1e-4676-835a-98395c3bc3bb") + FOLDERID_PicturesLibrary* = DEFINE_GUID("a990ae9f-a03b-4e80-94bc-9912d7504104") + FOLDERID_Playlists* = DEFINE_GUID("de92c1c7-837f-4f69-a3bb-86e631204a23") + FOLDERID_PrintHood* = DEFINE_GUID("9274bd8d-cfd1-41c3-b35e-b13f55a758f4") + FOLDERID_PrintersFolder* = DEFINE_GUID("76fc4e2d-d6ad-4519-a663-37bd56068185") + FOLDERID_Profile* = DEFINE_GUID("5e6c858f-0e22-4760-9afe-ea3317b67173") + FOLDERID_ProgramData* = DEFINE_GUID("62ab5d82-fdc1-4dc3-a9dd-070d1d495d97") + FOLDERID_ProgramFiles* = DEFINE_GUID("905e63b6-c1bf-494e-b29c-65b732d3d21a") + FOLDERID_ProgramFilesX64* = DEFINE_GUID("6d809377-6af0-444b-8957-a3773f02200e") + FOLDERID_ProgramFilesX86* = DEFINE_GUID("7c5a40ef-a0fb-4bfc-874a-c0f2e0b9fa8e") + FOLDERID_ProgramFilesCommon* = DEFINE_GUID("f7f1ed05-9f6d-47a2-aaae-29d317c6f066") + FOLDERID_ProgramFilesCommonX64* = DEFINE_GUID("6365d5a7-0f0d-45e5-87f6-0da56b6a4f7d") + FOLDERID_ProgramFilesCommonX86* = DEFINE_GUID("de974d24-d9c6-4d3e-bf91-f4455120b917") + FOLDERID_Programs* = DEFINE_GUID("a77f5d77-2e2b-44c3-a6a2-aba601054a51") + FOLDERID_Public* = DEFINE_GUID("dfdf76a2-c82a-4d63-906a-5644ac457385") + FOLDERID_PublicDesktop* = DEFINE_GUID("c4aa340d-f20f-4863-afef-f87ef2e6ba25") + FOLDERID_PublicDocuments* = DEFINE_GUID("ed4824af-dce4-45a8-81e2-fc7965083634") + FOLDERID_PublicDownloads* = DEFINE_GUID("3d644c9b-1fb8-4f30-9b45-f670235f79c0") + FOLDERID_PublicGameTasks* = DEFINE_GUID("debf2536-e1a8-4c59-b6a2-414586476aea") + FOLDERID_PublicLibraries* = DEFINE_GUID("48daf80b-e6cf-4f4e-b800-0e69d84ee384") + FOLDERID_PublicMusic* = DEFINE_GUID("3214fab5-9757-4298-bb61-92a9deaa44ff") + FOLDERID_PublicPictures* = DEFINE_GUID("b6ebfb86-6907-413c-9af7-4fc2abf07cc5") + FOLDERID_PublicRingtones* = DEFINE_GUID("e555ab60-153b-4d17-9f04-a5fe99fc15ec") + FOLDERID_PublicUserTiles* = DEFINE_GUID("0482af6c-08f1-4c34-8c90-e17ec98b1e17") + FOLDERID_PublicVideos* = DEFINE_GUID("2400183a-6185-49fb-a2d8-4a392a602ba3") + FOLDERID_QuickLaunch* = DEFINE_GUID("52a4f021-7b75-48a9-9f6b-4b87a210bc8f") + FOLDERID_Recent* = DEFINE_GUID("ae50c081-ebd2-438a-8655-8a092e34987a") + FOLDERID_RecordedTVLibrary* = DEFINE_GUID("1a6fdba2-f42d-4358-a798-b74d745926c5") + FOLDERID_RecycleBinFolder* = DEFINE_GUID("b7534046-3ecb-4c18-be4e-64cd4cb7d6ac") + FOLDERID_ResourceDir* = DEFINE_GUID("8ad10c31-2adb-4296-a8f7-e4701232c972") + FOLDERID_Ringtones* = DEFINE_GUID("c870044b-f49e-4126-a9c3-b52a1ff411e8") + FOLDERID_RoamingAppData* = DEFINE_GUID("3eb685db-65f9-4cf6-a03a-e3ef65729f3d") + FOLDERID_RoamingTiles* = DEFINE_GUID("00bcfc5a-ed94-4e48-96a1-3f6217f21990") + FOLDERID_RoamedTileImages* = DEFINE_GUID("aaa8d5a5-f1d6-4259-baa8-78e7ef60835e") + FOLDERID_SampleMusic* = DEFINE_GUID("b250c668-f57d-4ee1-a63c-290ee7d1aa1f") + FOLDERID_SamplePictures* = DEFINE_GUID("c4900540-2379-4c75-844b-64e6faf8716b") + FOLDERID_SamplePlaylists* = DEFINE_GUID("15ca69b3-30ee-49c1-ace1-6b5ec372afb5") + FOLDERID_SampleVideos* = DEFINE_GUID("859ead94-2e85-48ad-a71a-0969cb56a6cd") + FOLDERID_SavedGames* = DEFINE_GUID("4c5c32ff-bb9d-43b0-b5b4-2d72e54eaaa4") + FOLDERID_SavedSearches* = DEFINE_GUID("7d1d3a04-debb-4115-95cf-2f29da2920da") + FOLDERID_Screenshots* = DEFINE_GUID("b7bede81-df94-4682-a7d8-57a52620b86f") + FOLDERID_SEARCH_MAPI* = DEFINE_GUID("98ec0e18-2098-4d44-8644-66979315a281") + FOLDERID_SEARCH_CSC* = DEFINE_GUID("ee32e446-31ca-4aba-814f-a5ebd2fd6d5e") + FOLDERID_SearchHome* = DEFINE_GUID("190337d1-b8ca-4121-a639-6d472d16972a") + FOLDERID_SendTo* = DEFINE_GUID("8983036c-27c0-404b-8f08-102d10dcfd74") + FOLDERID_SidebarDefaultParts* = DEFINE_GUID("7b396e54-9ec5-4300-be0a-2482ebae1a26") + FOLDERID_SidebarParts* = DEFINE_GUID("a75d362e-50fc-4fb7-ac2c-a8beaa314493") + FOLDERID_StartMenu* = DEFINE_GUID("625b53c3-ab48-4ec1-ba1f-a1ef4146fc19") + FOLDERID_Startup* = DEFINE_GUID("b97d20bb-f46a-4c97-ba10-5e3608430854") + FOLDERID_SyncManagerFolder* = DEFINE_GUID("43668bf8-c14e-49b2-97c9-747784d784b7") + FOLDERID_SyncResultsFolder* = DEFINE_GUID("289a9a43-be44-4057-a41b-587a76d7e7f9") + FOLDERID_SyncSetupFolder* = DEFINE_GUID("0f214138-b1d3-4a90-bba9-27cbc0c5389a") + FOLDERID_System* = DEFINE_GUID("1ac14e77-02e7-4e5d-b744-2eb1ae5198b7") + FOLDERID_SystemX86* = DEFINE_GUID("d65231b0-b2f1-4857-a4ce-a8e7c6ea7d27") + FOLDERID_Templates* = DEFINE_GUID("a63293e8-664e-48db-a079-df759e0509f7") + FOLDERID_UserPinned* = DEFINE_GUID("9e3995ab-1f9c-4f13-b827-48b24b6c7174") + FOLDERID_UserProfiles* = DEFINE_GUID("0762d272-c50a-4bb0-a382-697dcd729b80") + FOLDERID_UserProgramFiles* = DEFINE_GUID("5cd7aee2-2219-4a67-b85d-6c9ce15660cb") + FOLDERID_UserProgramFilesCommon* = DEFINE_GUID("bcbd3057-ca5c-4622-b42d-bc56db0ae516") + FOLDERID_UsersFiles* = DEFINE_GUID("f3ce0f7c-4901-4acc-8648-d5d44b04ef8f") + FOLDERID_UsersLibraries* = DEFINE_GUID("a302545d-deff-464b-abe8-61c8648d939b") + FOLDERID_Videos* = DEFINE_GUID("18989b1d-99b5-455b-841c-ab7c74e4ddfc") + FOLDERID_VideosLibrary* = DEFINE_GUID("491e922f-5643-4af4-a7eb-4e7a138d8174") + FOLDERID_Windows* = DEFINE_GUID("f38bf404-1d43-42f2-9305-67de0b28fc23") + FOLDERTYPEID_Invalid* = DEFINE_GUID("57807898-8c4f-4462-bb63-71042380b109") + FOLDERTYPEID_Generic* = DEFINE_GUID("5c4f28b5-f869-4e84-8e60-f11db97c5cc7") + FOLDERTYPEID_GenericSearchResults* = DEFINE_GUID("7fde1a1e-8b31-49a5-93b8-6be14cfa4943") + FOLDERTYPEID_GenericLibrary* = DEFINE_GUID("5f4eab9a-6833-4f61-899d-31cf46979d49") + FOLDERTYPEID_Documents* = DEFINE_GUID("7d49d726-3c21-4f05-99aa-fdc2c9474656") + FOLDERTYPEID_Pictures* = DEFINE_GUID("b3690e58-e961-423b-b687-386ebfd83239") + FOLDERTYPEID_Music* = DEFINE_GUID("94d6ddcc-4a68-4175-a374-bd584a510b78") + FOLDERTYPEID_Videos* = DEFINE_GUID("5fa96407-7e77-483c-ac93-691d05850de8") + FOLDERTYPEID_UserFiles* = DEFINE_GUID("cd0fc69b-71e2-46e5-9690-5bcd9f57aab3") + FOLDERTYPEID_UsersLibraries* = DEFINE_GUID("c4d98f09-6124-4fe0-9942-826416082da9") + FOLDERTYPEID_OtherUsers* = DEFINE_GUID("b337fd00-9dd5-4635-a6d4-da33fd102b7a") + FOLDERTYPEID_PublishedItems* = DEFINE_GUID("7f2f5b96-ff74-41da-afd8-1c78a5f3aea2") + FOLDERTYPEID_Communications* = DEFINE_GUID("91475fe5-586b-4eba-8d75-d17434b8cdf6") + FOLDERTYPEID_Contacts* = DEFINE_GUID("de2b70ec-9bf7-4a93-bd3d-243f7881d492") + FOLDERTYPEID_StartMenu* = DEFINE_GUID("ef87b4cb-f2ce-4785-8658-4ca6c63e38c6") + FOLDERTYPEID_RecordedTV* = DEFINE_GUID("5557a28f-5da6-4f83-8809-c2c98a11a6fa") + FOLDERTYPEID_SavedGames* = DEFINE_GUID("d0363307-28cb-4106-9f23-2956e3e5e0e7") + FOLDERTYPEID_OpenSearch* = DEFINE_GUID("8faf9629-1980-46ff-8023-9dceab9c3ee3") + FOLDERTYPEID_SearchConnector* = DEFINE_GUID("982725ee-6f47-479e-b447-812bfa7d2e8f") + FOLDERTYPEID_AccountPictures* = DEFINE_GUID("db2a5d8f-06e6-4007-aba6-af877d526ea6") + FOLDERTYPEID_Games* = DEFINE_GUID("b689b0d0-76d3-4cbb-87f7-585d0e0ce070") + FOLDERTYPEID_ControlPanelCategory* = DEFINE_GUID("de4f0660-fa10-4b8f-a494-068b20b22307") + FOLDERTYPEID_ControlPanelClassic* = DEFINE_GUID("0c3794f3-b545-43aa-a329-c37430c58d2a") + FOLDERTYPEID_Printers* = DEFINE_GUID("2c7bbec6-c844-4a0a-91fa-cef6f59cfda1") + FOLDERTYPEID_RecycleBin* = DEFINE_GUID("d6d9e004-cd87-442b-9d57-5e0aeb4f6f72") + FOLDERTYPEID_SoftwareExplorer* = DEFINE_GUID("d674391b-52d9-4e07-834e-67c98610f39d") + FOLDERTYPEID_CompressedFolder* = DEFINE_GUID("80213e82-bcfd-4c4f-8817-bb27601267a9") + FOLDERTYPEID_NetworkExplorer* = DEFINE_GUID("25cc242b-9a7c-4f51-80e0-7a2928febe42") + FOLDERTYPEID_Searches* = DEFINE_GUID("0b0ba2e3-405f-415e-a6ee-cad625207853") + FOLDERTYPEID_SearchHome* = DEFINE_GUID("834d8a44-0974-4ed6-866e-f203d80b3810") + SYNCMGR_OBJECTID_Icon* = DEFINE_GUID("6dbc85c3-5d07-4c72-a777-7fec78072c06") + SYNCMGR_OBJECTID_EventStore* = DEFINE_GUID("4bef34b9-a786-4075-ba88-0c2b9d89a98f") + SYNCMGR_OBJECTID_ConflictStore* = DEFINE_GUID("d78181f4-2389-47e4-a960-60bcc2ed930b") + SYNCMGR_OBJECTID_BrowseContent* = DEFINE_GUID("57cbb584-e9b4-47ae-a120-c4df3335dee2") + SYNCMGR_OBJECTID_ShowSchedule* = DEFINE_GUID("edc6f3e3-8441-4109-adf3-6c1ca0b7de47") + SYNCMGR_OBJECTID_QueryBeforeActivate* = DEFINE_GUID("d882d80b-e7aa-49ed-86b7-e6e1f714cdfe") + SYNCMGR_OBJECTID_QueryBeforeDeactivate* = DEFINE_GUID("a0efc282-60e0-460e-9374-ea88513cfc80") + SYNCMGR_OBJECTID_QueryBeforeEnable* = DEFINE_GUID("04cbf7f0-5beb-4de1-bc90-908345c480f6") + SYNCMGR_OBJECTID_QueryBeforeDisable* = DEFINE_GUID("bb5f64aa-f004-4eb5-8e4d-26751966344c") + SYNCMGR_OBJECTID_QueryBeforeDelete* = DEFINE_GUID("f76c3397-afb3-45d7-a59f-5a49e905437e") + SYNCMGR_OBJECTID_EventLinkClick* = DEFINE_GUID("2203bdc1-1af1-4082-8c30-28399f41384c") + EP_NavPane* = DEFINE_GUID("cb316b22-25f7-42b8-8a09-540d23a43c2f") + EP_Commands* = DEFINE_GUID("d9745868-ca5f-4a76-91cd-f5a129fbb076") + EP_Commands_Organize* = DEFINE_GUID("72e81700-e3ec-4660-bf24-3c3b7b648806") + EP_Commands_View* = DEFINE_GUID("21f7c32d-eeaa-439b-bb51-37b96fd6a943") + EP_DetailsPane* = DEFINE_GUID("43abf98b-89b8-472d-b9ce-e69b8229f019") + EP_PreviewPane* = DEFINE_GUID("893c63d1-45c8-4d17-be19-223be71be365") + EP_QueryPane* = DEFINE_GUID("65bcde4f-4f07-4f27-83a7-1afca4df7ddd") + EP_AdvQueryPane* = DEFINE_GUID("b4e9db8b-34ba-4c39-b5cc-16a1bd2c411c") + EP_StatusBar* = DEFINE_GUID("65fe56ce-5cfe-4bc4-ad8a-7ae3fe7e8f7c") + EP_Ribbon* = DEFINE_GUID("d27524a8-c9f2-4834-a106-df8889fd4f37") + CATID_LocationFactory* = DEFINE_GUID("965c4d51-8b76-4e57-80b7-564d2ea4b55e") + CATID_LocationProvider* = DEFINE_GUID("1b3ca474-2614-414b-b813-1aceca3e3dd8") + ItemCount_Property_GUID* = DEFINE_GUID("abbf5c45-5ccc-47b7-bb4e-87cb87bbd162") + SelectedItemCount_Property_GUID* = DEFINE_GUID("8fe316d2-0e52-460a-9c1e-48f273d470a3") + ItemIndex_Property_GUID* = DEFINE_GUID("92a053da-2969-4021-bf27-514cfc2e4a69") + CATID_SearchableApplication* = DEFINE_GUID("366c292a-d9b3-4dbf-bb70-e62ec3d0bbbf") + IID_IObjectArray* = DEFINE_GUID("92ca9dcd-5622-4bba-a805-5e9f541bd8c9") + IID_IObjectCollection* = DEFINE_GUID("5632b1a4-e38a-400a-928a-d4cd63230295") + COPYENGINE_S_YES* = HRESULT 0x00270001 + COPYENGINE_S_NOT_HANDLED* = HRESULT 0x00270003 + COPYENGINE_S_USER_RETRY* = HRESULT 0x00270004 + COPYENGINE_S_USER_IGNORED* = HRESULT 0x00270005 + COPYENGINE_S_MERGE* = HRESULT 0x00270006 + COPYENGINE_S_DONT_PROCESS_CHILDREN* = HRESULT 0x00270008 + COPYENGINE_S_ALREADY_DONE* = HRESULT 0x0027000a + COPYENGINE_S_PENDING* = HRESULT 0x0027000b + COPYENGINE_S_KEEP_BOTH* = HRESULT 0x0027000c + COPYENGINE_S_CLOSE_PROGRAM* = HRESULT 0x0027000d + COPYENGINE_S_COLLISIONRESOLVED* = HRESULT 0x0027000e + COPYENGINE_S_PROGRESS_PAUSE* = HRESULT 0x0027000f + COPYENGINE_E_USER_CANCELLED* = HRESULT 0x80270000'i32 + COPYENGINE_E_CANCELLED* = HRESULT 0x80270001'i32 + COPYENGINE_E_REQUIRES_ELEVATION* = HRESULT 0x80270002'i32 + COPYENGINE_E_SAME_FILE* = HRESULT 0x80270003'i32 + COPYENGINE_E_DIFF_DIR* = HRESULT 0x80270004'i32 + COPYENGINE_E_MANY_SRC_1_DEST* = HRESULT 0x80270005'i32 + COPYENGINE_E_DEST_SUBTREE* = HRESULT 0x80270009'i32 + COPYENGINE_E_DEST_SAME_TREE* = HRESULT 0x8027000a'i32 + COPYENGINE_E_FLD_IS_FILE_DEST* = HRESULT 0x8027000b'i32 + COPYENGINE_E_FILE_IS_FLD_DEST* = HRESULT 0x8027000c'i32 + COPYENGINE_E_FILE_TOO_LARGE* = HRESULT 0x8027000d'i32 + COPYENGINE_E_REMOVABLE_FULL* = HRESULT 0x8027000e'i32 + COPYENGINE_E_DEST_IS_RO_CD* = HRESULT 0x8027000f'i32 + COPYENGINE_E_DEST_IS_RW_CD* = HRESULT 0x80270010'i32 + COPYENGINE_E_DEST_IS_R_CD* = HRESULT 0x80270011'i32 + COPYENGINE_E_DEST_IS_RO_DVD* = HRESULT 0x80270012'i32 + COPYENGINE_E_DEST_IS_RW_DVD* = HRESULT 0x80270013'i32 + COPYENGINE_E_DEST_IS_R_DVD* = HRESULT 0x80270014'i32 + COPYENGINE_E_SRC_IS_RO_CD* = HRESULT 0x80270015'i32 + COPYENGINE_E_SRC_IS_RW_CD* = HRESULT 0x80270016'i32 + COPYENGINE_E_SRC_IS_R_CD* = HRESULT 0x80270017'i32 + COPYENGINE_E_SRC_IS_RO_DVD* = HRESULT 0x80270018'i32 + COPYENGINE_E_SRC_IS_RW_DVD* = HRESULT 0x80270019'i32 + COPYENGINE_E_SRC_IS_R_DVD* = HRESULT 0x8027001a'i32 + COPYENGINE_E_INVALID_FILES_SRC* = HRESULT 0x8027001b'i32 + COPYENGINE_E_INVALID_FILES_DEST* = HRESULT 0x8027001c'i32 + COPYENGINE_E_PATH_TOO_DEEP_SRC* = HRESULT 0x8027001d'i32 + COPYENGINE_E_PATH_TOO_DEEP_DEST* = HRESULT 0x8027001e'i32 + COPYENGINE_E_ROOT_DIR_SRC* = HRESULT 0x8027001f'i32 + COPYENGINE_E_ROOT_DIR_DEST* = HRESULT 0x80270020'i32 + COPYENGINE_E_ACCESS_DENIED_SRC* = HRESULT 0x80270021'i32 + COPYENGINE_E_ACCESS_DENIED_DEST* = HRESULT 0x80270022'i32 + COPYENGINE_E_PATH_NOT_FOUND_SRC* = HRESULT 0x80270023'i32 + COPYENGINE_E_PATH_NOT_FOUND_DEST* = HRESULT 0x80270024'i32 + COPYENGINE_E_NET_DISCONNECT_SRC* = HRESULT 0x80270025'i32 + COPYENGINE_E_NET_DISCONNECT_DEST* = HRESULT 0x80270026'i32 + COPYENGINE_E_SHARING_VIOLATION_SRC* = HRESULT 0x80270027'i32 + COPYENGINE_E_SHARING_VIOLATION_DEST* = HRESULT 0x80270028'i32 + COPYENGINE_E_ALREADY_EXISTS_NORMAL* = HRESULT 0x80270029'i32 + COPYENGINE_E_ALREADY_EXISTS_READONLY* = HRESULT 0x8027002a'i32 + COPYENGINE_E_ALREADY_EXISTS_SYSTEM* = HRESULT 0x8027002b'i32 + COPYENGINE_E_ALREADY_EXISTS_FOLDER* = HRESULT 0x8027002c'i32 + COPYENGINE_E_STREAM_LOSS* = HRESULT 0x8027002d'i32 + COPYENGINE_E_EA_LOSS* = HRESULT 0x8027002e'i32 + COPYENGINE_E_PROPERTY_LOSS* = HRESULT 0x8027002f'i32 + COPYENGINE_E_PROPERTIES_LOSS* = HRESULT 0x80270030'i32 + COPYENGINE_E_ENCRYPTION_LOSS* = HRESULT 0x80270031'i32 + COPYENGINE_E_DISK_FULL* = HRESULT 0x80270032'i32 + COPYENGINE_E_DISK_FULL_CLEAN* = HRESULT 0x80270033'i32 + COPYENGINE_E_EA_NOT_SUPPORTED* = HRESULT 0x80270034'i32 + COPYENGINE_E_CANT_REACH_SOURCE* = HRESULT 0x80270035'i32 + COPYENGINE_E_RECYCLE_UNKNOWN_ERROR* = HRESULT 0x80270035'i32 + COPYENGINE_E_RECYCLE_FORCE_NUKE* = HRESULT 0x80270036'i32 + COPYENGINE_E_RECYCLE_SIZE_TOO_BIG* = HRESULT 0x80270037'i32 + COPYENGINE_E_RECYCLE_PATH_TOO_LONG* = HRESULT 0x80270038'i32 + COPYENGINE_E_RECYCLE_BIN_NOT_FOUND* = HRESULT 0x8027003a'i32 + COPYENGINE_E_NEWFILE_NAME_TOO_LONG* = HRESULT 0x8027003b'i32 + COPYENGINE_E_NEWFOLDER_NAME_TOO_LONG* = HRESULT 0x8027003c'i32 + COPYENGINE_E_DIR_NOT_EMPTY* = HRESULT 0x8027003d'i32 + COPYENGINE_E_FAT_MAX_IN_ROOT* = HRESULT 0x8027003e'i32 + COPYENGINE_E_ACCESSDENIED_READONLY* = HRESULT 0x8027003f'i32 + COPYENGINE_E_REDIRECTED_TO_WEBPAGE* = HRESULT 0x80270040'i32 + COPYENGINE_E_SERVER_BAD_FILE_TYPE* = HRESULT 0x80270041'i32 + NETCACHE_E_NEGATIVE_CACHE* = HRESULT 0x80270100'i32 + EXECUTE_E_LAUNCH_APPLICATION* = HRESULT 0x80270101'i32 + SHELL_E_WRONG_BITDEPTH* = HRESULT 0x80270102'i32 + LINK_E_DELETE* = HRESULT 0x80270103'i32 + STORE_E_NEWER_VERSION_AVAILABLE* = HRESULT 0x80270104'i32 + LIBRARY_E_NO_SAVE_LOCATION* = HRESULT 0x80270200'i32 + LIBRARY_E_NO_ACCESSIBLE_LOCATION* = HRESULT 0x80270201'i32 + E_USERTILE_UNSUPPORTEDFILETYPE* = HRESULT 0x80270210'i32 + E_USERTILE_CHANGEDISABLED* = HRESULT 0x80270211'i32 + E_USERTILE_LARGEORDYNAMIC* = HRESULT 0x80270212'i32 + E_USERTILE_VIDEOFRAMESIZE* = HRESULT 0x80270213'i32 + E_USERTILE_FILESIZE* = HRESULT 0x80270214'i32 + IMM_ACC_DOCKING_E_INSUFFICIENTHEIGHT* = HRESULT 0x80270230'i32 + IMM_ACC_DOCKING_E_DOCKOCCUPIED* = HRESULT 0x80270231'i32 + IMSC_E_SHELL_COMPONENT_STARTUP_FAILURE* = HRESULT 0x80270233'i32 + E_TILE_NOTIFICATIONS_PLATFORM_FAILURE* = HRESULT 0x80270249'i32 + E_SHELL_EXTENSION_BLOCKED* = HRESULT 0x80270301'i32 + CMF_NORMAL* = 0x0 + CMF_DEFAULTONLY* = 0x1 + CMF_VERBSONLY* = 0x2 + CMF_EXPLORE* = 0x4 + CMF_NOVERBS* = 0x8 + CMF_CANRENAME* = 0x10 + CMF_NODEFAULT* = 0x20 + CMF_INCLUDESTATIC* = 0x40 + CMF_ITEMMENU* = 0x80 + CMF_EXTENDEDVERBS* = 0x100 + CMF_DISABLEDVERBS* = 0x200 + CMF_ASYNCVERBSTATE* = 0x400 + CMF_OPTIMIZEFORINVOKE* = 0x800 + CMF_SYNCCASCADEMENU* = 0x1000 + CMF_DONOTPICKDEFAULT* = 0x2000 + CMF_RESERVED* = 0xffff0000'i32 + GCS_VERBA* = 0x0 + GCS_HELPTEXTA* = 0x1 + GCS_VALIDATEA* = 0x2 + GCS_VERBW* = 0x4 + GCS_HELPTEXTW* = 0x5 + GCS_VALIDATEW* = 0x6 + GCS_VERBICONW* = 0x14 + GCS_UNICODE* = 0x4 + CMDSTR_NEWFOLDERA* = "NewFolder" + CMDSTR_VIEWLISTA* = "ViewList" + CMDSTR_VIEWDETAILSA* = "ViewDetails" + CMDSTR_NEWFOLDERW* = "NewFolder" + CMDSTR_VIEWLISTW* = "ViewList" + CMDSTR_VIEWDETAILSW* = "ViewDetails" + CMIC_MASK_HOTKEY* = SEE_MASK_HOTKEY + CMIC_MASK_ICON* = SEE_MASK_ICON + CMIC_MASK_FLAG_NO_UI* = SEE_MASK_FLAG_NO_UI + CMIC_MASK_UNICODE* = SEE_MASK_UNICODE + CMIC_MASK_NO_CONSOLE* = SEE_MASK_NO_CONSOLE + CMIC_MASK_ASYNCOK* = SEE_MASK_ASYNCOK + CMIC_MASK_NOASYNC* = SEE_MASK_NOASYNC + CMIC_MASK_SHIFT_DOWN* = 0x10000000 + CMIC_MASK_CONTROL_DOWN* = 0x40000000 + CMIC_MASK_FLAG_LOG_USAGE* = SEE_MASK_FLAG_LOG_USAGE + CMIC_MASK_NOZONECHECKS* = SEE_MASK_NOZONECHECKS + CMIC_MASK_PTINVOKE* = 0x20000000 + IID_IContextMenu* = DEFINE_GUID("000214e4-0000-0000-c000-000000000046") + IID_IContextMenu2* = DEFINE_GUID("000214f4-0000-0000-c000-000000000046") + IID_IContextMenu3* = DEFINE_GUID("bcfce0a0-ec17-11d0-8d10-00a0c90f2719") + IID_IExecuteCommand* = DEFINE_GUID("7f9185b0-cb92-43c5-80a9-92277a4f7b54") + IID_IPersistFolder* = DEFINE_GUID("000214ea-0000-0000-c000-000000000046") + IRTIR_TASK_NOT_RUNNING* = 0 + IRTIR_TASK_RUNNING* = 1 + IRTIR_TASK_SUSPENDED* = 2 + IRTIR_TASK_PENDING* = 3 + IRTIR_TASK_FINISHED* = 4 + IID_IRunnableTask* = DEFINE_GUID("85788d00-6807-11d0-b810-00c04fd706ec") + TOID_NULL* = GUID_NULL + ITSAT_DEFAULT_PRIORITY* = 0x10000000 + ITSAT_MAX_PRIORITY* = 0x7fffffff + ITSAT_MIN_PRIORITY* = 0x00000000 + ITSSFLAG_COMPLETE_ON_DESTROY* = 0x0 + ITSSFLAG_KILL_ON_DESTROY* = 0x1 + ITSSFLAG_FLAGS_MASK* = 0x3 + ITSS_THREAD_DESTROY_DEFAULT_TIMEOUT* = 10*1000 + ITSS_THREAD_TERMINATE_TIMEOUT* = INFINITE + ITSS_THREAD_TIMEOUT_NO_CHANGE* = INFINITE-1 + IID_IShellTaskScheduler* = DEFINE_GUID("6ccb7be0-6807-11d0-b810-00c04fd706ec") + SID_ShellTaskScheduler* = IID_IShellTaskScheduler + IID_IQueryCodePage* = DEFINE_GUID("c7b236ce-ee80-11d0-985f-006008059382") + IID_IPersistFolder2* = DEFINE_GUID("1ac3d9f0-175c-11d1-95be-00609797ea4f") + CSIDL_FLAG_DONT_VERIFY* = 0x4000 + CSIDL_FLAG_PFTI_TRACKTARGET* = CSIDL_FLAG_DONT_VERIFY + IID_IPersistFolder3* = DEFINE_GUID("cef04fdf-fe72-11d2-87a5-00c04f6837cf") + IID_IPersistIDList* = DEFINE_GUID("1079acfc-29bd-11d3-8e0d-00c04f6837d5") + IID_IEnumIDList* = DEFINE_GUID("000214f2-0000-0000-c000-000000000046") + IID_IEnumFullIDList* = DEFINE_GUID("d0191542-7954-4908-bc06-b2360bbe45ba") + SHGDN_NORMAL* = 0x0 + SHGDN_INFOLDER* = 0x1 + SHGDN_FOREDITING* = 0x1000 + SHGDN_FORADDRESSBAR* = 0x4000 + SHGDN_FORPARSING* = 0x8000 + SHCONTF_CHECKING_FOR_CHILDREN* = 0x10 + SHCONTF_FOLDERS* = 0x20 + SHCONTF_NONFOLDERS* = 0x40 + SHCONTF_INCLUDEHIDDEN* = 0x80 + SHCONTF_INIT_ON_FIRST_NEXT* = 0x100 + SHCONTF_NETPRINTERSRCH* = 0x200 + SHCONTF_SHAREABLE* = 0x400 + SHCONTF_STORAGE* = 0x800 + SHCONTF_NAVIGATION_ENUM* = 0x1000 + SHCONTF_FASTITEMS* = 0x2000 + SHCONTF_FLATLIST* = 0x4000 + SHCONTF_ENABLE_ASYNC* = 0x8000 + SHCONTF_INCLUDESUPERHIDDEN* = 0x10000 + SHCIDS_ALLFIELDS* = 0x80000000'i32 + SHCIDS_CANONICALONLY* = 0x10000000 + SHCIDS_BITMASK* = 0xffff0000'i32 + SHCIDS_COLUMNMASK* = 0x0000ffff + SFGAO_CANCOPY* = DROPEFFECT_COPY + SFGAO_CANMOVE* = DROPEFFECT_MOVE + SFGAO_CANLINK* = DROPEFFECT_LINK + SFGAO_STORAGE* = 0x8 + SFGAO_CANRENAME* = 0x10 + SFGAO_CANDELETE* = 0x20 + SFGAO_HASPROPSHEET* = 0x40 + SFGAO_DROPTARGET* = 0x100 + SFGAO_CAPABILITYMASK* = 0x177 + SFGAO_SYSTEM* = 0x1000 + SFGAO_ENCRYPTED* = 0x2000 + SFGAO_ISSLOW* = 0x4000 + SFGAO_GHOSTED* = 0x8000 + SFGAO_LINK* = 0x10000 + SFGAO_SHARE* = 0x20000 + SFGAO_READONLY* = 0x40000 + SFGAO_HIDDEN* = 0x80000 + SFGAO_DISPLAYATTRMASK* = 0xfc000 + SFGAO_FILESYSANCESTOR* = 0x10000000 + SFGAO_FOLDER* = 0x20000000 + SFGAO_FILESYSTEM* = 0x40000000 + SFGAO_HASSUBFOLDER* = 0x80000000'i32 + SFGAO_CONTENTSMASK* = 0x80000000'i32 + SFGAO_VALIDATE* = 0x1000000 + SFGAO_REMOVABLE* = 0x2000000 + SFGAO_COMPRESSED* = 0x4000000 + SFGAO_BROWSABLE* = 0x8000000 + SFGAO_NONENUMERATED* = 0x100000 + SFGAO_NEWCONTENT* = 0x200000 + SFGAO_CANMONIKER* = 0x400000 + SFGAO_HASSTORAGE* = 0x400000 + SFGAO_STREAM* = 0x400000 + SFGAO_STORAGEANCESTOR* = 0x00800000 + SFGAO_STORAGECAPMASK* = 0x70c50008 + SFGAO_PKEYSFGAOMASK* = 0x81044000'i32 + STR_BIND_FORCE_FOLDER_SHORTCUT_RESOLVE* = "Force Folder Shortcut Resolve" + STR_AVOID_DRIVE_RESTRICTION_POLICY* = "Avoid Drive Restriction Policy" + STR_SKIP_BINDING_CLSID* = "Skip Binding CLSID" + STR_PARSE_PREFER_FOLDER_BROWSING* = "Parse Prefer Folder Browsing" + STR_DONT_PARSE_RELATIVE* = "Don't Parse Relative" + STR_PARSE_TRANSLATE_ALIASES* = "Parse Translate Aliases" + STR_PARSE_SKIP_NET_CACHE* = "Skip Net Resource Cache" + STR_PARSE_SHELL_PROTOCOL_TO_FILE_OBJECTS* = "Parse Shell Protocol To File Objects" + STR_TRACK_CLSID* = "Track the CLSID" + STR_INTERNAL_NAVIGATE* = "Internal Navigation" + STR_PARSE_PROPERTYSTORE* = "DelegateNamedProperties" + STR_NO_VALIDATE_FILENAME_CHARS* = "NoValidateFilenameChars" + STR_BIND_DELEGATE_CREATE_OBJECT* = "Delegate Object Creation" + STR_PARSE_ALLOW_INTERNET_SHELL_FOLDERS* = "Allow binding to Internet shell folder handlers and negate STR_PARSE_PREFER_WEB_BROWSING" + STR_PARSE_PREFER_WEB_BROWSING* = "Do not bind to Internet shell folder handlers" + STR_PARSE_SHOW_NET_DIAGNOSTICS_UI* = "Show network diagnostics UI" + STR_PARSE_DONT_REQUIRE_VALIDATED_URLS* = "Do not require validated URLs" + STR_INTERNETFOLDER_PARSE_ONLY_URLMON_BINDABLE* = "Validate UR" + BIND_INTERRUPTABLE* = 0xffffffff'i32 + STR_BIND_FOLDERS_READ_ONLY* = "Folders As Read Only" + STR_BIND_FOLDER_ENUM_MODE* = "Folder Enum Mode" + FEM_VIEWRESULT* = 0 + FEM_NAVIGATION* = 1 + IID_IObjectWithFolderEnumMode* = DEFINE_GUID("6a9d9026-0e6e-464c-b000-42ecc07de673") + STR_PARSE_WITH_EXPLICIT_PROGID* = "ExplicitProgid" + STR_PARSE_WITH_EXPLICIT_ASSOCAPP* = "ExplicitAssociationApp" + STR_PARSE_EXPLICIT_ASSOCIATION_SUCCESSFUL* = "ExplicitAssociationSuccessful" + STR_PARSE_AND_CREATE_ITEM* = "ParseAndCreateItem" + STR_PROPERTYBAG_PARAM* = "SHBindCtxPropertyBag" + STR_ENUM_ITEMS_FLAGS* = "SHCONTF" + IID_IParseAndCreateItem* = DEFINE_GUID("67efed0e-e827-4408-b493-78f3982b685c") + STR_ITEM_CACHE_CONTEXT* = "ItemCacheContext" + IID_IShellFolder* = DEFINE_GUID("000214e6-0000-0000-c000-000000000046") + IID_IEnumExtraSearch* = DEFINE_GUID("0e700be1-9db6-11d1-a1ce-00c04fd75d13") + IID_IShellFolder2* = DEFINE_GUID("93f2f68c-1d1b-11d3-a30e-00c04f79abd1") + FWF_NONE* = 0x0 + FWF_AUTOARRANGE* = 0x1 + FWF_ABBREVIATEDNAMES* = 0x2 + FWF_SNAPTOGRID* = 0x4 + FWF_OWNERDATA* = 0x8 + FWF_BESTFITWINDOW* = 0x10 + FWF_DESKTOP* = 0x20 + FWF_SINGLESEL* = 0x40 + FWF_NOSUBFOLDERS* = 0x80 + FWF_TRANSPARENT* = 0x100 + FWF_NOCLIENTEDGE* = 0x200 + FWF_NOSCROLL* = 0x400 + FWF_ALIGNLEFT* = 0x800 + FWF_NOICONS* = 0x1000 + FWF_SHOWSELALWAYS* = 0x2000 + FWF_NOVISIBLE* = 0x4000 + FWF_SINGLECLICKACTIVATE* = 0x8000 + FWF_NOWEBVIEW* = 0x10000 + FWF_HIDEFILENAMES* = 0x20000 + FWF_CHECKSELECT* = 0x40000 + FWF_NOENUMREFRESH* = 0x80000 + FWF_NOGROUPING* = 0x100000 + FWF_FULLROWSELECT* = 0x200000 + FWF_NOFILTERS* = 0x400000 + FWF_NOCOLUMNHEADER* = 0x800000 + FWF_NOHEADERINALLVIEWS* = 0x1000000 + FWF_EXTENDEDTILES* = 0x2000000 + FWF_TRICHECKSELECT* = 0x4000000 + FWF_AUTOCHECKSELECT* = 0x8000000 + FWF_NOBROWSERVIEWSTATE* = 0x10000000 + FWF_SUBSETGROUPS* = 0x20000000 + FWF_USESEARCHFOLDER* = 0x40000000 + FWF_ALLOWRTLREADING* = 0x80000000'i32 + FVM_AUTO* = -1 + FVM_FIRST* = 1 + FVM_ICON* = 1 + FVM_SMALLICON* = 2 + FVM_LIST* = 3 + FVM_DETAILS* = 4 + FVM_THUMBNAIL* = 5 + FVM_TILE* = 6 + FVM_THUMBSTRIP* = 7 + FVM_CONTENT* = 8 + FVM_LAST* = 8 + FLVM_UNSPECIFIED* = -1 + FLVM_FIRST* = 1 + FLVM_DETAILS* = 1 + FLVM_TILES* = 2 + FLVM_ICONS* = 3 + FLVM_LIST* = 4 + FLVM_CONTENT* = 5 + FLVM_LAST* = 5 + FVO_DEFAULT* = 0x0 + FVO_VISTALAYOUT* = 0x1 + FVO_CUSTOMPOSITION* = 0x2 + FVO_CUSTOMORDERING* = 0x4 + FVO_SUPPORTHYPERLINKS* = 0x8 + FVO_NOANIMATIONS* = 0x10 + FVO_NOSCROLLTIPS* = 0x20 + IID_IFolderViewOptions* = DEFINE_GUID("3cc974d2-b302-4d36-ad3e-06d93f695d3f") + SVSI_DESELECT* = 0x0 + SVSI_SELECT* = 0x1 + SVSI_EDIT* = 0x3 + SVSI_DESELECTOTHERS* = 0x4 + SVSI_ENSUREVISIBLE* = 0x8 + SVSI_FOCUSED* = 0x10 + SVSI_TRANSLATEPT* = 0x20 + SVSI_SELECTIONMARK* = 0x40 + SVSI_POSITIONITEM* = 0x80 + SVSI_CHECK* = 0x100 + SVSI_CHECK2* = 0x200 + SVSI_KEYBOARDSELECT* = 0x401 + SVSI_NOTAKEFOCUS* = 0x40000000 + SVSI_NOSTATECHANGE* = UINT 0x80000000'i32 + SVGIO_BACKGROUND* = 0x0 + SVGIO_SELECTION* = 0x1 + SVGIO_ALLVIEW* = 0x2 + SVGIO_CHECKED* = 0x3 + SVGIO_TYPE_MASK* = 0xf + SVGIO_FLAG_VIEWORDER* = 0x80000000'i32 + SVUIA_DEACTIVATE* = 0 + SVUIA_ACTIVATE_NOFOCUS* = 1 + SVUIA_ACTIVATE_FOCUS* = 2 + SVUIA_INPLACEACTIVATE* = 3 + IID_IShellView* = DEFINE_GUID("000214e3-0000-0000-c000-000000000046") + SV2GV_CURRENTVIEW* = UINT(-1) + SV2GV_DEFAULTVIEW* = UINT(-2) + IID_IShellView2* = DEFINE_GUID("88e39e80-3578-11cf-ae69-08002b2e1262") + SV3CVW3_DEFAULT* = 0x0 + SV3CVW3_NONINTERACTIVE* = 0x1 + SV3CVW3_FORCEVIEWMODE* = 0x2 + SV3CVW3_FORCEFOLDERFLAGS* = 0x4 + IID_IShellView3* = DEFINE_GUID("ec39fa88-f8af-41c5-8421-38bed28f4673") + IID_IFolderView* = DEFINE_GUID("cde725b0-ccc9-4519-917e-325d72fab4ce") + SID_SFolderView* = IID_IFolderView + IID_ISearchBoxInfo* = DEFINE_GUID("6af6e03f-d664-4ef4-9626-f7e0ed36755e") + SORT_DESCENDING* = -1 + SORT_ASCENDING* = 1 + FVST_EMPTYTEXT* = 0 + IID_IFolderView2* = DEFINE_GUID("1af3a467-214f-4298-908e-06b03e0b39f9") + IID_IFolderViewSettings* = DEFINE_GUID("ae8c987d-8797-4ed3-be72-2a47dd938db0") + IID_IPreviewHandlerVisuals* = DEFINE_GUID("196bf9a5-b346-4ef0-aa1e-5dcdb76768b1") + VPWF_DEFAULT* = 0x0 + VPWF_ALPHABLEND* = 0x1 + VPCF_TEXT* = 1 + VPCF_BACKGROUND* = 2 + VPCF_SORTCOLUMN* = 3 + VPCF_SUBTEXT* = 4 + VPCF_TEXTBACKGROUND* = 5 + IID_IVisualProperties* = DEFINE_GUID("e693cf68-d967-4112-8763-99172aee5e5a") + CDBOSC_SETFOCUS* = 0x00000000 + CDBOSC_KILLFOCUS* = 0x00000001 + CDBOSC_SELCHANGE* = 0x00000002 + CDBOSC_RENAME* = 0x00000003 + CDBOSC_STATECHANGE* = 0x00000004 + IID_ICommDlgBrowser* = DEFINE_GUID("000214f1-0000-0000-c000-000000000046") + SID_SExplorerBrowserFrame* = IID_ICommDlgBrowser + CDB2N_CONTEXTMENU_DONE* = 0x00000001 + CDB2N_CONTEXTMENU_START* = 0x00000002 + CDB2GVF_SHOWALLFILES* = 0x1 + CDB2GVF_ISFILESAVE* = 0x2 + CDB2GVF_ALLOWPREVIEWPANE* = 0x4 + CDB2GVF_NOSELECTVERB* = 0x8 + CDB2GVF_NOINCLUDEITEM* = 0x10 + CDB2GVF_ISFOLDERPICKER* = 0x20 + CDB2GVF_ADDSHIELD* = 0x40 + IID_ICommDlgBrowser2* = DEFINE_GUID("10339516-2894-11d2-9039-00c04f8eeb3e") + IID_ICommDlgBrowser3* = DEFINE_GUID("c8ad25a1-3294-41ee-8165-71174bd01c57") + CM_MASK_WIDTH* = 0x1 + CM_MASK_DEFAULTWIDTH* = 0x2 + CM_MASK_IDEALWIDTH* = 0x4 + CM_MASK_NAME* = 0x8 + CM_MASK_STATE* = 0x10 + CM_STATE_NONE* = 0x0 + CM_STATE_VISIBLE* = 0x1 + CM_STATE_FIXEDWIDTH* = 0x2 + CM_STATE_NOSORTBYFOLDERNESS* = 0x4 + CM_STATE_ALWAYSVISIBLE* = 0x8 + CM_ENUM_ALL* = 0x1 + CM_ENUM_VISIBLE* = 0x2 + CM_WIDTH_USEDEFAULT* = -1 + CM_WIDTH_AUTOSIZE* = -2 + IID_IColumnManager* = DEFINE_GUID("d8ec27bb-3f3b-4042-b10a-4acfd924d453") + IID_IFolderFilterSite* = DEFINE_GUID("c0a651f5-b48b-11d2-b5ed-006097c686f6") + IID_IFolderFilter* = DEFINE_GUID("9cc22886-dc8e-11d2-b1d0-00c04f8eeb3e") + IID_IInputObjectSite* = DEFINE_GUID("f1db8392-7331-11d0-8c99-00a0c92dbfe8") + IID_IInputObject* = DEFINE_GUID("68284faa-6a48-11d0-8c78-00c04fd918b4") + IID_IInputObject2* = DEFINE_GUID("6915c085-510b-44cd-94af-28dfa56cf92b") + IID_IShellIcon* = DEFINE_GUID("000214e5-0000-0000-c000-000000000046") + SBSP_DEFBROWSER* = 0x0000 + SBSP_SAMEBROWSER* = 0x0001 + SBSP_NEWBROWSER* = 0x0002 + SBSP_DEFMODE* = 0x0000 + SBSP_OPENMODE* = 0x0010 + SBSP_EXPLOREMODE* = 0x0020 + SBSP_HELPMODE* = 0x0040 + SBSP_NOTRANSFERHIST* = 0x0080 + SBSP_ABSOLUTE* = 0x0000 + SBSP_RELATIVE* = 0x1000 + SBSP_PARENT* = 0x2000 + SBSP_NAVIGATEBACK* = 0x4000 + SBSP_NAVIGATEFORWARD* = 0x8000 + SBSP_ALLOW_AUTONAVIGATE* = 0x00010000 + SBSP_KEEPSAMETEMPLATE* = 0x00020000 + SBSP_KEEPWORDWHEELTEXT* = 0x00040000 + SBSP_ACTIVATE_NOFOCUS* = 0x00080000 + SBSP_CREATENOHISTORY* = 0x00100000 + SBSP_PLAYNOSOUND* = 0x00200000 + SBSP_CALLERUNTRUSTED* = 0x00800000 + SBSP_TRUSTFIRSTDOWNLOAD* = 0x01000000 + SBSP_UNTRUSTEDFORDOWNLOAD* = 0x02000000 + SBSP_NOAUTOSELECT* = 0x04000000 + SBSP_WRITENOHISTORY* = 0x08000000 + SBSP_TRUSTEDFORACTIVEX* = 0x10000000 + SBSP_FEEDNAVIGATION* = 0x20000000 + SBSP_REDIRECT* = 0x40000000 + SBSP_INITIATEDBYHLINKFRAME* = 0x80000000'i32 + FCW_STATUS* = 0x0001 + FCW_TOOLBAR* = 0x0002 + FCW_TREE* = 0x0003 + FCW_INTERNETBAR* = 0x0006 + FCW_PROGRESS* = 0x0008 + FCT_MERGE* = 0x0001 + FCT_CONFIGABLE* = 0x0002 + FCT_ADDTOEND* = 0x0004 + IID_IProfferService* = DEFINE_GUID("cb728b20-f786-11ce-92ad-00aa00a74cd0") + SID_SProfferService* = IID_IProfferService + STR_DONT_RESOLVE_LINK* = "Don't Resolve Link" + STR_GET_ASYNC_HANDLER* = "GetAsyncHandler" + SIGDN_NORMALDISPLAY* = 0x0 + SIGDN_PARENTRELATIVEPARSING* = int32 0x80018001'i32 + SIGDN_DESKTOPABSOLUTEPARSING* = int32 0x80028000'i32 + SIGDN_PARENTRELATIVEEDITING* = int32 0x80031001'i32 + SIGDN_DESKTOPABSOLUTEEDITING* = int32 0x8004c000'i32 + SIGDN_FILESYSPATH* = int32 0x80058000'i32 + SIGDN_URL* = int32 0x80068000'i32 + SIGDN_PARENTRELATIVEFORADDRESSBAR* = int32 0x8007c001'i32 + SIGDN_PARENTRELATIVE* = int32 0x80080001'i32 + SIGDN_PARENTRELATIVEFORUI* = int32 0x80094001'i32 + SICHINT_DISPLAY* = 0x0 + SICHINT_ALLFIELDS* = int32 0x80000000'i32 + SICHINT_CANONICAL* = 0x10000000 + SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL* = 0x20000000 + IID_IShellItem* = DEFINE_GUID("43826d1e-e718-42ee-bc55-a1e261c37bfe") + DOGIF_DEFAULT* = 0x0 + DOGIF_TRAVERSE_LINK* = 0x1 + DOGIF_NO_HDROP* = 0x2 + DOGIF_NO_URL* = 0x4 + DOGIF_ONLY_IF_ONE* = 0x8 + STR_GPS_HANDLERPROPERTIESONLY* = "GPS_HANDLERPROPERTIESONLY" + STR_GPS_FASTPROPERTIESONLY* = "GPS_FASTPROPERTIESONLY" + STR_GPS_OPENSLOWITEM* = "GPS_OPENSLOWITEM" + STR_GPS_DELAYCREATION* = "GPS_DELAYCREATION" + STR_GPS_BESTEFFORT* = "GPS_BESTEFFORT" + STR_GPS_NO_OPLOCK* = "GPS_NO_OPLOCK" + IID_IShellItem2* = DEFINE_GUID("7e9fb0d3-919f-4307-ab2e-9b1860310c93") + SIIGBF_RESIZETOFIT* = 0x0 + SIIGBF_BIGGERSIZEOK* = 0x1 + SIIGBF_MEMORYONLY* = 0x2 + SIIGBF_ICONONLY* = 0x4 + SIIGBF_THUMBNAILONLY* = 0x8 + SIIGBF_INCACHEONLY* = 0x10 + SIIGBF_CROPTOSQUARE* = 0x20 + SIIGBF_WIDETHUMBNAILS* = 0x40 + SIIGBF_ICONBACKGROUND* = 0x80 + SIIGBF_SCALEUP* = 0x100 + IID_IShellItemImageFactory* = DEFINE_GUID("bcc18b79-ba16-442f-80c4-8a59c30c463b") + IID_IUserAccountChangeCallback* = DEFINE_GUID("a561e69a-b4b8-4113-91a5-64c6bcca3430") + IID_IEnumShellItems* = DEFINE_GUID("70629033-e363-4a28-a567-0db78006e6d7") + STGOP_MOVE* = 1 + STGOP_COPY* = 2 + STGOP_SYNC* = 3 + STGOP_REMOVE* = 5 + STGOP_RENAME* = 6 + STGOP_APPLYPROPERTIES* = 8 + STGOP_NEW* = 10 + TSF_NORMAL* = 0x0 + TSF_FAIL_EXIST* = 0x0 + TSF_RENAME_EXIST* = 0x1 + TSF_OVERWRITE_EXIST* = 0x2 + TSF_ALLOW_DECRYPTION* = 0x4 + TSF_NO_SECURITY* = 0x8 + TSF_COPY_CREATION_TIME* = 0x10 + TSF_COPY_WRITE_TIME* = 0x20 + TSF_USE_FULL_ACCESS* = 0x40 + TSF_DELETE_RECYCLE_IF_POSSIBLE* = 0x80 + TSF_COPY_HARD_LINK* = 0x100 + TSF_COPY_LOCALIZED_NAME* = 0x200 + TSF_MOVE_AS_COPY_DELETE* = 0x400 + TSF_SUSPEND_SHELLEVENTS* = 0x800 + TS_NONE* = 0x0 + TS_PERFORMING* = 0x1 + TS_PREPARING* = 0x2 + TS_INDETERMINATE* = 0x4 + IID_ITransferAdviseSink* = DEFINE_GUID("d594d0d8-8da7-457b-b3b4-ce5dbaac0b88") + IID_ITransferSource* = DEFINE_GUID("00adb003-bde9-45c6-8e29-d09f9353e108") + IID_IEnumResources* = DEFINE_GUID("2dd81fe3-a83c-4da9-a330-47249d345ba1") + IID_IShellItemResources* = DEFINE_GUID("ff5693be-2ce0-4d48-b5c5-40817d1acdb9") + IID_ITransferDestination* = DEFINE_GUID("48addd32-3ca5-4124-abe3-b5a72531b207") + IID_IStreamAsync* = DEFINE_GUID("fe0b6665-e0ca-49b9-a178-2b5cb48d92a5") + IID_IStreamUnbufferedInfo* = DEFINE_GUID("8a68fdda-1fdc-4c20-8ceb-416643b5a625") + IID_IFileOperationProgressSink* = DEFINE_GUID("04b0f1a7-9490-44bc-96e1-4296a31252e2") + SIATTRIBFLAGS_AND* = 0x1 + SIATTRIBFLAGS_OR* = 0x2 + SIATTRIBFLAGS_APPCOMPAT* = 0x3 + SIATTRIBFLAGS_MASK* = 0x3 + SIATTRIBFLAGS_ALLITEMS* = 0x4000 + IID_IShellItemArray* = DEFINE_GUID("b63ea76d-1f85-456f-a19c-48159efa858b") + IID_IInitializeWithItem* = DEFINE_GUID("7f73be3f-fb79-493c-a6c7-7ee14e245841") + IID_IObjectWithSelection* = DEFINE_GUID("1c9cd5bb-98e9-4491-a60f-31aacc72b83c") + IID_IObjectWithBackReferences* = DEFINE_GUID("321a6a6a-d61f-4bf3-97ae-14be2986bb36") + PUIFNF_DEFAULT* = 0x0 + PUIFNF_MNEMONIC* = 0x1 + PUIF_DEFAULT* = 0x0 + PUIF_RIGHTALIGN* = 0x1 + PUIF_NOLABELININFOTIP* = 0x2 + PUIFFDF_DEFAULT* = 0x0 + PUIFFDF_RIGHTTOLEFT* = 0x1 + PUIFFDF_SHORTFORMAT* = 0x2 + PUIFFDF_NOTIME* = 0x4 + PUIFFDF_FRIENDLYDATE* = 0x8 + IID_IPropertyUI* = DEFINE_GUID("757a7d9f-919a-4118-99d7-dbb208c8cc66") + IID_ICategoryProvider* = DEFINE_GUID("9af64809-5864-4c26-a720-c1f78c086ee3") + CATINFO_NORMAL* = 0x0 + CATINFO_COLLAPSED* = 0x1 + CATINFO_HIDDEN* = 0x2 + CATINFO_EXPANDED* = 0x4 + CATINFO_NOHEADER* = 0x8 + CATINFO_NOTCOLLAPSIBLE* = 0x10 + CATINFO_NOHEADERCOUNT* = 0x20 + CATINFO_SUBSETTED* = 0x40 + CATSORT_DEFAULT* = 0x0 + CATSORT_NAME* = 0x1 + IID_ICategorizer* = DEFINE_GUID("a3b14589-9174-49a8-89a3-06a1ae2b9ba7") + DI_GETDRAGIMAGE* = "ShellGetDragImage" + IID_IDropTargetHelper* = DEFINE_GUID("4657278b-411b-11d2-839a-00c04fd918d0") + IID_IDragSourceHelper* = DEFINE_GUID("de5bf786-477a-11d2-839d-00c04fd918d0") + DSH_ALLOWDROPDESCRIPTIONTEXT* = 0x1 + IID_IDragSourceHelper2* = DEFINE_GUID("83e07d0d-0c5f-4163-bf1a-60b274051e40") + SLR_NO_UI* = 0x1 + SLR_ANY_MATCH* = 0x2 + SLR_UPDATE* = 0x4 + SLR_NOUPDATE* = 0x8 + SLR_NOSEARCH* = 0x10 + SLR_NOTRACK* = 0x20 + SLR_NOLINKINFO* = 0x40 + SLR_INVOKE_MSI* = 0x80 + SLR_NO_UI_WITH_MSG_PUMP* = 0x101 + SLR_OFFER_DELETE_WITHOUT_FILE* = 0x200 + SLR_KNOWNFOLDER* = 0x400 + SLR_MACHINE_IN_LOCAL_TARGET* = 0x800 + SLR_UPDATE_MACHINE_AND_SID* = 0x1000 + SLGP_SHORTPATH* = 0x1 + SLGP_UNCPRIORITY* = 0x2 + SLGP_RAWPATH* = 0x4 + SLGP_RELATIVEPRIORITY* = 0x8 + IID_IShellLinkA* = DEFINE_GUID("000214ee-0000-0000-c000-000000000046") + IID_IShellLinkDataList* = DEFINE_GUID("45e2b4ae-b1c3-11d0-b92f-00a0c90312e1") + IID_IResolveShellLink* = DEFINE_GUID("5cd52983-9449-11d2-963a-00c04f79adf0") + SPINITF_NORMAL* = 0x0 + SPINITF_MODAL* = 0x1 + SPINITF_NOMINIMIZE* = 0x8 + IID_IActionProgressDialog* = DEFINE_GUID("49ff1172-eadc-446d-9285-156453a6431c") + IID_IHWEventHandler* = DEFINE_GUID("c1fb73d0-ec3a-4ba2-b512-8cdb9187b6d1") + IID_IHWEventHandler2* = DEFINE_GUID("cfcc809f-295d-42e8-9ffc-424b33c487e6") + ARCONTENT_AUTORUNINF* = 0x00000002 + ARCONTENT_AUDIOCD* = 0x00000004 + ARCONTENT_DVDMOVIE* = 0x00000008 + ARCONTENT_BLANKCD* = 0x00000010 + ARCONTENT_BLANKDVD* = 0x00000020 + ARCONTENT_UNKNOWNCONTENT* = 0x00000040 + ARCONTENT_AUTOPLAYPIX* = 0x00000080 + ARCONTENT_AUTOPLAYMUSIC* = 0x00000100 + ARCONTENT_AUTOPLAYVIDEO* = 0x00000200 + ARCONTENT_VCD* = 0x00000400 + ARCONTENT_SVCD* = 0x00000800 + ARCONTENT_DVDAUDIO* = 0x00001000 + ARCONTENT_BLANKBD* = 0x00002000 + ARCONTENT_BLURAY* = 0x00004000 + ARCONTENT_CAMERASTORAGE* = 0x00008000 + ARCONTENT_CUSTOMEVENT* = 0x00010000 + ARCONTENT_NONE* = 0x00000000 + ARCONTENT_MASK* = 0x0001FFFE + ARCONTENT_PHASE_UNKNOWN* = 0x00000000 + ARCONTENT_PHASE_PRESNIFF* = 0x10000000 + ARCONTENT_PHASE_SNIFFING* = 0x20000000 + ARCONTENT_PHASE_FINAL* = 0x40000000 + ARCONTENT_PHASE_MASK* = 0x70000000 + IID_IQueryCancelAutoPlay* = DEFINE_GUID("ddefe873-6997-4e68-be26-39b633adbe12") + IID_IDynamicHWHandler* = DEFINE_GUID("dc2601d7-059e-42fc-a09d-2afd21b6d5f7") + SPBEGINF_NORMAL* = 0x0 + SPBEGINF_AUTOTIME* = 0x2 + SPBEGINF_NOPROGRESSBAR* = 0x10 + SPBEGINF_MARQUEEPROGRESS* = 0x20 + SPBEGINF_NOCANCELBUTTON* = 0x40 + SPACTION_NONE* = 0 + SPACTION_MOVING* = 1 + SPACTION_COPYING* = 2 + SPACTION_RECYCLING* = 3 + SPACTION_APPLYINGATTRIBS* = 4 + SPACTION_DOWNLOADING* = 5 + SPACTION_SEARCHING_INTERNET* = 6 + SPACTION_CALCULATING* = 7 + SPACTION_UPLOADING* = 8 + SPACTION_SEARCHING_FILES* = 9 + SPACTION_DELETING* = 10 + SPACTION_RENAMING* = 11 + SPACTION_FORMATTING* = 12 + SPACTION_COPY_MOVING* = 13 + SPTEXT_ACTIONDESCRIPTION* = 1 + SPTEXT_ACTIONDETAIL* = 2 + IID_IActionProgress* = DEFINE_GUID("49ff1173-eadc-446d-9285-156453a6431c") + IID_IShellExtInit* = DEFINE_GUID("000214e8-0000-0000-c000-000000000046") + EXPPS_FILETYPES* = 0x1 + IID_IShellPropSheetExt* = DEFINE_GUID("000214e9-0000-0000-c000-000000000046") + IID_IRemoteComputer* = DEFINE_GUID("000214fe-0000-0000-c000-000000000046") + IID_IQueryContinue* = DEFINE_GUID("7307055c-b24a-486b-9f25-163e597a28a9") + IID_IObjectWithCancelEvent* = DEFINE_GUID("f279b885-0ae9-4b85-ac06-ddecf9408941") + IID_IUserNotification* = DEFINE_GUID("ba9711ba-5893-4787-a7e1-41277151550b") + IID_IUserNotificationCallback* = DEFINE_GUID("19108294-0441-4aff-8013-fa0a730b0bea") + IID_IUserNotification2* = DEFINE_GUID("215913cc-57eb-4fab-ab5a-e5fa7bea2a6c") + IID_IItemNameLimits* = DEFINE_GUID("1df0d7f1-b267-4d28-8b10-12e23202a5c4") + IID_ISearchFolderItemFactory* = DEFINE_GUID("a0ffbc28-5482-4366-be27-3e81e78e06c2") + IEI_PRIORITY_MAX* = ITSAT_MAX_PRIORITY + IEI_PRIORITY_MIN* = ITSAT_MIN_PRIORITY + IEIT_PRIORITY_NORMAL* = ITSAT_DEFAULT_PRIORITY + IEIFLAG_ASYNC* = 0x0001 + IEIFLAG_CACHE* = 0x0002 + IEIFLAG_ASPECT* = 0x0004 + IEIFLAG_OFFLINE* = 0x0008 + IEIFLAG_GLEAM* = 0x0010 + IEIFLAG_SCREEN* = 0x0020 + IEIFLAG_ORIGSIZE* = 0x0040 + IEIFLAG_NOSTAMP* = 0x0080 + IEIFLAG_NOBORDER* = 0x0100 + IEIFLAG_QUALITY* = 0x0200 + IEIFLAG_REFRESH* = 0x0400 + IID_IExtractImage* = DEFINE_GUID("bb2e617c-0920-11d1-9a0b-00c04fc2d6c1") + IID_IExtractImage2* = DEFINE_GUID("953bb1ee-93b4-11d1-98a3-00c04fb687da") + IID_IThumbnailHandlerFactory* = DEFINE_GUID("e35b4b2e-00da-4bc1-9f13-38bc11f5d417") + IID_IParentAndItem* = DEFINE_GUID("b3a4b685-b685-4805-99d9-5dead2873236") + IID_IDockingWindow* = DEFINE_GUID("012dd920-7b26-11d0-8ca9-00a0c92dbfe8") + DBIM_MINSIZE* = 0x0001 + DBIM_MAXSIZE* = 0x0002 + DBIM_INTEGRAL* = 0x0004 + DBIM_ACTUAL* = 0x0008 + DBIM_TITLE* = 0x0010 + DBIM_MODEFLAGS* = 0x0020 + DBIM_BKCOLOR* = 0x0040 + DBIMF_NORMAL* = 0x0000 + DBIMF_FIXED* = 0x0001 + DBIMF_FIXEDBMP* = 0x0004 + DBIMF_VARIABLEHEIGHT* = 0x0008 + DBIMF_UNDELETEABLE* = 0x0010 + DBIMF_DEBOSSED* = 0x0020 + DBIMF_BKCOLOR* = 0x0040 + DBIMF_USECHEVRON* = 0x0080 + DBIMF_BREAK* = 0x0100 + DBIMF_ADDTOFRONT* = 0x0200 + DBIMF_TOPALIGN* = 0x0400 + DBIMF_NOGRIPPER* = 0x0800 + DBIMF_ALWAYSGRIPPER* = 0x1000 + DBIMF_NOMARGINS* = 0x2000 + DBIF_VIEWMODE_NORMAL* = 0x0000 + DBIF_VIEWMODE_VERTICAL* = 0x0001 + DBIF_VIEWMODE_FLOATING* = 0x0002 + DBIF_VIEWMODE_TRANSPARENT* = 0x0004 + DBID_BANDINFOCHANGED* = 0 + DBID_SHOWONLY* = 1 + DBID_MAXIMIZEBAND* = 2 + DBID_PUSHCHEVRON* = 3 + DBID_DELAYINIT* = 4 + DBID_FINISHINIT* = 5 + DBID_SETWINDOWTHEME* = 6 + DBID_PERMITAUTOHIDE* = 7 + DBPC_SELECTFIRST* = DWORD(-1) + DBPC_SELECTLAST* = DWORD(-2) + IID_IDeskBand* = DEFINE_GUID("eb0fe172-1a3a-11d0-89b3-00a0c90a90ac") + CGID_DeskBand* = IID_IDeskBand + IID_IDeskBandInfo* = DEFINE_GUID("77e425fc-cbf9-4307-ba6a-bb5727745661") + IID_IDeskBand2* = DEFINE_GUID("79d16de4-abee-4021-8d9d-9169b261d657") + IID_ITaskbarList* = DEFINE_GUID("56fdf342-fd6d-11d0-958a-006097c9a090") + IID_ITaskbarList2* = DEFINE_GUID("602d4995-b13a-429b-a66e-1935e44f4317") + THBF_ENABLED* = 0x0 + THBF_DISABLED* = 0x1 + THBF_DISMISSONCLICK* = 0x2 + THBF_NOBACKGROUND* = 0x4 + THBF_HIDDEN* = 0x8 + THBF_NONINTERACTIVE* = 0x10 + THB_BITMAP* = 0x1 + THB_ICON* = 0x2 + THB_TOOLTIP* = 0x4 + THB_FLAGS* = 0x8 + THBN_CLICKED* = 0x1800 + TBPF_NOPROGRESS* = 0x0 + TBPF_INDETERMINATE* = 0x1 + TBPF_NORMAL* = 0x2 + TBPF_ERROR* = 0x4 + TBPF_PAUSED* = 0x8 + IID_ITaskbarList3* = DEFINE_GUID("ea1afb91-9e28-4b86-90e9-9e9f8a5eefaf") + STPF_NONE* = 0x0 + STPF_USEAPPTHUMBNAILALWAYS* = 0x1 + STPF_USEAPPTHUMBNAILWHENACTIVE* = 0x2 + STPF_USEAPPPEEKALWAYS* = 0x4 + STPF_USEAPPPEEKWHENACTIVE* = 0x8 + IID_ITaskbarList4* = DEFINE_GUID("c43dc798-95d1-4bea-9030-bb99e2983a1a") + IID_IStartMenuPinnedList* = DEFINE_GUID("4cd19ada-25a5-4a32-b3b7-347bee5be36b") + IID_ICDBurn* = DEFINE_GUID("3d73a659-e5d0-4d42-afc0-5121ba425c8d") + IDD_WIZEXTN_FIRST* = 0x5000 + IDD_WIZEXTN_LAST* = 0x5100 + IID_IWizardSite* = DEFINE_GUID("88960f5b-422f-4e7b-8013-73415381c3c3") + SID_WizardSite* = IID_IWizardSite + IID_IWizardExtension* = DEFINE_GUID("c02ea696-86cc-491e-9b23-74394a0444a8") + IID_IWebWizardExtension* = DEFINE_GUID("0e6b3f66-98d1-48c0-a222-fbde74e2fbc5") + SID_WebWizardHost* = IID_IWebWizardExtension + SHPWHF_NORECOMPRESS* = 0x00000001 + SHPWHF_NONETPLACECREATE* = 0x00000002 + SHPWHF_NOFILESELECTOR* = 0x00000004 + SHPWHF_USEMRU* = 0x00000008 + SHPWHF_ANYLOCATION* = 0x00000100 + SHPWHF_VALIDATEVIAWEBFOLDERS* = 0x00010000 + IID_IPublishingWizard* = DEFINE_GUID("aa9198bb-ccec-472d-beed-19a4f6733f7a") + IID_IFolderViewHost* = DEFINE_GUID("1ea58f02-d55a-411d-b09e-9e65ac21605b") + IID_IExplorerBrowserEvents* = DEFINE_GUID("361bbdc7-e6ee-4e13-be58-58e2240c810f") + EBO_NONE* = 0x0 + EBO_NAVIGATEONCE* = 0x1 + EBO_SHOWFRAMES* = 0x2 + EBO_ALWAYSNAVIGATE* = 0x4 + EBO_NOTRAVELLOG* = 0x8 + EBO_NOWRAPPERWINDOW* = 0x10 + EBO_HTMLSHAREPOINTVIEW* = 0x20 + EBO_NOBORDER* = 0x40 + EBO_NOPERSISTVIEWSTATE* = 0x80 + EBF_NONE* = 0x0 + EBF_SELECTFROMDATAOBJECT* = 0x100 + EBF_NODROPTARGET* = 0x200 + IID_IExplorerBrowser* = DEFINE_GUID("dfd3b6b5-c10c-4be9-85f6-a66969f402f6") + IID_IAccessibleObject* = DEFINE_GUID("95a391c5-9ed4-4c28-8401-ab9e06719e11") + IID_IResultsFolder* = DEFINE_GUID("96e5ae6d-6ae1-4b1c-900c-c6480eaa8828") + IID_IEnumObjects* = DEFINE_GUID("2c1c7e2e-2d0e-4059-831e-1e6f82335c2e") + OPPROGDLG_DEFAULT* = 0x0 + OPPROGDLG_ENABLEPAUSE* = 0x80 + OPPROGDLG_ALLOWUNDO* = 0x100 + OPPROGDLG_DONTDISPLAYSOURCEPATH* = 0x200 + OPPROGDLG_DONTDISPLAYDESTPATH* = 0x400 + OPPROGDLG_NOMULTIDAYESTIMATES* = 0x800 + OPPROGDLG_DONTDISPLAYLOCATIONS* = 0x1000 + PDM_DEFAULT* = 0x0 + PDM_RUN* = 0x1 + PDM_PREFLIGHT* = 0x2 + PDM_UNDOING* = 0x4 + PDM_ERRORSBLOCKING* = 0x8 + PDM_INDETERMINATE* = 0x10 + PDOPS_RUNNING* = 1 + PDOPS_PAUSED* = 2 + PDOPS_CANCELLED* = 3 + PDOPS_STOPPED* = 4 + PDOPS_ERRORS* = 5 + IID_IOperationsProgressDialog* = DEFINE_GUID("0c9fb851-e5c9-43eb-a370-f0677b13874c") + IID_IIOCancelInformation* = DEFINE_GUID("f5b0bf81-8cb5-4b1b-9449-1a159e0c733c") + FOFX_NOSKIPJUNCTIONS* = 0x00010000 + FOFX_PREFERHARDLINK* = 0x00020000 + FOFX_SHOWELEVATIONPROMPT* = 0x00040000 + FOFX_RECYCLEONDELETE* = 0x00080000 + FOFX_EARLYFAILURE* = 0x00100000 + FOFX_PRESERVEFILEEXTENSIONS* = 0x00200000 + FOFX_KEEPNEWERFILE* = 0x00400000 + FOFX_NOCOPYHOOKS* = 0x00800000 + FOFX_NOMINIMIZEBOX* = 0x01000000 + FOFX_MOVEACLSACROSSVOLUMES* = 0x02000000 + FOFX_DONTDISPLAYSOURCEPATH* = 0x04000000 + FOFX_DONTDISPLAYDESTPATH* = 0x08000000 + FOFX_REQUIREELEVATION* = 0x10000000 + FOFX_ADDUNDORECORD* = 0x20000000 + FOFX_COPYASDOWNLOAD* = 0x40000000 + FOFX_DONTDISPLAYLOCATIONS* = 0x80000000'i32 + IID_IFileOperation* = DEFINE_GUID("947aab5f-0a5c-4c13-b4d6-4bf7836fc9f8") + IID_IObjectProvider* = DEFINE_GUID("a6087428-3be3-4d73-b308-7c04a540bf1a") + IID_INamespaceWalkCB* = DEFINE_GUID("d92995f8-cf5e-4a76-bf59-ead39ea2b97e") + IID_INamespaceWalkCB2* = DEFINE_GUID("7ac7492b-c38e-438a-87db-68737844ff70") + NSWF_DEFAULT* = 0x0 + NSWF_NONE_IMPLIES_ALL* = 0x1 + NSWF_ONE_IMPLIES_ALL* = 0x2 + NSWF_DONT_TRAVERSE_LINKS* = 0x4 + NSWF_DONT_ACCUMULATE_RESULT* = 0x8 + NSWF_TRAVERSE_STREAM_JUNCTIONS* = 0x10 + NSWF_FILESYSTEM_ONLY* = 0x20 + NSWF_SHOW_PROGRESS* = 0x40 + NSWF_FLAG_VIEWORDER* = 0x80 + NSWF_IGNORE_AUTOPLAY_HIDA* = 0x100 + NSWF_ASYNC* = 0x200 + NSWF_DONT_RESOLVE_LINKS* = 0x400 + NSWF_ACCUMULATE_FOLDERS* = 0x800 + NSWF_DONT_SORT* = 0x1000 + NSWF_USE_TRANSFER_MEDIUM* = 0x2000 + NSWF_DONT_TRAVERSE_STREAM_JUNCTIONS* = 0x4000 + NSWF_ANY_IMPLIES_ALL* = 0x8000 + NSWF_ENUMERATE_BEST_EFFORT* = 0x00010000 + NSWF_TRAVERSE_ONLY_STORAGE* = 0x00020000 + IID_INamespaceWalk* = DEFINE_GUID("57ced8a7-3f4a-432c-9350-30f24483f74f") + ACDD_VISIBLE* = 0x1 + IID_IAutoCompleteDropDown* = DEFINE_GUID("3cd141f4-3c6a-11d2-bcaa-00c04fd929db") + BSID_BANDADDED* = 0 + BSID_BANDREMOVED* = 1 + BSIM_STATE* = 0x00000001 + BSIM_STYLE* = 0x00000002 + BSSF_VISIBLE* = 0x00000001 + BSSF_NOTITLE* = 0x00000002 + BSSF_UNDELETEABLE* = 0x00001000 + BSIS_AUTOGRIPPER* = 0x00000000 + BSIS_NOGRIPPER* = 0x00000001 + BSIS_ALWAYSGRIPPER* = 0x00000002 + BSIS_LEFTALIGN* = 0x00000004 + BSIS_SINGLECLICK* = 0x00000008 + BSIS_NOCONTEXTMENU* = 0x00000010 + BSIS_NODROPTARGET* = 0x00000020 + BSIS_NOCAPTION* = 0x00000040 + BSIS_PREFERNOLINEBREAK* = 0x00000080 + BSIS_LOCKED* = 0x00000100 + BSIS_PRESERVEORDERDURINGLAYOUT* = 0x00000200 + BSIS_FIXEDORDER* = 0x00000400 + IID_IBandSite* = DEFINE_GUID("4cf504b0-de96-11d0-8b3f-00a0c911e8e5") + SID_SBandSite* = IID_IBandSite + CGID_BandSite* = IID_IBandSite + IID_IModalWindow* = DEFINE_GUID("b4db1657-70d7-485e-8e3e-6fcb5a5c1802") + PROPSTR_EXTENSIONCOMPLETIONSTATE* = "ExtensionCompletionState" + CDBE_RET_DEFAULT* = 0x0 + CDBE_RET_DONTRUNOTHEREXTS* = 0x1 + CDBE_RET_STOPWIZARD* = 0x2 + IID_ICDBurnExt* = DEFINE_GUID("2271dcca-74fc-4414-8fb7-c56b05ace2d7") + SID_CDWizardHost* = IID_ICDBurnExt + CDBE_TYPE_MUSIC* = 0x1 + CDBE_TYPE_DATA* = 0x2 + CDBE_TYPE_ALL* = int32 0xffffffff'i32 + IID_IContextMenuSite* = DEFINE_GUID("0811aebe-0b87-4c54-9e72-548cf649016b") + IID_IEnumReadyCallback* = DEFINE_GUID("61e00d45-8fff-4e60-924e-6537b61612dd") + IID_IEnumerableView* = DEFINE_GUID("8c8bf236-1aec-495f-9894-91d57c3c686f") + SID_EnumerableView* = IID_IEnumerableView + IID_IInsertItem* = DEFINE_GUID("d2b57227-3d23-4b95-93c0-492bd454c356") + MBHANDCID_PIDLSELECT* = 0 + IID_IMenuBand* = DEFINE_GUID("568804cd-cbd7-11d0-9816-00c04fd91972") + IID_IFolderBandPriv* = DEFINE_GUID("47c01f95-e185-412c-b5c5-4f27df965aea") + IID_IRegTreeItem* = DEFINE_GUID("a9521922-0812-4d44-9ec3-7fd38c726f3d") + IID_IImageRecompress* = DEFINE_GUID("505f1513-6b3e-4892-a272-59f8889a4d3e") + IID_IDeskBar* = DEFINE_GUID("eb0fe173-1a3a-11d0-89b3-00a0c90a90ac") + MPOS_EXECUTE* = 0 + MPOS_FULLCANCEL* = 1 + MPOS_CANCELLEVEL* = 2 + MPOS_SELECTLEFT* = 3 + MPOS_SELECTRIGHT* = 4 + MPOS_CHILDTRACKING* = 5 + MPPF_SETFOCUS* = 0x1 + MPPF_INITIALSELECT* = 0x2 + MPPF_NOANIMATE* = 0x4 + MPPF_KEYBOARD* = 0x10 + MPPF_REPOSITION* = 0x20 + MPPF_FORCEZORDER* = 0x40 + MPPF_FINALSELECT* = 0x80 + MPPF_TOP* = 0x20000000 + MPPF_LEFT* = 0x40000000 + MPPF_RIGHT* = 0x60000000 + MPPF_BOTTOM* = int32 0x80000000'i32 + MPPF_POS_MASK* = int32 0xe0000000'i32 + MPPF_ALIGN_LEFT* = 0x2000000 + MPPF_ALIGN_RIGHT* = 0x4000000 + IID_IMenuPopup* = DEFINE_GUID("d1e7afeb-6a2e-11d0-8c78-00c04fd918b4") + FUT_PLAYING* = 0 + FUT_EDITING* = 1 + FUT_GENERIC* = 2 + OF_CAP_CANSWITCHTO* = 0x0001 + OF_CAP_CANCLOSE* = 0x0002 + IID_IFileIsInUse* = DEFINE_GUID("64a1cbf0-3a1a-4461-9158-376969693950") + FDEOR_DEFAULT* = 0 + FDEOR_ACCEPT* = 1 + FDEOR_REFUSE* = 2 + FDESVR_DEFAULT* = 0 + FDESVR_ACCEPT* = 1 + FDESVR_REFUSE* = 2 + FDAP_BOTTOM* = 0 + FDAP_TOP* = 1 + IID_IFileDialogEvents* = DEFINE_GUID("973510db-7d7f-452b-8975-74a85828d354") + FOS_OVERWRITEPROMPT* = 0x2 + FOS_STRICTFILETYPES* = 0x4 + FOS_NOCHANGEDIR* = 0x8 + FOS_PICKFOLDERS* = 0x20 + FOS_FORCEFILESYSTEM* = 0x40 + FOS_ALLNONSTORAGEITEMS* = 0x80 + FOS_NOVALIDATE* = 0x100 + FOS_ALLOWMULTISELECT* = 0x200 + FOS_PATHMUSTEXIST* = 0x800 + FOS_FILEMUSTEXIST* = 0x1000 + FOS_CREATEPROMPT* = 0x2000 + FOS_SHAREAWARE* = 0x4000 + FOS_NOREADONLYRETURN* = 0x8000 + FOS_NOTESTFILECREATE* = 0x10000 + FOS_HIDEMRUPLACES* = 0x20000 + FOS_HIDEPINNEDPLACES* = 0x40000 + FOS_NODEREFERENCELINKS* = 0x100000 + FOS_DONTADDTORECENT* = 0x2000000 + FOS_FORCESHOWHIDDEN* = 0x10000000 + FOS_DEFAULTNOMINIMODE* = 0x20000000 + FOS_FORCEPREVIEWPANEON* = 0x40000000 + IID_IFileDialog* = DEFINE_GUID("42f85136-db7e-439c-85f1-e4075d135fc8") + IID_IFileSaveDialog* = DEFINE_GUID("84bccd23-5fde-4cdb-aea4-af64b83d78ab") + IID_IFileOpenDialog* = DEFINE_GUID("d57c7288-d4ad-4768-be02-9d969532d960") + CDCS_INACTIVE* = 0x0 + CDCS_ENABLED* = 0x1 + CDCS_VISIBLE* = 0x2 + CDCS_ENABLEDVISIBLE* = 0x3 + IID_IFileDialogCustomize* = DEFINE_GUID("e6fdd21a-163f-4975-9c8c-a69f1ba37034") + IID_IFileDialogControlEvents* = DEFINE_GUID("36116642-d713-4b97-9b83-7484a9d00433") + IID_IFileDialog2* = DEFINE_GUID("61744fc7-85b5-4791-a9b0-272276309b13") + AL_MACHINE* = 0 + AL_EFFECTIVE* = 1 + AL_USER* = 2 + AT_FILEEXTENSION* = 0 + AT_URLPROTOCOL* = 1 + AT_STARTMENUCLIENT* = 2 + AT_MIMETYPE* = 3 + IID_IApplicationAssociationRegistration* = DEFINE_GUID("4e530b0a-e611-4c77-a3ac-9031d022281b") + IID_IApplicationAssociationRegistrationUI* = DEFINE_GUID("1f76a169-f994-40ac-8fc8-0959e8874710") + IID_IDelegateFolder* = DEFINE_GUID("add8ba80-002b-11d0-8f0f-00c04fd7d062") + BFO_NONE* = 0x0 + BFO_BROWSER_PERSIST_SETTINGS* = 0x1 + BFO_RENAME_FOLDER_OPTIONS_TOINTERNET* = 0x2 + BFO_BOTH_OPTIONS* = 0x4 + BIF_PREFER_INTERNET_SHORTCUT* = 0x8 + BFO_BROWSE_NO_IN_NEW_PROCESS* = 0x10 + BFO_ENABLE_HYPERLINK_TRACKING* = 0x20 + BFO_USE_IE_OFFLINE_SUPPORT* = 0x40 + BFO_SUBSTITUE_INTERNET_START_PAGE* = 0x80 + BFO_USE_IE_LOGOBANDING* = 0x100 + BFO_ADD_IE_TOCAPTIONBAR* = 0x200 + BFO_USE_DIALUP_REF* = 0x400 + BFO_USE_IE_TOOLBAR* = 0x800 + BFO_NO_PARENT_FOLDER_SUPPORT* = 0x1000 + BFO_NO_REOPEN_NEXT_RESTART* = 0x2000 + BFO_GO_HOME_PAGE* = 0x4000 + BFO_PREFER_IEPROCESS* = 0x8000 + BFO_SHOW_NAVIGATION_CANCELLED* = 0x10000 + BFO_USE_IE_STATUSBAR* = 0x20000 + BFO_QUERY_ALL* = int32 0xffffffff'i32 + IID_IBrowserFrameOptions* = DEFINE_GUID("10df43c8-1dbe-11d3-8b34-006097df5bd4") + NWMF_UNLOADING* = 0x1 + NWMF_USERINITED* = 0x2 + NWMF_FIRST* = 0x4 + NWMF_OVERRIDEKEY* = 0x8 + NWMF_SHOWHELP* = 0x10 + NWMF_HTMLDIALOG* = 0x20 + NWMF_FROMDIALOGCHILD* = 0x40 + NWMF_USERREQUESTED* = 0x80 + NWMF_USERALLOWED* = 0x100 + NWMF_FORCEWINDOW* = 0x10000 + NWMF_FORCETAB* = 0x20000 + NWMF_SUGGESTWINDOW* = 0x40000 + NWMF_SUGGESTTAB* = 0x80000 + NWMF_INACTIVETAB* = 0x100000 + IID_INewWindowManager* = DEFINE_GUID("d2bc4c84-3f72-4a52-a604-7bcbf3982cbb") + SID_SNewWindowManager* = IID_INewWindowManager + ATTACHMENT_PROMPT_NONE* = 0x0 + ATTACHMENT_PROMPT_SAVE* = 0x1 + ATTACHMENT_PROMPT_EXEC* = 0x2 + ATTACHMENT_PROMPT_EXEC_OR_SAVE* = 0x3 + ATTACHMENT_ACTION_CANCEL* = 0x0 + ATTACHMENT_ACTION_SAVE* = 0x1 + ATTACHMENT_ACTION_EXEC* = 0x2 + IID_IAttachmentExecute* = DEFINE_GUID("73db1241-1e85-4581-8e4f-a81e1d0f8c57") + SMDM_SHELLFOLDER* = 0x00000001 + SMDM_HMENU* = 0x00000002 + SMDM_TOOLBAR* = 0x00000004 + SMIM_TYPE* = 0x1 + SMIM_FLAGS* = 0x2 + SMIM_ICON* = 0x4 + SMIT_SEPARATOR* = 0x1 + SMIT_STRING* = 0x2 + SMIF_ICON* = 0x1 + SMIF_ACCELERATOR* = 0x2 + SMIF_DROPTARGET* = 0x4 + SMIF_SUBMENU* = 0x8 + SMIF_CHECKED* = 0x20 + SMIF_DROPCASCADE* = 0x40 + SMIF_HIDDEN* = 0x80 + SMIF_DISABLED* = 0x100 + SMIF_TRACKPOPUP* = 0x200 + SMIF_DEMOTED* = 0x400 + SMIF_ALTSTATE* = 0x800 + SMIF_DRAGNDROP* = 0x1000 + SMIF_NEW* = 0x2000 + SMC_INITMENU* = 0x00000001 + SMC_CREATE* = 0x00000002 + SMC_EXITMENU* = 0x00000003 + SMC_GETINFO* = 0x00000005 + SMC_GETSFINFO* = 0x00000006 + SMC_GETOBJECT* = 0x00000007 + SMC_GETSFOBJECT* = 0x00000008 + SMC_SFEXEC* = 0x00000009 + SMC_SFSELECTITEM* = 0x0000000A + SMC_REFRESH* = 0x00000010 + SMC_DEMOTE* = 0x00000011 + SMC_PROMOTE* = 0x00000012 + SMC_DEFAULTICON* = 0x00000016 + SMC_NEWITEM* = 0x00000017 + SMC_CHEVRONEXPAND* = 0x00000019 + SMC_DISPLAYCHEVRONTIP* = 0x0000002A + SMC_SETSFOBJECT* = 0x0000002D + SMC_SHCHANGENOTIFY* = 0x0000002E + SMC_CHEVRONGETTIP* = 0x0000002F + SMC_SFDDRESTRICTED* = 0x00000030 + SMC_SFEXEC_MIDDLE* = 0x00000031 + SMC_GETAUTOEXPANDSTATE* = 0x00000041 + SMC_AUTOEXPANDCHANGE* = 0x00000042 + SMC_GETCONTEXTMENUMODIFIER* = 0x00000043 + SMC_GETBKCONTEXTMENU* = 0x00000044 + SMC_OPEN* = 0x00000045 + SMAE_EXPANDED* = 0x00000001 + SMAE_CONTRACTED* = 0x00000002 + SMAE_USER* = 0x00000004 + SMAE_VALID* = 0x00000007 + IID_IShellMenuCallback* = DEFINE_GUID("4ca300a1-9b8d-11d1-8b22-00c04fd918d0") + SMINIT_DEFAULT* = 0x00000000 + SMINIT_RESTRICT_DRAGDROP* = 0x00000002 + SMINIT_TOPLEVEL* = 0x00000004 + SMINIT_CACHED* = 0x00000010 + SMINIT_AUTOEXPAND* = 0x00000100 + SMINIT_AUTOTOOLTIP* = 0x00000200 + SMINIT_DROPONCONTAINER* = 0x00000400 + SMINIT_VERTICAL* = 0x10000000 + SMINIT_HORIZONTAL* = 0x20000000 + ANCESTORDEFAULT* = UINT(-1) + SMSET_TOP* = 0x10000000 + SMSET_BOTTOM* = 0x20000000 + SMSET_DONTOWN* = 0x00000001 + SMINV_REFRESH* = 0x00000001 + SMINV_ID* = 0x00000008 + IID_IShellMenu* = DEFINE_GUID("ee1f7637-e138-11d1-8379-00c04fd918d0") + IID_IShellRunDll* = DEFINE_GUID("fce4bde0-4b68-4b80-8e9c-7426315a7388") + KF_CATEGORY_VIRTUAL* = 1 + KF_CATEGORY_FIXED* = 2 + KF_CATEGORY_COMMON* = 3 + KF_CATEGORY_PERUSER* = 4 + KFDF_LOCAL_REDIRECT_ONLY* = 0x2 + KFDF_ROAMABLE* = 0x4 + KFDF_PRECREATE* = 0x8 + KFDF_STREAM* = 0x10 + KFDF_PUBLISHEXPANDEDPATH* = 0x20 + KF_REDIRECT_USER_EXCLUSIVE* = 0x1 + KF_REDIRECT_COPY_SOURCE_DACL* = 0x2 + KF_REDIRECT_OWNER_USER* = 0x4 + KF_REDIRECT_SET_OWNER_EXPLICIT* = 0x8 + KF_REDIRECT_CHECK_ONLY* = 0x10 + KF_REDIRECT_WITH_UI* = 0x20 + KF_REDIRECT_UNPIN* = 0x40 + KF_REDIRECT_PIN* = 0x80 + KF_REDIRECT_COPY_CONTENTS* = 0x200 + KF_REDIRECT_DEL_SOURCE_CONTENTS* = 0x400 + KF_REDIRECT_EXCLUDE_ALL_KNOWN_SUBFOLDERS* = 0x800 + KF_REDIRECTION_CAPABILITIES_ALLOW_ALL* = 0xff + KF_REDIRECTION_CAPABILITIES_REDIRECTABLE* = 0x1 + KF_REDIRECTION_CAPABILITIES_DENY_ALL* = 0xfff00 + KF_REDIRECTION_CAPABILITIES_DENY_POLICY_REDIRECTED* = 0x100 + KF_REDIRECTION_CAPABILITIES_DENY_POLICY* = 0x200 + KF_REDIRECTION_CAPABILITIES_DENY_PERMISSIONS* = 0x400 + IID_IKnownFolder* = DEFINE_GUID("3aa7af7e-9b36-420c-a8e3-f77d4674a488") + FFFP_EXACTMATCH* = 0 + FFFP_NEARESTPARENTMATCH* = 1 + IID_IKnownFolderManager* = DEFINE_GUID("8be2d872-86aa-4d47-b776-32cca40c7018") + SHARE_ROLE_INVALID* = -1 + SHARE_ROLE_READER* = 0 + SHARE_ROLE_CONTRIBUTOR* = 1 + SHARE_ROLE_CO_OWNER* = 2 + SHARE_ROLE_OWNER* = 3 + SHARE_ROLE_CUSTOM* = 4 + SHARE_ROLE_MIXED* = 5 + DEFSHAREID_USERS* = 1 + DEFSHAREID_PUBLIC* = 2 + IID_ISharingConfigurationManager* = DEFINE_GUID("b4cd448a-9c86-4466-9201-2e62105b87ae") + IID_IPreviousVersionsInfo* = DEFINE_GUID("76e54780-ad74-48e3-a695-3ba9a0aff10d") + IID_IRelatedItem* = DEFINE_GUID("a73ce67a-8ab1-44f1-8d43-d2fcbf6b1cd0") + IID_IIdentityName* = DEFINE_GUID("7d903fca-d6f9-4810-8332-946c0177e247") + IID_IDelegateItem* = DEFINE_GUID("3c5a1c94-c951-4cb7-bb6d-3b93f30cce93") + IID_ICurrentItem* = DEFINE_GUID("240a7174-d653-4a1d-a6d3-d4943cfbfe3d") + IID_ITransferMediumItem* = DEFINE_GUID("77f295d5-2d6f-4e19-b8ae-322f3e721ab5") + IID_IUseToBrowseItem* = DEFINE_GUID("05edda5c-98a3-4717-8adb-c5e7da991eb1") + IID_IDisplayItem* = DEFINE_GUID("c6fd5997-9f6b-4888-8703-94e80e8cde3f") + IID_IViewStateIdentityItem* = DEFINE_GUID("9d264146-a94f-4195-9f9f-3bb12ce0c955") + IID_IPreviewItem* = DEFINE_GUID("36149969-0a8f-49c8-8b00-4aecb20222fb") + IID_IDestinationStreamFactory* = DEFINE_GUID("8a87781b-39a7-4a1f-aab3-a39b9c34a7d9") + NMCII_NONE* = 0x0 + NMCII_ITEMS* = 0x1 + NMCII_FOLDERS* = 0x2 + NMCSAEI_SELECT* = 0x0 + NMCSAEI_EDIT* = 0x1 + IID_INewMenuClient* = DEFINE_GUID("dcb07fdc-3bb5-451c-90be-966644fed7b0") + SID_SNewMenuClient* = IID_INewMenuClient + SID_SCommandBarState* = DEFINE_GUID("b99eaa5c-3850-4400-bc33-2ce534048bf8") + IID_IInitializeWithBindCtx* = DEFINE_GUID("71c0d2bc-726d-45cc-a6c0-2e31c1db2159") + IID_IShellItemFilter* = DEFINE_GUID("2659b475-eeb8-48b7-8f07-b378810f48cf") + NSTCS_HASEXPANDOS* = 0x1 + NSTCS_HASLINES* = 0x2 + NSTCS_SINGLECLICKEXPAND* = 0x4 + NSTCS_FULLROWSELECT* = 0x8 + NSTCS_SPRINGEXPAND* = 0x10 + NSTCS_HORIZONTALSCROLL* = 0x20 + NSTCS_ROOTHASEXPANDO* = 0x40 + NSTCS_SHOWSELECTIONALWAYS* = 0x80 + NSTCS_NOINFOTIP* = 0x200 + NSTCS_EVENHEIGHT* = 0x400 + NSTCS_NOREPLACEOPEN* = 0x800 + NSTCS_DISABLEDRAGDROP* = 0x1000 + NSTCS_NOORDERSTREAM* = 0x2000 + NSTCS_RICHTOOLTIP* = 0x4000 + NSTCS_BORDER* = 0x8000 + NSTCS_NOEDITLABELS* = 0x10000 + NSTCS_TABSTOP* = 0x20000 + NSTCS_FAVORITESMODE* = 0x80000 + NSTCS_AUTOHSCROLL* = 0x100000 + NSTCS_FADEINOUTEXPANDOS* = 0x200000 + NSTCS_EMPTYTEXT* = 0x400000 + NSTCS_CHECKBOXES* = 0x800000 + NSTCS_PARTIALCHECKBOXES* = 0x1000000 + NSTCS_EXCLUSIONCHECKBOXES* = 0x2000000 + NSTCS_DIMMEDCHECKBOXES* = 0x4000000 + NSTCS_NOINDENTCHECKS* = 0x8000000 + NSTCS_ALLOWJUNCTIONS* = 0x10000000 + NSTCS_SHOWTABSBUTTON* = 0x20000000 + NSTCS_SHOWDELETEBUTTON* = 0x40000000 + NSTCS_SHOWREFRESHBUTTON* = int32 0x80000000'i32 + NSTCRS_VISIBLE* = 0x0 + NSTCRS_HIDDEN* = 0x1 + NSTCRS_EXPANDED* = 0x2 + NSTCIS_NONE* = 0x0 + NSTCIS_SELECTED* = 0x1 + NSTCIS_EXPANDED* = 0x2 + NSTCIS_BOLD* = 0x4 + NSTCIS_DISABLED* = 0x8 + NSTCIS_SELECTEDNOEXPAND* = 0x10 + NSTCGNI_NEXT* = 0 + NSTCGNI_NEXTVISIBLE* = 1 + NSTCGNI_PREV* = 2 + NSTCGNI_PREVVISIBLE* = 3 + NSTCGNI_PARENT* = 4 + NSTCGNI_CHILD* = 5 + NSTCGNI_FIRSTVISIBLE* = 6 + NSTCGNI_LASTVISIBLE* = 7 + IID_INameSpaceTreeControl* = DEFINE_GUID("028212a3-b627-47e9-8856-c14265554e4f") + NSTCS2_DEFAULT* = 0x0 + NSTCS2_INTERRUPTNOTIFICATIONS* = 0x1 + NSTCS2_SHOWNULLSPACEMENU* = 0x2 + NSTCS2_DISPLAYPADDING* = 0x4 + NSTCS2_DISPLAYPINNEDONLY* = 0x8 + NTSCS2_NOSINGLETONAUTOEXPAND* = 0x10 + NTSCS2_NEVERINSERTNONENUMERATED* = 0x20 + IID_INameSpaceTreeControl2* = DEFINE_GUID("7cc7aed8-290e-49bc-8945-c1401cc9306c") + NSTCS2_ALLMASK* = NSTCS2_INTERRUPTNOTIFICATIONS or NSTCS2_SHOWNULLSPACEMENU or NSTCS2_DISPLAYPADDING + SID_SNavigationPane* = IID_INameSpaceTreeControl + NSTCEHT_NOWHERE* = 0x1 + NSTCEHT_ONITEMICON* = 0x2 + NSTCEHT_ONITEMLABEL* = 0x4 + NSTCEHT_ONITEMINDENT* = 0x8 + NSTCEHT_ONITEMBUTTON* = 0x10 + NSTCEHT_ONITEMRIGHT* = 0x20 + NSTCEHT_ONITEMSTATEICON* = 0x40 + NSTCEHT_ONITEM* = 0x46 + NSTCEHT_ONITEMTABBUTTON* = 0x1000 + NSTCECT_LBUTTON* = 0x1 + NSTCECT_MBUTTON* = 0x2 + NSTCECT_RBUTTON* = 0x3 + NSTCECT_BUTTON* = 0x3 + NSTCECT_DBLCLICK* = 0x4 + IID_INameSpaceTreeControlEvents* = DEFINE_GUID("93d77985-b3d8-4484-8318-672cdda002ce") + NSTCDHPOS_ONTOP* = -1 + IID_INameSpaceTreeControlDropHandler* = DEFINE_GUID("f9c665d6-c2f2-4c19-bf33-8322d7352f51") + IID_INameSpaceTreeAccessible* = DEFINE_GUID("71f312de-43ed-4190-8477-e9536b82350b") + IID_INameSpaceTreeControlCustomDraw* = DEFINE_GUID("2d3ba758-33ee-42d5-bb7b-5f3431d86c78") + NSTCFC_NONE* = 0x0 + NSTCFC_PINNEDITEMFILTERING* = 0x1 + NSTCFC_DELAY_REGISTER_NOTIFY* = 0x2 + IID_INameSpaceTreeControlFolderCapabilities* = DEFINE_GUID("e9701183-e6b3-4ff2-8568-813615fec7be") + E_PREVIEWHANDLER_DRM_FAIL* = HRESULT 0x86420001'i32 + E_PREVIEWHANDLER_NOAUTH* = HRESULT 0x86420002'i32 + E_PREVIEWHANDLER_NOTFOUND* = HRESULT 0x86420003'i32 + E_PREVIEWHANDLER_CORRUPT* = HRESULT 0x86420004'i32 + IID_IPreviewHandler* = DEFINE_GUID("8895b1c6-b41f-4c1c-a562-0d564250836f") + IID_IPreviewHandlerFrame* = DEFINE_GUID("fec87aaf-35f9-447a-adb7-20234491401a") + IID_ITrayDeskBand* = DEFINE_GUID("6d67e846-5b9c-4db8-9cbc-dde12f4254f1") + IID_IBandHost* = DEFINE_GUID("b9075c7c-d48e-403f-ab99-d6c77a1084ac") + SID_SBandHost* = IID_IBandHost + EPS_DONTCARE* = 0x0 + EPS_DEFAULT_ON* = 0x1 + EPS_DEFAULT_OFF* = 0x2 + EPS_STATEMASK* = 0xffff + EPS_INITIALSTATE* = 0x10000 + EPS_FORCE* = 0x20000 + IID_IExplorerPaneVisibility* = DEFINE_GUID("e07010ec-bc17-44c0-97b0-46c7c95b9edc") + SID_ExplorerPaneVisibility* = IID_IExplorerPaneVisibility + IID_IContextMenuCB* = DEFINE_GUID("3409e930-5a39-11d1-83fa-00a0c90dc849") + IID_IDefaultExtractIconInit* = DEFINE_GUID("41ded17d-d6b3-4261-997d-88c60e4b1d58") + ECS_ENABLED* = 0x0 + ECS_DISABLED* = 0x1 + ECS_HIDDEN* = 0x2 + ECS_CHECKBOX* = 0x4 + ECS_CHECKED* = 0x8 + ECS_RADIOCHECK* = 0x10 + ECF_DEFAULT* = 0x0 + ECF_HASSUBCOMMANDS* = 0x1 + ECF_HASSPLITBUTTON* = 0x2 + ECF_HIDELABEL* = 0x4 + ECF_ISSEPARATOR* = 0x8 + ECF_HASLUASHIELD* = 0x10 + ECF_SEPARATORBEFORE* = 0x20 + ECF_SEPARATORAFTER* = 0x40 + ECF_ISDROPDOWN* = 0x80 + ECF_TOGGLEABLE* = 0x100 + ECF_AUTOMENUICONS* = 0x200 + IID_IExplorerCommand* = DEFINE_GUID("a08ce4d0-fa25-44ab-b57c-c7b1c323e0b9") + IID_IExplorerCommandState* = DEFINE_GUID("bddacb60-7657-47ae-8445-d23e1acf82ae") + IID_IInitializeCommand* = DEFINE_GUID("85075acf-231f-40ea-9610-d26b7b58f638") + IID_IEnumExplorerCommand* = DEFINE_GUID("a88826f8-186f-4987-aade-ea0cef8fbfe8") + IID_IExplorerCommandProvider* = DEFINE_GUID("64961751-0835-43c0-8ffe-d57686530e64") + IID_IInitializeNetworkFolder* = DEFINE_GUID("6e0f9881-42a8-4f2a-97f8-8af4e026d92d") + CPVIEW_CLASSIC* = 0 + CPVIEW_ALLITEMS* = CPVIEW_CLASSIC + CPVIEW_CATEGORY* = 1 + CPVIEW_HOME* = CPVIEW_CATEGORY + IID_IOpenControlPanel* = DEFINE_GUID("d11ad862-66de-4df4-bf6c-1f5621996af1") + IID_IComputerInfoChangeNotify* = DEFINE_GUID("0df60d92-6818-46d6-b358-d66170dde466") + STR_FILE_SYS_BIND_DATA* = "File System Bind Data" + IID_IFileSystemBindData* = DEFINE_GUID("01e18d10-4d8b-11d2-855d-006008059367") + IID_IFileSystemBindData2* = DEFINE_GUID("3acf075f-71db-4afa-81f0-3fc4fdf2a5b8") + KDC_FREQUENT* = 1 + KDC_RECENT* = 2 + IID_ICustomDestinationList* = DEFINE_GUID("6332debf-87b5-4670-90c0-5e57b408a49e") + IID_IApplicationDestinations* = DEFINE_GUID("12337d35-94c6-48a0-bce7-6a9c69d4d600") + ADLT_RECENT* = 0 + ADLT_FREQUENT* = 1 + IID_IApplicationDocumentLists* = DEFINE_GUID("3c594f9f-9f30-47a1-979a-c9e83d3d0a06") + IID_IObjectWithAppUserModelID* = DEFINE_GUID("36db0196-9665-46d1-9ba7-d3709eecf9ed") + IID_IObjectWithProgID* = DEFINE_GUID("71e806fb-8dee-46fc-bf8c-7748a8a1ae13") + IID_IUpdateIDList* = DEFINE_GUID("6589b6d2-5f8d-4b9e-b7e0-23cdd9717d8c") + IID_IDesktopGadget* = DEFINE_GUID("c1646bc4-f298-4f91-a204-eb2dd1709d1a") + DSO_SHUFFLEIMAGES* = 0x1 + DSS_ENABLED* = 0x1 + DSS_SLIDESHOW* = 0x2 + DSS_DISABLED_BY_REMOTE_SESSION* = 0x4 + DSD_FORWARD* = 0 + DSD_BACKWARD* = 1 + DWPOS_CENTER* = 0 + DWPOS_TILE* = 1 + DWPOS_STRETCH* = 2 + DWPOS_FIT* = 3 + DWPOS_FILL* = 4 + DWPOS_SPAN* = 5 + IID_IDesktopWallpaper* = DEFINE_GUID("b92b56a9-8b55-4e14-9a89-0199bbb6f93b") + HOMEGROUP_SECURITY_GROUP_MULTI* = "HUG" + HOMEGROUP_SECURITY_GROUP* = "HomeUsers" + HGSC_NONE* = 0x0 + HGSC_MUSICLIBRARY* = 0x1 + HGSC_PICTURESLIBRARY* = 0x2 + HGSC_VIDEOSLIBRARY* = 0x4 + HGSC_DOCUMENTSLIBRARY* = 0x8 + HGSC_PRINTERS* = 0x10 + IID_IHomeGroup* = DEFINE_GUID("7a3bd1d9-35a9-4fb3-a467-f48cac35e2d0") + IID_IInitializeWithPropertyStore* = DEFINE_GUID("c3e12eb5-7d8d-44f8-b6dd-0e77b34d6de4") + IID_IOpenSearchSource* = DEFINE_GUID("f0ee7333-e6fc-479b-9f25-a860c234a38e") + LFF_FORCEFILESYSTEM* = 1 + LFF_STORAGEITEMS* = 2 + LFF_ALLITEMS* = 3 + LOF_DEFAULT* = 0x0 + LOF_PINNEDTONAVPANE* = 0x1 + LOF_MASK_ALL* = 0x1 + DSFT_DETECT* = 1 + DSFT_PRIVATE* = 2 + DSFT_PUBLIC* = 3 + LSF_FAILIFTHERE* = 0x0 + LSF_OVERRIDEEXISTING* = 0x1 + LSF_MAKEUNIQUENAME* = 0x2 + IID_IShellLibrary* = DEFINE_GUID("11a66efa-382e-451a-9234-1e0e12ef3085") + PE_DUCKSESSION* = 1 + PE_UNDUCKSESSION* = 2 + IID_IPlaybackManagerEvents* = DEFINE_GUID("385cfb7d-4e0c-4106-912e-8cfb4c191f45") + ST_COMMUNICATION* = 1 + ST_MEDIA* = 2 + PS_PLAYING* = 1 + PS_PAUSED* = 2 + PS_STOPPED* = 3 + MS_MUTED* = 1 + MS_UNMUTED* = 2 + IID_IPlaybackManager* = DEFINE_GUID("0f3c1b01-8199-4173-ba78-985882266f7a") + DFMR_DEFAULT* = 0x0 + DFMR_NO_STATIC_VERBS* = 0x8 + DFMR_STATIC_VERBS_ONLY* = 0x10 + DFMR_NO_RESOURCE_VERBS* = 0x20 + DFMR_OPTIN_HANDLERS_ONLY* = 0x40 + DFMR_RESOURCE_AND_FOLDER_VERBS_ONLY* = 0x80 + DFMR_USE_SPECIFIED_HANDLERS* = 0x100 + DFMR_USE_SPECIFIED_VERBS* = 0x200 + DFMR_NO_ASYNC_VERBS* = 0x400 + IID_IDefaultFolderMenuInitialize* = DEFINE_GUID("7690aa79-f8fc-4615-a327-36f7d18f5d91") + AO_NONE* = 0x0 + AO_DESIGNMODE* = 0x1 + AO_NOERRORUI* = 0x2 + AO_NOSPLASHSCREEN* = 0x4 + IID_IApplicationActivationManager* = DEFINE_GUID("2e941141-7f97-4756-ba1d-9decde894a3d") + LIBID_ShellObjects* = DEFINE_GUID("50a7e9b1-70ef-11d1-b75a-00a0c90564fe") + CLSID_DesktopWallpaper* = DEFINE_GUID("c2cf3110-460e-4fc1-b9d0-8a1c0c9cc4bd") + CLSID_ShellFSFolder* = DEFINE_GUID("f3364ba0-65b9-11ce-a9ba-00aa004ae837") + CLSID_NetworkPlaces* = DEFINE_GUID("208d2c60-3aea-1069-a2d7-08002b30309d") + CLSID_ShellLink* = DEFINE_GUID("00021401-0000-0000-c000-000000000046") + CLSID_QueryCancelAutoPlay* = DEFINE_GUID("331f1768-05a9-4ddd-b86e-dae34ddc998a") + CLSID_DriveSizeCategorizer* = DEFINE_GUID("94357b53-ca29-4b78-83ae-e8fe7409134f") + CLSID_DriveTypeCategorizer* = DEFINE_GUID("b0a8f3cf-4333-4bab-8873-1ccb1cada48b") + CLSID_FreeSpaceCategorizer* = DEFINE_GUID("b5607793-24ac-44c7-82e2-831726aa6cb7") + CLSID_TimeCategorizer* = DEFINE_GUID("3bb4118f-ddfd-4d30-a348-9fb5d6bf1afe") + CLSID_SizeCategorizer* = DEFINE_GUID("55d7b852-f6d1-42f2-aa75-8728a1b2d264") + CLSID_AlphabeticalCategorizer* = DEFINE_GUID("3c2654c6-7372-4f6b-b310-55d6128f49d2") + CLSID_MergedCategorizer* = DEFINE_GUID("8e827c11-33e7-4bc1-b242-8cd9a1c2b304") + CLSID_ImageProperties* = DEFINE_GUID("7ab770c7-0e23-4d7a-8aa2-19bfad479829") + CLSID_PropertiesUI* = DEFINE_GUID("d912f8cf-0396-4915-884e-fb425d32943b") + CLSID_UserNotification* = DEFINE_GUID("0010890e-8789-413c-adbc-48f5b511b3af") + CLSID_CDBurn* = DEFINE_GUID("fbeb8a05-beee-4442-804e-409d6c4515e9") + CLSID_TaskbarList* = DEFINE_GUID("56fdf344-fd6d-11d0-958a-006097c9a090") + CLSID_StartMenuPin* = DEFINE_GUID("a2a9545d-a0c2-42b4-9708-a0b2badd77c8") + CLSID_WebWizardHost* = DEFINE_GUID("c827f149-55c1-4d28-935e-57e47caed973") + CLSID_PublishDropTarget* = DEFINE_GUID("cc6eeffb-43f6-46c5-9619-51d571967f7d") + CLSID_PublishingWizard* = DEFINE_GUID("6b33163c-76a5-4b6c-bf21-45de9cd503a1") + SID_PublishingWizard* = CLSID_PublishingWizard + CLSID_InternetPrintOrdering* = DEFINE_GUID("add36aa8-751a-4579-a266-d66f5202ccbb") + CLSID_FolderViewHost* = DEFINE_GUID("20b1cb23-6968-4eb9-b7d4-a66d00d07cee") + CLSID_ExplorerBrowser* = DEFINE_GUID("71f96385-ddd6-48d3-a0c1-ae06e8b055fb") + CLSID_ImageRecompress* = DEFINE_GUID("6e33091c-d2f8-4740-b55e-2e11d1477a2c") + CLSID_TrayBandSiteService* = DEFINE_GUID("f60ad0a0-e5e1-45cb-b51a-e15b9f8b2934") + CLSID_TrayDeskBand* = DEFINE_GUID("e6442437-6c68-4f52-94dd-2cfed267efb9") + CLSID_AttachmentServices* = DEFINE_GUID("4125dd96-e03a-4103-8f70-e0597d803b9c") + CLSID_DocPropShellExtension* = DEFINE_GUID("883373c3-bf89-11d1-be35-080036b11a03") + CLSID_ShellItem* = DEFINE_GUID("9ac9fbe1-e0a2-4ad6-b4ee-e212013ea917") + CLSID_NamespaceWalker* = DEFINE_GUID("72eb61e0-8672-4303-9175-f2e4c68b2e7c") + CLSID_FileOperation* = DEFINE_GUID("3ad05575-8857-4850-9277-11b85bdb8e09") + CLSID_FileOpenDialog* = DEFINE_GUID("dc1c5a9c-e88a-4dde-a5a1-60f82a20aef7") + CLSID_FileSaveDialog* = DEFINE_GUID("c0b4e2f3-ba21-4773-8dba-335ec946eb8b") + CLSID_KnownFolderManager* = DEFINE_GUID("4df0c730-df9d-4ae3-9153-aa6b82e9795a") + CLSID_FSCopyHandler* = DEFINE_GUID("d197380a-0a79-4dc8-a033-ed882c2fa14b") + CLSID_SharingConfigurationManager* = DEFINE_GUID("49f371e1-8c5c-4d9c-9a3b-54a6827f513c") + CLSID_PreviousVersions* = DEFINE_GUID("596ab062-b4d2-4215-9f74-e9109b0a8153") + CLSID_NetworkConnections* = DEFINE_GUID("7007acc7-3202-11d1-aad2-00805fc1270e") + CLSID_NamespaceTreeControl* = DEFINE_GUID("ae054212-3535-4430-83ed-d501aa6680e6") + CLSID_IENamespaceTreeControl* = DEFINE_GUID("ace52d03-e5cd-4b20-82ff-e71b11beae1d") + CLSID_ScheduledTasks* = DEFINE_GUID("d6277990-4c6a-11cf-8d87-00aa0060f5bf") + CLSID_ApplicationAssociationRegistration* = DEFINE_GUID("591209c7-767b-42b2-9fba-44ee4615f2c7") + CLSID_ApplicationAssociationRegistrationUI* = DEFINE_GUID("1968106d-f3b5-44cf-890e-116fcb9ecef1") + CLSID_SearchFolderItemFactory* = DEFINE_GUID("14010e02-bbbd-41f0-88e3-eda371216584") + CLSID_OpenControlPanel* = DEFINE_GUID("06622d85-6856-4460-8de1-a81921b41c4b") + CLSID_MailRecipient* = DEFINE_GUID("9e56be60-c50f-11cf-9a2c-00a0c90a90ce") + CLSID_NetworkExplorerFolder* = DEFINE_GUID("f02c1a0d-be21-4350-88b0-7367fc96ef3c") + CLSID_DestinationList* = DEFINE_GUID("77f10cf0-3db5-4966-b520-b7c54fd35ed6") + CLSID_ApplicationDestinations* = DEFINE_GUID("86c14003-4d6b-4ef3-a7b4-0506663b2e68") + CLSID_ApplicationDocumentLists* = DEFINE_GUID("86bec222-30f2-47e0-9f25-60d11cd75c28") + CLSID_HomeGroup* = DEFINE_GUID("de77ba04-3c92-4d11-a1a5-42352a53e0e3") + CLSID_ShellLibrary* = DEFINE_GUID("d9b3211d-e57f-4426-aaef-30a806add397") + CLSID_AppStartupLink* = DEFINE_GUID("273eb5e7-88b0-4843-bfef-e2c81d43aae5") + CLSID_EnumerableObjectCollection* = DEFINE_GUID("2d3468c1-36a7-43b6-ac24-d3f02fd9607a") + CLSID_DesktopGadget* = DEFINE_GUID("924ccc1b-6562-4c85-8657-d177925222b6") + CLSID_PlaybackManager* = DEFINE_GUID("29dfa654-a97f-47f0-bf26-9e41fb9488d9") + CLSID_AccessibilityDockingService* = DEFINE_GUID("29ce1d46-b481-4aa0-a08a-d3ebc8aca402") + CLSID_FrameworkInputPane* = DEFINE_GUID("d5120aa3-46ba-44c5-822d-ca8092c1fc72") + CLSID_DefFolderMenu* = DEFINE_GUID("c63382be-7933-48d0-9ac8-85fb46be2fdd") + CLSID_AppVisibility* = DEFINE_GUID("7e5fe3d9-985f-4908-91f9-ee19f9fd1514") + CLSID_AppShellVerbHandler* = DEFINE_GUID("4ed3a719-cea8-4bd9-910d-e252f997afc2") + CLSID_ExecuteUnknown* = DEFINE_GUID("e44e9428-bdbc-4987-a099-40dc8fd255e7") + CLSID_PackageDebugSettings* = DEFINE_GUID("b1aec16f-2383-4852-b0e9-8f0b1dc66b4d") + CLSID_ApplicationActivationManager* = DEFINE_GUID("45ba127d-10a8-46ea-8ab7-56ea9078943c") + CLSID_ApplicationDesignModeSettings* = DEFINE_GUID("958a6fb5-dcb2-4faf-aafd-7fb054ad1a3b") + CLSID_ExecuteFolder* = DEFINE_GUID("11dbb47c-a525-400b-9e80-a54615a090c0") + LMD_DEFAULT* = 0x0 + LMD_ALLOWUNINDEXABLENETWORKLOCATIONS* = 0x1 + IID_IAssocHandlerInvoker* = DEFINE_GUID("92218cab-ecaa-4335-8133-807fd234c2ee") + IID_IAssocHandler* = DEFINE_GUID("f04061ac-1659-4a3f-a954-775aa57fc083") + IID_IEnumAssocHandlers* = DEFINE_GUID("973810ae-9599-4b88-9e4d-6ee98c9552da") + ASSOC_FILTER_NONE* = 0x0 + ASSOC_FILTER_RECOMMENDED* = 0x1 + IID_IDataObjectProvider* = DEFINE_GUID("3d25f6d6-4b2a-433c-9184-7c33ad35d001") + IID_IDataTransferManagerInterop* = DEFINE_GUID("3a3dcd6c-3eab-43dc-bcde-45671ce800c8") + IID_IFrameworkInputPaneHandler* = DEFINE_GUID("226c537b-1e76-4d9e-a760-33db29922f18") + IID_IFrameworkInputPane* = DEFINE_GUID("5752238b-24f0-495a-82f1-2fd593056796") + PROP_CONTRACT_DELEGATE* = "ContractDelegate" + IID_ISearchableApplication* = DEFINE_GUID("08922f8d-243a-49e3-a495-bd4f9cf8ab9e") + UR_RESOLUTION_CHANGE* = 0 + UR_MONITOR_DISCONNECT* = 1 + IID_IAccessibilityDockingServiceCallback* = DEFINE_GUID("157733fd-a592-42e5-b594-248468c5a81b") + IID_IAccessibilityDockingService* = DEFINE_GUID("8849dc22-cedf-4c95-998d-051419dd3f76") + MAV_UNKNOWN* = 0 + MAV_NO_APP_VISIBLE* = 1 + MAV_APP_VISIBLE* = 2 + IID_IAppVisibilityEvents* = DEFINE_GUID("6584ce6b-7d82-49c2-89c9-c6bc02ba8c38") + IID_IAppVisibility* = DEFINE_GUID("2246ea2d-caea-4444-a3c4-6de827e44313") + PES_UNKNOWN* = 0 + PES_RUNNING* = 1 + PES_SUSPENDING* = 2 + PES_SUSPENDED* = 3 + PES_TERMINATED* = 4 + IID_IPackageExecutionStateChangeNotification* = DEFINE_GUID("1bb12a62-2ad8-432b-8ccf-0c2c52afcd5b") + IID_IPackageDebugSettings* = DEFINE_GUID("f27c3930-8029-4ad1-94e3-3dba417810c1") + AHE_DESKTOP* = 0 + AHE_IMMERSIVE* = 1 + IID_IExecuteCommandApplicationHostEnvironment* = DEFINE_GUID("18b21aa9-e184-4ff0-9f5e-f882d03771b3") + ECHUIM_DESKTOP* = 0 + ECHUIM_IMMERSIVE* = 1 + ECHUIM_SYSTEM_LAUNCHER* = 2 + IID_IExecuteCommandHost* = DEFINE_GUID("4b6832a2-5f04-4c9d-b89d-727a15d103e7") + SID_ExecuteCommandHost* = IID_IExecuteCommandHost + AVS_FULLSCREEN_LANDSCAPE* = 0 + AVS_FILLED* = 1 + AVS_SNAPPED* = 2 + AVS_FULLSCREEN_PORTRAIT* = 3 + EGK_TOUCH* = 0 + EGK_KEYBOARD* = 1 + EGK_MOUSE* = 2 + IID_IApplicationDesignModeSettings* = DEFINE_GUID("2a3dee9a-e31d-46d6-8508-bcc597db3557") + IID_IInitializeWithWindow* = DEFINE_GUID("3e68d4bd-7135-4d10-8018-9fb6d9f33fa1") + IID_IHandlerInfo* = DEFINE_GUID("997706ef-f880-453b-8118-39e1a2d2655a") + IID_IHandlerActivationHost* = DEFINE_GUID("35094a87-8bb1-4237-96c6-c417eebdb078") + SID_SHandlerActivationHost* = IID_IHandlerActivationHost + SID_ShellExecuteNamedPropertyStore* = DEFINE_GUID("eb84ada2-00ff-4992-8324-ed5ce061cb29") + GIL_OPENICON* = 0x1 + GIL_FORSHELL* = 0x2 + GIL_ASYNC* = 0x20 + GIL_DEFAULTICON* = 0x40 + GIL_FORSHORTCUT* = 0x80 + GIL_CHECKSHIELD* = 0x200 + GIL_SIMULATEDOC* = 0x1 + GIL_PERINSTANCE* = 0x2 + GIL_PERCLASS* = 0x4 + GIL_NOTFILENAME* = 0x8 + GIL_DONTCACHE* = 0x10 + GIL_SHIELD* = 0x200 + GIL_FORCENOSHIELD* = 0x400 + ISIOI_ICONFILE* = 0x1 + ISIOI_ICONINDEX* = 0x2 + SIOM_OVERLAYINDEX* = 1 + SIOM_ICONINDEX* = 2 + SIOM_RESERVED_SHARED* = 0 + SIOM_RESERVED_LINK* = 1 + SIOM_RESERVED_SLOWFILE* = 2 + SIOM_RESERVED_DEFAULT* = 3 + OI_DEFAULT* = 0x0 + OI_ASYNC* = 0xffffeeee'i32 + IDO_SHGIOI_SHARE* = 0x0fffffff + IDO_SHGIOI_LINK* = 0x0ffffffe + IDO_SHGIOI_SLOWFILE* = 0x0fffffffd'i32 + IDO_SHGIOI_DEFAULT* = 0x0fffffffc'i32 + SLDF_DEFAULT* = 0x00000000 + SLDF_HAS_ID_LIST* = 0x00000001 + SLDF_HAS_LINK_INFO* = 0x00000002 + SLDF_HAS_NAME* = 0x00000004 + SLDF_HAS_RELPATH* = 0x00000008 + SLDF_HAS_WORKINGDIR* = 0x00000010 + SLDF_HAS_ARGS* = 0x00000020 + SLDF_HAS_ICONLOCATION* = 0x00000040 + SLDF_UNICODE* = 0x00000080 + SLDF_FORCE_NO_LINKINFO* = 0x00000100 + SLDF_HAS_EXP_SZ* = 0x00000200 + SLDF_RUN_IN_SEPARATE* = 0x00000400 + SLDF_HAS_LOGO3ID* = 0x00000800 + SLDF_HAS_DARWINID* = 0x00001000 + SLDF_RUNAS_USER* = 0x00002000 + SLDF_HAS_EXP_ICON_SZ* = 0x00004000 + SLDF_NO_PIDL_ALIAS* = 0x00008000 + SLDF_FORCE_UNCNAME* = 0x00010000 + SLDF_RUN_WITH_SHIMLAYER* = 0x00020000 + SLDF_FORCE_NO_LINKTRACK* = 0x00040000 + SLDF_ENABLE_TARGET_METADATA* = 0x00080000 + SLDF_DISABLE_LINK_PATH_TRACKING* = 0x00100000 + SLDF_DISABLE_KNOWNFOLDER_RELATIVE_TRACKING* = 0x00200000 + SLDF_NO_KF_ALIAS* = 0x00400000 + SLDF_ALLOW_LINK_TO_LINK* = 0x00800000 + SLDF_UNALIAS_ON_SAVE* = 0x01000000 + SLDF_PREFER_ENVIRONMENT_PATH* = 0x02000000 + SLDF_KEEP_LOCAL_IDLIST_FOR_UNC_TARGET* = 0x04000000 + SLDF_PERSIST_VOLUME_ID_RELATIVE* = 0x08000000 + SLDF_VALID* = 0x0ffff7ff + SLDF_RESERVED* = int32 0x80000000'i32 + NT_CONSOLE_PROPS_SIG* = 0xa0000002'i32 + NT_FE_CONSOLE_PROPS_SIG* = 0xa0000004'i32 + EXP_DARWIN_ID_SIG* = 0xa0000006'i32 + EXP_SPECIAL_FOLDER_SIG* = 0xa0000005'i32 + EXP_SZ_LINK_SIG* = 0xa0000001'i32 + EXP_SZ_ICON_SIG* = 0xa0000007'i32 + EXP_PROPERTYSTORAGE_SIG* = 0xa0000009'i32 + FVSIF_RECT* = 0x00000001 + FVSIF_PINNED* = 0x00000002 + FVSIF_NEWFAILED* = 0x08000000 + FVSIF_NEWFILE* = 0x80000000'i32 + FVSIF_CANVIEWIT* = 0x40000000 + FCIDM_SHVIEWFIRST* = 0x0000 + FCIDM_SHVIEWLAST* = 0x7fff + FCIDM_BROWSERFIRST* = 0xa000 + FCIDM_BROWSERLAST* = 0xbf00 + FCIDM_GLOBALFIRST* = 0x8000 + FCIDM_GLOBALLAST* = 0x9fff + FCIDM_MENU_FILE* = FCIDM_GLOBALFIRST+0x0000 + FCIDM_MENU_EDIT* = FCIDM_GLOBALFIRST+0x0040 + FCIDM_MENU_VIEW* = FCIDM_GLOBALFIRST+0x0080 + FCIDM_MENU_VIEW_SEP_OPTIONS* = FCIDM_GLOBALFIRST+0x0081 + FCIDM_MENU_TOOLS* = FCIDM_GLOBALFIRST+0x00c0 + FCIDM_MENU_TOOLS_SEP_GOTO* = FCIDM_GLOBALFIRST+0x00c1 + FCIDM_MENU_HELP* = FCIDM_GLOBALFIRST+0x0100 + FCIDM_MENU_FIND* = FCIDM_GLOBALFIRST+0x0140 + FCIDM_MENU_EXPLORE* = FCIDM_GLOBALFIRST+0x0150 + FCIDM_MENU_FAVORITES* = FCIDM_GLOBALFIRST+0x0170 + FCIDM_TOOLBAR* = FCIDM_BROWSERFIRST+0 + FCIDM_STATUS* = FCIDM_BROWSERFIRST+1 + IDC_OFFLINE_HAND* = 103 + IDC_PANTOOL_HAND_OPEN* = 104 + IDC_PANTOOL_HAND_CLOSED* = 105 + PANE_NONE* = DWORD(-1) + PANE_ZONE* = 1 + PANE_OFFLINE* = 2 + PANE_PRINTER* = 3 + PANE_SSL* = 4 + PANE_NAVIGATION* = 5 + PANE_PROGRESS* = 6 + PANE_PRIVACY* = 7 + GPFIDL_DEFAULT* = 0x0 + GPFIDL_ALTNAME* = 0x1 + GPFIDL_UNCPRINTER* = 0x2 + OFASI_EDIT* = 0x0001 + OFASI_OPENDESKTOP* = 0x0002 + REGSTR_PATH_SPECIAL_FOLDERS* = REGSTR_PATH_EXPLORER & "\\Shell Folders" + CSIDL_DESKTOP* = 0x0000 + CSIDL_INTERNET* = 0x0001 + CSIDL_PROGRAMS* = 0x0002 + CSIDL_CONTROLS* = 0x0003 + CSIDL_PRINTERS* = 0x0004 + CSIDL_FAVORITES* = 0x0006 + CSIDL_STARTUP* = 0x0007 + CSIDL_RECENT* = 0x0008 + CSIDL_SENDTO* = 0x0009 + CSIDL_BITBUCKET* = 0x000a + CSIDL_STARTMENU* = 0x000b + CSIDL_MYDOCUMENTS* = CSIDL_PERSONAL + CSIDL_DESKTOPDIRECTORY* = 0x0010 + CSIDL_DRIVES* = 0x0011 + CSIDL_NETWORK* = 0x0012 + CSIDL_NETHOOD* = 0x0013 + CSIDL_FONTS* = 0x0014 + CSIDL_TEMPLATES* = 0x0015 + CSIDL_COMMON_STARTMENU* = 0x0016 + CSIDL_COMMON_PROGRAMS* = 0x0017 + CSIDL_COMMON_STARTUP* = 0x0018 + CSIDL_COMMON_DESKTOPDIRECTORY* = 0x0019 + CSIDL_PRINTHOOD* = 0x001b + CSIDL_LOCAL_APPDATA* = 0x001c + CSIDL_ALTSTARTUP* = 0x001d + CSIDL_COMMON_ALTSTARTUP* = 0x001e + CSIDL_COMMON_FAVORITES* = 0x001f + CSIDL_INTERNET_CACHE* = 0x0020 + CSIDL_COOKIES* = 0x0021 + CSIDL_HISTORY* = 0x0022 + CSIDL_COMMON_APPDATA* = 0x0023 + CSIDL_WINDOWS* = 0x0024 + CSIDL_SYSTEM* = 0x0025 + CSIDL_PROGRAM_FILES* = 0x0026 + CSIDL_PROFILE* = 0x0028 + CSIDL_SYSTEMX86* = 0x0029 + CSIDL_PROGRAM_FILESX86* = 0x002a + CSIDL_PROGRAM_FILES_COMMON* = 0x002b + CSIDL_PROGRAM_FILES_COMMONX86* = 0x002c + CSIDL_COMMON_TEMPLATES* = 0x002d + CSIDL_COMMON_DOCUMENTS* = 0x002e + CSIDL_COMMON_ADMINTOOLS* = 0x002f + CSIDL_ADMINTOOLS* = 0x0030 + CSIDL_CONNECTIONS* = 0x0031 + CSIDL_COMMON_MUSIC* = 0x0035 + CSIDL_COMMON_PICTURES* = 0x0036 + CSIDL_COMMON_VIDEO* = 0x0037 + CSIDL_RESOURCES* = 0x0038 + CSIDL_RESOURCES_LOCALIZED* = 0x0039 + CSIDL_COMMON_OEM_LINKS* = 0x003a + CSIDL_CDBURN_AREA* = 0x003b + CSIDL_COMPUTERSNEARME* = 0x003d + CSIDL_FLAG_DONT_UNEXPAND* = 0x2000 + CSIDL_FLAG_NO_ALIAS* = 0x1000 + CSIDL_FLAG_PER_USER_INIT* = 0x0800 + CSIDL_FLAG_MASK* = 0xff00 + KF_FLAG_DEFAULT* = 0x00000000 + KF_FLAG_NO_APPCONTAINER_REDIRECTION* = 0x00010000 + KF_FLAG_CREATE* = 0x00008000 + KF_FLAG_DONT_VERIFY* = 0x00004000 + KF_FLAG_DONT_UNEXPAND* = 0x00002000 + KF_FLAG_NO_ALIAS* = 0x00001000 + KF_FLAG_INIT* = 0x00000800 + KF_FLAG_DEFAULT_PATH* = 0x00000400 + KF_FLAG_NOT_PARENT_RELATIVE* = 0x00000200 + KF_FLAG_SIMPLE_IDLIST* = 0x00000100 + KF_FLAG_ALIAS_ONLY* = 0x80000000'i32 + FCS_READ* = 0x00000001 + FCS_FORCEWRITE* = 0x00000002 + FCS_WRITE* = FCS_READ or FCS_FORCEWRITE + FCS_FLAG_DRAGDROP* = 2 + FCSM_VIEWID* = 0x00000001 + FCSM_WEBVIEWTEMPLATE* = 0x00000002 + FCSM_INFOTIP* = 0x00000004 + FCSM_CLSID* = 0x00000008 + FCSM_ICONFILE* = 0x00000010 + FCSM_LOGO* = 0x00000020 + FCSM_FLAGS* = 0x00000040 + BIF_RETURNONLYFSDIRS* = 0x00000001 + BIF_DONTGOBELOWDOMAIN* = 0x00000002 + BIF_STATUSTEXT* = 0x00000004 + BIF_RETURNFSANCESTORS* = 0x00000008 + BIF_EDITBOX* = 0x00000010 + BIF_VALIDATE* = 0x00000020 + BIF_NEWDIALOGSTYLE* = 0x00000040 + BIF_USENEWUI* = BIF_NEWDIALOGSTYLE or BIF_EDITBOX + BIF_BROWSEINCLUDEURLS* = 0x00000080 + BIF_UAHINT* = 0x00000100 + BIF_NONEWFOLDERBUTTON* = 0x00000200 + BIF_NOTRANSLATETARGETS* = 0x00000400 + BIF_BROWSEFORCOMPUTER* = 0x00001000 + BIF_BROWSEFORPRINTER* = 0x00002000 + BIF_BROWSEINCLUDEFILES* = 0x00004000 + BIF_SHAREABLE* = 0x00008000 + BIF_BROWSEFILEJUNCTIONS* = 0x00010000 + BFFM_INITIALIZED* = 1 + BFFM_SELCHANGED* = 2 + BFFM_VALIDATEFAILEDA* = 3 + BFFM_VALIDATEFAILEDW* = 4 + BFFM_IUNKNOWN* = 5 + BFFM_SETSTATUSTEXTA* = WM_USER+100 + BFFM_ENABLEOK* = WM_USER+101 + BFFM_SETSELECTIONA* = WM_USER+102 + BFFM_SETSELECTIONW* = WM_USER+103 + BFFM_SETSTATUSTEXTW* = WM_USER+104 + BFFM_SETOKTEXT* = WM_USER+105 + BFFM_SETEXPANDED* = WM_USER+106 + ISHCUTCMDID_DOWNLOADICON* = 0 + ISHCUTCMDID_INTSHORTCUTCREATE* = 1 + ISHCUTCMDID_COMMITHISTORY* = 2 + ISHCUTCMDID_SETUSERAWURL* = 3 + CMDID_INTSHORTCUTCREATE* = ISHCUTCMDID_INTSHORTCUTCREATE + STR_PARSE_WITH_PROPERTIES* = "ParseWithProperties" + STR_PARSE_PARTIAL_IDLIST* = "ParseOriginalItem" + ACLO_NONE* = 0 + ACLO_CURRENTDIR* = 1 + ACLO_MYCOMPUTER* = 2 + ACLO_DESKTOP* = 4 + ACLO_FAVORITES* = 8 + ACLO_FILESYSONLY* = 16 + ACLO_FILESYSDIRS* = 32 + ACLO_VIRTUALNAMESPACE* = 64 + PROGDLG_NORMAL* = 0x00000000 + PROGDLG_MODAL* = 0x00000001 + PROGDLG_AUTOTIME* = 0x00000002 + PROGDLG_NOTIME* = 0x00000004 + PROGDLG_NOMINIMIZE* = 0x00000008 + PROGDLG_NOPROGRESSBAR* = 0x00000010 + PROGDLG_MARQUEEPROGRESS* = 0x00000020 + PROGDLG_NOCANCEL* = 0x00000040 + PDTIMER_RESET* = 0x00000001 + PDTIMER_PAUSE* = 0x00000002 + PDTIMER_RESUME* = 0x00000003 + DWFRF_NORMAL* = 0x0000 + DWFRF_DELETECONFIGDATA* = 0x0001 + DWFAF_HIDDEN* = 0x1 + DWFAF_GROUP1* = 0x2 + DWFAF_GROUP2* = 0x4 + DWFAF_AUTOHIDE* = 0x10 + IID_IEnumShellImageStore* = DEFINE_GUID("6dfd582b-92e3-11d1-98a3-00c04fb687da") + SHIMSTCAPFLAG_LOCKABLE* = 0x0001 + SHIMSTCAPFLAG_PURGEABLE* = 0x0002 + ISFB_MASK_STATE* = 0x00000001 + ISFB_MASK_BKCOLOR* = 0x00000002 + ISFB_MASK_VIEWMODE* = 0x00000004 + ISFB_MASK_SHELLFOLDER* = 0x00000008 + ISFB_MASK_IDLIST* = 0x00000010 + ISFB_MASK_COLORS* = 0x00000020 + ISFB_STATE_DEFAULT* = 0x00000000 + ISFB_STATE_DEBOSSED* = 0x00000001 + ISFB_STATE_ALLOWRENAME* = 0x00000002 + ISFB_STATE_NOSHOWTEXT* = 0x00000004 + ISFB_STATE_CHANNELBAR* = 0x00000010 + ISFB_STATE_QLINKSMODE* = 0x00000020 + ISFB_STATE_FULLOPEN* = 0x00000040 + ISFB_STATE_NONAMESORT* = 0x00000080 + ISFB_STATE_BTNMINSIZE* = 0x00000100 + ISFBVIEWMODE_SMALLICONS* = 0x0001 + ISFBVIEWMODE_LARGEICONS* = 0x0002 + ISFBVIEWMODE_LOGOS* = 0x0003 + SFBID_PIDLCHANGED* = 0 + IID_IDeskBarClient* = DEFINE_GUID("eb0fe175-1a3a-11d0-89b3-00a0c90a90ac") + DBC_GS_IDEAL* = 0 + DBC_GS_SIZEDOWN* = 1 + DBC_HIDE* = 0 + DBC_SHOW* = 1 + DBC_SHOWOBSCURE* = 2 + DBCID_EMPTY* = 0 + DBCID_ONDRAG* = 1 + DBCID_CLSIDOFBAR* = 2 + DBCID_RESIZE* = 3 + DBCID_GETBAR* = 4 + COMPONENT_TOP* = 0x3fffffff + COMP_TYPE_HTMLDOC* = 0 + COMP_TYPE_PICTURE* = 1 + COMP_TYPE_WEBSITE* = 2 + COMP_TYPE_CONTROL* = 3 + COMP_TYPE_CFHTML* = 4 + COMP_TYPE_MAX* = 4 + IS_NORMAL* = 0x00000001 + IS_FULLSCREEN* = 0x00000002 + IS_SPLIT* = 0x00000004 + IS_VALIDSIZESTATEBITS* = IS_NORMAL or IS_SPLIT or IS_FULLSCREEN + IS_VALIDSTATEBITS* = IS_NORMAL or IS_SPLIT or IS_FULLSCREEN or 0x80000000'i32 or 0x40000000 + AD_APPLY_SAVE* = 0x00000001 + AD_APPLY_HTMLGEN* = 0x00000002 + AD_APPLY_REFRESH* = 0x00000004 + AD_APPLY_ALL* = AD_APPLY_SAVE or AD_APPLY_HTMLGEN or AD_APPLY_REFRESH + AD_APPLY_FORCE* = 0x00000008 + AD_APPLY_BUFFERED_REFRESH* = 0x00000010 + AD_APPLY_DYNAMICREFRESH* = 0x00000020 + AD_GETWP_BMP* = 0x00000000 + AD_GETWP_IMAGE* = 0x00000001 + AD_GETWP_LAST_APPLIED* = 0x00000002 + WPSTYLE_CENTER* = 0 + WPSTYLE_TILE* = 1 + WPSTYLE_STRETCH* = 2 + WPSTYLE_KEEPASPECT* = 3 + WPSTYLE_CROPTOFIT* = 4 + WPSTYLE_SPAN* = 5 + WPSTYLE_MAX* = 6 + COMP_ELEM_TYPE* = 0x00000001 + COMP_ELEM_CHECKED* = 0x00000002 + COMP_ELEM_DIRTY* = 0x00000004 + COMP_ELEM_NOSCROLL* = 0x00000008 + COMP_ELEM_POS_LEFT* = 0x00000010 + COMP_ELEM_POS_TOP* = 0x00000020 + COMP_ELEM_SIZE_WIDTH* = 0x00000040 + COMP_ELEM_SIZE_HEIGHT* = 0x00000080 + COMP_ELEM_POS_ZINDEX* = 0x00000100 + COMP_ELEM_SOURCE* = 0x00000200 + COMP_ELEM_FRIENDLYNAME* = 0x00000400 + COMP_ELEM_SUBSCRIBEDURL* = 0x00000800 + COMP_ELEM_ORIGINAL_CSI* = 0x00001000 + COMP_ELEM_RESTORED_CSI* = 0x00002000 + COMP_ELEM_CURITEMSTATE* = 0x00004000 + COMP_ELEM_ALL* = COMP_ELEM_TYPE or COMP_ELEM_CHECKED or COMP_ELEM_DIRTY or COMP_ELEM_NOSCROLL or COMP_ELEM_POS_LEFT or COMP_ELEM_SIZE_WIDTH or COMP_ELEM_SIZE_HEIGHT or COMP_ELEM_POS_ZINDEX or COMP_ELEM_SOURCE or COMP_ELEM_FRIENDLYNAME or COMP_ELEM_POS_TOP or COMP_ELEM_SUBSCRIBEDURL or COMP_ELEM_ORIGINAL_CSI or COMP_ELEM_RESTORED_CSI or COMP_ELEM_CURITEMSTATE + DTI_ADDUI_DEFAULT* = 0x0 + DTI_ADDUI_DISPSUBWIZARD* = 0x1 + DTI_ADDUI_POSITIONITEM* = 0x2 + ADDURL_SILENT* = 0x1 + COMPONENT_DEFAULT_LEFT* = 0xffff + COMPONENT_DEFAULT_TOP* = 0xffff + SSM_CLEAR* = 0x0000 + SSM_SET* = 0x0001 + SSM_REFRESH* = 0x0002 + SSM_UPDATE* = 0x0004 + SCHEME_DISPLAY* = 0x0001 + SCHEME_EDIT* = 0x0002 + SCHEME_LOCAL* = 0x0004 + SCHEME_GLOBAL* = 0x0008 + SCHEME_REFRESH* = 0x0010 + SCHEME_UPDATE* = 0x0020 + SCHEME_DONOTUSE* = 0x0040 + SCHEME_CREATE* = 0x0080 + GADOF_DIRTY* = 0x00000001 + SHCDF_UPDATEITEM* = 0x00000001 + CFSTR_SHELLIDLIST* = "Shell IDList Array" + CFSTR_SHELLIDLISTOFFSET* = "Shell Object Offsets" + CFSTR_NETRESOURCES* = "Net Resource" + CFSTR_FILEDESCRIPTORA* = "FileGroupDescriptor" + CFSTR_FILEDESCRIPTORW* = "FileGroupDescriptorW" + CFSTR_FILECONTENTS* = "FileContents" + CFSTR_FILENAMEA* = "FileName" + CFSTR_FILENAMEW* = "FileNameW" + CFSTR_PRINTERGROUP* = "PrinterFriendlyName" + CFSTR_FILENAMEMAPA* = "FileNameMap" + CFSTR_FILENAMEMAPW* = "FileNameMapW" + CFSTR_SHELLURL* = "UniformResourceLocator" + CFSTR_INETURLA* = CFSTR_SHELLURL + CFSTR_INETURLW* = "UniformResourceLocatorW" + CFSTR_PREFERREDDROPEFFECT* = "Preferred DropEffect" + CFSTR_PERFORMEDDROPEFFECT* = "Performed DropEffect" + CFSTR_PASTESUCCEEDED* = "Paste Succeeded" + CFSTR_INDRAGLOOP* = "InShellDragLoop" + CFSTR_MOUNTEDVOLUME* = "MountedVolume" + CFSTR_PERSISTEDDATAOBJECT* = "PersistedDataObject" + CFSTR_TARGETCLSID* = "TargetCLSID" + CFSTR_LOGICALPERFORMEDDROPEFFECT* = "Logical Performed DropEffect" + CFSTR_AUTOPLAY_SHELLIDLISTS* = "Autoplay Enumerated IDList Array" + CFSTR_UNTRUSTEDDRAGDROP* = "UntrustedDragDrop" + CFSTR_FILE_ATTRIBUTES_ARRAY* = "File Attributes Array" + CFSTR_INVOKECOMMAND_DROPPARAM* = "InvokeCommand DropParam" + CFSTR_SHELLDROPHANDLER* = "DropHandlerCLSID" + CFSTR_DROPDESCRIPTION* = "DropDescription" + CFSTR_ZONEIDENTIFIER* = "ZoneIdentifier" + DVASPECT_SHORTNAME* = 2 + DVASPECT_COPY* = 3 + DVASPECT_LINK* = 4 + FD_CLSID* = 0x1 + FD_SIZEPOINT* = 0x2 + FD_ATTRIBUTES* = 0x4 + FD_CREATETIME* = 0x8 + FD_ACCESSTIME* = 0x10 + FD_WRITESTIME* = 0x20 + FD_FILESIZE* = 0x40 + FD_PROGRESSUI* = 0x4000 + FD_LINKUI* = 0x8000 + FD_UNICODE* = int32 0x80000000'i32 + DROPIMAGE_INVALID* = -1 + DROPIMAGE_NONE* = 0 + DROPIMAGE_COPY* = DROPEFFECT_COPY + DROPIMAGE_MOVE* = DROPEFFECT_MOVE + DROPIMAGE_LINK* = DROPEFFECT_LINK + DROPIMAGE_LABEL* = 6 + DROPIMAGE_WARNING* = 7 + DROPIMAGE_NOIMAGE* = 8 + SHCNRF_InterruptLevel* = 0x0001 + SHCNRF_ShellLevel* = 0x0002 + SHCNRF_RecursiveInterrupt* = 0x1000 + SHCNRF_NewDelivery* = 0x8000 + SHCNE_RENAMEITEM* = 0x00000001 + SHCNE_CREATE* = 0x00000002 + SHCNE_DELETE* = 0x00000004 + SHCNE_MKDIR* = 0x00000008 + SHCNE_RMDIR* = 0x00000010 + SHCNE_MEDIAINSERTED* = 0x00000020 + SHCNE_MEDIAREMOVED* = 0x00000040 + SHCNE_DRIVEREMOVED* = 0x00000080 + SHCNE_DRIVEADD* = 0x00000100 + SHCNE_NETSHARE* = 0x00000200 + SHCNE_NETUNSHARE* = 0x00000400 + SHCNE_ATTRIBUTES* = 0x00000800 + SHCNE_UPDATEDIR* = 0x00001000 + SHCNE_UPDATEITEM* = 0x00002000 + SHCNE_SERVERDISCONNECT* = 0x00004000 + SHCNE_UPDATEIMAGE* = 0x00008000 + SHCNE_DRIVEADDGUI* = 0x00010000 + SHCNE_RENAMEFOLDER* = 0x00020000 + SHCNE_FREESPACE* = 0x00040000 + SHCNE_EXTENDED_EVENT* = 0x04000000 + SHCNE_ASSOCCHANGED* = 0x08000000 + SHCNE_DISKEVENTS* = 0x0002381f + SHCNE_GLOBALEVENTS* = 0x0c0581e0 + SHCNE_ALLEVENTS* = 0x7fffffff + SHCNE_INTERRUPT* = 0x80000000'i32 + SHCNEE_ORDERCHANGED* = 2 + SHCNEE_MSI_CHANGE* = 4 + SHCNEE_MSI_UNINSTALL* = 5 + SHCNF_IDLIST* = 0x0000 + SHCNF_PATHA* = 0x0001 + SHCNF_PRINTERA* = 0x0002 + SHCNF_DWORD* = 0x0003 + SHCNF_PATHW* = 0x0005 + SHCNF_PRINTERW* = 0x0006 + SHCNF_TYPE* = 0x00ff + SHCNF_FLUSH* = 0x1000 + SHCNF_FLUSHNOWAIT* = 0x3000 + SHCNF_NOTIFYRECURSIVE* = 0x10000 + QITIPF_DEFAULT* = 0x00000000 + QITIPF_USENAME* = 0x00000001 + QITIPF_LINKNOTARGET* = 0x00000002 + QITIPF_LINKUSETARGET* = 0x00000004 + QITIPF_USESLOWTIP* = 0x00000008 + QITIPF_SINGLELINE* = 0x00000010 + QIF_CACHED* = 0x00000001 + QIF_DONTEXPANDFOLDER* = 0x00000002 + SHARD_PIDL* = 0x00000001 + SHARD_PATHA* = 0x00000002 + SHARD_PATHW* = 0x00000003 + SHARD_APPIDINFO* = 0x00000004 + SHARD_APPIDINFOIDLIST* = 0x00000005 + SHARD_LINK* = 0x00000006 + SHARD_APPIDINFOLINK* = 0x00000007 + SHARD_SHELLITEM* = 0x00000008 + SCNRT_ENABLE* = 0 + SCNRT_DISABLE* = 1 + SHGDFIL_FINDDATA* = 1 + SHGDFIL_NETRESOURCE* = 2 + SHGDFIL_DESCRIPTIONID* = 3 + SHDID_ROOT_REGITEM* = 1 + SHDID_FS_FILE* = 2 + SHDID_FS_DIRECTORY* = 3 + SHDID_FS_OTHER* = 4 + SHDID_COMPUTER_DRIVE35* = 5 + SHDID_COMPUTER_DRIVE525* = 6 + SHDID_COMPUTER_REMOVABLE* = 7 + SHDID_COMPUTER_FIXED* = 8 + SHDID_COMPUTER_NETDRIVE* = 9 + SHDID_COMPUTER_CDROM* = 10 + SHDID_COMPUTER_RAMDISK* = 11 + SHDID_COMPUTER_OTHER* = 12 + SHDID_NET_DOMAIN* = 13 + SHDID_NET_SERVER* = 14 + SHDID_NET_SHARE* = 15 + SHDID_NET_RESTOFNET* = 16 + SHDID_NET_OTHER* = 17 + SHDID_COMPUTER_IMAGING* = 18 + SHDID_COMPUTER_AUDIO* = 19 + SHDID_COMPUTER_SHAREDDOCS* = 20 + SHDID_MOBILE_DEVICE* = 21 + PRF_VERIFYEXISTS* = 0x1 + PRF_TRYPROGRAMEXTENSIONS* = 0x2 or PRF_VERIFYEXISTS + PRF_FIRSTDIRDEF* = 0x4 + PRF_DONTFINDLNK* = 0x8 + PRF_REQUIREABSOLUTE* = 0x10 + NUM_POINTS* = 3 + CABINETSTATE_VERSION* = 2 + PCS_FATAL* = 0x80000000'i32 + PCS_REPLACEDCHAR* = 0x00000001 + PCS_REMOVEDCHAR* = 0x00000002 + PCS_TRUNCATED* = 0x00000004 + PCS_PATHTOOLONG* = 0x00000008 + MM_ADDSEPARATOR* = 0x00000001 + MM_SUBMENUSHAVEIDS* = 0x00000002 + MM_DONTREMOVESEPS* = 0x00000004 + SHOP_PRINTERNAME* = 0x00000001 + SHOP_FILEPATH* = 0x00000002 + SHOP_VOLUMEGUID* = 0x00000004 + SHFMT_ID_DEFAULT* = 0xffff + SHFMT_OPT_FULL* = 0x0001 + SHFMT_OPT_SYSONLY* = 0x0002 + SHFMT_ERROR* = 0xffffffff'i32 + SHFMT_CANCEL* = 0xfffffffe'i32 + SHFMT_NOFORMAT* = 0xfffffffd'i32 + REST_NONE* = 0x00000000 + REST_NORUN* = 0x00000001 + REST_NOCLOSE* = 0x00000002 + REST_NOSAVESET* = 0x00000004 + REST_NOFILEMENU* = 0x00000008 + REST_NOSETFOLDERS* = 0x00000010 + REST_NOSETTASKBAR* = 0x00000020 + REST_NODESKTOP* = 0x00000040 + REST_NOFIND* = 0x00000080 + REST_NODRIVES* = 0x00000100 + REST_NODRIVEAUTORUN* = 0x00000200 + REST_NODRIVETYPEAUTORUN* = 0x00000400 + REST_NONETHOOD* = 0x00000800 + REST_STARTBANNER* = 0x00001000 + REST_RESTRICTRUN* = 0x00002000 + REST_NOPRINTERTABS* = 0x00004000 + REST_NOPRINTERDELETE* = 0x00008000 + REST_NOPRINTERADD* = 0x00010000 + REST_NOSTARTMENUSUBFOLDERS* = 0x00020000 + REST_MYDOCSONNET* = 0x00040000 + REST_NOEXITTODOS* = 0x00080000 + REST_ENFORCESHELLEXTSECURITY* = 0x00100000 + REST_LINKRESOLVEIGNORELINKINFO* = 0x00200000 + REST_NOCOMMONGROUPS* = 0x00400000 + REST_SEPARATEDESKTOPPROCESS* = 0x00800000 + REST_NOWEB* = 0x01000000 + REST_NOTRAYCONTEXTMENU* = 0x02000000 + REST_NOVIEWCONTEXTMENU* = 0x04000000 + REST_NONETCONNECTDISCONNECT* = 0x08000000 + REST_STARTMENULOGOFF* = 0x10000000 + REST_NOSETTINGSASSIST* = 0x20000000 + REST_NOINTERNETICON* = 0x40000001 + REST_NORECENTDOCSHISTORY* = 0x40000002 + REST_NORECENTDOCSMENU* = 0x40000003 + REST_NOACTIVEDESKTOP* = 0x40000004 + REST_NOACTIVEDESKTOPCHANGES* = 0x40000005 + REST_NOFAVORITESMENU* = 0x40000006 + REST_CLEARRECENTDOCSONEXIT* = 0x40000007 + REST_CLASSICSHELL* = 0x40000008 + REST_NOCUSTOMIZEWEBVIEW* = 0x40000009 + REST_NOHTMLWALLPAPER* = 0x40000010 + REST_NOCHANGINGWALLPAPER* = 0x40000011 + REST_NODESKCOMP* = 0x40000012 + REST_NOADDDESKCOMP* = 0x40000013 + REST_NODELDESKCOMP* = 0x40000014 + REST_NOCLOSEDESKCOMP* = 0x40000015 + REST_NOCLOSE_DRAGDROPBAND* = 0x40000016 + REST_NOMOVINGBAND* = 0x40000017 + REST_NOEDITDESKCOMP* = 0x40000018 + REST_NORESOLVESEARCH* = 0x40000019 + REST_NORESOLVETRACK* = 0x4000001a + REST_FORCECOPYACLWITHFILE* = 0x4000001b + REST_NOLOGO3CHANNELNOTIFY* = 0x4000001c + REST_NOFORGETSOFTWAREUPDATE* = 0x4000001d + REST_NOSETACTIVEDESKTOP* = 0x4000001e + REST_NOUPDATEWINDOWS* = 0x4000001f + REST_NOCHANGESTARMENU* = 0x40000020 + REST_NOFOLDEROPTIONS* = 0x40000021 + REST_HASFINDCOMPUTERS* = 0x40000022 + REST_INTELLIMENUS* = 0x40000023 + REST_RUNDLGMEMCHECKBOX* = 0x40000024 + REST_ARP_ShowPostSetup* = 0x40000025 + REST_NOCSC* = 0x40000026 + REST_NOCONTROLPANEL* = 0x40000027 + REST_ENUMWORKGROUP* = 0x40000028 + REST_ARP_NOARP* = 0x40000029 + REST_ARP_NOREMOVEPAGE* = 0x4000002a + REST_ARP_NOADDPAGE* = 0x4000002b + REST_ARP_NOWINSETUPPAGE* = 0x4000002c + REST_GREYMSIADS* = 0x4000002d + REST_NOCHANGEMAPPEDDRIVELABEL* = 0x4000002e + REST_NOCHANGEMAPPEDDRIVECOMMENT* = 0x4000002f + REST_MaxRecentDocs* = 0x40000030 + REST_NONETWORKCONNECTIONS* = 0x40000031 + REST_FORCESTARTMENULOGOFF* = 0x40000032 + REST_NOWEBVIEW* = 0x40000033 + REST_NOCUSTOMIZETHISFOLDER* = 0x40000034 + REST_NOENCRYPTION* = 0x40000035 + REST_DONTSHOWSUPERHIDDEN* = 0x40000037 + REST_NOSHELLSEARCHBUTTON* = 0x40000038 + REST_NOHARDWARETAB* = 0x40000039 + REST_NORUNASINSTALLPROMPT* = 0x4000003a + REST_PROMPTRUNASINSTALLNETPATH* = 0x4000003b + REST_NOMANAGEMYCOMPUTERVERB* = 0x4000003c + REST_DISALLOWRUN* = 0x4000003e + REST_NOWELCOMESCREEN* = 0x4000003f + REST_RESTRICTCPL* = 0x40000040 + REST_DISALLOWCPL* = 0x40000041 + REST_NOSMBALLOONTIP* = 0x40000042 + REST_NOSMHELP* = 0x40000043 + REST_NOWINKEYS* = 0x40000044 + REST_NOENCRYPTONMOVE* = 0x40000045 + REST_NOLOCALMACHINERUN* = 0x40000046 + REST_NOCURRENTUSERRUN* = 0x40000047 + REST_NOLOCALMACHINERUNONCE* = 0x40000048 + REST_NOCURRENTUSERRUNONCE* = 0x40000049 + REST_FORCEACTIVEDESKTOPON* = 0x4000004a + REST_NOVIEWONDRIVE* = 0x4000004c + REST_NONETCRAWL* = 0x4000004d + REST_NOSHAREDDOCUMENTS* = 0x4000004e + REST_NOSMMYDOCS* = 0x4000004f + REST_NOSMMYPICS* = 0x40000050 + REST_ALLOWBITBUCKDRIVES* = 0x40000051 + REST_NONLEGACYSHELLMODE* = 0x40000052 + REST_NOCONTROLPANELBARRICADE* = 0x40000053 + REST_NOSTARTPAGE* = 0x40000054 + REST_NOAUTOTRAYNOTIFY* = 0x40000055 + REST_NOTASKGROUPING* = 0x40000056 + REST_NOCDBURNING* = 0x40000057 + REST_MYCOMPNOPROP* = 0x40000058 + REST_MYDOCSNOPROP* = 0x40000059 + REST_NOSTARTPANEL* = 0x4000005a + REST_NODISPLAYAPPEARANCEPAGE* = 0x4000005b + REST_NOTHEMESTAB* = 0x4000005c + REST_NOVISUALSTYLECHOICE* = 0x4000005d + REST_NOSIZECHOICE* = 0x4000005e + REST_NOCOLORCHOICE* = 0x4000005f + REST_SETVISUALSTYLE* = 0x40000060 + REST_STARTRUNNOHOMEPATH* = 0x40000061 + REST_NOUSERNAMEINSTARTPANEL* = 0x40000062 + REST_NOMYCOMPUTERICON* = 0x40000063 + REST_NOSMNETWORKPLACES* = 0x40000064 + REST_NOSMPINNEDLIST* = 0x40000065 + REST_NOSMMYMUSIC* = 0x40000066 + REST_NOSMEJECTPC* = 0x40000067 + REST_NOSMMOREPROGRAMS* = 0x40000068 + REST_NOSMMFUPROGRAMS* = 0x40000069 + REST_NOTRAYITEMSDISPLAY* = 0x4000006a + REST_NOTOOLBARSONTASKBAR* = 0x4000006b + REST_NOSMCONFIGUREPROGRAMS* = 0x4000006f + REST_HIDECLOCK* = 0x40000070 + REST_NOLOWDISKSPACECHECKS* = 0x40000071 + REST_NOENTIRENETWORK* = 0x40000072 + REST_NODESKTOPCLEANUP* = 0x40000073 + REST_BITBUCKNUKEONDELETE* = 0x40000074 + REST_BITBUCKCONFIRMDELETE* = 0x40000075 + REST_BITBUCKNOPROP* = 0x40000076 + REST_NODISPBACKGROUND* = 0x40000077 + REST_NODISPSCREENSAVEPG* = 0x40000078 + REST_NODISPSETTINGSPG* = 0x40000079 + REST_NODISPSCREENSAVEPREVIEW* = 0x4000007a + REST_NODISPLAYCPL* = 0x4000007b + REST_HIDERUNASVERB* = 0x4000007c + REST_NOTHUMBNAILCACHE* = 0x4000007d + REST_NOSTRCMPLOGICAL* = 0x4000007e + REST_NOPUBLISHWIZARD* = 0x4000007f + REST_NOONLINEPRINTSWIZARD* = 0x40000080 + REST_NOWEBSERVICES* = 0x40000081 + REST_ALLOWUNHASHEDWEBVIEW* = 0x40000082 + REST_ALLOWLEGACYWEBVIEW* = 0x40000083 + REST_REVERTWEBVIEWSECURITY* = 0x40000084 + REST_INHERITCONSOLEHANDLES* = 0x40000086 + REST_SORTMAXITEMCOUNT* = 0x40000087 + REST_NOREMOTERECURSIVEEVENTS* = 0x40000089 + REST_NOREMOTECHANGENOTIFY* = 0x40000091 + REST_NOSIMPLENETIDLIST* = 0x40000092 + REST_NOENUMENTIRENETWORK* = 0x40000093 + REST_NODETAILSTHUMBNAILONNETWORK* = 0x40000094 + REST_NOINTERNETOPENWITH* = 0x40000095 + REST_DONTRETRYBADNETNAME* = 0x4000009b + REST_ALLOWFILECLSIDJUNCTIONS* = 0x4000009c + REST_NOUPNPINSTALL* = 0x4000009d + REST_ARP_DONTGROUPPATCHES* = 0x400000ac + REST_ARP_NOCHOOSEPROGRAMSPAGE* = 0x400000ad + REST_NODISCONNECT* = 0x41000001 + REST_NOSECURITY* = 0x41000002 + REST_NOFILEASSOCIATE* = 0x41000003 + REST_ALLOWCOMMENTTOGGLE* = 0x41000004 + REST_USEDESKTOPINICACHE* = 0x41000005 + PPCF_ADDQUOTES* = 0x00000001 + PPCF_ADDARGUMENTS* = 0x00000003 + PPCF_NODIRECTORIES* = 0x00000010 + PPCF_FORCEQUALIFY* = 0x00000040 + PPCF_LONGESTPOSSIBLE* = 0x00000080 + OAIF_ALLOW_REGISTRATION* = 0x1 + OAIF_REGISTER_EXT* = 0x2 + OAIF_EXEC* = 0x4 + OAIF_FORCE_REGISTRATION* = 0x8 + OAIF_HIDE_REGISTRATION* = 0x20 + OAIF_URL_PROTOCOL* = 0x40 + OAIF_FILE_IS_URI* = 0x80 + VALIDATEUNC_CONNECT* = 0x0001 + VALIDATEUNC_NOUI* = 0x0002 + VALIDATEUNC_PRINT* = 0x0004 + VALIDATEUNC_PERSIST* = 0x0008 + VALIDATEUNC_VALID* = 0x000f + OPENPROPS_NONE* = 0x0000 + OPENPROPS_INHIBITPIF* = 0x8000 + GETPROPS_NONE* = 0x0000 + SETPROPS_NONE* = 0x0000 + CLOSEPROPS_NONE* = 0x0000 + CLOSEPROPS_DISCARD* = 0x0001 + PIFSHPROGSIZE* = 64 + PIFSHDATASIZE* = 64 + IID_IInitializeObject* = DEFINE_GUID("4622ad16-ff23-11d0-8d34-00a0c90f2719") + BMICON_LARGE* = 0 + BMICON_SMALL* = 1 + QCMINFO_PLACE_BEFORE* = 0 + QCMINFO_PLACE_AFTER* = 1 + TBIF_APPEND* = 0 + TBIF_PREPEND* = 1 + TBIF_REPLACE* = 2 + TBIF_DEFAULT* = 0x00000000 + TBIF_INTERNETBAR* = 0x00010000 + TBIF_STANDARDTOOLBAR* = 0x00020000 + TBIF_NOTOOLBAR* = 0x00030000 + SFVM_MERGEMENU* = 1 + SFVM_INVOKECOMMAND* = 2 + SFVM_GETHELPTEXT* = 3 + SFVM_GETTOOLTIPTEXT* = 4 + SFVM_GETBUTTONINFO* = 5 + SFVM_GETBUTTONS* = 6 + SFVM_INITMENUPOPUP* = 7 + SFVM_FSNOTIFY* = 14 + SFVM_WINDOWCREATED* = 15 + SFVM_GETDETAILSOF* = 23 + SFVM_COLUMNCLICK* = 24 + SFVM_QUERYFSNOTIFY* = 25 + SFVM_DEFITEMCOUNT* = 26 + SFVM_DEFVIEWMODE* = 27 + SFVM_UNMERGEMENU* = 28 + SFVM_UPDATESTATUSBAR* = 31 + SFVM_BACKGROUNDENUM* = 32 + SFVM_DIDDRAGDROP* = 36 + SFVM_SETISFV* = 39 + SFVM_THISIDLIST* = 41 + SFVM_ADDPROPERTYPAGES* = 47 + SFVM_BACKGROUNDENUMDONE* = 48 + SFVM_GETNOTIFY* = 49 + SFVM_GETSORTDEFAULTS* = 53 + SFVM_SIZE* = 57 + SFVM_GETZONE* = 58 + SFVM_GETPANE* = 59 + SFVM_GETHELPTOPIC* = 63 + SFVM_GETANIMATION* = 68 + SFVSOC_INVALIDATE_ALL* = 0x00000001 + SFVSOC_NOSCROLL* = LVSICF_NOSCROLL + SFVS_SELECT_NONE* = 0x0 + SFVS_SELECT_ALLITEMS* = 0x1 + SFVS_SELECT_INVERT* = 0x2 + IID_IShellFolderView* = DEFINE_GUID("37a378c0-f82d-11ce-ae65-08002b2e1262") + DFM_MERGECONTEXTMENU* = 1 + DFM_INVOKECOMMAND* = 2 + DFM_GETHELPTEXT* = 5 + DFM_WM_MEASUREITEM* = 6 + DFM_WM_DRAWITEM* = 7 + DFM_WM_INITMENUPOPUP* = 8 + DFM_VALIDATECMD* = 9 + DFM_MERGECONTEXTMENU_TOP* = 10 + DFM_GETHELPTEXTW* = 11 + DFM_INVOKECOMMANDEX* = 12 + DFM_MAPCOMMANDNAME* = 13 + DFM_GETDEFSTATICID* = 14 + DFM_GETVERBW* = 15 + DFM_GETVERBA* = 16 + DFM_MERGECONTEXTMENU_BOTTOM* = 17 + DFM_MODIFYQCMFLAGS* = 18 + DFM_CMD_DELETE* = UINT(-1) + DFM_CMD_MOVE* = UINT(-2) + DFM_CMD_COPY* = UINT(-3) + DFM_CMD_LINK* = UINT(-4) + DFM_CMD_PROPERTIES* = UINT(-5) + DFM_CMD_NEWFOLDER* = UINT(-6) + DFM_CMD_PASTE* = UINT(-7) + DFM_CMD_VIEWLIST* = UINT(-8) + DFM_CMD_VIEWDETAILS* = UINT(-9) + DFM_CMD_PASTELINK* = UINT(-10) + DFM_CMD_PASTESPECIAL* = UINT(-11) + DFM_CMD_MODALPROP* = UINT(-12) + DFM_CMD_RENAME* = UINT(-13) + SFVM_REARRANGE* = 0x00000001 + SFVM_ADDOBJECT* = 0x00000003 + SFVM_REMOVEOBJECT* = 0x00000006 + SFVM_UPDATEOBJECT* = 0x00000007 + SFVM_GETSELECTEDOBJECTS* = 0x00000009 + SFVM_SETITEMPOS* = 0x0000000e + SFVM_SETCLIPBOARD* = 0x00000010 + SFVM_SETPOINTS* = 0x00000017 + PID_IS_URL* = 2 + PID_IS_NAME* = 4 + PID_IS_WORKINGDIR* = 5 + PID_IS_HOTKEY* = 6 + PID_IS_SHOWCMD* = 7 + PID_IS_ICONINDEX* = 8 + PID_IS_ICONFILE* = 9 + PID_IS_WHATSNEW* = 10 + PID_IS_AUTHOR* = 11 + PID_IS_DESCRIPTION* = 12 + PID_IS_COMMENT* = 13 + PID_IS_ROAMED* = 15 + PID_INTSITE_WHATSNEW* = 2 + PID_INTSITE_AUTHOR* = 3 + PID_INTSITE_LASTVISIT* = 4 + PID_INTSITE_LASTMOD* = 5 + PID_INTSITE_VISITCOUNT* = 6 + PID_INTSITE_DESCRIPTION* = 7 + PID_INTSITE_COMMENT* = 8 + PID_INTSITE_FLAGS* = 9 + PID_INTSITE_CONTENTLEN* = 10 + PID_INTSITE_CONTENTCODE* = 11 + PID_INTSITE_RECURSE* = 12 + PID_INTSITE_WATCH* = 13 + PID_INTSITE_SUBSCRIPTION* = 14 + PID_INTSITE_URL* = 15 + PID_INTSITE_TITLE* = 16 + PID_INTSITE_CODEPAGE* = 18 + PID_INTSITE_TRACKING* = 19 + PID_INTSITE_ICONINDEX* = 20 + PID_INTSITE_ICONFILE* = 21 + PID_INTSITE_ROAMED* = 34 + PIDISF_RECENTLYCHANGED* = 0x00000001 + PIDISF_CACHEDSTICKY* = 0x00000002 + PIDISF_CACHEIMAGES* = 0x00000010 + PIDISF_FOLLOWALLLINKS* = 0x00000020 + PIDISM_GLOBAL* = 0 + PIDISM_WATCH* = 1 + PIDISM_DONTWATCH* = 2 + PIDISR_UP_TO_DATE* = 0 + PIDISR_NEEDS_ADD* = 1 + PIDISR_NEEDS_UPDATE* = 2 + PIDISR_NEEDS_DELETE* = 3 + SHELLSTATEVERSION_IE4* = 9 + SHELLSTATEVERSION_WIN2K* = 10 +when winimUnicode: + type + SHELLSTATE* = SHELLSTATEW +when winimAnsi: + type + SHELLSTATE* = SHELLSTATEA +const + SSF_SHOWALLOBJECTS* = 0x00000001 + SSF_SHOWEXTENSIONS* = 0x00000002 + SSF_HIDDENFILEEXTS* = 0x00000004 + SSF_SERVERADMINUI* = 0x00000004 + SSF_SHOWCOMPCOLOR* = 0x00000008 + SSF_SORTCOLUMNS* = 0x00000010 + SSF_SHOWSYSFILES* = 0x00000020 + SSF_DOUBLECLICKINWEBVIEW* = 0x00000080 + SSF_SHOWATTRIBCOL* = 0x00000100 + SSF_DESKTOPHTML* = 0x00000200 + SSF_WIN95CLASSIC* = 0x00000400 + SSF_DONTPRETTYPATH* = 0x00000800 + SSF_SHOWINFOTIP* = 0x00002000 + SSF_MAPNETDRVBUTTON* = 0x00001000 + SSF_NOCONFIRMRECYCLE* = 0x00008000 + SSF_HIDEICONS* = 0x00004000 + SSF_FILTER* = 0x00010000 + SSF_WEBVIEW* = 0x00020000 + SSF_SHOWSUPERHIDDEN* = 0x00040000 + SSF_SEPPROCESS* = 0x00080000 + SSF_NONETCRAWLING* = 0x00100000 + SSF_STARTPANELON* = 0x00200000 + SSF_SHOWSTARTPAGE* = 0x00400000 + SSF_AUTOCHECKSELECT* = 0x00800000 + SSF_ICONSONLY* = 0x01000000 + SSF_SHOWTYPEOVERLAY* = 0x02000000 + SSF_SHOWSTATUSBAR* = 0x04000000 + SHPPFW_NONE* = 0x00000000 + SHPPFW_DIRCREATE* = 0x00000001 + SHPPFW_DEFAULT* = SHPPFW_DIRCREATE + SHPPFW_ASKDIRCREATE* = 0x00000002 + SHPPFW_IGNOREFILENAME* = 0x00000004 + SHPPFW_NOWRITECHECK* = 0x00000008 + SHPPFW_MEDIACHECKONLY* = 0x00000010 + IESHORTCUT_NEWBROWSER* = 0x01 + IESHORTCUT_OPENNEWTAB* = 0x02 + IESHORTCUT_FORCENAVIGATE* = 0x04 + IESHORTCUT_BACKGROUNDTAB* = 0x08 + CMIC_MASK_HASLINKNAME* = 0x00010000 + CMIC_MASK_FLAG_SEP_VDM* = 0x00040000 + CMIC_MASK_HASTITLE* = 0x00020000 + SHELLSTATE_SIZE_WIN2K* = 32 + ITSAT_DEFAULT_LPARAM* = not DWORD_PTR(0) +type + PFNCANSHAREFOLDERW* = proc (pszPath: PCWSTR): HRESULT {.stdcall.} + PFNSHOWSHAREFOLDERUIW* = proc (hwndParent: HWND, pszPath: PCWSTR): HRESULT {.stdcall.} + DLLVERSIONINFO* {.pure.} = object + cbSize*: DWORD + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + dwBuildNumber*: DWORD + dwPlatformID*: DWORD + DLLGETVERSIONPROC* = proc (P1: ptr DLLVERSIONINFO): HRESULT {.stdcall.} + LPFNDFMCALLBACK* = proc (psf: ptr IShellFolder, hwnd: HWND, pdtobj: ptr IDataObject, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + ASSOCIATIONELEMENT* {.pure.} = object + ac*: ASSOCCLASS + hkClass*: HKEY + pszClass*: PCWSTR + SHFILEINFOA* {.pure.} = object + hIcon*: HICON + iIcon*: int32 + dwAttributes*: DWORD + szDisplayName*: array[MAX_PATH, CHAR] + szTypeName*: array[80, CHAR] + SHFILEINFOW* {.pure.} = object + hIcon*: HICON + iIcon*: int32 + dwAttributes*: DWORD + szDisplayName*: array[MAX_PATH, WCHAR] + szTypeName*: array[80, WCHAR] + SHSTOCKICONINFO* {.pure.} = object + cbSize*: DWORD + hIcon*: HICON + iSysImageIndex*: int32 + iIcon*: int32 + szPath*: array[MAX_PATH, WCHAR] + DLLVERSIONINFO2* {.pure.} = object + info1*: DLLVERSIONINFO + dwFlags*: DWORD + ullVersion*: ULONGLONG + PERSIST_FOLDER_TARGET_INFO* {.pure.} = object + pidlTargetFolder*: PIDLIST_ABSOLUTE + szTargetParsingName*: array[260, WCHAR] + szNetworkProvider*: array[260, WCHAR] + dwAttributes*: DWORD + csidl*: int32 + SORTCOLUMN* {.pure.} = object + propkey*: PROPERTYKEY + direction*: SORTDIRECTION + CM_COLUMNINFO* {.pure.} = object + cbSize*: DWORD + dwMask*: DWORD + dwState*: DWORD + uWidth*: UINT + uDefaultWidth*: UINT + uIdealWidth*: UINT + wszName*: array[80, WCHAR] + SHELL_ITEM_RESOURCE* {.pure.} = object + guidType*: GUID + szName*: array[260, WCHAR] + TCATEGORY_INFO* {.pure.} = object + cif*: CATEGORYINFO_FLAGS + wszName*: array[260, WCHAR] + DESKBANDINFO* {.pure.} = object + dwMask*: DWORD + ptMinSize*: POINTL + ptMaxSize*: POINTL + ptIntegral*: POINTL + ptActual*: POINTL + wszTitle*: array[256, WCHAR] + dwModeFlags*: DWORD + crBkgnd*: COLORREF + BANDSITEINFO* {.pure.} = object + dwMask*: DWORD + dwState*: DWORD + dwStyle*: DWORD + KNOWNFOLDER_DEFINITION* {.pure.} = object + category*: KF_CATEGORY + pszName*: LPWSTR + pszDescription*: LPWSTR + fidParent*: KNOWNFOLDERID + pszRelativePath*: LPWSTR + pszParsingName*: LPWSTR + pszTooltip*: LPWSTR + pszLocalizedName*: LPWSTR + pszIcon*: LPWSTR + pszSecurity*: LPWSTR + dwAttributes*: DWORD + kfdFlags*: KF_DEFINITION_FLAGS + ftidType*: FOLDERTYPEID + IShellItem* {.pure.} = object + lpVtbl*: ptr IShellItemVtbl + IShellItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BindToHandler*: proc(self: ptr IShellItem, pbc: ptr IBindCtx, bhid: REFGUID, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetParent*: proc(self: ptr IShellItem, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + GetDisplayName*: proc(self: ptr IShellItem, sigdnName: SIGDN, ppszName: ptr LPWSTR): HRESULT {.stdcall.} + GetAttributes*: proc(self: ptr IShellItem, sfgaoMask: SFGAOF, psfgaoAttribs: ptr SFGAOF): HRESULT {.stdcall.} + Compare*: proc(self: ptr IShellItem, psi: ptr IShellItem, hint: SICHINTF, piOrder: ptr int32): HRESULT {.stdcall.} + NSTCCUSTOMDRAW* {.pure.} = object + psi*: ptr IShellItem + uItemState*: UINT + nstcis*: NSTCITEMSTATE + pszText*: LPCWSTR + iImage*: int32 + himl*: HIMAGELIST + iLevel*: int32 + iIndent*: int32 + PREVIEWHANDLERFRAMEINFO* {.pure.} = object + haccel*: HACCEL + cAccelEntries*: UINT + EXP_PROPERTYSTORAGE* {.pure, packed.} = object + cbSize*: DWORD + dwSignature*: DWORD + abPropertyStorage*: array[1, BYTE] + FILE_ATTRIBUTES_ARRAY* {.pure.} = object + cItems*: UINT + dwSumFileAttributes*: DWORD + dwProductFileAttributes*: DWORD + rgdwFileAttributes*: array[1, DWORD] + DROPDESCRIPTION* {.pure.} = object + `type`*: DROPIMAGETYPE + szMessage*: array[MAX_PATH, WCHAR] + szInsert*: array[MAX_PATH, WCHAR] + SHChangeNotifyEntry* {.pure, packed.} = object + pidl*: PCIDLIST_ABSOLUTE + fRecursive*: WINBOOL + TSHARDAPPIDINFO* {.pure.} = object + psi*: ptr IShellItem + pszAppID*: PCWSTR + TSHARD_APPIDINFOIDLIST* {.pure.} = object + pidl*: PCIDLIST_ABSOLUTE + pszAppID*: PCWSTR + IShellLinkW* {.pure.} = object + lpVtbl*: ptr IShellLinkWVtbl + IShellLinkWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPath*: proc(self: ptr IShellLinkW, pszFile: LPWSTR, cch: int32, pfd: ptr WIN32_FIND_DATAW, fFlags: DWORD): HRESULT {.stdcall.} + GetIDList*: proc(self: ptr IShellLinkW, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + SetIDList*: proc(self: ptr IShellLinkW, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + GetDescription*: proc(self: ptr IShellLinkW, pszName: LPWSTR, cch: int32): HRESULT {.stdcall.} + SetDescription*: proc(self: ptr IShellLinkW, pszName: LPCWSTR): HRESULT {.stdcall.} + GetWorkingDirectory*: proc(self: ptr IShellLinkW, pszDir: LPWSTR, cch: int32): HRESULT {.stdcall.} + SetWorkingDirectory*: proc(self: ptr IShellLinkW, pszDir: LPCWSTR): HRESULT {.stdcall.} + GetArguments*: proc(self: ptr IShellLinkW, pszArgs: LPWSTR, cch: int32): HRESULT {.stdcall.} + SetArguments*: proc(self: ptr IShellLinkW, pszArgs: LPCWSTR): HRESULT {.stdcall.} + GetHotkey*: proc(self: ptr IShellLinkW, pwHotkey: ptr WORD): HRESULT {.stdcall.} + SetHotkey*: proc(self: ptr IShellLinkW, wHotkey: WORD): HRESULT {.stdcall.} + GetShowCmd*: proc(self: ptr IShellLinkW, piShowCmd: ptr int32): HRESULT {.stdcall.} + SetShowCmd*: proc(self: ptr IShellLinkW, iShowCmd: int32): HRESULT {.stdcall.} + GetIconLocation*: proc(self: ptr IShellLinkW, pszIconPath: LPWSTR, cch: int32, piIcon: ptr int32): HRESULT {.stdcall.} + SetIconLocation*: proc(self: ptr IShellLinkW, pszIconPath: LPCWSTR, iIcon: int32): HRESULT {.stdcall.} + SetRelativePath*: proc(self: ptr IShellLinkW, pszPathRel: LPCWSTR, dwReserved: DWORD): HRESULT {.stdcall.} + Resolve*: proc(self: ptr IShellLinkW, hwnd: HWND, fFlags: DWORD): HRESULT {.stdcall.} + SetPath*: proc(self: ptr IShellLinkW, pszFile: LPCWSTR): HRESULT {.stdcall.} +when winimUnicode: + type + IShellLink* = IShellLinkW +type + IShellLinkA* {.pure.} = object + lpVtbl*: ptr IShellLinkAVtbl + IShellLinkAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPath*: proc(self: ptr IShellLinkA, pszFile: LPSTR, cch: int32, pfd: ptr WIN32_FIND_DATAA, fFlags: DWORD): HRESULT {.stdcall.} + GetIDList*: proc(self: ptr IShellLinkA, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + SetIDList*: proc(self: ptr IShellLinkA, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + GetDescription*: proc(self: ptr IShellLinkA, pszName: LPSTR, cch: int32): HRESULT {.stdcall.} + SetDescription*: proc(self: ptr IShellLinkA, pszName: LPCSTR): HRESULT {.stdcall.} + GetWorkingDirectory*: proc(self: ptr IShellLinkA, pszDir: LPSTR, cch: int32): HRESULT {.stdcall.} + SetWorkingDirectory*: proc(self: ptr IShellLinkA, pszDir: LPCSTR): HRESULT {.stdcall.} + GetArguments*: proc(self: ptr IShellLinkA, pszArgs: LPSTR, cch: int32): HRESULT {.stdcall.} + SetArguments*: proc(self: ptr IShellLinkA, pszArgs: LPCSTR): HRESULT {.stdcall.} + GetHotkey*: proc(self: ptr IShellLinkA, pwHotkey: ptr WORD): HRESULT {.stdcall.} + SetHotkey*: proc(self: ptr IShellLinkA, wHotkey: WORD): HRESULT {.stdcall.} + GetShowCmd*: proc(self: ptr IShellLinkA, piShowCmd: ptr int32): HRESULT {.stdcall.} + SetShowCmd*: proc(self: ptr IShellLinkA, iShowCmd: int32): HRESULT {.stdcall.} + GetIconLocation*: proc(self: ptr IShellLinkA, pszIconPath: LPSTR, cch: int32, piIcon: ptr int32): HRESULT {.stdcall.} + SetIconLocation*: proc(self: ptr IShellLinkA, pszIconPath: LPCSTR, iIcon: int32): HRESULT {.stdcall.} + SetRelativePath*: proc(self: ptr IShellLinkA, pszPathRel: LPCSTR, dwReserved: DWORD): HRESULT {.stdcall.} + Resolve*: proc(self: ptr IShellLinkA, hwnd: HWND, fFlags: DWORD): HRESULT {.stdcall.} + SetPath*: proc(self: ptr IShellLinkA, pszFile: LPCSTR): HRESULT {.stdcall.} +when winimAnsi: + type + IShellLink* = IShellLinkA +type + TSHARDAPPIDINFOLINK* {.pure.} = object + psl*: ptr IShellLink + pszAppID*: PCWSTR + AUTO_SCROLL_DATA* {.pure.} = object + iNextSample*: int32 + dwLastScroll*: DWORD + bFull*: WINBOOL + pts*: array[NUM_POINTS, POINT] + dwTimes*: array[NUM_POINTS, DWORD] + SFVM_PROPPAGE_DATA* {.pure.} = object + dwReserved*: DWORD + pfn*: LPFNADDPROPSHEETPAGE + lParam*: LPARAM + SFVM_HELPTOPIC_DATA* {.pure.} = object + wszHelpFile*: array[MAX_PATH, WCHAR] + wszHelpTopic*: array[MAX_PATH, WCHAR] + ITEMSPACING* {.pure.} = object + cxSmall*: int32 + cySmall*: int32 + cxLarge*: int32 + cyLarge*: int32 + IShellFolderViewCB* {.pure.} = object + lpVtbl*: ptr IShellFolderViewCBVtbl + IShellFolderViewCBVtbl* {.pure, inheritable.} = object of IUnknownVtbl + MessageSFVCB*: proc(self: ptr IShellFolderViewCB, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + SFV_CREATE* {.pure.} = object + cbSize*: UINT + pshf*: ptr IShellFolder + psvOuter*: ptr IShellView + psfvcb*: ptr IShellFolderViewCB + IContextMenuCB* {.pure.} = object + lpVtbl*: ptr IContextMenuCBVtbl + IContextMenuCBVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CallBack*: proc(self: ptr IContextMenuCB, psf: ptr IShellFolder, hwndOwner: HWND, pdtobj: ptr IDataObject, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + DEFCONTEXTMENU* {.pure.} = object + hwnd*: HWND + pcmcb*: ptr IContextMenuCB + pidlFolder*: PCIDLIST_ABSOLUTE + psf*: ptr IShellFolder + cidl*: UINT + apidl*: PCUITEMID_CHILD_ARRAY + punkAssociationInfo*: ptr IUnknown + cKeys*: UINT + aKeys*: ptr HKEY + IQueryAssociations* {.pure.} = object + lpVtbl*: ptr IQueryAssociationsVtbl + IQueryAssociationsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Init*: proc(self: ptr IQueryAssociations, flags: ASSOCF, pszAssoc: LPCWSTR, hkProgid: HKEY, hwnd: HWND): HRESULT {.stdcall.} + GetString*: proc(self: ptr IQueryAssociations, flags: ASSOCF, str: ASSOCSTR, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.stdcall.} + GetKey*: proc(self: ptr IQueryAssociations, flags: ASSOCF, key: ASSOCKEY, pszExtra: LPCWSTR, phkeyOut: ptr HKEY): HRESULT {.stdcall.} + GetData*: proc(self: ptr IQueryAssociations, flags: ASSOCF, data: ASSOCDATA, pszExtra: LPCWSTR, pvOut: LPVOID, pcbOut: ptr DWORD): HRESULT {.stdcall.} + GetEnum*: proc(self: ptr IQueryAssociations, flags: ASSOCF, assocenum: ASSOCENUM, pszExtra: LPCWSTR, riid: REFIID, ppvOut: ptr LPVOID): HRESULT {.stdcall.} + IFolderViewOC* {.pure.} = object + lpVtbl*: ptr IFolderViewOCVtbl + IFolderViewOCVtbl* {.pure, inheritable.} = object of IDispatchVtbl + SetFolderView*: proc(self: ptr IFolderViewOC, pdisp: ptr IDispatch): HRESULT {.stdcall.} + DShellFolderViewEvents* {.pure.} = object + lpVtbl*: ptr DShellFolderViewEventsVtbl + DShellFolderViewEventsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + DFConstraint* {.pure.} = object + lpVtbl*: ptr DFConstraintVtbl + DFConstraintVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Name*: proc(self: ptr DFConstraint, pbs: ptr BSTR): HRESULT {.stdcall.} + get_Value*: proc(self: ptr DFConstraint, pv: ptr VARIANT): HRESULT {.stdcall.} + FolderItems* {.pure.} = object + lpVtbl*: ptr FolderItemsVtbl + FolderItemsVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Count*: proc(self: ptr FolderItems, plCount: ptr LONG): HRESULT {.stdcall.} + get_Application*: proc(self: ptr FolderItems, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr FolderItems, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + Item*: proc(self: ptr FolderItems, index: VARIANT, ppid: ptr ptr FolderItem): HRESULT {.stdcall.} + NewEnum*: proc(self: ptr FolderItems, ppunk: ptr ptr IUnknown): HRESULT {.stdcall.} + Folder* {.pure.} = object + lpVtbl*: ptr FolderVtbl + FolderVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Title*: proc(self: ptr Folder, pbs: ptr BSTR): HRESULT {.stdcall.} + get_Application*: proc(self: ptr Folder, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr Folder, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_ParentFolder*: proc(self: ptr Folder, ppsf: ptr ptr Folder): HRESULT {.stdcall.} + Items*: proc(self: ptr Folder, ppid: ptr ptr FolderItems): HRESULT {.stdcall.} + ParseName*: proc(self: ptr Folder, bName: BSTR, ppid: ptr ptr FolderItem): HRESULT {.stdcall.} + NewFolder*: proc(self: ptr Folder, bName: BSTR, vOptions: VARIANT): HRESULT {.stdcall.} + MoveHere*: proc(self: ptr Folder, vItem: VARIANT, vOptions: VARIANT): HRESULT {.stdcall.} + CopyHere*: proc(self: ptr Folder, vItem: VARIANT, vOptions: VARIANT): HRESULT {.stdcall.} + GetDetailsOf*: proc(self: ptr Folder, vItem: VARIANT, iColumn: int32, pbs: ptr BSTR): HRESULT {.stdcall.} + Folder2* {.pure.} = object + lpVtbl*: ptr Folder2Vtbl + Folder2Vtbl* {.pure, inheritable.} = object of FolderVtbl + get_Self*: proc(self: ptr Folder2, ppfi: ptr ptr FolderItem): HRESULT {.stdcall.} + get_OfflineStatus*: proc(self: ptr Folder2, pul: ptr LONG): HRESULT {.stdcall.} + Synchronize*: proc(self: ptr Folder2): HRESULT {.stdcall.} + get_HaveToShowWebViewBarricade*: proc(self: ptr Folder2, pbHaveToShowWebViewBarricade: ptr VARIANT_BOOL): HRESULT {.stdcall.} + DismissedWebViewBarricade*: proc(self: ptr Folder2): HRESULT {.stdcall.} + Folder3* {.pure.} = object + lpVtbl*: ptr Folder3Vtbl + Folder3Vtbl* {.pure, inheritable.} = object of Folder2Vtbl + get_ShowWebViewBarricade*: proc(self: ptr Folder3, pbShowWebViewBarricade: ptr VARIANT_BOOL): HRESULT {.stdcall.} + put_ShowWebViewBarricade*: proc(self: ptr Folder3, bShowWebViewBarricade: VARIANT_BOOL): HRESULT {.stdcall.} + FolderItem2* {.pure.} = object + lpVtbl*: ptr FolderItem2Vtbl + FolderItem2Vtbl* {.pure, inheritable.} = object of FolderItemVtbl + InvokeVerbEx*: proc(self: ptr FolderItem2, vVerb: VARIANT, vArgs: VARIANT): HRESULT {.stdcall.} + ExtendedProperty*: proc(self: ptr FolderItem2, bstrPropName: BSTR, pvRet: ptr VARIANT): HRESULT {.stdcall.} + FolderItems2* {.pure.} = object + lpVtbl*: ptr FolderItems2Vtbl + FolderItems2Vtbl* {.pure, inheritable.} = object of FolderItemsVtbl + InvokeVerbEx*: proc(self: ptr FolderItems2, vVerb: VARIANT, vArgs: VARIANT): HRESULT {.stdcall.} + FolderItems3* {.pure.} = object + lpVtbl*: ptr FolderItems3Vtbl + FolderItems3Vtbl* {.pure, inheritable.} = object of FolderItems2Vtbl + Filter*: proc(self: ptr FolderItems3, grfFlags: LONG, bstrFileSpec: BSTR): HRESULT {.stdcall.} + get_Verbs*: proc(self: ptr FolderItems3, ppfic: ptr ptr FolderItemVerbs): HRESULT {.stdcall.} + IShellLinkDual* {.pure.} = object + lpVtbl*: ptr IShellLinkDualVtbl + IShellLinkDualVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Path*: proc(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.stdcall.} + put_Path*: proc(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.stdcall.} + get_Description*: proc(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.stdcall.} + put_Description*: proc(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.stdcall.} + get_WorkingDirectory*: proc(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.stdcall.} + put_WorkingDirectory*: proc(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.stdcall.} + get_Arguments*: proc(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.stdcall.} + put_Arguments*: proc(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.stdcall.} + get_Hotkey*: proc(self: ptr IShellLinkDual, piHK: ptr int32): HRESULT {.stdcall.} + put_Hotkey*: proc(self: ptr IShellLinkDual, iHK: int32): HRESULT {.stdcall.} + get_ShowCommand*: proc(self: ptr IShellLinkDual, piShowCommand: ptr int32): HRESULT {.stdcall.} + put_ShowCommand*: proc(self: ptr IShellLinkDual, iShowCommand: int32): HRESULT {.stdcall.} + Resolve*: proc(self: ptr IShellLinkDual, fFlags: int32): HRESULT {.stdcall.} + GetIconLocation*: proc(self: ptr IShellLinkDual, pbs: ptr BSTR, piIcon: ptr int32): HRESULT {.stdcall.} + SetIconLocation*: proc(self: ptr IShellLinkDual, bs: BSTR, iIcon: int32): HRESULT {.stdcall.} + Save*: proc(self: ptr IShellLinkDual, vWhere: VARIANT): HRESULT {.stdcall.} + IShellLinkDual2* {.pure.} = object + lpVtbl*: ptr IShellLinkDual2Vtbl + IShellLinkDual2Vtbl* {.pure, inheritable.} = object of IShellLinkDualVtbl + get_Target*: proc(self: ptr IShellLinkDual2, ppfi: ptr ptr FolderItem): HRESULT {.stdcall.} + IShellFolderViewDual* {.pure.} = object + lpVtbl*: ptr IShellFolderViewDualVtbl + IShellFolderViewDualVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Application*: proc(self: ptr IShellFolderViewDual, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr IShellFolderViewDual, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Folder*: proc(self: ptr IShellFolderViewDual, ppid: ptr ptr Folder): HRESULT {.stdcall.} + SelectedItems*: proc(self: ptr IShellFolderViewDual, ppid: ptr ptr FolderItems): HRESULT {.stdcall.} + get_FocusedItem*: proc(self: ptr IShellFolderViewDual, ppid: ptr ptr FolderItem): HRESULT {.stdcall.} + SelectItem*: proc(self: ptr IShellFolderViewDual, pvfi: ptr VARIANT, dwFlags: int32): HRESULT {.stdcall.} + PopupItemMenu*: proc(self: ptr IShellFolderViewDual, pfi: ptr FolderItem, vx: VARIANT, vy: VARIANT, pbs: ptr BSTR): HRESULT {.stdcall.} + get_Script*: proc(self: ptr IShellFolderViewDual, ppDisp: ptr ptr IDispatch): HRESULT {.stdcall.} + get_ViewOptions*: proc(self: ptr IShellFolderViewDual, plViewOptions: ptr LONG): HRESULT {.stdcall.} + IShellFolderViewDual2* {.pure.} = object + lpVtbl*: ptr IShellFolderViewDual2Vtbl + IShellFolderViewDual2Vtbl* {.pure, inheritable.} = object of IShellFolderViewDualVtbl + get_CurrentViewMode*: proc(self: ptr IShellFolderViewDual2, pViewMode: ptr UINT): HRESULT {.stdcall.} + put_CurrentViewMode*: proc(self: ptr IShellFolderViewDual2, ViewMode: UINT): HRESULT {.stdcall.} + SelectItemRelative*: proc(self: ptr IShellFolderViewDual2, iRelative: int32): HRESULT {.stdcall.} + IShellFolderViewDual3* {.pure.} = object + lpVtbl*: ptr IShellFolderViewDual3Vtbl + IShellFolderViewDual3Vtbl* {.pure, inheritable.} = object of IShellFolderViewDual2Vtbl + get_GroupBy*: proc(self: ptr IShellFolderViewDual3, pbstrGroupBy: ptr BSTR): HRESULT {.stdcall.} + put_GroupBy*: proc(self: ptr IShellFolderViewDual3, bstrGroupBy: BSTR): HRESULT {.stdcall.} + get_FolderFlags*: proc(self: ptr IShellFolderViewDual3, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + put_FolderFlags*: proc(self: ptr IShellFolderViewDual3, dwFlags: DWORD): HRESULT {.stdcall.} + get_SortColumns*: proc(self: ptr IShellFolderViewDual3, pbstrSortColumns: ptr BSTR): HRESULT {.stdcall.} + put_SortColumns*: proc(self: ptr IShellFolderViewDual3, bstrSortColumns: BSTR): HRESULT {.stdcall.} + put_IconSize*: proc(self: ptr IShellFolderViewDual3, iIconSize: int32): HRESULT {.stdcall.} + get_IconSize*: proc(self: ptr IShellFolderViewDual3, piIconSize: ptr int32): HRESULT {.stdcall.} + FilterView*: proc(self: ptr IShellFolderViewDual3, bstrFilterText: BSTR): HRESULT {.stdcall.} + IShellDispatch* {.pure.} = object + lpVtbl*: ptr IShellDispatchVtbl + IShellDispatchVtbl* {.pure, inheritable.} = object of IDispatchVtbl + get_Application*: proc(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + get_Parent*: proc(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + NameSpace*: proc(self: ptr IShellDispatch, vDir: VARIANT, ppsdf: ptr ptr Folder): HRESULT {.stdcall.} + BrowseForFolder*: proc(self: ptr IShellDispatch, Hwnd: LONG, Title: BSTR, Options: LONG, RootFolder: VARIANT, ppsdf: ptr ptr Folder): HRESULT {.stdcall.} + Windows*: proc(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.stdcall.} + Open*: proc(self: ptr IShellDispatch, vDir: VARIANT): HRESULT {.stdcall.} + Explore*: proc(self: ptr IShellDispatch, vDir: VARIANT): HRESULT {.stdcall.} + MinimizeAll*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + UndoMinimizeALL*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + FileRun*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + CascadeWindows*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + TileVertically*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + TileHorizontally*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + ShutdownWindows*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + Suspend*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + EjectPC*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + SetTime*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + TrayProperties*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + Help*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + FindFiles*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + FindComputer*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + RefreshMenu*: proc(self: ptr IShellDispatch): HRESULT {.stdcall.} + ControlPanelItem*: proc(self: ptr IShellDispatch, bstrDir: BSTR): HRESULT {.stdcall.} + IShellDispatch2* {.pure.} = object + lpVtbl*: ptr IShellDispatch2Vtbl + IShellDispatch2Vtbl* {.pure, inheritable.} = object of IShellDispatchVtbl + IsRestricted*: proc(self: ptr IShellDispatch2, Group: BSTR, Restriction: BSTR, plRestrictValue: ptr LONG): HRESULT {.stdcall.} + ShellExecute*: proc(self: ptr IShellDispatch2, File: BSTR, vArgs: VARIANT, vDir: VARIANT, vOperation: VARIANT, vShow: VARIANT): HRESULT {.stdcall.} + FindPrinter*: proc(self: ptr IShellDispatch2, name: BSTR, location: BSTR, model: BSTR): HRESULT {.stdcall.} + GetSystemInformation*: proc(self: ptr IShellDispatch2, name: BSTR, pv: ptr VARIANT): HRESULT {.stdcall.} + ServiceStart*: proc(self: ptr IShellDispatch2, ServiceName: BSTR, Persistent: VARIANT, pSuccess: ptr VARIANT): HRESULT {.stdcall.} + ServiceStop*: proc(self: ptr IShellDispatch2, ServiceName: BSTR, Persistent: VARIANT, pSuccess: ptr VARIANT): HRESULT {.stdcall.} + IsServiceRunning*: proc(self: ptr IShellDispatch2, ServiceName: BSTR, pRunning: ptr VARIANT): HRESULT {.stdcall.} + CanStartStopService*: proc(self: ptr IShellDispatch2, ServiceName: BSTR, pCanStartStop: ptr VARIANT): HRESULT {.stdcall.} + ShowBrowserBar*: proc(self: ptr IShellDispatch2, bstrClsid: BSTR, bShow: VARIANT, pSuccess: ptr VARIANT): HRESULT {.stdcall.} + IShellDispatch3* {.pure.} = object + lpVtbl*: ptr IShellDispatch3Vtbl + IShellDispatch3Vtbl* {.pure, inheritable.} = object of IShellDispatch2Vtbl + AddToRecent*: proc(self: ptr IShellDispatch3, varFile: VARIANT, bstrCategory: BSTR): HRESULT {.stdcall.} + IShellDispatch4* {.pure.} = object + lpVtbl*: ptr IShellDispatch4Vtbl + IShellDispatch4Vtbl* {.pure, inheritable.} = object of IShellDispatch3Vtbl + WindowsSecurity*: proc(self: ptr IShellDispatch4): HRESULT {.stdcall.} + ToggleDesktop*: proc(self: ptr IShellDispatch4): HRESULT {.stdcall.} + ExplorerPolicy*: proc(self: ptr IShellDispatch4, bstrPolicyName: BSTR, pValue: ptr VARIANT): HRESULT {.stdcall.} + GetSetting*: proc(self: ptr IShellDispatch4, lSetting: LONG, pResult: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IShellDispatch5* {.pure.} = object + lpVtbl*: ptr IShellDispatch5Vtbl + IShellDispatch5Vtbl* {.pure, inheritable.} = object of IShellDispatch4Vtbl + WindowSwitcher*: proc(self: ptr IShellDispatch5): HRESULT {.stdcall.} + IShellDispatch6* {.pure.} = object + lpVtbl*: ptr IShellDispatch6Vtbl + IShellDispatch6Vtbl* {.pure, inheritable.} = object of IShellDispatch5Vtbl + SearchCommand*: proc(self: ptr IShellDispatch6): HRESULT {.stdcall.} + IFileSearchBand* {.pure.} = object + lpVtbl*: ptr IFileSearchBandVtbl + IFileSearchBandVtbl* {.pure, inheritable.} = object of IDispatchVtbl + SetFocus*: proc(self: ptr IFileSearchBand): HRESULT {.stdcall.} + SetSearchParameters*: proc(self: ptr IFileSearchBand, pbstrSearchID: ptr BSTR, bNavToResults: VARIANT_BOOL, pvarScope: ptr VARIANT, pvarQueryFile: ptr VARIANT): HRESULT {.stdcall.} + get_SearchID*: proc(self: ptr IFileSearchBand, pbstrSearchID: ptr BSTR): HRESULT {.stdcall.} + get_Scope*: proc(self: ptr IFileSearchBand, pvarScope: ptr VARIANT): HRESULT {.stdcall.} + get_QueryFile*: proc(self: ptr IFileSearchBand, pvarFile: ptr VARIANT): HRESULT {.stdcall.} + IWebWizardHost* {.pure.} = object + lpVtbl*: ptr IWebWizardHostVtbl + IWebWizardHostVtbl* {.pure, inheritable.} = object of IDispatchVtbl + FinalBack*: proc(self: ptr IWebWizardHost): HRESULT {.stdcall.} + FinalNext*: proc(self: ptr IWebWizardHost): HRESULT {.stdcall.} + Cancel*: proc(self: ptr IWebWizardHost): HRESULT {.stdcall.} + put_Caption*: proc(self: ptr IWebWizardHost, bstrCaption: BSTR): HRESULT {.stdcall.} + get_Caption*: proc(self: ptr IWebWizardHost, pbstrCaption: ptr BSTR): HRESULT {.stdcall.} + put_Property*: proc(self: ptr IWebWizardHost, bstrPropertyName: BSTR, pvProperty: ptr VARIANT): HRESULT {.stdcall.} + get_Property*: proc(self: ptr IWebWizardHost, bstrPropertyName: BSTR, pvProperty: ptr VARIANT): HRESULT {.stdcall.} + SetWizardButtons*: proc(self: ptr IWebWizardHost, vfEnableBack: VARIANT_BOOL, vfEnableNext: VARIANT_BOOL, vfLastPage: VARIANT_BOOL): HRESULT {.stdcall.} + SetHeaderText*: proc(self: ptr IWebWizardHost, bstrHeaderTitle: BSTR, bstrHeaderSubtitle: BSTR): HRESULT {.stdcall.} + INewWDEvents* {.pure.} = object + lpVtbl*: ptr INewWDEventsVtbl + INewWDEventsVtbl* {.pure, inheritable.} = object of IWebWizardHostVtbl + PassportAuthenticate*: proc(self: ptr INewWDEvents, bstrSignInUrl: BSTR, pvfAuthenitcated: ptr VARIANT_BOOL): HRESULT {.stdcall.} + IDataObjectAsyncCapability* {.pure.} = object + lpVtbl*: ptr IDataObjectAsyncCapabilityVtbl + IDataObjectAsyncCapabilityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAsyncMode*: proc(self: ptr IDataObjectAsyncCapability, fDoOpAsync: WINBOOL): HRESULT {.stdcall.} + GetAsyncMode*: proc(self: ptr IDataObjectAsyncCapability, pfIsOpAsync: ptr WINBOOL): HRESULT {.stdcall.} + StartOperation*: proc(self: ptr IDataObjectAsyncCapability, pbcReserved: ptr IBindCtx): HRESULT {.stdcall.} + InOperation*: proc(self: ptr IDataObjectAsyncCapability, pfInAsyncOp: ptr WINBOOL): HRESULT {.stdcall.} + EndOperation*: proc(self: ptr IDataObjectAsyncCapability, hResult: HRESULT, pbcReserved: ptr IBindCtx, dwEffects: DWORD): HRESULT {.stdcall.} + IObjectArray* {.pure.} = object + lpVtbl*: ptr IObjectArrayVtbl + IObjectArrayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCount*: proc(self: ptr IObjectArray, pcObjects: ptr UINT): HRESULT {.stdcall.} + GetAt*: proc(self: ptr IObjectArray, uiIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IObjectCollection* {.pure.} = object + lpVtbl*: ptr IObjectCollectionVtbl + IObjectCollectionVtbl* {.pure, inheritable.} = object of IObjectArrayVtbl + AddObject*: proc(self: ptr IObjectCollection, punk: ptr IUnknown): HRESULT {.stdcall.} + AddFromArray*: proc(self: ptr IObjectCollection, poaSource: ptr IObjectArray): HRESULT {.stdcall.} + RemoveObjectAt*: proc(self: ptr IObjectCollection, uiIndex: UINT): HRESULT {.stdcall.} + Clear*: proc(self: ptr IObjectCollection): HRESULT {.stdcall.} + IExecuteCommand* {.pure.} = object + lpVtbl*: ptr IExecuteCommandVtbl + IExecuteCommandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetKeyState*: proc(self: ptr IExecuteCommand, grfKeyState: DWORD): HRESULT {.stdcall.} + SetParameters*: proc(self: ptr IExecuteCommand, pszParameters: LPCWSTR): HRESULT {.stdcall.} + SetPosition*: proc(self: ptr IExecuteCommand, pt: POINT): HRESULT {.stdcall.} + SetShowWindow*: proc(self: ptr IExecuteCommand, nShow: int32): HRESULT {.stdcall.} + SetNoShowUI*: proc(self: ptr IExecuteCommand, fNoShowUI: WINBOOL): HRESULT {.stdcall.} + SetDirectory*: proc(self: ptr IExecuteCommand, pszDirectory: LPCWSTR): HRESULT {.stdcall.} + Execute*: proc(self: ptr IExecuteCommand): HRESULT {.stdcall.} + IRunnableTask* {.pure.} = object + lpVtbl*: ptr IRunnableTaskVtbl + IRunnableTaskVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Run*: proc(self: ptr IRunnableTask): HRESULT {.stdcall.} + Kill*: proc(self: ptr IRunnableTask, bWait: WINBOOL): HRESULT {.stdcall.} + Suspend*: proc(self: ptr IRunnableTask): HRESULT {.stdcall.} + Resume*: proc(self: ptr IRunnableTask): HRESULT {.stdcall.} + IsRunning*: proc(self: ptr IRunnableTask): ULONG {.stdcall.} + IShellTaskScheduler* {.pure.} = object + lpVtbl*: ptr IShellTaskSchedulerVtbl + IShellTaskSchedulerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddTask*: proc(self: ptr IShellTaskScheduler, prt: ptr IRunnableTask, rtoid: REFTASKOWNERID, lParam: DWORD_PTR, dwPriority: DWORD): HRESULT {.stdcall.} + RemoveTasks*: proc(self: ptr IShellTaskScheduler, rtoid: REFTASKOWNERID, lParam: DWORD_PTR, bWaitIfRunning: WINBOOL): HRESULT {.stdcall.} + CountTasks*: proc(self: ptr IShellTaskScheduler, rtoid: REFTASKOWNERID): UINT {.stdcall.} + Status*: proc(self: ptr IShellTaskScheduler, dwReleaseStatus: DWORD, dwThreadTimeout: DWORD): HRESULT {.stdcall.} + IQueryCodePage* {.pure.} = object + lpVtbl*: ptr IQueryCodePageVtbl + IQueryCodePageVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCodePage*: proc(self: ptr IQueryCodePage, puiCodePage: ptr UINT): HRESULT {.stdcall.} + SetCodePage*: proc(self: ptr IQueryCodePage, uiCodePage: UINT): HRESULT {.stdcall.} + IPersistFolder2* {.pure.} = object + lpVtbl*: ptr IPersistFolder2Vtbl + IPersistFolder2Vtbl* {.pure, inheritable.} = object of IPersistFolderVtbl + GetCurFolder*: proc(self: ptr IPersistFolder2, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IPersistFolder3* {.pure.} = object + lpVtbl*: ptr IPersistFolder3Vtbl + IPersistFolder3Vtbl* {.pure, inheritable.} = object of IPersistFolder2Vtbl + InitializeEx*: proc(self: ptr IPersistFolder3, pbc: ptr IBindCtx, pidlRoot: PCIDLIST_ABSOLUTE, ppfti: ptr PERSIST_FOLDER_TARGET_INFO): HRESULT {.stdcall.} + GetFolderTargetInfo*: proc(self: ptr IPersistFolder3, ppfti: ptr PERSIST_FOLDER_TARGET_INFO): HRESULT {.stdcall.} + IPersistIDList* {.pure.} = object + lpVtbl*: ptr IPersistIDListVtbl + IPersistIDListVtbl* {.pure, inheritable.} = object of IPersistVtbl + SetIDList*: proc(self: ptr IPersistIDList, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + GetIDList*: proc(self: ptr IPersistIDList, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IEnumFullIDList* {.pure.} = object + lpVtbl*: ptr IEnumFullIDListVtbl + IEnumFullIDListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumFullIDList, celt: ULONG, rgelt: ptr PIDLIST_ABSOLUTE, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumFullIDList, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumFullIDList): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumFullIDList, ppenum: ptr ptr IEnumFullIDList): HRESULT {.stdcall.} + IObjectWithFolderEnumMode* {.pure.} = object + lpVtbl*: ptr IObjectWithFolderEnumModeVtbl + IObjectWithFolderEnumModeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetMode*: proc(self: ptr IObjectWithFolderEnumMode, feMode: FOLDER_ENUM_MODE): HRESULT {.stdcall.} + GetMode*: proc(self: ptr IObjectWithFolderEnumMode, pfeMode: ptr FOLDER_ENUM_MODE): HRESULT {.stdcall.} + IParseAndCreateItem* {.pure.} = object + lpVtbl*: ptr IParseAndCreateItemVtbl + IParseAndCreateItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetItem*: proc(self: ptr IParseAndCreateItem, psi: ptr IShellItem): HRESULT {.stdcall.} + GetItem*: proc(self: ptr IParseAndCreateItem, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IShellFolder2* {.pure.} = object + lpVtbl*: ptr IShellFolder2Vtbl + IShellFolder2Vtbl* {.pure, inheritable.} = object of IShellFolderVtbl + GetDefaultSearchGUID*: proc(self: ptr IShellFolder2, pguid: ptr GUID): HRESULT {.stdcall.} + EnumSearches*: proc(self: ptr IShellFolder2, ppenum: ptr ptr IEnumExtraSearch): HRESULT {.stdcall.} + GetDefaultColumn*: proc(self: ptr IShellFolder2, dwRes: DWORD, pSort: ptr ULONG, pDisplay: ptr ULONG): HRESULT {.stdcall.} + GetDefaultColumnState*: proc(self: ptr IShellFolder2, iColumn: UINT, pcsFlags: ptr SHCOLSTATEF): HRESULT {.stdcall.} + GetDetailsEx*: proc(self: ptr IShellFolder2, pidl: PCUITEMID_CHILD, pscid: ptr SHCOLUMNID, pv: ptr VARIANT): HRESULT {.stdcall.} + GetDetailsOf*: proc(self: ptr IShellFolder2, pidl: PCUITEMID_CHILD, iColumn: UINT, psd: ptr SHELLDETAILS): HRESULT {.stdcall.} + MapColumnToSCID*: proc(self: ptr IShellFolder2, iColumn: UINT, pscid: ptr SHCOLUMNID): HRESULT {.stdcall.} + IFolderViewOptions* {.pure.} = object + lpVtbl*: ptr IFolderViewOptionsVtbl + IFolderViewOptionsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFolderViewOptions*: proc(self: ptr IFolderViewOptions, fvoMask: FOLDERVIEWOPTIONS, fvoFlags: FOLDERVIEWOPTIONS): HRESULT {.stdcall.} + GetFolderViewOptions*: proc(self: ptr IFolderViewOptions, pfvoFlags: ptr FOLDERVIEWOPTIONS): HRESULT {.stdcall.} + IShellView2* {.pure.} = object + lpVtbl*: ptr IShellView2Vtbl + IShellView2Vtbl* {.pure, inheritable.} = object of IShellViewVtbl + GetView*: proc(self: ptr IShellView2, pvid: ptr SHELLVIEWID, uView: ULONG): HRESULT {.stdcall.} + CreateViewWindow2*: proc(self: ptr IShellView2, lpParams: LPSV2CVW2_PARAMS): HRESULT {.stdcall.} + HandleRename*: proc(self: ptr IShellView2, pidlNew: PCUITEMID_CHILD): HRESULT {.stdcall.} + SelectAndPositionItem*: proc(self: ptr IShellView2, pidlItem: PCUITEMID_CHILD, uFlags: UINT, ppt: ptr POINT): HRESULT {.stdcall.} + IShellView3* {.pure.} = object + lpVtbl*: ptr IShellView3Vtbl + IShellView3Vtbl* {.pure, inheritable.} = object of IShellView2Vtbl + CreateViewWindow3*: proc(self: ptr IShellView3, psbOwner: ptr IShellBrowser, psvPrev: ptr IShellView, dwViewFlags: SV3CVW3_FLAGS, dwMask: FOLDERFLAGS, dwFlags: FOLDERFLAGS, fvMode: FOLDERVIEWMODE, pvid: ptr SHELLVIEWID, prcView: ptr RECT, phwndView: ptr HWND): HRESULT {.stdcall.} + IFolderView* {.pure.} = object + lpVtbl*: ptr IFolderViewVtbl + IFolderViewVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentViewMode*: proc(self: ptr IFolderView, pViewMode: ptr UINT): HRESULT {.stdcall.} + SetCurrentViewMode*: proc(self: ptr IFolderView, ViewMode: UINT): HRESULT {.stdcall.} + GetFolder*: proc(self: ptr IFolderView, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + Item*: proc(self: ptr IFolderView, iItemIndex: int32, ppidl: ptr PITEMID_CHILD): HRESULT {.stdcall.} + ItemCount*: proc(self: ptr IFolderView, uFlags: UINT, pcItems: ptr int32): HRESULT {.stdcall.} + Items*: proc(self: ptr IFolderView, uFlags: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetSelectionMarkedItem*: proc(self: ptr IFolderView, piItem: ptr int32): HRESULT {.stdcall.} + GetFocusedItem*: proc(self: ptr IFolderView, piItem: ptr int32): HRESULT {.stdcall.} + GetItemPosition*: proc(self: ptr IFolderView, pidl: PCUITEMID_CHILD, ppt: ptr POINT): HRESULT {.stdcall.} + GetSpacing*: proc(self: ptr IFolderView, ppt: ptr POINT): HRESULT {.stdcall.} + GetDefaultSpacing*: proc(self: ptr IFolderView, ppt: ptr POINT): HRESULT {.stdcall.} + GetAutoArrange*: proc(self: ptr IFolderView): HRESULT {.stdcall.} + SelectItem*: proc(self: ptr IFolderView, iItem: int32, dwFlags: DWORD): HRESULT {.stdcall.} + SelectAndPositionItems*: proc(self: ptr IFolderView, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, apt: ptr POINT, dwFlags: DWORD): HRESULT {.stdcall.} + ISearchBoxInfo* {.pure.} = object + lpVtbl*: ptr ISearchBoxInfoVtbl + ISearchBoxInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCondition*: proc(self: ptr ISearchBoxInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetText*: proc(self: ptr ISearchBoxInfo, ppsz: ptr LPWSTR): HRESULT {.stdcall.} + IEnumShellItems* {.pure.} = object + lpVtbl*: ptr IEnumShellItemsVtbl + IEnumShellItemsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumShellItems, celt: ULONG, rgelt: ptr ptr IShellItem, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumShellItems, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumShellItems): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumShellItems, ppenum: ptr ptr IEnumShellItems): HRESULT {.stdcall.} + IShellItemArray* {.pure.} = object + lpVtbl*: ptr IShellItemArrayVtbl + IShellItemArrayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BindToHandler*: proc(self: ptr IShellItemArray, pbc: ptr IBindCtx, bhid: REFGUID, riid: REFIID, ppvOut: ptr pointer): HRESULT {.stdcall.} + GetPropertyStore*: proc(self: ptr IShellItemArray, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyDescriptionList*: proc(self: ptr IShellItemArray, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetAttributes*: proc(self: ptr IShellItemArray, AttribFlags: SIATTRIBFLAGS, sfgaoMask: SFGAOF, psfgaoAttribs: ptr SFGAOF): HRESULT {.stdcall.} + GetCount*: proc(self: ptr IShellItemArray, pdwNumItems: ptr DWORD): HRESULT {.stdcall.} + GetItemAt*: proc(self: ptr IShellItemArray, dwIndex: DWORD, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + EnumItems*: proc(self: ptr IShellItemArray, ppenumShellItems: ptr ptr IEnumShellItems): HRESULT {.stdcall.} + IFolderView2* {.pure.} = object + lpVtbl*: ptr IFolderView2Vtbl + IFolderView2Vtbl* {.pure, inheritable.} = object of IFolderViewVtbl + SetGroupBy*: proc(self: ptr IFolderView2, key: REFPROPERTYKEY, fAscending: WINBOOL): HRESULT {.stdcall.} + GetGroupBy*: proc(self: ptr IFolderView2, pkey: ptr PROPERTYKEY, pfAscending: ptr WINBOOL): HRESULT {.stdcall.} + SetViewProperty*: proc(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT): HRESULT {.stdcall.} + GetViewProperty*: proc(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, propkey: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + SetTileViewProperties*: proc(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pszPropList: LPCWSTR): HRESULT {.stdcall.} + SetExtendedTileViewProperties*: proc(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pszPropList: LPCWSTR): HRESULT {.stdcall.} + SetText*: proc(self: ptr IFolderView2, iType: FVTEXTTYPE, pwszText: LPCWSTR): HRESULT {.stdcall.} + SetCurrentFolderFlags*: proc(self: ptr IFolderView2, dwMask: DWORD, dwFlags: DWORD): HRESULT {.stdcall.} + GetCurrentFolderFlags*: proc(self: ptr IFolderView2, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + GetSortColumnCount*: proc(self: ptr IFolderView2, pcColumns: ptr int32): HRESULT {.stdcall.} + SetSortColumns*: proc(self: ptr IFolderView2, rgSortColumns: ptr SORTCOLUMN, cColumns: int32): HRESULT {.stdcall.} + GetSortColumns*: proc(self: ptr IFolderView2, rgSortColumns: ptr SORTCOLUMN, cColumns: int32): HRESULT {.stdcall.} + GetItem*: proc(self: ptr IFolderView2, iItem: int32, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetVisibleItem*: proc(self: ptr IFolderView2, iStart: int32, fPrevious: WINBOOL, piItem: ptr int32): HRESULT {.stdcall.} + GetSelectedItem*: proc(self: ptr IFolderView2, iStart: int32, piItem: ptr int32): HRESULT {.stdcall.} + GetSelection*: proc(self: ptr IFolderView2, fNoneImpliesFolder: WINBOOL, ppsia: ptr ptr IShellItemArray): HRESULT {.stdcall.} + GetSelectionState*: proc(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + InvokeVerbOnSelection*: proc(self: ptr IFolderView2, pszVerb: LPCSTR): HRESULT {.stdcall.} + SetViewModeAndIconSize*: proc(self: ptr IFolderView2, uViewMode: FOLDERVIEWMODE, iImageSize: int32): HRESULT {.stdcall.} + GetViewModeAndIconSize*: proc(self: ptr IFolderView2, puViewMode: ptr FOLDERVIEWMODE, piImageSize: ptr int32): HRESULT {.stdcall.} + SetGroupSubsetCount*: proc(self: ptr IFolderView2, cVisibleRows: UINT): HRESULT {.stdcall.} + GetGroupSubsetCount*: proc(self: ptr IFolderView2, pcVisibleRows: ptr UINT): HRESULT {.stdcall.} + SetRedraw*: proc(self: ptr IFolderView2, fRedrawOn: WINBOOL): HRESULT {.stdcall.} + IsMoveInSameFolder*: proc(self: ptr IFolderView2): HRESULT {.stdcall.} + DoRename*: proc(self: ptr IFolderView2): HRESULT {.stdcall.} + IFolderViewSettings* {.pure.} = object + lpVtbl*: ptr IFolderViewSettingsVtbl + IFolderViewSettingsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetColumnPropertyList*: proc(self: ptr IFolderViewSettings, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetGroupByProperty*: proc(self: ptr IFolderViewSettings, pkey: ptr PROPERTYKEY, pfGroupAscending: ptr WINBOOL): HRESULT {.stdcall.} + GetViewMode*: proc(self: ptr IFolderViewSettings, plvm: ptr FOLDERLOGICALVIEWMODE): HRESULT {.stdcall.} + GetIconSize*: proc(self: ptr IFolderViewSettings, puIconSize: ptr UINT): HRESULT {.stdcall.} + GetFolderFlags*: proc(self: ptr IFolderViewSettings, pfolderMask: ptr FOLDERFLAGS, pfolderFlags: ptr FOLDERFLAGS): HRESULT {.stdcall.} + GetSortColumns*: proc(self: ptr IFolderViewSettings, rgSortColumns: ptr SORTCOLUMN, cColumnsIn: UINT, pcColumnsOut: ptr UINT): HRESULT {.stdcall.} + GetGroupSubsetCount*: proc(self: ptr IFolderViewSettings, pcVisibleRows: ptr UINT): HRESULT {.stdcall.} + IPreviewHandlerVisuals* {.pure.} = object + lpVtbl*: ptr IPreviewHandlerVisualsVtbl + IPreviewHandlerVisualsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetBackgroundColor*: proc(self: ptr IPreviewHandlerVisuals, color: COLORREF): HRESULT {.stdcall.} + SetFont*: proc(self: ptr IPreviewHandlerVisuals, plf: ptr LOGFONTW): HRESULT {.stdcall.} + SetTextColor*: proc(self: ptr IPreviewHandlerVisuals, color: COLORREF): HRESULT {.stdcall.} + IVisualProperties* {.pure.} = object + lpVtbl*: ptr IVisualPropertiesVtbl + IVisualPropertiesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetWatermark*: proc(self: ptr IVisualProperties, hbmp: HBITMAP, vpwf: VPWATERMARKFLAGS): HRESULT {.stdcall.} + SetColor*: proc(self: ptr IVisualProperties, vpcf: VPCOLORFLAGS, cr: COLORREF): HRESULT {.stdcall.} + GetColor*: proc(self: ptr IVisualProperties, vpcf: VPCOLORFLAGS, pcr: ptr COLORREF): HRESULT {.stdcall.} + SetItemHeight*: proc(self: ptr IVisualProperties, cyItemInPixels: int32): HRESULT {.stdcall.} + GetItemHeight*: proc(self: ptr IVisualProperties, cyItemInPixels: ptr int32): HRESULT {.stdcall.} + SetFont*: proc(self: ptr IVisualProperties, plf: ptr LOGFONTW, bRedraw: WINBOOL): HRESULT {.stdcall.} + GetFont*: proc(self: ptr IVisualProperties, plf: ptr LOGFONTW): HRESULT {.stdcall.} + SetTheme*: proc(self: ptr IVisualProperties, pszSubAppName: LPCWSTR, pszSubIdList: LPCWSTR): HRESULT {.stdcall.} + ICommDlgBrowser3* {.pure.} = object + lpVtbl*: ptr ICommDlgBrowser3Vtbl + ICommDlgBrowser3Vtbl* {.pure, inheritable.} = object of ICommDlgBrowser2Vtbl + OnColumnClicked*: proc(self: ptr ICommDlgBrowser3, ppshv: ptr IShellView, iColumn: int32): HRESULT {.stdcall.} + GetCurrentFilter*: proc(self: ptr ICommDlgBrowser3, pszFileSpec: LPWSTR, cchFileSpec: int32): HRESULT {.stdcall.} + OnPreViewCreated*: proc(self: ptr ICommDlgBrowser3, ppshv: ptr IShellView): HRESULT {.stdcall.} + IColumnManager* {.pure.} = object + lpVtbl*: ptr IColumnManagerVtbl + IColumnManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetColumnInfo*: proc(self: ptr IColumnManager, propkey: REFPROPERTYKEY, pcmci: ptr CM_COLUMNINFO): HRESULT {.stdcall.} + GetColumnInfo*: proc(self: ptr IColumnManager, propkey: REFPROPERTYKEY, pcmci: ptr CM_COLUMNINFO): HRESULT {.stdcall.} + GetColumnCount*: proc(self: ptr IColumnManager, dwFlags: CM_ENUM_FLAGS, puCount: ptr UINT): HRESULT {.stdcall.} + GetColumns*: proc(self: ptr IColumnManager, dwFlags: CM_ENUM_FLAGS, rgkeyOrder: ptr PROPERTYKEY, cColumns: UINT): HRESULT {.stdcall.} + SetColumns*: proc(self: ptr IColumnManager, rgkeyOrder: ptr PROPERTYKEY, cVisible: UINT): HRESULT {.stdcall.} + IFolderFilterSite* {.pure.} = object + lpVtbl*: ptr IFolderFilterSiteVtbl + IFolderFilterSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFilter*: proc(self: ptr IFolderFilterSite, punk: ptr IUnknown): HRESULT {.stdcall.} + IFolderFilter* {.pure.} = object + lpVtbl*: ptr IFolderFilterVtbl + IFolderFilterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShouldShow*: proc(self: ptr IFolderFilter, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, pidlItem: PCUITEMID_CHILD): HRESULT {.stdcall.} + GetEnumFlags*: proc(self: ptr IFolderFilter, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, phwnd: ptr HWND, pgrfFlags: ptr DWORD): HRESULT {.stdcall.} + IInputObjectSite* {.pure.} = object + lpVtbl*: ptr IInputObjectSiteVtbl + IInputObjectSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnFocusChangeIS*: proc(self: ptr IInputObjectSite, punkObj: ptr IUnknown, fSetFocus: WINBOOL): HRESULT {.stdcall.} + IInputObject* {.pure.} = object + lpVtbl*: ptr IInputObjectVtbl + IInputObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + UIActivateIO*: proc(self: ptr IInputObject, fActivate: WINBOOL, pMsg: ptr MSG): HRESULT {.stdcall.} + HasFocusIO*: proc(self: ptr IInputObject): HRESULT {.stdcall.} + TranslateAcceleratorIO*: proc(self: ptr IInputObject, pMsg: ptr MSG): HRESULT {.stdcall.} + IInputObject2* {.pure.} = object + lpVtbl*: ptr IInputObject2Vtbl + IInputObject2Vtbl* {.pure, inheritable.} = object of IInputObjectVtbl + TranslateAcceleratorGlobal*: proc(self: ptr IInputObject2, pMsg: ptr MSG): HRESULT {.stdcall.} + IShellIcon* {.pure.} = object + lpVtbl*: ptr IShellIconVtbl + IShellIconVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetIconOf*: proc(self: ptr IShellIcon, pidl: PCUITEMID_CHILD, flags: UINT, pIconIndex: ptr int32): HRESULT {.stdcall.} + IProfferService* {.pure.} = object + lpVtbl*: ptr IProfferServiceVtbl + IProfferServiceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ProfferService*: proc(self: ptr IProfferService, guidService: REFGUID, psp: ptr IServiceProvider, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + RevokeService*: proc(self: ptr IProfferService, dwCookie: DWORD): HRESULT {.stdcall.} + IShellItem2* {.pure.} = object + lpVtbl*: ptr IShellItem2Vtbl + IShellItem2Vtbl* {.pure, inheritable.} = object of IShellItemVtbl + GetPropertyStore*: proc(self: ptr IShellItem2, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyStoreWithCreateObject*: proc(self: ptr IShellItem2, flags: GETPROPERTYSTOREFLAGS, punkCreateObject: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyStoreForKeys*: proc(self: ptr IShellItem2, rgKeys: ptr PROPERTYKEY, cKeys: UINT, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPropertyDescriptionList*: proc(self: ptr IShellItem2, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + Update*: proc(self: ptr IShellItem2, pbc: ptr IBindCtx): HRESULT {.stdcall.} + GetProperty*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.stdcall.} + GetCLSID*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pclsid: ptr CLSID): HRESULT {.stdcall.} + GetFileTime*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pft: ptr FILETIME): HRESULT {.stdcall.} + GetInt32*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pi: ptr int32): HRESULT {.stdcall.} + GetString*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, ppsz: ptr LPWSTR): HRESULT {.stdcall.} + GetUInt32*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pui: ptr ULONG): HRESULT {.stdcall.} + GetUInt64*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pull: ptr ULONGLONG): HRESULT {.stdcall.} + GetBool*: proc(self: ptr IShellItem2, key: REFPROPERTYKEY, pf: ptr WINBOOL): HRESULT {.stdcall.} + IShellItemImageFactory* {.pure.} = object + lpVtbl*: ptr IShellItemImageFactoryVtbl + IShellItemImageFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetImage*: proc(self: ptr IShellItemImageFactory, size: SIZE, flags: SIIGBF, phbm: ptr HBITMAP): HRESULT {.stdcall.} + IUserAccountChangeCallback* {.pure.} = object + lpVtbl*: ptr IUserAccountChangeCallbackVtbl + IUserAccountChangeCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnPictureChange*: proc(self: ptr IUserAccountChangeCallback, pszUserName: LPCWSTR): HRESULT {.stdcall.} + ITransferAdviseSink* {.pure.} = object + lpVtbl*: ptr ITransferAdviseSinkVtbl + ITransferAdviseSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + UpdateProgress*: proc(self: ptr ITransferAdviseSink, ullSizeCurrent: ULONGLONG, ullSizeTotal: ULONGLONG, nFilesCurrent: int32, nFilesTotal: int32, nFoldersCurrent: int32, nFoldersTotal: int32): HRESULT {.stdcall.} + UpdateTransferState*: proc(self: ptr ITransferAdviseSink, ts: TRANSFER_ADVISE_STATE): HRESULT {.stdcall.} + ConfirmOverwrite*: proc(self: ptr ITransferAdviseSink, psiSource: ptr IShellItem, psiDestParent: ptr IShellItem, pszName: LPCWSTR): HRESULT {.stdcall.} + ConfirmEncryptionLoss*: proc(self: ptr ITransferAdviseSink, psiSource: ptr IShellItem): HRESULT {.stdcall.} + FileFailure*: proc(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pszItem: LPCWSTR, hrError: HRESULT, pszRename: LPWSTR, cchRename: ULONG): HRESULT {.stdcall.} + SubStreamFailure*: proc(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pszStreamName: LPCWSTR, hrError: HRESULT): HRESULT {.stdcall.} + PropertyFailure*: proc(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pkey: ptr PROPERTYKEY, hrError: HRESULT): HRESULT {.stdcall.} + ITransferSource* {.pure.} = object + lpVtbl*: ptr ITransferSourceVtbl + ITransferSourceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr ITransferSource, psink: ptr ITransferAdviseSink, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr ITransferSource, dwCookie: DWORD): HRESULT {.stdcall.} + SetProperties*: proc(self: ptr ITransferSource, pproparray: ptr IPropertyChangeArray): HRESULT {.stdcall.} + OpenItem*: proc(self: ptr ITransferSource, psi: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + MoveItem*: proc(self: ptr ITransferSource, psi: ptr IShellItem, psiParentDst: ptr IShellItem, pszNameDst: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNew: ptr ptr IShellItem): HRESULT {.stdcall.} + RecycleItem*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.stdcall.} + RemoveItem*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS): HRESULT {.stdcall.} + RenameItem*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, pszNewName: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.stdcall.} + LinkItem*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, pszNewName: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.stdcall.} + ApplyPropertiesToItem*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, ppsiNew: ptr ptr IShellItem): HRESULT {.stdcall.} + GetDefaultDestinationName*: proc(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, ppszDestinationName: ptr LPWSTR): HRESULT {.stdcall.} + EnterFolder*: proc(self: ptr ITransferSource, psiChildFolderDest: ptr IShellItem): HRESULT {.stdcall.} + LeaveFolder*: proc(self: ptr ITransferSource, psiChildFolderDest: ptr IShellItem): HRESULT {.stdcall.} + IEnumResources* {.pure.} = object + lpVtbl*: ptr IEnumResourcesVtbl + IEnumResourcesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumResources, celt: ULONG, psir: ptr SHELL_ITEM_RESOURCE, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumResources, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumResources): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumResources, ppenumr: ptr ptr IEnumResources): HRESULT {.stdcall.} + IShellItemResources* {.pure.} = object + lpVtbl*: ptr IShellItemResourcesVtbl + IShellItemResourcesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetAttributes*: proc(self: ptr IShellItemResources, pdwAttributes: ptr DWORD): HRESULT {.stdcall.} + GetSize*: proc(self: ptr IShellItemResources, pullSize: ptr ULONGLONG): HRESULT {.stdcall.} + GetTimes*: proc(self: ptr IShellItemResources, pftCreation: ptr FILETIME, pftWrite: ptr FILETIME, pftAccess: ptr FILETIME): HRESULT {.stdcall.} + SetTimes*: proc(self: ptr IShellItemResources, pftCreation: ptr FILETIME, pftWrite: ptr FILETIME, pftAccess: ptr FILETIME): HRESULT {.stdcall.} + GetResourceDescription*: proc(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, ppszDescription: ptr LPWSTR): HRESULT {.stdcall.} + EnumResources*: proc(self: ptr IShellItemResources, ppenumr: ptr ptr IEnumResources): HRESULT {.stdcall.} + SupportsResource*: proc(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE): HRESULT {.stdcall.} + OpenResource*: proc(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + CreateResource*: proc(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + MarkForDelete*: proc(self: ptr IShellItemResources): HRESULT {.stdcall.} + ITransferDestination* {.pure.} = object + lpVtbl*: ptr ITransferDestinationVtbl + ITransferDestinationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr ITransferDestination, psink: ptr ITransferAdviseSink, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr ITransferDestination, dwCookie: DWORD): HRESULT {.stdcall.} + CreateItem*: proc(self: ptr ITransferDestination, pszName: LPCWSTR, dwAttributes: DWORD, ullSize: ULONGLONG, flags: TRANSFER_SOURCE_FLAGS, riidItem: REFIID, ppvItem: ptr pointer, riidResources: REFIID, ppvResources: ptr pointer): HRESULT {.stdcall.} + IStreamAsync* {.pure.} = object + lpVtbl*: ptr IStreamAsyncVtbl + IStreamAsyncVtbl* {.pure, inheritable.} = object of IStreamVtbl + ReadAsync*: proc(self: ptr IStreamAsync, pv: pointer, cb: DWORD, pcbRead: LPDWORD, lpOverlapped: LPOVERLAPPED): HRESULT {.stdcall.} + WriteAsync*: proc(self: ptr IStreamAsync, lpBuffer: pointer, cb: DWORD, pcbWritten: LPDWORD, lpOverlapped: LPOVERLAPPED): HRESULT {.stdcall.} + OverlappedResult*: proc(self: ptr IStreamAsync, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: WINBOOL): HRESULT {.stdcall.} + CancelIo*: proc(self: ptr IStreamAsync): HRESULT {.stdcall.} + IStreamUnbufferedInfo* {.pure.} = object + lpVtbl*: ptr IStreamUnbufferedInfoVtbl + IStreamUnbufferedInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSectorSize*: proc(self: ptr IStreamUnbufferedInfo, pcbSectorSize: ptr ULONG): HRESULT {.stdcall.} + IFileOperationProgressSink* {.pure.} = object + lpVtbl*: ptr IFileOperationProgressSinkVtbl + IFileOperationProgressSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartOperations*: proc(self: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + FinishOperations*: proc(self: ptr IFileOperationProgressSink, hrResult: HRESULT): HRESULT {.stdcall.} + PreRenameItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.stdcall.} + PostRenameItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, pszNewName: LPCWSTR, hrRename: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.stdcall.} + PreMoveItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.stdcall.} + PostMoveItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.stdcall.} + PreCopyItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.stdcall.} + PostCopyItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, hrCopy: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.stdcall.} + PreDeleteItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem): HRESULT {.stdcall.} + PostDeleteItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, hrDelete: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.stdcall.} + PreNewItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.stdcall.} + PostNewItem*: proc(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, pszTemplateName: LPCWSTR, dwFileAttributes: DWORD, hrNew: HRESULT, psiNewItem: ptr IShellItem): HRESULT {.stdcall.} + UpdateProgress*: proc(self: ptr IFileOperationProgressSink, iWorkTotal: UINT, iWorkSoFar: UINT): HRESULT {.stdcall.} + ResetTimer*: proc(self: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + PauseTimer*: proc(self: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + ResumeTimer*: proc(self: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + IInitializeWithItem* {.pure.} = object + lpVtbl*: ptr IInitializeWithItemVtbl + IInitializeWithItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithItem, psi: ptr IShellItem, grfMode: DWORD): HRESULT {.stdcall.} + IObjectWithSelection* {.pure.} = object + lpVtbl*: ptr IObjectWithSelectionVtbl + IObjectWithSelectionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetSelection*: proc(self: ptr IObjectWithSelection, psia: ptr IShellItemArray): HRESULT {.stdcall.} + GetSelection*: proc(self: ptr IObjectWithSelection, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IObjectWithBackReferences* {.pure.} = object + lpVtbl*: ptr IObjectWithBackReferencesVtbl + IObjectWithBackReferencesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RemoveBackReferences*: proc(self: ptr IObjectWithBackReferences): HRESULT {.stdcall.} + IPropertyUI* {.pure.} = object + lpVtbl*: ptr IPropertyUIVtbl + IPropertyUIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ParsePropertyName*: proc(self: ptr IPropertyUI, pszName: LPCWSTR, pfmtid: ptr FMTID, ppid: ptr PROPID, pchEaten: ptr ULONG): HRESULT {.stdcall.} + GetCannonicalName*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszText: LPWSTR, cchText: DWORD): HRESULT {.stdcall.} + GetDisplayName*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, flags: PROPERTYUI_NAME_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {.stdcall.} + GetPropertyDescription*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszText: LPWSTR, cchText: DWORD): HRESULT {.stdcall.} + GetDefaultWidth*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pcxChars: ptr ULONG): HRESULT {.stdcall.} + GetFlags*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pflags: ptr PROPERTYUI_FLAGS): HRESULT {.stdcall.} + FormatForDisplay*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, ppropvar: ptr PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {.stdcall.} + GetHelpInfo*: proc(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszHelpFile: LPWSTR, cch: DWORD, puHelpID: ptr UINT): HRESULT {.stdcall.} + ICategoryProvider* {.pure.} = object + lpVtbl*: ptr ICategoryProviderVtbl + ICategoryProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CanCategorizeOnSCID*: proc(self: ptr ICategoryProvider, pscid: ptr SHCOLUMNID): HRESULT {.stdcall.} + GetDefaultCategory*: proc(self: ptr ICategoryProvider, pguid: ptr GUID, pscid: ptr SHCOLUMNID): HRESULT {.stdcall.} + GetCategoryForSCID*: proc(self: ptr ICategoryProvider, pscid: ptr SHCOLUMNID, pguid: ptr GUID): HRESULT {.stdcall.} + EnumCategories*: proc(self: ptr ICategoryProvider, penum: ptr ptr IEnumGUID): HRESULT {.stdcall.} + GetCategoryName*: proc(self: ptr ICategoryProvider, pguid: ptr GUID, pszName: LPWSTR, cch: UINT): HRESULT {.stdcall.} + CreateCategory*: proc(self: ptr ICategoryProvider, pguid: ptr GUID, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + ICategorizer* {.pure.} = object + lpVtbl*: ptr ICategorizerVtbl + ICategorizerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDescription*: proc(self: ptr ICategorizer, pszDesc: LPWSTR, cch: UINT): HRESULT {.stdcall.} + GetCategory*: proc(self: ptr ICategorizer, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, rgCategoryIds: ptr DWORD): HRESULT {.stdcall.} + GetCategoryInfo*: proc(self: ptr ICategorizer, dwCategoryId: DWORD, pci: ptr TCATEGORY_INFO): HRESULT {.stdcall.} + CompareCategory*: proc(self: ptr ICategorizer, csfFlags: CATSORT_FLAGS, dwCategoryId1: DWORD, dwCategoryId2: DWORD): HRESULT {.stdcall.} + IDropTargetHelper* {.pure.} = object + lpVtbl*: ptr IDropTargetHelperVtbl + IDropTargetHelperVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DragEnter*: proc(self: ptr IDropTargetHelper, hwndTarget: HWND, pDataObject: ptr IDataObject, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.stdcall.} + DragLeave*: proc(self: ptr IDropTargetHelper): HRESULT {.stdcall.} + DragOver*: proc(self: ptr IDropTargetHelper, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.stdcall.} + Drop*: proc(self: ptr IDropTargetHelper, pDataObject: ptr IDataObject, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.stdcall.} + Show*: proc(self: ptr IDropTargetHelper, fShow: WINBOOL): HRESULT {.stdcall.} + IDragSourceHelper* {.pure.} = object + lpVtbl*: ptr IDragSourceHelperVtbl + IDragSourceHelperVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitializeFromBitmap*: proc(self: ptr IDragSourceHelper, pshdi: LPSHDRAGIMAGE, pDataObject: ptr IDataObject): HRESULT {.stdcall.} + InitializeFromWindow*: proc(self: ptr IDragSourceHelper, hwnd: HWND, ppt: ptr POINT, pDataObject: ptr IDataObject): HRESULT {.stdcall.} + IDragSourceHelper2* {.pure.} = object + lpVtbl*: ptr IDragSourceHelper2Vtbl + IDragSourceHelper2Vtbl* {.pure, inheritable.} = object of IDragSourceHelperVtbl + SetFlags*: proc(self: ptr IDragSourceHelper2, dwFlags: DWORD): HRESULT {.stdcall.} + IShellLinkDataList* {.pure.} = object + lpVtbl*: ptr IShellLinkDataListVtbl + IShellLinkDataListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddDataBlock*: proc(self: ptr IShellLinkDataList, pDataBlock: pointer): HRESULT {.stdcall.} + CopyDataBlock*: proc(self: ptr IShellLinkDataList, dwSig: DWORD, ppDataBlock: ptr pointer): HRESULT {.stdcall.} + RemoveDataBlock*: proc(self: ptr IShellLinkDataList, dwSig: DWORD): HRESULT {.stdcall.} + GetFlags*: proc(self: ptr IShellLinkDataList, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + SetFlags*: proc(self: ptr IShellLinkDataList, dwFlags: DWORD): HRESULT {.stdcall.} + IResolveShellLink* {.pure.} = object + lpVtbl*: ptr IResolveShellLinkVtbl + IResolveShellLinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ResolveShellLink*: proc(self: ptr IResolveShellLink, punkLink: ptr IUnknown, hwnd: HWND, fFlags: DWORD): HRESULT {.stdcall.} + IActionProgressDialog* {.pure.} = object + lpVtbl*: ptr IActionProgressDialogVtbl + IActionProgressDialogVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IActionProgressDialog, flags: SPINITF, pszTitle: LPCWSTR, pszCancel: LPCWSTR): HRESULT {.stdcall.} + Stop*: proc(self: ptr IActionProgressDialog): HRESULT {.stdcall.} + IHWEventHandler* {.pure.} = object + lpVtbl*: ptr IHWEventHandlerVtbl + IHWEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IHWEventHandler, pszParams: LPCWSTR): HRESULT {.stdcall.} + HandleEvent*: proc(self: ptr IHWEventHandler, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR): HRESULT {.stdcall.} + HandleEventWithContent*: proc(self: ptr IHWEventHandler, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR, pszContentTypeHandler: LPCWSTR, pdataobject: ptr IDataObject): HRESULT {.stdcall.} + IHWEventHandler2* {.pure.} = object + lpVtbl*: ptr IHWEventHandler2Vtbl + IHWEventHandler2Vtbl* {.pure, inheritable.} = object of IHWEventHandlerVtbl + HandleEventWithHWND*: proc(self: ptr IHWEventHandler2, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR, hwndOwner: HWND): HRESULT {.stdcall.} + IQueryCancelAutoPlay* {.pure.} = object + lpVtbl*: ptr IQueryCancelAutoPlayVtbl + IQueryCancelAutoPlayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AllowAutoPlay*: proc(self: ptr IQueryCancelAutoPlay, pszPath: LPCWSTR, dwContentType: DWORD, pszLabel: LPCWSTR, dwSerialNumber: DWORD): HRESULT {.stdcall.} + IDynamicHWHandler* {.pure.} = object + lpVtbl*: ptr IDynamicHWHandlerVtbl + IDynamicHWHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDynamicInfo*: proc(self: ptr IDynamicHWHandler, pszDeviceID: LPCWSTR, dwContentType: DWORD, ppszAction: ptr LPWSTR): HRESULT {.stdcall.} + IActionProgress* {.pure.} = object + lpVtbl*: ptr IActionProgressVtbl + IActionProgressVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Begin*: proc(self: ptr IActionProgress, action: SPACTION, flags: SPBEGINF): HRESULT {.stdcall.} + UpdateProgress*: proc(self: ptr IActionProgress, ulCompleted: ULONGLONG, ulTotal: ULONGLONG): HRESULT {.stdcall.} + UpdateText*: proc(self: ptr IActionProgress, sptext: SPTEXT, pszText: LPCWSTR, fMayCompact: WINBOOL): HRESULT {.stdcall.} + QueryCancel*: proc(self: ptr IActionProgress, pfCancelled: ptr WINBOOL): HRESULT {.stdcall.} + ResetCancel*: proc(self: ptr IActionProgress): HRESULT {.stdcall.} + End*: proc(self: ptr IActionProgress): HRESULT {.stdcall.} + IRemoteComputer* {.pure.} = object + lpVtbl*: ptr IRemoteComputerVtbl + IRemoteComputerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IRemoteComputer, pszMachine: LPCWSTR, bEnumerating: WINBOOL): HRESULT {.stdcall.} + IQueryContinue* {.pure.} = object + lpVtbl*: ptr IQueryContinueVtbl + IQueryContinueVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryContinue*: proc(self: ptr IQueryContinue): HRESULT {.stdcall.} + IObjectWithCancelEvent* {.pure.} = object + lpVtbl*: ptr IObjectWithCancelEventVtbl + IObjectWithCancelEventVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCancelEvent*: proc(self: ptr IObjectWithCancelEvent, phEvent: ptr HANDLE): HRESULT {.stdcall.} + IUserNotification* {.pure.} = object + lpVtbl*: ptr IUserNotificationVtbl + IUserNotificationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetBalloonInfo*: proc(self: ptr IUserNotification, pszTitle: LPCWSTR, pszText: LPCWSTR, dwInfoFlags: DWORD): HRESULT {.stdcall.} + SetBalloonRetry*: proc(self: ptr IUserNotification, dwShowTime: DWORD, dwInterval: DWORD, cRetryCount: UINT): HRESULT {.stdcall.} + SetIconInfo*: proc(self: ptr IUserNotification, hIcon: HICON, pszToolTip: LPCWSTR): HRESULT {.stdcall.} + Show*: proc(self: ptr IUserNotification, pqc: ptr IQueryContinue, dwContinuePollInterval: DWORD): HRESULT {.stdcall.} + PlaySound*: proc(self: ptr IUserNotification, pszSoundName: LPCWSTR): HRESULT {.stdcall.} + IUserNotificationCallback* {.pure.} = object + lpVtbl*: ptr IUserNotificationCallbackVtbl + IUserNotificationCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnBalloonUserClick*: proc(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.stdcall.} + OnLeftClick*: proc(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.stdcall.} + OnContextMenu*: proc(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.stdcall.} + IUserNotification2* {.pure.} = object + lpVtbl*: ptr IUserNotification2Vtbl + IUserNotification2Vtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetBalloonInfo*: proc(self: ptr IUserNotification2, pszTitle: LPCWSTR, pszText: LPCWSTR, dwInfoFlags: DWORD): HRESULT {.stdcall.} + SetBalloonRetry*: proc(self: ptr IUserNotification2, dwShowTime: DWORD, dwInterval: DWORD, cRetryCount: UINT): HRESULT {.stdcall.} + SetIconInfo*: proc(self: ptr IUserNotification2, hIcon: HICON, pszToolTip: LPCWSTR): HRESULT {.stdcall.} + Show*: proc(self: ptr IUserNotification2, pqc: ptr IQueryContinue, dwContinuePollInterval: DWORD, pSink: ptr IUserNotificationCallback): HRESULT {.stdcall.} + PlaySound*: proc(self: ptr IUserNotification2, pszSoundName: LPCWSTR): HRESULT {.stdcall.} + IItemNameLimits* {.pure.} = object + lpVtbl*: ptr IItemNameLimitsVtbl + IItemNameLimitsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetValidCharacters*: proc(self: ptr IItemNameLimits, ppwszValidChars: ptr LPWSTR, ppwszInvalidChars: ptr LPWSTR): HRESULT {.stdcall.} + GetMaxLength*: proc(self: ptr IItemNameLimits, pszName: LPCWSTR, piMaxNameLen: ptr int32): HRESULT {.stdcall.} + ISearchFolderItemFactory* {.pure.} = object + lpVtbl*: ptr ISearchFolderItemFactoryVtbl + ISearchFolderItemFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetDisplayName*: proc(self: ptr ISearchFolderItemFactory, pszDisplayName: LPCWSTR): HRESULT {.stdcall.} + SetFolderTypeID*: proc(self: ptr ISearchFolderItemFactory, ftid: FOLDERTYPEID): HRESULT {.stdcall.} + SetFolderLogicalViewMode*: proc(self: ptr ISearchFolderItemFactory, flvm: FOLDERLOGICALVIEWMODE): HRESULT {.stdcall.} + SetIconSize*: proc(self: ptr ISearchFolderItemFactory, iIconSize: int32): HRESULT {.stdcall.} + SetVisibleColumns*: proc(self: ptr ISearchFolderItemFactory, cVisibleColumns: UINT, rgKey: ptr PROPERTYKEY): HRESULT {.stdcall.} + SetSortColumns*: proc(self: ptr ISearchFolderItemFactory, cSortColumns: UINT, rgSortColumns: ptr SORTCOLUMN): HRESULT {.stdcall.} + SetGroupColumn*: proc(self: ptr ISearchFolderItemFactory, keyGroup: REFPROPERTYKEY): HRESULT {.stdcall.} + SetStacks*: proc(self: ptr ISearchFolderItemFactory, cStackKeys: UINT, rgStackKeys: ptr PROPERTYKEY): HRESULT {.stdcall.} + SetScope*: proc(self: ptr ISearchFolderItemFactory, psiaScope: ptr IShellItemArray): HRESULT {.stdcall.} + SetCondition*: proc(self: ptr ISearchFolderItemFactory, pCondition: ptr ICondition): HRESULT {.stdcall.} + GetShellItem*: proc(self: ptr ISearchFolderItemFactory, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetIDList*: proc(self: ptr ISearchFolderItemFactory, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IThumbnailHandlerFactory* {.pure.} = object + lpVtbl*: ptr IThumbnailHandlerFactoryVtbl + IThumbnailHandlerFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetThumbnailHandler*: proc(self: ptr IThumbnailHandlerFactory, pidlChild: PCUITEMID_CHILD, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IParentAndItem* {.pure.} = object + lpVtbl*: ptr IParentAndItemVtbl + IParentAndItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetParentAndItem*: proc(self: ptr IParentAndItem, pidlParent: PCIDLIST_ABSOLUTE, psf: ptr IShellFolder, pidlChild: PCUITEMID_CHILD): HRESULT {.stdcall.} + GetParentAndItem*: proc(self: ptr IParentAndItem, ppidlParent: ptr PIDLIST_ABSOLUTE, ppsf: ptr ptr IShellFolder, ppidlChild: ptr PITEMID_CHILD): HRESULT {.stdcall.} + IDockingWindow* {.pure.} = object + lpVtbl*: ptr IDockingWindowVtbl + IDockingWindowVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + ShowDW*: proc(self: ptr IDockingWindow, fShow: WINBOOL): HRESULT {.stdcall.} + CloseDW*: proc(self: ptr IDockingWindow, dwReserved: DWORD): HRESULT {.stdcall.} + ResizeBorderDW*: proc(self: ptr IDockingWindow, prcBorder: LPCRECT, punkToolbarSite: ptr IUnknown, fReserved: WINBOOL): HRESULT {.stdcall.} + IDeskBand* {.pure.} = object + lpVtbl*: ptr IDeskBandVtbl + IDeskBandVtbl* {.pure, inheritable.} = object of IDockingWindowVtbl + GetBandInfo*: proc(self: ptr IDeskBand, dwBandID: DWORD, dwViewMode: DWORD, pdbi: ptr DESKBANDINFO): HRESULT {.stdcall.} + IDeskBandInfo* {.pure.} = object + lpVtbl*: ptr IDeskBandInfoVtbl + IDeskBandInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDefaultBandWidth*: proc(self: ptr IDeskBandInfo, dwBandID: DWORD, dwViewMode: DWORD, pnWidth: ptr int32): HRESULT {.stdcall.} + IDeskBand2* {.pure.} = object + lpVtbl*: ptr IDeskBand2Vtbl + IDeskBand2Vtbl* {.pure, inheritable.} = object of IDeskBandVtbl + CanRenderComposited*: proc(self: ptr IDeskBand2, pfCanRenderComposited: ptr WINBOOL): HRESULT {.stdcall.} + SetCompositionState*: proc(self: ptr IDeskBand2, fCompositionEnabled: WINBOOL): HRESULT {.stdcall.} + GetCompositionState*: proc(self: ptr IDeskBand2, pfCompositionEnabled: ptr WINBOOL): HRESULT {.stdcall.} + ITaskbarList* {.pure.} = object + lpVtbl*: ptr ITaskbarListVtbl + ITaskbarListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HrInit*: proc(self: ptr ITaskbarList): HRESULT {.stdcall.} + AddTab*: proc(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.stdcall.} + DeleteTab*: proc(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.stdcall.} + ActivateTab*: proc(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.stdcall.} + SetActiveAlt*: proc(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.stdcall.} + ITaskbarList2* {.pure.} = object + lpVtbl*: ptr ITaskbarList2Vtbl + ITaskbarList2Vtbl* {.pure, inheritable.} = object of ITaskbarListVtbl + MarkFullscreenWindow*: proc(self: ptr ITaskbarList2, hwnd: HWND, fFullscreen: WINBOOL): HRESULT {.stdcall.} + ITaskbarList3* {.pure.} = object + lpVtbl*: ptr ITaskbarList3Vtbl + ITaskbarList3Vtbl* {.pure, inheritable.} = object of ITaskbarList2Vtbl + SetProgressValue*: proc(self: ptr ITaskbarList3, hwnd: HWND, ullCompleted: ULONGLONG, ullTotal: ULONGLONG): HRESULT {.stdcall.} + SetProgressState*: proc(self: ptr ITaskbarList3, hwnd: HWND, tbpFlags: TBPFLAG): HRESULT {.stdcall.} + RegisterTab*: proc(self: ptr ITaskbarList3, hwndTab: HWND, hwndMDI: HWND): HRESULT {.stdcall.} + UnregisterTab*: proc(self: ptr ITaskbarList3, hwndTab: HWND): HRESULT {.stdcall.} + SetTabOrder*: proc(self: ptr ITaskbarList3, hwndTab: HWND, hwndInsertBefore: HWND): HRESULT {.stdcall.} + SetTabActive*: proc(self: ptr ITaskbarList3, hwndTab: HWND, hwndMDI: HWND, dwReserved: DWORD): HRESULT {.stdcall.} + ThumbBarAddButtons*: proc(self: ptr ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON): HRESULT {.stdcall.} + ThumbBarUpdateButtons*: proc(self: ptr ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON): HRESULT {.stdcall.} + ThumbBarSetImageList*: proc(self: ptr ITaskbarList3, hwnd: HWND, himl: HIMAGELIST): HRESULT {.stdcall.} + SetOverlayIcon*: proc(self: ptr ITaskbarList3, hwnd: HWND, hIcon: HICON, pszDescription: LPCWSTR): HRESULT {.stdcall.} + SetThumbnailTooltip*: proc(self: ptr ITaskbarList3, hwnd: HWND, pszTip: LPCWSTR): HRESULT {.stdcall.} + SetThumbnailClip*: proc(self: ptr ITaskbarList3, hwnd: HWND, prcClip: ptr RECT): HRESULT {.stdcall.} + ITaskbarList4* {.pure.} = object + lpVtbl*: ptr ITaskbarList4Vtbl + ITaskbarList4Vtbl* {.pure, inheritable.} = object of ITaskbarList3Vtbl + SetTabProperties*: proc(self: ptr ITaskbarList4, hwndTab: HWND, stpFlags: STPFLAG): HRESULT {.stdcall.} + IStartMenuPinnedList* {.pure.} = object + lpVtbl*: ptr IStartMenuPinnedListVtbl + IStartMenuPinnedListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RemoveFromList*: proc(self: ptr IStartMenuPinnedList, pitem: ptr IShellItem): HRESULT {.stdcall.} + ICDBurn* {.pure.} = object + lpVtbl*: ptr ICDBurnVtbl + ICDBurnVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRecorderDriveLetter*: proc(self: ptr ICDBurn, pszDrive: LPWSTR, cch: UINT): HRESULT {.stdcall.} + Burn*: proc(self: ptr ICDBurn, hwnd: HWND): HRESULT {.stdcall.} + HasRecordableDrive*: proc(self: ptr ICDBurn, pfHasRecorder: ptr WINBOOL): HRESULT {.stdcall.} + IWizardSite* {.pure.} = object + lpVtbl*: ptr IWizardSiteVtbl + IWizardSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPreviousPage*: proc(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.stdcall.} + GetNextPage*: proc(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.stdcall.} + GetCancelledPage*: proc(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.stdcall.} + IWizardExtension* {.pure.} = object + lpVtbl*: ptr IWizardExtensionVtbl + IWizardExtensionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddPages*: proc(self: ptr IWizardExtension, aPages: ptr HPROPSHEETPAGE, cPages: UINT, pnPagesAdded: ptr UINT): HRESULT {.stdcall.} + GetFirstPage*: proc(self: ptr IWizardExtension, phpage: ptr HPROPSHEETPAGE): HRESULT {.stdcall.} + GetLastPage*: proc(self: ptr IWizardExtension, phpage: ptr HPROPSHEETPAGE): HRESULT {.stdcall.} + IWebWizardExtension* {.pure.} = object + lpVtbl*: ptr IWebWizardExtensionVtbl + IWebWizardExtensionVtbl* {.pure, inheritable.} = object of IWizardExtensionVtbl + SetInitialURL*: proc(self: ptr IWebWizardExtension, pszURL: LPCWSTR): HRESULT {.stdcall.} + SetErrorURL*: proc(self: ptr IWebWizardExtension, pszErrorURL: LPCWSTR): HRESULT {.stdcall.} + IPublishingWizard* {.pure.} = object + lpVtbl*: ptr IPublishingWizardVtbl + IPublishingWizardVtbl* {.pure, inheritable.} = object of IWizardExtensionVtbl + Initialize*: proc(self: ptr IPublishingWizard, pdo: ptr IDataObject, dwOptions: DWORD, pszServiceScope: LPCWSTR): HRESULT {.stdcall.} + GetTransferManifest*: proc(self: ptr IPublishingWizard, phrFromTransfer: ptr HRESULT, pdocManifest: ptr ptr IXMLDOMDocument): HRESULT {.stdcall.} + IFolderViewHost* {.pure.} = object + lpVtbl*: ptr IFolderViewHostVtbl + IFolderViewHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IFolderViewHost, hwndParent: HWND, pdo: ptr IDataObject, prc: ptr RECT): HRESULT {.stdcall.} + IExplorerBrowserEvents* {.pure.} = object + lpVtbl*: ptr IExplorerBrowserEventsVtbl + IExplorerBrowserEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnNavigationPending*: proc(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + OnViewCreated*: proc(self: ptr IExplorerBrowserEvents, psv: ptr IShellView): HRESULT {.stdcall.} + OnNavigationComplete*: proc(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + OnNavigationFailed*: proc(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IExplorerBrowser* {.pure.} = object + lpVtbl*: ptr IExplorerBrowserVtbl + IExplorerBrowserVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IExplorerBrowser, hwndParent: HWND, prc: ptr RECT, pfs: ptr FOLDERSETTINGS): HRESULT {.stdcall.} + Destroy*: proc(self: ptr IExplorerBrowser): HRESULT {.stdcall.} + SetRect*: proc(self: ptr IExplorerBrowser, phdwp: ptr HDWP, rcBrowser: RECT): HRESULT {.stdcall.} + SetPropertyBag*: proc(self: ptr IExplorerBrowser, pszPropertyBag: LPCWSTR): HRESULT {.stdcall.} + SetEmptyText*: proc(self: ptr IExplorerBrowser, pszEmptyText: LPCWSTR): HRESULT {.stdcall.} + SetFolderSettings*: proc(self: ptr IExplorerBrowser, pfs: ptr FOLDERSETTINGS): HRESULT {.stdcall.} + Advise*: proc(self: ptr IExplorerBrowser, psbe: ptr IExplorerBrowserEvents, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IExplorerBrowser, dwCookie: DWORD): HRESULT {.stdcall.} + SetOptions*: proc(self: ptr IExplorerBrowser, dwFlag: EXPLORER_BROWSER_OPTIONS): HRESULT {.stdcall.} + GetOptions*: proc(self: ptr IExplorerBrowser, pdwFlag: ptr EXPLORER_BROWSER_OPTIONS): HRESULT {.stdcall.} + BrowseToIDList*: proc(self: ptr IExplorerBrowser, pidl: PCUIDLIST_RELATIVE, uFlags: UINT): HRESULT {.stdcall.} + BrowseToObject*: proc(self: ptr IExplorerBrowser, punk: ptr IUnknown, uFlags: UINT): HRESULT {.stdcall.} + FillFromObject*: proc(self: ptr IExplorerBrowser, punk: ptr IUnknown, dwFlags: EXPLORER_BROWSER_FILL_FLAGS): HRESULT {.stdcall.} + RemoveAll*: proc(self: ptr IExplorerBrowser): HRESULT {.stdcall.} + GetCurrentView*: proc(self: ptr IExplorerBrowser, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IAccessibleObject* {.pure.} = object + lpVtbl*: ptr IAccessibleObjectVtbl + IAccessibleObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAccessibleName*: proc(self: ptr IAccessibleObject, pszName: LPCWSTR): HRESULT {.stdcall.} + IResultsFolder* {.pure.} = object + lpVtbl*: ptr IResultsFolderVtbl + IResultsFolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddItem*: proc(self: ptr IResultsFolder, psi: ptr IShellItem): HRESULT {.stdcall.} + AddIDList*: proc(self: ptr IResultsFolder, pidl: PCIDLIST_ABSOLUTE, ppidlAdded: ptr PITEMID_CHILD): HRESULT {.stdcall.} + RemoveItem*: proc(self: ptr IResultsFolder, psi: ptr IShellItem): HRESULT {.stdcall.} + RemoveIDList*: proc(self: ptr IResultsFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + RemoveAll*: proc(self: ptr IResultsFolder): HRESULT {.stdcall.} + IEnumObjects* {.pure.} = object + lpVtbl*: ptr IEnumObjectsVtbl + IEnumObjectsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumObjects, celt: ULONG, riid: REFIID, rgelt: ptr pointer, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumObjects, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumObjects): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumObjects, ppenum: ptr ptr IEnumObjects): HRESULT {.stdcall.} + IOperationsProgressDialog* {.pure.} = object + lpVtbl*: ptr IOperationsProgressDialogVtbl + IOperationsProgressDialogVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartProgressDialog*: proc(self: ptr IOperationsProgressDialog, hwndOwner: HWND, flags: OPPROGDLGF): HRESULT {.stdcall.} + StopProgressDialog*: proc(self: ptr IOperationsProgressDialog): HRESULT {.stdcall.} + SetOperation*: proc(self: ptr IOperationsProgressDialog, action: SPACTION): HRESULT {.stdcall.} + SetMode*: proc(self: ptr IOperationsProgressDialog, mode: PDMODE): HRESULT {.stdcall.} + UpdateProgress*: proc(self: ptr IOperationsProgressDialog, ullPointsCurrent: ULONGLONG, ullPointsTotal: ULONGLONG, ullSizeCurrent: ULONGLONG, ullSizeTotal: ULONGLONG, ullItemsCurrent: ULONGLONG, ullItemsTotal: ULONGLONG): HRESULT {.stdcall.} + UpdateLocations*: proc(self: ptr IOperationsProgressDialog, psiSource: ptr IShellItem, psiTarget: ptr IShellItem, psiItem: ptr IShellItem): HRESULT {.stdcall.} + ResetTimer*: proc(self: ptr IOperationsProgressDialog): HRESULT {.stdcall.} + PauseTimer*: proc(self: ptr IOperationsProgressDialog): HRESULT {.stdcall.} + ResumeTimer*: proc(self: ptr IOperationsProgressDialog): HRESULT {.stdcall.} + GetMilliseconds*: proc(self: ptr IOperationsProgressDialog, pullElapsed: ptr ULONGLONG, pullRemaining: ptr ULONGLONG): HRESULT {.stdcall.} + GetOperationStatus*: proc(self: ptr IOperationsProgressDialog, popstatus: ptr PDOPSTATUS): HRESULT {.stdcall.} + IIOCancelInformation* {.pure.} = object + lpVtbl*: ptr IIOCancelInformationVtbl + IIOCancelInformationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetCancelInformation*: proc(self: ptr IIOCancelInformation, dwThreadID: DWORD, uMsgCancel: UINT): HRESULT {.stdcall.} + GetCancelInformation*: proc(self: ptr IIOCancelInformation, pdwThreadID: ptr DWORD, puMsgCancel: ptr UINT): HRESULT {.stdcall.} + IFileOperation* {.pure.} = object + lpVtbl*: ptr IFileOperationVtbl + IFileOperationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr IFileOperation, pfops: ptr IFileOperationProgressSink, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IFileOperation, dwCookie: DWORD): HRESULT {.stdcall.} + SetOperationFlags*: proc(self: ptr IFileOperation, dwOperationFlags: DWORD): HRESULT {.stdcall.} + SetProgressMessage*: proc(self: ptr IFileOperation, pszMessage: LPCWSTR): HRESULT {.stdcall.} + SetProgressDialog*: proc(self: ptr IFileOperation, popd: ptr IOperationsProgressDialog): HRESULT {.stdcall.} + SetProperties*: proc(self: ptr IFileOperation, pproparray: ptr IPropertyChangeArray): HRESULT {.stdcall.} + SetOwnerWindow*: proc(self: ptr IFileOperation, hwndOwner: HWND): HRESULT {.stdcall.} + ApplyPropertiesToItem*: proc(self: ptr IFileOperation, psiItem: ptr IShellItem): HRESULT {.stdcall.} + ApplyPropertiesToItems*: proc(self: ptr IFileOperation, punkItems: ptr IUnknown): HRESULT {.stdcall.} + RenameItem*: proc(self: ptr IFileOperation, psiItem: ptr IShellItem, pszNewName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + RenameItems*: proc(self: ptr IFileOperation, pUnkItems: ptr IUnknown, pszNewName: LPCWSTR): HRESULT {.stdcall.} + MoveItem*: proc(self: ptr IFileOperation, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + MoveItems*: proc(self: ptr IFileOperation, punkItems: ptr IUnknown, psiDestinationFolder: ptr IShellItem): HRESULT {.stdcall.} + CopyItem*: proc(self: ptr IFileOperation, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszCopyName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + CopyItems*: proc(self: ptr IFileOperation, punkItems: ptr IUnknown, psiDestinationFolder: ptr IShellItem): HRESULT {.stdcall.} + DeleteItem*: proc(self: ptr IFileOperation, psiItem: ptr IShellItem, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + DeleteItems*: proc(self: ptr IFileOperation, punkItems: ptr IUnknown): HRESULT {.stdcall.} + NewItem*: proc(self: ptr IFileOperation, psiDestinationFolder: ptr IShellItem, dwFileAttributes: DWORD, pszName: LPCWSTR, pszTemplateName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + PerformOperations*: proc(self: ptr IFileOperation): HRESULT {.stdcall.} + GetAnyOperationsAborted*: proc(self: ptr IFileOperation, pfAnyOperationsAborted: ptr WINBOOL): HRESULT {.stdcall.} + IObjectProvider* {.pure.} = object + lpVtbl*: ptr IObjectProviderVtbl + IObjectProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryObject*: proc(self: ptr IObjectProvider, guidObject: REFGUID, riid: REFIID, ppvOut: ptr pointer): HRESULT {.stdcall.} + INamespaceWalkCB* {.pure.} = object + lpVtbl*: ptr INamespaceWalkCBVtbl + INamespaceWalkCBVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FoundItem*: proc(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.stdcall.} + EnterFolder*: proc(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.stdcall.} + LeaveFolder*: proc(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.stdcall.} + InitializeProgressDialog*: proc(self: ptr INamespaceWalkCB, ppszTitle: ptr LPWSTR, ppszCancel: ptr LPWSTR): HRESULT {.stdcall.} + INamespaceWalkCB2* {.pure.} = object + lpVtbl*: ptr INamespaceWalkCB2Vtbl + INamespaceWalkCB2Vtbl* {.pure, inheritable.} = object of INamespaceWalkCBVtbl + WalkComplete*: proc(self: ptr INamespaceWalkCB2, hr: HRESULT): HRESULT {.stdcall.} + INamespaceWalk* {.pure.} = object + lpVtbl*: ptr INamespaceWalkVtbl + INamespaceWalkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Walk*: proc(self: ptr INamespaceWalk, punkToWalk: ptr IUnknown, dwFlags: DWORD, cDepth: int32, pnswcb: ptr INamespaceWalkCB): HRESULT {.stdcall.} + GetIDArrayResult*: proc(self: ptr INamespaceWalk, pcItems: ptr UINT, prgpidl: ptr ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IAutoCompleteDropDown* {.pure.} = object + lpVtbl*: ptr IAutoCompleteDropDownVtbl + IAutoCompleteDropDownVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDropDownStatus*: proc(self: ptr IAutoCompleteDropDown, pdwFlags: ptr DWORD, ppwszString: ptr LPWSTR): HRESULT {.stdcall.} + ResetEnumerator*: proc(self: ptr IAutoCompleteDropDown): HRESULT {.stdcall.} + IBandSite* {.pure.} = object + lpVtbl*: ptr IBandSiteVtbl + IBandSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddBand*: proc(self: ptr IBandSite, punk: ptr IUnknown): HRESULT {.stdcall.} + EnumBands*: proc(self: ptr IBandSite, uBand: UINT, pdwBandID: ptr DWORD): HRESULT {.stdcall.} + QueryBand*: proc(self: ptr IBandSite, dwBandID: DWORD, ppstb: ptr ptr IDeskBand, pdwState: ptr DWORD, pszName: LPWSTR, cchName: int32): HRESULT {.stdcall.} + SetBandState*: proc(self: ptr IBandSite, dwBandID: DWORD, dwMask: DWORD, dwState: DWORD): HRESULT {.stdcall.} + RemoveBand*: proc(self: ptr IBandSite, dwBandID: DWORD): HRESULT {.stdcall.} + GetBandObject*: proc(self: ptr IBandSite, dwBandID: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + SetBandSiteInfo*: proc(self: ptr IBandSite, pbsinfo: ptr BANDSITEINFO): HRESULT {.stdcall.} + GetBandSiteInfo*: proc(self: ptr IBandSite, pbsinfo: ptr BANDSITEINFO): HRESULT {.stdcall.} + IModalWindow* {.pure.} = object + lpVtbl*: ptr IModalWindowVtbl + IModalWindowVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Show*: proc(self: ptr IModalWindow, hwndOwner: HWND): HRESULT {.stdcall.} + ICDBurnExt* {.pure.} = object + lpVtbl*: ptr ICDBurnExtVtbl + ICDBurnExtVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSupportedActionTypes*: proc(self: ptr ICDBurnExt, pdwActions: ptr CDBE_ACTIONS): HRESULT {.stdcall.} + IContextMenuSite* {.pure.} = object + lpVtbl*: ptr IContextMenuSiteVtbl + IContextMenuSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + DoContextMenuPopup*: proc(self: ptr IContextMenuSite, punkContextMenu: ptr IUnknown, fFlags: UINT, pt: POINT): HRESULT {.stdcall.} + IEnumReadyCallback* {.pure.} = object + lpVtbl*: ptr IEnumReadyCallbackVtbl + IEnumReadyCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnumReady*: proc(self: ptr IEnumReadyCallback): HRESULT {.stdcall.} + IEnumerableView* {.pure.} = object + lpVtbl*: ptr IEnumerableViewVtbl + IEnumerableViewVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetEnumReadyCallback*: proc(self: ptr IEnumerableView, percb: ptr IEnumReadyCallback): HRESULT {.stdcall.} + CreateEnumIDListFromContents*: proc(self: ptr IEnumerableView, pidlFolder: PCIDLIST_ABSOLUTE, dwEnumFlags: DWORD, ppEnumIDList: ptr ptr IEnumIDList): HRESULT {.stdcall.} + IInsertItem* {.pure.} = object + lpVtbl*: ptr IInsertItemVtbl + IInsertItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InsertItem*: proc(self: ptr IInsertItem, pidl: PCUIDLIST_RELATIVE): HRESULT {.stdcall.} + IMenuBand* {.pure.} = object + lpVtbl*: ptr IMenuBandVtbl + IMenuBandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsMenuMessage*: proc(self: ptr IMenuBand, pmsg: ptr MSG): HRESULT {.stdcall.} + TranslateMenuMessage*: proc(self: ptr IMenuBand, pmsg: ptr MSG, plRet: ptr LRESULT): HRESULT {.stdcall.} + IFolderBandPriv* {.pure.} = object + lpVtbl*: ptr IFolderBandPrivVtbl + IFolderBandPrivVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetCascade*: proc(self: ptr IFolderBandPriv, fCascade: WINBOOL): HRESULT {.stdcall.} + SetAccelerators*: proc(self: ptr IFolderBandPriv, fAccelerators: WINBOOL): HRESULT {.stdcall.} + SetNoIcons*: proc(self: ptr IFolderBandPriv, fNoIcons: WINBOOL): HRESULT {.stdcall.} + SetNoText*: proc(self: ptr IFolderBandPriv, fNoText: WINBOOL): HRESULT {.stdcall.} + IRegTreeItem* {.pure.} = object + lpVtbl*: ptr IRegTreeItemVtbl + IRegTreeItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCheckState*: proc(self: ptr IRegTreeItem, pbCheck: ptr WINBOOL): HRESULT {.stdcall.} + SetCheckState*: proc(self: ptr IRegTreeItem, bCheck: WINBOOL): HRESULT {.stdcall.} + IImageRecompress* {.pure.} = object + lpVtbl*: ptr IImageRecompressVtbl + IImageRecompressVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RecompressImage*: proc(self: ptr IImageRecompress, psi: ptr IShellItem, cx: int32, cy: int32, iQuality: int32, pstg: ptr IStorage, ppstrmOut: ptr ptr IStream): HRESULT {.stdcall.} + IDeskBar* {.pure.} = object + lpVtbl*: ptr IDeskBarVtbl + IDeskBarVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + SetClient*: proc(self: ptr IDeskBar, punkClient: ptr IUnknown): HRESULT {.stdcall.} + GetClient*: proc(self: ptr IDeskBar, ppunkClient: ptr ptr IUnknown): HRESULT {.stdcall.} + OnPosRectChangeDB*: proc(self: ptr IDeskBar, prc: ptr RECT): HRESULT {.stdcall.} + IMenuPopup* {.pure.} = object + lpVtbl*: ptr IMenuPopupVtbl + IMenuPopupVtbl* {.pure, inheritable.} = object of IDeskBarVtbl + Popup*: proc(self: ptr IMenuPopup, ppt: ptr POINTL, prcExclude: ptr RECTL, dwFlags: MP_POPUPFLAGS): HRESULT {.stdcall.} + OnSelect*: proc(self: ptr IMenuPopup, dwSelectType: DWORD): HRESULT {.stdcall.} + SetSubMenu*: proc(self: ptr IMenuPopup, pmp: ptr IMenuPopup, fSet: WINBOOL): HRESULT {.stdcall.} + IFileIsInUse* {.pure.} = object + lpVtbl*: ptr IFileIsInUseVtbl + IFileIsInUseVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetAppName*: proc(self: ptr IFileIsInUse, ppszName: ptr LPWSTR): HRESULT {.stdcall.} + GetUsage*: proc(self: ptr IFileIsInUse, pfut: ptr FILE_USAGE_TYPE): HRESULT {.stdcall.} + GetCapabilities*: proc(self: ptr IFileIsInUse, pdwCapFlags: ptr DWORD): HRESULT {.stdcall.} + GetSwitchToHWND*: proc(self: ptr IFileIsInUse, phwnd: ptr HWND): HRESULT {.stdcall.} + CloseFile*: proc(self: ptr IFileIsInUse): HRESULT {.stdcall.} + IShellItemFilter* {.pure.} = object + lpVtbl*: ptr IShellItemFilterVtbl + IShellItemFilterVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IncludeItem*: proc(self: ptr IShellItemFilter, psi: ptr IShellItem): HRESULT {.stdcall.} + GetEnumFlagsForItem*: proc(self: ptr IShellItemFilter, psi: ptr IShellItem, pgrfFlags: ptr SHCONTF): HRESULT {.stdcall.} + IFileDialog* {.pure.} = object + lpVtbl*: ptr IFileDialogVtbl + IFileDialogVtbl* {.pure, inheritable.} = object of IModalWindowVtbl + SetFileTypes*: proc(self: ptr IFileDialog, cFileTypes: UINT, rgFilterSpec: ptr COMDLG_FILTERSPEC): HRESULT {.stdcall.} + SetFileTypeIndex*: proc(self: ptr IFileDialog, iFileType: UINT): HRESULT {.stdcall.} + GetFileTypeIndex*: proc(self: ptr IFileDialog, piFileType: ptr UINT): HRESULT {.stdcall.} + Advise*: proc(self: ptr IFileDialog, pfde: ptr IFileDialogEvents, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IFileDialog, dwCookie: DWORD): HRESULT {.stdcall.} + SetOptions*: proc(self: ptr IFileDialog, fos: FILEOPENDIALOGOPTIONS): HRESULT {.stdcall.} + GetOptions*: proc(self: ptr IFileDialog, pfos: ptr FILEOPENDIALOGOPTIONS): HRESULT {.stdcall.} + SetDefaultFolder*: proc(self: ptr IFileDialog, psi: ptr IShellItem): HRESULT {.stdcall.} + SetFolder*: proc(self: ptr IFileDialog, psi: ptr IShellItem): HRESULT {.stdcall.} + GetFolder*: proc(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + GetCurrentSelection*: proc(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + SetFileName*: proc(self: ptr IFileDialog, pszName: LPCWSTR): HRESULT {.stdcall.} + GetFileName*: proc(self: ptr IFileDialog, pszName: ptr LPWSTR): HRESULT {.stdcall.} + SetTitle*: proc(self: ptr IFileDialog, pszTitle: LPCWSTR): HRESULT {.stdcall.} + SetOkButtonLabel*: proc(self: ptr IFileDialog, pszText: LPCWSTR): HRESULT {.stdcall.} + SetFileNameLabel*: proc(self: ptr IFileDialog, pszLabel: LPCWSTR): HRESULT {.stdcall.} + GetResult*: proc(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + AddPlace*: proc(self: ptr IFileDialog, psi: ptr IShellItem, fdap: FDAP): HRESULT {.stdcall.} + SetDefaultExtension*: proc(self: ptr IFileDialog, pszDefaultExtension: LPCWSTR): HRESULT {.stdcall.} + Close*: proc(self: ptr IFileDialog, hr: HRESULT): HRESULT {.stdcall.} + SetClientGuid*: proc(self: ptr IFileDialog, guid: REFGUID): HRESULT {.stdcall.} + ClearClientData*: proc(self: ptr IFileDialog): HRESULT {.stdcall.} + SetFilter*: proc(self: ptr IFileDialog, pFilter: ptr IShellItemFilter): HRESULT {.stdcall.} + IFileDialogEvents* {.pure.} = object + lpVtbl*: ptr IFileDialogEventsVtbl + IFileDialogEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnFileOk*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.stdcall.} + OnFolderChanging*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psiFolder: ptr IShellItem): HRESULT {.stdcall.} + OnFolderChange*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.stdcall.} + OnSelectionChange*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.stdcall.} + OnShareViolation*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psi: ptr IShellItem, pResponse: ptr FDE_SHAREVIOLATION_RESPONSE): HRESULT {.stdcall.} + OnTypeChange*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.stdcall.} + OnOverwrite*: proc(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psi: ptr IShellItem, pResponse: ptr FDE_OVERWRITE_RESPONSE): HRESULT {.stdcall.} + IFileSaveDialog* {.pure.} = object + lpVtbl*: ptr IFileSaveDialogVtbl + IFileSaveDialogVtbl* {.pure, inheritable.} = object of IFileDialogVtbl + SetSaveAsItem*: proc(self: ptr IFileSaveDialog, psi: ptr IShellItem): HRESULT {.stdcall.} + SetProperties*: proc(self: ptr IFileSaveDialog, pStore: ptr IPropertyStore): HRESULT {.stdcall.} + SetCollectedProperties*: proc(self: ptr IFileSaveDialog, pList: ptr IPropertyDescriptionList, fAppendDefault: WINBOOL): HRESULT {.stdcall.} + GetProperties*: proc(self: ptr IFileSaveDialog, ppStore: ptr ptr IPropertyStore): HRESULT {.stdcall.} + ApplyProperties*: proc(self: ptr IFileSaveDialog, psi: ptr IShellItem, pStore: ptr IPropertyStore, hwnd: HWND, pSink: ptr IFileOperationProgressSink): HRESULT {.stdcall.} + IFileOpenDialog* {.pure.} = object + lpVtbl*: ptr IFileOpenDialogVtbl + IFileOpenDialogVtbl* {.pure, inheritable.} = object of IFileDialogVtbl + GetResults*: proc(self: ptr IFileOpenDialog, ppenum: ptr ptr IShellItemArray): HRESULT {.stdcall.} + GetSelectedItems*: proc(self: ptr IFileOpenDialog, ppsai: ptr ptr IShellItemArray): HRESULT {.stdcall.} + IFileDialogCustomize* {.pure.} = object + lpVtbl*: ptr IFileDialogCustomizeVtbl + IFileDialogCustomizeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnableOpenDropDown*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + AddMenu*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + AddPushButton*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + AddComboBox*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + AddRadioButtonList*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + AddCheckButton*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR, bChecked: WINBOOL): HRESULT {.stdcall.} + AddEditBox*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.stdcall.} + AddSeparator*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + AddText*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.stdcall.} + SetControlLabel*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + GetControlState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pdwState: ptr CDCONTROLSTATEF): HRESULT {.stdcall.} + SetControlState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwState: CDCONTROLSTATEF): HRESULT {.stdcall.} + GetEditBoxText*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, ppszText: ptr ptr WCHAR): HRESULT {.stdcall.} + SetEditBoxText*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.stdcall.} + GetCheckButtonState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pbChecked: ptr WINBOOL): HRESULT {.stdcall.} + SetCheckButtonState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, bChecked: WINBOOL): HRESULT {.stdcall.} + AddControlItem*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + RemoveControlItem*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.stdcall.} + RemoveAllControlItems*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + GetControlItemState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pdwState: ptr CDCONTROLSTATEF): HRESULT {.stdcall.} + SetControlItemState*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, dwState: CDCONTROLSTATEF): HRESULT {.stdcall.} + GetSelectedControlItem*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pdwIDItem: ptr DWORD): HRESULT {.stdcall.} + SetSelectedControlItem*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.stdcall.} + StartVisualGroup*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + EndVisualGroup*: proc(self: ptr IFileDialogCustomize): HRESULT {.stdcall.} + MakeProminent*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + SetControlItemText*: proc(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pszLabel: LPCWSTR): HRESULT {.stdcall.} + IFileDialogControlEvents* {.pure.} = object + lpVtbl*: ptr IFileDialogControlEventsVtbl + IFileDialogControlEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnItemSelected*: proc(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.stdcall.} + OnButtonClicked*: proc(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + OnCheckButtonToggled*: proc(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD, bChecked: WINBOOL): HRESULT {.stdcall.} + OnControlActivating*: proc(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.stdcall.} + IFileDialog2* {.pure.} = object + lpVtbl*: ptr IFileDialog2Vtbl + IFileDialog2Vtbl* {.pure, inheritable.} = object of IFileDialogVtbl + SetCancelButtonLabel*: proc(self: ptr IFileDialog2, pszLabel: LPCWSTR): HRESULT {.stdcall.} + SetNavigationRoot*: proc(self: ptr IFileDialog2, psi: ptr IShellItem): HRESULT {.stdcall.} + IApplicationAssociationRegistration* {.pure.} = object + lpVtbl*: ptr IApplicationAssociationRegistrationVtbl + IApplicationAssociationRegistrationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryCurrentDefault*: proc(self: ptr IApplicationAssociationRegistration, pszQuery: LPCWSTR, atQueryType: ASSOCIATIONTYPE, alQueryLevel: ASSOCIATIONLEVEL, ppszAssociation: ptr LPWSTR): HRESULT {.stdcall.} + QueryAppIsDefault*: proc(self: ptr IApplicationAssociationRegistration, pszQuery: LPCWSTR, atQueryType: ASSOCIATIONTYPE, alQueryLevel: ASSOCIATIONLEVEL, pszAppRegistryName: LPCWSTR, pfDefault: ptr WINBOOL): HRESULT {.stdcall.} + QueryAppIsDefaultAll*: proc(self: ptr IApplicationAssociationRegistration, alQueryLevel: ASSOCIATIONLEVEL, pszAppRegistryName: LPCWSTR, pfDefault: ptr WINBOOL): HRESULT {.stdcall.} + SetAppAsDefault*: proc(self: ptr IApplicationAssociationRegistration, pszAppRegistryName: LPCWSTR, pszSet: LPCWSTR, atSetType: ASSOCIATIONTYPE): HRESULT {.stdcall.} + SetAppAsDefaultAll*: proc(self: ptr IApplicationAssociationRegistration, pszAppRegistryName: LPCWSTR): HRESULT {.stdcall.} + ClearUserAssociations*: proc(self: ptr IApplicationAssociationRegistration): HRESULT {.stdcall.} + IApplicationAssociationRegistrationUI* {.pure.} = object + lpVtbl*: ptr IApplicationAssociationRegistrationUIVtbl + IApplicationAssociationRegistrationUIVtbl* {.pure, inheritable.} = object of IUnknownVtbl + LaunchAdvancedAssociationUI*: proc(self: ptr IApplicationAssociationRegistrationUI, pszAppRegistryName: LPCWSTR): HRESULT {.stdcall.} + IDelegateFolder* {.pure.} = object + lpVtbl*: ptr IDelegateFolderVtbl + IDelegateFolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetItemAlloc*: proc(self: ptr IDelegateFolder, pmalloc: ptr IMalloc): HRESULT {.stdcall.} + INewWindowManager* {.pure.} = object + lpVtbl*: ptr INewWindowManagerVtbl + INewWindowManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EvaluateNewWindow*: proc(self: ptr INewWindowManager, pszUrl: LPCWSTR, pszName: LPCWSTR, pszUrlContext: LPCWSTR, pszFeatures: LPCWSTR, fReplace: WINBOOL, dwFlags: DWORD, dwUserActionTime: DWORD): HRESULT {.stdcall.} + IAttachmentExecute* {.pure.} = object + lpVtbl*: ptr IAttachmentExecuteVtbl + IAttachmentExecuteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetClientTitle*: proc(self: ptr IAttachmentExecute, pszTitle: LPCWSTR): HRESULT {.stdcall.} + SetClientGuid*: proc(self: ptr IAttachmentExecute, guid: REFGUID): HRESULT {.stdcall.} + SetLocalPath*: proc(self: ptr IAttachmentExecute, pszLocalPath: LPCWSTR): HRESULT {.stdcall.} + SetFileName*: proc(self: ptr IAttachmentExecute, pszFileName: LPCWSTR): HRESULT {.stdcall.} + SetSource*: proc(self: ptr IAttachmentExecute, pszSource: LPCWSTR): HRESULT {.stdcall.} + SetReferrer*: proc(self: ptr IAttachmentExecute, pszReferrer: LPCWSTR): HRESULT {.stdcall.} + CheckPolicy*: proc(self: ptr IAttachmentExecute): HRESULT {.stdcall.} + Prompt*: proc(self: ptr IAttachmentExecute, hwnd: HWND, prompt: ATTACHMENT_PROMPT, paction: ptr ATTACHMENT_ACTION): HRESULT {.stdcall.} + Save*: proc(self: ptr IAttachmentExecute): HRESULT {.stdcall.} + Execute*: proc(self: ptr IAttachmentExecute, hwnd: HWND, pszVerb: LPCWSTR, phProcess: ptr HANDLE): HRESULT {.stdcall.} + SaveWithUI*: proc(self: ptr IAttachmentExecute, hwnd: HWND): HRESULT {.stdcall.} + ClearClientState*: proc(self: ptr IAttachmentExecute): HRESULT {.stdcall.} + IShellMenuCallback* {.pure.} = object + lpVtbl*: ptr IShellMenuCallbackVtbl + IShellMenuCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CallbackSM*: proc(self: ptr IShellMenuCallback, psmd: LPSMDATA, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + IShellMenu* {.pure.} = object + lpVtbl*: ptr IShellMenuVtbl + IShellMenuVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IShellMenu, psmc: ptr IShellMenuCallback, uId: UINT, uIdAncestor: UINT, dwFlags: DWORD): HRESULT {.stdcall.} + GetMenuInfo*: proc(self: ptr IShellMenu, ppsmc: ptr ptr IShellMenuCallback, puId: ptr UINT, puIdAncestor: ptr UINT, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + SetShellFolder*: proc(self: ptr IShellMenu, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, hKey: HKEY, dwFlags: DWORD): HRESULT {.stdcall.} + GetShellFolder*: proc(self: ptr IShellMenu, pdwFlags: ptr DWORD, ppidl: ptr PIDLIST_ABSOLUTE, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + SetMenu*: proc(self: ptr IShellMenu, hmenu: HMENU, hwnd: HWND, dwFlags: DWORD): HRESULT {.stdcall.} + GetMenu*: proc(self: ptr IShellMenu, phmenu: ptr HMENU, phwnd: ptr HWND, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + InvalidateItem*: proc(self: ptr IShellMenu, psmd: LPSMDATA, dwFlags: DWORD): HRESULT {.stdcall.} + GetState*: proc(self: ptr IShellMenu, psmd: LPSMDATA): HRESULT {.stdcall.} + SetMenuToolbar*: proc(self: ptr IShellMenu, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.stdcall.} + IShellRunDll* {.pure.} = object + lpVtbl*: ptr IShellRunDllVtbl + IShellRunDllVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Run*: proc(self: ptr IShellRunDll, pszArgs: LPCWSTR): HRESULT {.stdcall.} + IKnownFolder* {.pure.} = object + lpVtbl*: ptr IKnownFolderVtbl + IKnownFolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetId*: proc(self: ptr IKnownFolder, pkfid: ptr KNOWNFOLDERID): HRESULT {.stdcall.} + GetCategory*: proc(self: ptr IKnownFolder, pCategory: ptr KF_CATEGORY): HRESULT {.stdcall.} + GetShellItem*: proc(self: ptr IKnownFolder, dwFlags: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetPath*: proc(self: ptr IKnownFolder, dwFlags: DWORD, ppszPath: ptr LPWSTR): HRESULT {.stdcall.} + SetPath*: proc(self: ptr IKnownFolder, dwFlags: DWORD, pszPath: LPCWSTR): HRESULT {.stdcall.} + GetIDList*: proc(self: ptr IKnownFolder, dwFlags: DWORD, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + GetFolderType*: proc(self: ptr IKnownFolder, pftid: ptr FOLDERTYPEID): HRESULT {.stdcall.} + GetRedirectionCapabilities*: proc(self: ptr IKnownFolder, pCapabilities: ptr KF_REDIRECTION_CAPABILITIES): HRESULT {.stdcall.} + GetFolderDefinition*: proc(self: ptr IKnownFolder, pKFD: ptr KNOWNFOLDER_DEFINITION): HRESULT {.stdcall.} + IKnownFolderManager* {.pure.} = object + lpVtbl*: ptr IKnownFolderManagerVtbl + IKnownFolderManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FolderIdFromCsidl*: proc(self: ptr IKnownFolderManager, nCsidl: int32, pfid: ptr KNOWNFOLDERID): HRESULT {.stdcall.} + FolderIdToCsidl*: proc(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, pnCsidl: ptr int32): HRESULT {.stdcall.} + GetFolderIds*: proc(self: ptr IKnownFolderManager, ppKFId: ptr ptr KNOWNFOLDERID, pCount: ptr UINT): HRESULT {.stdcall.} + GetFolder*: proc(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, ppkf: ptr ptr IKnownFolder): HRESULT {.stdcall.} + GetFolderByName*: proc(self: ptr IKnownFolderManager, pszCanonicalName: LPCWSTR, ppkf: ptr ptr IKnownFolder): HRESULT {.stdcall.} + RegisterFolder*: proc(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, pKFD: ptr KNOWNFOLDER_DEFINITION): HRESULT {.stdcall.} + UnregisterFolder*: proc(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID): HRESULT {.stdcall.} + FindFolderFromPath*: proc(self: ptr IKnownFolderManager, pszPath: LPCWSTR, mode: FFFP_MODE, ppkf: ptr ptr IKnownFolder): HRESULT {.stdcall.} + FindFolderFromIDList*: proc(self: ptr IKnownFolderManager, pidl: PCIDLIST_ABSOLUTE, ppkf: ptr ptr IKnownFolder): HRESULT {.stdcall.} + Redirect*: proc(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, hwnd: HWND, flags: KF_REDIRECT_FLAGS, pszTargetPath: LPCWSTR, cFolders: UINT, pExclusion: ptr KNOWNFOLDERID, ppszError: ptr LPWSTR): HRESULT {.stdcall.} + ISharingConfigurationManager* {.pure.} = object + lpVtbl*: ptr ISharingConfigurationManagerVtbl + ISharingConfigurationManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateShare*: proc(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID, role: SHARE_ROLE): HRESULT {.stdcall.} + DeleteShare*: proc(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID): HRESULT {.stdcall.} + ShareExists*: proc(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID): HRESULT {.stdcall.} + GetSharePermissions*: proc(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID, pRole: ptr SHARE_ROLE): HRESULT {.stdcall.} + SharePrinters*: proc(self: ptr ISharingConfigurationManager): HRESULT {.stdcall.} + StopSharingPrinters*: proc(self: ptr ISharingConfigurationManager): HRESULT {.stdcall.} + ArePrintersShared*: proc(self: ptr ISharingConfigurationManager): HRESULT {.stdcall.} + IPreviousVersionsInfo* {.pure.} = object + lpVtbl*: ptr IPreviousVersionsInfoVtbl + IPreviousVersionsInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AreSnapshotsAvailable*: proc(self: ptr IPreviousVersionsInfo, pszPath: LPCWSTR, fOkToBeSlow: WINBOOL, pfAvailable: ptr WINBOOL): HRESULT {.stdcall.} + IRelatedItem* {.pure.} = object + lpVtbl*: ptr IRelatedItemVtbl + IRelatedItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetItemIDList*: proc(self: ptr IRelatedItem, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.stdcall.} + GetItem*: proc(self: ptr IRelatedItem, ppsi: ptr ptr IShellItem): HRESULT {.stdcall.} + IIdentityName* {.pure.} = object + lpVtbl*: ptr IIdentityNameVtbl + IIdentityNameVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IDelegateItem* {.pure.} = object + lpVtbl*: ptr IDelegateItemVtbl + IDelegateItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + ICurrentItem* {.pure.} = object + lpVtbl*: ptr ICurrentItemVtbl + ICurrentItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + ITransferMediumItem* {.pure.} = object + lpVtbl*: ptr ITransferMediumItemVtbl + ITransferMediumItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IUseToBrowseItem* {.pure.} = object + lpVtbl*: ptr IUseToBrowseItemVtbl + IUseToBrowseItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IDisplayItem* {.pure.} = object + lpVtbl*: ptr IDisplayItemVtbl + IDisplayItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IViewStateIdentityItem* {.pure.} = object + lpVtbl*: ptr IViewStateIdentityItemVtbl + IViewStateIdentityItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IPreviewItem* {.pure.} = object + lpVtbl*: ptr IPreviewItemVtbl + IPreviewItemVtbl* {.pure, inheritable.} = object of IRelatedItemVtbl + IDestinationStreamFactory* {.pure.} = object + lpVtbl*: ptr IDestinationStreamFactoryVtbl + IDestinationStreamFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDestinationStream*: proc(self: ptr IDestinationStreamFactory, ppstm: ptr ptr IStream): HRESULT {.stdcall.} + INewMenuClient* {.pure.} = object + lpVtbl*: ptr INewMenuClientVtbl + INewMenuClientVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IncludeItems*: proc(self: ptr INewMenuClient, pflags: ptr NMCII_FLAGS): HRESULT {.stdcall.} + SelectAndEditItem*: proc(self: ptr INewMenuClient, pidlItem: PCIDLIST_ABSOLUTE, flags: NMCSAEI_FLAGS): HRESULT {.stdcall.} + IInitializeWithBindCtx* {.pure.} = object + lpVtbl*: ptr IInitializeWithBindCtxVtbl + IInitializeWithBindCtxVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithBindCtx, pbc: ptr IBindCtx): HRESULT {.stdcall.} + INameSpaceTreeControl* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControlVtbl + INameSpaceTreeControlVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr INameSpaceTreeControl, hwndParent: HWND, prc: ptr RECT, nsctsFlags: NSTCSTYLE): HRESULT {.stdcall.} + TreeAdvise*: proc(self: ptr INameSpaceTreeControl, punk: ptr IUnknown, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + TreeUnadvise*: proc(self: ptr INameSpaceTreeControl, dwCookie: DWORD): HRESULT {.stdcall.} + AppendRoot*: proc(self: ptr INameSpaceTreeControl, psiRoot: ptr IShellItem, grfEnumFlags: SHCONTF, grfRootStyle: NSTCROOTSTYLE, pif: ptr IShellItemFilter): HRESULT {.stdcall.} + InsertRoot*: proc(self: ptr INameSpaceTreeControl, iIndex: int32, psiRoot: ptr IShellItem, grfEnumFlags: SHCONTF, grfRootStyle: NSTCROOTSTYLE, pif: ptr IShellItemFilter): HRESULT {.stdcall.} + RemoveRoot*: proc(self: ptr INameSpaceTreeControl, psiRoot: ptr IShellItem): HRESULT {.stdcall.} + RemoveAllRoots*: proc(self: ptr INameSpaceTreeControl): HRESULT {.stdcall.} + GetRootItems*: proc(self: ptr INameSpaceTreeControl, ppsiaRootItems: ptr ptr IShellItemArray): HRESULT {.stdcall.} + SetItemState*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisFlags: NSTCITEMSTATE): HRESULT {.stdcall.} + GetItemState*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, pnstcisFlags: ptr NSTCITEMSTATE): HRESULT {.stdcall.} + GetSelectedItems*: proc(self: ptr INameSpaceTreeControl, psiaItems: ptr ptr IShellItemArray): HRESULT {.stdcall.} + GetItemCustomState*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, piStateNumber: ptr int32): HRESULT {.stdcall.} + SetItemCustomState*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, iStateNumber: int32): HRESULT {.stdcall.} + EnsureItemVisible*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem): HRESULT {.stdcall.} + SetTheme*: proc(self: ptr INameSpaceTreeControl, pszTheme: LPCWSTR): HRESULT {.stdcall.} + GetNextItem*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcgi: NSTCGNI, ppsiNext: ptr ptr IShellItem): HRESULT {.stdcall.} + HitTest*: proc(self: ptr INameSpaceTreeControl, ppt: ptr POINT, ppsiOut: ptr ptr IShellItem): HRESULT {.stdcall.} + GetItemRect*: proc(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, prect: ptr RECT): HRESULT {.stdcall.} + CollapseAll*: proc(self: ptr INameSpaceTreeControl): HRESULT {.stdcall.} + INameSpaceTreeControl2* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControl2Vtbl + INameSpaceTreeControl2Vtbl* {.pure, inheritable.} = object of INameSpaceTreeControlVtbl + SetControlStyle*: proc(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE, nstcsStyle: NSTCSTYLE): HRESULT {.stdcall.} + GetControlStyle*: proc(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE, pnstcsStyle: ptr NSTCSTYLE): HRESULT {.stdcall.} + SetControlStyle2*: proc(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE2, nstcsStyle: NSTCSTYLE2): HRESULT {.stdcall.} + GetControlStyle2*: proc(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE2, pnstcsStyle: ptr NSTCSTYLE2): HRESULT {.stdcall.} + INameSpaceTreeControlEvents* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControlEventsVtbl + INameSpaceTreeControlEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnItemClick*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstceHitTest: NSTCEHITTEST, nstceClickType: NSTCECLICKTYPE): HRESULT {.stdcall.} + OnPropertyItemCommit*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnItemStateChanging*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisState: NSTCITEMSTATE): HRESULT {.stdcall.} + OnItemStateChanged*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisState: NSTCITEMSTATE): HRESULT {.stdcall.} + OnSelectionChanged*: proc(self: ptr INameSpaceTreeControlEvents, psiaSelection: ptr IShellItemArray): HRESULT {.stdcall.} + OnKeyboardInput*: proc(self: ptr INameSpaceTreeControlEvents, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.stdcall.} + OnBeforeExpand*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnAfterExpand*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnBeginLabelEdit*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnEndLabelEdit*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnGetToolTip*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, pszTip: LPWSTR, cchTip: int32): HRESULT {.stdcall.} + OnBeforeItemDelete*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnItemAdded*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, fIsRoot: WINBOOL): HRESULT {.stdcall.} + OnItemDeleted*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, fIsRoot: WINBOOL): HRESULT {.stdcall.} + OnBeforeContextMenu*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + OnAfterContextMenu*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, pcmIn: ptr IContextMenu, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + OnBeforeStateImageChange*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.stdcall.} + OnGetDefaultIconIndex*: proc(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, piDefaultIcon: ptr int32, piOpenIcon: ptr int32): HRESULT {.stdcall.} + INameSpaceTreeControlDropHandler* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControlDropHandlerVtbl + INameSpaceTreeControlDropHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnDragEnter*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, fOutsideSource: WINBOOL, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + OnDragOver*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + OnDragPosition*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iNewPosition: int32, iOldPosition: int32): HRESULT {.stdcall.} + OnDrop*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iPosition: int32, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.stdcall.} + OnDropPosition*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iNewPosition: int32, iOldPosition: int32): HRESULT {.stdcall.} + OnDragLeave*: proc(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem): HRESULT {.stdcall.} + INameSpaceTreeAccessible* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeAccessibleVtbl + INameSpaceTreeAccessibleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnGetDefaultAccessibilityAction*: proc(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem, pbstrDefaultAction: ptr BSTR): HRESULT {.stdcall.} + OnDoDefaultAccessibilityAction*: proc(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem): HRESULT {.stdcall.} + OnGetAccessibilityRole*: proc(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem, pvarRole: ptr VARIANT): HRESULT {.stdcall.} + INameSpaceTreeControlCustomDraw* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControlCustomDrawVtbl + INameSpaceTreeControlCustomDrawVtbl* {.pure, inheritable.} = object of IUnknownVtbl + PrePaint*: proc(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, plres: ptr LRESULT): HRESULT {.stdcall.} + PostPaint*: proc(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT): HRESULT {.stdcall.} + ItemPrePaint*: proc(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, pnstccdItem: ptr NSTCCUSTOMDRAW, pclrText: ptr COLORREF, pclrTextBk: ptr COLORREF, plres: ptr LRESULT): HRESULT {.stdcall.} + ItemPostPaint*: proc(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, pnstccdItem: ptr NSTCCUSTOMDRAW): HRESULT {.stdcall.} + INameSpaceTreeControlFolderCapabilities* {.pure.} = object + lpVtbl*: ptr INameSpaceTreeControlFolderCapabilitiesVtbl + INameSpaceTreeControlFolderCapabilitiesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFolderCapabilities*: proc(self: ptr INameSpaceTreeControlFolderCapabilities, nfcMask: NSTCFOLDERCAPABILITIES, pnfcValue: ptr NSTCFOLDERCAPABILITIES): HRESULT {.stdcall.} + IPreviewHandler* {.pure.} = object + lpVtbl*: ptr IPreviewHandlerVtbl + IPreviewHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetWindow*: proc(self: ptr IPreviewHandler, hwnd: HWND, prc: ptr RECT): HRESULT {.stdcall.} + SetRect*: proc(self: ptr IPreviewHandler, prc: ptr RECT): HRESULT {.stdcall.} + DoPreview*: proc(self: ptr IPreviewHandler): HRESULT {.stdcall.} + Unload*: proc(self: ptr IPreviewHandler): HRESULT {.stdcall.} + SetFocus*: proc(self: ptr IPreviewHandler): HRESULT {.stdcall.} + QueryFocus*: proc(self: ptr IPreviewHandler, phwnd: ptr HWND): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IPreviewHandler, pmsg: ptr MSG): HRESULT {.stdcall.} + IPreviewHandlerFrame* {.pure.} = object + lpVtbl*: ptr IPreviewHandlerFrameVtbl + IPreviewHandlerFrameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindowContext*: proc(self: ptr IPreviewHandlerFrame, pinfo: ptr PREVIEWHANDLERFRAMEINFO): HRESULT {.stdcall.} + TranslateAccelerator*: proc(self: ptr IPreviewHandlerFrame, pmsg: ptr MSG): HRESULT {.stdcall.} + ITrayDeskBand* {.pure.} = object + lpVtbl*: ptr ITrayDeskBandVtbl + ITrayDeskBandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ShowDeskBand*: proc(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.stdcall.} + HideDeskBand*: proc(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.stdcall.} + IsDeskBandShown*: proc(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.stdcall.} + DeskBandRegistrationChanged*: proc(self: ptr ITrayDeskBand): HRESULT {.stdcall.} + IBandHost* {.pure.} = object + lpVtbl*: ptr IBandHostVtbl + IBandHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateBand*: proc(self: ptr IBandHost, rclsidBand: REFCLSID, fAvailable: WINBOOL, fVisible: WINBOOL, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + SetBandAvailability*: proc(self: ptr IBandHost, rclsidBand: REFCLSID, fAvailable: WINBOOL): HRESULT {.stdcall.} + DestroyBand*: proc(self: ptr IBandHost, rclsidBand: REFCLSID): HRESULT {.stdcall.} + IExplorerPaneVisibility* {.pure.} = object + lpVtbl*: ptr IExplorerPaneVisibilityVtbl + IExplorerPaneVisibilityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetPaneState*: proc(self: ptr IExplorerPaneVisibility, ep: REFEXPLORERPANE, peps: ptr EXPLORERPANESTATE): HRESULT {.stdcall.} + IDefaultExtractIconInit* {.pure.} = object + lpVtbl*: ptr IDefaultExtractIconInitVtbl + IDefaultExtractIconInitVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFlags*: proc(self: ptr IDefaultExtractIconInit, uFlags: UINT): HRESULT {.stdcall.} + SetKey*: proc(self: ptr IDefaultExtractIconInit, hkey: HKEY): HRESULT {.stdcall.} + SetNormalIcon*: proc(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.stdcall.} + SetOpenIcon*: proc(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.stdcall.} + SetShortcutIcon*: proc(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.stdcall.} + SetDefaultIcon*: proc(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.stdcall.} + IEnumExplorerCommand* {.pure.} = object + lpVtbl*: ptr IEnumExplorerCommandVtbl + IEnumExplorerCommandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumExplorerCommand, celt: ULONG, pUICommand: ptr ptr IExplorerCommand, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IEnumExplorerCommand, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IEnumExplorerCommand): HRESULT {.stdcall.} + Clone*: proc(self: ptr IEnumExplorerCommand, ppenum: ptr ptr IEnumExplorerCommand): HRESULT {.stdcall.} + IExplorerCommand* {.pure.} = object + lpVtbl*: ptr IExplorerCommandVtbl + IExplorerCommandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetTitle*: proc(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszName: ptr LPWSTR): HRESULT {.stdcall.} + GetIcon*: proc(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszIcon: ptr LPWSTR): HRESULT {.stdcall.} + GetToolTip*: proc(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszInfotip: ptr LPWSTR): HRESULT {.stdcall.} + GetCanonicalName*: proc(self: ptr IExplorerCommand, pguidCommandName: ptr GUID): HRESULT {.stdcall.} + GetState*: proc(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, fOkToBeSlow: WINBOOL, pCmdState: ptr EXPCMDSTATE): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, pbc: ptr IBindCtx): HRESULT {.stdcall.} + GetFlags*: proc(self: ptr IExplorerCommand, pFlags: ptr EXPCMDFLAGS): HRESULT {.stdcall.} + EnumSubCommands*: proc(self: ptr IExplorerCommand, ppEnum: ptr ptr IEnumExplorerCommand): HRESULT {.stdcall.} + IExplorerCommandState* {.pure.} = object + lpVtbl*: ptr IExplorerCommandStateVtbl + IExplorerCommandStateVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetState*: proc(self: ptr IExplorerCommandState, psiItemArray: ptr IShellItemArray, fOkToBeSlow: WINBOOL, pCmdState: ptr EXPCMDSTATE): HRESULT {.stdcall.} + IInitializeCommand* {.pure.} = object + lpVtbl*: ptr IInitializeCommandVtbl + IInitializeCommandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeCommand, pszCommandName: LPCWSTR, ppb: ptr IPropertyBag): HRESULT {.stdcall.} + IExplorerCommandProvider* {.pure.} = object + lpVtbl*: ptr IExplorerCommandProviderVtbl + IExplorerCommandProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCommands*: proc(self: ptr IExplorerCommandProvider, punkSite: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetCommand*: proc(self: ptr IExplorerCommandProvider, rguidCommandId: REFGUID, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IInitializeNetworkFolder* {.pure.} = object + lpVtbl*: ptr IInitializeNetworkFolderVtbl + IInitializeNetworkFolderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeNetworkFolder, pidl: PCIDLIST_ABSOLUTE, pidlTarget: PCIDLIST_ABSOLUTE, uDisplayType: UINT, pszResName: LPCWSTR, pszProvider: LPCWSTR): HRESULT {.stdcall.} + IOpenControlPanel* {.pure.} = object + lpVtbl*: ptr IOpenControlPanelVtbl + IOpenControlPanelVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Open*: proc(self: ptr IOpenControlPanel, pszName: LPCWSTR, pszPage: LPCWSTR, punkSite: ptr IUnknown): HRESULT {.stdcall.} + GetPath*: proc(self: ptr IOpenControlPanel, pszName: LPCWSTR, pszPath: LPWSTR, cchPath: UINT): HRESULT {.stdcall.} + GetCurrentView*: proc(self: ptr IOpenControlPanel, pView: ptr CPVIEW): HRESULT {.stdcall.} + IComputerInfoChangeNotify* {.pure.} = object + lpVtbl*: ptr IComputerInfoChangeNotifyVtbl + IComputerInfoChangeNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ComputerInfoChanged*: proc(self: ptr IComputerInfoChangeNotify): HRESULT {.stdcall.} + IFileSystemBindData* {.pure.} = object + lpVtbl*: ptr IFileSystemBindDataVtbl + IFileSystemBindDataVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFindData*: proc(self: ptr IFileSystemBindData, pfd: ptr WIN32_FIND_DATAW): HRESULT {.stdcall.} + GetFindData*: proc(self: ptr IFileSystemBindData, pfd: ptr WIN32_FIND_DATAW): HRESULT {.stdcall.} + IFileSystemBindData2* {.pure.} = object + lpVtbl*: ptr IFileSystemBindData2Vtbl + IFileSystemBindData2Vtbl* {.pure, inheritable.} = object of IFileSystemBindDataVtbl + SetFileID*: proc(self: ptr IFileSystemBindData2, liFileID: LARGE_INTEGER): HRESULT {.stdcall.} + GetFileID*: proc(self: ptr IFileSystemBindData2, pliFileID: ptr LARGE_INTEGER): HRESULT {.stdcall.} + SetJunctionCLSID*: proc(self: ptr IFileSystemBindData2, clsid: REFCLSID): HRESULT {.stdcall.} + GetJunctionCLSID*: proc(self: ptr IFileSystemBindData2, pclsid: ptr CLSID): HRESULT {.stdcall.} + ICustomDestinationList* {.pure.} = object + lpVtbl*: ptr ICustomDestinationListVtbl + ICustomDestinationListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAppID*: proc(self: ptr ICustomDestinationList, pszAppID: LPCWSTR): HRESULT {.stdcall.} + BeginList*: proc(self: ptr ICustomDestinationList, pcMinSlots: ptr UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + AppendCategory*: proc(self: ptr ICustomDestinationList, pszCategory: LPCWSTR, poa: ptr IObjectArray): HRESULT {.stdcall.} + AppendKnownCategory*: proc(self: ptr ICustomDestinationList, category: KNOWNDESTCATEGORY): HRESULT {.stdcall.} + AddUserTasks*: proc(self: ptr ICustomDestinationList, poa: ptr IObjectArray): HRESULT {.stdcall.} + CommitList*: proc(self: ptr ICustomDestinationList): HRESULT {.stdcall.} + GetRemovedDestinations*: proc(self: ptr ICustomDestinationList, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + DeleteList*: proc(self: ptr ICustomDestinationList, pszAppID: LPCWSTR): HRESULT {.stdcall.} + AbortList*: proc(self: ptr ICustomDestinationList): HRESULT {.stdcall.} + IApplicationDestinations* {.pure.} = object + lpVtbl*: ptr IApplicationDestinationsVtbl + IApplicationDestinationsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAppID*: proc(self: ptr IApplicationDestinations, pszAppID: LPCWSTR): HRESULT {.stdcall.} + RemoveDestination*: proc(self: ptr IApplicationDestinations, punk: ptr IUnknown): HRESULT {.stdcall.} + RemoveAllDestinations*: proc(self: ptr IApplicationDestinations): HRESULT {.stdcall.} + IApplicationDocumentLists* {.pure.} = object + lpVtbl*: ptr IApplicationDocumentListsVtbl + IApplicationDocumentListsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAppID*: proc(self: ptr IApplicationDocumentLists, pszAppID: LPCWSTR): HRESULT {.stdcall.} + GetList*: proc(self: ptr IApplicationDocumentLists, listtype: APPDOCLISTTYPE, cItemsDesired: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IObjectWithAppUserModelID* {.pure.} = object + lpVtbl*: ptr IObjectWithAppUserModelIDVtbl + IObjectWithAppUserModelIDVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetAppID*: proc(self: ptr IObjectWithAppUserModelID, pszAppID: LPCWSTR): HRESULT {.stdcall.} + GetAppID*: proc(self: ptr IObjectWithAppUserModelID, ppszAppID: ptr LPWSTR): HRESULT {.stdcall.} + IObjectWithProgID* {.pure.} = object + lpVtbl*: ptr IObjectWithProgIDVtbl + IObjectWithProgIDVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetProgID*: proc(self: ptr IObjectWithProgID, pszProgID: LPCWSTR): HRESULT {.stdcall.} + GetProgID*: proc(self: ptr IObjectWithProgID, ppszProgID: ptr LPWSTR): HRESULT {.stdcall.} + IUpdateIDList* {.pure.} = object + lpVtbl*: ptr IUpdateIDListVtbl + IUpdateIDListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Update*: proc(self: ptr IUpdateIDList, pbc: ptr IBindCtx, pidlIn: PCUITEMID_CHILD, ppidlOut: ptr PITEMID_CHILD): HRESULT {.stdcall.} + IDesktopGadget* {.pure.} = object + lpVtbl*: ptr IDesktopGadgetVtbl + IDesktopGadgetVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RunGadget*: proc(self: ptr IDesktopGadget, gadgetPath: LPCWSTR): HRESULT {.stdcall.} + IDesktopWallpaper* {.pure.} = object + lpVtbl*: ptr IDesktopWallpaperVtbl + IDesktopWallpaperVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetWallpaper*: proc(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, wallpaper: LPCWSTR): HRESULT {.stdcall.} + GetWallpaper*: proc(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, wallpaper: ptr LPWSTR): HRESULT {.stdcall.} + GetMonitorDevicePathAt*: proc(self: ptr IDesktopWallpaper, monitorIndex: UINT, monitorID: ptr LPWSTR): HRESULT {.stdcall.} + GetMonitorDevicePathCount*: proc(self: ptr IDesktopWallpaper, count: ptr UINT): HRESULT {.stdcall.} + GetMonitorRECT*: proc(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, displayRect: ptr RECT): HRESULT {.stdcall.} + SetBackgroundColor*: proc(self: ptr IDesktopWallpaper, color: COLORREF): HRESULT {.stdcall.} + GetBackgroundColor*: proc(self: ptr IDesktopWallpaper, color: ptr COLORREF): HRESULT {.stdcall.} + SetPosition*: proc(self: ptr IDesktopWallpaper, position: DESKTOP_WALLPAPER_POSITION): HRESULT {.stdcall.} + GetPosition*: proc(self: ptr IDesktopWallpaper, position: ptr DESKTOP_WALLPAPER_POSITION): HRESULT {.stdcall.} + SetSlideshow*: proc(self: ptr IDesktopWallpaper, items: ptr IShellItemArray): HRESULT {.stdcall.} + GetSlideshow*: proc(self: ptr IDesktopWallpaper, items: ptr ptr IShellItemArray): HRESULT {.stdcall.} + SetSlideshowOptions*: proc(self: ptr IDesktopWallpaper, options: DESKTOP_SLIDESHOW_OPTIONS, slideshowTick: UINT): HRESULT {.stdcall.} + GetSlideshowOptions*: proc(self: ptr IDesktopWallpaper, options: ptr DESKTOP_SLIDESHOW_OPTIONS, slideshowTick: ptr UINT): HRESULT {.stdcall.} + AdvanceSlideshow*: proc(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, direction: DESKTOP_SLIDESHOW_DIRECTION): HRESULT {.stdcall.} + GetStatus*: proc(self: ptr IDesktopWallpaper, state: ptr DESKTOP_SLIDESHOW_STATE): HRESULT {.stdcall.} + Enable*: proc(self: ptr IDesktopWallpaper, enable: WINBOOL): HRESULT {.stdcall.} + IHomeGroup* {.pure.} = object + lpVtbl*: ptr IHomeGroupVtbl + IHomeGroupVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsMember*: proc(self: ptr IHomeGroup, member: ptr WINBOOL): HRESULT {.stdcall.} + ShowSharingWizard*: proc(self: ptr IHomeGroup, owner: HWND, sharingchoices: ptr HOMEGROUPSHARINGCHOICES): HRESULT {.stdcall.} + IInitializeWithPropertyStore* {.pure.} = object + lpVtbl*: ptr IInitializeWithPropertyStoreVtbl + IInitializeWithPropertyStoreVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithPropertyStore, pps: ptr IPropertyStore): HRESULT {.stdcall.} + IOpenSearchSource* {.pure.} = object + lpVtbl*: ptr IOpenSearchSourceVtbl + IOpenSearchSourceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetResults*: proc(self: ptr IOpenSearchSource, hwnd: HWND, pszQuery: LPCWSTR, dwStartIndex: DWORD, dwCount: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IShellLibrary* {.pure.} = object + lpVtbl*: ptr IShellLibraryVtbl + IShellLibraryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + LoadLibraryFromItem*: proc(self: ptr IShellLibrary, psiLibrary: ptr IShellItem, grfMode: DWORD): HRESULT {.stdcall.} + LoadLibraryFromKnownFolder*: proc(self: ptr IShellLibrary, kfidLibrary: REFKNOWNFOLDERID, grfMode: DWORD): HRESULT {.stdcall.} + AddFolder*: proc(self: ptr IShellLibrary, psiLocation: ptr IShellItem): HRESULT {.stdcall.} + RemoveFolder*: proc(self: ptr IShellLibrary, psiLocation: ptr IShellItem): HRESULT {.stdcall.} + GetFolders*: proc(self: ptr IShellLibrary, lff: LIBRARYFOLDERFILTER, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + ResolveFolder*: proc(self: ptr IShellLibrary, psiFolderToResolve: ptr IShellItem, dwTimeout: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + GetDefaultSaveFolder*: proc(self: ptr IShellLibrary, dsft: DEFAULTSAVEFOLDERTYPE, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + SetDefaultSaveFolder*: proc(self: ptr IShellLibrary, dsft: DEFAULTSAVEFOLDERTYPE, psi: ptr IShellItem): HRESULT {.stdcall.} + GetOptions*: proc(self: ptr IShellLibrary, plofOptions: ptr LIBRARYOPTIONFLAGS): HRESULT {.stdcall.} + SetOptions*: proc(self: ptr IShellLibrary, lofMask: LIBRARYOPTIONFLAGS, lofOptions: LIBRARYOPTIONFLAGS): HRESULT {.stdcall.} + GetFolderType*: proc(self: ptr IShellLibrary, pftid: ptr FOLDERTYPEID): HRESULT {.stdcall.} + SetFolderType*: proc(self: ptr IShellLibrary, ftid: REFFOLDERTYPEID): HRESULT {.stdcall.} + GetIcon*: proc(self: ptr IShellLibrary, ppszIcon: ptr LPWSTR): HRESULT {.stdcall.} + SetIcon*: proc(self: ptr IShellLibrary, pszIcon: LPCWSTR): HRESULT {.stdcall.} + Commit*: proc(self: ptr IShellLibrary): HRESULT {.stdcall.} + Save*: proc(self: ptr IShellLibrary, psiFolderToSaveIn: ptr IShellItem, pszLibraryName: LPCWSTR, lsf: LIBRARYSAVEFLAGS, ppsiSavedTo: ptr ptr IShellItem): HRESULT {.stdcall.} + SaveInKnownFolder*: proc(self: ptr IShellLibrary, kfidToSaveIn: REFKNOWNFOLDERID, pszLibraryName: LPCWSTR, lsf: LIBRARYSAVEFLAGS, ppsiSavedTo: ptr ptr IShellItem): HRESULT {.stdcall.} + IPlaybackManagerEvents* {.pure.} = object + lpVtbl*: ptr IPlaybackManagerEventsVtbl + IPlaybackManagerEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnPlaybackManagerEvent*: proc(self: ptr IPlaybackManagerEvents, dwSessionId: DWORD, mediaEvent: PBM_EVENT): HRESULT {.stdcall.} + IPlaybackManager* {.pure.} = object + lpVtbl*: ptr IPlaybackManagerVtbl + IPlaybackManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr IPlaybackManager, `type`: PBM_SESSION_TYPE, pEvents: ptr IPlaybackManagerEvents, pdwSessionId: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IPlaybackManager, dwSessionId: DWORD): HRESULT {.stdcall.} + ChangeSessionState*: proc(self: ptr IPlaybackManager, dwSessionId: DWORD, state: PBM_PLAY_STATE, mute: PBM_MUTE_STATE): HRESULT {.stdcall.} + IDefaultFolderMenuInitialize* {.pure.} = object + lpVtbl*: ptr IDefaultFolderMenuInitializeVtbl + IDefaultFolderMenuInitializeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IDefaultFolderMenuInitialize, hwnd: HWND, pcmcb: ptr IContextMenuCB, pidlFolder: PCIDLIST_ABSOLUTE, psf: ptr IShellFolder, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, punkAssociation: ptr IUnknown, cKeys: UINT, aKeys: ptr HKEY): HRESULT {.stdcall.} + SetMenuRestrictions*: proc(self: ptr IDefaultFolderMenuInitialize, dfmrValues: DEFAULT_FOLDER_MENU_RESTRICTIONS): HRESULT {.stdcall.} + GetMenuRestrictions*: proc(self: ptr IDefaultFolderMenuInitialize, dfmrMask: DEFAULT_FOLDER_MENU_RESTRICTIONS, pdfmrValues: ptr DEFAULT_FOLDER_MENU_RESTRICTIONS): HRESULT {.stdcall.} + SetHandlerClsid*: proc(self: ptr IDefaultFolderMenuInitialize, rclsid: REFCLSID): HRESULT {.stdcall.} + IApplicationActivationManager* {.pure.} = object + lpVtbl*: ptr IApplicationActivationManagerVtbl + IApplicationActivationManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ActivateApplication*: proc(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, arguments: LPCWSTR, options: ACTIVATEOPTIONS, processId: ptr DWORD): HRESULT {.stdcall.} + ActivateForFile*: proc(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, itemArray: ptr IShellItemArray, verb: LPCWSTR, processId: ptr DWORD): HRESULT {.stdcall.} + ActivateForProtocol*: proc(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, itemArray: ptr IShellItemArray, processId: ptr DWORD): HRESULT {.stdcall.} + IAssocHandlerInvoker* {.pure.} = object + lpVtbl*: ptr IAssocHandlerInvokerVtbl + IAssocHandlerInvokerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SupportsSelection*: proc(self: ptr IAssocHandlerInvoker): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IAssocHandlerInvoker): HRESULT {.stdcall.} + IAssocHandler* {.pure.} = object + lpVtbl*: ptr IAssocHandlerVtbl + IAssocHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetName*: proc(self: ptr IAssocHandler, ppsz: ptr LPWSTR): HRESULT {.stdcall.} + GetUIName*: proc(self: ptr IAssocHandler, ppsz: ptr LPWSTR): HRESULT {.stdcall.} + GetIconLocation*: proc(self: ptr IAssocHandler, ppszPath: ptr LPWSTR, pIndex: ptr int32): HRESULT {.stdcall.} + IsRecommended*: proc(self: ptr IAssocHandler): HRESULT {.stdcall.} + MakeDefault*: proc(self: ptr IAssocHandler, pszDescription: LPCWSTR): HRESULT {.stdcall.} + Invoke*: proc(self: ptr IAssocHandler, pdo: ptr IDataObject): HRESULT {.stdcall.} + CreateInvoker*: proc(self: ptr IAssocHandler, pdo: ptr IDataObject, ppInvoker: ptr ptr IAssocHandlerInvoker): HRESULT {.stdcall.} + IEnumAssocHandlers* {.pure.} = object + lpVtbl*: ptr IEnumAssocHandlersVtbl + IEnumAssocHandlersVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IEnumAssocHandlers, celt: ULONG, rgelt: ptr ptr IAssocHandler, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + IDataObjectProvider* {.pure.} = object + lpVtbl*: ptr IDataObjectProviderVtbl + IDataObjectProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDataObject*: proc(self: ptr IDataObjectProvider, dataObject: ptr ptr IDataObject): HRESULT {.stdcall.} + SetDataObject*: proc(self: ptr IDataObjectProvider, dataObject: ptr IDataObject): HRESULT {.stdcall.} + IDataTransferManagerInterop* {.pure.} = object + lpVtbl*: ptr IDataTransferManagerInteropVtbl + IDataTransferManagerInteropVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetForWindow*: proc(self: ptr IDataTransferManagerInterop, appWindow: HWND, riid: REFIID, dataTransferManager: ptr pointer): HRESULT {.stdcall.} + ShowShareUIForWindow*: proc(self: ptr IDataTransferManagerInterop, appWindow: HWND): HRESULT {.stdcall.} + IFrameworkInputPaneHandler* {.pure.} = object + lpVtbl*: ptr IFrameworkInputPaneHandlerVtbl + IFrameworkInputPaneHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Showing*: proc(self: ptr IFrameworkInputPaneHandler, prcInputPaneScreenLocation: ptr RECT, fEnsureFocusedElementInView: WINBOOL): HRESULT {.stdcall.} + Hiding*: proc(self: ptr IFrameworkInputPaneHandler, fEnsureFocusedElementInView: WINBOOL): HRESULT {.stdcall.} + IFrameworkInputPane* {.pure.} = object + lpVtbl*: ptr IFrameworkInputPaneVtbl + IFrameworkInputPaneVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Advise*: proc(self: ptr IFrameworkInputPane, pWindow: ptr IUnknown, pHandler: ptr IFrameworkInputPaneHandler, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + AdviseWithHWND*: proc(self: ptr IFrameworkInputPane, hwnd: HWND, pHandler: ptr IFrameworkInputPaneHandler, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IFrameworkInputPane, dwCookie: DWORD): HRESULT {.stdcall.} + Location*: proc(self: ptr IFrameworkInputPane, prcInputPaneScreenLocation: ptr RECT): HRESULT {.stdcall.} + ISearchableApplication* {.pure.} = object + lpVtbl*: ptr ISearchableApplicationVtbl + ISearchableApplicationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSearchWindow*: proc(self: ptr ISearchableApplication, hwnd: ptr HWND): HRESULT {.stdcall.} + IAccessibilityDockingServiceCallback* {.pure.} = object + lpVtbl*: ptr IAccessibilityDockingServiceCallbackVtbl + IAccessibilityDockingServiceCallbackVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Undocked*: proc(self: ptr IAccessibilityDockingServiceCallback, undockReason: UNDOCK_REASON): HRESULT {.stdcall.} + IAccessibilityDockingService* {.pure.} = object + lpVtbl*: ptr IAccessibilityDockingServiceVtbl + IAccessibilityDockingServiceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetAvailableSize*: proc(self: ptr IAccessibilityDockingService, hMonitor: HMONITOR, pcxFixed: ptr UINT, pcyMax: ptr UINT): HRESULT {.stdcall.} + DockWindow*: proc(self: ptr IAccessibilityDockingService, hwnd: HWND, hMonitor: HMONITOR, cyRequested: UINT, pCallback: ptr IAccessibilityDockingServiceCallback): HRESULT {.stdcall.} + UndockWindow*: proc(self: ptr IAccessibilityDockingService, hwnd: HWND): HRESULT {.stdcall.} + IAppVisibilityEvents* {.pure.} = object + lpVtbl*: ptr IAppVisibilityEventsVtbl + IAppVisibilityEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AppVisibilityOnMonitorChanged*: proc(self: ptr IAppVisibilityEvents, hMonitor: HMONITOR, previousMode: MONITOR_APP_VISIBILITY, currentMode: MONITOR_APP_VISIBILITY): HRESULT {.stdcall.} + LauncherVisibilityChange*: proc(self: ptr IAppVisibilityEvents, currentVisibleState: WINBOOL): HRESULT {.stdcall.} + IAppVisibility* {.pure.} = object + lpVtbl*: ptr IAppVisibilityVtbl + IAppVisibilityVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetAppVisibilityOnMonitor*: proc(self: ptr IAppVisibility, hMonitor: HMONITOR, pMode: ptr MONITOR_APP_VISIBILITY): HRESULT {.stdcall.} + IsLauncherVisible*: proc(self: ptr IAppVisibility, pfVisible: ptr WINBOOL): HRESULT {.stdcall.} + Advise*: proc(self: ptr IAppVisibility, pCallback: ptr IAppVisibilityEvents, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + Unadvise*: proc(self: ptr IAppVisibility, dwCookie: DWORD): HRESULT {.stdcall.} + IPackageExecutionStateChangeNotification* {.pure.} = object + lpVtbl*: ptr IPackageExecutionStateChangeNotificationVtbl + IPackageExecutionStateChangeNotificationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnStateChanged*: proc(self: ptr IPackageExecutionStateChangeNotification, pszPackageFullName: LPCWSTR, pesNewState: PACKAGE_EXECUTION_STATE): HRESULT {.stdcall.} + IPackageDebugSettings* {.pure.} = object + lpVtbl*: ptr IPackageDebugSettingsVtbl + IPackageDebugSettingsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + EnableDebugging*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, debuggerCommandLine: LPCWSTR, environment: PZZWSTR): HRESULT {.stdcall.} + DisableDebugging*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + Suspend*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + Resume*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + TerminateAllProcesses*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + SetTargetSessionId*: proc(self: ptr IPackageDebugSettings, sessionId: ULONG): HRESULT {.stdcall.} + EnumerateBackgroundTasks*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, taskCount: ptr ULONG, taskIds: ptr LPCGUID, taskNames: ptr ptr LPCWSTR): HRESULT {.stdcall.} + ActivateBackgroundTask*: proc(self: ptr IPackageDebugSettings, taskId: LPCGUID): HRESULT {.stdcall.} + StartServicing*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + StopServicing*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + StartSessionRedirection*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, sessionId: ULONG): HRESULT {.stdcall.} + StopSessionRedirection*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.stdcall.} + GetPackageExecutionState*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, packageExecutionState: ptr PACKAGE_EXECUTION_STATE): HRESULT {.stdcall.} + RegisterForPackageStateChanges*: proc(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, pPackageExecutionStateChangeNotification: ptr IPackageExecutionStateChangeNotification, pdwCookie: ptr DWORD): HRESULT {.stdcall.} + UnregisterForPackageStateChanges*: proc(self: ptr IPackageDebugSettings, dwCookie: DWORD): HRESULT {.stdcall.} + IExecuteCommandApplicationHostEnvironment* {.pure.} = object + lpVtbl*: ptr IExecuteCommandApplicationHostEnvironmentVtbl + IExecuteCommandApplicationHostEnvironmentVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetValue*: proc(self: ptr IExecuteCommandApplicationHostEnvironment, pahe: ptr AHE_TYPE): HRESULT {.stdcall.} + IExecuteCommandHost* {.pure.} = object + lpVtbl*: ptr IExecuteCommandHostVtbl + IExecuteCommandHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetUIMode*: proc(self: ptr IExecuteCommandHost, pUIMode: ptr EC_HOST_UI_MODE): HRESULT {.stdcall.} + IApplicationDesignModeSettings* {.pure.} = object + lpVtbl*: ptr IApplicationDesignModeSettingsVtbl + IApplicationDesignModeSettingsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetNativeDisplaySize*: proc(self: ptr IApplicationDesignModeSettings, sizeNativeDisplay: SIZE): HRESULT {.stdcall.} + SetScaleFactor*: proc(self: ptr IApplicationDesignModeSettings, scaleFactor: DEVICE_SCALE_FACTOR): HRESULT {.stdcall.} + SetApplicationViewState*: proc(self: ptr IApplicationDesignModeSettings, viewState: APPLICATION_VIEW_STATE): HRESULT {.stdcall.} + ComputeApplicationSize*: proc(self: ptr IApplicationDesignModeSettings, psizeApplication: ptr SIZE): HRESULT {.stdcall.} + IsApplicationViewStateSupported*: proc(self: ptr IApplicationDesignModeSettings, viewState: APPLICATION_VIEW_STATE, sizeNativeDisplay: SIZE, scaleFactor: DEVICE_SCALE_FACTOR, pfSupported: ptr WINBOOL): HRESULT {.stdcall.} + TriggerEdgeGesture*: proc(self: ptr IApplicationDesignModeSettings, edgeGestureKind: EDGE_GESTURE_KIND): HRESULT {.stdcall.} + IInitializeWithWindow* {.pure.} = object + lpVtbl*: ptr IInitializeWithWindowVtbl + IInitializeWithWindowVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeWithWindow, hwnd: HWND): HRESULT {.stdcall.} + IHandlerInfo* {.pure.} = object + lpVtbl*: ptr IHandlerInfoVtbl + IHandlerInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetApplicationDisplayName*: proc(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.stdcall.} + GetApplicationPublisher*: proc(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.stdcall.} + GetApplicationIconReference*: proc(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.stdcall.} + IHandlerActivationHost* {.pure.} = object + lpVtbl*: ptr IHandlerActivationHostVtbl + IHandlerActivationHostVtbl* {.pure, inheritable.} = object of IUnknownVtbl + BeforeCoCreateInstance*: proc(self: ptr IHandlerActivationHost, clsidHandler: REFCLSID, itemsBeingActivated: ptr IShellItemArray, handlerInfo: ptr IHandlerInfo): HRESULT {.stdcall.} + BeforeCreateProcess*: proc(self: ptr IHandlerActivationHost, applicationPath: LPCWSTR, commandLine: LPCWSTR, handlerInfo: ptr IHandlerInfo): HRESULT {.stdcall.} + IShellIconOverlayIdentifier* {.pure.} = object + lpVtbl*: ptr IShellIconOverlayIdentifierVtbl + IShellIconOverlayIdentifierVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IsMemberOf*: proc(self: ptr IShellIconOverlayIdentifier, pwszPath: PCWSTR, dwAttrib: DWORD): HRESULT {.stdcall.} + GetOverlayInfo*: proc(self: ptr IShellIconOverlayIdentifier, pwszIconFile: PWSTR, cchMax: int32, pIndex: ptr int32, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + GetPriority*: proc(self: ptr IShellIconOverlayIdentifier, pIPriority: ptr int32): HRESULT {.stdcall.} + IShellIconOverlayManager* {.pure.} = object + lpVtbl*: ptr IShellIconOverlayManagerVtbl + IShellIconOverlayManagerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFileOverlayInfo*: proc(self: ptr IShellIconOverlayManager, pwszPath: PCWSTR, dwAttrib: DWORD, pIndex: ptr int32, dwflags: DWORD): HRESULT {.stdcall.} + GetReservedOverlayInfo*: proc(self: ptr IShellIconOverlayManager, pwszPath: PCWSTR, dwAttrib: DWORD, pIndex: ptr int32, dwflags: DWORD, iReservedID: int32): HRESULT {.stdcall.} + RefreshOverlayImages*: proc(self: ptr IShellIconOverlayManager, dwFlags: DWORD): HRESULT {.stdcall.} + LoadNonloadedOverlayIdentifiers*: proc(self: ptr IShellIconOverlayManager): HRESULT {.stdcall.} + OverlayIndexFromImageIndex*: proc(self: ptr IShellIconOverlayManager, iImage: int32, piIndex: ptr int32, fAdd: WINBOOL): HRESULT {.stdcall.} + IShellIconOverlay* {.pure.} = object + lpVtbl*: ptr IShellIconOverlayVtbl + IShellIconOverlayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetOverlayIndex*: proc(self: ptr IShellIconOverlay, pidl: PCUITEMID_CHILD, pIndex: ptr int32): HRESULT {.stdcall.} + GetOverlayIconIndex*: proc(self: ptr IShellIconOverlay, pidl: PCUITEMID_CHILD, pIconIndex: ptr int32): HRESULT {.stdcall.} + IShellExecuteHookA* {.pure.} = object + lpVtbl*: ptr IShellExecuteHookAVtbl + IShellExecuteHookAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Execute*: proc(self: ptr IShellExecuteHookA, pei: LPSHELLEXECUTEINFOA): HRESULT {.stdcall.} + IShellExecuteHookW* {.pure.} = object + lpVtbl*: ptr IShellExecuteHookWVtbl + IShellExecuteHookWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Execute*: proc(self: ptr IShellExecuteHookW, pei: LPSHELLEXECUTEINFOW): HRESULT {.stdcall.} + IURLSearchHook* {.pure.} = object + lpVtbl*: ptr IURLSearchHookVtbl + IURLSearchHookVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Translate*: proc(self: ptr IURLSearchHook, pwszSearchURL: PWSTR, cchBufferSize: DWORD): HRESULT {.stdcall.} + ISearchContext* {.pure.} = object + lpVtbl*: ptr ISearchContextVtbl + ISearchContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSearchUrl*: proc(self: ptr ISearchContext, pbstrSearchUrl: ptr BSTR): HRESULT {.stdcall.} + GetSearchText*: proc(self: ptr ISearchContext, pbstrSearchText: ptr BSTR): HRESULT {.stdcall.} + GetSearchStyle*: proc(self: ptr ISearchContext, pdwSearchStyle: ptr DWORD): HRESULT {.stdcall.} + IURLSearchHook2* {.pure.} = object + lpVtbl*: ptr IURLSearchHook2Vtbl + IURLSearchHook2Vtbl* {.pure, inheritable.} = object of IURLSearchHookVtbl + TranslateWithSearchContext*: proc(self: ptr IURLSearchHook2, pwszSearchURL: PWSTR, cchBufferSize: DWORD, pSearchContext: ptr ISearchContext): HRESULT {.stdcall.} + INewShortcutHookA* {.pure.} = object + lpVtbl*: ptr INewShortcutHookAVtbl + INewShortcutHookAVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetReferent*: proc(self: ptr INewShortcutHookA, pcszReferent: PCSTR, hwnd: HWND): HRESULT {.stdcall.} + GetReferent*: proc(self: ptr INewShortcutHookA, pszReferent: PSTR, cchReferent: int32): HRESULT {.stdcall.} + SetFolder*: proc(self: ptr INewShortcutHookA, pcszFolder: PCSTR): HRESULT {.stdcall.} + GetFolder*: proc(self: ptr INewShortcutHookA, pszFolder: PSTR, cchFolder: int32): HRESULT {.stdcall.} + GetName*: proc(self: ptr INewShortcutHookA, pszName: PSTR, cchName: int32): HRESULT {.stdcall.} + GetExtension*: proc(self: ptr INewShortcutHookA, pszExtension: PSTR, cchExtension: int32): HRESULT {.stdcall.} + INewShortcutHookW* {.pure.} = object + lpVtbl*: ptr INewShortcutHookWVtbl + INewShortcutHookWVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetReferent*: proc(self: ptr INewShortcutHookW, pcszReferent: PCWSTR, hwnd: HWND): HRESULT {.stdcall.} + GetReferent*: proc(self: ptr INewShortcutHookW, pszReferent: PWSTR, cchReferent: int32): HRESULT {.stdcall.} + SetFolder*: proc(self: ptr INewShortcutHookW, pcszFolder: PCWSTR): HRESULT {.stdcall.} + GetFolder*: proc(self: ptr INewShortcutHookW, pszFolder: PWSTR, cchFolder: int32): HRESULT {.stdcall.} + GetName*: proc(self: ptr INewShortcutHookW, pszName: PWSTR, cchName: int32): HRESULT {.stdcall.} + GetExtension*: proc(self: ptr INewShortcutHookW, pszExtension: PWSTR, cchExtension: int32): HRESULT {.stdcall.} + IShellDetails* {.pure.} = object + lpVtbl*: ptr IShellDetailsVtbl + IShellDetailsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDetailsOf*: proc(self: ptr IShellDetails, pidl: PCUITEMID_CHILD, iColumn: UINT, pDetails: ptr SHELLDETAILS): HRESULT {.stdcall.} + ColumnClick*: proc(self: ptr IShellDetails, iColumn: UINT): HRESULT {.stdcall.} + IObjMgr* {.pure.} = object + lpVtbl*: ptr IObjMgrVtbl + IObjMgrVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Append*: proc(self: ptr IObjMgr, punk: ptr IUnknown): HRESULT {.stdcall.} + Remove*: proc(self: ptr IObjMgr, punk: ptr IUnknown): HRESULT {.stdcall.} + ICurrentWorkingDirectory* {.pure.} = object + lpVtbl*: ptr ICurrentWorkingDirectoryVtbl + ICurrentWorkingDirectoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetDirectory*: proc(self: ptr ICurrentWorkingDirectory, pwzPath: PWSTR, cchSize: DWORD): HRESULT {.stdcall.} + SetDirectory*: proc(self: ptr ICurrentWorkingDirectory, pwzPath: PCWSTR): HRESULT {.stdcall.} + IACList* {.pure.} = object + lpVtbl*: ptr IACListVtbl + IACListVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Expand*: proc(self: ptr IACList, pszExpand: PCWSTR): HRESULT {.stdcall.} + IACList2* {.pure.} = object + lpVtbl*: ptr IACList2Vtbl + IACList2Vtbl* {.pure, inheritable.} = object of IACListVtbl + SetOptions*: proc(self: ptr IACList2, dwFlag: DWORD): HRESULT {.stdcall.} + GetOptions*: proc(self: ptr IACList2, pdwFlag: ptr DWORD): HRESULT {.stdcall.} + IProgressDialog* {.pure.} = object + lpVtbl*: ptr IProgressDialogVtbl + IProgressDialogVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartProgressDialog*: proc(self: ptr IProgressDialog, hwndParent: HWND, punkEnableModless: ptr IUnknown, dwFlags: DWORD, pvResevered: LPCVOID): HRESULT {.stdcall.} + StopProgressDialog*: proc(self: ptr IProgressDialog): HRESULT {.stdcall.} + SetTitle*: proc(self: ptr IProgressDialog, pwzTitle: PCWSTR): HRESULT {.stdcall.} + SetAnimation*: proc(self: ptr IProgressDialog, hInstAnimation: HINSTANCE, idAnimation: UINT): HRESULT {.stdcall.} + HasUserCancelled*: proc(self: ptr IProgressDialog): WINBOOL {.stdcall.} + SetProgress*: proc(self: ptr IProgressDialog, dwCompleted: DWORD, dwTotal: DWORD): HRESULT {.stdcall.} + SetProgress64*: proc(self: ptr IProgressDialog, ullCompleted: ULONGLONG, ullTotal: ULONGLONG): HRESULT {.stdcall.} + SetLine*: proc(self: ptr IProgressDialog, dwLineNum: DWORD, pwzString: PCWSTR, fCompactPath: WINBOOL, pvResevered: LPCVOID): HRESULT {.stdcall.} + SetCancelMsg*: proc(self: ptr IProgressDialog, pwzCancelMsg: PCWSTR, pvResevered: LPCVOID): HRESULT {.stdcall.} + Timer*: proc(self: ptr IProgressDialog, dwTimerAction: DWORD, pvResevered: LPCVOID): HRESULT {.stdcall.} + IDockingWindowSite* {.pure.} = object + lpVtbl*: ptr IDockingWindowSiteVtbl + IDockingWindowSiteVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + GetBorderDW*: proc(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, prcBorder: ptr RECT): HRESULT {.stdcall.} + RequestBorderSpaceDW*: proc(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, pbw: LPCBORDERWIDTHS): HRESULT {.stdcall.} + SetBorderSpaceDW*: proc(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, pbw: LPCBORDERWIDTHS): HRESULT {.stdcall.} + IDockingWindowFrame* {.pure.} = object + lpVtbl*: ptr IDockingWindowFrameVtbl + IDockingWindowFrameVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + AddToolbar*: proc(self: ptr IDockingWindowFrame, punkSrc: ptr IUnknown, pwszItem: PCWSTR, dwAddFlags: DWORD): HRESULT {.stdcall.} + RemoveToolbar*: proc(self: ptr IDockingWindowFrame, punkSrc: ptr IUnknown, dwRemoveFlags: DWORD): HRESULT {.stdcall.} + FindToolbar*: proc(self: ptr IDockingWindowFrame, pwszItem: PCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.stdcall.} + IShellFolderBand* {.pure.} = object + lpVtbl*: ptr IShellFolderBandVtbl + IShellFolderBandVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitializeSFB*: proc(self: ptr IShellFolderBand, psf: ptr IShellFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + SetBandInfoSFB*: proc(self: ptr IShellFolderBand, pbi: PBANDINFOSFB): HRESULT {.stdcall.} + GetBandInfoSFB*: proc(self: ptr IShellFolderBand, pbi: PBANDINFOSFB): HRESULT {.stdcall.} + IDeskBarClient* {.pure.} = object + lpVtbl*: ptr IDeskBarClientVtbl + IDeskBarClientVtbl* {.pure, inheritable.} = object of IOleWindowVtbl + SetDeskBarSite*: proc(self: ptr IDeskBarClient, punkSite: ptr IUnknown): HRESULT {.stdcall.} + SetModeDBC*: proc(self: ptr IDeskBarClient, dwMode: DWORD): HRESULT {.stdcall.} + UIActivateDBC*: proc(self: ptr IDeskBarClient, dwState: DWORD): HRESULT {.stdcall.} + GetSize*: proc(self: ptr IDeskBarClient, dwWhich: DWORD, prc: LPRECT): HRESULT {.stdcall.} + IColumnProvider* {.pure.} = object + lpVtbl*: ptr IColumnProviderVtbl + IColumnProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IColumnProvider, psci: LPCSHCOLUMNINIT): HRESULT {.stdcall.} + GetColumnInfo*: proc(self: ptr IColumnProvider, dwIndex: DWORD, psci: ptr SHCOLUMNINFO): HRESULT {.stdcall.} + GetItemData*: proc(self: ptr IColumnProvider, pscid: LPCSHCOLUMNID, pscd: LPCSHCOLUMNDATA, pvarData: ptr VARIANT): HRESULT {.stdcall.} + IShellChangeNotify* {.pure.} = object + lpVtbl*: ptr IShellChangeNotifyVtbl + IShellChangeNotifyVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnChange*: proc(self: ptr IShellChangeNotify, lEvent: LONG, pidl1: PCIDLIST_ABSOLUTE, pidl2: PCIDLIST_ABSOLUTE): HRESULT {.stdcall.} + IQueryInfo* {.pure.} = object + lpVtbl*: ptr IQueryInfoVtbl + IQueryInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetInfoTip*: proc(self: ptr IQueryInfo, dwFlags: DWORD, ppwszTip: ptr PWSTR): HRESULT {.stdcall.} + GetInfoFlags*: proc(self: ptr IQueryInfo, pdwFlags: ptr DWORD): HRESULT {.stdcall.} + IDefViewFrame* {.pure.} = object + lpVtbl*: ptr IDefViewFrameVtbl + IDefViewFrameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetWindowLV*: proc(self: ptr IDefViewFrame, phwnd: ptr HWND): HRESULT {.stdcall.} + ReleaseWindowLV*: proc(self: ptr IDefViewFrame): HRESULT {.stdcall.} + GetShellFolder*: proc(self: ptr IDefViewFrame, ppsf: ptr ptr IShellFolder): HRESULT {.stdcall.} + IDocViewSite* {.pure.} = object + lpVtbl*: ptr IDocViewSiteVtbl + IDocViewSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + OnSetTitle*: proc(self: ptr IDocViewSite, pvTitle: ptr VARIANTARG): HRESULT {.stdcall.} + IInitializeObject* {.pure.} = object + lpVtbl*: ptr IInitializeObjectVtbl + IInitializeObjectVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IInitializeObject): HRESULT {.stdcall.} + IBanneredBar* {.pure.} = object + lpVtbl*: ptr IBanneredBarVtbl + IBanneredBarVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetIconSize*: proc(self: ptr IBanneredBar, iIcon: DWORD): HRESULT {.stdcall.} + GetIconSize*: proc(self: ptr IBanneredBar, piIcon: ptr DWORD): HRESULT {.stdcall.} + SetBitmap*: proc(self: ptr IBanneredBar, hBitmap: HBITMAP): HRESULT {.stdcall.} + GetBitmap*: proc(self: ptr IBanneredBar, phBitmap: ptr HBITMAP): HRESULT {.stdcall.} + IShellFolderView* {.pure.} = object + lpVtbl*: ptr IShellFolderViewVtbl + IShellFolderViewVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Rearrange*: proc(self: ptr IShellFolderView, lParamSort: LPARAM): HRESULT {.stdcall.} + GetArrangeParam*: proc(self: ptr IShellFolderView, plParamSort: ptr LPARAM): HRESULT {.stdcall.} + ArrangeGrid*: proc(self: ptr IShellFolderView): HRESULT {.stdcall.} + AutoArrange*: proc(self: ptr IShellFolderView): HRESULT {.stdcall.} + GetAutoArrange*: proc(self: ptr IShellFolderView): HRESULT {.stdcall.} + AddObject*: proc(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.stdcall.} + GetObject*: proc(self: ptr IShellFolderView, ppidl: ptr PITEMID_CHILD, uItem: UINT): HRESULT {.stdcall.} + RemoveObject*: proc(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.stdcall.} + GetObjectCount*: proc(self: ptr IShellFolderView, puCount: ptr UINT): HRESULT {.stdcall.} + SetObjectCount*: proc(self: ptr IShellFolderView, uCount: UINT, dwFlags: UINT): HRESULT {.stdcall.} + UpdateObject*: proc(self: ptr IShellFolderView, pidlOld: PUITEMID_CHILD, pidlNew: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.stdcall.} + RefreshObject*: proc(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.stdcall.} + SetRedraw*: proc(self: ptr IShellFolderView, bRedraw: WINBOOL): HRESULT {.stdcall.} + GetSelectedCount*: proc(self: ptr IShellFolderView, puSelected: ptr UINT): HRESULT {.stdcall.} + GetSelectedObjects*: proc(self: ptr IShellFolderView, pppidl: ptr ptr PCUITEMID_CHILD, puItems: ptr UINT): HRESULT {.stdcall.} + IsDropOnSource*: proc(self: ptr IShellFolderView, pDropTarget: ptr IDropTarget): HRESULT {.stdcall.} + GetDragPoint*: proc(self: ptr IShellFolderView, ppt: ptr POINT): HRESULT {.stdcall.} + GetDropPoint*: proc(self: ptr IShellFolderView, ppt: ptr POINT): HRESULT {.stdcall.} + MoveIcons*: proc(self: ptr IShellFolderView, pDataObject: ptr IDataObject): HRESULT {.stdcall.} + SetItemPos*: proc(self: ptr IShellFolderView, pidl: PCUITEMID_CHILD, ppt: ptr POINT): HRESULT {.stdcall.} + IsBkDropTarget*: proc(self: ptr IShellFolderView, pDropTarget: ptr IDropTarget): HRESULT {.stdcall.} + SetClipboard*: proc(self: ptr IShellFolderView, bMove: WINBOOL): HRESULT {.stdcall.} + SetPoints*: proc(self: ptr IShellFolderView, pDataObject: ptr IDataObject): HRESULT {.stdcall.} + GetItemSpacing*: proc(self: ptr IShellFolderView, pSpacing: ptr ITEMSPACING): HRESULT {.stdcall.} + SetCallback*: proc(self: ptr IShellFolderView, pNewCB: ptr IShellFolderViewCB, ppOldCB: ptr ptr IShellFolderViewCB): HRESULT {.stdcall.} + Select*: proc(self: ptr IShellFolderView, dwFlags: UINT): HRESULT {.stdcall.} + QuerySupport*: proc(self: ptr IShellFolderView, pdwSupport: ptr UINT): HRESULT {.stdcall.} + SetAutomationObject*: proc(self: ptr IShellFolderView, pdisp: ptr IDispatch): HRESULT {.stdcall.} + INamedPropertyBag* {.pure.} = object + lpVtbl*: ptr INamedPropertyBagVtbl + INamedPropertyBagVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ReadPropertyNPB*: proc(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR, pVar: ptr PROPVARIANT): HRESULT {.stdcall.} + WritePropertyNPB*: proc(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR, pVar: ptr PROPVARIANT): HRESULT {.stdcall.} + RemovePropertyNPB*: proc(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR): HRESULT {.stdcall.} +proc DragQueryFileA*(hDrop: HDROP, iFile: UINT, lpszFile: LPSTR, cch: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DragQueryFileW*(hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DragQueryPoint*(hDrop: HDROP, ppt: ptr POINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DragFinish*(hDrop: HDROP): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc DragAcceptFiles*(hWnd: HWND, fAccept: WINBOOL): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellExecuteA*(hwnd: HWND, lpOperation: LPCSTR, lpFile: LPCSTR, lpParameters: LPCSTR, lpDirectory: LPCSTR, nShowCmd: INT): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellExecuteW*(hwnd: HWND, lpOperation: LPCWSTR, lpFile: LPCWSTR, lpParameters: LPCWSTR, lpDirectory: LPCWSTR, nShowCmd: INT): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc.} +proc FindExecutableA*(lpFile: LPCSTR, lpDirectory: LPCSTR, lpResult: LPSTR): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc.} +proc FindExecutableW*(lpFile: LPCWSTR, lpDirectory: LPCWSTR, lpResult: LPWSTR): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc.} +proc CommandLineToArgvW*(lpCmdLine: LPCWSTR, pNumArgs: ptr int32): ptr LPWSTR {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellAboutA*(hWnd: HWND, szApp: LPCSTR, szOtherStuff: LPCSTR, hIcon: HICON): INT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellAboutW*(hWnd: HWND, szApp: LPCWSTR, szOtherStuff: LPCWSTR, hIcon: HICON): INT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DuplicateIcon*(hInst: HINSTANCE, hIcon: HICON): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractAssociatedIconA*(hInst: HINSTANCE, pszIconPath: LPSTR, piIcon: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractAssociatedIconW*(hInst: HINSTANCE, pszIconPath: LPWSTR, piIcon: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractAssociatedIconExA*(hInst: HINSTANCE, pszIconPath: LPSTR, piIconIndex: ptr WORD, piIconId: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractAssociatedIconExW*(hInst: HINSTANCE, pszIconPath: LPWSTR, piIconIndex: ptr WORD, piIconId: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractIconA*(hInst: HINSTANCE, pszExeFileName: LPCSTR, nIconIndex: UINT): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractIconW*(hInst: HINSTANCE, pszExeFileName: LPCWSTR, nIconIndex: UINT): HICON {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAppBarMessage*(dwMessage: DWORD, pData: PAPPBARDATA): UINT_PTR {.winapi, stdcall, dynlib: "shell32", importc.} +proc DoEnvironmentSubstA*(pszSrc: LPSTR, cchSrc: UINT): DWORD {.winapi, stdcall, dynlib: "shell32", importc.} +proc DoEnvironmentSubstW*(pszSrc: LPWSTR, cchSrc: UINT): DWORD {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractIconExA*(lpszFile: LPCSTR, nIconIndex: int32, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIcons: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ExtractIconExW*(lpszFile: LPCWSTR, nIconIndex: int32, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIcons: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFileOperationA*(lpFileOp: LPSHFILEOPSTRUCTA): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFileOperationW*(lpFileOp: LPSHFILEOPSTRUCTW): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFreeNameMappings*(hNameMappings: HANDLE): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellExecuteExA*(pExecInfo: ptr SHELLEXECUTEINFOA): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellExecuteExW*(pExecInfo: ptr SHELLEXECUTEINFOW): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateProcessAsUserW*(pscpi: PSHCREATEPROCESSINFOW): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHEvaluateSystemCommandTemplate*(pszCmdTemplate: PCWSTR, ppszApplication: ptr PWSTR, ppszCommandLine: ptr PWSTR, ppszParameters: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc AssocCreateForClasses*(rgClasses: ptr ASSOCIATIONELEMENT, cClasses: ULONG, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHQueryRecycleBinA*(pszRootPath: LPCSTR, pSHQueryRBInfo: LPSHQUERYRBINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHQueryRecycleBinW*(pszRootPath: LPCWSTR, pSHQueryRBInfo: LPSHQUERYRBINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHEmptyRecycleBinA*(hwnd: HWND, pszRootPath: LPCSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHEmptyRecycleBinW*(hwnd: HWND, pszRootPath: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHQueryUserNotificationState*(pquns: ptr QUERY_USER_NOTIFICATION_STATE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPropertyStoreForWindow*(hwnd: HWND, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_NotifyIconA*(dwMessage: DWORD, lpData: PNOTIFYICONDATAA): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_NotifyIconW*(dwMessage: DWORD, lpData: PNOTIFYICONDATAW): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_NotifyIconGetRect*(identifier: ptr NOTIFYICONIDENTIFIER, iconLocation: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFileInfoA*(pszPath: LPCSTR, dwFileAttributes: DWORD, psfi: ptr SHFILEINFOA, cbFileInfo: UINT, uFlags: UINT): DWORD_PTR {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFileInfoW*(pszPath: LPCWSTR, dwFileAttributes: DWORD, psfi: ptr SHFILEINFOW, cbFileInfo: UINT, uFlags: UINT): DWORD_PTR {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetStockIconInfo*(siid: SHSTOCKICONID, uFlags: UINT, psii: ptr SHSTOCKICONINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDiskFreeSpaceExA*(pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDiskFreeSpaceExW*(pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetNewLinkInfoA*(pszLinkTo: LPCSTR, pszDir: LPCSTR, pszName: LPSTR, pfMustCopy: ptr WINBOOL, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetNewLinkInfoW*(pszLinkTo: LPCWSTR, pszDir: LPCWSTR, pszName: LPWSTR, pfMustCopy: ptr WINBOOL, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHInvokePrinterCommandA*(hwnd: HWND, uAction: UINT, lpBuf1: LPCSTR, lpBuf2: LPCSTR, fModal: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHInvokePrinterCommandW*(hwnd: HWND, uAction: UINT, lpBuf1: LPCWSTR, lpBuf2: LPCWSTR, fModal: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHLoadNonloadedIconOverlayIdentifiers*(): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHIsFileAvailableOffline*(pwszPath: PCWSTR, pdwStatus: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetLocalizedName*(pszPath: PCWSTR, pszResModule: PCWSTR, idsRes: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHRemoveLocalizedName*(pszPath: PCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetLocalizedName*(pszPath: PCWSTR, pszResModule: PWSTR, cch: UINT, pidsRes: ptr int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ShellMessageBoxA*(hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCSTR, lpcTitle: LPCSTR, fuStyle: UINT): int32 {.winapi, cdecl, varargs, dynlib: "shlwapi", importc.} +proc ShellMessageBoxW*(hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCWSTR, lpcTitle: LPCWSTR, fuStyle: UINT): int32 {.winapi, cdecl, varargs, dynlib: "shlwapi", importc.} +proc IsLFNDriveA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc IsLFNDriveW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHEnumerateUnreadMailAccountsW*(hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPWSTR, cchMailAddress: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetUnreadMailCountW*(hKeyUser: HKEY, pszMailAddress: LPCWSTR, pdwCount: ptr DWORD, pFileTime: ptr FILETIME, pszShellExecuteCommand: LPWSTR, cchShellExecuteCommand: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetUnreadMailCountW*(pszMailAddress: LPCWSTR, dwCount: DWORD, pszShellExecuteCommand: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHTestTokenMembership*(hToken: HANDLE, ulRID: ULONG): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetImageList*(iImageList: int32, riid: REFIID, ppvObj: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc InitNetworkAddressControl*(): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDriveMedia*(pszDrive: PCWSTR, pdwMediaContent: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc StrChrA*(lpStart: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrChrW*(lpStart: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrChrIA*(lpStart: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrChrIW*(lpStart: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpNA*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpNW*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpNIA*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpNIW*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCSpnA*(lpStr: LPCSTR, lpSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCSpnW*(lpStr: LPCWSTR, lpSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCSpnIA*(lpStr: LPCSTR, lpSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCSpnIW*(lpStr: LPCWSTR, lpSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrDupA*(lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrDupW*(lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFormatByteSizeA*(dw: DWORD, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFormatByteSize64A*(qdw: LONGLONG, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFormatByteSizeW*(qdw: LONGLONG, szBuf: LPWSTR, uiBufSize: UINT): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFormatKBSizeW*(qdw: LONGLONG, szBuf: LPWSTR, uiBufSize: UINT): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFormatKBSizeA*(qdw: LONGLONG, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFromTimeIntervalA*(pszOut: LPSTR, cchMax: UINT, dwTimeMS: DWORD, digits: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrFromTimeIntervalW*(pszOut: LPWSTR, cchMax: UINT, dwTimeMS: DWORD, digits: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrIsIntlEqualA*(fCaseSens: WINBOOL, lpString1: LPCSTR, lpString2: LPCSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrIsIntlEqualW*(fCaseSens: WINBOOL, lpString1: LPCWSTR, lpString2: LPCWSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrNCatA*(psz1: LPSTR, psz2: LPCSTR, cchMax: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrNCatW*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrPBrkA*(psz: LPCSTR, pszSet: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrPBrkW*(psz: LPCWSTR, pszSet: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRChrA*(lpStart: LPCSTR, lpEnd: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRChrW*(lpStart: LPCWSTR, lpEnd: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRChrIA*(lpStart: LPCSTR, lpEnd: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRChrIW*(lpStart: LPCWSTR, lpEnd: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRStrIA*(lpSource: LPCSTR, lpLast: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRStrIW*(lpSource: LPCWSTR, lpLast: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrSpnA*(psz: LPCSTR, pszSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrSpnW*(psz: LPCWSTR, pszSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrStrA*(lpFirst: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrStrW*(lpFirst: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrStrIA*(lpFirst: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrStrIW*(lpFirst: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToIntA*(lpSrc: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToIntW*(lpSrc: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToIntExA*(pszString: LPCSTR, dwFlags: DWORD, piRet: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToIntExW*(pszString: LPCWSTR, dwFlags: DWORD, piRet: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToInt64ExA*(pszString: LPCSTR, dwFlags: DWORD, pllRet: ptr LONGLONG): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrToInt64ExW*(pszString: LPCWSTR, dwFlags: DWORD, pllRet: ptr LONGLONG): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrTrimA*(psz: LPSTR, pszTrimChars: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrTrimW*(psz: LPWSTR, pszTrimChars: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCatW*(psz1: LPWSTR, psz2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpW*(psz1: LPCWSTR, psz2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpIW*(psz1: LPCWSTR, psz2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCpyW*(psz1: LPWSTR, psz2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCpyNW*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCatBuffW*(pszDest: LPWSTR, pszSrc: LPCWSTR, cchDestBuffSize: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCatBuffA*(pszDest: LPSTR, pszSrc: LPCSTR, cchDestBuffSize: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc ChrCmpIA*(w1: WORD, w2: WORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc ChrCmpIW*(w1: WCHAR, w2: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc wvnsprintfA*(lpOut: LPSTR, cchLimitIn: int32, lpFmt: LPCSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc wvnsprintfW*(lpOut: LPWSTR, cchLimitIn: int32, lpFmt: LPCWSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc wnsprintfA*(lpOut: LPSTR, cchLimitIn: int32, lpFmt: LPCSTR): int32 {.winapi, cdecl, varargs, dynlib: "shlwapi", importc.} +proc wnsprintfW*(lpOut: LPWSTR, cchLimitIn: int32, lpFmt: LPCWSTR): int32 {.winapi, cdecl, varargs, dynlib: "shlwapi", importc.} +proc StrRetToStrA*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, ppsz: ptr LPSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRetToStrW*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, ppsz: ptr LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRetToBufA*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, pszBuf: LPSTR, cchBuf: UINT): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRetToBufW*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, pszBuf: LPWSTR, cchBuf: UINT): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrRetToBSTR*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, pbstr: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHStrDupA*(psz: LPCSTR, ppwsz: ptr ptr WCHAR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHStrDupW*(psz: LPCWSTR, ppwsz: ptr ptr WCHAR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpLogicalW*(psz1: LPCWSTR, psz2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCatChainW*(pszDst: LPWSTR, cchDst: DWORD, ichAt: DWORD, pszSrc: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHLoadIndirectString*(pszSource: LPCWSTR, pszOutBuf: LPWSTR, cchOutBuf: UINT, ppvReserved: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc IsCharSpaceA*(wch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc IsCharSpaceW*(wch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpCA*(pszStr1: LPCSTR, pszStr2: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpCW*(pszStr1: LPCWSTR, pszStr2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpICA*(pszStr1: LPCSTR, pszStr2: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc StrCmpICW*(pszStr1: LPCWSTR, pszStr2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc IntlStrEqWorkerA*(fCaseSens: WINBOOL, lpString1: LPCSTR, lpString2: LPCSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc IntlStrEqWorkerW*(fCaseSens: WINBOOL, lpString1: LPCWSTR, lpString2: LPCWSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAddBackslashA*(pszPath: LPSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAddBackslashW*(pszPath: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAddExtensionA*(pszPath: LPSTR, pszExt: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAddExtensionW*(pszPath: LPWSTR, pszExt: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAppendA*(pszPath: LPSTR, pMore: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathAppendW*(pszPath: LPWSTR, pMore: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathBuildRootA*(pszRoot: LPSTR, iDrive: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathBuildRootW*(pszRoot: LPWSTR, iDrive: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCanonicalizeA*(pszBuf: LPSTR, pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCanonicalizeW*(pszBuf: LPWSTR, pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCombineA*(pszDest: LPSTR, pszDir: LPCSTR, pszFile: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCombineW*(pszDest: LPWSTR, pszDir: LPCWSTR, pszFile: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCompactPathA*(hDC: HDC, pszPath: LPSTR, dx: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCompactPathW*(hDC: HDC, pszPath: LPWSTR, dx: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCompactPathExA*(pszOut: LPSTR, pszSrc: LPCSTR, cchMax: UINT, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCompactPathExW*(pszOut: LPWSTR, pszSrc: LPCWSTR, cchMax: UINT, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCommonPrefixA*(pszFile1: LPCSTR, pszFile2: LPCSTR, achPath: LPSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCommonPrefixW*(pszFile1: LPCWSTR, pszFile2: LPCWSTR, achPath: LPWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFileExistsA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFileExistsW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindExtensionA*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindExtensionW*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindFileNameA*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindFileNameW*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindNextComponentA*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindNextComponentW*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindOnPathA*(pszPath: LPSTR, ppszOtherDirs: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindOnPathW*(pszPath: LPWSTR, ppszOtherDirs: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetArgsA*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetArgsW*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindSuffixArrayA*(pszPath: LPCSTR, apszSuffix: ptr LPCSTR, iArraySize: int32): LPCSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathFindSuffixArrayW*(pszPath: LPCWSTR, apszSuffix: ptr LPCWSTR, iArraySize: int32): LPCWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsLFNFileSpecA*(lpName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsLFNFileSpecW*(lpName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetCharTypeA*(ch: UCHAR): UINT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetCharTypeW*(ch: WCHAR): UINT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetDriveNumberA*(pszPath: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathGetDriveNumberW*(pszPath: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsDirectoryA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsDirectoryW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsDirectoryEmptyA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsDirectoryEmptyW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsFileSpecA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsFileSpecW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsPrefixA*(pszPrefix: LPCSTR, pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsPrefixW*(pszPrefix: LPCWSTR, pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsRelativeA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsRelativeW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsRootA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsRootW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsSameRootA*(pszPath1: LPCSTR, pszPath2: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsSameRootW*(pszPath1: LPCWSTR, pszPath2: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsNetworkPathA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsNetworkPathW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCServerA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCServerW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCServerShareA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsUNCServerShareW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsContentTypeA*(pszPath: LPCSTR, pszContentType: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsContentTypeW*(pszPath: LPCWSTR, pszContentType: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsURLA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsURLW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMakePrettyA*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMakePrettyW*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMatchSpecA*(pszFile: LPCSTR, pszSpec: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMatchSpecW*(pszFile: LPCWSTR, pszSpec: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathParseIconLocationA*(pszIconFile: LPSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathParseIconLocationW*(pszIconFile: LPWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathQuoteSpacesA*(lpsz: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathQuoteSpacesW*(lpsz: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRelativePathToA*(pszPath: LPSTR, pszFrom: LPCSTR, dwAttrFrom: DWORD, pszTo: LPCSTR, dwAttrTo: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRelativePathToW*(pszPath: LPWSTR, pszFrom: LPCWSTR, dwAttrFrom: DWORD, pszTo: LPCWSTR, dwAttrTo: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveArgsA*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveArgsW*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveBackslashA*(pszPath: LPSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveBackslashW*(pszPath: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveBlanksA*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveBlanksW*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveExtensionA*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveExtensionW*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveFileSpecA*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRemoveFileSpecW*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRenameExtensionA*(pszPath: LPSTR, pszExt: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathRenameExtensionW*(pszPath: LPWSTR, pszExt: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSearchAndQualifyA*(pszPath: LPCSTR, pszBuf: LPSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSearchAndQualifyW*(pszPath: LPCWSTR, pszBuf: LPWSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSetDlgItemPathA*(hDlg: HWND, id: int32, pszPath: LPCSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSetDlgItemPathW*(hDlg: HWND, id: int32, pszPath: LPCWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSkipRootA*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathSkipRootW*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathStripPathA*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathStripPathW*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathStripToRootA*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathStripToRootW*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnquoteSpacesA*(lpsz: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnquoteSpacesW*(lpsz: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMakeSystemFolderA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathMakeSystemFolderW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnmakeSystemFolderA*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnmakeSystemFolderW*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsSystemFolderA*(pszPath: LPCSTR, dwAttrb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathIsSystemFolderW*(pszPath: LPCWSTR, dwAttrb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUndecorateA*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUndecorateW*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnExpandEnvStringsA*(pszPath: LPCSTR, pszBuf: LPSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathUnExpandEnvStringsW*(pszPath: LPCWSTR, pszBuf: LPWSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCompareA*(psz1: LPCSTR, psz2: LPCSTR, fIgnoreSlash: WINBOOL): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCompareW*(psz1: LPCWSTR, psz2: LPCWSTR, fIgnoreSlash: WINBOOL): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCombineA*(pszBase: LPCSTR, pszRelative: LPCSTR, pszCombined: LPSTR, pcchCombined: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCombineW*(pszBase: LPCWSTR, pszRelative: LPCWSTR, pszCombined: LPWSTR, pcchCombined: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCanonicalizeA*(pszUrl: LPCSTR, pszCanonicalized: LPSTR, pcchCanonicalized: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCanonicalizeW*(pszUrl: LPCWSTR, pszCanonicalized: LPWSTR, pcchCanonicalized: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsOpaqueA*(pszURL: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsOpaqueW*(pszURL: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsNoHistoryA*(pszURL: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsNoHistoryW*(pszURL: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsA*(pszUrl: LPCSTR, UrlIs: TURLIS): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlIsW*(pszUrl: LPCWSTR, UrlIs: TURLIS): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlGetLocationA*(psz1: LPCSTR): LPCSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlGetLocationW*(psz1: LPCWSTR): LPCWSTR {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlUnescapeA*(pszUrl: LPSTR, pszUnescaped: LPSTR, pcchUnescaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlUnescapeW*(pszUrl: LPWSTR, pszUnescaped: LPWSTR, pcchUnescaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlEscapeA*(pszUrl: LPCSTR, pszEscaped: LPSTR, pcchEscaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlEscapeW*(pszUrl: LPCWSTR, pszEscaped: LPWSTR, pcchEscaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCreateFromPathA*(pszPath: LPCSTR, pszUrl: LPSTR, pcchUrl: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlCreateFromPathW*(pszPath: LPCWSTR, pszUrl: LPWSTR, pcchUrl: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCreateFromUrlA*(pszUrl: LPCSTR, pszPath: LPSTR, pcchPath: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc PathCreateFromUrlW*(pszUrl: LPCWSTR, pszPath: LPWSTR, pcchPath: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlHashA*(pszUrl: LPCSTR, pbHash: LPBYTE, cbHash: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlHashW*(pszUrl: LPCWSTR, pbHash: LPBYTE, cbHash: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlGetPartW*(pszIn: LPCWSTR, pszOut: LPWSTR, pcchOut: LPDWORD, dwPart: DWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlGetPartA*(pszIn: LPCSTR, pszOut: LPSTR, pcchOut: LPDWORD, dwPart: DWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlApplySchemeA*(pszIn: LPCSTR, pszOut: LPSTR, pcchOut: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc UrlApplySchemeW*(pszIn: LPCWSTR, pszOut: LPWSTR, pcchOut: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc HashData*(pbData: LPBYTE, cbData: DWORD, pbHash: LPBYTE, cbHash: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteEmptyKeyA*(hkey: HKEY, pszSubKey: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteEmptyKeyW*(hkey: HKEY, pszSubKey: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteKeyA*(hkey: HKEY, pszSubKey: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteKeyW*(hkey: HKEY, pszSubKey: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegDuplicateHKey*(hkey: HKEY): HKEY {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteValueA*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHDeleteValueW*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHGetValueA*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHGetValueW*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHSetValueA*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, dwType: DWORD, pvData: LPCVOID, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHSetValueW*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, dwType: DWORD, pvData: LPCVOID, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetValueA*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, dwFlags: SRRF, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetValueW*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, dwFlags: SRRF, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHQueryValueExA*(hkey: HKEY, pszValue: LPCSTR, pdwReserved: ptr DWORD, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHQueryValueExW*(hkey: HKEY, pszValue: LPCWSTR, pdwReserved: ptr DWORD, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHEnumKeyExA*(hkey: HKEY, dwIndex: DWORD, pszName: LPSTR, pcchName: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHEnumKeyExW*(hkey: HKEY, dwIndex: DWORD, pszName: LPWSTR, pcchName: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHEnumValueA*(hkey: HKEY, dwIndex: DWORD, pszValueName: LPSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHEnumValueW*(hkey: HKEY, dwIndex: DWORD, pszValueName: LPWSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHQueryInfoKeyA*(hkey: HKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHQueryInfoKeyW*(hkey: HKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCopyKeyA*(hkeySrc: HKEY, szSrcSubKey: LPCSTR, hkeyDest: HKEY, fReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCopyKeyW*(hkeySrc: HKEY, wszSrcSubKey: LPCWSTR, hkeyDest: HKEY, fReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetPathA*(hKey: HKEY, pcszSubKey: LPCSTR, pcszValue: LPCSTR, pszPath: LPSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetPathW*(hKey: HKEY, pcszSubKey: LPCWSTR, pcszValue: LPCWSTR, pszPath: LPWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegSetPathA*(hKey: HKEY, pcszSubKey: LPCSTR, pcszValue: LPCSTR, pcszPath: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegSetPathW*(hKey: HKEY, pcszSubKey: LPCWSTR, pcszValue: LPCWSTR, pcszPath: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegCreateUSKeyA*(pszPath: LPCSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegCreateUSKeyW*(pwzPath: LPCWSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegOpenUSKeyA*(pszPath: LPCSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, fIgnoreHKCU: WINBOOL): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegOpenUSKeyW*(pwzPath: LPCWSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, fIgnoreHKCU: WINBOOL): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegQueryUSValueA*(hUSKey: HUSKEY, pszValue: LPCSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegQueryUSValueW*(hUSKey: HUSKEY, pwzValue: LPCWSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegWriteUSValueA*(hUSKey: HUSKEY, pszValue: LPCSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegWriteUSValueW*(hUSKey: HUSKEY, pwzValue: LPCWSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegDeleteUSValueA*(hUSKey: HUSKEY, pszValue: LPCSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegDeleteEmptyUSKeyW*(hUSKey: HUSKEY, pwzSubKey: LPCWSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegDeleteEmptyUSKeyA*(hUSKey: HUSKEY, pszSubKey: LPCSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegDeleteUSValueW*(hUSKey: HUSKEY, pwzValue: LPCWSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegEnumUSKeyA*(hUSKey: HUSKEY, dwIndex: DWORD, pszName: LPSTR, pcchName: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegEnumUSKeyW*(hUSKey: HUSKEY, dwIndex: DWORD, pwzName: LPWSTR, pcchName: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegEnumUSValueA*(hUSkey: HUSKEY, dwIndex: DWORD, pszValueName: LPSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegEnumUSValueW*(hUSkey: HUSKEY, dwIndex: DWORD, pszValueName: LPWSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegQueryInfoUSKeyA*(hUSKey: HUSKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegQueryInfoUSKeyW*(hUSKey: HUSKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegCloseUSKey*(hUSKey: HUSKEY): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetUSValueA*(pszSubKey: LPCSTR, pszValue: LPCSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetUSValueW*(pwzSubKey: LPCWSTR, pwzValue: LPCWSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegSetUSValueA*(pszSubKey: LPCSTR, pszValue: LPCSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegSetUSValueW*(pwzSubKey: LPCWSTR, pwzValue: LPCWSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetIntW*(hk: HKEY, pwzKey: LPCWSTR, iDefault: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetBoolUSValueA*(pszSubKey: LPCSTR, pszValue: LPCSTR, fIgnoreHKCU: WINBOOL, fDefault: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHRegGetBoolUSValueW*(pszSubKey: LPCWSTR, pszValue: LPCWSTR, fIgnoreHKCU: WINBOOL, fDefault: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocCreate*(clsid: CLSID, riid: REFIID, ppv: ptr LPVOID): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryStringA*(flags: ASSOCF, str: ASSOCSTR, pszAssoc: LPCSTR, pszExtra: LPCSTR, pszOut: LPSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryStringW*(flags: ASSOCF, str: ASSOCSTR, pszAssoc: LPCWSTR, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryStringByKeyA*(flags: ASSOCF, str: ASSOCSTR, hkAssoc: HKEY, pszExtra: LPCSTR, pszOut: LPSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryStringByKeyW*(flags: ASSOCF, str: ASSOCSTR, hkAssoc: HKEY, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryKeyA*(flags: ASSOCF, key: ASSOCKEY, pszAssoc: LPCSTR, pszExtra: LPCSTR, phkeyOut: ptr HKEY): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocQueryKeyW*(flags: ASSOCF, key: ASSOCKEY, pszAssoc: LPCWSTR, pszExtra: LPCWSTR, phkeyOut: ptr HKEY): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocIsDangerous*(pszAssoc: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc AssocGetPerceivedType*(pszExt: LPCWSTR, ptype: ptr PERCEIVED, pflag: ptr PERCEIVEDFLAG, ppszType: ptr LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHOpenRegStreamA*(hkey: HKEY, pszSubkey: LPCSTR, pszValue: LPCSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHOpenRegStreamW*(hkey: HKEY, pszSubkey: LPCWSTR, pszValue: LPCWSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHOpenRegStream2A*(hkey: HKEY, pszSubkey: LPCSTR, pszValue: LPCSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHOpenRegStream2W*(hkey: HKEY, pszSubkey: LPCWSTR, pszValue: LPCWSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateStreamOnFileA*(pszFile: LPCSTR, grfMode: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateStreamOnFileW*(pszFile: LPCWSTR, grfMode: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateStreamOnFileEx*(pszFile: LPCWSTR, grfMode: DWORD, dwAttributes: DWORD, fCreate: WINBOOL, pstmTemplate: ptr IStream, ppstm: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc GetAcceptLanguagesA*(psz: LPSTR, pcch: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc GetAcceptLanguagesW*(psz: LPWSTR, pcch: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHGetViewStatePropertyBag*(pidl: LPCITEMIDLIST, pszBagName: LPCWSTR, dwFlags: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHAllocShared*(pvData: pointer, dwSize: DWORD, dwProcessId: DWORD): HANDLE {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHFreeShared*(hData: HANDLE, dwProcessId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHLockShared*(hData: HANDLE, dwProcessId: DWORD): pointer {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHUnlockShared*(pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHAutoComplete*(hwndEdit: HWND, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHSetThreadRef*(punk: ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHGetThreadRef*(ppunk: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHSkipJunction*(pbc: ptr IBindCtx, pclsid: ptr CLSID): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateThreadRef*(pcRef: ptr LONG, ppunk: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateThread*(pfnThreadProc: LPTHREAD_START_ROUTINE, pData: pointer, dwFlags: DWORD, pfnCallback: LPTHREAD_START_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHReleaseThreadRef*(): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHCreateShellPalette*(hdc: HDC): HPALETTE {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc ColorRGBToHLS*(clrRGB: COLORREF, pwHue: ptr WORD, pwLuminance: ptr WORD, pwSaturation: ptr WORD): void {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc ColorHLSToRGB*(wHue: WORD, wLuminance: WORD, wSaturation: WORD): COLORREF {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc ColorAdjustLuma*(clrRGB: COLORREF, n: int32, fScale: WINBOOL): COLORREF {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc DllInstall*(bInstall: WINBOOL, pszCmdLine: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc IsInternetESCEnabled*(): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc.} +proc SHGetFolderPathW*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSimpleIDListFromPath*(pszPath: PCWSTR): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateItemFromIDList*(pidl: PCIDLIST_ABSOLUTE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateItemFromParsingName*(pszPath: PCWSTR, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateItemWithParent*(pidlParent: PCIDLIST_ABSOLUTE, psfParent: ptr IShellFolder, pidl: PCUITEMID_CHILD, riid: REFIID, ppvItem: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateItemFromRelativeName*(psiParent: ptr IShellItem, pszName: PCWSTR, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateItemInKnownFolder*(kfid: REFKNOWNFOLDERID, dwKFFlags: DWORD, pszItem: PCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetIDListFromObject*(punk: ptr IUnknown, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetItemFromObject*(punk: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPropertyStoreFromIDList*(pidl: PCIDLIST_ABSOLUTE, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPropertyStoreFromParsingName*(pszPath: PCWSTR, pbc: ptr IBindCtx, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetNameFromIDList*(pidl: PCIDLIST_ABSOLUTE, sigdnName: SIGDN, ppszName: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetItemFromDataObject*(pdtobj: ptr IDataObject, dwFlags: DATAOBJ_GET_ITEM_FLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellItemArray*(pidlParent: PCIDLIST_ABSOLUTE, psf: ptr IShellFolder, cidl: UINT, ppidl: PCUITEMID_CHILD_ARRAY, ppsiItemArray: ptr ptr IShellItemArray): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellItemArrayFromDataObject*(pdo: ptr IDataObject, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellItemArrayFromIDLists*(cidl: UINT, rgpidl: PCIDLIST_ABSOLUTE_ARRAY, ppsiItemArray: ptr ptr IShellItemArray): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellItemArrayFromShellItem*(psi: ptr IShellItem, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAddDefaultPropertiesByExt*(pszExt: PCWSTR, pPropStore: ptr IPropertyStore): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDefaultPropertiesOp*(psi: ptr IShellItem, ppFileOp: ptr ptr IFileOperation): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetDefaultProperties*(hwnd: HWND, psi: ptr IShellItem, dwFileOpFlags: DWORD, pfops: ptr IFileOperationProgressSink): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateAssociationRegistration*(riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDefaultExtractIcon*(riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SetCurrentProcessExplicitAppUserModelID*(AppID: PCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc GetCurrentProcessExplicitAppUserModelID*(AppID: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetTemporaryPropertyForItem*(psi: ptr IShellItem, propkey: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetTemporaryPropertyForItem*(psi: ptr IShellItem, propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHShowManageLibraryUI*(psiLibrary: ptr IShellItem, hwndOwner: HWND, pszTitle: LPCWSTR, pszInstruction: LPCWSTR, lmdOptions: LIBRARYMANAGEDIALOGOPTIONS): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHResolveLibrary*(psiLibrary: ptr IShellItem): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAssocEnumHandlers*(pszExtra: PCWSTR, afFilter: ASSOC_FILTER, ppEnumHandler: ptr ptr IEnumAssocHandlers): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAssocEnumHandlersForProtocolByApplication*(protocol: PCWSTR, riid: REFIID, enumHandlers: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetMalloc*(ppMalloc: ptr ptr IMalloc): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAlloc*(cb: SIZE_T): pointer {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFree*(pv: pointer): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetIconOverlayIndexA*(pszIconPath: LPCSTR, iIconIndex: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetIconOverlayIndexW*(pszIconPath: LPCWSTR, iIconIndex: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILClone*(pidl: PCUIDLIST_RELATIVE): PIDLIST_RELATIVE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILCloneFirst*(pidl: PCUIDLIST_RELATIVE): PITEMID_CHILD {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILCombine*(pidl1: PCIDLIST_ABSOLUTE, pidl2: PCUIDLIST_RELATIVE): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILFree*(pidl: PIDLIST_RELATIVE): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILGetNext*(pidl: PCUIDLIST_RELATIVE): PUIDLIST_RELATIVE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILGetSize*(pidl: PCUIDLIST_RELATIVE): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILFindChild*(pidlParent: PIDLIST_ABSOLUTE, pidlChild: PCIDLIST_ABSOLUTE): PUIDLIST_RELATIVE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILFindLastID*(pidl: PCUIDLIST_RELATIVE): PUITEMID_CHILD {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILRemoveLastID*(pidl: PUIDLIST_RELATIVE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILIsEqual*(pidl1: PCIDLIST_ABSOLUTE, pidl2: PCIDLIST_ABSOLUTE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILIsParent*(pidl1: PCIDLIST_ABSOLUTE, pidl2: PCIDLIST_ABSOLUTE, fImmediate: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILSaveToStream*(pstm: ptr IStream, pidl: PCUIDLIST_RELATIVE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILLoadFromStreamEx*(pstm: ptr IStream, pidl: ptr PIDLIST_RELATIVE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILCreateFromPathA*(pszPath: PCSTR): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILCreateFromPathW*(pszPath: PCWSTR): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHILCreateFromPath*(pszPath: PCWSTR, ppidl: ptr PIDLIST_ABSOLUTE, rgfInOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ILAppendID*(pidl: PIDLIST_RELATIVE, pmkid: LPCSHITEMID, fAppend: WINBOOL): PIDLIST_RELATIVE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPathFromIDListEx*(pidl: PCIDLIST_ABSOLUTE, pszPath: PWSTR, cchPath: DWORD, uOpts: GPFIDL_FLAGS): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPathFromIDListA*(pidl: PCIDLIST_ABSOLUTE, pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetPathFromIDListW*(pidl: PCIDLIST_ABSOLUTE, pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDirectory*(hwnd: HWND, pszPath: PCWSTR): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDirectoryExA*(hwnd: HWND, pszPath: LPCSTR, psa: ptr SECURITY_ATTRIBUTES): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDirectoryExW*(hwnd: HWND, pszPath: LPCWSTR, psa: ptr SECURITY_ATTRIBUTES): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHOpenFolderAndSelectItems*(pidlFolder: PCIDLIST_ABSOLUTE, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellItem*(pidlParent: PCIDLIST_ABSOLUTE, psfParent: ptr IShellFolder, pidl: PCUITEMID_CHILD, ppsi: ptr ptr IShellItem): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetSpecialFolderLocation*(hwnd: HWND, csidl: int32, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCloneSpecialIDList*(hwnd: HWND, csidl: int32, fCreate: WINBOOL): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetSpecialFolderPathA*(hwnd: HWND, pszPath: LPSTR, csidl: int32, fCreate: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetSpecialFolderPathW*(hwnd: HWND, pszPath: LPWSTR, csidl: int32, fCreate: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFlushSFCache*(): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFolderPathA*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFolderLocation*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetFolderPathA*(csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetFolderPathW*(csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFolderPathAndSubDirA*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszSubDir: LPCSTR, pszPath: LPSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetFolderPathAndSubDirW*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszSubDir: LPCWSTR, pszPath: LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetKnownFolderIDList*(rfid: REFKNOWNFOLDERID, dwFlags: DWORD, hToken: HANDLE, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetKnownFolderPath*(rfid: REFKNOWNFOLDERID, dwFlags: DWORD, hToken: HANDLE, pszPath: PCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetKnownFolderPath*(rfid: REFKNOWNFOLDERID, dwFlags: DWORD, hToken: HANDLE, ppszPath: ptr PWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetKnownFolderItem*(rfid: REFKNOWNFOLDERID, flags: KNOWN_FOLDER_FLAG, hToken: HANDLE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetSetFolderCustomSettings*(pfcs: LPSHFOLDERCUSTOMSETTINGS, pszPath: PCWSTR, dwReadWrite: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBrowseForFolderA*(lpbi: LPBROWSEINFOA): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBrowseForFolderW*(lpbi: LPBROWSEINFOW): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHLoadInProc*(rclsid: REFCLSID): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDesktopFolder*(ppshf: ptr ptr IShellFolder): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotify*(wEventId: LONG, uFlags: UINT, dwItem1: LPCVOID, dwItem2: LPCVOID): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAddToRecentDocs*(uFlags: UINT, pv: LPCVOID): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHHandleUpdateImage*(pidlExtra: PCIDLIST_ABSOLUTE): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHUpdateImageA*(pszHashItem: LPCSTR, iIndex: int32, uFlags: UINT, iImageIndex: int32): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHUpdateImageW*(pszHashItem: LPCWSTR, iIndex: int32, uFlags: UINT, iImageIndex: int32): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotifyRegister*(hwnd: HWND, fSources: int32, fEvents: LONG, wMsg: UINT, cEntries: int32, pshcne: ptr SHChangeNotifyEntry): ULONG {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotifyDeregister*(ulID: ULONG): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotifyRegisterThread*(status: SCNRT_STATUS): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotification_Lock*(hChange: HANDLE, dwProcId: DWORD, pppidl: ptr ptr PIDLIST_ABSOLUTE, plEvent: ptr LONG): HANDLE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHChangeNotification_Unlock*(hLock: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetRealIDL*(psf: ptr IShellFolder, pidlSimple: PCUITEMID_CHILD, ppidlReal: ptr PITEMID_CHILD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetInstanceExplorer*(ppunk: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDataFromIDListA*(psf: ptr IShellFolder, pidl: PCUITEMID_CHILD, nFormat: int32, pv: pointer, cb: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetDataFromIDListW*(psf: ptr IShellFolder, pidl: PCUITEMID_CHILD, nFormat: int32, pv: pointer, cb: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc RestartDialog*(hwnd: HWND, pszPrompt: PCWSTR, dwReturn: DWORD): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc RestartDialogEx*(hwnd: HWND, pszPrompt: PCWSTR, dwReturn: DWORD, dwReasonCode: DWORD): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCoCreateInstance*(pszCLSID: PCWSTR, pclsid: ptr CLSID, pUnkOuter: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDataObject*(pidlFolder: PCIDLIST_ABSOLUTE, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, pdtInner: ptr IDataObject, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc CIDLData_CreateFromIDArray*(pidlFolder: PCIDLIST_ABSOLUTE, cidl: UINT, apidl: PCUIDLIST_RELATIVE_ARRAY, ppdtobj: ptr ptr IDataObject): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateStdEnumFmtEtc*(cfmt: UINT, afmt: ptr FORMATETC, ppenumFormatEtc: ptr ptr IEnumFORMATETC): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHDoDragDrop*(hwnd: HWND, pdata: ptr IDataObject, pdsrc: ptr IDropSource, dwEffect: DWORD, pdwEffect: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_SetDragImage*(him: HIMAGELIST, pptOffset: ptr POINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_DragEnterEx*(hwndTarget: HWND, ptStart: POINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_DragEnterEx2*(hwndTarget: HWND, ptStart: POINT, pdtObject: ptr IDataObject): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_ShowDragImage*(fShow: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_DragMove*(pt: POINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_DragLeave*(): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DAD_AutoScroll*(hwnd: HWND, pad: ptr AUTO_SCROLL_DATA, pptNow: ptr POINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc ReadCabinetState*(pcs: ptr CABINETSTATE, cLength: int32): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc WriteCabinetState*(pcs: ptr CABINETSTATE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathMakeUniqueName*(pszUniqueName: PWSTR, cchMax: UINT, pszTemplate: PCWSTR, pszLongPlate: PCWSTR, pszDir: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathQualify*(psz: PWSTR): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathIsExe*(pszPath: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathIsSlowA*(pszFile: LPCSTR, dwAttr: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathIsSlowW*(pszFile: LPCWSTR, dwAttr: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathCleanupSpec*(pszDir: PCWSTR, pszSpec: PWSTR): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathResolve*(pszPath: PWSTR, dirs: PZPCWSTR, fFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc GetFileNameFromBrowse*(hwnd: HWND, pszFilePath: PWSTR, cchFilePath: UINT, pszWorkingDir: PCWSTR, pszDefExt: PCWSTR, pszFilters: PCWSTR, pszTitle: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc DriveType*(iDrive: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc RealDriveType*(iDrive: int32, fOKToHitNet: WINBOOL): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc IsNetDrive*(iDrive: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_MergeMenus*(hmDst: HMENU, hmSrc: HMENU, uInsert: UINT, uIDAdjust: UINT, uIDAdjustMax: UINT, uFlags: ULONG): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHObjectProperties*(hwnd: HWND, shopObjectType: DWORD, pszObjectName: PCWSTR, pszPropertyPage: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFormatDrive*(hwnd: HWND, drive: UINT, fmtID: UINT, options: UINT): DWORD {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreatePropSheetExtArray*(hKey: HKEY, pszSubKey: PCWSTR, max_iface: UINT): HPSXA {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHDestroyPropSheetExtArray*(hpsxa: HPSXA): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHAddFromPropSheetExtArray*(hpsxa: HPSXA, lpfnAddPage: LPFNADDPROPSHEETPAGE, lParam: LPARAM): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHReplaceFromPropSheetExtArray*(hpsxa: HPSXA, uPageID: UINT, lpfnReplaceWith: LPFNADDPROPSHEETPAGE, lParam: LPARAM): UINT {.winapi, stdcall, dynlib: "shell32", importc.} +proc OpenRegStream*(hkey: HKEY, pszSubkey: PCWSTR, pszValue: PCWSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFindFiles*(pidlFolder: PCIDLIST_ABSOLUTE, pidlSaveFile: PCIDLIST_ABSOLUTE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathGetShortPath*(pszLongPath: PWSTR): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc PathYetAnotherMakeUniqueName*(pszUniqueName: PWSTR, pszPath: PCWSTR, pszShort: PCWSTR, pszFileSpec: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc Win32DeleteFile*(pszPath: PCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHRestricted*(rest: RESTRICTIONS): DWORD {.winapi, stdcall, dynlib: "shell32", importc.} +proc SignalFileOpen*(pidl: PCIDLIST_ABSOLUTE): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc AssocGetDetailsOfPropKey*(psf: ptr IShellFolder, pidl: PCUITEMID_CHILD, pkey: ptr PROPERTYKEY, pv: ptr VARIANT, pfFoundPropKey: ptr WINBOOL): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHStartNetConnectionDialogW*(hwnd: HWND, pszRemoteName: LPCWSTR, dwType: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHDefExtractIconA*(pszIconFile: LPCSTR, iIndex: int32, uFlags: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHDefExtractIconW*(pszIconFile: LPCWSTR, iIndex: int32, uFlags: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHOpenWithDialog*(hwndParent: HWND, poainfo: ptr OPENASINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_GetImageLists*(phiml: ptr HIMAGELIST, phimlSmall: ptr HIMAGELIST): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_GetCachedImageIndex*(pwszIconPath: PCWSTR, iIconIndex: int32, uIconFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_GetCachedImageIndexA*(pszIconPath: LPCSTR, iIconIndex: int32, uIconFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc Shell_GetCachedImageIndexW*(pszIconPath: LPCWSTR, iIconIndex: int32, uIconFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHValidateUNC*(hwndOwner: HWND, pszFile: PWSTR, fConnect: UINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc PifMgr_OpenProperties*(pszApp: PCWSTR, pszPIF: PCWSTR, hInf: UINT, flOpt: UINT): HANDLE {.winapi, stdcall, dynlib: "shell32", importc.} +proc PifMgr_GetProperties*(hProps: HANDLE, pszGroup: PCSTR, lpProps: pointer, cbProps: int32, flOpt: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc PifMgr_SetProperties*(hProps: HANDLE, pszGroup: PCSTR, lpProps: pointer, cbProps: int32, flOpt: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc PifMgr_CloseProperties*(hProps: HANDLE, flOpt: UINT): HANDLE {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHSetInstanceExplorer*(punk: ptr IUnknown): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc IsUserAnAdmin*(): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHShellFolderView_Message*(hwndMain: HWND, uMsg: UINT, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellFolderView*(pcsfv: ptr SFV_CREATE, ppsv: ptr ptr IShellView): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc CDefFolderMenu_Create2*(pidlFolder: PCIDLIST_ABSOLUTE, hwnd: HWND, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, psf: ptr IShellFolder, pfn: LPFNDFMCALLBACK, nKeys: UINT, ahkeys: ptr HKEY, ppcm: ptr ptr IContextMenu): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateDefaultContextMenu*(pdcm: ptr DEFCONTEXTMENU, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHOpenPropSheetW*(pszCaption: LPCWSTR, ahkeys: ptr HKEY, ckeys: UINT, pclsidDefault: ptr CLSID, pdtobj: ptr IDataObject, psb: ptr IShellBrowser, pStartPage: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHFind_InitMenuPopup*(hmenu: HMENU, hwndOwner: HWND, idCmdFirst: UINT, idCmdLast: UINT): ptr IContextMenu {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateShellFolderViewEx*(pcsfv: ptr CSFV, ppsv: ptr ptr IShellView): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +when winimUnicode: + type + LPSHELLSTATE* = LPSHELLSTATEW +when winimAnsi: + type + LPSHELLSTATE* = LPSHELLSTATEA +proc SHGetSetSettings*(lpss: LPSHELLSTATE, dwMask: DWORD, bSet: WINBOOL): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetSettings*(psfs: ptr SHELLFLAGSTATE, dwMask: DWORD): void {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBindToParent*(pidl: PCIDLIST_ABSOLUTE, riid: REFIID, ppv: ptr pointer, ppidlLast: ptr PCUITEMID_CHILD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBindToFolderIDListParent*(psfRoot: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, riid: REFIID, ppv: ptr pointer, ppidlLast: ptr PCUITEMID_CHILD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBindToFolderIDListParentEx*(psfRoot: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, ppbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer, ppidlLast: ptr PCUITEMID_CHILD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHBindToObject*(psf: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHParseDisplayName*(pszName: PCWSTR, pbc: ptr IBindCtx, ppidl: ptr PIDLIST_ABSOLUTE, sfgaoIn: SFGAOF, psfgaoOut: ptr SFGAOF): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHPathPrepareForWriteA*(hwnd: HWND, punkEnableModless: ptr IUnknown, pszPath: LPCSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHPathPrepareForWriteW*(hwnd: HWND, punkEnableModless: ptr IUnknown, pszPath: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SoftwareUpdateMessageBox*(hWnd: HWND, pszDistUnit: PCWSTR, dwFlags: DWORD, psdi: LPSOFTDISTINFO): DWORD {.winapi, stdcall, dynlib: "shdocvw", importc.} +proc SHPropStgCreate*(psstg: ptr IPropertySetStorage, fmtid: REFFMTID, pclsid: ptr CLSID, grfFlags: DWORD, grfMode: DWORD, dwDisposition: DWORD, ppstg: ptr ptr IPropertyStorage, puCodePage: ptr UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHPropStgReadMultiple*(pps: ptr IPropertyStorage, uCodePage: UINT, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgvar: ptr PROPVARIANT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHPropStgWriteMultiple*(pps: ptr IPropertyStorage, puCodePage: ptr UINT, cpspec: ULONG, rgpspec: ptr PROPSPEC, rgvar: ptr PROPVARIANT, propidNameFirst: PROPID): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateFileExtractIconW*(pszFile: LPCWSTR, dwFileAttributes: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHLimitInputEdit*(hwndEdit: HWND, psf: ptr IShellFolder): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHGetAttributesFromDataObject*(pdo: ptr IDataObject, dwAttributeMask: DWORD, pdwAttributes: ptr DWORD, pcItems: ptr UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHMultiFileProperties*(pdtobj: ptr IDataObject, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHMapPIDLToSystemImageListIndex*(pshf: ptr IShellFolder, pidl: PCUITEMID_CHILD, piIndexSel: ptr int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCLSIDFromString*(psz: PCWSTR, pclsid: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc SHCreateQueryCancelAutoPlayMoniker*(ppmoniker: ptr ptr IMoniker): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc PerUserInit*(): void {.winapi, stdcall, dynlib: "mydocs", importc.} +proc PickIconDlg*(hwnd: HWND, pszIconPath: PWSTR, cchIconPath: UINT, piIconIndex: ptr int32): int32 {.winapi, stdcall, dynlib: "shell32", importc.} +proc StgMakeUniqueName*(pstgParent: ptr IStorage, pszFileSpec: PCWSTR, grfMode: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc.} +proc ImportPrivacySettings*(pszFilename: PCWSTR, pfParsePrivacyPreferences: ptr WINBOOL, pfParsePerSiteRules: ptr WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shdocvw", importc.} +proc `hIcon=`*(self: var SHELLEXECUTEINFOA, x: HANDLE) {.inline.} = self.union1.hIcon = x +proc hIcon*(self: SHELLEXECUTEINFOA): HANDLE {.inline.} = self.union1.hIcon +proc hIcon*(self: var SHELLEXECUTEINFOA): var HANDLE {.inline.} = self.union1.hIcon +proc `hMonitor=`*(self: var SHELLEXECUTEINFOA, x: HANDLE) {.inline.} = self.union1.hMonitor = x +proc hMonitor*(self: SHELLEXECUTEINFOA): HANDLE {.inline.} = self.union1.hMonitor +proc hMonitor*(self: var SHELLEXECUTEINFOA): var HANDLE {.inline.} = self.union1.hMonitor +proc `hIcon=`*(self: var SHELLEXECUTEINFOW, x: HANDLE) {.inline.} = self.union1.hIcon = x +proc hIcon*(self: SHELLEXECUTEINFOW): HANDLE {.inline.} = self.union1.hIcon +proc hIcon*(self: var SHELLEXECUTEINFOW): var HANDLE {.inline.} = self.union1.hIcon +proc `hMonitor=`*(self: var SHELLEXECUTEINFOW, x: HANDLE) {.inline.} = self.union1.hMonitor = x +proc hMonitor*(self: SHELLEXECUTEINFOW): HANDLE {.inline.} = self.union1.hMonitor +proc hMonitor*(self: var SHELLEXECUTEINFOW): var HANDLE {.inline.} = self.union1.hMonitor +proc `uTimeout=`*(self: var NOTIFYICONDATAA, x: UINT) {.inline.} = self.union1.uTimeout = x +proc uTimeout*(self: NOTIFYICONDATAA): UINT {.inline.} = self.union1.uTimeout +proc uTimeout*(self: var NOTIFYICONDATAA): var UINT {.inline.} = self.union1.uTimeout +proc `uVersion=`*(self: var NOTIFYICONDATAA, x: UINT) {.inline.} = self.union1.uVersion = x +proc uVersion*(self: NOTIFYICONDATAA): UINT {.inline.} = self.union1.uVersion +proc uVersion*(self: var NOTIFYICONDATAA): var UINT {.inline.} = self.union1.uVersion +proc `uTimeout=`*(self: var NOTIFYICONDATAW, x: UINT) {.inline.} = self.union1.uTimeout = x +proc uTimeout*(self: NOTIFYICONDATAW): UINT {.inline.} = self.union1.uTimeout +proc uTimeout*(self: var NOTIFYICONDATAW): var UINT {.inline.} = self.union1.uTimeout +proc `uVersion=`*(self: var NOTIFYICONDATAW, x: UINT) {.inline.} = self.union1.uVersion = x +proc uVersion*(self: NOTIFYICONDATAW): UINT {.inline.} = self.union1.uVersion +proc uVersion*(self: var NOTIFYICONDATAW): var UINT {.inline.} = self.union1.uVersion +proc Init*(self: ptr IQueryAssociations, flags: ASSOCF, pszAssoc: LPCWSTR, hkProgid: HKEY, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Init(self, flags, pszAssoc, hkProgid, hwnd) +proc GetString*(self: ptr IQueryAssociations, flags: ASSOCF, str: ASSOCSTR, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetString(self, flags, str, pszExtra, pszOut, pcchOut) +proc GetKey*(self: ptr IQueryAssociations, flags: ASSOCF, key: ASSOCKEY, pszExtra: LPCWSTR, phkeyOut: ptr HKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetKey(self, flags, key, pszExtra, phkeyOut) +proc GetData*(self: ptr IQueryAssociations, flags: ASSOCF, data: ASSOCDATA, pszExtra: LPCWSTR, pvOut: LPVOID, pcbOut: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetData(self, flags, data, pszExtra, pvOut, pcbOut) +proc GetEnum*(self: ptr IQueryAssociations, flags: ASSOCF, assocenum: ASSOCENUM, pszExtra: LPCWSTR, riid: REFIID, ppvOut: ptr LPVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnum(self, flags, assocenum, pszExtra, riid, ppvOut) +proc SetFolderView*(self: ptr IFolderViewOC, pdisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderView(self, pdisp) +proc get_Name*(self: ptr DFConstraint, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, pbs) +proc get_Value*(self: ptr DFConstraint, pv: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Value(self, pv) +proc get_Title*(self: ptr Folder, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Title(self, pbs) +proc get_Application*(self: ptr Folder, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr Folder, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc get_ParentFolder*(self: ptr Folder, ppsf: ptr ptr Folder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ParentFolder(self, ppsf) +proc Items*(self: ptr Folder, ppid: ptr ptr FolderItems): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Items(self, ppid) +proc ParseName*(self: ptr Folder, bName: BSTR, ppid: ptr ptr FolderItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseName(self, bName, ppid) +proc NewFolder*(self: ptr Folder, bName: BSTR, vOptions: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewFolder(self, bName, vOptions) +proc MoveHere*(self: ptr Folder, vItem: VARIANT, vOptions: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveHere(self, vItem, vOptions) +proc CopyHere*(self: ptr Folder, vItem: VARIANT, vOptions: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyHere(self, vItem, vOptions) +proc GetDetailsOf*(self: ptr Folder, vItem: VARIANT, iColumn: int32, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDetailsOf(self, vItem, iColumn, pbs) +proc get_Self*(self: ptr Folder2, ppfi: ptr ptr FolderItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Self(self, ppfi) +proc get_OfflineStatus*(self: ptr Folder2, pul: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_OfflineStatus(self, pul) +proc mSynchronize*(self: ptr Folder2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Synchronize(self) +proc get_HaveToShowWebViewBarricade*(self: ptr Folder2, pbHaveToShowWebViewBarricade: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HaveToShowWebViewBarricade(self, pbHaveToShowWebViewBarricade) +proc DismissedWebViewBarricade*(self: ptr Folder2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DismissedWebViewBarricade(self) +proc get_ShowWebViewBarricade*(self: ptr Folder3, pbShowWebViewBarricade: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShowWebViewBarricade(self, pbShowWebViewBarricade) +proc put_ShowWebViewBarricade*(self: ptr Folder3, bShowWebViewBarricade: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ShowWebViewBarricade(self, bShowWebViewBarricade) +proc get_Application*(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc get_Name*(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, pbs) +proc put_Name*(self: ptr FolderItem, bs: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Name(self, bs) +proc get_Path*(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Path(self, pbs) +proc get_GetLink*(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_GetLink(self, ppid) +proc get_GetFolder*(self: ptr FolderItem, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_GetFolder(self, ppid) +proc get_IsLink*(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsLink(self, pb) +proc get_IsFolder*(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFolder(self, pb) +proc get_IsFileSystem*(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsFileSystem(self, pb) +proc get_IsBrowsable*(self: ptr FolderItem, pb: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsBrowsable(self, pb) +proc get_ModifyDate*(self: ptr FolderItem, pdt: ptr DATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ModifyDate(self, pdt) +proc put_ModifyDate*(self: ptr FolderItem, dt: DATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ModifyDate(self, dt) +proc get_Size*(self: ptr FolderItem, pul: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Size(self, pul) +proc get_Type*(self: ptr FolderItem, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Type(self, pbs) +proc Verbs*(self: ptr FolderItem, ppfic: ptr ptr FolderItemVerbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Verbs(self, ppfic) +proc InvokeVerb*(self: ptr FolderItem, vVerb: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeVerb(self, vVerb) +proc InvokeVerbEx*(self: ptr FolderItem2, vVerb: VARIANT, vArgs: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeVerbEx(self, vVerb, vArgs) +proc ExtendedProperty*(self: ptr FolderItem2, bstrPropName: BSTR, pvRet: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExtendedProperty(self, bstrPropName, pvRet) +proc get_Count*(self: ptr FolderItems, plCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, plCount) +proc get_Application*(self: ptr FolderItems, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr FolderItems, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc Item*(self: ptr FolderItems, index: VARIANT, ppid: ptr ptr FolderItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, index, ppid) +proc NewEnum*(self: ptr FolderItems, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewEnum(self, ppunk) +proc InvokeVerbEx*(self: ptr FolderItems2, vVerb: VARIANT, vArgs: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeVerbEx(self, vVerb, vArgs) +proc Filter*(self: ptr FolderItems3, grfFlags: LONG, bstrFileSpec: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Filter(self, grfFlags, bstrFileSpec) +proc get_Verbs*(self: ptr FolderItems3, ppfic: ptr ptr FolderItemVerbs): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Verbs(self, ppfic) +proc get_Application*(self: ptr FolderItemVerb, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr FolderItemVerb, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc get_Name*(self: ptr FolderItemVerb, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, pbs) +proc DoIt*(self: ptr FolderItemVerb): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoIt(self) +proc get_Count*(self: ptr FolderItemVerbs, plCount: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, plCount) +proc get_Application*(self: ptr FolderItemVerbs, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr FolderItemVerbs, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc Item*(self: ptr FolderItemVerbs, index: VARIANT, ppid: ptr ptr FolderItemVerb): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, index, ppid) +proc NewEnum*(self: ptr FolderItemVerbs, ppunk: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewEnum(self, ppunk) +proc get_Path*(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Path(self, pbs) +proc put_Path*(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Path(self, bs) +proc get_Description*(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Description(self, pbs) +proc put_Description*(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Description(self, bs) +proc get_WorkingDirectory*(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_WorkingDirectory(self, pbs) +proc put_WorkingDirectory*(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_WorkingDirectory(self, bs) +proc get_Arguments*(self: ptr IShellLinkDual, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Arguments(self, pbs) +proc put_Arguments*(self: ptr IShellLinkDual, bs: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Arguments(self, bs) +proc get_Hotkey*(self: ptr IShellLinkDual, piHK: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Hotkey(self, piHK) +proc put_Hotkey*(self: ptr IShellLinkDual, iHK: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Hotkey(self, iHK) +proc get_ShowCommand*(self: ptr IShellLinkDual, piShowCommand: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ShowCommand(self, piShowCommand) +proc put_ShowCommand*(self: ptr IShellLinkDual, iShowCommand: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ShowCommand(self, iShowCommand) +proc Resolve*(self: ptr IShellLinkDual, fFlags: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resolve(self, fFlags) +proc GetIconLocation*(self: ptr IShellLinkDual, pbs: ptr BSTR, piIcon: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, pbs, piIcon) +proc SetIconLocation*(self: ptr IShellLinkDual, bs: BSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconLocation(self, bs, iIcon) +proc Save*(self: ptr IShellLinkDual, vWhere: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, vWhere) +proc get_Target*(self: ptr IShellLinkDual2, ppfi: ptr ptr FolderItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Target(self, ppfi) +proc get_Application*(self: ptr IShellFolderViewDual, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr IShellFolderViewDual, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc get_Folder*(self: ptr IShellFolderViewDual, ppid: ptr ptr Folder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Folder(self, ppid) +proc SelectedItems*(self: ptr IShellFolderViewDual, ppid: ptr ptr FolderItems): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectedItems(self, ppid) +proc get_FocusedItem*(self: ptr IShellFolderViewDual, ppid: ptr ptr FolderItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FocusedItem(self, ppid) +proc SelectItem*(self: ptr IShellFolderViewDual, pvfi: ptr VARIANT, dwFlags: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectItem(self, pvfi, dwFlags) +proc PopupItemMenu*(self: ptr IShellFolderViewDual, pfi: ptr FolderItem, vx: VARIANT, vy: VARIANT, pbs: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PopupItemMenu(self, pfi, vx, vy, pbs) +proc get_Script*(self: ptr IShellFolderViewDual, ppDisp: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Script(self, ppDisp) +proc get_ViewOptions*(self: ptr IShellFolderViewDual, plViewOptions: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ViewOptions(self, plViewOptions) +proc get_CurrentViewMode*(self: ptr IShellFolderViewDual2, pViewMode: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentViewMode(self, pViewMode) +proc put_CurrentViewMode*(self: ptr IShellFolderViewDual2, ViewMode: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_CurrentViewMode(self, ViewMode) +proc SelectItemRelative*(self: ptr IShellFolderViewDual2, iRelative: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectItemRelative(self, iRelative) +proc get_GroupBy*(self: ptr IShellFolderViewDual3, pbstrGroupBy: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_GroupBy(self, pbstrGroupBy) +proc put_GroupBy*(self: ptr IShellFolderViewDual3, bstrGroupBy: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_GroupBy(self, bstrGroupBy) +proc get_FolderFlags*(self: ptr IShellFolderViewDual3, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FolderFlags(self, pdwFlags) +proc put_FolderFlags*(self: ptr IShellFolderViewDual3, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_FolderFlags(self, dwFlags) +proc get_SortColumns*(self: ptr IShellFolderViewDual3, pbstrSortColumns: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SortColumns(self, pbstrSortColumns) +proc put_SortColumns*(self: ptr IShellFolderViewDual3, bstrSortColumns: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_SortColumns(self, bstrSortColumns) +proc put_IconSize*(self: ptr IShellFolderViewDual3, iIconSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_IconSize(self, iIconSize) +proc get_IconSize*(self: ptr IShellFolderViewDual3, piIconSize: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IconSize(self, piIconSize) +proc FilterView*(self: ptr IShellFolderViewDual3, bstrFilterText: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FilterView(self, bstrFilterText) +proc get_Application*(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Application(self, ppid) +proc get_Parent*(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Parent(self, ppid) +proc NameSpace*(self: ptr IShellDispatch, vDir: VARIANT, ppsdf: ptr ptr Folder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NameSpace(self, vDir, ppsdf) +proc BrowseForFolder*(self: ptr IShellDispatch, Hwnd: LONG, Title: BSTR, Options: LONG, RootFolder: VARIANT, ppsdf: ptr ptr Folder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BrowseForFolder(self, Hwnd, Title, Options, RootFolder, ppsdf) +proc Windows*(self: ptr IShellDispatch, ppid: ptr ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Windows(self, ppid) +proc Open*(self: ptr IShellDispatch, vDir: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, vDir) +proc Explore*(self: ptr IShellDispatch, vDir: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Explore(self, vDir) +proc MinimizeAll*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MinimizeAll(self) +proc UndoMinimizeALL*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UndoMinimizeALL(self) +proc FileRun*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FileRun(self) +proc CascadeWindows*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CascadeWindows(self) +proc TileVertically*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TileVertically(self) +proc TileHorizontally*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TileHorizontally(self) +proc ShutdownWindows*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShutdownWindows(self) +proc Suspend*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Suspend(self) +proc EjectPC*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EjectPC(self) +proc SetTime*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTime(self) +proc TrayProperties*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TrayProperties(self) +proc Help*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Help(self) +proc FindFiles*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFiles(self) +proc FindComputer*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindComputer(self) +proc RefreshMenu*(self: ptr IShellDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RefreshMenu(self) +proc ControlPanelItem*(self: ptr IShellDispatch, bstrDir: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ControlPanelItem(self, bstrDir) +proc IsRestricted*(self: ptr IShellDispatch2, Group: BSTR, Restriction: BSTR, plRestrictValue: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRestricted(self, Group, Restriction, plRestrictValue) +proc ShellExecute*(self: ptr IShellDispatch2, File: BSTR, vArgs: VARIANT, vDir: VARIANT, vOperation: VARIANT, vShow: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShellExecute(self, File, vArgs, vDir, vOperation, vShow) +proc FindPrinter*(self: ptr IShellDispatch2, name: BSTR, location: BSTR, model: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindPrinter(self, name, location, model) +proc GetSystemInformation*(self: ptr IShellDispatch2, name: BSTR, pv: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSystemInformation(self, name, pv) +proc mServiceStart*(self: ptr IShellDispatch2, ServiceName: BSTR, Persistent: VARIANT, pSuccess: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ServiceStart(self, ServiceName, Persistent, pSuccess) +proc mServiceStop*(self: ptr IShellDispatch2, ServiceName: BSTR, Persistent: VARIANT, pSuccess: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ServiceStop(self, ServiceName, Persistent, pSuccess) +proc IsServiceRunning*(self: ptr IShellDispatch2, ServiceName: BSTR, pRunning: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsServiceRunning(self, ServiceName, pRunning) +proc CanStartStopService*(self: ptr IShellDispatch2, ServiceName: BSTR, pCanStartStop: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanStartStopService(self, ServiceName, pCanStartStop) +proc ShowBrowserBar*(self: ptr IShellDispatch2, bstrClsid: BSTR, bShow: VARIANT, pSuccess: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowBrowserBar(self, bstrClsid, bShow, pSuccess) +proc AddToRecent*(self: ptr IShellDispatch3, varFile: VARIANT, bstrCategory: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToRecent(self, varFile, bstrCategory) +proc WindowsSecurity*(self: ptr IShellDispatch4): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WindowsSecurity(self) +proc ToggleDesktop*(self: ptr IShellDispatch4): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ToggleDesktop(self) +proc ExplorerPolicy*(self: ptr IShellDispatch4, bstrPolicyName: BSTR, pValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExplorerPolicy(self, bstrPolicyName, pValue) +proc GetSetting*(self: ptr IShellDispatch4, lSetting: LONG, pResult: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSetting(self, lSetting, pResult) +proc WindowSwitcher*(self: ptr IShellDispatch5): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WindowSwitcher(self) +proc SearchCommand*(self: ptr IShellDispatch6): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SearchCommand(self) +proc SetFocus*(self: ptr IFileSearchBand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFocus(self) +proc SetSearchParameters*(self: ptr IFileSearchBand, pbstrSearchID: ptr BSTR, bNavToResults: VARIANT_BOOL, pvarScope: ptr VARIANT, pvarQueryFile: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSearchParameters(self, pbstrSearchID, bNavToResults, pvarScope, pvarQueryFile) +proc get_SearchID*(self: ptr IFileSearchBand, pbstrSearchID: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SearchID(self, pbstrSearchID) +proc get_Scope*(self: ptr IFileSearchBand, pvarScope: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Scope(self, pvarScope) +proc get_QueryFile*(self: ptr IFileSearchBand, pvarFile: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_QueryFile(self, pvarFile) +proc FinalBack*(self: ptr IWebWizardHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FinalBack(self) +proc FinalNext*(self: ptr IWebWizardHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FinalNext(self) +proc Cancel*(self: ptr IWebWizardHost): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cancel(self) +proc put_Caption*(self: ptr IWebWizardHost, bstrCaption: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Caption(self, bstrCaption) +proc get_Caption*(self: ptr IWebWizardHost, pbstrCaption: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Caption(self, pbstrCaption) +proc put_Property*(self: ptr IWebWizardHost, bstrPropertyName: BSTR, pvProperty: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_Property(self, bstrPropertyName, pvProperty) +proc get_Property*(self: ptr IWebWizardHost, bstrPropertyName: BSTR, pvProperty: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Property(self, bstrPropertyName, pvProperty) +proc SetWizardButtons*(self: ptr IWebWizardHost, vfEnableBack: VARIANT_BOOL, vfEnableNext: VARIANT_BOOL, vfLastPage: VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWizardButtons(self, vfEnableBack, vfEnableNext, vfLastPage) +proc SetHeaderText*(self: ptr IWebWizardHost, bstrHeaderTitle: BSTR, bstrHeaderSubtitle: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHeaderText(self, bstrHeaderTitle, bstrHeaderSubtitle) +proc PassportAuthenticate*(self: ptr INewWDEvents, bstrSignInUrl: BSTR, pvfAuthenitcated: ptr VARIANT_BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PassportAuthenticate(self, bstrSignInUrl, pvfAuthenitcated) +proc Init*(self: ptr IAutoComplete, hwndEdit: HWND, punkACL: ptr IUnknown, pwszRegKeyPath: LPCWSTR, pwszQuickComplete: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Init(self, hwndEdit, punkACL, pwszRegKeyPath, pwszQuickComplete) +proc Enable*(self: ptr IAutoComplete, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enable(self, fEnable) +proc SetOptions*(self: ptr IAutoComplete2, dwFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOptions(self, dwFlag) +proc GetOptions*(self: ptr IAutoComplete2, pdwFlag: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptions(self, pdwFlag) +proc NextItem*(self: ptr IEnumACString, pszUrl: LPWSTR, cchMax: ULONG, pulSortIndex: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NextItem(self, pszUrl, cchMax, pulSortIndex) +proc SetEnumOptions*(self: ptr IEnumACString, dwOptions: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEnumOptions(self, dwOptions) +proc GetEnumOptions*(self: ptr IEnumACString, pdwOptions: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumOptions(self, pdwOptions) +proc SetAsyncMode*(self: ptr IDataObjectAsyncCapability, fDoOpAsync: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAsyncMode(self, fDoOpAsync) +proc GetAsyncMode*(self: ptr IDataObjectAsyncCapability, pfIsOpAsync: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAsyncMode(self, pfIsOpAsync) +proc StartOperation*(self: ptr IDataObjectAsyncCapability, pbcReserved: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartOperation(self, pbcReserved) +proc InOperation*(self: ptr IDataObjectAsyncCapability, pfInAsyncOp: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InOperation(self, pfInAsyncOp) +proc EndOperation*(self: ptr IDataObjectAsyncCapability, hResult: HRESULT, pbcReserved: ptr IBindCtx, dwEffects: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndOperation(self, hResult, pbcReserved, dwEffects) +proc GetCount*(self: ptr IObjectArray, pcObjects: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pcObjects) +proc GetAt*(self: ptr IObjectArray, uiIndex: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAt(self, uiIndex, riid, ppv) +proc AddObject*(self: ptr IObjectCollection, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddObject(self, punk) +proc AddFromArray*(self: ptr IObjectCollection, poaSource: ptr IObjectArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddFromArray(self, poaSource) +proc RemoveObjectAt*(self: ptr IObjectCollection, uiIndex: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveObjectAt(self, uiIndex) +proc Clear*(self: ptr IObjectCollection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clear(self) +proc QueryContextMenu*(self: ptr IContextMenu, hmenu: HMENU, indexMenu: UINT, idCmdFirst: UINT, idCmdLast: UINT, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryContextMenu(self, hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags) +proc InvokeCommand*(self: ptr IContextMenu, pici: ptr CMINVOKECOMMANDINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeCommand(self, pici) +proc GetCommandString*(self: ptr IContextMenu, idCmd: UINT_PTR, uType: UINT, pReserved: ptr UINT, pszName: ptr CHAR, cchMax: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCommandString(self, idCmd, uType, pReserved, pszName, cchMax) +proc HandleMenuMsg*(self: ptr IContextMenu2, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleMenuMsg(self, uMsg, wParam, lParam) +proc HandleMenuMsg2*(self: ptr IContextMenu3, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, plResult: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleMenuMsg2(self, uMsg, wParam, lParam, plResult) +proc SetKeyState*(self: ptr IExecuteCommand, grfKeyState: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetKeyState(self, grfKeyState) +proc SetParameters*(self: ptr IExecuteCommand, pszParameters: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetParameters(self, pszParameters) +proc SetPosition*(self: ptr IExecuteCommand, pt: POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPosition(self, pt) +proc SetShowWindow*(self: ptr IExecuteCommand, nShow: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShowWindow(self, nShow) +proc SetNoShowUI*(self: ptr IExecuteCommand, fNoShowUI: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNoShowUI(self, fNoShowUI) +proc SetDirectory*(self: ptr IExecuteCommand, pszDirectory: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDirectory(self, pszDirectory) +proc Execute*(self: ptr IExecuteCommand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Execute(self) +proc Initialize*(self: ptr IPersistFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pidl) +proc Run*(self: ptr IRunnableTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Run(self) +proc Kill*(self: ptr IRunnableTask, bWait: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Kill(self, bWait) +proc Suspend*(self: ptr IRunnableTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Suspend(self) +proc Resume*(self: ptr IRunnableTask): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resume(self) +proc IsRunning*(self: ptr IRunnableTask): ULONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRunning(self) +proc AddTask*(self: ptr IShellTaskScheduler, prt: ptr IRunnableTask, rtoid: REFTASKOWNERID, lParam: DWORD_PTR, dwPriority: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTask(self, prt, rtoid, lParam, dwPriority) +proc RemoveTasks*(self: ptr IShellTaskScheduler, rtoid: REFTASKOWNERID, lParam: DWORD_PTR, bWaitIfRunning: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveTasks(self, rtoid, lParam, bWaitIfRunning) +proc CountTasks*(self: ptr IShellTaskScheduler, rtoid: REFTASKOWNERID): UINT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CountTasks(self, rtoid) +proc Status*(self: ptr IShellTaskScheduler, dwReleaseStatus: DWORD, dwThreadTimeout: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Status(self, dwReleaseStatus, dwThreadTimeout) +proc GetCodePage*(self: ptr IQueryCodePage, puiCodePage: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCodePage(self, puiCodePage) +proc SetCodePage*(self: ptr IQueryCodePage, uiCodePage: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCodePage(self, uiCodePage) +proc GetCurFolder*(self: ptr IPersistFolder2, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurFolder(self, ppidl) +proc InitializeEx*(self: ptr IPersistFolder3, pbc: ptr IBindCtx, pidlRoot: PCIDLIST_ABSOLUTE, ppfti: ptr PERSIST_FOLDER_TARGET_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeEx(self, pbc, pidlRoot, ppfti) +proc GetFolderTargetInfo*(self: ptr IPersistFolder3, ppfti: ptr PERSIST_FOLDER_TARGET_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderTargetInfo(self, ppfti) +proc SetIDList*(self: ptr IPersistIDList, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIDList(self, pidl) +proc GetIDList*(self: ptr IPersistIDList, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDList(self, ppidl) +proc Next*(self: ptr IEnumIDList, celt: ULONG, rgelt: ptr PITEMID_CHILD, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumIDList, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumIDList, ppenum: ptr ptr IEnumIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc Next*(self: ptr IEnumFullIDList, celt: ULONG, rgelt: ptr PIDLIST_ABSOLUTE, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumFullIDList, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumFullIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumFullIDList, ppenum: ptr ptr IEnumFullIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc SetMode*(self: ptr IObjectWithFolderEnumMode, feMode: FOLDER_ENUM_MODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMode(self, feMode) +proc GetMode*(self: ptr IObjectWithFolderEnumMode, pfeMode: ptr FOLDER_ENUM_MODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMode(self, pfeMode) +proc SetItem*(self: ptr IParseAndCreateItem, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItem(self, psi) +proc GetItem*(self: ptr IParseAndCreateItem, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItem(self, riid, ppv) +proc ParseDisplayName*(self: ptr IShellFolder, hwnd: HWND, pbc: ptr IBindCtx, pszDisplayName: LPWSTR, pchEaten: ptr ULONG, ppidl: ptr PIDLIST_RELATIVE, pdwAttributes: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParseDisplayName(self, hwnd, pbc, pszDisplayName, pchEaten, ppidl, pdwAttributes) +proc EnumObjects*(self: ptr IShellFolder, hwnd: HWND, grfFlags: SHCONTF, ppenumIDList: ptr ptr IEnumIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumObjects(self, hwnd, grfFlags, ppenumIDList) +proc BindToObject*(self: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToObject(self, pidl, pbc, riid, ppv) +proc BindToStorage*(self: ptr IShellFolder, pidl: PCUIDLIST_RELATIVE, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToStorage(self, pidl, pbc, riid, ppv) +proc CompareIDs*(self: ptr IShellFolder, lParam: LPARAM, pidl1: PCUIDLIST_RELATIVE, pidl2: PCUIDLIST_RELATIVE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareIDs(self, lParam, pidl1, pidl2) +proc CreateViewObject*(self: ptr IShellFolder, hwndOwner: HWND, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateViewObject(self, hwndOwner, riid, ppv) +proc GetAttributesOf*(self: ptr IShellFolder, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, rgfInOut: ptr SFGAOF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributesOf(self, cidl, apidl, rgfInOut) +proc GetUIObjectOf*(self: ptr IShellFolder, hwndOwner: HWND, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, riid: REFIID, rgfReserved: ptr UINT, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUIObjectOf(self, hwndOwner, cidl, apidl, riid, rgfReserved, ppv) +proc GetDisplayNameOf*(self: ptr IShellFolder, pidl: PCUITEMID_CHILD, uFlags: SHGDNF, pName: ptr STRRET): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayNameOf(self, pidl, uFlags, pName) +proc SetNameOf*(self: ptr IShellFolder, hwnd: HWND, pidl: PCUITEMID_CHILD, pszName: LPCWSTR, uFlags: SHGDNF, ppidlOut: ptr PITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNameOf(self, hwnd, pidl, pszName, uFlags, ppidlOut) +proc Next*(self: ptr IEnumExtraSearch, celt: ULONG, rgelt: ptr EXTRASEARCH, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumExtraSearch, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumExtraSearch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumExtraSearch, ppenum: ptr ptr IEnumExtraSearch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc GetDefaultSearchGUID*(self: ptr IShellFolder2, pguid: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultSearchGUID(self, pguid) +proc EnumSearches*(self: ptr IShellFolder2, ppenum: ptr ptr IEnumExtraSearch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumSearches(self, ppenum) +proc GetDefaultColumn*(self: ptr IShellFolder2, dwRes: DWORD, pSort: ptr ULONG, pDisplay: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultColumn(self, dwRes, pSort, pDisplay) +proc GetDefaultColumnState*(self: ptr IShellFolder2, iColumn: UINT, pcsFlags: ptr SHCOLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultColumnState(self, iColumn, pcsFlags) +proc GetDetailsEx*(self: ptr IShellFolder2, pidl: PCUITEMID_CHILD, pscid: ptr SHCOLUMNID, pv: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDetailsEx(self, pidl, pscid, pv) +proc GetDetailsOf*(self: ptr IShellFolder2, pidl: PCUITEMID_CHILD, iColumn: UINT, psd: ptr SHELLDETAILS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDetailsOf(self, pidl, iColumn, psd) +proc MapColumnToSCID*(self: ptr IShellFolder2, iColumn: UINT, pscid: ptr SHCOLUMNID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MapColumnToSCID(self, iColumn, pscid) +proc SetFolderViewOptions*(self: ptr IFolderViewOptions, fvoMask: FOLDERVIEWOPTIONS, fvoFlags: FOLDERVIEWOPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderViewOptions(self, fvoMask, fvoFlags) +proc GetFolderViewOptions*(self: ptr IFolderViewOptions, pfvoFlags: ptr FOLDERVIEWOPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderViewOptions(self, pfvoFlags) +proc TranslateAccelerator*(self: ptr IShellView, pmsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pmsg) +proc EnableModeless*(self: ptr IShellView, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModeless(self, fEnable) +proc UIActivate*(self: ptr IShellView, uState: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UIActivate(self, uState) +proc Refresh*(self: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Refresh(self) +proc CreateViewWindow*(self: ptr IShellView, psvPrevious: ptr IShellView, pfs: LPCFOLDERSETTINGS, psb: ptr IShellBrowser, prcView: ptr RECT, phWnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateViewWindow(self, psvPrevious, pfs, psb, prcView, phWnd) +proc DestroyViewWindow*(self: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyViewWindow(self) +proc GetCurrentInfo*(self: ptr IShellView, pfs: LPFOLDERSETTINGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentInfo(self, pfs) +proc AddPropertySheetPages*(self: ptr IShellView, dwReserved: DWORD, pfn: LPFNSVADDPROPSHEETPAGE, lparam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPropertySheetPages(self, dwReserved, pfn, lparam) +proc SaveViewState*(self: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveViewState(self) +proc SelectItem*(self: ptr IShellView, pidlItem: PCUITEMID_CHILD, uFlags: SVSIF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectItem(self, pidlItem, uFlags) +proc GetItemObject*(self: ptr IShellView, uItem: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemObject(self, uItem, riid, ppv) +proc GetView*(self: ptr IShellView2, pvid: ptr SHELLVIEWID, uView: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetView(self, pvid, uView) +proc CreateViewWindow2*(self: ptr IShellView2, lpParams: LPSV2CVW2_PARAMS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateViewWindow2(self, lpParams) +proc HandleRename*(self: ptr IShellView2, pidlNew: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleRename(self, pidlNew) +proc SelectAndPositionItem*(self: ptr IShellView2, pidlItem: PCUITEMID_CHILD, uFlags: UINT, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectAndPositionItem(self, pidlItem, uFlags, ppt) +proc CreateViewWindow3*(self: ptr IShellView3, psbOwner: ptr IShellBrowser, psvPrev: ptr IShellView, dwViewFlags: SV3CVW3_FLAGS, dwMask: FOLDERFLAGS, dwFlags: FOLDERFLAGS, fvMode: FOLDERVIEWMODE, pvid: ptr SHELLVIEWID, prcView: ptr RECT, phwndView: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateViewWindow3(self, psbOwner, psvPrev, dwViewFlags, dwMask, dwFlags, fvMode, pvid, prcView, phwndView) +proc GetCurrentViewMode*(self: ptr IFolderView, pViewMode: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentViewMode(self, pViewMode) +proc SetCurrentViewMode*(self: ptr IFolderView, ViewMode: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCurrentViewMode(self, ViewMode) +proc GetFolder*(self: ptr IFolderView, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolder(self, riid, ppv) +proc Item*(self: ptr IFolderView, iItemIndex: int32, ppidl: ptr PITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Item(self, iItemIndex, ppidl) +proc ItemCount*(self: ptr IFolderView, uFlags: UINT, pcItems: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ItemCount(self, uFlags, pcItems) +proc Items*(self: ptr IFolderView, uFlags: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Items(self, uFlags, riid, ppv) +proc GetSelectionMarkedItem*(self: ptr IFolderView, piItem: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectionMarkedItem(self, piItem) +proc GetFocusedItem*(self: ptr IFolderView, piItem: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocusedItem(self, piItem) +proc GetItemPosition*(self: ptr IFolderView, pidl: PCUITEMID_CHILD, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemPosition(self, pidl, ppt) +proc GetSpacing*(self: ptr IFolderView, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSpacing(self, ppt) +proc GetDefaultSpacing*(self: ptr IFolderView, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultSpacing(self, ppt) +proc GetAutoArrange*(self: ptr IFolderView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAutoArrange(self) +proc SelectItem*(self: ptr IFolderView, iItem: int32, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectItem(self, iItem, dwFlags) +proc SelectAndPositionItems*(self: ptr IFolderView, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, apt: ptr POINT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectAndPositionItems(self, cidl, apidl, apt, dwFlags) +proc GetCondition*(self: ptr ISearchBoxInfo, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCondition(self, riid, ppv) +proc GetText*(self: ptr ISearchBoxInfo, ppsz: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetText(self, ppsz) +proc SetGroupBy*(self: ptr IFolderView2, key: REFPROPERTYKEY, fAscending: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGroupBy(self, key, fAscending) +proc GetGroupBy*(self: ptr IFolderView2, pkey: ptr PROPERTYKEY, pfAscending: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGroupBy(self, pkey, pfAscending) +proc SetViewProperty*(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, propkey: REFPROPERTYKEY, propvar: REFPROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetViewProperty(self, pidl, propkey, propvar) +proc GetViewProperty*(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, propkey: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewProperty(self, pidl, propkey, ppropvar) +proc SetTileViewProperties*(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pszPropList: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTileViewProperties(self, pidl, pszPropList) +proc SetExtendedTileViewProperties*(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pszPropList: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetExtendedTileViewProperties(self, pidl, pszPropList) +proc SetText*(self: ptr IFolderView2, iType: FVTEXTTYPE, pwszText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetText(self, iType, pwszText) +proc SetCurrentFolderFlags*(self: ptr IFolderView2, dwMask: DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCurrentFolderFlags(self, dwMask, dwFlags) +proc GetCurrentFolderFlags*(self: ptr IFolderView2, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentFolderFlags(self, pdwFlags) +proc GetSortColumnCount*(self: ptr IFolderView2, pcColumns: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortColumnCount(self, pcColumns) +proc SetSortColumns*(self: ptr IFolderView2, rgSortColumns: ptr SORTCOLUMN, cColumns: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSortColumns(self, rgSortColumns, cColumns) +proc GetSortColumns*(self: ptr IFolderView2, rgSortColumns: ptr SORTCOLUMN, cColumns: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortColumns(self, rgSortColumns, cColumns) +proc GetItem*(self: ptr IFolderView2, iItem: int32, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItem(self, iItem, riid, ppv) +proc GetVisibleItem*(self: ptr IFolderView2, iStart: int32, fPrevious: WINBOOL, piItem: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVisibleItem(self, iStart, fPrevious, piItem) +proc GetSelectedItem*(self: ptr IFolderView2, iStart: int32, piItem: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedItem(self, iStart, piItem) +proc GetSelection*(self: ptr IFolderView2, fNoneImpliesFolder: WINBOOL, ppsia: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, fNoneImpliesFolder, ppsia) +proc GetSelectionState*(self: ptr IFolderView2, pidl: PCUITEMID_CHILD, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectionState(self, pidl, pdwFlags) +proc InvokeVerbOnSelection*(self: ptr IFolderView2, pszVerb: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvokeVerbOnSelection(self, pszVerb) +proc SetViewModeAndIconSize*(self: ptr IFolderView2, uViewMode: FOLDERVIEWMODE, iImageSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetViewModeAndIconSize(self, uViewMode, iImageSize) +proc GetViewModeAndIconSize*(self: ptr IFolderView2, puViewMode: ptr FOLDERVIEWMODE, piImageSize: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewModeAndIconSize(self, puViewMode, piImageSize) +proc SetGroupSubsetCount*(self: ptr IFolderView2, cVisibleRows: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGroupSubsetCount(self, cVisibleRows) +proc GetGroupSubsetCount*(self: ptr IFolderView2, pcVisibleRows: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGroupSubsetCount(self, pcVisibleRows) +proc SetRedraw*(self: ptr IFolderView2, fRedrawOn: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRedraw(self, fRedrawOn) +proc IsMoveInSameFolder*(self: ptr IFolderView2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsMoveInSameFolder(self) +proc DoRename*(self: ptr IFolderView2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoRename(self) +proc GetColumnPropertyList*(self: ptr IFolderViewSettings, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnPropertyList(self, riid, ppv) +proc GetGroupByProperty*(self: ptr IFolderViewSettings, pkey: ptr PROPERTYKEY, pfGroupAscending: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGroupByProperty(self, pkey, pfGroupAscending) +proc GetViewMode*(self: ptr IFolderViewSettings, plvm: ptr FOLDERLOGICALVIEWMODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewMode(self, plvm) +proc GetIconSize*(self: ptr IFolderViewSettings, puIconSize: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconSize(self, puIconSize) +proc GetFolderFlags*(self: ptr IFolderViewSettings, pfolderMask: ptr FOLDERFLAGS, pfolderFlags: ptr FOLDERFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderFlags(self, pfolderMask, pfolderFlags) +proc GetSortColumns*(self: ptr IFolderViewSettings, rgSortColumns: ptr SORTCOLUMN, cColumnsIn: UINT, pcColumnsOut: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSortColumns(self, rgSortColumns, cColumnsIn, pcColumnsOut) +proc GetGroupSubsetCount*(self: ptr IFolderViewSettings, pcVisibleRows: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGroupSubsetCount(self, pcVisibleRows) +proc mSetBackgroundColor*(self: ptr IPreviewHandlerVisuals, color: COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBackgroundColor(self, color) +proc SetFont*(self: ptr IPreviewHandlerVisuals, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFont(self, plf) +proc SetTextColor*(self: ptr IPreviewHandlerVisuals, color: COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTextColor(self, color) +proc SetWatermark*(self: ptr IVisualProperties, hbmp: HBITMAP, vpwf: VPWATERMARKFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWatermark(self, hbmp, vpwf) +proc SetColor*(self: ptr IVisualProperties, vpcf: VPCOLORFLAGS, cr: COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColor(self, vpcf, cr) +proc GetColor*(self: ptr IVisualProperties, vpcf: VPCOLORFLAGS, pcr: ptr COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColor(self, vpcf, pcr) +proc SetItemHeight*(self: ptr IVisualProperties, cyItemInPixels: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItemHeight(self, cyItemInPixels) +proc GetItemHeight*(self: ptr IVisualProperties, cyItemInPixels: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemHeight(self, cyItemInPixels) +proc SetFont*(self: ptr IVisualProperties, plf: ptr LOGFONTW, bRedraw: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFont(self, plf, bRedraw) +proc GetFont*(self: ptr IVisualProperties, plf: ptr LOGFONTW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFont(self, plf) +proc SetTheme*(self: ptr IVisualProperties, pszSubAppName: LPCWSTR, pszSubIdList: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTheme(self, pszSubAppName, pszSubIdList) +proc OnDefaultCommand*(self: ptr ICommDlgBrowser, ppshv: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDefaultCommand(self, ppshv) +proc OnStateChange*(self: ptr ICommDlgBrowser, ppshv: ptr IShellView, uChange: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStateChange(self, ppshv, uChange) +proc IncludeObject*(self: ptr ICommDlgBrowser, ppshv: ptr IShellView, pidl: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IncludeObject(self, ppshv, pidl) +proc Notify*(self: ptr ICommDlgBrowser2, ppshv: ptr IShellView, dwNotifyType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Notify(self, ppshv, dwNotifyType) +proc GetDefaultMenuText*(self: ptr ICommDlgBrowser2, ppshv: ptr IShellView, pszText: LPWSTR, cchMax: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultMenuText(self, ppshv, pszText, cchMax) +proc GetViewFlags*(self: ptr ICommDlgBrowser2, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewFlags(self, pdwFlags) +proc OnColumnClicked*(self: ptr ICommDlgBrowser3, ppshv: ptr IShellView, iColumn: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnColumnClicked(self, ppshv, iColumn) +proc GetCurrentFilter*(self: ptr ICommDlgBrowser3, pszFileSpec: LPWSTR, cchFileSpec: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentFilter(self, pszFileSpec, cchFileSpec) +proc OnPreViewCreated*(self: ptr ICommDlgBrowser3, ppshv: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPreViewCreated(self, ppshv) +proc SetColumnInfo*(self: ptr IColumnManager, propkey: REFPROPERTYKEY, pcmci: ptr CM_COLUMNINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColumnInfo(self, propkey, pcmci) +proc GetColumnInfo*(self: ptr IColumnManager, propkey: REFPROPERTYKEY, pcmci: ptr CM_COLUMNINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnInfo(self, propkey, pcmci) +proc GetColumnCount*(self: ptr IColumnManager, dwFlags: CM_ENUM_FLAGS, puCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnCount(self, dwFlags, puCount) +proc GetColumns*(self: ptr IColumnManager, dwFlags: CM_ENUM_FLAGS, rgkeyOrder: ptr PROPERTYKEY, cColumns: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumns(self, dwFlags, rgkeyOrder, cColumns) +proc SetColumns*(self: ptr IColumnManager, rgkeyOrder: ptr PROPERTYKEY, cVisible: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColumns(self, rgkeyOrder, cVisible) +proc SetFilter*(self: ptr IFolderFilterSite, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFilter(self, punk) +proc ShouldShow*(self: ptr IFolderFilter, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, pidlItem: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShouldShow(self, psf, pidlFolder, pidlItem) +proc GetEnumFlags*(self: ptr IFolderFilter, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, phwnd: ptr HWND, pgrfFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumFlags(self, psf, pidlFolder, phwnd, pgrfFlags) +proc OnFocusChangeIS*(self: ptr IInputObjectSite, punkObj: ptr IUnknown, fSetFocus: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFocusChangeIS(self, punkObj, fSetFocus) +proc UIActivateIO*(self: ptr IInputObject, fActivate: WINBOOL, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UIActivateIO(self, fActivate, pMsg) +proc HasFocusIO*(self: ptr IInputObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasFocusIO(self) +proc TranslateAcceleratorIO*(self: ptr IInputObject, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAcceleratorIO(self, pMsg) +proc TranslateAcceleratorGlobal*(self: ptr IInputObject2, pMsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAcceleratorGlobal(self, pMsg) +proc GetIconOf*(self: ptr IShellIcon, pidl: PCUITEMID_CHILD, flags: UINT, pIconIndex: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconOf(self, pidl, flags, pIconIndex) +proc InsertMenusSB*(self: ptr IShellBrowser, hmenuShared: HMENU, lpMenuWidths: LPOLEMENUGROUPWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertMenusSB(self, hmenuShared, lpMenuWidths) +proc SetMenuSB*(self: ptr IShellBrowser, hmenuShared: HMENU, holemenuRes: HOLEMENU, hwndActiveObject: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMenuSB(self, hmenuShared, holemenuRes, hwndActiveObject) +proc RemoveMenusSB*(self: ptr IShellBrowser, hmenuShared: HMENU): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveMenusSB(self, hmenuShared) +proc SetStatusTextSB*(self: ptr IShellBrowser, pszStatusText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStatusTextSB(self, pszStatusText) +proc EnableModelessSB*(self: ptr IShellBrowser, fEnable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableModelessSB(self, fEnable) +proc TranslateAcceleratorSB*(self: ptr IShellBrowser, pmsg: ptr MSG, wID: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAcceleratorSB(self, pmsg, wID) +proc BrowseObject*(self: ptr IShellBrowser, pidl: PCUIDLIST_RELATIVE, wFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BrowseObject(self, pidl, wFlags) +proc GetViewStateStream*(self: ptr IShellBrowser, grfMode: DWORD, ppStrm: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewStateStream(self, grfMode, ppStrm) +proc GetControlWindow*(self: ptr IShellBrowser, id: UINT, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlWindow(self, id, phwnd) +proc SendControlMsg*(self: ptr IShellBrowser, id: UINT, uMsg: UINT, wParam: WPARAM, lParam: LPARAM, pret: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SendControlMsg(self, id, uMsg, wParam, lParam, pret) +proc QueryActiveShellView*(self: ptr IShellBrowser, ppshv: ptr ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryActiveShellView(self, ppshv) +proc OnViewWindowActive*(self: ptr IShellBrowser, pshv: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnViewWindowActive(self, pshv) +proc SetToolbarItems*(self: ptr IShellBrowser, lpButtons: LPTBBUTTONSB, nButtons: UINT, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetToolbarItems(self, lpButtons, nButtons, uFlags) +proc ProfferService*(self: ptr IProfferService, guidService: REFGUID, psp: ptr IServiceProvider, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ProfferService(self, guidService, psp, pdwCookie) +proc RevokeService*(self: ptr IProfferService, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RevokeService(self, dwCookie) +proc BindToHandler*(self: ptr IShellItem, pbc: ptr IBindCtx, bhid: REFGUID, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToHandler(self, pbc, bhid, riid, ppv) +proc GetParent*(self: ptr IShellItem, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParent(self, ppsi) +proc GetDisplayName*(self: ptr IShellItem, sigdnName: SIGDN, ppszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayName(self, sigdnName, ppszName) +proc GetAttributes*(self: ptr IShellItem, sfgaoMask: SFGAOF, psfgaoAttribs: ptr SFGAOF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributes(self, sfgaoMask, psfgaoAttribs) +proc Compare*(self: ptr IShellItem, psi: ptr IShellItem, hint: SICHINTF, piOrder: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Compare(self, psi, hint, piOrder) +proc GetPropertyStore*(self: ptr IShellItem2, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStore(self, flags, riid, ppv) +proc GetPropertyStoreWithCreateObject*(self: ptr IShellItem2, flags: GETPROPERTYSTOREFLAGS, punkCreateObject: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStoreWithCreateObject(self, flags, punkCreateObject, riid, ppv) +proc GetPropertyStoreForKeys*(self: ptr IShellItem2, rgKeys: ptr PROPERTYKEY, cKeys: UINT, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStoreForKeys(self, rgKeys, cKeys, flags, riid, ppv) +proc GetPropertyDescriptionList*(self: ptr IShellItem2, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescriptionList(self, keyType, riid, ppv) +proc Update*(self: ptr IShellItem2, pbc: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Update(self, pbc) +proc GetProperty*(self: ptr IShellItem2, key: REFPROPERTYKEY, ppropvar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, key, ppropvar) +proc GetCLSID*(self: ptr IShellItem2, key: REFPROPERTYKEY, pclsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCLSID(self, key, pclsid) +proc GetFileTime*(self: ptr IShellItem2, key: REFPROPERTYKEY, pft: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileTime(self, key, pft) +proc GetInt32*(self: ptr IShellItem2, key: REFPROPERTYKEY, pi: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInt32(self, key, pi) +proc GetString*(self: ptr IShellItem2, key: REFPROPERTYKEY, ppsz: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetString(self, key, ppsz) +proc GetUInt32*(self: ptr IShellItem2, key: REFPROPERTYKEY, pui: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUInt32(self, key, pui) +proc GetUInt64*(self: ptr IShellItem2, key: REFPROPERTYKEY, pull: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUInt64(self, key, pull) +proc GetBool*(self: ptr IShellItem2, key: REFPROPERTYKEY, pf: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBool(self, key, pf) +proc GetImage*(self: ptr IShellItemImageFactory, size: SIZE, flags: SIIGBF, phbm: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetImage(self, size, flags, phbm) +proc OnPictureChange*(self: ptr IUserAccountChangeCallback, pszUserName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPictureChange(self, pszUserName) +proc Next*(self: ptr IEnumShellItems, celt: ULONG, rgelt: ptr ptr IShellItem, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumShellItems, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumShellItems): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumShellItems, ppenum: ptr ptr IEnumShellItems): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc UpdateProgress*(self: ptr ITransferAdviseSink, ullSizeCurrent: ULONGLONG, ullSizeTotal: ULONGLONG, nFilesCurrent: int32, nFilesTotal: int32, nFoldersCurrent: int32, nFoldersTotal: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateProgress(self, ullSizeCurrent, ullSizeTotal, nFilesCurrent, nFilesTotal, nFoldersCurrent, nFoldersTotal) +proc UpdateTransferState*(self: ptr ITransferAdviseSink, ts: TRANSFER_ADVISE_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateTransferState(self, ts) +proc ConfirmOverwrite*(self: ptr ITransferAdviseSink, psiSource: ptr IShellItem, psiDestParent: ptr IShellItem, pszName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfirmOverwrite(self, psiSource, psiDestParent, pszName) +proc ConfirmEncryptionLoss*(self: ptr ITransferAdviseSink, psiSource: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConfirmEncryptionLoss(self, psiSource) +proc FileFailure*(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pszItem: LPCWSTR, hrError: HRESULT, pszRename: LPWSTR, cchRename: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FileFailure(self, psi, pszItem, hrError, pszRename, cchRename) +proc SubStreamFailure*(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pszStreamName: LPCWSTR, hrError: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SubStreamFailure(self, psi, pszStreamName, hrError) +proc PropertyFailure*(self: ptr ITransferAdviseSink, psi: ptr IShellItem, pkey: ptr PROPERTYKEY, hrError: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PropertyFailure(self, psi, pkey, hrError) +proc Advise*(self: ptr ITransferSource, psink: ptr ITransferAdviseSink, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, psink, pdwCookie) +proc Unadvise*(self: ptr ITransferSource, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc SetProperties*(self: ptr ITransferSource, pproparray: ptr IPropertyChangeArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProperties(self, pproparray) +proc OpenItem*(self: ptr ITransferSource, psi: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenItem(self, psi, flags, riid, ppv) +proc MoveItem*(self: ptr ITransferSource, psi: ptr IShellItem, psiParentDst: ptr IShellItem, pszNameDst: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNew: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveItem(self, psi, psiParentDst, pszNameDst, flags, ppsiNew) +proc RecycleItem*(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecycleItem(self, psiSource, psiParentDest, flags, ppsiNewDest) +proc RemoveItem*(self: ptr ITransferSource, psiSource: ptr IShellItem, flags: TRANSFER_SOURCE_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveItem(self, psiSource, flags) +proc RenameItem*(self: ptr ITransferSource, psiSource: ptr IShellItem, pszNewName: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RenameItem(self, psiSource, pszNewName, flags, ppsiNewDest) +proc LinkItem*(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, pszNewName: LPCWSTR, flags: TRANSFER_SOURCE_FLAGS, ppsiNewDest: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LinkItem(self, psiSource, psiParentDest, pszNewName, flags, ppsiNewDest) +proc ApplyPropertiesToItem*(self: ptr ITransferSource, psiSource: ptr IShellItem, ppsiNew: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyPropertiesToItem(self, psiSource, ppsiNew) +proc GetDefaultDestinationName*(self: ptr ITransferSource, psiSource: ptr IShellItem, psiParentDest: ptr IShellItem, ppszDestinationName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultDestinationName(self, psiSource, psiParentDest, ppszDestinationName) +proc EnterFolder*(self: ptr ITransferSource, psiChildFolderDest: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnterFolder(self, psiChildFolderDest) +proc LeaveFolder*(self: ptr ITransferSource, psiChildFolderDest: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LeaveFolder(self, psiChildFolderDest) +proc Next*(self: ptr IEnumResources, celt: ULONG, psir: ptr SHELL_ITEM_RESOURCE, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, psir, pceltFetched) +proc Skip*(self: ptr IEnumResources, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumResources): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumResources, ppenumr: ptr ptr IEnumResources): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenumr) +proc GetAttributes*(self: ptr IShellItemResources, pdwAttributes: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributes(self, pdwAttributes) +proc GetSize*(self: ptr IShellItemResources, pullSize: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, pullSize) +proc GetTimes*(self: ptr IShellItemResources, pftCreation: ptr FILETIME, pftWrite: ptr FILETIME, pftAccess: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTimes(self, pftCreation, pftWrite, pftAccess) +proc SetTimes*(self: ptr IShellItemResources, pftCreation: ptr FILETIME, pftWrite: ptr FILETIME, pftAccess: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTimes(self, pftCreation, pftWrite, pftAccess) +proc GetResourceDescription*(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, ppszDescription: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetResourceDescription(self, pcsir, ppszDescription) +proc EnumResources*(self: ptr IShellItemResources, ppenumr: ptr ptr IEnumResources): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumResources(self, ppenumr) +proc SupportsResource*(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SupportsResource(self, pcsir) +proc OpenResource*(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OpenResource(self, pcsir, riid, ppv) +proc CreateResource*(self: ptr IShellItemResources, pcsir: ptr SHELL_ITEM_RESOURCE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateResource(self, pcsir, riid, ppv) +proc MarkForDelete*(self: ptr IShellItemResources): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MarkForDelete(self) +proc Advise*(self: ptr ITransferDestination, psink: ptr ITransferAdviseSink, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, psink, pdwCookie) +proc Unadvise*(self: ptr ITransferDestination, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc CreateItem*(self: ptr ITransferDestination, pszName: LPCWSTR, dwAttributes: DWORD, ullSize: ULONGLONG, flags: TRANSFER_SOURCE_FLAGS, riidItem: REFIID, ppvItem: ptr pointer, riidResources: REFIID, ppvResources: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateItem(self, pszName, dwAttributes, ullSize, flags, riidItem, ppvItem, riidResources, ppvResources) +proc ReadAsync*(self: ptr IStreamAsync, pv: pointer, cb: DWORD, pcbRead: LPDWORD, lpOverlapped: LPOVERLAPPED): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadAsync(self, pv, cb, pcbRead, lpOverlapped) +proc WriteAsync*(self: ptr IStreamAsync, lpBuffer: pointer, cb: DWORD, pcbWritten: LPDWORD, lpOverlapped: LPOVERLAPPED): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteAsync(self, lpBuffer, cb, pcbWritten, lpOverlapped) +proc OverlappedResult*(self: ptr IStreamAsync, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OverlappedResult(self, lpOverlapped, lpNumberOfBytesTransferred, bWait) +proc CancelIo*(self: ptr IStreamAsync): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CancelIo(self) +proc GetSectorSize*(self: ptr IStreamUnbufferedInfo, pcbSectorSize: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSectorSize(self, pcbSectorSize) +proc StartOperations*(self: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartOperations(self) +proc FinishOperations*(self: ptr IFileOperationProgressSink, hrResult: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FinishOperations(self, hrResult) +proc PreRenameItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreRenameItem(self, dwFlags, psiItem, pszNewName) +proc PostRenameItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, pszNewName: LPCWSTR, hrRename: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostRenameItem(self, dwFlags, psiItem, pszNewName, hrRename, psiNewlyCreated) +proc PreMoveItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreMoveItem(self, dwFlags, psiItem, psiDestinationFolder, pszNewName) +proc PostMoveItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostMoveItem(self, dwFlags, psiItem, psiDestinationFolder, pszNewName, hrMove, psiNewlyCreated) +proc PreCopyItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreCopyItem(self, dwFlags, psiItem, psiDestinationFolder, pszNewName) +proc PostCopyItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, hrCopy: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostCopyItem(self, dwFlags, psiItem, psiDestinationFolder, pszNewName, hrCopy, psiNewlyCreated) +proc PreDeleteItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreDeleteItem(self, dwFlags, psiItem) +proc PostDeleteItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiItem: ptr IShellItem, hrDelete: HRESULT, psiNewlyCreated: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostDeleteItem(self, dwFlags, psiItem, hrDelete, psiNewlyCreated) +proc PreNewItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PreNewItem(self, dwFlags, psiDestinationFolder, pszNewName) +proc PostNewItem*(self: ptr IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, pszTemplateName: LPCWSTR, dwFileAttributes: DWORD, hrNew: HRESULT, psiNewItem: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostNewItem(self, dwFlags, psiDestinationFolder, pszNewName, pszTemplateName, dwFileAttributes, hrNew, psiNewItem) +proc UpdateProgress*(self: ptr IFileOperationProgressSink, iWorkTotal: UINT, iWorkSoFar: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateProgress(self, iWorkTotal, iWorkSoFar) +proc ResetTimer*(self: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetTimer(self) +proc PauseTimer*(self: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PauseTimer(self) +proc ResumeTimer*(self: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResumeTimer(self) +proc BindToHandler*(self: ptr IShellItemArray, pbc: ptr IBindCtx, bhid: REFGUID, riid: REFIID, ppvOut: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BindToHandler(self, pbc, bhid, riid, ppvOut) +proc GetPropertyStore*(self: ptr IShellItemArray, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyStore(self, flags, riid, ppv) +proc GetPropertyDescriptionList*(self: ptr IShellItemArray, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescriptionList(self, keyType, riid, ppv) +proc GetAttributes*(self: ptr IShellItemArray, AttribFlags: SIATTRIBFLAGS, sfgaoMask: SFGAOF, psfgaoAttribs: ptr SFGAOF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributes(self, AttribFlags, sfgaoMask, psfgaoAttribs) +proc GetCount*(self: ptr IShellItemArray, pdwNumItems: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCount(self, pdwNumItems) +proc GetItemAt*(self: ptr IShellItemArray, dwIndex: DWORD, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemAt(self, dwIndex, ppsi) +proc EnumItems*(self: ptr IShellItemArray, ppenumShellItems: ptr ptr IEnumShellItems): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumItems(self, ppenumShellItems) +proc Initialize*(self: ptr IInitializeWithItem, psi: ptr IShellItem, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, psi, grfMode) +proc SetSelection*(self: ptr IObjectWithSelection, psia: ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSelection(self, psia) +proc GetSelection*(self: ptr IObjectWithSelection, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, riid, ppv) +proc RemoveBackReferences*(self: ptr IObjectWithBackReferences): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveBackReferences(self) +proc ParsePropertyName*(self: ptr IPropertyUI, pszName: LPCWSTR, pfmtid: ptr FMTID, ppid: ptr PROPID, pchEaten: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ParsePropertyName(self, pszName, pfmtid, ppid, pchEaten) +proc GetCannonicalName*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCannonicalName(self, fmtid, pid, pwszText, cchText) +proc GetDisplayName*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, flags: PROPERTYUI_NAME_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDisplayName(self, fmtid, pid, flags, pwszText, cchText) +proc GetPropertyDescription*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyDescription(self, fmtid, pid, pwszText, cchText) +proc GetDefaultWidth*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pcxChars: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultWidth(self, fmtid, pid, pcxChars) +proc GetFlags*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pflags: ptr PROPERTYUI_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFlags(self, fmtid, pid, pflags) +proc FormatForDisplay*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, ppropvar: ptr PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwszText: LPWSTR, cchText: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FormatForDisplay(self, fmtid, pid, ppropvar, puiff, pwszText, cchText) +proc GetHelpInfo*(self: ptr IPropertyUI, fmtid: REFFMTID, pid: PROPID, pwszHelpFile: LPWSTR, cch: DWORD, puHelpID: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHelpInfo(self, fmtid, pid, pwszHelpFile, cch, puHelpID) +proc CanCategorizeOnSCID*(self: ptr ICategoryProvider, pscid: ptr SHCOLUMNID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanCategorizeOnSCID(self, pscid) +proc GetDefaultCategory*(self: ptr ICategoryProvider, pguid: ptr GUID, pscid: ptr SHCOLUMNID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultCategory(self, pguid, pscid) +proc GetCategoryForSCID*(self: ptr ICategoryProvider, pscid: ptr SHCOLUMNID, pguid: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategoryForSCID(self, pscid, pguid) +proc EnumCategories*(self: ptr ICategoryProvider, penum: ptr ptr IEnumGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumCategories(self, penum) +proc GetCategoryName*(self: ptr ICategoryProvider, pguid: ptr GUID, pszName: LPWSTR, cch: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategoryName(self, pguid, pszName, cch) +proc CreateCategory*(self: ptr ICategoryProvider, pguid: ptr GUID, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateCategory(self, pguid, riid, ppv) +proc GetDescription*(self: ptr ICategorizer, pszDesc: LPWSTR, cch: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pszDesc, cch) +proc GetCategory*(self: ptr ICategorizer, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, rgCategoryIds: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategory(self, cidl, apidl, rgCategoryIds) +proc GetCategoryInfo*(self: ptr ICategorizer, dwCategoryId: DWORD, pci: ptr TCATEGORY_INFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategoryInfo(self, dwCategoryId, pci) +proc CompareCategory*(self: ptr ICategorizer, csfFlags: CATSORT_FLAGS, dwCategoryId1: DWORD, dwCategoryId2: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareCategory(self, csfFlags, dwCategoryId1, dwCategoryId2) +proc DragEnter*(self: ptr IDropTargetHelper, hwndTarget: HWND, pDataObject: ptr IDataObject, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragEnter(self, hwndTarget, pDataObject, ppt, dwEffect) +proc DragLeave*(self: ptr IDropTargetHelper): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragLeave(self) +proc DragOver*(self: ptr IDropTargetHelper, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DragOver(self, ppt, dwEffect) +proc Drop*(self: ptr IDropTargetHelper, pDataObject: ptr IDataObject, ppt: ptr POINT, dwEffect: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Drop(self, pDataObject, ppt, dwEffect) +proc Show*(self: ptr IDropTargetHelper, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, fShow) +proc InitializeFromBitmap*(self: ptr IDragSourceHelper, pshdi: LPSHDRAGIMAGE, pDataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromBitmap(self, pshdi, pDataObject) +proc InitializeFromWindow*(self: ptr IDragSourceHelper, hwnd: HWND, ppt: ptr POINT, pDataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromWindow(self, hwnd, ppt, pDataObject) +proc SetFlags*(self: ptr IDragSourceHelper2, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFlags(self, dwFlags) +proc GetPath*(self: ptr IShellLinkA, pszFile: LPSTR, cch: int32, pfd: ptr WIN32_FIND_DATAA, fFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, pszFile, cch, pfd, fFlags) +proc GetIDList*(self: ptr IShellLinkA, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDList(self, ppidl) +proc SetIDList*(self: ptr IShellLinkA, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIDList(self, pidl) +proc GetDescription*(self: ptr IShellLinkA, pszName: LPSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pszName, cch) +proc SetDescription*(self: ptr IShellLinkA, pszName: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDescription(self, pszName) +proc GetWorkingDirectory*(self: ptr IShellLinkA, pszDir: LPSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWorkingDirectory(self, pszDir, cch) +proc SetWorkingDirectory*(self: ptr IShellLinkA, pszDir: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWorkingDirectory(self, pszDir) +proc GetArguments*(self: ptr IShellLinkA, pszArgs: LPSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetArguments(self, pszArgs, cch) +proc SetArguments*(self: ptr IShellLinkA, pszArgs: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetArguments(self, pszArgs) +proc GetHotkey*(self: ptr IShellLinkA, pwHotkey: ptr WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHotkey(self, pwHotkey) +proc SetHotkey*(self: ptr IShellLinkA, wHotkey: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHotkey(self, wHotkey) +proc GetShowCmd*(self: ptr IShellLinkA, piShowCmd: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShowCmd(self, piShowCmd) +proc SetShowCmd*(self: ptr IShellLinkA, iShowCmd: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShowCmd(self, iShowCmd) +proc GetIconLocation*(self: ptr IShellLinkA, pszIconPath: LPSTR, cch: int32, piIcon: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, pszIconPath, cch, piIcon) +proc SetIconLocation*(self: ptr IShellLinkA, pszIconPath: LPCSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconLocation(self, pszIconPath, iIcon) +proc SetRelativePath*(self: ptr IShellLinkA, pszPathRel: LPCSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRelativePath(self, pszPathRel, dwReserved) +proc Resolve*(self: ptr IShellLinkA, hwnd: HWND, fFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resolve(self, hwnd, fFlags) +proc SetPath*(self: ptr IShellLinkA, pszFile: LPCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPath(self, pszFile) +proc GetPath*(self: ptr IShellLinkW, pszFile: LPWSTR, cch: int32, pfd: ptr WIN32_FIND_DATAW, fFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, pszFile, cch, pfd, fFlags) +proc GetIDList*(self: ptr IShellLinkW, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDList(self, ppidl) +proc SetIDList*(self: ptr IShellLinkW, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIDList(self, pidl) +proc GetDescription*(self: ptr IShellLinkW, pszName: LPWSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDescription(self, pszName, cch) +proc SetDescription*(self: ptr IShellLinkW, pszName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDescription(self, pszName) +proc GetWorkingDirectory*(self: ptr IShellLinkW, pszDir: LPWSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWorkingDirectory(self, pszDir, cch) +proc SetWorkingDirectory*(self: ptr IShellLinkW, pszDir: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWorkingDirectory(self, pszDir) +proc GetArguments*(self: ptr IShellLinkW, pszArgs: LPWSTR, cch: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetArguments(self, pszArgs, cch) +proc SetArguments*(self: ptr IShellLinkW, pszArgs: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetArguments(self, pszArgs) +proc GetHotkey*(self: ptr IShellLinkW, pwHotkey: ptr WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetHotkey(self, pwHotkey) +proc SetHotkey*(self: ptr IShellLinkW, wHotkey: WORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHotkey(self, wHotkey) +proc GetShowCmd*(self: ptr IShellLinkW, piShowCmd: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShowCmd(self, piShowCmd) +proc SetShowCmd*(self: ptr IShellLinkW, iShowCmd: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShowCmd(self, iShowCmd) +proc GetIconLocation*(self: ptr IShellLinkW, pszIconPath: LPWSTR, cch: int32, piIcon: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, pszIconPath, cch, piIcon) +proc SetIconLocation*(self: ptr IShellLinkW, pszIconPath: LPCWSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconLocation(self, pszIconPath, iIcon) +proc SetRelativePath*(self: ptr IShellLinkW, pszPathRel: LPCWSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRelativePath(self, pszPathRel, dwReserved) +proc Resolve*(self: ptr IShellLinkW, hwnd: HWND, fFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resolve(self, hwnd, fFlags) +proc SetPath*(self: ptr IShellLinkW, pszFile: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPath(self, pszFile) +proc AddDataBlock*(self: ptr IShellLinkDataList, pDataBlock: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDataBlock(self, pDataBlock) +proc CopyDataBlock*(self: ptr IShellLinkDataList, dwSig: DWORD, ppDataBlock: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyDataBlock(self, dwSig, ppDataBlock) +proc RemoveDataBlock*(self: ptr IShellLinkDataList, dwSig: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveDataBlock(self, dwSig) +proc GetFlags*(self: ptr IShellLinkDataList, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFlags(self, pdwFlags) +proc SetFlags*(self: ptr IShellLinkDataList, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFlags(self, dwFlags) +proc ResolveShellLink*(self: ptr IResolveShellLink, punkLink: ptr IUnknown, hwnd: HWND, fFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResolveShellLink(self, punkLink, hwnd, fFlags) +proc Initialize*(self: ptr IActionProgressDialog, flags: SPINITF, pszTitle: LPCWSTR, pszCancel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, flags, pszTitle, pszCancel) +proc Stop*(self: ptr IActionProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Stop(self) +proc Initialize*(self: ptr IHWEventHandler, pszParams: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pszParams) +proc HandleEvent*(self: ptr IHWEventHandler, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleEvent(self, pszDeviceID, pszAltDeviceID, pszEventType) +proc HandleEventWithContent*(self: ptr IHWEventHandler, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR, pszContentTypeHandler: LPCWSTR, pdataobject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleEventWithContent(self, pszDeviceID, pszAltDeviceID, pszEventType, pszContentTypeHandler, pdataobject) +proc HandleEventWithHWND*(self: ptr IHWEventHandler2, pszDeviceID: LPCWSTR, pszAltDeviceID: LPCWSTR, pszEventType: LPCWSTR, hwndOwner: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleEventWithHWND(self, pszDeviceID, pszAltDeviceID, pszEventType, hwndOwner) +proc AllowAutoPlay*(self: ptr IQueryCancelAutoPlay, pszPath: LPCWSTR, dwContentType: DWORD, pszLabel: LPCWSTR, dwSerialNumber: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AllowAutoPlay(self, pszPath, dwContentType, pszLabel, dwSerialNumber) +proc GetDynamicInfo*(self: ptr IDynamicHWHandler, pszDeviceID: LPCWSTR, dwContentType: DWORD, ppszAction: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDynamicInfo(self, pszDeviceID, dwContentType, ppszAction) +proc Begin*(self: ptr IActionProgress, action: SPACTION, flags: SPBEGINF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin(self, action, flags) +proc UpdateProgress*(self: ptr IActionProgress, ulCompleted: ULONGLONG, ulTotal: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateProgress(self, ulCompleted, ulTotal) +proc UpdateText*(self: ptr IActionProgress, sptext: SPTEXT, pszText: LPCWSTR, fMayCompact: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateText(self, sptext, pszText, fMayCompact) +proc QueryCancel*(self: ptr IActionProgress, pfCancelled: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCancel(self, pfCancelled) +proc ResetCancel*(self: ptr IActionProgress): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetCancel(self) +proc End*(self: ptr IActionProgress): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.End(self) +proc Initialize*(self: ptr IShellExtInit, pidlFolder: PCIDLIST_ABSOLUTE, pdtobj: ptr IDataObject, hkeyProgID: HKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pidlFolder, pdtobj, hkeyProgID) +proc AddPages*(self: ptr IShellPropSheetExt, pfnAddPage: LPFNSVADDPROPSHEETPAGE, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPages(self, pfnAddPage, lParam) +proc ReplacePage*(self: ptr IShellPropSheetExt, uPageID: EXPPS, pfnReplaceWith: LPFNSVADDPROPSHEETPAGE, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReplacePage(self, uPageID, pfnReplaceWith, lParam) +proc Initialize*(self: ptr IRemoteComputer, pszMachine: LPCWSTR, bEnumerating: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pszMachine, bEnumerating) +proc QueryContinue*(self: ptr IQueryContinue): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryContinue(self) +proc GetCancelEvent*(self: ptr IObjectWithCancelEvent, phEvent: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCancelEvent(self, phEvent) +proc SetBalloonInfo*(self: ptr IUserNotification, pszTitle: LPCWSTR, pszText: LPCWSTR, dwInfoFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBalloonInfo(self, pszTitle, pszText, dwInfoFlags) +proc SetBalloonRetry*(self: ptr IUserNotification, dwShowTime: DWORD, dwInterval: DWORD, cRetryCount: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBalloonRetry(self, dwShowTime, dwInterval, cRetryCount) +proc SetIconInfo*(self: ptr IUserNotification, hIcon: HICON, pszToolTip: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconInfo(self, hIcon, pszToolTip) +proc Show*(self: ptr IUserNotification, pqc: ptr IQueryContinue, dwContinuePollInterval: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, pqc, dwContinuePollInterval) +proc PlaySound*(self: ptr IUserNotification, pszSoundName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PlaySound(self, pszSoundName) +proc OnBalloonUserClick*(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBalloonUserClick(self, pt) +proc OnLeftClick*(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnLeftClick(self, pt) +proc OnContextMenu*(self: ptr IUserNotificationCallback, pt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnContextMenu(self, pt) +proc SetBalloonInfo*(self: ptr IUserNotification2, pszTitle: LPCWSTR, pszText: LPCWSTR, dwInfoFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBalloonInfo(self, pszTitle, pszText, dwInfoFlags) +proc SetBalloonRetry*(self: ptr IUserNotification2, dwShowTime: DWORD, dwInterval: DWORD, cRetryCount: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBalloonRetry(self, dwShowTime, dwInterval, cRetryCount) +proc SetIconInfo*(self: ptr IUserNotification2, hIcon: HICON, pszToolTip: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconInfo(self, hIcon, pszToolTip) +proc Show*(self: ptr IUserNotification2, pqc: ptr IQueryContinue, dwContinuePollInterval: DWORD, pSink: ptr IUserNotificationCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, pqc, dwContinuePollInterval, pSink) +proc PlaySound*(self: ptr IUserNotification2, pszSoundName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PlaySound(self, pszSoundName) +proc GetValidCharacters*(self: ptr IItemNameLimits, ppwszValidChars: ptr LPWSTR, ppwszInvalidChars: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValidCharacters(self, ppwszValidChars, ppwszInvalidChars) +proc GetMaxLength*(self: ptr IItemNameLimits, pszName: LPCWSTR, piMaxNameLen: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMaxLength(self, pszName, piMaxNameLen) +proc SetDisplayName*(self: ptr ISearchFolderItemFactory, pszDisplayName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDisplayName(self, pszDisplayName) +proc SetFolderTypeID*(self: ptr ISearchFolderItemFactory, ftid: FOLDERTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderTypeID(self, ftid) +proc SetFolderLogicalViewMode*(self: ptr ISearchFolderItemFactory, flvm: FOLDERLOGICALVIEWMODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderLogicalViewMode(self, flvm) +proc SetIconSize*(self: ptr ISearchFolderItemFactory, iIconSize: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconSize(self, iIconSize) +proc SetVisibleColumns*(self: ptr ISearchFolderItemFactory, cVisibleColumns: UINT, rgKey: ptr PROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVisibleColumns(self, cVisibleColumns, rgKey) +proc SetSortColumns*(self: ptr ISearchFolderItemFactory, cSortColumns: UINT, rgSortColumns: ptr SORTCOLUMN): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSortColumns(self, cSortColumns, rgSortColumns) +proc SetGroupColumn*(self: ptr ISearchFolderItemFactory, keyGroup: REFPROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetGroupColumn(self, keyGroup) +proc SetStacks*(self: ptr ISearchFolderItemFactory, cStackKeys: UINT, rgStackKeys: ptr PROPERTYKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetStacks(self, cStackKeys, rgStackKeys) +proc SetScope*(self: ptr ISearchFolderItemFactory, psiaScope: ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScope(self, psiaScope) +proc SetCondition*(self: ptr ISearchFolderItemFactory, pCondition: ptr ICondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCondition(self, pCondition) +proc GetShellItem*(self: ptr ISearchFolderItemFactory, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShellItem(self, riid, ppv) +proc GetIDList*(self: ptr ISearchFolderItemFactory, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDList(self, ppidl) +proc GetLocation*(self: ptr IExtractImage, pszPathBuffer: LPWSTR, cch: DWORD, pdwPriority: ptr DWORD, prgSize: ptr SIZE, dwRecClrDepth: DWORD, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLocation(self, pszPathBuffer, cch, pdwPriority, prgSize, dwRecClrDepth, pdwFlags) +proc Extract*(self: ptr IExtractImage, phBmpThumbnail: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Extract(self, phBmpThumbnail) +proc GetDateStamp*(self: ptr IExtractImage2, pDateStamp: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDateStamp(self, pDateStamp) +proc GetThumbnailHandler*(self: ptr IThumbnailHandlerFactory, pidlChild: PCUITEMID_CHILD, pbc: ptr IBindCtx, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetThumbnailHandler(self, pidlChild, pbc, riid, ppv) +proc SetParentAndItem*(self: ptr IParentAndItem, pidlParent: PCIDLIST_ABSOLUTE, psf: ptr IShellFolder, pidlChild: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetParentAndItem(self, pidlParent, psf, pidlChild) +proc GetParentAndItem*(self: ptr IParentAndItem, ppidlParent: ptr PIDLIST_ABSOLUTE, ppsf: ptr ptr IShellFolder, ppidlChild: ptr PITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParentAndItem(self, ppidlParent, ppsf, ppidlChild) +proc ShowDW*(self: ptr IDockingWindow, fShow: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowDW(self, fShow) +proc CloseDW*(self: ptr IDockingWindow, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseDW(self, dwReserved) +proc ResizeBorderDW*(self: ptr IDockingWindow, prcBorder: LPCRECT, punkToolbarSite: ptr IUnknown, fReserved: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResizeBorderDW(self, prcBorder, punkToolbarSite, fReserved) +proc GetBandInfo*(self: ptr IDeskBand, dwBandID: DWORD, dwViewMode: DWORD, pdbi: ptr DESKBANDINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBandInfo(self, dwBandID, dwViewMode, pdbi) +proc GetDefaultBandWidth*(self: ptr IDeskBandInfo, dwBandID: DWORD, dwViewMode: DWORD, pnWidth: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultBandWidth(self, dwBandID, dwViewMode, pnWidth) +proc CanRenderComposited*(self: ptr IDeskBand2, pfCanRenderComposited: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanRenderComposited(self, pfCanRenderComposited) +proc SetCompositionState*(self: ptr IDeskBand2, fCompositionEnabled: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCompositionState(self, fCompositionEnabled) +proc GetCompositionState*(self: ptr IDeskBand2, pfCompositionEnabled: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCompositionState(self, pfCompositionEnabled) +proc HrInit*(self: ptr ITaskbarList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HrInit(self) +proc AddTab*(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTab(self, hwnd) +proc DeleteTab*(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteTab(self, hwnd) +proc ActivateTab*(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateTab(self, hwnd) +proc SetActiveAlt*(self: ptr ITaskbarList, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetActiveAlt(self, hwnd) +proc MarkFullscreenWindow*(self: ptr ITaskbarList2, hwnd: HWND, fFullscreen: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MarkFullscreenWindow(self, hwnd, fFullscreen) +proc SetProgressValue*(self: ptr ITaskbarList3, hwnd: HWND, ullCompleted: ULONGLONG, ullTotal: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgressValue(self, hwnd, ullCompleted, ullTotal) +proc SetProgressState*(self: ptr ITaskbarList3, hwnd: HWND, tbpFlags: TBPFLAG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgressState(self, hwnd, tbpFlags) +proc RegisterTab*(self: ptr ITaskbarList3, hwndTab: HWND, hwndMDI: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterTab(self, hwndTab, hwndMDI) +proc UnregisterTab*(self: ptr ITaskbarList3, hwndTab: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterTab(self, hwndTab) +proc SetTabOrder*(self: ptr ITaskbarList3, hwndTab: HWND, hwndInsertBefore: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTabOrder(self, hwndTab, hwndInsertBefore) +proc SetTabActive*(self: ptr ITaskbarList3, hwndTab: HWND, hwndMDI: HWND, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTabActive(self, hwndTab, hwndMDI, dwReserved) +proc ThumbBarAddButtons*(self: ptr ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThumbBarAddButtons(self, hwnd, cButtons, pButton) +proc ThumbBarUpdateButtons*(self: ptr ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThumbBarUpdateButtons(self, hwnd, cButtons, pButton) +proc ThumbBarSetImageList*(self: ptr ITaskbarList3, hwnd: HWND, himl: HIMAGELIST): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ThumbBarSetImageList(self, hwnd, himl) +proc SetOverlayIcon*(self: ptr ITaskbarList3, hwnd: HWND, hIcon: HICON, pszDescription: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOverlayIcon(self, hwnd, hIcon, pszDescription) +proc SetThumbnailTooltip*(self: ptr ITaskbarList3, hwnd: HWND, pszTip: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThumbnailTooltip(self, hwnd, pszTip) +proc SetThumbnailClip*(self: ptr ITaskbarList3, hwnd: HWND, prcClip: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThumbnailClip(self, hwnd, prcClip) +proc SetTabProperties*(self: ptr ITaskbarList4, hwndTab: HWND, stpFlags: STPFLAG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTabProperties(self, hwndTab, stpFlags) +proc RemoveFromList*(self: ptr IStartMenuPinnedList, pitem: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFromList(self, pitem) +proc GetRecorderDriveLetter*(self: ptr ICDBurn, pszDrive: LPWSTR, cch: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRecorderDriveLetter(self, pszDrive, cch) +proc Burn*(self: ptr ICDBurn, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Burn(self, hwnd) +proc HasRecordableDrive*(self: ptr ICDBurn, pfHasRecorder: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasRecordableDrive(self, pfHasRecorder) +proc GetPreviousPage*(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPreviousPage(self, phpage) +proc GetNextPage*(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextPage(self, phpage) +proc GetCancelledPage*(self: ptr IWizardSite, phpage: ptr HPROPSHEETPAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCancelledPage(self, phpage) +proc AddPages*(self: ptr IWizardExtension, aPages: ptr HPROPSHEETPAGE, cPages: UINT, pnPagesAdded: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPages(self, aPages, cPages, pnPagesAdded) +proc GetFirstPage*(self: ptr IWizardExtension, phpage: ptr HPROPSHEETPAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFirstPage(self, phpage) +proc GetLastPage*(self: ptr IWizardExtension, phpage: ptr HPROPSHEETPAGE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastPage(self, phpage) +proc SetInitialURL*(self: ptr IWebWizardExtension, pszURL: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInitialURL(self, pszURL) +proc SetErrorURL*(self: ptr IWebWizardExtension, pszErrorURL: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetErrorURL(self, pszErrorURL) +proc Initialize*(self: ptr IPublishingWizard, pdo: ptr IDataObject, dwOptions: DWORD, pszServiceScope: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pdo, dwOptions, pszServiceScope) +proc GetTransferManifest*(self: ptr IPublishingWizard, phrFromTransfer: ptr HRESULT, pdocManifest: ptr ptr IXMLDOMDocument): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTransferManifest(self, phrFromTransfer, pdocManifest) +proc Initialize*(self: ptr IFolderViewHost, hwndParent: HWND, pdo: ptr IDataObject, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, hwndParent, pdo, prc) +proc OnNavigationPending*(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnNavigationPending(self, pidlFolder) +proc OnViewCreated*(self: ptr IExplorerBrowserEvents, psv: ptr IShellView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnViewCreated(self, psv) +proc OnNavigationComplete*(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnNavigationComplete(self, pidlFolder) +proc OnNavigationFailed*(self: ptr IExplorerBrowserEvents, pidlFolder: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnNavigationFailed(self, pidlFolder) +proc Initialize*(self: ptr IExplorerBrowser, hwndParent: HWND, prc: ptr RECT, pfs: ptr FOLDERSETTINGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, hwndParent, prc, pfs) +proc Destroy*(self: ptr IExplorerBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Destroy(self) +proc SetRect*(self: ptr IExplorerBrowser, phdwp: ptr HDWP, rcBrowser: RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRect(self, phdwp, rcBrowser) +proc SetPropertyBag*(self: ptr IExplorerBrowser, pszPropertyBag: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPropertyBag(self, pszPropertyBag) +proc SetEmptyText*(self: ptr IExplorerBrowser, pszEmptyText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEmptyText(self, pszEmptyText) +proc SetFolderSettings*(self: ptr IExplorerBrowser, pfs: ptr FOLDERSETTINGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderSettings(self, pfs) +proc Advise*(self: ptr IExplorerBrowser, psbe: ptr IExplorerBrowserEvents, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, psbe, pdwCookie) +proc Unadvise*(self: ptr IExplorerBrowser, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc SetOptions*(self: ptr IExplorerBrowser, dwFlag: EXPLORER_BROWSER_OPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOptions(self, dwFlag) +proc GetOptions*(self: ptr IExplorerBrowser, pdwFlag: ptr EXPLORER_BROWSER_OPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptions(self, pdwFlag) +proc BrowseToIDList*(self: ptr IExplorerBrowser, pidl: PCUIDLIST_RELATIVE, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BrowseToIDList(self, pidl, uFlags) +proc BrowseToObject*(self: ptr IExplorerBrowser, punk: ptr IUnknown, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BrowseToObject(self, punk, uFlags) +proc FillFromObject*(self: ptr IExplorerBrowser, punk: ptr IUnknown, dwFlags: EXPLORER_BROWSER_FILL_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FillFromObject(self, punk, dwFlags) +proc RemoveAll*(self: ptr IExplorerBrowser): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAll(self) +proc GetCurrentView*(self: ptr IExplorerBrowser, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentView(self, riid, ppv) +proc SetAccessibleName*(self: ptr IAccessibleObject, pszName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAccessibleName(self, pszName) +proc AddItem*(self: ptr IResultsFolder, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddItem(self, psi) +proc AddIDList*(self: ptr IResultsFolder, pidl: PCIDLIST_ABSOLUTE, ppidlAdded: ptr PITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddIDList(self, pidl, ppidlAdded) +proc RemoveItem*(self: ptr IResultsFolder, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveItem(self, psi) +proc RemoveIDList*(self: ptr IResultsFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveIDList(self, pidl) +proc RemoveAll*(self: ptr IResultsFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAll(self) +proc Next*(self: ptr IEnumObjects, celt: ULONG, riid: REFIID, rgelt: ptr pointer, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, riid, rgelt, pceltFetched) +proc Skip*(self: ptr IEnumObjects, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumObjects): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumObjects, ppenum: ptr ptr IEnumObjects): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc StartProgressDialog*(self: ptr IOperationsProgressDialog, hwndOwner: HWND, flags: OPPROGDLGF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartProgressDialog(self, hwndOwner, flags) +proc StopProgressDialog*(self: ptr IOperationsProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopProgressDialog(self) +proc SetOperation*(self: ptr IOperationsProgressDialog, action: SPACTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOperation(self, action) +proc SetMode*(self: ptr IOperationsProgressDialog, mode: PDMODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMode(self, mode) +proc UpdateProgress*(self: ptr IOperationsProgressDialog, ullPointsCurrent: ULONGLONG, ullPointsTotal: ULONGLONG, ullSizeCurrent: ULONGLONG, ullSizeTotal: ULONGLONG, ullItemsCurrent: ULONGLONG, ullItemsTotal: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateProgress(self, ullPointsCurrent, ullPointsTotal, ullSizeCurrent, ullSizeTotal, ullItemsCurrent, ullItemsTotal) +proc UpdateLocations*(self: ptr IOperationsProgressDialog, psiSource: ptr IShellItem, psiTarget: ptr IShellItem, psiItem: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateLocations(self, psiSource, psiTarget, psiItem) +proc ResetTimer*(self: ptr IOperationsProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetTimer(self) +proc PauseTimer*(self: ptr IOperationsProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PauseTimer(self) +proc ResumeTimer*(self: ptr IOperationsProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResumeTimer(self) +proc GetMilliseconds*(self: ptr IOperationsProgressDialog, pullElapsed: ptr ULONGLONG, pullRemaining: ptr ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMilliseconds(self, pullElapsed, pullRemaining) +proc GetOperationStatus*(self: ptr IOperationsProgressDialog, popstatus: ptr PDOPSTATUS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOperationStatus(self, popstatus) +proc SetCancelInformation*(self: ptr IIOCancelInformation, dwThreadID: DWORD, uMsgCancel: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCancelInformation(self, dwThreadID, uMsgCancel) +proc GetCancelInformation*(self: ptr IIOCancelInformation, pdwThreadID: ptr DWORD, puMsgCancel: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCancelInformation(self, pdwThreadID, puMsgCancel) +proc Advise*(self: ptr IFileOperation, pfops: ptr IFileOperationProgressSink, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pfops, pdwCookie) +proc Unadvise*(self: ptr IFileOperation, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc SetOperationFlags*(self: ptr IFileOperation, dwOperationFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOperationFlags(self, dwOperationFlags) +proc SetProgressMessage*(self: ptr IFileOperation, pszMessage: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgressMessage(self, pszMessage) +proc SetProgressDialog*(self: ptr IFileOperation, popd: ptr IOperationsProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgressDialog(self, popd) +proc SetProperties*(self: ptr IFileOperation, pproparray: ptr IPropertyChangeArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProperties(self, pproparray) +proc SetOwnerWindow*(self: ptr IFileOperation, hwndOwner: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOwnerWindow(self, hwndOwner) +proc ApplyPropertiesToItem*(self: ptr IFileOperation, psiItem: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyPropertiesToItem(self, psiItem) +proc ApplyPropertiesToItems*(self: ptr IFileOperation, punkItems: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyPropertiesToItems(self, punkItems) +proc RenameItem*(self: ptr IFileOperation, psiItem: ptr IShellItem, pszNewName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RenameItem(self, psiItem, pszNewName, pfopsItem) +proc RenameItems*(self: ptr IFileOperation, pUnkItems: ptr IUnknown, pszNewName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RenameItems(self, pUnkItems, pszNewName) +proc MoveItem*(self: ptr IFileOperation, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszNewName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveItem(self, psiItem, psiDestinationFolder, pszNewName, pfopsItem) +proc MoveItems*(self: ptr IFileOperation, punkItems: ptr IUnknown, psiDestinationFolder: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveItems(self, punkItems, psiDestinationFolder) +proc CopyItem*(self: ptr IFileOperation, psiItem: ptr IShellItem, psiDestinationFolder: ptr IShellItem, pszCopyName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyItem(self, psiItem, psiDestinationFolder, pszCopyName, pfopsItem) +proc CopyItems*(self: ptr IFileOperation, punkItems: ptr IUnknown, psiDestinationFolder: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyItems(self, punkItems, psiDestinationFolder) +proc DeleteItem*(self: ptr IFileOperation, psiItem: ptr IShellItem, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteItem(self, psiItem, pfopsItem) +proc DeleteItems*(self: ptr IFileOperation, punkItems: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteItems(self, punkItems) +proc NewItem*(self: ptr IFileOperation, psiDestinationFolder: ptr IShellItem, dwFileAttributes: DWORD, pszName: LPCWSTR, pszTemplateName: LPCWSTR, pfopsItem: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NewItem(self, psiDestinationFolder, dwFileAttributes, pszName, pszTemplateName, pfopsItem) +proc PerformOperations*(self: ptr IFileOperation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PerformOperations(self) +proc GetAnyOperationsAborted*(self: ptr IFileOperation, pfAnyOperationsAborted: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAnyOperationsAborted(self, pfAnyOperationsAborted) +proc QueryObject*(self: ptr IObjectProvider, guidObject: REFGUID, riid: REFIID, ppvOut: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryObject(self, guidObject, riid, ppvOut) +proc FoundItem*(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FoundItem(self, psf, pidl) +proc EnterFolder*(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnterFolder(self, psf, pidl) +proc LeaveFolder*(self: ptr INamespaceWalkCB, psf: ptr IShellFolder, pidl: PCUITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LeaveFolder(self, psf, pidl) +proc InitializeProgressDialog*(self: ptr INamespaceWalkCB, ppszTitle: ptr LPWSTR, ppszCancel: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeProgressDialog(self, ppszTitle, ppszCancel) +proc WalkComplete*(self: ptr INamespaceWalkCB2, hr: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WalkComplete(self, hr) +proc Walk*(self: ptr INamespaceWalk, punkToWalk: ptr IUnknown, dwFlags: DWORD, cDepth: int32, pnswcb: ptr INamespaceWalkCB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Walk(self, punkToWalk, dwFlags, cDepth, pnswcb) +proc GetIDArrayResult*(self: ptr INamespaceWalk, pcItems: ptr UINT, prgpidl: ptr ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDArrayResult(self, pcItems, prgpidl) +proc GetDropDownStatus*(self: ptr IAutoCompleteDropDown, pdwFlags: ptr DWORD, ppwszString: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDropDownStatus(self, pdwFlags, ppwszString) +proc ResetEnumerator*(self: ptr IAutoCompleteDropDown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResetEnumerator(self) +proc AddBand*(self: ptr IBandSite, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddBand(self, punk) +proc EnumBands*(self: ptr IBandSite, uBand: UINT, pdwBandID: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumBands(self, uBand, pdwBandID) +proc QueryBand*(self: ptr IBandSite, dwBandID: DWORD, ppstb: ptr ptr IDeskBand, pdwState: ptr DWORD, pszName: LPWSTR, cchName: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryBand(self, dwBandID, ppstb, pdwState, pszName, cchName) +proc SetBandState*(self: ptr IBandSite, dwBandID: DWORD, dwMask: DWORD, dwState: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBandState(self, dwBandID, dwMask, dwState) +proc RemoveBand*(self: ptr IBandSite, dwBandID: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveBand(self, dwBandID) +proc GetBandObject*(self: ptr IBandSite, dwBandID: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBandObject(self, dwBandID, riid, ppv) +proc SetBandSiteInfo*(self: ptr IBandSite, pbsinfo: ptr BANDSITEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBandSiteInfo(self, pbsinfo) +proc GetBandSiteInfo*(self: ptr IBandSite, pbsinfo: ptr BANDSITEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBandSiteInfo(self, pbsinfo) +proc Show*(self: ptr IModalWindow, hwndOwner: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, hwndOwner) +proc GetSupportedActionTypes*(self: ptr ICDBurnExt, pdwActions: ptr CDBE_ACTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSupportedActionTypes(self, pdwActions) +proc DoContextMenuPopup*(self: ptr IContextMenuSite, punkContextMenu: ptr IUnknown, fFlags: UINT, pt: POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoContextMenuPopup(self, punkContextMenu, fFlags, pt) +proc EnumReady*(self: ptr IEnumReadyCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumReady(self) +proc SetEnumReadyCallback*(self: ptr IEnumerableView, percb: ptr IEnumReadyCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEnumReadyCallback(self, percb) +proc CreateEnumIDListFromContents*(self: ptr IEnumerableView, pidlFolder: PCIDLIST_ABSOLUTE, dwEnumFlags: DWORD, ppEnumIDList: ptr ptr IEnumIDList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateEnumIDListFromContents(self, pidlFolder, dwEnumFlags, ppEnumIDList) +proc InsertItem*(self: ptr IInsertItem, pidl: PCUIDLIST_RELATIVE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertItem(self, pidl) +proc IsMenuMessage*(self: ptr IMenuBand, pmsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsMenuMessage(self, pmsg) +proc TranslateMenuMessage*(self: ptr IMenuBand, pmsg: ptr MSG, plRet: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateMenuMessage(self, pmsg, plRet) +proc SetCascade*(self: ptr IFolderBandPriv, fCascade: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCascade(self, fCascade) +proc SetAccelerators*(self: ptr IFolderBandPriv, fAccelerators: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAccelerators(self, fAccelerators) +proc SetNoIcons*(self: ptr IFolderBandPriv, fNoIcons: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNoIcons(self, fNoIcons) +proc SetNoText*(self: ptr IFolderBandPriv, fNoText: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNoText(self, fNoText) +proc GetCheckState*(self: ptr IRegTreeItem, pbCheck: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCheckState(self, pbCheck) +proc SetCheckState*(self: ptr IRegTreeItem, bCheck: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCheckState(self, bCheck) +proc RecompressImage*(self: ptr IImageRecompress, psi: ptr IShellItem, cx: int32, cy: int32, iQuality: int32, pstg: ptr IStorage, ppstrmOut: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RecompressImage(self, psi, cx, cy, iQuality, pstg, ppstrmOut) +proc SetClient*(self: ptr IDeskBar, punkClient: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClient(self, punkClient) +proc GetClient*(self: ptr IDeskBar, ppunkClient: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClient(self, ppunkClient) +proc OnPosRectChangeDB*(self: ptr IDeskBar, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPosRectChangeDB(self, prc) +proc Popup*(self: ptr IMenuPopup, ppt: ptr POINTL, prcExclude: ptr RECTL, dwFlags: MP_POPUPFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Popup(self, ppt, prcExclude, dwFlags) +proc OnSelect*(self: ptr IMenuPopup, dwSelectType: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSelect(self, dwSelectType) +proc SetSubMenu*(self: ptr IMenuPopup, pmp: ptr IMenuPopup, fSet: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSubMenu(self, pmp, fSet) +proc GetAppName*(self: ptr IFileIsInUse, ppszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAppName(self, ppszName) +proc GetUsage*(self: ptr IFileIsInUse, pfut: ptr FILE_USAGE_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUsage(self, pfut) +proc GetCapabilities*(self: ptr IFileIsInUse, pdwCapFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCapabilities(self, pdwCapFlags) +proc GetSwitchToHWND*(self: ptr IFileIsInUse, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSwitchToHWND(self, phwnd) +proc CloseFile*(self: ptr IFileIsInUse): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CloseFile(self) +proc OnFileOk*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFileOk(self, pfd) +proc OnFolderChanging*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psiFolder: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFolderChanging(self, pfd, psiFolder) +proc OnFolderChange*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnFolderChange(self, pfd) +proc OnSelectionChange*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSelectionChange(self, pfd) +proc OnShareViolation*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psi: ptr IShellItem, pResponse: ptr FDE_SHAREVIOLATION_RESPONSE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnShareViolation(self, pfd, psi, pResponse) +proc OnTypeChange*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnTypeChange(self, pfd) +proc OnOverwrite*(self: ptr IFileDialogEvents, pfd: ptr IFileDialog, psi: ptr IShellItem, pResponse: ptr FDE_OVERWRITE_RESPONSE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnOverwrite(self, pfd, psi, pResponse) +proc SetFileTypes*(self: ptr IFileDialog, cFileTypes: UINT, rgFilterSpec: ptr COMDLG_FILTERSPEC): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileTypes(self, cFileTypes, rgFilterSpec) +proc SetFileTypeIndex*(self: ptr IFileDialog, iFileType: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileTypeIndex(self, iFileType) +proc GetFileTypeIndex*(self: ptr IFileDialog, piFileType: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileTypeIndex(self, piFileType) +proc Advise*(self: ptr IFileDialog, pfde: ptr IFileDialogEvents, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pfde, pdwCookie) +proc Unadvise*(self: ptr IFileDialog, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc SetOptions*(self: ptr IFileDialog, fos: FILEOPENDIALOGOPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOptions(self, fos) +proc GetOptions*(self: ptr IFileDialog, pfos: ptr FILEOPENDIALOGOPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptions(self, pfos) +proc SetDefaultFolder*(self: ptr IFileDialog, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultFolder(self, psi) +proc SetFolder*(self: ptr IFileDialog, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolder(self, psi) +proc GetFolder*(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolder(self, ppsi) +proc GetCurrentSelection*(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSelection(self, ppsi) +proc SetFileName*(self: ptr IFileDialog, pszName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileName(self, pszName) +proc GetFileName*(self: ptr IFileDialog, pszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileName(self, pszName) +proc SetTitle*(self: ptr IFileDialog, pszTitle: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTitle(self, pszTitle) +proc SetOkButtonLabel*(self: ptr IFileDialog, pszText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOkButtonLabel(self, pszText) +proc SetFileNameLabel*(self: ptr IFileDialog, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileNameLabel(self, pszLabel) +proc GetResult*(self: ptr IFileDialog, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetResult(self, ppsi) +proc AddPlace*(self: ptr IFileDialog, psi: ptr IShellItem, fdap: FDAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPlace(self, psi, fdap) +proc SetDefaultExtension*(self: ptr IFileDialog, pszDefaultExtension: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultExtension(self, pszDefaultExtension) +proc Close*(self: ptr IFileDialog, hr: HRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self, hr) +proc SetClientGuid*(self: ptr IFileDialog, guid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClientGuid(self, guid) +proc ClearClientData*(self: ptr IFileDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearClientData(self) +proc SetFilter*(self: ptr IFileDialog, pFilter: ptr IShellItemFilter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFilter(self, pFilter) +proc SetSaveAsItem*(self: ptr IFileSaveDialog, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSaveAsItem(self, psi) +proc SetProperties*(self: ptr IFileSaveDialog, pStore: ptr IPropertyStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProperties(self, pStore) +proc SetCollectedProperties*(self: ptr IFileSaveDialog, pList: ptr IPropertyDescriptionList, fAppendDefault: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCollectedProperties(self, pList, fAppendDefault) +proc GetProperties*(self: ptr IFileSaveDialog, ppStore: ptr ptr IPropertyStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperties(self, ppStore) +proc ApplyProperties*(self: ptr IFileSaveDialog, psi: ptr IShellItem, pStore: ptr IPropertyStore, hwnd: HWND, pSink: ptr IFileOperationProgressSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyProperties(self, psi, pStore, hwnd, pSink) +proc GetResults*(self: ptr IFileOpenDialog, ppenum: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetResults(self, ppenum) +proc GetSelectedItems*(self: ptr IFileOpenDialog, ppsai: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedItems(self, ppsai) +proc EnableOpenDropDown*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableOpenDropDown(self, dwIDCtl) +proc AddMenu*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddMenu(self, dwIDCtl, pszLabel) +proc AddPushButton*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPushButton(self, dwIDCtl, pszLabel) +proc AddComboBox*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddComboBox(self, dwIDCtl) +proc AddRadioButtonList*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddRadioButtonList(self, dwIDCtl) +proc AddCheckButton*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR, bChecked: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddCheckButton(self, dwIDCtl, pszLabel, bChecked) +proc AddEditBox*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddEditBox(self, dwIDCtl, pszText) +proc AddSeparator*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddSeparator(self, dwIDCtl) +proc AddText*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddText(self, dwIDCtl, pszText) +proc SetControlLabel*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlLabel(self, dwIDCtl, pszLabel) +proc GetControlState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pdwState: ptr CDCONTROLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlState(self, dwIDCtl, pdwState) +proc SetControlState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwState: CDCONTROLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlState(self, dwIDCtl, dwState) +proc GetEditBoxText*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, ppszText: ptr ptr WCHAR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEditBoxText(self, dwIDCtl, ppszText) +proc SetEditBoxText*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszText: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetEditBoxText(self, dwIDCtl, pszText) +proc GetCheckButtonState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pbChecked: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCheckButtonState(self, dwIDCtl, pbChecked) +proc SetCheckButtonState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, bChecked: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCheckButtonState(self, dwIDCtl, bChecked) +proc AddControlItem*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddControlItem(self, dwIDCtl, dwIDItem, pszLabel) +proc RemoveControlItem*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveControlItem(self, dwIDCtl, dwIDItem) +proc RemoveAllControlItems*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAllControlItems(self, dwIDCtl) +proc GetControlItemState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pdwState: ptr CDCONTROLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlItemState(self, dwIDCtl, dwIDItem, pdwState) +proc SetControlItemState*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, dwState: CDCONTROLSTATEF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlItemState(self, dwIDCtl, dwIDItem, dwState) +proc GetSelectedControlItem*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pdwIDItem: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedControlItem(self, dwIDCtl, pdwIDItem) +proc SetSelectedControlItem*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSelectedControlItem(self, dwIDCtl, dwIDItem) +proc StartVisualGroup*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartVisualGroup(self, dwIDCtl, pszLabel) +proc EndVisualGroup*(self: ptr IFileDialogCustomize): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndVisualGroup(self) +proc MakeProminent*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MakeProminent(self, dwIDCtl) +proc SetControlItemText*(self: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlItemText(self, dwIDCtl, dwIDItem, pszLabel) +proc OnItemSelected*(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD, dwIDItem: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemSelected(self, pfdc, dwIDCtl, dwIDItem) +proc OnButtonClicked*(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnButtonClicked(self, pfdc, dwIDCtl) +proc OnCheckButtonToggled*(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD, bChecked: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnCheckButtonToggled(self, pfdc, dwIDCtl, bChecked) +proc OnControlActivating*(self: ptr IFileDialogControlEvents, pfdc: ptr IFileDialogCustomize, dwIDCtl: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnControlActivating(self, pfdc, dwIDCtl) +proc SetCancelButtonLabel*(self: ptr IFileDialog2, pszLabel: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCancelButtonLabel(self, pszLabel) +proc SetNavigationRoot*(self: ptr IFileDialog2, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNavigationRoot(self, psi) +proc QueryCurrentDefault*(self: ptr IApplicationAssociationRegistration, pszQuery: LPCWSTR, atQueryType: ASSOCIATIONTYPE, alQueryLevel: ASSOCIATIONLEVEL, ppszAssociation: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCurrentDefault(self, pszQuery, atQueryType, alQueryLevel, ppszAssociation) +proc QueryAppIsDefault*(self: ptr IApplicationAssociationRegistration, pszQuery: LPCWSTR, atQueryType: ASSOCIATIONTYPE, alQueryLevel: ASSOCIATIONLEVEL, pszAppRegistryName: LPCWSTR, pfDefault: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryAppIsDefault(self, pszQuery, atQueryType, alQueryLevel, pszAppRegistryName, pfDefault) +proc QueryAppIsDefaultAll*(self: ptr IApplicationAssociationRegistration, alQueryLevel: ASSOCIATIONLEVEL, pszAppRegistryName: LPCWSTR, pfDefault: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryAppIsDefaultAll(self, alQueryLevel, pszAppRegistryName, pfDefault) +proc SetAppAsDefault*(self: ptr IApplicationAssociationRegistration, pszAppRegistryName: LPCWSTR, pszSet: LPCWSTR, atSetType: ASSOCIATIONTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppAsDefault(self, pszAppRegistryName, pszSet, atSetType) +proc SetAppAsDefaultAll*(self: ptr IApplicationAssociationRegistration, pszAppRegistryName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppAsDefaultAll(self, pszAppRegistryName) +proc ClearUserAssociations*(self: ptr IApplicationAssociationRegistration): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearUserAssociations(self) +proc LaunchAdvancedAssociationUI*(self: ptr IApplicationAssociationRegistrationUI, pszAppRegistryName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LaunchAdvancedAssociationUI(self, pszAppRegistryName) +proc SetItemAlloc*(self: ptr IDelegateFolder, pmalloc: ptr IMalloc): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItemAlloc(self, pmalloc) +proc GetFrameOptions*(self: ptr IBrowserFrameOptions, dwMask: BROWSERFRAMEOPTIONS, pdwOptions: ptr BROWSERFRAMEOPTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFrameOptions(self, dwMask, pdwOptions) +proc EvaluateNewWindow*(self: ptr INewWindowManager, pszUrl: LPCWSTR, pszName: LPCWSTR, pszUrlContext: LPCWSTR, pszFeatures: LPCWSTR, fReplace: WINBOOL, dwFlags: DWORD, dwUserActionTime: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EvaluateNewWindow(self, pszUrl, pszName, pszUrlContext, pszFeatures, fReplace, dwFlags, dwUserActionTime) +proc SetClientTitle*(self: ptr IAttachmentExecute, pszTitle: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClientTitle(self, pszTitle) +proc SetClientGuid*(self: ptr IAttachmentExecute, guid: REFGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClientGuid(self, guid) +proc SetLocalPath*(self: ptr IAttachmentExecute, pszLocalPath: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLocalPath(self, pszLocalPath) +proc SetFileName*(self: ptr IAttachmentExecute, pszFileName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileName(self, pszFileName) +proc SetSource*(self: ptr IAttachmentExecute, pszSource: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSource(self, pszSource) +proc SetReferrer*(self: ptr IAttachmentExecute, pszReferrer: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetReferrer(self, pszReferrer) +proc CheckPolicy*(self: ptr IAttachmentExecute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CheckPolicy(self) +proc Prompt*(self: ptr IAttachmentExecute, hwnd: HWND, prompt: ATTACHMENT_PROMPT, paction: ptr ATTACHMENT_ACTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Prompt(self, hwnd, prompt, paction) +proc Save*(self: ptr IAttachmentExecute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self) +proc Execute*(self: ptr IAttachmentExecute, hwnd: HWND, pszVerb: LPCWSTR, phProcess: ptr HANDLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Execute(self, hwnd, pszVerb, phProcess) +proc SaveWithUI*(self: ptr IAttachmentExecute, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveWithUI(self, hwnd) +proc ClearClientState*(self: ptr IAttachmentExecute): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearClientState(self) +proc CallbackSM*(self: ptr IShellMenuCallback, psmd: LPSMDATA, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CallbackSM(self, psmd, uMsg, wParam, lParam) +proc Initialize*(self: ptr IShellMenu, psmc: ptr IShellMenuCallback, uId: UINT, uIdAncestor: UINT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, psmc, uId, uIdAncestor, dwFlags) +proc GetMenuInfo*(self: ptr IShellMenu, ppsmc: ptr ptr IShellMenuCallback, puId: ptr UINT, puIdAncestor: ptr UINT, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMenuInfo(self, ppsmc, puId, puIdAncestor, pdwFlags) +proc SetShellFolder*(self: ptr IShellMenu, psf: ptr IShellFolder, pidlFolder: PCIDLIST_ABSOLUTE, hKey: HKEY, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShellFolder(self, psf, pidlFolder, hKey, dwFlags) +proc GetShellFolder*(self: ptr IShellMenu, pdwFlags: ptr DWORD, ppidl: ptr PIDLIST_ABSOLUTE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShellFolder(self, pdwFlags, ppidl, riid, ppv) +proc SetMenu*(self: ptr IShellMenu, hmenu: HMENU, hwnd: HWND, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMenu(self, hmenu, hwnd, dwFlags) +proc GetMenu*(self: ptr IShellMenu, phmenu: ptr HMENU, phwnd: ptr HWND, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMenu(self, phmenu, phwnd, pdwFlags) +proc InvalidateItem*(self: ptr IShellMenu, psmd: LPSMDATA, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InvalidateItem(self, psmd, dwFlags) +proc GetState*(self: ptr IShellMenu, psmd: LPSMDATA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, psmd) +proc SetMenuToolbar*(self: ptr IShellMenu, punk: ptr IUnknown, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMenuToolbar(self, punk, dwFlags) +proc Run*(self: ptr IShellRunDll, pszArgs: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Run(self, pszArgs) +proc GetId*(self: ptr IKnownFolder, pkfid: ptr KNOWNFOLDERID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetId(self, pkfid) +proc GetCategory*(self: ptr IKnownFolder, pCategory: ptr KF_CATEGORY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCategory(self, pCategory) +proc GetShellItem*(self: ptr IKnownFolder, dwFlags: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShellItem(self, dwFlags, riid, ppv) +proc GetPath*(self: ptr IKnownFolder, dwFlags: DWORD, ppszPath: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, dwFlags, ppszPath) +proc SetPath*(self: ptr IKnownFolder, dwFlags: DWORD, pszPath: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPath(self, dwFlags, pszPath) +proc GetIDList*(self: ptr IKnownFolder, dwFlags: DWORD, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIDList(self, dwFlags, ppidl) +proc GetFolderType*(self: ptr IKnownFolder, pftid: ptr FOLDERTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderType(self, pftid) +proc GetRedirectionCapabilities*(self: ptr IKnownFolder, pCapabilities: ptr KF_REDIRECTION_CAPABILITIES): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRedirectionCapabilities(self, pCapabilities) +proc GetFolderDefinition*(self: ptr IKnownFolder, pKFD: ptr KNOWNFOLDER_DEFINITION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderDefinition(self, pKFD) +proc FolderIdFromCsidl*(self: ptr IKnownFolderManager, nCsidl: int32, pfid: ptr KNOWNFOLDERID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FolderIdFromCsidl(self, nCsidl, pfid) +proc FolderIdToCsidl*(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, pnCsidl: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FolderIdToCsidl(self, rfid, pnCsidl) +proc GetFolderIds*(self: ptr IKnownFolderManager, ppKFId: ptr ptr KNOWNFOLDERID, pCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderIds(self, ppKFId, pCount) +proc GetFolder*(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, ppkf: ptr ptr IKnownFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolder(self, rfid, ppkf) +proc GetFolderByName*(self: ptr IKnownFolderManager, pszCanonicalName: LPCWSTR, ppkf: ptr ptr IKnownFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderByName(self, pszCanonicalName, ppkf) +proc RegisterFolder*(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, pKFD: ptr KNOWNFOLDER_DEFINITION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterFolder(self, rfid, pKFD) +proc UnregisterFolder*(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterFolder(self, rfid) +proc FindFolderFromPath*(self: ptr IKnownFolderManager, pszPath: LPCWSTR, mode: FFFP_MODE, ppkf: ptr ptr IKnownFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFolderFromPath(self, pszPath, mode, ppkf) +proc FindFolderFromIDList*(self: ptr IKnownFolderManager, pidl: PCIDLIST_ABSOLUTE, ppkf: ptr ptr IKnownFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFolderFromIDList(self, pidl, ppkf) +proc Redirect*(self: ptr IKnownFolderManager, rfid: REFKNOWNFOLDERID, hwnd: HWND, flags: KF_REDIRECT_FLAGS, pszTargetPath: LPCWSTR, cFolders: UINT, pExclusion: ptr KNOWNFOLDERID, ppszError: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Redirect(self, rfid, hwnd, flags, pszTargetPath, cFolders, pExclusion, ppszError) +proc CreateShare*(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID, role: SHARE_ROLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateShare(self, dsid, role) +proc DeleteShare*(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteShare(self, dsid) +proc ShareExists*(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShareExists(self, dsid) +proc GetSharePermissions*(self: ptr ISharingConfigurationManager, dsid: DEF_SHARE_ID, pRole: ptr SHARE_ROLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSharePermissions(self, dsid, pRole) +proc SharePrinters*(self: ptr ISharingConfigurationManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SharePrinters(self) +proc StopSharingPrinters*(self: ptr ISharingConfigurationManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopSharingPrinters(self) +proc ArePrintersShared*(self: ptr ISharingConfigurationManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ArePrintersShared(self) +proc AreSnapshotsAvailable*(self: ptr IPreviousVersionsInfo, pszPath: LPCWSTR, fOkToBeSlow: WINBOOL, pfAvailable: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AreSnapshotsAvailable(self, pszPath, fOkToBeSlow, pfAvailable) +proc GetItemIDList*(self: ptr IRelatedItem, ppidl: ptr PIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemIDList(self, ppidl) +proc GetItem*(self: ptr IRelatedItem, ppsi: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItem(self, ppsi) +proc GetDestinationStream*(self: ptr IDestinationStreamFactory, ppstm: ptr ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDestinationStream(self, ppstm) +proc IncludeItems*(self: ptr INewMenuClient, pflags: ptr NMCII_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IncludeItems(self, pflags) +proc SelectAndEditItem*(self: ptr INewMenuClient, pidlItem: PCIDLIST_ABSOLUTE, flags: NMCSAEI_FLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SelectAndEditItem(self, pidlItem, flags) +proc Initialize*(self: ptr IInitializeWithBindCtx, pbc: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pbc) +proc IncludeItem*(self: ptr IShellItemFilter, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IncludeItem(self, psi) +proc GetEnumFlagsForItem*(self: ptr IShellItemFilter, psi: ptr IShellItem, pgrfFlags: ptr SHCONTF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumFlagsForItem(self, psi, pgrfFlags) +proc Initialize*(self: ptr INameSpaceTreeControl, hwndParent: HWND, prc: ptr RECT, nsctsFlags: NSTCSTYLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, hwndParent, prc, nsctsFlags) +proc TreeAdvise*(self: ptr INameSpaceTreeControl, punk: ptr IUnknown, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TreeAdvise(self, punk, pdwCookie) +proc TreeUnadvise*(self: ptr INameSpaceTreeControl, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TreeUnadvise(self, dwCookie) +proc AppendRoot*(self: ptr INameSpaceTreeControl, psiRoot: ptr IShellItem, grfEnumFlags: SHCONTF, grfRootStyle: NSTCROOTSTYLE, pif: ptr IShellItemFilter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppendRoot(self, psiRoot, grfEnumFlags, grfRootStyle, pif) +proc InsertRoot*(self: ptr INameSpaceTreeControl, iIndex: int32, psiRoot: ptr IShellItem, grfEnumFlags: SHCONTF, grfRootStyle: NSTCROOTSTYLE, pif: ptr IShellItemFilter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertRoot(self, iIndex, psiRoot, grfEnumFlags, grfRootStyle, pif) +proc RemoveRoot*(self: ptr INameSpaceTreeControl, psiRoot: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveRoot(self, psiRoot) +proc RemoveAllRoots*(self: ptr INameSpaceTreeControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAllRoots(self) +proc GetRootItems*(self: ptr INameSpaceTreeControl, ppsiaRootItems: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRootItems(self, ppsiaRootItems) +proc SetItemState*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisFlags: NSTCITEMSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItemState(self, psi, nstcisMask, nstcisFlags) +proc GetItemState*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, pnstcisFlags: ptr NSTCITEMSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemState(self, psi, nstcisMask, pnstcisFlags) +proc GetSelectedItems*(self: ptr INameSpaceTreeControl, psiaItems: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedItems(self, psiaItems) +proc GetItemCustomState*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, piStateNumber: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemCustomState(self, psi, piStateNumber) +proc SetItemCustomState*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, iStateNumber: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItemCustomState(self, psi, iStateNumber) +proc EnsureItemVisible*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnsureItemVisible(self, psi) +proc SetTheme*(self: ptr INameSpaceTreeControl, pszTheme: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTheme(self, pszTheme) +proc GetNextItem*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, nstcgi: NSTCGNI, ppsiNext: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextItem(self, psi, nstcgi, ppsiNext) +proc HitTest*(self: ptr INameSpaceTreeControl, ppt: ptr POINT, ppsiOut: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HitTest(self, ppt, ppsiOut) +proc GetItemRect*(self: ptr INameSpaceTreeControl, psi: ptr IShellItem, prect: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemRect(self, psi, prect) +proc CollapseAll*(self: ptr INameSpaceTreeControl): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CollapseAll(self) +proc SetControlStyle*(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE, nstcsStyle: NSTCSTYLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlStyle(self, nstcsMask, nstcsStyle) +proc GetControlStyle*(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE, pnstcsStyle: ptr NSTCSTYLE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlStyle(self, nstcsMask, pnstcsStyle) +proc SetControlStyle2*(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE2, nstcsStyle: NSTCSTYLE2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetControlStyle2(self, nstcsMask, nstcsStyle) +proc GetControlStyle2*(self: ptr INameSpaceTreeControl2, nstcsMask: NSTCSTYLE2, pnstcsStyle: ptr NSTCSTYLE2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetControlStyle2(self, nstcsMask, pnstcsStyle) +proc OnItemClick*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstceHitTest: NSTCEHITTEST, nstceClickType: NSTCECLICKTYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemClick(self, psi, nstceHitTest, nstceClickType) +proc OnPropertyItemCommit*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPropertyItemCommit(self, psi) +proc OnItemStateChanging*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisState: NSTCITEMSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemStateChanging(self, psi, nstcisMask, nstcisState) +proc OnItemStateChanged*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, nstcisMask: NSTCITEMSTATE, nstcisState: NSTCITEMSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemStateChanged(self, psi, nstcisMask, nstcisState) +proc OnSelectionChanged*(self: ptr INameSpaceTreeControlEvents, psiaSelection: ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSelectionChanged(self, psiaSelection) +proc OnKeyboardInput*(self: ptr INameSpaceTreeControlEvents, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnKeyboardInput(self, uMsg, wParam, lParam) +proc OnBeforeExpand*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBeforeExpand(self, psi) +proc OnAfterExpand*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnAfterExpand(self, psi) +proc OnBeginLabelEdit*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBeginLabelEdit(self, psi) +proc OnEndLabelEdit*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnEndLabelEdit(self, psi) +proc OnGetToolTip*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, pszTip: LPWSTR, cchTip: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnGetToolTip(self, psi, pszTip, cchTip) +proc OnBeforeItemDelete*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBeforeItemDelete(self, psi) +proc OnItemAdded*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, fIsRoot: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemAdded(self, psi, fIsRoot) +proc OnItemDeleted*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, fIsRoot: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnItemDeleted(self, psi, fIsRoot) +proc OnBeforeContextMenu*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBeforeContextMenu(self, psi, riid, ppv) +proc OnAfterContextMenu*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, pcmIn: ptr IContextMenu, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnAfterContextMenu(self, psi, pcmIn, riid, ppv) +proc OnBeforeStateImageChange*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnBeforeStateImageChange(self, psi) +proc OnGetDefaultIconIndex*(self: ptr INameSpaceTreeControlEvents, psi: ptr IShellItem, piDefaultIcon: ptr int32, piOpenIcon: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnGetDefaultIconIndex(self, psi, piDefaultIcon, piOpenIcon) +proc OnDragEnter*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, fOutsideSource: WINBOOL, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDragEnter(self, psiOver, psiaData, fOutsideSource, grfKeyState, pdwEffect) +proc OnDragOver*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDragOver(self, psiOver, psiaData, grfKeyState, pdwEffect) +proc OnDragPosition*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iNewPosition: int32, iOldPosition: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDragPosition(self, psiOver, psiaData, iNewPosition, iOldPosition) +proc OnDrop*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iPosition: int32, grfKeyState: DWORD, pdwEffect: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDrop(self, psiOver, psiaData, iPosition, grfKeyState, pdwEffect) +proc OnDropPosition*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem, psiaData: ptr IShellItemArray, iNewPosition: int32, iOldPosition: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDropPosition(self, psiOver, psiaData, iNewPosition, iOldPosition) +proc OnDragLeave*(self: ptr INameSpaceTreeControlDropHandler, psiOver: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDragLeave(self, psiOver) +proc OnGetDefaultAccessibilityAction*(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem, pbstrDefaultAction: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnGetDefaultAccessibilityAction(self, psi, pbstrDefaultAction) +proc OnDoDefaultAccessibilityAction*(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnDoDefaultAccessibilityAction(self, psi) +proc OnGetAccessibilityRole*(self: ptr INameSpaceTreeAccessible, psi: ptr IShellItem, pvarRole: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnGetAccessibilityRole(self, psi, pvarRole) +proc PrePaint*(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, plres: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PrePaint(self, hdc, prc, plres) +proc PostPaint*(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PostPaint(self, hdc, prc) +proc ItemPrePaint*(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, pnstccdItem: ptr NSTCCUSTOMDRAW, pclrText: ptr COLORREF, pclrTextBk: ptr COLORREF, plres: ptr LRESULT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ItemPrePaint(self, hdc, prc, pnstccdItem, pclrText, pclrTextBk, plres) +proc ItemPostPaint*(self: ptr INameSpaceTreeControlCustomDraw, hdc: HDC, prc: ptr RECT, pnstccdItem: ptr NSTCCUSTOMDRAW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ItemPostPaint(self, hdc, prc, pnstccdItem) +proc GetFolderCapabilities*(self: ptr INameSpaceTreeControlFolderCapabilities, nfcMask: NSTCFOLDERCAPABILITIES, pnfcValue: ptr NSTCFOLDERCAPABILITIES): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderCapabilities(self, nfcMask, pnfcValue) +proc SetWindow*(self: ptr IPreviewHandler, hwnd: HWND, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWindow(self, hwnd, prc) +proc SetRect*(self: ptr IPreviewHandler, prc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRect(self, prc) +proc DoPreview*(self: ptr IPreviewHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoPreview(self) +proc Unload*(self: ptr IPreviewHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unload(self) +proc SetFocus*(self: ptr IPreviewHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFocus(self) +proc QueryFocus*(self: ptr IPreviewHandler, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryFocus(self, phwnd) +proc TranslateAccelerator*(self: ptr IPreviewHandler, pmsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pmsg) +proc GetWindowContext*(self: ptr IPreviewHandlerFrame, pinfo: ptr PREVIEWHANDLERFRAMEINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindowContext(self, pinfo) +proc TranslateAccelerator*(self: ptr IPreviewHandlerFrame, pmsg: ptr MSG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateAccelerator(self, pmsg) +proc ShowDeskBand*(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowDeskBand(self, clsid) +proc HideDeskBand*(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HideDeskBand(self, clsid) +proc IsDeskBandShown*(self: ptr ITrayDeskBand, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDeskBandShown(self, clsid) +proc DeskBandRegistrationChanged*(self: ptr ITrayDeskBand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeskBandRegistrationChanged(self) +proc CreateBand*(self: ptr IBandHost, rclsidBand: REFCLSID, fAvailable: WINBOOL, fVisible: WINBOOL, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBand(self, rclsidBand, fAvailable, fVisible, riid, ppv) +proc SetBandAvailability*(self: ptr IBandHost, rclsidBand: REFCLSID, fAvailable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBandAvailability(self, rclsidBand, fAvailable) +proc DestroyBand*(self: ptr IBandHost, rclsidBand: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DestroyBand(self, rclsidBand) +proc GetPaneState*(self: ptr IExplorerPaneVisibility, ep: REFEXPLORERPANE, peps: ptr EXPLORERPANESTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPaneState(self, ep, peps) +proc CallBack*(self: ptr IContextMenuCB, psf: ptr IShellFolder, hwndOwner: HWND, pdtobj: ptr IDataObject, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CallBack(self, psf, hwndOwner, pdtobj, uMsg, wParam, lParam) +proc SetFlags*(self: ptr IDefaultExtractIconInit, uFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFlags(self, uFlags) +proc SetKey*(self: ptr IDefaultExtractIconInit, hkey: HKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetKey(self, hkey) +proc SetNormalIcon*(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNormalIcon(self, pszFile, iIcon) +proc SetOpenIcon*(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOpenIcon(self, pszFile, iIcon) +proc SetShortcutIcon*(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetShortcutIcon(self, pszFile, iIcon) +proc SetDefaultIcon*(self: ptr IDefaultExtractIconInit, pszFile: LPCWSTR, iIcon: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultIcon(self, pszFile, iIcon) +proc GetTitle*(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszName: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTitle(self, psiItemArray, ppszName) +proc GetIcon*(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszIcon: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIcon(self, psiItemArray, ppszIcon) +proc GetToolTip*(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, ppszInfotip: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetToolTip(self, psiItemArray, ppszInfotip) +proc GetCanonicalName*(self: ptr IExplorerCommand, pguidCommandName: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCanonicalName(self, pguidCommandName) +proc GetState*(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, fOkToBeSlow: WINBOOL, pCmdState: ptr EXPCMDSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, psiItemArray, fOkToBeSlow, pCmdState) +proc Invoke*(self: ptr IExplorerCommand, psiItemArray: ptr IShellItemArray, pbc: ptr IBindCtx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, psiItemArray, pbc) +proc GetFlags*(self: ptr IExplorerCommand, pFlags: ptr EXPCMDFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFlags(self, pFlags) +proc EnumSubCommands*(self: ptr IExplorerCommand, ppEnum: ptr ptr IEnumExplorerCommand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumSubCommands(self, ppEnum) +proc GetState*(self: ptr IExplorerCommandState, psiItemArray: ptr IShellItemArray, fOkToBeSlow: WINBOOL, pCmdState: ptr EXPCMDSTATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetState(self, psiItemArray, fOkToBeSlow, pCmdState) +proc Initialize*(self: ptr IInitializeCommand, pszCommandName: LPCWSTR, ppb: ptr IPropertyBag): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pszCommandName, ppb) +proc Next*(self: ptr IEnumExplorerCommand, celt: ULONG, pUICommand: ptr ptr IExplorerCommand, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, pUICommand, pceltFetched) +proc Skip*(self: ptr IEnumExplorerCommand, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IEnumExplorerCommand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IEnumExplorerCommand, ppenum: ptr ptr IEnumExplorerCommand): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppenum) +proc GetCommands*(self: ptr IExplorerCommandProvider, punkSite: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCommands(self, punkSite, riid, ppv) +proc GetCommand*(self: ptr IExplorerCommandProvider, rguidCommandId: REFGUID, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCommand(self, rguidCommandId, riid, ppv) +proc Initialize*(self: ptr IInitializeNetworkFolder, pidl: PCIDLIST_ABSOLUTE, pidlTarget: PCIDLIST_ABSOLUTE, uDisplayType: UINT, pszResName: LPCWSTR, pszProvider: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pidl, pidlTarget, uDisplayType, pszResName, pszProvider) +proc Open*(self: ptr IOpenControlPanel, pszName: LPCWSTR, pszPage: LPCWSTR, punkSite: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, pszName, pszPage, punkSite) +proc GetPath*(self: ptr IOpenControlPanel, pszName: LPCWSTR, pszPath: LPWSTR, cchPath: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPath(self, pszName, pszPath, cchPath) +proc GetCurrentView*(self: ptr IOpenControlPanel, pView: ptr CPVIEW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentView(self, pView) +proc ComputerInfoChanged*(self: ptr IComputerInfoChangeNotify): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComputerInfoChanged(self) +proc SetFindData*(self: ptr IFileSystemBindData, pfd: ptr WIN32_FIND_DATAW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFindData(self, pfd) +proc GetFindData*(self: ptr IFileSystemBindData, pfd: ptr WIN32_FIND_DATAW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFindData(self, pfd) +proc SetFileID*(self: ptr IFileSystemBindData2, liFileID: LARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFileID(self, liFileID) +proc GetFileID*(self: ptr IFileSystemBindData2, pliFileID: ptr LARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileID(self, pliFileID) +proc SetJunctionCLSID*(self: ptr IFileSystemBindData2, clsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetJunctionCLSID(self, clsid) +proc GetJunctionCLSID*(self: ptr IFileSystemBindData2, pclsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetJunctionCLSID(self, pclsid) +proc SetAppID*(self: ptr ICustomDestinationList, pszAppID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppID(self, pszAppID) +proc BeginList*(self: ptr ICustomDestinationList, pcMinSlots: ptr UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeginList(self, pcMinSlots, riid, ppv) +proc AppendCategory*(self: ptr ICustomDestinationList, pszCategory: LPCWSTR, poa: ptr IObjectArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppendCategory(self, pszCategory, poa) +proc AppendKnownCategory*(self: ptr ICustomDestinationList, category: KNOWNDESTCATEGORY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppendKnownCategory(self, category) +proc AddUserTasks*(self: ptr ICustomDestinationList, poa: ptr IObjectArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddUserTasks(self, poa) +proc CommitList*(self: ptr ICustomDestinationList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CommitList(self) +proc GetRemovedDestinations*(self: ptr ICustomDestinationList, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRemovedDestinations(self, riid, ppv) +proc DeleteList*(self: ptr ICustomDestinationList, pszAppID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteList(self, pszAppID) +proc AbortList*(self: ptr ICustomDestinationList): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AbortList(self) +proc SetAppID*(self: ptr IApplicationDestinations, pszAppID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppID(self, pszAppID) +proc RemoveDestination*(self: ptr IApplicationDestinations, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveDestination(self, punk) +proc RemoveAllDestinations*(self: ptr IApplicationDestinations): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAllDestinations(self) +proc SetAppID*(self: ptr IApplicationDocumentLists, pszAppID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppID(self, pszAppID) +proc GetList*(self: ptr IApplicationDocumentLists, listtype: APPDOCLISTTYPE, cItemsDesired: UINT, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetList(self, listtype, cItemsDesired, riid, ppv) +proc SetAppID*(self: ptr IObjectWithAppUserModelID, pszAppID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAppID(self, pszAppID) +proc GetAppID*(self: ptr IObjectWithAppUserModelID, ppszAppID: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAppID(self, ppszAppID) +proc SetProgID*(self: ptr IObjectWithProgID, pszProgID: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgID(self, pszProgID) +proc GetProgID*(self: ptr IObjectWithProgID, ppszProgID: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProgID(self, ppszProgID) +proc Update*(self: ptr IUpdateIDList, pbc: ptr IBindCtx, pidlIn: PCUITEMID_CHILD, ppidlOut: ptr PITEMID_CHILD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Update(self, pbc, pidlIn, ppidlOut) +proc RunGadget*(self: ptr IDesktopGadget, gadgetPath: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RunGadget(self, gadgetPath) +proc SetWallpaper*(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, wallpaper: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWallpaper(self, monitorID, wallpaper) +proc GetWallpaper*(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, wallpaper: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWallpaper(self, monitorID, wallpaper) +proc GetMonitorDevicePathAt*(self: ptr IDesktopWallpaper, monitorIndex: UINT, monitorID: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMonitorDevicePathAt(self, monitorIndex, monitorID) +proc GetMonitorDevicePathCount*(self: ptr IDesktopWallpaper, count: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMonitorDevicePathCount(self, count) +proc GetMonitorRECT*(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, displayRect: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMonitorRECT(self, monitorID, displayRect) +proc mSetBackgroundColor*(self: ptr IDesktopWallpaper, color: COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBackgroundColor(self, color) +proc GetBackgroundColor*(self: ptr IDesktopWallpaper, color: ptr COLORREF): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBackgroundColor(self, color) +proc SetPosition*(self: ptr IDesktopWallpaper, position: DESKTOP_WALLPAPER_POSITION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPosition(self, position) +proc GetPosition*(self: ptr IDesktopWallpaper, position: ptr DESKTOP_WALLPAPER_POSITION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPosition(self, position) +proc SetSlideshow*(self: ptr IDesktopWallpaper, items: ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSlideshow(self, items) +proc GetSlideshow*(self: ptr IDesktopWallpaper, items: ptr ptr IShellItemArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSlideshow(self, items) +proc SetSlideshowOptions*(self: ptr IDesktopWallpaper, options: DESKTOP_SLIDESHOW_OPTIONS, slideshowTick: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSlideshowOptions(self, options, slideshowTick) +proc GetSlideshowOptions*(self: ptr IDesktopWallpaper, options: ptr DESKTOP_SLIDESHOW_OPTIONS, slideshowTick: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSlideshowOptions(self, options, slideshowTick) +proc AdvanceSlideshow*(self: ptr IDesktopWallpaper, monitorID: LPCWSTR, direction: DESKTOP_SLIDESHOW_DIRECTION): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AdvanceSlideshow(self, monitorID, direction) +proc GetStatus*(self: ptr IDesktopWallpaper, state: ptr DESKTOP_SLIDESHOW_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStatus(self, state) +proc Enable*(self: ptr IDesktopWallpaper, enable: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enable(self, enable) +proc IsMember*(self: ptr IHomeGroup, member: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsMember(self, member) +proc ShowSharingWizard*(self: ptr IHomeGroup, owner: HWND, sharingchoices: ptr HOMEGROUPSHARINGCHOICES): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowSharingWizard(self, owner, sharingchoices) +proc Initialize*(self: ptr IInitializeWithPropertyStore, pps: ptr IPropertyStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pps) +proc GetResults*(self: ptr IOpenSearchSource, hwnd: HWND, pszQuery: LPCWSTR, dwStartIndex: DWORD, dwCount: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetResults(self, hwnd, pszQuery, dwStartIndex, dwCount, riid, ppv) +proc LoadLibraryFromItem*(self: ptr IShellLibrary, psiLibrary: ptr IShellItem, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadLibraryFromItem(self, psiLibrary, grfMode) +proc LoadLibraryFromKnownFolder*(self: ptr IShellLibrary, kfidLibrary: REFKNOWNFOLDERID, grfMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadLibraryFromKnownFolder(self, kfidLibrary, grfMode) +proc AddFolder*(self: ptr IShellLibrary, psiLocation: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddFolder(self, psiLocation) +proc RemoveFolder*(self: ptr IShellLibrary, psiLocation: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFolder(self, psiLocation) +proc GetFolders*(self: ptr IShellLibrary, lff: LIBRARYFOLDERFILTER, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolders(self, lff, riid, ppv) +proc ResolveFolder*(self: ptr IShellLibrary, psiFolderToResolve: ptr IShellItem, dwTimeout: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ResolveFolder(self, psiFolderToResolve, dwTimeout, riid, ppv) +proc GetDefaultSaveFolder*(self: ptr IShellLibrary, dsft: DEFAULTSAVEFOLDERTYPE, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDefaultSaveFolder(self, dsft, riid, ppv) +proc SetDefaultSaveFolder*(self: ptr IShellLibrary, dsft: DEFAULTSAVEFOLDERTYPE, psi: ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDefaultSaveFolder(self, dsft, psi) +proc GetOptions*(self: ptr IShellLibrary, plofOptions: ptr LIBRARYOPTIONFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptions(self, plofOptions) +proc SetOptions*(self: ptr IShellLibrary, lofMask: LIBRARYOPTIONFLAGS, lofOptions: LIBRARYOPTIONFLAGS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOptions(self, lofMask, lofOptions) +proc GetFolderType*(self: ptr IShellLibrary, pftid: ptr FOLDERTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolderType(self, pftid) +proc SetFolderType*(self: ptr IShellLibrary, ftid: REFFOLDERTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolderType(self, ftid) +proc GetIcon*(self: ptr IShellLibrary, ppszIcon: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIcon(self, ppszIcon) +proc SetIcon*(self: ptr IShellLibrary, pszIcon: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIcon(self, pszIcon) +proc Commit*(self: ptr IShellLibrary): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self) +proc Save*(self: ptr IShellLibrary, psiFolderToSaveIn: ptr IShellItem, pszLibraryName: LPCWSTR, lsf: LIBRARYSAVEFLAGS, ppsiSavedTo: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Save(self, psiFolderToSaveIn, pszLibraryName, lsf, ppsiSavedTo) +proc SaveInKnownFolder*(self: ptr IShellLibrary, kfidToSaveIn: REFKNOWNFOLDERID, pszLibraryName: LPCWSTR, lsf: LIBRARYSAVEFLAGS, ppsiSavedTo: ptr ptr IShellItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SaveInKnownFolder(self, kfidToSaveIn, pszLibraryName, lsf, ppsiSavedTo) +proc OnPlaybackManagerEvent*(self: ptr IPlaybackManagerEvents, dwSessionId: DWORD, mediaEvent: PBM_EVENT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnPlaybackManagerEvent(self, dwSessionId, mediaEvent) +proc Advise*(self: ptr IPlaybackManager, `type`: PBM_SESSION_TYPE, pEvents: ptr IPlaybackManagerEvents, pdwSessionId: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, `type`, pEvents, pdwSessionId) +proc Unadvise*(self: ptr IPlaybackManager, dwSessionId: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwSessionId) +proc ChangeSessionState*(self: ptr IPlaybackManager, dwSessionId: DWORD, state: PBM_PLAY_STATE, mute: PBM_MUTE_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ChangeSessionState(self, dwSessionId, state, mute) +proc Initialize*(self: ptr IDefaultFolderMenuInitialize, hwnd: HWND, pcmcb: ptr IContextMenuCB, pidlFolder: PCIDLIST_ABSOLUTE, psf: ptr IShellFolder, cidl: UINT, apidl: PCUITEMID_CHILD_ARRAY, punkAssociation: ptr IUnknown, cKeys: UINT, aKeys: ptr HKEY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, hwnd, pcmcb, pidlFolder, psf, cidl, apidl, punkAssociation, cKeys, aKeys) +proc SetMenuRestrictions*(self: ptr IDefaultFolderMenuInitialize, dfmrValues: DEFAULT_FOLDER_MENU_RESTRICTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMenuRestrictions(self, dfmrValues) +proc GetMenuRestrictions*(self: ptr IDefaultFolderMenuInitialize, dfmrMask: DEFAULT_FOLDER_MENU_RESTRICTIONS, pdfmrValues: ptr DEFAULT_FOLDER_MENU_RESTRICTIONS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMenuRestrictions(self, dfmrMask, pdfmrValues) +proc SetHandlerClsid*(self: ptr IDefaultFolderMenuInitialize, rclsid: REFCLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetHandlerClsid(self, rclsid) +proc ActivateApplication*(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, arguments: LPCWSTR, options: ACTIVATEOPTIONS, processId: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateApplication(self, appUserModelId, arguments, options, processId) +proc ActivateForFile*(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, itemArray: ptr IShellItemArray, verb: LPCWSTR, processId: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateForFile(self, appUserModelId, itemArray, verb, processId) +proc ActivateForProtocol*(self: ptr IApplicationActivationManager, appUserModelId: LPCWSTR, itemArray: ptr IShellItemArray, processId: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateForProtocol(self, appUserModelId, itemArray, processId) +proc SupportsSelection*(self: ptr IAssocHandlerInvoker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SupportsSelection(self) +proc Invoke*(self: ptr IAssocHandlerInvoker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self) +proc GetName*(self: ptr IAssocHandler, ppsz: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName(self, ppsz) +proc GetUIName*(self: ptr IAssocHandler, ppsz: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUIName(self, ppsz) +proc GetIconLocation*(self: ptr IAssocHandler, ppszPath: ptr LPWSTR, pIndex: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, ppszPath, pIndex) +proc IsRecommended*(self: ptr IAssocHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsRecommended(self) +proc MakeDefault*(self: ptr IAssocHandler, pszDescription: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MakeDefault(self, pszDescription) +proc Invoke*(self: ptr IAssocHandler, pdo: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self, pdo) +proc CreateInvoker*(self: ptr IAssocHandler, pdo: ptr IDataObject, ppInvoker: ptr ptr IAssocHandlerInvoker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInvoker(self, pdo, ppInvoker) +proc Next*(self: ptr IEnumAssocHandlers, celt: ULONG, rgelt: ptr ptr IAssocHandler, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgelt, pceltFetched) +proc GetDataObject*(self: ptr IDataObjectProvider, dataObject: ptr ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDataObject(self, dataObject) +proc SetDataObject*(self: ptr IDataObjectProvider, dataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDataObject(self, dataObject) +proc GetForWindow*(self: ptr IDataTransferManagerInterop, appWindow: HWND, riid: REFIID, dataTransferManager: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetForWindow(self, appWindow, riid, dataTransferManager) +proc ShowShareUIForWindow*(self: ptr IDataTransferManagerInterop, appWindow: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowShareUIForWindow(self, appWindow) +proc Showing*(self: ptr IFrameworkInputPaneHandler, prcInputPaneScreenLocation: ptr RECT, fEnsureFocusedElementInView: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Showing(self, prcInputPaneScreenLocation, fEnsureFocusedElementInView) +proc Hiding*(self: ptr IFrameworkInputPaneHandler, fEnsureFocusedElementInView: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Hiding(self, fEnsureFocusedElementInView) +proc Advise*(self: ptr IFrameworkInputPane, pWindow: ptr IUnknown, pHandler: ptr IFrameworkInputPaneHandler, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pWindow, pHandler, pdwCookie) +proc AdviseWithHWND*(self: ptr IFrameworkInputPane, hwnd: HWND, pHandler: ptr IFrameworkInputPaneHandler, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AdviseWithHWND(self, hwnd, pHandler, pdwCookie) +proc Unadvise*(self: ptr IFrameworkInputPane, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc Location*(self: ptr IFrameworkInputPane, prcInputPaneScreenLocation: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Location(self, prcInputPaneScreenLocation) +proc GetSearchWindow*(self: ptr ISearchableApplication, hwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchWindow(self, hwnd) +proc Undocked*(self: ptr IAccessibilityDockingServiceCallback, undockReason: UNDOCK_REASON): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Undocked(self, undockReason) +proc GetAvailableSize*(self: ptr IAccessibilityDockingService, hMonitor: HMONITOR, pcxFixed: ptr UINT, pcyMax: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAvailableSize(self, hMonitor, pcxFixed, pcyMax) +proc DockWindow*(self: ptr IAccessibilityDockingService, hwnd: HWND, hMonitor: HMONITOR, cyRequested: UINT, pCallback: ptr IAccessibilityDockingServiceCallback): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DockWindow(self, hwnd, hMonitor, cyRequested, pCallback) +proc UndockWindow*(self: ptr IAccessibilityDockingService, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UndockWindow(self, hwnd) +proc AppVisibilityOnMonitorChanged*(self: ptr IAppVisibilityEvents, hMonitor: HMONITOR, previousMode: MONITOR_APP_VISIBILITY, currentMode: MONITOR_APP_VISIBILITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AppVisibilityOnMonitorChanged(self, hMonitor, previousMode, currentMode) +proc LauncherVisibilityChange*(self: ptr IAppVisibilityEvents, currentVisibleState: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LauncherVisibilityChange(self, currentVisibleState) +proc GetAppVisibilityOnMonitor*(self: ptr IAppVisibility, hMonitor: HMONITOR, pMode: ptr MONITOR_APP_VISIBILITY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAppVisibilityOnMonitor(self, hMonitor, pMode) +proc IsLauncherVisible*(self: ptr IAppVisibility, pfVisible: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLauncherVisible(self, pfVisible) +proc Advise*(self: ptr IAppVisibility, pCallback: ptr IAppVisibilityEvents, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Advise(self, pCallback, pdwCookie) +proc Unadvise*(self: ptr IAppVisibility, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Unadvise(self, dwCookie) +proc OnStateChanged*(self: ptr IPackageExecutionStateChangeNotification, pszPackageFullName: LPCWSTR, pesNewState: PACKAGE_EXECUTION_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnStateChanged(self, pszPackageFullName, pesNewState) +proc EnableDebugging*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, debuggerCommandLine: LPCWSTR, environment: PZZWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnableDebugging(self, packageFullName, debuggerCommandLine, environment) +proc DisableDebugging*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DisableDebugging(self, packageFullName) +proc Suspend*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Suspend(self, packageFullName) +proc Resume*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resume(self, packageFullName) +proc TerminateAllProcesses*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TerminateAllProcesses(self, packageFullName) +proc SetTargetSessionId*(self: ptr IPackageDebugSettings, sessionId: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTargetSessionId(self, sessionId) +proc EnumerateBackgroundTasks*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, taskCount: ptr ULONG, taskIds: ptr LPCGUID, taskNames: ptr ptr LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnumerateBackgroundTasks(self, packageFullName, taskCount, taskIds, taskNames) +proc ActivateBackgroundTask*(self: ptr IPackageDebugSettings, taskId: LPCGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ActivateBackgroundTask(self, taskId) +proc StartServicing*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartServicing(self, packageFullName) +proc StopServicing*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopServicing(self, packageFullName) +proc StartSessionRedirection*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, sessionId: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartSessionRedirection(self, packageFullName, sessionId) +proc StopSessionRedirection*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopSessionRedirection(self, packageFullName) +proc GetPackageExecutionState*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, packageExecutionState: ptr PACKAGE_EXECUTION_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPackageExecutionState(self, packageFullName, packageExecutionState) +proc RegisterForPackageStateChanges*(self: ptr IPackageDebugSettings, packageFullName: LPCWSTR, pPackageExecutionStateChangeNotification: ptr IPackageExecutionStateChangeNotification, pdwCookie: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterForPackageStateChanges(self, packageFullName, pPackageExecutionStateChangeNotification, pdwCookie) +proc UnregisterForPackageStateChanges*(self: ptr IPackageDebugSettings, dwCookie: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UnregisterForPackageStateChanges(self, dwCookie) +proc GetValue*(self: ptr IExecuteCommandApplicationHostEnvironment, pahe: ptr AHE_TYPE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetValue(self, pahe) +proc GetUIMode*(self: ptr IExecuteCommandHost, pUIMode: ptr EC_HOST_UI_MODE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUIMode(self, pUIMode) +proc SetNativeDisplaySize*(self: ptr IApplicationDesignModeSettings, sizeNativeDisplay: SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetNativeDisplaySize(self, sizeNativeDisplay) +proc SetScaleFactor*(self: ptr IApplicationDesignModeSettings, scaleFactor: DEVICE_SCALE_FACTOR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScaleFactor(self, scaleFactor) +proc SetApplicationViewState*(self: ptr IApplicationDesignModeSettings, viewState: APPLICATION_VIEW_STATE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetApplicationViewState(self, viewState) +proc ComputeApplicationSize*(self: ptr IApplicationDesignModeSettings, psizeApplication: ptr SIZE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ComputeApplicationSize(self, psizeApplication) +proc IsApplicationViewStateSupported*(self: ptr IApplicationDesignModeSettings, viewState: APPLICATION_VIEW_STATE, sizeNativeDisplay: SIZE, scaleFactor: DEVICE_SCALE_FACTOR, pfSupported: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsApplicationViewStateSupported(self, viewState, sizeNativeDisplay, scaleFactor, pfSupported) +proc TriggerEdgeGesture*(self: ptr IApplicationDesignModeSettings, edgeGestureKind: EDGE_GESTURE_KIND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TriggerEdgeGesture(self, edgeGestureKind) +proc Initialize*(self: ptr IInitializeWithWindow, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, hwnd) +proc GetApplicationDisplayName*(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetApplicationDisplayName(self, value) +proc GetApplicationPublisher*(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetApplicationPublisher(self, value) +proc GetApplicationIconReference*(self: ptr IHandlerInfo, value: ptr LPWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetApplicationIconReference(self, value) +proc BeforeCoCreateInstance*(self: ptr IHandlerActivationHost, clsidHandler: REFCLSID, itemsBeingActivated: ptr IShellItemArray, handlerInfo: ptr IHandlerInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeforeCoCreateInstance(self, clsidHandler, itemsBeingActivated, handlerInfo) +proc BeforeCreateProcess*(self: ptr IHandlerActivationHost, applicationPath: LPCWSTR, commandLine: LPCWSTR, handlerInfo: ptr IHandlerInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BeforeCreateProcess(self, applicationPath, commandLine, handlerInfo) +proc GetIconLocation*(self: ptr IExtractIconA, uFlags: UINT, pszIconFile: PSTR, cchMax: UINT, piIndex: ptr int32, pwFlags: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, uFlags, pszIconFile, cchMax, piIndex, pwFlags) +proc Extract*(self: ptr IExtractIconA, pszFile: PCSTR, nIconIndex: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Extract(self, pszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize) +proc GetIconLocation*(self: ptr IExtractIconW, uFlags: UINT, pszIconFile: PWSTR, cchMax: UINT, piIndex: ptr int32, pwFlags: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconLocation(self, uFlags, pszIconFile, cchMax, piIndex, pwFlags) +proc Extract*(self: ptr IExtractIconW, pszFile: PCWSTR, nIconIndex: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Extract(self, pszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize) +proc IsMemberOf*(self: ptr IShellIconOverlayIdentifier, pwszPath: PCWSTR, dwAttrib: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsMemberOf(self, pwszPath, dwAttrib) +proc GetOverlayInfo*(self: ptr IShellIconOverlayIdentifier, pwszIconFile: PWSTR, cchMax: int32, pIndex: ptr int32, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverlayInfo(self, pwszIconFile, cchMax, pIndex, pdwFlags) +proc GetPriority*(self: ptr IShellIconOverlayIdentifier, pIPriority: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPriority(self, pIPriority) +proc GetFileOverlayInfo*(self: ptr IShellIconOverlayManager, pwszPath: PCWSTR, dwAttrib: DWORD, pIndex: ptr int32, dwflags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileOverlayInfo(self, pwszPath, dwAttrib, pIndex, dwflags) +proc GetReservedOverlayInfo*(self: ptr IShellIconOverlayManager, pwszPath: PCWSTR, dwAttrib: DWORD, pIndex: ptr int32, dwflags: DWORD, iReservedID: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReservedOverlayInfo(self, pwszPath, dwAttrib, pIndex, dwflags, iReservedID) +proc RefreshOverlayImages*(self: ptr IShellIconOverlayManager, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RefreshOverlayImages(self, dwFlags) +proc LoadNonloadedOverlayIdentifiers*(self: ptr IShellIconOverlayManager): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.LoadNonloadedOverlayIdentifiers(self) +proc OverlayIndexFromImageIndex*(self: ptr IShellIconOverlayManager, iImage: int32, piIndex: ptr int32, fAdd: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OverlayIndexFromImageIndex(self, iImage, piIndex, fAdd) +proc GetOverlayIndex*(self: ptr IShellIconOverlay, pidl: PCUITEMID_CHILD, pIndex: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverlayIndex(self, pidl, pIndex) +proc GetOverlayIconIndex*(self: ptr IShellIconOverlay, pidl: PCUITEMID_CHILD, pIconIndex: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverlayIconIndex(self, pidl, pIconIndex) +proc Execute*(self: ptr IShellExecuteHookA, pei: LPSHELLEXECUTEINFOA): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Execute(self, pei) +proc Execute*(self: ptr IShellExecuteHookW, pei: LPSHELLEXECUTEINFOW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Execute(self, pei) +proc Translate*(self: ptr IURLSearchHook, pwszSearchURL: PWSTR, cchBufferSize: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Translate(self, pwszSearchURL, cchBufferSize) +proc GetSearchUrl*(self: ptr ISearchContext, pbstrSearchUrl: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchUrl(self, pbstrSearchUrl) +proc GetSearchText*(self: ptr ISearchContext, pbstrSearchText: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchText(self, pbstrSearchText) +proc GetSearchStyle*(self: ptr ISearchContext, pdwSearchStyle: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSearchStyle(self, pdwSearchStyle) +proc TranslateWithSearchContext*(self: ptr IURLSearchHook2, pwszSearchURL: PWSTR, cchBufferSize: DWORD, pSearchContext: ptr ISearchContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.TranslateWithSearchContext(self, pwszSearchURL, cchBufferSize, pSearchContext) +proc SetReferent*(self: ptr INewShortcutHookA, pcszReferent: PCSTR, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetReferent(self, pcszReferent, hwnd) +proc GetReferent*(self: ptr INewShortcutHookA, pszReferent: PSTR, cchReferent: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReferent(self, pszReferent, cchReferent) +proc SetFolder*(self: ptr INewShortcutHookA, pcszFolder: PCSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolder(self, pcszFolder) +proc GetFolder*(self: ptr INewShortcutHookA, pszFolder: PSTR, cchFolder: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolder(self, pszFolder, cchFolder) +proc GetName*(self: ptr INewShortcutHookA, pszName: PSTR, cchName: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName(self, pszName, cchName) +proc GetExtension*(self: ptr INewShortcutHookA, pszExtension: PSTR, cchExtension: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtension(self, pszExtension, cchExtension) +proc SetReferent*(self: ptr INewShortcutHookW, pcszReferent: PCWSTR, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetReferent(self, pcszReferent, hwnd) +proc GetReferent*(self: ptr INewShortcutHookW, pszReferent: PWSTR, cchReferent: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetReferent(self, pszReferent, cchReferent) +proc SetFolder*(self: ptr INewShortcutHookW, pcszFolder: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFolder(self, pcszFolder) +proc GetFolder*(self: ptr INewShortcutHookW, pszFolder: PWSTR, cchFolder: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFolder(self, pszFolder, cchFolder) +proc GetName*(self: ptr INewShortcutHookW, pszName: PWSTR, cchName: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetName(self, pszName, cchName) +proc GetExtension*(self: ptr INewShortcutHookW, pszExtension: PWSTR, cchExtension: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExtension(self, pszExtension, cchExtension) +proc CopyCallback*(self: ptr ICopyHookA, hwnd: HWND, wFunc: UINT, wFlags: UINT, pszSrcFile: PCSTR, dwSrcAttribs: DWORD, pszDestFile: PCSTR, dwDestAttribs: DWORD): UINT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyCallback(self, hwnd, wFunc, wFlags, pszSrcFile, dwSrcAttribs, pszDestFile, dwDestAttribs) +proc CopyCallback*(self: ptr ICopyHookW, hwnd: HWND, wFunc: UINT, wFlags: UINT, pszSrcFile: PCWSTR, dwSrcAttribs: DWORD, pszDestFile: PCWSTR, dwDestAttribs: DWORD): UINT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyCallback(self, hwnd, wFunc, wFlags, pszSrcFile, dwSrcAttribs, pszDestFile, dwDestAttribs) +proc SetPinnedWindow*(self: ptr IFileViewerSite, hwnd: HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPinnedWindow(self, hwnd) +proc GetPinnedWindow*(self: ptr IFileViewerSite, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPinnedWindow(self, phwnd) +proc ShowInitialize*(self: ptr IFileViewerA, lpfsi: LPFILEVIEWERSITE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowInitialize(self, lpfsi) +proc Show*(self: ptr IFileViewerA, pvsi: LPFVSHOWINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, pvsi) +proc PrintTo*(self: ptr IFileViewerA, pszDriver: PSTR, fSuppressUI: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PrintTo(self, pszDriver, fSuppressUI) +proc ShowInitialize*(self: ptr IFileViewerW, lpfsi: LPFILEVIEWERSITE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowInitialize(self, lpfsi) +proc Show*(self: ptr IFileViewerW, pvsi: LPFVSHOWINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Show(self, pvsi) +proc PrintTo*(self: ptr IFileViewerW, pszDriver: PWSTR, fSuppressUI: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PrintTo(self, pszDriver, fSuppressUI) +proc GetDetailsOf*(self: ptr IShellDetails, pidl: PCUITEMID_CHILD, iColumn: UINT, pDetails: ptr SHELLDETAILS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDetailsOf(self, pidl, iColumn, pDetails) +proc ColumnClick*(self: ptr IShellDetails, iColumn: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ColumnClick(self, iColumn) +proc Append*(self: ptr IObjMgr, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Append(self, punk) +proc Remove*(self: ptr IObjMgr, punk: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Remove(self, punk) +proc GetDirectory*(self: ptr ICurrentWorkingDirectory, pwzPath: PWSTR, cchSize: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDirectory(self, pwzPath, cchSize) +proc SetDirectory*(self: ptr ICurrentWorkingDirectory, pwzPath: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDirectory(self, pwzPath) +proc Expand*(self: ptr IACList, pszExpand: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Expand(self, pszExpand) +proc SetOptions*(self: ptr IACList2, dwFlag: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetOptions(self, dwFlag) +proc GetOptions*(self: ptr IACList2, pdwFlag: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOptions(self, pdwFlag) +proc StartProgressDialog*(self: ptr IProgressDialog, hwndParent: HWND, punkEnableModless: ptr IUnknown, dwFlags: DWORD, pvResevered: LPCVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartProgressDialog(self, hwndParent, punkEnableModless, dwFlags, pvResevered) +proc StopProgressDialog*(self: ptr IProgressDialog): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StopProgressDialog(self) +proc SetTitle*(self: ptr IProgressDialog, pwzTitle: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTitle(self, pwzTitle) +proc SetAnimation*(self: ptr IProgressDialog, hInstAnimation: HINSTANCE, idAnimation: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAnimation(self, hInstAnimation, idAnimation) +proc HasUserCancelled*(self: ptr IProgressDialog): WINBOOL {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasUserCancelled(self) +proc SetProgress*(self: ptr IProgressDialog, dwCompleted: DWORD, dwTotal: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgress(self, dwCompleted, dwTotal) +proc SetProgress64*(self: ptr IProgressDialog, ullCompleted: ULONGLONG, ullTotal: ULONGLONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetProgress64(self, ullCompleted, ullTotal) +proc SetLine*(self: ptr IProgressDialog, dwLineNum: DWORD, pwzString: PCWSTR, fCompactPath: WINBOOL, pvResevered: LPCVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetLine(self, dwLineNum, pwzString, fCompactPath, pvResevered) +proc SetCancelMsg*(self: ptr IProgressDialog, pwzCancelMsg: PCWSTR, pvResevered: LPCVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCancelMsg(self, pwzCancelMsg, pvResevered) +proc Timer*(self: ptr IProgressDialog, dwTimerAction: DWORD, pvResevered: LPCVOID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Timer(self, dwTimerAction, pvResevered) +proc GetBorderDW*(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, prcBorder: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBorderDW(self, punkObj, prcBorder) +proc RequestBorderSpaceDW*(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, pbw: LPCBORDERWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RequestBorderSpaceDW(self, punkObj, pbw) +proc SetBorderSpaceDW*(self: ptr IDockingWindowSite, punkObj: ptr IUnknown, pbw: LPCBORDERWIDTHS): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBorderSpaceDW(self, punkObj, pbw) +proc AddToolbar*(self: ptr IDockingWindowFrame, punkSrc: ptr IUnknown, pwszItem: PCWSTR, dwAddFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToolbar(self, punkSrc, pwszItem, dwAddFlags) +proc RemoveToolbar*(self: ptr IDockingWindowFrame, punkSrc: ptr IUnknown, dwRemoveFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveToolbar(self, punkSrc, dwRemoveFlags) +proc FindToolbar*(self: ptr IDockingWindowFrame, pwszItem: PCWSTR, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindToolbar(self, pwszItem, riid, ppv) +proc CaptureThumbnail*(self: ptr IThumbnailCapture, pMaxSize: ptr SIZE, pHTMLDoc2: ptr IUnknown, phbmThumbnail: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CaptureThumbnail(self, pMaxSize, pHTMLDoc2, phbmThumbnail) +proc Reset*(self: ptr IEnumShellImageStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Next*(self: ptr IEnumShellImageStore, celt: ULONG, prgElt: ptr PENUMSHELLIMAGESTOREDATA, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, prgElt, pceltFetched) +proc Skip*(self: ptr IEnumShellImageStore, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Clone*(self: ptr IEnumShellImageStore, ppEnum: ptr ptr IEnumShellImageStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppEnum) +proc Open*(self: ptr IShellImageStore, dwMode: DWORD, pdwLock: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Open(self, dwMode, pdwLock) +proc Create*(self: ptr IShellImageStore, dwMode: DWORD, pdwLock: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Create(self, dwMode, pdwLock) +proc ReleaseLock*(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseLock(self, pdwLock) +proc Close*(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self, pdwLock) +proc Commit*(self: ptr IShellImageStore, pdwLock: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self, pdwLock) +proc IsLocked*(self: ptr IShellImageStore): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsLocked(self) +proc GetMode*(self: ptr IShellImageStore, pdwMode: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMode(self, pdwMode) +proc GetCapabilities*(self: ptr IShellImageStore, pdwCapMask: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCapabilities(self, pdwCapMask) +proc AddEntry*(self: ptr IShellImageStore, pszName: PCWSTR, pftTimeStamp: ptr FILETIME, dwMode: DWORD, hImage: HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddEntry(self, pszName, pftTimeStamp, dwMode, hImage) +proc GetEntry*(self: ptr IShellImageStore, pszName: PCWSTR, dwMode: DWORD, phImage: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEntry(self, pszName, dwMode, phImage) +proc DeleteEntry*(self: ptr IShellImageStore, pszName: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteEntry(self, pszName) +proc IsEntryInStore*(self: ptr IShellImageStore, pszName: PCWSTR, pftTimeStamp: ptr FILETIME): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsEntryInStore(self, pszName, pftTimeStamp) +proc Enum*(self: ptr IShellImageStore, ppEnum: ptr LPENUMSHELLIMAGESTORE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Enum(self, ppEnum) +proc InitializeSFB*(self: ptr IShellFolderBand, psf: ptr IShellFolder, pidl: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeSFB(self, psf, pidl) +proc SetBandInfoSFB*(self: ptr IShellFolderBand, pbi: PBANDINFOSFB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBandInfoSFB(self, pbi) +proc GetBandInfoSFB*(self: ptr IShellFolderBand, pbi: PBANDINFOSFB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBandInfoSFB(self, pbi) +proc SetDeskBarSite*(self: ptr IDeskBarClient, punkSite: ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDeskBarSite(self, punkSite) +proc SetModeDBC*(self: ptr IDeskBarClient, dwMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetModeDBC(self, dwMode) +proc UIActivateDBC*(self: ptr IDeskBarClient, dwState: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UIActivateDBC(self, dwState) +proc GetSize*(self: ptr IDeskBarClient, dwWhich: DWORD, prc: LPRECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, dwWhich, prc) +proc ApplyChanges*(self: ptr IActiveDesktop, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ApplyChanges(self, dwFlags) +proc GetWallpaper*(self: ptr IActiveDesktop, pwszWallpaper: PWSTR, cchWallpaper: UINT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWallpaper(self, pwszWallpaper, cchWallpaper, dwFlags) +proc SetWallpaper*(self: ptr IActiveDesktop, pwszWallpaper: PCWSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWallpaper(self, pwszWallpaper, dwReserved) +proc GetWallpaperOptions*(self: ptr IActiveDesktop, pwpo: LPWALLPAPEROPT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWallpaperOptions(self, pwpo, dwReserved) +proc SetWallpaperOptions*(self: ptr IActiveDesktop, pwpo: LPCWALLPAPEROPT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWallpaperOptions(self, pwpo, dwReserved) +proc GetPattern*(self: ptr IActiveDesktop, pwszPattern: PWSTR, cchPattern: UINT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPattern(self, pwszPattern, cchPattern, dwReserved) +proc SetPattern*(self: ptr IActiveDesktop, pwszPattern: PCWSTR, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPattern(self, pwszPattern, dwReserved) +proc GetDesktopItemOptions*(self: ptr IActiveDesktop, pco: LPCOMPONENTSOPT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDesktopItemOptions(self, pco, dwReserved) +proc SetDesktopItemOptions*(self: ptr IActiveDesktop, pco: LPCCOMPONENTSOPT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDesktopItemOptions(self, pco, dwReserved) +proc AddDesktopItem*(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDesktopItem(self, pcomp, dwReserved) +proc AddDesktopItemWithUI*(self: ptr IActiveDesktop, hwnd: HWND, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddDesktopItemWithUI(self, hwnd, pcomp, dwReserved) +proc ModifyDesktopItem*(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ModifyDesktopItem(self, pcomp, dwFlags) +proc RemoveDesktopItem*(self: ptr IActiveDesktop, pcomp: LPCCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveDesktopItem(self, pcomp, dwReserved) +proc GetDesktopItemCount*(self: ptr IActiveDesktop, pcItems: ptr int32, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDesktopItemCount(self, pcItems, dwReserved) +proc GetDesktopItem*(self: ptr IActiveDesktop, nComponent: int32, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDesktopItem(self, nComponent, pcomp, dwReserved) +proc GetDesktopItemByID*(self: ptr IActiveDesktop, dwID: ULONG_PTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDesktopItemByID(self, dwID, pcomp, dwReserved) +proc GenerateDesktopItemHtml*(self: ptr IActiveDesktop, pwszFileName: PCWSTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GenerateDesktopItemHtml(self, pwszFileName, pcomp, dwReserved) +proc AddUrl*(self: ptr IActiveDesktop, hwnd: HWND, pszSource: PCWSTR, pcomp: LPCOMPONENT, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddUrl(self, hwnd, pszSource, pcomp, dwFlags) +proc GetDesktopItemBySource*(self: ptr IActiveDesktop, pwszSource: PCWSTR, pcomp: LPCOMPONENT, dwReserved: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDesktopItemBySource(self, pwszSource, pcomp, dwReserved) +proc SetSafeMode*(self: ptr IActiveDesktopP, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSafeMode(self, dwFlags) +proc EnsureUpdateHTML*(self: ptr IActiveDesktopP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EnsureUpdateHTML(self) +proc SetScheme*(self: ptr IActiveDesktopP, pwszSchemeName: PCWSTR, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScheme(self, pwszSchemeName, dwFlags) +proc GetScheme*(self: ptr IActiveDesktopP, pwszSchemeName: PWSTR, pdwcchBuffer: ptr DWORD, dwFlags: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetScheme(self, pwszSchemeName, pdwcchBuffer, dwFlags) +proc ReReadWallpaper*(self: ptr IADesktopP2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReReadWallpaper(self) +proc GetADObjectFlags*(self: ptr IADesktopP2, pdwFlags: ptr DWORD, dwMask: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetADObjectFlags(self, pdwFlags, dwMask) +proc UpdateAllDesktopSubscriptions*(self: ptr IADesktopP2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateAllDesktopSubscriptions(self) +proc MakeDynamicChanges*(self: ptr IADesktopP2, pOleObj: ptr IOleObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MakeDynamicChanges(self, pOleObj) +proc Initialize*(self: ptr IColumnProvider, psci: LPCSHCOLUMNINIT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, psci) +proc GetColumnInfo*(self: ptr IColumnProvider, dwIndex: DWORD, psci: ptr SHCOLUMNINFO): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnInfo(self, dwIndex, psci) +proc GetItemData*(self: ptr IColumnProvider, pscid: LPCSHCOLUMNID, pscd: LPCSHCOLUMNDATA, pvarData: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemData(self, pscid, pscd, pvarData) +proc OnChange*(self: ptr IShellChangeNotify, lEvent: LONG, pidl1: PCIDLIST_ABSOLUTE, pidl2: PCIDLIST_ABSOLUTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnChange(self, lEvent, pidl1, pidl2) +proc GetInfoTip*(self: ptr IQueryInfo, dwFlags: DWORD, ppwszTip: ptr PWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInfoTip(self, dwFlags, ppwszTip) +proc GetInfoFlags*(self: ptr IQueryInfo, pdwFlags: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetInfoFlags(self, pdwFlags) +proc GetWindowLV*(self: ptr IDefViewFrame, phwnd: ptr HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWindowLV(self, phwnd) +proc ReleaseWindowLV*(self: ptr IDefViewFrame): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReleaseWindowLV(self) +proc GetShellFolder*(self: ptr IDefViewFrame, ppsf: ptr ptr IShellFolder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetShellFolder(self, ppsf) +proc OnSetTitle*(self: ptr IDocViewSite, pvTitle: ptr VARIANTARG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.OnSetTitle(self, pvTitle) +proc Initialize*(self: ptr IInitializeObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self) +proc SetIconSize*(self: ptr IBanneredBar, iIcon: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetIconSize(self, iIcon) +proc GetIconSize*(self: ptr IBanneredBar, piIcon: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIconSize(self, piIcon) +proc SetBitmap*(self: ptr IBanneredBar, hBitmap: HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetBitmap(self, hBitmap) +proc GetBitmap*(self: ptr IBanneredBar, phBitmap: ptr HBITMAP): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBitmap(self, phBitmap) +proc MessageSFVCB*(self: ptr IShellFolderViewCB, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MessageSFVCB(self, uMsg, wParam, lParam) +proc Rearrange*(self: ptr IShellFolderView, lParamSort: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Rearrange(self, lParamSort) +proc GetArrangeParam*(self: ptr IShellFolderView, plParamSort: ptr LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetArrangeParam(self, plParamSort) +proc ArrangeGrid*(self: ptr IShellFolderView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ArrangeGrid(self) +proc AutoArrange*(self: ptr IShellFolderView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AutoArrange(self) +proc GetAutoArrange*(self: ptr IShellFolderView): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAutoArrange(self) +proc AddObject*(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddObject(self, pidl, puItem) +proc GetObject*(self: ptr IShellFolderView, ppidl: ptr PITEMID_CHILD, uItem: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObject(self, ppidl, uItem) +proc RemoveObject*(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveObject(self, pidl, puItem) +proc GetObjectCount*(self: ptr IShellFolderView, puCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectCount(self, puCount) +proc SetObjectCount*(self: ptr IShellFolderView, uCount: UINT, dwFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetObjectCount(self, uCount, dwFlags) +proc UpdateObject*(self: ptr IShellFolderView, pidlOld: PUITEMID_CHILD, pidlNew: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.UpdateObject(self, pidlOld, pidlNew, puItem) +proc RefreshObject*(self: ptr IShellFolderView, pidl: PUITEMID_CHILD, puItem: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RefreshObject(self, pidl, puItem) +proc SetRedraw*(self: ptr IShellFolderView, bRedraw: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetRedraw(self, bRedraw) +proc GetSelectedCount*(self: ptr IShellFolderView, puSelected: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedCount(self, puSelected) +proc GetSelectedObjects*(self: ptr IShellFolderView, pppidl: ptr ptr PCUITEMID_CHILD, puItems: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelectedObjects(self, pppidl, puItems) +proc IsDropOnSource*(self: ptr IShellFolderView, pDropTarget: ptr IDropTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsDropOnSource(self, pDropTarget) +proc GetDragPoint*(self: ptr IShellFolderView, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDragPoint(self, ppt) +proc GetDropPoint*(self: ptr IShellFolderView, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDropPoint(self, ppt) +proc MoveIcons*(self: ptr IShellFolderView, pDataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveIcons(self, pDataObject) +proc SetItemPos*(self: ptr IShellFolderView, pidl: PCUITEMID_CHILD, ppt: ptr POINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetItemPos(self, pidl, ppt) +proc IsBkDropTarget*(self: ptr IShellFolderView, pDropTarget: ptr IDropTarget): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsBkDropTarget(self, pDropTarget) +proc SetClipboard*(self: ptr IShellFolderView, bMove: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetClipboard(self, bMove) +proc SetPoints*(self: ptr IShellFolderView, pDataObject: ptr IDataObject): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPoints(self, pDataObject) +proc GetItemSpacing*(self: ptr IShellFolderView, pSpacing: ptr ITEMSPACING): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemSpacing(self, pSpacing) +proc SetCallback*(self: ptr IShellFolderView, pNewCB: ptr IShellFolderViewCB, ppOldCB: ptr ptr IShellFolderViewCB): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCallback(self, pNewCB, ppOldCB) +proc Select*(self: ptr IShellFolderView, dwFlags: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self, dwFlags) +proc QuerySupport*(self: ptr IShellFolderView, pdwSupport: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QuerySupport(self, pdwSupport) +proc SetAutomationObject*(self: ptr IShellFolderView, pdisp: ptr IDispatch): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetAutomationObject(self, pdisp) +proc ReadPropertyNPB*(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR, pVar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadPropertyNPB(self, pszBagname, pszPropName, pVar) +proc WritePropertyNPB*(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR, pVar: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WritePropertyNPB(self, pszBagname, pszPropName, pVar) +proc RemovePropertyNPB*(self: ptr INamedPropertyBag, pszBagname: PCWSTR, pszPropName: PCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemovePropertyNPB(self, pszBagname, pszPropName) +converter winimConverterIQueryAssociationsToIUnknown*(x: ptr IQueryAssociations): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderViewOCToIDispatch*(x: ptr IFolderViewOC): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIFolderViewOCToIUnknown*(x: ptr IFolderViewOC): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDShellFolderViewEventsToIDispatch*(x: ptr DShellFolderViewEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDShellFolderViewEventsToIUnknown*(x: ptr DShellFolderViewEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterDFConstraintToIDispatch*(x: ptr DFConstraint): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterDFConstraintToIUnknown*(x: ptr DFConstraint): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderToIDispatch*(x: ptr Folder): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderToIUnknown*(x: ptr Folder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolder2ToFolder*(x: ptr Folder2): ptr Folder = cast[ptr Folder](x) +converter winimConverterFolder2ToIDispatch*(x: ptr Folder2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolder2ToIUnknown*(x: ptr Folder2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolder3ToFolder2*(x: ptr Folder3): ptr Folder2 = cast[ptr Folder2](x) +converter winimConverterFolder3ToFolder*(x: ptr Folder3): ptr Folder = cast[ptr Folder](x) +converter winimConverterFolder3ToIDispatch*(x: ptr Folder3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolder3ToIUnknown*(x: ptr Folder3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItemToIDispatch*(x: ptr FolderItem): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItemToIUnknown*(x: ptr FolderItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItem2ToFolderItem*(x: ptr FolderItem2): ptr FolderItem = cast[ptr FolderItem](x) +converter winimConverterFolderItem2ToIDispatch*(x: ptr FolderItem2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItem2ToIUnknown*(x: ptr FolderItem2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItemsToIDispatch*(x: ptr FolderItems): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItemsToIUnknown*(x: ptr FolderItems): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItems2ToFolderItems*(x: ptr FolderItems2): ptr FolderItems = cast[ptr FolderItems](x) +converter winimConverterFolderItems2ToIDispatch*(x: ptr FolderItems2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItems2ToIUnknown*(x: ptr FolderItems2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItems3ToFolderItems2*(x: ptr FolderItems3): ptr FolderItems2 = cast[ptr FolderItems2](x) +converter winimConverterFolderItems3ToFolderItems*(x: ptr FolderItems3): ptr FolderItems = cast[ptr FolderItems](x) +converter winimConverterFolderItems3ToIDispatch*(x: ptr FolderItems3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItems3ToIUnknown*(x: ptr FolderItems3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItemVerbToIDispatch*(x: ptr FolderItemVerb): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItemVerbToIUnknown*(x: ptr FolderItemVerb): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterFolderItemVerbsToIDispatch*(x: ptr FolderItemVerbs): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterFolderItemVerbsToIUnknown*(x: ptr FolderItemVerbs): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLinkDualToIDispatch*(x: ptr IShellLinkDual): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellLinkDualToIUnknown*(x: ptr IShellLinkDual): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLinkDual2ToIShellLinkDual*(x: ptr IShellLinkDual2): ptr IShellLinkDual = cast[ptr IShellLinkDual](x) +converter winimConverterIShellLinkDual2ToIDispatch*(x: ptr IShellLinkDual2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellLinkDual2ToIUnknown*(x: ptr IShellLinkDual2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderViewDualToIDispatch*(x: ptr IShellFolderViewDual): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellFolderViewDualToIUnknown*(x: ptr IShellFolderViewDual): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderViewDual2ToIShellFolderViewDual*(x: ptr IShellFolderViewDual2): ptr IShellFolderViewDual = cast[ptr IShellFolderViewDual](x) +converter winimConverterIShellFolderViewDual2ToIDispatch*(x: ptr IShellFolderViewDual2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellFolderViewDual2ToIUnknown*(x: ptr IShellFolderViewDual2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderViewDual3ToIShellFolderViewDual2*(x: ptr IShellFolderViewDual3): ptr IShellFolderViewDual2 = cast[ptr IShellFolderViewDual2](x) +converter winimConverterIShellFolderViewDual3ToIShellFolderViewDual*(x: ptr IShellFolderViewDual3): ptr IShellFolderViewDual = cast[ptr IShellFolderViewDual](x) +converter winimConverterIShellFolderViewDual3ToIDispatch*(x: ptr IShellFolderViewDual3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellFolderViewDual3ToIUnknown*(x: ptr IShellFolderViewDual3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatchToIDispatch*(x: ptr IShellDispatch): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatchToIUnknown*(x: ptr IShellDispatch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatch2ToIShellDispatch*(x: ptr IShellDispatch2): ptr IShellDispatch = cast[ptr IShellDispatch](x) +converter winimConverterIShellDispatch2ToIDispatch*(x: ptr IShellDispatch2): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatch2ToIUnknown*(x: ptr IShellDispatch2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatch3ToIShellDispatch2*(x: ptr IShellDispatch3): ptr IShellDispatch2 = cast[ptr IShellDispatch2](x) +converter winimConverterIShellDispatch3ToIShellDispatch*(x: ptr IShellDispatch3): ptr IShellDispatch = cast[ptr IShellDispatch](x) +converter winimConverterIShellDispatch3ToIDispatch*(x: ptr IShellDispatch3): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatch3ToIUnknown*(x: ptr IShellDispatch3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatch4ToIShellDispatch3*(x: ptr IShellDispatch4): ptr IShellDispatch3 = cast[ptr IShellDispatch3](x) +converter winimConverterIShellDispatch4ToIShellDispatch2*(x: ptr IShellDispatch4): ptr IShellDispatch2 = cast[ptr IShellDispatch2](x) +converter winimConverterIShellDispatch4ToIShellDispatch*(x: ptr IShellDispatch4): ptr IShellDispatch = cast[ptr IShellDispatch](x) +converter winimConverterIShellDispatch4ToIDispatch*(x: ptr IShellDispatch4): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatch4ToIUnknown*(x: ptr IShellDispatch4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatch5ToIShellDispatch4*(x: ptr IShellDispatch5): ptr IShellDispatch4 = cast[ptr IShellDispatch4](x) +converter winimConverterIShellDispatch5ToIShellDispatch3*(x: ptr IShellDispatch5): ptr IShellDispatch3 = cast[ptr IShellDispatch3](x) +converter winimConverterIShellDispatch5ToIShellDispatch2*(x: ptr IShellDispatch5): ptr IShellDispatch2 = cast[ptr IShellDispatch2](x) +converter winimConverterIShellDispatch5ToIShellDispatch*(x: ptr IShellDispatch5): ptr IShellDispatch = cast[ptr IShellDispatch](x) +converter winimConverterIShellDispatch5ToIDispatch*(x: ptr IShellDispatch5): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatch5ToIUnknown*(x: ptr IShellDispatch5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDispatch6ToIShellDispatch5*(x: ptr IShellDispatch6): ptr IShellDispatch5 = cast[ptr IShellDispatch5](x) +converter winimConverterIShellDispatch6ToIShellDispatch4*(x: ptr IShellDispatch6): ptr IShellDispatch4 = cast[ptr IShellDispatch4](x) +converter winimConverterIShellDispatch6ToIShellDispatch3*(x: ptr IShellDispatch6): ptr IShellDispatch3 = cast[ptr IShellDispatch3](x) +converter winimConverterIShellDispatch6ToIShellDispatch2*(x: ptr IShellDispatch6): ptr IShellDispatch2 = cast[ptr IShellDispatch2](x) +converter winimConverterIShellDispatch6ToIShellDispatch*(x: ptr IShellDispatch6): ptr IShellDispatch = cast[ptr IShellDispatch](x) +converter winimConverterIShellDispatch6ToIDispatch*(x: ptr IShellDispatch6): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIShellDispatch6ToIUnknown*(x: ptr IShellDispatch6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileSearchBandToIDispatch*(x: ptr IFileSearchBand): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIFileSearchBandToIUnknown*(x: ptr IFileSearchBand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebWizardHostToIDispatch*(x: ptr IWebWizardHost): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterIWebWizardHostToIUnknown*(x: ptr IWebWizardHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINewWDEventsToIWebWizardHost*(x: ptr INewWDEvents): ptr IWebWizardHost = cast[ptr IWebWizardHost](x) +converter winimConverterINewWDEventsToIDispatch*(x: ptr INewWDEvents): ptr IDispatch = cast[ptr IDispatch](x) +converter winimConverterINewWDEventsToIUnknown*(x: ptr INewWDEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAutoCompleteToIUnknown*(x: ptr IAutoComplete): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAutoComplete2ToIAutoComplete*(x: ptr IAutoComplete2): ptr IAutoComplete = cast[ptr IAutoComplete](x) +converter winimConverterIAutoComplete2ToIUnknown*(x: ptr IAutoComplete2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumACStringToIEnumString*(x: ptr IEnumACString): ptr IEnumString = cast[ptr IEnumString](x) +converter winimConverterIEnumACStringToIUnknown*(x: ptr IEnumACString): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataObjectAsyncCapabilityToIUnknown*(x: ptr IDataObjectAsyncCapability): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectArrayToIUnknown*(x: ptr IObjectArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectCollectionToIObjectArray*(x: ptr IObjectCollection): ptr IObjectArray = cast[ptr IObjectArray](x) +converter winimConverterIObjectCollectionToIUnknown*(x: ptr IObjectCollection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextMenuToIUnknown*(x: ptr IContextMenu): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextMenu2ToIContextMenu*(x: ptr IContextMenu2): ptr IContextMenu = cast[ptr IContextMenu](x) +converter winimConverterIContextMenu2ToIUnknown*(x: ptr IContextMenu2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextMenu3ToIContextMenu2*(x: ptr IContextMenu3): ptr IContextMenu2 = cast[ptr IContextMenu2](x) +converter winimConverterIContextMenu3ToIContextMenu*(x: ptr IContextMenu3): ptr IContextMenu = cast[ptr IContextMenu](x) +converter winimConverterIContextMenu3ToIUnknown*(x: ptr IContextMenu3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExecuteCommandToIUnknown*(x: ptr IExecuteCommand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistFolderToIPersist*(x: ptr IPersistFolder): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistFolderToIUnknown*(x: ptr IPersistFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRunnableTaskToIUnknown*(x: ptr IRunnableTask): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellTaskSchedulerToIUnknown*(x: ptr IShellTaskScheduler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIQueryCodePageToIUnknown*(x: ptr IQueryCodePage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistFolder2ToIPersistFolder*(x: ptr IPersistFolder2): ptr IPersistFolder = cast[ptr IPersistFolder](x) +converter winimConverterIPersistFolder2ToIPersist*(x: ptr IPersistFolder2): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistFolder2ToIUnknown*(x: ptr IPersistFolder2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistFolder3ToIPersistFolder2*(x: ptr IPersistFolder3): ptr IPersistFolder2 = cast[ptr IPersistFolder2](x) +converter winimConverterIPersistFolder3ToIPersistFolder*(x: ptr IPersistFolder3): ptr IPersistFolder = cast[ptr IPersistFolder](x) +converter winimConverterIPersistFolder3ToIPersist*(x: ptr IPersistFolder3): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistFolder3ToIUnknown*(x: ptr IPersistFolder3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPersistIDListToIPersist*(x: ptr IPersistIDList): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIPersistIDListToIUnknown*(x: ptr IPersistIDList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumIDListToIUnknown*(x: ptr IEnumIDList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumFullIDListToIUnknown*(x: ptr IEnumFullIDList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithFolderEnumModeToIUnknown*(x: ptr IObjectWithFolderEnumMode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIParseAndCreateItemToIUnknown*(x: ptr IParseAndCreateItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderToIUnknown*(x: ptr IShellFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumExtraSearchToIUnknown*(x: ptr IEnumExtraSearch): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolder2ToIShellFolder*(x: ptr IShellFolder2): ptr IShellFolder = cast[ptr IShellFolder](x) +converter winimConverterIShellFolder2ToIUnknown*(x: ptr IShellFolder2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderViewOptionsToIUnknown*(x: ptr IFolderViewOptions): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellViewToIOleWindow*(x: ptr IShellView): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIShellViewToIUnknown*(x: ptr IShellView): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellView2ToIShellView*(x: ptr IShellView2): ptr IShellView = cast[ptr IShellView](x) +converter winimConverterIShellView2ToIOleWindow*(x: ptr IShellView2): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIShellView2ToIUnknown*(x: ptr IShellView2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellView3ToIShellView2*(x: ptr IShellView3): ptr IShellView2 = cast[ptr IShellView2](x) +converter winimConverterIShellView3ToIShellView*(x: ptr IShellView3): ptr IShellView = cast[ptr IShellView](x) +converter winimConverterIShellView3ToIOleWindow*(x: ptr IShellView3): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIShellView3ToIUnknown*(x: ptr IShellView3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderViewToIUnknown*(x: ptr IFolderView): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchBoxInfoToIUnknown*(x: ptr ISearchBoxInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderView2ToIFolderView*(x: ptr IFolderView2): ptr IFolderView = cast[ptr IFolderView](x) +converter winimConverterIFolderView2ToIUnknown*(x: ptr IFolderView2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderViewSettingsToIUnknown*(x: ptr IFolderViewSettings): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPreviewHandlerVisualsToIUnknown*(x: ptr IPreviewHandlerVisuals): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIVisualPropertiesToIUnknown*(x: ptr IVisualProperties): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICommDlgBrowserToIUnknown*(x: ptr ICommDlgBrowser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICommDlgBrowser2ToICommDlgBrowser*(x: ptr ICommDlgBrowser2): ptr ICommDlgBrowser = cast[ptr ICommDlgBrowser](x) +converter winimConverterICommDlgBrowser2ToIUnknown*(x: ptr ICommDlgBrowser2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICommDlgBrowser3ToICommDlgBrowser2*(x: ptr ICommDlgBrowser3): ptr ICommDlgBrowser2 = cast[ptr ICommDlgBrowser2](x) +converter winimConverterICommDlgBrowser3ToICommDlgBrowser*(x: ptr ICommDlgBrowser3): ptr ICommDlgBrowser = cast[ptr ICommDlgBrowser](x) +converter winimConverterICommDlgBrowser3ToIUnknown*(x: ptr ICommDlgBrowser3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIColumnManagerToIUnknown*(x: ptr IColumnManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderFilterSiteToIUnknown*(x: ptr IFolderFilterSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderFilterToIUnknown*(x: ptr IFolderFilter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInputObjectSiteToIUnknown*(x: ptr IInputObjectSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInputObjectToIUnknown*(x: ptr IInputObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInputObject2ToIInputObject*(x: ptr IInputObject2): ptr IInputObject = cast[ptr IInputObject](x) +converter winimConverterIInputObject2ToIUnknown*(x: ptr IInputObject2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellIconToIUnknown*(x: ptr IShellIcon): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellBrowserToIOleWindow*(x: ptr IShellBrowser): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIShellBrowserToIUnknown*(x: ptr IShellBrowser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProfferServiceToIUnknown*(x: ptr IProfferService): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItemToIUnknown*(x: ptr IShellItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItem2ToIShellItem*(x: ptr IShellItem2): ptr IShellItem = cast[ptr IShellItem](x) +converter winimConverterIShellItem2ToIUnknown*(x: ptr IShellItem2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItemImageFactoryToIUnknown*(x: ptr IShellItemImageFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUserAccountChangeCallbackToIUnknown*(x: ptr IUserAccountChangeCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumShellItemsToIUnknown*(x: ptr IEnumShellItems): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransferAdviseSinkToIUnknown*(x: ptr ITransferAdviseSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransferSourceToIUnknown*(x: ptr ITransferSource): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumResourcesToIUnknown*(x: ptr IEnumResources): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItemResourcesToIUnknown*(x: ptr IShellItemResources): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransferDestinationToIUnknown*(x: ptr ITransferDestination): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStreamAsyncToIStream*(x: ptr IStreamAsync): ptr IStream = cast[ptr IStream](x) +converter winimConverterIStreamAsyncToISequentialStream*(x: ptr IStreamAsync): ptr ISequentialStream = cast[ptr ISequentialStream](x) +converter winimConverterIStreamAsyncToIUnknown*(x: ptr IStreamAsync): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStreamUnbufferedInfoToIUnknown*(x: ptr IStreamUnbufferedInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileOperationProgressSinkToIUnknown*(x: ptr IFileOperationProgressSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItemArrayToIUnknown*(x: ptr IShellItemArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithItemToIUnknown*(x: ptr IInitializeWithItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithSelectionToIUnknown*(x: ptr IObjectWithSelection): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithBackReferencesToIUnknown*(x: ptr IObjectWithBackReferences): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPropertyUIToIUnknown*(x: ptr IPropertyUI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICategoryProviderToIUnknown*(x: ptr ICategoryProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICategorizerToIUnknown*(x: ptr ICategorizer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDropTargetHelperToIUnknown*(x: ptr IDropTargetHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDragSourceHelperToIUnknown*(x: ptr IDragSourceHelper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDragSourceHelper2ToIDragSourceHelper*(x: ptr IDragSourceHelper2): ptr IDragSourceHelper = cast[ptr IDragSourceHelper](x) +converter winimConverterIDragSourceHelper2ToIUnknown*(x: ptr IDragSourceHelper2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLinkAToIUnknown*(x: ptr IShellLinkA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLinkWToIUnknown*(x: ptr IShellLinkW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLinkDataListToIUnknown*(x: ptr IShellLinkDataList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIResolveShellLinkToIUnknown*(x: ptr IResolveShellLink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActionProgressDialogToIUnknown*(x: ptr IActionProgressDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHWEventHandlerToIUnknown*(x: ptr IHWEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHWEventHandler2ToIHWEventHandler*(x: ptr IHWEventHandler2): ptr IHWEventHandler = cast[ptr IHWEventHandler](x) +converter winimConverterIHWEventHandler2ToIUnknown*(x: ptr IHWEventHandler2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIQueryCancelAutoPlayToIUnknown*(x: ptr IQueryCancelAutoPlay): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDynamicHWHandlerToIUnknown*(x: ptr IDynamicHWHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActionProgressToIUnknown*(x: ptr IActionProgress): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellExtInitToIUnknown*(x: ptr IShellExtInit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellPropSheetExtToIUnknown*(x: ptr IShellPropSheetExt): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRemoteComputerToIUnknown*(x: ptr IRemoteComputer): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIQueryContinueToIUnknown*(x: ptr IQueryContinue): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithCancelEventToIUnknown*(x: ptr IObjectWithCancelEvent): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUserNotificationToIUnknown*(x: ptr IUserNotification): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUserNotificationCallbackToIUnknown*(x: ptr IUserNotificationCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUserNotification2ToIUnknown*(x: ptr IUserNotification2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIItemNameLimitsToIUnknown*(x: ptr IItemNameLimits): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchFolderItemFactoryToIUnknown*(x: ptr ISearchFolderItemFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExtractImageToIUnknown*(x: ptr IExtractImage): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExtractImage2ToIExtractImage*(x: ptr IExtractImage2): ptr IExtractImage = cast[ptr IExtractImage](x) +converter winimConverterIExtractImage2ToIUnknown*(x: ptr IExtractImage2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIThumbnailHandlerFactoryToIUnknown*(x: ptr IThumbnailHandlerFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIParentAndItemToIUnknown*(x: ptr IParentAndItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDockingWindowToIOleWindow*(x: ptr IDockingWindow): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDockingWindowToIUnknown*(x: ptr IDockingWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeskBandToIDockingWindow*(x: ptr IDeskBand): ptr IDockingWindow = cast[ptr IDockingWindow](x) +converter winimConverterIDeskBandToIOleWindow*(x: ptr IDeskBand): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDeskBandToIUnknown*(x: ptr IDeskBand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeskBandInfoToIUnknown*(x: ptr IDeskBandInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeskBand2ToIDeskBand*(x: ptr IDeskBand2): ptr IDeskBand = cast[ptr IDeskBand](x) +converter winimConverterIDeskBand2ToIDockingWindow*(x: ptr IDeskBand2): ptr IDockingWindow = cast[ptr IDockingWindow](x) +converter winimConverterIDeskBand2ToIOleWindow*(x: ptr IDeskBand2): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDeskBand2ToIUnknown*(x: ptr IDeskBand2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITaskbarListToIUnknown*(x: ptr ITaskbarList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITaskbarList2ToITaskbarList*(x: ptr ITaskbarList2): ptr ITaskbarList = cast[ptr ITaskbarList](x) +converter winimConverterITaskbarList2ToIUnknown*(x: ptr ITaskbarList2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITaskbarList3ToITaskbarList2*(x: ptr ITaskbarList3): ptr ITaskbarList2 = cast[ptr ITaskbarList2](x) +converter winimConverterITaskbarList3ToITaskbarList*(x: ptr ITaskbarList3): ptr ITaskbarList = cast[ptr ITaskbarList](x) +converter winimConverterITaskbarList3ToIUnknown*(x: ptr ITaskbarList3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITaskbarList4ToITaskbarList3*(x: ptr ITaskbarList4): ptr ITaskbarList3 = cast[ptr ITaskbarList3](x) +converter winimConverterITaskbarList4ToITaskbarList2*(x: ptr ITaskbarList4): ptr ITaskbarList2 = cast[ptr ITaskbarList2](x) +converter winimConverterITaskbarList4ToITaskbarList*(x: ptr ITaskbarList4): ptr ITaskbarList = cast[ptr ITaskbarList](x) +converter winimConverterITaskbarList4ToIUnknown*(x: ptr ITaskbarList4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStartMenuPinnedListToIUnknown*(x: ptr IStartMenuPinnedList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICDBurnToIUnknown*(x: ptr ICDBurn): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWizardSiteToIUnknown*(x: ptr IWizardSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWizardExtensionToIUnknown*(x: ptr IWizardExtension): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWebWizardExtensionToIWizardExtension*(x: ptr IWebWizardExtension): ptr IWizardExtension = cast[ptr IWizardExtension](x) +converter winimConverterIWebWizardExtensionToIUnknown*(x: ptr IWebWizardExtension): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPublishingWizardToIWizardExtension*(x: ptr IPublishingWizard): ptr IWizardExtension = cast[ptr IWizardExtension](x) +converter winimConverterIPublishingWizardToIUnknown*(x: ptr IPublishingWizard): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderViewHostToIUnknown*(x: ptr IFolderViewHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerBrowserEventsToIUnknown*(x: ptr IExplorerBrowserEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerBrowserToIUnknown*(x: ptr IExplorerBrowser): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibleObjectToIUnknown*(x: ptr IAccessibleObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIResultsFolderToIUnknown*(x: ptr IResultsFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumObjectsToIUnknown*(x: ptr IEnumObjects): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOperationsProgressDialogToIUnknown*(x: ptr IOperationsProgressDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIIOCancelInformationToIUnknown*(x: ptr IIOCancelInformation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileOperationToIUnknown*(x: ptr IFileOperation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectProviderToIUnknown*(x: ptr IObjectProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINamespaceWalkCBToIUnknown*(x: ptr INamespaceWalkCB): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINamespaceWalkCB2ToINamespaceWalkCB*(x: ptr INamespaceWalkCB2): ptr INamespaceWalkCB = cast[ptr INamespaceWalkCB](x) +converter winimConverterINamespaceWalkCB2ToIUnknown*(x: ptr INamespaceWalkCB2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINamespaceWalkToIUnknown*(x: ptr INamespaceWalk): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAutoCompleteDropDownToIUnknown*(x: ptr IAutoCompleteDropDown): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBandSiteToIUnknown*(x: ptr IBandSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIModalWindowToIUnknown*(x: ptr IModalWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICDBurnExtToIUnknown*(x: ptr ICDBurnExt): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextMenuSiteToIUnknown*(x: ptr IContextMenuSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumReadyCallbackToIUnknown*(x: ptr IEnumReadyCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumerableViewToIUnknown*(x: ptr IEnumerableView): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInsertItemToIUnknown*(x: ptr IInsertItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMenuBandToIUnknown*(x: ptr IMenuBand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFolderBandPrivToIUnknown*(x: ptr IFolderBandPriv): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRegTreeItemToIUnknown*(x: ptr IRegTreeItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIImageRecompressToIUnknown*(x: ptr IImageRecompress): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeskBarToIOleWindow*(x: ptr IDeskBar): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDeskBarToIUnknown*(x: ptr IDeskBar): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMenuPopupToIDeskBar*(x: ptr IMenuPopup): ptr IDeskBar = cast[ptr IDeskBar](x) +converter winimConverterIMenuPopupToIOleWindow*(x: ptr IMenuPopup): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIMenuPopupToIUnknown*(x: ptr IMenuPopup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileIsInUseToIUnknown*(x: ptr IFileIsInUse): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileDialogEventsToIUnknown*(x: ptr IFileDialogEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileDialogToIModalWindow*(x: ptr IFileDialog): ptr IModalWindow = cast[ptr IModalWindow](x) +converter winimConverterIFileDialogToIUnknown*(x: ptr IFileDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileSaveDialogToIFileDialog*(x: ptr IFileSaveDialog): ptr IFileDialog = cast[ptr IFileDialog](x) +converter winimConverterIFileSaveDialogToIModalWindow*(x: ptr IFileSaveDialog): ptr IModalWindow = cast[ptr IModalWindow](x) +converter winimConverterIFileSaveDialogToIUnknown*(x: ptr IFileSaveDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileOpenDialogToIFileDialog*(x: ptr IFileOpenDialog): ptr IFileDialog = cast[ptr IFileDialog](x) +converter winimConverterIFileOpenDialogToIModalWindow*(x: ptr IFileOpenDialog): ptr IModalWindow = cast[ptr IModalWindow](x) +converter winimConverterIFileOpenDialogToIUnknown*(x: ptr IFileOpenDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileDialogCustomizeToIUnknown*(x: ptr IFileDialogCustomize): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileDialogControlEventsToIUnknown*(x: ptr IFileDialogControlEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileDialog2ToIFileDialog*(x: ptr IFileDialog2): ptr IFileDialog = cast[ptr IFileDialog](x) +converter winimConverterIFileDialog2ToIModalWindow*(x: ptr IFileDialog2): ptr IModalWindow = cast[ptr IModalWindow](x) +converter winimConverterIFileDialog2ToIUnknown*(x: ptr IFileDialog2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationAssociationRegistrationToIUnknown*(x: ptr IApplicationAssociationRegistration): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationAssociationRegistrationUIToIUnknown*(x: ptr IApplicationAssociationRegistrationUI): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDelegateFolderToIUnknown*(x: ptr IDelegateFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBrowserFrameOptionsToIUnknown*(x: ptr IBrowserFrameOptions): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINewWindowManagerToIUnknown*(x: ptr INewWindowManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAttachmentExecuteToIUnknown*(x: ptr IAttachmentExecute): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellMenuCallbackToIUnknown*(x: ptr IShellMenuCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellMenuToIUnknown*(x: ptr IShellMenu): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellRunDllToIUnknown*(x: ptr IShellRunDll): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIKnownFolderToIUnknown*(x: ptr IKnownFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIKnownFolderManagerToIUnknown*(x: ptr IKnownFolderManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISharingConfigurationManagerToIUnknown*(x: ptr ISharingConfigurationManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPreviousVersionsInfoToIUnknown*(x: ptr IPreviousVersionsInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRelatedItemToIUnknown*(x: ptr IRelatedItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIIdentityNameToIRelatedItem*(x: ptr IIdentityName): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIIdentityNameToIUnknown*(x: ptr IIdentityName): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDelegateItemToIRelatedItem*(x: ptr IDelegateItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIDelegateItemToIUnknown*(x: ptr IDelegateItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICurrentItemToIRelatedItem*(x: ptr ICurrentItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterICurrentItemToIUnknown*(x: ptr ICurrentItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransferMediumItemToIRelatedItem*(x: ptr ITransferMediumItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterITransferMediumItemToIUnknown*(x: ptr ITransferMediumItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUseToBrowseItemToIRelatedItem*(x: ptr IUseToBrowseItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIUseToBrowseItemToIUnknown*(x: ptr IUseToBrowseItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDisplayItemToIRelatedItem*(x: ptr IDisplayItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIDisplayItemToIUnknown*(x: ptr IDisplayItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIViewStateIdentityItemToIRelatedItem*(x: ptr IViewStateIdentityItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIViewStateIdentityItemToIUnknown*(x: ptr IViewStateIdentityItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPreviewItemToIRelatedItem*(x: ptr IPreviewItem): ptr IRelatedItem = cast[ptr IRelatedItem](x) +converter winimConverterIPreviewItemToIUnknown*(x: ptr IPreviewItem): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDestinationStreamFactoryToIUnknown*(x: ptr IDestinationStreamFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINewMenuClientToIUnknown*(x: ptr INewMenuClient): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithBindCtxToIUnknown*(x: ptr IInitializeWithBindCtx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellItemFilterToIUnknown*(x: ptr IShellItemFilter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControlToIUnknown*(x: ptr INameSpaceTreeControl): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControl2ToINameSpaceTreeControl*(x: ptr INameSpaceTreeControl2): ptr INameSpaceTreeControl = cast[ptr INameSpaceTreeControl](x) +converter winimConverterINameSpaceTreeControl2ToIUnknown*(x: ptr INameSpaceTreeControl2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControlEventsToIUnknown*(x: ptr INameSpaceTreeControlEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControlDropHandlerToIUnknown*(x: ptr INameSpaceTreeControlDropHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeAccessibleToIUnknown*(x: ptr INameSpaceTreeAccessible): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControlCustomDrawToIUnknown*(x: ptr INameSpaceTreeControlCustomDraw): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINameSpaceTreeControlFolderCapabilitiesToIUnknown*(x: ptr INameSpaceTreeControlFolderCapabilities): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPreviewHandlerToIUnknown*(x: ptr IPreviewHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPreviewHandlerFrameToIUnknown*(x: ptr IPreviewHandlerFrame): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITrayDeskBandToIUnknown*(x: ptr ITrayDeskBand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBandHostToIUnknown*(x: ptr IBandHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerPaneVisibilityToIUnknown*(x: ptr IExplorerPaneVisibility): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIContextMenuCBToIUnknown*(x: ptr IContextMenuCB): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDefaultExtractIconInitToIUnknown*(x: ptr IDefaultExtractIconInit): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerCommandToIUnknown*(x: ptr IExplorerCommand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerCommandStateToIUnknown*(x: ptr IExplorerCommandState): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeCommandToIUnknown*(x: ptr IInitializeCommand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumExplorerCommandToIUnknown*(x: ptr IEnumExplorerCommand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExplorerCommandProviderToIUnknown*(x: ptr IExplorerCommandProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeNetworkFolderToIUnknown*(x: ptr IInitializeNetworkFolder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOpenControlPanelToIUnknown*(x: ptr IOpenControlPanel): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIComputerInfoChangeNotifyToIUnknown*(x: ptr IComputerInfoChangeNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileSystemBindDataToIUnknown*(x: ptr IFileSystemBindData): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileSystemBindData2ToIFileSystemBindData*(x: ptr IFileSystemBindData2): ptr IFileSystemBindData = cast[ptr IFileSystemBindData](x) +converter winimConverterIFileSystemBindData2ToIUnknown*(x: ptr IFileSystemBindData2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICustomDestinationListToIUnknown*(x: ptr ICustomDestinationList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationDestinationsToIUnknown*(x: ptr IApplicationDestinations): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationDocumentListsToIUnknown*(x: ptr IApplicationDocumentLists): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithAppUserModelIDToIUnknown*(x: ptr IObjectWithAppUserModelID): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectWithProgIDToIUnknown*(x: ptr IObjectWithProgID): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUpdateIDListToIUnknown*(x: ptr IUpdateIDList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDesktopGadgetToIUnknown*(x: ptr IDesktopGadget): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDesktopWallpaperToIUnknown*(x: ptr IDesktopWallpaper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHomeGroupToIUnknown*(x: ptr IHomeGroup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithPropertyStoreToIUnknown*(x: ptr IInitializeWithPropertyStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIOpenSearchSourceToIUnknown*(x: ptr IOpenSearchSource): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellLibraryToIUnknown*(x: ptr IShellLibrary): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPlaybackManagerEventsToIUnknown*(x: ptr IPlaybackManagerEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPlaybackManagerToIUnknown*(x: ptr IPlaybackManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDefaultFolderMenuInitializeToIUnknown*(x: ptr IDefaultFolderMenuInitialize): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationActivationManagerToIUnknown*(x: ptr IApplicationActivationManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAssocHandlerInvokerToIUnknown*(x: ptr IAssocHandlerInvoker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAssocHandlerToIUnknown*(x: ptr IAssocHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumAssocHandlersToIUnknown*(x: ptr IEnumAssocHandlers): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataObjectProviderToIUnknown*(x: ptr IDataObjectProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDataTransferManagerInteropToIUnknown*(x: ptr IDataTransferManagerInterop): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFrameworkInputPaneHandlerToIUnknown*(x: ptr IFrameworkInputPaneHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFrameworkInputPaneToIUnknown*(x: ptr IFrameworkInputPane): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchableApplicationToIUnknown*(x: ptr ISearchableApplication): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibilityDockingServiceCallbackToIUnknown*(x: ptr IAccessibilityDockingServiceCallback): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibilityDockingServiceToIUnknown*(x: ptr IAccessibilityDockingService): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAppVisibilityEventsToIUnknown*(x: ptr IAppVisibilityEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAppVisibilityToIUnknown*(x: ptr IAppVisibility): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPackageExecutionStateChangeNotificationToIUnknown*(x: ptr IPackageExecutionStateChangeNotification): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIPackageDebugSettingsToIUnknown*(x: ptr IPackageDebugSettings): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExecuteCommandApplicationHostEnvironmentToIUnknown*(x: ptr IExecuteCommandApplicationHostEnvironment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExecuteCommandHostToIUnknown*(x: ptr IExecuteCommandHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIApplicationDesignModeSettingsToIUnknown*(x: ptr IApplicationDesignModeSettings): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeWithWindowToIUnknown*(x: ptr IInitializeWithWindow): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHandlerInfoToIUnknown*(x: ptr IHandlerInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIHandlerActivationHostToIUnknown*(x: ptr IHandlerActivationHost): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExtractIconAToIUnknown*(x: ptr IExtractIconA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExtractIconWToIUnknown*(x: ptr IExtractIconW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellIconOverlayIdentifierToIUnknown*(x: ptr IShellIconOverlayIdentifier): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellIconOverlayManagerToIUnknown*(x: ptr IShellIconOverlayManager): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellIconOverlayToIUnknown*(x: ptr IShellIconOverlay): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellExecuteHookAToIUnknown*(x: ptr IShellExecuteHookA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellExecuteHookWToIUnknown*(x: ptr IShellExecuteHookW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIURLSearchHookToIUnknown*(x: ptr IURLSearchHook): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISearchContextToIUnknown*(x: ptr ISearchContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIURLSearchHook2ToIURLSearchHook*(x: ptr IURLSearchHook2): ptr IURLSearchHook = cast[ptr IURLSearchHook](x) +converter winimConverterIURLSearchHook2ToIUnknown*(x: ptr IURLSearchHook2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINewShortcutHookAToIUnknown*(x: ptr INewShortcutHookA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINewShortcutHookWToIUnknown*(x: ptr INewShortcutHookW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICopyHookAToIUnknown*(x: ptr ICopyHookA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICopyHookWToIUnknown*(x: ptr ICopyHookW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileViewerSiteToIUnknown*(x: ptr IFileViewerSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileViewerAToIUnknown*(x: ptr IFileViewerA): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIFileViewerWToIUnknown*(x: ptr IFileViewerW): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellDetailsToIUnknown*(x: ptr IShellDetails): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjMgrToIUnknown*(x: ptr IObjMgr): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICurrentWorkingDirectoryToIUnknown*(x: ptr ICurrentWorkingDirectory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIACListToIUnknown*(x: ptr IACList): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIACList2ToIACList*(x: ptr IACList2): ptr IACList = cast[ptr IACList](x) +converter winimConverterIACList2ToIUnknown*(x: ptr IACList2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProgressDialogToIUnknown*(x: ptr IProgressDialog): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDockingWindowSiteToIOleWindow*(x: ptr IDockingWindowSite): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDockingWindowSiteToIUnknown*(x: ptr IDockingWindowSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDockingWindowFrameToIOleWindow*(x: ptr IDockingWindowFrame): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDockingWindowFrameToIUnknown*(x: ptr IDockingWindowFrame): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIThumbnailCaptureToIUnknown*(x: ptr IThumbnailCapture): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIEnumShellImageStoreToIUnknown*(x: ptr IEnumShellImageStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellImageStoreToIUnknown*(x: ptr IShellImageStore): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderBandToIUnknown*(x: ptr IShellFolderBand): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDeskBarClientToIOleWindow*(x: ptr IDeskBarClient): ptr IOleWindow = cast[ptr IOleWindow](x) +converter winimConverterIDeskBarClientToIUnknown*(x: ptr IDeskBarClient): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveDesktopToIUnknown*(x: ptr IActiveDesktop): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIActiveDesktopPToIUnknown*(x: ptr IActiveDesktopP): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIADesktopP2ToIUnknown*(x: ptr IADesktopP2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIColumnProviderToIUnknown*(x: ptr IColumnProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellChangeNotifyToIUnknown*(x: ptr IShellChangeNotify): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIQueryInfoToIUnknown*(x: ptr IQueryInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDefViewFrameToIUnknown*(x: ptr IDefViewFrame): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDocViewSiteToIUnknown*(x: ptr IDocViewSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInitializeObjectToIUnknown*(x: ptr IInitializeObject): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIBanneredBarToIUnknown*(x: ptr IBanneredBar): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderViewCBToIUnknown*(x: ptr IShellFolderViewCB): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIShellFolderViewToIUnknown*(x: ptr IShellFolderView): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterINamedPropertyBagToIUnknown*(x: ptr INamedPropertyBag): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + DRAGINFO* = DRAGINFOW + LPDRAGINFO* = LPDRAGINFOW + SHFILEOPSTRUCT* = SHFILEOPSTRUCTW + LPSHFILEOPSTRUCT* = LPSHFILEOPSTRUCTW + SHNAMEMAPPING* = SHNAMEMAPPINGW + LPSHNAMEMAPPING* = LPSHNAMEMAPPINGW + SHELLEXECUTEINFO* = SHELLEXECUTEINFOW + LPSHELLEXECUTEINFO* = LPSHELLEXECUTEINFOW + NOTIFYICONDATA* = NOTIFYICONDATAW + PNOTIFYICONDATA* = PNOTIFYICONDATAW + SHFILEINFO* = SHFILEINFOW + OPEN_PRINTER_PROPS_INFO* = OPEN_PRINTER_PROPS_INFOW + POPEN_PRINTER_PROPS_INFO* = POPEN_PRINTER_PROPS_INFOW + IExtractIcon* = IExtractIconW + LPEXTRACTICON* = LPEXTRACTICONW + IShellExecuteHook* = IShellExecuteHookW + INewShortcutHook* = INewShortcutHookW + ICopyHook* = ICopyHookW + LPCOPYHOOK* = LPCOPYHOOKW + IFileViewer* = IFileViewerW + LPFILEVIEWER* = LPFILEVIEWERW + BROWSEINFO* = BROWSEINFOW + PBROWSEINFO* = PBROWSEINFOW + LPBROWSEINFO* = LPBROWSEINFOW + FILEDESCRIPTOR* = FILEDESCRIPTORW + LPFILEDESCRIPTOR* = LPFILEDESCRIPTORW + FILEGROUPDESCRIPTOR* = FILEGROUPDESCRIPTORW + LPFILEGROUPDESCRIPTOR* = LPFILEGROUPDESCRIPTORW + const + SZ_CONTENTTYPE_HTML* = SZ_CONTENTTYPE_HTMLW + SZ_CONTENTTYPE_CDF* = SZ_CONTENTTYPE_CDFW + IID_IFileViewer* = IID_IFileViewerW + IID_IShellLink* = IID_IShellLinkW + IID_IExtractIcon* = IID_IExtractIconW + IID_IShellCopyHook* = IID_IShellCopyHookW + IID_IShellExecuteHook* = IID_IShellExecuteHookW + IID_INewShortcutHook* = IID_INewShortcutHookW + IID_IUniformResourceLocator* = IID_IUniformResourceLocatorW + GCS_VERB* = GCS_VERBW + GCS_HELPTEXT* = GCS_HELPTEXTW + GCS_VALIDATE* = GCS_VALIDATEW + CMDSTR_NEWFOLDER* = CMDSTR_NEWFOLDERW + CMDSTR_VIEWLIST* = CMDSTR_VIEWLISTW + CMDSTR_VIEWDETAILS* = CMDSTR_VIEWDETAILSW + BFFM_SETSTATUSTEXT* = BFFM_SETSTATUSTEXTW + BFFM_SETSELECTION* = BFFM_SETSELECTIONW + BFFM_VALIDATEFAILED* = BFFM_VALIDATEFAILEDW + CFSTR_FILEDESCRIPTOR* = CFSTR_FILEDESCRIPTORW + CFSTR_FILENAME* = CFSTR_FILENAMEW + CFSTR_FILENAMEMAP* = CFSTR_FILENAMEMAPW + CFSTR_INETURL* = CFSTR_INETURLW + SHCNF_PATH* = SHCNF_PATHW + SHCNF_PRINTER* = SHCNF_PRINTERW + SHARD_PATH* = SHARD_PATHW + proc StrFormatByteSize64*(qdw: LONGLONG, szBuf: LPWSTR, uiBufSize: UINT): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatByteSizeW".} + proc StrCat*(psz1: LPWSTR, psz2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCatW".} + proc StrCmp*(psz1: LPCWSTR, psz2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpW".} + proc StrCmpI*(psz1: LPCWSTR, psz2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpIW".} + proc StrCpy*(psz1: LPWSTR, psz2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCpyW".} + proc StrCpyN*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCpyNW".} + proc DragQueryFile*(hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc: "DragQueryFileW".} + proc ShellExecute*(hwnd: HWND, lpOperation: LPCWSTR, lpFile: LPCWSTR, lpParameters: LPCWSTR, lpDirectory: LPCWSTR, nShowCmd: INT): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc: "ShellExecuteW".} + proc FindExecutable*(lpFile: LPCWSTR, lpDirectory: LPCWSTR, lpResult: LPWSTR): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc: "FindExecutableW".} + proc ShellAbout*(hWnd: HWND, szApp: LPCWSTR, szOtherStuff: LPCWSTR, hIcon: HICON): INT {.winapi, stdcall, dynlib: "shell32", importc: "ShellAboutW".} + proc ExtractAssociatedIcon*(hInst: HINSTANCE, pszIconPath: LPWSTR, piIcon: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconW".} + proc ExtractAssociatedIconEx*(hInst: HINSTANCE, pszIconPath: LPWSTR, piIconIndex: ptr WORD, piIconId: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconExW".} + proc ExtractIcon*(hInst: HINSTANCE, pszExeFileName: LPCWSTR, nIconIndex: UINT): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractIconW".} + proc DoEnvironmentSubst*(pszSrc: LPWSTR, cchSrc: UINT): DWORD {.winapi, stdcall, dynlib: "shell32", importc: "DoEnvironmentSubstW".} + proc ExtractIconEx*(lpszFile: LPCWSTR, nIconIndex: int32, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIcons: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc: "ExtractIconExW".} + proc SHFileOperation*(lpFileOp: LPSHFILEOPSTRUCTW): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHFileOperationW".} + proc ShellExecuteEx*(pExecInfo: ptr SHELLEXECUTEINFOW): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "ShellExecuteExW".} + proc SHQueryRecycleBin*(pszRootPath: LPCWSTR, pSHQueryRBInfo: LPSHQUERYRBINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHQueryRecycleBinW".} + proc SHEmptyRecycleBin*(hwnd: HWND, pszRootPath: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHEmptyRecycleBinW".} + proc Shell_NotifyIcon*(dwMessage: DWORD, lpData: PNOTIFYICONDATAW): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "Shell_NotifyIconW".} + proc SHGetFileInfo*(pszPath: LPCWSTR, dwFileAttributes: DWORD, psfi: ptr SHFILEINFOW, cbFileInfo: UINT, uFlags: UINT): DWORD_PTR {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFileInfoW".} + proc SHGetDiskFreeSpace*(pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDiskFreeSpaceExW".} + proc SHGetDiskFreeSpaceEx*(pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDiskFreeSpaceExW".} + proc SHGetNewLinkInfo*(pszLinkTo: LPCWSTR, pszDir: LPCWSTR, pszName: LPWSTR, pfMustCopy: ptr WINBOOL, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetNewLinkInfoW".} + proc SHInvokePrinterCommand*(hwnd: HWND, uAction: UINT, lpBuf1: LPCWSTR, lpBuf2: LPCWSTR, fModal: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHInvokePrinterCommandW".} + proc ShellMessageBox*(hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCWSTR, lpcTitle: LPCWSTR, fuStyle: UINT): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "ShellMessageBoxW".} + proc IsLFNDrive*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "IsLFNDriveW".} + proc SHEnumerateUnreadMailAccounts*(hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPWSTR, cchMailAddress: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHEnumerateUnreadMailAccountsW".} + proc SHGetUnreadMailCount*(hKeyUser: HKEY, pszMailAddress: LPCWSTR, pdwCount: ptr DWORD, pFileTime: ptr FILETIME, pszShellExecuteCommand: LPWSTR, cchShellExecuteCommand: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetUnreadMailCountW".} + proc SHSetUnreadMailCount*(pszMailAddress: LPCWSTR, dwCount: DWORD, pszShellExecuteCommand: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHSetUnreadMailCountW".} + proc StrRetToStr*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, ppsz: ptr LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRetToStrW".} + proc StrRetToBuf*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, pszBuf: LPWSTR, cchBuf: UINT): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRetToBufW".} + proc SHStrDup*(psz: LPCWSTR, ppwsz: ptr ptr WCHAR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "SHStrDupW".} + proc IsCharSpace*(wch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "IsCharSpaceW".} + proc StrCmpC*(pszStr1: LPCWSTR, pszStr2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpCW".} + proc StrCmpIC*(pszStr1: LPCWSTR, pszStr2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpICW".} + proc StrChr*(lpStart: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrChrW".} + proc StrRChr*(lpStart: LPCWSTR, lpEnd: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRChrW".} + proc StrChrI*(lpStart: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrChrIW".} + proc StrRChrI*(lpStart: LPCWSTR, lpEnd: LPCWSTR, wMatch: WCHAR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRChrIW".} + proc StrCmpN*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNW".} + proc StrCmpNI*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNIW".} + proc StrStr*(lpFirst: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrStrW".} + proc StrStrI*(lpFirst: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrStrIW".} + proc StrDup*(lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrDupW".} + proc StrRStrI*(lpSource: LPCWSTR, lpLast: LPCWSTR, lpSrch: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRStrIW".} + proc StrCSpn*(lpStr: LPCWSTR, lpSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCSpnW".} + proc StrCSpnI*(lpStr: LPCWSTR, lpSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCSpnIW".} + proc StrSpn*(psz: LPCWSTR, pszSet: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrSpnW".} + proc StrToInt*(lpSrc: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntW".} + proc StrPBrk*(psz: LPCWSTR, pszSet: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrPBrkW".} + proc StrToIntEx*(pszString: LPCWSTR, dwFlags: DWORD, piRet: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntExW".} + proc StrToInt64Ex*(pszString: LPCWSTR, dwFlags: DWORD, pllRet: ptr LONGLONG): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToInt64ExW".} + proc StrFromTimeInterval*(pszOut: LPWSTR, cchMax: UINT, dwTimeMS: DWORD, digits: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFromTimeIntervalW".} + proc StrFormatByteSize*(qdw: LONGLONG, szBuf: LPWSTR, uiBufSize: UINT): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatByteSizeW".} + proc StrFormatKBSize*(qdw: LONGLONG, szBuf: LPWSTR, uiBufSize: UINT): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatKBSizeW".} + proc StrNCat*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrNCatW".} + proc StrTrim*(psz: LPWSTR, pszTrimChars: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrTrimW".} + proc StrCatBuff*(pszDest: LPWSTR, pszSrc: LPCWSTR, cchDestBuffSize: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCatBuffW".} + proc ChrCmpI*(w1: WCHAR, w2: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "ChrCmpIW".} + proc wvnsprintf*(lpOut: LPWSTR, cchLimitIn: int32, lpFmt: LPCWSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "wvnsprintfW".} + proc wnsprintf*(lpOut: LPWSTR, cchLimitIn: int32, lpFmt: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "wnsprintfW".} + proc StrIsIntlEqual*(fCaseSens: WINBOOL, lpString1: LPCWSTR, lpString2: LPCWSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrIsIntlEqualW".} + proc StrToLong*(lpSrc: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntW".} + proc StrNCmp*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNW".} + proc StrNCmpI*(lpStr1: LPCWSTR, lpStr2: LPCWSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNIW".} + proc StrNCpy*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCpyNW".} + proc StrCatN*(psz1: LPWSTR, psz2: LPCWSTR, cchMax: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrNCatW".} + proc PathAddBackslash*(pszPath: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAddBackslashW".} + proc PathAddExtension*(pszPath: LPWSTR, pszExt: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAddExtensionW".} + proc PathBuildRoot*(pszRoot: LPWSTR, iDrive: int32): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathBuildRootW".} + proc PathCombine*(pszDest: LPWSTR, pszDir: LPCWSTR, pszFile: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCombineW".} + proc PathFileExists*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFileExistsW".} + proc PathFindExtension*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindExtensionW".} + proc PathFindFileName*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindFileNameW".} + proc PathFindNextComponent*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindNextComponentW".} + proc PathGetArgs*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetArgsW".} + proc PathFindSuffixArray*(pszPath: LPCWSTR, apszSuffix: ptr LPCWSTR, iArraySize: int32): LPCWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindSuffixArrayW".} + proc PathIsLFNFileSpec*(lpName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsLFNFileSpecW".} + proc PathGetDriveNumber*(pszPath: LPCWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetDriveNumberW".} + proc PathIsDirectory*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsDirectoryW".} + proc PathIsDirectoryEmpty*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsDirectoryEmptyW".} + proc PathIsFileSpec*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsFileSpecW".} + proc PathIsPrefix*(pszPrefix: LPCWSTR, pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsPrefixW".} + proc PathIsRelative*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsRelativeW".} + proc PathIsRoot*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsRootW".} + proc PathIsSameRoot*(pszPath1: LPCWSTR, pszPath2: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsSameRootW".} + proc PathIsUNC*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCW".} + proc PathIsNetworkPath*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsNetworkPathW".} + proc PathIsUNCServer*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCServerW".} + proc PathIsUNCServerShare*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCServerShareW".} + proc PathIsURL*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsURLW".} + proc PathRemoveBackslash*(pszPath: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveBackslashW".} + proc PathSkipRoot*(pszPath: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSkipRootW".} + proc PathStripPath*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathStripPathW".} + proc PathStripToRoot*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathStripToRootW".} + proc PathMakeSystemFolder*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMakeSystemFolderW".} + proc PathUnmakeSystemFolder*(pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnmakeSystemFolderW".} + proc PathIsSystemFolder*(pszPath: LPCWSTR, dwAttrb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsSystemFolderW".} + proc PathUndecorate*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUndecorateW".} + proc PathUnExpandEnvStrings*(pszPath: LPCWSTR, pszBuf: LPWSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnExpandEnvStringsW".} + proc PathAppend*(pszPath: LPWSTR, pMore: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAppendW".} + proc PathCanonicalize*(pszBuf: LPWSTR, pszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCanonicalizeW".} + proc PathCompactPath*(hDC: HDC, pszPath: LPWSTR, dx: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCompactPathW".} + proc PathCompactPathEx*(pszOut: LPWSTR, pszSrc: LPCWSTR, cchMax: UINT, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCompactPathExW".} + proc PathCommonPrefix*(pszFile1: LPCWSTR, pszFile2: LPCWSTR, achPath: LPWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCommonPrefixW".} + proc PathFindOnPath*(pszPath: LPWSTR, ppszOtherDirs: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindOnPathW".} + proc PathGetCharType*(ch: WCHAR): UINT {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetCharTypeW".} + proc PathIsContentType*(pszPath: LPCWSTR, pszContentType: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsContentTypeW".} + proc PathMakePretty*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMakePrettyW".} + proc PathMatchSpec*(pszFile: LPCWSTR, pszSpec: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMatchSpecW".} + proc PathParseIconLocation*(pszIconFile: LPWSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathParseIconLocationW".} + proc PathQuoteSpaces*(lpsz: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathQuoteSpacesW".} + proc PathRelativePathTo*(pszPath: LPWSTR, pszFrom: LPCWSTR, dwAttrFrom: DWORD, pszTo: LPCWSTR, dwAttrTo: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRelativePathToW".} + proc PathRemoveArgs*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveArgsW".} + proc PathRemoveBlanks*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveBlanksW".} + proc PathRemoveExtension*(pszPath: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveExtensionW".} + proc PathRemoveFileSpec*(pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveFileSpecW".} + proc PathRenameExtension*(pszPath: LPWSTR, pszExt: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRenameExtensionW".} + proc PathSearchAndQualify*(pszPath: LPCWSTR, pszBuf: LPWSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSearchAndQualifyW".} + proc PathSetDlgItemPath*(hDlg: HWND, id: int32, pszPath: LPCWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSetDlgItemPathW".} + proc PathUnquoteSpaces*(lpsz: LPWSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnquoteSpacesW".} + proc UrlCompare*(psz1: LPCWSTR, psz2: LPCWSTR, fIgnoreSlash: WINBOOL): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCompareW".} + proc UrlCombine*(pszBase: LPCWSTR, pszRelative: LPCWSTR, pszCombined: LPWSTR, pcchCombined: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCombineW".} + proc UrlCanonicalize*(pszUrl: LPCWSTR, pszCanonicalized: LPWSTR, pcchCanonicalized: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCanonicalizeW".} + proc UrlIsOpaque*(pszURL: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlIsOpaqueW".} + proc UrlGetLocation*(psz1: LPCWSTR): LPCWSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlGetLocationW".} + proc UrlUnescape*(pszUrl: LPWSTR, pszUnescaped: LPWSTR, pcchUnescaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlUnescapeW".} + proc UrlEscape*(pszUrl: LPCWSTR, pszEscaped: LPWSTR, pcchEscaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlEscapeW".} + proc UrlCreateFromPath*(pszPath: LPCWSTR, pszUrl: LPWSTR, pcchUrl: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCreateFromPathW".} + proc PathCreateFromUrl*(pszUrl: LPCWSTR, pszPath: LPWSTR, pcchPath: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCreateFromUrlW".} + proc UrlHash*(pszUrl: LPCWSTR, pbHash: LPBYTE, cbHash: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlHashW".} + proc UrlGetPart*(pszIn: LPCWSTR, pszOut: LPWSTR, pcchOut: LPDWORD, dwPart: DWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlGetPartW".} + proc UrlApplyScheme*(pszIn: LPCWSTR, pszOut: LPWSTR, pcchOut: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlApplySchemeW".} + proc UrlIs*(pszUrl: LPCWSTR, UrlIs: TURLIS): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlIsW".} + proc SHDeleteEmptyKey*(hkey: HKEY, pszSubKey: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteEmptyKeyW".} + proc SHDeleteKey*(hkey: HKEY, pszSubKey: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteKeyW".} + proc SHDeleteValue*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteValueW".} + proc SHGetValue*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHGetValueW".} + proc SHSetValue*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, dwType: DWORD, pvData: LPCVOID, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHSetValueW".} + proc SHRegGetValue*(hkey: HKEY, pszSubKey: LPCWSTR, pszValue: LPCWSTR, dwFlags: SRRF, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetValueW".} + proc SHQueryValueEx*(hkey: HKEY, pszValue: LPCWSTR, pdwReserved: ptr DWORD, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHQueryValueExW".} + proc SHEnumKeyEx*(hkey: HKEY, dwIndex: DWORD, pszName: LPWSTR, pcchName: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHEnumKeyExW".} + proc SHEnumValue*(hkey: HKEY, dwIndex: DWORD, pszValueName: LPWSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHEnumValueW".} + proc SHQueryInfoKey*(hkey: HKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHQueryInfoKeyW".} + proc SHCopyKey*(hkeySrc: HKEY, wszSrcSubKey: LPCWSTR, hkeyDest: HKEY, fReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHCopyKeyW".} + proc SHRegGetPath*(hKey: HKEY, pcszSubKey: LPCWSTR, pcszValue: LPCWSTR, pszPath: LPWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetPathW".} + proc SHRegSetPath*(hKey: HKEY, pcszSubKey: LPCWSTR, pcszValue: LPCWSTR, pcszPath: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegSetPathW".} + proc SHRegCreateUSKey*(pwzPath: LPCWSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegCreateUSKeyW".} + proc SHRegOpenUSKey*(pwzPath: LPCWSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, fIgnoreHKCU: WINBOOL): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegOpenUSKeyW".} + proc SHRegQueryUSValue*(hUSKey: HUSKEY, pwzValue: LPCWSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegQueryUSValueW".} + proc SHRegWriteUSValue*(hUSKey: HUSKEY, pwzValue: LPCWSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegWriteUSValueW".} + proc SHRegDeleteUSValue*(hUSKey: HUSKEY, pwzValue: LPCWSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegDeleteUSValueW".} + proc SHRegDeleteEmptyUSKey*(hUSKey: HUSKEY, pwzSubKey: LPCWSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegDeleteEmptyUSKeyW".} + proc SHRegEnumUSKey*(hUSKey: HUSKEY, dwIndex: DWORD, pwzName: LPWSTR, pcchName: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegEnumUSKeyW".} + proc SHRegEnumUSValue*(hUSkey: HUSKEY, dwIndex: DWORD, pszValueName: LPWSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegEnumUSValueW".} + proc SHRegQueryInfoUSKey*(hUSKey: HUSKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegQueryInfoUSKeyW".} + proc SHRegGetUSValue*(pwzSubKey: LPCWSTR, pwzValue: LPCWSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetUSValueW".} + proc SHRegSetUSValue*(pwzSubKey: LPCWSTR, pwzValue: LPCWSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegSetUSValueW".} + proc SHRegGetInt*(hk: HKEY, pwzKey: LPCWSTR, iDefault: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetIntW".} + proc SHRegGetBoolUSValue*(pszSubKey: LPCWSTR, pszValue: LPCWSTR, fIgnoreHKCU: WINBOOL, fDefault: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetBoolUSValueW".} + proc AssocQueryString*(flags: ASSOCF, str: ASSOCSTR, pszAssoc: LPCWSTR, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryStringW".} + proc AssocQueryStringByKey*(flags: ASSOCF, str: ASSOCSTR, hkAssoc: HKEY, pszExtra: LPCWSTR, pszOut: LPWSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryStringByKeyW".} + proc AssocQueryKey*(flags: ASSOCF, key: ASSOCKEY, pszAssoc: LPCWSTR, pszExtra: LPCWSTR, phkeyOut: ptr HKEY): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryKeyW".} + proc SHOpenRegStream2*(hkey: HKEY, pszSubkey: LPCWSTR, pszValue: LPCWSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc: "SHOpenRegStream2W".} + proc SHCreateStreamOnFile*(pszFile: LPCWSTR, grfMode: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "SHCreateStreamOnFileW".} + proc SHOpenRegStream*(hkey: HKEY, pszSubkey: LPCWSTR, pszValue: LPCWSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc: "SHOpenRegStream2W".} + proc GetAcceptLanguages*(psz: LPWSTR, pcch: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "GetAcceptLanguagesW".} + proc SHGetIconOverlayIndex*(pszIconPath: LPCWSTR, iIconIndex: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHGetIconOverlayIndexW".} + proc ILCreateFromPath*(pszPath: PCWSTR): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc: "ILCreateFromPathW".} + proc SHGetPathFromIDList*(pidl: PCIDLIST_ABSOLUTE, pszPath: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetPathFromIDListW".} + proc SHCreateDirectoryEx*(hwnd: HWND, pszPath: LPCWSTR, psa: ptr SECURITY_ATTRIBUTES): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHCreateDirectoryExW".} + proc SHGetSpecialFolderPath*(hwnd: HWND, pszPath: LPWSTR, csidl: int32, fCreate: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetSpecialFolderPathW".} + proc SHGetFolderPath*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFolderPathW".} + proc SHSetFolderPath*(csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHSetFolderPathW".} + proc SHGetFolderPathAndSubDir*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszSubDir: LPCWSTR, pszPath: LPWSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFolderPathAndSubDirW".} + proc SHBrowseForFolder*(lpbi: LPBROWSEINFOW): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc: "SHBrowseForFolderW".} + proc SHUpdateImage*(pszHashItem: LPCWSTR, iIndex: int32, uFlags: UINT, iImageIndex: int32): void {.winapi, stdcall, dynlib: "shell32", importc: "SHUpdateImageW".} + proc SHGetDataFromIDList*(psf: ptr IShellFolder, pidl: PCUITEMID_CHILD, nFormat: int32, pv: pointer, cb: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDataFromIDListW".} + proc PathIsSlow*(pszFile: LPCWSTR, dwAttr: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "PathIsSlowW".} + proc SHStartNetConnectionDialog*(hwnd: HWND, pszRemoteName: LPCWSTR, dwType: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHStartNetConnectionDialogW".} + proc SHDefExtractIcon*(pszIconFile: LPCWSTR, iIndex: int32, uFlags: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHDefExtractIconW".} + proc Shell_GetCachedImageIndex*(pszIconPath: LPCWSTR, iIconIndex: int32, uIconFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc: "Shell_GetCachedImageIndexW".} + proc SHOpenPropSheet*(pszCaption: LPCWSTR, ahkeys: ptr HKEY, ckeys: UINT, pclsidDefault: ptr CLSID, pdtobj: ptr IDataObject, psb: ptr IShellBrowser, pStartPage: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHOpenPropSheetW".} + proc SHPathPrepareForWrite*(hwnd: HWND, punkEnableModless: ptr IUnknown, pszPath: LPCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHPathPrepareForWriteW".} + proc SHCreateFileExtractIcon*(pszFile: LPCWSTR, dwFileAttributes: DWORD, riid: REFIID, ppv: ptr pointer): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHCreateFileExtractIconW".} +when winimAnsi: + type + DRAGINFO* = DRAGINFOA + LPDRAGINFO* = LPDRAGINFOA + SHFILEOPSTRUCT* = SHFILEOPSTRUCTA + LPSHFILEOPSTRUCT* = LPSHFILEOPSTRUCTA + SHNAMEMAPPING* = SHNAMEMAPPINGA + LPSHNAMEMAPPING* = LPSHNAMEMAPPINGA + SHELLEXECUTEINFO* = SHELLEXECUTEINFOA + LPSHELLEXECUTEINFO* = LPSHELLEXECUTEINFOA + NOTIFYICONDATA* = NOTIFYICONDATAA + PNOTIFYICONDATA* = PNOTIFYICONDATAA + SHFILEINFO* = SHFILEINFOA + OPEN_PRINTER_PROPS_INFO* = OPEN_PRINTER_PROPS_INFOA + POPEN_PRINTER_PROPS_INFO* = POPEN_PRINTER_PROPS_INFOA + IExtractIcon* = IExtractIconA + LPEXTRACTICON* = LPEXTRACTICONA + IShellExecuteHook* = IShellExecuteHookA + INewShortcutHook* = INewShortcutHookA + ICopyHook* = ICopyHookA + LPCOPYHOOK* = LPCOPYHOOKA + IFileViewer* = IFileViewerA + LPFILEVIEWER* = LPFILEVIEWERA + BROWSEINFO* = BROWSEINFOA + PBROWSEINFO* = PBROWSEINFOA + LPBROWSEINFO* = LPBROWSEINFOA + FILEDESCRIPTOR* = FILEDESCRIPTORA + LPFILEDESCRIPTOR* = LPFILEDESCRIPTORA + FILEGROUPDESCRIPTOR* = FILEGROUPDESCRIPTORA + LPFILEGROUPDESCRIPTOR* = LPFILEGROUPDESCRIPTORA + const + SZ_CONTENTTYPE_HTML* = SZ_CONTENTTYPE_HTMLA + SZ_CONTENTTYPE_CDF* = SZ_CONTENTTYPE_CDFA + IID_IFileViewer* = IID_IFileViewerA + IID_IShellLink* = IID_IShellLinkA + IID_IExtractIcon* = IID_IExtractIconA + IID_IShellCopyHook* = IID_IShellCopyHookA + IID_IShellExecuteHook* = IID_IShellExecuteHookA + IID_INewShortcutHook* = IID_INewShortcutHookA + IID_IUniformResourceLocator* = IID_IUniformResourceLocatorA + GCS_VERB* = GCS_VERBA + GCS_HELPTEXT* = GCS_HELPTEXTA + GCS_VALIDATE* = GCS_VALIDATEA + CMDSTR_NEWFOLDER* = CMDSTR_NEWFOLDERA + CMDSTR_VIEWLIST* = CMDSTR_VIEWLISTA + CMDSTR_VIEWDETAILS* = CMDSTR_VIEWDETAILSA + BFFM_SETSTATUSTEXT* = BFFM_SETSTATUSTEXTA + BFFM_SETSELECTION* = BFFM_SETSELECTIONA + BFFM_VALIDATEFAILED* = BFFM_VALIDATEFAILEDA + CFSTR_FILEDESCRIPTOR* = CFSTR_FILEDESCRIPTORA + CFSTR_FILENAME* = CFSTR_FILENAMEA + CFSTR_FILENAMEMAP* = CFSTR_FILENAMEMAPA + CFSTR_INETURL* = CFSTR_INETURLA + SHCNF_PATH* = SHCNF_PATHA + SHCNF_PRINTER* = SHCNF_PRINTERA + SHARD_PATH* = SHARD_PATHA + proc StrFormatByteSize64*(qdw: LONGLONG, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatByteSize64A".} + proc DragQueryFile*(hDrop: HDROP, iFile: UINT, lpszFile: LPSTR, cch: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc: "DragQueryFileA".} + proc ShellExecute*(hwnd: HWND, lpOperation: LPCSTR, lpFile: LPCSTR, lpParameters: LPCSTR, lpDirectory: LPCSTR, nShowCmd: INT): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc: "ShellExecuteA".} + proc FindExecutable*(lpFile: LPCSTR, lpDirectory: LPCSTR, lpResult: LPSTR): HINSTANCE {.winapi, stdcall, dynlib: "shell32", importc: "FindExecutableA".} + proc ShellAbout*(hWnd: HWND, szApp: LPCSTR, szOtherStuff: LPCSTR, hIcon: HICON): INT {.winapi, stdcall, dynlib: "shell32", importc: "ShellAboutA".} + proc ExtractAssociatedIcon*(hInst: HINSTANCE, pszIconPath: LPSTR, piIcon: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconA".} + proc ExtractAssociatedIconEx*(hInst: HINSTANCE, pszIconPath: LPSTR, piIconIndex: ptr WORD, piIconId: ptr WORD): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconExA".} + proc ExtractIcon*(hInst: HINSTANCE, pszExeFileName: LPCSTR, nIconIndex: UINT): HICON {.winapi, stdcall, dynlib: "shell32", importc: "ExtractIconA".} + proc DoEnvironmentSubst*(pszSrc: LPSTR, cchSrc: UINT): DWORD {.winapi, stdcall, dynlib: "shell32", importc: "DoEnvironmentSubstA".} + proc ExtractIconEx*(lpszFile: LPCSTR, nIconIndex: int32, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIcons: UINT): UINT {.winapi, stdcall, dynlib: "shell32", importc: "ExtractIconExA".} + proc SHFileOperation*(lpFileOp: LPSHFILEOPSTRUCTA): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHFileOperationA".} + proc ShellExecuteEx*(pExecInfo: ptr SHELLEXECUTEINFOA): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "ShellExecuteExA".} + proc SHQueryRecycleBin*(pszRootPath: LPCSTR, pSHQueryRBInfo: LPSHQUERYRBINFO): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHQueryRecycleBinA".} + proc SHEmptyRecycleBin*(hwnd: HWND, pszRootPath: LPCSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHEmptyRecycleBinA".} + proc Shell_NotifyIcon*(dwMessage: DWORD, lpData: PNOTIFYICONDATAA): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "Shell_NotifyIconA".} + proc SHGetFileInfo*(pszPath: LPCSTR, dwFileAttributes: DWORD, psfi: ptr SHFILEINFOA, cbFileInfo: UINT, uFlags: UINT): DWORD_PTR {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFileInfoA".} + proc SHGetDiskFreeSpace*(pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDiskFreeSpaceExA".} + proc SHGetDiskFreeSpaceEx*(pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: ptr ULARGE_INTEGER, pulTotalNumberOfBytes: ptr ULARGE_INTEGER, pulTotalNumberOfFreeBytes: ptr ULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDiskFreeSpaceExA".} + proc SHGetNewLinkInfo*(pszLinkTo: LPCSTR, pszDir: LPCSTR, pszName: LPSTR, pfMustCopy: ptr WINBOOL, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetNewLinkInfoA".} + proc SHInvokePrinterCommand*(hwnd: HWND, uAction: UINT, lpBuf1: LPCSTR, lpBuf2: LPCSTR, fModal: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHInvokePrinterCommandA".} + proc ShellMessageBox*(hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCSTR, lpcTitle: LPCSTR, fuStyle: UINT): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "ShellMessageBoxA".} + proc IsLFNDrive*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "IsLFNDriveA".} + proc StrRetToStr*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, ppsz: ptr LPSTR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRetToStrA".} + proc StrRetToBuf*(pstr: ptr STRRET, pidl: LPCITEMIDLIST, pszBuf: LPSTR, cchBuf: UINT): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRetToBufA".} + proc SHStrDup*(psz: LPCSTR, ppwsz: ptr ptr WCHAR): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "SHStrDupA".} + proc IsCharSpace*(wch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "IsCharSpaceA".} + proc StrCmpC*(pszStr1: LPCSTR, pszStr2: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpCA".} + proc StrCmpIC*(pszStr1: LPCSTR, pszStr2: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpICA".} + proc StrChr*(lpStart: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrChrA".} + proc StrRChr*(lpStart: LPCSTR, lpEnd: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRChrA".} + proc StrChrI*(lpStart: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrChrIA".} + proc StrRChrI*(lpStart: LPCSTR, lpEnd: LPCSTR, wMatch: WORD): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRChrIA".} + proc StrCmpN*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNA".} + proc StrCmpNI*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNIA".} + proc StrStr*(lpFirst: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrStrA".} + proc StrStrI*(lpFirst: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrStrIA".} + proc StrDup*(lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrDupA".} + proc StrRStrI*(lpSource: LPCSTR, lpLast: LPCSTR, lpSrch: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrRStrIA".} + proc StrCSpn*(lpStr: LPCSTR, lpSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCSpnA".} + proc StrCSpnI*(lpStr: LPCSTR, lpSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCSpnIA".} + proc StrSpn*(psz: LPCSTR, pszSet: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrSpnA".} + proc StrToInt*(lpSrc: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntA".} + proc StrPBrk*(psz: LPCSTR, pszSet: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrPBrkA".} + proc StrToIntEx*(pszString: LPCSTR, dwFlags: DWORD, piRet: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntExA".} + proc StrToInt64Ex*(pszString: LPCSTR, dwFlags: DWORD, pllRet: ptr LONGLONG): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToInt64ExA".} + proc StrFromTimeInterval*(pszOut: LPSTR, cchMax: UINT, dwTimeMS: DWORD, digits: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFromTimeIntervalA".} + proc StrFormatByteSize*(dw: DWORD, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatByteSizeA".} + proc StrFormatKBSize*(qdw: LONGLONG, szBuf: LPSTR, uiBufSize: UINT): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrFormatKBSizeA".} + proc StrNCat*(psz1: LPSTR, psz2: LPCSTR, cchMax: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrNCatA".} + proc StrTrim*(psz: LPSTR, pszTrimChars: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrTrimA".} + proc StrCatBuff*(pszDest: LPSTR, pszSrc: LPCSTR, cchDestBuffSize: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCatBuffA".} + proc ChrCmpI*(w1: WORD, w2: WORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "ChrCmpIA".} + proc wvnsprintf*(lpOut: LPSTR, cchLimitIn: int32, lpFmt: LPCSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "wvnsprintfA".} + proc wnsprintf*(lpOut: LPSTR, cchLimitIn: int32, lpFmt: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "wnsprintfA".} + proc StrIsIntlEqual*(fCaseSens: WINBOOL, lpString1: LPCSTR, lpString2: LPCSTR, nChar: int32): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "StrIsIntlEqualA".} + proc StrToLong*(lpSrc: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrToIntA".} + proc StrNCmp*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNA".} + proc StrNCmpI*(lpStr1: LPCSTR, lpStr2: LPCSTR, nChar: int32): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "StrCmpNIA".} + proc StrCatN*(psz1: LPSTR, psz2: LPCSTR, cchMax: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "StrNCatA".} + proc PathAddBackslash*(pszPath: LPSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAddBackslashA".} + proc PathAddExtension*(pszPath: LPSTR, pszExt: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAddExtensionA".} + proc PathBuildRoot*(pszRoot: LPSTR, iDrive: int32): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathBuildRootA".} + proc PathCombine*(pszDest: LPSTR, pszDir: LPCSTR, pszFile: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCombineA".} + proc PathFileExists*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFileExistsA".} + proc PathFindExtension*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindExtensionA".} + proc PathFindFileName*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindFileNameA".} + proc PathFindNextComponent*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindNextComponentA".} + proc PathGetArgs*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetArgsA".} + proc PathFindSuffixArray*(pszPath: LPCSTR, apszSuffix: ptr LPCSTR, iArraySize: int32): LPCSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindSuffixArrayA".} + proc PathIsLFNFileSpec*(lpName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsLFNFileSpecA".} + proc PathGetDriveNumber*(pszPath: LPCSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetDriveNumberA".} + proc PathIsDirectory*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsDirectoryA".} + proc PathIsDirectoryEmpty*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsDirectoryEmptyA".} + proc PathIsFileSpec*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsFileSpecA".} + proc PathIsPrefix*(pszPrefix: LPCSTR, pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsPrefixA".} + proc PathIsRelative*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsRelativeA".} + proc PathIsRoot*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsRootA".} + proc PathIsSameRoot*(pszPath1: LPCSTR, pszPath2: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsSameRootA".} + proc PathIsUNC*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCA".} + proc PathIsNetworkPath*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsNetworkPathA".} + proc PathIsUNCServer*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCServerA".} + proc PathIsUNCServerShare*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsUNCServerShareA".} + proc PathIsURL*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsURLA".} + proc PathRemoveBackslash*(pszPath: LPSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveBackslashA".} + proc PathSkipRoot*(pszPath: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSkipRootA".} + proc PathStripPath*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathStripPathA".} + proc PathStripToRoot*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathStripToRootA".} + proc PathMakeSystemFolder*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMakeSystemFolderA".} + proc PathUnmakeSystemFolder*(pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnmakeSystemFolderA".} + proc PathIsSystemFolder*(pszPath: LPCSTR, dwAttrb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsSystemFolderA".} + proc PathUndecorate*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUndecorateA".} + proc PathUnExpandEnvStrings*(pszPath: LPCSTR, pszBuf: LPSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnExpandEnvStringsA".} + proc PathAppend*(pszPath: LPSTR, pMore: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathAppendA".} + proc PathCanonicalize*(pszBuf: LPSTR, pszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCanonicalizeA".} + proc PathCompactPath*(hDC: HDC, pszPath: LPSTR, dx: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCompactPathA".} + proc PathCompactPathEx*(pszOut: LPSTR, pszSrc: LPCSTR, cchMax: UINT, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCompactPathExA".} + proc PathCommonPrefix*(pszFile1: LPCSTR, pszFile2: LPCSTR, achPath: LPSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCommonPrefixA".} + proc PathFindOnPath*(pszPath: LPSTR, ppszOtherDirs: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathFindOnPathA".} + proc PathGetCharType*(ch: UCHAR): UINT {.winapi, stdcall, dynlib: "shlwapi", importc: "PathGetCharTypeA".} + proc PathIsContentType*(pszPath: LPCSTR, pszContentType: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathIsContentTypeA".} + proc PathMakePretty*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMakePrettyA".} + proc PathMatchSpec*(pszFile: LPCSTR, pszSpec: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathMatchSpecA".} + proc PathParseIconLocation*(pszIconFile: LPSTR): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "PathParseIconLocationA".} + proc PathQuoteSpaces*(lpsz: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathQuoteSpacesA".} + proc PathRelativePathTo*(pszPath: LPSTR, pszFrom: LPCSTR, dwAttrFrom: DWORD, pszTo: LPCSTR, dwAttrTo: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRelativePathToA".} + proc PathRemoveArgs*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveArgsA".} + proc PathRemoveBlanks*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveBlanksA".} + proc PathRemoveExtension*(pszPath: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveExtensionA".} + proc PathRemoveFileSpec*(pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRemoveFileSpecA".} + proc PathRenameExtension*(pszPath: LPSTR, pszExt: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathRenameExtensionA".} + proc PathSearchAndQualify*(pszPath: LPCSTR, pszBuf: LPSTR, cchBuf: UINT): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSearchAndQualifyA".} + proc PathSetDlgItemPath*(hDlg: HWND, id: int32, pszPath: LPCSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathSetDlgItemPathA".} + proc PathUnquoteSpaces*(lpsz: LPSTR): void {.winapi, stdcall, dynlib: "shlwapi", importc: "PathUnquoteSpacesA".} + proc UrlCompare*(psz1: LPCSTR, psz2: LPCSTR, fIgnoreSlash: WINBOOL): int32 {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCompareA".} + proc UrlCombine*(pszBase: LPCSTR, pszRelative: LPCSTR, pszCombined: LPSTR, pcchCombined: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCombineA".} + proc UrlCanonicalize*(pszUrl: LPCSTR, pszCanonicalized: LPSTR, pcchCanonicalized: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCanonicalizeA".} + proc UrlIsOpaque*(pszURL: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlIsOpaqueA".} + proc UrlGetLocation*(psz1: LPCSTR): LPCSTR {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlGetLocationA".} + proc UrlUnescape*(pszUrl: LPSTR, pszUnescaped: LPSTR, pcchUnescaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlUnescapeA".} + proc UrlEscape*(pszUrl: LPCSTR, pszEscaped: LPSTR, pcchEscaped: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlEscapeA".} + proc UrlCreateFromPath*(pszPath: LPCSTR, pszUrl: LPSTR, pcchUrl: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlCreateFromPathA".} + proc PathCreateFromUrl*(pszUrl: LPCSTR, pszPath: LPSTR, pcchPath: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "PathCreateFromUrlA".} + proc UrlHash*(pszUrl: LPCSTR, pbHash: LPBYTE, cbHash: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlHashA".} + proc UrlGetPart*(pszIn: LPCSTR, pszOut: LPSTR, pcchOut: LPDWORD, dwPart: DWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlGetPartA".} + proc UrlApplyScheme*(pszIn: LPCSTR, pszOut: LPSTR, pcchOut: LPDWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlApplySchemeA".} + proc UrlIs*(pszUrl: LPCSTR, UrlIs: TURLIS): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "UrlIsA".} + proc SHDeleteEmptyKey*(hkey: HKEY, pszSubKey: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteEmptyKeyA".} + proc SHDeleteKey*(hkey: HKEY, pszSubKey: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteKeyA".} + proc SHDeleteValue*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHDeleteValueA".} + proc SHGetValue*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHGetValueA".} + proc SHSetValue*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, dwType: DWORD, pvData: LPCVOID, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHSetValueA".} + proc SHRegGetValue*(hkey: HKEY, pszSubKey: LPCSTR, pszValue: LPCSTR, dwFlags: SRRF, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetValueA".} + proc SHQueryValueEx*(hkey: HKEY, pszValue: LPCSTR, pdwReserved: ptr DWORD, pdwType: ptr DWORD, pvData: pointer, pcbData: ptr DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHQueryValueExA".} + proc SHEnumKeyEx*(hkey: HKEY, dwIndex: DWORD, pszName: LPSTR, pcchName: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHEnumKeyExA".} + proc SHEnumValue*(hkey: HKEY, dwIndex: DWORD, pszValueName: LPSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHEnumValueA".} + proc SHQueryInfoKey*(hkey: HKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHQueryInfoKeyA".} + proc SHCopyKey*(hkeySrc: HKEY, szSrcSubKey: LPCSTR, hkeyDest: HKEY, fReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHCopyKeyA".} + proc SHRegGetPath*(hKey: HKEY, pcszSubKey: LPCSTR, pcszValue: LPCSTR, pszPath: LPSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetPathA".} + proc SHRegSetPath*(hKey: HKEY, pcszSubKey: LPCSTR, pcszValue: LPCSTR, pcszPath: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegSetPathA".} + proc SHRegCreateUSKey*(pszPath: LPCSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegCreateUSKeyA".} + proc SHRegOpenUSKey*(pszPath: LPCSTR, samDesired: REGSAM, hRelativeUSKey: HUSKEY, phNewUSKey: PHUSKEY, fIgnoreHKCU: WINBOOL): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegOpenUSKeyA".} + proc SHRegQueryUSValue*(hUSKey: HUSKEY, pszValue: LPCSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegQueryUSValueA".} + proc SHRegWriteUSValue*(hUSKey: HUSKEY, pszValue: LPCSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegWriteUSValueA".} + proc SHRegDeleteUSValue*(hUSKey: HUSKEY, pszValue: LPCSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegDeleteUSValueA".} + proc SHRegDeleteEmptyUSKey*(hUSKey: HUSKEY, pszSubKey: LPCSTR, delRegFlags: SHREGDEL_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegDeleteEmptyUSKeyA".} + proc SHRegEnumUSKey*(hUSKey: HUSKEY, dwIndex: DWORD, pszName: LPSTR, pcchName: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegEnumUSKeyA".} + proc SHRegEnumUSValue*(hUSkey: HUSKEY, dwIndex: DWORD, pszValueName: LPSTR, pcchValueName: LPDWORD, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegEnumUSValueA".} + proc SHRegQueryInfoUSKey*(hUSKey: HUSKEY, pcSubKeys: LPDWORD, pcchMaxSubKeyLen: LPDWORD, pcValues: LPDWORD, pcchMaxValueNameLen: LPDWORD, enumRegFlags: SHREGENUM_FLAGS): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegQueryInfoUSKeyA".} + proc SHRegGetUSValue*(pszSubKey: LPCSTR, pszValue: LPCSTR, pdwType: LPDWORD, pvData: pointer, pcbData: LPDWORD, fIgnoreHKCU: WINBOOL, pvDefaultData: pointer, dwDefaultDataSize: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetUSValueA".} + proc SHRegSetUSValue*(pszSubKey: LPCSTR, pszValue: LPCSTR, dwType: DWORD, pvData: pointer, cbData: DWORD, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegSetUSValueA".} + proc SHRegGetBoolUSValue*(pszSubKey: LPCSTR, pszValue: LPCSTR, fIgnoreHKCU: WINBOOL, fDefault: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shlwapi", importc: "SHRegGetBoolUSValueA".} + proc AssocQueryString*(flags: ASSOCF, str: ASSOCSTR, pszAssoc: LPCSTR, pszExtra: LPCSTR, pszOut: LPSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryStringA".} + proc AssocQueryStringByKey*(flags: ASSOCF, str: ASSOCSTR, hkAssoc: HKEY, pszExtra: LPCSTR, pszOut: LPSTR, pcchOut: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryStringByKeyA".} + proc AssocQueryKey*(flags: ASSOCF, key: ASSOCKEY, pszAssoc: LPCSTR, pszExtra: LPCSTR, phkeyOut: ptr HKEY): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "AssocQueryKeyA".} + proc SHOpenRegStream2*(hkey: HKEY, pszSubkey: LPCSTR, pszValue: LPCSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc: "SHOpenRegStream2A".} + proc SHCreateStreamOnFile*(pszFile: LPCSTR, grfMode: DWORD, ppstm: ptr ptr IStream): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "SHCreateStreamOnFileA".} + proc SHOpenRegStream*(hkey: HKEY, pszSubkey: LPCSTR, pszValue: LPCSTR, grfMode: DWORD): ptr IStream {.winapi, stdcall, dynlib: "shlwapi", importc: "SHOpenRegStream2A".} + proc GetAcceptLanguages*(psz: LPSTR, pcch: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "shlwapi", importc: "GetAcceptLanguagesA".} + proc SHGetIconOverlayIndex*(pszIconPath: LPCSTR, iIconIndex: int32): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHGetIconOverlayIndexA".} + proc ILCreateFromPath*(pszPath: PCSTR): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc: "ILCreateFromPathA".} + proc SHGetPathFromIDList*(pidl: PCIDLIST_ABSOLUTE, pszPath: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetPathFromIDListA".} + proc SHCreateDirectoryEx*(hwnd: HWND, pszPath: LPCSTR, psa: ptr SECURITY_ATTRIBUTES): int32 {.winapi, stdcall, dynlib: "shell32", importc: "SHCreateDirectoryExA".} + proc SHGetSpecialFolderPath*(hwnd: HWND, pszPath: LPSTR, csidl: int32, fCreate: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "SHGetSpecialFolderPathA".} + proc SHGetFolderPath*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFolderPathA".} + proc SHSetFolderPath*(csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszPath: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHSetFolderPathA".} + proc SHGetFolderPathAndSubDir*(hwnd: HWND, csidl: int32, hToken: HANDLE, dwFlags: DWORD, pszSubDir: LPCSTR, pszPath: LPSTR): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetFolderPathAndSubDirA".} + proc SHBrowseForFolder*(lpbi: LPBROWSEINFOA): PIDLIST_ABSOLUTE {.winapi, stdcall, dynlib: "shell32", importc: "SHBrowseForFolderA".} + proc SHUpdateImage*(pszHashItem: LPCSTR, iIndex: int32, uFlags: UINT, iImageIndex: int32): void {.winapi, stdcall, dynlib: "shell32", importc: "SHUpdateImageA".} + proc SHGetDataFromIDList*(psf: ptr IShellFolder, pidl: PCUITEMID_CHILD, nFormat: int32, pv: pointer, cb: int32): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHGetDataFromIDListA".} + proc PathIsSlow*(pszFile: LPCSTR, dwAttr: DWORD): WINBOOL {.winapi, stdcall, dynlib: "shell32", importc: "PathIsSlowA".} + proc SHDefExtractIcon*(pszIconFile: LPCSTR, iIndex: int32, uFlags: UINT, phiconLarge: ptr HICON, phiconSmall: ptr HICON, nIconSize: UINT): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHDefExtractIconA".} + proc Shell_GetCachedImageIndex*(pszIconPath: LPCSTR, iIconIndex: int32, uIconFlags: UINT): int32 {.winapi, stdcall, dynlib: "shell32", importc: "Shell_GetCachedImageIndexA".} + proc SHPathPrepareForWrite*(hwnd: HWND, punkEnableModless: ptr IUnknown, pszPath: LPCSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "shell32", importc: "SHPathPrepareForWriteA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/snmp.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/snmp.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,232 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + AsnInteger32* = LONG + AsnUnsigned32* = ULONG + AsnCounter64* = ULARGE_INTEGER + AsnCounter32* = AsnUnsigned32 + AsnGauge32* = AsnUnsigned32 + AsnTimeticks* = AsnUnsigned32 + AsnOctetString* {.pure.} = object + stream*: ptr BYTE + length*: UINT + dynamic*: WINBOOL + AsnBits* = AsnOctetString + AsnSequence* = AsnOctetString + AsnImplicitSequence* = AsnOctetString + AsnIPAddress* = AsnOctetString + AsnNetworkAddress* = AsnOctetString + AsnDisplayString* = AsnOctetString + AsnOpaque* = AsnOctetString + AsnObjectIdentifier* {.pure, packed.} = object + idLength*: UINT + ids*: ptr UINT + AsnObjectName* = AsnObjectIdentifier + AsnAny_asnValue* {.pure, union.} = object + number*: AsnInteger32 + unsigned32*: AsnUnsigned32 + counter64*: AsnCounter64 + string*: AsnOctetString + bits*: AsnBits + `object`*: AsnObjectIdentifier + sequence*: AsnSequence + address*: AsnIPAddress + counter*: AsnCounter32 + gauge*: AsnGauge32 + ticks*: AsnTimeticks + arbitrary*: AsnOpaque + AsnAny* {.pure, packed.} = object + asnType*: BYTE + padding*: array[3, byte] + asnValue*: AsnAny_asnValue + AsnObjectSyntax* = AsnAny + SnmpVarBind* {.pure.} = object + name*: AsnObjectName + value*: AsnObjectSyntax + SnmpVarBindList* {.pure, packed.} = object + list*: ptr SnmpVarBind + len*: UINT + RFC1157VarBindList* = SnmpVarBindList + RFC1157VarBind* = SnmpVarBind + AsnInteger* = AsnInteger32 + AsnCounter* = AsnCounter32 + AsnGauge* = AsnGauge32 +const + asnUNIVERSAL* = 0x00 + asnAPPLICATION* = 0x40 + asnCONTEXT* = 0x80 + asnPRIVATE* = 0xC0 + asnPRIMITIVE* = 0x00 + asnCONSTRUCTOR* = 0x20 + SNMP_PDU_GET* = asnCONTEXT or asnCONSTRUCTOR or 0x0 + SNMP_PDU_GETNEXT* = asnCONTEXT or asnCONSTRUCTOR or 0x1 + SNMP_PDU_RESPONSE* = asnCONTEXT or asnCONSTRUCTOR or 0x2 + SNMP_PDU_SET* = asnCONTEXT or asnCONSTRUCTOR or 0x3 + SNMP_PDU_V1TRAP* = asnCONTEXT or asnCONSTRUCTOR or 0x4 + SNMP_PDU_GETBULK* = asnCONTEXT or asnCONSTRUCTOR or 0x5 + SNMP_PDU_INFORM* = asnCONTEXT or asnCONSTRUCTOR or 0x6 + SNMP_PDU_TRAP* = asnCONTEXT or asnCONSTRUCTOR or 0x7 + asnINTEGER* = asnUNIVERSAL or asnPRIMITIVE or 0x02 + asnBITS* = asnUNIVERSAL or asnPRIMITIVE or 0x03 + asnOCTETSTRING* = asnUNIVERSAL or asnPRIMITIVE or 0x04 + asnNULL* = asnUNIVERSAL or asnPRIMITIVE or 0x05 + asnOBJECTIDENTIFIER* = asnUNIVERSAL or asnPRIMITIVE or 0x06 + asnINTEGER32* = asnINTEGER + asnSEQUENCE* = asnUNIVERSAL or asnCONSTRUCTOR or 0x10 + asnSEQUENCEOF* = asnSEQUENCE + asnIPADDRESS* = asnAPPLICATION or asnPRIMITIVE or 0x00 + asnCOUNTER32* = asnAPPLICATION or asnPRIMITIVE or 0x01 + asnGAUGE32* = asnAPPLICATION or asnPRIMITIVE or 0x02 + asnTIMETICKS* = asnAPPLICATION or asnPRIMITIVE or 0x03 + asnOPAQUE* = asnAPPLICATION or asnPRIMITIVE or 0x04 + asnCOUNTER64* = asnAPPLICATION or asnPRIMITIVE or 0x06 + asnUINTEGER32* = asnAPPLICATION or asnPRIMITIVE or 0x07 + asnRFC2578_UNSIGNED32* = asnGAUGE32 + SNMP_EXCEPTION_NOSUCHOBJECT* = asnCONTEXT or asnPRIMITIVE or 0x00 + SNMP_EXCEPTION_NOSUCHINSTANCE* = asnCONTEXT or asnPRIMITIVE or 0x01 + SNMP_EXCEPTION_ENDOFMIBVIEW* = asnCONTEXT or asnPRIMITIVE or 0x02 + SNMP_EXTENSION_GET* = SNMP_PDU_GET + SNMP_EXTENSION_GET_NEXT* = SNMP_PDU_GETNEXT + SNMP_EXTENSION_GET_BULK* = SNMP_PDU_GETBULK + SNMP_EXTENSION_SET_TEST* = asnPRIVATE or asnCONSTRUCTOR or 0x0 + SNMP_EXTENSION_SET_COMMIT* = SNMP_PDU_SET + SNMP_EXTENSION_SET_UNDO* = asnPRIVATE or asnCONSTRUCTOR or 0x1 + SNMP_EXTENSION_SET_CLEANUP* = asnPRIVATE or asnCONSTRUCTOR or 0x2 + SNMP_ERRORSTATUS_NOERROR* = 0 + SNMP_ERRORSTATUS_TOOBIG* = 1 + SNMP_ERRORSTATUS_NOSUCHNAME* = 2 + SNMP_ERRORSTATUS_BADVALUE* = 3 + SNMP_ERRORSTATUS_READONLY* = 4 + SNMP_ERRORSTATUS_GENERR* = 5 + SNMP_ERRORSTATUS_NOACCESS* = 6 + SNMP_ERRORSTATUS_WRONGTYPE* = 7 + SNMP_ERRORSTATUS_WRONGLENGTH* = 8 + SNMP_ERRORSTATUS_WRONGENCODING* = 9 + SNMP_ERRORSTATUS_WRONGVALUE* = 10 + SNMP_ERRORSTATUS_NOCREATION* = 11 + SNMP_ERRORSTATUS_INCONSISTENTVALUE* = 12 + SNMP_ERRORSTATUS_RESOURCEUNAVAILABLE* = 13 + SNMP_ERRORSTATUS_COMMITFAILED* = 14 + SNMP_ERRORSTATUS_UNDOFAILED* = 15 + SNMP_ERRORSTATUS_AUTHORIZATIONERROR* = 16 + SNMP_ERRORSTATUS_NOTWRITABLE* = 17 + SNMP_ERRORSTATUS_INCONSISTENTNAME* = 18 + SNMP_GENERICTRAP_COLDSTART* = 0 + SNMP_GENERICTRAP_WARMSTART* = 1 + SNMP_GENERICTRAP_LINKDOWN* = 2 + SNMP_GENERICTRAP_LINKUP* = 3 + SNMP_GENERICTRAP_AUTHFAILURE* = 4 + SNMP_GENERICTRAP_EGPNEIGHLOSS* = 5 + SNMP_GENERICTRAP_ENTERSPECIFIC* = 6 + SNMP_ACCESS_NONE* = 0 + SNMP_ACCESS_NOTIFY* = 1 + SNMP_ACCESS_READ_ONLY* = 2 + SNMP_ACCESS_READ_WRITE* = 3 + SNMP_ACCESS_READ_CREATE* = 4 + SNMPAPI_NOERROR* = TRUE + SNMPAPI_ERROR* = FALSE + SNMP_LOG_SILENT* = 0x0 + SNMP_LOG_FATAL* = 0x1 + SNMP_LOG_ERROR* = 0x2 + SNMP_LOG_WARNING* = 0x3 + SNMP_LOG_TRACE* = 0x4 + SNMP_LOG_VERBOSE* = 0x5 + SNMP_OUTPUT_TO_CONSOLE* = 0x1 + SNMP_OUTPUT_TO_LOGFILE* = 0x2 + SNMP_OUTPUT_TO_EVENTLOG* = 0x4 + SNMP_OUTPUT_TO_DEBUGGER* = 0x8 + DEFAULT_SNMP_PORT_UDP* = 161 + DEFAULT_SNMP_PORT_IPX* = 36879 + DEFAULT_SNMPTRAP_PORT_UDP* = 162 + DEFAULT_SNMPTRAP_PORT_IPX* = 36880 + SNMP_MAX_OID_LEN* = 128 + SNMP_MEM_ALLOC_ERROR* = 1 + SNMP_BERAPI_INVALID_LENGTH* = 10 + SNMP_BERAPI_INVALID_TAG* = 11 + SNMP_BERAPI_OVERFLOW* = 12 + SNMP_BERAPI_SHORT_BUFFER* = 13 + SNMP_BERAPI_INVALID_OBJELEM* = 14 + SNMP_PDUAPI_UNRECOGNIZED_PDU* = 20 + SNMP_PDUAPI_INVALID_ES* = 21 + SNMP_PDUAPI_INVALID_GT* = 22 + SNMP_AUTHAPI_INVALID_VERSION* = 30 + SNMP_AUTHAPI_INVALID_MSG_TYPE* = 31 + SNMP_AUTHAPI_TRIV_AUTH_FAILED* = 32 + asnRFC1155_IPADDRESS* = asnIPADDRESS + asnRFC1155_COUNTER* = asnCOUNTER32 + asnRFC1155_GAUGE* = asnGAUGE32 + asnRFC1155_TIMETICKS* = asnTIMETICKS + asnRFC1155_OPAQUE* = asnOPAQUE + asnRFC1213_DISPSTRING* = asnOCTETSTRING + asnRFC1157_GETREQUEST* = SNMP_PDU_GET + asnRFC1157_GETNEXTREQUEST* = SNMP_PDU_GETNEXT + asnRFC1157_GETRESPONSE* = SNMP_PDU_RESPONSE + asnRFC1157_SETREQUEST* = SNMP_PDU_SET + asnRFC1157_TRAP* = SNMP_PDU_V1TRAP + asnCONTEXTSPECIFIC* = asnCONTEXT + asnPRIMATIVE* = asnPRIMITIVE + asnUNSIGNED32* = asnUINTEGER32 +type + SnmpExtensionInit* = proc (dwUptimeReference: DWORD, phSubagentTrapEvent: ptr HANDLE, pFirstSupportedRegion: ptr AsnObjectIdentifier): WINBOOL {.stdcall.} + SnmpExtensionInitEx* = proc (pNextSupportedRegion: ptr AsnObjectIdentifier): WINBOOL {.stdcall.} + SnmpExtensionMonitor* = proc (pAgentMgmtData: LPVOID): WINBOOL {.stdcall.} + SnmpExtensionQuery* = proc (bPduType: BYTE, pVarBindList: ptr SnmpVarBindList, pErrorStatus: ptr AsnInteger32, pErrorIndex: ptr AsnInteger32): WINBOOL {.stdcall.} + SnmpExtensionQueryEx* = proc (nRequestType: UINT, nTransactionId: UINT, pVarBindList: ptr SnmpVarBindList, pContextInfo: ptr AsnOctetString, pErrorStatus: ptr AsnInteger32, pErrorIndex: ptr AsnInteger32): WINBOOL {.stdcall.} + SnmpExtensionTrap* = proc (pEnterpriseOid: ptr AsnObjectIdentifier, pGenericTrapId: ptr AsnInteger32, pSpecificTrapId: ptr AsnInteger32, pTimeStamp: ptr AsnTimeticks, pVarBindList: ptr SnmpVarBindList): WINBOOL {.stdcall.} + SnmpExtensionClose* = proc (): VOID {.stdcall.} + PFNSNMPEXTENSIONINIT* = proc (dwUpTimeReference: DWORD, phSubagentTrapEvent: ptr HANDLE, pFirstSupportedRegion: ptr AsnObjectIdentifier): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONINITEX* = proc (pNextSupportedRegion: ptr AsnObjectIdentifier): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONMONITOR* = proc (pAgentMgmtData: LPVOID): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONQUERY* = proc (bPduType: BYTE, pVarBindList: ptr SnmpVarBindList, pErrorStatus: ptr AsnInteger32, pErrorIndex: ptr AsnInteger32): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONQUERYEX* = proc (nRequestType: UINT, nTransactionId: UINT, pVarBindList: ptr SnmpVarBindList, pContextInfo: ptr AsnOctetString, pErrorStatus: ptr AsnInteger32, pErrorIndex: ptr AsnInteger32): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONTRAP* = proc (pEnterpriseOid: ptr AsnObjectIdentifier, pGenericTrapId: ptr AsnInteger32, pSpecificTrapId: ptr AsnInteger32, pTimeStamp: ptr AsnTimeticks, pVarBindList: ptr SnmpVarBindList): WINBOOL {.stdcall.} + PFNSNMPEXTENSIONCLOSE* = proc (): VOID {.stdcall.} +proc SnmpUtilOidCpy*(pOidDst: ptr AsnObjectIdentifier, pOidSrc: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOidAppend*(pOidDst: ptr AsnObjectIdentifier, pOidSrc: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOidNCmp*(pOid1: ptr AsnObjectIdentifier, pOid2: ptr AsnObjectIdentifier, nSubIds: UINT): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOidCmp*(pOid1: ptr AsnObjectIdentifier, pOid2: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOidFree*(pOid: ptr AsnObjectIdentifier): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOctetsCmp*(pOctets1: ptr AsnOctetString, pOctets2: ptr AsnOctetString): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOctetsNCmp*(pOctets1: ptr AsnOctetString, pOctets2: ptr AsnOctetString, nChars: UINT): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOctetsCpy*(pOctetsDst: ptr AsnOctetString, pOctetsSrc: ptr AsnOctetString): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOctetsFree*(pOctets: ptr AsnOctetString): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilAsnAnyCpy*(pAnyDst: ptr AsnAny, pAnySrc: ptr AsnAny): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilAsnAnyFree*(pAny: ptr AsnAny): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilVarBindCpy*(pVbDst: ptr SnmpVarBind, pVbSrc: ptr SnmpVarBind): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilVarBindFree*(pVb: ptr SnmpVarBind): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilVarBindListCpy*(pVblDst: ptr SnmpVarBindList, pVblSrc: ptr SnmpVarBindList): INT {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilVarBindListFree*(pVbl: ptr SnmpVarBindList): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilMemFree*(pMem: LPVOID): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilMemAlloc*(nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilMemReAlloc*(pMem: LPVOID, nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilOidToA*(Oid: ptr AsnObjectIdentifier): LPSTR {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilIdsToA*(Ids: ptr UINT, IdLength: UINT): LPSTR {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilPrintOid*(Oid: ptr AsnObjectIdentifier): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilPrintAsnAny*(pAny: ptr AsnAny): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpSvcGetUptime*(): DWORD {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpSvcSetLogLevel*(nLogLevel: INT): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpSvcSetLogType*(nLogType: INT): VOID {.winapi, stdcall, dynlib: "snmpapi", importc.} +proc SnmpUtilDbgPrint*(nLogLevel: INT, szFormat: LPSTR): VOID {.winapi, cdecl, varargs, dynlib: "snmpapi", importc.} +proc SNMP_oidcpy*(pOidDst: ptr AsnObjectIdentifier, pOidSrc: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilOidCpy".} +proc SNMP_oidappend*(pOidDst: ptr AsnObjectIdentifier, pOidSrc: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilOidAppend".} +proc SNMP_oidncmp*(pOid1: ptr AsnObjectIdentifier, pOid2: ptr AsnObjectIdentifier, nSubIds: UINT): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilOidNCmp".} +proc SNMP_oidcmp*(pOid1: ptr AsnObjectIdentifier, pOid2: ptr AsnObjectIdentifier): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilOidCmp".} +proc SNMP_oidfree*(pOid: ptr AsnObjectIdentifier): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilOidFree".} +proc SNMP_CopyVarBindList*(pVblDst: ptr SnmpVarBindList, pVblSrc: ptr SnmpVarBindList): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilVarBindListCpy".} +proc SNMP_FreeVarBindList*(pVbl: ptr SnmpVarBindList): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilVarBindListFree".} +proc SNMP_CopyVarBind*(pVbDst: ptr SnmpVarBind, pVbSrc: ptr SnmpVarBind): INT {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilVarBindCpy".} +proc SNMP_FreeVarBind*(pVb: ptr SnmpVarBind): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilVarBindFree".} +proc SNMP_printany*(pAny: ptr AsnAny): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilPrintAsnAny".} +proc SNMP_free*(pMem: LPVOID): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemFree".} +proc SNMP_malloc*(nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemAlloc".} +proc SNMP_realloc*(pMem: LPVOID, nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemReAlloc".} +proc SNMP_DBG_free*(pMem: LPVOID): VOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemFree".} +proc SNMP_DBG_malloc*(nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemAlloc".} +proc SNMP_DBG_realloc*(pMem: LPVOID, nBytes: UINT): LPVOID {.winapi, stdcall, dynlib: "snmpapi", importc: "SnmpUtilMemReAlloc".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/subauth.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/subauth.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,182 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import windef +#include +type + NETLOGON_LOGON_INFO_CLASS* = int32 + SAM_HANDLE* = PVOID + PSAM_HANDLE* = ptr PVOID + OLD_LARGE_INTEGER* {.pure.} = object + LowPart*: ULONG + HighPart*: LONG + POLD_LARGE_INTEGER* = ptr OLD_LARGE_INTEGER + LOGON_HOURS* {.pure.} = object + UnitsPerWeek*: USHORT + LogonHours*: PUCHAR + PLOGON_HOURS* = ptr LOGON_HOURS + SR_SECURITY_DESCRIPTOR* {.pure.} = object + Length*: ULONG + SecurityDescriptor*: PUCHAR + PSR_SECURITY_DESCRIPTOR* = ptr SR_SECURITY_DESCRIPTOR + USER_ALL_INFORMATION* {.pure, packed.} = object + LastLogon*: LARGE_INTEGER + LastLogoff*: LARGE_INTEGER + PasswordLastSet*: LARGE_INTEGER + AccountExpires*: LARGE_INTEGER + PasswordCanChange*: LARGE_INTEGER + PasswordMustChange*: LARGE_INTEGER + UserName*: UNICODE_STRING + FullName*: UNICODE_STRING + HomeDirectory*: UNICODE_STRING + HomeDirectoryDrive*: UNICODE_STRING + ScriptPath*: UNICODE_STRING + ProfilePath*: UNICODE_STRING + AdminComment*: UNICODE_STRING + WorkStations*: UNICODE_STRING + UserComment*: UNICODE_STRING + Parameters*: UNICODE_STRING + LmPassword*: UNICODE_STRING + NtPassword*: UNICODE_STRING + PrivateData*: UNICODE_STRING + SecurityDescriptor*: SR_SECURITY_DESCRIPTOR + UserId*: ULONG + PrimaryGroupId*: ULONG + UserAccountControl*: ULONG + WhichFields*: ULONG + LogonHours*: LOGON_HOURS + BadPasswordCount*: USHORT + LogonCount*: USHORT + CountryCode*: USHORT + CodePage*: USHORT + LmPasswordPresent*: BOOLEAN + NtPasswordPresent*: BOOLEAN + PasswordExpired*: BOOLEAN + PrivateDataSensitive*: BOOLEAN + PUSER_ALL_INFORMATION* = ptr USER_ALL_INFORMATION +const + CLEAR_BLOCK_LENGTH* = 8 +type + CLEAR_BLOCK* {.pure.} = object + data*: array[CLEAR_BLOCK_LENGTH, CHAR] + PCLEAR_BLOCK* = ptr CLEAR_BLOCK +const + CYPHER_BLOCK_LENGTH* = 8 +type + CYPHER_BLOCK* {.pure.} = object + data*: array[CYPHER_BLOCK_LENGTH, CHAR] + PCYPHER_BLOCK* = ptr CYPHER_BLOCK + LM_OWF_PASSWORD* {.pure.} = object + data*: array[2, CYPHER_BLOCK] + PLM_OWF_PASSWORD* = ptr LM_OWF_PASSWORD + LM_CHALLENGE* = CLEAR_BLOCK + PLM_CHALLENGE* = ptr LM_CHALLENGE + NT_OWF_PASSWORD* = LM_OWF_PASSWORD + PNT_OWF_PASSWORD* = ptr NT_OWF_PASSWORD + NT_CHALLENGE* = LM_CHALLENGE + PNT_CHALLENGE* = ptr NT_CHALLENGE + USER_SESSION_KEY* {.pure.} = object + data*: array[2, CYPHER_BLOCK] + PUSER_SESSION_KEY* = ptr USER_SESSION_KEY + NETLOGON_LOGON_IDENTITY_INFO* {.pure.} = object + LogonDomainName*: UNICODE_STRING + ParameterControl*: ULONG + LogonId*: OLD_LARGE_INTEGER + UserName*: UNICODE_STRING + Workstation*: UNICODE_STRING + PNETLOGON_LOGON_IDENTITY_INFO* = ptr NETLOGON_LOGON_IDENTITY_INFO + NETLOGON_INTERACTIVE_INFO* {.pure.} = object + Identity*: NETLOGON_LOGON_IDENTITY_INFO + LmOwfPassword*: LM_OWF_PASSWORD + NtOwfPassword*: NT_OWF_PASSWORD + PNETLOGON_INTERACTIVE_INFO* = ptr NETLOGON_INTERACTIVE_INFO + NETLOGON_SERVICE_INFO* {.pure.} = object + Identity*: NETLOGON_LOGON_IDENTITY_INFO + LmOwfPassword*: LM_OWF_PASSWORD + NtOwfPassword*: NT_OWF_PASSWORD + PNETLOGON_SERVICE_INFO* = ptr NETLOGON_SERVICE_INFO + NETLOGON_NETWORK_INFO* {.pure.} = object + Identity*: NETLOGON_LOGON_IDENTITY_INFO + LmChallenge*: LM_CHALLENGE + NtChallengeResponse*: STRING + LmChallengeResponse*: STRING + PNETLOGON_NETWORK_INFO* = ptr NETLOGON_NETWORK_INFO + NETLOGON_GENERIC_INFO* {.pure.} = object + Identity*: NETLOGON_LOGON_IDENTITY_INFO + PackageName*: UNICODE_STRING + DataLength*: ULONG + LogonData*: PUCHAR + PNETLOGON_GENERIC_INFO* = ptr NETLOGON_GENERIC_INFO + MSV1_0_VALIDATION_INFO* {.pure.} = object + LogoffTime*: LARGE_INTEGER + KickoffTime*: LARGE_INTEGER + LogonServer*: UNICODE_STRING + LogonDomainName*: UNICODE_STRING + SessionKey*: USER_SESSION_KEY + Authoritative*: BOOLEAN + UserFlags*: ULONG + WhichFields*: ULONG + UserId*: ULONG + PMSV1_0_VALIDATION_INFO* = ptr MSV1_0_VALIDATION_INFO +const + USER_ACCOUNT_DISABLED* = 0x00000001 + USER_HOME_DIRECTORY_REQUIRED* = 0x00000002 + USER_PASSWORD_NOT_REQUIRED* = 0x00000004 + USER_TEMP_DUPLICATE_ACCOUNT* = 0x00000008 + USER_NORMAL_ACCOUNT* = 0x00000010 + USER_MNS_LOGON_ACCOUNT* = 0x00000020 + USER_INTERDOMAIN_TRUST_ACCOUNT* = 0x00000040 + USER_WORKSTATION_TRUST_ACCOUNT* = 0x00000080 + USER_SERVER_TRUST_ACCOUNT* = 0x00000100 + USER_DONT_EXPIRE_PASSWORD* = 0x00000200 + USER_ACCOUNT_AUTO_LOCKED* = 0x00000400 + USER_ENCRYPTED_TEXT_PASSWORD_ALLOWED* = 0x00000800 + USER_SMARTCARD_REQUIRED* = 0x00001000 + USER_TRUSTED_FOR_DELEGATION* = 0x00002000 + USER_NOT_DELEGATED* = 0x00004000 + USER_USE_DES_KEY_ONLY* = 0x00008000 + USER_DONT_REQUIRE_PREAUTH* = 0x00010000 + USER_PASSWORD_EXPIRED* = 0x00020000 + USER_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION* = 0x00040000 + USER_NO_AUTH_DATA_REQUIRED* = 0x00080000 + NEXT_FREE_ACCOUNT_CONTROL_BIT* = USER_NO_AUTH_DATA_REQUIRED shl 1 + USER_MACHINE_ACCOUNT_MASK* = USER_INTERDOMAIN_TRUST_ACCOUNT or USER_WORKSTATION_TRUST_ACCOUNT or USER_SERVER_TRUST_ACCOUNT + USER_ACCOUNT_TYPE_MASK* = USER_TEMP_DUPLICATE_ACCOUNT or USER_NORMAL_ACCOUNT or USER_MACHINE_ACCOUNT_MASK + USER_COMPUTED_ACCOUNT_CONTROL_BITS* = USER_ACCOUNT_AUTO_LOCKED or USER_PASSWORD_EXPIRED + SAM_DAYS_PER_WEEK* = 7 + SAM_HOURS_PER_WEEK* = 24*SAM_DAYS_PER_WEEK + SAM_MINUTES_PER_WEEK* = 60*SAM_HOURS_PER_WEEK + USER_ALL_PARAMETERS* = 0x00200000 + USER_SESSION_KEY_LENGTH* = CYPHER_BLOCK_LENGTH*2 + netlogonInteractiveInformation* = 1 + netlogonNetworkInformation* = 2 + netlogonServiceInformation* = 3 + netlogonGenericInformation* = 4 + netlogonInteractiveTransitiveInformation* = 5 + netlogonNetworkTransitiveInformation* = 6 + netlogonServiceTransitiveInformation* = 7 + MSV1_0_PASSTHRU* = 0x01 + MSV1_0_GUEST_LOGON* = 0x02 + MSV1_0_VALIDATION_LOGOFF_TIME* = 0x00000001 + MSV1_0_VALIDATION_KICKOFF_TIME* = 0x00000002 + MSV1_0_VALIDATION_LOGON_SERVER* = 0x00000004 + MSV1_0_VALIDATION_LOGON_DOMAIN* = 0x00000008 + MSV1_0_VALIDATION_SESSION_KEY* = 0x00000010 + MSV1_0_VALIDATION_USER_FLAGS* = 0x00000020 + MSV1_0_VALIDATION_USER_ID* = 0x00000040 + MSV1_0_SUBAUTH_ACCOUNT_DISABLED* = 0x00000001 + MSV1_0_SUBAUTH_PASSWORD* = 0x00000002 + MSV1_0_SUBAUTH_WORKSTATIONS* = 0x00000004 + MSV1_0_SUBAUTH_LOGON_HOURS* = 0x00000008 + MSV1_0_SUBAUTH_ACCOUNT_EXPIRY* = 0x00000010 + MSV1_0_SUBAUTH_PASSWORD_EXPIRY* = 0x00000020 + MSV1_0_SUBAUTH_ACCOUNT_TYPE* = 0x00000040 + MSV1_0_SUBAUTH_LOCKOUT* = 0x00000080 +type + Msv1_0SubAuthenticationRoutine* = proc (LogonLevel: NETLOGON_LOGON_INFO_CLASS, LogonInformation: PVOID, Flags: ULONG, UserAll: PUSER_ALL_INFORMATION, WhichFields: PULONG, UserFlags: PULONG, Authoritative: PBOOLEAN, LogoffTime: PLARGE_INTEGER, KickoffTime: PLARGE_INTEGER): NTSTATUS {.stdcall.} + Msv1_0SubAuthenticationRoutineEx* = proc (LogonLevel: NETLOGON_LOGON_INFO_CLASS, LogonInformation: PVOID, Flags: ULONG, UserAll: PUSER_ALL_INFORMATION, UserHandle: SAM_HANDLE, ValidationInfo: PMSV1_0_VALIDATION_INFO, ActionsPerformed: PULONG): NTSTATUS {.stdcall.} + Msv1_0SubAuthenticationRoutineGeneric* = proc (SubmitBuffer: PVOID, SubmitBufferLength: ULONG, ReturnBufferLength: PULONG, ReturnBuffer: ptr PVOID): NTSTATUS {.stdcall.} + Msv1_0SubAuthenticationFilter* = proc (LogonLevel: NETLOGON_LOGON_INFO_CLASS, LogonInformation: PVOID, Flags: ULONG, UserAll: PUSER_ALL_INFORMATION, WhichFields: PULONG, UserFlags: PULONG, Authoritative: PBOOLEAN, LogoffTime: PLARGE_INTEGER, KickoffTime: PLARGE_INTEGER): NTSTATUS {.stdcall.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/tlhelp32.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/tlhelp32.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,154 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + HEAPLIST32* {.pure.} = object + dwSize*: SIZE_T + th32ProcessID*: DWORD + th32HeapID*: ULONG_PTR + dwFlags*: DWORD + PHEAPLIST32* = ptr HEAPLIST32 + LPHEAPLIST32* = ptr HEAPLIST32 + HEAPENTRY32* {.pure.} = object + dwSize*: SIZE_T + hHandle*: HANDLE + dwAddress*: ULONG_PTR + dwBlockSize*: SIZE_T + dwFlags*: DWORD + dwLockCount*: DWORD + dwResvd*: DWORD + th32ProcessID*: DWORD + th32HeapID*: ULONG_PTR + PHEAPENTRY32* = ptr HEAPENTRY32 + LPHEAPENTRY32* = ptr HEAPENTRY32 + PROCESSENTRY32W* {.pure.} = object + dwSize*: DWORD + cntUsage*: DWORD + th32ProcessID*: DWORD + th32DefaultHeapID*: ULONG_PTR + th32ModuleID*: DWORD + cntThreads*: DWORD + th32ParentProcessID*: DWORD + pcPriClassBase*: LONG + dwFlags*: DWORD + szExeFile*: array[MAX_PATH, WCHAR] + PPROCESSENTRY32W* = ptr PROCESSENTRY32W + LPPROCESSENTRY32W* = ptr PROCESSENTRY32W + THREADENTRY32* {.pure.} = object + dwSize*: DWORD + cntUsage*: DWORD + th32ThreadID*: DWORD + th32OwnerProcessID*: DWORD + tpBasePri*: LONG + tpDeltaPri*: LONG + dwFlags*: DWORD + PTHREADENTRY32* = ptr THREADENTRY32 + LPTHREADENTRY32* = ptr THREADENTRY32 +const + MAX_MODULE_NAME32* = 255 +type + MODULEENTRY32W* {.pure.} = object + dwSize*: DWORD + th32ModuleID*: DWORD + th32ProcessID*: DWORD + GlblcntUsage*: DWORD + ProccntUsage*: DWORD + modBaseAddr*: ptr BYTE + modBaseSize*: DWORD + hModule*: HMODULE + szModule*: array[MAX_MODULE_NAME32 + 1, WCHAR] + szExePath*: array[MAX_PATH, WCHAR] + PMODULEENTRY32W* = ptr MODULEENTRY32W + LPMODULEENTRY32W* = ptr MODULEENTRY32W +when winimUnicode: + type + MODULEENTRY32* = MODULEENTRY32W +type + MODULEENTRY32A* {.pure.} = object + dwSize*: DWORD + th32ModuleID*: DWORD + th32ProcessID*: DWORD + GlblcntUsage*: DWORD + ProccntUsage*: DWORD + modBaseAddr*: ptr BYTE + modBaseSize*: DWORD + hModule*: HMODULE + szModule*: array[MAX_MODULE_NAME32 + 1, char] + szExePath*: array[MAX_PATH, char] +when winimAnsi: + type + MODULEENTRY32* = MODULEENTRY32A +type + LPMODULEENTRY32* = ptr MODULEENTRY32 + PROCESSENTRY32A* {.pure.} = object + dwSize*: DWORD + cntUsage*: DWORD + th32ProcessID*: DWORD + th32DefaultHeapID*: ULONG_PTR + th32ModuleID*: DWORD + cntThreads*: DWORD + th32ParentProcessID*: DWORD + pcPriClassBase*: LONG + dwFlags*: DWORD + szExeFile*: array[MAX_PATH, CHAR] + PPROCESSENTRY32A* = ptr PROCESSENTRY32A + LPPROCESSENTRY32A* = ptr PROCESSENTRY32A + PMODULEENTRY32A* = ptr MODULEENTRY32A + LPMODULEENTRY32A* = ptr MODULEENTRY32A +const + TH32CS_SNAPHEAPLIST* = 0x00000001 + TH32CS_SNAPPROCESS* = 0x00000002 + TH32CS_SNAPTHREAD* = 0x00000004 + TH32CS_SNAPMODULE* = 0x00000008 + TH32CS_SNAPMODULE32* = 0x00000010 + TH32CS_SNAPALL* = TH32CS_SNAPHEAPLIST or TH32CS_SNAPPROCESS or TH32CS_SNAPTHREAD or TH32CS_SNAPMODULE + TH32CS_INHERIT* = 0x80000000'i32 + HF32_DEFAULT* = 1 + HF32_SHARED* = 2 + LF32_FIXED* = 0x00000001 + LF32_FREE* = 0x00000002 + LF32_MOVEABLE* = 0x00000004 +proc CreateToolhelp32Snapshot*(dwFlags: DWORD, th32ProcessID: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Heap32ListFirst*(hSnapshot: HANDLE, lphl: LPHEAPLIST32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Heap32ListNext*(hSnapshot: HANDLE, lphl: LPHEAPLIST32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Heap32First*(lphe: LPHEAPENTRY32, th32ProcessID: DWORD, th32HeapID: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Heap32Next*(lphe: LPHEAPENTRY32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Toolhelp32ReadProcessMemory*(th32ProcessID: DWORD, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, cbRead: SIZE_T, lpNumberOfBytesRead: ptr SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Process32FirstW*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Process32NextW*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Process32FirstA*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Process32First".} +proc Process32NextA*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Process32Next".} +proc Thread32First*(hSnapshot: HANDLE, lpte: LPTHREADENTRY32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Thread32Next*(hSnapshot: HANDLE, lpte: LPTHREADENTRY32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Module32FirstW*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Module32NextW*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Module32FirstA*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Module32First".} +proc Module32NextA*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Module32Next".} +when winimUnicode: + type + PROCESSENTRY32* = PROCESSENTRY32W + PPROCESSENTRY32* = ptr PROCESSENTRY32W + LPPROCESSENTRY32* = ptr PROCESSENTRY32W + PMODULEENTRY32* = ptr MODULEENTRY32W + LMODULEENTRY32* = ptr MODULEENTRY32W + proc Process32First*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Process32FirstW".} + proc Process32Next*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Process32NextW".} + proc Module32First*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Module32FirstW".} + proc Module32Next*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "Module32NextW".} +when winimAnsi: + type + PROCESSENTRY32* = PROCESSENTRY32A + PPROCESSENTRY32* = ptr PROCESSENTRY32A + LPPROCESSENTRY32* = ptr PROCESSENTRY32A + PMODULEENTRY32* = ptr MODULEENTRY32A + LMODULEENTRY32* = ptr MODULEENTRY32A + proc Process32First*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} + proc Process32Next*(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} + proc Module32First*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} + proc Module32Next*(hSnapshot: HANDLE, lpme: LPMODULEENTRY32A): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/uiautomation.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/uiautomation.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,3440 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import objbase +import objext +#include +#include +#include +#include +type + NavigateDirection* = int32 + ProviderOptions* = int32 + StructureChangeType* = int32 + TextEditChangeType* = int32 + OrientationType* = int32 + DockPosition* = int32 + ExpandCollapseState* = int32 + ScrollAmount* = int32 + RowOrColumnMajor* = int32 + ToggleState* = int32 + WindowVisualState* = int32 + SynchronizedInputType* = int32 + WindowInteractionState* = int32 + SayAsInterpretAs* = int32 + TextUnit* = int32 + TextPatternRangeEndpoint* = int32 + SupportedTextSelection* = int32 + LiveSetting* = int32 + ActiveEnd* = int32 + CaretPosition* = int32 + CaretBidiMode* = int32 + ZoomUnit* = int32 + AnimationStyle* = int32 + BulletStyle* = int32 + CapStyle* = int32 + FlowDirections* = int32 + HorizontalTextAlignment* = int32 + OutlineStyles* = int32 + TextDecorationLineStyle* = int32 + VisualEffects* = int32 + NotificationProcessing* = int32 + NotificationKind* = int32 + PROPERTYID* = int32 + PATTERNID* = int32 + EVENTID* = int32 + TEXTATTRIBUTEID* = int32 + CONTROLTYPEID* = int32 + LANDMARKTYPEID* = int32 + METADATAID* = int32 + HEADINGLEVELID* = int32 + UIAutomationType* = int32 + TreeScope* = int32 + PropertyConditionFlags* = int32 + AutomationElementMode* = int32 + TreeTraversalOptions* = int32 + ConnectionRecoveryBehaviorOptions* = int32 + CoalesceEventsOptions* = int32 + UIA_HWND* = pointer + NormalizeState* = int32 + ProviderType* = int32 + AutomationIdentifierType* = int32 + EventArgsType* = int32 + AsyncContentLoadedState* = int32 + HUIANODE* = HANDLE + HUIAPATTERNOBJECT* = HANDLE + HUIATEXTRANGE* = HANDLE + HUIAEVENT* = HANDLE +const + REQUIRED_RPCSAL_H_VERSION* = 100 + NavigateDirection_Parent* = 0 + NavigateDirection_NextSibling* = 1 + NavigateDirection_PreviousSibling* = 2 + NavigateDirection_FirstChild* = 3 + NavigateDirection_LastChild* = 4 + ProviderOptions_ClientSideProvider* = 0x1 + ProviderOptions_ServerSideProvider* = 0x2 + ProviderOptions_NonClientAreaProvider* = 0x4 + ProviderOptions_OverrideProvider* = 0x8 + ProviderOptions_ProviderOwnsSetFocus* = 0x10 + ProviderOptions_UseComThreading* = 0x20 + ProviderOptions_RefuseNonClientSupport* = 0x40 + ProviderOptions_HasNativeIAccessible* = 0x80 + ProviderOptions_UseClientCoordinates* = 0x100 + StructureChangeType_ChildAdded* = 0 + StructureChangeType_ChildRemoved* = StructureChangeType_ChildAdded+1 + StructureChangeType_ChildrenInvalidated* = StructureChangeType_ChildRemoved+1 + StructureChangeType_ChildrenBulkAdded* = StructureChangeType_ChildrenInvalidated+1 + StructureChangeType_ChildrenBulkRemoved* = StructureChangeType_ChildrenBulkAdded+1 + StructureChangeType_ChildrenReordered* = StructureChangeType_ChildrenBulkRemoved+1 + TextEditChangeType_None* = 0 + TextEditChangeType_AutoCorrect* = 1 + TextEditChangeType_Composition* = 2 + TextEditChangeType_CompositionFinalized* = 3 + TextEditChangeType_AutoComplete* = 4 + OrientationType_None* = 0 + OrientationType_Horizontal* = 1 + OrientationType_Vertical* = 2 + DockPosition_Top* = 0 + DockPosition_Left* = 1 + DockPosition_Bottom* = 2 + DockPosition_Right* = 3 + DockPosition_Fill* = 4 + DockPosition_None* = 5 + ExpandCollapseState_Collapsed* = 0 + ExpandCollapseState_Expanded* = 1 + ExpandCollapseState_PartiallyExpanded* = 2 + ExpandCollapseState_LeafNode* = 3 + ScrollAmount_LargeDecrement* = 0 + ScrollAmount_SmallDecrement* = 1 + ScrollAmount_NoAmount* = 2 + ScrollAmount_LargeIncrement* = 3 + ScrollAmount_SmallIncrement* = 4 + RowOrColumnMajor_RowMajor* = 0 + RowOrColumnMajor_ColumnMajor* = 1 + RowOrColumnMajor_Indeterminate* = 2 + ToggleState_Off* = 0 + ToggleState_On* = 1 + ToggleState_Indeterminate* = 2 + WindowVisualState_Normal* = 0 + WindowVisualState_Maximized* = 1 + WindowVisualState_Minimized* = 2 + SynchronizedInputType_KeyUp* = 0x1 + SynchronizedInputType_KeyDown* = 0x2 + SynchronizedInputType_LeftMouseUp* = 0x4 + SynchronizedInputType_LeftMouseDown* = 0x8 + SynchronizedInputType_RightMouseUp* = 0x10 + SynchronizedInputType_RightMouseDown* = 0x20 + WindowInteractionState_Running* = 0 + WindowInteractionState_Closing* = 1 + WindowInteractionState_ReadyForUserInteraction* = 2 + WindowInteractionState_BlockedByModalWindow* = 3 + WindowInteractionState_NotResponding* = 4 + SayAsInterpretAs_None* = 0 + SayAsInterpretAs_Spell* = 1 + SayAsInterpretAs_Cardinal* = 2 + SayAsInterpretAs_Ordinal* = 3 + SayAsInterpretAs_Number* = 4 + SayAsInterpretAs_Date* = 5 + SayAsInterpretAs_Time* = 6 + SayAsInterpretAs_Telephone* = 7 + SayAsInterpretAs_Currency* = 8 + SayAsInterpretAs_Net* = 9 + SayAsInterpretAs_Url* = 10 + SayAsInterpretAs_Address* = 11 + SayAsInterpretAs_Alphanumeric* = 12 + SayAsInterpretAs_Name* = 13 + SayAsInterpretAs_Media* = 14 + SayAsInterpretAs_Date_MonthDayYear* = 15 + SayAsInterpretAs_Date_DayMonthYear* = 16 + SayAsInterpretAs_Date_YearMonthDay* = 17 + SayAsInterpretAs_Date_YearMonth* = 18 + SayAsInterpretAs_Date_MonthYear* = 19 + SayAsInterpretAs_Date_DayMonth* = 20 + SayAsInterpretAs_Date_MonthDay* = 21 + SayAsInterpretAs_Date_Year* = 22 + SayAsInterpretAs_Time_HoursMinutesSeconds12* = 23 + SayAsInterpretAs_Time_HoursMinutes12* = 24 + SayAsInterpretAs_Time_HoursMinutesSeconds24* = 25 + SayAsInterpretAs_Time_HoursMinutes24* = 26 + TextUnit_Character* = 0 + TextUnit_Format* = 1 + TextUnit_Word* = 2 + TextUnit_Line* = 3 + TextUnit_Paragraph* = 4 + TextUnit_Page* = 5 + TextUnit_Document* = 6 + TextPatternRangeEndpoint_Start* = 0 + TextPatternRangeEndpoint_End* = 1 + SupportedTextSelection_None* = 0 + SupportedTextSelection_Single* = 1 + SupportedTextSelection_Multiple* = 2 + polite* = 1 + assertive* = 2 + ActiveEnd_None* = 0 + ActiveEnd_Start* = 1 + ActiveEnd_End* = 2 + CaretPosition_Unknown* = 0 + CaretPosition_EndOfLine* = 1 + CaretPosition_BeginningOfLine* = 2 + CaretBidiMode_LTR* = 0 + CaretBidiMode_RTL* = 1 + ZoomUnit_NoAmount* = 0 + ZoomUnit_LargeDecrement* = 1 + ZoomUnit_SmallDecrement* = 2 + ZoomUnit_LargeIncrement* = 3 + ZoomUnit_SmallIncrement* = 4 + AnimationStyle_None* = 0 + AnimationStyle_LasVegasLights* = 1 + AnimationStyle_BlinkingBackground* = 2 + AnimationStyle_SparkleText* = 3 + AnimationStyle_MarchingBlackAnts* = 4 + AnimationStyle_MarchingRedAnts* = 5 + AnimationStyle_Shimmer* = 6 + AnimationStyle_Other* = -1 + BulletStyle_None* = 0 + BulletStyle_HollowRoundBullet* = 1 + BulletStyle_FilledRoundBullet* = 2 + BulletStyle_HollowSquareBullet* = 3 + BulletStyle_FilledSquareBullet* = 4 + BulletStyle_DashBullet* = 5 + BulletStyle_Other* = -1 + CapStyle_None* = 0 + CapStyle_SmallCap* = 1 + CapStyle_AllCap* = 2 + CapStyle_AllPetiteCaps* = 3 + CapStyle_PetiteCaps* = 4 + CapStyle_Unicase* = 5 + CapStyle_Titling* = 6 + CapStyle_Other* = -1 + FillType_None* = 0 + FillType_Color* = 1 + FillType_Gradient* = 2 + FillType_Picture* = 3 + FillType_Pattern* = 4 + FlowDirections_Default* = 0 + FlowDirections_RightToLeft* = 0x1 + FlowDirections_BottomToTop* = 0x2 + FlowDirections_Vertical* = 0x4 + HorizontalTextAlignment_Left* = 0 + HorizontalTextAlignment_Centered* = 1 + HorizontalTextAlignment_Right* = 2 + HorizontalTextAlignment_Justified* = 3 + OutlineStyles_None* = 0 + OutlineStyles_Outline* = 1 + OutlineStyles_Shadow* = 2 + OutlineStyles_Engraved* = 4 + OutlineStyles_Embossed* = 8 + TextDecorationLineStyle_None* = 0 + TextDecorationLineStyle_Single* = 1 + TextDecorationLineStyle_WordsOnly* = 2 + TextDecorationLineStyle_Double* = 3 + TextDecorationLineStyle_Dot* = 4 + TextDecorationLineStyle_Dash* = 5 + TextDecorationLineStyle_DashDot* = 6 + TextDecorationLineStyle_DashDotDot* = 7 + TextDecorationLineStyle_Wavy* = 8 + TextDecorationLineStyle_ThickSingle* = 9 + TextDecorationLineStyle_DoubleWavy* = 11 + TextDecorationLineStyle_ThickWavy* = 12 + TextDecorationLineStyle_LongDash* = 13 + TextDecorationLineStyle_ThickDash* = 14 + TextDecorationLineStyle_ThickDashDot* = 15 + TextDecorationLineStyle_ThickDashDotDot* = 16 + TextDecorationLineStyle_ThickDot* = 17 + TextDecorationLineStyle_ThickLongDash* = 18 + TextDecorationLineStyle_Other* = -1 + VisualEffects_None* = 0 + VisualEffects_Shadow* = 1 shl 0 + VisualEffects_Reflection* = 1 shl 1 + VisualEffects_Glow* = 1 shl 2 + VisualEffects_SoftEdges* = 1 shl 3 + VisualEffects_Bevel* = 1 shl 4 + NotificationProcessing_ImportantAll* = 0 + NotificationProcessing_ImportantMostRecent* = 1 + NotificationProcessing_All* = 2 + NotificationProcessing_MostRecent* = 3 + NotificationProcessing_CurrentThenMostRecent* = 4 + NotificationKind_ItemAdded* = 0 + NotificationKind_ItemRemoved* = 1 + NotificationKind_ActionCompleted* = 2 + NotificationKind_ActionAborted* = 3 + NotificationKind_Other* = 4 + UIAutomationType_Int* = 0x1 + UIAutomationType_Bool* = 0x2 + UIAutomationType_String* = 0x3 + UIAutomationType_Double* = 0x4 + UIAutomationType_Point* = 0x5 + UIAutomationType_Rect* = 0x6 + UIAutomationType_Element* = 0x7 + UIAutomationType_Array* = 0x10000 + UIAutomationType_Out* = 0x20000 + UIAutomationType_IntArray* = UIAutomationType_Int or UIAutomationType_Array + UIAutomationType_BoolArray* = UIAutomationType_Bool or UIAutomationType_Array + UIAutomationType_StringArray* = UIAutomationType_String or UIAutomationType_Array + UIAutomationType_DoubleArray* = UIAutomationType_Double or UIAutomationType_Array + UIAutomationType_PointArray* = UIAutomationType_Point or UIAutomationType_Array + UIAutomationType_RectArray* = UIAutomationType_Rect or UIAutomationType_Array + UIAutomationType_ElementArray* = UIAutomationType_Element or UIAutomationType_Array + UIAutomationType_OutInt* = UIAutomationType_Int or UIAutomationType_Out + UIAutomationType_OutBool* = UIAutomationType_Bool or UIAutomationType_Out + UIAutomationType_OutString* = UIAutomationType_String or UIAutomationType_Out + UIAutomationType_OutDouble* = UIAutomationType_Double or UIAutomationType_Out + UIAutomationType_OutPoint* = UIAutomationType_Point or UIAutomationType_Out + UIAutomationType_OutRect* = UIAutomationType_Rect or UIAutomationType_Out + UIAutomationType_OutElement* = UIAutomationType_Element or UIAutomationType_Out + UIAutomationType_OutIntArray* = ( UIAutomationType_Int or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutBoolArray* = ( UIAutomationType_Bool or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutStringArray* = ( UIAutomationType_String or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutDoubleArray* = ( UIAutomationType_Double or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutPointArray* = ( UIAutomationType_Point or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutRectArray* = ( UIAutomationType_Rect or UIAutomationType_Array ) or UIAutomationType_Out + UIAutomationType_OutElementArray* = ( UIAutomationType_Element or UIAutomationType_Array ) or UIAutomationType_Out + UIA_ScrollPatternNoScroll* = -1 + IID_IRawElementProviderSimple* = DEFINE_GUID("d6dd68d1-86fd-4332-8666-9abedea2d24c") + IID_IAccessibleEx* = DEFINE_GUID("f8b80ada-2c44-48d0-89be-5ff23c9cd875") + IID_IRawElementProviderSimple2* = DEFINE_GUID("a0a839a9-8da1-4a82-806a-8e0d44e79f56") + IID_IRawElementProviderSimple3* = DEFINE_GUID("fcf5d820-d7ec-4613-bdf6-42a84ce7daaf") + IID_IRawElementProviderFragmentRoot* = DEFINE_GUID("620ce2a5-ab8f-40a9-86cb-de3c75599b58") + IID_IRawElementProviderFragment* = DEFINE_GUID("f7063da8-8359-439c-9297-bbc5299a7d87") + IID_IRawElementProviderAdviseEvents* = DEFINE_GUID("a407b27b-0f6d-4427-9292-473c7bf93258") + IID_IRawElementProviderHwndOverride* = DEFINE_GUID("1d5df27c-8947-4425-b8d9-79787bb460b8") + IID_IProxyProviderWinEventSink* = DEFINE_GUID("4fd82b78-a43e-46ac-9803-0a6969c7c183") + IID_IProxyProviderWinEventHandler* = DEFINE_GUID("89592ad4-f4e0-43d5-a3b6-bad7e111b435") + IID_IRawElementProviderWindowlessSite* = DEFINE_GUID("0a2a93cc-bfad-42ac-9b2e-0991fb0d3ea0") + IID_IAccessibleHostingElementProviders* = DEFINE_GUID("33ac331b-943e-4020-b295-db37784974a3") + IID_IRawElementProviderHostingAccessibles* = DEFINE_GUID("24be0b07-d37d-487a-98cf-a13ed465e9b3") + IID_IDockProvider* = DEFINE_GUID("159bc72c-4ad3-485e-9637-d7052edf0146") + IID_IExpandCollapseProvider* = DEFINE_GUID("d847d3a5-cab0-4a98-8c32-ecb45c59ad24") + IID_IGridProvider* = DEFINE_GUID("b17d6187-0907-464b-a168-0ef17a1572b1") + IID_IGridItemProvider* = DEFINE_GUID("d02541f1-fb81-4d64-ae32-f520f8a6dbd1") + IID_IInvokeProvider* = DEFINE_GUID("54fcb24b-e18e-47a2-b4d3-eccbe77599a2") + IID_IMultipleViewProvider* = DEFINE_GUID("6278cab1-b556-4a1a-b4e0-418acc523201") + IID_IRangeValueProvider* = DEFINE_GUID("36dc7aef-33e6-4691-afe1-2be7274b3d33") + IID_IScrollItemProvider* = DEFINE_GUID("2360c714-4bf1-4b26-ba65-9b21316127eb") + IID_ISelectionProvider* = DEFINE_GUID("fb8b03af-3bdf-48d4-bd36-1a65793be168") + IID_ISelectionProvider2* = DEFINE_GUID("14f68475-ee1c-44f6-a869-d239381f0fe7") + IID_IScrollProvider* = DEFINE_GUID("b38b8077-1fc3-42a5-8cae-d40c2215055a") + IID_ISelectionItemProvider* = DEFINE_GUID("2acad808-b2d4-452d-a407-91ff1ad167b2") + IID_ISynchronizedInputProvider* = DEFINE_GUID("29db1a06-02ce-4cf7-9b42-565d4fab20ee") + IID_ITableProvider* = DEFINE_GUID("9c860395-97b3-490a-b52a-858cc22af166") + IID_ITableItemProvider* = DEFINE_GUID("b9734fa6-771f-4d78-9c90-2517999349cd") + IID_IToggleProvider* = DEFINE_GUID("56d00bd0-c4f4-433c-a836-1a52a57e0892") + IID_ITransformProvider* = DEFINE_GUID("6829ddc4-4f91-4ffa-b86f-bd3e2987cb4c") + IID_IValueProvider* = DEFINE_GUID("c7935180-6fb3-4201-b174-7df73adbf64a") + IID_IWindowProvider* = DEFINE_GUID("987df77b-db06-4d77-8f8a-86a9c3bb90b9") + IID_ILegacyIAccessibleProvider* = DEFINE_GUID("e44c3566-915d-4070-99c6-047bff5a08f5") + IID_IItemContainerProvider* = DEFINE_GUID("e747770b-39ce-4382-ab30-d8fb3f336f24") + IID_IVirtualizedItemProvider* = DEFINE_GUID("cb98b665-2d35-4fac-ad35-f3c60d0c0b8b") + IID_IObjectModelProvider* = DEFINE_GUID("3ad86ebd-f5ef-483d-bb18-b1042a475d64") + IID_IAnnotationProvider* = DEFINE_GUID("f95c7e80-bd63-4601-9782-445ebff011fc") + IID_IStylesProvider* = DEFINE_GUID("19b6b649-f5d7-4a6d-bdcb-129252be588a") + IID_ISpreadsheetProvider* = DEFINE_GUID("6f6b5d35-5525-4f80-b758-85473832ffc7") + IID_ISpreadsheetItemProvider* = DEFINE_GUID("eaed4660-7b3d-4879-a2e6-365ce603f3d0") + IID_ITransformProvider2* = DEFINE_GUID("4758742f-7ac2-460c-bc48-09fc09308a93") + IID_IDragProvider* = DEFINE_GUID("6aa7bbbb-7ff9-497d-904f-d20b897929d8") + IID_IDropTargetProvider* = DEFINE_GUID("bae82bfd-358a-481c-85a0-d8b4d90a5d61") + IID_ITextRangeProvider* = DEFINE_GUID("5347ad7b-c355-46f8-aff5-909033582f63") + IID_ITextProvider* = DEFINE_GUID("3589c92c-63f3-4367-99bb-ada653b77cf2") + IID_ITextProvider2* = DEFINE_GUID("0dc5e6ed-3e16-4bf1-8f9a-a979878bc195") + IID_ITextEditProvider* = DEFINE_GUID("ea3605b4-3a05-400e-b5f9-4e91b40f6176") + IID_ITextRangeProvider2* = DEFINE_GUID("9bbce42c-1921-4f18-89ca-dba1910a0386") + IID_ITextChildProvider* = DEFINE_GUID("4c2de2b9-c88f-4f88-a111-f1d336b7d1a9") + IID_ICustomNavigationProvider* = DEFINE_GUID("2062a28a-8c07-4b94-8e12-7037c622aeb8") + IID_IUIAutomationPatternInstance* = DEFINE_GUID("c03a7fe4-9431-409f-bed8-ae7c2299bc8d") + IID_IUIAutomationPatternHandler* = DEFINE_GUID("d97022f3-a947-465e-8b2a-ac4315fa54e8") + IID_IUIAutomationRegistrar* = DEFINE_GUID("8609c4ec-4a1a-4d88-a357-5a66e060e1cf") + CLSID_CUIAutomationRegistrar* = DEFINE_GUID("6e29fabf-9977-42d1-8d0e-ca7e61ad87e6") + TreeScope_None* = 0 + TreeScope_Element* = 0x1 + TreeScope_Children* = 0x2 + TreeScope_Descendants* = 0x4 + TreeScope_Parent* = 0x8 + TreeScope_Ancestors* = 0x10 + TreeScope_Subtree* = ( TreeScope_Element or TreeScope_Children ) or TreeScope_Descendants + PropertyConditionFlags_None* = 0 + PropertyConditionFlags_IgnoreCase* = 0x1 + PropertyConditionFlags_MatchSubstring* = 0x2 + AutomationElementMode_None* = 0 + AutomationElementMode_Full* = AutomationElementMode_None+1 + TreeTraversalOptions_Default* = 0 + TreeTraversalOptions_PostOrder* = 0x1 + TreeTraversalOptions_LastToFirstOrder* = 0x2 + ConnectionRecoveryBehaviorOptions_Disabled* = 0 + ConnectionRecoveryBehaviorOptions_Enabled* = 0x1 + CoalesceEventsOptions_Disabled* = 0 + CoalesceEventsOptions_Enabled* = 0x1 + UIA_InvokePatternId* = 10000 + UIA_SelectionPatternId* = 10001 + UIA_ValuePatternId* = 10002 + UIA_RangeValuePatternId* = 10003 + UIA_ScrollPatternId* = 10004 + UIA_ExpandCollapsePatternId* = 10005 + UIA_GridPatternId* = 10006 + UIA_GridItemPatternId* = 10007 + UIA_MultipleViewPatternId* = 10008 + UIA_WindowPatternId* = 10009 + UIA_SelectionItemPatternId* = 10010 + UIA_DockPatternId* = 10011 + UIA_TablePatternId* = 10012 + UIA_TableItemPatternId* = 10013 + UIA_TextPatternId* = 10014 + UIA_TogglePatternId* = 10015 + UIA_TransformPatternId* = 10016 + UIA_ScrollItemPatternId* = 10017 + UIA_LegacyIAccessiblePatternId* = 10018 + UIA_ItemContainerPatternId* = 10019 + UIA_VirtualizedItemPatternId* = 10020 + UIA_SynchronizedInputPatternId* = 10021 + UIA_ObjectModelPatternId* = 10022 + UIA_AnnotationPatternId* = 10023 + UIA_TextPattern2Id* = 10024 + UIA_StylesPatternId* = 10025 + UIA_SpreadsheetPatternId* = 10026 + UIA_SpreadsheetItemPatternId* = 10027 + UIA_TransformPattern2Id* = 10028 + UIA_TextChildPatternId* = 10029 + UIA_DragPatternId* = 10030 + UIA_DropTargetPatternId* = 10031 + UIA_TextEditPatternId* = 10032 + UIA_CustomNavigationPatternId* = 10033 + UIA_SelectionPattern2Id* = 10034 + UIA_ToolTipOpenedEventId* = 20000 + UIA_ToolTipClosedEventId* = 20001 + UIA_StructureChangedEventId* = 20002 + UIA_MenuOpenedEventId* = 20003 + UIA_AutomationPropertyChangedEventId* = 20004 + UIA_AutomationFocusChangedEventId* = 20005 + UIA_AsyncContentLoadedEventId* = 20006 + UIA_MenuClosedEventId* = 20007 + UIA_LayoutInvalidatedEventId* = 20008 + UIA_Invoke_InvokedEventId* = 20009 + UIA_SelectionItem_ElementAddedToSelectionEventId* = 20010 + UIA_SelectionItem_ElementRemovedFromSelectionEventId* = 20011 + UIA_SelectionItem_ElementSelectedEventId* = 20012 + UIA_Selection_InvalidatedEventId* = 20013 + UIA_Text_TextSelectionChangedEventId* = 20014 + UIA_Text_TextChangedEventId* = 20015 + UIA_Window_WindowOpenedEventId* = 20016 + UIA_Window_WindowClosedEventId* = 20017 + UIA_MenuModeStartEventId* = 20018 + UIA_MenuModeEndEventId* = 20019 + UIA_InputReachedTargetEventId* = 20020 + UIA_InputReachedOtherElementEventId* = 20021 + UIA_InputDiscardedEventId* = 20022 + UIA_SystemAlertEventId* = 20023 + UIA_LiveRegionChangedEventId* = 20024 + UIA_HostedFragmentRootsInvalidatedEventId* = 20025 + UIA_Drag_DragStartEventId* = 20026 + UIA_Drag_DragCancelEventId* = 20027 + UIA_Drag_DragCompleteEventId* = 20028 + UIA_DropTarget_DragEnterEventId* = 20029 + UIA_DropTarget_DragLeaveEventId* = 20030 + UIA_DropTarget_DroppedEventId* = 20031 + UIA_TextEdit_TextChangedEventId* = 20032 + UIA_TextEdit_ConversionTargetChangedEventId* = 20033 + UIA_ChangesEventId* = 20034 + UIA_NotificationEventId* = 20035 + UIA_ActiveTextPositionChangedEventId* = 20036 + UIA_RuntimeIdPropertyId* = 30000 + UIA_BoundingRectanglePropertyId* = 30001 + UIA_ProcessIdPropertyId* = 30002 + UIA_ControlTypePropertyId* = 30003 + UIA_LocalizedControlTypePropertyId* = 30004 + UIA_NamePropertyId* = 30005 + UIA_AcceleratorKeyPropertyId* = 30006 + UIA_AccessKeyPropertyId* = 30007 + UIA_HasKeyboardFocusPropertyId* = 30008 + UIA_IsKeyboardFocusablePropertyId* = 30009 + UIA_IsEnabledPropertyId* = 30010 + UIA_AutomationIdPropertyId* = 30011 + UIA_ClassNamePropertyId* = 30012 + UIA_HelpTextPropertyId* = 30013 + UIA_ClickablePointPropertyId* = 30014 + UIA_CulturePropertyId* = 30015 + UIA_IsControlElementPropertyId* = 30016 + UIA_IsContentElementPropertyId* = 30017 + UIA_LabeledByPropertyId* = 30018 + UIA_IsPasswordPropertyId* = 30019 + UIA_NativeWindowHandlePropertyId* = 30020 + UIA_ItemTypePropertyId* = 30021 + UIA_IsOffscreenPropertyId* = 30022 + UIA_OrientationPropertyId* = 30023 + UIA_FrameworkIdPropertyId* = 30024 + UIA_IsRequiredForFormPropertyId* = 30025 + UIA_ItemStatusPropertyId* = 30026 + UIA_IsDockPatternAvailablePropertyId* = 30027 + UIA_IsExpandCollapsePatternAvailablePropertyId* = 30028 + UIA_IsGridItemPatternAvailablePropertyId* = 30029 + UIA_IsGridPatternAvailablePropertyId* = 30030 + UIA_IsInvokePatternAvailablePropertyId* = 30031 + UIA_IsMultipleViewPatternAvailablePropertyId* = 30032 + UIA_IsRangeValuePatternAvailablePropertyId* = 30033 + UIA_IsScrollPatternAvailablePropertyId* = 30034 + UIA_IsScrollItemPatternAvailablePropertyId* = 30035 + UIA_IsSelectionItemPatternAvailablePropertyId* = 30036 + UIA_IsSelectionPatternAvailablePropertyId* = 30037 + UIA_IsTablePatternAvailablePropertyId* = 30038 + UIA_IsTableItemPatternAvailablePropertyId* = 30039 + UIA_IsTextPatternAvailablePropertyId* = 30040 + UIA_IsTogglePatternAvailablePropertyId* = 30041 + UIA_IsTransformPatternAvailablePropertyId* = 30042 + UIA_IsValuePatternAvailablePropertyId* = 30043 + UIA_IsWindowPatternAvailablePropertyId* = 30044 + UIA_ValueValuePropertyId* = 30045 + UIA_ValueIsReadOnlyPropertyId* = 30046 + UIA_RangeValueValuePropertyId* = 30047 + UIA_RangeValueIsReadOnlyPropertyId* = 30048 + UIA_RangeValueMinimumPropertyId* = 30049 + UIA_RangeValueMaximumPropertyId* = 30050 + UIA_RangeValueLargeChangePropertyId* = 30051 + UIA_RangeValueSmallChangePropertyId* = 30052 + UIA_ScrollHorizontalScrollPercentPropertyId* = 30053 + UIA_ScrollHorizontalViewSizePropertyId* = 30054 + UIA_ScrollVerticalScrollPercentPropertyId* = 30055 + UIA_ScrollVerticalViewSizePropertyId* = 30056 + UIA_ScrollHorizontallyScrollablePropertyId* = 30057 + UIA_ScrollVerticallyScrollablePropertyId* = 30058 + UIA_SelectionSelectionPropertyId* = 30059 + UIA_SelectionCanSelectMultiplePropertyId* = 30060 + UIA_SelectionIsSelectionRequiredPropertyId* = 30061 + UIA_GridRowCountPropertyId* = 30062 + UIA_GridColumnCountPropertyId* = 30063 + UIA_GridItemRowPropertyId* = 30064 + UIA_GridItemColumnPropertyId* = 30065 + UIA_GridItemRowSpanPropertyId* = 30066 + UIA_GridItemColumnSpanPropertyId* = 30067 + UIA_GridItemContainingGridPropertyId* = 30068 + UIA_DockDockPositionPropertyId* = 30069 + UIA_ExpandCollapseExpandCollapseStatePropertyId* = 30070 + UIA_MultipleViewCurrentViewPropertyId* = 30071 + UIA_MultipleViewSupportedViewsPropertyId* = 30072 + UIA_WindowCanMaximizePropertyId* = 30073 + UIA_WindowCanMinimizePropertyId* = 30074 + UIA_WindowWindowVisualStatePropertyId* = 30075 + UIA_WindowWindowInteractionStatePropertyId* = 30076 + UIA_WindowIsModalPropertyId* = 30077 + UIA_WindowIsTopmostPropertyId* = 30078 + UIA_SelectionItemIsSelectedPropertyId* = 30079 + UIA_SelectionItemSelectionContainerPropertyId* = 30080 + UIA_TableRowHeadersPropertyId* = 30081 + UIA_TableColumnHeadersPropertyId* = 30082 + UIA_TableRowOrColumnMajorPropertyId* = 30083 + UIA_TableItemRowHeaderItemsPropertyId* = 30084 + UIA_TableItemColumnHeaderItemsPropertyId* = 30085 + UIA_ToggleToggleStatePropertyId* = 30086 + UIA_TransformCanMovePropertyId* = 30087 + UIA_TransformCanResizePropertyId* = 30088 + UIA_TransformCanRotatePropertyId* = 30089 + UIA_IsLegacyIAccessiblePatternAvailablePropertyId* = 30090 + UIA_LegacyIAccessibleChildIdPropertyId* = 30091 + UIA_LegacyIAccessibleNamePropertyId* = 30092 + UIA_LegacyIAccessibleValuePropertyId* = 30093 + UIA_LegacyIAccessibleDescriptionPropertyId* = 30094 + UIA_LegacyIAccessibleRolePropertyId* = 30095 + UIA_LegacyIAccessibleStatePropertyId* = 30096 + UIA_LegacyIAccessibleHelpPropertyId* = 30097 + UIA_LegacyIAccessibleKeyboardShortcutPropertyId* = 30098 + UIA_LegacyIAccessibleSelectionPropertyId* = 30099 + UIA_LegacyIAccessibleDefaultActionPropertyId* = 30100 + UIA_AriaRolePropertyId* = 30101 + UIA_AriaPropertiesPropertyId* = 30102 + UIA_IsDataValidForFormPropertyId* = 30103 + UIA_ControllerForPropertyId* = 30104 + UIA_DescribedByPropertyId* = 30105 + UIA_FlowsToPropertyId* = 30106 + UIA_ProviderDescriptionPropertyId* = 30107 + UIA_IsItemContainerPatternAvailablePropertyId* = 30108 + UIA_IsVirtualizedItemPatternAvailablePropertyId* = 30109 + UIA_IsSynchronizedInputPatternAvailablePropertyId* = 30110 + UIA_OptimizeForVisualContentPropertyId* = 30111 + UIA_IsObjectModelPatternAvailablePropertyId* = 30112 + UIA_AnnotationAnnotationTypeIdPropertyId* = 30113 + UIA_AnnotationAnnotationTypeNamePropertyId* = 30114 + UIA_AnnotationAuthorPropertyId* = 30115 + UIA_AnnotationDateTimePropertyId* = 30116 + UIA_AnnotationTargetPropertyId* = 30117 + UIA_IsAnnotationPatternAvailablePropertyId* = 30118 + UIA_IsTextPattern2AvailablePropertyId* = 30119 + UIA_StylesStyleIdPropertyId* = 30120 + UIA_StylesStyleNamePropertyId* = 30121 + UIA_StylesFillColorPropertyId* = 30122 + UIA_StylesFillPatternStylePropertyId* = 30123 + UIA_StylesShapePropertyId* = 30124 + UIA_StylesFillPatternColorPropertyId* = 30125 + UIA_StylesExtendedPropertiesPropertyId* = 30126 + UIA_IsStylesPatternAvailablePropertyId* = 30127 + UIA_IsSpreadsheetPatternAvailablePropertyId* = 30128 + UIA_SpreadsheetItemFormulaPropertyId* = 30129 + UIA_SpreadsheetItemAnnotationObjectsPropertyId* = 30130 + UIA_SpreadsheetItemAnnotationTypesPropertyId* = 30131 + UIA_IsSpreadsheetItemPatternAvailablePropertyId* = 30132 + UIA_Transform2CanZoomPropertyId* = 30133 + UIA_IsTransformPattern2AvailablePropertyId* = 30134 + UIA_LiveSettingPropertyId* = 30135 + UIA_IsTextChildPatternAvailablePropertyId* = 30136 + UIA_IsDragPatternAvailablePropertyId* = 30137 + UIA_DragIsGrabbedPropertyId* = 30138 + UIA_DragDropEffectPropertyId* = 30139 + UIA_DragDropEffectsPropertyId* = 30140 + UIA_IsDropTargetPatternAvailablePropertyId* = 30141 + UIA_DropTargetDropTargetEffectPropertyId* = 30142 + UIA_DropTargetDropTargetEffectsPropertyId* = 30143 + UIA_DragGrabbedItemsPropertyId* = 30144 + UIA_Transform2ZoomLevelPropertyId* = 30145 + UIA_Transform2ZoomMinimumPropertyId* = 30146 + UIA_Transform2ZoomMaximumPropertyId* = 30147 + UIA_FlowsFromPropertyId* = 30148 + UIA_IsTextEditPatternAvailablePropertyId* = 30149 + UIA_IsPeripheralPropertyId* = 30150 + UIA_IsCustomNavigationPatternAvailablePropertyId* = 30151 + UIA_PositionInSetPropertyId* = 30152 + UIA_SizeOfSetPropertyId* = 30153 + UIA_LevelPropertyId* = 30154 + UIA_AnnotationTypesPropertyId* = 30155 + UIA_AnnotationObjectsPropertyId* = 30156 + UIA_LandmarkTypePropertyId* = 30157 + UIA_LocalizedLandmarkTypePropertyId* = 30158 + UIA_FullDescriptionPropertyId* = 30159 + UIA_FillColorPropertyId* = 30160 + UIA_OutlineColorPropertyId* = 30161 + UIA_FillTypePropertyId* = 30162 + UIA_VisualEffectsPropertyId* = 30163 + UIA_OutlineThicknessPropertyId* = 30164 + UIA_CenterPointPropertyId* = 30165 + UIA_RotationPropertyId* = 30166 + UIA_SizePropertyId* = 30167 + UIA_IsSelectionPattern2AvailablePropertyId* = 30168 + UIA_Selection2FirstSelectedItemPropertyId* = 30169 + UIA_Selection2LastSelectedItemPropertyId* = 30170 + UIA_Selection2CurrentSelectedItemPropertyId* = 30171 + UIA_Selection2ItemCountPropertyId* = 30172 + UIA_HeadingLevelPropertyId* = 30173 + UIA_IsDialogPropertyId* = 30174 + UIA_AnimationStyleAttributeId* = 40000 + UIA_BackgroundColorAttributeId* = 40001 + UIA_BulletStyleAttributeId* = 40002 + UIA_CapStyleAttributeId* = 40003 + UIA_CultureAttributeId* = 40004 + UIA_FontNameAttributeId* = 40005 + UIA_FontSizeAttributeId* = 40006 + UIA_FontWeightAttributeId* = 40007 + UIA_ForegroundColorAttributeId* = 40008 + UIA_HorizontalTextAlignmentAttributeId* = 40009 + UIA_IndentationFirstLineAttributeId* = 40010 + UIA_IndentationLeadingAttributeId* = 40011 + UIA_IndentationTrailingAttributeId* = 40012 + UIA_IsHiddenAttributeId* = 40013 + UIA_IsItalicAttributeId* = 40014 + UIA_IsReadOnlyAttributeId* = 40015 + UIA_IsSubscriptAttributeId* = 40016 + UIA_IsSuperscriptAttributeId* = 40017 + UIA_MarginBottomAttributeId* = 40018 + UIA_MarginLeadingAttributeId* = 40019 + UIA_MarginTopAttributeId* = 40020 + UIA_MarginTrailingAttributeId* = 40021 + UIA_OutlineStylesAttributeId* = 40022 + UIA_OverlineColorAttributeId* = 40023 + UIA_OverlineStyleAttributeId* = 40024 + UIA_StrikethroughColorAttributeId* = 40025 + UIA_StrikethroughStyleAttributeId* = 40026 + UIA_TabsAttributeId* = 40027 + UIA_TextFlowDirectionsAttributeId* = 40028 + UIA_UnderlineColorAttributeId* = 40029 + UIA_UnderlineStyleAttributeId* = 40030 + UIA_AnnotationTypesAttributeId* = 40031 + UIA_AnnotationObjectsAttributeId* = 40032 + UIA_StyleNameAttributeId* = 40033 + UIA_StyleIdAttributeId* = 40034 + UIA_LinkAttributeId* = 40035 + UIA_IsActiveAttributeId* = 40036 + UIA_SelectionActiveEndAttributeId* = 40037 + UIA_CaretPositionAttributeId* = 40038 + UIA_CaretBidiModeAttributeId* = 40039 + UIA_LineSpacingAttributeId* = 40040 + UIA_BeforeParagraphSpacingAttributeId* = 40041 + UIA_AfterParagraphSpacingAttributeId* = 40042 + UIA_SayAsInterpretAsAttributeId* = 40043 + UIA_ButtonControlTypeId* = 50000 + UIA_CalendarControlTypeId* = 50001 + UIA_CheckBoxControlTypeId* = 50002 + UIA_ComboBoxControlTypeId* = 50003 + UIA_EditControlTypeId* = 50004 + UIA_HyperlinkControlTypeId* = 50005 + UIA_ImageControlTypeId* = 50006 + UIA_ListItemControlTypeId* = 50007 + UIA_ListControlTypeId* = 50008 + UIA_MenuControlTypeId* = 50009 + UIA_MenuBarControlTypeId* = 50010 + UIA_MenuItemControlTypeId* = 50011 + UIA_ProgressBarControlTypeId* = 50012 + UIA_RadioButtonControlTypeId* = 50013 + UIA_ScrollBarControlTypeId* = 50014 + UIA_SliderControlTypeId* = 50015 + UIA_SpinnerControlTypeId* = 50016 + UIA_StatusBarControlTypeId* = 50017 + UIA_TabControlTypeId* = 50018 + UIA_TabItemControlTypeId* = 50019 + UIA_TextControlTypeId* = 50020 + UIA_ToolBarControlTypeId* = 50021 + UIA_ToolTipControlTypeId* = 50022 + UIA_TreeControlTypeId* = 50023 + UIA_TreeItemControlTypeId* = 50024 + UIA_CustomControlTypeId* = 50025 + UIA_GroupControlTypeId* = 50026 + UIA_ThumbControlTypeId* = 50027 + UIA_DataGridControlTypeId* = 50028 + UIA_DataItemControlTypeId* = 50029 + UIA_DocumentControlTypeId* = 50030 + UIA_SplitButtonControlTypeId* = 50031 + UIA_WindowControlTypeId* = 50032 + UIA_PaneControlTypeId* = 50033 + UIA_HeaderControlTypeId* = 50034 + UIA_HeaderItemControlTypeId* = 50035 + UIA_TableControlTypeId* = 50036 + UIA_TitleBarControlTypeId* = 50037 + UIA_SeparatorControlTypeId* = 50038 + UIA_SemanticZoomControlTypeId* = 50039 + UIA_AppBarControlTypeId* = 50040 + AnnotationType_Unknown* = 60000 + AnnotationType_SpellingError* = 60001 + AnnotationType_GrammarError* = 60002 + AnnotationType_Comment* = 60003 + AnnotationType_FormulaError* = 60004 + AnnotationType_TrackChanges* = 60005 + AnnotationType_Header* = 60006 + AnnotationType_Footer* = 60007 + AnnotationType_Highlighted* = 60008 + AnnotationType_Endnote* = 60009 + AnnotationType_Footnote* = 60010 + AnnotationType_InsertionChange* = 60011 + AnnotationType_DeletionChange* = 60012 + AnnotationType_MoveChange* = 60013 + AnnotationType_FormatChange* = 60014 + AnnotationType_UnsyncedChange* = 60015 + AnnotationType_EditingLockedChange* = 60016 + AnnotationType_ExternalChange* = 60017 + AnnotationType_ConflictingChange* = 60018 + AnnotationType_Author* = 60019 + AnnotationType_AdvancedProofingIssue* = 60020 + AnnotationType_DataValidationError* = 60021 + AnnotationType_CircularReferenceError* = 60022 + AnnotationType_Mathematics* = 60023 + StyleId_Custom* = 70000 + StyleId_Heading1* = 70001 + StyleId_Heading2* = 70002 + StyleId_Heading3* = 70003 + StyleId_Heading4* = 70004 + StyleId_Heading5* = 70005 + StyleId_Heading6* = 70006 + StyleId_Heading7* = 70007 + StyleId_Heading8* = 70008 + StyleId_Heading9* = 70009 + StyleId_Title* = 70010 + StyleId_Subtitle* = 70011 + StyleId_Normal* = 70012 + StyleId_Emphasis* = 70013 + StyleId_Quote* = 70014 + StyleId_BulletedList* = 70015 + StyleId_NumberedList* = 70016 + UIA_CustomLandmarkTypeId* = 80000 + UIA_FormLandmarkTypeId* = 80001 + UIA_MainLandmarkTypeId* = 80002 + UIA_NavigationLandmarkTypeId* = 80003 + UIA_SearchLandmarkTypeId* = 80004 + HeadingLevel_None* = 80050 + headingLevel1* = 80051 + headingLevel2* = 80052 + headingLevel3* = 80053 + headingLevel4* = 80054 + headingLevel5* = 80055 + headingLevel6* = 80056 + headingLevel7* = 80057 + headingLevel8* = 80058 + headingLevel9* = 80059 + UIA_SummaryChangeId* = 90000 + UIA_SayAsInterpretAsMetadataId* = 100000 + IID_IUIAutomationElement* = DEFINE_GUID("d22108aa-8ac5-49a5-837b-37bbb3d7591e") + IID_IUIAutomationElementArray* = DEFINE_GUID("14314595-b4bc-4055-95f2-58f2e42c9855") + IID_IUIAutomationCondition* = DEFINE_GUID("352ffba8-0973-437c-a61f-f64cafd81df9") + IID_IUIAutomationBoolCondition* = DEFINE_GUID("1b4e1f2e-75eb-4d0b-8952-5a69988e2307") + IID_IUIAutomationPropertyCondition* = DEFINE_GUID("99ebf2cb-5578-4267-9ad4-afd6ea77e94b") + IID_IUIAutomationAndCondition* = DEFINE_GUID("a7d0af36-b912-45fe-9855-091ddc174aec") + IID_IUIAutomationOrCondition* = DEFINE_GUID("8753f032-3db1-47b5-a1fc-6e34a266c712") + IID_IUIAutomationNotCondition* = DEFINE_GUID("f528b657-847b-498c-8896-d52b565407a1") + IID_IUIAutomationCacheRequest* = DEFINE_GUID("b32a92b5-bc25-4078-9c08-d7ee95c48e03") + IID_IUIAutomationTreeWalker* = DEFINE_GUID("4042c624-389c-4afc-a630-9df854a541fc") + IID_IUIAutomationEventHandler* = DEFINE_GUID("146c3c17-f12e-4e22-8c27-f894b9b79c69") + IID_IUIAutomationPropertyChangedEventHandler* = DEFINE_GUID("40cd37d4-c756-4b0c-8c6f-bddfeeb13b50") + IID_IUIAutomationStructureChangedEventHandler* = DEFINE_GUID("e81d1b4e-11c5-42f8-9754-e7036c79f054") + IID_IUIAutomationFocusChangedEventHandler* = DEFINE_GUID("c270f6b5-5c69-4290-9745-7a7f97169468") + IID_IUIAutomationTextEditTextChangedEventHandler* = DEFINE_GUID("92faa680-e704-4156-931a-e32d5bb38f3f") + IID_IUIAutomationChangesEventHandler* = DEFINE_GUID("58edca55-2c3e-4980-b1b9-56c17f27a2a0") + IID_IUIAutomationNotificationEventHandler* = DEFINE_GUID("c7cb2637-e6c2-4d0c-85de-4948c02175c7") + IID_IUIAutomationInvokePattern* = DEFINE_GUID("fb377fbe-8ea6-46d5-9c73-6499642d3059") + IID_IUIAutomationDockPattern* = DEFINE_GUID("fde5ef97-1464-48f6-90bf-43d0948e86ec") + IID_IUIAutomationExpandCollapsePattern* = DEFINE_GUID("619be086-1f4e-4ee4-bafa-210128738730") + IID_IUIAutomationGridPattern* = DEFINE_GUID("414c3cdc-856b-4f5b-8538-3131c6302550") + IID_IUIAutomationGridItemPattern* = DEFINE_GUID("78f8ef57-66c3-4e09-bd7c-e79b2004894d") + IID_IUIAutomationMultipleViewPattern* = DEFINE_GUID("8d253c91-1dc5-4bb5-b18f-ade16fa495e8") + IID_IUIAutomationObjectModelPattern* = DEFINE_GUID("71c284b3-c14d-4d14-981e-19751b0d756d") + IID_IUIAutomationRangeValuePattern* = DEFINE_GUID("59213f4f-7346-49e5-b120-80555987a148") + IID_IUIAutomationScrollPattern* = DEFINE_GUID("88f4d42a-e881-459d-a77c-73bbbb7e02dc") + IID_IUIAutomationScrollItemPattern* = DEFINE_GUID("b488300f-d015-4f19-9c29-bb595e3645ef") + IID_IUIAutomationSelectionPattern* = DEFINE_GUID("5ed5202e-b2ac-47a6-b638-4b0bf140d78e") + IID_IUIAutomationSelectionPattern2* = DEFINE_GUID("0532bfae-c011-4e32-a343-6d642d798555") + IID_IUIAutomationSelectionItemPattern* = DEFINE_GUID("a8efa66a-0fda-421a-9194-38021f3578ea") + IID_IUIAutomationSynchronizedInputPattern* = DEFINE_GUID("2233be0b-afb7-448b-9fda-3b378aa5eae1") + IID_IUIAutomationTablePattern* = DEFINE_GUID("620e691c-ea96-4710-a850-754b24ce2417") + IID_IUIAutomationTableItemPattern* = DEFINE_GUID("0b964eb3-ef2e-4464-9c79-61d61737a27e") + IID_IUIAutomationTogglePattern* = DEFINE_GUID("94cf8058-9b8d-4ab9-8bfd-4cd0a33c8c70") + IID_IUIAutomationTransformPattern* = DEFINE_GUID("a9b55844-a55d-4ef0-926d-569c16ff89bb") + IID_IUIAutomationValuePattern* = DEFINE_GUID("a94cd8b1-0844-4cd6-9d2d-640537ab39e9") + IID_IUIAutomationWindowPattern* = DEFINE_GUID("0faef453-9208-43ef-bbb2-3b485177864f") + IID_IUIAutomationTextRange* = DEFINE_GUID("a543cc6a-f4ae-494b-8239-c814481187a8") + IID_IUIAutomationTextRange2* = DEFINE_GUID("bb9b40e0-5e04-46bd-9be0-4b601b9afad4") + IID_IUIAutomationTextRange3* = DEFINE_GUID("6a315d69-5512-4c2e-85f0-53fce6dd4bc2") + IID_IUIAutomationTextRangeArray* = DEFINE_GUID("ce4ae76a-e717-4c98-81ea-47371d028eb6") + IID_IUIAutomationTextPattern* = DEFINE_GUID("32eba289-3583-42c9-9c59-3b6d9a1e9b6a") + IID_IUIAutomationTextPattern2* = DEFINE_GUID("506a921a-fcc9-409f-b23b-37eb74106872") + IID_IUIAutomationTextEditPattern* = DEFINE_GUID("17e21576-996c-4870-99d9-bff323380c06") + IID_IUIAutomationCustomNavigationPattern* = DEFINE_GUID("01ea217a-1766-47ed-a6cc-acf492854b1f") + IID_IUIAutomationActiveTextPositionChangedEventHandler* = DEFINE_GUID("f97933b0-8dae-4496-8997-5ba015fe0d82") + IID_IUIAutomationLegacyIAccessiblePattern* = DEFINE_GUID("828055ad-355b-4435-86d5-3b51c14a9b1b") + IID_IUIAutomationItemContainerPattern* = DEFINE_GUID("c690fdb2-27a8-423c-812d-429773c9084e") + IID_IUIAutomationVirtualizedItemPattern* = DEFINE_GUID("6ba3d7a6-04cf-4f11-8793-a8d1cde9969f") + IID_IUIAutomationAnnotationPattern* = DEFINE_GUID("9a175b21-339e-41b1-8e8b-623f6b681098") + IID_IUIAutomationStylesPattern* = DEFINE_GUID("85b5f0a2-bd79-484a-ad2b-388c9838d5fb") + IID_IUIAutomationSpreadsheetPattern* = DEFINE_GUID("7517a7c8-faae-4de9-9f08-29b91e8595c1") + IID_IUIAutomationSpreadsheetItemPattern* = DEFINE_GUID("7d4fb86c-8d34-40e1-8e83-62c15204e335") + IID_IUIAutomationTransformPattern2* = DEFINE_GUID("6d74d017-6ecb-4381-b38b-3c17a48ff1c2") + IID_IUIAutomationTextChildPattern* = DEFINE_GUID("6552b038-ae05-40c8-abfd-aa08352aab86") + IID_IUIAutomationDragPattern* = DEFINE_GUID("1dc7b570-1f54-4bad-bcda-d36a722fb7bd") + IID_IUIAutomationDropTargetPattern* = DEFINE_GUID("69a095f7-eee4-430e-a46b-fb73b1ae39a5") + IID_IUIAutomationElement2* = DEFINE_GUID("6749c683-f70d-4487-a698-5f79d55290d6") + IID_IUIAutomationElement3* = DEFINE_GUID("8471df34-aee0-4a01-a7de-7db9af12c296") + IID_IUIAutomationElement4* = DEFINE_GUID("3b6e233c-52fb-4063-a4c9-77c075c2a06b") + IID_IUIAutomationElement5* = DEFINE_GUID("98141c1d-0d0e-4175-bbe2-6bff455842a7") + IID_IUIAutomationElement6* = DEFINE_GUID("4780d450-8bca-4977-afa5-a4a517f555e3") + IID_IUIAutomationElement7* = DEFINE_GUID("204e8572-cfc3-4c11-b0c8-7da7420750b7") + IID_IUIAutomationElement8* = DEFINE_GUID("8c60217d-5411-4cde-bcc0-1ceda223830c") + IID_IUIAutomationElement9* = DEFINE_GUID("39325fac-039d-440e-a3a3-5eb81a5cecc3") + IID_IUIAutomationProxyFactory* = DEFINE_GUID("85b94ecd-849d-42b6-b94d-d6db23fdf5a4") + IID_IUIAutomationProxyFactoryEntry* = DEFINE_GUID("d50e472e-b64b-490c-bca1-d30696f9f289") + IID_IUIAutomationProxyFactoryMapping* = DEFINE_GUID("09e31e18-872d-4873-93d1-1e541ec133fd") + IID_IUIAutomationEventHandlerGroup* = DEFINE_GUID("c9ee12f2-c13b-4408-997c-639914377f4e") + IID_IUIAutomation* = DEFINE_GUID("30cbe57d-d9d0-452a-ab13-7ac5ac4825ee") + IID_IUIAutomation2* = DEFINE_GUID("34723aff-0c9d-49d0-9896-7ab52df8cd8a") + IID_IUIAutomation3* = DEFINE_GUID("73d768da-9b51-4b89-936e-c209290973e7") + IID_IUIAutomation4* = DEFINE_GUID("1189c02a-05f8-4319-8e21-e817e3db2860") + IID_IUIAutomation5* = DEFINE_GUID("25f700c8-d816-4057-a9dc-3cbdee77e256") + IID_IUIAutomation6* = DEFINE_GUID("aae072da-29e3-413d-87a7-192dbf81ed10") + CLSID_CUIAutomation* = DEFINE_GUID("ff48dba4-60ef-4201-aa87-54103eef594e") + CLSID_CUIAutomation8* = DEFINE_GUID("e22ad333-b25f-460c-83d0-0581107395c9") + UIA_E_ELEMENTNOTENABLED* = 0x80040200'i32 + UIA_E_ELEMENTNOTAVAILABLE* = 0x80040201'i32 + UIA_E_NOCLICKABLEPOINT* = 0x80040202'i32 + UIA_E_PROXYASSEMBLYNOTLOADED* = 0x80040203'i32 + UIA_E_NOTSUPPORTED* = 0x80040204'i32 + UIA_E_INVALIDOPERATION* = 0x80131509'i32 + UIA_E_TIMEOUT* = 0x80131505'i32 + uiaAppendRuntimeId* = 3 + uiaRootObjectId* = -25 + RuntimeId_Property_GUID* = DEFINE_GUID("a39eebfa-7fba-4c89-b4d4-b99e2de7d160") + BoundingRectangle_Property_GUID* = DEFINE_GUID("7bbfe8b2-3bfc-48dd-b729-c794b846e9a1") + ProcessId_Property_GUID* = DEFINE_GUID("40499998-9c31-4245-a403-87320e59eaf6") + ControlType_Property_GUID* = DEFINE_GUID("ca774fea-28ac-4bc2-94ca-acec6d6c10a3") + LocalizedControlType_Property_GUID* = DEFINE_GUID("8763404f-a1bd-452a-89c4-3f01d3833806") + Name_Property_GUID* = DEFINE_GUID("c3a6921b-4a99-44f1-bca6-61187052c431") + AcceleratorKey_Property_GUID* = DEFINE_GUID("514865df-2557-4cb9-aeed-6ced084ce52c") + AccessKey_Property_GUID* = DEFINE_GUID("06827b12-a7f9-4a15-917c-ffa5ad3eb0a7") + HasKeyboardFocus_Property_GUID* = DEFINE_GUID("cf8afd39-3f46-4800-9656-b2bf12529905") + IsKeyboardFocusable_Property_GUID* = DEFINE_GUID("f7b8552a-0859-4b37-b9cb-51e72092f29f") + IsEnabled_Property_GUID* = DEFINE_GUID("2109427f-da60-4fed-bf1b-264bdce6eb3a") + AutomationId_Property_GUID* = DEFINE_GUID("c82c0500-b60e-4310-a267-303c531f8ee5") + ClassName_Property_GUID* = DEFINE_GUID("157b7215-894f-4b65-84e2-aac0da08b16b") + HelpText_Property_GUID* = DEFINE_GUID("08555685-0977-45c7-a7a6-abaf5684121a") + ClickablePoint_Property_GUID* = DEFINE_GUID("0196903b-b203-4818-a9f3-f08e675f2341") + Culture_Property_GUID* = DEFINE_GUID("e2d74f27-3d79-4dc2-b88b-3044963a8afb") + IsControlElement_Property_GUID* = DEFINE_GUID("95f35085-abcc-4afd-a5f4-dbb46c230fdb") + IsContentElement_Property_GUID* = DEFINE_GUID("4bda64a8-f5d8-480b-8155-ef2e89adb672") + LabeledBy_Property_GUID* = DEFINE_GUID("e5b8924b-fc8a-4a35-8031-cf78ac43e55e") + IsPassword_Property_GUID* = DEFINE_GUID("e8482eb1-687c-497b-bebc-03be53ec1454") + NewNativeWindowHandle_Property_GUID* = DEFINE_GUID("5196b33b-380a-4982-95e1-91f3ef60e024") + ItemType_Property_GUID* = DEFINE_GUID("cdda434d-6222-413b-a68a-325dd1d40f39") + IsOffscreen_Property_GUID* = DEFINE_GUID("03c3d160-db79-42db-a2ef-1c231eede507") + Orientation_Property_GUID* = DEFINE_GUID("a01eee62-3884-4415-887e-678ec21e39ba") + FrameworkId_Property_GUID* = DEFINE_GUID("dbfd9900-7e1a-4f58-b61b-7063120f773b") + IsRequiredForForm_Property_GUID* = DEFINE_GUID("4f5f43cf-59fb-4bde-a270-602e5e1141e9") + ItemStatus_Property_GUID* = DEFINE_GUID("51de0321-3973-43e7-8913-0b08e813c37f") + AriaRole_Property_GUID* = DEFINE_GUID("dd207b95-be4a-4e0d-b727-63ace94b6916") + AriaProperties_Property_GUID* = DEFINE_GUID("4213678c-e025-4922-beb5-e43ba08e6221") + IsDataValidForForm_Property_GUID* = DEFINE_GUID("445ac684-c3fc-4dd9-acf8-845a579296ba") + ControllerFor_Property_GUID* = DEFINE_GUID("51124c8a-a5d2-4f13-9be6-7fa8ba9d3a90") + DescribedBy_Property_GUID* = DEFINE_GUID("7c5865b8-9992-40fd-8db0-6bf1d317f998") + FlowsTo_Property_GUID* = DEFINE_GUID("e4f33d20-559a-47fb-a830-f9cb4ff1a70a") + ProviderDescription_Property_GUID* = DEFINE_GUID("dca5708a-c16b-4cd9-b889-beb16a804904") + OptimizeForVisualContent_Property_GUID* = DEFINE_GUID("6a852250-c75a-4e5d-b858-e381b0f78861") + IsDockPatternAvailable_Property_GUID* = DEFINE_GUID("2600a4c4-2ff8-4c96-ae31-8fe619a13c6c") + IsExpandCollapsePatternAvailable_Property_GUID* = DEFINE_GUID("929d3806-5287-4725-aa16-222afc63d595") + IsGridItemPatternAvailable_Property_GUID* = DEFINE_GUID("5a43e524-f9a2-4b12-84c8-b48a3efedd34") + IsGridPatternAvailable_Property_GUID* = DEFINE_GUID("5622c26c-f0ef-4f3b-97cb-714c0868588b") + IsInvokePatternAvailable_Property_GUID* = DEFINE_GUID("4e725738-8364-4679-aa6c-f3f41931f750") + IsMultipleViewPatternAvailable_Property_GUID* = DEFINE_GUID("ff0a31eb-8e25-469d-8d6e-e771a27c1b90") + IsRangeValuePatternAvailable_Property_GUID* = DEFINE_GUID("fda4244a-eb4d-43ff-b5ad-ed36d373ec4c") + IsScrollPatternAvailable_Property_GUID* = DEFINE_GUID("3ebb7b4a-828a-4b57-9d22-2fea1632ed0d") + IsScrollItemPatternAvailable_Property_GUID* = DEFINE_GUID("1cad1a05-0927-4b76-97e1-0fcdb209b98a") + IsSelectionItemPatternAvailable_Property_GUID* = DEFINE_GUID("8becd62d-0bc3-4109-bee2-8e6715290e68") + IsSelectionPatternAvailable_Property_GUID* = DEFINE_GUID("f588acbe-c769-4838-9a60-2686dc1188c4") + IsTablePatternAvailable_Property_GUID* = DEFINE_GUID("cb83575f-45c2-4048-9c76-159715a139df") + IsTableItemPatternAvailable_Property_GUID* = DEFINE_GUID("eb36b40d-8ea4-489b-a013-e60d5951fe34") + IsTextPatternAvailable_Property_GUID* = DEFINE_GUID("fbe2d69d-aff6-4a45-82e2-fc92a82f5917") + IsTogglePatternAvailable_Property_GUID* = DEFINE_GUID("78686d53-fcd0-4b83-9b78-5832ce63bb5b") + IsTransformPatternAvailable_Property_GUID* = DEFINE_GUID("a7f78804-d68b-4077-a5c6-7a5ea1ac31c5") + IsValuePatternAvailable_Property_GUID* = DEFINE_GUID("0b5020a7-2119-473b-be37-5ceb98bbfb22") + IsWindowPatternAvailable_Property_GUID* = DEFINE_GUID("e7a57bb1-5888-4155-98dc-b422fd57f2bc") + IsLegacyIAccessiblePatternAvailable_Property_GUID* = DEFINE_GUID("d8ebd0c7-929a-4ee7-8d3a-d3d94413027b") + IsItemContainerPatternAvailable_Property_GUID* = DEFINE_GUID("624b5ca7-fe40-4957-a019-20c4cf11920f") + IsVirtualizedItemPatternAvailable_Property_GUID* = DEFINE_GUID("302cb151-2ac8-45d6-977b-d2b3a5a53f20") + IsSynchronizedInputPatternAvailable_Property_GUID* = DEFINE_GUID("75d69cc5-d2bf-4943-876e-b45b62a6cc66") + IsObjectModelPatternAvailable_Property_GUID* = DEFINE_GUID("6b21d89b-2841-412f-8ef2-15ca952318ba") + IsAnnotationPatternAvailable_Property_GUID* = DEFINE_GUID("0b5b3238-6d5c-41b6-bcc4-5e807f6551c4") + IsTextPattern2Available_Property_GUID* = DEFINE_GUID("41cf921d-e3f1-4b22-9c81-e1c3ed331c22") + IsTextEditPatternAvailable_Property_GUID* = DEFINE_GUID("7843425c-8b32-484c-9ab5-e3200571ffda") + IsCustomNavigationPatternAvailable_Property_GUID* = DEFINE_GUID("8f8e80d4-2351-48e0-874a-54aa7313889a") + IsStylesPatternAvailable_Property_GUID* = DEFINE_GUID("27f353d3-459c-4b59-a490-50611dacafb5") + IsSpreadsheetPatternAvailable_Property_GUID* = DEFINE_GUID("6ff43732-e4b4-4555-97bc-ecdbbc4d1888") + IsSpreadsheetItemPatternAvailable_Property_GUID* = DEFINE_GUID("9fe79b2a-2f94-43fd-996b-549e316f4acd") + IsTransformPattern2Available_Property_GUID* = DEFINE_GUID("25980b4b-be04-4710-ab4a-fda31dbd2895") + IsTextChildPatternAvailable_Property_GUID* = DEFINE_GUID("559e65df-30ff-43b5-b5ed-5b283b80c7e9") + IsDragPatternAvailable_Property_GUID* = DEFINE_GUID("e997a7b7-1d39-4ca7-be0f-277fcf5605cc") + IsDropTargetPatternAvailable_Property_GUID* = DEFINE_GUID("0686b62e-8e19-4aaf-873d-384f6d3b92be") + IsPeripheral_Property_GUID* = DEFINE_GUID("da758276-7ed5-49d4-8e68-ecc9a2d300dd") + PositionInSet_Property_GUID* = DEFINE_GUID("33d1dc54-641e-4d76-a6b1-13f341c1f896") + SizeOfSet_Property_GUID* = DEFINE_GUID("1600d33c-3b9f-4369-9431-aa293f344cf1") + Level_Property_GUID* = DEFINE_GUID("242ac529-cd36-400f-aad9-7876ef3af627") + AnnotationTypes_Property_GUID* = DEFINE_GUID("64b71f76-53c4-4696-a219-20e940c9a176") + AnnotationObjects_Property_GUID* = DEFINE_GUID("310910c8-7c6e-4f20-becd-4aaf6d191156") + LandmarkType_Property_GUID* = DEFINE_GUID("454045f2-6f61-49f7-a4f8-b5f0cf82da1e") + LocalizedLandmarkType_Property_GUID* = DEFINE_GUID("7ac81980-eafb-4fb2-bf91-f485bef5e8e1") + FullDescription_Property_GUID* = DEFINE_GUID("0d4450ff-6aef-4f33-95dd-7befa72a4391") + Value_Value_Property_GUID* = DEFINE_GUID("e95f5e64-269f-4a85-ba99-4092c3ea2986") + Value_IsReadOnly_Property_GUID* = DEFINE_GUID("eb090f30-e24c-4799-a705-0d247bc037f8") + RangeValue_Value_Property_GUID* = DEFINE_GUID("131f5d98-c50c-489d-abe5-ae220898c5f7") + RangeValue_IsReadOnly_Property_GUID* = DEFINE_GUID("25fa1055-debf-4373-a79e-1f1a1908d3c4") + RangeValue_Minimum_Property_GUID* = DEFINE_GUID("78cbd3b2-684d-4860-af93-d1f95cb022fd") + RangeValue_Maximum_Property_GUID* = DEFINE_GUID("19319914-f979-4b35-a1a6-d37e05433473") + RangeValue_LargeChange_Property_GUID* = DEFINE_GUID("a1f96325-3a3d-4b44-8e1f-4a46d9844019") + RangeValue_SmallChange_Property_GUID* = DEFINE_GUID("81c2c457-3941-4107-9975-139760f7c072") + Scroll_HorizontalScrollPercent_Property_GUID* = DEFINE_GUID("c7c13c0e-eb21-47ff-acc4-b5a3350f5191") + Scroll_HorizontalViewSize_Property_GUID* = DEFINE_GUID("70c2e5d4-fcb0-4713-a9aa-af92ff79e4cd") + Scroll_VerticalScrollPercent_Property_GUID* = DEFINE_GUID("6c8d7099-b2a8-4948-bff7-3cf9058bfefb") + Scroll_VerticalViewSize_Property_GUID* = DEFINE_GUID("de6a2e22-d8c7-40c5-83ba-e5f681d53108") + Scroll_HorizontallyScrollable_Property_GUID* = DEFINE_GUID("8b925147-28cd-49ae-bd63-f44118d2e719") + Scroll_VerticallyScrollable_Property_GUID* = DEFINE_GUID("89164798-0068-4315-b89a-1e7cfbbc3dfc") + Selection_Selection_Property_GUID* = DEFINE_GUID("aa6dc2a2-0e2b-4d38-96d5-34e470b81853") + Selection_CanSelectMultiple_Property_GUID* = DEFINE_GUID("49d73da5-c883-4500-883d-8fcf8daf6cbe") + Selection_IsSelectionRequired_Property_GUID* = DEFINE_GUID("b1ae4422-63fe-44e7-a5a5-a738c829b19a") + Grid_RowCount_Property_GUID* = DEFINE_GUID("2a9505bf-c2eb-4fb6-b356-8245ae53703e") + Grid_ColumnCount_Property_GUID* = DEFINE_GUID("fe96f375-44aa-4536-ac7a-2a75d71a3efc") + GridItem_Row_Property_GUID* = DEFINE_GUID("6223972a-c945-4563-9329-fdc974af2553") + GridItem_Column_Property_GUID* = DEFINE_GUID("c774c15c-62c0-4519-8bdc-47be573c8ad5") + GridItem_RowSpan_Property_GUID* = DEFINE_GUID("4582291c-466b-4e93-8e83-3d1715ec0c5e") + GridItem_ColumnSpan_Property_GUID* = DEFINE_GUID("583ea3f5-86d0-4b08-a6ec-2c5463ffc109") + GridItem_Parent_Property_GUID* = DEFINE_GUID("9d912252-b97f-4ecc-8510-ea0e33427c72") + Dock_DockPosition_Property_GUID* = DEFINE_GUID("6d67f02e-c0b0-4b10-b5b9-18d6ecf98760") + ExpandCollapse_ExpandCollapseState_Property_GUID* = DEFINE_GUID("275a4c48-85a7-4f69-aba0-af157610002b") + MultipleView_CurrentView_Property_GUID* = DEFINE_GUID("7a81a67a-b94f-4875-918b-65c8d2f998e5") + MultipleView_SupportedViews_Property_GUID* = DEFINE_GUID("8d5db9fd-ce3c-4ae7-b788-400a3c645547") + Window_CanMaximize_Property_GUID* = DEFINE_GUID("64fff53f-635d-41c1-950c-cb5adfbe28e3") + Window_CanMinimize_Property_GUID* = DEFINE_GUID("b73b4625-5988-4b97-b4c2-a6fe6e78c8c6") + Window_WindowVisualState_Property_GUID* = DEFINE_GUID("4ab7905f-e860-453e-a30a-f6431e5daad5") + Window_WindowInteractionState_Property_GUID* = DEFINE_GUID("4fed26a4-0455-4fa2-b21c-c4da2db1ff9c") + Window_IsModal_Property_GUID* = DEFINE_GUID("ff4e6892-37b9-4fca-8532-ffe674ecfeed") + Window_IsTopmost_Property_GUID* = DEFINE_GUID("ef7d85d3-0937-4962-9241-b62345f24041") + SelectionItem_IsSelected_Property_GUID* = DEFINE_GUID("f122835f-cd5f-43df-b79d-4b849e9e6020") + SelectionItem_SelectionContainer_Property_GUID* = DEFINE_GUID("a4365b6e-9c1e-4b63-8b53-c2421dd1e8fb") + Table_RowHeaders_Property_GUID* = DEFINE_GUID("d9e35b87-6eb8-4562-aac6-a8a9075236a8") + Table_ColumnHeaders_Property_GUID* = DEFINE_GUID("aff1d72b-968d-42b1-b459-150b299da664") + Table_RowOrColumnMajor_Property_GUID* = DEFINE_GUID("83be75c3-29fe-4a30-85e1-2a6277fd106e") + TableItem_RowHeaderItems_Property_GUID* = DEFINE_GUID("b3f853a0-0574-4cd8-bcd7-ed5923572d97") + TableItem_ColumnHeaderItems_Property_GUID* = DEFINE_GUID("967a56a3-74b6-431e-8de6-99c411031c58") + Toggle_ToggleState_Property_GUID* = DEFINE_GUID("b23cdc52-22c2-4c6c-9ded-f5c422479ede") + Transform_CanMove_Property_GUID* = DEFINE_GUID("1b75824d-208b-4fdf-bccd-f1f4e5741f4f") + Transform_CanResize_Property_GUID* = DEFINE_GUID("bb98dca5-4c1a-41d4-a4f6-ebc128644180") + Transform_CanRotate_Property_GUID* = DEFINE_GUID("10079b48-3849-476f-ac96-44a95c8440d9") + LegacyIAccessible_ChildId_Property_GUID* = DEFINE_GUID("9a191b5d-9ef2-4787-a459-dcde885dd4e8") + LegacyIAccessible_Name_Property_GUID* = DEFINE_GUID("caeb063d-40ae-4869-aa5a-1b8e5d666739") + LegacyIAccessible_Value_Property_GUID* = DEFINE_GUID("b5c5b0b6-8217-4a77-97a5-190a85ed0156") + LegacyIAccessible_Description_Property_GUID* = DEFINE_GUID("46448418-7d70-4ea9-9d27-b7e775cf2ad7") + LegacyIAccessible_Role_Property_GUID* = DEFINE_GUID("6856e59f-cbaf-4e31-93e8-bcbf6f7e491c") + LegacyIAccessible_State_Property_GUID* = DEFINE_GUID("df985854-2281-4340-ab9c-c60e2c5803f6") + LegacyIAccessible_Help_Property_GUID* = DEFINE_GUID("94402352-161c-4b77-a98d-a872cc33947a") + LegacyIAccessible_KeyboardShortcut_Property_GUID* = DEFINE_GUID("8f6909ac-00b8-4259-a41c-966266d43a8a") + LegacyIAccessible_Selection_Property_GUID* = DEFINE_GUID("8aa8b1e0-0891-40cc-8b06-90d7d4166219") + LegacyIAccessible_DefaultAction_Property_GUID* = DEFINE_GUID("3b331729-eaad-4502-b85f-92615622913c") + Annotation_AnnotationTypeId_Property_GUID* = DEFINE_GUID("20ae484f-69ef-4c48-8f5b-c4938b206ac7") + Annotation_AnnotationTypeName_Property_GUID* = DEFINE_GUID("9b818892-5ac9-4af9-aa96-f58a77b058e3") + Annotation_Author_Property_GUID* = DEFINE_GUID("7a528462-9c5c-4a03-a974-8b307a9937f2") + Annotation_DateTime_Property_GUID* = DEFINE_GUID("99b5ca5d-1acf-414b-a4d0-6b350b047578") + Annotation_Target_Property_GUID* = DEFINE_GUID("b71b302d-2104-44ad-9c5c-092b4907d70f") + Styles_StyleId_Property_GUID* = DEFINE_GUID("da82852f-3817-4233-82af-02279e72cc77") + Styles_StyleName_Property_GUID* = DEFINE_GUID("1c12b035-05d1-4f55-9e8e-1489f3ff550d") + Styles_FillColor_Property_GUID* = DEFINE_GUID("63eff97a-a1c5-4b1d-84eb-b765f2edd632") + Styles_FillPatternStyle_Property_GUID* = DEFINE_GUID("81cf651f-482b-4451-a30a-e1545e554fb8") + Styles_Shape_Property_GUID* = DEFINE_GUID("c71a23f8-778c-400d-8458-3b543e526984") + Styles_FillPatternColor_Property_GUID* = DEFINE_GUID("939a59fe-8fbd-4e75-a271-ac4595195163") + Styles_ExtendedProperties_Property_GUID* = DEFINE_GUID("f451cda0-ba0a-4681-b0b0-0dbdb53e58f3") + SpreadsheetItem_Formula_Property_GUID* = DEFINE_GUID("e602e47d-1b47-4bea-87cf-3b0b0b5c15b6") + SpreadsheetItem_AnnotationObjects_Property_GUID* = DEFINE_GUID("a3194c38-c9bc-4604-9396-ae3f9f457f7b") + SpreadsheetItem_AnnotationTypes_Property_GUID* = DEFINE_GUID("c70c51d0-d602-4b45-afbc-b4712b96d72b") + Transform2_CanZoom_Property_GUID* = DEFINE_GUID("f357e890-a756-4359-9ca6-86702bf8f381") + LiveSetting_Property_GUID* = DEFINE_GUID("c12bcd8e-2a8e-4950-8ae7-3625111d58eb") + Drag_IsGrabbed_Property_GUID* = DEFINE_GUID("45f206f3-75cc-4cca-a9b9-fcdfb982d8a2") + Drag_GrabbedItems_Property_GUID* = DEFINE_GUID("77c1562c-7b86-4b21-9ed7-3cefda6f4c43") + Drag_DropEffect_Property_GUID* = DEFINE_GUID("646f2779-48d3-4b23-8902-4bf100005df3") + Drag_DropEffects_Property_GUID* = DEFINE_GUID("f5d61156-7ce6-49be-a836-9269dcec920f") + DropTarget_DropTargetEffect_Property_GUID* = DEFINE_GUID("8bb75975-a0ca-4981-b818-87fc66e9509d") + DropTarget_DropTargetEffects_Property_GUID* = DEFINE_GUID("bc1dd4ed-cb89-45f1-a592-e03b08ae790f") + Transform2_ZoomLevel_Property_GUID* = DEFINE_GUID("eee29f1a-f4a2-4b5b-ac65-95cf93283387") + Transform2_ZoomMinimum_Property_GUID* = DEFINE_GUID("742ccc16-4ad1-4e07-96fe-b122c6e6b22b") + Transform2_ZoomMaximum_Property_GUID* = DEFINE_GUID("42ab6b77-ceb0-4eca-b82a-6cfa5fa1fc08") + FlowsFrom_Property_GUID* = DEFINE_GUID("05c6844f-19de-48f8-95fa-880d5b0fd615") + FillColor_Property_GUID* = DEFINE_GUID("6e0ec4d0-e2a8-4a56-9de7-953389933b39") + OutlineColor_Property_GUID* = DEFINE_GUID("c395d6c0-4b55-4762-a073-fd303a634f52") + FillType_Property_GUID* = DEFINE_GUID("c6fc74e4-8cb9-429c-a9e1-9bc4ac372b62") + VisualEffects_Property_GUID* = DEFINE_GUID("e61a8565-aad9-46d7-9e70-4e8a8420d420") + OutlineThickness_Property_GUID* = DEFINE_GUID("13e67cc7-dac2-4888-bdd3-375c62fa9618") + CenterPoint_Property_GUID* = DEFINE_GUID("0cb00c08-540c-4edb-9445-26359ea69785") + Rotation_Property_GUID* = DEFINE_GUID("767cdc7d-aec0-4110-ad32-30edd403492e") + Size_Property_GUID* = DEFINE_GUID("2b5f761d-f885-4404-973f-9b1d98e36d8f") + ToolTipOpened_Event_GUID* = DEFINE_GUID("3f4b97ff-2edc-451d-bca4-95a3188d5b03") + ToolTipClosed_Event_GUID* = DEFINE_GUID("276d71ef-24a9-49b6-8e97-da98b401bbcd") + StructureChanged_Event_GUID* = DEFINE_GUID("59977961-3edd-4b11-b13b-676b2a2a6ca9") + MenuOpened_Event_GUID* = DEFINE_GUID("ebe2e945-66ca-4ed1-9ff8-2ad7df0a1b08") + AutomationPropertyChanged_Event_GUID* = DEFINE_GUID("2527fba1-8d7a-4630-a4cc-e66315942f52") + AutomationFocusChanged_Event_GUID* = DEFINE_GUID("b68a1f17-f60d-41a7-a3cc-b05292155fe0") + ActiveTextPositionChanged_Event_GUID* = DEFINE_GUID("a5c09e9c-c77d-4f25-b491-e5bb7017cbd4") + AsyncContentLoaded_Event_GUID* = DEFINE_GUID("5fdee11c-d2fa-4fb9-904e-5cbee894d5ef") + MenuClosed_Event_GUID* = DEFINE_GUID("3cf1266e-1582-4041-acd7-88a35a965297") + LayoutInvalidated_Event_GUID* = DEFINE_GUID("ed7d6544-a6bd-4595-9bae-3d28946cc715") + Invoke_Invoked_Event_GUID* = DEFINE_GUID("dfd699f0-c915-49dd-b422-dde785c3d24b") + SelectionItem_ElementAddedToSelectionEvent_Event_GUID* = DEFINE_GUID("3c822dd1-c407-4dba-91dd-79d4aed0aec6") + SelectionItem_ElementRemovedFromSelectionEvent_Event_GUID* = DEFINE_GUID("097fa8a9-7079-41af-8b9c-0934d8305e5c") + SelectionItem_ElementSelectedEvent_Event_GUID* = DEFINE_GUID("b9c7dbfb-4ebe-4532-aaf4-008cf647233c") + Selection_InvalidatedEvent_Event_GUID* = DEFINE_GUID("cac14904-16b4-4b53-8e47-4cb1df267bb7") + Text_TextSelectionChangedEvent_Event_GUID* = DEFINE_GUID("918edaa1-71b3-49ae-9741-79beb8d358f3") + Text_TextChangedEvent_Event_GUID* = DEFINE_GUID("4a342082-f483-48c4-ac11-a84b435e2a84") + Window_WindowOpened_Event_GUID* = DEFINE_GUID("d3e81d06-de45-4f2f-9633-de9e02fb65af") + Window_WindowClosed_Event_GUID* = DEFINE_GUID("edf141f8-fa67-4e22-bbf7-944e05735ee2") + MenuModeStart_Event_GUID* = DEFINE_GUID("18d7c631-166a-4ac9-ae3b-ef4b5420e681") + MenuModeEnd_Event_GUID* = DEFINE_GUID("9ecd4c9f-80dd-47b8-8267-5aec06bb2cff") + InputReachedTarget_Event_GUID* = DEFINE_GUID("93ed549a-0549-40f0-bedb-28e44f7de2a3") + InputReachedOtherElement_Event_GUID* = DEFINE_GUID("ed201d8a-4e6c-415e-a874-2460c9b66ba8") + InputDiscarded_Event_GUID* = DEFINE_GUID("7f36c367-7b18-417c-97e3-9d58ddc944ab") + SystemAlert_Event_GUID* = DEFINE_GUID("d271545d-7a3a-47a7-8474-81d29a2451c9") + LiveRegionChanged_Event_GUID* = DEFINE_GUID("102d5e90-e6a9-41b6-b1c5-a9b1929d9510") + HostedFragmentRootsInvalidated_Event_GUID* = DEFINE_GUID("e6bdb03e-0921-4ec5-8dcf-eae877b0426b") + Drag_DragStart_Event_GUID* = DEFINE_GUID("883a480b-3aa9-429d-95e4-d9c8d011f0dd") + Drag_DragCancel_Event_GUID* = DEFINE_GUID("c3ede6fa-3451-4e0f-9e71-df9c280a4657") + Drag_DragComplete_Event_GUID* = DEFINE_GUID("38e96188-ef1f-463e-91ca-3a7792c29caf") + DropTarget_DragEnter_Event_GUID* = DEFINE_GUID("aad9319b-032c-4a88-961d-1cf579581e34") + DropTarget_DragLeave_Event_GUID* = DEFINE_GUID("0f82eb15-24a2-4988-9217-de162aee272b") + DropTarget_Dropped_Event_GUID* = DEFINE_GUID("622cead8-1edb-4a3d-abbc-be2211ff68b5") + Invoke_Pattern_GUID* = DEFINE_GUID("d976c2fc-66ea-4a6e-b28f-c24c7546ad37") + Selection_Pattern_GUID* = DEFINE_GUID("66e3b7e8-d821-4d25-8761-435d2c8b253f") + Value_Pattern_GUID* = DEFINE_GUID("17faad9e-c877-475b-b933-77332779b637") + RangeValue_Pattern_GUID* = DEFINE_GUID("18b00d87-b1c9-476a-bfbd-5f0bdb926f63") + Scroll_Pattern_GUID* = DEFINE_GUID("895fa4b4-759d-4c50-8e15-03460672003c") + ExpandCollapse_Pattern_GUID* = DEFINE_GUID("ae05efa2-f9d1-428a-834c-53a5c52f9b8b") + Grid_Pattern_GUID* = DEFINE_GUID("260a2ccb-93a8-4e44-a4c1-3df397f2b02b") + GridItem_Pattern_GUID* = DEFINE_GUID("f2d5c877-a462-4957-a2a5-2c96b303bc63") + MultipleView_Pattern_GUID* = DEFINE_GUID("547a6ae4-113f-47c4-850f-db4dfa466b1d") + Window_Pattern_GUID* = DEFINE_GUID("27901735-c760-4994-ad11-5919e606b110") + SelectionItem_Pattern_GUID* = DEFINE_GUID("9bc64eeb-87c7-4b28-94bb-4d9fa437b6ef") + Dock_Pattern_GUID* = DEFINE_GUID("9cbaa846-83c8-428d-827f-7e6063fe0620") + Table_Pattern_GUID* = DEFINE_GUID("c415218e-a028-461e-aa92-8f925cf79351") + TableItem_Pattern_GUID* = DEFINE_GUID("df1343bd-1888-4a29-a50c-b92e6de37f6f") + Text_Pattern_GUID* = DEFINE_GUID("8615f05d-7de5-44fd-a679-2ca4b46033a8") + Toggle_Pattern_GUID* = DEFINE_GUID("0b419760-e2f4-43ff-8c5f-9457c82b56e9") + Transform_Pattern_GUID* = DEFINE_GUID("24b46fdb-587e-49f1-9c4a-d8e98b664b7b") + ScrollItem_Pattern_GUID* = DEFINE_GUID("4591d005-a803-4d5c-b4d5-8d2800f906a7") + LegacyIAccessible_Pattern_GUID* = DEFINE_GUID("54cc0a9f-3395-48af-ba8d-73f85690f3e0") + ItemContainer_Pattern_GUID* = DEFINE_GUID("3d13da0f-8b9a-4a99-85fa-c5c9a69f1ed4") + VirtualizedItem_Pattern_GUID* = DEFINE_GUID("f510173e-2e71-45e9-a6e5-62f6ed8289d5") + SynchronizedInput_Pattern_GUID* = DEFINE_GUID("05c288a6-c47b-488b-b653-33977a551b8b") + ObjectModel_Pattern_GUID* = DEFINE_GUID("3e04acfe-08fc-47ec-96bc-353fa3b34aa7") + Annotation_Pattern_GUID* = DEFINE_GUID("f6c72ad7-356c-4850-9291-316f608a8c84") + Text_Pattern2_GUID* = DEFINE_GUID("498479a2-5b22-448d-b6e4-647490860698") + TextEdit_Pattern_GUID* = DEFINE_GUID("69f3ff89-5af9-4c75-9340-f2de292e4591") + CustomNavigation_Pattern_GUID* = DEFINE_GUID("afea938a-621e-4054-bb2c-2f46114dac3f") + Styles_Pattern_GUID* = DEFINE_GUID("1ae62655-da72-4d60-a153-e5aa6988e3bf") + Spreadsheet_Pattern_GUID* = DEFINE_GUID("6a5b24c9-9d1e-4b85-9e44-c02e3169b10b") + SpreadsheetItem_Pattern_GUID* = DEFINE_GUID("32cf83ff-f1a8-4a8c-8658-d47ba74e20ba") + Tranform_Pattern2_GUID* = DEFINE_GUID("8afcfd07-a369-44de-988b-2f7ff49fb8a8") + TextChild_Pattern_GUID* = DEFINE_GUID("7533cab7-3bfe-41ef-9e85-e2638cbe169e") + Drag_Pattern_GUID* = DEFINE_GUID("c0bee21f-ccb3-4fed-995b-114f6e3d2728") + DropTarget_Pattern_GUID* = DEFINE_GUID("0bcbec56-bd34-4b7b-9fd5-2659905ea3dc") + Button_Control_GUID* = DEFINE_GUID("5a78e369-c6a1-4f33-a9d7-79f20d0c788e") + Calendar_Control_GUID* = DEFINE_GUID("8913eb88-00e5-46bc-8e4e-14a786e165a1") + CheckBox_Control_GUID* = DEFINE_GUID("fb50f922-a3db-49c0-8bc3-06dad55778e2") + ComboBox_Control_GUID* = DEFINE_GUID("54cb426c-2f33-4fff-aaa1-aef60dac5deb") + Edit_Control_GUID* = DEFINE_GUID("6504a5c8-2c86-4f87-ae7b-1abddc810cf9") + Hyperlink_Control_GUID* = DEFINE_GUID("8a56022c-b00d-4d15-8ff0-5b6b266e5e02") + Image_Control_GUID* = DEFINE_GUID("2d3736e4-6b16-4c57-a962-f93260a75243") + ListItem_Control_GUID* = DEFINE_GUID("7b3717f2-44d1-4a58-98a8-f12a9b8f78e2") + List_Control_GUID* = DEFINE_GUID("9b149ee1-7cca-4cfc-9af1-cac7bddd3031") + Menu_Control_GUID* = DEFINE_GUID("2e9b1440-0ea8-41fd-b374-c1ea6f503cd1") + MenuBar_Control_GUID* = DEFINE_GUID("cc384250-0e7b-4ae8-95ae-a08f261b52ee") + MenuItem_Control_GUID* = DEFINE_GUID("f45225d3-d0a0-49d8-9834-9a000d2aeddc") + ProgressBar_Control_GUID* = DEFINE_GUID("228c9f86-c36c-47bb-9fb6-a5834bfc53a4") + RadioButton_Control_GUID* = DEFINE_GUID("3bdb49db-fe2c-4483-b3e1-e57f219440c6") + ScrollBar_Control_GUID* = DEFINE_GUID("daf34b36-5065-4946-b22f-92595fc0751a") + Slider_Control_GUID* = DEFINE_GUID("b033c24b-3b35-4cea-b609-763682fa660b") + Spinner_Control_GUID* = DEFINE_GUID("60cc4b38-3cb1-4161-b442-c6b726c17825") + StatusBar_Control_GUID* = DEFINE_GUID("d45e7d1b-5873-475f-95a4-0433e1f1b00a") + Tab_Control_GUID* = DEFINE_GUID("38cd1f2d-337a-4bd2-a5e3-adb469e30bd3") + TabItem_Control_GUID* = DEFINE_GUID("2c6a634f-921b-4e6e-b26e-08fcb0798f4c") + Text_Control_GUID* = DEFINE_GUID("ae9772dc-d331-4f09-be20-7e6dfaf07b0a") + ToolBar_Control_GUID* = DEFINE_GUID("8f06b751-e182-4e98-8893-2284543a7dce") + ToolTip_Control_GUID* = DEFINE_GUID("05ddc6d1-2137-4768-98ea-73f52f7134f3") + Tree_Control_GUID* = DEFINE_GUID("7561349c-d241-43f4-9908-b5f091bee611") + TreeItem_Control_GUID* = DEFINE_GUID("62c9feb9-8ffc-4878-a3a4-96b030315c18") + Custom_Control_GUID* = DEFINE_GUID("f29ea0c3-adb7-430a-ba90-e52c7313e6ed") + Group_Control_GUID* = DEFINE_GUID("ad50aa1c-e8c8-4774-ae1b-dd86df0b3bdc") + Thumb_Control_GUID* = DEFINE_GUID("701ca877-e310-4dd6-b644-797e4faea213") + DataGrid_Control_GUID* = DEFINE_GUID("84b783af-d103-4b0a-8415-e73942410f4b") + DataItem_Control_GUID* = DEFINE_GUID("a0177842-d94f-42a5-814b-6068addc8da5") + Document_Control_GUID* = DEFINE_GUID("3cd6bb6f-6f08-4562-b229-e4e2fc7a9eb4") + SplitButton_Control_GUID* = DEFINE_GUID("7011f01f-4ace-4901-b461-920a6f1ca650") + Window_Control_GUID* = DEFINE_GUID("e13a7242-f462-4f4d-aec1-53b28d6c3290") + Pane_Control_GUID* = DEFINE_GUID("5c2b3f5b-9182-42a3-8dec-8c04c1ee634d") + Header_Control_GUID* = DEFINE_GUID("5b90cbce-78fb-4614-82b6-554d74718e67") + HeaderItem_Control_GUID* = DEFINE_GUID("e6bc12cb-7c8e-49cf-b168-4a93a32bebb0") + Table_Control_GUID* = DEFINE_GUID("773bfa0e-5bc4-4deb-921b-de7b3206229e") + TitleBar_Control_GUID* = DEFINE_GUID("98aa55bf-3bb0-4b65-836e-2ea30dbc171f") + Separator_Control_GUID* = DEFINE_GUID("8767eba3-2a63-4ab0-ac8d-aa50e23de978") + SemanticZoom_Control_GUID* = DEFINE_GUID("5fd34a43-061e-42c8-b589-9dccf74bc43a") + AppBar_Control_GUID* = DEFINE_GUID("6114908d-cc02-4d37-875b-b530c7139554") + Text_AnimationStyle_Attribute_GUID* = DEFINE_GUID("628209f0-7c9a-4d57-be64-1f1836571ff5") + Text_BackgroundColor_Attribute_GUID* = DEFINE_GUID("fdc49a07-583d-4f17-ad27-77fc832a3c0b") + Text_BulletStyle_Attribute_GUID* = DEFINE_GUID("c1097c90-d5c4-4237-9781-3bec8ba54e48") + Text_CapStyle_Attribute_GUID* = DEFINE_GUID("fb059c50-92cc-49a5-ba8f-0aa872bba2f3") + Text_Culture_Attribute_GUID* = DEFINE_GUID("c2025af9-a42d-4ced-a1fb-c6746315222e") + Text_FontName_Attribute_GUID* = DEFINE_GUID("64e63ba8-f2e5-476e-a477-1734feaaf726") + Text_FontSize_Attribute_GUID* = DEFINE_GUID("dc5eeeff-0506-4673-93f2-377e4a8e01f1") + Text_FontWeight_Attribute_GUID* = DEFINE_GUID("6fc02359-b316-4f5f-b401-f1ce55741853") + Text_ForegroundColor_Attribute_GUID* = DEFINE_GUID("72d1c95d-5e60-471a-96b1-6c1b3b77a436") + Text_HorizontalTextAlignment_Attribute_GUID* = DEFINE_GUID("04ea6161-fba3-477a-952a-bb326d026a5b") + Text_IndentationFirstLine_Attribute_GUID* = DEFINE_GUID("206f9ad5-c1d3-424a-8182-6da9a7f3d632") + Text_IndentationLeading_Attribute_GUID* = DEFINE_GUID("5cf66bac-2d45-4a4b-b6c9-f7221d2815b0") + Text_IndentationTrailing_Attribute_GUID* = DEFINE_GUID("97ff6c0f-1ce4-408a-b67b-94d83eb69bf2") + Text_IsHidden_Attribute_GUID* = DEFINE_GUID("360182fb-bdd7-47f6-ab69-19e33f8a3344") + Text_IsItalic_Attribute_GUID* = DEFINE_GUID("fce12a56-1336-4a34-9663-1bab47239320") + Text_IsReadOnly_Attribute_GUID* = DEFINE_GUID("a738156b-ca3e-495e-9514-833c440feb11") + Text_IsSubscript_Attribute_GUID* = DEFINE_GUID("f0ead858-8f53-413c-873f-1a7d7f5e0de4") + Text_IsSuperscript_Attribute_GUID* = DEFINE_GUID("da706ee4-b3aa-4645-a41f-cd25157dea76") + Text_MarginBottom_Attribute_GUID* = DEFINE_GUID("7ee593c4-72b4-4cac-9271-3ed24b0e4d42") + Text_MarginLeading_Attribute_GUID* = DEFINE_GUID("9e9242d0-5ed0-4900-8e8a-eecc03835afc") + Text_MarginTop_Attribute_GUID* = DEFINE_GUID("683d936f-c9b9-4a9a-b3d9-d20d33311e2a") + Text_MarginTrailing_Attribute_GUID* = DEFINE_GUID("af522f98-999d-40af-a5b2-0169d0342002") + Text_OutlineStyles_Attribute_GUID* = DEFINE_GUID("5b675b27-db89-46fe-970c-614d523bb97d") + Text_OverlineColor_Attribute_GUID* = DEFINE_GUID("83ab383a-fd43-40da-ab3e-ecf8165cbb6d") + Text_OverlineStyle_Attribute_GUID* = DEFINE_GUID("0a234d66-617e-427f-871d-e1ff1e0c213f") + Text_StrikethroughColor_Attribute_GUID* = DEFINE_GUID("bfe15a18-8c41-4c5a-9a0b-04af0e07f487") + Text_StrikethroughStyle_Attribute_GUID* = DEFINE_GUID("72913ef1-da00-4f01-899c-ac5a8577a307") + Text_Tabs_Attribute_GUID* = DEFINE_GUID("2e68d00b-92fe-42d8-899a-a784aa4454a1") + Text_TextFlowDirections_Attribute_GUID* = DEFINE_GUID("8bdf8739-f420-423e-af77-20a5d973a907") + Text_UnderlineColor_Attribute_GUID* = DEFINE_GUID("bfa12c73-fde2-4473-bf64-1036d6aa0f45") + Text_UnderlineStyle_Attribute_GUID* = DEFINE_GUID("5f3b21c0-ede4-44bd-9c36-3853038cbfeb") + Text_AnnotationTypes_Attribute_GUID* = DEFINE_GUID("ad2eb431-ee4e-4be1-a7ba-5559155a73ef") + Text_AnnotationObjects_Attribute_GUID* = DEFINE_GUID("ff41cf68-e7ab-40b9-8c72-72a8ed94017d") + Text_StyleName_Attribute_GUID* = DEFINE_GUID("22c9e091-4d66-45d8-a828-737bab4c98a7") + Text_StyleId_Attribute_GUID* = DEFINE_GUID("14c300de-c32b-449b-ab7c-b0e0789aea5d") + Text_Link_Attribute_GUID* = DEFINE_GUID("b38ef51d-9e8d-4e46-9144-56ebe177329b") + Text_IsActive_Attribute_GUID* = DEFINE_GUID("f5a4e533-e1b8-436b-935d-b57aa3f558c4") + Text_SelectionActiveEnd_Attribute_GUID* = DEFINE_GUID("1f668cc3-9bbf-416b-b0a2-f89f86f6612c") + Text_CaretPosition_Attribute_GUID* = DEFINE_GUID("b227b131-9889-4752-a91b-733efdc5c5a0") + Text_CaretBidiMode_Attribute_GUID* = DEFINE_GUID("929ee7a6-51d3-4715-96dc-b694fa24a168") + Text_BeforeParagraphSpacing_Attribute_GUID* = DEFINE_GUID("be7b0ab1-c822-4a24-85e9-c8f2650fc79c") + Text_AfterParagraphSpacing_Attribute_GUID* = DEFINE_GUID("588cbb38-e62f-497c-b5d1-ccdf0ee823d8") + Text_LineSpacing_Attribute_GUID* = DEFINE_GUID("63ff70ae-d943-4b47-8ab7-a7a033d3214b") + Text_BeforeSpacing_Attribute_GUID* = DEFINE_GUID("be7b0ab1-c822-4a24-85e9-c8f2650fc79c") + Text_AfterSpacing_Attribute_GUID* = DEFINE_GUID("588cbb38-e62f-497c-b5d1-ccdf0ee823d8") + Text_SayAsInterpretAs_Attribute_GUID* = DEFINE_GUID("b38ad6ac-eee1-4b6e-88cc-014cefa93fcb") + TextEdit_TextChanged_Event_GUID* = DEFINE_GUID("120b0308-ec22-4eb8-9c98-9867cda1b165") + TextEdit_ConversionTargetChanged_Event_GUID* = DEFINE_GUID("3388c183-ed4f-4c8b-9baa-364d51d8847f") + Changes_Event_GUID* = DEFINE_GUID("7df26714-614f-4e05-9488-716c5ba19436") + Annotation_Custom_GUID* = DEFINE_GUID("9ec82750-3931-4952-85bc-1dbff78a43e3") + Annotation_SpellingError_GUID* = DEFINE_GUID("ae85567e-9ece-423f-81b7-96c43d53e50e") + Annotation_GrammarError_GUID* = DEFINE_GUID("757a048d-4518-41c6-854c-dc009b7cfb53") + Annotation_Comment_GUID* = DEFINE_GUID("fd2fda30-26b3-4c06-8bc7-98f1532e46fd") + Annotation_FormulaError_GUID* = DEFINE_GUID("95611982-0cab-46d5-a2f0-e30d1905f8bf") + Annotation_TrackChanges_GUID* = DEFINE_GUID("21e6e888-dc14-4016-ac27-190553c8c470") + Annotation_Header_GUID* = DEFINE_GUID("867b409b-b216-4472-a219-525e310681f8") + Annotation_Footer_GUID* = DEFINE_GUID("cceab046-1833-47aa-8080-701ed0b0c832") + Annotation_Highlighted_GUID* = DEFINE_GUID("757c884e-8083-4081-8b9c-e87f5072f0e4") + Annotation_Endnote_GUID* = DEFINE_GUID("7565725c-2d99-4839-960d-33d3b866aba5") + Annotation_Footnote_GUID* = DEFINE_GUID("3de10e21-4125-42db-8620-be8083080624") + Annotation_InsertionChange_GUID* = DEFINE_GUID("0dbeb3a6-df15-4164-a3c0-e21a8ce931c4") + Annotation_DeletionChange_GUID* = DEFINE_GUID("be3d5b05-951d-42e7-901d-adc8c2cf34d0") + Annotation_MoveChange_GUID* = DEFINE_GUID("9da587eb-23e5-4490-b385-1a22ddc8b187") + Annotation_FormatChange_GUID* = DEFINE_GUID("eb247345-d4f1-41ce-8e52-f79b69635e48") + Annotation_UnsyncedChange_GUID* = DEFINE_GUID("1851116a-0e47-4b30-8cb5-d7dae4fbcd1b") + Annotation_EditingLockedChange_GUID* = DEFINE_GUID("c31f3e1c-7423-4dac-8348-41f099ff6f64") + Annotation_ExternalChange_GUID* = DEFINE_GUID("75a05b31-5f11-42fd-887d-dfa010db2392") + Annotation_ConflictingChange_GUID* = DEFINE_GUID("98af8802-517c-459f-af13-016d3fab877e") + Annotation_Author_GUID* = DEFINE_GUID("f161d3a7-f81b-4128-b17f-71f690914520") + Annotation_AdvancedProofingIssue_GUID* = DEFINE_GUID("dac7b72c-c0f2-4b84-b90d-5fafc0f0ef1c") + Annotation_DataValidationError_GUID* = DEFINE_GUID("c8649fa8-9775-437e-ad46-e709d93c2343") + Annotation_CircularReferenceError_GUID* = DEFINE_GUID("25bd9cf4-1745-4659-ba67-727f0318c616") + Annotation_Mathematics_GUID* = DEFINE_GUID("eaab634b-26d0-40c1-8073-57ca1c633c9b") + Changes_Summary_GUID* = DEFINE_GUID("313d65a6-e60f-4d62-9861-55afd728d207") + StyleId_Custom_GUID* = DEFINE_GUID("ef2edd3e-a999-4b7c-a378-09bbd52a3516") + StyleId_Heading1_GUID* = DEFINE_GUID("7f7e8f69-6866-4621-930c-9a5d0ca5961c") + StyleId_Heading2_GUID* = DEFINE_GUID("baa9b241-5c69-469d-85ad-474737b52b14") + StyleId_Heading3_GUID* = DEFINE_GUID("bf8be9d2-d8b8-4ec5-8c52-9cfb0d035970") + StyleId_Heading4_GUID* = DEFINE_GUID("8436ffc0-9578-45fc-83a4-ff40053315dd") + StyleId_Heading5_GUID* = DEFINE_GUID("909f424d-0dbf-406e-97bb-4e773d9798f7") + StyleId_Heading6_GUID* = DEFINE_GUID("89d23459-5d5b-4824-a420-11d3ed82e40f") + StyleId_Heading7_GUID* = DEFINE_GUID("a3790473-e9ae-422d-b8e3-3b675c6181a4") + StyleId_Heading8_GUID* = DEFINE_GUID("2bc14145-a40c-4881-84ae-f2235685380c") + StyleId_Heading9_GUID* = DEFINE_GUID("c70d9133-bb2a-43d3-8ac6-33657884b0f0") + StyleId_Title_GUID* = DEFINE_GUID("15d8201a-ffcf-481f-b0a1-30b63be98f07") + StyleId_Subtitle_GUID* = DEFINE_GUID("b5d9fc17-5d6f-4420-b439-7cb19ad434e2") + StyleId_Normal_GUID* = DEFINE_GUID("cd14d429-e45e-4475-a1c5-7f9e6be96eba") + StyleId_Emphasis_GUID* = DEFINE_GUID("ca6e7dbe-355e-4820-95a0-925f041d3470") + StyleId_Quote_GUID* = DEFINE_GUID("5d1c21ea-8195-4f6c-87ea-5dabece64c1d") + StyleId_BulletedList_GUID* = DEFINE_GUID("5963ed64-6426-4632-8caf-a32ad402d91a") + StyleId_NumberedList_GUID* = DEFINE_GUID("1e96dbd5-64c3-43d0-b1ee-b53b06e3eddf") + Notification_Event_GUID* = DEFINE_GUID("72c5a2f7-9788-480f-b8eb-4dee00f6186f") + SID_IsUIAutomationObject* = DEFINE_GUID("b96fdb85-7204-4724-842b-c7059dedb9d0") + SID_ControlElementProvider* = DEFINE_GUID("f4791d68-e254-4ba3-9a53-26a5c5497946") + IsSelectionPattern2Available_Property_GUID* = DEFINE_GUID("490806fb-6e89-4a47-8319-d266e511f021") + Selection2_FirstSelectedItem_Property_GUID* = DEFINE_GUID("cc24ea67-369c-4e55-9ff7-38da69540c29") + Selection2_LastSelectedItem_Property_GUID* = DEFINE_GUID("cf7bda90-2d83-49f8-860c-9ce394cf89b4") + Selection2_CurrentSelectedItem_Property_GUID* = DEFINE_GUID("34257c26-83b5-41a6-939c-ae841c136236") + Selection2_ItemCount_Property_GUID* = DEFINE_GUID("bb49eb9f-456d-4048-b591-9c2026b84636") + Selection_Pattern2_GUID* = DEFINE_GUID("fba25cab-ab98-49f7-a7dc-fe539dc15be7") + HeadingLevel_Property_GUID* = DEFINE_GUID("29084272-aaaf-4a30-8796-3c12f62b6bbb") + IsDialog_Property_GUID* = DEFINE_GUID("9d0dfb9b-8436-4501-bbbb-e534a4fb3b3f") + ConditionType_True* = 0 + ConditionType_False* = 1 + ConditionType_Property* = 2 + ConditionType_And* = 3 + ConditionType_Or* = 4 + ConditionType_Not* = 5 + NormalizeState_None* = 0 + NormalizeState_View* = 1 + NormalizeState_Custom* = 2 + ProviderType_BaseHwnd* = 0 + ProviderType_Proxy* = 1 + ProviderType_NonClientArea* = 2 + AutomationIdentifierType_Property* = 0 + AutomationIdentifierType_Pattern* = 1 + AutomationIdentifierType_Event* = 2 + AutomationIdentifierType_ControlType* = 3 + AutomationIdentifierType_TextAttribute* = 4 + AutomationIdentifierType_LandmarkType* = 5 + AutomationIdentifierType_Annotation* = 6 + AutomationIdentifierType_Changes* = 7 + AutomationIdentifierType_Style* = 8 + EventArgsType_Simple* = 0 + EventArgsType_PropertyChanged* = 1 + EventArgsType_StructureChanged* = 2 + EventArgsType_AsyncContentLoaded* = 3 + EventArgsType_WindowClosed* = 4 + EventArgsType_TextEditTextChanged* = 5 + EventArgsType_Changes* = 6 + EventArgsType_Notification* = 7 + EventArgsType_ActiveTextPositionChanged* = 8 + AsyncContentLoadedState_Beginning* = 0 + AsyncContentLoadedState_Progress* = 1 + AsyncContentLoadedState_Completed* = 2 + UIA_IAFP_DEFAULT* = 0x0000 + UIA_IAFP_UNWRAP_BRIDGE* = 0x0001 + UIA_PFIA_DEFAULT* = 0x0000 + UIA_PFIA_UNWRAP_BRIDGE* = 0x0001 +type + UiaProviderCallback* = proc (hwnd: HWND, providerType: ProviderType): ptr SAFEARRAY {.stdcall.} + UiaEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + UiaEventCallback* = proc (pArgs: ptr UiaEventArgs, pRequestedData: ptr SAFEARRAY, pTreeStructure: BSTR): void {.stdcall.} + UiaRect* {.pure.} = object + left*: float64 + top*: float64 + width*: float64 + height*: float64 + UiaPoint* {.pure.} = object + x*: float64 + y*: float64 + UiaChangeInfo* {.pure.} = object + uiaId*: int32 + payload*: VARIANT + extraInfo*: VARIANT + UIAutomationParameter* {.pure.} = object + `type`*: UIAutomationType + pData*: pointer + UIAutomationPropertyInfo* {.pure.} = object + guid*: GUID + pProgrammaticName*: LPCWSTR + `type`*: UIAutomationType + UIAutomationEventInfo* {.pure.} = object + guid*: GUID + pProgrammaticName*: LPCWSTR + UIAutomationMethodInfo* {.pure.} = object + pProgrammaticName*: LPCWSTR + doSetFocus*: BOOL + cInParameters*: UINT + cOutParameters*: UINT + pParameterTypes*: ptr UIAutomationType + pParameterNames*: ptr LPCWSTR + IUIAutomationPatternInstance* {.pure.} = object + lpVtbl*: ptr IUIAutomationPatternInstanceVtbl + IUIAutomationPatternInstanceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetProperty*: proc(self: ptr IUIAutomationPatternInstance, index: UINT, cached: BOOL, `type`: UIAutomationType, pPtr: pointer): HRESULT {.stdcall.} + CallMethod*: proc(self: ptr IUIAutomationPatternInstance, index: UINT, pParams: ptr UIAutomationParameter, cParams: UINT): HRESULT {.stdcall.} + IUIAutomationPatternHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationPatternHandlerVtbl + IUIAutomationPatternHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateClientWrapper*: proc(self: ptr IUIAutomationPatternHandler, pPatternInstance: ptr IUIAutomationPatternInstance, pClientWrapper: ptr ptr IUnknown): HRESULT {.stdcall.} + Dispatch*: proc(self: ptr IUIAutomationPatternHandler, pTarget: ptr IUnknown, index: UINT, pParams: ptr UIAutomationParameter, cParams: UINT): HRESULT {.stdcall.} + UIAutomationPatternInfo* {.pure.} = object + guid*: GUID + pProgrammaticName*: LPCWSTR + providerInterfaceId*: GUID + clientInterfaceId*: GUID + cProperties*: UINT + pProperties*: ptr UIAutomationPropertyInfo + cMethods*: UINT + pMethods*: ptr UIAutomationMethodInfo + cEvents*: UINT + pEvents*: ptr UIAutomationEventInfo + pPatternHandler*: ptr IUIAutomationPatternHandler + TExtendedProperty* {.pure.} = object + PropertyName*: BSTR + PropertyValue*: BSTR + UiaCondition* {.pure.} = object + ConditionType*: ConditionType + UiaPropertyCondition* {.pure.} = object + ConditionType*: ConditionType + PropertyId*: PROPERTYID + Value*: VARIANT + Flags*: PropertyConditionFlags + UiaAndOrCondition* {.pure.} = object + ConditionType*: ConditionType + ppConditions*: ptr ptr UiaCondition + cConditions*: int32 + UiaNotCondition* {.pure.} = object + ConditionType*: ConditionType + pCondition*: ptr UiaCondition + UiaCacheRequest* {.pure.} = object + pViewCondition*: ptr UiaCondition + Scope*: TreeScope + pProperties*: ptr PROPERTYID + cProperties*: int32 + pPatterns*: ptr PATTERNID + cPatterns*: int32 + automationElementMode*: AutomationElementMode + UiaFindParams* {.pure.} = object + MaxDepth*: int32 + FindFirst*: BOOL + ExcludeRoot*: BOOL + pFindCondition*: ptr UiaCondition + UiaPropertyChangedEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + PropertyId*: PROPERTYID + OldValue*: VARIANT + NewValue*: VARIANT + UiaStructureChangedEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + StructureChangeType*: StructureChangeType + pRuntimeId*: ptr int32 + cRuntimeIdLen*: int32 + UiaTextEditTextChangedEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + TextEditChangeType*: TextEditChangeType + pTextChange*: ptr SAFEARRAY + UiaChangesEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + EventIdCount*: int32 + pUiaChanges*: ptr UiaChangeInfo + UiaAsyncContentLoadedEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + AsyncContentLoadedState*: AsyncContentLoadedState + PercentComplete*: float64 + UiaWindowClosedEventArgs* {.pure.} = object + Type*: EventArgsType + EventId*: int32 + pRuntimeId*: ptr int32 + cRuntimeIdLen*: int32 + IRawElementProviderSimple* {.pure.} = object + lpVtbl*: ptr IRawElementProviderSimpleVtbl + IRawElementProviderSimpleVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_ProviderOptions*: proc(self: ptr IRawElementProviderSimple, pRetVal: ptr ProviderOptions): HRESULT {.stdcall.} + GetPatternProvider*: proc(self: ptr IRawElementProviderSimple, patternId: PATTERNID, pRetVal: ptr ptr IUnknown): HRESULT {.stdcall.} + GetPropertyValue*: proc(self: ptr IRawElementProviderSimple, propertyId: PROPERTYID, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + get_HostRawElementProvider*: proc(self: ptr IRawElementProviderSimple, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IAccessibleEx* {.pure.} = object + lpVtbl*: ptr IAccessibleExVtbl + IAccessibleExVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetObjectForChild*: proc(self: ptr IAccessibleEx, idChild: int32, pRetVal: ptr ptr IAccessibleEx): HRESULT {.stdcall.} + GetIAccessiblePair*: proc(self: ptr IAccessibleEx, ppAcc: ptr ptr IAccessible, pidChild: ptr int32): HRESULT {.stdcall.} + GetRuntimeId*: proc(self: ptr IAccessibleEx, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + ConvertReturnedElement*: proc(self: ptr IAccessibleEx, pIn: ptr IRawElementProviderSimple, ppRetValOut: ptr ptr IAccessibleEx): HRESULT {.stdcall.} + IRawElementProviderSimple2* {.pure.} = object + lpVtbl*: ptr IRawElementProviderSimple2Vtbl + IRawElementProviderSimple2Vtbl* {.pure, inheritable.} = object of IRawElementProviderSimpleVtbl + ShowContextMenu*: proc(self: ptr IRawElementProviderSimple2): HRESULT {.stdcall.} + IRawElementProviderSimple3* {.pure.} = object + lpVtbl*: ptr IRawElementProviderSimple3Vtbl + IRawElementProviderSimple3Vtbl* {.pure, inheritable.} = object of IRawElementProviderSimple2Vtbl + GetMetadataValue*: proc(self: ptr IRawElementProviderSimple3, targetId: int32, metadataId: METADATAID, returnVal: ptr VARIANT): HRESULT {.stdcall.} + IRawElementProviderFragment* {.pure.} = object + lpVtbl*: ptr IRawElementProviderFragmentVtbl + IRawElementProviderFragmentVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Navigate*: proc(self: ptr IRawElementProviderFragment, direction: NavigateDirection, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.stdcall.} + GetRuntimeId*: proc(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_BoundingRectangle*: proc(self: ptr IRawElementProviderFragment, pRetVal: ptr UiaRect): HRESULT {.stdcall.} + GetEmbeddedFragmentRoots*: proc(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + SetFocus*: proc(self: ptr IRawElementProviderFragment): HRESULT {.stdcall.} + get_FragmentRoot*: proc(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr IRawElementProviderFragmentRoot): HRESULT {.stdcall.} + IRawElementProviderFragmentRoot* {.pure.} = object + lpVtbl*: ptr IRawElementProviderFragmentRootVtbl + IRawElementProviderFragmentRootVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ElementProviderFromPoint*: proc(self: ptr IRawElementProviderFragmentRoot, x: float64, y: float64, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.stdcall.} + GetFocus*: proc(self: ptr IRawElementProviderFragmentRoot, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.stdcall.} + IRawElementProviderAdviseEvents* {.pure.} = object + lpVtbl*: ptr IRawElementProviderAdviseEventsVtbl + IRawElementProviderAdviseEventsVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AdviseEventAdded*: proc(self: ptr IRawElementProviderAdviseEvents, eventId: EVENTID, propertyIDs: ptr SAFEARRAY): HRESULT {.stdcall.} + AdviseEventRemoved*: proc(self: ptr IRawElementProviderAdviseEvents, eventId: EVENTID, propertyIDs: ptr SAFEARRAY): HRESULT {.stdcall.} + IRawElementProviderHwndOverride* {.pure.} = object + lpVtbl*: ptr IRawElementProviderHwndOverrideVtbl + IRawElementProviderHwndOverrideVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetOverrideProviderForHwnd*: proc(self: ptr IRawElementProviderHwndOverride, hwnd: HWND, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IProxyProviderWinEventSink* {.pure.} = object + lpVtbl*: ptr IProxyProviderWinEventSinkVtbl + IProxyProviderWinEventSinkVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddAutomationPropertyChangedEvent*: proc(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, id: PROPERTYID, newValue: VARIANT): HRESULT {.stdcall.} + AddAutomationEvent*: proc(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, id: EVENTID): HRESULT {.stdcall.} + AddStructureChangedEvent*: proc(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, structureChangeType: StructureChangeType, runtimeId: ptr SAFEARRAY): HRESULT {.stdcall.} + IProxyProviderWinEventHandler* {.pure.} = object + lpVtbl*: ptr IProxyProviderWinEventHandlerVtbl + IProxyProviderWinEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RespondToWinEvent*: proc(self: ptr IProxyProviderWinEventHandler, idWinEvent: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG, pSink: ptr IProxyProviderWinEventSink): HRESULT {.stdcall.} + IRawElementProviderWindowlessSite* {.pure.} = object + lpVtbl*: ptr IRawElementProviderWindowlessSiteVtbl + IRawElementProviderWindowlessSiteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetAdjacentFragment*: proc(self: ptr IRawElementProviderWindowlessSite, direction: NavigateDirection, ppParent: ptr ptr IRawElementProviderFragment): HRESULT {.stdcall.} + GetRuntimeIdPrefix*: proc(self: ptr IRawElementProviderWindowlessSite, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IAccessibleHostingElementProviders* {.pure.} = object + lpVtbl*: ptr IAccessibleHostingElementProvidersVtbl + IAccessibleHostingElementProvidersVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetEmbeddedFragmentRoots*: proc(self: ptr IAccessibleHostingElementProviders, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetObjectIdForProvider*: proc(self: ptr IAccessibleHostingElementProviders, pProvider: ptr IRawElementProviderSimple, pidObject: ptr int32): HRESULT {.stdcall.} + IRawElementProviderHostingAccessibles* {.pure.} = object + lpVtbl*: ptr IRawElementProviderHostingAccessiblesVtbl + IRawElementProviderHostingAccessiblesVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetEmbeddedAccessibles*: proc(self: ptr IRawElementProviderHostingAccessibles, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IDockProvider* {.pure.} = object + lpVtbl*: ptr IDockProviderVtbl + IDockProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetDockPosition*: proc(self: ptr IDockProvider, dockPosition: DockPosition): HRESULT {.stdcall.} + get_DockPosition*: proc(self: ptr IDockProvider, pRetVal: ptr DockPosition): HRESULT {.stdcall.} + IExpandCollapseProvider* {.pure.} = object + lpVtbl*: ptr IExpandCollapseProviderVtbl + IExpandCollapseProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Expand*: proc(self: ptr IExpandCollapseProvider): HRESULT {.stdcall.} + Collapse*: proc(self: ptr IExpandCollapseProvider): HRESULT {.stdcall.} + get_ExpandCollapseState*: proc(self: ptr IExpandCollapseProvider, pRetVal: ptr ExpandCollapseState): HRESULT {.stdcall.} + IGridProvider* {.pure.} = object + lpVtbl*: ptr IGridProviderVtbl + IGridProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetItem*: proc(self: ptr IGridProvider, row: int32, column: int32, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_RowCount*: proc(self: ptr IGridProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_ColumnCount*: proc(self: ptr IGridProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + IGridItemProvider* {.pure.} = object + lpVtbl*: ptr IGridItemProviderVtbl + IGridItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Row*: proc(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_Column*: proc(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_RowSpan*: proc(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_ColumnSpan*: proc(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_ContainingGrid*: proc(self: ptr IGridItemProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IInvokeProvider* {.pure.} = object + lpVtbl*: ptr IInvokeProviderVtbl + IInvokeProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Invoke*: proc(self: ptr IInvokeProvider): HRESULT {.stdcall.} + IMultipleViewProvider* {.pure.} = object + lpVtbl*: ptr IMultipleViewProviderVtbl + IMultipleViewProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetViewName*: proc(self: ptr IMultipleViewProvider, viewId: int32, pRetVal: ptr BSTR): HRESULT {.stdcall.} + SetCurrentView*: proc(self: ptr IMultipleViewProvider, viewId: int32): HRESULT {.stdcall.} + get_CurrentView*: proc(self: ptr IMultipleViewProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + GetSupportedViews*: proc(self: ptr IMultipleViewProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IRangeValueProvider* {.pure.} = object + lpVtbl*: ptr IRangeValueProviderVtbl + IRangeValueProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetValue*: proc(self: ptr IRangeValueProvider, val: float64): HRESULT {.stdcall.} + get_Value*: proc(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_IsReadOnly*: proc(self: ptr IRangeValueProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_Maximum*: proc(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_Minimum*: proc(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_LargeChange*: proc(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_SmallChange*: proc(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + IScrollItemProvider* {.pure.} = object + lpVtbl*: ptr IScrollItemProviderVtbl + IScrollItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ScrollIntoView*: proc(self: ptr IScrollItemProvider): HRESULT {.stdcall.} + ISelectionProvider* {.pure.} = object + lpVtbl*: ptr ISelectionProviderVtbl + ISelectionProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSelection*: proc(self: ptr ISelectionProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CanSelectMultiple*: proc(self: ptr ISelectionProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_IsSelectionRequired*: proc(self: ptr ISelectionProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + ISelectionProvider2* {.pure.} = object + lpVtbl*: ptr ISelectionProvider2Vtbl + ISelectionProvider2Vtbl* {.pure, inheritable.} = object of ISelectionProviderVtbl + get_FirstSelectedItem*: proc(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_LastSelectedItem*: proc(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_CurrentSelectedItem*: proc(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_ItemCount*: proc(self: ptr ISelectionProvider2, retVal: ptr int32): HRESULT {.stdcall.} + IScrollProvider* {.pure.} = object + lpVtbl*: ptr IScrollProviderVtbl + IScrollProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Scroll*: proc(self: ptr IScrollProvider, horizontalAmount: ScrollAmount, verticalAmount: ScrollAmount): HRESULT {.stdcall.} + SetScrollPercent*: proc(self: ptr IScrollProvider, horizontalPercent: float64, verticalPercent: float64): HRESULT {.stdcall.} + get_HorizontalScrollPercent*: proc(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_VerticalScrollPercent*: proc(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_HorizontalViewSize*: proc(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_VerticalViewSize*: proc(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.stdcall.} + get_HorizontallyScrollable*: proc(self: ptr IScrollProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_VerticallyScrollable*: proc(self: ptr IScrollProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + ISelectionItemProvider* {.pure.} = object + lpVtbl*: ptr ISelectionItemProviderVtbl + ISelectionItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Select*: proc(self: ptr ISelectionItemProvider): HRESULT {.stdcall.} + AddToSelection*: proc(self: ptr ISelectionItemProvider): HRESULT {.stdcall.} + RemoveFromSelection*: proc(self: ptr ISelectionItemProvider): HRESULT {.stdcall.} + get_IsSelected*: proc(self: ptr ISelectionItemProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_SelectionContainer*: proc(self: ptr ISelectionItemProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + ISynchronizedInputProvider* {.pure.} = object + lpVtbl*: ptr ISynchronizedInputProviderVtbl + ISynchronizedInputProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartListening*: proc(self: ptr ISynchronizedInputProvider, inputType: SynchronizedInputType): HRESULT {.stdcall.} + Cancel*: proc(self: ptr ISynchronizedInputProvider): HRESULT {.stdcall.} + ITableProvider* {.pure.} = object + lpVtbl*: ptr ITableProviderVtbl + ITableProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRowHeaders*: proc(self: ptr ITableProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetColumnHeaders*: proc(self: ptr ITableProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_RowOrColumnMajor*: proc(self: ptr ITableProvider, pRetVal: ptr RowOrColumnMajor): HRESULT {.stdcall.} + ITableItemProvider* {.pure.} = object + lpVtbl*: ptr ITableItemProviderVtbl + ITableItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetRowHeaderItems*: proc(self: ptr ITableItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetColumnHeaderItems*: proc(self: ptr ITableItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IToggleProvider* {.pure.} = object + lpVtbl*: ptr IToggleProviderVtbl + IToggleProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Toggle*: proc(self: ptr IToggleProvider): HRESULT {.stdcall.} + get_ToggleState*: proc(self: ptr IToggleProvider, pRetVal: ptr ToggleState): HRESULT {.stdcall.} + ITransformProvider* {.pure.} = object + lpVtbl*: ptr ITransformProviderVtbl + ITransformProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Move*: proc(self: ptr ITransformProvider, x: float64, y: float64): HRESULT {.stdcall.} + Resize*: proc(self: ptr ITransformProvider, width: float64, height: float64): HRESULT {.stdcall.} + Rotate*: proc(self: ptr ITransformProvider, degrees: float64): HRESULT {.stdcall.} + get_CanMove*: proc(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_CanResize*: proc(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_CanRotate*: proc(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + IValueProvider* {.pure.} = object + lpVtbl*: ptr IValueProviderVtbl + IValueProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetValue*: proc(self: ptr IValueProvider, val: LPCWSTR): HRESULT {.stdcall.} + get_Value*: proc(self: ptr IValueProvider, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_IsReadOnly*: proc(self: ptr IValueProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + IWindowProvider* {.pure.} = object + lpVtbl*: ptr IWindowProviderVtbl + IWindowProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetVisualState*: proc(self: ptr IWindowProvider, state: WindowVisualState): HRESULT {.stdcall.} + Close*: proc(self: ptr IWindowProvider): HRESULT {.stdcall.} + WaitForInputIdle*: proc(self: ptr IWindowProvider, milliseconds: int32, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_CanMaximize*: proc(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_CanMinimize*: proc(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_IsModal*: proc(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_WindowVisualState*: proc(self: ptr IWindowProvider, pRetVal: ptr WindowVisualState): HRESULT {.stdcall.} + get_WindowInteractionState*: proc(self: ptr IWindowProvider, pRetVal: ptr WindowInteractionState): HRESULT {.stdcall.} + get_IsTopmost*: proc(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + ILegacyIAccessibleProvider* {.pure.} = object + lpVtbl*: ptr ILegacyIAccessibleProviderVtbl + ILegacyIAccessibleProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Select*: proc(self: ptr ILegacyIAccessibleProvider, flagsSelect: int32): HRESULT {.stdcall.} + DoDefaultAction*: proc(self: ptr ILegacyIAccessibleProvider): HRESULT {.stdcall.} + SetValue*: proc(self: ptr ILegacyIAccessibleProvider, szValue: LPCWSTR): HRESULT {.stdcall.} + GetIAccessible*: proc(self: ptr ILegacyIAccessibleProvider, ppAccessible: ptr ptr IAccessible): HRESULT {.stdcall.} + get_ChildId*: proc(self: ptr ILegacyIAccessibleProvider, pRetVal: ptr int32): HRESULT {.stdcall.} + get_Name*: proc(self: ptr ILegacyIAccessibleProvider, pszName: ptr BSTR): HRESULT {.stdcall.} + get_Value*: proc(self: ptr ILegacyIAccessibleProvider, pszValue: ptr BSTR): HRESULT {.stdcall.} + get_Description*: proc(self: ptr ILegacyIAccessibleProvider, pszDescription: ptr BSTR): HRESULT {.stdcall.} + get_Role*: proc(self: ptr ILegacyIAccessibleProvider, pdwRole: ptr DWORD): HRESULT {.stdcall.} + get_State*: proc(self: ptr ILegacyIAccessibleProvider, pdwState: ptr DWORD): HRESULT {.stdcall.} + get_Help*: proc(self: ptr ILegacyIAccessibleProvider, pszHelp: ptr BSTR): HRESULT {.stdcall.} + get_KeyboardShortcut*: proc(self: ptr ILegacyIAccessibleProvider, pszKeyboardShortcut: ptr BSTR): HRESULT {.stdcall.} + GetSelection*: proc(self: ptr ILegacyIAccessibleProvider, pvarSelectedChildren: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_DefaultAction*: proc(self: ptr ILegacyIAccessibleProvider, pszDefaultAction: ptr BSTR): HRESULT {.stdcall.} + IItemContainerProvider* {.pure.} = object + lpVtbl*: ptr IItemContainerProviderVtbl + IItemContainerProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FindItemByProperty*: proc(self: ptr IItemContainerProvider, pStartAfter: ptr IRawElementProviderSimple, propertyId: PROPERTYID, value: VARIANT, pFound: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IVirtualizedItemProvider* {.pure.} = object + lpVtbl*: ptr IVirtualizedItemProviderVtbl + IVirtualizedItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Realize*: proc(self: ptr IVirtualizedItemProvider): HRESULT {.stdcall.} + IObjectModelProvider* {.pure.} = object + lpVtbl*: ptr IObjectModelProviderVtbl + IObjectModelProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetUnderlyingObjectModel*: proc(self: ptr IObjectModelProvider, ppUnknown: ptr ptr IUnknown): HRESULT {.stdcall.} + IAnnotationProvider* {.pure.} = object + lpVtbl*: ptr IAnnotationProviderVtbl + IAnnotationProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_AnnotationTypeId*: proc(self: ptr IAnnotationProvider, retVal: ptr int32): HRESULT {.stdcall.} + get_AnnotationTypeName*: proc(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_Author*: proc(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_DateTime*: proc(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_Target*: proc(self: ptr IAnnotationProvider, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IStylesProvider* {.pure.} = object + lpVtbl*: ptr IStylesProviderVtbl + IStylesProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_StyleId*: proc(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.stdcall.} + get_StyleName*: proc(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_FillColor*: proc(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.stdcall.} + get_FillPatternStyle*: proc(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_Shape*: proc(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + get_FillPatternColor*: proc(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.stdcall.} + get_ExtendedProperties*: proc(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.stdcall.} + ISpreadsheetProvider* {.pure.} = object + lpVtbl*: ptr ISpreadsheetProviderVtbl + ISpreadsheetProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetItemByName*: proc(self: ptr ISpreadsheetProvider, name: LPCWSTR, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + ISpreadsheetItemProvider* {.pure.} = object + lpVtbl*: ptr ISpreadsheetItemProviderVtbl + ISpreadsheetItemProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Formula*: proc(self: ptr ISpreadsheetItemProvider, pRetVal: ptr BSTR): HRESULT {.stdcall.} + GetAnnotationObjects*: proc(self: ptr ISpreadsheetItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetAnnotationTypes*: proc(self: ptr ISpreadsheetItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + ITransformProvider2* {.pure.} = object + lpVtbl*: ptr ITransformProvider2Vtbl + ITransformProvider2Vtbl* {.pure, inheritable.} = object of ITransformProviderVtbl + Zoom*: proc(self: ptr ITransformProvider2, zoom: float64): HRESULT {.stdcall.} + get_CanZoom*: proc(self: ptr ITransformProvider2, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_ZoomLevel*: proc(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.stdcall.} + get_ZoomMinimum*: proc(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.stdcall.} + get_ZoomMaximum*: proc(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.stdcall.} + ZoomByUnit*: proc(self: ptr ITransformProvider2, zoomUnit: ZoomUnit): HRESULT {.stdcall.} + IDragProvider* {.pure.} = object + lpVtbl*: ptr IDragProviderVtbl + IDragProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_IsGrabbed*: proc(self: ptr IDragProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + get_DropEffect*: proc(self: ptr IDragProvider, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_DropEffects*: proc(self: ptr IDragProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetGrabbedItems*: proc(self: ptr IDragProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IDropTargetProvider* {.pure.} = object + lpVtbl*: ptr IDropTargetProviderVtbl + IDropTargetProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_DropTargetEffect*: proc(self: ptr IDropTargetProvider, pRetVal: ptr BSTR): HRESULT {.stdcall.} + get_DropTargetEffects*: proc(self: ptr IDropTargetProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + ITextRangeProvider* {.pure.} = object + lpVtbl*: ptr ITextRangeProviderVtbl + ITextRangeProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Clone*: proc(self: ptr ITextRangeProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + Compare*: proc(self: ptr ITextRangeProvider, range: ptr ITextRangeProvider, pRetVal: ptr BOOL): HRESULT {.stdcall.} + CompareEndpoints*: proc(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, targetRange: ptr ITextRangeProvider, targetEndpoint: TextPatternRangeEndpoint, pRetVal: ptr int32): HRESULT {.stdcall.} + ExpandToEnclosingUnit*: proc(self: ptr ITextRangeProvider, unit: TextUnit): HRESULT {.stdcall.} + FindAttribute*: proc(self: ptr ITextRangeProvider, attributeId: TEXTATTRIBUTEID, val: VARIANT, backward: BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + FindText*: proc(self: ptr ITextRangeProvider, text: BSTR, backward: BOOL, ignoreCase: BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + GetAttributeValue*: proc(self: ptr ITextRangeProvider, attributeId: TEXTATTRIBUTEID, pRetVal: ptr VARIANT): HRESULT {.stdcall.} + GetBoundingRectangles*: proc(self: ptr ITextRangeProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetEnclosingElement*: proc(self: ptr ITextRangeProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + GetText*: proc(self: ptr ITextRangeProvider, maxLength: int32, pRetVal: ptr BSTR): HRESULT {.stdcall.} + Move*: proc(self: ptr ITextRangeProvider, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.stdcall.} + MoveEndpointByUnit*: proc(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.stdcall.} + MoveEndpointByRange*: proc(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, targetRange: ptr ITextRangeProvider, targetEndpoint: TextPatternRangeEndpoint): HRESULT {.stdcall.} + Select*: proc(self: ptr ITextRangeProvider): HRESULT {.stdcall.} + AddToSelection*: proc(self: ptr ITextRangeProvider): HRESULT {.stdcall.} + RemoveFromSelection*: proc(self: ptr ITextRangeProvider): HRESULT {.stdcall.} + ScrollIntoView*: proc(self: ptr ITextRangeProvider, alignToTop: BOOL): HRESULT {.stdcall.} + GetChildren*: proc(self: ptr ITextRangeProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + ITextProvider* {.pure.} = object + lpVtbl*: ptr ITextProviderVtbl + ITextProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSelection*: proc(self: ptr ITextProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetVisibleRanges*: proc(self: ptr ITextProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + RangeFromChild*: proc(self: ptr ITextProvider, childElement: ptr IRawElementProviderSimple, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + RangeFromPoint*: proc(self: ptr ITextProvider, point: UiaPoint, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + get_DocumentRange*: proc(self: ptr ITextProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + get_SupportedTextSelection*: proc(self: ptr ITextProvider, pRetVal: ptr SupportedTextSelection): HRESULT {.stdcall.} + ITextProvider2* {.pure.} = object + lpVtbl*: ptr ITextProvider2Vtbl + ITextProvider2Vtbl* {.pure, inheritable.} = object of ITextProviderVtbl + RangeFromAnnotation*: proc(self: ptr ITextProvider2, annotationElement: ptr IRawElementProviderSimple, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + GetCaretRange*: proc(self: ptr ITextProvider2, isActive: ptr BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + ITextEditProvider* {.pure.} = object + lpVtbl*: ptr ITextEditProviderVtbl + ITextEditProviderVtbl* {.pure, inheritable.} = object of ITextProviderVtbl + GetActiveComposition*: proc(self: ptr ITextEditProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + GetConversionTarget*: proc(self: ptr ITextEditProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + ITextRangeProvider2* {.pure.} = object + lpVtbl*: ptr ITextRangeProvider2Vtbl + ITextRangeProvider2Vtbl* {.pure, inheritable.} = object of ITextRangeProviderVtbl + ShowContextMenu*: proc(self: ptr ITextRangeProvider2): HRESULT {.stdcall.} + ITextChildProvider* {.pure.} = object + lpVtbl*: ptr ITextChildProviderVtbl + ITextChildProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_TextContainer*: proc(self: ptr ITextChildProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_TextRange*: proc(self: ptr ITextChildProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.stdcall.} + ICustomNavigationProvider* {.pure.} = object + lpVtbl*: ptr ICustomNavigationProviderVtbl + ICustomNavigationProviderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Navigate*: proc(self: ptr ICustomNavigationProvider, direction: NavigateDirection, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + IUIAutomationRegistrar* {.pure.} = object + lpVtbl*: ptr IUIAutomationRegistrarVtbl + IUIAutomationRegistrarVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RegisterProperty*: proc(self: ptr IUIAutomationRegistrar, property: ptr UIAutomationPropertyInfo, propertyId: ptr PROPERTYID): HRESULT {.stdcall.} + RegisterEvent*: proc(self: ptr IUIAutomationRegistrar, event: ptr UIAutomationEventInfo, eventId: ptr EVENTID): HRESULT {.stdcall.} + RegisterPattern*: proc(self: ptr IUIAutomationRegistrar, pattern: ptr UIAutomationPatternInfo, pPatternId: ptr PATTERNID, pPatternAvailablePropertyId: ptr PROPERTYID, propertyIdCount: UINT, pPropertyIds: ptr PROPERTYID, eventIdCount: UINT, pEventIds: ptr EVENTID): HRESULT {.stdcall.} + IUIAutomationCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationConditionVtbl + IUIAutomationConditionVtbl* {.pure, inheritable.} = object of IUnknownVtbl + IUIAutomationElementArray* {.pure.} = object + lpVtbl*: ptr IUIAutomationElementArrayVtbl + IUIAutomationElementArrayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Length*: proc(self: ptr IUIAutomationElementArray, length: ptr int32): HRESULT {.stdcall.} + GetElement*: proc(self: ptr IUIAutomationElementArray, index: int32, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationCacheRequest* {.pure.} = object + lpVtbl*: ptr IUIAutomationCacheRequestVtbl + IUIAutomationCacheRequestVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddProperty*: proc(self: ptr IUIAutomationCacheRequest, propertyId: PROPERTYID): HRESULT {.stdcall.} + AddPattern*: proc(self: ptr IUIAutomationCacheRequest, patternId: PATTERNID): HRESULT {.stdcall.} + Clone*: proc(self: ptr IUIAutomationCacheRequest, clonedRequest: ptr ptr IUIAutomationCacheRequest): HRESULT {.stdcall.} + get_TreeScope*: proc(self: ptr IUIAutomationCacheRequest, scope: ptr TreeScope): HRESULT {.stdcall.} + put_TreeScope*: proc(self: ptr IUIAutomationCacheRequest, scope: TreeScope): HRESULT {.stdcall.} + get_TreeFilter*: proc(self: ptr IUIAutomationCacheRequest, filter: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + put_TreeFilter*: proc(self: ptr IUIAutomationCacheRequest, filter: ptr IUIAutomationCondition): HRESULT {.stdcall.} + get_AutomationElementMode*: proc(self: ptr IUIAutomationCacheRequest, mode: ptr AutomationElementMode): HRESULT {.stdcall.} + put_AutomationElementMode*: proc(self: ptr IUIAutomationCacheRequest, mode: AutomationElementMode): HRESULT {.stdcall.} + IUIAutomationElement* {.pure.} = object + lpVtbl*: ptr IUIAutomationElementVtbl + IUIAutomationElementVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetFocus*: proc(self: ptr IUIAutomationElement): HRESULT {.stdcall.} + GetRuntimeId*: proc(self: ptr IUIAutomationElement, runtimeId: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + FindFirst*: proc(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, found: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + FindAll*: proc(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, found: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + FindFirstBuildCache*: proc(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, found: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + FindAllBuildCache*: proc(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, found: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + BuildUpdatedCache*: proc(self: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, updatedElement: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetCurrentPropertyValue*: proc(self: ptr IUIAutomationElement, propertyId: PROPERTYID, retVal: ptr VARIANT): HRESULT {.stdcall.} + GetCurrentPropertyValueEx*: proc(self: ptr IUIAutomationElement, propertyId: PROPERTYID, ignoreDefaultValue: BOOL, retVal: ptr VARIANT): HRESULT {.stdcall.} + GetCachedPropertyValue*: proc(self: ptr IUIAutomationElement, propertyId: PROPERTYID, retVal: ptr VARIANT): HRESULT {.stdcall.} + GetCachedPropertyValueEx*: proc(self: ptr IUIAutomationElement, propertyId: PROPERTYID, ignoreDefaultValue: BOOL, retVal: ptr VARIANT): HRESULT {.stdcall.} + GetCurrentPatternAs*: proc(self: ptr IUIAutomationElement, patternId: PATTERNID, riid: REFIID, patternObject: ptr pointer): HRESULT {.stdcall.} + GetCachedPatternAs*: proc(self: ptr IUIAutomationElement, patternId: PATTERNID, riid: REFIID, patternObject: ptr pointer): HRESULT {.stdcall.} + GetCurrentPattern*: proc(self: ptr IUIAutomationElement, patternId: PATTERNID, patternObject: ptr ptr IUnknown): HRESULT {.stdcall.} + GetCachedPattern*: proc(self: ptr IUIAutomationElement, patternId: PATTERNID, patternObject: ptr ptr IUnknown): HRESULT {.stdcall.} + GetCachedParent*: proc(self: ptr IUIAutomationElement, parent: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetCachedChildren*: proc(self: ptr IUIAutomationElement, children: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentProcessId*: proc(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentControlType*: proc(self: ptr IUIAutomationElement, retVal: ptr CONTROLTYPEID): HRESULT {.stdcall.} + get_CurrentLocalizedControlType*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentName*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentAcceleratorKey*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentAccessKey*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentHasKeyboardFocus*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsKeyboardFocusable*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsEnabled*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentAutomationId*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentClassName*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentHelpText*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentCulture*: proc(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentIsControlElement*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsContentElement*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsPassword*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentNativeWindowHandle*: proc(self: ptr IUIAutomationElement, retVal: ptr UIA_HWND): HRESULT {.stdcall.} + get_CurrentItemType*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentIsOffscreen*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentOrientation*: proc(self: ptr IUIAutomationElement, retVal: ptr OrientationType): HRESULT {.stdcall.} + get_CurrentFrameworkId*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentIsRequiredForForm*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentItemStatus*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentBoundingRectangle*: proc(self: ptr IUIAutomationElement, retVal: ptr RECT): HRESULT {.stdcall.} + get_CurrentLabeledBy*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentAriaRole*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentAriaProperties*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentIsDataValidForForm*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentControllerFor*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentDescribedBy*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentFlowsTo*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentProviderDescription*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedProcessId*: proc(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedControlType*: proc(self: ptr IUIAutomationElement, retVal: ptr CONTROLTYPEID): HRESULT {.stdcall.} + get_CachedLocalizedControlType*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedName*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedAcceleratorKey*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedAccessKey*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedHasKeyboardFocus*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsKeyboardFocusable*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsEnabled*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedAutomationId*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedClassName*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedHelpText*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedCulture*: proc(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedIsControlElement*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsContentElement*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsPassword*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedNativeWindowHandle*: proc(self: ptr IUIAutomationElement, retVal: ptr UIA_HWND): HRESULT {.stdcall.} + get_CachedItemType*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedIsOffscreen*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedOrientation*: proc(self: ptr IUIAutomationElement, retVal: ptr OrientationType): HRESULT {.stdcall.} + get_CachedFrameworkId*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedIsRequiredForForm*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedItemStatus*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedBoundingRectangle*: proc(self: ptr IUIAutomationElement, retVal: ptr RECT): HRESULT {.stdcall.} + get_CachedLabeledBy*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedAriaRole*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedAriaProperties*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedIsDataValidForForm*: proc(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedControllerFor*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedDescribedBy*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedFlowsTo*: proc(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedProviderDescription*: proc(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.stdcall.} + GetClickablePoint*: proc(self: ptr IUIAutomationElement, clickable: ptr POINT, gotClickable: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationBoolCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationBoolConditionVtbl + IUIAutomationBoolConditionVtbl* {.pure, inheritable.} = object of IUIAutomationConditionVtbl + get_BooleanValue*: proc(self: ptr IUIAutomationBoolCondition, boolVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationPropertyCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationPropertyConditionVtbl + IUIAutomationPropertyConditionVtbl* {.pure, inheritable.} = object of IUIAutomationConditionVtbl + get_PropertyId*: proc(self: ptr IUIAutomationPropertyCondition, propertyId: ptr PROPERTYID): HRESULT {.stdcall.} + get_PropertyValue*: proc(self: ptr IUIAutomationPropertyCondition, propertyValue: ptr VARIANT): HRESULT {.stdcall.} + get_PropertyConditionFlags*: proc(self: ptr IUIAutomationPropertyCondition, flags: ptr PropertyConditionFlags): HRESULT {.stdcall.} + IUIAutomationAndCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationAndConditionVtbl + IUIAutomationAndConditionVtbl* {.pure, inheritable.} = object of IUIAutomationConditionVtbl + get_ChildCount*: proc(self: ptr IUIAutomationAndCondition, childCount: ptr int32): HRESULT {.stdcall.} + GetChildrenAsNativeArray*: proc(self: ptr IUIAutomationAndCondition, childArray: ptr ptr ptr IUIAutomationCondition, childArrayCount: ptr int32): HRESULT {.stdcall.} + GetChildren*: proc(self: ptr IUIAutomationAndCondition, childArray: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationOrCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationOrConditionVtbl + IUIAutomationOrConditionVtbl* {.pure, inheritable.} = object of IUIAutomationConditionVtbl + get_ChildCount*: proc(self: ptr IUIAutomationOrCondition, childCount: ptr int32): HRESULT {.stdcall.} + GetChildrenAsNativeArray*: proc(self: ptr IUIAutomationOrCondition, childArray: ptr ptr ptr IUIAutomationCondition, childArrayCount: ptr int32): HRESULT {.stdcall.} + GetChildren*: proc(self: ptr IUIAutomationOrCondition, childArray: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationNotCondition* {.pure.} = object + lpVtbl*: ptr IUIAutomationNotConditionVtbl + IUIAutomationNotConditionVtbl* {.pure, inheritable.} = object of IUIAutomationConditionVtbl + GetChild*: proc(self: ptr IUIAutomationNotCondition, condition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + IUIAutomationTreeWalker* {.pure.} = object + lpVtbl*: ptr IUIAutomationTreeWalkerVtbl + IUIAutomationTreeWalkerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetParentElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, parent: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetFirstChildElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, first: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetLastChildElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, last: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetNextSiblingElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, next: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetPreviousSiblingElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, previous: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + NormalizeElement*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, normalized: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetParentElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, parent: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetFirstChildElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, first: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetLastChildElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, last: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetNextSiblingElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, next: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetPreviousSiblingElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, previous: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + NormalizeElementBuildCache*: proc(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, normalized: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_Condition*: proc(self: ptr IUIAutomationTreeWalker, condition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + IUIAutomationEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationEventHandlerVtbl + IUIAutomationEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleAutomationEvent*: proc(self: ptr IUIAutomationEventHandler, sender: ptr IUIAutomationElement, eventId: EVENTID): HRESULT {.stdcall.} + IUIAutomationPropertyChangedEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationPropertyChangedEventHandlerVtbl + IUIAutomationPropertyChangedEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandlePropertyChangedEvent*: proc(self: ptr IUIAutomationPropertyChangedEventHandler, sender: ptr IUIAutomationElement, propertyId: PROPERTYID, newValue: VARIANT): HRESULT {.stdcall.} + IUIAutomationStructureChangedEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationStructureChangedEventHandlerVtbl + IUIAutomationStructureChangedEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleStructureChangedEvent*: proc(self: ptr IUIAutomationStructureChangedEventHandler, sender: ptr IUIAutomationElement, changeType: StructureChangeType, runtimeId: ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationFocusChangedEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationFocusChangedEventHandlerVtbl + IUIAutomationFocusChangedEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleFocusChangedEvent*: proc(self: ptr IUIAutomationFocusChangedEventHandler, sender: ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationTextEditTextChangedEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextEditTextChangedEventHandlerVtbl + IUIAutomationTextEditTextChangedEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleTextEditTextChangedEvent*: proc(self: ptr IUIAutomationTextEditTextChangedEventHandler, sender: ptr IUIAutomationElement, textEditChangeType: TextEditChangeType, eventStrings: ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationChangesEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationChangesEventHandlerVtbl + IUIAutomationChangesEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleChangesEvent*: proc(self: ptr IUIAutomationChangesEventHandler, sender: ptr IUIAutomationElement, uiaChanges: ptr UiaChangeInfo, changesCount: int32): HRESULT {.stdcall.} + IUIAutomationNotificationEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationNotificationEventHandlerVtbl + IUIAutomationNotificationEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleNotificationEvent*: proc(self: ptr IUIAutomationNotificationEventHandler, sender: ptr IUIAutomationElement, notificationKind: NotificationKind, notificationProcessing: NotificationProcessing, displayString: BSTR, activityId: BSTR): HRESULT {.stdcall.} + IUIAutomationInvokePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationInvokePatternVtbl + IUIAutomationInvokePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Invoke*: proc(self: ptr IUIAutomationInvokePattern): HRESULT {.stdcall.} + IUIAutomationDockPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationDockPatternVtbl + IUIAutomationDockPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetDockPosition*: proc(self: ptr IUIAutomationDockPattern, dockPos: DockPosition): HRESULT {.stdcall.} + get_CurrentDockPosition*: proc(self: ptr IUIAutomationDockPattern, retVal: ptr DockPosition): HRESULT {.stdcall.} + get_CachedDockPosition*: proc(self: ptr IUIAutomationDockPattern, retVal: ptr DockPosition): HRESULT {.stdcall.} + IUIAutomationExpandCollapsePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationExpandCollapsePatternVtbl + IUIAutomationExpandCollapsePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Expand*: proc(self: ptr IUIAutomationExpandCollapsePattern): HRESULT {.stdcall.} + Collapse*: proc(self: ptr IUIAutomationExpandCollapsePattern): HRESULT {.stdcall.} + get_CurrentExpandCollapseState*: proc(self: ptr IUIAutomationExpandCollapsePattern, retVal: ptr ExpandCollapseState): HRESULT {.stdcall.} + get_CachedExpandCollapseState*: proc(self: ptr IUIAutomationExpandCollapsePattern, retVal: ptr ExpandCollapseState): HRESULT {.stdcall.} + IUIAutomationGridPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationGridPatternVtbl + IUIAutomationGridPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetItem*: proc(self: ptr IUIAutomationGridPattern, row: int32, column: int32, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentRowCount*: proc(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentColumnCount*: proc(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedRowCount*: proc(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedColumnCount*: proc(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.stdcall.} + IUIAutomationGridItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationGridItemPatternVtbl + IUIAutomationGridItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentContainingGrid*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentRow*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentColumn*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentRowSpan*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentColumnSpan*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedContainingGrid*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedRow*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedColumn*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedRowSpan*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedColumnSpan*: proc(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.stdcall.} + IUIAutomationMultipleViewPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationMultipleViewPatternVtbl + IUIAutomationMultipleViewPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetViewName*: proc(self: ptr IUIAutomationMultipleViewPattern, view: int32, name: ptr BSTR): HRESULT {.stdcall.} + SetCurrentView*: proc(self: ptr IUIAutomationMultipleViewPattern, view: int32): HRESULT {.stdcall.} + get_CurrentCurrentView*: proc(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr int32): HRESULT {.stdcall.} + GetCurrentSupportedViews*: proc(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CachedCurrentView*: proc(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr int32): HRESULT {.stdcall.} + GetCachedSupportedViews*: proc(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationObjectModelPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationObjectModelPatternVtbl + IUIAutomationObjectModelPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetUnderlyingObjectModel*: proc(self: ptr IUIAutomationObjectModelPattern, retVal: ptr ptr IUnknown): HRESULT {.stdcall.} + IUIAutomationRangeValuePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationRangeValuePatternVtbl + IUIAutomationRangeValuePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetValue*: proc(self: ptr IUIAutomationRangeValuePattern, val: float64): HRESULT {.stdcall.} + get_CurrentValue*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentIsReadOnly*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentMaximum*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentMinimum*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentLargeChange*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentSmallChange*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedValue*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedIsReadOnly*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedMaximum*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedMinimum*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedLargeChange*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedSmallChange*: proc(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.stdcall.} + IUIAutomationScrollPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationScrollPatternVtbl + IUIAutomationScrollPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Scroll*: proc(self: ptr IUIAutomationScrollPattern, horizontalAmount: ScrollAmount, verticalAmount: ScrollAmount): HRESULT {.stdcall.} + SetScrollPercent*: proc(self: ptr IUIAutomationScrollPattern, horizontalPercent: float64, verticalPercent: float64): HRESULT {.stdcall.} + get_CurrentHorizontalScrollPercent*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentVerticalScrollPercent*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentHorizontalViewSize*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentVerticalViewSize*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentHorizontallyScrollable*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentVerticallyScrollable*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedHorizontalScrollPercent*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedVerticalScrollPercent*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedHorizontalViewSize*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedVerticalViewSize*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedHorizontallyScrollable*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedVerticallyScrollable*: proc(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationScrollItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationScrollItemPatternVtbl + IUIAutomationScrollItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + ScrollIntoView*: proc(self: ptr IUIAutomationScrollItemPattern): HRESULT {.stdcall.} + IUIAutomationSelectionPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationSelectionPatternVtbl + IUIAutomationSelectionPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentSelection*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentCanSelectMultiple*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsSelectionRequired*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + GetCachedSelection*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedCanSelectMultiple*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsSelectionRequired*: proc(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationSelectionPattern2* {.pure.} = object + lpVtbl*: ptr IUIAutomationSelectionPattern2Vtbl + IUIAutomationSelectionPattern2Vtbl* {.pure, inheritable.} = object of IUIAutomationSelectionPatternVtbl + get_CurrentFirstSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentLastSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentCurrentSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CurrentItemCount*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedFirstSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedLastSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedCurrentSelectedItem*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedItemCount*: proc(self: ptr IUIAutomationSelectionPattern2, retVal: ptr int32): HRESULT {.stdcall.} + IUIAutomationSelectionItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationSelectionItemPatternVtbl + IUIAutomationSelectionItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Select*: proc(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.stdcall.} + AddToSelection*: proc(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.stdcall.} + RemoveFromSelection*: proc(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.stdcall.} + get_CurrentIsSelected*: proc(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentSelectionContainer*: proc(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedIsSelected*: proc(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedSelectionContainer*: proc(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationSynchronizedInputPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationSynchronizedInputPatternVtbl + IUIAutomationSynchronizedInputPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + StartListening*: proc(self: ptr IUIAutomationSynchronizedInputPattern, inputType: SynchronizedInputType): HRESULT {.stdcall.} + Cancel*: proc(self: ptr IUIAutomationSynchronizedInputPattern): HRESULT {.stdcall.} + IUIAutomationTablePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTablePatternVtbl + IUIAutomationTablePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentRowHeaders*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCurrentColumnHeaders*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentRowOrColumnMajor*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr RowOrColumnMajor): HRESULT {.stdcall.} + GetCachedRowHeaders*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCachedColumnHeaders*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedRowOrColumnMajor*: proc(self: ptr IUIAutomationTablePattern, retVal: ptr RowOrColumnMajor): HRESULT {.stdcall.} + IUIAutomationTableItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTableItemPatternVtbl + IUIAutomationTableItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetCurrentRowHeaderItems*: proc(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCurrentColumnHeaderItems*: proc(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCachedRowHeaderItems*: proc(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCachedColumnHeaderItems*: proc(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + IUIAutomationTogglePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTogglePatternVtbl + IUIAutomationTogglePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Toggle*: proc(self: ptr IUIAutomationTogglePattern): HRESULT {.stdcall.} + get_CurrentToggleState*: proc(self: ptr IUIAutomationTogglePattern, retVal: ptr ToggleState): HRESULT {.stdcall.} + get_CachedToggleState*: proc(self: ptr IUIAutomationTogglePattern, retVal: ptr ToggleState): HRESULT {.stdcall.} + IUIAutomationTransformPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTransformPatternVtbl + IUIAutomationTransformPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Move*: proc(self: ptr IUIAutomationTransformPattern, x: float64, y: float64): HRESULT {.stdcall.} + Resize*: proc(self: ptr IUIAutomationTransformPattern, width: float64, height: float64): HRESULT {.stdcall.} + Rotate*: proc(self: ptr IUIAutomationTransformPattern, degrees: float64): HRESULT {.stdcall.} + get_CurrentCanMove*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentCanResize*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentCanRotate*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedCanMove*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedCanResize*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedCanRotate*: proc(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationValuePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationValuePatternVtbl + IUIAutomationValuePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + SetValue*: proc(self: ptr IUIAutomationValuePattern, val: BSTR): HRESULT {.stdcall.} + get_CurrentValue*: proc(self: ptr IUIAutomationValuePattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentIsReadOnly*: proc(self: ptr IUIAutomationValuePattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedValue*: proc(self: ptr IUIAutomationValuePattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedIsReadOnly*: proc(self: ptr IUIAutomationValuePattern, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationWindowPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationWindowPatternVtbl + IUIAutomationWindowPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Close*: proc(self: ptr IUIAutomationWindowPattern): HRESULT {.stdcall.} + WaitForInputIdle*: proc(self: ptr IUIAutomationWindowPattern, milliseconds: int32, success: ptr BOOL): HRESULT {.stdcall.} + SetWindowVisualState*: proc(self: ptr IUIAutomationWindowPattern, state: WindowVisualState): HRESULT {.stdcall.} + get_CurrentCanMaximize*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentCanMinimize*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsModal*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentIsTopmost*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentWindowVisualState*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowVisualState): HRESULT {.stdcall.} + get_CurrentWindowInteractionState*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowInteractionState): HRESULT {.stdcall.} + get_CachedCanMaximize*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedCanMinimize*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsModal*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsTopmost*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedWindowVisualState*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowVisualState): HRESULT {.stdcall.} + get_CachedWindowInteractionState*: proc(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowInteractionState): HRESULT {.stdcall.} + IUIAutomationTextRange* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextRangeVtbl + IUIAutomationTextRangeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Clone*: proc(self: ptr IUIAutomationTextRange, clonedRange: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + Compare*: proc(self: ptr IUIAutomationTextRange, range: ptr IUIAutomationTextRange, areSame: ptr BOOL): HRESULT {.stdcall.} + CompareEndpoints*: proc(self: ptr IUIAutomationTextRange, srcEndPoint: TextPatternRangeEndpoint, range: ptr IUIAutomationTextRange, targetEndPoint: TextPatternRangeEndpoint, compValue: ptr int32): HRESULT {.stdcall.} + ExpandToEnclosingUnit*: proc(self: ptr IUIAutomationTextRange, textUnit: TextUnit): HRESULT {.stdcall.} + FindAttribute*: proc(self: ptr IUIAutomationTextRange, attr: TEXTATTRIBUTEID, val: VARIANT, backward: BOOL, found: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + FindText*: proc(self: ptr IUIAutomationTextRange, text: BSTR, backward: BOOL, ignoreCase: BOOL, found: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + GetAttributeValue*: proc(self: ptr IUIAutomationTextRange, attr: TEXTATTRIBUTEID, value: ptr VARIANT): HRESULT {.stdcall.} + GetBoundingRectangles*: proc(self: ptr IUIAutomationTextRange, boundingRects: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetEnclosingElement*: proc(self: ptr IUIAutomationTextRange, enclosingElement: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetText*: proc(self: ptr IUIAutomationTextRange, maxLength: int32, text: ptr BSTR): HRESULT {.stdcall.} + Move*: proc(self: ptr IUIAutomationTextRange, unit: TextUnit, count: int32, moved: ptr int32): HRESULT {.stdcall.} + MoveEndpointByUnit*: proc(self: ptr IUIAutomationTextRange, endpoint: TextPatternRangeEndpoint, unit: TextUnit, count: int32, moved: ptr int32): HRESULT {.stdcall.} + MoveEndpointByRange*: proc(self: ptr IUIAutomationTextRange, srcEndPoint: TextPatternRangeEndpoint, range: ptr IUIAutomationTextRange, targetEndPoint: TextPatternRangeEndpoint): HRESULT {.stdcall.} + Select*: proc(self: ptr IUIAutomationTextRange): HRESULT {.stdcall.} + AddToSelection*: proc(self: ptr IUIAutomationTextRange): HRESULT {.stdcall.} + RemoveFromSelection*: proc(self: ptr IUIAutomationTextRange): HRESULT {.stdcall.} + ScrollIntoView*: proc(self: ptr IUIAutomationTextRange, alignToTop: BOOL): HRESULT {.stdcall.} + GetChildren*: proc(self: ptr IUIAutomationTextRange, children: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + IUIAutomationTextRange2* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextRange2Vtbl + IUIAutomationTextRange2Vtbl* {.pure, inheritable.} = object of IUIAutomationTextRangeVtbl + ShowContextMenu*: proc(self: ptr IUIAutomationTextRange2): HRESULT {.stdcall.} + IUIAutomationTextRange3* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextRange3Vtbl + IUIAutomationTextRange3Vtbl* {.pure, inheritable.} = object of IUIAutomationTextRange2Vtbl + GetEnclosingElementBuildCache*: proc(self: ptr IUIAutomationTextRange3, cacheRequest: ptr IUIAutomationCacheRequest, enclosingElement: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetChildrenBuildCache*: proc(self: ptr IUIAutomationTextRange3, cacheRequest: ptr IUIAutomationCacheRequest, children: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetAttributeValues*: proc(self: ptr IUIAutomationTextRange3, attributeIds: ptr TEXTATTRIBUTEID, attributeIdCount: int32, attributeValues: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationTextRangeArray* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextRangeArrayVtbl + IUIAutomationTextRangeArrayVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Length*: proc(self: ptr IUIAutomationTextRangeArray, length: ptr int32): HRESULT {.stdcall.} + GetElement*: proc(self: ptr IUIAutomationTextRangeArray, index: int32, element: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + IUIAutomationTextPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextPatternVtbl + IUIAutomationTextPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + RangeFromPoint*: proc(self: ptr IUIAutomationTextPattern, pt: POINT, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + RangeFromChild*: proc(self: ptr IUIAutomationTextPattern, child: ptr IUIAutomationElement, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + GetSelection*: proc(self: ptr IUIAutomationTextPattern, ranges: ptr ptr IUIAutomationTextRangeArray): HRESULT {.stdcall.} + GetVisibleRanges*: proc(self: ptr IUIAutomationTextPattern, ranges: ptr ptr IUIAutomationTextRangeArray): HRESULT {.stdcall.} + get_DocumentRange*: proc(self: ptr IUIAutomationTextPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + get_SupportedTextSelection*: proc(self: ptr IUIAutomationTextPattern, supportedTextSelection: ptr SupportedTextSelection): HRESULT {.stdcall.} + IUIAutomationTextPattern2* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextPattern2Vtbl + IUIAutomationTextPattern2Vtbl* {.pure, inheritable.} = object of IUIAutomationTextPatternVtbl + RangeFromAnnotation*: proc(self: ptr IUIAutomationTextPattern2, annotation: ptr IUIAutomationElement, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + GetCaretRange*: proc(self: ptr IUIAutomationTextPattern2, isActive: ptr BOOL, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + IUIAutomationTextEditPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextEditPatternVtbl + IUIAutomationTextEditPatternVtbl* {.pure, inheritable.} = object of IUIAutomationTextPatternVtbl + GetActiveComposition*: proc(self: ptr IUIAutomationTextEditPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + GetConversionTarget*: proc(self: ptr IUIAutomationTextEditPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + IUIAutomationCustomNavigationPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationCustomNavigationPatternVtbl + IUIAutomationCustomNavigationPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Navigate*: proc(self: ptr IUIAutomationCustomNavigationPattern, direction: NavigateDirection, pRetVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationActiveTextPositionChangedEventHandler* {.pure.} = object + lpVtbl*: ptr IUIAutomationActiveTextPositionChangedEventHandlerVtbl + IUIAutomationActiveTextPositionChangedEventHandlerVtbl* {.pure, inheritable.} = object of IUnknownVtbl + HandleActiveTextPositionChangedEvent*: proc(self: ptr IUIAutomationActiveTextPositionChangedEventHandler, sender: ptr IUIAutomationElement, range: ptr IUIAutomationTextRange): HRESULT {.stdcall.} + IUIAutomationLegacyIAccessiblePattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationLegacyIAccessiblePatternVtbl + IUIAutomationLegacyIAccessiblePatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Select*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, flagsSelect: int32): HRESULT {.stdcall.} + DoDefaultAction*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern): HRESULT {.stdcall.} + SetValue*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, szValue: LPCWSTR): HRESULT {.stdcall.} + get_CurrentChildId*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pRetVal: ptr int32): HRESULT {.stdcall.} + get_CurrentName*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszName: ptr BSTR): HRESULT {.stdcall.} + get_CurrentValue*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszValue: ptr BSTR): HRESULT {.stdcall.} + get_CurrentDescription*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDescription: ptr BSTR): HRESULT {.stdcall.} + get_CurrentRole*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwRole: ptr DWORD): HRESULT {.stdcall.} + get_CurrentState*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwState: ptr DWORD): HRESULT {.stdcall.} + get_CurrentHelp*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszHelp: ptr BSTR): HRESULT {.stdcall.} + get_CurrentKeyboardShortcut*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszKeyboardShortcut: ptr BSTR): HRESULT {.stdcall.} + GetCurrentSelection*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pvarSelectedChildren: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CurrentDefaultAction*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDefaultAction: ptr BSTR): HRESULT {.stdcall.} + get_CachedChildId*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pRetVal: ptr int32): HRESULT {.stdcall.} + get_CachedName*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszName: ptr BSTR): HRESULT {.stdcall.} + get_CachedValue*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszValue: ptr BSTR): HRESULT {.stdcall.} + get_CachedDescription*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDescription: ptr BSTR): HRESULT {.stdcall.} + get_CachedRole*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwRole: ptr DWORD): HRESULT {.stdcall.} + get_CachedState*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwState: ptr DWORD): HRESULT {.stdcall.} + get_CachedHelp*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszHelp: ptr BSTR): HRESULT {.stdcall.} + get_CachedKeyboardShortcut*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszKeyboardShortcut: ptr BSTR): HRESULT {.stdcall.} + GetCachedSelection*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pvarSelectedChildren: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedDefaultAction*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDefaultAction: ptr BSTR): HRESULT {.stdcall.} + GetIAccessible*: proc(self: ptr IUIAutomationLegacyIAccessiblePattern, ppAccessible: ptr ptr IAccessible): HRESULT {.stdcall.} + IUIAutomationItemContainerPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationItemContainerPatternVtbl + IUIAutomationItemContainerPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + FindItemByProperty*: proc(self: ptr IUIAutomationItemContainerPattern, pStartAfter: ptr IUIAutomationElement, propertyId: PROPERTYID, value: VARIANT, pFound: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationVirtualizedItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationVirtualizedItemPatternVtbl + IUIAutomationVirtualizedItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Realize*: proc(self: ptr IUIAutomationVirtualizedItemPattern): HRESULT {.stdcall.} + IUIAutomationAnnotationPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationAnnotationPatternVtbl + IUIAutomationAnnotationPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentAnnotationTypeId*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentAnnotationTypeName*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentAuthor*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentDateTime*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentTarget*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_CachedAnnotationTypeId*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedAnnotationTypeName*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedAuthor*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedDateTime*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedTarget*: proc(self: ptr IUIAutomationAnnotationPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationStylesPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationStylesPatternVtbl + IUIAutomationStylesPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentStyleId*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentStyleName*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentFillColor*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentFillPatternStyle*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentShape*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentFillPatternColor*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentExtendedProperties*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + GetCurrentExtendedPropertiesAsArray*: proc(self: ptr IUIAutomationStylesPattern, propertyArray: ptr ptr TExtendedProperty, propertyCount: ptr int32): HRESULT {.stdcall.} + get_CachedStyleId*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedStyleName*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedFillColor*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedFillPatternStyle*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedShape*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedFillPatternColor*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedExtendedProperties*: proc(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + GetCachedExtendedPropertiesAsArray*: proc(self: ptr IUIAutomationStylesPattern, propertyArray: ptr ptr TExtendedProperty, propertyCount: ptr int32): HRESULT {.stdcall.} + IUIAutomationSpreadsheetPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationSpreadsheetPatternVtbl + IUIAutomationSpreadsheetPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetItemByName*: proc(self: ptr IUIAutomationSpreadsheetPattern, name: BSTR, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomationSpreadsheetItemPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationSpreadsheetItemPatternVtbl + IUIAutomationSpreadsheetItemPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentFormula*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + GetCurrentAnnotationObjects*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCurrentAnnotationTypes*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CachedFormula*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + GetCachedAnnotationObjects*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCachedAnnotationTypes*: proc(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationTransformPattern2* {.pure.} = object + lpVtbl*: ptr IUIAutomationTransformPattern2Vtbl + IUIAutomationTransformPattern2Vtbl* {.pure, inheritable.} = object of IUIAutomationTransformPatternVtbl + Zoom*: proc(self: ptr IUIAutomationTransformPattern2, zoomValue: float64): HRESULT {.stdcall.} + ZoomByUnit*: proc(self: ptr IUIAutomationTransformPattern2, zoomUnit: ZoomUnit): HRESULT {.stdcall.} + get_CurrentCanZoom*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedCanZoom*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentZoomLevel*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedZoomLevel*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentZoomMinimum*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedZoomMinimum*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + get_CurrentZoomMaximum*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + get_CachedZoomMaximum*: proc(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.stdcall.} + IUIAutomationTextChildPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationTextChildPatternVtbl + IUIAutomationTextChildPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_TextContainer*: proc(self: ptr IUIAutomationTextChildPattern, container: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + get_TextRange*: proc(self: ptr IUIAutomationTextChildPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.stdcall.} + IUIAutomationDragPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationDragPatternVtbl + IUIAutomationDragPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentIsGrabbed*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsGrabbed*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentDropEffect*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedDropEffect*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentDropEffects*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CachedDropEffects*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetCurrentGrabbedItems*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCachedGrabbedItems*: proc(self: ptr IUIAutomationDragPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + IUIAutomationDropTargetPattern* {.pure.} = object + lpVtbl*: ptr IUIAutomationDropTargetPatternVtbl + IUIAutomationDropTargetPatternVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_CurrentDropTargetEffect*: proc(self: ptr IUIAutomationDropTargetPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedDropTargetEffect*: proc(self: ptr IUIAutomationDropTargetPattern, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CurrentDropTargetEffects*: proc(self: ptr IUIAutomationDropTargetPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CachedDropTargetEffects*: proc(self: ptr IUIAutomationDropTargetPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationElement2* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement2Vtbl + IUIAutomationElement2Vtbl* {.pure, inheritable.} = object of IUIAutomationElementVtbl + get_CurrentOptimizeForVisualContent*: proc(self: ptr IUIAutomationElement2, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedOptimizeForVisualContent*: proc(self: ptr IUIAutomationElement2, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CurrentLiveSetting*: proc(self: ptr IUIAutomationElement2, retVal: ptr LiveSetting): HRESULT {.stdcall.} + get_CachedLiveSetting*: proc(self: ptr IUIAutomationElement2, retVal: ptr LiveSetting): HRESULT {.stdcall.} + get_CurrentFlowsFrom*: proc(self: ptr IUIAutomationElement2, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedFlowsFrom*: proc(self: ptr IUIAutomationElement2, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + IUIAutomationElement3* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement3Vtbl + IUIAutomationElement3Vtbl* {.pure, inheritable.} = object of IUIAutomationElement2Vtbl + ShowContextMenu*: proc(self: ptr IUIAutomationElement3): HRESULT {.stdcall.} + get_CurrentIsPeripheral*: proc(self: ptr IUIAutomationElement3, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsPeripheral*: proc(self: ptr IUIAutomationElement3, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationElement4* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement4Vtbl + IUIAutomationElement4Vtbl* {.pure, inheritable.} = object of IUIAutomationElement3Vtbl + get_CurrentPositionInSet*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentSizeOfSet*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentLevel*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CurrentAnnotationTypes*: proc(self: ptr IUIAutomationElement4, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CurrentAnnotationObjects*: proc(self: ptr IUIAutomationElement4, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + get_CachedPositionInSet*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedSizeOfSet*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedLevel*: proc(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.stdcall.} + get_CachedAnnotationTypes*: proc(self: ptr IUIAutomationElement4, retVal: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + get_CachedAnnotationObjects*: proc(self: ptr IUIAutomationElement4, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + IUIAutomationElement5* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement5Vtbl + IUIAutomationElement5Vtbl* {.pure, inheritable.} = object of IUIAutomationElement4Vtbl + get_CurrentLandmarkType*: proc(self: ptr IUIAutomationElement5, retVal: ptr LANDMARKTYPEID): HRESULT {.stdcall.} + get_CurrentLocalizedLandmarkType*: proc(self: ptr IUIAutomationElement5, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedLandmarkType*: proc(self: ptr IUIAutomationElement5, retVal: ptr LANDMARKTYPEID): HRESULT {.stdcall.} + get_CachedLocalizedLandmarkType*: proc(self: ptr IUIAutomationElement5, retVal: ptr BSTR): HRESULT {.stdcall.} + IUIAutomationElement6* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement6Vtbl + IUIAutomationElement6Vtbl* {.pure, inheritable.} = object of IUIAutomationElement5Vtbl + get_CurrentFullDescription*: proc(self: ptr IUIAutomationElement6, retVal: ptr BSTR): HRESULT {.stdcall.} + get_CachedFullDescription*: proc(self: ptr IUIAutomationElement6, retVal: ptr BSTR): HRESULT {.stdcall.} + IUIAutomationElement7* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement7Vtbl + IUIAutomationElement7Vtbl* {.pure, inheritable.} = object of IUIAutomationElement6Vtbl + FindFirstWithOptions*: proc(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + FindAllWithOptions*: proc(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + FindFirstWithOptionsBuildCache*: proc(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + FindAllWithOptionsBuildCache*: proc(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElementArray): HRESULT {.stdcall.} + GetCurrentMetadataValue*: proc(self: ptr IUIAutomationElement7, targetId: int32, metadataId: METADATAID, returnVal: ptr VARIANT): HRESULT {.stdcall.} + IUIAutomationElement8* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement8Vtbl + IUIAutomationElement8Vtbl* {.pure, inheritable.} = object of IUIAutomationElement7Vtbl + get_CurrentHeadingLevel*: proc(self: ptr IUIAutomationElement8, retVal: ptr HEADINGLEVELID): HRESULT {.stdcall.} + get_CachedHeadingLevel*: proc(self: ptr IUIAutomationElement8, retVal: ptr HEADINGLEVELID): HRESULT {.stdcall.} + IUIAutomationElement9* {.pure.} = object + lpVtbl*: ptr IUIAutomationElement9Vtbl + IUIAutomationElement9Vtbl* {.pure, inheritable.} = object of IUIAutomationElement8Vtbl + get_CurrentIsDialog*: proc(self: ptr IUIAutomationElement9, retVal: ptr BOOL): HRESULT {.stdcall.} + get_CachedIsDialog*: proc(self: ptr IUIAutomationElement9, retVal: ptr BOOL): HRESULT {.stdcall.} + IUIAutomationProxyFactory* {.pure.} = object + lpVtbl*: ptr IUIAutomationProxyFactoryVtbl + IUIAutomationProxyFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateProvider*: proc(self: ptr IUIAutomationProxyFactory, hwnd: UIA_HWND, idObject: LONG, idChild: LONG, provider: ptr ptr IRawElementProviderSimple): HRESULT {.stdcall.} + get_ProxyFactoryId*: proc(self: ptr IUIAutomationProxyFactory, factoryId: ptr BSTR): HRESULT {.stdcall.} + IUIAutomationProxyFactoryEntry* {.pure.} = object + lpVtbl*: ptr IUIAutomationProxyFactoryEntryVtbl + IUIAutomationProxyFactoryEntryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_ProxyFactory*: proc(self: ptr IUIAutomationProxyFactoryEntry, factory: ptr ptr IUIAutomationProxyFactory): HRESULT {.stdcall.} + get_ClassName*: proc(self: ptr IUIAutomationProxyFactoryEntry, className: ptr BSTR): HRESULT {.stdcall.} + get_ImageName*: proc(self: ptr IUIAutomationProxyFactoryEntry, imageName: ptr BSTR): HRESULT {.stdcall.} + get_AllowSubstringMatch*: proc(self: ptr IUIAutomationProxyFactoryEntry, allowSubstringMatch: ptr BOOL): HRESULT {.stdcall.} + get_CanCheckBaseClass*: proc(self: ptr IUIAutomationProxyFactoryEntry, canCheckBaseClass: ptr BOOL): HRESULT {.stdcall.} + get_NeedsAdviseEvents*: proc(self: ptr IUIAutomationProxyFactoryEntry, adviseEvents: ptr BOOL): HRESULT {.stdcall.} + put_ClassName*: proc(self: ptr IUIAutomationProxyFactoryEntry, className: LPCWSTR): HRESULT {.stdcall.} + put_ImageName*: proc(self: ptr IUIAutomationProxyFactoryEntry, imageName: LPCWSTR): HRESULT {.stdcall.} + put_AllowSubstringMatch*: proc(self: ptr IUIAutomationProxyFactoryEntry, allowSubstringMatch: BOOL): HRESULT {.stdcall.} + put_CanCheckBaseClass*: proc(self: ptr IUIAutomationProxyFactoryEntry, canCheckBaseClass: BOOL): HRESULT {.stdcall.} + put_NeedsAdviseEvents*: proc(self: ptr IUIAutomationProxyFactoryEntry, adviseEvents: BOOL): HRESULT {.stdcall.} + SetWinEventsForAutomationEvent*: proc(self: ptr IUIAutomationProxyFactoryEntry, eventId: EVENTID, propertyId: PROPERTYID, winEvents: ptr SAFEARRAY): HRESULT {.stdcall.} + GetWinEventsForAutomationEvent*: proc(self: ptr IUIAutomationProxyFactoryEntry, eventId: EVENTID, propertyId: PROPERTYID, winEvents: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IUIAutomationProxyFactoryMapping* {.pure.} = object + lpVtbl*: ptr IUIAutomationProxyFactoryMappingVtbl + IUIAutomationProxyFactoryMappingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + get_Count*: proc(self: ptr IUIAutomationProxyFactoryMapping, count: ptr UINT): HRESULT {.stdcall.} + GetTable*: proc(self: ptr IUIAutomationProxyFactoryMapping, table: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + GetEntry*: proc(self: ptr IUIAutomationProxyFactoryMapping, index: UINT, entry: ptr ptr IUIAutomationProxyFactoryEntry): HRESULT {.stdcall.} + SetTable*: proc(self: ptr IUIAutomationProxyFactoryMapping, factoryList: ptr SAFEARRAY): HRESULT {.stdcall.} + InsertEntries*: proc(self: ptr IUIAutomationProxyFactoryMapping, before: UINT, factoryList: ptr SAFEARRAY): HRESULT {.stdcall.} + InsertEntry*: proc(self: ptr IUIAutomationProxyFactoryMapping, before: UINT, factory: ptr IUIAutomationProxyFactoryEntry): HRESULT {.stdcall.} + RemoveEntry*: proc(self: ptr IUIAutomationProxyFactoryMapping, index: UINT): HRESULT {.stdcall.} + ClearTable*: proc(self: ptr IUIAutomationProxyFactoryMapping): HRESULT {.stdcall.} + RestoreDefaultTable*: proc(self: ptr IUIAutomationProxyFactoryMapping): HRESULT {.stdcall.} + IUIAutomationEventHandlerGroup* {.pure.} = object + lpVtbl*: ptr IUIAutomationEventHandlerGroupVtbl + IUIAutomationEventHandlerGroupVtbl* {.pure, inheritable.} = object of IUnknownVtbl + AddActiveTextPositionChangedEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.stdcall.} + AddAutomationEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, eventId: EVENTID, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationEventHandler): HRESULT {.stdcall.} + AddChangesEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, changeTypes: ptr int32, changesCount: int32, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.stdcall.} + AddNotificationEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.stdcall.} + AddPropertyChangedEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr PROPERTYID, propertyCount: int32): HRESULT {.stdcall.} + AddStructureChangedEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.stdcall.} + AddTextEditTextChangedEventHandler*: proc(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, textEditChangeType: TextEditChangeType, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.stdcall.} + IUIAutomation* {.pure.} = object + lpVtbl*: ptr IUIAutomationVtbl + IUIAutomationVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CompareElements*: proc(self: ptr IUIAutomation, el1: ptr IUIAutomationElement, el2: ptr IUIAutomationElement, areSame: ptr BOOL): HRESULT {.stdcall.} + CompareRuntimeIds*: proc(self: ptr IUIAutomation, runtimeId1: ptr SAFEARRAY, runtimeId2: ptr SAFEARRAY, areSame: ptr BOOL): HRESULT {.stdcall.} + GetRootElement*: proc(self: ptr IUIAutomation, root: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + ElementFromHandle*: proc(self: ptr IUIAutomation, hwnd: UIA_HWND, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + ElementFromPoint*: proc(self: ptr IUIAutomation, pt: POINT, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetFocusedElement*: proc(self: ptr IUIAutomation, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetRootElementBuildCache*: proc(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, root: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + ElementFromHandleBuildCache*: proc(self: ptr IUIAutomation, hwnd: UIA_HWND, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + ElementFromPointBuildCache*: proc(self: ptr IUIAutomation, pt: POINT, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + GetFocusedElementBuildCache*: proc(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + CreateTreeWalker*: proc(self: ptr IUIAutomation, pCondition: ptr IUIAutomationCondition, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.stdcall.} + get_ControlViewWalker*: proc(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.stdcall.} + get_ContentViewWalker*: proc(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.stdcall.} + get_RawViewWalker*: proc(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.stdcall.} + get_RawViewCondition*: proc(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + get_ControlViewCondition*: proc(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + get_ContentViewCondition*: proc(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateCacheRequest*: proc(self: ptr IUIAutomation, cacheRequest: ptr ptr IUIAutomationCacheRequest): HRESULT {.stdcall.} + CreateTrueCondition*: proc(self: ptr IUIAutomation, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateFalseCondition*: proc(self: ptr IUIAutomation, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreatePropertyCondition*: proc(self: ptr IUIAutomation, propertyId: PROPERTYID, value: VARIANT, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreatePropertyConditionEx*: proc(self: ptr IUIAutomation, propertyId: PROPERTYID, value: VARIANT, flags: PropertyConditionFlags, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateAndCondition*: proc(self: ptr IUIAutomation, condition1: ptr IUIAutomationCondition, condition2: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateAndConditionFromArray*: proc(self: ptr IUIAutomation, conditions: ptr SAFEARRAY, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateAndConditionFromNativeArray*: proc(self: ptr IUIAutomation, conditions: ptr ptr IUIAutomationCondition, conditionCount: int32, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateOrCondition*: proc(self: ptr IUIAutomation, condition1: ptr IUIAutomationCondition, condition2: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateOrConditionFromArray*: proc(self: ptr IUIAutomation, conditions: ptr SAFEARRAY, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateOrConditionFromNativeArray*: proc(self: ptr IUIAutomation, conditions: ptr ptr IUIAutomationCondition, conditionCount: int32, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + CreateNotCondition*: proc(self: ptr IUIAutomation, condition: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.stdcall.} + AddAutomationEventHandler*: proc(self: ptr IUIAutomation, eventId: EVENTID, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationEventHandler): HRESULT {.stdcall.} + RemoveAutomationEventHandler*: proc(self: ptr IUIAutomation, eventId: EVENTID, element: ptr IUIAutomationElement, handler: ptr IUIAutomationEventHandler): HRESULT {.stdcall.} + AddPropertyChangedEventHandlerNativeArray*: proc(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr PROPERTYID, propertyCount: int32): HRESULT {.stdcall.} + AddPropertyChangedEventHandler*: proc(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr SAFEARRAY): HRESULT {.stdcall.} + RemovePropertyChangedEventHandler*: proc(self: ptr IUIAutomation, element: ptr IUIAutomationElement, handler: ptr IUIAutomationPropertyChangedEventHandler): HRESULT {.stdcall.} + AddStructureChangedEventHandler*: proc(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.stdcall.} + RemoveStructureChangedEventHandler*: proc(self: ptr IUIAutomation, element: ptr IUIAutomationElement, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.stdcall.} + AddFocusChangedEventHandler*: proc(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationFocusChangedEventHandler): HRESULT {.stdcall.} + RemoveFocusChangedEventHandler*: proc(self: ptr IUIAutomation, handler: ptr IUIAutomationFocusChangedEventHandler): HRESULT {.stdcall.} + RemoveAllEventHandlers*: proc(self: ptr IUIAutomation): HRESULT {.stdcall.} + IntNativeArrayToSafeArray*: proc(self: ptr IUIAutomation, array: ptr int32, arrayCount: int32, safeArray: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + IntSafeArrayToNativeArray*: proc(self: ptr IUIAutomation, intArray: ptr SAFEARRAY, array: ptr ptr int32, arrayCount: ptr int32): HRESULT {.stdcall.} + RectToVariant*: proc(self: ptr IUIAutomation, rc: RECT, `var`: ptr VARIANT): HRESULT {.stdcall.} + VariantToRect*: proc(self: ptr IUIAutomation, `var`: VARIANT, rc: ptr RECT): HRESULT {.stdcall.} + SafeArrayToRectNativeArray*: proc(self: ptr IUIAutomation, rects: ptr SAFEARRAY, rectArray: ptr ptr RECT, rectArrayCount: ptr int32): HRESULT {.stdcall.} + CreateProxyFactoryEntry*: proc(self: ptr IUIAutomation, factory: ptr IUIAutomationProxyFactory, factoryEntry: ptr ptr IUIAutomationProxyFactoryEntry): HRESULT {.stdcall.} + get_ProxyFactoryMapping*: proc(self: ptr IUIAutomation, factoryMapping: ptr ptr IUIAutomationProxyFactoryMapping): HRESULT {.stdcall.} + GetPropertyProgrammaticName*: proc(self: ptr IUIAutomation, property: PROPERTYID, name: ptr BSTR): HRESULT {.stdcall.} + GetPatternProgrammaticName*: proc(self: ptr IUIAutomation, pattern: PATTERNID, name: ptr BSTR): HRESULT {.stdcall.} + PollForPotentialSupportedPatterns*: proc(self: ptr IUIAutomation, pElement: ptr IUIAutomationElement, patternIds: ptr ptr SAFEARRAY, patternNames: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + PollForPotentialSupportedProperties*: proc(self: ptr IUIAutomation, pElement: ptr IUIAutomationElement, propertyIds: ptr ptr SAFEARRAY, propertyNames: ptr ptr SAFEARRAY): HRESULT {.stdcall.} + CheckNotSupported*: proc(self: ptr IUIAutomation, value: VARIANT, isNotSupported: ptr BOOL): HRESULT {.stdcall.} + get_ReservedNotSupportedValue*: proc(self: ptr IUIAutomation, notSupportedValue: ptr ptr IUnknown): HRESULT {.stdcall.} + get_ReservedMixedAttributeValue*: proc(self: ptr IUIAutomation, mixedAttributeValue: ptr ptr IUnknown): HRESULT {.stdcall.} + ElementFromIAccessible*: proc(self: ptr IUIAutomation, accessible: ptr IAccessible, childId: int32, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + ElementFromIAccessibleBuildCache*: proc(self: ptr IUIAutomation, accessible: ptr IAccessible, childId: int32, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.stdcall.} + IUIAutomation2* {.pure.} = object + lpVtbl*: ptr IUIAutomation2Vtbl + IUIAutomation2Vtbl* {.pure, inheritable.} = object of IUIAutomationVtbl + get_AutoSetFocus*: proc(self: ptr IUIAutomation2, autoSetFocus: ptr BOOL): HRESULT {.stdcall.} + put_AutoSetFocus*: proc(self: ptr IUIAutomation2, autoSetFocus: BOOL): HRESULT {.stdcall.} + get_ConnectionTimeout*: proc(self: ptr IUIAutomation2, timeout: ptr DWORD): HRESULT {.stdcall.} + put_ConnectionTimeout*: proc(self: ptr IUIAutomation2, timeout: DWORD): HRESULT {.stdcall.} + get_TransactionTimeout*: proc(self: ptr IUIAutomation2, timeout: ptr DWORD): HRESULT {.stdcall.} + put_TransactionTimeout*: proc(self: ptr IUIAutomation2, timeout: DWORD): HRESULT {.stdcall.} + IUIAutomation3* {.pure.} = object + lpVtbl*: ptr IUIAutomation3Vtbl + IUIAutomation3Vtbl* {.pure, inheritable.} = object of IUIAutomation2Vtbl + AddTextEditTextChangedEventHandler*: proc(self: ptr IUIAutomation3, element: ptr IUIAutomationElement, scope: TreeScope, textEditChangeType: TextEditChangeType, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.stdcall.} + RemoveTextEditTextChangedEventHandler*: proc(self: ptr IUIAutomation3, element: ptr IUIAutomationElement, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.stdcall.} + IUIAutomation4* {.pure.} = object + lpVtbl*: ptr IUIAutomation4Vtbl + IUIAutomation4Vtbl* {.pure, inheritable.} = object of IUIAutomation3Vtbl + AddChangesEventHandler*: proc(self: ptr IUIAutomation4, element: ptr IUIAutomationElement, scope: TreeScope, changeTypes: ptr int32, changesCount: int32, pCacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.stdcall.} + RemoveChangesEventHandler*: proc(self: ptr IUIAutomation4, element: ptr IUIAutomationElement, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.stdcall.} + IUIAutomation5* {.pure.} = object + lpVtbl*: ptr IUIAutomation5Vtbl + IUIAutomation5Vtbl* {.pure, inheritable.} = object of IUIAutomation4Vtbl + AddNotificationEventHandler*: proc(self: ptr IUIAutomation5, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.stdcall.} + RemoveNotificationEventHandler*: proc(self: ptr IUIAutomation5, element: ptr IUIAutomationElement, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.stdcall.} + IUIAutomation6* {.pure.} = object + lpVtbl*: ptr IUIAutomation6Vtbl + IUIAutomation6Vtbl* {.pure, inheritable.} = object of IUIAutomation5Vtbl + CreateEventHandlerGroup*: proc(self: ptr IUIAutomation6, handlerGroup: ptr ptr IUIAutomationEventHandlerGroup): HRESULT {.stdcall.} + AddEventHandlerGroup*: proc(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handlerGroup: ptr IUIAutomationEventHandlerGroup): HRESULT {.stdcall.} + RemoveEventHandlerGroup*: proc(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handlerGroup: ptr IUIAutomationEventHandlerGroup): HRESULT {.stdcall.} + get_ConnectionRecoveryBehavior*: proc(self: ptr IUIAutomation6, connectionRecoveryBehaviorOptions: ptr ConnectionRecoveryBehaviorOptions): HRESULT {.stdcall.} + put_ConnectionRecoveryBehavior*: proc(self: ptr IUIAutomation6, connectionRecoveryBehaviorOptions: ConnectionRecoveryBehaviorOptions): HRESULT {.stdcall.} + get_CoalesceEvents*: proc(self: ptr IUIAutomation6, coalesceEventsOptions: ptr CoalesceEventsOptions): HRESULT {.stdcall.} + put_CoalesceEvents*: proc(self: ptr IUIAutomation6, coalesceEventsOptions: CoalesceEventsOptions): HRESULT {.stdcall.} + AddActiveTextPositionChangedEventHandler*: proc(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.stdcall.} + RemoveActiveTextPositionChangedEventHandler*: proc(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.stdcall.} +proc UiaGetErrorDescription*(pDescription: ptr BSTR): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaHUiaNodeFromVariant*(pvar: ptr VARIANT, phnode: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaHPatternObjectFromVariant*(pvar: ptr VARIANT, phobj: ptr HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaHTextRangeFromVariant*(pvar: ptr VARIANT, phtextrange: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNodeRelease*(hnode: HUIANODE): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetPropertyValue*(hnode: HUIANODE, propertyId: PROPERTYID, pValue: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetPatternProvider*(hnode: HUIANODE, patternId: PATTERNID, phobj: ptr HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetRuntimeId*(hnode: HUIANODE, pruntimeId: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaSetFocus*(hnode: HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNavigate*(hnode: HUIANODE, direction: NavigateDirection, pCondition: ptr UiaCondition, pRequest: ptr UiaCacheRequest, ppRequestedData: ptr ptr SAFEARRAY, ppTreeStructure: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetUpdatedCache*(hnode: HUIANODE, pRequest: ptr UiaCacheRequest, normalizeState: NormalizeState, pNormalizeCondition: ptr UiaCondition, ppRequestedData: ptr ptr SAFEARRAY, ppTreeStructure: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaFind*(hnode: HUIANODE, pParams: ptr UiaFindParams, pRequest: ptr UiaCacheRequest, ppRequestedData: ptr ptr SAFEARRAY, ppOffsets: ptr ptr SAFEARRAY, ppTreeStructures: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNodeFromPoint*(x: float64, y: float64, pRequest: ptr UiaCacheRequest, ppRequestedData: ptr ptr SAFEARRAY, ppTreeStructure: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNodeFromFocus*(pRequest: ptr UiaCacheRequest, ppRequestedData: ptr ptr SAFEARRAY, ppTreeStructure: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNodeFromHandle*(hwnd: HWND, phnode: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaNodeFromProvider*(pProvider: ptr IRawElementProviderSimple, phnode: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetRootNode*(phnode: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRegisterProviderCallback*(pCallback: UiaProviderCallback): void {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaLookupId*(`type`: AutomationIdentifierType, pGuid: ptr GUID): int32 {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetReservedNotSupportedValue*(punkNotSupportedValue: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaGetReservedMixedAttributeValue*(punkMixedAttributeValue: ptr ptr IUnknown): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaClientsAreListening*(): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseAutomationPropertyChangedEvent*(pProvider: ptr IRawElementProviderSimple, id: PROPERTYID, oldValue: VARIANT, newValue: VARIANT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseAutomationEvent*(pProvider: ptr IRawElementProviderSimple, id: EVENTID): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseStructureChangedEvent*(pProvider: ptr IRawElementProviderSimple, structureChangeType: StructureChangeType, pRuntimeId: ptr int32, cRuntimeIdLen: int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseAsyncContentLoadedEvent*(pProvider: ptr IRawElementProviderSimple, asyncContentLoadedState: AsyncContentLoadedState, percentComplete: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseTextEditTextChangedEvent*(pProvider: ptr IRawElementProviderSimple, textEditChangeType: TextEditChangeType, pChangedData: ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseChangesEvent*(pProvider: ptr IRawElementProviderSimple, eventIdCount: int32, pUiaChanges: ptr UiaChangeInfo): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseNotificationEvent*(provider: ptr IRawElementProviderSimple, notificationKind: NotificationKind, notificationProcessing: NotificationProcessing, displayString: BSTR, activityId: BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRaiseActiveTextPositionChangedEvent*(provider: ptr IRawElementProviderSimple, textRange: ptr ITextRangeProvider): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaAddEvent*(hnode: HUIANODE, eventId: EVENTID, pCallback: UiaEventCallback, scope: TreeScope, pProperties: ptr PROPERTYID, cProperties: int32, pRequest: ptr UiaCacheRequest, phEvent: ptr HUIAEVENT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaRemoveEvent*(hEvent: HUIAEVENT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaEventAddWindow*(hEvent: HUIAEVENT, hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaEventRemoveWindow*(hEvent: HUIAEVENT, hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc DockPattern_SetDockPosition*(hobj: HUIAPATTERNOBJECT, dockPosition: DockPosition): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ExpandCollapsePattern_Collapse*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ExpandCollapsePattern_Expand*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc GridPattern_GetItem*(hobj: HUIAPATTERNOBJECT, row: int32, column: int32, pResult: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc InvokePattern_Invoke*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc MultipleViewPattern_GetViewName*(hobj: HUIAPATTERNOBJECT, viewId: int32, ppStr: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc MultipleViewPattern_SetCurrentView*(hobj: HUIAPATTERNOBJECT, viewId: int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc RangeValuePattern_SetValue*(hobj: HUIAPATTERNOBJECT, val: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ScrollItemPattern_ScrollIntoView*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ScrollPattern_Scroll*(hobj: HUIAPATTERNOBJECT, horizontalAmount: ScrollAmount, verticalAmount: ScrollAmount): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ScrollPattern_SetScrollPercent*(hobj: HUIAPATTERNOBJECT, horizontalPercent: float64, verticalPercent: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc SelectionItemPattern_AddToSelection*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc SelectionItemPattern_RemoveFromSelection*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc SelectionItemPattern_Select*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TogglePattern_Toggle*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TransformPattern_Move*(hobj: HUIAPATTERNOBJECT, x: float64, y: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TransformPattern_Resize*(hobj: HUIAPATTERNOBJECT, width: float64, height: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TransformPattern_Rotate*(hobj: HUIAPATTERNOBJECT, degrees: float64): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ValuePattern_SetValue*(hobj: HUIAPATTERNOBJECT, pVal: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc WindowPattern_Close*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc WindowPattern_SetWindowVisualState*(hobj: HUIAPATTERNOBJECT, state: WindowVisualState): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc WindowPattern_WaitForInputIdle*(hobj: HUIAPATTERNOBJECT, milliseconds: int32, pResult: ptr BOOL): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_GetSelection*(hobj: HUIAPATTERNOBJECT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_GetVisibleRanges*(hobj: HUIAPATTERNOBJECT, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_RangeFromChild*(hobj: HUIAPATTERNOBJECT, hnodeChild: HUIANODE, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_RangeFromPoint*(hobj: HUIAPATTERNOBJECT, point: UiaPoint, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_get_DocumentRange*(hobj: HUIAPATTERNOBJECT, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextPattern_get_SupportedTextSelection*(hobj: HUIAPATTERNOBJECT, pRetVal: ptr SupportedTextSelection): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_Clone*(hobj: HUIATEXTRANGE, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_Compare*(hobj: HUIATEXTRANGE, range: HUIATEXTRANGE, pRetVal: ptr BOOL): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_CompareEndpoints*(hobj: HUIATEXTRANGE, endpoint: TextPatternRangeEndpoint, targetRange: HUIATEXTRANGE, targetEndpoint: TextPatternRangeEndpoint, pRetVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_ExpandToEnclosingUnit*(hobj: HUIATEXTRANGE, unit: TextUnit): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_GetAttributeValue*(hobj: HUIATEXTRANGE, attributeId: TEXTATTRIBUTEID, pRetVal: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_FindAttribute*(hobj: HUIATEXTRANGE, attributeId: TEXTATTRIBUTEID, val: VARIANT, backward: BOOL, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_FindText*(hobj: HUIATEXTRANGE, text: BSTR, backward: BOOL, ignoreCase: BOOL, pRetVal: ptr HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_GetBoundingRectangles*(hobj: HUIATEXTRANGE, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_GetEnclosingElement*(hobj: HUIATEXTRANGE, pRetVal: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_GetText*(hobj: HUIATEXTRANGE, maxLength: int32, pRetVal: ptr BSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_Move*(hobj: HUIATEXTRANGE, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_MoveEndpointByUnit*(hobj: HUIATEXTRANGE, endpoint: TextPatternRangeEndpoint, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_MoveEndpointByRange*(hobj: HUIATEXTRANGE, endpoint: TextPatternRangeEndpoint, targetRange: HUIATEXTRANGE, targetEndpoint: TextPatternRangeEndpoint): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_Select*(hobj: HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_AddToSelection*(hobj: HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_RemoveFromSelection*(hobj: HUIATEXTRANGE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_ScrollIntoView*(hobj: HUIATEXTRANGE, alignToTop: BOOL): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc TextRange_GetChildren*(hobj: HUIATEXTRANGE, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc ItemContainerPattern_FindItemByProperty*(hobj: HUIAPATTERNOBJECT, hnodeStartAfter: HUIANODE, propertyId: PROPERTYID, value: VARIANT, pFound: ptr HUIANODE): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc LegacyIAccessiblePattern_Select*(hobj: HUIAPATTERNOBJECT, flagsSelect: int32): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc LegacyIAccessiblePattern_DoDefaultAction*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc LegacyIAccessiblePattern_SetValue*(hobj: HUIAPATTERNOBJECT, szValue: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc LegacyIAccessiblePattern_GetIAccessible*(hobj: HUIAPATTERNOBJECT, pAccessible: ptr ptr IAccessible): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc SynchronizedInputPattern_StartListening*(hobj: HUIAPATTERNOBJECT, inputType: SynchronizedInputType): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc SynchronizedInputPattern_Cancel*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc VirtualizedItemPattern_Realize*(hobj: HUIAPATTERNOBJECT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaPatternRelease*(hobj: HUIAPATTERNOBJECT): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaTextRangeRelease*(hobj: HUIATEXTRANGE): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaReturnRawElementProvider*(hwnd: HWND, wParam: WPARAM, lParam: LPARAM, el: ptr IRawElementProviderSimple): LRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaHostProviderFromHwnd*(hwnd: HWND, ppProvider: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaProviderForNonClient*(hwnd: HWND, idObject: int32, idChild: int32, ppProvider: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaIAccessibleFromProvider*(pProvider: ptr IRawElementProviderSimple, dwFlags: DWORD, ppAccessible: ptr ptr IAccessible, pvarChild: ptr VARIANT): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaProviderFromIAccessible*(pAccessible: ptr IAccessible, idChild: int32, dwFlags: DWORD, ppProvider: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaDisconnectAllProviders*(): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaDisconnectProvider*(pProvider: ptr IRawElementProviderSimple): HRESULT {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc UiaHasServerSideProvider*(hwnd: HWND): BOOL {.winapi, stdcall, dynlib: "uiautomationcore", importc.} +proc get_ProviderOptions*(self: ptr IRawElementProviderSimple, pRetVal: ptr ProviderOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ProviderOptions(self, pRetVal) +proc GetPatternProvider*(self: ptr IRawElementProviderSimple, patternId: PATTERNID, pRetVal: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPatternProvider(self, patternId, pRetVal) +proc GetPropertyValue*(self: ptr IRawElementProviderSimple, propertyId: PROPERTYID, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyValue(self, propertyId, pRetVal) +proc get_HostRawElementProvider*(self: ptr IRawElementProviderSimple, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HostRawElementProvider(self, pRetVal) +proc GetObjectForChild*(self: ptr IAccessibleEx, idChild: int32, pRetVal: ptr ptr IAccessibleEx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectForChild(self, idChild, pRetVal) +proc GetIAccessiblePair*(self: ptr IAccessibleEx, ppAcc: ptr ptr IAccessible, pidChild: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIAccessiblePair(self, ppAcc, pidChild) +proc GetRuntimeId*(self: ptr IAccessibleEx, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntimeId(self, pRetVal) +proc ConvertReturnedElement*(self: ptr IAccessibleEx, pIn: ptr IRawElementProviderSimple, ppRetValOut: ptr ptr IAccessibleEx): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ConvertReturnedElement(self, pIn, ppRetValOut) +proc ShowContextMenu*(self: ptr IRawElementProviderSimple2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContextMenu(self) +proc GetMetadataValue*(self: ptr IRawElementProviderSimple3, targetId: int32, metadataId: METADATAID, returnVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataValue(self, targetId, metadataId, returnVal) +proc ElementProviderFromPoint*(self: ptr IRawElementProviderFragmentRoot, x: float64, y: float64, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementProviderFromPoint(self, x, y, pRetVal) +proc GetFocus*(self: ptr IRawElementProviderFragmentRoot, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocus(self, pRetVal) +proc Navigate*(self: ptr IRawElementProviderFragment, direction: NavigateDirection, pRetVal: ptr ptr IRawElementProviderFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Navigate(self, direction, pRetVal) +proc GetRuntimeId*(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntimeId(self, pRetVal) +proc get_BoundingRectangle*(self: ptr IRawElementProviderFragment, pRetVal: ptr UiaRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BoundingRectangle(self, pRetVal) +proc GetEmbeddedFragmentRoots*(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEmbeddedFragmentRoots(self, pRetVal) +proc SetFocus*(self: ptr IRawElementProviderFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFocus(self) +proc get_FragmentRoot*(self: ptr IRawElementProviderFragment, pRetVal: ptr ptr IRawElementProviderFragmentRoot): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FragmentRoot(self, pRetVal) +proc AdviseEventAdded*(self: ptr IRawElementProviderAdviseEvents, eventId: EVENTID, propertyIDs: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AdviseEventAdded(self, eventId, propertyIDs) +proc AdviseEventRemoved*(self: ptr IRawElementProviderAdviseEvents, eventId: EVENTID, propertyIDs: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AdviseEventRemoved(self, eventId, propertyIDs) +proc GetOverrideProviderForHwnd*(self: ptr IRawElementProviderHwndOverride, hwnd: HWND, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetOverrideProviderForHwnd(self, hwnd, pRetVal) +proc AddAutomationPropertyChangedEvent*(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, id: PROPERTYID, newValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddAutomationPropertyChangedEvent(self, pProvider, id, newValue) +proc AddAutomationEvent*(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, id: EVENTID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddAutomationEvent(self, pProvider, id) +proc AddStructureChangedEvent*(self: ptr IProxyProviderWinEventSink, pProvider: ptr IRawElementProviderSimple, structureChangeType: StructureChangeType, runtimeId: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddStructureChangedEvent(self, pProvider, structureChangeType, runtimeId) +proc RespondToWinEvent*(self: ptr IProxyProviderWinEventHandler, idWinEvent: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG, pSink: ptr IProxyProviderWinEventSink): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RespondToWinEvent(self, idWinEvent, hwnd, idObject, idChild, pSink) +proc GetAdjacentFragment*(self: ptr IRawElementProviderWindowlessSite, direction: NavigateDirection, ppParent: ptr ptr IRawElementProviderFragment): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAdjacentFragment(self, direction, ppParent) +proc GetRuntimeIdPrefix*(self: ptr IRawElementProviderWindowlessSite, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntimeIdPrefix(self, pRetVal) +proc GetEmbeddedFragmentRoots*(self: ptr IAccessibleHostingElementProviders, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEmbeddedFragmentRoots(self, pRetVal) +proc GetObjectIdForProvider*(self: ptr IAccessibleHostingElementProviders, pProvider: ptr IRawElementProviderSimple, pidObject: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetObjectIdForProvider(self, pProvider, pidObject) +proc GetEmbeddedAccessibles*(self: ptr IRawElementProviderHostingAccessibles, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEmbeddedAccessibles(self, pRetVal) +proc SetDockPosition*(self: ptr IDockProvider, dockPosition: DockPosition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDockPosition(self, dockPosition) +proc get_DockPosition*(self: ptr IDockProvider, pRetVal: ptr DockPosition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DockPosition(self, pRetVal) +proc Expand*(self: ptr IExpandCollapseProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Expand(self) +proc Collapse*(self: ptr IExpandCollapseProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Collapse(self) +proc get_ExpandCollapseState*(self: ptr IExpandCollapseProvider, pRetVal: ptr ExpandCollapseState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ExpandCollapseState(self, pRetVal) +proc GetItem*(self: ptr IGridProvider, row: int32, column: int32, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItem(self, row, column, pRetVal) +proc get_RowCount*(self: ptr IGridProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RowCount(self, pRetVal) +proc get_ColumnCount*(self: ptr IGridProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ColumnCount(self, pRetVal) +proc get_Row*(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Row(self, pRetVal) +proc get_Column*(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Column(self, pRetVal) +proc get_RowSpan*(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RowSpan(self, pRetVal) +proc get_ColumnSpan*(self: ptr IGridItemProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ColumnSpan(self, pRetVal) +proc get_ContainingGrid*(self: ptr IGridItemProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ContainingGrid(self, pRetVal) +proc Invoke*(self: ptr IInvokeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self) +proc GetViewName*(self: ptr IMultipleViewProvider, viewId: int32, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewName(self, viewId, pRetVal) +proc SetCurrentView*(self: ptr IMultipleViewProvider, viewId: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCurrentView(self, viewId) +proc get_CurrentView*(self: ptr IMultipleViewProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentView(self, pRetVal) +proc GetSupportedViews*(self: ptr IMultipleViewProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSupportedViews(self, pRetVal) +proc SetValue*(self: ptr IRangeValueProvider, val: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, val) +proc get_Value*(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Value(self, pRetVal) +proc get_IsReadOnly*(self: ptr IRangeValueProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsReadOnly(self, pRetVal) +proc get_Maximum*(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Maximum(self, pRetVal) +proc get_Minimum*(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Minimum(self, pRetVal) +proc get_LargeChange*(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_LargeChange(self, pRetVal) +proc get_SmallChange*(self: ptr IRangeValueProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SmallChange(self, pRetVal) +proc ScrollIntoView*(self: ptr IScrollItemProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self) +proc GetSelection*(self: ptr ISelectionProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, pRetVal) +proc get_CanSelectMultiple*(self: ptr ISelectionProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanSelectMultiple(self, pRetVal) +proc get_IsSelectionRequired*(self: ptr ISelectionProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSelectionRequired(self, pRetVal) +proc get_FirstSelectedItem*(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FirstSelectedItem(self, retVal) +proc get_LastSelectedItem*(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_LastSelectedItem(self, retVal) +proc get_CurrentSelectedItem*(self: ptr ISelectionProvider2, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentSelectedItem(self, retVal) +proc get_ItemCount*(self: ptr ISelectionProvider2, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ItemCount(self, retVal) +proc Scroll*(self: ptr IScrollProvider, horizontalAmount: ScrollAmount, verticalAmount: ScrollAmount): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Scroll(self, horizontalAmount, verticalAmount) +proc SetScrollPercent*(self: ptr IScrollProvider, horizontalPercent: float64, verticalPercent: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScrollPercent(self, horizontalPercent, verticalPercent) +proc get_HorizontalScrollPercent*(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HorizontalScrollPercent(self, pRetVal) +proc get_VerticalScrollPercent*(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_VerticalScrollPercent(self, pRetVal) +proc get_HorizontalViewSize*(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HorizontalViewSize(self, pRetVal) +proc get_VerticalViewSize*(self: ptr IScrollProvider, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_VerticalViewSize(self, pRetVal) +proc get_HorizontallyScrollable*(self: ptr IScrollProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_HorizontallyScrollable(self, pRetVal) +proc get_VerticallyScrollable*(self: ptr IScrollProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_VerticallyScrollable(self, pRetVal) +proc Select*(self: ptr ISelectionItemProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self) +proc AddToSelection*(self: ptr ISelectionItemProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToSelection(self) +proc RemoveFromSelection*(self: ptr ISelectionItemProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFromSelection(self) +proc get_IsSelected*(self: ptr ISelectionItemProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsSelected(self, pRetVal) +proc get_SelectionContainer*(self: ptr ISelectionItemProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SelectionContainer(self, pRetVal) +proc StartListening*(self: ptr ISynchronizedInputProvider, inputType: SynchronizedInputType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartListening(self, inputType) +proc Cancel*(self: ptr ISynchronizedInputProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cancel(self) +proc GetRowHeaders*(self: ptr ITableProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRowHeaders(self, pRetVal) +proc GetColumnHeaders*(self: ptr ITableProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnHeaders(self, pRetVal) +proc get_RowOrColumnMajor*(self: ptr ITableProvider, pRetVal: ptr RowOrColumnMajor): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RowOrColumnMajor(self, pRetVal) +proc GetRowHeaderItems*(self: ptr ITableItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRowHeaderItems(self, pRetVal) +proc GetColumnHeaderItems*(self: ptr ITableItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColumnHeaderItems(self, pRetVal) +proc Toggle*(self: ptr IToggleProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Toggle(self) +proc get_ToggleState*(self: ptr IToggleProvider, pRetVal: ptr ToggleState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ToggleState(self, pRetVal) +proc Move*(self: ptr ITransformProvider, x: float64, y: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, x, y) +proc Resize*(self: ptr ITransformProvider, width: float64, height: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resize(self, width, height) +proc Rotate*(self: ptr ITransformProvider, degrees: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Rotate(self, degrees) +proc get_CanMove*(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanMove(self, pRetVal) +proc get_CanResize*(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanResize(self, pRetVal) +proc get_CanRotate*(self: ptr ITransformProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanRotate(self, pRetVal) +proc SetValue*(self: ptr IValueProvider, val: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, val) +proc get_Value*(self: ptr IValueProvider, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Value(self, pRetVal) +proc get_IsReadOnly*(self: ptr IValueProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsReadOnly(self, pRetVal) +proc SetVisualState*(self: ptr IWindowProvider, state: WindowVisualState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetVisualState(self, state) +proc Close*(self: ptr IWindowProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self) +proc WaitForInputIdle*(self: ptr IWindowProvider, milliseconds: int32, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WaitForInputIdle(self, milliseconds, pRetVal) +proc get_CanMaximize*(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanMaximize(self, pRetVal) +proc get_CanMinimize*(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanMinimize(self, pRetVal) +proc get_IsModal*(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsModal(self, pRetVal) +proc get_WindowVisualState*(self: ptr IWindowProvider, pRetVal: ptr WindowVisualState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_WindowVisualState(self, pRetVal) +proc get_WindowInteractionState*(self: ptr IWindowProvider, pRetVal: ptr WindowInteractionState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_WindowInteractionState(self, pRetVal) +proc get_IsTopmost*(self: ptr IWindowProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsTopmost(self, pRetVal) +proc Select*(self: ptr ILegacyIAccessibleProvider, flagsSelect: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self, flagsSelect) +proc DoDefaultAction*(self: ptr ILegacyIAccessibleProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoDefaultAction(self) +proc SetValue*(self: ptr ILegacyIAccessibleProvider, szValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, szValue) +proc GetIAccessible*(self: ptr ILegacyIAccessibleProvider, ppAccessible: ptr ptr IAccessible): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIAccessible(self, ppAccessible) +proc get_ChildId*(self: ptr ILegacyIAccessibleProvider, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ChildId(self, pRetVal) +proc get_Name*(self: ptr ILegacyIAccessibleProvider, pszName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Name(self, pszName) +proc get_Value*(self: ptr ILegacyIAccessibleProvider, pszValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Value(self, pszValue) +proc get_Description*(self: ptr ILegacyIAccessibleProvider, pszDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Description(self, pszDescription) +proc get_Role*(self: ptr ILegacyIAccessibleProvider, pdwRole: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Role(self, pdwRole) +proc get_State*(self: ptr ILegacyIAccessibleProvider, pdwState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_State(self, pdwState) +proc get_Help*(self: ptr ILegacyIAccessibleProvider, pszHelp: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Help(self, pszHelp) +proc get_KeyboardShortcut*(self: ptr ILegacyIAccessibleProvider, pszKeyboardShortcut: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_KeyboardShortcut(self, pszKeyboardShortcut) +proc GetSelection*(self: ptr ILegacyIAccessibleProvider, pvarSelectedChildren: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, pvarSelectedChildren) +proc get_DefaultAction*(self: ptr ILegacyIAccessibleProvider, pszDefaultAction: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DefaultAction(self, pszDefaultAction) +proc FindItemByProperty*(self: ptr IItemContainerProvider, pStartAfter: ptr IRawElementProviderSimple, propertyId: PROPERTYID, value: VARIANT, pFound: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindItemByProperty(self, pStartAfter, propertyId, value, pFound) +proc Realize*(self: ptr IVirtualizedItemProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Realize(self) +proc GetUnderlyingObjectModel*(self: ptr IObjectModelProvider, ppUnknown: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUnderlyingObjectModel(self, ppUnknown) +proc get_AnnotationTypeId*(self: ptr IAnnotationProvider, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AnnotationTypeId(self, retVal) +proc get_AnnotationTypeName*(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AnnotationTypeName(self, retVal) +proc get_Author*(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Author(self, retVal) +proc get_DateTime*(self: ptr IAnnotationProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DateTime(self, retVal) +proc get_Target*(self: ptr IAnnotationProvider, retVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Target(self, retVal) +proc get_StyleId*(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StyleId(self, retVal) +proc get_StyleName*(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_StyleName(self, retVal) +proc get_FillColor*(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FillColor(self, retVal) +proc get_FillPatternStyle*(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FillPatternStyle(self, retVal) +proc get_Shape*(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Shape(self, retVal) +proc get_FillPatternColor*(self: ptr IStylesProvider, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_FillPatternColor(self, retVal) +proc get_ExtendedProperties*(self: ptr IStylesProvider, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ExtendedProperties(self, retVal) +proc GetItemByName*(self: ptr ISpreadsheetProvider, name: LPCWSTR, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemByName(self, name, pRetVal) +proc get_Formula*(self: ptr ISpreadsheetItemProvider, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Formula(self, pRetVal) +proc GetAnnotationObjects*(self: ptr ISpreadsheetItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAnnotationObjects(self, pRetVal) +proc GetAnnotationTypes*(self: ptr ISpreadsheetItemProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAnnotationTypes(self, pRetVal) +proc Zoom*(self: ptr ITransformProvider2, zoom: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Zoom(self, zoom) +proc get_CanZoom*(self: ptr ITransformProvider2, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanZoom(self, pRetVal) +proc get_ZoomLevel*(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ZoomLevel(self, pRetVal) +proc get_ZoomMinimum*(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ZoomMinimum(self, pRetVal) +proc get_ZoomMaximum*(self: ptr ITransformProvider2, pRetVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ZoomMaximum(self, pRetVal) +proc ZoomByUnit*(self: ptr ITransformProvider2, zoomUnit: ZoomUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ZoomByUnit(self, zoomUnit) +proc get_IsGrabbed*(self: ptr IDragProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_IsGrabbed(self, pRetVal) +proc get_DropEffect*(self: ptr IDragProvider, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DropEffect(self, pRetVal) +proc get_DropEffects*(self: ptr IDragProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DropEffects(self, pRetVal) +proc GetGrabbedItems*(self: ptr IDragProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetGrabbedItems(self, pRetVal) +proc get_DropTargetEffect*(self: ptr IDropTargetProvider, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DropTargetEffect(self, pRetVal) +proc get_DropTargetEffects*(self: ptr IDropTargetProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DropTargetEffects(self, pRetVal) +proc Clone*(self: ptr ITextRangeProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, pRetVal) +proc Compare*(self: ptr ITextRangeProvider, range: ptr ITextRangeProvider, pRetVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Compare(self, range, pRetVal) +proc CompareEndpoints*(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, targetRange: ptr ITextRangeProvider, targetEndpoint: TextPatternRangeEndpoint, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareEndpoints(self, endpoint, targetRange, targetEndpoint, pRetVal) +proc ExpandToEnclosingUnit*(self: ptr ITextRangeProvider, unit: TextUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExpandToEnclosingUnit(self, unit) +proc FindAttribute*(self: ptr ITextRangeProvider, attributeId: TEXTATTRIBUTEID, val: VARIANT, backward: BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAttribute(self, attributeId, val, backward, pRetVal) +proc FindText*(self: ptr ITextRangeProvider, text: BSTR, backward: BOOL, ignoreCase: BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindText(self, text, backward, ignoreCase, pRetVal) +proc GetAttributeValue*(self: ptr ITextRangeProvider, attributeId: TEXTATTRIBUTEID, pRetVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributeValue(self, attributeId, pRetVal) +proc GetBoundingRectangles*(self: ptr ITextRangeProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBoundingRectangles(self, pRetVal) +proc GetEnclosingElement*(self: ptr ITextRangeProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnclosingElement(self, pRetVal) +proc GetText*(self: ptr ITextRangeProvider, maxLength: int32, pRetVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetText(self, maxLength, pRetVal) +proc Move*(self: ptr ITextRangeProvider, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, unit, count, pRetVal) +proc MoveEndpointByUnit*(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, unit: TextUnit, count: int32, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveEndpointByUnit(self, endpoint, unit, count, pRetVal) +proc MoveEndpointByRange*(self: ptr ITextRangeProvider, endpoint: TextPatternRangeEndpoint, targetRange: ptr ITextRangeProvider, targetEndpoint: TextPatternRangeEndpoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveEndpointByRange(self, endpoint, targetRange, targetEndpoint) +proc Select*(self: ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self) +proc AddToSelection*(self: ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToSelection(self) +proc RemoveFromSelection*(self: ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFromSelection(self) +proc ScrollIntoView*(self: ptr ITextRangeProvider, alignToTop: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self, alignToTop) +proc GetChildren*(self: ptr ITextRangeProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildren(self, pRetVal) +proc GetSelection*(self: ptr ITextProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, pRetVal) +proc GetVisibleRanges*(self: ptr ITextProvider, pRetVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVisibleRanges(self, pRetVal) +proc RangeFromChild*(self: ptr ITextProvider, childElement: ptr IRawElementProviderSimple, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromChild(self, childElement, pRetVal) +proc RangeFromPoint*(self: ptr ITextProvider, point: UiaPoint, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromPoint(self, point, pRetVal) +proc get_DocumentRange*(self: ptr ITextProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DocumentRange(self, pRetVal) +proc get_SupportedTextSelection*(self: ptr ITextProvider, pRetVal: ptr SupportedTextSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SupportedTextSelection(self, pRetVal) +proc RangeFromAnnotation*(self: ptr ITextProvider2, annotationElement: ptr IRawElementProviderSimple, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromAnnotation(self, annotationElement, pRetVal) +proc GetCaretRange*(self: ptr ITextProvider2, isActive: ptr BOOL, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCaretRange(self, isActive, pRetVal) +proc GetActiveComposition*(self: ptr ITextEditProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetActiveComposition(self, pRetVal) +proc GetConversionTarget*(self: ptr ITextEditProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionTarget(self, pRetVal) +proc ShowContextMenu*(self: ptr ITextRangeProvider2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContextMenu(self) +proc get_TextContainer*(self: ptr ITextChildProvider, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextContainer(self, pRetVal) +proc get_TextRange*(self: ptr ITextChildProvider, pRetVal: ptr ptr ITextRangeProvider): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRange(self, pRetVal) +proc Navigate*(self: ptr ICustomNavigationProvider, direction: NavigateDirection, pRetVal: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Navigate(self, direction, pRetVal) +proc GetProperty*(self: ptr IUIAutomationPatternInstance, index: UINT, cached: BOOL, `type`: UIAutomationType, pPtr: pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProperty(self, index, cached, `type`, pPtr) +proc CallMethod*(self: ptr IUIAutomationPatternInstance, index: UINT, pParams: ptr UIAutomationParameter, cParams: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CallMethod(self, index, pParams, cParams) +proc CreateClientWrapper*(self: ptr IUIAutomationPatternHandler, pPatternInstance: ptr IUIAutomationPatternInstance, pClientWrapper: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateClientWrapper(self, pPatternInstance, pClientWrapper) +proc Dispatch*(self: ptr IUIAutomationPatternHandler, pTarget: ptr IUnknown, index: UINT, pParams: ptr UIAutomationParameter, cParams: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Dispatch(self, pTarget, index, pParams, cParams) +proc RegisterProperty*(self: ptr IUIAutomationRegistrar, property: ptr UIAutomationPropertyInfo, propertyId: ptr PROPERTYID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterProperty(self, property, propertyId) +proc RegisterEvent*(self: ptr IUIAutomationRegistrar, event: ptr UIAutomationEventInfo, eventId: ptr EVENTID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterEvent(self, event, eventId) +proc RegisterPattern*(self: ptr IUIAutomationRegistrar, pattern: ptr UIAutomationPatternInfo, pPatternId: ptr PATTERNID, pPatternAvailablePropertyId: ptr PROPERTYID, propertyIdCount: UINT, pPropertyIds: ptr PROPERTYID, eventIdCount: UINT, pEventIds: ptr EVENTID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RegisterPattern(self, pattern, pPatternId, pPatternAvailablePropertyId, propertyIdCount, pPropertyIds, eventIdCount, pEventIds) +proc SetFocus*(self: ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFocus(self) +proc GetRuntimeId*(self: ptr IUIAutomationElement, runtimeId: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRuntimeId(self, runtimeId) +proc FindFirst*(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, found: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFirst(self, scope, condition, found) +proc FindAll*(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, found: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAll(self, scope, condition, found) +proc FindFirstBuildCache*(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, found: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFirstBuildCache(self, scope, condition, cacheRequest, found) +proc FindAllBuildCache*(self: ptr IUIAutomationElement, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, found: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAllBuildCache(self, scope, condition, cacheRequest, found) +proc BuildUpdatedCache*(self: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, updatedElement: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.BuildUpdatedCache(self, cacheRequest, updatedElement) +proc GetCurrentPropertyValue*(self: ptr IUIAutomationElement, propertyId: PROPERTYID, retVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPropertyValue(self, propertyId, retVal) +proc GetCurrentPropertyValueEx*(self: ptr IUIAutomationElement, propertyId: PROPERTYID, ignoreDefaultValue: BOOL, retVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPropertyValueEx(self, propertyId, ignoreDefaultValue, retVal) +proc GetCachedPropertyValue*(self: ptr IUIAutomationElement, propertyId: PROPERTYID, retVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedPropertyValue(self, propertyId, retVal) +proc GetCachedPropertyValueEx*(self: ptr IUIAutomationElement, propertyId: PROPERTYID, ignoreDefaultValue: BOOL, retVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedPropertyValueEx(self, propertyId, ignoreDefaultValue, retVal) +proc GetCurrentPatternAs*(self: ptr IUIAutomationElement, patternId: PATTERNID, riid: REFIID, patternObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPatternAs(self, patternId, riid, patternObject) +proc GetCachedPatternAs*(self: ptr IUIAutomationElement, patternId: PATTERNID, riid: REFIID, patternObject: ptr pointer): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedPatternAs(self, patternId, riid, patternObject) +proc GetCurrentPattern*(self: ptr IUIAutomationElement, patternId: PATTERNID, patternObject: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentPattern(self, patternId, patternObject) +proc GetCachedPattern*(self: ptr IUIAutomationElement, patternId: PATTERNID, patternObject: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedPattern(self, patternId, patternObject) +proc GetCachedParent*(self: ptr IUIAutomationElement, parent: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedParent(self, parent) +proc GetCachedChildren*(self: ptr IUIAutomationElement, children: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedChildren(self, children) +proc get_CurrentProcessId*(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentProcessId(self, retVal) +proc get_CurrentControlType*(self: ptr IUIAutomationElement, retVal: ptr CONTROLTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentControlType(self, retVal) +proc get_CurrentLocalizedControlType*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLocalizedControlType(self, retVal) +proc get_CurrentName*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentName(self, retVal) +proc get_CurrentAcceleratorKey*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAcceleratorKey(self, retVal) +proc get_CurrentAccessKey*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAccessKey(self, retVal) +proc get_CurrentHasKeyboardFocus*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHasKeyboardFocus(self, retVal) +proc get_CurrentIsKeyboardFocusable*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsKeyboardFocusable(self, retVal) +proc get_CurrentIsEnabled*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsEnabled(self, retVal) +proc get_CurrentAutomationId*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAutomationId(self, retVal) +proc get_CurrentClassName*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentClassName(self, retVal) +proc get_CurrentHelpText*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHelpText(self, retVal) +proc get_CurrentCulture*(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCulture(self, retVal) +proc get_CurrentIsControlElement*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsControlElement(self, retVal) +proc get_CurrentIsContentElement*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsContentElement(self, retVal) +proc get_CurrentIsPassword*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsPassword(self, retVal) +proc get_CurrentNativeWindowHandle*(self: ptr IUIAutomationElement, retVal: ptr UIA_HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentNativeWindowHandle(self, retVal) +proc get_CurrentItemType*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentItemType(self, retVal) +proc get_CurrentIsOffscreen*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsOffscreen(self, retVal) +proc get_CurrentOrientation*(self: ptr IUIAutomationElement, retVal: ptr OrientationType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentOrientation(self, retVal) +proc get_CurrentFrameworkId*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFrameworkId(self, retVal) +proc get_CurrentIsRequiredForForm*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsRequiredForForm(self, retVal) +proc get_CurrentItemStatus*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentItemStatus(self, retVal) +proc get_CurrentBoundingRectangle*(self: ptr IUIAutomationElement, retVal: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentBoundingRectangle(self, retVal) +proc get_CurrentLabeledBy*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLabeledBy(self, retVal) +proc get_CurrentAriaRole*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAriaRole(self, retVal) +proc get_CurrentAriaProperties*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAriaProperties(self, retVal) +proc get_CurrentIsDataValidForForm*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsDataValidForForm(self, retVal) +proc get_CurrentControllerFor*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentControllerFor(self, retVal) +proc get_CurrentDescribedBy*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDescribedBy(self, retVal) +proc get_CurrentFlowsTo*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFlowsTo(self, retVal) +proc get_CurrentProviderDescription*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentProviderDescription(self, retVal) +proc get_CachedProcessId*(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedProcessId(self, retVal) +proc get_CachedControlType*(self: ptr IUIAutomationElement, retVal: ptr CONTROLTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedControlType(self, retVal) +proc get_CachedLocalizedControlType*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLocalizedControlType(self, retVal) +proc get_CachedName*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedName(self, retVal) +proc get_CachedAcceleratorKey*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAcceleratorKey(self, retVal) +proc get_CachedAccessKey*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAccessKey(self, retVal) +proc get_CachedHasKeyboardFocus*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHasKeyboardFocus(self, retVal) +proc get_CachedIsKeyboardFocusable*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsKeyboardFocusable(self, retVal) +proc get_CachedIsEnabled*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsEnabled(self, retVal) +proc get_CachedAutomationId*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAutomationId(self, retVal) +proc get_CachedClassName*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedClassName(self, retVal) +proc get_CachedHelpText*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHelpText(self, retVal) +proc get_CachedCulture*(self: ptr IUIAutomationElement, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCulture(self, retVal) +proc get_CachedIsControlElement*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsControlElement(self, retVal) +proc get_CachedIsContentElement*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsContentElement(self, retVal) +proc get_CachedIsPassword*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsPassword(self, retVal) +proc get_CachedNativeWindowHandle*(self: ptr IUIAutomationElement, retVal: ptr UIA_HWND): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedNativeWindowHandle(self, retVal) +proc get_CachedItemType*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedItemType(self, retVal) +proc get_CachedIsOffscreen*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsOffscreen(self, retVal) +proc get_CachedOrientation*(self: ptr IUIAutomationElement, retVal: ptr OrientationType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedOrientation(self, retVal) +proc get_CachedFrameworkId*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFrameworkId(self, retVal) +proc get_CachedIsRequiredForForm*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsRequiredForForm(self, retVal) +proc get_CachedItemStatus*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedItemStatus(self, retVal) +proc get_CachedBoundingRectangle*(self: ptr IUIAutomationElement, retVal: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedBoundingRectangle(self, retVal) +proc get_CachedLabeledBy*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLabeledBy(self, retVal) +proc get_CachedAriaRole*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAriaRole(self, retVal) +proc get_CachedAriaProperties*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAriaProperties(self, retVal) +proc get_CachedIsDataValidForForm*(self: ptr IUIAutomationElement, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsDataValidForForm(self, retVal) +proc get_CachedControllerFor*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedControllerFor(self, retVal) +proc get_CachedDescribedBy*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDescribedBy(self, retVal) +proc get_CachedFlowsTo*(self: ptr IUIAutomationElement, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFlowsTo(self, retVal) +proc get_CachedProviderDescription*(self: ptr IUIAutomationElement, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedProviderDescription(self, retVal) +proc GetClickablePoint*(self: ptr IUIAutomationElement, clickable: ptr POINT, gotClickable: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetClickablePoint(self, clickable, gotClickable) +proc get_Length*(self: ptr IUIAutomationElementArray, length: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Length(self, length) +proc GetElement*(self: ptr IUIAutomationElementArray, index: int32, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElement(self, index, element) +proc get_BooleanValue*(self: ptr IUIAutomationBoolCondition, boolVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_BooleanValue(self, boolVal) +proc get_PropertyId*(self: ptr IUIAutomationPropertyCondition, propertyId: ptr PROPERTYID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_PropertyId(self, propertyId) +proc get_PropertyValue*(self: ptr IUIAutomationPropertyCondition, propertyValue: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_PropertyValue(self, propertyValue) +proc get_PropertyConditionFlags*(self: ptr IUIAutomationPropertyCondition, flags: ptr PropertyConditionFlags): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_PropertyConditionFlags(self, flags) +proc get_ChildCount*(self: ptr IUIAutomationAndCondition, childCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ChildCount(self, childCount) +proc GetChildrenAsNativeArray*(self: ptr IUIAutomationAndCondition, childArray: ptr ptr ptr IUIAutomationCondition, childArrayCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildrenAsNativeArray(self, childArray, childArrayCount) +proc GetChildren*(self: ptr IUIAutomationAndCondition, childArray: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildren(self, childArray) +proc get_ChildCount*(self: ptr IUIAutomationOrCondition, childCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ChildCount(self, childCount) +proc GetChildrenAsNativeArray*(self: ptr IUIAutomationOrCondition, childArray: ptr ptr ptr IUIAutomationCondition, childArrayCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildrenAsNativeArray(self, childArray, childArrayCount) +proc GetChildren*(self: ptr IUIAutomationOrCondition, childArray: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildren(self, childArray) +proc GetChild*(self: ptr IUIAutomationNotCondition, condition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChild(self, condition) +proc AddProperty*(self: ptr IUIAutomationCacheRequest, propertyId: PROPERTYID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddProperty(self, propertyId) +proc AddPattern*(self: ptr IUIAutomationCacheRequest, patternId: PATTERNID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPattern(self, patternId) +proc Clone*(self: ptr IUIAutomationCacheRequest, clonedRequest: ptr ptr IUIAutomationCacheRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, clonedRequest) +proc get_TreeScope*(self: ptr IUIAutomationCacheRequest, scope: ptr TreeScope): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TreeScope(self, scope) +proc put_TreeScope*(self: ptr IUIAutomationCacheRequest, scope: TreeScope): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_TreeScope(self, scope) +proc get_TreeFilter*(self: ptr IUIAutomationCacheRequest, filter: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TreeFilter(self, filter) +proc put_TreeFilter*(self: ptr IUIAutomationCacheRequest, filter: ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_TreeFilter(self, filter) +proc get_AutomationElementMode*(self: ptr IUIAutomationCacheRequest, mode: ptr AutomationElementMode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AutomationElementMode(self, mode) +proc put_AutomationElementMode*(self: ptr IUIAutomationCacheRequest, mode: AutomationElementMode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_AutomationElementMode(self, mode) +proc GetParentElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, parent: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParentElement(self, element, parent) +proc GetFirstChildElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, first: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFirstChildElement(self, element, first) +proc GetLastChildElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, last: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastChildElement(self, element, last) +proc GetNextSiblingElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, next: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextSiblingElement(self, element, next) +proc GetPreviousSiblingElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, previous: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPreviousSiblingElement(self, element, previous) +proc NormalizeElement*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, normalized: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NormalizeElement(self, element, normalized) +proc GetParentElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, parent: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetParentElementBuildCache(self, element, cacheRequest, parent) +proc GetFirstChildElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, first: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFirstChildElementBuildCache(self, element, cacheRequest, first) +proc GetLastChildElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, last: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLastChildElementBuildCache(self, element, cacheRequest, last) +proc GetNextSiblingElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, next: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNextSiblingElementBuildCache(self, element, cacheRequest, next) +proc GetPreviousSiblingElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, previous: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPreviousSiblingElementBuildCache(self, element, cacheRequest, previous) +proc NormalizeElementBuildCache*(self: ptr IUIAutomationTreeWalker, element: ptr IUIAutomationElement, cacheRequest: ptr IUIAutomationCacheRequest, normalized: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.NormalizeElementBuildCache(self, element, cacheRequest, normalized) +proc get_Condition*(self: ptr IUIAutomationTreeWalker, condition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Condition(self, condition) +proc HandleAutomationEvent*(self: ptr IUIAutomationEventHandler, sender: ptr IUIAutomationElement, eventId: EVENTID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleAutomationEvent(self, sender, eventId) +proc HandlePropertyChangedEvent*(self: ptr IUIAutomationPropertyChangedEventHandler, sender: ptr IUIAutomationElement, propertyId: PROPERTYID, newValue: VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandlePropertyChangedEvent(self, sender, propertyId, newValue) +proc HandleStructureChangedEvent*(self: ptr IUIAutomationStructureChangedEventHandler, sender: ptr IUIAutomationElement, changeType: StructureChangeType, runtimeId: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleStructureChangedEvent(self, sender, changeType, runtimeId) +proc HandleFocusChangedEvent*(self: ptr IUIAutomationFocusChangedEventHandler, sender: ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleFocusChangedEvent(self, sender) +proc HandleTextEditTextChangedEvent*(self: ptr IUIAutomationTextEditTextChangedEventHandler, sender: ptr IUIAutomationElement, textEditChangeType: TextEditChangeType, eventStrings: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleTextEditTextChangedEvent(self, sender, textEditChangeType, eventStrings) +proc HandleChangesEvent*(self: ptr IUIAutomationChangesEventHandler, sender: ptr IUIAutomationElement, uiaChanges: ptr UiaChangeInfo, changesCount: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleChangesEvent(self, sender, uiaChanges, changesCount) +proc HandleNotificationEvent*(self: ptr IUIAutomationNotificationEventHandler, sender: ptr IUIAutomationElement, notificationKind: NotificationKind, notificationProcessing: NotificationProcessing, displayString: BSTR, activityId: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleNotificationEvent(self, sender, notificationKind, notificationProcessing, displayString, activityId) +proc Invoke*(self: ptr IUIAutomationInvokePattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Invoke(self) +proc SetDockPosition*(self: ptr IUIAutomationDockPattern, dockPos: DockPosition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetDockPosition(self, dockPos) +proc get_CurrentDockPosition*(self: ptr IUIAutomationDockPattern, retVal: ptr DockPosition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDockPosition(self, retVal) +proc get_CachedDockPosition*(self: ptr IUIAutomationDockPattern, retVal: ptr DockPosition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDockPosition(self, retVal) +proc Expand*(self: ptr IUIAutomationExpandCollapsePattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Expand(self) +proc Collapse*(self: ptr IUIAutomationExpandCollapsePattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Collapse(self) +proc get_CurrentExpandCollapseState*(self: ptr IUIAutomationExpandCollapsePattern, retVal: ptr ExpandCollapseState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentExpandCollapseState(self, retVal) +proc get_CachedExpandCollapseState*(self: ptr IUIAutomationExpandCollapsePattern, retVal: ptr ExpandCollapseState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedExpandCollapseState(self, retVal) +proc GetItem*(self: ptr IUIAutomationGridPattern, row: int32, column: int32, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItem(self, row, column, element) +proc get_CurrentRowCount*(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentRowCount(self, retVal) +proc get_CurrentColumnCount*(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentColumnCount(self, retVal) +proc get_CachedRowCount*(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedRowCount(self, retVal) +proc get_CachedColumnCount*(self: ptr IUIAutomationGridPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedColumnCount(self, retVal) +proc get_CurrentContainingGrid*(self: ptr IUIAutomationGridItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentContainingGrid(self, retVal) +proc get_CurrentRow*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentRow(self, retVal) +proc get_CurrentColumn*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentColumn(self, retVal) +proc get_CurrentRowSpan*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentRowSpan(self, retVal) +proc get_CurrentColumnSpan*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentColumnSpan(self, retVal) +proc get_CachedContainingGrid*(self: ptr IUIAutomationGridItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedContainingGrid(self, retVal) +proc get_CachedRow*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedRow(self, retVal) +proc get_CachedColumn*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedColumn(self, retVal) +proc get_CachedRowSpan*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedRowSpan(self, retVal) +proc get_CachedColumnSpan*(self: ptr IUIAutomationGridItemPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedColumnSpan(self, retVal) +proc GetViewName*(self: ptr IUIAutomationMultipleViewPattern, view: int32, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetViewName(self, view, name) +proc SetCurrentView*(self: ptr IUIAutomationMultipleViewPattern, view: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetCurrentView(self, view) +proc get_CurrentCurrentView*(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCurrentView(self, retVal) +proc GetCurrentSupportedViews*(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSupportedViews(self, retVal) +proc get_CachedCurrentView*(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCurrentView(self, retVal) +proc GetCachedSupportedViews*(self: ptr IUIAutomationMultipleViewPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedSupportedViews(self, retVal) +proc GetUnderlyingObjectModel*(self: ptr IUIAutomationObjectModelPattern, retVal: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetUnderlyingObjectModel(self, retVal) +proc SetValue*(self: ptr IUIAutomationRangeValuePattern, val: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, val) +proc get_CurrentValue*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentValue(self, retVal) +proc get_CurrentIsReadOnly*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsReadOnly(self, retVal) +proc get_CurrentMaximum*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentMaximum(self, retVal) +proc get_CurrentMinimum*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentMinimum(self, retVal) +proc get_CurrentLargeChange*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLargeChange(self, retVal) +proc get_CurrentSmallChange*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentSmallChange(self, retVal) +proc get_CachedValue*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedValue(self, retVal) +proc get_CachedIsReadOnly*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsReadOnly(self, retVal) +proc get_CachedMaximum*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedMaximum(self, retVal) +proc get_CachedMinimum*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedMinimum(self, retVal) +proc get_CachedLargeChange*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLargeChange(self, retVal) +proc get_CachedSmallChange*(self: ptr IUIAutomationRangeValuePattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedSmallChange(self, retVal) +proc Scroll*(self: ptr IUIAutomationScrollPattern, horizontalAmount: ScrollAmount, verticalAmount: ScrollAmount): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Scroll(self, horizontalAmount, verticalAmount) +proc SetScrollPercent*(self: ptr IUIAutomationScrollPattern, horizontalPercent: float64, verticalPercent: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetScrollPercent(self, horizontalPercent, verticalPercent) +proc get_CurrentHorizontalScrollPercent*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHorizontalScrollPercent(self, retVal) +proc get_CurrentVerticalScrollPercent*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentVerticalScrollPercent(self, retVal) +proc get_CurrentHorizontalViewSize*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHorizontalViewSize(self, retVal) +proc get_CurrentVerticalViewSize*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentVerticalViewSize(self, retVal) +proc get_CurrentHorizontallyScrollable*(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHorizontallyScrollable(self, retVal) +proc get_CurrentVerticallyScrollable*(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentVerticallyScrollable(self, retVal) +proc get_CachedHorizontalScrollPercent*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHorizontalScrollPercent(self, retVal) +proc get_CachedVerticalScrollPercent*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedVerticalScrollPercent(self, retVal) +proc get_CachedHorizontalViewSize*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHorizontalViewSize(self, retVal) +proc get_CachedVerticalViewSize*(self: ptr IUIAutomationScrollPattern, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedVerticalViewSize(self, retVal) +proc get_CachedHorizontallyScrollable*(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHorizontallyScrollable(self, retVal) +proc get_CachedVerticallyScrollable*(self: ptr IUIAutomationScrollPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedVerticallyScrollable(self, retVal) +proc ScrollIntoView*(self: ptr IUIAutomationScrollItemPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self) +proc GetCurrentSelection*(self: ptr IUIAutomationSelectionPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSelection(self, retVal) +proc get_CurrentCanSelectMultiple*(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanSelectMultiple(self, retVal) +proc get_CurrentIsSelectionRequired*(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsSelectionRequired(self, retVal) +proc GetCachedSelection*(self: ptr IUIAutomationSelectionPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedSelection(self, retVal) +proc get_CachedCanSelectMultiple*(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanSelectMultiple(self, retVal) +proc get_CachedIsSelectionRequired*(self: ptr IUIAutomationSelectionPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsSelectionRequired(self, retVal) +proc get_CurrentFirstSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFirstSelectedItem(self, retVal) +proc get_CurrentLastSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLastSelectedItem(self, retVal) +proc get_CurrentCurrentSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCurrentSelectedItem(self, retVal) +proc get_CurrentItemCount*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentItemCount(self, retVal) +proc get_CachedFirstSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFirstSelectedItem(self, retVal) +proc get_CachedLastSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLastSelectedItem(self, retVal) +proc get_CachedCurrentSelectedItem*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCurrentSelectedItem(self, retVal) +proc get_CachedItemCount*(self: ptr IUIAutomationSelectionPattern2, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedItemCount(self, retVal) +proc Select*(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self) +proc AddToSelection*(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToSelection(self) +proc RemoveFromSelection*(self: ptr IUIAutomationSelectionItemPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFromSelection(self) +proc get_CurrentIsSelected*(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsSelected(self, retVal) +proc get_CurrentSelectionContainer*(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentSelectionContainer(self, retVal) +proc get_CachedIsSelected*(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsSelected(self, retVal) +proc get_CachedSelectionContainer*(self: ptr IUIAutomationSelectionItemPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedSelectionContainer(self, retVal) +proc StartListening*(self: ptr IUIAutomationSynchronizedInputPattern, inputType: SynchronizedInputType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.StartListening(self, inputType) +proc Cancel*(self: ptr IUIAutomationSynchronizedInputPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cancel(self) +proc GetCurrentRowHeaders*(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentRowHeaders(self, retVal) +proc GetCurrentColumnHeaders*(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentColumnHeaders(self, retVal) +proc get_CurrentRowOrColumnMajor*(self: ptr IUIAutomationTablePattern, retVal: ptr RowOrColumnMajor): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentRowOrColumnMajor(self, retVal) +proc GetCachedRowHeaders*(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedRowHeaders(self, retVal) +proc GetCachedColumnHeaders*(self: ptr IUIAutomationTablePattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedColumnHeaders(self, retVal) +proc get_CachedRowOrColumnMajor*(self: ptr IUIAutomationTablePattern, retVal: ptr RowOrColumnMajor): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedRowOrColumnMajor(self, retVal) +proc GetCurrentRowHeaderItems*(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentRowHeaderItems(self, retVal) +proc GetCurrentColumnHeaderItems*(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentColumnHeaderItems(self, retVal) +proc GetCachedRowHeaderItems*(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedRowHeaderItems(self, retVal) +proc GetCachedColumnHeaderItems*(self: ptr IUIAutomationTableItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedColumnHeaderItems(self, retVal) +proc Toggle*(self: ptr IUIAutomationTogglePattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Toggle(self) +proc get_CurrentToggleState*(self: ptr IUIAutomationTogglePattern, retVal: ptr ToggleState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentToggleState(self, retVal) +proc get_CachedToggleState*(self: ptr IUIAutomationTogglePattern, retVal: ptr ToggleState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedToggleState(self, retVal) +proc Move*(self: ptr IUIAutomationTransformPattern, x: float64, y: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, x, y) +proc Resize*(self: ptr IUIAutomationTransformPattern, width: float64, height: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Resize(self, width, height) +proc Rotate*(self: ptr IUIAutomationTransformPattern, degrees: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Rotate(self, degrees) +proc get_CurrentCanMove*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanMove(self, retVal) +proc get_CurrentCanResize*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanResize(self, retVal) +proc get_CurrentCanRotate*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanRotate(self, retVal) +proc get_CachedCanMove*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanMove(self, retVal) +proc get_CachedCanResize*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanResize(self, retVal) +proc get_CachedCanRotate*(self: ptr IUIAutomationTransformPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanRotate(self, retVal) +proc SetValue*(self: ptr IUIAutomationValuePattern, val: BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, val) +proc get_CurrentValue*(self: ptr IUIAutomationValuePattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentValue(self, retVal) +proc get_CurrentIsReadOnly*(self: ptr IUIAutomationValuePattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsReadOnly(self, retVal) +proc get_CachedValue*(self: ptr IUIAutomationValuePattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedValue(self, retVal) +proc get_CachedIsReadOnly*(self: ptr IUIAutomationValuePattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsReadOnly(self, retVal) +proc Close*(self: ptr IUIAutomationWindowPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Close(self) +proc WaitForInputIdle*(self: ptr IUIAutomationWindowPattern, milliseconds: int32, success: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WaitForInputIdle(self, milliseconds, success) +proc SetWindowVisualState*(self: ptr IUIAutomationWindowPattern, state: WindowVisualState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWindowVisualState(self, state) +proc get_CurrentCanMaximize*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanMaximize(self, retVal) +proc get_CurrentCanMinimize*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanMinimize(self, retVal) +proc get_CurrentIsModal*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsModal(self, retVal) +proc get_CurrentIsTopmost*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsTopmost(self, retVal) +proc get_CurrentWindowVisualState*(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowVisualState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentWindowVisualState(self, retVal) +proc get_CurrentWindowInteractionState*(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowInteractionState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentWindowInteractionState(self, retVal) +proc get_CachedCanMaximize*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanMaximize(self, retVal) +proc get_CachedCanMinimize*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanMinimize(self, retVal) +proc get_CachedIsModal*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsModal(self, retVal) +proc get_CachedIsTopmost*(self: ptr IUIAutomationWindowPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsTopmost(self, retVal) +proc get_CachedWindowVisualState*(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowVisualState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedWindowVisualState(self, retVal) +proc get_CachedWindowInteractionState*(self: ptr IUIAutomationWindowPattern, retVal: ptr WindowInteractionState): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedWindowInteractionState(self, retVal) +proc Clone*(self: ptr IUIAutomationTextRange, clonedRange: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, clonedRange) +proc Compare*(self: ptr IUIAutomationTextRange, range: ptr IUIAutomationTextRange, areSame: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Compare(self, range, areSame) +proc CompareEndpoints*(self: ptr IUIAutomationTextRange, srcEndPoint: TextPatternRangeEndpoint, range: ptr IUIAutomationTextRange, targetEndPoint: TextPatternRangeEndpoint, compValue: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareEndpoints(self, srcEndPoint, range, targetEndPoint, compValue) +proc ExpandToEnclosingUnit*(self: ptr IUIAutomationTextRange, textUnit: TextUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ExpandToEnclosingUnit(self, textUnit) +proc FindAttribute*(self: ptr IUIAutomationTextRange, attr: TEXTATTRIBUTEID, val: VARIANT, backward: BOOL, found: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAttribute(self, attr, val, backward, found) +proc FindText*(self: ptr IUIAutomationTextRange, text: BSTR, backward: BOOL, ignoreCase: BOOL, found: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindText(self, text, backward, ignoreCase, found) +proc GetAttributeValue*(self: ptr IUIAutomationTextRange, attr: TEXTATTRIBUTEID, value: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributeValue(self, attr, value) +proc GetBoundingRectangles*(self: ptr IUIAutomationTextRange, boundingRects: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBoundingRectangles(self, boundingRects) +proc GetEnclosingElement*(self: ptr IUIAutomationTextRange, enclosingElement: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnclosingElement(self, enclosingElement) +proc GetText*(self: ptr IUIAutomationTextRange, maxLength: int32, text: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetText(self, maxLength, text) +proc Move*(self: ptr IUIAutomationTextRange, unit: TextUnit, count: int32, moved: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Move(self, unit, count, moved) +proc MoveEndpointByUnit*(self: ptr IUIAutomationTextRange, endpoint: TextPatternRangeEndpoint, unit: TextUnit, count: int32, moved: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveEndpointByUnit(self, endpoint, unit, count, moved) +proc MoveEndpointByRange*(self: ptr IUIAutomationTextRange, srcEndPoint: TextPatternRangeEndpoint, range: ptr IUIAutomationTextRange, targetEndPoint: TextPatternRangeEndpoint): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MoveEndpointByRange(self, srcEndPoint, range, targetEndPoint) +proc Select*(self: ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self) +proc AddToSelection*(self: ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddToSelection(self) +proc RemoveFromSelection*(self: ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFromSelection(self) +proc ScrollIntoView*(self: ptr IUIAutomationTextRange, alignToTop: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ScrollIntoView(self, alignToTop) +proc GetChildren*(self: ptr IUIAutomationTextRange, children: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildren(self, children) +proc ShowContextMenu*(self: ptr IUIAutomationTextRange2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContextMenu(self) +proc GetEnclosingElementBuildCache*(self: ptr IUIAutomationTextRange3, cacheRequest: ptr IUIAutomationCacheRequest, enclosingElement: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnclosingElementBuildCache(self, cacheRequest, enclosingElement) +proc GetChildrenBuildCache*(self: ptr IUIAutomationTextRange3, cacheRequest: ptr IUIAutomationCacheRequest, children: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChildrenBuildCache(self, cacheRequest, children) +proc GetAttributeValues*(self: ptr IUIAutomationTextRange3, attributeIds: ptr TEXTATTRIBUTEID, attributeIdCount: int32, attributeValues: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAttributeValues(self, attributeIds, attributeIdCount, attributeValues) +proc get_Length*(self: ptr IUIAutomationTextRangeArray, length: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Length(self, length) +proc GetElement*(self: ptr IUIAutomationTextRangeArray, index: int32, element: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetElement(self, index, element) +proc RangeFromPoint*(self: ptr IUIAutomationTextPattern, pt: POINT, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromPoint(self, pt, range) +proc RangeFromChild*(self: ptr IUIAutomationTextPattern, child: ptr IUIAutomationElement, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromChild(self, child, range) +proc GetSelection*(self: ptr IUIAutomationTextPattern, ranges: ptr ptr IUIAutomationTextRangeArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSelection(self, ranges) +proc GetVisibleRanges*(self: ptr IUIAutomationTextPattern, ranges: ptr ptr IUIAutomationTextRangeArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVisibleRanges(self, ranges) +proc get_DocumentRange*(self: ptr IUIAutomationTextPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_DocumentRange(self, range) +proc get_SupportedTextSelection*(self: ptr IUIAutomationTextPattern, supportedTextSelection: ptr SupportedTextSelection): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_SupportedTextSelection(self, supportedTextSelection) +proc RangeFromAnnotation*(self: ptr IUIAutomationTextPattern2, annotation: ptr IUIAutomationElement, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RangeFromAnnotation(self, annotation, range) +proc GetCaretRange*(self: ptr IUIAutomationTextPattern2, isActive: ptr BOOL, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCaretRange(self, isActive, range) +proc GetActiveComposition*(self: ptr IUIAutomationTextEditPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetActiveComposition(self, range) +proc GetConversionTarget*(self: ptr IUIAutomationTextEditPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetConversionTarget(self, range) +proc Navigate*(self: ptr IUIAutomationCustomNavigationPattern, direction: NavigateDirection, pRetVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Navigate(self, direction, pRetVal) +proc HandleActiveTextPositionChangedEvent*(self: ptr IUIAutomationActiveTextPositionChangedEventHandler, sender: ptr IUIAutomationElement, range: ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HandleActiveTextPositionChangedEvent(self, sender, range) +proc Select*(self: ptr IUIAutomationLegacyIAccessiblePattern, flagsSelect: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Select(self, flagsSelect) +proc DoDefaultAction*(self: ptr IUIAutomationLegacyIAccessiblePattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoDefaultAction(self) +proc SetValue*(self: ptr IUIAutomationLegacyIAccessiblePattern, szValue: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetValue(self, szValue) +proc get_CurrentChildId*(self: ptr IUIAutomationLegacyIAccessiblePattern, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentChildId(self, pRetVal) +proc get_CurrentName*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentName(self, pszName) +proc get_CurrentValue*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentValue(self, pszValue) +proc get_CurrentDescription*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDescription(self, pszDescription) +proc get_CurrentRole*(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwRole: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentRole(self, pdwRole) +proc get_CurrentState*(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentState(self, pdwState) +proc get_CurrentHelp*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszHelp: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHelp(self, pszHelp) +proc get_CurrentKeyboardShortcut*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszKeyboardShortcut: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentKeyboardShortcut(self, pszKeyboardShortcut) +proc GetCurrentSelection*(self: ptr IUIAutomationLegacyIAccessiblePattern, pvarSelectedChildren: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentSelection(self, pvarSelectedChildren) +proc get_CurrentDefaultAction*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDefaultAction: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDefaultAction(self, pszDefaultAction) +proc get_CachedChildId*(self: ptr IUIAutomationLegacyIAccessiblePattern, pRetVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedChildId(self, pRetVal) +proc get_CachedName*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedName(self, pszName) +proc get_CachedValue*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszValue: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedValue(self, pszValue) +proc get_CachedDescription*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDescription: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDescription(self, pszDescription) +proc get_CachedRole*(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwRole: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedRole(self, pdwRole) +proc get_CachedState*(self: ptr IUIAutomationLegacyIAccessiblePattern, pdwState: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedState(self, pdwState) +proc get_CachedHelp*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszHelp: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHelp(self, pszHelp) +proc get_CachedKeyboardShortcut*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszKeyboardShortcut: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedKeyboardShortcut(self, pszKeyboardShortcut) +proc GetCachedSelection*(self: ptr IUIAutomationLegacyIAccessiblePattern, pvarSelectedChildren: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedSelection(self, pvarSelectedChildren) +proc get_CachedDefaultAction*(self: ptr IUIAutomationLegacyIAccessiblePattern, pszDefaultAction: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDefaultAction(self, pszDefaultAction) +proc GetIAccessible*(self: ptr IUIAutomationLegacyIAccessiblePattern, ppAccessible: ptr ptr IAccessible): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetIAccessible(self, ppAccessible) +proc FindItemByProperty*(self: ptr IUIAutomationItemContainerPattern, pStartAfter: ptr IUIAutomationElement, propertyId: PROPERTYID, value: VARIANT, pFound: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindItemByProperty(self, pStartAfter, propertyId, value, pFound) +proc Realize*(self: ptr IUIAutomationVirtualizedItemPattern): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Realize(self) +proc get_CurrentAnnotationTypeId*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAnnotationTypeId(self, retVal) +proc get_CurrentAnnotationTypeName*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAnnotationTypeName(self, retVal) +proc get_CurrentAuthor*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAuthor(self, retVal) +proc get_CurrentDateTime*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDateTime(self, retVal) +proc get_CurrentTarget*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentTarget(self, retVal) +proc get_CachedAnnotationTypeId*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAnnotationTypeId(self, retVal) +proc get_CachedAnnotationTypeName*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAnnotationTypeName(self, retVal) +proc get_CachedAuthor*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAuthor(self, retVal) +proc get_CachedDateTime*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDateTime(self, retVal) +proc get_CachedTarget*(self: ptr IUIAutomationAnnotationPattern, retVal: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedTarget(self, retVal) +proc get_CurrentStyleId*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentStyleId(self, retVal) +proc get_CurrentStyleName*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentStyleName(self, retVal) +proc get_CurrentFillColor*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFillColor(self, retVal) +proc get_CurrentFillPatternStyle*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFillPatternStyle(self, retVal) +proc get_CurrentShape*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentShape(self, retVal) +proc get_CurrentFillPatternColor*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFillPatternColor(self, retVal) +proc get_CurrentExtendedProperties*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentExtendedProperties(self, retVal) +proc GetCurrentExtendedPropertiesAsArray*(self: ptr IUIAutomationStylesPattern, propertyArray: ptr ptr TExtendedProperty, propertyCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentExtendedPropertiesAsArray(self, propertyArray, propertyCount) +proc get_CachedStyleId*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedStyleId(self, retVal) +proc get_CachedStyleName*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedStyleName(self, retVal) +proc get_CachedFillColor*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFillColor(self, retVal) +proc get_CachedFillPatternStyle*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFillPatternStyle(self, retVal) +proc get_CachedShape*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedShape(self, retVal) +proc get_CachedFillPatternColor*(self: ptr IUIAutomationStylesPattern, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFillPatternColor(self, retVal) +proc get_CachedExtendedProperties*(self: ptr IUIAutomationStylesPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedExtendedProperties(self, retVal) +proc GetCachedExtendedPropertiesAsArray*(self: ptr IUIAutomationStylesPattern, propertyArray: ptr ptr TExtendedProperty, propertyCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedExtendedPropertiesAsArray(self, propertyArray, propertyCount) +proc GetItemByName*(self: ptr IUIAutomationSpreadsheetPattern, name: BSTR, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetItemByName(self, name, element) +proc get_CurrentFormula*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFormula(self, retVal) +proc GetCurrentAnnotationObjects*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentAnnotationObjects(self, retVal) +proc GetCurrentAnnotationTypes*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentAnnotationTypes(self, retVal) +proc get_CachedFormula*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFormula(self, retVal) +proc GetCachedAnnotationObjects*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedAnnotationObjects(self, retVal) +proc GetCachedAnnotationTypes*(self: ptr IUIAutomationSpreadsheetItemPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedAnnotationTypes(self, retVal) +proc Zoom*(self: ptr IUIAutomationTransformPattern2, zoomValue: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Zoom(self, zoomValue) +proc ZoomByUnit*(self: ptr IUIAutomationTransformPattern2, zoomUnit: ZoomUnit): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ZoomByUnit(self, zoomUnit) +proc get_CurrentCanZoom*(self: ptr IUIAutomationTransformPattern2, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentCanZoom(self, retVal) +proc get_CachedCanZoom*(self: ptr IUIAutomationTransformPattern2, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedCanZoom(self, retVal) +proc get_CurrentZoomLevel*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentZoomLevel(self, retVal) +proc get_CachedZoomLevel*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedZoomLevel(self, retVal) +proc get_CurrentZoomMinimum*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentZoomMinimum(self, retVal) +proc get_CachedZoomMinimum*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedZoomMinimum(self, retVal) +proc get_CurrentZoomMaximum*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentZoomMaximum(self, retVal) +proc get_CachedZoomMaximum*(self: ptr IUIAutomationTransformPattern2, retVal: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedZoomMaximum(self, retVal) +proc get_TextContainer*(self: ptr IUIAutomationTextChildPattern, container: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextContainer(self, container) +proc get_TextRange*(self: ptr IUIAutomationTextChildPattern, range: ptr ptr IUIAutomationTextRange): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TextRange(self, range) +proc get_CurrentIsGrabbed*(self: ptr IUIAutomationDragPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsGrabbed(self, retVal) +proc get_CachedIsGrabbed*(self: ptr IUIAutomationDragPattern, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsGrabbed(self, retVal) +proc get_CurrentDropEffect*(self: ptr IUIAutomationDragPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDropEffect(self, retVal) +proc get_CachedDropEffect*(self: ptr IUIAutomationDragPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDropEffect(self, retVal) +proc get_CurrentDropEffects*(self: ptr IUIAutomationDragPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDropEffects(self, retVal) +proc get_CachedDropEffects*(self: ptr IUIAutomationDragPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDropEffects(self, retVal) +proc GetCurrentGrabbedItems*(self: ptr IUIAutomationDragPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentGrabbedItems(self, retVal) +proc GetCachedGrabbedItems*(self: ptr IUIAutomationDragPattern, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCachedGrabbedItems(self, retVal) +proc get_CurrentDropTargetEffect*(self: ptr IUIAutomationDropTargetPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDropTargetEffect(self, retVal) +proc get_CachedDropTargetEffect*(self: ptr IUIAutomationDropTargetPattern, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDropTargetEffect(self, retVal) +proc get_CurrentDropTargetEffects*(self: ptr IUIAutomationDropTargetPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentDropTargetEffects(self, retVal) +proc get_CachedDropTargetEffects*(self: ptr IUIAutomationDropTargetPattern, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedDropTargetEffects(self, retVal) +proc get_CurrentOptimizeForVisualContent*(self: ptr IUIAutomationElement2, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentOptimizeForVisualContent(self, retVal) +proc get_CachedOptimizeForVisualContent*(self: ptr IUIAutomationElement2, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedOptimizeForVisualContent(self, retVal) +proc get_CurrentLiveSetting*(self: ptr IUIAutomationElement2, retVal: ptr LiveSetting): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLiveSetting(self, retVal) +proc get_CachedLiveSetting*(self: ptr IUIAutomationElement2, retVal: ptr LiveSetting): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLiveSetting(self, retVal) +proc get_CurrentFlowsFrom*(self: ptr IUIAutomationElement2, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFlowsFrom(self, retVal) +proc get_CachedFlowsFrom*(self: ptr IUIAutomationElement2, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFlowsFrom(self, retVal) +proc ShowContextMenu*(self: ptr IUIAutomationElement3): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ShowContextMenu(self) +proc get_CurrentIsPeripheral*(self: ptr IUIAutomationElement3, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsPeripheral(self, retVal) +proc get_CachedIsPeripheral*(self: ptr IUIAutomationElement3, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsPeripheral(self, retVal) +proc get_CurrentPositionInSet*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentPositionInSet(self, retVal) +proc get_CurrentSizeOfSet*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentSizeOfSet(self, retVal) +proc get_CurrentLevel*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLevel(self, retVal) +proc get_CurrentAnnotationTypes*(self: ptr IUIAutomationElement4, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAnnotationTypes(self, retVal) +proc get_CurrentAnnotationObjects*(self: ptr IUIAutomationElement4, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentAnnotationObjects(self, retVal) +proc get_CachedPositionInSet*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedPositionInSet(self, retVal) +proc get_CachedSizeOfSet*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedSizeOfSet(self, retVal) +proc get_CachedLevel*(self: ptr IUIAutomationElement4, retVal: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLevel(self, retVal) +proc get_CachedAnnotationTypes*(self: ptr IUIAutomationElement4, retVal: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAnnotationTypes(self, retVal) +proc get_CachedAnnotationObjects*(self: ptr IUIAutomationElement4, retVal: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedAnnotationObjects(self, retVal) +proc get_CurrentLandmarkType*(self: ptr IUIAutomationElement5, retVal: ptr LANDMARKTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLandmarkType(self, retVal) +proc get_CurrentLocalizedLandmarkType*(self: ptr IUIAutomationElement5, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentLocalizedLandmarkType(self, retVal) +proc get_CachedLandmarkType*(self: ptr IUIAutomationElement5, retVal: ptr LANDMARKTYPEID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLandmarkType(self, retVal) +proc get_CachedLocalizedLandmarkType*(self: ptr IUIAutomationElement5, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedLocalizedLandmarkType(self, retVal) +proc get_CurrentFullDescription*(self: ptr IUIAutomationElement6, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentFullDescription(self, retVal) +proc get_CachedFullDescription*(self: ptr IUIAutomationElement6, retVal: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedFullDescription(self, retVal) +proc FindFirstWithOptions*(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFirstWithOptions(self, scope, condition, traversalOptions, root, found) +proc FindAllWithOptions*(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAllWithOptions(self, scope, condition, traversalOptions, root, found) +proc FindFirstWithOptionsBuildCache*(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindFirstWithOptionsBuildCache(self, scope, condition, cacheRequest, traversalOptions, root, found) +proc FindAllWithOptionsBuildCache*(self: ptr IUIAutomationElement7, scope: TreeScope, condition: ptr IUIAutomationCondition, cacheRequest: ptr IUIAutomationCacheRequest, traversalOptions: TreeTraversalOptions, root: ptr IUIAutomationElement, found: ptr ptr IUIAutomationElementArray): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindAllWithOptionsBuildCache(self, scope, condition, cacheRequest, traversalOptions, root, found) +proc GetCurrentMetadataValue*(self: ptr IUIAutomationElement7, targetId: int32, metadataId: METADATAID, returnVal: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCurrentMetadataValue(self, targetId, metadataId, returnVal) +proc get_CurrentHeadingLevel*(self: ptr IUIAutomationElement8, retVal: ptr HEADINGLEVELID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentHeadingLevel(self, retVal) +proc get_CachedHeadingLevel*(self: ptr IUIAutomationElement8, retVal: ptr HEADINGLEVELID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedHeadingLevel(self, retVal) +proc get_CurrentIsDialog*(self: ptr IUIAutomationElement9, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CurrentIsDialog(self, retVal) +proc get_CachedIsDialog*(self: ptr IUIAutomationElement9, retVal: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CachedIsDialog(self, retVal) +proc CreateProvider*(self: ptr IUIAutomationProxyFactory, hwnd: UIA_HWND, idObject: LONG, idChild: LONG, provider: ptr ptr IRawElementProviderSimple): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateProvider(self, hwnd, idObject, idChild, provider) +proc get_ProxyFactoryId*(self: ptr IUIAutomationProxyFactory, factoryId: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ProxyFactoryId(self, factoryId) +proc get_ProxyFactory*(self: ptr IUIAutomationProxyFactoryEntry, factory: ptr ptr IUIAutomationProxyFactory): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ProxyFactory(self, factory) +proc get_ClassName*(self: ptr IUIAutomationProxyFactoryEntry, className: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ClassName(self, className) +proc get_ImageName*(self: ptr IUIAutomationProxyFactoryEntry, imageName: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ImageName(self, imageName) +proc get_AllowSubstringMatch*(self: ptr IUIAutomationProxyFactoryEntry, allowSubstringMatch: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AllowSubstringMatch(self, allowSubstringMatch) +proc get_CanCheckBaseClass*(self: ptr IUIAutomationProxyFactoryEntry, canCheckBaseClass: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CanCheckBaseClass(self, canCheckBaseClass) +proc get_NeedsAdviseEvents*(self: ptr IUIAutomationProxyFactoryEntry, adviseEvents: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_NeedsAdviseEvents(self, adviseEvents) +proc put_ClassName*(self: ptr IUIAutomationProxyFactoryEntry, className: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ClassName(self, className) +proc put_ImageName*(self: ptr IUIAutomationProxyFactoryEntry, imageName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ImageName(self, imageName) +proc put_AllowSubstringMatch*(self: ptr IUIAutomationProxyFactoryEntry, allowSubstringMatch: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_AllowSubstringMatch(self, allowSubstringMatch) +proc put_CanCheckBaseClass*(self: ptr IUIAutomationProxyFactoryEntry, canCheckBaseClass: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_CanCheckBaseClass(self, canCheckBaseClass) +proc put_NeedsAdviseEvents*(self: ptr IUIAutomationProxyFactoryEntry, adviseEvents: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_NeedsAdviseEvents(self, adviseEvents) +proc SetWinEventsForAutomationEvent*(self: ptr IUIAutomationProxyFactoryEntry, eventId: EVENTID, propertyId: PROPERTYID, winEvents: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetWinEventsForAutomationEvent(self, eventId, propertyId, winEvents) +proc GetWinEventsForAutomationEvent*(self: ptr IUIAutomationProxyFactoryEntry, eventId: EVENTID, propertyId: PROPERTYID, winEvents: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetWinEventsForAutomationEvent(self, eventId, propertyId, winEvents) +proc get_Count*(self: ptr IUIAutomationProxyFactoryMapping, count: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_Count(self, count) +proc GetTable*(self: ptr IUIAutomationProxyFactoryMapping, table: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetTable(self, table) +proc GetEntry*(self: ptr IUIAutomationProxyFactoryMapping, index: UINT, entry: ptr ptr IUIAutomationProxyFactoryEntry): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEntry(self, index, entry) +proc SetTable*(self: ptr IUIAutomationProxyFactoryMapping, factoryList: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetTable(self, factoryList) +proc InsertEntries*(self: ptr IUIAutomationProxyFactoryMapping, before: UINT, factoryList: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertEntries(self, before, factoryList) +proc InsertEntry*(self: ptr IUIAutomationProxyFactoryMapping, before: UINT, factory: ptr IUIAutomationProxyFactoryEntry): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InsertEntry(self, before, factory) +proc RemoveEntry*(self: ptr IUIAutomationProxyFactoryMapping, index: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveEntry(self, index) +proc ClearTable*(self: ptr IUIAutomationProxyFactoryMapping): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ClearTable(self) +proc RestoreDefaultTable*(self: ptr IUIAutomationProxyFactoryMapping): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RestoreDefaultTable(self) +proc AddActiveTextPositionChangedEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddActiveTextPositionChangedEventHandler(self, scope, cacheRequest, handler) +proc AddAutomationEventHandler*(self: ptr IUIAutomationEventHandlerGroup, eventId: EVENTID, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddAutomationEventHandler(self, eventId, scope, cacheRequest, handler) +proc AddChangesEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, changeTypes: ptr int32, changesCount: int32, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddChangesEventHandler(self, scope, changeTypes, changesCount, cacheRequest, handler) +proc AddNotificationEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddNotificationEventHandler(self, scope, cacheRequest, handler) +proc AddPropertyChangedEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr PROPERTYID, propertyCount: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPropertyChangedEventHandler(self, scope, cacheRequest, handler, propertyArray, propertyCount) +proc AddStructureChangedEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddStructureChangedEventHandler(self, scope, cacheRequest, handler) +proc AddTextEditTextChangedEventHandler*(self: ptr IUIAutomationEventHandlerGroup, scope: TreeScope, textEditChangeType: TextEditChangeType, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTextEditTextChangedEventHandler(self, scope, textEditChangeType, cacheRequest, handler) +proc CompareElements*(self: ptr IUIAutomation, el1: ptr IUIAutomationElement, el2: ptr IUIAutomationElement, areSame: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareElements(self, el1, el2, areSame) +proc CompareRuntimeIds*(self: ptr IUIAutomation, runtimeId1: ptr SAFEARRAY, runtimeId2: ptr SAFEARRAY, areSame: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CompareRuntimeIds(self, runtimeId1, runtimeId2, areSame) +proc GetRootElement*(self: ptr IUIAutomation, root: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRootElement(self, root) +proc ElementFromHandle*(self: ptr IUIAutomation, hwnd: UIA_HWND, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromHandle(self, hwnd, element) +proc ElementFromPoint*(self: ptr IUIAutomation, pt: POINT, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromPoint(self, pt, element) +proc GetFocusedElement*(self: ptr IUIAutomation, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocusedElement(self, element) +proc GetRootElementBuildCache*(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, root: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetRootElementBuildCache(self, cacheRequest, root) +proc ElementFromHandleBuildCache*(self: ptr IUIAutomation, hwnd: UIA_HWND, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromHandleBuildCache(self, hwnd, cacheRequest, element) +proc ElementFromPointBuildCache*(self: ptr IUIAutomation, pt: POINT, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromPointBuildCache(self, pt, cacheRequest, element) +proc GetFocusedElementBuildCache*(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFocusedElementBuildCache(self, cacheRequest, element) +proc CreateTreeWalker*(self: ptr IUIAutomation, pCondition: ptr IUIAutomationCondition, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateTreeWalker(self, pCondition, walker) +proc get_ControlViewWalker*(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ControlViewWalker(self, walker) +proc get_ContentViewWalker*(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ContentViewWalker(self, walker) +proc get_RawViewWalker*(self: ptr IUIAutomation, walker: ptr ptr IUIAutomationTreeWalker): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RawViewWalker(self, walker) +proc get_RawViewCondition*(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_RawViewCondition(self, condition) +proc get_ControlViewCondition*(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ControlViewCondition(self, condition) +proc get_ContentViewCondition*(self: ptr IUIAutomation, condition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ContentViewCondition(self, condition) +proc CreateCacheRequest*(self: ptr IUIAutomation, cacheRequest: ptr ptr IUIAutomationCacheRequest): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateCacheRequest(self, cacheRequest) +proc CreateTrueCondition*(self: ptr IUIAutomation, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateTrueCondition(self, newCondition) +proc CreateFalseCondition*(self: ptr IUIAutomation, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateFalseCondition(self, newCondition) +proc CreatePropertyCondition*(self: ptr IUIAutomation, propertyId: PROPERTYID, value: VARIANT, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreatePropertyCondition(self, propertyId, value, newCondition) +proc CreatePropertyConditionEx*(self: ptr IUIAutomation, propertyId: PROPERTYID, value: VARIANT, flags: PropertyConditionFlags, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreatePropertyConditionEx(self, propertyId, value, flags, newCondition) +proc CreateAndCondition*(self: ptr IUIAutomation, condition1: ptr IUIAutomationCondition, condition2: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateAndCondition(self, condition1, condition2, newCondition) +proc CreateAndConditionFromArray*(self: ptr IUIAutomation, conditions: ptr SAFEARRAY, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateAndConditionFromArray(self, conditions, newCondition) +proc CreateAndConditionFromNativeArray*(self: ptr IUIAutomation, conditions: ptr ptr IUIAutomationCondition, conditionCount: int32, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateAndConditionFromNativeArray(self, conditions, conditionCount, newCondition) +proc CreateOrCondition*(self: ptr IUIAutomation, condition1: ptr IUIAutomationCondition, condition2: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateOrCondition(self, condition1, condition2, newCondition) +proc CreateOrConditionFromArray*(self: ptr IUIAutomation, conditions: ptr SAFEARRAY, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateOrConditionFromArray(self, conditions, newCondition) +proc CreateOrConditionFromNativeArray*(self: ptr IUIAutomation, conditions: ptr ptr IUIAutomationCondition, conditionCount: int32, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateOrConditionFromNativeArray(self, conditions, conditionCount, newCondition) +proc CreateNotCondition*(self: ptr IUIAutomation, condition: ptr IUIAutomationCondition, newCondition: ptr ptr IUIAutomationCondition): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateNotCondition(self, condition, newCondition) +proc AddAutomationEventHandler*(self: ptr IUIAutomation, eventId: EVENTID, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddAutomationEventHandler(self, eventId, element, scope, cacheRequest, handler) +proc RemoveAutomationEventHandler*(self: ptr IUIAutomation, eventId: EVENTID, element: ptr IUIAutomationElement, handler: ptr IUIAutomationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAutomationEventHandler(self, eventId, element, handler) +proc AddPropertyChangedEventHandlerNativeArray*(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr PROPERTYID, propertyCount: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPropertyChangedEventHandlerNativeArray(self, element, scope, cacheRequest, handler, propertyArray, propertyCount) +proc AddPropertyChangedEventHandler*(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationPropertyChangedEventHandler, propertyArray: ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddPropertyChangedEventHandler(self, element, scope, cacheRequest, handler, propertyArray) +proc RemovePropertyChangedEventHandler*(self: ptr IUIAutomation, element: ptr IUIAutomationElement, handler: ptr IUIAutomationPropertyChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemovePropertyChangedEventHandler(self, element, handler) +proc AddStructureChangedEventHandler*(self: ptr IUIAutomation, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddStructureChangedEventHandler(self, element, scope, cacheRequest, handler) +proc RemoveStructureChangedEventHandler*(self: ptr IUIAutomation, element: ptr IUIAutomationElement, handler: ptr IUIAutomationStructureChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveStructureChangedEventHandler(self, element, handler) +proc AddFocusChangedEventHandler*(self: ptr IUIAutomation, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationFocusChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddFocusChangedEventHandler(self, cacheRequest, handler) +proc RemoveFocusChangedEventHandler*(self: ptr IUIAutomation, handler: ptr IUIAutomationFocusChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveFocusChangedEventHandler(self, handler) +proc RemoveAllEventHandlers*(self: ptr IUIAutomation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveAllEventHandlers(self) +proc IntNativeArrayToSafeArray*(self: ptr IUIAutomation, array: ptr int32, arrayCount: int32, safeArray: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IntNativeArrayToSafeArray(self, array, arrayCount, safeArray) +proc IntSafeArrayToNativeArray*(self: ptr IUIAutomation, intArray: ptr SAFEARRAY, array: ptr ptr int32, arrayCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IntSafeArrayToNativeArray(self, intArray, array, arrayCount) +proc RectToVariant*(self: ptr IUIAutomation, rc: RECT, `var`: ptr VARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RectToVariant(self, rc, `var`) +proc VariantToRect*(self: ptr IUIAutomation, `var`: VARIANT, rc: ptr RECT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.VariantToRect(self, `var`, rc) +proc SafeArrayToRectNativeArray*(self: ptr IUIAutomation, rects: ptr SAFEARRAY, rectArray: ptr ptr RECT, rectArrayCount: ptr int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SafeArrayToRectNativeArray(self, rects, rectArray, rectArrayCount) +proc CreateProxyFactoryEntry*(self: ptr IUIAutomation, factory: ptr IUIAutomationProxyFactory, factoryEntry: ptr ptr IUIAutomationProxyFactoryEntry): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateProxyFactoryEntry(self, factory, factoryEntry) +proc get_ProxyFactoryMapping*(self: ptr IUIAutomation, factoryMapping: ptr ptr IUIAutomationProxyFactoryMapping): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ProxyFactoryMapping(self, factoryMapping) +proc GetPropertyProgrammaticName*(self: ptr IUIAutomation, property: PROPERTYID, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPropertyProgrammaticName(self, property, name) +proc GetPatternProgrammaticName*(self: ptr IUIAutomation, pattern: PATTERNID, name: ptr BSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPatternProgrammaticName(self, pattern, name) +proc PollForPotentialSupportedPatterns*(self: ptr IUIAutomation, pElement: ptr IUIAutomationElement, patternIds: ptr ptr SAFEARRAY, patternNames: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PollForPotentialSupportedPatterns(self, pElement, patternIds, patternNames) +proc PollForPotentialSupportedProperties*(self: ptr IUIAutomation, pElement: ptr IUIAutomationElement, propertyIds: ptr ptr SAFEARRAY, propertyNames: ptr ptr SAFEARRAY): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.PollForPotentialSupportedProperties(self, pElement, propertyIds, propertyNames) +proc CheckNotSupported*(self: ptr IUIAutomation, value: VARIANT, isNotSupported: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CheckNotSupported(self, value, isNotSupported) +proc get_ReservedNotSupportedValue*(self: ptr IUIAutomation, notSupportedValue: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReservedNotSupportedValue(self, notSupportedValue) +proc get_ReservedMixedAttributeValue*(self: ptr IUIAutomation, mixedAttributeValue: ptr ptr IUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ReservedMixedAttributeValue(self, mixedAttributeValue) +proc ElementFromIAccessible*(self: ptr IUIAutomation, accessible: ptr IAccessible, childId: int32, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromIAccessible(self, accessible, childId, element) +proc ElementFromIAccessibleBuildCache*(self: ptr IUIAutomation, accessible: ptr IAccessible, childId: int32, cacheRequest: ptr IUIAutomationCacheRequest, element: ptr ptr IUIAutomationElement): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ElementFromIAccessibleBuildCache(self, accessible, childId, cacheRequest, element) +proc get_AutoSetFocus*(self: ptr IUIAutomation2, autoSetFocus: ptr BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_AutoSetFocus(self, autoSetFocus) +proc put_AutoSetFocus*(self: ptr IUIAutomation2, autoSetFocus: BOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_AutoSetFocus(self, autoSetFocus) +proc get_ConnectionTimeout*(self: ptr IUIAutomation2, timeout: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ConnectionTimeout(self, timeout) +proc put_ConnectionTimeout*(self: ptr IUIAutomation2, timeout: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ConnectionTimeout(self, timeout) +proc get_TransactionTimeout*(self: ptr IUIAutomation2, timeout: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_TransactionTimeout(self, timeout) +proc put_TransactionTimeout*(self: ptr IUIAutomation2, timeout: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_TransactionTimeout(self, timeout) +proc AddTextEditTextChangedEventHandler*(self: ptr IUIAutomation3, element: ptr IUIAutomationElement, scope: TreeScope, textEditChangeType: TextEditChangeType, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddTextEditTextChangedEventHandler(self, element, scope, textEditChangeType, cacheRequest, handler) +proc RemoveTextEditTextChangedEventHandler*(self: ptr IUIAutomation3, element: ptr IUIAutomationElement, handler: ptr IUIAutomationTextEditTextChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveTextEditTextChangedEventHandler(self, element, handler) +proc AddChangesEventHandler*(self: ptr IUIAutomation4, element: ptr IUIAutomationElement, scope: TreeScope, changeTypes: ptr int32, changesCount: int32, pCacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddChangesEventHandler(self, element, scope, changeTypes, changesCount, pCacheRequest, handler) +proc RemoveChangesEventHandler*(self: ptr IUIAutomation4, element: ptr IUIAutomationElement, handler: ptr IUIAutomationChangesEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveChangesEventHandler(self, element, handler) +proc AddNotificationEventHandler*(self: ptr IUIAutomation5, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddNotificationEventHandler(self, element, scope, cacheRequest, handler) +proc RemoveNotificationEventHandler*(self: ptr IUIAutomation5, element: ptr IUIAutomationElement, handler: ptr IUIAutomationNotificationEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveNotificationEventHandler(self, element, handler) +proc CreateEventHandlerGroup*(self: ptr IUIAutomation6, handlerGroup: ptr ptr IUIAutomationEventHandlerGroup): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateEventHandlerGroup(self, handlerGroup) +proc AddEventHandlerGroup*(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handlerGroup: ptr IUIAutomationEventHandlerGroup): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddEventHandlerGroup(self, element, handlerGroup) +proc RemoveEventHandlerGroup*(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handlerGroup: ptr IUIAutomationEventHandlerGroup): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveEventHandlerGroup(self, element, handlerGroup) +proc get_ConnectionRecoveryBehavior*(self: ptr IUIAutomation6, connectionRecoveryBehaviorOptions: ptr ConnectionRecoveryBehaviorOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_ConnectionRecoveryBehavior(self, connectionRecoveryBehaviorOptions) +proc put_ConnectionRecoveryBehavior*(self: ptr IUIAutomation6, connectionRecoveryBehaviorOptions: ConnectionRecoveryBehaviorOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_ConnectionRecoveryBehavior(self, connectionRecoveryBehaviorOptions) +proc get_CoalesceEvents*(self: ptr IUIAutomation6, coalesceEventsOptions: ptr CoalesceEventsOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.get_CoalesceEvents(self, coalesceEventsOptions) +proc put_CoalesceEvents*(self: ptr IUIAutomation6, coalesceEventsOptions: CoalesceEventsOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.put_CoalesceEvents(self, coalesceEventsOptions) +proc AddActiveTextPositionChangedEventHandler*(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, scope: TreeScope, cacheRequest: ptr IUIAutomationCacheRequest, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.AddActiveTextPositionChangedEventHandler(self, element, scope, cacheRequest, handler) +proc RemoveActiveTextPositionChangedEventHandler*(self: ptr IUIAutomation6, element: ptr IUIAutomationElement, handler: ptr IUIAutomationActiveTextPositionChangedEventHandler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveActiveTextPositionChangedEventHandler(self, element, handler) +converter winimConverterIRawElementProviderSimpleToIUnknown*(x: ptr IRawElementProviderSimple): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibleExToIUnknown*(x: ptr IAccessibleEx): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderSimple2ToIRawElementProviderSimple*(x: ptr IRawElementProviderSimple2): ptr IRawElementProviderSimple = cast[ptr IRawElementProviderSimple](x) +converter winimConverterIRawElementProviderSimple2ToIUnknown*(x: ptr IRawElementProviderSimple2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderSimple3ToIRawElementProviderSimple2*(x: ptr IRawElementProviderSimple3): ptr IRawElementProviderSimple2 = cast[ptr IRawElementProviderSimple2](x) +converter winimConverterIRawElementProviderSimple3ToIRawElementProviderSimple*(x: ptr IRawElementProviderSimple3): ptr IRawElementProviderSimple = cast[ptr IRawElementProviderSimple](x) +converter winimConverterIRawElementProviderSimple3ToIUnknown*(x: ptr IRawElementProviderSimple3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderFragmentRootToIUnknown*(x: ptr IRawElementProviderFragmentRoot): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderFragmentToIUnknown*(x: ptr IRawElementProviderFragment): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderAdviseEventsToIUnknown*(x: ptr IRawElementProviderAdviseEvents): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderHwndOverrideToIUnknown*(x: ptr IRawElementProviderHwndOverride): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProxyProviderWinEventSinkToIUnknown*(x: ptr IProxyProviderWinEventSink): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIProxyProviderWinEventHandlerToIUnknown*(x: ptr IProxyProviderWinEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderWindowlessSiteToIUnknown*(x: ptr IRawElementProviderWindowlessSite): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAccessibleHostingElementProvidersToIUnknown*(x: ptr IAccessibleHostingElementProviders): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRawElementProviderHostingAccessiblesToIUnknown*(x: ptr IRawElementProviderHostingAccessibles): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDockProviderToIUnknown*(x: ptr IDockProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIExpandCollapseProviderToIUnknown*(x: ptr IExpandCollapseProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGridProviderToIUnknown*(x: ptr IGridProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGridItemProviderToIUnknown*(x: ptr IGridItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIInvokeProviderToIUnknown*(x: ptr IInvokeProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIMultipleViewProviderToIUnknown*(x: ptr IMultipleViewProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIRangeValueProviderToIUnknown*(x: ptr IRangeValueProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIScrollItemProviderToIUnknown*(x: ptr IScrollItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISelectionProviderToIUnknown*(x: ptr ISelectionProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISelectionProvider2ToISelectionProvider*(x: ptr ISelectionProvider2): ptr ISelectionProvider = cast[ptr ISelectionProvider](x) +converter winimConverterISelectionProvider2ToIUnknown*(x: ptr ISelectionProvider2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIScrollProviderToIUnknown*(x: ptr IScrollProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISelectionItemProviderToIUnknown*(x: ptr ISelectionItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISynchronizedInputProviderToIUnknown*(x: ptr ISynchronizedInputProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITableProviderToIUnknown*(x: ptr ITableProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITableItemProviderToIUnknown*(x: ptr ITableItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIToggleProviderToIUnknown*(x: ptr IToggleProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransformProviderToIUnknown*(x: ptr ITransformProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIValueProviderToIUnknown*(x: ptr IValueProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWindowProviderToIUnknown*(x: ptr IWindowProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterILegacyIAccessibleProviderToIUnknown*(x: ptr ILegacyIAccessibleProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIItemContainerProviderToIUnknown*(x: ptr IItemContainerProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIVirtualizedItemProviderToIUnknown*(x: ptr IVirtualizedItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIObjectModelProviderToIUnknown*(x: ptr IObjectModelProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAnnotationProviderToIUnknown*(x: ptr IAnnotationProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIStylesProviderToIUnknown*(x: ptr IStylesProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISpreadsheetProviderToIUnknown*(x: ptr ISpreadsheetProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterISpreadsheetItemProviderToIUnknown*(x: ptr ISpreadsheetItemProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITransformProvider2ToITransformProvider*(x: ptr ITransformProvider2): ptr ITransformProvider = cast[ptr ITransformProvider](x) +converter winimConverterITransformProvider2ToIUnknown*(x: ptr ITransformProvider2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDragProviderToIUnknown*(x: ptr IDragProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIDropTargetProviderToIUnknown*(x: ptr IDropTargetProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextRangeProviderToIUnknown*(x: ptr ITextRangeProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextProviderToIUnknown*(x: ptr ITextProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextProvider2ToITextProvider*(x: ptr ITextProvider2): ptr ITextProvider = cast[ptr ITextProvider](x) +converter winimConverterITextProvider2ToIUnknown*(x: ptr ITextProvider2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextEditProviderToITextProvider*(x: ptr ITextEditProvider): ptr ITextProvider = cast[ptr ITextProvider](x) +converter winimConverterITextEditProviderToIUnknown*(x: ptr ITextEditProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextRangeProvider2ToITextRangeProvider*(x: ptr ITextRangeProvider2): ptr ITextRangeProvider = cast[ptr ITextRangeProvider](x) +converter winimConverterITextRangeProvider2ToIUnknown*(x: ptr ITextRangeProvider2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterITextChildProviderToIUnknown*(x: ptr ITextChildProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterICustomNavigationProviderToIUnknown*(x: ptr ICustomNavigationProvider): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationPatternInstanceToIUnknown*(x: ptr IUIAutomationPatternInstance): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationPatternHandlerToIUnknown*(x: ptr IUIAutomationPatternHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationRegistrarToIUnknown*(x: ptr IUIAutomationRegistrar): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElementToIUnknown*(x: ptr IUIAutomationElement): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElementArrayToIUnknown*(x: ptr IUIAutomationElementArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationConditionToIUnknown*(x: ptr IUIAutomationCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationBoolConditionToIUIAutomationCondition*(x: ptr IUIAutomationBoolCondition): ptr IUIAutomationCondition = cast[ptr IUIAutomationCondition](x) +converter winimConverterIUIAutomationBoolConditionToIUnknown*(x: ptr IUIAutomationBoolCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationPropertyConditionToIUIAutomationCondition*(x: ptr IUIAutomationPropertyCondition): ptr IUIAutomationCondition = cast[ptr IUIAutomationCondition](x) +converter winimConverterIUIAutomationPropertyConditionToIUnknown*(x: ptr IUIAutomationPropertyCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationAndConditionToIUIAutomationCondition*(x: ptr IUIAutomationAndCondition): ptr IUIAutomationCondition = cast[ptr IUIAutomationCondition](x) +converter winimConverterIUIAutomationAndConditionToIUnknown*(x: ptr IUIAutomationAndCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationOrConditionToIUIAutomationCondition*(x: ptr IUIAutomationOrCondition): ptr IUIAutomationCondition = cast[ptr IUIAutomationCondition](x) +converter winimConverterIUIAutomationOrConditionToIUnknown*(x: ptr IUIAutomationOrCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationNotConditionToIUIAutomationCondition*(x: ptr IUIAutomationNotCondition): ptr IUIAutomationCondition = cast[ptr IUIAutomationCondition](x) +converter winimConverterIUIAutomationNotConditionToIUnknown*(x: ptr IUIAutomationNotCondition): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationCacheRequestToIUnknown*(x: ptr IUIAutomationCacheRequest): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTreeWalkerToIUnknown*(x: ptr IUIAutomationTreeWalker): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationEventHandlerToIUnknown*(x: ptr IUIAutomationEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationPropertyChangedEventHandlerToIUnknown*(x: ptr IUIAutomationPropertyChangedEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationStructureChangedEventHandlerToIUnknown*(x: ptr IUIAutomationStructureChangedEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationFocusChangedEventHandlerToIUnknown*(x: ptr IUIAutomationFocusChangedEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextEditTextChangedEventHandlerToIUnknown*(x: ptr IUIAutomationTextEditTextChangedEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationChangesEventHandlerToIUnknown*(x: ptr IUIAutomationChangesEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationNotificationEventHandlerToIUnknown*(x: ptr IUIAutomationNotificationEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationInvokePatternToIUnknown*(x: ptr IUIAutomationInvokePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationDockPatternToIUnknown*(x: ptr IUIAutomationDockPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationExpandCollapsePatternToIUnknown*(x: ptr IUIAutomationExpandCollapsePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationGridPatternToIUnknown*(x: ptr IUIAutomationGridPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationGridItemPatternToIUnknown*(x: ptr IUIAutomationGridItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationMultipleViewPatternToIUnknown*(x: ptr IUIAutomationMultipleViewPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationObjectModelPatternToIUnknown*(x: ptr IUIAutomationObjectModelPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationRangeValuePatternToIUnknown*(x: ptr IUIAutomationRangeValuePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationScrollPatternToIUnknown*(x: ptr IUIAutomationScrollPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationScrollItemPatternToIUnknown*(x: ptr IUIAutomationScrollItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSelectionPatternToIUnknown*(x: ptr IUIAutomationSelectionPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSelectionPattern2ToIUIAutomationSelectionPattern*(x: ptr IUIAutomationSelectionPattern2): ptr IUIAutomationSelectionPattern = cast[ptr IUIAutomationSelectionPattern](x) +converter winimConverterIUIAutomationSelectionPattern2ToIUnknown*(x: ptr IUIAutomationSelectionPattern2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSelectionItemPatternToIUnknown*(x: ptr IUIAutomationSelectionItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSynchronizedInputPatternToIUnknown*(x: ptr IUIAutomationSynchronizedInputPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTablePatternToIUnknown*(x: ptr IUIAutomationTablePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTableItemPatternToIUnknown*(x: ptr IUIAutomationTableItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTogglePatternToIUnknown*(x: ptr IUIAutomationTogglePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTransformPatternToIUnknown*(x: ptr IUIAutomationTransformPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationValuePatternToIUnknown*(x: ptr IUIAutomationValuePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationWindowPatternToIUnknown*(x: ptr IUIAutomationWindowPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextRangeToIUnknown*(x: ptr IUIAutomationTextRange): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextRange2ToIUIAutomationTextRange*(x: ptr IUIAutomationTextRange2): ptr IUIAutomationTextRange = cast[ptr IUIAutomationTextRange](x) +converter winimConverterIUIAutomationTextRange2ToIUnknown*(x: ptr IUIAutomationTextRange2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextRange3ToIUIAutomationTextRange2*(x: ptr IUIAutomationTextRange3): ptr IUIAutomationTextRange2 = cast[ptr IUIAutomationTextRange2](x) +converter winimConverterIUIAutomationTextRange3ToIUIAutomationTextRange*(x: ptr IUIAutomationTextRange3): ptr IUIAutomationTextRange = cast[ptr IUIAutomationTextRange](x) +converter winimConverterIUIAutomationTextRange3ToIUnknown*(x: ptr IUIAutomationTextRange3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextRangeArrayToIUnknown*(x: ptr IUIAutomationTextRangeArray): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextPatternToIUnknown*(x: ptr IUIAutomationTextPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextPattern2ToIUIAutomationTextPattern*(x: ptr IUIAutomationTextPattern2): ptr IUIAutomationTextPattern = cast[ptr IUIAutomationTextPattern](x) +converter winimConverterIUIAutomationTextPattern2ToIUnknown*(x: ptr IUIAutomationTextPattern2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextEditPatternToIUIAutomationTextPattern*(x: ptr IUIAutomationTextEditPattern): ptr IUIAutomationTextPattern = cast[ptr IUIAutomationTextPattern](x) +converter winimConverterIUIAutomationTextEditPatternToIUnknown*(x: ptr IUIAutomationTextEditPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationCustomNavigationPatternToIUnknown*(x: ptr IUIAutomationCustomNavigationPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationActiveTextPositionChangedEventHandlerToIUnknown*(x: ptr IUIAutomationActiveTextPositionChangedEventHandler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationLegacyIAccessiblePatternToIUnknown*(x: ptr IUIAutomationLegacyIAccessiblePattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationItemContainerPatternToIUnknown*(x: ptr IUIAutomationItemContainerPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationVirtualizedItemPatternToIUnknown*(x: ptr IUIAutomationVirtualizedItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationAnnotationPatternToIUnknown*(x: ptr IUIAutomationAnnotationPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationStylesPatternToIUnknown*(x: ptr IUIAutomationStylesPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSpreadsheetPatternToIUnknown*(x: ptr IUIAutomationSpreadsheetPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationSpreadsheetItemPatternToIUnknown*(x: ptr IUIAutomationSpreadsheetItemPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTransformPattern2ToIUIAutomationTransformPattern*(x: ptr IUIAutomationTransformPattern2): ptr IUIAutomationTransformPattern = cast[ptr IUIAutomationTransformPattern](x) +converter winimConverterIUIAutomationTransformPattern2ToIUnknown*(x: ptr IUIAutomationTransformPattern2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationTextChildPatternToIUnknown*(x: ptr IUIAutomationTextChildPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationDragPatternToIUnknown*(x: ptr IUIAutomationDragPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationDropTargetPatternToIUnknown*(x: ptr IUIAutomationDropTargetPattern): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement2ToIUIAutomationElement*(x: ptr IUIAutomationElement2): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement2ToIUnknown*(x: ptr IUIAutomationElement2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement3ToIUIAutomationElement2*(x: ptr IUIAutomationElement3): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement3ToIUIAutomationElement*(x: ptr IUIAutomationElement3): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement3ToIUnknown*(x: ptr IUIAutomationElement3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement4ToIUIAutomationElement3*(x: ptr IUIAutomationElement4): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement4ToIUIAutomationElement2*(x: ptr IUIAutomationElement4): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement4ToIUIAutomationElement*(x: ptr IUIAutomationElement4): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement4ToIUnknown*(x: ptr IUIAutomationElement4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement5ToIUIAutomationElement4*(x: ptr IUIAutomationElement5): ptr IUIAutomationElement4 = cast[ptr IUIAutomationElement4](x) +converter winimConverterIUIAutomationElement5ToIUIAutomationElement3*(x: ptr IUIAutomationElement5): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement5ToIUIAutomationElement2*(x: ptr IUIAutomationElement5): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement5ToIUIAutomationElement*(x: ptr IUIAutomationElement5): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement5ToIUnknown*(x: ptr IUIAutomationElement5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement6ToIUIAutomationElement5*(x: ptr IUIAutomationElement6): ptr IUIAutomationElement5 = cast[ptr IUIAutomationElement5](x) +converter winimConverterIUIAutomationElement6ToIUIAutomationElement4*(x: ptr IUIAutomationElement6): ptr IUIAutomationElement4 = cast[ptr IUIAutomationElement4](x) +converter winimConverterIUIAutomationElement6ToIUIAutomationElement3*(x: ptr IUIAutomationElement6): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement6ToIUIAutomationElement2*(x: ptr IUIAutomationElement6): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement6ToIUIAutomationElement*(x: ptr IUIAutomationElement6): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement6ToIUnknown*(x: ptr IUIAutomationElement6): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement6*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement6 = cast[ptr IUIAutomationElement6](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement5*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement5 = cast[ptr IUIAutomationElement5](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement4*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement4 = cast[ptr IUIAutomationElement4](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement3*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement2*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement7ToIUIAutomationElement*(x: ptr IUIAutomationElement7): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement7ToIUnknown*(x: ptr IUIAutomationElement7): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement7*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement7 = cast[ptr IUIAutomationElement7](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement6*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement6 = cast[ptr IUIAutomationElement6](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement5*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement5 = cast[ptr IUIAutomationElement5](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement4*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement4 = cast[ptr IUIAutomationElement4](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement3*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement2*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement8ToIUIAutomationElement*(x: ptr IUIAutomationElement8): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement8ToIUnknown*(x: ptr IUIAutomationElement8): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement8*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement8 = cast[ptr IUIAutomationElement8](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement7*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement7 = cast[ptr IUIAutomationElement7](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement6*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement6 = cast[ptr IUIAutomationElement6](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement5*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement5 = cast[ptr IUIAutomationElement5](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement4*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement4 = cast[ptr IUIAutomationElement4](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement3*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement3 = cast[ptr IUIAutomationElement3](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement2*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement2 = cast[ptr IUIAutomationElement2](x) +converter winimConverterIUIAutomationElement9ToIUIAutomationElement*(x: ptr IUIAutomationElement9): ptr IUIAutomationElement = cast[ptr IUIAutomationElement](x) +converter winimConverterIUIAutomationElement9ToIUnknown*(x: ptr IUIAutomationElement9): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationProxyFactoryToIUnknown*(x: ptr IUIAutomationProxyFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationProxyFactoryEntryToIUnknown*(x: ptr IUIAutomationProxyFactoryEntry): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationProxyFactoryMappingToIUnknown*(x: ptr IUIAutomationProxyFactoryMapping): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationEventHandlerGroupToIUnknown*(x: ptr IUIAutomationEventHandlerGroup): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomationToIUnknown*(x: ptr IUIAutomation): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomation2ToIUIAutomation*(x: ptr IUIAutomation2): ptr IUIAutomation = cast[ptr IUIAutomation](x) +converter winimConverterIUIAutomation2ToIUnknown*(x: ptr IUIAutomation2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomation3ToIUIAutomation2*(x: ptr IUIAutomation3): ptr IUIAutomation2 = cast[ptr IUIAutomation2](x) +converter winimConverterIUIAutomation3ToIUIAutomation*(x: ptr IUIAutomation3): ptr IUIAutomation = cast[ptr IUIAutomation](x) +converter winimConverterIUIAutomation3ToIUnknown*(x: ptr IUIAutomation3): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomation4ToIUIAutomation3*(x: ptr IUIAutomation4): ptr IUIAutomation3 = cast[ptr IUIAutomation3](x) +converter winimConverterIUIAutomation4ToIUIAutomation2*(x: ptr IUIAutomation4): ptr IUIAutomation2 = cast[ptr IUIAutomation2](x) +converter winimConverterIUIAutomation4ToIUIAutomation*(x: ptr IUIAutomation4): ptr IUIAutomation = cast[ptr IUIAutomation](x) +converter winimConverterIUIAutomation4ToIUnknown*(x: ptr IUIAutomation4): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomation5ToIUIAutomation4*(x: ptr IUIAutomation5): ptr IUIAutomation4 = cast[ptr IUIAutomation4](x) +converter winimConverterIUIAutomation5ToIUIAutomation3*(x: ptr IUIAutomation5): ptr IUIAutomation3 = cast[ptr IUIAutomation3](x) +converter winimConverterIUIAutomation5ToIUIAutomation2*(x: ptr IUIAutomation5): ptr IUIAutomation2 = cast[ptr IUIAutomation2](x) +converter winimConverterIUIAutomation5ToIUIAutomation*(x: ptr IUIAutomation5): ptr IUIAutomation = cast[ptr IUIAutomation](x) +converter winimConverterIUIAutomation5ToIUnknown*(x: ptr IUIAutomation5): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIUIAutomation6ToIUIAutomation5*(x: ptr IUIAutomation6): ptr IUIAutomation5 = cast[ptr IUIAutomation5](x) +converter winimConverterIUIAutomation6ToIUIAutomation4*(x: ptr IUIAutomation6): ptr IUIAutomation4 = cast[ptr IUIAutomation4](x) +converter winimConverterIUIAutomation6ToIUIAutomation3*(x: ptr IUIAutomation6): ptr IUIAutomation3 = cast[ptr IUIAutomation3](x) +converter winimConverterIUIAutomation6ToIUIAutomation2*(x: ptr IUIAutomation6): ptr IUIAutomation2 = cast[ptr IUIAutomation2](x) +converter winimConverterIUIAutomation6ToIUIAutomation*(x: ptr IUIAutomation6): ptr IUIAutomation = cast[ptr IUIAutomation](x) +converter winimConverterIUIAutomation6ToIUnknown*(x: ptr IUIAutomation6): ptr IUnknown = cast[ptr IUnknown](x) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/usp10.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/usp10.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,206 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import wingdi +#include +type + SCRIPT_CACHE* = pointer + SCRIPT_STRING_ANALYSIS* = pointer + OPENTYPE_TAG* = ULONG +const + USPBUILD* = 0400 + SCRIPT_UNDEFINED* = 0 + UNISCRIBE_OPENTYPE* = 0x0100 + SCRIPT_TAG_UNKNOWN* = 0x00000000 + USP_E_SCRIPT_NOT_IN_FONT* = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x200) + SGCM_RTL* = 0x00000001 + SSA_PASSWORD* = 0x00000001 + SSA_TAB* = 0x00000002 + SSA_CLIP* = 0x00000004 + SSA_FIT* = 0x00000008 + SSA_DZWG* = 0x00000010 + SSA_FALLBACK* = 0x00000020 + SSA_BREAK* = 0x00000040 + SSA_GLYPHS* = 0x00000080 + SSA_RTL* = 0x00000100 + SSA_GCP* = 0x00000200 + SSA_HOTKEY* = 0x00000400 + SSA_METAFILE* = 0x00000800 + SSA_LINK* = 0x00001000 + SSA_HIDEHOTKEY* = 0x00002000 + SSA_HOTKEYONLY* = 0x00002400 + SSA_FULLMEASURE* = 0x04000000 + SSA_LPKANSIFALLBACK* = 0x08000000 + SSA_PIDX* = 0x10000000 + SSA_LAYOUTRTL* = 0x20000000 + SSA_DONTGLYPH* = 0x40000000 + SSA_NOKASHIDA* = 0x80000000'i32 + SIC_COMPLEX* = 1 + SIC_ASCIIDIGIT* = 2 + SIC_NEUTRAL* = 4 + SCRIPT_DIGITSUBSTITUTE_CONTEXT* = 0 + SCRIPT_DIGITSUBSTITUTE_NONE* = 1 + SCRIPT_DIGITSUBSTITUTE_NATIONAL* = 2 + SCRIPT_DIGITSUBSTITUTE_TRADITIONAL* = 3 + SCRIPT_JUSTIFY_NONE* = 0 + SCRIPT_JUSTIFY_ARABIC_BLANK* = 1 + SCRIPT_JUSTIFY_CHARACTER* = 2 + SCRIPT_JUSTIFY_RESERVED1* = 3 + SCRIPT_JUSTIFY_BLANK* = 4 + SCRIPT_JUSTIFY_RESERVED2* = 5 + SCRIPT_JUSTIFY_RESERVED3* = 6 + SCRIPT_JUSTIFY_ARABIC_NORMAL* = 7 + SCRIPT_JUSTIFY_ARABIC_KASHIDA* = 8 + SCRIPT_JUSTIFY_ARABIC_ALEF* = 9 + SCRIPT_JUSTIFY_ARABIC_HA* = 10 + SCRIPT_JUSTIFY_ARABIC_RA* = 11 + SCRIPT_JUSTIFY_ARABIC_BA* = 12 + SCRIPT_JUSTIFY_ARABIC_BARA* = 13 + SCRIPT_JUSTIFY_ARABIC_SEEN* = 14 + SCRIPT_JUSTIFY_ARABIC_SEEN_M* = 15 +type + SCRIPT_CONTROL* {.pure.} = object + uDefaultLanguage* {.bitsize:16.}: DWORD + fContextDigits* {.bitsize:1.}: DWORD + fInvertPreBoundDir* {.bitsize:1.}: DWORD + fInvertPostBoundDir* {.bitsize:1.}: DWORD + fLinkStringBefore* {.bitsize:1.}: DWORD + fLinkStringAfter* {.bitsize:1.}: DWORD + fNeutralOverride* {.bitsize:1.}: DWORD + fNumericOverride* {.bitsize:1.}: DWORD + fLegacyBidiClass* {.bitsize:1.}: DWORD + fMergeNeutralItems* {.bitsize:1.}: DWORD + fUseStandardBidi* {.bitsize:1.}: DWORD + fReserved* {.bitsize:6.}: DWORD + SCRIPT_STATE* {.pure.} = object + uBidiLevel* {.bitsize:5.}: WORD + fOverrideDirection* {.bitsize:1.}: WORD + fInhibitSymSwap* {.bitsize:1.}: WORD + fCharShape* {.bitsize:1.}: WORD + fDigitSubstitute* {.bitsize:1.}: WORD + fInhibitLigate* {.bitsize:1.}: WORD + fDisplayZWG* {.bitsize:1.}: WORD + fArabicNumContext* {.bitsize:1.}: WORD + fGcpClusters* {.bitsize:1.}: WORD + fReserved* {.bitsize:1.}: WORD + fEngineReserved* {.bitsize:2.}: WORD + SCRIPT_ANALYSIS* {.pure.} = object + eScript* {.bitsize:10.}: WORD + fRTL* {.bitsize:1.}: WORD + fLayoutRTL* {.bitsize:1.}: WORD + fLinkBefore* {.bitsize:1.}: WORD + fLinkAfter* {.bitsize:1.}: WORD + fLogicalOrder* {.bitsize:1.}: WORD + fNoGlyphIndex* {.bitsize:1.}: WORD + s*: SCRIPT_STATE + SCRIPT_ITEM* {.pure.} = object + iCharPos*: int32 + a*: SCRIPT_ANALYSIS + SCRIPT_VISATTR* {.pure.} = object + uJustification* {.bitsize:4.}: WORD + fClusterStart* {.bitsize:1.}: WORD + fDiacritic* {.bitsize:1.}: WORD + fZeroWidth* {.bitsize:1.}: WORD + fReserved* {.bitsize:1.}: WORD + fShapeReserved* {.bitsize:8.}: WORD + GOFFSET* {.pure.} = object + du*: LONG + dv*: LONG + SCRIPT_LOGATTR* {.pure.} = object + fSoftBreak* {.bitsize:1.}: BYTE + fWhiteSpace* {.bitsize:1.}: BYTE + fCharStop* {.bitsize:1.}: BYTE + fWordStop* {.bitsize:1.}: BYTE + fInvalid* {.bitsize:1.}: BYTE + fReserved* {.bitsize:3.}: BYTE + SCRIPT_PROPERTIES* {.pure.} = object + langid* {.bitsize:16.}: DWORD + fNumeric* {.bitsize:1.}: DWORD + fComplex* {.bitsize:1.}: DWORD + fNeedsWordBreaking* {.bitsize:1.}: DWORD + fNeedsCaretInfo* {.bitsize:1.}: DWORD + bCharSet* {.bitsize:8.}: DWORD + fControl* {.bitsize:1.}: DWORD + fPrivateUseArea* {.bitsize:1.}: DWORD + fNeedsCharacterJustify* {.bitsize:1.}: DWORD + fInvalidGlyph* {.bitsize:1.}: DWORD + fInvalidLogAttr* {.bitsize:1.}: DWORD + fCDM* {.bitsize:1.}: DWORD + fAmbiguousCharSet* {.bitsize:1.}: DWORD + fClusterSizeVaries* {.bitsize:1.}: DWORD + fRejectInvalid* {.bitsize:1.}: DWORD + SCRIPT_FONTPROPERTIES* {.pure.} = object + cBytes*: int32 + wgBlank*: WORD + wgDefault*: WORD + wgInvalid*: WORD + wgKashida*: WORD + iKashidaWidth*: int32 + SCRIPT_TABDEF* {.pure.} = object + cTabStops*: int32 + iScale*: int32 + pTabStops*: ptr int32 + iTabOrigin*: int32 + SCRIPT_DIGITSUBSTITUTE* {.pure.} = object + NationalDigitLanguage* {.bitsize:16.}: DWORD + TraditionalDigitLanguage* {.bitsize:16.}: DWORD + DigitSubstitute* {.bitsize:8.}: DWORD + dwReserved*: DWORD + OPENTYPE_FEATURE_RECORD* {.pure.} = object + tagFeature*: OPENTYPE_TAG + lParameter*: LONG + TEXTRANGE_PROPERTIES* {.pure.} = object + potfRecords*: ptr OPENTYPE_FEATURE_RECORD + cotfRecords*: int32 + SCRIPT_CHARPROP* {.pure.} = object + fCanGlyphAlone* {.bitsize:1.}: WORD + reserved* {.bitsize:15.}: WORD + SCRIPT_GLYPHPROP* {.pure.} = object + sva*: SCRIPT_VISATTR + reserved*: WORD +proc ScriptFreeCache*(psc: ptr SCRIPT_CACHE): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptItemize*(pwcInChars: ptr WCHAR, cInChars: int32, cMaxItems: int32, psControl: ptr SCRIPT_CONTROL, psState: ptr SCRIPT_STATE, pItems: ptr SCRIPT_ITEM, pcItems: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptLayout*(cRuns: int32, pbLevel: ptr BYTE, piVisualToLogical: ptr int32, piLogicalToVisual: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptShape*(hdc: HDC, psc: ptr SCRIPT_CACHE, pwcChars: ptr WCHAR, cChars: int32, cMaxGlyphs: int32, psa: ptr SCRIPT_ANALYSIS, pwOutGlyphs: ptr WORD, pwLogClust: ptr WORD, psva: ptr SCRIPT_VISATTR, pcGlyphs: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptPlace*(hdc: HDC, psc: ptr SCRIPT_CACHE, pwGlyphs: ptr WORD, cGlyphs: int32, psva: ptr SCRIPT_VISATTR, psa: ptr SCRIPT_ANALYSIS, piAdvance: ptr int32, pGoffset: ptr GOFFSET, pABC: ptr ABC): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptTextOut*(hdc: HDC, psc: ptr SCRIPT_CACHE, x: int32, y: int32, fuOptions: UINT, lprc: ptr RECT, psa: ptr SCRIPT_ANALYSIS, pwcReserved: ptr WCHAR, iReserved: int32, pwGlyphs: ptr WORD, cGlyphs: int32, piAdvance: ptr int32, piJustify: ptr int32, pGoffset: ptr GOFFSET): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptJustify*(psva: ptr SCRIPT_VISATTR, piAdvance: ptr int32, cGlyphs: int32, iDx: int32, iMinKashida: int32, piJustify: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptBreak*(pwcChars: ptr WCHAR, cChars: int32, psa: ptr SCRIPT_ANALYSIS, psla: ptr SCRIPT_LOGATTR): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptCPtoX*(iCP: int32, fTrailing: WINBOOL, cChars: int32, cGlyphs: int32, pwLogClust: ptr WORD, psva: ptr SCRIPT_VISATTR, piAdvance: ptr int32, psa: ptr SCRIPT_ANALYSIS, piX: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptXtoCP*(iX: int32, cChars: int32, cGlyphs: int32, pwLogClust: ptr WORD, psva: ptr SCRIPT_VISATTR, piAdvance: ptr int32, psa: ptr SCRIPT_ANALYSIS, piCP: ptr int32, piTrailing: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetLogicalWidths*(psa: ptr SCRIPT_ANALYSIS, cChars: int32, cGlyphs: int32, piGlyphWidth: ptr int32, pwLogClust: ptr WORD, psva: ptr SCRIPT_VISATTR, piDx: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptApplyLogicalWidth*(piDx: ptr int32, cChars: int32, cGlyphs: int32, pwLogClust: ptr WORD, psva: ptr SCRIPT_VISATTR, piAdvance: ptr int32, psa: ptr SCRIPT_ANALYSIS, pABC: ptr ABC, piJustify: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetCMap*(hdc: HDC, psc: ptr SCRIPT_CACHE, pwcInChars: ptr WCHAR, cChars: int32, dwFlags: DWORD, pwOutGlyphs: ptr WORD): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetGlyphABCWidth*(hdc: HDC, psc: ptr SCRIPT_CACHE, wGlyph: WORD, pABC: ptr ABC): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetProperties*(ppSp: ptr ptr ptr SCRIPT_PROPERTIES, piNumScripts: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetFontProperties*(hdc: HDC, psc: ptr SCRIPT_CACHE, sfp: ptr SCRIPT_FONTPROPERTIES): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptCacheGetHeight*(hdc: HDC, psc: ptr SCRIPT_CACHE, tmHeight: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringAnalyse*(hdc: HDC, pString: pointer, cString: int32, cGlyphs: int32, iCharset: int32, dwFlags: DWORD, iReqWidth: int32, psControl: ptr SCRIPT_CONTROL, psState: ptr SCRIPT_STATE, piDx: ptr int32, pTabdef: ptr SCRIPT_TABDEF, pbInClass: ptr BYTE, pssa: ptr SCRIPT_STRING_ANALYSIS): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringFree*(pssa: ptr SCRIPT_STRING_ANALYSIS): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptString_pSize*(ssa: SCRIPT_STRING_ANALYSIS): ptr SIZE {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptString_pcOutChars*(ssa: SCRIPT_STRING_ANALYSIS): ptr int32 {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptString_pLogAttr*(ssa: SCRIPT_STRING_ANALYSIS): ptr SCRIPT_LOGATTR {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringGetOrder*(ssa: SCRIPT_STRING_ANALYSIS, puOrder: ptr UINT): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringCPtoX*(ssa: SCRIPT_STRING_ANALYSIS, icp: int32, fTrailing: WINBOOL, pX: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringXtoCP*(ssa: SCRIPT_STRING_ANALYSIS, iX: int32, piCh: ptr int32, piTrailing: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringGetLogicalWidths*(ssa: SCRIPT_STRING_ANALYSIS, piDx: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringValidate*(ssa: SCRIPT_STRING_ANALYSIS): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptStringOut*(ssa: SCRIPT_STRING_ANALYSIS, iX: int32, iY: int32, uOptions: UINT, prc: ptr RECT, iMinSel: int32, iMaxSel: int32, fDisabled: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptIsComplex*(pwcInChars: ptr WCHAR, cInChars: int32, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptRecordDigitSubstitution*(Locale: LCID, psds: ptr SCRIPT_DIGITSUBSTITUTE): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptApplyDigitSubstitution*(psds: ptr SCRIPT_DIGITSUBSTITUTE, psc: ptr SCRIPT_CONTROL, pss: ptr SCRIPT_STATE): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptShapeOpenType*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, rcRangeChars: ptr int32, rpRangeProperties: ptr ptr TEXTRANGE_PROPERTIES, cRanges: int32, pwcChars: ptr WCHAR, cChars: int32, cMaxGlyphs: int32, pwLogClust: ptr WORD, pCharProps: ptr SCRIPT_CHARPROP, pwOutGlyphs: ptr WORD, pOutGlyphProps: ptr SCRIPT_GLYPHPROP, pcGlyphs: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptPlaceOpenType*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, rcRangeChars: ptr int32, rpRangeProperties: ptr ptr TEXTRANGE_PROPERTIES, cRanges: int32, pwcChars: ptr WCHAR, pwLogClust: ptr WORD, pCharProps: ptr SCRIPT_CHARPROP, cChars: int32, pwGlyphs: ptr WORD, pGlyphProps: ptr SCRIPT_GLYPHPROP, cGlyphs: int32, piAdvance: ptr int32, pGoffset: ptr GOFFSET, pABC: ptr ABC): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptItemizeOpenType*(pwcInChars: ptr WCHAR, cInChars: int32, cMaxItems: int32, psControl: ptr SCRIPT_CONTROL, psState: ptr SCRIPT_STATE, pItems: ptr SCRIPT_ITEM, pScriptTags: ptr OPENTYPE_TAG, pcItems: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetFontScriptTags*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, cMaxTags: int32, pScriptTags: ptr OPENTYPE_TAG, pcTags: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetFontLanguageTags*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, cMaxTags: int32, pLangsysTags: ptr OPENTYPE_TAG, pcTags: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetFontFeatureTags*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, cMaxTags: int32, pFeatureTags: ptr OPENTYPE_TAG, pcTags: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptGetFontAlternateGlyphs*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, tagFeature: OPENTYPE_TAG, wGlyphId: WORD, cMaxAlternates: int32, pAlternateGlyphs: ptr WORD, pcAlternates: ptr int32): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptSubstituteSingleGlyph*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, tagFeature: OPENTYPE_TAG, lParameter: LONG, wGlyphId: WORD, pwOutGlyphId: ptr WORD): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} +proc ScriptPositionSingleGlyph*(hdc: HDC, psc: ptr SCRIPT_CACHE, psa: ptr SCRIPT_ANALYSIS, tagScript: OPENTYPE_TAG, tagLangSys: OPENTYPE_TAG, tagFeature: OPENTYPE_TAG, lParameter: LONG, wGlyphId: WORD, iAdvance: int32, GOffset: GOFFSET, piOutAdvance: ptr int32, pOutGoffset: ptr GOFFSET): HRESULT {.winapi, stdcall, dynlib: "usp10", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/uxtheme.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/uxtheme.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,228 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wingdi +import commctrl +import shellapi +#include +type + BP_BUFFERFORMAT* = int32 + BP_ANIMATIONSTYLE* = int32 + WINDOWTHEMEATTRIBUTETYPE* = int32 + THEMESIZE* = int32 + PROPERTYORIGIN* = int32 + HPAINTBUFFER* = HANDLE + HANIMATIONBUFFER* = HANDLE + BP_PAINTPARAMS* {.pure.} = object + cbSize*: DWORD + dwFlags*: DWORD + prcExclude*: ptr RECT + pBlendFunction*: ptr BLENDFUNCTION + PBP_PAINTPARAMS* = ptr BP_PAINTPARAMS + BP_ANIMATIONPARAMS* {.pure.} = object + cbSize*: DWORD + dwFlags*: DWORD + style*: BP_ANIMATIONSTYLE + dwDuration*: DWORD + PBP_ANIMATIONPARAMS* = ptr BP_ANIMATIONPARAMS + WTA_OPTIONS* {.pure.} = object + dwFlags*: DWORD + dwMask*: DWORD + PWTA_OPTIONS* = ptr WTA_OPTIONS + DTT_CALLBACK_PROC* = proc (hdc: HDC, pszText: LPWSTR, cchText: int32, prc: LPRECT, dwFlags: UINT, lParam: LPARAM): int32 {.stdcall.} + DTTOPTS* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + crText*: COLORREF + crBorder*: COLORREF + crShadow*: COLORREF + iTextShadowType*: int32 + ptShadowOffset*: POINT + iBorderSize*: int32 + iFontPropId*: int32 + iColorPropId*: int32 + iStateId*: int32 + fApplyOverlay*: WINBOOL + iGlowSize*: int32 + pfnDrawTextCallback*: DTT_CALLBACK_PROC + lParam*: LPARAM + PDTTOPTS* = ptr DTTOPTS + MARGINS* {.pure.} = object + cxLeftWidth*: int32 + cxRightWidth*: int32 + cyTopHeight*: int32 + cyBottomHeight*: int32 + PMARGINS* = ptr MARGINS +const + MAX_INTLIST_COUNT* = 402 +type + INTLIST* {.pure.} = object + iValueCount*: int32 + iValues*: array[MAX_INTLIST_COUNT, int32] + PINTLIST* = ptr INTLIST + DTBGOPTS* {.pure.} = object + dwSize*: DWORD + dwFlags*: DWORD + rcClip*: RECT + PDTBGOPTS* = ptr DTBGOPTS +const + GBF_DIRECT* = 0x00000001 + GBF_COPY* = 0x00000002 + GBF_VALIDBITS* = GBF_DIRECT or GBF_COPY + BPBF_COMPATIBLEBITMAP* = 0 + BPBF_DIB* = 1 + BPBF_TOPDOWNDIB* = 2 + BPBF_TOPDOWNMONODIB* = 3 + BPPF_ERASE* = 0x00000001 + BPPF_NOCLIP* = 0x00000002 + BPPF_NONCLIENT* = 0x00000004 + BPAS_NONE* = 0 + BPAS_LINEAR* = 1 + BPAS_CUBIC* = 2 + BPAS_SINE* = 3 + WTA_NONCLIENT* = 1 + WTNCA_NODRAWCAPTION* = 0x00000001 + WTNCA_NODRAWICON* = 0x00000002 + WTNCA_NOSYSMENU* = 0x00000004 + WTNCA_NOMIRRORHELP* = 0x00000008 + WTNCA_VALIDBITS* = WTNCA_NODRAWCAPTION or WTNCA_NODRAWICON or WTNCA_NOSYSMENU or WTNCA_NOMIRRORHELP + OTD_FORCE_RECT_SIZING* = 0x00000001 + OTD_NONCLIENT* = 0x00000002 + OTD_VALIDBITS* = OTD_FORCE_RECT_SIZING or OTD_NONCLIENT + DTT_GRAYED* = 0x1 + DTT_TEXTCOLOR* = 1 shl 0 + DTT_BORDERCOLOR* = 1 shl 1 + DTT_SHADOWCOLOR* = 1 shl 2 + DTT_SHADOWTYPE* = 1 shl 3 + DTT_SHADOWOFFSET* = 1 shl 4 + DTT_BORDERSIZE* = 1 shl 5 + DTT_FONTPROP* = 1 shl 6 + DTT_COLORPROP* = 1 shl 7 + DTT_STATEID* = 1 shl 8 + DTT_CALCRECT* = 1 shl 9 + DTT_APPLYOVERLAY* = 1 shl 10 + DTT_GLOWSIZE* = 1 shl 11 + DTT_CALLBACK* = 1 shl 12 + DTT_COMPOSITED* = 1 shl 13 + DTT_VALIDBITS* = DTT_TEXTCOLOR or DTT_BORDERCOLOR or DTT_SHADOWCOLOR or DTT_SHADOWTYPE or DTT_SHADOWOFFSET or DTT_BORDERSIZE or DTT_FONTPROP or DTT_COLORPROP or DTT_STATEID or DTT_CALCRECT or DTT_APPLYOVERLAY or DTT_GLOWSIZE or DTT_COMPOSITED + TS_MIN* = 0 + TS_TRUE* = 1 + TS_DRAW* = 2 + HTTB_BACKGROUNDSEG* = 0x0000 + HTTB_FIXEDBORDER* = 0x0002 + HTTB_CAPTION* = 0x0004 + HTTB_RESIZINGBORDER_LEFT* = 0x0010 + HTTB_RESIZINGBORDER_TOP* = 0x0020 + HTTB_RESIZINGBORDER_RIGHT* = 0x0040 + HTTB_RESIZINGBORDER_BOTTOM* = 0x0080 + HTTB_RESIZINGBORDER* = HTTB_RESIZINGBORDER_LEFT or HTTB_RESIZINGBORDER_TOP or HTTB_RESIZINGBORDER_RIGHT or HTTB_RESIZINGBORDER_BOTTOM + HTTB_SIZINGTEMPLATE* = 0x0100 + HTTB_SYSTEMSIZINGMARGINS* = 0x0200 + PO_STATE* = 0 + PO_PART* = 1 + PO_CLASS* = 2 + PO_GLOBAL* = 3 + PO_NOTFOUND* = 4 + ETDT_DISABLE* = 0x00000001 + ETDT_ENABLE* = 0x00000002 + ETDT_USETABTEXTURE* = 0x00000004 + ETDT_ENABLETAB* = ETDT_ENABLE or ETDT_USETABTEXTURE + ETDT_USEAEROWIZARDTABTEXTURE* = 0x00000008 + ETDT_ENABLEAEROWIZARDTAB* = ETDT_ENABLE or ETDT_USEAEROWIZARDTABTEXTURE + ETDT_VALIDBITS* = ETDT_DISABLE or ETDT_ENABLE or ETDT_USETABTEXTURE or ETDT_USEAEROWIZARDTABTEXTURE + STAP_ALLOW_NONCLIENT* = 1 shl 0 + STAP_ALLOW_CONTROLS* = 1 shl 1 + STAP_ALLOW_WEBCONTENT* = 1 shl 2 + SZ_THDOCPROP_DISPLAYNAME* = "DisplayName" + SZ_THDOCPROP_CANONICALNAME* = "ThemeName" + SZ_THDOCPROP_TOOLTIP* = "ToolTip" + SZ_THDOCPROP_AUTHOR* = "author" + DTPB_WINDOWDC* = 0x00000001 + DTPB_USECTLCOLORSTATIC* = 0x00000002 + DTPB_USEERASEBKGND* = 0x00000004 + DTBG_CLIPRECT* = 0x00000001 + DTBG_DRAWSOLID* = 0x00000002 + DTBG_OMITBORDER* = 0x00000004 + DTBG_OMITCONTENT* = 0x00000008 + DTBG_COMPUTINGREGION* = 0x00000010 + DTBG_MIRRORDC* = 0x00000020 + DTBG_NOMIRROR* = 0x00000040 + DTBG_VALIDBITS* = DTBG_CLIPRECT or DTBG_DRAWSOLID or DTBG_OMITBORDER or DTBG_OMITCONTENT or DTBG_COMPUTINGREGION or DTBG_MIRRORDC or DTBG_NOMIRROR +proc BeginPanningFeedback*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc UpdatePanningFeedback*(hwnd: HWND, lTotalOverpanOffsetX: LONG, lTotalOverpanOffsetY: LONG, fInInertia: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc EndPanningFeedback*(hwnd: HWND, fAnimateBack: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeBitmap*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, dwFlags: ULONG, phBitmap: ptr HBITMAP): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeStream*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, ppvStream: ptr pointer, pcbStream: ptr DWORD, hInst: HINSTANCE): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeTransitionDuration*(hTheme: HTHEME, iPartId: int32, iStateIdFrom: int32, iStateIdTo: int32, iPropId: int32, pdwDuration: ptr DWORD): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BeginBufferedPaint*(hdcTarget: HDC, prcTarget: ptr RECT, dwFormat: BP_BUFFERFORMAT, pPaintParams: ptr BP_PAINTPARAMS, phdc: ptr HDC): HPAINTBUFFER {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc EndBufferedPaint*(hBufferedPaint: HPAINTBUFFER, fUpdateTarget: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetBufferedPaintTargetRect*(hBufferedPaint: HPAINTBUFFER, prc: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetBufferedPaintTargetDC*(hBufferedPaint: HPAINTBUFFER): HDC {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetBufferedPaintDC*(hBufferedPaint: HPAINTBUFFER): HDC {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetBufferedPaintBits*(hBufferedPaint: HPAINTBUFFER, ppbBuffer: ptr ptr RGBQUAD, pcxRow: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintClear*(hBufferedPaint: HPAINTBUFFER, prc: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintSetAlpha*(hBufferedPaint: HPAINTBUFFER, prc: ptr RECT, alpha: BYTE): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintInit*(): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintUnInit*(): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BeginBufferedAnimation*(hwnd: HWND, hdcTarget: HDC, rcTarget: ptr RECT, dwFormat: BP_BUFFERFORMAT, pPaintParams: ptr BP_PAINTPARAMS, pAnimationParams: ptr BP_ANIMATIONPARAMS, phdcFrom: ptr HDC, phdcTo: ptr HDC): HANIMATIONBUFFER {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc EndBufferedAnimation*(hbpAnimation: HANIMATIONBUFFER, fUpdateTarget: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintRenderAnimation*(hwnd: HWND, hdcTarget: HDC): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc BufferedPaintStopAllAnimations*(hwnd: HWND): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsCompositionActive*(): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc SetWindowThemeAttribute*(hwnd: HWND, eAttribute: WINDOWTHEMEATTRIBUTETYPE, pvAttribute: PVOID, cbAttribute: DWORD): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc OpenThemeData*(hwnd: HWND, pszClassList: LPCWSTR): HTHEME {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc OpenThemeDataEx*(hwnd: HWND, pszClassList: LPCWSTR, dwFlags: DWORD): HTHEME {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc CloseThemeData*(hTheme: HTHEME): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeBackground*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pRect: ptr RECT, pClipRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeText*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pszText: LPCWSTR, iCharCount: int32, dwTextFlags: DWORD, dwTextFlags2: DWORD, pRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeTextEx*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pszText: LPCWSTR, iCharCount: int32, dwFlags: DWORD, pRect: LPRECT, pOptions: ptr DTTOPTS): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeBackgroundContentRect*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pBoundingRect: ptr RECT, pContentRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeBackgroundExtent*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pContentRect: ptr RECT, pExtentRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemePartSize*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, prc: ptr RECT, eSize: THEMESIZE, psz: ptr SIZE): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeTextExtent*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pszText: LPCWSTR, iCharCount: int32, dwTextFlags: DWORD, pBoundingRect: ptr RECT, pExtentRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeTextMetrics*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, ptm: ptr TEXTMETRIC): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeBackgroundRegion*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pRect: ptr RECT, pRegion: ptr HRGN): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc HitTestThemeBackground*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, dwOptions: DWORD, pRect: ptr RECT, hrgn: HRGN, ptTest: POINT, pwHitTestCode: ptr WORD): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeEdge*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pDestRect: ptr RECT, uEdge: UINT, uFlags: UINT, pContentRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeIcon*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pRect: ptr RECT, himl: HIMAGELIST, iImageIndex: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsThemePartDefined*(hTheme: HTHEME, iPartId: int32, iStateId: int32): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsThemeBackgroundPartiallyTransparent*(hTheme: HTHEME, iPartId: int32, iStateId: int32): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeColor*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pColor: ptr COLORREF): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeMetric*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, iPropId: int32, piVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeString*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pszBuff: LPWSTR, cchMaxBuffChars: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeBool*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pfVal: ptr WINBOOL): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeInt*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, piVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeEnumValue*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, piVal: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemePosition*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pPoint: ptr POINT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeFont*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, iPropId: int32, pFont: ptr LOGFONTW): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeRect*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pRect: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeMargins*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, iPropId: int32, prc: ptr RECT, pMargins: ptr MARGINS): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeIntList*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pIntList: ptr INTLIST): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemePropertyOrigin*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pOrigin: ptr PROPERTYORIGIN): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc SetWindowTheme*(hwnd: HWND, pszSubAppName: LPCWSTR, pszSubIdList: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeFilename*(hTheme: HTHEME, iPartId: int32, iStateId: int32, iPropId: int32, pszThemeFileName: LPWSTR, cchMaxBuffChars: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysColor*(hTheme: HTHEME, iColorId: int32): COLORREF {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysColorBrush*(hTheme: HTHEME, iColorId: int32): HBRUSH {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysBool*(hTheme: HTHEME, iBoolId: int32): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysSize*(hTheme: HTHEME, iSizeId: int32): int32 {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysFont*(hTheme: HTHEME, iFontId: int32, plf: ptr LOGFONT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysString*(hTheme: HTHEME, iStringId: int32, pszStringBuff: LPWSTR, cchMaxStringChars: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeSysInt*(hTheme: HTHEME, iIntId: int32, piValue: ptr int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsThemeActive*(): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsAppThemed*(): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetWindowTheme*(hwnd: HWND): HTHEME {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc EnableThemeDialogTexture*(hwnd: HWND, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc IsThemeDialogTextureEnabled*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeAppProperties*(): DWORD {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc SetThemeAppProperties*(dwFlags: DWORD): void {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetCurrentThemeName*(pszThemeFileName: LPWSTR, cchMaxNameChars: int32, pszColorBuff: LPWSTR, cchMaxColorChars: int32, pszSizeBuff: LPWSTR, cchMaxSizeChars: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc GetThemeDocumentationProperty*(pszThemeName: LPCWSTR, pszPropertyName: LPCWSTR, pszValueBuff: LPWSTR, cchMaxValChars: int32): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeParentBackground*(hwnd: HWND, hdc: HDC, prc: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeParentBackgroundEx*(hwnd: HWND, hdc: HDC, dwFlags: DWORD, prc: ptr RECT): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc EnableTheming*(fEnable: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} +proc DrawThemeBackgroundEx*(hTheme: HTHEME, hdc: HDC, iPartId: int32, iStateId: int32, pRect: ptr RECT, pOptions: ptr DTBGOPTS): HRESULT {.winapi, stdcall, dynlib: "uxtheme", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/vfw.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/vfw.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,2038 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import wingdi +import winuser +import objbase +import commdlg +import mmsystem +#include +#include +type + HIC* = HANDLE + HDRAWDIB* = HANDLE + TWOCC* = WORD + HVIDEO* = HANDLE + HACMDRIVERID* = HANDLE + HACMDRIVER* = HANDLE + HACMSTREAM* = HANDLE + HACMOBJ* = HANDLE + COMPVARS* {.pure.} = object + cbSize*: LONG + dwFlags*: DWORD + hic*: HIC + fccType*: DWORD + fccHandler*: DWORD + lpbiIn*: LPBITMAPINFO + lpbiOut*: LPBITMAPINFO + lpBitsOut*: LPVOID + lpBitsPrev*: LPVOID + lFrame*: LONG + lKey*: LONG + lDataRate*: LONG + lQ*: LONG + lKeyCount*: LONG + lpState*: LPVOID + cbState*: LONG + PCOMPVARS* = ptr COMPVARS + TDRAWDIBTIME* {.pure.} = object + timeCount*: LONG + timeDraw*: LONG + timeDecompress*: LONG + timeDither*: LONG + timeStretch*: LONG + timeBlt*: LONG + timeSetDIBits*: LONG + LPDRAWDIBTIME* = ptr TDRAWDIBTIME + TAVISTREAMINFOW* {.pure.} = object + fccType*: DWORD + fccHandler*: DWORD + dwFlags*: DWORD + dwCaps*: DWORD + wPriority*: WORD + wLanguage*: WORD + dwScale*: DWORD + dwRate*: DWORD + dwStart*: DWORD + dwLength*: DWORD + dwInitialFrames*: DWORD + dwSuggestedBufferSize*: DWORD + dwQuality*: DWORD + dwSampleSize*: DWORD + rcFrame*: RECT + dwEditCount*: DWORD + dwFormatChangeCount*: DWORD + szName*: array[64, WCHAR] + LPAVISTREAMINFOW* = ptr TAVISTREAMINFOW + TAVISTREAMINFOA* {.pure.} = object + fccType*: DWORD + fccHandler*: DWORD + dwFlags*: DWORD + dwCaps*: DWORD + wPriority*: WORD + wLanguage*: WORD + dwScale*: DWORD + dwRate*: DWORD + dwStart*: DWORD + dwLength*: DWORD + dwInitialFrames*: DWORD + dwSuggestedBufferSize*: DWORD + dwQuality*: DWORD + dwSampleSize*: DWORD + rcFrame*: RECT + dwEditCount*: DWORD + dwFormatChangeCount*: DWORD + szName*: array[64, char] + LPAVISTREAMINFOA* = ptr TAVISTREAMINFOA + TAVIFILEINFOW* {.pure.} = object + dwMaxBytesPerSec*: DWORD + dwFlags*: DWORD + dwCaps*: DWORD + dwStreams*: DWORD + dwSuggestedBufferSize*: DWORD + dwWidth*: DWORD + dwHeight*: DWORD + dwScale*: DWORD + dwRate*: DWORD + dwLength*: DWORD + dwEditCount*: DWORD + szFileType*: array[64, WCHAR] + LPAVIFILEINFOW* = ptr TAVIFILEINFOW + TAVIFILEINFOA* {.pure.} = object + dwMaxBytesPerSec*: DWORD + dwFlags*: DWORD + dwCaps*: DWORD + dwStreams*: DWORD + dwSuggestedBufferSize*: DWORD + dwWidth*: DWORD + dwHeight*: DWORD + dwScale*: DWORD + dwRate*: DWORD + dwLength*: DWORD + dwEditCount*: DWORD + szFileType*: array[64, char] + LPAVIFILEINFOA* = ptr TAVIFILEINFOA + AVICOMPRESSOPTIONS* {.pure.} = object + fccType*: DWORD + fccHandler*: DWORD + dwKeyFrameEvery*: DWORD + dwQuality*: DWORD + dwBytesPerSecond*: DWORD + dwFlags*: DWORD + lpFormat*: LPVOID + cbFormat*: DWORD + lpParms*: LPVOID + cbParms*: DWORD + dwInterleaveEvery*: DWORD + LPAVICOMPRESSOPTIONS* = ptr AVICOMPRESSOPTIONS + IAVIStream* {.pure.} = object + lpVtbl*: ptr IAVIStreamVtbl + IAVIStreamVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Create*: proc(self: ptr IAVIStream, lParam1: LPARAM, lParam2: LPARAM): HRESULT {.stdcall.} + Info*: proc(self: ptr IAVIStream, psi: ptr TAVISTREAMINFOW, lSize: LONG): HRESULT {.stdcall.} + FindSample*: proc(self: ptr IAVIStream, lPos: LONG, lFlags: LONG): LONG {.stdcall.} + ReadFormat*: proc(self: ptr IAVIStream, lPos: LONG, lpFormat: LPVOID, lpcbFormat: ptr LONG): HRESULT {.stdcall.} + SetFormat*: proc(self: ptr IAVIStream, lPos: LONG, lpFormat: LPVOID, cbFormat: LONG): HRESULT {.stdcall.} + Read*: proc(self: ptr IAVIStream, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, plBytes: ptr LONG, plSamples: ptr LONG): HRESULT {.stdcall.} + Write*: proc(self: ptr IAVIStream, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, dwFlags: DWORD, plSampWritten: ptr LONG, plBytesWritten: ptr LONG): HRESULT {.stdcall.} + Delete*: proc(self: ptr IAVIStream, lStart: LONG, lSamples: LONG): HRESULT {.stdcall.} + ReadData*: proc(self: ptr IAVIStream, fcc: DWORD, lp: LPVOID, lpcb: ptr LONG): HRESULT {.stdcall.} + WriteData*: proc(self: ptr IAVIStream, fcc: DWORD, lp: LPVOID, cb: LONG): HRESULT {.stdcall.} + SetInfo*: proc(self: ptr IAVIStream, lpInfo: ptr TAVISTREAMINFOW, cbInfo: LONG): HRESULT {.stdcall.} + PAVISTREAM* = ptr IAVIStream + IAVIStreaming* {.pure.} = object + lpVtbl*: ptr IAVIStreamingVtbl + IAVIStreamingVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Begin*: proc(self: ptr IAVIStreaming, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {.stdcall.} + End*: proc(self: ptr IAVIStreaming): HRESULT {.stdcall.} + PAVISTREAMING* = ptr IAVIStreaming + IAVIEditStream* {.pure.} = object + lpVtbl*: ptr IAVIEditStreamVtbl + IAVIEditStreamVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Cut*: proc(self: ptr IAVIEditStream, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.stdcall.} + Copy*: proc(self: ptr IAVIEditStream, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.stdcall.} + Paste*: proc(self: ptr IAVIEditStream, plPos: ptr LONG, plLength: ptr LONG, pstream: PAVISTREAM, lStart: LONG, lEnd: LONG): HRESULT {.stdcall.} + Clone*: proc(self: ptr IAVIEditStream, ppResult: ptr PAVISTREAM): HRESULT {.stdcall.} + SetInfo*: proc(self: ptr IAVIEditStream, lpInfo: ptr TAVISTREAMINFOW, cbInfo: LONG): HRESULT {.stdcall.} + PAVIEDITSTREAM* = ptr IAVIEditStream + IAVIPersistFile* {.pure.} = object + lpVtbl*: ptr IAVIPersistFileVtbl + IAVIPersistFileVtbl* {.pure, inheritable.} = object of IPersistFileVtbl + Reserved1*: proc(self: ptr IAVIPersistFile): HRESULT {.stdcall.} + PAVIPERSISTFILE* = ptr IAVIPersistFile + IAVIFile* {.pure.} = object + lpVtbl*: ptr IAVIFileVtbl + IAVIFileVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Info*: proc(self: ptr IAVIFile, pfi: ptr TAVIFILEINFOW, lSize: LONG): HRESULT {.stdcall.} + GetStream*: proc(self: ptr IAVIFile, ppStream: ptr PAVISTREAM, fccType: DWORD, lParam: LONG): HRESULT {.stdcall.} + CreateStream*: proc(self: ptr IAVIFile, ppStream: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOW): HRESULT {.stdcall.} + WriteData*: proc(self: ptr IAVIFile, ckid: DWORD, lpData: LPVOID, cbData: LONG): HRESULT {.stdcall.} + ReadData*: proc(self: ptr IAVIFile, ckid: DWORD, lpData: LPVOID, lpcbData: ptr LONG): HRESULT {.stdcall.} + EndRecord*: proc(self: ptr IAVIFile): HRESULT {.stdcall.} + DeleteStream*: proc(self: ptr IAVIFile, fccType: DWORD, lParam: LONG): HRESULT {.stdcall.} + PAVIFILE* = ptr IAVIFile + IGetFrame* {.pure.} = object + lpVtbl*: ptr IGetFrameVtbl + IGetFrameVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetFrame*: proc(self: ptr IGetFrame, lPos: LONG): LPVOID {.stdcall.} + Begin*: proc(self: ptr IGetFrame, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {.stdcall.} + End*: proc(self: ptr IGetFrame): HRESULT {.stdcall.} + SetFormat*: proc(self: ptr IGetFrame, lpbi: LPBITMAPINFOHEADER, lpBits: LPVOID, x: int32, y: int32, dx: int32, dy: int32): HRESULT {.stdcall.} + PGETFRAME* = ptr IGetFrame + LPHVIDEO* = ptr HVIDEO + VIDEOHDR* {.pure.} = object + lpData*: LPBYTE + dwBufferLength*: DWORD + dwBytesUsed*: DWORD + dwTimeCaptured*: DWORD + dwUser*: DWORD_PTR + dwFlags*: DWORD + dwReserved*: array[4, DWORD_PTR] + PVIDEOHDR* = ptr VIDEOHDR + LPVIDEOHDR* = ptr VIDEOHDR + CHANNEL_CAPS* {.pure.} = object + dwFlags*: DWORD + dwSrcRectXMod*: DWORD + dwSrcRectYMod*: DWORD + dwSrcRectWidthMod*: DWORD + dwSrcRectHeightMod*: DWORD + dwDstRectXMod*: DWORD + dwDstRectYMod*: DWORD + dwDstRectWidthMod*: DWORD + dwDstRectHeightMod*: DWORD + PCHANNEL_CAPS* = ptr CHANNEL_CAPS + LPCHANNEL_CAPS* = ptr CHANNEL_CAPS + CAPDRIVERCAPS* {.pure.} = object + wDeviceIndex*: UINT + fHasOverlay*: WINBOOL + fHasDlgVideoSource*: WINBOOL + fHasDlgVideoFormat*: WINBOOL + fHasDlgVideoDisplay*: WINBOOL + fCaptureInitialized*: WINBOOL + fDriverSuppliesPalettes*: WINBOOL + hVideoIn*: HANDLE + hVideoOut*: HANDLE + hVideoExtIn*: HANDLE + hVideoExtOut*: HANDLE + PCAPDRIVERCAPS* = ptr CAPDRIVERCAPS + LPCAPDRIVERCAPS* = ptr CAPDRIVERCAPS + CAPSTATUS* {.pure.} = object + uiImageWidth*: UINT + uiImageHeight*: UINT + fLiveWindow*: WINBOOL + fOverlayWindow*: WINBOOL + fScale*: WINBOOL + ptScroll*: POINT + fUsingDefaultPalette*: WINBOOL + fAudioHardware*: WINBOOL + fCapFileExists*: WINBOOL + dwCurrentVideoFrame*: DWORD + dwCurrentVideoFramesDropped*: DWORD + dwCurrentWaveSamples*: DWORD + dwCurrentTimeElapsedMS*: DWORD + hPalCurrent*: HPALETTE + fCapturingNow*: WINBOOL + dwReturn*: DWORD + wNumVideoAllocated*: UINT + wNumAudioAllocated*: UINT + PCAPSTATUS* = ptr CAPSTATUS + LPCAPSTATUS* = ptr CAPSTATUS + CAPTUREPARMS* {.pure.} = object + dwRequestMicroSecPerFrame*: DWORD + fMakeUserHitOKToCapture*: WINBOOL + wPercentDropForError*: UINT + fYield*: WINBOOL + dwIndexSize*: DWORD + wChunkGranularity*: UINT + fUsingDOSMemory*: WINBOOL + wNumVideoRequested*: UINT + fCaptureAudio*: WINBOOL + wNumAudioRequested*: UINT + vKeyAbort*: UINT + fAbortLeftMouse*: WINBOOL + fAbortRightMouse*: WINBOOL + fLimitEnabled*: WINBOOL + wTimeLimit*: UINT + fMCIControl*: WINBOOL + fStepMCIDevice*: WINBOOL + dwMCIStartTime*: DWORD + dwMCIStopTime*: DWORD + fStepCaptureAt2x*: WINBOOL + wStepCaptureAverageFrames*: UINT + dwAudioBufferSize*: DWORD + fDisableWriteCache*: WINBOOL + AVStreamMaster*: UINT + PCAPTUREPARMS* = ptr CAPTUREPARMS + LPCAPTUREPARMS* = ptr CAPTUREPARMS + CAPINFOCHUNK* {.pure.} = object + fccInfoID*: FOURCC + lpData*: LPVOID + cbData*: LONG + PCAPINFOCHUNK* = ptr CAPINFOCHUNK + LPCAPINFOCHUNK* = ptr CAPINFOCHUNK + PHACMDRIVERID* = ptr HACMDRIVERID + LPHACMDRIVERID* = ptr HACMDRIVERID + PHACMDRIVER* = ptr HACMDRIVER + LPHACMDRIVER* = ptr HACMDRIVER + PHACMSTREAM* = ptr HACMSTREAM + LPHACMSTREAM* = ptr HACMSTREAM + PHACMOBJ* = ptr HACMOBJ + LPHACMOBJ* = ptr HACMOBJ + ACMDRIVERPROC* = proc (P1: DWORD_PTR, P2: HACMDRIVERID, P3: UINT, P4: LPARAM, P5: LPARAM): LRESULT {.stdcall.} + LPACMDRIVERPROC* = ptr ACMDRIVERPROC +const + ACMDRIVERDETAILS_SHORTNAME_CHARS* = 32 + ACMDRIVERDETAILS_LONGNAME_CHARS* = 128 + ACMDRIVERDETAILS_COPYRIGHT_CHARS* = 80 + ACMDRIVERDETAILS_LICENSING_CHARS* = 128 + ACMDRIVERDETAILS_FEATURES_CHARS* = 512 +type + ACMDRIVERDETAILSA* {.pure, packed.} = object + cbStruct*: DWORD + fccType*: FOURCC + fccComp*: FOURCC + wMid*: WORD + wPid*: WORD + vdwACM*: DWORD + vdwDriver*: DWORD + fdwSupport*: DWORD + cFormatTags*: DWORD + cFilterTags*: DWORD + hicon*: HICON + szShortName*: array[ACMDRIVERDETAILS_SHORTNAME_CHARS, char] + szLongName*: array[ACMDRIVERDETAILS_LONGNAME_CHARS, char] + szCopyright*: array[ACMDRIVERDETAILS_COPYRIGHT_CHARS, char] + szLicensing*: array[ACMDRIVERDETAILS_LICENSING_CHARS, char] + szFeatures*: array[ACMDRIVERDETAILS_FEATURES_CHARS, char] + PACMDRIVERDETAILSA* = ptr ACMDRIVERDETAILSA + LPACMDRIVERDETAILSA* = ptr ACMDRIVERDETAILSA + ACMDRIVERDETAILSW* {.pure, packed.} = object + cbStruct*: DWORD + fccType*: FOURCC + fccComp*: FOURCC + wMid*: WORD + wPid*: WORD + vdwACM*: DWORD + vdwDriver*: DWORD + fdwSupport*: DWORD + cFormatTags*: DWORD + cFilterTags*: DWORD + hicon*: HICON + szShortName*: array[ACMDRIVERDETAILS_SHORTNAME_CHARS, WCHAR] + szLongName*: array[ACMDRIVERDETAILS_LONGNAME_CHARS, WCHAR] + szCopyright*: array[ACMDRIVERDETAILS_COPYRIGHT_CHARS, WCHAR] + szLicensing*: array[ACMDRIVERDETAILS_LICENSING_CHARS, WCHAR] + szFeatures*: array[ACMDRIVERDETAILS_FEATURES_CHARS, WCHAR] + PACMDRIVERDETAILSW* = ptr ACMDRIVERDETAILSW + LPACMDRIVERDETAILSW* = ptr ACMDRIVERDETAILSW +const + ACMFORMATTAGDETAILS_FORMATTAG_CHARS* = 48 +type + ACMFORMATTAGDETAILSA* {.pure.} = object + cbStruct*: DWORD + dwFormatTagIndex*: DWORD + dwFormatTag*: DWORD + cbFormatSize*: DWORD + fdwSupport*: DWORD + cStandardFormats*: DWORD + szFormatTag*: array[ACMFORMATTAGDETAILS_FORMATTAG_CHARS, char] + PACMFORMATTAGDETAILSA* = ptr ACMFORMATTAGDETAILSA + LPACMFORMATTAGDETAILSA* = ptr ACMFORMATTAGDETAILSA + ACMFORMATTAGDETAILSW* {.pure.} = object + cbStruct*: DWORD + dwFormatTagIndex*: DWORD + dwFormatTag*: DWORD + cbFormatSize*: DWORD + fdwSupport*: DWORD + cStandardFormats*: DWORD + szFormatTag*: array[ACMFORMATTAGDETAILS_FORMATTAG_CHARS, WCHAR] + PACMFORMATTAGDETAILSW* = ptr ACMFORMATTAGDETAILSW + LPACMFORMATTAGDETAILSW* = ptr ACMFORMATTAGDETAILSW +const + ACMFORMATDETAILS_FORMAT_CHARS* = 128 +type + ACMFORMATDETAILSA* {.pure, packed.} = object + cbStruct*: DWORD + dwFormatIndex*: DWORD + dwFormatTag*: DWORD + fdwSupport*: DWORD + pwfx*: LPWAVEFORMATEX + cbwfx*: DWORD + szFormat*: array[ACMFORMATDETAILS_FORMAT_CHARS, char] + PACMFORMATDETAILSA* = ptr ACMFORMATDETAILSA + LPACMFORMATDETAILSA* = ptr ACMFORMATDETAILSA + ACMFORMATDETAILSW* {.pure, packed.} = object + cbStruct*: DWORD + dwFormatIndex*: DWORD + dwFormatTag*: DWORD + fdwSupport*: DWORD + pwfx*: LPWAVEFORMATEX + cbwfx*: DWORD + szFormat*: array[ACMFORMATDETAILS_FORMAT_CHARS, WCHAR] + PACMFORMATDETAILSW* = ptr ACMFORMATDETAILSW + LPACMFORMATDETAILSW* = ptr ACMFORMATDETAILSW + ACMFORMATCHOOSEHOOKPROCA* = proc (hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): UINT {.stdcall.} + ACMFORMATCHOOSEA* {.pure, packed.} = object + cbStruct*: DWORD + fdwStyle*: DWORD + hwndOwner*: HWND + pwfx*: LPWAVEFORMATEX + cbwfx*: DWORD + pszTitle*: LPCSTR + szFormatTag*: array[ACMFORMATTAGDETAILS_FORMATTAG_CHARS, char] + szFormat*: array[ACMFORMATDETAILS_FORMAT_CHARS, char] + pszName*: LPSTR + cchName*: DWORD + fdwEnum*: DWORD + pwfxEnum*: LPWAVEFORMATEX + hInstance*: HINSTANCE + pszTemplateName*: LPCSTR + lCustData*: LPARAM + pfnHook*: ACMFORMATCHOOSEHOOKPROCA + PACMFORMATCHOOSEA* = ptr ACMFORMATCHOOSEA + LPACMFORMATCHOOSEA* = ptr ACMFORMATCHOOSEA + ACMFORMATCHOOSEHOOKPROCW* = proc (hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): UINT {.stdcall.} + ACMFORMATCHOOSEW* {.pure, packed.} = object + cbStruct*: DWORD + fdwStyle*: DWORD + hwndOwner*: HWND + pwfx*: LPWAVEFORMATEX + cbwfx*: DWORD + pszTitle*: LPCWSTR + szFormatTag*: array[ACMFORMATTAGDETAILS_FORMATTAG_CHARS, WCHAR] + szFormat*: array[ACMFORMATDETAILS_FORMAT_CHARS, WCHAR] + pszName*: LPWSTR + cchName*: DWORD + fdwEnum*: DWORD + pwfxEnum*: LPWAVEFORMATEX + hInstance*: HINSTANCE + pszTemplateName*: LPCWSTR + lCustData*: LPARAM + pfnHook*: ACMFORMATCHOOSEHOOKPROCW + PACMFORMATCHOOSEW* = ptr ACMFORMATCHOOSEW + LPACMFORMATCHOOSEW* = ptr ACMFORMATCHOOSEW +const + ACMFILTERTAGDETAILS_FILTERTAG_CHARS* = 48 +type + ACMFILTERTAGDETAILSA* {.pure.} = object + cbStruct*: DWORD + dwFilterTagIndex*: DWORD + dwFilterTag*: DWORD + cbFilterSize*: DWORD + fdwSupport*: DWORD + cStandardFilters*: DWORD + szFilterTag*: array[ACMFILTERTAGDETAILS_FILTERTAG_CHARS, char] + PACMFILTERTAGDETAILSA* = ptr ACMFILTERTAGDETAILSA + LPACMFILTERTAGDETAILSA* = ptr ACMFILTERTAGDETAILSA + ACMFILTERTAGDETAILSW* {.pure.} = object + cbStruct*: DWORD + dwFilterTagIndex*: DWORD + dwFilterTag*: DWORD + cbFilterSize*: DWORD + fdwSupport*: DWORD + cStandardFilters*: DWORD + szFilterTag*: array[ACMFILTERTAGDETAILS_FILTERTAG_CHARS, WCHAR] + PACMFILTERTAGDETAILSW* = ptr ACMFILTERTAGDETAILSW + LPACMFILTERTAGDETAILSW* = ptr ACMFILTERTAGDETAILSW +const + ACMFILTERDETAILS_FILTER_CHARS* = 128 +type + ACMFILTERDETAILSA* {.pure, packed.} = object + cbStruct*: DWORD + dwFilterIndex*: DWORD + dwFilterTag*: DWORD + fdwSupport*: DWORD + pwfltr*: LPWAVEFILTER + cbwfltr*: DWORD + szFilter*: array[ACMFILTERDETAILS_FILTER_CHARS, char] + PACMFILTERDETAILSA* = ptr ACMFILTERDETAILSA + LPACMFILTERDETAILSA* = ptr ACMFILTERDETAILSA + ACMFILTERDETAILSW* {.pure, packed.} = object + cbStruct*: DWORD + dwFilterIndex*: DWORD + dwFilterTag*: DWORD + fdwSupport*: DWORD + pwfltr*: LPWAVEFILTER + cbwfltr*: DWORD + szFilter*: array[ACMFILTERDETAILS_FILTER_CHARS, WCHAR] + PACMFILTERDETAILSW* = ptr ACMFILTERDETAILSW + LPACMFILTERDETAILSW* = ptr ACMFILTERDETAILSW + ACMFILTERCHOOSEHOOKPROCA* = proc (hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): UINT {.stdcall.} + ACMFILTERCHOOSEA* {.pure, packed.} = object + cbStruct*: DWORD + fdwStyle*: DWORD + hwndOwner*: HWND + pwfltr*: LPWAVEFILTER + cbwfltr*: DWORD + pszTitle*: LPCSTR + szFilterTag*: array[ACMFILTERTAGDETAILS_FILTERTAG_CHARS, char] + szFilter*: array[ACMFILTERDETAILS_FILTER_CHARS, char] + pszName*: LPSTR + cchName*: DWORD + fdwEnum*: DWORD + pwfltrEnum*: LPWAVEFILTER + hInstance*: HINSTANCE + pszTemplateName*: LPCSTR + lCustData*: LPARAM + pfnHook*: ACMFILTERCHOOSEHOOKPROCA + PACMFILTERCHOOSEA* = ptr ACMFILTERCHOOSEA + LPACMFILTERCHOOSEA* = ptr ACMFILTERCHOOSEA + ACMFILTERCHOOSEHOOKPROCW* = proc (hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): UINT {.stdcall.} + ACMFILTERCHOOSEW* {.pure, packed.} = object + cbStruct*: DWORD + fdwStyle*: DWORD + hwndOwner*: HWND + pwfltr*: LPWAVEFILTER + cbwfltr*: DWORD + pszTitle*: LPCWSTR + szFilterTag*: array[ACMFILTERTAGDETAILS_FILTERTAG_CHARS, WCHAR] + szFilter*: array[ACMFILTERDETAILS_FILTER_CHARS, WCHAR] + pszName*: LPWSTR + cchName*: DWORD + fdwEnum*: DWORD + pwfltrEnum*: LPWAVEFILTER + hInstance*: HINSTANCE + pszTemplateName*: LPCWSTR + lCustData*: LPARAM + pfnHook*: ACMFILTERCHOOSEHOOKPROCW + PACMFILTERCHOOSEW* = ptr ACMFILTERCHOOSEW + LPACMFILTERCHOOSEW* = ptr ACMFILTERCHOOSEW +when winimCpu64: + const + VFW_DRVRESERVED* = 15 +when winimCpu32: + const + VFW_DRVRESERVED* = 10 +type + ACMSTREAMHEADER* {.pure, packed.} = object + cbStruct*: DWORD + fdwStatus*: DWORD + dwUser*: DWORD_PTR + pbSrc*: LPBYTE + cbSrcLength*: DWORD + cbSrcLengthUsed*: DWORD + dwSrcUser*: DWORD_PTR + pbDst*: LPBYTE + cbDstLength*: DWORD + cbDstLengthUsed*: DWORD + dwDstUser*: DWORD_PTR + dwReservedDriver*: array[VFW_DRVRESERVED, DWORD] + PACMSTREAMHEADER* = ptr ACMSTREAMHEADER + LPACMSTREAMHEADER* = ptr ACMSTREAMHEADER +const + ICVERSION* = 0x0104 + BI_1632* = 0x32333631 + ICERR_OK* = 0 + ICERR_DONTDRAW* = 1 + ICERR_NEWPALETTE* = 2 + ICERR_GOTOKEYFRAME* = 3 + ICERR_STOPDRAWING* = 4 + ICERR_UNSUPPORTED* = -1 + ICERR_BADFORMAT* = -2 + ICERR_MEMORY* = -3 + ICERR_INTERNAL* = -4 + ICERR_BADFLAGS* = -5 + ICERR_BADPARAM* = -6 + ICERR_BADSIZE* = -7 + ICERR_BADHANDLE* = -8 + ICERR_CANTUPDATE* = -9 + ICERR_ABORT* = -10 + ICERR_ERROR* = -100 + ICERR_BADBITDEPTH* = -200 + ICERR_BADIMAGESIZE* = -201 + ICERR_CUSTOM* = -400 + ICMODE_COMPRESS* = 1 + ICMODE_DECOMPRESS* = 2 + ICMODE_FASTDECOMPRESS* = 3 + ICMODE_QUERY* = 4 + ICMODE_FASTCOMPRESS* = 5 + ICMODE_DRAW* = 8 + AVIIF_LIST* = 0x00000001 + AVIIF_TWOCC* = 0x00000002 + AVIIF_KEYFRAME* = 0x00000010 + ICQUALITY_LOW* = 0 + ICQUALITY_HIGH* = 10000 + ICQUALITY_DEFAULT* = -1 + ICM_USER* = DRV_USER+0x0000 + ICM_RESERVED_LOW* = DRV_USER+0x1000 + ICM_RESERVED* = ICM_RESERVED_LOW + ICM_RESERVED_HIGH* = DRV_USER+0x2000 + ICM_GETSTATE* = ICM_RESERVED+0 + ICM_SETSTATE* = ICM_RESERVED+1 + ICM_GETINFO* = ICM_RESERVED+2 + ICM_CONFIGURE* = ICM_RESERVED+10 + ICM_ABOUT* = ICM_RESERVED+11 + ICM_GETERRORTEXT* = ICM_RESERVED+12 + ICM_GETFORMATNAME* = ICM_RESERVED+20 + ICM_ENUMFORMATS* = ICM_RESERVED+21 + ICM_GETDEFAULTQUALITY* = ICM_RESERVED+30 + ICM_GETQUALITY* = ICM_RESERVED+31 + ICM_SETQUALITY* = ICM_RESERVED+32 + ICM_SET* = ICM_RESERVED+40 + ICM_GET* = ICM_RESERVED+41 + ICM_FRAMERATE* = mmioFOURCC('F','r','m','R') + ICM_KEYFRAMERATE* = mmioFOURCC('K','e','y','R') + ICM_COMPRESS_GET_FORMAT* = ICM_USER+4 + ICM_COMPRESS_GET_SIZE* = ICM_USER+5 + ICM_COMPRESS_QUERY* = ICM_USER+6 + ICM_COMPRESS_BEGIN* = ICM_USER+7 + ICM_COMPRESS* = ICM_USER+8 + ICM_COMPRESS_END* = ICM_USER+9 + ICM_DECOMPRESS_GET_FORMAT* = ICM_USER+10 + ICM_DECOMPRESS_QUERY* = ICM_USER+11 + ICM_DECOMPRESS_BEGIN* = ICM_USER+12 + ICM_DECOMPRESS* = ICM_USER+13 + ICM_DECOMPRESS_END* = ICM_USER+14 + ICM_DECOMPRESS_SET_PALETTE* = ICM_USER+29 + ICM_DECOMPRESS_GET_PALETTE* = ICM_USER+30 + ICM_DRAW_QUERY* = ICM_USER+31 + ICM_DRAW_BEGIN* = ICM_USER+15 + ICM_DRAW_GET_PALETTE* = ICM_USER+16 + ICM_DRAW_UPDATE* = ICM_USER+17 + ICM_DRAW_START* = ICM_USER+18 + ICM_DRAW_STOP* = ICM_USER+19 + ICM_DRAW_BITS* = ICM_USER+20 + ICM_DRAW_END* = ICM_USER+21 + ICM_DRAW_GETTIME* = ICM_USER+32 + ICM_DRAW* = ICM_USER+33 + ICM_DRAW_WINDOW* = ICM_USER+34 + ICM_DRAW_SETTIME* = ICM_USER+35 + ICM_DRAW_REALIZE* = ICM_USER+36 + ICM_DRAW_FLUSH* = ICM_USER+37 + ICM_DRAW_RENDERBUFFER* = ICM_USER+38 + ICM_DRAW_START_PLAY* = ICM_USER+39 + ICM_DRAW_STOP_PLAY* = ICM_USER+40 + ICM_DRAW_SUGGESTFORMAT* = ICM_USER+50 + ICM_DRAW_CHANGEPALETTE* = ICM_USER+51 + ICM_DRAW_IDLE* = ICM_USER+52 + ICM_GETBUFFERSWANTED* = ICM_USER+41 + ICM_GETDEFAULTKEYFRAMERATE* = ICM_USER+42 + ICM_DECOMPRESSEX_BEGIN* = ICM_USER+60 + ICM_DECOMPRESSEX_QUERY* = ICM_USER+61 + ICM_DECOMPRESSEX* = ICM_USER+62 + ICM_DECOMPRESSEX_END* = ICM_USER+63 + ICM_COMPRESS_FRAMES_INFO* = ICM_USER+70 + ICM_COMPRESS_FRAMES* = ICM_USER+71 + ICM_SET_STATUS_PROC* = ICM_USER+72 + VIDCF_QUALITY* = 0x0001 + VIDCF_CRUNCH* = 0x0002 + VIDCF_TEMPORAL* = 0x0004 + VIDCF_COMPRESSFRAMES* = 0x0008 + VIDCF_DRAW* = 0x0010 + VIDCF_FASTTEMPORALC* = 0x0020 + VIDCF_QUALITYTIME* = 0x0040 + VIDCF_FASTTEMPORALD* = 0x0080 + VIDCF_FASTTEMPORAL* = VIDCF_FASTTEMPORALC or VIDCF_FASTTEMPORALD + ICCOMPRESS_KEYFRAME* = 0x00000001 + ICCOMPRESSFRAMES_PADDING* = 0x00000001 + ICSTATUS_START* = 0 + ICSTATUS_STATUS* = 1 + ICSTATUS_END* = 2 + ICSTATUS_ERROR* = 3 + ICSTATUS_YIELD* = 4 + ICDECOMPRESS_HURRYUP* = 0x80000000'i32 + ICDECOMPRESS_UPDATE* = 0x40000000 + ICDECOMPRESS_PREROLL* = 0x20000000 + ICDECOMPRESS_NULLFRAME* = 0x10000000 + ICDECOMPRESS_NOTKEYFRAME* = 0x08000000 + ICDRAW_QUERY* = 0x00000001 + ICDRAW_FULLSCREEN* = 0x00000002 + ICDRAW_HDC* = 0x00000004 + ICDRAW_ANIMATE* = 0x00000008 + ICDRAW_CONTINUE* = 0x00000010 + ICDRAW_MEMORYDC* = 0x00000020 + ICDRAW_UPDATING* = 0x00000040 + ICDRAW_RENDER* = 0x00000080 + ICDRAW_BUFFER* = 0x00000100 + ICDRAW_HURRYUP* = 0x80000000'i32 + ICDRAW_UPDATE* = 0x40000000 + ICDRAW_PREROLL* = 0x20000000 + ICDRAW_NULLFRAME* = 0x10000000 + ICDRAW_NOTKEYFRAME* = 0x08000000 + ICINSTALL_UNICODE* = 0x8000 + ICINSTALL_FUNCTION* = 0x0001 + ICINSTALL_DRIVER* = 0x0002 + ICINSTALL_HDRV* = 0x0004 + ICINSTALL_DRIVERW* = 0x8002 + ICMF_CONFIGURE_QUERY* = 0x00000001 + ICMF_ABOUT_QUERY* = 0x00000001 + ICMF_COMPVARS_VALID* = 0x00000001 + ICMF_CHOOSE_KEYFRAME* = 0x0001 + ICMF_CHOOSE_DATARATE* = 0x0002 + ICMF_CHOOSE_PREVIEW* = 0x0004 + ICMF_CHOOSE_ALLCOMPRESSORS* = 0x0008 + DDF_0001* = 0x0001 + DDF_UPDATE* = 0x0002 + DDF_SAME_HDC* = 0x0004 + DDF_SAME_DRAW* = 0x0008 + DDF_DONTDRAW* = 0x0010 + DDF_ANIMATE* = 0x0020 + DDF_BUFFER* = 0x0040 + DDF_JUSTDRAWIT* = 0x0080 + DDF_FULLSCREEN* = 0x0100 + DDF_BACKGROUNDPAL* = 0x0200 + DDF_NOTKEYFRAME* = 0x0400 + DDF_HURRYUP* = 0x0800 + DDF_HALFTONE* = 0x1000 + DDF_2000* = 0x2000 + DDF_PREROLL* = DDF_DONTDRAW + DDF_SAME_DIB* = DDF_SAME_DRAW + DDF_SAME_SIZE* = DDF_SAME_DRAW + PD_CAN_DRAW_DIB* = 0x0001 + PD_CAN_STRETCHDIB* = 0x0002 + PD_STRETCHDIB_1_1_OK* = 0x0004 + PD_STRETCHDIB_1_2_OK* = 0x0008 + PD_STRETCHDIB_1_N_OK* = 0x0010 + formtypeAVI* = mmioFOURCC('A','V','I',' ') + listtypeAVIHEADER* = mmioFOURCC('h','d','r','l') + ckidAVIMAINHDR* = mmioFOURCC('a','v','i','h') + listtypeSTREAMHEADER* = mmioFOURCC('s','t','r','l') + ckidSTREAMHEADER* = mmioFOURCC('s','t','r','h') + ckidSTREAMFORMAT* = mmioFOURCC('s','t','r','f') + ckidSTREAMHANDLERDATA* = mmioFOURCC('s','t','r','d') + ckidSTREAMNAME* = mmioFOURCC('s','t','r','n') + listtypeAVIMOVIE* = mmioFOURCC('m','o','v','i') + listtypeAVIRECORD* = mmioFOURCC('r','e','c',' ') + ckidAVINEWINDEX* = mmioFOURCC('i','d','x','1') + streamtypeANY* = 0 + streamtypeVIDEO* = mmioFOURCC('v','i','d','s') + streamtypeAUDIO* = mmioFOURCC('a','u','d','s') + streamtypeMIDI* = mmioFOURCC('m','i','d','s') + streamtypeTEXT* = mmioFOURCC('t','x','t','s') +template aviTWOCC*(c0: untyped, c1: untyped): untyped = c0.DWORD or (c1.DWORD shl 8) +const + cktypeDIBbits* = aviTWOCC('d','b') + cktypeDIBcompressed* = aviTWOCC('d','c') + cktypePALchange* = aviTWOCC('p','c') + cktypeWAVEbytes* = aviTWOCC('w','b') + ckidAVIPADDING* = mmioFOURCC('J','U','N','K') + AVIF_HASINDEX* = 0x00000010 + AVIF_MUSTUSEINDEX* = 0x00000020 + AVIF_ISINTERLEAVED* = 0x00000100 + AVIF_TRUSTCKTYPE* = 0x00000800 + AVIF_WASCAPTUREFILE* = 0x00010000 + AVIF_COPYRIGHTED* = 0x00020000 + AVI_HEADERSIZE* = 2048 + AVISF_DISABLED* = 0x00000001 + AVISF_VIDEO_PALCHANGES* = 0x00010000 + AVIIF_FIRSTPART* = 0x00000020 + AVIIF_LASTPART* = 0x00000040 + AVIIF_MIDPART* = AVIIF_LASTPART or AVIIF_FIRSTPART + AVIIF_NOTIME* = 0x00000100 + AVIIF_COMPUSE* = 0x0FFF0000 + AVIGETFRAMEF_BESTDISPLAYFMT* = 1 + AVISTREAMINFO_DISABLED* = 0x00000001 + AVISTREAMINFO_FORMATCHANGES* = 0x00010000 + AVIFILEINFO_HASINDEX* = 0x00000010 + AVIFILEINFO_MUSTUSEINDEX* = 0x00000020 + AVIFILEINFO_ISINTERLEAVED* = 0x00000100 + AVIFILEINFO_TRUSTCKTYPE* = 0x00000800 + AVIFILEINFO_WASCAPTUREFILE* = 0x00010000 + AVIFILEINFO_COPYRIGHTED* = 0x00020000 + AVIFILECAPS_CANREAD* = 0x00000001 + AVIFILECAPS_CANWRITE* = 0x00000002 + AVIFILECAPS_ALLKEYFRAMES* = 0x00000010 + AVIFILECAPS_NOCOMPRESSION* = 0x00000020 + AVICOMPRESSF_INTERLEAVE* = 0x00000001 + AVICOMPRESSF_DATARATE* = 0x00000002 + AVICOMPRESSF_KEYFRAMES* = 0x00000004 + AVICOMPRESSF_VALID* = 0x00000008 + IID_IAVIFile* = DEFINE_GUID("00020020-0000-0000-c000-000000000046") + IID_IAVIStream* = DEFINE_GUID("00020021-0000-0000-c000-000000000046") + IID_IAVIStreaming* = DEFINE_GUID("00020022-0000-0000-c000-000000000046") + IID_IGetFrame* = DEFINE_GUID("00020023-0000-0000-c000-000000000046") + IID_IAVIEditStream* = DEFINE_GUID("00020024-0000-0000-c000-000000000046") + IID_IAVIPersistFile* = DEFINE_GUID("00020025-0000-0000-c000-000000000046") + CLSID_AVIFile* = DEFINE_GUID("00020000-0000-0000-c000-000000000046") + AVIFILEHANDLER_CANREAD* = 0x0001 + AVIFILEHANDLER_CANWRITE* = 0x0002 + AVIFILEHANDLER_CANACCEPTNONRGB* = 0x0004 + AVISTREAMREAD_CONVENIENT* = -1 + FIND_DIR* = 0x0000000F + FIND_NEXT* = 0x00000001 + FIND_PREV* = 0x00000004 + VFW_FIND_FROM_START* = 0x00000008 + FIND_TYPE* = 0x000000F0 + FIND_KEY* = 0x00000010 + FIND_ANY* = 0x00000020 + FIND_FORMAT* = 0x00000040 + FIND_RET* = 0x0000F000 + FIND_POS* = 0x00000000 + FIND_LENGTH* = 0x00001000 + FIND_OFFSET* = 0x00002000 + FIND_SIZE* = 0x00003000 + FIND_INDEX* = 0x00004000 + SEARCH_NEAREST* = FIND_PREV + SEARCH_BACKWARD* = FIND_PREV + SEARCH_FORWARD* = FIND_NEXT + SEARCH_KEY* = FIND_KEY + SEARCH_ANY* = FIND_ANY + comptypeDIB* = mmioFOURCC('D','I','B',' ') + AVIERR_OK* = 0 +template MAKE_AVIERR*(error: untyped): SCODE = MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, error + 0x4000) +const + AVIERR_UNSUPPORTED* = MAKE_AVIERR(101) + AVIERR_BADFORMAT* = MAKE_AVIERR(102) + AVIERR_MEMORY* = MAKE_AVIERR(103) + AVIERR_INTERNAL* = MAKE_AVIERR(104) + AVIERR_BADFLAGS* = MAKE_AVIERR(105) + AVIERR_BADPARAM* = MAKE_AVIERR(106) + AVIERR_BADSIZE* = MAKE_AVIERR(107) + AVIERR_BADHANDLE* = MAKE_AVIERR(108) + AVIERR_FILEREAD* = MAKE_AVIERR(109) + AVIERR_FILEWRITE* = MAKE_AVIERR(110) + AVIERR_FILEOPEN* = MAKE_AVIERR(111) + AVIERR_COMPRESSOR* = MAKE_AVIERR(112) + AVIERR_NOCOMPRESSOR* = MAKE_AVIERR(113) + AVIERR_READONLY* = MAKE_AVIERR(114) + AVIERR_NODATA* = MAKE_AVIERR(115) + AVIERR_BUFFERTOOSMALL* = MAKE_AVIERR(116) + AVIERR_CANTCOMPRESS* = MAKE_AVIERR(117) + AVIERR_USERABORT* = MAKE_AVIERR(198) + AVIERR_ERROR* = MAKE_AVIERR(199) + MCIWND_WINDOW_CLASS* = "MCIWndClass" + MCIWNDOPENF_NEW* = 0x0001 + MCIWNDF_NOAUTOSIZEWINDOW* = 0x0001 + MCIWNDF_NOPLAYBAR* = 0x0002 + MCIWNDF_NOAUTOSIZEMOVIE* = 0x0004 + MCIWNDF_NOMENU* = 0x0008 + MCIWNDF_SHOWNAME* = 0x0010 + MCIWNDF_SHOWPOS* = 0x0020 + MCIWNDF_SHOWMODE* = 0x0040 + MCIWNDF_SHOWALL* = 0x0070 + MCIWNDF_NOTIFYMODE* = 0x0100 + MCIWNDF_NOTIFYPOS* = 0x0200 + MCIWNDF_NOTIFYSIZE* = 0x0400 + MCIWNDF_NOTIFYERROR* = 0x1000 + MCIWNDF_NOTIFYALL* = 0x1F00 + MCIWNDF_NOTIFYANSI* = 0x0080 + MCIWNDF_NOTIFYMEDIAA* = 0x0880 + MCIWNDF_NOTIFYMEDIAW* = 0x0800 + MCIWNDF_RECORD* = 0x2000 + MCIWNDF_NOERRORDLG* = 0x4000 + MCIWNDF_NOOPEN* = 0x8000 + MCIWNDM_GETDEVICEID* = WM_USER+100 + MCIWNDM_GETSTART* = WM_USER+103 + MCIWNDM_GETLENGTH* = WM_USER+104 + MCIWNDM_GETEND* = WM_USER+105 + MCIWNDM_EJECT* = WM_USER+107 + MCIWNDM_SETZOOM* = WM_USER+108 + MCIWNDM_GETZOOM* = WM_USER+109 + MCIWNDM_SETVOLUME* = WM_USER+110 + MCIWNDM_GETVOLUME* = WM_USER+111 + MCIWNDM_SETSPEED* = WM_USER+112 + MCIWNDM_GETSPEED* = WM_USER+113 + MCIWNDM_SETREPEAT* = WM_USER+114 + MCIWNDM_GETREPEAT* = WM_USER+115 + MCIWNDM_REALIZE* = WM_USER+118 + MCIWNDM_VALIDATEMEDIA* = WM_USER+121 + MCIWNDM_PLAYFROM* = WM_USER+122 + MCIWNDM_PLAYTO* = WM_USER+123 + MCIWNDM_GETPALETTE* = WM_USER+126 + MCIWNDM_SETPALETTE* = WM_USER+127 + MCIWNDM_SETTIMERS* = WM_USER+129 + MCIWNDM_SETACTIVETIMER* = WM_USER+130 + MCIWNDM_SETINACTIVETIMER* = WM_USER+131 + MCIWNDM_GETACTIVETIMER* = WM_USER+132 + MCIWNDM_GETINACTIVETIMER* = WM_USER+133 + MCIWNDM_CHANGESTYLES* = WM_USER+135 + MCIWNDM_GETSTYLES* = WM_USER+136 + MCIWNDM_GETALIAS* = WM_USER+137 + MCIWNDM_PLAYREVERSE* = WM_USER+139 + MCIWNDM_GET_SOURCE* = WM_USER+140 + MCIWNDM_PUT_SOURCE* = WM_USER+141 + MCIWNDM_GET_DEST* = WM_USER+142 + MCIWNDM_PUT_DEST* = WM_USER+143 + MCIWNDM_CAN_PLAY* = WM_USER+144 + MCIWNDM_CAN_WINDOW* = WM_USER+145 + MCIWNDM_CAN_RECORD* = WM_USER+146 + MCIWNDM_CAN_SAVE* = WM_USER+147 + MCIWNDM_CAN_EJECT* = WM_USER+148 + MCIWNDM_CAN_CONFIG* = WM_USER+149 + MCIWNDM_PALETTEKICK* = WM_USER+150 + MCIWNDM_OPENINTERFACE* = WM_USER+151 + MCIWNDM_SETOWNER* = WM_USER+152 + MCIWNDM_SENDSTRINGA* = WM_USER+101 + MCIWNDM_GETPOSITIONA* = WM_USER+102 + MCIWNDM_GETMODEA* = WM_USER+106 + MCIWNDM_SETTIMEFORMATA* = WM_USER+119 + MCIWNDM_GETTIMEFORMATA* = WM_USER+120 + MCIWNDM_GETFILENAMEA* = WM_USER+124 + MCIWNDM_GETDEVICEA* = WM_USER+125 + MCIWNDM_GETERRORA* = WM_USER+128 + MCIWNDM_NEWA* = WM_USER+134 + MCIWNDM_RETURNSTRINGA* = WM_USER+138 + MCIWNDM_OPENA* = WM_USER+153 + MCIWNDM_SENDSTRINGW* = WM_USER+201 + MCIWNDM_GETPOSITIONW* = WM_USER+202 + MCIWNDM_GETMODEW* = WM_USER+206 + MCIWNDM_SETTIMEFORMATW* = WM_USER+219 + MCIWNDM_GETTIMEFORMATW* = WM_USER+220 + MCIWNDM_GETFILENAMEW* = WM_USER+224 + MCIWNDM_GETDEVICEW* = WM_USER+225 + MCIWNDM_GETERRORW* = WM_USER+228 + MCIWNDM_NEWW* = WM_USER+234 + MCIWNDM_RETURNSTRINGW* = WM_USER+238 + MCIWNDM_OPENW* = WM_USER+252 + MCIWNDM_NOTIFYMODE* = WM_USER+200 + MCIWNDM_NOTIFYPOS* = WM_USER+201 + MCIWNDM_NOTIFYSIZE* = WM_USER+202 + MCIWNDM_NOTIFYMEDIA* = WM_USER+203 + MCIWNDM_NOTIFYERROR* = WM_USER+205 + MCIWND_START* = -1 + MCIWND_END* = -2 + DV_ERR_OK* = 0 + DV_ERR_BASE* = 1 + DV_ERR_NONSPECIFIC* = DV_ERR_BASE + DV_ERR_BADFORMAT* = DV_ERR_BASE+1 + DV_ERR_STILLPLAYING* = DV_ERR_BASE+2 + DV_ERR_UNPREPARED* = DV_ERR_BASE+3 + DV_ERR_SYNC* = DV_ERR_BASE+4 + DV_ERR_TOOMANYCHANNELS* = DV_ERR_BASE+5 + DV_ERR_NOTDETECTED* = DV_ERR_BASE+6 + DV_ERR_BADINSTALL* = DV_ERR_BASE+7 + DV_ERR_CREATEPALETTE* = DV_ERR_BASE+8 + DV_ERR_SIZEFIELD* = DV_ERR_BASE+9 + DV_ERR_PARAM1* = DV_ERR_BASE+10 + DV_ERR_PARAM2* = DV_ERR_BASE+11 + DV_ERR_CONFIG1* = DV_ERR_BASE+12 + DV_ERR_CONFIG2* = DV_ERR_BASE+13 + DV_ERR_FLAGS* = DV_ERR_BASE+14 + DV_ERR_13* = DV_ERR_BASE+15 + DV_ERR_NOTSUPPORTED* = DV_ERR_BASE+16 + DV_ERR_NOMEM* = DV_ERR_BASE+17 + DV_ERR_ALLOCATED* = DV_ERR_BASE+18 + DV_ERR_BADDEVICEID* = DV_ERR_BASE+19 + DV_ERR_INVALHANDLE* = DV_ERR_BASE+20 + DV_ERR_BADERRNUM* = DV_ERR_BASE+21 + DV_ERR_NO_BUFFERS* = DV_ERR_BASE+22 + DV_ERR_MEM_CONFLICT* = DV_ERR_BASE+23 + DV_ERR_IO_CONFLICT* = DV_ERR_BASE+24 + DV_ERR_DMA_CONFLICT* = DV_ERR_BASE+25 + DV_ERR_INT_CONFLICT* = DV_ERR_BASE+26 + DV_ERR_PROTECT_ONLY* = DV_ERR_BASE+27 + DV_ERR_LASTERROR* = DV_ERR_BASE+27 + DV_ERR_USER_MSG* = DV_ERR_BASE+1000 + DV_VM_OPEN* = MM_DRVM_OPEN + DV_VM_CLOSE* = MM_DRVM_CLOSE + DV_VM_DATA* = MM_DRVM_DATA + DV_VM_ERROR* = MM_DRVM_ERROR + VHDR_DONE* = 0x00000001 + VHDR_PREPARED* = 0x00000002 + VHDR_INQUEUE* = 0x00000004 + VHDR_KEYFRAME* = 0x00000008 + VHDR_VALID* = 0x0000000F + VCAPS_OVERLAY* = 0x00000001 + VCAPS_SRC_CAN_CLIP* = 0x00000002 + VCAPS_DST_CAN_CLIP* = 0x00000004 + VCAPS_CAN_SCALE* = 0x00000008 + VIDEO_EXTERNALIN* = 0x0001 + VIDEO_EXTERNALOUT* = 0x0002 + VIDEO_IN* = 0x0004 + VIDEO_OUT* = 0x0008 + VIDEO_DLG_QUERY* = 0x0010 + VIDEO_CONFIGURE_QUERY* = 0x8000 + VIDEO_CONFIGURE_SET* = 0x1000 + VIDEO_CONFIGURE_GET* = 0x2000 + VIDEO_CONFIGURE_QUERYSIZE* = 0x0001 + VIDEO_CONFIGURE_CURRENT* = 0x0010 + VIDEO_CONFIGURE_NOMINAL* = 0x0020 + VIDEO_CONFIGURE_MIN* = 0x0040 + VIDEO_CONFIGURE_MAX* = 0x0080 + DVM_USER* = 0X4000 + DVM_CONFIGURE_START* = 0x1000 + DVM_CONFIGURE_END* = 0x1FFF + DVM_PALETTE* = DVM_CONFIGURE_START+1 + DVM_FORMAT* = DVM_CONFIGURE_START+2 + DVM_PALETTERGB555* = DVM_CONFIGURE_START+3 + DVM_SRC_RECT* = DVM_CONFIGURE_START+4 + DVM_DST_RECT* = DVM_CONFIGURE_START+5 + WM_CAP_START* = WM_USER + WM_CAP_UNICODE_START* = WM_USER+100 + WM_CAP_GET_CAPSTREAMPTR* = WM_CAP_START+1 + WM_CAP_SET_CALLBACK_ERRORW* = WM_CAP_UNICODE_START+2 + WM_CAP_SET_CALLBACK_STATUSW* = WM_CAP_UNICODE_START+3 + WM_CAP_SET_CALLBACK_ERRORA* = WM_CAP_START+2 + WM_CAP_SET_CALLBACK_STATUSA* = WM_CAP_START+3 + WM_CAP_SET_CALLBACK_YIELD* = WM_CAP_START+4 + WM_CAP_SET_CALLBACK_FRAME* = WM_CAP_START+5 + WM_CAP_SET_CALLBACK_VIDEOSTREAM* = WM_CAP_START+6 + WM_CAP_SET_CALLBACK_WAVESTREAM* = WM_CAP_START+7 + WM_CAP_GET_USER_DATA* = WM_CAP_START+8 + WM_CAP_SET_USER_DATA* = WM_CAP_START+9 + WM_CAP_DRIVER_CONNECT* = WM_CAP_START+10 + WM_CAP_DRIVER_DISCONNECT* = WM_CAP_START+11 + WM_CAP_DRIVER_GET_NAMEA* = WM_CAP_START+12 + WM_CAP_DRIVER_GET_VERSIONA* = WM_CAP_START+13 + WM_CAP_DRIVER_GET_NAMEW* = WM_CAP_UNICODE_START+12 + WM_CAP_DRIVER_GET_VERSIONW* = WM_CAP_UNICODE_START+13 + WM_CAP_DRIVER_GET_CAPS* = WM_CAP_START+14 + WM_CAP_FILE_SET_CAPTURE_FILEA* = WM_CAP_START+20 + WM_CAP_FILE_GET_CAPTURE_FILEA* = WM_CAP_START+21 + WM_CAP_FILE_SAVEASA* = WM_CAP_START+23 + WM_CAP_FILE_SAVEDIBA* = WM_CAP_START+25 + WM_CAP_FILE_SET_CAPTURE_FILEW* = WM_CAP_UNICODE_START+20 + WM_CAP_FILE_GET_CAPTURE_FILEW* = WM_CAP_UNICODE_START+21 + WM_CAP_FILE_SAVEASW* = WM_CAP_UNICODE_START+23 + WM_CAP_FILE_SAVEDIBW* = WM_CAP_UNICODE_START+25 + WM_CAP_FILE_ALLOCATE* = WM_CAP_START+22 + WM_CAP_FILE_SET_INFOCHUNK* = WM_CAP_START+24 + WM_CAP_EDIT_COPY* = WM_CAP_START+30 + WM_CAP_SET_AUDIOFORMAT* = WM_CAP_START+35 + WM_CAP_GET_AUDIOFORMAT* = WM_CAP_START+36 + WM_CAP_DLG_VIDEOFORMAT* = WM_CAP_START+41 + WM_CAP_DLG_VIDEOSOURCE* = WM_CAP_START+42 + WM_CAP_DLG_VIDEODISPLAY* = WM_CAP_START+43 + WM_CAP_GET_VIDEOFORMAT* = WM_CAP_START+44 + WM_CAP_SET_VIDEOFORMAT* = WM_CAP_START+45 + WM_CAP_DLG_VIDEOCOMPRESSION* = WM_CAP_START+46 + WM_CAP_SET_PREVIEW* = WM_CAP_START+50 + WM_CAP_SET_OVERLAY* = WM_CAP_START+51 + WM_CAP_SET_PREVIEWRATE* = WM_CAP_START+52 + WM_CAP_SET_SCALE* = WM_CAP_START+53 + WM_CAP_GET_STATUS* = WM_CAP_START+54 + WM_CAP_SET_SCROLL* = WM_CAP_START+55 + WM_CAP_GRAB_FRAME* = WM_CAP_START+60 + WM_CAP_GRAB_FRAME_NOSTOP* = WM_CAP_START+61 + WM_CAP_SEQUENCE* = WM_CAP_START+62 + WM_CAP_SEQUENCE_NOFILE* = WM_CAP_START+63 + WM_CAP_SET_SEQUENCE_SETUP* = WM_CAP_START+64 + WM_CAP_GET_SEQUENCE_SETUP* = WM_CAP_START+65 + WM_CAP_SET_MCI_DEVICEA* = WM_CAP_START+66 + WM_CAP_GET_MCI_DEVICEA* = WM_CAP_START+67 + WM_CAP_SET_MCI_DEVICEW* = WM_CAP_UNICODE_START+66 + WM_CAP_GET_MCI_DEVICEW* = WM_CAP_UNICODE_START+67 + WM_CAP_STOP* = WM_CAP_START+68 + WM_CAP_ABORT* = WM_CAP_START+69 + WM_CAP_SINGLE_FRAME_OPEN* = WM_CAP_START+70 + WM_CAP_SINGLE_FRAME_CLOSE* = WM_CAP_START+71 + WM_CAP_SINGLE_FRAME* = WM_CAP_START+72 + WM_CAP_PAL_OPENA* = WM_CAP_START+80 + WM_CAP_PAL_SAVEA* = WM_CAP_START+81 + WM_CAP_PAL_OPENW* = WM_CAP_UNICODE_START+80 + WM_CAP_PAL_SAVEW* = WM_CAP_UNICODE_START+81 + WM_CAP_PAL_PASTE* = WM_CAP_START+82 + WM_CAP_PAL_AUTOCREATE* = WM_CAP_START+83 + WM_CAP_PAL_MANUALCREATE* = WM_CAP_START+84 + WM_CAP_SET_CALLBACK_CAPCONTROL* = WM_CAP_START+85 + WM_CAP_UNICODE_END* = WM_CAP_PAL_SAVEW + WM_CAP_END* = WM_CAP_UNICODE_END + AVSTREAMMASTER_AUDIO* = 0 + AVSTREAMMASTER_NONE* = 1 + CONTROLCALLBACK_PREROLL* = 1 + CONTROLCALLBACK_CAPTURING* = 2 + infotypeDIGITIZATION_TIME* = mmioFOURCC('I','D','I','T') + infotypeSMPTE_TIME* = mmioFOURCC('I','S','M','P') + IDS_CAP_BEGIN* = 300 + IDS_CAP_END* = 301 + IDS_CAP_INFO* = 401 + IDS_CAP_OUTOFMEM* = 402 + IDS_CAP_FILEEXISTS* = 403 + IDS_CAP_ERRORPALOPEN* = 404 + IDS_CAP_ERRORPALSAVE* = 405 + IDS_CAP_ERRORDIBSAVE* = 406 + IDS_CAP_DEFAVIEXT* = 407 + IDS_CAP_DEFPALEXT* = 408 + IDS_CAP_CANTOPEN* = 409 + IDS_CAP_SEQ_MSGSTART* = 410 + IDS_CAP_SEQ_MSGSTOP* = 411 + IDS_CAP_VIDEDITERR* = 412 + IDS_CAP_READONLYFILE* = 413 + IDS_CAP_WRITEERROR* = 414 + IDS_CAP_NODISKSPACE* = 415 + IDS_CAP_SETFILESIZE* = 416 + IDS_CAP_SAVEASPERCENT* = 417 + IDS_CAP_DRIVER_ERROR* = 418 + IDS_CAP_WAVE_OPEN_ERROR* = 419 + IDS_CAP_WAVE_ALLOC_ERROR* = 420 + IDS_CAP_WAVE_PREPARE_ERROR* = 421 + IDS_CAP_WAVE_ADD_ERROR* = 422 + IDS_CAP_WAVE_SIZE_ERROR* = 423 + IDS_CAP_VIDEO_OPEN_ERROR* = 424 + IDS_CAP_VIDEO_ALLOC_ERROR* = 425 + IDS_CAP_VIDEO_PREPARE_ERROR* = 426 + IDS_CAP_VIDEO_ADD_ERROR* = 427 + IDS_CAP_VIDEO_SIZE_ERROR* = 428 + IDS_CAP_FILE_OPEN_ERROR* = 429 + IDS_CAP_FILE_WRITE_ERROR* = 430 + IDS_CAP_RECORDING_ERROR* = 431 + IDS_CAP_RECORDING_ERROR2* = 432 + IDS_CAP_AVI_INIT_ERROR* = 433 + IDS_CAP_NO_FRAME_CAP_ERROR* = 434 + IDS_CAP_NO_PALETTE_WARN* = 435 + IDS_CAP_MCI_CONTROL_ERROR* = 436 + IDS_CAP_MCI_CANT_STEP_ERROR* = 437 + IDS_CAP_NO_AUDIO_CAP_ERROR* = 438 + IDS_CAP_AVI_DRAWDIB_ERROR* = 439 + IDS_CAP_COMPRESSOR_ERROR* = 440 + IDS_CAP_AUDIO_DROP_ERROR* = 441 + IDS_CAP_AUDIO_DROP_COMPERROR* = 442 + IDS_CAP_STAT_LIVE_MODE* = 500 + IDS_CAP_STAT_OVERLAY_MODE* = 501 + IDS_CAP_STAT_CAP_INIT* = 502 + IDS_CAP_STAT_CAP_FINI* = 503 + IDS_CAP_STAT_PALETTE_BUILD* = 504 + IDS_CAP_STAT_OPTPAL_BUILD* = 505 + IDS_CAP_STAT_I_FRAMES* = 506 + IDS_CAP_STAT_L_FRAMES* = 507 + IDS_CAP_STAT_CAP_L_FRAMES* = 508 + IDS_CAP_STAT_CAP_AUDIO* = 509 + IDS_CAP_STAT_VIDEOCURRENT* = 510 + IDS_CAP_STAT_VIDEOAUDIO* = 511 + IDS_CAP_STAT_VIDEOONLY* = 512 + IDS_CAP_STAT_FRAMESDROPPED* = 513 + DRV_MAPPER_PREFERRED_INPUT_GET* = DRV_USER+0 + DRV_MAPPER_PREFERRED_OUTPUT_GET* = DRV_USER+2 + DRVM_MAPPER* = 0x2000 + DRVM_MAPPER_STATUS* = DRVM_MAPPER+0 + WIDM_MAPPER_STATUS* = DRVM_MAPPER_STATUS+0 + WAVEIN_MAPPER_STATUS_DEVICE* = 0 + WAVEIN_MAPPER_STATUS_MAPPED* = 1 + WAVEIN_MAPPER_STATUS_FORMAT* = 2 + WODM_MAPPER_STATUS* = DRVM_MAPPER_STATUS+0 + WAVEOUT_MAPPER_STATUS_DEVICE* = 0 + WAVEOUT_MAPPER_STATUS_MAPPED* = 1 + WAVEOUT_MAPPER_STATUS_FORMAT* = 2 + ACMERR_BASE* = 512 + ACMERR_NOTPOSSIBLE* = ACMERR_BASE+0 + ACMERR_BUSY* = ACMERR_BASE+1 + ACMERR_UNPREPARED* = ACMERR_BASE+2 + ACMERR_CANCELED* = ACMERR_BASE+3 + MM_ACM_OPEN* = MM_STREAM_OPEN + MM_ACM_CLOSE* = MM_STREAM_CLOSE + MM_ACM_DONE* = MM_STREAM_DONE + ACM_METRIC_COUNT_DRIVERS* = 1 + ACM_METRIC_COUNT_CODECS* = 2 + ACM_METRIC_COUNT_CONVERTERS* = 3 + ACM_METRIC_COUNT_FILTERS* = 4 + ACM_METRIC_COUNT_DISABLED* = 5 + ACM_METRIC_COUNT_HARDWARE* = 6 + ACM_METRIC_COUNT_LOCAL_DRIVERS* = 20 + ACM_METRIC_COUNT_LOCAL_CODECS* = 21 + ACM_METRIC_COUNT_LOCAL_CONVERTERS* = 22 + ACM_METRIC_COUNT_LOCAL_FILTERS* = 23 + ACM_METRIC_COUNT_LOCAL_DISABLED* = 24 + ACM_METRIC_HARDWARE_WAVE_INPUT* = 30 + ACM_METRIC_HARDWARE_WAVE_OUTPUT* = 31 + ACM_METRIC_MAX_SIZE_FORMAT* = 50 + ACM_METRIC_MAX_SIZE_FILTER* = 51 + ACM_METRIC_DRIVER_SUPPORT* = 100 + ACM_METRIC_DRIVER_PRIORITY* = 101 + ACM_DRIVERENUMF_NOLOCAL* = 0x40000000 + ACM_DRIVERENUMF_DISABLED* = 0x80000000'i32 + ACM_DRIVERADDF_NAME* = 0x00000001 + ACM_DRIVERADDF_FUNCTION* = 0x00000003 + ACM_DRIVERADDF_NOTIFYHWND* = 0x00000004 + ACM_DRIVERADDF_TYPEMASK* = 0x00000007 + ACM_DRIVERADDF_LOCAL* = 0x00000000 + ACM_DRIVERADDF_GLOBAL* = 0x00000008 + ACMDM_USER* = DRV_USER+0x0000 + ACMDM_RESERVED_LOW* = DRV_USER+0x2000 + ACMDM_RESERVED_HIGH* = DRV_USER+0x2FFF + ACMDM_BASE* = ACMDM_RESERVED_LOW + ACMDM_DRIVER_ABOUT* = ACMDM_BASE+11 + ACM_DRIVERPRIORITYF_ENABLE* = 0x00000001 + ACM_DRIVERPRIORITYF_DISABLE* = 0x00000002 + ACM_DRIVERPRIORITYF_ABLEMASK* = 0x00000003 + ACM_DRIVERPRIORITYF_BEGIN* = 0x00010000 + ACM_DRIVERPRIORITYF_END* = 0x00020000 + ACM_DRIVERPRIORITYF_DEFERMASK* = 0x00030000 + ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC* = mmioFOURCC('a','u','d','c') + ACMDRIVERDETAILS_FCCCOMP_UNDEFINED* = mmioFOURCC('\0','\0','\0','\0') + ACMDRIVERDETAILS_SUPPORTF_CODEC* = 0x00000001 + ACMDRIVERDETAILS_SUPPORTF_CONVERTER* = 0x00000002 + ACMDRIVERDETAILS_SUPPORTF_FILTER* = 0x00000004 + ACMDRIVERDETAILS_SUPPORTF_HARDWARE* = 0x00000008 + ACMDRIVERDETAILS_SUPPORTF_ASYNC* = 0x00000010 + ACMDRIVERDETAILS_SUPPORTF_LOCAL* = 0x40000000 + ACMDRIVERDETAILS_SUPPORTF_DISABLED* = 0x80000000'i32 + ACM_FORMATTAGDETAILSF_INDEX* = 0x00000000 + ACM_FORMATTAGDETAILSF_FORMATTAG* = 0x00000001 + ACM_FORMATTAGDETAILSF_LARGESTSIZE* = 0x00000002 + ACM_FORMATTAGDETAILSF_QUERYMASK* = 0x0000000F + ACM_FORMATDETAILSF_INDEX* = 0x00000000 + ACM_FORMATDETAILSF_FORMAT* = 0x00000001 + ACM_FORMATDETAILSF_QUERYMASK* = 0x0000000F + ACM_FORMATENUMF_WFORMATTAG* = 0x00010000 + ACM_FORMATENUMF_NCHANNELS* = 0x00020000 + ACM_FORMATENUMF_NSAMPLESPERSEC* = 0x00040000 + ACM_FORMATENUMF_WBITSPERSAMPLE* = 0x00080000 + ACM_FORMATENUMF_CONVERT* = 0x00100000 + ACM_FORMATENUMF_SUGGEST* = 0x00200000 + ACM_FORMATENUMF_HARDWARE* = 0x00400000 + ACM_FORMATENUMF_INPUT* = 0x00800000 + ACM_FORMATENUMF_OUTPUT* = 0x01000000 + ACM_FORMATSUGGESTF_WFORMATTAG* = 0x00010000 + ACM_FORMATSUGGESTF_NCHANNELS* = 0x00020000 + ACM_FORMATSUGGESTF_NSAMPLESPERSEC* = 0x00040000 + ACM_FORMATSUGGESTF_WBITSPERSAMPLE* = 0x00080000 + ACM_FORMATSUGGESTF_TYPEMASK* = 0x00FF0000 + ACMHELPMSGSTRINGA* = "acmchoose_help" + ACMHELPMSGSTRINGW* = "acmchoose_help" + ACMHELPMSGCONTEXTMENUA* = "acmchoose_contextmenu" + ACMHELPMSGCONTEXTMENUW* = "acmchoose_contextmenu" + ACMHELPMSGCONTEXTHELPA* = "acmchoose_contexthelp" + ACMHELPMSGCONTEXTHELPW* = "acmchoose_contexthelp" + MM_ACM_FORMATCHOOSE* = 0x8000 + FORMATCHOOSE_MESSAGE* = 0 + FORMATCHOOSE_FORMATTAG_VERIFY* = FORMATCHOOSE_MESSAGE+0 + FORMATCHOOSE_FORMAT_VERIFY* = FORMATCHOOSE_MESSAGE+1 + FORMATCHOOSE_CUSTOM_VERIFY* = FORMATCHOOSE_MESSAGE+2 + ACMFORMATCHOOSE_STYLEF_SHOWHELP* = 0x00000004 + ACMFORMATCHOOSE_STYLEF_ENABLEHOOK* = 0x00000008 + ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE* = 0x00000010 + ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE* = 0x00000020 + ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT* = 0x00000040 + ACMFORMATCHOOSE_STYLEF_CONTEXTHELP* = 0x00000080 + ACM_FILTERTAGDETAILSF_INDEX* = 0x00000000 + ACM_FILTERTAGDETAILSF_FILTERTAG* = 0x00000001 + ACM_FILTERTAGDETAILSF_LARGESTSIZE* = 0x00000002 + ACM_FILTERTAGDETAILSF_QUERYMASK* = 0x0000000F + ACM_FILTERDETAILSF_INDEX* = 0x00000000 + ACM_FILTERDETAILSF_FILTER* = 0x00000001 + ACM_FILTERDETAILSF_QUERYMASK* = 0x0000000F + ACM_FILTERENUMF_DWFILTERTAG* = 0x00010000 + MM_ACM_FILTERCHOOSE* = 0x8000 + FILTERCHOOSE_MESSAGE* = 0 + FILTERCHOOSE_FILTERTAG_VERIFY* = FILTERCHOOSE_MESSAGE+0 + FILTERCHOOSE_FILTER_VERIFY* = FILTERCHOOSE_MESSAGE+1 + FILTERCHOOSE_CUSTOM_VERIFY* = FILTERCHOOSE_MESSAGE+2 + ACMFILTERCHOOSE_STYLEF_SHOWHELP* = 0x00000004 + ACMFILTERCHOOSE_STYLEF_ENABLEHOOK* = 0x00000008 + ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE* = 0x00000010 + ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE* = 0x00000020 + ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT* = 0x00000040 + ACMFILTERCHOOSE_STYLEF_CONTEXTHELP* = 0x00000080 + ACMSTREAMHEADER_STATUSF_DONE* = 0x00010000 + ACMSTREAMHEADER_STATUSF_PREPARED* = 0x00020000 + ACMSTREAMHEADER_STATUSF_INQUEUE* = 0x00100000 + ACM_STREAMOPENF_QUERY* = 0x00000001 + ACM_STREAMOPENF_ASYNC* = 0x00000002 + ACM_STREAMOPENF_NONREALTIME* = 0x00000004 + ACM_STREAMSIZEF_SOURCE* = 0x00000000 + ACM_STREAMSIZEF_DESTINATION* = 0x00000001 + ACM_STREAMSIZEF_QUERYMASK* = 0x0000000F + ACM_STREAMCONVERTF_BLOCKALIGN* = 0x00000004 + ACM_STREAMCONVERTF_START* = 0x00000010 + ACM_STREAMCONVERTF_END* = 0x00000020 +type + AVISAVECALLBACK* = proc (P1: int32): WINBOOL {.stdcall.} + CAPYIELDCALLBACK* = proc (hWnd: HWND): LRESULT {.stdcall.} + CAPSTATUSCALLBACKW* = proc (hWnd: HWND, nID: int32, lpsz: LPCWSTR): LRESULT {.stdcall.} + CAPERRORCALLBACKW* = proc (hWnd: HWND, nID: int32, lpsz: LPCWSTR): LRESULT {.stdcall.} + CAPSTATUSCALLBACKA* = proc (hWnd: HWND, nID: int32, lpsz: LPCSTR): LRESULT {.stdcall.} + CAPERRORCALLBACKA* = proc (hWnd: HWND, nID: int32, lpsz: LPCSTR): LRESULT {.stdcall.} + CAPVIDEOCALLBACK* = proc (hWnd: HWND, lpVHdr: LPVIDEOHDR): LRESULT {.stdcall.} + CAPWAVECALLBACK* = proc (hWnd: HWND, lpWHdr: LPWAVEHDR): LRESULT {.stdcall.} + CAPCONTROLCALLBACK* = proc (hWnd: HWND, nState: int32): LRESULT {.stdcall.} + ACMDRIVERENUMCB* = proc (hadid: HACMDRIVERID, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFORMATTAGENUMCBA* = proc (hadid: HACMDRIVERID, paftd: LPACMFORMATTAGDETAILSA, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFORMATTAGENUMCBW* = proc (hadid: HACMDRIVERID, paftd: LPACMFORMATTAGDETAILSW, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFORMATENUMCBA* = proc (hadid: HACMDRIVERID, pafd: LPACMFORMATDETAILSA, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFORMATENUMCBW* = proc (hadid: HACMDRIVERID, pafd: LPACMFORMATDETAILSW, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFILTERTAGENUMCBA* = proc (hadid: HACMDRIVERID, paftd: LPACMFILTERTAGDETAILSA, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFILTERTAGENUMCBW* = proc (hadid: HACMDRIVERID, paftd: LPACMFILTERTAGDETAILSW, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFILTERENUMCBA* = proc (hadid: HACMDRIVERID, pafd: LPACMFILTERDETAILSA, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + ACMFILTERENUMCBW* = proc (hadid: HACMDRIVERID, pafd: LPACMFILTERDETAILSW, dwInstance: DWORD_PTR, fdwSupport: DWORD): WINBOOL {.stdcall.} + TICOPEN* {.pure.} = object + dwSize*: DWORD + fccType*: DWORD + fccHandler*: DWORD + dwVersion*: DWORD + dwFlags*: DWORD + dwError*: LRESULT + pV1Reserved*: LPVOID + pV2Reserved*: LPVOID + dnDevNode*: DWORD + TICINFO* {.pure.} = object + dwSize*: DWORD + fccType*: DWORD + fccHandler*: DWORD + dwFlags*: DWORD + dwVersion*: DWORD + dwVersionICM*: DWORD + szName*: array[16, WCHAR] + szDescription*: array[128, WCHAR] + szDriver*: array[128, WCHAR] + TICCOMPRESS* {.pure.} = object + dwFlags*: DWORD + lpbiOutput*: LPBITMAPINFOHEADER + lpOutput*: LPVOID + lpbiInput*: LPBITMAPINFOHEADER + lpInput*: LPVOID + lpckid*: LPDWORD + lpdwFlags*: LPDWORD + lFrameNum*: LONG + dwFrameSize*: DWORD + dwQuality*: DWORD + lpbiPrev*: LPBITMAPINFOHEADER + lpPrev*: LPVOID + ICCOMPRESSFRAMES* {.pure.} = object + dwFlags*: DWORD + lpbiOutput*: LPBITMAPINFOHEADER + lOutput*: LPARAM + lpbiInput*: LPBITMAPINFOHEADER + lInput*: LPARAM + lStartFrame*: LONG + lFrameCount*: LONG + lQuality*: LONG + lDataRate*: LONG + lKeyRate*: LONG + dwRate*: DWORD + dwScale*: DWORD + dwOverheadPerFrame*: DWORD + dwReserved2*: DWORD + GetData*: proc(lInput: LPARAM, lFrame: LONG, lpBits: LPVOID, len: LONG): LONG {.stdcall.} + PutData*: proc(lOutput: LPARAM, lFrame: LONG, lpBits: LPVOID, len: LONG): LONG {.stdcall.} + ICSETSTATUSPROC* {.pure.} = object + dwFlags*: DWORD + lParam*: LPARAM + Status*: proc(lParam: LPARAM, message: UINT, l: LONG): LONG {.stdcall.} + TICDECOMPRESS* {.pure.} = object + dwFlags*: DWORD + lpbiInput*: LPBITMAPINFOHEADER + lpInput*: LPVOID + lpbiOutput*: LPBITMAPINFOHEADER + lpOutput*: LPVOID + ckid*: DWORD + ICDECOMPRESSEX* {.pure.} = object + dwFlags*: DWORD + lpbiSrc*: LPBITMAPINFOHEADER + lpSrc*: LPVOID + lpbiDst*: LPBITMAPINFOHEADER + lpDst*: LPVOID + xDst*: int32 + yDst*: int32 + dxDst*: int32 + dyDst*: int32 + xSrc*: int32 + ySrc*: int32 + dxSrc*: int32 + dySrc*: int32 + TICDRAWBEGIN* {.pure.} = object + dwFlags*: DWORD + hpal*: HPALETTE + hwnd*: HWND + hdc*: HDC + xDst*: int32 + yDst*: int32 + dxDst*: int32 + dyDst*: int32 + lpbi*: LPBITMAPINFOHEADER + xSrc*: int32 + ySrc*: int32 + dxSrc*: int32 + dySrc*: int32 + dwRate*: DWORD + dwScale*: DWORD + TICDRAW* {.pure.} = object + dwFlags*: DWORD + lpFormat*: LPVOID + lpData*: LPVOID + cbData*: DWORD + lTime*: LONG + ICDRAWSUGGEST* {.pure.} = object + lpbiIn*: LPBITMAPINFOHEADER + lpbiSuggest*: LPBITMAPINFOHEADER + dxSrc*: int32 + dySrc*: int32 + dxDst*: int32 + dyDst*: int32 + hicDecompressor*: HIC + ICPALETTE* {.pure.} = object + dwFlags*: DWORD + iStart*: int32 + iLen*: int32 + lppe*: LPPALETTEENTRY + MainAVIHeader* {.pure.} = object + dwMicroSecPerFrame*: DWORD + dwMaxBytesPerSec*: DWORD + dwPaddingGranularity*: DWORD + dwFlags*: DWORD + dwTotalFrames*: DWORD + dwInitialFrames*: DWORD + dwStreams*: DWORD + dwSuggestedBufferSize*: DWORD + dwWidth*: DWORD + dwHeight*: DWORD + dwReserved*: array[4, DWORD] + AVIStreamHeader* {.pure.} = object + fccType*: FOURCC + fccHandler*: FOURCC + dwFlags*: DWORD + wPriority*: WORD + wLanguage*: WORD + dwInitialFrames*: DWORD + dwScale*: DWORD + dwRate*: DWORD + dwStart*: DWORD + dwLength*: DWORD + dwSuggestedBufferSize*: DWORD + dwQuality*: DWORD + dwSampleSize*: DWORD + rcFrame*: RECT + AVIINDEXENTRY* {.pure.} = object + ckid*: DWORD + dwFlags*: DWORD + dwChunkOffset*: DWORD + dwChunkLength*: DWORD + AVIPALCHANGE* {.pure.} = object + bFirstEntry*: BYTE + bNumEntries*: BYTE + wFlags*: WORD + peNew*: UncheckedArray[PALETTEENTRY] +proc VideoForWindowsVersion*(): DWORD {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICInfo*(fccType: DWORD, fccHandler: DWORD, lpicinfo: ptr TICINFO): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICInstall*(fccType: DWORD, fccHandler: DWORD, lParam: LPARAM, szDesc: LPSTR, wFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICRemove*(fccType: DWORD, fccHandler: DWORD, wFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICGetInfo*(hic: HIC, picinfo: ptr TICINFO, cb: DWORD): LRESULT {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICOpen*(fccType: DWORD, fccHandler: DWORD, wMode: UINT): HIC {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICOpenFunction*(fccType: DWORD, fccHandler: DWORD, wMode: UINT, lpfnHandler: FARPROC): HIC {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICClose*(hic: HIC): LRESULT {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICSendMessage*(hic: HIC, msg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR): LRESULT {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICCompress*(hic: HIC, dwFlags: DWORD, lpbiOutput: LPBITMAPINFOHEADER, lpData: LPVOID, lpbiInput: LPBITMAPINFOHEADER, lpBits: LPVOID, lpckid: LPDWORD, lpdwFlags: LPDWORD, lFrameNum: LONG, dwFrameSize: DWORD, dwQuality: DWORD, lpbiPrev: LPBITMAPINFOHEADER, lpPrev: LPVOID): DWORD {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc ICDecompress*(hic: HIC, dwFlags: DWORD, lpbiFormat: LPBITMAPINFOHEADER, lpData: LPVOID, lpbi: LPBITMAPINFOHEADER, lpBits: LPVOID): DWORD {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc ICDrawBegin*(hic: HIC, dwFlags: DWORD, hpal: HPALETTE, hwnd: HWND, hdc: HDC, xDst: int32, yDst: int32, dxDst: int32, dyDst: int32, lpbi: LPBITMAPINFOHEADER, xSrc: int32, ySrc: int32, dxSrc: int32, dySrc: int32, dwRate: DWORD, dwScale: DWORD): DWORD {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc ICDraw*(hic: HIC, dwFlags: DWORD, lpFormat: LPVOID, lpData: LPVOID, cbData: DWORD, lTime: LONG): DWORD {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc ICLocate*(fccType: DWORD, fccHandler: DWORD, lpbiIn: LPBITMAPINFOHEADER, lpbiOut: LPBITMAPINFOHEADER, wFlags: WORD): HIC {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICGetDisplayFormat*(hic: HIC, lpbiIn: LPBITMAPINFOHEADER, lpbiOut: LPBITMAPINFOHEADER, BitDepth: int32, dx: int32, dy: int32): HIC {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICImageCompress*(hic: HIC, uiFlags: UINT, lpbiIn: LPBITMAPINFO, lpBits: LPVOID, lpbiOut: LPBITMAPINFO, lQuality: LONG, plSize: ptr LONG): HANDLE {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICImageDecompress*(hic: HIC, uiFlags: UINT, lpbiIn: LPBITMAPINFO, lpBits: LPVOID, lpbiOut: LPBITMAPINFO): HANDLE {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICCompressorChoose*(hwnd: HWND, uiFlags: UINT, pvIn: LPVOID, lpData: LPVOID, pc: PCOMPVARS, lpszTitle: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICSeqCompressFrameStart*(pc: PCOMPVARS, lpbiIn: LPBITMAPINFO): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICSeqCompressFrameEnd*(pc: PCOMPVARS): void {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICSeqCompressFrame*(pc: PCOMPVARS, uiFlags: UINT, lpBits: LPVOID, pfKey: ptr WINBOOL, plSize: ptr LONG): LPVOID {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc ICCompressorFree*(pc: PCOMPVARS): void {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibOpen*(): HDRAWDIB {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibClose*(hdd: HDRAWDIB): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibGetBuffer*(hdd: HDRAWDIB, lpbi: LPBITMAPINFOHEADER, dwSize: DWORD, dwFlags: DWORD): LPVOID {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibGetPalette*(hdd: HDRAWDIB): HPALETTE {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibSetPalette*(hdd: HDRAWDIB, hpal: HPALETTE): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibChangePalette*(hdd: HDRAWDIB, iStart: int32, iLen: int32, lppe: LPPALETTEENTRY): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibRealize*(hdd: HDRAWDIB, hdc: HDC, fBackground: WINBOOL): UINT {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibStart*(hdd: HDRAWDIB, rate: DWORD): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibStop*(hdd: HDRAWDIB): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibBegin*(hdd: HDRAWDIB, hdc: HDC, dxDst: int32, dyDst: int32, lpbi: LPBITMAPINFOHEADER, dxSrc: int32, dySrc: int32, wFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibDraw*(hdd: HDRAWDIB, hdc: HDC, xDst: int32, yDst: int32, dxDst: int32, dyDst: int32, lpbi: LPBITMAPINFOHEADER, lpBits: LPVOID, xSrc: int32, ySrc: int32, dxSrc: int32, dySrc: int32, wFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibEnd*(hdd: HDRAWDIB): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibTime*(hdd: HDRAWDIB, lpddtime: LPDRAWDIBTIME): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc DrawDibProfileDisplay*(lpbi: LPBITMAPINFOHEADER): LRESULT {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc StretchDIB*(biDst: LPBITMAPINFOHEADER, lpDst: LPVOID, DstX: int32, DstY: int32, DstXE: int32, DstYE: int32, biSrc: LPBITMAPINFOHEADER, lpSrc: LPVOID, SrcX: int32, SrcY: int32, SrcXE: int32, SrcYE: int32): void {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc AVIFileInit*(): void {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileExit*(): void {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileAddRef*(pfile: PAVIFILE): ULONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileRelease*(pfile: PAVIFILE): ULONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileOpenA*(ppfile: ptr PAVIFILE, szFile: LPCSTR, uMode: UINT, lpHandler: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileOpenW*(ppfile: ptr PAVIFILE, szFile: LPCWSTR, uMode: UINT, lpHandler: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileInfoW*(pfile: PAVIFILE, pfi: LPAVIFILEINFOW, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileInfoA*(pfile: PAVIFILE, pfi: LPAVIFILEINFOA, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileGetStream*(pfile: PAVIFILE, ppavi: ptr PAVISTREAM, fccType: DWORD, lParam: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileCreateStreamW*(pfile: PAVIFILE, ppavi: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOW): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileCreateStreamA*(pfile: PAVIFILE, ppavi: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOA): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileWriteData*(pfile: PAVIFILE, ckid: DWORD, lpData: LPVOID, cbData: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileReadData*(pfile: PAVIFILE, ckid: DWORD, lpData: LPVOID, lpcbData: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIFileEndRecord*(pfile: PAVIFILE): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamAddRef*(pavi: PAVISTREAM): ULONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamRelease*(pavi: PAVISTREAM): ULONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamInfoW*(pavi: PAVISTREAM, psi: LPAVISTREAMINFOW, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamInfoA*(pavi: PAVISTREAM, psi: LPAVISTREAMINFOA, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamFindSample*(pavi: PAVISTREAM, lPos: LONG, lFlags: LONG): LONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamReadFormat*(pavi: PAVISTREAM, lPos: LONG, lpFormat: LPVOID, lpcbFormat: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamSetFormat*(pavi: PAVISTREAM, lPos: LONG, lpFormat: LPVOID, cbFormat: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamReadData*(pavi: PAVISTREAM, fcc: DWORD, lp: LPVOID, lpcb: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamWriteData*(pavi: PAVISTREAM, fcc: DWORD, lp: LPVOID, cb: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamRead*(pavi: PAVISTREAM, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, plBytes: ptr LONG, plSamples: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamWrite*(pavi: PAVISTREAM, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, dwFlags: DWORD, plSampWritten: ptr LONG, plBytesWritten: ptr LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamStart*(pavi: PAVISTREAM): LONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamLength*(pavi: PAVISTREAM): LONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamTimeToSample*(pavi: PAVISTREAM, lTime: LONG): LONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamSampleToTime*(pavi: PAVISTREAM, lSample: LONG): LONG {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamBeginStreaming*(pavi: PAVISTREAM, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamEndStreaming*(pavi: PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamGetFrameOpen*(pavi: PAVISTREAM, lpbiWanted: LPBITMAPINFOHEADER): PGETFRAME {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamGetFrame*(pg: PGETFRAME, lPos: LONG): LPVOID {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamGetFrameClose*(pg: PGETFRAME): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamOpenFromFileA*(ppavi: ptr PAVISTREAM, szFile: LPCSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamOpenFromFileW*(ppavi: ptr PAVISTREAM, szFile: LPCWSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamCreate*(ppavi: ptr PAVISTREAM, lParam1: LONG, lParam2: LONG, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIStreamFindKeyFrame*(pavi: PAVISTREAM, lPos: LONG, lFlags: LONG): LONG {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamFindSample".} +proc AVIStreamClose*(pavi: PAVISTREAM): ULONG {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamRelease".} +proc AVIFileClose*(pfile: PAVIFILE): ULONG {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileRelease".} +proc AVIStreamInit*(): void {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileInit".} +proc AVIStreamExit*(): void {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileExit".} +proc AVIMakeCompressedStream*(ppsCompressed: ptr PAVISTREAM, ppsSource: PAVISTREAM, lpOptions: ptr AVICOMPRESSOPTIONS, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVISaveVA*(szFile: LPCSTR, pclsidHandler: ptr CLSID, lpfnCallback: AVISAVECALLBACK, nStreams: int32, ppavi: ptr PAVISTREAM, plpOptions: ptr LPAVICOMPRESSOPTIONS): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVISaveVW*(szFile: LPCWSTR, pclsidHandler: ptr CLSID, lpfnCallback: AVISAVECALLBACK, nStreams: int32, ppavi: ptr PAVISTREAM, plpOptions: ptr LPAVICOMPRESSOPTIONS): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVISaveOptions*(hwnd: HWND, uiFlags: UINT, nStreams: int32, ppavi: ptr PAVISTREAM, plpOptions: ptr LPAVICOMPRESSOPTIONS): INT_PTR {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVISaveOptionsFree*(nStreams: int32, plpOptions: ptr LPAVICOMPRESSOPTIONS): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIBuildFilterW*(lpszFilter: LPWSTR, cbFilter: LONG, fSaving: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIBuildFilterA*(lpszFilter: LPSTR, cbFilter: LONG, fSaving: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIMakeFileFromStreams*(ppfile: ptr PAVIFILE, nStreams: int32, papStreams: ptr PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIMakeStreamFromClipboard*(cfFormat: UINT, hGlobal: HANDLE, ppstream: ptr PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIPutFileOnClipboard*(pf: PAVIFILE): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIGetFromClipboard*(lppf: ptr PAVIFILE): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc AVIClearClipboard*(): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc CreateEditableStream*(ppsEditable: ptr PAVISTREAM, psSource: PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamCut*(pavi: PAVISTREAM, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamCopy*(pavi: PAVISTREAM, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamPaste*(pavi: PAVISTREAM, plPos: ptr LONG, plLength: ptr LONG, pstream: PAVISTREAM, lStart: LONG, lEnd: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamClone*(pavi: PAVISTREAM, ppResult: ptr PAVISTREAM): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamSetNameA*(pavi: PAVISTREAM, lpszName: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamSetNameW*(pavi: PAVISTREAM, lpszName: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamSetInfoW*(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOW, cbInfo: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc EditStreamSetInfoA*(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOA, cbInfo: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc.} +proc MCIWndCreateA*(hwndParent: HWND, hInstance: HINSTANCE, dwStyle: DWORD, szFile: LPCSTR): HWND {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc MCIWndCreateW*(hwndParent: HWND, hInstance: HINSTANCE, dwStyle: DWORD, szFile: LPCWSTR): HWND {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc MCIWndRegisterClass*(): WINBOOL {.winapi, cdecl, dynlib: "msvfw32", importc.} +proc capCreateCaptureWindowA*(lpszWindowName: LPCSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hwndParent: HWND, nID: int32): HWND {.winapi, stdcall, dynlib: "avicap32", importc.} +proc capGetDriverDescriptionA*(wDriverIndex: UINT, lpszName: LPSTR, cbName: int32, lpszVer: LPSTR, cbVer: int32): WINBOOL {.winapi, stdcall, dynlib: "avicap32", importc.} +proc capCreateCaptureWindowW*(lpszWindowName: LPCWSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hwndParent: HWND, nID: int32): HWND {.winapi, stdcall, dynlib: "avicap32", importc.} +proc capGetDriverDescriptionW*(wDriverIndex: UINT, lpszName: LPWSTR, cbName: int32, lpszVer: LPWSTR, cbVer: int32): WINBOOL {.winapi, stdcall, dynlib: "avicap32", importc.} +proc acmGetVersion*(): DWORD {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmMetrics*(hao: HACMOBJ, uMetric: UINT, pMetric: LPVOID): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverEnum*(fnCallback: ACMDRIVERENUMCB, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverID*(hao: HACMOBJ, phadid: LPHACMDRIVERID, fdwDriverID: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverAddA*(phadid: LPHACMDRIVERID, hinstModule: HINSTANCE, lParam: LPARAM, dwPriority: DWORD, fdwAdd: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverAddW*(phadid: LPHACMDRIVERID, hinstModule: HINSTANCE, lParam: LPARAM, dwPriority: DWORD, fdwAdd: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverRemove*(hadid: HACMDRIVERID, fdwRemove: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverOpen*(phad: LPHACMDRIVER, hadid: HACMDRIVERID, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverClose*(had: HACMDRIVER, fdwClose: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverMessage*(had: HACMDRIVER, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM): LRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverPriority*(hadid: HACMDRIVERID, dwPriority: DWORD, fdwPriority: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverDetailsA*(hadid: HACMDRIVERID, padd: LPACMDRIVERDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmDriverDetailsW*(hadid: HACMDRIVERID, padd: LPACMDRIVERDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatTagDetailsA*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatTagDetailsW*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatTagEnumA*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSA, fnCallback: ACMFORMATTAGENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatTagEnumW*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSW, fnCallback: ACMFORMATTAGENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatDetailsA*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatDetailsW*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatEnumA*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSA, fnCallback: ACMFORMATENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatEnumW*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSW, fnCallback: ACMFORMATENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatSuggest*(had: HACMDRIVER, pwfxSrc: LPWAVEFORMATEX, pwfxDst: LPWAVEFORMATEX, cbwfxDst: DWORD, fdwSuggest: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatChooseA*(pafmtc: LPACMFORMATCHOOSEA): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFormatChooseW*(pafmtc: LPACMFORMATCHOOSEW): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterTagDetailsA*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterTagDetailsW*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterTagEnumA*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSA, fnCallback: ACMFILTERTAGENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterTagEnumW*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSW, fnCallback: ACMFILTERTAGENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterDetailsA*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterDetailsW*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterEnumA*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSA, fnCallback: ACMFILTERENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterEnumW*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSW, fnCallback: ACMFILTERENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterChooseA*(pafltrc: LPACMFILTERCHOOSEA): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmFilterChooseW*(pafltrc: LPACMFILTERCHOOSEW): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamOpen*(phas: LPHACMSTREAM, had: HACMDRIVER, pwfxSrc: LPWAVEFORMATEX, pwfxDst: LPWAVEFORMATEX, pwfltr: LPWAVEFILTER, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamClose*(has: HACMSTREAM, fdwClose: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamSize*(has: HACMSTREAM, cbInput: DWORD, pdwOutputBytes: LPDWORD, fdwSize: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamReset*(has: HACMSTREAM, fdwReset: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamMessage*(has: HACMSTREAM, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamConvert*(has: HACMSTREAM, pash: LPACMSTREAMHEADER, fdwConvert: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamPrepareHeader*(has: HACMSTREAM, pash: LPACMSTREAMHEADER, fdwPrepare: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc acmStreamUnprepareHeader*(has: HACMSTREAM, pash: LPACMSTREAMHEADER, fdwUnprepare: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc.} +proc GetOpenFileNamePreviewA*(lpofn: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc GetSaveFileNamePreviewA*(lpofn: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc GetOpenFileNamePreviewW*(lpofn: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +proc GetSaveFileNamePreviewW*(lpofn: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc.} +template MCIWndCanPlay*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_PLAY, 0, 0) +template MCIWndCanRecord*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_RECORD, 0, 0) +template MCIWndCanSave*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_SAVE, 0, 0) +template MCIWndCanWindow*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_WINDOW, 0, 0) +template MCIWndCanEject*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_EJECT, 0, 0) +template MCIWndCanConfig*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_CAN_CONFIG, 0, 0) +template MCIWndPaletteKick*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_PALETTEKICK, 0, 0) +template MCIWndSave*(hwnd: HWND, szFile: PCWSTR): LONG = discardable LONG SendMessage(hwnd, MCI_SAVE, 0, cast[LPARAM](szFile)) +template MCIWndSaveDialog*(hwnd: HWND): LONG = discardable MCIWndSave(hwnd, cast[PCWSTR](-1)) +when winimUnicode: + const + MCIWNDM_NEW* = MCIWNDM_NEWW +when winimAnsi: + const + MCIWNDM_NEW* = MCIWNDM_NEWA +template MCIWndNew*(hwnd: HWND, lp: LPVOID): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_NEW, 0, cast[LPARAM](lp)) +template MCIWndRecord*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_RECORD, 0, 0) +when winimUnicode: + const + MCIWNDM_OPEN* = MCIWNDM_OPENW +when winimAnsi: + const + MCIWNDM_OPEN* = MCIWNDM_OPENA +template MCIWndOpen*(hwnd: HWND, sz: LPVOID, f: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_OPEN, cast[WPARAM](f), cast[LPARAM](sz)) +template MCIWndOpenDialog*(hwnd: HWND): LONG = discardable MCIWndOpen(hwnd, cast[LPVOID](-1), 0) +template MCIWndClose*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_CLOSE, 0, 0) +template MCIWndPlay*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_PLAY, 0, 0) +template MCIWndStop*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_STOP, 0, 0) +template MCIWndPause*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_PAUSE, 0, 0) +template MCIWndResume*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCI_RESUME, 0, 0) +template MCIWndSeek*(hwnd: HWND, lPos: LONG): LONG = discardable LONG SendMessage(hwnd, MCI_SEEK, 0, cast[LPARAM](lPos)) +template MCIWndEject*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_EJECT, 0, 0) +template MCIWndHome*(hwnd: HWND): LONG = discardable MCIWndSeek(hwnd, MCIWND_START) +template MCIWndToEnd*(hwnd: HWND): LONG = discardable MCIWndSeek(hwnd, MCIWND_END) +template MCIWndGetSource*(hwnd: HWND, prc: LPRECT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GET_SOURCE, 0, cast[LPARAM](prc)) +template MCIWndPutSource*(hwnd: HWND, prc: LPRECT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_PUT_SOURCE, 0, cast[LPARAM](prc)) +template MCIWndGetDest*(hwnd: HWND, prc: LPRECT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GET_DEST, 0, cast[LPARAM](prc)) +template MCIWndPutDest*(hwnd: HWND, prc: LPRECT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_PUT_DEST, 0, cast[LPARAM](prc)) +template MCIWndPlayReverse*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_PLAYREVERSE, 0, 0) +template MCIWndPlayFrom*(hwnd: HWND, lPos: LONG): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_PLAYFROM, 0, cast[LPARAM](lPos)) +template MCIWndPlayTo*(hwnd: HWND, lPos: LONG): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_PLAYTO, 0, cast[LPARAM](lPos)) +template MCIWndPlayFromTo*(hwnd: HWND, lStart: LONG, lEnd: LONG): LONG = MCIWndSeek(hwnd, lStart); discardable MCIWndPlayTo(hwnd, lEnd) +template MCIWndGetDeviceID*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETDEVICEID, 0, 0) +template MCIWndGetAlias*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETALIAS, 0, 0) +when winimUnicode: + const + MCIWNDM_GETMODE* = MCIWNDM_GETMODEW +when winimAnsi: + const + MCIWNDM_GETMODE* = MCIWNDM_GETMODEA +template MCIWndGetMode*(hwnd: HWND, lp: LPTSTR, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETMODE, cast[WPARAM](L), cast[LPARAM](lp)) +when winimUnicode: + const + MCIWNDM_GETPOSITION* = MCIWNDM_GETPOSITIONW +when winimAnsi: + const + MCIWNDM_GETPOSITION* = MCIWNDM_GETPOSITIONA +template MCIWndGetPosition*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETPOSITION, 0, 0) +template MCIWndGetPositionString*(hwnd: HWND, lp: LPTSTR, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETPOSITION, cast[WPARAM](L), cast[LPARAM](lp)) +template MCIWndGetStart*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETSTART, 0, 0) +template MCIWndGetLength*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETLENGTH, 0, 0) +template MCIWndGetEnd*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETEND, 0, 0) +template MCIWndStep*(hwnd: HWND, n: LONG): LONG = discardable LONG SendMessage(hwnd, MCI_STEP, 0, cast[LPARAM](n)) +template MCIWndDestroy*(hwnd: HWND): void = SendMessage(hwnd, WM_CLOSE, 0, 0) +template MCIWndSetZoom*(hwnd: HWND, iZoom: UINT): void = SendMessage(hwnd, MCIWNDM_SETZOOM, 0, cast[LPARAM](iZoom)) +template MCIWndGetZoom*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETZOOM, 0, 0) +template MCIWndSetVolume*(hwnd: HWND, iVol: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SETVOLUME, 0, cast[LPARAM](iVol)) +template MCIWndGetVolume*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETVOLUME, 0, 0) +template MCIWndSetSpeed*(hwnd: HWND, iSpeed: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SETSPEED, 0, cast[LPARAM](iSpeed)) +template MCIWndGetSpeed*(hwnd: HWND): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETSPEED, 0, 0) +when winimUnicode: + const + MCIWNDM_SETTIMEFORMAT* = MCIWNDM_SETTIMEFORMATW +when winimAnsi: + const + MCIWNDM_SETTIMEFORMAT* = MCIWNDM_SETTIMEFORMATA +template MCIWndSetTimeFormat*(hwnd: HWND, lp: LPTSTR): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SETTIMEFORMAT, 0, cast[LPARAM](lp)) +when winimUnicode: + const + MCIWNDM_GETTIMEFORMAT* = MCIWNDM_GETTIMEFORMATW +when winimAnsi: + const + MCIWNDM_GETTIMEFORMAT* = MCIWNDM_GETTIMEFORMATA +template MCIWndGetTimeFormat*(hwnd: HWND, lp: LPTSTR, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETTIMEFORMAT, cast[WPARAM](L), cast[LPARAM](lp)) +template MCIWndValidateMedia*(hwnd: HWND): void = SendMessage(hwnd, MCIWNDM_VALIDATEMEDIA, 0, 0) +template MCIWndSetRepeat*(hwnd: HWND, f: BOOL): void = SendMessage(hwnd, MCIWNDM_SETREPEAT, 0, cast[LPARAM](f)) +template MCIWndGetRepeat*(hwnd: HWND): BOOL = discardable BOOL SendMessage(hwnd, MCIWNDM_GETREPEAT, 0, 0) +template MCIWndSetActiveTimer*(hwnd: HWND, active: UINT): void = SendMessage(hwnd, MCIWNDM_SETACTIVETIMER, cast[WPARAM](active), 0) +template MCIWndSetInactiveTimer*(hwnd: HWND, inactive: UINT): void = SendMessage(hwnd, MCIWNDM_SETINACTIVETIMER, cast[WPARAM](inactive), 0) +template MCIWndSetTimers*(hwnd: HWND, active: UINT, inactive: UINT): void = SendMessage(hwnd, MCIWNDM_SETTIMERS, cast[WPARAM](active), cast[LPARAM](inactive)) +template MCIWndGetActiveTimer*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETACTIVETIMER, 0, 0) +template MCIWndGetInactiveTimer*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETINACTIVETIMER, 0, 0) +template MCIWndRealize*(hwnd: HWND, fBkgnd: BOOL): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_REALIZE, cast[WPARAM](fBkgnd), 0) +when winimUnicode: + const + MCIWNDM_SENDSTRING* = MCIWNDM_SENDSTRINGW +when winimAnsi: + const + MCIWNDM_SENDSTRING* = MCIWNDM_SENDSTRINGA +template MCIWndSendString*(hwnd: HWND, sz: LPTSTR): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SENDSTRING, 0, cast[LPARAM](sz)) +when winimUnicode: + const + MCIWNDM_RETURNSTRING* = MCIWNDM_RETURNSTRINGW +when winimAnsi: + const + MCIWNDM_RETURNSTRING* = MCIWNDM_RETURNSTRINGA +template MCIWndReturnString*(hwnd: HWND, lp: LPVOID, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_RETURNSTRING, cast[WPARAM](L), cast[LPARAM](lp)) +when winimUnicode: + const + MCIWNDM_GETERROR* = MCIWNDM_GETERRORW +when winimAnsi: + const + MCIWNDM_GETERROR* = MCIWNDM_GETERRORA +template MCIWndGetError*(hwnd: HWND, lp: LPVOID, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETERROR, cast[WPARAM](L), cast[LPARAM](lp)) +template MCIWndGetPalette*(hwnd: HWND): HPALETTE = discardable HPALETTE SendMessage(hwnd, MCIWNDM_GETPALETTE, 0, 0) +template MCIWndSetPalette*(hwnd: HWND, hpal: HPALETTE): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SETPALETTE, cast[WPARAM](hpal), 0) +when winimUnicode: + const + MCIWNDM_GETFILENAME* = MCIWNDM_GETFILENAMEW +when winimAnsi: + const + MCIWNDM_GETFILENAME* = MCIWNDM_GETFILENAMEA +template MCIWndGetFileName*(hwnd: HWND, lp: LPVOID, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETFILENAME, cast[WPARAM](L), cast[LPARAM](lp)) +when winimUnicode: + const + MCIWNDM_GETDEVICE* = MCIWNDM_GETDEVICEW +when winimAnsi: + const + MCIWNDM_GETDEVICE* = MCIWNDM_GETDEVICEA +template MCIWndGetDevice*(hwnd: HWND, lp: LPVOID, L: UINT): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_GETDEVICE, cast[WPARAM](L), cast[LPARAM](lp)) +template MCIWndGetStyles*(hwnd: HWND): UINT = discardable UINT SendMessage(hwnd, MCIWNDM_GETSTYLES, 0, 0) +template MCIWndChangeStyles*(hwnd: HWND, mask: UINT, value: LONG): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_CHANGESTYLES, cast[WPARAM](mask), cast[LPARAM](value)) +template MCIWndOpenInterface*(hwnd: HWND, pUnk): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_OPENINTERFACE, 0, cast[LPARAM](pUnk)) +template MCIWndSetOwner*(hwnd: HWND, hwndP): LONG = discardable LONG SendMessage(hwnd, MCIWNDM_SETOWNER, cast[WPARAM](hwndP), 0) +template ICQueryAbout*(hic: HIC): bool = discardable ICSendMessage(hic, ICM_ABOUT, cast[DWORD_PTR](-1), ICMF_ABOUT_QUERY) == ICERR_OK +template ICAbout*(hic: HIC, hwnd: HWND): LRESULT = discardable ICSendMessage(hic, ICM_ABOUT, cast[DWORD_PTR](hwnd), 0) +template ICQueryConfigure*(hic: HIC): bool = discardable ICSendMessage(hic, ICM_CONFIGURE, cast[DWORD_PTR](-1), ICMF_CONFIGURE_QUERY) == ICERR_OK +template ICConfigure*(hic: HIC, hwnd: HWND): LRESULT = discardable ICSendMessage(hic, ICM_CONFIGURE, cast[DWORD_PTR](hwnd), 0) +template ICGetState*(hic: HIC, pv: LPVOID, cb: DWORD_PTR): LRESULT = discardable ICSendMessage(hic, ICM_GETSTATE, cast[DWORD_PTR](pv), cb) +template ICSetState*(hic: HIC, pv: LPVOID, cb: DWORD_PTR): LRESULT = discardable ICSendMessage(hic, ICM_SETSTATE, cast[DWORD_PTR](pv), cb) +template ICGetStateSize*(hic: HIC): DWORD = discardable DWORD ICGetState(hic, 0, 0) +template ICDrawWindow*(hic: HIC, prc: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_WINDOW, cast[DWORD_PTR](prc), cast[DWORD_PTR](sizeof(RECT))) +template ICCompressBegin*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_COMPRESS_BEGIN, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICCompressQuery*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_COMPRESS_QUERY, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICCompressGetFormat*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICCompressGetFormatSize*(hic: HIC, lpbi: LPVOID): DWORD = discardable DWORD ICCompressGetFormat(hic, lpbi, nil) +template ICCompressGetSize*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): DWORD = discardable DWORD ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICCompressEnd*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_COMPRESS_END, 0, 0) +template ICDecompressBegin*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICDecompressQuery*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESS_QUERY, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICDecompressGetFormat*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LONG = discardable LONG ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICDecompressGetFormatSize*(hic: HIC, lpbi: LPVOID): LRESULT = discardable ICDecompressGetFormat(hic, lpbi, nil) +template ICDecompressGetPalette*(hic: HIC, lpbiInput: LPVOID, lpbiOutput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, cast[DWORD_PTR](lpbiInput), cast[DWORD_PTR](lpbiOutput)) +template ICDecompressSetPalette*(hic: HIC, lpbiPalette: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, cast[DWORD_PTR](lpbiPalette), 0) +template ICDecompressEnd*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0) +template ICDecompressExEnd*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0) +template ICDrawQuery2*(hic: HIC, lpbiInput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_QUERY, cast[DWORD_PTR](lpbiInput), 0) +template ICDrawChangePalette*(hic: HIC, lpbiInput: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, cast[DWORD_PTR](lpbiInput), 0) +template ICGetBuffersWanted*(hic: HIC, lpdwBuffers: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_GETBUFFERSWANTED, cast[DWORD_PTR](lpdwBuffers), 0) +template ICDrawEnd*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_END, 0, 0) +template ICDrawStart*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_START, 0, 0) +template ICDrawStartPlay*(hic: HIC, lFrom: LONG, lTo: LONG): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_START_PLAY, cast[DWORD_PTR](lFrom), cast[DWORD_PTR](lTo)) +template ICDrawStop*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_STOP, 0, 0) +template ICDrawStopPlay*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0) +template ICDrawGetTime*(hic: HIC, lplTime: LPVOID): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_GETTIME, cast[DWORD_PTR](lplTime), 0) +template ICDrawSetTime*(hic: HIC, lTime: LONG): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_SETTIME, cast[DWORD_PTR](lTime), 0) +template ICDrawRealize*(hic: HIC, hdc: HDC, fBackground: BOOL): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_REALIZE, cast[DWORD_PTR](hdc), cast[DWORD_PTR](fBackground)) +template ICDrawFlush*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0) +template ICDrawRenderBuffer*(hic: HIC): LRESULT = discardable ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0) +template ICDecompressOpen*(fccType: DWORD, fccHandler: DWORD, lpbiIn: LPVOID, lpbiOut: LPVOID): HIC = discardable ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS) +template ICDrawOpen*(fccType: DWORD, fccHandler: DWORD, lpbiIn: LPVOID): HIC = discardable ICLocate(fccType, fccHandler, lpbiIn, nil, ICMODE_DRAW) +template DrawDibUpdate*(hdd: HDRAWDIB, hdc: HDC, x: int32, y: int32): WINBOOL = discardable DrawDibDraw(hdd, hdc, x, y, 0, 0, nil, nil, 0, 0, 0, 0, DDF_UPDATE) +template AVIStreamSampleToSample*(pavi1: PAVISTREAM, pavi2: PAVISTREAM, l: LONG): LONG = discardable AVIStreamTimeToSample(pavi1, AVIStreamSampleToTime(pavi2, l)) +template AVIStreamNextSample*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l+1, FIND_NEXT or FIND_ANY) +template AVIStreamPrevSample*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l-1, FIND_PREV or FIND_ANY) +template AVIStreamNearestSample*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l, FIND_PREV or FIND_ANY) +template AVIStreamNextKeyFrame*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l+1, FIND_NEXT or FIND_KEY) +template AVIStreamPrevKeyFrame*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l-1, FIND_PREV or FIND_KEY) +template AVIStreamNearestKeyFrame*(pavi: PAVISTREAM, l: LONG): LONG = discardable AVIStreamFindSample(pavi, l, FIND_PREV or FIND_KEY) +template AVIStreamIsKeyFrame*(pavi: PAVISTREAM, l: LONG): bool = AVIStreamNearestKeyFrame(pavi, l) == l +template AVIStreamPrevSampleTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamPrevSample(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamNextSampleTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamNextSample(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamNearestSampleTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamNearestSample(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamNextKeyFrameTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamNextKeyFrame(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamPrevKeyFrameTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamPrevKeyFrame(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamNearestKeyFrameTime*(pavi: PAVISTREAM, t: LONG): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamNearestKeyFrame(pavi, AVIStreamTimeToSample(pavi, t))) +template AVIStreamStartTime*(pavi: PAVISTREAM): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamStart(pavi)) +template AVIStreamLengthTime*(pavi: PAVISTREAM): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamLength(pavi)) +template AVIStreamEnd*(pavi: PAVISTREAM): LONG = discardable(AVIStreamStart(pavi) + AVIStreamLength(pavi)) +template AVIStreamEndTime*(pavi: PAVISTREAM): LONG = discardable AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi)) +template AVIStreamSampleSize*(pavi: PAVISTREAM, lPos: LONG, plSize: ptr LONG): HRESULT = discardable AVIStreamRead(pavi, lPos, 1, nil, 0, plSize, nil) +template AVIStreamFormatSize*(pavi: PAVISTREAM, lPos: LONG, plSize: ptr LONG): HRESULT = discardable AVIStreamReadFormat(pavi, lPos, nil, plSize) +template AVIStreamDataSize*(pavi: PAVISTREAM, fcc: DWORD, plSize: ptr LONG): HRESULT = discardable AVIStreamReadData(pavi, fcc, nil, plSize) +template AVStreamNextKeyFrame*(pavi: PAVISTREAM, pos: LONG): LONG = discardable AVIStreamFindSample(pavi, pos+1, FIND_NEXT or FIND_KEY) +template AVStreamPrevKeyFrame*(pavi: PAVISTREAM, pos: LONG): LONG = discardable AVIStreamFindSample(pavi, pos-1, FIND_NEXT or FIND_KEY) +template AVICapSM*(hwnd: HWND, msg: UINT, wparam: untyped, lparam: untyped): LRESULT = (if IsWindow(hwnd) != FALSE: SendMessage(hwnd, msg, cast[WPARAM](wparam), cast[LPARAM](lparam)) else: 0) +when winimUnicode: + const + WM_CAP_SET_CALLBACK_ERROR* = WM_CAP_SET_CALLBACK_ERRORW +when winimAnsi: + const + WM_CAP_SET_CALLBACK_ERROR* = WM_CAP_SET_CALLBACK_ERRORA +template capSetCallbackOnError*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_ERROR, 0, fpProc) +when winimUnicode: + const + WM_CAP_SET_CALLBACK_STATUS* = WM_CAP_SET_CALLBACK_STATUSW +when winimAnsi: + const + WM_CAP_SET_CALLBACK_STATUS* = WM_CAP_SET_CALLBACK_STATUSA +template capSetCallbackOnStatus*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_STATUS, 0, fpProc) +template capSetCallbackOnYield*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_YIELD, 0, fpProc) +template capSetCallbackOnFrame*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_FRAME, 0, fpProc) +template capSetCallbackOnVideoStream*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, fpProc) +template capSetCallbackOnWaveStream*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, fpProc) +template capSetCallbackOnCapControl*(hwnd: HWND, fpProc: LPVOID): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, fpProc) +template capSetUserData*(hwnd: HWND, lUser: LPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_USER_DATA, 0, lUser) +template capGetUserData*(hwnd: HWND): LPARAM = discardable LPARAM AVICapSM(hwnd, WM_CAP_GET_USER_DATA, 0, 0) +template capDriverConnect*(hwnd: HWND, i: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DRIVER_CONNECT, i, 0) +template capDriverDisconnect*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DRIVER_DISCONNECT, 0, 0) +when winimUnicode: + const + WM_CAP_DRIVER_GET_NAME* = WM_CAP_DRIVER_GET_NAMEW +when winimAnsi: + const + WM_CAP_DRIVER_GET_NAME* = WM_CAP_DRIVER_GET_NAMEA +template capDriverGetName*(hwnd: HWND, szName: LPTSTR, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DRIVER_GET_NAME, wSize, szName) +when winimUnicode: + const + WM_CAP_DRIVER_GET_VERSION* = WM_CAP_DRIVER_GET_VERSIONW +when winimAnsi: + const + WM_CAP_DRIVER_GET_VERSION* = WM_CAP_DRIVER_GET_VERSIONA +template capDriverGetVersion*(hwnd: HWND, szVer: LPTSTR, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DRIVER_GET_VERSION, wSize, szVer) +template capDriverGetCaps*(hwnd: HWND, s: LPCAPDRIVERCAPS, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DRIVER_GET_CAPS, wSize, s) +when winimUnicode: + const + WM_CAP_FILE_SET_CAPTURE_FILE* = WM_CAP_FILE_SET_CAPTURE_FILEW +when winimAnsi: + const + WM_CAP_FILE_SET_CAPTURE_FILE* = WM_CAP_FILE_SET_CAPTURE_FILEA +template capFileSetCaptureFile*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, szName) +when winimUnicode: + const + WM_CAP_FILE_GET_CAPTURE_FILE* = WM_CAP_FILE_GET_CAPTURE_FILEW +when winimAnsi: + const + WM_CAP_FILE_GET_CAPTURE_FILE* = WM_CAP_FILE_GET_CAPTURE_FILEA +template capFileGetCaptureFile*(hwnd: HWND, szName: LPTSTR, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, szName) +template capFileAlloc*(hwnd: HWND, dwSize: DWORD): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_ALLOCATE, 0, dwSize) +when winimUnicode: + const + WM_CAP_FILE_SAVEAS* = WM_CAP_FILE_SAVEASW +when winimAnsi: + const + WM_CAP_FILE_SAVEAS* = WM_CAP_FILE_SAVEASA +template capFileSaveAs*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_SAVEAS, 0, szName) +template capFileSetInfoChunk*(hwnd: HWND, lpInfoChunk: LPCAPINFOCHUNK): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_SET_INFOCHUNK, 0, lpInfoChunk) +when winimUnicode: + const + WM_CAP_FILE_SAVEDIB* = WM_CAP_FILE_SAVEDIBW +when winimAnsi: + const + WM_CAP_FILE_SAVEDIB* = WM_CAP_FILE_SAVEDIBA +template capFileSaveDIB*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_FILE_SAVEDIB, 0, szName) +template capEditCopy*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_EDIT_COPY, 0, 0) +template capSetAudioFormat*(hwnd: HWND, s: LPWAVEFORMATEX, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_AUDIOFORMAT, wSize, s) +template capGetAudioFormat*(hwnd: HWND, s: LPWAVEFORMATEX, wSize: WPARAM): DWORD = discardable DWORD AVICapSM(hwnd, WM_CAP_GET_AUDIOFORMAT, wSize, s) +template capGetAudioFormatSize*(hwnd: HWND): DWORD = discardable DWORD AVICapSM(hwnd, WM_CAP_GET_AUDIOFORMAT, 0, 0) +template capDlgVideoFormat*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0) +template capDlgVideoSource*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0) +template capDlgVideoDisplay*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0) +template capDlgVideoCompression*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0) +template capGetVideoFormat*(hwnd: HWND, s: LPVOID, wSize: WPARAM): DWORD = discardable DWORD AVICapSM(hwnd, WM_CAP_GET_VIDEOFORMAT, wSize, s) +template capGetVideoFormatSize*(hwnd: HWND): DWORD = discardable DWORD AVICapSM(hwnd, WM_CAP_GET_VIDEOFORMAT, 0, 0) +template capSetVideoFormat*(hwnd: HWND, s: LPVOID, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_VIDEOFORMAT, wSize, s) +template capPreview*(hwnd: HWND, f: BOOL): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_PREVIEW, f, 0) +template capPreviewRate*(hwnd: HWND, wMS: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_PREVIEWRATE, wMS, 0) +template capOverlay*(hwnd: HWND, f: BOOL): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_OVERLAY, f, 0) +template capPreviewScale*(hwnd: HWND, f: BOOL): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_SCALE, f, 0) +template capGetStatus*(hwnd: HWND, s: LPCAPSTATUS, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_GET_STATUS, wSize, s) +template capSetScrollPos*(hwnd: HWND, lpP: LPPOINT): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_SCROLL, 0, lpP) +template capGrabFrame*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_GRAB_FRAME, 0, 0) +template capGrabFrameNoStop*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0) +template capCaptureSequence*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SEQUENCE, 0, 0) +template capCaptureSequenceNoFile*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SEQUENCE_NOFILE, 0, 0) +template capCaptureStop*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_STOP, 0, 0) +template capCaptureAbort*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_ABORT, 0, 0) +template capCaptureSingleFrameOpen*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0) +template capCaptureSingleFrameClose*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0) +template capCaptureSingleFrame*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SINGLE_FRAME, 0, 0) +template capCaptureGetSetup*(hwnd: HWND, s: LPCAPTUREPARMS, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_GET_SEQUENCE_SETUP, wSize, s) +template capCaptureSetSetup*(hwnd: HWND, s: LPCAPTUREPARMS, wSize: WPARAM): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_SEQUENCE_SETUP, wSize, s) +when winimUnicode: + const + WM_CAP_SET_MCI_DEVICE* = WM_CAP_SET_MCI_DEVICEW +when winimAnsi: + const + WM_CAP_SET_MCI_DEVICE* = WM_CAP_SET_MCI_DEVICEA +template capSetMCIDeviceName*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_SET_MCI_DEVICE, 0, szName) +when winimUnicode: + const + WM_CAP_GET_MCI_DEVICE* = WM_CAP_GET_MCI_DEVICEW +when winimAnsi: + const + WM_CAP_GET_MCI_DEVICE* = WM_CAP_GET_MCI_DEVICEA +template capGetMCIDeviceName*(hwnd: HWND, szName: LPTSTR, wSize): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_GET_MCI_DEVICE, wSize, szName) +when winimUnicode: + const + WM_CAP_PAL_OPEN* = WM_CAP_PAL_OPENW +when winimAnsi: + const + WM_CAP_PAL_OPEN* = WM_CAP_PAL_OPENA +template capPaletteOpen*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_PAL_OPEN, 0, szName) +when winimUnicode: + const + WM_CAP_PAL_SAVE* = WM_CAP_PAL_SAVEW +when winimAnsi: + const + WM_CAP_PAL_SAVE* = WM_CAP_PAL_SAVEA +template capPaletteSave*(hwnd: HWND, szName: LPTSTR): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_PAL_SAVE, 0, szName) +template capPalettePaste*(hwnd: HWND): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_PAL_PASTE, 0, 0) +template capPaletteAuto*(hwnd: HWND, iFrames: WPARAM, iColors: DWORD): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_PAL_AUTOCREATE, iFrames, iColors) +template capPaletteManual*(hwnd: HWND, fGrab: WPARAM, iColors: DWORD): BOOL = discardable BOOL AVICapSM(hwnd, WM_CAP_PAL_MANUALCREATE, fGrab, iColors) +proc ICGetDefaultQuality*(hic: HIC): DWORD {.winapi, inline.} = discard ICSendMessage(hic, ICM_GETDEFAULTQUALITY, cast[DWORD_PTR](addr result), cast[DWORD_PTR](sizeof(DWORD))); result +proc ICGetDefaultKeyFrameRate*(hic: HIC): DWORD {.winapi, inline.} = discard ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, cast[DWORD_PTR](addr result), cast[DWORD_PTR](sizeof(DWORD))); result +proc Create*(self: ptr IAVIStream, lParam1: LPARAM, lParam2: LPARAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Create(self, lParam1, lParam2) +proc Info*(self: ptr IAVIStream, psi: ptr TAVISTREAMINFOW, lSize: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Info(self, psi, lSize) +proc FindSample*(self: ptr IAVIStream, lPos: LONG, lFlags: LONG): LONG {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.FindSample(self, lPos, lFlags) +proc ReadFormat*(self: ptr IAVIStream, lPos: LONG, lpFormat: LPVOID, lpcbFormat: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadFormat(self, lPos, lpFormat, lpcbFormat) +proc SetFormat*(self: ptr IAVIStream, lPos: LONG, lpFormat: LPVOID, cbFormat: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFormat(self, lPos, lpFormat, cbFormat) +proc Read*(self: ptr IAVIStream, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, plBytes: ptr LONG, plSamples: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Read(self, lStart, lSamples, lpBuffer, cbBuffer, plBytes, plSamples) +proc Write*(self: ptr IAVIStream, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, dwFlags: DWORD, plSampWritten: ptr LONG, plBytesWritten: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Write(self, lStart, lSamples, lpBuffer, cbBuffer, dwFlags, plSampWritten, plBytesWritten) +proc mDelete*(self: ptr IAVIStream, lStart: LONG, lSamples: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Delete(self, lStart, lSamples) +proc ReadData*(self: ptr IAVIStream, fcc: DWORD, lp: LPVOID, lpcb: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadData(self, fcc, lp, lpcb) +proc WriteData*(self: ptr IAVIStream, fcc: DWORD, lp: LPVOID, cb: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteData(self, fcc, lp, cb) +proc SetInfo*(self: ptr IAVIStream, lpInfo: ptr TAVISTREAMINFOW, cbInfo: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInfo(self, lpInfo, cbInfo) +proc Begin*(self: ptr IAVIStreaming, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin(self, lStart, lEnd, lRate) +proc End*(self: ptr IAVIStreaming): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.End(self) +proc Cut*(self: ptr IAVIEditStream, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Cut(self, plStart, plLength, ppResult) +proc Copy*(self: ptr IAVIEditStream, plStart: ptr LONG, plLength: ptr LONG, ppResult: ptr PAVISTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Copy(self, plStart, plLength, ppResult) +proc Paste*(self: ptr IAVIEditStream, plPos: ptr LONG, plLength: ptr LONG, pstream: PAVISTREAM, lStart: LONG, lEnd: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Paste(self, plPos, plLength, pstream, lStart, lEnd) +proc Clone*(self: ptr IAVIEditStream, ppResult: ptr PAVISTREAM): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppResult) +proc SetInfo*(self: ptr IAVIEditStream, lpInfo: ptr TAVISTREAMINFOW, cbInfo: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetInfo(self, lpInfo, cbInfo) +proc Reserved1*(self: ptr IAVIPersistFile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reserved1(self) +proc Info*(self: ptr IAVIFile, pfi: ptr TAVIFILEINFOW, lSize: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Info(self, pfi, lSize) +proc GetStream*(self: ptr IAVIFile, ppStream: ptr PAVISTREAM, fccType: DWORD, lParam: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStream(self, ppStream, fccType, lParam) +proc CreateStream*(self: ptr IAVIFile, ppStream: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOW): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStream(self, ppStream, psi) +proc WriteData*(self: ptr IAVIFile, ckid: DWORD, lpData: LPVOID, cbData: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteData(self, ckid, lpData, cbData) +proc ReadData*(self: ptr IAVIFile, ckid: DWORD, lpData: LPVOID, lpcbData: ptr LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.ReadData(self, ckid, lpData, lpcbData) +proc EndRecord*(self: ptr IAVIFile): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.EndRecord(self) +proc DeleteStream*(self: ptr IAVIFile, fccType: DWORD, lParam: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DeleteStream(self, fccType, lParam) +proc GetFrame*(self: ptr IGetFrame, lPos: LONG): LPVOID {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFrame(self, lPos) +proc Begin*(self: ptr IGetFrame, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Begin(self, lStart, lEnd, lRate) +proc End*(self: ptr IGetFrame): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.End(self) +proc SetFormat*(self: ptr IGetFrame, lpbi: LPBITMAPINFOHEADER, lpBits: LPVOID, x: int32, y: int32, dx: int32, dy: int32): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetFormat(self, lpbi, lpBits, x, y, dx, dy) +converter winimConverterIAVIStreamToIUnknown*(x: ptr IAVIStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAVIStreamingToIUnknown*(x: ptr IAVIStreaming): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAVIEditStreamToIUnknown*(x: ptr IAVIEditStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAVIPersistFileToIPersistFile*(x: ptr IAVIPersistFile): ptr IPersistFile = cast[ptr IPersistFile](x) +converter winimConverterIAVIPersistFileToIPersist*(x: ptr IAVIPersistFile): ptr IPersist = cast[ptr IPersist](x) +converter winimConverterIAVIPersistFileToIUnknown*(x: ptr IAVIPersistFile): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIAVIFileToIUnknown*(x: ptr IAVIFile): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIGetFrameToIUnknown*(x: ptr IGetFrame): ptr IUnknown = cast[ptr IUnknown](x) +when winimUnicode: + type + ACMDRIVERDETAILS* = ACMDRIVERDETAILSW + PACMDRIVERDETAILS* = PACMDRIVERDETAILSW + LPACMDRIVERDETAILS* = LPACMDRIVERDETAILSW + ACMFORMATTAGDETAILS* = ACMFORMATTAGDETAILSW + PACMFORMATTAGDETAILS* = PACMFORMATTAGDETAILSW + LPACMFORMATTAGDETAILS* = LPACMFORMATTAGDETAILSW + ACMFORMATTAGENUMCB* = ACMFORMATTAGENUMCBW + ACMFORMATDETAILS* = ACMFORMATDETAILSW + PACMFORMATDETAILS* = PACMFORMATDETAILSW + LPACMFORMATDETAILS* = LPACMFORMATDETAILSW + ACMFORMATENUMCB* = ACMFORMATENUMCBW + ACMFORMATCHOOSEHOOKPROC* = ACMFORMATCHOOSEHOOKPROCW + ACMFORMATCHOOSE* = ACMFORMATCHOOSEW + PACMFORMATCHOOSE* = PACMFORMATCHOOSEW + LPACMFORMATCHOOSE* = LPACMFORMATCHOOSEW + ACMFILTERTAGDETAILS* = ACMFILTERTAGDETAILSW + PACMFILTERTAGDETAILS* = PACMFILTERTAGDETAILSW + LPACMFILTERTAGDETAILS* = LPACMFILTERTAGDETAILSW + ACMFILTERTAGENUMCB* = ACMFILTERTAGENUMCBW + ACMFILTERDETAILS* = ACMFILTERDETAILSW + PACMFILTERDETAILS* = PACMFILTERDETAILSW + LPACMFILTERDETAILS* = LPACMFILTERDETAILSW + ACMFILTERENUMCB* = ACMFILTERENUMCBW + ACMFILTERCHOOSEHOOKPROC* = ACMFILTERCHOOSEHOOKPROCW + ACMFILTERCHOOSE* = ACMFILTERCHOOSEW + PACMFILTERCHOOSE* = PACMFILTERCHOOSEW + LPACMFILTERCHOOSE* = LPACMFILTERCHOOSEW + TAVISTREAMINFO* = TAVISTREAMINFOW + LPAVISTREAMINFO* = LPAVISTREAMINFOW + TAVIFILEINFO* = TAVIFILEINFOW + LPAVIFILEINFO* = LPAVIFILEINFOW + CAPSTATUSCALLBACK* = CAPSTATUSCALLBACKW + CAPERRORCALLBACK* = CAPERRORCALLBACKW + const + ACMHELPMSGSTRING* = ACMHELPMSGSTRINGW + ACMHELPMSGCONTEXTMENU* = ACMHELPMSGCONTEXTMENUW + ACMHELPMSGCONTEXTHELP* = ACMHELPMSGCONTEXTHELPW + MCIWNDF_NOTIFYMEDIA* = MCIWNDF_NOTIFYMEDIAW + proc acmDriverAdd*(phadid: LPHACMDRIVERID, hinstModule: HINSTANCE, lParam: LPARAM, dwPriority: DWORD, fdwAdd: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmDriverAddW".} + proc acmDriverDetails*(hadid: HACMDRIVERID, padd: LPACMDRIVERDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmDriverDetailsW".} + proc acmFormatTagDetails*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatTagDetailsW".} + proc acmFormatTagEnum*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSW, fnCallback: ACMFORMATTAGENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatTagEnumW".} + proc acmFormatDetails*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatDetailsW".} + proc acmFormatEnum*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSW, fnCallback: ACMFORMATENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatEnumW".} + proc acmFormatChoose*(pafmtc: LPACMFORMATCHOOSEW): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatChooseW".} + proc acmFilterTagDetails*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterTagDetailsW".} + proc acmFilterTagEnum*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSW, fnCallback: ACMFILTERTAGENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterTagEnumW".} + proc acmFilterDetails*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSW, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterDetailsW".} + proc acmFilterEnum*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSW, fnCallback: ACMFILTERENUMCBW, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterEnumW".} + proc acmFilterChoose*(pafltrc: LPACMFILTERCHOOSEW): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterChooseW".} + proc AVIFileOpen*(ppfile: ptr PAVIFILE, szFile: LPCWSTR, uMode: UINT, lpHandler: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileOpenW".} + proc AVIFileInfo*(pfile: PAVIFILE, pfi: LPAVIFILEINFOW, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileInfoW".} + proc AVIFileCreateStream*(pfile: PAVIFILE, ppavi: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOW): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileCreateStreamW".} + proc AVIStreamInfo*(pavi: PAVISTREAM, psi: LPAVISTREAMINFOW, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamInfoW".} + proc AVIStreamOpenFromFile*(ppavi: ptr PAVISTREAM, szFile: LPCWSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamOpenFromFileW".} + proc AVISaveV*(szFile: LPCWSTR, pclsidHandler: ptr CLSID, lpfnCallback: AVISAVECALLBACK, nStreams: int32, ppavi: ptr PAVISTREAM, plpOptions: ptr LPAVICOMPRESSOPTIONS): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVISaveVW".} + proc AVIBuildFilter*(lpszFilter: LPWSTR, cbFilter: LONG, fSaving: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIBuildFilterW".} + proc EditStreamSetInfo*(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOW, cbInfo: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "EditStreamSetInfoW".} + proc EditStreamSetName*(pavi: PAVISTREAM, lpszName: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "EditStreamSetNameW".} + proc MCIWndCreate*(hwndParent: HWND, hInstance: HINSTANCE, dwStyle: DWORD, szFile: LPCWSTR): HWND {.winapi, stdcall, dynlib: "msvfw32", importc: "MCIWndCreateW".} + proc capCreateCaptureWindow*(lpszWindowName: LPCWSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hwndParent: HWND, nID: int32): HWND {.winapi, stdcall, dynlib: "avicap32", importc: "capCreateCaptureWindowW".} + proc capGetDriverDescription*(wDriverIndex: UINT, lpszName: LPWSTR, cbName: int32, lpszVer: LPWSTR, cbVer: int32): WINBOOL {.winapi, stdcall, dynlib: "avicap32", importc: "capGetDriverDescriptionW".} + proc GetOpenFileNamePreview*(lpofn: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc: "GetOpenFileNamePreviewW".} + proc GetSaveFileNamePreview*(lpofn: LPOPENFILENAMEW): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc: "GetSaveFileNamePreviewW".} +when winimAnsi: + type + ACMDRIVERDETAILS* = ACMDRIVERDETAILSA + PACMDRIVERDETAILS* = PACMDRIVERDETAILSA + LPACMDRIVERDETAILS* = LPACMDRIVERDETAILSA + ACMFORMATTAGDETAILS* = ACMFORMATTAGDETAILSA + PACMFORMATTAGDETAILS* = PACMFORMATTAGDETAILSA + LPACMFORMATTAGDETAILS* = LPACMFORMATTAGDETAILSA + ACMFORMATTAGENUMCB* = ACMFORMATTAGENUMCBA + ACMFORMATDETAILS* = ACMFORMATDETAILSA + PACMFORMATDETAILS* = PACMFORMATDETAILSA + LPACMFORMATDETAILS* = LPACMFORMATDETAILSA + ACMFORMATENUMCB* = ACMFORMATENUMCBA + ACMFORMATCHOOSEHOOKPROC* = ACMFORMATCHOOSEHOOKPROCA + ACMFORMATCHOOSE* = ACMFORMATCHOOSEA + PACMFORMATCHOOSE* = PACMFORMATCHOOSEA + LPACMFORMATCHOOSE* = LPACMFORMATCHOOSEA + ACMFILTERTAGDETAILS* = ACMFILTERTAGDETAILSA + PACMFILTERTAGDETAILS* = PACMFILTERTAGDETAILSA + LPACMFILTERTAGDETAILS* = LPACMFILTERTAGDETAILSA + ACMFILTERTAGENUMCB* = ACMFILTERTAGENUMCBA + ACMFILTERDETAILS* = ACMFILTERDETAILSA + PACMFILTERDETAILS* = PACMFILTERDETAILSA + LPACMFILTERDETAILS* = LPACMFILTERDETAILSA + ACMFILTERENUMCB* = ACMFILTERENUMCBA + ACMFILTERCHOOSEHOOKPROC* = ACMFILTERCHOOSEHOOKPROCA + ACMFILTERCHOOSE* = ACMFILTERCHOOSEA + PACMFILTERCHOOSE* = PACMFILTERCHOOSEA + LPACMFILTERCHOOSE* = LPACMFILTERCHOOSEA + TAVISTREAMINFO* = TAVISTREAMINFOA + LPAVISTREAMINFO* = LPAVISTREAMINFOA + TAVIFILEINFO* = TAVIFILEINFOA + LPAVIFILEINFO* = LPAVIFILEINFOA + CAPSTATUSCALLBACK* = CAPSTATUSCALLBACKA + CAPERRORCALLBACK* = CAPERRORCALLBACKA + const + CLSID_AVISimpleUnMarshal* = DEFINE_GUID("00020009-0000-0000-c000-000000000046") + ACMHELPMSGSTRING* = ACMHELPMSGSTRINGA + ACMHELPMSGCONTEXTMENU* = ACMHELPMSGCONTEXTMENUA + ACMHELPMSGCONTEXTHELP* = ACMHELPMSGCONTEXTHELPA + MCIWNDF_NOTIFYMEDIA* = MCIWNDF_NOTIFYMEDIAA + proc acmDriverAdd*(phadid: LPHACMDRIVERID, hinstModule: HINSTANCE, lParam: LPARAM, dwPriority: DWORD, fdwAdd: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmDriverAddA".} + proc acmDriverDetails*(hadid: HACMDRIVERID, padd: LPACMDRIVERDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmDriverDetailsA".} + proc acmFormatTagDetails*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatTagDetailsA".} + proc acmFormatTagEnum*(had: HACMDRIVER, paftd: LPACMFORMATTAGDETAILSA, fnCallback: ACMFORMATTAGENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatTagEnumA".} + proc acmFormatDetails*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatDetailsA".} + proc acmFormatEnum*(had: HACMDRIVER, pafd: LPACMFORMATDETAILSA, fnCallback: ACMFORMATENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatEnumA".} + proc acmFormatChoose*(pafmtc: LPACMFORMATCHOOSEA): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFormatChooseA".} + proc acmFilterTagDetails*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterTagDetailsA".} + proc acmFilterTagEnum*(had: HACMDRIVER, paftd: LPACMFILTERTAGDETAILSA, fnCallback: ACMFILTERTAGENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterTagEnumA".} + proc acmFilterDetails*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSA, fdwDetails: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterDetailsA".} + proc acmFilterEnum*(had: HACMDRIVER, pafd: LPACMFILTERDETAILSA, fnCallback: ACMFILTERENUMCBA, dwInstance: DWORD_PTR, fdwEnum: DWORD): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterEnumA".} + proc acmFilterChoose*(pafltrc: LPACMFILTERCHOOSEA): MMRESULT {.winapi, stdcall, dynlib: "msacm32", importc: "acmFilterChooseA".} + proc AVIFileOpen*(ppfile: ptr PAVIFILE, szFile: LPCSTR, uMode: UINT, lpHandler: LPCLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileOpenA".} + proc AVIFileInfo*(pfile: PAVIFILE, pfi: LPAVIFILEINFOA, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileInfoA".} + proc AVIFileCreateStream*(pfile: PAVIFILE, ppavi: ptr PAVISTREAM, psi: ptr TAVISTREAMINFOA): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIFileCreateStreamA".} + proc AVIStreamInfo*(pavi: PAVISTREAM, psi: LPAVISTREAMINFOA, lSize: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamInfoA".} + proc AVIStreamOpenFromFile*(ppavi: ptr PAVISTREAM, szFile: LPCSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: ptr CLSID): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIStreamOpenFromFileA".} + proc AVISaveV*(szFile: LPCSTR, pclsidHandler: ptr CLSID, lpfnCallback: AVISAVECALLBACK, nStreams: int32, ppavi: ptr PAVISTREAM, plpOptions: ptr LPAVICOMPRESSOPTIONS): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVISaveVA".} + proc AVIBuildFilter*(lpszFilter: LPSTR, cbFilter: LONG, fSaving: WINBOOL): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "AVIBuildFilterA".} + proc EditStreamSetInfo*(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOA, cbInfo: LONG): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "EditStreamSetInfoA".} + proc EditStreamSetName*(pavi: PAVISTREAM, lpszName: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "avifil32", importc: "EditStreamSetNameA".} + proc MCIWndCreate*(hwndParent: HWND, hInstance: HINSTANCE, dwStyle: DWORD, szFile: LPCSTR): HWND {.winapi, stdcall, dynlib: "msvfw32", importc: "MCIWndCreateA".} + proc capCreateCaptureWindow*(lpszWindowName: LPCSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hwndParent: HWND, nID: int32): HWND {.winapi, stdcall, dynlib: "avicap32", importc: "capCreateCaptureWindowA".} + proc capGetDriverDescription*(wDriverIndex: UINT, lpszName: LPSTR, cbName: int32, lpszVer: LPSTR, cbVer: int32): WINBOOL {.winapi, stdcall, dynlib: "avicap32", importc: "capGetDriverDescriptionA".} + proc GetOpenFileNamePreview*(lpofn: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc: "GetOpenFileNamePreviewA".} + proc GetSaveFileNamePreview*(lpofn: LPOPENFILENAMEA): WINBOOL {.winapi, stdcall, dynlib: "msvfw32", importc: "GetSaveFileNamePreviewA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/virtdisk.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/virtdisk.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,269 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +type + ATTACH_VIRTUAL_DISK_FLAG* = int32 + ATTACH_VIRTUAL_DISK_VERSION* = int32 + COMPACT_VIRTUAL_DISK_FLAG* = int32 + COMPACT_VIRTUAL_DISK_VERSION* = int32 + CREATE_VIRTUAL_DISK_FLAG* = int32 + CREATE_VIRTUAL_DISK_VERSION* = int32 + DEPENDENT_DISK_FLAG* = int32 + EXPAND_VIRTUAL_DISK_VERSION* = int32 + DETACH_VIRTUAL_DISK_FLAG* = int32 + EXPAND_VIRTUAL_DISK_FLAG* = int32 + GET_STORAGE_DEPENDENCY_FLAG* = int32 + GET_VIRTUAL_DISK_INFO_VERSION* = int32 + MERGE_VIRTUAL_DISK_FLAG* = int32 + MERGE_VIRTUAL_DISK_VERSION* = int32 + OPEN_VIRTUAL_DISK_FLAG* = int32 + OPEN_VIRTUAL_DISK_VERSION* = int32 + SET_VIRTUAL_DISK_INFO_VERSION* = int32 + STORAGE_DEPENDENCY_INFO_VERSION* = int32 + VIRTUAL_DISK_ACCESS_MASK* = int32 + VIRTUAL_STORAGE_TYPE* {.pure.} = object + DeviceId*: ULONG + VendorId*: GUID + PVIRTUAL_STORAGE_TYPE* = ptr VIRTUAL_STORAGE_TYPE + ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + Reserved*: ULONG + ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + ATTACH_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: ATTACH_VIRTUAL_DISK_VERSION + union1*: ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1 + PATTACH_VIRTUAL_DISK_PARAMETERS* = ptr ATTACH_VIRTUAL_DISK_PARAMETERS + COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + Reserved*: ULONG + COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + COMPACT_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: COMPACT_VIRTUAL_DISK_VERSION + union1*: COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1 + PCOMPACT_VIRTUAL_DISK_PARAMETERS* = ptr COMPACT_VIRTUAL_DISK_PARAMETERS + CREATE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + UniqueId*: GUID + MaximumSize*: ULONGLONG + BlockSizeInBytes*: ULONG + SectorSizeInBytes*: ULONG + ParentPath*: PCWSTR + SourcePath*: PCWSTR + CREATE_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: CREATE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + CREATE_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: CREATE_VIRTUAL_DISK_VERSION + union1*: CREATE_VIRTUAL_DISK_PARAMETERS_UNION1 + PCREATE_VIRTUAL_DISK_PARAMETERS* = ptr CREATE_VIRTUAL_DISK_PARAMETERS + EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + NewSize*: ULONGLONG + EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + EXPAND_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: EXPAND_VIRTUAL_DISK_VERSION + union1*: EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1 + PEXPAND_VIRTUAL_DISK_PARAMETERS* = ptr EXPAND_VIRTUAL_DISK_PARAMETERS + GET_VIRTUAL_DISK_INFO_UNION1_Size* {.pure.} = object + VirtualSize*: ULONGLONG + PhysicalSize*: ULONGLONG + BlockSize*: ULONG + SectorSize*: ULONG + GET_VIRTUAL_DISK_INFO_UNION1_ParentLocation* {.pure.} = object + ParentResolved*: BOOL + ParentLocationBuffer*: array[1, WCHAR] + GET_VIRTUAL_DISK_INFO_UNION1* {.pure, union.} = object + Size*: GET_VIRTUAL_DISK_INFO_UNION1_Size + Identifier*: GUID + ParentLocation*: GET_VIRTUAL_DISK_INFO_UNION1_ParentLocation + ParentIdentifier*: GUID + ParentTimestamp*: ULONG + VirtualStorageType*: VIRTUAL_STORAGE_TYPE + ProviderSubtype*: ULONG + GET_VIRTUAL_DISK_INFO* {.pure.} = object + Version*: GET_VIRTUAL_DISK_INFO_VERSION + union1*: GET_VIRTUAL_DISK_INFO_UNION1 + PGET_VIRTUAL_DISK_INFO* = ptr GET_VIRTUAL_DISK_INFO + MERGE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + MergeDepth*: ULONG + MERGE_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: MERGE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + MERGE_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: MERGE_VIRTUAL_DISK_VERSION + union1*: MERGE_VIRTUAL_DISK_PARAMETERS_UNION1 + PMERGE_VIRTUAL_DISK_PARAMETERS* = ptr MERGE_VIRTUAL_DISK_PARAMETERS + OPEN_VIRTUAL_DISK_PARAMETERS_UNION1_Version1* {.pure.} = object + RWDepth*: ULONG + OPEN_VIRTUAL_DISK_PARAMETERS_UNION1* {.pure, union.} = object + Version1*: OPEN_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 + OPEN_VIRTUAL_DISK_PARAMETERS* {.pure.} = object + Version*: OPEN_VIRTUAL_DISK_VERSION + union1*: OPEN_VIRTUAL_DISK_PARAMETERS_UNION1 + POPEN_VIRTUAL_DISK_PARAMETERS* = ptr OPEN_VIRTUAL_DISK_PARAMETERS + SET_VIRTUAL_DISK_INFO_UNION1* {.pure, union.} = object + ParentFilePath*: PCWSTR + UniqueIdentifier*: GUID + SET_VIRTUAL_DISK_INFO* {.pure.} = object + Version*: SET_VIRTUAL_DISK_INFO_VERSION + union1*: SET_VIRTUAL_DISK_INFO_UNION1 + PSET_VIRTUAL_DISK_INFO* = ptr SET_VIRTUAL_DISK_INFO + STORAGE_DEPENDENCY_INFO_TYPE_1* {.pure.} = object + DependencyTypeFlags*: DEPENDENT_DISK_FLAG + ProviderSpecificFlags*: ULONG + VirtualStorageType*: VIRTUAL_STORAGE_TYPE + PSTORAGE_DEPENDENCY_INFO_TYPE_1* = ptr STORAGE_DEPENDENCY_INFO_TYPE_1 + STORAGE_DEPENDENCY_INFO_TYPE_2* {.pure.} = object + DependencyTypeFlags*: DEPENDENT_DISK_FLAG + ProviderSpecificFlags*: ULONG + VirtualStorageType*: VIRTUAL_STORAGE_TYPE + AncestorLevel*: ULONG + DependencyDeviceName*: PWSTR + HostVolumeName*: PWSTR + DependentVolumeName*: PWSTR + DependentVolumeRelativePath*: PWSTR + PSTORAGE_DEPENDENCY_INFO_TYPE_2* = ptr STORAGE_DEPENDENCY_INFO_TYPE_2 + STORAGE_DEPENDENCY_INFO_UNION1* {.pure, union.} = object + Version1Entries*: array[1, STORAGE_DEPENDENCY_INFO_TYPE_1] + Version2Entries*: array[1, STORAGE_DEPENDENCY_INFO_TYPE_2] + STORAGE_DEPENDENCY_INFO* {.pure.} = object + Version*: STORAGE_DEPENDENCY_INFO_VERSION + NumberEntries*: ULONG + union1*: STORAGE_DEPENDENCY_INFO_UNION1 + PSTORAGE_DEPENDENCY_INFO* = ptr STORAGE_DEPENDENCY_INFO + VIRTUAL_DISK_PROGRESS* {.pure.} = object + OperationStatus*: DWORD + CurrentValue*: ULONGLONG + CompletionValue*: ULONGLONG + PVIRTUAL_DISK_PROGRESS* = ptr VIRTUAL_DISK_PROGRESS +const + ATTACH_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + ATTACH_VIRTUAL_DISK_FLAG_READ_ONLY* = 0x00000001 + ATTACH_VIRTUAL_DISK_FLAG_NO_DRIVE_LETTER* = 0x00000002 + ATTACH_VIRTUAL_DISK_FLAG_PERMANENT_LIFETIME* = 0x00000004 + ATTACH_VIRTUAL_DISK_FLAG_NO_LOCAL_HOST* = 0x00000008 + ATTACH_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + ATTACH_VIRTUAL_DISK_VERSION_1* = 1 + COMPACT_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + COMPACT_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + COMPACT_VIRTUAL_DISK_VERSION_1* = 1 + CREATE_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION* = 0x00000001 + CREATE_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + CREATE_VIRTUAL_DISK_VERSION_1* = 1 + DEPENDENT_DISK_FLAG_NONE* = 0x00000000 + DEPENDENT_DISK_FLAG_MULT_BACKING_FILES* = 0x00000001 + DEPENDENT_DISK_FLAG_FULLY_ALLOCATED* = 0x00000002 + DEPENDENT_DISK_FLAG_READ_ONLY* = 0x00000004 + DEPENDENT_DISK_FLAG_REMOTE* = 0x00000008 + DEPENDENT_DISK_FLAG_SYSTEM_VOLUME* = 0x00000010 + DEPENDENT_DISK_FLAG_SYSTEM_VOLUME_PARENT* = 0x00000020 + DEPENDENT_DISK_FLAG_REMOVABLE* = 0x00000040 + DEPENDENT_DISK_FLAG_NO_DRIVE_LETTER* = 0x00000080 + DEPENDENT_DISK_FLAG_PARENT* = 0x00000100 + DEPENDENT_DISK_FLAG_NO_HOST_DISK* = 0x00000200 + DEPENDENT_DISK_FLAG_PERMANENT_LIFETIME* = 0x00000400 + EXPAND_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + EXPAND_VIRTUAL_DISK_VERSION_1* = 1 + DETACH_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + EXPAND_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + GET_STORAGE_DEPENDENCY_FLAG_NONE* = 0x00000000 + GET_STORAGE_DEPENDENCY_FLAG_HOST_VOLUMES* = 0x00000001 + GET_STORAGE_DEPENDENCY_FLAG_DISK_HANDLE* = 0x00000002 + GET_VIRTUAL_DISK_INFO_UNSPECIFIED* = 0 + GET_VIRTUAL_DISK_INFO_SIZE* = 1 + GET_VIRTUAL_DISK_INFO_IDENTIFIER* = 2 + GET_VIRTUAL_DISK_INFO_PARENT_LOCATION* = 3 + GET_VIRTUAL_DISK_INFO_PARENT_IDENTIFIER* = 4 + GET_VIRTUAL_DISK_INFO_PARENT_TIMESTAMP* = 5 + GET_VIRTUAL_DISK_INFO_VIRTUAL_STORAGE_TYPE* = 6 + GET_VIRTUAL_DISK_INFO_PROVIDER_SUBTYPE* = 7 + MERGE_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + MERGE_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + MERGE_VIRTUAL_DISK_VERSION_1* = 1 + OPEN_VIRTUAL_DISK_FLAG_NONE* = 0x00000000 + OPEN_VIRTUAL_DISK_FLAG_NO_PARENTS* = 0x00000001 + OPEN_VIRTUAL_DISK_FLAG_BLANK_FILE* = 0x00000002 + OPEN_VIRTUAL_DISK_FLAG_BOOT_DRIVE* = 0x00000004 + OPEN_VIRTUAL_DISK_VERSION_UNSPECIFIED* = 0 + OPEN_VIRTUAL_DISK_VERSION_1* = 1 + SET_VIRTUAL_DISK_INFO_UNSPECIFIED* = 0 + SET_VIRTUAL_DISK_INFO_PARENT_PATH* = 1 + SET_VIRTUAL_DISK_INFO_IDENTIFIER* = 2 + STORAGE_DEPENDENCY_INFO_VERSION_UNSPECIFIED* = 0 + STORAGE_DEPENDENCY_INFO_VERSION_1* = 1 + STORAGE_DEPENDENCY_INFO_VERSION_2* = 2 + VIRTUAL_DISK_ACCESS_ATTACH_RO* = 0x00010000 + VIRTUAL_DISK_ACCESS_ATTACH_RW* = 0x00020000 + VIRTUAL_DISK_ACCESS_DETACH* = 0x00040000 + VIRTUAL_DISK_ACCESS_GET_INFO* = 0x00080000 + VIRTUAL_DISK_ACCESS_CREATE* = 0x00100000 + VIRTUAL_DISK_ACCESS_METAOPS* = 0x00200000 + VIRTUAL_DISK_ACCESS_READ* = 0x000d0000 + VIRTUAL_DISK_ACCESS_ALL* = 0x003f0000 + VIRTUAL_DISK_ACCESS_WRITABLE* = 0x00320000 + VIRTUAL_STORAGE_TYPE_DEVICE_UNKNOWN* = 0 + VIRTUAL_STORAGE_TYPE_DEVICE_ISO* = 1 + VIRTUAL_STORAGE_TYPE_DEVICE_VHD* = 2 + VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT* = DEFINE_GUID("ec984aec-a0f9-47e9-901f-71415a66345b") +proc AttachVirtualDisk*(VirtualDiskHandle: HANDLE, SecurityDescriptor: PSECURITY_DESCRIPTOR, Flags: ATTACH_VIRTUAL_DISK_FLAG, ProviderSpecificFlags: ULONG, Parameters: PATTACH_VIRTUAL_DISK_PARAMETERS, Overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc CompactVirtualDisk*(VirtualDiskHandle: HANDLE, Flags: COMPACT_VIRTUAL_DISK_FLAG, Parameters: PCOMPACT_VIRTUAL_DISK_PARAMETERS, Overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc CreateVirtualDisk*(VirtualStorageType: PVIRTUAL_STORAGE_TYPE, Path: PCWSTR, VirtualDiskAccessMask: VIRTUAL_DISK_ACCESS_MASK, SecurityDescriptor: PSECURITY_DESCRIPTOR, Flags: CREATE_VIRTUAL_DISK_FLAG, ProviderSpecificFlags: ULONG, Parameters: PCREATE_VIRTUAL_DISK_PARAMETERS, Overlapped: LPOVERLAPPED, Handle: PHANDLE): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc DetachVirtualDisk*(VirtualDiskHandle: HANDLE, Flags: DETACH_VIRTUAL_DISK_FLAG, ProviderSpecificFlags: ULONG): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc ExpandVirtualDisk*(VirtualDiskHandle: HANDLE, Flags: EXPAND_VIRTUAL_DISK_FLAG, Parameters: PEXPAND_VIRTUAL_DISK_PARAMETERS, Overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc GetStorageDependencyInformation*(ObjectHandle: HANDLE, Flags: GET_STORAGE_DEPENDENCY_FLAG, StorageDependencyInfoSize: ULONG, StorageDependencyInfo: PSTORAGE_DEPENDENCY_INFO, SizeUsed: PULONG): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc GetVirtualDiskInformation*(VirtualDiskHandle: HANDLE, VirtualDiskInfoSize: PULONG, VirtualDiskInfo: PGET_VIRTUAL_DISK_INFO, SizeUsed: PULONG): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc GetVirtualDiskOperationProgress*(VirtualDiskHandle: HANDLE, Overlapped: LPOVERLAPPED, Progress: PVIRTUAL_DISK_PROGRESS): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc GetVirtualDiskPhysicalPath*(VirtualDiskHandle: HANDLE, DiskPathSizeInBytes: PULONG, DiskPath: PWSTR): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc MergeVirtualDisk*(VirtualDiskHandle: HANDLE, Flags: MERGE_VIRTUAL_DISK_FLAG, Parameters: PMERGE_VIRTUAL_DISK_PARAMETERS, Overlapped: LPOVERLAPPED): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc OpenVirtualDisk*(VirtualStorageType: PVIRTUAL_STORAGE_TYPE, Path: PCWSTR, VirtualDiskAccessMask: VIRTUAL_DISK_ACCESS_MASK, Flags: OPEN_VIRTUAL_DISK_FLAG, Parameters: POPEN_VIRTUAL_DISK_PARAMETERS, Handle: PHANDLE): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc SetVirtualDiskInformation*(VirtualDiskHandle: HANDLE, VirtualDiskInfo: PSET_VIRTUAL_DISK_INFO): DWORD {.winapi, stdcall, dynlib: "virtdisk", importc.} +proc `Version1=`*(self: var ATTACH_VIRTUAL_DISK_PARAMETERS, x: ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: ATTACH_VIRTUAL_DISK_PARAMETERS): ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var ATTACH_VIRTUAL_DISK_PARAMETERS): var ATTACH_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `Version1=`*(self: var COMPACT_VIRTUAL_DISK_PARAMETERS, x: COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: COMPACT_VIRTUAL_DISK_PARAMETERS): COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var COMPACT_VIRTUAL_DISK_PARAMETERS): var COMPACT_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `Version1=`*(self: var CREATE_VIRTUAL_DISK_PARAMETERS, x: CREATE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: CREATE_VIRTUAL_DISK_PARAMETERS): CREATE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var CREATE_VIRTUAL_DISK_PARAMETERS): var CREATE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `Version1=`*(self: var EXPAND_VIRTUAL_DISK_PARAMETERS, x: EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: EXPAND_VIRTUAL_DISK_PARAMETERS): EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var EXPAND_VIRTUAL_DISK_PARAMETERS): var EXPAND_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `Identifier=`*(self: var GET_VIRTUAL_DISK_INFO, x: GUID) {.inline.} = self.union1.Identifier = x +proc Identifier*(self: GET_VIRTUAL_DISK_INFO): GUID {.inline.} = self.union1.Identifier +proc Identifier*(self: var GET_VIRTUAL_DISK_INFO): var GUID {.inline.} = self.union1.Identifier +proc `ParentLocation=`*(self: var GET_VIRTUAL_DISK_INFO, x: GET_VIRTUAL_DISK_INFO_UNION1_ParentLocation) {.inline.} = self.union1.ParentLocation = x +proc ParentLocation*(self: GET_VIRTUAL_DISK_INFO): GET_VIRTUAL_DISK_INFO_UNION1_ParentLocation {.inline.} = self.union1.ParentLocation +proc ParentLocation*(self: var GET_VIRTUAL_DISK_INFO): var GET_VIRTUAL_DISK_INFO_UNION1_ParentLocation {.inline.} = self.union1.ParentLocation +proc `ParentIdentifier=`*(self: var GET_VIRTUAL_DISK_INFO, x: GUID) {.inline.} = self.union1.ParentIdentifier = x +proc ParentIdentifier*(self: GET_VIRTUAL_DISK_INFO): GUID {.inline.} = self.union1.ParentIdentifier +proc ParentIdentifier*(self: var GET_VIRTUAL_DISK_INFO): var GUID {.inline.} = self.union1.ParentIdentifier +proc `ParentTimestamp=`*(self: var GET_VIRTUAL_DISK_INFO, x: ULONG) {.inline.} = self.union1.ParentTimestamp = x +proc ParentTimestamp*(self: GET_VIRTUAL_DISK_INFO): ULONG {.inline.} = self.union1.ParentTimestamp +proc ParentTimestamp*(self: var GET_VIRTUAL_DISK_INFO): var ULONG {.inline.} = self.union1.ParentTimestamp +proc `ProviderSubtype=`*(self: var GET_VIRTUAL_DISK_INFO, x: ULONG) {.inline.} = self.union1.ProviderSubtype = x +proc ProviderSubtype*(self: GET_VIRTUAL_DISK_INFO): ULONG {.inline.} = self.union1.ProviderSubtype +proc ProviderSubtype*(self: var GET_VIRTUAL_DISK_INFO): var ULONG {.inline.} = self.union1.ProviderSubtype +proc `Version1=`*(self: var MERGE_VIRTUAL_DISK_PARAMETERS, x: MERGE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: MERGE_VIRTUAL_DISK_PARAMETERS): MERGE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var MERGE_VIRTUAL_DISK_PARAMETERS): var MERGE_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `Version1=`*(self: var OPEN_VIRTUAL_DISK_PARAMETERS, x: OPEN_VIRTUAL_DISK_PARAMETERS_UNION1_Version1) {.inline.} = self.union1.Version1 = x +proc Version1*(self: OPEN_VIRTUAL_DISK_PARAMETERS): OPEN_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc Version1*(self: var OPEN_VIRTUAL_DISK_PARAMETERS): var OPEN_VIRTUAL_DISK_PARAMETERS_UNION1_Version1 {.inline.} = self.union1.Version1 +proc `ParentFilePath=`*(self: var SET_VIRTUAL_DISK_INFO, x: PCWSTR) {.inline.} = self.union1.ParentFilePath = x +proc ParentFilePath*(self: SET_VIRTUAL_DISK_INFO): PCWSTR {.inline.} = self.union1.ParentFilePath +proc ParentFilePath*(self: var SET_VIRTUAL_DISK_INFO): var PCWSTR {.inline.} = self.union1.ParentFilePath +proc `UniqueIdentifier=`*(self: var SET_VIRTUAL_DISK_INFO, x: GUID) {.inline.} = self.union1.UniqueIdentifier = x +proc UniqueIdentifier*(self: SET_VIRTUAL_DISK_INFO): GUID {.inline.} = self.union1.UniqueIdentifier +proc UniqueIdentifier*(self: var SET_VIRTUAL_DISK_INFO): var GUID {.inline.} = self.union1.UniqueIdentifier +proc `Version1Entries=`*(self: var STORAGE_DEPENDENCY_INFO, x: array[1, STORAGE_DEPENDENCY_INFO_TYPE_1]) {.inline.} = self.union1.Version1Entries = x +proc Version1Entries*(self: STORAGE_DEPENDENCY_INFO): array[1, STORAGE_DEPENDENCY_INFO_TYPE_1] {.inline.} = self.union1.Version1Entries +proc Version1Entries*(self: var STORAGE_DEPENDENCY_INFO): var array[1, STORAGE_DEPENDENCY_INFO_TYPE_1] {.inline.} = self.union1.Version1Entries +proc `Version2Entries=`*(self: var STORAGE_DEPENDENCY_INFO, x: array[1, STORAGE_DEPENDENCY_INFO_TYPE_2]) {.inline.} = self.union1.Version2Entries = x +proc Version2Entries*(self: STORAGE_DEPENDENCY_INFO): array[1, STORAGE_DEPENDENCY_INFO_TYPE_2] {.inline.} = self.union1.Version2Entries +proc Version2Entries*(self: var STORAGE_DEPENDENCY_INFO): var array[1, STORAGE_DEPENDENCY_INFO_TYPE_2] {.inline.} = self.union1.Version2Entries diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/vssym32.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/vssym32.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1551 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +#include +#include +type + AEROWIZARDPARTS* = int32 + TITLEBARSTATES* = int32 + HEADERAREASTATES* = int32 + CONTENTAREASTATES* = int32 + BUTTONPARTS* = int32 + PUSHBUTTONSTATES* = int32 + RADIOBUTTONSTATES* = int32 + CHECKBOXSTATES* = int32 + GROUPBOXSTATES* = int32 + COMMANDLINKSTATES* = int32 + COMMANDLINKGLYPHSTATES* = int32 + COMBOBOXPARTS* = int32 + COMBOBOXSTYLESTATES* = int32 + DROPDOWNBUTTONRIGHTSTATES* = int32 + DROPDOWNBUTTONLEFTSTATES* = int32 + TRANSPARENTBACKGROUNDSTATES* = int32 + BORDERSTATES* = int32 + READONLYSTATES* = int32 + CUEBANNERSTATES* = int32 + COMMUNICATIONSPARTS* = int32 + TABSTATES* = int32 + CONTROLPANELPARTS* = int32 + HELPLINKSTATES* = int32 + TASKLINKSTATES* = int32 + CONTENTLINKSTATES* = int32 + SECTIONTITLELINKSTATES* = int32 + DATEPICKERPARTS* = int32 + DATETEXTSTATES* = int32 + DATEBORDERSTATES* = int32 + SHOWCALENDARBUTTONRIGHTSTATES* = int32 + DRAGDROPPARTS* = int32 + COPYSTATES* = int32 + MOVESTATES* = int32 + UPDATEMETADATASTATES* = int32 + CREATELINKSTATES* = int32 + WARNINGSTATES* = int32 + NONESTATES* = int32 + EDITPARTS* = int32 + EDITTEXTSTATES* = int32 + BACKGROUNDSTATES* = int32 + BACKGROUNDWITHBORDERSTATES* = int32 + EDITBORDER_NOSCROLLSTATES* = int32 + EDITBORDER_HSCROLLSTATES* = int32 + EDITBORDER_VSCROLLSTATES* = int32 + EDITBORDER_HVSCROLLSTATES* = int32 + EXPLORERBARPARTS* = int32 + HEADERCLOSESTATES* = int32 + HEADERPINSTATES* = int32 + IEBARMENUSTATES* = int32 + NORMALGROUPCOLLAPSESTATES* = int32 + NORMALGROUPEXPANDSTATES* = int32 + SPECIALGROUPCOLLAPSESTATES* = int32 + SPECIALGROUPEXPANDSTATES* = int32 + FLYOUTPARTS* = int32 + LABELSTATES* = int32 + LINKSTATES* = int32 + BODYSTATES* = int32 + LINKHEADERSTATES* = int32 + HEADERPARTS* = int32 + HEADERSTYLESTATES* = int32 + HEADERITEMSTATES* = int32 + HEADERITEMLEFTSTATES* = int32 + HEADERITEMRIGHTSTATES* = int32 + HEADERSORTARROWSTATES* = int32 + HEADERDROPDOWNSTATES* = int32 + HEADERDROPDOWNFILTERSTATES* = int32 + HEADEROVERFLOWSTATES* = int32 + LISTBOXPARTS* = int32 + BORDER_HSCROLLSTATES* = int32 + BORDER_HVSCROLLSTATES* = int32 + BORDER_NOSCROLLSTATES* = int32 + BORDER_VSCROLLSTATES* = int32 + ITEMSTATES* = int32 + LISTVIEWPARTS* = int32 + LISTITEMSTATES* = int32 + GROUPHEADERSTATES* = int32 + GROUPHEADERLINESTATES* = int32 + EXPANDBUTTONSTATES* = int32 + COLLAPSEBUTTONSTATES* = int32 + MENUPARTS* = int32 + BARBACKGROUNDSTATES* = int32 + BARITEMSTATES* = int32 + POPUPCHECKSTATES* = int32 + POPUPCHECKBACKGROUNDSTATES* = int32 + POPUPITEMSTATES* = int32 + POPUPSUBMENUSTATES* = int32 + SYSTEMCLOSESTATES* = int32 + SYSTEMMAXIMIZESTATES* = int32 + SYSTEMMINIMIZESTATES* = int32 + SYSTEMRESTORESTATES* = int32 + NAVIGATIONPARTS* = int32 + NAV_BACKBUTTONSTATES* = int32 + NAV_FORWARDBUTTONSTATES* = int32 + NAV_MENUBUTTONSTATES* = int32 + PROGRESSPARTS* = int32 + TRANSPARENTBARSTATES* = int32 + TRANSPARENTBARVERTSTATES* = int32 + FILLSTATES* = int32 + FILLVERTSTATES* = int32 + REBARPARTS* = int32 + CHEVRONSTATES* = int32 + CHEVRONVERTSTATES* = int32 + SPLITTERSTATES* = int32 + SPLITTERVERTSTATES* = int32 + SCROLLBARPARTS* = int32 + ARROWBTNSTATES* = int32 + SCROLLBARSTYLESTATES* = int32 + SIZEBOXSTATES* = int32 + SPINPARTS* = int32 + UPSTATES* = int32 + DOWNSTATES* = int32 + UPHORZSTATES* = int32 + DOWNHORZSTATES* = int32 + STATUSPARTS* = int32 + TABPARTS* = int32 + TABITEMSTATES* = int32 + TABITEMLEFTEDGESTATES* = int32 + TABITEMRIGHTEDGESTATES* = int32 + TABITEMBOTHEDGESTATES* = int32 + TOPTABITEMSTATES* = int32 + TOPTABITEMLEFTEDGESTATES* = int32 + TOPTABITEMRIGHTEDGESTATES* = int32 + TOPTABITEMBOTHEDGESTATES* = int32 + TASKDIALOGPARTS* = int32 + CONTENTPANESTATES* = int32 + EXPANDOBUTTONSTATES* = int32 + TEXTSTYLEPARTS* = int32 + HYPERLINKTEXTSTATES* = int32 + CONTROLLABELSTATES* = int32 + TOOLBARPARTS* = int32 + TOOLBARSTYLESTATES* = int32 + TOOLTIPPARTS* = int32 + CLOSESTATES* = int32 + STANDARDSTATES* = int32 + BALLOONSTATES* = int32 + BALLOONSTEMSTATES* = int32 + WRENCHSTATES* = int32 + TRACKBARPARTS* = int32 + TRACKBARSTYLESTATES* = int32 + TRACKSTATES* = int32 + TRACKVERTSTATES* = int32 + THUMBSTATES* = int32 + THUMBBOTTOMSTATES* = int32 + THUMBTOPSTATES* = int32 + THUMBVERTSTATES* = int32 + THUMBLEFTSTATES* = int32 + THUMBRIGHTSTATES* = int32 + TICSSTATES* = int32 + TICSVERTSTATES* = int32 + TREEVIEWPARTS* = int32 + TREEITEMSTATES* = int32 + GLYPHSTATES* = int32 + HOTGLYPHSTATES* = int32 + WINDOWPARTS* = int32 + FRAMESTATES* = int32 + CAPTIONSTATES* = int32 + MAXCAPTIONSTATES* = int32 + MINCAPTIONSTATES* = int32 + HORZSCROLLSTATES* = int32 + HORZTHUMBSTATES* = int32 + VERTSCROLLSTATES* = int32 + VERTTHUMBSTATES* = int32 + SYSBUTTONSTATES* = int32 + MINBUTTONSTATES* = int32 + MAXBUTTONSTATES* = int32 + RESTOREBUTTONSTATES* = int32 + HELPBUTTONSTATES* = int32 + CLOSEBUTTONSTATES* = int32 + BGTYPE* = int32 + IMAGELAYOUT* = int32 + BORDERTYPE* = int32 + FILLTYPE* = int32 + SIZINGTYPE* = int32 + HALIGN* = int32 + CONTENTALIGNMENT* = int32 + VALIGN* = int32 + OFFSETTYPE* = int32 + ICONEFFECT* = int32 + TEXTSHADOWTYPE* = int32 + GLYPHTYPE* = int32 + IMAGESELECTTYPE* = int32 + TRUESIZESCALINGTYPE* = int32 + GLYPHFONTSIZINGTYPE* = int32 + LINKPARTS* = int32 + HYPERLINKSTATES* = int32 + EMPTYMARKUPPARTS* = int32 + MARKUPTEXTSTATES* = int32 + STATICPARTS* = int32 + PAGEPARTS* = int32 + MONTHCALPARTS* = int32 + GRIDCELLBACKGROUNDSTATES* = int32 + GRIDCELLSTATES* = int32 + GRIDCELLUPPERSTATES* = int32 + TRAILINGGRIDCELLSTATES* = int32 + TRAILINGGRIDCELLUPPERSTATES* = int32 + NAVNEXTSTATES* = int32 + NAVPREVSTATES* = int32 + CLOCKPARTS* = int32 + CLOCKSTATES* = int32 + TRAYNOTIFYPARTS* = int32 + TASKBARPARTS* = int32 + TASKBANDPARTS* = int32 + STARTPANELPARTS* = int32 + MOREPROGRAMSTABSTATES* = int32 + SOFTWAREEXPLORERSTATES* = int32 + OPENBOXSTATES* = int32 + MOREPROGRAMSARROWSTATES* = int32 + MOREPROGRAMSARROWBACKSTATES* = int32 + LOGOFFBUTTONSSTATES* = int32 + MENUBANDPARTS* = int32 + MENUBANDSTATES* = int32 +const + TMTVS_RESERVEDLOW* = 100000 + TMTVS_RESERVEDHIGH* = 19999 + VSCLASS_AEROWIZARDSTYLE* = "AEROWIZARDSTYLE" + VSCLASS_AEROWIZARD* = "AEROWIZARD" + AW_TITLEBAR* = 1 + AW_HEADERAREA* = 2 + AW_CONTENTAREA* = 3 + AW_COMMANDAREA* = 4 + AW_BUTTON* = 5 + AW_S_TITLEBAR_ACTIVE* = 1 + AW_S_TITLEBAR_INACTIVE* = 2 + AW_S_HEADERAREA_NOMARGIN* = 1 + AW_S_CONTENTAREA_NOMARGIN* = 1 + VSCLASS_BUTTONSTYLE* = "BUTTONSTYLE" + VSCLASS_BUTTON* = "BUTTON" + BP_PUSHBUTTON* = 1 + BP_RADIOBUTTON* = 2 + BP_CHECKBOX* = 3 + BP_GROUPBOX* = 4 + BP_USERBUTTON* = 5 + BP_COMMANDLINK* = 6 + BP_COMMANDLINKGLYPH* = 7 + PBS_NORMAL* = 1 + PBS_HOT* = 2 + PBS_PRESSED* = 3 + PBS_DISABLED* = 4 + PBS_DEFAULTED* = 5 + PBS_DEFAULTED_ANIMATING* = 6 + RBS_UNCHECKEDNORMAL* = 1 + RBS_UNCHECKEDHOT* = 2 + RBS_UNCHECKEDPRESSED* = 3 + RBS_UNCHECKEDDISABLED* = 4 + RBS_CHECKEDNORMAL* = 5 + RBS_CHECKEDHOT* = 6 + RBS_CHECKEDPRESSED* = 7 + RBS_CHECKEDDISABLED* = 8 + CBS_UNCHECKEDNORMAL* = 1 + CBS_UNCHECKEDHOT* = 2 + CBS_UNCHECKEDPRESSED* = 3 + CBS_UNCHECKEDDISABLED* = 4 + CBS_CHECKEDNORMAL* = 5 + CBS_CHECKEDHOT* = 6 + CBS_CHECKEDPRESSED* = 7 + CBS_CHECKEDDISABLED* = 8 + CBS_MIXEDNORMAL* = 9 + CBS_MIXEDHOT* = 10 + CBS_MIXEDPRESSED* = 11 + CBS_MIXEDDISABLED* = 12 + CBS_IMPLICITNORMAL* = 13 + CBS_IMPLICITHOT* = 14 + CBS_IMPLICITPRESSED* = 15 + CBS_IMPLICITDISABLED* = 16 + CBS_EXCLUDEDNORMAL* = 17 + CBS_EXCLUDEDHOT* = 18 + CBS_EXCLUDEDPRESSED* = 19 + CBS_EXCLUDEDDISABLED* = 20 + GBS_NORMAL* = 1 + GBS_DISABLED* = 2 + CMDLS_NORMAL* = 1 + CMDLS_HOT* = 2 + CMDLS_PRESSED* = 3 + CMDLS_DISABLED* = 4 + CMDLS_DEFAULTED* = 5 + CMDLS_DEFAULTED_ANIMATING* = 6 + CMDLGS_NORMAL* = 1 + CMDLGS_HOT* = 2 + CMDLGS_PRESSED* = 3 + CMDLGS_DISABLED* = 4 + CMDLGS_DEFAULTED* = 5 + VSCLASS_COMBOBOXSTYLE* = "COMBOBOXSTYLE" + VSCLASS_COMBOBOX* = "COMBOBOX" + CP_DROPDOWNBUTTON* = 1 + CP_BACKGROUND* = 2 + CP_TRANSPARENTBACKGROUND* = 3 + CP_BORDER* = 4 + CP_READONLY* = 5 + CP_DROPDOWNBUTTONRIGHT* = 6 + CP_DROPDOWNBUTTONLEFT* = 7 + CP_CUEBANNER* = 8 + CBXS_NORMAL* = 1 + CBXS_HOT* = 2 + CBXS_PRESSED* = 3 + CBXS_DISABLED* = 4 + CBXSR_NORMAL* = 1 + CBXSR_HOT* = 2 + CBXSR_PRESSED* = 3 + CBXSR_DISABLED* = 4 + CBXSL_NORMAL* = 1 + CBXSL_HOT* = 2 + CBXSL_PRESSED* = 3 + CBXSL_DISABLED* = 4 + CBTBS_NORMAL* = 1 + CBTBS_HOT* = 2 + CBTBS_DISABLED* = 3 + CBTBS_FOCUSED* = 4 + CBB_NORMAL* = 1 + CBB_HOT* = 2 + CBB_FOCUSED* = 3 + CBB_DISABLED* = 4 + CBRO_NORMAL* = 1 + CBRO_HOT* = 2 + CBRO_PRESSED* = 3 + CBRO_DISABLED* = 4 + CBCB_NORMAL* = 1 + CBCB_HOT* = 2 + CBCB_PRESSED* = 3 + CBCB_DISABLED* = 4 + VSCLASS_COMMUNICATIONSSTYLE* = "COMMUNICATIONSSTYLE" + VSCLASS_COMMUNICATIONS* = "COMMUNICATIONS" + CSST_TAB* = 1 + CSTB_NORMAL* = 1 + CSTB_HOT* = 2 + CSTB_SELECTED* = 3 + VSCLASS_CONTROLPANELSTYLE* = "CONTROLPANELSTYLE" + VSCLASS_CONTROLPANEL* = "CONTROLPANE" + CPANEL_NAVIGATIONPANE* = 1 + CPANEL_CONTENTPANE* = 2 + CPANEL_NAVIGATIONPANELABEL* = 3 + CPANEL_CONTENTPANELABEL* = 4 + CPANEL_TITLE* = 5 + CPANEL_BODYTEXT* = 6 + CPANEL_HELPLINK* = 7 + CPANEL_TASKLINK* = 8 + CPANEL_GROUPTEXT* = 9 + CPANEL_CONTENTLINK* = 10 + CPANEL_SECTIONTITLELINK* = 11 + CPANEL_LARGECOMMANDAREA* = 12 + CPANEL_SMALLCOMMANDAREA* = 13 + CPANEL_BUTTON* = 14 + CPANEL_MESSAGETEXT* = 15 + CPANEL_NAVIGATIONPANELINE* = 16 + CPANEL_CONTENTPANELINE* = 17 + CPANEL_BANNERAREA* = 18 + CPANEL_BODYTITLE* = 19 + CPHL_NORMAL* = 1 + CPHL_HOT* = 2 + CPHL_PRESSED* = 3 + CPHL_DISABLED* = 4 + CPTL_NORMAL* = 1 + CPTL_HOT* = 2 + CPTL_PRESSED* = 3 + CPTL_DISABLED* = 4 + CPTL_PAGE* = 5 + CPCL_NORMAL* = 1 + CPCL_HOT* = 2 + CPCL_PRESSED* = 3 + CPCL_DISABLED* = 4 + CPSTL_NORMAL* = 1 + CPSTL_HOT* = 2 + VSCLASS_DATEPICKERSTYLE* = "DATEPICKERSTYLE" + VSCLASS_DATEPICKER* = "DATEPICKER" + DP_DATETEXT* = 1 + DP_DATEBORDER* = 2 + DP_SHOWCALENDARBUTTONRIGHT* = 3 + DPDT_NORMAL* = 1 + DPDT_DISABLED* = 2 + DPDT_SELECTED* = 3 + DPDB_NORMAL* = 1 + DPDB_HOT* = 2 + DPDB_FOCUSED* = 3 + DPDB_DISABLED* = 4 + DPSCBR_NORMAL* = 1 + DPSCBR_HOT* = 2 + DPSCBR_PRESSED* = 3 + DPSCBR_DISABLED* = 4 + VSCLASS_DRAGDROPSTYLE* = "DRAGDROPSTYLE" + VSCLASS_DRAGDROP* = "DRAGDROP" + DD_COPY* = 1 + DD_MOVE* = 2 + DD_UPDATEMETADATA* = 3 + DD_CREATELINK* = 4 + DD_WARNING* = 5 + DD_NONE* = 6 + DD_IMAGEBG* = 7 + DD_TEXTBG* = 8 + DDCOPY_HIGHLIGHT* = 1 + DDCOPY_NOHIGHLIGHT* = 2 + DDMOVE_HIGHLIGHT* = 1 + DDMOVE_NOHIGHLIGHT* = 2 + DDUPDATEMETADATA_HIGHLIGHT* = 1 + DDUPDATEMETADATA_NOHIGHLIGHT* = 2 + DDCREATELINK_HIGHLIGHT* = 1 + DDCREATELINK_NOHIGHLIGHT* = 2 + DDWARNING_HIGHLIGHT* = 1 + DDWARNING_NOHIGHLIGHT* = 2 + DDNONE_HIGHLIGHT* = 1 + DDNONE_NOHIGHLIGHT* = 2 + VSCLASS_EDITSTYLE* = "EDITSTYLE" + VSCLASS_EDIT* = "EDIT" + EP_EDITTEXT* = 1 + EP_CARET* = 2 + EP_BACKGROUND* = 3 + EP_PASSWORD* = 4 + EP_BACKGROUNDWITHBORDER* = 5 + EP_EDITBORDER_NOSCROLL* = 6 + EP_EDITBORDER_HSCROLL* = 7 + EP_EDITBORDER_VSCROLL* = 8 + EP_EDITBORDER_HVSCROLL* = 9 + ETS_NORMAL* = 1 + ETS_HOT* = 2 + ETS_SELECTED* = 3 + ETS_DISABLED* = 4 + ETS_FOCUSED* = 5 + ETS_READONLY* = 6 + ETS_ASSIST* = 7 + ETS_CUEBANNER* = 8 + EBS_NORMAL* = 1 + EBS_HOT* = 2 + EBS_DISABLED* = 3 + EBS_FOCUSED* = 4 + EBS_READONLY* = 5 + EBS_ASSIST* = 6 + EBWBS_NORMAL* = 1 + EBWBS_HOT* = 2 + EBWBS_DISABLED* = 3 + EBWBS_FOCUSED* = 4 + EPSN_NORMAL* = 1 + EPSN_HOT* = 2 + EPSN_FOCUSED* = 3 + EPSN_DISABLED* = 4 + EPSH_NORMAL* = 1 + EPSH_HOT* = 2 + EPSH_FOCUSED* = 3 + EPSH_DISABLED* = 4 + EPSV_NORMAL* = 1 + EPSV_HOT* = 2 + EPSV_FOCUSED* = 3 + EPSV_DISABLED* = 4 + EPSHV_NORMAL* = 1 + EPSHV_HOT* = 2 + EPSHV_FOCUSED* = 3 + EPSHV_DISABLED* = 4 + VSCLASS_EXPLORERBARSTYLE* = "EXPLORERBARSTYLE" + VSCLASS_EXPLORERBAR* = "EXPLORERBAR" + EBP_HEADERBACKGROUND* = 1 + EBP_HEADERCLOSE* = 2 + EBP_HEADERPIN* = 3 + EBP_IEBARMENU* = 4 + EBP_NORMALGROUPBACKGROUND* = 5 + EBP_NORMALGROUPCOLLAPSE* = 6 + EBP_NORMALGROUPEXPAND* = 7 + EBP_NORMALGROUPHEAD* = 8 + EBP_SPECIALGROUPBACKGROUND* = 9 + EBP_SPECIALGROUPCOLLAPSE* = 10 + EBP_SPECIALGROUPEXPAND* = 11 + EBP_SPECIALGROUPHEAD* = 12 + EBHC_NORMAL* = 1 + EBHC_HOT* = 2 + EBHC_PRESSED* = 3 + EBHP_NORMAL* = 1 + EBHP_HOT* = 2 + EBHP_PRESSED* = 3 + EBHP_SELECTEDNORMAL* = 4 + EBHP_SELECTEDHOT* = 5 + EBHP_SELECTEDPRESSED* = 6 + EBM_NORMAL* = 1 + EBM_HOT* = 2 + EBM_PRESSED* = 3 + EBNGC_NORMAL* = 1 + EBNGC_HOT* = 2 + EBNGC_PRESSED* = 3 + EBNGE_NORMAL* = 1 + EBNGE_HOT* = 2 + EBNGE_PRESSED* = 3 + EBSGC_NORMAL* = 1 + EBSGC_HOT* = 2 + EBSGC_PRESSED* = 3 + EBSGE_NORMAL* = 1 + EBSGE_HOT* = 2 + EBSGE_PRESSED* = 3 + VSCLASS_FLYOUTSTYLE* = "FLYOUTSTYLE" + VSCLASS_FLYOUT* = "FLYOUT" + FLYOUT_HEADER* = 1 + FLYOUT_BODY* = 2 + FLYOUT_LABEL* = 3 + FLYOUT_LINK* = 4 + FLYOUT_DIVIDER* = 5 + FLYOUT_WINDOW* = 6 + FLYOUT_LINKAREA* = 7 + FLYOUT_LINKHEADER* = 8 + FLS_NORMAL* = 1 + FLS_SELECTED* = 2 + FLS_EMPHASIZED* = 3 + FLS_DISABLED* = 4 + FLYOUTLINK_NORMAL* = 1 + FLYOUTLINK_HOVER* = 2 + FBS_NORMAL* = 1 + FBS_EMPHASIZED* = 2 + FLH_NORMAL* = 1 + FLH_HOVER* = 2 + VSCLASS_HEADERSTYLE* = "HEADERSTYLE" + VSCLASS_HEADER* = "HEADER" + HP_HEADERITEM* = 1 + HP_HEADERITEMLEFT* = 2 + HP_HEADERITEMRIGHT* = 3 + HP_HEADERSORTARROW* = 4 + HP_HEADERDROPDOWN* = 5 + HP_HEADERDROPDOWNFILTER* = 6 + HP_HEADEROVERFLOW* = 7 + HBG_DETAILS* = 1 + HBG_ICON* = 2 + HIS_NORMAL* = 1 + HIS_HOT* = 2 + HIS_PRESSED* = 3 + HIS_SORTEDNORMAL* = 4 + HIS_SORTEDHOT* = 5 + HIS_SORTEDPRESSED* = 6 + HIS_ICONNORMAL* = 7 + HIS_ICONHOT* = 8 + HIS_ICONPRESSED* = 9 + HIS_ICONSORTEDNORMAL* = 10 + HIS_ICONSORTEDHOT* = 11 + HIS_ICONSORTEDPRESSED* = 12 + HILS_NORMAL* = 1 + HILS_HOT* = 2 + HILS_PRESSED* = 3 + HIRS_NORMAL* = 1 + HIRS_HOT* = 2 + HIRS_PRESSED* = 3 + HSAS_SORTEDUP* = 1 + HSAS_SORTEDDOWN* = 2 + HDDS_NORMAL* = 1 + HDDS_SOFTHOT* = 2 + HDDS_HOT* = 3 + HDDFS_NORMAL* = 1 + HDDFS_SOFTHOT* = 2 + HDDFS_HOT* = 3 + HOFS_NORMAL* = 1 + HOFS_HOT* = 2 + VSCLASS_LISTBOXSTYLE* = "LISTBOXSTYLE" + VSCLASS_LISTBOX* = "LISTBOX" + LBCP_BORDER_HSCROLL* = 1 + LBCP_BORDER_HVSCROLL* = 2 + LBCP_BORDER_NOSCROLL* = 3 + LBCP_BORDER_VSCROLL* = 4 + LBCP_ITEM* = 5 + LBPSH_NORMAL* = 1 + LBPSH_FOCUSED* = 2 + LBPSH_HOT* = 3 + LBPSH_DISABLED* = 4 + LBPSHV_NORMAL* = 1 + LBPSHV_FOCUSED* = 2 + LBPSHV_HOT* = 3 + LBPSHV_DISABLED* = 4 + LBPSN_NORMAL* = 1 + LBPSN_FOCUSED* = 2 + LBPSN_HOT* = 3 + LBPSN_DISABLED* = 4 + LBPSV_NORMAL* = 1 + LBPSV_FOCUSED* = 2 + LBPSV_HOT* = 3 + LBPSV_DISABLED* = 4 + LBPSI_HOT* = 1 + LBPSI_HOTSELECTED* = 2 + LBPSI_SELECTED* = 3 + LBPSI_SELECTEDNOTFOCUS* = 4 + VSCLASS_LISTVIEWSTYLE* = "LISTVIEWSTYLE" + VSCLASS_LISTVIEW* = "LISTVIEW" + LVP_LISTITEM* = 1 + LVP_LISTGROUP* = 2 + LVP_LISTDETAIL* = 3 + LVP_LISTSORTEDDETAIL* = 4 + LVP_EMPTYTEXT* = 5 + LVP_GROUPHEADER* = 6 + LVP_GROUPHEADERLINE* = 7 + LVP_EXPANDBUTTON* = 8 + LVP_COLLAPSEBUTTON* = 9 + LVP_COLUMNDETAIL* = 10 + LISS_NORMAL* = 1 + LISS_HOT* = 2 + LISS_SELECTED* = 3 + LISS_DISABLED* = 4 + LISS_SELECTEDNOTFOCUS* = 5 + LISS_HOTSELECTED* = 6 + LVGH_OPEN* = 1 + LVGH_OPENHOT* = 2 + LVGH_OPENSELECTED* = 3 + LVGH_OPENSELECTEDHOT* = 4 + LVGH_OPENSELECTEDNOTFOCUSED* = 5 + LVGH_OPENSELECTEDNOTFOCUSEDHOT* = 6 + LVGH_OPENMIXEDSELECTION* = 7 + LVGH_OPENMIXEDSELECTIONHOT* = 8 + LVGH_CLOSE* = 9 + LVGH_CLOSEHOT* = 10 + LVGH_CLOSESELECTED* = 11 + LVGH_CLOSESELECTEDHOT* = 12 + LVGH_CLOSESELECTEDNOTFOCUSED* = 13 + LVGH_CLOSESELECTEDNOTFOCUSEDHOT* = 14 + LVGH_CLOSEMIXEDSELECTION* = 15 + LVGH_CLOSEMIXEDSELECTIONHOT* = 16 + LVGHL_OPEN* = 1 + LVGHL_OPENHOT* = 2 + LVGHL_OPENSELECTED* = 3 + LVGHL_OPENSELECTEDHOT* = 4 + LVGHL_OPENSELECTEDNOTFOCUSED* = 5 + LVGHL_OPENSELECTEDNOTFOCUSEDHOT* = 6 + LVGHL_OPENMIXEDSELECTION* = 7 + LVGHL_OPENMIXEDSELECTIONHOT* = 8 + LVGHL_CLOSE* = 9 + LVGHL_CLOSEHOT* = 10 + LVGHL_CLOSESELECTED* = 11 + LVGHL_CLOSESELECTEDHOT* = 12 + LVGHL_CLOSESELECTEDNOTFOCUSED* = 13 + LVGHL_CLOSESELECTEDNOTFOCUSEDHOT* = 14 + LVGHL_CLOSEMIXEDSELECTION* = 15 + LVGHL_CLOSEMIXEDSELECTIONHOT* = 16 + LVEB_NORMAL* = 1 + LVEB_HOVER* = 2 + LVEB_PUSHED* = 3 + LVCB_NORMAL* = 1 + LVCB_HOVER* = 2 + LVCB_PUSHED* = 3 + VSCLASS_MENUSTYLE* = "MENUSTYLE" + VSCLASS_MENU* = "MENU" + MENU_MENUITEM_TMSCHEMA* = 1 + MENU_MENUDROPDOWN_TMSCHEMA* = 2 + MENU_MENUBARITEM_TMSCHEMA* = 3 + MENU_MENUBARDROPDOWN_TMSCHEMA* = 4 + MENU_CHEVRON_TMSCHEMA* = 5 + MENU_SEPARATOR_TMSCHEMA* = 6 + MENU_BARBACKGROUND* = 7 + MENU_BARITEM* = 8 + MENU_POPUPBACKGROUND* = 9 + MENU_POPUPBORDERS* = 10 + MENU_POPUPCHECK* = 11 + MENU_POPUPCHECKBACKGROUND* = 12 + MENU_POPUPGUTTER* = 13 + MENU_POPUPITEM* = 14 + MENU_POPUPSEPARATOR* = 15 + MENU_POPUPSUBMENU* = 16 + MENU_SYSTEMCLOSE* = 17 + MENU_SYSTEMMAXIMIZE* = 18 + MENU_SYSTEMMINIMIZE* = 19 + MENU_SYSTEMRESTORE* = 20 + MB_ACTIVE* = 1 + MB_INACTIVE* = 2 + MBI_NORMAL* = 1 + MBI_HOT* = 2 + MBI_PUSHED* = 3 + MBI_DISABLED* = 4 + MBI_DISABLEDHOT* = 5 + MBI_DISABLEDPUSHED* = 6 + MC_CHECKMARKNORMAL* = 1 + MC_CHECKMARKDISABLED* = 2 + MC_BULLETNORMAL* = 3 + MC_BULLETDISABLED* = 4 + MCB_DISABLED* = 1 + MCB_NORMAL* = 2 + MCB_BITMAP* = 3 + MPI_NORMAL* = 1 + MPI_HOT* = 2 + MPI_DISABLED* = 3 + MPI_DISABLEDHOT* = 4 + MSM_NORMAL* = 1 + MSM_DISABLED* = 2 + MSYSC_NORMAL* = 1 + MSYSC_DISABLED* = 2 + MSYSMX_NORMAL* = 1 + MSYSMX_DISABLED* = 2 + MSYSMN_NORMAL* = 1 + MSYSMN_DISABLED* = 2 + MSYSR_NORMAL* = 1 + MSYSR_DISABLED* = 2 + VSCLASS_NAVIGATION* = "NAVIGATION" + NAV_BACKBUTTON* = 1 + NAV_FORWARDBUTTON* = 2 + NAV_MENUBUTTON* = 3 + NAV_BB_NORMAL* = 1 + NAV_BB_HOT* = 2 + NAV_BB_PRESSED* = 3 + NAV_BB_DISABLED* = 4 + NAV_FB_NORMAL* = 1 + NAV_FB_HOT* = 2 + NAV_FB_PRESSED* = 3 + NAV_FB_DISABLED* = 4 + NAV_MB_NORMAL* = 1 + NAV_MB_HOT* = 2 + NAV_MB_PRESSED* = 3 + NAV_MB_DISABLED* = 4 + VSCLASS_PROGRESSSTYLE* = "PROGRESSSTYLE" + VSCLASS_PROGRESS* = "PROGRESS" + PP_BAR* = 1 + PP_BARVERT* = 2 + PP_CHUNK* = 3 + PP_CHUNKVERT* = 4 + PP_FILL* = 5 + PP_FILLVERT* = 6 + PP_PULSEOVERLAY* = 7 + PP_MOVEOVERLAY* = 8 + PP_PULSEOVERLAYVERT* = 9 + PP_MOVEOVERLAYVERT* = 10 + PP_TRANSPARENTBAR* = 11 + PP_TRANSPARENTBARVERT* = 12 + PBBS_NORMAL* = 1 + PBBS_PARTIAL* = 2 + PBBVS_NORMAL* = 1 + PBBVS_PARTIAL* = 2 + PBFS_NORMAL* = 1 + PBFS_ERROR* = 2 + PBFS_PAUSED* = 3 + PBFS_PARTIAL* = 4 + PBFVS_NORMAL* = 1 + PBFVS_ERROR* = 2 + PBFVS_PAUSED* = 3 + PBFVS_PARTIAL* = 4 + VSCLASS_REBARSTYLE* = "REBARSTYLE" + VSCLASS_REBAR* = "REBAR" + RP_GRIPPER* = 1 + RP_GRIPPERVERT* = 2 + RP_BAND* = 3 + RP_CHEVRON* = 4 + RP_CHEVRONVERT* = 5 + RP_BACKGROUND* = 6 + RP_SPLITTER* = 7 + RP_SPLITTERVERT* = 8 + CHEVS_NORMAL* = 1 + CHEVS_HOT* = 2 + CHEVS_PRESSED* = 3 + CHEVSV_NORMAL* = 1 + CHEVSV_HOT* = 2 + CHEVSV_PRESSED* = 3 + SPLITS_NORMAL* = 1 + SPLITS_HOT* = 2 + SPLITS_PRESSED* = 3 + SPLITSV_NORMAL* = 1 + SPLITSV_HOT* = 2 + SPLITSV_PRESSED* = 3 + VSCLASS_SCROLLBARSTYLE* = "SCROLLBARSTYLE" + VSCLASS_SCROLLBAR* = "SCROLLBAR" + SBP_ARROWBTN* = 1 + SBP_THUMBBTNHORZ* = 2 + SBP_THUMBBTNVERT* = 3 + SBP_LOWERTRACKHORZ* = 4 + SBP_UPPERTRACKHORZ* = 5 + SBP_LOWERTRACKVERT* = 6 + SBP_UPPERTRACKVERT* = 7 + SBP_GRIPPERHORZ* = 8 + SBP_GRIPPERVERT* = 9 + SBP_SIZEBOX* = 10 + ABS_UPNORMAL* = 1 + ABS_UPHOT* = 2 + ABS_UPPRESSED* = 3 + ABS_UPDISABLED* = 4 + ABS_DOWNNORMAL* = 5 + ABS_DOWNHOT* = 6 + ABS_DOWNPRESSED* = 7 + ABS_DOWNDISABLED* = 8 + ABS_LEFTNORMAL* = 9 + ABS_LEFTHOT* = 10 + ABS_LEFTPRESSED* = 11 + ABS_LEFTDISABLED* = 12 + ABS_RIGHTNORMAL* = 13 + ABS_RIGHTHOT* = 14 + ABS_RIGHTPRESSED* = 15 + ABS_RIGHTDISABLED* = 16 + ABS_UPHOVER* = 17 + ABS_DOWNHOVER* = 18 + ABS_LEFTHOVER* = 19 + ABS_RIGHTHOVER* = 20 + SCRBS_NORMAL* = 1 + SCRBS_HOT* = 2 + SCRBS_PRESSED* = 3 + SCRBS_DISABLED* = 4 + SCRBS_HOVER* = 5 + SZB_RIGHTALIGN* = 1 + SZB_LEFTALIGN* = 2 + SZB_TOPRIGHTALIGN* = 3 + SZB_TOPLEFTALIGN* = 4 + SZB_HALFBOTTOMRIGHTALIGN* = 5 + SZB_HALFBOTTOMLEFTALIGN* = 6 + SZB_HALFTOPRIGHTALIGN* = 7 + SZB_HALFTOPLEFTALIGN* = 8 + VSCLASS_SPINSTYLE* = "SPINSTYLE" + VSCLASS_SPIN* = "SPIN" + SPNP_UP* = 1 + SPNP_DOWN* = 2 + SPNP_UPHORZ* = 3 + SPNP_DOWNHORZ* = 4 + UPS_NORMAL* = 1 + UPS_HOT* = 2 + UPS_PRESSED* = 3 + UPS_DISABLED* = 4 + DNS_NORMAL* = 1 + DNS_HOT* = 2 + DNS_PRESSED* = 3 + DNS_DISABLED* = 4 + UPHZS_NORMAL* = 1 + UPHZS_HOT* = 2 + UPHZS_PRESSED* = 3 + UPHZS_DISABLED* = 4 + DNHZS_NORMAL* = 1 + DNHZS_HOT* = 2 + DNHZS_PRESSED* = 3 + DNHZS_DISABLED* = 4 + VSCLASS_STATUSSTYLE* = "STATUSSTYLE" + VSCLASS_STATUS* = "STATUS" + SP_PANE* = 1 + SP_GRIPPERPANE* = 2 + SP_GRIPPER* = 3 + VSCLASS_TABSTYLE* = "TABSTYLE" + VSCLASS_TAB* = "TAB" + TABP_TABITEM* = 1 + TABP_TABITEMLEFTEDGE* = 2 + TABP_TABITEMRIGHTEDGE* = 3 + TABP_TABITEMBOTHEDGE* = 4 + TABP_TOPTABITEM* = 5 + TABP_TOPTABITEMLEFTEDGE* = 6 + TABP_TOPTABITEMRIGHTEDGE* = 7 + TABP_TOPTABITEMBOTHEDGE* = 8 + TABP_PANE* = 9 + TABP_BODY* = 10 + TABP_AEROWIZARDBODY* = 11 + TIS_NORMAL* = 1 + TIS_HOT* = 2 + TIS_SELECTED* = 3 + TIS_DISABLED* = 4 + TIS_FOCUSED* = 5 + TILES_NORMAL* = 1 + TILES_HOT* = 2 + TILES_SELECTED* = 3 + TILES_DISABLED* = 4 + TILES_FOCUSED* = 5 + TIRES_NORMAL* = 1 + TIRES_HOT* = 2 + TIRES_SELECTED* = 3 + TIRES_DISABLED* = 4 + TIRES_FOCUSED* = 5 + TIBES_NORMAL* = 1 + TIBES_HOT* = 2 + TIBES_SELECTED* = 3 + TIBES_DISABLED* = 4 + TIBES_FOCUSED* = 5 + TTIS_NORMAL* = 1 + TTIS_HOT* = 2 + TTIS_SELECTED* = 3 + TTIS_DISABLED* = 4 + TTIS_FOCUSED* = 5 + TTILES_NORMAL* = 1 + TTILES_HOT* = 2 + TTILES_SELECTED* = 3 + TTILES_DISABLED* = 4 + TTILES_FOCUSED* = 5 + TTIRES_NORMAL* = 1 + TTIRES_HOT* = 2 + TTIRES_SELECTED* = 3 + TTIRES_DISABLED* = 4 + TTIRES_FOCUSED* = 5 + TTIBES_NORMAL* = 1 + TTIBES_HOT* = 2 + TTIBES_SELECTED* = 3 + TTIBES_DISABLED* = 4 + TTIBES_FOCUSED* = 5 + VSCLASS_TASKDIALOGSTYLE* = "TASKDIALOGSTYLE" + VSCLASS_TASKDIALOG* = "TASKDIALOG" + TDLG_PRIMARYPANEL* = 1 + TDLG_MAININSTRUCTIONPANE* = 2 + TDLG_MAINICON* = 3 + TDLG_CONTENTPANE* = 4 + TDLG_CONTENTICON* = 5 + TDLG_EXPANDEDCONTENT* = 6 + TDLG_COMMANDLINKPANE* = 7 + TDLG_SECONDARYPANEL* = 8 + TDLG_CONTROLPANE* = 9 + TDLG_BUTTONSECTION* = 10 + TDLG_BUTTONWRAPPER* = 11 + TDLG_EXPANDOTEXT* = 12 + TDLG_EXPANDOBUTTON* = 13 + TDLG_VERIFICATIONTEXT* = 14 + TDLG_FOOTNOTEPANE* = 15 + TDLG_FOOTNOTEAREA* = 16 + TDLG_FOOTNOTESEPARATOR* = 17 + TDLG_EXPANDEDFOOTERAREA* = 18 + TDLG_PROGRESSBAR* = 19 + TDLG_IMAGEALIGNMENT* = 20 + TDLG_RADIOBUTTONPANE* = 21 + TDLGCPS_STANDALONE* = 1 + TDLGEBS_NORMAL* = 1 + TDLGEBS_HOVER* = 2 + TDLGEBS_PRESSED* = 3 + TDLGEBS_EXPANDEDNORMAL* = 4 + TDLGEBS_EXPANDEDHOVER* = 5 + TDLGEBS_EXPANDEDPRESSED* = 6 + VSCLASS_TEXTSTYLE* = "TEXTSTYLE" + TEXT_MAININSTRUCTION* = 1 + TEXT_INSTRUCTION* = 2 + TEXT_BODYTITLE* = 3 + TEXT_BODYTEXT* = 4 + TEXT_SECONDARYTEXT* = 5 + TEXT_HYPERLINKTEXT* = 6 + TEXT_EXPANDED* = 7 + TEXT_LABEL* = 8 + TEXT_CONTROLLABEL* = 9 + TS_HYPERLINK_NORMAL* = 1 + TS_HYPERLINK_HOT* = 2 + TS_HYPERLINK_PRESSED* = 3 + TS_HYPERLINK_DISABLED* = 4 + TS_CONTROLLABEL_NORMAL* = 1 + TS_CONTROLLABEL_DISABLED* = 2 + VSCLASS_TOOLBARSTYLE* = "TOOLBARSTYLE" + VSCLASS_TOOLBAR* = "TOOLBAR" + TP_BUTTON* = 1 + TP_DROPDOWNBUTTON* = 2 + TP_SPLITBUTTON* = 3 + TP_SPLITBUTTONDROPDOWN* = 4 + TP_SEPARATOR* = 5 + TP_SEPARATORVERT* = 6 + TP_DROPDOWNBUTTONGLYPH* = 7 + TS_NORMAL* = 1 + TS_HOT* = 2 + TS_PRESSED* = 3 + TS_DISABLED* = 4 + TS_CHECKED* = 5 + TS_HOTCHECKED* = 6 + TS_NEARHOT* = 7 + TS_OTHERSIDEHOT* = 8 + VSCLASS_TOOLTIPSTYLE* = "TOOLTIPSTYLE" + VSCLASS_TOOLTIP* = "TOOLTIP" + TTP_STANDARD* = 1 + TTP_STANDARDTITLE* = 2 + TTP_BALLOON* = 3 + TTP_BALLOONTITLE* = 4 + TTP_CLOSE* = 5 + TTP_BALLOONSTEM* = 6 + TTP_WRENCH* = 7 + TTCS_NORMAL* = 1 + TTCS_HOT* = 2 + TTCS_PRESSED* = 3 + TTSS_NORMAL* = 1 + TTSS_LINK* = 2 + TTBS_NORMAL* = 1 + TTBS_LINK* = 2 + TTBSS_POINTINGUPLEFTWALL* = 1 + TTBSS_POINTINGUPCENTERED* = 2 + TTBSS_POINTINGUPRIGHTWALL* = 3 + TTBSS_POINTINGDOWNRIGHTWALL* = 4 + TTBSS_POINTINGDOWNCENTERED* = 5 + TTBSS_POINTINGDOWNLEFTWALL* = 6 + TTWS_NORMAL* = 1 + TTWS_HOT* = 2 + TTWS_PRESSED* = 3 + VSCLASS_TRACKBARSTYLE* = "TRACKBARSTYLE" + VSCLASS_TRACKBAR* = "TRACKBAR" + TKP_TRACK* = 1 + TKP_TRACKVERT* = 2 + TKP_THUMB* = 3 + TKP_THUMBBOTTOM* = 4 + TKP_THUMBTOP* = 5 + TKP_THUMBVERT* = 6 + TKP_THUMBLEFT* = 7 + TKP_THUMBRIGHT* = 8 + TKP_TICS* = 9 + TKP_TICSVERT* = 10 + TKS_NORMAL* = 1 + TRS_NORMAL* = 1 + TRVS_NORMAL* = 1 + TUS_NORMAL* = 1 + TUS_HOT* = 2 + TUS_PRESSED* = 3 + TUS_FOCUSED* = 4 + TUS_DISABLED* = 5 + TUBS_NORMAL* = 1 + TUBS_HOT* = 2 + TUBS_PRESSED* = 3 + TUBS_FOCUSED* = 4 + TUBS_DISABLED* = 5 + TUTS_NORMAL* = 1 + TUTS_HOT* = 2 + TUTS_PRESSED* = 3 + TUTS_FOCUSED* = 4 + TUTS_DISABLED* = 5 + TUVS_NORMAL* = 1 + TUVS_HOT* = 2 + TUVS_PRESSED* = 3 + TUVS_FOCUSED* = 4 + TUVS_DISABLED* = 5 + TUVLS_NORMAL* = 1 + TUVLS_HOT* = 2 + TUVLS_PRESSED* = 3 + TUVLS_FOCUSED* = 4 + TUVLS_DISABLED* = 5 + TUVRS_NORMAL* = 1 + TUVRS_HOT* = 2 + TUVRS_PRESSED* = 3 + TUVRS_FOCUSED* = 4 + TUVRS_DISABLED* = 5 + TSS_NORMAL* = 1 + TSVS_NORMAL* = 1 + VSCLASS_TREEVIEWSTYLE* = "TREEVIEWSTYLE" + VSCLASS_TREEVIEW* = "TREEVIEW" + TVP_TREEITEM* = 1 + TVP_GLYPH* = 2 + TVP_BRANCH* = 3 + TVP_HOTGLYPH* = 4 + TREIS_NORMAL* = 1 + TREIS_HOT* = 2 + TREIS_SELECTED* = 3 + TREIS_DISABLED* = 4 + TREIS_SELECTEDNOTFOCUS* = 5 + TREIS_HOTSELECTED* = 6 + GLPS_CLOSED* = 1 + GLPS_OPENED* = 2 + HGLPS_CLOSED* = 1 + HGLPS_OPENED* = 2 + VSCLASS_WINDOWSTYLE* = "WINDOWSTYLE" + VSCLASS_WINDOW* = "WINDOW" + WP_CAPTION* = 1 + WP_SMALLCAPTION* = 2 + WP_MINCAPTION* = 3 + WP_SMALLMINCAPTION* = 4 + WP_MAXCAPTION* = 5 + WP_SMALLMAXCAPTION* = 6 + WP_FRAMELEFT* = 7 + WP_FRAMERIGHT* = 8 + WP_FRAMEBOTTOM* = 9 + WP_SMALLFRAMELEFT* = 10 + WP_SMALLFRAMERIGHT* = 11 + WP_SMALLFRAMEBOTTOM* = 12 + WP_SYSBUTTON* = 13 + WP_MDISYSBUTTON* = 14 + WP_MINBUTTON* = 15 + WP_MDIMINBUTTON* = 16 + WP_MAXBUTTON* = 17 + WP_CLOSEBUTTON* = 18 + WP_SMALLCLOSEBUTTON* = 19 + WP_MDICLOSEBUTTON* = 20 + WP_RESTOREBUTTON* = 21 + WP_MDIRESTOREBUTTON* = 22 + WP_HELPBUTTON* = 23 + WP_MDIHELPBUTTON* = 24 + WP_HORZSCROLL* = 25 + WP_HORZTHUMB* = 26 + WP_VERTSCROLL* = 27 + WP_VERTTHUMB* = 28 + WP_DIALOG* = 29 + WP_CAPTIONSIZINGTEMPLATE* = 30 + WP_SMALLCAPTIONSIZINGTEMPLATE* = 31 + WP_FRAMELEFTSIZINGTEMPLATE* = 32 + WP_SMALLFRAMELEFTSIZINGTEMPLATE* = 33 + WP_FRAMERIGHTSIZINGTEMPLATE* = 34 + WP_SMALLFRAMERIGHTSIZINGTEMPLATE* = 35 + WP_FRAMEBOTTOMSIZINGTEMPLATE* = 36 + WP_SMALLFRAMEBOTTOMSIZINGTEMPLATE* = 37 + WP_FRAME* = 38 + FS_ACTIVE* = 1 + FS_INACTIVE* = 2 + CS_ACTIVE* = 1 + CS_INACTIVE* = 2 + CS_DISABLED* = 3 + MXCS_ACTIVE* = 1 + MXCS_INACTIVE* = 2 + MXCS_DISABLED* = 3 + MNCS_ACTIVE* = 1 + MNCS_INACTIVE* = 2 + MNCS_DISABLED* = 3 + HSS_NORMAL* = 1 + HSS_HOT* = 2 + HSS_PUSHED* = 3 + HSS_DISABLED* = 4 + HTS_NORMAL* = 1 + HTS_HOT* = 2 + HTS_PUSHED* = 3 + HTS_DISABLED* = 4 + VSS_NORMAL* = 1 + VSS_HOT* = 2 + VSS_PUSHED* = 3 + VSS_DISABLED* = 4 + VTS_NORMAL* = 1 + VTS_HOT* = 2 + VTS_PUSHED* = 3 + VTS_DISABLED* = 4 + SBS_NORMAL* = 1 + SBS_HOT* = 2 + SBS_PUSHED* = 3 + SBS_DISABLED* = 4 + MINBS_NORMAL* = 1 + MINBS_HOT* = 2 + MINBS_PUSHED* = 3 + MINBS_DISABLED* = 4 + MAXBS_NORMAL* = 1 + MAXBS_HOT* = 2 + MAXBS_PUSHED* = 3 + MAXBS_DISABLED* = 4 + RBS_NORMAL* = 1 + RBS_HOT* = 2 + RBS_PUSHED* = 3 + RBS_DISABLED* = 4 + HBS_NORMAL* = 1 + HBS_HOT* = 2 + HBS_PUSHED* = 3 + HBS_DISABLED* = 4 + CBS_NORMAL* = 1 + CBS_HOT* = 2 + CBS_PUSHED* = 3 + CBS_DISABLED* = 4 + BT_IMAGEFILE* = 0 + BT_BORDERFILL* = 1 + BT_NONE* = 2 + IL_VERTICAL* = 0 + IL_HORIZONTAL* = 1 + BT_RECT* = 0 + BT_ROUNDRECT* = 1 + BT_ELLIPSE* = 2 + FT_SOLID* = 0 + FT_VERTGRADIENT* = 1 + FT_HORZGRADIENT* = 2 + FT_RADIALGRADIENT* = 3 + FT_TILEIMAGE* = 4 + ST_TRUESIZE* = 0 + ST_STRETCH* = 1 + ST_TILE* = 2 + HA_LEFT* = 0 + HA_CENTER* = 1 + HA_RIGHT* = 2 + CA_LEFT* = 0 + CA_CENTER* = 1 + CA_RIGHT* = 2 + VA_TOP* = 0 + VA_CENTER* = 1 + VA_BOTTOM* = 2 + OT_TOPLEFT* = 0 + OT_TOPRIGHT* = 1 + OT_TOPMIDDLE* = 2 + OT_BOTTOMLEFT* = 3 + OT_BOTTOMRIGHT* = 4 + OT_BOTTOMMIDDLE* = 5 + OT_MIDDLELEFT* = 6 + OT_MIDDLERIGHT* = 7 + OT_LEFTOFCAPTION* = 8 + OT_RIGHTOFCAPTION* = 9 + OT_LEFTOFLASTBUTTON* = 10 + OT_RIGHTOFLASTBUTTON* = 11 + OT_ABOVELASTBUTTON* = 12 + OT_BELOWLASTBUTTON* = 13 + ICE_NONE* = 0 + ICE_GLOW* = 1 + ICE_SHADOW* = 2 + ICE_PULSE* = 3 + ICE_ALPHA* = 4 + TST_NONE* = 0 + TST_SINGLE* = 1 + TST_CONTINUOUS* = 2 + GT_NONE* = 0 + GT_IMAGEGLYPH* = 1 + GT_FONTGLYPH* = 2 + IST_NONE* = 0 + IST_SIZE* = 1 + IST_DPI* = 2 + TSST_NONE* = 0 + TSST_SIZE* = 1 + TSST_DPI* = 2 + GFST_NONE* = 0 + GFST_SIZE* = 1 + GFST_DPI* = 2 + TMT_RESERVEDLOW* = 0 + TMT_RESERVEDHIGH* = 7999 + TMT_DIBDATA* = 2 + TMT_GLYPHDIBDATA* = 8 + TMT_ENUM* = 200 + TMT_STRING* = 201 + TMT_INT* = 202 + TMT_BOOL* = 203 + TMT_COLOR* = 204 + TMT_MARGINS* = 205 + TMT_FILENAME* = 206 + TMT_SIZE* = 207 + TMT_POSITION* = 208 + TMT_RECT* = 209 + TMT_FONT* = 210 + TMT_INTLIST* = 211 + TMT_HBITMAP* = 212 + TMT_DISKSTREAM* = 213 + TMT_STREAM* = 214 + TMT_BITMAPREF* = 215 + TMT_COLORSCHEMES* = 401 + TMT_SIZES* = 402 + TMT_CHARSET* = 403 + TMT_NAME* = 600 + TMT_DISPLAYNAME* = 601 + TMT_TOOLTIP* = 602 + TMT_COMPANY* = 603 + TMT_AUTHOR* = 604 + TMT_COPYRIGHT* = 605 + TMT_URL* = 606 + TMT_VERSION* = 607 + TMT_DESCRIPTION* = 608 + TMT_FIRST_RCSTRING_NAME* = TMT_DISPLAYNAME + TMT_LAST_RCSTRING_NAME* = TMT_DESCRIPTION + TMT_CAPTIONFONT* = 801 + TMT_SMALLCAPTIONFONT* = 802 + TMT_MENUFONT* = 803 + TMT_STATUSFONT* = 804 + TMT_MSGBOXFONT* = 805 + TMT_ICONTITLEFONT* = 806 + TMT_HEADING1FONT* = 807 + TMT_HEADING2FONT* = 808 + TMT_BODYFONT* = 809 + TMT_FIRSTFONT* = TMT_CAPTIONFONT + TMT_LASTFONT* = TMT_BODYFONT + TMT_FLATMENUS* = 1001 + TMT_FIRSTBOOL* = TMT_FLATMENUS + TMT_LASTBOOL* = TMT_FLATMENUS + TMT_SIZINGBORDERWIDTH* = 1201 + TMT_SCROLLBARWIDTH* = 1202 + TMT_SCROLLBARHEIGHT* = 1203 + TMT_CAPTIONBARWIDTH* = 1204 + TMT_CAPTIONBARHEIGHT* = 1205 + TMT_SMCAPTIONBARWIDTH* = 1206 + TMT_SMCAPTIONBARHEIGHT* = 1207 + TMT_MENUBARWIDTH* = 1208 + TMT_MENUBARHEIGHT* = 1209 + TMT_PADDEDBORDERWIDTH* = 1210 + TMT_FIRSTSIZE* = TMT_SIZINGBORDERWIDTH + TMT_LASTSIZE* = TMT_PADDEDBORDERWIDTH + TMT_MINCOLORDEPTH* = 1301 + TMT_FIRSTINT* = TMT_MINCOLORDEPTH + TMT_LASTINT* = TMT_MINCOLORDEPTH + TMT_CSSNAME* = 1401 + TMT_XMLNAME* = 1402 + TMT_LASTUPDATED* = 1403 + TMT_ALIAS* = 1404 + TMT_FIRSTSTRING* = TMT_CSSNAME + TMT_LASTSTRING* = TMT_ALIAS + TMT_SCROLLBAR* = 1601 + TMT_BACKGROUND* = 1602 + TMT_ACTIVECAPTION* = 1603 + TMT_INACTIVECAPTION* = 1604 + TMT_MENU* = 1605 + TMT_WINDOW* = 1606 + TMT_WINDOWFRAME* = 1607 + TMT_MENUTEXT* = 1608 + TMT_WINDOWTEXT* = 1609 + TMT_CAPTIONTEXT* = 1610 + TMT_ACTIVEBORDER* = 1611 + TMT_INACTIVEBORDER* = 1612 + TMT_APPWORKSPACE* = 1613 + TMT_HIGHLIGHT* = 1614 + TMT_HIGHLIGHTTEXT* = 1615 + TMT_BTNFACE* = 1616 + TMT_BTNSHADOW* = 1617 + TMT_GRAYTEXT* = 1618 + TMT_BTNTEXT* = 1619 + TMT_INACTIVECAPTIONTEXT* = 1620 + TMT_BTNHIGHLIGHT* = 1621 + TMT_DKSHADOW3D* = 1622 + TMT_LIGHT3D* = 1623 + TMT_INFOTEXT* = 1624 + TMT_INFOBK* = 1625 + TMT_BUTTONALTERNATEFACE* = 1626 + TMT_HOTTRACKING* = 1627 + TMT_GRADIENTACTIVECAPTION* = 1628 + TMT_GRADIENTINACTIVECAPTION* = 1629 + TMT_MENUHILIGHT* = 1630 + TMT_MENUBAR* = 1631 + TMT_FIRSTCOLOR* = TMT_SCROLLBAR + TMT_LASTCOLOR* = TMT_MENUBAR + TMT_FROMHUE1* = 1801 + TMT_FROMHUE2* = 1802 + TMT_FROMHUE3* = 1803 + TMT_FROMHUE4* = 1804 + TMT_FROMHUE5* = 1805 + TMT_TOHUE1* = 1806 + TMT_TOHUE2* = 1807 + TMT_TOHUE3* = 1808 + TMT_TOHUE4* = 1809 + TMT_TOHUE5* = 1810 + TMT_FROMCOLOR1* = 2001 + TMT_FROMCOLOR2* = 2002 + TMT_FROMCOLOR3* = 2003 + TMT_FROMCOLOR4* = 2004 + TMT_FROMCOLOR5* = 2005 + TMT_TOCOLOR1* = 2006 + TMT_TOCOLOR2* = 2007 + TMT_TOCOLOR3* = 2008 + TMT_TOCOLOR4* = 2009 + TMT_TOCOLOR5* = 2010 + TMT_TRANSPARENT* = 2201 + TMT_AUTOSIZE* = 2202 + TMT_BORDERONLY* = 2203 + TMT_COMPOSITED* = 2204 + TMT_BGFILL* = 2205 + TMT_GLYPHTRANSPARENT* = 2206 + TMT_GLYPHONLY* = 2207 + TMT_ALWAYSSHOWSIZINGBAR* = 2208 + TMT_MIRRORIMAGE* = 2209 + TMT_UNIFORMSIZING* = 2210 + TMT_INTEGRALSIZING* = 2211 + TMT_SOURCEGROW* = 2212 + TMT_SOURCESHRINK* = 2213 + TMT_DRAWBORDERS* = 2214 + TMT_NOETCHEDEFFECT* = 2215 + TMT_TEXTAPPLYOVERLAY* = 2216 + TMT_TEXTGLOW* = 2217 + TMT_TEXTITALIC* = 2218 + TMT_COMPOSITEDOPAQUE* = 2219 + TMT_LOCALIZEDMIRRORIMAGE* = 2220 + TMT_IMAGECOUNT* = 2401 + TMT_ALPHALEVEL* = 2402 + TMT_BORDERSIZE* = 2403 + TMT_ROUNDCORNERWIDTH* = 2404 + TMT_ROUNDCORNERHEIGHT* = 2405 + TMT_GRADIENTRATIO1* = 2406 + TMT_GRADIENTRATIO2* = 2407 + TMT_GRADIENTRATIO3* = 2408 + TMT_GRADIENTRATIO4* = 2409 + TMT_GRADIENTRATIO5* = 2410 + TMT_PROGRESSCHUNKSIZE* = 2411 + TMT_PROGRESSSPACESIZE* = 2412 + TMT_SATURATION* = 2413 + TMT_TEXTBORDERSIZE* = 2414 + TMT_ALPHATHRESHOLD* = 2415 + TMT_WIDTH* = 2416 + TMT_HEIGHT* = 2417 + TMT_GLYPHINDEX* = 2418 + TMT_TRUESIZESTRETCHMARK* = 2419 + TMT_MINDPI1* = 2420 + TMT_MINDPI2* = 2421 + TMT_MINDPI3* = 2422 + TMT_MINDPI4* = 2423 + TMT_MINDPI5* = 2424 + TMT_TEXTGLOWSIZE* = 2425 + TMT_FRAMESPERSECOND* = 2426 + TMT_PIXELSPERFRAME* = 2427 + TMT_ANIMATIONDELAY* = 2428 + TMT_GLOWINTENSITY* = 2429 + TMT_OPACITY* = 2430 + TMT_COLORIZATIONCOLOR* = 2431 + TMT_COLORIZATIONOPACITY* = 2432 + TMT_GLYPHFONT* = 2601 + TMT_IMAGEFILE* = 3001 + TMT_IMAGEFILE1* = 3002 + TMT_IMAGEFILE2* = 3003 + TMT_IMAGEFILE3* = 3004 + TMT_IMAGEFILE4* = 3005 + TMT_IMAGEFILE5* = 3006 + TMT_GLYPHIMAGEFILE* = 3008 + TMT_TEXT* = 3201 + TMT_CLASSICVALUE* = 3202 + TMT_OFFSET* = 3401 + TMT_TEXTSHADOWOFFSET* = 3402 + TMT_MINSIZE* = 3403 + TMT_MINSIZE1* = 3404 + TMT_MINSIZE2* = 3405 + TMT_MINSIZE3* = 3406 + TMT_MINSIZE4* = 3407 + TMT_MINSIZE5* = 3408 + TMT_NORMALSIZE* = 3409 + TMT_SIZINGMARGINS* = 3601 + TMT_CONTENTMARGINS* = 3602 + TMT_CAPTIONMARGINS* = 3603 + TMT_BORDERCOLOR* = 3801 + TMT_FILLCOLOR* = 3802 + TMT_TEXTCOLOR* = 3803 + TMT_EDGELIGHTCOLOR* = 3804 + TMT_EDGEHIGHLIGHTCOLOR* = 3805 + TMT_EDGESHADOWCOLOR* = 3806 + TMT_EDGEDKSHADOWCOLOR* = 3807 + TMT_EDGEFILLCOLOR* = 3808 + TMT_TRANSPARENTCOLOR* = 3809 + TMT_GRADIENTCOLOR1* = 3810 + TMT_GRADIENTCOLOR2* = 3811 + TMT_GRADIENTCOLOR3* = 3812 + TMT_GRADIENTCOLOR4* = 3813 + TMT_GRADIENTCOLOR5* = 3814 + TMT_SHADOWCOLOR* = 3815 + TMT_GLOWCOLOR* = 3816 + TMT_TEXTBORDERCOLOR* = 3817 + TMT_TEXTSHADOWCOLOR* = 3818 + TMT_GLYPHTEXTCOLOR* = 3819 + TMT_GLYPHTRANSPARENTCOLOR* = 3820 + TMT_FILLCOLORHINT* = 3821 + TMT_BORDERCOLORHINT* = 3822 + TMT_ACCENTCOLORHINT* = 3823 + TMT_TEXTCOLORHINT* = 3824 + TMT_HEADING1TEXTCOLOR* = 3825 + TMT_HEADING2TEXTCOLOR* = 3826 + TMT_BODYTEXTCOLOR* = 3827 + TMT_BGTYPE* = 4001 + TMT_BORDERTYPE* = 4002 + TMT_FILLTYPE* = 4003 + TMT_SIZINGTYPE* = 4004 + TMT_HALIGN* = 4005 + TMT_CONTENTALIGNMENT* = 4006 + TMT_VALIGN* = 4007 + TMT_OFFSETTYPE* = 4008 + TMT_ICONEFFECT* = 4009 + TMT_TEXTSHADOWTYPE* = 4010 + TMT_IMAGELAYOUT* = 4011 + TMT_GLYPHTYPE* = 4012 + TMT_IMAGESELECTTYPE* = 4013 + TMT_GLYPHFONTSIZINGTYPE* = 4014 + TMT_TRUESIZESCALINGTYPE* = 4015 + TMT_USERPICTURE* = 5001 + TMT_DEFAULTPANESIZE* = 5002 + TMT_BLENDCOLOR* = 5003 + TMT_CUSTOMSPLITRECT* = 5004 + TMT_ANIMATIONBUTTONRECT* = 5005 + TMT_ANIMATIONDURATION* = 5006 + TMT_TRANSITIONDURATIONS* = 6000 + TMT_SCALEDBACKGROUND* = 7001 + TMT_ATLASIMAGE* = 8000 + TMT_ATLASINPUTIMAGE* = 8001 + TMT_ATLASRECT* = 8002 + VSCLASS_LINK* = "LINK" + LP_HYPERLINK* = 1 + HLS_NORMALTEXT* = 1 + HLS_LINKTEXT* = 2 + VSCLASS_EMPTYMARKUP* = "EMPTYMARKUP" + EMP_MARKUPTEXT* = 1 + EMT_NORMALTEXT* = 1 + EMT_LINKTEXT* = 2 + VSCLASS_STATIC* = "STATIC" + STAT_TEXT* = 1 + VSCLASS_PAGE* = "PAGE" + PGRP_UP* = 1 + PGRP_DOWN* = 2 + PGRP_UPHORZ* = 3 + PGRP_DOWNHORZ* = 4 + VSCLASS_MONTHCAL* = "MONTHCA" + MC_BACKGROUND* = 1 + MC_BORDERS* = 2 + MC_GRIDBACKGROUND* = 3 + MC_COLHEADERSPLITTER* = 4 + MC_GRIDCELLBACKGROUND* = 5 + MC_GRIDCELL* = 6 + MC_GRIDCELLUPPER* = 7 + MC_TRAILINGGRIDCELL* = 8 + MC_TRAILINGGRIDCELLUPPER* = 9 + MC_NAVNEXT* = 10 + MC_NAVPREV* = 11 + MCGCB_SELECTED* = 1 + MCGCB_HOT* = 2 + MCGCB_SELECTEDHOT* = 3 + MCGCB_SELECTEDNOTFOCUSED* = 4 + MCGCB_TODAY* = 5 + MCGC_HOT* = 1 + MCGC_HASSTATE* = 2 + MCGC_HASSTATEHOT* = 3 + MCGC_TODAY* = 4 + MCGCU_HOT* = 1 + MCGCU_HASSTATE* = 2 + MCGCU_HASSTATEHOT* = 3 + MCTGC_HOT* = 1 + MCTGC_HASSTATE* = 2 + MCTGC_HASSTATEHOT* = 3 + MCTGC_TODAY* = 4 + MCTGCU_HOT* = 1 + MCTGCU_HASSTATE* = 2 + MCTGCU_HASSTATEHOT* = 3 + MCNN_NORMAL* = 1 + MCNN_HOT* = 2 + MCNN_PRESSED* = 3 + MCNN_DISABLED* = 4 + MCNP_NORMAL* = 1 + MCNP_HOT* = 2 + MCNP_PRESSED* = 3 + MCNP_DISABLED* = 4 + VSCLASS_CLOCK* = "CLOCK" + CLP_TIME* = 1 + CLS_NORMAL* = 1 + CLS_HOT* = 2 + CLS_PRESSED* = 3 + VSCLASS_TRAYNOTIFY* = "TRAYNOTIFY" + TNP_BACKGROUND* = 1 + TNP_ANIMBACKGROUND* = 2 + VSCLASS_TASKBAR* = "TASKBAR" + TBP_BACKGROUNDBOTTOM* = 1 + TBP_BACKGROUNDRIGHT* = 2 + TBP_BACKGROUNDTOP* = 3 + TBP_BACKGROUNDLEFT* = 4 + TBP_SIZINGBARBOTTOM* = 5 + TBP_SIZINGBARRIGHT* = 6 + TBP_SIZINGBARTOP* = 7 + TBP_SIZINGBARLEFT* = 8 + VSCLASS_TASKBAND* = "TASKBAND" + TDP_GROUPCOUNT* = 1 + TDP_FLASHBUTTON* = 2 + TDP_FLASHBUTTONGROUPMENU* = 3 + VSCLASS_STARTPANEL* = "STARTPANE" + SPP_USERPANE* = 1 + SPP_MOREPROGRAMS* = 2 + SPP_MOREPROGRAMSARROW* = 3 + SPP_PROGLIST* = 4 + SPP_PROGLISTSEPARATOR* = 5 + SPP_PLACESLIST* = 6 + SPP_PLACESLISTSEPARATOR* = 7 + SPP_LOGOFF* = 8 + SPP_LOGOFFBUTTONS* = 9 + SPP_USERPICTURE* = 10 + SPP_PREVIEW* = 11 + SPP_MOREPROGRAMSTAB* = 12 + SPP_NSCHOST* = 13 + SPP_SOFTWAREEXPLORER* = 14 + SPP_OPENBOX* = 15 + SPP_SEARCHVIEW* = 16 + SPP_MOREPROGRAMSARROWBACK* = 17 + SPP_TOPMATCH* = 18 + SPP_LOGOFFSPLITBUTTONDROPDOWN* = 19 + SPMPT_NORMAL* = 1 + SPMPT_HOT* = 2 + SPMPT_SELECTED* = 3 + SPMPT_DISABLED* = 4 + SPMPT_FOCUSED* = 5 + SPSE_NORMAL* = 1 + SPSE_HOT* = 2 + SPSE_SELECTED* = 3 + SPSE_DISABLED* = 4 + SPSE_FOCUSED* = 5 + SPOB_NORMAL* = 1 + SPOB_HOT* = 2 + SPOB_SELECTED* = 3 + SPOB_DISABLED* = 4 + SPOB_FOCUSED* = 5 + SPS_NORMAL* = 1 + SPS_HOT* = 2 + SPS_PRESSED* = 3 + SPSB_NORMAL* = 1 + SPSB_HOT* = 2 + SPSB_PRESSED* = 3 + SPLS_NORMAL* = 1 + SPLS_HOT* = 2 + SPLS_PRESSED* = 3 + VSCLASS_MENUBAND* = "MENUBAND" + MDP_NEWAPPBUTTON* = 1 + MDP_SEPERATOR* = 2 + MDS_NORMAL* = 1 + MDS_HOT* = 2 + MDS_PRESSED* = 3 + MDS_DISABLED* = 4 + MDS_CHECKED* = 5 + MDS_HOTCHECKED* = 6 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winbase.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winbase.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,3313 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + FINDEX_INFO_LEVELS* = int32 + FINDEX_SEARCH_OPS* = int32 + GET_FILEEX_INFO_LEVELS* = int32 + FILE_INFO_BY_HANDLE_CLASS* = int32 + PFILE_INFO_BY_HANDLE_CLASS* = ptr int32 + MEMORY_RESOURCE_NOTIFICATION_TYPE* = int32 + OFFER_PRIORITY* = int32 + COMPUTER_NAME_FORMAT* = int32 + THREAD_INFORMATION_CLASS* = int32 + PROCESS_INFORMATION_CLASS* = int32 + DEP_SYSTEM_POLICY_TYPE* = int32 + PROC_THREAD_ATTRIBUTE_NUM* = int32 + COPYFILE2_MESSAGE_TYPE* = int32 + COPYFILE2_MESSAGE_ACTION* = int32 + COPYFILE2_COPY_PHASE* = int32 + STREAM_INFO_LEVELS* = int32 + PRIORITY_HINT* = int32 + FILE_ID_TYPE* = int32 + PFILE_ID_TYPE* = ptr int32 + BAD_MEMORY_CALLBACK_ROUTINE* = pointer + DLL_DIRECTORY_COOKIE* = PVOID + PDLL_DIRECTORY_COOKIE* = ptr PVOID + OPERATION_ID* = ULONG + SECURITY_ATTRIBUTES* {.pure.} = object + nLength*: DWORD + lpSecurityDescriptor*: LPVOID + bInheritHandle*: WINBOOL + PSECURITY_ATTRIBUTES* = ptr SECURITY_ATTRIBUTES + LPSECURITY_ATTRIBUTES* = ptr SECURITY_ATTRIBUTES + OVERLAPPED_UNION1_STRUCT1* {.pure.} = object + Offset*: DWORD + OffsetHigh*: DWORD + OVERLAPPED_UNION1* {.pure, union.} = object + struct1*: OVERLAPPED_UNION1_STRUCT1 + Pointer*: PVOID + OVERLAPPED* {.pure.} = object + Internal*: ULONG_PTR + InternalHigh*: ULONG_PTR + union1*: OVERLAPPED_UNION1 + hEvent*: HANDLE + LPOVERLAPPED* = ptr OVERLAPPED + OVERLAPPED_ENTRY* {.pure.} = object + lpCompletionKey*: ULONG_PTR + lpOverlapped*: LPOVERLAPPED + Internal*: ULONG_PTR + dwNumberOfBytesTransferred*: DWORD + LPOVERLAPPED_ENTRY* = ptr OVERLAPPED_ENTRY + SYSTEMTIME* {.pure.} = object + wYear*: WORD + wMonth*: WORD + wDayOfWeek*: WORD + wDay*: WORD + wHour*: WORD + wMinute*: WORD + wSecond*: WORD + wMilliseconds*: WORD + PSYSTEMTIME* = ptr SYSTEMTIME + LPSYSTEMTIME* = ptr SYSTEMTIME + WIN32_FIND_DATAA* {.pure.} = object + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + dwReserved0*: DWORD + dwReserved1*: DWORD + cFileName*: array[MAX_PATH, CHAR] + cAlternateFileName*: array[14, CHAR] + PWIN32_FIND_DATAA* = ptr WIN32_FIND_DATAA + LPWIN32_FIND_DATAA* = ptr WIN32_FIND_DATAA + WIN32_FIND_DATAW* {.pure.} = object + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + dwReserved0*: DWORD + dwReserved1*: DWORD + cFileName*: array[MAX_PATH, WCHAR] + cAlternateFileName*: array[14, WCHAR] + PWIN32_FIND_DATAW* = ptr WIN32_FIND_DATAW + LPWIN32_FIND_DATAW* = ptr WIN32_FIND_DATAW + CRITICAL_SECTION* = RTL_CRITICAL_SECTION + PCRITICAL_SECTION* = PRTL_CRITICAL_SECTION + LPCRITICAL_SECTION* = PRTL_CRITICAL_SECTION + CRITICAL_SECTION_DEBUG* = RTL_CRITICAL_SECTION_DEBUG + PCRITICAL_SECTION_DEBUG* = PRTL_CRITICAL_SECTION_DEBUG + LPCRITICAL_SECTION_DEBUG* = PRTL_CRITICAL_SECTION_DEBUG + PROCESS_HEAP_ENTRY_UNION1_Block* {.pure.} = object + hMem*: HANDLE + dwReserved*: array[3, DWORD] + PROCESS_HEAP_ENTRY_UNION1_Region* {.pure.} = object + dwCommittedSize*: DWORD + dwUnCommittedSize*: DWORD + lpFirstBlock*: LPVOID + lpLastBlock*: LPVOID + PROCESS_HEAP_ENTRY_UNION1* {.pure, union.} = object + Block*: PROCESS_HEAP_ENTRY_UNION1_Block + Region*: PROCESS_HEAP_ENTRY_UNION1_Region + PROCESS_HEAP_ENTRY* {.pure.} = object + lpData*: PVOID + cbData*: DWORD + cbOverhead*: BYTE + iRegionIndex*: BYTE + wFlags*: WORD + union1*: PROCESS_HEAP_ENTRY_UNION1 + LPPROCESS_HEAP_ENTRY* = ptr PROCESS_HEAP_ENTRY + PPROCESS_HEAP_ENTRY* = ptr PROCESS_HEAP_ENTRY + REASON_CONTEXT_Reason_Detailed* {.pure.} = object + LocalizedReasonModule*: HMODULE + LocalizedReasonId*: ULONG + ReasonStringCount*: ULONG + ReasonStrings*: ptr LPWSTR + REASON_CONTEXT_Reason* {.pure, union.} = object + Detailed*: REASON_CONTEXT_Reason_Detailed + SimpleReasonString*: LPWSTR + REASON_CONTEXT* {.pure.} = object + Version*: ULONG + Flags*: DWORD + Reason*: REASON_CONTEXT_Reason + PREASON_CONTEXT* = ptr REASON_CONTEXT + PTHREAD_START_ROUTINE* = proc (lpThreadParameter: LPVOID): DWORD {.stdcall.} + LPTHREAD_START_ROUTINE* = PTHREAD_START_ROUTINE + EXCEPTION_DEBUG_INFO* {.pure.} = object + ExceptionRecord*: EXCEPTION_RECORD + dwFirstChance*: DWORD + LPEXCEPTION_DEBUG_INFO* = ptr EXCEPTION_DEBUG_INFO + CREATE_THREAD_DEBUG_INFO* {.pure.} = object + hThread*: HANDLE + lpThreadLocalBase*: LPVOID + lpStartAddress*: LPTHREAD_START_ROUTINE + LPCREATE_THREAD_DEBUG_INFO* = ptr CREATE_THREAD_DEBUG_INFO + CREATE_PROCESS_DEBUG_INFO* {.pure.} = object + hFile*: HANDLE + hProcess*: HANDLE + hThread*: HANDLE + lpBaseOfImage*: LPVOID + dwDebugInfoFileOffset*: DWORD + nDebugInfoSize*: DWORD + lpThreadLocalBase*: LPVOID + lpStartAddress*: LPTHREAD_START_ROUTINE + lpImageName*: LPVOID + fUnicode*: WORD + LPCREATE_PROCESS_DEBUG_INFO* = ptr CREATE_PROCESS_DEBUG_INFO + EXIT_THREAD_DEBUG_INFO* {.pure.} = object + dwExitCode*: DWORD + LPEXIT_THREAD_DEBUG_INFO* = ptr EXIT_THREAD_DEBUG_INFO + EXIT_PROCESS_DEBUG_INFO* {.pure.} = object + dwExitCode*: DWORD + LPEXIT_PROCESS_DEBUG_INFO* = ptr EXIT_PROCESS_DEBUG_INFO + LOAD_DLL_DEBUG_INFO* {.pure.} = object + hFile*: HANDLE + lpBaseOfDll*: LPVOID + dwDebugInfoFileOffset*: DWORD + nDebugInfoSize*: DWORD + lpImageName*: LPVOID + fUnicode*: WORD + LPLOAD_DLL_DEBUG_INFO* = ptr LOAD_DLL_DEBUG_INFO + UNLOAD_DLL_DEBUG_INFO* {.pure.} = object + lpBaseOfDll*: LPVOID + LPUNLOAD_DLL_DEBUG_INFO* = ptr UNLOAD_DLL_DEBUG_INFO + OUTPUT_DEBUG_STRING_INFO* {.pure.} = object + lpDebugStringData*: LPSTR + fUnicode*: WORD + nDebugStringLength*: WORD + LPOUTPUT_DEBUG_STRING_INFO* = ptr OUTPUT_DEBUG_STRING_INFO + RIP_INFO* {.pure.} = object + dwError*: DWORD + dwType*: DWORD + LPRIP_INFO* = ptr RIP_INFO + DEBUG_EVENT_u* {.pure, union.} = object + Exception*: EXCEPTION_DEBUG_INFO + CreateThread*: CREATE_THREAD_DEBUG_INFO + CreateProcessInfo*: CREATE_PROCESS_DEBUG_INFO + ExitThread*: EXIT_THREAD_DEBUG_INFO + ExitProcess*: EXIT_PROCESS_DEBUG_INFO + LoadDll*: LOAD_DLL_DEBUG_INFO + UnloadDll*: UNLOAD_DLL_DEBUG_INFO + DebugString*: OUTPUT_DEBUG_STRING_INFO + RipInfo*: RIP_INFO + DEBUG_EVENT* {.pure.} = object + dwDebugEventCode*: DWORD + dwProcessId*: DWORD + dwThreadId*: DWORD + u*: DEBUG_EVENT_u + LPDEBUG_EVENT* = ptr DEBUG_EVENT + LPCONTEXT* = PCONTEXT + PTOP_LEVEL_EXCEPTION_FILTER* = proc (ExceptionInfo: ptr EXCEPTION_POINTERS): LONG {.stdcall.} + LPTOP_LEVEL_EXCEPTION_FILTER* = PTOP_LEVEL_EXCEPTION_FILTER + BY_HANDLE_FILE_INFORMATION* {.pure.} = object + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + dwVolumeSerialNumber*: DWORD + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + nNumberOfLinks*: DWORD + nFileIndexHigh*: DWORD + nFileIndexLow*: DWORD + PBY_HANDLE_FILE_INFORMATION* = ptr BY_HANDLE_FILE_INFORMATION + LPBY_HANDLE_FILE_INFORMATION* = ptr BY_HANDLE_FILE_INFORMATION + WIN32_FILE_ATTRIBUTE_DATA* {.pure.} = object + dwFileAttributes*: DWORD + ftCreationTime*: FILETIME + ftLastAccessTime*: FILETIME + ftLastWriteTime*: FILETIME + nFileSizeHigh*: DWORD + nFileSizeLow*: DWORD + LPWIN32_FILE_ATTRIBUTE_DATA* = ptr WIN32_FILE_ATTRIBUTE_DATA + CREATEFILE2_EXTENDED_PARAMETERS* {.pure.} = object + dwSize*: DWORD + dwFileAttributes*: DWORD + dwFileFlags*: DWORD + dwSecurityQosFlags*: DWORD + lpSecurityAttributes*: LPSECURITY_ATTRIBUTES + hTemplateFile*: HANDLE + PCREATEFILE2_EXTENDED_PARAMETERS* = ptr CREATEFILE2_EXTENDED_PARAMETERS + LPCREATEFILE2_EXTENDED_PARAMETERS* = ptr CREATEFILE2_EXTENDED_PARAMETERS + THEAP_SUMMARY* {.pure.} = object + cb*: DWORD + cbAllocated*: SIZE_T + cbCommitted*: SIZE_T + cbReserved*: SIZE_T + cbMaxReserve*: SIZE_T + PHEAP_SUMMARY* = ptr THEAP_SUMMARY + LPHEAP_SUMMARY* = PHEAP_SUMMARY + ENUMUILANG* {.pure.} = object + NumOfEnumUILang*: ULONG + SizeOfEnumUIBuffer*: ULONG + pEnumUIBuffer*: ptr LANGID + PENUMUILANG* = ptr ENUMUILANG + WIN32_MEMORY_RANGE_ENTRY* {.pure.} = object + VirtualAddress*: PVOID + NumberOfBytes*: SIZE_T + PWIN32_MEMORY_RANGE_ENTRY* = ptr WIN32_MEMORY_RANGE_ENTRY + PROCESS_INFORMATION* {.pure.} = object + hProcess*: HANDLE + hThread*: HANDLE + dwProcessId*: DWORD + dwThreadId*: DWORD + PPROCESS_INFORMATION* = ptr PROCESS_INFORMATION + LPPROCESS_INFORMATION* = ptr PROCESS_INFORMATION + STARTUPINFOA* {.pure.} = object + cb*: DWORD + lpReserved*: LPSTR + lpDesktop*: LPSTR + lpTitle*: LPSTR + dwX*: DWORD + dwY*: DWORD + dwXSize*: DWORD + dwYSize*: DWORD + dwXCountChars*: DWORD + dwYCountChars*: DWORD + dwFillAttribute*: DWORD + dwFlags*: DWORD + wShowWindow*: WORD + cbReserved2*: WORD + lpReserved2*: LPBYTE + hStdInput*: HANDLE + hStdOutput*: HANDLE + hStdError*: HANDLE + LPSTARTUPINFOA* = ptr STARTUPINFOA + STARTUPINFOW* {.pure.} = object + cb*: DWORD + lpReserved*: LPWSTR + lpDesktop*: LPWSTR + lpTitle*: LPWSTR + dwX*: DWORD + dwY*: DWORD + dwXSize*: DWORD + dwYSize*: DWORD + dwXCountChars*: DWORD + dwYCountChars*: DWORD + dwFillAttribute*: DWORD + dwFlags*: DWORD + wShowWindow*: WORD + cbReserved2*: WORD + lpReserved2*: LPBYTE + hStdInput*: HANDLE + hStdOutput*: HANDLE + hStdError*: HANDLE + LPSTARTUPINFOW* = ptr STARTUPINFOW + PROC_THREAD_ATTRIBUTE_LIST* {.pure.} = object + PPROC_THREAD_ATTRIBUTE_LIST* = ptr PROC_THREAD_ATTRIBUTE_LIST + LPPROC_THREAD_ATTRIBUTE_LIST* = ptr PROC_THREAD_ATTRIBUTE_LIST + SRWLOCK* = RTL_SRWLOCK + PSRWLOCK* = ptr RTL_SRWLOCK + INIT_ONCE* = RTL_RUN_ONCE + PINIT_ONCE* = PRTL_RUN_ONCE + LPINIT_ONCE* = PRTL_RUN_ONCE + CONDITION_VARIABLE* = RTL_CONDITION_VARIABLE + PCONDITION_VARIABLE* = ptr RTL_CONDITION_VARIABLE + SYNCHRONIZATION_BARRIER* = RTL_BARRIER + PSYNCHRONIZATION_BARRIER* = PRTL_BARRIER + LPSYNCHRONIZATION_BARRIER* = PRTL_BARRIER + SYSTEM_INFO_UNION1_STRUCT1* {.pure.} = object + wProcessorArchitecture*: WORD + wReserved*: WORD + SYSTEM_INFO_UNION1* {.pure, union.} = object + dwOemId*: DWORD + struct1*: SYSTEM_INFO_UNION1_STRUCT1 + SYSTEM_INFO* {.pure.} = object + union1*: SYSTEM_INFO_UNION1 + dwPageSize*: DWORD + lpMinimumApplicationAddress*: LPVOID + lpMaximumApplicationAddress*: LPVOID + dwActiveProcessorMask*: DWORD_PTR + dwNumberOfProcessors*: DWORD + dwProcessorType*: DWORD + dwAllocationGranularity*: DWORD + wProcessorLevel*: WORD + wProcessorRevision*: WORD + LPSYSTEM_INFO* = ptr SYSTEM_INFO + MEMORYSTATUSEX* {.pure.} = object + dwLength*: DWORD + dwMemoryLoad*: DWORD + ullTotalPhys*: DWORDLONG + ullAvailPhys*: DWORDLONG + ullTotalPageFile*: DWORDLONG + ullAvailPageFile*: DWORDLONG + ullTotalVirtual*: DWORDLONG + ullAvailVirtual*: DWORDLONG + ullAvailExtendedVirtual*: DWORDLONG + LPMEMORYSTATUSEX* = ptr MEMORYSTATUSEX + PFIBER_START_ROUTINE* = proc (lpFiberParameter: LPVOID): VOID {.stdcall.} + LPFIBER_START_ROUTINE* = PFIBER_START_ROUTINE + COMMPROP* {.pure.} = object + wPacketLength*: WORD + wPacketVersion*: WORD + dwServiceMask*: DWORD + dwReserved1*: DWORD + dwMaxTxQueue*: DWORD + dwMaxRxQueue*: DWORD + dwMaxBaud*: DWORD + dwProvSubType*: DWORD + dwProvCapabilities*: DWORD + dwSettableParams*: DWORD + dwSettableBaud*: DWORD + wSettableData*: WORD + wSettableStopParity*: WORD + dwCurrentTxQueue*: DWORD + dwCurrentRxQueue*: DWORD + dwProvSpec1*: DWORD + dwProvSpec2*: DWORD + wcProvChar*: array[1, WCHAR] + LPCOMMPROP* = ptr COMMPROP + COMSTAT* {.pure.} = object + fCtsHold* {.bitsize:1.}: DWORD + fDsrHold* {.bitsize:1.}: DWORD + fRlsdHold* {.bitsize:1.}: DWORD + fXoffHold* {.bitsize:1.}: DWORD + fXoffSent* {.bitsize:1.}: DWORD + fEof* {.bitsize:1.}: DWORD + fTxim* {.bitsize:1.}: DWORD + fReserved* {.bitsize:25.}: DWORD + cbInQue*: DWORD + cbOutQue*: DWORD + LPCOMSTAT* = ptr COMSTAT + DCB* {.pure.} = object + DCBlength*: DWORD + BaudRate*: DWORD + fBinary* {.bitsize:1.}: DWORD + fParity* {.bitsize:1.}: DWORD + fOutxCtsFlow* {.bitsize:1.}: DWORD + fOutxDsrFlow* {.bitsize:1.}: DWORD + fDtrControl* {.bitsize:2.}: DWORD + fDsrSensitivity* {.bitsize:1.}: DWORD + fTXContinueOnXoff* {.bitsize:1.}: DWORD + fOutX* {.bitsize:1.}: DWORD + fInX* {.bitsize:1.}: DWORD + fErrorChar* {.bitsize:1.}: DWORD + fNull* {.bitsize:1.}: DWORD + fRtsControl* {.bitsize:2.}: DWORD + fAbortOnError* {.bitsize:1.}: DWORD + fDummy2* {.bitsize:17.}: DWORD + wReserved*: WORD + XonLim*: WORD + XoffLim*: WORD + ByteSize*: BYTE + Parity*: BYTE + StopBits*: BYTE + XonChar*: char + XoffChar*: char + ErrorChar*: char + EofChar*: char + EvtChar*: char + wReserved1*: WORD + LPDCB* = ptr DCB + COMMTIMEOUTS* {.pure.} = object + ReadIntervalTimeout*: DWORD + ReadTotalTimeoutMultiplier*: DWORD + ReadTotalTimeoutConstant*: DWORD + WriteTotalTimeoutMultiplier*: DWORD + WriteTotalTimeoutConstant*: DWORD + LPCOMMTIMEOUTS* = ptr COMMTIMEOUTS + COMMCONFIG* {.pure.} = object + dwSize*: DWORD + wVersion*: WORD + wReserved*: WORD + dcb*: DCB + dwProviderSubType*: DWORD + dwProviderOffset*: DWORD + dwProviderSize*: DWORD + wcProviderData*: array[1, WCHAR] + LPCOMMCONFIG* = ptr COMMCONFIG + MEMORYSTATUS* {.pure.} = object + dwLength*: DWORD + dwMemoryLoad*: DWORD + dwTotalPhys*: SIZE_T + dwAvailPhys*: SIZE_T + dwTotalPageFile*: SIZE_T + dwAvailPageFile*: SIZE_T + dwTotalVirtual*: SIZE_T + dwAvailVirtual*: SIZE_T + LPMEMORYSTATUS* = ptr MEMORYSTATUS + JIT_DEBUG_INFO* {.pure.} = object + dwSize*: DWORD + dwProcessorArchitecture*: DWORD + dwThreadID*: DWORD + dwReserved0*: DWORD + lpExceptionAddress*: ULONG64 + lpExceptionRecord*: ULONG64 + lpContextRecord*: ULONG64 + LPJIT_DEBUG_INFO* = ptr JIT_DEBUG_INFO + JIT_DEBUG_INFO32* = JIT_DEBUG_INFO + LPJIT_DEBUG_INFO32* = ptr JIT_DEBUG_INFO + JIT_DEBUG_INFO64* = JIT_DEBUG_INFO + LPJIT_DEBUG_INFO64* = ptr JIT_DEBUG_INFO + LPEXCEPTION_RECORD* = PEXCEPTION_RECORD + LPEXCEPTION_POINTERS* = PEXCEPTION_POINTERS +const + OFS_MAXPATHNAME* = 128 +type + OFSTRUCT* {.pure.} = object + cBytes*: BYTE + fFixedDisk*: BYTE + nErrCode*: WORD + Reserved1*: WORD + Reserved2*: WORD + szPathName*: array[OFS_MAXPATHNAME, CHAR] + LPOFSTRUCT* = ptr OFSTRUCT + POFSTRUCT* = ptr OFSTRUCT + MEMORY_PRIORITY_INFORMATION* {.pure.} = object + MemoryPriority*: ULONG + PMEMORY_PRIORITY_INFORMATION* = ptr MEMORY_PRIORITY_INFORMATION + POWER_REQUEST_CONTEXT* = REASON_CONTEXT + PPOWER_REQUEST_CONTEXT* = ptr REASON_CONTEXT + LPPOWER_REQUEST_CONTEXT* = ptr REASON_CONTEXT + WIN32_STREAM_ID* {.pure.} = object + dwStreamId*: DWORD + dwStreamAttributes*: DWORD + Size*: LARGE_INTEGER + dwStreamNameSize*: DWORD + cStreamName*: array[ANYSIZE_ARRAY, WCHAR] + LPWIN32_STREAM_ID* = ptr WIN32_STREAM_ID + STARTUPINFOEXA* {.pure.} = object + StartupInfo*: STARTUPINFOA + lpAttributeList*: LPPROC_THREAD_ATTRIBUTE_LIST + LPSTARTUPINFOEXA* = ptr STARTUPINFOEXA + STARTUPINFOEXW* {.pure.} = object + StartupInfo*: STARTUPINFOW + lpAttributeList*: LPPROC_THREAD_ATTRIBUTE_LIST + LPSTARTUPINFOEXW* = ptr STARTUPINFOEXW + WIN32_FIND_STREAM_DATA* {.pure.} = object + StreamSize*: LARGE_INTEGER + cStreamName*: array[MAX_PATH + 36, WCHAR] + PWIN32_FIND_STREAM_DATA* = ptr WIN32_FIND_STREAM_DATA + EVENTLOG_FULL_INFORMATION* {.pure.} = object + dwFull*: DWORD + LPEVENTLOG_FULL_INFORMATION* = ptr EVENTLOG_FULL_INFORMATION + OPERATION_START_PARAMETERS* {.pure.} = object + Version*: ULONG + OperationId*: OPERATION_ID + Flags*: ULONG + POPERATION_START_PARAMETERS* = ptr OPERATION_START_PARAMETERS + OPERATION_END_PARAMETERS* {.pure.} = object + Version*: ULONG + OperationId*: OPERATION_ID + Flags*: ULONG + POPERATION_END_PARAMETERS* = ptr OPERATION_END_PARAMETERS +const + HW_PROFILE_GUIDLEN* = 39 + MAX_PROFILE_LEN* = 80 +type + HW_PROFILE_INFOA* {.pure.} = object + dwDockInfo*: DWORD + szHwProfileGuid*: array[HW_PROFILE_GUIDLEN, CHAR] + szHwProfileName*: array[MAX_PROFILE_LEN, CHAR] + LPHW_PROFILE_INFOA* = ptr HW_PROFILE_INFOA + HW_PROFILE_INFOW* {.pure.} = object + dwDockInfo*: DWORD + szHwProfileGuid*: array[HW_PROFILE_GUIDLEN, WCHAR] + szHwProfileName*: array[MAX_PROFILE_LEN, WCHAR] + LPHW_PROFILE_INFOW* = ptr HW_PROFILE_INFOW + TIME_ZONE_INFORMATION* {.pure.} = object + Bias*: LONG + StandardName*: array[32, WCHAR] + StandardDate*: SYSTEMTIME + StandardBias*: LONG + DaylightName*: array[32, WCHAR] + DaylightDate*: SYSTEMTIME + DaylightBias*: LONG + PTIME_ZONE_INFORMATION* = ptr TIME_ZONE_INFORMATION + LPTIME_ZONE_INFORMATION* = ptr TIME_ZONE_INFORMATION + DYNAMIC_TIME_ZONE_INFORMATION* {.pure.} = object + Bias*: LONG + StandardName*: array[32, WCHAR] + StandardDate*: SYSTEMTIME + StandardBias*: LONG + DaylightName*: array[32, WCHAR] + DaylightDate*: SYSTEMTIME + DaylightBias*: LONG + TimeZoneKeyName*: array[128, WCHAR] + DynamicDaylightTimeDisabled*: BOOLEAN + PDYNAMIC_TIME_ZONE_INFORMATION* = ptr DYNAMIC_TIME_ZONE_INFORMATION + SYSTEM_POWER_STATUS* {.pure.} = object + ACLineStatus*: BYTE + BatteryFlag*: BYTE + BatteryLifePercent*: BYTE + Reserved1*: BYTE + BatteryLifeTime*: DWORD + BatteryFullLifeTime*: DWORD + LPSYSTEM_POWER_STATUS* = ptr SYSTEM_POWER_STATUS + PBAD_MEMORY_CALLBACK_ROUTINE* = ptr BAD_MEMORY_CALLBACK_ROUTINE + ACTCTXA* {.pure.} = object + cbSize*: ULONG + dwFlags*: DWORD + lpSource*: LPCSTR + wProcessorArchitecture*: USHORT + wLangId*: LANGID + lpAssemblyDirectory*: LPCSTR + lpResourceName*: LPCSTR + lpApplicationName*: LPCSTR + hModule*: HMODULE + PACTCTXA* = ptr ACTCTXA + ACTCTXW* {.pure.} = object + cbSize*: ULONG + dwFlags*: DWORD + lpSource*: LPCWSTR + wProcessorArchitecture*: USHORT + wLangId*: LANGID + lpAssemblyDirectory*: LPCWSTR + lpResourceName*: LPCWSTR + lpApplicationName*: LPCWSTR + hModule*: HMODULE + PACTCTXW* = ptr ACTCTXW + PCACTCTXA* = ptr ACTCTXA + PCACTCTXW* = ptr ACTCTXW + ACTCTX_SECTION_KEYED_DATA_2600* {.pure.} = object + cbSize*: ULONG + ulDataFormatVersion*: ULONG + lpData*: PVOID + ulLength*: ULONG + lpSectionGlobalData*: PVOID + ulSectionGlobalDataLength*: ULONG + lpSectionBase*: PVOID + ulSectionTotalLength*: ULONG + hActCtx*: HANDLE + ulAssemblyRosterIndex*: ULONG + PACTCTX_SECTION_KEYED_DATA_2600* = ptr ACTCTX_SECTION_KEYED_DATA_2600 + PCACTCTX_SECTION_KEYED_DATA_2600* = ptr ACTCTX_SECTION_KEYED_DATA_2600 + ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA* {.pure.} = object + lpInformation*: PVOID + lpSectionBase*: PVOID + ulSectionLength*: ULONG + lpSectionGlobalDataBase*: PVOID + ulSectionGlobalDataLength*: ULONG + PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA* = ptr ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA + PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA* = ptr ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA + ACTCTX_SECTION_KEYED_DATA* {.pure.} = object + cbSize*: ULONG + ulDataFormatVersion*: ULONG + lpData*: PVOID + ulLength*: ULONG + lpSectionGlobalData*: PVOID + ulSectionGlobalDataLength*: ULONG + lpSectionBase*: PVOID + ulSectionTotalLength*: ULONG + hActCtx*: HANDLE + ulAssemblyRosterIndex*: ULONG + ulFlags*: ULONG + AssemblyMetadata*: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA + PACTCTX_SECTION_KEYED_DATA* = ptr ACTCTX_SECTION_KEYED_DATA + PCACTCTX_SECTION_KEYED_DATA* = ptr ACTCTX_SECTION_KEYED_DATA + ACTIVATION_CONTEXT_BASIC_INFORMATION* {.pure.} = object + hActCtx*: HANDLE + dwFlags*: DWORD + PACTIVATION_CONTEXT_BASIC_INFORMATION* = ptr ACTIVATION_CONTEXT_BASIC_INFORMATION + PCACTIVATION_CONTEXT_BASIC_INFORMATION* = ptr ACTIVATION_CONTEXT_BASIC_INFORMATION + FILE_BASIC_INFO* {.pure.} = object + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + FileAttributes*: DWORD + PFILE_BASIC_INFO* = ptr FILE_BASIC_INFO + FILE_STANDARD_INFO* {.pure.} = object + AllocationSize*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + NumberOfLinks*: DWORD + DeletePending*: BOOLEAN + Directory*: BOOLEAN + PFILE_STANDARD_INFO* = ptr FILE_STANDARD_INFO + FILE_NAME_INFO* {.pure.} = object + FileNameLength*: DWORD + FileName*: array[1, WCHAR] + PFILE_NAME_INFO* = ptr FILE_NAME_INFO + FILE_RENAME_INFO* {.pure.} = object + ReplaceIfExists*: BOOLEAN + RootDirectory*: HANDLE + FileNameLength*: DWORD + FileName*: array[1, WCHAR] + PFILE_RENAME_INFO* = ptr FILE_RENAME_INFO + FILE_ALLOCATION_INFO* {.pure.} = object + AllocationSize*: LARGE_INTEGER + PFILE_ALLOCATION_INFO* = ptr FILE_ALLOCATION_INFO + FILE_END_OF_FILE_INFO* {.pure.} = object + EndOfFile*: LARGE_INTEGER + PFILE_END_OF_FILE_INFO* = ptr FILE_END_OF_FILE_INFO + FILE_STREAM_INFO* {.pure.} = object + NextEntryOffset*: DWORD + StreamNameLength*: DWORD + StreamSize*: LARGE_INTEGER + StreamAllocationSize*: LARGE_INTEGER + StreamName*: array[1, WCHAR] + PFILE_STREAM_INFO* = ptr FILE_STREAM_INFO + FILE_COMPRESSION_INFO* {.pure.} = object + CompressedFileSize*: LARGE_INTEGER + CompressionFormat*: WORD + CompressionUnitShift*: UCHAR + ChunkShift*: UCHAR + ClusterShift*: UCHAR + Reserved*: array[3, UCHAR] + PFILE_COMPRESSION_INFO* = ptr FILE_COMPRESSION_INFO + FILE_ATTRIBUTE_TAG_INFO* {.pure.} = object + FileAttributes*: DWORD + ReparseTag*: DWORD + PFILE_ATTRIBUTE_TAG_INFO* = ptr FILE_ATTRIBUTE_TAG_INFO + FILE_DISPOSITION_INFO* {.pure.} = object + DeleteFile*: BOOLEAN + PFILE_DISPOSITION_INFO* = ptr FILE_DISPOSITION_INFO + FILE_ID_BOTH_DIR_INFO* {.pure.} = object + NextEntryOffset*: DWORD + FileIndex*: DWORD + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: DWORD + FileNameLength*: DWORD + EaSize*: DWORD + ShortNameLength*: CCHAR + ShortName*: array[12, WCHAR] + FileId*: LARGE_INTEGER + FileName*: array[1, WCHAR] + PFILE_ID_BOTH_DIR_INFO* = ptr FILE_ID_BOTH_DIR_INFO + FILE_FULL_DIR_INFO* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + FileName*: array[1, WCHAR] + PFILE_FULL_DIR_INFO* = ptr FILE_FULL_DIR_INFO + FILE_IO_PRIORITY_HINT_INFO* {.pure.} = object + PriorityHint*: PRIORITY_HINT + PFILE_IO_PRIORITY_HINT_INFO* = ptr FILE_IO_PRIORITY_HINT_INFO + FILE_ALIGNMENT_INFO* {.pure.} = object + AlignmentRequirement*: ULONG + PFILE_ALIGNMENT_INFO* = ptr FILE_ALIGNMENT_INFO + FILE_STORAGE_INFO* {.pure.} = object + LogicalBytesPerSector*: ULONG + PhysicalBytesPerSectorForAtomicity*: ULONG + PhysicalBytesPerSectorForPerformance*: ULONG + FileSystemEffectivePhysicalBytesPerSectorForAtomicity*: ULONG + Flags*: ULONG + ByteOffsetForSectorAlignment*: ULONG + ByteOffsetForPartitionAlignment*: ULONG + PFILE_STORAGE_INFO* = ptr FILE_STORAGE_INFO + FILE_ID_INFO* {.pure.} = object + VolumeSerialNumber*: ULONGLONG + FileId*: FILE_ID_128 + PFILE_ID_INFO* = ptr FILE_ID_INFO + FILE_ID_EXTD_DIR_INFO* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + ReparsePointTag*: ULONG + FileId*: FILE_ID_128 + FileName*: array[1, WCHAR] + PFILE_ID_EXTD_DIR_INFO* = ptr FILE_ID_EXTD_DIR_INFO + FILE_REMOTE_PROTOCOL_INFO_GenericReserved* {.pure.} = object + Reserved*: array[8, ULONG] + FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2_Server* {.pure.} = object + Capabilities*: ULONG + FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2_Share* {.pure.} = object + Capabilities*: ULONG + CachingFlags*: ULONG + FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2* {.pure.} = object + Server*: FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2_Server + Share*: FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2_Share + FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific* {.pure, union.} = object + Smb2*: FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific_Smb2 + Reserved*: array[16, ULONG] + FILE_REMOTE_PROTOCOL_INFO* {.pure.} = object + StructureVersion*: USHORT + StructureSize*: USHORT + Protocol*: ULONG + ProtocolMajorVersion*: USHORT + ProtocolMinorVersion*: USHORT + ProtocolRevision*: USHORT + Reserved*: USHORT + Flags*: ULONG + GenericReserved*: FILE_REMOTE_PROTOCOL_INFO_GenericReserved + ProtocolSpecific*: FILE_REMOTE_PROTOCOL_INFO_ProtocolSpecific + PFILE_REMOTE_PROTOCOL_INFO* = ptr FILE_REMOTE_PROTOCOL_INFO + FILE_ID_DESCRIPTOR_UNION1* {.pure, union.} = object + FileId*: LARGE_INTEGER + ObjectId*: GUID + ExtendedFileId*: FILE_ID_128 + FILE_ID_DESCRIPTOR* {.pure.} = object + dwSize*: DWORD + Type*: FILE_ID_TYPE + union1*: FILE_ID_DESCRIPTOR_UNION1 + LPFILE_ID_DESCRIPTOR* = ptr FILE_ID_DESCRIPTOR +const + findExInfoStandard* = 0 + findExInfoBasic* = 1 + findExInfoMaxInfoLevel* = 2 + FIND_FIRST_EX_CASE_SENSITIVE* = 0x00000001 + FIND_FIRST_EX_LARGE_FETCH* = 0x00000002 + findExSearchNameMatch* = 0 + findExSearchLimitToDirectories* = 1 + findExSearchLimitToDevices* = 2 + findExSearchMaxSearchOp* = 3 + getFileExInfoStandard* = 0 + getFileExMaxInfoLevel* = 1 + fileBasicInfo* = 0 + fileStandardInfo* = 1 + fileNameInfo* = 2 + fileRenameInfo* = 3 + fileDispositionInfo* = 4 + fileAllocationInfo* = 5 + fileEndOfFileInfo* = 6 + fileStreamInfo* = 7 + fileCompressionInfo* = 8 + fileAttributeTagInfo* = 9 + fileIdBothDirectoryInfo* = 10 + fileIdBothDirectoryRestartInfo* = 11 + fileIoPriorityHintInfo* = 12 + fileRemoteProtocolInfo* = 13 + fileFullDirectoryInfo* = 14 + fileFullDirectoryRestartInfo* = 15 + fileStorageInfo* = 16 + fileAlignmentInfo* = 17 + fileIdInfo* = 18 + fileIdExtdDirectoryInfo* = 19 + fileIdExtdDirectoryRestartInfo* = 20 + maximumFileInfoByHandleClass* = 21 + LOCKFILE_FAIL_IMMEDIATELY* = 0x1 + LOCKFILE_EXCLUSIVE_LOCK* = 0x2 + PROCESS_HEAP_REGION* = 0x1 + PROCESS_HEAP_UNCOMMITTED_RANGE* = 0x2 + PROCESS_HEAP_ENTRY_BUSY* = 0x4 + PROCESS_HEAP_ENTRY_MOVEABLE* = 0x10 + PROCESS_HEAP_ENTRY_DDESHARE* = 0x20 + EXCEPTION_DEBUG_EVENT* = 1 + CREATE_THREAD_DEBUG_EVENT* = 2 + CREATE_PROCESS_DEBUG_EVENT* = 3 + EXIT_THREAD_DEBUG_EVENT* = 4 + EXIT_PROCESS_DEBUG_EVENT* = 5 + LOAD_DLL_DEBUG_EVENT* = 6 + UNLOAD_DLL_DEBUG_EVENT* = 7 + OUTPUT_DEBUG_STRING_EVENT* = 8 + RIP_EVENT* = 9 + STILL_ACTIVE* = STATUS_PENDING + EXCEPTION_ACCESS_VIOLATION* = STATUS_ACCESS_VIOLATION + EXCEPTION_DATATYPE_MISALIGNMENT* = STATUS_DATATYPE_MISALIGNMENT + EXCEPTION_BREAKPOINT* = STATUS_BREAKPOINT + EXCEPTION_SINGLE_STEP* = STATUS_SINGLE_STEP + EXCEPTION_ARRAY_BOUNDS_EXCEEDED* = STATUS_ARRAY_BOUNDS_EXCEEDED + EXCEPTION_FLT_DENORMAL_OPERAND* = STATUS_FLOAT_DENORMAL_OPERAND + EXCEPTION_FLT_DIVIDE_BY_ZERO* = STATUS_FLOAT_DIVIDE_BY_ZERO + EXCEPTION_FLT_INEXACT_RESULT* = STATUS_FLOAT_INEXACT_RESULT + EXCEPTION_FLT_INVALID_OPERATION* = STATUS_FLOAT_INVALID_OPERATION + EXCEPTION_FLT_OVERFLOW* = STATUS_FLOAT_OVERFLOW + EXCEPTION_FLT_STACK_CHECK* = STATUS_FLOAT_STACK_CHECK + EXCEPTION_FLT_UNDERFLOW* = STATUS_FLOAT_UNDERFLOW + EXCEPTION_INT_DIVIDE_BY_ZERO* = STATUS_INTEGER_DIVIDE_BY_ZERO + EXCEPTION_INT_OVERFLOW* = STATUS_INTEGER_OVERFLOW + EXCEPTION_PRIV_INSTRUCTION* = STATUS_PRIVILEGED_INSTRUCTION + EXCEPTION_IN_PAGE_ERROR* = STATUS_IN_PAGE_ERROR + EXCEPTION_ILLEGAL_INSTRUCTION* = STATUS_ILLEGAL_INSTRUCTION + EXCEPTION_NONCONTINUABLE_EXCEPTION* = STATUS_NONCONTINUABLE_EXCEPTION + EXCEPTION_STACK_OVERFLOW* = STATUS_STACK_OVERFLOW + EXCEPTION_INVALID_DISPOSITION* = STATUS_INVALID_DISPOSITION + EXCEPTION_GUARD_PAGE* = STATUS_GUARD_PAGE_VIOLATION + EXCEPTION_INVALID_HANDLE* = STATUS_INVALID_HANDLE + EXCEPTION_POSSIBLE_DEADLOCK* = STATUS_POSSIBLE_DEADLOCK + CONTROL_C_EXIT* = STATUS_CONTROL_C_EXIT + LMEM_FIXED* = 0x0 + LMEM_MOVEABLE* = 0x2 + LMEM_NOCOMPACT* = 0x10 + LMEM_NODISCARD* = 0x20 + LMEM_ZEROINIT* = 0x40 + LMEM_MODIFY* = 0x80 + LMEM_DISCARDABLE* = 0xf00 + LMEM_VALID_FLAGS* = 0xf72 + LMEM_INVALID_HANDLE* = 0x8000 + LHND* = LMEM_MOVEABLE or LMEM_ZEROINIT + LPTR* = LMEM_FIXED or LMEM_ZEROINIT + NONZEROLHND* = LMEM_MOVEABLE + NONZEROLPTR* = LMEM_FIXED + LMEM_DISCARDED* = 0x4000 + LMEM_LOCKCOUNT* = 0xff + RESTORE_LAST_ERROR_NAME_A* = "RestoreLastError" + RESTORE_LAST_ERROR_NAME_W* = "RestoreLastError" + RESTORE_LAST_ERROR_NAME* = "RestoreLastError" + FLS_OUT_OF_INDEXES* = DWORD 0xffffffff'i32 + CREATE_NEW* = 1 + CREATE_ALWAYS* = 2 + OPEN_EXISTING* = 3 + OPEN_ALWAYS* = 4 + TRUNCATE_EXISTING* = 5 + INVALID_FILE_SIZE* = DWORD 0xffffffff'i32 + INVALID_SET_FILE_POINTER* = DWORD(-1) + INVALID_FILE_ATTRIBUTES* = DWORD(-1) + FIND_RESOURCE_DIRECTORY_TYPES* = 0x0100 + FIND_RESOURCE_DIRECTORY_NAMES* = 0x0200 + FIND_RESOURCE_DIRECTORY_LANGUAGES* = 0x0400 + RESOURCE_ENUM_LN* = 0x0001 + RESOURCE_ENUM_MUI* = 0x0002 + RESOURCE_ENUM_MUI_SYSTEM* = 0x0004 + RESOURCE_ENUM_VALIDATE* = 0x0008 + RESOURCE_ENUM_MODULE_EXACT* = 0x0010 + SUPPORT_LANG_NUMBER* = 32 + DONT_RESOLVE_DLL_REFERENCES* = 0x1 + LOAD_LIBRARY_AS_DATAFILE* = 0x2 + LOAD_WITH_ALTERED_SEARCH_PATH* = 0x8 + LOAD_IGNORE_CODE_AUTHZ_LEVEL* = 0x10 + LOAD_LIBRARY_AS_IMAGE_RESOURCE* = 0x20 + LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE* = 0x40 + LOAD_LIBRARY_REQUIRE_SIGNED_TARGET* = 0x80 + LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR* = 0x100 + LOAD_LIBRARY_SEARCH_APPLICATION_DIR* = 0x200 + LOAD_LIBRARY_SEARCH_USER_DIRS* = 0x400 + LOAD_LIBRARY_SEARCH_SYSTEM32* = 0x800 + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS* = 0x1000 + GET_MODULE_HANDLE_EX_FLAG_PIN* = 0x1 + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT* = 0x2 + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS* = 0x4 + lowMemoryResourceNotification* = 0 + highMemoryResourceNotification* = 1 + vmOfferPriorityVeryLow* = 1 + vmOfferPriorityLow* = 2 + vmOfferPriorityBelowNormal* = 3 + vmOfferPriorityNormal* = 4 + FILE_MAP_WRITE* = SECTION_MAP_WRITE + FILE_MAP_READ* = SECTION_MAP_READ + FILE_MAP_ALL_ACCESS* = SECTION_ALL_ACCESS + FILE_MAP_COPY* = 0x1 + FILE_MAP_RESERVE* = 0x80000000'i32 + FILE_MAP_EXECUTE* = SECTION_MAP_EXECUTE_EXPLICIT + FILE_CACHE_MAX_HARD_ENABLE* = 0x00000001 + FILE_CACHE_MAX_HARD_DISABLE* = 0x00000002 + FILE_CACHE_MIN_HARD_ENABLE* = 0x00000004 + FILE_CACHE_MIN_HARD_DISABLE* = 0x00000008 + PRIVATE_NAMESPACE_FLAG_DESTROY* = 0x1 + TLS_OUT_OF_INDEXES* = DWORD 0xffffffff'i32 + PROCESS_AFFINITY_ENABLE_AUTO_UPDATE* = 0x1 + PROC_THREAD_ATTRIBUTE_REPLACE_VALUE* = 0x00000001 + SRWLOCK_INIT* = RTL_SRWLOCK_INIT + INIT_ONCE_STATIC_INIT* = RTL_RUN_ONCE_INIT + INIT_ONCE_CHECK_ONLY* = RTL_RUN_ONCE_CHECK_ONLY + INIT_ONCE_ASYNC* = RTL_RUN_ONCE_ASYNC + INIT_ONCE_INIT_FAILED* = RTL_RUN_ONCE_INIT_FAILED + INIT_ONCE_CTX_RESERVED_BITS* = RTL_RUN_ONCE_CTX_RESERVED_BITS + CONDITION_VARIABLE_INIT* = RTL_CONDITION_VARIABLE_INIT + CONDITION_VARIABLE_LOCKMODE_SHARED* = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED + MUTEX_MODIFY_STATE* = MUTANT_QUERY_STATE + MUTEX_ALL_ACCESS* = MUTANT_ALL_ACCESS + CREATE_MUTEX_INITIAL_OWNER* = 0x1 + CREATE_EVENT_MANUAL_RESET* = 0x1 + CREATE_EVENT_INITIAL_SET* = 0x2 + SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY* = 0x01 + SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY* = 0x02 + SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE* = 0x04 + CREATE_WAITABLE_TIMER_MANUAL_RESET* = 0x1 + computerNameNetBIOS* = 0 + computerNameDnsHostname* = 1 + computerNameDnsDomain* = 2 + computerNameDnsFullyQualified* = 3 + computerNamePhysicalNetBIOS* = 4 + computerNamePhysicalDnsHostname* = 5 + computerNamePhysicalDnsDomain* = 6 + computerNamePhysicalDnsFullyQualified* = 7 + computerNameMax* = 8 + FILE_BEGIN* = 0 + FILE_CURRENT* = 1 + FILE_END* = 2 + WAIT_FAILED* = DWORD 0xffffffff'i32 + WAIT_OBJECT_0* = (STATUS_WAIT_0)+0 + WAIT_ABANDONED* = (STATUS_ABANDONED_WAIT_0)+0 + WAIT_ABANDONED_0* = (STATUS_ABANDONED_WAIT_0)+0 + WAIT_IO_COMPLETION* = STATUS_USER_APC + FILE_FLAG_WRITE_THROUGH* = 0x80000000'i32 + FILE_FLAG_OVERLAPPED* = 0x40000000 + FILE_FLAG_NO_BUFFERING* = 0x20000000 + FILE_FLAG_RANDOM_ACCESS* = 0x10000000 + FILE_FLAG_SEQUENTIAL_SCAN* = 0x8000000 + FILE_FLAG_DELETE_ON_CLOSE* = 0x4000000 + FILE_FLAG_BACKUP_SEMANTICS* = 0x2000000 + FILE_FLAG_POSIX_SEMANTICS* = 0x1000000 + FILE_FLAG_SESSION_AWARE* = 0x800000 + FILE_FLAG_OPEN_REPARSE_POINT* = 0x200000 + FILE_FLAG_OPEN_NO_RECALL* = 0x100000 + FILE_FLAG_FIRST_PIPE_INSTANCE* = 0x80000 + FILE_FLAG_OPEN_REQUIRING_OPLOCK* = 0x40000 + PROGRESS_CONTINUE* = 0 + PROGRESS_CANCEL* = 1 + PROGRESS_STOP* = 2 + PROGRESS_QUIET* = 3 + CALLBACK_CHUNK_FINISHED* = 0x0 + CALLBACK_STREAM_SWITCH* = 0x1 + COPY_FILE_FAIL_IF_EXISTS* = 0x1 + COPY_FILE_RESTARTABLE* = 0x2 + COPY_FILE_OPEN_SOURCE_FOR_WRITE* = 0x4 + COPY_FILE_ALLOW_DECRYPTED_DESTINATION* = 0x8 + COPY_FILE_COPY_SYMLINK* = 0x800 + COPY_FILE_NO_BUFFERING* = 0x1000 + COPY_FILE_REQUEST_SECURITY_PRIVILEGES* = 0x2000 + COPY_FILE_RESUME_FROM_PAUSE* = 0x4000 + COPY_FILE_NO_OFFLOAD* = 0x40000 + REPLACEFILE_WRITE_THROUGH* = 0x1 + REPLACEFILE_IGNORE_MERGE_ERRORS* = 0x2 + REPLACEFILE_IGNORE_ACL_ERRORS* = 0x4 + PIPE_ACCESS_INBOUND* = 0x1 + PIPE_ACCESS_OUTBOUND* = 0x2 + PIPE_ACCESS_DUPLEX* = 0x3 + PIPE_CLIENT_END* = 0x0 + PIPE_SERVER_END* = 0x1 + PIPE_WAIT* = 0x0 + PIPE_NOWAIT* = 0x1 + PIPE_READMODE_BYTE* = 0x0 + PIPE_READMODE_MESSAGE* = 0x2 + PIPE_TYPE_BYTE* = 0x0 + PIPE_TYPE_MESSAGE* = 0x4 + PIPE_ACCEPT_REMOTE_CLIENTS* = 0x0 + PIPE_REJECT_REMOTE_CLIENTS* = 0x8 + PIPE_UNLIMITED_INSTANCES* = 255 + SECURITY_ANONYMOUS* = securityAnonymous shl 16 + SECURITY_IDENTIFICATION* = securityIdentification shl 16 + SECURITY_IMPERSONATION* = securityImpersonation shl 16 + SECURITY_DELEGATION* = securityDelegation shl 16 + SECURITY_CONTEXT_TRACKING* = 0x40000 + SECURITY_EFFECTIVE_ONLY* = 0x80000 + SECURITY_SQOS_PRESENT* = 0x100000 + SECURITY_VALID_SQOS_FLAGS* = 0x1f0000 + FAIL_FAST_GENERATE_EXCEPTION_ADDRESS* = 0x1 + FAIL_FAST_NO_HARD_ERROR_DLG* = 0x2 + SP_SERIALCOMM* = DWORD 0x1 + PST_UNSPECIFIED* = DWORD 0x0 + PST_RS232* = DWORD 0x1 + PST_PARALLELPORT* = DWORD 0x2 + PST_RS422* = DWORD 0x3 + PST_RS423* = DWORD 0x4 + PST_RS449* = DWORD 0x5 + PST_MODEM* = DWORD 0x6 + PST_FAX* = DWORD 0x21 + PST_SCANNER* = DWORD 0x22 + PST_NETWORK_BRIDGE* = DWORD 0x100 + PST_LAT* = DWORD 0x101 + PST_TCPIP_TELNET* = DWORD 0x102 + PST_X25* = DWORD 0x103 + PCF_DTRDSR* = DWORD 0x1 + PCF_RTSCTS* = DWORD 0x2 + PCF_RLSD* = DWORD 0x4 + PCF_PARITY_CHECK* = DWORD 0x8 + PCF_XONXOFF* = DWORD 0x10 + PCF_SETXCHAR* = DWORD 0x20 + PCF_TOTALTIMEOUTS* = DWORD 0x40 + PCF_INTTIMEOUTS* = DWORD 0x80 + PCF_SPECIALCHARS* = DWORD 0x100 + PCF_16BITMODE* = DWORD 0x200 + SP_PARITY* = DWORD 0x1 + SP_BAUD* = DWORD 0x2 + SP_DATABITS* = DWORD 0x4 + SP_STOPBITS* = DWORD 0x8 + SP_HANDSHAKING* = DWORD 0x10 + SP_PARITY_CHECK* = DWORD 0x20 + SP_RLSD* = DWORD 0x40 + BAUD_075* = DWORD 0x1 + BAUD_110* = DWORD 0x2 + BAUD_134_5* = DWORD 0x4 + BAUD_150* = DWORD 0x8 + BAUD_300* = DWORD 0x10 + BAUD_600* = DWORD 0x20 + BAUD_1200* = DWORD 0x40 + BAUD_1800* = DWORD 0x80 + BAUD_2400* = DWORD 0x100 + BAUD_4800* = DWORD 0x200 + BAUD_7200* = DWORD 0x400 + BAUD_9600* = DWORD 0x800 + BAUD_14400* = DWORD 0x1000 + BAUD_19200* = DWORD 0x2000 + BAUD_38400* = DWORD 0x4000 + BAUD_56K* = DWORD 0x8000 + BAUD_128K* = DWORD 0x10000 + BAUD_115200* = DWORD 0x20000 + BAUD_57600* = DWORD 0x40000 + BAUD_USER* = DWORD 0x10000000 + DATABITS_5* = WORD 0x1 + DATABITS_6* = WORD 0x2 + DATABITS_7* = WORD 0x4 + DATABITS_8* = WORD 0x8 + DATABITS_16* = WORD 0x10 + DATABITS_16X* = WORD 0x20 + STOPBITS_10* = WORD 0x1 + STOPBITS_15* = WORD 0x2 + STOPBITS_20* = WORD 0x4 + PARITY_NONE* = WORD 0x100 + PARITY_ODD* = WORD 0x200 + PARITY_EVEN* = WORD 0x400 + PARITY_MARK* = WORD 0x800 + PARITY_SPACE* = WORD 0x1000 + COMMPROP_INITIALIZED* = DWORD 0xe73cf52e'i32 + DTR_CONTROL_DISABLE* = 0x0 + DTR_CONTROL_ENABLE* = 0x1 + DTR_CONTROL_HANDSHAKE* = 0x2 + RTS_CONTROL_DISABLE* = 0x0 + RTS_CONTROL_ENABLE* = 0x1 + RTS_CONTROL_HANDSHAKE* = 0x2 + RTS_CONTROL_TOGGLE* = 0x3 + GMEM_FIXED* = 0x0 + GMEM_MOVEABLE* = 0x2 + GMEM_NOCOMPACT* = 0x10 + GMEM_NODISCARD* = 0x20 + GMEM_ZEROINIT* = 0x40 + GMEM_MODIFY* = 0x80 + GMEM_DISCARDABLE* = 0x100 + GMEM_NOT_BANKED* = 0x1000 + GMEM_SHARE* = 0x2000 + GMEM_DDESHARE* = 0x2000 + GMEM_NOTIFY* = 0x4000 + GMEM_LOWER* = GMEM_NOT_BANKED + GMEM_VALID_FLAGS* = 0x7f72 + GMEM_INVALID_HANDLE* = 0x8000 + GHND* = GMEM_MOVEABLE or GMEM_ZEROINIT + GPTR* = GMEM_FIXED or GMEM_ZEROINIT + GMEM_DISCARDED* = 0x4000 + GMEM_LOCKCOUNT* = 0x00ff + NUMA_NO_PREFERRED_NODE* = DWORD(-1) + DEBUG_PROCESS* = 0x1 + DEBUG_ONLY_THIS_PROCESS* = 0x2 + CREATE_SUSPENDED* = 0x4 + DETACHED_PROCESS* = 0x8 + CREATE_NEW_CONSOLE* = 0x10 + NORMAL_PRIORITY_CLASS* = 0x20 + IDLE_PRIORITY_CLASS* = 0x40 + HIGH_PRIORITY_CLASS* = 0x80 + REALTIME_PRIORITY_CLASS* = 0x100 + CREATE_NEW_PROCESS_GROUP* = 0x200 + CREATE_UNICODE_ENVIRONMENT* = 0x400 + CREATE_SEPARATE_WOW_VDM* = 0x800 + CREATE_SHARED_WOW_VDM* = 0x1000 + CREATE_FORCEDOS* = 0x2000 + BELOW_NORMAL_PRIORITY_CLASS* = 0x4000 + ABOVE_NORMAL_PRIORITY_CLASS* = 0x8000 + INHERIT_PARENT_AFFINITY* = 0x10000 + INHERIT_CALLER_PRIORITY* = 0x20000 + CREATE_PROTECTED_PROCESS* = 0x40000 + EXTENDED_STARTUPINFO_PRESENT* = 0x80000 + PROCESS_MODE_BACKGROUND_BEGIN* = 0x100000 + PROCESS_MODE_BACKGROUND_END* = 0x200000 + CREATE_BREAKAWAY_FROM_JOB* = 0x1000000 + CREATE_PRESERVE_CODE_AUTHZ_LEVEL* = 0x2000000 + CREATE_DEFAULT_ERROR_MODE* = 0x4000000 + CREATE_NO_WINDOW* = 0x8000000 + PROFILE_USER* = 0x10000000 + PROFILE_KERNEL* = 0x20000000 + PROFILE_SERVER* = 0x40000000 + CREATE_IGNORE_SYSTEM_DEFAULT* = 0x80000000'i32 + STACK_SIZE_PARAM_IS_A_RESERVATION* = 0x10000 + THREAD_PRIORITY_LOWEST* = THREAD_BASE_PRIORITY_MIN + THREAD_PRIORITY_BELOW_NORMAL* = THREAD_PRIORITY_LOWEST+1 + THREAD_PRIORITY_NORMAL* = 0 + THREAD_PRIORITY_HIGHEST* = THREAD_BASE_PRIORITY_MAX + THREAD_PRIORITY_ABOVE_NORMAL* = THREAD_PRIORITY_HIGHEST-1 + THREAD_PRIORITY_ERROR_RETURN* = MAXLONG + THREAD_PRIORITY_TIME_CRITICAL* = THREAD_BASE_PRIORITY_LOWRT + THREAD_PRIORITY_IDLE* = THREAD_BASE_PRIORITY_IDLE + THREAD_MODE_BACKGROUND_BEGIN* = 0x00010000 + THREAD_MODE_BACKGROUND_END* = 0x00020000 + VOLUME_NAME_DOS* = 0x0 + VOLUME_NAME_GUID* = 0x1 + VOLUME_NAME_NT* = 0x2 + VOLUME_NAME_NONE* = 0x4 + FILE_NAME_NORMALIZED* = 0x0 + FILE_NAME_OPENED* = 0x8 + DRIVE_UNKNOWN* = 0 + DRIVE_NO_ROOT_DIR* = 1 + DRIVE_REMOVABLE* = 2 + DRIVE_FIXED* = 3 + DRIVE_REMOTE* = 4 + DRIVE_CDROM* = 5 + DRIVE_RAMDISK* = 6 + FILE_TYPE_UNKNOWN* = 0x0 + FILE_TYPE_DISK* = 0x1 + FILE_TYPE_CHAR* = 0x2 + FILE_TYPE_PIPE* = 0x3 + FILE_TYPE_REMOTE* = 0x8000 + STD_INPUT_HANDLE* = DWORD(-10) + STD_OUTPUT_HANDLE* = DWORD(-11) + STD_ERROR_HANDLE* = DWORD(-12) + NOPARITY* = 0 + ODDPARITY* = 1 + EVENPARITY* = 2 + MARKPARITY* = 3 + SPACEPARITY* = 4 + ONESTOPBIT* = 0 + ONE5STOPBITS* = 1 + TWOSTOPBITS* = 2 + IGNORE* = 0 + INFINITE* = 0xffffffff'i32 + CBR_110* = 110 + CBR_300* = 300 + CBR_600* = 600 + CBR_1200* = 1200 + CBR_2400* = 2400 + CBR_4800* = 4800 + CBR_9600* = 9600 + CBR_14400* = 14400 + CBR_19200* = 19200 + CBR_38400* = 38400 + CBR_56000* = 56000 + CBR_57600* = 57600 + CBR_115200* = 115200 + CBR_128000* = 128000 + CBR_256000* = 256000 + CE_RXOVER* = 0x1 + CE_OVERRUN* = 0x2 + CE_RXPARITY* = 0x4 + CE_FRAME* = 0x8 + CE_BREAK* = 0x10 + CE_TXFULL* = 0x100 + CE_PTO* = 0x200 + CE_IOE* = 0x400 + CE_DNS* = 0x800 + CE_OOP* = 0x1000 + CE_MODE* = 0x8000 + IE_BADID* = -1 + IE_OPEN* = -2 + IE_NOPEN* = -3 + IE_MEMORY* = -4 + IE_DEFAULT* = -5 + IE_HARDWARE* = -10 + IE_BYTESIZE* = -11 + IE_BAUDRATE* = -12 + EV_RXCHAR* = 0x1 + EV_RXFLAG* = 0x2 + EV_TXEMPTY* = 0x4 + EV_CTS* = 0x8 + EV_DSR* = 0x10 + EV_RLSD* = 0x20 + EV_BREAK* = 0x40 + EV_ERR* = 0x80 + EV_RING* = 0x100 + EV_PERR* = 0x200 + EV_RX80FULL* = 0x400 + EV_EVENT1* = 0x800 + EV_EVENT2* = 0x1000 + SETXOFF* = 1 + SETXON* = 2 + SETRTS* = 3 + CLRRTS* = 4 + SETDTR* = 5 + CLRDTR* = 6 + RESETDEV* = 7 + SETBREAK* = 8 + CLRBREAK* = 9 + PURGE_TXABORT* = 0x1 + PURGE_RXABORT* = 0x2 + PURGE_TXCLEAR* = 0x4 + PURGE_RXCLEAR* = 0x8 + LPTx* = 0x80 + MS_CTS_ON* = DWORD 0x10 + MS_DSR_ON* = DWORD 0x20 + MS_RING_ON* = DWORD 0x40 + MS_RLSD_ON* = DWORD 0x80 + S_QUEUEEMPTY* = 0 + S_THRESHOLD* = 1 + S_ALLTHRESHOLD* = 2 + S_NORMAL* = 0 + S_LEGATO* = 1 + S_STACCATO* = 2 + S_PERIOD512* = 0 + S_PERIOD1024* = 1 + S_PERIOD2048* = 2 + S_PERIODVOICE* = 3 + S_WHITE512* = 4 + S_WHITE1024* = 5 + S_WHITE2048* = 6 + S_WHITEVOICE* = 7 + S_SERDVNA* = -1 + S_SEROFM* = -2 + S_SERMACT* = -3 + S_SERQFUL* = -4 + S_SERBDNT* = -5 + S_SERDLN* = -6 + S_SERDCC* = -7 + S_SERDTP* = -8 + S_SERDVL* = -9 + S_SERDMD* = -10 + S_SERDSH* = -11 + S_SERDPT* = -12 + S_SERDFQ* = -13 + S_SERDDR* = -14 + S_SERDSR* = -15 + S_SERDST* = -16 + NMPWAIT_WAIT_FOREVER* = 0xffffffff'i32 + NMPWAIT_NOWAIT* = 0x1 + NMPWAIT_USE_DEFAULT_WAIT* = 0x0 + FS_CASE_IS_PRESERVED* = FILE_CASE_PRESERVED_NAMES + FS_CASE_SENSITIVE* = FILE_CASE_SENSITIVE_SEARCH + FS_UNICODE_STORED_ON_DISK* = FILE_UNICODE_ON_DISK + FS_PERSISTENT_ACLS* = FILE_PERSISTENT_ACLS + FS_VOL_IS_COMPRESSED* = FILE_VOLUME_IS_COMPRESSED + FS_FILE_COMPRESSION* = FILE_FILE_COMPRESSION + FS_FILE_ENCRYPTION* = FILE_SUPPORTS_ENCRYPTION + OF_READ* = 0x0 + OF_WRITE* = 0x1 + OF_READWRITE* = 0x2 + OF_SHARE_COMPAT* = 0x0 + OF_SHARE_EXCLUSIVE* = 0x10 + OF_SHARE_DENY_WRITE* = 0x20 + OF_SHARE_DENY_READ* = 0x30 + OF_SHARE_DENY_NONE* = 0x40 + OF_PARSE* = 0x100 + OF_DELETE* = 0x200 + OF_VERIFY* = 0x400 + OF_CANCEL* = 0x800 + OF_CREATE* = 0x1000 + OF_PROMPT* = 0x2000 + OF_EXIST* = 0x4000 + OF_REOPEN* = 0x8000 + MAXINTATOM* = 0xc000 + INVALID_ATOM* = ATOM 0 + SCS_32BIT_BINARY* = 0 + SCS_DOS_BINARY* = 1 + SCS_WOW_BINARY* = 2 + SCS_PIF_BINARY* = 3 + SCS_POSIX_BINARY* = 4 + SCS_OS216_BINARY* = 5 + SCS_64BIT_BINARY* = 6 + FIBER_FLAG_FLOAT_SWITCH* = 0x1 + threadMemoryPriority* = 0 + threadAbsoluteCpuPriority* = 1 + threadInformationClassMax* = 2 + processMemoryPriority* = 0 + processInformationClassMax* = 1 + MEMORY_PRIORITY_LOWEST* = 0 + MEMORY_PRIORITY_VERY_LOW* = 1 + MEMORY_PRIORITY_LOW* = 2 + MEMORY_PRIORITY_MEDIUM* = 3 + MEMORY_PRIORITY_BELOW_NORMAL* = 4 + MEMORY_PRIORITY_NORMAL* = 5 + PROCESS_DEP_ENABLE* = 0x00000001 + PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION* = 0x00000002 + FILE_SKIP_COMPLETION_PORT_ON_SUCCESS* = 0x1 + FILE_SKIP_SET_EVENT_ON_HANDLE* = 0x2 + SEM_FAILCRITICALERRORS* = 0x0001 + SEM_NOGPFAULTERRORBOX* = 0x0002 + SEM_NOALIGNMENTFAULTEXCEPT* = 0x0004 + SEM_NOOPENFILEERRORBOX* = 0x8000 + CRITICAL_SECTION_NO_DEBUG_INFO* = RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO + dEPPolicyAlwaysOff* = 0 + dEPPolicyAlwaysOn* = 1 + dEPPolicyOptIn* = 2 + dEPPolicyOptOut* = 3 + dEPTotalPolicyCount* = 4 + HANDLE_FLAG_INHERIT* = 0x1 + HANDLE_FLAG_PROTECT_FROM_CLOSE* = 0x2 + HINSTANCE_ERROR* = 32 + GET_TAPE_MEDIA_INFORMATION* = 0 + GET_TAPE_DRIVE_INFORMATION* = 1 + SET_TAPE_MEDIA_INFORMATION* = 0 + SET_TAPE_DRIVE_INFORMATION* = 1 + FORMAT_MESSAGE_IGNORE_INSERTS* = 0x00000200 + FORMAT_MESSAGE_FROM_STRING* = 0x00000400 + FORMAT_MESSAGE_FROM_HMODULE* = 0x00000800 + FORMAT_MESSAGE_FROM_SYSTEM* = 0x00001000 + FORMAT_MESSAGE_ARGUMENT_ARRAY* = 0x00002000 + FORMAT_MESSAGE_MAX_WIDTH_MASK* = 0x000000ff + FILE_ENCRYPTABLE* = 0 + FILE_IS_ENCRYPTED* = 1 + FILE_SYSTEM_ATTR* = 2 + FILE_ROOT_DIR* = 3 + FILE_SYSTEM_DIR* = 4 + FILE_UNKNOWN* = 5 + FILE_SYSTEM_NOT_SUPPORT* = 6 + FILE_USER_DISALLOWED* = 7 + FILE_READ_ONLY* = 8 + FILE_DIR_DISALLOWED* = 9 + FORMAT_MESSAGE_ALLOCATE_BUFFER* = 0x00000100 + EFS_USE_RECOVERY_KEYS* = 0x1 + CREATE_FOR_IMPORT* = 1 + CREATE_FOR_DIR* = 2 + OVERWRITE_HIDDEN* = 4 + EFSRPC_SECURE_ONLY* = 8 + BACKUP_INVALID* = 0x00000000 + BACKUP_DATA* = 0x00000001 + BACKUP_EA_DATA* = 0x00000002 + BACKUP_SECURITY_DATA* = 0x00000003 + BACKUP_ALTERNATE_DATA* = 0x00000004 + BACKUP_LINK* = 0x00000005 + BACKUP_PROPERTY_DATA* = 0x00000006 + BACKUP_OBJECT_ID* = 0x00000007 + BACKUP_REPARSE_DATA* = 0x00000008 + BACKUP_SPARSE_BLOCK* = 0x00000009 + BACKUP_TXFS_DATA* = 0x0000000a + STREAM_NORMAL_ATTRIBUTE* = 0x00000000 + STREAM_MODIFIED_WHEN_READ* = 0x00000001 + STREAM_CONTAINS_SECURITY* = 0x00000002 + STREAM_CONTAINS_PROPERTIES* = 0x00000004 + STREAM_SPARSE_ATTRIBUTE* = 0x00000008 + STARTF_USESHOWWINDOW* = 0x00000001 + STARTF_USESIZE* = 0x00000002 + STARTF_USEPOSITION* = 0x00000004 + STARTF_USECOUNTCHARS* = 0x00000008 + STARTF_USEFILLATTRIBUTE* = 0x00000010 + STARTF_RUNFULLSCREEN* = 0x00000020 + STARTF_FORCEONFEEDBACK* = 0x00000040 + STARTF_FORCEOFFFEEDBACK* = 0x00000080 + STARTF_USESTDHANDLES* = 0x00000100 + STARTF_USEHOTKEY* = 0x00000200 + STARTF_TITLEISLINKNAME* = 0x00000800 + STARTF_TITLEISAPPID* = 0x00001000 + STARTF_PREVENTPINNING* = 0x00002000 + SHUTDOWN_NORETRY* = 0x1 + PROCESS_NAME_NATIVE* = 0x00000001 + PROC_THREAD_ATTRIBUTE_NUMBER* = 0x0000ffff + PROC_THREAD_ATTRIBUTE_THREAD* = 0x00010000 + PROC_THREAD_ATTRIBUTE_INPUT* = 0x00020000 + PROC_THREAD_ATTRIBUTE_ADDITIVE* = 0x00040000 + procThreadAttributeParentProcess* = 0 + procThreadAttributeHandleList* = 2 + procThreadAttributeGroupAffinity* = 3 + procThreadAttributePreferredNode* = 4 + procThreadAttributeIdealProcessor* = 5 + procThreadAttributeUmsThread* = 6 + procThreadAttributeMitigationPolicy* = 7 + procThreadAttributeSecurityCapabilities* = 9 +template ProcThreadAttributeValue*(Number, Thread, Input, Additive: untyped): untyped = (((Number) and PROC_THREAD_ATTRIBUTE_NUMBER) or (if (Thread != FALSE): PROC_THREAD_ATTRIBUTE_THREAD else: 0) or (if (Input != FALSE): PROC_THREAD_ATTRIBUTE_INPUT else: 0) or (if (Additive != FALSE): PROC_THREAD_ATTRIBUTE_ADDITIVE else: 0)) +const + PROC_THREAD_ATTRIBUTE_PARENT_PROCESS* = ProcThreadAttributeValue(procThreadAttributeParentProcess, FALSE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_HANDLE_LIST* = ProcThreadAttributeValue(procThreadAttributeHandleList, FALSE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_GROUP_AFFINITY* = ProcThreadAttributeValue(procThreadAttributeGroupAffinity, TRUE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_PREFERRED_NODE* = ProcThreadAttributeValue(procThreadAttributePreferredNode, FALSE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR* = ProcThreadAttributeValue(procThreadAttributeIdealProcessor, TRUE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_UMS_THREAD* = ProcThreadAttributeValue(procThreadAttributeUmsThread, TRUE, TRUE, FALSE) + PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY* = ProcThreadAttributeValue(procThreadAttributeMitigationPolicy, FALSE, TRUE, FALSE) + PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE* = 0x01 + PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE* = 0x02 + PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE* = 0x04 + PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES* = ProcThreadAttributeValue(procThreadAttributeSecurityCapabilities, FALSE, TRUE, FALSE) + PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_MASK* = 0x00000003 shl 8 + PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_DEFER* = 0x00000000 shl 8 + PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_ON* = 0x00000001 shl 8 + PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_OFF* = 0x00000002 shl 8 + PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_ON_REQ_RELOCS* = 0x00000003 shl 8 + PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_MASK* = 0x00000003 shl 12 + PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_DEFER* = 0x00000000 shl 12 + PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON* = 0x00000001 shl 12 + PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF* = 0x00000002 shl 12 + PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_RESERVED* = 0x00000003 shl 12 + PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_MASK* = 0x00000003 shl 16 + PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_DEFER* = 0x00000000 shl 16 + PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_ON* = 0x00000001 shl 16 + PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF* = 0x00000002 shl 16 + PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_RESERVED* = 0x00000003 shl 16 + PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_MASK* = 0x00000003 shl 20 + PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_DEFER* = 0x00000000 shl 20 + PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_ON* = 0x00000001 shl 20 + PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF* = 0x00000002 shl 20 + PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_RESERVED* = 0x00000003 shl 20 + PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_MASK* = 0x00000003 shl 24 + PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_DEFER* = 0x00000000 shl 24 + PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON* = 0x00000001 shl 24 + PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF* = 0x00000002 shl 24 + PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_RESERVED* = 0x00000003 shl 24 + PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_MASK* = 0x00000003 shl 28 + PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_DEFER* = 0x00000000 shl 28 + PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_ON* = 0x00000001 shl 28 + PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_OFF* = 0x00000002 shl 28 + PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_RESERVED* = 0x00000003 shl 28 + PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_MASK* = 0x00000003 shl 32 + PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_DEFER* = 0x00000000 shl 32 + PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_ON* = 0x00000001 shl 32 + PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF* = 0x00000002 shl 32 + PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_RESERVED* = 0x00000003 shl 32 + ATOM_FLAG_GLOBAL* = 0x2 + GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A* = "GetSystemWow64DirectoryA" + GET_SYSTEM_WOW64_DIRECTORY_NAME_A_W* = "GetSystemWow64DirectoryA" + GET_SYSTEM_WOW64_DIRECTORY_NAME_A_T* = "GetSystemWow64DirectoryA" + GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A* = "GetSystemWow64DirectoryW" + GET_SYSTEM_WOW64_DIRECTORY_NAME_W_W* = "GetSystemWow64DirectoryW" + GET_SYSTEM_WOW64_DIRECTORY_NAME_W_T* = "GetSystemWow64DirectoryW" + BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE* = 0x1 + BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE* = 0x10000 + BASE_SEARCH_PATH_PERMANENT* = 0x8000 + BASE_SEARCH_PATH_INVALID_FLAGS* = not 0x18001 + DDD_RAW_TARGET_PATH* = 0x00000001 + DDD_REMOVE_DEFINITION* = 0x00000002 + DDD_EXACT_MATCH_ON_REMOVE* = 0x00000004 + DDD_NO_BROADCAST_SYSTEM* = 0x00000008 + DDD_LUID_BROADCAST_DRIVE* = 0x00000010 + COPYFILE2_CALLBACK_NONE* = 0 + COPYFILE2_CALLBACK_CHUNK_STARTED* = 1 + COPYFILE2_CALLBACK_CHUNK_FINISHED* = 2 + COPYFILE2_CALLBACK_STREAM_STARTED* = 3 + COPYFILE2_CALLBACK_STREAM_FINISHED* = 4 + COPYFILE2_CALLBACK_POLL_CONTINUE* = 5 + COPYFILE2_CALLBACK_ERROR* = 6 + COPYFILE2_CALLBACK_MAX* = 7 + COPYFILE2_PROGRESS_CONTINUE* = 0 + COPYFILE2_PROGRESS_CANCEL* = 1 + COPYFILE2_PROGRESS_STOP* = 2 + COPYFILE2_PROGRESS_QUIET* = 3 + COPYFILE2_PROGRESS_PAUSE* = 4 + COPYFILE2_PHASE_NONE* = 0 + COPYFILE2_PHASE_PREPARE_SOURCE* = 1 + COPYFILE2_PHASE_PREPARE_DEST* = 2 + COPYFILE2_PHASE_READ_SOURCE* = 3 + COPYFILE2_PHASE_WRITE_DESTINATION* = 4 + COPYFILE2_PHASE_SERVER_COPY* = 5 + COPYFILE2_PHASE_NAMEGRAFT_COPY* = 6 + COPYFILE2_PHASE_MAX* = 7 + COPYFILE2_MESSAGE_COPY_OFFLOAD* = 0x00000001 + MOVEFILE_REPLACE_EXISTING* = 0x00000001 + MOVEFILE_COPY_ALLOWED* = 0x00000002 + MOVEFILE_DELAY_UNTIL_REBOOT* = 0x00000004 + MOVEFILE_WRITE_THROUGH* = 0x00000008 + MOVEFILE_CREATE_HARDLINK* = 0x00000010 + MOVEFILE_FAIL_IF_NOT_TRACKABLE* = 0x00000020 + findStreamInfoStandard* = 0 + findStreamInfoMaxInfoLevel* = 1 + EVENTLOG_FULL_INFO* = 0 + OPERATION_API_VERSION* = 1 + OPERATION_START_TRACE_CURRENT_THREAD* = 0x1 + OPERATION_END_DISCARD* = 0x1 + MAX_COMPUTERNAME_LENGTH* = 15 + LOGON32_LOGON_INTERACTIVE* = 2 + LOGON32_LOGON_NETWORK* = 3 + LOGON32_LOGON_BATCH* = 4 + LOGON32_LOGON_SERVICE* = 5 + LOGON32_LOGON_UNLOCK* = 7 + LOGON32_LOGON_NETWORK_CLEARTEXT* = 8 + LOGON32_LOGON_NEW_CREDENTIALS* = 9 + LOGON32_PROVIDER_DEFAULT* = 0 + LOGON32_PROVIDER_WINNT35* = 1 + LOGON32_PROVIDER_WINNT40* = 2 + LOGON32_PROVIDER_WINNT50* = 3 + LOGON32_PROVIDER_VIRTUAL* = 4 + LOGON_WITH_PROFILE* = 0x00000001 + LOGON_NETCREDENTIALS_ONLY* = 0x00000002 + LOGON_ZERO_PASSWORD_BUFFER* = 0x80000000'i32 + DOCKINFO_UNDOCKED* = 0x1 + DOCKINFO_DOCKED* = 0x2 + DOCKINFO_USER_SUPPLIED* = 0x4 + DOCKINFO_USER_UNDOCKED* = DOCKINFO_USER_SUPPLIED or DOCKINFO_UNDOCKED + DOCKINFO_USER_DOCKED* = DOCKINFO_USER_SUPPLIED or DOCKINFO_DOCKED + TIME_ZONE_ID_INVALID* = DWORD 0xffffffff'i32 + AC_LINE_OFFLINE* = 0x00 + AC_LINE_ONLINE* = 0x01 + AC_LINE_BACKUP_POWER* = 0x02 + AC_LINE_UNKNOWN* = 0xff + BATTERY_FLAG_HIGH* = 0x01 + BATTERY_FLAG_LOW* = 0x02 + BATTERY_FLAG_CRITICAL* = 0x04 + BATTERY_FLAG_CHARGING* = 0x08 + BATTERY_FLAG_NO_BATTERY* = 0x80 + BATTERY_FLAG_UNKNOWN* = 0xff + BATTERY_PERCENTAGE_UNKNOWN* = 0xff + BATTERY_LIFE_UNKNOWN* = 0xffffffff'i32 + MEHC_PATROL_SCRUBBER_PRESENT* = 0x1 + ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID* = 0x00000001 + ACTCTX_FLAG_LANGID_VALID* = 0x00000002 + ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID* = 0x00000004 + ACTCTX_FLAG_RESOURCE_NAME_VALID* = 0x00000008 + ACTCTX_FLAG_SET_PROCESS_DEFAULT* = 0x00000010 + ACTCTX_FLAG_APPLICATION_NAME_VALID* = 0x00000020 + ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF* = 0x00000040 + ACTCTX_FLAG_HMODULE_VALID* = 0x00000080 + DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION* = 0x00000001 + FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX* = 0x00000001 + FIND_ACTCTX_SECTION_KEY_RETURN_FLAGS* = 0x00000002 + FIND_ACTCTX_SECTION_KEY_RETURN_ASSEMBLY_METADATA* = 0x00000004 + ACTIVATION_CONTEXT_BASIC_INFORMATION_DEFINED* = 1 + QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX* = 0x00000004 + QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE* = 0x00000008 + QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS* = 0x00000010 + QUERY_ACTCTX_FLAG_NO_ADDREF* = 0x80000000'i32 + RESTART_MAX_CMD_LINE* = 1024 + RESTART_NO_CRASH* = 1 + RESTART_NO_HANG* = 2 + RESTART_NO_PATCH* = 4 + RESTART_NO_REBOOT* = 8 + RECOVERY_DEFAULT_PING_INTERVAL* = 5000 + RECOVERY_MAX_PING_INTERVAL* = 5*60*1000 + ioPriorityHintVeryLow* = 0 + ioPriorityHintLow* = 1 + ioPriorityHintNormal* = 2 + maximumIoPriorityHintType* = 3 + STORAGE_INFO_FLAGS_ALIGNED_DEVICE* = 0x00000001 + STORAGE_INFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE* = 0x00000002 + STORAGE_INFO_OFFSET_UNKNOWN* = 0xffffffff'i32 + REMOTE_PROTOCOL_INFO_FLAG_LOOPBACK* = 0x00000001 + REMOTE_PROTOCOL_INFO_FLAG_OFFLINE* = 0x00000002 + REMOTE_PROTOCOL_INFO_FLAG_PERSISTENT_HANDLE* = 0x00000004 + RPI_FLAG_SMB2_SHARECAP_TIMEWARP* = 0x00000002 + RPI_FLAG_SMB2_SHARECAP_DFS* = 0x00000008 + RPI_FLAG_SMB2_SHARECAP_CONTINUOUS_AVAILABILITY* = 0x00000010 + RPI_FLAG_SMB2_SHARECAP_SCALEOUT* = 0x00000020 + RPI_FLAG_SMB2_SHARECAP_CLUSTER* = 0x00000040 + RPI_SMB2_FLAG_SERVERCAP_DFS* = 0x00000001 + RPI_SMB2_FLAG_SERVERCAP_LEASING* = 0x00000002 + RPI_SMB2_FLAG_SERVERCAP_LARGEMTU* = 0x00000004 + RPI_SMB2_FLAG_SERVERCAP_MULTICHANNEL* = 0x00000008 + RPI_SMB2_FLAG_SERVERCAP_PERSISTENT_HANDLES* = 0x00000010 + RPI_SMB2_FLAG_SERVERCAP_DIRECTORY_LEASING* = 0x00000020 + fileIdType* = 0 + objectIdType* = 1 + extendedFileIdType* = 2 + maximumFileIdType* = 3 + SYMBOLIC_LINK_FLAG_DIRECTORY* = 0x1 + VALID_SYMBOLIC_LINK_FLAGS* = SYMBOLIC_LINK_FLAG_DIRECTORY + INVALID_HANDLE_VALUE* = HANDLE(-1) +type + LPOVERLAPPED_COMPLETION_ROUTINE* = proc (dwErrorCode: DWORD, dwNumberOfBytesTransfered: DWORD, lpOverlapped: LPOVERLAPPED): VOID {.stdcall.} + BEM_FREE_INTERFACE_CALLBACK* = proc (interfaceInstance: pointer): void {.stdcall.} + PRESTORE_LAST_ERROR* = proc (P1: DWORD): VOID {.stdcall.} + ENUMRESLANGPROCA* = proc (hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lParam: LONG_PTR): WINBOOL {.stdcall.} + ENUMRESLANGPROCW* = proc (hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lParam: LONG_PTR): WINBOOL {.stdcall.} + ENUMRESNAMEPROCA* = proc (hModule: HMODULE, lpType: LPCSTR, lpName: LPSTR, lParam: LONG_PTR): WINBOOL {.stdcall.} + ENUMRESNAMEPROCW* = proc (hModule: HMODULE, lpType: LPCWSTR, lpName: LPWSTR, lParam: LONG_PTR): WINBOOL {.stdcall.} + ENUMRESTYPEPROCA* = proc (hModule: HMODULE, lpType: LPSTR, lParam: LONG_PTR): WINBOOL {.stdcall.} + ENUMRESTYPEPROCW* = proc (hModule: HMODULE, lpType: LPWSTR, lParam: LONG_PTR): WINBOOL {.stdcall.} + PGET_MODULE_HANDLE_EXA* = proc (dwFlags: DWORD, lpModuleName: LPCSTR, phModule: ptr HMODULE): WINBOOL {.stdcall.} + PGET_MODULE_HANDLE_EXW* = proc (dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: ptr HMODULE): WINBOOL {.stdcall.} + PINIT_ONCE_FN* = proc (InitOnce: PINIT_ONCE, Parameter: PVOID, Context: ptr PVOID): WINBOOL {.stdcall.} + PTIMERAPCROUTINE* = proc (lpArgToCompletionRoutine: LPVOID, dwTimerLowValue: DWORD, dwTimerHighValue: DWORD): VOID {.stdcall.} + PTP_WIN32_IO_CALLBACK* = proc (Instance: PTP_CALLBACK_INSTANCE, Context: PVOID, Overlapped: PVOID, IoResult: ULONG, NumberOfBytesTransferred: ULONG_PTR, Io: PTP_IO): VOID {.stdcall.} + PFE_EXPORT_FUNC* = proc (pbData: PBYTE, pvCallbackContext: PVOID, ulLength: ULONG): DWORD {.stdcall.} + PFE_IMPORT_FUNC* = proc (pbData: PBYTE, pvCallbackContext: PVOID, ulLength: PULONG): DWORD {.stdcall.} + PGET_SYSTEM_WOW64_DIRECTORY_A* = proc (lpBuffer: LPSTR, uSize: UINT): UINT {.stdcall.} + PGET_SYSTEM_WOW64_DIRECTORY_W* = proc (lpBuffer: LPWSTR, uSize: UINT): UINT {.stdcall.} + LPPROGRESS_ROUTINE* = proc (TotalFileSize: LARGE_INTEGER, TotalBytesTransferred: LARGE_INTEGER, StreamSize: LARGE_INTEGER, StreamBytesTransferred: LARGE_INTEGER, dwStreamNumber: DWORD, dwCallbackReason: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, lpData: LPVOID): DWORD {.stdcall.} + COPYFILE2_MESSAGE_Info_ChunkStarted* {.pure.} = object + dwStreamNumber*: DWORD + dwReserved*: DWORD + hSourceFile*: HANDLE + hDestinationFile*: HANDLE + uliChunkNumber*: ULARGE_INTEGER + uliChunkSize*: ULARGE_INTEGER + uliStreamSize*: ULARGE_INTEGER + uliTotalFileSize*: ULARGE_INTEGER + COPYFILE2_MESSAGE_Info_ChunkFinished* {.pure.} = object + dwStreamNumber*: DWORD + dwFlags*: DWORD + hSourceFile*: HANDLE + hDestinationFile*: HANDLE + uliChunkNumber*: ULARGE_INTEGER + uliChunkSize*: ULARGE_INTEGER + uliStreamSize*: ULARGE_INTEGER + uliStreamBytesTransferred*: ULARGE_INTEGER + uliTotalFileSize*: ULARGE_INTEGER + uliTotalBytesTransferred*: ULARGE_INTEGER + COPYFILE2_MESSAGE_Info_StreamStarted* {.pure.} = object + dwStreamNumber*: DWORD + dwReserved*: DWORD + hSourceFile*: HANDLE + hDestinationFile*: HANDLE + uliStreamSize*: ULARGE_INTEGER + uliTotalFileSize*: ULARGE_INTEGER + COPYFILE2_MESSAGE_Info_StreamFinished* {.pure.} = object + dwStreamNumber*: DWORD + dwReserved*: DWORD + hSourceFile*: HANDLE + hDestinationFile*: HANDLE + uliStreamSize*: ULARGE_INTEGER + uliStreamBytesTransferred*: ULARGE_INTEGER + uliTotalFileSize*: ULARGE_INTEGER + uliTotalBytesTransferred*: ULARGE_INTEGER + COPYFILE2_MESSAGE_Info_PollContinue* {.pure.} = object + dwReserved*: DWORD + COPYFILE2_MESSAGE_Info_Error* {.pure.} = object + CopyPhase*: COPYFILE2_COPY_PHASE + dwStreamNumber*: DWORD + hrFailure*: HRESULT + dwReserved*: DWORD + uliChunkNumber*: ULARGE_INTEGER + uliStreamSize*: ULARGE_INTEGER + uliStreamBytesTransferred*: ULARGE_INTEGER + uliTotalFileSize*: ULARGE_INTEGER + uliTotalBytesTransferred*: ULARGE_INTEGER + COPYFILE2_MESSAGE_Info* {.pure, union.} = object + ChunkStarted*: COPYFILE2_MESSAGE_Info_ChunkStarted + ChunkFinished*: COPYFILE2_MESSAGE_Info_ChunkFinished + StreamStarted*: COPYFILE2_MESSAGE_Info_StreamStarted + StreamFinished*: COPYFILE2_MESSAGE_Info_StreamFinished + PollContinue*: COPYFILE2_MESSAGE_Info_PollContinue + Error*: COPYFILE2_MESSAGE_Info_Error + COPYFILE2_MESSAGE* {.pure.} = object + Type*: COPYFILE2_MESSAGE_TYPE + dwPadding*: DWORD + Info*: COPYFILE2_MESSAGE_Info + PCOPYFILE2_PROGRESS_ROUTINE* = proc (pMessage: ptr COPYFILE2_MESSAGE, pvCallbackContext: PVOID): COPYFILE2_MESSAGE_ACTION {.stdcall.} + PQUERYACTCTXW_FUNC* = proc (dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: ptr SIZE_T): WINBOOL {.stdcall.} + APPLICATION_RECOVERY_CALLBACK* = proc (pvParameter: PVOID): DWORD {.stdcall.} + COPYFILE2_EXTENDED_PARAMETERS* {.pure.} = object + dwSize*: DWORD + dwCopyFlags*: DWORD + pfCancel*: ptr WINBOOL + pProgressRoutine*: PCOPYFILE2_PROGRESS_ROUTINE + pvCallbackContext*: PVOID +proc IsDebuggerPresent*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OutputDebugStringA*(lpOutputString: LPCSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OutputDebugStringW*(lpOutputString: LPCWSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DebugBreak*(): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ContinueDebugEvent*(dwProcessId: DWORD, dwThreadId: DWORD, dwContinueStatus: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForDebugEvent*(lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DebugActiveProcess*(dwProcessId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DebugActiveProcessStop*(dwProcessId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CheckRemoteDebuggerPresent*(hProcess: HANDLE, pbDebuggerPresent: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnhandledExceptionFilter*(ExceptionInfo: ptr EXCEPTION_POINTERS): LONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetUnhandledExceptionFilter*(lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER): LPTOP_LEVEL_EXCEPTION_FILTER {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetErrorMode*(uMode: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddVectoredExceptionHandler*(First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveVectoredExceptionHandler*(Handle: PVOID): ULONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddVectoredContinueHandler*(First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveVectoredContinueHandler*(Handle: PVOID): ULONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetErrorMode*(): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RestoreLastError*(dwErrCode: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RaiseException*(dwExceptionCode: DWORD, dwExceptionFlags: DWORD, nNumberOfArguments: DWORD, lpArguments: ptr ULONG_PTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLastError*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetLastError*(dwErrCode: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlsAlloc*(lpCallback: PFLS_CALLBACK_FUNCTION): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlsGetValue*(dwFlsIndex: DWORD): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlsSetValue*(dwFlsIndex: DWORD, lpFlsData: PVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlsFree*(dwFlsIndex: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsThreadAFiber*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CompareFileTime*(lpFileTime1: ptr FILETIME, lpFileTime2: ptr FILETIME): LONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileA*(lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileW*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DefineDosDeviceW*(dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteVolumeMountPointW*(lpszVolumeMountPoint: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FileTimeToLocalFileTime*(lpFileTime: ptr FILETIME, lpLocalFileTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindCloseChangeNotification*(hChangeHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstChangeNotificationA*(lpPathName: LPCSTR, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstChangeNotificationW*(lpPathName: LPCWSTR, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileA*(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileW*(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstVolumeW*(lpszVolumeName: LPWSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextChangeNotification*(hChangeHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextVolumeW*(hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindVolumeClose*(hFindVolume: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDiskFreeSpaceA*(lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDiskFreeSpaceW*(lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDriveTypeA*(lpRootPathName: LPCSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDriveTypeW*(lpRootPathName: LPCWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesA*(lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesW*(lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileInformationByHandle*(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileSize*(hFile: HANDLE, lpFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileSizeEx*(hFile: HANDLE, lpFileSize: PLARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileTime*(hFile: HANDLE, lpCreationTime: LPFILETIME, lpLastAccessTime: LPFILETIME, lpLastWriteTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileType*(hFile: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFullPathNameA*(lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFullPathNameW*(lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLogicalDrives*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLogicalDriveStringsW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLongPathNameA*(lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLongPathNameW*(lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetShortPathNameW*(lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTempFileNameW*(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumeInformationW*(lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumePathNameW*(lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalFileTimeToFileTime*(lpLocalFileTime: ptr FILETIME, lpFileTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LockFile*(hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryDosDeviceW*(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadFileEx*(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadFileScatter*(hFile: HANDLE, aSegmentArray: ptr FILE_SEGMENT_ELEMENT, nNumberOfBytesToRead: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFilePointer*(hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileTime*(hFile: HANDLE, lpCreationTime: ptr FILETIME, lpLastAccessTime: ptr FILETIME, lpLastWriteTime: ptr FILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileValidData*(hFile: HANDLE, ValidDataLength: LONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnlockFile*(hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteFileEx*(hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteFileGather*(hFile: HANDLE, aSegmentArray: ptr FILE_SEGMENT_ELEMENT, nNumberOfBytesToWrite: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumeNameForVolumeMountPointW*(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumePathNamesForVolumeNameW*(lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFinalPathNameByHandleA*(hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFinalPathNameByHandleW*(hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumeInformationByHandleW*(hFile: HANDLE, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryA*(lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryW*(lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteFileA*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteFileW*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindClose*(hFindFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileExA*(lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileExW*(lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextFileA*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextFileW*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlushFileBuffers*(hFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDiskFreeSpaceExA*(lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDiskFreeSpaceExW*(lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesExA*(lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesExW*(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTempPathW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LockFileEx*(hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadFile*(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveDirectoryA*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveDirectoryW*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEndOfFile*(hFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileAttributesA*(lpFileName: LPCSTR, dwFileAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileAttributesW*(lpFileName: LPCWSTR, dwFileAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFilePointerEx*(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnlockFileEx*(hFile: HANDLE, dwReserved: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteFile*(hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileInformationByHandle*(hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFile2*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwCreationDisposition: DWORD, pCreateExParams: LPCREATEFILE2_EXTENDED_PARAMETERS): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseHandle*(hObject: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DuplicateHandle*(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, dwOptions: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetHandleInformation*(hObject: HANDLE, lpdwFlags: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetHandleInformation*(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapCreate*(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapDestroy*(hHeap: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapValidate*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapCompact*(hHeap: HANDLE, dwFlags: DWORD): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapSummary*(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessHeaps*(NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapLock*(hHeap: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapUnlock*(hHeap: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapWalk*(hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapSetInformation*(HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapQueryInformation*(HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapAlloc*(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapReAlloc*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapFree*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc HeapSize*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessHeap*(): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetOverlappedResult*(hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateIoCompletionPort*(FileHandle: HANDLE, ExistingCompletionPort: HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetQueuedCompletionStatus*(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: PULONG_PTR, lpOverlapped: ptr LPOVERLAPPED, dwMilliseconds: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PostQueuedCompletionStatus*(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeviceIoControl*(hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelIo*(hFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetQueuedCompletionStatusEx*(CompletionPort: HANDLE, lpCompletionPortEntries: LPOVERLAPPED_ENTRY, ulCount: ULONG, ulNumEntriesRemoved: PULONG, dwMilliseconds: DWORD, fAlertable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelIoEx*(hFile: HANDLE, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelSynchronousIo*(hThread: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetOverlappedResultEx*(hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, dwMilliseconds: DWORD, bAlertable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeSListHead*(ListHead: PSLIST_HEADER): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InterlockedPopEntrySList*(ListHead: PSLIST_HEADER): PSLIST_ENTRY {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InterlockedPushEntrySList*(ListHead: PSLIST_HEADER, ListEntry: PSLIST_ENTRY): PSLIST_ENTRY {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InterlockedFlushSList*(ListHead: PSLIST_HEADER): PSLIST_ENTRY {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryDepthSList*(ListHead: PSLIST_HEADER): USHORT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InterlockedPushListSListEx*(ListHead: PSLIST_HEADER, List: PSLIST_ENTRY, ListEnd: PSLIST_ENTRY, Count: ULONG): PSLIST_ENTRY {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsProcessInJob*(ProcessHandle: HANDLE, JobHandle: HANDLE, Result: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindResourceExW*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeLibraryAndExitThread*(hLibModule: HMODULE, dwExitCode: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeResource*(hResData: HGLOBAL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleFileNameA*(hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleFileNameW*(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleHandleA*(lpModuleName: LPCSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleHandleW*(lpModuleName: LPCWSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadLibraryExA*(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadLibraryExW*(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadResource*(hModule: HMODULE, hResInfo: HRSRC): HGLOBAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadStringA*(hInstance: HINSTANCE, uID: UINT, lpBuffer: LPSTR, cchBufferMax: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadStringW*(hInstance: HINSTANCE, uID: UINT, lpBuffer: LPWSTR, cchBufferMax: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc LockResource*(hResData: HGLOBAL): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SizeofResource*(hModule: HMODULE, hResInfo: HRSRC): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddDllDirectory*(NewDirectory: PCWSTR): DLL_DIRECTORY_COOKIE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveDllDirectory*(Cookie: DLL_DIRECTORY_COOKIE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDefaultDllDirectories*(DirectoryFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleHandleExA*(dwFlags: DWORD, lpModuleName: LPCSTR, phModule: ptr HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetModuleHandleExW*(dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: ptr HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceLanguagesA*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceLanguagesW*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceLanguagesExA*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceLanguagesExW*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceNamesExA*(hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceNamesExW*(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceTypesExA*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceTypesExW*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DisableThreadLibraryCalls*(hLibModule: HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeLibrary*(hLibModule: HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcAddress*(hModule: HMODULE, lpProcName: LPCSTR): FARPROC {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindStringOrdinal*(dwFindStringOrdinalFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int32, lpStringValue: LPCWSTR, cchValue: int32, bIgnoreCase: WINBOOL): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualQuery*(lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlushViewOfFile*(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnmapViewOfFile*(lpBaseAddress: LPCVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileMappingFromApp*(hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG, MaximumSize: ULONG64, Name: PCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapViewOfFileFromApp*(hFileMappingObject: HANDLE, DesiredAccess: ULONG, FileOffset: ULONG64, NumberOfBytesToMap: SIZE_T): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualAlloc*(lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualFree*(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualProtect*(lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualAllocEx*(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualFreeEx*(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualProtectEx*(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualQueryEx*(hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadProcessMemory*(hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: ptr SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteProcessMemory*(hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: ptr SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileMappingW*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenFileMappingW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapViewOfFile*(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapViewOfFileEx*(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLargePageMinimum*(): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessWorkingSetSizeEx*(hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessWorkingSetSizeEx*(hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualLock*(lpAddress: LPVOID, dwSize: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualUnlock*(lpAddress: LPVOID, dwSize: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetWriteWatch*(dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: ptr PVOID, lpdwCount: ptr ULONG_PTR, lpdwGranularity: LPDWORD): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ResetWriteWatch*(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMemoryResourceNotification*(NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryMemoryResourceNotification*(ResourceNotificationHandle: HANDLE, ResourceState: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemFileCacheSize*(lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetSystemFileCacheSize*(MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileMappingNumaW*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PrefetchVirtualMemory*(hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnmapViewOfFileEx*(BaseAddress: PVOID, UnmapFlags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DiscardVirtualMemory*(VirtualAddress: PVOID, Size: SIZE_T): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OfferVirtualMemory*(VirtualAddress: PVOID, Size: SIZE_T, Priority: OFFER_PRIORITY): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReclaimVirtualMemory*(VirtualAddress: PVOID, Size: SIZE_T): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ImpersonateNamedPipeClient*(hNamedPipe: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreatePipe*(hReadPipe: PHANDLE, hWritePipe: PHANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConnectNamedPipe*(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DisconnectNamedPipe*(hNamedPipe: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetNamedPipeHandleState*(hNamedPipe: HANDLE, lpMode: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PeekNamedPipe*(hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD, lpBytesRead: LPDWORD, lpTotalBytesAvail: LPDWORD, lpBytesLeftThisMessage: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TransactNamedPipe*(hNamedPipe: HANDLE, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateNamedPipeW*(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitNamedPipeW*(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeClientComputerNameW*(Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreatePrivateNamespaceW*(lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenPrivateNamespaceW*(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ClosePrivateNamespace*(Handle: HANDLE, Flags: ULONG): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateBoundaryDescriptorW*(Name: LPCWSTR, Flags: ULONG): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddSIDToBoundaryDescriptor*(BoundaryDescriptor: ptr HANDLE, RequiredSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteBoundaryDescriptor*(BoundaryDescriptor: HANDLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetEnvironmentStringsA*(): LPCH {.winapi, stdcall, dynlib: "kernel32", importc: "GetEnvironmentStrings".} +proc GetEnvironmentStringsW*(): LPWCH {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEnvironmentStringsW*(NewEnvironment: LPWCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeEnvironmentStringsA*(penv: LPCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeEnvironmentStringsW*(penv: LPWCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStdHandle*(nStdHandle: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetStdHandle*(nStdHandle: DWORD, hHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetStdHandleEx*(nStdHandle: DWORD, hHandle: HANDLE, phPrevValue: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommandLineA*(): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommandLineW*(): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetEnvironmentVariableA*(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetEnvironmentVariableW*(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEnvironmentVariableA*(lpName: LPCSTR, lpValue: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEnvironmentVariableW*(lpName: LPCWSTR, lpValue: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ExpandEnvironmentStringsA*(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ExpandEnvironmentStringsW*(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCurrentDirectoryA*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCurrentDirectoryW*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentDirectoryA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentDirectoryW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SearchPathW*(lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SearchPathA*(lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc NeedCurrentDirectoryForExePathA*(ExeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc NeedCurrentDirectoryForExePathW*(ExeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueueUserAPC*(pfnAPC: PAPCFUNC, hThread: HANDLE, dwData: ULONG_PTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessTimes*(hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ExitProcess*(uExitCode: UINT): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TerminateProcess*(hProcess: HANDLE, uExitCode: UINT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetExitCodeProcess*(hProcess: HANDLE, lpExitCode: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SwitchToThread*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateRemoteThread*(hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenThread*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, dwThreadId: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadPriorityBoost*(hThread: HANDLE, bDisablePriorityBoost: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadPriorityBoost*(hThread: HANDLE, pDisablePriorityBoost: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TerminateThread*(hThread: HANDLE, dwExitCode: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessShutdownParameters*(dwLevel: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessVersion*(ProcessId: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStartupInfoW*(lpStartupInfo: LPSTARTUPINFOW): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadToken*(Thread: PHANDLE, Token: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenProcessToken*(ProcessHandle: HANDLE, DesiredAccess: DWORD, TokenHandle: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenThreadToken*(ThreadHandle: HANDLE, DesiredAccess: DWORD, OpenAsSelf: WINBOOL, TokenHandle: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetPriorityClass*(hProcess: HANDLE, dwPriorityClass: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadStackGuarantee*(StackSizeInBytes: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPriorityClass*(hProcess: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ProcessIdToSessionId*(dwProcessId: DWORD, pSessionId: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessId*(Process: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadId*(Thread: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateRemoteThreadEx*(hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, lpThreadId: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadContext*(hThread: HANDLE, lpContext: LPCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadContext*(hThread: HANDLE, lpContext: ptr CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlushInstructionCache*(hProcess: HANDLE, lpBaseAddress: LPCVOID, dwSize: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadTimes*(hThread: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenProcess*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, dwProcessId: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessHandleCount*(hProcess: HANDLE, pdwHandleCount: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentProcessorNumber*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateProcessA*(lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateProcessW*(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateProcessAsUserW*(hToken: HANDLE, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetProcessIdOfThread*(Thread: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeProcThreadAttributeList*(lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount: DWORD, dwFlags: DWORD, lpSize: PSIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteProcThreadAttributeList*(lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessAffinityUpdateMode*(hProcess: HANDLE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryProcessAffinityUpdateMode*(hProcess: HANDLE, lpdwFlags: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UpdateProcThreadAttribute*(lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags: DWORD, Attribute: DWORD_PTR, lpValue: PVOID, cbSize: SIZE_T, lpPreviousValue: PVOID, lpReturnSize: PSIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadIdealProcessorEx*(hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentProcessorNumberEx*(ProcNumber: PPROCESSOR_NUMBER): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentThreadStackLimits*(LowLimit: PULONG_PTR, HighLimit: PULONG_PTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessMitigationPolicy*(MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: PVOID, dwLength: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessMitigationPolicy*(hProcess: HANDLE, MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: PVOID, dwLength: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentProcess*(): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentProcessId*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentThread*(): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentThreadId*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsProcessorFeaturePresent*(ProcessorFeature: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlushProcessWriteBuffers*(): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThread*(lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadPriority*(hThread: HANDLE, nPriority: int32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadPriority*(hThread: HANDLE): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ExitThread*(dwExitCode: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetExitCodeThread*(hThread: HANDLE, lpExitCode: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SuspendThread*(hThread: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ResumeThread*(hThread: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TlsAlloc*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TlsGetValue*(dwTlsIndex: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TlsSetValue*(dwTlsIndex: DWORD, lpTlsValue: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TlsFree*(dwTlsIndex: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadIdealProcessorEx*(hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER, lpPreviousIdealProcessor: PPROCESSOR_NUMBER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessGroupAffinity*(hProcess: HANDLE, GroupCount: PUSHORT, GroupArray: PUSHORT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadGroupAffinity*(hThread: HANDLE, GroupAffinity: PGROUP_AFFINITY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadGroupAffinity*(hThread: HANDLE, GroupAffinity: ptr GROUP_AFFINITY, PreviousGroupAffinity: PGROUP_AFFINITY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryPerformanceCounter*(lpPerformanceCount: ptr LARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryPerformanceFrequency*(lpFrequency: ptr LARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryThreadCycleTime*(ThreadHandle: HANDLE, CycleTime: PULONG64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryProcessCycleTime*(ProcessHandle: HANDLE, CycleTime: PULONG64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryIdleProcessorCycleTime*(BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryIdleProcessorCycleTimeEx*(Group: USHORT, BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryUnbiasedInterruptTime*(UnbiasedTime: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetAppContainerNamedObjectPath*(Token: HANDLE, AppContainerSid: PSID, ObjectPathLength: ULONG, ObjectPath: LPWSTR, ReturnLength: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AccessCheck*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccess: LPDWORD, AccessStatus: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckAndAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByType*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, DesiredAccess: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccess: LPDWORD, AccessStatus: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeResultList*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, DesiredAccess: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeAndAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeResultListAndAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeResultListAndAuditAlarmByHandleW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessAllowedAce*(pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessAllowedAceEx*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessAllowedObjectAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: ptr GUID, InheritedObjectTypeGuid: ptr GUID, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessDeniedAce*(pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessDeniedAceEx*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAccessDeniedObjectAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: ptr GUID, InheritedObjectTypeGuid: ptr GUID, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAce*(pAcl: PACL, dwAceRevision: DWORD, dwStartingAceIndex: DWORD, pAceList: LPVOID, nAceListLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAuditAccessAce*(pAcl: PACL, dwAceRevision: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: WINBOOL, bAuditFailure: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAuditAccessAceEx*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: WINBOOL, bAuditFailure: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddAuditAccessObjectAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: ptr GUID, InheritedObjectTypeGuid: ptr GUID, pSid: PSID, bAuditSuccess: WINBOOL, bAuditFailure: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddMandatoryAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, MandatoryPolicy: DWORD, pLabelSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddResourceAttributeAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID, pAttributeInfo: PCLAIM_SECURITY_ATTRIBUTES_INFORMATION, pReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddScopedPolicyIDAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AdjustTokenGroups*(TokenHandle: HANDLE, ResetToDefault: WINBOOL, NewState: PTOKEN_GROUPS, BufferLength: DWORD, PreviousState: PTOKEN_GROUPS, ReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AdjustTokenPrivileges*(TokenHandle: HANDLE, DisableAllPrivileges: WINBOOL, NewState: PTOKEN_PRIVILEGES, BufferLength: DWORD, PreviousState: PTOKEN_PRIVILEGES, ReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AllocateAndInitializeSid*(pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, nSubAuthorityCount: BYTE, nSubAuthority0: DWORD, nSubAuthority1: DWORD, nSubAuthority2: DWORD, nSubAuthority3: DWORD, nSubAuthority4: DWORD, nSubAuthority5: DWORD, nSubAuthority6: DWORD, nSubAuthority7: DWORD, pSid: ptr PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AllocateLocallyUniqueId*(Luid: PLUID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AreAllAccessesGranted*(GrantedAccess: DWORD, DesiredAccess: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AreAnyAccessesGranted*(GrantedAccess: DWORD, DesiredAccess: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CheckTokenMembership*(TokenHandle: HANDLE, SidToCheck: PSID, IsMember: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CheckTokenCapability*(TokenHandle: HANDLE, CapabilitySidToCheck: PSID, HasCapability: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetAppContainerAce*(Acl: PACL, StartingAceIndex: DWORD, AppContainerAce: ptr PVOID, AppContainerAceIndex: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CheckTokenMembershipEx*(TokenHandle: HANDLE, SidToCheck: PSID, Flags: DWORD, IsMember: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConvertToAutoInheritPrivateObjectSecurity*(ParentDescriptor: PSECURITY_DESCRIPTOR, CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR, NewSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, ObjectType: ptr GUID, IsDirectoryObject: BOOLEAN, GenericMapping: PGENERIC_MAPPING): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CopySid*(nDestinationSidLength: DWORD, pDestinationSid: PSID, pSourceSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreatePrivateObjectSecurity*(ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: ptr PSECURITY_DESCRIPTOR, IsDirectoryObject: WINBOOL, Token: HANDLE, GenericMapping: PGENERIC_MAPPING): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreatePrivateObjectSecurityEx*(ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: ptr PSECURITY_DESCRIPTOR, ObjectType: ptr GUID, IsContainerObject: WINBOOL, AutoInheritFlags: ULONG, Token: HANDLE, GenericMapping: PGENERIC_MAPPING): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreatePrivateObjectSecurityWithMultipleInheritance*(ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: ptr PSECURITY_DESCRIPTOR, ObjectTypes: ptr ptr GUID, GuidCount: ULONG, IsContainerObject: WINBOOL, AutoInheritFlags: ULONG, Token: HANDLE, GenericMapping: PGENERIC_MAPPING): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateRestrictedToken*(ExistingTokenHandle: HANDLE, Flags: DWORD, DisableSidCount: DWORD, SidsToDisable: PSID_AND_ATTRIBUTES, DeletePrivilegeCount: DWORD, PrivilegesToDelete: PLUID_AND_ATTRIBUTES, RestrictedSidCount: DWORD, SidsToRestrict: PSID_AND_ATTRIBUTES, NewTokenHandle: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateWellKnownSid*(WellKnownSidType: WELL_KNOWN_SID_TYPE, DomainSid: PSID, pSid: PSID, cbSid: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EqualDomainSid*(pSid1: PSID, pSid2: PSID, pfEqual: ptr WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DeleteAce*(pAcl: PACL, dwAceIndex: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DestroyPrivateObjectSecurity*(ObjectDescriptor: ptr PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DuplicateToken*(ExistingTokenHandle: HANDLE, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, DuplicateTokenHandle: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DuplicateTokenEx*(hExistingToken: HANDLE, dwDesiredAccess: DWORD, lpTokenAttributes: LPSECURITY_ATTRIBUTES, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, TokenType: TOKEN_TYPE, phNewToken: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EqualPrefixSid*(pSid1: PSID, pSid2: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EqualSid*(pSid1: PSID, pSid2: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FindFirstFreeAce*(pAcl: PACL, pAce: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FreeSid*(pSid: PSID): PVOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetAce*(pAcl: PACL, dwAceIndex: DWORD, pAce: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetAclInformation*(pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetFileSecurityW*(lpFileName: LPCWSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetKernelObjectSecurity*(Handle: HANDLE, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetLengthSid*(pSid: PSID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetPrivateObjectSecurity*(ObjectDescriptor: PSECURITY_DESCRIPTOR, SecurityInformation: SECURITY_INFORMATION, ResultantDescriptor: PSECURITY_DESCRIPTOR, DescriptorLength: DWORD, ReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorControl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, pControl: PSECURITY_DESCRIPTOR_CONTROL, lpdwRevision: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorDacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbDaclPresent: LPBOOL, pDacl: ptr PACL, lpbDaclDefaulted: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorGroup*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: ptr PSID, lpbGroupDefaulted: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorLength*(pSecurityDescriptor: PSECURITY_DESCRIPTOR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorOwner*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: ptr PSID, lpbOwnerDefaulted: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorRMControl*(SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSecurityDescriptorSacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbSaclPresent: LPBOOL, pSacl: ptr PACL, lpbSaclDefaulted: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSidIdentifierAuthority*(pSid: PSID): PSID_IDENTIFIER_AUTHORITY {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSidLengthRequired*(nSubAuthorityCount: UCHAR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSidSubAuthority*(pSid: PSID, nSubAuthority: DWORD): PDWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetSidSubAuthorityCount*(pSid: PSID): PUCHAR {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetTokenInformation*(TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD, ReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetWindowsAccountDomainSid*(pSid: PSID, pDomainSid: PSID, cbDomainSid: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ImpersonateAnonymousToken*(ThreadHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ImpersonateLoggedOnUser*(hToken: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ImpersonateSelf*(ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitializeAcl*(pAcl: PACL, nAclLength: DWORD, dwAclRevision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitializeSecurityDescriptor*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, dwRevision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitializeSid*(Sid: PSID, pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, nSubAuthorityCount: BYTE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsTokenRestricted*(TokenHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsValidAcl*(pAcl: PACL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsValidSecurityDescriptor*(pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsValidSid*(pSid: PSID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsWellKnownSid*(pSid: PSID, WellKnownSidType: WELL_KNOWN_SID_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc MakeAbsoluteSD*(pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwAbsoluteSecurityDescriptorSize: LPDWORD, pDacl: PACL, lpdwDaclSize: LPDWORD, pSacl: PACL, lpdwSaclSize: LPDWORD, pOwner: PSID, lpdwOwnerSize: LPDWORD, pPrimaryGroup: PSID, lpdwPrimaryGroupSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc MakeSelfRelativeSD*(pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc MapGenericMask*(AccessMask: PDWORD, GenericMapping: PGENERIC_MAPPING): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectCloseAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectDeleteAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectOpenAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: WINBOOL, AccessGranted: WINBOOL, GenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectPrivilegeAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc PrivilegeCheck*(ClientToken: HANDLE, RequiredPrivileges: PPRIVILEGE_SET, pfResult: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc PrivilegedServiceAuditAlarmW*(SubsystemName: LPCWSTR, ServiceName: LPCWSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QuerySecurityAccessMask*(SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RevertToSelf*(): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetAclInformation*(pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetFileSecurityW*(lpFileName: LPCWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetKernelObjectSecurity*(Handle: HANDLE, SecurityInformation: SECURITY_INFORMATION, SecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetPrivateObjectSecurity*(SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, GenericMapping: PGENERIC_MAPPING, Token: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetPrivateObjectSecurityEx*(SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: ptr PSECURITY_DESCRIPTOR, AutoInheritFlags: ULONG, GenericMapping: PGENERIC_MAPPING, Token: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityAccessMask*(SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorControl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, ControlBitsOfInterest: SECURITY_DESCRIPTOR_CONTROL, ControlBitsToSet: SECURITY_DESCRIPTOR_CONTROL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorDacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, bDaclPresent: WINBOOL, pDacl: PACL, bDaclDefaulted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorGroup*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: PSID, bGroupDefaulted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorOwner*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: PSID, bOwnerDefaulted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorRMControl*(SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetSecurityDescriptorSacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR, bSaclPresent: WINBOOL, pSacl: PACL, bSaclDefaulted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetTokenInformation*(TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetCachedSigningLevel*(SourceFiles: PHANDLE, SourceFileCount: ULONG, Flags: ULONG, TargetFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCachedSigningLevel*(File: HANDLE, Flags: PULONG, SigningLevel: PULONG, Thumbprint: PUCHAR, ThumbprintSize: PULONG, ThumbprintAlgorithm: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnterCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LeaveCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TryEnterCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEvent*(hEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ResetEvent*(hEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseSemaphore*(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseMutex*(hMutex: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForSingleObjectEx*(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForMultipleObjectsEx*(nCount: DWORD, lpHandles: ptr HANDLE, bWaitAll: WINBOOL, dwMilliseconds: DWORD, bAlertable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenMutexW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenEventA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenEventW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenSemaphoreW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeSRWLock*(SRWLock: PSRWLOCK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseSRWLockExclusive*(SRWLock: PSRWLOCK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseSRWLockShared*(SRWLock: PSRWLOCK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AcquireSRWLockExclusive*(SRWLock: PSRWLOCK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AcquireSRWLockShared*(SRWLock: PSRWLOCK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TryAcquireSRWLockExclusive*(SRWLock: PSRWLOCK): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TryAcquireSRWLockShared*(SRWLock: PSRWLOCK): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeCriticalSectionEx*(lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitOnceInitialize*(InitOnce: PINIT_ONCE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitOnceExecuteOnce*(InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitOnceBeginInitialize*(lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitOnceComplete*(lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeConditionVariable*(ConditionVariable: PCONDITION_VARIABLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WakeConditionVariable*(ConditionVariable: PCONDITION_VARIABLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WakeAllConditionVariable*(ConditionVariable: PCONDITION_VARIABLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SleepConditionVariableCS*(ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION, dwMilliseconds: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SleepConditionVariableSRW*(ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMutexExA*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMutexExW*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateEventExA*(lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateEventExW*(lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSemaphoreExW*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeCriticalSectionAndSpinCount*(lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCriticalSectionSpinCount*(lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForSingleObject*(hHandle: HANDLE, dwMilliseconds: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SleepEx*(dwMilliseconds: DWORD, bAlertable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMutexA*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMutexW*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateEventA*(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, bInitialState: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateEventW*(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, bInitialState: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetWaitableTimer*(hTimer: HANDLE, lpDueTime: ptr LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelWaitableTimer*(hTimer: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenWaitableTimerW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpTimerName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnterSynchronizationBarrier*(lpBarrier: LPSYNCHRONIZATION_BARRIER, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeSynchronizationBarrier*(lpBarrier: LPSYNCHRONIZATION_BARRIER, lTotalThreads: LONG, lSpinCount: LONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteSynchronizationBarrier*(lpBarrier: LPSYNCHRONIZATION_BARRIER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Sleep*(dwMilliseconds: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SignalObjectAndWait*(hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateWaitableTimerExW*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetWaitableTimerEx*(hTimer: HANDLE, lpDueTime: ptr LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemTime*(lpSystemTime: LPSYSTEMTIME): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemTimeAsFileTime*(lpSystemTimeAsFileTime: LPFILETIME): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLocalTime*(lpSystemTime: LPSYSTEMTIME): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNativeSystemInfo*(lpSystemInfo: LPSYSTEM_INFO): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTickCount64*(): ULONGLONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVersion*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalMemoryStatusEx*(lpBuffer: LPMEMORYSTATUSEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetLocalTime*(lpSystemTime: ptr SYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemInfo*(lpSystemInfo: LPSYSTEM_INFO): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTickCount*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemTimeAdjustment*(lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD, lpTimeAdjustmentDisabled: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetWindowsDirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetWindowsDirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemWindowsDirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemWindowsDirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetComputerNameExA*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetComputerNameExW*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetComputerNameExW*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetSystemTime*(lpSystemTime: ptr SYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVersionExA*(lpVersionInformation: LPOSVERSIONINFOA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVersionExW*(lpVersionInformation: LPOSVERSIONINFOW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLogicalProcessorInformation*(Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, ReturnedLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemTimePreciseAsFileTime*(lpSystemTimeAsFileTime: LPFILETIME): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemFirmwareTables*(FirmwareTableProviderSignature: DWORD, pFirmwareTableEnumBuffer: PVOID, BufferSize: DWORD): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemFirmwareTable*(FirmwareTableProviderSignature: DWORD, FirmwareTableID: DWORD, pFirmwareTableBuffer: PVOID, BufferSize: DWORD): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProductInfo*(dwOSMajorVersion: DWORD, dwOSMinorVersion: DWORD, dwSpMajorVersion: DWORD, dwSpMinorVersion: DWORD, pdwReturnedProductType: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLogicalProcessorInformationEx*(RelationshipType: LOGICAL_PROCESSOR_RELATIONSHIP, Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, ReturnedLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaHighestNodeNumber*(HighestNodeNumber: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaNodeProcessorMaskEx*(Node: USHORT, ProcessorMask: PGROUP_AFFINITY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpool*(reserved: PVOID): PTP_POOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolThreadMaximum*(ptpp: PTP_POOL, cthrdMost: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolThreadMinimum*(ptpp: PTP_POOL, cthrdMic: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolStackInformation*(ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryThreadpoolStackInformation*(ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpool*(ptpp: PTP_POOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpoolCleanupGroup*(): PTP_CLEANUP_GROUP {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolCleanupGroupMembers*(ptpcg: PTP_CLEANUP_GROUP, fCancelPendingCallbacks: WINBOOL, pvCleanupContext: PVOID): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolCleanupGroup*(ptpcg: PTP_CLEANUP_GROUP): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEventWhenCallbackReturns*(pci: PTP_CALLBACK_INSTANCE, evt: HANDLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseSemaphoreWhenCallbackReturns*(pci: PTP_CALLBACK_INSTANCE, sem: HANDLE, crel: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseMutexWhenCallbackReturns*(pci: PTP_CALLBACK_INSTANCE, mut: HANDLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LeaveCriticalSectionWhenCallbackReturns*(pci: PTP_CALLBACK_INSTANCE, pcs: PCRITICAL_SECTION): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeLibraryWhenCallbackReturns*(pci: PTP_CALLBACK_INSTANCE, `mod`: HMODULE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CallbackMayRunLong*(pci: PTP_CALLBACK_INSTANCE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DisassociateCurrentThreadFromCallback*(pci: PTP_CALLBACK_INSTANCE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TrySubmitThreadpoolCallback*(pfns: PTP_SIMPLE_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpoolWork*(pfnwk: PTP_WORK_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON): PTP_WORK {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SubmitThreadpoolWork*(pwk: PTP_WORK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForThreadpoolWorkCallbacks*(pwk: PTP_WORK, fCancelPendingCallbacks: WINBOOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolWork*(pwk: PTP_WORK): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpoolTimer*(pfnti: PTP_TIMER_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON): PTP_TIMER {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolTimer*(pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsThreadpoolTimerSet*(pti: PTP_TIMER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForThreadpoolTimerCallbacks*(pti: PTP_TIMER, fCancelPendingCallbacks: WINBOOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolTimer*(pti: PTP_TIMER): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpoolWait*(pfnwa: PTP_WAIT_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON): PTP_WAIT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolWait*(pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForThreadpoolWaitCallbacks*(pwa: PTP_WAIT, fCancelPendingCallbacks: WINBOOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolWait*(pwa: PTP_WAIT): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateThreadpoolIo*(fl: HANDLE, pfnio: PTP_WIN32_IO_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON): PTP_IO {.winapi, stdcall, dynlib: "kernel32", importc.} +proc StartThreadpoolIo*(pio: PTP_IO): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelThreadpoolIo*(pio: PTP_IO): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForThreadpoolIoCallbacks*(pio: PTP_IO, fCancelPendingCallbacks: WINBOOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CloseThreadpoolIo*(pio: PTP_IO): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolTimerEx*(pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadpoolWaitEx*(pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME, Reserved: PVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateTimerQueueTimer*(phNewTimer: PHANDLE, TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteTimerQueueTimer*(TimerQueue: HANDLE, Timer: HANDLE, CompletionEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueueUserWorkItem*(Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnregisterWaitEx*(WaitHandle: HANDLE, CompletionEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateTimerQueue*(): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ChangeTimerQueueTimer*(TimerQueue: HANDLE, Timer: HANDLE, DueTime: ULONG, Period: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteTimerQueueEx*(TimerQueue: HANDLE, CompletionEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EncodePointer*(Ptr: PVOID): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DecodePointer*(Ptr: PVOID): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EncodeSystemPointer*(Ptr: PVOID): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DecodeSystemPointer*(Ptr: PVOID): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Beep*(dwFreq: DWORD, dwDuration: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64DisableWow64FsRedirection*(OldValue: ptr PVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64RevertWow64FsRedirection*(OlValue: PVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsWow64Process*(hProcess: HANDLE, Wow64Process: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalAlloc*(uFlags: UINT, dwBytes: SIZE_T): HGLOBAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalReAlloc*(hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT): HGLOBAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalSize*(hMem: HGLOBAL): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalFlags*(hMem: HGLOBAL): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalLock*(hMem: HGLOBAL): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalHandle*(pMem: LPCVOID): HGLOBAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalUnlock*(hMem: HGLOBAL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalFree*(hMem: HGLOBAL): HGLOBAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalCompact*(dwMinFree: DWORD): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalFix*(hMem: HGLOBAL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalUnfix*(hMem: HGLOBAL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalWire*(hMem: HGLOBAL): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalUnWire*(hMem: HGLOBAL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalMemoryStatus*(lpBuffer: LPMEMORYSTATUS): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalAlloc*(uFlags: UINT, uBytes: SIZE_T): HLOCAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalReAlloc*(hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT): HLOCAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalLock*(hMem: HLOCAL): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalHandle*(pMem: LPCVOID): HLOCAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalUnlock*(hMem: HLOCAL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalSize*(hMem: HLOCAL): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalFlags*(hMem: HLOCAL): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalFree*(hMem: HLOCAL): HLOCAL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalShrink*(hMem: HLOCAL, cbNewSize: UINT): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocalCompact*(uMinFree: UINT): SIZE_T {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VirtualAllocExNuma*(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessorSystemCycleTime*(Group: USHORT, Buffer: PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, ReturnedLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPhysicallyInstalledSystemMemory*(TotalMemoryInKilobytes: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetBinaryTypeA*(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetBinaryTypeW*(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetShortPathNameA*(lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLongPathNameTransactedA*(lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLongPathNameTransactedW*(lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessAffinityMask*(hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessAffinityMask*(hProcess: HANDLE, dwProcessAffinityMask: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessIoCounters*(hProcess: HANDLE, lpIoCounters: PIO_COUNTERS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessWorkingSetSize*(hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessWorkingSetSize*(hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FatalExit*(ExitCode: int32): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetEnvironmentStringsA*(NewEnvironment: LPCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RaiseFailFastException*(pExceptionRecord: PEXCEPTION_RECORD, pContextRecord: PCONTEXT, dwFlags: DWORD): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadIdealProcessor*(hThread: HANDLE, dwIdealProcessor: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFiber*(dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFiberEx*(dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteFiber*(lpFiber: LPVOID): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConvertThreadToFiber*(lpParameter: LPVOID): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConvertThreadToFiberEx*(lpParameter: LPVOID, dwFlags: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConvertFiberToThread*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SwitchToFiber*(lpFiber: LPVOID): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadAffinityMask*(hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR): DWORD_PTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadInformation*(hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS, ThreadInformation: LPVOID, ThreadInformationSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadInformation*(hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS, ThreadInformation: LPVOID, ThreadInformationSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessInformation*(hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS, ProcessInformation: LPVOID, ProcessInformationSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessInformation*(hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS, ProcessInformation: LPVOID, ProcessInformationSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessDEPPolicy*(dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessDEPPolicy*(hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessPriorityBoost*(hProcess: HANDLE, bDisablePriorityBoost: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessPriorityBoost*(hProcess: HANDLE, pDisablePriorityBoost: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RequestWakeupLatency*(latency: LATENCY_TIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsSystemResumeAutomatic*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadIOPendingFlag*(hThread: HANDLE, lpIOIsPending: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +when winimCpu64: + type + LPLDT_ENTRY* = LPVOID +when winimCpu32: + type + LPLDT_ENTRY* = PLDT_ENTRY +proc GetThreadSelectorEntry*(hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadExecutionState*(esFlags: EXECUTION_STATE): EXECUTION_STATE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PowerCreateRequest*(Context: PREASON_CONTEXT): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PowerSetRequest*(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PowerClearRequest*(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileCompletionNotificationModes*(FileHandle: HANDLE, Flags: UCHAR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileIoOverlappedRange*(FileHandle: HANDLE, OverlappedRangeStart: PUCHAR, Length: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadErrorMode*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadErrorMode*(dwNewMode: DWORD, lpOldMode: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64GetThreadContext*(hThread: HANDLE, lpContext: PWOW64_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64SetThreadContext*(hThread: HANDLE, lpContext: ptr WOW64_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64GetThreadSelectorEntry*(hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64SuspendThread*(hThread: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DebugSetProcessKillOnExit*(KillOnExit: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DebugBreakProcess*(Process: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PulseEvent*(hEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitForMultipleObjects*(nCount: DWORD, lpHandles: ptr HANDLE, bWaitAll: WINBOOL, dwMilliseconds: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalDeleteAtom*(nAtom: ATOM): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitAtomTable*(nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteAtom*(nAtom: ATOM): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetHandleCount*(uNumber: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RequestDeviceWakeup*(hDevice: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelDeviceWakeupRequest*(hDevice: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDevicePowerState*(hDevice: HANDLE, pfOn: ptr WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetMessageWaitingIndicator*(hMsgIndicator: HANDLE, ulMsgCount: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileShortNameA*(hFile: HANDLE, lpShortName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileShortNameW*(hFile: HANDLE, lpShortName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadModule*(lpModuleName: LPCSTR, lpParameterBlock: LPVOID): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WinExec*(lpCmdLine: LPCSTR, uCmdShow: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ClearCommBreak*(hFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ClearCommError*(hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetupComm*(hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EscapeCommFunction*(hFile: HANDLE, dwFunc: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommConfig*(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommMask*(hFile: HANDLE, lpEvtMask: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommProperties*(hFile: HANDLE, lpCommProp: LPCOMMPROP): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommModemStatus*(hFile: HANDLE, lpModemStat: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommState*(hFile: HANDLE, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCommTimeouts*(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PurgeComm*(hFile: HANDLE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCommBreak*(hFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCommConfig*(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCommMask*(hFile: HANDLE, dwEvtMask: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCommState*(hFile: HANDLE, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCommTimeouts*(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TransmitCommChar*(hFile: HANDLE, cChar: char): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitCommEvent*(hFile: HANDLE, lpEvtMask: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetTapePosition*(hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTapePosition*(hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PrepareTape*(hDevice: HANDLE, dwOperation: DWORD, bImmediate: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EraseTape*(hDevice: HANDLE, dwEraseType: DWORD, bImmediate: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateTapePartition*(hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteTapemark*(hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: WINBOOL): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTapeStatus*(hDevice: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTapeParameters*(hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetTapeParameters*(hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDEPPolicy*(): DEP_SYSTEM_POLICY_TYPE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemRegistryQuota*(pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemTimes*(lpIdleTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FileTimeToDosDateTime*(lpFileTime: ptr FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DosDateTimeToFileTime*(wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetSystemTimeAdjustment*(dwTimeAdjustment: DWORD, bTimeAdjustmentDisabled: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MulDiv*(nNumber: int32, nNumerator: int32, nDenominator: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FormatMessageA*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: ptr va_list): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FormatMessageW*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ptr va_list): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeInfo*(hNamedPipe: HANDLE, lpFlags: LPDWORD, lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD, lpMaxInstances: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMailslotA*(lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateMailslotW*(lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetMailslotInfo*(hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetMailslotInfo*(hMailslot: HANDLE, lReadTimeout: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EncryptFileA*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EncryptFileW*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DecryptFileA*(lpFileName: LPCSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DecryptFileW*(lpFileName: LPCWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FileEncryptionStatusA*(lpFileName: LPCSTR, lpStatus: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FileEncryptionStatusW*(lpFileName: LPCWSTR, lpStatus: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenEncryptedFileRawA*(lpFileName: LPCSTR, ulFlags: ULONG, pvContext: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenEncryptedFileRawW*(lpFileName: LPCWSTR, ulFlags: ULONG, pvContext: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReadEncryptedFileRaw*(pfExportCallback: PFE_EXPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc WriteEncryptedFileRaw*(pfImportCallback: PFE_IMPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CloseEncryptedFileRaw*(pvContext: PVOID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc lstrcmpA*(lpString1: LPCSTR, lpString2: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcmpW*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcmpiA*(lpString1: LPCSTR, lpString2: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcmpiW*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcpynA*(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int32): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcpynW*(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int32): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcpyA*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcpyW*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcatA*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrcatW*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrlenA*(lpString: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrlenW*(lpString: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenFile*(lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT): HFILE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsTextUnicode*(lpv: pointer, iSize: int32, lpiResult: LPINT): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BackupRead*(hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: WINBOOL, bProcessSecurity: WINBOOL, lpContext: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BackupSeek*(hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BackupWrite*(hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: WINBOOL, bProcessSecurity: WINBOOL, lpContext: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSemaphoreW*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadLibraryW*(lpLibFileName: LPCWSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenMutexA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSemaphoreA*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenSemaphoreA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateWaitableTimerA*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, lpTimerName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateWaitableTimerW*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, lpTimerName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenWaitableTimerA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpTimerName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileMappingA*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSemaphoreExA*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateWaitableTimerExA*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileMappingNumaA*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenFileMappingA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLogicalDriveStringsA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadLibraryA*(lpLibFileName: LPCSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LoadPackagedLibrary*(lpwLibFileName: LPCWSTR, Reserved: DWORD): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryFullProcessImageNameA*(hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryFullProcessImageNameW*(hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessShutdownParameters*(lpdwLevel: LPDWORD, lpdwFlags: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FatalAppExitA*(uAction: UINT, lpMessageText: LPCSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FatalAppExitW*(uAction: UINT, lpMessageText: LPCWSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStartupInfoA*(lpStartupInfo: LPSTARTUPINFOA): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFirmwareEnvironmentVariableA*(lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFirmwareEnvironmentVariableW*(lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFirmwareEnvironmentVariableA*(lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFirmwareEnvironmentVariableW*(lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindResourceA*(hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindResourceW*(hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindResourceExA*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceTypesA*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceTypesW*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceNamesA*(hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumResourceNamesW*(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BeginUpdateResourceA*(pFileName: LPCSTR, bDeleteExistingResources: WINBOOL): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BeginUpdateResourceW*(pFileName: LPCWSTR, bDeleteExistingResources: WINBOOL): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UpdateResourceA*(hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UpdateResourceW*(hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EndUpdateResourceA*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EndUpdateResourceW*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFirmwareEnvironmentVariableExA*(lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFirmwareEnvironmentVariableExW*(lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFirmwareEnvironmentVariableExA*(lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFirmwareEnvironmentVariableExW*(lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFirmwareType*(FirmwareType: PFIRMWARE_TYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsNativeVhdBoot*(NativeVhdBoot: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalAddAtomA*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalAddAtomW*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalAddAtomExA*(lpString: LPCSTR, Flags: DWORD): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalAddAtomExW*(lpString: LPCWSTR, Flags: DWORD): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalFindAtomA*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalFindAtomW*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalGetAtomNameA*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GlobalGetAtomNameW*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddAtomA*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddAtomW*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindAtomA*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindAtomW*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetAtomNameA*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetAtomNameW*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileIntA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileIntW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileSectionA*(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProfileSectionW*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteProfileSectionA*(lpAppName: LPCSTR, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteProfileSectionW*(lpAppName: LPCWSTR, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileIntA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileIntW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileSectionA*(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileSectionW*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileSectionA*(lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileSectionW*(lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileSectionNamesA*(lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileSectionNamesW*(lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileStructA*(lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetPrivateProfileStructW*(lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileStructA*(lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WritePrivateProfileStructW*(lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTempPathA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTempFileNameA*(lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemWow64DirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemWow64DirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc Wow64EnableWow64FsRedirection*(Wow64FsEnableRedirection: BOOLEAN): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDllDirectoryA*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDllDirectoryW*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDllDirectoryA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDllDirectoryW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetSearchPathMode*(Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryExA*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryExW*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryTransactedA*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateDirectoryTransactedW*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveDirectoryTransactedA*(lpPathName: LPCSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveDirectoryTransactedW*(lpPathName: LPCWSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFullPathNameTransactedA*(lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFullPathNameTransactedW*(lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DefineDosDeviceA*(dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryDosDeviceA*(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileTransactedA*(lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateFileTransactedW*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReOpenFile*(hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlagsAndAttributes: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileAttributesTransactedA*(lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileAttributesTransactedW*(lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesTransactedA*(lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileAttributesTransactedW*(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCompressedFileSizeA*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCompressedFileSizeW*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCompressedFileSizeTransactedA*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCompressedFileSizeTransactedW*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteFileTransactedA*(lpFileName: LPCSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteFileTransactedW*(lpFileName: LPCWSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CheckNameLegalDOS8Dot3A*(lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CheckNameLegalDOS8Dot3W*(lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileExA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileExW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileTransactedA*(lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileTransactedW*(lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileTransactedA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFileTransactedW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyFile2*(pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: ptr COPYFILE2_EXTENDED_PARAMETERS): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileExA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileExW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileWithProgressA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileWithProgressW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileTransactedA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MoveFileTransactedW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReplaceFileA*(lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReplaceFileW*(lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateHardLinkA*(lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateHardLinkW*(lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateHardLinkTransactedA*(lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateHardLinkTransactedW*(lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstStreamW*(lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextStreamW*(hFindStream: HANDLE, lpFindStreamData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstStreamTransactedW*(lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileNameW*(lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextFileNameW*(hFindStream: HANDLE, StringLength: LPDWORD, LinkName: PWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstFileNameTransactedW*(lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeClientComputerNameA*(Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeClientProcessId*(Pipe: HANDLE, ClientProcessId: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeClientSessionId*(Pipe: HANDLE, ClientSessionId: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeServerProcessId*(Pipe: HANDLE, ServerProcessId: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeServerSessionId*(Pipe: HANDLE, ServerSessionId: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileBandwidthReservation*(hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: WINBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileBandwidthReservation*(hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateNamedPipeA*(lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeHandleStateA*(hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNamedPipeHandleStateW*(hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR, nMaxUserNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CallNamedPipeA*(lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CallNamedPipeW*(lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WaitNamedPipeA*(lpNamedPipeName: LPCSTR, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetVolumeLabelA*(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetVolumeLabelW*(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileApisToOEM*(): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetFileApisToANSI*(): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AreFileApisANSI*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumeInformationA*(lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ClearEventLogA*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ClearEventLogW*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BackupEventLogA*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BackupEventLogW*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CloseEventLog*(hEventLog: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DeregisterEventSource*(hEventLog: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc NotifyChangeEventLog*(hEventLog: HANDLE, hEvent: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetNumberOfEventLogRecords*(hEventLog: HANDLE, NumberOfRecords: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetOldestEventLogRecord*(hEventLog: HANDLE, OldestRecord: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenEventLogA*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenEventLogW*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterEventSourceA*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterEventSourceW*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenBackupEventLogA*(lpUNCServerName: LPCSTR, lpFileName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenBackupEventLogW*(lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReadEventLogA*(hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: ptr DWORD, pnMinNumberOfBytesNeeded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReadEventLogW*(hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: ptr DWORD, pnMinNumberOfBytesNeeded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReportEventA*(hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: ptr LPCSTR, lpRawData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReportEventW*(hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: ptr LPCWSTR, lpRawData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetNamedPipeClientComputerName*(Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetNamedPipeClientComputerNameA".} +proc GetEventLogInformation*(hEventLog: HANDLE, dwInfoLevel: DWORD, lpBuffer: LPVOID, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OperationStart*(OperationStartParams: ptr OPERATION_START_PARAMETERS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OperationEnd*(OperationEndParams: ptr OPERATION_END_PARAMETERS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckAndAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeAndAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeResultListAndAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AccessCheckByTypeResultListAndAuditAlarmByHandleA*(SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectOpenAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: WINBOOL, AccessGranted: WINBOOL, GenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectPrivilegeAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectCloseAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ObjectDeleteAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc PrivilegedServiceAuditAlarmA*(SubsystemName: LPCSTR, ServiceName: LPCSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetFileSecurityA*(lpFileName: LPCSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetFileSecurityA*(lpFileName: LPCSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ReadDirectoryChangesW*(hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadReadPtr*(lp: pointer, ucb: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadWritePtr*(lp: LPVOID, ucb: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadHugeReadPtr*(lp: pointer, ucb: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadHugeWritePtr*(lp: LPVOID, ucb: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadCodePtr*(lpfn: FARPROC): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadStringPtrA*(lpsz: LPCSTR, ucchMax: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsBadStringPtrW*(lpsz: LPCWSTR, ucchMax: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapViewOfFileExNuma*(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD): LPVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddConditionalAce*(pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AceType: UCHAR, AccessMask: DWORD, pSid: PSID, ConditionStr: PWCHAR, ReturnLength: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupAccountSidA*(lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupAccountSidW*(lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupAccountNameA*(lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupAccountNameW*(lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeValueA*(lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeValueW*(lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeNameA*(lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeNameW*(lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeDisplayNameA*(lpSystemName: LPCSTR, lpName: LPCSTR, lpDisplayName: LPSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LookupPrivilegeDisplayNameW*(lpSystemName: LPCWSTR, lpName: LPCWSTR, lpDisplayName: LPWSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BuildCommDCBA*(lpDef: LPCSTR, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BuildCommDCBW*(lpDef: LPCWSTR, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BuildCommDCBAndTimeoutsA*(lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BuildCommDCBAndTimeoutsW*(lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CommConfigDialogA*(lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CommConfigDialogW*(lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDefaultCommConfigA*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDefaultCommConfigW*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDefaultCommConfigA*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDefaultCommConfigW*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetComputerNameA*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetComputerNameW*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetComputerNameA*(lpComputerName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetComputerNameW*(lpComputerName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetComputerNameExA*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCTSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DnsHostnameToComputerNameA*(Hostname: LPCSTR, ComputerName: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DnsHostnameToComputerNameW*(Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserNameA*(lpBuffer: LPSTR, pcbBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetUserNameW*(lpBuffer: LPWSTR, pcbBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LogonUserA*(lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LogonUserW*(lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LogonUserExA*(lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: ptr PSID, ppProfileBuffer: ptr PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LogonUserExW*(lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: ptr PSID, ppProfileBuffer: ptr PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateProcessAsUserA*(hToken: HANDLE, lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateProcessWithLogonW*(lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateProcessWithTokenW*(hToken: HANDLE, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc IsTokenUntrusted*(TokenHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterWaitForSingleObject*(phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnregisterWait*(WaitHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc BindIoCompletionCallback*(FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetTimerQueueTimer*(TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: WINBOOL): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CancelTimerQueueTimer*(TimerQueue: HANDLE, Timer: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteTimerQueue*(TimerQueue: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreatePrivateNamespaceA*(lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenPrivateNamespaceA*(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateBoundaryDescriptorA*(Name: LPCSTR, Flags: ULONG): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddIntegrityLabelToBoundaryDescriptor*(BoundaryDescriptor: ptr HANDLE, IntegrityLabel: PSID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentHwProfileA*(lpHwProfileInfo: LPHW_PROFILE_INFOA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetCurrentHwProfileW*(lpHwProfileInfo: LPHW_PROFILE_INFOW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc VerifyVersionInfoA*(lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VerifyVersionInfoW*(lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SystemTimeToTzSpecificLocalTime*(lpTimeZoneInformation: ptr TIME_ZONE_INFORMATION, lpUniversalTime: ptr SYSTEMTIME, lpLocalTime: LPSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TzSpecificLocalTimeToSystemTime*(lpTimeZoneInformation: ptr TIME_ZONE_INFORMATION, lpLocalTime: ptr SYSTEMTIME, lpUniversalTime: LPSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FileTimeToSystemTime*(lpFileTime: ptr FILETIME, lpSystemTime: LPSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SystemTimeToFileTime*(lpSystemTime: ptr SYSTEMTIME, lpFileTime: LPFILETIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTimeZoneInformation*(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDynamicTimeZoneInformation*(pTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTimeZoneInformationForYear*(wYear: USHORT, pdtzi: PDYNAMIC_TIME_ZONE_INFORMATION, ptzi: LPTIME_ZONE_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDynamicTimeZoneInformation*(dwIndex: DWORD, lpTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetDynamicTimeZoneInformationEffectiveYears*(lpTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION, FirstYear: LPDWORD, LastYear: LPDWORD): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SystemTimeToTzSpecificLocalTimeEx*(lpTimeZoneInformation: ptr DYNAMIC_TIME_ZONE_INFORMATION, lpUniversalTime: ptr SYSTEMTIME, lpLocalTime: LPSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TzSpecificLocalTimeToSystemTimeEx*(lpTimeZoneInformation: ptr DYNAMIC_TIME_ZONE_INFORMATION, lpLocalTime: ptr SYSTEMTIME, lpUniversalTime: LPSYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetTimeZoneInformation*(lpTimeZoneInformation: ptr TIME_ZONE_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetDynamicTimeZoneInformation*(lpTimeZoneInformation: ptr DYNAMIC_TIME_ZONE_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemPowerStatus*(lpSystemPowerStatus: LPSYSTEM_POWER_STATUS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetSystemPowerState*(fSuspend: WINBOOL, fForce: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RegisterBadMemoryNotification*(Callback: PBAD_MEMORY_CALLBACK_ROUTINE): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnregisterBadMemoryNotification*(RegistrationHandle: PVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetMemoryErrorHandlingCapabilities*(Capabilities: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AllocateUserPhysicalPages*(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeUserPhysicalPages*(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapUserPhysicalPages*(VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MapUserPhysicalPagesScatter*(VirtualAddresses: ptr PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateJobObjectA*(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateJobObjectW*(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenJobObjectA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenJobObjectW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AssignProcessToJobObject*(hJob: HANDLE, hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc TerminateJobObject*(hJob: HANDLE, uExitCode: UINT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryInformationJobObject*(hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD, lpReturnLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetInformationJobObject*(hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateJobSet*(NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstVolumeA*(lpszVolumeName: LPSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextVolumeA*(hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstVolumeMountPointA*(lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindFirstVolumeMountPointW*(lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextVolumeMountPointA*(hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNextVolumeMountPointW*(hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindVolumeMountPointClose*(hFindVolumeMountPoint: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetVolumeMountPointA*(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetVolumeMountPointW*(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeleteVolumeMountPointA*(lpszVolumeMountPoint: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumeNameForVolumeMountPointA*(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumePathNameA*(lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetVolumePathNamesForVolumeNameA*(lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AllocateUserPhysicalPagesNuma*(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateActCtxA*(pActCtx: PCACTCTXA): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateActCtxW*(pActCtx: PCACTCTXW): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddRefActCtx*(hActCtx: HANDLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReleaseActCtx*(hActCtx: HANDLE): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ZombifyActCtx*(hActCtx: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ActivateActCtx*(hActCtx: HANDLE, lpCookie: ptr ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DeactivateActCtx*(dwFlags: DWORD, ulCookie: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentActCtx*(lphActCtx: ptr HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindActCtxSectionStringA*(dwFlags: DWORD, lpExtensionGuid: ptr GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindActCtxSectionStringW*(dwFlags: DWORD, lpExtensionGuid: ptr GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindActCtxSectionGuid*(dwFlags: DWORD, lpExtensionGuid: ptr GUID, ulSectionId: ULONG, lpGuidToFind: ptr GUID, ReturnedData: PACTCTX_SECTION_KEYED_DATA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryActCtxW*(dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: ptr SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WTSGetActiveConsoleSessionId*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaProcessorNode*(Processor: UCHAR, NodeNumber: PUCHAR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaNodeProcessorMask*(Node: UCHAR, ProcessorMask: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaAvailableMemoryNode*(Node: UCHAR, AvailableBytes: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaProximityNode*(ProximityId: ULONG, NodeNumber: PUCHAR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetActiveProcessorGroupCount*(): WORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetMaximumProcessorGroupCount*(): WORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetActiveProcessorCount*(GroupNumber: WORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetMaximumProcessorCount*(GroupNumber: WORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaNodeNumberFromHandle*(hFile: HANDLE, NodeNumber: PUSHORT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaProcessorNodeEx*(Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaAvailableMemoryNodeEx*(Node: USHORT, AvailableBytes: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumaProximityNodeEx*(ProximityId: ULONG, NodeNumber: PUSHORT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RegisterApplicationRecoveryCallback*(pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnregisterApplicationRecoveryCallback*(): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RegisterApplicationRestart*(pwzCommandline: PCWSTR, dwFlags: DWORD): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc UnregisterApplicationRestart*(): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetApplicationRecoveryCallback*(hProcess: HANDLE, pRecoveryCallback: ptr APPLICATION_RECOVERY_CALLBACK, ppvParameter: ptr PVOID, pdwPingInterval: PDWORD, pdwFlags: PDWORD): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetApplicationRestartSettings*(hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ApplicationRecoveryInProgress*(pbCancelled: PBOOL): HRESULT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ApplicationRecoveryFinished*(bSuccess: WINBOOL): VOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileInformationByHandleEx*(hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc OpenFileById*(hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSymbolicLinkA*(lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSymbolicLinkW*(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSymbolicLinkTransactedA*(lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateSymbolicLinkTransactedW*(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryActCtxSettingsW*(dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: ptr SIZE_T): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReplacePartitionUnit*(TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddSecureMemoryCacheCallback*(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RemoveSecureMemoryCacheCallback*(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CopyContext*(Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc InitializeContext*(Buffer: PVOID, ContextFlags: DWORD, Context: ptr PCONTEXT, ContextLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnableThreadProfiling*(ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: ptr HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc DisableThreadProfiling*(PerformanceDataHandle: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc QueryThreadProfiling*(ThreadHandle: HANDLE, Enabled: PBOOLEAN): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadThreadProfilingData*(PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentTime*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetTickCount".} +proc LockSegment*(hMem: HGLOBAL): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalFix".} +proc UnlockSegment*(hMem: HGLOBAL): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalUnfix".} +proc FreeModule*(hLibModule: HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FreeLibrary".} +proc InterlockedPushListSList*(ListHead: PSLIST_HEADER, List: PSLIST_ENTRY, ListEnd: PSLIST_ENTRY, Count: ULONG): PSLIST_ENTRY {.winapi, stdcall, dynlib: "kernel32", importc: "InterlockedPushListSListEx".} +template HasOverlappedIoCompleted*(lpOverlapped: LPOVERLAPPED): bool = lpOverlapped.Internal != STATUS_PENDING +template RtlSecureZeroMemory*(Destination: PVOID, Length: SIZE_T) = zeroMem(Destination, Length) +template SecureZeroMemory*(Destination: PVOID, Length: SIZE_T) = zeroMem(Destination, Length) +template RtlZeroMemory*(Destination: PVOID, Length: SIZE_T) = zeroMem(Destination, Length) +template ZeroMemory*(Destination: PVOID, Length: SIZE_T) = zeroMem(Destination, Length) +template RtlCopyMemory*(Destination: PVOID, Source: PVOID, Length: SIZE_T) = copyMem(Destination, Source, Length) +template CopyMemory*(Destination: PVOID, Source: PVOID, Length: SIZE_T) = copyMem(Destination, Source, Length) +template MAKEINTATOM*(i: untyped): untyped = cast[LPTSTR](i and 0xffff) +proc LocalDiscard*(h: HLOCAL): HLOCAL {.winapi, inline.} = LocalReAlloc(h, 0, LMEM_MOVEABLE) +proc GlobalDiscard*(h: HGLOBAL): HGLOBAL {.winapi, inline.} = GlobalReAlloc(h, 0, GMEM_MOVEABLE) +when winimAnsi: + proc LookupAccountName*(lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupAccountNameA".} +proc LookupAccountNameLocalA*(lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountNameA(nil, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse) +when winimUnicode: + proc LookupAccountName*(lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupAccountNameW".} +proc LookupAccountNameLocalW*(lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountNameW(nil, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse) +when winimAnsi: + proc LookupAccountSid*(lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupAccountSidA".} +proc LookupAccountSidLocalA*(Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountSidA(nil, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse) +when winimUnicode: + proc LookupAccountSid*(lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupAccountSidW".} +proc LookupAccountSidLocalW*(Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountSidW(nil, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse) +proc InterlockedOr*(Destination: ptr LONG, Value: LONG): LONG {.importc: "InterlockedOr", header: "".} +proc InterlockedOr8*(Destination: ptr byte, Value: byte): byte {.importc: "InterlockedOr8", header: "".} +proc InterlockedOr16*(Destination: ptr SHORT, Value: SHORT): SHORT {.importc: "InterlockedOr16", header: "".} +proc InterlockedOr64*(Destination: ptr LONGLONG, Value: LONGLONG): LONGLONG {.importc: "InterlockedOr64", header: "".} +proc InterlockedXor*(Destination: ptr LONG, Value: LONG): LONG {.importc: "InterlockedXor", header: "".} +proc InterlockedXor8*(Destination: ptr byte, Value: byte): byte {.importc: "InterlockedXor8", header: "".} +proc InterlockedXor16*(Destination: ptr SHORT, Value: SHORT): SHORT {.importc: "InterlockedXor16", header: "".} +proc InterlockedXor64*(Destination: ptr LONGLONG, Value: LONGLONG): LONGLONG {.importc: "InterlockedXor64", header: "".} +proc InterlockedAnd*(Destination: ptr LONG, Value: LONG): LONG {.importc: "InterlockedAnd", header: "".} +proc InterlockedAnd8*(Destination: ptr byte, Value: byte): byte {.importc: "InterlockedAnd8", header: "".} +proc InterlockedAnd16*(Destination: ptr SHORT, Value: SHORT): SHORT {.importc: "InterlockedAnd16", header: "".} +proc InterlockedAnd64*(Destination: ptr LONGLONG, Value: LONGLONG): LONGLONG {.importc: "InterlockedAnd64", header: "".} +proc InterlockedIncrement64*(Addend: ptr LONGLONG): LONGLONG {.importc: "InterlockedIncrement64", header: "".} +proc InterlockedDecrement64*(Addend: ptr LONGLONG): LONGLONG {.importc: "InterlockedDecrement64", header: "".} +proc InterlockedExchange64*(Target: ptr LONGLONG, Value: LONGLONG): LONGLONG {.importc: "InterlockedExchange64", header: "".} +proc InterlockedExchangeAdd64*(Addend: ptr LONGLONG, Value: LONGLONG): LONGLONG {.importc: "InterlockedExchangeAdd64", header: "".} +proc InterlockedCompareExchange64*(Destination: ptr LONGLONG, ExChange: LONGLONG, Comperand: LONGLONG): LONGLONG {.importc: "InterlockedCompareExchange64", header: "".} +proc InterlockedCompare64Exchange128*(Destination: ptr LONG64, ExchangeHigh: LONG64, ExchangeLow: LONG64, Comperand: LONG64): LONG64 {.importc: "InterlockedCompare64Exchange128", header: "".} +proc InterlockedIncrement*(Addend: ptr LONG): LONG {.importc: "InterlockedIncrement", header: "".} +proc InterlockedDecrement*(Addend: ptr LONG): LONG {.importc: "InterlockedDecrement", header: "".} +proc InterlockedExchange*(Target: ptr LONG, Value: LONG): LONG {.importc: "InterlockedExchange", header: "".} +proc InterlockedExchangeAdd*(Addend: ptr LONG, Value: LONG): LONG {.importc: "InterlockedExchangeAdd", header: "".} +proc InterlockedCompareExchange*(Destination: ptr LONG, ExChange: LONG, Comperand: LONG): LONG {.importc: "InterlockedCompareExchange", header: "".} +proc InterlockedExchangePointer*(Target: ptr PVOID, Value: PVOID): PVOID {.importc: "InterlockedExchangePointer", header: "".} +proc InterlockedCompareExchangePointer*(Destination: ptr PVOID, ExChange: PVOID, Comperand: PVOID): PVOID {.importc: "InterlockedCompareExchangePointer", header: "".} +proc `Offset=`*(self: var OVERLAPPED, x: DWORD) {.inline.} = self.union1.struct1.Offset = x +proc Offset*(self: OVERLAPPED): DWORD {.inline.} = self.union1.struct1.Offset +proc Offset*(self: var OVERLAPPED): var DWORD {.inline.} = self.union1.struct1.Offset +proc `OffsetHigh=`*(self: var OVERLAPPED, x: DWORD) {.inline.} = self.union1.struct1.OffsetHigh = x +proc OffsetHigh*(self: OVERLAPPED): DWORD {.inline.} = self.union1.struct1.OffsetHigh +proc OffsetHigh*(self: var OVERLAPPED): var DWORD {.inline.} = self.union1.struct1.OffsetHigh +proc `Pointer=`*(self: var OVERLAPPED, x: PVOID) {.inline.} = self.union1.Pointer = x +proc Pointer*(self: OVERLAPPED): PVOID {.inline.} = self.union1.Pointer +proc Pointer*(self: var OVERLAPPED): var PVOID {.inline.} = self.union1.Pointer +proc `Block=`*(self: var PROCESS_HEAP_ENTRY, x: PROCESS_HEAP_ENTRY_UNION1_Block) {.inline.} = self.union1.Block = x +proc Block*(self: PROCESS_HEAP_ENTRY): PROCESS_HEAP_ENTRY_UNION1_Block {.inline.} = self.union1.Block +proc Block*(self: var PROCESS_HEAP_ENTRY): var PROCESS_HEAP_ENTRY_UNION1_Block {.inline.} = self.union1.Block +proc `Region=`*(self: var PROCESS_HEAP_ENTRY, x: PROCESS_HEAP_ENTRY_UNION1_Region) {.inline.} = self.union1.Region = x +proc Region*(self: PROCESS_HEAP_ENTRY): PROCESS_HEAP_ENTRY_UNION1_Region {.inline.} = self.union1.Region +proc Region*(self: var PROCESS_HEAP_ENTRY): var PROCESS_HEAP_ENTRY_UNION1_Region {.inline.} = self.union1.Region +proc `dwOemId=`*(self: var SYSTEM_INFO, x: DWORD) {.inline.} = self.union1.dwOemId = x +proc dwOemId*(self: SYSTEM_INFO): DWORD {.inline.} = self.union1.dwOemId +proc dwOemId*(self: var SYSTEM_INFO): var DWORD {.inline.} = self.union1.dwOemId +proc `wProcessorArchitecture=`*(self: var SYSTEM_INFO, x: WORD) {.inline.} = self.union1.struct1.wProcessorArchitecture = x +proc wProcessorArchitecture*(self: SYSTEM_INFO): WORD {.inline.} = self.union1.struct1.wProcessorArchitecture +proc wProcessorArchitecture*(self: var SYSTEM_INFO): var WORD {.inline.} = self.union1.struct1.wProcessorArchitecture +proc `wReserved=`*(self: var SYSTEM_INFO, x: WORD) {.inline.} = self.union1.struct1.wReserved = x +proc wReserved*(self: SYSTEM_INFO): WORD {.inline.} = self.union1.struct1.wReserved +proc wReserved*(self: var SYSTEM_INFO): var WORD {.inline.} = self.union1.struct1.wReserved +proc `FileId=`*(self: var FILE_ID_DESCRIPTOR, x: LARGE_INTEGER) {.inline.} = self.union1.FileId = x +proc FileId*(self: FILE_ID_DESCRIPTOR): LARGE_INTEGER {.inline.} = self.union1.FileId +proc FileId*(self: var FILE_ID_DESCRIPTOR): var LARGE_INTEGER {.inline.} = self.union1.FileId +proc `ObjectId=`*(self: var FILE_ID_DESCRIPTOR, x: GUID) {.inline.} = self.union1.ObjectId = x +proc objectId*(self: FILE_ID_DESCRIPTOR): GUID {.inline.} = self.union1.ObjectId +proc objectId*(self: var FILE_ID_DESCRIPTOR): var GUID {.inline.} = self.union1.ObjectId +proc `ExtendedFileId=`*(self: var FILE_ID_DESCRIPTOR, x: FILE_ID_128) {.inline.} = self.union1.ExtendedFileId = x +proc ExtendedFileId*(self: FILE_ID_DESCRIPTOR): FILE_ID_128 {.inline.} = self.union1.ExtendedFileId +proc ExtendedFileId*(self: var FILE_ID_DESCRIPTOR): var FILE_ID_128 {.inline.} = self.union1.ExtendedFileId +when winimUnicode: + type + WIN32_FIND_DATA* = WIN32_FIND_DATAW + PWIN32_FIND_DATA* = PWIN32_FIND_DATAW + LPWIN32_FIND_DATA* = LPWIN32_FIND_DATAW + ENUMRESLANGPROC* = ENUMRESLANGPROCW + ENUMRESNAMEPROC* = ENUMRESNAMEPROCW + ENUMRESTYPEPROC* = ENUMRESTYPEPROCW + PGET_MODULE_HANDLE_EX* = PGET_MODULE_HANDLE_EXW + STARTUPINFO* = STARTUPINFOW + LPSTARTUPINFO* = LPSTARTUPINFOW + STARTUPINFOEX* = STARTUPINFOEXW + LPSTARTUPINFOEX* = LPSTARTUPINFOEXW + HW_PROFILE_INFO* = HW_PROFILE_INFOW + LPHW_PROFILE_INFO* = LPHW_PROFILE_INFOW + ACTCTX* = ACTCTXW + PACTCTX* = PACTCTXW + PCACTCTX* = PCACTCTXW + const + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_A* = GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_W* = GET_SYSTEM_WOW64_DIRECTORY_NAME_W_W + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_T* = GET_SYSTEM_WOW64_DIRECTORY_NAME_W_T + proc DefineDosDevice*(dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DefineDosDeviceW".} + proc DeleteVolumeMountPoint*(lpszVolumeMountPoint: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteVolumeMountPointW".} + proc FindFirstVolume*(lpszVolumeName: LPWSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstVolumeW".} + proc FindNextVolume*(hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextVolumeW".} + proc GetLogicalDriveStrings*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLogicalDriveStringsW".} + proc GetShortPathName*(lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetShortPathNameW".} + proc GetTempFileName*(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetTempFileNameW".} + proc GetVolumeInformation*(lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumeInformationW".} + proc GetVolumePathName*(lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumePathNameW".} + proc QueryDosDevice*(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "QueryDosDeviceW".} + proc GetVolumeNameForVolumeMountPoint*(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumeNameForVolumeMountPointW".} + proc GetVolumePathNamesForVolumeName*(lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumePathNamesForVolumeNameW".} + proc GetTempPath*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetTempPathW".} + proc FindResourceEx*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc: "FindResourceExW".} + proc CreateFileMapping*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileMappingW".} + proc OpenFileMapping*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenFileMappingW".} + proc CreateFileMappingNuma*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileMappingNumaW".} + proc CreateNamedPipe*(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateNamedPipeW".} + proc WaitNamedPipe*(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WaitNamedPipeW".} + proc GetNamedPipeClientComputerName*(Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetNamedPipeClientComputerNameW".} + proc CreatePrivateNamespace*(lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreatePrivateNamespaceW".} + proc CreateBoundaryDescriptor*(Name: LPCWSTR, Flags: ULONG): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateBoundaryDescriptorW".} + proc GetEnvironmentStrings*(): LPWCH {.winapi, stdcall, dynlib: "kernel32", importc: "GetEnvironmentStringsW".} + proc SetEnvironmentStrings*(NewEnvironment: LPWCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetEnvironmentStringsW".} + proc GetStartupInfo*(lpStartupInfo: LPSTARTUPINFOW): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "GetStartupInfoW".} + proc CreateProcessAsUser*(hToken: HANDLE, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserW".} + proc AccessCheckAndAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmW".} + proc AccessCheckByTypeAndAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeAndAuditAlarmW".} + proc AccessCheckByTypeResultListAndAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeResultListAndAuditAlarmW".} + proc AccessCheckByTypeResultListAndAuditAlarmByHandle*(SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeResultListAndAuditAlarmByHandleW".} + proc GetFileSecurity*(lpFileName: LPCWSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetFileSecurityW".} + proc ObjectCloseAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectCloseAuditAlarmW".} + proc ObjectDeleteAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectDeleteAuditAlarmW".} + proc ObjectOpenAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: WINBOOL, AccessGranted: WINBOOL, GenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectOpenAuditAlarmW".} + proc ObjectPrivilegeAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmW".} + proc PrivilegedServiceAuditAlarm*(SubsystemName: LPCWSTR, ServiceName: LPCWSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmW".} + proc SetFileSecurity*(lpFileName: LPCWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "SetFileSecurityW".} + proc CreateSemaphoreEx*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSemaphoreExW".} + proc OpenMutex*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenMutexW".} + proc OpenSemaphore*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenSemaphoreW".} + proc CreateWaitableTimerEx*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateWaitableTimerExW".} + proc OpenWaitableTimer*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpTimerName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenWaitableTimerW".} + proc SetComputerNameEx*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetComputerNameExW".} + proc OutputDebugString*(lpOutputString: LPCWSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "OutputDebugStringW".} + proc CreateFile*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileW".} + proc FindFirstChangeNotification*(lpPathName: LPCWSTR, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstChangeNotificationW".} + proc FindFirstFile*(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileW".} + proc GetDiskFreeSpace*(lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceW".} + proc GetDriveType*(lpRootPathName: LPCWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetDriveTypeW".} + proc GetFileAttributes*(lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesW".} + proc GetFullPathName*(lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFullPathNameW".} + proc GetLongPathName*(lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLongPathNameW".} + proc GetFinalPathNameByHandle*(hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFinalPathNameByHandleW".} + proc CreateDirectory*(lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryW".} + proc DeleteFile*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteFileW".} + proc FindFirstFileEx*(lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileExW".} + proc FindNextFile*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextFileW".} + proc GetDiskFreeSpaceEx*(lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExW".} + proc GetFileAttributesEx*(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesExW".} + proc RemoveDirectory*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "RemoveDirectoryW".} + proc SetFileAttributes*(lpFileName: LPCWSTR, dwFileAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileAttributesW".} + proc GetModuleHandleEx*(dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: ptr HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleHandleExW".} + proc LoadString*(hInstance: HINSTANCE, uID: UINT, lpBuffer: LPWSTR, cchBufferMax: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "LoadStringW".} + proc GetModuleFileName*(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleFileNameW".} + proc GetModuleHandle*(lpModuleName: LPCWSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleHandleW".} + proc LoadLibraryEx*(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "LoadLibraryExW".} + proc EnumResourceLanguages*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesW".} + proc EnumResourceLanguagesEx*(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesExW".} + proc EnumResourceNamesEx*(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceNamesExW".} + proc EnumResourceTypesEx*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceTypesExW".} + proc ExpandEnvironmentStrings*(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "ExpandEnvironmentStringsW".} + proc FreeEnvironmentStrings*(penv: LPWCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FreeEnvironmentStringsW".} + proc GetCommandLine*(): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc: "GetCommandLineW".} + proc GetCurrentDirectory*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryW".} + proc GetEnvironmentVariable*(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetEnvironmentVariableW".} + proc NeedCurrentDirectoryForExePath*(ExeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "NeedCurrentDirectoryForExePathW".} + proc SearchPath*(lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "SearchPathW".} + proc SetCurrentDirectory*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetCurrentDirectoryW".} + proc SetEnvironmentVariable*(lpName: LPCWSTR, lpValue: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableW".} + proc CreateProcess*(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateProcessW".} + proc CreateMutexEx*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMutexExW".} + proc CreateEventEx*(lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateEventExW".} + proc OpenEvent*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenEventW".} + proc CreateMutex*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMutexW".} + proc CreateEvent*(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, bInitialState: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateEventW".} + proc GetSystemDirectory*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemDirectoryW".} + proc GetWindowsDirectory*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetWindowsDirectoryW".} + proc GetSystemWindowsDirectory*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemWindowsDirectoryW".} + proc GetComputerNameEx*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetComputerNameExW".} + proc GetVersionEx*(lpVersionInformation: LPOSVERSIONINFOW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVersionExW".} + proc GetBinaryType*(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetBinaryTypeW".} + proc GetLongPathNameTransacted*(lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLongPathNameTransactedW".} + proc SetFileShortName*(hFile: HANDLE, lpShortName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileShortNameW".} + proc FormatMessage*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ptr va_list): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "FormatMessageW".} + proc CreateMailslot*(lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMailslotW".} + proc EncryptFile*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EncryptFileW".} + proc DecryptFile*(lpFileName: LPCWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "DecryptFileW".} + proc FileEncryptionStatus*(lpFileName: LPCWSTR, lpStatus: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "FileEncryptionStatusW".} + proc OpenEncryptedFileRaw*(lpFileName: LPCWSTR, ulFlags: ULONG, pvContext: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "OpenEncryptedFileRawW".} + proc lstrcmp*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcmpW".} + proc lstrcmpi*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcmpiW".} + proc lstrcpyn*(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int32): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcpynW".} + proc lstrcpy*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcpyW".} + proc lstrcat*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcatW".} + proc lstrlen*(lpString: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrlenW".} + proc CreateSemaphore*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSemaphoreW".} + proc CreateWaitableTimer*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, lpTimerName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateWaitableTimerW".} + proc LoadLibrary*(lpLibFileName: LPCWSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "LoadLibraryW".} + proc QueryFullProcessImageName*(hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "QueryFullProcessImageNameW".} + proc FatalAppExit*(uAction: UINT, lpMessageText: LPCWSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "FatalAppExitW".} + proc GetFirmwareEnvironmentVariable*(lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFirmwareEnvironmentVariableW".} + proc SetFirmwareEnvironmentVariable*(lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFirmwareEnvironmentVariableW".} + proc FindResource*(hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc: "FindResourceW".} + proc EnumResourceTypes*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceTypesW".} + proc EnumResourceNames*(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceNamesW".} + proc BeginUpdateResource*(pFileName: LPCWSTR, bDeleteExistingResources: WINBOOL): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "BeginUpdateResourceW".} + proc UpdateResource*(hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "UpdateResourceW".} + proc EndUpdateResource*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EndUpdateResourceW".} + proc GlobalAddAtom*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalAddAtomW".} + proc GlobalAddAtomEx*(lpString: LPCWSTR, Flags: DWORD): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalAddAtomExW".} + proc GlobalFindAtom*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalFindAtomW".} + proc GlobalGetAtomName*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameW".} + proc AddAtom*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "AddAtomW".} + proc FindAtom*(lpString: LPCWSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "FindAtomW".} + proc GetAtomName*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetAtomNameW".} + proc GetProfileInt*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileIntW".} + proc GetProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileStringW".} + proc WriteProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteProfileStringW".} + proc GetProfileSection*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileSectionW".} + proc WriteProfileSection*(lpAppName: LPCWSTR, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteProfileSectionW".} + proc GetPrivateProfileInt*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileIntW".} + proc GetPrivateProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringW".} + proc WritePrivateProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringW".} + proc GetPrivateProfileSection*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionW".} + proc WritePrivateProfileSection*(lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileSectionW".} + proc GetPrivateProfileSectionNames*(lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionNamesW".} + proc GetPrivateProfileStruct*(lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStructW".} + proc WritePrivateProfileStruct*(lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStructW".} + proc GetFirmwareEnvironmentVariableEx*(lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFirmwareEnvironmentVariableExW".} + proc SetFirmwareEnvironmentVariableEx*(lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFirmwareEnvironmentVariableExW".} + proc GetSystemWow64Directory*(lpBuffer: LPWSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemWow64DirectoryW".} + proc SetDllDirectory*(lpPathName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetDllDirectoryW".} + proc GetDllDirectory*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetDllDirectoryW".} + proc CreateDirectoryEx*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryExW".} + proc CreateDirectoryTransacted*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryTransactedW".} + proc RemoveDirectoryTransacted*(lpPathName: LPCWSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "RemoveDirectoryTransactedW".} + proc GetFullPathNameTransacted*(lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: ptr LPWSTR, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFullPathNameTransactedW".} + proc CreateFileTransacted*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileTransactedW".} + proc SetFileAttributesTransacted*(lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileAttributesTransactedW".} + proc GetFileAttributesTransacted*(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesTransactedW".} + proc GetCompressedFileSize*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeW".} + proc DeleteFileTransacted*(lpFileName: LPCWSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteFileTransactedW".} + proc GetCompressedFileSizeTransacted*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeTransactedW".} + proc FindFirstFileTransacted*(lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileTransactedW".} + proc CopyFileTransacted*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileTransactedW".} + proc CheckNameLegalDOS8Dot3*(lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CheckNameLegalDOS8Dot3W".} + proc CopyFile*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileW".} + proc CopyFileEx*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileExW".} + proc MoveFile*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileW".} + proc MoveFileEx*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileExW".} + proc MoveFileWithProgress*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileWithProgressW".} + proc MoveFileTransacted*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileTransactedW".} + proc ReplaceFile*(lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReplaceFileW".} + proc CreateHardLink*(lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateHardLinkW".} + proc CreateHardLinkTransacted*(lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateHardLinkTransactedW".} + proc GetNamedPipeHandleState*(hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR, nMaxUserNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetNamedPipeHandleStateW".} + proc CallNamedPipe*(lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CallNamedPipeW".} + proc SetVolumeLabel*(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetVolumeLabelW".} + proc ClearEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ClearEventLogW".} + proc BackupEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "BackupEventLogW".} + proc OpenEventLog*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenEventLogW".} + proc RegisterEventSource*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterEventSourceW".} + proc OpenBackupEventLog*(lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogW".} + proc ReadEventLog*(hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: ptr DWORD, pnMinNumberOfBytesNeeded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ReadEventLogW".} + proc ReportEvent*(hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: ptr LPCWSTR, lpRawData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ReportEventW".} + proc IsBadStringPtr*(lpsz: LPCWSTR, ucchMax: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "IsBadStringPtrW".} + proc LookupPrivilegeValue*(lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeValueW".} + proc LookupPrivilegeName*(lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeNameW".} + proc LookupPrivilegeDisplayName*(lpSystemName: LPCWSTR, lpName: LPCWSTR, lpDisplayName: LPWSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameW".} + proc BuildCommDCB*(lpDef: LPCWSTR, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "BuildCommDCBW".} + proc BuildCommDCBAndTimeouts*(lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsW".} + proc CommConfigDialog*(lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CommConfigDialogW".} + proc GetDefaultCommConfig*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDefaultCommConfigW".} + proc SetDefaultCommConfig*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetDefaultCommConfigW".} + proc GetComputerName*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetComputerNameW".} + proc SetComputerName*(lpComputerName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetComputerNameW".} + proc DnsHostnameToComputerName*(Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DnsHostnameToComputerNameW".} + proc GetUserName*(lpBuffer: LPWSTR, pcbBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetUserNameW".} + proc LogonUser*(lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LogonUserW".} + proc LogonUserEx*(lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: ptr PSID, ppProfileBuffer: ptr PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LogonUserExW".} + proc OpenPrivateNamespace*(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenPrivateNamespaceW".} + proc GetCurrentHwProfile*(lpHwProfileInfo: LPHW_PROFILE_INFOW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetCurrentHwProfileW".} + proc VerifyVersionInfo*(lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "VerifyVersionInfoW".} + proc CreateJobObject*(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateJobObjectW".} + proc OpenJobObject*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenJobObjectW".} + proc FindFirstVolumeMountPoint*(lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstVolumeMountPointW".} + proc FindNextVolumeMountPoint*(hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextVolumeMountPointW".} + proc SetVolumeMountPoint*(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetVolumeMountPointW".} + proc CreateActCtx*(pActCtx: PCACTCTXW): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateActCtxW".} + proc FindActCtxSectionString*(dwFlags: DWORD, lpExtensionGuid: ptr GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindActCtxSectionStringW".} + proc CreateSymbolicLink*(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSymbolicLinkW".} + proc CreateSymbolicLinkTransacted*(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSymbolicLinkTransactedW".} + proc LookupAccountNameLocal*(lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountNameW(nil, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse) + proc LookupAccountSidLocal*(Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountSidW(nil, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse) +when winimAnsi: + type + WIN32_FIND_DATA* = WIN32_FIND_DATAA + PWIN32_FIND_DATA* = PWIN32_FIND_DATAA + LPWIN32_FIND_DATA* = LPWIN32_FIND_DATAA + ENUMRESLANGPROC* = ENUMRESLANGPROCA + ENUMRESNAMEPROC* = ENUMRESNAMEPROCA + ENUMRESTYPEPROC* = ENUMRESTYPEPROCA + PGET_MODULE_HANDLE_EX* = PGET_MODULE_HANDLE_EXA + STARTUPINFO* = STARTUPINFOA + LPSTARTUPINFO* = LPSTARTUPINFOA + STARTUPINFOEX* = STARTUPINFOEXA + LPSTARTUPINFOEX* = LPSTARTUPINFOEXA + HW_PROFILE_INFO* = HW_PROFILE_INFOA + LPHW_PROFILE_INFO* = LPHW_PROFILE_INFOA + ACTCTX* = ACTCTXA + PACTCTX* = PACTCTXA + PCACTCTX* = PCACTCTXA + const + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_A* = GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_W* = GET_SYSTEM_WOW64_DIRECTORY_NAME_A_W + GET_SYSTEM_WOW64_DIRECTORY_NAME_T_T* = GET_SYSTEM_WOW64_DIRECTORY_NAME_A_T + proc GetEnvironmentStrings*(): LPCH {.winapi, stdcall, dynlib: "kernel32", importc.} + proc SetEnvironmentStrings*(NewEnvironment: LPCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetEnvironmentStringsA".} + proc GetShortPathName*(lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetShortPathNameA".} + proc OpenMutex*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenMutexA".} + proc OpenSemaphore*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenSemaphoreA".} + proc OpenWaitableTimer*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpTimerName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenWaitableTimerA".} + proc CreateFileMapping*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileMappingA".} + proc OpenFileMapping*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenFileMappingA".} + proc GetLogicalDriveStrings*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLogicalDriveStringsA".} + proc CreateSemaphoreEx*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSemaphoreExA".} + proc CreateWaitableTimerEx*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateWaitableTimerExA".} + proc CreateFileMappingNuma*(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileMappingNumaA".} + proc GetStartupInfo*(lpStartupInfo: LPSTARTUPINFOA): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "GetStartupInfoA".} + proc FindResourceEx*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc: "FindResourceExA".} + proc GetTempPath*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetTempPathA".} + proc GetTempFileName*(lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetTempFileNameA".} + proc DefineDosDevice*(dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DefineDosDeviceA".} + proc QueryDosDevice*(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "QueryDosDeviceA".} + proc CreateNamedPipe*(lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateNamedPipeA".} + proc WaitNamedPipe*(lpNamedPipeName: LPCSTR, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WaitNamedPipeA".} + proc GetVolumeInformation*(lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumeInformationA".} + proc AccessCheckAndAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmA".} + proc AccessCheckByTypeAndAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeAndAuditAlarmA".} + proc AccessCheckByTypeResultListAndAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeResultListAndAuditAlarmA".} + proc AccessCheckByTypeResultListAndAuditAlarmByHandle*(SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: WINBOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AccessCheckByTypeResultListAndAuditAlarmByHandleA".} + proc ObjectOpenAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: WINBOOL, AccessGranted: WINBOOL, GenerateOnClose: LPBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectOpenAuditAlarmA".} + proc ObjectPrivilegeAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmA".} + proc ObjectCloseAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectCloseAuditAlarmA".} + proc ObjectDeleteAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ObjectDeleteAuditAlarmA".} + proc PrivilegedServiceAuditAlarm*(SubsystemName: LPCSTR, ServiceName: LPCSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmA".} + proc SetFileSecurity*(lpFileName: LPCSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "SetFileSecurityA".} + proc GetFileSecurity*(lpFileName: LPCSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetFileSecurityA".} + proc SetComputerNameEx*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCTSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetComputerNameExA".} + proc CreateProcessAsUser*(hToken: HANDLE, lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserA".} + proc FindFirstVolume*(lpszVolumeName: LPSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstVolumeA".} + proc FindNextVolume*(hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextVolumeA".} + proc DeleteVolumeMountPoint*(lpszVolumeMountPoint: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteVolumeMountPointA".} + proc GetVolumeNameForVolumeMountPoint*(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumeNameForVolumeMountPointA".} + proc GetVolumePathName*(lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumePathNameA".} + proc GetVolumePathNamesForVolumeName*(lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVolumePathNamesForVolumeNameA".} + proc OutputDebugString*(lpOutputString: LPCSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "OutputDebugStringA".} + proc CreateFile*(lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileA".} + proc FindFirstChangeNotification*(lpPathName: LPCSTR, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstChangeNotificationA".} + proc FindFirstFile*(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileA".} + proc GetDiskFreeSpace*(lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceA".} + proc GetDriveType*(lpRootPathName: LPCSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetDriveTypeA".} + proc GetFileAttributes*(lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesA".} + proc GetFullPathName*(lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFullPathNameA".} + proc GetLongPathName*(lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLongPathNameA".} + proc GetFinalPathNameByHandle*(hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFinalPathNameByHandleA".} + proc CreateDirectory*(lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryA".} + proc DeleteFile*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteFileA".} + proc FindFirstFileEx*(lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileExA".} + proc FindNextFile*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextFileA".} + proc GetDiskFreeSpaceEx*(lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExA".} + proc GetFileAttributesEx*(lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesExA".} + proc RemoveDirectory*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "RemoveDirectoryA".} + proc SetFileAttributes*(lpFileName: LPCSTR, dwFileAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileAttributesA".} + proc GetModuleHandleEx*(dwFlags: DWORD, lpModuleName: LPCSTR, phModule: ptr HMODULE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleHandleExA".} + proc LoadString*(hInstance: HINSTANCE, uID: UINT, lpBuffer: LPSTR, cchBufferMax: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "LoadStringA".} + proc GetModuleFileName*(hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleFileNameA".} + proc GetModuleHandle*(lpModuleName: LPCSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "GetModuleHandleA".} + proc LoadLibraryEx*(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "LoadLibraryExA".} + proc EnumResourceLanguages*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesA".} + proc EnumResourceLanguagesEx*(hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesExA".} + proc EnumResourceNamesEx*(hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceNamesExA".} + proc EnumResourceTypesEx*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceTypesExA".} + proc ExpandEnvironmentStrings*(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "ExpandEnvironmentStringsA".} + proc FreeEnvironmentStrings*(penv: LPCH): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FreeEnvironmentStringsA".} + proc GetCommandLine*(): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc: "GetCommandLineA".} + proc GetCurrentDirectory*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryA".} + proc GetEnvironmentVariable*(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetEnvironmentVariableA".} + proc NeedCurrentDirectoryForExePath*(ExeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "NeedCurrentDirectoryForExePathA".} + proc SearchPath*(lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "SearchPathA".} + proc SetCurrentDirectory*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetCurrentDirectoryA".} + proc SetEnvironmentVariable*(lpName: LPCSTR, lpValue: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableA".} + proc CreateProcess*(lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: WINBOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateProcessA".} + proc CreateMutexEx*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMutexExA".} + proc CreateEventEx*(lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateEventExA".} + proc OpenEvent*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenEventA".} + proc CreateMutex*(lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMutexA".} + proc CreateEvent*(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, bInitialState: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateEventA".} + proc GetSystemDirectory*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemDirectoryA".} + proc GetWindowsDirectory*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetWindowsDirectoryA".} + proc GetSystemWindowsDirectory*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemWindowsDirectoryA".} + proc GetComputerNameEx*(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetComputerNameExA".} + proc GetVersionEx*(lpVersionInformation: LPOSVERSIONINFOA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetVersionExA".} + proc GetBinaryType*(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetBinaryTypeA".} + proc GetLongPathNameTransacted*(lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetLongPathNameTransactedA".} + proc SetFileShortName*(hFile: HANDLE, lpShortName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileShortNameA".} + proc FormatMessage*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: ptr va_list): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "FormatMessageA".} + proc CreateMailslot*(lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateMailslotA".} + proc EncryptFile*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EncryptFileA".} + proc DecryptFile*(lpFileName: LPCSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "DecryptFileA".} + proc FileEncryptionStatus*(lpFileName: LPCSTR, lpStatus: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "FileEncryptionStatusA".} + proc OpenEncryptedFileRaw*(lpFileName: LPCSTR, ulFlags: ULONG, pvContext: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "OpenEncryptedFileRawA".} + proc lstrcmp*(lpString1: LPCSTR, lpString2: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcmpA".} + proc lstrcmpi*(lpString1: LPCSTR, lpString2: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcmpiA".} + proc lstrcpyn*(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int32): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcpynA".} + proc lstrcpy*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcpyA".} + proc lstrcat*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "kernel32", importc: "lstrcatA".} + proc lstrlen*(lpString: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "lstrlenA".} + proc CreateSemaphore*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSemaphoreA".} + proc CreateWaitableTimer*(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: WINBOOL, lpTimerName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateWaitableTimerA".} + proc LoadLibrary*(lpLibFileName: LPCSTR): HMODULE {.winapi, stdcall, dynlib: "kernel32", importc: "LoadLibraryA".} + proc QueryFullProcessImageName*(hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "QueryFullProcessImageNameA".} + proc FatalAppExit*(uAction: UINT, lpMessageText: LPCSTR): VOID {.winapi, stdcall, dynlib: "kernel32", importc: "FatalAppExitA".} + proc GetFirmwareEnvironmentVariable*(lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFirmwareEnvironmentVariableA".} + proc SetFirmwareEnvironmentVariable*(lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFirmwareEnvironmentVariableA".} + proc FindResource*(hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR): HRSRC {.winapi, stdcall, dynlib: "kernel32", importc: "FindResourceA".} + proc EnumResourceTypes*(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceTypesA".} + proc EnumResourceNames*(hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumResourceNamesA".} + proc BeginUpdateResource*(pFileName: LPCSTR, bDeleteExistingResources: WINBOOL): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "BeginUpdateResourceA".} + proc UpdateResource*(hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "UpdateResourceA".} + proc EndUpdateResource*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EndUpdateResourceA".} + proc GlobalAddAtom*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalAddAtomA".} + proc GlobalAddAtomEx*(lpString: LPCSTR, Flags: DWORD): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalAddAtomExA".} + proc GlobalFindAtom*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalFindAtomA".} + proc GlobalGetAtomName*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameA".} + proc AddAtom*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "AddAtomA".} + proc FindAtom*(lpString: LPCSTR): ATOM {.winapi, stdcall, dynlib: "kernel32", importc: "FindAtomA".} + proc GetAtomName*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetAtomNameA".} + proc GetProfileInt*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileIntA".} + proc GetProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileStringA".} + proc WriteProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteProfileStringA".} + proc GetProfileSection*(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetProfileSectionA".} + proc WriteProfileSection*(lpAppName: LPCSTR, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteProfileSectionA".} + proc GetPrivateProfileInt*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileIntA".} + proc GetPrivateProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringA".} + proc WritePrivateProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringA".} + proc GetPrivateProfileSection*(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionA".} + proc WritePrivateProfileSection*(lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileSectionA".} + proc GetPrivateProfileSectionNames*(lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionNamesA".} + proc GetPrivateProfileStruct*(lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStructA".} + proc WritePrivateProfileStruct*(lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStructA".} + proc GetFirmwareEnvironmentVariableEx*(lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFirmwareEnvironmentVariableExA".} + proc SetFirmwareEnvironmentVariableEx*(lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFirmwareEnvironmentVariableExA".} + proc GetSystemWow64Directory*(lpBuffer: LPSTR, uSize: UINT): UINT {.winapi, stdcall, dynlib: "kernel32", importc: "GetSystemWow64DirectoryA".} + proc SetDllDirectory*(lpPathName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetDllDirectoryA".} + proc GetDllDirectory*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetDllDirectoryA".} + proc CreateDirectoryEx*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryExA".} + proc CreateDirectoryTransacted*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateDirectoryTransactedA".} + proc RemoveDirectoryTransacted*(lpPathName: LPCSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "RemoveDirectoryTransactedA".} + proc GetFullPathNameTransacted*(lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: ptr LPSTR, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetFullPathNameTransactedA".} + proc CreateFileTransacted*(lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateFileTransactedA".} + proc SetFileAttributesTransacted*(lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetFileAttributesTransactedA".} + proc GetFileAttributesTransacted*(lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetFileAttributesTransactedA".} + proc GetCompressedFileSize*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeA".} + proc DeleteFileTransacted*(lpFileName: LPCSTR, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DeleteFileTransactedA".} + proc GetCompressedFileSizeTransacted*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeTransactedA".} + proc FindFirstFileTransacted*(lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstFileTransactedA".} + proc CopyFileTransacted*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileTransactedA".} + proc CheckNameLegalDOS8Dot3*(lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CheckNameLegalDOS8Dot3A".} + proc CopyFile*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileA".} + proc CopyFileEx*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CopyFileExA".} + proc MoveFile*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileA".} + proc MoveFileEx*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileExA".} + proc MoveFileWithProgress*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileWithProgressA".} + proc MoveFileTransacted*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "MoveFileTransactedA".} + proc ReplaceFile*(lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReplaceFileA".} + proc CreateHardLink*(lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateHardLinkA".} + proc CreateHardLinkTransacted*(lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CreateHardLinkTransactedA".} + proc GetNamedPipeHandleState*(hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetNamedPipeHandleStateA".} + proc CallNamedPipe*(lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CallNamedPipeA".} + proc SetVolumeLabel*(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetVolumeLabelA".} + proc ClearEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ClearEventLogA".} + proc BackupEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "BackupEventLogA".} + proc OpenEventLog*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenEventLogA".} + proc RegisterEventSource*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterEventSourceA".} + proc OpenBackupEventLog*(lpUNCServerName: LPCSTR, lpFileName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogA".} + proc ReadEventLog*(hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: ptr DWORD, pnMinNumberOfBytesNeeded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ReadEventLogA".} + proc ReportEvent*(hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: ptr LPCSTR, lpRawData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ReportEventA".} + proc IsBadStringPtr*(lpsz: LPCSTR, ucchMax: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "IsBadStringPtrA".} + proc LookupPrivilegeValue*(lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeValueA".} + proc LookupPrivilegeName*(lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeNameA".} + proc LookupPrivilegeDisplayName*(lpSystemName: LPCSTR, lpName: LPCSTR, lpDisplayName: LPSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameA".} + proc BuildCommDCB*(lpDef: LPCSTR, lpDCB: LPDCB): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "BuildCommDCBA".} + proc BuildCommDCBAndTimeouts*(lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsA".} + proc CommConfigDialog*(lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "CommConfigDialogA".} + proc GetDefaultCommConfig*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetDefaultCommConfigA".} + proc SetDefaultCommConfig*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetDefaultCommConfigA".} + proc GetComputerName*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetComputerNameA".} + proc SetComputerName*(lpComputerName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetComputerNameA".} + proc DnsHostnameToComputerName*(Hostname: LPCSTR, ComputerName: LPSTR, nSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "DnsHostnameToComputerNameA".} + proc GetUserName*(lpBuffer: LPSTR, pcbBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetUserNameA".} + proc LogonUser*(lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LogonUserA".} + proc LogonUserEx*(lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: ptr PSID, ppProfileBuffer: ptr PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "LogonUserExA".} + proc CreatePrivateNamespace*(lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreatePrivateNamespaceA".} + proc OpenPrivateNamespace*(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenPrivateNamespaceA".} + proc CreateBoundaryDescriptor*(Name: LPCSTR, Flags: ULONG): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateBoundaryDescriptorA".} + proc GetCurrentHwProfile*(lpHwProfileInfo: LPHW_PROFILE_INFOA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetCurrentHwProfileA".} + proc VerifyVersionInfo*(lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "VerifyVersionInfoA".} + proc CreateJobObject*(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateJobObjectA".} + proc OpenJobObject*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "OpenJobObjectA".} + proc FindFirstVolumeMountPoint*(lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "FindFirstVolumeMountPointA".} + proc FindNextVolumeMountPoint*(hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindNextVolumeMountPointA".} + proc SetVolumeMountPoint*(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetVolumeMountPointA".} + proc CreateActCtx*(pActCtx: PCACTCTXA): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc: "CreateActCtxA".} + proc FindActCtxSectionString*(dwFlags: DWORD, lpExtensionGuid: ptr GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FindActCtxSectionStringA".} + proc CreateSymbolicLink*(lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSymbolicLinkA".} + proc CreateSymbolicLinkTransacted*(lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE): BOOLEAN {.winapi, stdcall, dynlib: "kernel32", importc: "CreateSymbolicLinkTransactedA".} + proc LookupAccountNameLocal*(lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountNameA(nil, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse) + proc LookupAccountSidLocal*(Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL {.winapi, inline.} = LookupAccountSidA(nil, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse) +when winimCpu64: + const + SCS_THIS_PLATFORM_BINARY* = SCS_64BIT_BINARY + proc GetEnabledXStateFeatures*(): DWORD64 {.winapi, stdcall, dynlib: "kernel32", importc.} + proc GetXStateFeaturesMask*(Context: PCONTEXT, FeatureMask: PDWORD64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} + proc LocateXStateFeature*(Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD): PVOID {.winapi, stdcall, dynlib: "kernel32", importc.} + proc SetXStateFeaturesMask*(Context: PCONTEXT, FeatureMask: DWORD64): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +when winimCpu32: + const + SCS_THIS_PLATFORM_BINARY* = SCS_32BIT_BINARY diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wincodec.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wincodec.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,651 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import objbase +#include +type + WICDecodeOptions* = int32 + WICBitmapCreateCacheOption* = int32 + WICBitmapAlphaChannelOption* = int32 + WICBitmapDecoderCapabilities* = int32 + WICBitmapDitherType* = int32 + WICBitmapEncoderCacheOption* = int32 + WICBitmapInterpolationMode* = int32 + WICBitmapLockFlags* = int32 + WICBitmapPaletteType* = int32 + WICBitmapTransformOptions* = int32 + WICColorContextType* = int32 + WICComponentType* = int32 + WICComponentSigning* = int32 + WICComponentEnumerateOptions* = int32 + WICPixelFormatNumericRepresentation* = int32 + WICTiffCompressionOption* = int32 + WICPixelFormatGUID* = GUID + REFWICPixelFormatGUID* = REFGUID + WICColor* = UINT32 +const + WINCODEC_SDK_VERSION* = 0x0236 + wICDecodeMetadataCacheOnDemand* = 0x0 + wICDecodeMetadataCacheOnLoad* = 0x1 + WICMETADATACACHEOPTION_FORCE_DWORD* = 0x7fffffff + wICBitmapNoCache* = 0x0 + wICBitmapCacheOnDemand* = 0x1 + wICBitmapCacheOnLoad* = 0x2 + WICBITMAPCREATECACHEOPTION_FORCE_DWORD* = 0x7fffffff + wICBitmapUseAlpha* = 0x0 + wICBitmapUsePremultipliedAlpha* = 0x1 + wICBitmapIgnoreAlpha* = 0x2 + WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD* = 0x7fffffff + wICBitmapDecoderCapabilitySameEncoder* = 0x1 + wICBitmapDecoderCapabilityCanDecodeAllImages* = 0x2 + wICBitmapDecoderCapabilityCanDecodeSomeImages* = 0x4 + wICBitmapDecoderCapabilityCanEnumerateMetadata* = 0x8 + wICBitmapDecoderCapabilityCanDecodeThumbnail* = 0x10 + wICBitmapDitherTypeNone* = 0x0 + wICBitmapDitherTypeSolid* = 0x0 + wICBitmapDitherTypeOrdered4x4* = 0x1 + wICBitmapDitherTypeOrdered8x8* = 0x2 + wICBitmapDitherTypeOrdered16x16* = 0x3 + wICBitmapDitherTypeSpiral4x4* = 0x4 + wICBitmapDitherTypeSpiral8x8* = 0x5 + wICBitmapDitherTypeDualSpiral4x4* = 0x6 + wICBitmapDitherTypeDualSpiral8x8* = 0x7 + wICBitmapDitherTypeErrorDiffusion* = 0x8 + WICBITMAPDITHERTYPE_FORCE_DWORD* = 0x7fffffff + wICBitmapEncoderCacheInMemory* = 0x0 + wICBitmapEncoderCacheTempFile* = 0x1 + wICBitmapEncoderNoCache* = 0x2 + WICBITMAPENCODERCACHEOPTION_FORCE_DWORD* = 0x7fffffff + wICBitmapInterpolationModeNearestNeighbor* = 0x0 + wICBitmapInterpolationModeLinear* = 0x1 + wICBitmapInterpolationModeCubic* = 0x2 + wICBitmapInterpolationModeFant* = 0x3 + WICBITMAPINTERPOLATIONMODE_FORCE_DWORD* = 0x7fffffff + wICBitmapLockRead* = 0x1 + wICBitmapLockWrite* = 0x2 + WICBITMAPLOCKFLAGS_FORCE_DWORD* = 0x7fffffff + wICBitmapPaletteTypeCustom* = 0x0 + wICBitmapPaletteTypeMedianCut* = 0x1 + wICBitmapPaletteTypeFixedBW* = 0x2 + wICBitmapPaletteTypeFixedHalftone8* = 0x3 + wICBitmapPaletteTypeFixedHalftone27* = 0x4 + wICBitmapPaletteTypeFixedHalftone64* = 0x5 + wICBitmapPaletteTypeFixedHalftone125* = 0x6 + wICBitmapPaletteTypeFixedHalftone216* = 0x7 + wICBitmapPaletteTypeFixedWebPalette* = wICBitmapPaletteTypeFixedHalftone216 + wICBitmapPaletteTypeFixedHalftone252* = 0x8 + wICBitmapPaletteTypeFixedHalftone256* = 0x9 + wICBitmapPaletteTypeFixedGray4* = 0xa + wICBitmapPaletteTypeFixedGray16* = 0xb + wICBitmapPaletteTypeFixedGray256* = 0xc + WICBITMAPPALETTETYPE_FORCE_DWORD* = 0x7fffffff + wICBitmapTransformRotate0* = 0x0 + wICBitmapTransformRotate90* = 0x1 + wICBitmapTransformRotate180* = 0x2 + wICBitmapTransformRotate270* = 0x3 + wICBitmapTransformFlipHorizontal* = 0x8 + wICBitmapTransformFlipVertical* = 0x10 + WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD* = 0x7fffffff + wICColorContextUninitialized* = 0x0 + wICColorContextProfile* = 0x1 + wICColorContextExifColorSpace* = 0x2 + wICDecoder* = 0x1 + wICEncoder* = 0x2 + wICPixelFormatConverter* = 0x4 + wICMetadataReader* = 0x8 + wICMetadataWriter* = 0x10 + wICPixelFormat* = 0x20 + WICCOMPONENTTYPE_FORCE_DWORD* = 0x7fffffff + wICComponentSigned* = 0x1 + wICComponentUnsigned* = 0x2 + wICComponentSafe* = 0x4 + wICComponentDisabled* = 0x80000000'i32 + wICComponentEnumerateDefault* = 0x0 + wICComponentEnumerateRefresh* = 0x1 + wICComponentEnumerateBuiltInOnly* = 0x20000000 + wICComponentEnumerateUnsigned* = 0x40000000 + wICComponentEnumerateDisabled* = 0x80000000'i32 + wICPixelFormatNumericRepresentationUnspecified* = 0x0 + wICPixelFormatNumericRepresentationIndexed* = 0x1 + wICPixelFormatNumericRepresentationUnsignedInteger* = 0x2 + wICPixelFormatNumericRepresentationSignedInteger* = 0x3 + wICPixelFormatNumericRepresentationFixed* = 0x4 + wICPixelFormatNumericRepresentationFloat* = 0x5 + WICPIXELFORMATNUMERICREPRESENTATION_FORCE_DWORD* = 0x7fffffff + wICTiffCompressionDontCare* = 0x0 + wICTiffCompressionNone* = 0x1 + wICTiffCompressionCCITT3* = 0x2 + wICTiffCompressionCCITT4* = 0x3 + wICTiffCompressionLZW* = 0x4 + wICTiffCompressionRLE* = 0x5 + wICTiffCompressionZIP* = 0x6 + wICTiffCompressionLZWHDifferencing* = 0x7 + WICTIFFCOMPRESSIONOPTION_FORCE_DWORD* = 0x7fffffff + GUID_WICPixelFormatDontCare* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc900") + GUID_WICPixelFormatUndefined* = GUID_WICPixelFormatDontCare + GUID_WICPixelFormat1bppIndexed* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc901") + GUID_WICPixelFormat2bppIndexed* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc902") + GUID_WICPixelFormat4bppIndexed* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc903") + GUID_WICPixelFormat8bppIndexed* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc904") + GUID_WICPixelFormatBlackWhite* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc905") + GUID_WICPixelFormat2bppGray* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc906") + GUID_WICPixelFormat4bppGray* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc907") + GUID_WICPixelFormat8bppGray* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc908") + GUID_WICPixelFormat16bppGray* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90b") + GUID_WICPixelFormat16bppBGR555* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc909") + GUID_WICPixelFormat16bppBGR565* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90a") + GUID_WICPixelFormat16bppBGRA5551* = DEFINE_GUID("05ec7c2b-f1e6-4961-ad46-e1cc810a87d2") + GUID_WICPixelFormat24bppBGR* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90c") + GUID_WICPixelFormat24bppRGB* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90d") + GUID_WICPixelFormat32bppBGR* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90e") + GUID_WICPixelFormat32bppBGRA* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc90f") + GUID_WICPixelFormat32bppPBGRA* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc910") + GUID_WICPixelFormat32bppRGB* = DEFINE_GUID("d98c6b95-3efe-47d6-bb25-eb1748ab0cf1") + GUID_WICPixelFormat32bppRGBA* = DEFINE_GUID("f5c7ad2d-6a8d-43dd-a7a8-a29935261ae9") + GUID_WICPixelFormat32bppPRGBA* = DEFINE_GUID("3cc4a650-a527-4d37-a916-3142c7ebedba") + GUID_WICPixelFormat48bppRGB* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc915") + GUID_WICPixelFormat64bppRGBA* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc916") + GUID_WICPixelFormat64bppPRGBA* = DEFINE_GUID("6fddc324-4e03-4bfe-b185-3d77768dc917") + GUID_WICPixelFormat32bppCMYK* = DEFINE_GUID("6fddc324-4e03-4fbe-b185-3d77768dc91c") + WINCODEC_ERR_WRONGSTATE* = 0x88982f04'i32 + WINCODEC_ERR_VALUEOUTOFRANGE* = 0x88982f05'i32 + WINCODEC_ERR_NOTINITIALIZED* = 0x88982f0c'i32 + WINCODEC_ERR_ALREADYLOCKED* = 0x88982f0d'i32 + WINCODEC_ERR_PROPERTYNOTFOUND* = 0x88982f40'i32 + WINCODEC_ERR_CODECNOTHUMBNAIL* = 0x88982f44'i32 + WINCODEC_ERR_PALETTEUNAVAILABLE* = 0x88982f45'i32 + WINCODEC_ERR_COMPONENTNOTFOUND* = 0x88982f50'i32 + WINCODEC_ERR_BADIMAGE* = 0x88982f60'i32 + WINCODEC_ERR_FRAMEMISSING* = 0x88982f62'i32 + WINCODEC_ERR_BADMETADATAHEADER* = 0x88982f63'i32 + WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT* = 0x88982f80'i32 + WINCODEC_ERR_UNSUPPORTEDOPERATION* = 0x88982f81'i32 + WINCODEC_ERR_INSUFFICIENTBUFFER* = 0x88982f8c'i32 + WINCODEC_ERR_PROPERTYUNEXPECTEDTYPE* = 0x88982f8e'i32 + WINCODEC_ERR_WIN32ERROR* = 0x88982f94'i32 + IID_IWICColorContext* = DEFINE_GUID("3c613a02-34b2-44ea-9a7c-45aea9c6fd6d") + IID_IWICBitmapSource* = DEFINE_GUID("00000120-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICBitmapLock* = DEFINE_GUID("00000123-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICBitmapFlipRotator* = DEFINE_GUID("5009834f-2d6a-41ce-9e1b-17c5aff7a782") + IID_IWICBitmap* = DEFINE_GUID("00000121-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICPalette* = DEFINE_GUID("00000040-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICComponentInfo* = DEFINE_GUID("23bc3f0a-698b-4357-886b-f24d50671334") + IID_IWICMetadataQueryReader* = DEFINE_GUID("30989668-e1c9-4597-b395-458eedb808df") + IID_IWICMetadataQueryWriter* = DEFINE_GUID("a721791a-0def-4d06-bd91-2118bf1db10b") + IID_IWICBitmapFrameDecode* = DEFINE_GUID("3b16811b-6a43-4ec9-a813-3d930c13b940") + IID_IWICPixelFormatInfo* = DEFINE_GUID("e8eda601-3d48-431a-ab44-69059be88bbe") + IID_IWICPixelFormatInfo2* = DEFINE_GUID("a9db33a2-af5f-43c7-b679-74f5984b5aa4") + IID_IWICBitmapCodecInfo* = DEFINE_GUID("e87a44c4-b76e-4c47-8b09-298eb12a2714") + IID_IWICBitmapDecoderInfo* = DEFINE_GUID("d8cd007f-d08f-4191-9bfc-236ea7f0e4b5") + IID_IWICBitmapDecoder* = DEFINE_GUID("9edde9e7-8dee-47ea-99df-e6faf2ed44bf") + IID_IWICBitmapFrameEncode* = DEFINE_GUID("00000105-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICBitmapEncoderInfo* = DEFINE_GUID("94c9b4ee-a09f-4f92-8a1e-4a9bce7e76fb") + IID_IWICBitmapEncoder* = DEFINE_GUID("00000103-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICFormatConverter* = DEFINE_GUID("00000301-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICFormatConverterInfo* = DEFINE_GUID("9f34fb65-13f4-4f15-bc57-3726b5e53d9f") + IID_IWICStream* = DEFINE_GUID("135ff860-22b7-4ddf-b0f6-218f4f299a43") + IID_IWICBitmapScaler* = DEFINE_GUID("00000302-a8f2-4877-ba0a-fd2b6645fb94") + IID_IWICBitmapClipper* = DEFINE_GUID("e4fbcf03-223d-4e81-9333-d635556dd1b5") + IID_IWICColorTransform* = DEFINE_GUID("b66f034f-d0e2-40ab-b436-6de39e321a94") + IID_IWICFastMetadataEncoder* = DEFINE_GUID("b84e2c09-78c9-4ac4-8bd3-524ae1663a2f") + CLSID_WICImagingFactory* = DEFINE_GUID("cacaf262-9370-4615-a13b-9f5539da4c0a") + IID_IWICImagingFactory* = DEFINE_GUID("ec5ec8a9-c395-4314-9c77-54d7a935ff70") + IID_IWICEnumMetadataItem* = DEFINE_GUID("dc2bb46d-3f07-481e-8625-220c4aedbb33") + CLSID_WICBmpDecoder* = DEFINE_GUID("6b462062-7cbf-400d-9fdb-813dd10f2778") + CLSID_WICPngDecoder* = DEFINE_GUID("389ea17b-5078-4cde-b6ef-25c15175c751") + CLSID_WICIcoDecoder* = DEFINE_GUID("c61bfcdf-2e0f-4aad-a8d7-e06bafebcdfe") + CLSID_WICJpegDecoder* = DEFINE_GUID("9456a480-e88b-43ea-9e73-0b2d9b71b1ca") + CLSID_WICGifDecoder* = DEFINE_GUID("381dda3c-9ce9-4834-a23e-1f98f8fc52be") + CLSID_WICTiffDecoder* = DEFINE_GUID("b54e85d9-fe23-499f-8b88-6acea713752b") + CLSID_WICWmpDecoder* = DEFINE_GUID("a26cec36-234c-4950-ae16-e34aace71d0d") + CLSID_WICBmpEncoder* = DEFINE_GUID("69be8bb4-d66d-47c8-865a-ed1589433782") + CLSID_WICPngEncoder* = DEFINE_GUID("27949969-876a-41d7-9447-568f6a35a4dc") + CLSID_WICJpegEncoder* = DEFINE_GUID("1a34f5c1-4a5a-46dc-b644-1f4567e7a676") + CLSID_WICGifEncoder* = DEFINE_GUID("114f5598-0b22-40a0-86a1-c83ea495adbd") + CLSID_WICTiffEncoder* = DEFINE_GUID("0131be10-2001-4c5f-a9b0-cc88fab64ce8") + CLSID_WICWmpEncoder* = DEFINE_GUID("ac4ce3cb-e1c1-44cd-8215-5a1665509ec2") + CLSID_WICDefaultFormatConverter* = DEFINE_GUID("1a3f11dc-b514-4b17-8c5f-2154513852f1") + GUID_ContainerFormatBmp* = DEFINE_GUID("0af1d87e-fcfe-4188-bdeb-a7906471cbe3") + GUID_ContainerFormatPng* = DEFINE_GUID("1b7cfaf4-713f-473c-bbcd-6137425faeaf") + GUID_ContainerFormatIco* = DEFINE_GUID("a3a860c4-338f-4c17-919a-fba4b5628f21") + GUID_ContainerFormatJpeg* = DEFINE_GUID("19e4a5aa-5662-4fc5-a0c0-1758028e1057") + GUID_ContainerFormatTiff* = DEFINE_GUID("163bcc30-e2e9-4f0b-961d-a3e9fdb788a3") + GUID_ContainerFormatGif* = DEFINE_GUID("1f8a5601-7d4d-4cbd-9c82-1bc8d4eeb9a5") + GUID_ContainerFormatWmp* = DEFINE_GUID("57a37caa-367a-4540-916b-f183c5093a4b") + GUID_VendorMicrosoft* = DEFINE_GUID("f0e749ca-edef-4589-a73a-ee0e626a2a2b") + CLSID_WICImagingCategories* = DEFINE_GUID("fae3d380-fea4-4623-8c75-c6b61110b681") + CATID_WICBitmapDecoders* = DEFINE_GUID("7ed96837-96f0-4812-b211-f13c24117ed3") + CATID_WICBitmapEncoders* = DEFINE_GUID("ac757296-3522-4e11-9862-c17be5a1767e") + CATID_WICFormatConverters* = DEFINE_GUID("7835eae8-bf14-49d1-93ce-533a407b2248") + CATID_WICMetadataReader* = DEFINE_GUID("05af94d8-7174-4cd2-be4a-4124b80ee4b8") + CATID_WICPixelFormats* = DEFINE_GUID("2b46e70f-cda7-473e-89f6-dc9630a2390b") +type + WICRect* {.pure.} = object + X*: INT + Y*: INT + Width*: INT + Height*: INT + WICBitmapPattern* {.pure.} = object + Position*: ULARGE_INTEGER + Length*: ULONG + Pattern*: ptr BYTE + Mask*: ptr BYTE + EndOfStream*: WINBOOL + IWICColorContext* {.pure.} = object + lpVtbl*: ptr IWICColorContextVtbl + IWICColorContextVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitializeFromFilename*: proc(self: ptr IWICColorContext, wzFilename: LPCWSTR): HRESULT {.stdcall.} + InitializeFromMemory*: proc(self: ptr IWICColorContext, pbBuffer: ptr BYTE, cbBufferSize: UINT): HRESULT {.stdcall.} + InitializeFromExifColorSpace*: proc(self: ptr IWICColorContext, value: UINT): HRESULT {.stdcall.} + GetType*: proc(self: ptr IWICColorContext, pType: ptr WICColorContextType): HRESULT {.stdcall.} + GetProfileBytes*: proc(self: ptr IWICColorContext, cbBuffer: UINT, pbBuffer: ptr BYTE, pcbActual: ptr UINT): HRESULT {.stdcall.} + GetExifColorSpace*: proc(self: ptr IWICColorContext, pValue: ptr UINT): HRESULT {.stdcall.} + IWICPalette* {.pure.} = object + lpVtbl*: ptr IWICPaletteVtbl + IWICPaletteVtbl* {.pure, inheritable.} = object of IUnknownVtbl + InitializePredefined*: proc(self: ptr IWICPalette, ePaletteType: WICBitmapPaletteType, fAddTransparentColor: WINBOOL): HRESULT {.stdcall.} + InitializeCustom*: proc(self: ptr IWICPalette, pColors: ptr WICColor, colorCount: UINT): HRESULT {.stdcall.} + InitializeFromBitmap*: proc(self: ptr IWICPalette, pISurface: ptr IWICBitmapSource, colorCount: UINT, fAddTransparentColor: WINBOOL): HRESULT {.stdcall.} + InitializeFromPalette*: proc(self: ptr IWICPalette, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + GetType*: proc(self: ptr IWICPalette, pePaletteType: ptr WICBitmapPaletteType): HRESULT {.stdcall.} + GetColorCount*: proc(self: ptr IWICPalette, pcCount: ptr UINT): HRESULT {.stdcall.} + GetColors*: proc(self: ptr IWICPalette, colorCount: UINT, pColors: ptr WICColor, pcActualColors: ptr UINT): HRESULT {.stdcall.} + IsBlackWhite*: proc(self: ptr IWICPalette, pfIsBlackWhite: ptr WINBOOL): HRESULT {.stdcall.} + IsGrayscale*: proc(self: ptr IWICPalette, pfIsGrayscale: ptr WINBOOL): HRESULT {.stdcall.} + HasAlpha*: proc(self: ptr IWICPalette, pfHasAlpha: ptr WINBOOL): HRESULT {.stdcall.} + IWICBitmapSource* {.pure.} = object + lpVtbl*: ptr IWICBitmapSourceVtbl + IWICBitmapSourceVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSize*: proc(self: ptr IWICBitmapSource, puiWidth: ptr UINT, puiHeight: ptr UINT): HRESULT {.stdcall.} + GetPixelFormat*: proc(self: ptr IWICBitmapSource, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.stdcall.} + GetResolution*: proc(self: ptr IWICBitmapSource, pDpiX: ptr float64, pDpiY: ptr float64): HRESULT {.stdcall.} + CopyPalette*: proc(self: ptr IWICBitmapSource, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + CopyPixels*: proc(self: ptr IWICBitmapSource, prc: ptr WICRect, cbStride: UINT, cbBufferSize: UINT, pbBuffer: ptr BYTE): HRESULT {.stdcall.} + IWICBitmapLock* {.pure.} = object + lpVtbl*: ptr IWICBitmapLockVtbl + IWICBitmapLockVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetSize*: proc(self: ptr IWICBitmapLock, pWidth: ptr UINT, pHeight: ptr UINT): HRESULT {.stdcall.} + GetStride*: proc(self: ptr IWICBitmapLock, pcbStride: ptr UINT): HRESULT {.stdcall.} + GetDataPointer*: proc(self: ptr IWICBitmapLock, pcbBufferSize: ptr UINT, ppbData: ptr ptr BYTE): HRESULT {.stdcall.} + GetPixelFormat*: proc(self: ptr IWICBitmapLock, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.stdcall.} + IWICBitmapFlipRotator* {.pure.} = object + lpVtbl*: ptr IWICBitmapFlipRotatorVtbl + IWICBitmapFlipRotatorVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Initialize*: proc(self: ptr IWICBitmapFlipRotator, pISource: ptr IWICBitmapSource, options: WICBitmapTransformOptions): HRESULT {.stdcall.} + IWICBitmap* {.pure.} = object + lpVtbl*: ptr IWICBitmapVtbl + IWICBitmapVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Lock*: proc(self: ptr IWICBitmap, prcLock: ptr WICRect, flags: DWORD, ppILock: ptr ptr IWICBitmapLock): HRESULT {.stdcall.} + SetPalette*: proc(self: ptr IWICBitmap, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + SetResolution*: proc(self: ptr IWICBitmap, dpiX: float64, dpiY: float64): HRESULT {.stdcall.} + IWICComponentInfo* {.pure.} = object + lpVtbl*: ptr IWICComponentInfoVtbl + IWICComponentInfoVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetComponentType*: proc(self: ptr IWICComponentInfo, pType: ptr WICComponentType): HRESULT {.stdcall.} + GetCLSID*: proc(self: ptr IWICComponentInfo, pclsid: ptr CLSID): HRESULT {.stdcall.} + GetSigningStatus*: proc(self: ptr IWICComponentInfo, pStatus: ptr DWORD): HRESULT {.stdcall.} + GetAuthor*: proc(self: ptr IWICComponentInfo, cchAuthor: UINT, wzAuthor: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetVendorGUID*: proc(self: ptr IWICComponentInfo, pguidVendor: ptr GUID): HRESULT {.stdcall.} + GetVersion*: proc(self: ptr IWICComponentInfo, cchVersion: UINT, wzVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetSpecVersion*: proc(self: ptr IWICComponentInfo, cchSpecVersion: UINT, wzSpecVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetFriendlyName*: proc(self: ptr IWICComponentInfo, cchFriendlyName: UINT, wzFriendlyName: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + IWICMetadataQueryReader* {.pure.} = object + lpVtbl*: ptr IWICMetadataQueryReaderVtbl + IWICMetadataQueryReaderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + GetContainerFormat*: proc(self: ptr IWICMetadataQueryReader, pguidContainerFormat: ptr GUID): HRESULT {.stdcall.} + GetLocation*: proc(self: ptr IWICMetadataQueryReader, cchMaxLength: UINT, wzNamespace: ptr WCHAR, pcchActualLength: ptr UINT): HRESULT {.stdcall.} + GetMetadataByName*: proc(self: ptr IWICMetadataQueryReader, wzName: LPCWSTR, pvarValue: ptr PROPVARIANT): HRESULT {.stdcall.} + GetEnumerator*: proc(self: ptr IWICMetadataQueryReader, ppIEnumString: ptr ptr IEnumString): HRESULT {.stdcall.} + IWICMetadataQueryWriter* {.pure.} = object + lpVtbl*: ptr IWICMetadataQueryWriterVtbl + IWICMetadataQueryWriterVtbl* {.pure, inheritable.} = object of IWICMetadataQueryReaderVtbl + SetMetadataByName*: proc(self: ptr IWICMetadataQueryWriter, wzName: LPCWSTR, pvarValue: ptr PROPVARIANT): HRESULT {.stdcall.} + RemoveMetadataByName*: proc(self: ptr IWICMetadataQueryWriter, wzName: LPCWSTR): HRESULT {.stdcall.} + IWICBitmapFrameDecode* {.pure.} = object + lpVtbl*: ptr IWICBitmapFrameDecodeVtbl + IWICBitmapFrameDecodeVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + GetMetadataQueryReader*: proc(self: ptr IWICBitmapFrameDecode, ppIMetadataQueryReader: ptr ptr IWICMetadataQueryReader): HRESULT {.stdcall.} + GetColorContexts*: proc(self: ptr IWICBitmapFrameDecode, cCount: UINT, ppIColorContexts: ptr ptr IWICColorContext, pcActualCount: ptr UINT): HRESULT {.stdcall.} + GetThumbnail*: proc(self: ptr IWICBitmapFrameDecode, ppIThumbnail: ptr ptr IWICBitmapSource): HRESULT {.stdcall.} + IWICPixelFormatInfo* {.pure.} = object + lpVtbl*: ptr IWICPixelFormatInfoVtbl + IWICPixelFormatInfoVtbl* {.pure, inheritable.} = object of IWICComponentInfoVtbl + GetFormatGUID*: proc(self: ptr IWICPixelFormatInfo, pFormat: ptr GUID): HRESULT {.stdcall.} + GetColorContext*: proc(self: ptr IWICPixelFormatInfo, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.stdcall.} + GetBitsPerPixel*: proc(self: ptr IWICPixelFormatInfo, puiBitsPerPixel: ptr UINT): HRESULT {.stdcall.} + GetChannelCount*: proc(self: ptr IWICPixelFormatInfo, puiChannelCount: ptr UINT): HRESULT {.stdcall.} + GetChannelMask*: proc(self: ptr IWICPixelFormatInfo, uiChannelIndex: UINT, cbMaskBuffer: UINT, pbMaskBuffer: ptr BYTE, pcbActual: ptr UINT): HRESULT {.stdcall.} + IWICPixelFormatInfo2* {.pure.} = object + lpVtbl*: ptr IWICPixelFormatInfo2Vtbl + IWICPixelFormatInfo2Vtbl* {.pure, inheritable.} = object of IWICPixelFormatInfoVtbl + SupportsTransparency*: proc(self: ptr IWICPixelFormatInfo2, pfSupportsTransparency: ptr WINBOOL): HRESULT {.stdcall.} + GetNumericRepresentation*: proc(self: ptr IWICPixelFormatInfo2, pNumericRepresentation: ptr WICPixelFormatNumericRepresentation): HRESULT {.stdcall.} + IWICBitmapCodecInfo* {.pure.} = object + lpVtbl*: ptr IWICBitmapCodecInfoVtbl + IWICBitmapCodecInfoVtbl* {.pure, inheritable.} = object of IWICComponentInfoVtbl + GetContainerFormat*: proc(self: ptr IWICBitmapCodecInfo, pguidContainerFormat: ptr GUID): HRESULT {.stdcall.} + GetPixelFormats*: proc(self: ptr IWICBitmapCodecInfo, cFormats: UINT, pguidPixelFormats: ptr GUID, pcActual: ptr UINT): HRESULT {.stdcall.} + GetColorManagementVersion*: proc(self: ptr IWICBitmapCodecInfo, cchColorManagementVersion: UINT, wzColorManagementVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetDeviceManufacturer*: proc(self: ptr IWICBitmapCodecInfo, cchDeviceManufacturer: UINT, wzDeviceManufacturer: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetDeviceModels*: proc(self: ptr IWICBitmapCodecInfo, cchDeviceModels: UINT, wzDeviceModels: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetMimeTypes*: proc(self: ptr IWICBitmapCodecInfo, cchMimeTypes: UINT, wzMimeTypes: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + GetFileExtensions*: proc(self: ptr IWICBitmapCodecInfo, cchFileExtensions: UINT, wzFileExtensions: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.stdcall.} + DoesSupportAnimation*: proc(self: ptr IWICBitmapCodecInfo, pfSupportAnimation: ptr WINBOOL): HRESULT {.stdcall.} + DoesSupportChromaKey*: proc(self: ptr IWICBitmapCodecInfo, pfSupportChromaKey: ptr WINBOOL): HRESULT {.stdcall.} + DoesSupportLossless*: proc(self: ptr IWICBitmapCodecInfo, pfSupportLossless: ptr WINBOOL): HRESULT {.stdcall.} + DoesSupportMultiframe*: proc(self: ptr IWICBitmapCodecInfo, pfSupportMultiframe: ptr WINBOOL): HRESULT {.stdcall.} + MatchesMimeType*: proc(self: ptr IWICBitmapCodecInfo, wzMimeType: LPCWSTR, pfMatches: ptr WINBOOL): HRESULT {.stdcall.} + IWICBitmapDecoder* {.pure.} = object + lpVtbl*: ptr IWICBitmapDecoderVtbl + IWICBitmapDecoderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + QueryCapability*: proc(self: ptr IWICBitmapDecoder, pIStream: ptr IStream, pdwCapability: ptr DWORD): HRESULT {.stdcall.} + Initialize*: proc(self: ptr IWICBitmapDecoder, pIStream: ptr IStream, cacheOptions: WICDecodeOptions): HRESULT {.stdcall.} + GetContainerFormat*: proc(self: ptr IWICBitmapDecoder, pguidContainerFormat: ptr GUID): HRESULT {.stdcall.} + GetDecoderInfo*: proc(self: ptr IWICBitmapDecoder, ppIDecoderInfo: ptr ptr IWICBitmapDecoderInfo): HRESULT {.stdcall.} + CopyPalette*: proc(self: ptr IWICBitmapDecoder, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + GetMetadataQueryReader*: proc(self: ptr IWICBitmapDecoder, ppIMetadataQueryReader: ptr ptr IWICMetadataQueryReader): HRESULT {.stdcall.} + GetPreview*: proc(self: ptr IWICBitmapDecoder, ppIBitmapSource: ptr ptr IWICBitmapSource): HRESULT {.stdcall.} + GetColorContexts*: proc(self: ptr IWICBitmapDecoder, cCount: UINT, ppIColorContexts: ptr ptr IWICColorContext, pcActualCount: ptr UINT): HRESULT {.stdcall.} + GetThumbnail*: proc(self: ptr IWICBitmapDecoder, ppIThumbnail: ptr ptr IWICBitmapSource): HRESULT {.stdcall.} + GetFrameCount*: proc(self: ptr IWICBitmapDecoder, pCount: ptr UINT): HRESULT {.stdcall.} + GetFrame*: proc(self: ptr IWICBitmapDecoder, index: UINT, ppIBitmapFrame: ptr ptr IWICBitmapFrameDecode): HRESULT {.stdcall.} + IWICBitmapDecoderInfo* {.pure.} = object + lpVtbl*: ptr IWICBitmapDecoderInfoVtbl + IWICBitmapDecoderInfoVtbl* {.pure, inheritable.} = object of IWICBitmapCodecInfoVtbl + GetPatterns*: proc(self: ptr IWICBitmapDecoderInfo, cbSizePatterns: UINT, pPatterns: ptr WICBitmapPattern, pcPatterns: ptr UINT, pcbPatternsActual: ptr UINT): HRESULT {.stdcall.} + MatchesPattern*: proc(self: ptr IWICBitmapDecoderInfo, pIStream: ptr IStream, pfMatches: ptr WINBOOL): HRESULT {.stdcall.} + CreateInstance*: proc(self: ptr IWICBitmapDecoderInfo, ppIBitmapDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.stdcall.} + IWICBitmapFrameEncode* {.pure.} = object + lpVtbl*: ptr IWICBitmapFrameEncodeVtbl + IWICBitmapFrameEncodeVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IWICBitmapFrameEncode, pIEncoderOptions: ptr IPropertyBag2): HRESULT {.stdcall.} + SetSize*: proc(self: ptr IWICBitmapFrameEncode, uiWidth: UINT, uiHeight: UINT): HRESULT {.stdcall.} + SetResolution*: proc(self: ptr IWICBitmapFrameEncode, dpiX: float64, dpiY: float64): HRESULT {.stdcall.} + SetPixelFormat*: proc(self: ptr IWICBitmapFrameEncode, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.stdcall.} + SetColorContexts*: proc(self: ptr IWICBitmapFrameEncode, cCount: UINT, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.stdcall.} + SetPalette*: proc(self: ptr IWICBitmapFrameEncode, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + SetThumbnail*: proc(self: ptr IWICBitmapFrameEncode, pIThumbnail: ptr IWICBitmapSource): HRESULT {.stdcall.} + WritePixels*: proc(self: ptr IWICBitmapFrameEncode, lineCount: UINT, cbStride: UINT, cbBufferSize: UINT, pbPixels: ptr BYTE): HRESULT {.stdcall.} + WriteSource*: proc(self: ptr IWICBitmapFrameEncode, pIBitmapSource: ptr IWICBitmapSource, prc: ptr WICRect): HRESULT {.stdcall.} + Commit*: proc(self: ptr IWICBitmapFrameEncode): HRESULT {.stdcall.} + GetMetadataQueryWriter*: proc(self: ptr IWICBitmapFrameEncode, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.stdcall.} + IWICBitmapEncoder* {.pure.} = object + lpVtbl*: ptr IWICBitmapEncoderVtbl + IWICBitmapEncoderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Initialize*: proc(self: ptr IWICBitmapEncoder, pIStream: ptr IStream, cacheOption: WICBitmapEncoderCacheOption): HRESULT {.stdcall.} + GetContainerFormat*: proc(self: ptr IWICBitmapEncoder, pguidContainerFormat: ptr GUID): HRESULT {.stdcall.} + GetEncoderInfo*: proc(self: ptr IWICBitmapEncoder, ppIEncoderInfo: ptr ptr IWICBitmapEncoderInfo): HRESULT {.stdcall.} + SetColorContexts*: proc(self: ptr IWICBitmapEncoder, cCount: UINT, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.stdcall.} + SetPalette*: proc(self: ptr IWICBitmapEncoder, pIPalette: ptr IWICPalette): HRESULT {.stdcall.} + SetThumbnail*: proc(self: ptr IWICBitmapEncoder, pIThumbnail: ptr IWICBitmapSource): HRESULT {.stdcall.} + SetPreview*: proc(self: ptr IWICBitmapEncoder, pIPreview: ptr IWICBitmapSource): HRESULT {.stdcall.} + CreateNewFrame*: proc(self: ptr IWICBitmapEncoder, ppIFrameEncode: ptr ptr IWICBitmapFrameEncode, ppIEncoderOptions: ptr ptr IPropertyBag2): HRESULT {.stdcall.} + Commit*: proc(self: ptr IWICBitmapEncoder): HRESULT {.stdcall.} + GetMetadataQueryWriter*: proc(self: ptr IWICBitmapEncoder, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.stdcall.} + IWICBitmapEncoderInfo* {.pure.} = object + lpVtbl*: ptr IWICBitmapEncoderInfoVtbl + IWICBitmapEncoderInfoVtbl* {.pure, inheritable.} = object of IWICBitmapCodecInfoVtbl + CreateInstance*: proc(self: ptr IWICBitmapEncoderInfo, ppIBitmapEncoder: ptr ptr IWICBitmapEncoder): HRESULT {.stdcall.} + IWICFormatConverter* {.pure.} = object + lpVtbl*: ptr IWICFormatConverterVtbl + IWICFormatConverterVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Initialize*: proc(self: ptr IWICFormatConverter, pISource: ptr IWICBitmapSource, dstFormat: REFWICPixelFormatGUID, dither: WICBitmapDitherType, pIPalette: ptr IWICPalette, alphaThresholdPercent: float64, paletteTranslate: WICBitmapPaletteType): HRESULT {.stdcall.} + CanConvert*: proc(self: ptr IWICFormatConverter, srcPixelFormat: REFWICPixelFormatGUID, dstPixelFormat: REFWICPixelFormatGUID, pfCanConvert: ptr WINBOOL): HRESULT {.stdcall.} + IWICFormatConverterInfo* {.pure.} = object + lpVtbl*: ptr IWICFormatConverterInfoVtbl + IWICFormatConverterInfoVtbl* {.pure, inheritable.} = object of IWICComponentInfoVtbl + GetPixelFormats*: proc(self: ptr IWICFormatConverterInfo, cFormats: UINT, pPixelFormatGUIDs: ptr WICPixelFormatGUID, pcActual: ptr UINT): HRESULT {.stdcall.} + CreateInstance*: proc(self: ptr IWICFormatConverterInfo, ppIConverter: ptr ptr IWICFormatConverter): HRESULT {.stdcall.} + IWICStream* {.pure.} = object + lpVtbl*: ptr IWICStreamVtbl + IWICStreamVtbl* {.pure, inheritable.} = object of IStreamVtbl + InitializeFromIStream*: proc(self: ptr IWICStream, pIStream: ptr IStream): HRESULT {.stdcall.} + InitializeFromFilename*: proc(self: ptr IWICStream, wzFileName: LPCWSTR, dwAccessMode: DWORD): HRESULT {.stdcall.} + InitializeFromMemory*: proc(self: ptr IWICStream, pbBuffer: ptr BYTE, cbBufferSize: DWORD): HRESULT {.stdcall.} + InitializeFromIStreamRegion*: proc(self: ptr IWICStream, pIStream: ptr IStream, ulOffset: ULARGE_INTEGER, ulMaxSize: ULARGE_INTEGER): HRESULT {.stdcall.} + IWICBitmapScaler* {.pure.} = object + lpVtbl*: ptr IWICBitmapScalerVtbl + IWICBitmapScalerVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Initialize*: proc(self: ptr IWICBitmapScaler, pISource: ptr IWICBitmapSource, uiWidth: UINT, uiHeight: UINT, mode: WICBitmapInterpolationMode): HRESULT {.stdcall.} + IWICBitmapClipper* {.pure.} = object + lpVtbl*: ptr IWICBitmapClipperVtbl + IWICBitmapClipperVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Initialize*: proc(self: ptr IWICBitmapClipper, pISource: ptr IWICBitmapSource, prc: ptr WICRect): HRESULT {.stdcall.} + IWICColorTransform* {.pure.} = object + lpVtbl*: ptr IWICColorTransformVtbl + IWICColorTransformVtbl* {.pure, inheritable.} = object of IWICBitmapSourceVtbl + Initialize*: proc(self: ptr IWICColorTransform, pIBitmapSource: ptr IWICBitmapSource, pIContextSource: ptr IWICColorContext, pIContextDest: ptr IWICColorContext, pixelFmtDest: REFWICPixelFormatGUID): HRESULT {.stdcall.} + IWICFastMetadataEncoder* {.pure.} = object + lpVtbl*: ptr IWICFastMetadataEncoderVtbl + IWICFastMetadataEncoderVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Commit*: proc(self: ptr IWICFastMetadataEncoder): HRESULT {.stdcall.} + GetMetadataQueryWriter*: proc(self: ptr IWICFastMetadataEncoder, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.stdcall.} + IWICImagingFactory* {.pure.} = object + lpVtbl*: ptr IWICImagingFactoryVtbl + IWICImagingFactoryVtbl* {.pure, inheritable.} = object of IUnknownVtbl + CreateDecoderFromFilename*: proc(self: ptr IWICImagingFactory, wzFilename: LPCWSTR, pguidVendor: ptr GUID, dwDesiredAccess: DWORD, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.stdcall.} + CreateDecoderFromStream*: proc(self: ptr IWICImagingFactory, pIStream: ptr IStream, pguidVendor: ptr GUID, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.stdcall.} + CreateDecoderFromFileHandle*: proc(self: ptr IWICImagingFactory, hFile: ULONG_PTR, pguidVendor: ptr GUID, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.stdcall.} + CreateComponentInfo*: proc(self: ptr IWICImagingFactory, clsidComponent: REFCLSID, ppIInfo: ptr ptr IWICComponentInfo): HRESULT {.stdcall.} + CreateDecoder*: proc(self: ptr IWICImagingFactory, guidContainerFormat: REFGUID, pguidVendor: ptr GUID, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.stdcall.} + CreateEncoder*: proc(self: ptr IWICImagingFactory, guidContainerFormat: REFGUID, pguidVendor: ptr GUID, ppIEncoder: ptr ptr IWICBitmapEncoder): HRESULT {.stdcall.} + CreatePalette*: proc(self: ptr IWICImagingFactory, ppIPalette: ptr ptr IWICPalette): HRESULT {.stdcall.} + CreateFormatConverter*: proc(self: ptr IWICImagingFactory, ppIFormatConverter: ptr ptr IWICFormatConverter): HRESULT {.stdcall.} + CreateBitmapScaler*: proc(self: ptr IWICImagingFactory, ppIBitmapScaler: ptr ptr IWICBitmapScaler): HRESULT {.stdcall.} + CreateBitmapClipper*: proc(self: ptr IWICImagingFactory, ppIBitmapClipper: ptr ptr IWICBitmapClipper): HRESULT {.stdcall.} + CreateBitmapFlipRotator*: proc(self: ptr IWICImagingFactory, ppIBitmapFlipRotator: ptr ptr IWICBitmapFlipRotator): HRESULT {.stdcall.} + CreateStream*: proc(self: ptr IWICImagingFactory, ppIWICStream: ptr ptr IWICStream): HRESULT {.stdcall.} + CreateColorContext*: proc(self: ptr IWICImagingFactory, ppIWICColorContext: ptr ptr IWICColorContext): HRESULT {.stdcall.} + CreateColorTransformer*: proc(self: ptr IWICImagingFactory, ppIWICColorTransform: ptr ptr IWICColorTransform): HRESULT {.stdcall.} + CreateBitmap*: proc(self: ptr IWICImagingFactory, uiWidth: UINT, uiHeight: UINT, pixelFormat: REFWICPixelFormatGUID, option: WICBitmapCreateCacheOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateBitmapFromSource*: proc(self: ptr IWICImagingFactory, piBitmapSource: ptr IWICBitmapSource, option: WICBitmapCreateCacheOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateBitmapFromSourceRect*: proc(self: ptr IWICImagingFactory, piBitmapSource: ptr IWICBitmapSource, x: UINT, y: UINT, width: UINT, height: UINT, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateBitmapFromMemory*: proc(self: ptr IWICImagingFactory, uiWidth: UINT, uiHeight: UINT, pixelFormat: REFWICPixelFormatGUID, cbStride: UINT, cbBufferSize: UINT, pbBuffer: ptr BYTE, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateBitmapFromHBITMAP*: proc(self: ptr IWICImagingFactory, hBitmap: HBITMAP, hPalette: HPALETTE, options: WICBitmapAlphaChannelOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateBitmapFromHICON*: proc(self: ptr IWICImagingFactory, hIcon: HICON, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.stdcall.} + CreateComponentEnumerator*: proc(self: ptr IWICImagingFactory, componentTypes: DWORD, options: DWORD, ppIEnumUnknown: ptr ptr IEnumUnknown): HRESULT {.stdcall.} + CreateFastMetadataEncoderFromDecoder*: proc(self: ptr IWICImagingFactory, pIDecoder: ptr IWICBitmapDecoder, ppIFastEncoder: ptr ptr IWICFastMetadataEncoder): HRESULT {.stdcall.} + CreateFastMetadataEncoderFromFrameDecode*: proc(self: ptr IWICImagingFactory, pIFrameDecoder: ptr IWICBitmapFrameDecode, ppIFastEncoder: ptr ptr IWICFastMetadataEncoder): HRESULT {.stdcall.} + CreateQueryWriter*: proc(self: ptr IWICImagingFactory, guidMetadataFormat: REFGUID, pguidVendor: ptr GUID, ppIQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.stdcall.} + CreateQueryWriterFromReader*: proc(self: ptr IWICImagingFactory, pIQueryReader: ptr IWICMetadataQueryReader, pguidVendor: ptr GUID, ppIQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.stdcall.} + IWICEnumMetadataItem* {.pure.} = object + lpVtbl*: ptr IWICEnumMetadataItemVtbl + IWICEnumMetadataItemVtbl* {.pure, inheritable.} = object of IUnknownVtbl + Next*: proc(self: ptr IWICEnumMetadataItem, celt: ULONG, rgeltSchema: ptr PROPVARIANT, rgeltId: ptr PROPVARIANT, rgeltValue: ptr PROPVARIANT, pceltFetched: ptr ULONG): HRESULT {.stdcall.} + Skip*: proc(self: ptr IWICEnumMetadataItem, celt: ULONG): HRESULT {.stdcall.} + Reset*: proc(self: ptr IWICEnumMetadataItem): HRESULT {.stdcall.} + Clone*: proc(self: ptr IWICEnumMetadataItem, ppIEnumMetadataItem: ptr ptr IWICEnumMetadataItem): HRESULT {.stdcall.} +proc InitializeFromFilename*(self: ptr IWICColorContext, wzFilename: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromFilename(self, wzFilename) +proc InitializeFromMemory*(self: ptr IWICColorContext, pbBuffer: ptr BYTE, cbBufferSize: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromMemory(self, pbBuffer, cbBufferSize) +proc InitializeFromExifColorSpace*(self: ptr IWICColorContext, value: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromExifColorSpace(self, value) +proc GetType*(self: ptr IWICColorContext, pType: ptr WICColorContextType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pType) +proc GetProfileBytes*(self: ptr IWICColorContext, cbBuffer: UINT, pbBuffer: ptr BYTE, pcbActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetProfileBytes(self, cbBuffer, pbBuffer, pcbActual) +proc GetExifColorSpace*(self: ptr IWICColorContext, pValue: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetExifColorSpace(self, pValue) +proc GetSize*(self: ptr IWICBitmapSource, puiWidth: ptr UINT, puiHeight: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, puiWidth, puiHeight) +proc GetPixelFormat*(self: ptr IWICBitmapSource, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPixelFormat(self, pPixelFormat) +proc GetResolution*(self: ptr IWICBitmapSource, pDpiX: ptr float64, pDpiY: ptr float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetResolution(self, pDpiX, pDpiY) +proc CopyPalette*(self: ptr IWICBitmapSource, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyPalette(self, pIPalette) +proc CopyPixels*(self: ptr IWICBitmapSource, prc: ptr WICRect, cbStride: UINT, cbBufferSize: UINT, pbBuffer: ptr BYTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyPixels(self, prc, cbStride, cbBufferSize, pbBuffer) +proc GetSize*(self: ptr IWICBitmapLock, pWidth: ptr UINT, pHeight: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSize(self, pWidth, pHeight) +proc GetStride*(self: ptr IWICBitmapLock, pcbStride: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetStride(self, pcbStride) +proc GetDataPointer*(self: ptr IWICBitmapLock, pcbBufferSize: ptr UINT, ppbData: ptr ptr BYTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDataPointer(self, pcbBufferSize, ppbData) +proc GetPixelFormat*(self: ptr IWICBitmapLock, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPixelFormat(self, pPixelFormat) +proc Initialize*(self: ptr IWICBitmapFlipRotator, pISource: ptr IWICBitmapSource, options: WICBitmapTransformOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pISource, options) +proc Lock*(self: ptr IWICBitmap, prcLock: ptr WICRect, flags: DWORD, ppILock: ptr ptr IWICBitmapLock): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Lock(self, prcLock, flags, ppILock) +proc SetPalette*(self: ptr IWICBitmap, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPalette(self, pIPalette) +proc SetResolution*(self: ptr IWICBitmap, dpiX: float64, dpiY: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetResolution(self, dpiX, dpiY) +proc InitializePredefined*(self: ptr IWICPalette, ePaletteType: WICBitmapPaletteType, fAddTransparentColor: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializePredefined(self, ePaletteType, fAddTransparentColor) +proc InitializeCustom*(self: ptr IWICPalette, pColors: ptr WICColor, colorCount: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeCustom(self, pColors, colorCount) +proc InitializeFromBitmap*(self: ptr IWICPalette, pISurface: ptr IWICBitmapSource, colorCount: UINT, fAddTransparentColor: WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromBitmap(self, pISurface, colorCount, fAddTransparentColor) +proc InitializeFromPalette*(self: ptr IWICPalette, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromPalette(self, pIPalette) +proc GetType*(self: ptr IWICPalette, pePaletteType: ptr WICBitmapPaletteType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetType(self, pePaletteType) +proc GetColorCount*(self: ptr IWICPalette, pcCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorCount(self, pcCount) +proc GetColors*(self: ptr IWICPalette, colorCount: UINT, pColors: ptr WICColor, pcActualColors: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColors(self, colorCount, pColors, pcActualColors) +proc IsBlackWhite*(self: ptr IWICPalette, pfIsBlackWhite: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsBlackWhite(self, pfIsBlackWhite) +proc IsGrayscale*(self: ptr IWICPalette, pfIsGrayscale: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.IsGrayscale(self, pfIsGrayscale) +proc HasAlpha*(self: ptr IWICPalette, pfHasAlpha: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.HasAlpha(self, pfHasAlpha) +proc GetComponentType*(self: ptr IWICComponentInfo, pType: ptr WICComponentType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetComponentType(self, pType) +proc GetCLSID*(self: ptr IWICComponentInfo, pclsid: ptr CLSID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetCLSID(self, pclsid) +proc GetSigningStatus*(self: ptr IWICComponentInfo, pStatus: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSigningStatus(self, pStatus) +proc GetAuthor*(self: ptr IWICComponentInfo, cchAuthor: UINT, wzAuthor: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetAuthor(self, cchAuthor, wzAuthor, pcchActual) +proc GetVendorGUID*(self: ptr IWICComponentInfo, pguidVendor: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVendorGUID(self, pguidVendor) +proc GetVersion*(self: ptr IWICComponentInfo, cchVersion: UINT, wzVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetVersion(self, cchVersion, wzVersion, pcchActual) +proc GetSpecVersion*(self: ptr IWICComponentInfo, cchSpecVersion: UINT, wzSpecVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetSpecVersion(self, cchSpecVersion, wzSpecVersion, pcchActual) +proc GetFriendlyName*(self: ptr IWICComponentInfo, cchFriendlyName: UINT, wzFriendlyName: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFriendlyName(self, cchFriendlyName, wzFriendlyName, pcchActual) +proc GetContainerFormat*(self: ptr IWICMetadataQueryReader, pguidContainerFormat: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainerFormat(self, pguidContainerFormat) +proc GetLocation*(self: ptr IWICMetadataQueryReader, cchMaxLength: UINT, wzNamespace: ptr WCHAR, pcchActualLength: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetLocation(self, cchMaxLength, wzNamespace, pcchActualLength) +proc GetMetadataByName*(self: ptr IWICMetadataQueryReader, wzName: LPCWSTR, pvarValue: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataByName(self, wzName, pvarValue) +proc GetEnumerator*(self: ptr IWICMetadataQueryReader, ppIEnumString: ptr ptr IEnumString): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEnumerator(self, ppIEnumString) +proc SetMetadataByName*(self: ptr IWICMetadataQueryWriter, wzName: LPCWSTR, pvarValue: ptr PROPVARIANT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetMetadataByName(self, wzName, pvarValue) +proc RemoveMetadataByName*(self: ptr IWICMetadataQueryWriter, wzName: LPCWSTR): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.RemoveMetadataByName(self, wzName) +proc GetMetadataQueryReader*(self: ptr IWICBitmapFrameDecode, ppIMetadataQueryReader: ptr ptr IWICMetadataQueryReader): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataQueryReader(self, ppIMetadataQueryReader) +proc GetColorContexts*(self: ptr IWICBitmapFrameDecode, cCount: UINT, ppIColorContexts: ptr ptr IWICColorContext, pcActualCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorContexts(self, cCount, ppIColorContexts, pcActualCount) +proc GetThumbnail*(self: ptr IWICBitmapFrameDecode, ppIThumbnail: ptr ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetThumbnail(self, ppIThumbnail) +proc GetFormatGUID*(self: ptr IWICPixelFormatInfo, pFormat: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFormatGUID(self, pFormat) +proc GetColorContext*(self: ptr IWICPixelFormatInfo, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorContext(self, ppIColorContext) +proc GetBitsPerPixel*(self: ptr IWICPixelFormatInfo, puiBitsPerPixel: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetBitsPerPixel(self, puiBitsPerPixel) +proc GetChannelCount*(self: ptr IWICPixelFormatInfo, puiChannelCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChannelCount(self, puiChannelCount) +proc GetChannelMask*(self: ptr IWICPixelFormatInfo, uiChannelIndex: UINT, cbMaskBuffer: UINT, pbMaskBuffer: ptr BYTE, pcbActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetChannelMask(self, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual) +proc SupportsTransparency*(self: ptr IWICPixelFormatInfo2, pfSupportsTransparency: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SupportsTransparency(self, pfSupportsTransparency) +proc GetNumericRepresentation*(self: ptr IWICPixelFormatInfo2, pNumericRepresentation: ptr WICPixelFormatNumericRepresentation): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetNumericRepresentation(self, pNumericRepresentation) +proc GetContainerFormat*(self: ptr IWICBitmapCodecInfo, pguidContainerFormat: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainerFormat(self, pguidContainerFormat) +proc GetPixelFormats*(self: ptr IWICBitmapCodecInfo, cFormats: UINT, pguidPixelFormats: ptr GUID, pcActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPixelFormats(self, cFormats, pguidPixelFormats, pcActual) +proc GetColorManagementVersion*(self: ptr IWICBitmapCodecInfo, cchColorManagementVersion: UINT, wzColorManagementVersion: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorManagementVersion(self, cchColorManagementVersion, wzColorManagementVersion, pcchActual) +proc GetDeviceManufacturer*(self: ptr IWICBitmapCodecInfo, cchDeviceManufacturer: UINT, wzDeviceManufacturer: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDeviceManufacturer(self, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual) +proc GetDeviceModels*(self: ptr IWICBitmapCodecInfo, cchDeviceModels: UINT, wzDeviceModels: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDeviceModels(self, cchDeviceModels, wzDeviceModels, pcchActual) +proc GetMimeTypes*(self: ptr IWICBitmapCodecInfo, cchMimeTypes: UINT, wzMimeTypes: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMimeTypes(self, cchMimeTypes, wzMimeTypes, pcchActual) +proc GetFileExtensions*(self: ptr IWICBitmapCodecInfo, cchFileExtensions: UINT, wzFileExtensions: ptr WCHAR, pcchActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFileExtensions(self, cchFileExtensions, wzFileExtensions, pcchActual) +proc DoesSupportAnimation*(self: ptr IWICBitmapCodecInfo, pfSupportAnimation: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoesSupportAnimation(self, pfSupportAnimation) +proc DoesSupportChromaKey*(self: ptr IWICBitmapCodecInfo, pfSupportChromaKey: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoesSupportChromaKey(self, pfSupportChromaKey) +proc DoesSupportLossless*(self: ptr IWICBitmapCodecInfo, pfSupportLossless: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoesSupportLossless(self, pfSupportLossless) +proc DoesSupportMultiframe*(self: ptr IWICBitmapCodecInfo, pfSupportMultiframe: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.DoesSupportMultiframe(self, pfSupportMultiframe) +proc MatchesMimeType*(self: ptr IWICBitmapCodecInfo, wzMimeType: LPCWSTR, pfMatches: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MatchesMimeType(self, wzMimeType, pfMatches) +proc GetPatterns*(self: ptr IWICBitmapDecoderInfo, cbSizePatterns: UINT, pPatterns: ptr WICBitmapPattern, pcPatterns: ptr UINT, pcbPatternsActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPatterns(self, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual) +proc MatchesPattern*(self: ptr IWICBitmapDecoderInfo, pIStream: ptr IStream, pfMatches: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.MatchesPattern(self, pIStream, pfMatches) +proc CreateInstance*(self: ptr IWICBitmapDecoderInfo, ppIBitmapDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, ppIBitmapDecoder) +proc QueryCapability*(self: ptr IWICBitmapDecoder, pIStream: ptr IStream, pdwCapability: ptr DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.QueryCapability(self, pIStream, pdwCapability) +proc Initialize*(self: ptr IWICBitmapDecoder, pIStream: ptr IStream, cacheOptions: WICDecodeOptions): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pIStream, cacheOptions) +proc GetContainerFormat*(self: ptr IWICBitmapDecoder, pguidContainerFormat: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainerFormat(self, pguidContainerFormat) +proc GetDecoderInfo*(self: ptr IWICBitmapDecoder, ppIDecoderInfo: ptr ptr IWICBitmapDecoderInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetDecoderInfo(self, ppIDecoderInfo) +proc CopyPalette*(self: ptr IWICBitmapDecoder, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CopyPalette(self, pIPalette) +proc GetMetadataQueryReader*(self: ptr IWICBitmapDecoder, ppIMetadataQueryReader: ptr ptr IWICMetadataQueryReader): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataQueryReader(self, ppIMetadataQueryReader) +proc GetPreview*(self: ptr IWICBitmapDecoder, ppIBitmapSource: ptr ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPreview(self, ppIBitmapSource) +proc GetColorContexts*(self: ptr IWICBitmapDecoder, cCount: UINT, ppIColorContexts: ptr ptr IWICColorContext, pcActualCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetColorContexts(self, cCount, ppIColorContexts, pcActualCount) +proc GetThumbnail*(self: ptr IWICBitmapDecoder, ppIThumbnail: ptr ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetThumbnail(self, ppIThumbnail) +proc GetFrameCount*(self: ptr IWICBitmapDecoder, pCount: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFrameCount(self, pCount) +proc GetFrame*(self: ptr IWICBitmapDecoder, index: UINT, ppIBitmapFrame: ptr ptr IWICBitmapFrameDecode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetFrame(self, index, ppIBitmapFrame) +proc Initialize*(self: ptr IWICBitmapFrameEncode, pIEncoderOptions: ptr IPropertyBag2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pIEncoderOptions) +proc SetSize*(self: ptr IWICBitmapFrameEncode, uiWidth: UINT, uiHeight: UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetSize(self, uiWidth, uiHeight) +proc SetResolution*(self: ptr IWICBitmapFrameEncode, dpiX: float64, dpiY: float64): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetResolution(self, dpiX, dpiY) +proc SetPixelFormat*(self: ptr IWICBitmapFrameEncode, pPixelFormat: ptr WICPixelFormatGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPixelFormat(self, pPixelFormat) +proc SetColorContexts*(self: ptr IWICBitmapFrameEncode, cCount: UINT, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColorContexts(self, cCount, ppIColorContext) +proc SetPalette*(self: ptr IWICBitmapFrameEncode, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPalette(self, pIPalette) +proc SetThumbnail*(self: ptr IWICBitmapFrameEncode, pIThumbnail: ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThumbnail(self, pIThumbnail) +proc WritePixels*(self: ptr IWICBitmapFrameEncode, lineCount: UINT, cbStride: UINT, cbBufferSize: UINT, pbPixels: ptr BYTE): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WritePixels(self, lineCount, cbStride, cbBufferSize, pbPixels) +proc WriteSource*(self: ptr IWICBitmapFrameEncode, pIBitmapSource: ptr IWICBitmapSource, prc: ptr WICRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.WriteSource(self, pIBitmapSource, prc) +proc Commit*(self: ptr IWICBitmapFrameEncode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self) +proc GetMetadataQueryWriter*(self: ptr IWICBitmapFrameEncode, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataQueryWriter(self, ppIMetadataQueryWriter) +proc CreateInstance*(self: ptr IWICBitmapEncoderInfo, ppIBitmapEncoder: ptr ptr IWICBitmapEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, ppIBitmapEncoder) +proc Initialize*(self: ptr IWICBitmapEncoder, pIStream: ptr IStream, cacheOption: WICBitmapEncoderCacheOption): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pIStream, cacheOption) +proc GetContainerFormat*(self: ptr IWICBitmapEncoder, pguidContainerFormat: ptr GUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetContainerFormat(self, pguidContainerFormat) +proc GetEncoderInfo*(self: ptr IWICBitmapEncoder, ppIEncoderInfo: ptr ptr IWICBitmapEncoderInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetEncoderInfo(self, ppIEncoderInfo) +proc SetColorContexts*(self: ptr IWICBitmapEncoder, cCount: UINT, ppIColorContext: ptr ptr IWICColorContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetColorContexts(self, cCount, ppIColorContext) +proc SetPalette*(self: ptr IWICBitmapEncoder, pIPalette: ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPalette(self, pIPalette) +proc SetThumbnail*(self: ptr IWICBitmapEncoder, pIThumbnail: ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetThumbnail(self, pIThumbnail) +proc SetPreview*(self: ptr IWICBitmapEncoder, pIPreview: ptr IWICBitmapSource): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.SetPreview(self, pIPreview) +proc CreateNewFrame*(self: ptr IWICBitmapEncoder, ppIFrameEncode: ptr ptr IWICBitmapFrameEncode, ppIEncoderOptions: ptr ptr IPropertyBag2): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateNewFrame(self, ppIFrameEncode, ppIEncoderOptions) +proc Commit*(self: ptr IWICBitmapEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self) +proc GetMetadataQueryWriter*(self: ptr IWICBitmapEncoder, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataQueryWriter(self, ppIMetadataQueryWriter) +proc Initialize*(self: ptr IWICFormatConverter, pISource: ptr IWICBitmapSource, dstFormat: REFWICPixelFormatGUID, dither: WICBitmapDitherType, pIPalette: ptr IWICPalette, alphaThresholdPercent: float64, paletteTranslate: WICBitmapPaletteType): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate) +proc CanConvert*(self: ptr IWICFormatConverter, srcPixelFormat: REFWICPixelFormatGUID, dstPixelFormat: REFWICPixelFormatGUID, pfCanConvert: ptr WINBOOL): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CanConvert(self, srcPixelFormat, dstPixelFormat, pfCanConvert) +proc GetPixelFormats*(self: ptr IWICFormatConverterInfo, cFormats: UINT, pPixelFormatGUIDs: ptr WICPixelFormatGUID, pcActual: ptr UINT): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetPixelFormats(self, cFormats, pPixelFormatGUIDs, pcActual) +proc CreateInstance*(self: ptr IWICFormatConverterInfo, ppIConverter: ptr ptr IWICFormatConverter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateInstance(self, ppIConverter) +proc InitializeFromIStream*(self: ptr IWICStream, pIStream: ptr IStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromIStream(self, pIStream) +proc InitializeFromFilename*(self: ptr IWICStream, wzFileName: LPCWSTR, dwAccessMode: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromFilename(self, wzFileName, dwAccessMode) +proc InitializeFromMemory*(self: ptr IWICStream, pbBuffer: ptr BYTE, cbBufferSize: DWORD): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromMemory(self, pbBuffer, cbBufferSize) +proc InitializeFromIStreamRegion*(self: ptr IWICStream, pIStream: ptr IStream, ulOffset: ULARGE_INTEGER, ulMaxSize: ULARGE_INTEGER): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.InitializeFromIStreamRegion(self, pIStream, ulOffset, ulMaxSize) +proc Initialize*(self: ptr IWICBitmapScaler, pISource: ptr IWICBitmapSource, uiWidth: UINT, uiHeight: UINT, mode: WICBitmapInterpolationMode): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pISource, uiWidth, uiHeight, mode) +proc Initialize*(self: ptr IWICBitmapClipper, pISource: ptr IWICBitmapSource, prc: ptr WICRect): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pISource, prc) +proc Initialize*(self: ptr IWICColorTransform, pIBitmapSource: ptr IWICBitmapSource, pIContextSource: ptr IWICColorContext, pIContextDest: ptr IWICColorContext, pixelFmtDest: REFWICPixelFormatGUID): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Initialize(self, pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDest) +proc Commit*(self: ptr IWICFastMetadataEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Commit(self) +proc GetMetadataQueryWriter*(self: ptr IWICFastMetadataEncoder, ppIMetadataQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.GetMetadataQueryWriter(self, ppIMetadataQueryWriter) +proc CreateDecoderFromFilename*(self: ptr IWICImagingFactory, wzFilename: LPCWSTR, pguidVendor: ptr GUID, dwDesiredAccess: DWORD, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDecoderFromFilename(self, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder) +proc CreateDecoderFromStream*(self: ptr IWICImagingFactory, pIStream: ptr IStream, pguidVendor: ptr GUID, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDecoderFromStream(self, pIStream, pguidVendor, metadataOptions, ppIDecoder) +proc CreateDecoderFromFileHandle*(self: ptr IWICImagingFactory, hFile: ULONG_PTR, pguidVendor: ptr GUID, metadataOptions: WICDecodeOptions, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDecoderFromFileHandle(self, hFile, pguidVendor, metadataOptions, ppIDecoder) +proc CreateComponentInfo*(self: ptr IWICImagingFactory, clsidComponent: REFCLSID, ppIInfo: ptr ptr IWICComponentInfo): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateComponentInfo(self, clsidComponent, ppIInfo) +proc CreateDecoder*(self: ptr IWICImagingFactory, guidContainerFormat: REFGUID, pguidVendor: ptr GUID, ppIDecoder: ptr ptr IWICBitmapDecoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateDecoder(self, guidContainerFormat, pguidVendor, ppIDecoder) +proc CreateEncoder*(self: ptr IWICImagingFactory, guidContainerFormat: REFGUID, pguidVendor: ptr GUID, ppIEncoder: ptr ptr IWICBitmapEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateEncoder(self, guidContainerFormat, pguidVendor, ppIEncoder) +proc CreatePalette*(self: ptr IWICImagingFactory, ppIPalette: ptr ptr IWICPalette): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreatePalette(self, ppIPalette) +proc CreateFormatConverter*(self: ptr IWICImagingFactory, ppIFormatConverter: ptr ptr IWICFormatConverter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateFormatConverter(self, ppIFormatConverter) +proc CreateBitmapScaler*(self: ptr IWICImagingFactory, ppIBitmapScaler: ptr ptr IWICBitmapScaler): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapScaler(self, ppIBitmapScaler) +proc CreateBitmapClipper*(self: ptr IWICImagingFactory, ppIBitmapClipper: ptr ptr IWICBitmapClipper): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapClipper(self, ppIBitmapClipper) +proc CreateBitmapFlipRotator*(self: ptr IWICImagingFactory, ppIBitmapFlipRotator: ptr ptr IWICBitmapFlipRotator): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFlipRotator(self, ppIBitmapFlipRotator) +proc CreateStream*(self: ptr IWICImagingFactory, ppIWICStream: ptr ptr IWICStream): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateStream(self, ppIWICStream) +proc CreateColorContext*(self: ptr IWICImagingFactory, ppIWICColorContext: ptr ptr IWICColorContext): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateColorContext(self, ppIWICColorContext) +proc CreateColorTransformer*(self: ptr IWICImagingFactory, ppIWICColorTransform: ptr ptr IWICColorTransform): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateColorTransformer(self, ppIWICColorTransform) +proc CreateBitmap*(self: ptr IWICImagingFactory, uiWidth: UINT, uiHeight: UINT, pixelFormat: REFWICPixelFormatGUID, option: WICBitmapCreateCacheOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmap(self, uiWidth, uiHeight, pixelFormat, option, ppIBitmap) +proc CreateBitmapFromSource*(self: ptr IWICImagingFactory, piBitmapSource: ptr IWICBitmapSource, option: WICBitmapCreateCacheOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFromSource(self, piBitmapSource, option, ppIBitmap) +proc CreateBitmapFromSourceRect*(self: ptr IWICImagingFactory, piBitmapSource: ptr IWICBitmapSource, x: UINT, y: UINT, width: UINT, height: UINT, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFromSourceRect(self, piBitmapSource, x, y, width, height, ppIBitmap) +proc CreateBitmapFromMemory*(self: ptr IWICImagingFactory, uiWidth: UINT, uiHeight: UINT, pixelFormat: REFWICPixelFormatGUID, cbStride: UINT, cbBufferSize: UINT, pbBuffer: ptr BYTE, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFromMemory(self, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap) +proc CreateBitmapFromHBITMAP*(self: ptr IWICImagingFactory, hBitmap: HBITMAP, hPalette: HPALETTE, options: WICBitmapAlphaChannelOption, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFromHBITMAP(self, hBitmap, hPalette, options, ppIBitmap) +proc CreateBitmapFromHICON*(self: ptr IWICImagingFactory, hIcon: HICON, ppIBitmap: ptr ptr IWICBitmap): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateBitmapFromHICON(self, hIcon, ppIBitmap) +proc CreateComponentEnumerator*(self: ptr IWICImagingFactory, componentTypes: DWORD, options: DWORD, ppIEnumUnknown: ptr ptr IEnumUnknown): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateComponentEnumerator(self, componentTypes, options, ppIEnumUnknown) +proc CreateFastMetadataEncoderFromDecoder*(self: ptr IWICImagingFactory, pIDecoder: ptr IWICBitmapDecoder, ppIFastEncoder: ptr ptr IWICFastMetadataEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateFastMetadataEncoderFromDecoder(self, pIDecoder, ppIFastEncoder) +proc CreateFastMetadataEncoderFromFrameDecode*(self: ptr IWICImagingFactory, pIFrameDecoder: ptr IWICBitmapFrameDecode, ppIFastEncoder: ptr ptr IWICFastMetadataEncoder): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateFastMetadataEncoderFromFrameDecode(self, pIFrameDecoder, ppIFastEncoder) +proc CreateQueryWriter*(self: ptr IWICImagingFactory, guidMetadataFormat: REFGUID, pguidVendor: ptr GUID, ppIQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateQueryWriter(self, guidMetadataFormat, pguidVendor, ppIQueryWriter) +proc CreateQueryWriterFromReader*(self: ptr IWICImagingFactory, pIQueryReader: ptr IWICMetadataQueryReader, pguidVendor: ptr GUID, ppIQueryWriter: ptr ptr IWICMetadataQueryWriter): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.CreateQueryWriterFromReader(self, pIQueryReader, pguidVendor, ppIQueryWriter) +proc Next*(self: ptr IWICEnumMetadataItem, celt: ULONG, rgeltSchema: ptr PROPVARIANT, rgeltId: ptr PROPVARIANT, rgeltValue: ptr PROPVARIANT, pceltFetched: ptr ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Next(self, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched) +proc Skip*(self: ptr IWICEnumMetadataItem, celt: ULONG): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Skip(self, celt) +proc Reset*(self: ptr IWICEnumMetadataItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Reset(self) +proc Clone*(self: ptr IWICEnumMetadataItem, ppIEnumMetadataItem: ptr ptr IWICEnumMetadataItem): HRESULT {.winapi, inline.} = {.gcsafe.}: self.lpVtbl.Clone(self, ppIEnumMetadataItem) +converter winimConverterIWICColorContextToIUnknown*(x: ptr IWICColorContext): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapSourceToIUnknown*(x: ptr IWICBitmapSource): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapLockToIUnknown*(x: ptr IWICBitmapLock): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapFlipRotatorToIWICBitmapSource*(x: ptr IWICBitmapFlipRotator): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICBitmapFlipRotatorToIUnknown*(x: ptr IWICBitmapFlipRotator): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapToIWICBitmapSource*(x: ptr IWICBitmap): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICBitmapToIUnknown*(x: ptr IWICBitmap): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICPaletteToIUnknown*(x: ptr IWICPalette): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICComponentInfoToIUnknown*(x: ptr IWICComponentInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICMetadataQueryReaderToIUnknown*(x: ptr IWICMetadataQueryReader): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICMetadataQueryWriterToIWICMetadataQueryReader*(x: ptr IWICMetadataQueryWriter): ptr IWICMetadataQueryReader = cast[ptr IWICMetadataQueryReader](x) +converter winimConverterIWICMetadataQueryWriterToIUnknown*(x: ptr IWICMetadataQueryWriter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapFrameDecodeToIWICBitmapSource*(x: ptr IWICBitmapFrameDecode): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICBitmapFrameDecodeToIUnknown*(x: ptr IWICBitmapFrameDecode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICPixelFormatInfoToIWICComponentInfo*(x: ptr IWICPixelFormatInfo): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICPixelFormatInfoToIUnknown*(x: ptr IWICPixelFormatInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICPixelFormatInfo2ToIWICPixelFormatInfo*(x: ptr IWICPixelFormatInfo2): ptr IWICPixelFormatInfo = cast[ptr IWICPixelFormatInfo](x) +converter winimConverterIWICPixelFormatInfo2ToIWICComponentInfo*(x: ptr IWICPixelFormatInfo2): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICPixelFormatInfo2ToIUnknown*(x: ptr IWICPixelFormatInfo2): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapCodecInfoToIWICComponentInfo*(x: ptr IWICBitmapCodecInfo): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICBitmapCodecInfoToIUnknown*(x: ptr IWICBitmapCodecInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapDecoderInfoToIWICBitmapCodecInfo*(x: ptr IWICBitmapDecoderInfo): ptr IWICBitmapCodecInfo = cast[ptr IWICBitmapCodecInfo](x) +converter winimConverterIWICBitmapDecoderInfoToIWICComponentInfo*(x: ptr IWICBitmapDecoderInfo): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICBitmapDecoderInfoToIUnknown*(x: ptr IWICBitmapDecoderInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapDecoderToIUnknown*(x: ptr IWICBitmapDecoder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapFrameEncodeToIUnknown*(x: ptr IWICBitmapFrameEncode): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapEncoderInfoToIWICBitmapCodecInfo*(x: ptr IWICBitmapEncoderInfo): ptr IWICBitmapCodecInfo = cast[ptr IWICBitmapCodecInfo](x) +converter winimConverterIWICBitmapEncoderInfoToIWICComponentInfo*(x: ptr IWICBitmapEncoderInfo): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICBitmapEncoderInfoToIUnknown*(x: ptr IWICBitmapEncoderInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapEncoderToIUnknown*(x: ptr IWICBitmapEncoder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICFormatConverterToIWICBitmapSource*(x: ptr IWICFormatConverter): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICFormatConverterToIUnknown*(x: ptr IWICFormatConverter): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICFormatConverterInfoToIWICComponentInfo*(x: ptr IWICFormatConverterInfo): ptr IWICComponentInfo = cast[ptr IWICComponentInfo](x) +converter winimConverterIWICFormatConverterInfoToIUnknown*(x: ptr IWICFormatConverterInfo): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICStreamToIStream*(x: ptr IWICStream): ptr IStream = cast[ptr IStream](x) +converter winimConverterIWICStreamToISequentialStream*(x: ptr IWICStream): ptr ISequentialStream = cast[ptr ISequentialStream](x) +converter winimConverterIWICStreamToIUnknown*(x: ptr IWICStream): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapScalerToIWICBitmapSource*(x: ptr IWICBitmapScaler): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICBitmapScalerToIUnknown*(x: ptr IWICBitmapScaler): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICBitmapClipperToIWICBitmapSource*(x: ptr IWICBitmapClipper): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICBitmapClipperToIUnknown*(x: ptr IWICBitmapClipper): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICColorTransformToIWICBitmapSource*(x: ptr IWICColorTransform): ptr IWICBitmapSource = cast[ptr IWICBitmapSource](x) +converter winimConverterIWICColorTransformToIUnknown*(x: ptr IWICColorTransform): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICFastMetadataEncoderToIUnknown*(x: ptr IWICFastMetadataEncoder): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICImagingFactoryToIUnknown*(x: ptr IWICImagingFactory): ptr IUnknown = cast[ptr IUnknown](x) +converter winimConverterIWICEnumMetadataItemToIUnknown*(x: ptr IWICEnumMetadataItem): ptr IUnknown = cast[ptr IUnknown](x) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wincon.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wincon.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,314 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import wingdi +#include +type + COORD* {.pure.} = object + X*: SHORT + Y*: SHORT + PCOORD* = ptr COORD + SMALL_RECT* {.pure.} = object + Left*: SHORT + Top*: SHORT + Right*: SHORT + Bottom*: SHORT + PSMALL_RECT* = ptr SMALL_RECT + KEY_EVENT_RECORD_uChar* {.pure, union.} = object + UnicodeChar*: WCHAR + AsciiChar*: CHAR + KEY_EVENT_RECORD* {.pure.} = object + bKeyDown*: WINBOOL + wRepeatCount*: WORD + wVirtualKeyCode*: WORD + wVirtualScanCode*: WORD + uChar*: KEY_EVENT_RECORD_uChar + dwControlKeyState*: DWORD + PKEY_EVENT_RECORD* = ptr KEY_EVENT_RECORD + MOUSE_EVENT_RECORD* {.pure.} = object + dwMousePosition*: COORD + dwButtonState*: DWORD + dwControlKeyState*: DWORD + dwEventFlags*: DWORD + PMOUSE_EVENT_RECORD* = ptr MOUSE_EVENT_RECORD + WINDOW_BUFFER_SIZE_RECORD* {.pure.} = object + dwSize*: COORD + PWINDOW_BUFFER_SIZE_RECORD* = ptr WINDOW_BUFFER_SIZE_RECORD + MENU_EVENT_RECORD* {.pure.} = object + dwCommandId*: UINT + PMENU_EVENT_RECORD* = ptr MENU_EVENT_RECORD + FOCUS_EVENT_RECORD* {.pure.} = object + bSetFocus*: WINBOOL + PFOCUS_EVENT_RECORD* = ptr FOCUS_EVENT_RECORD + INPUT_RECORD_Event* {.pure, union.} = object + KeyEvent*: KEY_EVENT_RECORD + MouseEvent*: MOUSE_EVENT_RECORD + WindowBufferSizeEvent*: WINDOW_BUFFER_SIZE_RECORD + MenuEvent*: MENU_EVENT_RECORD + FocusEvent*: FOCUS_EVENT_RECORD + INPUT_RECORD* {.pure.} = object + EventType*: WORD + Event*: INPUT_RECORD_Event + PINPUT_RECORD* = ptr INPUT_RECORD + CHAR_INFO_Char* {.pure, union.} = object + UnicodeChar*: WCHAR + AsciiChar*: CHAR + CHAR_INFO* {.pure.} = object + Char*: CHAR_INFO_Char + Attributes*: WORD + PCHAR_INFO* = ptr CHAR_INFO + CONSOLE_SCREEN_BUFFER_INFO* {.pure.} = object + dwSize*: COORD + dwCursorPosition*: COORD + wAttributes*: WORD + srWindow*: SMALL_RECT + dwMaximumWindowSize*: COORD + PCONSOLE_SCREEN_BUFFER_INFO* = ptr CONSOLE_SCREEN_BUFFER_INFO + CONSOLE_CURSOR_INFO* {.pure.} = object + dwSize*: DWORD + bVisible*: WINBOOL + PCONSOLE_CURSOR_INFO* = ptr CONSOLE_CURSOR_INFO + CONSOLE_FONT_INFO* {.pure.} = object + nFont*: DWORD + dwFontSize*: COORD + PCONSOLE_FONT_INFO* = ptr CONSOLE_FONT_INFO + CONSOLE_SELECTION_INFO* {.pure.} = object + dwFlags*: DWORD + dwSelectionAnchor*: COORD + srSelection*: SMALL_RECT + PCONSOLE_SELECTION_INFO* = ptr CONSOLE_SELECTION_INFO + CONSOLE_FONT_INFOEX* {.pure.} = object + cbSize*: ULONG + nFont*: DWORD + dwFontSize*: COORD + FontFamily*: UINT + FontWeight*: UINT + FaceName*: array[LF_FACESIZE, WCHAR] + PCONSOLE_FONT_INFOEX* = ptr CONSOLE_FONT_INFOEX + CONSOLE_HISTORY_INFO* {.pure.} = object + cbSize*: UINT + HistoryBufferSize*: UINT + NumberOfHistoryBuffers*: UINT + dwFlags*: DWORD + PCONSOLE_HISTORY_INFO* = ptr CONSOLE_HISTORY_INFO + CONSOLE_READCONSOLE_CONTROL* {.pure.} = object + nLength*: ULONG + nInitialChars*: ULONG + dwCtrlWakeupMask*: ULONG + dwControlKeyState*: ULONG + PCONSOLE_READCONSOLE_CONTROL* = ptr CONSOLE_READCONSOLE_CONTROL + CONSOLE_SCREEN_BUFFER_INFOEX* {.pure.} = object + cbSize*: ULONG + dwSize*: COORD + dwCursorPosition*: COORD + wAttributes*: WORD + srWindow*: SMALL_RECT + dwMaximumWindowSize*: COORD + wPopupAttributes*: WORD + bFullscreenSupported*: WINBOOL + ColorTable*: array[16, COLORREF] + PCONSOLE_SCREEN_BUFFER_INFOEX* = ptr CONSOLE_SCREEN_BUFFER_INFOEX +const + RIGHT_ALT_PRESSED* = 0x1 + LEFT_ALT_PRESSED* = 0x2 + RIGHT_CTRL_PRESSED* = 0x4 + LEFT_CTRL_PRESSED* = 0x8 + SHIFT_PRESSED* = 0x10 + NUMLOCK_ON* = 0x20 + SCROLLLOCK_ON* = 0x40 + CAPSLOCK_ON* = 0x80 + ENHANCED_KEY* = 0x100 + NLS_DBCSCHAR* = 0x10000 + NLS_ALPHANUMERIC* = 0x0 + NLS_KATAKANA* = 0x20000 + NLS_HIRAGANA* = 0x40000 + NLS_ROMAN* = 0x400000 + NLS_IME_CONVERSION* = 0x800000 + NLS_IME_DISABLE* = 0x20000000 + FROM_LEFT_1ST_BUTTON_PRESSED* = 0x1 + RIGHTMOST_BUTTON_PRESSED* = 0x2 + FROM_LEFT_2ND_BUTTON_PRESSED* = 0x4 + FROM_LEFT_3RD_BUTTON_PRESSED* = 0x8 + FROM_LEFT_4TH_BUTTON_PRESSED* = 0x10 + MOUSE_MOVED* = 0x1 + DOUBLE_CLICK* = 0x2 + MOUSE_WHEELED* = 0x4 + MOUSE_HWHEELED* = 0x8 + KEY_EVENT* = 0x1 + MOUSE_EVENT* = 0x2 + WINDOW_BUFFER_SIZE_EVENT* = 0x4 + MENU_EVENT* = 0x8 + FOCUS_EVENT* = 0x10 + FOREGROUND_BLUE* = 0x1 + FOREGROUND_GREEN* = 0x2 + FOREGROUND_RED* = 0x4 + FOREGROUND_INTENSITY* = 0x8 + BACKGROUND_BLUE* = 0x10 + BACKGROUND_GREEN* = 0x20 + BACKGROUND_RED* = 0x40 + BACKGROUND_INTENSITY* = 0x80 + COMMON_LVB_LEADING_BYTE* = 0x100 + COMMON_LVB_TRAILING_BYTE* = 0x200 + COMMON_LVB_GRID_HORIZONTAL* = 0x400 + COMMON_LVB_GRID_LVERTICAL* = 0x800 + COMMON_LVB_GRID_RVERTICAL* = 0x1000 + COMMON_LVB_REVERSE_VIDEO* = 0x4000 + COMMON_LVB_UNDERSCORE* = 0x8000 + COMMON_LVB_SBCSDBCS* = 0x300 + CONSOLE_NO_SELECTION* = 0x0 + CONSOLE_SELECTION_IN_PROGRESS* = 0x1 + CONSOLE_SELECTION_NOT_EMPTY* = 0x2 + CONSOLE_MOUSE_SELECTION* = 0x4 + CONSOLE_MOUSE_DOWN* = 0x8 + CTRL_C_EVENT* = 0 + CTRL_BREAK_EVENT* = 1 + CTRL_CLOSE_EVENT* = 2 + CTRL_LOGOFF_EVENT* = 5 + CTRL_SHUTDOWN_EVENT* = 6 + ENABLE_PROCESSED_INPUT* = 0x1 + ENABLE_LINE_INPUT* = 0x2 + ENABLE_ECHO_INPUT* = 0x4 + ENABLE_WINDOW_INPUT* = 0x8 + ENABLE_MOUSE_INPUT* = 0x10 + ENABLE_INSERT_MODE* = 0x20 + ENABLE_QUICK_EDIT_MODE* = 0x40 + ENABLE_EXTENDED_FLAGS* = 0x80 + ENABLE_AUTO_POSITION* = 0x100 + ENABLE_PROCESSED_OUTPUT* = 0x1 + ENABLE_WRAP_AT_EOL_OUTPUT* = 0x2 + ATTACH_PARENT_PROCESS* = DWORD(-1) + CONSOLE_TEXTMODE_BUFFER* = 1 + CONSOLE_FULLSCREEN* = 1 + CONSOLE_FULLSCREEN_HARDWARE* = 2 + CONSOLE_FULLSCREEN_MODE* = 1 + CONSOLE_WINDOWED_MODE* = 2 +type + PHANDLER_ROUTINE* = proc (CtrlType: DWORD): WINBOOL {.stdcall.} +proc PeekConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc PeekConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: ptr INPUT_RECORD, nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: ptr INPUT_RECORD, nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleOutputA*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleOutputW*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleOutputA*(hConsoleOutput: HANDLE, lpBuffer: ptr CHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleOutputW*(hConsoleOutput: HANDLE, lpBuffer: ptr CHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleOutputCharacterA*(hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleOutputCharacterW*(hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleOutputAttribute*(hConsoleOutput: HANDLE, lpAttribute: LPWORD, nLength: DWORD, dwReadCoord: COORD, lpNumberOfAttrsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleOutputCharacterA*(hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleOutputCharacterW*(hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleOutputAttribute*(hConsoleOutput: HANDLE, lpAttribute: ptr WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FillConsoleOutputCharacterA*(hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FillConsoleOutputCharacterW*(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FillConsoleOutputAttribute*(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleMode*(hConsoleHandle: HANDLE, lpMode: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumberOfConsoleInputEvents*(hConsoleInput: HANDLE, lpNumberOfEvents: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleScreenBufferInfo*(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLargestConsoleWindowSize*(hConsoleOutput: HANDLE): COORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleCursorInfo*(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentConsoleFont*(hConsoleOutput: HANDLE, bMaximumWindow: WINBOOL, lpConsoleCurrentFont: PCONSOLE_FONT_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleFontSize*(hConsoleOutput: HANDLE, nFont: DWORD): COORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleSelectionInfo*(lpConsoleSelectionInfo: PCONSOLE_SELECTION_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumberOfConsoleMouseButtons*(lpNumberOfMouseButtons: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleMode*(hConsoleHandle: HANDLE, dwMode: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleActiveScreenBuffer*(hConsoleOutput: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FlushConsoleInputBuffer*(hConsoleInput: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleScreenBufferSize*(hConsoleOutput: HANDLE, dwSize: COORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleCursorPosition*(hConsoleOutput: HANDLE, dwCursorPosition: COORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleCursorInfo*(hConsoleOutput: HANDLE, lpConsoleCursorInfo: ptr CONSOLE_CURSOR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ScrollConsoleScreenBufferA*(hConsoleOutput: HANDLE, lpScrollRectangle: ptr SMALL_RECT, lpClipRectangle: ptr SMALL_RECT, dwDestinationOrigin: COORD, lpFill: ptr CHAR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ScrollConsoleScreenBufferW*(hConsoleOutput: HANDLE, lpScrollRectangle: ptr SMALL_RECT, lpClipRectangle: ptr SMALL_RECT, dwDestinationOrigin: COORD, lpFill: ptr CHAR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleWindowInfo*(hConsoleOutput: HANDLE, bAbsolute: WINBOOL, lpConsoleWindow: ptr SMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleTextAttribute*(hConsoleOutput: HANDLE, wAttributes: WORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleCtrlHandler*(HandlerRoutine: PHANDLER_ROUTINE, Add: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GenerateConsoleCtrlEvent*(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AllocConsole*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FreeConsole*(): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AttachConsole*(dwProcessId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleTitleA*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleTitleW*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleTitleA*(lpConsoleTitle: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleTitleW*(lpConsoleTitle: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleA*(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ReadConsoleW*(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleA*(hConsoleOutput: HANDLE, lpBuffer: pointer, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WriteConsoleW*(hConsoleOutput: HANDLE, lpBuffer: pointer, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CreateConsoleScreenBuffer*(dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: ptr SECURITY_ATTRIBUTES, dwFlags: DWORD, lpScreenBufferData: LPVOID): HANDLE {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleCP*(): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleCP*(wCodePageID: UINT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleOutputCP*(): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleOutputCP*(wCodePageID: UINT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleDisplayMode*(lpModeFlags: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleDisplayMode*(hConsoleOutput: HANDLE, dwFlags: DWORD, lpNewScreenBufferDimensions: PCOORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleWindow*(): HWND {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleProcessList*(lpdwProcessList: LPDWORD, dwProcessCount: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddConsoleAliasA*(Source: LPSTR, Target: LPSTR, ExeName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc AddConsoleAliasW*(Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasA*(Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasW*(Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasesLengthA*(ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasesLengthW*(ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasExesLengthA*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasExesLengthW*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasesA*(AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasesW*(AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasExesA*(ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleAliasExesW*(ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleHistoryInfo*(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleOriginalTitleA*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleOriginalTitleW*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetConsoleScreenBufferInfoEx*(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrentConsoleFontEx*(hConsoleOutput: HANDLE, bMaximumWindow: WINBOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleHistoryInfo*(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetConsoleScreenBufferInfoEx*(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCurrentConsoleFontEx*(hConsoleOutput: HANDLE, bMaximumWindow: WINBOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +when winimUnicode: + proc PeekConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "PeekConsoleInputW".} + proc ReadConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleInputW".} + proc WriteConsoleInput*(hConsoleInput: HANDLE, lpBuffer: ptr INPUT_RECORD, nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleInputW".} + proc ReadConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputW".} + proc WriteConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: ptr CHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputW".} + proc ReadConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterW".} + proc WriteConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterW".} + proc FillConsoleOutputCharacter*(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterW".} + proc ScrollConsoleScreenBuffer*(hConsoleOutput: HANDLE, lpScrollRectangle: ptr SMALL_RECT, lpClipRectangle: ptr SMALL_RECT, dwDestinationOrigin: COORD, lpFill: ptr CHAR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferW".} + proc GetConsoleTitle*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleTitleW".} + proc SetConsoleTitle*(lpConsoleTitle: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetConsoleTitleW".} + proc ReadConsole*(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleW".} + proc WriteConsole*(hConsoleOutput: HANDLE, lpBuffer: pointer, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleW".} + proc AddConsoleAlias*(Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "AddConsoleAliasW".} + proc GetConsoleAlias*(Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasW".} + proc GetConsoleAliasesLength*(ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasesLengthW".} + proc GetConsoleAliasExesLength*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasExesLengthW".} + proc GetConsoleAliases*(AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasesW".} + proc GetConsoleAliasExes*(ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasExesW".} + proc GetConsoleOriginalTitle*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleOriginalTitleW".} +when winimAnsi: + proc PeekConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "PeekConsoleInputA".} + proc ReadConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleInputA".} + proc WriteConsoleInput*(hConsoleInput: HANDLE, lpBuffer: ptr INPUT_RECORD, nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleInputA".} + proc ReadConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputA".} + proc WriteConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: ptr CHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputA".} + proc ReadConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterA".} + proc WriteConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterA".} + proc FillConsoleOutputCharacter*(hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterA".} + proc ScrollConsoleScreenBuffer*(hConsoleOutput: HANDLE, lpScrollRectangle: ptr SMALL_RECT, lpClipRectangle: ptr SMALL_RECT, dwDestinationOrigin: COORD, lpFill: ptr CHAR_INFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferA".} + proc GetConsoleTitle*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleTitleA".} + proc SetConsoleTitle*(lpConsoleTitle: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetConsoleTitleA".} + proc ReadConsole*(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "ReadConsoleA".} + proc WriteConsole*(hConsoleOutput: HANDLE, lpBuffer: pointer, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "WriteConsoleA".} + proc AddConsoleAlias*(Source: LPSTR, Target: LPSTR, ExeName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "AddConsoleAliasA".} + proc GetConsoleAlias*(Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasA".} + proc GetConsoleAliasesLength*(ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasesLengthA".} + proc GetConsoleAliasExesLength*(): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasExesLengthA".} + proc GetConsoleAliases*(AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasesA".} + proc GetConsoleAliasExes*(ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleAliasExesA".} + proc GetConsoleOriginalTitle*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "kernel32", importc: "GetConsoleOriginalTitleA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wincred.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wincred.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,295 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import security +#include +type + CRED_MARSHAL_TYPE* = int32 + PCRED_MARSHAL_TYPE* = ptr int32 + CRED_PROTECTION_TYPE* = int32 + PCRED_PROTECTION_TYPE* = ptr int32 + CREDENTIAL_ATTRIBUTEA* {.pure.} = object + Keyword*: LPSTR + Flags*: DWORD + ValueSize*: DWORD + Value*: LPBYTE + PCREDENTIAL_ATTRIBUTEA* = ptr CREDENTIAL_ATTRIBUTEA + CREDENTIAL_ATTRIBUTEW* {.pure.} = object + Keyword*: LPWSTR + Flags*: DWORD + ValueSize*: DWORD + Value*: LPBYTE + PCREDENTIAL_ATTRIBUTEW* = ptr CREDENTIAL_ATTRIBUTEW + CREDENTIALA* {.pure.} = object + Flags*: DWORD + Type*: DWORD + TargetName*: LPSTR + Comment*: LPSTR + LastWritten*: FILETIME + CredentialBlobSize*: DWORD + CredentialBlob*: LPBYTE + Persist*: DWORD + AttributeCount*: DWORD + Attributes*: PCREDENTIAL_ATTRIBUTEA + TargetAlias*: LPSTR + UserName*: LPSTR + PCREDENTIALA* = ptr CREDENTIALA + CREDENTIALW* {.pure.} = object + Flags*: DWORD + Type*: DWORD + TargetName*: LPWSTR + Comment*: LPWSTR + LastWritten*: FILETIME + CredentialBlobSize*: DWORD + CredentialBlob*: LPBYTE + Persist*: DWORD + AttributeCount*: DWORD + Attributes*: PCREDENTIAL_ATTRIBUTEW + TargetAlias*: LPWSTR + UserName*: LPWSTR + PCREDENTIALW* = ptr CREDENTIALW + CREDENTIAL_TARGET_INFORMATIONA* {.pure.} = object + TargetName*: LPSTR + NetbiosServerName*: LPSTR + DnsServerName*: LPSTR + NetbiosDomainName*: LPSTR + DnsDomainName*: LPSTR + DnsTreeName*: LPSTR + PackageName*: LPSTR + Flags*: ULONG + CredTypeCount*: DWORD + CredTypes*: LPDWORD + PCREDENTIAL_TARGET_INFORMATIONA* = ptr CREDENTIAL_TARGET_INFORMATIONA + CREDENTIAL_TARGET_INFORMATIONW* {.pure.} = object + TargetName*: LPWSTR + NetbiosServerName*: LPWSTR + DnsServerName*: LPWSTR + NetbiosDomainName*: LPWSTR + DnsDomainName*: LPWSTR + DnsTreeName*: LPWSTR + PackageName*: LPWSTR + Flags*: ULONG + CredTypeCount*: DWORD + CredTypes*: LPDWORD + PCREDENTIAL_TARGET_INFORMATIONW* = ptr CREDENTIAL_TARGET_INFORMATIONW +const + CERT_HASH_LENGTH* = 20 +type + CERT_CREDENTIAL_INFO* {.pure.} = object + cbSize*: ULONG + rgbHashOfCert*: array[CERT_HASH_LENGTH, UCHAR] + PCERT_CREDENTIAL_INFO* = ptr CERT_CREDENTIAL_INFO + USERNAME_TARGET_CREDENTIAL_INFO* {.pure.} = object + UserName*: LPWSTR + PUSERNAME_TARGET_CREDENTIAL_INFO* = ptr USERNAME_TARGET_CREDENTIAL_INFO + CREDUI_INFOA* {.pure.} = object + cbSize*: DWORD + hwndParent*: HWND + pszMessageText*: PCSTR + pszCaptionText*: PCSTR + hbmBanner*: HBITMAP + PCREDUI_INFOA* = ptr CREDUI_INFOA + CREDUI_INFOW* {.pure.} = object + cbSize*: DWORD + hwndParent*: HWND + pszMessageText*: PCWSTR + pszCaptionText*: PCWSTR + hbmBanner*: HBITMAP + PCREDUI_INFOW* = ptr CREDUI_INFOW +const + CRED_MAX_STRING_LENGTH* = 256 + CRED_MAX_USERNAME_LENGTH* = 256+1+256 + CRED_MAX_GENERIC_TARGET_NAME_LENGTH* = 32767 + CRED_MAX_DOMAIN_TARGET_NAME_LENGTH* = 256+1+80 + CRED_MAX_VALUE_SIZE* = 256 + CRED_MAX_ATTRIBUTES* = 64 + CRED_SESSION_WILDCARD_NAME_W* = "*Session" + CRED_SESSION_WILDCARD_NAME_A* = "*Session" + CRED_FLAGS_PASSWORD_FOR_CERT* = 0x0001 + CRED_FLAGS_PROMPT_NOW* = 0x0002 + CRED_FLAGS_USERNAME_TARGET* = 0x0004 + CRED_FLAGS_OWF_CRED_BLOB* = 0x0008 + CRED_FLAGS_VALID_FLAGS* = 0x000F + CRED_TYPE_GENERIC* = 1 + CRED_TYPE_DOMAIN_PASSWORD* = 2 + CRED_TYPE_DOMAIN_CERTIFICATE* = 3 + CRED_TYPE_DOMAIN_VISIBLE_PASSWORD* = 4 + CRED_TYPE_MAXIMUM* = 5 + CRED_TYPE_MAXIMUM_EX* = CRED_TYPE_MAXIMUM+1000 + CRED_MAX_CREDENTIAL_BLOB_SIZE* = 512 + CRED_PERSIST_NONE* = 0 + CRED_PERSIST_SESSION* = 1 + CRED_PERSIST_LOCAL_MACHINE* = 2 + CRED_PERSIST_ENTERPRISE* = 3 + CRED_TI_SERVER_FORMAT_UNKNOWN* = 0x0001 + CRED_TI_DOMAIN_FORMAT_UNKNOWN* = 0x0002 + CRED_TI_ONLY_PASSWORD_REQUIRED* = 0x0004 + CRED_TI_USERNAME_TARGET* = 0x0008 + CRED_TI_CREATE_EXPLICIT_CRED* = 0x0010 + CRED_TI_WORKGROUP_MEMBER* = 0x0020 + CRED_TI_VALID_FLAGS* = 0x003F + certCredential* = 1 + usernameTargetCredential* = 2 + CREDUI_MAX_MESSAGE_LENGTH* = 32767 + CREDUI_MAX_CAPTION_LENGTH* = 128 + CREDUI_MAX_GENERIC_TARGET_LENGTH* = CRED_MAX_GENERIC_TARGET_NAME_LENGTH + CREDUI_MAX_DOMAIN_TARGET_LENGTH* = CRED_MAX_DOMAIN_TARGET_NAME_LENGTH + CREDUI_MAX_USERNAME_LENGTH* = CRED_MAX_USERNAME_LENGTH + CREDUI_MAX_PASSWORD_LENGTH* = CRED_MAX_CREDENTIAL_BLOB_SIZE/2 + CREDUI_FLAGS_INCORRECT_PASSWORD* = 0x00001 + CREDUI_FLAGS_DO_NOT_PERSIST* = 0x00002 + CREDUI_FLAGS_REQUEST_ADMINISTRATOR* = 0x00004 + CREDUI_FLAGS_EXCLUDE_CERTIFICATES* = 0x00008 + CREDUI_FLAGS_REQUIRE_CERTIFICATE* = 0x00010 + CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX* = 0x00040 + CREDUI_FLAGS_ALWAYS_SHOW_UI* = 0x00080 + CREDUI_FLAGS_REQUIRE_SMARTCARD* = 0x00100 + CREDUI_FLAGS_PASSWORD_ONLY_OK* = 0x00200 + CREDUI_FLAGS_VALIDATE_USERNAME* = 0x00400 + CREDUI_FLAGS_COMPLETE_USERNAME* = 0x00800 + CREDUI_FLAGS_PERSIST* = 0x01000 + CREDUI_FLAGS_SERVER_CREDENTIAL* = 0x04000 + CREDUI_FLAGS_EXPECT_CONFIRMATION* = 0x20000 + CREDUI_FLAGS_GENERIC_CREDENTIALS* = 0x40000 + CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS* = 0x80000 + CREDUI_FLAGS_KEEP_USERNAME* = 0x100000 + CREDUI_FLAGS_PROMPT_VALID* = CREDUI_FLAGS_INCORRECT_PASSWORD or CREDUI_FLAGS_DO_NOT_PERSIST or CREDUI_FLAGS_REQUEST_ADMINISTRATOR or CREDUI_FLAGS_EXCLUDE_CERTIFICATES or CREDUI_FLAGS_REQUIRE_CERTIFICATE or CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX or CREDUI_FLAGS_ALWAYS_SHOW_UI or CREDUI_FLAGS_REQUIRE_SMARTCARD or CREDUI_FLAGS_PASSWORD_ONLY_OK or CREDUI_FLAGS_VALIDATE_USERNAME or CREDUI_FLAGS_COMPLETE_USERNAME or CREDUI_FLAGS_PERSIST or CREDUI_FLAGS_SERVER_CREDENTIAL or CREDUI_FLAGS_EXPECT_CONFIRMATION or CREDUI_FLAGS_GENERIC_CREDENTIALS or CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS or CREDUI_FLAGS_KEEP_USERNAME + CRED_PRESERVE_CREDENTIAL_BLOB* = 0x1 + CRED_CACHE_TARGET_INFORMATION* = 0x1 + CRED_ALLOW_NAME_RESOLUTION* = 0x1 + CREDUIWIN_GENERIC* = 0x1 + CREDUIWIN_CHECKBOX* = 0x2 + CREDUIWIN_AUTHPACKAGE_ONLY* = 0x10 + CREDUIWIN_IN_CRED_ONLY* = 0x20 + CREDUIWIN_ENUMERATE_ADMINS* = 0x100 + CREDUIWIN_ENUMERATE_CURRENT_USER* = 0x200 + CREDUIWIN_SECURE_PROMPT* = 0x1000 + CREDUIWIN_PACK_32_WOW* = 0x10000000 + credUnprotected* = 0 + credUserProtection* = 1 + credTrustedProtection* = 2 +when winimUnicode: + const + CRED_SESSION_WILDCARD_NAME* = CRED_SESSION_WILDCARD_NAME_W +when winimAnsi: + const + CRED_SESSION_WILDCARD_NAME* = CRED_SESSION_WILDCARD_NAME_A +const + CRED_SESSION_WILDCARD_NAME_LENGTH* = CRED_SESSION_WILDCARD_NAME.len +proc CredWriteW*(Credential: PCREDENTIALW, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredWriteA*(Credential: PCREDENTIALA, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredReadW*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredReadA*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredEnumerateW*(Filter: LPCWSTR, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredEnumerateA*(Filter: LPCSTR, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredWriteDomainCredentialsW*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Credential: PCREDENTIALW, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredWriteDomainCredentialsA*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Credential: PCREDENTIALA, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredReadDomainCredentialsW*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredReadDomainCredentialsA*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredDeleteW*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredDeleteA*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredRenameW*(OldTargetName: LPCWSTR, NewTargetName: LPCWSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredRenameA*(OldTargetName: LPCSTR, NewTargetName: LPCSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredGetTargetInfoW*(TargetName: LPCWSTR, Flags: DWORD, TargetInfo: ptr PCREDENTIAL_TARGET_INFORMATIONW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredGetTargetInfoA*(TargetName: LPCSTR, Flags: DWORD, TargetInfo: ptr PCREDENTIAL_TARGET_INFORMATIONA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredMarshalCredentialW*(CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarshaledCredential: ptr LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredMarshalCredentialA*(CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarshaledCredential: ptr LPSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredUnmarshalCredentialW*(MarshaledCredential: LPCWSTR, CredType: PCRED_MARSHAL_TYPE, Credential: ptr PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredUnmarshalCredentialA*(MarshaledCredential: LPCSTR, CredType: PCRED_MARSHAL_TYPE, Credential: ptr PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredIsMarshaledCredentialW*(MarshaledCredential: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredIsMarshaledCredentialA*(MarshaledCredential: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredGetSessionTypes*(MaximumPersistCount: DWORD, MaximumPersist: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredFree*(Buffer: PVOID): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredUIPromptForCredentialsW*(pUiInfo: PCREDUI_INFOW, pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PWSTR, ulUserNameBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, save: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIPromptForCredentialsA*(pUiInfo: PCREDUI_INFOA, pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PSTR, ulUserNameBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, save: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIParseUserNameW*(UserName: ptr WCHAR, user: ptr WCHAR, userBufferSize: ULONG, domain: ptr WCHAR, domainBufferSize: ULONG): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIParseUserNameA*(userName: ptr CHAR, user: ptr CHAR, userBufferSize: ULONG, domain: ptr CHAR, domainBufferSize: ULONG): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUICmdLinePromptForCredentialsW*(pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PWSTR, ulUserBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUICmdLinePromptForCredentialsA*(pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PSTR, ulUserBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIConfirmCredentialsW*(pszTargetName: PCWSTR, bConfirm: WINBOOL): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIConfirmCredentialsA*(pszTargetName: PCSTR, bConfirm: WINBOOL): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIStoreSSOCredW*(pszRealm: PCWSTR, pszUsername: PCWSTR, pszPassword: PCWSTR, bPersist: WINBOOL): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIReadSSOCredW*(pszRealm: PCWSTR, ppszUsername: ptr PWSTR): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredFindBestCredentialA*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredFindBestCredentialW*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredIsProtectedA*(pszProtectedCredentials: LPSTR, pProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredIsProtectedW*(pszProtectedCredentials: LPWSTR, pProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredPackAuthenticationBufferA*(dwFlags: DWORD, pszUserName: LPSTR, pszPassword: LPSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc.} +proc CredPackAuthenticationBufferW*(dwFlags: DWORD, pszUserName: LPWSTR, pszPassword: LPWSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc.} +proc CredProtectW*(fAsSelf: WINBOOL, pszCredentials: LPWSTR, cchCredentials: DWORD, pszProtectedCredentials: LPWSTR, pcchMaxChars: ptr DWORD, ProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredProtectA*(fAsSelf: WINBOOL, pszCredentials: LPSTR, cchCredentials: DWORD, pszProtectedCredentials: LPSTR, pcchMaxChars: ptr DWORD, ProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredUIPromptForWindowsCredentialsA*(pUiInfo: PCREDUI_INFOA, dwAuthError: DWORD, pulAuthPackage: ptr ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: ptr LPVOID, pulOutAuthBufferSize: ptr ULONG, pfSave: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUIPromptForWindowsCredentialsW*(pUiInfo: PCREDUI_INFOW, dwAuthError: DWORD, pulAuthPackage: ptr ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: ptr LPVOID, pulOutAuthBufferSize: ptr ULONG, pfSave: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUnPackAuthenticationBufferA*(dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPSTR, pcchMaxUserName: ptr DWORD, pszDomainName: LPSTR, pcchMaxDomainame: ptr DWORD, pszPassword: LPSTR, pcchMaxPassword: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUnPackAuthenticationBufferW*(dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPWSTR, pcchMaxUserName: ptr DWORD, pszDomainName: LPWSTR, pcchMaxDomainame: ptr DWORD, pszPassword: LPWSTR, pcchMaxPassword: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc.} +proc CredUnprotectA*(fAsSelf: WINBOOL, pszProtectedCredentials: LPSTR, cchCredentials: DWORD, pszCredentials: LPSTR, pcchMaxChars: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CredUnprotectW*(fAsSelf: WINBOOL, pszProtectedCredentials: LPWSTR, cchCredentials: DWORD, pszCredentials: LPWSTR, pcchMaxChars: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +when winimUnicode: + type + CREDENTIAL_ATTRIBUTE* = CREDENTIAL_ATTRIBUTEW + PCREDENTIAL_ATTRIBUTE* = PCREDENTIAL_ATTRIBUTEW + CREDENTIAL* = CREDENTIALW + PCREDENTIAL* = PCREDENTIALW + CREDENTIAL_TARGET_INFORMATION* = CREDENTIAL_TARGET_INFORMATIONW + PCREDENTIAL_TARGET_INFORMATION* = PCREDENTIAL_TARGET_INFORMATIONW + CREDUI_INFO* = CREDUI_INFOW + PCREDUI_INFO* = PCREDUI_INFOW + proc CredWrite*(Credential: PCREDENTIALW, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredWriteW".} + proc CredRead*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredReadW".} + proc CredEnumerate*(Filter: LPCWSTR, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredEnumerateW".} + proc CredWriteDomainCredentials*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Credential: PCREDENTIALW, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredWriteDomainCredentialsW".} + proc CredReadDomainCredentials*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredReadDomainCredentialsW".} + proc CredDelete*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredDeleteW".} + proc CredRename*(OldTargetName: LPCWSTR, NewTargetName: LPCWSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredRenameW".} + proc CredGetTargetInfo*(TargetName: LPCWSTR, Flags: DWORD, TargetInfo: ptr PCREDENTIAL_TARGET_INFORMATIONW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredGetTargetInfoW".} + proc CredMarshalCredential*(CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarshaledCredential: ptr LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredMarshalCredentialW".} + proc CredUnmarshalCredential*(MarshaledCredential: LPCWSTR, CredType: PCRED_MARSHAL_TYPE, Credential: ptr PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredUnmarshalCredentialW".} + proc CredIsMarshaledCredential*(MarshaledCredential: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredIsMarshaledCredentialW".} + proc CredUIPromptForCredentials*(pUiInfo: PCREDUI_INFOW, pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PWSTR, ulUserNameBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, save: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIPromptForCredentialsW".} + proc CredUIParseUserName*(UserName: ptr WCHAR, user: ptr WCHAR, userBufferSize: ULONG, domain: ptr WCHAR, domainBufferSize: ULONG): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIParseUserNameW".} + proc CredUICmdLinePromptForCredentials*(pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PWSTR, ulUserBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUICmdLinePromptForCredentialsW".} + proc CredUIConfirmCredentials*(pszTargetName: PCWSTR, bConfirm: WINBOOL): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIConfirmCredentialsW".} + proc CredFindBestCredential*(TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredFindBestCredentialW".} + proc CredIsProtected*(pszProtectedCredentials: LPWSTR, pProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredIsProtectedW".} + proc CredPackAuthenticationBuffer*(dwFlags: DWORD, pszUserName: LPWSTR, pszPassword: LPWSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc: "CredPackAuthenticationBufferW".} + proc CredProtect*(fAsSelf: WINBOOL, pszCredentials: LPWSTR, cchCredentials: DWORD, pszProtectedCredentials: LPWSTR, pcchMaxChars: ptr DWORD, ProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredProtectW".} + proc CredUIPromptForWindowsCredentials*(pUiInfo: PCREDUI_INFOW, dwAuthError: DWORD, pulAuthPackage: ptr ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: ptr LPVOID, pulOutAuthBufferSize: ptr ULONG, pfSave: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIPromptForWindowsCredentialsW".} + proc CredUnPackAuthenticationBuffer*(dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPWSTR, pcchMaxUserName: ptr DWORD, pszDomainName: LPWSTR, pcchMaxDomainame: ptr DWORD, pszPassword: LPWSTR, pcchMaxPassword: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc: "CredUnPackAuthenticationBufferW".} + proc CredUnprotect*(fAsSelf: WINBOOL, pszProtectedCredentials: LPWSTR, cchCredentials: DWORD, pszCredentials: LPWSTR, pcchMaxChars: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredUnprotectW".} +when winimAnsi: + type + CREDENTIAL_ATTRIBUTE* = CREDENTIAL_ATTRIBUTEA + PCREDENTIAL_ATTRIBUTE* = PCREDENTIAL_ATTRIBUTEA + CREDENTIAL* = CREDENTIALA + PCREDENTIAL* = PCREDENTIALA + CREDENTIAL_TARGET_INFORMATION* = CREDENTIAL_TARGET_INFORMATIONA + PCREDENTIAL_TARGET_INFORMATION* = PCREDENTIAL_TARGET_INFORMATIONA + CREDUI_INFO* = CREDUI_INFOA + PCREDUI_INFO* = PCREDUI_INFOA + proc CredWrite*(Credential: PCREDENTIALA, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredWriteA".} + proc CredRead*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredReadA".} + proc CredEnumerate*(Filter: LPCSTR, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredEnumerateA".} + proc CredWriteDomainCredentials*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Credential: PCREDENTIALA, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredWriteDomainCredentialsA".} + proc CredReadDomainCredentials*(TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Flags: DWORD, Count: ptr DWORD, Credential: ptr ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredReadDomainCredentialsA".} + proc CredDelete*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredDeleteA".} + proc CredRename*(OldTargetName: LPCSTR, NewTargetName: LPCSTR, Type: DWORD, Flags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredRenameA".} + proc CredGetTargetInfo*(TargetName: LPCSTR, Flags: DWORD, TargetInfo: ptr PCREDENTIAL_TARGET_INFORMATIONA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredGetTargetInfoA".} + proc CredMarshalCredential*(CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarshaledCredential: ptr LPSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredMarshalCredentialA".} + proc CredUnmarshalCredential*(MarshaledCredential: LPCSTR, CredType: PCRED_MARSHAL_TYPE, Credential: ptr PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredUnmarshalCredentialA".} + proc CredIsMarshaledCredential*(MarshaledCredential: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredIsMarshaledCredentialA".} + proc CredUIPromptForCredentials*(pUiInfo: PCREDUI_INFOA, pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PSTR, ulUserNameBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, save: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIPromptForCredentialsA".} + proc CredUIParseUserName*(userName: ptr CHAR, user: ptr CHAR, userBufferSize: ULONG, domain: ptr CHAR, domainBufferSize: ULONG): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIParseUserNameA".} + proc CredUICmdLinePromptForCredentials*(pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PSTR, ulUserBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUICmdLinePromptForCredentialsA".} + proc CredUIConfirmCredentials*(pszTargetName: PCSTR, bConfirm: WINBOOL): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIConfirmCredentialsA".} + proc CredFindBestCredential*(TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: ptr PCREDENTIALA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredFindBestCredentialA".} + proc CredIsProtected*(pszProtectedCredentials: LPSTR, pProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredIsProtectedA".} + proc CredPackAuthenticationBuffer*(dwFlags: DWORD, pszUserName: LPSTR, pszPassword: LPSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc: "CredPackAuthenticationBufferA".} + proc CredProtect*(fAsSelf: WINBOOL, pszCredentials: LPSTR, cchCredentials: DWORD, pszProtectedCredentials: LPSTR, pcchMaxChars: ptr DWORD, ProtectionType: ptr CRED_PROTECTION_TYPE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredProtectA".} + proc CredUIPromptForWindowsCredentials*(pUiInfo: PCREDUI_INFOA, dwAuthError: DWORD, pulAuthPackage: ptr ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: ptr LPVOID, pulOutAuthBufferSize: ptr ULONG, pfSave: ptr WINBOOL, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "credui", importc: "CredUIPromptForWindowsCredentialsA".} + proc CredUnPackAuthenticationBuffer*(dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPSTR, pcchMaxUserName: ptr DWORD, pszDomainName: LPSTR, pcchMaxDomainame: ptr DWORD, pszPassword: LPSTR, pcchMaxPassword: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "credui", importc: "CredUnPackAuthenticationBufferA".} + proc CredUnprotect*(fAsSelf: WINBOOL, pszProtectedCredentials: LPSTR, cchCredentials: DWORD, pszCredentials: LPSTR, pcchMaxChars: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CredUnprotectA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wincrypt.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wincrypt.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,5408 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +#include +#include +#include +type + ALG_ID* = int32 + HASHALGORITHM_ENUM* = int32 + DSAFIPSVERSION_ENUM* = int32 + HCRYPTOIDFUNCSET* = pointer + HCRYPTOIDFUNCADDR* = pointer + HCRYPTMSG* = pointer + HCERTSTORE* = pointer + HCERTSTOREPROV* = pointer + HCRYPTDEFAULTCONTEXT* = pointer + HCERT_SERVER_OCSP_RESPONSE* = pointer + PRKEVENT* = pointer + HCRYPTHASH* = ULONG_PTR + HCRYPTKEY* = ULONG_PTR + HCRYPTPROV* = ULONG_PTR + HCRYPTPROV_OR_NCRYPT_KEY_HANDLE* = ULONG_PTR + HCRYPTPROV_LEGACY* = ULONG_PTR + BCRYPT_HANDLE* = PVOID + BCRYPT_ALG_HANDLE* = PVOID + BCRYPT_KEY_HANDLE* = PVOID + BCRYPT_HASH_HANDLE* = PVOID + BCRYPT_SECRET_HANDLE* = PVOID + SECURITY_STATUS* = LONG + NCRYPT_HANDLE* = ULONG_PTR + NCRYPT_PROV_HANDLE* = ULONG_PTR + NCRYPT_KEY_HANDLE* = ULONG_PTR + NCRYPT_HASH_HANDLE* = ULONG_PTR + NCRYPT_SECRET_HANDLE* = ULONG_PTR + HCRYPTASYNC* = HANDLE + PHCRYPTASYNC* = ptr HANDLE + HCERTCHAINENGINE* = HANDLE + CMS_KEY_INFO* {.pure.} = object + dwVersion*: DWORD + Algid*: ALG_ID + pbOID*: ptr BYTE + cbOID*: DWORD + PCMS_KEY_INFO* = ptr CMS_KEY_INFO + HMAC_INFO* {.pure.} = object + HashAlgid*: ALG_ID + pbInnerString*: ptr BYTE + cbInnerString*: DWORD + pbOuterString*: ptr BYTE + cbOuterString*: DWORD + PHMAC_INFO* = ptr HMAC_INFO + SCHANNEL_ALG* {.pure.} = object + dwUse*: DWORD + Algid*: ALG_ID + cBits*: DWORD + dwFlags*: DWORD + dwReserved*: DWORD + PSCHANNEL_ALG* = ptr SCHANNEL_ALG + BLOBHEADER* {.pure.} = object + bType*: BYTE + bVersion*: BYTE + reserved*: WORD + aiKeyAlg*: ALG_ID + PUBLICKEYSTRUC* = BLOBHEADER + DHPUBKEY* {.pure.} = object + magic*: DWORD + bitlen*: DWORD + DSSPUBKEY* = DHPUBKEY + KEAPUBKEY* = DHPUBKEY + TEKPUBKEY* = DHPUBKEY + DSSSEED* {.pure.} = object + counter*: DWORD + seed*: array[20, BYTE] + DHPUBKEY_VER3* {.pure.} = object + magic*: DWORD + bitlenP*: DWORD + bitlenQ*: DWORD + bitlenJ*: DWORD + DSSSeed*: DSSSEED + DSSPUBKEY_VER3* = DHPUBKEY_VER3 + DHPRIVKEY_VER3* {.pure.} = object + magic*: DWORD + bitlenP*: DWORD + bitlenQ*: DWORD + bitlenJ*: DWORD + bitlenX*: DWORD + DSSSeed*: DSSSEED + DSSPRIVKEY_VER3* = DHPRIVKEY_VER3 + KEY_TYPE_SUBTYPE* {.pure.} = object + dwKeySpec*: DWORD + Type*: GUID + Subtype*: GUID + PKEY_TYPE_SUBTYPE* = ptr KEY_TYPE_SUBTYPE + CRYPT_RC4_KEY_STATE* {.pure.} = object + Key*: array[16, uint8] + SBox*: array[256, uint8] + i*: uint8 + j*: uint8 + PCRYPT_RC4_KEY_STATE* = ptr CRYPT_RC4_KEY_STATE + CRYPT_DES_KEY_STATE* {.pure.} = object + Key*: array[8, uint8] + IV*: array[8, uint8] + Feedback*: array[8, uint8] + PCRYPT_DES_KEY_STATE* = ptr CRYPT_DES_KEY_STATE + CRYPT_3DES_KEY_STATE* {.pure.} = object + Key*: array[24, uint8] + IV*: array[8, uint8] + Feedback*: array[8, uint8] + PCRYPT_3DES_KEY_STATE* = ptr CRYPT_3DES_KEY_STATE + CRYPT_AES_128_KEY_STATE* {.pure.} = object + Key*: array[16, uint8] + IV*: array[16, uint8] + EncryptionState*: array[11, array[16, uint8]] + DecryptionState*: array[11, array[16, uint8]] + Feedback*: array[16, uint8] + PCRYPT_AES_128_KEY_STATE* = ptr CRYPT_AES_128_KEY_STATE + CRYPT_AES_256_KEY_STATE* {.pure.} = object + Key*: array[32, uint8] + IV*: array[16, uint8] + EncryptionState*: array[15, array[16, uint8]] + DecryptionState*: array[15, array[16, uint8]] + Feedback*: array[16, uint8] + PCRYPT_AES_256_KEY_STATE* = ptr CRYPT_AES_256_KEY_STATE + CRYPT_INTEGER_BLOB* {.pure.} = object + cbData*: DWORD + pbData*: ptr BYTE + PCRYPT_INTEGER_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_UINT_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_UINT_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_OBJID_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_OBJID_BLOB* = ptr CRYPT_INTEGER_BLOB + CERT_NAME_BLOB* = CRYPT_INTEGER_BLOB + PCERT_NAME_BLOB* = ptr CRYPT_INTEGER_BLOB + CERT_RDN_VALUE_BLOB* = CRYPT_INTEGER_BLOB + PCERT_RDN_VALUE_BLOB* = ptr CRYPT_INTEGER_BLOB + CERT_BLOB* = CRYPT_INTEGER_BLOB + PCERT_BLOB* = ptr CRYPT_INTEGER_BLOB + CRL_BLOB* = CRYPT_INTEGER_BLOB + PCRL_BLOB* = ptr CRYPT_INTEGER_BLOB + DATA_BLOB* = CRYPT_INTEGER_BLOB + PDATA_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_DATA_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_DATA_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_HASH_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_HASH_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_DIGEST_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_DIGEST_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_DER_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_DER_BLOB* = ptr CRYPT_INTEGER_BLOB + CRYPT_ATTR_BLOB* = CRYPT_INTEGER_BLOB + PCRYPT_ATTR_BLOB* = ptr CRYPT_INTEGER_BLOB + CMS_DH_KEY_INFO* {.pure.} = object + dwVersion*: DWORD + Algid*: ALG_ID + pszContentEncObjId*: LPSTR + PubInfo*: CRYPT_DATA_BLOB + pReserved*: pointer + PCMS_DH_KEY_INFO* = ptr CMS_DH_KEY_INFO + BCRYPT_KEY_LENGTHS_STRUCT* {.pure.} = object + dwMinLength*: ULONG + dwMaxLength*: ULONG + dwIncrement*: ULONG + BCRYPT_AUTH_TAG_LENGTHS_STRUCT* = BCRYPT_KEY_LENGTHS_STRUCT + BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO* {.pure.} = object + cbSize*: ULONG + dwInfoVersion*: ULONG + pbNonce*: PUCHAR + cbNonce*: ULONG + pbAuthData*: PUCHAR + cbAuthData*: ULONG + pbTag*: PUCHAR + cbTag*: ULONG + pbMacContext*: PUCHAR + cbMacContext*: ULONG + cbAAD*: ULONG + cbData*: ULONGLONG + dwFlags*: ULONG + PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO* = ptr BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO + BCryptBuffer* {.pure.} = object + cbBuffer*: ULONG + BufferType*: ULONG + pvBuffer*: PVOID + PBCryptBuffer* = ptr BCryptBuffer + BCryptBufferDesc* {.pure.} = object + ulVersion*: ULONG + cBuffers*: ULONG + pBuffers*: PBCryptBuffer + PBCryptBufferDesc* = ptr BCryptBufferDesc + BCRYPT_ECCKEY_BLOB* {.pure.} = object + dwMagic*: ULONG + cbKey*: ULONG + PBCRYPT_ECCKEY_BLOB* = ptr BCRYPT_ECCKEY_BLOB + BCRYPT_DH_KEY_BLOB* {.pure.} = object + dwMagic*: ULONG + cbKey*: ULONG + PBCRYPT_DH_KEY_BLOB* = ptr BCRYPT_DH_KEY_BLOB + BCRYPT_DSA_KEY_BLOB* {.pure.} = object + dwMagic*: ULONG + cbKey*: ULONG + Count*: array[4, UCHAR] + Seed*: array[20, UCHAR] + q*: array[20, UCHAR] + PBCRYPT_DSA_KEY_BLOB* = ptr BCRYPT_DSA_KEY_BLOB + BCRYPT_DSA_KEY_BLOB_V2* {.pure.} = object + dwMagic*: ULONG + cbKey*: ULONG + hashAlgorithm*: HASHALGORITHM_ENUM + standardVersion*: DSAFIPSVERSION_ENUM + cbSeedLength*: ULONG + cbGroupSize*: ULONG + Count*: array[4, UCHAR] + PBCRYPT_DSA_KEY_BLOB_V2* = ptr BCRYPT_DSA_KEY_BLOB_V2 + BCRYPT_KEY_DATA_BLOB_HEADER* {.pure.} = object + dwMagic*: ULONG + dwVersion*: ULONG + cbKeyData*: ULONG + PBCRYPT_KEY_DATA_BLOB_HEADER* = ptr BCRYPT_KEY_DATA_BLOB_HEADER + BCRYPT_INTERFACE_VERSION* {.pure.} = object + MajorVersion*: USHORT + MinorVersion*: USHORT + PBCRYPT_INTERFACE_VERSION* = ptr BCRYPT_INTERFACE_VERSION + CRYPT_INTERFACE_REG* {.pure.} = object + dwInterface*: ULONG + dwFlags*: ULONG + cFunctions*: ULONG + rgpszFunctions*: ptr PWSTR + PCRYPT_INTERFACE_REG* = ptr CRYPT_INTERFACE_REG + CRYPT_IMAGE_REG* {.pure.} = object + pszImage*: PWSTR + cInterfaces*: ULONG + rgpInterfaces*: ptr PCRYPT_INTERFACE_REG + PCRYPT_IMAGE_REG* = ptr CRYPT_IMAGE_REG + CRYPT_PROVIDER_REG* {.pure.} = object + cAliases*: ULONG + rgpszAliases*: ptr PWSTR + pUM*: PCRYPT_IMAGE_REG + pKM*: PCRYPT_IMAGE_REG + PCRYPT_PROVIDER_REG* = ptr CRYPT_PROVIDER_REG + CRYPT_PROVIDERS* {.pure.} = object + cProviders*: ULONG + rgpszProviders*: ptr PWSTR + PCRYPT_PROVIDERS* = ptr CRYPT_PROVIDERS + CRYPT_CONTEXT_CONFIG* {.pure.} = object + dwFlags*: ULONG + dwReserved*: ULONG + PCRYPT_CONTEXT_CONFIG* = ptr CRYPT_CONTEXT_CONFIG + CRYPT_CONTEXT_FUNCTION_CONFIG* {.pure.} = object + dwFlags*: ULONG + dwReserved*: ULONG + PCRYPT_CONTEXT_FUNCTION_CONFIG* = ptr CRYPT_CONTEXT_FUNCTION_CONFIG + CRYPT_CONTEXTS* {.pure.} = object + cContexts*: ULONG + rgpszContexts*: ptr PWSTR + PCRYPT_CONTEXTS* = ptr CRYPT_CONTEXTS + CRYPT_CONTEXT_FUNCTIONS* {.pure.} = object + cFunctions*: ULONG + rgpszFunctions*: ptr PWSTR + PCRYPT_CONTEXT_FUNCTIONS* = ptr CRYPT_CONTEXT_FUNCTIONS + CRYPT_CONTEXT_FUNCTION_PROVIDERS* {.pure.} = object + cProviders*: ULONG + rgpszProviders*: ptr PWSTR + PCRYPT_CONTEXT_FUNCTION_PROVIDERS* = ptr CRYPT_CONTEXT_FUNCTION_PROVIDERS + CRYPT_PROPERTY_REF* {.pure.} = object + pszProperty*: PWSTR + cbValue*: ULONG + pbValue*: PUCHAR + PCRYPT_PROPERTY_REF* = ptr CRYPT_PROPERTY_REF + CRYPT_IMAGE_REF* {.pure.} = object + pszImage*: PWSTR + dwFlags*: ULONG + PCRYPT_IMAGE_REF* = ptr CRYPT_IMAGE_REF + CRYPT_PROVIDER_REF* {.pure.} = object + dwInterface*: ULONG + pszFunction*: PWSTR + pszProvider*: PWSTR + cProperties*: ULONG + rgpProperties*: ptr PCRYPT_PROPERTY_REF + pUM*: PCRYPT_IMAGE_REF + pKM*: PCRYPT_IMAGE_REF + PCRYPT_PROVIDER_REF* = ptr CRYPT_PROVIDER_REF + CRYPT_PROVIDER_REFS* {.pure.} = object + cProviders*: ULONG + rgpProviders*: ptr PCRYPT_PROVIDER_REF + PCRYPT_PROVIDER_REFS* = ptr CRYPT_PROVIDER_REFS + NCryptBuffer* = BCryptBuffer + PNCryptBuffer* = ptr BCryptBuffer + NCryptBufferDesc* = BCryptBufferDesc + PNCryptBufferDesc* = ptr BCryptBufferDesc + NCRYPT_CIPHER_PADDING_INFO* {.pure.} = object + cbSize*: ULONG + dwFlags*: DWORD + pbIV*: PUCHAR + cbIV*: ULONG + pbOtherInfo*: PUCHAR + cbOtherInfo*: ULONG + PNCRYPT_CIPHER_PADDING_INFO* = ptr NCRYPT_CIPHER_PADDING_INFO + NCRYPT_KEY_BLOB_HEADER* {.pure.} = object + cbSize*: ULONG + dwMagic*: ULONG + cbAlgName*: ULONG + cbKeyData*: ULONG + PNCRYPT_KEY_BLOB_HEADER* = ptr NCRYPT_KEY_BLOB_HEADER + CRYPT_BIT_BLOB* {.pure.} = object + cbData*: DWORD + pbData*: ptr BYTE + cUnusedBits*: DWORD + PCRYPT_BIT_BLOB* = ptr CRYPT_BIT_BLOB + CRYPT_ALGORITHM_IDENTIFIER* {.pure.} = object + pszObjId*: LPSTR + Parameters*: CRYPT_OBJID_BLOB + PCRYPT_ALGORITHM_IDENTIFIER* = ptr CRYPT_ALGORITHM_IDENTIFIER + CRYPT_OBJID_TABLE* {.pure.} = object + dwAlgId*: DWORD + pszObjId*: LPCSTR + PCRYPT_OBJID_TABLE* = ptr CRYPT_OBJID_TABLE + CRYPT_HASH_INFO* {.pure.} = object + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Hash*: CRYPT_HASH_BLOB + PCRYPT_HASH_INFO* = ptr CRYPT_HASH_INFO + CERT_EXTENSION* {.pure.} = object + pszObjId*: LPSTR + fCritical*: WINBOOL + Value*: CRYPT_OBJID_BLOB + PCERT_EXTENSION* = ptr CERT_EXTENSION + PCCERT_EXTENSION* = ptr CERT_EXTENSION + CRYPT_ATTRIBUTE_TYPE_VALUE* {.pure.} = object + pszObjId*: LPSTR + Value*: CRYPT_OBJID_BLOB + PCRYPT_ATTRIBUTE_TYPE_VALUE* = ptr CRYPT_ATTRIBUTE_TYPE_VALUE + CRYPT_ATTRIBUTE* {.pure.} = object + pszObjId*: LPSTR + cValue*: DWORD + rgValue*: PCRYPT_ATTR_BLOB + PCRYPT_ATTRIBUTE* = ptr CRYPT_ATTRIBUTE + CRYPT_ATTRIBUTES* {.pure.} = object + cAttr*: DWORD + rgAttr*: PCRYPT_ATTRIBUTE + PCRYPT_ATTRIBUTES* = ptr CRYPT_ATTRIBUTES + CERT_RDN_ATTR* {.pure.} = object + pszObjId*: LPSTR + dwValueType*: DWORD + Value*: CERT_RDN_VALUE_BLOB + PCERT_RDN_ATTR* = ptr CERT_RDN_ATTR + CERT_RDN* {.pure.} = object + cRDNAttr*: DWORD + rgRDNAttr*: PCERT_RDN_ATTR + PCERT_RDN* = ptr CERT_RDN + CERT_NAME_INFO* {.pure.} = object + cRDN*: DWORD + rgRDN*: PCERT_RDN + PCERT_NAME_INFO* = ptr CERT_NAME_INFO + CERT_NAME_VALUE* {.pure.} = object + dwValueType*: DWORD + Value*: CERT_RDN_VALUE_BLOB + PCERT_NAME_VALUE* = ptr CERT_NAME_VALUE + CERT_PUBLIC_KEY_INFO* {.pure.} = object + Algorithm*: CRYPT_ALGORITHM_IDENTIFIER + PublicKey*: CRYPT_BIT_BLOB + PCERT_PUBLIC_KEY_INFO* = ptr CERT_PUBLIC_KEY_INFO + CRYPT_ECC_PRIVATE_KEY_INFO* {.pure.} = object + dwVersion*: DWORD + PrivateKey*: CRYPT_DER_BLOB + szCurveOid*: LPSTR + PublicKey*: CRYPT_BIT_BLOB + PCRYPT_ECC_PRIVATE_KEY_INFO* = ptr CRYPT_ECC_PRIVATE_KEY_INFO + CRYPT_PRIVATE_KEY_INFO* {.pure.} = object + Version*: DWORD + Algorithm*: CRYPT_ALGORITHM_IDENTIFIER + PrivateKey*: CRYPT_DER_BLOB + pAttributes*: PCRYPT_ATTRIBUTES + PCRYPT_PRIVATE_KEY_INFO* = ptr CRYPT_PRIVATE_KEY_INFO + CRYPT_ENCRYPTED_PRIVATE_KEY_INFO* {.pure.} = object + EncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedPrivateKey*: CRYPT_DATA_BLOB + PCRYPT_ENCRYPTED_PRIVATE_KEY_INFO* = ptr CRYPT_ENCRYPTED_PRIVATE_KEY_INFO + PCRYPT_RESOLVE_HCRYPTPROV_FUNC* = proc (pPrivateKeyInfo: ptr CRYPT_PRIVATE_KEY_INFO, phCryptProv: ptr HCRYPTPROV, pVoidResolveFunc: LPVOID): WINBOOL {.stdcall.} + PCRYPT_DECRYPT_PRIVATE_KEY_FUNC* = proc (Algorithm: CRYPT_ALGORITHM_IDENTIFIER, EncryptedPrivateKey: CRYPT_DATA_BLOB, pbClearTextKey: ptr BYTE, pcbClearTextKey: ptr DWORD, pVoidDecryptFunc: LPVOID): WINBOOL {.stdcall.} + CRYPT_PKCS8_IMPORT_PARAMS* {.pure.} = object + PrivateKey*: CRYPT_DIGEST_BLOB + pResolvehCryptProvFunc*: PCRYPT_RESOLVE_HCRYPTPROV_FUNC + pVoidResolveFunc*: LPVOID + pDecryptPrivateKeyFunc*: PCRYPT_DECRYPT_PRIVATE_KEY_FUNC + pVoidDecryptFunc*: LPVOID + PCRYPT_PKCS8_IMPORT_PARAMS* = ptr CRYPT_PKCS8_IMPORT_PARAMS + CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS* = CRYPT_PKCS8_IMPORT_PARAMS + PCRYPT_PRIVATE_KEY_BLOB_AND_PARAMS* = ptr CRYPT_PKCS8_IMPORT_PARAMS + PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC* = proc (pAlgorithm: ptr CRYPT_ALGORITHM_IDENTIFIER, pClearTextPrivateKey: ptr CRYPT_DATA_BLOB, pbEncryptedKey: ptr BYTE, pcbEncryptedKey: ptr DWORD, pVoidEncryptFunc: LPVOID): WINBOOL {.stdcall.} + CRYPT_PKCS8_EXPORT_PARAMS* {.pure.} = object + hCryptProv*: HCRYPTPROV + dwKeySpec*: DWORD + pszPrivateKeyObjId*: LPSTR + pEncryptPrivateKeyFunc*: PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC + pVoidEncryptFunc*: LPVOID + PCRYPT_PKCS8_EXPORT_PARAMS* = ptr CRYPT_PKCS8_EXPORT_PARAMS + CERT_INFO* {.pure.} = object + dwVersion*: DWORD + SerialNumber*: CRYPT_INTEGER_BLOB + SignatureAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Issuer*: CERT_NAME_BLOB + NotBefore*: FILETIME + NotAfter*: FILETIME + Subject*: CERT_NAME_BLOB + SubjectPublicKeyInfo*: CERT_PUBLIC_KEY_INFO + IssuerUniqueId*: CRYPT_BIT_BLOB + SubjectUniqueId*: CRYPT_BIT_BLOB + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCERT_INFO* = ptr CERT_INFO + CRL_ENTRY* {.pure.} = object + SerialNumber*: CRYPT_INTEGER_BLOB + RevocationDate*: FILETIME + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCRL_ENTRY* = ptr CRL_ENTRY + CRL_INFO* {.pure.} = object + dwVersion*: DWORD + SignatureAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Issuer*: CERT_NAME_BLOB + ThisUpdate*: FILETIME + NextUpdate*: FILETIME + cCRLEntry*: DWORD + rgCRLEntry*: PCRL_ENTRY + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCRL_INFO* = ptr CRL_INFO + CERT_OR_CRL_BLOB* {.pure.} = object + dwChoice*: DWORD + cbEncoded*: DWORD + pbEncoded*: ptr BYTE + PCERT_OR_CRL_BLOB* = ptr CERT_OR_CRL_BLOB + CERT_OR_CRL_BUNDLE* {.pure.} = object + cItem*: DWORD + rgItem*: PCERT_OR_CRL_BLOB + PCERT_OR_CRL_BUNDLE* = ptr CERT_OR_CRL_BUNDLE + CERT_REQUEST_INFO* {.pure.} = object + dwVersion*: DWORD + Subject*: CERT_NAME_BLOB + SubjectPublicKeyInfo*: CERT_PUBLIC_KEY_INFO + cAttribute*: DWORD + rgAttribute*: PCRYPT_ATTRIBUTE + PCERT_REQUEST_INFO* = ptr CERT_REQUEST_INFO + CERT_KEYGEN_REQUEST_INFO* {.pure.} = object + dwVersion*: DWORD + SubjectPublicKeyInfo*: CERT_PUBLIC_KEY_INFO + pwszChallengeString*: LPWSTR + PCERT_KEYGEN_REQUEST_INFO* = ptr CERT_KEYGEN_REQUEST_INFO + CERT_SIGNED_CONTENT_INFO* {.pure.} = object + ToBeSigned*: CRYPT_DER_BLOB + SignatureAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Signature*: CRYPT_BIT_BLOB + PCERT_SIGNED_CONTENT_INFO* = ptr CERT_SIGNED_CONTENT_INFO + CTL_USAGE* {.pure.} = object + cUsageIdentifier*: DWORD + rgpszUsageIdentifier*: ptr LPSTR + PCTL_USAGE* = ptr CTL_USAGE + CERT_ENHKEY_USAGE* = CTL_USAGE + PCERT_ENHKEY_USAGE* = ptr CTL_USAGE + PCCTL_USAGE* = ptr CTL_USAGE + PCCERT_ENHKEY_USAGE* = ptr CERT_ENHKEY_USAGE + CTL_ENTRY* {.pure.} = object + SubjectIdentifier*: CRYPT_DATA_BLOB + cAttribute*: DWORD + rgAttribute*: PCRYPT_ATTRIBUTE + PCTL_ENTRY* = ptr CTL_ENTRY + CTL_INFO* {.pure.} = object + dwVersion*: DWORD + SubjectUsage*: CTL_USAGE + ListIdentifier*: CRYPT_DATA_BLOB + SequenceNumber*: CRYPT_INTEGER_BLOB + ThisUpdate*: FILETIME + NextUpdate*: FILETIME + SubjectAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + cCTLEntry*: DWORD + rgCTLEntry*: PCTL_ENTRY + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCTL_INFO* = ptr CTL_INFO + CRYPT_TIME_STAMP_REQUEST_INFO* {.pure.} = object + pszTimeStampAlgorithm*: LPSTR + pszContentType*: LPSTR + Content*: CRYPT_OBJID_BLOB + cAttribute*: DWORD + rgAttribute*: PCRYPT_ATTRIBUTE + PCRYPT_TIME_STAMP_REQUEST_INFO* = ptr CRYPT_TIME_STAMP_REQUEST_INFO + CRYPT_ENROLLMENT_NAME_VALUE_PAIR* {.pure.} = object + pwszName*: LPWSTR + pwszValue*: LPWSTR + PCRYPT_ENROLLMENT_NAME_VALUE_PAIR* = ptr CRYPT_ENROLLMENT_NAME_VALUE_PAIR + CRYPT_CSP_PROVIDER* {.pure.} = object + dwKeySpec*: DWORD + pwszProviderName*: LPWSTR + Signature*: CRYPT_BIT_BLOB + PCRYPT_CSP_PROVIDER* = ptr CRYPT_CSP_PROVIDER + PFN_CRYPT_ALLOC* = proc (cbSize: int): LPVOID {.stdcall.} + PFN_CRYPT_FREE* = proc (pv: LPVOID): VOID {.stdcall.} + CRYPT_ENCODE_PARA* {.pure.} = object + cbSize*: DWORD + pfnAlloc*: PFN_CRYPT_ALLOC + pfnFree*: PFN_CRYPT_FREE + PCRYPT_ENCODE_PARA* = ptr CRYPT_ENCODE_PARA + CRYPT_DECODE_PARA* {.pure.} = object + cbSize*: DWORD + pfnAlloc*: PFN_CRYPT_ALLOC + pfnFree*: PFN_CRYPT_FREE + PCRYPT_DECODE_PARA* = ptr CRYPT_DECODE_PARA + CERT_EXTENSIONS* {.pure.} = object + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCERT_EXTENSIONS* = ptr CERT_EXTENSIONS + CERT_AUTHORITY_KEY_ID_INFO* {.pure.} = object + KeyId*: CRYPT_DATA_BLOB + CertIssuer*: CERT_NAME_BLOB + CertSerialNumber*: CRYPT_INTEGER_BLOB + PCERT_AUTHORITY_KEY_ID_INFO* = ptr CERT_AUTHORITY_KEY_ID_INFO + CERT_PRIVATE_KEY_VALIDITY* {.pure.} = object + NotBefore*: FILETIME + NotAfter*: FILETIME + PCERT_PRIVATE_KEY_VALIDITY* = ptr CERT_PRIVATE_KEY_VALIDITY + CERT_KEY_ATTRIBUTES_INFO* {.pure.} = object + KeyId*: CRYPT_DATA_BLOB + IntendedKeyUsage*: CRYPT_BIT_BLOB + pPrivateKeyUsagePeriod*: PCERT_PRIVATE_KEY_VALIDITY + PCERT_KEY_ATTRIBUTES_INFO* = ptr CERT_KEY_ATTRIBUTES_INFO + CERT_POLICY_ID* {.pure.} = object + cCertPolicyElementId*: DWORD + rgpszCertPolicyElementId*: ptr LPSTR + PCERT_POLICY_ID* = ptr CERT_POLICY_ID + CERT_KEY_USAGE_RESTRICTION_INFO* {.pure.} = object + cCertPolicyId*: DWORD + rgCertPolicyId*: PCERT_POLICY_ID + RestrictedKeyUsage*: CRYPT_BIT_BLOB + PCERT_KEY_USAGE_RESTRICTION_INFO* = ptr CERT_KEY_USAGE_RESTRICTION_INFO + CERT_OTHER_NAME* {.pure.} = object + pszObjId*: LPSTR + Value*: CRYPT_OBJID_BLOB + PCERT_OTHER_NAME* = ptr CERT_OTHER_NAME + CERT_ALT_NAME_ENTRY_UNION1* {.pure, union.} = object + pOtherName*: PCERT_OTHER_NAME + pwszRfc822Name*: LPWSTR + pwszDNSName*: LPWSTR + DirectoryName*: CERT_NAME_BLOB + pwszURL*: LPWSTR + IPAddress*: CRYPT_DATA_BLOB + pszRegisteredID*: LPSTR + CERT_ALT_NAME_ENTRY* {.pure.} = object + dwAltNameChoice*: DWORD + union1*: CERT_ALT_NAME_ENTRY_UNION1 + PCERT_ALT_NAME_ENTRY* = ptr CERT_ALT_NAME_ENTRY + CERT_ALT_NAME_INFO* {.pure.} = object + cAltEntry*: DWORD + rgAltEntry*: PCERT_ALT_NAME_ENTRY + PCERT_ALT_NAME_INFO* = ptr CERT_ALT_NAME_INFO + CERT_BASIC_CONSTRAINTS_INFO* {.pure.} = object + SubjectType*: CRYPT_BIT_BLOB + fPathLenConstraint*: WINBOOL + dwPathLenConstraint*: DWORD + cSubtreesConstraint*: DWORD + rgSubtreesConstraint*: ptr CERT_NAME_BLOB + PCERT_BASIC_CONSTRAINTS_INFO* = ptr CERT_BASIC_CONSTRAINTS_INFO + CERT_BASIC_CONSTRAINTS2_INFO* {.pure.} = object + fCA*: WINBOOL + fPathLenConstraint*: WINBOOL + dwPathLenConstraint*: DWORD + PCERT_BASIC_CONSTRAINTS2_INFO* = ptr CERT_BASIC_CONSTRAINTS2_INFO + CERT_POLICY_QUALIFIER_INFO* {.pure.} = object + pszPolicyQualifierId*: LPSTR + Qualifier*: CRYPT_OBJID_BLOB + PCERT_POLICY_QUALIFIER_INFO* = ptr CERT_POLICY_QUALIFIER_INFO + CERT_POLICY_INFO* {.pure.} = object + pszPolicyIdentifier*: LPSTR + cPolicyQualifier*: DWORD + rgPolicyQualifier*: ptr CERT_POLICY_QUALIFIER_INFO + PCERT_POLICY_INFO* = ptr CERT_POLICY_INFO + CERT_POLICIES_INFO* {.pure.} = object + cPolicyInfo*: DWORD + rgPolicyInfo*: ptr CERT_POLICY_INFO + PCERT_POLICIES_INFO* = ptr CERT_POLICIES_INFO + CERT_POLICY_QUALIFIER_NOTICE_REFERENCE* {.pure.} = object + pszOrganization*: LPSTR + cNoticeNumbers*: DWORD + rgNoticeNumbers*: ptr int32 + PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE* = ptr CERT_POLICY_QUALIFIER_NOTICE_REFERENCE + CERT_POLICY_QUALIFIER_USER_NOTICE* {.pure.} = object + pNoticeReference*: ptr CERT_POLICY_QUALIFIER_NOTICE_REFERENCE + pszDisplayText*: LPWSTR + PCERT_POLICY_QUALIFIER_USER_NOTICE* = ptr CERT_POLICY_QUALIFIER_USER_NOTICE + CPS_URLS* {.pure.} = object + pszURL*: LPWSTR + pAlgorithm*: ptr CRYPT_ALGORITHM_IDENTIFIER + pDigest*: ptr CRYPT_DATA_BLOB + PCPS_URLS* = ptr CPS_URLS + CERT_POLICY95_QUALIFIER1* {.pure.} = object + pszPracticesReference*: LPWSTR + pszNoticeIdentifier*: LPSTR + pszNSINoticeIdentifier*: LPSTR + cCPSURLs*: DWORD + rgCPSURLs*: ptr CPS_URLS + PCERT_POLICY95_QUALIFIER1* = ptr CERT_POLICY95_QUALIFIER1 + CERT_POLICY_MAPPING* {.pure.} = object + pszIssuerDomainPolicy*: LPSTR + pszSubjectDomainPolicy*: LPSTR + PCERT_POLICY_MAPPING* = ptr CERT_POLICY_MAPPING + CERT_POLICY_MAPPINGS_INFO* {.pure.} = object + cPolicyMapping*: DWORD + rgPolicyMapping*: PCERT_POLICY_MAPPING + PCERT_POLICY_MAPPINGS_INFO* = ptr CERT_POLICY_MAPPINGS_INFO + CERT_POLICY_CONSTRAINTS_INFO* {.pure.} = object + fRequireExplicitPolicy*: WINBOOL + dwRequireExplicitPolicySkipCerts*: DWORD + fInhibitPolicyMapping*: WINBOOL + dwInhibitPolicyMappingSkipCerts*: DWORD + PCERT_POLICY_CONSTRAINTS_INFO* = ptr CERT_POLICY_CONSTRAINTS_INFO + CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY* {.pure.} = object + pszObjId*: LPSTR + cValue*: DWORD + rgValue*: PCRYPT_DER_BLOB + PCRYPT_CONTENT_INFO_SEQUENCE_OF_ANY* = ptr CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY + CRYPT_CONTENT_INFO* {.pure.} = object + pszObjId*: LPSTR + Content*: CRYPT_DER_BLOB + PCRYPT_CONTENT_INFO* = ptr CRYPT_CONTENT_INFO + CRYPT_SEQUENCE_OF_ANY* {.pure.} = object + cValue*: DWORD + rgValue*: PCRYPT_DER_BLOB + PCRYPT_SEQUENCE_OF_ANY* = ptr CRYPT_SEQUENCE_OF_ANY + CERT_AUTHORITY_KEY_ID2_INFO* {.pure.} = object + KeyId*: CRYPT_DATA_BLOB + AuthorityCertIssuer*: CERT_ALT_NAME_INFO + AuthorityCertSerialNumber*: CRYPT_INTEGER_BLOB + PCERT_AUTHORITY_KEY_ID2_INFO* = ptr CERT_AUTHORITY_KEY_ID2_INFO + CERT_ACCESS_DESCRIPTION* {.pure.} = object + pszAccessMethod*: LPSTR + AccessLocation*: CERT_ALT_NAME_ENTRY + PCERT_ACCESS_DESCRIPTION* = ptr CERT_ACCESS_DESCRIPTION + CERT_AUTHORITY_INFO_ACCESS* {.pure.} = object + cAccDescr*: DWORD + rgAccDescr*: PCERT_ACCESS_DESCRIPTION + PCERT_AUTHORITY_INFO_ACCESS* = ptr CERT_AUTHORITY_INFO_ACCESS + CERT_SUBJECT_INFO_ACCESS* = CERT_AUTHORITY_INFO_ACCESS + PCERT_SUBJECT_INFO_ACCESS* = ptr CERT_AUTHORITY_INFO_ACCESS + CRL_DIST_POINT_NAME_UNION1* {.pure, union.} = object + FullName*: CERT_ALT_NAME_INFO + CRL_DIST_POINT_NAME* {.pure.} = object + dwDistPointNameChoice*: DWORD + union1*: CRL_DIST_POINT_NAME_UNION1 + PCRL_DIST_POINT_NAME* = ptr CRL_DIST_POINT_NAME + CRL_DIST_POINT* {.pure.} = object + DistPointName*: CRL_DIST_POINT_NAME + ReasonFlags*: CRYPT_BIT_BLOB + CRLIssuer*: CERT_ALT_NAME_INFO + PCRL_DIST_POINT* = ptr CRL_DIST_POINT + CRL_DIST_POINTS_INFO* {.pure.} = object + cDistPoint*: DWORD + rgDistPoint*: PCRL_DIST_POINT + PCRL_DIST_POINTS_INFO* = ptr CRL_DIST_POINTS_INFO + CROSS_CERT_DIST_POINTS_INFO* {.pure.} = object + dwSyncDeltaTime*: DWORD + cDistPoint*: DWORD + rgDistPoint*: PCERT_ALT_NAME_INFO + PCROSS_CERT_DIST_POINTS_INFO* = ptr CROSS_CERT_DIST_POINTS_INFO + CERT_PAIR* {.pure.} = object + Forward*: CERT_BLOB + Reverse*: CERT_BLOB + PCERT_PAIR* = ptr CERT_PAIR + CRL_ISSUING_DIST_POINT* {.pure.} = object + DistPointName*: CRL_DIST_POINT_NAME + fOnlyContainsUserCerts*: WINBOOL + fOnlyContainsCACerts*: WINBOOL + OnlySomeReasonFlags*: CRYPT_BIT_BLOB + fIndirectCRL*: WINBOOL + PCRL_ISSUING_DIST_POINT* = ptr CRL_ISSUING_DIST_POINT + CERT_GENERAL_SUBTREE* {.pure.} = object + Base*: CERT_ALT_NAME_ENTRY + dwMinimum*: DWORD + fMaximum*: WINBOOL + dwMaximum*: DWORD + PCERT_GENERAL_SUBTREE* = ptr CERT_GENERAL_SUBTREE + CERT_NAME_CONSTRAINTS_INFO* {.pure.} = object + cPermittedSubtree*: DWORD + rgPermittedSubtree*: PCERT_GENERAL_SUBTREE + cExcludedSubtree*: DWORD + rgExcludedSubtree*: PCERT_GENERAL_SUBTREE + PCERT_NAME_CONSTRAINTS_INFO* = ptr CERT_NAME_CONSTRAINTS_INFO + CERT_DSS_PARAMETERS* {.pure.} = object + p*: CRYPT_UINT_BLOB + q*: CRYPT_UINT_BLOB + g*: CRYPT_UINT_BLOB + PCERT_DSS_PARAMETERS* = ptr CERT_DSS_PARAMETERS + CERT_DH_PARAMETERS* {.pure.} = object + p*: CRYPT_UINT_BLOB + g*: CRYPT_UINT_BLOB + PCERT_DH_PARAMETERS* = ptr CERT_DH_PARAMETERS + CERT_ECC_SIGNATURE* {.pure.} = object + r*: CRYPT_UINT_BLOB + s*: CRYPT_UINT_BLOB + PCERT_ECC_SIGNATURE* = ptr CERT_ECC_SIGNATURE + CERT_X942_DH_VALIDATION_PARAMS* {.pure.} = object + seed*: CRYPT_BIT_BLOB + pgenCounter*: DWORD + PCERT_X942_DH_VALIDATION_PARAMS* = ptr CERT_X942_DH_VALIDATION_PARAMS + CERT_X942_DH_PARAMETERS* {.pure.} = object + p*: CRYPT_UINT_BLOB + g*: CRYPT_UINT_BLOB + q*: CRYPT_UINT_BLOB + j*: CRYPT_UINT_BLOB + pValidationParams*: PCERT_X942_DH_VALIDATION_PARAMS + PCERT_X942_DH_PARAMETERS* = ptr CERT_X942_DH_PARAMETERS +const + CRYPT_X942_COUNTER_BYTE_LENGTH* = 4 + CRYPT_X942_KEY_LENGTH_BYTE_LENGTH* = 4 +type + CRYPT_X942_OTHER_INFO* {.pure.} = object + pszContentEncryptionObjId*: LPSTR + rgbCounter*: array[CRYPT_X942_COUNTER_BYTE_LENGTH, BYTE] + rgbKeyLength*: array[CRYPT_X942_KEY_LENGTH_BYTE_LENGTH, BYTE] + PubInfo*: CRYPT_DATA_BLOB + PCRYPT_X942_OTHER_INFO* = ptr CRYPT_X942_OTHER_INFO +const + CRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTH* = 4 +type + CRYPT_ECC_CMS_SHARED_INFO* {.pure.} = object + Algorithm*: CRYPT_ALGORITHM_IDENTIFIER + EntityUInfo*: CRYPT_DATA_BLOB + rgbSuppPubInfo*: array[CRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTH, BYTE] + PCRYPT_ECC_CMS_SHARED_INFO* = ptr CRYPT_ECC_CMS_SHARED_INFO + CRYPT_RC2_CBC_PARAMETERS* {.pure.} = object + dwVersion*: DWORD + fIV*: WINBOOL + rgbIV*: array[8, BYTE] + PCRYPT_RC2_CBC_PARAMETERS* = ptr CRYPT_RC2_CBC_PARAMETERS + CRYPT_SMIME_CAPABILITY* {.pure.} = object + pszObjId*: LPSTR + Parameters*: CRYPT_OBJID_BLOB + PCRYPT_SMIME_CAPABILITY* = ptr CRYPT_SMIME_CAPABILITY + CRYPT_SMIME_CAPABILITIES* {.pure.} = object + cCapability*: DWORD + rgCapability*: PCRYPT_SMIME_CAPABILITY + PCRYPT_SMIME_CAPABILITIES* = ptr CRYPT_SMIME_CAPABILITIES + CERT_QC_STATEMENT* {.pure.} = object + pszStatementId*: LPSTR + StatementInfo*: CRYPT_OBJID_BLOB + PCERT_QC_STATEMENT* = ptr CERT_QC_STATEMENT + CERT_QC_STATEMENTS_EXT_INFO* {.pure.} = object + cStatement*: DWORD + rgStatement*: PCERT_QC_STATEMENT + PCERT_QC_STATEMENTS_EXT_INFO* = ptr CERT_QC_STATEMENTS_EXT_INFO + CRYPT_MASK_GEN_ALGORITHM* {.pure.} = object + pszObjId*: LPSTR + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + PCRYPT_MASK_GEN_ALGORITHM* = ptr CRYPT_MASK_GEN_ALGORITHM + CRYPT_RSA_SSA_PSS_PARAMETERS* {.pure.} = object + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + MaskGenAlgorithm*: CRYPT_MASK_GEN_ALGORITHM + dwSaltLength*: DWORD + dwTrailerField*: DWORD + PCRYPT_RSA_SSA_PSS_PARAMETERS* = ptr CRYPT_RSA_SSA_PSS_PARAMETERS + CRYPT_PSOURCE_ALGORITHM* {.pure.} = object + pszObjId*: LPSTR + EncodingParameters*: CRYPT_DATA_BLOB + PCRYPT_PSOURCE_ALGORITHM* = ptr CRYPT_PSOURCE_ALGORITHM + CRYPT_RSAES_OAEP_PARAMETERS* {.pure.} = object + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + MaskGenAlgorithm*: CRYPT_MASK_GEN_ALGORITHM + PSourceAlgorithm*: CRYPT_PSOURCE_ALGORITHM + PCRYPT_RSAES_OAEP_PARAMETERS* = ptr CRYPT_RSAES_OAEP_PARAMETERS + CMC_TAGGED_ATTRIBUTE* {.pure.} = object + dwBodyPartID*: DWORD + Attribute*: CRYPT_ATTRIBUTE + PCMC_TAGGED_ATTRIBUTE* = ptr CMC_TAGGED_ATTRIBUTE + CMC_TAGGED_CERT_REQUEST* {.pure.} = object + dwBodyPartID*: DWORD + SignedCertRequest*: CRYPT_DER_BLOB + PCMC_TAGGED_CERT_REQUEST* = ptr CMC_TAGGED_CERT_REQUEST + CMC_TAGGED_REQUEST_UNION1* {.pure, union.} = object + pTaggedCertRequest*: PCMC_TAGGED_CERT_REQUEST + CMC_TAGGED_REQUEST* {.pure.} = object + dwTaggedRequestChoice*: DWORD + union1*: CMC_TAGGED_REQUEST_UNION1 + PCMC_TAGGED_REQUEST* = ptr CMC_TAGGED_REQUEST + CMC_TAGGED_CONTENT_INFO* {.pure.} = object + dwBodyPartID*: DWORD + EncodedContentInfo*: CRYPT_DER_BLOB + PCMC_TAGGED_CONTENT_INFO* = ptr CMC_TAGGED_CONTENT_INFO + CMC_TAGGED_OTHER_MSG* {.pure.} = object + dwBodyPartID*: DWORD + pszObjId*: LPSTR + Value*: CRYPT_OBJID_BLOB + PCMC_TAGGED_OTHER_MSG* = ptr CMC_TAGGED_OTHER_MSG + CMC_DATA_INFO* {.pure.} = object + cTaggedAttribute*: DWORD + rgTaggedAttribute*: PCMC_TAGGED_ATTRIBUTE + cTaggedRequest*: DWORD + rgTaggedRequest*: PCMC_TAGGED_REQUEST + cTaggedContentInfo*: DWORD + rgTaggedContentInfo*: PCMC_TAGGED_CONTENT_INFO + cTaggedOtherMsg*: DWORD + rgTaggedOtherMsg*: PCMC_TAGGED_OTHER_MSG + PCMC_DATA_INFO* = ptr CMC_DATA_INFO + CMC_RESPONSE_INFO* {.pure.} = object + cTaggedAttribute*: DWORD + rgTaggedAttribute*: PCMC_TAGGED_ATTRIBUTE + cTaggedContentInfo*: DWORD + rgTaggedContentInfo*: PCMC_TAGGED_CONTENT_INFO + cTaggedOtherMsg*: DWORD + rgTaggedOtherMsg*: PCMC_TAGGED_OTHER_MSG + PCMC_RESPONSE_INFO* = ptr CMC_RESPONSE_INFO + CMC_PEND_INFO* {.pure.} = object + PendToken*: CRYPT_DATA_BLOB + PendTime*: FILETIME + PCMC_PEND_INFO* = ptr CMC_PEND_INFO + CMC_STATUS_INFO_UNION1* {.pure, union.} = object + dwFailInfo*: DWORD + pPendInfo*: PCMC_PEND_INFO + CMC_STATUS_INFO* {.pure.} = object + dwStatus*: DWORD + cBodyList*: DWORD + rgdwBodyList*: ptr DWORD + pwszStatusString*: LPWSTR + dwOtherInfoChoice*: DWORD + union1*: CMC_STATUS_INFO_UNION1 + PCMC_STATUS_INFO* = ptr CMC_STATUS_INFO + CMC_ADD_EXTENSIONS_INFO* {.pure.} = object + dwCmcDataReference*: DWORD + cCertReference*: DWORD + rgdwCertReference*: ptr DWORD + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCMC_ADD_EXTENSIONS_INFO* = ptr CMC_ADD_EXTENSIONS_INFO + CMC_ADD_ATTRIBUTES_INFO* {.pure.} = object + dwCmcDataReference*: DWORD + cCertReference*: DWORD + rgdwCertReference*: ptr DWORD + cAttribute*: DWORD + rgAttribute*: PCRYPT_ATTRIBUTE + PCMC_ADD_ATTRIBUTES_INFO* = ptr CMC_ADD_ATTRIBUTES_INFO + CERT_TEMPLATE_EXT* {.pure.} = object + pszObjId*: LPSTR + dwMajorVersion*: DWORD + fMinorVersion*: WINBOOL + dwMinorVersion*: DWORD + PCERT_TEMPLATE_EXT* = ptr CERT_TEMPLATE_EXT + CERT_HASHED_URL* {.pure.} = object + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Hash*: CRYPT_HASH_BLOB + pwszUrl*: LPWSTR + PCERT_HASHED_URL* = ptr CERT_HASHED_URL + CERT_LOGOTYPE_DETAILS* {.pure.} = object + pwszMimeType*: LPWSTR + cHashedUrl*: DWORD + rgHashedUrl*: PCERT_HASHED_URL + PCERT_LOGOTYPE_DETAILS* = ptr CERT_LOGOTYPE_DETAILS + CERT_LOGOTYPE_REFERENCE* {.pure.} = object + cHashedUrl*: DWORD + rgHashedUrl*: PCERT_HASHED_URL + PCERT_LOGOTYPE_REFERENCE* = ptr CERT_LOGOTYPE_REFERENCE + CERT_LOGOTYPE_IMAGE_INFO_UNION1* {.pure, union.} = object + dwNumBits*: DWORD + dwTableSize*: DWORD + CERT_LOGOTYPE_IMAGE_INFO* {.pure.} = object + dwLogotypeImageInfoChoice*: DWORD + dwFileSize*: DWORD + dwXSize*: DWORD + dwYSize*: DWORD + dwLogotypeImageResolutionChoice*: DWORD + union1*: CERT_LOGOTYPE_IMAGE_INFO_UNION1 + pwszLanguage*: LPWSTR + PCERT_LOGOTYPE_IMAGE_INFO* = ptr CERT_LOGOTYPE_IMAGE_INFO + CERT_LOGOTYPE_IMAGE* {.pure.} = object + LogotypeDetails*: CERT_LOGOTYPE_DETAILS + pLogotypeImageInfo*: PCERT_LOGOTYPE_IMAGE_INFO + PCERT_LOGOTYPE_IMAGE* = ptr CERT_LOGOTYPE_IMAGE + CERT_LOGOTYPE_AUDIO_INFO* {.pure.} = object + dwFileSize*: DWORD + dwPlayTime*: DWORD + dwChannels*: DWORD + dwSampleRate*: DWORD + pwszLanguage*: LPWSTR + PCERT_LOGOTYPE_AUDIO_INFO* = ptr CERT_LOGOTYPE_AUDIO_INFO + CERT_LOGOTYPE_AUDIO* {.pure.} = object + LogotypeDetails*: CERT_LOGOTYPE_DETAILS + pLogotypeAudioInfo*: PCERT_LOGOTYPE_AUDIO_INFO + PCERT_LOGOTYPE_AUDIO* = ptr CERT_LOGOTYPE_AUDIO + CERT_LOGOTYPE_DATA* {.pure.} = object + cLogotypeImage*: DWORD + rgLogotypeImage*: PCERT_LOGOTYPE_IMAGE + cLogotypeAudio*: DWORD + rgLogotypeAudio*: PCERT_LOGOTYPE_AUDIO + PCERT_LOGOTYPE_DATA* = ptr CERT_LOGOTYPE_DATA + CERT_LOGOTYPE_INFO_UNION1* {.pure, union.} = object + pLogotypeDirectInfo*: PCERT_LOGOTYPE_DATA + pLogotypeIndirectInfo*: PCERT_LOGOTYPE_REFERENCE + CERT_LOGOTYPE_INFO* {.pure.} = object + dwLogotypeInfoChoice*: DWORD + union1*: CERT_LOGOTYPE_INFO_UNION1 + PCERT_LOGOTYPE_INFO* = ptr CERT_LOGOTYPE_INFO + CERT_OTHER_LOGOTYPE_INFO* {.pure.} = object + pszObjId*: LPSTR + LogotypeInfo*: CERT_LOGOTYPE_INFO + PCERT_OTHER_LOGOTYPE_INFO* = ptr CERT_OTHER_LOGOTYPE_INFO + CERT_LOGOTYPE_EXT_INFO* {.pure.} = object + cCommunityLogo*: DWORD + rgCommunityLogo*: PCERT_LOGOTYPE_INFO + pIssuerLogo*: PCERT_LOGOTYPE_INFO + pSubjectLogo*: PCERT_LOGOTYPE_INFO + cOtherLogo*: DWORD + rgOtherLogo*: PCERT_OTHER_LOGOTYPE_INFO + PCERT_LOGOTYPE_EXT_INFO* = ptr CERT_LOGOTYPE_EXT_INFO + CERT_BIOMETRIC_DATA_UNION1* {.pure, union.} = object + dwPredefined*: DWORD + pszObjId*: LPSTR + CERT_BIOMETRIC_DATA* {.pure.} = object + dwTypeOfBiometricDataChoice*: DWORD + union1*: CERT_BIOMETRIC_DATA_UNION1 + HashedUrl*: CERT_HASHED_URL + PCERT_BIOMETRIC_DATA* = ptr CERT_BIOMETRIC_DATA + CERT_BIOMETRIC_EXT_INFO* {.pure.} = object + cBiometricData*: DWORD + rgBiometricData*: PCERT_BIOMETRIC_DATA + PCERT_BIOMETRIC_EXT_INFO* = ptr CERT_BIOMETRIC_EXT_INFO + OCSP_SIGNATURE_INFO* {.pure.} = object + SignatureAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Signature*: CRYPT_BIT_BLOB + cCertEncoded*: DWORD + rgCertEncoded*: PCERT_BLOB + POCSP_SIGNATURE_INFO* = ptr OCSP_SIGNATURE_INFO + OCSP_SIGNED_REQUEST_INFO* {.pure.} = object + ToBeSigned*: CRYPT_DER_BLOB + pOptionalSignatureInfo*: POCSP_SIGNATURE_INFO + POCSP_SIGNED_REQUEST_INFO* = ptr OCSP_SIGNED_REQUEST_INFO + OCSP_CERT_ID* {.pure.} = object + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + IssuerNameHash*: CRYPT_HASH_BLOB + IssuerKeyHash*: CRYPT_HASH_BLOB + SerialNumber*: CRYPT_INTEGER_BLOB + POCSP_CERT_ID* = ptr OCSP_CERT_ID + OCSP_REQUEST_ENTRY* {.pure.} = object + CertId*: OCSP_CERT_ID + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + POCSP_REQUEST_ENTRY* = ptr OCSP_REQUEST_ENTRY + OCSP_REQUEST_INFO* {.pure.} = object + dwVersion*: DWORD + pRequestorName*: PCERT_ALT_NAME_ENTRY + cRequestEntry*: DWORD + rgRequestEntry*: POCSP_REQUEST_ENTRY + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + POCSP_REQUEST_INFO* = ptr OCSP_REQUEST_INFO + OCSP_RESPONSE_INFO* {.pure.} = object + dwStatus*: DWORD + pszObjId*: LPSTR + Value*: CRYPT_OBJID_BLOB + POCSP_RESPONSE_INFO* = ptr OCSP_RESPONSE_INFO + OCSP_BASIC_SIGNED_RESPONSE_INFO* {.pure.} = object + ToBeSigned*: CRYPT_DER_BLOB + SignatureInfo*: OCSP_SIGNATURE_INFO + POCSP_BASIC_SIGNED_RESPONSE_INFO* = ptr OCSP_BASIC_SIGNED_RESPONSE_INFO + OCSP_BASIC_REVOKED_INFO* {.pure.} = object + RevocationDate*: FILETIME + dwCrlReasonCode*: DWORD + POCSP_BASIC_REVOKED_INFO* = ptr OCSP_BASIC_REVOKED_INFO + OCSP_BASIC_RESPONSE_ENTRY_UNION1* {.pure, union.} = object + pRevokedInfo*: POCSP_BASIC_REVOKED_INFO + OCSP_BASIC_RESPONSE_ENTRY* {.pure.} = object + CertId*: OCSP_CERT_ID + dwCertStatus*: DWORD + union1*: OCSP_BASIC_RESPONSE_ENTRY_UNION1 + ThisUpdate*: FILETIME + NextUpdate*: FILETIME + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + POCSP_BASIC_RESPONSE_ENTRY* = ptr OCSP_BASIC_RESPONSE_ENTRY + OCSP_BASIC_RESPONSE_INFO_UNION1* {.pure, union.} = object + ByNameResponderId*: CERT_NAME_BLOB + ByKeyResponderId*: CRYPT_HASH_BLOB + OCSP_BASIC_RESPONSE_INFO* {.pure.} = object + dwVersion*: DWORD + dwResponderIdChoice*: DWORD + union1*: OCSP_BASIC_RESPONSE_INFO_UNION1 + ProducedAt*: FILETIME + cResponseEntry*: DWORD + rgResponseEntry*: POCSP_BASIC_RESPONSE_ENTRY + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + POCSP_BASIC_RESPONSE_INFO* = ptr OCSP_BASIC_RESPONSE_INFO + CRYPT_OID_FUNC_ENTRY* {.pure.} = object + pszOID*: LPCSTR + pvFuncAddr*: pointer + PCRYPT_OID_FUNC_ENTRY* = ptr CRYPT_OID_FUNC_ENTRY + CRYPT_OID_INFO_UNION1* {.pure, union.} = object + dwValue*: DWORD + Algid*: ALG_ID + dwLength*: DWORD +when winimCpu64: + type + CRYPT_OID_INFO* {.pure.} = object + cbSize*: DWORD + pszOID*: LPCSTR + pwszName*: LPCWSTR + dwGroupId*: DWORD + union1*: CRYPT_OID_INFO_UNION1 + ExtraInfo*: CRYPT_DATA_BLOB + pwszCNGAlgid*: LPCWSTR + pwszCNGExtraAlgid*: LPCWSTR +when winimCpu32: + type + CRYPT_OID_INFO* {.pure, packed.} = object + cbSize*: DWORD + pszOID*: LPCSTR + pwszName*: LPCWSTR + dwGroupId*: DWORD + union1*: CRYPT_OID_INFO_UNION1 + ExtraInfo*: CRYPT_DATA_BLOB + pwszCNGAlgid*: LPCWSTR + pwszCNGExtraAlgid*: LPCWSTR +type + PCRYPT_OID_INFO* = ptr CRYPT_OID_INFO + CCRYPT_OID_INFO* = CRYPT_OID_INFO + PCCRYPT_OID_INFO* = ptr CRYPT_OID_INFO + CERT_STRONG_SIGN_SERIALIZED_INFO* {.pure.} = object + dwFlags*: DWORD + pwszCNGSignHashAlgids*: LPWSTR + pwszCNGPubKeyMinBitLengths*: LPWSTR + PCERT_STRONG_SIGN_SERIALIZED_INFO* = ptr CERT_STRONG_SIGN_SERIALIZED_INFO + CERT_STRONG_SIGN_PARA_UNION1* {.pure, union.} = object + pvInfo*: pointer + pSerializedInfo*: PCERT_STRONG_SIGN_SERIALIZED_INFO + pszOID*: LPSTR + CERT_STRONG_SIGN_PARA* {.pure.} = object + cbSize*: DWORD + dwInfoChoice*: DWORD + union1*: CERT_STRONG_SIGN_PARA_UNION1 + PCERT_STRONG_SIGN_PARA* = ptr CERT_STRONG_SIGN_PARA + PCCERT_STRONG_SIGN_PARA* = ptr CERT_STRONG_SIGN_PARA + CERT_ISSUER_SERIAL_NUMBER* {.pure.} = object + Issuer*: CERT_NAME_BLOB + SerialNumber*: CRYPT_INTEGER_BLOB + PCERT_ISSUER_SERIAL_NUMBER* = ptr CERT_ISSUER_SERIAL_NUMBER + CERT_ID_UNION1* {.pure, union.} = object + IssuerSerialNumber*: CERT_ISSUER_SERIAL_NUMBER + KeyId*: CRYPT_HASH_BLOB + HashId*: CRYPT_HASH_BLOB + CERT_ID* {.pure.} = object + dwIdChoice*: DWORD + union1*: CERT_ID_UNION1 + PCERT_ID* = ptr CERT_ID + CMSG_SIGNER_ENCODE_INFO_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CMSG_SIGNER_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + pCertInfo*: PCERT_INFO + union1*: CMSG_SIGNER_ENCODE_INFO_UNION1 + dwKeySpec*: DWORD + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashAuxInfo*: pointer + cAuthAttr*: DWORD + rgAuthAttr*: PCRYPT_ATTRIBUTE + cUnauthAttr*: DWORD + rgUnauthAttr*: PCRYPT_ATTRIBUTE + SignerId*: CERT_ID + HashEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashEncryptionAuxInfo*: pointer + PCMSG_SIGNER_ENCODE_INFO* = ptr CMSG_SIGNER_ENCODE_INFO + CMSG_SIGNED_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + cSigners*: DWORD + rgSigners*: PCMSG_SIGNER_ENCODE_INFO + cCertEncoded*: DWORD + rgCertEncoded*: PCERT_BLOB + cCrlEncoded*: DWORD + rgCrlEncoded*: PCRL_BLOB + cAttrCertEncoded*: DWORD + rgAttrCertEncoded*: PCERT_BLOB + PCMSG_SIGNED_ENCODE_INFO* = ptr CMSG_SIGNED_ENCODE_INFO + CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvKeyEncryptionAuxInfo*: pointer + hCryptProv*: HCRYPTPROV_LEGACY + RecipientPublicKey*: CRYPT_BIT_BLOB + RecipientId*: CERT_ID + PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO* = ptr CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO + CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_UNION1* {.pure, union.} = object + pEphemeralAlgorithm*: PCRYPT_ALGORITHM_IDENTIFIER + pSenderId*: PCERT_ID + CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + RecipientPublicKey*: CRYPT_BIT_BLOB + RecipientId*: CERT_ID + Date*: FILETIME + pOtherAttr*: PCRYPT_ATTRIBUTE_TYPE_VALUE + PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO* = ptr CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO + CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvKeyEncryptionAuxInfo*: pointer + KeyWrapAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvKeyWrapAuxInfo*: pointer + hCryptProv*: HCRYPTPROV_LEGACY + dwKeySpec*: DWORD + dwKeyChoice*: DWORD + union1*: CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_UNION1 + UserKeyingMaterial*: CRYPT_DATA_BLOB + cRecipientEncryptedKeys*: DWORD + rgpRecipientEncryptedKeys*: ptr PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO + PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO* = ptr CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO + CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_UNION1* {.pure, union.} = object + hKeyEncryptionKey*: HCRYPTKEY + pvKeyEncryptionKey*: pointer + CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvKeyEncryptionAuxInfo*: pointer + hCryptProv*: HCRYPTPROV + dwKeyChoice*: DWORD + union1*: CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_UNION1 + KeyId*: CRYPT_DATA_BLOB + Date*: FILETIME + pOtherAttr*: PCRYPT_ATTRIBUTE_TYPE_VALUE + PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO* = ptr CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO + CMSG_RECIPIENT_ENCODE_INFO_UNION1* {.pure, union.} = object + pKeyTrans*: PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO + pKeyAgree*: PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO + pMailList*: PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO + CMSG_RECIPIENT_ENCODE_INFO* {.pure.} = object + dwRecipientChoice*: DWORD + union1*: CMSG_RECIPIENT_ENCODE_INFO_UNION1 + PCMSG_RECIPIENT_ENCODE_INFO* = ptr CMSG_RECIPIENT_ENCODE_INFO + CMSG_ENVELOPED_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + ContentEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvEncryptionAuxInfo*: pointer + cRecipients*: DWORD + rgpRecipients*: ptr PCERT_INFO + rgCmsRecipients*: PCMSG_RECIPIENT_ENCODE_INFO + cCertEncoded*: DWORD + rgCertEncoded*: PCERT_BLOB + cCrlEncoded*: DWORD + rgCrlEncoded*: PCRL_BLOB + cAttrCertEncoded*: DWORD + rgAttrCertEncoded*: PCERT_BLOB + cUnprotectedAttr*: DWORD + rgUnprotectedAttr*: PCRYPT_ATTRIBUTE + PCMSG_ENVELOPED_ENCODE_INFO* = ptr CMSG_ENVELOPED_ENCODE_INFO + CMSG_RC2_AUX_INFO* {.pure.} = object + cbSize*: DWORD + dwBitLen*: DWORD + PCMSG_RC2_AUX_INFO* = ptr CMSG_RC2_AUX_INFO + CMSG_SP3_COMPATIBLE_AUX_INFO* {.pure.} = object + cbSize*: DWORD + dwFlags*: DWORD + PCMSG_SP3_COMPATIBLE_AUX_INFO* = ptr CMSG_SP3_COMPATIBLE_AUX_INFO + CMSG_RC4_AUX_INFO* {.pure.} = object + cbSize*: DWORD + dwBitLen*: DWORD + PCMSG_RC4_AUX_INFO* = ptr CMSG_RC4_AUX_INFO + CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + SignedInfo*: CMSG_SIGNED_ENCODE_INFO + EnvelopedInfo*: CMSG_ENVELOPED_ENCODE_INFO + PCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO* = ptr CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO + CMSG_HASHED_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashAuxInfo*: pointer + PCMSG_HASHED_ENCODE_INFO* = ptr CMSG_HASHED_ENCODE_INFO + CMSG_ENCRYPTED_ENCODE_INFO* {.pure.} = object + cbSize*: DWORD + ContentEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvEncryptionAuxInfo*: pointer + PCMSG_ENCRYPTED_ENCODE_INFO* = ptr CMSG_ENCRYPTED_ENCODE_INFO + PFN_CMSG_STREAM_OUTPUT* = proc (pvArg: pointer, pbData: ptr BYTE, cbData: DWORD, fFinal: WINBOOL): WINBOOL {.stdcall.} + CMSG_STREAM_INFO* {.pure.} = object + cbContent*: DWORD + pfnStreamOutput*: PFN_CMSG_STREAM_OUTPUT + pvArg*: pointer + PCMSG_STREAM_INFO* = ptr CMSG_STREAM_INFO + CMSG_SIGNER_INFO* {.pure.} = object + dwVersion*: DWORD + Issuer*: CERT_NAME_BLOB + SerialNumber*: CRYPT_INTEGER_BLOB + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + HashEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedHash*: CRYPT_DATA_BLOB + AuthAttrs*: CRYPT_ATTRIBUTES + UnauthAttrs*: CRYPT_ATTRIBUTES + PCMSG_SIGNER_INFO* = ptr CMSG_SIGNER_INFO + CMSG_CMS_SIGNER_INFO* {.pure.} = object + dwVersion*: DWORD + SignerId*: CERT_ID + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + HashEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedHash*: CRYPT_DATA_BLOB + AuthAttrs*: CRYPT_ATTRIBUTES + UnauthAttrs*: CRYPT_ATTRIBUTES + PCMSG_CMS_SIGNER_INFO* = ptr CMSG_CMS_SIGNER_INFO + CMSG_ATTR* = CRYPT_ATTRIBUTES + PCMSG_ATTR* = ptr CRYPT_ATTRIBUTES + CMSG_KEY_TRANS_RECIPIENT_INFO* {.pure.} = object + dwVersion*: DWORD + RecipientId*: CERT_ID + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedKey*: CRYPT_DATA_BLOB + PCMSG_KEY_TRANS_RECIPIENT_INFO* = ptr CMSG_KEY_TRANS_RECIPIENT_INFO + CMSG_RECIPIENT_ENCRYPTED_KEY_INFO* {.pure.} = object + RecipientId*: CERT_ID + EncryptedKey*: CRYPT_DATA_BLOB + Date*: FILETIME + pOtherAttr*: PCRYPT_ATTRIBUTE_TYPE_VALUE + PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO* = ptr CMSG_RECIPIENT_ENCRYPTED_KEY_INFO + CMSG_KEY_AGREE_RECIPIENT_INFO_UNION1* {.pure, union.} = object + OriginatorCertId*: CERT_ID + OriginatorPublicKeyInfo*: CERT_PUBLIC_KEY_INFO + CMSG_KEY_AGREE_RECIPIENT_INFO* {.pure.} = object + dwVersion*: DWORD + dwOriginatorChoice*: DWORD + union1*: CMSG_KEY_AGREE_RECIPIENT_INFO_UNION1 + UserKeyingMaterial*: CRYPT_DATA_BLOB + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + cRecipientEncryptedKeys*: DWORD + rgpRecipientEncryptedKeys*: ptr PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO + PCMSG_KEY_AGREE_RECIPIENT_INFO* = ptr CMSG_KEY_AGREE_RECIPIENT_INFO + CMSG_MAIL_LIST_RECIPIENT_INFO* {.pure.} = object + dwVersion*: DWORD + KeyId*: CRYPT_DATA_BLOB + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedKey*: CRYPT_DATA_BLOB + Date*: FILETIME + pOtherAttr*: PCRYPT_ATTRIBUTE_TYPE_VALUE + PCMSG_MAIL_LIST_RECIPIENT_INFO* = ptr CMSG_MAIL_LIST_RECIPIENT_INFO + CMSG_CMS_RECIPIENT_INFO_UNION1* {.pure, union.} = object + pKeyTrans*: PCMSG_KEY_TRANS_RECIPIENT_INFO + pKeyAgree*: PCMSG_KEY_AGREE_RECIPIENT_INFO + pMailList*: PCMSG_MAIL_LIST_RECIPIENT_INFO + CMSG_CMS_RECIPIENT_INFO* {.pure.} = object + dwRecipientChoice*: DWORD + union1*: CMSG_CMS_RECIPIENT_INFO_UNION1 + PCMSG_CMS_RECIPIENT_INFO* = ptr CMSG_CMS_RECIPIENT_INFO + CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA* {.pure.} = object + cbSize*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + dwSignerIndex*: DWORD + dwSignerType*: DWORD + pvSigner*: pointer + PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA* = ptr CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA + CMSG_CTRL_DECRYPT_PARA_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CMSG_CTRL_DECRYPT_PARA* {.pure.} = object + cbSize*: DWORD + union1*: CMSG_CTRL_DECRYPT_PARA_UNION1 + dwKeySpec*: DWORD + dwRecipientIndex*: DWORD + PCMSG_CTRL_DECRYPT_PARA* = ptr CMSG_CTRL_DECRYPT_PARA + CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CMSG_CTRL_KEY_TRANS_DECRYPT_PARA* {.pure.} = object + cbSize*: DWORD + union1*: CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_UNION1 + dwKeySpec*: DWORD + pKeyTrans*: PCMSG_KEY_TRANS_RECIPIENT_INFO + dwRecipientIndex*: DWORD + PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA* = ptr CMSG_CTRL_KEY_TRANS_DECRYPT_PARA + CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CMSG_CTRL_KEY_AGREE_DECRYPT_PARA* {.pure.} = object + cbSize*: DWORD + union1*: CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_UNION1 + dwKeySpec*: DWORD + pKeyAgree*: PCMSG_KEY_AGREE_RECIPIENT_INFO + dwRecipientIndex*: DWORD + dwRecipientEncryptedKeyIndex*: DWORD + OriginatorPublicKey*: CRYPT_BIT_BLOB + PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA* = ptr CMSG_CTRL_KEY_AGREE_DECRYPT_PARA + CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_UNION1* {.pure, union.} = object + hKeyEncryptionKey*: HCRYPTKEY + pvKeyEncryptionKey*: pointer + CMSG_CTRL_MAIL_LIST_DECRYPT_PARA* {.pure.} = object + cbSize*: DWORD + hCryptProv*: HCRYPTPROV + pMailList*: PCMSG_MAIL_LIST_RECIPIENT_INFO + dwRecipientIndex*: DWORD + dwKeyChoice*: DWORD + union1*: CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_UNION1 + PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA* = ptr CMSG_CTRL_MAIL_LIST_DECRYPT_PARA + CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA* {.pure.} = object + cbSize*: DWORD + dwSignerIndex*: DWORD + blob*: CRYPT_DATA_BLOB + PCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA* = ptr CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA + CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA* {.pure.} = object + cbSize*: DWORD + dwSignerIndex*: DWORD + dwUnauthAttrIndex*: DWORD + PCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA* = ptr CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA + PFN_CMSG_ALLOC* = proc (cb: int): pointer {.stdcall.} + PFN_CMSG_FREE* = proc (pv: pointer): void {.stdcall.} + CMSG_CONTENT_ENCRYPT_INFO_UNION1* {.pure, union.} = object + hContentEncryptKey*: HCRYPTKEY + hCNGContentEncryptKey*: BCRYPT_KEY_HANDLE + CMSG_CONTENT_ENCRYPT_INFO* {.pure.} = object + cbSize*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + ContentEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvEncryptionAuxInfo*: pointer + cRecipients*: DWORD + rgCmsRecipients*: PCMSG_RECIPIENT_ENCODE_INFO + pfnAlloc*: PFN_CMSG_ALLOC + pfnFree*: PFN_CMSG_FREE + dwEncryptFlags*: DWORD + union1*: CMSG_CONTENT_ENCRYPT_INFO_UNION1 + dwFlags*: DWORD + fCNG*: WINBOOL + pbCNGContentEncryptKeyObject*: ptr BYTE + pbContentEncryptKey*: ptr BYTE + cbContentEncryptKey*: DWORD + PCMSG_CONTENT_ENCRYPT_INFO* = ptr CMSG_CONTENT_ENCRYPT_INFO + CMSG_KEY_TRANS_ENCRYPT_INFO* {.pure.} = object + cbSize*: DWORD + dwRecipientIndex*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedKey*: CRYPT_DATA_BLOB + dwFlags*: DWORD + PCMSG_KEY_TRANS_ENCRYPT_INFO* = ptr CMSG_KEY_TRANS_ENCRYPT_INFO + CMSG_KEY_AGREE_KEY_ENCRYPT_INFO* {.pure.} = object + cbSize*: DWORD + EncryptedKey*: CRYPT_DATA_BLOB + PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO* = ptr CMSG_KEY_AGREE_KEY_ENCRYPT_INFO + CMSG_KEY_AGREE_ENCRYPT_INFO_UNION1* {.pure, union.} = object + OriginatorCertId*: CERT_ID + OriginatorPublicKeyInfo*: CERT_PUBLIC_KEY_INFO + CMSG_KEY_AGREE_ENCRYPT_INFO* {.pure.} = object + cbSize*: DWORD + dwRecipientIndex*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + UserKeyingMaterial*: CRYPT_DATA_BLOB + dwOriginatorChoice*: DWORD + union1*: CMSG_KEY_AGREE_ENCRYPT_INFO_UNION1 + cKeyAgreeKeyEncryptInfo*: DWORD + rgpKeyAgreeKeyEncryptInfo*: ptr PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO + dwFlags*: DWORD + PCMSG_KEY_AGREE_ENCRYPT_INFO* = ptr CMSG_KEY_AGREE_ENCRYPT_INFO + CMSG_MAIL_LIST_ENCRYPT_INFO* {.pure.} = object + cbSize*: DWORD + dwRecipientIndex*: DWORD + KeyEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + EncryptedKey*: CRYPT_DATA_BLOB + dwFlags*: DWORD + PCMSG_MAIL_LIST_ENCRYPT_INFO* = ptr CMSG_MAIL_LIST_ENCRYPT_INFO + CMSG_CNG_CONTENT_DECRYPT_INFO* {.pure.} = object + cbSize*: DWORD + ContentEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pfnAlloc*: PFN_CMSG_ALLOC + pfnFree*: PFN_CMSG_FREE + hNCryptKey*: NCRYPT_KEY_HANDLE + pbContentEncryptKey*: ptr BYTE + cbContentEncryptKey*: DWORD + hCNGContentEncryptKey*: BCRYPT_KEY_HANDLE + pbCNGContentEncryptKeyObject*: ptr BYTE + PCMSG_CNG_CONTENT_DECRYPT_INFO* = ptr CMSG_CNG_CONTENT_DECRYPT_INFO + CERT_CONTEXT* {.pure.} = object + dwCertEncodingType*: DWORD + pbCertEncoded*: ptr BYTE + cbCertEncoded*: DWORD + pCertInfo*: PCERT_INFO + hCertStore*: HCERTSTORE + PCERT_CONTEXT* = ptr CERT_CONTEXT + PCCERT_CONTEXT* = ptr CERT_CONTEXT + CRL_CONTEXT* {.pure.} = object + dwCertEncodingType*: DWORD + pbCrlEncoded*: ptr BYTE + cbCrlEncoded*: DWORD + pCrlInfo*: PCRL_INFO + hCertStore*: HCERTSTORE + PCRL_CONTEXT* = ptr CRL_CONTEXT + PCCRL_CONTEXT* = ptr CRL_CONTEXT + CTL_CONTEXT* {.pure.} = object + dwMsgAndCertEncodingType*: DWORD + pbCtlEncoded*: ptr BYTE + cbCtlEncoded*: DWORD + pCtlInfo*: PCTL_INFO + hCertStore*: HCERTSTORE + hCryptMsg*: HCRYPTMSG + pbCtlContent*: ptr BYTE + cbCtlContent*: DWORD + PCTL_CONTEXT* = ptr CTL_CONTEXT + PCCTL_CONTEXT* = ptr CTL_CONTEXT + CRYPT_KEY_PROV_PARAM* {.pure.} = object + dwParam*: DWORD + pbData*: ptr BYTE + cbData*: DWORD + dwFlags*: DWORD + PCRYPT_KEY_PROV_PARAM* = ptr CRYPT_KEY_PROV_PARAM + CRYPT_KEY_PROV_INFO* {.pure.} = object + pwszContainerName*: LPWSTR + pwszProvName*: LPWSTR + dwProvType*: DWORD + dwFlags*: DWORD + cProvParam*: DWORD + rgProvParam*: PCRYPT_KEY_PROV_PARAM + dwKeySpec*: DWORD + PCRYPT_KEY_PROV_INFO* = ptr CRYPT_KEY_PROV_INFO + CERT_KEY_CONTEXT_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CERT_KEY_CONTEXT* {.pure.} = object + cbSize*: DWORD + union1*: CERT_KEY_CONTEXT_UNION1 + dwKeySpec*: DWORD + PCERT_KEY_CONTEXT* = ptr CERT_KEY_CONTEXT + ROOT_INFO_LUID* {.pure.} = object + LowPart*: DWORD + HighPart*: LONG + PROOT_INFO_LUID* = ptr ROOT_INFO_LUID + CRYPT_SMART_CARD_ROOT_INFO* {.pure.} = object + rgbCardID*: array[16, BYTE] + luid*: ROOT_INFO_LUID + PCRYPT_SMART_CARD_ROOT_INFO* = ptr CRYPT_SMART_CARD_ROOT_INFO + CERT_SYSTEM_STORE_RELOCATE_PARA_UNION1* {.pure, union.} = object + hKeyBase*: HKEY + pvBase*: pointer + CERT_SYSTEM_STORE_RELOCATE_PARA_UNION2* {.pure, union.} = object + pvSystemStore*: pointer + pszSystemStore*: LPCSTR + pwszSystemStore*: LPCWSTR + CERT_SYSTEM_STORE_RELOCATE_PARA* {.pure.} = object + union1*: CERT_SYSTEM_STORE_RELOCATE_PARA_UNION1 + union2*: CERT_SYSTEM_STORE_RELOCATE_PARA_UNION2 + PCERT_SYSTEM_STORE_RELOCATE_PARA* = ptr CERT_SYSTEM_STORE_RELOCATE_PARA + CERT_REGISTRY_STORE_CLIENT_GPT_PARA* {.pure.} = object + hKeyBase*: HKEY + pwszRegPath*: LPWSTR + PCERT_REGISTRY_STORE_CLIENT_GPT_PARA* = ptr CERT_REGISTRY_STORE_CLIENT_GPT_PARA + CERT_REGISTRY_STORE_ROAMING_PARA* {.pure.} = object + hKey*: HKEY + pwszStoreDirectory*: LPWSTR + PCERT_REGISTRY_STORE_ROAMING_PARA* = ptr CERT_REGISTRY_STORE_ROAMING_PARA + CERT_LDAP_STORE_OPENED_PARA* {.pure.} = object + pvLdapSessionHandle*: pointer + pwszLdapUrl*: LPCWSTR + PCERT_LDAP_STORE_OPENED_PARA* = ptr CERT_LDAP_STORE_OPENED_PARA + CERT_STORE_PROV_INFO* {.pure.} = object + cbSize*: DWORD + cStoreProvFunc*: DWORD + rgpvStoreProvFunc*: ptr pointer + hStoreProv*: HCERTSTOREPROV + dwStoreProvFlags*: DWORD + hStoreProvFuncAddr2*: HCRYPTOIDFUNCADDR + PCERT_STORE_PROV_INFO* = ptr CERT_STORE_PROV_INFO + CERT_STORE_PROV_FIND_INFO* {.pure.} = object + cbSize*: DWORD + dwMsgAndCertEncodingType*: DWORD + dwFindFlags*: DWORD + dwFindType*: DWORD + pvFindPara*: pointer + PCERT_STORE_PROV_FIND_INFO* = ptr CERT_STORE_PROV_FIND_INFO + CCERT_STORE_PROV_FIND_INFO* = CERT_STORE_PROV_FIND_INFO + PCCERT_STORE_PROV_FIND_INFO* = ptr CERT_STORE_PROV_FIND_INFO + CRL_FIND_ISSUED_FOR_PARA* {.pure.} = object + pSubjectCert*: PCCERT_CONTEXT + pIssuerCert*: PCCERT_CONTEXT + PCRL_FIND_ISSUED_FOR_PARA* = ptr CRL_FIND_ISSUED_FOR_PARA + CTL_ANY_SUBJECT_INFO* {.pure.} = object + SubjectAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + SubjectIdentifier*: CRYPT_DATA_BLOB + PCTL_ANY_SUBJECT_INFO* = ptr CTL_ANY_SUBJECT_INFO + CTL_FIND_USAGE_PARA* {.pure.} = object + cbSize*: DWORD + SubjectUsage*: CTL_USAGE + ListIdentifier*: CRYPT_DATA_BLOB + pSigner*: PCERT_INFO + PCTL_FIND_USAGE_PARA* = ptr CTL_FIND_USAGE_PARA + CTL_FIND_SUBJECT_PARA* {.pure.} = object + cbSize*: DWORD + pUsagePara*: PCTL_FIND_USAGE_PARA + dwSubjectType*: DWORD + pvSubject*: pointer + PCTL_FIND_SUBJECT_PARA* = ptr CTL_FIND_SUBJECT_PARA + PFN_CERT_CREATE_CONTEXT_SORT_FUNC* = proc (cbTotalEncoded: DWORD, cbRemainEncoded: DWORD, cEntry: DWORD, pvSort: pointer): WINBOOL {.stdcall.} + CERT_CREATE_CONTEXT_PARA* {.pure.} = object + cbSize*: DWORD + pfnFree*: PFN_CRYPT_FREE + pvFree*: pointer + pfnSort*: PFN_CERT_CREATE_CONTEXT_SORT_FUNC + pvSort*: pointer + PCERT_CREATE_CONTEXT_PARA* = ptr CERT_CREATE_CONTEXT_PARA + CERT_SYSTEM_STORE_INFO* {.pure.} = object + cbSize*: DWORD + PCERT_SYSTEM_STORE_INFO* = ptr CERT_SYSTEM_STORE_INFO + CERT_PHYSICAL_STORE_INFO* {.pure.} = object + cbSize*: DWORD + pszOpenStoreProvider*: LPSTR + dwOpenEncodingType*: DWORD + dwOpenFlags*: DWORD + OpenParameters*: CRYPT_DATA_BLOB + dwFlags*: DWORD + dwPriority*: DWORD + PCERT_PHYSICAL_STORE_INFO* = ptr CERT_PHYSICAL_STORE_INFO + CTL_VERIFY_USAGE_PARA* {.pure.} = object + cbSize*: DWORD + ListIdentifier*: CRYPT_DATA_BLOB + cCtlStore*: DWORD + rghCtlStore*: ptr HCERTSTORE + cSignerStore*: DWORD + rghSignerStore*: ptr HCERTSTORE + PCTL_VERIFY_USAGE_PARA* = ptr CTL_VERIFY_USAGE_PARA + CTL_VERIFY_USAGE_STATUS* {.pure.} = object + cbSize*: DWORD + dwError*: DWORD + dwFlags*: DWORD + ppCtl*: ptr PCCTL_CONTEXT + dwCtlEntryIndex*: DWORD + ppSigner*: ptr PCCERT_CONTEXT + dwSignerIndex*: DWORD + PCTL_VERIFY_USAGE_STATUS* = ptr CTL_VERIFY_USAGE_STATUS + CERT_REVOCATION_CRL_INFO* {.pure.} = object + cbSize*: DWORD + pBaseCrlContext*: PCCRL_CONTEXT + pDeltaCrlContext*: PCCRL_CONTEXT + pCrlEntry*: PCRL_ENTRY + fDeltaCrlEntry*: WINBOOL + PCERT_REVOCATION_CRL_INFO* = ptr CERT_REVOCATION_CRL_INFO + CERT_REVOCATION_CHAIN_PARA* {.pure.} = object + cbSize*: DWORD + hChainEngine*: HCERTCHAINENGINE + hAdditionalStore*: HCERTSTORE + dwChainFlags*: DWORD + dwUrlRetrievalTimeout*: DWORD + pftCurrentTime*: LPFILETIME + pftCacheResync*: LPFILETIME + cbMaxUrlRetrievalByteCount*: DWORD + PCERT_REVOCATION_CHAIN_PARA* = ptr CERT_REVOCATION_CHAIN_PARA + CERT_REVOCATION_PARA* {.pure.} = object + cbSize*: DWORD + pIssuerCert*: PCCERT_CONTEXT + cCertStore*: DWORD + rgCertStore*: ptr HCERTSTORE + hCrlStore*: HCERTSTORE + pftTimeToUse*: LPFILETIME + dwUrlRetrievalTimeout*: DWORD + fCheckFreshnessTime*: WINBOOL + dwFreshnessTime*: DWORD + pftCurrentTime*: LPFILETIME + pCrlInfo*: PCERT_REVOCATION_CRL_INFO + pftCacheResync*: LPFILETIME + pChainPara*: PCERT_REVOCATION_CHAIN_PARA + PCERT_REVOCATION_PARA* = ptr CERT_REVOCATION_PARA + CERT_REVOCATION_STATUS* {.pure.} = object + cbSize*: DWORD + dwIndex*: DWORD + dwError*: DWORD + dwReason*: DWORD + fHasFreshnessTime*: WINBOOL + dwFreshnessTime*: DWORD + PCERT_REVOCATION_STATUS* = ptr CERT_REVOCATION_STATUS + CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO* {.pure.} = object + CertSignHashCNGAlgPropData*: CRYPT_DATA_BLOB + CertIssuerPubKeyBitLengthPropData*: CRYPT_DATA_BLOB + PCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO* = ptr CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO + CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA* {.pure.} = object + cOID*: DWORD + rgpszOID*: ptr LPSTR + PCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA* = ptr CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA + CRYPT_SIGN_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgEncodingType*: DWORD + pSigningCert*: PCCERT_CONTEXT + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashAuxInfo*: pointer + cMsgCert*: DWORD + rgpMsgCert*: ptr PCCERT_CONTEXT + cMsgCrl*: DWORD + rgpMsgCrl*: ptr PCCRL_CONTEXT + cAuthAttr*: DWORD + rgAuthAttr*: PCRYPT_ATTRIBUTE + cUnauthAttr*: DWORD + rgUnauthAttr*: PCRYPT_ATTRIBUTE + dwFlags*: DWORD + dwInnerContentType*: DWORD + HashEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashEncryptionAuxInfo*: pointer + PCRYPT_SIGN_MESSAGE_PARA* = ptr CRYPT_SIGN_MESSAGE_PARA + PFN_CRYPT_GET_SIGNER_CERTIFICATE* = proc (pvGetArg: pointer, dwCertEncodingType: DWORD, pSignerId: PCERT_INFO, hMsgCertStore: HCERTSTORE): PCCERT_CONTEXT {.stdcall.} + CRYPT_VERIFY_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgAndCertEncodingType*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + pfnGetSignerCertificate*: PFN_CRYPT_GET_SIGNER_CERTIFICATE + pvGetArg*: pointer + pStrongSignPara*: PCCERT_STRONG_SIGN_PARA + PCRYPT_VERIFY_MESSAGE_PARA* = ptr CRYPT_VERIFY_MESSAGE_PARA + CRYPT_ENCRYPT_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgEncodingType*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + ContentEncryptionAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvEncryptionAuxInfo*: pointer + dwFlags*: DWORD + dwInnerContentType*: DWORD + PCRYPT_ENCRYPT_MESSAGE_PARA* = ptr CRYPT_ENCRYPT_MESSAGE_PARA + CRYPT_DECRYPT_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgAndCertEncodingType*: DWORD + cCertStore*: DWORD + rghCertStore*: ptr HCERTSTORE + dwFlags*: DWORD + PCRYPT_DECRYPT_MESSAGE_PARA* = ptr CRYPT_DECRYPT_MESSAGE_PARA + CRYPT_HASH_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgEncodingType*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashAuxInfo*: pointer + PCRYPT_HASH_MESSAGE_PARA* = ptr CRYPT_HASH_MESSAGE_PARA + CRYPT_KEY_SIGN_MESSAGE_PARA_UNION1* {.pure, union.} = object + hCryptProv*: HCRYPTPROV + hNCryptKey*: NCRYPT_KEY_HANDLE + CRYPT_KEY_SIGN_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgAndCertEncodingType*: DWORD + union1*: CRYPT_KEY_SIGN_MESSAGE_PARA_UNION1 + dwKeySpec*: DWORD + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + pvHashAuxInfo*: pointer + PubKeyAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + PCRYPT_KEY_SIGN_MESSAGE_PARA* = ptr CRYPT_KEY_SIGN_MESSAGE_PARA + CRYPT_KEY_VERIFY_MESSAGE_PARA* {.pure.} = object + cbSize*: DWORD + dwMsgEncodingType*: DWORD + hCryptProv*: HCRYPTPROV_LEGACY + PCRYPT_KEY_VERIFY_MESSAGE_PARA* = ptr CRYPT_KEY_VERIFY_MESSAGE_PARA + CERT_CHAIN* {.pure.} = object + cCerts*: DWORD + certs*: PCERT_BLOB + keyLocatorInfo*: CRYPT_KEY_PROV_INFO + PCERT_CHAIN* = ptr CERT_CHAIN + CRYPT_BLOB_ARRAY* {.pure.} = object + cBlob*: DWORD + rgBlob*: PCRYPT_DATA_BLOB + PCRYPT_BLOB_ARRAY* = ptr CRYPT_BLOB_ARRAY + CRYPT_CREDENTIALS* {.pure.} = object + cbSize*: DWORD + pszCredentialsOid*: LPCSTR + pvCredentials*: LPVOID + PCRYPT_CREDENTIALS* = ptr CRYPT_CREDENTIALS + CRYPT_PASSWORD_CREDENTIALSA* {.pure.} = object + cbSize*: DWORD + pszUsername*: LPSTR + pszPassword*: LPSTR + PCRYPT_PASSWORD_CREDENTIALSA* = ptr CRYPT_PASSWORD_CREDENTIALSA + CRYPT_PASSWORD_CREDENTIALSW* {.pure.} = object + cbSize*: DWORD + pszUsername*: LPWSTR + pszPassword*: LPWSTR + PCRYPT_PASSWORD_CREDENTIALSW* = ptr CRYPT_PASSWORD_CREDENTIALSW + CRYPTNET_URL_CACHE_PRE_FETCH_INFO* {.pure.} = object + cbSize*: DWORD + dwObjectType*: DWORD + dwError*: DWORD + dwReserved*: DWORD + ThisUpdateTime*: FILETIME + NextUpdateTime*: FILETIME + PublishTime*: FILETIME + PCRYPTNET_URL_CACHE_PRE_FETCH_INFO* = ptr CRYPTNET_URL_CACHE_PRE_FETCH_INFO + CRYPTNET_URL_CACHE_FLUSH_INFO* {.pure.} = object + cbSize*: DWORD + dwExemptSeconds*: DWORD + ExpireTime*: FILETIME + PCRYPTNET_URL_CACHE_FLUSH_INFO* = ptr CRYPTNET_URL_CACHE_FLUSH_INFO + CRYPTNET_URL_CACHE_RESPONSE_INFO* {.pure.} = object + cbSize*: DWORD + wResponseType*: WORD + wResponseFlags*: WORD + LastModifiedTime*: FILETIME + dwMaxAge*: DWORD + pwszETag*: LPCWSTR + dwProxyId*: DWORD + PCRYPTNET_URL_CACHE_RESPONSE_INFO* = ptr CRYPTNET_URL_CACHE_RESPONSE_INFO + CRYPT_RETRIEVE_AUX_INFO* {.pure.} = object + cbSize*: DWORD + pLastSyncTime*: ptr FILETIME + dwMaxUrlRetrievalByteCount*: DWORD + pPreFetchInfo*: PCRYPTNET_URL_CACHE_PRE_FETCH_INFO + pFlushInfo*: PCRYPTNET_URL_CACHE_FLUSH_INFO + ppResponseInfo*: ptr PCRYPTNET_URL_CACHE_RESPONSE_INFO + pwszCacheFileNamePrefix*: LPWSTR + pftCacheResync*: LPFILETIME + fProxyCacheRetrieval*: WINBOOL + dwHttpStatusCode*: DWORD + PCRYPT_RETRIEVE_AUX_INFO* = ptr CRYPT_RETRIEVE_AUX_INFO + PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC* = proc (pvCompletion: LPVOID, dwCompletionCode: DWORD, pszUrl: LPCSTR, pszObjectOid: LPSTR, pvObject: LPVOID): VOID {.stdcall.} + CRYPT_ASYNC_RETRIEVAL_COMPLETION* {.pure.} = object + pfnCompletion*: PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC + pvCompletion*: LPVOID + PCRYPT_ASYNC_RETRIEVAL_COMPLETION* = ptr CRYPT_ASYNC_RETRIEVAL_COMPLETION + CRYPT_URL_ARRAY* {.pure.} = object + cUrl*: DWORD + rgwszUrl*: ptr LPWSTR + PCRYPT_URL_ARRAY* = ptr CRYPT_URL_ARRAY + CRYPT_URL_INFO* {.pure.} = object + cbSize*: DWORD + dwSyncDeltaTime*: DWORD + cGroup*: DWORD + rgcGroupEntry*: ptr DWORD + PCRYPT_URL_INFO* = ptr CRYPT_URL_INFO + CERT_CRL_CONTEXT_PAIR* {.pure.} = object + pCertContext*: PCCERT_CONTEXT + pCrlContext*: PCCRL_CONTEXT + PCERT_CRL_CONTEXT_PAIR* = ptr CERT_CRL_CONTEXT_PAIR + PCCERT_CRL_CONTEXT_PAIR* = ptr CERT_CRL_CONTEXT_PAIR + CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO* {.pure.} = object + cbSize*: DWORD + iDeltaCrlIndicator*: int32 + pftCacheResync*: LPFILETIME + pLastSyncTime*: LPFILETIME + pMaxAgeTime*: LPFILETIME + pChainPara*: PCERT_REVOCATION_CHAIN_PARA + pDeltaCrlIndicator*: PCRYPT_INTEGER_BLOB + PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO* = ptr CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO + CERT_CHAIN_ENGINE_CONFIG* {.pure.} = object + cbSize*: DWORD + hRestrictedRoot*: HCERTSTORE + hRestrictedTrust*: HCERTSTORE + hRestrictedOther*: HCERTSTORE + cAdditionalStore*: DWORD + rghAdditionalStore*: ptr HCERTSTORE + dwFlags*: DWORD + dwUrlRetrievalTimeout*: DWORD + MaximumCachedCertificates*: DWORD + CycleDetectionModulus*: DWORD + hExclusiveRoot*: HCERTSTORE + hExclusiveTrustedPeople*: HCERTSTORE + dwExclusiveFlags*: DWORD + PCERT_CHAIN_ENGINE_CONFIG* = ptr CERT_CHAIN_ENGINE_CONFIG + CERT_TRUST_STATUS* {.pure.} = object + dwErrorStatus*: DWORD + dwInfoStatus*: DWORD + PCERT_TRUST_STATUS* = ptr CERT_TRUST_STATUS + CERT_REVOCATION_INFO* {.pure.} = object + cbSize*: DWORD + dwRevocationResult*: DWORD + pszRevocationOid*: LPCSTR + pvOidSpecificInfo*: LPVOID + fHasFreshnessTime*: WINBOOL + dwFreshnessTime*: DWORD + pCrlInfo*: PCERT_REVOCATION_CRL_INFO + PCERT_REVOCATION_INFO* = ptr CERT_REVOCATION_INFO + CERT_TRUST_LIST_INFO* {.pure.} = object + cbSize*: DWORD + pCtlEntry*: PCTL_ENTRY + pCtlContext*: PCCTL_CONTEXT + PCERT_TRUST_LIST_INFO* = ptr CERT_TRUST_LIST_INFO + CERT_CHAIN_ELEMENT* {.pure.} = object + cbSize*: DWORD + pCertContext*: PCCERT_CONTEXT + TrustStatus*: CERT_TRUST_STATUS + pRevocationInfo*: PCERT_REVOCATION_INFO + pIssuanceUsage*: PCERT_ENHKEY_USAGE + pApplicationUsage*: PCERT_ENHKEY_USAGE + pwszExtendedErrorInfo*: LPCWSTR + PCERT_CHAIN_ELEMENT* = ptr CERT_CHAIN_ELEMENT + PCCERT_CHAIN_ELEMENT* = ptr CERT_CHAIN_ELEMENT + CERT_SIMPLE_CHAIN* {.pure.} = object + cbSize*: DWORD + TrustStatus*: CERT_TRUST_STATUS + cElement*: DWORD + rgpElement*: ptr PCERT_CHAIN_ELEMENT + pTrustListInfo*: PCERT_TRUST_LIST_INFO + fHasRevocationFreshnessTime*: WINBOOL + dwRevocationFreshnessTime*: DWORD + PCERT_SIMPLE_CHAIN* = ptr CERT_SIMPLE_CHAIN + PCCERT_SIMPLE_CHAIN* = ptr CERT_SIMPLE_CHAIN + PCCERT_CHAIN_CONTEXT* = ptr CERT_CHAIN_CONTEXT + CERT_CHAIN_CONTEXT* {.pure.} = object + cbSize*: DWORD + TrustStatus*: CERT_TRUST_STATUS + cChain*: DWORD + rgpChain*: ptr PCERT_SIMPLE_CHAIN + cLowerQualityChainContext*: DWORD + rgpLowerQualityChainContext*: ptr PCCERT_CHAIN_CONTEXT + fHasRevocationFreshnessTime*: WINBOOL + dwRevocationFreshnessTime*: DWORD + dwCreateFlags*: DWORD + ChainId*: GUID + PCERT_CHAIN_CONTEXT* = ptr CERT_CHAIN_CONTEXT + CERT_USAGE_MATCH* {.pure.} = object + dwType*: DWORD + Usage*: CERT_ENHKEY_USAGE + PCERT_USAGE_MATCH* = ptr CERT_USAGE_MATCH + CTL_USAGE_MATCH* {.pure.} = object + dwType*: DWORD + Usage*: CTL_USAGE + PCTL_USAGE_MATCH* = ptr CTL_USAGE_MATCH + CERT_CHAIN_PARA* {.pure.} = object + cbSize*: DWORD + RequestedUsage*: CERT_USAGE_MATCH + RequestedIssuancePolicy*: CERT_USAGE_MATCH + dwUrlRetrievalTimeout*: DWORD + fCheckRevocationFreshnessTime*: WINBOOL + dwRevocationFreshnessTime*: DWORD + pftCacheResync*: LPFILETIME + pStrongSignPara*: PCCERT_STRONG_SIGN_PARA + dwStrongSignFlags*: DWORD + PCERT_CHAIN_PARA* = ptr CERT_CHAIN_PARA + CRL_REVOCATION_INFO* {.pure.} = object + pCrlEntry*: PCRL_ENTRY + pCrlContext*: PCCRL_CONTEXT + pCrlIssuerChain*: PCCERT_CHAIN_CONTEXT + PCRL_REVOCATION_INFO* = ptr CRL_REVOCATION_INFO + PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK* = proc (pCert: PCCERT_CONTEXT, pvFindArg: pointer): WINBOOL {.stdcall.} + CERT_CHAIN_FIND_ISSUER_PARA* {.pure.} = object + cbSize*: DWORD + pszUsageIdentifier*: LPCSTR + dwKeySpec*: DWORD + dwAcquirePrivateKeyFlags*: DWORD + cIssuer*: DWORD + rgIssuer*: ptr CERT_NAME_BLOB + pfnFindCallback*: PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK + pvFindArg*: pointer + pdwIssuerChainIndex*: ptr DWORD + pdwIssuerElementIndex*: ptr DWORD + PCERT_CHAIN_FIND_ISSUER_PARA* = ptr CERT_CHAIN_FIND_ISSUER_PARA + CERT_CHAIN_FIND_BY_ISSUER_PARA* = CERT_CHAIN_FIND_ISSUER_PARA + PCERT_CHAIN_FIND_BY_ISSUER_PARA* = ptr CERT_CHAIN_FIND_ISSUER_PARA + CERT_CHAIN_POLICY_PARA* {.pure.} = object + cbSize*: DWORD + dwFlags*: DWORD + pvExtraPolicyPara*: pointer + PCERT_CHAIN_POLICY_PARA* = ptr CERT_CHAIN_POLICY_PARA + CERT_CHAIN_POLICY_STATUS* {.pure.} = object + cbSize*: DWORD + dwError*: DWORD + lChainIndex*: LONG + lElementIndex*: LONG + pvExtraPolicyStatus*: pointer + PCERT_CHAIN_POLICY_STATUS* = ptr CERT_CHAIN_POLICY_STATUS + AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA* {.pure.} = object + cbSize*: DWORD + dwRegPolicySettings*: DWORD + pSignerInfo*: PCMSG_SIGNER_INFO + PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA* = ptr AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA + AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS* {.pure.} = object + cbSize*: DWORD + fCommercial*: WINBOOL + PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS* = ptr AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS + AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA* {.pure.} = object + cbSize*: DWORD + dwRegPolicySettings*: DWORD + fCommercial*: WINBOOL + PAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA* = ptr AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA + HTTPSPolicyCallbackData_UNION1* {.pure, union.} = object + cbStruct*: DWORD + cbSize*: DWORD + HTTPSPolicyCallbackData* {.pure.} = object + union1*: HTTPSPolicyCallbackData_UNION1 + dwAuthType*: DWORD + fdwChecks*: DWORD + pwszServerName*: ptr WCHAR + PHTTPSPolicyCallbackData* = ptr HTTPSPolicyCallbackData + SSL_EXTRA_CERT_CHAIN_POLICY_PARA* = HTTPSPolicyCallbackData + PSSL_EXTRA_CERT_CHAIN_POLICY_PARA* = ptr HTTPSPolicyCallbackData + EV_EXTRA_CERT_CHAIN_POLICY_PARA* {.pure.} = object + cbSize*: DWORD + dwRootProgramQualifierFlags*: DWORD + PEV_EXTRA_CERT_CHAIN_POLICY_PARA* = ptr EV_EXTRA_CERT_CHAIN_POLICY_PARA + EV_EXTRA_CERT_CHAIN_POLICY_STATUS* {.pure.} = object + cbSize*: DWORD + dwQualifiers*: DWORD + dwIssuanceUsageIndex*: DWORD + PEV_EXTRA_CERT_CHAIN_POLICY_STATUS* = ptr EV_EXTRA_CERT_CHAIN_POLICY_STATUS + CERT_SERVER_OCSP_RESPONSE_CONTEXT* {.pure.} = object + cbSize*: DWORD + pbEncodedOcspResponse*: ptr BYTE + cbEncodedOcspResponse*: DWORD + PCERT_SERVER_OCSP_RESPONSE_CONTEXT* = ptr CERT_SERVER_OCSP_RESPONSE_CONTEXT + PCCERT_SERVER_OCSP_RESPONSE_CONTEXT* = ptr CERT_SERVER_OCSP_RESPONSE_CONTEXT + CERT_SELECT_CHAIN_PARA* {.pure.} = object + hChainEngine*: HCERTCHAINENGINE + pTime*: PFILETIME + hAdditionalStore*: HCERTSTORE + pChainPara*: PCERT_CHAIN_PARA + dwFlags*: DWORD + PCERT_SELECT_CHAIN_PARA* = ptr CERT_SELECT_CHAIN_PARA + PCCERT_SELECT_CHAIN_PARA* = ptr CERT_SELECT_CHAIN_PARA + CERT_SELECT_CRITERIA* {.pure.} = object + dwType*: DWORD + cPara*: DWORD + ppPara*: ptr pointer + PCERT_SELECT_CRITERIA* = ptr CERT_SELECT_CRITERIA + PCCERT_SELECT_CRITERIA* = ptr CERT_SELECT_CRITERIA + CRYPT_TIMESTAMP_REQUEST* {.pure.} = object + dwVersion*: DWORD + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + HashedMessage*: CRYPT_DER_BLOB + pszTSAPolicyId*: LPSTR + Nonce*: CRYPT_INTEGER_BLOB + fCertReq*: WINBOOL + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCRYPT_TIMESTAMP_REQUEST* = ptr CRYPT_TIMESTAMP_REQUEST + CRYPT_TIMESTAMP_RESPONSE* {.pure.} = object + dwStatus*: DWORD + cFreeText*: DWORD + rgFreeText*: ptr LPWSTR + FailureInfo*: CRYPT_BIT_BLOB + ContentInfo*: CRYPT_DER_BLOB + PCRYPT_TIMESTAMP_RESPONSE* = ptr CRYPT_TIMESTAMP_RESPONSE + CRYPT_TIMESTAMP_ACCURACY* {.pure.} = object + dwSeconds*: DWORD + dwMillis*: DWORD + dwMicros*: DWORD + PCRYPT_TIMESTAMP_ACCURACY* = ptr CRYPT_TIMESTAMP_ACCURACY + CRYPT_TIMESTAMP_INFO* {.pure.} = object + dwVersion*: DWORD + pszTSAPolicyId*: LPSTR + HashAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + HashedMessage*: CRYPT_DER_BLOB + SerialNumber*: CRYPT_INTEGER_BLOB + ftTime*: FILETIME + pvAccuracy*: PCRYPT_TIMESTAMP_ACCURACY + fOrdering*: WINBOOL + Nonce*: CRYPT_DER_BLOB + Tsa*: CRYPT_DER_BLOB + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCRYPT_TIMESTAMP_INFO* = ptr CRYPT_TIMESTAMP_INFO + CRYPT_TIMESTAMP_CONTEXT* {.pure.} = object + cbEncoded*: DWORD + pbEncoded*: ptr BYTE + pTimeStamp*: PCRYPT_TIMESTAMP_INFO + PCRYPT_TIMESTAMP_CONTEXT* = ptr CRYPT_TIMESTAMP_CONTEXT + CRYPT_TIMESTAMP_PARA* {.pure.} = object + pszTSAPolicyId*: LPCSTR + fRequestCerts*: WINBOOL + Nonce*: CRYPT_INTEGER_BLOB + cExtension*: DWORD + rgExtension*: PCERT_EXTENSION + PCRYPT_TIMESTAMP_PARA* = ptr CRYPT_TIMESTAMP_PARA + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET* = proc (pPluginContext: LPVOID, pIdentifier: PCRYPT_DATA_BLOB, dwNameType: DWORD, pNameBlob: PCERT_NAME_BLOB, ppbContent: ptr PBYTE, pcbContent: ptr DWORD, ppwszPassword: ptr PCWSTR, ppIdentifier: ptr PCRYPT_DATA_BLOB): WINBOOL {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE* = proc (dwReason: DWORD, pPluginContext: LPVOID): void {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD* = proc (pPluginContext: LPVOID, pwszPassword: PCWSTR): void {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE* = proc (pPluginContext: LPVOID, pbData: PBYTE): void {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER* = proc (pPluginContext: LPVOID, pIdentifier: PCRYPT_DATA_BLOB): void {.stdcall.} + CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE* {.pure.} = object + cbSize*: DWORD + pfnGet*: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET + pfnRelease*: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE + pfnFreePassword*: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD + pfnFree*: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE + pfnFreeIdentifier*: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER + PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE* = ptr CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE + CRYPTPROTECT_PROMPTSTRUCT* {.pure.} = object + cbSize*: DWORD + dwPromptFlags*: DWORD + hwndApp*: HWND + szPrompt*: LPCWSTR + PCRYPTPROTECT_PROMPTSTRUCT* = ptr CRYPTPROTECT_PROMPTSTRUCT +const + ALG_CLASS_ANY* = 0 + ALG_CLASS_SIGNATURE* = 1 shl 13 + ALG_CLASS_MSG_ENCRYPT* = 2 shl 13 + ALG_CLASS_DATA_ENCRYPT* = 3 shl 13 + ALG_CLASS_HASH* = 4 shl 13 + ALG_CLASS_KEY_EXCHANGE* = 5 shl 13 + ALG_CLASS_ALL* = 7 shl 13 + ALG_TYPE_ANY* = 0 + ALG_TYPE_DSS* = 1 shl 9 + ALG_TYPE_RSA* = 2 shl 9 + ALG_TYPE_BLOCK* = 3 shl 9 + ALG_TYPE_STREAM* = 4 shl 9 + ALG_TYPE_DH* = 5 shl 9 + ALG_TYPE_SECURECHANNEL* = 6 shl 9 + ALG_SID_ANY* = 0 + ALG_SID_RSA_ANY* = 0 + ALG_SID_RSA_PKCS* = 1 + ALG_SID_RSA_MSATWORK* = 2 + ALG_SID_RSA_ENTRUST* = 3 + ALG_SID_RSA_PGP* = 4 + ALG_SID_DSS_ANY* = 0 + ALG_SID_DSS_PKCS* = 1 + ALG_SID_DSS_DMS* = 2 + ALG_SID_ECDSA* = 3 + ALG_SID_DES* = 1 + ALG_SID_3DES* = 3 + ALG_SID_DESX* = 4 + ALG_SID_IDEA* = 5 + ALG_SID_CAST* = 6 + ALG_SID_SAFERSK64* = 7 + ALG_SID_SAFERSK128* = 8 + ALG_SID_3DES_112* = 9 + ALG_SID_SKIPJACK* = 10 + ALG_SID_TEK* = 11 + ALG_SID_CYLINK_MEK* = 12 + ALG_SID_RC5* = 13 + ALG_SID_AES_128* = 14 + ALG_SID_AES_192* = 15 + ALG_SID_AES_256* = 16 + ALG_SID_AES* = 17 + CRYPT_MODE_CBCI* = 6 + CRYPT_MODE_CFBP* = 7 + CRYPT_MODE_OFBP* = 8 + CRYPT_MODE_CBCOFM* = 9 + CRYPT_MODE_CBCOFMI* = 10 + ALG_SID_RC2* = 2 + ALG_SID_RC4* = 1 + ALG_SID_SEAL* = 2 + ALG_SID_DH_SANDF* = 1 + ALG_SID_DH_EPHEM* = 2 + ALG_SID_AGREED_KEY_ANY* = 3 + ALG_SID_KEA* = 4 + ALG_SID_ECDH* = 5 + ALG_SID_MD2* = 1 + ALG_SID_MD4* = 2 + ALG_SID_MD5* = 3 + ALG_SID_SHA* = 4 + ALG_SID_SHA1* = 4 + ALG_SID_MAC* = 5 + ALG_SID_RIPEMD* = 6 + ALG_SID_RIPEMD160* = 7 + ALG_SID_SSL3SHAMD5* = 8 + ALG_SID_HMAC* = 9 + ALG_SID_TLS1PRF* = 10 + ALG_SID_HASH_REPLACE_OWF* = 11 + ALG_SID_SHA_256* = 12 + ALG_SID_SHA_384* = 13 + ALG_SID_SHA_512* = 14 + ALG_SID_SSL3_MASTER* = 1 + ALG_SID_SCHANNEL_MASTER_HASH* = 2 + ALG_SID_SCHANNEL_MAC_KEY* = 3 + ALG_SID_PCT1_MASTER* = 4 + ALG_SID_SSL2_MASTER* = 5 + ALG_SID_TLS1_MASTER* = 6 + ALG_SID_SCHANNEL_ENC_KEY* = 7 + ALG_SID_ECMQV* = 1 + ALG_SID_EXAMPLE* = 80 + CALG_MD2* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD2 + CALG_MD4* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD4 + CALG_MD5* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD5 + CALG_SHA* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA + CALG_SHA1* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA1 + CALG_MAC* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MAC + CALG_RSA_SIGN* = ALG_CLASS_SIGNATURE or ALG_TYPE_RSA or ALG_SID_RSA_ANY + CALG_DSS_SIGN* = ALG_CLASS_SIGNATURE or ALG_TYPE_DSS or ALG_SID_DSS_ANY + CALG_NO_SIGN* = ALG_CLASS_SIGNATURE or ALG_TYPE_ANY or ALG_SID_ANY + CALG_RSA_KEYX* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_RSA or ALG_SID_RSA_ANY + CALG_DES* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_DES + CALG_3DES_112* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_3DES_112 + CALG_3DES* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_3DES + CALG_DESX* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_DESX + CALG_RC2* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_RC2 + CALG_RC4* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_STREAM or ALG_SID_RC4 + CALG_SEAL* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_STREAM or ALG_SID_SEAL + CALG_DH_SF* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_DH or ALG_SID_DH_SANDF + CALG_DH_EPHEM* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_DH or ALG_SID_DH_EPHEM + CALG_AGREEDKEY_ANY* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_DH or ALG_SID_AGREED_KEY_ANY + CALG_KEA_KEYX* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_DH or ALG_SID_KEA + CALG_HUGHES_MD5* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_ANY or ALG_SID_MD5 + CALG_SKIPJACK* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_SKIPJACK + CALG_TEK* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_TEK + CALG_CYLINK_MEK* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_CYLINK_MEK + CALG_SSL3_SHAMD5* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SSL3SHAMD5 + CALG_SSL3_MASTER* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_SSL3_MASTER + CALG_SCHANNEL_MASTER_HASH* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_SCHANNEL_MASTER_HASH + CALG_SCHANNEL_MAC_KEY* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_SCHANNEL_MAC_KEY + CALG_SCHANNEL_ENC_KEY* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_SCHANNEL_ENC_KEY + CALG_PCT1_MASTER* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_PCT1_MASTER + CALG_SSL2_MASTER* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_SSL2_MASTER + CALG_TLS1_MASTER* = ALG_CLASS_MSG_ENCRYPT or ALG_TYPE_SECURECHANNEL or ALG_SID_TLS1_MASTER + CALG_RC5* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_RC5 + CALG_HMAC* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_HMAC + CALG_TLS1PRF* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_TLS1PRF + CALG_HASH_REPLACE_OWF* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_HASH_REPLACE_OWF + CALG_AES_128* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_AES_128 + CALG_AES_192* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_AES_192 + CALG_AES_256* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_AES_256 + CALG_AES* = ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_AES + CALG_SHA_256* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA_256 + CALG_SHA_384* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA_384 + CALG_SHA_512* = ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA_512 + CALG_ECDH* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_DH or ALG_SID_ECDH + CALG_ECMQV* = ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_ANY or ALG_SID_ECMQV + CALG_ECDSA* = ALG_CLASS_SIGNATURE or ALG_TYPE_DSS or ALG_SID_ECDSA + CRYPT_VERIFYCONTEXT* = 0xf0000000'i32 + CRYPT_NEWKEYSET* = 0x8 + CRYPT_DELETEKEYSET* = 0x10 + CRYPT_MACHINE_KEYSET* = 0x20 + CRYPT_SILENT* = 0x40 + CRYPT_DEFAULT_CONTAINER_OPTIONAL* = 0x80 + CRYPT_EXPORTABLE* = 0x1 + CRYPT_USER_PROTECTED* = 0x2 + CRYPT_CREATE_SALT* = 0x4 + CRYPT_UPDATE_KEY* = 0x8 + CRYPT_NO_SALT* = 0x10 + CRYPT_PREGEN* = 0x40 + CRYPT_RECIPIENT* = 0x10 + CRYPT_INITIATOR* = 0x40 + CRYPT_ONLINE* = 0x80 + CRYPT_SF* = 0x100 + CRYPT_CREATE_IV* = 0x200 + CRYPT_KEK* = 0x400 + CRYPT_DATA_KEY* = 0x800 + CRYPT_VOLATILE* = 0x1000 + CRYPT_SGCKEY* = 0x2000 + CRYPT_ARCHIVABLE* = 0x4000 + CRYPT_FORCE_KEY_PROTECTION_HIGH* = 0x8000 + CRYPT_USER_PROTECTED_STRONG* = 0x100000 + RSA1024BIT_KEY* = 0x4000000 + CRYPT_SERVER* = 0x400 + KEY_LENGTH_MASK* = 0xffff0000'i32 + CRYPT_Y_ONLY* = 0x1 + CRYPT_SSL2_FALLBACK* = 0x2 + crypt_destroykey* = 0x4 + CRYPT_DECRYPT_RSA_NO_PADDING_CHECK* = 0x20 + CRYPT_OAEP* = 0x40 + CRYPT_BLOB_VER3* = 0x80 + CRYPT_IPSEC_HMAC_KEY* = 0x100 + CRYPT_SECRETDIGEST* = 0x1 + CRYPT_OWF_REPL_LM_HASH* = 0x1 + CRYPT_LITTLE_ENDIAN* = 0x1 + CRYPT_NOHASHOID* = 0x1 + CRYPT_TYPE2_FORMAT* = 0x2 + CRYPT_X931_FORMAT* = 0x4 + CRYPT_MACHINE_DEFAULT* = 0x1 + CRYPT_USER_DEFAULT* = 0x2 + CRYPT_DELETE_DEFAULT* = 0x4 + SIMPLEBLOB* = 0x1 + PUBLICKEYBLOB* = 0x6 + PRIVATEKEYBLOB* = 0x7 + PLAINTEXTKEYBLOB* = 0x8 + OPAQUEKEYBLOB* = 0x9 + PUBLICKEYBLOBEX* = 0xa + SYMMETRICWRAPKEYBLOB* = 0xb + KEYSTATEBLOB* = 0xc + AT_KEYEXCHANGE* = 1 + AT_SIGNATURE* = 2 + CRYPT_USERDATA* = 1 + KP_IV* = 1 + KP_SALT* = 2 + KP_PADDING* = 3 + KP_MODE* = 4 + KP_MODE_BITS* = 5 + KP_PERMISSIONS* = 6 + KP_ALGID* = 7 + KP_BLOCKLEN* = 8 + KP_KEYLEN* = 9 + KP_SALT_EX* = 10 + KP_P* = 11 + KP_G* = 12 + KP_Q* = 13 + KP_X* = 14 + KP_Y* = 15 + KP_RA* = 16 + KP_RB* = 17 + KP_INFO* = 18 + KP_EFFECTIVE_KEYLEN* = 19 + KP_SCHANNEL_ALG* = 20 + KP_CLIENT_RANDOM* = 21 + KP_SERVER_RANDOM* = 22 + KP_RP* = 23 + KP_PRECOMP_MD5* = 24 + KP_PRECOMP_SHA* = 25 + KP_CERTIFICATE* = 26 + KP_CLEAR_KEY* = 27 + KP_PUB_EX_LEN* = 28 + KP_PUB_EX_VAL* = 29 + KP_KEYVAL* = 30 + KP_ADMIN_PIN* = 31 + KP_KEYEXCHANGE_PIN* = 32 + KP_SIGNATURE_PIN* = 33 + KP_PREHASH* = 34 + KP_ROUNDS* = 35 + KP_OAEP_PARAMS* = 36 + KP_CMS_KEY_INFO* = 37 + KP_CMS_DH_KEY_INFO* = 38 + KP_PUB_PARAMS* = 39 + KP_VERIFY_PARAMS* = 40 + KP_HIGHEST_VERSION* = 41 + KP_GET_USE_COUNT* = 42 + KP_PIN_ID* = 43 + KP_PIN_INFO* = 44 + PKCS5_PADDING* = 1 + RANDOM_PADDING* = 2 + ZERO_PADDING* = 3 + CRYPT_MODE_CBC* = 1 + CRYPT_MODE_ECB* = 2 + CRYPT_MODE_OFB* = 3 + CRYPT_MODE_CFB* = 4 + CRYPT_MODE_CTS* = 5 + crypt_encrypt* = 0x1 + crypt_decrypt* = 0x2 + CRYPT_EXPORT* = 0x4 + CRYPT_READ* = 0x8 + CRYPT_WRITE* = 0x10 + CRYPT_MAC* = 0x20 + crypt_export_key* = 0x40 + crypt_import_key* = 0x80 + CRYPT_ARCHIVE* = 0x100 + HP_ALGID* = 0x1 + HP_HASHVAL* = 0x2 + HP_HASHSIZE* = 0x4 + HP_HMAC_INFO* = 0x5 + HP_TLS1PRF_LABEL* = 0x6 + HP_TLS1PRF_SEED* = 0x7 + CRYPT_FAILED* = FALSE + CRYPT_SUCCEED* = TRUE + PP_ENUMALGS* = 1 + PP_ENUMCONTAINERS* = 2 + PP_IMPTYPE* = 3 + PP_NAME* = 4 + PP_VERSION* = 5 + PP_CONTAINER* = 6 + PP_CHANGE_PASSWORD* = 7 + PP_KEYSET_SEC_DESCR* = 8 + PP_CERTCHAIN* = 9 + PP_KEY_TYPE_SUBTYPE* = 10 + PP_PROVTYPE* = 16 + PP_KEYSTORAGE* = 17 + PP_APPLI_CERT* = 18 + PP_SYM_KEYSIZE* = 19 + PP_SESSION_KEYSIZE* = 20 + PP_UI_PROMPT* = 21 + PP_ENUMALGS_EX* = 22 + PP_ENUMMANDROOTS* = 25 + PP_ENUMELECTROOTS* = 26 + PP_KEYSET_TYPE* = 27 + PP_ADMIN_PIN* = 31 + PP_KEYEXCHANGE_PIN* = 32 + PP_SIGNATURE_PIN* = 33 + PP_SIG_KEYSIZE_INC* = 34 + PP_KEYX_KEYSIZE_INC* = 35 + PP_UNIQUE_CONTAINER* = 36 + PP_SGC_INFO* = 37 + PP_USE_HARDWARE_RNG* = 38 + PP_KEYSPEC* = 39 + PP_ENUMEX_SIGNING_PROT* = 40 + PP_CRYPT_COUNT_KEY_USE* = 41 + PP_USER_CERTSTORE* = 42 + PP_SMARTCARD_READER* = 43 + PP_SMARTCARD_GUID* = 45 + PP_ROOT_CERTSTORE* = 46 + PP_SMARTCARD_READER_ICON* = 47 + CRYPT_FIRST* = 1 + CRYPT_NEXT* = 2 + CRYPT_SGC_ENUM* = 4 + CRYPT_IMPL_HARDWARE* = 1 + CRYPT_IMPL_SOFTWARE* = 2 + CRYPT_IMPL_MIXED* = 3 + CRYPT_IMPL_UNKNOWN* = 4 + CRYPT_IMPL_REMOVABLE* = 8 + CRYPT_SEC_DESCR* = 0x1 + CRYPT_PSTORE* = 0x2 + CRYPT_UI_PROMPT* = 0x4 + CRYPT_FLAG_PCT1* = 0x1 + CRYPT_FLAG_SSL2* = 0x2 + CRYPT_FLAG_SSL3* = 0x4 + CRYPT_FLAG_TLS1* = 0x8 + CRYPT_FLAG_IPSEC* = 0x10 + CRYPT_FLAG_SIGNING* = 0x20 + CRYPT_SGC* = 0x1 + CRYPT_FASTSGC* = 0x2 + PP_CLIENT_HWND* = 1 + PP_CONTEXT_INFO* = 11 + PP_KEYEXCHANGE_KEYSIZE* = 12 + PP_SIGNATURE_KEYSIZE* = 13 + PP_KEYEXCHANGE_ALG* = 14 + PP_SIGNATURE_ALG* = 15 + PP_DELETEKEY* = 24 + PP_PIN_PROMPT_STRING* = 44 + PP_SECURE_KEYEXCHANGE_PIN* = 47 + PP_SECURE_SIGNATURE_PIN* = 48 + PROV_RSA_FULL* = 1 + PROV_RSA_SIG* = 2 + PROV_DSS* = 3 + PROV_FORTEZZA* = 4 + PROV_MS_EXCHANGE* = 5 + PROV_SSL* = 6 + PROV_STT_MER* = 7 + PROV_STT_ACQ* = 8 + PROV_STT_BRND* = 9 + PROV_STT_ROOT* = 10 + PROV_STT_ISS* = 11 + PROV_RSA_SCHANNEL* = 12 + PROV_DSS_DH* = 13 + PROV_EC_ECDSA_SIG* = 14 + PROV_EC_ECNRA_SIG* = 15 + PROV_EC_ECDSA_FULL* = 16 + PROV_EC_ECNRA_FULL* = 17 + PROV_DH_SCHANNEL* = 18 + PROV_SPYRUS_LYNKS* = 20 + PROV_RNG* = 21 + PROV_INTEL_SEC* = 22 + PROV_REPLACE_OWF* = 23 + PROV_RSA_AES* = 24 + MS_DEF_PROV_A* = "Microsoft Base Cryptographic Provider v1.0" + MS_DEF_PROV_W* = "Microsoft Base Cryptographic Provider v1.0" + MS_ENHANCED_PROV_A* = "Microsoft Enhanced Cryptographic Provider v1.0" + MS_ENHANCED_PROV_W* = "Microsoft Enhanced Cryptographic Provider v1.0" + MS_STRONG_PROV_A* = "Microsoft Strong Cryptographic Provider" + MS_STRONG_PROV_W* = "Microsoft Strong Cryptographic Provider" + MS_DEF_RSA_SIG_PROV_A* = "Microsoft RSA Signature Cryptographic Provider" + MS_DEF_RSA_SIG_PROV_W* = "Microsoft RSA Signature Cryptographic Provider" + MS_DEF_RSA_SCHANNEL_PROV_A* = "Microsoft RSA SChannel Cryptographic Provider" + MS_DEF_RSA_SCHANNEL_PROV_W* = "Microsoft RSA SChannel Cryptographic Provider" + MS_DEF_DSS_PROV_A* = "Microsoft Base DSS Cryptographic Provider" + MS_DEF_DSS_PROV_W* = "Microsoft Base DSS Cryptographic Provider" + MS_DEF_DSS_DH_PROV_A* = "Microsoft Base DSS and Diffie-Hellman Cryptographic Provider" + MS_DEF_DSS_DH_PROV_W* = "Microsoft Base DSS and Diffie-Hellman Cryptographic Provider" + MS_ENH_DSS_DH_PROV_A* = "Microsoft Enhanced DSS and Diffie-Hellman Cryptographic Provider" + MS_ENH_DSS_DH_PROV_W* = "Microsoft Enhanced DSS and Diffie-Hellman Cryptographic Provider" + MS_DEF_DH_SCHANNEL_PROV_A* = "Microsoft DH SChannel Cryptographic Provider" + MS_DEF_DH_SCHANNEL_PROV_W* = "Microsoft DH SChannel Cryptographic Provider" + MS_SCARD_PROV_A* = "Microsoft Base Smart Card Crypto Provider" + MS_SCARD_PROV_W* = "Microsoft Base Smart Card Crypto Provider" + MS_ENH_RSA_AES_PROV_A* = "Microsoft Enhanced RSA and AES Cryptographic Provider" + MS_ENH_RSA_AES_PROV_W* = "Microsoft Enhanced RSA and AES Cryptographic Provider" + MAXUIDLEN* = 64 + EXPO_OFFLOAD_REG_VALUE* = "ExpoOffload" + EXPO_OFFLOAD_FUNC_NAME* = "OffloadModExpo" + szKEY_CRYPTOAPI_PRIVATE_KEY_OPTIONS* = "Software\\Policies\\Microsoft\\Cryptography" + szKEY_CACHE_ENABLED* = "CachePrivateKeys" + szKEY_CACHE_SECONDS* = "PrivateKeyLifetimeSeconds" + szPRIV_KEY_CACHE_MAX_ITEMS* = "PrivKeyCacheMaxItems" + cPRIV_KEY_CACHE_MAX_ITEMS_DEFAULT* = 20 + szPRIV_KEY_CACHE_PURGE_INTERVAL_SECONDS* = "PrivKeyCachePurgeIntervalSeconds" + cPRIV_KEY_CACHE_PURGE_INTERVAL_SECONDS_DEFAULT* = 86400 + CUR_BLOB_VERSION* = 2 + SCHANNEL_MAC_KEY* = 0x0 + SCHANNEL_ENC_KEY* = 0x1 + INTERNATIONAL_USAGE* = 0x1 + BCRYPT_OBJECT_ALIGNMENT* = 16 + BCRYPT_KDF_HASH* = "HASH" + BCRYPT_KDF_HMAC* = "HMAC" + BCRYPT_KDF_TLS_PRF* = "TLS_PRF" + BCRYPT_KDF_SP80056A_CONCAT* = "SP800_56A_CONCAT" + KDF_HASH_ALGORITHM* = 0x0 + KDF_SECRET_PREPEND* = 0x1 + KDF_SECRET_APPEND* = 0x2 + KDF_HMAC_KEY* = 0x3 + KDF_TLS_PRF_LABEL* = 0x4 + KDF_TLS_PRF_SEED* = 0x5 + KDF_SECRET_HANDLE* = 0x6 + KDF_TLS_PRF_PROTOCOL* = 0x7 + KDF_ALGORITHMID* = 0x8 + KDF_PARTYUINFO* = 0x9 + KDF_PARTYVINFO* = 0xa + KDF_SUPPPUBINFO* = 0xb + KDF_SUPPPRIVINFO* = 0xc + KDF_LABEL* = 0xd + KDF_CONTEXT* = 0xe + KDF_SALT* = 0xf + KDF_ITERATION_COUNT* = 0x10 + KDF_GENERIC_PARAMETER* = 0x11 + KDF_KEYBITLENGTH* = 0x12 + KDF_USE_SECRET_AS_HMAC_KEY_FLAG* = 1 + BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION* = 1 + BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG* = 0x00000001 + BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG* = 0x00000002 + BCRYPT_OPAQUE_KEY_BLOB* = "OpaqueKeyBlob" + BCRYPT_KEY_DATA_BLOB* = "KeyDataBlob" + BCRYPT_AES_WRAP_KEY_BLOB* = "Rfc3565KeyWrapBlob" + BCRYPT_ALGORITHM_NAME* = "AlgorithmName" + BCRYPT_AUTH_TAG_LENGTH* = "AuthTagLength" + BCRYPT_BLOCK_LENGTH* = "BlockLength" + BCRYPT_BLOCK_SIZE_LIST* = "BlockSizeList" + BCRYPT_CHAINING_MODE* = "ChainingMode" + BCRYPT_CHAIN_MODE_CBC* = "ChainingModeCBC" + BCRYPT_CHAIN_MODE_CCM* = "ChainingModeCCM" + BCRYPT_CHAIN_MODE_CFB* = "ChainingModeCFB" + BCRYPT_CHAIN_MODE_ECB* = "ChainingModeECB" + BCRYPT_CHAIN_MODE_GCM* = "ChainingModeGCM" + BCRYPT_CHAIN_MODE_NA* = "ChainingModeN/A" + BCRYPT_EFFECTIVE_KEY_LENGTH* = "EffectiveKeyLength" + BCRYPT_HASH_BLOCK_LENGTH* = "HashBlockLength" + BCRYPT_HASH_LENGTH* = "HashDigestLength" + BCRYPT_HASH_OID_LIST* = "HashOIDList" + BCRYPT_INITIALIZATION_VECTOR* = "IV" + BCRYPT_IS_KEYED_HASH* = "IsKeyedHash" + BCRYPT_IS_REUSABLE_HASH* = "IsReusableHash" + BCRYPT_KEY_LENGTH* = "KeyLength" + BCRYPT_KEY_LENGTHS* = "KeyLengths" + BCRYPT_KEY_OBJECT_LENGTH* = "KeyObjectLength" + BCRYPT_KEY_STRENGTH* = "KeyStrength" + BCRYPT_MESSAGE_BLOCK_LENGTH* = "MessageBlockLength" + BCRYPT_OBJECT_LENGTH* = "ObjectLength" + BCRYPT_PADDING_SCHEMES* = "PaddingSchemes" + BCRYPT_PCP_PLATFORM_TYPE_PROPERTY* = "PCP_PLATFORM_TYPE" + BCRYPT_PCP_PROVIDER_VERSION_PROPERTY* = "PCP_PROVIDER_VERSION" + BCRYPT_PRIMITIVE_TYPE* = "PrimitiveType" + BCRYPT_PROVIDER_HANDLE* = "ProviderHandle" + BCRYPT_SIGNATURE_LENGTH* = "SignatureLength" + BCRYPT_SUPPORTED_PAD_ROUTER* = 0x00000001 + BCRYPT_SUPPORTED_PAD_PKCS1_ENC* = 0x00000002 + BCRYPT_SUPPORTED_PAD_PKCS1_SIG* = 0x00000004 + BCRYPT_SUPPORTED_PAD_OAEP* = 0x00000008 + BCRYPT_SUPPORTED_PAD_PSS* = 0x00000010 + BCRYPT_PROV_DISPATCH* = 0x00000001 + BCRYPT_BLOCK_PADDING* = 0x00000001 + BCRYPT_PAD_NONE* = 0x00000001 + BCRYPT_PAD_PKCS1* = 0x00000002 + BCRYPT_PAD_OAEP* = 0x00000004 + BCRYPT_PAD_PSS* = 0x00000008 + BCRYPTBUFFER_VERSION* = 0 + BCRYPT_PUBLIC_KEY_BLOB* = "PUBLICBLOB" + BCRYPT_PRIVATE_KEY_BLOB* = "PRIVATEBLOB" + BCRYPT_RSAPUBLIC_BLOB* = "RSAPUBLICBLOB" + BCRYPT_RSAPRIVATE_BLOB* = "RSAPRIVATEBLOB" + LEGACY_RSAPUBLIC_BLOB* = "CAPIPUBLICBLOB" + LEGACY_RSAPRIVATE_BLOB* = "CAPIPRIVATEBLOB" + BCRYPT_RSAPUBLIC_MAGIC* = 0x31415352 + BCRYPT_RSAPRIVATE_MAGIC* = 0x32415352 + BCRYPT_RSAFULLPRIVATE_BLOB* = "RSAFULLPRIVATEBLOB" + BCRYPT_RSAFULLPRIVATE_MAGIC* = 0x33415352 + BCRYPT_GLOBAL_PARAMETERS* = "SecretAgreementParam" + BCRYPT_PRIVATE_KEY* = "PrivKeyVal" + BCRYPT_ECCPUBLIC_BLOB* = "ECCPUBLICBLOB" + BCRYPT_ECCPRIVATE_BLOB* = "ECCPRIVATEBLOB" + BCRYPT_ECDH_PUBLIC_P256_MAGIC* = 0x314b4345 + BCRYPT_ECDH_PRIVATE_P256_MAGIC* = 0x324b4345 + BCRYPT_ECDH_PUBLIC_P384_MAGIC* = 0x334b4345 + BCRYPT_ECDH_PRIVATE_P384_MAGIC* = 0x344b4345 + BCRYPT_ECDH_PUBLIC_P521_MAGIC* = 0x354b4345 + BCRYPT_ECDH_PRIVATE_P521_MAGIC* = 0x364b4345 + BCRYPT_ECDSA_PUBLIC_P256_MAGIC* = 0x31534345 + BCRYPT_ECDSA_PRIVATE_P256_MAGIC* = 0x32534345 + BCRYPT_ECDSA_PUBLIC_P384_MAGIC* = 0x33534345 + BCRYPT_ECDSA_PRIVATE_P384_MAGIC* = 0x34534345 + BCRYPT_ECDSA_PUBLIC_P521_MAGIC* = 0x35534345 + BCRYPT_ECDSA_PRIVATE_P521_MAGIC* = 0x36534345 + BCRYPT_DH_PUBLIC_BLOB* = "DHPUBLICBLOB" + BCRYPT_DH_PRIVATE_BLOB* = "DHPRIVATEBLOB" + LEGACY_DH_PUBLIC_BLOB* = "CAPIDHPUBLICBLOB" + LEGACY_DH_PRIVATE_BLOB* = "CAPIDHPRIVATEBLOB" + BCRYPT_DH_PUBLIC_MAGIC* = 0x42504844 + BCRYPT_DH_PRIVATE_MAGIC* = 0x56504844 + BCRYPT_DH_PARAMETERS* = "DHParameters" + BCRYPT_DH_PARAMETERS_MAGIC* = 0x4d504844 + BCRYPT_DSA_PUBLIC_BLOB* = "DSAPUBLICBLOB" + BCRYPT_DSA_PRIVATE_BLOB* = "DSAPRIVATEBLOB" + LEGACY_DSA_PUBLIC_BLOB* = "CAPIDSAPUBLICBLOB" + LEGACY_DSA_PRIVATE_BLOB* = "CAPIDSAPRIVATEBLOB" + LEGACY_DSA_V2_PUBLIC_BLOB* = "V2CAPIDSAPUBLICBLOB" + LEGACY_DSA_V2_PRIVATE_BLOB* = "V2CAPIDSAPRIVATEBLOB" + BCRYPT_DSA_PUBLIC_MAGIC* = 0x42505344 + BCRYPT_DSA_PRIVATE_MAGIC* = 0x56505344 + BCRYPT_DSA_PUBLIC_MAGIC_V2* = 0x32425044 + BCRYPT_DSA_PRIVATE_MAGIC_V2* = 0x32565044 + BCRYPT_KEY_DATA_BLOB_MAGIC* = 0x4d42444b + BCRYPT_KEY_DATA_BLOB_VERSION1* = 0x1 + BCRYPT_DSA_PARAMETERS* = "DSAParameters" + BCRYPT_DSA_PARAMETERS_MAGIC* = 0x4d505344 + BCRYPT_DSA_PARAMETERS_MAGIC_V2* = 0x324d5044 + MS_PRIMITIVE_PROVIDER* = "Microsoft Primitive Provider" + MS_PLATFORM_CRYPTO_PROVIDER* = "Microsoft Platform Crypto Provider" + BCRYPT_RSA_ALGORITHM* = "RSA" + BCRYPT_RSA_SIGN_ALGORITHM* = "RSA_SIGN" + BCRYPT_DH_ALGORITHM* = "DH" + BCRYPT_DSA_ALGORITHM* = "DSA" + BCRYPT_RC2_ALGORITHM* = "RC2" + BCRYPT_RC4_ALGORITHM* = "RC4" + BCRYPT_AES_ALGORITHM* = "AES" + BCRYPT_DES_ALGORITHM* = "DES" + BCRYPT_DESX_ALGORITHM* = "DESX" + BCRYPT_3DES_ALGORITHM* = "3DES" + BCRYPT_3DES_112_ALGORITHM* = "3DES_112" + BCRYPT_MD2_ALGORITHM* = "MD2" + BCRYPT_MD4_ALGORITHM* = "MD4" + BCRYPT_MD5_ALGORITHM* = "MD5" + BCRYPT_SHA1_ALGORITHM* = "SHA1" + BCRYPT_SHA256_ALGORITHM* = "SHA256" + BCRYPT_SHA384_ALGORITHM* = "SHA384" + BCRYPT_SHA512_ALGORITHM* = "SHA512" + BCRYPT_AES_GMAC_ALGORITHM* = "AES-GMAC" + BCRYPT_AES_CMAC_ALGORITHM* = "AES-CMAC" + BCRYPT_ECDSA_P256_ALGORITHM* = "ECDSA_P256" + BCRYPT_ECDSA_P384_ALGORITHM* = "ECDSA_P384" + BCRYPT_ECDSA_P521_ALGORITHM* = "ECDSA_P521" + BCRYPT_ECDH_P256_ALGORITHM* = "ECDH_P256" + BCRYPT_ECDH_P384_ALGORITHM* = "ECDH_P384" + BCRYPT_ECDH_P521_ALGORITHM* = "ECDH_P521" + BCRYPT_RNG_ALGORITHM* = "RNG" + BCRYPT_RNG_FIPS186_DSA_ALGORITHM* = "FIPS186DSARNG" + BCRYPT_RNG_DUAL_EC_ALGORITHM* = "DUALECRNG" + BCRYPT_SP800108_CTR_HMAC_ALGORITHM* = "SP800_108_CTR_HMAC" + BCRYPT_SP80056A_CONCAT_ALGORITHM* = "SP800_56A_CONCAT" + BCRYPT_PBKDF2_ALGORITHM* = "PBKDF2" + BCRYPT_CAPI_KDF_ALGORITHM* = "CAPI_KDF" + BCRYPT_CIPHER_INTERFACE* = 0x00000001 + BCRYPT_HASH_INTERFACE* = 0x00000002 + BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE* = 0x00000003 + BCRYPT_SECRET_AGREEMENT_INTERFACE* = 0x00000004 + BCRYPT_SIGNATURE_INTERFACE* = 0x00000005 + BCRYPT_RNG_INTERFACE* = 0x00000006 + BCRYPT_KEY_DERIVATION_INTERFACE* = 0x00000007 + BCRYPT_ALG_HANDLE_HMAC_FLAG* = 0x00000008 + BCRYPT_CAPI_AES_FLAG* = 0x00000010 + BCRYPT_HASH_REUSABLE_FLAG* = 0x00000020 + BCRYPT_BUFFERS_LOCKED_FLAG* = 0x00000040 + BCRYPT_CIPHER_OPERATION* = 0x00000001 + BCRYPT_HASH_OPERATION* = 0x00000002 + BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION* = 0x00000004 + BCRYPT_SECRET_AGREEMENT_OPERATION* = 0x00000008 + BCRYPT_SIGNATURE_OPERATION* = 0x00000010 + BCRYPT_RNG_OPERATION* = 0x00000020 + BCRYPT_KEY_DERIVATION_OPERATION* = 0x00000040 + BCRYPT_PUBLIC_KEY_FLAG* = 0x00000001 + BCRYPT_PRIVATE_KEY_FLAG* = 0x00000002 + BCRYPT_NO_KEY_VALIDATION* = 0x00000008 + BCRYPT_RNG_USE_ENTROPY_IN_BUFFER* = 0x00000001 + BCRYPT_USE_SYSTEM_PREFERRED_RNG* = 0x00000002 + CRYPT_MIN_DEPENDENCIES* = 0x00000001 + CRYPT_PROCESS_ISOLATE* = 0x00010000 + CRYPT_UM* = 0x00000001 + CRYPT_KM* = 0x00000002 + CRYPT_MM* = 0x00000003 + CRYPT_ANY* = 0x00000004 + CRYPT_OVERWRITE* = 0x00000001 + CRYPT_LOCAL* = 0x00000001 + CRYPT_DOMAIN* = 0x00000002 + CRYPT_EXCLUSIVE* = 0x00000001 + CRYPT_OVERRIDE* = 0x00010000 + CRYPT_ALL_FUNCTIONS* = 0x00000001 + CRYPT_ALL_PROVIDERS* = 0x00000002 + CRYPT_PRIORITY_TOP* = 0x00000000 + CRYPT_PRIORITY_BOTTOM* = 0xffffffff'i32 + CRYPT_DEFAULT_CONTEXT* = "Default" + DSA_HASH_ALGORITHM_SHA1* = 0 + DSA_HASH_ALGORITHM_SHA256* = 1 + DSA_HASH_ALGORITHM_SHA512* = 2 + DSA_FIPS186_2* = 0 + DSA_FIPS186_3* = 1 + NCRYPT_MAX_KEY_NAME_LENGTH* = 512 + NCRYPT_MAX_ALG_ID_LENGTH* = 512 + MS_KEY_STORAGE_PROVIDER* = "Microsoft Software Key Storage Provider" + MS_SMART_CARD_KEY_STORAGE_PROVIDER* = "Microsoft Smart Card Key Storage Provider" + MS_PLATFORM_KEY_STORAGE_PROVIDER* = "Microsoft Platform Crypto Provider" + NCRYPT_RSA_ALGORITHM* = BCRYPT_RSA_ALGORITHM + NCRYPT_RSA_SIGN_ALGORITHM* = BCRYPT_RSA_SIGN_ALGORITHM + NCRYPT_DH_ALGORITHM* = BCRYPT_DH_ALGORITHM + NCRYPT_DSA_ALGORITHM* = BCRYPT_DSA_ALGORITHM + NCRYPT_MD2_ALGORITHM* = BCRYPT_MD2_ALGORITHM + NCRYPT_MD4_ALGORITHM* = BCRYPT_MD4_ALGORITHM + NCRYPT_MD5_ALGORITHM* = BCRYPT_MD5_ALGORITHM + NCRYPT_SHA1_ALGORITHM* = BCRYPT_SHA1_ALGORITHM + NCRYPT_SHA256_ALGORITHM* = BCRYPT_SHA256_ALGORITHM + NCRYPT_SHA384_ALGORITHM* = BCRYPT_SHA384_ALGORITHM + NCRYPT_SHA512_ALGORITHM* = BCRYPT_SHA512_ALGORITHM + NCRYPT_ECDSA_P256_ALGORITHM* = BCRYPT_ECDSA_P256_ALGORITHM + NCRYPT_ECDSA_P384_ALGORITHM* = BCRYPT_ECDSA_P384_ALGORITHM + NCRYPT_ECDSA_P521_ALGORITHM* = BCRYPT_ECDSA_P521_ALGORITHM + NCRYPT_ECDH_P256_ALGORITHM* = BCRYPT_ECDH_P256_ALGORITHM + NCRYPT_ECDH_P384_ALGORITHM* = BCRYPT_ECDH_P384_ALGORITHM + NCRYPT_ECDH_P521_ALGORITHM* = BCRYPT_ECDH_P521_ALGORITHM + NCRYPT_AES_ALGORITHM* = BCRYPT_AES_ALGORITHM + NCRYPT_RC2_ALGORITHM* = BCRYPT_RC2_ALGORITHM + NCRYPT_3DES_ALGORITHM* = BCRYPT_3DES_ALGORITHM + NCRYPT_DES_ALGORITHM* = BCRYPT_DES_ALGORITHM + NCRYPT_DESX_ALGORITHM* = BCRYPT_DESX_ALGORITHM + NCRYPT_3DES_112_ALGORITHM* = BCRYPT_3DES_112_ALGORITHM + NCRYPT_SP800108_CTR_HMAC_ALGORITHM* = BCRYPT_SP800108_CTR_HMAC_ALGORITHM + NCRYPT_SP80056A_CONCAT_ALGORITHM* = BCRYPT_SP80056A_CONCAT_ALGORITHM + NCRYPT_PBKDF2_ALGORITHM* = BCRYPT_PBKDF2_ALGORITHM + NCRYPT_CAPI_KDF_ALGORITHM* = BCRYPT_CAPI_KDF_ALGORITHM + NCRYPT_KEY_STORAGE_ALGORITHM* = "KEY_STORAGE" + NCRYPT_CIPHER_INTERFACE* = BCRYPT_CIPHER_INTERFACE + NCRYPT_HASH_INTERFACE* = BCRYPT_HASH_INTERFACE + NCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE* = BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE + NCRYPT_SECRET_AGREEMENT_INTERFACE* = BCRYPT_SECRET_AGREEMENT_INTERFACE + NCRYPT_SIGNATURE_INTERFACE* = BCRYPT_SIGNATURE_INTERFACE + NCRYPT_KEY_DERIVATION_INTERFACE* = BCRYPT_KEY_DERIVATION_INTERFACE + NCRYPT_KEY_STORAGE_INTERFACE* = 0x00010001 + NCRYPT_SCHANNEL_INTERFACE* = 0x00010002 + NCRYPT_SCHANNEL_SIGNATURE_INTERFACE* = 0x00010003 + NCRYPT_KEY_PROTECTION_INTERFACE* = 0x00010004 + NCRYPT_RSA_ALGORITHM_GROUP* = NCRYPT_RSA_ALGORITHM + NCRYPT_DH_ALGORITHM_GROUP* = NCRYPT_DH_ALGORITHM + NCRYPT_DSA_ALGORITHM_GROUP* = NCRYPT_DSA_ALGORITHM + NCRYPT_ECDSA_ALGORITHM_GROUP* = "ECDSA" + NCRYPT_ECDH_ALGORITHM_GROUP* = "ECDH" + NCRYPT_AES_ALGORITHM_GROUP* = NCRYPT_AES_ALGORITHM + NCRYPT_RC2_ALGORITHM_GROUP* = NCRYPT_RC2_ALGORITHM + NCRYPT_DES_ALGORITHM_GROUP* = "DES" + NCRYPT_KEY_DERIVATION_GROUP* = "KEY_DERIVATION" + NCRYPTBUFFER_VERSION* = 0 + NCRYPTBUFFER_EMPTY* = 0 + NCRYPTBUFFER_DATA* = 1 + NCRYPTBUFFER_PROTECTION_DESCRIPTOR_STRING* = 3 + NCRYPTBUFFER_PROTECTION_FLAGS* = 4 + NCRYPTBUFFER_SSL_CLIENT_RANDOM* = 20 + NCRYPTBUFFER_SSL_SERVER_RANDOM* = 21 + NCRYPTBUFFER_SSL_HIGHEST_VERSION* = 22 + NCRYPTBUFFER_SSL_CLEAR_KEY* = 23 + NCRYPTBUFFER_SSL_KEY_ARG_DATA* = 24 + NCRYPTBUFFER_PKCS_OID* = 40 + NCRYPTBUFFER_PKCS_ALG_OID* = 41 + NCRYPTBUFFER_PKCS_ALG_PARAM* = 42 + NCRYPTBUFFER_PKCS_ALG_ID* = 43 + NCRYPTBUFFER_PKCS_ATTRS* = 44 + NCRYPTBUFFER_PKCS_KEY_NAME* = 45 + NCRYPTBUFFER_PKCS_SECRET* = 46 + NCRYPTBUFFER_CERT_BLOB* = 47 + NCRYPT_NO_PADDING_FLAG* = 0x1 + NCRYPT_PAD_PKCS1_FLAG* = 0x2 + NCRYPT_PAD_OAEP_FLAG* = 0x4 + NCRYPT_PAD_PSS_FLAG* = 0x8 + NCRYPT_PAD_CIPHER_FLAG* = 0x10 + NCRYPT_CIPHER_NO_PADDING_FLAG* = 0x0 + NCRYPT_CIPHER_BLOCK_PADDING_FLAG* = 0x1 + NCRYPT_CIPHER_OTHER_PADDING_FLAG* = 0x2 + NCRYPT_NO_KEY_VALIDATION* = BCRYPT_NO_KEY_VALIDATION + NCRYPT_MACHINE_KEY_FLAG* = 0x20 + NCRYPT_SILENT_FLAG* = 0x40 + NCRYPT_OVERWRITE_KEY_FLAG* = 0x80 + NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG* = 0x200 + NCRYPT_DO_NOT_FINALIZE_FLAG* = 0x400 + NCRYPT_PERSIST_ONLY_FLAG* = 0x40000000 + NCRYPT_PERSIST_FLAG* = 0x80000000'i32 + NCRYPT_REGISTER_NOTIFY_FLAG* = 0x1 + NCRYPT_UNREGISTER_NOTIFY_FLAG* = 0x2 + NCRYPT_CIPHER_OPERATION* = BCRYPT_CIPHER_OPERATION + NCRYPT_HASH_OPERATION* = BCRYPT_HASH_OPERATION + NCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION* = BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION + NCRYPT_SECRET_AGREEMENT_OPERATION* = BCRYPT_SECRET_AGREEMENT_OPERATION + NCRYPT_SIGNATURE_OPERATION* = BCRYPT_SIGNATURE_OPERATION + NCRYPT_RNG_OPERATION* = BCRYPT_RNG_OPERATION + NCRYPT_KEY_DERIVATION_OPERATION* = BCRYPT_KEY_DERIVATION_OPERATION + NCRYPT_NAME_PROPERTY* = "Name" + NCRYPT_UNIQUE_NAME_PROPERTY* = "Unique Name" + NCRYPT_ALGORITHM_PROPERTY* = "Algorithm Name" + NCRYPT_LENGTH_PROPERTY* = "Length" + NCRYPT_LENGTHS_PROPERTY* = "Lengths" + NCRYPT_BLOCK_LENGTH_PROPERTY* = "Block Length" + NCRYPT_CHAINING_MODE_PROPERTY* = "Chaining Mode" + NCRYPT_AUTH_TAG_LENGTH* = "AuthTagLength" + NCRYPT_UI_POLICY_PROPERTY* = "UI Policy" + NCRYPT_EXPORT_POLICY_PROPERTY* = "Export Policy" + NCRYPT_WINDOW_HANDLE_PROPERTY* = "HWND Handle" + NCRYPT_USE_CONTEXT_PROPERTY* = "Use Context" + NCRYPT_IMPL_TYPE_PROPERTY* = "Impl Type" + NCRYPT_KEY_USAGE_PROPERTY* = "Key Usage" + NCRYPT_KEY_TYPE_PROPERTY* = "Key Type" + NCRYPT_VERSION_PROPERTY* = "Version" + NCRYPT_SECURITY_DESCR_SUPPORT_PROPERTY* = "Security Descr Support" + NCRYPT_SECURITY_DESCR_PROPERTY* = "Security Descr" + NCRYPT_USE_COUNT_ENABLED_PROPERTY* = "Enabled Use Count" + NCRYPT_USE_COUNT_PROPERTY* = "Use Count" + NCRYPT_LAST_MODIFIED_PROPERTY* = "Modified" + NCRYPT_MAX_NAME_LENGTH_PROPERTY* = "Max Name Length" + NCRYPT_ALGORITHM_GROUP_PROPERTY* = "Algorithm Group" + NCRYPT_DH_PARAMETERS_PROPERTY* = BCRYPT_DH_PARAMETERS + NCRYPT_PROVIDER_HANDLE_PROPERTY* = "Provider Handle" + NCRYPT_PIN_PROPERTY* = "SmartCardPin" + NCRYPT_READER_PROPERTY* = "SmartCardReader" + NCRYPT_SMARTCARD_GUID_PROPERTY* = "SmartCardGuid" + NCRYPT_CERTIFICATE_PROPERTY* = "SmartCardKeyCertificate" + NCRYPT_PIN_PROMPT_PROPERTY* = "SmartCardPinPrompt" + NCRYPT_USER_CERTSTORE_PROPERTY* = "SmartCardUserCertStore" + NCRYPT_ROOT_CERTSTORE_PROPERTY* = "SmartcardRootCertStore" + NCRYPT_SECURE_PIN_PROPERTY* = "SmartCardSecurePin" + NCRYPT_ASSOCIATED_ECDH_KEY* = "SmartCardAssociatedECDHKey" + NCRYPT_SCARD_PIN_ID* = "SmartCardPinId" + NCRYPT_SCARD_PIN_INFO* = "SmartCardPinInfo" + NCRYPT_READER_ICON_PROPERTY* = "SmartCardReaderIcon" + NCRYPT_KDF_SECRET_VALUE* = "KDFKeySecret" + NCRYPT_PCP_PLATFORM_TYPE_PROPERTY* = "PCP_PLATFORM_TYPE" + NCRYPT_PCP_PROVIDER_VERSION_PROPERTY* = "PCP_PROVIDER_VERSION" + NCRYPT_PCP_EKPUB_PROPERTY* = "PCP_EKPUB" + NCRYPT_PCP_EKCERT_PROPERTY* = "PCP_EKCERT" + NCRYPT_PCP_EKNVCERT_PROPERTY* = "PCP_EKNVCERT" + NCRYPT_PCP_SRKPUB_PROPERTY* = "PCP_SRKPUB" + NCRYPT_PCP_PCRTABLE_PROPERTY* = "PCP_PCRTABLE" + NCRYPT_PCP_CHANGEPASSWORD_PROPERTY* = "PCP_CHANGEPASSWORD" + NCRYPT_PCP_PASSWORD_REQUIRED_PROPERTY* = "PCP_PASSWORD_REQUIRED" + NCRYPT_PCP_USAGEAUTH_PROPERTY* = "PCP_USAGEAUTH" + NCRYPT_PCP_MIGRATIONPASSWORD_PROPERTY* = "PCP_MIGRATIONPASSWORD" + NCRYPT_PCP_EXPORT_ALLOWED_PROPERTY* = "PCP_EXPORT_ALLOWED" + NCRYPT_PCP_STORAGEPARENT_PROPERTY* = "PCP_STORAGEPARENT" + NCRYPT_PCP_PROVIDERHANDLE_PROPERTY* = "PCP_PROVIDERMHANDLE" + NCRYPT_PCP_PLATFORMHANDLE_PROPERTY* = "PCP_PLATFORMHANDLE" + NCRYPT_PCP_PLATFORM_BINDING_PCRMASK_PROPERTY* = "PCP_PLATFORM_BINDING_PCRMASK" + NCRYPT_PCP_PLATFORM_BINDING_PCRDIGESTLIST_PROPERTY* = "PCP_PLATFORM_BINDING_PCRDIGESTLIST" + NCRYPT_PCP_PLATFORM_BINDING_PCRDIGEST_PROPERTY* = "PCP_PLATFORM_BINDING_PCRDIGEST" + NCRYPT_PCP_KEY_USAGE_POLICY_PROPERTY* = "PCP_KEY_USAGE_POLICY" + NCRYPT_PCP_TPM12_IDBINDING_PROPERTY* = "PCP_TPM12_IDBINDING" + NCRYPT_PCP_TPM12_IDACTIVATION_PROPERTY* = "PCP_TPM12_IDACTIVATION" + NCRYPT_PCP_KEYATTESTATION_PROPERTY* = "PCP_TPM12_KEYATTESTATION" + NCRYPT_PCP_ALTERNATE_KEY_STORAGE_LOCATION_PROPERTY* = "PCP_ALTERNATE_KEY_STORAGE_LOCATION" + NCRYPT_TPM12_PROVIDER* = 0x00010000 + NCRYPT_PCP_SIGNATURE_KEY* = 0x1 + NCRYPT_PCP_ENCRYPTION_KEY* = 0x2 + NCRYPT_PCP_GENERIC_KEY* = NCRYPT_PCP_SIGNATURE_KEY or NCRYPT_PCP_ENCRYPTION_KEY + NCRYPT_PCP_STORAGE_KEY* = 0x00000004 + NCRYPT_PCP_IDENTITY_KEY* = 0x00000008 + NCRYPT_INITIALIZATION_VECTOR* = BCRYPT_INITIALIZATION_VECTOR + NCRYPT_MAX_PROPERTY_NAME* = 64 + NCRYPT_MAX_PROPERTY_DATA* = 0x100000 + NCRYPT_ALLOW_EXPORT_FLAG* = 0x1 + NCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAG* = 0x2 + NCRYPT_ALLOW_ARCHIVING_FLAG* = 0x00000004 + NCRYPT_ALLOW_PLAINTEXT_ARCHIVING_FLAG* = 0x00000008 + NCRYPT_IMPL_HARDWARE_FLAG* = 0x1 + NCRYPT_IMPL_SOFTWARE_FLAG* = 0x2 + NCRYPT_IMPL_REMOVABLE_FLAG* = 0x00000008 + NCRYPT_IMPL_HARDWARE_RNG_FLAG* = 0x00000010 + NCRYPT_ALLOW_DECRYPT_FLAG* = 0x1 + NCRYPT_ALLOW_SIGNING_FLAG* = 0x2 + NCRYPT_ALLOW_KEY_AGREEMENT_FLAG* = 0x00000004 + NCRYPT_ALLOW_ALL_USAGES* = 0x00ffffff + NCRYPT_UI_PROTECT_KEY_FLAG* = 0x1 + NCRYPT_UI_FORCE_HIGH_PROTECTION_FLAG* = 0x2 + NCRYPT_CIPHER_KEY_BLOB_MAGIC* = 0x52485043 + NCRYPT_PROTECTED_KEY_BLOB_MAGIC* = 0x4b545250 + NCRYPT_CIPHER_KEY_BLOB* = "CipherKeyBlob" + NCRYPT_PROTECTED_KEY_BLOB* = "ProtectedKeyBlob" + NCRYPT_PKCS7_ENVELOPE_BLOB* = "PKCS7_ENVELOPE" + NCRYPT_PKCS8_PRIVATE_KEY_BLOB* = "PKCS8_PRIVATEKEY" + NCRYPT_OPAQUETRANSPORT_BLOB* = "OpaqueTransport" + NCRYPT_EXPORT_LEGACY_FLAG* = 0x00000800 + szOID_RSA* = "1.2.840.113549" + szOID_PKCS* = "1.2.840.113549.1" + szOID_RSA_HASH* = "1.2.840.113549.2" + szOID_RSA_ENCRYPT* = "1.2.840.113549.3" + szOID_PKCS_1* = "1.2.840.113549.1.1" + szOID_PKCS_2* = "1.2.840.113549.1.2" + szOID_PKCS_3* = "1.2.840.113549.1.3" + szOID_PKCS_4* = "1.2.840.113549.1.4" + szOID_PKCS_5* = "1.2.840.113549.1.5" + szOID_PKCS_6* = "1.2.840.113549.1.6" + szOID_PKCS_7* = "1.2.840.113549.1.7" + szOID_PKCS_8* = "1.2.840.113549.1.8" + szOID_PKCS_9* = "1.2.840.113549.1.9" + szOID_PKCS_10* = "1.2.840.113549.1.10" + szOID_PKCS_12* = "1.2.840.113549.1.12" + szOID_RSA_RSA* = "1.2.840.113549.1.1.1" + szOID_RSA_MD2RSA* = "1.2.840.113549.1.1.2" + szOID_RSA_MD4RSA* = "1.2.840.113549.1.1.3" + szOID_RSA_MD5RSA* = "1.2.840.113549.1.1.4" + szOID_RSA_SHA1RSA* = "1.2.840.113549.1.1.5" + szOID_RSA_SETOAEP_RSA* = "1.2.840.113549.1.1.6" + szOID_RSAES_OAEP* = "1.2.840.113549.1.1.7" + szOID_RSA_MGF1* = "1.2.840.113549.1.1.8" + szOID_RSA_PSPECIFIED* = "1.2.840.113549.1.1.9" + szOID_RSA_SSA_PSS* = "1.2.840.113549.1.1.10" + szOID_RSA_SHA256RSA* = "1.2.840.113549.1.1.11" + szOID_RSA_SHA384RSA* = "1.2.840.113549.1.1.12" + szOID_RSA_SHA512RSA* = "1.2.840.113549.1.1.13" + szOID_RSA_DH* = "1.2.840.113549.1.3.1" + szOID_RSA_data* = "1.2.840.113549.1.7.1" + szOID_RSA_signedData* = "1.2.840.113549.1.7.2" + szOID_RSA_envelopedData* = "1.2.840.113549.1.7.3" + szOID_RSA_signEnvData* = "1.2.840.113549.1.7.4" + szOID_RSA_digestedData* = "1.2.840.113549.1.7.5" + szOID_RSA_hashedData* = "1.2.840.113549.1.7.5" + szOID_RSA_encryptedData* = "1.2.840.113549.1.7.6" + szOID_RSA_emailAddr* = "1.2.840.113549.1.9.1" + szOID_RSA_unstructName* = "1.2.840.113549.1.9.2" + szOID_RSA_contentType* = "1.2.840.113549.1.9.3" + szOID_RSA_messageDigest* = "1.2.840.113549.1.9.4" + szOID_RSA_signingTime* = "1.2.840.113549.1.9.5" + szOID_RSA_counterSign* = "1.2.840.113549.1.9.6" + szOID_RSA_challengePwd* = "1.2.840.113549.1.9.7" + szOID_RSA_unstructAddr* = "1.2.840.113549.1.9.8" + szOID_RSA_extCertAttrs* = "1.2.840.113549.1.9.9" + szOID_RSA_certExtensions* = "1.2.840.113549.1.9.14" + szOID_RSA_SMIMECapabilities* = "1.2.840.113549.1.9.15" + szOID_RSA_preferSignedData* = "1.2.840.113549.1.9.15.1" + szOID_TIMESTAMP_TOKEN* = "1.2.840.113549.1.9.16.1.4" + szOID_RFC3161_counterSign* = "1.3.6.1.4.1.311.3.3.1" + szOID_RSA_SMIMEalg* = "1.2.840.113549.1.9.16.3" + szOID_RSA_SMIMEalgESDH* = "1.2.840.113549.1.9.16.3.5" + szOID_RSA_SMIMEalgCMS3DESwrap* = "1.2.840.113549.1.9.16.3.6" + szOID_RSA_SMIMEalgCMSRC2wrap* = "1.2.840.113549.1.9.16.3.7" + szOID_RSA_MD2* = "1.2.840.113549.2.2" + szOID_RSA_MD4* = "1.2.840.113549.2.4" + szOID_RSA_MD5* = "1.2.840.113549.2.5" + szOID_RSA_RC2CBC* = "1.2.840.113549.3.2" + szOID_RSA_RC4* = "1.2.840.113549.3.4" + szOID_RSA_DES_EDE3_CBC* = "1.2.840.113549.3.7" + szOID_RSA_RC5_CBCPad* = "1.2.840.113549.3.9" + szOID_ANSI_X942* = "1.2.840.10046" + szOID_ANSI_X942_DH* = "1.2.840.10046.2.1" + szOID_X957* = "1.2.840.10040" + szOID_X957_DSA* = "1.2.840.10040.4.1" + szOID_X957_SHA1DSA* = "1.2.840.10040.4.3" + szOID_ECC_PUBLIC_KEY* = "1.2.840.10045.2.1" + szOID_ECC_CURVE_P256* = "1.2.840.10045.3.1.7" + szOID_ECC_CURVE_P384* = "1.3.132.0.34" + szOID_ECC_CURVE_P521* = "1.3.132.0.35" + szOID_ECDSA_SHA1* = "1.2.840.10045.4.1" + szOID_ECDSA_SPECIFIED* = "1.2.840.10045.4.3" + szOID_ECDSA_SHA256* = "1.2.840.10045.4.3.2" + szOID_ECDSA_SHA384* = "1.2.840.10045.4.3.3" + szOID_ECDSA_SHA512* = "1.2.840.10045.4.3.4" + szOID_NIST_AES128_CBC* = "2.16.840.1.101.3.4.1.2" + szOID_NIST_AES192_CBC* = "2.16.840.1.101.3.4.1.22" + szOID_NIST_AES256_CBC* = "2.16.840.1.101.3.4.1.42" + szOID_NIST_AES128_WRAP* = "2.16.840.1.101.3.4.1.5" + szOID_NIST_AES192_WRAP* = "2.16.840.1.101.3.4.1.25" + szOID_NIST_AES256_WRAP* = "2.16.840.1.101.3.4.1.45" + szOID_DH_SINGLE_PASS_STDDH_SHA1_KDF* = "1.3.133.16.840.63.0.2" + szOID_DH_SINGLE_PASS_STDDH_SHA256_KDF* = "1.3.132.1.11.1" + szOID_DH_SINGLE_PASS_STDDH_SHA384_KDF* = "1.3.132.1.11.2" + szOID_DS* = "2.5" + szOID_DSALG* = "2.5.8" + szOID_DSALG_CRPT* = "2.5.8.1" + szOID_DSALG_HASH* = "2.5.8.2" + szOID_DSALG_SIGN* = "2.5.8.3" + szOID_DSALG_RSA* = "2.5.8.1.1" + szOID_OIW* = "1.3.14" + szOID_OIWSEC* = "1.3.14.3.2" + szOID_OIWSEC_md4RSA* = "1.3.14.3.2.2" + szOID_OIWSEC_md5RSA* = "1.3.14.3.2.3" + szOID_OIWSEC_md4RSA2* = "1.3.14.3.2.4" + szOID_OIWSEC_desECB* = "1.3.14.3.2.6" + szOID_OIWSEC_desCBC* = "1.3.14.3.2.7" + szOID_OIWSEC_desOFB* = "1.3.14.3.2.8" + szOID_OIWSEC_desCFB* = "1.3.14.3.2.9" + szOID_OIWSEC_desMAC* = "1.3.14.3.2.10" + szOID_OIWSEC_rsaSign* = "1.3.14.3.2.11" + szOID_OIWSEC_dsa* = "1.3.14.3.2.12" + szOID_OIWSEC_shaDSA* = "1.3.14.3.2.13" + szOID_OIWSEC_mdc2RSA* = "1.3.14.3.2.14" + szOID_OIWSEC_shaRSA* = "1.3.14.3.2.15" + szOID_OIWSEC_dhCommMod* = "1.3.14.3.2.16" + szOID_OIWSEC_desEDE* = "1.3.14.3.2.17" + szOID_OIWSEC_sha* = "1.3.14.3.2.18" + szOID_OIWSEC_mdc2* = "1.3.14.3.2.19" + szOID_OIWSEC_dsaComm* = "1.3.14.3.2.20" + szOID_OIWSEC_dsaCommSHA* = "1.3.14.3.2.21" + szOID_OIWSEC_rsaXchg* = "1.3.14.3.2.22" + szOID_OIWSEC_keyHashSeal* = "1.3.14.3.2.23" + szOID_OIWSEC_md2RSASign* = "1.3.14.3.2.24" + szOID_OIWSEC_md5RSASign* = "1.3.14.3.2.25" + szOID_OIWSEC_sha1* = "1.3.14.3.2.26" + szOID_OIWSEC_dsaSHA1* = "1.3.14.3.2.27" + szOID_OIWSEC_dsaCommSHA1* = "1.3.14.3.2.28" + szOID_OIWSEC_sha1RSASign* = "1.3.14.3.2.29" + szOID_OIWDIR* = "1.3.14.7.2" + szOID_OIWDIR_CRPT* = "1.3.14.7.2.1" + szOID_OIWDIR_HASH* = "1.3.14.7.2.2" + szOID_OIWDIR_SIGN* = "1.3.14.7.2.3" + szOID_OIWDIR_md2* = "1.3.14.7.2.2.1" + szOID_OIWDIR_md2RSA* = "1.3.14.7.2.3.1" + szOID_INFOSEC* = "2.16.840.1.101.2.1" + szOID_INFOSEC_sdnsSignature* = "2.16.840.1.101.2.1.1.1" + szOID_INFOSEC_mosaicSignature* = "2.16.840.1.101.2.1.1.2" + szOID_INFOSEC_sdnsConfidentiality* = "2.16.840.1.101.2.1.1.3" + szOID_INFOSEC_mosaicConfidentiality* = "2.16.840.1.101.2.1.1.4" + szOID_INFOSEC_sdnsIntegrity* = "2.16.840.1.101.2.1.1.5" + szOID_INFOSEC_mosaicIntegrity* = "2.16.840.1.101.2.1.1.6" + szOID_INFOSEC_sdnsTokenProtection* = "2.16.840.1.101.2.1.1.7" + szOID_INFOSEC_mosaicTokenProtection* = "2.16.840.1.101.2.1.1.8" + szOID_INFOSEC_sdnsKeyManagement* = "2.16.840.1.101.2.1.1.9" + szOID_INFOSEC_mosaicKeyManagement* = "2.16.840.1.101.2.1.1.10" + szOID_INFOSEC_sdnsKMandSig* = "2.16.840.1.101.2.1.1.11" + szOID_INFOSEC_mosaicKMandSig* = "2.16.840.1.101.2.1.1.12" + szOID_INFOSEC_SuiteASignature* = "2.16.840.1.101.2.1.1.13" + szOID_INFOSEC_SuiteAConfidentiality* = "2.16.840.1.101.2.1.1.14" + szOID_INFOSEC_SuiteAIntegrity* = "2.16.840.1.101.2.1.1.15" + szOID_INFOSEC_SuiteATokenProtection* = "2.16.840.1.101.2.1.1.16" + szOID_INFOSEC_SuiteAKeyManagement* = "2.16.840.1.101.2.1.1.17" + szOID_INFOSEC_SuiteAKMandSig* = "2.16.840.1.101.2.1.1.18" + szOID_INFOSEC_mosaicUpdatedSig* = "2.16.840.1.101.2.1.1.19" + szOID_INFOSEC_mosaicKMandUpdSig* = "2.16.840.1.101.2.1.1.20" + szOID_INFOSEC_mosaicUpdatedInteg* = "2.16.840.1.101.2.1.1.21" + szOID_NIST_sha256* = "2.16.840.1.101.3.4.2.1" + szOID_NIST_sha384* = "2.16.840.1.101.3.4.2.2" + szOID_NIST_sha512* = "2.16.840.1.101.3.4.2.3" + szOID_COMMON_NAME* = "2.5.4.3" + szOID_SUR_NAME* = "2.5.4.4" + szOID_DEVICE_SERIAL_NUMBER* = "2.5.4.5" + szOID_COUNTRY_NAME* = "2.5.4.6" + szOID_LOCALITY_NAME* = "2.5.4.7" + szOID_STATE_OR_PROVINCE_NAME* = "2.5.4.8" + szOID_STREET_ADDRESS* = "2.5.4.9" + szOID_ORGANIZATION_NAME* = "2.5.4.10" + szOID_ORGANIZATIONAL_UNIT_NAME* = "2.5.4.11" + szOID_TITLE* = "2.5.4.12" + szOID_DESCRIPTION* = "2.5.4.13" + szOID_SEARCH_GUIDE* = "2.5.4.14" + szOID_BUSINESS_CATEGORY* = "2.5.4.15" + szOID_POSTAL_ADDRESS* = "2.5.4.16" + szOID_POSTAL_CODE* = "2.5.4.17" + szOID_POST_OFFICE_BOX* = "2.5.4.18" + szOID_PHYSICAL_DELIVERY_OFFICE_NAME* = "2.5.4.19" + szOID_TELEPHONE_NUMBER* = "2.5.4.20" + szOID_TELEX_NUMBER* = "2.5.4.21" + szOID_TELETEXT_TERMINAL_IDENTIFIER* = "2.5.4.22" + szOID_FACSIMILE_TELEPHONE_NUMBER* = "2.5.4.23" + szOID_X21_ADDRESS* = "2.5.4.24" + szOID_INTERNATIONAL_ISDN_NUMBER* = "2.5.4.25" + szOID_REGISTERED_ADDRESS* = "2.5.4.26" + szOID_DESTINATION_INDICATOR* = "2.5.4.27" + szOID_PREFERRED_DELIVERY_METHOD* = "2.5.4.28" + szOID_PRESENTATION_ADDRESS* = "2.5.4.29" + szOID_SUPPORTED_APPLICATION_CONTEXT* = "2.5.4.30" + szOID_MEMBER* = "2.5.4.31" + szOID_OWNER* = "2.5.4.32" + szOID_ROLE_OCCUPANT* = "2.5.4.33" + szOID_SEE_ALSO* = "2.5.4.34" + szOID_USER_PASSWORD* = "2.5.4.35" + szOID_USER_CERTIFICATE* = "2.5.4.36" + szOID_CA_CERTIFICATE* = "2.5.4.37" + szOID_AUTHORITY_REVOCATION_LIST* = "2.5.4.38" + szOID_CERTIFICATE_REVOCATION_LIST* = "2.5.4.39" + szOID_CROSS_CERTIFICATE_PAIR* = "2.5.4.40" + szOID_GIVEN_NAME* = "2.5.4.42" + szOID_INITIALS* = "2.5.4.43" + szOID_DN_QUALIFIER* = "2.5.4.46" + szOID_DOMAIN_COMPONENT* = "0.9.2342.19200300.100.1.25" + szOID_PKCS_12_FRIENDLY_NAME_ATTR* = "1.2.840.113549.1.9.20" + szOID_PKCS_12_LOCAL_KEY_ID* = "1.2.840.113549.1.9.21" + szOID_PKCS_12_KEY_PROVIDER_NAME_ATTR* = "1.3.6.1.4.1.311.17.1" + szOID_LOCAL_MACHINE_KEYSET* = "1.3.6.1.4.1.311.17.2" + szOID_PKCS_12_EXTENDED_ATTRIBUTES* = "1.3.6.1.4.1.311.17.3" + szOID_PKCS_12_PROTECTED_PASSWORD_SECRET_BAG_TYPE_ID* = "1.3.6.1.4.1.311.17.4" + szOID_KEYID_RDN* = "1.3.6.1.4.1.311.10.7.1" + szOID_EV_RDN_LOCALE* = "1.3.6.1.4.1.311.60.2.1.1" + szOID_EV_RDN_STATE_OR_PROVINCE* = "1.3.6.1.4.1.311.60.2.1.2" + szOID_EV_RDN_COUNTRY* = "1.3.6.1.4.1.311.60.2.1.3" + CERT_RDN_ANY_TYPE* = 0 + CERT_RDN_ENCODED_BLOB* = 1 + CERT_RDN_OCTET_STRING* = 2 + CERT_RDN_NUMERIC_STRING* = 3 + CERT_RDN_PRINTABLE_STRING* = 4 + CERT_RDN_TELETEX_STRING* = 5 + CERT_RDN_T61_STRING* = 5 + CERT_RDN_VIDEOTEX_STRING* = 6 + CERT_RDN_IA5_STRING* = 7 + CERT_RDN_GRAPHIC_STRING* = 8 + CERT_RDN_VISIBLE_STRING* = 9 + CERT_RDN_ISO646_STRING* = 9 + CERT_RDN_GENERAL_STRING* = 10 + CERT_RDN_UNIVERSAL_STRING* = 11 + CERT_RDN_INT4_STRING* = 11 + CERT_RDN_BMP_STRING* = 12 + CERT_RDN_UNICODE_STRING* = 12 + CERT_RDN_UTF8_STRING* = 13 + CERT_RDN_TYPE_MASK* = 0x000000ff + CERT_RDN_FLAGS_MASK* = 0xff000000'i32 + CERT_RDN_ENABLE_T61_UNICODE_FLAG* = 0x80000000'i32 + CERT_RDN_ENABLE_UTF8_UNICODE_FLAG* = 0x20000000 + CERT_RDN_FORCE_UTF8_UNICODE_FLAG* = 0x10000000 + CERT_RDN_DISABLE_CHECK_TYPE_FLAG* = 0x40000000 + CERT_RDN_DISABLE_IE4_UTF8_FLAG* = 0x1000000 + CERT_RDN_ENABLE_PUNYCODE_FLAG* = 0x2000000 + CERT_RSA_PUBLIC_KEY_OBJID* = szOID_RSA_RSA + CERT_DEFAULT_OID_PUBLIC_KEY_SIGN* = szOID_RSA_RSA + CERT_DEFAULT_OID_PUBLIC_KEY_XCHG* = szOID_RSA_RSA + CRYPT_ECC_PRIVATE_KEY_INFO_v1* = 1 + CERT_V1* = 0 + CERT_V2* = 1 + CERT_V3* = 2 + CERT_INFO_VERSION_FLAG* = 1 + CERT_INFO_SERIAL_NUMBER_FLAG* = 2 + CERT_INFO_SIGNATURE_ALGORITHM_FLAG* = 3 + CERT_INFO_ISSUER_FLAG* = 4 + CERT_INFO_NOT_BEFORE_FLAG* = 5 + CERT_INFO_NOT_AFTER_FLAG* = 6 + CERT_INFO_SUBJECT_FLAG* = 7 + CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG* = 8 + CERT_INFO_ISSUER_UNIQUE_ID_FLAG* = 9 + CERT_INFO_SUBJECT_UNIQUE_ID_FLAG* = 10 + CERT_INFO_EXTENSION_FLAG* = 11 + CRL_V1* = 0 + CRL_V2* = 1 + CERT_BUNDLE_CERTIFICATE* = 0 + CERT_BUNDLE_CRL* = 1 + CERT_REQUEST_V1* = 0 + CERT_KEYGEN_REQUEST_V1* = 0 + CTL_V1* = 0 + CERT_ENCODING_TYPE_MASK* = 0x0000ffff + CMSG_ENCODING_TYPE_MASK* = 0xffff0000'i32 + CRYPT_ASN_ENCODING* = 0x1 + CRYPT_NDR_ENCODING* = 0x2 + X509_ASN_ENCODING* = 0x1 + X509_NDR_ENCODING* = 0x2 + PKCS_7_ASN_ENCODING* = 0x10000 + PKCS_7_NDR_ENCODING* = 0x20000 + CRYPT_FORMAT_STR_MULTI_LINE* = 0x1 + CRYPT_FORMAT_STR_NO_HEX* = 0x10 + CRYPT_FORMAT_SIMPLE* = 0x1 + CRYPT_FORMAT_X509* = 0x2 + CRYPT_FORMAT_OID* = 0x4 + CRYPT_FORMAT_RDN_SEMICOLON* = 0x100 + CRYPT_FORMAT_RDN_CRLF* = 0x200 + CRYPT_FORMAT_RDN_UNQUOTE* = 0x400 + CRYPT_FORMAT_RDN_REVERSE* = 0x800 + CRYPT_FORMAT_COMMA* = 0x1000 + CRYPT_FORMAT_SEMICOLON* = CRYPT_FORMAT_RDN_SEMICOLON + CRYPT_FORMAT_CRLF* = CRYPT_FORMAT_RDN_CRLF + CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG* = 0x8 + CRYPT_ENCODE_ALLOC_FLAG* = 0x8000 + CRYPT_UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG* = CERT_RDN_ENABLE_T61_UNICODE_FLAG + CRYPT_UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG* = CERT_RDN_ENABLE_UTF8_UNICODE_FLAG + CRYPT_UNICODE_NAME_ENCODE_FORCE_UTF8_UNICODE_FLAG* = CERT_RDN_FORCE_UTF8_UNICODE_FLAG + CRYPT_UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG* = CERT_RDN_DISABLE_CHECK_TYPE_FLAG + CRYPT_SORTED_CTL_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG* = 0x10000 + CRYPT_ENCODE_ENABLE_PUNYCODE_FLAG* = 0x20000 + CRYPT_ENCODE_ENABLE_UTF8PERCENT_FLAG* = 0x40000 + CRYPT_ENCODE_ENABLE_IA5CONVERSION_FLAG* = CRYPT_ENCODE_ENABLE_PUNYCODE_FLAG or CRYPT_ENCODE_ENABLE_UTF8PERCENT_FLAG + CRYPT_DECODE_NOCOPY_FLAG* = 0x1 + CRYPT_DECODE_TO_BE_SIGNED_FLAG* = 0x2 + CRYPT_DECODE_SHARE_OID_STRING_FLAG* = 0x4 + CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG* = 0x8 + CRYPT_DECODE_ALLOC_FLAG* = 0x8000 + CRYPT_UNICODE_NAME_DECODE_DISABLE_IE4_UTF8_FLAG* = CERT_RDN_DISABLE_IE4_UTF8_FLAG + CRYPT_DECODE_ENABLE_PUNYCODE_FLAG* = 0x2000000 + CRYPT_DECODE_ENABLE_UTF8PERCENT_FLAG* = 0x4000000 + CRYPT_DECODE_ENABLE_IA5CONVERSION_FLAG* = CRYPT_DECODE_ENABLE_PUNYCODE_FLAG or CRYPT_DECODE_ENABLE_UTF8PERCENT_FLAG + CRYPT_ENCODE_DECODE_NONE* = 0 + X509_CERT* = cast[LPCSTR](1) + X509_CERT_TO_BE_SIGNED* = cast[LPCSTR](2) + X509_CERT_CRL_TO_BE_SIGNED* = cast[LPCSTR](3) + X509_CERT_REQUEST_TO_BE_SIGNED* = cast[LPCSTR](4) + X509_EXTENSIONS* = cast[LPCSTR](5) + X509_NAME_VALUE* = cast[LPCSTR](6) + X509_NAME* = cast[LPCSTR](7) + X509_PUBLIC_KEY_INFO* = cast[LPCSTR](8) + X509_AUTHORITY_KEY_ID* = cast[LPCSTR](9) + X509_KEY_ATTRIBUTES* = cast[LPCSTR](10) + X509_KEY_USAGE_RESTRICTION* = cast[LPCSTR](11) + X509_ALTERNATE_NAME* = cast[LPCSTR](12) + X509_BASIC_CONSTRAINTS* = cast[LPCSTR](13) + X509_KEY_USAGE* = cast[LPCSTR](14) + X509_BASIC_CONSTRAINTS2* = cast[LPCSTR](15) + X509_CERT_POLICIES* = cast[LPCSTR](16) + PKCS_UTC_TIME* = cast[LPCSTR](17) + PKCS_TIME_REQUEST* = cast[LPCSTR](18) + RSA_CSP_PUBLICKEYBLOB* = cast[LPCSTR](19) + X509_UNICODE_NAME* = cast[LPCSTR](20) + X509_KEYGEN_REQUEST_TO_BE_SIGNED* = cast[LPCSTR](21) + PKCS_ATTRIBUTE* = cast[LPCSTR](22) + PKCS_CONTENT_INFO_SEQUENCE_OF_ANY* = cast[LPCSTR](23) + X509_UNICODE_NAME_VALUE* = cast[LPCSTR](24) + X509_ANY_STRING* = X509_NAME_VALUE + X509_UNICODE_ANY_STRING* = X509_UNICODE_NAME_VALUE + X509_OCTET_STRING* = cast[LPCSTR](25) + X509_BITS* = cast[LPCSTR](26) + X509_INTEGER* = cast[LPCSTR](27) + X509_MULTI_BYTE_INTEGER* = cast[LPCSTR](28) + X509_ENUMERATED* = cast[LPCSTR](29) + X509_CHOICE_OF_TIME* = cast[LPCSTR](30) + X509_AUTHORITY_KEY_ID2* = cast[LPCSTR](31) + X509_AUTHORITY_INFO_ACCESS* = cast[LPCSTR](32) + X509_SUBJECT_INFO_ACCESS* = X509_AUTHORITY_INFO_ACCESS + X509_CRL_REASON_CODE* = X509_ENUMERATED + PKCS_CONTENT_INFO* = cast[LPCSTR](33) + X509_SEQUENCE_OF_ANY* = cast[LPCSTR](34) + X509_CRL_DIST_POINTS* = cast[LPCSTR](35) + X509_ENHANCED_KEY_USAGE* = cast[LPCSTR](36) + PKCS_CTL* = cast[LPCSTR](37) + X509_MULTI_BYTE_UINT* = cast[LPCSTR](38) + X509_DSS_PUBLICKEY* = X509_MULTI_BYTE_UINT + X509_DSS_PARAMETERS* = cast[LPCSTR](39) + X509_DSS_SIGNATURE* = cast[LPCSTR](40) + PKCS_RC2_CBC_PARAMETERS* = cast[LPCSTR](41) + PKCS_SMIME_CAPABILITIES* = cast[LPCSTR](42) + X509_QC_STATEMENTS_EXT* = cast[LPCSTR](42) + PKCS_RSA_PRIVATE_KEY* = cast[LPCSTR](43) + PKCS_PRIVATE_KEY_INFO* = cast[LPCSTR](44) + PKCS_ENCRYPTED_PRIVATE_KEY_INFO* = cast[LPCSTR](45) + X509_PKIX_POLICY_QUALIFIER_USERNOTICE* = cast[LPCSTR](46) + X509_DH_PUBLICKEY* = X509_MULTI_BYTE_UINT + X509_DH_PARAMETERS* = cast[LPCSTR](47) + X509_ECC_SIGNATURE* = cast[LPCSTR](47) + PKCS_ATTRIBUTES* = cast[LPCSTR](48) + PKCS_SORTED_CTL* = cast[LPCSTR](49) + X942_DH_PARAMETERS* = cast[LPCSTR](50) + X509_BITS_WITHOUT_TRAILING_ZEROES* = cast[LPCSTR](51) + X942_OTHER_INFO* = cast[LPCSTR](52) + X509_CERT_PAIR* = cast[LPCSTR](53) + X509_ISSUING_DIST_POINT* = cast[LPCSTR](54) + X509_NAME_CONSTRAINTS* = cast[LPCSTR](55) + X509_POLICY_MAPPINGS* = cast[LPCSTR](56) + X509_POLICY_CONSTRAINTS* = cast[LPCSTR](57) + X509_CROSS_CERT_DIST_POINTS* = cast[LPCSTR](58) + CMC_DATA* = cast[LPCSTR](59) + CMC_RESPONSE* = cast[LPCSTR](60) + CMC_STATUS* = cast[LPCSTR](61) + CMC_ADD_EXTENSIONS* = cast[LPCSTR](62) + CMC_ADD_ATTRIBUTES* = cast[LPCSTR](63) + X509_CERTIFICATE_TEMPLATE* = cast[LPCSTR](64) + OCSP_SIGNED_REQUEST* = cast[LPCSTR](65) + OCSP_REQUEST* = cast[LPCSTR](66) + OCSP_RESPONSE* = cast[LPCSTR](67) + OCSP_BASIC_SIGNED_RESPONSE* = cast[LPCSTR](68) + OCSP_BASIC_RESPONSE* = cast[LPCSTR](69) + X509_LOGOTYPE_EXT* = cast[LPCSTR](70) + X509_BIOMETRIC_EXT* = cast[LPCSTR](71) + CNG_RSA_PUBLIC_KEY_BLOB* = cast[LPCSTR](72) + X509_OBJECT_IDENTIFIER* = cast[LPCSTR](73) + X509_ALGORITHM_IDENTIFIER* = cast[LPCSTR](74) + PKCS_RSA_SSA_PSS_PARAMETERS* = cast[LPCSTR](75) + PKCS_RSAES_OAEP_PARAMETERS* = cast[LPCSTR](76) + ECC_CMS_SHARED_INFO* = cast[LPCSTR](77) + TIMESTAMP_REQUEST* = cast[LPCSTR](78) + TIMESTAMP_RESPONSE* = cast[LPCSTR](79) + TIMESTAMP_INFO* = cast[LPCSTR](80) + X509_CERT_BUNDLE* = cast[LPCSTR](81) + X509_ECC_PRIVATE_KEY* = cast[LPCSTR](82) + CNG_RSA_PRIVATE_KEY_BLOB* = cast[LPCSTR](83) + PKCS7_SIGNER_INFO* = cast[LPCSTR](500) + CMS_SIGNER_INFO* = cast[LPCSTR](501) + szOID_AUTHORITY_KEY_IDENTIFIER* = "2.5.29.1" + szOID_KEY_ATTRIBUTES* = "2.5.29.2" + szOID_CERT_POLICIES_95* = "2.5.29.3" + szOID_KEY_USAGE_RESTRICTION* = "2.5.29.4" + szOID_SUBJECT_ALT_NAME* = "2.5.29.7" + szOID_ISSUER_ALT_NAME* = "2.5.29.8" + szOID_BASIC_CONSTRAINTS* = "2.5.29.10" + szOID_KEY_USAGE* = "2.5.29.15" + szOID_PRIVATEKEY_USAGE_PERIOD* = "2.5.29.16" + szOID_BASIC_CONSTRAINTS2* = "2.5.29.19" + szOID_CERT_POLICIES* = "2.5.29.32" + szOID_ANY_CERT_POLICY* = "2.5.29.32.0" + szOID_INHIBIT_ANY_POLICY* = "2.5.29.54" + szOID_AUTHORITY_KEY_IDENTIFIER2* = "2.5.29.35" + szOID_SUBJECT_KEY_IDENTIFIER* = "2.5.29.14" + szOID_SUBJECT_ALT_NAME2* = "2.5.29.17" + szOID_ISSUER_ALT_NAME2* = "2.5.29.18" + szOID_CRL_REASON_CODE* = "2.5.29.21" + szOID_REASON_CODE_HOLD* = "2.5.29.23" + szOID_CRL_DIST_POINTS* = "2.5.29.31" + szOID_ENHANCED_KEY_USAGE* = "2.5.29.37" + szOID_ANY_ENHANCED_KEY_USAGE* = "2.5.29.37.0" + szOID_CRL_NUMBER* = "2.5.29.20" + szOID_DELTA_CRL_INDICATOR* = "2.5.29.27" + szOID_ISSUING_DIST_POINT* = "2.5.29.28" + szOID_FRESHEST_CRL* = "2.5.29.46" + szOID_NAME_CONSTRAINTS* = "2.5.29.30" + szOID_POLICY_MAPPINGS* = "2.5.29.33" + szOID_LEGACY_POLICY_MAPPINGS* = "2.5.29.5" + szOID_POLICY_CONSTRAINTS* = "2.5.29.36" + szOID_RENEWAL_CERTIFICATE* = "1.3.6.1.4.1.311.13.1" + szOID_ENROLLMENT_NAME_VALUE_PAIR* = "1.3.6.1.4.1.311.13.2.1" + szOID_ENROLLMENT_CSP_PROVIDER* = "1.3.6.1.4.1.311.13.2.2" + szOID_OS_VERSION* = "1.3.6.1.4.1.311.13.2.3" + szOID_ENROLLMENT_AGENT* = "1.3.6.1.4.1.311.20.2.1" + szOID_PKIX* = "1.3.6.1.5.5.7" + szOID_PKIX_PE* = "1.3.6.1.5.5.7.1" + szOID_AUTHORITY_INFO_ACCESS* = "1.3.6.1.5.5.7.1.1" + szOID_SUBJECT_INFO_ACCESS* = "1.3.6.1.5.5.7.1.11" + szOID_BIOMETRIC_EXT* = "1.3.6.1.5.5.7.1.2" + szOID_QC_STATEMENTS_EXT* = "1.3.6.1.5.5.7.1.3" + szOID_LOGOTYPE_EXT* = "1.3.6.1.5.5.7.1.12" + szOID_CERT_EXTENSIONS* = "1.3.6.1.4.1.311.2.1.14" + szOID_NEXT_UPDATE_LOCATION* = "1.3.6.1.4.1.311.10.2" + szOID_REMOVE_CERTIFICATE* = "1.3.6.1.4.1.311.10.8.1" + szOID_CROSS_CERT_DIST_POINTS* = "1.3.6.1.4.1.311.10.9.1" + szOID_CTL* = "1.3.6.1.4.1.311.10.1" + szOID_SORTED_CTL* = "1.3.6.1.4.1.311.10.1.1" + szOID_SERIALIZED* = "1.3.6.1.4.1.311.10.3.3.1" + szOID_NT_PRINCIPAL_NAME* = "1.3.6.1.4.1.311.20.2.3" + szOID_INTERNATIONALIZED_EMAIL_ADDRESS* = "1.3.6.1.4.1.311.20.2.4" + szOID_PRODUCT_UPDATE* = "1.3.6.1.4.1.311.31.1" + szOID_ANY_APPLICATION_POLICY* = "1.3.6.1.4.1.311.10.12.1" + szOID_AUTO_ENROLL_CTL_USAGE* = "1.3.6.1.4.1.311.20.1" + szOID_ENROLL_CERTTYPE_EXTENSION* = "1.3.6.1.4.1.311.20.2" + szOID_CERT_MANIFOLD* = "1.3.6.1.4.1.311.20.3" + szOID_CERTSRV_CA_VERSION* = "1.3.6.1.4.1.311.21.1" + szOID_CERTSRV_PREVIOUS_CERT_HASH* = "1.3.6.1.4.1.311.21.2" + szOID_CRL_VIRTUAL_BASE* = "1.3.6.1.4.1.311.21.3" + szOID_CRL_NEXT_PUBLISH* = "1.3.6.1.4.1.311.21.4" + szOID_KP_CA_EXCHANGE* = "1.3.6.1.4.1.311.21.5" + szOID_KP_KEY_RECOVERY_AGENT* = "1.3.6.1.4.1.311.21.6" + szOID_CERTIFICATE_TEMPLATE* = "1.3.6.1.4.1.311.21.7" + szOID_ENTERPRISE_OID_ROOT* = "1.3.6.1.4.1.311.21.8" + szOID_RDN_DUMMY_SIGNER* = "1.3.6.1.4.1.311.21.9" + szOID_APPLICATION_CERT_POLICIES* = "1.3.6.1.4.1.311.21.10" + szOID_APPLICATION_POLICY_MAPPINGS* = "1.3.6.1.4.1.311.21.11" + szOID_APPLICATION_POLICY_CONSTRAINTS* = "1.3.6.1.4.1.311.21.12" + szOID_ARCHIVED_KEY_ATTR* = "1.3.6.1.4.1.311.21.13" + szOID_CRL_SELF_CDP* = "1.3.6.1.4.1.311.21.14" + szOID_REQUIRE_CERT_CHAIN_POLICY* = "1.3.6.1.4.1.311.21.15" + szOID_ARCHIVED_KEY_CERT_HASH* = "1.3.6.1.4.1.311.21.16" + szOID_ISSUED_CERT_HASH* = "1.3.6.1.4.1.311.21.17" + szOID_DS_EMAIL_REPLICATION* = "1.3.6.1.4.1.311.21.19" + szOID_REQUEST_CLIENT_INFO* = "1.3.6.1.4.1.311.21.20" + szOID_ENCRYPTED_KEY_HASH* = "1.3.6.1.4.1.311.21.21" + szOID_CERTSRV_CROSSCA_VERSION* = "1.3.6.1.4.1.311.21.22" + szOID_NTDS_REPLICATION* = "1.3.6.1.4.1.311.25.1" + szOID_SUBJECT_DIR_ATTRS* = "2.5.29.9" + szOID_PKIX_KP* = "1.3.6.1.5.5.7.3" + szOID_PKIX_KP_SERVER_AUTH* = "1.3.6.1.5.5.7.3.1" + szOID_PKIX_KP_CLIENT_AUTH* = "1.3.6.1.5.5.7.3.2" + szOID_PKIX_KP_CODE_SIGNING* = "1.3.6.1.5.5.7.3.3" + szOID_PKIX_KP_EMAIL_PROTECTION* = "1.3.6.1.5.5.7.3.4" + szOID_PKIX_KP_IPSEC_END_SYSTEM* = "1.3.6.1.5.5.7.3.5" + szOID_PKIX_KP_IPSEC_TUNNEL* = "1.3.6.1.5.5.7.3.6" + szOID_PKIX_KP_IPSEC_USER* = "1.3.6.1.5.5.7.3.7" + szOID_PKIX_KP_TIMESTAMP_SIGNING* = "1.3.6.1.5.5.7.3.8" + szOID_PKIX_KP_OCSP_SIGNING* = "1.3.6.1.5.5.7.3.9" + szOID_PKIX_OCSP_NONCE* = "1.3.6.1.5.5.7.48.1.2" + szOID_PKIX_OCSP_NOCHECK* = "1.3.6.1.5.5.7.48.1.5" + szOID_IPSEC_KP_IKE_INTERMEDIATE* = "1.3.6.1.5.5.8.2.2" + szOID_PKINIT_KP_KDC* = "1.3.6.1.5.2.3.5" + szOID_KP_CTL_USAGE_SIGNING* = "1.3.6.1.4.1.311.10.3.1" + szOID_KP_TIME_STAMP_SIGNING* = "1.3.6.1.4.1.311.10.3.2" + szOID_SERVER_GATED_CRYPTO* = "1.3.6.1.4.1.311.10.3.3" + szOID_SGC_NETSCAPE* = "2.16.840.1.113730.4.1" + szOID_KP_EFS* = "1.3.6.1.4.1.311.10.3.4" + szOID_EFS_RECOVERY* = "1.3.6.1.4.1.311.10.3.4.1" + szOID_WHQL_CRYPTO* = "1.3.6.1.4.1.311.10.3.5" + szOID_NT5_CRYPTO* = "1.3.6.1.4.1.311.10.3.6" + szOID_OEM_WHQL_CRYPTO* = "1.3.6.1.4.1.311.10.3.7" + szOID_EMBEDDED_NT_CRYPTO* = "1.3.6.1.4.1.311.10.3.8" + szOID_ROOT_LIST_SIGNER* = "1.3.6.1.4.1.311.10.3.9" + szOID_KP_QUALIFIED_SUBORDINATION* = "1.3.6.1.4.1.311.10.3.10" + szOID_KP_KEY_RECOVERY* = "1.3.6.1.4.1.311.10.3.11" + szOID_KP_DOCUMENT_SIGNING* = "1.3.6.1.4.1.311.10.3.12" + szOID_KP_LIFETIME_SIGNING* = "1.3.6.1.4.1.311.10.3.13" + szOID_KP_MOBILE_DEVICE_SOFTWARE* = "1.3.6.1.4.1.311.10.3.14" + szOID_KP_SMART_DISPLAY* = "1.3.6.1.4.1.311.10.3.15" + szOID_KP_CSP_SIGNATURE* = "1.3.6.1.4.1.311.10.3.16" + szOID_DRM* = "1.3.6.1.4.1.311.10.5.1" + szOID_DRM_INDIVIDUALIZATION* = "1.3.6.1.4.1.311.10.5.2" + szOID_LICENSES* = "1.3.6.1.4.1.311.10.6.1" + szOID_LICENSE_SERVER* = "1.3.6.1.4.1.311.10.6.2" + szOID_KP_SMARTCARD_LOGON* = "1.3.6.1.4.1.311.20.2.2" + szOID_KP_KERNEL_MODE_CODE_SIGNING* = "1.3.6.1.4.1.311.61.1.1" + szOID_KP_KERNEL_MODE_TRUSTED_BOOT_SIGNING* = "1.3.6.1.4.1.311.61.4.1" + szOID_REVOKED_LIST_SIGNER* = "1.3.6.1.4.1.311.10.3.19" + szOID_DISALLOWED_LIST* = "1.3.6.1.4.1.311.10.3.30" + szOID_KP_KERNEL_MODE_HAL_EXTENSION_SIGNING* = "1.3.6.1.4.1.311.61.5.1" + szOID_YESNO_TRUST_ATTR* = "1.3.6.1.4.1.311.10.4.1" + szOID_PKIX_POLICY_QUALIFIER_CPS* = "1.3.6.1.5.5.7.2.1" + szOID_PKIX_POLICY_QUALIFIER_USERNOTICE* = "1.3.6.1.5.5.7.2.2" + szOID_ROOT_PROGRAM_FLAGS* = "1.3.6.1.4.1.311.60.1.1" + CERT_ROOT_PROGRAM_FLAG_ORG* = 0x80 + CERT_ROOT_PROGRAM_FLAG_LSC* = 0x40 + CERT_ROOT_PROGRAM_FLAG_SUBJECT_LOGO* = 0x20 + CERT_ROOT_PROGRAM_FLAG_OU* = 0x10 + CERT_ROOT_PROGRAM_FLAG_ADDRESS* = 0x08 + szOID_CERT_POLICIES_95_QUALIFIER1* = "2.16.840.1.113733.1.7.1.1" + CERT_UNICODE_RDN_ERR_INDEX_MASK* = 0x3ff + CERT_UNICODE_RDN_ERR_INDEX_SHIFT* = 22 + CERT_UNICODE_ATTR_ERR_INDEX_MASK* = 0x3f + CERT_UNICODE_ATTR_ERR_INDEX_SHIFT* = 16 + CERT_UNICODE_VALUE_ERR_INDEX_MASK* = 0xffff + CERT_UNICODE_VALUE_ERR_INDEX_SHIFT* = 0 + CERT_ENCIPHER_ONLY_KEY_USAGE* = 0x01 + CERT_OFFLINE_CRL_SIGN_KEY_USAGE* = 0x02 + CERT_KEY_CERT_SIGN_KEY_USAGE* = 0x04 + CERT_KEY_AGREEMENT_KEY_USAGE* = 0x08 + CERT_DATA_ENCIPHERMENT_KEY_USAGE* = 0x10 + CERT_KEY_ENCIPHERMENT_KEY_USAGE* = 0x20 + CERT_NON_REPUDIATION_KEY_USAGE* = 0x40 + CERT_DIGITAL_SIGNATURE_KEY_USAGE* = 0x80 + CERT_DECIPHER_ONLY_KEY_USAGE* = 0x80 + CERT_ALT_NAME_OTHER_NAME* = 1 + CERT_ALT_NAME_RFC822_NAME* = 2 + CERT_ALT_NAME_DNS_NAME* = 3 + CERT_ALT_NAME_X400_ADDRESS* = 4 + CERT_ALT_NAME_DIRECTORY_NAME* = 5 + CERT_ALT_NAME_EDI_PARTY_NAME* = 6 + CERT_ALT_NAME_URL* = 7 + CERT_ALT_NAME_IP_ADDRESS* = 8 + CERT_ALT_NAME_REGISTERED_ID* = 9 + CERT_ALT_NAME_ENTRY_ERR_INDEX_MASK* = 0xff + CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT* = 16 + CERT_ALT_NAME_VALUE_ERR_INDEX_MASK* = 0x0000ffff + CERT_ALT_NAME_VALUE_ERR_INDEX_SHIFT* = 0 + CERT_CA_SUBJECT_FLAG* = 0x80 + CERT_END_ENTITY_SUBJECT_FLAG* = 0x40 + szOID_PKIX_ACC_DESCR* = "1.3.6.1.5.5.7.48" + szOID_PKIX_OCSP* = "1.3.6.1.5.5.7.48.1" + szOID_PKIX_CA_ISSUERS* = "1.3.6.1.5.5.7.48.2" + szOID_PKIX_TIME_STAMPING* = "1.3.6.1.5.5.7.48.3" + szOID_PKIX_CA_REPOSITORY* = "1.3.6.1.5.5.7.48.5" + CRL_REASON_UNSPECIFIED* = 0 + CRL_REASON_KEY_COMPROMISE* = 1 + CRL_REASON_CA_COMPROMISE* = 2 + CRL_REASON_AFFILIATION_CHANGED* = 3 + CRL_REASON_SUPERSEDED* = 4 + CRL_REASON_CESSATION_OF_OPERATION* = 5 + CRL_REASON_CERTIFICATE_HOLD* = 6 + CRL_REASON_REMOVE_FROM_CRL* = 8 + CRL_DIST_POINT_NO_NAME* = 0 + CRL_DIST_POINT_FULL_NAME* = 1 + CRL_DIST_POINT_ISSUER_RDN_NAME* = 2 + CRL_REASON_UNUSED_FLAG* = 0x80 + CRL_REASON_KEY_COMPROMISE_FLAG* = 0x40 + CRL_REASON_CA_COMPROMISE_FLAG* = 0x20 + CRL_REASON_AFFILIATION_CHANGED_FLAG* = 0x10 + CRL_REASON_SUPERSEDED_FLAG* = 0x08 + CRL_REASON_CESSATION_OF_OPERATION_FLAG* = 0x04 + CRL_REASON_CERTIFICATE_HOLD_FLAG* = 0x02 + CRL_DIST_POINT_ERR_INDEX_MASK* = 0x7f + CRL_DIST_POINT_ERR_INDEX_SHIFT* = 24 + CRL_DIST_POINT_ERR_CRL_ISSUER_BIT* = 0x80000000'i32 + CROSS_CERT_DIST_POINT_ERR_INDEX_MASK* = 0xff + CROSS_CERT_DIST_POINT_ERR_INDEX_SHIFT* = 24 + CERT_EXCLUDED_SUBTREE_BIT* = 0x80000000'i32 + SORTED_CTL_EXT_FLAGS_OFFSET* = 0 + SORTED_CTL_EXT_COUNT_OFFSET* = 4 + SORTED_CTL_EXT_MAX_COLLISION_OFFSET* = 8 + SORTED_CTL_EXT_HASH_BUCKET_OFFSET* = 12 + SORTED_CTL_EXT_HASHED_SUBJECT_IDENTIFIER_FLAG* = 0x1 + CERT_DSS_R_LEN* = 20 + CERT_DSS_S_LEN* = 20 + CERT_DSS_SIGNATURE_LEN* = CERT_DSS_R_LEN+CERT_DSS_S_LEN + CERT_MAX_ASN_ENCODED_DSS_SIGNATURE_LEN* = 48 + CRYPT_X942_PUB_INFO_BYTE_LENGTH* = 512/8 + CRYPT_RC2_40BIT_VERSION* = 160 + CRYPT_RC2_56BIT_VERSION* = 52 + CRYPT_RC2_64BIT_VERSION* = 120 + CRYPT_RC2_128BIT_VERSION* = 58 + szOID_QC_EU_COMPLIANCE* = "0.4.0.1862.1.1" + szOID_QC_SSCD* = "0.4.0.1862.1.4" + PKCS_RSA_SSA_PSS_TRAILER_FIELD_BC* = 1 + szOID_VERISIGN_PRIVATE_6_9* = "2.16.840.1.113733.1.6.9" + szOID_VERISIGN_ONSITE_JURISDICTION_HASH* = "2.16.840.1.113733.1.6.11" + szOID_VERISIGN_BITSTRING_6_13* = "2.16.840.1.113733.1.6.13" + szOID_VERISIGN_ISS_STRONG_CRYPTO* = "2.16.840.1.113733.1.8.1" + szOID_NETSCAPE* = "2.16.840.1.113730" + szOID_NETSCAPE_CERT_EXTENSION* = "2.16.840.1.113730.1" + szOID_NETSCAPE_CERT_TYPE* = "2.16.840.1.113730.1.1" + szOID_NETSCAPE_BASE_URL* = "2.16.840.1.113730.1.2" + szOID_NETSCAPE_REVOCATION_URL* = "2.16.840.1.113730.1.3" + szOID_NETSCAPE_CA_REVOCATION_URL* = "2.16.840.1.113730.1.4" + szOID_NETSCAPE_CERT_RENEWAL_URL* = "2.16.840.1.113730.1.7" + szOID_NETSCAPE_CA_POLICY_URL* = "2.16.840.1.113730.1.8" + szOID_NETSCAPE_SSL_SERVER_NAME* = "2.16.840.1.113730.1.12" + szOID_NETSCAPE_COMMENT* = "2.16.840.1.113730.1.13" + szOID_NETSCAPE_DATA_TYPE* = "2.16.840.1.113730.2" + szOID_NETSCAPE_CERT_SEQUENCE* = "2.16.840.1.113730.2.5" + NETSCAPE_SIGN_CA_CERT_TYPE* = 0x01 + NETSCAPE_SMIME_CA_CERT_TYPE* = 0x02 + NETSCAPE_SSL_CA_CERT_TYPE* = 0x04 + NETSCAPE_SIGN_CERT_TYPE* = 0x10 + NETSCAPE_SMIME_CERT_TYPE* = 0x20 + NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE* = 0x40 + NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE* = 0x80 + szOID_CT_PKI_DATA* = "1.3.6.1.5.5.7.12.2" + szOID_CT_PKI_RESPONSE* = "1.3.6.1.5.5.7.12.3" + szOID_PKIX_NO_SIGNATURE* = "1.3.6.1.5.5.7.6.2" + szOID_CMC* = "1.3.6.1.5.5.7.7" + szOID_CMC_STATUS_INFO* = "1.3.6.1.5.5.7.7.1" + szOID_CMC_IDENTIFICATION* = "1.3.6.1.5.5.7.7.2" + szOID_CMC_IDENTITY_PROOF* = "1.3.6.1.5.5.7.7.3" + szOID_CMC_DATA_RETURN* = "1.3.6.1.5.5.7.7.4" + szOID_CMC_TRANSACTION_ID* = "1.3.6.1.5.5.7.7.5" + szOID_CMC_SENDER_NONCE* = "1.3.6.1.5.5.7.7.6" + szOID_CMC_RECIPIENT_NONCE* = "1.3.6.1.5.5.7.7.7" + szOID_CMC_ADD_EXTENSIONS* = "1.3.6.1.5.5.7.7.8" + szOID_CMC_ENCRYPTED_POP* = "1.3.6.1.5.5.7.7.9" + szOID_CMC_DECRYPTED_POP* = "1.3.6.1.5.5.7.7.10" + szOID_CMC_LRA_POP_WITNESS* = "1.3.6.1.5.5.7.7.11" + szOID_CMC_GET_CERT* = "1.3.6.1.5.5.7.7.15" + szOID_CMC_GET_CRL* = "1.3.6.1.5.5.7.7.16" + szOID_CMC_REVOKE_REQUEST* = "1.3.6.1.5.5.7.7.17" + szOID_CMC_REG_INFO* = "1.3.6.1.5.5.7.7.18" + szOID_CMC_RESPONSE_INFO* = "1.3.6.1.5.5.7.7.19" + szOID_CMC_QUERY_PENDING* = "1.3.6.1.5.5.7.7.21" + szOID_CMC_ID_POP_LINK_RANDOM* = "1.3.6.1.5.5.7.7.22" + szOID_CMC_ID_POP_LINK_WITNESS* = "1.3.6.1.5.5.7.7.23" + szOID_CMC_ID_CONFIRM_CERT_ACCEPTANCE* = "1.3.6.1.5.5.7.7.24" + szOID_CMC_ADD_ATTRIBUTES* = "1.3.6.1.4.1.311.10.10.1" + CMC_TAGGED_CERT_REQUEST_CHOICE* = 1 + CMC_OTHER_INFO_NO_CHOICE* = 0 + CMC_OTHER_INFO_FAIL_CHOICE* = 1 + CMC_OTHER_INFO_PEND_CHOICE* = 2 + CMC_STATUS_SUCCESS* = 0 + CMC_STATUS_FAILED* = 2 + CMC_STATUS_PENDING* = 3 + CMC_STATUS_NO_SUPPORT* = 4 + CMC_STATUS_CONFIRM_REQUIRED* = 5 + CMC_FAIL_BAD_ALG* = 0 + CMC_FAIL_BAD_MESSAGE_CHECK* = 1 + CMC_FAIL_BAD_REQUEST* = 2 + CMC_FAIL_BAD_TIME* = 3 + CMC_FAIL_BAD_CERT_ID* = 4 + CMC_FAIL_UNSUPORTED_EXT* = 5 + CMC_FAIL_MUST_ARCHIVE_KEYS* = 6 + CMC_FAIL_BAD_IDENTITY* = 7 + CMC_FAIL_POP_REQUIRED* = 8 + CMC_FAIL_POP_FAILED* = 9 + CMC_FAIL_NO_KEY_REUSE* = 10 + CMC_FAIL_INTERNAL_CA_ERROR* = 11 + CMC_FAIL_TRY_LATER* = 12 + CERT_LOGOTYPE_GRAY_SCALE_IMAGE_INFO_CHOICE* = 1 + CERT_LOGOTYPE_COLOR_IMAGE_INFO_CHOICE* = 2 + CERT_LOGOTYPE_NO_IMAGE_RESOLUTION_CHOICE* = 0 + CERT_LOGOTYPE_BITS_IMAGE_RESOLUTION_CHOICE* = 1 + CERT_LOGOTYPE_TABLE_SIZE_IMAGE_RESOLUTION_CHOICE* = 2 + CERT_LOGOTYPE_DIRECT_INFO_CHOICE* = 1 + CERT_LOGOTYPE_INDIRECT_INFO_CHOICE* = 2 + szOID_LOYALTY_OTHER_LOGOTYPE* = "1.3.6.1.5.5.7.20.1" + szOID_BACKGROUND_OTHER_LOGOTYPE* = "1.3.6.1.5.5.7.20.2" + CERT_BIOMETRIC_PREDEFINED_DATA_CHOICE* = 1 + CERT_BIOMETRIC_OID_DATA_CHOICE* = 2 + CERT_BIOMETRIC_PICTURE_TYPE* = 0 + CERT_BIOMETRIC_SIGNATURE_TYPE* = 1 + OCSP_REQUEST_V1* = 0 + OCSP_SUCCESSFUL_RESPONSE* = 0 + OCSP_MALFORMED_REQUEST_RESPONSE* = 1 + OCSP_INTERNAL_ERROR_RESPONSE* = 2 + OCSP_TRY_LATER_RESPONSE* = 3 + OCSP_SIG_REQUIRED_RESPONSE* = 5 + OCSP_UNAUTHORIZED_RESPONSE* = 6 + szOID_PKIX_OCSP_BASIC_SIGNED_RESPONSE* = "1.3.6.1.5.5.7.48.1.1" + OCSP_BASIC_GOOD_CERT_STATUS* = 0 + OCSP_BASIC_REVOKED_CERT_STATUS* = 1 + OCSP_BASIC_UNKNOWN_CERT_STATUS* = 2 + OCSP_BASIC_RESPONSE_V1* = 0 + OCSP_BASIC_BY_NAME_RESPONDER_ID* = 1 + OCSP_BASIC_BY_KEY_RESPONDER_ID* = 2 + CRYPT_OID_ENCODE_OBJECT_FUNC* = "CryptDllEncodeObject" + CRYPT_OID_DECODE_OBJECT_FUNC* = "CryptDllDecodeObject" + CRYPT_OID_ENCODE_OBJECT_EX_FUNC* = "CryptDllEncodeObjectEx" + CRYPT_OID_DECODE_OBJECT_EX_FUNC* = "CryptDllDecodeObjectEx" + CRYPT_OID_CREATE_COM_OBJECT_FUNC* = "CryptDllCreateCOMObject" + CRYPT_OID_VERIFY_REVOCATION_FUNC* = "CertDllVerifyRevocation" + CRYPT_OID_VERIFY_CTL_USAGE_FUNC* = "CertDllVerifyCTLUsage" + CRYPT_OID_FORMAT_OBJECT_FUNC* = "CryptDllFormatObject" + CRYPT_OID_FIND_OID_INFO_FUNC* = "CryptDllFindOIDInfo" + CRYPT_OID_FIND_LOCALIZED_NAME_FUNC* = "CryptDllFindLocalizedName" + CRYPT_OID_REGPATH* = "Software\\Microsoft\\Cryptography\\OID" + CRYPT_OID_REG_ENCODING_TYPE_PREFIX* = "EncodingType " + CRYPT_OID_REG_DLL_VALUE_NAME* = "Dll" + CRYPT_OID_REG_FUNC_NAME_VALUE_NAME* = "FuncName" + CRYPT_OID_REG_FUNC_NAME_VALUE_NAME_A* = "FuncName" + CRYPT_OID_REG_FLAGS_VALUE_NAME* = "CryptFlags" + CRYPT_DEFAULT_OID* = "DEFAULT" + CRYPT_INSTALL_OID_FUNC_BEFORE_FLAG* = 1 + CRYPT_GET_INSTALLED_OID_FUNC_FLAG* = 0x1 + CRYPT_REGISTER_FIRST_INDEX* = 0 + CRYPT_REGISTER_LAST_INDEX* = 0xffffffff'i32 + CRYPT_MATCH_ANY_ENCODING_TYPE* = 0xffffffff'i32 + CALG_OID_INFO_CNG_ONLY* = 0xffffffff'i32 + CALG_OID_INFO_PARAMETERS* = 0xfffffffe'i32 + CRYPT_OID_INFO_HASH_PARAMETERS_ALGORITHM* = "CryptOIDInfoHashParameters" + CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM* = "CryptOIDInfoECCParameters" + CRYPT_OID_INFO_MGF1_PARAMETERS_ALGORITHM* = "CryptOIDInfoMgf1Parameters" + CRYPT_OID_INFO_NO_SIGN_ALGORITHM* = "CryptOIDInfoNoSign" + CRYPT_OID_INFO_OAEP_PARAMETERS_ALGORITHM* = "CryptOIDInfoOAEPParameters" + CRYPT_OID_INFO_ECC_WRAP_PARAMETERS_ALGORITHM* = "CryptOIDInfoECCWrapParameters" + CRYPT_OID_INFO_NO_PARAMETERS_ALGORITHM* = "CryptOIDInfoNoParameters" + CRYPT_HASH_ALG_OID_GROUP_ID* = 1 + CRYPT_ENCRYPT_ALG_OID_GROUP_ID* = 2 + CRYPT_PUBKEY_ALG_OID_GROUP_ID* = 3 + CRYPT_SIGN_ALG_OID_GROUP_ID* = 4 + CRYPT_RDN_ATTR_OID_GROUP_ID* = 5 + CRYPT_EXT_OR_ATTR_OID_GROUP_ID* = 6 + CRYPT_ENHKEY_USAGE_OID_GROUP_ID* = 7 + CRYPT_POLICY_OID_GROUP_ID* = 8 + CRYPT_TEMPLATE_OID_GROUP_ID* = 9 + CRYPT_KDF_OID_GROUP_ID* = 10 + CRYPT_LAST_OID_GROUP_ID* = 10 + CRYPT_FIRST_ALG_OID_GROUP_ID* = CRYPT_HASH_ALG_OID_GROUP_ID + CRYPT_LAST_ALG_OID_GROUP_ID* = CRYPT_SIGN_ALG_OID_GROUP_ID + CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG* = 0x1 + CRYPT_OID_USE_PUBKEY_PARA_FOR_PKCS7_FLAG* = 0x2 + CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG* = 0x4 + CRYPT_OID_PUBKEY_ENCRYPT_ONLY_FLAG* = 0x40000000 + CRYPT_OID_PUBKEY_SIGN_ONLY_FLAG* = 0x80000000'i32 + CRYPT_OID_INFO_OID_KEY* = 1 + CRYPT_OID_INFO_NAME_KEY* = 2 + CRYPT_OID_INFO_ALGID_KEY* = 3 + CRYPT_OID_INFO_SIGN_KEY* = 4 + CRYPT_OID_INFO_CNG_ALGID_KEY* = 5 + CRYPT_OID_INFO_CNG_SIGN_KEY* = 6 + CRYPT_OID_INFO_OID_KEY_FLAGS_MASK* = 0xffff0000'i32 + CRYPT_OID_INFO_PUBKEY_SIGN_KEY_FLAG* = 0x80000000'i32 + CRYPT_OID_INFO_PUBKEY_ENCRYPT_KEY_FLAG* = 0x40000000 + CRYPT_OID_DISABLE_SEARCH_DS_FLAG* = 0x80000000'i32 + CRYPT_OID_PREFER_CNG_ALGID_FLAG* = 0x40000000 + CRYPT_OID_INFO_OID_GROUP_BIT_LEN_MASK* = 0x0fff0000 + CRYPT_OID_INFO_OID_GROUP_BIT_LEN_SHIFT* = 16 + CRYPT_INSTALL_OID_INFO_BEFORE_FLAG* = 1 + CRYPT_LOCALIZED_NAME_ENCODING_TYPE* = 0 + CRYPT_LOCALIZED_NAME_OID* = "LocalizedNames" + CERT_STRONG_SIGN_ECDSA_ALGORITHM* = "ECDSA" + CERT_STRONG_SIGN_SERIALIZED_INFO_CHOICE* = 1 + CERT_STRONG_SIGN_OID_INFO_CHOICE* = 2 + CERT_STRONG_SIGN_ENABLE_CRL_CHECK* = 0x1 + CERT_STRONG_SIGN_ENABLE_OCSP_CHECK* = 0x2 + szOID_CERT_STRONG_SIGN_OS_PREFIX* = "1.3.6.1.4.1.311.72.1." + szOID_CERT_STRONG_SIGN_OS_1* = "1.3.6.1.4.1.311.72.1.1" + szOID_CERT_STRONG_SIGN_OS_CURRENT* = szOID_CERT_STRONG_SIGN_OS_1 + szOID_CERT_STRONG_KEY_OS_PREFIX* = "1.3.6.1.4.1.311.72.2." + szOID_CERT_STRONG_KEY_OS_1* = "1.3.6.1.4.1.311.72.2.1" + szOID_CERT_STRONG_KEY_OS_CURRENT* = szOID_CERT_STRONG_KEY_OS_1 + szOID_PKCS_7_DATA* = "1.2.840.113549.1.7.1" + szOID_PKCS_7_SIGNED* = "1.2.840.113549.1.7.2" + szOID_PKCS_7_ENVELOPED* = "1.2.840.113549.1.7.3" + szOID_PKCS_7_SIGNEDANDENVELOPED* = "1.2.840.113549.1.7.4" + szOID_PKCS_7_DIGESTED* = "1.2.840.113549.1.7.5" + szOID_PKCS_7_ENCRYPTED* = "1.2.840.113549.1.7.6" + szOID_PKCS_9_CONTENT_TYPE* = "1.2.840.113549.1.9.3" + szOID_PKCS_9_MESSAGE_DIGEST* = "1.2.840.113549.1.9.4" + CMSG_DATA* = 1 + CMSG_SIGNED* = 2 + CMSG_ENVELOPED* = 3 + CMSG_SIGNED_AND_ENVELOPED* = 4 + CMSG_HASHED* = 5 + CMSG_ENCRYPTED* = 6 + CMSG_ALL_FLAGS* = not 0 + CMSG_DATA_FLAG* = 1 shl CMSG_DATA + CMSG_SIGNED_FLAG* = 1 shl CMSG_SIGNED + CMSG_ENVELOPED_FLAG* = 1 shl CMSG_ENVELOPED + CMSG_SIGNED_AND_ENVELOPED_FLAG* = 1 shl CMSG_SIGNED_AND_ENVELOPED + CMSG_HASHED_FLAG* = 1 shl CMSG_HASHED + CMSG_ENCRYPTED_FLAG* = 1 shl CMSG_ENCRYPTED + CERT_ID_ISSUER_SERIAL_NUMBER* = 1 + CERT_ID_KEY_IDENTIFIER* = 2 + CERT_ID_SHA1_HASH* = 3 + CMSG_KEY_AGREE_EPHEMERAL_KEY_CHOICE* = 1 + CMSG_KEY_AGREE_STATIC_KEY_CHOICE* = 2 + CMSG_MAIL_LIST_HANDLE_KEY_CHOICE* = 1 + CMSG_KEY_TRANS_RECIPIENT* = 1 + CMSG_KEY_AGREE_RECIPIENT* = 2 + CMSG_MAIL_LIST_RECIPIENT* = 3 + CMSG_RC4_NO_SALT_FLAG* = 0x40000000 + CMSG_SP3_COMPATIBLE_ENCRYPT_FLAG* = 0x80000000'i32 + CMSG_INDEFINITE_LENGTH* = 0xffffffff'i32 + CMSG_BARE_CONTENT_FLAG* = 0x1 + CMSG_LENGTH_ONLY_FLAG* = 0x2 + CMSG_DETACHED_FLAG* = 0x4 + CMSG_AUTHENTICATED_ATTRIBUTES_FLAG* = 0x8 + CMSG_CONTENTS_OCTETS_FLAG* = 0x10 + CMSG_MAX_LENGTH_FLAG* = 0x20 + CMSG_CMS_ENCAPSULATED_CONTENT_FLAG* = 0x40 + CMSG_CRYPT_RELEASE_CONTEXT_FLAG* = 0x8000 + CMSG_TYPE_PARAM* = 1 + CMSG_CONTENT_PARAM* = 2 + CMSG_BARE_CONTENT_PARAM* = 3 + CMSG_INNER_CONTENT_TYPE_PARAM* = 4 + CMSG_SIGNER_COUNT_PARAM* = 5 + CMSG_SIGNER_INFO_PARAM* = 6 + CMSG_SIGNER_CERT_INFO_PARAM* = 7 + CMSG_SIGNER_HASH_ALGORITHM_PARAM* = 8 + CMSG_SIGNER_AUTH_ATTR_PARAM* = 9 + CMSG_SIGNER_UNAUTH_ATTR_PARAM* = 10 + CMSG_CERT_COUNT_PARAM* = 11 + CMSG_CERT_PARAM* = 12 + CMSG_CRL_COUNT_PARAM* = 13 + CMSG_CRL_PARAM* = 14 + CMSG_ENVELOPE_ALGORITHM_PARAM* = 15 + CMSG_RECIPIENT_COUNT_PARAM* = 17 + CMSG_RECIPIENT_INDEX_PARAM* = 18 + CMSG_RECIPIENT_INFO_PARAM* = 19 + CMSG_HASH_ALGORITHM_PARAM* = 20 + CMSG_HASH_DATA_PARAM* = 21 + CMSG_COMPUTED_HASH_PARAM* = 22 + CMSG_ENCRYPT_PARAM* = 26 + CMSG_ENCRYPTED_DIGEST* = 27 + CMSG_ENCODED_SIGNER* = 28 + CMSG_ENCODED_MESSAGE* = 29 + CMSG_VERSION_PARAM* = 30 + CMSG_ATTR_CERT_COUNT_PARAM* = 31 + CMSG_ATTR_CERT_PARAM* = 32 + CMSG_CMS_RECIPIENT_COUNT_PARAM* = 33 + CMSG_CMS_RECIPIENT_INDEX_PARAM* = 34 + CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM* = 35 + CMSG_CMS_RECIPIENT_INFO_PARAM* = 36 + CMSG_UNPROTECTED_ATTR_PARAM* = 37 + CMSG_SIGNER_CERT_ID_PARAM* = 38 + CMSG_CMS_SIGNER_INFO_PARAM* = 39 + CMSG_SIGNED_DATA_V1* = 1 + CMSG_SIGNED_DATA_V3* = 3 + CMSG_SIGNED_DATA_PKCS_1_5_VERSION* = CMSG_SIGNED_DATA_V1 + CMSG_SIGNED_DATA_CMS_VERSION* = CMSG_SIGNED_DATA_V3 + CMSG_SIGNER_INFO_V1* = 1 + CMSG_SIGNER_INFO_V3* = 3 + CMSG_SIGNER_INFO_PKCS_1_5_VERSION* = CMSG_SIGNER_INFO_V1 + CMSG_SIGNER_INFO_CMS_VERSION* = CMSG_SIGNER_INFO_V3 + CMSG_HASHED_DATA_V0* = 0 + CMSG_HASHED_DATA_V2* = 2 + CMSG_HASHED_DATA_PKCS_1_5_VERSION* = CMSG_HASHED_DATA_V0 + CMSG_HASHED_DATA_CMS_VERSION* = CMSG_HASHED_DATA_V2 + CMSG_ENVELOPED_DATA_V0* = 0 + CMSG_ENVELOPED_DATA_V2* = 2 + CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION* = CMSG_ENVELOPED_DATA_V0 + CMSG_ENVELOPED_DATA_CMS_VERSION* = CMSG_ENVELOPED_DATA_V2 + CMSG_KEY_AGREE_ORIGINATOR_CERT* = 1 + CMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEY* = 2 + CMSG_ENVELOPED_RECIPIENT_V0* = 0 + CMSG_ENVELOPED_RECIPIENT_V2* = 2 + CMSG_ENVELOPED_RECIPIENT_V3* = 3 + CMSG_ENVELOPED_RECIPIENT_V4* = 4 + CMSG_KEY_TRANS_PKCS_1_5_VERSION* = CMSG_ENVELOPED_RECIPIENT_V0 + CMSG_KEY_TRANS_CMS_VERSION* = CMSG_ENVELOPED_RECIPIENT_V2 + CMSG_KEY_AGREE_VERSION* = CMSG_ENVELOPED_RECIPIENT_V3 + CMSG_MAIL_LIST_VERSION* = CMSG_ENVELOPED_RECIPIENT_V4 + CMSG_CTRL_VERIFY_SIGNATURE* = 1 + CMSG_CTRL_DECRYPT* = 2 + CMSG_CTRL_VERIFY_HASH* = 5 + CMSG_CTRL_ADD_SIGNER* = 6 + CMSG_CTRL_DEL_SIGNER* = 7 + CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR* = 8 + CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR* = 9 + CMSG_CTRL_ADD_CERT* = 10 + CMSG_CTRL_DEL_CERT* = 11 + CMSG_CTRL_ADD_CRL* = 12 + CMSG_CTRL_DEL_CRL* = 13 + CMSG_CTRL_ADD_ATTR_CERT* = 14 + CMSG_CTRL_DEL_ATTR_CERT* = 15 + CMSG_CTRL_KEY_TRANS_DECRYPT* = 16 + CMSG_CTRL_KEY_AGREE_DECRYPT* = 17 + CMSG_CTRL_MAIL_LIST_DECRYPT* = 18 + CMSG_CTRL_VERIFY_SIGNATURE_EX* = 19 + CMSG_CTRL_ADD_CMS_SIGNER_INFO* = 20 + CMSG_CTRL_ENABLE_STRONG_SIGNATURE* = 21 + CMSG_VERIFY_SIGNER_PUBKEY* = 1 + CMSG_VERIFY_SIGNER_CERT* = 2 + CMSG_VERIFY_SIGNER_CHAIN* = 3 + CMSG_VERIFY_SIGNER_NULL* = 4 + CMSG_VERIFY_COUNTER_SIGN_ENABLE_STRONG_FLAG* = 0x1 + CMSG_OID_GEN_ENCRYPT_KEY_FUNC* = "CryptMsgDllGenEncryptKey" + CMSG_OID_EXPORT_ENCRYPT_KEY_FUNC* = "CryptMsgDllExportEncryptKey" + CMSG_OID_IMPORT_ENCRYPT_KEY_FUNC* = "CryptMsgDllImportEncryptKey" + CMSG_DEFAULT_INSTALLABLE_FUNC_OID* = cast[LPCSTR](1) + CMSG_CONTENT_ENCRYPT_PAD_ENCODED_LEN_FLAG* = 0x1 + CMSG_CONTENT_ENCRYPT_FREE_PARA_FLAG* = 0x1 + CMSG_CONTENT_ENCRYPT_FREE_OBJID_FLAG* = 0x2 + CMSG_CONTENT_ENCRYPT_RELEASE_CONTEXT_FLAG* = 0x8000 + CMSG_OID_GEN_CONTENT_ENCRYPT_KEY_FUNC* = "CryptMsgDllGenContentEncryptKey" + CMSG_OID_CAPI1_GEN_CONTENT_ENCRYPT_KEY_FUNC* = CMSG_OID_GEN_CONTENT_ENCRYPT_KEY_FUNC + CMSG_OID_CNG_GEN_CONTENT_ENCRYPT_KEY_FUNC* = "CryptMsgDllCNGGenContentEncryptKey" + CMSG_KEY_TRANS_ENCRYPT_FREE_PARA_FLAG* = 0x1 + CMSG_KEY_TRANS_ENCRYPT_FREE_OBJID_FLAG* = 0x2 + CMSG_OID_EXPORT_KEY_TRANS_FUNC* = "CryptMsgDllExportKeyTrans" + CMSG_OID_CAPI1_EXPORT_KEY_TRANS_FUNC* = CMSG_OID_EXPORT_KEY_TRANS_FUNC + CMSG_OID_CNG_EXPORT_KEY_TRANS_FUNC* = "CryptMsgDllCNGExportKeyTrans" + CMSG_KEY_AGREE_ENCRYPT_FREE_PARA_FLAG* = 0x1 + CMSG_KEY_AGREE_ENCRYPT_FREE_MATERIAL_FLAG* = 0x2 + CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_ALG_FLAG* = 0x4 + CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_PARA_FLAG* = 0x8 + CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_BITS_FLAG* = 0x10 + CMSG_KEY_AGREE_ENCRYPT_FREE_OBJID_FLAG* = 0x20 + CMSG_OID_EXPORT_KEY_AGREE_FUNC* = "CryptMsgDllExportKeyAgree" + CMSG_OID_CAPI1_EXPORT_KEY_AGREE_FUNC* = CMSG_OID_EXPORT_KEY_AGREE_FUNC + CMSG_OID_CNG_EXPORT_KEY_AGREE_FUNC* = "CryptMsgDllCNGExportKeyAgree" + CMSG_MAIL_LIST_ENCRYPT_FREE_PARA_FLAG* = 0x1 + CMSG_MAIL_LIST_ENCRYPT_FREE_OBJID_FLAG* = 0x2 + CMSG_OID_EXPORT_MAIL_LIST_FUNC* = "CryptMsgDllExportMailList" + CMSG_OID_CAPI1_EXPORT_MAIL_LIST_FUNC* = CMSG_OID_EXPORT_MAIL_LIST_FUNC + CMSG_OID_IMPORT_KEY_TRANS_FUNC* = "CryptMsgDllImportKeyTrans" + CMSG_OID_CAPI1_IMPORT_KEY_TRANS_FUNC* = CMSG_OID_IMPORT_KEY_TRANS_FUNC + CMSG_OID_IMPORT_KEY_AGREE_FUNC* = "CryptMsgDllImportKeyAgree" + CMSG_OID_CAPI1_IMPORT_KEY_AGREE_FUNC* = CMSG_OID_IMPORT_KEY_AGREE_FUNC + CMSG_OID_IMPORT_MAIL_LIST_FUNC* = "CryptMsgDllImportMailList" + CMSG_OID_CAPI1_IMPORT_MAIL_LIST_FUNC* = CMSG_OID_IMPORT_MAIL_LIST_FUNC + CMSG_OID_CNG_IMPORT_KEY_TRANS_FUNC* = "CryptMsgDllCNGImportKeyTrans" + CMSG_OID_CNG_IMPORT_KEY_AGREE_FUNC* = "CryptMsgDllCNGImportKeyAgree" + CMSG_OID_CNG_IMPORT_CONTENT_ENCRYPT_KEY_FUNC* = "CryptMsgDllCNGImportContentEncryptKey" + CERT_KEY_PROV_HANDLE_PROP_ID* = 1 + CERT_KEY_PROV_INFO_PROP_ID* = 2 + CERT_SHA1_HASH_PROP_ID* = 3 + CERT_MD5_HASH_PROP_ID* = 4 + CERT_HASH_PROP_ID* = CERT_SHA1_HASH_PROP_ID + CERT_KEY_CONTEXT_PROP_ID* = 5 + CERT_KEY_SPEC_PROP_ID* = 6 + CERT_IE30_RESERVED_PROP_ID* = 7 + CERT_PUBKEY_HASH_RESERVED_PROP_ID* = 8 + CERT_ENHKEY_USAGE_PROP_ID* = 9 + CERT_CTL_USAGE_PROP_ID* = CERT_ENHKEY_USAGE_PROP_ID + CERT_NEXT_UPDATE_LOCATION_PROP_ID* = 10 + CERT_FRIENDLY_NAME_PROP_ID* = 11 + CERT_PVK_FILE_PROP_ID* = 12 + CERT_DESCRIPTION_PROP_ID* = 13 + CERT_ACCESS_STATE_PROP_ID* = 14 + CERT_SIGNATURE_HASH_PROP_ID* = 15 + CERT_SMART_CARD_DATA_PROP_ID* = 16 + CERT_EFS_PROP_ID* = 17 + CERT_FORTEZZA_DATA_PROP_ID* = 18 + CERT_ARCHIVED_PROP_ID* = 19 + CERT_KEY_IDENTIFIER_PROP_ID* = 20 + CERT_AUTO_ENROLL_PROP_ID* = 21 + CERT_PUBKEY_ALG_PARA_PROP_ID* = 22 + CERT_CROSS_CERT_DIST_POINTS_PROP_ID* = 23 + CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID* = 24 + CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID* = 25 + CERT_ENROLLMENT_PROP_ID* = 26 + CERT_DATE_STAMP_PROP_ID* = 27 + CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID* = 28 + CERT_SUBJECT_NAME_MD5_HASH_PROP_ID* = 29 + CERT_EXTENDED_ERROR_INFO_PROP_ID* = 30 + CERT_RENEWAL_PROP_ID* = 64 + CERT_ARCHIVED_KEY_HASH_PROP_ID* = 65 + CERT_AUTO_ENROLL_RETRY_PROP_ID* = 66 + CERT_AIA_URL_RETRIEVED_PROP_ID* = 67 + CERT_AUTHORITY_INFO_ACCESS_PROP_ID* = 68 + CERT_BACKED_UP_PROP_ID* = 69 + CERT_OCSP_RESPONSE_PROP_ID* = 70 + CERT_REQUEST_ORIGINATOR_PROP_ID* = 71 + CERT_SOURCE_LOCATION_PROP_ID* = 72 + CERT_SOURCE_URL_PROP_ID* = 73 + CERT_NEW_KEY_PROP_ID* = 74 + CERT_OCSP_CACHE_PREFIX_PROP_ID* = 75 + CERT_SMART_CARD_ROOT_INFO_PROP_ID* = 76 + CERT_NO_AUTO_EXPIRE_CHECK_PROP_ID* = 77 + CERT_NCRYPT_KEY_HANDLE_PROP_ID* = 78 + CERT_HCRYPTPROV_OR_NCRYPT_KEY_HANDLE_PROP_ID* = 79 + CERT_SUBJECT_INFO_ACCESS_PROP_ID* = 80 + CERT_CA_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID* = 81 + CERT_CA_DISABLE_CRL_PROP_ID* = 82 + CERT_ROOT_PROGRAM_CERT_POLICIES_PROP_ID* = 83 + CERT_ROOT_PROGRAM_NAME_CONSTRAINTS_PROP_ID* = 84 + CERT_SUBJECT_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID* = 85 + CERT_SUBJECT_DISABLE_CRL_PROP_ID* = 86 + CERT_CEP_PROP_ID* = 87 + CERT_SIGN_HASH_CNG_ALG_PROP_ID* = 89 + CERT_SCARD_PIN_ID_PROP_ID* = 90 + CERT_SCARD_PIN_INFO_PROP_ID* = 91 + CERT_SUBJECT_PUB_KEY_BIT_LENGTH_PROP_ID* = 92 + CERT_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID* = 93 + CERT_ISSUER_PUB_KEY_BIT_LENGTH_PROP_ID* = 94 + CERT_ISSUER_CHAIN_SIGN_HASH_CNG_ALG_PROP_ID* = 95 + CERT_ISSUER_CHAIN_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID* = 96 + CERT_NO_EXPIRE_NOTIFICATION_PROP_ID* = 97 + CERT_AUTH_ROOT_SHA256_HASH_PROP_ID* = 98 + CERT_NCRYPT_KEY_HANDLE_TRANSFER_PROP_ID* = 99 + CERT_HCRYPTPROV_TRANSFER_PROP_ID* = 100 + CERT_SMART_CARD_READER_PROP_ID* = 101 + CERT_SEND_AS_TRUSTED_ISSUER_PROP_ID* = 102 + CERT_KEY_REPAIR_ATTEMPTED_PROP_ID* = 103 + CERT_DISALLOWED_FILETIME_PROP_ID* = 104 + CERT_ROOT_PROGRAM_CHAIN_POLICIES_PROP_ID* = 105 + CERT_SMART_CARD_READER_NON_REMOVABLE_PROP_ID* = 106 + CERT_FIRST_RESERVED_PROP_ID* = 107 + CERT_LAST_RESERVED_PROP_ID* = 0x00007fff + CERT_FIRST_USER_PROP_ID* = 0x8000 + CERT_LAST_USER_PROP_ID* = 0x0000ffff + szOID_CERT_PROP_ID_PREFIX* = "1.3.6.1.4.1.311.10.11." + szOID_CERT_KEY_IDENTIFIER_PROP_ID* = "1.3.6.1.4.1.311.10.11.20" + szOID_CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID* = "1.3.6.1.4.1.311.10.11.28" + szOID_CERT_SUBJECT_NAME_MD5_HASH_PROP_ID* = "1.3.6.1.4.1.311.10.11.29" + szOID_CERT_MD5_HASH_PROP_ID* = "1.3.6.1.4.1.311.10.11.4" + szOID_CERT_SIGNATURE_HASH_PROP_ID* = "1.3.6.1.4.1.311.10.11.15" + szOID_DISALLOWED_HASH* = szOID_CERT_SIGNATURE_HASH_PROP_ID + szOID_CERT_DISALLOWED_FILETIME_PROP_ID* = "1.3.6.1.4.1.311.10.11.104" + CERT_ACCESS_STATE_WRITE_PERSIST_FLAG* = 0x1 + CERT_ACCESS_STATE_SYSTEM_STORE_FLAG* = 0x2 + CERT_ACCESS_STATE_LM_SYSTEM_STORE_FLAG* = 0x4 + CERT_ACCESS_STATE_GP_SYSTEM_STORE_FLAG* = 0x8 + CERT_ACCESS_STATE_SHARED_USER_FLAG* = 0x10 + szOID_ROOT_PROGRAM_AUTO_UPDATE_CA_REVOCATION* = "1.3.6.1.4.1.311.60.3.1" + szOID_ROOT_PROGRAM_AUTO_UPDATE_END_REVOCATION* = "1.3.6.1.4.1.311.60.3.2" + szOID_ROOT_PROGRAM_NO_OCSP_FAILOVER_TO_CRL* = "1.3.6.1.4.1.311.60.3.3" + CERT_SET_KEY_PROV_HANDLE_PROP_ID* = 0x1 + CERT_SET_KEY_CONTEXT_PROP_ID* = 0x1 + CERT_NCRYPT_KEY_SPEC* = 0xffffffff'i32 + CERT_STORE_PROV_MSG* = cast[LPCSTR](1) + CERT_STORE_PROV_MEMORY* = cast[LPCSTR](2) + CERT_STORE_PROV_FILE* = cast[LPCSTR](3) + CERT_STORE_PROV_REG* = cast[LPCSTR](4) + CERT_STORE_PROV_PKCS7* = cast[LPCSTR](5) + CERT_STORE_PROV_SERIALIZED* = cast[LPCSTR](6) + CERT_STORE_PROV_FILENAME_A* = cast[LPCSTR](7) + CERT_STORE_PROV_FILENAME_W* = cast[LPCSTR](8) + CERT_STORE_PROV_FILENAME* = CERT_STORE_PROV_FILENAME_W + CERT_STORE_PROV_SYSTEM_A* = cast[LPCSTR](9) + CERT_STORE_PROV_SYSTEM_W* = cast[LPCSTR](10) + CERT_STORE_PROV_SYSTEM* = CERT_STORE_PROV_SYSTEM_W + CERT_STORE_PROV_COLLECTION* = cast[LPCSTR](11) + CERT_STORE_PROV_SYSTEM_REGISTRY_A* = cast[LPCSTR](12) + CERT_STORE_PROV_SYSTEM_REGISTRY_W* = cast[LPCSTR](13) + CERT_STORE_PROV_SYSTEM_REGISTRY* = CERT_STORE_PROV_SYSTEM_REGISTRY_W + CERT_STORE_PROV_PHYSICAL_W* = cast[LPCSTR](14) + CERT_STORE_PROV_PHYSICAL* = CERT_STORE_PROV_PHYSICAL_W + CERT_STORE_PROV_SMART_CARD_W* = cast[LPCSTR](15) + CERT_STORE_PROV_SMART_CARD* = CERT_STORE_PROV_SMART_CARD_W + CERT_STORE_PROV_LDAP_W* = cast[LPCSTR](16) + CERT_STORE_PROV_LDAP* = CERT_STORE_PROV_LDAP_W + CERT_STORE_PROV_PKCS12* = cast[LPCSTR](17) + sz_CERT_STORE_PROV_MEMORY* = "Memory" + sz_CERT_STORE_PROV_FILENAME_W* = "File" + sz_CERT_STORE_PROV_FILENAME* = sz_CERT_STORE_PROV_FILENAME_W + sz_CERT_STORE_PROV_SYSTEM_W* = "System" + sz_CERT_STORE_PROV_SYSTEM* = sz_CERT_STORE_PROV_SYSTEM_W + sz_CERT_STORE_PROV_PKCS7* = "PKCS7" + sz_CERT_STORE_PROV_PKCS12* = "PKCS12" + sz_CERT_STORE_PROV_SERIALIZED* = "Serialized" + sz_CERT_STORE_PROV_COLLECTION* = "Collection" + sz_CERT_STORE_PROV_SYSTEM_REGISTRY_W* = "SystemRegistry" + sz_CERT_STORE_PROV_SYSTEM_REGISTRY* = sz_CERT_STORE_PROV_SYSTEM_REGISTRY_W + sz_CERT_STORE_PROV_PHYSICAL_W* = "Physical" + sz_CERT_STORE_PROV_PHYSICAL* = sz_CERT_STORE_PROV_PHYSICAL_W + sz_CERT_STORE_PROV_SMART_CARD_W* = "SmartCard" + sz_CERT_STORE_PROV_SMART_CARD* = sz_CERT_STORE_PROV_SMART_CARD_W + sz_CERT_STORE_PROV_LDAP_W* = "Ldap" + sz_CERT_STORE_PROV_LDAP* = sz_CERT_STORE_PROV_LDAP_W + CERT_STORE_SIGNATURE_FLAG* = 0x1 + CERT_STORE_TIME_VALIDITY_FLAG* = 0x2 + CERT_STORE_REVOCATION_FLAG* = 0x4 + CERT_STORE_NO_CRL_FLAG* = 0x10000 + CERT_STORE_NO_ISSUER_FLAG* = 0x20000 + CERT_STORE_BASE_CRL_FLAG* = 0x100 + CERT_STORE_DELTA_CRL_FLAG* = 0x200 + CERT_STORE_NO_CRYPT_RELEASE_FLAG* = 0x1 + CERT_STORE_SET_LOCALIZED_NAME_FLAG* = 0x2 + CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG* = 0x4 + CERT_STORE_DELETE_FLAG* = 0x10 + CERT_STORE_UNSAFE_PHYSICAL_FLAG* = 0x20 + CERT_STORE_SHARE_STORE_FLAG* = 0x40 + CERT_STORE_SHARE_CONTEXT_FLAG* = 0x80 + CERT_STORE_MANIFOLD_FLAG* = 0x100 + CERT_STORE_ENUM_ARCHIVED_FLAG* = 0x200 + CERT_STORE_UPDATE_KEYID_FLAG* = 0x400 + CERT_STORE_BACKUP_RESTORE_FLAG* = 0x800 + CERT_STORE_READONLY_FLAG* = 0x8000 + CERT_STORE_OPEN_EXISTING_FLAG* = 0x4000 + CERT_STORE_CREATE_NEW_FLAG* = 0x2000 + CERT_STORE_MAXIMUM_ALLOWED_FLAG* = 0x1000 + CERT_SYSTEM_STORE_MASK* = 0xffff0000'i32 + CERT_SYSTEM_STORE_RELOCATE_FLAG* = 0x80000000'i32 + CERT_SYSTEM_STORE_DEFER_READ_FLAG* = 0x20000000 + CERT_SYSTEM_STORE_UNPROTECTED_FLAG* = 0x40000000 + CERT_SYSTEM_STORE_LOCATION_MASK* = 0x00ff0000 + CERT_SYSTEM_STORE_LOCATION_SHIFT* = 16 + CERT_SYSTEM_STORE_CURRENT_USER_ID* = 1 + CERT_SYSTEM_STORE_LOCAL_MACHINE_ID* = 2 + CERT_SYSTEM_STORE_CURRENT_SERVICE_ID* = 4 + CERT_SYSTEM_STORE_SERVICES_ID* = 5 + CERT_SYSTEM_STORE_USERS_ID* = 6 + CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID* = 7 + CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID* = 8 + CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID* = 9 + CERT_SYSTEM_STORE_CURRENT_USER* = CERT_SYSTEM_STORE_CURRENT_USER_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_LOCAL_MACHINE* = CERT_SYSTEM_STORE_LOCAL_MACHINE_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_CURRENT_SERVICE* = CERT_SYSTEM_STORE_CURRENT_SERVICE_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_SERVICES* = CERT_SYSTEM_STORE_SERVICES_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_USERS* = CERT_SYSTEM_STORE_USERS_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY* = CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY* = CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE* = CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID shl CERT_SYSTEM_STORE_LOCATION_SHIFT + CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH* = "Software\\Policies\\Microsoft\\SystemCertificates" + CERT_EFSBLOB_VALUE_NAME* = "EFSBlob" + CERT_PROT_ROOT_FLAGS_VALUE_NAME* = "Flags" + CERT_PROT_ROOT_DISABLE_CURRENT_USER_FLAG* = 0x1 + CERT_PROT_ROOT_INHIBIT_ADD_AT_INIT_FLAG* = 0x2 + CERT_PROT_ROOT_INHIBIT_PURGE_LM_FLAG* = 0x4 + CERT_PROT_ROOT_DISABLE_LM_AUTH_FLAG* = 0x8 + CERT_PROT_ROOT_ONLY_LM_GPT_FLAG* = 0x8 + CERT_PROT_ROOT_DISABLE_NT_AUTH_REQUIRED_FLAG* = 0x10 + CERT_PROT_ROOT_DISABLE_NOT_DEFINED_NAME_CONSTRAINT_FLAG* = 0x20 + CERT_PROT_ROOT_DISABLE_PEER_TRUST* = 0x10000 + CERT_PROT_ROOT_PEER_USAGES_VALUE_NAME* = "PeerUsages" + CERT_PROT_ROOT_PEER_USAGES_VALUE_NAME_A* = "PeerUsages" + CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH* = "Software\\Microsoft\\SystemCertificates" + CERT_TRUST_PUB_AUTHENTICODE_FLAGS_VALUE_NAME* = "AuthenticodeFlags" + CERT_TRUST_PUB_ALLOW_TRUST_MASK* = 0x3 + CERT_TRUST_PUB_ALLOW_END_USER_TRUST* = 0x0 + CERT_TRUST_PUB_ALLOW_MACHINE_ADMIN_TRUST* = 0x1 + CERT_TRUST_PUB_ALLOW_ENTERPRISE_ADMIN_TRUST* = 0x2 + CERT_TRUST_PUB_CHECK_PUBLISHER_REV_FLAG* = 0x100 + CERT_TRUST_PUB_CHECK_TIMESTAMP_REV_FLAG* = 0x200 + CERT_OCM_SUBCOMPONENTS_LOCAL_MACHINE_REGPATH* = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\Subcomponents" + CERT_OCM_SUBCOMPONENTS_ROOT_AUTO_UPDATE_VALUE_NAME* = "RootAutoUpdate" + CERT_DISABLE_ROOT_AUTO_UPDATE_VALUE_NAME* = "DisableRootAutoUpdate" + CERT_AUTO_UPDATE_ROOT_DIR_URL_VALUE_NAME* = "RootDirUrl" + CERT_AUTO_UPDATE_LOCAL_MACHINE_REGPATH* = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH & "\\AuthRoot\\AutoUpdate" + CERT_AUTH_ROOT_AUTO_UPDATE_LOCAL_MACHINE_REGPATH* = CERT_AUTO_UPDATE_LOCAL_MACHINE_REGPATH + CERT_AUTH_ROOT_AUTO_UPDATE_ROOT_DIR_URL_VALUE_NAME* = CERT_AUTO_UPDATE_ROOT_DIR_URL_VALUE_NAME + CERT_AUTH_ROOT_AUTO_UPDATE_SYNC_DELTA_TIME_VALUE_NAME* = "SyncDeltaTime" + CERT_AUTH_ROOT_AUTO_UPDATE_FLAGS_VALUE_NAME* = "Flags" + CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_UNTRUSTED_ROOT_LOGGING_FLAG* = 0x1 + CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_PARTIAL_CHAIN_LOGGING_FLAG* = 0x2 + CERT_AUTO_UPDATE_DISABLE_RANDOM_QUERY_STRING_FLAG* = 0x4 + CERT_AUTH_ROOT_AUTO_UPDATE_LAST_SYNC_TIME_VALUE_NAME* = "LastSyncTime" + CERT_AUTH_ROOT_AUTO_UPDATE_ENCODED_CTL_VALUE_NAME* = "EncodedCtl" + CERT_AUTH_ROOT_CTL_FILENAME* = "authroot.stl" + CERT_AUTH_ROOT_CTL_FILENAME_A* = "authroot.stl" + CERT_AUTH_ROOT_CAB_FILENAME* = "authrootstl.cab" + CERT_AUTH_ROOT_SEQ_FILENAME* = "authrootseq.txt" + CERT_AUTH_ROOT_CERT_EXT* = ".crt" + CERT_DISALLOWED_CERT_AUTO_UPDATE_SYNC_DELTA_TIME_VALUE_NAME* = "DisallowedCertSyncDeltaTime" + CERT_DISALLOWED_CERT_AUTO_UPDATE_LAST_SYNC_TIME_VALUE_NAME* = "DisallowedCertLastSyncTime" + CERT_DISALLOWED_CERT_AUTO_UPDATE_ENCODED_CTL_VALUE_NAME* = "DisallowedCertEncodedCtl" + CERT_DISALLOWED_CERT_CTL_FILENAME* = "disallowedcert.stl" + CERT_DISALLOWED_CERT_CTL_FILENAME_A* = "disallowedcert.stl" + CERT_DISALLOWED_CERT_CAB_FILENAME* = "disallowedcertstl.cab" + CERT_DISALLOWED_CERT_AUTO_UPDATE_LIST_IDENTIFIER* = "DisallowedCert_AutoUpdate_1" + CERT_REGISTRY_STORE_REMOTE_FLAG* = 0x10000 + CERT_REGISTRY_STORE_SERIALIZED_FLAG* = 0x20000 + CERT_REGISTRY_STORE_CLIENT_GPT_FLAG* = 0x80000000'i32 + CERT_REGISTRY_STORE_LM_GPT_FLAG* = 0x1000000 + CERT_REGISTRY_STORE_ROAMING_FLAG* = 0x40000 + CERT_REGISTRY_STORE_MY_IE_DIRTY_FLAG* = 0x80000 + CERT_REGISTRY_STORE_EXTERNAL_FLAG* = 0x100000 + CERT_IE_DIRTY_FLAGS_REGPATH* = "Software\\Microsoft\\Cryptography\\IEDirtyFlags" + CERT_FILE_STORE_COMMIT_ENABLE_FLAG* = 0x10000 + CERT_LDAP_STORE_SIGN_FLAG* = 0x10000 + CERT_LDAP_STORE_AREC_EXCLUSIVE_FLAG* = 0x20000 + CERT_LDAP_STORE_OPENED_FLAG* = 0x40000 + CERT_LDAP_STORE_UNBIND_FLAG* = 0x80000 + CRYPT_OID_OPEN_STORE_PROV_FUNC* = "CertDllOpenStoreProv" + CERT_STORE_PROV_EXTERNAL_FLAG* = 0x1 + CERT_STORE_PROV_DELETED_FLAG* = 0x2 + CERT_STORE_PROV_NO_PERSIST_FLAG* = 0x4 + CERT_STORE_PROV_SYSTEM_STORE_FLAG* = 0x8 + CERT_STORE_PROV_LM_SYSTEM_STORE_FLAG* = 0x10 + CERT_STORE_PROV_GP_SYSTEM_STORE_FLAG* = 0x20 + CERT_STORE_PROV_SHARED_USER_FLAG* = 0x40 + CERT_STORE_PROV_CLOSE_FUNC* = 0 + CERT_STORE_PROV_READ_CERT_FUNC* = 1 + CERT_STORE_PROV_WRITE_CERT_FUNC* = 2 + CERT_STORE_PROV_DELETE_CERT_FUNC* = 3 + CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC* = 4 + CERT_STORE_PROV_READ_CRL_FUNC* = 5 + CERT_STORE_PROV_WRITE_CRL_FUNC* = 6 + CERT_STORE_PROV_DELETE_CRL_FUNC* = 7 + CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC* = 8 + CERT_STORE_PROV_READ_CTL_FUNC* = 9 + CERT_STORE_PROV_WRITE_CTL_FUNC* = 10 + CERT_STORE_PROV_DELETE_CTL_FUNC* = 11 + CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC* = 12 + CERT_STORE_PROV_CONTROL_FUNC* = 13 + CERT_STORE_PROV_FIND_CERT_FUNC* = 14 + CERT_STORE_PROV_FREE_FIND_CERT_FUNC* = 15 + CERT_STORE_PROV_GET_CERT_PROPERTY_FUNC* = 16 + CERT_STORE_PROV_FIND_CRL_FUNC* = 17 + CERT_STORE_PROV_FREE_FIND_CRL_FUNC* = 18 + CERT_STORE_PROV_GET_CRL_PROPERTY_FUNC* = 19 + CERT_STORE_PROV_FIND_CTL_FUNC* = 20 + CERT_STORE_PROV_FREE_FIND_CTL_FUNC* = 21 + CERT_STORE_PROV_GET_CTL_PROPERTY_FUNC* = 22 + CERT_STORE_PROV_WRITE_ADD_FLAG* = 0x1 + CERT_STORE_SAVE_AS_STORE* = 1 + CERT_STORE_SAVE_AS_PKCS7* = 2 + CERT_STORE_SAVE_AS_PKCS12* = 3 + CERT_STORE_SAVE_TO_FILE* = 1 + CERT_STORE_SAVE_TO_MEMORY* = 2 + CERT_STORE_SAVE_TO_FILENAME_A* = 3 + CERT_STORE_SAVE_TO_FILENAME_W* = 4 + CERT_STORE_SAVE_TO_FILENAME* = CERT_STORE_SAVE_TO_FILENAME_W + CERT_CLOSE_STORE_FORCE_FLAG* = 0x1 + CERT_CLOSE_STORE_CHECK_FLAG* = 0x2 + CERT_COMPARE_MASK* = 0xffff + CERT_COMPARE_SHIFT* = 16 + CERT_COMPARE_ANY* = 0 + CERT_COMPARE_SHA1_HASH* = 1 + CERT_COMPARE_NAME* = 2 + CERT_COMPARE_ATTR* = 3 + CERT_COMPARE_MD5_HASH* = 4 + CERT_COMPARE_PROPERTY* = 5 + CERT_COMPARE_PUBLIC_KEY* = 6 + CERT_COMPARE_HASH* = CERT_COMPARE_SHA1_HASH + CERT_COMPARE_NAME_STR_A* = 7 + CERT_COMPARE_NAME_STR_W* = 8 + CERT_COMPARE_KEY_SPEC* = 9 + CERT_COMPARE_ENHKEY_USAGE* = 10 + CERT_COMPARE_CTL_USAGE* = CERT_COMPARE_ENHKEY_USAGE + CERT_COMPARE_SUBJECT_CERT* = 11 + CERT_COMPARE_ISSUER_OF* = 12 + CERT_COMPARE_EXISTING* = 13 + CERT_COMPARE_SIGNATURE_HASH* = 14 + CERT_COMPARE_KEY_IDENTIFIER* = 15 + CERT_COMPARE_CERT_ID* = 16 + CERT_COMPARE_CROSS_CERT_DIST_POINTS* = 17 + CERT_COMPARE_PUBKEY_MD5_HASH* = 18 + CERT_COMPARE_SUBJECT_INFO_ACCESS* = 19 + CERT_COMPARE_HASH_STR* = 20 + CERT_COMPARE_HAS_PRIVATE_KEY* = 21 + CERT_FIND_ANY* = CERT_COMPARE_ANY shl CERT_COMPARE_SHIFT + CERT_FIND_SHA1_HASH* = CERT_COMPARE_SHA1_HASH shl CERT_COMPARE_SHIFT + CERT_FIND_MD5_HASH* = CERT_COMPARE_MD5_HASH shl CERT_COMPARE_SHIFT + CERT_FIND_SIGNATURE_HASH* = CERT_COMPARE_SIGNATURE_HASH shl CERT_COMPARE_SHIFT + CERT_FIND_KEY_IDENTIFIER* = CERT_COMPARE_KEY_IDENTIFIER shl CERT_COMPARE_SHIFT + CERT_FIND_HASH* = CERT_FIND_SHA1_HASH + CERT_FIND_PROPERTY* = CERT_COMPARE_PROPERTY shl CERT_COMPARE_SHIFT + CERT_FIND_PUBLIC_KEY* = CERT_COMPARE_PUBLIC_KEY shl CERT_COMPARE_SHIFT + CERT_FIND_SUBJECT_NAME* = CERT_COMPARE_NAME shl CERT_COMPARE_SHIFT or CERT_INFO_SUBJECT_FLAG + CERT_FIND_SUBJECT_ATTR* = CERT_COMPARE_ATTR shl CERT_COMPARE_SHIFT or CERT_INFO_SUBJECT_FLAG + CERT_FIND_ISSUER_NAME* = CERT_COMPARE_NAME shl CERT_COMPARE_SHIFT or CERT_INFO_ISSUER_FLAG + CERT_FIND_ISSUER_ATTR* = CERT_COMPARE_ATTR shl CERT_COMPARE_SHIFT or CERT_INFO_ISSUER_FLAG + CERT_FIND_SUBJECT_STR_A* = CERT_COMPARE_NAME_STR_A shl CERT_COMPARE_SHIFT or CERT_INFO_SUBJECT_FLAG + CERT_FIND_SUBJECT_STR_W* = CERT_COMPARE_NAME_STR_W shl CERT_COMPARE_SHIFT or CERT_INFO_SUBJECT_FLAG + CERT_FIND_SUBJECT_STR* = CERT_FIND_SUBJECT_STR_W + CERT_FIND_ISSUER_STR_A* = CERT_COMPARE_NAME_STR_A shl CERT_COMPARE_SHIFT or CERT_INFO_ISSUER_FLAG + CERT_FIND_ISSUER_STR_W* = CERT_COMPARE_NAME_STR_W shl CERT_COMPARE_SHIFT or CERT_INFO_ISSUER_FLAG + CERT_FIND_ISSUER_STR* = CERT_FIND_ISSUER_STR_W + CERT_FIND_KEY_SPEC* = CERT_COMPARE_KEY_SPEC shl CERT_COMPARE_SHIFT + CERT_FIND_ENHKEY_USAGE* = CERT_COMPARE_ENHKEY_USAGE shl CERT_COMPARE_SHIFT + CERT_FIND_CTL_USAGE* = CERT_FIND_ENHKEY_USAGE + CERT_FIND_SUBJECT_CERT* = CERT_COMPARE_SUBJECT_CERT shl CERT_COMPARE_SHIFT + CERT_FIND_ISSUER_OF* = CERT_COMPARE_ISSUER_OF shl CERT_COMPARE_SHIFT + CERT_FIND_EXISTING* = CERT_COMPARE_EXISTING shl CERT_COMPARE_SHIFT + CERT_FIND_CERT_ID* = CERT_COMPARE_CERT_ID shl CERT_COMPARE_SHIFT + CERT_FIND_CROSS_CERT_DIST_POINTS* = CERT_COMPARE_CROSS_CERT_DIST_POINTS shl CERT_COMPARE_SHIFT + CERT_FIND_PUBKEY_MD5_HASH* = CERT_COMPARE_PUBKEY_MD5_HASH shl CERT_COMPARE_SHIFT + CERT_FIND_SUBJECT_INFO_ACCESS* = CERT_COMPARE_SUBJECT_INFO_ACCESS shl CERT_COMPARE_SHIFT + CERT_FIND_HASH_STR* = CERT_COMPARE_HASH_STR shl CERT_COMPARE_SHIFT + CERT_FIND_HAS_PRIVATE_KEY* = CERT_COMPARE_HAS_PRIVATE_KEY shl CERT_COMPARE_SHIFT + CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG* = 0x1 + CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG* = 0x2 + CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG* = 0x4 + CERT_FIND_NO_ENHKEY_USAGE_FLAG* = 0x8 + CERT_FIND_OR_ENHKEY_USAGE_FLAG* = 0x10 + CERT_FIND_VALID_ENHKEY_USAGE_FLAG* = 0x20 + CERT_FIND_OPTIONAL_CTL_USAGE_FLAG* = CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG + CERT_FIND_EXT_ONLY_CTL_USAGE_FLAG* = CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG + CERT_FIND_PROP_ONLY_CTL_USAGE_FLAG* = CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG + CERT_FIND_NO_CTL_USAGE_FLAG* = CERT_FIND_NO_ENHKEY_USAGE_FLAG + CERT_FIND_OR_CTL_USAGE_FLAG* = CERT_FIND_OR_ENHKEY_USAGE_FLAG + CERT_FIND_VALID_CTL_USAGE_FLAG* = CERT_FIND_VALID_ENHKEY_USAGE_FLAG + CERT_SET_PROPERTY_INHIBIT_PERSIST_FLAG* = 0x40000000 + CERT_SET_PROPERTY_IGNORE_PERSIST_ERROR_FLAG* = 0x80000000'i32 + CTL_ENTRY_FROM_PROP_CHAIN_FLAG* = 0x1 + CRL_FIND_ANY* = 0 + CRL_FIND_ISSUED_BY* = 1 + CRL_FIND_EXISTING* = 2 + CRL_FIND_ISSUED_FOR* = 3 + CRL_FIND_ISSUED_BY_AKI_FLAG* = 0x1 + CRL_FIND_ISSUED_BY_SIGNATURE_FLAG* = 0x2 + CRL_FIND_ISSUED_BY_DELTA_FLAG* = 0x4 + CRL_FIND_ISSUED_BY_BASE_FLAG* = 0x8 + CRL_FIND_ISSUED_FOR_SET_STRONG_PROPERTIES_FLAG* = 0x10 + CERT_STORE_ADD_NEW* = 1 + CERT_STORE_ADD_USE_EXISTING* = 2 + CERT_STORE_ADD_REPLACE_EXISTING* = 3 + CERT_STORE_ADD_ALWAYS* = 4 + CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES* = 5 + CERT_STORE_ADD_NEWER* = 6 + CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES* = 7 + CERT_STORE_CERTIFICATE_CONTEXT* = 1 + CERT_STORE_CRL_CONTEXT* = 2 + CERT_STORE_CTL_CONTEXT* = 3 + CERT_STORE_ALL_CONTEXT_FLAG* = not 0 + CERT_STORE_CERTIFICATE_CONTEXT_FLAG* = 1 shl CERT_STORE_CERTIFICATE_CONTEXT + CERT_STORE_CRL_CONTEXT_FLAG* = 1 shl CERT_STORE_CRL_CONTEXT + CERT_STORE_CTL_CONTEXT_FLAG* = 1 shl CERT_STORE_CTL_CONTEXT + CTL_ANY_SUBJECT_TYPE* = 1 + CTL_CERT_SUBJECT_TYPE* = 2 + CTL_FIND_ANY* = 0 + CTL_FIND_SHA1_HASH* = 1 + CTL_FIND_MD5_HASH* = 2 + CTL_FIND_USAGE* = 3 + CTL_FIND_SUBJECT* = 4 + CTL_FIND_EXISTING* = 5 + CTL_FIND_SAME_USAGE_FLAG* = 0x1 + CTL_FIND_NO_LIST_ID_CBDATA* = 0xffffffff'i32 + CERT_STORE_CTRL_RESYNC* = 1 + CERT_STORE_CTRL_NOTIFY_CHANGE* = 2 + CERT_STORE_CTRL_COMMIT* = 3 + CERT_STORE_CTRL_AUTO_RESYNC* = 4 + CERT_STORE_CTRL_CANCEL_NOTIFY* = 5 + CERT_STORE_CTRL_INHIBIT_DUPLICATE_HANDLE_FLAG* = 0x1 + CERT_STORE_CTRL_COMMIT_FORCE_FLAG* = 0x1 + CERT_STORE_CTRL_COMMIT_CLEAR_FLAG* = 0x2 + CERT_STORE_LOCALIZED_NAME_PROP_ID* = 0x1000 + CERT_CREATE_CONTEXT_NOCOPY_FLAG* = 0x1 + CERT_CREATE_CONTEXT_SORTED_FLAG* = 0x2 + CERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAG* = 0x4 + CERT_CREATE_CONTEXT_NO_ENTRY_FLAG* = 0x8 + CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG* = 0x1 + CERT_PHYSICAL_STORE_OPEN_DISABLE_FLAG* = 0x2 + CERT_PHYSICAL_STORE_REMOTE_OPEN_DISABLE_FLAG* = 0x4 + CERT_PHYSICAL_STORE_INSERT_COMPUTER_NAME_ENABLE_FLAG* = 0x8 + CERT_PHYSICAL_STORE_PREDEFINED_ENUM_FLAG* = 0x1 + CERT_PHYSICAL_STORE_DEFAULT_NAME* = ".Default" + CERT_PHYSICAL_STORE_GROUP_POLICY_NAME* = ".GroupPolicy" + CERT_PHYSICAL_STORE_LOCAL_MACHINE_NAME* = ".LocalMachine" + CERT_PHYSICAL_STORE_DS_USER_CERTIFICATE_NAME* = ".UserCertificate" + CERT_PHYSICAL_STORE_LOCAL_MACHINE_GROUP_POLICY_NAME* = ".LocalMachineGroupPolicy" + CERT_PHYSICAL_STORE_ENTERPRISE_NAME* = ".Enterprise" + CERT_PHYSICAL_STORE_AUTH_ROOT_NAME* = ".AuthRoot" + CERT_PHYSICAL_STORE_SMART_CARD_NAME* = ".SmartCard" + CRYPT_OID_OPEN_SYSTEM_STORE_PROV_FUNC* = "CertDllOpenSystemStoreProv" + CRYPT_OID_REGISTER_SYSTEM_STORE_FUNC* = "CertDllRegisterSystemStore" + CRYPT_OID_UNREGISTER_SYSTEM_STORE_FUNC* = "CertDllUnregisterSystemStore" + CRYPT_OID_ENUM_SYSTEM_STORE_FUNC* = "CertDllEnumSystemStore" + CRYPT_OID_REGISTER_PHYSICAL_STORE_FUNC* = "CertDllRegisterPhysicalStore" + CRYPT_OID_UNREGISTER_PHYSICAL_STORE_FUNC* = "CertDllUnregisterPhysicalStore" + CRYPT_OID_ENUM_PHYSICAL_STORE_FUNC* = "CertDllEnumPhysicalStore" + CRYPT_OID_SYSTEM_STORE_LOCATION_VALUE_NAME* = "SystemStoreLocation" + CMSG_TRUSTED_SIGNER_FLAG* = 0x1 + CMSG_SIGNER_ONLY_FLAG* = 0x2 + CMSG_USE_SIGNER_INDEX_FLAG* = 0x4 + CMSG_CMS_ENCAPSULATED_CTL_FLAG* = 0x8000 + CMSG_ENCODE_SORTED_CTL_FLAG* = 0x1 + CMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG* = 0x2 + CERT_VERIFY_INHIBIT_CTL_UPDATE_FLAG* = 0x1 + CERT_VERIFY_TRUSTED_SIGNERS_FLAG* = 0x2 + CERT_VERIFY_NO_TIME_CHECK_FLAG* = 0x4 + CERT_VERIFY_ALLOW_MORE_USAGE_FLAG* = 0x8 + CERT_VERIFY_UPDATED_CTL_FLAG* = 0x1 + CERT_CONTEXT_REVOCATION_TYPE* = 1 + CERT_VERIFY_REV_CHAIN_FLAG* = 0x1 + CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION* = 0x2 + CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG* = 0x4 + CERT_VERIFY_REV_SERVER_OCSP_FLAG* = 0x8 + CERT_VERIFY_REV_NO_OCSP_FAILOVER_TO_CRL_FLAG* = 0x10 + CERT_UNICODE_IS_RDN_ATTRS_FLAG* = 0x1 + CERT_CASE_INSENSITIVE_IS_RDN_ATTRS_FLAG* = 0x2 + CRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOB* = 1 + CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT* = 2 + CRYPT_VERIFY_CERT_SIGN_SUBJECT_CRL* = 3 + CRYPT_VERIFY_CERT_SIGN_SUBJECT_OCSP_BASIC_SIGNED_RESPONSE* = 4 + CRYPT_VERIFY_CERT_SIGN_ISSUER_PUBKEY* = 1 + CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT* = 2 + CRYPT_VERIFY_CERT_SIGN_ISSUER_CHAIN* = 3 + CRYPT_VERIFY_CERT_SIGN_ISSUER_NULL* = 4 + CRYPT_VERIFY_CERT_SIGN_DISABLE_MD2_MD4_FLAG* = 0x1 + CRYPT_VERIFY_CERT_SIGN_SET_STRONG_PROPERTIES_FLAG* = 0x2 + CRYPT_VERIFY_CERT_SIGN_RETURN_STRONG_PROPERTIES_FLAG* = 0x4 + CRYPT_OID_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC* = "CryptDllExtractEncodedSignatureParameters" + CRYPT_OID_SIGN_AND_ENCODE_HASH_FUNC* = "CryptDllSignAndEncodeHash" + CRYPT_OID_VERIFY_ENCODED_SIGNATURE_FUNC* = "CryptDllVerifyEncodedSignature" + CRYPT_DEFAULT_CONTEXT_AUTO_RELEASE_FLAG* = 0x1 + CRYPT_DEFAULT_CONTEXT_PROCESS_FLAG* = 0x2 + CRYPT_DEFAULT_CONTEXT_CERT_SIGN_OID* = 1 + CRYPT_DEFAULT_CONTEXT_MULTI_CERT_SIGN_OID* = 2 + CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC* = "CryptDllExportPublicKeyInfoEx" + CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC* = "CryptDllExportPublicKeyInfoEx2" + CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC* = "CryptDllExportPublicKeyInfoFromBCryptKeyHandle" + CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC* = "CryptDllImportPublicKeyInfoEx" + CRYPT_OID_IMPORT_PRIVATE_KEY_INFO_FUNC* = "CryptDllImportPrivateKeyInfoEx" + CRYPT_OID_EXPORT_PRIVATE_KEY_INFO_FUNC* = "CryptDllExportPrivateKeyInfoEx" + CRYPT_ACQUIRE_CACHE_FLAG* = 0x1 + CRYPT_ACQUIRE_USE_PROV_INFO_FLAG* = 0x2 + CRYPT_ACQUIRE_COMPARE_KEY_FLAG* = 0x4 + CRYPT_ACQUIRE_NO_HEALING* = 0x8 + CRYPT_ACQUIRE_SILENT_FLAG* = 0x40 + CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG* = 0x80 + CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK* = 0x70000 + CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG* = 0x10000 + CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG* = 0x20000 + CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG* = 0x40000 + CRYPT_FIND_USER_KEYSET_FLAG* = 0x1 + CRYPT_FIND_MACHINE_KEYSET_FLAG* = 0x2 + CRYPT_FIND_SILENT_KEYSET_FLAG* = 0x40 + CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC* = "CryptDllImportPublicKeyInfoEx2" + CERT_SIMPLE_NAME_STR* = 1 + CERT_OID_NAME_STR* = 2 + CERT_X500_NAME_STR* = 3 + CERT_XML_NAME_STR* = 4 + CERT_NAME_STR_DISABLE_IE4_UTF8_FLAG* = 0x10000 + CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG* = 0x20000 + CERT_NAME_STR_ENABLE_UTF8_UNICODE_FLAG* = 0x40000 + CERT_NAME_STR_FORCE_UTF8_DIR_STR_FLAG* = 0x80000 + CERT_NAME_STR_FORWARD_FLAG* = 0x1000000 + CERT_NAME_STR_REVERSE_FLAG* = 0x2000000 + CERT_NAME_STR_COMMA_FLAG* = 0x4000000 + CERT_NAME_STR_CRLF_FLAG* = 0x8000000 + CERT_NAME_STR_NO_QUOTING_FLAG* = 0x10000000 + CERT_NAME_STR_NO_PLUS_FLAG* = 0x20000000 + CERT_NAME_STR_SEMICOLON_FLAG* = 0x40000000 + CERT_NAME_STR_DISABLE_UTF8_DIR_STR_FLAG* = 0x100000 + CERT_NAME_STR_ENABLE_PUNYCODE_FLAG* = 0x200000 + CERT_NAME_EMAIL_TYPE* = 1 + CERT_NAME_RDN_TYPE* = 2 + CERT_NAME_ATTR_TYPE* = 3 + CERT_NAME_SIMPLE_DISPLAY_TYPE* = 4 + CERT_NAME_FRIENDLY_DISPLAY_TYPE* = 5 + CERT_NAME_DNS_TYPE* = 6 + CERT_NAME_URL_TYPE* = 7 + CERT_NAME_UPN_TYPE* = 8 + CERT_NAME_ISSUER_FLAG* = 0x1 + CERT_NAME_DISABLE_IE4_UTF8_FLAG* = 0x10000 + CERT_NAME_SEARCH_ALL_NAMES_FLAG* = 0x2 + CRYPT_MESSAGE_BARE_CONTENT_OUT_FLAG* = 0x1 + CRYPT_MESSAGE_ENCAPSULATED_CONTENT_OUT_FLAG* = 0x2 + CRYPT_MESSAGE_KEYID_SIGNER_FLAG* = 0x4 + CRYPT_MESSAGE_SILENT_KEYSET_FLAG* = 0x40 + CRYPT_MESSAGE_KEYID_RECIPIENT_FLAG* = 0x4 + CERT_QUERY_OBJECT_FILE* = 0x1 + CERT_QUERY_OBJECT_BLOB* = 0x2 + CERT_QUERY_CONTENT_CERT* = 1 + CERT_QUERY_CONTENT_CTL* = 2 + CERT_QUERY_CONTENT_CRL* = 3 + CERT_QUERY_CONTENT_SERIALIZED_STORE* = 4 + CERT_QUERY_CONTENT_SERIALIZED_CERT* = 5 + CERT_QUERY_CONTENT_SERIALIZED_CTL* = 6 + CERT_QUERY_CONTENT_SERIALIZED_CRL* = 7 + CERT_QUERY_CONTENT_PKCS7_SIGNED* = 8 + CERT_QUERY_CONTENT_PKCS7_UNSIGNED* = 9 + CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED* = 10 + CERT_QUERY_CONTENT_PKCS10* = 11 + CERT_QUERY_CONTENT_PFX* = 12 + CERT_QUERY_CONTENT_CERT_PAIR* = 13 + CERT_QUERY_CONTENT_PFX_AND_LOAD* = 14 + CERT_QUERY_CONTENT_FLAG_CERT* = 1 shl CERT_QUERY_CONTENT_CERT + CERT_QUERY_CONTENT_FLAG_CTL* = 1 shl CERT_QUERY_CONTENT_CTL + CERT_QUERY_CONTENT_FLAG_CRL* = 1 shl CERT_QUERY_CONTENT_CRL + CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE* = 1 shl CERT_QUERY_CONTENT_SERIALIZED_STORE + CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT* = 1 shl CERT_QUERY_CONTENT_SERIALIZED_CERT + CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL* = 1 shl CERT_QUERY_CONTENT_SERIALIZED_CTL + CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL* = 1 shl CERT_QUERY_CONTENT_SERIALIZED_CRL + CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED* = 1 shl CERT_QUERY_CONTENT_PKCS7_SIGNED + CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED* = 1 shl CERT_QUERY_CONTENT_PKCS7_UNSIGNED + CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED* = 1 shl CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED + CERT_QUERY_CONTENT_FLAG_PKCS10* = 1 shl CERT_QUERY_CONTENT_PKCS10 + CERT_QUERY_CONTENT_FLAG_PFX* = 1 shl CERT_QUERY_CONTENT_PFX + CERT_QUERY_CONTENT_FLAG_CERT_PAIR* = 1 shl CERT_QUERY_CONTENT_CERT_PAIR + CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD* = 1 shl CERT_QUERY_CONTENT_PFX_AND_LOAD + CERT_QUERY_CONTENT_FLAG_ALL* = CERT_QUERY_CONTENT_FLAG_CERT or CERT_QUERY_CONTENT_FLAG_CTL or CERT_QUERY_CONTENT_FLAG_CRL or CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE or CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT or CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL or CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL or CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED or CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED or CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED or CERT_QUERY_CONTENT_FLAG_PKCS10 or CERT_QUERY_CONTENT_FLAG_PFX or CERT_QUERY_CONTENT_FLAG_CERT_PAIR + CERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERT* = CERT_QUERY_CONTENT_FLAG_CERT or CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE or CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT or CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED or CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED + CERT_QUERY_FORMAT_BINARY* = 1 + CERT_QUERY_FORMAT_BASE64_ENCODED* = 2 + CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED* = 3 + CERT_QUERY_FORMAT_FLAG_BINARY* = 1 shl CERT_QUERY_FORMAT_BINARY + CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED* = 1 shl CERT_QUERY_FORMAT_BASE64_ENCODED + CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED* = 1 shl CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED + CERT_QUERY_FORMAT_FLAG_ALL* = CERT_QUERY_FORMAT_FLAG_BINARY or CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED or CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED + CREDENTIAL_OID_PASSWORD_CREDENTIALS_A* = cast[LPCSTR](1) + CREDENTIAL_OID_PASSWORD_CREDENTIALS_W* = cast[LPCSTR](2) + SCHEME_OID_RETRIEVE_ENCODED_OBJECT_FUNC* = "SchemeDllRetrieveEncodedObject" + SCHEME_OID_RETRIEVE_ENCODED_OBJECTW_FUNC* = "SchemeDllRetrieveEncodedObjectW" + CONTEXT_OID_CREATE_OBJECT_CONTEXT_FUNC* = "ContextDllCreateObjectContext" + CONTEXT_OID_CERTIFICATE* = cast[LPCSTR](1) + CONTEXT_OID_CRL* = cast[LPCSTR](2) + CONTEXT_OID_CTL* = cast[LPCSTR](3) + CONTEXT_OID_PKCS7* = cast[LPCSTR](4) + CONTEXT_OID_CAPI2_ANY* = cast[LPCSTR](5) + CONTEXT_OID_OCSP_RESP* = cast[LPCSTR](6) + CRYPT_RETRIEVE_MULTIPLE_OBJECTS* = 0x1 + CRYPT_CACHE_ONLY_RETRIEVAL* = 0x2 + CRYPT_WIRE_ONLY_RETRIEVAL* = 0x4 + CRYPT_DONT_CACHE_RESULT* = 0x8 + CRYPT_ASYNC_RETRIEVAL* = 0x10 + CRYPT_VERIFY_CONTEXT_SIGNATURE* = 0x20 + CRYPT_VERIFY_DATA_HASH* = 0x40 + CRYPT_KEEP_TIME_VALID* = 0x80 + CRYPT_DONT_VERIFY_SIGNATURE* = 0x100 + CRYPT_DONT_CHECK_TIME_VALIDITY* = 0x200 + CRYPT_CHECK_FRESHNESS_TIME_VALIDITY* = 0x400 + CRYPT_ACCUMULATIVE_TIMEOUT* = 0x800 + CRYPT_STICKY_CACHE_RETRIEVAL* = 0x1000 + CRYPT_LDAP_SCOPE_BASE_ONLY_RETRIEVAL* = 0x2000 + CRYPT_OFFLINE_CHECK_RETRIEVAL* = 0x4000 + CRYPT_LDAP_INSERT_ENTRY_ATTRIBUTE* = 0x8000 + CRYPT_LDAP_SIGN_RETRIEVAL* = 0x10000 + CRYPT_NO_AUTH_RETRIEVAL* = 0x20000 + CRYPT_LDAP_AREC_EXCLUSIVE_RETRIEVAL* = 0x40000 + CRYPT_AIA_RETRIEVAL* = 0x80000 + CRYPT_HTTP_POST_RETRIEVAL* = 0x100000 + CRYPT_PROXY_CACHE_RETRIEVAL* = 0x200000 + CRYPT_NOT_MODIFIED_RETRIEVAL* = 0x400000 + CRYPT_ENABLE_SSL_REVOCATION_RETRIEVAL* = 0x800000 + CRYPT_OCSP_ONLY_RETRIEVAL* = 0x1000000 + CRYPT_NO_OCSP_FAILOVER_TO_CRL_RETRIEVAL* = 0x2000000 + CRYPT_RANDOM_QUERY_STRING_RETRIEVAL* = 0x4000000 + CRYPTNET_URL_CACHE_PRE_FETCH_NONE* = 0 + CRYPTNET_URL_CACHE_PRE_FETCH_BLOB* = 1 + CRYPTNET_URL_CACHE_PRE_FETCH_CRL* = 2 + CRYPTNET_URL_CACHE_PRE_FETCH_OCSP* = 3 + CRYPTNET_URL_CACHE_PRE_FETCH_AUTOROOT_CAB* = 5 + CRYPTNET_URL_CACHE_PRE_FETCH_DISALLOWED_CERT_CAB* = 6 + CRYPTNET_URL_CACHE_DEFAULT_FLUSH* = 0 + CRYPTNET_URL_CACHE_DISABLE_FLUSH* = 0xffffffff'i32 + CRYPTNET_URL_CACHE_RESPONSE_NONE* = 0 + CRYPTNET_URL_CACHE_RESPONSE_HTTP* = 1 + CRYPTNET_URL_CACHE_RESPONSE_VALIDATED* = 0x8000 + CRYPT_PARAM_ASYNC_RETRIEVAL_COMPLETION* = cast[LPCSTR](1) + CRYPT_PARAM_CANCEL_ASYNC_RETRIEVAL* = cast[LPCSTR](2) + CRYPT_GET_URL_FROM_PROPERTY* = 0x1 + CRYPT_GET_URL_FROM_EXTENSION* = 0x2 + CRYPT_GET_URL_FROM_UNAUTH_ATTRIBUTE* = 0x4 + CRYPT_GET_URL_FROM_AUTH_ATTRIBUTE* = 0x8 + URL_OID_GET_OBJECT_URL_FUNC* = "UrlDllGetObjectUrl" + URL_OID_CERTIFICATE_ISSUER* = cast[LPCSTR](1) + URL_OID_CERTIFICATE_CRL_DIST_POINT* = cast[LPCSTR](2) + URL_OID_CTL_ISSUER* = cast[LPCSTR](3) + URL_OID_CTL_NEXT_UPDATE* = cast[LPCSTR](4) + URL_OID_CRL_ISSUER* = cast[LPCSTR](5) + URL_OID_CERTIFICATE_FRESHEST_CRL* = cast[LPCSTR](6) + URL_OID_CRL_FRESHEST_CRL* = cast[LPCSTR](7) + URL_OID_CROSS_CERT_DIST_POINT* = cast[LPCSTR](8) + URL_OID_CERTIFICATE_OCSP* = cast[LPCSTR](9) + URL_OID_CERTIFICATE_OCSP_AND_CRL_DIST_POINT* = cast[LPCSTR](10) + URL_OID_CERTIFICATE_CRL_DIST_POINT_AND_OCSP* = cast[LPCSTR](11) + URL_OID_CROSS_CERT_SUBJECT_INFO_ACCESS* = cast[LPCSTR](12) + URL_OID_CERTIFICATE_ONLY_OCSP* = cast[LPCSTR](13) + TIME_VALID_OID_GET_OBJECT_FUNC* = "TimeValidDllGetObject" + CERT_CHAIN_CONFIG_REGPATH* = "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CertDllCreateCertificateChainEngine\\Config" + TIME_VALID_OID_GET_CTL* = cast[LPCSTR](1) + TIME_VALID_OID_GET_CRL* = cast[LPCSTR](2) + TIME_VALID_OID_GET_CRL_FROM_CERT* = cast[LPCSTR](3) + TIME_VALID_OID_GET_FRESHEST_CRL_FROM_CERT* = cast[LPCSTR](4) + TIME_VALID_OID_GET_FRESHEST_CRL_FROM_CRL* = cast[LPCSTR](5) + TIME_VALID_OID_FLUSH_OBJECT_FUNC* = "TimeValidDllFlushObject" + TIME_VALID_OID_FLUSH_CTL* = cast[LPCSTR](1) + TIME_VALID_OID_FLUSH_CRL* = cast[LPCSTR](2) + TIME_VALID_OID_FLUSH_CRL_FROM_CERT* = cast[LPCSTR](3) + TIME_VALID_OID_FLUSH_FRESHEST_CRL_FROM_CERT* = cast[LPCSTR](4) + TIME_VALID_OID_FLUSH_FRESHEST_CRL_FROM_CRL* = cast[LPCSTR](5) + CERT_CREATE_SELFSIGN_NO_SIGN* = 1 + CERT_CREATE_SELFSIGN_NO_KEY_INFO* = 2 + CRYPT_KEYID_DELETE_FLAG* = 0x10 + CRYPT_KEYID_MACHINE_FLAG* = 0x20 + CRYPT_KEYID_SET_NEW_FLAG* = 0x2000 + CRYPT_KEYID_ALLOC_FLAG* = 0x8000 + CERT_CHAIN_MAX_URL_RETRIEVAL_BYTE_COUNT_VALUE_NAME* = "MaxUrlRetrievalByteCount" + CERT_CHAIN_MAX_URL_RETRIEVAL_BYTE_COUNT_DEFAULT* = 100*1024*1024 + CERT_CHAIN_CACHE_RESYNC_FILETIME_VALUE_NAME* = "ChainCacheResyncFiletime" + CERT_CHAIN_DISABLE_MANDATORY_BASIC_CONSTRAINTS_VALUE_NAME* = "DisableMandatoryBasicConstraints" + CERT_CHAIN_DISABLE_CA_NAME_CONSTRAINTS_VALUE_NAME* = "DisableCANameConstraints" + CERT_CHAIN_DISABLE_UNSUPPORTED_CRITICAL_EXTENSIONS_VALUE_NAME* = "DisableUnsupportedCriticalExtensions" + CERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_VALUE_NAME* = "MaxAIAUrlCountInCert" + CERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_DEFAULT* = 5 + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_VALUE_NAME* = "MaxAIAUrlRetrievalCountPerChain" + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_DEFAULT* = 3 + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_VALUE_NAME* = "MaxAIAUrlRetrievalByteCount" + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_DEFAULT* = 100000 + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_VALUE_NAME* = "MaxAIAUrlRetrievalCertCount" + CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_DEFAULT* = 10 + CERT_CHAIN_OCSP_VALIDITY_SECONDS_VALUE_NAME* = "OcspValiditySeconds" + CERT_CHAIN_OCSP_VALIDITY_SECONDS_DEFAULT* = 12*60*60 + CERT_CHAIN_ENABLE_WEAK_SIGNATURE_FLAGS_VALUE_NAME* = "EnableWeakSignatureFlags" + CERT_CHAIN_ENABLE_MD2_MD4_FLAG* = 0x1 + CERT_CHAIN_ENABLE_WEAK_RSA_ROOT_FLAG* = 0x2 + CERT_CHAIN_ENABLE_WEAK_LOGGING_FLAG* = 0x4 + CERT_CHAIN_ENABLE_ONLY_WEAK_LOGGING_FLAG* = 0x8 + CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_VALUE_NAME* = "MinRsaPubKeyBitLength" + CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DEFAULT* = 1023 + CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DISABLE* = 0xffffffff'i32 + CERT_CHAIN_WEAK_RSA_PUB_KEY_TIME_VALUE_NAME* = "WeakRsaPubKeyTime" + CERT_CHAIN_WEAK_RSA_PUB_KEY_TIME_DEFAULT* = 0x01ca8a755c6e0000 + CERT_CHAIN_WEAK_SIGNATURE_LOG_DIR_VALUE_NAME* = "WeakSignatureLogDir" + CERT_SRV_OCSP_RESP_MIN_VALIDITY_SECONDS_VALUE_NAME* = "SrvOcspRespMinValiditySeconds" + CERT_SRV_OCSP_RESP_MIN_VALIDITY_SECONDS_DEFAULT* = 10*60 + CERT_SRV_OCSP_RESP_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAME* = "SrvOcspRespUrlRetrievalTimeoutMilliseconds" + CERT_SRV_OCSP_RESP_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULT* = 15*1000 + CERT_SRV_OCSP_RESP_MAX_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAME* = "SrvOcspRespMaxBeforeNextUpdateSeconds" + CERT_SRV_OCSP_RESP_MAX_BEFORE_NEXT_UPDATE_SECONDS_DEFAULT* = 4*60*60 + CERT_SRV_OCSP_RESP_MIN_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAME* = "SrvOcspRespMinBeforeNextUpdateSeconds" + CERT_SRV_OCSP_RESP_MIN_BEFORE_NEXT_UPDATE_SECONDS_DEFAULT* = 2*60 + CERT_SRV_OCSP_RESP_MIN_AFTER_NEXT_UPDATE_SECONDS_VALUE_NAME* = "SrvOcspRespMinAfterNextUpdateSeconds" + CERT_SRV_OCSP_RESP_MIN_AFTER_NEXT_UPDATE_SECONDS_DEFAULT* = 1*60 + CRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_VALUE_NAME* = "CryptnetMaxCachedOcspPerCrlCount" + CRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_DEFAULT* = 500 + CRYPTNET_OCSP_AFTER_CRL_DISABLE* = 0xffffffff'i32 + CRYPTNET_URL_CACHE_DEFAULT_FLUSH_EXEMPT_SECONDS_VALUE_NAME* = "CryptnetDefaultFlushExemptSeconds" + CRYPTNET_URL_CACHE_DEFAULT_FLUSH_EXEMPT_SECONDS_DEFAULT* = 28*24*60*60 + CRYPTNET_PRE_FETCH_MIN_MAX_AGE_SECONDS_VALUE_NAME* = "CryptnetPreFetchMinMaxAgeSeconds" + CRYPTNET_PRE_FETCH_MIN_MAX_AGE_SECONDS_DEFAULT* = 1*60*60 + CRYPTNET_PRE_FETCH_MAX_MAX_AGE_SECONDS_VALUE_NAME* = "CryptnetPreFetchMaxMaxAgeSeconds" + CRYPTNET_PRE_FETCH_MAX_MAX_AGE_SECONDS_DEFAULT* = 14*24*60*60 + CRYPTNET_PRE_FETCH_MIN_OCSP_VALIDITY_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchMinOcspValidityPeriodSeconds" + CRYPTNET_PRE_FETCH_MIN_OCSP_VALIDITY_PERIOD_SECONDS_DEFAULT* = 14*24*60*60 + CRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_VALUE_NAME* = "CryptnetPreFetchAfterPublishPreFetchDivisor" + CRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_DEFAULT* = 10 + CRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_VALUE_NAME* = "CryptnetPreFetchBeforeNextUpdatePreFetchDivisor" + CRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT* = 20 + CRYPTNET_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchMinBeforeNextUpdatePreFetchSeconds" + CRYPTNET_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULT* = 1*60*60 + CRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_VALUE_NAME* = "CryptnetPreFetchValidityPeriodAfterNextUpdatePreFetchDivisor" + CRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT* = 10 + CRYPTNET_PRE_FETCH_MAX_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchMaxAfterNextUpdatePreFetchPeriodSeconds" + CRYPTNET_PRE_FETCH_MAX_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULT* = 4*60*60 + CRYPTNET_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchMinAfterNextUpdatePreFetchPeriodSeconds" + CRYPTNET_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULT* = 30*60 + CRYPTNET_PRE_FETCH_AFTER_CURRENT_TIME_PRE_FETCH_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchAfterCurrentTimePreFetchPeriodSeconds" + CRYPTNET_PRE_FETCH_AFTER_CURRENT_TIME_PRE_FETCH_PERIOD_SECONDS_DEFAULT* = 30*60 + CRYPTNET_PRE_FETCH_TRIGGER_PERIOD_SECONDS_VALUE_NAME* = "CryptnetPreFetchTriggerPeriodSeconds" + CRYPTNET_PRE_FETCH_TRIGGER_PERIOD_SECONDS_DEFAULT* = 10*60 + CRYPTNET_PRE_FETCH_TRIGGER_DISABLE* = 0xffffffff'i32 + CRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_VALUE_NAME* = "CryptnetPreFetchScanAfterTriggerDelaySeconds" + CRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_DEFAULT* = 30 + CRYPTNET_PRE_FETCH_RETRIEVAL_TIMEOUT_SECONDS_VALUE_NAME* = "CryptnetPreFetchRetrievalTimeoutSeconds" + CRYPTNET_PRE_FETCH_RETRIEVAL_TIMEOUT_SECONDS_DEFAULT* = 5*60 + CERT_CHAIN_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAME* = "ChainUrlRetrievalTimeoutMilliseconds" + CERT_CHAIN_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULT* = 15*1000 + CERT_CHAIN_REV_ACCUMULATIVE_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAME* = "ChainRevAccumulativeUrlRetrievalTimeoutMilliseconds" + CERT_CHAIN_REV_ACCUMULATIVE_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULT* = 20*1000 + CERT_RETR_BEHAVIOR_INET_AUTH_VALUE_NAME* = "EnableInetUnknownAuth" + CERT_RETR_BEHAVIOR_INET_STATUS_VALUE_NAME* = "EnableInetLocal" + CERT_RETR_BEHAVIOR_FILE_VALUE_NAME* = "AllowFileUrlScheme" + CERT_RETR_BEHAVIOR_LDAP_VALUE_NAME* = "DisableLDAPSignAndEncrypt" + CRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_VALUE_NAME* = "CryptnetCachedOcspSwitchToCrlCount" + CRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_DEFAULT* = 50 + CRYPTNET_CRL_BEFORE_OCSP_ENABLE* = 0xffffffff'i32 + CERT_CHAIN_DISABLE_AIA_URL_RETRIEVAL_VALUE_NAME* = "DisableAIAUrlRetrieval" + CERT_CHAIN_OPTIONS_VALUE_NAME* = "Options" + CERT_CHAIN_OPTION_DISABLE_AIA_URL_RETRIEVAL* = 0x2 + CERT_CHAIN_OPTION_ENABLE_SIA_URL_RETRIEVAL* = 0x4 + CERT_CHAIN_CROSS_CERT_DOWNLOAD_INTERVAL_HOURS_VALUE_NAME* = "CrossCertDownloadIntervalHours" + CERT_CHAIN_CROSS_CERT_DOWNLOAD_INTERVAL_HOURS_DEFAULT* = 24*7 + CERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_VALUE_NAME* = "CRLValidityExtensionPeriod" + CERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_DEFAULT* = 12 + HCCE_LOCAL_MACHINE* = HCERTCHAINENGINE 0x1 + CERT_CHAIN_CACHE_END_CERT* = 0x1 + CERT_CHAIN_THREAD_STORE_SYNC* = 0x2 + CERT_CHAIN_CACHE_ONLY_URL_RETRIEVAL* = 0x4 + CERT_CHAIN_USE_LOCAL_MACHINE_STORE* = 0x8 + CERT_CHAIN_ENABLE_CACHE_AUTO_UPDATE* = 0x10 + CERT_CHAIN_ENABLE_SHARE_STORE* = 0x20 + CERT_CHAIN_EXCLUSIVE_ENABLE_CA_FLAG* = 0x1 + CERT_TRUST_NO_ERROR* = 0x0 + CERT_TRUST_IS_NOT_TIME_VALID* = 0x1 + CERT_TRUST_IS_NOT_TIME_NESTED* = 0x2 + CERT_TRUST_IS_REVOKED* = 0x4 + CERT_TRUST_IS_NOT_SIGNATURE_VALID* = 0x8 + CERT_TRUST_IS_NOT_VALID_FOR_USAGE* = 0x10 + CERT_TRUST_IS_UNTRUSTED_ROOT* = 0x20 + CERT_TRUST_REVOCATION_STATUS_UNKNOWN* = 0x40 + CERT_TRUST_IS_CYCLIC* = 0x80 + CERT_TRUST_INVALID_EXTENSION* = 0x100 + CERT_TRUST_INVALID_POLICY_CONSTRAINTS* = 0x200 + CERT_TRUST_INVALID_BASIC_CONSTRAINTS* = 0x400 + CERT_TRUST_INVALID_NAME_CONSTRAINTS* = 0x800 + CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT* = 0x1000 + CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT* = 0x2000 + CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT* = 0x4000 + CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT* = 0x8000 + CERT_TRUST_IS_PARTIAL_CHAIN* = 0x10000 + CERT_TRUST_CTL_IS_NOT_TIME_VALID* = 0x20000 + CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID* = 0x40000 + CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE* = 0x80000 + CERT_TRUST_IS_OFFLINE_REVOCATION* = 0x1000000 + CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY* = 0x2000000 + CERT_TRUST_IS_EXPLICIT_DISTRUST* = 0x4000000 + CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT* = 0x8000000 + CERT_TRUST_HAS_WEAK_SIGNATURE* = 0x100000 + CERT_TRUST_HAS_EXACT_MATCH_ISSUER* = 0x1 + CERT_TRUST_HAS_KEY_MATCH_ISSUER* = 0x2 + CERT_TRUST_HAS_NAME_MATCH_ISSUER* = 0x4 + CERT_TRUST_IS_SELF_SIGNED* = 0x8 + CERT_TRUST_AUTO_UPDATE_CA_REVOCATION* = 0x10 + CERT_TRUST_AUTO_UPDATE_END_REVOCATION* = 0x20 + CERT_TRUST_NO_OCSP_FAILOVER_TO_CRL* = 0x40 + CERT_TRUST_HAS_PREFERRED_ISSUER* = 0x100 + CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY* = 0x200 + CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS* = 0x400 + CERT_TRUST_IS_PEER_TRUSTED* = 0x800 + CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED* = 0x1000 + CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE* = 0x2000 + CERT_TRUST_IS_CA_TRUSTED* = 0x4000 + CERT_TRUST_IS_COMPLEX_CHAIN* = 0x10000 + USAGE_MATCH_TYPE_AND* = 0x0 + USAGE_MATCH_TYPE_OR* = 0x1 + CERT_CHAIN_STRONG_SIGN_DISABLE_END_CHECK_FLAG* = 0x1 + CERT_CHAIN_DISABLE_PASS1_QUALITY_FILTERING* = 0x40 + CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS* = 0x80 + CERT_CHAIN_DISABLE_AUTH_ROOT_AUTO_UPDATE* = 0x100 + CERT_CHAIN_TIMESTAMP_TIME* = 0x200 + CERT_CHAIN_ENABLE_PEER_TRUST* = 0x400 + CERT_CHAIN_DISABLE_MY_PEER_TRUST* = 0x800 + CERT_CHAIN_DISABLE_MD2_MD4* = 0x1000 + CERT_CHAIN_REVOCATION_CHECK_END_CERT* = 0x10000000 + CERT_CHAIN_REVOCATION_CHECK_CHAIN* = 0x20000000 + CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT* = 0x40000000 + CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY* = 0x80000000'i32 + CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT* = 0x8000000 + CERT_CHAIN_REVOCATION_CHECK_OCSP_CERT* = 0x4000000 + REVOCATION_OID_CRL_REVOCATION* = cast[LPCSTR](1) + CERT_CHAIN_FIND_BY_ISSUER* = 1 + CERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAG* = 0x1 + CERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAG* = 0x2 + CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAG* = 0x4 + CERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAG* = 0x8 + CERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAG* = 0x4000 + CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAG* = 0x8000 + CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG* = 0x1 + CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG* = 0x2 + CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG* = 0x4 + CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG* = 0x8 + CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS* = CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG or CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG or CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG + CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG* = 0x10 + CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG* = 0x20 + CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG* = 0x40 + CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG* = 0x80 + CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG* = 0x100 + CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG* = 0x200 + CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG* = 0x400 + CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG* = 0x800 + CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS* = CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG or CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG or CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG or CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG + CERT_CHAIN_POLICY_IGNORE_PEER_TRUST_FLAG* = 0x1000 + CERT_CHAIN_POLICY_IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAG* = 0x2000 + CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG* = 0x4000 + CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG* = 0x8000 + CRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNC* = "CertDllVerifyCertificateChainPolicy" + CERT_CHAIN_POLICY_BASE* = cast[LPCSTR](1) + CERT_CHAIN_POLICY_AUTHENTICODE* = cast[LPCSTR](2) + CERT_CHAIN_POLICY_AUTHENTICODE_TS* = cast[LPCSTR](3) + CERT_CHAIN_POLICY_SSL* = cast[LPCSTR](4) + CERT_CHAIN_POLICY_BASIC_CONSTRAINTS* = cast[LPCSTR](5) + CERT_CHAIN_POLICY_NT_AUTH* = cast[LPCSTR](6) + CERT_CHAIN_POLICY_MICROSOFT_ROOT* = cast[LPCSTR](7) + CERT_CHAIN_POLICY_EV* = cast[LPCSTR](8) + AUTHTYPE_CLIENT* = 1 + AUTHTYPE_SERVER* = 2 + BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_CA_FLAG* = 0x80000000'i32 + BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_END_ENTITY_FLAG* = 0x40000000 + MICROSOFT_ROOT_CERT_CHAIN_POLICY_ENABLE_TEST_ROOT_FLAG* = 0x10000 + MICROSOFT_ROOT_CERT_CHAIN_POLICY_CHECK_APPLICATION_ROOT_FLAG* = 0x20000 + CRYPT_STRING_BASE64HEADER* = 0x0 + CRYPT_STRING_BASE64* = 0x1 + CRYPT_STRING_BINARY* = 0x2 + CRYPT_STRING_BASE64REQUESTHEADER* = 0x00000003 + CRYPT_STRING_HEX* = 0x4 + CRYPT_STRING_HEXASCII* = 0x00000005 + CRYPT_STRING_BASE64_ANY* = 0x00000006 + CRYPT_STRING_ANY* = 0x00000007 + CRYPT_STRING_HEX_ANY* = 0x8 + CRYPT_STRING_BASE64X509CRLHEADER* = 0x00000009 + CRYPT_STRING_HEXADDR* = 0x0000000a + CRYPT_STRING_HEXASCIIADDR* = 0x0000000b + CRYPT_STRING_HEXRAW* = 0x0000000c + CRYPT_STRING_HASHDATA* = 0x10000000 + CRYPT_STRING_STRICT* = 0x20000000 + CRYPT_STRING_NOCRLF* = 0x40000000 + CRYPT_STRING_NOCR* = 0x80000000'i32 + szOID_PKCS_12_PbeIds* = "1.2.840.113549.1.12.1" + szOID_PKCS_12_pbeWithSHA1And128BitRC4* = "1.2.840.113549.1.12.1.1" + szOID_PKCS_12_pbeWithSHA1And40BitRC4* = "1.2.840.113549.1.12.1.2" + szOID_PKCS_12_pbeWithSHA1And3KeyTripleDES* = "1.2.840.113549.1.12.1.3" + szOID_PKCS_12_pbeWithSHA1And2KeyTripleDES* = "1.2.840.113549.1.12.1.4" + szOID_PKCS_12_pbeWithSHA1And128BitRC2* = "1.2.840.113549.1.12.1.5" + szOID_PKCS_12_pbeWithSHA1And40BitRC2* = "1.2.840.113549.1.12.1.6" + PKCS12_IMPORT_SILENT* = 0x40 + CRYPT_USER_KEYSET* = 0x1000 + PKCS12_PREFER_CNG_KSP* = 0x100 + PKCS12_ALWAYS_CNG_KSP* = 0x200 + PKCS12_ALLOW_OVERWRITE_KEY* = 0x4000 + PKCS12_NO_PERSIST_KEY* = 0x8000 + PKCS12_IMPORT_RESERVED_MASK* = 0xffff0000'i32 + PKCS12_INCLUDE_EXTENDED_PROPERTIES* = 0x10 + PKCS12_OBJECT_LOCATOR_ALL_IMPORT_FLAGS* = PKCS12_ALWAYS_CNG_KSP or PKCS12_NO_PERSIST_KEY or PKCS12_IMPORT_SILENT or PKCS12_INCLUDE_EXTENDED_PROPERTIES + REPORT_NO_PRIVATE_KEY* = 0x1 + REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY* = 0x2 + EXPORT_PRIVATE_KEYS* = 0x4 + PKCS12_PROTECT_TO_DOMAIN_SIDS* = 0x20 + PKCS12_EXPORT_SILENT* = 0x40 + PKCS12_EXPORT_RESERVED_MASK* = 0xffff0000'i32 + CERT_SERVER_OCSP_RESPONSE_ASYNC_FLAG* = 0x1 + CERT_RETRIEVE_ISSUER_LOGO* = cast[LPCSTR](1) + CERT_RETRIEVE_SUBJECT_LOGO* = cast[LPCSTR](2) + CERT_RETRIEVE_COMMUNITY_LOGO* = cast[LPCSTR](3) + CERT_RETRIEVE_BIOMETRIC_PREDEFINED_BASE_TYPE* = cast[LPCSTR](1000) + CERT_SELECT_MAX_PARA* = 500 + CERT_SELECT_BY_ENHKEY_USAGE* = 1 + CERT_SELECT_BY_KEY_USAGE* = 2 + CERT_SELECT_BY_POLICY_OID* = 3 + CERT_SELECT_BY_PROV_NAME* = 4 + CERT_SELECT_BY_EXTENSION* = 5 + CERT_SELECT_BY_SUBJECT_HOST_NAME* = 6 + CERT_SELECT_BY_ISSUER_ATTR* = 7 + CERT_SELECT_BY_SUBJECT_ATTR* = 8 + CERT_SELECT_BY_ISSUER_NAME* = 9 + CERT_SELECT_BY_PUBLIC_KEY* = 10 + CERT_SELECT_BY_TLS_SIGNATURES* = 11 + CERT_SELECT_LAST* = CERT_SELECT_BY_TLS_SIGNATURES + CERT_SELECT_MAX* = CERT_SELECT_LAST*3 + CERT_SELECT_ALLOW_EXPIRED* = 0x1 + CERT_SELECT_TRUSTED_ROOT* = 0x2 + CERT_SELECT_DISALLOW_SELFSIGNED* = 0x4 + CERT_SELECT_HAS_PRIVATE_KEY* = 0x8 + CERT_SELECT_HAS_KEY_FOR_SIGNATURE* = 0x10 + CERT_SELECT_HAS_KEY_FOR_KEY_EXCHANGE* = 0x20 + CERT_SELECT_HARDWARE_ONLY* = 0x40 + CERT_SELECT_ALLOW_DUPLICATES* = 0x80 + TIMESTAMP_VERSION* = 1 + TIMESTAMP_STATUS_GRANTED* = 0 + TIMESTAMP_STATUS_GRANTED_WITH_MODS* = 1 + TIMESTAMP_STATUS_REJECTED* = 2 + TIMESTAMP_STATUS_WAITING* = 3 + TIMESTAMP_STATUS_REVOCATION_WARNING* = 4 + TIMESTAMP_STATUS_REVOKED* = 5 + TIMESTAMP_FAILURE_BAD_ALG* = 0 + TIMESTAMP_FAILURE_BAD_REQUEST* = 2 + TIMESTAMP_FAILURE_BAD_FORMAT* = 5 + TIMESTAMP_FAILURE_TIME_NOT_AVAILABLE* = 14 + TIMESTAMP_FAILURE_POLICY_NOT_SUPPORTED* = 15 + TIMESTAMP_FAILURE_EXTENSION_NOT_SUPPORTED* = 16 + TIMESTAMP_FAILURE_INFO_NOT_AVAILABLE* = 17 + TIMESTAMP_FAILURE_SYSTEM_FAILURE* = 25 + TIMESTAMP_DONT_HASH_DATA* = 0x1 + TIMESTAMP_VERIFY_CONTEXT_SIGNATURE* = 0x20 + TIMESTAMP_NO_AUTH_RETRIEVAL* = 0x20000 + CRYPT_OBJECT_LOCATOR_SPN_NAME_TYPE* = 1 + CRYPT_OBJECT_LOCATOR_LAST_RESERVED_NAME_TYPE* = 32 + CRYPT_OBJECT_LOCATOR_FIRST_RESERVED_USER_NAME_TYPE* = 33 + CRYPT_OBJECT_LOCATOR_LAST_RESERVED_USER_NAME_TYPE* = 0x0000ffff + SSL_OBJECT_LOCATOR_PFX_FUNC* = "SslObjectLocatorInitializePfx" + SSL_OBJECT_LOCATOR_ISSUER_LIST_FUNC* = "SslObjectLocatorInitializeIssuerList" + SSL_OBJECT_LOCATOR_CERT_VALIDATION_CONFIG_FUNC* = "SslObjectLocatorInitializeCertValidationConfig" + CRYPT_OBJECT_LOCATOR_RELEASE_SYSTEM_SHUTDOWN* = 1 + CRYPT_OBJECT_LOCATOR_RELEASE_SERVICE_STOP* = 2 + CRYPT_OBJECT_LOCATOR_RELEASE_PROCESS_EXIT* = 3 + CRYPT_OBJECT_LOCATOR_RELEASE_DLL_UNLOAD* = 4 + CRYPTPROTECT_DEFAULT_PROVIDER* = DEFINE_GUID("df9d8cd0-1501-11d1-8c7a-00c04fc297eb") + szFORCE_KEY_PROTECTION* = "ForceKeyProtection" + dwFORCE_KEY_PROTECTION_DISABLED* = 0x0 + dwFORCE_KEY_PROTECTION_USER_SELECT* = 0x1 + dwFORCE_KEY_PROTECTION_HIGH* = 0x2 + CRYPTPROTECT_PROMPT_ON_UNPROTECT* = 0x1 + CRYPTPROTECT_PROMPT_ON_PROTECT* = 0x2 + CRYPTPROTECT_PROMPT_RESERVED* = 0x04 + CRYPTPROTECT_PROMPT_STRONG* = 0x08 + CRYPTPROTECT_PROMPT_REQUIRE_STRONG* = 0x10 + CRYPTPROTECT_UI_FORBIDDEN* = 0x1 + CRYPTPROTECT_LOCAL_MACHINE* = 0x4 + CRYPTPROTECT_CRED_SYNC* = 0x8 + CRYPTPROTECT_AUDIT* = 0x10 + CRYPTPROTECT_NO_RECOVERY* = 0x20 + CRYPTPROTECT_VERIFY_PROTECTION* = 0x40 + CRYPTPROTECT_CRED_REGENERATE* = 0x80 + CRYPTPROTECT_FIRST_RESERVED_FLAGVAL* = 0x0fffffff + CRYPTPROTECT_LAST_RESERVED_FLAGVAL* = 0xffffffff'i32 + CRYPTPROTECTMEMORY_BLOCK_SIZE* = 16 + CRYPTPROTECTMEMORY_SAME_PROCESS* = 0x0 + CRYPTPROTECTMEMORY_CROSS_PROCESS* = 0x1 + CRYPTPROTECTMEMORY_SAME_LOGON* = 0x2 + MS_ENH_RSA_AES_PROV_XP_A* = "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)" + MS_ENH_RSA_AES_PROV_XP_W* = "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)" + BCRYPT_CIPHER_INTERFACE_VERSION_1* = [1'u16, 0] + BCRYPT_HASH_INTERFACE_VERSION_1* = [1'u16, 0] + BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE_VERSION_1* = [1'u16, 0] + BCRYPT_SECRET_AGREEMENT_INTERFACE_VERSION_1* = [1'u16, 0] + BCRYPT_SIGNATURE_INTERFACE_VERSION_1* = [1'u16, 0] + BCRYPT_RNG_INTERFACE_VERSION_1* = [1'u16, 0] + NCRYPT_KEY_STORAGE_INTERFACE_VERSION* = [1'u16, 0] + NCRYPT_KEY_STORAGE_INTERFACE_VERSION_2* = [2'u16, 0] + CTL_FIND_NO_SIGNER_PTR* = cast[PCERT_INFO](-1) + HCCE_CURRENT_USER* = HCERTCHAINENGINE(0) + CERT_EFSBLOB_REGPATH* = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH & "\\EFS" + CERT_PROT_ROOT_FLAGS_REGPATH* = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH & "\\Root\\ProtectedRoots" + CERT_PROT_ROOT_PEER_USAGES_DEFAULT_A* = szOID_PKIX_KP_CLIENT_AUTH & "\0" & szOID_PKIX_KP_EMAIL_PROTECTION & "\0" & szOID_KP_EFS & "\0" + CERT_TRUST_PUB_SAFER_GROUP_POLICY_REGPATH* = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH & "\\TrustedPublisher\\Safer" + CERT_TRUST_PUB_SAFER_LOCAL_MACHINE_REGPATH* = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH & "\\TrustedPublisher\\Safer" + CERT_DISABLE_ROOT_AUTO_UPDATE_REGPATH* = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH & "\\AuthRoot" + CERT_GROUP_POLICY_CHAIN_CONFIG_REGPATH* = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH & "\\ChainEngine\\Config" + CERT_RETRIEVE_BIOMETRIC_PICTURE_TYPE* = cast[LPCSTR](1000) + CERT_RETRIEVE_BIOMETRIC_SIGNATURE_TYPE* = cast[LPCSTR](1001) +type + PFN_NCRYPT_ALLOC* = proc (cbSize: SIZE_T): LPVOID {.stdcall.} + PFN_NCRYPT_FREE* = proc (pv: LPVOID): VOID {.stdcall.} + PFN_CRYPT_ENUM_OID_FUNC* = proc (dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, cValue: DWORD, rgdwValueType: ptr DWORD, rgpwszValueName: ptr LPCWSTR, rgpbValueData: ptr ptr BYTE, rgcbValueData: ptr DWORD, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CRYPT_ENUM_OID_INFO* = proc (pInfo: PCCRYPT_OID_INFO, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CMSG_GEN_ENCRYPT_KEY* = proc (phCryptProv: ptr HCRYPTPROV, paiEncrypt: PCRYPT_ALGORITHM_IDENTIFIER, pvEncryptAuxInfo: PVOID, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO, pfnAlloc: PFN_CMSG_ALLOC, phEncryptKey: ptr HCRYPTKEY, ppbEncryptParameters: ptr PBYTE, pcbEncryptParameters: PDWORD): WINBOOL {.stdcall.} + PFN_CMSG_EXPORT_ENCRYPT_KEY* = proc (hCryptProv: HCRYPTPROV, hEncryptKey: HCRYPTKEY, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO, pbData: PBYTE, pcbData: PDWORD): WINBOOL {.stdcall.} + PFN_CMSG_IMPORT_ENCRYPT_KEY* = proc (hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, paiEncrypt: PCRYPT_ALGORITHM_IDENTIFIER, paiPubKey: PCRYPT_ALGORITHM_IDENTIFIER, pbEncodedKey: PBYTE, cbEncodedKey: DWORD, phEncryptKey: ptr HCRYPTKEY): WINBOOL {.stdcall.} + PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY* = proc (pContentEncryptInfo: PCMSG_CONTENT_ENCRYPT_INFO, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_EXPORT_KEY_TRANS* = proc (pContentEncryptInfo: PCMSG_CONTENT_ENCRYPT_INFO, pKeyTransEncodeInfo: PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, pKeyTransEncryptInfo: PCMSG_KEY_TRANS_ENCRYPT_INFO, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_EXPORT_KEY_AGREE* = proc (pContentEncryptInfo: PCMSG_CONTENT_ENCRYPT_INFO, pKeyAgreeEncodeInfo: PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, pKeyAgreeEncryptInfo: PCMSG_KEY_AGREE_ENCRYPT_INFO, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_EXPORT_MAIL_LIST* = proc (pContentEncryptInfo: PCMSG_CONTENT_ENCRYPT_INFO, pMailListEncodeInfo: PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, pMailListEncryptInfo: PCMSG_MAIL_LIST_ENCRYPT_INFO, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_IMPORT_KEY_TRANS* = proc (pContentEncryptionAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pKeyTransDecryptPara: PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags: DWORD, pvReserved: pointer, phContentEncryptKey: ptr HCRYPTKEY): WINBOOL {.stdcall.} + PFN_CMSG_IMPORT_KEY_AGREE* = proc (pContentEncryptionAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pKeyAgreeDecryptPara: PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags: DWORD, pvReserved: pointer, phContentEncryptKey: ptr HCRYPTKEY): WINBOOL {.stdcall.} + PFN_CMSG_IMPORT_MAIL_LIST* = proc (pContentEncryptionAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pMailListDecryptPara: PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA, dwFlags: DWORD, pvReserved: pointer, phContentEncryptKey: ptr HCRYPTKEY): WINBOOL {.stdcall.} + PFN_CMSG_CNG_IMPORT_KEY_TRANS* = proc (pCNGContentDecryptInfo: PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyTransDecryptPara: PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_CNG_IMPORT_KEY_AGREE* = proc (pCNGContentDecryptInfo: PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyAgreeDecryptPara: PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY* = proc (pCNGContentDecryptInfo: PCMSG_CNG_CONTENT_DECRYPT_INFO, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.stdcall.} + PFN_CERT_DLL_OPEN_STORE_PROV_FUNC* = proc (lpszStoreProvider: LPCSTR, dwEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pvPara: pointer, hCertStore: HCERTSTORE, pStoreProvInfo: PCERT_STORE_PROV_INFO): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_CLOSE* = proc (hStoreProv: HCERTSTOREPROV, dwFlags: DWORD): void {.stdcall.} + PFN_CERT_STORE_PROV_READ_CERT* = proc (hStoreProv: HCERTSTOREPROV, pStoreCertContext: PCCERT_CONTEXT, dwFlags: DWORD, ppProvCertContext: ptr PCCERT_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_WRITE_CERT* = proc (hStoreProv: HCERTSTOREPROV, pCertContext: PCCERT_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_DELETE_CERT* = proc (hStoreProv: HCERTSTOREPROV, pCertContext: PCCERT_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_SET_CERT_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_READ_CRL* = proc (hStoreProv: HCERTSTOREPROV, pStoreCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, ppProvCrlContext: ptr PCCRL_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_WRITE_CRL* = proc (hStoreProv: HCERTSTOREPROV, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_DELETE_CRL* = proc (hStoreProv: HCERTSTOREPROV, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_SET_CRL_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_READ_CTL* = proc (hStoreProv: HCERTSTOREPROV, pStoreCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, ppProvCtlContext: ptr PCCTL_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_WRITE_CTL* = proc (hStoreProv: HCERTSTOREPROV, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_DELETE_CTL* = proc (hStoreProv: HCERTSTOREPROV, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_SET_CTL_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_CONTROL* = proc (hStoreProv: HCERTSTOREPROV, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: pointer): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FIND_CERT* = proc (hStoreProv: HCERTSTOREPROV, pFindInfo: PCCERT_STORE_PROV_FIND_INFO, pPrevCertContext: PCCERT_CONTEXT, dwFlags: DWORD, ppvStoreProvFindInfo: ptr pointer, ppProvCertContext: ptr PCCERT_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FREE_FIND_CERT* = proc (hStoreProv: HCERTSTOREPROV, pCertContext: PCCERT_CONTEXT, pvStoreProvFindInfo: pointer, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_GET_CERT_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FIND_CRL* = proc (hStoreProv: HCERTSTOREPROV, pFindInfo: PCCERT_STORE_PROV_FIND_INFO, pPrevCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, ppvStoreProvFindInfo: ptr pointer, ppProvCrlContext: ptr PCCRL_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FREE_FIND_CRL* = proc (hStoreProv: HCERTSTOREPROV, pCrlContext: PCCRL_CONTEXT, pvStoreProvFindInfo: pointer, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_GET_CRL_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FIND_CTL* = proc (hStoreProv: HCERTSTOREPROV, pFindInfo: PCCERT_STORE_PROV_FIND_INFO, pPrevCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, ppvStoreProvFindInfo: ptr pointer, ppProvCtlContext: ptr PCCTL_CONTEXT): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_FREE_FIND_CTL* = proc (hStoreProv: HCERTSTOREPROV, pCtlContext: PCCTL_CONTEXT, pvStoreProvFindInfo: pointer, dwFlags: DWORD): WINBOOL {.stdcall.} + PFN_CERT_STORE_PROV_GET_CTL_PROPERTY* = proc (hStoreProv: HCERTSTOREPROV, pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.stdcall.} + PFN_CERT_ENUM_SYSTEM_STORE_LOCATION* = proc (pwszStoreLocation: LPCWSTR, dwFlags: DWORD, pvReserved: pointer, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CERT_ENUM_SYSTEM_STORE* = proc (pvSystemStore: pointer, dwFlags: DWORD, pStoreInfo: PCERT_SYSTEM_STORE_INFO, pvReserved: pointer, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CERT_ENUM_PHYSICAL_STORE* = proc (pvSystemStore: pointer, dwFlags: DWORD, pwszStoreName: LPCWSTR, pStoreInfo: PCERT_PHYSICAL_STORE_INFO, pvReserved: pointer, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC* = proc (dwCertEncodingType: DWORD, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, ppvDecodedSignPara: ptr pointer, ppwszCNGHashAlgid: ptr LPWSTR): WINBOOL {.stdcall.} + PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC* = proc (hKey: NCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara: pointer, pwszCNGPubKeyAlgid: LPCWSTR, pwszCNGHashAlgid: LPCWSTR, pbComputedHash: ptr BYTE, cbComputedHash: DWORD, pbSignature: ptr BYTE, pcbSignature: ptr DWORD): WINBOOL {.stdcall.} + PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC* = proc (dwCertEncodingType: DWORD, pPubKeyInfo: PCERT_PUBLIC_KEY_INFO, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara: pointer, pwszCNGPubKeyAlgid: LPCWSTR, pwszCNGHashAlgid: LPCWSTR, pbComputedHash: ptr BYTE, cbComputedHash: DWORD, pbSignature: ptr BYTE, cbSignature: DWORD): WINBOOL {.stdcall.} + PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC* = proc (hNCryptKey: NCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: ptr DWORD): WINBOOL {.stdcall.} + PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC* = proc (hBCryptKey: BCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: ptr DWORD): WINBOOL {.stdcall.} + PFN_IMPORT_PRIV_KEY_FUNC* = proc (hCryptProv: HCRYPTPROV, pPrivateKeyInfo: ptr CRYPT_PRIVATE_KEY_INFO, dwFlags: DWORD, pvAuxInfo: pointer): WINBOOL {.stdcall.} + PFN_EXPORT_PRIV_KEY_FUNC* = proc (hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, pszPrivateKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pPrivateKeyInfo: ptr CRYPT_PRIVATE_KEY_INFO, pcbPrivateKeyInfo: ptr DWORD): WINBOOL {.stdcall.} + PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC* = proc (dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, dwFlags: DWORD, pvAuxInfo: pointer, phKey: ptr BCRYPT_KEY_HANDLE): WINBOOL {.stdcall.} + PFN_CRYPT_ASYNC_PARAM_FREE_FUNC* = proc (pszParamOid: LPSTR, pvParam: LPVOID): VOID {.stdcall.} + PFN_FREE_ENCODED_OBJECT_FUNC* = proc (pszObjectOid: LPCSTR, pObject: PCRYPT_BLOB_ARRAY, pvFreeContext: LPVOID): VOID {.stdcall.} + PFN_CRYPT_CANCEL_RETRIEVAL* = proc (dwFlags: DWORD, pvArg: pointer): WINBOOL {.stdcall.} + PFN_CANCEL_ASYNC_RETRIEVAL_FUNC* = proc (hAsyncRetrieve: HCRYPTASYNC): WINBOOL {.stdcall.} + PFN_CRYPT_ENUM_KEYID_PROP* = proc (pKeyIdentifier: ptr CRYPT_HASH_BLOB, dwFlags: DWORD, pvReserved: pointer, pvArg: pointer, cProp: DWORD, rgdwPropId: ptr DWORD, rgpvData: ptr pointer, rgcbData: ptr DWORD): WINBOOL {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH* = proc (pContext: LPVOID, rgIdentifierOrNameList: ptr PCERT_NAME_BLOB, dwIdentifierOrNameListCount: DWORD): WINBOOL {.stdcall.} + PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE* = proc (pfnFlush: PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH, pContext: LPVOID, pdwExpectedObjectCount: ptr DWORD, ppFuncTable: ptr PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE, ppPluginContext: ptr pointer): WINBOOL {.stdcall.} + PROV_ENUMALGS* {.pure.} = object + aiAlgid*: ALG_ID + dwBitLen*: DWORD + dwNameLen*: DWORD + szName*: array[20, CHAR] + PROV_ENUMALGS_EX* {.pure.} = object + aiAlgid*: ALG_ID + dwDefaultLen*: DWORD + dwMinLen*: DWORD + dwMaxLen*: DWORD + dwProtocols*: DWORD + dwNameLen*: DWORD + szName*: array[20, CHAR] + dwLongNameLen*: DWORD + szLongName*: array[40, CHAR] + RSAPUBKEY* {.pure.} = object + magic*: DWORD + bitlen*: DWORD + pubexp*: DWORD + CERT_FORTEZZA_DATA_PROP* {.pure.} = object + SerialNumber*: array[8, uint8] + CertIndex*: int32 + CertLabel*: array[36, uint8] + BCRYPT_OID* {.pure.} = object + cbOID*: ULONG + pbOID*: PUCHAR + BCRYPT_OID_LIST* {.pure.} = object + dwOIDCount*: ULONG + pOIDs*: ptr BCRYPT_OID + BCRYPT_PKCS1_PADDING_INFO* {.pure.} = object + pszAlgId*: LPCWSTR + BCRYPT_PSS_PADDING_INFO* {.pure.} = object + pszAlgId*: LPCWSTR + cbSalt*: ULONG + BCRYPT_OAEP_PADDING_INFO* {.pure.} = object + pszAlgId*: LPCWSTR + pbLabel*: PUCHAR + cbLabel*: ULONG + BCRYPT_KEY_BLOB* {.pure.} = object + Magic*: ULONG + BCRYPT_RSAKEY_BLOB* {.pure.} = object + Magic*: ULONG + BitLength*: ULONG + cbPublicExp*: ULONG + cbModulus*: ULONG + cbPrime1*: ULONG + cbPrime2*: ULONG + BCRYPT_DH_PARAMETER_HEADER* {.pure.} = object + cbLength*: ULONG + dwMagic*: ULONG + cbKeyLength*: ULONG + BCRYPT_DSA_PARAMETER_HEADER* {.pure.} = object + cbLength*: ULONG + dwMagic*: ULONG + cbKeyLength*: ULONG + Count*: array[4, UCHAR] + Seed*: array[20, UCHAR] + q*: array[20, UCHAR] + BCRYPT_DSA_PARAMETER_HEADER_V2* {.pure.} = object + cbLength*: ULONG + dwMagic*: ULONG + cbKeyLength*: ULONG + hashAlgorithm*: HASHALGORITHM_ENUM + standardVersion*: DSAFIPSVERSION_ENUM + cbSeedLength*: ULONG + cbGroupSize*: ULONG + Count*: array[4, UCHAR] + BCRYPT_ALGORITHM_IDENTIFIER* {.pure.} = object + pszName*: LPWSTR + dwClass*: ULONG + dwFlags*: ULONG + BCRYPT_PROVIDER_NAME* {.pure.} = object + pszProviderName*: LPWSTR + NCRYPT_ALLOC_PARA* {.pure.} = object + cbSize*: DWORD + pfnAlloc*: PFN_NCRYPT_ALLOC + pfnFree*: PFN_NCRYPT_FREE + NCryptAlgorithmName* {.pure.} = object + pszName*: LPWSTR + dwClass*: DWORD + dwAlgOperations*: DWORD + dwFlags*: DWORD + NCryptKeyName* {.pure.} = object + pszName*: LPWSTR + pszAlgid*: LPWSTR + dwLegacyKeySpec*: DWORD + dwFlags*: DWORD + NCryptProviderName* {.pure.} = object + pszName*: LPWSTR + pszComment*: LPWSTR + NCRYPT_UI_POLICY* {.pure.} = object + dwVersion*: DWORD + dwFlags*: DWORD + pszCreationTitle*: LPCWSTR + pszFriendlyName*: LPCWSTR + pszDescription*: LPCWSTR + NCRYPT_SUPPORTED_LENGTHS* {.pure.} = object + dwMinLength*: DWORD + dwMaxLength*: DWORD + dwIncrement*: DWORD + dwDefaultLength*: DWORD + CRYPT_PKCS12_PBE_PARAMS* {.pure.} = object + iIterations*: int32 + cbSalt*: ULONG +proc CryptAcquireContextA*(phProv: ptr HCRYPTPROV, szContainer: LPCSTR, szProvider: LPCSTR, dwProvType: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptAcquireContextW*(phProv: ptr HCRYPTPROV, szContainer: LPCWSTR, szProvider: LPCWSTR, dwProvType: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptReleaseContext*(hProv: HCRYPTPROV, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGenKey*(hProv: HCRYPTPROV, Algid: ALG_ID, dwFlags: DWORD, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDeriveKey*(hProv: HCRYPTPROV, Algid: ALG_ID, hBaseData: HCRYPTHASH, dwFlags: DWORD, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDestroyKey*(hKey: HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetKeyParam*(hKey: HCRYPTKEY, dwParam: DWORD, pbData: ptr BYTE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetKeyParam*(hKey: HCRYPTKEY, dwParam: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetHashParam*(hHash: HCRYPTHASH, dwParam: DWORD, pbData: ptr BYTE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetHashParam*(hHash: HCRYPTHASH, dwParam: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetProvParam*(hProv: HCRYPTPROV, dwParam: DWORD, pbData: ptr BYTE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetProvParam*(hProv: HCRYPTPROV, dwParam: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGenRandom*(hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: ptr BYTE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetUserKey*(hProv: HCRYPTPROV, dwKeySpec: DWORD, phUserKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptExportKey*(hKey: HCRYPTKEY, hExpKey: HCRYPTKEY, dwBlobType: DWORD, dwFlags: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptImportKey*(hProv: HCRYPTPROV, pbData: ptr BYTE, dwDataLen: DWORD, hPubKey: HCRYPTKEY, dwFlags: DWORD, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptEncrypt*(hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: WINBOOL, dwFlags: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD, dwBufLen: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDecrypt*(hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: WINBOOL, dwFlags: DWORD, pbData: ptr BYTE, pdwDataLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptCreateHash*(hProv: HCRYPTPROV, Algid: ALG_ID, hKey: HCRYPTKEY, dwFlags: DWORD, phHash: ptr HCRYPTHASH): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptHashData*(hHash: HCRYPTHASH, pbData: ptr BYTE, dwDataLen: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptHashSessionKey*(hHash: HCRYPTHASH, hKey: HCRYPTKEY, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDestroyHash*(hHash: HCRYPTHASH): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSignHashA*(hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCSTR, dwFlags: DWORD, pbSignature: ptr BYTE, pdwSigLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSignHashW*(hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCWSTR, dwFlags: DWORD, pbSignature: ptr BYTE, pdwSigLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptVerifySignatureA*(hHash: HCRYPTHASH, pbSignature: ptr BYTE, dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptVerifySignatureW*(hHash: HCRYPTHASH, pbSignature: ptr BYTE, dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetProviderA*(pszProvName: LPCSTR, dwProvType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetProviderW*(pszProvName: LPCWSTR, dwProvType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetProviderExA*(pszProvName: LPCSTR, dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptSetProviderExW*(pszProvName: LPCWSTR, dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetDefaultProviderA*(dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pszProvName: LPSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptGetDefaultProviderW*(dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pszProvName: LPWSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptEnumProviderTypesA*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szTypeName: LPSTR, pcbTypeName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptEnumProviderTypesW*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szTypeName: LPWSTR, pcbTypeName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptEnumProvidersA*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szProvName: LPSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptEnumProvidersW*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szProvName: LPWSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptContextAddRef*(hProv: HCRYPTPROV, pdwReserved: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDuplicateKey*(hKey: HCRYPTKEY, pdwReserved: ptr DWORD, dwFlags: DWORD, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CryptDuplicateHash*(hHash: HCRYPTHASH, pdwReserved: ptr DWORD, dwFlags: DWORD, phHash: ptr HCRYPTHASH): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc BCryptOpenAlgorithmProvider*(phAlgorithm: ptr BCRYPT_ALG_HANDLE, pszAlgId: LPCWSTR, pszImplementation: LPCWSTR, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumAlgorithms*(dwAlgOperations: ULONG, pAlgCount: ptr ULONG, ppAlgList: ptr ptr BCRYPT_ALGORITHM_IDENTIFIER, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumProviders*(pszAlgId: LPCWSTR, pImplCount: ptr ULONG, ppImplList: ptr ptr BCRYPT_PROVIDER_NAME, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptGetProperty*(hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptSetProperty*(hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptCloseAlgorithmProvider*(hAlgorithm: BCRYPT_ALG_HANDLE, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptFreeBuffer*(pvBuffer: PVOID): VOID {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptGenerateSymmetricKey*(hAlgorithm: BCRYPT_ALG_HANDLE, phKey: ptr BCRYPT_KEY_HANDLE, pbKeyObject: PUCHAR, cbKeyObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptGenerateKeyPair*(hAlgorithm: BCRYPT_ALG_HANDLE, phKey: ptr BCRYPT_KEY_HANDLE, dwLength: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEncrypt*(hKey: BCRYPT_KEY_HANDLE, pbInput: PUCHAR, cbInput: ULONG, pPaddingInfo: pointer, pbIV: PUCHAR, cbIV: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDecrypt*(hKey: BCRYPT_KEY_HANDLE, pbInput: PUCHAR, cbInput: ULONG, pPaddingInfo: pointer, pbIV: PUCHAR, cbIV: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptExportKey*(hKey: BCRYPT_KEY_HANDLE, hExportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptImportKey*(hAlgorithm: BCRYPT_ALG_HANDLE, hImportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, phKey: ptr BCRYPT_KEY_HANDLE, pbKeyObject: PUCHAR, cbKeyObject: ULONG, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptImportKeyPair*(hAlgorithm: BCRYPT_ALG_HANDLE, hImportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, phKey: ptr BCRYPT_KEY_HANDLE, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDuplicateKey*(hKey: BCRYPT_KEY_HANDLE, phNewKey: ptr BCRYPT_KEY_HANDLE, pbKeyObject: PUCHAR, cbKeyObject: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptFinalizeKeyPair*(hKey: BCRYPT_KEY_HANDLE, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDestroyKey*(hKey: BCRYPT_KEY_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDestroySecret*(hSecret: BCRYPT_SECRET_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptSignHash*(hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: pointer, pbInput: PUCHAR, cbInput: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptVerifySignature*(hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: pointer, pbHash: PUCHAR, cbHash: ULONG, pbSignature: PUCHAR, cbSignature: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptSecretAgreement*(hPrivKey: BCRYPT_KEY_HANDLE, hPubKey: BCRYPT_KEY_HANDLE, phAgreedSecret: ptr BCRYPT_SECRET_HANDLE, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDeriveKey*(hSharedSecret: BCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: ptr BCryptBufferDesc, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptKeyDerivation*(hKey: BCRYPT_KEY_HANDLE, pParameterList: ptr BCryptBufferDesc, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, pcbResult: ptr ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptCreateHash*(hAlgorithm: BCRYPT_ALG_HANDLE, phHash: ptr BCRYPT_HASH_HANDLE, pbHashObject: PUCHAR, cbHashObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptHashData*(hHash: BCRYPT_HASH_HANDLE, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptFinishHash*(hHash: BCRYPT_HASH_HANDLE, pbOutput: PUCHAR, cbOutput: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDuplicateHash*(hHash: BCRYPT_HASH_HANDLE, phNewHash: ptr BCRYPT_HASH_HANDLE, pbHashObject: PUCHAR, cbHashObject: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDestroyHash*(hHash: BCRYPT_HASH_HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptGenRandom*(hAlgorithm: BCRYPT_ALG_HANDLE, pbBuffer: PUCHAR, cbBuffer: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDeriveKeyCapi*(hHash: BCRYPT_HASH_HANDLE, hTargetAlg: BCRYPT_ALG_HANDLE, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDeriveKeyPBKDF2*(hPrf: BCRYPT_ALG_HANDLE, pbPassword: PUCHAR, cbPassword: ULONG, pbSalt: PUCHAR, cbSalt: ULONG, cIterations: ULONGLONG, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptResolveProviders*(pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProvider: LPCWSTR, dwMode: ULONG, dwFlags: ULONG, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_PROVIDER_REFS): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptGetFipsAlgorithmMode*(pfEnabled: ptr BOOLEAN): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptRegisterConfigChangeNotify*(pEvent: PRKEVENT): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptUnregisterConfigChangeNotify*(pEvent: PRKEVENT): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptUnregisterConfigChangeNotify*(hEvent: HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptQueryProviderRegistration*(pszProvider: LPCWSTR, dwMode: ULONG, dwInterface: ULONG, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_PROVIDER_REG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumRegisteredProviders*(pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_PROVIDERS): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptCreateContext*(dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptDeleteContext*(dwTable: ULONG, pszContext: LPCWSTR): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumContexts*(dwTable: ULONG, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_CONTEXTS): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptConfigureContext*(dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptQueryContextConfiguration*(dwTable: ULONG, pszContext: LPCWSTR, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_CONTEXT_CONFIG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptAddContextFunction*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, dwPosition: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptRemoveContextFunction*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumContextFunctions*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_CONTEXT_FUNCTIONS): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptConfigureContextFunction*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pConfig: PCRYPT_CONTEXT_FUNCTION_CONFIG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptQueryContextFunctionConfiguration*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_CONTEXT_FUNCTION_CONFIG): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptEnumContextFunctionProviders*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: ptr ULONG, ppBuffer: ptr PCRYPT_CONTEXT_FUNCTION_PROVIDERS): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptSetContextFunctionProperty*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, cbValue: ULONG, pbValue: PUCHAR): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptQueryContextFunctionProperty*(dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, pcbValue: ptr ULONG, ppbValue: ptr PUCHAR): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc BCryptRegisterConfigChangeNotify*(phEvent: ptr HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "bcrypt", importc.} +proc NCryptOpenStorageProvider*(phProvider: ptr NCRYPT_PROV_HANDLE, pszProviderName: LPCWSTR, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptEnumAlgorithms*(hProvider: NCRYPT_PROV_HANDLE, dwAlgOperations: DWORD, pdwAlgCount: ptr DWORD, ppAlgList: ptr ptr NCryptAlgorithmName, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptIsAlgSupported*(hProvider: NCRYPT_PROV_HANDLE, pszAlgId: LPCWSTR, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptEnumKeys*(hProvider: NCRYPT_PROV_HANDLE, pszScope: LPCWSTR, ppKeyName: ptr ptr NCryptKeyName, ppEnumState: ptr PVOID, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptEnumStorageProviders*(pdwProviderCount: ptr DWORD, ppProviderList: ptr ptr NCryptProviderName, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptFreeBuffer*(pvInput: PVOID): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptOpenKey*(hProvider: NCRYPT_PROV_HANDLE, phKey: ptr NCRYPT_KEY_HANDLE, pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptCreatePersistedKey*(hProvider: NCRYPT_PROV_HANDLE, phKey: ptr NCRYPT_KEY_HANDLE, pszAlgId: LPCWSTR, pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptGetProperty*(hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: ptr DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptSetProperty*(hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PBYTE, cbInput: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptFinalizeKey*(hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptEncrypt*(hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: pointer, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: ptr DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptDecrypt*(hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: pointer, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: ptr DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptImportKey*(hProvider: NCRYPT_PROV_HANDLE, hImportKey: NCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pParameterList: ptr NCryptBufferDesc, phKey: ptr NCRYPT_KEY_HANDLE, pbData: PBYTE, cbData: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptExportKey*(hKey: NCRYPT_KEY_HANDLE, hExportKey: NCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pParameterList: ptr NCryptBufferDesc, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: ptr DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptSignHash*(hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: pointer, pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, pcbResult: ptr DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptVerifySignature*(hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: pointer, pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptDeleteKey*(hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptFreeObject*(hObject: NCRYPT_HANDLE): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptIsKeyHandle*(hKey: NCRYPT_KEY_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptTranslateHandle*(phProvider: ptr NCRYPT_PROV_HANDLE, phKey: ptr NCRYPT_KEY_HANDLE, hLegacyProv: HCRYPTPROV, hLegacyKey: HCRYPTKEY, dwLegacyKeySpec: DWORD, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptNotifyChangeKey*(hProvider: NCRYPT_PROV_HANDLE, phEvent: ptr HANDLE, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptSecretAgreement*(hPrivKey: NCRYPT_KEY_HANDLE, hPubKey: NCRYPT_KEY_HANDLE, phAgreedSecret: ptr NCRYPT_SECRET_HANDLE, dwFlags: DWORD): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptDeriveKey*(hSharedSecret: NCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: ptr NCryptBufferDesc, pbDerivedKey: PBYTE, cbDerivedKey: DWORD, pcbResult: ptr DWORD, dwFlags: ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc NCryptKeyDerivation*(hKey: NCRYPT_KEY_HANDLE, pParameterList: ptr NCryptBufferDesc, pbDerivedKey: PUCHAR, cbDerivedKey: DWORD, pcbResult: ptr DWORD, dwFlags: ULONG): SECURITY_STATUS {.winapi, stdcall, dynlib: "ncrypt", importc.} +proc CryptFormatObject*(dwCertEncodingType: DWORD, dwFormatType: DWORD, dwFormatStrType: DWORD, pFormatStruct: pointer, lpszStructType: LPCSTR, pbEncoded: ptr BYTE, cbEncoded: DWORD, pbFormat: pointer, pcbFormat: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEncodeObjectEx*(dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: pointer, dwFlags: DWORD, pEncodePara: PCRYPT_ENCODE_PARA, pvEncoded: pointer, pcbEncoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEncodeObject*(dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptDecodeObjectEx*(dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: ptr BYTE, cbEncoded: DWORD, dwFlags: DWORD, pDecodePara: PCRYPT_DECODE_PARA, pvStructInfo: pointer, pcbStructInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptDecodeObject*(dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: ptr BYTE, cbEncoded: DWORD, dwFlags: DWORD, pvStructInfo: pointer, pcbStructInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptInstallOIDFunctionAddress*(hModule: HMODULE, dwEncodingType: DWORD, pszFuncName: LPCSTR, cFuncEntry: DWORD, rgFuncEntry: ptr CRYPT_OID_FUNC_ENTRY, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptInitOIDFunctionSet*(pszFuncName: LPCSTR, dwFlags: DWORD): HCRYPTOIDFUNCSET {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetOIDFunctionAddress*(hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pszOID: LPCSTR, dwFlags: DWORD, ppvFuncAddr: ptr pointer, phFuncAddr: ptr HCRYPTOIDFUNCADDR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetDefaultOIDDllList*(hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDllList: ptr WCHAR, pcchDllList: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetDefaultOIDFunctionAddress*(hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDll: LPCWSTR, dwFlags: DWORD, ppvFuncAddr: ptr pointer, phFuncAddr: ptr HCRYPTOIDFUNCADDR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptFreeOIDFunctionAddress*(hFuncAddr: HCRYPTOIDFUNCADDR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptRegisterOIDFunction*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszDll: LPCWSTR, pszOverrideFuncName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUnregisterOIDFunction*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptRegisterDefaultOIDFunction*(dwEncodingType: DWORD, pszFuncName: LPCSTR, dwIndex: DWORD, pwszDll: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUnregisterDefaultOIDFunction*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pwszDll: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSetOIDFunctionValue*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, dwValueType: DWORD, pbValueData: ptr BYTE, cbValueData: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetOIDFunctionValue*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, pdwValueType: ptr DWORD, pbValueData: ptr BYTE, pcbValueData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEnumOIDFunction*(dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, dwFlags: DWORD, pvArg: pointer, pfnEnumOIDFunc: PFN_CRYPT_ENUM_OID_FUNC): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptFindOIDInfo*(dwKeyType: DWORD, pvKey: pointer, dwGroupId: DWORD): PCCRYPT_OID_INFO {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptRegisterOIDInfo*(pInfo: PCCRYPT_OID_INFO, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUnregisterOIDInfo*(pInfo: PCCRYPT_OID_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEnumOIDInfo*(dwGroupId: DWORD, dwFlags: DWORD, pvArg: pointer, pfnEnumOIDInfo: PFN_CRYPT_ENUM_OID_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptFindLocalizedName*(pwszCryptName: LPCWSTR): LPCWSTR {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgOpenToEncode*(dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: pointer, pszInnerContentObjID: LPSTR, pStreamInfo: PCMSG_STREAM_INFO): HCRYPTMSG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgCalculateEncodedLength*(dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: pointer, pszInnerContentObjID: LPSTR, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgOpenToDecode*(dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, pRecipientInfo: PCERT_INFO, pStreamInfo: PCMSG_STREAM_INFO): HCRYPTMSG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgDuplicate*(hCryptMsg: HCRYPTMSG): HCRYPTMSG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgClose*(hCryptMsg: HCRYPTMSG): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgUpdate*(hCryptMsg: HCRYPTMSG, pbData: ptr BYTE, cbData: DWORD, fFinal: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgGetParam*(hCryptMsg: HCRYPTMSG, dwParamType: DWORD, dwIndex: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgControl*(hCryptMsg: HCRYPTMSG, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgVerifyCountersignatureEncoded*(hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE, cbSignerInfoCountersignature: DWORD, pciCountersigner: PCERT_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgVerifyCountersignatureEncodedEx*(hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE, cbSignerInfoCountersignature: DWORD, dwSignerType: DWORD, pvSigner: pointer, dwFlags: DWORD, pvExtra: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgCountersign*(hCryptMsg: HCRYPTMSG, dwIndex: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgCountersignEncoded*(dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO, pbCountersignature: PBYTE, pcbCountersignature: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertOpenStore*(lpszStoreProvider: LPCSTR, dwEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pvPara: pointer): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDuplicateStore*(hCertStore: HCERTSTORE): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSaveStore*(hCertStore: HCERTSTORE, dwEncodingType: DWORD, dwSaveAs: DWORD, dwSaveTo: DWORD, pvSaveToPara: pointer, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCloseStore*(hCertStore: HCERTSTORE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetSubjectCertificateFromStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pCertId: PCERT_INFO): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCertificatesInStore*(hCertStore: HCERTSTORE, pPrevCertContext: PCCERT_CONTEXT): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindCertificateInStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: pointer, pPrevCertContext: PCCERT_CONTEXT): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetIssuerCertificateFromStore*(hCertStore: HCERTSTORE, pSubjectContext: PCCERT_CONTEXT, pPrevIssuerContext: PCCERT_CONTEXT, pdwFlags: ptr DWORD): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifySubjectCertificateContext*(pSubject: PCCERT_CONTEXT, pIssuer: PCCERT_CONTEXT, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDuplicateCertificateContext*(pCertContext: PCCERT_CONTEXT): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCreateCertificateContext*(dwCertEncodingType: DWORD, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCertificateContext*(pCertContext: PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetCertificateContextProperty*(pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCRLsInStore*(hCertStore: HCERTSTORE, pPrevCrlContext: PCCRL_CONTEXT): PCCRL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDeleteCRLFromStore*(pCrlContext: PCCRL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDuplicateCRLContext*(pCrlContext: PCCRL_CONTEXT): PCCRL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindCRLInStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: pointer, pPrevCrlContext: PCCRL_CONTEXT): PCCRL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCRLContext*(pCrlContext: PCCRL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetCertificateContextProperty*(pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCertificateContextProperties*(pCertContext: PCCERT_CONTEXT, dwPropId: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCreateCTLEntryFromCertificateContextProperties*(pCertContext: PCCERT_CONTEXT, cOptAttr: DWORD, rgOptAttr: PCRYPT_ATTRIBUTE, dwFlags: DWORD, pvReserved: pointer, pCtlEntry: PCTL_ENTRY, pcbCtlEntry: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetCertificateContextPropertiesFromCTLEntry*(pCertContext: PCCERT_CONTEXT, pCtlEntry: PCTL_ENTRY, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetCRLFromStore*(hCertStore: HCERTSTORE, pIssuerContext: PCCERT_CONTEXT, pPrevCrlContext: PCCRL_CONTEXT, pdwFlags: ptr DWORD): PCCRL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCreateCRLContext*(dwCertEncodingType: DWORD, pbCrlEncoded: ptr BYTE, cbCrlEncoded: DWORD): PCCRL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetCRLContextProperty*(pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetCRLContextProperty*(pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCRLContextProperties*(pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindCertificateInCRL*(pCert: PCCERT_CONTEXT, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: pointer, ppCrlEntry: ptr PCRL_ENTRY): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertIsValidCRLForCertificate*(pCert: PCCERT_CONTEXT, pCrl: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEncodedCertificateToStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD, dwAddDisposition: DWORD, ppCertContext: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCertificateContextToStore*(hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddSerializedElementToStore*(hCertStore: HCERTSTORE, pbElement: ptr BYTE, cbElement: DWORD, dwAddDisposition: DWORD, dwFlags: DWORD, dwContextTypeFlags: DWORD, pdwContextType: ptr DWORD, ppvContext: ptr pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDeleteCertificateFromStore*(pCertContext: PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEncodedCRLToStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCrlEncoded: ptr BYTE, cbCrlEncoded: DWORD, dwAddDisposition: DWORD, ppCrlContext: ptr PCCRL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCRLContextToStore*(hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCRL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSerializeCertificateStoreElement*(pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pbElement: ptr BYTE, pcbElement: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSerializeCRLStoreElement*(pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pbElement: ptr BYTE, pcbElement: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDuplicateCTLContext*(pCtlContext: PCCTL_CONTEXT): PCCTL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCreateCTLContext*(dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: ptr BYTE, cbCtlEncoded: DWORD): PCCTL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCTLContext*(pCtlContext: PCCTL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetCTLContextProperty*(pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetCTLContextProperty*(pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCTLContextProperties*(pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumCTLsInStore*(hCertStore: HCERTSTORE, pPrevCtlContext: PCCTL_CONTEXT): PCCTL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindSubjectInCTL*(dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: pointer, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD): PCTL_ENTRY {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindCTLInStore*(hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: pointer, pPrevCtlContext: PCCTL_CONTEXT): PCCTL_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEncodedCTLToStore*(hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: ptr BYTE, cbCtlEncoded: DWORD, dwAddDisposition: DWORD, ppCtlContext: ptr PCCTL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCTLContextToStore*(hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCTL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSerializeCTLStoreElement*(pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pbElement: ptr BYTE, pcbElement: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDeleteCTLFromStore*(pCtlContext: PCCTL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCertificateLinkToStore*(hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCRLLinkToStore*(hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCRL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddCTLLinkToStore*(hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: ptr PCCTL_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddStoreToCollection*(hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE, dwUpdateFlags: DWORD, dwPriority: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRemoveStoreFromCollection*(hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE): void {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertControlStore*(hCertStore: HCERTSTORE, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetStoreProperty*(hCertStore: HCERTSTORE, dwPropId: DWORD, dwFlags: DWORD, pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetStoreProperty*(hCertStore: HCERTSTORE, dwPropId: DWORD, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRegisterSystemStore*(pvSystemStore: pointer, dwFlags: DWORD, pStoreInfo: PCERT_SYSTEM_STORE_INFO, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRegisterPhysicalStore*(pvSystemStore: pointer, dwFlags: DWORD, pwszStoreName: LPCWSTR, pStoreInfo: PCERT_PHYSICAL_STORE_INFO, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertUnregisterSystemStore*(pvSystemStore: pointer, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertUnregisterPhysicalStore*(pvSystemStore: pointer, dwFlags: DWORD, pwszStoreName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumSystemStoreLocation*(dwFlags: DWORD, pvArg: pointer, pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE_LOCATION): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumSystemStore*(dwFlags: DWORD, pvSystemStoreLocationPara: pointer, pvArg: pointer, pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumPhysicalStore*(pvSystemStore: pointer, dwFlags: DWORD, pvArg: pointer, pfnEnum: PFN_CERT_ENUM_PHYSICAL_STORE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetEnhancedKeyUsage*(pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pUsage: PCERT_ENHKEY_USAGE, pcbUsage: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSetEnhancedKeyUsage*(pCertContext: PCCERT_CONTEXT, pUsage: PCERT_ENHKEY_USAGE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEnhancedKeyUsageIdentifier*(pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRemoveEnhancedKeyUsageIdentifier*(pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetValidUsages*(cCerts: DWORD, rghCerts: ptr PCCERT_CONTEXT, cNumOIDs: ptr int32, rghOIDs: ptr LPSTR, pcbOIDs: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgGetAndVerifySigner*(hCryptMsg: HCRYPTMSG, cSignerStore: DWORD, rghSignerStore: ptr HCERTSTORE, dwFlags: DWORD, ppSigner: ptr PCCERT_CONTEXT, pdwSignerIndex: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgSignCTL*(dwMsgEncodingType: DWORD, pbCtlContent: ptr BYTE, cbCtlContent: DWORD, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMsgEncodeAndSignCTL*(dwMsgEncodingType: DWORD, pCtlInfo: PCTL_INFO, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindSubjectInSortedCTL*(pSubjectIdentifier: PCRYPT_DATA_BLOB, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pvReserved: pointer, pEncodedAttributes: PCRYPT_DER_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertEnumSubjectInSortedCTL*(pCtlContext: PCCTL_CONTEXT, ppvNextSubject: ptr pointer, pSubjectIdentifier: PCRYPT_DER_BLOB, pEncodedAttributes: PCRYPT_DER_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyCTLUsage*(dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: pointer, pSubjectUsage: PCTL_USAGE, dwFlags: DWORD, pVerifyUsagePara: PCTL_VERIFY_USAGE_PARA, pVerifyUsageStatus: PCTL_VERIFY_USAGE_STATUS): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyRevocation*(dwEncodingType: DWORD, dwRevType: DWORD, cContext: DWORD, rgpvContext: ptr PVOID, dwFlags: DWORD, pRevPara: PCERT_REVOCATION_PARA, pRevStatus: PCERT_REVOCATION_STATUS): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCompareIntegerBlob*(pInt1: PCRYPT_INTEGER_BLOB, pInt2: PCRYPT_INTEGER_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCompareCertificate*(dwCertEncodingType: DWORD, pCertId1: PCERT_INFO, pCertId2: PCERT_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCompareCertificateName*(dwCertEncodingType: DWORD, pCertName1: PCERT_NAME_BLOB, pCertName2: PCERT_NAME_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertIsRDNAttrsInCertificateName*(dwCertEncodingType: DWORD, dwFlags: DWORD, pCertName: PCERT_NAME_BLOB, pRDN: PCERT_RDN): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertComparePublicKeyInfo*(dwCertEncodingType: DWORD, pPublicKey1: PCERT_PUBLIC_KEY_INFO, pPublicKey2: PCERT_PUBLIC_KEY_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetPublicKeyLength*(dwCertEncodingType: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyCertificateSignature*(hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: ptr BYTE, cbEncoded: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyCertificateSignatureEx*(hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: pointer, dwIssuerType: DWORD, pvIssuer: pointer, dwFlags: DWORD, pvExtra: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertIsStrongHashToSign*(pStrongSignPara: PCCERT_STRONG_SIGN_PARA, pwszCNGHashAlgid: LPCWSTR, pSigningCert: PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptHashToBeSigned*(hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: ptr BYTE, cbEncoded: DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptHashCertificate*(hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, pbEncoded: ptr BYTE, cbEncoded: DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptHashCertificate2*(pwszCNGHashAlgid: LPCWSTR, dwFlags: DWORD, pvReserved: pointer, pbEncoded: ptr BYTE, cbEncoded: DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSignCertificate*(hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pbEncodedToBeSigned: ptr BYTE, cbEncodedToBeSigned: DWORD, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: pointer, pbSignature: ptr BYTE, pcbSignature: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSignAndEncodeCertificate*(hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: pointer, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyTimeValidity*(pTimeToVerify: LPFILETIME, pCertInfo: PCERT_INFO): LONG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyCRLTimeValidity*(pTimeToVerify: LPFILETIME, pCrlInfo: PCRL_INFO): LONG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyValidityNesting*(pSubjectInfo: PCERT_INFO, pIssuerInfo: PCERT_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyCRLRevocation*(dwCertEncodingType: DWORD, pCertId: PCERT_INFO, cCrlInfo: DWORD, rgpCrlInfo: ptr PCRL_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAlgIdToOID*(dwAlgId: DWORD): LPCSTR {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertOIDToAlgId*(pszObjId: LPCSTR): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindExtension*(pszObjId: LPCSTR, cExtensions: DWORD, rgExtensions: ptr CERT_EXTENSION): PCERT_EXTENSION {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindAttribute*(pszObjId: LPCSTR, cAttr: DWORD, rgAttr: ptr CRYPT_ATTRIBUTE): PCRYPT_ATTRIBUTE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindRDNAttr*(pszObjId: LPCSTR, pName: PCERT_NAME_INFO): PCERT_RDN_ATTR {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetIntendedKeyUsage*(dwCertEncodingType: DWORD, pCertInfo: PCERT_INFO, pbKeyUsage: ptr BYTE, cbKeyUsage: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptInstallDefaultContext*(hCryptProv: HCRYPTPROV, dwDefaultType: DWORD, pvDefaultPara: pointer, dwFlags: DWORD, pvReserved: pointer, phDefaultContext: ptr HCRYPTDEFAULTCONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUninstallDefaultContext*(hDefaultContext: HCRYPTDEFAULTCONTEXT, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptExportPublicKeyInfo*(hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptExportPublicKeyInfoEx*(hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptExportPublicKeyInfoFromBCryptKeyHandle*(hBCryptKey: BCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptImportPublicKeyInfo*(hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptImportPublicKeyInfoEx*(hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, aiKeyAlg: ALG_ID, dwFlags: DWORD, pvAuxInfo: pointer, phKey: ptr HCRYPTKEY): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptImportPublicKeyInfoEx2*(dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, dwFlags: DWORD, pvAuxInfo: pointer, phKey: ptr BCRYPT_KEY_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptAcquireCertificatePrivateKey*(pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvParameters: pointer, phCryptProvOrNCryptKey: ptr HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pdwKeySpec: ptr DWORD, pfCallerFreeProvOrNCryptKey: ptr WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptFindCertificateKeyProvInfo*(pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptImportPKCS8*(sPrivateKeyAndParams: CRYPT_PKCS8_IMPORT_PARAMS, dwFlags: DWORD, phCryptProv: ptr HCRYPTPROV, pvAuxInfo: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptExportPKCS8*(hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, pszPrivateKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: pointer, pbPrivateKeyBlob: ptr BYTE, pcbPrivateKeyBlob: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptHashPublicKeyInfo*(hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRDNValueToStrA*(dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRDNValueToStrW*(dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPWSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertNameToStrA*(dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertNameToStrW*(dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPWSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertStrToNameA*(dwCertEncodingType: DWORD, pszX500: LPCSTR, dwStrType: DWORD, pvReserved: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD, ppszError: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertStrToNameW*(dwCertEncodingType: DWORD, pszX500: LPCWSTR, dwStrType: DWORD, pvReserved: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD, ppszError: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetNameStringA*(pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: pointer, pszNameString: LPSTR, cchNameString: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetNameStringW*(pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: pointer, pszNameString: LPWSTR, cchNameString: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSignMessage*(pSignPara: PCRYPT_SIGN_MESSAGE_PARA, fDetachedSignature: WINBOOL, cToBeSigned: DWORD, rgpbToBeSigned: ptr ptr BYTE, rgcbToBeSigned: ptr DWORD, pbSignedBlob: ptr BYTE, pcbSignedBlob: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyMessageSignature*(pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbSignedBlob: ptr BYTE, cbSignedBlob: DWORD, pbDecoded: ptr BYTE, pcbDecoded: ptr DWORD, ppSignerCert: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetMessageSignerCount*(dwMsgEncodingType: DWORD, pbSignedBlob: ptr BYTE, cbSignedBlob: DWORD): LONG {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetMessageCertificates*(dwMsgAndCertEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pbSignedBlob: ptr BYTE, cbSignedBlob: DWORD): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyDetachedMessageSignature*(pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbDetachedSignBlob: ptr BYTE, cbDetachedSignBlob: DWORD, cToBeSigned: DWORD, rgpbToBeSigned: ptr ptr BYTE, rgcbToBeSigned: ptr DWORD, ppSignerCert: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEncryptMessage*(pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: ptr PCCERT_CONTEXT, pbToBeEncrypted: ptr BYTE, cbToBeEncrypted: DWORD, pbEncryptedBlob: ptr BYTE, pcbEncryptedBlob: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptDecryptMessage*(pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pbEncryptedBlob: ptr BYTE, cbEncryptedBlob: DWORD, pbDecrypted: ptr BYTE, pcbDecrypted: ptr DWORD, ppXchgCert: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSignAndEncryptMessage*(pSignPara: PCRYPT_SIGN_MESSAGE_PARA, pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: ptr PCCERT_CONTEXT, pbToBeSignedAndEncrypted: ptr BYTE, cbToBeSignedAndEncrypted: DWORD, pbSignedAndEncryptedBlob: ptr BYTE, pcbSignedAndEncryptedBlob: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptDecryptAndVerifyMessageSignature*(pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbEncryptedBlob: ptr BYTE, cbEncryptedBlob: DWORD, pbDecrypted: ptr BYTE, pcbDecrypted: ptr DWORD, ppXchgCert: ptr PCCERT_CONTEXT, ppSignerCert: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptDecodeMessage*(dwMsgTypeFlags: DWORD, pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbEncodedBlob: ptr BYTE, cbEncodedBlob: DWORD, dwPrevInnerContentType: DWORD, pdwMsgType: ptr DWORD, pdwInnerContentType: ptr DWORD, pbDecoded: ptr BYTE, pcbDecoded: ptr DWORD, ppXchgCert: ptr PCCERT_CONTEXT, ppSignerCert: ptr PCCERT_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptHashMessage*(pHashPara: PCRYPT_HASH_MESSAGE_PARA, fDetachedHash: WINBOOL, cToBeHashed: DWORD, rgpbToBeHashed: ptr ptr BYTE, rgcbToBeHashed: ptr DWORD, pbHashedBlob: ptr BYTE, pcbHashedBlob: ptr DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyMessageHash*(pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbHashedBlob: ptr BYTE, cbHashedBlob: DWORD, pbToBeHashed: ptr BYTE, pcbToBeHashed: ptr DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyDetachedMessageHash*(pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbDetachedHashBlob: ptr BYTE, cbDetachedHashBlob: DWORD, cToBeHashed: DWORD, rgpbToBeHashed: ptr ptr BYTE, rgcbToBeHashed: ptr DWORD, pbComputedHash: ptr BYTE, pcbComputedHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSignMessageWithKey*(pSignPara: PCRYPT_KEY_SIGN_MESSAGE_PARA, pbToBeSigned: ptr BYTE, cbToBeSigned: DWORD, pbSignedBlob: ptr BYTE, pcbSignedBlob: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyMessageSignatureWithKey*(pVerifyPara: PCRYPT_KEY_VERIFY_MESSAGE_PARA, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO, pbSignedBlob: ptr BYTE, cbSignedBlob: DWORD, pbDecoded: ptr BYTE, pcbDecoded: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertOpenSystemStoreA*(hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCSTR): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertOpenSystemStoreW*(hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCWSTR): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEncodedCertificateToSystemStoreA*(szCertStoreName: LPCSTR, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddEncodedCertificateToSystemStoreW*(szCertStoreName: LPCWSTR, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc FindCertsByIssuer*(pCertChains: PCERT_CHAIN, pcbCertChains: ptr DWORD, pcCertChains: ptr DWORD, pbEncodedIssuerName: ptr BYTE, cbEncodedIssuerName: DWORD, pwszPurpose: LPCWSTR, dwKeySpec: DWORD): HRESULT {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptQueryObject*(dwObjectType: DWORD, pvObject: pointer, dwExpectedContentTypeFlags: DWORD, dwExpectedFormatTypeFlags: DWORD, dwFlags: DWORD, pdwMsgAndCertEncodingType: ptr DWORD, pdwContentType: ptr DWORD, pdwFormatType: ptr DWORD, phCertStore: ptr HCERTSTORE, phMsg: ptr HCRYPTMSG, ppvContext: ptr pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMemAlloc*(cbSize: ULONG): LPVOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMemRealloc*(pv: LPVOID, cbSize: ULONG): LPVOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptMemFree*(pv: LPVOID): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptCreateAsyncHandle*(dwFlags: DWORD, phAsync: PHCRYPTASYNC): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSetAsyncParam*(hAsync: HCRYPTASYNC, pszParamOid: LPSTR, pvParam: LPVOID, pfnFree: PFN_CRYPT_ASYNC_PARAM_FREE_FUNC): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetAsyncParam*(hAsync: HCRYPTASYNC, pszParamOid: LPSTR, ppvParam: ptr LPVOID, ppfnFree: ptr PFN_CRYPT_ASYNC_PARAM_FREE_FUNC): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptCloseAsyncHandle*(hAsync: HCRYPTASYNC): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptRetrieveObjectByUrlA*(pszUrl: LPCSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: ptr LPVOID, hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptRetrieveObjectByUrlW*(pszUrl: LPCWSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: ptr LPVOID, hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptInstallCancelRetrieval*(pfnCancel: PFN_CRYPT_CANCEL_RETRIEVAL, pvArg: pointer, dwFlags: DWORD, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptUninstallCancelRetrieval*(dwFlags: DWORD, pvReserved: pointer): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptCancelAsyncRetrieval*(hAsyncRetrieval: HCRYPTASYNC): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptGetObjectUrl*(pszUrlOid: LPCSTR, pvPara: LPVOID, dwFlags: DWORD, pUrlArray: PCRYPT_URL_ARRAY, pcbUrlArray: ptr DWORD, pUrlInfo: PCRYPT_URL_INFO, pcbUrlInfo: ptr DWORD, pvReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptGetTimeValidObject*(pszTimeValidOid: LPCSTR, pvPara: LPVOID, pIssuer: PCCERT_CONTEXT, pftValidFor: LPFILETIME, dwFlags: DWORD, dwTimeout: DWORD, ppvObject: ptr LPVOID, pCredentials: PCRYPT_CREDENTIALS, pExtraInfo: PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CryptFlushTimeValidObject*(pszFlushTimeValidOid: LPCSTR, pvPara: LPVOID, pIssuer: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc.} +proc CertCreateSelfSignCertificate*(hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pSubjectIssuerBlob: PCERT_NAME_BLOB, dwFlags: DWORD, pKeyProvInfo: PCRYPT_KEY_PROV_INFO, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pStartTime: PSYSTEMTIME, pEndTime: PSYSTEMTIME, pExtensions: PCERT_EXTENSIONS): PCCERT_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptGetKeyIdentifierProperty*(pKeyIdentifier: ptr CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: pointer, pvData: pointer, pcbData: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSetKeyIdentifierProperty*(pKeyIdentifier: ptr CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: pointer, pvData: pointer): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptEnumKeyIdentifierProperties*(pKeyIdentifier: ptr CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: pointer, pvArg: pointer, pfnEnum: PFN_CRYPT_ENUM_KEYID_PROP): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptCreateKeyIdentifierFromCSP*(dwCertEncodingType: DWORD, pszPubKeyOID: LPCSTR, pPubKeyStruc: ptr PUBLICKEYSTRUC, cbPubKeyStruc: DWORD, dwFlags: DWORD, pvReserved: pointer, pbHash: ptr BYTE, pcbHash: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCreateCertificateChainEngine*(pConfig: PCERT_CHAIN_ENGINE_CONFIG, phChainEngine: ptr HCERTCHAINENGINE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCertificateChainEngine*(hChainEngine: HCERTCHAINENGINE): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertResyncCertificateChainEngine*(hChainEngine: HCERTCHAINENGINE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetCertificateChain*(hChainEngine: HCERTCHAINENGINE, pCertContext: PCCERT_CONTEXT, pTime: LPFILETIME, hAdditionalStore: HCERTSTORE, pChainPara: PCERT_CHAIN_PARA, dwFlags: DWORD, pvReserved: LPVOID, ppChainContext: ptr PCCERT_CHAIN_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCertificateChain*(pChainContext: PCCERT_CHAIN_CONTEXT): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertDuplicateCertificateChain*(pChainContext: PCCERT_CHAIN_CONTEXT): PCCERT_CHAIN_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFindChainInStore*(hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: pointer, pPrevChainContext: PCCERT_CHAIN_CONTEXT): PCCERT_CHAIN_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertVerifyCertificateChainPolicy*(pszPolicyOID: LPCSTR, pChainContext: PCCERT_CHAIN_CONTEXT, pPolicyPara: PCERT_CHAIN_POLICY_PARA, pPolicyStatus: PCERT_CHAIN_POLICY_STATUS): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptStringToBinaryA*(pszString: LPCSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: ptr BYTE, pcbBinary: ptr DWORD, pdwSkip: ptr DWORD, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptStringToBinaryW*(pszString: LPCWSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: ptr BYTE, pcbBinary: ptr DWORD, pdwSkip: ptr DWORD, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptBinaryToStringA*(pbBinary: ptr BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPSTR, pcchString: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptBinaryToStringW*(pbBinary: ptr BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPWSTR, pcchString: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc PFXImportCertStore*(pPFX: ptr CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc PFXIsPFXBlob*(pPFX: ptr CRYPT_DATA_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc PFXVerifyPassword*(pPFX: ptr CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc PFXExportCertStoreEx*(hStore: HCERTSTORE, pPFX: ptr CRYPT_DATA_BLOB, szPassword: LPCWSTR, pvPara: pointer, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc PFXExportCertStore*(hStore: HCERTSTORE, pPFX: ptr CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertOpenServerOcspResponse*(pChainContext: PCCERT_CHAIN_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID): HCERT_SERVER_OCSP_RESPONSE {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddRefServerOcspResponse*(hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertCloseServerOcspResponse*(hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertGetServerOcspResponseContext*(hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD, pvReserved: LPVOID): PCCERT_SERVER_OCSP_RESPONSE_CONTEXT {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertAddRefServerOcspResponseContext*(pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeServerOcspResponseContext*(pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertRetrieveLogoOrBiometricInfo*(pCertContext: PCCERT_CONTEXT, lpszLogoOrBiometricType: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, dwFlags: DWORD, pvReserved: pointer, ppbData: ptr ptr BYTE, pcbData: ptr DWORD, ppwszMimeType: ptr LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertSelectCertificateChains*(pSelectionContext: LPCGUID, dwFlags: DWORD, pChainParameters: PCCERT_SELECT_CHAIN_PARA, cCriteria: DWORD, rgpCriteria: PCCERT_SELECT_CRITERIA, hStore: HCERTSTORE, pcSelection: PDWORD, pprgpSelection: ptr ptr PCCERT_CHAIN_CONTEXT): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CertFreeCertificateChainList*(prgpSelection: ptr PCCERT_CHAIN_CONTEXT): VOID {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptRetrieveTimeStamp*(wszUrl: LPCWSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, pszHashId: LPCSTR, pPara: ptr CRYPT_TIMESTAMP_PARA, pbData: ptr BYTE, cbData: DWORD, ppTsContext: ptr PCRYPT_TIMESTAMP_CONTEXT, ppTsSigner: ptr PCCERT_CONTEXT, phStore: ptr HCERTSTORE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptVerifyTimeStampSignature*(pbTSContentInfo: ptr BYTE, cbTSContentInfo: DWORD, pbData: ptr BYTE, cbData: DWORD, hAdditionalStore: HCERTSTORE, ppTsContext: ptr PCRYPT_TIMESTAMP_CONTEXT, ppTsSigner: ptr PCCERT_CONTEXT, phStore: ptr HCERTSTORE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptProtectData*(pDataIn: ptr DATA_BLOB, szDataDescr: LPCWSTR, pOptionalEntropy: ptr DATA_BLOB, pvReserved: PVOID, pPromptStruct: ptr CRYPTPROTECT_PROMPTSTRUCT, dwFlags: DWORD, pDataOut: ptr DATA_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUnprotectData*(pDataIn: ptr DATA_BLOB, ppszDataDescr: ptr LPWSTR, pOptionalEntropy: ptr DATA_BLOB, pvReserved: PVOID, pPromptStruct: ptr CRYPTPROTECT_PROMPTSTRUCT, dwFlags: DWORD, pDataOut: ptr DATA_BLOB): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptProtectMemory*(pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUnprotectMemory*(pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptUpdateProtectedState*(pOldSid: PSID, pwszOldPassword: LPCWSTR, dwFlags: DWORD, pdwSuccessCount: ptr DWORD, pdwFailureCount: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc `pOtherName=`*(self: var CERT_ALT_NAME_ENTRY, x: PCERT_OTHER_NAME) {.inline.} = self.union1.pOtherName = x +proc pOtherName*(self: CERT_ALT_NAME_ENTRY): PCERT_OTHER_NAME {.inline.} = self.union1.pOtherName +proc pOtherName*(self: var CERT_ALT_NAME_ENTRY): var PCERT_OTHER_NAME {.inline.} = self.union1.pOtherName +proc `pwszRfc822Name=`*(self: var CERT_ALT_NAME_ENTRY, x: LPWSTR) {.inline.} = self.union1.pwszRfc822Name = x +proc pwszRfc822Name*(self: CERT_ALT_NAME_ENTRY): LPWSTR {.inline.} = self.union1.pwszRfc822Name +proc pwszRfc822Name*(self: var CERT_ALT_NAME_ENTRY): var LPWSTR {.inline.} = self.union1.pwszRfc822Name +proc `pwszDNSName=`*(self: var CERT_ALT_NAME_ENTRY, x: LPWSTR) {.inline.} = self.union1.pwszDNSName = x +proc pwszDNSName*(self: CERT_ALT_NAME_ENTRY): LPWSTR {.inline.} = self.union1.pwszDNSName +proc pwszDNSName*(self: var CERT_ALT_NAME_ENTRY): var LPWSTR {.inline.} = self.union1.pwszDNSName +proc `DirectoryName=`*(self: var CERT_ALT_NAME_ENTRY, x: CERT_NAME_BLOB) {.inline.} = self.union1.DirectoryName = x +proc DirectoryName*(self: CERT_ALT_NAME_ENTRY): CERT_NAME_BLOB {.inline.} = self.union1.DirectoryName +proc DirectoryName*(self: var CERT_ALT_NAME_ENTRY): var CERT_NAME_BLOB {.inline.} = self.union1.DirectoryName +proc `pwszURL=`*(self: var CERT_ALT_NAME_ENTRY, x: LPWSTR) {.inline.} = self.union1.pwszURL = x +proc pwszURL*(self: CERT_ALT_NAME_ENTRY): LPWSTR {.inline.} = self.union1.pwszURL +proc pwszURL*(self: var CERT_ALT_NAME_ENTRY): var LPWSTR {.inline.} = self.union1.pwszURL +proc `IPAddress=`*(self: var CERT_ALT_NAME_ENTRY, x: CRYPT_DATA_BLOB) {.inline.} = self.union1.IPAddress = x +proc IPAddress*(self: CERT_ALT_NAME_ENTRY): CRYPT_DATA_BLOB {.inline.} = self.union1.IPAddress +proc IPAddress*(self: var CERT_ALT_NAME_ENTRY): var CRYPT_DATA_BLOB {.inline.} = self.union1.IPAddress +proc `pszRegisteredID=`*(self: var CERT_ALT_NAME_ENTRY, x: LPSTR) {.inline.} = self.union1.pszRegisteredID = x +proc pszRegisteredID*(self: CERT_ALT_NAME_ENTRY): LPSTR {.inline.} = self.union1.pszRegisteredID +proc pszRegisteredID*(self: var CERT_ALT_NAME_ENTRY): var LPSTR {.inline.} = self.union1.pszRegisteredID +proc `FullName=`*(self: var CRL_DIST_POINT_NAME, x: CERT_ALT_NAME_INFO) {.inline.} = self.union1.FullName = x +proc FullName*(self: CRL_DIST_POINT_NAME): CERT_ALT_NAME_INFO {.inline.} = self.union1.FullName +proc FullName*(self: var CRL_DIST_POINT_NAME): var CERT_ALT_NAME_INFO {.inline.} = self.union1.FullName +proc `pTaggedCertRequest=`*(self: var CMC_TAGGED_REQUEST, x: PCMC_TAGGED_CERT_REQUEST) {.inline.} = self.union1.pTaggedCertRequest = x +proc pTaggedCertRequest*(self: CMC_TAGGED_REQUEST): PCMC_TAGGED_CERT_REQUEST {.inline.} = self.union1.pTaggedCertRequest +proc pTaggedCertRequest*(self: var CMC_TAGGED_REQUEST): var PCMC_TAGGED_CERT_REQUEST {.inline.} = self.union1.pTaggedCertRequest +proc `dwFailInfo=`*(self: var CMC_STATUS_INFO, x: DWORD) {.inline.} = self.union1.dwFailInfo = x +proc dwFailInfo*(self: CMC_STATUS_INFO): DWORD {.inline.} = self.union1.dwFailInfo +proc dwFailInfo*(self: var CMC_STATUS_INFO): var DWORD {.inline.} = self.union1.dwFailInfo +proc `pPendInfo=`*(self: var CMC_STATUS_INFO, x: PCMC_PEND_INFO) {.inline.} = self.union1.pPendInfo = x +proc pPendInfo*(self: CMC_STATUS_INFO): PCMC_PEND_INFO {.inline.} = self.union1.pPendInfo +proc pPendInfo*(self: var CMC_STATUS_INFO): var PCMC_PEND_INFO {.inline.} = self.union1.pPendInfo +proc `dwNumBits=`*(self: var CERT_LOGOTYPE_IMAGE_INFO, x: DWORD) {.inline.} = self.union1.dwNumBits = x +proc dwNumBits*(self: CERT_LOGOTYPE_IMAGE_INFO): DWORD {.inline.} = self.union1.dwNumBits +proc dwNumBits*(self: var CERT_LOGOTYPE_IMAGE_INFO): var DWORD {.inline.} = self.union1.dwNumBits +proc `dwTableSize=`*(self: var CERT_LOGOTYPE_IMAGE_INFO, x: DWORD) {.inline.} = self.union1.dwTableSize = x +proc dwTableSize*(self: CERT_LOGOTYPE_IMAGE_INFO): DWORD {.inline.} = self.union1.dwTableSize +proc dwTableSize*(self: var CERT_LOGOTYPE_IMAGE_INFO): var DWORD {.inline.} = self.union1.dwTableSize +proc `pLogotypeDirectInfo=`*(self: var CERT_LOGOTYPE_INFO, x: PCERT_LOGOTYPE_DATA) {.inline.} = self.union1.pLogotypeDirectInfo = x +proc pLogotypeDirectInfo*(self: CERT_LOGOTYPE_INFO): PCERT_LOGOTYPE_DATA {.inline.} = self.union1.pLogotypeDirectInfo +proc pLogotypeDirectInfo*(self: var CERT_LOGOTYPE_INFO): var PCERT_LOGOTYPE_DATA {.inline.} = self.union1.pLogotypeDirectInfo +proc `pLogotypeIndirectInfo=`*(self: var CERT_LOGOTYPE_INFO, x: PCERT_LOGOTYPE_REFERENCE) {.inline.} = self.union1.pLogotypeIndirectInfo = x +proc pLogotypeIndirectInfo*(self: CERT_LOGOTYPE_INFO): PCERT_LOGOTYPE_REFERENCE {.inline.} = self.union1.pLogotypeIndirectInfo +proc pLogotypeIndirectInfo*(self: var CERT_LOGOTYPE_INFO): var PCERT_LOGOTYPE_REFERENCE {.inline.} = self.union1.pLogotypeIndirectInfo +proc `dwPredefined=`*(self: var CERT_BIOMETRIC_DATA, x: DWORD) {.inline.} = self.union1.dwPredefined = x +proc dwPredefined*(self: CERT_BIOMETRIC_DATA): DWORD {.inline.} = self.union1.dwPredefined +proc dwPredefined*(self: var CERT_BIOMETRIC_DATA): var DWORD {.inline.} = self.union1.dwPredefined +proc `pszObjId=`*(self: var CERT_BIOMETRIC_DATA, x: LPSTR) {.inline.} = self.union1.pszObjId = x +proc pszObjId*(self: CERT_BIOMETRIC_DATA): LPSTR {.inline.} = self.union1.pszObjId +proc pszObjId*(self: var CERT_BIOMETRIC_DATA): var LPSTR {.inline.} = self.union1.pszObjId +proc `pRevokedInfo=`*(self: var OCSP_BASIC_RESPONSE_ENTRY, x: POCSP_BASIC_REVOKED_INFO) {.inline.} = self.union1.pRevokedInfo = x +proc pRevokedInfo*(self: OCSP_BASIC_RESPONSE_ENTRY): POCSP_BASIC_REVOKED_INFO {.inline.} = self.union1.pRevokedInfo +proc pRevokedInfo*(self: var OCSP_BASIC_RESPONSE_ENTRY): var POCSP_BASIC_REVOKED_INFO {.inline.} = self.union1.pRevokedInfo +proc `ByNameResponderId=`*(self: var OCSP_BASIC_RESPONSE_INFO, x: CERT_NAME_BLOB) {.inline.} = self.union1.ByNameResponderId = x +proc ByNameResponderId*(self: OCSP_BASIC_RESPONSE_INFO): CERT_NAME_BLOB {.inline.} = self.union1.ByNameResponderId +proc ByNameResponderId*(self: var OCSP_BASIC_RESPONSE_INFO): var CERT_NAME_BLOB {.inline.} = self.union1.ByNameResponderId +proc `ByKeyResponderId=`*(self: var OCSP_BASIC_RESPONSE_INFO, x: CRYPT_HASH_BLOB) {.inline.} = self.union1.ByKeyResponderId = x +proc ByKeyResponderId*(self: OCSP_BASIC_RESPONSE_INFO): CRYPT_HASH_BLOB {.inline.} = self.union1.ByKeyResponderId +proc ByKeyResponderId*(self: var OCSP_BASIC_RESPONSE_INFO): var CRYPT_HASH_BLOB {.inline.} = self.union1.ByKeyResponderId +proc `dwValue=`*(self: var CRYPT_OID_INFO, x: DWORD) {.inline.} = self.union1.dwValue = x +proc dwValue*(self: CRYPT_OID_INFO): DWORD {.inline.} = self.union1.dwValue +proc dwValue*(self: var CRYPT_OID_INFO): var DWORD {.inline.} = self.union1.dwValue +proc `Algid=`*(self: var CRYPT_OID_INFO, x: ALG_ID) {.inline.} = self.union1.Algid = x +proc algid*(self: CRYPT_OID_INFO): ALG_ID {.inline.} = self.union1.Algid +proc algid*(self: var CRYPT_OID_INFO): var ALG_ID {.inline.} = self.union1.Algid +proc `dwLength=`*(self: var CRYPT_OID_INFO, x: DWORD) {.inline.} = self.union1.dwLength = x +proc dwLength*(self: CRYPT_OID_INFO): DWORD {.inline.} = self.union1.dwLength +proc dwLength*(self: var CRYPT_OID_INFO): var DWORD {.inline.} = self.union1.dwLength +proc `pvInfo=`*(self: var CERT_STRONG_SIGN_PARA, x: pointer) {.inline.} = self.union1.pvInfo = x +proc pvInfo*(self: CERT_STRONG_SIGN_PARA): pointer {.inline.} = self.union1.pvInfo +proc pvInfo*(self: var CERT_STRONG_SIGN_PARA): var pointer {.inline.} = self.union1.pvInfo +proc `pSerializedInfo=`*(self: var CERT_STRONG_SIGN_PARA, x: PCERT_STRONG_SIGN_SERIALIZED_INFO) {.inline.} = self.union1.pSerializedInfo = x +proc pSerializedInfo*(self: CERT_STRONG_SIGN_PARA): PCERT_STRONG_SIGN_SERIALIZED_INFO {.inline.} = self.union1.pSerializedInfo +proc pSerializedInfo*(self: var CERT_STRONG_SIGN_PARA): var PCERT_STRONG_SIGN_SERIALIZED_INFO {.inline.} = self.union1.pSerializedInfo +proc `pszOID=`*(self: var CERT_STRONG_SIGN_PARA, x: LPSTR) {.inline.} = self.union1.pszOID = x +proc pszOID*(self: CERT_STRONG_SIGN_PARA): LPSTR {.inline.} = self.union1.pszOID +proc pszOID*(self: var CERT_STRONG_SIGN_PARA): var LPSTR {.inline.} = self.union1.pszOID +proc `IssuerSerialNumber=`*(self: var CERT_ID, x: CERT_ISSUER_SERIAL_NUMBER) {.inline.} = self.union1.IssuerSerialNumber = x +proc IssuerSerialNumber*(self: CERT_ID): CERT_ISSUER_SERIAL_NUMBER {.inline.} = self.union1.IssuerSerialNumber +proc IssuerSerialNumber*(self: var CERT_ID): var CERT_ISSUER_SERIAL_NUMBER {.inline.} = self.union1.IssuerSerialNumber +proc `KeyId=`*(self: var CERT_ID, x: CRYPT_HASH_BLOB) {.inline.} = self.union1.KeyId = x +proc KeyId*(self: CERT_ID): CRYPT_HASH_BLOB {.inline.} = self.union1.KeyId +proc KeyId*(self: var CERT_ID): var CRYPT_HASH_BLOB {.inline.} = self.union1.KeyId +proc `HashId=`*(self: var CERT_ID, x: CRYPT_HASH_BLOB) {.inline.} = self.union1.HashId = x +proc HashId*(self: CERT_ID): CRYPT_HASH_BLOB {.inline.} = self.union1.HashId +proc HashId*(self: var CERT_ID): var CRYPT_HASH_BLOB {.inline.} = self.union1.HashId +proc `hCryptProv=`*(self: var CMSG_SIGNER_ENCODE_INFO, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CMSG_SIGNER_ENCODE_INFO): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CMSG_SIGNER_ENCODE_INFO): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CMSG_SIGNER_ENCODE_INFO, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CMSG_SIGNER_ENCODE_INFO): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CMSG_SIGNER_ENCODE_INFO): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `pEphemeralAlgorithm=`*(self: var CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, x: PCRYPT_ALGORITHM_IDENTIFIER) {.inline.} = self.union1.pEphemeralAlgorithm = x +proc pEphemeralAlgorithm*(self: CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO): PCRYPT_ALGORITHM_IDENTIFIER {.inline.} = self.union1.pEphemeralAlgorithm +proc pEphemeralAlgorithm*(self: var CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO): var PCRYPT_ALGORITHM_IDENTIFIER {.inline.} = self.union1.pEphemeralAlgorithm +proc `pSenderId=`*(self: var CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, x: PCERT_ID) {.inline.} = self.union1.pSenderId = x +proc pSenderId*(self: CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO): PCERT_ID {.inline.} = self.union1.pSenderId +proc pSenderId*(self: var CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO): var PCERT_ID {.inline.} = self.union1.pSenderId +proc `hKeyEncryptionKey=`*(self: var CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, x: HCRYPTKEY) {.inline.} = self.union1.hKeyEncryptionKey = x +proc hKeyEncryptionKey*(self: CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO): HCRYPTKEY {.inline.} = self.union1.hKeyEncryptionKey +proc hKeyEncryptionKey*(self: var CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO): var HCRYPTKEY {.inline.} = self.union1.hKeyEncryptionKey +proc `pvKeyEncryptionKey=`*(self: var CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, x: pointer) {.inline.} = self.union1.pvKeyEncryptionKey = x +proc pvKeyEncryptionKey*(self: CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO): pointer {.inline.} = self.union1.pvKeyEncryptionKey +proc pvKeyEncryptionKey*(self: var CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO): var pointer {.inline.} = self.union1.pvKeyEncryptionKey +proc `pKeyTrans=`*(self: var CMSG_RECIPIENT_ENCODE_INFO, x: PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO) {.inline.} = self.union1.pKeyTrans = x +proc pKeyTrans*(self: CMSG_RECIPIENT_ENCODE_INFO): PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pKeyTrans +proc pKeyTrans*(self: var CMSG_RECIPIENT_ENCODE_INFO): var PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pKeyTrans +proc `pKeyAgree=`*(self: var CMSG_RECIPIENT_ENCODE_INFO, x: PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO) {.inline.} = self.union1.pKeyAgree = x +proc pKeyAgree*(self: CMSG_RECIPIENT_ENCODE_INFO): PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pKeyAgree +proc pKeyAgree*(self: var CMSG_RECIPIENT_ENCODE_INFO): var PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pKeyAgree +proc `pMailList=`*(self: var CMSG_RECIPIENT_ENCODE_INFO, x: PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO) {.inline.} = self.union1.pMailList = x +proc pMailList*(self: CMSG_RECIPIENT_ENCODE_INFO): PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pMailList +proc pMailList*(self: var CMSG_RECIPIENT_ENCODE_INFO): var PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {.inline.} = self.union1.pMailList +proc `OriginatorCertId=`*(self: var CMSG_KEY_AGREE_RECIPIENT_INFO, x: CERT_ID) {.inline.} = self.union1.OriginatorCertId = x +proc OriginatorCertId*(self: CMSG_KEY_AGREE_RECIPIENT_INFO): CERT_ID {.inline.} = self.union1.OriginatorCertId +proc OriginatorCertId*(self: var CMSG_KEY_AGREE_RECIPIENT_INFO): var CERT_ID {.inline.} = self.union1.OriginatorCertId +proc `OriginatorPublicKeyInfo=`*(self: var CMSG_KEY_AGREE_RECIPIENT_INFO, x: CERT_PUBLIC_KEY_INFO) {.inline.} = self.union1.OriginatorPublicKeyInfo = x +proc OriginatorPublicKeyInfo*(self: CMSG_KEY_AGREE_RECIPIENT_INFO): CERT_PUBLIC_KEY_INFO {.inline.} = self.union1.OriginatorPublicKeyInfo +proc OriginatorPublicKeyInfo*(self: var CMSG_KEY_AGREE_RECIPIENT_INFO): var CERT_PUBLIC_KEY_INFO {.inline.} = self.union1.OriginatorPublicKeyInfo +proc `pKeyTrans=`*(self: var CMSG_CMS_RECIPIENT_INFO, x: PCMSG_KEY_TRANS_RECIPIENT_INFO) {.inline.} = self.union1.pKeyTrans = x +proc pKeyTrans*(self: CMSG_CMS_RECIPIENT_INFO): PCMSG_KEY_TRANS_RECIPIENT_INFO {.inline.} = self.union1.pKeyTrans +proc pKeyTrans*(self: var CMSG_CMS_RECIPIENT_INFO): var PCMSG_KEY_TRANS_RECIPIENT_INFO {.inline.} = self.union1.pKeyTrans +proc `pKeyAgree=`*(self: var CMSG_CMS_RECIPIENT_INFO, x: PCMSG_KEY_AGREE_RECIPIENT_INFO) {.inline.} = self.union1.pKeyAgree = x +proc pKeyAgree*(self: CMSG_CMS_RECIPIENT_INFO): PCMSG_KEY_AGREE_RECIPIENT_INFO {.inline.} = self.union1.pKeyAgree +proc pKeyAgree*(self: var CMSG_CMS_RECIPIENT_INFO): var PCMSG_KEY_AGREE_RECIPIENT_INFO {.inline.} = self.union1.pKeyAgree +proc `pMailList=`*(self: var CMSG_CMS_RECIPIENT_INFO, x: PCMSG_MAIL_LIST_RECIPIENT_INFO) {.inline.} = self.union1.pMailList = x +proc pMailList*(self: CMSG_CMS_RECIPIENT_INFO): PCMSG_MAIL_LIST_RECIPIENT_INFO {.inline.} = self.union1.pMailList +proc pMailList*(self: var CMSG_CMS_RECIPIENT_INFO): var PCMSG_MAIL_LIST_RECIPIENT_INFO {.inline.} = self.union1.pMailList +proc `hCryptProv=`*(self: var CMSG_CTRL_DECRYPT_PARA, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CMSG_CTRL_DECRYPT_PARA): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CMSG_CTRL_DECRYPT_PARA): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CMSG_CTRL_DECRYPT_PARA, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CMSG_CTRL_DECRYPT_PARA): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CMSG_CTRL_DECRYPT_PARA): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `hCryptProv=`*(self: var CMSG_CTRL_KEY_TRANS_DECRYPT_PARA, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CMSG_CTRL_KEY_TRANS_DECRYPT_PARA): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CMSG_CTRL_KEY_TRANS_DECRYPT_PARA): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CMSG_CTRL_KEY_TRANS_DECRYPT_PARA, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CMSG_CTRL_KEY_TRANS_DECRYPT_PARA): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CMSG_CTRL_KEY_TRANS_DECRYPT_PARA): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `hCryptProv=`*(self: var CMSG_CTRL_KEY_AGREE_DECRYPT_PARA, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CMSG_CTRL_KEY_AGREE_DECRYPT_PARA): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CMSG_CTRL_KEY_AGREE_DECRYPT_PARA): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CMSG_CTRL_KEY_AGREE_DECRYPT_PARA, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CMSG_CTRL_KEY_AGREE_DECRYPT_PARA): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CMSG_CTRL_KEY_AGREE_DECRYPT_PARA): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `hKeyEncryptionKey=`*(self: var CMSG_CTRL_MAIL_LIST_DECRYPT_PARA, x: HCRYPTKEY) {.inline.} = self.union1.hKeyEncryptionKey = x +proc hKeyEncryptionKey*(self: CMSG_CTRL_MAIL_LIST_DECRYPT_PARA): HCRYPTKEY {.inline.} = self.union1.hKeyEncryptionKey +proc hKeyEncryptionKey*(self: var CMSG_CTRL_MAIL_LIST_DECRYPT_PARA): var HCRYPTKEY {.inline.} = self.union1.hKeyEncryptionKey +proc `pvKeyEncryptionKey=`*(self: var CMSG_CTRL_MAIL_LIST_DECRYPT_PARA, x: pointer) {.inline.} = self.union1.pvKeyEncryptionKey = x +proc pvKeyEncryptionKey*(self: CMSG_CTRL_MAIL_LIST_DECRYPT_PARA): pointer {.inline.} = self.union1.pvKeyEncryptionKey +proc pvKeyEncryptionKey*(self: var CMSG_CTRL_MAIL_LIST_DECRYPT_PARA): var pointer {.inline.} = self.union1.pvKeyEncryptionKey +proc `hContentEncryptKey=`*(self: var CMSG_CONTENT_ENCRYPT_INFO, x: HCRYPTKEY) {.inline.} = self.union1.hContentEncryptKey = x +proc hContentEncryptKey*(self: CMSG_CONTENT_ENCRYPT_INFO): HCRYPTKEY {.inline.} = self.union1.hContentEncryptKey +proc hContentEncryptKey*(self: var CMSG_CONTENT_ENCRYPT_INFO): var HCRYPTKEY {.inline.} = self.union1.hContentEncryptKey +proc `hCNGContentEncryptKey=`*(self: var CMSG_CONTENT_ENCRYPT_INFO, x: BCRYPT_KEY_HANDLE) {.inline.} = self.union1.hCNGContentEncryptKey = x +proc hCNGContentEncryptKey*(self: CMSG_CONTENT_ENCRYPT_INFO): BCRYPT_KEY_HANDLE {.inline.} = self.union1.hCNGContentEncryptKey +proc hCNGContentEncryptKey*(self: var CMSG_CONTENT_ENCRYPT_INFO): var BCRYPT_KEY_HANDLE {.inline.} = self.union1.hCNGContentEncryptKey +proc `OriginatorCertId=`*(self: var CMSG_KEY_AGREE_ENCRYPT_INFO, x: CERT_ID) {.inline.} = self.union1.OriginatorCertId = x +proc OriginatorCertId*(self: CMSG_KEY_AGREE_ENCRYPT_INFO): CERT_ID {.inline.} = self.union1.OriginatorCertId +proc OriginatorCertId*(self: var CMSG_KEY_AGREE_ENCRYPT_INFO): var CERT_ID {.inline.} = self.union1.OriginatorCertId +proc `OriginatorPublicKeyInfo=`*(self: var CMSG_KEY_AGREE_ENCRYPT_INFO, x: CERT_PUBLIC_KEY_INFO) {.inline.} = self.union1.OriginatorPublicKeyInfo = x +proc OriginatorPublicKeyInfo*(self: CMSG_KEY_AGREE_ENCRYPT_INFO): CERT_PUBLIC_KEY_INFO {.inline.} = self.union1.OriginatorPublicKeyInfo +proc OriginatorPublicKeyInfo*(self: var CMSG_KEY_AGREE_ENCRYPT_INFO): var CERT_PUBLIC_KEY_INFO {.inline.} = self.union1.OriginatorPublicKeyInfo +proc `hCryptProv=`*(self: var CERT_KEY_CONTEXT, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CERT_KEY_CONTEXT): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CERT_KEY_CONTEXT): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CERT_KEY_CONTEXT, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CERT_KEY_CONTEXT): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CERT_KEY_CONTEXT): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `hKeyBase=`*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA, x: HKEY) {.inline.} = self.union1.hKeyBase = x +proc hKeyBase*(self: CERT_SYSTEM_STORE_RELOCATE_PARA): HKEY {.inline.} = self.union1.hKeyBase +proc hKeyBase*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA): var HKEY {.inline.} = self.union1.hKeyBase +proc `pvBase=`*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA, x: pointer) {.inline.} = self.union1.pvBase = x +proc pvBase*(self: CERT_SYSTEM_STORE_RELOCATE_PARA): pointer {.inline.} = self.union1.pvBase +proc pvBase*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA): var pointer {.inline.} = self.union1.pvBase +proc `pvSystemStore=`*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA, x: pointer) {.inline.} = self.union2.pvSystemStore = x +proc pvSystemStore*(self: CERT_SYSTEM_STORE_RELOCATE_PARA): pointer {.inline.} = self.union2.pvSystemStore +proc pvSystemStore*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA): var pointer {.inline.} = self.union2.pvSystemStore +proc `pszSystemStore=`*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA, x: LPCSTR) {.inline.} = self.union2.pszSystemStore = x +proc pszSystemStore*(self: CERT_SYSTEM_STORE_RELOCATE_PARA): LPCSTR {.inline.} = self.union2.pszSystemStore +proc pszSystemStore*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA): var LPCSTR {.inline.} = self.union2.pszSystemStore +proc `pwszSystemStore=`*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA, x: LPCWSTR) {.inline.} = self.union2.pwszSystemStore = x +proc pwszSystemStore*(self: CERT_SYSTEM_STORE_RELOCATE_PARA): LPCWSTR {.inline.} = self.union2.pwszSystemStore +proc pwszSystemStore*(self: var CERT_SYSTEM_STORE_RELOCATE_PARA): var LPCWSTR {.inline.} = self.union2.pwszSystemStore +proc `hCryptProv=`*(self: var CRYPT_KEY_SIGN_MESSAGE_PARA, x: HCRYPTPROV) {.inline.} = self.union1.hCryptProv = x +proc hCryptProv*(self: CRYPT_KEY_SIGN_MESSAGE_PARA): HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc hCryptProv*(self: var CRYPT_KEY_SIGN_MESSAGE_PARA): var HCRYPTPROV {.inline.} = self.union1.hCryptProv +proc `hNCryptKey=`*(self: var CRYPT_KEY_SIGN_MESSAGE_PARA, x: NCRYPT_KEY_HANDLE) {.inline.} = self.union1.hNCryptKey = x +proc hNCryptKey*(self: CRYPT_KEY_SIGN_MESSAGE_PARA): NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc hNCryptKey*(self: var CRYPT_KEY_SIGN_MESSAGE_PARA): var NCRYPT_KEY_HANDLE {.inline.} = self.union1.hNCryptKey +proc `cbStruct=`*(self: var HTTPSPolicyCallbackData, x: DWORD) {.inline.} = self.union1.cbStruct = x +proc cbStruct*(self: HTTPSPolicyCallbackData): DWORD {.inline.} = self.union1.cbStruct +proc cbStruct*(self: var HTTPSPolicyCallbackData): var DWORD {.inline.} = self.union1.cbStruct +proc `cbSize=`*(self: var HTTPSPolicyCallbackData, x: DWORD) {.inline.} = self.union1.cbSize = x +proc cbSize*(self: HTTPSPolicyCallbackData): DWORD {.inline.} = self.union1.cbSize +proc cbSize*(self: var HTTPSPolicyCallbackData): var DWORD {.inline.} = self.union1.cbSize +when winimUnicode: + type + CRYPT_PASSWORD_CREDENTIALS* = CRYPT_PASSWORD_CREDENTIALSW + PCRYPT_PASSWORD_CREDENTIALS* = PCRYPT_PASSWORD_CREDENTIALSW + const + MS_DEF_PROV* = MS_DEF_PROV_W + MS_ENHANCED_PROV* = MS_ENHANCED_PROV_W + MS_STRONG_PROV* = MS_STRONG_PROV_W + MS_DEF_RSA_SIG_PROV* = MS_DEF_RSA_SIG_PROV_W + MS_DEF_RSA_SCHANNEL_PROV* = MS_DEF_RSA_SCHANNEL_PROV_W + MS_DEF_DSS_PROV* = MS_DEF_DSS_PROV_W + MS_DEF_DSS_DH_PROV* = MS_DEF_DSS_DH_PROV_W + MS_ENH_DSS_DH_PROV* = MS_ENH_DSS_DH_PROV_W + MS_DEF_DH_SCHANNEL_PROV* = MS_DEF_DH_SCHANNEL_PROV_W + MS_SCARD_PROV* = MS_SCARD_PROV_W + MS_ENH_RSA_AES_PROV_XP* = MS_ENH_RSA_AES_PROV_XP_W + MS_ENH_RSA_AES_PROV* = MS_ENH_RSA_AES_PROV_W + CREDENTIAL_OID_PASSWORD_CREDENTIALS* = CREDENTIAL_OID_PASSWORD_CREDENTIALS_W + proc CryptAcquireContext*(phProv: ptr HCRYPTPROV, szContainer: LPCWSTR, szProvider: LPCWSTR, dwProvType: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptAcquireContextW".} + proc CryptSignHash*(hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCWSTR, dwFlags: DWORD, pbSignature: ptr BYTE, pdwSigLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSignHashW".} + proc CryptVerifySignature*(hHash: HCRYPTHASH, pbSignature: ptr BYTE, dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptVerifySignatureW".} + proc CryptSetProvider*(pszProvName: LPCWSTR, dwProvType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSetProviderW".} + proc CryptSetProviderEx*(pszProvName: LPCWSTR, dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSetProviderExW".} + proc CryptGetDefaultProvider*(dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pszProvName: LPWSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptGetDefaultProviderW".} + proc CryptEnumProviderTypes*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szTypeName: LPWSTR, pcbTypeName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptEnumProviderTypesW".} + proc CryptEnumProviders*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szProvName: LPWSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptEnumProvidersW".} + proc CertRDNValueToStr*(dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPWSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertRDNValueToStrW".} + proc CertNameToStr*(dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPWSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertNameToStrW".} + proc CertStrToName*(dwCertEncodingType: DWORD, pszX500: LPCWSTR, dwStrType: DWORD, pvReserved: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD, ppszError: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CertStrToNameW".} + proc CertGetNameString*(pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: pointer, pszNameString: LPWSTR, cchNameString: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertGetNameStringW".} + proc CertOpenSystemStore*(hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCWSTR): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc: "CertOpenSystemStoreW".} + proc CertAddEncodedCertificateToSystemStore*(szCertStoreName: LPCWSTR, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CertAddEncodedCertificateToSystemStoreW".} + proc CryptRetrieveObjectByUrl*(pszUrl: LPCWSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: ptr LPVOID, hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc: "CryptRetrieveObjectByUrlW".} + proc CryptStringToBinary*(pszString: LPCWSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: ptr BYTE, pcbBinary: ptr DWORD, pdwSkip: ptr DWORD, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CryptStringToBinaryW".} + proc CryptBinaryToString*(pbBinary: ptr BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPWSTR, pcchString: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CryptBinaryToStringW".} +when winimAnsi: + type + CRYPT_PASSWORD_CREDENTIALS* = CRYPT_PASSWORD_CREDENTIALSA + PCRYPT_PASSWORD_CREDENTIALS* = PCRYPT_PASSWORD_CREDENTIALSA + const + MS_DEF_PROV* = MS_DEF_PROV_A + MS_ENHANCED_PROV* = MS_ENHANCED_PROV_A + MS_STRONG_PROV* = MS_STRONG_PROV_A + MS_DEF_RSA_SIG_PROV* = MS_DEF_RSA_SIG_PROV_A + MS_DEF_RSA_SCHANNEL_PROV* = MS_DEF_RSA_SCHANNEL_PROV_A + MS_DEF_DSS_PROV* = MS_DEF_DSS_PROV_A + MS_DEF_DSS_DH_PROV* = MS_DEF_DSS_DH_PROV_A + MS_ENH_DSS_DH_PROV* = MS_ENH_DSS_DH_PROV_A + MS_DEF_DH_SCHANNEL_PROV* = MS_DEF_DH_SCHANNEL_PROV_A + MS_SCARD_PROV* = MS_SCARD_PROV_A + MS_ENH_RSA_AES_PROV_XP* = MS_ENH_RSA_AES_PROV_XP_A + MS_ENH_RSA_AES_PROV* = MS_ENH_RSA_AES_PROV_A + CREDENTIAL_OID_PASSWORD_CREDENTIALS* = CREDENTIAL_OID_PASSWORD_CREDENTIALS_A + proc CryptAcquireContext*(phProv: ptr HCRYPTPROV, szContainer: LPCSTR, szProvider: LPCSTR, dwProvType: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptAcquireContextA".} + proc CryptSignHash*(hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCSTR, dwFlags: DWORD, pbSignature: ptr BYTE, pdwSigLen: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSignHashA".} + proc CryptVerifySignature*(hHash: HCRYPTHASH, pbSignature: ptr BYTE, dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptVerifySignatureA".} + proc CryptSetProvider*(pszProvName: LPCSTR, dwProvType: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSetProviderA".} + proc CryptSetProviderEx*(pszProvName: LPCSTR, dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptSetProviderExA".} + proc CryptGetDefaultProvider*(dwProvType: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pszProvName: LPSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptGetDefaultProviderA".} + proc CryptEnumProviderTypes*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szTypeName: LPSTR, pcbTypeName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptEnumProviderTypesA".} + proc CryptEnumProviders*(dwIndex: DWORD, pdwReserved: ptr DWORD, dwFlags: DWORD, pdwProvType: ptr DWORD, szProvName: LPSTR, pcbProvName: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "CryptEnumProvidersA".} + proc CertRDNValueToStr*(dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertRDNValueToStrA".} + proc CertNameToStr*(dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPSTR, csz: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertNameToStrA".} + proc CertStrToName*(dwCertEncodingType: DWORD, pszX500: LPCSTR, dwStrType: DWORD, pvReserved: pointer, pbEncoded: ptr BYTE, pcbEncoded: ptr DWORD, ppszError: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CertStrToNameA".} + proc CertGetNameString*(pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: pointer, pszNameString: LPSTR, cchNameString: DWORD): DWORD {.winapi, stdcall, dynlib: "crypt32", importc: "CertGetNameStringA".} + proc CertOpenSystemStore*(hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCSTR): HCERTSTORE {.winapi, stdcall, dynlib: "crypt32", importc: "CertOpenSystemStoreA".} + proc CertAddEncodedCertificateToSystemStore*(szCertStoreName: LPCSTR, pbCertEncoded: ptr BYTE, cbCertEncoded: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CertAddEncodedCertificateToSystemStoreA".} + proc CryptRetrieveObjectByUrl*(pszUrl: LPCSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: ptr LPVOID, hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO): WINBOOL {.winapi, stdcall, dynlib: "cryptnet", importc: "CryptRetrieveObjectByUrlA".} + proc CryptStringToBinary*(pszString: LPCSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: ptr BYTE, pcbBinary: ptr DWORD, pdwSkip: ptr DWORD, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CryptStringToBinaryA".} + proc CryptBinaryToString*(pbBinary: ptr BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPSTR, pcchString: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc: "CryptBinaryToStringA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/windef.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/windef.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,9837 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + INT8* = int8 + PINT8* = ptr int8 + INT32* = int32 + PINT32* = ptr int32 + INT64* = int64 + PINT64* = ptr int64 + UINT8* = uint8 + PUINT8* = ptr uint8 + UINT16* = uint16 + PUINT16* = ptr uint16 + UINT32* = int32 + PUINT32* = ptr int32 + UINT64* = int64 + PUINT64* = ptr int64 + LONG32* = int32 + PLONG32* = ptr int32 + ULONG32* = int32 + PULONG32* = ptr int32 + DWORD32* = int32 + PDWORD32* = ptr int32 + LONG64* = int64 + PLONG64* = ptr int64 + ULONG64* = int64 + PULONG64* = ptr int64 + DWORD64* = int64 + PDWORD64* = ptr int64 + PVOID* = pointer + CHAR* = char + LONG* = int32 + INT* = int32 + UCHAR* = uint8 + PUCHAR* = ptr uint8 + USHORT* = uint16 + PUSHORT* = ptr uint16 + ULONG* = int32 + PULONG* = ptr int32 + SCHAR* = int8 + WINBOOL* = int32 + BOOL* = int32 + LONGLONG* = int64 + PLONGLONG* = ptr int64 + ULONGLONG* = int64 + PULONGLONG* = ptr int64 + PCSZ* = ptr char + WCHAR* = uint16 + CCHAR* = char + PCCHAR* = ptr char + NT_PRODUCT_TYPE* = int32 + PNT_PRODUCT_TYPE* = ptr int32 + EVENT_TYPE* = int32 + TIMER_TYPE* = int32 + WAIT_TYPE* = int32 + BYTE* = uint8 + WORD* = uint16 + DWORD* = int32 + PINT* = ptr int32 + LPINT* = ptr int32 + LPLONG* = ptr int32 + LPVOID* = pointer + LPCVOID* = pointer + UINT* = int32 + PUINT* = ptr int32 + UCSCHAR* = int32 + COMPARTMENT_ID* = int32 + PCOMPARTMENT_ID* = ptr int32 + SID_NAME_USE* = int32 + PSID_NAME_USE* = ptr int32 + WELL_KNOWN_SID_TYPE* = int32 + ACL_INFORMATION_CLASS* = int32 + AUDIT_EVENT_TYPE* = int32 + PAUDIT_EVENT_TYPE* = ptr int32 + ACCESS_REASON_TYPE* = int32 + SECURITY_IMPERSONATION_LEVEL* = int32 + PSECURITY_IMPERSONATION_LEVEL* = ptr int32 + TOKEN_TYPE* = int32 + TOKEN_ELEVATION_TYPE* = int32 + PTOKEN_ELEVATION_TYPE* = ptr int32 + TOKEN_INFORMATION_CLASS* = int32 + PTOKEN_INFORMATION_CLASS* = ptr int32 + MANDATORY_LEVEL* = int32 + PMANDATORY_LEVEL* = ptr int32 + SE_LEARNING_MODE_DATA_TYPE* = int32 + HARDWARE_COUNTER_TYPE* = int32 + PHARDWARE_COUNTER_TYPE* = ptr int32 + PROCESS_MITIGATION_POLICY* = int32 + PPROCESS_MITIGATION_POLICY* = ptr int32 + JOBOBJECT_RATE_CONTROL_TOLERANCE* = int32 + JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL* = int32 + JOBOBJECTINFOCLASS* = int32 + FIRMWARE_TYPE* = int32 + PFIRMWARE_TYPE* = ptr int32 + LOGICAL_PROCESSOR_RELATIONSHIP* = int32 + PROCESSOR_CACHE_TYPE* = int32 + SYSTEM_POWER_STATE* = int32 + PSYSTEM_POWER_STATE* = ptr int32 + POWER_ACTION* = int32 + PPOWER_ACTION* = ptr int32 + DEVICE_POWER_STATE* = int32 + PDEVICE_POWER_STATE* = ptr int32 + MONITOR_DISPLAY_STATE* = int32 + PMONITOR_DISPLAY_STATE* = ptr int32 + USER_ACTIVITY_PRESENCE* = int32 + PUSER_ACTIVITY_PRESENCE* = ptr int32 + LATENCY_TIME* = int32 + POWER_REQUEST_TYPE* = int32 + PPOWER_REQUEST_TYPE* = ptr int32 + POWER_INFORMATION_LEVEL* = int32 + POWER_USER_PRESENCE_TYPE* = int32 + PPOWER_USER_PRESENCE_TYPE* = ptr int32 + POWER_MONITOR_REQUEST_REASON* = int32 + SYSTEM_POWER_CONDITION* = int32 + POWER_PLATFORM_ROLE* = int32 + PPOWER_PLATFORM_ROLE* = ptr int32 + IMAGE_AUX_SYMBOL_TYPE* = int32 + IMPORT_OBJECT_TYPE* = int32 + IMPORT_OBJECT_NAME_TYPE* = int32 + ReplacesCorHdrNumericDefines* = int32 + RTL_UMS_THREAD_INFO_CLASS* = int32 + PRTL_UMS_THREAD_INFO_CLASS* = ptr int32 + RTL_UMS_SCHEDULER_REASON* = int32 + PRTL_UMS_SCHEDULER_REASON* = ptr int32 + HEAP_INFORMATION_CLASS* = int32 + ACTIVATION_CONTEXT_INFO_CLASS* = int32 + ACTCTX_REQUESTED_RUN_LEVEL* = int32 + ACTCTX_COMPATIBILITY_ELEMENT_TYPE* = int32 + SERVICE_NODE_TYPE* = int32 + SERVICE_LOAD_TYPE* = int32 + SERVICE_ERROR_TYPE* = int32 + TAPE_DRIVE_PROBLEM_TYPE* = int32 + TP_CALLBACK_PRIORITY* = int32 + TRANSACTION_OUTCOME* = int32 + TRANSACTION_STATE* = int32 + TRANSACTION_INFORMATION_CLASS* = int32 + TRANSACTIONMANAGER_INFORMATION_CLASS* = int32 + RESOURCEMANAGER_INFORMATION_CLASS* = int32 + ENLISTMENT_INFORMATION_CLASS* = int32 + KTMOBJECT_TYPE* = int32 + PKTMOBJECT_TYPE* = ptr int32 + HFILE* = int32 + FILE_INFORMATION_CLASS* = int32 + PFILE_INFORMATION_CLASS* = ptr int32 + FS_INFORMATION_CLASS* = int32 + PFS_INFORMATION_CLASS* = ptr int32 + THREAD_STATE* = int32 + KWAIT_REASON* = int32 + PROCESSINFOCLASS* = int32 + THREADINFOCLASS* = int32 + SYSTEM_INFORMATION_CLASS* = int32 + OBJECT_INFORMATION_CLASS* = int32 + POBJECT_INFORMATION_CLASS* = ptr int32 + WINSTATIONINFOCLASS* = int32 + HANDLE* = int + VOID* = void + PVOID64* = pointer + va_list* = pointer + FARPROC* = pointer + NEARPROC* = pointer + PROC* = pointer + EXCEPTION_DISPOSITION* = int + QWORD* = int64 + PQWORD* = ptr int64 +when winimAnsi: + type + TCHAR* = char + PTCHAR* = ptr char + TBYTE* = uint8 + PTBYTE* = ptr uint8 +when winimCpu64: + type + INT_PTR* = int64 + PINT_PTR* = ptr int64 + UINT_PTR* = int64 + PUINT_PTR* = ptr int64 + LONG_PTR* = int64 + PLONG_PTR* = ptr int64 + ULONG_PTR* = int64 + PULONG_PTR* = ptr int64 + SHANDLE_PTR* = int64 + HANDLE_PTR* = int64 + UHALF_PTR* = int32 + PUHALF_PTR* = ptr int32 + HALF_PTR* = int32 + PHALF_PTR* = ptr int32 +when winimCpu32: + type + INT_PTR* = int32 + PINT_PTR* = ptr int32 + UINT_PTR* = int32 + PUINT_PTR* = ptr int32 + LONG_PTR* = int32 + PLONG_PTR* = ptr int32 + ULONG_PTR* = int32 + PULONG_PTR* = ptr int32 + UHALF_PTR* = uint16 + PUHALF_PTR* = ptr uint16 + SHANDLE_PTR* = int32 + HANDLE_PTR* = int32 +type + SIZE_T* = ULONG_PTR + PSIZE_T* = ptr ULONG_PTR + SSIZE_T* = LONG_PTR + PSSIZE_T* = ptr LONG_PTR + DWORD_PTR* = ULONG_PTR + PDWORD_PTR* = ptr ULONG_PTR + KAFFINITY* = ULONG_PTR + PHANDLE* = ptr HANDLE + PCUCHAR* = ptr UCHAR + PCUSHORT* = ptr USHORT + PCULONG* = ptr ULONG + FCHAR* = UCHAR + FSHORT* = USHORT + FLONG* = ULONG + BOOLEAN* = UCHAR + PBOOLEAN* = ptr UCHAR + LOGICAL* = ULONG + PLOGICAL* = ptr ULONG + SHORT* = int16 + PSHORT* = ptr SHORT + PLONG* = ptr LONG + NTSTATUS* = LONG + PSCHAR* = ptr SCHAR + PBOOL* = ptr BOOL + LPBOOL* = ptr BOOL + HRESULT* = LONG + DWORDLONG* = ULONGLONG + PDWORDLONG* = ptr ULONGLONG + USN* = LONGLONG + PCHAR* = ptr CHAR + LPCH* = ptr CHAR + PCH* = ptr CHAR + LPCCH* = ptr CHAR + PCCH* = ptr CHAR + NPSTR* = ptr CHAR + LPSTR* = ptr CHAR + PSTR* = ptr CHAR + PZPSTR* = ptr PSTR + PCZPSTR* = ptr PSTR + LPCSTR* = ptr CHAR + PCSTR* = ptr CHAR + PZPCSTR* = ptr PCSTR + PSZ* = ptr CHAR + PWCHAR* = ptr WCHAR + LPWCH* = ptr WCHAR + PWCH* = ptr WCHAR + LPCWCH* = ptr WCHAR + PCWCH* = ptr WCHAR + NWPSTR* = ptr WCHAR + LPWSTR* = ptr WCHAR + PWSTR* = ptr WCHAR + PZPWSTR* = ptr PWSTR + PCZPWSTR* = ptr PWSTR + LPUWSTR* = ptr WCHAR + PUWSTR* = ptr WCHAR + LPCWSTR* = ptr WCHAR + PCWSTR* = ptr WCHAR + PZPCWSTR* = ptr PCWSTR + LPCUWSTR* = ptr WCHAR + PCUWSTR* = ptr WCHAR + CLONG* = ULONG + PCLONG* = ptr ULONG + LCID* = ULONG + PLCID* = PULONG + LANGID* = USHORT + FLOAT* = float32 + PFLOAT* = ptr FLOAT + PBYTE* = ptr BYTE + LPBYTE* = ptr BYTE + PWORD* = ptr WORD + LPWORD* = ptr WORD + PDWORD* = ptr DWORD + LPDWORD* = ptr DWORD + PZZWSTR* = ptr WCHAR + PCZZWSTR* = ptr WCHAR + PUZZWSTR* = ptr WCHAR + PCUZZWSTR* = ptr WCHAR + PNZWCH* = ptr WCHAR + PCNZWCH* = ptr WCHAR + PUNZWCH* = ptr WCHAR + PCUNZWCH* = ptr WCHAR + LPCWCHAR* = ptr WCHAR + PCWCHAR* = ptr WCHAR + LPCUWCHAR* = ptr WCHAR + PCUWCHAR* = ptr WCHAR + PUCSCHAR* = ptr UCSCHAR + PCUCSCHAR* = ptr UCSCHAR + PUCSSTR* = ptr UCSCHAR + PUUCSSTR* = ptr UCSCHAR + PCUCSSTR* = ptr UCSCHAR + PCUUCSSTR* = ptr UCSCHAR + PUUCSCHAR* = ptr UCSCHAR + PCUUCSCHAR* = ptr UCSCHAR + PZZSTR* = ptr CHAR + PCZZSTR* = ptr CHAR + PNZCH* = ptr CHAR + PCNZCH* = ptr CHAR + KSPIN_LOCK* = ULONG_PTR + PACCESS_TOKEN* = PVOID + PSECURITY_DESCRIPTOR* = PVOID + PSID* = PVOID + PCLAIMS_BLOB* = PVOID + ACCESS_MASK* = DWORD + SID_HASH_ENTRY* = ULONG_PTR + PSID_HASH_ENTRY* = ptr ULONG_PTR + SECURITY_DESCRIPTOR_CONTROL* = WORD + PSECURITY_DESCRIPTOR_CONTROL* = ptr WORD + ACCESS_REASON* = DWORD + SECURITY_CONTEXT_TRACKING_MODE* = BOOLEAN + PSECURITY_CONTEXT_TRACKING_MODE* = ptr BOOLEAN + SECURITY_INFORMATION* = DWORD + PSECURITY_INFORMATION* = ptr DWORD + EXECUTION_STATE* = DWORD + PEXECUTION_STATE* = ptr DWORD + TP_VERSION* = DWORD + PTP_VERSION* = ptr DWORD + TP_WAIT_RESULT* = DWORD + NOTIFICATION_MASK* = ULONG + SAVEPOINT_ID* = ULONG + PSAVEPOINT_ID* = ptr ULONG + WPARAM* = UINT_PTR + LPARAM* = LONG_PTR + LRESULT* = LONG_PTR + SPHANDLE* = ptr HANDLE + LPHANDLE* = ptr HANDLE + HGLOBAL* = HANDLE + HLOCAL* = HANDLE + ATOM* = WORD + HINSTANCE* = HANDLE + HKEY* = HANDLE + HKL* = HANDLE + HLSURF* = HANDLE + HMETAFILE* = HANDLE + HMODULE* = HINSTANCE + HRGN* = HANDLE + HRSRC* = HANDLE + HSPRITE* = HANDLE + HSTR* = HANDLE + HTASK* = HANDLE + HWINSTA* = HANDLE + HWND* = HANDLE + HHOOK* = HANDLE + HEVENT* = HANDLE + HACCEL* = HANDLE + HBITMAP* = HANDLE + HBRUSH* = HANDLE + HCOLORSPACE* = HANDLE + HDC* = HANDLE + HGLRC* = HANDLE + HDESK* = HANDLE + HENHMETAFILE* = HANDLE + HFONT* = HANDLE + HICON* = HANDLE + HMENU* = HANDLE + HPALETTE* = HANDLE + HPEN* = HANDLE + HMONITOR* = HANDLE + HWINEVENTHOOK* = HANDLE + HCURSOR* = HICON + COLORREF* = DWORD + HUMPD* = HANDLE + LPCOLORREF* = ptr DWORD + DEVICE_TYPE* = ULONG + KPRIORITY* = LONG + HGDIOBJ* = HANDLE + OLECHAR* = WCHAR +when winimUnicode: + type + TCHAR* = WCHAR + PTCHAR* = ptr WCHAR + TBYTE* = WCHAR + PTBYTE* = ptr WCHAR + LPTCH* = LPWSTR + PTCH* = LPWSTR + PTSTR* = LPWSTR + LPTSTR* = LPWSTR + PCTSTR* = LPCWSTR + LPCTSTR* = LPCWSTR + PUTSTR* = LPUWSTR + LPUTSTR* = LPUWSTR + PCUTSTR* = LPCUWSTR + LPCUTSTR* = LPCUWSTR + LP* = LPWSTR + PZZTSTR* = PZZWSTR + PUZZTSTR* = PUZZWSTR + PZPTSTR* = PZPWSTR + PUNZTCH* = PUNZWCH +when winimAnsi: + type + LPTCH* = LPSTR + PTCH* = LPSTR + LPCTCH* = LPCCH + PCTCH* = LPCCH + PTSTR* = LPSTR + LPTSTR* = LPSTR + PUTSTR* = LPSTR + LPUTSTR* = LPSTR + PCTSTR* = LPCSTR + LPCTSTR* = LPCSTR + PCUTSTR* = LPCSTR + LPCUTSTR* = LPCSTR + PZZTSTR* = PZZSTR + PUZZTSTR* = PZZSTR + PZPTSTR* = PZPSTR +type + INT16* = int16 + PINT16* = ptr int16 + PKAFFINITY* = ptr KAFFINITY +const + EXCEPTION_MAXIMUM_PARAMETERS* = 15 +type + EXCEPTION_RECORD* {.pure.} = object + ExceptionCode*: DWORD + ExceptionFlags*: DWORD + ExceptionRecord*: ptr EXCEPTION_RECORD + ExceptionAddress*: PVOID + NumberParameters*: DWORD + ExceptionInformation*: array[EXCEPTION_MAXIMUM_PARAMETERS, ULONG_PTR] + PEXCEPTION_RECORD* = ptr EXCEPTION_RECORD + M128A* {.pure.} = object + Low*: ULONGLONG + High*: LONGLONG +when winimCpu64: + type + XMM_SAVE_AREA32* {.pure.} = object + ControlWord*: WORD + StatusWord*: WORD + TagWord*: BYTE + Reserved1*: BYTE + ErrorOpcode*: WORD + ErrorOffset*: DWORD + ErrorSelector*: WORD + Reserved2*: WORD + DataOffset*: DWORD + DataSelector*: WORD + Reserved3*: WORD + MxCsr*: DWORD + MxCsr_Mask*: DWORD + FloatRegisters*: array[8, M128A] + XmmRegisters*: array[16, M128A] + Reserved4*: array[96, BYTE] + CONTEXT_UNION1_STRUCT1* {.pure.} = object + Header*: array[2, M128A] + Legacy*: array[8, M128A] + Xmm0*: M128A + Xmm1*: M128A + Xmm2*: M128A + Xmm3*: M128A + Xmm4*: M128A + Xmm5*: M128A + Xmm6*: M128A + Xmm7*: M128A + Xmm8*: M128A + Xmm9*: M128A + Xmm10*: M128A + Xmm11*: M128A + Xmm12*: M128A + Xmm13*: M128A + Xmm14*: M128A + Xmm15*: M128A + CONTEXT_UNION1* {.pure, union.} = object + FltSave*: XMM_SAVE_AREA32 + FloatSave*: XMM_SAVE_AREA32 + struct1*: CONTEXT_UNION1_STRUCT1 + CONTEXT* {.pure.} = object + P1Home*: DWORD64 + P2Home*: DWORD64 + P3Home*: DWORD64 + P4Home*: DWORD64 + P5Home*: DWORD64 + P6Home*: DWORD64 + ContextFlags*: DWORD + MxCsr*: DWORD + SegCs*: WORD + SegDs*: WORD + SegEs*: WORD + SegFs*: WORD + SegGs*: WORD + SegSs*: WORD + EFlags*: DWORD + Dr0*: DWORD64 + Dr1*: DWORD64 + Dr2*: DWORD64 + Dr3*: DWORD64 + Dr6*: DWORD64 + Dr7*: DWORD64 + Rax*: DWORD64 + Rcx*: DWORD64 + Rdx*: DWORD64 + Rbx*: DWORD64 + Rsp*: DWORD64 + Rbp*: DWORD64 + Rsi*: DWORD64 + Rdi*: DWORD64 + R8*: DWORD64 + R9*: DWORD64 + R10*: DWORD64 + R11*: DWORD64 + R12*: DWORD64 + R13*: DWORD64 + R14*: DWORD64 + R15*: DWORD64 + Rip*: DWORD64 + union1*: CONTEXT_UNION1 + VectorRegister*: array[26, M128A] + VectorControl*: DWORD64 + DebugControl*: DWORD64 + LastBranchToRip*: DWORD64 + LastBranchFromRip*: DWORD64 + LastExceptionToRip*: DWORD64 + LastExceptionFromRip*: DWORD64 +when winimCpu32: + const + SIZE_OF_80387_REGISTERS* = 80 + type + FLOATING_SAVE_AREA* {.pure.} = object + ControlWord*: DWORD + StatusWord*: DWORD + TagWord*: DWORD + ErrorOffset*: DWORD + ErrorSelector*: DWORD + DataOffset*: DWORD + DataSelector*: DWORD + RegisterArea*: array[SIZE_OF_80387_REGISTERS, BYTE] + Cr0NpxState*: DWORD + const + MAXIMUM_SUPPORTED_EXTENSION* = 512 + type + CONTEXT* {.pure.} = object + ContextFlags*: DWORD + Dr0*: DWORD + Dr1*: DWORD + Dr2*: DWORD + Dr3*: DWORD + Dr6*: DWORD + Dr7*: DWORD + FloatSave*: FLOATING_SAVE_AREA + SegGs*: DWORD + SegFs*: DWORD + SegEs*: DWORD + SegDs*: DWORD + Edi*: DWORD + Esi*: DWORD + Ebx*: DWORD + Edx*: DWORD + Ecx*: DWORD + Eax*: DWORD + Ebp*: DWORD + Eip*: DWORD + SegCs*: DWORD + EFlags*: DWORD + Esp*: DWORD + SegSs*: DWORD + ExtendedRegisters*: array[MAXIMUM_SUPPORTED_EXTENSION, BYTE] +when winimCpu64: + type + PCONTEXT* = ptr CONTEXT +when winimCpu32: + type + PCONTEXT* = ptr CONTEXT +type + EXCEPTION_POINTERS* {.pure.} = object + ExceptionRecord*: PEXCEPTION_RECORD + ContextRecord*: PCONTEXT + Exception_info_ptr* = ptr EXCEPTION_POINTERS + DOUBLE* = float64 + PNTSTATUS* = ptr NTSTATUS + CSHORT* = int16 + PCSHORT* = ptr int16 + QUAD_UNION1* {.pure, union.} = object + UseThisFieldToCopy*: int64 + DoNotUseThisField*: float64 + QUAD* {.pure.} = object + union1*: QUAD_UNION1 + PQUAD* = ptr QUAD + UQUAD* = QUAD + PUQUAD* = ptr QUAD + LARGE_INTEGER_STRUCT1* {.pure.} = object + LowPart*: ULONG + HighPart*: LONG + LARGE_INTEGER_u* {.pure.} = object + LowPart*: ULONG + HighPart*: LONG + LARGE_INTEGER* {.pure, union.} = object + struct1*: LARGE_INTEGER_STRUCT1 + u*: LARGE_INTEGER_u + QuadPart*: LONGLONG + PLARGE_INTEGER* = ptr LARGE_INTEGER + ULARGE_INTEGER_STRUCT1* {.pure.} = object + LowPart*: ULONG + HighPart*: ULONG + ULARGE_INTEGER_u* {.pure.} = object + LowPart*: ULONG + HighPart*: ULONG + ULARGE_INTEGER* {.pure, union.} = object + struct1*: ULARGE_INTEGER_STRUCT1 + u*: ULARGE_INTEGER_u + QuadPart*: ULONGLONG + PULARGE_INTEGER* = ptr ULARGE_INTEGER + LUID* {.pure.} = object + LowPart*: ULONG + HighPart*: LONG + PLUID* = ptr LUID + PHYSICAL_ADDRESS* = LARGE_INTEGER + PPHYSICAL_ADDRESS* = ptr LARGE_INTEGER + UNICODE_STRING* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Buffer*: PWSTR + PUNICODE_STRING* = ptr UNICODE_STRING + PCUNICODE_STRING* = ptr UNICODE_STRING + CSTRING* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Buffer*: ptr CHAR + PCSTRING* = ptr CSTRING + STRING* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Buffer*: PCHAR + PSTRING* = ptr STRING + ANSI_STRING* = STRING + PANSI_STRING* = PSTRING + OEM_STRING* = STRING + POEM_STRING* = PSTRING + PCOEM_STRING* = ptr STRING + CANSI_STRING* = STRING + PCANSI_STRING* = PSTRING + STRING32* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Buffer*: ULONG + PSTRING32* = ptr STRING32 + UNICODE_STRING32* = STRING32 + PUNICODE_STRING32* = ptr STRING32 + ANSI_STRING32* = STRING32 + PANSI_STRING32* = ptr STRING32 + STRING64* {.pure.} = object + Length*: USHORT + MaximumLength*: USHORT + Buffer*: ULONGLONG + PSTRING64* = ptr STRING64 + UNICODE_STRING64* = STRING64 + PUNICODE_STRING64* = ptr STRING64 + ANSI_STRING64* = STRING64 + PANSI_STRING64* = ptr STRING64 + OBJECT_ATTRIBUTES* {.pure.} = object + Length*: ULONG + RootDirectory*: HANDLE + ObjectName*: PUNICODE_STRING + Attributes*: ULONG + SecurityDescriptor*: PVOID + SecurityQualityOfService*: PVOID + POBJECT_ATTRIBUTES* = ptr OBJECT_ATTRIBUTES + PCOBJECT_ATTRIBUTES* = ptr OBJECT_ATTRIBUTES + LIST_ENTRY* {.pure.} = object + Flink*: ptr LIST_ENTRY + Blink*: ptr LIST_ENTRY + PLIST_ENTRY* = ptr LIST_ENTRY + PRLIST_ENTRY* = ptr LIST_ENTRY + LIST_ENTRY32* {.pure.} = object + Flink*: ULONG + Blink*: ULONG + PLIST_ENTRY32* = ptr LIST_ENTRY32 + LIST_ENTRY64* {.pure.} = object + Flink*: ULONGLONG + Blink*: ULONGLONG + PLIST_ENTRY64* = ptr LIST_ENTRY64 + SINGLE_LIST_ENTRY* {.pure.} = object + Next*: ptr SINGLE_LIST_ENTRY + PSINGLE_LIST_ENTRY* = ptr SINGLE_LIST_ENTRY + PROCESSOR_NUMBER* {.pure.} = object + Group*: USHORT + Number*: UCHAR + Reserved*: UCHAR + PPROCESSOR_NUMBER* = ptr PROCESSOR_NUMBER + GROUP_AFFINITY* {.pure.} = object + Mask*: KAFFINITY + Group*: USHORT + Reserved*: array[3, USHORT] + PGROUP_AFFINITY* = ptr GROUP_AFFINITY + REPARSE_DATA_BUFFER_UNION1_SymbolicLinkReparseBuffer* {.pure.} = object + SubstituteNameOffset*: USHORT + SubstituteNameLength*: USHORT + PrintNameOffset*: USHORT + PrintNameLength*: USHORT + Flags*: ULONG + PathBuffer*: array[1, WCHAR] + REPARSE_DATA_BUFFER_UNION1_MountPointReparseBuffer* {.pure.} = object + SubstituteNameOffset*: USHORT + SubstituteNameLength*: USHORT + PrintNameOffset*: USHORT + PrintNameLength*: USHORT + PathBuffer*: array[1, WCHAR] + REPARSE_DATA_BUFFER_UNION1_GenericReparseBuffer* {.pure.} = object + DataBuffer*: array[1, UCHAR] + REPARSE_DATA_BUFFER_UNION1* {.pure, union.} = object + SymbolicLinkReparseBuffer*: REPARSE_DATA_BUFFER_UNION1_SymbolicLinkReparseBuffer + MountPointReparseBuffer*: REPARSE_DATA_BUFFER_UNION1_MountPointReparseBuffer + GenericReparseBuffer*: REPARSE_DATA_BUFFER_UNION1_GenericReparseBuffer + REPARSE_DATA_BUFFER* {.pure.} = object + ReparseTag*: ULONG + ReparseDataLength*: USHORT + Reserved*: USHORT + union1*: REPARSE_DATA_BUFFER_UNION1 + PREPARSE_DATA_BUFFER* = ptr REPARSE_DATA_BUFFER + FLOAT128* {.pure.} = object + LowPart*: int64 + HighPart*: int64 + PFLOAT128* = ptr FLOAT128 + GUID* {.pure.} = object + Data1*: int32 + Data2*: uint16 + Data3*: uint16 + Data4*: array[8, uint8] + LPGUID* = ptr GUID + LPCGUID* = ptr GUID + IID* = GUID + LPIID* = ptr IID + CLSID* = GUID + LPCLSID* = ptr CLSID + FMTID* = GUID + LPFMTID* = ptr FMTID + REFGUID* = ptr GUID + REFIID* = ptr IID + REFCLSID* = ptr IID + REFFMTID* = ptr IID + EXCEPTION_ROUTINE* = proc (ExceptionRecord: ptr EXCEPTION_RECORD, EstablisherFrame: PVOID, ContextRecord: ptr CONTEXT, DispatcherContext: PVOID): EXCEPTION_DISPOSITION {.stdcall.} + PEXCEPTION_ROUTINE* = EXCEPTION_ROUTINE + PKSPIN_LOCK* = ptr KSPIN_LOCK + PM128A* = ptr M128A + XSAVE_AREA_HEADER* {.pure.} = object + Mask*: DWORD64 + Reserved*: array[7, DWORD64] + PXSAVE_AREA_HEADER* = ptr XSAVE_AREA_HEADER +when winimCpu64: + type + XSAVE_FORMAT* {.pure.} = object + ControlWord*: WORD + StatusWord*: WORD + TagWord*: BYTE + Reserved1*: BYTE + ErrorOpcode*: WORD + ErrorOffset*: DWORD + ErrorSelector*: WORD + Reserved2*: WORD + DataOffset*: DWORD + DataSelector*: WORD + Reserved3*: WORD + MxCsr*: DWORD + MxCsr_Mask*: DWORD + FloatRegisters*: array[8, M128A] + XmmRegisters*: array[16, M128A] + Reserved4*: array[96, BYTE] +when winimCpu32: + type + XSAVE_FORMAT* {.pure.} = object + ControlWord*: WORD + StatusWord*: WORD + TagWord*: BYTE + Reserved1*: BYTE + ErrorOpcode*: WORD + ErrorOffset*: DWORD + ErrorSelector*: WORD + Reserved2*: WORD + DataOffset*: DWORD + DataSelector*: WORD + Reserved3*: WORD + MxCsr*: DWORD + MxCsr_Mask*: DWORD + FloatRegisters*: array[8, M128A] + XmmRegisters*: array[8, M128A] + Reserved4*: array[220, BYTE] + Cr0NpxState*: DWORD +type + XSAVE_AREA* {.pure.} = object + LegacyState*: XSAVE_FORMAT + Header*: XSAVE_AREA_HEADER + PXSAVE_AREA* = ptr XSAVE_AREA + SCOPE_TABLE_AMD64_ScopeRecord* {.pure.} = object + BeginAddress*: DWORD + EndAddress*: DWORD + HandlerAddress*: DWORD + JumpTarget*: DWORD + SCOPE_TABLE_AMD64* {.pure.} = object + Count*: DWORD + ScopeRecord*: array[1, SCOPE_TABLE_AMD64_ScopeRecord] + PSCOPE_TABLE_AMD64* = ptr SCOPE_TABLE_AMD64 + LDT_ENTRY_HighWord_Bytes* {.pure.} = object + BaseMid*: BYTE + Flags1*: BYTE + Flags2*: BYTE + BaseHi*: BYTE + LDT_ENTRY_HighWord_Bits* {.pure.} = object + BaseMid* {.bitsize:8.}: DWORD + Type* {.bitsize:5.}: DWORD + Dpl* {.bitsize:2.}: DWORD + Pres* {.bitsize:1.}: DWORD + LimitHi* {.bitsize:4.}: DWORD + Sys* {.bitsize:1.}: DWORD + Reserved_0* {.bitsize:1.}: DWORD + Default_Big* {.bitsize:1.}: DWORD + Granularity* {.bitsize:1.}: DWORD + BaseHi* {.bitsize:8.}: DWORD + LDT_ENTRY_HighWord* {.pure, union.} = object + Bytes*: LDT_ENTRY_HighWord_Bytes + Bits*: LDT_ENTRY_HighWord_Bits + LDT_ENTRY* {.pure.} = object + LimitLow*: WORD + BaseLow*: WORD + HighWord*: LDT_ENTRY_HighWord + PLDT_ENTRY* = ptr LDT_ENTRY + EXCEPTION_RECORD32* {.pure.} = object + ExceptionCode*: DWORD + ExceptionFlags*: DWORD + ExceptionRecord*: DWORD + ExceptionAddress*: DWORD + NumberParameters*: DWORD + ExceptionInformation*: array[EXCEPTION_MAXIMUM_PARAMETERS, DWORD] + PEXCEPTION_RECORD32* = ptr EXCEPTION_RECORD32 + EXCEPTION_RECORD64* {.pure.} = object + ExceptionCode*: DWORD + ExceptionFlags*: DWORD + ExceptionRecord*: DWORD64 + ExceptionAddress*: DWORD64 + NumberParameters*: DWORD + unusedAlignment*: DWORD + ExceptionInformation*: array[EXCEPTION_MAXIMUM_PARAMETERS, DWORD64] + PEXCEPTION_RECORD64* = ptr EXCEPTION_RECORD64 + PEXCEPTION_POINTERS* = ptr EXCEPTION_POINTERS + PACCESS_MASK* = ptr ACCESS_MASK + GENERIC_MAPPING* {.pure.} = object + GenericRead*: ACCESS_MASK + GenericWrite*: ACCESS_MASK + GenericExecute*: ACCESS_MASK + GenericAll*: ACCESS_MASK + PGENERIC_MAPPING* = ptr GENERIC_MAPPING + LUID_AND_ATTRIBUTES* {.pure.} = object + Luid*: LUID + Attributes*: DWORD + PLUID_AND_ATTRIBUTES* = ptr LUID_AND_ATTRIBUTES +const + ANYSIZE_ARRAY* = 1 +type + LUID_AND_ATTRIBUTES_ARRAY* = array[ANYSIZE_ARRAY, LUID_AND_ATTRIBUTES] + PLUID_AND_ATTRIBUTES_ARRAY* = ptr LUID_AND_ATTRIBUTES_ARRAY + SID_IDENTIFIER_AUTHORITY* {.pure.} = object + Value*: array[6, BYTE] + PSID_IDENTIFIER_AUTHORITY* = ptr SID_IDENTIFIER_AUTHORITY + SID* {.pure.} = object + Revision*: BYTE + SubAuthorityCount*: BYTE + IdentifierAuthority*: SID_IDENTIFIER_AUTHORITY + SubAuthority*: array[ANYSIZE_ARRAY, DWORD] + PISID* = ptr SID + SID_AND_ATTRIBUTES* {.pure.} = object + Sid*: PSID + Attributes*: DWORD + PSID_AND_ATTRIBUTES* = ptr SID_AND_ATTRIBUTES + SID_AND_ATTRIBUTES_ARRAY* = array[ANYSIZE_ARRAY, SID_AND_ATTRIBUTES] + PSID_AND_ATTRIBUTES_ARRAY* = ptr SID_AND_ATTRIBUTES_ARRAY +const + SID_HASH_SIZE* = 32 +type + SID_AND_ATTRIBUTES_HASH* {.pure.} = object + SidCount*: DWORD + SidAttr*: PSID_AND_ATTRIBUTES + Hash*: array[SID_HASH_SIZE, SID_HASH_ENTRY] + PSID_AND_ATTRIBUTES_HASH* = ptr SID_AND_ATTRIBUTES_HASH + ACL* {.pure.} = object + AclRevision*: BYTE + Sbz1*: BYTE + AclSize*: WORD + AceCount*: WORD + Sbz2*: WORD + PACL* = ptr ACL + ACE_HEADER* {.pure.} = object + AceType*: BYTE + AceFlags*: BYTE + AceSize*: WORD + PACE_HEADER* = ptr ACE_HEADER + ACCESS_ALLOWED_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PACCESS_ALLOWED_ACE* = ptr ACCESS_ALLOWED_ACE + ACCESS_DENIED_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PACCESS_DENIED_ACE* = ptr ACCESS_DENIED_ACE + SYSTEM_AUDIT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_AUDIT_ACE* = ptr SYSTEM_AUDIT_ACE + SYSTEM_ALARM_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_ALARM_ACE* = ptr SYSTEM_ALARM_ACE + SYSTEM_RESOURCE_ATTRIBUTE_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_RESOURCE_ATTRIBUTE_ACE* = ptr SYSTEM_RESOURCE_ATTRIBUTE_ACE + SYSTEM_SCOPED_POLICY_ID_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_SCOPED_POLICY_ID_ACE* = ptr SYSTEM_SCOPED_POLICY_ID_ACE + SYSTEM_MANDATORY_LABEL_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_MANDATORY_LABEL_ACE* = ptr SYSTEM_MANDATORY_LABEL_ACE + ACCESS_ALLOWED_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PACCESS_ALLOWED_OBJECT_ACE* = ptr ACCESS_ALLOWED_OBJECT_ACE + ACCESS_DENIED_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PACCESS_DENIED_OBJECT_ACE* = ptr ACCESS_DENIED_OBJECT_ACE + SYSTEM_AUDIT_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PSYSTEM_AUDIT_OBJECT_ACE* = ptr SYSTEM_AUDIT_OBJECT_ACE + SYSTEM_ALARM_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PSYSTEM_ALARM_OBJECT_ACE* = ptr SYSTEM_ALARM_OBJECT_ACE + ACCESS_ALLOWED_CALLBACK_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PACCESS_ALLOWED_CALLBACK_ACE* = ptr ACCESS_ALLOWED_CALLBACK_ACE + ACCESS_DENIED_CALLBACK_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PACCESS_DENIED_CALLBACK_ACE* = ptr ACCESS_DENIED_CALLBACK_ACE + SYSTEM_AUDIT_CALLBACK_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_AUDIT_CALLBACK_ACE* = ptr SYSTEM_AUDIT_CALLBACK_ACE + SYSTEM_ALARM_CALLBACK_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + SidStart*: DWORD + PSYSTEM_ALARM_CALLBACK_ACE* = ptr SYSTEM_ALARM_CALLBACK_ACE + ACCESS_ALLOWED_CALLBACK_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PACCESS_ALLOWED_CALLBACK_OBJECT_ACE* = ptr ACCESS_ALLOWED_CALLBACK_OBJECT_ACE + ACCESS_DENIED_CALLBACK_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PACCESS_DENIED_CALLBACK_OBJECT_ACE* = ptr ACCESS_DENIED_CALLBACK_OBJECT_ACE + SYSTEM_AUDIT_CALLBACK_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE* = ptr SYSTEM_AUDIT_CALLBACK_OBJECT_ACE + SYSTEM_ALARM_CALLBACK_OBJECT_ACE* {.pure.} = object + Header*: ACE_HEADER + Mask*: ACCESS_MASK + Flags*: DWORD + ObjectType*: GUID + InheritedObjectType*: GUID + SidStart*: DWORD + PSYSTEM_ALARM_CALLBACK_OBJECT_ACE* = ptr SYSTEM_ALARM_CALLBACK_OBJECT_ACE + ACL_REVISION_INFORMATION* {.pure.} = object + AclRevision*: DWORD + PACL_REVISION_INFORMATION* = ptr ACL_REVISION_INFORMATION + ACL_SIZE_INFORMATION* {.pure.} = object + AceCount*: DWORD + AclBytesInUse*: DWORD + AclBytesFree*: DWORD + PACL_SIZE_INFORMATION* = ptr ACL_SIZE_INFORMATION + SECURITY_DESCRIPTOR_RELATIVE* {.pure.} = object + Revision*: BYTE + Sbz1*: BYTE + Control*: SECURITY_DESCRIPTOR_CONTROL + Owner*: DWORD + Group*: DWORD + Sacl*: DWORD + Dacl*: DWORD + PISECURITY_DESCRIPTOR_RELATIVE* = ptr SECURITY_DESCRIPTOR_RELATIVE + SECURITY_DESCRIPTOR* {.pure.} = object + Revision*: BYTE + Sbz1*: BYTE + Control*: SECURITY_DESCRIPTOR_CONTROL + Owner*: PSID + Group*: PSID + Sacl*: PACL + Dacl*: PACL + PISECURITY_DESCRIPTOR* = ptr SECURITY_DESCRIPTOR + OBJECT_TYPE_LIST* {.pure.} = object + Level*: WORD + Sbz*: WORD + ObjectType*: ptr GUID + POBJECT_TYPE_LIST* = ptr OBJECT_TYPE_LIST + PRIVILEGE_SET* {.pure.} = object + PrivilegeCount*: DWORD + Control*: DWORD + Privilege*: array[ANYSIZE_ARRAY, LUID_AND_ATTRIBUTES] + PPRIVILEGE_SET* = ptr PRIVILEGE_SET + ACCESS_REASONS* {.pure.} = object + Data*: array[32, ACCESS_REASON] + PACCESS_REASONS* = ptr ACCESS_REASONS + SE_SECURITY_DESCRIPTOR* {.pure.} = object + Size*: DWORD + Flags*: DWORD + SecurityDescriptor*: PSECURITY_DESCRIPTOR + PSE_SECURITY_DESCRIPTOR* = ptr SE_SECURITY_DESCRIPTOR + SE_ACCESS_REQUEST* {.pure.} = object + Size*: DWORD + SeSecurityDescriptor*: PSE_SECURITY_DESCRIPTOR + DesiredAccess*: ACCESS_MASK + PreviouslyGrantedAccess*: ACCESS_MASK + PrincipalSelfSid*: PSID + GenericMapping*: PGENERIC_MAPPING + ObjectTypeListCount*: DWORD + ObjectTypeList*: POBJECT_TYPE_LIST + PSE_ACCESS_REQUEST* = ptr SE_ACCESS_REQUEST + SE_ACCESS_REPLY* {.pure.} = object + Size*: DWORD + ResultListCount*: DWORD + GrantedAccess*: PACCESS_MASK + AccessStatus*: PDWORD + AccessReason*: PACCESS_REASONS + Privileges*: ptr PPRIVILEGE_SET + PSE_ACCESS_REPLY* = ptr SE_ACCESS_REPLY + PTOKEN_TYPE* = ptr TOKEN_TYPE + TOKEN_USER* {.pure.} = object + User*: SID_AND_ATTRIBUTES + PTOKEN_USER* = ptr TOKEN_USER + TOKEN_GROUPS* {.pure.} = object + GroupCount*: DWORD + Groups*: array[ANYSIZE_ARRAY, SID_AND_ATTRIBUTES] + PTOKEN_GROUPS* = ptr TOKEN_GROUPS + TOKEN_PRIVILEGES* {.pure.} = object + PrivilegeCount*: DWORD + Privileges*: array[ANYSIZE_ARRAY, LUID_AND_ATTRIBUTES] + PTOKEN_PRIVILEGES* = ptr TOKEN_PRIVILEGES + TOKEN_OWNER* {.pure.} = object + Owner*: PSID + PTOKEN_OWNER* = ptr TOKEN_OWNER + TOKEN_PRIMARY_GROUP* {.pure.} = object + PrimaryGroup*: PSID + PTOKEN_PRIMARY_GROUP* = ptr TOKEN_PRIMARY_GROUP + TOKEN_DEFAULT_DACL* {.pure.} = object + DefaultDacl*: PACL + PTOKEN_DEFAULT_DACL* = ptr TOKEN_DEFAULT_DACL + TOKEN_USER_CLAIMS* {.pure.} = object + UserClaims*: PCLAIMS_BLOB + PTOKEN_USER_CLAIMS* = ptr TOKEN_USER_CLAIMS + TOKEN_DEVICE_CLAIMS* {.pure.} = object + DeviceClaims*: PCLAIMS_BLOB + PTOKEN_DEVICE_CLAIMS* = ptr TOKEN_DEVICE_CLAIMS + TOKEN_GROUPS_AND_PRIVILEGES* {.pure.} = object + SidCount*: DWORD + SidLength*: DWORD + Sids*: PSID_AND_ATTRIBUTES + RestrictedSidCount*: DWORD + RestrictedSidLength*: DWORD + RestrictedSids*: PSID_AND_ATTRIBUTES + PrivilegeCount*: DWORD + PrivilegeLength*: DWORD + Privileges*: PLUID_AND_ATTRIBUTES + AuthenticationId*: LUID + PTOKEN_GROUPS_AND_PRIVILEGES* = ptr TOKEN_GROUPS_AND_PRIVILEGES + TOKEN_LINKED_TOKEN* {.pure.} = object + LinkedToken*: HANDLE + PTOKEN_LINKED_TOKEN* = ptr TOKEN_LINKED_TOKEN + TOKEN_ELEVATION* {.pure.} = object + TokenIsElevated*: DWORD + PTOKEN_ELEVATION* = ptr TOKEN_ELEVATION + TOKEN_MANDATORY_LABEL* {.pure.} = object + Label*: SID_AND_ATTRIBUTES + PTOKEN_MANDATORY_LABEL* = ptr TOKEN_MANDATORY_LABEL + TOKEN_MANDATORY_POLICY* {.pure.} = object + Policy*: DWORD + PTOKEN_MANDATORY_POLICY* = ptr TOKEN_MANDATORY_POLICY + TOKEN_ACCESS_INFORMATION* {.pure.} = object + SidHash*: PSID_AND_ATTRIBUTES_HASH + RestrictedSidHash*: PSID_AND_ATTRIBUTES_HASH + Privileges*: PTOKEN_PRIVILEGES + AuthenticationId*: LUID + TokenType*: TOKEN_TYPE + ImpersonationLevel*: SECURITY_IMPERSONATION_LEVEL + MandatoryPolicy*: TOKEN_MANDATORY_POLICY + Flags*: DWORD + AppContainerNumber*: DWORD + PackageSid*: PSID + CapabilitiesHash*: PSID_AND_ATTRIBUTES_HASH + PTOKEN_ACCESS_INFORMATION* = ptr TOKEN_ACCESS_INFORMATION +const + POLICY_AUDIT_SUBCATEGORY_COUNT* = 56 +type + TOKEN_AUDIT_POLICY* {.pure.} = object + PerUserPolicy*: array[((POLICY_AUDIT_SUBCATEGORY_COUNT) shr 1) + 1, UCHAR] + PTOKEN_AUDIT_POLICY* = ptr TOKEN_AUDIT_POLICY +const + TOKEN_SOURCE_LENGTH* = 8 +type + TOKEN_SOURCE* {.pure.} = object + SourceName*: array[TOKEN_SOURCE_LENGTH, CHAR] + SourceIdentifier*: LUID + PTOKEN_SOURCE* = ptr TOKEN_SOURCE + TOKEN_STATISTICS* {.pure.} = object + TokenId*: LUID + AuthenticationId*: LUID + ExpirationTime*: LARGE_INTEGER + TokenType*: TOKEN_TYPE + ImpersonationLevel*: SECURITY_IMPERSONATION_LEVEL + DynamicCharged*: DWORD + DynamicAvailable*: DWORD + GroupCount*: DWORD + PrivilegeCount*: DWORD + ModifiedId*: LUID + PTOKEN_STATISTICS* = ptr TOKEN_STATISTICS + TOKEN_CONTROL* {.pure.} = object + TokenId*: LUID + AuthenticationId*: LUID + ModifiedId*: LUID + TokenSource*: TOKEN_SOURCE + PTOKEN_CONTROL* = ptr TOKEN_CONTROL + TOKEN_ORIGIN* {.pure.} = object + OriginatingLogonSession*: LUID + PTOKEN_ORIGIN* = ptr TOKEN_ORIGIN + TOKEN_APPCONTAINER_INFORMATION* {.pure.} = object + TokenAppContainer*: PSID + PTOKEN_APPCONTAINER_INFORMATION* = ptr TOKEN_APPCONTAINER_INFORMATION + CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE* {.pure.} = object + Version*: DWORD64 + Name*: PWSTR + PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE* = ptr CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE + CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE* {.pure.} = object + pValue*: PVOID + ValueLength*: DWORD + PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE* = ptr CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + CLAIM_SECURITY_ATTRIBUTE_V1_Values* {.pure, union.} = object + pInt64*: PLONG64 + pUint64*: PDWORD64 + ppString*: ptr PWSTR + pFqbn*: PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE + pOctetString*: PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + CLAIM_SECURITY_ATTRIBUTE_V1* {.pure.} = object + Name*: PWSTR + ValueType*: WORD + Reserved*: WORD + Flags*: DWORD + ValueCount*: DWORD + Values*: CLAIM_SECURITY_ATTRIBUTE_V1_Values + PCLAIM_SECURITY_ATTRIBUTE_V1* = ptr CLAIM_SECURITY_ATTRIBUTE_V1 + CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_Values* {.pure, union.} = object + pInt64*: array[ANYSIZE_ARRAY, DWORD] + pUint64*: array[ANYSIZE_ARRAY, DWORD] + ppString*: array[ANYSIZE_ARRAY, DWORD] + pFqbn*: array[ANYSIZE_ARRAY, DWORD] + pOctetString*: array[ANYSIZE_ARRAY, DWORD] + CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1* {.pure.} = object + Name*: DWORD + ValueType*: WORD + Reserved*: WORD + Flags*: DWORD + ValueCount*: DWORD + Values*: CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_Values + PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1* = ptr CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 + CLAIM_SECURITY_ATTRIBUTES_INFORMATION_Attribute* {.pure, union.} = object + pAttributeV1*: PCLAIM_SECURITY_ATTRIBUTE_V1 + CLAIM_SECURITY_ATTRIBUTES_INFORMATION* {.pure.} = object + Version*: WORD + Reserved*: WORD + AttributeCount*: DWORD + Attribute*: CLAIM_SECURITY_ATTRIBUTES_INFORMATION_Attribute + PCLAIM_SECURITY_ATTRIBUTES_INFORMATION* = ptr CLAIM_SECURITY_ATTRIBUTES_INFORMATION + SECURITY_QUALITY_OF_SERVICE* {.pure.} = object + Length*: DWORD + ImpersonationLevel*: SECURITY_IMPERSONATION_LEVEL + ContextTrackingMode*: SECURITY_CONTEXT_TRACKING_MODE + EffectiveOnly*: BOOLEAN + PSECURITY_QUALITY_OF_SERVICE* = ptr SECURITY_QUALITY_OF_SERVICE + SE_IMPERSONATION_STATE* {.pure.} = object + Token*: PACCESS_TOKEN + CopyOnOpen*: BOOLEAN + EffectiveOnly*: BOOLEAN + Level*: SECURITY_IMPERSONATION_LEVEL + PSE_IMPERSONATION_STATE* = ptr SE_IMPERSONATION_STATE + SECURITY_CAPABILITIES* {.pure.} = object + AppContainerSid*: PSID + Capabilities*: PSID_AND_ATTRIBUTES + CapabilityCount*: DWORD + Reserved*: DWORD + PSECURITY_CAPABILITIES* = ptr SECURITY_CAPABILITIES + LPSECURITY_CAPABILITIES* = ptr SECURITY_CAPABILITIES + JOB_SET_ARRAY* {.pure.} = object + JobHandle*: HANDLE + MemberLevel*: DWORD + Flags*: DWORD + PJOB_SET_ARRAY* = ptr JOB_SET_ARRAY + EXCEPTION_REGISTRATION_RECORD* {.pure.} = object + NT_TIB_UNION1* {.pure, union.} = object + FiberData*: PVOID + Version*: DWORD + NT_TIB* {.pure.} = object + ExceptionList*: ptr EXCEPTION_REGISTRATION_RECORD + StackBase*: PVOID + StackLimit*: PVOID + SubSystemTib*: PVOID + union1*: NT_TIB_UNION1 + ArbitraryUserPointer*: PVOID + Self*: ptr NT_TIB + PNT_TIB* = ptr NT_TIB + NT_TIB32_UNION1* {.pure, union.} = object + FiberData*: DWORD + Version*: DWORD + NT_TIB32* {.pure.} = object + ExceptionList*: DWORD + StackBase*: DWORD + StackLimit*: DWORD + SubSystemTib*: DWORD + union1*: NT_TIB32_UNION1 + ArbitraryUserPointer*: DWORD + Self*: DWORD + PNT_TIB32* = ptr NT_TIB32 + NT_TIB64_UNION1* {.pure, union.} = object + FiberData*: DWORD64 + Version*: DWORD + NT_TIB64* {.pure.} = object + ExceptionList*: DWORD64 + StackBase*: DWORD64 + StackLimit*: DWORD64 + SubSystemTib*: DWORD64 + union1*: NT_TIB64_UNION1 + ArbitraryUserPointer*: DWORD64 + Self*: DWORD64 + PNT_TIB64* = ptr NT_TIB64 + UMS_CREATE_THREAD_ATTRIBUTES* {.pure.} = object + UmsVersion*: DWORD + UmsContext*: PVOID + UmsCompletionList*: PVOID + PUMS_CREATE_THREAD_ATTRIBUTES* = ptr UMS_CREATE_THREAD_ATTRIBUTES + QUOTA_LIMITS* {.pure.} = object + PagedPoolLimit*: SIZE_T + NonPagedPoolLimit*: SIZE_T + MinimumWorkingSetSize*: SIZE_T + MaximumWorkingSetSize*: SIZE_T + PagefileLimit*: SIZE_T + TimeLimit*: LARGE_INTEGER + PQUOTA_LIMITS* = ptr QUOTA_LIMITS + RATE_QUOTA_LIMIT_STRUCT1* {.pure.} = object + RatePercent* {.bitsize:7.}: DWORD + Reserved0* {.bitsize:25.}: DWORD + RATE_QUOTA_LIMIT* {.pure, union.} = object + RateData*: DWORD + struct1*: RATE_QUOTA_LIMIT_STRUCT1 + PRATE_QUOTA_LIMIT* = ptr RATE_QUOTA_LIMIT + QUOTA_LIMITS_EX* {.pure.} = object + PagedPoolLimit*: SIZE_T + NonPagedPoolLimit*: SIZE_T + MinimumWorkingSetSize*: SIZE_T + MaximumWorkingSetSize*: SIZE_T + PagefileLimit*: SIZE_T + TimeLimit*: LARGE_INTEGER + WorkingSetLimit*: SIZE_T + Reserved2*: SIZE_T + Reserved3*: SIZE_T + Reserved4*: SIZE_T + Flags*: DWORD + CpuRateLimit*: RATE_QUOTA_LIMIT + PQUOTA_LIMITS_EX* = ptr QUOTA_LIMITS_EX + IO_COUNTERS* {.pure.} = object + ReadOperationCount*: ULONGLONG + WriteOperationCount*: ULONGLONG + OtherOperationCount*: ULONGLONG + ReadTransferCount*: ULONGLONG + WriteTransferCount*: ULONGLONG + OtherTransferCount*: ULONGLONG + PIO_COUNTERS* = ptr IO_COUNTERS + PROCESS_MITIGATION_ASLR_POLICY_UNION1_STRUCT1* {.pure.} = object + EnableBottomUpRandomization* {.bitsize:1.}: DWORD + EnableForceRelocateImages* {.bitsize:1.}: DWORD + EnableHighEntropy* {.bitsize:1.}: DWORD + DisallowStrippedImages* {.bitsize:1.}: DWORD + ReservedFlags* {.bitsize:28.}: DWORD + PROCESS_MITIGATION_ASLR_POLICY_UNION1* {.pure, union.} = object + Flags*: DWORD + struct1*: PROCESS_MITIGATION_ASLR_POLICY_UNION1_STRUCT1 + PROCESS_MITIGATION_ASLR_POLICY* {.pure.} = object + union1*: PROCESS_MITIGATION_ASLR_POLICY_UNION1 + PPROCESS_MITIGATION_ASLR_POLICY* = ptr PROCESS_MITIGATION_ASLR_POLICY + PROCESS_MITIGATION_DEP_POLICY_UNION1_STRUCT1* {.pure.} = object + Enable* {.bitsize:1.}: DWORD + DisableAtlThunkEmulation* {.bitsize:1.}: DWORD + ReservedFlags* {.bitsize:30.}: DWORD + PROCESS_MITIGATION_DEP_POLICY_UNION1* {.pure, union.} = object + Flags*: DWORD + struct1*: PROCESS_MITIGATION_DEP_POLICY_UNION1_STRUCT1 + PROCESS_MITIGATION_DEP_POLICY* {.pure.} = object + union1*: PROCESS_MITIGATION_DEP_POLICY_UNION1 + Permanent*: BOOLEAN + PPROCESS_MITIGATION_DEP_POLICY* = ptr PROCESS_MITIGATION_DEP_POLICY + PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION1_STRUCT1* {.pure.} = object + RaiseExceptionOnInvalidHandleReference* {.bitsize:1.}: DWORD + HandleExceptionsPermanentlyEnabled* {.bitsize:1.}: DWORD + ReservedFlags* {.bitsize:30.}: DWORD + PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION1* {.pure, union.} = object + Flags*: DWORD + struct1*: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION1_STRUCT1 + PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY* {.pure.} = object + union1*: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION1 + PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY* = ptr PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY + PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION1_STRUCT1* {.pure.} = object + DisallowWin32kSystemCalls* {.bitsize:1.}: DWORD + ReservedFlags* {.bitsize:31.}: DWORD + PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION1* {.pure, union.} = object + Flags*: DWORD + struct1*: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION1_STRUCT1 + PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY* {.pure.} = object + union1*: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION1 + PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY* = ptr PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY + PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION1_STRUCT1* {.pure.} = object + DisableExtensionPoints* {.bitsize:1.}: DWORD + ReservedFlags* {.bitsize:31.}: DWORD + PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION1* {.pure, union.} = object + Flags*: DWORD + struct1*: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION1_STRUCT1 + PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY* {.pure.} = object + union1*: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION1 + PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY* = ptr PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY + JOBOBJECT_BASIC_ACCOUNTING_INFORMATION* {.pure.} = object + TotalUserTime*: LARGE_INTEGER + TotalKernelTime*: LARGE_INTEGER + ThisPeriodTotalUserTime*: LARGE_INTEGER + ThisPeriodTotalKernelTime*: LARGE_INTEGER + TotalPageFaultCount*: DWORD + TotalProcesses*: DWORD + ActiveProcesses*: DWORD + TotalTerminatedProcesses*: DWORD + PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION* = ptr JOBOBJECT_BASIC_ACCOUNTING_INFORMATION + JOBOBJECT_BASIC_LIMIT_INFORMATION* {.pure.} = object + PerProcessUserTimeLimit*: LARGE_INTEGER + PerJobUserTimeLimit*: LARGE_INTEGER + LimitFlags*: DWORD + MinimumWorkingSetSize*: SIZE_T + MaximumWorkingSetSize*: SIZE_T + ActiveProcessLimit*: DWORD + Affinity*: ULONG_PTR + PriorityClass*: DWORD + SchedulingClass*: DWORD + PJOBOBJECT_BASIC_LIMIT_INFORMATION* = ptr JOBOBJECT_BASIC_LIMIT_INFORMATION + JOBOBJECT_EXTENDED_LIMIT_INFORMATION* {.pure.} = object + BasicLimitInformation*: JOBOBJECT_BASIC_LIMIT_INFORMATION + IoInfo*: IO_COUNTERS + ProcessMemoryLimit*: SIZE_T + JobMemoryLimit*: SIZE_T + PeakProcessMemoryUsed*: SIZE_T + PeakJobMemoryUsed*: SIZE_T + PJOBOBJECT_EXTENDED_LIMIT_INFORMATION* = ptr JOBOBJECT_EXTENDED_LIMIT_INFORMATION + JOBOBJECT_BASIC_PROCESS_ID_LIST* {.pure.} = object + NumberOfAssignedProcesses*: DWORD + NumberOfProcessIdsInList*: DWORD + ProcessIdList*: array[1, ULONG_PTR] + PJOBOBJECT_BASIC_PROCESS_ID_LIST* = ptr JOBOBJECT_BASIC_PROCESS_ID_LIST + JOBOBJECT_BASIC_UI_RESTRICTIONS* {.pure.} = object + UIRestrictionsClass*: DWORD + PJOBOBJECT_BASIC_UI_RESTRICTIONS* = ptr JOBOBJECT_BASIC_UI_RESTRICTIONS + JOBOBJECT_SECURITY_LIMIT_INFORMATION* {.pure.} = object + SecurityLimitFlags*: DWORD + JobToken*: HANDLE + SidsToDisable*: PTOKEN_GROUPS + PrivilegesToDelete*: PTOKEN_PRIVILEGES + RestrictedSids*: PTOKEN_GROUPS + PJOBOBJECT_SECURITY_LIMIT_INFORMATION* = ptr JOBOBJECT_SECURITY_LIMIT_INFORMATION + JOBOBJECT_END_OF_JOB_TIME_INFORMATION* {.pure.} = object + EndOfJobTimeAction*: DWORD + PJOBOBJECT_END_OF_JOB_TIME_INFORMATION* = ptr JOBOBJECT_END_OF_JOB_TIME_INFORMATION + JOBOBJECT_ASSOCIATE_COMPLETION_PORT* {.pure.} = object + CompletionKey*: PVOID + CompletionPort*: HANDLE + PJOBOBJECT_ASSOCIATE_COMPLETION_PORT* = ptr JOBOBJECT_ASSOCIATE_COMPLETION_PORT + JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION* {.pure.} = object + BasicInfo*: JOBOBJECT_BASIC_ACCOUNTING_INFORMATION + IoInfo*: IO_COUNTERS + PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION* = ptr JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION + JOBOBJECT_JOBSET_INFORMATION* {.pure.} = object + MemberLevel*: DWORD + PJOBOBJECT_JOBSET_INFORMATION* = ptr JOBOBJECT_JOBSET_INFORMATION + JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION* {.pure.} = object + IoReadBytesLimit*: DWORD64 + IoWriteBytesLimit*: DWORD64 + PerJobUserTimeLimit*: LARGE_INTEGER + JobMemoryLimit*: DWORD64 + RateControlTolerance*: JOBOBJECT_RATE_CONTROL_TOLERANCE + RateControlToleranceInterval*: JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL + LimitFlags*: DWORD + PJOBOBJECT_NOTIFICATION_LIMIT_INFORMATION* = ptr JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION + JOBOBJECT_LIMIT_VIOLATION_INFORMATION* {.pure.} = object + LimitFlags*: DWORD + ViolationLimitFlags*: DWORD + IoReadBytes*: DWORD64 + IoReadBytesLimit*: DWORD64 + IoWriteBytes*: DWORD64 + IoWriteBytesLimit*: DWORD64 + PerJobUserTime*: LARGE_INTEGER + PerJobUserTimeLimit*: LARGE_INTEGER + JobMemory*: DWORD64 + JobMemoryLimit*: DWORD64 + RateControlTolerance*: JOBOBJECT_RATE_CONTROL_TOLERANCE + RateControlToleranceLimit*: JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL + PJOBOBJECT_LIMIT_VIOLATION_INFORMATION* = ptr JOBOBJECT_LIMIT_VIOLATION_INFORMATION + JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_UNION1* {.pure, union.} = object + CpuRate*: DWORD + Weight*: DWORD + JOBOBJECT_CPU_RATE_CONTROL_INFORMATION* {.pure.} = object + ControlFlags*: DWORD + union1*: JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_UNION1 + PJOBOBJECT_CPU_RATE_CONTROL_INFORMATION* = ptr JOBOBJECT_CPU_RATE_CONTROL_INFORMATION + CACHE_DESCRIPTOR* {.pure.} = object + Level*: BYTE + Associativity*: BYTE + LineSize*: WORD + Size*: DWORD + Type*: PROCESSOR_CACHE_TYPE + PCACHE_DESCRIPTOR* = ptr CACHE_DESCRIPTOR + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_ProcessorCore* {.pure.} = object + Flags*: BYTE + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_NumaNode* {.pure.} = object + NodeNumber*: DWORD + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1* {.pure, union.} = object + ProcessorCore*: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_ProcessorCore + NumaNode*: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_NumaNode + Cache*: CACHE_DESCRIPTOR + Reserved*: array[2, ULONGLONG] + SYSTEM_LOGICAL_PROCESSOR_INFORMATION* {.pure.} = object + ProcessorMask*: ULONG_PTR + Relationship*: LOGICAL_PROCESSOR_RELATIONSHIP + union1*: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1 + PSYSTEM_LOGICAL_PROCESSOR_INFORMATION* = ptr SYSTEM_LOGICAL_PROCESSOR_INFORMATION + PROCESSOR_RELATIONSHIP* {.pure.} = object + Flags*: BYTE + Reserved*: array[21, BYTE] + GroupCount*: WORD + GroupMask*: array[ANYSIZE_ARRAY, GROUP_AFFINITY] + PPROCESSOR_RELATIONSHIP* = ptr PROCESSOR_RELATIONSHIP + NUMA_NODE_RELATIONSHIP* {.pure.} = object + NodeNumber*: DWORD + Reserved*: array[20, BYTE] + GroupMask*: GROUP_AFFINITY + PNUMA_NODE_RELATIONSHIP* = ptr NUMA_NODE_RELATIONSHIP + CACHE_RELATIONSHIP* {.pure.} = object + Level*: BYTE + Associativity*: BYTE + LineSize*: WORD + CacheSize*: DWORD + Type*: PROCESSOR_CACHE_TYPE + Reserved*: array[20, BYTE] + GroupMask*: GROUP_AFFINITY + PCACHE_RELATIONSHIP* = ptr CACHE_RELATIONSHIP + PROCESSOR_GROUP_INFO* {.pure.} = object + MaximumProcessorCount*: BYTE + ActiveProcessorCount*: BYTE + Reserved*: array[38, BYTE] + ActiveProcessorMask*: KAFFINITY + PPROCESSOR_GROUP_INFO* = ptr PROCESSOR_GROUP_INFO + GROUP_RELATIONSHIP* {.pure.} = object + MaximumGroupCount*: WORD + ActiveGroupCount*: WORD + Reserved*: array[20, BYTE] + GroupInfo*: array[ANYSIZE_ARRAY, PROCESSOR_GROUP_INFO] + PGROUP_RELATIONSHIP* = ptr GROUP_RELATIONSHIP + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_UNION1* {.pure, union.} = object + Processor*: PROCESSOR_RELATIONSHIP + NumaNode*: NUMA_NODE_RELATIONSHIP + Cache*: CACHE_RELATIONSHIP + Group*: GROUP_RELATIONSHIP + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* {.pure.} = object + Relationship*: LOGICAL_PROCESSOR_RELATIONSHIP + Size*: DWORD + union1*: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_UNION1 + PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* = ptr SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX + SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION* {.pure.} = object + CycleTime*: DWORD64 + PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION* = ptr SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION + XSTATE_FEATURE* {.pure.} = object + Offset*: DWORD + Size*: DWORD + PXSTATE_FEATURE* = ptr XSTATE_FEATURE +const + MAXIMUM_XSTATE_FEATURES* = 64 +type + XSTATE_CONFIGURATION* {.pure.} = object + EnabledFeatures*: DWORD64 + EnabledVolatileFeatures*: DWORD64 + Size*: DWORD + OptimizedSave* {.bitsize:1.}: DWORD + Features*: array[MAXIMUM_XSTATE_FEATURES, XSTATE_FEATURE] + PXSTATE_CONFIGURATION* = ptr XSTATE_CONFIGURATION + MEMORY_BASIC_INFORMATION* {.pure.} = object + BaseAddress*: PVOID + AllocationBase*: PVOID + AllocationProtect*: DWORD + RegionSize*: SIZE_T + State*: DWORD + Protect*: DWORD + Type*: DWORD + PMEMORY_BASIC_INFORMATION* = ptr MEMORY_BASIC_INFORMATION + MEMORY_BASIC_INFORMATION32* {.pure.} = object + BaseAddress*: DWORD + AllocationBase*: DWORD + AllocationProtect*: DWORD + RegionSize*: DWORD + State*: DWORD + Protect*: DWORD + Type*: DWORD + PMEMORY_BASIC_INFORMATION32* = ptr MEMORY_BASIC_INFORMATION32 + MEMORY_BASIC_INFORMATION64* {.pure.} = object + BaseAddress*: ULONGLONG + AllocationBase*: ULONGLONG + AllocationProtect*: DWORD + alignment1*: DWORD + RegionSize*: ULONGLONG + State*: DWORD + Protect*: DWORD + Type*: DWORD + alignment2*: DWORD + PMEMORY_BASIC_INFORMATION64* = ptr MEMORY_BASIC_INFORMATION64 + FILE_ID_128* {.pure.} = object + LowPart*: ULONGLONG + HighPart*: ULONGLONG + PFILE_ID_128* = ptr FILE_ID_128 + FILE_NOTIFY_INFORMATION* {.pure.} = object + NextEntryOffset*: DWORD + Action*: DWORD + FileNameLength*: DWORD + FileName*: array[1, WCHAR] + PFILE_NOTIFY_INFORMATION* = ptr FILE_NOTIFY_INFORMATION + FILE_SEGMENT_ELEMENT* {.pure, union.} = object + Buffer*: PVOID64 + Alignment*: ULONGLONG + PFILE_SEGMENT_ELEMENT* = ptr FILE_SEGMENT_ELEMENT + REPARSE_GUID_DATA_BUFFER_GenericReparseBuffer* {.pure.} = object + DataBuffer*: array[1, BYTE] + REPARSE_GUID_DATA_BUFFER* {.pure.} = object + ReparseTag*: DWORD + ReparseDataLength*: WORD + Reserved*: WORD + ReparseGuid*: GUID + GenericReparseBuffer*: REPARSE_GUID_DATA_BUFFER_GenericReparseBuffer + PREPARSE_GUID_DATA_BUFFER* = ptr REPARSE_GUID_DATA_BUFFER + SCRUB_DATA_INPUT* {.pure.} = object + Size*: DWORD + Flags*: DWORD + MaximumIos*: DWORD + Reserved*: array[17, DWORD] + ResumeContext*: array[816, BYTE] + PSCRUB_DATA_INPUT* = ptr SCRUB_DATA_INPUT + SCRUB_DATA_OUTPUT* {.pure.} = object + Size*: DWORD + Flags*: DWORD + Status*: DWORD + ErrorFileOffset*: ULONGLONG + ErrorLength*: ULONGLONG + NumberOfBytesRepaired*: ULONGLONG + NumberOfBytesFailed*: ULONGLONG + InternalFileReference*: ULONGLONG + Reserved*: array[6, DWORD] + ResumeContext*: array[816, BYTE] + PSCRUB_DATA_OUTPUT* = ptr SCRUB_DATA_OUTPUT +const + POWER_SYSTEM_MAXIMUM* = 7 +type + CM_POWER_DATA* {.pure.} = object + PD_Size*: DWORD + PD_MostRecentPowerState*: DEVICE_POWER_STATE + PD_Capabilities*: DWORD + PD_D1Latency*: DWORD + PD_D2Latency*: DWORD + PD_D3Latency*: DWORD + PD_PowerStateMapping*: array[POWER_SYSTEM_MAXIMUM, DEVICE_POWER_STATE] + PD_DeepestSystemWake*: SYSTEM_POWER_STATE + PCM_POWER_DATA* = ptr CM_POWER_DATA + POWER_USER_PRESENCE* {.pure.} = object + UserPresence*: POWER_USER_PRESENCE_TYPE + PPOWER_USER_PRESENCE* = ptr POWER_USER_PRESENCE + POWER_SESSION_CONNECT* {.pure.} = object + Connected*: BOOLEAN + Console*: BOOLEAN + PPOWER_SESSION_CONNECT* = ptr POWER_SESSION_CONNECT + POWER_SESSION_TIMEOUTS* {.pure.} = object + InputTimeout*: DWORD + DisplayTimeout*: DWORD + PPOWER_SESSION_TIMEOUTS* = ptr POWER_SESSION_TIMEOUTS + POWER_SESSION_RIT_STATE* {.pure.} = object + Active*: BOOLEAN + LastInputTime*: DWORD + PPOWER_SESSION_RIT_STATE* = ptr POWER_SESSION_RIT_STATE + POWER_SESSION_WINLOGON* {.pure.} = object + SessionId*: DWORD + Console*: BOOLEAN + Locked*: BOOLEAN + PPOWER_SESSION_WINLOGON* = ptr POWER_SESSION_WINLOGON + POWER_IDLE_RESILIENCY* {.pure.} = object + CoalescingTimeout*: DWORD + IdleResiliencyPeriod*: DWORD + PPOWER_IDLE_RESILIENCY* = ptr POWER_IDLE_RESILIENCY + POWER_MONITOR_INVOCATION* {.pure.} = object + On*: BOOLEAN + Console*: BOOLEAN + RequestReason*: POWER_MONITOR_REQUEST_REASON + PPOWER_MONITOR_INVOCATION* = ptr POWER_MONITOR_INVOCATION + RESUME_PERFORMANCE* {.pure.} = object + PostTimeMs*: DWORD + TotalResumeTimeMs*: ULONGLONG + ResumeCompleteTimestamp*: ULONGLONG + PRESUME_PERFORMANCE* = ptr RESUME_PERFORMANCE + SET_POWER_SETTING_VALUE* {.pure.} = object + Version*: DWORD + Guid*: GUID + PowerCondition*: SYSTEM_POWER_CONDITION + DataLength*: DWORD + Data*: array[ANYSIZE_ARRAY, BYTE] + PSET_POWER_SETTING_VALUE* = ptr SET_POWER_SETTING_VALUE + NOTIFY_USER_POWER_SETTING* {.pure.} = object + Guid*: GUID + PNOTIFY_USER_POWER_SETTING* = ptr NOTIFY_USER_POWER_SETTING + APPLICATIONLAUNCH_SETTING_VALUE* {.pure.} = object + ActivationTime*: LARGE_INTEGER + Flags*: DWORD + ButtonInstanceID*: DWORD + PAPPLICATIONLAUNCH_SETTING_VALUE* = ptr APPLICATIONLAUNCH_SETTING_VALUE + POWER_PLATFORM_INFORMATION* {.pure.} = object + AoAc*: BOOLEAN + PPOWER_PLATFORM_INFORMATION* = ptr POWER_PLATFORM_INFORMATION + BATTERY_REPORTING_SCALE* {.pure.} = object + Granularity*: DWORD + Capacity*: DWORD + PBATTERY_REPORTING_SCALE* = ptr BATTERY_REPORTING_SCALE + PPM_WMI_LEGACY_PERFSTATE* {.pure.} = object + Frequency*: DWORD + Flags*: DWORD + PercentFrequency*: DWORD + PPPM_WMI_LEGACY_PERFSTATE* = ptr PPM_WMI_LEGACY_PERFSTATE + PPM_WMI_IDLE_STATE* {.pure.} = object + Latency*: DWORD + Power*: DWORD + TimeCheck*: DWORD + PromotePercent*: BYTE + DemotePercent*: BYTE + StateType*: BYTE + Reserved*: BYTE + StateFlags*: DWORD + Context*: DWORD + IdleHandler*: DWORD + Reserved1*: DWORD + PPPM_WMI_IDLE_STATE* = ptr PPM_WMI_IDLE_STATE + PPM_WMI_IDLE_STATES* {.pure.} = object + Type*: DWORD + Count*: DWORD + TargetState*: DWORD + OldState*: DWORD + TargetProcessors*: DWORD64 + State*: array[ANYSIZE_ARRAY, PPM_WMI_IDLE_STATE] + PPPM_WMI_IDLE_STATES* = ptr PPM_WMI_IDLE_STATES + PPM_WMI_IDLE_STATES_EX* {.pure.} = object + Type*: DWORD + Count*: DWORD + TargetState*: DWORD + OldState*: DWORD + TargetProcessors*: PVOID + State*: array[ANYSIZE_ARRAY, PPM_WMI_IDLE_STATE] + PPPM_WMI_IDLE_STATES_EX* = ptr PPM_WMI_IDLE_STATES_EX + PPM_WMI_PERF_STATE* {.pure.} = object + Frequency*: DWORD + Power*: DWORD + PercentFrequency*: BYTE + IncreaseLevel*: BYTE + DecreaseLevel*: BYTE + Type*: BYTE + IncreaseTime*: DWORD + DecreaseTime*: DWORD + Control*: DWORD64 + Status*: DWORD64 + HitCount*: DWORD + Reserved1*: DWORD + Reserved2*: DWORD64 + Reserved3*: DWORD64 + PPPM_WMI_PERF_STATE* = ptr PPM_WMI_PERF_STATE + PPM_WMI_PERF_STATES* {.pure.} = object + Count*: DWORD + MaxFrequency*: DWORD + CurrentState*: DWORD + MaxPerfState*: DWORD + MinPerfState*: DWORD + LowestPerfState*: DWORD + ThermalConstraint*: DWORD + BusyAdjThreshold*: BYTE + PolicyType*: BYTE + Type*: BYTE + Reserved*: BYTE + TimerInterval*: DWORD + TargetProcessors*: DWORD64 + PStateHandler*: DWORD + PStateContext*: DWORD + TStateHandler*: DWORD + TStateContext*: DWORD + FeedbackHandler*: DWORD + Reserved1*: DWORD + Reserved2*: DWORD64 + State*: array[ANYSIZE_ARRAY, PPM_WMI_PERF_STATE] + PPPM_WMI_PERF_STATES* = ptr PPM_WMI_PERF_STATES + PPM_WMI_PERF_STATES_EX* {.pure.} = object + Count*: DWORD + MaxFrequency*: DWORD + CurrentState*: DWORD + MaxPerfState*: DWORD + MinPerfState*: DWORD + LowestPerfState*: DWORD + ThermalConstraint*: DWORD + BusyAdjThreshold*: BYTE + PolicyType*: BYTE + Type*: BYTE + Reserved*: BYTE + TimerInterval*: DWORD + TargetProcessors*: PVOID + PStateHandler*: DWORD + PStateContext*: DWORD + TStateHandler*: DWORD + TStateContext*: DWORD + FeedbackHandler*: DWORD + Reserved1*: DWORD + Reserved2*: DWORD64 + State*: array[ANYSIZE_ARRAY, PPM_WMI_PERF_STATE] + PPPM_WMI_PERF_STATES_EX* = ptr PPM_WMI_PERF_STATES_EX +const + PROC_IDLE_BUCKET_COUNT* = 6 +type + PPM_IDLE_STATE_ACCOUNTING* {.pure.} = object + IdleTransitions*: DWORD + FailedTransitions*: DWORD + InvalidBucketIndex*: DWORD + TotalTime*: DWORD64 + IdleTimeBuckets*: array[PROC_IDLE_BUCKET_COUNT, DWORD] + PPPM_IDLE_STATE_ACCOUNTING* = ptr PPM_IDLE_STATE_ACCOUNTING + PPM_IDLE_ACCOUNTING* {.pure.} = object + StateCount*: DWORD + TotalTransitions*: DWORD + ResetCount*: DWORD + StartTime*: DWORD64 + State*: array[ANYSIZE_ARRAY, PPM_IDLE_STATE_ACCOUNTING] + PPPM_IDLE_ACCOUNTING* = ptr PPM_IDLE_ACCOUNTING + PPM_IDLE_STATE_BUCKET_EX* {.pure.} = object + TotalTimeUs*: DWORD64 + MinTimeUs*: DWORD + MaxTimeUs*: DWORD + Count*: DWORD + PPPM_IDLE_STATE_BUCKET_EX* = ptr PPM_IDLE_STATE_BUCKET_EX +const + PROC_IDLE_BUCKET_COUNT_EX* = 16 +type + PPM_IDLE_STATE_ACCOUNTING_EX* {.pure.} = object + TotalTime*: DWORD64 + IdleTransitions*: DWORD + FailedTransitions*: DWORD + InvalidBucketIndex*: DWORD + MinTimeUs*: DWORD + MaxTimeUs*: DWORD + CancelledTransitions*: DWORD + IdleTimeBuckets*: array[PROC_IDLE_BUCKET_COUNT_EX, PPM_IDLE_STATE_BUCKET_EX] + PPPM_IDLE_STATE_ACCOUNTING_EX* = ptr PPM_IDLE_STATE_ACCOUNTING_EX + PPM_IDLE_ACCOUNTING_EX* {.pure.} = object + StateCount*: DWORD + TotalTransitions*: DWORD + ResetCount*: DWORD + AbortCount*: DWORD + StartTime*: DWORD64 + State*: array[ANYSIZE_ARRAY, PPM_IDLE_STATE_ACCOUNTING_EX] + PPPM_IDLE_ACCOUNTING_EX* = ptr PPM_IDLE_ACCOUNTING_EX + PPM_PERFSTATE_EVENT* {.pure.} = object + State*: DWORD + Status*: DWORD + Latency*: DWORD + Speed*: DWORD + Processor*: DWORD + PPPM_PERFSTATE_EVENT* = ptr PPM_PERFSTATE_EVENT + PPM_PERFSTATE_DOMAIN_EVENT* {.pure.} = object + State*: DWORD + Latency*: DWORD + Speed*: DWORD + Processors*: DWORD64 + PPPM_PERFSTATE_DOMAIN_EVENT* = ptr PPM_PERFSTATE_DOMAIN_EVENT + PPM_IDLESTATE_EVENT* {.pure.} = object + NewState*: DWORD + OldState*: DWORD + Processors*: DWORD64 + PPPM_IDLESTATE_EVENT* = ptr PPM_IDLESTATE_EVENT + PPM_THERMALCHANGE_EVENT* {.pure.} = object + ThermalConstraint*: DWORD + Processors*: DWORD64 + PPPM_THERMALCHANGE_EVENT* = ptr PPM_THERMALCHANGE_EVENT + PPM_THERMAL_POLICY_EVENT* {.pure.} = object + Mode*: BYTE + Processors*: DWORD64 + PPPM_THERMAL_POLICY_EVENT* = ptr PPM_THERMAL_POLICY_EVENT + POWER_ACTION_POLICY* {.pure.} = object + Action*: POWER_ACTION + Flags*: DWORD + EventCode*: DWORD + PPOWER_ACTION_POLICY* = ptr POWER_ACTION_POLICY + PROCESSOR_IDLESTATE_INFO* {.pure.} = object + TimeCheck*: DWORD + DemotePercent*: BYTE + PromotePercent*: BYTE + Spare*: array[2, BYTE] + PPROCESSOR_IDLESTATE_INFO* = ptr PROCESSOR_IDLESTATE_INFO + SYSTEM_POWER_LEVEL* {.pure.} = object + Enable*: BOOLEAN + Spare*: array[3, BYTE] + BatteryLevel*: DWORD + PowerPolicy*: POWER_ACTION_POLICY + MinSystemState*: SYSTEM_POWER_STATE + PSYSTEM_POWER_LEVEL* = ptr SYSTEM_POWER_LEVEL +const + NUM_DISCHARGE_POLICIES* = 4 +type + SYSTEM_POWER_POLICY* {.pure.} = object + Revision*: DWORD + PowerButton*: POWER_ACTION_POLICY + SleepButton*: POWER_ACTION_POLICY + LidClose*: POWER_ACTION_POLICY + LidOpenWake*: SYSTEM_POWER_STATE + Reserved*: DWORD + Idle*: POWER_ACTION_POLICY + IdleTimeout*: DWORD + IdleSensitivity*: BYTE + DynamicThrottle*: BYTE + Spare2*: array[2, BYTE] + MinSleep*: SYSTEM_POWER_STATE + MaxSleep*: SYSTEM_POWER_STATE + ReducedLatencySleep*: SYSTEM_POWER_STATE + WinLogonFlags*: DWORD + Spare3*: DWORD + DozeS4Timeout*: DWORD + BroadcastCapacityResolution*: DWORD + DischargePolicy*: array[NUM_DISCHARGE_POLICIES, SYSTEM_POWER_LEVEL] + VideoTimeout*: DWORD + VideoDimDisplay*: BOOLEAN + VideoReserved*: array[3, DWORD] + SpindownTimeout*: DWORD + OptimizeForPower*: BOOLEAN + FanThrottleTolerance*: BYTE + ForcedThrottle*: BYTE + MinThrottle*: BYTE + OverThrottled*: POWER_ACTION_POLICY + PSYSTEM_POWER_POLICY* = ptr SYSTEM_POWER_POLICY + PROCESSOR_IDLESTATE_POLICY_Flags_STRUCT1* {.pure.} = object + AllowScaling* {.bitsize:1.}: WORD + Disabled* {.bitsize:1.}: WORD + Reserved* {.bitsize:14.}: WORD + PROCESSOR_IDLESTATE_POLICY_Flags* {.pure, union.} = object + AsWORD*: WORD + struct1*: PROCESSOR_IDLESTATE_POLICY_Flags_STRUCT1 +const + PROCESSOR_IDLESTATE_POLICY_COUNT* = 0x3 +type + PROCESSOR_IDLESTATE_POLICY* {.pure.} = object + Revision*: WORD + Flags*: PROCESSOR_IDLESTATE_POLICY_Flags + PolicyCount*: DWORD + Policy*: array[PROCESSOR_IDLESTATE_POLICY_COUNT, PROCESSOR_IDLESTATE_INFO] + PPROCESSOR_IDLESTATE_POLICY* = ptr PROCESSOR_IDLESTATE_POLICY + PROCESSOR_POWER_POLICY_INFO* {.pure.} = object + TimeCheck*: DWORD + DemoteLimit*: DWORD + PromoteLimit*: DWORD + DemotePercent*: BYTE + PromotePercent*: BYTE + Spare*: array[2, BYTE] + AllowDemotion* {.bitsize:1.}: DWORD + AllowPromotion* {.bitsize:1.}: DWORD + Reserved* {.bitsize:30.}: DWORD + PPROCESSOR_POWER_POLICY_INFO* = ptr PROCESSOR_POWER_POLICY_INFO + PROCESSOR_POWER_POLICY* {.pure.} = object + Revision*: DWORD + DynamicThrottle*: BYTE + Spare*: array[3, BYTE] + DisableCStates* {.bitsize:1.}: DWORD + Reserved* {.bitsize:31.}: DWORD + PolicyCount*: DWORD + Policy*: array[3, PROCESSOR_POWER_POLICY_INFO] + PPROCESSOR_POWER_POLICY* = ptr PROCESSOR_POWER_POLICY + PROCESSOR_PERFSTATE_POLICY_UNION1_Flags_STRUCT1* {.pure.} = object + NoDomainAccounting* {.bitsize:1.}: BYTE + IncreasePolicy* {.bitsize:2.}: BYTE + DecreasePolicy* {.bitsize:2.}: BYTE + Reserved* {.bitsize:3.}: BYTE + PROCESSOR_PERFSTATE_POLICY_UNION1_Flags* {.pure, union.} = object + AsBYTE*: BYTE + struct1*: PROCESSOR_PERFSTATE_POLICY_UNION1_Flags_STRUCT1 + PROCESSOR_PERFSTATE_POLICY_UNION1* {.pure, union.} = object + Spare*: BYTE + Flags*: PROCESSOR_PERFSTATE_POLICY_UNION1_Flags + PROCESSOR_PERFSTATE_POLICY* {.pure.} = object + Revision*: DWORD + MaxThrottle*: BYTE + MinThrottle*: BYTE + BusyAdjThreshold*: BYTE + union1*: PROCESSOR_PERFSTATE_POLICY_UNION1 + TimeCheck*: DWORD + IncreaseTime*: DWORD + DecreaseTime*: DWORD + IncreasePercent*: DWORD + DecreasePercent*: DWORD + PPROCESSOR_PERFSTATE_POLICY* = ptr PROCESSOR_PERFSTATE_POLICY + ADMINISTRATOR_POWER_POLICY* {.pure.} = object + MinSleep*: SYSTEM_POWER_STATE + MaxSleep*: SYSTEM_POWER_STATE + MinVideoTimeout*: DWORD + MaxVideoTimeout*: DWORD + MinSpindownTimeout*: DWORD + MaxSpindownTimeout*: DWORD + PADMINISTRATOR_POWER_POLICY* = ptr ADMINISTRATOR_POWER_POLICY + SYSTEM_POWER_CAPABILITIES* {.pure.} = object + PowerButtonPresent*: BOOLEAN + SleepButtonPresent*: BOOLEAN + LidPresent*: BOOLEAN + SystemS1*: BOOLEAN + SystemS2*: BOOLEAN + SystemS3*: BOOLEAN + SystemS4*: BOOLEAN + SystemS5*: BOOLEAN + HiberFilePresent*: BOOLEAN + FullWake*: BOOLEAN + VideoDimPresent*: BOOLEAN + ApmPresent*: BOOLEAN + UpsPresent*: BOOLEAN + ThermalControl*: BOOLEAN + ProcessorThrottle*: BOOLEAN + ProcessorMinThrottle*: BYTE + ProcessorMaxThrottle*: BYTE + FastSystemS4*: BOOLEAN + spare2*: array[3, BYTE] + DiskSpinDown*: BOOLEAN + spare3*: array[8, BYTE] + SystemBatteriesPresent*: BOOLEAN + BatteriesAreShortTerm*: BOOLEAN + BatteryScale*: array[3, BATTERY_REPORTING_SCALE] + AcOnLineWake*: SYSTEM_POWER_STATE + SoftLidWake*: SYSTEM_POWER_STATE + RtcWake*: SYSTEM_POWER_STATE + MinDeviceWakeState*: SYSTEM_POWER_STATE + DefaultLowLatencyWake*: SYSTEM_POWER_STATE + PSYSTEM_POWER_CAPABILITIES* = ptr SYSTEM_POWER_CAPABILITIES + SYSTEM_BATTERY_STATE* {.pure.} = object + AcOnLine*: BOOLEAN + BatteryPresent*: BOOLEAN + Charging*: BOOLEAN + Discharging*: BOOLEAN + Spare1*: array[4, BOOLEAN] + MaxCapacity*: DWORD + RemainingCapacity*: DWORD + Rate*: DWORD + EstimatedTime*: DWORD + DefaultAlert1*: DWORD + DefaultAlert2*: DWORD + PSYSTEM_BATTERY_STATE* = ptr SYSTEM_BATTERY_STATE + IMAGE_DOS_HEADER* {.pure.} = object + e_magic*: WORD + e_cblp*: WORD + e_cp*: WORD + e_crlc*: WORD + e_cparhdr*: WORD + e_minalloc*: WORD + e_maxalloc*: WORD + e_ss*: WORD + e_sp*: WORD + e_csum*: WORD + e_ip*: WORD + e_cs*: WORD + e_lfarlc*: WORD + e_ovno*: WORD + e_res*: array[4, WORD] + e_oemid*: WORD + e_oeminfo*: WORD + e_res2*: array[10, WORD] + e_lfanew*: LONG + PIMAGE_DOS_HEADER* = ptr IMAGE_DOS_HEADER + IMAGE_OS2_HEADER* {.pure.} = object + ne_magic*: WORD + ne_ver*: CHAR + ne_rev*: CHAR + ne_enttab*: WORD + ne_cbenttab*: WORD + ne_crc*: LONG + ne_flags*: WORD + ne_autodata*: WORD + ne_heap*: WORD + ne_stack*: WORD + ne_csip*: LONG + ne_sssp*: LONG + ne_cseg*: WORD + ne_cmod*: WORD + ne_cbnrestab*: WORD + ne_segtab*: WORD + ne_rsrctab*: WORD + ne_restab*: WORD + ne_modtab*: WORD + ne_imptab*: WORD + ne_nrestab*: LONG + ne_cmovent*: WORD + ne_align*: WORD + ne_cres*: WORD + ne_exetyp*: BYTE + ne_flagsothers*: BYTE + ne_pretthunks*: WORD + ne_psegrefbytes*: WORD + ne_swaparea*: WORD + ne_expver*: WORD + PIMAGE_OS2_HEADER* = ptr IMAGE_OS2_HEADER + IMAGE_VXD_HEADER* {.pure.} = object + e32_magic*: WORD + e32_border*: BYTE + e32_worder*: BYTE + e32_level*: DWORD + e32_cpu*: WORD + e32_os*: WORD + e32_ver*: DWORD + e32_mflags*: DWORD + e32_mpages*: DWORD + e32_startobj*: DWORD + e32_eip*: DWORD + e32_stackobj*: DWORD + e32_esp*: DWORD + e32_pagesize*: DWORD + e32_lastpagesize*: DWORD + e32_fixupsize*: DWORD + e32_fixupsum*: DWORD + e32_ldrsize*: DWORD + e32_ldrsum*: DWORD + e32_objtab*: DWORD + e32_objcnt*: DWORD + e32_objmap*: DWORD + e32_itermap*: DWORD + e32_rsrctab*: DWORD + e32_rsrccnt*: DWORD + e32_restab*: DWORD + e32_enttab*: DWORD + e32_dirtab*: DWORD + e32_dircnt*: DWORD + e32_fpagetab*: DWORD + e32_frectab*: DWORD + e32_impmod*: DWORD + e32_impmodcnt*: DWORD + e32_impproc*: DWORD + e32_pagesum*: DWORD + e32_datapage*: DWORD + e32_preload*: DWORD + e32_nrestab*: DWORD + e32_cbnrestab*: DWORD + e32_nressum*: DWORD + e32_autodata*: DWORD + e32_debuginfo*: DWORD + e32_debuglen*: DWORD + e32_instpreload*: DWORD + e32_instdemand*: DWORD + e32_heapsize*: DWORD + e32_res3*: array[12, BYTE] + e32_winresoff*: DWORD + e32_winreslen*: DWORD + e32_devid*: WORD + e32_ddkver*: WORD + PIMAGE_VXD_HEADER* = ptr IMAGE_VXD_HEADER + IMAGE_FILE_HEADER* {.pure.} = object + Machine*: WORD + NumberOfSections*: WORD + TimeDateStamp*: DWORD + PointerToSymbolTable*: DWORD + NumberOfSymbols*: DWORD + SizeOfOptionalHeader*: WORD + Characteristics*: WORD + PIMAGE_FILE_HEADER* = ptr IMAGE_FILE_HEADER + IMAGE_DATA_DIRECTORY* {.pure.} = object + VirtualAddress*: DWORD + Size*: DWORD + PIMAGE_DATA_DIRECTORY* = ptr IMAGE_DATA_DIRECTORY +const + IMAGE_NUMBEROF_DIRECTORY_ENTRIES* = 16 +type + IMAGE_OPTIONAL_HEADER32* {.pure.} = object + Magic*: WORD + MajorLinkerVersion*: BYTE + MinorLinkerVersion*: BYTE + SizeOfCode*: DWORD + SizeOfInitializedData*: DWORD + SizeOfUninitializedData*: DWORD + AddressOfEntryPoint*: DWORD + BaseOfCode*: DWORD + BaseOfData*: DWORD + ImageBase*: DWORD + SectionAlignment*: DWORD + FileAlignment*: DWORD + MajorOperatingSystemVersion*: WORD + MinorOperatingSystemVersion*: WORD + MajorImageVersion*: WORD + MinorImageVersion*: WORD + MajorSubsystemVersion*: WORD + MinorSubsystemVersion*: WORD + Win32VersionValue*: DWORD + SizeOfImage*: DWORD + SizeOfHeaders*: DWORD + CheckSum*: DWORD + Subsystem*: WORD + DllCharacteristics*: WORD + SizeOfStackReserve*: DWORD + SizeOfStackCommit*: DWORD + SizeOfHeapReserve*: DWORD + SizeOfHeapCommit*: DWORD + LoaderFlags*: DWORD + NumberOfRvaAndSizes*: DWORD + DataDirectory*: array[IMAGE_NUMBEROF_DIRECTORY_ENTRIES, IMAGE_DATA_DIRECTORY] + PIMAGE_OPTIONAL_HEADER32* = ptr IMAGE_OPTIONAL_HEADER32 + IMAGE_ROM_OPTIONAL_HEADER* {.pure.} = object + Magic*: WORD + MajorLinkerVersion*: BYTE + MinorLinkerVersion*: BYTE + SizeOfCode*: DWORD + SizeOfInitializedData*: DWORD + SizeOfUninitializedData*: DWORD + AddressOfEntryPoint*: DWORD + BaseOfCode*: DWORD + BaseOfData*: DWORD + BaseOfBss*: DWORD + GprMask*: DWORD + CprMask*: array[4, DWORD] + GpValue*: DWORD + PIMAGE_ROM_OPTIONAL_HEADER* = ptr IMAGE_ROM_OPTIONAL_HEADER + IMAGE_OPTIONAL_HEADER64* {.pure.} = object + Magic*: WORD + MajorLinkerVersion*: BYTE + MinorLinkerVersion*: BYTE + SizeOfCode*: DWORD + SizeOfInitializedData*: DWORD + SizeOfUninitializedData*: DWORD + AddressOfEntryPoint*: DWORD + BaseOfCode*: DWORD + ImageBase*: ULONGLONG + SectionAlignment*: DWORD + FileAlignment*: DWORD + MajorOperatingSystemVersion*: WORD + MinorOperatingSystemVersion*: WORD + MajorImageVersion*: WORD + MinorImageVersion*: WORD + MajorSubsystemVersion*: WORD + MinorSubsystemVersion*: WORD + Win32VersionValue*: DWORD + SizeOfImage*: DWORD + SizeOfHeaders*: DWORD + CheckSum*: DWORD + Subsystem*: WORD + DllCharacteristics*: WORD + SizeOfStackReserve*: ULONGLONG + SizeOfStackCommit*: ULONGLONG + SizeOfHeapReserve*: ULONGLONG + SizeOfHeapCommit*: ULONGLONG + LoaderFlags*: DWORD + NumberOfRvaAndSizes*: DWORD + DataDirectory*: array[IMAGE_NUMBEROF_DIRECTORY_ENTRIES, IMAGE_DATA_DIRECTORY] + PIMAGE_OPTIONAL_HEADER64* = ptr IMAGE_OPTIONAL_HEADER64 + IMAGE_NT_HEADERS64* {.pure.} = object + Signature*: DWORD + FileHeader*: IMAGE_FILE_HEADER + OptionalHeader*: IMAGE_OPTIONAL_HEADER64 + PIMAGE_NT_HEADERS64* = ptr IMAGE_NT_HEADERS64 + IMAGE_NT_HEADERS32* {.pure.} = object + Signature*: DWORD + FileHeader*: IMAGE_FILE_HEADER + OptionalHeader*: IMAGE_OPTIONAL_HEADER32 + PIMAGE_NT_HEADERS32* = ptr IMAGE_NT_HEADERS32 + IMAGE_ROM_HEADERS* {.pure.} = object + FileHeader*: IMAGE_FILE_HEADER + OptionalHeader*: IMAGE_ROM_OPTIONAL_HEADER + PIMAGE_ROM_HEADERS* = ptr IMAGE_ROM_HEADERS +const + IMAGE_SIZEOF_SHORT_NAME* = 8 +type + IMAGE_SECTION_HEADER_Misc* {.pure, union.} = object + PhysicalAddress*: DWORD + VirtualSize*: DWORD + IMAGE_SECTION_HEADER* {.pure.} = object + Name*: array[IMAGE_SIZEOF_SHORT_NAME, BYTE] + Misc*: IMAGE_SECTION_HEADER_Misc + VirtualAddress*: DWORD + SizeOfRawData*: DWORD + PointerToRawData*: DWORD + PointerToRelocations*: DWORD + PointerToLinenumbers*: DWORD + NumberOfRelocations*: WORD + NumberOfLinenumbers*: WORD + Characteristics*: DWORD + PIMAGE_SECTION_HEADER* = ptr IMAGE_SECTION_HEADER + IMAGE_SYMBOL_N_Name* {.pure.} = object + Short*: DWORD + Long*: DWORD + IMAGE_SYMBOL_N* {.pure, union.} = object + ShortName*: array[8, BYTE] + Name*: IMAGE_SYMBOL_N_Name + LongName*: array[2, DWORD] + IMAGE_SYMBOL* {.pure, packed.} = object + N*: IMAGE_SYMBOL_N + Value*: DWORD + SectionNumber*: SHORT + Type*: WORD + StorageClass*: BYTE + NumberOfAuxSymbols*: BYTE + PIMAGE_SYMBOL* = ptr IMAGE_SYMBOL + IMAGE_SYMBOL_EX_N_Name* {.pure.} = object + Short*: DWORD + Long*: DWORD + IMAGE_SYMBOL_EX_N* {.pure, union.} = object + ShortName*: array[8, BYTE] + Name*: IMAGE_SYMBOL_EX_N_Name + LongName*: array[2, DWORD] + IMAGE_SYMBOL_EX* {.pure.} = object + N*: IMAGE_SYMBOL_EX_N + Value*: DWORD + SectionNumber*: LONG + Type*: WORD + StorageClass*: BYTE + NumberOfAuxSymbols*: BYTE + PIMAGE_SYMBOL_EX* = ptr IMAGE_SYMBOL_EX + IMAGE_AUX_SYMBOL_TOKEN_DEF* {.pure, packed.} = object + bAuxType*: BYTE + bReserved*: BYTE + SymbolTableIndex*: DWORD + rgbReserved*: array[12, BYTE] + PIMAGE_AUX_SYMBOL_TOKEN_DEF* = ptr IMAGE_AUX_SYMBOL_TOKEN_DEF + IMAGE_AUX_SYMBOL_Sym_Misc_LnSz* {.pure.} = object + Linenumber*: WORD + Size*: WORD + IMAGE_AUX_SYMBOL_Sym_Misc* {.pure, union.} = object + LnSz*: IMAGE_AUX_SYMBOL_Sym_Misc_LnSz + TotalSize*: DWORD + IMAGE_AUX_SYMBOL_Sym_FcnAry_Function* {.pure.} = object + PointerToLinenumber*: DWORD + PointerToNextFunction*: DWORD + IMAGE_AUX_SYMBOL_Sym_FcnAry_Array* {.pure.} = object + Dimension*: array[4, WORD] + IMAGE_AUX_SYMBOL_Sym_FcnAry* {.pure, union.} = object + Function*: IMAGE_AUX_SYMBOL_Sym_FcnAry_Function + Array*: IMAGE_AUX_SYMBOL_Sym_FcnAry_Array + IMAGE_AUX_SYMBOL_Sym* {.pure.} = object + TagIndex*: DWORD + Misc*: IMAGE_AUX_SYMBOL_Sym_Misc + FcnAry*: IMAGE_AUX_SYMBOL_Sym_FcnAry + TvIndex*: WORD +const + IMAGE_SIZEOF_SYMBOL* = 18 +type + IMAGE_AUX_SYMBOL_File* {.pure.} = object + Name*: array[IMAGE_SIZEOF_SYMBOL, BYTE] + IMAGE_AUX_SYMBOL_Section* {.pure.} = object + Length*: DWORD + NumberOfRelocations*: WORD + NumberOfLinenumbers*: WORD + CheckSum*: DWORD + Number*: SHORT + Selection*: BYTE + IMAGE_AUX_SYMBOL_CRC* {.pure.} = object + crc*: DWORD + rgbReserved*: array[14, BYTE] + IMAGE_AUX_SYMBOL* {.pure, union.} = object + Sym*: IMAGE_AUX_SYMBOL_Sym + File*: IMAGE_AUX_SYMBOL_File + Section*: IMAGE_AUX_SYMBOL_Section + TokenDef*: IMAGE_AUX_SYMBOL_TOKEN_DEF + CRC*: IMAGE_AUX_SYMBOL_CRC + PIMAGE_AUX_SYMBOL* = ptr IMAGE_AUX_SYMBOL + IMAGE_AUX_SYMBOL_EX_Sym* {.pure.} = object + WeakDefaultSymIndex*: DWORD + WeakSearchType*: DWORD + rgbReserved*: array[12, BYTE] + IMAGE_AUX_SYMBOL_EX_File* {.pure.} = object + Name*: array[20, BYTE] + IMAGE_AUX_SYMBOL_EX_Section* {.pure.} = object + Length*: DWORD + NumberOfRelocations*: WORD + NumberOfLinenumbers*: WORD + CheckSum*: DWORD + Number*: SHORT + Selection*: BYTE + bReserved*: BYTE + HighNumber*: SHORT + rgbReserved*: array[2, BYTE] + IMAGE_AUX_SYMBOL_EX_STRUCT4* {.pure.} = object + TokenDef*: IMAGE_AUX_SYMBOL_TOKEN_DEF + rgbReserved*: array[2, BYTE] + IMAGE_AUX_SYMBOL_EX_CRC* {.pure.} = object + crc*: DWORD + rgbReserved*: array[16, BYTE] + IMAGE_AUX_SYMBOL_EX* {.pure, union.} = object + Sym*: IMAGE_AUX_SYMBOL_EX_Sym + File*: IMAGE_AUX_SYMBOL_EX_File + Section*: IMAGE_AUX_SYMBOL_EX_Section + struct4*: IMAGE_AUX_SYMBOL_EX_STRUCT4 + CRC*: IMAGE_AUX_SYMBOL_EX_CRC + PIMAGE_AUX_SYMBOL_EX* = ptr IMAGE_AUX_SYMBOL_EX + IMAGE_RELOCATION_UNION1* {.pure, union.} = object + VirtualAddress*: DWORD + RelocCount*: DWORD + IMAGE_RELOCATION* {.pure, packed.} = object + union1*: IMAGE_RELOCATION_UNION1 + SymbolTableIndex*: DWORD + Type*: WORD + PIMAGE_RELOCATION* = ptr IMAGE_RELOCATION + IMAGE_LINENUMBER_Type* {.pure, union.} = object + SymbolTableIndex*: DWORD + VirtualAddress*: DWORD + IMAGE_LINENUMBER* {.pure, packed.} = object + Type*: IMAGE_LINENUMBER_Type + Linenumber*: WORD + PIMAGE_LINENUMBER* = ptr IMAGE_LINENUMBER + IMAGE_BASE_RELOCATION* {.pure.} = object + VirtualAddress*: DWORD + SizeOfBlock*: DWORD + PIMAGE_BASE_RELOCATION* = ptr IMAGE_BASE_RELOCATION + IMAGE_ARCHIVE_MEMBER_HEADER* {.pure.} = object + Name*: array[16, BYTE] + Date*: array[12, BYTE] + UserID*: array[6, BYTE] + GroupID*: array[6, BYTE] + Mode*: array[8, BYTE] + Size*: array[10, BYTE] + EndHeader*: array[2, BYTE] + PIMAGE_ARCHIVE_MEMBER_HEADER* = ptr IMAGE_ARCHIVE_MEMBER_HEADER + IMAGE_EXPORT_DIRECTORY* {.pure.} = object + Characteristics*: DWORD + TimeDateStamp*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + Name*: DWORD + Base*: DWORD + NumberOfFunctions*: DWORD + NumberOfNames*: DWORD + AddressOfFunctions*: DWORD + AddressOfNames*: DWORD + AddressOfNameOrdinals*: DWORD + PIMAGE_EXPORT_DIRECTORY* = ptr IMAGE_EXPORT_DIRECTORY + IMAGE_IMPORT_BY_NAME* {.pure.} = object + Hint*: WORD + Name*: array[1, BYTE] + PIMAGE_IMPORT_BY_NAME* = ptr IMAGE_IMPORT_BY_NAME + IMAGE_THUNK_DATA64_u1* {.pure, union.} = object + ForwarderString*: ULONGLONG + Function*: ULONGLONG + Ordinal*: ULONGLONG + AddressOfData*: ULONGLONG + IMAGE_THUNK_DATA64* {.pure.} = object + u1*: IMAGE_THUNK_DATA64_u1 + PIMAGE_THUNK_DATA64* = ptr IMAGE_THUNK_DATA64 + IMAGE_THUNK_DATA32_u1* {.pure, union.} = object + ForwarderString*: DWORD + Function*: DWORD + Ordinal*: DWORD + AddressOfData*: DWORD + IMAGE_THUNK_DATA32* {.pure.} = object + u1*: IMAGE_THUNK_DATA32_u1 + PIMAGE_THUNK_DATA32* = ptr IMAGE_THUNK_DATA32 + IMAGE_TLS_DIRECTORY64* {.pure.} = object + StartAddressOfRawData*: ULONGLONG + EndAddressOfRawData*: ULONGLONG + AddressOfIndex*: ULONGLONG + AddressOfCallBacks*: ULONGLONG + SizeOfZeroFill*: DWORD + Characteristics*: DWORD + PIMAGE_TLS_DIRECTORY64* = ptr IMAGE_TLS_DIRECTORY64 + IMAGE_TLS_DIRECTORY32* {.pure.} = object + StartAddressOfRawData*: DWORD + EndAddressOfRawData*: DWORD + AddressOfIndex*: DWORD + AddressOfCallBacks*: DWORD + SizeOfZeroFill*: DWORD + Characteristics*: DWORD + PIMAGE_TLS_DIRECTORY32* = ptr IMAGE_TLS_DIRECTORY32 + IMAGE_IMPORT_DESCRIPTOR_UNION1* {.pure, union.} = object + Characteristics*: DWORD + OriginalFirstThunk*: DWORD + IMAGE_IMPORT_DESCRIPTOR* {.pure.} = object + union1*: IMAGE_IMPORT_DESCRIPTOR_UNION1 + TimeDateStamp*: DWORD + ForwarderChain*: DWORD + Name*: DWORD + FirstThunk*: DWORD + PIMAGE_IMPORT_DESCRIPTOR* = ptr IMAGE_IMPORT_DESCRIPTOR + IMAGE_BOUND_IMPORT_DESCRIPTOR* {.pure.} = object + TimeDateStamp*: DWORD + OffsetModuleName*: WORD + NumberOfModuleForwarderRefs*: WORD + PIMAGE_BOUND_IMPORT_DESCRIPTOR* = ptr IMAGE_BOUND_IMPORT_DESCRIPTOR + IMAGE_BOUND_FORWARDER_REF* {.pure.} = object + TimeDateStamp*: DWORD + OffsetModuleName*: WORD + Reserved*: WORD + PIMAGE_BOUND_FORWARDER_REF* = ptr IMAGE_BOUND_FORWARDER_REF + IMAGE_DELAYLOAD_DESCRIPTOR_Attributes_STRUCT1* {.pure.} = object + RvaBased* {.bitsize:1.}: DWORD + ReservedAttributes* {.bitsize:31.}: DWORD + IMAGE_DELAYLOAD_DESCRIPTOR_Attributes* {.pure, union.} = object + AllAttributes*: DWORD + struct1*: IMAGE_DELAYLOAD_DESCRIPTOR_Attributes_STRUCT1 + IMAGE_DELAYLOAD_DESCRIPTOR* {.pure.} = object + Attributes*: IMAGE_DELAYLOAD_DESCRIPTOR_Attributes + DllNameRVA*: DWORD + ModuleHandleRVA*: DWORD + ImportAddressTableRVA*: DWORD + ImportNameTableRVA*: DWORD + BoundImportAddressTableRVA*: DWORD + UnloadInformationTableRVA*: DWORD + TimeDateStamp*: DWORD + PIMAGE_DELAYLOAD_DESCRIPTOR* = ptr IMAGE_DELAYLOAD_DESCRIPTOR + PCIMAGE_DELAYLOAD_DESCRIPTOR* = ptr IMAGE_DELAYLOAD_DESCRIPTOR + IMAGE_RESOURCE_DIRECTORY* {.pure.} = object + Characteristics*: DWORD + TimeDateStamp*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + NumberOfNamedEntries*: WORD + NumberOfIdEntries*: WORD + PIMAGE_RESOURCE_DIRECTORY* = ptr IMAGE_RESOURCE_DIRECTORY + IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION1_STRUCT1* {.pure.} = object + NameOffset* {.bitsize:31.}: DWORD + NameIsString* {.bitsize:1.}: DWORD + IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION1* {.pure, union.} = object + struct1*: IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION1_STRUCT1 + Name*: DWORD + Id*: WORD + IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION2_STRUCT1* {.pure.} = object + OffsetToDirectory* {.bitsize:31.}: DWORD + DataIsDirectory* {.bitsize:1.}: DWORD + IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION2* {.pure, union.} = object + OffsetToData*: DWORD + struct1*: IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION2_STRUCT1 + IMAGE_RESOURCE_DIRECTORY_ENTRY* {.pure.} = object + union1*: IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION1 + union2*: IMAGE_RESOURCE_DIRECTORY_ENTRY_UNION2 + PIMAGE_RESOURCE_DIRECTORY_ENTRY* = ptr IMAGE_RESOURCE_DIRECTORY_ENTRY + IMAGE_RESOURCE_DIRECTORY_STRING* {.pure.} = object + Length*: WORD + NameString*: array[1, CHAR] + PIMAGE_RESOURCE_DIRECTORY_STRING* = ptr IMAGE_RESOURCE_DIRECTORY_STRING + IMAGE_RESOURCE_DIR_STRING_U* {.pure.} = object + Length*: WORD + NameString*: array[1, WCHAR] + PIMAGE_RESOURCE_DIR_STRING_U* = ptr IMAGE_RESOURCE_DIR_STRING_U + IMAGE_RESOURCE_DATA_ENTRY* {.pure.} = object + OffsetToData*: DWORD + Size*: DWORD + CodePage*: DWORD + Reserved*: DWORD + PIMAGE_RESOURCE_DATA_ENTRY* = ptr IMAGE_RESOURCE_DATA_ENTRY + IMAGE_LOAD_CONFIG_DIRECTORY32* {.pure.} = object + Size*: DWORD + TimeDateStamp*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + GlobalFlagsClear*: DWORD + GlobalFlagsSet*: DWORD + CriticalSectionDefaultTimeout*: DWORD + DeCommitFreeBlockThreshold*: DWORD + DeCommitTotalFreeThreshold*: DWORD + LockPrefixTable*: DWORD + MaximumAllocationSize*: DWORD + VirtualMemoryThreshold*: DWORD + ProcessHeapFlags*: DWORD + ProcessAffinityMask*: DWORD + CSDVersion*: WORD + Reserved1*: WORD + EditList*: DWORD + SecurityCookie*: DWORD + SEHandlerTable*: DWORD + SEHandlerCount*: DWORD + PIMAGE_LOAD_CONFIG_DIRECTORY32* = ptr IMAGE_LOAD_CONFIG_DIRECTORY32 + IMAGE_LOAD_CONFIG_DIRECTORY64* {.pure.} = object + Size*: DWORD + TimeDateStamp*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + GlobalFlagsClear*: DWORD + GlobalFlagsSet*: DWORD + CriticalSectionDefaultTimeout*: DWORD + DeCommitFreeBlockThreshold*: ULONGLONG + DeCommitTotalFreeThreshold*: ULONGLONG + LockPrefixTable*: ULONGLONG + MaximumAllocationSize*: ULONGLONG + VirtualMemoryThreshold*: ULONGLONG + ProcessAffinityMask*: ULONGLONG + ProcessHeapFlags*: DWORD + CSDVersion*: WORD + Reserved1*: WORD + EditList*: ULONGLONG + SecurityCookie*: ULONGLONG + SEHandlerTable*: ULONGLONG + SEHandlerCount*: ULONGLONG + PIMAGE_LOAD_CONFIG_DIRECTORY64* = ptr IMAGE_LOAD_CONFIG_DIRECTORY64 + IMAGE_DEBUG_DIRECTORY* {.pure.} = object + Characteristics*: DWORD + TimeDateStamp*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + Type*: DWORD + SizeOfData*: DWORD + AddressOfRawData*: DWORD + PointerToRawData*: DWORD + PIMAGE_DEBUG_DIRECTORY* = ptr IMAGE_DEBUG_DIRECTORY + IMAGE_COFF_SYMBOLS_HEADER* {.pure.} = object + NumberOfSymbols*: DWORD + LvaToFirstSymbol*: DWORD + NumberOfLinenumbers*: DWORD + LvaToFirstLinenumber*: DWORD + RvaToFirstByteOfCode*: DWORD + RvaToLastByteOfCode*: DWORD + RvaToFirstByteOfData*: DWORD + RvaToLastByteOfData*: DWORD + PIMAGE_COFF_SYMBOLS_HEADER* = ptr IMAGE_COFF_SYMBOLS_HEADER + FPO_DATA* {.pure.} = object + ulOffStart*: DWORD + cbProcSize*: DWORD + cdwLocals*: DWORD + cdwParams*: WORD + cbProlog* {.bitsize:8.}: WORD + cbRegs* {.bitsize:3.}: WORD + fHasSEH* {.bitsize:1.}: WORD + fUseBP* {.bitsize:1.}: WORD + reserved* {.bitsize:1.}: WORD + cbFrame* {.bitsize:2.}: WORD + PFPO_DATA* = ptr FPO_DATA + IMAGE_DEBUG_MISC* {.pure.} = object + DataType*: DWORD + Length*: DWORD + Unicode*: BOOLEAN + Reserved*: array[3, BYTE] + Data*: array[1, BYTE] + PIMAGE_DEBUG_MISC* = ptr IMAGE_DEBUG_MISC + IMAGE_FUNCTION_ENTRY* {.pure.} = object + StartingAddress*: DWORD + EndingAddress*: DWORD + EndOfPrologue*: DWORD + PIMAGE_FUNCTION_ENTRY* = ptr IMAGE_FUNCTION_ENTRY + IMAGE_FUNCTION_ENTRY64_UNION1* {.pure, union.} = object + EndOfPrologue*: ULONGLONG + UnwindInfoAddress*: ULONGLONG + IMAGE_FUNCTION_ENTRY64* {.pure.} = object + StartingAddress*: ULONGLONG + EndingAddress*: ULONGLONG + union1*: IMAGE_FUNCTION_ENTRY64_UNION1 + PIMAGE_FUNCTION_ENTRY64* = ptr IMAGE_FUNCTION_ENTRY64 + IMAGE_SEPARATE_DEBUG_HEADER* {.pure.} = object + Signature*: WORD + Flags*: WORD + Machine*: WORD + Characteristics*: WORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + ImageBase*: DWORD + SizeOfImage*: DWORD + NumberOfSections*: DWORD + ExportedNamesSize*: DWORD + DebugDirectorySize*: DWORD + SectionAlignment*: DWORD + Reserved*: array[2, DWORD] + PIMAGE_SEPARATE_DEBUG_HEADER* = ptr IMAGE_SEPARATE_DEBUG_HEADER + NON_PAGED_DEBUG_INFO* {.pure.} = object + Signature*: WORD + Flags*: WORD + Size*: DWORD + Machine*: WORD + Characteristics*: WORD + TimeDateStamp*: DWORD + CheckSum*: DWORD + SizeOfImage*: DWORD + ImageBase*: ULONGLONG + PNON_PAGED_DEBUG_INFO* = ptr NON_PAGED_DEBUG_INFO + IMAGE_ARCHITECTURE_HEADER* {.pure.} = object + AmaskValue* {.bitsize:1.}: int32 + Adummy1* {.bitsize:7.}: int32 + AmaskShift* {.bitsize:8.}: int32 + Adummy2* {.bitsize:16.}: int32 + FirstEntryRVA*: DWORD + PIMAGE_ARCHITECTURE_HEADER* = ptr IMAGE_ARCHITECTURE_HEADER + IMAGE_ARCHITECTURE_ENTRY* {.pure.} = object + FixupInstRVA*: DWORD + NewInst*: DWORD + PIMAGE_ARCHITECTURE_ENTRY* = ptr IMAGE_ARCHITECTURE_ENTRY + IMAGE_COR20_HEADER_UNION1* {.pure, union.} = object + EntryPointToken*: DWORD + EntryPointRVA*: DWORD + IMAGE_COR20_HEADER* {.pure.} = object + cb*: DWORD + MajorRuntimeVersion*: WORD + MinorRuntimeVersion*: WORD + MetaData*: IMAGE_DATA_DIRECTORY + Flags*: DWORD + union1*: IMAGE_COR20_HEADER_UNION1 + Resources*: IMAGE_DATA_DIRECTORY + StrongNameSignature*: IMAGE_DATA_DIRECTORY + CodeManagerTable*: IMAGE_DATA_DIRECTORY + VTableFixups*: IMAGE_DATA_DIRECTORY + ExportAddressTableJumps*: IMAGE_DATA_DIRECTORY + ManagedNativeHeader*: IMAGE_DATA_DIRECTORY + PIMAGE_COR20_HEADER* = ptr IMAGE_COR20_HEADER + RTL_RUN_ONCE* {.pure.} = object + Ptr*: PVOID + PRTL_RUN_ONCE* = ptr RTL_RUN_ONCE + RTL_BARRIER* {.pure.} = object + Reserved1*: DWORD + Reserved2*: DWORD + Reserved3*: array[2, ULONG_PTR] + Reserved4*: DWORD + Reserved5*: DWORD + PRTL_BARRIER* = ptr RTL_BARRIER + MESSAGE_RESOURCE_ENTRY* {.pure.} = object + Length*: WORD + Flags*: WORD + Text*: array[1, BYTE] + PMESSAGE_RESOURCE_ENTRY* = ptr MESSAGE_RESOURCE_ENTRY + MESSAGE_RESOURCE_BLOCK* {.pure.} = object + LowId*: DWORD + HighId*: DWORD + OffsetToEntries*: DWORD + PMESSAGE_RESOURCE_BLOCK* = ptr MESSAGE_RESOURCE_BLOCK + MESSAGE_RESOURCE_DATA* {.pure.} = object + NumberOfBlocks*: DWORD + Blocks*: array[1, MESSAGE_RESOURCE_BLOCK] + PMESSAGE_RESOURCE_DATA* = ptr MESSAGE_RESOURCE_DATA + OSVERSIONINFOA* {.pure.} = object + dwOSVersionInfoSize*: DWORD + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + dwBuildNumber*: DWORD + dwPlatformId*: DWORD + szCSDVersion*: array[128, CHAR] + POSVERSIONINFOA* = ptr OSVERSIONINFOA + LPOSVERSIONINFOA* = ptr OSVERSIONINFOA + OSVERSIONINFOW* {.pure.} = object + dwOSVersionInfoSize*: DWORD + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + dwBuildNumber*: DWORD + dwPlatformId*: DWORD + szCSDVersion*: array[128, WCHAR] + POSVERSIONINFOW* = ptr OSVERSIONINFOW + LPOSVERSIONINFOW* = ptr OSVERSIONINFOW + RTL_OSVERSIONINFOW* = OSVERSIONINFOW + PRTL_OSVERSIONINFOW* = ptr OSVERSIONINFOW + OSVERSIONINFOEXA* {.pure.} = object + dwOSVersionInfoSize*: DWORD + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + dwBuildNumber*: DWORD + dwPlatformId*: DWORD + szCSDVersion*: array[128, CHAR] + wServicePackMajor*: WORD + wServicePackMinor*: WORD + wSuiteMask*: WORD + wProductType*: BYTE + wReserved*: BYTE + POSVERSIONINFOEXA* = ptr OSVERSIONINFOEXA + LPOSVERSIONINFOEXA* = ptr OSVERSIONINFOEXA + OSVERSIONINFOEXW* {.pure.} = object + dwOSVersionInfoSize*: DWORD + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + dwBuildNumber*: DWORD + dwPlatformId*: DWORD + szCSDVersion*: array[128, WCHAR] + wServicePackMajor*: WORD + wServicePackMinor*: WORD + wSuiteMask*: WORD + wProductType*: BYTE + wReserved*: BYTE + POSVERSIONINFOEXW* = ptr OSVERSIONINFOEXW + LPOSVERSIONINFOEXW* = ptr OSVERSIONINFOEXW + RTL_OSVERSIONINFOEXW* = OSVERSIONINFOEXW + PRTL_OSVERSIONINFOEXW* = ptr OSVERSIONINFOEXW + RTL_UMS_SCHEDULER_ENTRY_POINT* = proc (Reason: RTL_UMS_SCHEDULER_REASON, ActivationPayload: ULONG_PTR, SchedulerParam: PVOID): VOID {.stdcall.} + PRTL_UMS_SCHEDULER_ENTRY_POINT* = RTL_UMS_SCHEDULER_ENTRY_POINT + RTL_CRITICAL_SECTION* {.pure.} = object + DebugInfo*: PRTL_CRITICAL_SECTION_DEBUG + LockCount*: LONG + RecursionCount*: LONG + OwningThread*: HANDLE + LockSemaphore*: HANDLE + SpinCount*: ULONG_PTR + RTL_CRITICAL_SECTION_DEBUG* {.pure.} = object + Type*: WORD + CreatorBackTraceIndex*: WORD + CriticalSection*: ptr RTL_CRITICAL_SECTION + ProcessLocksList*: LIST_ENTRY + EntryCount*: DWORD + ContentionCount*: DWORD + Flags*: DWORD + CreatorBackTraceIndexHigh*: WORD + SpareWORD*: WORD + PRTL_CRITICAL_SECTION_DEBUG* = ptr RTL_CRITICAL_SECTION_DEBUG + RTL_RESOURCE_DEBUG* = RTL_CRITICAL_SECTION_DEBUG + PRTL_RESOURCE_DEBUG* = ptr RTL_CRITICAL_SECTION_DEBUG + PRTL_CRITICAL_SECTION* = ptr RTL_CRITICAL_SECTION + RTL_SRWLOCK* {.pure.} = object + Ptr*: PVOID + PRTL_SRWLOCK* = ptr RTL_SRWLOCK + RTL_CONDITION_VARIABLE* {.pure.} = object + Ptr*: PVOID + PRTL_CONDITION_VARIABLE* = ptr RTL_CONDITION_VARIABLE + WAITORTIMERCALLBACKFUNC* = proc (P1: PVOID, P2: BOOLEAN): VOID {.stdcall.} + WAITORTIMERCALLBACK* = WAITORTIMERCALLBACKFUNC + ACTIVATION_CONTEXT_QUERY_INDEX* {.pure.} = object + ulAssemblyIndex*: DWORD + ulFileIndexInAssembly*: DWORD + PACTIVATION_CONTEXT_QUERY_INDEX* = ptr ACTIVATION_CONTEXT_QUERY_INDEX + ASSEMBLY_FILE_DETAILED_INFORMATION* {.pure.} = object + ulFlags*: DWORD + ulFilenameLength*: DWORD + ulPathLength*: DWORD + lpFileName*: PCWSTR + lpFilePath*: PCWSTR + PASSEMBLY_FILE_DETAILED_INFORMATION* = ptr ASSEMBLY_FILE_DETAILED_INFORMATION + ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION* {.pure.} = object + ulFlags*: DWORD + ulEncodedAssemblyIdentityLength*: DWORD + ulManifestPathType*: DWORD + ulManifestPathLength*: DWORD + liManifestLastWriteTime*: LARGE_INTEGER + ulPolicyPathType*: DWORD + ulPolicyPathLength*: DWORD + liPolicyLastWriteTime*: LARGE_INTEGER + ulMetadataSatelliteRosterIndex*: DWORD + ulManifestVersionMajor*: DWORD + ulManifestVersionMinor*: DWORD + ulPolicyVersionMajor*: DWORD + ulPolicyVersionMinor*: DWORD + ulAssemblyDirectoryNameLength*: DWORD + lpAssemblyEncodedAssemblyIdentity*: PCWSTR + lpAssemblyManifestPath*: PCWSTR + lpAssemblyPolicyPath*: PCWSTR + lpAssemblyDirectoryName*: PCWSTR + ulFileCount*: DWORD + PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION* = ptr ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION + ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION* {.pure.} = object + ulFlags*: DWORD + RunLevel*: ACTCTX_REQUESTED_RUN_LEVEL + UiAccess*: DWORD + PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION* = ptr ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION + COMPATIBILITY_CONTEXT_ELEMENT* {.pure.} = object + Id*: GUID + Type*: ACTCTX_COMPATIBILITY_ELEMENT_TYPE + PCOMPATIBILITY_CONTEXT_ELEMENT* = ptr COMPATIBILITY_CONTEXT_ELEMENT + ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION* {.pure.} = object + ElementCount*: DWORD + Elements*: UncheckedArray[COMPATIBILITY_CONTEXT_ELEMENT] + PACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION* = ptr ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION +const + MAX_SUPPORTED_OS_NUM* = 4 +type + SUPPORTED_OS_INFO* {.pure.} = object + OsCount*: WORD + MitigationExist*: WORD + OsList*: array[MAX_SUPPORTED_OS_NUM, WORD] + PSUPPORTED_OS_INFO* = ptr SUPPORTED_OS_INFO + ACTIVATION_CONTEXT_DETAILED_INFORMATION* {.pure.} = object + dwFlags*: DWORD + ulFormatVersion*: DWORD + ulAssemblyCount*: DWORD + ulRootManifestPathType*: DWORD + ulRootManifestPathChars*: DWORD + ulRootConfigurationPathType*: DWORD + ulRootConfigurationPathChars*: DWORD + ulAppDirPathType*: DWORD + ulAppDirPathChars*: DWORD + lpRootManifestPath*: PCWSTR + lpRootConfigurationPath*: PCWSTR + lpAppDirPath*: PCWSTR + PACTIVATION_CONTEXT_DETAILED_INFORMATION* = ptr ACTIVATION_CONTEXT_DETAILED_INFORMATION + PCACTIVATION_CONTEXT_QUERY_INDEX* = ptr ACTIVATION_CONTEXT_QUERY_INDEX + PCASSEMBLY_FILE_DETAILED_INFORMATION* = ptr ASSEMBLY_FILE_DETAILED_INFORMATION + PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION* = ptr ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION + PCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION* = ptr ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION + PCCOMPATIBILITY_CONTEXT_ELEMENT* = ptr COMPATIBILITY_CONTEXT_ELEMENT + PCACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION* = ptr ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION + PCACTIVATION_CONTEXT_DETAILED_INFORMATION* = ptr ACTIVATION_CONTEXT_DETAILED_INFORMATION + ASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION* = ASSEMBLY_FILE_DETAILED_INFORMATION + PASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION* = PASSEMBLY_FILE_DETAILED_INFORMATION + PCASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION* = PCASSEMBLY_FILE_DETAILED_INFORMATION + RTL_VERIFIER_THUNK_DESCRIPTOR* {.pure.} = object + ThunkName*: PCHAR + ThunkOldAddress*: PVOID + ThunkNewAddress*: PVOID + PRTL_VERIFIER_THUNK_DESCRIPTOR* = ptr RTL_VERIFIER_THUNK_DESCRIPTOR + RTL_VERIFIER_DLL_DESCRIPTOR* {.pure.} = object + DllName*: PWCHAR + DllFlags*: DWORD + DllAddress*: PVOID + DllThunks*: PRTL_VERIFIER_THUNK_DESCRIPTOR + PRTL_VERIFIER_DLL_DESCRIPTOR* = ptr RTL_VERIFIER_DLL_DESCRIPTOR + RTL_VERIFIER_DLL_LOAD_CALLBACK* = proc (DllName: PWSTR, DllBase: PVOID, DllSize: SIZE_T, Reserved: PVOID): VOID {.stdcall.} + RTL_VERIFIER_DLL_UNLOAD_CALLBACK* = proc (DllName: PWSTR, DllBase: PVOID, DllSize: SIZE_T, Reserved: PVOID): VOID {.stdcall.} + RTL_VERIFIER_NTDLLHEAPFREE_CALLBACK* = proc (AllocationBase: PVOID, AllocationSize: SIZE_T): VOID {.stdcall.} + RTL_VERIFIER_PROVIDER_DESCRIPTOR* {.pure.} = object + Length*: DWORD + ProviderDlls*: PRTL_VERIFIER_DLL_DESCRIPTOR + ProviderDllLoadCallback*: RTL_VERIFIER_DLL_LOAD_CALLBACK + ProviderDllUnloadCallback*: RTL_VERIFIER_DLL_UNLOAD_CALLBACK + VerifierImage*: PWSTR + VerifierFlags*: DWORD + VerifierDebug*: DWORD + RtlpGetStackTraceAddress*: PVOID + RtlpDebugPageHeapCreate*: PVOID + RtlpDebugPageHeapDestroy*: PVOID + ProviderNtdllHeapFreeCallback*: RTL_VERIFIER_NTDLLHEAPFREE_CALLBACK + PRTL_VERIFIER_PROVIDER_DESCRIPTOR* = ptr RTL_VERIFIER_PROVIDER_DESCRIPTOR + HARDWARE_COUNTER_DATA* {.pure.} = object + Type*: HARDWARE_COUNTER_TYPE + Reserved*: DWORD + Value*: DWORD64 + PHARDWARE_COUNTER_DATA* = ptr HARDWARE_COUNTER_DATA +const + MAX_HW_COUNTERS* = 16 +type + PERFORMANCE_DATA* {.pure.} = object + Size*: WORD + Version*: BYTE + HwCountersCount*: BYTE + ContextSwitchCount*: DWORD + WaitReasonBitMap*: DWORD64 + CycleTime*: DWORD64 + RetryCount*: DWORD + Reserved*: DWORD + HwCounters*: array[MAX_HW_COUNTERS, HARDWARE_COUNTER_DATA] + PPERFORMANCE_DATA* = ptr PERFORMANCE_DATA + EVENTLOGRECORD* {.pure.} = object + Length*: DWORD + Reserved*: DWORD + RecordNumber*: DWORD + TimeGenerated*: DWORD + TimeWritten*: DWORD + EventID*: DWORD + EventType*: WORD + NumStrings*: WORD + EventCategory*: WORD + ReservedFlags*: WORD + ClosingRecordNumber*: DWORD + StringOffset*: DWORD + UserSidLength*: DWORD + UserSidOffset*: DWORD + DataLength*: DWORD + DataOffset*: DWORD + PEVENTLOGRECORD* = ptr EVENTLOGRECORD +const + MAXLOGICALLOGNAMESIZE* = 256 +type + EVENTSFORLOGFILE* {.pure.} = object + ulSize*: DWORD + szLogicalLogFile*: array[MAXLOGICALLOGNAMESIZE, WCHAR] + ulNumRecords*: DWORD + pEventLogRecords*: UncheckedArray[EVENTLOGRECORD] + PEVENTSFORLOGFILE* = ptr EVENTSFORLOGFILE + PACKEDEVENTINFO* {.pure.} = object + ulSize*: DWORD + ulNumEventsForLogFile*: DWORD + ulOffsets*: UncheckedArray[DWORD] + PPACKEDEVENTINFO* = ptr PACKEDEVENTINFO + TAPE_ERASE* {.pure.} = object + Type*: DWORD + Immediate*: BOOLEAN + PTAPE_ERASE* = ptr TAPE_ERASE + TAPE_PREPARE* {.pure.} = object + Operation*: DWORD + Immediate*: BOOLEAN + PTAPE_PREPARE* = ptr TAPE_PREPARE + TAPE_WRITE_MARKS* {.pure.} = object + Type*: DWORD + Count*: DWORD + Immediate*: BOOLEAN + PTAPE_WRITE_MARKS* = ptr TAPE_WRITE_MARKS + TAPE_GET_POSITION* {.pure.} = object + Type*: DWORD + Partition*: DWORD + Offset*: LARGE_INTEGER + PTAPE_GET_POSITION* = ptr TAPE_GET_POSITION + TAPE_SET_POSITION* {.pure.} = object + Method*: DWORD + Partition*: DWORD + Offset*: LARGE_INTEGER + Immediate*: BOOLEAN + PTAPE_SET_POSITION* = ptr TAPE_SET_POSITION + TAPE_GET_DRIVE_PARAMETERS* {.pure.} = object + ECC*: BOOLEAN + Compression*: BOOLEAN + DataPadding*: BOOLEAN + ReportSetmarks*: BOOLEAN + DefaultBlockSize*: DWORD + MaximumBlockSize*: DWORD + MinimumBlockSize*: DWORD + MaximumPartitionCount*: DWORD + FeaturesLow*: DWORD + FeaturesHigh*: DWORD + EOTWarningZoneSize*: DWORD + PTAPE_GET_DRIVE_PARAMETERS* = ptr TAPE_GET_DRIVE_PARAMETERS + TAPE_SET_DRIVE_PARAMETERS* {.pure.} = object + ECC*: BOOLEAN + Compression*: BOOLEAN + DataPadding*: BOOLEAN + ReportSetmarks*: BOOLEAN + EOTWarningZoneSize*: DWORD + PTAPE_SET_DRIVE_PARAMETERS* = ptr TAPE_SET_DRIVE_PARAMETERS + TAPE_GET_MEDIA_PARAMETERS* {.pure.} = object + Capacity*: LARGE_INTEGER + Remaining*: LARGE_INTEGER + BlockSize*: DWORD + PartitionCount*: DWORD + WriteProtected*: BOOLEAN + PTAPE_GET_MEDIA_PARAMETERS* = ptr TAPE_GET_MEDIA_PARAMETERS + TAPE_SET_MEDIA_PARAMETERS* {.pure.} = object + BlockSize*: DWORD + PTAPE_SET_MEDIA_PARAMETERS* = ptr TAPE_SET_MEDIA_PARAMETERS + TAPE_CREATE_PARTITION* {.pure.} = object + Method*: DWORD + Count*: DWORD + Size*: DWORD + PTAPE_CREATE_PARTITION* = ptr TAPE_CREATE_PARTITION + TAPE_WMI_OPERATIONS* {.pure.} = object + Method*: DWORD + DataBufferSize*: DWORD + DataBuffer*: PVOID + PTAPE_WMI_OPERATIONS* = ptr TAPE_WMI_OPERATIONS + TP_CALLBACK_INSTANCE* {.pure.} = object + PTP_CALLBACK_INSTANCE* = ptr TP_CALLBACK_INSTANCE + TP_POOL* {.pure.} = object + PTP_POOL* = ptr TP_POOL + TP_POOL_STACK_INFORMATION* {.pure.} = object + StackReserve*: SIZE_T + StackCommit*: SIZE_T + PTP_POOL_STACK_INFORMATION* = ptr TP_POOL_STACK_INFORMATION + TP_CLEANUP_GROUP* {.pure.} = object + PTP_CLEANUP_GROUP* = ptr TP_CLEANUP_GROUP + PTP_CLEANUP_GROUP_CANCEL_CALLBACK* = proc (ObjectContext: PVOID, CleanupContext: PVOID): VOID {.stdcall.} + ACTIVATION_CONTEXT* {.pure.} = object + PTP_SIMPLE_CALLBACK* = proc (Instance: PTP_CALLBACK_INSTANCE, Context: PVOID): VOID {.stdcall.} + TP_CALLBACK_ENVIRON_V3_u_s* {.pure.} = object + LongFunction* {.bitsize:1.}: DWORD + Persistent* {.bitsize:1.}: DWORD + Private* {.bitsize:30.}: DWORD + TP_CALLBACK_ENVIRON_V3_u* {.pure, union.} = object + Flags*: DWORD + s*: TP_CALLBACK_ENVIRON_V3_u_s + TP_CALLBACK_ENVIRON_V3* {.pure.} = object + Version*: TP_VERSION + Pool*: PTP_POOL + CleanupGroup*: PTP_CLEANUP_GROUP + CleanupGroupCancelCallback*: PTP_CLEANUP_GROUP_CANCEL_CALLBACK + RaceDll*: PVOID + ActivationContext*: ptr ACTIVATION_CONTEXT + FinalizationCallback*: PTP_SIMPLE_CALLBACK + u*: TP_CALLBACK_ENVIRON_V3_u + CallbackPriority*: TP_CALLBACK_PRIORITY + Size*: DWORD + TP_CALLBACK_ENVIRON* = TP_CALLBACK_ENVIRON_V3 + PTP_CALLBACK_ENVIRON* = ptr TP_CALLBACK_ENVIRON_V3 + TP_WORK* {.pure.} = object + PTP_WORK* = ptr TP_WORK + TP_TIMER* {.pure.} = object + PTP_TIMER* = ptr TP_TIMER + TP_WAIT* {.pure.} = object + PTP_WAIT* = ptr TP_WAIT + TP_IO* {.pure.} = object + PTP_IO* = ptr TP_IO + CRM_PROTOCOL_ID* = GUID + PCRM_PROTOCOL_ID* = ptr GUID + TRANSACTION_NOTIFICATION* {.pure.} = object + TransactionKey*: PVOID + TransactionNotification*: ULONG + TmVirtualClock*: LARGE_INTEGER + ArgumentLength*: ULONG + PTRANSACTION_NOTIFICATION* = ptr TRANSACTION_NOTIFICATION + TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT* {.pure.} = object + EnlistmentId*: GUID + UOW*: GUID + PTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT + TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT* {.pure.} = object + TmIdentity*: GUID + Flags*: ULONG + PTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT + TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT* {.pure.} = object + SavepointId*: SAVEPOINT_ID + PTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT + TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT* {.pure.} = object + PropagationCookie*: ULONG + UOW*: GUID + TmIdentity*: GUID + BufferLength*: ULONG + PTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT + TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT* {.pure.} = object + MarshalCookie*: ULONG + UOW*: GUID + PTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT + TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT* = TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT + PTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT* = ptr TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT + KCRM_MARSHAL_HEADER* {.pure.} = object + VersionMajor*: ULONG + VersionMinor*: ULONG + NumProtocols*: ULONG + Unused*: ULONG + PKCRM_MARSHAL_HEADER* = ptr KCRM_MARSHAL_HEADER + PRKCRM_MARSHAL_HEADER* = ptr KCRM_MARSHAL_HEADER +const + MAX_TRANSACTION_DESCRIPTION_LENGTH* = 64 +type + KCRM_TRANSACTION_BLOB* {.pure.} = object + UOW*: GUID + TmIdentity*: GUID + IsolationLevel*: ULONG + IsolationFlags*: ULONG + Timeout*: ULONG + Description*: array[MAX_TRANSACTION_DESCRIPTION_LENGTH, WCHAR] + PKCRM_TRANSACTION_BLOB* = ptr KCRM_TRANSACTION_BLOB + PRKCRM_TRANSACTION_BLOB* = ptr KCRM_TRANSACTION_BLOB + KCRM_PROTOCOL_BLOB* {.pure.} = object + ProtocolId*: CRM_PROTOCOL_ID + StaticInfoLength*: ULONG + TransactionIdInfoLength*: ULONG + Unused1*: ULONG + Unused2*: ULONG + PKCRM_PROTOCOL_BLOB* = ptr KCRM_PROTOCOL_BLOB + PRKCRM_PROTOCOL_BLOB* = ptr KCRM_PROTOCOL_BLOB + TRANSACTION_BASIC_INFORMATION* {.pure.} = object + TransactionId*: GUID + State*: DWORD + Outcome*: DWORD + PTRANSACTION_BASIC_INFORMATION* = ptr TRANSACTION_BASIC_INFORMATION + TRANSACTIONMANAGER_BASIC_INFORMATION* {.pure.} = object + TmIdentity*: GUID + VirtualClock*: LARGE_INTEGER + PTRANSACTIONMANAGER_BASIC_INFORMATION* = ptr TRANSACTIONMANAGER_BASIC_INFORMATION + TRANSACTIONMANAGER_LOG_INFORMATION* {.pure.} = object + LogIdentity*: GUID + PTRANSACTIONMANAGER_LOG_INFORMATION* = ptr TRANSACTIONMANAGER_LOG_INFORMATION + TRANSACTIONMANAGER_LOGPATH_INFORMATION* {.pure.} = object + LogPathLength*: DWORD + LogPath*: array[1, WCHAR] + PTRANSACTIONMANAGER_LOGPATH_INFORMATION* = ptr TRANSACTIONMANAGER_LOGPATH_INFORMATION + TRANSACTIONMANAGER_RECOVERY_INFORMATION* {.pure.} = object + LastRecoveredLsn*: ULONGLONG + PTRANSACTIONMANAGER_RECOVERY_INFORMATION* = ptr TRANSACTIONMANAGER_RECOVERY_INFORMATION + TRANSACTIONMANAGER_OLDEST_INFORMATION* {.pure.} = object + OldestTransactionGuid*: GUID + PTRANSACTIONMANAGER_OLDEST_INFORMATION* = ptr TRANSACTIONMANAGER_OLDEST_INFORMATION + TRANSACTION_PROPERTIES_INFORMATION* {.pure.} = object + IsolationLevel*: DWORD + IsolationFlags*: DWORD + Timeout*: LARGE_INTEGER + Outcome*: DWORD + DescriptionLength*: DWORD + Description*: array[1, WCHAR] + PTRANSACTION_PROPERTIES_INFORMATION* = ptr TRANSACTION_PROPERTIES_INFORMATION + TRANSACTION_BIND_INFORMATION* {.pure.} = object + TmHandle*: HANDLE + PTRANSACTION_BIND_INFORMATION* = ptr TRANSACTION_BIND_INFORMATION + TRANSACTION_ENLISTMENT_PAIR* {.pure.} = object + EnlistmentId*: GUID + ResourceManagerId*: GUID + PTRANSACTION_ENLISTMENT_PAIR* = ptr TRANSACTION_ENLISTMENT_PAIR + TRANSACTION_ENLISTMENTS_INFORMATION* {.pure.} = object + NumberOfEnlistments*: DWORD + EnlistmentPair*: array[1, TRANSACTION_ENLISTMENT_PAIR] + PTRANSACTION_ENLISTMENTS_INFORMATION* = ptr TRANSACTION_ENLISTMENTS_INFORMATION + TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION* {.pure.} = object + SuperiorEnlistmentPair*: TRANSACTION_ENLISTMENT_PAIR + PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION* = ptr TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION + RESOURCEMANAGER_BASIC_INFORMATION* {.pure.} = object + ResourceManagerId*: GUID + DescriptionLength*: DWORD + Description*: array[1, WCHAR] + PRESOURCEMANAGER_BASIC_INFORMATION* = ptr RESOURCEMANAGER_BASIC_INFORMATION + RESOURCEMANAGER_COMPLETION_INFORMATION* {.pure.} = object + IoCompletionPortHandle*: HANDLE + CompletionKey*: ULONG_PTR + PRESOURCEMANAGER_COMPLETION_INFORMATION* = ptr RESOURCEMANAGER_COMPLETION_INFORMATION + ENLISTMENT_BASIC_INFORMATION* {.pure.} = object + EnlistmentId*: GUID + TransactionId*: GUID + ResourceManagerId*: GUID + PENLISTMENT_BASIC_INFORMATION* = ptr ENLISTMENT_BASIC_INFORMATION + ENLISTMENT_CRM_INFORMATION* {.pure.} = object + CrmTransactionManagerId*: GUID + CrmResourceManagerId*: GUID + CrmEnlistmentId*: GUID + PENLISTMENT_CRM_INFORMATION* = ptr ENLISTMENT_CRM_INFORMATION + TRANSACTION_LIST_ENTRY* {.pure.} = object + UOW*: GUID + PTRANSACTION_LIST_ENTRY* = ptr TRANSACTION_LIST_ENTRY + TRANSACTION_LIST_INFORMATION* {.pure.} = object + NumberOfTransactions*: DWORD + TransactionInformation*: array[1, TRANSACTION_LIST_ENTRY] + PTRANSACTION_LIST_INFORMATION* = ptr TRANSACTION_LIST_INFORMATION + KTMOBJECT_CURSOR* {.pure.} = object + LastQuery*: GUID + ObjectIdCount*: DWORD + ObjectIds*: array[1, GUID] + PKTMOBJECT_CURSOR* = ptr KTMOBJECT_CURSOR +const + WOW64_SIZE_OF_80387_REGISTERS* = 80 +type + WOW64_FLOATING_SAVE_AREA* {.pure.} = object + ControlWord*: DWORD + StatusWord*: DWORD + TagWord*: DWORD + ErrorOffset*: DWORD + ErrorSelector*: DWORD + DataOffset*: DWORD + DataSelector*: DWORD + RegisterArea*: array[WOW64_SIZE_OF_80387_REGISTERS, BYTE] + Cr0NpxState*: DWORD + PWOW64_FLOATING_SAVE_AREA* = ptr WOW64_FLOATING_SAVE_AREA +const + WOW64_MAXIMUM_SUPPORTED_EXTENSION* = 512 +type + WOW64_CONTEXT* {.pure.} = object + ContextFlags*: DWORD + Dr0*: DWORD + Dr1*: DWORD + Dr2*: DWORD + Dr3*: DWORD + Dr6*: DWORD + Dr7*: DWORD + FloatSave*: WOW64_FLOATING_SAVE_AREA + SegGs*: DWORD + SegFs*: DWORD + SegEs*: DWORD + SegDs*: DWORD + Edi*: DWORD + Esi*: DWORD + Ebx*: DWORD + Edx*: DWORD + Ecx*: DWORD + Eax*: DWORD + Ebp*: DWORD + Eip*: DWORD + SegCs*: DWORD + EFlags*: DWORD + Esp*: DWORD + SegSs*: DWORD + ExtendedRegisters*: array[WOW64_MAXIMUM_SUPPORTED_EXTENSION, BYTE] + PWOW64_CONTEXT* = ptr WOW64_CONTEXT + WOW64_LDT_ENTRY_HighWord_Bytes* {.pure.} = object + BaseMid*: BYTE + Flags1*: BYTE + Flags2*: BYTE + BaseHi*: BYTE + WOW64_LDT_ENTRY_HighWord_Bits* {.pure.} = object + BaseMid* {.bitsize:8.}: DWORD + Type* {.bitsize:5.}: DWORD + Dpl* {.bitsize:2.}: DWORD + Pres* {.bitsize:1.}: DWORD + LimitHi* {.bitsize:4.}: DWORD + Sys* {.bitsize:1.}: DWORD + Reserved_0* {.bitsize:1.}: DWORD + Default_Big* {.bitsize:1.}: DWORD + Granularity* {.bitsize:1.}: DWORD + BaseHi* {.bitsize:8.}: DWORD + WOW64_LDT_ENTRY_HighWord* {.pure, union.} = object + Bytes*: WOW64_LDT_ENTRY_HighWord_Bytes + Bits*: WOW64_LDT_ENTRY_HighWord_Bits + WOW64_LDT_ENTRY* {.pure.} = object + LimitLow*: WORD + BaseLow*: WORD + HighWord*: WOW64_LDT_ENTRY_HighWord + PWOW64_LDT_ENTRY* = ptr WOW64_LDT_ENTRY + WOW64_DESCRIPTOR_TABLE_ENTRY* {.pure.} = object + Selector*: DWORD + Descriptor*: WOW64_LDT_ENTRY + PWOW64_DESCRIPTOR_TABLE_ENTRY* = ptr WOW64_DESCRIPTOR_TABLE_ENTRY + PHKEY* = ptr HKEY + FILETIME* {.pure.} = object + dwLowDateTime*: DWORD + dwHighDateTime*: DWORD + PFILETIME* = ptr FILETIME + LPFILETIME* = ptr FILETIME + RECT* {.pure.} = object + left*: LONG + top*: LONG + right*: LONG + bottom*: LONG + PRECT* = ptr RECT + NPRECT* = ptr RECT + LPRECT* = ptr RECT + LPCRECT* = ptr RECT + RECTL* {.pure.} = object + left*: LONG + top*: LONG + right*: LONG + bottom*: LONG + PRECTL* = ptr RECTL + LPRECTL* = ptr RECTL + LPCRECTL* = ptr RECTL + POINT* {.pure.} = object + x*: LONG + y*: LONG + PPOINT* = ptr POINT + NPPOINT* = ptr POINT + LPPOINT* = ptr POINT + POINTL* {.pure.} = object + x*: LONG + y*: LONG + PPOINTL* = ptr POINTL + SIZE* {.pure.} = object + cx*: LONG + cy*: LONG + PSIZE* = ptr SIZE + LPSIZE* = ptr SIZE + SIZEL* = SIZE + PSIZEL* = ptr SIZE + LPSIZEL* = ptr SIZE + POINTS* {.pure.} = object + x*: SHORT + y*: SHORT + PPOINTS* = ptr POINTS + LPPOINTS* = ptr POINTS + PEB_LDR_DATA* {.pure.} = object + Reserved1*: array[8, BYTE] + Reserved2*: array[3, PVOID] + InMemoryOrderModuleList*: LIST_ENTRY + PPEB_LDR_DATA* = ptr PEB_LDR_DATA + LDR_DATA_TABLE_ENTRY_UNION1* {.pure, union.} = object + CheckSum*: ULONG + Reserved6*: PVOID + LDR_DATA_TABLE_ENTRY* {.pure.} = object + Reserved1*: array[2, PVOID] + InMemoryOrderLinks*: LIST_ENTRY + Reserved2*: array[2, PVOID] + DllBase*: PVOID + Reserved3*: array[2, PVOID] + FullDllName*: UNICODE_STRING + Reserved4*: array[8, BYTE] + Reserved5*: array[3, PVOID] + union1*: LDR_DATA_TABLE_ENTRY_UNION1 + TimeDateStamp*: ULONG + PLDR_DATA_TABLE_ENTRY* = ptr LDR_DATA_TABLE_ENTRY + RTL_USER_PROCESS_PARAMETERS* {.pure.} = object + Reserved1*: array[16, BYTE] + Reserved2*: array[10, PVOID] + ImagePathName*: UNICODE_STRING + CommandLine*: UNICODE_STRING + PRTL_USER_PROCESS_PARAMETERS* = ptr RTL_USER_PROCESS_PARAMETERS + PPS_POST_PROCESS_INIT_ROUTINE* = proc (): VOID {.stdcall.} + PEB* {.pure.} = object + Reserved1*: array[2, BYTE] + BeingDebugged*: BYTE + Reserved2*: array[1, BYTE] + Reserved3*: array[2, PVOID] + Ldr*: PPEB_LDR_DATA + ProcessParameters*: PRTL_USER_PROCESS_PARAMETERS + Reserved4*: array[104, BYTE] + Reserved5*: array[52, PVOID] + PostProcessInitRoutine*: PPS_POST_PROCESS_INIT_ROUTINE + Reserved6*: array[128, BYTE] + Reserved7*: array[1, PVOID] + SessionId*: ULONG + PPEB* = ptr PEB + TEB* {.pure.} = object + Reserved1*: array[1952, BYTE] + Reserved2*: array[412, PVOID] + TlsSlots*: array[64, PVOID] + Reserved3*: array[8, BYTE] + Reserved4*: array[26, PVOID] + ReservedForOle*: PVOID + Reserved5*: array[4, PVOID] + TlsExpansionSlots*: PVOID + PTEB* = ptr TEB + OBJECT_DATA_INFORMATION* {.pure.} = object + InheritHandle*: BOOLEAN + ProtectFromClose*: BOOLEAN + POBJECT_DATA_INFORMATION* = ptr OBJECT_DATA_INFORMATION + OBJECT_BASIC_INFORMATION* {.pure.} = object + Attributes*: ULONG + GrantedAccess*: ACCESS_MASK + HandleCount*: ULONG + PointerCount*: ULONG + PagedPoolUsage*: ULONG + NonPagedPoolUsage*: ULONG + Reserved*: array[3, ULONG] + NameInformationLength*: ULONG + TypeInformationLength*: ULONG + SecurityDescriptorLength*: ULONG + CreateTime*: LARGE_INTEGER + POBJECT_BASIC_INFORMATION* = ptr OBJECT_BASIC_INFORMATION + OBJECT_NAME_INFORMATION* {.pure.} = object + Name*: UNICODE_STRING + POBJECT_NAME_INFORMATION* = ptr OBJECT_NAME_INFORMATION + OBJECT_TYPE_INFORMATION* {.pure.} = object + TypeName*: UNICODE_STRING + TotalNumberOfObjects*: ULONG + TotalNumberOfHandles*: ULONG + TotalPagedPoolUsage*: ULONG + TotalNonPagedPoolUsage*: ULONG + TotalNamePoolUsage*: ULONG + TotalHandleTableUsage*: ULONG + HighWaterNumberOfObjects*: ULONG + HighWaterNumberOfHandles*: ULONG + HighWaterPagedPoolUsage*: ULONG + HighWaterNonPagedPoolUsage*: ULONG + HighWaterNamePoolUsage*: ULONG + HighWaterHandleTableUsage*: ULONG + InvalidAttributes*: ULONG + GenericMapping*: GENERIC_MAPPING + ValidAccessMask*: ULONG + SecurityRequired*: BOOLEAN + MaintainHandleCount*: BOOLEAN + PoolType*: ULONG + DefaultPagedPoolCharge*: ULONG + DefaultNonPagedPoolCharge*: ULONG + POBJECT_TYPE_INFORMATION* = ptr OBJECT_TYPE_INFORMATION + OBJECT_ALL_INFORMATION* {.pure.} = object + NumberOfObjects*: ULONG + ObjectTypeInformation*: array[1, OBJECT_TYPE_INFORMATION] + POBJECT_ALL_INFORMATION* = ptr OBJECT_ALL_INFORMATION + FILE_DIRECTORY_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + FileName*: array[ANYSIZE_ARRAY, WCHAR] + PFILE_DIRECTORY_INFORMATION* = ptr FILE_DIRECTORY_INFORMATION + FILE_FULL_DIR_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + FileName*: array[ANYSIZE_ARRAY, WCHAR] + PFILE_FULL_DIR_INFORMATION* = ptr FILE_FULL_DIR_INFORMATION + FILE_ID_FULL_DIR_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + FileId*: LARGE_INTEGER + FileName*: array[ANYSIZE_ARRAY, WCHAR] + PFILE_ID_FULL_DIR_INFORMATION* = ptr FILE_ID_FULL_DIR_INFORMATION + FILE_BOTH_DIR_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + ShortNameLength*: CHAR + ShortName*: array[12, WCHAR] + FileName*: array[ANYSIZE_ARRAY, WCHAR] + PFILE_BOTH_DIR_INFORMATION* = ptr FILE_BOTH_DIR_INFORMATION + FILE_ID_BOTH_DIR_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + FileAttributes*: ULONG + FileNameLength*: ULONG + EaSize*: ULONG + ShortNameLength*: CHAR + ShortName*: array[12, WCHAR] + FileId*: LARGE_INTEGER + FileName*: array[ANYSIZE_ARRAY, WCHAR] + PFILE_ID_BOTH_DIR_INFORMATION* = ptr FILE_ID_BOTH_DIR_INFORMATION + FILE_FULL_DIRECTORY_INFORMATION* = FILE_FULL_DIR_INFORMATION + PFILE_FULL_DIRECTORY_INFORMATION* = ptr FILE_FULL_DIR_INFORMATION + FILE_ID_FULL_DIRECTORY_INFORMATION* = FILE_ID_FULL_DIR_INFORMATION + PFILE_ID_FULL_DIRECTORY_INFORMATION* = ptr FILE_ID_FULL_DIR_INFORMATION + FILE_BOTH_DIRECTORY_INFORMATION* = FILE_BOTH_DIR_INFORMATION + PFILE_BOTH_DIRECTORY_INFORMATION* = ptr FILE_BOTH_DIR_INFORMATION + FILE_ID_BOTH_DIRECTORY_INFORMATION* = FILE_ID_BOTH_DIR_INFORMATION + PFILE_ID_BOTH_DIRECTORY_INFORMATION* = ptr FILE_ID_BOTH_DIR_INFORMATION + FILE_BASIC_INFORMATION* {.pure.} = object + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + FileAttributes*: ULONG + PFILE_BASIC_INFORMATION* = ptr FILE_BASIC_INFORMATION + FILE_STANDARD_INFORMATION* {.pure.} = object + AllocationSize*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + NumberOfLinks*: ULONG + DeletePending*: BOOLEAN + Directory*: BOOLEAN + PFILE_STANDARD_INFORMATION* = ptr FILE_STANDARD_INFORMATION + FILE_INTERNAL_INFORMATION* {.pure.} = object + IndexNumber*: LARGE_INTEGER + PFILE_INTERNAL_INFORMATION* = ptr FILE_INTERNAL_INFORMATION + FILE_EA_INFORMATION* {.pure.} = object + EaSize*: ULONG + PFILE_EA_INFORMATION* = ptr FILE_EA_INFORMATION + FILE_ACCESS_INFORMATION* {.pure.} = object + AccessFlags*: ACCESS_MASK + PFILE_ACCESS_INFORMATION* = ptr FILE_ACCESS_INFORMATION + FILE_LINK_INFORMATION* {.pure.} = object + ReplaceIfExists*: BOOLEAN + RootDirectory*: HANDLE + FileNameLength*: ULONG + FileName*: array[1, WCHAR] + PFILE_LINK_INFORMATION* = ptr FILE_LINK_INFORMATION + FILE_NAME_INFORMATION* {.pure.} = object + FileNameLength*: ULONG + FileName*: array[1, WCHAR] + PFILE_NAME_INFORMATION* = ptr FILE_NAME_INFORMATION + FILE_RENAME_INFORMATION* {.pure.} = object + ReplaceIfExists*: BOOLEAN + RootDirectory*: HANDLE + FileNameLength*: ULONG + FileName*: array[1, WCHAR] + PFILE_RENAME_INFORMATION* = ptr FILE_RENAME_INFORMATION + FILE_NAMES_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + FileIndex*: ULONG + FileNameLength*: ULONG + FileName*: array[1, WCHAR] + PFILE_NAMES_INFORMATION* = ptr FILE_NAMES_INFORMATION + FILE_DISPOSITION_INFORMATION* {.pure.} = object + DoDeleteFile*: BOOLEAN + PFILE_DISPOSITION_INFORMATION* = ptr FILE_DISPOSITION_INFORMATION + FILE_POSITION_INFORMATION* {.pure.} = object + CurrentByteOffset*: LARGE_INTEGER + PFILE_POSITION_INFORMATION* = ptr FILE_POSITION_INFORMATION + FILE_ALIGNMENT_INFORMATION* {.pure.} = object + AlignmentRequirement*: ULONG + PFILE_ALIGNMENT_INFORMATION* = ptr FILE_ALIGNMENT_INFORMATION + FILE_ALLOCATION_INFORMATION* {.pure.} = object + AllocationSize*: LARGE_INTEGER + PFILE_ALLOCATION_INFORMATION* = ptr FILE_ALLOCATION_INFORMATION + FILE_END_OF_FILE_INFORMATION* {.pure.} = object + EndOfFile*: LARGE_INTEGER + PFILE_END_OF_FILE_INFORMATION* = ptr FILE_END_OF_FILE_INFORMATION + FILE_NETWORK_OPEN_INFORMATION* {.pure.} = object + CreationTime*: LARGE_INTEGER + LastAccessTime*: LARGE_INTEGER + LastWriteTime*: LARGE_INTEGER + ChangeTime*: LARGE_INTEGER + AllocationSize*: LARGE_INTEGER + EndOfFile*: LARGE_INTEGER + FileAttributes*: ULONG + PFILE_NETWORK_OPEN_INFORMATION* = ptr FILE_NETWORK_OPEN_INFORMATION + FILE_FULL_EA_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + Flags*: UCHAR + EaNameLength*: UCHAR + EaValueLength*: USHORT + EaName*: array[1, CHAR] + PFILE_FULL_EA_INFORMATION* = ptr FILE_FULL_EA_INFORMATION + FILE_MODE_INFORMATION* {.pure.} = object + Mode*: ULONG + PFILE_MODE_INFORMATION* = ptr FILE_MODE_INFORMATION + FILE_STREAM_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + StreamNameLength*: ULONG + StreamSize*: LARGE_INTEGER + StreamAllocationSize*: LARGE_INTEGER + StreamName*: array[1, WCHAR] + PFILE_STREAM_INFORMATION* = ptr FILE_STREAM_INFORMATION + FILE_ATTRIBUTE_TAG_INFORMATION* {.pure.} = object + FileAttributes*: ULONG + ReparseTag*: ULONG + PFILE_ATTRIBUTE_TAG_INFORMATION* = ptr FILE_ATTRIBUTE_TAG_INFORMATION + FILE_MAILSLOT_QUERY_INFORMATION* {.pure.} = object + MaximumMessageSize*: ULONG + MailslotQuota*: ULONG + NextMessageSize*: ULONG + MessagesAvailable*: ULONG + ReadTimeout*: LARGE_INTEGER + PFILE_MAILSLOT_QUERY_INFORMATION* = ptr FILE_MAILSLOT_QUERY_INFORMATION + FILE_MAILSLOT_SET_INFORMATION* {.pure.} = object + ReadTimeout*: LARGE_INTEGER + PFILE_MAILSLOT_SET_INFORMATION* = ptr FILE_MAILSLOT_SET_INFORMATION + FILE_PIPE_LOCAL_INFORMATION* {.pure.} = object + NamedPipeType*: ULONG + NamedPipeConfiguration*: ULONG + MaximumInstances*: ULONG + CurrentInstances*: ULONG + InboundQuota*: ULONG + ReadDataAvailable*: ULONG + OutboundQuota*: ULONG + WriteQuotaAvailable*: ULONG + NamedPipeState*: ULONG + NamedPipeEnd*: ULONG + PFILE_PIPE_LOCAL_INFORMATION* = ptr FILE_PIPE_LOCAL_INFORMATION + FILE_ALL_INFORMATION* {.pure.} = object + BasicInformation*: FILE_BASIC_INFORMATION + StandardInformation*: FILE_STANDARD_INFORMATION + InternalInformation*: FILE_INTERNAL_INFORMATION + EaInformation*: FILE_EA_INFORMATION + AccessInformation*: FILE_ACCESS_INFORMATION + PositionInformation*: FILE_POSITION_INFORMATION + ModeInformation*: FILE_MODE_INFORMATION + AlignmentInformation*: FILE_ALIGNMENT_INFORMATION + NameInformation*: FILE_NAME_INFORMATION + PFILE_ALL_INFORMATION* = ptr FILE_ALL_INFORMATION + FILE_FS_VOLUME_INFORMATION* {.pure.} = object + VolumeCreationTime*: LARGE_INTEGER + VolumeSerialNumber*: ULONG + VolumeLabelLength*: ULONG + SupportsObjects*: BOOLEAN + VolumeLabel*: array[1, WCHAR] + PFILE_FS_VOLUME_INFORMATION* = ptr FILE_FS_VOLUME_INFORMATION + FILE_FS_LABEL_INFORMATION* {.pure.} = object + VolumeLabelLength*: ULONG + VolumeLabel*: array[1, WCHAR] + PFILE_FS_LABEL_INFORMATION* = ptr FILE_FS_LABEL_INFORMATION + FILE_FS_SIZE_INFORMATION* {.pure.} = object + TotalAllocationUnits*: LARGE_INTEGER + AvailableAllocationUnits*: LARGE_INTEGER + SectorsPerAllocationUnit*: ULONG + BytesPerSector*: ULONG + PFILE_FS_SIZE_INFORMATION* = ptr FILE_FS_SIZE_INFORMATION + FILE_FS_DEVICE_INFORMATION* {.pure.} = object + DeviceType*: DEVICE_TYPE + Characteristics*: ULONG + PFILE_FS_DEVICE_INFORMATION* = ptr FILE_FS_DEVICE_INFORMATION + FILE_FS_ATTRIBUTE_INFORMATION* {.pure.} = object + FileSystemAttributes*: ULONG + MaximumComponentNameLength*: ULONG + FileSystemNameLength*: ULONG + FileSystemName*: array[1, WCHAR] + PFILE_FS_ATTRIBUTE_INFORMATION* = ptr FILE_FS_ATTRIBUTE_INFORMATION + FILE_FS_FULL_SIZE_INFORMATION* {.pure.} = object + TotalAllocationUnits*: LARGE_INTEGER + CallerAvailableAllocationUnits*: LARGE_INTEGER + ActualAvailableAllocationUnits*: LARGE_INTEGER + SectorsPerAllocationUnit*: ULONG + BytesPerSector*: ULONG + PFILE_FS_FULL_SIZE_INFORMATION* = ptr FILE_FS_FULL_SIZE_INFORMATION + FILE_FS_OBJECTID_INFORMATION* {.pure.} = object + ObjectId*: array[16, UCHAR] + ExtendedInfo*: array[48, UCHAR] + PFILE_FS_OBJECTID_INFORMATION* = ptr FILE_FS_OBJECTID_INFORMATION + IO_STATUS_BLOCK_UNION1* {.pure, union.} = object + Status*: NTSTATUS + Pointer*: PVOID + IO_STATUS_BLOCK* {.pure.} = object + union1*: IO_STATUS_BLOCK_UNION1 + Information*: ULONG_PTR + PIO_STATUS_BLOCK* = ptr IO_STATUS_BLOCK + VM_COUNTERS* {.pure.} = object + PeakVirtualSize*: SIZE_T + VirtualSize*: SIZE_T + PageFaultCount*: ULONG + PeakWorkingSetSize*: SIZE_T + WorkingSetSize*: SIZE_T + QuotaPeakPagedPoolUsage*: SIZE_T + QuotaPagedPoolUsage*: SIZE_T + QuotaPeakNonPagedPoolUsage*: SIZE_T + QuotaNonPagedPoolUsage*: SIZE_T + PagefileUsage*: SIZE_T + PeakPagefileUsage*: SIZE_T + PVM_COUNTERS* = ptr VM_COUNTERS + CLIENT_ID* {.pure.} = object + UniqueProcess*: HANDLE + UniqueThread*: HANDLE + PCLIENT_ID* = ptr CLIENT_ID + SYSTEM_THREADS* {.pure.} = object + KernelTime*: LARGE_INTEGER + UserTime*: LARGE_INTEGER + CreateTime*: LARGE_INTEGER + WaitTime*: ULONG + StartAddress*: PVOID + ClientId*: CLIENT_ID + Priority*: KPRIORITY + BasePriority*: KPRIORITY + ContextSwitchCount*: ULONG + State*: THREAD_STATE + WaitReason*: KWAIT_REASON + PSYSTEM_THREADS* = ptr SYSTEM_THREADS + PROCESS_BASIC_INFORMATION* {.pure.} = object + ExitStatus*: NTSTATUS + PebBaseAddress*: PPEB + AffinityMask*: KAFFINITY + BasePriority*: KPRIORITY + UniqueProcessId*: ULONG_PTR + InheritedFromUniqueProcessId*: ULONG_PTR + PPROCESS_BASIC_INFORMATION* = ptr PROCESS_BASIC_INFORMATION + KERNEL_USER_TIMES* {.pure.} = object + CreateTime*: FILETIME + ExitTime*: FILETIME + KernelTime*: LARGE_INTEGER + UserTime*: LARGE_INTEGER + PKERNEL_USER_TIMES* = ptr KERNEL_USER_TIMES + SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* {.pure.} = object + IdleTime*: LARGE_INTEGER + KernelTime*: LARGE_INTEGER + UserTime*: LARGE_INTEGER + Reserved1*: array[2, LARGE_INTEGER] + Reserved2*: ULONG + PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* = ptr SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION + SYSTEM_PROCESS_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + NumberOfThreads*: ULONG + Reserved*: array[3, LARGE_INTEGER] + CreateTime*: LARGE_INTEGER + UserTime*: LARGE_INTEGER + KernelTime*: LARGE_INTEGER + ImageName*: UNICODE_STRING + BasePriority*: KPRIORITY + UniqueProcessId*: HANDLE + InheritedFromUniqueProcessId*: HANDLE + HandleCount*: ULONG + SessionId*: ULONG + PageDirectoryBase*: ULONG + VirtualMemoryCounters*: VM_COUNTERS + PrivatePageCount*: SIZE_T + IoCounters*: IO_COUNTERS + PSYSTEM_PROCESS_INFORMATION* = ptr SYSTEM_PROCESS_INFORMATION + SYSTEM_REGISTRY_QUOTA_INFORMATION* {.pure.} = object + RegistryQuotaAllowed*: ULONG + RegistryQuotaUsed*: ULONG + Reserved1*: PVOID + PSYSTEM_REGISTRY_QUOTA_INFORMATION* = ptr SYSTEM_REGISTRY_QUOTA_INFORMATION + SYSTEM_BASIC_INFORMATION* {.pure.} = object + Reserved1*: array[4, BYTE] + MaximumIncrement*: ULONG + PhysicalPageSize*: ULONG + NumberOfPhysicalPages*: ULONG + LowestPhysicalPage*: ULONG + HighestPhysicalPage*: ULONG + AllocationGranularity*: ULONG + LowestUserAddress*: ULONG_PTR + HighestUserAddress*: ULONG_PTR + ActiveProcessors*: ULONG_PTR + NumberOfProcessors*: CCHAR + PSYSTEM_BASIC_INFORMATION* = ptr SYSTEM_BASIC_INFORMATION + SYSTEM_PROCESSOR_INFORMATION* {.pure.} = object + ProcessorArchitecture*: USHORT + ProcessorLevel*: USHORT + ProcessorRevision*: USHORT + Unknown*: USHORT + FeatureBits*: ULONG + PSYSTEM_PROCESSOR_INFORMATION* = ptr SYSTEM_PROCESSOR_INFORMATION + SYSTEM_TIMEOFDAY_INFORMATION* {.pure.} = object + BootTime*: LARGE_INTEGER + CurrentTime*: LARGE_INTEGER + TimeZoneBias*: LARGE_INTEGER + CurrentTimeZoneId*: ULONG + Reserved1*: array[20, BYTE] + PSYSTEM_TIMEOFDAY_INFORMATION* = ptr SYSTEM_TIMEOFDAY_INFORMATION + SYSTEM_PERFORMANCE_INFORMATION* {.pure.} = object + IdleTime*: LARGE_INTEGER + ReadTransferCount*: LARGE_INTEGER + WriteTransferCount*: LARGE_INTEGER + OtherTransferCount*: LARGE_INTEGER + ReadOperationCount*: ULONG + WriteOperationCount*: ULONG + OtherOperationCount*: ULONG + AvailablePages*: ULONG + TotalCommittedPages*: ULONG + TotalCommitLimit*: ULONG + PeakCommitment*: ULONG + PageFaults*: ULONG + WriteCopyFaults*: ULONG + TransitionFaults*: ULONG + CacheTransitionFaults*: ULONG + DemandZeroFaults*: ULONG + PagesRead*: ULONG + PageReadIos*: ULONG + CacheReads*: ULONG + CacheIos*: ULONG + PagefilePagesWritten*: ULONG + PagefilePageWriteIos*: ULONG + MappedFilePagesWritten*: ULONG + MappedFilePageWriteIos*: ULONG + PagedPoolUsage*: ULONG + NonPagedPoolUsage*: ULONG + PagedPoolAllocs*: ULONG + PagedPoolFrees*: ULONG + NonPagedPoolAllocs*: ULONG + NonPagedPoolFrees*: ULONG + TotalFreeSystemPtes*: ULONG + SystemCodePage*: ULONG + TotalSystemDriverPages*: ULONG + TotalSystemCodePages*: ULONG + SmallNonPagedLookasideListAllocateHits*: ULONG + SmallPagedLookasideListAllocateHits*: ULONG + Reserved3*: ULONG + MmSystemCachePage*: ULONG + PagedPoolPage*: ULONG + SystemDriverPage*: ULONG + FastReadNoWait*: ULONG + FastReadWait*: ULONG + FastReadResourceMiss*: ULONG + FastReadNotPossible*: ULONG + FastMdlReadNoWait*: ULONG + FastMdlReadWait*: ULONG + FastMdlReadResourceMiss*: ULONG + FastMdlReadNotPossible*: ULONG + MapDataNoWait*: ULONG + MapDataWait*: ULONG + MapDataNoWaitMiss*: ULONG + MapDataWaitMiss*: ULONG + PinMappedDataCount*: ULONG + PinReadNoWait*: ULONG + PinReadWait*: ULONG + PinReadNoWaitMiss*: ULONG + PinReadWaitMiss*: ULONG + CopyReadNoWait*: ULONG + CopyReadWait*: ULONG + CopyReadNoWaitMiss*: ULONG + CopyReadWaitMiss*: ULONG + MdlReadNoWait*: ULONG + MdlReadWait*: ULONG + MdlReadNoWaitMiss*: ULONG + MdlReadWaitMiss*: ULONG + ReadAheadIos*: ULONG + LazyWriteIos*: ULONG + LazyWritePages*: ULONG + DataFlushes*: ULONG + DataPages*: ULONG + ContextSwitches*: ULONG + FirstLevelTbFills*: ULONG + SecondLevelTbFills*: ULONG + SystemCalls*: ULONG + PSYSTEM_PERFORMANCE_INFORMATION* = ptr SYSTEM_PERFORMANCE_INFORMATION + SYSTEM_EXCEPTION_INFORMATION* {.pure.} = object + Reserved1*: array[16, BYTE] + PSYSTEM_EXCEPTION_INFORMATION* = ptr SYSTEM_EXCEPTION_INFORMATION + SYSTEM_LOOKASIDE_INFORMATION* {.pure.} = object + Reserved1*: array[32, BYTE] + PSYSTEM_LOOKASIDE_INFORMATION* = ptr SYSTEM_LOOKASIDE_INFORMATION + SYSTEM_INTERRUPT_INFORMATION* {.pure.} = object + Reserved1*: array[24, BYTE] + PSYSTEM_INTERRUPT_INFORMATION* = ptr SYSTEM_INTERRUPT_INFORMATION + SYSTEM_HANDLE_ENTRY* {.pure.} = object + OwnerPid*: ULONG + ObjectType*: BYTE + HandleFlags*: BYTE + HandleValue*: USHORT + ObjectPointer*: PVOID + AccessMask*: ULONG + PSYSTEM_HANDLE_ENTRY* = ptr SYSTEM_HANDLE_ENTRY + SYSTEM_HANDLE_INFORMATION* {.pure.} = object + Count*: ULONG + Handle*: array[1, SYSTEM_HANDLE_ENTRY] + PSYSTEM_HANDLE_INFORMATION* = ptr SYSTEM_HANDLE_INFORMATION + SYSTEM_PAGEFILE_INFORMATION* {.pure.} = object + NextEntryOffset*: ULONG + CurrentSize*: ULONG + TotalUsed*: ULONG + PeakUsed*: ULONG + FileName*: UNICODE_STRING + PSYSTEM_PAGEFILE_INFORMATION* = ptr SYSTEM_PAGEFILE_INFORMATION + PRTL_HEAP_COMMIT_ROUTINE* = proc (Base: PVOID, CommitAddress: ptr PVOID, CommitSize: PSIZE_T): NTSTATUS {.stdcall.} + RTL_HEAP_PARAMETERS* {.pure.} = object + Length*: ULONG + SegmentReserve*: SIZE_T + SegmentCommit*: SIZE_T + DeCommitFreeBlockThreshold*: SIZE_T + DeCommitTotalFreeThreshold*: SIZE_T + MaximumAllocationSize*: SIZE_T + VirtualMemoryThreshold*: SIZE_T + InitialCommit*: SIZE_T + InitialReserve*: SIZE_T + CommitRoutine*: PRTL_HEAP_COMMIT_ROUTINE + Reserved*: array[ 2 , SIZE_T] + PRTL_HEAP_PARAMETERS* = ptr RTL_HEAP_PARAMETERS + WINSTATIONINFORMATIONW* {.pure.} = object + Reserved2*: array[70, BYTE] + LogonId*: ULONG + Reserved3*: array[1140, BYTE] + PWINSTATIONINFORMATIONW* = ptr WINSTATIONINFORMATIONW + BSTR* = distinct ptr OLECHAR +const + exceptionContinueExecution* = 0 + exceptionContinueSearch* = 1 + exceptionNestedException* = 2 + exceptionCollidedUnwind* = 3 + exceptionExecuteHandler* = 4 + EXCEPTION_EXECUTE_HANDLER* = 1 + EXCEPTION_CONTINUE_SEARCH* = 0 + EXCEPTION_CONTINUE_EXECUTION* = -1 + FALSE* = 0 + TRUE* = 1 + UNICODE_NULL* = WCHAR 0 + ANSI_NULL* = CHAR 0 + NLS_VALID_LOCALE_MASK* = 0x000fffff + OBJ_INHERIT* = 0x00000002 + OBJ_PERMANENT* = 0x00000010 + OBJ_EXCLUSIVE* = 0x00000020 + OBJ_CASE_INSENSITIVE* = 0x00000040 + OBJ_OPENIF* = 0x00000080 + OBJ_OPENLINK* = 0x00000100 + OBJ_KERNEL_HANDLE* = 0x00000200 + OBJ_FORCE_ACCESS_CHECK* = 0x00000400 + OBJ_VALID_ATTRIBUTES* = 0x000007F2 + ntProductWinNt* = 1 + ntProductLanManNt* = 2 + ntProductServer* = 3 + notificationEvent* = 0 + synchronizationEvent* = 1 + notificationTimer* = 0 + synchronizationTimer* = 1 + waitAll* = 0 + waitAny* = 1 + MINCHAR* = 0x80 + MAXCHAR* = 0x7f + MINSHORT* = 0x8000 + MAXSHORT* = 0x7fff + MINLONG* = 0x80000000'i32 + MAXLONG* = 0x7fffffff + MAXUCHAR* = 0xff + MAXUSHORT* = 0xffff + MAXULONG* = 0xffffffff'i32 + MAXLONGLONG* = 0x7fffffffffffffff + VER_WORKSTATION_NT* = 0x40000000 + VER_SERVER_NT* = 0x80000000'i32 + VER_SUITE_SMALLBUSINESS* = 0x00000001 + VER_SUITE_ENTERPRISE* = 0x00000002 + VER_SUITE_BACKOFFICE* = 0x00000004 + VER_SUITE_COMMUNICATIONS* = 0x00000008 + VER_SUITE_TERMINAL* = 0x00000010 + VER_SUITE_SMALLBUSINESS_RESTRICTED* = 0x00000020 + VER_SUITE_EMBEDDEDNT* = 0x00000040 + VER_SUITE_DATACENTER* = 0x00000080 + VER_SUITE_SINGLEUSERTS* = 0x00000100 + VER_SUITE_PERSONAL* = 0x00000200 + VER_SUITE_BLADE* = 0x00000400 + VER_SUITE_EMBEDDED_RESTRICTED* = 0x00000800 + VER_SUITE_SECURITY_APPLIANCE* = 0x00001000 + VER_SUITE_STORAGE_SERVER* = 0x00002000 + VER_SUITE_COMPUTE_SERVER* = 0x00004000 + VER_SUITE_WH_SERVER* = 0x00008000 + LANG_NEUTRAL* = 0x00 + LANG_INVARIANT* = 0x7f + LANG_AFRIKAANS* = 0x36 + LANG_ALBANIAN* = 0x1c + LANG_ALSATIAN* = 0x84 + LANG_AMHARIC* = 0x5e + LANG_ARABIC* = 0x01 + LANG_ARMENIAN* = 0x2b + LANG_ASSAMESE* = 0x4d + LANG_AZERI* = 0x2c + LANG_BASHKIR* = 0x6d + LANG_BASQUE* = 0x2d + LANG_BELARUSIAN* = 0x23 + LANG_BENGALI* = 0x45 + LANG_BRETON* = 0x7e + LANG_BOSNIAN* = 0x1a + LANG_BOSNIAN_NEUTRAL* = 0x781a + LANG_BULGARIAN* = 0x02 + LANG_CATALAN* = 0x03 + LANG_CHINESE* = 0x04 + LANG_CHINESE_SIMPLIFIED* = 0x04 + LANG_CHINESE_TRADITIONAL* = 0x7c04 + LANG_CORSICAN* = 0x83 + LANG_CROATIAN* = 0x1a + LANG_CZECH* = 0x05 + LANG_DANISH* = 0x06 + LANG_DARI* = 0x8c + LANG_DIVEHI* = 0x65 + LANG_DUTCH* = 0x13 + LANG_ENGLISH* = 0x09 + LANG_ESTONIAN* = 0x25 + LANG_FAEROESE* = 0x38 + LANG_FARSI* = 0x29 + LANG_FILIPINO* = 0x64 + LANG_FINNISH* = 0x0b + LANG_FRENCH* = 0x0c + LANG_FRISIAN* = 0x62 + LANG_GALICIAN* = 0x56 + LANG_GEORGIAN* = 0x37 + LANG_GERMAN* = 0x07 + LANG_GREEK* = 0x08 + LANG_GREENLANDIC* = 0x6f + LANG_GUJARATI* = 0x47 + LANG_HAUSA* = 0x68 + LANG_HEBREW* = 0x0d + LANG_HINDI* = 0x39 + LANG_HUNGARIAN* = 0x0e + LANG_ICELANDIC* = 0x0f + LANG_IGBO* = 0x70 + LANG_INDONESIAN* = 0x21 + LANG_INUKTITUT* = 0x5d + LANG_IRISH* = 0x3c + LANG_ITALIAN* = 0x10 + LANG_JAPANESE* = 0x11 + LANG_KANNADA* = 0x4b + LANG_KASHMIRI* = 0x60 + LANG_KAZAK* = 0x3f + LANG_KHMER* = 0x53 + LANG_KICHE* = 0x86 + LANG_KINYARWANDA* = 0x87 + LANG_KONKANI* = 0x57 + LANG_KOREAN* = 0x12 + LANG_KYRGYZ* = 0x40 + LANG_LAO* = 0x54 + LANG_LATVIAN* = 0x26 + LANG_LITHUANIAN* = 0x27 + LANG_LOWER_SORBIAN* = 0x2e + LANG_LUXEMBOURGISH* = 0x6e + LANG_MACEDONIAN* = 0x2f + LANG_MALAY* = 0x3e + LANG_MALAYALAM* = 0x4c + LANG_MALTESE* = 0x3a + LANG_MANIPURI* = 0x58 + LANG_MAORI* = 0x81 + LANG_MAPUDUNGUN* = 0x7a + LANG_MARATHI* = 0x4e + LANG_MOHAWK* = 0x7c + LANG_MONGOLIAN* = 0x50 + LANG_NEPALI* = 0x61 + LANG_NORWEGIAN* = 0x14 + LANG_OCCITAN* = 0x82 + LANG_ORIYA* = 0x48 + LANG_PASHTO* = 0x63 + LANG_PERSIAN* = 0x29 + LANG_POLISH* = 0x15 + LANG_PORTUGUESE* = 0x16 + LANG_PUNJABI* = 0x46 + LANG_QUECHUA* = 0x6b + LANG_ROMANIAN* = 0x18 + LANG_ROMANSH* = 0x17 + LANG_RUSSIAN* = 0x19 + LANG_SAMI* = 0x3b + LANG_SANSKRIT* = 0x4f + LANG_SERBIAN* = 0x1a + LANG_SERBIAN_NEUTRAL* = 0x7c1a + LANG_SINDHI* = 0x59 + LANG_SINHALESE* = 0x5b + LANG_SLOVAK* = 0x1b + LANG_SLOVENIAN* = 0x24 + LANG_SOTHO* = 0x6c + LANG_SPANISH* = 0x0a + LANG_SWAHILI* = 0x41 + LANG_SWEDISH* = 0x1d + LANG_SYRIAC* = 0x5a + LANG_TAJIK* = 0x28 + LANG_TAMAZIGHT* = 0x5f + LANG_TAMIL* = 0x49 + LANG_TATAR* = 0x44 + LANG_TELUGU* = 0x4a + LANG_THAI* = 0x1e + LANG_TIBETAN* = 0x51 + LANG_TIGRIGNA* = 0x73 + LANG_TSWANA* = 0x32 + LANG_TURKISH* = 0x1f + LANG_TURKMEN* = 0x42 + LANG_UIGHUR* = 0x80 + LANG_UKRAINIAN* = 0x22 + LANG_UPPER_SORBIAN* = 0x2e + LANG_URDU* = 0x20 + LANG_UZBEK* = 0x43 + LANG_VIETNAMESE* = 0x2a + LANG_WELSH* = 0x52 + LANG_WOLOF* = 0x88 + LANG_XHOSA* = 0x34 + LANG_YAKUT* = 0x85 + LANG_YI* = 0x78 + LANG_YORUBA* = 0x6a + LANG_ZULU* = 0x35 + FILE_ATTRIBUTE_VALID_FLAGS* = 0x00007fb7 + FILE_SHARE_READ* = 0x00000001 + FILE_SHARE_WRITE* = 0x00000002 + FILE_SHARE_DELETE* = 0x00000004 + FILE_SHARE_VALID_FLAGS* = FILE_SHARE_READ or FILE_SHARE_WRITE or FILE_SHARE_DELETE + FILE_SUPERSEDE* = 0x00000000 + FILE_OPEN* = 0x00000001 + FILE_CREATE* = 0x00000002 + FILE_OPEN_IF* = 0x00000003 + FILE_OVERWRITE* = 0x00000004 + FILE_OVERWRITE_IF* = 0x00000005 + FILE_MAXIMUM_DISPOSITION* = 0x00000005 + FILE_DIRECTORY_FILE* = 0x00000001 + FILE_WRITE_THROUGH* = 0x00000002 + FILE_SEQUENTIAL_ONLY* = 0x00000004 + FILE_NO_INTERMEDIATE_BUFFERING* = 0x00000008 + FILE_SYNCHRONOUS_IO_ALERT* = 0x00000010 + FILE_SYNCHRONOUS_IO_NONALERT* = 0x00000020 + FILE_NON_DIRECTORY_FILE* = 0x00000040 + FILE_CREATE_TREE_CONNECTION* = 0x00000080 + FILE_COMPLETE_IF_OPLOCKED* = 0x00000100 + FILE_NO_EA_KNOWLEDGE* = 0x00000200 + FILE_OPEN_REMOTE_INSTANCE* = 0x00000400 + FILE_RANDOM_ACCESS* = 0x00000800 + FILE_DELETE_ON_CLOSE* = 0x00001000 + FILE_OPEN_BY_FILE_ID* = 0x00002000 + FILE_OPEN_FOR_BACKUP_INTENT* = 0x00004000 + FILE_NO_COMPRESSION* = 0x00008000 + FILE_OPEN_REQUIRING_OPLOCK* = 0x00010000 + FILE_DISALLOW_EXCLUSIVE* = 0x00020000 + FILE_RESERVE_OPFILTER* = 0x00100000 + FILE_OPEN_REPARSE_POINT* = 0x00200000 + FILE_OPEN_NO_RECALL* = 0x00400000 + FILE_OPEN_FOR_FREE_SPACE_QUERY* = 0x00800000 + FACILITY_USB_ERROR_CODE* = 0x10 + FACILITY_TRANSACTION* = 0x19 + FACILITY_TERMINAL_SERVER* = 0xA + FACILITY_SXS_ERROR_CODE* = 0x15 + FACILITY_RPC_STUBS* = 0x3 + FACILITY_RPC_RUNTIME* = 0x2 + FACILITY_IO_ERROR_CODE* = 0x4 + FACILITY_HID_ERROR_CODE* = 0x11 + FACILITY_FIREWIRE_ERROR_CODE* = 0x12 + FACILITY_DEBUGGER* = 0x1 + FACILITY_COMMONLOG_ERROR_CODE* = 0x1A + FACILITY_CLUSTER_ERROR_CODE* = 0x13 + FACILITY_ACPI_ERROR_CODE* = 0x14 + STATUS_SEVERITY_WARNING* = 0x2 + STATUS_SEVERITY_SUCCESS* = 0x0 + STATUS_SEVERITY_INFORMATIONAL* = 0x1 + STATUS_SEVERITY_ERROR* = 0x3 + STATUS_KERNEL_APC* = NTSTATUS 0x00000100 + STATUS_DEVICE_POWER_FAILURE* = NTSTATUS 0xC000009E'i32 + STATUS_ABIOS_NOT_PRESENT* = NTSTATUS 0xC000010F'i32 + STATUS_ABIOS_LID_NOT_EXIST* = NTSTATUS 0xC0000110'i32 + STATUS_ABIOS_LID_ALREADY_OWNED* = NTSTATUS 0xC0000111'i32 + STATUS_ABIOS_NOT_LID_OWNER* = NTSTATUS 0xC0000112'i32 + STATUS_ABIOS_INVALID_COMMAND* = NTSTATUS 0xC0000113'i32 + STATUS_ABIOS_INVALID_LID* = NTSTATUS 0xC0000114'i32 + STATUS_ABIOS_SELECTOR_NOT_AVAILABLE* = NTSTATUS 0xC0000115'i32 + STATUS_ABIOS_INVALID_SELECTOR* = NTSTATUS 0xC0000116'i32 + STATUS_MULTIPLE_FAULT_VIOLATION* = NTSTATUS 0xC00002E8'i32 + STATUS_SUCCESS* = NTSTATUS 0x00000000 + STATUS_WAIT_0* = NTSTATUS 0x00000000 + STATUS_WAIT_1* = NTSTATUS 0x00000001 + STATUS_WAIT_2* = NTSTATUS 0x00000002 + STATUS_WAIT_3* = NTSTATUS 0x00000003 + STATUS_WAIT_63* = NTSTATUS 0x0000003F + STATUS_ABANDONED* = NTSTATUS 0x00000080 + STATUS_ABANDONED_WAIT_0* = NTSTATUS 0x00000080 + STATUS_ABANDONED_WAIT_63* = NTSTATUS 0x000000BF + STATUS_USER_APC* = NTSTATUS 0x000000C0 + STATUS_ALERTED* = NTSTATUS 0x00000101 + STATUS_TIMEOUT* = NTSTATUS 0x00000102 + STATUS_PENDING* = NTSTATUS 0x00000103 + STATUS_REPARSE* = NTSTATUS 0x00000104 + STATUS_MORE_ENTRIES* = NTSTATUS 0x00000105 + STATUS_NOT_ALL_ASSIGNED* = NTSTATUS 0x00000106 + STATUS_SOME_NOT_MAPPED* = NTSTATUS 0x00000107 + STATUS_OPLOCK_BREAK_IN_PROGRESS* = NTSTATUS 0x00000108 + STATUS_VOLUME_MOUNTED* = NTSTATUS 0x00000109 + STATUS_RXACT_COMMITTED* = NTSTATUS 0x0000010A + STATUS_NOTIFY_CLEANUP* = NTSTATUS 0x0000010B + STATUS_NOTIFY_ENUM_DIR* = NTSTATUS 0x0000010C + STATUS_NO_QUOTAS_FOR_ACCOUNT* = NTSTATUS 0x0000010D + STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED* = NTSTATUS 0x0000010E + STATUS_PAGE_FAULT_TRANSITION* = NTSTATUS 0x00000110 + STATUS_PAGE_FAULT_DEMAND_ZERO* = NTSTATUS 0x00000111 + STATUS_PAGE_FAULT_COPY_ON_WRITE* = NTSTATUS 0x00000112 + STATUS_PAGE_FAULT_GUARD_PAGE* = NTSTATUS 0x00000113 + STATUS_PAGE_FAULT_PAGING_FILE* = NTSTATUS 0x00000114 + STATUS_CACHE_PAGE_LOCKED* = NTSTATUS 0x00000115 + STATUS_CRASH_DUMP* = NTSTATUS 0x00000116 + STATUS_BUFFER_ALL_ZEROS* = NTSTATUS 0x00000117 + STATUS_REPARSE_OBJECT* = NTSTATUS 0x00000118 + STATUS_RESOURCE_REQUIREMENTS_CHANGED* = NTSTATUS 0x00000119 + STATUS_TRANSLATION_COMPLETE* = NTSTATUS 0x00000120 + STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY* = NTSTATUS 0x00000121 + STATUS_NOTHING_TO_TERMINATE* = NTSTATUS 0x00000122 + STATUS_PROCESS_NOT_IN_JOB* = NTSTATUS 0x00000123 + STATUS_PROCESS_IN_JOB* = NTSTATUS 0x00000124 + STATUS_VOLSNAP_HIBERNATE_READY* = NTSTATUS 0x00000125 + STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY* = NTSTATUS 0x00000126 + STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED* = NTSTATUS 0x00000127 + STATUS_INTERRUPT_STILL_CONNECTED* = NTSTATUS 0x00000128 + STATUS_PROCESS_CLONED* = NTSTATUS 0x00000129 + STATUS_FILE_LOCKED_WITH_ONLY_READERS* = NTSTATUS 0x0000012A + STATUS_FILE_LOCKED_WITH_WRITERS* = NTSTATUS 0x0000012B + STATUS_RESOURCEMANAGER_READ_ONLY* = NTSTATUS 0x00000202 + STATUS_WAIT_FOR_OPLOCK* = NTSTATUS 0x00000367 + DBG_EXCEPTION_HANDLED* = NTSTATUS 0x00010001 + DBG_CONTINUE* = NTSTATUS 0x00010002 + STATUS_FLT_IO_COMPLETE* = NTSTATUS 0x001C0001 + STATUS_FILE_NOT_AVAILABLE* = NTSTATUS 0xC0000467'i32 + STATUS_OBJECT_NAME_EXISTS* = NTSTATUS 0x40000000 + STATUS_THREAD_WAS_SUSPENDED* = NTSTATUS 0x40000001 + STATUS_WORKING_SET_LIMIT_RANGE* = NTSTATUS 0x40000002 + STATUS_IMAGE_NOT_AT_BASE* = NTSTATUS 0x40000003 + STATUS_RXACT_STATE_CREATED* = NTSTATUS 0x40000004 + STATUS_SEGMENT_NOTIFICATION* = NTSTATUS 0x40000005 + STATUS_LOCAL_USER_SESSION_KEY* = NTSTATUS 0x40000006 + STATUS_BAD_CURRENT_DIRECTORY* = NTSTATUS 0x40000007 + STATUS_SERIAL_MORE_WRITES* = NTSTATUS 0x40000008 + STATUS_REGISTRY_RECOVERED* = NTSTATUS 0x40000009 + STATUS_FT_READ_RECOVERY_FROM_BACKUP* = NTSTATUS 0x4000000A + STATUS_FT_WRITE_RECOVERY* = NTSTATUS 0x4000000B + STATUS_SERIAL_COUNTER_TIMEOUT* = NTSTATUS 0x4000000C + STATUS_NULL_LM_PASSWORD* = NTSTATUS 0x4000000D + STATUS_IMAGE_MACHINE_TYPE_MISMATCH* = NTSTATUS 0x4000000E + STATUS_RECEIVE_PARTIAL* = NTSTATUS 0x4000000F + STATUS_RECEIVE_EXPEDITED* = NTSTATUS 0x40000010 + STATUS_RECEIVE_PARTIAL_EXPEDITED* = NTSTATUS 0x40000011 + STATUS_EVENT_DONE* = NTSTATUS 0x40000012 + STATUS_EVENT_PENDING* = NTSTATUS 0x40000013 + STATUS_CHECKING_FILE_SYSTEM* = NTSTATUS 0x40000014 + STATUS_FATAL_APP_EXIT* = NTSTATUS 0x40000015 + STATUS_PREDEFINED_HANDLE* = NTSTATUS 0x40000016 + STATUS_WAS_UNLOCKED* = NTSTATUS 0x40000017 + STATUS_SERVICE_NOTIFICATION* = NTSTATUS 0x40000018 + STATUS_WAS_LOCKED* = NTSTATUS 0x40000019 + STATUS_LOG_HARD_ERROR* = NTSTATUS 0x4000001A + STATUS_ALREADY_WIN32* = NTSTATUS 0x4000001B + STATUS_WX86_UNSIMULATE* = NTSTATUS 0x4000001C + STATUS_WX86_CONTINUE* = NTSTATUS 0x4000001D + STATUS_WX86_SINGLE_STEP* = NTSTATUS 0x4000001E + STATUS_WX86_BREAKPOINT* = NTSTATUS 0x4000001F + STATUS_WX86_EXCEPTION_CONTINUE* = NTSTATUS 0x40000020 + STATUS_WX86_EXCEPTION_LASTCHANCE* = NTSTATUS 0x40000021 + STATUS_WX86_EXCEPTION_CHAIN* = NTSTATUS 0x40000022 + STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE* = NTSTATUS 0x40000023 + STATUS_NO_YIELD_PERFORMED* = NTSTATUS 0x40000024 + STATUS_TIMER_RESUME_IGNORED* = NTSTATUS 0x40000025 + STATUS_ARBITRATION_UNHANDLED* = NTSTATUS 0x40000026 + STATUS_CARDBUS_NOT_SUPPORTED* = NTSTATUS 0x40000027 + STATUS_WX86_CREATEWX86TIB* = NTSTATUS 0x40000028 + STATUS_MP_PROCESSOR_MISMATCH* = NTSTATUS 0x40000029 + STATUS_HIBERNATED* = NTSTATUS 0x4000002A + STATUS_RESUME_HIBERNATION* = NTSTATUS 0x4000002B + STATUS_FIRMWARE_UPDATED* = NTSTATUS 0x4000002C + STATUS_DRIVERS_LEAKING_LOCKED_PAGES* = NTSTATUS 0x4000002D + STATUS_MESSAGE_RETRIEVED* = NTSTATUS 0x4000002E + STATUS_SYSTEM_POWERSTATE_TRANSITION* = NTSTATUS 0x4000002F + STATUS_ALPC_CHECK_COMPLETION_LIST* = NTSTATUS 0x40000030 + STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION* = NTSTATUS 0x40000031 + STATUS_ACCESS_AUDIT_BY_POLICY* = NTSTATUS 0x40000032 + STATUS_ABANDON_HIBERFILE* = NTSTATUS 0x40000033 + STATUS_BIZRULES_NOT_ENABLED* = NTSTATUS 0x40000034 + STATUS_WAKE_SYSTEM* = NTSTATUS 0x40000294 + STATUS_DS_SHUTTING_DOWN* = NTSTATUS 0x40000370 + DBG_REPLY_LATER* = NTSTATUS 0x40010001 + DBG_UNABLE_TO_PROVIDE_HANDLE* = NTSTATUS 0x40010002 + DBG_TERMINATE_THREAD* = NTSTATUS 0x40010003 + DBG_TERMINATE_PROCESS* = NTSTATUS 0x40010004 + DBG_CONTROL_C* = NTSTATUS 0x40010005 + DBG_PRINTEXCEPTION_C* = NTSTATUS 0x40010006 + DBG_RIPEXCEPTION* = NTSTATUS 0x40010007 + DBG_CONTROL_BREAK* = NTSTATUS 0x40010008 + DBG_COMMAND_EXCEPTION* = NTSTATUS 0x40010009 + RPC_NT_UUID_LOCAL_ONLY* = NTSTATUS 0x40020056 + RPC_NT_SEND_INCOMPLETE* = NTSTATUS 0x400200AF + STATUS_CTX_CDM_CONNECT* = NTSTATUS 0x400A0004 + STATUS_CTX_CDM_DISCONNECT* = NTSTATUS 0x400A0005 + STATUS_SXS_RELEASE_ACTIVATION_CONTEXT* = NTSTATUS 0x4015000D + STATUS_RECOVERY_NOT_NEEDED* = NTSTATUS 0x40190034 + STATUS_RM_ALREADY_STARTED* = NTSTATUS 0x40190035 + STATUS_LOG_NO_RESTART* = NTSTATUS 0x401A000C + STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST* = NTSTATUS 0x401B00EC + STATUS_GRAPHICS_PARTIAL_DATA_POPULATED* = NTSTATUS 0x401E000A + STATUS_GRAPHICS_DRIVER_MISMATCH* = NTSTATUS 0x401E0117 + STATUS_GRAPHICS_MODE_NOT_PINNED* = NTSTATUS 0x401E0307 + STATUS_GRAPHICS_NO_PREFERRED_MODE* = NTSTATUS 0x401E031E + STATUS_GRAPHICS_DATASET_IS_EMPTY* = NTSTATUS 0x401E034B + STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET* = NTSTATUS 0x401E034C + STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED* = NTSTATUS 0x401E0351 + STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS* = NTSTATUS 0x401E042F + STATUS_GRAPHICS_LEADLINK_START_DEFERRED* = NTSTATUS 0x401E0437 + STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY* = NTSTATUS 0x401E0439 + STATUS_GRAPHICS_START_DEFERRED* = NTSTATUS 0x401E043A + STATUS_NDIS_INDICATION_REQUIRED* = NTSTATUS 0x40230001 + STATUS_GUARD_PAGE_VIOLATION* = NTSTATUS 0x80000001'i32 + STATUS_DATATYPE_MISALIGNMENT* = NTSTATUS 0x80000002'i32 + STATUS_BREAKPOINT* = NTSTATUS 0x80000003'i32 + STATUS_SINGLE_STEP* = NTSTATUS 0x80000004'i32 + STATUS_BUFFER_OVERFLOW* = NTSTATUS 0x80000005'i32 + STATUS_NO_MORE_FILES* = NTSTATUS 0x80000006'i32 + STATUS_WAKE_SYSTEM_DEBUGGER* = NTSTATUS 0x80000007'i32 + STATUS_HANDLES_CLOSED* = NTSTATUS 0x8000000A'i32 + STATUS_NO_INHERITANCE* = NTSTATUS 0x8000000B'i32 + STATUS_GUID_SUBSTITUTION_MADE* = NTSTATUS 0x8000000C'i32 + STATUS_PARTIAL_COPY* = NTSTATUS 0x8000000D'i32 + STATUS_DEVICE_PAPER_EMPTY* = NTSTATUS 0x8000000E'i32 + STATUS_DEVICE_POWERED_OFF* = NTSTATUS 0x8000000F'i32 + STATUS_DEVICE_OFF_LINE* = NTSTATUS 0x80000010'i32 + STATUS_DEVICE_BUSY* = NTSTATUS 0x80000011'i32 + STATUS_NO_MORE_EAS* = NTSTATUS 0x80000012'i32 + STATUS_INVALID_EA_NAME* = NTSTATUS 0x80000013'i32 + STATUS_EA_LIST_INCONSISTENT* = NTSTATUS 0x80000014'i32 + STATUS_INVALID_EA_FLAG* = NTSTATUS 0x80000015'i32 + STATUS_VERIFY_REQUIRED* = NTSTATUS 0x80000016'i32 + STATUS_EXTRANEOUS_INFORMATION* = NTSTATUS 0x80000017'i32 + STATUS_RXACT_COMMIT_NECESSARY* = NTSTATUS 0x80000018'i32 + STATUS_NO_MORE_ENTRIES* = NTSTATUS 0x8000001A'i32 + STATUS_FILEMARK_DETECTED* = NTSTATUS 0x8000001B'i32 + STATUS_MEDIA_CHANGED* = NTSTATUS 0x8000001C'i32 + STATUS_BUS_RESET* = NTSTATUS 0x8000001D'i32 + STATUS_END_OF_MEDIA* = NTSTATUS 0x8000001E'i32 + STATUS_BEGINNING_OF_MEDIA* = NTSTATUS 0x8000001F'i32 + STATUS_MEDIA_CHECK* = NTSTATUS 0x80000020'i32 + STATUS_SETMARK_DETECTED* = NTSTATUS 0x80000021'i32 + STATUS_NO_DATA_DETECTED* = NTSTATUS 0x80000022'i32 + STATUS_REDIRECTOR_HAS_OPEN_HANDLES* = NTSTATUS 0x80000023'i32 + STATUS_SERVER_HAS_OPEN_HANDLES* = NTSTATUS 0x80000024'i32 + STATUS_ALREADY_DISCONNECTED* = NTSTATUS 0x80000025'i32 + STATUS_LONGJUMP* = NTSTATUS 0x80000026'i32 + STATUS_CLEANER_CARTRIDGE_INSTALLED* = NTSTATUS 0x80000027'i32 + STATUS_PLUGPLAY_QUERY_VETOED* = NTSTATUS 0x80000028'i32 + STATUS_UNWIND_CONSOLIDATE* = NTSTATUS 0x80000029'i32 + STATUS_REGISTRY_HIVE_RECOVERED* = NTSTATUS 0x8000002A'i32 + STATUS_DLL_MIGHT_BE_INSECURE* = NTSTATUS 0x8000002B'i32 + STATUS_DLL_MIGHT_BE_INCOMPATIBLE* = NTSTATUS 0x8000002C'i32 + STATUS_STOPPED_ON_SYMLINK* = NTSTATUS 0x8000002D'i32 + STATUS_DEVICE_REQUIRES_CLEANING* = NTSTATUS 0x80000288'i32 + STATUS_DEVICE_DOOR_OPEN* = NTSTATUS 0x80000289'i32 + STATUS_DATA_LOST_REPAIR* = NTSTATUS 0x80000803'i32 + DBG_EXCEPTION_NOT_HANDLED* = NTSTATUS 0x80010001'i32 + STATUS_CLUSTER_NODE_ALREADY_UP* = NTSTATUS 0x80130001'i32 + STATUS_CLUSTER_NODE_ALREADY_DOWN* = NTSTATUS 0x80130002'i32 + STATUS_CLUSTER_NETWORK_ALREADY_ONLINE* = NTSTATUS 0x80130003'i32 + STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE* = NTSTATUS 0x80130004'i32 + STATUS_CLUSTER_NODE_ALREADY_MEMBER* = NTSTATUS 0x80130005'i32 + STATUS_COULD_NOT_RESIZE_LOG* = NTSTATUS 0x80190009'i32 + STATUS_NO_TXF_METADATA* = NTSTATUS 0x80190029'i32 + STATUS_CANT_RECOVER_WITH_HANDLE_OPEN* = NTSTATUS 0x80190031'i32 + STATUS_TXF_METADATA_ALREADY_PRESENT* = NTSTATUS 0x80190041'i32 + STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET* = NTSTATUS 0x80190042'i32 + STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED* = NTSTATUS 0x801B00EB'i32 + STATUS_FLT_BUFFER_TOO_SMALL* = NTSTATUS 0x801C0001'i32 + STATUS_FVE_PARTIAL_METADATA* = NTSTATUS 0x80210001'i32 + STATUS_FVE_TRANSIENT_STATE* = NTSTATUS 0x80210002'i32 + STATUS_UNSUCCESSFUL* = NTSTATUS 0xC0000001'i32 + STATUS_NOT_IMPLEMENTED* = NTSTATUS 0xC0000002'i32 + STATUS_INVALID_INFO_CLASS* = NTSTATUS 0xC0000003'i32 + STATUS_INFO_LENGTH_MISMATCH* = NTSTATUS 0xC0000004'i32 + STATUS_ACCESS_VIOLATION* = NTSTATUS 0xC0000005'i32 + STATUS_IN_PAGE_ERROR* = NTSTATUS 0xC0000006'i32 + STATUS_PAGEFILE_QUOTA* = NTSTATUS 0xC0000007'i32 + STATUS_INVALID_HANDLE* = NTSTATUS 0xC0000008'i32 + STATUS_BAD_INITIAL_STACK* = NTSTATUS 0xC0000009'i32 + STATUS_BAD_INITIAL_PC* = NTSTATUS 0xC000000A'i32 + STATUS_INVALID_CID* = NTSTATUS 0xC000000B'i32 + STATUS_TIMER_NOT_CANCELED* = NTSTATUS 0xC000000C'i32 + STATUS_INVALID_PARAMETER* = NTSTATUS 0xC000000D'i32 + STATUS_NO_SUCH_DEVICE* = NTSTATUS 0xC000000E'i32 + STATUS_NO_SUCH_FILE* = NTSTATUS 0xC000000F'i32 + STATUS_INVALID_DEVICE_REQUEST* = NTSTATUS 0xC0000010'i32 + STATUS_END_OF_FILE* = NTSTATUS 0xC0000011'i32 + STATUS_WRONG_VOLUME* = NTSTATUS 0xC0000012'i32 + STATUS_NO_MEDIA_IN_DEVICE* = NTSTATUS 0xC0000013'i32 + STATUS_UNRECOGNIZED_MEDIA* = NTSTATUS 0xC0000014'i32 + STATUS_NONEXISTENT_SECTOR* = NTSTATUS 0xC0000015'i32 + STATUS_MORE_PROCESSING_REQUIRED* = NTSTATUS 0xC0000016'i32 + STATUS_NO_MEMORY* = NTSTATUS 0xC0000017'i32 + STATUS_CONFLICTING_ADDRESSES* = NTSTATUS 0xC0000018'i32 + STATUS_NOT_MAPPED_VIEW* = NTSTATUS 0xC0000019'i32 + STATUS_UNABLE_TO_FREE_VM* = NTSTATUS 0xC000001A'i32 + STATUS_UNABLE_TO_DELETE_SECTION* = NTSTATUS 0xC000001B'i32 + STATUS_INVALID_SYSTEM_SERVICE* = NTSTATUS 0xC000001C'i32 + STATUS_ILLEGAL_INSTRUCTION* = NTSTATUS 0xC000001D'i32 + STATUS_INVALID_LOCK_SEQUENCE* = NTSTATUS 0xC000001E'i32 + STATUS_INVALID_VIEW_SIZE* = NTSTATUS 0xC000001F'i32 + STATUS_INVALID_FILE_FOR_SECTION* = NTSTATUS 0xC0000020'i32 + STATUS_ALREADY_COMMITTED* = NTSTATUS 0xC0000021'i32 + STATUS_ACCESS_DENIED* = NTSTATUS 0xC0000022'i32 + STATUS_BUFFER_TOO_SMALL* = NTSTATUS 0xC0000023'i32 + STATUS_OBJECT_TYPE_MISMATCH* = NTSTATUS 0xC0000024'i32 + STATUS_NONCONTINUABLE_EXCEPTION* = NTSTATUS 0xC0000025'i32 + STATUS_INVALID_DISPOSITION* = NTSTATUS 0xC0000026'i32 + STATUS_UNWIND* = NTSTATUS 0xC0000027'i32 + STATUS_BAD_STACK* = NTSTATUS 0xC0000028'i32 + STATUS_INVALID_UNWIND_TARGET* = NTSTATUS 0xC0000029'i32 + STATUS_NOT_LOCKED* = NTSTATUS 0xC000002A'i32 + STATUS_PARITY_ERROR* = NTSTATUS 0xC000002B'i32 + STATUS_UNABLE_TO_DECOMMIT_VM* = NTSTATUS 0xC000002C'i32 + STATUS_NOT_COMMITTED* = NTSTATUS 0xC000002D'i32 + STATUS_INVALID_PORT_ATTRIBUTES* = NTSTATUS 0xC000002E'i32 + STATUS_PORT_MESSAGE_TOO_LONG* = NTSTATUS 0xC000002F'i32 + STATUS_INVALID_PARAMETER_MIX* = NTSTATUS 0xC0000030'i32 + STATUS_INVALID_QUOTA_LOWER* = NTSTATUS 0xC0000031'i32 + STATUS_DISK_CORRUPT_ERROR* = NTSTATUS 0xC0000032'i32 + STATUS_OBJECT_NAME_INVALID* = NTSTATUS 0xC0000033'i32 + STATUS_OBJECT_NAME_NOT_FOUND* = NTSTATUS 0xC0000034'i32 + STATUS_OBJECT_NAME_COLLISION* = NTSTATUS 0xC0000035'i32 + STATUS_PORT_DISCONNECTED* = NTSTATUS 0xC0000037'i32 + STATUS_DEVICE_ALREADY_ATTACHED* = NTSTATUS 0xC0000038'i32 + STATUS_OBJECT_PATH_INVALID* = NTSTATUS 0xC0000039'i32 + STATUS_OBJECT_PATH_NOT_FOUND* = NTSTATUS 0xC000003A'i32 + STATUS_OBJECT_PATH_SYNTAX_BAD* = NTSTATUS 0xC000003B'i32 + STATUS_DATA_OVERRUN* = NTSTATUS 0xC000003C'i32 + STATUS_DATA_LATE_ERROR* = NTSTATUS 0xC000003D'i32 + STATUS_DATA_ERROR* = NTSTATUS 0xC000003E'i32 + STATUS_CRC_ERROR* = NTSTATUS 0xC000003F'i32 + STATUS_SECTION_TOO_BIG* = NTSTATUS 0xC0000040'i32 + STATUS_PORT_CONNECTION_REFUSED* = NTSTATUS 0xC0000041'i32 + STATUS_INVALID_PORT_HANDLE* = NTSTATUS 0xC0000042'i32 + STATUS_SHARING_VIOLATION* = NTSTATUS 0xC0000043'i32 + STATUS_QUOTA_EXCEEDED* = NTSTATUS 0xC0000044'i32 + STATUS_INVALID_PAGE_PROTECTION* = NTSTATUS 0xC0000045'i32 + STATUS_MUTANT_NOT_OWNED* = NTSTATUS 0xC0000046'i32 + STATUS_SEMAPHORE_LIMIT_EXCEEDED* = NTSTATUS 0xC0000047'i32 + STATUS_PORT_ALREADY_SET* = NTSTATUS 0xC0000048'i32 + STATUS_SECTION_NOT_IMAGE* = NTSTATUS 0xC0000049'i32 + STATUS_SUSPEND_COUNT_EXCEEDED* = NTSTATUS 0xC000004A'i32 + STATUS_THREAD_IS_TERMINATING* = NTSTATUS 0xC000004B'i32 + STATUS_BAD_WORKING_SET_LIMIT* = NTSTATUS 0xC000004C'i32 + STATUS_INCOMPATIBLE_FILE_MAP* = NTSTATUS 0xC000004D'i32 + STATUS_SECTION_PROTECTION* = NTSTATUS 0xC000004E'i32 + STATUS_EAS_NOT_SUPPORTED* = NTSTATUS 0xC000004F'i32 + STATUS_EA_TOO_LARGE* = NTSTATUS 0xC0000050'i32 + STATUS_NONEXISTENT_EA_ENTRY* = NTSTATUS 0xC0000051'i32 + STATUS_NO_EAS_ON_FILE* = NTSTATUS 0xC0000052'i32 + STATUS_EA_CORRUPT_ERROR* = NTSTATUS 0xC0000053'i32 + STATUS_FILE_LOCK_CONFLICT* = NTSTATUS 0xC0000054'i32 + STATUS_LOCK_NOT_GRANTED* = NTSTATUS 0xC0000055'i32 + STATUS_DELETE_PENDING* = NTSTATUS 0xC0000056'i32 + STATUS_CTL_FILE_NOT_SUPPORTED* = NTSTATUS 0xC0000057'i32 + STATUS_UNKNOWN_REVISION* = NTSTATUS 0xC0000058'i32 + STATUS_REVISION_MISMATCH* = NTSTATUS 0xC0000059'i32 + STATUS_INVALID_OWNER* = NTSTATUS 0xC000005A'i32 + STATUS_INVALID_PRIMARY_GROUP* = NTSTATUS 0xC000005B'i32 + STATUS_NO_IMPERSONATION_TOKEN* = NTSTATUS 0xC000005C'i32 + STATUS_CANT_DISABLE_MANDATORY* = NTSTATUS 0xC000005D'i32 + STATUS_NO_LOGON_SERVERS* = NTSTATUS 0xC000005E'i32 + STATUS_NO_SUCH_LOGON_SESSION* = NTSTATUS 0xC000005F'i32 + STATUS_NO_SUCH_PRIVILEGE* = NTSTATUS 0xC0000060'i32 + STATUS_PRIVILEGE_NOT_HELD* = NTSTATUS 0xC0000061'i32 + STATUS_INVALID_ACCOUNT_NAME* = NTSTATUS 0xC0000062'i32 + STATUS_USER_EXISTS* = NTSTATUS 0xC0000063'i32 + STATUS_NO_SUCH_USER* = NTSTATUS 0xC0000064'i32 + STATUS_GROUP_EXISTS* = NTSTATUS 0xC0000065'i32 + STATUS_NO_SUCH_GROUP* = NTSTATUS 0xC0000066'i32 + STATUS_MEMBER_IN_GROUP* = NTSTATUS 0xC0000067'i32 + STATUS_MEMBER_NOT_IN_GROUP* = NTSTATUS 0xC0000068'i32 + STATUS_LAST_ADMIN* = NTSTATUS 0xC0000069'i32 + STATUS_WRONG_PASSWORD* = NTSTATUS 0xC000006A'i32 + STATUS_ILL_FORMED_PASSWORD* = NTSTATUS 0xC000006B'i32 + STATUS_PASSWORD_RESTRICTION* = NTSTATUS 0xC000006C'i32 + STATUS_LOGON_FAILURE* = NTSTATUS 0xC000006D'i32 + STATUS_ACCOUNT_RESTRICTION* = NTSTATUS 0xC000006E'i32 + STATUS_INVALID_LOGON_HOURS* = NTSTATUS 0xC000006F'i32 + STATUS_INVALID_WORKSTATION* = NTSTATUS 0xC0000070'i32 + STATUS_PASSWORD_EXPIRED* = NTSTATUS 0xC0000071'i32 + STATUS_ACCOUNT_DISABLED* = NTSTATUS 0xC0000072'i32 + STATUS_NONE_MAPPED* = NTSTATUS 0xC0000073'i32 + STATUS_TOO_MANY_LUIDS_REQUESTED* = NTSTATUS 0xC0000074'i32 + STATUS_LUIDS_EXHAUSTED* = NTSTATUS 0xC0000075'i32 + STATUS_INVALID_SUB_AUTHORITY* = NTSTATUS 0xC0000076'i32 + STATUS_INVALID_ACL* = NTSTATUS 0xC0000077'i32 + STATUS_INVALID_SID* = NTSTATUS 0xC0000078'i32 + STATUS_INVALID_SECURITY_DESCR* = NTSTATUS 0xC0000079'i32 + STATUS_PROCEDURE_NOT_FOUND* = NTSTATUS 0xC000007A'i32 + STATUS_INVALID_IMAGE_FORMAT* = NTSTATUS 0xC000007B'i32 + STATUS_NO_TOKEN* = NTSTATUS 0xC000007C'i32 + STATUS_BAD_INHERITANCE_ACL* = NTSTATUS 0xC000007D'i32 + STATUS_RANGE_NOT_LOCKED* = NTSTATUS 0xC000007E'i32 + STATUS_DISK_FULL* = NTSTATUS 0xC000007F'i32 + STATUS_SERVER_DISABLED* = NTSTATUS 0xC0000080'i32 + STATUS_SERVER_NOT_DISABLED* = NTSTATUS 0xC0000081'i32 + STATUS_TOO_MANY_GUIDS_REQUESTED* = NTSTATUS 0xC0000082'i32 + STATUS_GUIDS_EXHAUSTED* = NTSTATUS 0xC0000083'i32 + STATUS_INVALID_ID_AUTHORITY* = NTSTATUS 0xC0000084'i32 + STATUS_AGENTS_EXHAUSTED* = NTSTATUS 0xC0000085'i32 + STATUS_INVALID_VOLUME_LABEL* = NTSTATUS 0xC0000086'i32 + STATUS_SECTION_NOT_EXTENDED* = NTSTATUS 0xC0000087'i32 + STATUS_NOT_MAPPED_DATA* = NTSTATUS 0xC0000088'i32 + STATUS_RESOURCE_DATA_NOT_FOUND* = NTSTATUS 0xC0000089'i32 + STATUS_RESOURCE_TYPE_NOT_FOUND* = NTSTATUS 0xC000008A'i32 + STATUS_RESOURCE_NAME_NOT_FOUND* = NTSTATUS 0xC000008B'i32 + STATUS_ARRAY_BOUNDS_EXCEEDED* = NTSTATUS 0xC000008C'i32 + STATUS_FLOAT_DENORMAL_OPERAND* = NTSTATUS 0xC000008D'i32 + STATUS_FLOAT_DIVIDE_BY_ZERO* = NTSTATUS 0xC000008E'i32 + STATUS_FLOAT_INEXACT_RESULT* = NTSTATUS 0xC000008F'i32 + STATUS_FLOAT_INVALID_OPERATION* = NTSTATUS 0xC0000090'i32 + STATUS_FLOAT_OVERFLOW* = NTSTATUS 0xC0000091'i32 + STATUS_FLOAT_STACK_CHECK* = NTSTATUS 0xC0000092'i32 + STATUS_FLOAT_UNDERFLOW* = NTSTATUS 0xC0000093'i32 + STATUS_INTEGER_DIVIDE_BY_ZERO* = NTSTATUS 0xC0000094'i32 + STATUS_INTEGER_OVERFLOW* = NTSTATUS 0xC0000095'i32 + STATUS_PRIVILEGED_INSTRUCTION* = NTSTATUS 0xC0000096'i32 + STATUS_TOO_MANY_PAGING_FILES* = NTSTATUS 0xC0000097'i32 + STATUS_FILE_INVALID* = NTSTATUS 0xC0000098'i32 + STATUS_ALLOTTED_SPACE_EXCEEDED* = NTSTATUS 0xC0000099'i32 + STATUS_INSUFFICIENT_RESOURCES* = NTSTATUS 0xC000009A'i32 + STATUS_DFS_EXIT_PATH_FOUND* = NTSTATUS 0xC000009B'i32 + STATUS_DEVICE_DATA_ERROR* = NTSTATUS 0xC000009C'i32 + STATUS_DEVICE_NOT_CONNECTED* = NTSTATUS 0xC000009D'i32 + STATUS_FREE_VM_NOT_AT_BASE* = NTSTATUS 0xC000009F'i32 + STATUS_MEMORY_NOT_ALLOCATED* = NTSTATUS 0xC00000A0'i32 + STATUS_WORKING_SET_QUOTA* = NTSTATUS 0xC00000A1'i32 + STATUS_MEDIA_WRITE_PROTECTED* = NTSTATUS 0xC00000A2'i32 + STATUS_DEVICE_NOT_READY* = NTSTATUS 0xC00000A3'i32 + STATUS_INVALID_GROUP_ATTRIBUTES* = NTSTATUS 0xC00000A4'i32 + STATUS_BAD_IMPERSONATION_LEVEL* = NTSTATUS 0xC00000A5'i32 + STATUS_CANT_OPEN_ANONYMOUS* = NTSTATUS 0xC00000A6'i32 + STATUS_BAD_VALIDATION_CLASS* = NTSTATUS 0xC00000A7'i32 + STATUS_BAD_TOKEN_TYPE* = NTSTATUS 0xC00000A8'i32 + STATUS_BAD_MASTER_BOOT_RECORD* = NTSTATUS 0xC00000A9'i32 + STATUS_INSTRUCTION_MISALIGNMENT* = NTSTATUS 0xC00000AA'i32 + STATUS_INSTANCE_NOT_AVAILABLE* = NTSTATUS 0xC00000AB'i32 + STATUS_PIPE_NOT_AVAILABLE* = NTSTATUS 0xC00000AC'i32 + STATUS_INVALID_PIPE_STATE* = NTSTATUS 0xC00000AD'i32 + STATUS_PIPE_BUSY* = NTSTATUS 0xC00000AE'i32 + STATUS_ILLEGAL_FUNCTION* = NTSTATUS 0xC00000AF'i32 + STATUS_PIPE_DISCONNECTED* = NTSTATUS 0xC00000B0'i32 + STATUS_PIPE_CLOSING* = NTSTATUS 0xC00000B1'i32 + STATUS_PIPE_CONNECTED* = NTSTATUS 0xC00000B2'i32 + STATUS_PIPE_LISTENING* = NTSTATUS 0xC00000B3'i32 + STATUS_INVALID_READ_MODE* = NTSTATUS 0xC00000B4'i32 + STATUS_IO_TIMEOUT* = NTSTATUS 0xC00000B5'i32 + STATUS_FILE_FORCED_CLOSED* = NTSTATUS 0xC00000B6'i32 + STATUS_PROFILING_NOT_STARTED* = NTSTATUS 0xC00000B7'i32 + STATUS_PROFILING_NOT_STOPPED* = NTSTATUS 0xC00000B8'i32 + STATUS_COULD_NOT_INTERPRET* = NTSTATUS 0xC00000B9'i32 + STATUS_FILE_IS_A_DIRECTORY* = NTSTATUS 0xC00000BA'i32 + STATUS_NOT_SUPPORTED* = NTSTATUS 0xC00000BB'i32 + STATUS_REMOTE_NOT_LISTENING* = NTSTATUS 0xC00000BC'i32 + STATUS_DUPLICATE_NAME* = NTSTATUS 0xC00000BD'i32 + STATUS_BAD_NETWORK_PATH* = NTSTATUS 0xC00000BE'i32 + STATUS_NETWORK_BUSY* = NTSTATUS 0xC00000BF'i32 + STATUS_DEVICE_DOES_NOT_EXIST* = NTSTATUS 0xC00000C0'i32 + STATUS_TOO_MANY_COMMANDS* = NTSTATUS 0xC00000C1'i32 + STATUS_ADAPTER_HARDWARE_ERROR* = NTSTATUS 0xC00000C2'i32 + STATUS_INVALID_NETWORK_RESPONSE* = NTSTATUS 0xC00000C3'i32 + STATUS_UNEXPECTED_NETWORK_ERROR* = NTSTATUS 0xC00000C4'i32 + STATUS_BAD_REMOTE_ADAPTER* = NTSTATUS 0xC00000C5'i32 + STATUS_PRINT_QUEUE_FULL* = NTSTATUS 0xC00000C6'i32 + STATUS_NO_SPOOL_SPACE* = NTSTATUS 0xC00000C7'i32 + STATUS_PRINT_CANCELLED* = NTSTATUS 0xC00000C8'i32 + STATUS_NETWORK_NAME_DELETED* = NTSTATUS 0xC00000C9'i32 + STATUS_NETWORK_ACCESS_DENIED* = NTSTATUS 0xC00000CA'i32 + STATUS_BAD_DEVICE_TYPE* = NTSTATUS 0xC00000CB'i32 + STATUS_BAD_NETWORK_NAME* = NTSTATUS 0xC00000CC'i32 + STATUS_TOO_MANY_NAMES* = NTSTATUS 0xC00000CD'i32 + STATUS_TOO_MANY_SESSIONS* = NTSTATUS 0xC00000CE'i32 + STATUS_SHARING_PAUSED* = NTSTATUS 0xC00000CF'i32 + STATUS_REQUEST_NOT_ACCEPTED* = NTSTATUS 0xC00000D0'i32 + STATUS_REDIRECTOR_PAUSED* = NTSTATUS 0xC00000D1'i32 + STATUS_NET_WRITE_FAULT* = NTSTATUS 0xC00000D2'i32 + STATUS_PROFILING_AT_LIMIT* = NTSTATUS 0xC00000D3'i32 + STATUS_NOT_SAME_DEVICE* = NTSTATUS 0xC00000D4'i32 + STATUS_FILE_RENAMED* = NTSTATUS 0xC00000D5'i32 + STATUS_VIRTUAL_CIRCUIT_CLOSED* = NTSTATUS 0xC00000D6'i32 + STATUS_NO_SECURITY_ON_OBJECT* = NTSTATUS 0xC00000D7'i32 + STATUS_CANT_WAIT* = NTSTATUS 0xC00000D8'i32 + STATUS_PIPE_EMPTY* = NTSTATUS 0xC00000D9'i32 + STATUS_CANT_ACCESS_DOMAIN_INFO* = NTSTATUS 0xC00000DA'i32 + STATUS_CANT_TERMINATE_SELF* = NTSTATUS 0xC00000DB'i32 + STATUS_INVALID_SERVER_STATE* = NTSTATUS 0xC00000DC'i32 + STATUS_INVALID_DOMAIN_STATE* = NTSTATUS 0xC00000DD'i32 + STATUS_INVALID_DOMAIN_ROLE* = NTSTATUS 0xC00000DE'i32 + STATUS_NO_SUCH_DOMAIN* = NTSTATUS 0xC00000DF'i32 + STATUS_DOMAIN_EXISTS* = NTSTATUS 0xC00000E0'i32 + STATUS_DOMAIN_LIMIT_EXCEEDED* = NTSTATUS 0xC00000E1'i32 + STATUS_OPLOCK_NOT_GRANTED* = NTSTATUS 0xC00000E2'i32 + STATUS_INVALID_OPLOCK_PROTOCOL* = NTSTATUS 0xC00000E3'i32 + STATUS_INTERNAL_DB_CORRUPTION* = NTSTATUS 0xC00000E4'i32 + STATUS_INTERNAL_ERROR* = NTSTATUS 0xC00000E5'i32 + STATUS_GENERIC_NOT_MAPPED* = NTSTATUS 0xC00000E6'i32 + STATUS_BAD_DESCRIPTOR_FORMAT* = NTSTATUS 0xC00000E7'i32 + STATUS_INVALID_USER_BUFFER* = NTSTATUS 0xC00000E8'i32 + STATUS_UNEXPECTED_IO_ERROR* = NTSTATUS 0xC00000E9'i32 + STATUS_UNEXPECTED_MM_CREATE_ERR* = NTSTATUS 0xC00000EA'i32 + STATUS_UNEXPECTED_MM_MAP_ERROR* = NTSTATUS 0xC00000EB'i32 + STATUS_UNEXPECTED_MM_EXTEND_ERR* = NTSTATUS 0xC00000EC'i32 + STATUS_NOT_LOGON_PROCESS* = NTSTATUS 0xC00000ED'i32 + STATUS_LOGON_SESSION_EXISTS* = NTSTATUS 0xC00000EE'i32 + STATUS_INVALID_PARAMETER_1* = NTSTATUS 0xC00000EF'i32 + STATUS_INVALID_PARAMETER_2* = NTSTATUS 0xC00000F0'i32 + STATUS_INVALID_PARAMETER_3* = NTSTATUS 0xC00000F1'i32 + STATUS_INVALID_PARAMETER_4* = NTSTATUS 0xC00000F2'i32 + STATUS_INVALID_PARAMETER_5* = NTSTATUS 0xC00000F3'i32 + STATUS_INVALID_PARAMETER_6* = NTSTATUS 0xC00000F4'i32 + STATUS_INVALID_PARAMETER_7* = NTSTATUS 0xC00000F5'i32 + STATUS_INVALID_PARAMETER_8* = NTSTATUS 0xC00000F6'i32 + STATUS_INVALID_PARAMETER_9* = NTSTATUS 0xC00000F7'i32 + STATUS_INVALID_PARAMETER_10* = NTSTATUS 0xC00000F8'i32 + STATUS_INVALID_PARAMETER_11* = NTSTATUS 0xC00000F9'i32 + STATUS_INVALID_PARAMETER_12* = NTSTATUS 0xC00000FA'i32 + STATUS_REDIRECTOR_NOT_STARTED* = NTSTATUS 0xC00000FB'i32 + STATUS_REDIRECTOR_STARTED* = NTSTATUS 0xC00000FC'i32 + STATUS_STACK_OVERFLOW* = NTSTATUS 0xC00000FD'i32 + STATUS_NO_SUCH_PACKAGE* = NTSTATUS 0xC00000FE'i32 + STATUS_BAD_FUNCTION_TABLE* = NTSTATUS 0xC00000FF'i32 + STATUS_VARIABLE_NOT_FOUND* = NTSTATUS 0xC0000100'i32 + STATUS_DIRECTORY_NOT_EMPTY* = NTSTATUS 0xC0000101'i32 + STATUS_FILE_CORRUPT_ERROR* = NTSTATUS 0xC0000102'i32 + STATUS_NOT_A_DIRECTORY* = NTSTATUS 0xC0000103'i32 + STATUS_BAD_LOGON_SESSION_STATE* = NTSTATUS 0xC0000104'i32 + STATUS_LOGON_SESSION_COLLISION* = NTSTATUS 0xC0000105'i32 + STATUS_NAME_TOO_LONG* = NTSTATUS 0xC0000106'i32 + STATUS_FILES_OPEN* = NTSTATUS 0xC0000107'i32 + STATUS_CONNECTION_IN_USE* = NTSTATUS 0xC0000108'i32 + STATUS_MESSAGE_NOT_FOUND* = NTSTATUS 0xC0000109'i32 + STATUS_PROCESS_IS_TERMINATING* = NTSTATUS 0xC000010A'i32 + STATUS_INVALID_LOGON_TYPE* = NTSTATUS 0xC000010B'i32 + STATUS_NO_GUID_TRANSLATION* = NTSTATUS 0xC000010C'i32 + STATUS_CANNOT_IMPERSONATE* = NTSTATUS 0xC000010D'i32 + STATUS_IMAGE_ALREADY_LOADED* = NTSTATUS 0xC000010E'i32 + STATUS_NO_LDT* = NTSTATUS 0xC0000117'i32 + STATUS_INVALID_LDT_SIZE* = NTSTATUS 0xC0000118'i32 + STATUS_INVALID_LDT_OFFSET* = NTSTATUS 0xC0000119'i32 + STATUS_INVALID_LDT_DESCRIPTOR* = NTSTATUS 0xC000011A'i32 + STATUS_INVALID_IMAGE_NE_FORMAT* = NTSTATUS 0xC000011B'i32 + STATUS_RXACT_INVALID_STATE* = NTSTATUS 0xC000011C'i32 + STATUS_RXACT_COMMIT_FAILURE* = NTSTATUS 0xC000011D'i32 + STATUS_MAPPED_FILE_SIZE_ZERO* = NTSTATUS 0xC000011E'i32 + STATUS_TOO_MANY_OPENED_FILES* = NTSTATUS 0xC000011F'i32 + STATUS_CANCELLED* = NTSTATUS 0xC0000120'i32 + STATUS_CANNOT_DELETE* = NTSTATUS 0xC0000121'i32 + STATUS_INVALID_COMPUTER_NAME* = NTSTATUS 0xC0000122'i32 + STATUS_FILE_DELETED* = NTSTATUS 0xC0000123'i32 + STATUS_SPECIAL_ACCOUNT* = NTSTATUS 0xC0000124'i32 + STATUS_SPECIAL_GROUP* = NTSTATUS 0xC0000125'i32 + STATUS_SPECIAL_USER* = NTSTATUS 0xC0000126'i32 + STATUS_MEMBERS_PRIMARY_GROUP* = NTSTATUS 0xC0000127'i32 + STATUS_FILE_CLOSED* = NTSTATUS 0xC0000128'i32 + STATUS_TOO_MANY_THREADS* = NTSTATUS 0xC0000129'i32 + STATUS_THREAD_NOT_IN_PROCESS* = NTSTATUS 0xC000012A'i32 + STATUS_TOKEN_ALREADY_IN_USE* = NTSTATUS 0xC000012B'i32 + STATUS_PAGEFILE_QUOTA_EXCEEDED* = NTSTATUS 0xC000012C'i32 + STATUS_COMMITMENT_LIMIT* = NTSTATUS 0xC000012D'i32 + STATUS_INVALID_IMAGE_LE_FORMAT* = NTSTATUS 0xC000012E'i32 + STATUS_INVALID_IMAGE_NOT_MZ* = NTSTATUS 0xC000012F'i32 + STATUS_INVALID_IMAGE_PROTECT* = NTSTATUS 0xC0000130'i32 + STATUS_INVALID_IMAGE_WIN_16* = NTSTATUS 0xC0000131'i32 + STATUS_LOGON_SERVER_CONFLICT* = NTSTATUS 0xC0000132'i32 + STATUS_TIME_DIFFERENCE_AT_DC* = NTSTATUS 0xC0000133'i32 + STATUS_SYNCHRONIZATION_REQUIRED* = NTSTATUS 0xC0000134'i32 + STATUS_DLL_NOT_FOUND* = NTSTATUS 0xC0000135'i32 + STATUS_OPEN_FAILED* = NTSTATUS 0xC0000136'i32 + STATUS_IO_PRIVILEGE_FAILED* = NTSTATUS 0xC0000137'i32 + STATUS_ORDINAL_NOT_FOUND* = NTSTATUS 0xC0000138'i32 + STATUS_ENTRYPOINT_NOT_FOUND* = NTSTATUS 0xC0000139'i32 + STATUS_CONTROL_C_EXIT* = NTSTATUS 0xC000013A'i32 + STATUS_LOCAL_DISCONNECT* = NTSTATUS 0xC000013B'i32 + STATUS_REMOTE_DISCONNECT* = NTSTATUS 0xC000013C'i32 + STATUS_REMOTE_RESOURCES* = NTSTATUS 0xC000013D'i32 + STATUS_LINK_FAILED* = NTSTATUS 0xC000013E'i32 + STATUS_LINK_TIMEOUT* = NTSTATUS 0xC000013F'i32 + STATUS_INVALID_CONNECTION* = NTSTATUS 0xC0000140'i32 + STATUS_INVALID_ADDRESS* = NTSTATUS 0xC0000141'i32 + STATUS_DLL_INIT_FAILED* = NTSTATUS 0xC0000142'i32 + STATUS_MISSING_SYSTEMFILE* = NTSTATUS 0xC0000143'i32 + STATUS_UNHANDLED_EXCEPTION* = NTSTATUS 0xC0000144'i32 + STATUS_APP_INIT_FAILURE* = NTSTATUS 0xC0000145'i32 + STATUS_PAGEFILE_CREATE_FAILED* = NTSTATUS 0xC0000146'i32 + STATUS_NO_PAGEFILE* = NTSTATUS 0xC0000147'i32 + STATUS_INVALID_LEVEL* = NTSTATUS 0xC0000148'i32 + STATUS_WRONG_PASSWORD_CORE* = NTSTATUS 0xC0000149'i32 + STATUS_ILLEGAL_FLOAT_CONTEXT* = NTSTATUS 0xC000014A'i32 + STATUS_PIPE_BROKEN* = NTSTATUS 0xC000014B'i32 + STATUS_REGISTRY_CORRUPT* = NTSTATUS 0xC000014C'i32 + STATUS_REGISTRY_IO_FAILED* = NTSTATUS 0xC000014D'i32 + STATUS_NO_EVENT_PAIR* = NTSTATUS 0xC000014E'i32 + STATUS_UNRECOGNIZED_VOLUME* = NTSTATUS 0xC000014F'i32 + STATUS_SERIAL_NO_DEVICE_INITED* = NTSTATUS 0xC0000150'i32 + STATUS_NO_SUCH_ALIAS* = NTSTATUS 0xC0000151'i32 + STATUS_MEMBER_NOT_IN_ALIAS* = NTSTATUS 0xC0000152'i32 + STATUS_MEMBER_IN_ALIAS* = NTSTATUS 0xC0000153'i32 + STATUS_ALIAS_EXISTS* = NTSTATUS 0xC0000154'i32 + STATUS_LOGON_NOT_GRANTED* = NTSTATUS 0xC0000155'i32 + STATUS_TOO_MANY_SECRETS* = NTSTATUS 0xC0000156'i32 + STATUS_SECRET_TOO_LONG* = NTSTATUS 0xC0000157'i32 + STATUS_INTERNAL_DB_ERROR* = NTSTATUS 0xC0000158'i32 + STATUS_FULLSCREEN_MODE* = NTSTATUS 0xC0000159'i32 + STATUS_TOO_MANY_CONTEXT_IDS* = NTSTATUS 0xC000015A'i32 + STATUS_LOGON_TYPE_NOT_GRANTED* = NTSTATUS 0xC000015B'i32 + STATUS_NOT_REGISTRY_FILE* = NTSTATUS 0xC000015C'i32 + STATUS_NT_CROSS_ENCRYPTION_REQUIRED* = NTSTATUS 0xC000015D'i32 + STATUS_DOMAIN_CTRLR_CONFIG_ERROR* = NTSTATUS 0xC000015E'i32 + STATUS_FT_MISSING_MEMBER* = NTSTATUS 0xC000015F'i32 + STATUS_ILL_FORMED_SERVICE_ENTRY* = NTSTATUS 0xC0000160'i32 + STATUS_ILLEGAL_CHARACTER* = NTSTATUS 0xC0000161'i32 + STATUS_UNMAPPABLE_CHARACTER* = NTSTATUS 0xC0000162'i32 + STATUS_UNDEFINED_CHARACTER* = NTSTATUS 0xC0000163'i32 + STATUS_FLOPPY_VOLUME* = NTSTATUS 0xC0000164'i32 + STATUS_FLOPPY_ID_MARK_NOT_FOUND* = NTSTATUS 0xC0000165'i32 + STATUS_FLOPPY_WRONG_CYLINDER* = NTSTATUS 0xC0000166'i32 + STATUS_FLOPPY_UNKNOWN_ERROR* = NTSTATUS 0xC0000167'i32 + STATUS_FLOPPY_BAD_REGISTERS* = NTSTATUS 0xC0000168'i32 + STATUS_DISK_RECALIBRATE_FAILED* = NTSTATUS 0xC0000169'i32 + STATUS_DISK_OPERATION_FAILED* = NTSTATUS 0xC000016A'i32 + STATUS_DISK_RESET_FAILED* = NTSTATUS 0xC000016B'i32 + STATUS_SHARED_IRQ_BUSY* = NTSTATUS 0xC000016C'i32 + STATUS_FT_ORPHANING* = NTSTATUS 0xC000016D'i32 + STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT* = NTSTATUS 0xC000016E'i32 + STATUS_PARTITION_FAILURE* = NTSTATUS 0xC0000172'i32 + STATUS_INVALID_BLOCK_LENGTH* = NTSTATUS 0xC0000173'i32 + STATUS_DEVICE_NOT_PARTITIONED* = NTSTATUS 0xC0000174'i32 + STATUS_UNABLE_TO_LOCK_MEDIA* = NTSTATUS 0xC0000175'i32 + STATUS_UNABLE_TO_UNLOAD_MEDIA* = NTSTATUS 0xC0000176'i32 + STATUS_EOM_OVERFLOW* = NTSTATUS 0xC0000177'i32 + STATUS_NO_MEDIA* = NTSTATUS 0xC0000178'i32 + STATUS_NO_SUCH_MEMBER* = NTSTATUS 0xC000017A'i32 + STATUS_INVALID_MEMBER* = NTSTATUS 0xC000017B'i32 + STATUS_KEY_DELETED* = NTSTATUS 0xC000017C'i32 + STATUS_NO_LOG_SPACE* = NTSTATUS 0xC000017D'i32 + STATUS_TOO_MANY_SIDS* = NTSTATUS 0xC000017E'i32 + STATUS_LM_CROSS_ENCRYPTION_REQUIRED* = NTSTATUS 0xC000017F'i32 + STATUS_KEY_HAS_CHILDREN* = NTSTATUS 0xC0000180'i32 + STATUS_CHILD_MUST_BE_VOLATILE* = NTSTATUS 0xC0000181'i32 + STATUS_DEVICE_CONFIGURATION_ERROR* = NTSTATUS 0xC0000182'i32 + STATUS_DRIVER_INTERNAL_ERROR* = NTSTATUS 0xC0000183'i32 + STATUS_INVALID_DEVICE_STATE* = NTSTATUS 0xC0000184'i32 + STATUS_IO_DEVICE_ERROR* = NTSTATUS 0xC0000185'i32 + STATUS_DEVICE_PROTOCOL_ERROR* = NTSTATUS 0xC0000186'i32 + STATUS_BACKUP_CONTROLLER* = NTSTATUS 0xC0000187'i32 + STATUS_LOG_FILE_FULL* = NTSTATUS 0xC0000188'i32 + STATUS_TOO_LATE* = NTSTATUS 0xC0000189'i32 + STATUS_NO_TRUST_LSA_SECRET* = NTSTATUS 0xC000018A'i32 + STATUS_NO_TRUST_SAM_ACCOUNT* = NTSTATUS 0xC000018B'i32 + STATUS_TRUSTED_DOMAIN_FAILURE* = NTSTATUS 0xC000018C'i32 + STATUS_TRUSTED_RELATIONSHIP_FAILURE* = NTSTATUS 0xC000018D'i32 + STATUS_EVENTLOG_FILE_CORRUPT* = NTSTATUS 0xC000018E'i32 + STATUS_EVENTLOG_CANT_START* = NTSTATUS 0xC000018F'i32 + STATUS_TRUST_FAILURE* = NTSTATUS 0xC0000190'i32 + STATUS_MUTANT_LIMIT_EXCEEDED* = NTSTATUS 0xC0000191'i32 + STATUS_NETLOGON_NOT_STARTED* = NTSTATUS 0xC0000192'i32 + STATUS_ACCOUNT_EXPIRED* = NTSTATUS 0xC0000193'i32 + STATUS_POSSIBLE_DEADLOCK* = NTSTATUS 0xC0000194'i32 + STATUS_NETWORK_CREDENTIAL_CONFLICT* = NTSTATUS 0xC0000195'i32 + STATUS_REMOTE_SESSION_LIMIT* = NTSTATUS 0xC0000196'i32 + STATUS_EVENTLOG_FILE_CHANGED* = NTSTATUS 0xC0000197'i32 + STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT* = NTSTATUS 0xC0000198'i32 + STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT* = NTSTATUS 0xC0000199'i32 + STATUS_NOLOGON_SERVER_TRUST_ACCOUNT* = NTSTATUS 0xC000019A'i32 + STATUS_DOMAIN_TRUST_INCONSISTENT* = NTSTATUS 0xC000019B'i32 + STATUS_FS_DRIVER_REQUIRED* = NTSTATUS 0xC000019C'i32 + STATUS_IMAGE_ALREADY_LOADED_AS_DLL* = NTSTATUS 0xC000019D'i32 + STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING* = NTSTATUS 0xC000019E'i32 + STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME* = NTSTATUS 0xC000019F'i32 + STATUS_SECURITY_STREAM_IS_INCONSISTENT* = NTSTATUS 0xC00001A0'i32 + STATUS_INVALID_LOCK_RANGE* = NTSTATUS 0xC00001A1'i32 + STATUS_INVALID_ACE_CONDITION* = NTSTATUS 0xC00001A2'i32 + STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT* = NTSTATUS 0xC00001A3'i32 + STATUS_NOTIFICATION_GUID_ALREADY_DEFINED* = NTSTATUS 0xC00001A4'i32 + STATUS_NETWORK_OPEN_RESTRICTION* = NTSTATUS 0xC0000201'i32 + STATUS_NO_USER_SESSION_KEY* = NTSTATUS 0xC0000202'i32 + STATUS_USER_SESSION_DELETED* = NTSTATUS 0xC0000203'i32 + STATUS_RESOURCE_LANG_NOT_FOUND* = NTSTATUS 0xC0000204'i32 + STATUS_INSUFF_SERVER_RESOURCES* = NTSTATUS 0xC0000205'i32 + STATUS_INVALID_BUFFER_SIZE* = NTSTATUS 0xC0000206'i32 + STATUS_INVALID_ADDRESS_COMPONENT* = NTSTATUS 0xC0000207'i32 + STATUS_INVALID_ADDRESS_WILDCARD* = NTSTATUS 0xC0000208'i32 + STATUS_TOO_MANY_ADDRESSES* = NTSTATUS 0xC0000209'i32 + STATUS_ADDRESS_ALREADY_EXISTS* = NTSTATUS 0xC000020A'i32 + STATUS_ADDRESS_CLOSED* = NTSTATUS 0xC000020B'i32 + STATUS_CONNECTION_DISCONNECTED* = NTSTATUS 0xC000020C'i32 + STATUS_CONNECTION_RESET* = NTSTATUS 0xC000020D'i32 + STATUS_TOO_MANY_NODES* = NTSTATUS 0xC000020E'i32 + STATUS_TRANSACTION_ABORTED* = NTSTATUS 0xC000020F'i32 + STATUS_TRANSACTION_TIMED_OUT* = NTSTATUS 0xC0000210'i32 + STATUS_TRANSACTION_NO_RELEASE* = NTSTATUS 0xC0000211'i32 + STATUS_TRANSACTION_NO_MATCH* = NTSTATUS 0xC0000212'i32 + STATUS_TRANSACTION_RESPONDED* = NTSTATUS 0xC0000213'i32 + STATUS_TRANSACTION_INVALID_ID* = NTSTATUS 0xC0000214'i32 + STATUS_TRANSACTION_INVALID_TYPE* = NTSTATUS 0xC0000215'i32 + STATUS_NOT_SERVER_SESSION* = NTSTATUS 0xC0000216'i32 + STATUS_NOT_CLIENT_SESSION* = NTSTATUS 0xC0000217'i32 + STATUS_CANNOT_LOAD_REGISTRY_FILE* = NTSTATUS 0xC0000218'i32 + STATUS_DEBUG_ATTACH_FAILED* = NTSTATUS 0xC0000219'i32 + STATUS_SYSTEM_PROCESS_TERMINATED* = NTSTATUS 0xC000021A'i32 + STATUS_DATA_NOT_ACCEPTED* = NTSTATUS 0xC000021B'i32 + STATUS_NO_BROWSER_SERVERS_FOUND* = NTSTATUS 0xC000021C'i32 + STATUS_VDM_HARD_ERROR* = NTSTATUS 0xC000021D'i32 + STATUS_DRIVER_CANCEL_TIMEOUT* = NTSTATUS 0xC000021E'i32 + STATUS_REPLY_MESSAGE_MISMATCH* = NTSTATUS 0xC000021F'i32 + STATUS_MAPPED_ALIGNMENT* = NTSTATUS 0xC0000220'i32 + STATUS_IMAGE_CHECKSUM_MISMATCH* = NTSTATUS 0xC0000221'i32 + STATUS_LOST_WRITEBEHIND_DATA* = NTSTATUS 0xC0000222'i32 + STATUS_CLIENT_SERVER_PARAMETERS_INVALID* = NTSTATUS 0xC0000223'i32 + STATUS_PASSWORD_MUST_CHANGE* = NTSTATUS 0xC0000224'i32 + STATUS_NOT_FOUND* = NTSTATUS 0xC0000225'i32 + STATUS_NOT_TINY_STREAM* = NTSTATUS 0xC0000226'i32 + STATUS_RECOVERY_FAILURE* = NTSTATUS 0xC0000227'i32 + STATUS_STACK_OVERFLOW_READ* = NTSTATUS 0xC0000228'i32 + STATUS_FAIL_CHECK* = NTSTATUS 0xC0000229'i32 + STATUS_DUPLICATE_OBJECTID* = NTSTATUS 0xC000022A'i32 + STATUS_OBJECTID_EXISTS* = NTSTATUS 0xC000022B'i32 + STATUS_CONVERT_TO_LARGE* = NTSTATUS 0xC000022C'i32 + STATUS_RETRY* = NTSTATUS 0xC000022D'i32 + STATUS_FOUND_OUT_OF_SCOPE* = NTSTATUS 0xC000022E'i32 + STATUS_ALLOCATE_BUCKET* = NTSTATUS 0xC000022F'i32 + STATUS_PROPSET_NOT_FOUND* = NTSTATUS 0xC0000230'i32 + STATUS_MARSHALL_OVERFLOW* = NTSTATUS 0xC0000231'i32 + STATUS_INVALID_VARIANT* = NTSTATUS 0xC0000232'i32 + STATUS_DOMAIN_CONTROLLER_NOT_FOUND* = NTSTATUS 0xC0000233'i32 + STATUS_ACCOUNT_LOCKED_OUT* = NTSTATUS 0xC0000234'i32 + STATUS_HANDLE_NOT_CLOSABLE* = NTSTATUS 0xC0000235'i32 + STATUS_CONNECTION_REFUSED* = NTSTATUS 0xC0000236'i32 + STATUS_GRACEFUL_DISCONNECT* = NTSTATUS 0xC0000237'i32 + STATUS_ADDRESS_ALREADY_ASSOCIATED* = NTSTATUS 0xC0000238'i32 + STATUS_ADDRESS_NOT_ASSOCIATED* = NTSTATUS 0xC0000239'i32 + STATUS_CONNECTION_INVALID* = NTSTATUS 0xC000023A'i32 + STATUS_CONNECTION_ACTIVE* = NTSTATUS 0xC000023B'i32 + STATUS_NETWORK_UNREACHABLE* = NTSTATUS 0xC000023C'i32 + STATUS_HOST_UNREACHABLE* = NTSTATUS 0xC000023D'i32 + STATUS_PROTOCOL_UNREACHABLE* = NTSTATUS 0xC000023E'i32 + STATUS_PORT_UNREACHABLE* = NTSTATUS 0xC000023F'i32 + STATUS_REQUEST_ABORTED* = NTSTATUS 0xC0000240'i32 + STATUS_CONNECTION_ABORTED* = NTSTATUS 0xC0000241'i32 + STATUS_BAD_COMPRESSION_BUFFER* = NTSTATUS 0xC0000242'i32 + STATUS_USER_MAPPED_FILE* = NTSTATUS 0xC0000243'i32 + STATUS_AUDIT_FAILED* = NTSTATUS 0xC0000244'i32 + STATUS_TIMER_RESOLUTION_NOT_SET* = NTSTATUS 0xC0000245'i32 + STATUS_CONNECTION_COUNT_LIMIT* = NTSTATUS 0xC0000246'i32 + STATUS_LOGIN_TIME_RESTRICTION* = NTSTATUS 0xC0000247'i32 + STATUS_LOGIN_WKSTA_RESTRICTION* = NTSTATUS 0xC0000248'i32 + STATUS_IMAGE_MP_UP_MISMATCH* = NTSTATUS 0xC0000249'i32 + STATUS_INSUFFICIENT_LOGON_INFO* = NTSTATUS 0xC0000250'i32 + STATUS_BAD_DLL_ENTRYPOINT* = NTSTATUS 0xC0000251'i32 + STATUS_BAD_SERVICE_ENTRYPOINT* = NTSTATUS 0xC0000252'i32 + STATUS_LPC_REPLY_LOST* = NTSTATUS 0xC0000253'i32 + STATUS_IP_ADDRESS_CONFLICT1* = NTSTATUS 0xC0000254'i32 + STATUS_IP_ADDRESS_CONFLICT2* = NTSTATUS 0xC0000255'i32 + STATUS_REGISTRY_QUOTA_LIMIT* = NTSTATUS 0xC0000256'i32 + STATUS_PATH_NOT_COVERED* = NTSTATUS 0xC0000257'i32 + STATUS_NO_CALLBACK_ACTIVE* = NTSTATUS 0xC0000258'i32 + STATUS_LICENSE_QUOTA_EXCEEDED* = NTSTATUS 0xC0000259'i32 + STATUS_PWD_TOO_SHORT* = NTSTATUS 0xC000025A'i32 + STATUS_PWD_TOO_RECENT* = NTSTATUS 0xC000025B'i32 + STATUS_PWD_HISTORY_CONFLICT* = NTSTATUS 0xC000025C'i32 + STATUS_PLUGPLAY_NO_DEVICE* = NTSTATUS 0xC000025E'i32 + STATUS_UNSUPPORTED_COMPRESSION* = NTSTATUS 0xC000025F'i32 + STATUS_INVALID_HW_PROFILE* = NTSTATUS 0xC0000260'i32 + STATUS_INVALID_PLUGPLAY_DEVICE_PATH* = NTSTATUS 0xC0000261'i32 + STATUS_DRIVER_ORDINAL_NOT_FOUND* = NTSTATUS 0xC0000262'i32 + STATUS_DRIVER_ENTRYPOINT_NOT_FOUND* = NTSTATUS 0xC0000263'i32 + STATUS_RESOURCE_NOT_OWNED* = NTSTATUS 0xC0000264'i32 + STATUS_TOO_MANY_LINKS* = NTSTATUS 0xC0000265'i32 + STATUS_QUOTA_LIST_INCONSISTENT* = NTSTATUS 0xC0000266'i32 + STATUS_FILE_IS_OFFLINE* = NTSTATUS 0xC0000267'i32 + STATUS_EVALUATION_EXPIRATION* = NTSTATUS 0xC0000268'i32 + STATUS_ILLEGAL_DLL_RELOCATION* = NTSTATUS 0xC0000269'i32 + STATUS_LICENSE_VIOLATION* = NTSTATUS 0xC000026A'i32 + STATUS_DLL_INIT_FAILED_LOGOFF* = NTSTATUS 0xC000026B'i32 + STATUS_DRIVER_UNABLE_TO_LOAD* = NTSTATUS 0xC000026C'i32 + STATUS_DFS_UNAVAILABLE* = NTSTATUS 0xC000026D'i32 + STATUS_VOLUME_DISMOUNTED* = NTSTATUS 0xC000026E'i32 + STATUS_WX86_INTERNAL_ERROR* = NTSTATUS 0xC000026F'i32 + STATUS_WX86_FLOAT_STACK_CHECK* = NTSTATUS 0xC0000270'i32 + STATUS_VALIDATE_CONTINUE* = NTSTATUS 0xC0000271'i32 + STATUS_NO_MATCH* = NTSTATUS 0xC0000272'i32 + STATUS_NO_MORE_MATCHES* = NTSTATUS 0xC0000273'i32 + STATUS_NOT_A_REPARSE_POINT* = NTSTATUS 0xC0000275'i32 + STATUS_IO_REPARSE_TAG_INVALID* = NTSTATUS 0xC0000276'i32 + STATUS_IO_REPARSE_TAG_MISMATCH* = NTSTATUS 0xC0000277'i32 + STATUS_IO_REPARSE_DATA_INVALID* = NTSTATUS 0xC0000278'i32 + STATUS_IO_REPARSE_TAG_NOT_HANDLED* = NTSTATUS 0xC0000279'i32 + STATUS_REPARSE_POINT_NOT_RESOLVED* = NTSTATUS 0xC0000280'i32 + STATUS_DIRECTORY_IS_A_REPARSE_POINT* = NTSTATUS 0xC0000281'i32 + STATUS_RANGE_LIST_CONFLICT* = NTSTATUS 0xC0000282'i32 + STATUS_SOURCE_ELEMENT_EMPTY* = NTSTATUS 0xC0000283'i32 + STATUS_DESTINATION_ELEMENT_FULL* = NTSTATUS 0xC0000284'i32 + STATUS_ILLEGAL_ELEMENT_ADDRESS* = NTSTATUS 0xC0000285'i32 + STATUS_MAGAZINE_NOT_PRESENT* = NTSTATUS 0xC0000286'i32 + STATUS_REINITIALIZATION_NEEDED* = NTSTATUS 0xC0000287'i32 + STATUS_ENCRYPTION_FAILED* = NTSTATUS 0xC000028A'i32 + STATUS_DECRYPTION_FAILED* = NTSTATUS 0xC000028B'i32 + STATUS_RANGE_NOT_FOUND* = NTSTATUS 0xC000028C'i32 + STATUS_NO_RECOVERY_POLICY* = NTSTATUS 0xC000028D'i32 + STATUS_NO_EFS* = NTSTATUS 0xC000028E'i32 + STATUS_WRONG_EFS* = NTSTATUS 0xC000028F'i32 + STATUS_NO_USER_KEYS* = NTSTATUS 0xC0000290'i32 + STATUS_FILE_NOT_ENCRYPTED* = NTSTATUS 0xC0000291'i32 + STATUS_NOT_EXPORT_FORMAT* = NTSTATUS 0xC0000292'i32 + STATUS_FILE_ENCRYPTED* = NTSTATUS 0xC0000293'i32 + STATUS_WMI_GUID_NOT_FOUND* = NTSTATUS 0xC0000295'i32 + STATUS_WMI_INSTANCE_NOT_FOUND* = NTSTATUS 0xC0000296'i32 + STATUS_WMI_ITEMID_NOT_FOUND* = NTSTATUS 0xC0000297'i32 + STATUS_WMI_TRY_AGAIN* = NTSTATUS 0xC0000298'i32 + STATUS_SHARED_POLICY* = NTSTATUS 0xC0000299'i32 + STATUS_POLICY_OBJECT_NOT_FOUND* = NTSTATUS 0xC000029A'i32 + STATUS_POLICY_ONLY_IN_DS* = NTSTATUS 0xC000029B'i32 + STATUS_VOLUME_NOT_UPGRADED* = NTSTATUS 0xC000029C'i32 + STATUS_REMOTE_STORAGE_NOT_ACTIVE* = NTSTATUS 0xC000029D'i32 + STATUS_REMOTE_STORAGE_MEDIA_ERROR* = NTSTATUS 0xC000029E'i32 + STATUS_NO_TRACKING_SERVICE* = NTSTATUS 0xC000029F'i32 + STATUS_SERVER_SID_MISMATCH* = NTSTATUS 0xC00002A0'i32 + STATUS_DS_NO_ATTRIBUTE_OR_VALUE* = NTSTATUS 0xC00002A1'i32 + STATUS_DS_INVALID_ATTRIBUTE_SYNTAX* = NTSTATUS 0xC00002A2'i32 + STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED* = NTSTATUS 0xC00002A3'i32 + STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS* = NTSTATUS 0xC00002A4'i32 + STATUS_DS_BUSY* = NTSTATUS 0xC00002A5'i32 + STATUS_DS_UNAVAILABLE* = NTSTATUS 0xC00002A6'i32 + STATUS_DS_NO_RIDS_ALLOCATED* = NTSTATUS 0xC00002A7'i32 + STATUS_DS_NO_MORE_RIDS* = NTSTATUS 0xC00002A8'i32 + STATUS_DS_INCORRECT_ROLE_OWNER* = NTSTATUS 0xC00002A9'i32 + STATUS_DS_RIDMGR_INIT_ERROR* = NTSTATUS 0xC00002AA'i32 + STATUS_DS_OBJ_CLASS_VIOLATION* = NTSTATUS 0xC00002AB'i32 + STATUS_DS_CANT_ON_NON_LEAF* = NTSTATUS 0xC00002AC'i32 + STATUS_DS_CANT_ON_RDN* = NTSTATUS 0xC00002AD'i32 + STATUS_DS_CANT_MOD_OBJ_CLASS* = NTSTATUS 0xC00002AE'i32 + STATUS_DS_CROSS_DOM_MOVE_FAILED* = NTSTATUS 0xC00002AF'i32 + STATUS_DS_GC_NOT_AVAILABLE* = NTSTATUS 0xC00002B0'i32 + STATUS_DIRECTORY_SERVICE_REQUIRED* = NTSTATUS 0xC00002B1'i32 + STATUS_REPARSE_ATTRIBUTE_CONFLICT* = NTSTATUS 0xC00002B2'i32 + STATUS_CANT_ENABLE_DENY_ONLY* = NTSTATUS 0xC00002B3'i32 + STATUS_FLOAT_MULTIPLE_FAULTS* = NTSTATUS 0xC00002B4'i32 + STATUS_FLOAT_MULTIPLE_TRAPS* = NTSTATUS 0xC00002B5'i32 + STATUS_DEVICE_REMOVED* = NTSTATUS 0xC00002B6'i32 + STATUS_JOURNAL_DELETE_IN_PROGRESS* = NTSTATUS 0xC00002B7'i32 + STATUS_JOURNAL_NOT_ACTIVE* = NTSTATUS 0xC00002B8'i32 + STATUS_NOINTERFACE* = NTSTATUS 0xC00002B9'i32 + STATUS_DS_ADMIN_LIMIT_EXCEEDED* = NTSTATUS 0xC00002C1'i32 + STATUS_DRIVER_FAILED_SLEEP* = NTSTATUS 0xC00002C2'i32 + STATUS_MUTUAL_AUTHENTICATION_FAILED* = NTSTATUS 0xC00002C3'i32 + STATUS_CORRUPT_SYSTEM_FILE* = NTSTATUS 0xC00002C4'i32 + STATUS_DATATYPE_MISALIGNMENT_ERROR* = NTSTATUS 0xC00002C5'i32 + STATUS_WMI_READ_ONLY* = NTSTATUS 0xC00002C6'i32 + STATUS_WMI_SET_FAILURE* = NTSTATUS 0xC00002C7'i32 + STATUS_COMMITMENT_MINIMUM* = NTSTATUS 0xC00002C8'i32 + STATUS_REG_NAT_CONSUMPTION* = NTSTATUS 0xC00002C9'i32 + STATUS_TRANSPORT_FULL* = NTSTATUS 0xC00002CA'i32 + STATUS_DS_SAM_INIT_FAILURE* = NTSTATUS 0xC00002CB'i32 + STATUS_ONLY_IF_CONNECTED* = NTSTATUS 0xC00002CC'i32 + STATUS_DS_SENSITIVE_GROUP_VIOLATION* = NTSTATUS 0xC00002CD'i32 + STATUS_PNP_RESTART_ENUMERATION* = NTSTATUS 0xC00002CE'i32 + STATUS_JOURNAL_ENTRY_DELETED* = NTSTATUS 0xC00002CF'i32 + STATUS_DS_CANT_MOD_PRIMARYGROUPID* = NTSTATUS 0xC00002D0'i32 + STATUS_SYSTEM_IMAGE_BAD_SIGNATURE* = NTSTATUS 0xC00002D1'i32 + STATUS_PNP_REBOOT_REQUIRED* = NTSTATUS 0xC00002D2'i32 + STATUS_POWER_STATE_INVALID* = NTSTATUS 0xC00002D3'i32 + STATUS_DS_INVALID_GROUP_TYPE* = NTSTATUS 0xC00002D4'i32 + STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN* = NTSTATUS 0xC00002D5'i32 + STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN* = NTSTATUS 0xC00002D6'i32 + STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER* = NTSTATUS 0xC00002D7'i32 + STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER* = NTSTATUS 0xC00002D8'i32 + STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER* = NTSTATUS 0xC00002D9'i32 + STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER* = NTSTATUS 0xC00002DA'i32 + STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER* = NTSTATUS 0xC00002DB'i32 + STATUS_DS_HAVE_PRIMARY_MEMBERS* = NTSTATUS 0xC00002DC'i32 + STATUS_WMI_NOT_SUPPORTED* = NTSTATUS 0xC00002DD'i32 + STATUS_INSUFFICIENT_POWER* = NTSTATUS 0xC00002DE'i32 + STATUS_SAM_NEED_BOOTKEY_PASSWORD* = NTSTATUS 0xC00002DF'i32 + STATUS_SAM_NEED_BOOTKEY_FLOPPY* = NTSTATUS 0xC00002E0'i32 + STATUS_DS_CANT_START* = NTSTATUS 0xC00002E1'i32 + STATUS_DS_INIT_FAILURE* = NTSTATUS 0xC00002E2'i32 + STATUS_SAM_INIT_FAILURE* = NTSTATUS 0xC00002E3'i32 + STATUS_DS_GC_REQUIRED* = NTSTATUS 0xC00002E4'i32 + STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY* = NTSTATUS 0xC00002E5'i32 + STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS* = NTSTATUS 0xC00002E6'i32 + STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED* = NTSTATUS 0xC00002E7'i32 + STATUS_CURRENT_DOMAIN_NOT_ALLOWED* = NTSTATUS 0xC00002E9'i32 + STATUS_CANNOT_MAKE* = NTSTATUS 0xC00002EA'i32 + STATUS_SYSTEM_SHUTDOWN* = NTSTATUS 0xC00002EB'i32 + STATUS_DS_INIT_FAILURE_CONSOLE* = NTSTATUS 0xC00002EC'i32 + STATUS_DS_SAM_INIT_FAILURE_CONSOLE* = NTSTATUS 0xC00002ED'i32 + STATUS_UNFINISHED_CONTEXT_DELETED* = NTSTATUS 0xC00002EE'i32 + STATUS_NO_TGT_REPLY* = NTSTATUS 0xC00002EF'i32 + STATUS_OBJECTID_NOT_FOUND* = NTSTATUS 0xC00002F0'i32 + STATUS_NO_IP_ADDRESSES* = NTSTATUS 0xC00002F1'i32 + STATUS_WRONG_CREDENTIAL_HANDLE* = NTSTATUS 0xC00002F2'i32 + STATUS_CRYPTO_SYSTEM_INVALID* = NTSTATUS 0xC00002F3'i32 + STATUS_MAX_REFERRALS_EXCEEDED* = NTSTATUS 0xC00002F4'i32 + STATUS_MUST_BE_KDC* = NTSTATUS 0xC00002F5'i32 + STATUS_STRONG_CRYPTO_NOT_SUPPORTED* = NTSTATUS 0xC00002F6'i32 + STATUS_TOO_MANY_PRINCIPALS* = NTSTATUS 0xC00002F7'i32 + STATUS_NO_PA_DATA* = NTSTATUS 0xC00002F8'i32 + STATUS_PKINIT_NAME_MISMATCH* = NTSTATUS 0xC00002F9'i32 + STATUS_SMARTCARD_LOGON_REQUIRED* = NTSTATUS 0xC00002FA'i32 + STATUS_KDC_INVALID_REQUEST* = NTSTATUS 0xC00002FB'i32 + STATUS_KDC_UNABLE_TO_REFER* = NTSTATUS 0xC00002FC'i32 + STATUS_KDC_UNKNOWN_ETYPE* = NTSTATUS 0xC00002FD'i32 + STATUS_SHUTDOWN_IN_PROGRESS* = NTSTATUS 0xC00002FE'i32 + STATUS_SERVER_SHUTDOWN_IN_PROGRESS* = NTSTATUS 0xC00002FF'i32 + STATUS_NOT_SUPPORTED_ON_SBS* = NTSTATUS 0xC0000300'i32 + STATUS_WMI_GUID_DISCONNECTED* = NTSTATUS 0xC0000301'i32 + STATUS_WMI_ALREADY_DISABLED* = NTSTATUS 0xC0000302'i32 + STATUS_WMI_ALREADY_ENABLED* = NTSTATUS 0xC0000303'i32 + STATUS_MFT_TOO_FRAGMENTED* = NTSTATUS 0xC0000304'i32 + STATUS_COPY_PROTECTION_FAILURE* = NTSTATUS 0xC0000305'i32 + STATUS_CSS_AUTHENTICATION_FAILURE* = NTSTATUS 0xC0000306'i32 + STATUS_CSS_KEY_NOT_PRESENT* = NTSTATUS 0xC0000307'i32 + STATUS_CSS_KEY_NOT_ESTABLISHED* = NTSTATUS 0xC0000308'i32 + STATUS_CSS_SCRAMBLED_SECTOR* = NTSTATUS 0xC0000309'i32 + STATUS_CSS_REGION_MISMATCH* = NTSTATUS 0xC000030A'i32 + STATUS_CSS_RESETS_EXHAUSTED* = NTSTATUS 0xC000030B'i32 + STATUS_PKINIT_FAILURE* = NTSTATUS 0xC0000320'i32 + STATUS_SMARTCARD_SUBSYSTEM_FAILURE* = NTSTATUS 0xC0000321'i32 + STATUS_NO_KERB_KEY* = NTSTATUS 0xC0000322'i32 + STATUS_HOST_DOWN* = NTSTATUS 0xC0000350'i32 + STATUS_UNSUPPORTED_PREAUTH* = NTSTATUS 0xC0000351'i32 + STATUS_EFS_ALG_BLOB_TOO_BIG* = NTSTATUS 0xC0000352'i32 + STATUS_PORT_NOT_SET* = NTSTATUS 0xC0000353'i32 + STATUS_DEBUGGER_INACTIVE* = NTSTATUS 0xC0000354'i32 + STATUS_DS_VERSION_CHECK_FAILURE* = NTSTATUS 0xC0000355'i32 + STATUS_AUDITING_DISABLED* = NTSTATUS 0xC0000356'i32 + STATUS_PRENT4_MACHINE_ACCOUNT* = NTSTATUS 0xC0000357'i32 + STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER* = NTSTATUS 0xC0000358'i32 + STATUS_INVALID_IMAGE_WIN_32* = NTSTATUS 0xC0000359'i32 + STATUS_INVALID_IMAGE_WIN_64* = NTSTATUS 0xC000035A'i32 + STATUS_BAD_BINDINGS* = NTSTATUS 0xC000035B'i32 + STATUS_NETWORK_SESSION_EXPIRED* = NTSTATUS 0xC000035C'i32 + STATUS_APPHELP_BLOCK* = NTSTATUS 0xC000035D'i32 + STATUS_ALL_SIDS_FILTERED* = NTSTATUS 0xC000035E'i32 + STATUS_NOT_SAFE_MODE_DRIVER* = NTSTATUS 0xC000035F'i32 + STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT* = NTSTATUS 0xC0000361'i32 + STATUS_ACCESS_DISABLED_BY_POLICY_PATH* = NTSTATUS 0xC0000362'i32 + STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER* = NTSTATUS 0xC0000363'i32 + STATUS_ACCESS_DISABLED_BY_POLICY_OTHER* = NTSTATUS 0xC0000364'i32 + STATUS_FAILED_DRIVER_ENTRY* = NTSTATUS 0xC0000365'i32 + STATUS_DEVICE_ENUMERATION_ERROR* = NTSTATUS 0xC0000366'i32 + STATUS_MOUNT_POINT_NOT_RESOLVED* = NTSTATUS 0xC0000368'i32 + STATUS_INVALID_DEVICE_OBJECT_PARAMETER* = NTSTATUS 0xC0000369'i32 + STATUS_MCA_OCCURED* = NTSTATUS 0xC000036A'i32 + STATUS_DRIVER_BLOCKED_CRITICAL* = NTSTATUS 0xC000036B'i32 + STATUS_DRIVER_BLOCKED* = NTSTATUS 0xC000036C'i32 + STATUS_DRIVER_DATABASE_ERROR* = NTSTATUS 0xC000036D'i32 + STATUS_SYSTEM_HIVE_TOO_LARGE* = NTSTATUS 0xC000036E'i32 + STATUS_INVALID_IMPORT_OF_NON_DLL* = NTSTATUS 0xC000036F'i32 + STATUS_NO_SECRETS* = NTSTATUS 0xC0000371'i32 + STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY* = NTSTATUS 0xC0000372'i32 + STATUS_FAILED_STACK_SWITCH* = NTSTATUS 0xC0000373'i32 + STATUS_HEAP_CORRUPTION* = NTSTATUS 0xC0000374'i32 + STATUS_SMARTCARD_WRONG_PIN* = NTSTATUS 0xC0000380'i32 + STATUS_SMARTCARD_CARD_BLOCKED* = NTSTATUS 0xC0000381'i32 + STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED* = NTSTATUS 0xC0000382'i32 + STATUS_SMARTCARD_NO_CARD* = NTSTATUS 0xC0000383'i32 + STATUS_SMARTCARD_NO_KEY_CONTAINER* = NTSTATUS 0xC0000384'i32 + STATUS_SMARTCARD_NO_CERTIFICATE* = NTSTATUS 0xC0000385'i32 + STATUS_SMARTCARD_NO_KEYSET* = NTSTATUS 0xC0000386'i32 + STATUS_SMARTCARD_IO_ERROR* = NTSTATUS 0xC0000387'i32 + STATUS_DOWNGRADE_DETECTED* = NTSTATUS 0xC0000388'i32 + STATUS_SMARTCARD_CERT_REVOKED* = NTSTATUS 0xC0000389'i32 + STATUS_ISSUING_CA_UNTRUSTED* = NTSTATUS 0xC000038A'i32 + STATUS_REVOCATION_OFFLINE_C* = NTSTATUS 0xC000038B'i32 + STATUS_PKINIT_CLIENT_FAILURE* = NTSTATUS 0xC000038C'i32 + STATUS_SMARTCARD_CERT_EXPIRED* = NTSTATUS 0xC000038D'i32 + STATUS_DRIVER_FAILED_PRIOR_UNLOAD* = NTSTATUS 0xC000038E'i32 + STATUS_SMARTCARD_SILENT_CONTEXT* = NTSTATUS 0xC000038F'i32 + STATUS_PER_USER_TRUST_QUOTA_EXCEEDED* = NTSTATUS 0xC0000401'i32 + STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED* = NTSTATUS 0xC0000402'i32 + STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED* = NTSTATUS 0xC0000403'i32 + STATUS_DS_NAME_NOT_UNIQUE* = NTSTATUS 0xC0000404'i32 + STATUS_DS_DUPLICATE_ID_FOUND* = NTSTATUS 0xC0000405'i32 + STATUS_DS_GROUP_CONVERSION_ERROR* = NTSTATUS 0xC0000406'i32 + STATUS_VOLSNAP_PREPARE_HIBERNATE* = NTSTATUS 0xC0000407'i32 + STATUS_USER2USER_REQUIRED* = NTSTATUS 0xC0000408'i32 + STATUS_STACK_BUFFER_OVERRUN* = NTSTATUS 0xC0000409'i32 + STATUS_NO_S4U_PROT_SUPPORT* = NTSTATUS 0xC000040A'i32 + STATUS_CROSSREALM_DELEGATION_FAILURE* = NTSTATUS 0xC000040B'i32 + STATUS_REVOCATION_OFFLINE_KDC* = NTSTATUS 0xC000040C'i32 + STATUS_ISSUING_CA_UNTRUSTED_KDC* = NTSTATUS 0xC000040D'i32 + STATUS_KDC_CERT_EXPIRED* = NTSTATUS 0xC000040E'i32 + STATUS_KDC_CERT_REVOKED* = NTSTATUS 0xC000040F'i32 + STATUS_PARAMETER_QUOTA_EXCEEDED* = NTSTATUS 0xC0000410'i32 + STATUS_HIBERNATION_FAILURE* = NTSTATUS 0xC0000411'i32 + STATUS_DELAY_LOAD_FAILED* = NTSTATUS 0xC0000412'i32 + STATUS_AUTHENTICATION_FIREWALL_FAILED* = NTSTATUS 0xC0000413'i32 + STATUS_VDM_DISALLOWED* = NTSTATUS 0xC0000414'i32 + STATUS_HUNG_DISPLAY_DRIVER_THREAD* = NTSTATUS 0xC0000415'i32 + STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE* = NTSTATUS 0xC0000416'i32 + STATUS_INVALID_CRUNTIME_PARAMETER* = NTSTATUS 0xC0000417'i32 + STATUS_NTLM_BLOCKED* = NTSTATUS 0xC0000418'i32 + STATUS_DS_SRC_SID_EXISTS_IN_FOREST* = NTSTATUS 0xC0000419'i32 + STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST* = NTSTATUS 0xC000041A'i32 + STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST* = NTSTATUS 0xC000041B'i32 + STATUS_INVALID_USER_PRINCIPAL_NAME* = NTSTATUS 0xC000041C'i32 + STATUS_ASSERTION_FAILURE* = NTSTATUS 0xC0000420'i32 + STATUS_VERIFIER_STOP* = NTSTATUS 0xC0000421'i32 + STATUS_CALLBACK_POP_STACK* = NTSTATUS 0xC0000423'i32 + STATUS_INCOMPATIBLE_DRIVER_BLOCKED* = NTSTATUS 0xC0000424'i32 + STATUS_HIVE_UNLOADED* = NTSTATUS 0xC0000425'i32 + STATUS_COMPRESSION_DISABLED* = NTSTATUS 0xC0000426'i32 + STATUS_FILE_SYSTEM_LIMITATION* = NTSTATUS 0xC0000427'i32 + STATUS_INVALID_IMAGE_HASH* = NTSTATUS 0xC0000428'i32 + STATUS_NOT_CAPABLE* = NTSTATUS 0xC0000429'i32 + STATUS_REQUEST_OUT_OF_SEQUENCE* = NTSTATUS 0xC000042A'i32 + STATUS_IMPLEMENTATION_LIMIT* = NTSTATUS 0xC000042B'i32 + STATUS_ELEVATION_REQUIRED* = NTSTATUS 0xC000042C'i32 + STATUS_NO_SECURITY_CONTEXT* = NTSTATUS 0xC000042D'i32 + STATUS_PKU2U_CERT_FAILURE* = NTSTATUS 0xC000042E'i32 + STATUS_BEYOND_VDL* = NTSTATUS 0xC0000432'i32 + STATUS_ENCOUNTERED_WRITE_IN_PROGRESS* = NTSTATUS 0xC0000433'i32 + STATUS_PTE_CHANGED* = NTSTATUS 0xC0000434'i32 + STATUS_PURGE_FAILED* = NTSTATUS 0xC0000435'i32 + STATUS_CRED_REQUIRES_CONFIRMATION* = NTSTATUS 0xC0000440'i32 + STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE* = NTSTATUS 0xC0000441'i32 + STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER* = NTSTATUS 0xC0000442'i32 + STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE* = NTSTATUS 0xC0000443'i32 + STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE* = NTSTATUS 0xC0000444'i32 + STATUS_CS_ENCRYPTION_FILE_NOT_CSE* = NTSTATUS 0xC0000445'i32 + STATUS_INVALID_LABEL* = NTSTATUS 0xC0000446'i32 + STATUS_DRIVER_PROCESS_TERMINATED* = NTSTATUS 0xC0000450'i32 + STATUS_AMBIGUOUS_SYSTEM_DEVICE* = NTSTATUS 0xC0000451'i32 + STATUS_SYSTEM_DEVICE_NOT_FOUND* = NTSTATUS 0xC0000452'i32 + STATUS_RESTART_BOOT_APPLICATION* = NTSTATUS 0xC0000453'i32 + STATUS_INSUFFICIENT_NVRAM_RESOURCES* = NTSTATUS 0xC0000454'i32 + STATUS_INVALID_TASK_NAME* = NTSTATUS 0xC0000500'i32 + STATUS_INVALID_TASK_INDEX* = NTSTATUS 0xC0000501'i32 + STATUS_THREAD_ALREADY_IN_TASK* = NTSTATUS 0xC0000502'i32 + STATUS_CALLBACK_BYPASS* = NTSTATUS 0xC0000503'i32 + STATUS_FAIL_FAST_EXCEPTION* = NTSTATUS 0xC0000602'i32 + STATUS_IMAGE_CERT_REVOKED* = NTSTATUS 0xC0000603'i32 + STATUS_PORT_CLOSED* = NTSTATUS 0xC0000700'i32 + STATUS_MESSAGE_LOST* = NTSTATUS 0xC0000701'i32 + STATUS_INVALID_MESSAGE* = NTSTATUS 0xC0000702'i32 + STATUS_REQUEST_CANCELED* = NTSTATUS 0xC0000703'i32 + STATUS_RECURSIVE_DISPATCH* = NTSTATUS 0xC0000704'i32 + STATUS_LPC_RECEIVE_BUFFER_EXPECTED* = NTSTATUS 0xC0000705'i32 + STATUS_LPC_INVALID_CONNECTION_USAGE* = NTSTATUS 0xC0000706'i32 + STATUS_LPC_REQUESTS_NOT_ALLOWED* = NTSTATUS 0xC0000707'i32 + STATUS_RESOURCE_IN_USE* = NTSTATUS 0xC0000708'i32 + STATUS_HARDWARE_MEMORY_ERROR* = NTSTATUS 0xC0000709'i32 + STATUS_THREADPOOL_HANDLE_EXCEPTION* = NTSTATUS 0xC000070A'i32 + STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED* = NTSTATUS 0xC000070B'i32 + STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED* = NTSTATUS 0xC000070C'i32 + STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED* = NTSTATUS 0xC000070D'i32 + STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED* = NTSTATUS 0xC000070E'i32 + STATUS_THREADPOOL_RELEASED_DURING_OPERATION* = NTSTATUS 0xC000070F'i32 + STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING* = NTSTATUS 0xC0000710'i32 + STATUS_APC_RETURNED_WHILE_IMPERSONATING* = NTSTATUS 0xC0000711'i32 + STATUS_PROCESS_IS_PROTECTED* = NTSTATUS 0xC0000712'i32 + STATUS_MCA_EXCEPTION* = NTSTATUS 0xC0000713'i32 + STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE* = NTSTATUS 0xC0000714'i32 + STATUS_SYMLINK_CLASS_DISABLED* = NTSTATUS 0xC0000715'i32 + STATUS_INVALID_IDN_NORMALIZATION* = NTSTATUS 0xC0000716'i32 + STATUS_NO_UNICODE_TRANSLATION* = NTSTATUS 0xC0000717'i32 + STATUS_ALREADY_REGISTERED* = NTSTATUS 0xC0000718'i32 + STATUS_CONTEXT_MISMATCH* = NTSTATUS 0xC0000719'i32 + STATUS_PORT_ALREADY_HAS_COMPLETION_LIST* = NTSTATUS 0xC000071A'i32 + STATUS_CALLBACK_RETURNED_THREAD_PRIORITY* = NTSTATUS 0xC000071B'i32 + STATUS_INVALID_THREAD* = NTSTATUS 0xC000071C'i32 + STATUS_CALLBACK_RETURNED_TRANSACTION* = NTSTATUS 0xC000071D'i32 + STATUS_CALLBACK_RETURNED_LDR_LOCK* = NTSTATUS 0xC000071E'i32 + STATUS_CALLBACK_RETURNED_LANG* = NTSTATUS 0xC000071F'i32 + STATUS_CALLBACK_RETURNED_PRI_BACK* = NTSTATUS 0xC0000720'i32 + STATUS_DISK_REPAIR_DISABLED* = NTSTATUS 0xC0000800'i32 + STATUS_DS_DOMAIN_RENAME_IN_PROGRESS* = NTSTATUS 0xC0000801'i32 + STATUS_DISK_QUOTA_EXCEEDED* = NTSTATUS 0xC0000802'i32 + STATUS_CONTENT_BLOCKED* = NTSTATUS 0xC0000804'i32 + STATUS_BAD_CLUSTERS* = NTSTATUS 0xC0000805'i32 + STATUS_VOLUME_DIRTY* = NTSTATUS 0xC0000806'i32 + STATUS_FILE_CHECKED_OUT* = NTSTATUS 0xC0000901'i32 + STATUS_CHECKOUT_REQUIRED* = NTSTATUS 0xC0000902'i32 + STATUS_BAD_FILE_TYPE* = NTSTATUS 0xC0000903'i32 + STATUS_FILE_TOO_LARGE* = NTSTATUS 0xC0000904'i32 + STATUS_FORMS_AUTH_REQUIRED* = NTSTATUS 0xC0000905'i32 + STATUS_VIRUS_INFECTED* = NTSTATUS 0xC0000906'i32 + STATUS_VIRUS_DELETED* = NTSTATUS 0xC0000907'i32 + STATUS_BAD_MCFG_TABLE* = NTSTATUS 0xC0000908'i32 + STATUS_CANNOT_BREAK_OPLOCK* = NTSTATUS 0xC0000909'i32 + STATUS_WOW_ASSERTION* = NTSTATUS 0xC0009898'i32 + STATUS_INVALID_SIGNATURE* = NTSTATUS 0xC000A000'i32 + STATUS_HMAC_NOT_SUPPORTED* = NTSTATUS 0xC000A001'i32 + STATUS_IPSEC_QUEUE_OVERFLOW* = NTSTATUS 0xC000A010'i32 + STATUS_ND_QUEUE_OVERFLOW* = NTSTATUS 0xC000A011'i32 + STATUS_HOPLIMIT_EXCEEDED* = NTSTATUS 0xC000A012'i32 + STATUS_PROTOCOL_NOT_SUPPORTED* = NTSTATUS 0xC000A013'i32 + STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED* = NTSTATUS 0xC000A080'i32 + STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR* = NTSTATUS 0xC000A081'i32 + STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR* = NTSTATUS 0xC000A082'i32 + STATUS_XML_PARSE_ERROR* = NTSTATUS 0xC000A083'i32 + STATUS_XMLDSIG_ERROR* = NTSTATUS 0xC000A084'i32 + STATUS_WRONG_COMPARTMENT* = NTSTATUS 0xC000A085'i32 + STATUS_AUTHIP_FAILURE* = NTSTATUS 0xC000A086'i32 + STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS* = NTSTATUS 0xC000A087'i32 + STATUS_DS_OID_NOT_FOUND* = NTSTATUS 0xC000A088'i32 + STATUS_HASH_NOT_SUPPORTED* = NTSTATUS 0xC000A100'i32 + STATUS_HASH_NOT_PRESENT* = NTSTATUS 0xC000A101'i32 + DBG_NO_STATE_CHANGE* = NTSTATUS 0xC0010001'i32 + DBG_APP_NOT_IDLE* = NTSTATUS 0xC0010002'i32 + RPC_NT_INVALID_STRING_BINDING* = NTSTATUS 0xC0020001'i32 + RPC_NT_WRONG_KIND_OF_BINDING* = NTSTATUS 0xC0020002'i32 + RPC_NT_INVALID_BINDING* = NTSTATUS 0xC0020003'i32 + RPC_NT_PROTSEQ_NOT_SUPPORTED* = NTSTATUS 0xC0020004'i32 + RPC_NT_INVALID_RPC_PROTSEQ* = NTSTATUS 0xC0020005'i32 + RPC_NT_INVALID_STRING_UUID* = NTSTATUS 0xC0020006'i32 + RPC_NT_INVALID_ENDPOINT_FORMAT* = NTSTATUS 0xC0020007'i32 + RPC_NT_INVALID_NET_ADDR* = NTSTATUS 0xC0020008'i32 + RPC_NT_NO_ENDPOINT_FOUND* = NTSTATUS 0xC0020009'i32 + RPC_NT_INVALID_TIMEOUT* = NTSTATUS 0xC002000A'i32 + RPC_NT_OBJECT_NOT_FOUND* = NTSTATUS 0xC002000B'i32 + RPC_NT_ALREADY_REGISTERED* = NTSTATUS 0xC002000C'i32 + RPC_NT_TYPE_ALREADY_REGISTERED* = NTSTATUS 0xC002000D'i32 + RPC_NT_ALREADY_LISTENING* = NTSTATUS 0xC002000E'i32 + RPC_NT_NO_PROTSEQS_REGISTERED* = NTSTATUS 0xC002000F'i32 + RPC_NT_NOT_LISTENING* = NTSTATUS 0xC0020010'i32 + RPC_NT_UNKNOWN_MGR_TYPE* = NTSTATUS 0xC0020011'i32 + RPC_NT_UNKNOWN_IF* = NTSTATUS 0xC0020012'i32 + RPC_NT_NO_BINDINGS* = NTSTATUS 0xC0020013'i32 + RPC_NT_NO_PROTSEQS* = NTSTATUS 0xC0020014'i32 + RPC_NT_CANT_CREATE_ENDPOINT* = NTSTATUS 0xC0020015'i32 + RPC_NT_OUT_OF_RESOURCES* = NTSTATUS 0xC0020016'i32 + RPC_NT_SERVER_UNAVAILABLE* = NTSTATUS 0xC0020017'i32 + RPC_NT_SERVER_TOO_BUSY* = NTSTATUS 0xC0020018'i32 + RPC_NT_INVALID_NETWORK_OPTIONS* = NTSTATUS 0xC0020019'i32 + RPC_NT_NO_CALL_ACTIVE* = NTSTATUS 0xC002001A'i32 + RPC_NT_CALL_FAILED* = NTSTATUS 0xC002001B'i32 + RPC_NT_CALL_FAILED_DNE* = NTSTATUS 0xC002001C'i32 + RPC_NT_PROTOCOL_ERROR* = NTSTATUS 0xC002001D'i32 + RPC_NT_UNSUPPORTED_TRANS_SYN* = NTSTATUS 0xC002001F'i32 + RPC_NT_UNSUPPORTED_TYPE* = NTSTATUS 0xC0020021'i32 + RPC_NT_INVALID_TAG* = NTSTATUS 0xC0020022'i32 + RPC_NT_INVALID_BOUND* = NTSTATUS 0xC0020023'i32 + RPC_NT_NO_ENTRY_NAME* = NTSTATUS 0xC0020024'i32 + RPC_NT_INVALID_NAME_SYNTAX* = NTSTATUS 0xC0020025'i32 + RPC_NT_UNSUPPORTED_NAME_SYNTAX* = NTSTATUS 0xC0020026'i32 + RPC_NT_UUID_NO_ADDRESS* = NTSTATUS 0xC0020028'i32 + RPC_NT_DUPLICATE_ENDPOINT* = NTSTATUS 0xC0020029'i32 + RPC_NT_UNKNOWN_AUTHN_TYPE* = NTSTATUS 0xC002002A'i32 + RPC_NT_MAX_CALLS_TOO_SMALL* = NTSTATUS 0xC002002B'i32 + RPC_NT_STRING_TOO_LONG* = NTSTATUS 0xC002002C'i32 + RPC_NT_PROTSEQ_NOT_FOUND* = NTSTATUS 0xC002002D'i32 + RPC_NT_PROCNUM_OUT_OF_RANGE* = NTSTATUS 0xC002002E'i32 + RPC_NT_BINDING_HAS_NO_AUTH* = NTSTATUS 0xC002002F'i32 + RPC_NT_UNKNOWN_AUTHN_SERVICE* = NTSTATUS 0xC0020030'i32 + RPC_NT_UNKNOWN_AUTHN_LEVEL* = NTSTATUS 0xC0020031'i32 + RPC_NT_INVALID_AUTH_IDENTITY* = NTSTATUS 0xC0020032'i32 + RPC_NT_UNKNOWN_AUTHZ_SERVICE* = NTSTATUS 0xC0020033'i32 + EPT_NT_INVALID_ENTRY* = NTSTATUS 0xC0020034'i32 + EPT_NT_CANT_PERFORM_OP* = NTSTATUS 0xC0020035'i32 + EPT_NT_NOT_REGISTERED* = NTSTATUS 0xC0020036'i32 + RPC_NT_NOTHING_TO_EXPORT* = NTSTATUS 0xC0020037'i32 + RPC_NT_INCOMPLETE_NAME* = NTSTATUS 0xC0020038'i32 + RPC_NT_INVALID_VERS_OPTION* = NTSTATUS 0xC0020039'i32 + RPC_NT_NO_MORE_MEMBERS* = NTSTATUS 0xC002003A'i32 + RPC_NT_NOT_ALL_OBJS_UNEXPORTED* = NTSTATUS 0xC002003B'i32 + RPC_NT_INTERFACE_NOT_FOUND* = NTSTATUS 0xC002003C'i32 + RPC_NT_ENTRY_ALREADY_EXISTS* = NTSTATUS 0xC002003D'i32 + RPC_NT_ENTRY_NOT_FOUND* = NTSTATUS 0xC002003E'i32 + RPC_NT_NAME_SERVICE_UNAVAILABLE* = NTSTATUS 0xC002003F'i32 + RPC_NT_INVALID_NAF_ID* = NTSTATUS 0xC0020040'i32 + RPC_NT_CANNOT_SUPPORT* = NTSTATUS 0xC0020041'i32 + RPC_NT_NO_CONTEXT_AVAILABLE* = NTSTATUS 0xC0020042'i32 + RPC_NT_INTERNAL_ERROR* = NTSTATUS 0xC0020043'i32 + RPC_NT_ZERO_DIVIDE* = NTSTATUS 0xC0020044'i32 + RPC_NT_ADDRESS_ERROR* = NTSTATUS 0xC0020045'i32 + RPC_NT_FP_DIV_ZERO* = NTSTATUS 0xC0020046'i32 + RPC_NT_FP_UNDERFLOW* = NTSTATUS 0xC0020047'i32 + RPC_NT_FP_OVERFLOW* = NTSTATUS 0xC0020048'i32 + RPC_NT_CALL_IN_PROGRESS* = NTSTATUS 0xC0020049'i32 + RPC_NT_NO_MORE_BINDINGS* = NTSTATUS 0xC002004A'i32 + RPC_NT_GROUP_MEMBER_NOT_FOUND* = NTSTATUS 0xC002004B'i32 + EPT_NT_CANT_CREATE* = NTSTATUS 0xC002004C'i32 + RPC_NT_INVALID_OBJECT* = NTSTATUS 0xC002004D'i32 + RPC_NT_NO_INTERFACES* = NTSTATUS 0xC002004F'i32 + RPC_NT_CALL_CANCELLED* = NTSTATUS 0xC0020050'i32 + RPC_NT_BINDING_INCOMPLETE* = NTSTATUS 0xC0020051'i32 + RPC_NT_COMM_FAILURE* = NTSTATUS 0xC0020052'i32 + RPC_NT_UNSUPPORTED_AUTHN_LEVEL* = NTSTATUS 0xC0020053'i32 + RPC_NT_NO_PRINC_NAME* = NTSTATUS 0xC0020054'i32 + RPC_NT_NOT_RPC_ERROR* = NTSTATUS 0xC0020055'i32 + RPC_NT_SEC_PKG_ERROR* = NTSTATUS 0xC0020057'i32 + RPC_NT_NOT_CANCELLED* = NTSTATUS 0xC0020058'i32 + RPC_NT_INVALID_ASYNC_HANDLE* = NTSTATUS 0xC0020062'i32 + RPC_NT_INVALID_ASYNC_CALL* = NTSTATUS 0xC0020063'i32 + RPC_NT_PROXY_ACCESS_DENIED* = NTSTATUS 0xC0020064'i32 + RPC_NT_NO_MORE_ENTRIES* = NTSTATUS 0xC0030001'i32 + RPC_NT_SS_CHAR_TRANS_OPEN_FAIL* = NTSTATUS 0xC0030002'i32 + RPC_NT_SS_CHAR_TRANS_SHORT_FILE* = NTSTATUS 0xC0030003'i32 + RPC_NT_SS_IN_NULL_CONTEXT* = NTSTATUS 0xC0030004'i32 + RPC_NT_SS_CONTEXT_MISMATCH* = NTSTATUS 0xC0030005'i32 + RPC_NT_SS_CONTEXT_DAMAGED* = NTSTATUS 0xC0030006'i32 + RPC_NT_SS_HANDLES_MISMATCH* = NTSTATUS 0xC0030007'i32 + RPC_NT_SS_CANNOT_GET_CALL_HANDLE* = NTSTATUS 0xC0030008'i32 + RPC_NT_NULL_REF_POINTER* = NTSTATUS 0xC0030009'i32 + RPC_NT_ENUM_VALUE_OUT_OF_RANGE* = NTSTATUS 0xC003000A'i32 + RPC_NT_BYTE_COUNT_TOO_SMALL* = NTSTATUS 0xC003000B'i32 + RPC_NT_BAD_STUB_DATA* = NTSTATUS 0xC003000C'i32 + RPC_NT_INVALID_ES_ACTION* = NTSTATUS 0xC0030059'i32 + RPC_NT_WRONG_ES_VERSION* = NTSTATUS 0xC003005A'i32 + RPC_NT_WRONG_STUB_VERSION* = NTSTATUS 0xC003005B'i32 + RPC_NT_INVALID_PIPE_OBJECT* = NTSTATUS 0xC003005C'i32 + RPC_NT_INVALID_PIPE_OPERATION* = NTSTATUS 0xC003005D'i32 + RPC_NT_WRONG_PIPE_VERSION* = NTSTATUS 0xC003005E'i32 + RPC_NT_PIPE_CLOSED* = NTSTATUS 0xC003005F'i32 + RPC_NT_PIPE_DISCIPLINE_ERROR* = NTSTATUS 0xC0030060'i32 + RPC_NT_PIPE_EMPTY* = NTSTATUS 0xC0030061'i32 + STATUS_PNP_BAD_MPS_TABLE* = NTSTATUS 0xC0040035'i32 + STATUS_PNP_TRANSLATION_FAILED* = NTSTATUS 0xC0040036'i32 + STATUS_PNP_IRQ_TRANSLATION_FAILED* = NTSTATUS 0xC0040037'i32 + STATUS_PNP_INVALID_ID* = NTSTATUS 0xC0040038'i32 + STATUS_IO_REISSUE_AS_CACHED* = NTSTATUS 0xC0040039'i32 + STATUS_CTX_WINSTATION_NAME_INVALID* = NTSTATUS 0xC00A0001'i32 + STATUS_CTX_INVALID_PD* = NTSTATUS 0xC00A0002'i32 + STATUS_CTX_PD_NOT_FOUND* = NTSTATUS 0xC00A0003'i32 + STATUS_CTX_CLOSE_PENDING* = NTSTATUS 0xC00A0006'i32 + STATUS_CTX_NO_OUTBUF* = NTSTATUS 0xC00A0007'i32 + STATUS_CTX_MODEM_INF_NOT_FOUND* = NTSTATUS 0xC00A0008'i32 + STATUS_CTX_INVALID_MODEMNAME* = NTSTATUS 0xC00A0009'i32 + STATUS_CTX_RESPONSE_ERROR* = NTSTATUS 0xC00A000A'i32 + STATUS_CTX_MODEM_RESPONSE_TIMEOUT* = NTSTATUS 0xC00A000B'i32 + STATUS_CTX_MODEM_RESPONSE_NO_CARRIER* = NTSTATUS 0xC00A000C'i32 + STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE* = NTSTATUS 0xC00A000D'i32 + STATUS_CTX_MODEM_RESPONSE_BUSY* = NTSTATUS 0xC00A000E'i32 + STATUS_CTX_MODEM_RESPONSE_VOICE* = NTSTATUS 0xC00A000F'i32 + STATUS_CTX_TD_ERROR* = NTSTATUS 0xC00A0010'i32 + STATUS_CTX_LICENSE_CLIENT_INVALID* = NTSTATUS 0xC00A0012'i32 + STATUS_CTX_LICENSE_NOT_AVAILABLE* = NTSTATUS 0xC00A0013'i32 + STATUS_CTX_LICENSE_EXPIRED* = NTSTATUS 0xC00A0014'i32 + STATUS_CTX_WINSTATION_NOT_FOUND* = NTSTATUS 0xC00A0015'i32 + STATUS_CTX_WINSTATION_NAME_COLLISION* = NTSTATUS 0xC00A0016'i32 + STATUS_CTX_WINSTATION_BUSY* = NTSTATUS 0xC00A0017'i32 + STATUS_CTX_BAD_VIDEO_MODE* = NTSTATUS 0xC00A0018'i32 + STATUS_CTX_GRAPHICS_INVALID* = NTSTATUS 0xC00A0022'i32 + STATUS_CTX_NOT_CONSOLE* = NTSTATUS 0xC00A0024'i32 + STATUS_CTX_CLIENT_QUERY_TIMEOUT* = NTSTATUS 0xC00A0026'i32 + STATUS_CTX_CONSOLE_DISCONNECT* = NTSTATUS 0xC00A0027'i32 + STATUS_CTX_CONSOLE_CONNECT* = NTSTATUS 0xC00A0028'i32 + STATUS_CTX_SHADOW_DENIED* = NTSTATUS 0xC00A002A'i32 + STATUS_CTX_WINSTATION_ACCESS_DENIED* = NTSTATUS 0xC00A002B'i32 + STATUS_CTX_INVALID_WD* = NTSTATUS 0xC00A002E'i32 + STATUS_CTX_WD_NOT_FOUND* = NTSTATUS 0xC00A002F'i32 + STATUS_CTX_SHADOW_INVALID* = NTSTATUS 0xC00A0030'i32 + STATUS_CTX_SHADOW_DISABLED* = NTSTATUS 0xC00A0031'i32 + STATUS_RDP_PROTOCOL_ERROR* = NTSTATUS 0xC00A0032'i32 + STATUS_CTX_CLIENT_LICENSE_NOT_SET* = NTSTATUS 0xC00A0033'i32 + STATUS_CTX_CLIENT_LICENSE_IN_USE* = NTSTATUS 0xC00A0034'i32 + STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE* = NTSTATUS 0xC00A0035'i32 + STATUS_CTX_SHADOW_NOT_RUNNING* = NTSTATUS 0xC00A0036'i32 + STATUS_CTX_LOGON_DISABLED* = NTSTATUS 0xC00A0037'i32 + STATUS_CTX_SECURITY_LAYER_ERROR* = NTSTATUS 0xC00A0038'i32 + STATUS_TS_INCOMPATIBLE_SESSIONS* = NTSTATUS 0xC00A0039'i32 + STATUS_MUI_FILE_NOT_FOUND* = NTSTATUS 0xC00B0001'i32 + STATUS_MUI_INVALID_FILE* = NTSTATUS 0xC00B0002'i32 + STATUS_MUI_INVALID_RC_CONFIG* = NTSTATUS 0xC00B0003'i32 + STATUS_MUI_INVALID_LOCALE_NAME* = NTSTATUS 0xC00B0004'i32 + STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME* = NTSTATUS 0xC00B0005'i32 + STATUS_MUI_FILE_NOT_LOADED* = NTSTATUS 0xC00B0006'i32 + STATUS_RESOURCE_ENUM_USER_STOP* = NTSTATUS 0xC00B0007'i32 + STATUS_CLUSTER_INVALID_NODE* = NTSTATUS 0xC0130001'i32 + STATUS_CLUSTER_NODE_EXISTS* = NTSTATUS 0xC0130002'i32 + STATUS_CLUSTER_JOIN_IN_PROGRESS* = NTSTATUS 0xC0130003'i32 + STATUS_CLUSTER_NODE_NOT_FOUND* = NTSTATUS 0xC0130004'i32 + STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND* = NTSTATUS 0xC0130005'i32 + STATUS_CLUSTER_NETWORK_EXISTS* = NTSTATUS 0xC0130006'i32 + STATUS_CLUSTER_NETWORK_NOT_FOUND* = NTSTATUS 0xC0130007'i32 + STATUS_CLUSTER_NETINTERFACE_EXISTS* = NTSTATUS 0xC0130008'i32 + STATUS_CLUSTER_NETINTERFACE_NOT_FOUND* = NTSTATUS 0xC0130009'i32 + STATUS_CLUSTER_INVALID_REQUEST* = NTSTATUS 0xC013000A'i32 + STATUS_CLUSTER_INVALID_NETWORK_PROVIDER* = NTSTATUS 0xC013000B'i32 + STATUS_CLUSTER_NODE_DOWN* = NTSTATUS 0xC013000C'i32 + STATUS_CLUSTER_NODE_UNREACHABLE* = NTSTATUS 0xC013000D'i32 + STATUS_CLUSTER_NODE_NOT_MEMBER* = NTSTATUS 0xC013000E'i32 + STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS* = NTSTATUS 0xC013000F'i32 + STATUS_CLUSTER_INVALID_NETWORK* = NTSTATUS 0xC0130010'i32 + STATUS_CLUSTER_NO_NET_ADAPTERS* = NTSTATUS 0xC0130011'i32 + STATUS_CLUSTER_NODE_UP* = NTSTATUS 0xC0130012'i32 + STATUS_CLUSTER_NODE_PAUSED* = NTSTATUS 0xC0130013'i32 + STATUS_CLUSTER_NODE_NOT_PAUSED* = NTSTATUS 0xC0130014'i32 + STATUS_CLUSTER_NO_SECURITY_CONTEXT* = NTSTATUS 0xC0130015'i32 + STATUS_CLUSTER_NETWORK_NOT_INTERNAL* = NTSTATUS 0xC0130016'i32 + STATUS_CLUSTER_POISONED* = NTSTATUS 0xC0130017'i32 + STATUS_ACPI_INVALID_OPCODE* = NTSTATUS 0xC0140001'i32 + STATUS_ACPI_STACK_OVERFLOW* = NTSTATUS 0xC0140002'i32 + STATUS_ACPI_ASSERT_FAILED* = NTSTATUS 0xC0140003'i32 + STATUS_ACPI_INVALID_INDEX* = NTSTATUS 0xC0140004'i32 + STATUS_ACPI_INVALID_ARGUMENT* = NTSTATUS 0xC0140005'i32 + STATUS_ACPI_FATAL* = NTSTATUS 0xC0140006'i32 + STATUS_ACPI_INVALID_SUPERNAME* = NTSTATUS 0xC0140007'i32 + STATUS_ACPI_INVALID_ARGTYPE* = NTSTATUS 0xC0140008'i32 + STATUS_ACPI_INVALID_OBJTYPE* = NTSTATUS 0xC0140009'i32 + STATUS_ACPI_INVALID_TARGETTYPE* = NTSTATUS 0xC014000A'i32 + STATUS_ACPI_INCORRECT_ARGUMENT_COUNT* = NTSTATUS 0xC014000B'i32 + STATUS_ACPI_ADDRESS_NOT_MAPPED* = NTSTATUS 0xC014000C'i32 + STATUS_ACPI_INVALID_EVENTTYPE* = NTSTATUS 0xC014000D'i32 + STATUS_ACPI_HANDLER_COLLISION* = NTSTATUS 0xC014000E'i32 + STATUS_ACPI_INVALID_DATA* = NTSTATUS 0xC014000F'i32 + STATUS_ACPI_INVALID_REGION* = NTSTATUS 0xC0140010'i32 + STATUS_ACPI_INVALID_ACCESS_SIZE* = NTSTATUS 0xC0140011'i32 + STATUS_ACPI_ACQUIRE_GLOBAL_LOCK* = NTSTATUS 0xC0140012'i32 + STATUS_ACPI_ALREADY_INITIALIZED* = NTSTATUS 0xC0140013'i32 + STATUS_ACPI_NOT_INITIALIZED* = NTSTATUS 0xC0140014'i32 + STATUS_ACPI_INVALID_MUTEX_LEVEL* = NTSTATUS 0xC0140015'i32 + STATUS_ACPI_MUTEX_NOT_OWNED* = NTSTATUS 0xC0140016'i32 + STATUS_ACPI_MUTEX_NOT_OWNER* = NTSTATUS 0xC0140017'i32 + STATUS_ACPI_RS_ACCESS* = NTSTATUS 0xC0140018'i32 + STATUS_ACPI_INVALID_TABLE* = NTSTATUS 0xC0140019'i32 + STATUS_ACPI_REG_HANDLER_FAILED* = NTSTATUS 0xC0140020'i32 + STATUS_ACPI_POWER_REQUEST_FAILED* = NTSTATUS 0xC0140021'i32 + STATUS_SXS_SECTION_NOT_FOUND* = NTSTATUS 0xC0150001'i32 + STATUS_SXS_CANT_GEN_ACTCTX* = NTSTATUS 0xC0150002'i32 + STATUS_SXS_INVALID_ACTCTXDATA_FORMAT* = NTSTATUS 0xC0150003'i32 + STATUS_SXS_ASSEMBLY_NOT_FOUND* = NTSTATUS 0xC0150004'i32 + STATUS_SXS_MANIFEST_FORMAT_ERROR* = NTSTATUS 0xC0150005'i32 + STATUS_SXS_MANIFEST_PARSE_ERROR* = NTSTATUS 0xC0150006'i32 + STATUS_SXS_ACTIVATION_CONTEXT_DISABLED* = NTSTATUS 0xC0150007'i32 + STATUS_SXS_KEY_NOT_FOUND* = NTSTATUS 0xC0150008'i32 + STATUS_SXS_VERSION_CONFLICT* = NTSTATUS 0xC0150009'i32 + STATUS_SXS_WRONG_SECTION_TYPE* = NTSTATUS 0xC015000A'i32 + STATUS_SXS_THREAD_QUERIES_DISABLED* = NTSTATUS 0xC015000B'i32 + STATUS_SXS_ASSEMBLY_MISSING* = NTSTATUS 0xC015000C'i32 + STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET* = NTSTATUS 0xC015000E'i32 + STATUS_SXS_EARLY_DEACTIVATION* = NTSTATUS 0xC015000F'i32 + STATUS_SXS_INVALID_DEACTIVATION* = NTSTATUS 0xC0150010'i32 + STATUS_SXS_MULTIPLE_DEACTIVATION* = NTSTATUS 0xC0150011'i32 + STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY* = NTSTATUS 0xC0150012'i32 + STATUS_SXS_PROCESS_TERMINATION_REQUESTED* = NTSTATUS 0xC0150013'i32 + STATUS_SXS_CORRUPT_ACTIVATION_STACK* = NTSTATUS 0xC0150014'i32 + STATUS_SXS_CORRUPTION* = NTSTATUS 0xC0150015'i32 + STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE* = NTSTATUS 0xC0150016'i32 + STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME* = NTSTATUS 0xC0150017'i32 + STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE* = NTSTATUS 0xC0150018'i32 + STATUS_SXS_IDENTITY_PARSE_ERROR* = NTSTATUS 0xC0150019'i32 + STATUS_SXS_COMPONENT_STORE_CORRUPT* = NTSTATUS 0xC015001A'i32 + STATUS_SXS_FILE_HASH_MISMATCH* = NTSTATUS 0xC015001B'i32 + STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT* = NTSTATUS 0xC015001C'i32 + STATUS_SXS_IDENTITIES_DIFFERENT* = NTSTATUS 0xC015001D'i32 + STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT* = NTSTATUS 0xC015001E'i32 + STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY* = NTSTATUS 0xC015001F'i32 + STATUS_ADVANCED_INSTALLER_FAILED* = NTSTATUS 0xC0150020'i32 + STATUS_XML_ENCODING_MISMATCH* = NTSTATUS 0xC0150021'i32 + STATUS_SXS_MANIFEST_TOO_BIG* = NTSTATUS 0xC0150022'i32 + STATUS_SXS_SETTING_NOT_REGISTERED* = NTSTATUS 0xC0150023'i32 + STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE* = NTSTATUS 0xC0150024'i32 + STATUS_SMI_PRIMITIVE_INSTALLER_FAILED* = NTSTATUS 0xC0150025'i32 + STATUS_GENERIC_COMMAND_FAILED* = NTSTATUS 0xC0150026'i32 + STATUS_SXS_FILE_HASH_MISSING* = NTSTATUS 0xC0150027'i32 + STATUS_TRANSACTIONAL_CONFLICT* = NTSTATUS 0xC0190001'i32 + STATUS_INVALID_TRANSACTION* = NTSTATUS 0xC0190002'i32 + STATUS_TRANSACTION_NOT_ACTIVE* = NTSTATUS 0xC0190003'i32 + STATUS_TM_INITIALIZATION_FAILED* = NTSTATUS 0xC0190004'i32 + STATUS_RM_NOT_ACTIVE* = NTSTATUS 0xC0190005'i32 + STATUS_RM_METADATA_CORRUPT* = NTSTATUS 0xC0190006'i32 + STATUS_TRANSACTION_NOT_JOINED* = NTSTATUS 0xC0190007'i32 + STATUS_DIRECTORY_NOT_RM* = NTSTATUS 0xC0190008'i32 + STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE* = NTSTATUS 0xC019000A'i32 + STATUS_LOG_RESIZE_INVALID_SIZE* = NTSTATUS 0xC019000B'i32 + STATUS_REMOTE_FILE_VERSION_MISMATCH* = NTSTATUS 0xC019000C'i32 + STATUS_CRM_PROTOCOL_ALREADY_EXISTS* = NTSTATUS 0xC019000F'i32 + STATUS_TRANSACTION_PROPAGATION_FAILED* = NTSTATUS 0xC0190010'i32 + STATUS_CRM_PROTOCOL_NOT_FOUND* = NTSTATUS 0xC0190011'i32 + STATUS_TRANSACTION_SUPERIOR_EXISTS* = NTSTATUS 0xC0190012'i32 + STATUS_TRANSACTION_REQUEST_NOT_VALID* = NTSTATUS 0xC0190013'i32 + STATUS_TRANSACTION_NOT_REQUESTED* = NTSTATUS 0xC0190014'i32 + STATUS_TRANSACTION_ALREADY_ABORTED* = NTSTATUS 0xC0190015'i32 + STATUS_TRANSACTION_ALREADY_COMMITTED* = NTSTATUS 0xC0190016'i32 + STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER* = NTSTATUS 0xC0190017'i32 + STATUS_CURRENT_TRANSACTION_NOT_VALID* = NTSTATUS 0xC0190018'i32 + STATUS_LOG_GROWTH_FAILED* = NTSTATUS 0xC0190019'i32 + STATUS_OBJECT_NO_LONGER_EXISTS* = NTSTATUS 0xC0190021'i32 + STATUS_STREAM_MINIVERSION_NOT_FOUND* = NTSTATUS 0xC0190022'i32 + STATUS_STREAM_MINIVERSION_NOT_VALID* = NTSTATUS 0xC0190023'i32 + STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION* = NTSTATUS 0xC0190024'i32 + STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT* = NTSTATUS 0xC0190025'i32 + STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS* = NTSTATUS 0xC0190026'i32 + STATUS_HANDLE_NO_LONGER_VALID* = NTSTATUS 0xC0190028'i32 + STATUS_LOG_CORRUPTION_DETECTED* = NTSTATUS 0xC0190030'i32 + STATUS_RM_DISCONNECTED* = NTSTATUS 0xC0190032'i32 + STATUS_ENLISTMENT_NOT_SUPERIOR* = NTSTATUS 0xC0190033'i32 + STATUS_FILE_IDENTITY_NOT_PERSISTENT* = NTSTATUS 0xC0190036'i32 + STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY* = NTSTATUS 0xC0190037'i32 + STATUS_CANT_CROSS_RM_BOUNDARY* = NTSTATUS 0xC0190038'i32 + STATUS_TXF_DIR_NOT_EMPTY* = NTSTATUS 0xC0190039'i32 + STATUS_INDOUBT_TRANSACTIONS_EXIST* = NTSTATUS 0xC019003A'i32 + STATUS_TM_VOLATILE* = NTSTATUS 0xC019003B'i32 + STATUS_ROLLBACK_TIMER_EXPIRED* = NTSTATUS 0xC019003C'i32 + STATUS_TXF_ATTRIBUTE_CORRUPT* = NTSTATUS 0xC019003D'i32 + STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION* = NTSTATUS 0xC019003E'i32 + STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED* = NTSTATUS 0xC019003F'i32 + STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE* = NTSTATUS 0xC0190040'i32 + STATUS_TRANSACTION_REQUIRED_PROMOTION* = NTSTATUS 0xC0190043'i32 + STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION* = NTSTATUS 0xC0190044'i32 + STATUS_TRANSACTIONS_NOT_FROZEN* = NTSTATUS 0xC0190045'i32 + STATUS_TRANSACTION_FREEZE_IN_PROGRESS* = NTSTATUS 0xC0190046'i32 + STATUS_NOT_SNAPSHOT_VOLUME* = NTSTATUS 0xC0190047'i32 + STATUS_NO_SAVEPOINT_WITH_OPEN_FILES* = NTSTATUS 0xC0190048'i32 + STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION* = NTSTATUS 0xC0190049'i32 + STATUS_TM_IDENTITY_MISMATCH* = NTSTATUS 0xC019004A'i32 + STATUS_FLOATED_SECTION* = NTSTATUS 0xC019004B'i32 + STATUS_CANNOT_ACCEPT_TRANSACTED_WORK* = NTSTATUS 0xC019004C'i32 + STATUS_CANNOT_ABORT_TRANSACTIONS* = NTSTATUS 0xC019004D'i32 + STATUS_TRANSACTION_NOT_FOUND* = NTSTATUS 0xC019004E'i32 + STATUS_RESOURCEMANAGER_NOT_FOUND* = NTSTATUS 0xC019004F'i32 + STATUS_ENLISTMENT_NOT_FOUND* = NTSTATUS 0xC0190050'i32 + STATUS_TRANSACTIONMANAGER_NOT_FOUND* = NTSTATUS 0xC0190051'i32 + STATUS_TRANSACTIONMANAGER_NOT_ONLINE* = NTSTATUS 0xC0190052'i32 + STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION* = NTSTATUS 0xC0190053'i32 + STATUS_TRANSACTION_NOT_ROOT* = NTSTATUS 0xC0190054'i32 + STATUS_TRANSACTION_OBJECT_EXPIRED* = NTSTATUS 0xC0190055'i32 + STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION* = NTSTATUS 0xC0190056'i32 + STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED* = NTSTATUS 0xC0190057'i32 + STATUS_TRANSACTION_RECORD_TOO_LONG* = NTSTATUS 0xC0190058'i32 + STATUS_NO_LINK_TRACKING_IN_TRANSACTION* = NTSTATUS 0xC0190059'i32 + STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION* = NTSTATUS 0xC019005A'i32 + STATUS_TRANSACTION_INTEGRITY_VIOLATED* = NTSTATUS 0xC019005B'i32 + STATUS_EXPIRED_HANDLE* = NTSTATUS 0xC0190060'i32 + STATUS_TRANSACTION_NOT_ENLISTED* = NTSTATUS 0xC0190061'i32 + STATUS_LOG_SECTOR_INVALID* = NTSTATUS 0xC01A0001'i32 + STATUS_LOG_SECTOR_PARITY_INVALID* = NTSTATUS 0xC01A0002'i32 + STATUS_LOG_SECTOR_REMAPPED* = NTSTATUS 0xC01A0003'i32 + STATUS_LOG_BLOCK_INCOMPLETE* = NTSTATUS 0xC01A0004'i32 + STATUS_LOG_INVALID_RANGE* = NTSTATUS 0xC01A0005'i32 + STATUS_LOG_BLOCKS_EXHAUSTED* = NTSTATUS 0xC01A0006'i32 + STATUS_LOG_READ_CONTEXT_INVALID* = NTSTATUS 0xC01A0007'i32 + STATUS_LOG_RESTART_INVALID* = NTSTATUS 0xC01A0008'i32 + STATUS_LOG_BLOCK_VERSION* = NTSTATUS 0xC01A0009'i32 + STATUS_LOG_BLOCK_INVALID* = NTSTATUS 0xC01A000A'i32 + STATUS_LOG_READ_MODE_INVALID* = NTSTATUS 0xC01A000B'i32 + STATUS_LOG_METADATA_CORRUPT* = NTSTATUS 0xC01A000D'i32 + STATUS_LOG_METADATA_INVALID* = NTSTATUS 0xC01A000E'i32 + STATUS_LOG_METADATA_INCONSISTENT* = NTSTATUS 0xC01A000F'i32 + STATUS_LOG_RESERVATION_INVALID* = NTSTATUS 0xC01A0010'i32 + STATUS_LOG_CANT_DELETE* = NTSTATUS 0xC01A0011'i32 + STATUS_LOG_CONTAINER_LIMIT_EXCEEDED* = NTSTATUS 0xC01A0012'i32 + STATUS_LOG_START_OF_LOG* = NTSTATUS 0xC01A0013'i32 + STATUS_LOG_POLICY_ALREADY_INSTALLED* = NTSTATUS 0xC01A0014'i32 + STATUS_LOG_POLICY_NOT_INSTALLED* = NTSTATUS 0xC01A0015'i32 + STATUS_LOG_POLICY_INVALID* = NTSTATUS 0xC01A0016'i32 + STATUS_LOG_POLICY_CONFLICT* = NTSTATUS 0xC01A0017'i32 + STATUS_LOG_PINNED_ARCHIVE_TAIL* = NTSTATUS 0xC01A0018'i32 + STATUS_LOG_RECORD_NONEXISTENT* = NTSTATUS 0xC01A0019'i32 + STATUS_LOG_RECORDS_RESERVED_INVALID* = NTSTATUS 0xC01A001A'i32 + STATUS_LOG_SPACE_RESERVED_INVALID* = NTSTATUS 0xC01A001B'i32 + STATUS_LOG_TAIL_INVALID* = NTSTATUS 0xC01A001C'i32 + STATUS_LOG_FULL* = NTSTATUS 0xC01A001D'i32 + STATUS_LOG_MULTIPLEXED* = NTSTATUS 0xC01A001E'i32 + STATUS_LOG_DEDICATED* = NTSTATUS 0xC01A001F'i32 + STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS* = NTSTATUS 0xC01A0020'i32 + STATUS_LOG_ARCHIVE_IN_PROGRESS* = NTSTATUS 0xC01A0021'i32 + STATUS_LOG_EPHEMERAL* = NTSTATUS 0xC01A0022'i32 + STATUS_LOG_NOT_ENOUGH_CONTAINERS* = NTSTATUS 0xC01A0023'i32 + STATUS_LOG_CLIENT_ALREADY_REGISTERED* = NTSTATUS 0xC01A0024'i32 + STATUS_LOG_CLIENT_NOT_REGISTERED* = NTSTATUS 0xC01A0025'i32 + STATUS_LOG_FULL_HANDLER_IN_PROGRESS* = NTSTATUS 0xC01A0026'i32 + STATUS_LOG_CONTAINER_READ_FAILED* = NTSTATUS 0xC01A0027'i32 + STATUS_LOG_CONTAINER_WRITE_FAILED* = NTSTATUS 0xC01A0028'i32 + STATUS_LOG_CONTAINER_OPEN_FAILED* = NTSTATUS 0xC01A0029'i32 + STATUS_LOG_CONTAINER_STATE_INVALID* = NTSTATUS 0xC01A002A'i32 + STATUS_LOG_STATE_INVALID* = NTSTATUS 0xC01A002B'i32 + STATUS_LOG_PINNED* = NTSTATUS 0xC01A002C'i32 + STATUS_LOG_METADATA_FLUSH_FAILED* = NTSTATUS 0xC01A002D'i32 + STATUS_LOG_INCONSISTENT_SECURITY* = NTSTATUS 0xC01A002E'i32 + STATUS_LOG_APPENDED_FLUSH_FAILED* = NTSTATUS 0xC01A002F'i32 + STATUS_LOG_PINNED_RESERVATION* = NTSTATUS 0xC01A0030'i32 + STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD* = NTSTATUS 0xC01B00EA'i32 + STATUS_FLT_NO_HANDLER_DEFINED* = NTSTATUS 0xC01C0001'i32 + STATUS_FLT_CONTEXT_ALREADY_DEFINED* = NTSTATUS 0xC01C0002'i32 + STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST* = NTSTATUS 0xC01C0003'i32 + STATUS_FLT_DISALLOW_FAST_IO* = NTSTATUS 0xC01C0004'i32 + STATUS_FLT_INVALID_NAME_REQUEST* = NTSTATUS 0xC01C0005'i32 + STATUS_FLT_NOT_SAFE_TO_POST_OPERATION* = NTSTATUS 0xC01C0006'i32 + STATUS_FLT_NOT_INITIALIZED* = NTSTATUS 0xC01C0007'i32 + STATUS_FLT_FILTER_NOT_READY* = NTSTATUS 0xC01C0008'i32 + STATUS_FLT_POST_OPERATION_CLEANUP* = NTSTATUS 0xC01C0009'i32 + STATUS_FLT_INTERNAL_ERROR* = NTSTATUS 0xC01C000A'i32 + STATUS_FLT_DELETING_OBJECT* = NTSTATUS 0xC01C000B'i32 + STATUS_FLT_MUST_BE_NONPAGED_POOL* = NTSTATUS 0xC01C000C'i32 + STATUS_FLT_DUPLICATE_ENTRY* = NTSTATUS 0xC01C000D'i32 + STATUS_FLT_CBDQ_DISABLED* = NTSTATUS 0xC01C000E'i32 + STATUS_FLT_DO_NOT_ATTACH* = NTSTATUS 0xC01C000F'i32 + STATUS_FLT_DO_NOT_DETACH* = NTSTATUS 0xC01C0010'i32 + STATUS_FLT_INSTANCE_ALTITUDE_COLLISION* = NTSTATUS 0xC01C0011'i32 + STATUS_FLT_INSTANCE_NAME_COLLISION* = NTSTATUS 0xC01C0012'i32 + STATUS_FLT_FILTER_NOT_FOUND* = NTSTATUS 0xC01C0013'i32 + STATUS_FLT_VOLUME_NOT_FOUND* = NTSTATUS 0xC01C0014'i32 + STATUS_FLT_INSTANCE_NOT_FOUND* = NTSTATUS 0xC01C0015'i32 + STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND* = NTSTATUS 0xC01C0016'i32 + STATUS_FLT_INVALID_CONTEXT_REGISTRATION* = NTSTATUS 0xC01C0017'i32 + STATUS_FLT_NAME_CACHE_MISS* = NTSTATUS 0xC01C0018'i32 + STATUS_FLT_NO_DEVICE_OBJECT* = NTSTATUS 0xC01C0019'i32 + STATUS_FLT_VOLUME_ALREADY_MOUNTED* = NTSTATUS 0xC01C001A'i32 + STATUS_FLT_ALREADY_ENLISTED* = NTSTATUS 0xC01C001B'i32 + STATUS_FLT_CONTEXT_ALREADY_LINKED* = NTSTATUS 0xC01C001C'i32 + STATUS_FLT_NO_WAITER_FOR_REPLY* = NTSTATUS 0xC01C0020'i32 + STATUS_MONITOR_NO_DESCRIPTOR* = NTSTATUS 0xC01D0001'i32 + STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT* = NTSTATUS 0xC01D0002'i32 + STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM* = NTSTATUS 0xC01D0003'i32 + STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK* = NTSTATUS 0xC01D0004'i32 + STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED* = NTSTATUS 0xC01D0005'i32 + STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK* = NTSTATUS 0xC01D0006'i32 + STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK* = NTSTATUS 0xC01D0007'i32 + STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA* = NTSTATUS 0xC01D0008'i32 + STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK* = NTSTATUS 0xC01D0009'i32 + STATUS_MONITOR_INVALID_MANUFACTURE_DATE* = NTSTATUS 0xC01D000A'i32 + STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER* = NTSTATUS 0xC01E0000'i32 + STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER* = NTSTATUS 0xC01E0001'i32 + STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER* = NTSTATUS 0xC01E0002'i32 + STATUS_GRAPHICS_ADAPTER_WAS_RESET* = NTSTATUS 0xC01E0003'i32 + STATUS_GRAPHICS_INVALID_DRIVER_MODEL* = NTSTATUS 0xC01E0004'i32 + STATUS_GRAPHICS_PRESENT_MODE_CHANGED* = NTSTATUS 0xC01E0005'i32 + STATUS_GRAPHICS_PRESENT_OCCLUDED* = NTSTATUS 0xC01E0006'i32 + STATUS_GRAPHICS_PRESENT_DENIED* = NTSTATUS 0xC01E0007'i32 + STATUS_GRAPHICS_CANNOTCOLORCONVERT* = NTSTATUS 0xC01E0008'i32 + STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED* = NTSTATUS 0xC01E000B'i32 + STATUS_GRAPHICS_PRESENT_UNOCCLUDED* = NTSTATUS 0xC01E000C'i32 + STATUS_GRAPHICS_NO_VIDEO_MEMORY* = NTSTATUS 0xC01E0100'i32 + STATUS_GRAPHICS_CANT_LOCK_MEMORY* = NTSTATUS 0xC01E0101'i32 + STATUS_GRAPHICS_ALLOCATION_BUSY* = NTSTATUS 0xC01E0102'i32 + STATUS_GRAPHICS_TOO_MANY_REFERENCES* = NTSTATUS 0xC01E0103'i32 + STATUS_GRAPHICS_TRY_AGAIN_LATER* = NTSTATUS 0xC01E0104'i32 + STATUS_GRAPHICS_TRY_AGAIN_NOW* = NTSTATUS 0xC01E0105'i32 + STATUS_GRAPHICS_ALLOCATION_INVALID* = NTSTATUS 0xC01E0106'i32 + STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE* = NTSTATUS 0xC01E0107'i32 + STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED* = NTSTATUS 0xC01E0108'i32 + STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION* = NTSTATUS 0xC01E0109'i32 + STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE* = NTSTATUS 0xC01E0110'i32 + STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION* = NTSTATUS 0xC01E0111'i32 + STATUS_GRAPHICS_ALLOCATION_CLOSED* = NTSTATUS 0xC01E0112'i32 + STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE* = NTSTATUS 0xC01E0113'i32 + STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE* = NTSTATUS 0xC01E0114'i32 + STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE* = NTSTATUS 0xC01E0115'i32 + STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST* = NTSTATUS 0xC01E0116'i32 + STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE* = NTSTATUS 0xC01E0200'i32 + STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY* = NTSTATUS 0xC01E0300'i32 + STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED* = NTSTATUS 0xC01E0301'i32 + STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED* = NTSTATUS 0xC01E0302'i32 + STATUS_GRAPHICS_INVALID_VIDPN* = NTSTATUS 0xC01E0303'i32 + STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE* = NTSTATUS 0xC01E0304'i32 + STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET* = NTSTATUS 0xC01E0305'i32 + STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED* = NTSTATUS 0xC01E0306'i32 + STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET* = NTSTATUS 0xC01E0308'i32 + STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET* = NTSTATUS 0xC01E0309'i32 + STATUS_GRAPHICS_INVALID_FREQUENCY* = NTSTATUS 0xC01E030A'i32 + STATUS_GRAPHICS_INVALID_ACTIVE_REGION* = NTSTATUS 0xC01E030B'i32 + STATUS_GRAPHICS_INVALID_TOTAL_REGION* = NTSTATUS 0xC01E030C'i32 + STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE* = NTSTATUS 0xC01E0310'i32 + STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE* = NTSTATUS 0xC01E0311'i32 + STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET* = NTSTATUS 0xC01E0312'i32 + STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY* = NTSTATUS 0xC01E0313'i32 + STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET* = NTSTATUS 0xC01E0314'i32 + STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET* = NTSTATUS 0xC01E0315'i32 + STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET* = NTSTATUS 0xC01E0316'i32 + STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET* = NTSTATUS 0xC01E0317'i32 + STATUS_GRAPHICS_TARGET_ALREADY_IN_SET* = NTSTATUS 0xC01E0318'i32 + STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH* = NTSTATUS 0xC01E0319'i32 + STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY* = NTSTATUS 0xC01E031A'i32 + STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET* = NTSTATUS 0xC01E031B'i32 + STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE* = NTSTATUS 0xC01E031C'i32 + STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET* = NTSTATUS 0xC01E031D'i32 + STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET* = NTSTATUS 0xC01E031F'i32 + STATUS_GRAPHICS_STALE_MODESET* = NTSTATUS 0xC01E0320'i32 + STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET* = NTSTATUS 0xC01E0321'i32 + STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE* = NTSTATUS 0xC01E0322'i32 + STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN* = NTSTATUS 0xC01E0323'i32 + STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE* = NTSTATUS 0xC01E0324'i32 + STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION* = NTSTATUS 0xC01E0325'i32 + STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES* = NTSTATUS 0xC01E0326'i32 + STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY* = NTSTATUS 0xC01E0327'i32 + STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE* = NTSTATUS 0xC01E0328'i32 + STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET* = NTSTATUS 0xC01E0329'i32 + STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET* = NTSTATUS 0xC01E032A'i32 + STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR* = NTSTATUS 0xC01E032B'i32 + STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET* = NTSTATUS 0xC01E032C'i32 + STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET* = NTSTATUS 0xC01E032D'i32 + STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE* = NTSTATUS 0xC01E032E'i32 + STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE* = NTSTATUS 0xC01E032F'i32 + STATUS_GRAPHICS_RESOURCES_NOT_RELATED* = NTSTATUS 0xC01E0330'i32 + STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE* = NTSTATUS 0xC01E0331'i32 + STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE* = NTSTATUS 0xC01E0332'i32 + STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET* = NTSTATUS 0xC01E0333'i32 + STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER* = NTSTATUS 0xC01E0334'i32 + STATUS_GRAPHICS_NO_VIDPNMGR* = NTSTATUS 0xC01E0335'i32 + STATUS_GRAPHICS_NO_ACTIVE_VIDPN* = NTSTATUS 0xC01E0336'i32 + STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY* = NTSTATUS 0xC01E0337'i32 + STATUS_GRAPHICS_MONITOR_NOT_CONNECTED* = NTSTATUS 0xC01E0338'i32 + STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY* = NTSTATUS 0xC01E0339'i32 + STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE* = NTSTATUS 0xC01E033A'i32 + STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE* = NTSTATUS 0xC01E033B'i32 + STATUS_GRAPHICS_INVALID_STRIDE* = NTSTATUS 0xC01E033C'i32 + STATUS_GRAPHICS_INVALID_PIXELFORMAT* = NTSTATUS 0xC01E033D'i32 + STATUS_GRAPHICS_INVALID_COLORBASIS* = NTSTATUS 0xC01E033E'i32 + STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE* = NTSTATUS 0xC01E033F'i32 + STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY* = NTSTATUS 0xC01E0340'i32 + STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT* = NTSTATUS 0xC01E0341'i32 + STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE* = NTSTATUS 0xC01E0342'i32 + STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN* = NTSTATUS 0xC01E0343'i32 + STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL* = NTSTATUS 0xC01E0344'i32 + STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION* = NTSTATUS 0xC01E0345'i32 + STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED* = NTSTATUS 0xC01E0346'i32 + STATUS_GRAPHICS_INVALID_GAMMA_RAMP* = NTSTATUS 0xC01E0347'i32 + STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED* = NTSTATUS 0xC01E0348'i32 + STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED* = NTSTATUS 0xC01E0349'i32 + STATUS_GRAPHICS_MODE_NOT_IN_MODESET* = NTSTATUS 0xC01E034A'i32 + STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON* = NTSTATUS 0xC01E034D'i32 + STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE* = NTSTATUS 0xC01E034E'i32 + STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE* = NTSTATUS 0xC01E034F'i32 + STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS* = NTSTATUS 0xC01E0350'i32 + STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING* = NTSTATUS 0xC01E0352'i32 + STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED* = NTSTATUS 0xC01E0353'i32 + STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS* = NTSTATUS 0xC01E0354'i32 + STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT* = NTSTATUS 0xC01E0355'i32 + STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM* = NTSTATUS 0xC01E0356'i32 + STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN* = NTSTATUS 0xC01E0357'i32 + STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT* = NTSTATUS 0xC01E0358'i32 + STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED* = NTSTATUS 0xC01E0359'i32 + STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION* = NTSTATUS 0xC01E035A'i32 + STATUS_GRAPHICS_INVALID_CLIENT_TYPE* = NTSTATUS 0xC01E035B'i32 + STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET* = NTSTATUS 0xC01E035C'i32 + STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED* = NTSTATUS 0xC01E0400'i32 + STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED* = NTSTATUS 0xC01E0401'i32 + STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER* = NTSTATUS 0xC01E0430'i32 + STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED* = NTSTATUS 0xC01E0431'i32 + STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED* = NTSTATUS 0xC01E0432'i32 + STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY* = NTSTATUS 0xC01E0433'i32 + STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED* = NTSTATUS 0xC01E0434'i32 + STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON* = NTSTATUS 0xC01E0435'i32 + STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE* = NTSTATUS 0xC01E0436'i32 + STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER* = NTSTATUS 0xC01E0438'i32 + STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED* = NTSTATUS 0xC01E043B'i32 + STATUS_GRAPHICS_OPM_NOT_SUPPORTED* = NTSTATUS 0xC01E0500'i32 + STATUS_GRAPHICS_COPP_NOT_SUPPORTED* = NTSTATUS 0xC01E0501'i32 + STATUS_GRAPHICS_UAB_NOT_SUPPORTED* = NTSTATUS 0xC01E0502'i32 + STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS* = NTSTATUS 0xC01E0503'i32 + STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL* = NTSTATUS 0xC01E0504'i32 + STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST* = NTSTATUS 0xC01E0505'i32 + STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME* = NTSTATUS 0xC01E0506'i32 + STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP* = NTSTATUS 0xC01E0507'i32 + STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED* = NTSTATUS 0xC01E0508'i32 + STATUS_GRAPHICS_OPM_INVALID_POINTER* = NTSTATUS 0xC01E050A'i32 + STATUS_GRAPHICS_OPM_INTERNAL_ERROR* = NTSTATUS 0xC01E050B'i32 + STATUS_GRAPHICS_OPM_INVALID_HANDLE* = NTSTATUS 0xC01E050C'i32 + STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE* = NTSTATUS 0xC01E050D'i32 + STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH* = NTSTATUS 0xC01E050E'i32 + STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED* = NTSTATUS 0xC01E050F'i32 + STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED* = NTSTATUS 0xC01E0510'i32 + STATUS_GRAPHICS_PVP_HFS_FAILED* = NTSTATUS 0xC01E0511'i32 + STATUS_GRAPHICS_OPM_INVALID_SRM* = NTSTATUS 0xC01E0512'i32 + STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP* = NTSTATUS 0xC01E0513'i32 + STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP* = NTSTATUS 0xC01E0514'i32 + STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA* = NTSTATUS 0xC01E0515'i32 + STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET* = NTSTATUS 0xC01E0516'i32 + STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH* = NTSTATUS 0xC01E0517'i32 + STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE* = NTSTATUS 0xC01E0518'i32 + STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS* = NTSTATUS 0xC01E051A'i32 + STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS* = NTSTATUS 0xC01E051B'i32 + STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS* = NTSTATUS 0xC01E051C'i32 + STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST* = NTSTATUS 0xC01E051D'i32 + STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR* = NTSTATUS 0xC01E051E'i32 + STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS* = NTSTATUS 0xC01E051F'i32 + STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED* = NTSTATUS 0xC01E0520'i32 + STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST* = NTSTATUS 0xC01E0521'i32 + STATUS_GRAPHICS_I2C_NOT_SUPPORTED* = NTSTATUS 0xC01E0580'i32 + STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST* = NTSTATUS 0xC01E0581'i32 + STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA* = NTSTATUS 0xC01E0582'i32 + STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA* = NTSTATUS 0xC01E0583'i32 + STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED* = NTSTATUS 0xC01E0584'i32 + STATUS_GRAPHICS_DDCCI_INVALID_DATA* = NTSTATUS 0xC01E0585'i32 + STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE* = NTSTATUS 0xC01E0586'i32 + STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING* = NTSTATUS 0xC01E0587'i32 + STATUS_GRAPHICS_MCA_INTERNAL_ERROR* = NTSTATUS 0xC01E0588'i32 + STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND* = NTSTATUS 0xC01E0589'i32 + STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH* = NTSTATUS 0xC01E058A'i32 + STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM* = NTSTATUS 0xC01E058B'i32 + STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE* = NTSTATUS 0xC01E058C'i32 + STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS* = NTSTATUS 0xC01E058D'i32 + STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED* = NTSTATUS 0xC01E05E0'i32 + STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME* = NTSTATUS 0xC01E05E1'i32 + STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP* = NTSTATUS 0xC01E05E2'i32 + STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED* = NTSTATUS 0xC01E05E3'i32 + STATUS_GRAPHICS_INVALID_POINTER* = NTSTATUS 0xC01E05E4'i32 + STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE* = NTSTATUS 0xC01E05E5'i32 + STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL* = NTSTATUS 0xC01E05E6'i32 + STATUS_GRAPHICS_INTERNAL_ERROR* = NTSTATUS 0xC01E05E7'i32 + STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS* = NTSTATUS 0xC01E05E8'i32 + STATUS_FVE_LOCKED_VOLUME* = NTSTATUS 0xC0210000'i32 + STATUS_FVE_NOT_ENCRYPTED* = NTSTATUS 0xC0210001'i32 + STATUS_FVE_BAD_INFORMATION* = NTSTATUS 0xC0210002'i32 + STATUS_FVE_TOO_SMALL* = NTSTATUS 0xC0210003'i32 + STATUS_FVE_FAILED_WRONG_FS* = NTSTATUS 0xC0210004'i32 + STATUS_FVE_FAILED_BAD_FS* = NTSTATUS 0xC0210005'i32 + STATUS_FVE_FS_NOT_EXTENDED* = NTSTATUS 0xC0210006'i32 + STATUS_FVE_FS_MOUNTED* = NTSTATUS 0xC0210007'i32 + STATUS_FVE_NO_LICENSE* = NTSTATUS 0xC0210008'i32 + STATUS_FVE_ACTION_NOT_ALLOWED* = NTSTATUS 0xC0210009'i32 + STATUS_FVE_BAD_DATA* = NTSTATUS 0xC021000A'i32 + STATUS_FVE_VOLUME_NOT_BOUND* = NTSTATUS 0xC021000B'i32 + STATUS_FVE_NOT_DATA_VOLUME* = NTSTATUS 0xC021000C'i32 + STATUS_FVE_CONV_READ_ERROR* = NTSTATUS 0xC021000D'i32 + STATUS_FVE_CONV_WRITE_ERROR* = NTSTATUS 0xC021000E'i32 + STATUS_FVE_OVERLAPPED_UPDATE* = NTSTATUS 0xC021000F'i32 + STATUS_FVE_FAILED_SECTOR_SIZE* = NTSTATUS 0xC0210010'i32 + STATUS_FVE_FAILED_AUTHENTICATION* = NTSTATUS 0xC0210011'i32 + STATUS_FVE_NOT_OS_VOLUME* = NTSTATUS 0xC0210012'i32 + STATUS_FVE_KEYFILE_NOT_FOUND* = NTSTATUS 0xC0210013'i32 + STATUS_FVE_KEYFILE_INVALID* = NTSTATUS 0xC0210014'i32 + STATUS_FVE_KEYFILE_NO_VMK* = NTSTATUS 0xC0210015'i32 + STATUS_FVE_TPM_DISABLED* = NTSTATUS 0xC0210016'i32 + STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO* = NTSTATUS 0xC0210017'i32 + STATUS_FVE_TPM_INVALID_PCR* = NTSTATUS 0xC0210018'i32 + STATUS_FVE_TPM_NO_VMK* = NTSTATUS 0xC0210019'i32 + STATUS_FVE_PIN_INVALID* = NTSTATUS 0xC021001A'i32 + STATUS_FVE_AUTH_INVALID_APPLICATION* = NTSTATUS 0xC021001B'i32 + STATUS_FVE_AUTH_INVALID_CONFIG* = NTSTATUS 0xC021001C'i32 + STATUS_FVE_DEBUGGER_ENABLED* = NTSTATUS 0xC021001D'i32 + STATUS_FVE_DRY_RUN_FAILED* = NTSTATUS 0xC021001E'i32 + STATUS_FVE_BAD_METADATA_POINTER* = NTSTATUS 0xC021001F'i32 + STATUS_FVE_OLD_METADATA_COPY* = NTSTATUS 0xC0210020'i32 + STATUS_FVE_REBOOT_REQUIRED* = NTSTATUS 0xC0210021'i32 + STATUS_FVE_RAW_ACCESS* = NTSTATUS 0xC0210022'i32 + STATUS_FVE_RAW_BLOCKED* = NTSTATUS 0xC0210023'i32 + STATUS_FVE_NO_FEATURE_LICENSE* = NTSTATUS 0xC0210026'i32 + STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED* = NTSTATUS 0xC0210027'i32 + STATUS_FVE_CONV_RECOVERY_FAILED* = NTSTATUS 0xC0210028'i32 + STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG* = NTSTATUS 0xC0210029'i32 + STATUS_FVE_VOLUME_TOO_SMALL* = NTSTATUS 0xC0210030'i32 + STATUS_FWP_CALLOUT_NOT_FOUND* = NTSTATUS 0xC0220001'i32 + STATUS_FWP_CONDITION_NOT_FOUND* = NTSTATUS 0xC0220002'i32 + STATUS_FWP_FILTER_NOT_FOUND* = NTSTATUS 0xC0220003'i32 + STATUS_FWP_LAYER_NOT_FOUND* = NTSTATUS 0xC0220004'i32 + STATUS_FWP_PROVIDER_NOT_FOUND* = NTSTATUS 0xC0220005'i32 + STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND* = NTSTATUS 0xC0220006'i32 + STATUS_FWP_SUBLAYER_NOT_FOUND* = NTSTATUS 0xC0220007'i32 + STATUS_FWP_NOT_FOUND* = NTSTATUS 0xC0220008'i32 + STATUS_FWP_ALREADY_EXISTS* = NTSTATUS 0xC0220009'i32 + STATUS_FWP_IN_USE* = NTSTATUS 0xC022000A'i32 + STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS* = NTSTATUS 0xC022000B'i32 + STATUS_FWP_WRONG_SESSION* = NTSTATUS 0xC022000C'i32 + STATUS_FWP_NO_TXN_IN_PROGRESS* = NTSTATUS 0xC022000D'i32 + STATUS_FWP_TXN_IN_PROGRESS* = NTSTATUS 0xC022000E'i32 + STATUS_FWP_TXN_ABORTED* = NTSTATUS 0xC022000F'i32 + STATUS_FWP_SESSION_ABORTED* = NTSTATUS 0xC0220010'i32 + STATUS_FWP_INCOMPATIBLE_TXN* = NTSTATUS 0xC0220011'i32 + STATUS_FWP_TIMEOUT* = NTSTATUS 0xC0220012'i32 + STATUS_FWP_NET_EVENTS_DISABLED* = NTSTATUS 0xC0220013'i32 + STATUS_FWP_INCOMPATIBLE_LAYER* = NTSTATUS 0xC0220014'i32 + STATUS_FWP_KM_CLIENTS_ONLY* = NTSTATUS 0xC0220015'i32 + STATUS_FWP_LIFETIME_MISMATCH* = NTSTATUS 0xC0220016'i32 + STATUS_FWP_BUILTIN_OBJECT* = NTSTATUS 0xC0220017'i32 + STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS* = NTSTATUS 0xC0220018'i32 + STATUS_FWP_TOO_MANY_CALLOUTS* = NTSTATUS 0xC0220018'i32 + STATUS_FWP_NOTIFICATION_DROPPED* = NTSTATUS 0xC0220019'i32 + STATUS_FWP_TRAFFIC_MISMATCH* = NTSTATUS 0xC022001A'i32 + STATUS_FWP_INCOMPATIBLE_SA_STATE* = NTSTATUS 0xC022001B'i32 + STATUS_FWP_NULL_POINTER* = NTSTATUS 0xC022001C'i32 + STATUS_FWP_INVALID_ENUMERATOR* = NTSTATUS 0xC022001D'i32 + STATUS_FWP_INVALID_FLAGS* = NTSTATUS 0xC022001E'i32 + STATUS_FWP_INVALID_NET_MASK* = NTSTATUS 0xC022001F'i32 + STATUS_FWP_INVALID_RANGE* = NTSTATUS 0xC0220020'i32 + STATUS_FWP_INVALID_INTERVAL* = NTSTATUS 0xC0220021'i32 + STATUS_FWP_ZERO_LENGTH_ARRAY* = NTSTATUS 0xC0220022'i32 + STATUS_FWP_NULL_DISPLAY_NAME* = NTSTATUS 0xC0220023'i32 + STATUS_FWP_INVALID_ACTION_TYPE* = NTSTATUS 0xC0220024'i32 + STATUS_FWP_INVALID_WEIGHT* = NTSTATUS 0xC0220025'i32 + STATUS_FWP_MATCH_TYPE_MISMATCH* = NTSTATUS 0xC0220026'i32 + STATUS_FWP_TYPE_MISMATCH* = NTSTATUS 0xC0220027'i32 + STATUS_FWP_OUT_OF_BOUNDS* = NTSTATUS 0xC0220028'i32 + STATUS_FWP_RESERVED* = NTSTATUS 0xC0220029'i32 + STATUS_FWP_DUPLICATE_CONDITION* = NTSTATUS 0xC022002A'i32 + STATUS_FWP_DUPLICATE_KEYMOD* = NTSTATUS 0xC022002B'i32 + STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER* = NTSTATUS 0xC022002C'i32 + STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER* = NTSTATUS 0xC022002D'i32 + STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER* = NTSTATUS 0xC022002E'i32 + STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT* = NTSTATUS 0xC022002F'i32 + STATUS_FWP_INCOMPATIBLE_AUTH_METHOD* = NTSTATUS 0xC0220030'i32 + STATUS_FWP_INCOMPATIBLE_DH_GROUP* = NTSTATUS 0xC0220031'i32 + STATUS_FWP_EM_NOT_SUPPORTED* = NTSTATUS 0xC0220032'i32 + STATUS_FWP_NEVER_MATCH* = NTSTATUS 0xC0220033'i32 + STATUS_FWP_PROVIDER_CONTEXT_MISMATCH* = NTSTATUS 0xC0220034'i32 + STATUS_FWP_INVALID_PARAMETER* = NTSTATUS 0xC0220035'i32 + STATUS_FWP_TOO_MANY_SUBLAYERS* = NTSTATUS 0xC0220036'i32 + STATUS_FWP_CALLOUT_NOTIFICATION_FAILED* = NTSTATUS 0xC0220037'i32 + STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG* = NTSTATUS 0xC0220038'i32 + STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG* = NTSTATUS 0xC0220039'i32 + STATUS_FWP_DUPLICATE_AUTH_METHOD* = NTSTATUS 0xC022003C'i32 + STATUS_FWP_TCPIP_NOT_READY* = NTSTATUS 0xC0220100'i32 + STATUS_FWP_INJECT_HANDLE_CLOSING* = NTSTATUS 0xC0220101'i32 + STATUS_FWP_INJECT_HANDLE_STALE* = NTSTATUS 0xC0220102'i32 + STATUS_FWP_CANNOT_PEND* = NTSTATUS 0xC0220103'i32 + STATUS_NDIS_CLOSING* = NTSTATUS 0xC0230002'i32 + STATUS_NDIS_BAD_VERSION* = NTSTATUS 0xC0230004'i32 + STATUS_NDIS_BAD_CHARACTERISTICS* = NTSTATUS 0xC0230005'i32 + STATUS_NDIS_ADAPTER_NOT_FOUND* = NTSTATUS 0xC0230006'i32 + STATUS_NDIS_OPEN_FAILED* = NTSTATUS 0xC0230007'i32 + STATUS_NDIS_DEVICE_FAILED* = NTSTATUS 0xC0230008'i32 + STATUS_NDIS_MULTICAST_FULL* = NTSTATUS 0xC0230009'i32 + STATUS_NDIS_MULTICAST_EXISTS* = NTSTATUS 0xC023000A'i32 + STATUS_NDIS_MULTICAST_NOT_FOUND* = NTSTATUS 0xC023000B'i32 + STATUS_NDIS_REQUEST_ABORTED* = NTSTATUS 0xC023000C'i32 + STATUS_NDIS_RESET_IN_PROGRESS* = NTSTATUS 0xC023000D'i32 + STATUS_NDIS_INVALID_PACKET* = NTSTATUS 0xC023000F'i32 + STATUS_NDIS_INVALID_DEVICE_REQUEST* = NTSTATUS 0xC0230010'i32 + STATUS_NDIS_ADAPTER_NOT_READY* = NTSTATUS 0xC0230011'i32 + STATUS_NDIS_INVALID_LENGTH* = NTSTATUS 0xC0230014'i32 + STATUS_NDIS_INVALID_DATA* = NTSTATUS 0xC0230015'i32 + STATUS_NDIS_BUFFER_TOO_SHORT* = NTSTATUS 0xC0230016'i32 + STATUS_NDIS_INVALID_OID* = NTSTATUS 0xC0230017'i32 + STATUS_NDIS_ADAPTER_REMOVED* = NTSTATUS 0xC0230018'i32 + STATUS_NDIS_UNSUPPORTED_MEDIA* = NTSTATUS 0xC0230019'i32 + STATUS_NDIS_GROUP_ADDRESS_IN_USE* = NTSTATUS 0xC023001A'i32 + STATUS_NDIS_FILE_NOT_FOUND* = NTSTATUS 0xC023001B'i32 + STATUS_NDIS_ERROR_READING_FILE* = NTSTATUS 0xC023001C'i32 + STATUS_NDIS_ALREADY_MAPPED* = NTSTATUS 0xC023001D'i32 + STATUS_NDIS_RESOURCE_CONFLICT* = NTSTATUS 0xC023001E'i32 + STATUS_NDIS_MEDIA_DISCONNECTED* = NTSTATUS 0xC023001F'i32 + STATUS_NDIS_INVALID_ADDRESS* = NTSTATUS 0xC0230022'i32 + STATUS_NDIS_PAUSED* = NTSTATUS 0xC023002A'i32 + STATUS_NDIS_INTERFACE_NOT_FOUND* = NTSTATUS 0xC023002B'i32 + STATUS_NDIS_UNSUPPORTED_REVISION* = NTSTATUS 0xC023002C'i32 + STATUS_NDIS_INVALID_PORT* = NTSTATUS 0xC023002D'i32 + STATUS_NDIS_INVALID_PORT_STATE* = NTSTATUS 0xC023002E'i32 + STATUS_NDIS_LOW_POWER_STATE* = NTSTATUS 0xC023002F'i32 + STATUS_NDIS_NOT_SUPPORTED* = NTSTATUS 0xC02300BB'i32 + STATUS_NDIS_OFFLOAD_POLICY* = NTSTATUS 0xC023100F'i32 + STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED* = NTSTATUS 0xC0231012'i32 + STATUS_NDIS_OFFLOAD_PATH_REJECTED* = NTSTATUS 0xC0231013'i32 + STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED* = NTSTATUS 0xC0232000'i32 + STATUS_NDIS_DOT11_MEDIA_IN_USE* = NTSTATUS 0xC0232001'i32 + STATUS_NDIS_DOT11_POWER_STATE_INVALID* = NTSTATUS 0xC0232002'i32 + STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL* = NTSTATUS 0xC0232003'i32 + STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL* = NTSTATUS 0xC0232004'i32 + STATUS_IPSEC_BAD_SPI* = NTSTATUS 0xC0360001'i32 + STATUS_IPSEC_SA_LIFETIME_EXPIRED* = NTSTATUS 0xC0360002'i32 + STATUS_IPSEC_WRONG_SA* = NTSTATUS 0xC0360003'i32 + STATUS_IPSEC_REPLAY_CHECK_FAILED* = NTSTATUS 0xC0360004'i32 + STATUS_IPSEC_INVALID_PACKET* = NTSTATUS 0xC0360005'i32 + STATUS_IPSEC_INTEGRITY_CHECK_FAILED* = NTSTATUS 0xC0360006'i32 + STATUS_IPSEC_CLEAR_TEXT_DROP* = NTSTATUS 0xC0360007'i32 + STATUS_IPSEC_AUTH_FIREWALL_DROP* = NTSTATUS 0xC0360008'i32 + STATUS_IPSEC_THROTTLE_DROP* = NTSTATUS 0xC0360009'i32 + STATUS_IPSEC_DOSP_BLOCK* = NTSTATUS 0xC0368000'i32 + STATUS_IPSEC_DOSP_RECEIVED_MULTICAST* = NTSTATUS 0xC0368001'i32 + STATUS_IPSEC_DOSP_INVALID_PACKET* = NTSTATUS 0xC0368002'i32 + STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED* = NTSTATUS 0xC0368003'i32 + STATUS_IPSEC_DOSP_MAX_ENTRIES* = NTSTATUS 0xC0368004'i32 + STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED* = NTSTATUS 0xC0368005'i32 + STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES* = NTSTATUS 0xC0368006'i32 + STATUS_VOLMGR_MIRROR_NOT_SUPPORTED* = NTSTATUS 0xC038005B'i32 + STATUS_VOLMGR_RAID5_NOT_SUPPORTED* = NTSTATUS 0xC038005C'i32 + STATUS_VIRTDISK_PROVIDER_NOT_FOUND* = NTSTATUS 0xC03A0014'i32 + STATUS_VIRTDISK_NOT_VIRTUAL_DISK* = NTSTATUS 0xC03A0015'i32 + STATUS_VHD_PARENT_VHD_ACCESS_DENIED* = NTSTATUS 0xC03A0016'i32 + STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH* = NTSTATUS 0xC03A0017'i32 + STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED* = NTSTATUS 0xC03A0018'i32 + STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT* = NTSTATUS 0xC03A0019'i32 + MAX_PATH* = 260 + PRAGMA_DEPRECATED_DDK* = 0 + UCSCHAR_INVALID_CHARACTER* = 0xffffffff'i32 + MIN_UCSCHAR* = 0 + MAX_UCSCHAR* = 0x0010ffff + UNSPECIFIED_COMPARTMENT_ID* = 0 + DEFAULT_COMPARTMENT_ID* = 1 + APPLICATION_ERROR_MASK* = 0x20000000 + ERROR_SEVERITY_SUCCESS* = 0x00000000 + ERROR_SEVERITY_INFORMATIONAL* = 0x40000000 + ERROR_SEVERITY_WARNING* = 0x80000000'i32 + ERROR_SEVERITY_ERROR* = 0xC0000000'i32 + UNICODE_STRING_MAX_BYTES* = WORD 65534 + UNICODE_STRING_MAX_CHARS* = 32767 +template DEFINE_GUID*(data1: int32, data2: uint16, data3: uint16, data4: array[8, uint8]): GUID = GUID(Data1: data1, Data2: data2, Data3: data3, Data4: data4) +const + GUID_NULL* = DEFINE_GUID("00000000-0000-0000-0000-000000000000") + IID_NULL* = GUID_NULL + CLSID_NULL* = GUID_NULL + FMTID_NULL* = GUID_NULL + MAXBYTE* = 0xff + MAXWORD* = 0xffff + MAXDWORD* = 0xffffffff'i32 + PRODUCT_UNDEFINED* = 0x0 + PRODUCT_ULTIMATE* = 0x1 + PRODUCT_HOME_BASIC* = 0x2 + PRODUCT_HOME_PREMIUM* = 0x3 + PRODUCT_ENTERPRISE* = 0x4 + PRODUCT_HOME_BASIC_N* = 0x5 + PRODUCT_BUSINESS* = 0x6 + PRODUCT_STANDARD_SERVER* = 0x7 + PRODUCT_DATACENTER_SERVER* = 0x8 + PRODUCT_SMALLBUSINESS_SERVER* = 0x9 + PRODUCT_ENTERPRISE_SERVER* = 0xa + PRODUCT_STARTER* = 0xb + PRODUCT_DATACENTER_SERVER_CORE* = 0xc + PRODUCT_STANDARD_SERVER_CORE* = 0xd + PRODUCT_ENTERPRISE_SERVER_CORE* = 0xe + PRODUCT_ENTERPRISE_SERVER_IA64* = 0xf + PRODUCT_BUSINESS_N* = 0x10 + PRODUCT_WEB_SERVER* = 0x11 + PRODUCT_CLUSTER_SERVER* = 0x12 + PRODUCT_HOME_SERVER* = 0x13 + PRODUCT_STORAGE_EXPRESS_SERVER* = 0x14 + PRODUCT_STORAGE_STANDARD_SERVER* = 0x15 + PRODUCT_STORAGE_WORKGROUP_SERVER* = 0x16 + PRODUCT_STORAGE_ENTERPRISE_SERVER* = 0x17 + PRODUCT_SERVER_FOR_SMALLBUSINESS* = 0x18 + PRODUCT_SMALLBUSINESS_SERVER_PREMIUM* = 0x19 + PRODUCT_HOME_PREMIUM_N* = 0x1a + PRODUCT_ENTERPRISE_N* = 0x1b + PRODUCT_ULTIMATE_N* = 0x1c + PRODUCT_WEB_SERVER_CORE* = 0x1d + PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT* = 0x1e + PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY* = 0x1f + PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING* = 0x20 + PRODUCT_SERVER_FOUNDATION* = 0x21 + PRODUCT_HOME_PREMIUM_SERVER* = 0x22 + PRODUCT_SERVER_FOR_SMALLBUSINESS_V* = 0x23 + PRODUCT_STANDARD_SERVER_V* = 0x24 + PRODUCT_DATACENTER_SERVER_V* = 0x25 + PRODUCT_ENTERPRISE_SERVER_V* = 0x26 + PRODUCT_DATACENTER_SERVER_CORE_V* = 0x27 + PRODUCT_STANDARD_SERVER_CORE_V* = 0x28 + PRODUCT_ENTERPRISE_SERVER_CORE_V* = 0x29 + PRODUCT_HYPERV* = 0x2a + PRODUCT_STORAGE_EXPRESS_SERVER_CORE* = 0x2b + PRODUCT_STORAGE_STANDARD_SERVER_CORE* = 0x2c + PRODUCT_STORAGE_WORKGROUP_SERVER_CORE* = 0x2d + PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE* = 0x2e + PRODUCT_STARTER_N* = 0x2f + PRODUCT_PROFESSIONAL* = 0x30 + PRODUCT_PROFESSIONAL_N* = 0x31 + PRODUCT_SB_SOLUTION_SERVER* = 0x32 + PRODUCT_SERVER_FOR_SB_SOLUTIONS* = 0x33 + PRODUCT_STANDARD_SERVER_SOLUTIONS* = 0x34 + PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE* = 0x35 + PRODUCT_SB_SOLUTION_SERVER_EM* = 0x36 + PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM* = 0x37 + PRODUCT_SOLUTION_EMBEDDEDSERVER* = 0x38 + PRODUCT_SOLUTION_EMBEDDEDSERVER_CORE* = 0x39 + PRODUCT_ESSENTIALBUSINESS_SERVER_MGMT* = 0x3B + PRODUCT_ESSENTIALBUSINESS_SERVER_ADDL* = 0x3C + PRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVC* = 0x3D + PRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVC* = 0x3E + PRODUCT_SMALLBUSINESS_SERVER_PREMIUM_CORE* = 0x3f + PRODUCT_CLUSTER_SERVER_V* = 0x40 + PRODUCT_EMBEDDED* = 0x41 + PRODUCT_STARTER_E* = 0x42 + PRODUCT_HOME_BASIC_E* = 0x43 + PRODUCT_HOME_PREMIUM_E* = 0x44 + PRODUCT_PROFESSIONAL_E* = 0x45 + PRODUCT_ENTERPRISE_E* = 0x46 + PRODUCT_ULTIMATE_E* = 0x47 + PRODUCT_ENTERPRISE_EVALUATION* = 0x48 + PRODUCT_MULTIPOINT_STANDARD_SERVER* = 0x4C + PRODUCT_MULTIPOINT_PREMIUM_SERVER* = 0x4D + PRODUCT_STANDARD_EVALUATION_SERVER* = 0x4F + PRODUCT_DATACENTER_EVALUATION_SERVER* = 0x50 + PRODUCT_ENTERPRISE_N_EVALUATION* = 0x54 + PRODUCT_EMBEDDED_AUTOMOTIVE* = 0x55 + PRODUCT_EMBEDDED_INDUSTRY_A* = 0x56 + PRODUCT_THINPC* = 0x57 + PRODUCT_EMBEDDED_A* = 0x58 + PRODUCT_EMBEDDED_INDUSTRY* = 0x59 + PRODUCT_EMBEDDED_E* = 0x5A + PRODUCT_EMBEDDED_INDUSTRY_E* = 0x5B + PRODUCT_EMBEDDED_INDUSTRY_A_E* = 0x5C + PRODUCT_STORAGE_WORKGROUP_EVALUATION_SERVER* = 0x5F + PRODUCT_STORAGE_STANDARD_EVALUATION_SERVER* = 0x60 + PRODUCT_CORE_ARM* = 0x61 + PRODUCT_CORE_N* = 0x62 + PRODUCT_CORE_COUNTRYSPECIFIC* = 0x63 + PRODUCT_CORE_SINGLELANGUAGE* = 0x64 + PRODUCT_CORE* = 0x65 + PRODUCT_PROFESSIONAL_WMC* = 0x67 + PRODUCT_MOBILE_CORE* = 0x68 + PRODUCT_EDUCATION* = 0x79 + PRODUCT_EDUCATION_N* = 0x7a + PRODUCT_MOBILE_ENTERPRISE* = 0x85 + PRODUCT_UNLICENSED* = 0xabcdabcd'i32 + LANG_AZERBAIJANI* = 0x2c + LANG_BANGLA* = 0x45 + LANG_CENTRAL_KURDISH* = 0x92 + LANG_CHEROKEE* = 0x5c + LANG_FULAH* = 0x67 + LANG_ODIA* = 0x48 + LANG_PULAR* = 0x67 + LANG_SAKHA* = 0x85 + LANG_SCOTTISH_GAELIC* = 0x91 + LANG_TIGRINYA* = 0x73 + LANG_VALENCIAN* = 0x03 + SUBLANG_NEUTRAL* = 0x00 + SUBLANG_DEFAULT* = 0x01 + SUBLANG_SYS_DEFAULT* = 0x02 + SUBLANG_CUSTOM_DEFAULT* = 0x03 + SUBLANG_CUSTOM_UNSPECIFIED* = 0x04 + SUBLANG_UI_CUSTOM_DEFAULT* = 0x05 + SUBLANG_AFRIKAANS_SOUTH_AFRICA* = 0x01 + SUBLANG_ALBANIAN_ALBANIA* = 0x01 + SUBLANG_ALSATIAN_FRANCE* = 0x01 + SUBLANG_AMHARIC_ETHIOPIA* = 0x01 + SUBLANG_ARABIC_SAUDI_ARABIA* = 0x01 + SUBLANG_ARABIC_IRAQ* = 0x02 + SUBLANG_ARABIC_EGYPT* = 0x03 + SUBLANG_ARABIC_LIBYA* = 0x04 + SUBLANG_ARABIC_ALGERIA* = 0x05 + SUBLANG_ARABIC_MOROCCO* = 0x06 + SUBLANG_ARABIC_TUNISIA* = 0x07 + SUBLANG_ARABIC_OMAN* = 0x08 + SUBLANG_ARABIC_YEMEN* = 0x09 + SUBLANG_ARABIC_SYRIA* = 0x0a + SUBLANG_ARABIC_JORDAN* = 0x0b + SUBLANG_ARABIC_LEBANON* = 0x0c + SUBLANG_ARABIC_KUWAIT* = 0x0d + SUBLANG_ARABIC_UAE* = 0x0e + SUBLANG_ARABIC_BAHRAIN* = 0x0f + SUBLANG_ARABIC_QATAR* = 0x10 + SUBLANG_ARMENIAN_ARMENIA* = 0x01 + SUBLANG_ASSAMESE_INDIA* = 0x01 + SUBLANG_AZERI_LATIN* = 0x01 + SUBLANG_AZERI_CYRILLIC* = 0x02 + SUBLANG_AZERBAIJANI_AZERBAIJAN_LATIN* = 0x01 + SUBLANG_AZERBAIJANI_AZERBAIJAN_CYRILLIC* = 0x02 + SUBLANG_BANGLA_INDIA* = 0x01 + SUBLANG_BANGLA_BANGLADESH* = 0x02 + SUBLANG_BASHKIR_RUSSIA* = 0x01 + SUBLANG_BASQUE_BASQUE* = 0x01 + SUBLANG_BELARUSIAN_BELARUS* = 0x01 + SUBLANG_BENGALI_INDIA* = 0x01 + SUBLANG_BENGALI_BANGLADESH* = 0x02 + SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN* = 0x05 + SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC* = 0x08 + SUBLANG_BRETON_FRANCE* = 0x01 + SUBLANG_BULGARIAN_BULGARIA* = 0x01 + SUBLANG_CATALAN_CATALAN* = 0x01 + SUBLANG_CENTRAL_KURDISH_IRAQ* = 0x01 + SUBLANG_CHEROKEE_CHEROKEE* = 0x01 + SUBLANG_CHINESE_TRADITIONAL* = 0x01 + SUBLANG_CHINESE_SIMPLIFIED* = 0x02 + SUBLANG_CHINESE_HONGKONG* = 0x03 + SUBLANG_CHINESE_SINGAPORE* = 0x04 + SUBLANG_CHINESE_MACAU* = 0x05 + SUBLANG_CORSICAN_FRANCE* = 0x01 + SUBLANG_CZECH_CZECH_REPUBLIC* = 0x01 + SUBLANG_CROATIAN_CROATIA* = 0x01 + SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN* = 0x04 + SUBLANG_DANISH_DENMARK* = 0x01 + SUBLANG_DARI_AFGHANISTAN* = 0x01 + SUBLANG_DIVEHI_MALDIVES* = 0x01 + SUBLANG_DUTCH* = 0x01 + SUBLANG_DUTCH_BELGIAN* = 0x02 + SUBLANG_ENGLISH_US* = 0x01 + SUBLANG_ENGLISH_UK* = 0x02 + SUBLANG_ENGLISH_AUS* = 0x03 + SUBLANG_ENGLISH_CAN* = 0x04 + SUBLANG_ENGLISH_NZ* = 0x05 + SUBLANG_ENGLISH_IRELAND* = 0x06 + SUBLANG_ENGLISH_EIRE* = 0x06 + SUBLANG_ENGLISH_SOUTH_AFRICA* = 0x07 + SUBLANG_ENGLISH_JAMAICA* = 0x08 + SUBLANG_ENGLISH_CARIBBEAN* = 0x09 + SUBLANG_ENGLISH_BELIZE* = 0x0a + SUBLANG_ENGLISH_TRINIDAD* = 0x0b + SUBLANG_ENGLISH_ZIMBABWE* = 0x0c + SUBLANG_ENGLISH_PHILIPPINES* = 0x0d + SUBLANG_ENGLISH_INDIA* = 0x10 + SUBLANG_ENGLISH_MALAYSIA* = 0x11 + SUBLANG_ENGLISH_SINGAPORE* = 0x12 + SUBLANG_ESTONIAN_ESTONIA* = 0x01 + SUBLANG_FAEROESE_FAROE_ISLANDS* = 0x01 + SUBLANG_FILIPINO_PHILIPPINES* = 0x01 + SUBLANG_FINNISH_FINLAND* = 0x01 + SUBLANG_FRENCH* = 0x01 + SUBLANG_FRENCH_BELGIAN* = 0x02 + SUBLANG_FRENCH_CANADIAN* = 0x03 + SUBLANG_FRENCH_SWISS* = 0x04 + SUBLANG_FRENCH_LUXEMBOURG* = 0x05 + SUBLANG_FRENCH_MONACO* = 0x06 + SUBLANG_FRISIAN_NETHERLANDS* = 0x01 + SUBLANG_FULAH_SENEGAL* = 0x02 + SUBLANG_GALICIAN_GALICIAN* = 0x01 + SUBLANG_GEORGIAN_GEORGIA* = 0x01 + SUBLANG_GERMAN* = 0x01 + SUBLANG_GERMAN_SWISS* = 0x02 + SUBLANG_GERMAN_AUSTRIAN* = 0x03 + SUBLANG_GERMAN_LUXEMBOURG* = 0x04 + SUBLANG_GERMAN_LIECHTENSTEIN* = 0x05 + SUBLANG_GREEK_GREECE* = 0x01 + SUBLANG_GREENLANDIC_GREENLAND* = 0x01 + SUBLANG_GUJARATI_INDIA* = 0x01 + SUBLANG_HAUSA_NIGERIA_LATIN* = 0x01 + SUBLANG_HAUSA_NIGERIA* = SUBLANG_HAUSA_NIGERIA_LATIN + SUBLANG_HAWAIIAN_US* = 0x01 + SUBLANG_HEBREW_ISRAEL* = 0x01 + SUBLANG_HINDI_INDIA* = 0x01 + SUBLANG_HUNGARIAN_HUNGARY* = 0x01 + SUBLANG_ICELANDIC_ICELAND* = 0x01 + SUBLANG_IGBO_NIGERIA* = 0x01 + SUBLANG_INDONESIAN_INDONESIA* = 0x01 + SUBLANG_INUKTITUT_CANADA* = 0x01 + SUBLANG_INUKTITUT_CANADA_LATIN* = 0x02 + SUBLANG_IRISH_IRELAND* = 0x02 + SUBLANG_ITALIAN* = 0x01 + SUBLANG_ITALIAN_SWISS* = 0x02 + SUBLANG_JAPANESE_JAPAN* = 0x01 + SUBLANG_KANNADA_INDIA* = 0x01 + SUBLANG_KASHMIRI_INDIA* = 0x02 + SUBLANG_KASHMIRI_SASIA* = 0x02 + SUBLANG_KAZAK_KAZAKHSTAN* = 0x01 + SUBLANG_KHMER_CAMBODIA* = 0x01 + SUBLANG_KICHE_GUATEMALA* = 0x01 + SUBLANG_KINYARWANDA_RWANDA* = 0x01 + SUBLANG_KONKANI_INDIA* = 0x01 + SUBLANG_KOREAN* = 0x01 + SUBLANG_KYRGYZ_KYRGYZSTAN* = 0x01 + SUBLANG_LAO_LAO* = 0x01 + SUBLANG_LAO_LAO_PDR* = SUBLANG_LAO_LAO + SUBLANG_LATVIAN_LATVIA* = 0x01 + SUBLANG_LITHUANIAN_LITHUANIA* = 0x01 + SUBLANG_LITHUANIAN* = 0x01 + SUBLANG_LOWER_SORBIAN_GERMANY* = 0x02 + SUBLANG_LUXEMBOURGISH_LUXEMBOURG* = 0x01 + SUBLANG_MACEDONIAN_MACEDONIA* = 0x01 + SUBLANG_MALAY_MALAYSIA* = 0x01 + SUBLANG_MALAY_BRUNEI_DARUSSALAM* = 0x02 + SUBLANG_MALAYALAM_INDIA* = 0x01 + SUBLANG_MALTESE_MALTA* = 0x01 + SUBLANG_MAORI_NEW_ZEALAND* = 0x01 + SUBLANG_MAPUDUNGUN_CHILE* = 0x01 + SUBLANG_MARATHI_INDIA* = 0x01 + SUBLANG_MOHAWK_MOHAWK* = 0x01 + SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA* = 0x01 + SUBLANG_MONGOLIAN_PRC* = 0x02 + SUBLANG_NEPALI_NEPAL* = 0x01 + SUBLANG_NEPALI_INDIA* = 0x02 + SUBLANG_NORWEGIAN_BOKMAL* = 0x01 + SUBLANG_NORWEGIAN_NYNORSK* = 0x02 + SUBLANG_OCCITAN_FRANCE* = 0x01 + SUBLANG_ORIYA_INDIA* = 0x01 + SUBLANG_PASHTO_AFGHANISTAN* = 0x01 + SUBLANG_PERSIAN_IRAN* = 0x01 + SUBLANG_POLISH_POLAND* = 0x01 + SUBLANG_PORTUGUESE_BRAZILIAN* = 0x01 + SUBLANG_PORTUGUESE_PORTUGAL* = 0x02 + SUBLANG_PORTUGUESE* = 0x02 + SUBLANG_PULAR_SENEGAL* = 0x02 + SUBLANG_PUNJABI_INDIA* = 0x01 + SUBLANG_PUNJABI_PAKISTAN* = 0x02 + SUBLANG_QUECHUA_BOLIVIA* = 0x01 + SUBLANG_QUECHUA_ECUADOR* = 0x02 + SUBLANG_QUECHUA_PERU* = 0x03 + SUBLANG_ROMANIAN_ROMANIA* = 0x01 + SUBLANG_ROMANSH_SWITZERLAND* = 0x01 + SUBLANG_RUSSIAN_RUSSIA* = 0x01 + SUBLANG_SAKHA_RUSSIA* = 0x01 + SUBLANG_SAMI_NORTHERN_NORWAY* = 0x01 + SUBLANG_SAMI_NORTHERN_SWEDEN* = 0x02 + SUBLANG_SAMI_NORTHERN_FINLAND* = 0x03 + SUBLANG_SAMI_LULE_NORWAY* = 0x04 + SUBLANG_SAMI_LULE_SWEDEN* = 0x05 + SUBLANG_SAMI_SOUTHERN_NORWAY* = 0x06 + SUBLANG_SAMI_SOUTHERN_SWEDEN* = 0x07 + SUBLANG_SAMI_SKOLT_FINLAND* = 0x08 + SUBLANG_SAMI_INARI_FINLAND* = 0x09 + SUBLANG_SANSKRIT_INDIA* = 0x01 + SUBLANG_SCOTTISH_GAELIC* = 0x01 + SUBLANG_SERBIAN_LATIN* = 0x02 + SUBLANG_SERBIAN_CYRILLIC* = 0x03 + SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATIN* = 0x06 + SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLIC* = 0x07 + SUBLANG_SERBIAN_MONTENEGRO_LATIN* = 0x0b + SUBLANG_SERBIAN_MONTENEGRO_CYRILLIC* = 0x0c + SUBLANG_SERBIAN_SERBIA_LATIN* = 0x09 + SUBLANG_SERBIAN_SERBIA_CYRILLIC* = 0x0a + SUBLANG_SINDHI_INDIA* = 0x01 + SUBLANG_SINDHI_AFGHANISTAN* = 0x02 + SUBLANG_SINDHI_PAKISTAN* = 0x02 + SUBLANG_SINHALESE_SRI_LANKA* = 0x01 + SUBLANG_SOTHO_NORTHERN_SOUTH_AFRICA* = 0x01 + SUBLANG_SLOVAK_SLOVAKIA* = 0x01 + SUBLANG_SLOVENIAN_SLOVENIA* = 0x01 + SUBLANG_SPANISH* = 0x01 + SUBLANG_SPANISH_MEXICAN* = 0x02 + SUBLANG_SPANISH_MODERN* = 0x03 + SUBLANG_SPANISH_GUATEMALA* = 0x04 + SUBLANG_SPANISH_COSTA_RICA* = 0x05 + SUBLANG_SPANISH_PANAMA* = 0x06 + SUBLANG_SPANISH_DOMINICAN_REPUBLIC* = 0x07 + SUBLANG_SPANISH_VENEZUELA* = 0x08 + SUBLANG_SPANISH_COLOMBIA* = 0x09 + SUBLANG_SPANISH_PERU* = 0x0a + SUBLANG_SPANISH_ARGENTINA* = 0x0b + SUBLANG_SPANISH_ECUADOR* = 0x0c + SUBLANG_SPANISH_CHILE* = 0x0d + SUBLANG_SPANISH_URUGUAY* = 0x0e + SUBLANG_SPANISH_PARAGUAY* = 0x0f + SUBLANG_SPANISH_BOLIVIA* = 0x10 + SUBLANG_SPANISH_EL_SALVADOR* = 0x11 + SUBLANG_SPANISH_HONDURAS* = 0x12 + SUBLANG_SPANISH_NICARAGUA* = 0x13 + SUBLANG_SPANISH_PUERTO_RICO* = 0x14 + SUBLANG_SPANISH_US* = 0x15 + SUBLANG_SWAHILI_KENYA* = 0x01 + SUBLANG_SWEDISH_SWEDEN* = 0x01 + SUBLANG_SWEDISH* = 0x01 + SUBLANG_SWEDISH_FINLAND* = 0x02 + SUBLANG_SYRIAC* = 0x01 + SUBLANG_SYRIAC_SYRIA* = SUBLANG_SYRIAC + SUBLANG_TAJIK_TAJIKISTAN* = 0x01 + SUBLANG_TAMAZIGHT_ALGERIA_LATIN* = 0x02 + SUBLANG_TAMAZIGHT_MOROCCO_TIFINAGH* = 0x04 + SUBLANG_TAMIL_INDIA* = 0x01 + SUBLANG_TAMIL_SRI_LANKA* = 0x02 + SUBLANG_TATAR_RUSSIA* = 0x01 + SUBLANG_TELUGU_INDIA* = 0x01 + SUBLANG_THAI_THAILAND* = 0x01 + SUBLANG_TIBETAN_PRC* = 0x01 + SUBLANG_TIBETAN_BHUTAN* = 0x02 + SUBLANG_TIGRIGNA_ERITREA* = 0x02 + SUBLANG_TIGRINYA_ERITREA* = 0x02 + SUBLANG_TIGRINYA_ETHIOPIA* = 0x01 + SUBLANG_TSWANA_BOTSWANA* = 0x02 + SUBLANG_TSWANA_SOUTH_AFRICA* = 0x01 + SUBLANG_TURKISH_TURKEY* = 0x01 + SUBLANG_TURKMEN_TURKMENISTAN* = 0x01 + SUBLANG_UIGHUR_PRC* = 0x01 + SUBLANG_UKRAINIAN_UKRAINE* = 0x01 + SUBLANG_UPPER_SORBIAN_GERMANY* = 0x01 + SUBLANG_URDU_PAKISTAN* = 0x01 + SUBLANG_URDU_INDIA* = 0x02 + SUBLANG_UZBEK_LATIN* = 0x01 + SUBLANG_UZBEK_CYRILLIC* = 0x02 + SUBLANG_VALENCIAN_VALENCIA* = 0x02 + SUBLANG_VIETNAMESE_VIETNAM* = 0x01 + SUBLANG_WELSH_UNITED_KINGDOM* = 0x01 + SUBLANG_WOLOF_SENEGAL* = 0x01 + SUBLANG_YORUBA_NIGERIA* = 0x01 + SUBLANG_XHOSA_SOUTH_AFRICA* = 0x01 + SUBLANG_YAKUT_RUSSIA* = 0x01 + SUBLANG_YI_PRC* = 0x01 + SUBLANG_ZULU_SOUTH_AFRICA* = 0x01 + SORT_DEFAULT* = 0x0 + SORT_INVARIANT_MATH* = 0x1 + SORT_JAPANESE_XJIS* = 0x0 + SORT_JAPANESE_UNICODE* = 0x1 + SORT_JAPANESE_RADICALSTROKE* = 0x4 + SORT_CHINESE_BIG5* = 0x0 + SORT_CHINESE_PRCP* = 0x0 + SORT_CHINESE_UNICODE* = 0x1 + SORT_CHINESE_PRC* = 0x2 + SORT_CHINESE_BOPOMOFO* = 0x3 + SORT_CHINESE_RADICALSTROKE* = 0x4 + SORT_KOREAN_KSC* = 0x0 + SORT_KOREAN_UNICODE* = 0x1 + SORT_GERMAN_PHONE_BOOK* = 0x1 + SORT_HUNGARIAN_DEFAULT* = 0x0 + SORT_HUNGARIAN_TECHNICAL* = 0x1 + SORT_GEORGIAN_TRADITIONAL* = 0x0 + SORT_GEORGIAN_MODERN* = 0x1 + LOCALE_NAME_MAX_LENGTH* = 85 +template MAKELANGID*(p: untyped, s: untyped): WORD = s.WORD shl 10 or p.WORD +const + LANG_SYSTEM_DEFAULT* = MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT) + LANG_USER_DEFAULT* = MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT) +template MAKELCID*(l: untyped, s: untyped): DWORD = (s.DWORD shl 16) or l.DWORD +const + LOCALE_SYSTEM_DEFAULT* = MAKELCID(LANG_SYSTEM_DEFAULT,SORT_DEFAULT) + LOCALE_USER_DEFAULT* = MAKELCID(LANG_USER_DEFAULT,SORT_DEFAULT) + LOCALE_NEUTRAL* = MAKELCID(MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),SORT_DEFAULT) + LOCALE_CUSTOM_DEFAULT* = MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT), SORT_DEFAULT) + LOCALE_CUSTOM_UNSPECIFIED* = MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_UNSPECIFIED), SORT_DEFAULT) + LOCALE_CUSTOM_UI_DEFAULT* = MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_UI_CUSTOM_DEFAULT), SORT_DEFAULT) + LOCALE_INVARIANT* = MAKELCID(MAKELANGID(LANG_INVARIANT,SUBLANG_NEUTRAL),SORT_DEFAULT) + MAXIMUM_WAIT_OBJECTS* = 64 + MAXIMUM_SUSPEND_COUNT* = MAXCHAR + EXCEPTION_NONCONTINUABLE* = 0x1 + EXCEPTION_UNWINDING* = 0x2 + EXCEPTION_EXIT_UNWIND* = 0x4 + EXCEPTION_STACK_INVALID* = 0x8 + EXCEPTION_NESTED_CALL* = 0x10 + EXCEPTION_TARGET_UNWIND* = 0x20 + EXCEPTION_COLLIDED_UNWIND* = 0x40 + EXCEPTION_UNWIND* = 0x66 + DELETE* = 0x00010000 + READ_CONTROL* = 0x00020000 + WRITE_DAC* = 0x00040000 + WRITE_OWNER* = 0x00080000 + SYNCHRONIZE* = 0x00100000 + STANDARD_RIGHTS_REQUIRED* = 0x000F0000 + STANDARD_RIGHTS_READ* = READ_CONTROL + STANDARD_RIGHTS_WRITE* = READ_CONTROL + STANDARD_RIGHTS_EXECUTE* = READ_CONTROL + STANDARD_RIGHTS_ALL* = 0x001F0000 + SPECIFIC_RIGHTS_ALL* = 0x0000FFFF + ACCESS_SYSTEM_SECURITY* = 0x01000000 + MAXIMUM_ALLOWED* = 0x02000000 + GENERIC_READ* = 0x80000000'i32 + GENERIC_WRITE* = 0x40000000 + GENERIC_EXECUTE* = 0x20000000 + GENERIC_ALL* = 0x10000000 + SID_REVISION* = 1 + SID_MAX_SUB_AUTHORITIES* = 15 + SID_RECOMMENDED_SUB_AUTHORITIES* = 1 + sidTypeUser* = 1 + sidTypeGroup* = 2 + sidTypeDomain* = 3 + sidTypeAlias* = 4 + sidTypeWellKnownGroup* = 5 + sidTypeDeletedAccount* = 6 + sidTypeInvalid* = 7 + sidTypeUnknown* = 8 + sidTypeComputer* = 9 + sidTypeLabel* = 10 + SECURITY_NULL_SID_AUTHORITY* = [0'u8,0,0,0,0,0] + SECURITY_WORLD_SID_AUTHORITY* = [0'u8,0,0,0,0,1] + SECURITY_LOCAL_SID_AUTHORITY* = [0'u8,0,0,0,0,2] + SECURITY_CREATOR_SID_AUTHORITY* = [0'u8,0,0,0,0,3] + SECURITY_NON_UNIQUE_AUTHORITY* = [0'u8,0,0,0,0,4] + SECURITY_RESOURCE_MANAGER_AUTHORITY* = [0'u8,0,0,0,0,9] + SECURITY_NULL_RID* = 0x00000000 + SECURITY_WORLD_RID* = 0x00000000 + SECURITY_LOCAL_RID* = 0x00000000 + SECURITY_LOCAL_LOGON_RID* = 0x00000001 + SECURITY_CREATOR_OWNER_RID* = 0x00000000 + SECURITY_CREATOR_GROUP_RID* = 0x00000001 + SECURITY_CREATOR_OWNER_SERVER_RID* = 0x00000002 + SECURITY_CREATOR_GROUP_SERVER_RID* = 0x00000003 + SECURITY_CREATOR_OWNER_RIGHTS_RID* = 0x00000004 + SECURITY_NT_AUTHORITY* = [0'u8,0,0,0,0,5] + SECURITY_DIALUP_RID* = 0x00000001 + SECURITY_NETWORK_RID* = 0x00000002 + SECURITY_BATCH_RID* = 0x00000003 + SECURITY_INTERACTIVE_RID* = 0x00000004 + SECURITY_LOGON_IDS_RID* = 0x00000005 + SECURITY_LOGON_IDS_RID_COUNT* = 3 + SECURITY_SERVICE_RID* = 0x00000006 + SECURITY_ANONYMOUS_LOGON_RID* = 0x00000007 + SECURITY_PROXY_RID* = 0x00000008 + SECURITY_ENTERPRISE_CONTROLLERS_RID* = 0x00000009 + SECURITY_SERVER_LOGON_RID* = SECURITY_ENTERPRISE_CONTROLLERS_RID + SECURITY_PRINCIPAL_SELF_RID* = 0x0000000A + SECURITY_AUTHENTICATED_USER_RID* = 0x0000000B + SECURITY_RESTRICTED_CODE_RID* = 0x0000000C + SECURITY_TERMINAL_SERVER_RID* = 0x0000000D + SECURITY_REMOTE_LOGON_RID* = 0x0000000E + SECURITY_THIS_ORGANIZATION_RID* = 0x0000000F + SECURITY_IUSER_RID* = 0x00000011 + SECURITY_LOCAL_SYSTEM_RID* = 0x00000012 + SECURITY_LOCAL_SERVICE_RID* = 0x00000013 + SECURITY_NETWORK_SERVICE_RID* = 0x00000014 + SECURITY_NT_NON_UNIQUE* = 0x00000015 + SECURITY_NT_NON_UNIQUE_SUB_AUTH_COUNT* = 3 + SECURITY_ENTERPRISE_READONLY_CONTROLLERS_RID* = 0x00000016 + SECURITY_BUILTIN_DOMAIN_RID* = 0x00000020 + SECURITY_WRITE_RESTRICTED_CODE_RID* = 0x00000021 + SECURITY_PACKAGE_BASE_RID* = 0x00000040 + SECURITY_PACKAGE_RID_COUNT* = 2 + SECURITY_PACKAGE_NTLM_RID* = 0x0000000A + SECURITY_PACKAGE_SCHANNEL_RID* = 0x0000000E + SECURITY_PACKAGE_DIGEST_RID* = 0x00000015 + SECURITY_CRED_TYPE_BASE_RID* = 0x00000041 + SECURITY_CRED_TYPE_RID_COUNT* = 2 + SECURITY_CRED_TYPE_THIS_ORG_CERT_RID* = 0x00000001 + SECURITY_MIN_BASE_RID* = 0x00000050 + SECURITY_SERVICE_ID_BASE_RID* = 0x00000050 + SECURITY_SERVICE_ID_RID_COUNT* = 6 + SECURITY_RESERVED_ID_BASE_RID* = 0x00000051 + SECURITY_APPPOOL_ID_BASE_RID* = 0x00000052 + SECURITY_APPPOOL_ID_RID_COUNT* = 6 + SECURITY_VIRTUALSERVER_ID_BASE_RID* = 0x00000053 + SECURITY_VIRTUALSERVER_ID_RID_COUNT* = 6 + SECURITY_USERMODEDRIVERHOST_ID_BASE_RID* = 0x00000054 + SECURITY_USERMODEDRIVERHOST_ID_RID_COUNT* = 6 + SECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_BASE_RID* = 0x00000055 + SECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_RID_COUNT* = 6 + SECURITY_WMIHOST_ID_BASE_RID* = 0x00000056 + SECURITY_WMIHOST_ID_RID_COUNT* = 6 + SECURITY_TASK_ID_BASE_RID* = 0x00000057 + SECURITY_NFS_ID_BASE_RID* = 0x00000058 + SECURITY_COM_ID_BASE_RID* = 0x00000059 + SECURITY_WINDOW_MANAGER_BASE_RID* = 0x0000005a + SECURITY_RDV_GFX_BASE_RID* = 0x0000005b + SECURITY_DASHOST_ID_BASE_RID* = 0x0000005c + SECURITY_DASHOST_ID_RID_COUNT* = 6 + SECURITY_VIRTUALACCOUNT_ID_RID_COUNT* = 6 + SECURITY_MAX_BASE_RID* = 0x0000006f + SECURITY_MAX_ALWAYS_FILTERED* = 0x000003E7 + SECURITY_MIN_NEVER_FILTERED* = 0x000003E8 + SECURITY_OTHER_ORGANIZATION_RID* = 0x000003E8 + SECURITY_WINDOWSMOBILE_ID_BASE_RID* = 0x00000070 + DOMAIN_GROUP_RID_AUTHORIZATION_DATA_IS_COMPOUNDED* = 0x000001f0 + DOMAIN_GROUP_RID_AUTHORIZATION_DATA_CONTAINS_CLAIMS* = 0x000001f1 + DOMAIN_GROUP_RID_ENTERPRISE_READONLY_DOMAIN_CONTROLLERS* = 0x000001f2 + FOREST_USER_RID_MAX* = 0x000001F3 + DOMAIN_USER_RID_ADMIN* = 0x000001F4 + DOMAIN_USER_RID_GUEST* = 0x000001F5 + DOMAIN_USER_RID_KRBTGT* = 0x000001F6 + DOMAIN_USER_RID_MAX* = 0x000003E7 + DOMAIN_GROUP_RID_ADMINS* = 0x00000200 + DOMAIN_GROUP_RID_USERS* = 0x00000201 + DOMAIN_GROUP_RID_GUESTS* = 0x00000202 + DOMAIN_GROUP_RID_COMPUTERS* = 0x00000203 + DOMAIN_GROUP_RID_CONTROLLERS* = 0x00000204 + DOMAIN_GROUP_RID_CERT_ADMINS* = 0x00000205 + DOMAIN_GROUP_RID_SCHEMA_ADMINS* = 0x00000206 + DOMAIN_GROUP_RID_ENTERPRISE_ADMINS* = 0x00000207 + DOMAIN_GROUP_RID_POLICY_ADMINS* = 0x00000208 + DOMAIN_GROUP_RID_READONLY_CONTROLLERS* = 0x00000209 + DOMAIN_GROUP_RID_CLONEABLE_CONTROLLERS* = 0x0000020a + DOMAIN_ALIAS_RID_ADMINS* = 0x00000220 + DOMAIN_ALIAS_RID_USERS* = 0x00000221 + DOMAIN_ALIAS_RID_GUESTS* = 0x00000222 + DOMAIN_ALIAS_RID_POWER_USERS* = 0x00000223 + DOMAIN_ALIAS_RID_ACCOUNT_OPS* = 0x00000224 + DOMAIN_ALIAS_RID_SYSTEM_OPS* = 0x00000225 + DOMAIN_ALIAS_RID_PRINT_OPS* = 0x00000226 + DOMAIN_ALIAS_RID_BACKUP_OPS* = 0x00000227 + DOMAIN_ALIAS_RID_REPLICATOR* = 0x00000228 + DOMAIN_ALIAS_RID_RAS_SERVERS* = 0x00000229 + DOMAIN_ALIAS_RID_PREW2KCOMPACCESS* = 0x0000022A + DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS* = 0x0000022B + DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS* = 0x0000022C + DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS* = 0x0000022D + DOMAIN_ALIAS_RID_MONITORING_USERS* = 0x0000022E + DOMAIN_ALIAS_RID_LOGGING_USERS* = 0x0000022F + DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS* = 0x00000230 + DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS* = 0x00000231 + DOMAIN_ALIAS_RID_DCOM_USERS* = 0x00000232 + DOMAIN_ALIAS_RID_IUSERS* = 0x00000238 + DOMAIN_ALIAS_RID_CRYPTO_OPERATORS* = 0x00000239 + DOMAIN_ALIAS_RID_CACHEABLE_PRINCIPALS_GROUP* = 0x0000023B + DOMAIN_ALIAS_RID_NON_CACHEABLE_PRINCIPALS_GROUP* = 0x0000023C + DOMAIN_ALIAS_RID_EVENT_LOG_READERS_GROUP* = 0x0000023D + DOMAIN_ALIAS_RID_CERTSVC_DCOM_ACCESS_GROUP* = 0x0000023e + DOMAIN_ALIAS_RID_RDS_REMOTE_ACCESS_SERVERS* = 0x0000023f + DOMAIN_ALIAS_RID_RDS_ENDPOINT_SERVERS* = 0x00000240 + DOMAIN_ALIAS_RID_RDS_MANAGEMENT_SERVERS* = 0x00000241 + DOMAIN_ALIAS_RID_HYPER_V_ADMINS* = 0x00000242 + DOMAIN_ALIAS_RID_ACCESS_CONTROL_ASSISTANCE_OPS* = 0x00000243 + DOMAIN_ALIAS_RID_REMOTE_MANAGEMENT_USERS* = 0x00000244 + SECURITY_APP_PACKAGE_AUTHORITY* = [0'u8, 0, 0, 0, 0, 15] + SECURITY_APP_PACKAGE_BASE_RID* = 0x00000002 + SECURITY_BUILTIN_APP_PACKAGE_RID_COUNT* = 2 + SECURITY_APP_PACKAGE_RID_COUNT* = 8 + SECURITY_CAPABILITY_BASE_RID* = 0x00000003 + SECURITY_BUILTIN_CAPABILITY_RID_COUNT* = 2 + SECURITY_CAPABILITY_RID_COUNT* = 5 + SECURITY_BUILTIN_PACKAGE_ANY_PACKAGE* = 0x00000001 + SECURITY_CAPABILITY_INTERNET_CLIENT* = 0x00000001 + SECURITY_CAPABILITY_INTERNET_CLIENT_SERVER* = 0x00000002 + SECURITY_CAPABILITY_PRIVATE_NETWORK_CLIENT_SERVER* = 0x00000003 + SECURITY_CAPABILITY_PICTURES_LIBRARY* = 0x00000004 + SECURITY_CAPABILITY_VIDEOS_LIBRARY* = 0x00000005 + SECURITY_CAPABILITY_MUSIC_LIBRARY* = 0x00000006 + SECURITY_CAPABILITY_DOCUMENTS_LIBRARY* = 0x00000007 + SECURITY_CAPABILITY_ENTERPRISE_AUTHENTICATION* = 0x00000008 + SECURITY_CAPABILITY_SHARED_USER_CERTIFICATES* = 0x00000009 + SECURITY_CAPABILITY_REMOVABLE_STORAGE* = 0x0000000a + SECURITY_CAPABILITY_INTERNET_EXPLORER* = 0x00001000 + SECURITY_MANDATORY_LABEL_AUTHORITY* = [0'u8,0,0,0,0,16] + SECURITY_MANDATORY_UNTRUSTED_RID* = 0x00000000 + SECURITY_MANDATORY_LOW_RID* = 0x00001000 + SECURITY_MANDATORY_MEDIUM_RID* = 0x00002000 + SECURITY_MANDATORY_HIGH_RID* = 0x00003000 + SECURITY_MANDATORY_SYSTEM_RID* = 0x00004000 + SECURITY_MANDATORY_PROTECTED_PROCESS_RID* = 0x00005000 + SECURITY_MANDATORY_MAXIMUM_USER_RID* = SECURITY_MANDATORY_SYSTEM_RID + SECURITY_SCOPED_POLICY_ID_AUTHORITY* = [0'u8, 0, 0, 0, 0, 17] + SECURITY_AUTHENTICATION_AUTHORITY* = [0'u8, 0, 0, 0, 0, 18] + SECURITY_AUTHENTICATION_AUTHORITY_RID_COUNT* = 1 + SECURITY_AUTHENTICATION_AUTHORITY_ASSERTED_RID* = 0x00000001 + SECURITY_AUTHENTICATION_SERVICE_ASSERTED_RID* = 0x00000002 + SECURITY_TRUSTED_INSTALLER_RID1* = 956008885 + SECURITY_TRUSTED_INSTALLER_RID2* = 3418522649 + SECURITY_TRUSTED_INSTALLER_RID3* = 1831038044 + SECURITY_TRUSTED_INSTALLER_RID4* = 1853292631 + SECURITY_TRUSTED_INSTALLER_RID5* = 2271478464 + winNullSid* = 0 + winWorldSid* = 1 + winLocalSid* = 2 + winCreatorOwnerSid* = 3 + winCreatorGroupSid* = 4 + winCreatorOwnerServerSid* = 5 + winCreatorGroupServerSid* = 6 + winNtAuthoritySid* = 7 + winDialupSid* = 8 + winNetworkSid* = 9 + winBatchSid* = 10 + winInteractiveSid* = 11 + winServiceSid* = 12 + winAnonymousSid* = 13 + winProxySid* = 14 + winEnterpriseControllersSid* = 15 + winSelfSid* = 16 + winAuthenticatedUserSid* = 17 + winRestrictedCodeSid* = 18 + winTerminalServerSid* = 19 + winRemoteLogonIdSid* = 20 + winLogonIdsSid* = 21 + winLocalSystemSid* = 22 + winLocalServiceSid* = 23 + winNetworkServiceSid* = 24 + winBuiltinDomainSid* = 25 + winBuiltinAdministratorsSid* = 26 + winBuiltinUsersSid* = 27 + winBuiltinGuestsSid* = 28 + winBuiltinPowerUsersSid* = 29 + winBuiltinAccountOperatorsSid* = 30 + winBuiltinSystemOperatorsSid* = 31 + winBuiltinPrintOperatorsSid* = 32 + winBuiltinBackupOperatorsSid* = 33 + winBuiltinReplicatorSid* = 34 + winBuiltinPreWindows2000CompatibleAccessSid* = 35 + winBuiltinRemoteDesktopUsersSid* = 36 + winBuiltinNetworkConfigurationOperatorsSid* = 37 + winAccountAdministratorSid* = 38 + winAccountGuestSid* = 39 + winAccountKrbtgtSid* = 40 + winAccountDomainAdminsSid* = 41 + winAccountDomainUsersSid* = 42 + winAccountDomainGuestsSid* = 43 + winAccountComputersSid* = 44 + winAccountControllersSid* = 45 + winAccountCertAdminsSid* = 46 + winAccountSchemaAdminsSid* = 47 + winAccountEnterpriseAdminsSid* = 48 + winAccountPolicyAdminsSid* = 49 + winAccountRasAndIasServersSid* = 50 + winNTLMAuthenticationSid* = 51 + winDigestAuthenticationSid* = 52 + winSChannelAuthenticationSid* = 53 + winThisOrganizationSid* = 54 + winOtherOrganizationSid* = 55 + winBuiltinIncomingForestTrustBuildersSid* = 56 + winBuiltinPerfMonitoringUsersSid* = 57 + winBuiltinPerfLoggingUsersSid* = 58 + winBuiltinAuthorizationAccessSid* = 59 + winBuiltinTerminalServerLicenseServersSid* = 60 + winBuiltinDCOMUsersSid* = 61 + winBuiltinIUsersSid* = 62 + winIUserSid* = 63 + winBuiltinCryptoOperatorsSid* = 64 + winUntrustedLabelSid* = 65 + winLowLabelSid* = 66 + winMediumLabelSid* = 67 + winHighLabelSid* = 68 + winSystemLabelSid* = 69 + winWriteRestrictedCodeSid* = 70 + winCreatorOwnerRightsSid* = 71 + winCacheablePrincipalsGroupSid* = 72 + winNonCacheablePrincipalsGroupSid* = 73 + winEnterpriseReadonlyControllersSid* = 74 + winAccountReadonlyControllersSid* = 75 + winBuiltinEventLogReadersGroup* = 76 + winNewEnterpriseReadonlyControllersSid* = 77 + winBuiltinCertSvcDComAccessGroup* = 78 + winMediumPlusLabelSid* = 79 + winLocalLogonSid* = 80 + winConsoleLogonSid* = 81 + winThisOrganizationCertificateSid* = 82 + winApplicationPackageAuthoritySid* = 83 + winBuiltinAnyPackageSid* = 84 + winCapabilityInternetClientSid* = 85 + winCapabilityInternetClientServerSid* = 86 + winCapabilityPrivateNetworkClientServerSid* = 87 + winCapabilityPicturesLibrarySid* = 88 + winCapabilityVideosLibrarySid* = 89 + winCapabilityMusicLibrarySid* = 90 + winCapabilityDocumentsLibrarySid* = 91 + winCapabilitySharedUserCertificatesSid* = 92 + winCapabilityEnterpriseAuthenticationSid* = 93 + winCapabilityRemovableStorageSid* = 94 + winBuiltinRDSRemoteAccessServersSid* = 95 + winBuiltinRDSEndpointServersSid* = 96 + winBuiltinRDSManagementServersSid* = 97 + winUserModeDriversSid* = 98 + winBuiltinHyperVAdminsSid* = 99 + winAccountCloneableControllersSid* = 100 + winBuiltinAccessControlAssistanceOperatorsSid* = 101 + winBuiltinRemoteManagementUsersSid* = 102 + winAuthenticationAuthorityAssertedSid* = 103 + winAuthenticationServiceAssertedSid* = 104 + SE_GROUP_MANDATORY* = 0x00000001 + SE_GROUP_ENABLED_BY_DEFAULT* = 0x00000002 + SE_GROUP_ENABLED* = 0x00000004 + SE_GROUP_OWNER* = 0x00000008 + SE_GROUP_USE_FOR_DENY_ONLY* = 0x00000010 + SE_GROUP_INTEGRITY* = 0x00000020 + SE_GROUP_INTEGRITY_ENABLED* = 0x00000040 + SE_GROUP_LOGON_ID* = 0xC0000000'i32 + SE_GROUP_RESOURCE* = 0x20000000 + SE_GROUP_VALID_ATTRIBUTES* = SE_GROUP_MANDATORY or SE_GROUP_ENABLED_BY_DEFAULT or SE_GROUP_ENABLED or SE_GROUP_OWNER or SE_GROUP_USE_FOR_DENY_ONLY or SE_GROUP_LOGON_ID or SE_GROUP_RESOURCE or SE_GROUP_INTEGRITY or SE_GROUP_INTEGRITY_ENABLED + ACL_REVISION* = 2 + ACL_REVISION_DS* = 4 + ACL_REVISION1* = 1 + ACL_REVISION2* = 2 + MIN_ACL_REVISION* = ACL_REVISION2 + ACL_REVISION3* = 3 + ACL_REVISION4* = 4 + MAX_ACL_REVISION* = ACL_REVISION4 + ACCESS_MIN_MS_ACE_TYPE* = 0x0 + ACCESS_ALLOWED_ACE_TYPE* = 0x0 + ACCESS_DENIED_ACE_TYPE* = 0x1 + SYSTEM_AUDIT_ACE_TYPE* = 0x2 + SYSTEM_ALARM_ACE_TYPE* = 0x3 + ACCESS_MAX_MS_V2_ACE_TYPE* = 0x3 + ACCESS_ALLOWED_COMPOUND_ACE_TYPE* = 0x4 + ACCESS_MAX_MS_V3_ACE_TYPE* = 0x4 + ACCESS_MIN_MS_OBJECT_ACE_TYPE* = 0x5 + ACCESS_ALLOWED_OBJECT_ACE_TYPE* = 0x5 + ACCESS_DENIED_OBJECT_ACE_TYPE* = 0x6 + SYSTEM_AUDIT_OBJECT_ACE_TYPE* = 0x7 + SYSTEM_ALARM_OBJECT_ACE_TYPE* = 0x8 + ACCESS_MAX_MS_OBJECT_ACE_TYPE* = 0x8 + ACCESS_MAX_MS_V4_ACE_TYPE* = 0x8 + ACCESS_MAX_MS_ACE_TYPE* = 0x8 + ACCESS_ALLOWED_CALLBACK_ACE_TYPE* = 0x9 + ACCESS_DENIED_CALLBACK_ACE_TYPE* = 0xA + ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE* = 0xB + ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE* = 0xC + SYSTEM_AUDIT_CALLBACK_ACE_TYPE* = 0xD + SYSTEM_ALARM_CALLBACK_ACE_TYPE* = 0xE + SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE* = 0xF + SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE* = 0x10 + SYSTEM_MANDATORY_LABEL_ACE_TYPE* = 0x11 + SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE* = 0x12 + SYSTEM_SCOPED_POLICY_ID_ACE_TYPE* = 0x13 + ACCESS_MAX_MS_V5_ACE_TYPE* = 0x13 + OBJECT_INHERIT_ACE* = 0x1 + CONTAINER_INHERIT_ACE* = 0x2 + NO_PROPAGATE_INHERIT_ACE* = 0x4 + INHERIT_ONLY_ACE* = 0x8 + INHERITED_ACE* = 0x10 + VALID_INHERIT_FLAGS* = 0x1F + SUCCESSFUL_ACCESS_ACE_FLAG* = 0x40 + FAILED_ACCESS_ACE_FLAG* = 0x80 + SYSTEM_MANDATORY_LABEL_NO_WRITE_UP* = 0x1 + SYSTEM_MANDATORY_LABEL_NO_READ_UP* = 0x2 + SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP* = 0x4 + SYSTEM_MANDATORY_LABEL_VALID_MASK* = SYSTEM_MANDATORY_LABEL_NO_WRITE_UP or SYSTEM_MANDATORY_LABEL_NO_READ_UP or SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP + ACE_OBJECT_TYPE_PRESENT* = 0x1 + ACE_INHERITED_OBJECT_TYPE_PRESENT* = 0x2 + aclRevisionInformation* = 1 + aclSizeInformation* = 2 + SECURITY_DESCRIPTOR_REVISION* = 1 + SECURITY_DESCRIPTOR_REVISION1* = 1 + SE_OWNER_DEFAULTED* = 0x0001 + SE_GROUP_DEFAULTED* = 0x0002 + SE_DACL_PRESENT* = 0x0004 + SE_DACL_DEFAULTED* = 0x0008 + SE_SACL_PRESENT* = 0x0010 + SE_SACL_DEFAULTED* = 0x0020 + SE_DACL_AUTO_INHERIT_REQ* = 0x0100 + SE_SACL_AUTO_INHERIT_REQ* = 0x0200 + SE_DACL_AUTO_INHERITED* = 0x0400 + SE_SACL_AUTO_INHERITED* = 0x0800 + SE_DACL_PROTECTED* = 0x1000 + SE_SACL_PROTECTED* = 0x2000 + SE_RM_CONTROL_VALID* = 0x4000 + SE_SELF_RELATIVE* = 0x8000 + ACCESS_OBJECT_GUID* = 0 + ACCESS_PROPERTY_SET_GUID* = 1 + ACCESS_PROPERTY_GUID* = 2 + ACCESS_MAX_LEVEL* = 4 + auditEventObjectAccess* = 0 + auditEventDirectoryServiceAccess* = 1 + AUDIT_ALLOW_NO_PRIVILEGE* = 0x1 + ACCESS_DS_SOURCE_A* = "DS" + ACCESS_DS_SOURCE_W* = "DS" + ACCESS_DS_OBJECT_TYPE_NAME_A* = "Directory Service Object" + ACCESS_DS_OBJECT_TYPE_NAME_W* = "Directory Service Object" + SE_PRIVILEGE_ENABLED_BY_DEFAULT* = 0x00000001 + SE_PRIVILEGE_ENABLED* = 0x00000002 + SE_PRIVILEGE_REMOVED* = 0X00000004 + SE_PRIVILEGE_USED_FOR_ACCESS* = 0x80000000'i32 + SE_PRIVILEGE_VALID_ATTRIBUTES* = SE_PRIVILEGE_ENABLED_BY_DEFAULT or SE_PRIVILEGE_ENABLED or SE_PRIVILEGE_REMOVED or SE_PRIVILEGE_USED_FOR_ACCESS + PRIVILEGE_SET_ALL_NECESSARY* = 1 + ACCESS_REASON_TYPE_MASK* = 0x00ff0000 + ACCESS_REASON_DATA_MASK* = 0x0000ffff + ACCESS_REASON_STAGING_MASK* = 0x80000000'i32 + ACCESS_REASON_EXDATA_MASK* = 0x7f000000 + accessReasonNone* = 0x00000000 + accessReasonAllowedAce* = 0x00010000 + accessReasonDeniedAce* = 0x00020000 + accessReasonAllowedParentAce* = 0x00030000 + accessReasonDeniedParentAce* = 0x00040000 + accessReasonNotGrantedByCape* = 0x00050000 + accessReasonNotGrantedByParentCape* = 0x00060000 + accessReasonNotGrantedToAppContainer* = 0x00070000 + accessReasonMissingPrivilege* = 0x00100000 + accessReasonFromPrivilege* = 0x00200000 + accessReasonIntegrityLevel* = 0x00300000 + accessReasonOwnership* = 0x00400000 + accessReasonNullDacl* = 0x00500000 + accessReasonEmptyDacl* = 0x00600000 + accessReasonNoSD* = 0x00700000 + accessReasonNoGrant* = 0x00800000 + SE_SECURITY_DESCRIPTOR_FLAG_NO_OWNER_ACE* = 0x00000001 + SE_SECURITY_DESCRIPTOR_FLAG_NO_LABEL_ACE* = 0x00000002 + SE_SECURITY_DESCRIPTOR_VALID_FLAGS* = 0x00000003 + SE_CREATE_TOKEN_NAME* = "SeCreateTokenPrivilege" + SE_ASSIGNPRIMARYTOKEN_NAME* = "SeAssignPrimaryTokenPrivilege" + SE_LOCK_MEMORY_NAME* = "SeLockMemoryPrivilege" + SE_INCREASE_QUOTA_NAME* = "SeIncreaseQuotaPrivilege" + SE_UNSOLICITED_INPUT_NAME* = "SeUnsolicitedInputPrivilege" + SE_MACHINE_ACCOUNT_NAME* = "SeMachineAccountPrivilege" + SE_TCB_NAME* = "SeTcbPrivilege" + SE_SECURITY_NAME* = "SeSecurityPrivilege" + SE_TAKE_OWNERSHIP_NAME* = "SeTakeOwnershipPrivilege" + SE_LOAD_DRIVER_NAME* = "SeLoadDriverPrivilege" + SE_SYSTEM_PROFILE_NAME* = "SeSystemProfilePrivilege" + SE_SYSTEMTIME_NAME* = "SeSystemtimePrivilege" + SE_PROF_SINGLE_PROCESS_NAME* = "SeProfileSingleProcessPrivilege" + SE_INC_BASE_PRIORITY_NAME* = "SeIncreaseBasePriorityPrivilege" + SE_CREATE_PAGEFILE_NAME* = "SeCreatePagefilePrivilege" + SE_CREATE_PERMANENT_NAME* = "SeCreatePermanentPrivilege" + SE_BACKUP_NAME* = "SeBackupPrivilege" + SE_RESTORE_NAME* = "SeRestorePrivilege" + SE_SHUTDOWN_NAME* = "SeShutdownPrivilege" + SE_DEBUG_NAME* = "SeDebugPrivilege" + SE_AUDIT_NAME* = "SeAuditPrivilege" + SE_SYSTEM_ENVIRONMENT_NAME* = "SeSystemEnvironmentPrivilege" + SE_CHANGE_NOTIFY_NAME* = "SeChangeNotifyPrivilege" + SE_REMOTE_SHUTDOWN_NAME* = "SeRemoteShutdownPrivilege" + SE_UNDOCK_NAME* = "SeUndockPrivilege" + SE_SYNC_AGENT_NAME* = "SeSyncAgentPrivilege" + SE_ENABLE_DELEGATION_NAME* = "SeEnableDelegationPrivilege" + SE_MANAGE_VOLUME_NAME* = "SeManageVolumePrivilege" + SE_IMPERSONATE_NAME* = "SeImpersonatePrivilege" + SE_CREATE_GLOBAL_NAME* = "SeCreateGlobalPrivilege" + SE_TRUSTED_CREDMAN_ACCESS_NAME* = "SeTrustedCredManAccessPrivilege" + SE_RELABEL_NAME* = "SeRelabelPrivilege" + SE_INC_WORKING_SET_NAME* = "SeIncreaseWorkingSetPrivilege" + SE_TIME_ZONE_NAME* = "SeTimeZonePrivilege" + SE_CREATE_SYMBOLIC_LINK_NAME* = "SeCreateSymbolicLinkPrivilege" + securityAnonymous* = 0 + securityIdentification* = 1 + securityImpersonation* = 2 + securityDelegation* = 3 + SECURITY_MAX_IMPERSONATION_LEVEL* = securityDelegation + SECURITY_MIN_IMPERSONATION_LEVEL* = securityAnonymous + DEFAULT_IMPERSONATION_LEVEL* = securityImpersonation + TOKEN_ASSIGN_PRIMARY* = 0x0001 + TOKEN_DUPLICATE* = 0x0002 + TOKEN_IMPERSONATE* = 0x0004 + TOKEN_QUERY* = 0x0008 + TOKEN_QUERY_SOURCE* = 0x0010 + TOKEN_ADJUST_PRIVILEGES* = 0x0020 + TOKEN_ADJUST_GROUPS* = 0x0040 + TOKEN_ADJUST_DEFAULT* = 0x0080 + TOKEN_ADJUST_SESSIONID* = 0x0100 + TOKEN_ALL_ACCESS_P* = STANDARD_RIGHTS_REQUIRED or TOKEN_ASSIGN_PRIMARY or TOKEN_DUPLICATE or TOKEN_IMPERSONATE or TOKEN_QUERY or TOKEN_QUERY_SOURCE or TOKEN_ADJUST_PRIVILEGES or TOKEN_ADJUST_GROUPS or TOKEN_ADJUST_DEFAULT + TOKEN_ALL_ACCESS* = TOKEN_ALL_ACCESS_P or TOKEN_ADJUST_SESSIONID + TOKEN_READ* = STANDARD_RIGHTS_READ or TOKEN_QUERY + TOKEN_WRITE* = STANDARD_RIGHTS_WRITE or TOKEN_ADJUST_PRIVILEGES or TOKEN_ADJUST_GROUPS or TOKEN_ADJUST_DEFAULT + TOKEN_EXECUTE* = STANDARD_RIGHTS_EXECUTE + tokenPrimary* = 1 + tokenImpersonation* = 2 + tokenElevationTypeDefault* = 1 + tokenElevationTypeFull* = 2 + tokenElevationTypeLimited* = 3 + tokenUser* = 1 + tokenGroups* = 2 + tokenPrivileges* = 3 + tokenOwner* = 4 + tokenPrimaryGroup* = 5 + tokenDefaultDacl* = 6 + tokenSource* = 7 + tokenType* = 8 + tokenImpersonationLevel* = 9 + tokenStatistics* = 10 + tokenRestrictedSids* = 11 + tokenSessionId* = 12 + tokenGroupsAndPrivileges* = 13 + tokenSessionReference* = 14 + tokenSandBoxInert* = 15 + tokenAuditPolicy* = 16 + tokenOrigin* = 17 + tokenElevationType* = 18 + tokenLinkedToken* = 19 + tokenElevation* = 20 + tokenHasRestrictions* = 21 + tokenAccessInformation* = 22 + tokenVirtualizationAllowed* = 23 + tokenVirtualizationEnabled* = 24 + tokenIntegrityLevel* = 25 + tokenUIAccess* = 26 + tokenMandatoryPolicy* = 27 + tokenLogonSid* = 28 + tokenIsAppContainer* = 29 + tokenCapabilities* = 30 + tokenAppContainerSid* = 31 + tokenAppContainerNumber* = 32 + tokenUserClaimAttributes* = 33 + tokenDeviceClaimAttributes* = 34 + tokenRestrictedUserClaimAttributes* = 35 + tokenRestrictedDeviceClaimAttributes* = 36 + tokenDeviceGroups* = 37 + tokenRestrictedDeviceGroups* = 38 + tokenSecurityAttributes* = 39 + tokenIsRestricted* = 40 + maxTokenInfoClass* = 41 + TOKEN_MANDATORY_POLICY_OFF* = 0x0 + TOKEN_MANDATORY_POLICY_NO_WRITE_UP* = 0x1 + TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN* = 0x2 + TOKEN_MANDATORY_POLICY_VALID_MASK* = TOKEN_MANDATORY_POLICY_NO_WRITE_UP or TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN + mandatoryLevelUntrusted* = 0 + mandatoryLevelLow* = 1 + mandatoryLevelMedium* = 2 + mandatoryLevelHigh* = 3 + mandatoryLevelSystem* = 4 + mandatoryLevelSecureProcess* = 5 + mandatoryLevelCount* = 6 + CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID* = 0x00 + CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64* = 0x01 + CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64* = 0x02 + CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING* = 0x03 + CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN* = 0x04 + CLAIM_SECURITY_ATTRIBUTE_TYPE_SID* = 0x05 + CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN* = 0x06 + CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING* = 0x10 + CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE* = 0x0001 + CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE* = 0x0002 + CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY* = 0x0004 + CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT* = 0x0008 + CLAIM_SECURITY_ATTRIBUTE_DISABLED* = 0x0010 + CLAIM_SECURITY_ATTRIBUTE_MANDATORY* = 0x0020 + CLAIM_SECURITY_ATTRIBUTE_VALID_FLAGS* = CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE or CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE or CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY or CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT or CLAIM_SECURITY_ATTRIBUTE_DISABLED or CLAIM_SECURITY_ATTRIBUTE_MANDATORY + CLAIM_SECURITY_ATTRIBUTE_CUSTOM_FLAGS* = 0xffff0000'i32 + CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1* = 1 + CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION* = CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1 + SECURITY_DYNAMIC_TRACKING* = TRUE + SECURITY_STATIC_TRACKING* = FALSE + DISABLE_MAX_PRIVILEGE* = 0x1 + SANDBOX_INERT* = 0x2 + LUA_TOKEN* = 0x4 + WRITE_RESTRICTED* = 0x8 + OWNER_SECURITY_INFORMATION* = 0x00000001 + GROUP_SECURITY_INFORMATION* = 0x00000002 + DACL_SECURITY_INFORMATION* = 0x00000004 + SACL_SECURITY_INFORMATION* = 0x00000008 + LABEL_SECURITY_INFORMATION* = 0x00000010 + ATTRIBUTE_SECURITY_INFORMATION* = 0x00000020 + SCOPE_SECURITY_INFORMATION* = 0x00000040 + BACKUP_SECURITY_INFORMATION* = 0x00010000 + PROTECTED_DACL_SECURITY_INFORMATION* = 0x80000000'i32 + PROTECTED_SACL_SECURITY_INFORMATION* = 0x40000000 + UNPROTECTED_DACL_SECURITY_INFORMATION* = 0x20000000 + UNPROTECTED_SACL_SECURITY_INFORMATION* = 0x10000000 + seLearningModeInvalidType* = 0 + seLearningModeSettings* = 1 + seLearningModeMax* = 2 + SE_LEARNING_MODE_FLAG_PERMISSIVE* = 0x00000001 + PROCESS_TERMINATE* = 0x0001 + PROCESS_CREATE_THREAD* = 0x0002 + PROCESS_SET_SESSIONID* = 0x0004 + PROCESS_VM_OPERATION* = 0x0008 + PROCESS_VM_READ* = 0x0010 + PROCESS_VM_WRITE* = 0x0020 + PROCESS_DUP_HANDLE* = 0x0040 + PROCESS_CREATE_PROCESS* = 0x0080 + PROCESS_SET_QUOTA* = 0x0100 + PROCESS_SET_INFORMATION* = 0x0200 + PROCESS_QUERY_INFORMATION* = 0x0400 + PROCESS_SUSPEND_RESUME* = 0x0800 + PROCESS_QUERY_LIMITED_INFORMATION* = 0x1000 + PROCESS_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0xffff +when winimCpu64: + const + MAXIMUM_PROC_PER_GROUP* = 64 +when winimCpu32: + const + MAXIMUM_PROC_PER_GROUP* = 32 +const + MAXIMUM_PROCESSORS* = MAXIMUM_PROC_PER_GROUP + THREAD_TERMINATE* = 0x0001 + THREAD_SUSPEND_RESUME* = 0x0002 + THREAD_GET_CONTEXT* = 0x0008 + THREAD_SET_CONTEXT* = 0x0010 + THREAD_SET_INFORMATION* = 0x0020 + THREAD_QUERY_INFORMATION* = 0x0040 + THREAD_SET_THREAD_TOKEN* = 0x0080 + THREAD_IMPERSONATE* = 0x0100 + THREAD_DIRECT_IMPERSONATION* = 0x0200 + THREAD_SET_LIMITED_INFORMATION* = 0x0400 + THREAD_QUERY_LIMITED_INFORMATION* = 0x0800 + THREAD_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0xffff + JOB_OBJECT_ASSIGN_PROCESS* = 0x0001 + JOB_OBJECT_SET_ATTRIBUTES* = 0x0002 + JOB_OBJECT_QUERY* = 0x0004 + JOB_OBJECT_TERMINATE* = 0x0008 + JOB_OBJECT_SET_SECURITY_ATTRIBUTES* = 0x0010 + JOB_OBJECT_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x1F + FLS_MAXIMUM_AVAILABLE* = 128 + TLS_MINIMUM_AVAILABLE* = 64 + THREAD_BASE_PRIORITY_LOWRT* = 15 + THREAD_BASE_PRIORITY_MAX* = 2 + THREAD_BASE_PRIORITY_MIN* = -2 + THREAD_BASE_PRIORITY_IDLE* = -15 + QUOTA_LIMITS_HARDWS_MIN_ENABLE* = 0x00000001 + QUOTA_LIMITS_HARDWS_MIN_DISABLE* = 0x00000002 + QUOTA_LIMITS_HARDWS_MAX_ENABLE* = 0x00000004 + QUOTA_LIMITS_HARDWS_MAX_DISABLE* = 0x00000008 + QUOTA_LIMITS_USE_DEFAULT_LIMITS* = 0x00000010 + THREAD_PROFILING_FLAG_DISPATCH* = 0x1 + pMCCounter* = 0 + maxHardwareCounterType* = 1 + processDEPPolicy* = 0 + processASLRPolicy* = 1 + processReserved1MitigationPolicy* = 2 + processStrictHandleCheckPolicy* = 3 + processSystemCallDisablePolicy* = 4 + processMitigationOptionsMask* = 5 + processExtensionPointDisablePolicy* = 6 + maxProcessMitigationPolicy* = 7 + toleranceLow* = 1 + toleranceMedium* = 2 + toleranceHigh* = 3 + toleranceIntervalShort* = 1 + toleranceIntervalMedium* = 2 + toleranceIntervalLong* = 3 + JOB_OBJECT_TERMINATE_AT_END_OF_JOB* = 0 + JOB_OBJECT_POST_AT_END_OF_JOB* = 1 + JOB_OBJECT_MSG_END_OF_JOB_TIME* = 1 + JOB_OBJECT_MSG_END_OF_PROCESS_TIME* = 2 + JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT* = 3 + JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO* = 4 + JOB_OBJECT_MSG_NEW_PROCESS* = 6 + JOB_OBJECT_MSG_EXIT_PROCESS* = 7 + JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS* = 8 + JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT* = 9 + JOB_OBJECT_MSG_JOB_MEMORY_LIMIT* = 10 + JOB_OBJECT_MSG_NOTIFICATION_LIMIT* = 11 + JOB_OBJECT_MSG_JOB_CYCLE_TIME_LIMIT* = 12 + JOB_OBJECT_MSG_MINIMUM* = 1 + JOB_OBJECT_MSG_MAXIMUM* = 12 + JOB_OBJECT_LIMIT_WORKINGSET* = 0x00000001 + JOB_OBJECT_LIMIT_PROCESS_TIME* = 0x00000002 + JOB_OBJECT_LIMIT_JOB_TIME* = 0x00000004 + JOB_OBJECT_LIMIT_ACTIVE_PROCESS* = 0x00000008 + JOB_OBJECT_LIMIT_AFFINITY* = 0x00000010 + JOB_OBJECT_LIMIT_PRIORITY_CLASS* = 0x00000020 + JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME* = 0x00000040 + JOB_OBJECT_LIMIT_SCHEDULING_CLASS* = 0x00000080 + JOB_OBJECT_LIMIT_PROCESS_MEMORY* = 0x00000100 + JOB_OBJECT_LIMIT_JOB_MEMORY* = 0x00000200 + JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION* = 0x00000400 + JOB_OBJECT_LIMIT_BREAKAWAY_OK* = 0x00000800 + JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK* = 0x00001000 + JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE* = 0x00002000 + JOB_OBJECT_LIMIT_SUBSET_AFFINITY* = 0x00004000 + JOB_OBJECT_LIMIT_RESERVED3* = 0x00008000 + JOB_OBJECT_LIMIT_JOB_READ_BYTES* = 0x00010000 + JOB_OBJECT_LIMIT_JOB_WRITE_BYTES* = 0x00020000 + JOB_OBJECT_LIMIT_RATE_CONTROL* = 0x00040000 + JOB_OBJECT_LIMIT_RESERVED4* = 0x00010000 + JOB_OBJECT_LIMIT_RESERVED5* = 0x00020000 + JOB_OBJECT_LIMIT_RESERVED6* = 0x00040000 + JOB_OBJECT_LIMIT_VALID_FLAGS* = 0x0007ffff + JOB_OBJECT_BASIC_LIMIT_VALID_FLAGS* = 0x000000ff + JOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGS* = 0x00007fff + JOB_OBJECT_RESERVED_LIMIT_VALID_FLAGS* = 0x0007ffff + JOB_OBJECT_NOTIFICATION_LIMIT_VALID_FLAGS* = 0x00070204 + JOB_OBJECT_UILIMIT_NONE* = 0x00000000 + JOB_OBJECT_UILIMIT_HANDLES* = 0x00000001 + JOB_OBJECT_UILIMIT_READCLIPBOARD* = 0x00000002 + JOB_OBJECT_UILIMIT_WRITECLIPBOARD* = 0x00000004 + JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS* = 0x00000008 + JOB_OBJECT_UILIMIT_DISPLAYSETTINGS* = 0x00000010 + JOB_OBJECT_UILIMIT_GLOBALATOMS* = 0x00000020 + JOB_OBJECT_UILIMIT_DESKTOP* = 0x00000040 + JOB_OBJECT_UILIMIT_EXITWINDOWS* = 0x00000080 + JOB_OBJECT_UILIMIT_ALL* = 0x000000FF + JOB_OBJECT_UI_VALID_FLAGS* = 0x000000FF + JOB_OBJECT_SECURITY_NO_ADMIN* = 0x00000001 + JOB_OBJECT_SECURITY_RESTRICTED_TOKEN* = 0x00000002 + JOB_OBJECT_SECURITY_ONLY_TOKEN* = 0x00000004 + JOB_OBJECT_SECURITY_FILTER_TOKENS* = 0x00000008 + JOB_OBJECT_SECURITY_VALID_FLAGS* = 0x0000000f + JOB_OBJECT_CPU_RATE_CONTROL_ENABLE* = 0x1 + JOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASED* = 0x2 + JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP* = 0x4 + JOB_OBJECT_CPU_RATE_CONTROL_NOTIFY* = 0x8 + JOB_OBJECT_CPU_RATE_CONTROL_VALID_FLAGS* = 0xf + jobObjectBasicAccountingInformation* = 1 + jobObjectBasicLimitInformation* = 2 + jobObjectBasicProcessIdList* = 3 + jobObjectBasicUIRestrictions* = 4 + jobObjectSecurityLimitInformation* = 5 + jobObjectEndOfJobTimeInformation* = 6 + jobObjectAssociateCompletionPortInformation* = 7 + jobObjectBasicAndIoAccountingInformation* = 8 + jobObjectExtendedLimitInformation* = 9 + jobObjectJobSetInformation* = 10 + jobObjectGroupInformation* = 11 + jobObjectNotificationLimitInformation* = 12 + jobObjectLimitViolationInformation* = 13 + jobObjectGroupInformationEx* = 14 + jobObjectCpuRateControlInformation* = 15 + jobObjectCompletionFilter* = 16 + jobObjectCompletionCounter* = 17 + jobObjectReserved1Information* = 18 + jobObjectReserved2Information* = 19 + jobObjectReserved3Information* = 20 + jobObjectReserved4Information* = 21 + jobObjectReserved5Information* = 22 + jobObjectReserved6Information* = 23 + jobObjectReserved7Information* = 24 + jobObjectReserved8Information* = 25 + maxJobObjectInfoClass* = 26 + firmwareTypeUnknown* = 0 + firmwareTypeBios* = 1 + firmwareTypeUefi* = 2 + firmwareTypeMax* = 3 + EVENT_MODIFY_STATE* = 0x0002 + EVENT_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x3 + MUTANT_QUERY_STATE* = 0x0001 + MUTANT_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or MUTANT_QUERY_STATE + SEMAPHORE_MODIFY_STATE* = 0x0002 + SEMAPHORE_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x3 + TIMER_QUERY_STATE* = 0x0001 + TIMER_MODIFY_STATE* = 0x0002 + TIMER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or TIMER_QUERY_STATE or TIMER_MODIFY_STATE + TIME_ZONE_ID_UNKNOWN* = 0 + TIME_ZONE_ID_STANDARD* = 1 + TIME_ZONE_ID_DAYLIGHT* = 2 + relationProcessorCore* = 0 + relationNumaNode* = 1 + relationCache* = 2 + relationProcessorPackage* = 3 + relationGroup* = 4 + relationAll* = 0xffff + LTP_PC_SMT* = 0x1 + cacheUnified* = 0 + cacheInstruction* = 1 + cacheData* = 2 + cacheTrace* = 3 + CACHE_FULLY_ASSOCIATIVE* = 0xFF + PROCESSOR_INTEL_386* = 386 + PROCESSOR_INTEL_486* = 486 + PROCESSOR_INTEL_PENTIUM* = 586 + PROCESSOR_INTEL_IA64* = 2200 + PROCESSOR_AMD_X8664* = 8664 + PROCESSOR_MIPS_R4000* = 4000 + PROCESSOR_ALPHA_21064* = 21064 + PROCESSOR_PPC_601* = 601 + PROCESSOR_PPC_603* = 603 + PROCESSOR_PPC_604* = 604 + PROCESSOR_PPC_620* = 620 + PROCESSOR_HITACHI_SH3* = 10003 + PROCESSOR_HITACHI_SH3E* = 10004 + PROCESSOR_HITACHI_SH4* = 10005 + PROCESSOR_MOTOROLA_821* = 821 + PROCESSOR_SHx_SH3* = 103 + PROCESSOR_SHx_SH4* = 104 + PROCESSOR_STRONGARM* = 2577 + PROCESSOR_ARM720* = 1824 + PROCESSOR_ARM820* = 2080 + PROCESSOR_ARM920* = 2336 + PROCESSOR_ARM_7TDMI* = 70001 + PROCESSOR_OPTIL* = 0x494f + PROCESSOR_ARCHITECTURE_INTEL* = 0 + PROCESSOR_ARCHITECTURE_MIPS* = 1 + PROCESSOR_ARCHITECTURE_ALPHA* = 2 + PROCESSOR_ARCHITECTURE_PPC* = 3 + PROCESSOR_ARCHITECTURE_SHX* = 4 + PROCESSOR_ARCHITECTURE_ARM* = 5 + PROCESSOR_ARCHITECTURE_IA64* = 6 + PROCESSOR_ARCHITECTURE_ALPHA64* = 7 + PROCESSOR_ARCHITECTURE_MSIL* = 8 + PROCESSOR_ARCHITECTURE_AMD64* = 9 + PROCESSOR_ARCHITECTURE_IA32_ON_WIN64* = 10 + PROCESSOR_ARCHITECTURE_NEUTRAL* = 11 + PROCESSOR_ARCHITECTURE_UNKNOWN* = 0xffff + PF_FLOATING_POINT_PRECISION_ERRATA* = 0 + PF_FLOATING_POINT_EMULATED* = 1 + PF_COMPARE_EXCHANGE_DOUBLE* = 2 + PF_MMX_INSTRUCTIONS_AVAILABLE* = 3 + PF_PPC_MOVEMEM_64BIT_OK* = 4 + PF_ALPHA_BYTE_INSTRUCTIONS* = 5 + PF_XMMI_INSTRUCTIONS_AVAILABLE* = 6 + PF_3DNOW_INSTRUCTIONS_AVAILABLE* = 7 + PF_RDTSC_INSTRUCTION_AVAILABLE* = 8 + PF_PAE_ENABLED* = 9 + PF_XMMI64_INSTRUCTIONS_AVAILABLE* = 10 + PF_SSE_DAZ_MODE_AVAILABLE* = 11 + PF_NX_ENABLED* = 12 + PF_SSE3_INSTRUCTIONS_AVAILABLE* = 13 + PF_COMPARE_EXCHANGE128* = 14 + PF_COMPARE64_EXCHANGE128* = 15 + PF_CHANNELS_ENABLED* = 16 + PF_XSAVE_ENABLED* = 17 + PF_ARM_VFP_32_REGISTERS_AVAILABLE* = 18 + PF_ARM_NEON_INSTRUCTIONS_AVAILABLE* = 19 + PF_SECOND_LEVEL_ADDRESS_TRANSLATION* = 20 + PF_VIRT_FIRMWARE_ENABLED* = 21 + PF_RDWRFSGSBASE_AVAILABLE* = 22 + PF_FASTFAIL_AVAILABLE* = 23 + PF_ARM_DIVIDE_INSTRUCTION_AVAILABLE* = 24 + PF_ARM_64BIT_LOADSTORE_ATOMIC* = 25 + PF_ARM_EXTERNAL_CACHE_AVAILABLE* = 26 + PF_ARM_FMAC_INSTRUCTIONS_AVAILABLE* = 27 + XSTATE_LEGACY_FLOATING_POINT* = 0 + XSTATE_LEGACY_SSE* = 1 + XSTATE_GSSE* = 2 + XSTATE_AVX* = XSTATE_GSSE + XSTATE_MASK_LEGACY_FLOATING_POINT* = 1 shl (XSTATE_LEGACY_FLOATING_POINT) + XSTATE_MASK_LEGACY_SSE* = 1 shl (XSTATE_LEGACY_SSE) + XSTATE_MASK_LEGACY* = XSTATE_MASK_LEGACY_FLOATING_POINT or XSTATE_MASK_LEGACY_SSE + XSTATE_MASK_GSSE* = 1 shl (XSTATE_GSSE) + XSTATE_MASK_AVX* = XSTATE_MASK_GSSE + SECTION_QUERY* = 0x0001 + SECTION_MAP_WRITE* = 0x0002 + SECTION_MAP_READ* = 0x0004 + SECTION_MAP_EXECUTE* = 0x0008 + SECTION_EXTEND_SIZE* = 0x0010 + SECTION_MAP_EXECUTE_EXPLICIT* = 0x0020 + SECTION_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SECTION_QUERY or SECTION_MAP_WRITE or SECTION_MAP_READ or SECTION_MAP_EXECUTE or SECTION_EXTEND_SIZE + SESSION_QUERY_ACCESS* = 0x1 + SESSION_MODIFY_ACCESS* = 0x2 + SESSION_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SESSION_QUERY_ACCESS or SESSION_MODIFY_ACCESS + PAGE_NOACCESS* = 0x01 + PAGE_READONLY* = 0x02 + PAGE_READWRITE* = 0x04 + PAGE_WRITECOPY* = 0x08 + PAGE_EXECUTE* = 0x10 + PAGE_EXECUTE_READ* = 0x20 + PAGE_EXECUTE_READWRITE* = 0x40 + PAGE_EXECUTE_WRITECOPY* = 0x80 + PAGE_GUARD* = 0x100 + PAGE_NOCACHE* = 0x200 + PAGE_WRITECOMBINE* = 0x400 + MEM_COMMIT* = 0x1000 + MEM_RESERVE* = 0x2000 + MEM_DECOMMIT* = 0x4000 + MEM_RELEASE* = 0x8000 + MEM_FREE* = 0x10000 + MEM_PRIVATE* = 0x20000 + MEM_MAPPED* = 0x40000 + MEM_RESET* = 0x80000 + MEM_TOP_DOWN* = 0x100000 + MEM_WRITE_WATCH* = 0x200000 + MEM_PHYSICAL* = 0x400000 + MEM_ROTATE* = 0x800000 + MEM_LARGE_PAGES* = 0x20000000 + MEM_4MB_PAGES* = 0x80000000'i32 + SEC_FILE* = 0x800000 + SEC_IMAGE* = 0x1000000 + SEC_PROTECTED_IMAGE* = 0x2000000 + SEC_RESERVE* = 0x4000000 + SEC_COMMIT* = 0x8000000 + SEC_NOCACHE* = 0x10000000 + SEC_WRITECOMBINE* = 0x40000000 + SEC_LARGE_PAGES* = 0x80000000'i32 + SEC_IMAGE_NO_EXECUTE* = SEC_IMAGE or SEC_NOCACHE + MEM_IMAGE* = SEC_IMAGE + WRITE_WATCH_FLAG_RESET* = 0x01 + MEM_UNMAP_WITH_TRANSIENT_BOOST* = 0x01 + FILE_READ_DATA* = 0x0001 + FILE_LIST_DIRECTORY* = 0x0001 + FILE_WRITE_DATA* = 0x0002 + FILE_ADD_FILE* = 0x0002 + FILE_APPEND_DATA* = 0x0004 + FILE_ADD_SUBDIRECTORY* = 0x0004 + FILE_CREATE_PIPE_INSTANCE* = 0x0004 + FILE_READ_EA* = 0x0008 + FILE_WRITE_EA* = 0x0010 + FILE_EXECUTE* = 0x0020 + FILE_TRAVERSE* = 0x0020 + FILE_DELETE_CHILD* = 0x0040 + FILE_READ_ATTRIBUTES* = 0x0080 + FILE_WRITE_ATTRIBUTES* = 0x0100 + FILE_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x1FF + FILE_GENERIC_READ* = STANDARD_RIGHTS_READ or FILE_READ_DATA or FILE_READ_ATTRIBUTES or FILE_READ_EA or SYNCHRONIZE + FILE_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or FILE_WRITE_DATA or FILE_WRITE_ATTRIBUTES or FILE_WRITE_EA or FILE_APPEND_DATA or SYNCHRONIZE + FILE_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE or FILE_READ_ATTRIBUTES or FILE_EXECUTE or SYNCHRONIZE + FILE_ATTRIBUTE_READONLY* = 0x00000001 + FILE_ATTRIBUTE_HIDDEN* = 0x00000002 + FILE_ATTRIBUTE_SYSTEM* = 0x00000004 + FILE_ATTRIBUTE_DIRECTORY* = 0x00000010 + FILE_ATTRIBUTE_ARCHIVE* = 0x00000020 + FILE_ATTRIBUTE_DEVICE* = 0x00000040 + FILE_ATTRIBUTE_NORMAL* = 0x00000080 + FILE_ATTRIBUTE_TEMPORARY* = 0x00000100 + FILE_ATTRIBUTE_SPARSE_FILE* = 0x00000200 + FILE_ATTRIBUTE_REPARSE_POINT* = 0x00000400 + FILE_ATTRIBUTE_COMPRESSED* = 0x00000800 + FILE_ATTRIBUTE_OFFLINE* = 0x00001000 + FILE_ATTRIBUTE_NOT_CONTENT_INDEXED* = 0x00002000 + FILE_ATTRIBUTE_ENCRYPTED* = 0x00004000 + FILE_ATTRIBUTE_VIRTUAL* = 0x00010000 + FILE_NOTIFY_CHANGE_FILE_NAME* = 0x00000001 + FILE_NOTIFY_CHANGE_DIR_NAME* = 0x00000002 + FILE_NOTIFY_CHANGE_ATTRIBUTES* = 0x00000004 + FILE_NOTIFY_CHANGE_SIZE* = 0x00000008 + FILE_NOTIFY_CHANGE_LAST_WRITE* = 0x00000010 + FILE_NOTIFY_CHANGE_LAST_ACCESS* = 0x00000020 + FILE_NOTIFY_CHANGE_CREATION* = 0x00000040 + FILE_NOTIFY_CHANGE_SECURITY* = 0x00000100 + FILE_ACTION_ADDED* = 0x00000001 + FILE_ACTION_REMOVED* = 0x00000002 + FILE_ACTION_MODIFIED* = 0x00000003 + FILE_ACTION_RENAMED_OLD_NAME* = 0x00000004 + FILE_ACTION_RENAMED_NEW_NAME* = 0x00000005 + MAILSLOT_NO_MESSAGE* = DWORD(-1) + MAILSLOT_WAIT_FOREVER* = DWORD(-1) + FILE_CASE_SENSITIVE_SEARCH* = 0x00000001 + FILE_CASE_PRESERVED_NAMES* = 0x00000002 + FILE_UNICODE_ON_DISK* = 0x00000004 + FILE_PERSISTENT_ACLS* = 0x00000008 + FILE_FILE_COMPRESSION* = 0x00000010 + FILE_VOLUME_QUOTAS* = 0x00000020 + FILE_SUPPORTS_SPARSE_FILES* = 0x00000040 + FILE_SUPPORTS_REPARSE_POINTS* = 0x00000080 + FILE_SUPPORTS_REMOTE_STORAGE* = 0x00000100 + FILE_VOLUME_IS_COMPRESSED* = 0x00008000 + FILE_SUPPORTS_OBJECT_IDS* = 0x00010000 + FILE_SUPPORTS_ENCRYPTION* = 0x00020000 + FILE_NAMED_STREAMS* = 0x00040000 + FILE_READ_ONLY_VOLUME* = 0x00080000 + FILE_SEQUENTIAL_WRITE_ONCE* = 0x00100000 + FILE_SUPPORTS_TRANSACTIONS* = 0x00200000 + FILE_SUPPORTS_HARD_LINKS* = 0x00400000 + FILE_SUPPORTS_EXTENDED_ATTRIBUTES* = 0x00800000 + FILE_SUPPORTS_OPEN_BY_FILE_ID* = 0x01000000 + FILE_SUPPORTS_USN_JOURNAL* = 0x02000000 + FILE_SUPPORTS_INTEGRITY_STREAMS* = 0x04000000 + MAXIMUM_REPARSE_DATA_BUFFER_SIZE* = 16*1024 + SYMLINK_FLAG_RELATIVE* = 1 + IO_REPARSE_TAG_RESERVED_ZERO* = 0 + IO_REPARSE_TAG_RESERVED_ONE* = 1 + IO_REPARSE_TAG_RESERVED_RANGE* = IO_REPARSE_TAG_RESERVED_ONE + IO_REPARSE_TAG_MOUNT_POINT* = 0xA0000003'i32 + IO_REPARSE_TAG_HSM* = 0xC0000004'i32 + IO_REPARSE_TAG_HSM2* = 0x80000006'i32 + IO_REPARSE_TAG_SIS* = 0x80000007'i32 + IO_REPARSE_TAG_WIM* = 0x80000008'i32 + IO_REPARSE_TAG_CSV* = 0x80000009'i32 + IO_REPARSE_TAG_DFS* = 0x8000000A'i32 + IO_REPARSE_TAG_FILTER_MANAGER* = 0x8000000B'i32 + IO_REPARSE_TAG_DFSR* = 0x80000012'i32 + IO_REPARSE_TAG_SYMLINK* = 0xA000000C'i32 + IO_REPARSE_TAG_IIS_CACHE* = 0xA0000010'i32 + IO_REPARSE_TAG_DRIVE_EXTENDER* = 0x80000005'i32 + IO_REPARSE_TAG_DEDUP* = 0x80000013'i32 + IO_REPARSE_TAG_NFS* = 0x80000014'i32 + SCRUB_DATA_INPUT_FLAG_RESUME* = 0x00000001 + SCRUB_DATA_INPUT_FLAG_SKIP_IN_SYNC* = 0x00000002 + SCRUB_DATA_INPUT_FLAG_SKIP_NON_INTEGRITY_DATA* = 0x00000004 + SCRUB_DATA_OUTPUT_FLAG_INCOMPLETE* = 0x00000001 + SCRUB_DATA_OUTPUT_FLAG_NON_USER_DATA_RANGE* = 0x00010000 + IO_COMPLETION_MODIFY_STATE* = 0x0002 + IO_COMPLETION_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x3 + DUPLICATE_CLOSE_SOURCE* = 0x00000001 + DUPLICATE_SAME_ACCESS* = 0x00000002 + POWERBUTTON_ACTION_INDEX_NOTHING* = 0 + POWERBUTTON_ACTION_INDEX_SLEEP* = 1 + POWERBUTTON_ACTION_INDEX_HIBERNATE* = 2 + POWERBUTTON_ACTION_INDEX_SHUTDOWN* = 3 + POWERBUTTON_ACTION_VALUE_NOTHING* = 0 + POWERBUTTON_ACTION_VALUE_SLEEP* = 2 + POWERBUTTON_ACTION_VALUE_HIBERNATE* = 3 + POWERBUTTON_ACTION_VALUE_SHUTDOWN* = 6 + PERFSTATE_POLICY_CHANGE_IDEAL* = 0 + PERFSTATE_POLICY_CHANGE_SINGLE* = 1 + PERFSTATE_POLICY_CHANGE_ROCKET* = 2 + PERFSTATE_POLICY_CHANGE_MAX* = PERFSTATE_POLICY_CHANGE_ROCKET + PROCESSOR_PERF_BOOST_POLICY_DISABLED* = 0 + PROCESSOR_PERF_BOOST_POLICY_MAX* = 100 + PROCESSOR_PERF_BOOST_MODE_DISABLED* = 0 + PROCESSOR_PERF_BOOST_MODE_ENABLED* = 1 + PROCESSOR_PERF_BOOST_MODE_AGGRESSIVE* = 2 + PROCESSOR_PERF_BOOST_MODE_EFFICIENT_ENABLED* = 3 + PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE* = 4 + PROCESSOR_PERF_BOOST_MODE_MAX* = PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE + CORE_PARKING_POLICY_CHANGE_IDEAL* = 0 + CORE_PARKING_POLICY_CHANGE_SINGLE* = 1 + CORE_PARKING_POLICY_CHANGE_ROCKET* = 2 + CORE_PARKING_POLICY_CHANGE_MULTISTEP* = 3 + CORE_PARKING_POLICY_CHANGE_MAX* = CORE_PARKING_POLICY_CHANGE_MULTISTEP + POWER_DEVICE_IDLE_POLICY_PERFORMANCE* = 0 + POWER_DEVICE_IDLE_POLICY_CONSERVATIVE* = 1 + GUID_MAX_POWER_SAVINGS* = DEFINE_GUID("a1841308-3541-4fab-bc81-f71556f20b4a") + GUID_MIN_POWER_SAVINGS* = DEFINE_GUID("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c") + GUID_TYPICAL_POWER_SAVINGS* = DEFINE_GUID("381b4222-f694-41f0-9685-ff5bb260df2e") + NO_SUBGROUP_GUID* = DEFINE_GUID("fea3413e-7e05-4911-9a71-700331f1c294") + ALL_POWERSCHEMES_GUID* = DEFINE_GUID("68a1e95e-13ea-41e1-8011-0c496ca490b0") + GUID_POWERSCHEME_PERSONALITY* = DEFINE_GUID("245d8541-3943-4422-b025-13a784f679b7") + GUID_ACTIVE_POWERSCHEME* = DEFINE_GUID("31f9f286-5084-42fe-b720-2b0264993763") + GUID_IDLE_RESILIENCY_SUBGROUP* = DEFINE_GUID("2e601130-5351-4d9d-8e04-252966bad054") + GUID_IDLE_RESILIENCY_PERIOD* = DEFINE_GUID("c42b79aa-aa3a-484b-a98f-2cf32aa90a28") + GUID_DISK_COALESCING_POWERDOWN_TIMEOUT* = DEFINE_GUID("c36f0eb4-2988-4a70-8eee-0884fc2c2433") + GUID_EXECUTION_REQUIRED_REQUEST_TIMEOUT* = DEFINE_GUID("3166bc41-7e98-4e03-b34e-ec0f5f2b218e") + GUID_VIDEO_SUBGROUP* = DEFINE_GUID("7516b95f-f776-4464-8c53-06167f40cc99") + GUID_VIDEO_POWERDOWN_TIMEOUT* = DEFINE_GUID("3c0bc021-c8a8-4e07-a973-6b14cbcb2b7e") + GUID_VIDEO_ANNOYANCE_TIMEOUT* = DEFINE_GUID("82dbcf2d-cd67-40c5-bfdc-9f1a5ccd4663") + GUID_VIDEO_ADAPTIVE_PERCENT_INCREASE* = DEFINE_GUID("eed904df-b142-4183-b10b-5a1197a37864") + GUID_VIDEO_DIM_TIMEOUT* = DEFINE_GUID("17aaa29b-8b43-4b94-aafe-35f64daaf1ee") + GUID_VIDEO_ADAPTIVE_POWERDOWN* = DEFINE_GUID("90959d22-d6a1-49b9-af93-bce885ad335b") + GUID_MONITOR_POWER_ON* = DEFINE_GUID("02731015-4510-4526-99e6-e5a17ebd1aea") + GUID_DEVICE_POWER_POLICY_VIDEO_BRIGHTNESS* = DEFINE_GUID("aded5e82-b909-4619-9949-f5d71dac0bcb") + GUID_DEVICE_POWER_POLICY_VIDEO_DIM_BRIGHTNESS* = DEFINE_GUID("f1fbfde2-a960-4165-9f88-50667911ce96") + GUID_VIDEO_CURRENT_MONITOR_BRIGHTNESS* = DEFINE_GUID("8ffee2c6-2d01-46be-adb9-398addc5b4ff") + GUID_VIDEO_ADAPTIVE_DISPLAY_BRIGHTNESS* = DEFINE_GUID("fbd9aa66-9553-4097-ba44-ed6e9d65eab8") + GUID_CONSOLE_DISPLAY_STATE* = DEFINE_GUID("6fe69556-704a-47a0-8f24-c28d936fda47") + GUID_ALLOW_DISPLAY_REQUIRED* = DEFINE_GUID("a9ceb8da-cd46-44fb-a98b-02af69de4623") + GUID_VIDEO_CONSOLE_LOCK_TIMEOUT* = DEFINE_GUID("8ec4b3a5-6868-48c2-be75-4f3044be88a7") + GUID_ADAPTIVE_POWER_BEHAVIOR_SUBGROUP* = DEFINE_GUID("8619b916-e004-4dd8-9b66-dae86f806698") + GUID_NON_ADAPTIVE_INPUT_TIMEOUT* = DEFINE_GUID("5adbbfbc-074e-4da1-ba38-db8b36b2c8f3") + GUID_DISK_SUBGROUP* = DEFINE_GUID("0012ee47-9041-4b5d-9b77-535fba8b1442") + GUID_DISK_POWERDOWN_TIMEOUT* = DEFINE_GUID("6738e2c4-e8a5-4a42-b16a-e040e769756e") + GUID_DISK_IDLE_TIMEOUT* = DEFINE_GUID("58e39ba8-b8e6-4ef6-90d0-89ae32b258d6") + GUID_DISK_BURST_IGNORE_THRESHOLD* = DEFINE_GUID("80e3c60e-bb94-4ad8-bbe0-0d3195efc663") + GUID_DISK_ADAPTIVE_POWERDOWN* = DEFINE_GUID("396a32e1-499a-40b2-9124-a96afe707667") + GUID_SLEEP_SUBGROUP* = DEFINE_GUID("238c9fa8-0aad-41ed-83f4-97be242c8f20") + GUID_SLEEP_IDLE_THRESHOLD* = DEFINE_GUID("81cd32e0-7833-44f3-8737-7081f38d1f70") + GUID_STANDBY_TIMEOUT* = DEFINE_GUID("29f6c1db-86da-48c5-9fdb-f2b67b1f44da") + GUID_UNATTEND_SLEEP_TIMEOUT* = DEFINE_GUID("7bc4a2f9-d8fc-4469-b07b-33eb785aaca0") + GUID_HIBERNATE_TIMEOUT* = DEFINE_GUID("9d7815a6-7ee4-497e-8888-515a05f02364") + GUID_HIBERNATE_FASTS4_POLICY* = DEFINE_GUID("94ac6d29-73ce-41a6-809f-6363ba21b47e") + GUID_CRITICAL_POWER_TRANSITION* = DEFINE_GUID("b7a27025-e569-46c2-a504-2b96cad225a1") + GUID_SYSTEM_AWAYMODE* = DEFINE_GUID("98a7f580-01f7-48aa-9c0f-44352c29e5c0") + GUID_ALLOW_AWAYMODE* = DEFINE_GUID("25dfa149-5dd1-4736-b5ab-e8a37b5b8187") + GUID_ALLOW_STANDBY_STATES* = DEFINE_GUID("abfc2519-3608-4c2a-94ea-171b0ed546ab") + GUID_ALLOW_RTC_WAKE* = DEFINE_GUID("bd3b718a-0680-4d9d-8ab2-e1d2b4ac806d") + GUID_ALLOW_SYSTEM_REQUIRED* = DEFINE_GUID("a4b195f5-8225-47d8-8012-9d41369786e2") + GUID_SYSTEM_BUTTON_SUBGROUP* = DEFINE_GUID("4f971e89-eebd-4455-a8de-9e59040e7347") + GUID_POWERBUTTON_ACTION* = DEFINE_GUID("7648efa3-dd9c-4e3e-b566-50f929386280") + GUID_SLEEPBUTTON_ACTION* = DEFINE_GUID("96996bc0-ad50-47ec-923b-6f41874dd9eb") + GUID_USERINTERFACEBUTTON_ACTION* = DEFINE_GUID("a7066653-8d6c-40a8-910e-a1f54b84c7e5") + GUID_LIDCLOSE_ACTION* = DEFINE_GUID("5ca83367-6e45-459f-a27b-476b1d01c936") + GUID_LIDOPEN_POWERSTATE* = DEFINE_GUID("99ff10e7-23b1-4c07-a9d1-5c3206d741b4") + GUID_BATTERY_SUBGROUP* = DEFINE_GUID("e73a048d-bf27-4f12-9731-8b2076e8891f") + GUID_BATTERY_DISCHARGE_ACTION_0* = DEFINE_GUID("637ea02f-bbcb-4015-8e2c-a1c7b9c0b546") + GUID_BATTERY_DISCHARGE_LEVEL_0* = DEFINE_GUID("9a66d8d7-4ff7-4ef9-b5a2-5a326ca2a469") + GUID_BATTERY_DISCHARGE_FLAGS_0* = DEFINE_GUID("5dbb7c9f-38e9-40d2-9749-4f8a0e9f640f") + GUID_BATTERY_DISCHARGE_ACTION_1* = DEFINE_GUID("d8742dcb-3e6a-4b3c-b3fe-374623cdcf06") + GUID_BATTERY_DISCHARGE_LEVEL_1* = DEFINE_GUID("8183ba9a-e910-48da-8769-14ae6dc1170a") + GUID_BATTERY_DISCHARGE_FLAGS_1* = DEFINE_GUID("bcded951-187b-4d05-bccc-f7e51960c258") + GUID_BATTERY_DISCHARGE_ACTION_2* = DEFINE_GUID("421cba38-1a8e-4881-ac89-e33a8b04ece4") + GUID_BATTERY_DISCHARGE_LEVEL_2* = DEFINE_GUID("07a07ca2-adaf-40d7-b077-533aaded1bfa") + GUID_BATTERY_DISCHARGE_FLAGS_2* = DEFINE_GUID("7fd2f0c4-feb7-4da3-8117-e3fbedc46582") + GUID_BATTERY_DISCHARGE_ACTION_3* = DEFINE_GUID("80472613-9780-455e-b308-72d3003cf2f8") + GUID_BATTERY_DISCHARGE_LEVEL_3* = DEFINE_GUID("58afd5a6-c2dd-47d2-9fbf-ef70cc5c5965") + GUID_BATTERY_DISCHARGE_FLAGS_3* = DEFINE_GUID("73613ccf-dbfa-4279-8356-4935f6bf62f3") + GUID_PROCESSOR_SETTINGS_SUBGROUP* = DEFINE_GUID("54533251-82be-4824-96c1-47b60b740d00") + GUID_PROCESSOR_THROTTLE_POLICY* = DEFINE_GUID("57027304-4af6-4104-9260-e3d95248fc36") + GUID_PROCESSOR_THROTTLE_MAXIMUM* = DEFINE_GUID("bc5038f7-23e0-4960-96da-33abaf5935ec") + GUID_PROCESSOR_THROTTLE_MINIMUM* = DEFINE_GUID("893dee8e-2bef-41e0-89c6-b55d0929964c") + GUID_PROCESSOR_ALLOW_THROTTLING* = DEFINE_GUID("3b04d4fd-1cc7-4f23-ab1c-d1337819c4bb") + GUID_PROCESSOR_IDLESTATE_POLICY* = DEFINE_GUID("68f262a7-f621-4069-b9a5-4874169be23c") + GUID_PROCESSOR_PERFSTATE_POLICY* = DEFINE_GUID("bbdc3814-18e9-4463-8a55-d197327c45c0") + GUID_PROCESSOR_PERF_INCREASE_THRESHOLD* = DEFINE_GUID("06cadf0e-64ed-448a-8927-ce7bf90eb35d") + GUID_PROCESSOR_PERF_DECREASE_THRESHOLD* = DEFINE_GUID("12a0ab44-fe28-4fa9-b3bd-4b64f44960a6") + GUID_PROCESSOR_PERF_INCREASE_POLICY* = DEFINE_GUID("465e1f50-b610-473a-ab58-00d1077dc418") + GUID_PROCESSOR_PERF_DECREASE_POLICY* = DEFINE_GUID("40fbefc7-2e9d-4d25-a185-0cfd8574bac6") + GUID_PROCESSOR_PERF_INCREASE_TIME* = DEFINE_GUID("984cf492-3bed-4488-a8f9-4286c97bf5aa") + GUID_PROCESSOR_PERF_DECREASE_TIME* = DEFINE_GUID("d8edeb9b-95cf-4f95-a73c-b061973693c8") + GUID_PROCESSOR_PERF_TIME_CHECK* = DEFINE_GUID("4d2b0152-7d5c-498b-88e2-34345392a2c5") + GUID_PROCESSOR_PERF_BOOST_POLICY* = DEFINE_GUID("45bcc044-d885-43e2-8605-ee0ec6e96b59") + GUID_PROCESSOR_PERF_BOOST_MODE* = DEFINE_GUID("be337238-0d82-4146-a960-4f3749d470c7") + GUID_PROCESSOR_IDLE_ALLOW_SCALING* = DEFINE_GUID("6c2993b0-8f48-481f-bcc6-00dd2742aa06") + GUID_PROCESSOR_IDLE_DISABLE* = DEFINE_GUID("5d76a2ca-e8c0-402f-a133-2158492d58ad") + GUID_PROCESSOR_IDLE_STATE_MAXIMUM* = DEFINE_GUID("9943e905-9a30-4ec1-9b99-44dd3b76f7a2") + GUID_PROCESSOR_IDLE_TIME_CHECK* = DEFINE_GUID("c4581c31-89ab-4597-8e2b-9c9cab440e6b") + GUID_PROCESSOR_IDLE_DEMOTE_THRESHOLD* = DEFINE_GUID("4b92d758-5a24-4851-a470-815d78aee119") + GUID_PROCESSOR_IDLE_PROMOTE_THRESHOLD* = DEFINE_GUID("7b224883-b3cc-4d79-819f-8374152cbe7c") + GUID_PROCESSOR_CORE_PARKING_INCREASE_THRESHOLD* = DEFINE_GUID("df142941-20f3-4edf-9a4a-9c83d3d717d1") + GUID_PROCESSOR_CORE_PARKING_DECREASE_THRESHOLD* = DEFINE_GUID("68dd2f27-a4ce-4e11-8487-3794e4135dfa") + GUID_PROCESSOR_CORE_PARKING_INCREASE_POLICY* = DEFINE_GUID("c7be0679-2817-4d69-9d02-519a537ed0c6") + GUID_PROCESSOR_CORE_PARKING_DECREASE_POLICY* = DEFINE_GUID("71021b41-c749-4d21-be74-a00f335d582b") + GUID_PROCESSOR_CORE_PARKING_MAX_CORES* = DEFINE_GUID("ea062031-0e34-4ff1-9b6d-eb1059334028") + GUID_PROCESSOR_CORE_PARKING_MIN_CORES* = DEFINE_GUID("0cc5b647-c1df-4637-891a-dec35c318583") + GUID_PROCESSOR_CORE_PARKING_INCREASE_TIME* = DEFINE_GUID("2ddd5a84-5a71-437e-912a-db0b8c788732") + GUID_PROCESSOR_CORE_PARKING_DECREASE_TIME* = DEFINE_GUID("dfd10d17-d5eb-45dd-877a-9a34ddd15c82") + GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_DECREASE_FACTOR* = DEFINE_GUID("8f7b45e3-c393-480a-878c-f67ac3d07082") + GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_THRESHOLD* = DEFINE_GUID("5b33697b-e89d-4d38-aa46-9e7dfb7cd2f9") + GUID_PROCESSOR_CORE_PARKING_AFFINITY_WEIGHTING* = DEFINE_GUID("e70867f1-fa2f-4f4e-aea1-4d8a0ba23b20") + GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_DECREASE_FACTOR* = DEFINE_GUID("1299023c-bc28-4f0a-81ec-d3295a8d815d") + GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_THRESHOLD* = DEFINE_GUID("9ac18e92-aa3c-4e27-b307-01ae37307129") + GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_WEIGHTING* = DEFINE_GUID("8809c2d8-b155-42d4-bcda-0d345651b1db") + GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_THRESHOLD* = DEFINE_GUID("943c8cb6-6f93-4227-ad87-e9a3feec08d1") + GUID_PROCESSOR_PARKING_CORE_OVERRIDE* = DEFINE_GUID("a55612aa-f624-42c6-a443-7397d064c04f") + GUID_PROCESSOR_PARKING_PERF_STATE* = DEFINE_GUID("447235c7-6a8d-4cc0-8e24-9eaf70b96e2b") + GUID_PROCESSOR_PARKING_CONCURRENCY_THRESHOLD* = DEFINE_GUID("2430ab6f-a520-44a2-9601-f7f23b5134b1") + GUID_PROCESSOR_PARKING_HEADROOM_THRESHOLD* = DEFINE_GUID("f735a673-2066-4f80-a0c5-ddee0cf1bf5d") + GUID_PROCESSOR_PERF_HISTORY* = DEFINE_GUID("7d24baa7-0b84-480f-840c-1b0743c00f5f") + GUID_PROCESSOR_PERF_LATENCY_HINT* = DEFINE_GUID("0822df31-9c83-441c-a079-0de4cf009c7b") + GUID_PROCESSOR_DISTRIBUTE_UTILITY* = DEFINE_GUID("e0007330-f589-42ed-a401-5ddb10e785d3") + GUID_SYSTEM_COOLING_POLICY* = DEFINE_GUID("94d3a615-a899-4ac5-ae2b-e4d8f634367f") + GUID_LOCK_CONSOLE_ON_WAKE* = DEFINE_GUID("0e796bdb-100d-47d6-a2d5-f7d2daa51f51") + GUID_DEVICE_IDLE_POLICY* = DEFINE_GUID("4faab71a-92e5-4726-b531-224559672d19") + GUID_ACDC_POWER_SOURCE* = DEFINE_GUID("5d3e9a59-e9d5-4b00-a6bd-ff34ff516548") + GUID_LIDSWITCH_STATE_CHANGE* = DEFINE_GUID("ba3e0f4d-b817-4094-a2d1-d56379e6a0f3") + GUID_BATTERY_PERCENTAGE_REMAINING* = DEFINE_GUID("a7ad8041-b45a-4cae-87a3-eecbb468a9e1") + GUID_GLOBAL_USER_PRESENCE* = DEFINE_GUID("786e8a1d-b427-4344-9207-09e70bdcbea9") + GUID_SESSION_DISPLAY_STATUS* = DEFINE_GUID("2b84c20e-ad23-4ddf-93db-05ffbd7efca5") + GUID_SESSION_USER_PRESENCE* = DEFINE_GUID("3c0f4548-c03f-4c4d-b9f2-237ede686376") + GUID_IDLE_BACKGROUND_TASK* = DEFINE_GUID("515c31d8-f734-163d-a0fd-11a08c91e8f1") + GUID_BACKGROUND_TASK_NOTIFICATION* = DEFINE_GUID("cf23f240-2a54-48d8-b114-de1518ff052e") + GUID_APPLAUNCH_BUTTON* = DEFINE_GUID("1a689231-7399-4e9a-8f99-b71f999db3fa") + GUID_PCIEXPRESS_SETTINGS_SUBGROUP* = DEFINE_GUID("501a4d13-42af-4429-9fd1-a8218c268e20") + GUID_PCIEXPRESS_ASPM_POLICY* = DEFINE_GUID("ee12f906-d277-404b-b6da-e5fa1a576df5") + GUID_ENABLE_SWITCH_FORCED_SHUTDOWN* = DEFINE_GUID("833a6b62-dfa4-46d1-82f8-e09e34d029d6") + powerSystemUnspecified* = 0 + powerSystemWorking* = 1 + powerSystemSleeping1* = 2 + powerSystemSleeping2* = 3 + powerSystemSleeping3* = 4 + powerSystemHibernate* = 5 + powerSystemShutdown* = 6 + powerSystemMaximum* = 7 + powerActionNone* = 0 + powerActionReserved* = 1 + powerActionSleep* = 2 + powerActionHibernate* = 3 + powerActionShutdown* = 4 + powerActionShutdownReset* = 5 + powerActionShutdownOff* = 6 + powerActionWarmEject* = 7 + powerDeviceUnspecified* = 0 + powerDeviceD0* = 1 + powerDeviceD1* = 2 + powerDeviceD2* = 3 + powerDeviceD3* = 4 + powerDeviceMaximum* = 5 + powerMonitorOff* = 0 + powerMonitorOn* = 1 + powerMonitorDim* = 2 + powerUserPresent* = 0 + powerUserNotPresent* = 1 + powerUserInactive* = 2 + powerUserMaximum* = 3 + powerUserInvalid* = powerUserMaximum + ES_SYSTEM_REQUIRED* = DWORD 0x00000001 + ES_DISPLAY_REQUIRED* = DWORD 0x00000002 + ES_USER_PRESENT* = DWORD 0x00000004 + ES_AWAYMODE_REQUIRED* = DWORD 0x00000040 + ES_CONTINUOUS* = DWORD 0x80000000'i32 + LT_DONT_CARE* = 0 + LT_LOWEST_LATENCY* = 1 + DIAGNOSTIC_REASON_VERSION* = 0 + POWER_REQUEST_CONTEXT_VERSION* = 0 + DIAGNOSTIC_REASON_SIMPLE_STRING* = 0x00000001 + DIAGNOSTIC_REASON_DETAILED_STRING* = 0x00000002 + DIAGNOSTIC_REASON_NOT_SPECIFIED* = 0x80000000'i32 + DIAGNOSTIC_REASON_INVALID_FLAGS* = not 0x80000003'i32 + POWER_REQUEST_CONTEXT_SIMPLE_STRING* = 0x00000001 + POWER_REQUEST_CONTEXT_DETAILED_STRING* = 0x00000002 + powerRequestDisplayRequired* = 0 + powerRequestSystemRequired* = 1 + powerRequestAwayModeRequired* = 2 + powerRequestExecutionRequired* = 3 + PDCAP_D0_SUPPORTED* = 0x00000001 + PDCAP_D1_SUPPORTED* = 0x00000002 + PDCAP_D2_SUPPORTED* = 0x00000004 + PDCAP_D3_SUPPORTED* = 0x00000008 + PDCAP_WAKE_FROM_D0_SUPPORTED* = 0x00000010 + PDCAP_WAKE_FROM_D1_SUPPORTED* = 0x00000020 + PDCAP_WAKE_FROM_D2_SUPPORTED* = 0x00000040 + PDCAP_WAKE_FROM_D3_SUPPORTED* = 0x00000080 + PDCAP_WARM_EJECT_SUPPORTED* = 0x00000100 + systemPowerPolicyAc* = 0 + systemPowerPolicyDc* = 1 + verifySystemPolicyAc* = 2 + verifySystemPolicyDc* = 3 + systemPowerCapabilities* = 4 + systemBatteryState* = 5 + systemPowerStateHandler* = 6 + processorStateHandler* = 7 + systemPowerPolicyCurrent* = 8 + administratorPowerPolicy* = 9 + systemReserveHiberFile* = 10 + processorInformation* = 11 + systemPowerInformation* = 12 + processorStateHandler2* = 13 + lastWakeTime* = 14 + lastSleepTime* = 15 + systemExecutionState* = 16 + systemPowerStateNotifyHandler* = 17 + processorPowerPolicyAc* = 18 + processorPowerPolicyDc* = 19 + verifyProcessorPowerPolicyAc* = 20 + verifyProcessorPowerPolicyDc* = 21 + processorPowerPolicyCurrent* = 22 + systemPowerStateLogging* = 23 + systemPowerLoggingEntry* = 24 + setPowerSettingValue* = 25 + notifyUserPowerSetting* = 26 + powerInformationLevelUnused0* = 27 + systemMonitorHiberBootPowerOff* = 28 + systemVideoState* = 29 + traceApplicationPowerMessage* = 30 + traceApplicationPowerMessageEnd* = 31 + processorPerfStates* = 32 + processorIdleStates* = 33 + processorCap* = 34 + systemWakeSource* = 35 + systemHiberFileInformation* = 36 + traceServicePowerMessage* = 37 + processorLoad* = 38 + powerShutdownNotification* = 39 + monitorCapabilities* = 40 + sessionPowerInit* = 41 + sessionDisplayState* = 42 + powerRequestCreate* = 43 + powerRequestAction* = 44 + getPowerRequestList* = 45 + processorInformationEx* = 46 + notifyUserModeLegacyPowerEvent* = 47 + groupPark* = 48 + processorIdleDomains* = 49 + wakeTimerList* = 50 + systemHiberFileSize* = 51 + processorIdleStatesHv* = 52 + processorPerfStatesHv* = 53 + processorPerfCapHv* = 54 + processorSetIdle* = 55 + logicalProcessorIdling* = 56 + userPresence* = 57 + powerSettingNotificationName* = 58 + getPowerSettingValue* = 59 + idleResiliency* = 60 + sessionRITState* = 61 + sessionConnectNotification* = 62 + sessionPowerCleanup* = 63 + sessionLockState* = 64 + systemHiberbootState* = 65 + platformInformation* = 66 + pdcInvocation* = 67 + monitorInvocation* = 68 + firmwareTableInformationRegistered* = 69 + setShutdownSelectedTime* = 70 + suspendResumeInvocation* = 71 + plmPowerRequestCreate* = 72 + screenOff* = 73 + csDeviceNotification* = 74 + platformRole* = 75 + lastResumePerformance* = 76 + displayBurst* = 77 + exitLatencySamplingPercentage* = 78 + applyLowPowerScenarioSettings* = 79 + powerInformationLevelMaximum* = 80 + userNotPresent* = 0 + userPresent* = 1 + userUnknown* = 0xff + monitorRequestReasonUnknown* = 0 + monitorRequestReasonPowerButton* = 1 + monitorRequestReasonRemoteConnection* = 2 + monitorRequestReasonScMonitorpower* = 3 + monitorRequestReasonUserInput* = 4 + monitorRequestReasonAcDcDisplayBurst* = 5 + monitorRequestReasonUserDisplayBurst* = 6 + monitorRequestReasonPoSetSystemState* = 7 + monitorRequestReasonSetThreadExecutionState* = 8 + monitorRequestReasonFullWake* = 9 + monitorRequestReasonSessionUnlock* = 10 + monitorRequestReasonScreenOffRequest* = 11 + monitorRequestReasonIdleTimeout* = 12 + monitorRequestReasonPolicyChange* = 13 + monitorRequestReasonMax* = 14 + poAc* = 0 + poDc* = 1 + poHot* = 2 + poConditionMaximum* = 3 + POWER_SETTING_VALUE_VERSION* = 0x1 + platformRoleUnspecified* = 0 + platformRoleDesktop* = 1 + platformRoleMobile* = 2 + platformRoleWorkstation* = 3 + platformRoleEnterpriseServer* = 4 + platformRoleSOHOServer* = 5 + platformRoleAppliancePC* = 6 + platformRolePerformanceServer* = 7 + platformRoleSlate* = 8 + platformRoleMaximum* = 9 + POWER_PLATFORM_ROLE_V1* = 0x00000001 + POWER_PLATFORM_ROLE_V1_MAX* = platformRolePerformanceServer+1 + POWER_PLATFORM_ROLE_V2* = 0x00000002 + POWER_PLATFORM_ROLE_V2_MAX* = platformRoleSlate+1 + POWER_PLATFORM_ROLE_VERSION* = POWER_PLATFORM_ROLE_V2 + POWER_PLATFORM_ROLE_VERSION_MAX* = POWER_PLATFORM_ROLE_V2_MAX + ACPI_PPM_SOFTWARE_ALL* = 0xfc + ACPI_PPM_SOFTWARE_ANY* = 0xfd + ACPI_PPM_HARDWARE_ALL* = 0xfe + MS_PPM_SOFTWARE_ALL* = 0x1 + PPM_FIRMWARE_ACPI1C2* = 0x1 + PPM_FIRMWARE_ACPI1C3* = 0x2 + PPM_FIRMWARE_ACPI1TSTATES* = 0x4 + PPM_FIRMWARE_CST* = 0x8 + PPM_FIRMWARE_CSD* = 0x10 + PPM_FIRMWARE_PCT* = 0x20 + PPM_FIRMWARE_PSS* = 0x40 + PPM_FIRMWARE_XPSS* = 0x80 + PPM_FIRMWARE_PPC* = 0x100 + PPM_FIRMWARE_PSD* = 0x200 + PPM_FIRMWARE_PTC* = 0x400 + PPM_FIRMWARE_TSS* = 0x800 + PPM_FIRMWARE_TPC* = 0x1000 + PPM_FIRMWARE_TSD* = 0x2000 + PPM_FIRMWARE_PCCH* = 0x4000 + PPM_FIRMWARE_PCCP* = 0x8000 + PPM_FIRMWARE_OSC* = 0x10000 + PPM_FIRMWARE_PDC* = 0x20000 + PPM_FIRMWARE_CPC* = 0x40000 + PPM_PERFORMANCE_IMPLEMENTATION_NONE* = 0 + PPM_PERFORMANCE_IMPLEMENTATION_PSTATES* = 1 + PPM_PERFORMANCE_IMPLEMENTATION_PCCV1* = 2 + PPM_PERFORMANCE_IMPLEMENTATION_CPPC* = 3 + PPM_PERFORMANCE_IMPLEMENTATION_PEP* = 4 + PPM_IDLE_IMPLEMENTATION_NONE* = 0x0 + PPM_IDLE_IMPLEMENTATION_CSTATES* = 0x1 + PPM_IDLE_IMPLEMENTATION_PEP* = 0x2 + PPM_PERFSTATE_CHANGE_GUID* = DEFINE_GUID("a5b32ddd-7f39-4abc-b892-900e43b59ebb") + PPM_PERFSTATE_DOMAIN_CHANGE_GUID* = DEFINE_GUID("995e6b7f-d653-497a-b978-36a30c29bf01") + PPM_IDLESTATE_CHANGE_GUID* = DEFINE_GUID("4838fe4f-f71c-4e51-9ecc-8430a7ac4c6c") + PPM_PERFSTATES_DATA_GUID* = DEFINE_GUID("5708cc20-7d40-4bf4-b4aa-2b01338d0126") + PPM_IDLESTATES_DATA_GUID* = DEFINE_GUID("ba138e10-e250-4ad7-8616-cf1a7ad410e7") + PPM_IDLE_ACCOUNTING_GUID* = DEFINE_GUID("e2a26f78-ae07-4ee0-a30f-ce54f55a94cd") + PPM_IDLE_ACCOUNTING_EX_GUID* = DEFINE_GUID("d67abd39-81f8-4a5e-8152-72e31ec912ee") + PPM_THERMALCONSTRAINT_GUID* = DEFINE_GUID("a852c2c8-1a4c-423b-8c2c-f30d82931a88") + PPM_PERFMON_PERFSTATE_GUID* = DEFINE_GUID("7fd18652-0cfe-40d2-b0a1-0b066a87759e") + PPM_THERMAL_POLICY_CHANGE_GUID* = DEFINE_GUID("48f377b8-6880-4c7b-8bdc-380176c6654d") + POWER_ACTION_QUERY_ALLOWED* = 0x00000001 + POWER_ACTION_UI_ALLOWED* = 0x00000002 + POWER_ACTION_OVERRIDE_APPS* = 0x00000004 + POWER_ACTION_HIBERBOOT* = 0x00000008 + POWER_ACTION_PSEUDO_TRANSITION* = 0x08000000 + POWER_ACTION_LIGHTEST_FIRST* = 0x10000000 + POWER_ACTION_LOCK_CONSOLE* = 0x20000000 + POWER_ACTION_DISABLE_WAKES* = 0x40000000 + POWER_ACTION_CRITICAL* = 0x80000000'i32 + POWER_LEVEL_USER_NOTIFY_TEXT* = 0x00000001 + POWER_LEVEL_USER_NOTIFY_SOUND* = 0x00000002 + POWER_LEVEL_USER_NOTIFY_EXEC* = 0x00000004 + POWER_USER_NOTIFY_BUTTON* = 0x00000008 + POWER_USER_NOTIFY_SHUTDOWN* = 0x00000010 + POWER_USER_NOTIFY_FORCED_SHUTDOWN* = 0x00000020 + POWER_FORCE_TRIGGER_RESET* = 0x80000000'i32 + BATTERY_DISCHARGE_FLAGS_EVENTCODE_MASK* = 0x00000007 + BATTERY_DISCHARGE_FLAGS_ENABLE* = 0x80000000'i32 + DISCHARGE_POLICY_CRITICAL* = 0 + DISCHARGE_POLICY_LOW* = 1 + PO_THROTTLE_NONE* = 0 + PO_THROTTLE_CONSTANT* = 1 + PO_THROTTLE_DEGRADE* = 2 + PO_THROTTLE_ADAPTIVE* = 3 + PO_THROTTLE_MAXIMUM* = 4 + IMAGE_DOS_SIGNATURE* = 0x5A4D + IMAGE_OS2_SIGNATURE* = 0x454E + IMAGE_OS2_SIGNATURE_LE* = 0x454C + IMAGE_VXD_SIGNATURE* = 0x454C + IMAGE_NT_SIGNATURE* = 0x00004550 + IMAGE_SIZEOF_FILE_HEADER* = 20 + IMAGE_FILE_RELOCS_STRIPPED* = 0x0001 + IMAGE_FILE_EXECUTABLE_IMAGE* = 0x0002 + IMAGE_FILE_LINE_NUMS_STRIPPED* = 0x0004 + IMAGE_FILE_LOCAL_SYMS_STRIPPED* = 0x0008 + IMAGE_FILE_AGGRESIVE_WS_TRIM* = 0x0010 + IMAGE_FILE_LARGE_ADDRESS_AWARE* = 0x0020 + IMAGE_FILE_BYTES_REVERSED_LO* = 0x0080 + IMAGE_FILE_32BIT_MACHINE* = 0x0100 + IMAGE_FILE_DEBUG_STRIPPED* = 0x0200 + IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP* = 0x0400 + IMAGE_FILE_NET_RUN_FROM_SWAP* = 0x0800 + IMAGE_FILE_SYSTEM* = 0x1000 + IMAGE_FILE_DLL* = 0x2000 + IMAGE_FILE_UP_SYSTEM_ONLY* = 0x4000 + IMAGE_FILE_BYTES_REVERSED_HI* = 0x8000 + IMAGE_FILE_MACHINE_UNKNOWN* = 0 + IMAGE_FILE_MACHINE_I386* = 0x014c + IMAGE_FILE_MACHINE_R3000* = 0x0162 + IMAGE_FILE_MACHINE_R4000* = 0x0166 + IMAGE_FILE_MACHINE_R10000* = 0x0168 + IMAGE_FILE_MACHINE_WCEMIPSV2* = 0x0169 + IMAGE_FILE_MACHINE_ALPHA* = 0x0184 + IMAGE_FILE_MACHINE_SH3* = 0x01a2 + IMAGE_FILE_MACHINE_SH3DSP* = 0x01a3 + IMAGE_FILE_MACHINE_SH3E* = 0x01a4 + IMAGE_FILE_MACHINE_SH4* = 0x01a6 + IMAGE_FILE_MACHINE_SH5* = 0x01a8 + IMAGE_FILE_MACHINE_ARM* = 0x01c0 + IMAGE_FILE_MACHINE_ARMV7* = 0x01c4 + IMAGE_FILE_MACHINE_ARMNT* = 0x01c4 + IMAGE_FILE_MACHINE_THUMB* = 0x01c2 + IMAGE_FILE_MACHINE_AM33* = 0x01d3 + IMAGE_FILE_MACHINE_POWERPC* = 0x01F0 + IMAGE_FILE_MACHINE_POWERPCFP* = 0x01f1 + IMAGE_FILE_MACHINE_IA64* = 0x0200 + IMAGE_FILE_MACHINE_MIPS16* = 0x0266 + IMAGE_FILE_MACHINE_ALPHA64* = 0x0284 + IMAGE_FILE_MACHINE_MIPSFPU* = 0x0366 + IMAGE_FILE_MACHINE_MIPSFPU16* = 0x0466 + IMAGE_FILE_MACHINE_AXP64* = IMAGE_FILE_MACHINE_ALPHA64 + IMAGE_FILE_MACHINE_TRICORE* = 0x0520 + IMAGE_FILE_MACHINE_CEF* = 0x0CEF + IMAGE_FILE_MACHINE_EBC* = 0x0EBC + IMAGE_FILE_MACHINE_AMD64* = 0x8664 + IMAGE_FILE_MACHINE_M32R* = 0x9041 + IMAGE_FILE_MACHINE_CEE* = 0xc0ee + IMAGE_SIZEOF_ROM_OPTIONAL_HEADER* = 56 + IMAGE_SIZEOF_STD_OPTIONAL_HEADER* = 28 + IMAGE_SIZEOF_NT_OPTIONAL32_HEADER* = 224 + IMAGE_SIZEOF_NT_OPTIONAL64_HEADER* = 240 + IMAGE_NT_OPTIONAL_HDR32_MAGIC* = 0x10b + IMAGE_NT_OPTIONAL_HDR64_MAGIC* = 0x20b + IMAGE_ROM_OPTIONAL_HDR_MAGIC* = 0x107 + IMAGE_SUBSYSTEM_UNKNOWN* = 0 + IMAGE_SUBSYSTEM_NATIVE* = 1 + IMAGE_SUBSYSTEM_WINDOWS_GUI* = 2 + IMAGE_SUBSYSTEM_WINDOWS_CUI* = 3 + IMAGE_SUBSYSTEM_OS2_CUI* = 5 + IMAGE_SUBSYSTEM_POSIX_CUI* = 7 + IMAGE_SUBSYSTEM_NATIVE_WINDOWS* = 8 + IMAGE_SUBSYSTEM_WINDOWS_CE_GUI* = 9 + IMAGE_SUBSYSTEM_EFI_APPLICATION* = 10 + IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER* = 11 + IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER* = 12 + IMAGE_SUBSYSTEM_EFI_ROM* = 13 + IMAGE_SUBSYSTEM_XBOX* = 14 + IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION* = 16 + IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA* = 0x0020 + IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE* = 0x0040 + IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY* = 0x0080 + IMAGE_DLLCHARACTERISTICS_NX_COMPAT* = 0x0100 + IMAGE_DLLCHARACTERISTICS_NO_ISOLATION* = 0x0200 + IMAGE_DLLCHARACTERISTICS_NO_SEH* = 0x0400 + IMAGE_DLLCHARACTERISTICS_NO_BIND* = 0x0800 + IMAGE_DLLCHARACTERISTICS_APPCONTAINER* = 0x1000 + IMAGE_DLLCHARACTERISTICS_WDM_DRIVER* = 0x2000 + IMAGE_DLLCHARACTERISTICS_GUARD_CF* = 0x4000 + IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE* = 0x8000 + IMAGE_DIRECTORY_ENTRY_EXPORT* = 0 + IMAGE_DIRECTORY_ENTRY_IMPORT* = 1 + IMAGE_DIRECTORY_ENTRY_RESOURCE* = 2 + IMAGE_DIRECTORY_ENTRY_EXCEPTION* = 3 + IMAGE_DIRECTORY_ENTRY_SECURITY* = 4 + IMAGE_DIRECTORY_ENTRY_BASERELOC* = 5 + IMAGE_DIRECTORY_ENTRY_DEBUG* = 6 + IMAGE_DIRECTORY_ENTRY_ARCHITECTURE* = 7 + IMAGE_DIRECTORY_ENTRY_GLOBALPTR* = 8 + IMAGE_DIRECTORY_ENTRY_TLS* = 9 + IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG* = 10 + IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT* = 11 + IMAGE_DIRECTORY_ENTRY_IAT* = 12 + IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT* = 13 + IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR* = 14 + IMAGE_SIZEOF_SECTION_HEADER* = 40 + IMAGE_SCN_TYPE_NO_PAD* = 0x00000008 + IMAGE_SCN_CNT_CODE* = 0x00000020 + IMAGE_SCN_CNT_INITIALIZED_DATA* = 0x00000040 + IMAGE_SCN_CNT_UNINITIALIZED_DATA* = 0x00000080 + IMAGE_SCN_LNK_OTHER* = 0x00000100 + IMAGE_SCN_LNK_INFO* = 0x00000200 + IMAGE_SCN_LNK_REMOVE* = 0x00000800 + IMAGE_SCN_LNK_COMDAT* = 0x00001000 + IMAGE_SCN_NO_DEFER_SPEC_EXC* = 0x00004000 + IMAGE_SCN_GPREL* = 0x00008000 + IMAGE_SCN_MEM_FARDATA* = 0x00008000 + IMAGE_SCN_MEM_PURGEABLE* = 0x00020000 + IMAGE_SCN_MEM_16BIT* = 0x00020000 + IMAGE_SCN_MEM_LOCKED* = 0x00040000 + IMAGE_SCN_MEM_PRELOAD* = 0x00080000 + IMAGE_SCN_ALIGN_1BYTES* = 0x00100000 + IMAGE_SCN_ALIGN_2BYTES* = 0x00200000 + IMAGE_SCN_ALIGN_4BYTES* = 0x00300000 + IMAGE_SCN_ALIGN_8BYTES* = 0x00400000 + IMAGE_SCN_ALIGN_16BYTES* = 0x00500000 + IMAGE_SCN_ALIGN_32BYTES* = 0x00600000 + IMAGE_SCN_ALIGN_64BYTES* = 0x00700000 + IMAGE_SCN_ALIGN_128BYTES* = 0x00800000 + IMAGE_SCN_ALIGN_256BYTES* = 0x00900000 + IMAGE_SCN_ALIGN_512BYTES* = 0x00A00000 + IMAGE_SCN_ALIGN_1024BYTES* = 0x00B00000 + IMAGE_SCN_ALIGN_2048BYTES* = 0x00C00000 + IMAGE_SCN_ALIGN_4096BYTES* = 0x00D00000 + IMAGE_SCN_ALIGN_8192BYTES* = 0x00E00000 + IMAGE_SCN_ALIGN_MASK* = 0x00F00000 + IMAGE_SCN_LNK_NRELOC_OVFL* = 0x01000000 + IMAGE_SCN_MEM_DISCARDABLE* = 0x02000000 + IMAGE_SCN_MEM_NOT_CACHED* = 0x04000000 + IMAGE_SCN_MEM_NOT_PAGED* = 0x08000000 + IMAGE_SCN_MEM_SHARED* = 0x10000000 + IMAGE_SCN_MEM_EXECUTE* = 0x20000000 + IMAGE_SCN_MEM_READ* = 0x40000000 + IMAGE_SCN_MEM_WRITE* = 0x80000000'i32 + IMAGE_SCN_SCALE_INDEX* = 0x00000001 + IMAGE_SYM_UNDEFINED* = SHORT 0 + IMAGE_SYM_ABSOLUTE* = SHORT(-1) + IMAGE_SYM_DEBUG* = SHORT(-2) + IMAGE_SYM_SECTION_MAX* = 0xFEFF + IMAGE_SYM_SECTION_MAX_EX* = MAXLONG + IMAGE_SYM_TYPE_NULL* = 0x0000 + IMAGE_SYM_TYPE_VOID* = 0x0001 + IMAGE_SYM_TYPE_CHAR* = 0x0002 + IMAGE_SYM_TYPE_SHORT* = 0x0003 + IMAGE_SYM_TYPE_INT* = 0x0004 + IMAGE_SYM_TYPE_LONG* = 0x0005 + IMAGE_SYM_TYPE_FLOAT* = 0x0006 + IMAGE_SYM_TYPE_DOUBLE* = 0x0007 + IMAGE_SYM_TYPE_STRUCT* = 0x0008 + IMAGE_SYM_TYPE_UNION* = 0x0009 + IMAGE_SYM_TYPE_ENUM* = 0x000A + IMAGE_SYM_TYPE_MOE* = 0x000B + IMAGE_SYM_TYPE_BYTE* = 0x000C + IMAGE_SYM_TYPE_WORD* = 0x000D + IMAGE_SYM_TYPE_UINT* = 0x000E + IMAGE_SYM_TYPE_DWORD* = 0x000F + IMAGE_SYM_TYPE_PCODE* = 0x8000 + IMAGE_SYM_DTYPE_NULL* = 0 + IMAGE_SYM_DTYPE_POINTER* = 1 + IMAGE_SYM_DTYPE_FUNCTION* = 2 + IMAGE_SYM_DTYPE_ARRAY* = 3 + IMAGE_SYM_CLASS_NULL* = 0x0000 + IMAGE_SYM_CLASS_AUTOMATIC* = 0x0001 + IMAGE_SYM_CLASS_EXTERNAL* = 0x0002 + IMAGE_SYM_CLASS_STATIC* = 0x0003 + IMAGE_SYM_CLASS_REGISTER* = 0x0004 + IMAGE_SYM_CLASS_EXTERNAL_DEF* = 0x0005 + IMAGE_SYM_CLASS_LABEL* = 0x0006 + IMAGE_SYM_CLASS_UNDEFINED_LABEL* = 0x0007 + IMAGE_SYM_CLASS_MEMBER_OF_STRUCT* = 0x0008 + IMAGE_SYM_CLASS_ARGUMENT* = 0x0009 + IMAGE_SYM_CLASS_STRUCT_TAG* = 0x000A + IMAGE_SYM_CLASS_MEMBER_OF_UNION* = 0x000B + IMAGE_SYM_CLASS_UNION_TAG* = 0x000C + IMAGE_SYM_CLASS_TYPE_DEFINITION* = 0x000D + IMAGE_SYM_CLASS_UNDEFINED_STATIC* = 0x000E + IMAGE_SYM_CLASS_ENUM_TAG* = 0x000F + IMAGE_SYM_CLASS_MEMBER_OF_ENUM* = 0x0010 + IMAGE_SYM_CLASS_REGISTER_PARAM* = 0x0011 + IMAGE_SYM_CLASS_BIT_FIELD* = 0x0012 + IMAGE_SYM_CLASS_FAR_EXTERNAL* = 0x0044 + IMAGE_SYM_CLASS_BLOCK* = 0x0064 + IMAGE_SYM_CLASS_FUNCTION* = 0x0065 + IMAGE_SYM_CLASS_END_OF_STRUCT* = 0x0066 + IMAGE_SYM_CLASS_FILE* = 0x0067 + IMAGE_SYM_CLASS_SECTION* = 0x0068 + IMAGE_SYM_CLASS_WEAK_EXTERNAL* = 0x0069 + IMAGE_SYM_CLASS_CLR_TOKEN* = 0x006B + N_BTMASK* = 0x000F + N_TMASK* = 0x0030 + N_TMASK1* = 0x00C0 + N_TMASK2* = 0x00F0 + N_BTSHFT* = 4 + N_TSHIFT* = 2 + IMAGE_SIZEOF_AUX_SYMBOL* = 18 + IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF* = 1 + IMAGE_COMDAT_SELECT_NODUPLICATES* = 1 + IMAGE_COMDAT_SELECT_ANY* = 2 + IMAGE_COMDAT_SELECT_SAME_SIZE* = 3 + IMAGE_COMDAT_SELECT_EXACT_MATCH* = 4 + IMAGE_COMDAT_SELECT_ASSOCIATIVE* = 5 + IMAGE_COMDAT_SELECT_LARGEST* = 6 + IMAGE_COMDAT_SELECT_NEWEST* = 7 + IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY* = 1 + IMAGE_WEAK_EXTERN_SEARCH_LIBRARY* = 2 + IMAGE_WEAK_EXTERN_SEARCH_ALIAS* = 3 + IMAGE_SIZEOF_RELOCATION* = 10 + IMAGE_REL_I386_ABSOLUTE* = 0x0000 + IMAGE_REL_I386_DIR16* = 0x0001 + IMAGE_REL_I386_REL16* = 0x0002 + IMAGE_REL_I386_DIR32* = 0x0006 + IMAGE_REL_I386_DIR32NB* = 0x0007 + IMAGE_REL_I386_SEG12* = 0x0009 + IMAGE_REL_I386_SECTION* = 0x000A + IMAGE_REL_I386_SECREL* = 0x000B + IMAGE_REL_I386_TOKEN* = 0x000C + IMAGE_REL_I386_SECREL7* = 0x000D + IMAGE_REL_I386_REL32* = 0x0014 + IMAGE_REL_MIPS_ABSOLUTE* = 0x0000 + IMAGE_REL_MIPS_REFHALF* = 0x0001 + IMAGE_REL_MIPS_REFWORD* = 0x0002 + IMAGE_REL_MIPS_JMPADDR* = 0x0003 + IMAGE_REL_MIPS_REFHI* = 0x0004 + IMAGE_REL_MIPS_REFLO* = 0x0005 + IMAGE_REL_MIPS_GPREL* = 0x0006 + IMAGE_REL_MIPS_LITERAL* = 0x0007 + IMAGE_REL_MIPS_SECTION* = 0x000A + IMAGE_REL_MIPS_SECREL* = 0x000B + IMAGE_REL_MIPS_SECRELLO* = 0x000C + IMAGE_REL_MIPS_SECRELHI* = 0x000D + IMAGE_REL_MIPS_TOKEN* = 0x000E + IMAGE_REL_MIPS_JMPADDR16* = 0x0010 + IMAGE_REL_MIPS_REFWORDNB* = 0x0022 + IMAGE_REL_MIPS_PAIR* = 0x0025 + IMAGE_REL_ALPHA_ABSOLUTE* = 0x0000 + IMAGE_REL_ALPHA_REFLONG* = 0x0001 + IMAGE_REL_ALPHA_REFQUAD* = 0x0002 + IMAGE_REL_ALPHA_GPREL32* = 0x0003 + IMAGE_REL_ALPHA_LITERAL* = 0x0004 + IMAGE_REL_ALPHA_LITUSE* = 0x0005 + IMAGE_REL_ALPHA_GPDISP* = 0x0006 + IMAGE_REL_ALPHA_BRADDR* = 0x0007 + IMAGE_REL_ALPHA_HINT* = 0x0008 + IMAGE_REL_ALPHA_INLINE_REFLONG* = 0x0009 + IMAGE_REL_ALPHA_REFHI* = 0x000A + IMAGE_REL_ALPHA_REFLO* = 0x000B + IMAGE_REL_ALPHA_PAIR* = 0x000C + IMAGE_REL_ALPHA_MATCH* = 0x000D + IMAGE_REL_ALPHA_SECTION* = 0x000E + IMAGE_REL_ALPHA_SECREL* = 0x000F + IMAGE_REL_ALPHA_REFLONGNB* = 0x0010 + IMAGE_REL_ALPHA_SECRELLO* = 0x0011 + IMAGE_REL_ALPHA_SECRELHI* = 0x0012 + IMAGE_REL_ALPHA_REFQ3* = 0x0013 + IMAGE_REL_ALPHA_REFQ2* = 0x0014 + IMAGE_REL_ALPHA_REFQ1* = 0x0015 + IMAGE_REL_ALPHA_GPRELLO* = 0x0016 + IMAGE_REL_ALPHA_GPRELHI* = 0x0017 + IMAGE_REL_PPC_ABSOLUTE* = 0x0000 + IMAGE_REL_PPC_ADDR64* = 0x0001 + IMAGE_REL_PPC_ADDR32* = 0x0002 + IMAGE_REL_PPC_ADDR24* = 0x0003 + IMAGE_REL_PPC_ADDR16* = 0x0004 + IMAGE_REL_PPC_ADDR14* = 0x0005 + IMAGE_REL_PPC_REL24* = 0x0006 + IMAGE_REL_PPC_REL14* = 0x0007 + IMAGE_REL_PPC_TOCREL16* = 0x0008 + IMAGE_REL_PPC_TOCREL14* = 0x0009 + IMAGE_REL_PPC_ADDR32NB* = 0x000A + IMAGE_REL_PPC_SECREL* = 0x000B + IMAGE_REL_PPC_SECTION* = 0x000C + IMAGE_REL_PPC_IFGLUE* = 0x000D + IMAGE_REL_PPC_IMGLUE* = 0x000E + IMAGE_REL_PPC_SECREL16* = 0x000F + IMAGE_REL_PPC_REFHI* = 0x0010 + IMAGE_REL_PPC_REFLO* = 0x0011 + IMAGE_REL_PPC_PAIR* = 0x0012 + IMAGE_REL_PPC_SECRELLO* = 0x0013 + IMAGE_REL_PPC_SECRELHI* = 0x0014 + IMAGE_REL_PPC_GPREL* = 0x0015 + IMAGE_REL_PPC_TOKEN* = 0x0016 + IMAGE_REL_PPC_TYPEMASK* = 0x00FF + IMAGE_REL_PPC_NEG* = 0x0100 + IMAGE_REL_PPC_BRTAKEN* = 0x0200 + IMAGE_REL_PPC_BRNTAKEN* = 0x0400 + IMAGE_REL_PPC_TOCDEFN* = 0x0800 + IMAGE_REL_SH3_ABSOLUTE* = 0x0000 + IMAGE_REL_SH3_DIRECT16* = 0x0001 + IMAGE_REL_SH3_DIRECT32* = 0x0002 + IMAGE_REL_SH3_DIRECT8* = 0x0003 + IMAGE_REL_SH3_DIRECT8_WORD* = 0x0004 + IMAGE_REL_SH3_DIRECT8_LONG* = 0x0005 + IMAGE_REL_SH3_DIRECT4* = 0x0006 + IMAGE_REL_SH3_DIRECT4_WORD* = 0x0007 + IMAGE_REL_SH3_DIRECT4_LONG* = 0x0008 + IMAGE_REL_SH3_PCREL8_WORD* = 0x0009 + IMAGE_REL_SH3_PCREL8_LONG* = 0x000A + IMAGE_REL_SH3_PCREL12_WORD* = 0x000B + IMAGE_REL_SH3_STARTOF_SECTION* = 0x000C + IMAGE_REL_SH3_SIZEOF_SECTION* = 0x000D + IMAGE_REL_SH3_SECTION* = 0x000E + IMAGE_REL_SH3_SECREL* = 0x000F + IMAGE_REL_SH3_DIRECT32_NB* = 0x0010 + IMAGE_REL_SH3_GPREL4_LONG* = 0x0011 + IMAGE_REL_SH3_TOKEN* = 0x0012 + IMAGE_REL_SHM_PCRELPT* = 0x0013 + IMAGE_REL_SHM_REFLO* = 0x0014 + IMAGE_REL_SHM_REFHALF* = 0x0015 + IMAGE_REL_SHM_RELLO* = 0x0016 + IMAGE_REL_SHM_RELHALF* = 0x0017 + IMAGE_REL_SHM_PAIR* = 0x0018 + IMAGE_REL_SH_NOMODE* = 0x8000 + IMAGE_REL_ARM_ABSOLUTE* = 0x0000 + IMAGE_REL_ARM_ADDR32* = 0x0001 + IMAGE_REL_ARM_ADDR32NB* = 0x0002 + IMAGE_REL_ARM_BRANCH24* = 0x0003 + IMAGE_REL_ARM_BRANCH11* = 0x0004 + IMAGE_REL_ARM_TOKEN* = 0x0005 + IMAGE_REL_ARM_GPREL12* = 0x0006 + IMAGE_REL_ARM_GPREL7* = 0x0007 + IMAGE_REL_ARM_BLX24* = 0x0008 + IMAGE_REL_ARM_BLX11* = 0x0009 + IMAGE_REL_ARM_SECTION* = 0x000E + IMAGE_REL_ARM_SECREL* = 0x000F + IMAGE_REL_ARM_MOV32A* = 0x0010 + IMAGE_REL_ARM_MOV32* = 0x0010 + IMAGE_REL_ARM_MOV32T* = 0x0011 + IMAGE_REL_THUMB_MOV32* = 0x0011 + IMAGE_REL_ARM_BRANCH20T* = 0x0012 + IMAGE_REL_THUMB_BRANCH20* = 0x0012 + IMAGE_REL_ARM_BRANCH24T* = 0x0014 + IMAGE_REL_THUMB_BRANCH24* = 0x0014 + IMAGE_REL_ARM_BLX23T* = 0x0015 + IMAGE_REL_THUMB_BLX23* = 0x0015 + IMAGE_REL_AM_ABSOLUTE* = 0x0000 + IMAGE_REL_AM_ADDR32* = 0x0001 + IMAGE_REL_AM_ADDR32NB* = 0x0002 + IMAGE_REL_AM_CALL32* = 0x0003 + IMAGE_REL_AM_FUNCINFO* = 0x0004 + IMAGE_REL_AM_REL32_1* = 0x0005 + IMAGE_REL_AM_REL32_2* = 0x0006 + IMAGE_REL_AM_SECREL* = 0x0007 + IMAGE_REL_AM_SECTION* = 0x0008 + IMAGE_REL_AM_TOKEN* = 0x0009 + IMAGE_REL_AMD64_ABSOLUTE* = 0x0000 + IMAGE_REL_AMD64_ADDR64* = 0x0001 + IMAGE_REL_AMD64_ADDR32* = 0x0002 + IMAGE_REL_AMD64_ADDR32NB* = 0x0003 + IMAGE_REL_AMD64_REL32* = 0x0004 + IMAGE_REL_AMD64_REL32_1* = 0x0005 + IMAGE_REL_AMD64_REL32_2* = 0x0006 + IMAGE_REL_AMD64_REL32_3* = 0x0007 + IMAGE_REL_AMD64_REL32_4* = 0x0008 + IMAGE_REL_AMD64_REL32_5* = 0x0009 + IMAGE_REL_AMD64_SECTION* = 0x000A + IMAGE_REL_AMD64_SECREL* = 0x000B + IMAGE_REL_AMD64_SECREL7* = 0x000C + IMAGE_REL_AMD64_TOKEN* = 0x000D + IMAGE_REL_AMD64_SREL32* = 0x000E + IMAGE_REL_AMD64_PAIR* = 0x000F + IMAGE_REL_AMD64_SSPAN32* = 0x0010 + IMAGE_REL_IA64_ABSOLUTE* = 0x0000 + IMAGE_REL_IA64_IMM14* = 0x0001 + IMAGE_REL_IA64_IMM22* = 0x0002 + IMAGE_REL_IA64_IMM64* = 0x0003 + IMAGE_REL_IA64_DIR32* = 0x0004 + IMAGE_REL_IA64_DIR64* = 0x0005 + IMAGE_REL_IA64_PCREL21B* = 0x0006 + IMAGE_REL_IA64_PCREL21M* = 0x0007 + IMAGE_REL_IA64_PCREL21F* = 0x0008 + IMAGE_REL_IA64_GPREL22* = 0x0009 + IMAGE_REL_IA64_LTOFF22* = 0x000A + IMAGE_REL_IA64_SECTION* = 0x000B + IMAGE_REL_IA64_SECREL22* = 0x000C + IMAGE_REL_IA64_SECREL64I* = 0x000D + IMAGE_REL_IA64_SECREL32* = 0x000E + IMAGE_REL_IA64_DIR32NB* = 0x0010 + IMAGE_REL_IA64_SREL14* = 0x0011 + IMAGE_REL_IA64_SREL22* = 0x0012 + IMAGE_REL_IA64_SREL32* = 0x0013 + IMAGE_REL_IA64_UREL32* = 0x0014 + IMAGE_REL_IA64_PCREL60X* = 0x0015 + IMAGE_REL_IA64_PCREL60B* = 0x0016 + IMAGE_REL_IA64_PCREL60F* = 0x0017 + IMAGE_REL_IA64_PCREL60I* = 0x0018 + IMAGE_REL_IA64_PCREL60M* = 0x0019 + IMAGE_REL_IA64_IMMGPREL64* = 0x001A + IMAGE_REL_IA64_TOKEN* = 0x001B + IMAGE_REL_IA64_GPREL32* = 0x001C + IMAGE_REL_IA64_ADDEND* = 0x001F + IMAGE_REL_CEF_ABSOLUTE* = 0x0000 + IMAGE_REL_CEF_ADDR32* = 0x0001 + IMAGE_REL_CEF_ADDR64* = 0x0002 + IMAGE_REL_CEF_ADDR32NB* = 0x0003 + IMAGE_REL_CEF_SECTION* = 0x0004 + IMAGE_REL_CEF_SECREL* = 0x0005 + IMAGE_REL_CEF_TOKEN* = 0x0006 + IMAGE_REL_CEE_ABSOLUTE* = 0x0000 + IMAGE_REL_CEE_ADDR32* = 0x0001 + IMAGE_REL_CEE_ADDR64* = 0x0002 + IMAGE_REL_CEE_ADDR32NB* = 0x0003 + IMAGE_REL_CEE_SECTION* = 0x0004 + IMAGE_REL_CEE_SECREL* = 0x0005 + IMAGE_REL_CEE_TOKEN* = 0x0006 + IMAGE_REL_M32R_ABSOLUTE* = 0x0000 + IMAGE_REL_M32R_ADDR32* = 0x0001 + IMAGE_REL_M32R_ADDR32NB* = 0x0002 + IMAGE_REL_M32R_ADDR24* = 0x0003 + IMAGE_REL_M32R_GPREL16* = 0x0004 + IMAGE_REL_M32R_PCREL24* = 0x0005 + IMAGE_REL_M32R_PCREL16* = 0x0006 + IMAGE_REL_M32R_PCREL8* = 0x0007 + IMAGE_REL_M32R_REFHALF* = 0x0008 + IMAGE_REL_M32R_REFHI* = 0x0009 + IMAGE_REL_M32R_REFLO* = 0x000A + IMAGE_REL_M32R_PAIR* = 0x000B + IMAGE_REL_M32R_SECTION* = 0x000C + IMAGE_REL_M32R_SECREL32* = 0x000D + IMAGE_REL_M32R_TOKEN* = 0x000E + IMAGE_REL_EBC_ABSOLUTE* = 0x0000 + IMAGE_REL_EBC_ADDR32NB* = 0x0001 + IMAGE_REL_EBC_REL32* = 0x0002 + IMAGE_REL_EBC_SECTION* = 0x0003 + IMAGE_REL_EBC_SECREL* = 0x0004 + EMARCH_ENC_I17_IMM7B_INST_WORD_X* = 3 + EMARCH_ENC_I17_IMM7B_SIZE_X* = 7 + EMARCH_ENC_I17_IMM7B_INST_WORD_POS_X* = 4 + EMARCH_ENC_I17_IMM7B_VAL_POS_X* = 0 + EMARCH_ENC_I17_IMM9D_INST_WORD_X* = 3 + EMARCH_ENC_I17_IMM9D_SIZE_X* = 9 + EMARCH_ENC_I17_IMM9D_INST_WORD_POS_X* = 18 + EMARCH_ENC_I17_IMM9D_VAL_POS_X* = 7 + EMARCH_ENC_I17_IMM5C_INST_WORD_X* = 3 + EMARCH_ENC_I17_IMM5C_SIZE_X* = 5 + EMARCH_ENC_I17_IMM5C_INST_WORD_POS_X* = 13 + EMARCH_ENC_I17_IMM5C_VAL_POS_X* = 16 + EMARCH_ENC_I17_IC_INST_WORD_X* = 3 + EMARCH_ENC_I17_IC_SIZE_X* = 1 + EMARCH_ENC_I17_IC_INST_WORD_POS_X* = 12 + EMARCH_ENC_I17_IC_VAL_POS_X* = 21 + EMARCH_ENC_I17_IMM41a_INST_WORD_X* = 1 + EMARCH_ENC_I17_IMM41a_SIZE_X* = 10 + EMARCH_ENC_I17_IMM41a_INST_WORD_POS_X* = 14 + EMARCH_ENC_I17_IMM41a_VAL_POS_X* = 22 + EMARCH_ENC_I17_IMM41b_INST_WORD_X* = 1 + EMARCH_ENC_I17_IMM41b_SIZE_X* = 8 + EMARCH_ENC_I17_IMM41b_INST_WORD_POS_X* = 24 + EMARCH_ENC_I17_IMM41b_VAL_POS_X* = 32 + EMARCH_ENC_I17_IMM41c_INST_WORD_X* = 2 + EMARCH_ENC_I17_IMM41c_SIZE_X* = 23 + EMARCH_ENC_I17_IMM41c_INST_WORD_POS_X* = 0 + EMARCH_ENC_I17_IMM41c_VAL_POS_X* = 40 + EMARCH_ENC_I17_SIGN_INST_WORD_X* = 3 + EMARCH_ENC_I17_SIGN_SIZE_X* = 1 + EMARCH_ENC_I17_SIGN_INST_WORD_POS_X* = 27 + EMARCH_ENC_I17_SIGN_VAL_POS_X* = 63 + X3_OPCODE_INST_WORD_X* = 3 + X3_OPCODE_SIZE_X* = 4 + X3_OPCODE_INST_WORD_POS_X* = 28 + X3_OPCODE_SIGN_VAL_POS_X* = 0 + X3_I_INST_WORD_X* = 3 + X3_I_SIZE_X* = 1 + X3_I_INST_WORD_POS_X* = 27 + X3_I_SIGN_VAL_POS_X* = 59 + X3_D_WH_INST_WORD_X* = 3 + X3_D_WH_SIZE_X* = 3 + X3_D_WH_INST_WORD_POS_X* = 24 + X3_D_WH_SIGN_VAL_POS_X* = 0 + X3_IMM20_INST_WORD_X* = 3 + X3_IMM20_SIZE_X* = 20 + X3_IMM20_INST_WORD_POS_X* = 4 + X3_IMM20_SIGN_VAL_POS_X* = 0 + X3_IMM39_1_INST_WORD_X* = 2 + X3_IMM39_1_SIZE_X* = 23 + X3_IMM39_1_INST_WORD_POS_X* = 0 + X3_IMM39_1_SIGN_VAL_POS_X* = 36 + X3_IMM39_2_INST_WORD_X* = 1 + X3_IMM39_2_SIZE_X* = 16 + X3_IMM39_2_INST_WORD_POS_X* = 16 + X3_IMM39_2_SIGN_VAL_POS_X* = 20 + X3_P_INST_WORD_X* = 3 + X3_P_SIZE_X* = 4 + X3_P_INST_WORD_POS_X* = 0 + X3_P_SIGN_VAL_POS_X* = 0 + X3_TMPLT_INST_WORD_X* = 0 + X3_TMPLT_SIZE_X* = 4 + X3_TMPLT_INST_WORD_POS_X* = 0 + X3_TMPLT_SIGN_VAL_POS_X* = 0 + X3_BTYPE_QP_INST_WORD_X* = 2 + X3_BTYPE_QP_SIZE_X* = 9 + X3_BTYPE_QP_INST_WORD_POS_X* = 23 + X3_BTYPE_QP_INST_VAL_POS_X* = 0 + X3_EMPTY_INST_WORD_X* = 1 + X3_EMPTY_SIZE_X* = 2 + X3_EMPTY_INST_WORD_POS_X* = 14 + X3_EMPTY_INST_VAL_POS_X* = 0 + IMAGE_SIZEOF_LINENUMBER* = 6 + IMAGE_SIZEOF_BASE_RELOCATION* = 8 + IMAGE_REL_BASED_ABSOLUTE* = 0 + IMAGE_REL_BASED_HIGH* = 1 + IMAGE_REL_BASED_LOW* = 2 + IMAGE_REL_BASED_HIGHLOW* = 3 + IMAGE_REL_BASED_HIGHADJ* = 4 + IMAGE_REL_BASED_MIPS_JMPADDR* = 5 + IMAGE_REL_BASED_ARM_MOV32* = 5 + IMAGE_REL_BASED_THUMB_MOV32* = 7 + IMAGE_REL_BASED_MIPS_JMPADDR16* = 9 + IMAGE_REL_BASED_IA64_IMM64* = 9 + IMAGE_REL_BASED_DIR64* = 10 + IMAGE_ARCHIVE_START_SIZE* = 8 + IMAGE_ARCHIVE_START* = "!\n" + IMAGE_ARCHIVE_END* = "`\n" + IMAGE_ARCHIVE_PAD* = "\n" + IMAGE_ARCHIVE_LINKER_MEMBER* = "/" + IMAGE_ARCHIVE_LONGNAMES_MEMBER* = "//" + IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR* = 60 + IMAGE_ORDINAL_FLAG64* = 0x8000000000000000 + IMAGE_ORDINAL_FLAG32* = 0x80000000'i32 + IMAGE_RESOURCE_NAME_IS_STRING* = 0x80000000'i32 + IMAGE_RESOURCE_DATA_IS_DIRECTORY* = 0x80000000'i32 + IMAGE_DEBUG_TYPE_UNKNOWN* = 0 + IMAGE_DEBUG_TYPE_COFF* = 1 + IMAGE_DEBUG_TYPE_CODEVIEW* = 2 + IMAGE_DEBUG_TYPE_FPO* = 3 + IMAGE_DEBUG_TYPE_MISC* = 4 + IMAGE_DEBUG_TYPE_EXCEPTION* = 5 + IMAGE_DEBUG_TYPE_FIXUP* = 6 + IMAGE_DEBUG_TYPE_OMAP_TO_SRC* = 7 + IMAGE_DEBUG_TYPE_OMAP_FROM_SRC* = 8 + IMAGE_DEBUG_TYPE_BORLAND* = 9 + IMAGE_DEBUG_TYPE_RESERVED10* = 10 + IMAGE_DEBUG_TYPE_CLSID* = 11 + FRAME_FPO* = 0 + FRAME_TRAP* = 1 + FRAME_TSS* = 2 + FRAME_NONFPO* = 3 + SIZEOF_RFPO_DATA* = 16 + IMAGE_DEBUG_MISC_EXENAME* = 1 + IMAGE_SEPARATE_DEBUG_SIGNATURE* = 0x4944 + NON_PAGED_DEBUG_SIGNATURE* = 0x494E + IMAGE_SEPARATE_DEBUG_FLAGS_MASK* = 0x8000 + IMAGE_SEPARATE_DEBUG_MISMATCH* = 0x8000 + IMPORT_OBJECT_HDR_SIG2* = 0xffff + IMPORT_OBJECT_CODE* = 0 + IMPORT_OBJECT_DATA* = 1 + IMPORT_OBJECT_CONST* = 2 + IMPORT_OBJECT_ORDINAL* = 0 + IMPORT_OBJECT_NAME* = 1 + IMPORT_OBJECT_NAME_NO_PREFIX* = 2 + IMPORT_OBJECT_NAME_UNDECORATE* = 3 + COMIMAGE_FLAGS_ILONLY* = 0x00000001 + COMIMAGE_FLAGS_32BITREQUIRED* = 0x00000002 + COMIMAGE_FLAGS_IL_LIBRARY* = 0x00000004 + COMIMAGE_FLAGS_STRONGNAMESIGNED* = 0x00000008 + COMIMAGE_FLAGS_TRACKDEBUGDATA* = 0x00010000 + COR_VERSION_MAJOR_V2* = 2 + COR_VERSION_MAJOR* = COR_VERSION_MAJOR_V2 + COR_VERSION_MINOR* = 0 + COR_DELETED_NAME_LENGTH* = 8 + COR_VTABLEGAP_NAME_LENGTH* = 8 + NATIVE_TYPE_MAX_CB* = 1 + COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE* = 0xFF + IMAGE_COR_MIH_METHODRVA* = 0x01 + IMAGE_COR_MIH_EHRVA* = 0x02 + IMAGE_COR_MIH_BASICBLOCK* = 0x08 + COR_VTABLE_32BIT* = 0x01 + COR_VTABLE_64BIT* = 0x02 + COR_VTABLE_FROM_UNMANAGED* = 0x04 + COR_VTABLE_CALL_MOST_DERIVED* = 0x10 + IMAGE_COR_EATJ_THUNK_SIZE* = 32 + MAX_CLASS_NAME* = 1024 + MAX_PACKAGE_NAME* = 1024 + RTL_RUN_ONCE_INIT* = [0'u8] + RTL_RUN_ONCE_CHECK_ONLY* = 1 + RTL_RUN_ONCE_ASYNC* = 2 + RTL_RUN_ONCE_INIT_FAILED* = 4 + RTL_RUN_ONCE_CTX_RESERVED_BITS* = 2 + FAST_FAIL_LEGACY_GS_VIOLATION* = 0 + FAST_FAIL_VTGUARD_CHECK_FAILURE* = 1 + FAST_FAIL_STACK_COOKIE_CHECK_FAILURE* = 2 + FAST_FAIL_CORRUPT_LIST_ENTRY* = 3 + FAST_FAIL_INCORRECT_STACK* = 4 + FAST_FAIL_INVALID_ARG* = 5 + FAST_FAIL_GS_COOKIE_INIT* = 6 + FAST_FAIL_FATAL_APP_EXIT* = 7 + FAST_FAIL_RANGE_CHECK_FAILURE* = 8 + FAST_FAIL_UNSAFE_REGISTRY_ACCESS* = 9 + FAST_FAIL_INVALID_FAST_FAIL_CODE* = 0xffffffff'i32 + HEAP_NO_SERIALIZE* = 0x00000001 + HEAP_GROWABLE* = 0x00000002 + HEAP_GENERATE_EXCEPTIONS* = 0x00000004 + HEAP_ZERO_MEMORY* = 0x00000008 + HEAP_REALLOC_IN_PLACE_ONLY* = 0x00000010 + HEAP_TAIL_CHECKING_ENABLED* = 0x00000020 + HEAP_FREE_CHECKING_ENABLED* = 0x00000040 + HEAP_DISABLE_COALESCE_ON_FREE* = 0x00000080 + HEAP_CREATE_ALIGN_16* = 0x00010000 + HEAP_CREATE_ENABLE_TRACING* = 0x00020000 + HEAP_CREATE_ENABLE_EXECUTE* = 0x00040000 + HEAP_MAXIMUM_TAG* = 0x0FFF + HEAP_PSEUDO_TAG_FLAG* = 0x8000 + HEAP_TAG_SHIFT* = 18 + IS_TEXT_UNICODE_ASCII16* = 0x0001 + IS_TEXT_UNICODE_REVERSE_ASCII16* = 0x0010 + IS_TEXT_UNICODE_STATISTICS* = 0x0002 + IS_TEXT_UNICODE_REVERSE_STATISTICS* = 0x0020 + IS_TEXT_UNICODE_CONTROLS* = 0x0004 + IS_TEXT_UNICODE_REVERSE_CONTROLS* = 0x0040 + IS_TEXT_UNICODE_SIGNATURE* = 0x0008 + IS_TEXT_UNICODE_REVERSE_SIGNATURE* = 0x0080 + IS_TEXT_UNICODE_ILLEGAL_CHARS* = 0x0100 + IS_TEXT_UNICODE_ODD_LENGTH* = 0x0200 + IS_TEXT_UNICODE_DBCS_LEADBYTE* = 0x0400 + IS_TEXT_UNICODE_NULL_BYTES* = 0x1000 + IS_TEXT_UNICODE_UNICODE_MASK* = 0x000F + IS_TEXT_UNICODE_REVERSE_MASK* = 0x00F0 + IS_TEXT_UNICODE_NOT_UNICODE_MASK* = 0x0F00 + IS_TEXT_UNICODE_NOT_ASCII_MASK* = 0xF000 + COMPRESSION_FORMAT_NONE* = 0x0000 + COMPRESSION_FORMAT_DEFAULT* = 0x0001 + COMPRESSION_FORMAT_LZNT1* = 0x0002 + COMPRESSION_FORMAT_XPRESS* = 0x0003 + COMPRESSION_FORMAT_XPRESS_HUFF* = 0x0004 + COMPRESSION_ENGINE_STANDARD* = 0x0000 + COMPRESSION_ENGINE_MAXIMUM* = 0x0100 + COMPRESSION_ENGINE_HIBER* = 0x0200 + SEF_DACL_AUTO_INHERIT* = 0x01 + SEF_SACL_AUTO_INHERIT* = 0x02 + SEF_DEFAULT_DESCRIPTOR_FOR_OBJECT* = 0x04 + SEF_AVOID_PRIVILEGE_CHECK* = 0x08 + SEF_AVOID_OWNER_CHECK* = 0x10 + SEF_DEFAULT_OWNER_FROM_PARENT* = 0x20 + SEF_DEFAULT_GROUP_FROM_PARENT* = 0x40 + SEF_MACL_NO_WRITE_UP* = 0x100 + SEF_MACL_NO_READ_UP* = 0x200 + SEF_MACL_NO_EXECUTE_UP* = 0x400 + SEF_AVOID_OWNER_RESTRICTION* = 0x1000 + SEF_MACL_VALID_FLAGS* = SEF_MACL_NO_WRITE_UP or SEF_MACL_NO_READ_UP or SEF_MACL_NO_EXECUTE_UP + MESSAGE_RESOURCE_UNICODE* = 0x0001 + VER_EQUAL* = 1 + VER_GREATER* = 2 + VER_GREATER_EQUAL* = 3 + VER_LESS* = 4 + VER_LESS_EQUAL* = 5 + VER_AND* = 6 + VER_OR* = 7 + VER_CONDITION_MASK* = 7 + VER_NUM_BITS_PER_CONDITION_MASK* = 3 + VER_MINORVERSION* = 0x0000001 + VER_MAJORVERSION* = 0x0000002 + VER_BUILDNUMBER* = 0x0000004 + VER_PLATFORMID* = 0x0000008 + VER_SERVICEPACKMINOR* = 0x0000010 + VER_SERVICEPACKMAJOR* = 0x0000020 + VER_SUITENAME* = 0x0000040 + VER_PRODUCT_TYPE* = 0x0000080 + VER_NT_WORKSTATION* = 0x0000001 + VER_NT_DOMAIN_CONTROLLER* = 0x0000002 + VER_NT_SERVER* = 0x0000003 + VER_PLATFORM_WIN32s* = 0 + VER_PLATFORM_WIN32_WINDOWS* = 1 + VER_PLATFORM_WIN32_NT* = 2 + RTL_UMS_VERSION* = 0x0100 + umsThreadInvalidInfoClass* = 0 + umsThreadUserContext* = 1 + umsThreadPriority* = 2 + umsThreadAffinity* = 3 + umsThreadTeb* = 4 + umsThreadIsSuspended* = 5 + umsThreadIsTerminated* = 6 + umsThreadMaxInfoClass* = 7 + umsSchedulerStartup* = 0 + umsSchedulerThreadBlocked* = 1 + umsSchedulerThreadYield* = 2 + VRL_PREDEFINED_CLASS_BEGIN* = 1 + VRL_CUSTOM_CLASS_BEGIN* = 1 shl 8 + VRL_CLASS_CONSISTENCY* = VRL_PREDEFINED_CLASS_BEGIN + VRL_ENABLE_KERNEL_BREAKS* = 1 shl 31 + CTMF_INCLUDE_APPCONTAINER* = 0x1 + CTMF_VALID_FLAGS* = CTMF_INCLUDE_APPCONTAINER + RTL_CRITSECT_TYPE* = 0 + RTL_RESOURCE_TYPE* = 1 + RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO* = 0x01000000 + RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN* = 0x02000000 + RTL_CRITICAL_SECTION_FLAG_STATIC_INIT* = 0x04000000 + RTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPE* = 0x08000000 + RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO* = 0x10000000 + RTL_CRITICAL_SECTION_ALL_FLAG_BITS* = 0xff000000'i32 + RTL_CRITICAL_SECTION_FLAG_RESERVED* = RTL_CRITICAL_SECTION_ALL_FLAG_BITS and (not (RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO or RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN or RTL_CRITICAL_SECTION_FLAG_STATIC_INIT or RTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPE or RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO)) + RTL_CRITICAL_SECTION_DEBUG_FLAG_STATIC_INIT* = 0x00000001 + RTL_SRWLOCK_INIT* = [0'u8] + RTL_CONDITION_VARIABLE_INIT* = [0'u8] + RTL_CONDITION_VARIABLE_LOCKMODE_SHARED* = 0x1 + heapCompatibilityInformation* = 0 + heapEnableTerminationOnCorruption* = 1 + WT_EXECUTEDEFAULT* = 0x00000000 + WT_EXECUTEINIOTHREAD* = 0x00000001 + WT_EXECUTEINUITHREAD* = 0x00000002 + WT_EXECUTEINWAITTHREAD* = 0x00000004 + WT_EXECUTEONLYONCE* = 0x00000008 + WT_EXECUTEINTIMERTHREAD* = 0x00000020 + WT_EXECUTELONGFUNCTION* = 0x00000010 + WT_EXECUTEINPERSISTENTIOTHREAD* = 0x00000040 + WT_EXECUTEINPERSISTENTTHREAD* = 0x00000080 + WT_TRANSFER_IMPERSONATION* = 0x00000100 + WT_EXECUTEDELETEWAIT* = 0x00000008 + WT_EXECUTEINLONGTHREAD* = 0x00000010 + activationContextBasicInformation* = 1 + activationContextDetailedInformation* = 2 + assemblyDetailedInformationInActivationContext* = 3 + fileInformationInAssemblyOfAssemblyInActivationContext* = 4 + runlevelInformationInActivationContext* = 5 + compatibilityInformationInActivationContext* = 6 + activationContextManifestResourceName* = 7 + maxActivationContextInfoClass* = 8 + assemblyDetailedInformationInActivationContxt* = 3 + fileInformationInAssemblyOfAssemblyInActivationContxt* = 4 + ACTCTX_RUN_LEVEL_UNSPECIFIED* = 0 + ACTCTX_RUN_LEVEL_AS_INVOKER* = 1 + ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE* = 2 + ACTCTX_RUN_LEVEL_REQUIRE_ADMIN* = 3 + ACTCTX_RUN_LEVEL_NUMBERS* = 4 + ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN* = 0 + ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS* = 1 + ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION* = 2 + ACTIVATION_CONTEXT_PATH_TYPE_NONE* = 1 + ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE* = 2 + ACTIVATION_CONTEXT_PATH_TYPE_URL* = 3 + ACTIVATION_CONTEXT_PATH_TYPE_ASSEMBLYREF* = 4 + INVALID_OS_COUNT* = 0xffff + CREATE_BOUNDARY_DESCRIPTOR_ADD_APPCONTAINER_SID* = 0x1 + RTL_VRF_FLG_FULL_PAGE_HEAP* = 0x00000001 + RTL_VRF_FLG_RESERVED_DONOTUSE* = 0x00000002 + RTL_VRF_FLG_HANDLE_CHECKS* = 0x00000004 + RTL_VRF_FLG_STACK_CHECKS* = 0x00000008 + RTL_VRF_FLG_APPCOMPAT_CHECKS* = 0x00000010 + RTL_VRF_FLG_TLS_CHECKS* = 0x00000020 + RTL_VRF_FLG_DIRTY_STACKS* = 0x00000040 + RTL_VRF_FLG_RPC_CHECKS* = 0x00000080 + RTL_VRF_FLG_COM_CHECKS* = 0x00000100 + RTL_VRF_FLG_DANGEROUS_APIS* = 0x00000200 + RTL_VRF_FLG_RACE_CHECKS* = 0x00000400 + RTL_VRF_FLG_DEADLOCK_CHECKS* = 0x00000800 + RTL_VRF_FLG_FIRST_CHANCE_EXCEPTION_CHECKS* = 0x00001000 + RTL_VRF_FLG_VIRTUAL_MEM_CHECKS* = 0x00002000 + RTL_VRF_FLG_ENABLE_LOGGING* = 0x00004000 + RTL_VRF_FLG_FAST_FILL_HEAP* = 0x00008000 + RTL_VRF_FLG_VIRTUAL_SPACE_TRACKING* = 0x00010000 + RTL_VRF_FLG_ENABLED_SYSTEM_WIDE* = 0x00020000 + RTL_VRF_FLG_MISCELLANEOUS_CHECKS* = 0x00020000 + RTL_VRF_FLG_LOCK_CHECKS* = 0x00040000 + APPLICATION_VERIFIER_INTERNAL_ERROR* = 0x80000000'i32 + APPLICATION_VERIFIER_INTERNAL_WARNING* = 0x40000000 + APPLICATION_VERIFIER_NO_BREAK* = 0x20000000 + APPLICATION_VERIFIER_CONTINUABLE_BREAK* = 0x10000000 + APPLICATION_VERIFIER_UNKNOWN_ERROR* = 0x0001 + APPLICATION_VERIFIER_ACCESS_VIOLATION* = 0x0002 + APPLICATION_VERIFIER_UNSYNCHRONIZED_ACCESS* = 0x0003 + APPLICATION_VERIFIER_EXTREME_SIZE_REQUEST* = 0x0004 + APPLICATION_VERIFIER_BAD_HEAP_HANDLE* = 0x0005 + APPLICATION_VERIFIER_SWITCHED_HEAP_HANDLE* = 0x0006 + APPLICATION_VERIFIER_DOUBLE_FREE* = 0x0007 + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK* = 0x0008 + APPLICATION_VERIFIER_DESTROY_PROCESS_HEAP* = 0x0009 + APPLICATION_VERIFIER_UNEXPECTED_EXCEPTION* = 0x000A + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_EXCEPTION_RAISED_FOR_HEADER* = 0x000B + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_EXCEPTION_RAISED_FOR_PROBING* = 0x000C + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_HEADER* = 0x000D + APPLICATION_VERIFIER_CORRUPTED_FREED_HEAP_BLOCK* = 0x000E + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_SUFFIX* = 0x000F + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_START_STAMP* = 0x0010 + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_END_STAMP* = 0x0011 + APPLICATION_VERIFIER_CORRUPTED_HEAP_BLOCK_PREFIX* = 0x0012 + APPLICATION_VERIFIER_FIRST_CHANCE_ACCESS_VIOLATION* = 0x0013 + APPLICATION_VERIFIER_CORRUPTED_HEAP_LIST* = 0x0014 + APPLICATION_VERIFIER_TERMINATE_THREAD_CALL* = 0x0100 + APPLICATION_VERIFIER_STACK_OVERFLOW* = 0x0101 + APPLICATION_VERIFIER_INVALID_EXIT_PROCESS_CALL* = 0x0102 + APPLICATION_VERIFIER_EXIT_THREAD_OWNS_LOCK* = 0x0200 + APPLICATION_VERIFIER_LOCK_IN_UNLOADED_DLL* = 0x0201 + APPLICATION_VERIFIER_LOCK_IN_FREED_HEAP* = 0x0202 + APPLICATION_VERIFIER_LOCK_DOUBLE_INITIALIZE* = 0x0203 + APPLICATION_VERIFIER_LOCK_IN_FREED_MEMORY* = 0x0204 + APPLICATION_VERIFIER_LOCK_CORRUPTED* = 0x0205 + APPLICATION_VERIFIER_LOCK_INVALID_OWNER* = 0x0206 + APPLICATION_VERIFIER_LOCK_INVALID_RECURSION_COUNT* = 0x0207 + APPLICATION_VERIFIER_LOCK_INVALID_LOCK_COUNT* = 0x0208 + APPLICATION_VERIFIER_LOCK_OVER_RELEASED* = 0x0209 + APPLICATION_VERIFIER_LOCK_NOT_INITIALIZED* = 0x0210 + APPLICATION_VERIFIER_LOCK_ALREADY_INITIALIZED* = 0x0211 + APPLICATION_VERIFIER_LOCK_IN_FREED_VMEM* = 0x0212 + APPLICATION_VERIFIER_LOCK_IN_UNMAPPED_MEM* = 0x0213 + APPLICATION_VERIFIER_THREAD_NOT_LOCK_OWNER* = 0x0214 + APPLICATION_VERIFIER_INVALID_HANDLE* = 0x0300 + APPLICATION_VERIFIER_INVALID_TLS_VALUE* = 0x0301 + APPLICATION_VERIFIER_INCORRECT_WAIT_CALL* = 0x0302 + APPLICATION_VERIFIER_NULL_HANDLE* = 0x0303 + APPLICATION_VERIFIER_WAIT_IN_DLLMAIN* = 0x0304 + APPLICATION_VERIFIER_COM_ERROR* = 0x0400 + APPLICATION_VERIFIER_COM_API_IN_DLLMAIN* = 0x0401 + APPLICATION_VERIFIER_COM_UNHANDLED_EXCEPTION* = 0x0402 + APPLICATION_VERIFIER_COM_UNBALANCED_COINIT* = 0x0403 + APPLICATION_VERIFIER_COM_UNBALANCED_OLEINIT* = 0x0404 + APPLICATION_VERIFIER_COM_UNBALANCED_SWC* = 0x0405 + APPLICATION_VERIFIER_COM_NULL_DACL* = 0x0406 + APPLICATION_VERIFIER_COM_UNSAFE_IMPERSONATION* = 0x0407 + APPLICATION_VERIFIER_COM_SMUGGLED_WRAPPER* = 0x0408 + APPLICATION_VERIFIER_COM_SMUGGLED_PROXY* = 0x0409 + APPLICATION_VERIFIER_COM_CF_SUCCESS_WITH_NULL* = 0x040A + APPLICATION_VERIFIER_COM_GCO_SUCCESS_WITH_NULL* = 0x040B + APPLICATION_VERIFIER_COM_OBJECT_IN_FREED_MEMORY* = 0x040C + APPLICATION_VERIFIER_COM_OBJECT_IN_UNLOADED_DLL* = 0x040D + APPLICATION_VERIFIER_COM_VTBL_IN_FREED_MEMORY* = 0x040E + APPLICATION_VERIFIER_COM_VTBL_IN_UNLOADED_DLL* = 0x040F + APPLICATION_VERIFIER_COM_HOLDING_LOCKS_ON_CALL* = 0x0410 + APPLICATION_VERIFIER_RPC_ERROR* = 0x0500 + APPLICATION_VERIFIER_INVALID_FREEMEM* = 0x0600 + APPLICATION_VERIFIER_INVALID_ALLOCMEM* = 0x0601 + APPLICATION_VERIFIER_INVALID_MAPVIEW* = 0x0602 + APPLICATION_VERIFIER_PROBE_INVALID_ADDRESS* = 0x0603 + APPLICATION_VERIFIER_PROBE_FREE_MEM* = 0x0604 + APPLICATION_VERIFIER_PROBE_GUARD_PAGE* = 0x0605 + APPLICATION_VERIFIER_PROBE_NULL* = 0x0606 + APPLICATION_VERIFIER_PROBE_INVALID_START_OR_SIZE* = 0x0607 + APPLICATION_VERIFIER_SIZE_HEAP_UNEXPECTED_EXCEPTION* = 0x0618 + PERFORMANCE_DATA_VERSION* = 1 + READ_THREAD_PROFILING_FLAG_DISPATCHING* = 0x00000001 + READ_THREAD_PROFILING_FLAG_HARDWARE_COUNTERS* = 0x00000002 + DLL_PROCESS_ATTACH* = 1 + DLL_THREAD_ATTACH* = 2 + DLL_THREAD_DETACH* = 3 + DLL_PROCESS_DETACH* = 0 + DLL_PROCESS_VERIFIER* = 4 + EVENTLOG_SEQUENTIAL_READ* = 0x0001 + EVENTLOG_SEEK_READ* = 0x0002 + EVENTLOG_FORWARDS_READ* = 0x0004 + EVENTLOG_BACKWARDS_READ* = 0x0008 + EVENTLOG_SUCCESS* = 0x0000 + EVENTLOG_ERROR_TYPE* = 0x0001 + EVENTLOG_WARNING_TYPE* = 0x0002 + EVENTLOG_INFORMATION_TYPE* = 0x0004 + EVENTLOG_AUDIT_SUCCESS* = 0x0008 + EVENTLOG_AUDIT_FAILURE* = 0x0010 + EVENTLOG_START_PAIRED_EVENT* = 0x0001 + EVENTLOG_END_PAIRED_EVENT* = 0x0002 + EVENTLOG_END_ALL_PAIRED_EVENTS* = 0x0004 + EVENTLOG_PAIRED_EVENT_ACTIVE* = 0x0008 + EVENTLOG_PAIRED_EVENT_INACTIVE* = 0x0010 + KEY_QUERY_VALUE* = 0x0001 + KEY_SET_VALUE* = 0x0002 + KEY_CREATE_SUB_KEY* = 0x0004 + KEY_ENUMERATE_SUB_KEYS* = 0x0008 + KEY_NOTIFY* = 0x0010 + KEY_CREATE_LINK* = 0x0020 + KEY_WOW64_64KEY* = 0x0100 + KEY_WOW64_32KEY* = 0x0200 + KEY_WOW64_RES* = 0x0300 + KEY_READ* = (STANDARD_RIGHTS_READ or KEY_QUERY_VALUE or KEY_ENUMERATE_SUB_KEYS or KEY_NOTIFY) and (not SYNCHRONIZE) + KEY_WRITE* = (STANDARD_RIGHTS_WRITE or KEY_SET_VALUE or KEY_CREATE_SUB_KEY) and (not SYNCHRONIZE) + KEY_EXECUTE* = (KEY_READ) and (not SYNCHRONIZE) + KEY_ALL_ACCESS* = (STANDARD_RIGHTS_ALL or KEY_QUERY_VALUE or KEY_SET_VALUE or KEY_CREATE_SUB_KEY or KEY_ENUMERATE_SUB_KEYS or KEY_NOTIFY or KEY_CREATE_LINK) and (not SYNCHRONIZE) + REG_OPTION_RESERVED* = 0x00000000 + REG_OPTION_NON_VOLATILE* = 0x00000000 + REG_OPTION_VOLATILE* = 0x00000001 + REG_OPTION_CREATE_LINK* = 0x00000002 + REG_OPTION_BACKUP_RESTORE* = 0x00000004 + REG_OPTION_OPEN_LINK* = 0x00000008 + REG_LEGAL_OPTION* = REG_OPTION_RESERVED or REG_OPTION_NON_VOLATILE or REG_OPTION_VOLATILE or REG_OPTION_CREATE_LINK or REG_OPTION_BACKUP_RESTORE or REG_OPTION_OPEN_LINK + REG_CREATED_NEW_KEY* = 0x00000001 + REG_OPENED_EXISTING_KEY* = 0x00000002 + REG_STANDARD_FORMAT* = 1 + REG_LATEST_FORMAT* = 2 + REG_NO_COMPRESSION* = 4 + REG_WHOLE_HIVE_VOLATILE* = 0x00000001 + REG_REFRESH_HIVE* = 0x00000002 + REG_NO_LAZY_FLUSH* = 0x00000004 + REG_FORCE_RESTORE* = 0x00000008 + REG_APP_HIVE* = 0x00000010 + REG_PROCESS_PRIVATE* = 0x00000020 + REG_START_JOURNAL* = 0x00000040 + REG_HIVE_EXACT_FILE_GROWTH* = 0x00000080 + REG_HIVE_NO_RM* = 0x00000100 + REG_HIVE_SINGLE_LOG* = 0x00000200 + REG_BOOT_HIVE* = 0x00000400 + REG_FORCE_UNLOAD* = 1 + REG_NOTIFY_CHANGE_NAME* = 0x00000001 + REG_NOTIFY_CHANGE_ATTRIBUTES* = 0x00000002 + REG_NOTIFY_CHANGE_LAST_SET* = 0x00000004 + REG_NOTIFY_CHANGE_SECURITY* = 0x00000008 + REG_NOTIFY_THREAD_AGNOSTIC* = 0x10000000 + REG_LEGAL_CHANGE_FILTER* = REG_NOTIFY_CHANGE_NAME or REG_NOTIFY_CHANGE_ATTRIBUTES or REG_NOTIFY_CHANGE_LAST_SET or REG_NOTIFY_CHANGE_SECURITY or REG_NOTIFY_THREAD_AGNOSTIC + REG_NONE* = 0 + REG_SZ* = 1 + REG_EXPAND_SZ* = 2 + REG_BINARY* = 3 + REG_DWORD* = 4 + REG_DWORD_LITTLE_ENDIAN* = 4 + REG_DWORD_BIG_ENDIAN* = 5 + REG_LINK* = 6 + REG_MULTI_SZ* = 7 + REG_RESOURCE_LIST* = 8 + REG_FULL_RESOURCE_DESCRIPTOR* = 9 + REG_RESOURCE_REQUIREMENTS_LIST* = 10 + REG_QWORD* = 11 + REG_QWORD_LITTLE_ENDIAN* = 11 + SERVICE_KERNEL_DRIVER* = 0x00000001 + SERVICE_FILE_SYSTEM_DRIVER* = 0x00000002 + SERVICE_ADAPTER* = 0x00000004 + SERVICE_RECOGNIZER_DRIVER* = 0x00000008 + SERVICE_DRIVER* = SERVICE_KERNEL_DRIVER or SERVICE_FILE_SYSTEM_DRIVER or SERVICE_RECOGNIZER_DRIVER + SERVICE_WIN32_OWN_PROCESS* = 0x00000010 + SERVICE_WIN32_SHARE_PROCESS* = 0x00000020 + SERVICE_WIN32* = SERVICE_WIN32_OWN_PROCESS or SERVICE_WIN32_SHARE_PROCESS + SERVICE_INTERACTIVE_PROCESS* = 0x00000100 + SERVICE_TYPE_ALL* = SERVICE_WIN32 or SERVICE_ADAPTER or SERVICE_DRIVER or SERVICE_INTERACTIVE_PROCESS + SERVICE_BOOT_START* = 0x00000000 + SERVICE_SYSTEM_START* = 0x00000001 + SERVICE_AUTO_START* = 0x00000002 + SERVICE_DEMAND_START* = 0x00000003 + SERVICE_DISABLED* = 0x00000004 + SERVICE_ERROR_IGNORE* = 0x00000000 + SERVICE_ERROR_NORMAL* = 0x00000001 + SERVICE_ERROR_SEVERE* = 0x00000002 + SERVICE_ERROR_CRITICAL* = 0x00000003 + driverType* = SERVICE_KERNEL_DRIVER + fileSystemType* = SERVICE_FILE_SYSTEM_DRIVER + win32ServiceOwnProcess* = SERVICE_WIN32_OWN_PROCESS + win32ServiceShareProcess* = SERVICE_WIN32_SHARE_PROCESS + adapterType* = SERVICE_ADAPTER + recognizerType* = SERVICE_RECOGNIZER_DRIVER + bootLoad* = SERVICE_BOOT_START + systemLoad* = SERVICE_SYSTEM_START + autoLoad* = SERVICE_AUTO_START + demandLoad* = SERVICE_DEMAND_START + disableLoad* = SERVICE_DISABLED + ignoreError* = SERVICE_ERROR_IGNORE + normalError* = SERVICE_ERROR_NORMAL + severeError* = SERVICE_ERROR_SEVERE + criticalError* = SERVICE_ERROR_CRITICAL + CM_SERVICE_NETWORK_BOOT_LOAD* = 0x00000001 + CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD* = 0x00000002 + CM_SERVICE_USB_DISK_BOOT_LOAD* = 0x00000004 + CM_SERVICE_SD_DISK_BOOT_LOAD* = 0x00000008 + CM_SERVICE_USB3_DISK_BOOT_LOAD* = 0x00000010 + CM_SERVICE_MEASURED_BOOT_LOAD* = 0x00000020 + CM_SERVICE_VERIFIER_BOOT_LOAD* = 0x00000040 + CM_SERVICE_WINPE_BOOT_LOAD* = 0x00000080 + CM_SERVICE_VALID_PROMOTION_MASK* = CM_SERVICE_NETWORK_BOOT_LOAD or CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD or CM_SERVICE_USB_DISK_BOOT_LOAD or CM_SERVICE_SD_DISK_BOOT_LOAD or CM_SERVICE_USB3_DISK_BOOT_LOAD or CM_SERVICE_MEASURED_BOOT_LOAD or CM_SERVICE_VERIFIER_BOOT_LOAD or CM_SERVICE_WINPE_BOOT_LOAD + TAPE_ERASE_SHORT* = 0 + TAPE_ERASE_LONG* = 1 + TAPE_LOAD* = 0 + TAPE_UNLOAD* = 1 + TAPE_TENSION* = 2 + TAPE_LOCK* = 3 + TAPE_UNLOCK* = 4 + TAPE_FORMAT* = 5 + TAPE_SETMARKS* = 0 + TAPE_FILEMARKS* = 1 + TAPE_SHORT_FILEMARKS* = 2 + TAPE_LONG_FILEMARKS* = 3 + TAPE_ABSOLUTE_POSITION* = 0 + TAPE_LOGICAL_POSITION* = 1 + TAPE_PSEUDO_LOGICAL_POSITION* = 2 + TAPE_REWIND* = 0 + TAPE_ABSOLUTE_BLOCK* = 1 + TAPE_LOGICAL_BLOCK* = 2 + TAPE_PSEUDO_LOGICAL_BLOCK* = 3 + TAPE_SPACE_END_OF_DATA* = 4 + TAPE_SPACE_RELATIVE_BLOCKS* = 5 + TAPE_SPACE_FILEMARKS* = 6 + TAPE_SPACE_SEQUENTIAL_FMKS* = 7 + TAPE_SPACE_SETMARKS* = 8 + TAPE_SPACE_SEQUENTIAL_SMKS* = 9 + TAPE_DRIVE_FIXED* = 0x00000001 + TAPE_DRIVE_SELECT* = 0x00000002 + TAPE_DRIVE_INITIATOR* = 0x00000004 + TAPE_DRIVE_ERASE_SHORT* = 0x00000010 + TAPE_DRIVE_ERASE_LONG* = 0x00000020 + TAPE_DRIVE_ERASE_BOP_ONLY* = 0x00000040 + TAPE_DRIVE_ERASE_IMMEDIATE* = 0x00000080 + TAPE_DRIVE_TAPE_CAPACITY* = 0x00000100 + TAPE_DRIVE_TAPE_REMAINING* = 0x00000200 + TAPE_DRIVE_FIXED_BLOCK* = 0x00000400 + TAPE_DRIVE_VARIABLE_BLOCK* = 0x00000800 + TAPE_DRIVE_WRITE_PROTECT* = 0x00001000 + TAPE_DRIVE_EOT_WZ_SIZE* = 0x00002000 + TAPE_DRIVE_ECC* = 0x00010000 + TAPE_DRIVE_COMPRESSION* = 0x00020000 + TAPE_DRIVE_PADDING* = 0x00040000 + TAPE_DRIVE_REPORT_SMKS* = 0x00080000 + TAPE_DRIVE_GET_ABSOLUTE_BLK* = 0x00100000 + TAPE_DRIVE_GET_LOGICAL_BLK* = 0x00200000 + TAPE_DRIVE_SET_EOT_WZ_SIZE* = 0x00400000 + TAPE_DRIVE_EJECT_MEDIA* = 0x01000000 + TAPE_DRIVE_CLEAN_REQUESTS* = 0x02000000 + TAPE_DRIVE_SET_CMP_BOP_ONLY* = 0x04000000 + TAPE_DRIVE_RESERVED_BIT* = 0x80000000'i32 + TAPE_DRIVE_LOAD_UNLOAD* = 0x80000001'i32 + TAPE_DRIVE_TENSION* = 0x80000002'i32 + TAPE_DRIVE_LOCK_UNLOCK* = 0x80000004'i32 + TAPE_DRIVE_REWIND_IMMEDIATE* = 0x80000008'i32 + TAPE_DRIVE_SET_BLOCK_SIZE* = 0x80000010'i32 + TAPE_DRIVE_LOAD_UNLD_IMMED* = 0x80000020'i32 + TAPE_DRIVE_TENSION_IMMED* = 0x80000040'i32 + TAPE_DRIVE_LOCK_UNLK_IMMED* = 0x80000080'i32 + TAPE_DRIVE_SET_ECC* = 0x80000100'i32 + TAPE_DRIVE_SET_COMPRESSION* = 0x80000200'i32 + TAPE_DRIVE_SET_PADDING* = 0x80000400'i32 + TAPE_DRIVE_SET_REPORT_SMKS* = 0x80000800'i32 + TAPE_DRIVE_ABSOLUTE_BLK* = 0x80001000'i32 + TAPE_DRIVE_ABS_BLK_IMMED* = 0x80002000'i32 + TAPE_DRIVE_LOGICAL_BLK* = 0x80004000'i32 + TAPE_DRIVE_LOG_BLK_IMMED* = 0x80008000'i32 + TAPE_DRIVE_END_OF_DATA* = 0x80010000'i32 + TAPE_DRIVE_RELATIVE_BLKS* = 0x80020000'i32 + TAPE_DRIVE_FILEMARKS* = 0x80040000'i32 + TAPE_DRIVE_SEQUENTIAL_FMKS* = 0x80080000'i32 + TAPE_DRIVE_SETMARKS* = 0x80100000'i32 + TAPE_DRIVE_SEQUENTIAL_SMKS* = 0x80200000'i32 + TAPE_DRIVE_REVERSE_POSITION* = 0x80400000'i32 + TAPE_DRIVE_SPACE_IMMEDIATE* = 0x80800000'i32 + TAPE_DRIVE_WRITE_SETMARKS* = 0x81000000'i32 + TAPE_DRIVE_WRITE_FILEMARKS* = 0x82000000'i32 + TAPE_DRIVE_WRITE_SHORT_FMKS* = 0x84000000'i32 + TAPE_DRIVE_WRITE_LONG_FMKS* = 0x88000000'i32 + TAPE_DRIVE_WRITE_MARK_IMMED* = 0x90000000'i32 + TAPE_DRIVE_FORMAT* = 0xA0000000'i32 + TAPE_DRIVE_FORMAT_IMMEDIATE* = 0xC0000000'i32 + TAPE_DRIVE_HIGH_FEATURES* = 0x80000000'i32 + TAPE_FIXED_PARTITIONS* = 0 + TAPE_SELECT_PARTITIONS* = 1 + TAPE_INITIATOR_PARTITIONS* = 2 + TAPE_QUERY_DRIVE_PARAMETERS* = 0 + TAPE_QUERY_MEDIA_CAPACITY* = 1 + TAPE_CHECK_FOR_DRIVE_PROBLEM* = 2 + TAPE_QUERY_IO_ERROR_DATA* = 3 + TAPE_QUERY_DEVICE_ERROR_DATA* = 4 + tapeDriveProblemNone* = 0 + tapeDriveReadWriteWarning* = 1 + tapeDriveReadWriteError* = 2 + tapeDriveReadWarning* = 3 + tapeDriveWriteWarning* = 4 + tapeDriveReadError* = 5 + tapeDriveWriteError* = 6 + tapeDriveHardwareError* = 7 + tapeDriveUnsupportedMedia* = 8 + tapeDriveScsiConnectionError* = 9 + tapeDriveTimetoClean* = 10 + tapeDriveCleanDriveNow* = 11 + tapeDriveMediaLifeExpired* = 12 + tapeDriveSnappedTape* = 13 + TP_CALLBACK_PRIORITY_HIGH* = 0 + TP_CALLBACK_PRIORITY_NORMAL* = 1 + TP_CALLBACK_PRIORITY_LOW* = 2 + TP_CALLBACK_PRIORITY_INVALID* = 3 + TP_CALLBACK_PRIORITY_COUNT* = TP_CALLBACK_PRIORITY_INVALID + TRANSACTION_MANAGER_VOLATILE* = 0x00000001 + TRANSACTION_MANAGER_COMMIT_DEFAULT* = 0x00000000 + TRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUME* = 0x00000002 + TRANSACTION_MANAGER_COMMIT_SYSTEM_HIVES* = 0x00000004 + TRANSACTION_MANAGER_COMMIT_LOWEST* = 0x00000008 + TRANSACTION_MANAGER_CORRUPT_FOR_RECOVERY* = 0x00000010 + TRANSACTION_MANAGER_CORRUPT_FOR_PROGRESS* = 0x00000020 + TRANSACTION_MANAGER_MAXIMUM_OPTION* = 0x0000003f + TRANSACTION_DO_NOT_PROMOTE* = 0x00000001 + TRANSACTION_MAXIMUM_OPTION* = 0x00000001 + RESOURCE_MANAGER_VOLATILE* = 0x00000001 + RESOURCE_MANAGER_COMMUNICATION* = 0x00000002 + RESOURCE_MANAGER_MAXIMUM_OPTION* = 0x00000003 + CRM_PROTOCOL_EXPLICIT_MARSHAL_ONLY* = 0x00000001 + CRM_PROTOCOL_DYNAMIC_MARSHAL_INFO* = 0x00000002 + CRM_PROTOCOL_MAXIMUM_OPTION* = 0x00000003 + ENLISTMENT_SUPERIOR* = 0x00000001 + ENLISTMENT_MAXIMUM_OPTION* = 0x00000001 + TRANSACTION_NOTIFY_MASK* = 0x3fffffff + TRANSACTION_NOTIFY_PREPREPARE* = 0x00000001 + TRANSACTION_NOTIFY_PREPARE* = 0x00000002 + TRANSACTION_NOTIFY_COMMIT* = 0x00000004 + TRANSACTION_NOTIFY_ROLLBACK* = 0x00000008 + TRANSACTION_NOTIFY_PREPREPARE_COMPLETE* = 0x00000010 + TRANSACTION_NOTIFY_PREPARE_COMPLETE* = 0x00000020 + TRANSACTION_NOTIFY_COMMIT_COMPLETE* = 0x00000040 + TRANSACTION_NOTIFY_ROLLBACK_COMPLETE* = 0x00000080 + TRANSACTION_NOTIFY_RECOVER* = 0x00000100 + TRANSACTION_NOTIFY_SINGLE_PHASE_COMMIT* = 0x00000200 + TRANSACTION_NOTIFY_DELEGATE_COMMIT* = 0x00000400 + TRANSACTION_NOTIFY_RECOVER_QUERY* = 0x00000800 + TRANSACTION_NOTIFY_ENLIST_PREPREPARE* = 0x00001000 + TRANSACTION_NOTIFY_LAST_RECOVER* = 0x00002000 + TRANSACTION_NOTIFY_INDOUBT* = 0x00004000 + TRANSACTION_NOTIFY_PROPAGATE_PULL* = 0x00008000 + TRANSACTION_NOTIFY_PROPAGATE_PUSH* = 0x00010000 + TRANSACTION_NOTIFY_MARSHAL* = 0x00020000 + TRANSACTION_NOTIFY_ENLIST_MASK* = 0x00040000 + TRANSACTION_NOTIFY_RM_DISCONNECTED* = 0x01000000 + TRANSACTION_NOTIFY_TM_ONLINE* = 0x02000000 + TRANSACTION_NOTIFY_COMMIT_REQUEST* = 0x04000000 + TRANSACTION_NOTIFY_PROMOTE* = 0x08000000 + TRANSACTION_NOTIFY_PROMOTE_NEW* = 0x10000000 + TRANSACTION_NOTIFY_REQUEST_OUTCOME* = 0x20000000 + TRANSACTION_NOTIFY_COMMIT_FINALIZE* = 0x40000000 + TRANSACTIONMANAGER_OBJECT_PATH* = "\\TransactionManager\\" + TRANSACTION_OBJECT_PATH* = "\\Transaction\\" + ENLISTMENT_OBJECT_PATH* = "\\Enlistment\\" + RESOURCE_MANAGER_OBJECT_PATH* = "\\ResourceManager\\" + TRANSACTION_NOTIFICATION_TM_ONLINE_FLAG_IS_CLUSTERED* = 0x1 + KTM_MARSHAL_BLOB_VERSION_MAJOR* = 1 + KTM_MARSHAL_BLOB_VERSION_MINOR* = 1 + MAX_RESOURCEMANAGER_DESCRIPTION_LENGTH* = 64 + TRANSACTIONMANAGER_QUERY_INFORMATION* = 0x00001 + TRANSACTIONMANAGER_SET_INFORMATION* = 0x00002 + TRANSACTIONMANAGER_RECOVER* = 0x00004 + TRANSACTIONMANAGER_RENAME* = 0x00008 + TRANSACTIONMANAGER_CREATE_RM* = 0x00010 + TRANSACTIONMANAGER_BIND_TRANSACTION* = 0x00020 + TRANSACTIONMANAGER_GENERIC_READ* = STANDARD_RIGHTS_READ or TRANSACTIONMANAGER_QUERY_INFORMATION + TRANSACTIONMANAGER_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or TRANSACTIONMANAGER_SET_INFORMATION or TRANSACTIONMANAGER_RECOVER or TRANSACTIONMANAGER_RENAME or TRANSACTIONMANAGER_CREATE_RM + TRANSACTIONMANAGER_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE + TRANSACTIONMANAGER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or TRANSACTIONMANAGER_GENERIC_READ or TRANSACTIONMANAGER_GENERIC_WRITE or TRANSACTIONMANAGER_GENERIC_EXECUTE or TRANSACTIONMANAGER_BIND_TRANSACTION + TRANSACTION_QUERY_INFORMATION* = 0x0001 + TRANSACTION_SET_INFORMATION* = 0x0002 + TRANSACTION_ENLIST* = 0x0004 + TRANSACTION_COMMIT* = 0x0008 + TRANSACTION_ROLLBACK* = 0x0010 + TRANSACTION_PROPAGATE* = 0x0020 + TRANSACTION_RIGHT_RESERVED1* = 0x0040 + TRANSACTION_GENERIC_READ* = STANDARD_RIGHTS_READ or TRANSACTION_QUERY_INFORMATION or SYNCHRONIZE + TRANSACTION_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or TRANSACTION_SET_INFORMATION or TRANSACTION_COMMIT or TRANSACTION_ENLIST or TRANSACTION_ROLLBACK or TRANSACTION_PROPAGATE or SYNCHRONIZE + TRANSACTION_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE or TRANSACTION_COMMIT or TRANSACTION_ROLLBACK or SYNCHRONIZE + TRANSACTION_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or TRANSACTION_GENERIC_READ or TRANSACTION_GENERIC_WRITE or TRANSACTION_GENERIC_EXECUTE + TRANSACTION_RESOURCE_MANAGER_RIGHTS* = TRANSACTION_GENERIC_READ or STANDARD_RIGHTS_WRITE or TRANSACTION_SET_INFORMATION or TRANSACTION_ENLIST or TRANSACTION_ROLLBACK or TRANSACTION_PROPAGATE or SYNCHRONIZE + RESOURCEMANAGER_QUERY_INFORMATION* = 0x0001 + RESOURCEMANAGER_SET_INFORMATION* = 0x0002 + RESOURCEMANAGER_RECOVER* = 0x0004 + RESOURCEMANAGER_ENLIST* = 0x0008 + RESOURCEMANAGER_GET_NOTIFICATION* = 0x0010 + RESOURCEMANAGER_REGISTER_PROTOCOL* = 0x0020 + RESOURCEMANAGER_COMPLETE_PROPAGATION* = 0x0040 + RESOURCEMANAGER_GENERIC_READ* = STANDARD_RIGHTS_READ or RESOURCEMANAGER_QUERY_INFORMATION or SYNCHRONIZE + RESOURCEMANAGER_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or RESOURCEMANAGER_SET_INFORMATION or RESOURCEMANAGER_RECOVER or RESOURCEMANAGER_ENLIST or RESOURCEMANAGER_GET_NOTIFICATION or RESOURCEMANAGER_REGISTER_PROTOCOL or RESOURCEMANAGER_COMPLETE_PROPAGATION or SYNCHRONIZE + RESOURCEMANAGER_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE or RESOURCEMANAGER_RECOVER or RESOURCEMANAGER_ENLIST or RESOURCEMANAGER_GET_NOTIFICATION or RESOURCEMANAGER_COMPLETE_PROPAGATION or SYNCHRONIZE + RESOURCEMANAGER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or RESOURCEMANAGER_GENERIC_READ or RESOURCEMANAGER_GENERIC_WRITE or RESOURCEMANAGER_GENERIC_EXECUTE + ENLISTMENT_QUERY_INFORMATION* = 1 + ENLISTMENT_SET_INFORMATION* = 2 + ENLISTMENT_RECOVER* = 4 + ENLISTMENT_SUBORDINATE_RIGHTS* = 8 + ENLISTMENT_SUPERIOR_RIGHTS* = 0x10 + ENLISTMENT_GENERIC_READ* = STANDARD_RIGHTS_READ or ENLISTMENT_QUERY_INFORMATION + ENLISTMENT_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or ENLISTMENT_SET_INFORMATION or ENLISTMENT_RECOVER or ENLISTMENT_SUBORDINATE_RIGHTS or ENLISTMENT_SUPERIOR_RIGHTS + ENLISTMENT_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE or ENLISTMENT_RECOVER or ENLISTMENT_SUBORDINATE_RIGHTS or ENLISTMENT_SUPERIOR_RIGHTS + ENLISTMENT_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or ENLISTMENT_GENERIC_READ or ENLISTMENT_GENERIC_WRITE or ENLISTMENT_GENERIC_EXECUTE + transactionOutcomeUndetermined* = 1 + transactionOutcomeCommitted* = 2 + transactionOutcomeAborted* = 3 + transactionStateNormal* = 1 + transactionStateIndoubt* = 2 + transactionStateCommittedNotify* = 3 + transactionBasicInformation* = 0 + transactionPropertiesInformation* = 1 + transactionEnlistmentInformation* = 2 + transactionSuperiorEnlistmentInformation* = 3 + transactionBindInformation* = 4 + transactionDTCPrivateInformation* = 5 + transactionManagerBasicInformation* = 0 + transactionManagerLogInformation* = 1 + transactionManagerLogPathInformation* = 2 + transactionManagerOnlineProbeInformation* = 3 + transactionManagerRecoveryInformation* = 4 + transactionManagerOldestTransactionInformation* = 5 + resourceManagerBasicInformation* = 0 + resourceManagerCompletionInformation* = 1 + enlistmentBasicInformation* = 0 + enlistmentRecoveryInformation* = 1 + enlistmentCrmInformation* = 2 + KTMOBJECT_TRANSACTION* = 0 + KTMOBJECT_TRANSACTION_MANAGER* = 1 + KTMOBJECT_RESOURCE_MANAGER* = 2 + KTMOBJECT_ENLISTMENT* = 3 + KTMOBJECT_INVALID* = 4 + WOW64_CONTEXT_i386* = 0x00010000 + WOW64_CONTEXT_i486* = 0x00010000 + WOW64_CONTEXT_CONTROL* = WOW64_CONTEXT_i386 or 0x00000001 + WOW64_CONTEXT_INTEGER* = WOW64_CONTEXT_i386 or 0x00000002 + WOW64_CONTEXT_SEGMENTS* = WOW64_CONTEXT_i386 or 0x00000004 + WOW64_CONTEXT_FLOATING_POINT* = WOW64_CONTEXT_i386 or 0x00000008 + WOW64_CONTEXT_DEBUG_REGISTERS* = WOW64_CONTEXT_i386 or 0x00000010 + WOW64_CONTEXT_EXTENDED_REGISTERS* = WOW64_CONTEXT_i386 or 0x00000020 + WOW64_CONTEXT_FULL* = WOW64_CONTEXT_CONTROL or WOW64_CONTEXT_INTEGER or WOW64_CONTEXT_SEGMENTS + WOW64_CONTEXT_ALL* = WOW64_CONTEXT_CONTROL or WOW64_CONTEXT_INTEGER or WOW64_CONTEXT_SEGMENTS or WOW64_CONTEXT_FLOATING_POINT or WOW64_CONTEXT_DEBUG_REGISTERS or WOW64_CONTEXT_EXTENDED_REGISTERS + WOW64_CONTEXT_XSTATE* = WOW64_CONTEXT_i386 or 0x00000040 + WOW64_CONTEXT_EXCEPTION_ACTIVE* = 0x08000000 + WOW64_CONTEXT_SERVICE_ACTIVE* = 0x10000000 + WOW64_CONTEXT_EXCEPTION_REQUEST* = 0x40000000 + WOW64_CONTEXT_EXCEPTION_REPORTING* = 0x80000000'i32 + ALL_PROCESSOR_GROUPS* = 0xffff + ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION* = 1 + ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION* = 2 + ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION* = 3 + ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION* = 4 + ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION* = 5 + ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION* = 6 + ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION* = 7 + ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE* = 8 + ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES* = 9 + ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS* = 10 + ACTIVATION_CONTEXT_SECTION_COMPATIBILITY_INFO* = 11 + HFILE_ERROR* = HFILE(-1) + DM_UPDATE* = 1 + DM_COPY* = 2 + DM_PROMPT* = 4 + DM_MODIFY* = 8 + DM_IN_BUFFER* = DM_MODIFY + DM_IN_PROMPT* = DM_PROMPT + DM_OUT_BUFFER* = DM_COPY + DM_OUT_DEFAULT* = DM_UPDATE + DC_FIELDS* = 1 + DC_PAPERS* = 2 + DC_PAPERSIZE* = 3 + DC_MINEXTENT* = 4 + DC_MAXEXTENT* = 5 + DC_BINS* = 6 + DC_DUPLEX* = 7 + DC_SIZE* = 8 + DC_EXTRA* = 9 + DC_VERSION* = 10 + DC_DRIVER* = 11 + DC_BINNAMES* = 12 + DC_ENUMRESOLUTIONS* = 13 + DC_FILEDEPENDENCIES* = 14 + DC_TRUETYPE* = 15 + DC_PAPERNAMES* = 16 + DC_ORIENTATION* = 17 + DC_COPIES* = 18 + fileDirectoryInformation* = 1 + fileFullDirectoryInformation* = 2 + fileBothDirectoryInformation* = 3 + fileBasicInformation* = 4 + fileStandardInformation* = 5 + fileInternalInformation* = 6 + fileEaInformation* = 7 + fileAccessInformation* = 8 + fileNameInformation* = 9 + fileRenameInformation* = 10 + fileLinkInformation* = 11 + fileNamesInformation* = 12 + fileDispositionInformation* = 13 + filePositionInformation* = 14 + fileFullEaInformation* = 15 + fileModeInformation* = 16 + fileAlignmentInformation* = 17 + fileAllInformation* = 18 + fileAllocationInformation* = 19 + fileEndOfFileInformation* = 20 + fileAlternateNameInformation* = 21 + fileStreamInformation* = 22 + filePipeInformation* = 23 + filePipeLocalInformation* = 24 + filePipeRemoteInformation* = 25 + fileMailslotQueryInformation* = 26 + fileMailslotSetInformation* = 27 + fileCompressionInformation* = 28 + fileObjectIdInformation* = 29 + fileCompletionInformation* = 30 + fileMoveClusterInformation* = 31 + fileQuotaInformation* = 32 + fileReparsePointInformation* = 33 + fileNetworkOpenInformation* = 34 + fileAttributeTagInformation* = 35 + fileTrackingInformation* = 36 + fileIdBothDirectoryInformation* = 37 + fileIdFullDirectoryInformation* = 38 + fileValidDataLengthInformation* = 39 + fileShortNameInformation* = 40 + fileSfioReserveInformation* = 44 + fileSfioVolumeInformation* = 45 + fileHardLinkInformation* = 46 + fileNormalizedNameInformation* = 48 + fileIdGlobalTxDirectoryInformation* = 50 + fileStandardLinkInformation* = 54 + fileMaximumInformation* = 55 + fileFsVolumeInformation* = 1 + fileFsLabelInformation* = 2 + fileFsSizeInformation* = 3 + fileFsDeviceInformation* = 4 + fileFsAttributeInformation* = 5 + fileFsControlInformation* = 6 + fileFsFullSizeInformation* = 7 + fileFsObjectIdInformation* = 8 + fileFsDriverPathInformation* = 9 + fileFsVolumeFlagsInformation* = 10 + fileFsMaximumInformation* = 11 + stateInitialized* = 0 + stateReady* = 1 + stateRunning* = 2 + stateStandby* = 3 + stateTerminated* = 4 + stateWait* = 5 + stateTransition* = 6 + stateUnknown* = 7 + executive* = 0 + freePage* = 1 + pageIn* = 2 + poolAllocation* = 3 + delayExecution* = 4 + suspended* = 5 + userRequest* = 6 + wrExecutive* = 7 + wrFreePage* = 8 + wrPageIn* = 9 + wrPoolAllocation* = 10 + wrDelayExecution* = 11 + wrSuspended* = 12 + wrUserRequest* = 13 + wrEventPair* = 14 + wrQueue* = 15 + wrLpcReceive* = 16 + wrLpcReply* = 17 + wrVirtualMemory* = 18 + wrPageOut* = 19 + wrRendezvous* = 20 + spare2* = 21 + spare3* = 22 + spare4* = 23 + spare5* = 24 + spare6* = 25 + wrKernel* = 26 + maximumWaitReason* = 27 + processBasicInformation* = 0 + processQuotaLimits* = 1 + processIoCounters* = 2 + processVmCounters* = 3 + processTimes* = 4 + processBasePriority* = 5 + processRaisePriority* = 6 + processDebugPort* = 7 + processExceptionPort* = 8 + processAccessToken* = 9 + processLdtInformation* = 10 + processLdtSize* = 11 + processDefaultHardErrorMode* = 12 + processIoPortHandlers* = 13 + processPooledUsageAndLimits* = 14 + processWorkingSetWatch* = 15 + processUserModeIOPL* = 16 + processEnableAlignmentFaultFixup* = 17 + processPriorityClass* = 18 + processWx86Information* = 19 + processHandleCount* = 20 + processAffinityMask* = 21 + processPriorityBoost* = 22 + processDeviceMap* = 23 + processSessionInformation* = 24 + processForegroundInformation* = 25 + processWow64Information* = 26 + processImageFileName* = 27 + processLUIDDeviceMapsEnabled* = 28 + processBreakOnTermination* = 29 + processDebugObjectHandle* = 30 + processDebugFlags* = 31 + processHandleTracing* = 32 + processIoPriority* = 33 + processExecuteFlags* = 34 + processTlsInformation* = 35 + processCookie* = 36 + processImageInformation* = 37 + processCycleTime* = 38 + processPagePriority* = 39 + processInstrumentationCallback* = 40 + processThreadStackAllocation* = 41 + processWorkingSetWatchEx* = 42 + processImageFileNameWin32* = 43 + processImageFileMapping* = 44 + processAffinityUpdateMode* = 45 + processMemoryAllocationMode* = 46 + processGroupInformation* = 47 + processTokenVirtualizationEnabled* = 48 + processConsoleHostProcess* = 49 + processWindowInformation* = 50 + maxProcessInfoClass* = 51 + threadBasicInformation* = 0 + threadTimes* = 1 + threadPriority* = 2 + threadBasePriority* = 3 + threadAffinityMask* = 4 + threadImpersonationToken* = 5 + threadDescriptorTableEntry* = 6 + threadEnableAlignmentFaultFixup* = 7 + threadEventPair* = 8 + threadQuerySetWin32StartAddress* = 9 + threadZeroTlsCell* = 10 + threadPerformanceCount* = 11 + threadAmILastThread* = 12 + threadIdealProcessor* = 13 + threadPriorityBoost* = 14 + threadSetTlsArrayAddress* = 15 + threadIsIoPending* = 16 + threadHideFromDebugger* = 17 + systemBasicInformation* = 0 + systemProcessorInformation* = 1 + systemPerformanceInformation* = 2 + systemTimeOfDayInformation* = 3 + systemProcessInformation* = 5 + systemProcessorPerformanceInformation* = 8 + systemHandleInformation* = 16 + systemPagefileInformation* = 18 + systemInterruptInformation* = 23 + systemExceptionInformation* = 33 + systemRegistryQuotaInformation* = 37 + systemLookasideInformation* = 45 + objectBasicInformation* = 0 + objectNameInformation* = 1 + objectTypeInformation* = 2 + objectAllInformation* = 3 + objectDataInformation* = 4 + LOGONID_CURRENT* = ULONG(-1) + winStationInformation* = 8 + REPARSE_DATA_BUFFER_HEADER_SIZE* = 0x00000008 + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE* = 0x00000018 + SECURITY_DESCRIPTOR_MIN_LENGTH* = 0x00000028 + NULL* = nil + NULL64* = nil + SYSTEM_LUID* = LUID(LowPart: 0x3e7, HighPart: 0x0) + ANONYMOUS_LOGON_LUID* = LUID(LowPart: 0x3e6, HighPart: 0x0) + LOCALSERVICE_LUID* = LUID(LowPart: 0x3e5, HighPart: 0x0) + NETWORKSERVICE_LUID* = LUID(LowPart: 0x3e4, HighPart: 0x0) + IUSER_LUID* = LUID(LowPart: 0x3e3, HighPart: 0x0) + SERVERNAME_CURRENT* = HANDLE 0 + TRANSACTIONMANAGER_OBJECT_NAME_LENGTH_IN_BYTES* = (len(TRANSACTIONMANAGER_OBJECT_PATH)+1)+(38*sizeof(WCHAR)) + TRANSACTION_OBJECT_NAME_LENGTH_IN_BYTES* = (len(TRANSACTION_OBJECT_PATH)+1)+(38*sizeof(WCHAR)) + ENLISTMENT_OBJECT_NAME_LENGTH_IN_BYTES* = (len(ENLISTMENT_OBJECT_PATH)+1)+(38*sizeof(WCHAR)) + RESOURCE_MANAGER_OBJECT_NAME_LENGTH_IN_BYTES* = (len(RESOURCE_MANAGER_OBJECT_PATH)+1)+(38*sizeof(WCHAR)) + IMAGE_SYM_CLASS_END_OF_FUNCTION* = not BYTE(0) +type + PHNDLR* = proc (P1: int32): void {.stdcall.} + PEXCEPTION_HANDLER* = proc (P1: ptr EXCEPTION_RECORD, P2: pointer, P3: ptr CONTEXT, P4: pointer): EXCEPTION_DISPOSITION {.stdcall.} + PIMAGE_TLS_CALLBACK* = proc (DllHandle: PVOID, Reason: DWORD, Reserved: PVOID): VOID {.stdcall.} + PRTL_RUN_ONCE_INIT_FN* = proc (P1: PRTL_RUN_ONCE, P2: PVOID, P3: ptr PVOID): DWORD {.stdcall.} + PAPCFUNC* = proc (Parameter: ULONG_PTR): VOID {.stdcall.} + PVECTORED_EXCEPTION_HANDLER* = proc (ExceptionInfo: ptr EXCEPTION_POINTERS): LONG {.stdcall.} + WORKERCALLBACKFUNC* = proc (P1: PVOID): VOID {.stdcall.} + APC_CALLBACK_FUNCTION* = proc (P1: DWORD, P2: PVOID, P3: PVOID): VOID {.stdcall.} + PFLS_CALLBACK_FUNCTION* = proc (lpFlsData: PVOID): VOID {.stdcall.} + PSECURE_MEMORY_CACHE_CALLBACK* = proc (Addr: PVOID, Range: SIZE_T): BOOLEAN {.stdcall.} + PTP_WORK_CALLBACK* = proc (Instance: PTP_CALLBACK_INSTANCE, Context: PVOID, Work: PTP_WORK): VOID {.stdcall.} + PTP_TIMER_CALLBACK* = proc (Instance: PTP_CALLBACK_INSTANCE, Context: PVOID, Timer: PTP_TIMER): VOID {.stdcall.} + PTP_WAIT_CALLBACK* = proc (Instance: PTP_CALLBACK_INSTANCE, Context: PVOID, Wait: PTP_WAIT, WaitResult: TP_WAIT_RESULT): VOID {.stdcall.} + PIO_APC_ROUTINE* = proc (ApcContext: PVOID, IoStatusBlock: PIO_STATUS_BLOCK, Reserved: ULONG): VOID {.stdcall.} + PWINSTATIONQUERYINFORMATIONW* = proc (P1: HANDLE, P2: ULONG, P3: WINSTATIONINFOCLASS, P4: PVOID, P5: ULONG, P6: PULONG): BOOLEAN {.stdcall.} + XCPT_ACTION* {.pure.} = object + XcptNum*: int32 + SigNum*: int32 + XcptAction*: PHNDLR + OBJECTID* {.pure.} = object + Lineage*: GUID + Uniquifier*: DWORD + ANON_OBJECT_HEADER* {.pure.} = object + Sig1*: WORD + Sig2*: WORD + Version*: WORD + Machine*: WORD + TimeDateStamp*: DWORD + ClassID*: CLSID + SizeOfData*: DWORD + ANON_OBJECT_HEADER_V2* {.pure.} = object + Sig1*: WORD + Sig2*: WORD + Version*: WORD + Machine*: WORD + TimeDateStamp*: DWORD + ClassID*: CLSID + SizeOfData*: DWORD + Flags*: DWORD + MetaDataSize*: DWORD + MetaDataOffset*: DWORD + ANON_OBJECT_HEADER_BIGOBJ* {.pure.} = object + Sig1*: WORD + Sig2*: WORD + Version*: WORD + Machine*: WORD + TimeDateStamp*: DWORD + ClassID*: CLSID + SizeOfData*: DWORD + Flags*: DWORD + MetaDataSize*: DWORD + MetaDataOffset*: DWORD + NumberOfSections*: DWORD + PointerToSymbolTable*: DWORD + NumberOfSymbols*: DWORD + IMPORT_OBJECT_HEADER_UNION1* {.pure, union.} = object + Ordinal*: WORD + Hint*: WORD + IMPORT_OBJECT_HEADER* {.pure.} = object + Sig1*: WORD + Sig2*: WORD + Version*: WORD + Machine*: WORD + TimeDateStamp*: DWORD + SizeOfData*: DWORD + union1*: IMPORT_OBJECT_HEADER_UNION1 + Type* {.bitsize:2.}: WORD + NameType* {.bitsize:3.}: WORD + Reserved* {.bitsize:11.}: WORD + TP_CALLBACK_ENVIRON_V1_u_s* {.pure.} = object + LongFunction* {.bitsize:1.}: DWORD + Persistent* {.bitsize:1.}: DWORD + Private* {.bitsize:30.}: DWORD + TP_CALLBACK_ENVIRON_V1_u* {.pure, union.} = object + Flags*: DWORD + s*: TP_CALLBACK_ENVIRON_V1_u_s + TP_CALLBACK_ENVIRON_V1* {.pure.} = object + Version*: TP_VERSION + Pool*: PTP_POOL + CleanupGroup*: PTP_CLEANUP_GROUP + CleanupGroupCancelCallback*: PTP_CLEANUP_GROUP_CANCEL_CALLBACK + RaceDll*: PVOID + ActivationContext*: ptr ACTIVATION_CONTEXT + FinalizationCallback*: PTP_SIMPLE_CALLBACK + u*: TP_CALLBACK_ENVIRON_V1_u +proc IsEqualGUID*(rguid1: REFGUID, rguid2: REFGUID): BOOL {.winapi, stdcall, dynlib: "ole32", importc.} +proc IsEqualIID*(rguid1: REFIID, rguid2: REFIID): BOOL {.winapi, stdcall, dynlib: "ole32", importc: "IsEqualGUID".} +proc IsEqualCLSID*(rguid1: REFCLSID, rguid2: REFCLSID): BOOL {.winapi, stdcall, dynlib: "ole32", importc: "IsEqualGUID".} +proc IsEqualFMTID*(rguid1: REFFMTID, rguid2: REFFMTID): BOOL {.winapi, stdcall, dynlib: "ole32", importc: "IsEqualGUID".} +proc RtlCaptureStackBackTrace*(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: ptr PVOID, BackTraceHash: PDWORD): WORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCaptureContext*(ContextRecord: PCONTEXT): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCompareMemory*(Source1: pointer, Source2: pointer, Length: SIZE_T): SIZE_T {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlUnwind*(TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlPcToFileHeader*(PcValue: PVOID, BaseOfImage: ptr PVOID): PVOID {.winapi, stdcall, dynlib: "ntdll", importc.} +when winimCpu64: + type + SLIST_HEADER_STRUCT1* {.pure.} = object + Alignment*: ULONGLONG + Region*: ULONGLONG +when winimCpu32: + type + SLIST_ENTRY* = SINGLE_LIST_ENTRY +when winimCpu64: + type + SLIST_ENTRY* {.pure.} = object + Next*: ptr SLIST_ENTRY + padding*: array[8, byte] +when winimCpu32: + type + SLIST_HEADER_STRUCT1* {.pure.} = object + Next*: SLIST_ENTRY + Depth*: WORD + Sequence*: WORD +when winimCpu64: + type + SLIST_HEADER_Header8* {.pure.} = object + Depth* {.bitsize:16.}: ULONGLONG + Sequence* {.bitsize:9.}: ULONGLONG + NextEntry* {.bitsize:39.}: ULONGLONG + HeaderType* {.bitsize:1.}: ULONGLONG + Init* {.bitsize:1.}: ULONGLONG + Reserved* {.bitsize:59.}: ULONGLONG + Region* {.bitsize:3.}: ULONGLONG + SLIST_HEADER_HeaderX64* {.pure.} = object + Depth* {.bitsize:16.}: ULONGLONG + Sequence* {.bitsize:48.}: ULONGLONG + HeaderType* {.bitsize:1.}: ULONGLONG + Reserved* {.bitsize:3.}: ULONGLONG + NextEntry* {.bitsize:60.}: ULONGLONG + SLIST_HEADER* {.pure, union.} = object + struct1*: SLIST_HEADER_STRUCT1 + Header8*: SLIST_HEADER_Header8 + HeaderX64*: SLIST_HEADER_HeaderX64 +when winimCpu32: + type + SLIST_HEADER* {.pure, union.} = object + Alignment*: ULONGLONG + struct1*: SLIST_HEADER_STRUCT1 +when winimCpu64: + type + PSLIST_HEADER* = ptr SLIST_HEADER +when winimCpu32: + type + PSLIST_HEADER* = ptr SLIST_HEADER +proc RtlInitializeSListHead*(ListHead: PSLIST_HEADER): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +when winimCpu64: + type + PSLIST_ENTRY* = ptr SLIST_ENTRY +when winimCpu32: + type + PSLIST_ENTRY* = ptr SINGLE_LIST_ENTRY +proc RtlFirstEntrySList*(ListHead: ptr SLIST_HEADER): PSLIST_ENTRY {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInterlockedPopEntrySList*(ListHead: PSLIST_HEADER): PSLIST_ENTRY {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInterlockedPushEntrySList*(ListHead: PSLIST_HEADER, ListEntry: PSLIST_ENTRY): PSLIST_ENTRY {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInterlockedPushListSListEx*(ListHead: PSLIST_HEADER, List: PSLIST_ENTRY, ListEnd: PSLIST_ENTRY, Count: DWORD): PSLIST_ENTRY {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInterlockedFlushSList*(ListHead: PSLIST_HEADER): PSLIST_ENTRY {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlQueryDepthSList*(ListHead: PSLIST_HEADER): WORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc VerSetConditionMask*(ConditionMask: ULONGLONG, TypeMask: DWORD, Condition: BYTE): ULONGLONG {.winapi, stdcall, dynlib: "kernel32", importc.} +proc RtlGetProductInfo*(OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, ReturnedProductType: PDWORD): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCrc32*(Buffer: pointer, Size: int, InitialCrc: DWORD): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCrc64*(Buffer: pointer, Size: int, InitialCrc: ULONGLONG): ULONGLONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlApplicationVerifierStop*(Code: ULONG_PTR, Message: PSTR, Param1: ULONG_PTR, Description1: PSTR, Param2: ULONG_PTR, Description2: PSTR, Param3: ULONG_PTR, Description3: PSTR, Param4: ULONG_PTR, Description4: PSTR): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlSetHeapInformation*(HeapHandle: PVOID, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlQueryHeapInformation*(HeapHandle: PVOID, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlMultipleAllocateHeap*(HeapHandle: PVOID, Flags: DWORD, Size: SIZE_T, Count: DWORD, Array: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlMultipleFreeHeap*(HeapHandle: PVOID, Flags: DWORD, Count: DWORD, Array: ptr PVOID): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtClose*(Handle: HANDLE): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtCreateFile*(FileHandle: PHANDLE, DesiredAccess: ACCESS_MASK, ObjectAttributes: POBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, AllocationSize: PLARGE_INTEGER, FileAttributes: ULONG, ShareAccess: ULONG, CreateDisposition: ULONG, CreateOptions: ULONG, EaBuffer: PVOID, EaLength: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtOpenFile*(FileHandle: PHANDLE, DesiredAccess: ACCESS_MASK, ObjectAttributes: POBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, ShareAccess: ULONG, OpenOptions: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtFsControlFile*(FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, ApcContext: PVOID, IoStatusBlock: PIO_STATUS_BLOCK, IoControlCode: ULONG, InputBuffer: PVOID, InputBufferLength: ULONG, OutputBuffer: PVOID, OutputBufferLength: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtDeviceIoControlFile*(FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, ApcContext: PVOID, IoStatusBlock: PIO_STATUS_BLOCK, IoControlCode: ULONG, InputBuffer: PVOID, InputBufferLength: ULONG, OutputBuffer: PVOID, OutputBufferLength: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtWaitForSingleObject*(Handle: HANDLE, Alertable: BOOLEAN, Timeout: PLARGE_INTEGER): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIsNameLegalDOS8Dot3*(Name: PUNICODE_STRING, OemName: POEM_STRING, NameContainsSpaces: PBOOLEAN): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlNtStatusToDosError*(Status: NTSTATUS): ULONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQueryInformationProcess*(ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, ProcessInformation: PVOID, ProcessInformationLength: ULONG, ReturnLength: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQueryInformationThread*(ThreadHandle: HANDLE, ThreadInformationClass: THREADINFOCLASS, ThreadInformation: PVOID, ThreadInformationLength: ULONG, ReturnLength: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQueryInformationFile*(hFile: HANDLE, io: PIO_STATUS_BLOCK, `ptr`: PVOID, len: ULONG, FileInformationClass: FILE_INFORMATION_CLASS): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQueryObject*(Handle: HANDLE, ObjectInformationClass: OBJECT_INFORMATION_CLASS, ObjectInformation: PVOID, ObjectInformationLength: ULONG, ReturnLength: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQuerySystemInformation*(SystemInformationClass: SYSTEM_INFORMATION_CLASS, SystemInformation: PVOID, SystemInformationLength: ULONG, ReturnLength: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQuerySystemTime*(SystemTime: PLARGE_INTEGER): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtQueryVolumeInformationFile*(hFile: HANDLE, io: PIO_STATUS_BLOCK, `ptr`: PVOID, len: ULONG, FsInformationClass: FS_INFORMATION_CLASS): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtSetInformationFile*(hFile: HANDLE, io: PIO_STATUS_BLOCK, `ptr`: PVOID, len: ULONG, FileInformationClass: FILE_INFORMATION_CLASS): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtSetInformationProcess*(ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, ProcessInformation: PVOID, ProcessInformationLength: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc NtSetVolumeInformationFile*(hFile: HANDLE, io: PIO_STATUS_BLOCK, `ptr`: PVOID, len: ULONG, FileInformationClass: FILE_INFORMATION_CLASS): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlLocalTimeToSystemTime*(LocalTime: PLARGE_INTEGER, SystemTime: PLARGE_INTEGER): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlTimeToSecondsSince1970*(Time: PLARGE_INTEGER, ElapsedSeconds: PULONG): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlFreeAnsiString*(AnsiString: PANSI_STRING): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlFreeUnicodeString*(UnicodeString: PUNICODE_STRING): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlFreeOemString*(OemString: POEM_STRING): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInitString*(DestinationString: PSTRING, SourceString: PCSZ): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInitAnsiString*(DestinationString: PANSI_STRING, SourceString: PCSZ): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlInitUnicodeString*(DestinationString: PUNICODE_STRING, SourceString: PCWSTR): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlAnsiStringToUnicodeString*(DestinationString: PUNICODE_STRING, SourceString: PCANSI_STRING, AllocateDestinationString: BOOLEAN): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlUnicodeStringToAnsiString*(DestinationString: PANSI_STRING, SourceString: PCUNICODE_STRING, AllocateDestinationString: BOOLEAN): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlUnicodeStringToOemString*(DestinationString: POEM_STRING, SourceString: PCUNICODE_STRING, AllocateDestinationString: BOOLEAN): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlUnicodeToMultiByteSize*(BytesInMultiByteString: PULONG, UnicodeString: PWCH, BytesInUnicodeString: ULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCharToInteger*(String: PCSZ, Base: ULONG, Value: PULONG): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlConvertSidToUnicodeString*(UnicodeString: PUNICODE_STRING, Sid: PSID, AllocateDestinationString: BOOLEAN): NTSTATUS {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlUniform*(Seed: PULONG): ULONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlDosPathNameToNtPathName_U*(DosPathName: PCWSTR, NtPathName: PUNICODE_STRING, NtFileNamePart: ptr PCWSTR, DirectoryInfo: pointer): BOOL {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlPrefixUnicodeString*(String1: PCUNICODE_STRING, String2: PCUNICODE_STRING, CaseInSensitive: BOOLEAN): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCreateUnicodeStringFromAsciiz*(target: PUNICODE_STRING, src: LPCSTR): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlFreeHeap*(HeapHandle: PVOID, Flags: ULONG, HeapBase: PVOID): BOOLEAN {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlAllocateHeap*(HeapHandle: PVOID, Flags: ULONG, Size: SIZE_T): PVOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlCreateHeap*(Flags: ULONG, HeapBase: PVOID, ReserveSize: SIZE_T, CommitSize: SIZE_T, Lock: PVOID, Parameters: PRTL_HEAP_PARAMETERS): PVOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlDestroyHeap*(HeapHandle: PVOID): PVOID {.winapi, stdcall, dynlib: "ntdll", importc.} +proc CaptureStackBackTrace*(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: ptr PVOID, BackTraceHash: PDWORD): WORD {.winapi, stdcall, dynlib: "ntdll", importc: "RtlCaptureStackBackTrace".} +template NT_SUCCESS*(status: untyped): bool = status.NTSTATUS >= 0 +template NT_INFORMATION*(status: untyped): bool = status.NTSTATUS shr 30 == 1 +template NT_WARNING*(status: untyped): bool = status.NTSTATUS shr 30 == 2 +template NT_ERROR*(status: untyped): bool = status.NTSTATUS shr 30 == 3 +template PRIMARYLANGID*(lgid: untyped): WORD = lgid.WORD and 0x3ff +template SUBLANGID*(lgid: untyped): WORD = lgid.WORD shr 10 +template MAKESORTLCID*(lgid: untyped, srtid: untyped, ver: untyped): DWORD = MAKELCID(lgid, srtid) or (ver.DWORD shl 20) +template LANGIDFROMLCID*(lcid: untyped): WORD = WORD(lcid and 0xffff) +template SORTIDFROMLCID*(lcid: untyped): WORD = WORD((lcid shr 16) and 0xf) +template SORTVERSIONFROMLCID*(lcid: untyped): WORD = WORD((lcid shr 20) and 0xf) +template MAKEWORD*(a: untyped, b: untyped): WORD = WORD((b and 0xff) shl 8) or WORD(a and 0xff) +template MAKELONG*(a: untyped, b: untyped): DWORD = cast[DWORD](b shl 16) or DWORD(a and 0xffff) +template LOWORD*(l: untyped): WORD = WORD(l and 0xffff) +template HIWORD*(l: untyped): WORD = WORD((l shr 16) and 0xffff) +template LOBYTE*(w: untyped): BYTE = BYTE(w and 0xff) +template HIBYTE*(w: untyped): BYTE = BYTE((w shr 8) and 0xff) +template GET_X_LPARAM*(x: untyped): int = int cast[int16](LOWORD(x)) +template GET_Y_LPARAM*(x: untyped): int = int cast[int16](HIWORD(x)) +template IS_UNWINDING*(f: untyped): bool = (f and EXCEPTION_UNWIND) != 0 +template IS_DISPATCHING*(f: untyped): bool = (f and EXCEPTION_UNWIND) == 0 +template IS_TARGET_UNWIND*(f: untyped): bool = (f and EXCEPTION_TARGET_UNWIND) != 0 +template MANDATORY_LEVEL_TO_MANDATORY_RID*(IL: untyped): DWORD = IL.DWORD * 0x1000 +template VALID_IMPERSONATION_LEVEL*(L: untyped): bool = (L >= SECURITY_MIN_IMPERSONATION_LEVEL) and (L <= SECURITY_MAX_IMPERSONATION_LEVEL) +template IsReparseTagMicrosoft*(tag: untyped): ULONG = tag.ULONG and 0x80000000'i32 +template IsReparseTagNameSurrogate*(tag: untyped): ULONG = tag.ULONG and 0x20000000'i32 +when winimCpu64: + type + PIMAGE_NT_HEADERS* = PIMAGE_NT_HEADERS64 +when winimCpu32: + type + PIMAGE_NT_HEADERS* = PIMAGE_NT_HEADERS32 +template IMAGE_FIRST_SECTION*(ntheader: PIMAGE_NT_HEADERS): PIMAGE_SECTION_HEADER = cast[PIMAGE_SECTION_HEADER](cast[int](addr ntheader.OptionalHeader) + int(ntheader.FileHeader.SizeOfOptionalHeader)) +template BTYPE*(x: untyped): DWORD = x.DWORD and N_BTMASK +template ISPTR*(x: untyped): bool = DWORD(x and N_TMASK) == DWORD(IMAGE_SYM_DTYPE_POINTER shl N_BTSHFT) +template ISFCN*(x: untyped): bool = DWORD(x and N_TMASK) == DWORD(IMAGE_SYM_DTYPE_FUNCTION shl N_BTSHFT) +template ISARY*(x: untyped): bool = DWORD(x and N_TMASK) == DWORD(IMAGE_SYM_DTYPE_ARRAY shl N_BTSHFT) +template ISTAG*(x: untyped): bool = (x == IMAGE_SYM_CLASS_STRUCT_TAG) or (x == IMAGE_SYM_CLASS_UNION_TAG) or (x == IMAGE_SYM_CLASS_ENUM_TAG) +template INCREF*(x: untyped): DWORD = ((x.DWORD and (not N_BTMASK)) shl N_TSHIFT) or DWORD(IMAGE_SYM_DTYPE_POINTER shl N_BTSHFT) or DWORD(x and N_BTMASK) +template DECREF*(x: untyped): DWORD = (x.DWORD shr N_TSHIFT) and DWORD(not N_BTMASK) or (x.DWORD and N_BTMASK) +template IMAGE_ORDINAL64*(Ordinal: untyped): int64 = Ordinal.int64 and 0xffff'i64 +template IMAGE_ORDINAL32*(Ordinal: untyped): int32 = Ordinal.int32 and 0xffff'i32 +template IMAGE_SNAP_BY_ORDINAL64*(Ordinal: untyped): bool = (Ordinal and IMAGE_ORDINAL_FLAG64) != 0 +template IMAGE_SNAP_BY_ORDINAL32*(Ordinal: untyped): bool = (Ordinal and IMAGE_ORDINAL_FLAG32) != 0 +template HEAP_MAKE_TAG_FLAGS*(b: untyped, o: untyped): DWORD = b.DWORD + (o.DWORD shl 18) +template InitializeObjectAttributes*(p: POBJECT_ATTRIBUTES, n: PUNICODE_STRING, a: ULONG, r: HANDLE, s: PSECURITY_DESCRIPTOR) = p.Length = int32 sizeof(OBJECT_ATTRIBUTES); p.RootDirectory = r; p.Attributes = a; p.ObjectName = n; p.SecurityDescriptor = s; p.SecurityQualityOfService = nil +proc ReadTimeStampCounter*(): int64 {.importc: "__rdtsc".} +proc RtlEqualMemory*(Destination: pointer, Source: pointer, Length: Natural): bool {.importc: "RtlEqualMemory", header: "".} +proc RtlMoveMemory*(Destination: pointer, Source: pointer, Length: Natural) {.importc: "RtlMoveMemory", header: "".} +proc RtlCopyMemory*(Destination: pointer, Source: pointer, Length: Natural) {.importc: "RtlCopyMemory", header: "".} +proc RtlZeroMemory*(Destination: pointer, Length: Natural) {.importc: "RtlZeroMemory", header: "".} +proc RtlSecureZeroMemory*(Destination: pointer, Length: Natural) {.importc: "RtlSecureZeroMemory", header: "".} +proc RtlFillMemory*(Destination: pointer, Length: Natural, Fill: byte): void {.importc: "RtlFillMemory", header: "".} +proc `UseThisFieldToCopy=`*(self: var QUAD, x: int64) {.inline.} = self.union1.UseThisFieldToCopy = x +proc UseThisFieldToCopy*(self: QUAD): int64 {.inline.} = self.union1.UseThisFieldToCopy +proc UseThisFieldToCopy*(self: var QUAD): var int64 {.inline.} = self.union1.UseThisFieldToCopy +proc `DoNotUseThisField=`*(self: var QUAD, x: float64) {.inline.} = self.union1.DoNotUseThisField = x +proc DoNotUseThisField*(self: QUAD): float64 {.inline.} = self.union1.DoNotUseThisField +proc DoNotUseThisField*(self: var QUAD): var float64 {.inline.} = self.union1.DoNotUseThisField +proc `LowPart=`*(self: var LARGE_INTEGER, x: ULONG) {.inline.} = self.struct1.LowPart = x +proc LowPart*(self: LARGE_INTEGER): ULONG {.inline.} = self.struct1.LowPart +proc LowPart*(self: var LARGE_INTEGER): var ULONG {.inline.} = self.struct1.LowPart +proc `HighPart=`*(self: var LARGE_INTEGER, x: LONG) {.inline.} = self.struct1.HighPart = x +proc HighPart*(self: LARGE_INTEGER): LONG {.inline.} = self.struct1.HighPart +proc HighPart*(self: var LARGE_INTEGER): var LONG {.inline.} = self.struct1.HighPart +proc `LowPart=`*(self: var ULARGE_INTEGER, x: ULONG) {.inline.} = self.struct1.LowPart = x +proc LowPart*(self: ULARGE_INTEGER): ULONG {.inline.} = self.struct1.LowPart +proc LowPart*(self: var ULARGE_INTEGER): var ULONG {.inline.} = self.struct1.LowPart +proc `HighPart=`*(self: var ULARGE_INTEGER, x: ULONG) {.inline.} = self.struct1.HighPart = x +proc HighPart*(self: ULARGE_INTEGER): ULONG {.inline.} = self.struct1.HighPart +proc HighPart*(self: var ULARGE_INTEGER): var ULONG {.inline.} = self.struct1.HighPart +proc `SymbolicLinkReparseBuffer=`*(self: var REPARSE_DATA_BUFFER, x: REPARSE_DATA_BUFFER_UNION1_SymbolicLinkReparseBuffer) {.inline.} = self.union1.SymbolicLinkReparseBuffer = x +proc SymbolicLinkReparseBuffer*(self: REPARSE_DATA_BUFFER): REPARSE_DATA_BUFFER_UNION1_SymbolicLinkReparseBuffer {.inline.} = self.union1.SymbolicLinkReparseBuffer +proc SymbolicLinkReparseBuffer*(self: var REPARSE_DATA_BUFFER): var REPARSE_DATA_BUFFER_UNION1_SymbolicLinkReparseBuffer {.inline.} = self.union1.SymbolicLinkReparseBuffer +proc `MountPointReparseBuffer=`*(self: var REPARSE_DATA_BUFFER, x: REPARSE_DATA_BUFFER_UNION1_MountPointReparseBuffer) {.inline.} = self.union1.MountPointReparseBuffer = x +proc MountPointReparseBuffer*(self: REPARSE_DATA_BUFFER): REPARSE_DATA_BUFFER_UNION1_MountPointReparseBuffer {.inline.} = self.union1.MountPointReparseBuffer +proc MountPointReparseBuffer*(self: var REPARSE_DATA_BUFFER): var REPARSE_DATA_BUFFER_UNION1_MountPointReparseBuffer {.inline.} = self.union1.MountPointReparseBuffer +proc `GenericReparseBuffer=`*(self: var REPARSE_DATA_BUFFER, x: REPARSE_DATA_BUFFER_UNION1_GenericReparseBuffer) {.inline.} = self.union1.GenericReparseBuffer = x +proc GenericReparseBuffer*(self: REPARSE_DATA_BUFFER): REPARSE_DATA_BUFFER_UNION1_GenericReparseBuffer {.inline.} = self.union1.GenericReparseBuffer +proc GenericReparseBuffer*(self: var REPARSE_DATA_BUFFER): var REPARSE_DATA_BUFFER_UNION1_GenericReparseBuffer {.inline.} = self.union1.GenericReparseBuffer +proc `FiberData=`*(self: var NT_TIB, x: PVOID) {.inline.} = self.union1.FiberData = x +proc FiberData*(self: NT_TIB): PVOID {.inline.} = self.union1.FiberData +proc FiberData*(self: var NT_TIB): var PVOID {.inline.} = self.union1.FiberData +proc `Version=`*(self: var NT_TIB, x: DWORD) {.inline.} = self.union1.Version = x +proc Version*(self: NT_TIB): DWORD {.inline.} = self.union1.Version +proc Version*(self: var NT_TIB): var DWORD {.inline.} = self.union1.Version +proc `FiberData=`*(self: var NT_TIB32, x: DWORD) {.inline.} = self.union1.FiberData = x +proc FiberData*(self: NT_TIB32): DWORD {.inline.} = self.union1.FiberData +proc FiberData*(self: var NT_TIB32): var DWORD {.inline.} = self.union1.FiberData +proc `Version=`*(self: var NT_TIB32, x: DWORD) {.inline.} = self.union1.Version = x +proc Version*(self: NT_TIB32): DWORD {.inline.} = self.union1.Version +proc Version*(self: var NT_TIB32): var DWORD {.inline.} = self.union1.Version +proc `FiberData=`*(self: var NT_TIB64, x: DWORD64) {.inline.} = self.union1.FiberData = x +proc FiberData*(self: NT_TIB64): DWORD64 {.inline.} = self.union1.FiberData +proc FiberData*(self: var NT_TIB64): var DWORD64 {.inline.} = self.union1.FiberData +proc `Version=`*(self: var NT_TIB64, x: DWORD) {.inline.} = self.union1.Version = x +proc Version*(self: NT_TIB64): DWORD {.inline.} = self.union1.Version +proc Version*(self: var NT_TIB64): var DWORD {.inline.} = self.union1.Version +proc `RatePercent=`*(self: var RATE_QUOTA_LIMIT, x: DWORD) {.inline.} = self.struct1.RatePercent = x +proc RatePercent*(self: RATE_QUOTA_LIMIT): DWORD {.inline.} = self.struct1.RatePercent +proc `Reserved0=`*(self: var RATE_QUOTA_LIMIT, x: DWORD) {.inline.} = self.struct1.Reserved0 = x +proc Reserved0*(self: RATE_QUOTA_LIMIT): DWORD {.inline.} = self.struct1.Reserved0 +proc `Flags=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESS_MITIGATION_ASLR_POLICY): var DWORD {.inline.} = self.union1.Flags +proc `EnableBottomUpRandomization=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.struct1.EnableBottomUpRandomization = x +proc EnableBottomUpRandomization*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.struct1.EnableBottomUpRandomization +proc `EnableForceRelocateImages=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.struct1.EnableForceRelocateImages = x +proc EnableForceRelocateImages*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.struct1.EnableForceRelocateImages +proc `EnableHighEntropy=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.struct1.EnableHighEntropy = x +proc EnableHighEntropy*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.struct1.EnableHighEntropy +proc `DisallowStrippedImages=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.struct1.DisallowStrippedImages = x +proc DisallowStrippedImages*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.struct1.DisallowStrippedImages +proc `ReservedFlags=`*(self: var PROCESS_MITIGATION_ASLR_POLICY, x: DWORD) {.inline.} = self.union1.struct1.ReservedFlags = x +proc ReservedFlags*(self: PROCESS_MITIGATION_ASLR_POLICY): DWORD {.inline.} = self.union1.struct1.ReservedFlags +proc `Flags=`*(self: var PROCESS_MITIGATION_DEP_POLICY, x: DWORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESS_MITIGATION_DEP_POLICY): DWORD {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESS_MITIGATION_DEP_POLICY): var DWORD {.inline.} = self.union1.Flags +proc `Enable=`*(self: var PROCESS_MITIGATION_DEP_POLICY, x: DWORD) {.inline.} = self.union1.struct1.Enable = x +proc Enable*(self: PROCESS_MITIGATION_DEP_POLICY): DWORD {.inline.} = self.union1.struct1.Enable +proc `DisableAtlThunkEmulation=`*(self: var PROCESS_MITIGATION_DEP_POLICY, x: DWORD) {.inline.} = self.union1.struct1.DisableAtlThunkEmulation = x +proc DisableAtlThunkEmulation*(self: PROCESS_MITIGATION_DEP_POLICY): DWORD {.inline.} = self.union1.struct1.DisableAtlThunkEmulation +proc `ReservedFlags=`*(self: var PROCESS_MITIGATION_DEP_POLICY, x: DWORD) {.inline.} = self.union1.struct1.ReservedFlags = x +proc ReservedFlags*(self: PROCESS_MITIGATION_DEP_POLICY): DWORD {.inline.} = self.union1.struct1.ReservedFlags +proc `Flags=`*(self: var PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, x: DWORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY): DWORD {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY): var DWORD {.inline.} = self.union1.Flags +proc `RaiseExceptionOnInvalidHandleReference=`*(self: var PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, x: DWORD) {.inline.} = self.union1.struct1.RaiseExceptionOnInvalidHandleReference = x +proc RaiseExceptionOnInvalidHandleReference*(self: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY): DWORD {.inline.} = self.union1.struct1.RaiseExceptionOnInvalidHandleReference +proc `HandleExceptionsPermanentlyEnabled=`*(self: var PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, x: DWORD) {.inline.} = self.union1.struct1.HandleExceptionsPermanentlyEnabled = x +proc HandleExceptionsPermanentlyEnabled*(self: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY): DWORD {.inline.} = self.union1.struct1.HandleExceptionsPermanentlyEnabled +proc `ReservedFlags=`*(self: var PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, x: DWORD) {.inline.} = self.union1.struct1.ReservedFlags = x +proc ReservedFlags*(self: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY): DWORD {.inline.} = self.union1.struct1.ReservedFlags +proc `Flags=`*(self: var PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY): DWORD {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY): var DWORD {.inline.} = self.union1.Flags +proc `DisallowWin32kSystemCalls=`*(self: var PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.struct1.DisallowWin32kSystemCalls = x +proc DisallowWin32kSystemCalls*(self: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY): DWORD {.inline.} = self.union1.struct1.DisallowWin32kSystemCalls +proc `ReservedFlags=`*(self: var PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.struct1.ReservedFlags = x +proc ReservedFlags*(self: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY): DWORD {.inline.} = self.union1.struct1.ReservedFlags +proc `Flags=`*(self: var PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY): DWORD {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY): var DWORD {.inline.} = self.union1.Flags +proc `DisableExtensionPoints=`*(self: var PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.struct1.DisableExtensionPoints = x +proc DisableExtensionPoints*(self: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY): DWORD {.inline.} = self.union1.struct1.DisableExtensionPoints +proc `ReservedFlags=`*(self: var PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, x: DWORD) {.inline.} = self.union1.struct1.ReservedFlags = x +proc ReservedFlags*(self: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY): DWORD {.inline.} = self.union1.struct1.ReservedFlags +proc `CpuRate=`*(self: var JOBOBJECT_CPU_RATE_CONTROL_INFORMATION, x: DWORD) {.inline.} = self.union1.CpuRate = x +proc CpuRate*(self: JOBOBJECT_CPU_RATE_CONTROL_INFORMATION): DWORD {.inline.} = self.union1.CpuRate +proc CpuRate*(self: var JOBOBJECT_CPU_RATE_CONTROL_INFORMATION): var DWORD {.inline.} = self.union1.CpuRate +proc `Weight=`*(self: var JOBOBJECT_CPU_RATE_CONTROL_INFORMATION, x: DWORD) {.inline.} = self.union1.Weight = x +proc Weight*(self: JOBOBJECT_CPU_RATE_CONTROL_INFORMATION): DWORD {.inline.} = self.union1.Weight +proc Weight*(self: var JOBOBJECT_CPU_RATE_CONTROL_INFORMATION): var DWORD {.inline.} = self.union1.Weight +proc `ProcessorCore=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION, x: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_ProcessorCore) {.inline.} = self.union1.ProcessorCore = x +proc ProcessorCore*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION): SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_ProcessorCore {.inline.} = self.union1.ProcessorCore +proc ProcessorCore*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION): var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_ProcessorCore {.inline.} = self.union1.ProcessorCore +proc `NumaNode=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION, x: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_NumaNode) {.inline.} = self.union1.NumaNode = x +proc NumaNode*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION): SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_NumaNode {.inline.} = self.union1.NumaNode +proc NumaNode*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION): var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_UNION1_NumaNode {.inline.} = self.union1.NumaNode +proc `Cache=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION, x: CACHE_DESCRIPTOR) {.inline.} = self.union1.Cache = x +proc Cache*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION): CACHE_DESCRIPTOR {.inline.} = self.union1.Cache +proc Cache*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION): var CACHE_DESCRIPTOR {.inline.} = self.union1.Cache +proc `Reserved=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION, x: array[2, ULONGLONG]) {.inline.} = self.union1.Reserved = x +proc Reserved*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION): array[2, ULONGLONG] {.inline.} = self.union1.Reserved +proc Reserved*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION): var array[2, ULONGLONG] {.inline.} = self.union1.Reserved +proc `Processor=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, x: PROCESSOR_RELATIONSHIP) {.inline.} = self.union1.Processor = x +proc Processor*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): PROCESSOR_RELATIONSHIP {.inline.} = self.union1.Processor +proc Processor*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): var PROCESSOR_RELATIONSHIP {.inline.} = self.union1.Processor +proc `NumaNode=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, x: NUMA_NODE_RELATIONSHIP) {.inline.} = self.union1.NumaNode = x +proc NumaNode*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): NUMA_NODE_RELATIONSHIP {.inline.} = self.union1.NumaNode +proc NumaNode*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): var NUMA_NODE_RELATIONSHIP {.inline.} = self.union1.NumaNode +proc `Cache=`*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, x: CACHE_RELATIONSHIP) {.inline.} = self.union1.Cache = x +proc Cache*(self: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): CACHE_RELATIONSHIP {.inline.} = self.union1.Cache +proc Cache*(self: var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX): var CACHE_RELATIONSHIP {.inline.} = self.union1.Cache +proc `AllowScaling=`*(self: var PROCESSOR_IDLESTATE_POLICY, x: WORD) {.inline.} = self.Flags.struct1.AllowScaling = x +proc AllowScaling*(self: PROCESSOR_IDLESTATE_POLICY): WORD {.inline.} = self.Flags.struct1.AllowScaling +proc `Disabled=`*(self: var PROCESSOR_IDLESTATE_POLICY, x: WORD) {.inline.} = self.Flags.struct1.Disabled = x +proc Disabled*(self: PROCESSOR_IDLESTATE_POLICY): WORD {.inline.} = self.Flags.struct1.Disabled +proc `Reserved=`*(self: var PROCESSOR_IDLESTATE_POLICY, x: WORD) {.inline.} = self.Flags.struct1.Reserved = x +proc Reserved*(self: PROCESSOR_IDLESTATE_POLICY): WORD {.inline.} = self.Flags.struct1.Reserved +proc `Spare=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: BYTE) {.inline.} = self.union1.Spare = x +proc Spare*(self: PROCESSOR_PERFSTATE_POLICY): BYTE {.inline.} = self.union1.Spare +proc Spare*(self: var PROCESSOR_PERFSTATE_POLICY): var BYTE {.inline.} = self.union1.Spare +proc `NoDomainAccounting=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: BYTE) {.inline.} = self.union1.Flags.struct1.NoDomainAccounting = x +proc NoDomainAccounting*(self: PROCESSOR_PERFSTATE_POLICY): BYTE {.inline.} = self.union1.Flags.struct1.NoDomainAccounting +proc `IncreasePolicy=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: BYTE) {.inline.} = self.union1.Flags.struct1.IncreasePolicy = x +proc IncreasePolicy*(self: PROCESSOR_PERFSTATE_POLICY): BYTE {.inline.} = self.union1.Flags.struct1.IncreasePolicy +proc `DecreasePolicy=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: BYTE) {.inline.} = self.union1.Flags.struct1.DecreasePolicy = x +proc DecreasePolicy*(self: PROCESSOR_PERFSTATE_POLICY): BYTE {.inline.} = self.union1.Flags.struct1.DecreasePolicy +proc `Reserved=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: BYTE) {.inline.} = self.union1.Flags.struct1.Reserved = x +proc Reserved*(self: PROCESSOR_PERFSTATE_POLICY): BYTE {.inline.} = self.union1.Flags.struct1.Reserved +proc `Flags=`*(self: var PROCESSOR_PERFSTATE_POLICY, x: PROCESSOR_PERFSTATE_POLICY_UNION1_Flags) {.inline.} = self.union1.Flags = x +proc Flags*(self: PROCESSOR_PERFSTATE_POLICY): PROCESSOR_PERFSTATE_POLICY_UNION1_Flags {.inline.} = self.union1.Flags +proc Flags*(self: var PROCESSOR_PERFSTATE_POLICY): var PROCESSOR_PERFSTATE_POLICY_UNION1_Flags {.inline.} = self.union1.Flags +proc `TokenDef=`*(self: var IMAGE_AUX_SYMBOL_EX, x: IMAGE_AUX_SYMBOL_TOKEN_DEF) {.inline.} = self.struct4.TokenDef = x +proc TokenDef*(self: IMAGE_AUX_SYMBOL_EX): IMAGE_AUX_SYMBOL_TOKEN_DEF {.inline.} = self.struct4.TokenDef +proc TokenDef*(self: var IMAGE_AUX_SYMBOL_EX): var IMAGE_AUX_SYMBOL_TOKEN_DEF {.inline.} = self.struct4.TokenDef +proc `rgbReserved=`*(self: var IMAGE_AUX_SYMBOL_EX, x: array[2, BYTE]) {.inline.} = self.struct4.rgbReserved = x +proc rgbReserved*(self: IMAGE_AUX_SYMBOL_EX): array[2, BYTE] {.inline.} = self.struct4.rgbReserved +proc rgbReserved*(self: var IMAGE_AUX_SYMBOL_EX): var array[2, BYTE] {.inline.} = self.struct4.rgbReserved +proc `VirtualAddress=`*(self: var IMAGE_RELOCATION, x: DWORD) {.inline.} = self.union1.VirtualAddress = x +proc VirtualAddress*(self: IMAGE_RELOCATION): DWORD {.inline.} = self.union1.VirtualAddress +proc VirtualAddress*(self: var IMAGE_RELOCATION): var DWORD {.inline.} = self.union1.VirtualAddress +proc `RelocCount=`*(self: var IMAGE_RELOCATION, x: DWORD) {.inline.} = self.union1.RelocCount = x +proc RelocCount*(self: IMAGE_RELOCATION): DWORD {.inline.} = self.union1.RelocCount +proc RelocCount*(self: var IMAGE_RELOCATION): var DWORD {.inline.} = self.union1.RelocCount +proc `Characteristics=`*(self: var IMAGE_IMPORT_DESCRIPTOR, x: DWORD) {.inline.} = self.union1.Characteristics = x +proc Characteristics*(self: IMAGE_IMPORT_DESCRIPTOR): DWORD {.inline.} = self.union1.Characteristics +proc Characteristics*(self: var IMAGE_IMPORT_DESCRIPTOR): var DWORD {.inline.} = self.union1.Characteristics +proc `OriginalFirstThunk=`*(self: var IMAGE_IMPORT_DESCRIPTOR, x: DWORD) {.inline.} = self.union1.OriginalFirstThunk = x +proc OriginalFirstThunk*(self: IMAGE_IMPORT_DESCRIPTOR): DWORD {.inline.} = self.union1.OriginalFirstThunk +proc OriginalFirstThunk*(self: var IMAGE_IMPORT_DESCRIPTOR): var DWORD {.inline.} = self.union1.OriginalFirstThunk +proc `RvaBased=`*(self: var IMAGE_DELAYLOAD_DESCRIPTOR, x: DWORD) {.inline.} = self.Attributes.struct1.RvaBased = x +proc RvaBased*(self: IMAGE_DELAYLOAD_DESCRIPTOR): DWORD {.inline.} = self.Attributes.struct1.RvaBased +proc `ReservedAttributes=`*(self: var IMAGE_DELAYLOAD_DESCRIPTOR, x: DWORD) {.inline.} = self.Attributes.struct1.ReservedAttributes = x +proc ReservedAttributes*(self: IMAGE_DELAYLOAD_DESCRIPTOR): DWORD {.inline.} = self.Attributes.struct1.ReservedAttributes +proc `NameOffset=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union1.struct1.NameOffset = x +proc NameOffset*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union1.struct1.NameOffset +proc `NameIsString=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union1.struct1.NameIsString = x +proc NameIsString*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union1.struct1.NameIsString +proc `Name=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union1.Name = x +proc Name*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union1.Name +proc Name*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY): var DWORD {.inline.} = self.union1.Name +proc `Id=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: WORD) {.inline.} = self.union1.Id = x +proc Id*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): WORD {.inline.} = self.union1.Id +proc Id*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY): var WORD {.inline.} = self.union1.Id +proc `OffsetToData=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union2.OffsetToData = x +proc OffsetToData*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union2.OffsetToData +proc OffsetToData*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY): var DWORD {.inline.} = self.union2.OffsetToData +proc `OffsetToDirectory=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union2.struct1.OffsetToDirectory = x +proc OffsetToDirectory*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union2.struct1.OffsetToDirectory +proc `DataIsDirectory=`*(self: var IMAGE_RESOURCE_DIRECTORY_ENTRY, x: DWORD) {.inline.} = self.union2.struct1.DataIsDirectory = x +proc DataIsDirectory*(self: IMAGE_RESOURCE_DIRECTORY_ENTRY): DWORD {.inline.} = self.union2.struct1.DataIsDirectory +proc `EndOfPrologue=`*(self: var IMAGE_FUNCTION_ENTRY64, x: ULONGLONG) {.inline.} = self.union1.EndOfPrologue = x +proc EndOfPrologue*(self: IMAGE_FUNCTION_ENTRY64): ULONGLONG {.inline.} = self.union1.EndOfPrologue +proc EndOfPrologue*(self: var IMAGE_FUNCTION_ENTRY64): var ULONGLONG {.inline.} = self.union1.EndOfPrologue +proc `UnwindInfoAddress=`*(self: var IMAGE_FUNCTION_ENTRY64, x: ULONGLONG) {.inline.} = self.union1.UnwindInfoAddress = x +proc UnwindInfoAddress*(self: IMAGE_FUNCTION_ENTRY64): ULONGLONG {.inline.} = self.union1.UnwindInfoAddress +proc UnwindInfoAddress*(self: var IMAGE_FUNCTION_ENTRY64): var ULONGLONG {.inline.} = self.union1.UnwindInfoAddress +proc `Ordinal=`*(self: var IMPORT_OBJECT_HEADER, x: WORD) {.inline.} = self.union1.Ordinal = x +proc Ordinal*(self: IMPORT_OBJECT_HEADER): WORD {.inline.} = self.union1.Ordinal +proc Ordinal*(self: var IMPORT_OBJECT_HEADER): var WORD {.inline.} = self.union1.Ordinal +proc `Hint=`*(self: var IMPORT_OBJECT_HEADER, x: WORD) {.inline.} = self.union1.Hint = x +proc Hint*(self: IMPORT_OBJECT_HEADER): WORD {.inline.} = self.union1.Hint +proc Hint*(self: var IMPORT_OBJECT_HEADER): var WORD {.inline.} = self.union1.Hint +proc `EntryPointToken=`*(self: var IMAGE_COR20_HEADER, x: DWORD) {.inline.} = self.union1.EntryPointToken = x +proc EntryPointToken*(self: IMAGE_COR20_HEADER): DWORD {.inline.} = self.union1.EntryPointToken +proc EntryPointToken*(self: var IMAGE_COR20_HEADER): var DWORD {.inline.} = self.union1.EntryPointToken +proc `EntryPointRVA=`*(self: var IMAGE_COR20_HEADER, x: DWORD) {.inline.} = self.union1.EntryPointRVA = x +proc EntryPointRVA*(self: IMAGE_COR20_HEADER): DWORD {.inline.} = self.union1.EntryPointRVA +proc EntryPointRVA*(self: var IMAGE_COR20_HEADER): var DWORD {.inline.} = self.union1.EntryPointRVA +proc `CheckSum=`*(self: var LDR_DATA_TABLE_ENTRY, x: ULONG) {.inline.} = self.union1.CheckSum = x +proc CheckSum*(self: LDR_DATA_TABLE_ENTRY): ULONG {.inline.} = self.union1.CheckSum +proc CheckSum*(self: var LDR_DATA_TABLE_ENTRY): var ULONG {.inline.} = self.union1.CheckSum +proc `Reserved6=`*(self: var LDR_DATA_TABLE_ENTRY, x: PVOID) {.inline.} = self.union1.Reserved6 = x +proc Reserved6*(self: LDR_DATA_TABLE_ENTRY): PVOID {.inline.} = self.union1.Reserved6 +proc Reserved6*(self: var LDR_DATA_TABLE_ENTRY): var PVOID {.inline.} = self.union1.Reserved6 +proc `Status=`*(self: var IO_STATUS_BLOCK, x: NTSTATUS) {.inline.} = self.union1.Status = x +proc Status*(self: IO_STATUS_BLOCK): NTSTATUS {.inline.} = self.union1.Status +proc Status*(self: var IO_STATUS_BLOCK): var NTSTATUS {.inline.} = self.union1.Status +proc `Pointer=`*(self: var IO_STATUS_BLOCK, x: PVOID) {.inline.} = self.union1.Pointer = x +proc Pointer*(self: IO_STATUS_BLOCK): PVOID {.inline.} = self.union1.Pointer +proc Pointer*(self: var IO_STATUS_BLOCK): var PVOID {.inline.} = self.union1.Pointer +when winimUnicode: + type + PCZZTSTR* = PCZZWSTR + PCUZZTSTR* = PCUZZWSTR + PNZTCH* = PNZWCH + PCNZTCH* = PCNZWCH + PCUNZTCH* = PCUNZWCH + OSVERSIONINFO* = OSVERSIONINFOW + POSVERSIONINFO* = POSVERSIONINFOW + LPOSVERSIONINFO* = LPOSVERSIONINFOW + OSVERSIONINFOEX* = OSVERSIONINFOEXW + POSVERSIONINFOEX* = POSVERSIONINFOEXW + LPOSVERSIONINFOEX* = LPOSVERSIONINFOEXW +when winimAnsi: + type + PCZZTSTR* = PCZZSTR + PCUZZTSTR* = PCZZSTR + PNZTCH* = PNZCH + PUNZTCH* = PNZCH + PCNZTCH* = PCNZCH + PCUNZTCH* = PCNZCH + OSVERSIONINFO* = OSVERSIONINFOA + POSVERSIONINFO* = POSVERSIONINFOA + LPOSVERSIONINFO* = LPOSVERSIONINFOA + OSVERSIONINFOEX* = OSVERSIONINFOEXA + POSVERSIONINFOEX* = POSVERSIONINFOEXA + LPOSVERSIONINFOEX* = LPOSVERSIONINFOEXA +when winimCpu64: + type + PXSAVE_FORMAT* = ptr XSAVE_FORMAT + XSTATE_CONTEXT* {.pure.} = object + Mask*: DWORD64 + Length*: DWORD + Reserved1*: DWORD + Area*: PXSAVE_AREA + Buffer*: PVOID +when winimCpu32: + type + XSTATE_CONTEXT* {.pure.} = object + Mask*: DWORD64 + Length*: DWORD + Reserved1*: DWORD + Area*: PXSAVE_AREA + Reserved2*: DWORD + Buffer*: PVOID + Reserved3*: DWORD +when winimCpu64: + type + PXSTATE_CONTEXT* = ptr XSTATE_CONTEXT + PXMM_SAVE_AREA32* = ptr XMM_SAVE_AREA32 + RUNTIME_FUNCTION* {.pure.} = object + BeginAddress*: DWORD + EndAddress*: DWORD + UnwindData*: DWORD + PRUNTIME_FUNCTION* = ptr RUNTIME_FUNCTION + UNWIND_HISTORY_TABLE_ENTRY* {.pure.} = object + ImageBase*: ULONG64 + FunctionEntry*: PRUNTIME_FUNCTION + PUNWIND_HISTORY_TABLE_ENTRY* = ptr UNWIND_HISTORY_TABLE_ENTRY + const + UNWIND_HISTORY_TABLE_SIZE* = 12 + type + UNWIND_HISTORY_TABLE* {.pure.} = object + Count*: ULONG + Search*: UCHAR + LowAddress*: ULONG64 + HighAddress*: ULONG64 + Entry*: array[UNWIND_HISTORY_TABLE_SIZE, UNWIND_HISTORY_TABLE_ENTRY] + PUNWIND_HISTORY_TABLE* = ptr UNWIND_HISTORY_TABLE + DISPATCHER_CONTEXT* {.pure.} = object + ControlPc*: ULONG64 + ImageBase*: ULONG64 + FunctionEntry*: PRUNTIME_FUNCTION + EstablisherFrame*: ULONG64 + TargetIp*: ULONG64 + ContextRecord*: PCONTEXT + LanguageHandler*: PEXCEPTION_ROUTINE + HandlerData*: PVOID + HistoryTable*: PUNWIND_HISTORY_TABLE + ScopeIndex*: ULONG + Fill0*: ULONG + PDISPATCHER_CONTEXT* = ptr DISPATCHER_CONTEXT + KNONVOLATILE_CONTEXT_POINTERS* {.pure.} = object + FloatingContext*: array[16, PM128A] + IntegerContext*: array[16, PULONG64] + PKNONVOLATILE_CONTEXT_POINTERS* = ptr KNONVOLATILE_CONTEXT_POINTERS + IMAGE_OPTIONAL_HEADER* = IMAGE_OPTIONAL_HEADER64 + PIMAGE_OPTIONAL_HEADER* = PIMAGE_OPTIONAL_HEADER64 + IMAGE_NT_HEADERS* = IMAGE_NT_HEADERS64 + IMAGE_THUNK_DATA* = IMAGE_THUNK_DATA64 + PIMAGE_THUNK_DATA* = PIMAGE_THUNK_DATA64 + IMAGE_TLS_DIRECTORY* = IMAGE_TLS_DIRECTORY64 + PIMAGE_TLS_DIRECTORY* = PIMAGE_TLS_DIRECTORY64 + IMAGE_LOAD_CONFIG_DIRECTORY* = IMAGE_LOAD_CONFIG_DIRECTORY64 + PIMAGE_LOAD_CONFIG_DIRECTORY* = PIMAGE_LOAD_CONFIG_DIRECTORY64 + const + ADDRESS_TAG_BIT* = 0x40000000000 + EXCEPTION_READ_FAULT* = 0 + EXCEPTION_WRITE_FAULT* = 1 + EXCEPTION_EXECUTE_FAULT* = 8 + CONTEXT_AMD64* = 0x100000 + CONTEXT_CONTROL* = CONTEXT_AMD64 or 0x1 + CONTEXT_INTEGER* = CONTEXT_AMD64 or 0x2 + CONTEXT_SEGMENTS* = CONTEXT_AMD64 or 0x4 + CONTEXT_FLOATING_POINT* = CONTEXT_AMD64 or 0x8 + CONTEXT_DEBUG_REGISTERS* = CONTEXT_AMD64 or 0x10 +when winimCpu32: + const + CONTEXT_i386* = 0x00010000 + CONTEXT_CONTROL* = CONTEXT_i386 or 0x00000001 + CONTEXT_INTEGER* = CONTEXT_i386 or 0x00000002 + CONTEXT_FLOATING_POINT* = CONTEXT_i386 or 0x00000008 +when winimCpu64: + const + CONTEXT_FULL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_FLOATING_POINT +when winimCpu32: + const + CONTEXT_SEGMENTS* = CONTEXT_i386 or 0x00000004 + CONTEXT_DEBUG_REGISTERS* = CONTEXT_i386 or 0x00000010 +when winimCpu64: + const + CONTEXT_ALL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS or CONTEXT_FLOATING_POINT or CONTEXT_DEBUG_REGISTERS + CONTEXT_EXCEPTION_ACTIVE* = 0x8000000 + CONTEXT_SERVICE_ACTIVE* = 0x10000000 + CONTEXT_EXCEPTION_REQUEST* = 0x40000000 + CONTEXT_EXCEPTION_REPORTING* = 0x80000000'i32 + INITIAL_MXCSR* = 0x1f80 + INITIAL_FPCSR* = 0x027f + LEGACY_SAVE_AREA_LENGTH* = sizeof(XMM_SAVE_AREA32) + RUNTIME_FUNCTION_INDIRECT* = 0x1 + OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME* = "OutOfProcessFunctionTableCallback" + UNW_FLAG_NHANDLER* = 0x0 + UNW_FLAG_EHANDLER* = 0x1 + UNW_FLAG_UHANDLER* = 0x2 + UNW_FLAG_CHAININFO* = 0x4 + UNWIND_HISTORY_TABLE_NONE* = 0 + UNWIND_HISTORY_TABLE_GLOBAL* = 1 + UNWIND_HISTORY_TABLE_LOCAL* = 2 + IMAGE_SIZEOF_NT_OPTIONAL_HEADER* = IMAGE_SIZEOF_NT_OPTIONAL64_HEADER + IMAGE_NT_OPTIONAL_HDR_MAGIC* = IMAGE_NT_OPTIONAL_HDR64_MAGIC + IMAGE_ORDINAL_FLAG* = IMAGE_ORDINAL_FLAG64 + type + PGET_RUNTIME_FUNCTION_CALLBACK* = proc (ControlPc: DWORD64, Context: PVOID): PRUNTIME_FUNCTION {.stdcall.} + POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK* = proc (Process: HANDLE, TableAddress: PVOID, Entries: PDWORD, Functions: ptr PRUNTIME_FUNCTION): DWORD {.stdcall.} + proc RtlAddGrowableFunctionTable*(DynamicTable: ptr PVOID, FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, MaximumEntryCount: DWORD, RangeBase: ULONG_PTR, RangeEnd: ULONG_PTR): DWORD {.winapi, stdcall, dynlib: "ntdll", importc.} + proc RtlGrowFunctionTable*(DynamicTable: PVOID, NewEntryCount: DWORD): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} + proc RtlDeleteGrowableFunctionTable*(DynamicTable: PVOID): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} + proc RtlAddFunctionTable*(FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, BaseAddress: DWORD64): BOOLEAN {.winapi, cdecl, dynlib: "ntdll", importc.} + proc RtlDeleteFunctionTable*(FunctionTable: PRUNTIME_FUNCTION): BOOLEAN {.winapi, cdecl, dynlib: "ntdll", importc.} + proc RtlInstallFunctionTableCallback*(TableIdentifier: DWORD64, BaseAddress: DWORD64, Length: DWORD, Callback: PGET_RUNTIME_FUNCTION_CALLBACK, Context: PVOID, OutOfProcessCallbackDll: PCWSTR): BOOLEAN {.winapi, cdecl, dynlib: "ntdll", importc.} + proc RtlRestoreContext*(ContextRecord: PCONTEXT, ExceptionRecord: ptr EXCEPTION_RECORD): VOID {.winapi, cdecl, dynlib: "ntdll", importc.} + proc RtlVirtualUnwind*(HandlerType: DWORD, ImageBase: DWORD64, ControlPc: DWORD64, FunctionEntry: PRUNTIME_FUNCTION, ContextRecord: PCONTEXT, HandlerData: ptr PVOID, EstablisherFrame: PDWORD64, ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS): PEXCEPTION_ROUTINE {.winapi, stdcall, dynlib: "ntdll", importc.} + proc RtlLookupFunctionEntry*(ControlPc: DWORD64, ImageBase: PDWORD64, HistoryTable: PUNWIND_HISTORY_TABLE): PRUNTIME_FUNCTION {.winapi, stdcall, dynlib: "ntdll", importc.} + proc RtlUnwindEx*(TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID, ContextRecord: PCONTEXT, HistoryTable: PUNWIND_HISTORY_TABLE): VOID {.winapi, stdcall, dynlib: "ntdll", importc.} + template IMAGE_ORDINAL*(Ordinal: untyped): int64 = Ordinal.int64 and 0xffff'i64 + template IMAGE_SNAP_BY_ORDINAL*(Ordinal: untyped): bool = (Ordinal and IMAGE_ORDINAL_FLAG64) != 0 + proc `FltSave=`*(self: var CONTEXT, x: XMM_SAVE_AREA32) {.inline.} = self.union1.FltSave = x + proc FltSave*(self: CONTEXT): XMM_SAVE_AREA32 {.inline.} = self.union1.FltSave + proc FltSave*(self: var CONTEXT): var XMM_SAVE_AREA32 {.inline.} = self.union1.FltSave + proc `FloatSave=`*(self: var CONTEXT, x: XMM_SAVE_AREA32) {.inline.} = self.union1.FloatSave = x + proc FloatSave*(self: CONTEXT): XMM_SAVE_AREA32 {.inline.} = self.union1.FloatSave + proc FloatSave*(self: var CONTEXT): var XMM_SAVE_AREA32 {.inline.} = self.union1.FloatSave + proc `Header=`*(self: var CONTEXT, x: array[2, M128A]) {.inline.} = self.union1.struct1.Header = x + proc Header*(self: CONTEXT): array[2, M128A] {.inline.} = self.union1.struct1.Header + proc Header*(self: var CONTEXT): var array[2, M128A] {.inline.} = self.union1.struct1.Header + proc `Legacy=`*(self: var CONTEXT, x: array[8, M128A]) {.inline.} = self.union1.struct1.Legacy = x + proc Legacy*(self: CONTEXT): array[8, M128A] {.inline.} = self.union1.struct1.Legacy + proc Legacy*(self: var CONTEXT): var array[8, M128A] {.inline.} = self.union1.struct1.Legacy + proc `Xmm0=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm0 = x + proc Xmm0*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm0 + proc Xmm0*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm0 + proc `Xmm1=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm1 = x + proc Xmm1*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm1 + proc Xmm1*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm1 + proc `Xmm2=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm2 = x + proc Xmm2*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm2 + proc Xmm2*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm2 + proc `Xmm3=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm3 = x + proc Xmm3*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm3 + proc Xmm3*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm3 + proc `Xmm4=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm4 = x + proc Xmm4*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm4 + proc Xmm4*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm4 + proc `Xmm5=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm5 = x + proc Xmm5*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm5 + proc Xmm5*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm5 + proc `Xmm6=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm6 = x + proc Xmm6*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm6 + proc Xmm6*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm6 + proc `Xmm7=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm7 = x + proc Xmm7*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm7 + proc Xmm7*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm7 + proc `Xmm8=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm8 = x + proc Xmm8*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm8 + proc Xmm8*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm8 + proc `Xmm9=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm9 = x + proc Xmm9*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm9 + proc Xmm9*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm9 + proc `Xmm10=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm10 = x + proc Xmm10*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm10 + proc Xmm10*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm10 + proc `Xmm11=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm11 = x + proc Xmm11*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm11 + proc Xmm11*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm11 + proc `Xmm12=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm12 = x + proc Xmm12*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm12 + proc Xmm12*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm12 + proc `Xmm13=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm13 = x + proc Xmm13*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm13 + proc Xmm13*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm13 + proc `Xmm14=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm14 = x + proc Xmm14*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm14 + proc Xmm14*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm14 + proc `Xmm15=`*(self: var CONTEXT, x: M128A) {.inline.} = self.union1.struct1.Xmm15 = x + proc Xmm15*(self: CONTEXT): M128A {.inline.} = self.union1.struct1.Xmm15 + proc Xmm15*(self: var CONTEXT): var M128A {.inline.} = self.union1.struct1.Xmm15 + proc `Alignment=`*(self: var SLIST_HEADER, x: ULONGLONG) {.inline.} = self.struct1.Alignment = x + proc Alignment*(self: SLIST_HEADER): ULONGLONG {.inline.} = self.struct1.Alignment + proc Alignment*(self: var SLIST_HEADER): var ULONGLONG {.inline.} = self.struct1.Alignment + proc `Region=`*(self: var SLIST_HEADER, x: ULONGLONG) {.inline.} = self.struct1.Region = x + proc Region*(self: SLIST_HEADER): ULONGLONG {.inline.} = self.struct1.Region + proc Region*(self: var SLIST_HEADER): var ULONGLONG {.inline.} = self.struct1.Region +when winimCpu32: + type + HALF_PTR* = int16 + PHALF_PTR* = ptr int16 + PXSAVE_FORMAT* = ptr XSAVE_FORMAT + PXSTATE_CONTEXT* = ptr XSTATE_CONTEXT + PFLOATING_SAVE_AREA* = ptr FLOATING_SAVE_AREA + IMAGE_OPTIONAL_HEADER* = IMAGE_OPTIONAL_HEADER32 + PIMAGE_OPTIONAL_HEADER* = PIMAGE_OPTIONAL_HEADER32 + IMAGE_NT_HEADERS* = IMAGE_NT_HEADERS32 + IMAGE_THUNK_DATA* = IMAGE_THUNK_DATA32 + PIMAGE_THUNK_DATA* = PIMAGE_THUNK_DATA32 + IMAGE_TLS_DIRECTORY* = IMAGE_TLS_DIRECTORY32 + PIMAGE_TLS_DIRECTORY* = PIMAGE_TLS_DIRECTORY32 + IMAGE_LOAD_CONFIG_DIRECTORY* = IMAGE_LOAD_CONFIG_DIRECTORY32 + PIMAGE_LOAD_CONFIG_DIRECTORY* = PIMAGE_LOAD_CONFIG_DIRECTORY32 + const + ADDRESS_TAG_BIT* = 0x80000000'i32 + pcTeb* = 0x18 + EXCEPTION_READ_FAULT* = 0 + EXCEPTION_WRITE_FAULT* = 1 + EXCEPTION_EXECUTE_FAULT* = 8 + CONTEXT_i486* = 0x00010000 + CONTEXT_EXTENDED_REGISTERS* = CONTEXT_i386 or 0x00000020 + CONTEXT_FULL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS + CONTEXT_ALL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS or CONTEXT_FLOATING_POINT or CONTEXT_DEBUG_REGISTERS or CONTEXT_EXTENDED_REGISTERS + IMAGE_SIZEOF_NT_OPTIONAL_HEADER* = IMAGE_SIZEOF_NT_OPTIONAL32_HEADER + IMAGE_NT_OPTIONAL_HDR_MAGIC* = IMAGE_NT_OPTIONAL_HDR32_MAGIC + IMAGE_ORDINAL_FLAG* = IMAGE_ORDINAL_FLAG32 + template IMAGE_ORDINAL*(Ordinal: untyped): int32 = Ordinal.int32 and 0xffff'i32 + template IMAGE_SNAP_BY_ORDINAL*(Ordinal: untyped): bool = (Ordinal and IMAGE_ORDINAL_FLAG32) != 0 + proc `Next=`*(self: var SLIST_HEADER, x: SLIST_ENTRY) {.inline.} = self.struct1.Next = x + proc Next*(self: SLIST_HEADER): SLIST_ENTRY {.inline.} = self.struct1.Next + proc Next*(self: var SLIST_HEADER): var SLIST_ENTRY {.inline.} = self.struct1.Next + proc `Depth=`*(self: var SLIST_HEADER, x: WORD) {.inline.} = self.struct1.Depth = x + proc Depth*(self: SLIST_HEADER): WORD {.inline.} = self.struct1.Depth + proc Depth*(self: var SLIST_HEADER): var WORD {.inline.} = self.struct1.Depth + proc `Sequence=`*(self: var SLIST_HEADER, x: WORD) {.inline.} = self.struct1.Sequence = x + proc Sequence*(self: SLIST_HEADER): WORD {.inline.} = self.struct1.Sequence + proc Sequence*(self: var SLIST_HEADER): var WORD {.inline.} = self.struct1.Sequence diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/windns.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/windns.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,836 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winsock +#include +type + DNS_CONFIG_TYPE* = int32 + DNS_SECTION* = int32 + DNS_CHARSET* = int32 + DNS_FREE_TYPE* = int32 + DNS_NAME_FORMAT* = int32 + DNS_STATUS* = LONG + PDNS_STATUS* = ptr LONG + IP4_ADDRESS* = DWORD + PIP4_ADDRESS* = ptr DWORD + IP4_ARRAY* {.pure.} = object + AddrCount*: DWORD + AddrArray*: array[1, IP4_ADDRESS] + PIP4_ARRAY* = ptr IP4_ARRAY + IP6_ADDRESS* {.pure, union.} = object + IP6Qword*: array[2, QWORD] + IP6Dword*: array[4, DWORD] + IP6Word*: array[8, WORD] + IP6Byte*: array[16, BYTE] + In6*: IN6_ADDR + PIP6_ADDRESS* = ptr IP6_ADDRESS + DNS_HEADER* {.pure.} = object + Xid*: WORD + RecursionDesired* {.bitsize:1.}: BYTE + Truncation* {.bitsize:1.}: BYTE + Authoritative* {.bitsize:1.}: BYTE + Opcode* {.bitsize:4.}: BYTE + IsResponse* {.bitsize:1.}: BYTE + ResponseCode* {.bitsize:4.}: BYTE + Reserved* {.bitsize:3.}: BYTE + RecursionAvailable* {.bitsize:1.}: BYTE + QuestionCount*: WORD + AnswerCount*: WORD + NameServerCount*: WORD + AdditionalCount*: WORD + PDNS_HEADER* = ptr DNS_HEADER + DNS_WIRE_QUESTION* {.pure.} = object + QuestionType*: WORD + QuestionClass*: WORD + PDNS_WIRE_QUESTION* = ptr DNS_WIRE_QUESTION + DNS_WIRE_RECORD* {.pure, packed.} = object + RecordType*: WORD + RecordClass*: WORD + TimeToLive*: DWORD + DataLength*: WORD + PDNS_WIRE_RECORD* = ptr DNS_WIRE_RECORD + DNS_A_DATA* {.pure.} = object + IpAddress*: IP4_ADDRESS + PDNS_A_DATA* = ptr DNS_A_DATA + DNS_PTR_DATAW* {.pure.} = object + pNameHost*: PWSTR + PDNS_PTR_DATAW* = ptr DNS_PTR_DATAW + DNS_PTR_DATAA* {.pure.} = object + pNameHost*: PSTR + PDNS_PTR_DATAA* = ptr DNS_PTR_DATAA + DNS_SOA_DATAW* {.pure.} = object + pNamePrimaryServer*: PWSTR + pNameAdministrator*: PWSTR + dwSerialNo*: DWORD + dwRefresh*: DWORD + dwRetry*: DWORD + dwExpire*: DWORD + dwDefaultTtl*: DWORD + PDNS_SOA_DATAW* = ptr DNS_SOA_DATAW + DNS_SOA_DATAA* {.pure.} = object + pNamePrimaryServer*: PSTR + pNameAdministrator*: PSTR + dwSerialNo*: DWORD + dwRefresh*: DWORD + dwRetry*: DWORD + dwExpire*: DWORD + dwDefaultTtl*: DWORD + PDNS_SOA_DATAA* = ptr DNS_SOA_DATAA + DNS_MINFO_DATAW* {.pure.} = object + pNameMailbox*: PWSTR + pNameErrorsMailbox*: PWSTR + PDNS_MINFO_DATAW* = ptr DNS_MINFO_DATAW + DNS_MINFO_DATAA* {.pure.} = object + pNameMailbox*: PSTR + pNameErrorsMailbox*: PSTR + PDNS_MINFO_DATAA* = ptr DNS_MINFO_DATAA + DNS_MX_DATAW* {.pure.} = object + pNameExchange*: PWSTR + wPreference*: WORD + Pad*: WORD + PDNS_MX_DATAW* = ptr DNS_MX_DATAW + DNS_MX_DATAA* {.pure.} = object + pNameExchange*: PSTR + wPreference*: WORD + Pad*: WORD + PDNS_MX_DATAA* = ptr DNS_MX_DATAA + DNS_TXT_DATAW* {.pure.} = object + dwStringCount*: DWORD + pStringArray*: array[1, PWSTR] + PDNS_TXT_DATAW* = ptr DNS_TXT_DATAW + DNS_TXT_DATAA* {.pure.} = object + dwStringCount*: DWORD + pStringArray*: array[1, PSTR] + PDNS_TXT_DATAA* = ptr DNS_TXT_DATAA + DNS_NULL_DATA* {.pure.} = object + dwByteCount*: DWORD + Data*: array[1, BYTE] + PDNS_NULL_DATA* = ptr DNS_NULL_DATA + DNS_WKS_DATA* {.pure.} = object + IpAddress*: IP4_ADDRESS + chProtocol*: UCHAR + BitMask*: array[1, BYTE] + PDNS_WKS_DATA* = ptr DNS_WKS_DATA + DNS_AAAA_DATA* {.pure.} = object + Ip6Address*: IP6_ADDRESS + PDNS_AAAA_DATA* = ptr DNS_AAAA_DATA + DNS_SIG_DATAW* {.pure.} = object + pNameSigner*: PWSTR + wTypeCovered*: WORD + chAlgorithm*: BYTE + chLabelCount*: BYTE + dwOriginalTtl*: DWORD + dwExpiration*: DWORD + dwTimeSigned*: DWORD + wKeyTag*: WORD + Pad*: WORD + Signature*: array[1, BYTE] + PDNS_SIG_DATAW* = ptr DNS_SIG_DATAW + DNS_SIG_DATAA* {.pure.} = object + pNameSigner*: PSTR + wTypeCovered*: WORD + chAlgorithm*: BYTE + chLabelCount*: BYTE + dwOriginalTtl*: DWORD + dwExpiration*: DWORD + dwTimeSigned*: DWORD + wKeyTag*: WORD + Pad*: WORD + Signature*: array[1, BYTE] + PDNS_SIG_DATAA* = ptr DNS_SIG_DATAA + DNS_KEY_DATA* {.pure.} = object + wFlags*: WORD + chProtocol*: BYTE + chAlgorithm*: BYTE + Key*: array[1, BYTE] + PDNS_KEY_DATA* = ptr DNS_KEY_DATA + DNS_LOC_DATA* {.pure.} = object + wVersion*: WORD + wSize*: WORD + wHorPrec*: WORD + wVerPrec*: WORD + dwLatitude*: DWORD + dwLongitude*: DWORD + dwAltitude*: DWORD + PDNS_LOC_DATA* = ptr DNS_LOC_DATA + DNS_NXT_DATAW* {.pure.} = object + pNameNext*: PWSTR + wNumTypes*: WORD + wTypes*: array[1, WORD] + PDNS_NXT_DATAW* = ptr DNS_NXT_DATAW + DNS_NXT_DATAA* {.pure.} = object + pNameNext*: PSTR + wNumTypes*: WORD + wTypes*: array[1, WORD] + PDNS_NXT_DATAA* = ptr DNS_NXT_DATAA + DNS_SRV_DATAW* {.pure.} = object + pNameTarget*: PWSTR + wPriority*: WORD + wWeight*: WORD + wPort*: WORD + Pad*: WORD + PDNS_SRV_DATAW* = ptr DNS_SRV_DATAW + DNS_SRV_DATAA* {.pure.} = object + pNameTarget*: PSTR + wPriority*: WORD + wWeight*: WORD + wPort*: WORD + Pad*: WORD + PDNS_SRV_DATAA* = ptr DNS_SRV_DATAA +const + DNS_ATMA_MAX_ADDR_LENGTH* = 20 +type + DNS_ATMA_DATA* {.pure.} = object + AddressType*: BYTE + Address*: array[DNS_ATMA_MAX_ADDR_LENGTH , BYTE] + PDNS_ATMA_DATA* = ptr DNS_ATMA_DATA + DNS_TKEY_DATAW* {.pure.} = object + pNameAlgorithm*: PWSTR + pAlgorithmPacket*: PBYTE + pKey*: PBYTE + pOtherData*: PBYTE + dwCreateTime*: DWORD + dwExpireTime*: DWORD + wMode*: WORD + wError*: WORD + wKeyLength*: WORD + wOtherLength*: WORD + cAlgNameLength*: UCHAR + bPacketPointers*: WINBOOL + PDNS_TKEY_DATAW* = ptr DNS_TKEY_DATAW + DNS_TKEY_DATAA* {.pure.} = object + pNameAlgorithm*: PSTR + pAlgorithmPacket*: PBYTE + pKey*: PBYTE + pOtherData*: PBYTE + dwCreateTime*: DWORD + dwExpireTime*: DWORD + wMode*: WORD + wError*: WORD + wKeyLength*: WORD + wOtherLength*: WORD + cAlgNameLength*: UCHAR + bPacketPointers*: WINBOOL + PDNS_TKEY_DATAA* = ptr DNS_TKEY_DATAA + DNS_TSIG_DATAW* {.pure.} = object + pNameAlgorithm*: PWSTR + pAlgorithmPacket*: PBYTE + pSignature*: PBYTE + pOtherData*: PBYTE + i64CreateTime*: LONGLONG + wFudgeTime*: WORD + wOriginalXid*: WORD + wError*: WORD + wSigLength*: WORD + wOtherLength*: WORD + cAlgNameLength*: UCHAR + bPacketPointers*: WINBOOL + PDNS_TSIG_DATAW* = ptr DNS_TSIG_DATAW + DNS_TSIG_DATAA* {.pure.} = object + pNameAlgorithm*: PSTR + pAlgorithmPacket*: PBYTE + pSignature*: PBYTE + pOtherData*: PBYTE + i64CreateTime*: LONGLONG + wFudgeTime*: WORD + wOriginalXid*: WORD + wError*: WORD + wSigLength*: WORD + wOtherLength*: WORD + cAlgNameLength*: UCHAR + bPacketPointers*: WINBOOL + PDNS_TSIG_DATAA* = ptr DNS_TSIG_DATAA + DNS_WINS_DATA* {.pure.} = object + dwMappingFlag*: DWORD + dwLookupTimeout*: DWORD + dwCacheTimeout*: DWORD + cWinsServerCount*: DWORD + WinsServers*: array[1, IP4_ADDRESS] + PDNS_WINS_DATA* = ptr DNS_WINS_DATA + DNS_WINSR_DATAW* {.pure.} = object + dwMappingFlag*: DWORD + dwLookupTimeout*: DWORD + dwCacheTimeout*: DWORD + pNameResultDomain*: PWSTR + PDNS_WINSR_DATAW* = ptr DNS_WINSR_DATAW + DNS_WINSR_DATAA* {.pure.} = object + dwMappingFlag*: DWORD + dwLookupTimeout*: DWORD + dwCacheTimeout*: DWORD + pNameResultDomain*: PSTR + PDNS_WINSR_DATAA* = ptr DNS_WINSR_DATAA + DNS_RECORD_FLAGS* {.pure.} = object + Section* {.bitsize:2.}: DWORD + Delete* {.bitsize:1.}: DWORD + CharSet* {.bitsize:2.}: DWORD + Unused* {.bitsize:3.}: DWORD + Reserved* {.bitsize:24.}: DWORD + DNS_RECORDW_Flags* {.pure, union.} = object + DW*: DWORD + S*: DNS_RECORD_FLAGS + DNS_RECORDW_Data* {.pure, union.} = object + A*: DNS_A_DATA + SOA*: DNS_SOA_DATAW + soa*: DNS_SOA_DATAW + PTR*: DNS_PTR_DATAW + `ptr`*: DNS_PTR_DATAW + NS*: DNS_PTR_DATAW + ns*: DNS_PTR_DATAW + CNAME*: DNS_PTR_DATAW + cname*: DNS_PTR_DATAW + MB*: DNS_PTR_DATAW + mb*: DNS_PTR_DATAW + MD*: DNS_PTR_DATAW + md*: DNS_PTR_DATAW + MF*: DNS_PTR_DATAW + mf*: DNS_PTR_DATAW + MG*: DNS_PTR_DATAW + mg*: DNS_PTR_DATAW + MR*: DNS_PTR_DATAW + mr*: DNS_PTR_DATAW + MINFO*: DNS_MINFO_DATAW + minfo*: DNS_MINFO_DATAW + RP*: DNS_MINFO_DATAW + rp*: DNS_MINFO_DATAW + MX*: DNS_MX_DATAW + mx*: DNS_MX_DATAW + AFSDB*: DNS_MX_DATAW + afsdb*: DNS_MX_DATAW + RT*: DNS_MX_DATAW + rt*: DNS_MX_DATAW + HINFO*: DNS_TXT_DATAW + hinfo*: DNS_TXT_DATAW + ISDN*: DNS_TXT_DATAW + isdn*: DNS_TXT_DATAW + TXT*: DNS_TXT_DATAW + txt*: DNS_TXT_DATAW + X25*: DNS_TXT_DATAW + Null*: DNS_NULL_DATA + WKS*: DNS_WKS_DATA + wks*: DNS_WKS_DATA + AAAA*: DNS_AAAA_DATA + KEY*: DNS_KEY_DATA + key*: DNS_KEY_DATA + SIG*: DNS_SIG_DATAW + sig*: DNS_SIG_DATAW + ATMA*: DNS_ATMA_DATA + atma*: DNS_ATMA_DATA + NXT*: DNS_NXT_DATAW + nxt*: DNS_NXT_DATAW + SRV*: DNS_SRV_DATAW + srv*: DNS_SRV_DATAW + TKEY*: DNS_TKEY_DATAW + tkey*: DNS_TKEY_DATAW + TSIG*: DNS_TSIG_DATAW + tsig*: DNS_TSIG_DATAW + WINS*: DNS_WINS_DATA + wins*: DNS_WINS_DATA + WINSR*: DNS_WINSR_DATAW + winsr*: DNS_WINSR_DATAW + NBSTAT*: DNS_WINSR_DATAW + nbstat*: DNS_WINSR_DATAW + DNS_RECORDW* {.pure.} = object + pNext*: ptr DnsRecordW + pName*: PWSTR + wType*: WORD + wDataLength*: WORD + Flags*: DNS_RECORDW_Flags + dwTtl*: DWORD + dwReserved*: DWORD + Data*: DNS_RECORDW_Data + PDNS_RECORDW* = ptr DNS_RECORDW + DNS_RECORDA_Flags* {.pure, union.} = object + DW*: DWORD + S*: DNS_RECORD_FLAGS + DNS_RECORDA_Data* {.pure, union.} = object + A*: DNS_A_DATA + SOA*: DNS_SOA_DATAA + soa*: DNS_SOA_DATAA + PTR*: DNS_PTR_DATAA + `ptr`*: DNS_PTR_DATAA + NS*: DNS_PTR_DATAA + ns*: DNS_PTR_DATAA + CNAME*: DNS_PTR_DATAA + cname*: DNS_PTR_DATAA + MB*: DNS_PTR_DATAA + mb*: DNS_PTR_DATAA + MD*: DNS_PTR_DATAA + md*: DNS_PTR_DATAA + MF*: DNS_PTR_DATAA + mf*: DNS_PTR_DATAA + MG*: DNS_PTR_DATAA + mg*: DNS_PTR_DATAA + MR*: DNS_PTR_DATAA + mr*: DNS_PTR_DATAA + MINFO*: DNS_MINFO_DATAA + minfo*: DNS_MINFO_DATAA + RP*: DNS_MINFO_DATAA + rp*: DNS_MINFO_DATAA + MX*: DNS_MX_DATAA + mx*: DNS_MX_DATAA + AFSDB*: DNS_MX_DATAA + afsdb*: DNS_MX_DATAA + RT*: DNS_MX_DATAA + rt*: DNS_MX_DATAA + HINFO*: DNS_TXT_DATAA + hinfo*: DNS_TXT_DATAA + ISDN*: DNS_TXT_DATAA + isdn*: DNS_TXT_DATAA + TXT*: DNS_TXT_DATAA + txt*: DNS_TXT_DATAA + X25*: DNS_TXT_DATAA + Null*: DNS_NULL_DATA + WKS*: DNS_WKS_DATA + wks*: DNS_WKS_DATA + AAAA*: DNS_AAAA_DATA + KEY*: DNS_KEY_DATA + key*: DNS_KEY_DATA + SIG*: DNS_SIG_DATAA + sig*: DNS_SIG_DATAA + ATMA*: DNS_ATMA_DATA + atma*: DNS_ATMA_DATA + NXT*: DNS_NXT_DATAA + nxt*: DNS_NXT_DATAA + SRV*: DNS_SRV_DATAA + srv*: DNS_SRV_DATAA + TKEY*: DNS_TKEY_DATAA + tkey*: DNS_TKEY_DATAA + TSIG*: DNS_TSIG_DATAA + tsig*: DNS_TSIG_DATAA + WINS*: DNS_WINS_DATA + wins*: DNS_WINS_DATA + WINSR*: DNS_WINSR_DATAA + winsr*: DNS_WINSR_DATAA + NBSTAT*: DNS_WINSR_DATAA + nbstat*: DNS_WINSR_DATAA + DNS_RECORDA* {.pure.} = object + pNext*: ptr DnsRecordA + pName*: PSTR + wType*: WORD + wDataLength*: WORD + Flags*: DNS_RECORDA_Flags + dwTtl*: DWORD + dwReserved*: DWORD + Data*: DNS_RECORDA_Data + PDNS_RECORDA* = ptr DNS_RECORDA +when winimUnicode: + type + PDNS_RECORD* = ptr DNS_RECORDW +when winimAnsi: + type + PDNS_RECORD* = ptr DNS_RECORDA +type + DNS_RRSET* {.pure.} = object + pFirstRR*: PDNS_RECORD + pLastRR*: PDNS_RECORD + PDNS_RRSET* = ptr DNS_RRSET + DNS_MESSAGE_BUFFER* {.pure, packed.} = object + MessageHead*: DNS_HEADER + MessageBody*: array[1, CHAR] + PDNS_MESSAGE_BUFFER* = ptr DNS_MESSAGE_BUFFER +const + SIZEOF_IP4_ADDRESS* = 4 + IP4_ADDRESS_STRING_LENGTH* = 15 + IP4_ADDRESS_STRING_BUFFER_LENGTH* = 16 + IP6_ADDRESS_STRING_LENGTH* = 47 + IP6_ADDRESS_STRING_BUFFER_LENGTH* = 48 + DNS_PORT_HOST_ORDER* = 0x0035 + DNS_PORT_NET_ORDER* = 0x3500 + DNS_RFC_MAX_UDP_PACKET_LENGTH* = 512 + DNS_MAX_NAME_LENGTH* = 255 + DNS_MAX_LABEL_LENGTH* = 63 + DNS_MAX_NAME_BUFFER_LENGTH* = 256 + DNS_MAX_LABEL_BUFFER_LENGTH* = 64 + DNS_IP4_REVERSE_DOMAIN_STRING_A* = "in-addr.arpa." + DNS_IP4_REVERSE_DOMAIN_STRING_W* = "in-addr.arpa." + DNS_MAX_IP4_REVERSE_NAME_LENGTH* = IP4_ADDRESS_STRING_LENGTH+1+(len(DNS_IP4_REVERSE_DOMAIN_STRING_A)+1) + DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH* = DNS_MAX_IP4_REVERSE_NAME_LENGTH+1 + DNS_IP6_REVERSE_DOMAIN_STRING_A* = "ip6.arpa." + DNS_IP6_REVERSE_DOMAIN_STRING_W* = "ip6.arpa." + DNS_MAX_IP6_REVERSE_NAME_LENGTH* = 64+(len(DNS_IP6_REVERSE_DOMAIN_STRING_A)+1) + DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH* = DNS_MAX_IP6_REVERSE_NAME_LENGTH+1 + DNS_MAX_REVERSE_NAME_LENGTH* = DNS_MAX_IP6_REVERSE_NAME_LENGTH + DNS_MAX_REVERSE_NAME_BUFFER_LENGTH* = DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH + DNS_MAX_TEXT_STRING_LENGTH* = 255 + DNS_COMPRESSED_QUESTION_NAME* = 0xC00C + DNS_OPCODE_QUERY* = 0 + DNS_OPCODE_IQUERY* = 1 + DNS_OPCODE_SERVER_STATUS* = 2 + DNS_OPCODE_UNKNOWN* = 3 + DNS_OPCODE_NOTIFY* = 4 + DNS_OPCODE_UPDATE* = 5 + DNS_RCODE_NOERROR* = 0 + DNS_RCODE_FORMERR* = 1 + DNS_RCODE_SERVFAIL* = 2 + DNS_RCODE_NXDOMAIN* = 3 + DNS_RCODE_NOTIMPL* = 4 + DNS_RCODE_REFUSED* = 5 + DNS_RCODE_YXDOMAIN* = 6 + DNS_RCODE_YXRRSET* = 7 + DNS_RCODE_NXRRSET* = 8 + DNS_RCODE_NOTAUTH* = 9 + DNS_RCODE_NOTZONE* = 10 + DNS_RCODE_MAX* = 15 + DNS_RCODE_BADVERS* = 16 + DNS_RCODE_BADSIG* = 16 + DNS_RCODE_BADKEY* = 17 + DNS_RCODE_BADTIME* = 18 + DNS_RCODE_FORMAT_ERROR* = DNS_RCODE_FORMERR + DNS_RCODE_SERVER_FAILURE* = DNS_RCODE_SERVFAIL + DNS_RCODE_NAME_ERROR* = DNS_RCODE_NXDOMAIN + DNS_RCODE_NOT_IMPLEMENTED* = DNS_RCODE_NOTIMPL + DNS_CLASS_INTERNET* = 0x0001 + DNS_CLASS_CSNET* = 0x0002 + DNS_CLASS_CHAOS* = 0x0003 + DNS_CLASS_HESIOD* = 0x0004 + DNS_CLASS_NONE* = 0x00fe + DNS_CLASS_ALL* = 0x00ff + DNS_CLASS_ANY* = 0x00ff + DNS_RCLASS_INTERNET* = 0x0100 + DNS_RCLASS_CSNET* = 0x0200 + DNS_RCLASS_CHAOS* = 0x0300 + DNS_RCLASS_HESIOD* = 0x0400 + DNS_RCLASS_NONE* = 0xfe00 + DNS_RCLASS_ALL* = 0xff00 + DNS_RCLASS_ANY* = 0xff00 + DNS_TYPE_ZERO* = 0x0000 + DNS_TYPE_A* = 0x0001 + DNS_TYPE_NS* = 0x0002 + DNS_TYPE_MD* = 0x0003 + DNS_TYPE_MF* = 0x0004 + DNS_TYPE_CNAME* = 0x0005 + DNS_TYPE_SOA* = 0x0006 + DNS_TYPE_MB* = 0x0007 + DNS_TYPE_MG* = 0x0008 + DNS_TYPE_MR* = 0x0009 + DNS_TYPE_NULL* = 0x000a + DNS_TYPE_WKS* = 0x000b + DNS_TYPE_PTR* = 0x000c + DNS_TYPE_HINFO* = 0x000d + DNS_TYPE_MINFO* = 0x000e + DNS_TYPE_MX* = 0x000f + DNS_TYPE_TEXT* = 0x0010 + DNS_TYPE_RP* = 0x0011 + DNS_TYPE_AFSDB* = 0x0012 + DNS_TYPE_X25* = 0x0013 + DNS_TYPE_ISDN* = 0x0014 + DNS_TYPE_RT* = 0x0015 + DNS_TYPE_NSAP* = 0x0016 + DNS_TYPE_NSAPPTR* = 0x0017 + DNS_TYPE_SIG* = 0x0018 + DNS_TYPE_KEY* = 0x0019 + DNS_TYPE_PX* = 0x001a + DNS_TYPE_GPOS* = 0x001b + DNS_TYPE_AAAA* = 0x001c + DNS_TYPE_LOC* = 0x001d + DNS_TYPE_NXT* = 0x001e + DNS_TYPE_EID* = 0x001f + DNS_TYPE_NIMLOC* = 0x0020 + DNS_TYPE_SRV* = 0x0021 + DNS_TYPE_ATMA* = 0x0022 + DNS_TYPE_NAPTR* = 0x0023 + DNS_TYPE_KX* = 0x0024 + DNS_TYPE_CERT* = 0x0025 + DNS_TYPE_A6* = 0x0026 + DNS_TYPE_DNAME* = 0x0027 + DNS_TYPE_SINK* = 0x0028 + DNS_TYPE_OPT* = 0x0029 + DNS_TYPE_UINFO* = 0x0064 + DNS_TYPE_UID* = 0x0065 + DNS_TYPE_GID* = 0x0066 + DNS_TYPE_UNSPEC* = 0x0067 + DNS_TYPE_ADDRS* = 0x00f8 + DNS_TYPE_TKEY* = 0x00f9 + DNS_TYPE_TSIG* = 0x00fa + DNS_TYPE_IXFR* = 0x00fb + DNS_TYPE_AXFR* = 0x00fc + DNS_TYPE_MAILB* = 0x00fd + DNS_TYPE_MAILA* = 0x00fe + DNS_TYPE_ALL* = 0x00ff + DNS_TYPE_ANY* = 0x00ff + DNS_TYPE_WINS* = 0xff01 + DNS_TYPE_WINSR* = 0xff02 + DNS_TYPE_NBSTAT* = DNS_TYPE_WINSR + DNS_RTYPE_A* = 0x0100 + DNS_RTYPE_NS* = 0x0200 + DNS_RTYPE_MD* = 0x0300 + DNS_RTYPE_MF* = 0x0400 + DNS_RTYPE_CNAME* = 0x0500 + DNS_RTYPE_SOA* = 0x0600 + DNS_RTYPE_MB* = 0x0700 + DNS_RTYPE_MG* = 0x0800 + DNS_RTYPE_MR* = 0x0900 + DNS_RTYPE_NULL* = 0x0a00 + DNS_RTYPE_WKS* = 0x0b00 + DNS_RTYPE_PTR* = 0x0c00 + DNS_RTYPE_HINFO* = 0x0d00 + DNS_RTYPE_MINFO* = 0x0e00 + DNS_RTYPE_MX* = 0x0f00 + DNS_RTYPE_TEXT* = 0x1000 + DNS_RTYPE_RP* = 0x1100 + DNS_RTYPE_AFSDB* = 0x1200 + DNS_RTYPE_X25* = 0x1300 + DNS_RTYPE_ISDN* = 0x1400 + DNS_RTYPE_RT* = 0x1500 + DNS_RTYPE_NSAP* = 0x1600 + DNS_RTYPE_NSAPPTR* = 0x1700 + DNS_RTYPE_SIG* = 0x1800 + DNS_RTYPE_KEY* = 0x1900 + DNS_RTYPE_PX* = 0x1a00 + DNS_RTYPE_GPOS* = 0x1b00 + DNS_RTYPE_AAAA* = 0x1c00 + DNS_RTYPE_LOC* = 0x1d00 + DNS_RTYPE_NXT* = 0x1e00 + DNS_RTYPE_EID* = 0x1f00 + DNS_RTYPE_NIMLOC* = 0x2000 + DNS_RTYPE_SRV* = 0x2100 + DNS_RTYPE_ATMA* = 0x2200 + DNS_RTYPE_NAPTR* = 0x2300 + DNS_RTYPE_KX* = 0x2400 + DNS_RTYPE_CERT* = 0x2500 + DNS_RTYPE_A6* = 0x2600 + DNS_RTYPE_DNAME* = 0x2700 + DNS_RTYPE_SINK* = 0x2800 + DNS_RTYPE_OPT* = 0x2900 + DNS_RTYPE_UINFO* = 0x6400 + DNS_RTYPE_UID* = 0x6500 + DNS_RTYPE_GID* = 0x6600 + DNS_RTYPE_UNSPEC* = 0x6700 + DNS_RTYPE_TKEY* = 0xf900 + DNS_RTYPE_TSIG* = 0xfa00 + DNS_RTYPE_IXFR* = 0xfb00 + DNS_RTYPE_AXFR* = 0xfc00 + DNS_RTYPE_MAILB* = 0xfd00 + DNS_RTYPE_MAILA* = 0xfe00 + DNS_RTYPE_ALL* = 0xff00 + DNS_RTYPE_ANY* = 0xff00 + DNS_RTYPE_WINS* = 0x01ff + DNS_RTYPE_WINSR* = 0x02ff + DNS_ATMA_FORMAT_E164* = 1 + DNS_ATMA_FORMAT_AESA* = 2 + DNS_ATMA_AESA_ADDR_LENGTH* = 20 + DNS_ATMA_MAX_RECORD_LENGTH* = DNS_ATMA_MAX_ADDR_LENGTH+1 + DNSSEC_ALGORITHM_RSAMD5* = 1 + DNSSEC_ALGORITHM_NULL* = 253 + DNSSEC_ALGORITHM_PRIVATE* = 254 + DNSSEC_PROTOCOL_NONE* = 0 + DNSSEC_PROTOCOL_TLS* = 1 + DNSSEC_PROTOCOL_EMAIL* = 2 + DNSSEC_PROTOCOL_DNSSEC* = 3 + DNSSEC_PROTOCOL_IPSEC* = 4 + DNSSEC_KEY_FLAG_NOAUTH* = 0x0001 + DNSSEC_KEY_FLAG_NOCONF* = 0x0002 + DNSSEC_KEY_FLAG_FLAG2* = 0x0004 + DNSSEC_KEY_FLAG_EXTEND* = 0x0008 + DNSSEC_KEY_FLAG_FLAG4* = 0x0010 + DNSSEC_KEY_FLAG_FLAG5* = 0x0020 + DNSSEC_KEY_FLAG_USER* = 0x0000 + DNSSEC_KEY_FLAG_ZONE* = 0x0040 + DNSSEC_KEY_FLAG_HOST* = 0x0080 + DNSSEC_KEY_FLAG_NTPE3* = 0x00c0 + DNSSEC_KEY_FLAG_FLAG8* = 0x0100 + DNSSEC_KEY_FLAG_FLAG9* = 0x0200 + DNSSEC_KEY_FLAG_FLAG10* = 0x0400 + DNSSEC_KEY_FLAG_FLAG11* = 0x0800 + DNSSEC_KEY_FLAG_SIG0* = 0x0000 + DNSSEC_KEY_FLAG_SIG1* = 0x1000 + DNSSEC_KEY_FLAG_SIG2* = 0x2000 + DNSSEC_KEY_FLAG_SIG3* = 0x3000 + DNSSEC_KEY_FLAG_SIG4* = 0x4000 + DNSSEC_KEY_FLAG_SIG5* = 0x5000 + DNSSEC_KEY_FLAG_SIG6* = 0x6000 + DNSSEC_KEY_FLAG_SIG7* = 0x7000 + DNSSEC_KEY_FLAG_SIG8* = 0x8000 + DNSSEC_KEY_FLAG_SIG9* = 0x9000 + DNSSEC_KEY_FLAG_SIG10* = 0xa000 + DNSSEC_KEY_FLAG_SIG11* = 0xb000 + DNSSEC_KEY_FLAG_SIG12* = 0xc000 + DNSSEC_KEY_FLAG_SIG13* = 0xd000 + DNSSEC_KEY_FLAG_SIG14* = 0xe000 + DNSSEC_KEY_FLAG_SIG15* = 0xf000 + DNS_TKEY_MODE_SERVER_ASSIGN* = 1 + DNS_TKEY_MODE_DIFFIE_HELLMAN* = 2 + DNS_TKEY_MODE_GSS* = 3 + DNS_TKEY_MODE_RESOLVER_ASSIGN* = 4 + DNS_WINS_FLAG_SCOPE* = 0x80000000'i32 + DNS_WINS_FLAG_LOCAL* = 0x00010000 + DnsConfigPrimaryDomainName_W* = 0 + DnsConfigPrimaryDomainName_A* = 1 + DnsConfigPrimaryDomainName_UTF8* = 2 + DnsConfigAdapterDomainName_W* = 3 + DnsConfigAdapterDomainName_A* = 4 + DnsConfigAdapterDomainName_UTF8* = 5 + dnsConfigDnsServerList* = 6 + dnsConfigSearchList* = 7 + dnsConfigAdapterInfo* = 8 + dnsConfigPrimaryHostNameRegistrationEnabled* = 9 + dnsConfigAdapterHostNameRegistrationEnabled* = 10 + dnsConfigAddressRegistrationMaxCount* = 11 + DnsConfigHostName_W* = 12 + DnsConfigHostName_A* = 13 + DnsConfigHostName_UTF8* = 14 + DnsConfigFullHostName_W* = 15 + DnsConfigFullHostName_A* = 16 + DnsConfigFullHostName_UTF8* = 17 + DNS_CONFIG_FLAG_ALLOC* = 0x00000001 + dnsSectionQuestion* = 0 + dnsSectionAnswer* = 1 + dnsSectionAuthority* = 2 + dnsSectionAddtional* = 3 + dnsSectionZone* = dnsSectionQuestion + dnsSectionPrereq* = dnsSectionAnswer + dnsSectionUpdate* = dnsSectionAuthority + DNSREC_SECTION* = 0x00000003 + DNSREC_QUESTION* = 0x00000000 + DNSREC_ANSWER* = 0x00000001 + DNSREC_AUTHORITY* = 0x00000002 + DNSREC_ADDITIONAL* = 0x00000003 + DNSREC_ZONE* = 0x00000000 + DNSREC_PREREQ* = 0x00000001 + DNSREC_UPDATE* = 0x00000002 + DNSREC_DELETE* = 0x00000004 + DNSREC_NOEXIST* = 0x00000004 + DNS_RECORD_FIXED_SIZE* = 32 + SIZEOF_DNS_RECORD_HEADER* = DNS_RECORD_FIXED_SIZE + dnsCharSetUnknown* = 0 + dnsCharSetUnicode* = 1 + dnsCharSetUtf8* = 2 + dnsCharSetAnsi* = 3 + dnsFreeFlat* = 0 + dnsFreeRecordList* = 1 + dnsFreeParsedMessageFields* = 2 + dnsFreeRecordListDeep* = dnsFreeRecordList + DNS_QUERY_STANDARD* = 0x00000000 + DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE* = 0x00000001 + DNS_QUERY_USE_TCP_ONLY* = 0x00000002 + DNS_QUERY_NO_RECURSION* = 0x00000004 + DNS_QUERY_BYPASS_CACHE* = 0x00000008 + DNS_QUERY_NO_WIRE_QUERY* = 0x00000010 + DNS_QUERY_NO_LOCAL_NAME* = 0x00000020 + DNS_QUERY_NO_HOSTS_FILE* = 0x00000040 + DNS_QUERY_NO_NETBT* = 0x00000080 + DNS_QUERY_WIRE_ONLY* = 0x00000100 + DNS_QUERY_RETURN_MESSAGE* = 0x00000200 + DNS_QUERY_MULTICAST_ONLY* = 0x00000400 + DNS_QUERY_NO_MULTICAST* = 0x00000800 + DNS_QUERY_TREAT_AS_FQDN* = 0x00001000 + DNS_QUERY_APPEND_MULTILABEL* = 0x00800000 + DNS_QUERY_DONT_RESET_TTL_VALUES* = 0x00100000 + DNS_QUERY_RESERVED* = 0xff000000'i32 + DNS_QUERY_CACHE_ONLY* = DNS_QUERY_NO_WIRE_QUERY + DNS_UPDATE_SECURITY_USE_DEFAULT* = 0x00000000 + DNS_UPDATE_SECURITY_OFF* = 0x00000010 + DNS_UPDATE_SECURITY_ON* = 0x00000020 + DNS_UPDATE_SECURITY_ONLY* = 0x00000100 + DNS_UPDATE_CACHE_SECURITY_CONTEXT* = 0x00000200 + DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT* = 0x00000400 + DNS_UPDATE_FORCE_SECURITY_NEGO* = 0x00000800 + DNS_UPDATE_TRY_ALL_MASTER_SERVERS* = 0x00001000 + DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS* = 0x00002000 + DNS_UPDATE_REMOTE_SERVER* = 0x00004000 + DNS_UPDATE_RESERVED* = 0xffff0000'i32 + dnsNameDomain* = 0 + dnsNameDomainLabel* = 1 + dnsNameHostnameFull* = 2 + dnsNameHostnameLabel* = 3 + dnsNameWildcard* = 4 + dnsNameSrvRecord* = 5 + DNS_OFFSET_TO_QUESTION_NAME* = 12 +proc DnsQueryConfig*(Config: DNS_CONFIG_TYPE, Flag: DWORD, pwsAdapterName: PWSTR, pReserved: PVOID, pBuffer: PVOID, pBufferLength: PDWORD): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordCopyEx*(pRecord: PDNS_RECORD, CharSetIn: DNS_CHARSET, CharSetOut: DNS_CHARSET): PDNS_RECORD {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordSetCopyEx*(pRecordSet: PDNS_RECORD, CharSetIn: DNS_CHARSET, CharSetOut: DNS_CHARSET): PDNS_RECORD {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordCompare*(pRecord1: PDNS_RECORD, pRecord2: PDNS_RECORD): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordSetCompare*(pRR1: PDNS_RECORD, pRR2: PDNS_RECORD, ppDiff1: ptr PDNS_RECORD, ppDiff2: ptr PDNS_RECORD): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordSetDetach*(pRecordList: PDNS_RECORD): PDNS_RECORD {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsFree*(pData: PVOID, FreeType: DNS_FREE_TYPE): VOID {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsRecordListFree*(pRecordList: PDNS_RECORD, FreeType: DNS_FREE_TYPE): VOID {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsQuery_A*(pszName: PCSTR, wType: WORD, Options: DWORD, aipServers: PIP4_ARRAY, ppQueryResults: ptr PDNS_RECORD, pReserved: ptr PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsQuery_UTF8*(pszName: PCSTR, wType: WORD, Options: DWORD, aipServers: PIP4_ARRAY, ppQueryResults: ptr PDNS_RECORDA, pReserved: ptr PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsQuery_W*(pszName: PCWSTR, wType: WORD, Options: DWORD, aipServers: PIP4_ARRAY, ppQueryResults: ptr PDNS_RECORD, pReserved: ptr PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsAcquireContextHandle_W*(CredentialFlags: DWORD, pCredentials: PVOID, pContextHandle: PHANDLE): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsAcquireContextHandle_A*(CredentialFlags: DWORD, pCredentials: PVOID, pContextHandle: PHANDLE): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsReleaseContextHandle*(hContext: HANDLE): VOID {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsModifyRecordsInSet_W*(pAddRecords: PDNS_RECORD, pDeleteRecords: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsModifyRecordsInSet_A*(pAddRecords: PDNS_RECORD, pDeleteRecords: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsModifyRecordsInSet_UTF8*(pAddRecords: PDNS_RECORDA, pDeleteRecords: PDNS_RECORDA, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsReplaceRecordSetW*(pNewSet: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsReplaceRecordSetA*(pNewSet: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsReplaceRecordSetUTF8*(pNewSet: PDNS_RECORDA, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsValidateName_UTF8*(pszName: LPCSTR, Format: DNS_NAME_FORMAT): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsValidateName_W*(pwszName: LPCWSTR, Format: DNS_NAME_FORMAT): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsValidateName_A*(pszName: LPCSTR, Format: DNS_NAME_FORMAT): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsNameCompare_A*(pName1: LPSTR, pName2: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsNameCompare_W*(pName1: LPWSTR, pName2: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsWriteQuestionToBuffer_W*(pDnsBuffer: PDNS_MESSAGE_BUFFER, pdwBufferSize: PDWORD, pszName: LPWSTR, wType: WORD, Xid: WORD, fRecursionDesired: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsWriteQuestionToBuffer_UTF8*(pDnsBuffer: PDNS_MESSAGE_BUFFER, pdwBufferSize: LPDWORD, pszName: LPSTR, wType: WORD, Xid: WORD, fRecursionDesired: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsExtractRecordsFromMessage_W*(pDnsBuffer: PDNS_MESSAGE_BUFFER, wMessageLength: WORD, ppRecord: ptr PDNS_RECORD): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +proc DnsExtractRecordsFromMessage_UTF8*(pDnsBuffer: PDNS_MESSAGE_BUFFER, wMessageLength: WORD, ppRecord: ptr PDNS_RECORDA): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc.} +when winimUnicode: + type + DNS_RECORD* = DNS_RECORDW + DNS_PTR_DATA* = DNS_PTR_DATAW + PDNS_PTR_DATA* = PDNS_PTR_DATAW + DNS_SOA_DATA* = DNS_SOA_DATAW + PDNS_SOA_DATA* = PDNS_SOA_DATAW + DNS_MINFO_DATA* = DNS_MINFO_DATAW + PDNS_MINFO_DATA* = PDNS_MINFO_DATAW + DNS_MX_DATA* = DNS_MX_DATAW + PDNS_MX_DATA* = PDNS_MX_DATAW + DNS_TXT_DATA* = DNS_TXT_DATAW + PDNS_TXT_DATA* = PDNS_TXT_DATAW + DNS_SIG_DATA* = DNS_SIG_DATAW + PDNS_SIG_DATA* = PDNS_SIG_DATAW + DNS_NXT_DATA* = DNS_NXT_DATAW + PDNS_NXT_DATA* = PDNS_NXT_DATAW + DNS_SRV_DATA* = DNS_SRV_DATAW + PDNS_SRV_DATA* = PDNS_SRV_DATAW + DNS_TKEY_DATA* = DNS_TKEY_DATAW + PDNS_TKEY_DATA* = PDNS_TKEY_DATAW + DNS_TSIG_DATA* = DNS_TSIG_DATAW + PDNS_TSIG_DATA* = PDNS_TSIG_DATAW + DNS_WINSR_DATA* = DNS_WINSR_DATAW + PDNS_WINSR_DATA* = PDNS_WINSR_DATAW + const + DNS_IP4_REVERSE_DOMAIN_STRING* = DNS_IP4_REVERSE_DOMAIN_STRING_W + DNS_IP6_REVERSE_DOMAIN_STRING* = DNS_IP6_REVERSE_DOMAIN_STRING_W + proc DnsQuery*(pszName: PCWSTR, wType: WORD, Options: DWORD, aipServers: PIP4_ARRAY, ppQueryResults: ptr PDNS_RECORD, pReserved: ptr PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsQuery_W".} + proc DnsAcquireContextHandle*(CredentialFlags: DWORD, pCredentials: PVOID, pContextHandle: PHANDLE): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsAcquireContextHandle_W".} + proc DnsModifyRecordsInSet*(pAddRecords: PDNS_RECORD, pDeleteRecords: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsModifyRecordsInSet_W".} + proc DnsReplaceRecordSet*(pNewSet: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsReplaceRecordSetW".} +when winimAnsi: + type + DNS_RECORD* = DNS_RECORDA + DNS_PTR_DATA* = DNS_PTR_DATAA + PDNS_PTR_DATA* = PDNS_PTR_DATAA + DNS_SOA_DATA* = DNS_SOA_DATAA + PDNS_SOA_DATA* = PDNS_SOA_DATAA + DNS_MINFO_DATA* = DNS_MINFO_DATAA + PDNS_MINFO_DATA* = PDNS_MINFO_DATAA + DNS_MX_DATA* = DNS_MX_DATAA + PDNS_MX_DATA* = PDNS_MX_DATAA + DNS_TXT_DATA* = DNS_TXT_DATAA + PDNS_TXT_DATA* = PDNS_TXT_DATAA + DNS_SIG_DATA* = DNS_SIG_DATAA + PDNS_SIG_DATA* = PDNS_SIG_DATAA + DNS_NXT_DATA* = DNS_NXT_DATAA + PDNS_NXT_DATA* = PDNS_NXT_DATAA + DNS_SRV_DATA* = DNS_SRV_DATAA + PDNS_SRV_DATA* = PDNS_SRV_DATAA + DNS_TKEY_DATA* = DNS_TKEY_DATAA + PDNS_TKEY_DATA* = PDNS_TKEY_DATAA + DNS_TSIG_DATA* = DNS_TSIG_DATAA + PDNS_TSIG_DATA* = PDNS_TSIG_DATAA + DNS_WINSR_DATA* = DNS_WINSR_DATAA + PDNS_WINSR_DATA* = PDNS_WINSR_DATAA + const + DNS_IP4_REVERSE_DOMAIN_STRING* = DNS_IP4_REVERSE_DOMAIN_STRING_A + DNS_IP6_REVERSE_DOMAIN_STRING* = DNS_IP6_REVERSE_DOMAIN_STRING_A + proc DnsQuery*(pszName: PCSTR, wType: WORD, Options: DWORD, aipServers: PIP4_ARRAY, ppQueryResults: ptr PDNS_RECORD, pReserved: ptr PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsQuery_A".} + proc DnsAcquireContextHandle*(CredentialFlags: DWORD, pCredentials: PVOID, pContextHandle: PHANDLE): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsAcquireContextHandle_A".} + proc DnsModifyRecordsInSet*(pAddRecords: PDNS_RECORD, pDeleteRecords: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsModifyRecordsInSet_A".} + proc DnsReplaceRecordSet*(pNewSet: PDNS_RECORD, Options: DWORD, hContext: HANDLE, pServerList: PIP4_ARRAY, pReserved: PVOID): DNS_STATUS {.winapi, stdcall, dynlib: "dnsapi", importc: "DnsReplaceRecordSetA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winefs.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winefs.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,60 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import wincrypt +#include +type + EFS_CERTIFICATE_BLOB* {.pure.} = object + dwCertEncodingType*: DWORD + cbData*: DWORD + pbData*: PBYTE + PEFS_CERTIFICATE_BLOB* = ptr EFS_CERTIFICATE_BLOB + EFS_HASH_BLOB* {.pure.} = object + cbData*: DWORD + pbData*: PBYTE + PEFS_HASH_BLOB* = ptr EFS_HASH_BLOB + EFS_RPC_BLOB* {.pure.} = object + cbData*: DWORD + pbData*: PBYTE + PEFS_RPC_BLOB* = ptr EFS_RPC_BLOB + EFS_KEY_INFO* {.pure.} = object + dwVersion*: DWORD + Entropy*: ULONG + Algorithm*: ALG_ID + KeyLength*: ULONG + PEFS_KEY_INFO* = ptr EFS_KEY_INFO + ENCRYPTION_CERTIFICATE* {.pure.} = object + cbTotalLength*: DWORD + pUserSid*: ptr SID + pCertBlob*: PEFS_CERTIFICATE_BLOB + PENCRYPTION_CERTIFICATE* = ptr ENCRYPTION_CERTIFICATE + ENCRYPTION_CERTIFICATE_HASH* {.pure.} = object + cbTotalLength*: DWORD + pUserSid*: ptr SID + pHash*: PEFS_HASH_BLOB + lpDisplayInformation*: LPWSTR + PENCRYPTION_CERTIFICATE_HASH* = ptr ENCRYPTION_CERTIFICATE_HASH + ENCRYPTION_CERTIFICATE_HASH_LIST* {.pure.} = object + nCert_Hash*: DWORD + pUsers*: ptr PENCRYPTION_CERTIFICATE_HASH + PENCRYPTION_CERTIFICATE_HASH_LIST* = ptr ENCRYPTION_CERTIFICATE_HASH_LIST + ENCRYPTION_CERTIFICATE_LIST* {.pure.} = object + nUsers*: DWORD + pUsers*: ptr PENCRYPTION_CERTIFICATE + PENCRYPTION_CERTIFICATE_LIST* = ptr ENCRYPTION_CERTIFICATE_LIST +const + MAX_SID_SIZE* = 256 +proc QueryUsersOnEncryptedFile*(lpFileName: LPCWSTR, pUsers: ptr PENCRYPTION_CERTIFICATE_HASH_LIST): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryRecoveryAgentsOnEncryptedFile*(lpFileName: LPCWSTR, pRecoveryAgents: ptr PENCRYPTION_CERTIFICATE_HASH_LIST): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RemoveUsersFromEncryptedFile*(lpFileName: LPCWSTR, pHashes: PENCRYPTION_CERTIFICATE_HASH_LIST): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AddUsersToEncryptedFile*(lpFileName: LPCWSTR, pUsers: PENCRYPTION_CERTIFICATE_LIST): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetUserFileEncryptionKey*(pEncryptionCertificate: PENCRYPTION_CERTIFICATE): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc FreeEncryptionCertificateHashList*(pHashes: PENCRYPTION_CERTIFICATE_HASH_LIST): VOID {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EncryptionDisable*(DirPath: LPCWSTR, Disable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DuplicateEncryptionInfoFile*(SrcFileName: LPCWSTR, DstFileName: LPCWSTR, dwCreationDistribution: DWORD, dwAttributes: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winerror.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winerror.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,3565 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import windef +#include +#include +#include +const + NO_ERROR* = 0 + ERROR_INVALID_FUNCTION* = 1 + ERROR_FILE_NOT_FOUND* = 2 + ERROR_PATH_NOT_FOUND* = 3 + ERROR_TOO_MANY_OPEN_FILES* = 4 + ERROR_ACCESS_DENIED* = 5 + ERROR_INVALID_HANDLE* = 6 + ERROR_ARENA_TRASHED* = 7 + ERROR_NOT_ENOUGH_MEMORY* = 8 + ERROR_INVALID_BLOCK* = 9 + ERROR_BAD_ENVIRONMENT* = 10 + ERROR_BAD_FORMAT* = 11 + ERROR_INVALID_ACCESS* = 12 + ERROR_INVALID_DATA* = 13 + ERROR_INVALID_DRIVE* = 15 + ERROR_CURRENT_DIRECTORY* = 16 + ERROR_NOT_SAME_DEVICE* = 17 + ERROR_NO_MORE_FILES* = 18 + ERROR_WRITE_PROTECT* = 19 + ERROR_BAD_UNIT* = 20 + ERROR_NOT_READY* = 21 + ERROR_BAD_COMMAND* = 22 + ERROR_CRC* = 23 + ERROR_BAD_LENGTH* = 24 + ERROR_SEEK* = 25 + ERROR_NOT_DOS_DISK* = 26 + ERROR_SECTOR_NOT_FOUND* = 27 + ERROR_OUT_OF_PAPER* = 28 + ERROR_WRITE_FAULT* = 29 + ERROR_READ_FAULT* = 30 + ERROR_GEN_FAILURE* = 31 + ERROR_SHARING_VIOLATION* = 32 + ERROR_LOCK_VIOLATION* = 33 + ERROR_WRONG_DISK* = 34 + ERROR_FCB_UNAVAILABLE* = 35 + ERROR_SHARING_BUFFER_EXCEEDED* = 36 + ERROR_NOT_SUPPORTED* = 50 + ERROR_FILE_EXISTS* = 80 + ERROR_DUP_FCB* = 81 + ERROR_CANNOT_MAKE* = 82 + ERROR_FAIL_I24* = 83 + ERROR_OUT_OF_STRUCTURES* = 84 + ERROR_ALREADY_ASSIGNED* = 85 + ERROR_INVALID_PASSWORD* = 86 + ERROR_INVALID_PARAMETER* = 87 + ERROR_NET_WRITE_FAULT* = 88 + ERROR_NO_PROC_SLOTS* = 89 + ERROR_NOT_FROZEN* = 90 + ERR_TSTOVFL* = 91 + ERR_TSTDUP* = 92 + ERROR_NO_ITEMS* = 93 + ERROR_INTERRUPT* = 95 + ERROR_TOO_MANY_SEMAPHORES* = 100 + ERROR_EXCL_SEM_ALREADY_OWNED* = 101 + ERROR_SEM_IS_SET* = 102 + ERROR_TOO_MANY_SEM_REQUESTS* = 103 + ERROR_INVALID_AT_INTERRUPT_TIME* = 104 + ERROR_SEM_OWNER_DIED* = 105 + ERROR_SEM_USER_LIMIT* = 106 + ERROR_DISK_CHANGE* = 107 + ERROR_DRIVE_LOCKED* = 108 + ERROR_BROKEN_PIPE* = 109 + ERROR_OPEN_FAILED* = 110 + ERROR_BUFFER_OVERFLOW* = 111 + ERROR_DISK_FULL* = 112 + ERROR_NO_MORE_SEARCH_HANDLES* = 113 + ERROR_INVALID_TARGET_HANDLE* = 114 + ERROR_PROTECTION_VIOLATION* = 115 + ERROR_VIOKBD_REQUEST* = 116 + ERROR_INVALID_CATEGORY* = 117 + ERROR_INVALID_VERIFY_SWITCH* = 118 + ERROR_BAD_DRIVER_LEVEL* = 119 + ERROR_CALL_NOT_IMPLEMENTED* = 120 + ERROR_SEM_TIMEOUT* = 121 + ERROR_INSUFFICIENT_BUFFER* = 122 + ERROR_INVALID_NAME* = 123 + ERROR_INVALID_LEVEL* = 124 + ERROR_NO_VOLUME_LABEL* = 125 + ERROR_MOD_NOT_FOUND* = 126 + ERROR_PROC_NOT_FOUND* = 127 + ERROR_WAIT_NO_CHILDREN* = 128 + ERROR_CHILD_NOT_COMPLETE* = 129 + ERROR_DIRECT_ACCESS_HANDLE* = 130 + ERROR_NEGATIVE_SEEK* = 131 + ERROR_SEEK_ON_DEVICE* = 132 + ERROR_IS_JOIN_TARGET* = 133 + ERROR_IS_JOINED* = 134 + ERROR_IS_SUBSTED* = 135 + ERROR_NOT_JOINED* = 136 + ERROR_NOT_SUBSTED* = 137 + ERROR_JOIN_TO_JOIN* = 138 + ERROR_SUBST_TO_SUBST* = 139 + ERROR_JOIN_TO_SUBST* = 140 + ERROR_SUBST_TO_JOIN* = 141 + ERROR_BUSY_DRIVE* = 142 + ERROR_SAME_DRIVE* = 143 + ERROR_DIR_NOT_ROOT* = 144 + ERROR_DIR_NOT_EMPTY* = 145 + ERROR_IS_SUBST_PATH* = 146 + ERROR_IS_JOIN_PATH* = 147 + ERROR_PATH_BUSY* = 148 + ERROR_IS_SUBST_TARGET* = 149 + ERROR_SYSTEM_TRACE* = 150 + ERROR_INVALID_EVENT_COUNT* = 151 + ERROR_TOO_MANY_MUXWAITERS* = 152 + ERROR_INVALID_LIST_FORMAT* = 153 + ERROR_LABEL_TOO_LONG* = 154 + ERROR_TOO_MANY_TCBS* = 155 + ERROR_SIGNAL_REFUSED* = 156 + ERROR_DISCARDED* = 157 + ERROR_NOT_LOCKED* = 158 + ERROR_BAD_THREADID_ADDR* = 159 + ERROR_BAD_ARGUMENTS* = 160 + ERROR_BAD_PATHNAME* = 161 + ERROR_SIGNAL_PENDING* = 162 + ERROR_UNCERTAIN_MEDIA* = 163 + ERROR_MAX_THRDS_REACHED* = 164 + ERROR_MONITORS_NOT_SUPPORTED* = 165 + ERROR_INVALID_SEGMENT_NUMBER* = 180 + ERROR_INVALID_CALLGATE* = 181 + ERROR_INVALID_ORDINAL* = 182 + ERROR_ALREADY_EXISTS* = 183 + ERROR_NO_CHILD_PROCESS* = 184 + ERROR_CHILD_ALIVE_NOWAIT* = 185 + ERROR_INVALID_FLAG_NUMBER* = 186 + ERROR_SEM_NOT_FOUND* = 187 + ERROR_INVALID_STARTING_CODESEG* = 188 + ERROR_INVALID_STACKSEG* = 189 + ERROR_INVALID_MODULETYPE* = 190 + ERROR_INVALID_EXE_SIGNATURE* = 191 + ERROR_EXE_MARKED_INVALID* = 192 + ERROR_BAD_EXE_FORMAT* = 193 + ERROR_ITERATED_DATA_EXCEEDS_64k* = 194 + ERROR_INVALID_MINALLOCSIZE* = 195 + ERROR_DYNLINK_FROM_INVALID_RING* = 196 + ERROR_IOPL_NOT_ENABLED* = 197 + ERROR_INVALID_SEGDPL* = 198 + ERROR_AUTODATASEG_EXCEEDS_64k* = 199 + ERROR_RING2SEG_MUST_BE_MOVABLE* = 200 + ERROR_RELOC_CHAIN_XEEDS_SEGLIM* = 201 + ERROR_INFLOOP_IN_RELOC_CHAIN* = 202 + ERROR_ENVVAR_NOT_FOUND* = 203 + ERROR_NOT_CURRENT_CTRY* = 204 + ERROR_NO_SIGNAL_SENT* = 205 + ERROR_FILENAME_EXCED_RANGE* = 206 + ERROR_RING2_STACK_IN_USE* = 207 + ERROR_META_EXPANSION_TOO_LONG* = 208 + ERROR_INVALID_SIGNAL_NUMBER* = 209 + ERROR_THREAD_1_INACTIVE* = 210 + ERROR_INFO_NOT_AVAIL* = 211 + ERROR_LOCKED* = 212 + ERROR_BAD_DYNALINK* = 213 + ERROR_TOO_MANY_MODULES* = 214 + ERROR_NESTING_NOT_ALLOWED* = 215 + ERROR_USER_DEFINED_BASE* = 0xF000 + ERROR_I24_WRITE_PROTECT* = 0 + ERROR_I24_BAD_UNIT* = 1 + ERROR_I24_NOT_READY* = 2 + ERROR_I24_BAD_COMMAND* = 3 + ERROR_I24_CRC* = 4 + ERROR_I24_BAD_LENGTH* = 5 + ERROR_I24_SEEK* = 6 + ERROR_I24_NOT_DOS_DISK* = 7 + ERROR_I24_SECTOR_NOT_FOUND* = 8 + ERROR_I24_OUT_OF_PAPER* = 9 + ERROR_I24_WRITE_FAULT* = 0x0A + ERROR_I24_READ_FAULT* = 0x0B + ERROR_I24_GEN_FAILURE* = 0x0C + ERROR_I24_DISK_CHANGE* = 0x0D + ERROR_I24_WRONG_DISK* = 0x0F + ERROR_I24_UNCERTAIN_MEDIA* = 0x10 + ERROR_I24_CHAR_CALL_INTERRUPTED* = 0x11 + ERROR_I24_NO_MONITOR_SUPPORT* = 0x12 + ERROR_I24_INVALID_PARAMETER* = 0x13 + ALLOWED_FAIL* = 0x0001 + ALLOWED_ABORT* = 0x0002 + ALLOWED_RETRY* = 0x0004 + ALLOWED_IGNORE* = 0x0008 + I24_OPERATION* = 0x1 + I24_AREA* = 0x6 + I24_CLASS* = 0x80 + ERRCLASS_OUTRES* = 1 + ERRCLASS_TEMPSIT* = 2 + ERRCLASS_AUTH* = 3 + ERRCLASS_INTRN* = 4 + ERRCLASS_HRDFAIL* = 5 + ERRCLASS_SYSFAIL* = 6 + ERRCLASS_APPERR* = 7 + ERRCLASS_NOTFND* = 8 + ERRCLASS_BADFMT* = 9 + ERRCLASS_LOCKED* = 10 + ERRCLASS_MEDIA* = 11 + ERRCLASS_ALREADY* = 12 + ERRCLASS_UNK* = 13 + ERRCLASS_CANT* = 14 + ERRCLASS_TIME* = 15 + ERRACT_RETRY* = 1 + ERRACT_DLYRET* = 2 + ERRACT_USER* = 3 + ERRACT_ABORT* = 4 + ERRACT_PANIC* = 5 + ERRACT_IGNORE* = 6 + ERRACT_INTRET* = 7 + ERRLOC_UNK* = 1 + ERRLOC_DISK* = 2 + ERRLOC_NET* = 3 + ERRLOC_SERDEV* = 4 + ERRLOC_MEM* = 5 + TC_NORMAL* = 0 + TC_HARDERR* = 1 + TC_GP_TRAP* = 2 + TC_SIGNAL* = 3 + IN_WINERROR* = 1 + FACILITY_WINDOWSUPDATE* = 36 + FACILITY_WINDOWS_CE* = 24 + FACILITY_WINDOWS* = 8 + FACILITY_URT* = 19 + FACILITY_UMI* = 22 + FACILITY_SXS* = 23 + FACILITY_STORAGE* = 3 + FACILITY_STATE_MANAGEMENT* = 34 + FACILITY_SSPI* = 9 + FACILITY_SCARD* = 16 + FACILITY_SETUPAPI* = 15 + FACILITY_SECURITY* = 9 + FACILITY_RPC* = 1 + FACILITY_WIN32* = 7 + FACILITY_CONTROL* = 10 + FACILITY_NULL* = 0 + FACILITY_METADIRECTORY* = 35 + FACILITY_MSMQ* = 14 + FACILITY_MEDIASERVER* = 13 + FACILITY_INTERNET* = 12 + FACILITY_ITF* = 4 + FACILITY_HTTP* = 25 + FACILITY_DPLAY* = 21 + FACILITY_DISPATCH* = 2 + FACILITY_DIRECTORYSERVICE* = 37 + FACILITY_CONFIGURATION* = 33 + FACILITY_COMPLUS* = 17 + FACILITY_CERT* = 11 + FACILITY_BACKGROUNDCOPY* = 32 + FACILITY_ACS* = 20 + FACILITY_AAF* = 18 + FACILITY_AUDCLNT* = 2185 + ERROR_SUCCESS* = 0 + SEC_E_OK* = HRESULT 0x00000000 + ERROR_OUTOFMEMORY* = 14 + ERROR_HANDLE_EOF* = 38 + ERROR_HANDLE_DISK_FULL* = 39 + ERROR_REM_NOT_LIST* = 51 + ERROR_DUP_NAME* = 52 + ERROR_BAD_NETPATH* = 53 + ERROR_NETWORK_BUSY* = 54 + ERROR_DEV_NOT_EXIST* = 55 + ERROR_TOO_MANY_CMDS* = 56 + ERROR_ADAP_HDW_ERR* = 57 + ERROR_BAD_NET_RESP* = 58 + ERROR_UNEXP_NET_ERR* = 59 + ERROR_BAD_REM_ADAP* = 60 + ERROR_PRINTQ_FULL* = 61 + ERROR_NO_SPOOL_SPACE* = 62 + ERROR_PRINT_CANCELLED* = 63 + ERROR_NETNAME_DELETED* = 64 + ERROR_NETWORK_ACCESS_DENIED* = 65 + ERROR_BAD_DEV_TYPE* = 66 + ERROR_BAD_NET_NAME* = 67 + ERROR_TOO_MANY_NAMES* = 68 + ERROR_TOO_MANY_SESS* = 69 + ERROR_SHARING_PAUSED* = 70 + ERROR_REQ_NOT_ACCEP* = 71 + ERROR_REDIR_PAUSED* = 72 + ERROR_LOCK_FAILED* = 167 + ERROR_BUSY* = 170 + ERROR_CANCEL_VIOLATION* = 173 + ERROR_ATOMIC_LOCKS_NOT_SUPPORTED* = 174 + ERROR_EXE_MACHINE_TYPE_MISMATCH* = 216 + ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY* = 217 + ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY* = 218 + ERROR_FILE_CHECKED_OUT* = 220 + ERROR_CHECKOUT_REQUIRED* = 221 + ERROR_BAD_FILE_TYPE* = 222 + ERROR_FILE_TOO_LARGE* = 223 + ERROR_FORMS_AUTH_REQUIRED* = 224 + ERROR_PIPE_LOCAL* = 229 + ERROR_BAD_PIPE* = 230 + ERROR_PIPE_BUSY* = 231 + ERROR_NO_DATA* = 232 + ERROR_PIPE_NOT_CONNECTED* = 233 + ERROR_MORE_DATA* = 234 + ERROR_VC_DISCONNECTED* = 240 + ERROR_INVALID_EA_NAME* = 254 + ERROR_EA_LIST_INCONSISTENT* = 255 + WAIT_TIMEOUT* = 258 + ERROR_NO_MORE_ITEMS* = 259 + ERROR_CANNOT_COPY* = 266 + ERROR_DIRECTORY* = 267 + ERROR_EAS_DIDNT_FIT* = 275 + ERROR_EA_FILE_CORRUPT* = 276 + ERROR_EA_TABLE_FULL* = 277 + ERROR_INVALID_EA_HANDLE* = 278 + ERROR_EAS_NOT_SUPPORTED* = 282 + ERROR_NOT_OWNER* = 288 + ERROR_TOO_MANY_POSTS* = 298 + ERROR_PARTIAL_COPY* = 299 + ERROR_OPLOCK_NOT_GRANTED* = 300 + ERROR_INVALID_OPLOCK_PROTOCOL* = 301 + ERROR_DISK_TOO_FRAGMENTED* = 302 + ERROR_DELETE_PENDING* = 303 + ERROR_MR_MID_NOT_FOUND* = 317 + ERROR_SCOPE_NOT_FOUND* = 318 + ERROR_INVALID_ADDRESS* = 487 + ERROR_ARITHMETIC_OVERFLOW* = 534 + ERROR_PIPE_CONNECTED* = 535 + ERROR_PIPE_LISTENING* = 536 + ERROR_WAKE_SYSTEM* = 730 + ERROR_WAIT_1* = 731 + ERROR_WAIT_2* = 732 + ERROR_WAIT_3* = 733 + ERROR_WAIT_63* = 734 + ERROR_ABANDONED_WAIT_0* = 735 + ERROR_ABANDONED_WAIT_63* = 736 + ERROR_USER_APC* = 737 + ERROR_KERNEL_APC* = 738 + ERROR_ALERTED* = 739 + ERROR_EA_ACCESS_DENIED* = 994 + ERROR_OPERATION_ABORTED* = 995 + ERROR_IO_INCOMPLETE* = 996 + ERROR_IO_PENDING* = 997 + ERROR_NOACCESS* = 998 + ERROR_SWAPERROR* = 999 + ERROR_STACK_OVERFLOW* = 1001 + ERROR_INVALID_MESSAGE* = 1002 + ERROR_CAN_NOT_COMPLETE* = 1003 + ERROR_INVALID_FLAGS* = 1004 + ERROR_UNRECOGNIZED_VOLUME* = 1005 + ERROR_FILE_INVALID* = 1006 + ERROR_FULLSCREEN_MODE* = 1007 + ERROR_NO_TOKEN* = 1008 + ERROR_BADDB* = 1009 + ERROR_BADKEY* = 1010 + ERROR_CANTOPEN* = 1011 + ERROR_CANTREAD* = 1012 + ERROR_CANTWRITE* = 1013 + ERROR_REGISTRY_RECOVERED* = 1014 + ERROR_REGISTRY_CORRUPT* = 1015 + ERROR_REGISTRY_IO_FAILED* = 1016 + ERROR_NOT_REGISTRY_FILE* = 1017 + ERROR_KEY_DELETED* = 1018 + ERROR_NO_LOG_SPACE* = 1019 + ERROR_KEY_HAS_CHILDREN* = 1020 + ERROR_CHILD_MUST_BE_VOLATILE* = 1021 + ERROR_NOTIFY_ENUM_DIR* = 1022 + ERROR_DEPENDENT_SERVICES_RUNNING* = 1051 + ERROR_INVALID_SERVICE_CONTROL* = 1052 + ERROR_SERVICE_REQUEST_TIMEOUT* = 1053 + ERROR_SERVICE_NO_THREAD* = 1054 + ERROR_SERVICE_DATABASE_LOCKED* = 1055 + ERROR_SERVICE_ALREADY_RUNNING* = 1056 + ERROR_INVALID_SERVICE_ACCOUNT* = 1057 + ERROR_SERVICE_DISABLED* = 1058 + ERROR_CIRCULAR_DEPENDENCY* = 1059 + ERROR_SERVICE_DOES_NOT_EXIST* = 1060 + ERROR_SERVICE_CANNOT_ACCEPT_CTRL* = 1061 + ERROR_SERVICE_NOT_ACTIVE* = 1062 + ERROR_FAILED_SERVICE_CONTROLLER_CONNECT* = 1063 + ERROR_EXCEPTION_IN_SERVICE* = 1064 + ERROR_DATABASE_DOES_NOT_EXIST* = 1065 + ERROR_SERVICE_SPECIFIC_ERROR* = 1066 + ERROR_PROCESS_ABORTED* = 1067 + ERROR_SERVICE_DEPENDENCY_FAIL* = 1068 + ERROR_SERVICE_LOGON_FAILED* = 1069 + ERROR_SERVICE_START_HANG* = 1070 + ERROR_INVALID_SERVICE_LOCK* = 1071 + ERROR_SERVICE_MARKED_FOR_DELETE* = 1072 + ERROR_SERVICE_EXISTS* = 1073 + ERROR_ALREADY_RUNNING_LKG* = 1074 + ERROR_SERVICE_DEPENDENCY_DELETED* = 1075 + ERROR_BOOT_ALREADY_ACCEPTED* = 1076 + ERROR_SERVICE_NEVER_STARTED* = 1077 + ERROR_DUPLICATE_SERVICE_NAME* = 1078 + ERROR_DIFFERENT_SERVICE_ACCOUNT* = 1079 + ERROR_CANNOT_DETECT_DRIVER_FAILURE* = 1080 + ERROR_CANNOT_DETECT_PROCESS_ABORT* = 1081 + ERROR_NO_RECOVERY_PROGRAM* = 1082 + ERROR_SERVICE_NOT_IN_EXE* = 1083 + ERROR_NOT_SAFEBOOT_SERVICE* = 1084 + ERROR_END_OF_MEDIA* = 1100 + ERROR_FILEMARK_DETECTED* = 1101 + ERROR_BEGINNING_OF_MEDIA* = 1102 + ERROR_SETMARK_DETECTED* = 1103 + ERROR_NO_DATA_DETECTED* = 1104 + ERROR_PARTITION_FAILURE* = 1105 + ERROR_INVALID_BLOCK_LENGTH* = 1106 + ERROR_DEVICE_NOT_PARTITIONED* = 1107 + ERROR_UNABLE_TO_LOCK_MEDIA* = 1108 + ERROR_UNABLE_TO_UNLOAD_MEDIA* = 1109 + ERROR_MEDIA_CHANGED* = 1110 + ERROR_BUS_RESET* = 1111 + ERROR_NO_MEDIA_IN_DRIVE* = 1112 + ERROR_NO_UNICODE_TRANSLATION* = 1113 + ERROR_DLL_INIT_FAILED* = 1114 + ERROR_SHUTDOWN_IN_PROGRESS* = 1115 + ERROR_NO_SHUTDOWN_IN_PROGRESS* = 1116 + ERROR_IO_DEVICE* = 1117 + ERROR_SERIAL_NO_DEVICE* = 1118 + ERROR_IRQ_BUSY* = 1119 + ERROR_MORE_WRITES* = 1120 + ERROR_COUNTER_TIMEOUT* = 1121 + ERROR_FLOPPY_ID_MARK_NOT_FOUND* = 1122 + ERROR_FLOPPY_WRONG_CYLINDER* = 1123 + ERROR_FLOPPY_UNKNOWN_ERROR* = 1124 + ERROR_FLOPPY_BAD_REGISTERS* = 1125 + ERROR_DISK_RECALIBRATE_FAILED* = 1126 + ERROR_DISK_OPERATION_FAILED* = 1127 + ERROR_DISK_RESET_FAILED* = 1128 + ERROR_EOM_OVERFLOW* = 1129 + ERROR_NOT_ENOUGH_SERVER_MEMORY* = 1130 + ERROR_POSSIBLE_DEADLOCK* = 1131 + ERROR_MAPPED_ALIGNMENT* = 1132 + ERROR_SET_POWER_STATE_VETOED* = 1140 + ERROR_SET_POWER_STATE_FAILED* = 1141 + ERROR_TOO_MANY_LINKS* = 1142 + ERROR_OLD_WIN_VERSION* = 1150 + ERROR_APP_WRONG_OS* = 1151 + ERROR_SINGLE_INSTANCE_APP* = 1152 + ERROR_RMODE_APP* = 1153 + ERROR_INVALID_DLL* = 1154 + ERROR_NO_ASSOCIATION* = 1155 + ERROR_DDE_FAIL* = 1156 + ERROR_DLL_NOT_FOUND* = 1157 + ERROR_NO_MORE_USER_HANDLES* = 1158 + ERROR_MESSAGE_SYNC_ONLY* = 1159 + ERROR_SOURCE_ELEMENT_EMPTY* = 1160 + ERROR_DESTINATION_ELEMENT_FULL* = 1161 + ERROR_ILLEGAL_ELEMENT_ADDRESS* = 1162 + ERROR_MAGAZINE_NOT_PRESENT* = 1163 + ERROR_DEVICE_REINITIALIZATION_NEEDED* = 1164 + ERROR_DEVICE_REQUIRES_CLEANING* = 1165 + ERROR_DEVICE_DOOR_OPEN* = 1166 + ERROR_DEVICE_NOT_CONNECTED* = 1167 + ERROR_NOT_FOUND* = 1168 + ERROR_NO_MATCH* = 1169 + ERROR_SET_NOT_FOUND* = 1170 + ERROR_POINT_NOT_FOUND* = 1171 + ERROR_NO_TRACKING_SERVICE* = 1172 + ERROR_NO_VOLUME_ID* = 1173 + ERROR_UNABLE_TO_REMOVE_REPLACED* = 1175 + ERROR_UNABLE_TO_MOVE_REPLACEMENT* = 1176 + ERROR_UNABLE_TO_MOVE_REPLACEMENT_2* = 1177 + ERROR_JOURNAL_DELETE_IN_PROGRESS* = 1178 + ERROR_JOURNAL_NOT_ACTIVE* = 1179 + ERROR_POTENTIAL_FILE_FOUND* = 1180 + ERROR_JOURNAL_ENTRY_DELETED* = 1181 + ERROR_BAD_DEVICE* = 1200 + ERROR_CONNECTION_UNAVAIL* = 1201 + ERROR_DEVICE_ALREADY_REMEMBERED* = 1202 + ERROR_NO_NET_OR_BAD_PATH* = 1203 + ERROR_BAD_PROVIDER* = 1204 + ERROR_CANNOT_OPEN_PROFILE* = 1205 + ERROR_BAD_PROFILE* = 1206 + ERROR_NOT_CONTAINER* = 1207 + ERROR_EXTENDED_ERROR* = 1208 + ERROR_INVALID_GROUPNAME* = 1209 + ERROR_INVALID_COMPUTERNAME* = 1210 + ERROR_INVALID_EVENTNAME* = 1211 + ERROR_INVALID_DOMAINNAME* = 1212 + ERROR_INVALID_SERVICENAME* = 1213 + ERROR_INVALID_NETNAME* = 1214 + ERROR_INVALID_SHARENAME* = 1215 + ERROR_INVALID_PASSWORDNAME* = 1216 + ERROR_INVALID_MESSAGENAME* = 1217 + ERROR_INVALID_MESSAGEDEST* = 1218 + ERROR_SESSION_CREDENTIAL_CONFLICT* = 1219 + ERROR_REMOTE_SESSION_LIMIT_EXCEEDED* = 1220 + ERROR_DUP_DOMAINNAME* = 1221 + ERROR_NO_NETWORK* = 1222 + ERROR_CANCELLED* = 1223 + ERROR_USER_MAPPED_FILE* = 1224 + ERROR_CONNECTION_REFUSED* = 1225 + ERROR_GRACEFUL_DISCONNECT* = 1226 + ERROR_ADDRESS_ALREADY_ASSOCIATED* = 1227 + ERROR_ADDRESS_NOT_ASSOCIATED* = 1228 + ERROR_CONNECTION_INVALID* = 1229 + ERROR_CONNECTION_ACTIVE* = 1230 + ERROR_NETWORK_UNREACHABLE* = 1231 + ERROR_HOST_UNREACHABLE* = 1232 + ERROR_PROTOCOL_UNREACHABLE* = 1233 + ERROR_PORT_UNREACHABLE* = 1234 + ERROR_REQUEST_ABORTED* = 1235 + ERROR_CONNECTION_ABORTED* = 1236 + ERROR_RETRY* = 1237 + ERROR_CONNECTION_COUNT_LIMIT* = 1238 + ERROR_LOGIN_TIME_RESTRICTION* = 1239 + ERROR_LOGIN_WKSTA_RESTRICTION* = 1240 + ERROR_INCORRECT_ADDRESS* = 1241 + ERROR_ALREADY_REGISTERED* = 1242 + ERROR_SERVICE_NOT_FOUND* = 1243 + ERROR_NOT_AUTHENTICATED* = 1244 + ERROR_NOT_LOGGED_ON* = 1245 + ERROR_CONTINUE* = 1246 + ERROR_ALREADY_INITIALIZED* = 1247 + ERROR_NO_MORE_DEVICES* = 1248 + ERROR_NO_SUCH_SITE* = 1249 + ERROR_DOMAIN_CONTROLLER_EXISTS* = 1250 + ERROR_ONLY_IF_CONNECTED* = 1251 + ERROR_OVERRIDE_NOCHANGES* = 1252 + ERROR_BAD_USER_PROFILE* = 1253 + ERROR_NOT_SUPPORTED_ON_SBS* = 1254 + ERROR_SERVER_SHUTDOWN_IN_PROGRESS* = 1255 + ERROR_HOST_DOWN* = 1256 + ERROR_NON_ACCOUNT_SID* = 1257 + ERROR_NON_DOMAIN_SID* = 1258 + ERROR_APPHELP_BLOCK* = 1259 + ERROR_ACCESS_DISABLED_BY_POLICY* = 1260 + ERROR_REG_NAT_CONSUMPTION* = 1261 + ERROR_CSCSHARE_OFFLINE* = 1262 + ERROR_PKINIT_FAILURE* = 1263 + ERROR_SMARTCARD_SUBSYSTEM_FAILURE* = 1264 + ERROR_DOWNGRADE_DETECTED* = 1265 + ERROR_MACHINE_LOCKED* = 1271 + ERROR_CALLBACK_SUPPLIED_INVALID_DATA* = 1273 + ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED* = 1274 + ERROR_DRIVER_BLOCKED* = 1275 + ERROR_INVALID_IMPORT_OF_NON_DLL* = 1276 + ERROR_ACCESS_DISABLED_WEBBLADE* = 1277 + ERROR_ACCESS_DISABLED_WEBBLADE_TAMPER* = 1278 + ERROR_RECOVERY_FAILURE* = 1279 + ERROR_ALREADY_FIBER* = 1280 + ERROR_ALREADY_THREAD* = 1281 + ERROR_STACK_BUFFER_OVERRUN* = 1282 + ERROR_PARAMETER_QUOTA_EXCEEDED* = 1283 + ERROR_DEBUGGER_INACTIVE* = 1284 + ERROR_DELAY_LOAD_FAILED* = 1285 + ERROR_VDM_DISALLOWED* = 1286 + ERROR_UNIDENTIFIED_ERROR* = 1287 + ERROR_NOT_ALL_ASSIGNED* = 1300 + ERROR_SOME_NOT_MAPPED* = 1301 + ERROR_NO_QUOTAS_FOR_ACCOUNT* = 1302 + ERROR_LOCAL_USER_SESSION_KEY* = 1303 + ERROR_NULL_LM_PASSWORD* = 1304 + ERROR_UNKNOWN_REVISION* = 1305 + ERROR_REVISION_MISMATCH* = 1306 + ERROR_INVALID_OWNER* = 1307 + ERROR_INVALID_PRIMARY_GROUP* = 1308 + ERROR_NO_IMPERSONATION_TOKEN* = 1309 + ERROR_CANT_DISABLE_MANDATORY* = 1310 + ERROR_NO_LOGON_SERVERS* = 1311 + ERROR_NO_SUCH_LOGON_SESSION* = 1312 + ERROR_NO_SUCH_PRIVILEGE* = 1313 + ERROR_PRIVILEGE_NOT_HELD* = 1314 + ERROR_INVALID_ACCOUNT_NAME* = 1315 + ERROR_USER_EXISTS* = 1316 + ERROR_NO_SUCH_USER* = 1317 + ERROR_GROUP_EXISTS* = 1318 + ERROR_NO_SUCH_GROUP* = 1319 + ERROR_MEMBER_IN_GROUP* = 1320 + ERROR_MEMBER_NOT_IN_GROUP* = 1321 + ERROR_LAST_ADMIN* = 1322 + ERROR_WRONG_PASSWORD* = 1323 + ERROR_ILL_FORMED_PASSWORD* = 1324 + ERROR_PASSWORD_RESTRICTION* = 1325 + ERROR_LOGON_FAILURE* = 1326 + ERROR_ACCOUNT_RESTRICTION* = 1327 + ERROR_INVALID_LOGON_HOURS* = 1328 + ERROR_INVALID_WORKSTATION* = 1329 + ERROR_PASSWORD_EXPIRED* = 1330 + ERROR_ACCOUNT_DISABLED* = 1331 + ERROR_NONE_MAPPED* = 1332 + ERROR_TOO_MANY_LUIDS_REQUESTED* = 1333 + ERROR_LUIDS_EXHAUSTED* = 1334 + ERROR_INVALID_SUB_AUTHORITY* = 1335 + ERROR_INVALID_ACL* = 1336 + ERROR_INVALID_SID* = 1337 + ERROR_INVALID_SECURITY_DESCR* = 1338 + ERROR_BAD_INHERITANCE_ACL* = 1340 + ERROR_SERVER_DISABLED* = 1341 + ERROR_SERVER_NOT_DISABLED* = 1342 + ERROR_INVALID_ID_AUTHORITY* = 1343 + ERROR_ALLOTTED_SPACE_EXCEEDED* = 1344 + ERROR_INVALID_GROUP_ATTRIBUTES* = 1345 + ERROR_BAD_IMPERSONATION_LEVEL* = 1346 + ERROR_CANT_OPEN_ANONYMOUS* = 1347 + ERROR_BAD_VALIDATION_CLASS* = 1348 + ERROR_BAD_TOKEN_TYPE* = 1349 + ERROR_NO_SECURITY_ON_OBJECT* = 1350 + ERROR_CANT_ACCESS_DOMAIN_INFO* = 1351 + ERROR_INVALID_SERVER_STATE* = 1352 + ERROR_INVALID_DOMAIN_STATE* = 1353 + ERROR_INVALID_DOMAIN_ROLE* = 1354 + ERROR_NO_SUCH_DOMAIN* = 1355 + ERROR_DOMAIN_EXISTS* = 1356 + ERROR_DOMAIN_LIMIT_EXCEEDED* = 1357 + ERROR_INTERNAL_DB_CORRUPTION* = 1358 + ERROR_INTERNAL_ERROR* = 1359 + ERROR_GENERIC_NOT_MAPPED* = 1360 + ERROR_BAD_DESCRIPTOR_FORMAT* = 1361 + ERROR_NOT_LOGON_PROCESS* = 1362 + ERROR_LOGON_SESSION_EXISTS* = 1363 + ERROR_NO_SUCH_PACKAGE* = 1364 + ERROR_BAD_LOGON_SESSION_STATE* = 1365 + ERROR_LOGON_SESSION_COLLISION* = 1366 + ERROR_INVALID_LOGON_TYPE* = 1367 + ERROR_CANNOT_IMPERSONATE* = 1368 + ERROR_RXACT_INVALID_STATE* = 1369 + ERROR_RXACT_COMMIT_FAILURE* = 1370 + ERROR_SPECIAL_ACCOUNT* = 1371 + ERROR_SPECIAL_GROUP* = 1372 + ERROR_SPECIAL_USER* = 1373 + ERROR_MEMBERS_PRIMARY_GROUP* = 1374 + ERROR_TOKEN_ALREADY_IN_USE* = 1375 + ERROR_NO_SUCH_ALIAS* = 1376 + ERROR_MEMBER_NOT_IN_ALIAS* = 1377 + ERROR_MEMBER_IN_ALIAS* = 1378 + ERROR_ALIAS_EXISTS* = 1379 + ERROR_LOGON_NOT_GRANTED* = 1380 + ERROR_TOO_MANY_SECRETS* = 1381 + ERROR_SECRET_TOO_LONG* = 1382 + ERROR_INTERNAL_DB_ERROR* = 1383 + ERROR_TOO_MANY_CONTEXT_IDS* = 1384 + ERROR_LOGON_TYPE_NOT_GRANTED* = 1385 + ERROR_NT_CROSS_ENCRYPTION_REQUIRED* = 1386 + ERROR_NO_SUCH_MEMBER* = 1387 + ERROR_INVALID_MEMBER* = 1388 + ERROR_TOO_MANY_SIDS* = 1389 + ERROR_LM_CROSS_ENCRYPTION_REQUIRED* = 1390 + ERROR_NO_INHERITANCE* = 1391 + ERROR_FILE_CORRUPT* = 1392 + ERROR_DISK_CORRUPT* = 1393 + ERROR_NO_USER_SESSION_KEY* = 1394 + ERROR_LICENSE_QUOTA_EXCEEDED* = 1395 + ERROR_WRONG_TARGET_NAME* = 1396 + ERROR_MUTUAL_AUTH_FAILED* = 1397 + ERROR_TIME_SKEW* = 1398 + ERROR_CURRENT_DOMAIN_NOT_ALLOWED* = 1399 + ERROR_INVALID_WINDOW_HANDLE* = 1400 + ERROR_INVALID_MENU_HANDLE* = 1401 + ERROR_INVALID_CURSOR_HANDLE* = 1402 + ERROR_INVALID_ACCEL_HANDLE* = 1403 + ERROR_INVALID_HOOK_HANDLE* = 1404 + ERROR_INVALID_DWP_HANDLE* = 1405 + ERROR_TLW_WITH_WSCHILD* = 1406 + ERROR_CANNOT_FIND_WND_CLASS* = 1407 + ERROR_WINDOW_OF_OTHER_THREAD* = 1408 + ERROR_HOTKEY_ALREADY_REGISTERED* = 1409 + ERROR_CLASS_ALREADY_EXISTS* = 1410 + ERROR_CLASS_DOES_NOT_EXIST* = 1411 + ERROR_CLASS_HAS_WINDOWS* = 1412 + ERROR_INVALID_INDEX* = 1413 + ERROR_INVALID_ICON_HANDLE* = 1414 + ERROR_PRIVATE_DIALOG_INDEX* = 1415 + ERROR_LISTBOX_ID_NOT_FOUND* = 1416 + ERROR_NO_WILDCARD_CHARACTERS* = 1417 + ERROR_CLIPBOARD_NOT_OPEN* = 1418 + ERROR_HOTKEY_NOT_REGISTERED* = 1419 + ERROR_WINDOW_NOT_DIALOG* = 1420 + ERROR_CONTROL_ID_NOT_FOUND* = 1421 + ERROR_INVALID_COMBOBOX_MESSAGE* = 1422 + ERROR_WINDOW_NOT_COMBOBOX* = 1423 + ERROR_INVALID_EDIT_HEIGHT* = 1424 + ERROR_DC_NOT_FOUND* = 1425 + ERROR_INVALID_HOOK_FILTER* = 1426 + ERROR_INVALID_FILTER_PROC* = 1427 + ERROR_HOOK_NEEDS_HMOD* = 1428 + ERROR_GLOBAL_ONLY_HOOK* = 1429 + ERROR_JOURNAL_HOOK_SET* = 1430 + ERROR_HOOK_NOT_INSTALLED* = 1431 + ERROR_INVALID_LB_MESSAGE* = 1432 + ERROR_SETCOUNT_ON_BAD_LB* = 1433 + ERROR_LB_WITHOUT_TABSTOPS* = 1434 + ERROR_DESTROY_OBJECT_OF_OTHER_THREAD* = 1435 + ERROR_CHILD_WINDOW_MENU* = 1436 + ERROR_NO_SYSTEM_MENU* = 1437 + ERROR_INVALID_MSGBOX_STYLE* = 1438 + ERROR_INVALID_SPI_VALUE* = 1439 + ERROR_SCREEN_ALREADY_LOCKED* = 1440 + ERROR_HWNDS_HAVE_DIFF_PARENT* = 1441 + ERROR_NOT_CHILD_WINDOW* = 1442 + ERROR_INVALID_GW_COMMAND* = 1443 + ERROR_INVALID_THREAD_ID* = 1444 + ERROR_NON_MDICHILD_WINDOW* = 1445 + ERROR_POPUP_ALREADY_ACTIVE* = 1446 + ERROR_NO_SCROLLBARS* = 1447 + ERROR_INVALID_SCROLLBAR_RANGE* = 1448 + ERROR_INVALID_SHOWWIN_COMMAND* = 1449 + ERROR_NO_SYSTEM_RESOURCES* = 1450 + ERROR_NONPAGED_SYSTEM_RESOURCES* = 1451 + ERROR_PAGED_SYSTEM_RESOURCES* = 1452 + ERROR_WORKING_SET_QUOTA* = 1453 + ERROR_PAGEFILE_QUOTA* = 1454 + ERROR_COMMITMENT_LIMIT* = 1455 + ERROR_MENU_ITEM_NOT_FOUND* = 1456 + ERROR_INVALID_KEYBOARD_HANDLE* = 1457 + ERROR_HOOK_TYPE_NOT_ALLOWED* = 1458 + ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION* = 1459 + ERROR_TIMEOUT* = 1460 + ERROR_INVALID_MONITOR_HANDLE* = 1461 + ERROR_INCORRECT_SIZE* = 1462 + ERROR_EVENTLOG_FILE_CORRUPT* = 1500 + ERROR_EVENTLOG_CANT_START* = 1501 + ERROR_LOG_FILE_FULL* = 1502 + ERROR_EVENTLOG_FILE_CHANGED* = 1503 + ERROR_INSTALL_SERVICE_FAILURE* = 1601 + ERROR_INSTALL_USEREXIT* = 1602 + ERROR_INSTALL_FAILURE* = 1603 + ERROR_INSTALL_SUSPEND* = 1604 + ERROR_UNKNOWN_PRODUCT* = 1605 + ERROR_UNKNOWN_FEATURE* = 1606 + ERROR_UNKNOWN_COMPONENT* = 1607 + ERROR_UNKNOWN_PROPERTY* = 1608 + ERROR_INVALID_HANDLE_STATE* = 1609 + ERROR_BAD_CONFIGURATION* = 1610 + ERROR_INDEX_ABSENT* = 1611 + ERROR_INSTALL_SOURCE_ABSENT* = 1612 + ERROR_INSTALL_PACKAGE_VERSION* = 1613 + ERROR_PRODUCT_UNINSTALLED* = 1614 + ERROR_BAD_QUERY_SYNTAX* = 1615 + ERROR_INVALID_FIELD* = 1616 + ERROR_DEVICE_REMOVED* = 1617 + ERROR_INSTALL_ALREADY_RUNNING* = 1618 + ERROR_INSTALL_PACKAGE_OPEN_FAILED* = 1619 + ERROR_INSTALL_PACKAGE_INVALID* = 1620 + ERROR_INSTALL_UI_FAILURE* = 1621 + ERROR_INSTALL_LOG_FAILURE* = 1622 + ERROR_INSTALL_LANGUAGE_UNSUPPORTED* = 1623 + ERROR_INSTALL_TRANSFORM_FAILURE* = 1624 + ERROR_INSTALL_PACKAGE_REJECTED* = 1625 + ERROR_FUNCTION_NOT_CALLED* = 1626 + ERROR_FUNCTION_FAILED* = 1627 + ERROR_INVALID_TABLE* = 1628 + ERROR_DATATYPE_MISMATCH* = 1629 + ERROR_UNSUPPORTED_TYPE* = 1630 + ERROR_CREATE_FAILED* = 1631 + ERROR_INSTALL_TEMP_UNWRITABLE* = 1632 + ERROR_INSTALL_PLATFORM_UNSUPPORTED* = 1633 + ERROR_INSTALL_NOTUSED* = 1634 + ERROR_PATCH_PACKAGE_OPEN_FAILED* = 1635 + ERROR_PATCH_PACKAGE_INVALID* = 1636 + ERROR_PATCH_PACKAGE_UNSUPPORTED* = 1637 + ERROR_PRODUCT_VERSION* = 1638 + ERROR_INVALID_COMMAND_LINE* = 1639 + ERROR_INSTALL_REMOTE_DISALLOWED* = 1640 + ERROR_SUCCESS_REBOOT_INITIATED* = 1641 + ERROR_PATCH_TARGET_NOT_FOUND* = 1642 + ERROR_PATCH_PACKAGE_REJECTED* = 1643 + ERROR_INSTALL_TRANSFORM_REJECTED* = 1644 + ERROR_INSTALL_REMOTE_PROHIBITED* = 1645 + RPC_S_INVALID_STRING_BINDING* = 1700 + RPC_S_WRONG_KIND_OF_BINDING* = 1701 + RPC_S_INVALID_BINDING* = 1702 + RPC_S_PROTSEQ_NOT_SUPPORTED* = 1703 + RPC_S_INVALID_RPC_PROTSEQ* = 1704 + RPC_S_INVALID_STRING_UUID* = 1705 + RPC_S_INVALID_ENDPOINT_FORMAT* = 1706 + RPC_S_INVALID_NET_ADDR* = 1707 + RPC_S_NO_ENDPOINT_FOUND* = 1708 + RPC_S_INVALID_TIMEOUT* = 1709 + RPC_S_OBJECT_NOT_FOUND* = 1710 + RPC_S_ALREADY_REGISTERED* = 1711 + RPC_S_TYPE_ALREADY_REGISTERED* = 1712 + RPC_S_ALREADY_LISTENING* = 1713 + RPC_S_NO_PROTSEQS_REGISTERED* = 1714 + RPC_S_NOT_LISTENING* = 1715 + RPC_S_UNKNOWN_MGR_TYPE* = 1716 + RPC_S_UNKNOWN_IF* = 1717 + RPC_S_NO_BINDINGS* = 1718 + RPC_S_NO_PROTSEQS* = 1719 + RPC_S_CANT_CREATE_ENDPOINT* = 1720 + RPC_S_OUT_OF_RESOURCES* = 1721 + RPC_S_SERVER_UNAVAILABLE* = 1722 + RPC_S_SERVER_TOO_BUSY* = 1723 + RPC_S_INVALID_NETWORK_OPTIONS* = 1724 + RPC_S_NO_CALL_ACTIVE* = 1725 + RPC_S_CALL_FAILED* = 1726 + RPC_S_CALL_FAILED_DNE* = 1727 + RPC_S_PROTOCOL_ERROR* = 1728 + RPC_S_UNSUPPORTED_TRANS_SYN* = 1730 + RPC_S_UNSUPPORTED_TYPE* = 1732 + RPC_S_INVALID_TAG* = 1733 + RPC_S_INVALID_BOUND* = 1734 + RPC_S_NO_ENTRY_NAME* = 1735 + RPC_S_INVALID_NAME_SYNTAX* = 1736 + RPC_S_UNSUPPORTED_NAME_SYNTAX* = 1737 + RPC_S_UUID_NO_ADDRESS* = 1739 + RPC_S_DUPLICATE_ENDPOINT* = 1740 + RPC_S_UNKNOWN_AUTHN_TYPE* = 1741 + RPC_S_MAX_CALLS_TOO_SMALL* = 1742 + RPC_S_STRING_TOO_LONG* = 1743 + RPC_S_PROTSEQ_NOT_FOUND* = 1744 + RPC_S_PROCNUM_OUT_OF_RANGE* = 1745 + RPC_S_BINDING_HAS_NO_AUTH* = 1746 + RPC_S_UNKNOWN_AUTHN_SERVICE* = 1747 + RPC_S_UNKNOWN_AUTHN_LEVEL* = 1748 + RPC_S_INVALID_AUTH_IDENTITY* = 1749 + RPC_S_UNKNOWN_AUTHZ_SERVICE* = 1750 + EPT_S_INVALID_ENTRY* = 1751 + EPT_S_CANT_PERFORM_OP* = 1752 + EPT_S_NOT_REGISTERED* = 1753 + RPC_S_NOTHING_TO_EXPORT* = 1754 + RPC_S_INCOMPLETE_NAME* = 1755 + RPC_S_INVALID_VERS_OPTION* = 1756 + RPC_S_NO_MORE_MEMBERS* = 1757 + RPC_S_NOT_ALL_OBJS_UNEXPORTED* = 1758 + RPC_S_INTERFACE_NOT_FOUND* = 1759 + RPC_S_ENTRY_ALREADY_EXISTS* = 1760 + RPC_S_ENTRY_NOT_FOUND* = 1761 + RPC_S_NAME_SERVICE_UNAVAILABLE* = 1762 + RPC_S_INVALID_NAF_ID* = 1763 + RPC_S_CANNOT_SUPPORT* = 1764 + RPC_S_NO_CONTEXT_AVAILABLE* = 1765 + RPC_S_INTERNAL_ERROR* = 1766 + RPC_S_ZERO_DIVIDE* = 1767 + RPC_S_ADDRESS_ERROR* = 1768 + RPC_S_FP_DIV_ZERO* = 1769 + RPC_S_FP_UNDERFLOW* = 1770 + RPC_S_FP_OVERFLOW* = 1771 + RPC_X_NO_MORE_ENTRIES* = 1772 + RPC_X_SS_CHAR_TRANS_OPEN_FAIL* = 1773 + RPC_X_SS_CHAR_TRANS_SHORT_FILE* = 1774 + RPC_X_SS_IN_NULL_CONTEXT* = 1775 + RPC_X_SS_CONTEXT_DAMAGED* = 1777 + RPC_X_SS_HANDLES_MISMATCH* = 1778 + RPC_X_SS_CANNOT_GET_CALL_HANDLE* = 1779 + RPC_X_NULL_REF_POINTER* = 1780 + RPC_X_ENUM_VALUE_OUT_OF_RANGE* = 1781 + RPC_X_BYTE_COUNT_TOO_SMALL* = 1782 + RPC_X_BAD_STUB_DATA* = 1783 + ERROR_INVALID_USER_BUFFER* = 1784 + ERROR_UNRECOGNIZED_MEDIA* = 1785 + ERROR_NO_TRUST_LSA_SECRET* = 1786 + ERROR_NO_TRUST_SAM_ACCOUNT* = 1787 + ERROR_TRUSTED_DOMAIN_FAILURE* = 1788 + ERROR_TRUSTED_RELATIONSHIP_FAILURE* = 1789 + ERROR_TRUST_FAILURE* = 1790 + RPC_S_CALL_IN_PROGRESS* = 1791 + ERROR_NETLOGON_NOT_STARTED* = 1792 + ERROR_ACCOUNT_EXPIRED* = 1793 + ERROR_REDIRECTOR_HAS_OPEN_HANDLES* = 1794 + ERROR_PRINTER_DRIVER_ALREADY_INSTALLED* = 1795 + ERROR_UNKNOWN_PORT* = 1796 + ERROR_UNKNOWN_PRINTER_DRIVER* = 1797 + ERROR_UNKNOWN_PRINTPROCESSOR* = 1798 + ERROR_INVALID_SEPARATOR_FILE* = 1799 + ERROR_INVALID_PRIORITY* = 1800 + ERROR_INVALID_PRINTER_NAME* = 1801 + ERROR_PRINTER_ALREADY_EXISTS* = 1802 + ERROR_INVALID_PRINTER_COMMAND* = 1803 + ERROR_INVALID_DATATYPE* = 1804 + ERROR_INVALID_ENVIRONMENT* = 1805 + RPC_S_NO_MORE_BINDINGS* = 1806 + ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT* = 1807 + ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT* = 1808 + ERROR_NOLOGON_SERVER_TRUST_ACCOUNT* = 1809 + ERROR_DOMAIN_TRUST_INCONSISTENT* = 1810 + ERROR_SERVER_HAS_OPEN_HANDLES* = 1811 + ERROR_RESOURCE_DATA_NOT_FOUND* = 1812 + ERROR_RESOURCE_TYPE_NOT_FOUND* = 1813 + ERROR_RESOURCE_NAME_NOT_FOUND* = 1814 + ERROR_RESOURCE_LANG_NOT_FOUND* = 1815 + ERROR_NOT_ENOUGH_QUOTA* = 1816 + RPC_S_NO_INTERFACES* = 1817 + RPC_S_CALL_CANCELLED* = 1818 + RPC_S_BINDING_INCOMPLETE* = 1819 + RPC_S_COMM_FAILURE* = 1820 + RPC_S_UNSUPPORTED_AUTHN_LEVEL* = 1821 + RPC_S_NO_PRINC_NAME* = 1822 + RPC_S_NOT_RPC_ERROR* = 1823 + RPC_S_UUID_LOCAL_ONLY* = 1824 + RPC_S_SEC_PKG_ERROR* = 1825 + RPC_S_NOT_CANCELLED* = 1826 + RPC_X_INVALID_ES_ACTION* = 1827 + RPC_X_WRONG_ES_VERSION* = 1828 + RPC_X_WRONG_STUB_VERSION* = 1829 + RPC_X_INVALID_PIPE_OBJECT* = 1830 + RPC_X_WRONG_PIPE_ORDER* = 1831 + RPC_X_WRONG_PIPE_VERSION* = 1832 + RPC_S_GROUP_MEMBER_NOT_FOUND* = 1898 + EPT_S_CANT_CREATE* = 1899 + RPC_S_INVALID_OBJECT* = 1900 + ERROR_INVALID_TIME* = 1901 + ERROR_INVALID_FORM_NAME* = 1902 + ERROR_INVALID_FORM_SIZE* = 1903 + ERROR_ALREADY_WAITING* = 1904 + ERROR_PRINTER_DELETED* = 1905 + ERROR_INVALID_PRINTER_STATE* = 1906 + ERROR_PASSWORD_MUST_CHANGE* = 1907 + ERROR_DOMAIN_CONTROLLER_NOT_FOUND* = 1908 + ERROR_ACCOUNT_LOCKED_OUT* = 1909 + OR_INVALID_OXID* = 1910 + OR_INVALID_OID* = 1911 + OR_INVALID_SET* = 1912 + RPC_S_SEND_INCOMPLETE* = 1913 + RPC_S_INVALID_ASYNC_HANDLE* = 1914 + RPC_S_INVALID_ASYNC_CALL* = 1915 + RPC_X_PIPE_CLOSED* = 1916 + RPC_X_PIPE_DISCIPLINE_ERROR* = 1917 + RPC_X_PIPE_EMPTY* = 1918 + ERROR_NO_SITENAME* = 1919 + ERROR_CANT_ACCESS_FILE* = 1920 + ERROR_CANT_RESOLVE_FILENAME* = 1921 + RPC_S_ENTRY_TYPE_MISMATCH* = 1922 + RPC_S_NOT_ALL_OBJS_EXPORTED* = 1923 + RPC_S_INTERFACE_NOT_EXPORTED* = 1924 + RPC_S_PROFILE_NOT_ADDED* = 1925 + RPC_S_PRF_ELT_NOT_ADDED* = 1926 + RPC_S_PRF_ELT_NOT_REMOVED* = 1927 + RPC_S_GRP_ELT_NOT_ADDED* = 1928 + RPC_S_GRP_ELT_NOT_REMOVED* = 1929 + ERROR_KM_DRIVER_BLOCKED* = 1930 + ERROR_CONTEXT_EXPIRED* = 1931 + ERROR_PER_USER_TRUST_QUOTA_EXCEEDED* = 1932 + ERROR_ALL_USER_TRUST_QUOTA_EXCEEDED* = 1933 + ERROR_USER_DELETE_TRUST_QUOTA_EXCEEDED* = 1934 + ERROR_AUTHENTICATION_FIREWALL_FAILED* = 1935 + ERROR_REMOTE_PRINT_CONNECTIONS_BLOCKED* = 1936 + ERROR_INVALID_PIXEL_FORMAT* = 2000 + ERROR_BAD_DRIVER* = 2001 + ERROR_INVALID_WINDOW_STYLE* = 2002 + ERROR_METAFILE_NOT_SUPPORTED* = 2003 + ERROR_TRANSFORM_NOT_SUPPORTED* = 2004 + ERROR_CLIPPING_NOT_SUPPORTED* = 2005 + ERROR_INVALID_CMM* = 2010 + ERROR_INVALID_PROFILE* = 2011 + ERROR_TAG_NOT_FOUND* = 2012 + ERROR_TAG_NOT_PRESENT* = 2013 + ERROR_DUPLICATE_TAG* = 2014 + ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE* = 2015 + ERROR_PROFILE_NOT_FOUND* = 2016 + ERROR_INVALID_COLORSPACE* = 2017 + ERROR_ICM_NOT_ENABLED* = 2018 + ERROR_DELETING_ICM_XFORM* = 2019 + ERROR_INVALID_TRANSFORM* = 2020 + ERROR_COLORSPACE_MISMATCH* = 2021 + ERROR_INVALID_COLORINDEX* = 2022 + ERROR_CONNECTED_OTHER_PASSWORD* = 2108 + ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT* = 2109 + ERROR_BAD_USERNAME* = 2202 + ERROR_NOT_CONNECTED* = 2250 + ERROR_OPEN_FILES* = 2401 + ERROR_ACTIVE_CONNECTIONS* = 2402 + ERROR_DEVICE_IN_USE* = 2404 + ERROR_UNKNOWN_PRINT_MONITOR* = 3000 + ERROR_PRINTER_DRIVER_IN_USE* = 3001 + ERROR_SPOOL_FILE_NOT_FOUND* = 3002 + ERROR_SPL_NO_STARTDOC* = 3003 + ERROR_SPL_NO_ADDJOB* = 3004 + ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED* = 3005 + ERROR_PRINT_MONITOR_ALREADY_INSTALLED* = 3006 + ERROR_INVALID_PRINT_MONITOR* = 3007 + ERROR_PRINT_MONITOR_IN_USE* = 3008 + ERROR_PRINTER_HAS_JOBS_QUEUED* = 3009 + ERROR_SUCCESS_REBOOT_REQUIRED* = 3010 + ERROR_SUCCESS_RESTART_REQUIRED* = 3011 + ERROR_PRINTER_NOT_FOUND* = 3012 + ERROR_PRINTER_DRIVER_WARNED* = 3013 + ERROR_PRINTER_DRIVER_BLOCKED* = 3014 + ERROR_WINS_INTERNAL* = 4000 + ERROR_CAN_NOT_DEL_LOCAL_WINS* = 4001 + ERROR_STATIC_INIT* = 4002 + ERROR_INC_BACKUP* = 4003 + ERROR_FULL_BACKUP* = 4004 + ERROR_REC_NON_EXISTENT* = 4005 + ERROR_RPL_NOT_ALLOWED* = 4006 + ERROR_DHCP_ADDRESS_CONFLICT* = 4100 + ERROR_WMI_GUID_NOT_FOUND* = 4200 + ERROR_WMI_INSTANCE_NOT_FOUND* = 4201 + ERROR_WMI_ITEMID_NOT_FOUND* = 4202 + ERROR_WMI_TRY_AGAIN* = 4203 + ERROR_WMI_DP_NOT_FOUND* = 4204 + ERROR_WMI_UNRESOLVED_INSTANCE_REF* = 4205 + ERROR_WMI_ALREADY_ENABLED* = 4206 + ERROR_WMI_GUID_DISCONNECTED* = 4207 + ERROR_WMI_SERVER_UNAVAILABLE* = 4208 + ERROR_WMI_DP_FAILED* = 4209 + ERROR_WMI_INVALID_MOF* = 4210 + ERROR_WMI_INVALID_REGINFO* = 4211 + ERROR_WMI_ALREADY_DISABLED* = 4212 + ERROR_WMI_READ_ONLY* = 4213 + ERROR_WMI_SET_FAILURE* = 4214 + ERROR_INVALID_MEDIA* = 4300 + ERROR_INVALID_LIBRARY* = 4301 + ERROR_INVALID_MEDIA_POOL* = 4302 + ERROR_DRIVE_MEDIA_MISMATCH* = 4303 + ERROR_MEDIA_OFFLINE* = 4304 + ERROR_LIBRARY_OFFLINE* = 4305 + ERROR_EMPTY* = 4306 + ERROR_NOT_EMPTY* = 4307 + ERROR_MEDIA_UNAVAILABLE* = 4308 + ERROR_RESOURCE_DISABLED* = 4309 + ERROR_INVALID_CLEANER* = 4310 + ERROR_UNABLE_TO_CLEAN* = 4311 + ERROR_OBJECT_NOT_FOUND* = 4312 + ERROR_DATABASE_FAILURE* = 4313 + ERROR_DATABASE_FULL* = 4314 + ERROR_MEDIA_INCOMPATIBLE* = 4315 + ERROR_RESOURCE_NOT_PRESENT* = 4316 + ERROR_INVALID_OPERATION* = 4317 + ERROR_MEDIA_NOT_AVAILABLE* = 4318 + ERROR_DEVICE_NOT_AVAILABLE* = 4319 + ERROR_REQUEST_REFUSED* = 4320 + ERROR_INVALID_DRIVE_OBJECT* = 4321 + ERROR_LIBRARY_FULL* = 4322 + ERROR_MEDIUM_NOT_ACCESSIBLE* = 4323 + ERROR_UNABLE_TO_LOAD_MEDIUM* = 4324 + ERROR_UNABLE_TO_INVENTORY_DRIVE* = 4325 + ERROR_UNABLE_TO_INVENTORY_SLOT* = 4326 + ERROR_UNABLE_TO_INVENTORY_TRANSPORT* = 4327 + ERROR_TRANSPORT_FULL* = 4328 + ERROR_CONTROLLING_IEPORT* = 4329 + ERROR_UNABLE_TO_EJECT_MOUNTED_MEDIA* = 4330 + ERROR_CLEANER_SLOT_SET* = 4331 + ERROR_CLEANER_SLOT_NOT_SET* = 4332 + ERROR_CLEANER_CARTRIDGE_SPENT* = 4333 + ERROR_UNEXPECTED_OMID* = 4334 + ERROR_CANT_DELETE_LAST_ITEM* = 4335 + ERROR_MESSAGE_EXCEEDS_MAX_SIZE* = 4336 + ERROR_VOLUME_CONTAINS_SYS_FILES* = 4337 + ERROR_INDIGENOUS_TYPE* = 4338 + ERROR_NO_SUPPORTING_DRIVES* = 4339 + ERROR_CLEANER_CARTRIDGE_INSTALLED* = 4340 + ERROR_IEPORT_FULL* = 4341 + ERROR_FILE_OFFLINE* = 4350 + ERROR_REMOTE_STORAGE_NOT_ACTIVE* = 4351 + ERROR_REMOTE_STORAGE_MEDIA_ERROR* = 4352 + ERROR_NOT_A_REPARSE_POINT* = 4390 + ERROR_REPARSE_ATTRIBUTE_CONFLICT* = 4391 + ERROR_INVALID_REPARSE_DATA* = 4392 + ERROR_REPARSE_TAG_INVALID* = 4393 + ERROR_REPARSE_TAG_MISMATCH* = 4394 + ERROR_VOLUME_NOT_SIS_ENABLED* = 4500 + ERROR_DEPENDENT_RESOURCE_EXISTS* = 5001 + ERROR_DEPENDENCY_NOT_FOUND* = 5002 + ERROR_DEPENDENCY_ALREADY_EXISTS* = 5003 + ERROR_RESOURCE_NOT_ONLINE* = 5004 + ERROR_HOST_NODE_NOT_AVAILABLE* = 5005 + ERROR_RESOURCE_NOT_AVAILABLE* = 5006 + ERROR_RESOURCE_NOT_FOUND* = 5007 + ERROR_SHUTDOWN_CLUSTER* = 5008 + ERROR_CANT_EVICT_ACTIVE_NODE* = 5009 + ERROR_OBJECT_ALREADY_EXISTS* = 5010 + ERROR_OBJECT_IN_LIST* = 5011 + ERROR_GROUP_NOT_AVAILABLE* = 5012 + ERROR_GROUP_NOT_FOUND* = 5013 + ERROR_GROUP_NOT_ONLINE* = 5014 + ERROR_HOST_NODE_NOT_RESOURCE_OWNER* = 5015 + ERROR_HOST_NODE_NOT_GROUP_OWNER* = 5016 + ERROR_RESMON_CREATE_FAILED* = 5017 + ERROR_RESMON_ONLINE_FAILED* = 5018 + ERROR_RESOURCE_ONLINE* = 5019 + ERROR_QUORUM_RESOURCE* = 5020 + ERROR_NOT_QUORUM_CAPABLE* = 5021 + ERROR_CLUSTER_SHUTTING_DOWN* = 5022 + ERROR_INVALID_STATE* = 5023 + ERROR_RESOURCE_PROPERTIES_STORED* = 5024 + ERROR_NOT_QUORUM_CLASS* = 5025 + ERROR_CORE_RESOURCE* = 5026 + ERROR_QUORUM_RESOURCE_ONLINE_FAILED* = 5027 + ERROR_QUORUMLOG_OPEN_FAILED* = 5028 + ERROR_CLUSTERLOG_CORRUPT* = 5029 + ERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE* = 5030 + ERROR_CLUSTERLOG_EXCEEDS_MAXSIZE* = 5031 + ERROR_CLUSTERLOG_CHKPOINT_NOT_FOUND* = 5032 + ERROR_CLUSTERLOG_NOT_ENOUGH_SPACE* = 5033 + ERROR_QUORUM_OWNER_ALIVE* = 5034 + ERROR_NETWORK_NOT_AVAILABLE* = 5035 + ERROR_NODE_NOT_AVAILABLE* = 5036 + ERROR_ALL_NODES_NOT_AVAILABLE* = 5037 + ERROR_RESOURCE_FAILED* = 5038 + ERROR_CLUSTER_INVALID_NODE* = 5039 + ERROR_CLUSTER_NODE_EXISTS* = 5040 + ERROR_CLUSTER_JOIN_IN_PROGRESS* = 5041 + ERROR_CLUSTER_NODE_NOT_FOUND* = 5042 + ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND* = 5043 + ERROR_CLUSTER_NETWORK_EXISTS* = 5044 + ERROR_CLUSTER_NETWORK_NOT_FOUND* = 5045 + ERROR_CLUSTER_NETINTERFACE_EXISTS* = 5046 + ERROR_CLUSTER_NETINTERFACE_NOT_FOUND* = 5047 + ERROR_CLUSTER_INVALID_REQUEST* = 5048 + ERROR_CLUSTER_INVALID_NETWORK_PROVIDER* = 5049 + ERROR_CLUSTER_NODE_DOWN* = 5050 + ERROR_CLUSTER_NODE_UNREACHABLE* = 5051 + ERROR_CLUSTER_NODE_NOT_MEMBER* = 5052 + ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS* = 5053 + ERROR_CLUSTER_INVALID_NETWORK* = 5054 + ERROR_CLUSTER_NODE_UP* = 5056 + ERROR_CLUSTER_IPADDR_IN_USE* = 5057 + ERROR_CLUSTER_NODE_NOT_PAUSED* = 5058 + ERROR_CLUSTER_NO_SECURITY_CONTEXT* = 5059 + ERROR_CLUSTER_NETWORK_NOT_INTERNAL* = 5060 + ERROR_CLUSTER_NODE_ALREADY_UP* = 5061 + ERROR_CLUSTER_NODE_ALREADY_DOWN* = 5062 + ERROR_CLUSTER_NETWORK_ALREADY_ONLINE* = 5063 + ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE* = 5064 + ERROR_CLUSTER_NODE_ALREADY_MEMBER* = 5065 + ERROR_CLUSTER_LAST_INTERNAL_NETWORK* = 5066 + ERROR_CLUSTER_NETWORK_HAS_DEPENDENTS* = 5067 + ERROR_INVALID_OPERATION_ON_QUORUM* = 5068 + ERROR_DEPENDENCY_NOT_ALLOWED* = 5069 + ERROR_CLUSTER_NODE_PAUSED* = 5070 + ERROR_NODE_CANT_HOST_RESOURCE* = 5071 + ERROR_CLUSTER_NODE_NOT_READY* = 5072 + ERROR_CLUSTER_NODE_SHUTTING_DOWN* = 5073 + ERROR_CLUSTER_JOIN_ABORTED* = 5074 + ERROR_CLUSTER_INCOMPATIBLE_VERSIONS* = 5075 + ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED* = 5076 + ERROR_CLUSTER_SYSTEM_CONFIG_CHANGED* = 5077 + ERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUND* = 5078 + ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED* = 5079 + ERROR_CLUSTER_RESNAME_NOT_FOUND* = 5080 + ERROR_CLUSTER_NO_RPC_PACKAGES_REGISTERED* = 5081 + ERROR_CLUSTER_OWNER_NOT_IN_PREFLIST* = 5082 + ERROR_CLUSTER_DATABASE_SEQMISMATCH* = 5083 + ERROR_RESMON_INVALID_STATE* = 5084 + ERROR_CLUSTER_GUM_NOT_LOCKER* = 5085 + ERROR_QUORUM_DISK_NOT_FOUND* = 5086 + ERROR_DATABASE_BACKUP_CORRUPT* = 5087 + ERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT* = 5088 + ERROR_RESOURCE_PROPERTY_UNCHANGEABLE* = 5089 + ERROR_CLUSTER_MEMBERSHIP_INVALID_STATE* = 5890 + ERROR_CLUSTER_QUORUMLOG_NOT_FOUND* = 5891 + ERROR_CLUSTER_MEMBERSHIP_HALT* = 5892 + ERROR_CLUSTER_INSTANCE_ID_MISMATCH* = 5893 + ERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP* = 5894 + ERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH* = 5895 + ERROR_CLUSTER_EVICT_WITHOUT_CLEANUP* = 5896 + ERROR_CLUSTER_PARAMETER_MISMATCH* = 5897 + ERROR_NODE_CANNOT_BE_CLUSTERED* = 5898 + ERROR_CLUSTER_WRONG_OS_VERSION* = 5899 + ERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME* = 5900 + ERROR_CLUSCFG_ALREADY_COMMITTED* = 5901 + ERROR_CLUSCFG_ROLLBACK_FAILED* = 5902 + ERROR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT* = 5903 + ERROR_CLUSTER_OLD_VERSION* = 5904 + ERROR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME* = 5905 + ERROR_ENCRYPTION_FAILED* = 6000 + ERROR_DECRYPTION_FAILED* = 6001 + ERROR_FILE_ENCRYPTED* = 6002 + ERROR_NO_RECOVERY_POLICY* = 6003 + ERROR_NO_EFS* = 6004 + ERROR_WRONG_EFS* = 6005 + ERROR_NO_USER_KEYS* = 6006 + ERROR_FILE_NOT_ENCRYPTED* = 6007 + ERROR_NOT_EXPORT_FORMAT* = 6008 + ERROR_FILE_READ_ONLY* = 6009 + ERROR_DIR_EFS_DISALLOWED* = 6010 + ERROR_EFS_SERVER_NOT_TRUSTED* = 6011 + ERROR_BAD_RECOVERY_POLICY* = 6012 + ERROR_EFS_ALG_BLOB_TOO_BIG* = 6013 + ERROR_VOLUME_NOT_SUPPORT_EFS* = 6014 + ERROR_EFS_DISABLED* = 6015 + ERROR_EFS_VERSION_NOT_SUPPORT* = 6016 + ERROR_NO_BROWSER_SERVERS_FOUND* = 6118 + SCHED_E_SERVICE_NOT_LOCALSYSTEM* = 6200 + ERROR_CTX_WINSTATION_NAME_INVALID* = 7001 + ERROR_CTX_INVALID_PD* = 7002 + ERROR_CTX_PD_NOT_FOUND* = 7003 + ERROR_CTX_WD_NOT_FOUND* = 7004 + ERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY* = 7005 + ERROR_CTX_SERVICE_NAME_COLLISION* = 7006 + ERROR_CTX_CLOSE_PENDING* = 7007 + ERROR_CTX_NO_OUTBUF* = 7008 + ERROR_CTX_MODEM_INF_NOT_FOUND* = 7009 + ERROR_CTX_INVALID_MODEMNAME* = 7010 + ERROR_CTX_MODEM_RESPONSE_ERROR* = 7011 + ERROR_CTX_MODEM_RESPONSE_TIMEOUT* = 7012 + ERROR_CTX_MODEM_RESPONSE_NO_CARRIER* = 7013 + ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE* = 7014 + ERROR_CTX_MODEM_RESPONSE_BUSY* = 7015 + ERROR_CTX_MODEM_RESPONSE_VOICE* = 7016 + ERROR_CTX_TD_ERROR* = 7017 + ERROR_CTX_WINSTATION_NOT_FOUND* = 7022 + ERROR_CTX_WINSTATION_ALREADY_EXISTS* = 7023 + ERROR_CTX_WINSTATION_BUSY* = 7024 + ERROR_CTX_BAD_VIDEO_MODE* = 7025 + ERROR_CTX_GRAPHICS_INVALID* = 7035 + ERROR_CTX_LOGON_DISABLED* = 7037 + ERROR_CTX_NOT_CONSOLE* = 7038 + ERROR_CTX_CLIENT_QUERY_TIMEOUT* = 7040 + ERROR_CTX_CONSOLE_DISCONNECT* = 7041 + ERROR_CTX_CONSOLE_CONNECT* = 7042 + ERROR_CTX_SHADOW_DENIED* = 7044 + ERROR_CTX_WINSTATION_ACCESS_DENIED* = 7045 + ERROR_CTX_INVALID_WD* = 7049 + ERROR_CTX_SHADOW_INVALID* = 7050 + ERROR_CTX_SHADOW_DISABLED* = 7051 + ERROR_CTX_CLIENT_LICENSE_IN_USE* = 7052 + ERROR_CTX_CLIENT_LICENSE_NOT_SET* = 7053 + ERROR_CTX_LICENSE_NOT_AVAILABLE* = 7054 + ERROR_CTX_LICENSE_CLIENT_INVALID* = 7055 + ERROR_CTX_LICENSE_EXPIRED* = 7056 + ERROR_CTX_SHADOW_NOT_RUNNING* = 7057 + ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE* = 7058 + ERROR_ACTIVATION_COUNT_EXCEEDED* = 7059 + FRS_ERR_INVALID_API_SEQUENCE* = 8001 + FRS_ERR_STARTING_SERVICE* = 8002 + FRS_ERR_STOPPING_SERVICE* = 8003 + FRS_ERR_INTERNAL_API* = 8004 + FRS_ERR_INTERNAL* = 8005 + FRS_ERR_SERVICE_COMM* = 8006 + FRS_ERR_INSUFFICIENT_PRIV* = 8007 + FRS_ERR_AUTHENTICATION* = 8008 + FRS_ERR_PARENT_INSUFFICIENT_PRIV* = 8009 + FRS_ERR_PARENT_AUTHENTICATION* = 8010 + FRS_ERR_CHILD_TO_PARENT_COMM* = 8011 + FRS_ERR_PARENT_TO_CHILD_COMM* = 8012 + FRS_ERR_SYSVOL_POPULATE* = 8013 + FRS_ERR_SYSVOL_POPULATE_TIMEOUT* = 8014 + FRS_ERR_SYSVOL_IS_BUSY* = 8015 + FRS_ERR_SYSVOL_DEMOTE* = 8016 + FRS_ERR_INVALID_SERVICE_PARAMETER* = 8017 + DS_S_SUCCESS* = NO_ERROR + ERROR_DS_NOT_INSTALLED* = 8200 + ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY* = 8201 + ERROR_DS_NO_ATTRIBUTE_OR_VALUE* = 8202 + ERROR_DS_INVALID_ATTRIBUTE_SYNTAX* = 8203 + ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED* = 8204 + ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS* = 8205 + ERROR_DS_BUSY* = 8206 + ERROR_DS_UNAVAILABLE* = 8207 + ERROR_DS_NO_RIDS_ALLOCATED* = 8208 + ERROR_DS_NO_MORE_RIDS* = 8209 + ERROR_DS_INCORRECT_ROLE_OWNER* = 8210 + ERROR_DS_RIDMGR_INIT_ERROR* = 8211 + ERROR_DS_OBJ_CLASS_VIOLATION* = 8212 + ERROR_DS_CANT_ON_NON_LEAF* = 8213 + ERROR_DS_CANT_ON_RDN* = 8214 + ERROR_DS_CANT_MOD_OBJ_CLASS* = 8215 + ERROR_DS_CROSS_DOM_MOVE_ERROR* = 8216 + ERROR_DS_GC_NOT_AVAILABLE* = 8217 + ERROR_SHARED_POLICY* = 8218 + ERROR_POLICY_OBJECT_NOT_FOUND* = 8219 + ERROR_POLICY_ONLY_IN_DS* = 8220 + ERROR_PROMOTION_ACTIVE* = 8221 + ERROR_NO_PROMOTION_ACTIVE* = 8222 + ERROR_DS_OPERATIONS_ERROR* = 8224 + ERROR_DS_PROTOCOL_ERROR* = 8225 + ERROR_DS_TIMELIMIT_EXCEEDED* = 8226 + ERROR_DS_SIZELIMIT_EXCEEDED* = 8227 + ERROR_DS_ADMIN_LIMIT_EXCEEDED* = 8228 + ERROR_DS_COMPARE_FALSE* = 8229 + ERROR_DS_COMPARE_TRUE* = 8230 + ERROR_DS_AUTH_METHOD_NOT_SUPPORTED* = 8231 + ERROR_DS_STRONG_AUTH_REQUIRED* = 8232 + ERROR_DS_INAPPROPRIATE_AUTH* = 8233 + ERROR_DS_AUTH_UNKNOWN* = 8234 + ERROR_DS_REFERRAL* = 8235 + ERROR_DS_UNAVAILABLE_CRIT_EXTENSION* = 8236 + ERROR_DS_CONFIDENTIALITY_REQUIRED* = 8237 + ERROR_DS_INAPPROPRIATE_MATCHING* = 8238 + ERROR_DS_CONSTRAINT_VIOLATION* = 8239 + ERROR_DS_NO_SUCH_OBJECT* = 8240 + ERROR_DS_ALIAS_PROBLEM* = 8241 + ERROR_DS_INVALID_DN_SYNTAX* = 8242 + ERROR_DS_IS_LEAF* = 8243 + ERROR_DS_ALIAS_DEREF_PROBLEM* = 8244 + ERROR_DS_UNWILLING_TO_PERFORM* = 8245 + ERROR_DS_LOOP_DETECT* = 8246 + ERROR_DS_NAMING_VIOLATION* = 8247 + ERROR_DS_OBJECT_RESULTS_TOO_LARGE* = 8248 + ERROR_DS_AFFECTS_MULTIPLE_DSAS* = 8249 + ERROR_DS_SERVER_DOWN* = 8250 + ERROR_DS_LOCAL_ERROR* = 8251 + ERROR_DS_ENCODING_ERROR* = 8252 + ERROR_DS_DECODING_ERROR* = 8253 + ERROR_DS_FILTER_UNKNOWN* = 8254 + ERROR_DS_PARAM_ERROR* = 8255 + ERROR_DS_NOT_SUPPORTED* = 8256 + ERROR_DS_NO_RESULTS_RETURNED* = 8257 + ERROR_DS_CONTROL_NOT_FOUND* = 8258 + ERROR_DS_CLIENT_LOOP* = 8259 + ERROR_DS_REFERRAL_LIMIT_EXCEEDED* = 8260 + ERROR_DS_SORT_CONTROL_MISSING* = 8261 + ERROR_DS_OFFSET_RANGE_ERROR* = 8262 + ERROR_DS_ROOT_MUST_BE_NC* = 8301 + ERROR_DS_ADD_REPLICA_INHIBITED* = 8302 + ERROR_DS_ATT_NOT_DEF_IN_SCHEMA* = 8303 + ERROR_DS_MAX_OBJ_SIZE_EXCEEDED* = 8304 + ERROR_DS_OBJ_STRING_NAME_EXISTS* = 8305 + ERROR_DS_NO_RDN_DEFINED_IN_SCHEMA* = 8306 + ERROR_DS_RDN_DOESNT_MATCH_SCHEMA* = 8307 + ERROR_DS_NO_REQUESTED_ATTS_FOUND* = 8308 + ERROR_DS_USER_BUFFER_TO_SMALL* = 8309 + ERROR_DS_ATT_IS_NOT_ON_OBJ* = 8310 + ERROR_DS_ILLEGAL_MOD_OPERATION* = 8311 + ERROR_DS_OBJ_TOO_LARGE* = 8312 + ERROR_DS_BAD_INSTANCE_TYPE* = 8313 + ERROR_DS_MASTERDSA_REQUIRED* = 8314 + ERROR_DS_OBJECT_CLASS_REQUIRED* = 8315 + ERROR_DS_MISSING_REQUIRED_ATT* = 8316 + ERROR_DS_ATT_NOT_DEF_FOR_CLASS* = 8317 + ERROR_DS_ATT_ALREADY_EXISTS* = 8318 + ERROR_DS_CANT_ADD_ATT_VALUES* = 8320 + ERROR_DS_SINGLE_VALUE_CONSTRAINT* = 8321 + ERROR_DS_RANGE_CONSTRAINT* = 8322 + ERROR_DS_ATT_VAL_ALREADY_EXISTS* = 8323 + ERROR_DS_CANT_REM_MISSING_ATT* = 8324 + ERROR_DS_CANT_REM_MISSING_ATT_VAL* = 8325 + ERROR_DS_ROOT_CANT_BE_SUBREF* = 8326 + ERROR_DS_NO_CHAINING* = 8327 + ERROR_DS_NO_CHAINED_EVAL* = 8328 + ERROR_DS_NO_PARENT_OBJECT* = 8329 + ERROR_DS_PARENT_IS_AN_ALIAS* = 8330 + ERROR_DS_CANT_MIX_MASTER_AND_REPS* = 8331 + ERROR_DS_CHILDREN_EXIST* = 8332 + ERROR_DS_OBJ_NOT_FOUND* = 8333 + ERROR_DS_ALIASED_OBJ_MISSING* = 8334 + ERROR_DS_BAD_NAME_SYNTAX* = 8335 + ERROR_DS_ALIAS_POINTS_TO_ALIAS* = 8336 + ERROR_DS_CANT_DEREF_ALIAS* = 8337 + ERROR_DS_OUT_OF_SCOPE* = 8338 + ERROR_DS_OBJECT_BEING_REMOVED* = 8339 + ERROR_DS_CANT_DELETE_DSA_OBJ* = 8340 + ERROR_DS_GENERIC_ERROR* = 8341 + ERROR_DS_DSA_MUST_BE_INT_MASTER* = 8342 + ERROR_DS_CLASS_NOT_DSA* = 8343 + ERROR_DS_INSUFF_ACCESS_RIGHTS* = 8344 + ERROR_DS_ILLEGAL_SUPERIOR* = 8345 + ERROR_DS_ATTRIBUTE_OWNED_BY_SAM* = 8346 + ERROR_DS_NAME_TOO_MANY_PARTS* = 8347 + ERROR_DS_NAME_TOO_LONG* = 8348 + ERROR_DS_NAME_VALUE_TOO_LONG* = 8349 + ERROR_DS_NAME_UNPARSEABLE* = 8350 + ERROR_DS_NAME_TYPE_UNKNOWN* = 8351 + ERROR_DS_NOT_AN_OBJECT* = 8352 + ERROR_DS_SEC_DESC_TOO_SHORT* = 8353 + ERROR_DS_SEC_DESC_INVALID* = 8354 + ERROR_DS_NO_DELETED_NAME* = 8355 + ERROR_DS_SUBREF_MUST_HAVE_PARENT* = 8356 + ERROR_DS_NCNAME_MUST_BE_NC* = 8357 + ERROR_DS_CANT_ADD_SYSTEM_ONLY* = 8358 + ERROR_DS_CLASS_MUST_BE_CONCRETE* = 8359 + ERROR_DS_INVALID_DMD* = 8360 + ERROR_DS_OBJ_GUID_EXISTS* = 8361 + ERROR_DS_NOT_ON_BACKLINK* = 8362 + ERROR_DS_NO_CROSSREF_FOR_NC* = 8363 + ERROR_DS_SHUTTING_DOWN* = 8364 + ERROR_DS_UNKNOWN_OPERATION* = 8365 + ERROR_DS_INVALID_ROLE_OWNER* = 8366 + ERROR_DS_COULDNT_CONTACT_FSMO* = 8367 + ERROR_DS_CROSS_NC_DN_RENAME* = 8368 + ERROR_DS_CANT_MOD_SYSTEM_ONLY* = 8369 + ERROR_DS_REPLICATOR_ONLY* = 8370 + ERROR_DS_OBJ_CLASS_NOT_DEFINED* = 8371 + ERROR_DS_OBJ_CLASS_NOT_SUBCLASS* = 8372 + ERROR_DS_NAME_REFERENCE_INVALID* = 8373 + ERROR_DS_CROSS_REF_EXISTS* = 8374 + ERROR_DS_CANT_DEL_MASTER_CROSSREF* = 8375 + ERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD* = 8376 + ERROR_DS_NOTIFY_FILTER_TOO_COMPLEX* = 8377 + ERROR_DS_DUP_RDN* = 8378 + ERROR_DS_DUP_OID* = 8379 + ERROR_DS_DUP_MAPI_ID* = 8380 + ERROR_DS_DUP_SCHEMA_ID_GUID* = 8381 + ERROR_DS_DUP_LDAP_DISPLAY_NAME* = 8382 + ERROR_DS_SEMANTIC_ATT_TEST* = 8383 + ERROR_DS_SYNTAX_MISMATCH* = 8384 + ERROR_DS_EXISTS_IN_MUST_HAVE* = 8385 + ERROR_DS_EXISTS_IN_MAY_HAVE* = 8386 + ERROR_DS_NONEXISTENT_MAY_HAVE* = 8387 + ERROR_DS_NONEXISTENT_MUST_HAVE* = 8388 + ERROR_DS_AUX_CLS_TEST_FAIL* = 8389 + ERROR_DS_NONEXISTENT_POSS_SUP* = 8390 + ERROR_DS_SUB_CLS_TEST_FAIL* = 8391 + ERROR_DS_BAD_RDN_ATT_ID_SYNTAX* = 8392 + ERROR_DS_EXISTS_IN_AUX_CLS* = 8393 + ERROR_DS_EXISTS_IN_SUB_CLS* = 8394 + ERROR_DS_EXISTS_IN_POSS_SUP* = 8395 + ERROR_DS_RECALCSCHEMA_FAILED* = 8396 + ERROR_DS_TREE_DELETE_NOT_FINISHED* = 8397 + ERROR_DS_CANT_DELETE* = 8398 + ERROR_DS_ATT_SCHEMA_REQ_ID* = 8399 + ERROR_DS_BAD_ATT_SCHEMA_SYNTAX* = 8400 + ERROR_DS_CANT_CACHE_ATT* = 8401 + ERROR_DS_CANT_CACHE_CLASS* = 8402 + ERROR_DS_CANT_REMOVE_ATT_CACHE* = 8403 + ERROR_DS_CANT_REMOVE_CLASS_CACHE* = 8404 + ERROR_DS_CANT_RETRIEVE_DN* = 8405 + ERROR_DS_MISSING_SUPREF* = 8406 + ERROR_DS_CANT_RETRIEVE_INSTANCE* = 8407 + ERROR_DS_CODE_INCONSISTENCY* = 8408 + ERROR_DS_DATABASE_ERROR* = 8409 + ERROR_DS_GOVERNSID_MISSING* = 8410 + ERROR_DS_MISSING_EXPECTED_ATT* = 8411 + ERROR_DS_NCNAME_MISSING_CR_REF* = 8412 + ERROR_DS_SECURITY_CHECKING_ERROR* = 8413 + ERROR_DS_SCHEMA_NOT_LOADED* = 8414 + ERROR_DS_SCHEMA_ALLOC_FAILED* = 8415 + ERROR_DS_ATT_SCHEMA_REQ_SYNTAX* = 8416 + ERROR_DS_GCVERIFY_ERROR* = 8417 + ERROR_DS_DRA_SCHEMA_MISMATCH* = 8418 + ERROR_DS_CANT_FIND_DSA_OBJ* = 8419 + ERROR_DS_CANT_FIND_EXPECTED_NC* = 8420 + ERROR_DS_CANT_FIND_NC_IN_CACHE* = 8421 + ERROR_DS_CANT_RETRIEVE_CHILD* = 8422 + ERROR_DS_SECURITY_ILLEGAL_MODIFY* = 8423 + ERROR_DS_CANT_REPLACE_HIDDEN_REC* = 8424 + ERROR_DS_BAD_HIERARCHY_FILE* = 8425 + ERROR_DS_BUILD_HIERARCHY_TABLE_FAILED* = 8426 + ERROR_DS_CONFIG_PARAM_MISSING* = 8427 + ERROR_DS_COUNTING_AB_INDICES_FAILED* = 8428 + ERROR_DS_HIERARCHY_TABLE_MALLOC_FAILED* = 8429 + ERROR_DS_INTERNAL_FAILURE* = 8430 + ERROR_DS_UNKNOWN_ERROR* = 8431 + ERROR_DS_ROOT_REQUIRES_CLASS_TOP* = 8432 + ERROR_DS_REFUSING_FSMO_ROLES* = 8433 + ERROR_DS_MISSING_FSMO_SETTINGS* = 8434 + ERROR_DS_UNABLE_TO_SURRENDER_ROLES* = 8435 + ERROR_DS_DRA_GENERIC* = 8436 + ERROR_DS_DRA_INVALID_PARAMETER* = 8437 + ERROR_DS_DRA_BUSY* = 8438 + ERROR_DS_DRA_BAD_DN* = 8439 + ERROR_DS_DRA_BAD_NC* = 8440 + ERROR_DS_DRA_DN_EXISTS* = 8441 + ERROR_DS_DRA_INTERNAL_ERROR* = 8442 + ERROR_DS_DRA_INCONSISTENT_DIT* = 8443 + ERROR_DS_DRA_CONNECTION_FAILED* = 8444 + ERROR_DS_DRA_BAD_INSTANCE_TYPE* = 8445 + ERROR_DS_DRA_OUT_OF_MEM* = 8446 + ERROR_DS_DRA_MAIL_PROBLEM* = 8447 + ERROR_DS_DRA_REF_ALREADY_EXISTS* = 8448 + ERROR_DS_DRA_REF_NOT_FOUND* = 8449 + ERROR_DS_DRA_OBJ_IS_REP_SOURCE* = 8450 + ERROR_DS_DRA_DB_ERROR* = 8451 + ERROR_DS_DRA_NO_REPLICA* = 8452 + ERROR_DS_DRA_ACCESS_DENIED* = 8453 + ERROR_DS_DRA_NOT_SUPPORTED* = 8454 + ERROR_DS_DRA_RPC_CANCELLED* = 8455 + ERROR_DS_DRA_SOURCE_DISABLED* = 8456 + ERROR_DS_DRA_SINK_DISABLED* = 8457 + ERROR_DS_DRA_NAME_COLLISION* = 8458 + ERROR_DS_DRA_SOURCE_REINSTALLED* = 8459 + ERROR_DS_DRA_MISSING_PARENT* = 8460 + ERROR_DS_DRA_PREEMPTED* = 8461 + ERROR_DS_DRA_ABANDON_SYNC* = 8462 + ERROR_DS_DRA_SHUTDOWN* = 8463 + ERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SET* = 8464 + ERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA* = 8465 + ERROR_DS_DRA_EXTN_CONNECTION_FAILED* = 8466 + ERROR_DS_INSTALL_SCHEMA_MISMATCH* = 8467 + ERROR_DS_DUP_LINK_ID* = 8468 + ERROR_DS_NAME_ERROR_RESOLVING* = 8469 + ERROR_DS_NAME_ERROR_NOT_FOUND* = 8470 + ERROR_DS_NAME_ERROR_NOT_UNIQUE* = 8471 + ERROR_DS_NAME_ERROR_NO_MAPPING* = 8472 + ERROR_DS_NAME_ERROR_DOMAIN_ONLY* = 8473 + ERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING* = 8474 + ERROR_DS_CONSTRUCTED_ATT_MOD* = 8475 + ERROR_DS_WRONG_OM_OBJ_CLASS* = 8476 + ERROR_DS_DRA_REPL_PENDING* = 8477 + ERROR_DS_DS_REQUIRED* = 8478 + ERROR_DS_INVALID_LDAP_DISPLAY_NAME* = 8479 + ERROR_DS_NON_BASE_SEARCH* = 8480 + ERROR_DS_CANT_RETRIEVE_ATTS* = 8481 + ERROR_DS_BACKLINK_WITHOUT_LINK* = 8482 + ERROR_DS_EPOCH_MISMATCH* = 8483 + ERROR_DS_SRC_NAME_MISMATCH* = 8484 + ERROR_DS_SRC_AND_DST_NC_IDENTICAL* = 8485 + ERROR_DS_DST_NC_MISMATCH* = 8486 + ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC* = 8487 + ERROR_DS_SRC_GUID_MISMATCH* = 8488 + ERROR_DS_CANT_MOVE_DELETED_OBJECT* = 8489 + ERROR_DS_PDC_OPERATION_IN_PROGRESS* = 8490 + ERROR_DS_CROSS_DOMAIN_CLEANUP_REQD* = 8491 + ERROR_DS_ILLEGAL_XDOM_MOVE_OPERATION* = 8492 + ERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS* = 8493 + ERROR_DS_NC_MUST_HAVE_NC_PARENT* = 8494 + ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE* = 8495 + ERROR_DS_DST_DOMAIN_NOT_NATIVE* = 8496 + ERROR_DS_MISSING_INFRASTRUCTURE_CONTAINER* = 8497 + ERROR_DS_CANT_MOVE_ACCOUNT_GROUP* = 8498 + ERROR_DS_CANT_MOVE_RESOURCE_GROUP* = 8499 + ERROR_DS_INVALID_SEARCH_FLAG* = 8500 + ERROR_DS_NO_TREE_DELETE_ABOVE_NC* = 8501 + ERROR_DS_COULDNT_LOCK_TREE_FOR_DELETE* = 8502 + ERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE* = 8503 + ERROR_DS_SAM_INIT_FAILURE* = 8504 + ERROR_DS_SENSITIVE_GROUP_VIOLATION* = 8505 + ERROR_DS_CANT_MOD_PRIMARYGROUPID* = 8506 + ERROR_DS_ILLEGAL_BASE_SCHEMA_MOD* = 8507 + ERROR_DS_NONSAFE_SCHEMA_CHANGE* = 8508 + ERROR_DS_SCHEMA_UPDATE_DISALLOWED* = 8509 + ERROR_DS_CANT_CREATE_UNDER_SCHEMA* = 8510 + ERROR_DS_INSTALL_NO_SRC_SCH_VERSION* = 8511 + ERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE* = 8512 + ERROR_DS_INVALID_GROUP_TYPE* = 8513 + ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN* = 8514 + ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN* = 8515 + ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER* = 8516 + ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER* = 8517 + ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER* = 8518 + ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER* = 8519 + ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER* = 8520 + ERROR_DS_HAVE_PRIMARY_MEMBERS* = 8521 + ERROR_DS_STRING_SD_CONVERSION_FAILED* = 8522 + ERROR_DS_NAMING_MASTER_GC* = 8523 + ERROR_DS_DNS_LOOKUP_FAILURE* = 8524 + ERROR_DS_COULDNT_UPDATE_SPNS* = 8525 + ERROR_DS_CANT_RETRIEVE_SD* = 8526 + ERROR_DS_KEY_NOT_UNIQUE* = 8527 + ERROR_DS_WRONG_LINKED_ATT_SYNTAX* = 8528 + ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD* = 8529 + ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY* = 8530 + ERROR_DS_CANT_START* = 8531 + ERROR_DS_INIT_FAILURE* = 8532 + ERROR_DS_NO_PKT_PRIVACY_ON_CONNECTION* = 8533 + ERROR_DS_SOURCE_DOMAIN_IN_FOREST* = 8534 + ERROR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST* = 8535 + ERROR_DS_DESTINATION_AUDITING_NOT_ENABLED* = 8536 + ERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN* = 8537 + ERROR_DS_SRC_OBJ_NOT_GROUP_OR_USER* = 8538 + ERROR_DS_SRC_SID_EXISTS_IN_FOREST* = 8539 + ERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH* = 8540 + ERROR_SAM_INIT_FAILURE* = 8541 + ERROR_DS_DRA_SCHEMA_INFO_SHIP* = 8542 + ERROR_DS_DRA_SCHEMA_CONFLICT* = 8543 + ERROR_DS_DRA_EARLIER_SCHEMA_CONFLICT* = 8544 + ERROR_DS_DRA_OBJ_NC_MISMATCH* = 8545 + ERROR_DS_NC_STILL_HAS_DSAS* = 8546 + ERROR_DS_GC_REQUIRED* = 8547 + ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY* = 8548 + ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS* = 8549 + ERROR_DS_CANT_ADD_TO_GC* = 8550 + ERROR_DS_NO_CHECKPOINT_WITH_PDC* = 8551 + ERROR_DS_SOURCE_AUDITING_NOT_ENABLED* = 8552 + ERROR_DS_CANT_CREATE_IN_NONDOMAIN_NC* = 8553 + ERROR_DS_INVALID_NAME_FOR_SPN* = 8554 + ERROR_DS_FILTER_USES_CONTRUCTED_ATTRS* = 8555 + ERROR_DS_UNICODEPWD_NOT_IN_QUOTES* = 8556 + ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED* = 8557 + ERROR_DS_MUST_BE_RUN_ON_DST_DC* = 8558 + ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER* = 8559 + ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ* = 8560 + ERROR_DS_INIT_FAILURE_CONSOLE* = 8561 + ERROR_DS_SAM_INIT_FAILURE_CONSOLE* = 8562 + ERROR_DS_FOREST_VERSION_TOO_HIGH* = 8563 + ERROR_DS_DOMAIN_VERSION_TOO_HIGH* = 8564 + ERROR_DS_FOREST_VERSION_TOO_LOW* = 8565 + ERROR_DS_DOMAIN_VERSION_TOO_LOW* = 8566 + ERROR_DS_INCOMPATIBLE_VERSION* = 8567 + ERROR_DS_LOW_DSA_VERSION* = 8568 + ERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN* = 8569 + ERROR_DS_NOT_SUPPORTED_SORT_ORDER* = 8570 + ERROR_DS_NAME_NOT_UNIQUE* = 8571 + ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4* = 8572 + ERROR_DS_OUT_OF_VERSION_STORE* = 8573 + ERROR_DS_INCOMPATIBLE_CONTROLS_USED* = 8574 + ERROR_DS_NO_REF_DOMAIN* = 8575 + ERROR_DS_RESERVED_LINK_ID* = 8576 + ERROR_DS_LINK_ID_NOT_AVAILABLE* = 8577 + ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER* = 8578 + ERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE* = 8579 + ERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC* = 8580 + ERROR_DS_MODIFYDN_DISALLOWED_BY_FLAG* = 8581 + ERROR_DS_MODIFYDN_WRONG_GRANDPARENT* = 8582 + ERROR_DS_NAME_ERROR_TRUST_REFERRAL* = 8583 + ERROR_NOT_SUPPORTED_ON_STANDARD_SERVER* = 8584 + ERROR_DS_CANT_ACCESS_REMOTE_PART_OF_AD* = 8585 + ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2* = 8586 + ERROR_DS_THREAD_LIMIT_EXCEEDED* = 8587 + ERROR_DS_NOT_CLOSEST* = 8588 + ERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF* = 8589 + ERROR_DS_SINGLE_USER_MODE_FAILED* = 8590 + ERROR_DS_NTDSCRIPT_SYNTAX_ERROR* = 8591 + ERROR_DS_NTDSCRIPT_PROCESS_ERROR* = 8592 + ERROR_DS_DIFFERENT_REPL_EPOCHS* = 8593 + ERROR_DS_DRS_EXTENSIONS_CHANGED* = 8594 + ERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR* = 8595 + ERROR_DS_NO_MSDS_INTID* = 8596 + ERROR_DS_DUP_MSDS_INTID* = 8597 + ERROR_DS_EXISTS_IN_RDNATTID* = 8598 + ERROR_DS_AUTHORIZATION_FAILED* = 8599 + ERROR_DS_INVALID_SCRIPT* = 8600 + ERROR_DS_REMOTE_CROSSREF_OP_FAILED* = 8601 + ERROR_DS_CROSS_REF_BUSY* = 8602 + ERROR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN* = 8603 + ERROR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC* = 8604 + ERROR_DS_DUPLICATE_ID_FOUND* = 8605 + ERROR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT* = 8606 + ERROR_DS_GROUP_CONVERSION_ERROR* = 8607 + ERROR_DS_CANT_MOVE_APP_BASIC_GROUP* = 8608 + ERROR_DS_CANT_MOVE_APP_QUERY_GROUP* = 8609 + ERROR_DS_ROLE_NOT_VERIFIED* = 8610 + ERROR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL* = 8611 + ERROR_DS_DOMAIN_RENAME_IN_PROGRESS* = 8612 + ERROR_DS_EXISTING_AD_CHILD_NC* = 8613 + ERROR_DS_REPL_LIFETIME_EXCEEDED* = 8614 + ERROR_DS_DISALLOWED_IN_SYSTEM_CONTAINER* = 8615 + ERROR_DS_LDAP_SEND_QUEUE_FULL* = 8616 + ERROR_DS_DRA_OUT_SCHEDULE_WINDOW* = 8617 + DNS_ERROR_RESPONSE_CODES_BASE* = 9000 + DNS_ERROR_RCODE_NO_ERROR* = NO_ERROR + DNS_ERROR_MASK* = 0x00002328 + DNS_ERROR_RCODE_FORMAT_ERROR* = 9001 + DNS_ERROR_RCODE_SERVER_FAILURE* = 9002 + DNS_ERROR_RCODE_NAME_ERROR* = 9003 + DNS_ERROR_RCODE_NOT_IMPLEMENTED* = 9004 + DNS_ERROR_RCODE_REFUSED* = 9005 + DNS_ERROR_RCODE_YXDOMAIN* = 9006 + DNS_ERROR_RCODE_YXRRSET* = 9007 + DNS_ERROR_RCODE_NXRRSET* = 9008 + DNS_ERROR_RCODE_NOTAUTH* = 9009 + DNS_ERROR_RCODE_NOTZONE* = 9010 + DNS_ERROR_RCODE_BADSIG* = 9016 + DNS_ERROR_RCODE_BADKEY* = 9017 + DNS_ERROR_RCODE_BADTIME* = 9018 + DNS_ERROR_RCODE_LAST* = DNS_ERROR_RCODE_BADTIME + DNS_ERROR_PACKET_FMT_BASE* = 9500 + DNS_INFO_NO_RECORDS* = 9501 + DNS_ERROR_BAD_PACKET* = 9502 + DNS_ERROR_NO_PACKET* = 9503 + DNS_ERROR_RCODE* = 9504 + DNS_ERROR_UNSECURE_PACKET* = 9505 + DNS_STATUS_PACKET_UNSECURE* = DNS_ERROR_UNSECURE_PACKET + DNS_ERROR_NO_MEMORY* = ERROR_OUTOFMEMORY + DNS_ERROR_INVALID_NAME* = ERROR_INVALID_NAME + DNS_ERROR_INVALID_DATA* = ERROR_INVALID_DATA + DNS_ERROR_GENERAL_API_BASE* = 9550 + DNS_ERROR_INVALID_TYPE* = 9551 + DNS_ERROR_INVALID_IP_ADDRESS* = 9552 + DNS_ERROR_INVALID_PROPERTY* = 9553 + DNS_ERROR_TRY_AGAIN_LATER* = 9554 + DNS_ERROR_NOT_UNIQUE* = 9555 + DNS_ERROR_NON_RFC_NAME* = 9556 + DNS_STATUS_FQDN* = 9557 + DNS_STATUS_DOTTED_NAME* = 9558 + DNS_STATUS_SINGLE_PART_NAME* = 9559 + DNS_ERROR_INVALID_NAME_CHAR* = 9560 + DNS_ERROR_NUMERIC_NAME* = 9561 + DNS_ERROR_NOT_ALLOWED_ON_ROOT_SERVER* = 9562 + DNS_ERROR_NOT_ALLOWED_UNDER_DELEGATION* = 9563 + DNS_ERROR_CANNOT_FIND_ROOT_HINTS* = 9564 + DNS_ERROR_INCONSISTENT_ROOT_HINTS* = 9565 + DNS_ERROR_ZONE_BASE* = 9600 + DNS_ERROR_ZONE_DOES_NOT_EXIST* = 9601 + DNS_ERROR_NO_ZONE_INFO* = 9602 + DNS_ERROR_INVALID_ZONE_OPERATION* = 9603 + DNS_ERROR_ZONE_CONFIGURATION_ERROR* = 9604 + DNS_ERROR_ZONE_HAS_NO_SOA_RECORD* = 9605 + DNS_ERROR_ZONE_HAS_NO_NS_RECORDS* = 9606 + DNS_ERROR_ZONE_LOCKED* = 9607 + DNS_ERROR_ZONE_CREATION_FAILED* = 9608 + DNS_ERROR_ZONE_ALREADY_EXISTS* = 9609 + DNS_ERROR_AUTOZONE_ALREADY_EXISTS* = 9610 + DNS_ERROR_INVALID_ZONE_TYPE* = 9611 + DNS_ERROR_SECONDARY_REQUIRES_MASTER_IP* = 9612 + DNS_ERROR_ZONE_NOT_SECONDARY* = 9613 + DNS_ERROR_NEED_SECONDARY_ADDRESSES* = 9614 + DNS_ERROR_WINS_INIT_FAILED* = 9615 + DNS_ERROR_NEED_WINS_SERVERS* = 9616 + DNS_ERROR_NBSTAT_INIT_FAILED* = 9617 + DNS_ERROR_SOA_DELETE_INVALID* = 9618 + DNS_ERROR_FORWARDER_ALREADY_EXISTS* = 9619 + DNS_ERROR_ZONE_REQUIRES_MASTER_IP* = 9620 + DNS_ERROR_ZONE_IS_SHUTDOWN* = 9621 + DNS_ERROR_DATAFILE_BASE* = 9650 + DNS_ERROR_PRIMARY_REQUIRES_DATAFILE* = 9651 + DNS_ERROR_INVALID_DATAFILE_NAME* = 9652 + DNS_ERROR_DATAFILE_OPEN_FAILURE* = 9653 + DNS_ERROR_FILE_WRITEBACK_FAILED* = 9654 + DNS_ERROR_DATAFILE_PARSING* = 9655 + DNS_ERROR_DATABASE_BASE* = 9700 + DNS_ERROR_RECORD_DOES_NOT_EXIST* = 9701 + DNS_ERROR_RECORD_FORMAT* = 9702 + DNS_ERROR_NODE_CREATION_FAILED* = 9703 + DNS_ERROR_UNKNOWN_RECORD_TYPE* = 9704 + DNS_ERROR_RECORD_TIMED_OUT* = 9705 + DNS_ERROR_NAME_NOT_IN_ZONE* = 9706 + DNS_ERROR_CNAME_LOOP* = 9707 + DNS_ERROR_NODE_IS_CNAME* = 9708 + DNS_ERROR_CNAME_COLLISION* = 9709 + DNS_ERROR_RECORD_ONLY_AT_ZONE_ROOT* = 9710 + DNS_ERROR_RECORD_ALREADY_EXISTS* = 9711 + DNS_ERROR_SECONDARY_DATA* = 9712 + DNS_ERROR_NO_CREATE_CACHE_DATA* = 9713 + DNS_ERROR_NAME_DOES_NOT_EXIST* = 9714 + DNS_WARNING_PTR_CREATE_FAILED* = 9715 + DNS_WARNING_DOMAIN_UNDELETED* = 9716 + DNS_ERROR_DS_UNAVAILABLE* = 9717 + DNS_ERROR_DS_ZONE_ALREADY_EXISTS* = 9718 + DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE* = 9719 + DNS_ERROR_OPERATION_BASE* = 9750 + DNS_INFO_AXFR_COMPLETE* = 9751 + DNS_ERROR_AXFR* = 9752 + DNS_INFO_ADDED_LOCAL_WINS* = 9753 + DNS_ERROR_SECURE_BASE* = 9800 + DNS_STATUS_CONTINUE_NEEDED* = 9801 + DNS_ERROR_SETUP_BASE* = 9850 + DNS_ERROR_NO_TCPIP* = 9851 + DNS_ERROR_NO_DNS_SERVERS* = 9852 + DNS_ERROR_DP_BASE* = 9900 + DNS_ERROR_DP_DOES_NOT_EXIST* = 9901 + DNS_ERROR_DP_ALREADY_EXISTS* = 9902 + DNS_ERROR_DP_NOT_ENLISTED* = 9903 + DNS_ERROR_DP_ALREADY_ENLISTED* = 9904 + DNS_ERROR_DP_NOT_AVAILABLE* = 9905 + DNS_ERROR_DP_FSMO_ERROR* = 9906 + WSABASEERR* = 10000 + WSAEINTR* = WSABASEERR+4 + WSAEBADF* = WSABASEERR+9 + WSAEACCES* = WSABASEERR+13 + WSAEFAULT* = WSABASEERR+14 + WSAEINVAL* = WSABASEERR+22 + WSAEMFILE* = WSABASEERR+24 + WSAEWOULDBLOCK* = WSABASEERR+35 + WSAEINPROGRESS* = WSABASEERR+36 + WSAEALREADY* = WSABASEERR+37 + WSAENOTSOCK* = WSABASEERR+38 + WSAEDESTADDRREQ* = WSABASEERR+39 + WSAEMSGSIZE* = WSABASEERR+40 + WSAEPROTOTYPE* = WSABASEERR+41 + WSAENOPROTOOPT* = WSABASEERR+42 + WSAEPROTONOSUPPORT* = WSABASEERR+43 + WSAESOCKTNOSUPPORT* = WSABASEERR+44 + WSAEOPNOTSUPP* = WSABASEERR+45 + WSAEPFNOSUPPORT* = WSABASEERR+46 + WSAEAFNOSUPPORT* = WSABASEERR+47 + WSAEADDRINUSE* = WSABASEERR+48 + WSAEADDRNOTAVAIL* = WSABASEERR+49 + WSAENETDOWN* = WSABASEERR+50 + WSAENETUNREACH* = WSABASEERR+51 + WSAENETRESET* = WSABASEERR+52 + WSAECONNABORTED* = WSABASEERR+53 + WSAECONNRESET* = WSABASEERR+54 + WSAENOBUFS* = WSABASEERR+55 + WSAEISCONN* = WSABASEERR+56 + WSAENOTCONN* = WSABASEERR+57 + WSAESHUTDOWN* = WSABASEERR+58 + WSAETOOMANYREFS* = WSABASEERR+59 + WSAETIMEDOUT* = WSABASEERR+60 + WSAECONNREFUSED* = WSABASEERR+61 + WSAELOOP* = WSABASEERR+62 + WSAENAMETOOLONG* = WSABASEERR+63 + WSAEHOSTDOWN* = WSABASEERR+64 + WSAEHOSTUNREACH* = WSABASEERR+65 + WSAENOTEMPTY* = WSABASEERR+66 + WSAEPROCLIM* = WSABASEERR+67 + WSAEUSERS* = WSABASEERR+68 + WSAEDQUOT* = WSABASEERR+69 + WSAESTALE* = WSABASEERR+70 + WSAEREMOTE* = WSABASEERR+71 + WSASYSNOTREADY* = WSABASEERR+91 + WSAVERNOTSUPPORTED* = WSABASEERR+92 + WSANOTINITIALISED* = WSABASEERR+93 + WSAEDISCON* = WSABASEERR+101 + WSAEINVALIDPROCTABLE* = WSABASEERR+104 + WSAEINVALIDPROVIDER* = WSABASEERR+105 + WSAEPROVIDERFAILEDINIT* = WSABASEERR+106 + WSASYSCALLFAILURE* = WSABASEERR+107 + WSASERVICE_NOT_FOUND* = WSABASEERR+108 + WSATYPE_NOT_FOUND* = WSABASEERR+109 + WSA_E_NO_MORE* = WSABASEERR+110 + WSA_E_CANCELLED* = WSABASEERR+111 + WSAEREFUSED* = WSABASEERR+112 + WSAHOST_NOT_FOUND* = WSABASEERR+1001 + WSATRY_AGAIN* = WSABASEERR+1002 + WSANO_RECOVERY* = WSABASEERR+1003 + WSANO_DATA* = WSABASEERR+1004 + WSA_QOS_RECEIVERS* = WSABASEERR+1005 + WSA_QOS_SENDERS* = WSABASEERR+1006 + WSA_QOS_NO_SENDERS* = WSABASEERR+1007 + WSA_QOS_NO_RECEIVERS* = WSABASEERR+1008 + WSA_QOS_REQUEST_CONFIRMED* = WSABASEERR+1009 + WSA_QOS_ADMISSION_FAILURE* = WSABASEERR+1010 + WSA_QOS_POLICY_FAILURE* = WSABASEERR+1011 + WSA_QOS_BAD_STYLE* = WSABASEERR+1012 + WSA_QOS_BAD_OBJECT* = WSABASEERR+1013 + WSA_QOS_TRAFFIC_CTRL_ERROR* = WSABASEERR+1014 + WSA_QOS_GENERIC_ERROR* = WSABASEERR+1015 + WSA_QOS_ESERVICETYPE* = WSABASEERR+1016 + WSA_QOS_EFLOWSPEC* = WSABASEERR+1017 + WSA_QOS_EPROVSPECBUF* = WSABASEERR+1018 + WSA_QOS_EFILTERSTYLE* = WSABASEERR+1019 + WSA_QOS_EFILTERTYPE* = WSABASEERR+1020 + WSA_QOS_EFILTERCOUNT* = WSABASEERR+1021 + WSA_QOS_EOBJLENGTH* = WSABASEERR+1022 + WSA_QOS_EFLOWCOUNT* = WSABASEERR+1023 + WSA_QOS_EUNKNOWNPSOBJ* = WSABASEERR+1024 + WSA_QOS_EUNKOWNPSOBJ* = WSA_QOS_EUNKNOWNPSOBJ + WSA_QOS_EPOLICYOBJ* = WSABASEERR+1025 + WSA_QOS_EFLOWDESC* = WSABASEERR+1026 + WSA_QOS_EPSFLOWSPEC* = WSABASEERR+1027 + WSA_QOS_EPSFILTERSPEC* = WSABASEERR+1028 + WSA_QOS_ESDMODEOBJ* = WSABASEERR+1029 + WSA_QOS_ESHAPERATEOBJ* = WSABASEERR+1030 + WSA_QOS_RESERVED_PETYPE* = WSABASEERR+1031 + ERROR_SXS_SECTION_NOT_FOUND* = 14000 + ERROR_SXS_CANT_GEN_ACTCTX* = 14001 + ERROR_SXS_INVALID_ACTCTXDATA_FORMAT* = 14002 + ERROR_SXS_ASSEMBLY_NOT_FOUND* = 14003 + ERROR_SXS_MANIFEST_FORMAT_ERROR* = 14004 + ERROR_SXS_MANIFEST_PARSE_ERROR* = 14005 + ERROR_SXS_ACTIVATION_CONTEXT_DISABLED* = 14006 + ERROR_SXS_KEY_NOT_FOUND* = 14007 + ERROR_SXS_VERSION_CONFLICT* = 14008 + ERROR_SXS_WRONG_SECTION_TYPE* = 14009 + ERROR_SXS_THREAD_QUERIES_DISABLED* = 14010 + ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET* = 14011 + ERROR_SXS_UNKNOWN_ENCODING_GROUP* = 14012 + ERROR_SXS_UNKNOWN_ENCODING* = 14013 + ERROR_SXS_INVALID_XML_NAMESPACE_URI* = 14014 + ERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED* = 14015 + ERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED* = 14016 + ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE* = 14017 + ERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE* = 14018 + ERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE* = 14019 + ERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT* = 14020 + ERROR_SXS_DUPLICATE_DLL_NAME* = 14021 + ERROR_SXS_DUPLICATE_WINDOWCLASS_NAME* = 14022 + ERROR_SXS_DUPLICATE_CLSID* = 14023 + ERROR_SXS_DUPLICATE_IID* = 14024 + ERROR_SXS_DUPLICATE_TLBID* = 14025 + ERROR_SXS_DUPLICATE_PROGID* = 14026 + ERROR_SXS_DUPLICATE_ASSEMBLY_NAME* = 14027 + ERROR_SXS_FILE_HASH_MISMATCH* = 14028 + ERROR_SXS_POLICY_PARSE_ERROR* = 14029 + ERROR_SXS_XML_E_MISSINGQUOTE* = 14030 + ERROR_SXS_XML_E_COMMENTSYNTAX* = 14031 + ERROR_SXS_XML_E_BADSTARTNAMECHAR* = 14032 + ERROR_SXS_XML_E_BADNAMECHAR* = 14033 + ERROR_SXS_XML_E_BADCHARINSTRING* = 14034 + ERROR_SXS_XML_E_XMLDECLSYNTAX* = 14035 + ERROR_SXS_XML_E_BADCHARDATA* = 14036 + ERROR_SXS_XML_E_MISSINGWHITESPACE* = 14037 + ERROR_SXS_XML_E_EXPECTINGTAGEND* = 14038 + ERROR_SXS_XML_E_MISSINGSEMICOLON* = 14039 + ERROR_SXS_XML_E_UNBALANCEDPAREN* = 14040 + ERROR_SXS_XML_E_INTERNALERROR* = 14041 + ERROR_SXS_XML_E_UNEXPECTED_WHITESPACE* = 14042 + ERROR_SXS_XML_E_INCOMPLETE_ENCODING* = 14043 + ERROR_SXS_XML_E_MISSING_PAREN* = 14044 + ERROR_SXS_XML_E_EXPECTINGCLOSEQUOTE* = 14045 + ERROR_SXS_XML_E_MULTIPLE_COLONS* = 14046 + ERROR_SXS_XML_E_INVALID_DECIMAL* = 14047 + ERROR_SXS_XML_E_INVALID_HEXIDECIMAL* = 14048 + ERROR_SXS_XML_E_INVALID_UNICODE* = 14049 + ERROR_SXS_XML_E_WHITESPACEORQUESTIONMARK* = 14050 + ERROR_SXS_XML_E_UNEXPECTEDENDTAG* = 14051 + ERROR_SXS_XML_E_UNCLOSEDTAG* = 14052 + ERROR_SXS_XML_E_DUPLICATEATTRIBUTE* = 14053 + ERROR_SXS_XML_E_MULTIPLEROOTS* = 14054 + ERROR_SXS_XML_E_INVALIDATROOTLEVEL* = 14055 + ERROR_SXS_XML_E_BADXMLDECL* = 14056 + ERROR_SXS_XML_E_MISSINGROOT* = 14057 + ERROR_SXS_XML_E_UNEXPECTEDEOF* = 14058 + ERROR_SXS_XML_E_BADPEREFINSUBSET* = 14059 + ERROR_SXS_XML_E_UNCLOSEDSTARTTAG* = 14060 + ERROR_SXS_XML_E_UNCLOSEDENDTAG* = 14061 + ERROR_SXS_XML_E_UNCLOSEDSTRING* = 14062 + ERROR_SXS_XML_E_UNCLOSEDCOMMENT* = 14063 + ERROR_SXS_XML_E_UNCLOSEDDECL* = 14064 + ERROR_SXS_XML_E_UNCLOSEDCDATA* = 14065 + ERROR_SXS_XML_E_RESERVEDNAMESPACE* = 14066 + ERROR_SXS_XML_E_INVALIDENCODING* = 14067 + ERROR_SXS_XML_E_INVALIDSWITCH* = 14068 + ERROR_SXS_XML_E_BADXMLCASE* = 14069 + ERROR_SXS_XML_E_INVALID_STANDALONE* = 14070 + ERROR_SXS_XML_E_UNEXPECTED_STANDALONE* = 14071 + ERROR_SXS_XML_E_INVALID_VERSION* = 14072 + ERROR_SXS_XML_E_MISSINGEQUALS* = 14073 + ERROR_SXS_PROTECTION_RECOVERY_FAILED* = 14074 + ERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT* = 14075 + ERROR_SXS_PROTECTION_CATALOG_NOT_VALID* = 14076 + ERROR_SXS_UNTRANSLATABLE_HRESULT* = 14077 + ERROR_SXS_PROTECTION_CATALOG_FILE_MISSING* = 14078 + ERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE* = 14079 + ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME* = 14080 + ERROR_SXS_ASSEMBLY_MISSING* = 14081 + ERROR_SXS_CORRUPT_ACTIVATION_STACK* = 14082 + ERROR_SXS_CORRUPTION* = 14083 + ERROR_SXS_EARLY_DEACTIVATION* = 14084 + ERROR_SXS_INVALID_DEACTIVATION* = 14085 + ERROR_SXS_MULTIPLE_DEACTIVATION* = 14086 + ERROR_SXS_PROCESS_TERMINATION_REQUESTED* = 14087 + ERROR_SXS_RELEASE_ACTIVATION_CONTEXT* = 14088 + ERROR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY* = 14089 + ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE* = 14090 + ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME* = 14091 + ERROR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE* = 14092 + ERROR_SXS_IDENTITY_PARSE_ERROR* = 14093 + ERROR_MALFORMED_SUBSTITUTION_STRING* = 14094 + ERROR_SXS_INCORRECT_PUBLIC_KEY_TOKEN* = 14095 + ERROR_UNMAPPED_SUBSTITUTION_STRING* = 14096 + ERROR_SXS_ASSEMBLY_NOT_LOCKED* = 14097 + ERROR_SXS_COMPONENT_STORE_CORRUPT* = 14098 + ERROR_ADVANCED_INSTALLER_FAILED* = 14099 + ERROR_XML_ENCODING_MISMATCH* = 14100 + ERROR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT* = 14101 + ERROR_SXS_IDENTITIES_DIFFERENT* = 14102 + ERROR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT* = 14103 + ERROR_SXS_FILE_NOT_PART_OF_ASSEMBLY* = 14104 + ERROR_SXS_MANIFEST_TOO_BIG* = 14105 + ERROR_SXS_SETTING_NOT_REGISTERED* = 14106 + ERROR_SXS_TRANSACTION_CLOSURE_INCOMPLETE* = 14107 + ERROR_SMI_PRIMITIVE_INSTALLER_FAILED* = 14108 + ERROR_GENERIC_COMMAND_FAILED* = 14109 + ERROR_SXS_FILE_HASH_MISSING* = 14110 + ERROR_IPSEC_QM_POLICY_EXISTS* = 13000 + ERROR_IPSEC_QM_POLICY_NOT_FOUND* = 13001 + ERROR_IPSEC_QM_POLICY_IN_USE* = 13002 + ERROR_IPSEC_MM_POLICY_EXISTS* = 13003 + ERROR_IPSEC_MM_POLICY_NOT_FOUND* = 13004 + ERROR_IPSEC_MM_POLICY_IN_USE* = 13005 + ERROR_IPSEC_MM_FILTER_EXISTS* = 13006 + ERROR_IPSEC_MM_FILTER_NOT_FOUND* = 13007 + ERROR_IPSEC_TRANSPORT_FILTER_EXISTS* = 13008 + ERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUND* = 13009 + ERROR_IPSEC_MM_AUTH_EXISTS* = 13010 + ERROR_IPSEC_MM_AUTH_NOT_FOUND* = 13011 + ERROR_IPSEC_MM_AUTH_IN_USE* = 13012 + ERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND* = 13013 + ERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND* = 13014 + ERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND* = 13015 + ERROR_IPSEC_TUNNEL_FILTER_EXISTS* = 13016 + ERROR_IPSEC_TUNNEL_FILTER_NOT_FOUND* = 13017 + ERROR_IPSEC_MM_FILTER_PENDING_DELETION* = 13018 + ERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETION* = 13019 + ERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETION* = 13020 + ERROR_IPSEC_MM_POLICY_PENDING_DELETION* = 13021 + ERROR_IPSEC_MM_AUTH_PENDING_DELETION* = 13022 + ERROR_IPSEC_QM_POLICY_PENDING_DELETION* = 13023 + WARNING_IPSEC_MM_POLICY_PRUNED* = 13024 + WARNING_IPSEC_QM_POLICY_PRUNED* = 13025 + ERROR_IPSEC_IKE_NEG_STATUS_BEGIN* = 13800 + ERROR_IPSEC_IKE_AUTH_FAIL* = 13801 + ERROR_IPSEC_IKE_ATTRIB_FAIL* = 13802 + ERROR_IPSEC_IKE_NEGOTIATION_PENDING* = 13803 + ERROR_IPSEC_IKE_GENERAL_PROCESSING_ERROR* = 13804 + ERROR_IPSEC_IKE_TIMED_OUT* = 13805 + ERROR_IPSEC_IKE_NO_CERT* = 13806 + ERROR_IPSEC_IKE_SA_DELETED* = 13807 + ERROR_IPSEC_IKE_SA_REAPED* = 13808 + ERROR_IPSEC_IKE_MM_ACQUIRE_DROP* = 13809 + ERROR_IPSEC_IKE_QM_ACQUIRE_DROP* = 13810 + ERROR_IPSEC_IKE_QUEUE_DROP_MM* = 13811 + ERROR_IPSEC_IKE_QUEUE_DROP_NO_MM* = 13812 + ERROR_IPSEC_IKE_DROP_NO_RESPONSE* = 13813 + ERROR_IPSEC_IKE_MM_DELAY_DROP* = 13814 + ERROR_IPSEC_IKE_QM_DELAY_DROP* = 13815 + ERROR_IPSEC_IKE_ERROR* = 13816 + ERROR_IPSEC_IKE_CRL_FAILED* = 13817 + ERROR_IPSEC_IKE_INVALID_KEY_USAGE* = 13818 + ERROR_IPSEC_IKE_INVALID_CERT_TYPE* = 13819 + ERROR_IPSEC_IKE_NO_PRIVATE_KEY* = 13820 + ERROR_IPSEC_IKE_DH_FAIL* = 13822 + ERROR_IPSEC_IKE_INVALID_HEADER* = 13824 + ERROR_IPSEC_IKE_NO_POLICY* = 13825 + ERROR_IPSEC_IKE_INVALID_SIGNATURE* = 13826 + ERROR_IPSEC_IKE_KERBEROS_ERROR* = 13827 + ERROR_IPSEC_IKE_NO_PUBLIC_KEY* = 13828 + ERROR_IPSEC_IKE_PROCESS_ERR* = 13829 + ERROR_IPSEC_IKE_PROCESS_ERR_SA* = 13830 + ERROR_IPSEC_IKE_PROCESS_ERR_PROP* = 13831 + ERROR_IPSEC_IKE_PROCESS_ERR_TRANS* = 13832 + ERROR_IPSEC_IKE_PROCESS_ERR_KE* = 13833 + ERROR_IPSEC_IKE_PROCESS_ERR_ID* = 13834 + ERROR_IPSEC_IKE_PROCESS_ERR_CERT* = 13835 + ERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQ* = 13836 + ERROR_IPSEC_IKE_PROCESS_ERR_HASH* = 13837 + ERROR_IPSEC_IKE_PROCESS_ERR_SIG* = 13838 + ERROR_IPSEC_IKE_PROCESS_ERR_NONCE* = 13839 + ERROR_IPSEC_IKE_PROCESS_ERR_NOTIFY* = 13840 + ERROR_IPSEC_IKE_PROCESS_ERR_DELETE* = 13841 + ERROR_IPSEC_IKE_PROCESS_ERR_VENDOR* = 13842 + ERROR_IPSEC_IKE_INVALID_PAYLOAD* = 13843 + ERROR_IPSEC_IKE_LOAD_SOFT_SA* = 13844 + ERROR_IPSEC_IKE_SOFT_SA_TORN_DOWN* = 13845 + ERROR_IPSEC_IKE_INVALID_COOKIE* = 13846 + ERROR_IPSEC_IKE_NO_PEER_CERT* = 13847 + ERROR_IPSEC_IKE_PEER_CRL_FAILED* = 13848 + ERROR_IPSEC_IKE_POLICY_CHANGE* = 13849 + ERROR_IPSEC_IKE_NO_MM_POLICY* = 13850 + ERROR_IPSEC_IKE_NOTCBPRIV* = 13851 + ERROR_IPSEC_IKE_SECLOADFAIL* = 13852 + ERROR_IPSEC_IKE_FAILSSPINIT* = 13853 + ERROR_IPSEC_IKE_FAILQUERYSSP* = 13854 + ERROR_IPSEC_IKE_SRVACQFAIL* = 13855 + ERROR_IPSEC_IKE_SRVQUERYCRED* = 13856 + ERROR_IPSEC_IKE_GETSPIFAIL* = 13857 + ERROR_IPSEC_IKE_INVALID_FILTER* = 13858 + ERROR_IPSEC_IKE_OUT_OF_MEMORY* = 13859 + ERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED* = 13860 + ERROR_IPSEC_IKE_INVALID_POLICY* = 13861 + ERROR_IPSEC_IKE_UNKNOWN_DOI* = 13862 + ERROR_IPSEC_IKE_INVALID_SITUATION* = 13863 + ERROR_IPSEC_IKE_DH_FAILURE* = 13864 + ERROR_IPSEC_IKE_INVALID_GROUP* = 13865 + ERROR_IPSEC_IKE_ENCRYPT* = 13866 + ERROR_IPSEC_IKE_DECRYPT* = 13867 + ERROR_IPSEC_IKE_POLICY_MATCH* = 13868 + ERROR_IPSEC_IKE_UNSUPPORTED_ID* = 13869 + ERROR_IPSEC_IKE_INVALID_HASH* = 13870 + ERROR_IPSEC_IKE_INVALID_HASH_ALG* = 13871 + ERROR_IPSEC_IKE_INVALID_HASH_SIZE* = 13872 + ERROR_IPSEC_IKE_INVALID_ENCRYPT_ALG* = 13873 + ERROR_IPSEC_IKE_INVALID_AUTH_ALG* = 13874 + ERROR_IPSEC_IKE_INVALID_SIG* = 13875 + ERROR_IPSEC_IKE_LOAD_FAILED* = 13876 + ERROR_IPSEC_IKE_RPC_DELETE* = 13877 + ERROR_IPSEC_IKE_BENIGN_REINIT* = 13878 + ERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY* = 13879 + ERROR_IPSEC_IKE_INVALID_CERT_KEYLEN* = 13881 + ERROR_IPSEC_IKE_MM_LIMIT* = 13882 + ERROR_IPSEC_IKE_NEGOTIATION_DISABLED* = 13883 + ERROR_IPSEC_IKE_QM_LIMIT* = 13884 + ERROR_IPSEC_IKE_MM_EXPIRED* = 13885 + ERROR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID* = 13886 + ERROR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH* = 13887 + ERROR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID* = 13888 + ERROR_IPSEC_IKE_INVALID_AUTH_PAYLOAD* = 13889 + ERROR_IPSEC_IKE_DOS_COOKIE_SENT* = 13890 + ERROR_IPSEC_IKE_SHUTTING_DOWN* = 13891 + ERROR_IPSEC_IKE_CGA_AUTH_FAILED* = 13892 + ERROR_IPSEC_IKE_PROCESS_ERR_NATOA* = 13893 + ERROR_IPSEC_IKE_INVALID_MM_FOR_QM* = 13894 + ERROR_IPSEC_IKE_QM_EXPIRED* = 13895 + ERROR_IPSEC_IKE_TOO_MANY_FILTERS* = 13896 + ERROR_IPSEC_IKE_NEG_STATUS_END* = 13897 + ERROR_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL* = 13898 + ERROR_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE* = 13899 + ERROR_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING* = 13900 + ERROR_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING* = 13901 + ERROR_IPSEC_IKE_COEXISTENCE_SUPPRESS* = 13902 + ERROR_IPSEC_IKE_RATELIMIT_DROP* = 13903 + ERROR_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE* = 13904 + ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE* = 13905 + ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE* = 13906 + ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY* = 13907 + ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE* = 13908 + ERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_END* = 13909 + ERROR_IPSEC_BAD_SPI* = 13910 + ERROR_IPSEC_SA_LIFETIME_EXPIRED* = 13911 + ERROR_IPSEC_WRONG_SA* = 13912 + ERROR_IPSEC_REPLAY_CHECK_FAILED* = 13913 + ERROR_IPSEC_INVALID_PACKET* = 13914 + ERROR_IPSEC_INTEGRITY_CHECK_FAILED* = 13915 + ERROR_IPSEC_CLEAR_TEXT_DROP* = 13916 + ERROR_IPSEC_AUTH_FIREWALL_DROP* = 13917 + ERROR_IPSEC_THROTTLE_DROP* = 13918 + ERROR_IPSEC_DOSP_BLOCK* = 13925 + ERROR_IPSEC_DOSP_RECEIVED_MULTICAST* = 13926 + ERROR_IPSEC_DOSP_INVALID_PACKET* = 13927 + ERROR_IPSEC_DOSP_STATE_LOOKUP_FAILED* = 13928 + ERROR_IPSEC_DOSP_MAX_ENTRIES* = 13929 + ERROR_IPSEC_DOSP_KEYMOD_NOT_ALLOWED* = 13930 + ERROR_IPSEC_DOSP_NOT_INSTALLED* = 13931 + ERROR_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES* = 13932 + ERROR_EVT_INVALID_CHANNEL_PATH* = 15000 + ERROR_EVT_INVALID_QUERY* = 15001 + ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND* = 15002 + ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND* = 15003 + ERROR_EVT_INVALID_PUBLISHER_NAME* = 15004 + ERROR_EVT_INVALID_EVENT_DATA* = 15005 + ERROR_EVT_CHANNEL_NOT_FOUND* = 15007 + ERROR_EVT_MALFORMED_XML_TEXT* = 15008 + ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL* = 15009 + ERROR_EVT_CONFIGURATION_ERROR* = 15010 + ERROR_EVT_QUERY_RESULT_STALE* = 15011 + ERROR_EVT_QUERY_RESULT_INVALID_POSITION* = 15012 + ERROR_EVT_NON_VALIDATING_MSXML* = 15013 + ERROR_EVT_FILTER_ALREADYSCOPED* = 15014 + ERROR_EVT_FILTER_NOTELTSET* = 15015 + ERROR_EVT_FILTER_INVARG* = 15016 + ERROR_EVT_FILTER_INVTEST* = 15017 + ERROR_EVT_FILTER_INVTYPE* = 15018 + ERROR_EVT_FILTER_PARSEERR* = 15019 + ERROR_EVT_FILTER_UNSUPPORTEDOP* = 15020 + ERROR_EVT_FILTER_UNEXPECTEDTOKEN* = 15021 + ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL* = 15022 + ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE* = 15023 + ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE* = 15024 + ERROR_EVT_CHANNEL_CANNOT_ACTIVATE* = 15025 + ERROR_EVT_FILTER_TOO_COMPLEX* = 15026 + ERROR_EVT_MESSAGE_NOT_FOUND* = 15027 + ERROR_EVT_MESSAGE_ID_NOT_FOUND* = 15028 + ERROR_EVT_UNRESOLVED_VALUE_INSERT* = 15029 + ERROR_EVT_UNRESOLVED_PARAMETER_INSERT* = 15030 + ERROR_EVT_MAX_INSERTS_REACHED* = 15031 + ERROR_EVT_EVENT_DEFINITION_NOT_FOUND* = 15032 + ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND* = 15033 + ERROR_EVT_VERSION_TOO_OLD* = 15034 + ERROR_EVT_VERSION_TOO_NEW* = 15035 + ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY* = 15036 + ERROR_EVT_PUBLISHER_DISABLED* = 15037 + ERROR_EVT_FILTER_OUT_OF_RANGE* = 15038 + ERROR_EC_SUBSCRIPTION_CANNOT_ACTIVATE* = 15080 + ERROR_EC_LOG_DISABLED* = 15081 + ERROR_EC_CIRCULAR_FORWARDING* = 15082 + ERROR_EC_CREDSTORE_FULL* = 15083 + ERROR_EC_CRED_NOT_FOUND* = 15084 + ERROR_EC_NO_ACTIVE_CHANNEL* = 15085 + ERROR_MUI_FILE_NOT_FOUND* = 15100 + ERROR_MUI_INVALID_FILE* = 15101 + ERROR_MUI_INVALID_RC_CONFIG* = 15102 + ERROR_MUI_INVALID_LOCALE_NAME* = 15103 + ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME* = 15104 + ERROR_MUI_FILE_NOT_LOADED* = 15105 + ERROR_RESOURCE_ENUM_USER_STOP* = 15106 + ERROR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED* = 15107 + ERROR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME* = 15108 + ERROR_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE* = 15110 + ERROR_MRM_INVALID_PRICONFIG* = 15111 + ERROR_MRM_INVALID_FILE_TYPE* = 15112 + ERROR_MRM_UNKNOWN_QUALIFIER* = 15113 + ERROR_MRM_INVALID_QUALIFIER_VALUE* = 15114 + ERROR_MRM_NO_CANDIDATE* = 15115 + ERROR_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE* = 15116 + ERROR_MRM_RESOURCE_TYPE_MISMATCH* = 15117 + ERROR_MRM_DUPLICATE_MAP_NAME* = 15118 + ERROR_MRM_DUPLICATE_ENTRY* = 15119 + ERROR_MRM_INVALID_RESOURCE_IDENTIFIER* = 15120 + ERROR_MRM_FILEPATH_TOO_LONG* = 15121 + ERROR_MRM_UNSUPPORTED_DIRECTORY_TYPE* = 15122 + ERROR_MRM_INVALID_PRI_FILE* = 15126 + ERROR_MRM_NAMED_RESOURCE_NOT_FOUND* = 15127 + ERROR_MRM_MAP_NOT_FOUND* = 15135 + ERROR_MRM_UNSUPPORTED_PROFILE_TYPE* = 15136 + ERROR_MRM_INVALID_QUALIFIER_OPERATOR* = 15137 + ERROR_MRM_INDETERMINATE_QUALIFIER_VALUE* = 15138 + ERROR_MRM_AUTOMERGE_ENABLED* = 15139 + ERROR_MRM_TOO_MANY_RESOURCES* = 15140 + ERROR_MCA_INVALID_CAPABILITIES_STRING* = 15200 + ERROR_MCA_INVALID_VCP_VERSION* = 15201 + ERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION* = 15202 + ERROR_MCA_MCCS_VERSION_MISMATCH* = 15203 + ERROR_MCA_UNSUPPORTED_MCCS_VERSION* = 15204 + ERROR_MCA_INTERNAL_ERROR* = 15205 + ERROR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED* = 15206 + ERROR_MCA_UNSUPPORTED_COLOR_TEMPERATURE* = 15207 + ERROR_AMBIGUOUS_SYSTEM_DEVICE* = 15250 + ERROR_SYSTEM_DEVICE_NOT_FOUND* = 15299 + ERROR_HASH_NOT_SUPPORTED* = 15300 + ERROR_HASH_NOT_PRESENT* = 15301 + ERROR_SECONDARY_IC_PROVIDER_NOT_REGISTERED* = 15321 + ERROR_GPIO_CLIENT_INFORMATION_INVALID* = 15322 + ERROR_GPIO_VERSION_NOT_SUPPORTED* = 15323 + ERROR_GPIO_INVALID_REGISTRATION_PACKET* = 15324 + ERROR_GPIO_OPERATION_DENIED* = 15325 + ERROR_GPIO_INCOMPATIBLE_CONNECT_MODE* = 15326 + ERROR_GPIO_INTERRUPT_ALREADY_UNMASKED* = 15327 + ERROR_CANNOT_SWITCH_RUNLEVEL* = 15400 + ERROR_INVALID_RUNLEVEL_SETTING* = 15401 + ERROR_RUNLEVEL_SWITCH_TIMEOUT* = 15402 + ERROR_RUNLEVEL_SWITCH_AGENT_TIMEOUT* = 15403 + ERROR_RUNLEVEL_SWITCH_IN_PROGRESS* = 15404 + ERROR_SERVICES_FAILED_AUTOSTART* = 15405 + ERROR_COM_TASK_STOP_PENDING* = 15501 + ERROR_INSTALL_OPEN_PACKAGE_FAILED* = 15600 + ERROR_INSTALL_PACKAGE_NOT_FOUND* = 15601 + ERROR_INSTALL_INVALID_PACKAGE* = 15602 + ERROR_INSTALL_RESOLVE_DEPENDENCY_FAILED* = 15603 + ERROR_INSTALL_OUT_OF_DISK_SPACE* = 15604 + ERROR_INSTALL_NETWORK_FAILURE* = 15605 + ERROR_INSTALL_REGISTRATION_FAILURE* = 15606 + ERROR_INSTALL_DEREGISTRATION_FAILURE* = 15607 + ERROR_INSTALL_CANCEL* = 15608 + ERROR_INSTALL_FAILED* = 15609 + ERROR_REMOVE_FAILED* = 15610 + ERROR_PACKAGE_ALREADY_EXISTS* = 15611 + ERROR_NEEDS_REMEDIATION* = 15612 + ERROR_INSTALL_PREREQUISITE_FAILED* = 15613 + ERROR_PACKAGE_REPOSITORY_CORRUPTED* = 15614 + ERROR_INSTALL_POLICY_FAILURE* = 15615 + ERROR_PACKAGE_UPDATING* = 15616 + ERROR_DEPLOYMENT_BLOCKED_BY_POLICY* = 15617 + ERROR_PACKAGES_IN_USE* = 15618 + ERROR_RECOVERY_FILE_CORRUPT* = 15619 + ERROR_INVALID_STAGED_SIGNATURE* = 15620 + ERROR_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED* = 15621 + ERROR_INSTALL_PACKAGE_DOWNGRADE* = 15622 + ERROR_SYSTEM_NEEDS_REMEDIATION* = 15623 + ERROR_APPX_INTEGRITY_FAILURE_CLR_NGEN* = 15624 + ERROR_RESILIENCY_FILE_CORRUPT* = 15625 + ERROR_INSTALL_FIREWALL_SERVICE_NOT_RUNNING* = 15626 + APPMODEL_ERROR_NO_PACKAGE* = 15700 + APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT* = 15701 + APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT* = 15702 + APPMODEL_ERROR_NO_APPLICATION* = 15703 + ERROR_STATE_LOAD_STORE_FAILED* = 15800 + ERROR_STATE_GET_VERSION_FAILED* = 15801 + ERROR_STATE_SET_VERSION_FAILED* = 15802 + ERROR_STATE_STRUCTURED_RESET_FAILED* = 15803 + ERROR_STATE_OPEN_CONTAINER_FAILED* = 15804 + ERROR_STATE_CREATE_CONTAINER_FAILED* = 15805 + ERROR_STATE_DELETE_CONTAINER_FAILED* = 15806 + ERROR_STATE_READ_SETTING_FAILED* = 15807 + ERROR_STATE_WRITE_SETTING_FAILED* = 15808 + ERROR_STATE_DELETE_SETTING_FAILED* = 15809 + ERROR_STATE_QUERY_SETTING_FAILED* = 15810 + ERROR_STATE_READ_COMPOSITE_SETTING_FAILED* = 15811 + ERROR_STATE_WRITE_COMPOSITE_SETTING_FAILED* = 15812 + ERROR_STATE_ENUMERATE_CONTAINER_FAILED* = 15813 + ERROR_STATE_ENUMERATE_SETTINGS_FAILED* = 15814 + ERROR_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED* = 15815 + ERROR_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED* = 15816 + ERROR_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED* = 15817 + ERROR_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED* = 15818 + ERROR_API_UNAVAILABLE* = 15841 + SEVERITY_SUCCESS* = 0 + SEVERITY_ERROR* = 1 + FACILITY_NT_BIT* = 0x10000000 + E_UNEXPECTED* = HRESULT 0x8000FFFF'i32 + E_NOTIMPL* = HRESULT 0x80004001'i32 + E_OUTOFMEMORY* = HRESULT 0x8007000E'i32 + E_INVALIDARG* = HRESULT 0x80070057'i32 + E_NOINTERFACE* = HRESULT 0x80004002'i32 + E_POINTER* = HRESULT 0x80004003'i32 + E_HANDLE* = HRESULT 0x80070006'i32 + E_ABORT* = HRESULT 0x80004004'i32 + E_FAIL* = HRESULT 0x80004005'i32 + E_ACCESSDENIED* = HRESULT 0x80070005'i32 + E_PENDING* = HRESULT 0x8000000A'i32 +template HRESULT_FROM_WIN32*(x: untyped): HRESULT = (if x <= 0: HRESULT x else: HRESULT(x and 0x0000ffff) or HRESULT(FACILITY_WIN32 shl 16) or HRESULT(0x80000000'i32)) +const + E_NOT_SUFFICIENT_BUFFER* = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) + CO_E_INIT_TLS* = HRESULT 0x80004006'i32 + CO_E_INIT_SHARED_ALLOCATOR* = HRESULT 0x80004007'i32 + CO_E_INIT_MEMORY_ALLOCATOR* = HRESULT 0x80004008'i32 + CO_E_INIT_CLASS_CACHE* = HRESULT 0x80004009'i32 + CO_E_INIT_RPC_CHANNEL* = HRESULT 0x8000400A'i32 + CO_E_INIT_TLS_SET_CHANNEL_CONTROL* = HRESULT 0x8000400B'i32 + CO_E_INIT_TLS_CHANNEL_CONTROL* = HRESULT 0x8000400C'i32 + CO_E_INIT_UNACCEPTED_USER_ALLOCATOR* = HRESULT 0x8000400D'i32 + CO_E_INIT_SCM_MUTEX_EXISTS* = HRESULT 0x8000400E'i32 + CO_E_INIT_SCM_FILE_MAPPING_EXISTS* = HRESULT 0x8000400F'i32 + CO_E_INIT_SCM_MAP_VIEW_OF_FILE* = HRESULT 0x80004010'i32 + CO_E_INIT_SCM_EXEC_FAILURE* = HRESULT 0x80004011'i32 + CO_E_INIT_ONLY_SINGLE_THREADED* = HRESULT 0x80004012'i32 + CO_E_CANT_REMOTE* = HRESULT 0x80004013'i32 + CO_E_BAD_SERVER_NAME* = HRESULT 0x80004014'i32 + CO_E_WRONG_SERVER_IDENTITY* = HRESULT 0x80004015'i32 + CO_E_OLE1DDE_DISABLED* = HRESULT 0x80004016'i32 + CO_E_RUNAS_SYNTAX* = HRESULT 0x80004017'i32 + CO_E_CREATEPROCESS_FAILURE* = HRESULT 0x80004018'i32 + CO_E_RUNAS_CREATEPROCESS_FAILURE* = HRESULT 0x80004019'i32 + CO_E_RUNAS_LOGON_FAILURE* = HRESULT 0x8000401A'i32 + CO_E_LAUNCH_PERMSSION_DENIED* = HRESULT 0x8000401B'i32 + CO_E_START_SERVICE_FAILURE* = HRESULT 0x8000401C'i32 + CO_E_REMOTE_COMMUNICATION_FAILURE* = HRESULT 0x8000401D'i32 + CO_E_SERVER_START_TIMEOUT* = HRESULT 0x8000401E'i32 + CO_E_CLSREG_INCONSISTENT* = HRESULT 0x8000401F'i32 + CO_E_IIDREG_INCONSISTENT* = HRESULT 0x80004020'i32 + CO_E_NOT_SUPPORTED* = HRESULT 0x80004021'i32 + CO_E_RELOAD_DLL* = HRESULT 0x80004022'i32 + CO_E_MSI_ERROR* = HRESULT 0x80004023'i32 + CO_E_ATTEMPT_TO_CREATE_OUTSIDE_CLIENT_CONTEXT* = HRESULT 0x80004024'i32 + CO_E_SERVER_PAUSED* = HRESULT 0x80004025'i32 + CO_E_SERVER_NOT_PAUSED* = HRESULT 0x80004026'i32 + CO_E_CLASS_DISABLED* = HRESULT 0x80004027'i32 + CO_E_CLRNOTAVAILABLE* = HRESULT 0x80004028'i32 + CO_E_ASYNC_WORK_REJECTED* = HRESULT 0x80004029'i32 + CO_E_SERVER_INIT_TIMEOUT* = HRESULT 0x8000402A'i32 + CO_E_NO_SECCTX_IN_ACTIVATE* = HRESULT 0x8000402B'i32 + CO_E_TRACKER_CONFIG* = HRESULT 0x80004030'i32 + CO_E_THREADPOOL_CONFIG* = HRESULT 0x80004031'i32 + CO_E_SXS_CONFIG* = HRESULT 0x80004032'i32 + CO_E_MALFORMED_SPN* = HRESULT 0x80004033'i32 + S_OK* = HRESULT 0x00000000 + S_FALSE* = HRESULT 0x00000001 + OLE_E_FIRST* = HRESULT 0x80040000'i32 + OLE_E_LAST* = HRESULT 0x800400FF'i32 + OLE_S_FIRST* = HRESULT 0x00040000 + OLE_S_LAST* = HRESULT 0x000400FF + OLE_E_OLEVERB* = HRESULT 0x80040000'i32 + OLE_E_ADVF* = HRESULT 0x80040001'i32 + OLE_E_ENUM_NOMORE* = HRESULT 0x80040002'i32 + OLE_E_ADVISENOTSUPPORTED* = HRESULT 0x80040003'i32 + OLE_E_NOCONNECTION* = HRESULT 0x80040004'i32 + OLE_E_NOTRUNNING* = HRESULT 0x80040005'i32 + OLE_E_NOCACHE* = HRESULT 0x80040006'i32 + OLE_E_BLANK* = HRESULT 0x80040007'i32 + OLE_E_CLASSDIFF* = HRESULT 0x80040008'i32 + OLE_E_CANT_GETMONIKER* = HRESULT 0x80040009'i32 + OLE_E_CANT_BINDTOSOURCE* = HRESULT 0x8004000A'i32 + OLE_E_STATIC* = HRESULT 0x8004000B'i32 + OLE_E_PROMPTSAVECANCELLED* = HRESULT 0x8004000C'i32 + OLE_E_INVALIDRECT* = HRESULT 0x8004000D'i32 + OLE_E_WRONGCOMPOBJ* = HRESULT 0x8004000E'i32 + OLE_E_INVALIDHWND* = HRESULT 0x8004000F'i32 + OLE_E_NOT_INPLACEACTIVE* = HRESULT 0x80040010'i32 + OLE_E_CANTCONVERT* = HRESULT 0x80040011'i32 + OLE_E_NOSTORAGE* = HRESULT 0x80040012'i32 + DV_E_FORMATETC* = HRESULT 0x80040064'i32 + DV_E_DVTARGETDEVICE* = HRESULT 0x80040065'i32 + DV_E_STGMEDIUM* = HRESULT 0x80040066'i32 + DV_E_STATDATA* = HRESULT 0x80040067'i32 + DV_E_LINDEX* = HRESULT 0x80040068'i32 + DV_E_TYMED* = HRESULT 0x80040069'i32 + DV_E_CLIPFORMAT* = HRESULT 0x8004006A'i32 + DV_E_DVASPECT* = HRESULT 0x8004006B'i32 + DV_E_DVTARGETDEVICE_SIZE* = HRESULT 0x8004006C'i32 + DV_E_NOIVIEWOBJECT* = HRESULT 0x8004006D'i32 + DRAGDROP_E_FIRST* = 0x80040100'i32 + DRAGDROP_E_LAST* = 0x8004010F'i32 + DRAGDROP_S_FIRST* = 0x00040100 + DRAGDROP_S_LAST* = 0x0004010F + DRAGDROP_E_NOTREGISTERED* = HRESULT 0x80040100'i32 + DRAGDROP_E_ALREADYREGISTERED* = HRESULT 0x80040101'i32 + DRAGDROP_E_INVALIDHWND* = HRESULT 0x80040102'i32 + CLASSFACTORY_E_FIRST* = 0x80040110'i32 + CLASSFACTORY_E_LAST* = 0x8004011F'i32 + CLASSFACTORY_S_FIRST* = 0x00040110 + CLASSFACTORY_S_LAST* = 0x0004011F + CLASS_E_NOAGGREGATION* = HRESULT 0x80040110'i32 + CLASS_E_CLASSNOTAVAILABLE* = HRESULT 0x80040111'i32 + CLASS_E_NOTLICENSED* = HRESULT 0x80040112'i32 + MARSHAL_E_FIRST* = 0x80040120'i32 + MARSHAL_E_LAST* = 0x8004012F'i32 + MARSHAL_S_FIRST* = 0x00040120 + MARSHAL_S_LAST* = 0x0004012F + DATA_E_FIRST* = 0x80040130'i32 + DATA_E_LAST* = 0x8004013F'i32 + DATA_S_FIRST* = 0x00040130 + DATA_S_LAST* = 0x0004013F + VIEW_E_FIRST* = 0x80040140'i32 + VIEW_E_LAST* = 0x8004014F'i32 + VIEW_S_FIRST* = 0x00040140 + VIEW_S_LAST* = 0x0004014F + VIEW_E_DRAW* = HRESULT 0x80040140'i32 + REGDB_E_FIRST* = 0x80040150'i32 + REGDB_E_LAST* = 0x8004015F'i32 + REGDB_S_FIRST* = 0x00040150 + REGDB_S_LAST* = 0x0004015F + REGDB_E_READREGDB* = HRESULT 0x80040150'i32 + REGDB_E_WRITEREGDB* = HRESULT 0x80040151'i32 + REGDB_E_KEYMISSING* = HRESULT 0x80040152'i32 + REGDB_E_INVALIDVALUE* = HRESULT 0x80040153'i32 + REGDB_E_CLASSNOTREG* = HRESULT 0x80040154'i32 + REGDB_E_IIDNOTREG* = HRESULT 0x80040155'i32 + REGDB_E_BADTHREADINGMODEL* = HRESULT 0x80040156'i32 + CAT_E_FIRST* = 0x80040160'i32 + CAT_E_LAST* = 0x80040161'i32 + CAT_E_CATIDNOEXIST* = HRESULT 0x80040160'i32 + CAT_E_NODESCRIPTION* = HRESULT 0x80040161'i32 + CS_E_FIRST* = 0x80040164'i32 + CS_E_LAST* = 0x8004016F'i32 + CS_E_PACKAGE_NOTFOUND* = HRESULT 0x80040164'i32 + CS_E_NOT_DELETABLE* = HRESULT 0x80040165'i32 + CS_E_CLASS_NOTFOUND* = HRESULT 0x80040166'i32 + CS_E_INVALID_VERSION* = HRESULT 0x80040167'i32 + CS_E_NO_CLASSSTORE* = HRESULT 0x80040168'i32 + CS_E_OBJECT_NOTFOUND* = HRESULT 0x80040169'i32 + CS_E_OBJECT_ALREADY_EXISTS* = HRESULT 0x8004016A'i32 + CS_E_INVALID_PATH* = HRESULT 0x8004016B'i32 + CS_E_NETWORK_ERROR* = HRESULT 0x8004016C'i32 + CS_E_ADMIN_LIMIT_EXCEEDED* = HRESULT 0x8004016D'i32 + CS_E_SCHEMA_MISMATCH* = HRESULT 0x8004016E'i32 + CS_E_INTERNAL_ERROR* = HRESULT 0x8004016F'i32 + CACHE_E_FIRST* = 0x80040170'i32 + CACHE_E_LAST* = 0x8004017F'i32 + CACHE_S_FIRST* = 0x00040170 + CACHE_S_LAST* = 0x0004017F + CACHE_E_NOCACHE_UPDATED* = HRESULT 0x80040170'i32 + OLEOBJ_E_FIRST* = 0x80040180'i32 + OLEOBJ_E_LAST* = 0x8004018F'i32 + OLEOBJ_S_FIRST* = 0x00040180 + OLEOBJ_S_LAST* = 0x0004018F + OLEOBJ_E_NOVERBS* = HRESULT 0x80040180'i32 + OLEOBJ_E_INVALIDVERB* = HRESULT 0x80040181'i32 + CLIENTSITE_E_FIRST* = 0x80040190'i32 + CLIENTSITE_E_LAST* = 0x8004019F'i32 + CLIENTSITE_S_FIRST* = 0x00040190 + CLIENTSITE_S_LAST* = 0x0004019F + INPLACE_E_NOTUNDOABLE* = HRESULT 0x800401A0'i32 + INPLACE_E_NOTOOLSPACE* = HRESULT 0x800401A1'i32 + INPLACE_E_FIRST* = 0x800401A0'i32 + INPLACE_E_LAST* = 0x800401AF'i32 + INPLACE_S_FIRST* = 0x000401A0 + INPLACE_S_LAST* = 0x000401AF + ENUM_E_FIRST* = 0x800401B0'i32 + ENUM_E_LAST* = 0x800401BF'i32 + ENUM_S_FIRST* = 0x000401B0 + ENUM_S_LAST* = 0x000401BF + CONVERT10_E_FIRST* = 0x800401C0'i32 + CONVERT10_E_LAST* = 0x800401CF'i32 + CONVERT10_S_FIRST* = 0x000401C0 + CONVERT10_S_LAST* = 0x000401CF + CONVERT10_E_OLESTREAM_GET* = HRESULT 0x800401C0'i32 + CONVERT10_E_OLESTREAM_PUT* = HRESULT 0x800401C1'i32 + CONVERT10_E_OLESTREAM_FMT* = HRESULT 0x800401C2'i32 + CONVERT10_E_OLESTREAM_BITMAP_TO_DIB* = HRESULT 0x800401C3'i32 + CONVERT10_E_STG_FMT* = HRESULT 0x800401C4'i32 + CONVERT10_E_STG_NO_STD_STREAM* = HRESULT 0x800401C5'i32 + CONVERT10_E_STG_DIB_TO_BITMAP* = HRESULT 0x800401C6'i32 + CLIPBRD_E_FIRST* = 0x800401D0'i32 + CLIPBRD_E_LAST* = 0x800401DF'i32 + CLIPBRD_S_FIRST* = 0x000401D0 + CLIPBRD_S_LAST* = 0x000401DF + CLIPBRD_E_CANT_OPEN* = HRESULT 0x800401D0'i32 + CLIPBRD_E_CANT_EMPTY* = HRESULT 0x800401D1'i32 + CLIPBRD_E_CANT_SET* = HRESULT 0x800401D2'i32 + CLIPBRD_E_BAD_DATA* = HRESULT 0x800401D3'i32 + CLIPBRD_E_CANT_CLOSE* = HRESULT 0x800401D4'i32 + MK_E_FIRST* = 0x800401E0'i32 + MK_E_LAST* = 0x800401EF'i32 + MK_S_FIRST* = 0x000401E0 + MK_S_LAST* = 0x000401EF + MK_E_CONNECTMANUALLY* = HRESULT 0x800401E0'i32 + MK_E_EXCEEDEDDEADLINE* = HRESULT 0x800401E1'i32 + MK_E_NEEDGENERIC* = HRESULT 0x800401E2'i32 + MK_E_UNAVAILABLE* = HRESULT 0x800401E3'i32 + MK_E_SYNTAX* = HRESULT 0x800401E4'i32 + MK_E_NOOBJECT* = HRESULT 0x800401E5'i32 + MK_E_INVALIDEXTENSION* = HRESULT 0x800401E6'i32 + MK_E_INTERMEDIATEINTERFACENOTSUPPORTED* = HRESULT 0x800401E7'i32 + MK_E_NOTBINDABLE* = HRESULT 0x800401E8'i32 + MK_E_NOTBOUND* = HRESULT 0x800401E9'i32 + MK_E_CANTOPENFILE* = HRESULT 0x800401EA'i32 + MK_E_MUSTBOTHERUSER* = HRESULT 0x800401EB'i32 + MK_E_NOINVERSE* = HRESULT 0x800401EC'i32 + MK_E_NOSTORAGE* = HRESULT 0x800401ED'i32 + MK_E_NOPREFIX* = HRESULT 0x800401EE'i32 + MK_E_ENUMERATION_FAILED* = HRESULT 0x800401EF'i32 + CO_E_FIRST* = 0x800401F0'i32 + CO_E_LAST* = 0x800401FF'i32 + CO_S_FIRST* = 0x000401F0 + CO_S_LAST* = 0x000401FF + CO_E_NOTINITIALIZED* = HRESULT 0x800401F0'i32 + CO_E_ALREADYINITIALIZED* = HRESULT 0x800401F1'i32 + CO_E_CANTDETERMINECLASS* = HRESULT 0x800401F2'i32 + CO_E_CLASSSTRING* = HRESULT 0x800401F3'i32 + CO_E_IIDSTRING* = HRESULT 0x800401F4'i32 + CO_E_APPNOTFOUND* = HRESULT 0x800401F5'i32 + CO_E_APPSINGLEUSE* = HRESULT 0x800401F6'i32 + CO_E_ERRORINAPP* = HRESULT 0x800401F7'i32 + CO_E_DLLNOTFOUND* = HRESULT 0x800401F8'i32 + CO_E_ERRORINDLL* = HRESULT 0x800401F9'i32 + CO_E_WRONGOSFORAPP* = HRESULT 0x800401FA'i32 + CO_E_OBJNOTREG* = HRESULT 0x800401FB'i32 + CO_E_OBJISREG* = HRESULT 0x800401FC'i32 + CO_E_OBJNOTCONNECTED* = HRESULT 0x800401FD'i32 + CO_E_APPDIDNTREG* = HRESULT 0x800401FE'i32 + CO_E_RELEASED* = HRESULT 0x800401FF'i32 + EVENT_E_FIRST* = 0x80040200'i32 + EVENT_E_LAST* = 0x8004021F'i32 + EVENT_S_FIRST* = 0x00040200 + EVENT_S_LAST* = 0x0004021F + EVENT_S_SOME_SUBSCRIBERS_FAILED* = HRESULT 0x00040200 + EVENT_E_ALL_SUBSCRIBERS_FAILED* = HRESULT 0x80040201'i32 + EVENT_S_NOSUBSCRIBERS* = HRESULT 0x00040202 + EVENT_E_QUERYSYNTAX* = HRESULT 0x80040203'i32 + EVENT_E_QUERYFIELD* = HRESULT 0x80040204'i32 + EVENT_E_INTERNALEXCEPTION* = HRESULT 0x80040205'i32 + EVENT_E_INTERNALERROR* = HRESULT 0x80040206'i32 + EVENT_E_INVALID_PER_USER_SID* = HRESULT 0x80040207'i32 + EVENT_E_USER_EXCEPTION* = HRESULT 0x80040208'i32 + EVENT_E_TOO_MANY_METHODS* = HRESULT 0x80040209'i32 + EVENT_E_MISSING_EVENTCLASS* = HRESULT 0x8004020A'i32 + EVENT_E_NOT_ALL_REMOVED* = HRESULT 0x8004020B'i32 + EVENT_E_COMPLUS_NOT_INSTALLED* = HRESULT 0x8004020C'i32 + EVENT_E_CANT_MODIFY_OR_DELETE_UNCONFIGURED_OBJECT* = HRESULT 0x8004020D'i32 + EVENT_E_CANT_MODIFY_OR_DELETE_CONFIGURED_OBJECT* = HRESULT 0x8004020E'i32 + EVENT_E_INVALID_EVENT_CLASS_PARTITION* = HRESULT 0x8004020F'i32 + EVENT_E_PER_USER_SID_NOT_LOGGED_ON* = HRESULT 0x80040210'i32 + XACT_E_FIRST* = 0x8004D000'i32 + XACT_E_LAST* = 0x8004D029'i32 + XACT_S_FIRST* = 0x0004D000 + XACT_S_LAST* = 0x0004D010 + XACT_E_ALREADYOTHERSINGLEPHASE* = HRESULT 0x8004D000'i32 + XACT_E_CANTRETAIN* = HRESULT 0x8004D001'i32 + XACT_E_COMMITFAILED* = HRESULT 0x8004D002'i32 + XACT_E_COMMITPREVENTED* = HRESULT 0x8004D003'i32 + XACT_E_HEURISTICABORT* = HRESULT 0x8004D004'i32 + XACT_E_HEURISTICCOMMIT* = HRESULT 0x8004D005'i32 + XACT_E_HEURISTICDAMAGE* = HRESULT 0x8004D006'i32 + XACT_E_HEURISTICDANGER* = HRESULT 0x8004D007'i32 + XACT_E_ISOLATIONLEVEL* = HRESULT 0x8004D008'i32 + XACT_E_NOASYNC* = HRESULT 0x8004D009'i32 + XACT_E_NOENLIST* = HRESULT 0x8004D00A'i32 + XACT_E_NOISORETAIN* = HRESULT 0x8004D00B'i32 + XACT_E_NORESOURCE* = HRESULT 0x8004D00C'i32 + XACT_E_NOTCURRENT* = HRESULT 0x8004D00D'i32 + XACT_E_NOTRANSACTION* = HRESULT 0x8004D00E'i32 + XACT_E_NOTSUPPORTED* = HRESULT 0x8004D00F'i32 + XACT_E_UNKNOWNRMGRID* = HRESULT 0x8004D010'i32 + XACT_E_WRONGSTATE* = HRESULT 0x8004D011'i32 + XACT_E_WRONGUOW* = HRESULT 0x8004D012'i32 + XACT_E_XTIONEXISTS* = HRESULT 0x8004D013'i32 + XACT_E_NOIMPORTOBJECT* = HRESULT 0x8004D014'i32 + XACT_E_INVALIDCOOKIE* = HRESULT 0x8004D015'i32 + XACT_E_INDOUBT* = HRESULT 0x8004D016'i32 + XACT_E_NOTIMEOUT* = HRESULT 0x8004D017'i32 + XACT_E_ALREADYINPROGRESS* = HRESULT 0x8004D018'i32 + XACT_E_ABORTED* = HRESULT 0x8004D019'i32 + XACT_E_LOGFULL* = HRESULT 0x8004D01A'i32 + XACT_E_TMNOTAVAILABLE* = HRESULT 0x8004D01B'i32 + XACT_E_CONNECTION_DOWN* = HRESULT 0x8004D01C'i32 + XACT_E_CONNECTION_DENIED* = HRESULT 0x8004D01D'i32 + XACT_E_REENLISTTIMEOUT* = HRESULT 0x8004D01E'i32 + XACT_E_TIP_CONNECT_FAILED* = HRESULT 0x8004D01F'i32 + XACT_E_TIP_PROTOCOL_ERROR* = HRESULT 0x8004D020'i32 + XACT_E_TIP_PULL_FAILED* = HRESULT 0x8004D021'i32 + XACT_E_DEST_TMNOTAVAILABLE* = HRESULT 0x8004D022'i32 + XACT_E_TIP_DISABLED* = HRESULT 0x8004D023'i32 + XACT_E_NETWORK_TX_DISABLED* = HRESULT 0x8004D024'i32 + XACT_E_PARTNER_NETWORK_TX_DISABLED* = HRESULT 0x8004D025'i32 + XACT_E_XA_TX_DISABLED* = HRESULT 0x8004D026'i32 + XACT_E_UNABLE_TO_READ_DTC_CONFIG* = HRESULT 0x8004D027'i32 + XACT_E_UNABLE_TO_LOAD_DTC_PROXY* = HRESULT 0x8004D028'i32 + XACT_E_ABORTING* = HRESULT 0x8004D029'i32 + XACT_E_CLERKNOTFOUND* = HRESULT 0x8004D080'i32 + XACT_E_CLERKEXISTS* = HRESULT 0x8004D081'i32 + XACT_E_RECOVERYINPROGRESS* = HRESULT 0x8004D082'i32 + XACT_E_TRANSACTIONCLOSED* = HRESULT 0x8004D083'i32 + XACT_E_INVALIDLSN* = HRESULT 0x8004D084'i32 + XACT_E_REPLAYREQUEST* = HRESULT 0x8004D085'i32 + XACT_S_ASYNC* = HRESULT 0x0004D000 + XACT_S_DEFECT* = HRESULT 0x0004D001 + XACT_S_READONLY* = HRESULT 0x0004D002 + XACT_S_SOMENORETAIN* = HRESULT 0x0004D003 + XACT_S_OKINFORM* = HRESULT 0x0004D004 + XACT_S_MADECHANGESCONTENT* = HRESULT 0x0004D005 + XACT_S_MADECHANGESINFORM* = HRESULT 0x0004D006 + XACT_S_ALLNORETAIN* = HRESULT 0x0004D007 + XACT_S_ABORTING* = HRESULT 0x0004D008 + XACT_S_SINGLEPHASE* = HRESULT 0x0004D009 + XACT_S_LOCALLY_OK* = HRESULT 0x0004D00A + XACT_S_LASTRESOURCEMANAGER* = HRESULT 0x0004D010 + CONTEXT_E_FIRST* = 0x8004E000'i32 + CONTEXT_E_LAST* = 0x8004E02F'i32 + CONTEXT_S_FIRST* = 0x0004E000 + CONTEXT_S_LAST* = 0x0004E02F + CONTEXT_E_ABORTED* = HRESULT 0x8004E002'i32 + CONTEXT_E_ABORTING* = HRESULT 0x8004E003'i32 + CONTEXT_E_NOCONTEXT* = HRESULT 0x8004E004'i32 + CONTEXT_E_WOULD_DEADLOCK* = HRESULT 0x8004E005'i32 + CONTEXT_E_SYNCH_TIMEOUT* = HRESULT 0x8004E006'i32 + CONTEXT_E_OLDREF* = HRESULT 0x8004E007'i32 + CONTEXT_E_ROLENOTFOUND* = HRESULT 0x8004E00C'i32 + CONTEXT_E_TMNOTAVAILABLE* = HRESULT 0x8004E00F'i32 + CO_E_ACTIVATIONFAILED* = HRESULT 0x8004E021'i32 + CO_E_ACTIVATIONFAILED_EVENTLOGGED* = HRESULT 0x8004E022'i32 + CO_E_ACTIVATIONFAILED_CATALOGERROR* = HRESULT 0x8004E023'i32 + CO_E_ACTIVATIONFAILED_TIMEOUT* = HRESULT 0x8004E024'i32 + CO_E_INITIALIZATIONFAILED* = HRESULT 0x8004E025'i32 + CONTEXT_E_NOJIT* = HRESULT 0x8004E026'i32 + CONTEXT_E_NOTRANSACTION* = HRESULT 0x8004E027'i32 + CO_E_THREADINGMODEL_CHANGED* = HRESULT 0x8004E028'i32 + CO_E_NOIISINTRINSICS* = HRESULT 0x8004E029'i32 + CO_E_NOCOOKIES* = HRESULT 0x8004E02A'i32 + CO_E_DBERROR* = HRESULT 0x8004E02B'i32 + CO_E_NOTPOOLED* = HRESULT 0x8004E02C'i32 + CO_E_NOTCONSTRUCTED* = HRESULT 0x8004E02D'i32 + CO_E_NOSYNCHRONIZATION* = HRESULT 0x8004E02E'i32 + CO_E_ISOLEVELMISMATCH* = HRESULT 0x8004E02F'i32 + OLE_S_USEREG* = HRESULT 0x00040000 + OLE_S_STATIC* = HRESULT 0x00040001 + OLE_S_MAC_CLIPFORMAT* = HRESULT 0x00040002 + DRAGDROP_S_DROP* = HRESULT 0x00040100 + DRAGDROP_S_CANCEL* = HRESULT 0x00040101 + DRAGDROP_S_USEDEFAULTCURSORS* = HRESULT 0x00040102 + DATA_S_SAMEFORMATETC* = HRESULT 0x00040130 + VIEW_S_ALREADY_FROZEN* = HRESULT 0x00040140 + CACHE_S_FORMATETC_NOTSUPPORTED* = HRESULT 0x00040170 + CACHE_S_SAMECACHE* = HRESULT 0x00040171 + CACHE_S_SOMECACHES_NOTUPDATED* = HRESULT 0x00040172 + OLEOBJ_S_INVALIDVERB* = HRESULT 0x00040180 + OLEOBJ_S_CANNOT_DOVERB_NOW* = HRESULT 0x00040181 + OLEOBJ_S_INVALIDHWND* = HRESULT 0x00040182 + INPLACE_S_TRUNCATED* = HRESULT 0x000401A0 + CONVERT10_S_NO_PRESENTATION* = HRESULT 0x000401C0 + MK_S_REDUCED_TO_SELF* = HRESULT 0x000401E2 + MK_S_ME* = HRESULT 0x000401E4 + MK_S_HIM* = HRESULT 0x000401E5 + MK_S_US* = HRESULT 0x000401E6 + MK_S_MONIKERALREADYREGISTERED* = HRESULT 0x000401E7 + SCHED_S_TASK_READY* = HRESULT 0x00041300 + SCHED_S_TASK_RUNNING* = HRESULT 0x00041301 + SCHED_S_TASK_DISABLED* = HRESULT 0x00041302 + SCHED_S_TASK_HAS_NOT_RUN* = HRESULT 0x00041303 + SCHED_S_TASK_NO_MORE_RUNS* = HRESULT 0x00041304 + SCHED_S_TASK_NOT_SCHEDULED* = HRESULT 0x00041305 + SCHED_S_TASK_TERMINATED* = HRESULT 0x00041306 + SCHED_S_TASK_NO_VALID_TRIGGERS* = HRESULT 0x00041307 + SCHED_S_EVENT_TRIGGER* = HRESULT 0x00041308 + SCHED_E_TRIGGER_NOT_FOUND* = HRESULT 0x80041309'i32 + SCHED_E_TASK_NOT_READY* = HRESULT 0x8004130A'i32 + SCHED_E_TASK_NOT_RUNNING* = HRESULT 0x8004130B'i32 + SCHED_E_SERVICE_NOT_INSTALLED* = HRESULT 0x8004130C'i32 + SCHED_E_CANNOT_OPEN_TASK* = HRESULT 0x8004130D'i32 + SCHED_E_INVALID_TASK* = HRESULT 0x8004130E'i32 + SCHED_E_ACCOUNT_INFORMATION_NOT_SET* = HRESULT 0x8004130F'i32 + SCHED_E_ACCOUNT_NAME_NOT_FOUND* = HRESULT 0x80041310'i32 + SCHED_E_ACCOUNT_DBASE_CORRUPT* = HRESULT 0x80041311'i32 + SCHED_E_NO_SECURITY_SERVICES* = HRESULT 0x80041312'i32 + SCHED_E_UNKNOWN_OBJECT_VERSION* = HRESULT 0x80041313'i32 + SCHED_E_UNSUPPORTED_ACCOUNT_OPTION* = HRESULT 0x80041314'i32 + SCHED_E_SERVICE_NOT_RUNNING* = HRESULT 0x80041315'i32 + CO_E_CLASS_CREATE_FAILED* = HRESULT 0x80080001'i32 + CO_E_SCM_ERROR* = HRESULT 0x80080002'i32 + CO_E_SCM_RPC_FAILURE* = HRESULT 0x80080003'i32 + CO_E_BAD_PATH* = HRESULT 0x80080004'i32 + CO_E_SERVER_EXEC_FAILURE* = HRESULT 0x80080005'i32 + CO_E_OBJSRV_RPC_FAILURE* = HRESULT 0x80080006'i32 + MK_E_NO_NORMALIZED* = HRESULT 0x80080007'i32 + CO_E_SERVER_STOPPING* = HRESULT 0x80080008'i32 + MEM_E_INVALID_ROOT* = HRESULT 0x80080009'i32 + MEM_E_INVALID_LINK* = HRESULT 0x80080010'i32 + MEM_E_INVALID_SIZE* = HRESULT 0x80080011'i32 + CO_S_NOTALLINTERFACES* = HRESULT 0x00080012 + CO_S_MACHINENAMENOTFOUND* = HRESULT 0x00080013 + DISP_E_UNKNOWNINTERFACE* = HRESULT 0x80020001'i32 + DISP_E_MEMBERNOTFOUND* = HRESULT 0x80020003'i32 + DISP_E_PARAMNOTFOUND* = HRESULT 0x80020004'i32 + DISP_E_TYPEMISMATCH* = HRESULT 0x80020005'i32 + DISP_E_UNKNOWNNAME* = HRESULT 0x80020006'i32 + DISP_E_NONAMEDARGS* = HRESULT 0x80020007'i32 + DISP_E_BADVARTYPE* = HRESULT 0x80020008'i32 + DISP_E_EXCEPTION* = HRESULT 0x80020009'i32 + DISP_E_OVERFLOW* = HRESULT 0x8002000A'i32 + DISP_E_BADINDEX* = HRESULT 0x8002000B'i32 + DISP_E_UNKNOWNLCID* = HRESULT 0x8002000C'i32 + DISP_E_ARRAYISLOCKED* = HRESULT 0x8002000D'i32 + DISP_E_BADPARAMCOUNT* = HRESULT 0x8002000E'i32 + DISP_E_PARAMNOTOPTIONAL* = HRESULT 0x8002000F'i32 + DISP_E_BADCALLEE* = HRESULT 0x80020010'i32 + DISP_E_NOTACOLLECTION* = HRESULT 0x80020011'i32 + DISP_E_DIVBYZERO* = HRESULT 0x80020012'i32 + DISP_E_BUFFERTOOSMALL* = HRESULT 0x80020013'i32 + TYPE_E_BUFFERTOOSMALL* = HRESULT 0x80028016'i32 + TYPE_E_FIELDNOTFOUND* = HRESULT 0x80028017'i32 + TYPE_E_INVDATAREAD* = HRESULT 0x80028018'i32 + TYPE_E_UNSUPFORMAT* = HRESULT 0x80028019'i32 + TYPE_E_REGISTRYACCESS* = HRESULT 0x8002801C'i32 + TYPE_E_LIBNOTREGISTERED* = HRESULT 0x8002801D'i32 + TYPE_E_UNDEFINEDTYPE* = HRESULT 0x80028027'i32 + TYPE_E_QUALIFIEDNAMEDISALLOWED* = HRESULT 0x80028028'i32 + TYPE_E_INVALIDSTATE* = HRESULT 0x80028029'i32 + TYPE_E_WRONGTYPEKIND* = HRESULT 0x8002802A'i32 + TYPE_E_ELEMENTNOTFOUND* = HRESULT 0x8002802B'i32 + TYPE_E_AMBIGUOUSNAME* = HRESULT 0x8002802C'i32 + TYPE_E_NAMECONFLICT* = HRESULT 0x8002802D'i32 + TYPE_E_UNKNOWNLCID* = HRESULT 0x8002802E'i32 + TYPE_E_DLLFUNCTIONNOTFOUND* = HRESULT 0x8002802F'i32 + TYPE_E_BADMODULEKIND* = HRESULT 0x800288BD'i32 + TYPE_E_SIZETOOBIG* = HRESULT 0x800288C5'i32 + TYPE_E_DUPLICATEID* = HRESULT 0x800288C6'i32 + TYPE_E_INVALIDID* = HRESULT 0x800288CF'i32 + TYPE_E_TYPEMISMATCH* = HRESULT 0x80028CA0'i32 + TYPE_E_OUTOFBOUNDS* = HRESULT 0x80028CA1'i32 + TYPE_E_IOERROR* = HRESULT 0x80028CA2'i32 + TYPE_E_CANTCREATETMPFILE* = HRESULT 0x80028CA3'i32 + TYPE_E_CANTLOADLIBRARY* = HRESULT 0x80029C4A'i32 + TYPE_E_INCONSISTENTPROPFUNCS* = HRESULT 0x80029C83'i32 + TYPE_E_CIRCULARTYPE* = HRESULT 0x80029C84'i32 + STG_E_INVALIDFUNCTION* = HRESULT 0x80030001'i32 + STG_E_FILENOTFOUND* = HRESULT 0x80030002'i32 + STG_E_PATHNOTFOUND* = HRESULT 0x80030003'i32 + STG_E_TOOMANYOPENFILES* = HRESULT 0x80030004'i32 + STG_E_ACCESSDENIED* = HRESULT 0x80030005'i32 + STG_E_INVALIDHANDLE* = HRESULT 0x80030006'i32 + STG_E_INSUFFICIENTMEMORY* = HRESULT 0x80030008'i32 + STG_E_INVALIDPOINTER* = HRESULT 0x80030009'i32 + STG_E_NOMOREFILES* = HRESULT 0x80030012'i32 + STG_E_DISKISWRITEPROTECTED* = HRESULT 0x80030013'i32 + STG_E_SEEKERROR* = HRESULT 0x80030019'i32 + STG_E_WRITEFAULT* = HRESULT 0x8003001D'i32 + STG_E_READFAULT* = HRESULT 0x8003001E'i32 + STG_E_SHAREVIOLATION* = HRESULT 0x80030020'i32 + STG_E_LOCKVIOLATION* = HRESULT 0x80030021'i32 + STG_E_FILEALREADYEXISTS* = HRESULT 0x80030050'i32 + STG_E_INVALIDPARAMETER* = HRESULT 0x80030057'i32 + STG_E_MEDIUMFULL* = HRESULT 0x80030070'i32 + STG_E_PROPSETMISMATCHED* = HRESULT 0x800300F0'i32 + STG_E_ABNORMALAPIEXIT* = HRESULT 0x800300FA'i32 + STG_E_INVALIDHEADER* = HRESULT 0x800300FB'i32 + STG_E_INVALIDNAME* = HRESULT 0x800300FC'i32 + STG_E_UNKNOWN* = HRESULT 0x800300FD'i32 + STG_E_UNIMPLEMENTEDFUNCTION* = HRESULT 0x800300FE'i32 + STG_E_INVALIDFLAG* = HRESULT 0x800300FF'i32 + STG_E_INUSE* = HRESULT 0x80030100'i32 + STG_E_NOTCURRENT* = HRESULT 0x80030101'i32 + STG_E_REVERTED* = HRESULT 0x80030102'i32 + STG_E_CANTSAVE* = HRESULT 0x80030103'i32 + STG_E_OLDFORMAT* = HRESULT 0x80030104'i32 + STG_E_OLDDLL* = HRESULT 0x80030105'i32 + STG_E_SHAREREQUIRED* = HRESULT 0x80030106'i32 + STG_E_NOTFILEBASEDSTORAGE* = HRESULT 0x80030107'i32 + STG_E_EXTANTMARSHALLINGS* = HRESULT 0x80030108'i32 + STG_E_DOCFILECORRUPT* = HRESULT 0x80030109'i32 + STG_E_BADBASEADDRESS* = HRESULT 0x80030110'i32 + STG_E_DOCFILETOOLARGE* = HRESULT 0x80030111'i32 + STG_E_NOTSIMPLEFORMAT* = HRESULT 0x80030112'i32 + STG_E_INCOMPLETE* = HRESULT 0x80030201'i32 + STG_E_TERMINATED* = HRESULT 0x80030202'i32 + STG_S_CONVERTED* = HRESULT 0x00030200 + STG_S_BLOCK* = HRESULT 0x00030201 + STG_S_RETRYNOW* = HRESULT 0x00030202 + STG_S_MONITORING* = HRESULT 0x00030203 + STG_S_MULTIPLEOPENS* = HRESULT 0x00030204 + STG_S_CONSOLIDATIONFAILED* = HRESULT 0x00030205 + STG_S_CANNOTCONSOLIDATE* = HRESULT 0x00030206 + STG_E_STATUS_COPY_PROTECTION_FAILURE* = HRESULT 0x80030305'i32 + STG_E_CSS_AUTHENTICATION_FAILURE* = HRESULT 0x80030306'i32 + STG_E_CSS_KEY_NOT_PRESENT* = HRESULT 0x80030307'i32 + STG_E_CSS_KEY_NOT_ESTABLISHED* = HRESULT 0x80030308'i32 + STG_E_CSS_SCRAMBLED_SECTOR* = HRESULT 0x80030309'i32 + STG_E_CSS_REGION_MISMATCH* = HRESULT 0x8003030A'i32 + STG_E_RESETS_EXHAUSTED* = HRESULT 0x8003030B'i32 + RPC_E_CALL_REJECTED* = HRESULT 0x80010001'i32 + RPC_E_CALL_CANCELED* = HRESULT 0x80010002'i32 + RPC_E_CANTPOST_INSENDCALL* = HRESULT 0x80010003'i32 + RPC_E_CANTCALLOUT_INASYNCCALL* = HRESULT 0x80010004'i32 + RPC_E_CANTCALLOUT_INEXTERNALCALL* = HRESULT 0x80010005'i32 + RPC_E_CONNECTION_TERMINATED* = HRESULT 0x80010006'i32 + RPC_E_SERVER_DIED* = HRESULT 0x80010007'i32 + RPC_E_CLIENT_DIED* = HRESULT 0x80010008'i32 + RPC_E_INVALID_DATAPACKET* = HRESULT 0x80010009'i32 + RPC_E_CANTTRANSMIT_CALL* = HRESULT 0x8001000A'i32 + RPC_E_CLIENT_CANTMARSHAL_DATA* = HRESULT 0x8001000B'i32 + RPC_E_CLIENT_CANTUNMARSHAL_DATA* = HRESULT 0x8001000C'i32 + RPC_E_SERVER_CANTMARSHAL_DATA* = HRESULT 0x8001000D'i32 + RPC_E_SERVER_CANTUNMARSHAL_DATA* = HRESULT 0x8001000E'i32 + RPC_E_INVALID_DATA* = HRESULT 0x8001000F'i32 + RPC_E_INVALID_PARAMETER* = HRESULT 0x80010010'i32 + RPC_E_CANTCALLOUT_AGAIN* = HRESULT 0x80010011'i32 + RPC_E_SERVER_DIED_DNE* = HRESULT 0x80010012'i32 + RPC_E_SYS_CALL_FAILED* = HRESULT 0x80010100'i32 + RPC_E_OUT_OF_RESOURCES* = HRESULT 0x80010101'i32 + RPC_E_ATTEMPTED_MULTITHREAD* = HRESULT 0x80010102'i32 + RPC_E_NOT_REGISTERED* = HRESULT 0x80010103'i32 + RPC_E_FAULT* = HRESULT 0x80010104'i32 + RPC_E_SERVERFAULT* = HRESULT 0x80010105'i32 + RPC_E_CHANGED_MODE* = HRESULT 0x80010106'i32 + RPC_E_INVALIDMETHOD* = HRESULT 0x80010107'i32 + RPC_E_DISCONNECTED* = HRESULT 0x80010108'i32 + RPC_E_RETRY* = HRESULT 0x80010109'i32 + RPC_E_SERVERCALL_RETRYLATER* = HRESULT 0x8001010A'i32 + RPC_E_SERVERCALL_REJECTED* = HRESULT 0x8001010B'i32 + RPC_E_INVALID_CALLDATA* = HRESULT 0x8001010C'i32 + RPC_E_CANTCALLOUT_ININPUTSYNCCALL* = HRESULT 0x8001010D'i32 + RPC_E_WRONG_THREAD* = HRESULT 0x8001010E'i32 + RPC_E_THREAD_NOT_INIT* = HRESULT 0x8001010F'i32 + RPC_E_VERSION_MISMATCH* = HRESULT 0x80010110'i32 + RPC_E_INVALID_HEADER* = HRESULT 0x80010111'i32 + RPC_E_INVALID_EXTENSION* = HRESULT 0x80010112'i32 + RPC_E_INVALID_IPID* = HRESULT 0x80010113'i32 + RPC_E_INVALID_OBJECT* = HRESULT 0x80010114'i32 + RPC_S_CALLPENDING* = HRESULT 0x80010115'i32 + RPC_S_WAITONTIMER* = HRESULT 0x80010116'i32 + RPC_E_CALL_COMPLETE* = HRESULT 0x80010117'i32 + RPC_E_UNSECURE_CALL* = HRESULT 0x80010118'i32 + RPC_E_TOO_LATE* = HRESULT 0x80010119'i32 + RPC_E_NO_GOOD_SECURITY_PACKAGES* = HRESULT 0x8001011A'i32 + RPC_E_ACCESS_DENIED* = HRESULT 0x8001011B'i32 + RPC_E_REMOTE_DISABLED* = HRESULT 0x8001011C'i32 + RPC_E_INVALID_OBJREF* = HRESULT 0x8001011D'i32 + RPC_E_NO_CONTEXT* = HRESULT 0x8001011E'i32 + RPC_E_TIMEOUT* = HRESULT 0x8001011F'i32 + RPC_E_NO_SYNC* = HRESULT 0x80010120'i32 + RPC_E_FULLSIC_REQUIRED* = HRESULT 0x80010121'i32 + RPC_E_INVALID_STD_NAME* = HRESULT 0x80010122'i32 + CO_E_FAILEDTOIMPERSONATE* = HRESULT 0x80010123'i32 + CO_E_FAILEDTOGETSECCTX* = HRESULT 0x80010124'i32 + CO_E_FAILEDTOOPENTHREADTOKEN* = HRESULT 0x80010125'i32 + CO_E_FAILEDTOGETTOKENINFO* = HRESULT 0x80010126'i32 + CO_E_TRUSTEEDOESNTMATCHCLIENT* = HRESULT 0x80010127'i32 + CO_E_FAILEDTOQUERYCLIENTBLANKET* = HRESULT 0x80010128'i32 + CO_E_FAILEDTOSETDACL* = HRESULT 0x80010129'i32 + CO_E_ACCESSCHECKFAILED* = HRESULT 0x8001012A'i32 + CO_E_NETACCESSAPIFAILED* = HRESULT 0x8001012B'i32 + CO_E_WRONGTRUSTEENAMESYNTAX* = HRESULT 0x8001012C'i32 + CO_E_INVALIDSID* = HRESULT 0x8001012D'i32 + CO_E_CONVERSIONFAILED* = HRESULT 0x8001012E'i32 + CO_E_NOMATCHINGSIDFOUND* = HRESULT 0x8001012F'i32 + CO_E_LOOKUPACCSIDFAILED* = HRESULT 0x80010130'i32 + CO_E_NOMATCHINGNAMEFOUND* = HRESULT 0x80010131'i32 + CO_E_LOOKUPACCNAMEFAILED* = HRESULT 0x80010132'i32 + CO_E_SETSERLHNDLFAILED* = HRESULT 0x80010133'i32 + CO_E_FAILEDTOGETWINDIR* = HRESULT 0x80010134'i32 + CO_E_PATHTOOLONG* = HRESULT 0x80010135'i32 + CO_E_FAILEDTOGENUUID* = HRESULT 0x80010136'i32 + CO_E_FAILEDTOCREATEFILE* = HRESULT 0x80010137'i32 + CO_E_FAILEDTOCLOSEHANDLE* = HRESULT 0x80010138'i32 + CO_E_EXCEEDSYSACLLIMIT* = HRESULT 0x80010139'i32 + CO_E_ACESINWRONGORDER* = HRESULT 0x8001013A'i32 + CO_E_INCOMPATIBLESTREAMVERSION* = HRESULT 0x8001013B'i32 + CO_E_FAILEDTOOPENPROCESSTOKEN* = HRESULT 0x8001013C'i32 + CO_E_DECODEFAILED* = HRESULT 0x8001013D'i32 + CO_E_ACNOTINITIALIZED* = HRESULT 0x8001013F'i32 + CO_E_CANCEL_DISABLED* = HRESULT 0x80010140'i32 + RPC_E_UNEXPECTED* = HRESULT 0x8001FFFF'i32 + ERROR_AUDITING_DISABLED* = HRESULT 0xC0090001'i32 + ERROR_ALL_SIDS_FILTERED* = HRESULT 0xC0090002'i32 + NTE_BAD_UID* = HRESULT 0x80090001'i32 + NTE_BAD_HASH* = HRESULT 0x80090002'i32 + NTE_BAD_KEY* = HRESULT 0x80090003'i32 + NTE_BAD_LEN* = HRESULT 0x80090004'i32 + NTE_BAD_DATA* = HRESULT 0x80090005'i32 + NTE_BAD_SIGNATURE* = HRESULT 0x80090006'i32 + NTE_BAD_VER* = HRESULT 0x80090007'i32 + NTE_BAD_ALGID* = HRESULT 0x80090008'i32 + NTE_BAD_FLAGS* = HRESULT 0x80090009'i32 + NTE_BAD_TYPE* = HRESULT 0x8009000A'i32 + NTE_BAD_KEY_STATE* = HRESULT 0x8009000B'i32 + NTE_BAD_HASH_STATE* = HRESULT 0x8009000C'i32 + NTE_NO_KEY* = HRESULT 0x8009000D'i32 + NTE_NO_MEMORY* = HRESULT 0x8009000E'i32 + NTE_EXISTS* = HRESULT 0x8009000F'i32 + NTE_PERM* = HRESULT 0x80090010'i32 + NTE_NOT_FOUND* = HRESULT 0x80090011'i32 + NTE_DOUBLE_ENCRYPT* = HRESULT 0x80090012'i32 + NTE_BAD_PROVIDER* = HRESULT 0x80090013'i32 + NTE_BAD_PROV_TYPE* = HRESULT 0x80090014'i32 + NTE_BAD_PUBLIC_KEY* = HRESULT 0x80090015'i32 + NTE_BAD_KEYSET* = HRESULT 0x80090016'i32 + NTE_PROV_TYPE_NOT_DEF* = HRESULT 0x80090017'i32 + NTE_PROV_TYPE_ENTRY_BAD* = HRESULT 0x80090018'i32 + NTE_KEYSET_NOT_DEF* = HRESULT 0x80090019'i32 + NTE_KEYSET_ENTRY_BAD* = HRESULT 0x8009001A'i32 + NTE_PROV_TYPE_NO_MATCH* = HRESULT 0x8009001B'i32 + NTE_SIGNATURE_FILE_BAD* = HRESULT 0x8009001C'i32 + NTE_PROVIDER_DLL_FAIL* = HRESULT 0x8009001D'i32 + NTE_PROV_DLL_NOT_FOUND* = HRESULT 0x8009001E'i32 + NTE_BAD_KEYSET_PARAM* = HRESULT 0x8009001F'i32 + NTE_FAIL* = HRESULT 0x80090020'i32 + NTE_SYS_ERR* = HRESULT 0x80090021'i32 + NTE_SILENT_CONTEXT* = HRESULT 0x80090022'i32 + NTE_TOKEN_KEYSET_STORAGE_FULL* = HRESULT 0x80090023'i32 + NTE_TEMPORARY_PROFILE* = HRESULT 0x80090024'i32 + NTE_FIXEDPARAMETER* = HRESULT 0x80090025'i32 + SEC_E_INSUFFICIENT_MEMORY* = HRESULT 0x80090300'i32 + SEC_E_INVALID_HANDLE* = HRESULT 0x80090301'i32 + SEC_E_UNSUPPORTED_FUNCTION* = HRESULT 0x80090302'i32 + SEC_E_TARGET_UNKNOWN* = HRESULT 0x80090303'i32 + SEC_E_INTERNAL_ERROR* = HRESULT 0x80090304'i32 + SEC_E_SECPKG_NOT_FOUND* = HRESULT 0x80090305'i32 + SEC_E_NOT_OWNER* = HRESULT 0x80090306'i32 + SEC_E_CANNOT_INSTALL* = HRESULT 0x80090307'i32 + SEC_E_INVALID_TOKEN* = HRESULT 0x80090308'i32 + SEC_E_CANNOT_PACK* = HRESULT 0x80090309'i32 + SEC_E_QOP_NOT_SUPPORTED* = HRESULT 0x8009030A'i32 + SEC_E_NO_IMPERSONATION* = HRESULT 0x8009030B'i32 + SEC_E_LOGON_DENIED* = HRESULT 0x8009030C'i32 + SEC_E_UNKNOWN_CREDENTIALS* = HRESULT 0x8009030D'i32 + SEC_E_NO_CREDENTIALS* = HRESULT 0x8009030E'i32 + SEC_E_MESSAGE_ALTERED* = HRESULT 0x8009030F'i32 + SEC_E_OUT_OF_SEQUENCE* = HRESULT 0x80090310'i32 + SEC_E_NO_AUTHENTICATING_AUTHORITY* = HRESULT 0x80090311'i32 + SEC_I_CONTINUE_NEEDED* = HRESULT 0x00090312 + SEC_I_COMPLETE_NEEDED* = HRESULT 0x00090313 + SEC_I_COMPLETE_AND_CONTINUE* = HRESULT 0x00090314 + SEC_I_LOCAL_LOGON* = HRESULT 0x00090315 + SEC_E_BAD_PKGID* = HRESULT 0x80090316'i32 + SEC_E_CONTEXT_EXPIRED* = HRESULT 0x80090317'i32 + SEC_I_CONTEXT_EXPIRED* = HRESULT 0x00090317 + SEC_E_INCOMPLETE_MESSAGE* = HRESULT 0x80090318'i32 + SEC_E_INCOMPLETE_CREDENTIALS* = HRESULT 0x80090320'i32 + SEC_E_BUFFER_TOO_SMALL* = HRESULT 0x80090321'i32 + SEC_I_INCOMPLETE_CREDENTIALS* = HRESULT 0x00090320 + SEC_I_RENEGOTIATE* = HRESULT 0x00090321 + SEC_E_WRONG_PRINCIPAL* = HRESULT 0x80090322'i32 + SEC_I_NO_LSA_CONTEXT* = HRESULT 0x00090323 + SEC_E_TIME_SKEW* = HRESULT 0x80090324'i32 + SEC_E_UNTRUSTED_ROOT* = HRESULT 0x80090325'i32 + SEC_E_ILLEGAL_MESSAGE* = HRESULT 0x80090326'i32 + SEC_E_CERT_UNKNOWN* = HRESULT 0x80090327'i32 + SEC_E_CERT_EXPIRED* = HRESULT 0x80090328'i32 + SEC_E_ENCRYPT_FAILURE* = HRESULT 0x80090329'i32 + SEC_E_DECRYPT_FAILURE* = HRESULT 0x80090330'i32 + SEC_E_ALGORITHM_MISMATCH* = HRESULT 0x80090331'i32 + SEC_E_SECURITY_QOS_FAILED* = HRESULT 0x80090332'i32 + SEC_E_UNFINISHED_CONTEXT_DELETED* = HRESULT 0x80090333'i32 + SEC_E_NO_TGT_REPLY* = HRESULT 0x80090334'i32 + SEC_E_NO_IP_ADDRESSES* = HRESULT 0x80090335'i32 + SEC_E_WRONG_CREDENTIAL_HANDLE* = HRESULT 0x80090336'i32 + SEC_E_CRYPTO_SYSTEM_INVALID* = HRESULT 0x80090337'i32 + SEC_E_MAX_REFERRALS_EXCEEDED* = HRESULT 0x80090338'i32 + SEC_E_MUST_BE_KDC* = HRESULT 0x80090339'i32 + SEC_E_STRONG_CRYPTO_NOT_SUPPORTED* = HRESULT 0x8009033A'i32 + SEC_E_TOO_MANY_PRINCIPALS* = HRESULT 0x8009033B'i32 + SEC_E_NO_PA_DATA* = HRESULT 0x8009033C'i32 + SEC_E_PKINIT_NAME_MISMATCH* = HRESULT 0x8009033D'i32 + SEC_E_SMARTCARD_LOGON_REQUIRED* = HRESULT 0x8009033E'i32 + SEC_E_SHUTDOWN_IN_PROGRESS* = HRESULT 0x8009033F'i32 + SEC_E_KDC_INVALID_REQUEST* = HRESULT 0x80090340'i32 + SEC_E_KDC_UNABLE_TO_REFER* = HRESULT 0x80090341'i32 + SEC_E_KDC_UNKNOWN_ETYPE* = HRESULT 0x80090342'i32 + SEC_E_UNSUPPORTED_PREAUTH* = HRESULT 0x80090343'i32 + SEC_E_DELEGATION_REQUIRED* = HRESULT 0x80090345'i32 + SEC_E_BAD_BINDINGS* = HRESULT 0x80090346'i32 + SEC_E_MULTIPLE_ACCOUNTS* = HRESULT 0x80090347'i32 + SEC_E_NO_KERB_KEY* = HRESULT 0x80090348'i32 + SEC_E_CERT_WRONG_USAGE* = HRESULT 0x80090349'i32 + SEC_E_DOWNGRADE_DETECTED* = HRESULT 0x80090350'i32 + SEC_E_SMARTCARD_CERT_REVOKED* = HRESULT 0x80090351'i32 + SEC_E_ISSUING_CA_UNTRUSTED* = HRESULT 0x80090352'i32 + SEC_E_REVOCATION_OFFLINE_C* = HRESULT 0x80090353'i32 + SEC_E_PKINIT_CLIENT_FAILURE* = HRESULT 0x80090354'i32 + SEC_E_SMARTCARD_CERT_EXPIRED* = HRESULT 0x80090355'i32 + SEC_E_NO_S4U_PROT_SUPPORT* = HRESULT 0x80090356'i32 + SEC_E_CROSSREALM_DELEGATION_FAILURE* = HRESULT 0x80090357'i32 + SEC_E_REVOCATION_OFFLINE_KDC* = HRESULT 0x80090358'i32 + SEC_E_ISSUING_CA_UNTRUSTED_KDC* = HRESULT 0x80090359'i32 + SEC_E_KDC_CERT_EXPIRED* = HRESULT 0x8009035A'i32 + SEC_E_KDC_CERT_REVOKED* = HRESULT 0x8009035B'i32 + SEC_E_NO_SPM* = SEC_E_INTERNAL_ERROR + SEC_E_NOT_SUPPORTED* = SEC_E_UNSUPPORTED_FUNCTION + CRYPT_E_MSG_ERROR* = HRESULT 0x80091001'i32 + CRYPT_E_UNKNOWN_ALGO* = HRESULT 0x80091002'i32 + CRYPT_E_OID_FORMAT* = HRESULT 0x80091003'i32 + CRYPT_E_INVALID_MSG_TYPE* = HRESULT 0x80091004'i32 + CRYPT_E_UNEXPECTED_ENCODING* = HRESULT 0x80091005'i32 + CRYPT_E_AUTH_ATTR_MISSING* = HRESULT 0x80091006'i32 + CRYPT_E_HASH_VALUE* = HRESULT 0x80091007'i32 + CRYPT_E_INVALID_INDEX* = HRESULT 0x80091008'i32 + CRYPT_E_ALREADY_DECRYPTED* = HRESULT 0x80091009'i32 + CRYPT_E_NOT_DECRYPTED* = HRESULT 0x8009100A'i32 + CRYPT_E_RECIPIENT_NOT_FOUND* = HRESULT 0x8009100B'i32 + CRYPT_E_CONTROL_TYPE* = HRESULT 0x8009100C'i32 + CRYPT_E_ISSUER_SERIALNUMBER* = HRESULT 0x8009100D'i32 + CRYPT_E_SIGNER_NOT_FOUND* = HRESULT 0x8009100E'i32 + CRYPT_E_ATTRIBUTES_MISSING* = HRESULT 0x8009100F'i32 + CRYPT_E_STREAM_MSG_NOT_READY* = HRESULT 0x80091010'i32 + CRYPT_E_STREAM_INSUFFICIENT_DATA* = HRESULT 0x80091011'i32 + CRYPT_I_NEW_PROTECTION_REQUIRED* = HRESULT 0x00091012 + CRYPT_E_BAD_LEN* = HRESULT 0x80092001'i32 + CRYPT_E_BAD_ENCODE* = HRESULT 0x80092002'i32 + CRYPT_E_FILE_ERROR* = HRESULT 0x80092003'i32 + CRYPT_E_NOT_FOUND* = HRESULT 0x80092004'i32 + CRYPT_E_EXISTS* = HRESULT 0x80092005'i32 + CRYPT_E_NO_PROVIDER* = HRESULT 0x80092006'i32 + CRYPT_E_SELF_SIGNED* = HRESULT 0x80092007'i32 + CRYPT_E_DELETED_PREV* = HRESULT 0x80092008'i32 + CRYPT_E_NO_MATCH* = HRESULT 0x80092009'i32 + CRYPT_E_UNEXPECTED_MSG_TYPE* = HRESULT 0x8009200A'i32 + CRYPT_E_NO_KEY_PROPERTY* = HRESULT 0x8009200B'i32 + CRYPT_E_NO_DECRYPT_CERT* = HRESULT 0x8009200C'i32 + CRYPT_E_BAD_MSG* = HRESULT 0x8009200D'i32 + CRYPT_E_NO_SIGNER* = HRESULT 0x8009200E'i32 + CRYPT_E_PENDING_CLOSE* = HRESULT 0x8009200F'i32 + CRYPT_E_REVOKED* = HRESULT 0x80092010'i32 + CRYPT_E_NO_REVOCATION_DLL* = HRESULT 0x80092011'i32 + CRYPT_E_NO_REVOCATION_CHECK* = HRESULT 0x80092012'i32 + CRYPT_E_REVOCATION_OFFLINE* = HRESULT 0x80092013'i32 + CRYPT_E_NOT_IN_REVOCATION_DATABASE* = HRESULT 0x80092014'i32 + CRYPT_E_INVALID_NUMERIC_STRING* = HRESULT 0x80092020'i32 + CRYPT_E_INVALID_PRINTABLE_STRING* = HRESULT 0x80092021'i32 + CRYPT_E_INVALID_IA5_STRING* = HRESULT 0x80092022'i32 + CRYPT_E_INVALID_X500_STRING* = HRESULT 0x80092023'i32 + CRYPT_E_NOT_CHAR_STRING* = HRESULT 0x80092024'i32 + CRYPT_E_FILERESIZED* = HRESULT 0x80092025'i32 + CRYPT_E_SECURITY_SETTINGS* = HRESULT 0x80092026'i32 + CRYPT_E_NO_VERIFY_USAGE_DLL* = HRESULT 0x80092027'i32 + CRYPT_E_NO_VERIFY_USAGE_CHECK* = HRESULT 0x80092028'i32 + CRYPT_E_VERIFY_USAGE_OFFLINE* = HRESULT 0x80092029'i32 + CRYPT_E_NOT_IN_CTL* = HRESULT 0x8009202A'i32 + CRYPT_E_NO_TRUSTED_SIGNER* = HRESULT 0x8009202B'i32 + CRYPT_E_MISSING_PUBKEY_PARA* = HRESULT 0x8009202C'i32 + CRYPT_E_OSS_ERROR* = HRESULT 0x80093000'i32 + OSS_MORE_BUF* = HRESULT 0x80093001'i32 + OSS_NEGATIVE_UINTEGER* = HRESULT 0x80093002'i32 + OSS_PDU_RANGE* = HRESULT 0x80093003'i32 + OSS_MORE_INPUT* = HRESULT 0x80093004'i32 + OSS_DATA_ERROR* = HRESULT 0x80093005'i32 + OSS_BAD_ARG* = HRESULT 0x80093006'i32 + OSS_BAD_VERSION* = HRESULT 0x80093007'i32 + OSS_OUT_MEMORY* = HRESULT 0x80093008'i32 + OSS_PDU_MISMATCH* = HRESULT 0x80093009'i32 + OSS_LIMITED* = HRESULT 0x8009300A'i32 + OSS_BAD_PTR* = HRESULT 0x8009300B'i32 + OSS_BAD_TIME* = HRESULT 0x8009300C'i32 + OSS_INDEFINITE_NOT_SUPPORTED* = HRESULT 0x8009300D'i32 + OSS_MEM_ERROR* = HRESULT 0x8009300E'i32 + OSS_BAD_TABLE* = HRESULT 0x8009300F'i32 + OSS_TOO_LONG* = HRESULT 0x80093010'i32 + OSS_CONSTRAINT_VIOLATED* = HRESULT 0x80093011'i32 + OSS_FATAL_ERROR* = HRESULT 0x80093012'i32 + OSS_ACCESS_SERIALIZATION_ERROR* = HRESULT 0x80093013'i32 + OSS_NULL_TBL* = HRESULT 0x80093014'i32 + OSS_NULL_FCN* = HRESULT 0x80093015'i32 + OSS_BAD_ENCRULES* = HRESULT 0x80093016'i32 + OSS_UNAVAIL_ENCRULES* = HRESULT 0x80093017'i32 + OSS_CANT_OPEN_TRACE_WINDOW* = HRESULT 0x80093018'i32 + OSS_UNIMPLEMENTED* = HRESULT 0x80093019'i32 + OSS_OID_DLL_NOT_LINKED* = HRESULT 0x8009301A'i32 + OSS_CANT_OPEN_TRACE_FILE* = HRESULT 0x8009301B'i32 + OSS_TRACE_FILE_ALREADY_OPEN* = HRESULT 0x8009301C'i32 + OSS_TABLE_MISMATCH* = HRESULT 0x8009301D'i32 + OSS_TYPE_NOT_SUPPORTED* = HRESULT 0x8009301E'i32 + OSS_REAL_DLL_NOT_LINKED* = HRESULT 0x8009301F'i32 + OSS_REAL_CODE_NOT_LINKED* = HRESULT 0x80093020'i32 + OSS_OUT_OF_RANGE* = HRESULT 0x80093021'i32 + OSS_COPIER_DLL_NOT_LINKED* = HRESULT 0x80093022'i32 + OSS_CONSTRAINT_DLL_NOT_LINKED* = HRESULT 0x80093023'i32 + OSS_COMPARATOR_DLL_NOT_LINKED* = HRESULT 0x80093024'i32 + OSS_COMPARATOR_CODE_NOT_LINKED* = HRESULT 0x80093025'i32 + OSS_MEM_MGR_DLL_NOT_LINKED* = HRESULT 0x80093026'i32 + OSS_PDV_DLL_NOT_LINKED* = HRESULT 0x80093027'i32 + OSS_PDV_CODE_NOT_LINKED* = HRESULT 0x80093028'i32 + OSS_API_DLL_NOT_LINKED* = HRESULT 0x80093029'i32 + OSS_BERDER_DLL_NOT_LINKED* = HRESULT 0x8009302A'i32 + OSS_PER_DLL_NOT_LINKED* = HRESULT 0x8009302B'i32 + OSS_OPEN_TYPE_ERROR* = HRESULT 0x8009302C'i32 + OSS_MUTEX_NOT_CREATED* = HRESULT 0x8009302D'i32 + OSS_CANT_CLOSE_TRACE_FILE* = HRESULT 0x8009302E'i32 + CRYPT_E_ASN1_ERROR* = HRESULT 0x80093100'i32 + CRYPT_E_ASN1_INTERNAL* = HRESULT 0x80093101'i32 + CRYPT_E_ASN1_EOD* = HRESULT 0x80093102'i32 + CRYPT_E_ASN1_CORRUPT* = HRESULT 0x80093103'i32 + CRYPT_E_ASN1_LARGE* = HRESULT 0x80093104'i32 + CRYPT_E_ASN1_CONSTRAINT* = HRESULT 0x80093105'i32 + CRYPT_E_ASN1_MEMORY* = HRESULT 0x80093106'i32 + CRYPT_E_ASN1_OVERFLOW* = HRESULT 0x80093107'i32 + CRYPT_E_ASN1_BADPDU* = HRESULT 0x80093108'i32 + CRYPT_E_ASN1_BADARGS* = HRESULT 0x80093109'i32 + CRYPT_E_ASN1_BADREAL* = HRESULT 0x8009310A'i32 + CRYPT_E_ASN1_BADTAG* = HRESULT 0x8009310B'i32 + CRYPT_E_ASN1_CHOICE* = HRESULT 0x8009310C'i32 + CRYPT_E_ASN1_RULE* = HRESULT 0x8009310D'i32 + CRYPT_E_ASN1_UTF8* = HRESULT 0x8009310E'i32 + CRYPT_E_ASN1_PDU_TYPE* = HRESULT 0x80093133'i32 + CRYPT_E_ASN1_NYI* = HRESULT 0x80093134'i32 + CRYPT_E_ASN1_EXTENDED* = HRESULT 0x80093201'i32 + CRYPT_E_ASN1_NOEOD* = HRESULT 0x80093202'i32 + CERTSRV_E_BAD_REQUESTSUBJECT* = HRESULT 0x80094001'i32 + CERTSRV_E_NO_REQUEST* = HRESULT 0x80094002'i32 + CERTSRV_E_BAD_REQUESTSTATUS* = HRESULT 0x80094003'i32 + CERTSRV_E_PROPERTY_EMPTY* = HRESULT 0x80094004'i32 + CERTSRV_E_INVALID_CA_CERTIFICATE* = HRESULT 0x80094005'i32 + CERTSRV_E_SERVER_SUSPENDED* = HRESULT 0x80094006'i32 + CERTSRV_E_ENCODING_LENGTH* = HRESULT 0x80094007'i32 + CERTSRV_E_ROLECONFLICT* = HRESULT 0x80094008'i32 + CERTSRV_E_RESTRICTEDOFFICER* = HRESULT 0x80094009'i32 + CERTSRV_E_KEY_ARCHIVAL_NOT_CONFIGURED* = HRESULT 0x8009400A'i32 + CERTSRV_E_NO_VALID_KRA* = HRESULT 0x8009400B'i32 + CERTSRV_E_BAD_REQUEST_KEY_ARCHIVAL* = HRESULT 0x8009400C'i32 + CERTSRV_E_NO_CAADMIN_DEFINED* = HRESULT 0x8009400D'i32 + CERTSRV_E_BAD_RENEWAL_CERT_ATTRIBUTE* = HRESULT 0x8009400E'i32 + CERTSRV_E_NO_DB_SESSIONS* = HRESULT 0x8009400F'i32 + CERTSRV_E_ALIGNMENT_FAULT* = HRESULT 0x80094010'i32 + CERTSRV_E_ENROLL_DENIED* = HRESULT 0x80094011'i32 + CERTSRV_E_TEMPLATE_DENIED* = HRESULT 0x80094012'i32 + CERTSRV_E_DOWNLEVEL_DC_SSL_OR_UPGRADE* = HRESULT 0x80094013'i32 + CERTSRV_E_UNSUPPORTED_CERT_TYPE* = HRESULT 0x80094800'i32 + CERTSRV_E_NO_CERT_TYPE* = HRESULT 0x80094801'i32 + CERTSRV_E_TEMPLATE_CONFLICT* = HRESULT 0x80094802'i32 + CERTSRV_E_SUBJECT_ALT_NAME_REQUIRED* = HRESULT 0x80094803'i32 + CERTSRV_E_ARCHIVED_KEY_REQUIRED* = HRESULT 0x80094804'i32 + CERTSRV_E_SMIME_REQUIRED* = HRESULT 0x80094805'i32 + CERTSRV_E_BAD_RENEWAL_SUBJECT* = HRESULT 0x80094806'i32 + CERTSRV_E_BAD_TEMPLATE_VERSION* = HRESULT 0x80094807'i32 + CERTSRV_E_TEMPLATE_POLICY_REQUIRED* = HRESULT 0x80094808'i32 + CERTSRV_E_SIGNATURE_POLICY_REQUIRED* = HRESULT 0x80094809'i32 + CERTSRV_E_SIGNATURE_COUNT* = HRESULT 0x8009480A'i32 + CERTSRV_E_SIGNATURE_REJECTED* = HRESULT 0x8009480B'i32 + CERTSRV_E_ISSUANCE_POLICY_REQUIRED* = HRESULT 0x8009480C'i32 + CERTSRV_E_SUBJECT_UPN_REQUIRED* = HRESULT 0x8009480D'i32 + CERTSRV_E_SUBJECT_DIRECTORY_GUID_REQUIRED* = HRESULT 0x8009480E'i32 + CERTSRV_E_SUBJECT_DNS_REQUIRED* = HRESULT 0x8009480F'i32 + CERTSRV_E_ARCHIVED_KEY_UNEXPECTED* = HRESULT 0x80094810'i32 + CERTSRV_E_KEY_LENGTH* = HRESULT 0x80094811'i32 + CERTSRV_E_SUBJECT_EMAIL_REQUIRED* = HRESULT 0x80094812'i32 + CERTSRV_E_UNKNOWN_CERT_TYPE* = HRESULT 0x80094813'i32 + CERTSRV_E_CERT_TYPE_OVERLAP* = HRESULT 0x80094814'i32 + XENROLL_E_KEY_NOT_EXPORTABLE* = HRESULT 0x80095000'i32 + XENROLL_E_CANNOT_ADD_ROOT_CERT* = HRESULT 0x80095001'i32 + XENROLL_E_RESPONSE_KA_HASH_NOT_FOUND* = HRESULT 0x80095002'i32 + XENROLL_E_RESPONSE_UNEXPECTED_KA_HASH* = HRESULT 0x80095003'i32 + XENROLL_E_RESPONSE_KA_HASH_MISMATCH* = HRESULT 0x80095004'i32 + XENROLL_E_KEYSPEC_SMIME_MISMATCH* = HRESULT 0x80095005'i32 + TRUST_E_SYSTEM_ERROR* = HRESULT 0x80096001'i32 + TRUST_E_NO_SIGNER_CERT* = HRESULT 0x80096002'i32 + TRUST_E_COUNTER_SIGNER* = HRESULT 0x80096003'i32 + TRUST_E_CERT_SIGNATURE* = HRESULT 0x80096004'i32 + TRUST_E_TIME_STAMP* = HRESULT 0x80096005'i32 + TRUST_E_BAD_DIGEST* = HRESULT 0x80096010'i32 + TRUST_E_BASIC_CONSTRAINTS* = HRESULT 0x80096019'i32 + TRUST_E_FINANCIAL_CRITERIA* = HRESULT 0x8009601E'i32 + MSSIPOTF_E_OUTOFMEMRANGE* = HRESULT 0x80097001'i32 + MSSIPOTF_E_CANTGETOBJECT* = HRESULT 0x80097002'i32 + MSSIPOTF_E_NOHEADTABLE* = HRESULT 0x80097003'i32 + MSSIPOTF_E_BAD_MAGICNUMBER* = HRESULT 0x80097004'i32 + MSSIPOTF_E_BAD_OFFSET_TABLE* = HRESULT 0x80097005'i32 + MSSIPOTF_E_TABLE_TAGORDER* = HRESULT 0x80097006'i32 + MSSIPOTF_E_TABLE_LONGWORD* = HRESULT 0x80097007'i32 + MSSIPOTF_E_BAD_FIRST_TABLE_PLACEMENT* = HRESULT 0x80097008'i32 + MSSIPOTF_E_TABLES_OVERLAP* = HRESULT 0x80097009'i32 + MSSIPOTF_E_TABLE_PADBYTES* = HRESULT 0x8009700A'i32 + MSSIPOTF_E_FILETOOSMALL* = HRESULT 0x8009700B'i32 + MSSIPOTF_E_TABLE_CHECKSUM* = HRESULT 0x8009700C'i32 + MSSIPOTF_E_FILE_CHECKSUM* = HRESULT 0x8009700D'i32 + MSSIPOTF_E_FAILED_POLICY* = HRESULT 0x80097010'i32 + MSSIPOTF_E_FAILED_HINTS_CHECK* = HRESULT 0x80097011'i32 + MSSIPOTF_E_NOT_OPENTYPE* = HRESULT 0x80097012'i32 + MSSIPOTF_E_FILE* = HRESULT 0x80097013'i32 + MSSIPOTF_E_CRYPT* = HRESULT 0x80097014'i32 + MSSIPOTF_E_BADVERSION* = HRESULT 0x80097015'i32 + MSSIPOTF_E_DSIG_STRUCTURE* = HRESULT 0x80097016'i32 + MSSIPOTF_E_PCONST_CHECK* = HRESULT 0x80097017'i32 + MSSIPOTF_E_STRUCTURE* = HRESULT 0x80097018'i32 + NTE_OP_OK* = 0 + TRUST_E_PROVIDER_UNKNOWN* = HRESULT 0x800B0001'i32 + TRUST_E_ACTION_UNKNOWN* = HRESULT 0x800B0002'i32 + TRUST_E_SUBJECT_FORM_UNKNOWN* = HRESULT 0x800B0003'i32 + TRUST_E_SUBJECT_NOT_TRUSTED* = HRESULT 0x800B0004'i32 + DIGSIG_E_ENCODE* = HRESULT 0x800B0005'i32 + DIGSIG_E_DECODE* = HRESULT 0x800B0006'i32 + DIGSIG_E_EXTENSIBILITY* = HRESULT 0x800B0007'i32 + DIGSIG_E_CRYPTO* = HRESULT 0x800B0008'i32 + PERSIST_E_SIZEDEFINITE* = HRESULT 0x800B0009'i32 + PERSIST_E_SIZEINDEFINITE* = HRESULT 0x800B000A'i32 + PERSIST_E_NOTSELFSIZING* = HRESULT 0x800B000B'i32 + TRUST_E_NOSIGNATURE* = HRESULT 0x800B0100'i32 + CERT_E_EXPIRED* = HRESULT 0x800B0101'i32 + CERT_E_VALIDITYPERIODNESTING* = HRESULT 0x800B0102'i32 + CERT_E_ROLE* = HRESULT 0x800B0103'i32 + CERT_E_PATHLENCONST* = HRESULT 0x800B0104'i32 + CERT_E_CRITICAL* = HRESULT 0x800B0105'i32 + CERT_E_PURPOSE* = HRESULT 0x800B0106'i32 + CERT_E_ISSUERCHAINING* = HRESULT 0x800B0107'i32 + CERT_E_MALFORMED* = HRESULT 0x800B0108'i32 + CERT_E_UNTRUSTEDROOT* = HRESULT 0x800B0109'i32 + CERT_E_CHAINING* = HRESULT 0x800B010A'i32 + TRUST_E_FAIL* = HRESULT 0x800B010B'i32 + CERT_E_REVOKED* = HRESULT 0x800B010C'i32 + CERT_E_UNTRUSTEDTESTROOT* = HRESULT 0x800B010D'i32 + CERT_E_REVOCATION_FAILURE* = HRESULT 0x800B010E'i32 + CERT_E_CN_NO_MATCH* = HRESULT 0x800B010F'i32 + CERT_E_WRONG_USAGE* = HRESULT 0x800B0110'i32 + TRUST_E_EXPLICIT_DISTRUST* = HRESULT 0x800B0111'i32 + CERT_E_UNTRUSTEDCA* = HRESULT 0x800B0112'i32 + CERT_E_INVALID_POLICY* = HRESULT 0x800B0113'i32 + CERT_E_INVALID_NAME* = HRESULT 0x800B0114'i32 + SPAPI_E_EXPECTED_SECTION_NAME* = HRESULT 0x800F0000'i32 + SPAPI_E_BAD_SECTION_NAME_LINE* = HRESULT 0x800F0001'i32 + SPAPI_E_SECTION_NAME_TOO_LONG* = HRESULT 0x800F0002'i32 + SPAPI_E_GENERAL_SYNTAX* = HRESULT 0x800F0003'i32 + SPAPI_E_WRONG_INF_STYLE* = HRESULT 0x800F0100'i32 + SPAPI_E_SECTION_NOT_FOUND* = HRESULT 0x800F0101'i32 + SPAPI_E_LINE_NOT_FOUND* = HRESULT 0x800F0102'i32 + SPAPI_E_NO_BACKUP* = HRESULT 0x800F0103'i32 + SPAPI_E_NO_ASSOCIATED_CLASS* = HRESULT 0x800F0200'i32 + SPAPI_E_CLASS_MISMATCH* = HRESULT 0x800F0201'i32 + SPAPI_E_DUPLICATE_FOUND* = HRESULT 0x800F0202'i32 + SPAPI_E_NO_DRIVER_SELECTED* = HRESULT 0x800F0203'i32 + SPAPI_E_KEY_DOES_NOT_EXIST* = HRESULT 0x800F0204'i32 + SPAPI_E_INVALID_DEVINST_NAME* = HRESULT 0x800F0205'i32 + SPAPI_E_INVALID_CLASS* = HRESULT 0x800F0206'i32 + SPAPI_E_DEVINST_ALREADY_EXISTS* = HRESULT 0x800F0207'i32 + SPAPI_E_DEVINFO_NOT_REGISTERED* = HRESULT 0x800F0208'i32 + SPAPI_E_INVALID_REG_PROPERTY* = HRESULT 0x800F0209'i32 + SPAPI_E_NO_INF* = HRESULT 0x800F020A'i32 + SPAPI_E_NO_SUCH_DEVINST* = HRESULT 0x800F020B'i32 + SPAPI_E_CANT_LOAD_CLASS_ICON* = HRESULT 0x800F020C'i32 + SPAPI_E_INVALID_CLASS_INSTALLER* = HRESULT 0x800F020D'i32 + SPAPI_E_DI_DO_DEFAULT* = HRESULT 0x800F020E'i32 + SPAPI_E_DI_NOFILECOPY* = HRESULT 0x800F020F'i32 + SPAPI_E_INVALID_HWPROFILE* = HRESULT 0x800F0210'i32 + SPAPI_E_NO_DEVICE_SELECTED* = HRESULT 0x800F0211'i32 + SPAPI_E_DEVINFO_LIST_LOCKED* = HRESULT 0x800F0212'i32 + SPAPI_E_DEVINFO_DATA_LOCKED* = HRESULT 0x800F0213'i32 + SPAPI_E_DI_BAD_PATH* = HRESULT 0x800F0214'i32 + SPAPI_E_NO_CLASSINSTALL_PARAMS* = HRESULT 0x800F0215'i32 + SPAPI_E_FILEQUEUE_LOCKED* = HRESULT 0x800F0216'i32 + SPAPI_E_BAD_SERVICE_INSTALLSECT* = HRESULT 0x800F0217'i32 + SPAPI_E_NO_CLASS_DRIVER_LIST* = HRESULT 0x800F0218'i32 + SPAPI_E_NO_ASSOCIATED_SERVICE* = HRESULT 0x800F0219'i32 + SPAPI_E_NO_DEFAULT_DEVICE_INTERFACE* = HRESULT 0x800F021A'i32 + SPAPI_E_DEVICE_INTERFACE_ACTIVE* = HRESULT 0x800F021B'i32 + SPAPI_E_DEVICE_INTERFACE_REMOVED* = HRESULT 0x800F021C'i32 + SPAPI_E_BAD_INTERFACE_INSTALLSECT* = HRESULT 0x800F021D'i32 + SPAPI_E_NO_SUCH_INTERFACE_CLASS* = HRESULT 0x800F021E'i32 + SPAPI_E_INVALID_REFERENCE_STRING* = HRESULT 0x800F021F'i32 + SPAPI_E_INVALID_MACHINENAME* = HRESULT 0x800F0220'i32 + SPAPI_E_REMOTE_COMM_FAILURE* = HRESULT 0x800F0221'i32 + SPAPI_E_MACHINE_UNAVAILABLE* = HRESULT 0x800F0222'i32 + SPAPI_E_NO_CONFIGMGR_SERVICES* = HRESULT 0x800F0223'i32 + SPAPI_E_INVALID_PROPPAGE_PROVIDER* = HRESULT 0x800F0224'i32 + SPAPI_E_NO_SUCH_DEVICE_INTERFACE* = HRESULT 0x800F0225'i32 + SPAPI_E_DI_POSTPROCESSING_REQUIRED* = HRESULT 0x800F0226'i32 + SPAPI_E_INVALID_COINSTALLER* = HRESULT 0x800F0227'i32 + SPAPI_E_NO_COMPAT_DRIVERS* = HRESULT 0x800F0228'i32 + SPAPI_E_NO_DEVICE_ICON* = HRESULT 0x800F0229'i32 + SPAPI_E_INVALID_INF_LOGCONFIG* = HRESULT 0x800F022A'i32 + SPAPI_E_DI_DONT_INSTALL* = HRESULT 0x800F022B'i32 + SPAPI_E_INVALID_FILTER_DRIVER* = HRESULT 0x800F022C'i32 + SPAPI_E_NON_WINDOWS_NT_DRIVER* = HRESULT 0x800F022D'i32 + SPAPI_E_NON_WINDOWS_DRIVER* = HRESULT 0x800F022E'i32 + SPAPI_E_NO_CATALOG_FOR_OEM_INF* = HRESULT 0x800F022F'i32 + SPAPI_E_DEVINSTALL_QUEUE_NONNATIVE* = HRESULT 0x800F0230'i32 + SPAPI_E_NOT_DISABLEABLE* = HRESULT 0x800F0231'i32 + SPAPI_E_CANT_REMOVE_DEVINST* = HRESULT 0x800F0232'i32 + SPAPI_E_INVALID_TARGET* = HRESULT 0x800F0233'i32 + SPAPI_E_DRIVER_NONNATIVE* = HRESULT 0x800F0234'i32 + SPAPI_E_IN_WOW64* = HRESULT 0x800F0235'i32 + SPAPI_E_SET_SYSTEM_RESTORE_POINT* = HRESULT 0x800F0236'i32 + SPAPI_E_INCORRECTLY_COPIED_INF* = HRESULT 0x800F0237'i32 + SPAPI_E_SCE_DISABLED* = HRESULT 0x800F0238'i32 + SPAPI_E_UNKNOWN_EXCEPTION* = HRESULT 0x800F0239'i32 + SPAPI_E_PNP_REGISTRY_ERROR* = HRESULT 0x800F023A'i32 + SPAPI_E_REMOTE_REQUEST_UNSUPPORTED* = HRESULT 0x800F023B'i32 + SPAPI_E_NOT_AN_INSTALLED_OEM_INF* = HRESULT 0x800F023C'i32 + SPAPI_E_INF_IN_USE_BY_DEVICES* = HRESULT 0x800F023D'i32 + SPAPI_E_DI_FUNCTION_OBSOLETE* = HRESULT 0x800F023E'i32 + SPAPI_E_NO_AUTHENTICODE_CATALOG* = HRESULT 0x800F023F'i32 + SPAPI_E_AUTHENTICODE_DISALLOWED* = HRESULT 0x800F0240'i32 + SPAPI_E_AUTHENTICODE_TRUSTED_PUBLISHER* = HRESULT 0x800F0241'i32 + SPAPI_E_AUTHENTICODE_TRUST_NOT_ESTABLISHED* = HRESULT 0x800F0242'i32 + SPAPI_E_AUTHENTICODE_PUBLISHER_NOT_TRUSTED* = HRESULT 0x800F0243'i32 + SPAPI_E_SIGNATURE_OSATTRIBUTE_MISMATCH* = HRESULT 0x800F0244'i32 + SPAPI_E_ONLY_VALIDATE_VIA_AUTHENTICODE* = HRESULT 0x800F0245'i32 + SPAPI_E_UNRECOVERABLE_STACK_OVERFLOW* = HRESULT 0x800F0300'i32 + SPAPI_E_ERROR_NOT_INSTALLED* = HRESULT 0x800F1000'i32 + SCARD_S_SUCCESS* = NO_ERROR + SCARD_F_INTERNAL_ERROR* = HRESULT 0x80100001'i32 + SCARD_E_CANCELLED* = HRESULT 0x80100002'i32 + SCARD_E_INVALID_HANDLE* = HRESULT 0x80100003'i32 + SCARD_E_INVALID_PARAMETER* = HRESULT 0x80100004'i32 + SCARD_E_INVALID_TARGET* = HRESULT 0x80100005'i32 + SCARD_E_NO_MEMORY* = HRESULT 0x80100006'i32 + SCARD_F_WAITED_TOO_LONG* = HRESULT 0x80100007'i32 + SCARD_E_INSUFFICIENT_BUFFER* = HRESULT 0x80100008'i32 + SCARD_E_UNKNOWN_READER* = HRESULT 0x80100009'i32 + SCARD_E_TIMEOUT* = HRESULT 0x8010000A'i32 + SCARD_E_SHARING_VIOLATION* = HRESULT 0x8010000B'i32 + SCARD_E_NO_SMARTCARD* = HRESULT 0x8010000C'i32 + SCARD_E_UNKNOWN_CARD* = HRESULT 0x8010000D'i32 + SCARD_E_CANT_DISPOSE* = HRESULT 0x8010000E'i32 + SCARD_E_PROTO_MISMATCH* = HRESULT 0x8010000F'i32 + SCARD_E_NOT_READY* = HRESULT 0x80100010'i32 + SCARD_E_INVALID_VALUE* = HRESULT 0x80100011'i32 + SCARD_E_SYSTEM_CANCELLED* = HRESULT 0x80100012'i32 + SCARD_F_COMM_ERROR* = HRESULT 0x80100013'i32 + SCARD_F_UNKNOWN_ERROR* = HRESULT 0x80100014'i32 + SCARD_E_INVALID_ATR* = HRESULT 0x80100015'i32 + SCARD_E_NOT_TRANSACTED* = HRESULT 0x80100016'i32 + SCARD_E_READER_UNAVAILABLE* = HRESULT 0x80100017'i32 + SCARD_P_SHUTDOWN* = HRESULT 0x80100018'i32 + SCARD_E_PCI_TOO_SMALL* = HRESULT 0x80100019'i32 + SCARD_E_READER_UNSUPPORTED* = HRESULT 0x8010001A'i32 + SCARD_E_DUPLICATE_READER* = HRESULT 0x8010001B'i32 + SCARD_E_CARD_UNSUPPORTED* = HRESULT 0x8010001C'i32 + SCARD_E_NO_SERVICE* = HRESULT 0x8010001D'i32 + SCARD_E_SERVICE_STOPPED* = HRESULT 0x8010001E'i32 + SCARD_E_UNEXPECTED* = HRESULT 0x8010001F'i32 + SCARD_E_ICC_INSTALLATION* = HRESULT 0x80100020'i32 + SCARD_E_ICC_CREATEORDER* = HRESULT 0x80100021'i32 + SCARD_E_UNSUPPORTED_FEATURE* = HRESULT 0x80100022'i32 + SCARD_E_DIR_NOT_FOUND* = HRESULT 0x80100023'i32 + SCARD_E_FILE_NOT_FOUND* = HRESULT 0x80100024'i32 + SCARD_E_NO_DIR* = HRESULT 0x80100025'i32 + SCARD_E_NO_FILE* = HRESULT 0x80100026'i32 + SCARD_E_NO_ACCESS* = HRESULT 0x80100027'i32 + SCARD_E_WRITE_TOO_MANY* = HRESULT 0x80100028'i32 + SCARD_E_BAD_SEEK* = HRESULT 0x80100029'i32 + SCARD_E_INVALID_CHV* = HRESULT 0x8010002A'i32 + SCARD_E_UNKNOWN_RES_MNG* = HRESULT 0x8010002B'i32 + SCARD_E_NO_SUCH_CERTIFICATE* = HRESULT 0x8010002C'i32 + SCARD_E_CERTIFICATE_UNAVAILABLE* = HRESULT 0x8010002D'i32 + SCARD_E_NO_READERS_AVAILABLE* = HRESULT 0x8010002E'i32 + SCARD_E_COMM_DATA_LOST* = HRESULT 0x8010002F'i32 + SCARD_E_NO_KEY_CONTAINER* = HRESULT 0x80100030'i32 + SCARD_E_SERVER_TOO_BUSY* = HRESULT 0x80100031'i32 + SCARD_W_UNSUPPORTED_CARD* = HRESULT 0x80100065'i32 + SCARD_W_UNRESPONSIVE_CARD* = HRESULT 0x80100066'i32 + SCARD_W_UNPOWERED_CARD* = HRESULT 0x80100067'i32 + SCARD_W_RESET_CARD* = HRESULT 0x80100068'i32 + SCARD_W_REMOVED_CARD* = HRESULT 0x80100069'i32 + SCARD_W_SECURITY_VIOLATION* = HRESULT 0x8010006A'i32 + SCARD_W_WRONG_CHV* = HRESULT 0x8010006B'i32 + SCARD_W_CHV_BLOCKED* = HRESULT 0x8010006C'i32 + SCARD_W_EOF* = HRESULT 0x8010006D'i32 + SCARD_W_CANCELLED_BY_USER* = HRESULT 0x8010006E'i32 + SCARD_W_CARD_NOT_AUTHENTICATED* = HRESULT 0x8010006F'i32 + SCARD_W_CACHE_ITEM_NOT_FOUND* = HRESULT 0x80100070'i32 + SCARD_W_CACHE_ITEM_STALE* = HRESULT 0x80100071'i32 + COMADMIN_E_OBJECTERRORS* = HRESULT 0x80110401'i32 + COMADMIN_E_OBJECTINVALID* = HRESULT 0x80110402'i32 + COMADMIN_E_KEYMISSING* = HRESULT 0x80110403'i32 + COMADMIN_E_ALREADYINSTALLED* = HRESULT 0x80110404'i32 + COMADMIN_E_APP_FILE_WRITEFAIL* = HRESULT 0x80110407'i32 + COMADMIN_E_APP_FILE_READFAIL* = HRESULT 0x80110408'i32 + COMADMIN_E_APP_FILE_VERSION* = HRESULT 0x80110409'i32 + COMADMIN_E_BADPATH* = HRESULT 0x8011040A'i32 + COMADMIN_E_APPLICATIONEXISTS* = HRESULT 0x8011040B'i32 + COMADMIN_E_ROLEEXISTS* = HRESULT 0x8011040C'i32 + COMADMIN_E_CANTCOPYFILE* = HRESULT 0x8011040D'i32 + COMADMIN_E_NOUSER* = HRESULT 0x8011040F'i32 + COMADMIN_E_INVALIDUSERIDS* = HRESULT 0x80110410'i32 + COMADMIN_E_NOREGISTRYCLSID* = HRESULT 0x80110411'i32 + COMADMIN_E_BADREGISTRYPROGID* = HRESULT 0x80110412'i32 + COMADMIN_E_AUTHENTICATIONLEVEL* = HRESULT 0x80110413'i32 + COMADMIN_E_USERPASSWDNOTVALID* = HRESULT 0x80110414'i32 + COMADMIN_E_CLSIDORIIDMISMATCH* = HRESULT 0x80110418'i32 + COMADMIN_E_REMOTEINTERFACE* = HRESULT 0x80110419'i32 + COMADMIN_E_DLLREGISTERSERVER* = HRESULT 0x8011041A'i32 + COMADMIN_E_NOSERVERSHARE* = HRESULT 0x8011041B'i32 + COMADMIN_E_DLLLOADFAILED* = HRESULT 0x8011041D'i32 + COMADMIN_E_BADREGISTRYLIBID* = HRESULT 0x8011041E'i32 + COMADMIN_E_APPDIRNOTFOUND* = HRESULT 0x8011041F'i32 + COMADMIN_E_REGISTRARFAILED* = HRESULT 0x80110423'i32 + COMADMIN_E_COMPFILE_DOESNOTEXIST* = HRESULT 0x80110424'i32 + COMADMIN_E_COMPFILE_LOADDLLFAIL* = HRESULT 0x80110425'i32 + COMADMIN_E_COMPFILE_GETCLASSOBJ* = HRESULT 0x80110426'i32 + COMADMIN_E_COMPFILE_CLASSNOTAVAIL* = HRESULT 0x80110427'i32 + COMADMIN_E_COMPFILE_BADTLB* = HRESULT 0x80110428'i32 + COMADMIN_E_COMPFILE_NOTINSTALLABLE* = HRESULT 0x80110429'i32 + COMADMIN_E_NOTCHANGEABLE* = HRESULT 0x8011042A'i32 + COMADMIN_E_NOTDELETEABLE* = HRESULT 0x8011042B'i32 + COMADMIN_E_SESSION* = HRESULT 0x8011042C'i32 + COMADMIN_E_COMP_MOVE_LOCKED* = HRESULT 0x8011042D'i32 + COMADMIN_E_COMP_MOVE_BAD_DEST* = HRESULT 0x8011042E'i32 + COMADMIN_E_REGISTERTLB* = HRESULT 0x80110430'i32 + COMADMIN_E_SYSTEMAPP* = HRESULT 0x80110433'i32 + COMADMIN_E_COMPFILE_NOREGISTRAR* = HRESULT 0x80110434'i32 + COMADMIN_E_COREQCOMPINSTALLED* = HRESULT 0x80110435'i32 + COMADMIN_E_SERVICENOTINSTALLED* = HRESULT 0x80110436'i32 + COMADMIN_E_PROPERTYSAVEFAILED* = HRESULT 0x80110437'i32 + COMADMIN_E_OBJECTEXISTS* = HRESULT 0x80110438'i32 + COMADMIN_E_COMPONENTEXISTS* = HRESULT 0x80110439'i32 + COMADMIN_E_REGFILE_CORRUPT* = HRESULT 0x8011043B'i32 + COMADMIN_E_PROPERTY_OVERFLOW* = HRESULT 0x8011043C'i32 + COMADMIN_E_NOTINREGISTRY* = HRESULT 0x8011043E'i32 + COMADMIN_E_OBJECTNOTPOOLABLE* = HRESULT 0x8011043F'i32 + COMADMIN_E_APPLID_MATCHES_CLSID* = HRESULT 0x80110446'i32 + COMADMIN_E_ROLE_DOES_NOT_EXIST* = HRESULT 0x80110447'i32 + COMADMIN_E_START_APP_NEEDS_COMPONENTS* = HRESULT 0x80110448'i32 + COMADMIN_E_REQUIRES_DIFFERENT_PLATFORM* = HRESULT 0x80110449'i32 + COMADMIN_E_CAN_NOT_EXPORT_APP_PROXY* = HRESULT 0x8011044A'i32 + COMADMIN_E_CAN_NOT_START_APP* = HRESULT 0x8011044B'i32 + COMADMIN_E_CAN_NOT_EXPORT_SYS_APP* = HRESULT 0x8011044C'i32 + COMADMIN_E_CANT_SUBSCRIBE_TO_COMPONENT* = HRESULT 0x8011044D'i32 + COMADMIN_E_EVENTCLASS_CANT_BE_SUBSCRIBER* = HRESULT 0x8011044E'i32 + COMADMIN_E_LIB_APP_PROXY_INCOMPATIBLE* = HRESULT 0x8011044F'i32 + COMADMIN_E_BASE_PARTITION_ONLY* = HRESULT 0x80110450'i32 + COMADMIN_E_START_APP_DISABLED* = HRESULT 0x80110451'i32 + COMADMIN_E_CAT_DUPLICATE_PARTITION_NAME* = HRESULT 0x80110457'i32 + COMADMIN_E_CAT_INVALID_PARTITION_NAME* = HRESULT 0x80110458'i32 + COMADMIN_E_CAT_PARTITION_IN_USE* = HRESULT 0x80110459'i32 + COMADMIN_E_FILE_PARTITION_DUPLICATE_FILES* = HRESULT 0x8011045A'i32 + COMADMIN_E_CAT_IMPORTED_COMPONENTS_NOT_ALLOWED* = HRESULT 0x8011045B'i32 + COMADMIN_E_AMBIGUOUS_APPLICATION_NAME* = HRESULT 0x8011045C'i32 + COMADMIN_E_AMBIGUOUS_PARTITION_NAME* = HRESULT 0x8011045D'i32 + COMADMIN_E_REGDB_NOTINITIALIZED* = HRESULT 0x80110472'i32 + COMADMIN_E_REGDB_NOTOPEN* = HRESULT 0x80110473'i32 + COMADMIN_E_REGDB_SYSTEMERR* = HRESULT 0x80110474'i32 + COMADMIN_E_REGDB_ALREADYRUNNING* = HRESULT 0x80110475'i32 + COMADMIN_E_MIG_VERSIONNOTSUPPORTED* = HRESULT 0x80110480'i32 + COMADMIN_E_MIG_SCHEMANOTFOUND* = HRESULT 0x80110481'i32 + COMADMIN_E_CAT_BITNESSMISMATCH* = HRESULT 0x80110482'i32 + COMADMIN_E_CAT_UNACCEPTABLEBITNESS* = HRESULT 0x80110483'i32 + COMADMIN_E_CAT_WRONGAPPBITNESS* = HRESULT 0x80110484'i32 + COMADMIN_E_CAT_PAUSE_RESUME_NOT_SUPPORTED* = HRESULT 0x80110485'i32 + COMADMIN_E_CAT_SERVERFAULT* = HRESULT 0x80110486'i32 + COMQC_E_APPLICATION_NOT_QUEUED* = HRESULT 0x80110600'i32 + COMQC_E_NO_QUEUEABLE_INTERFACES* = HRESULT 0x80110601'i32 + COMQC_E_QUEUING_SERVICE_NOT_AVAILABLE* = HRESULT 0x80110602'i32 + COMQC_E_NO_IPERSISTSTREAM* = HRESULT 0x80110603'i32 + COMQC_E_BAD_MESSAGE* = HRESULT 0x80110604'i32 + COMQC_E_UNAUTHENTICATED* = HRESULT 0x80110605'i32 + COMQC_E_UNTRUSTED_ENQUEUER* = HRESULT 0x80110606'i32 + MSDTC_E_DUPLICATE_RESOURCE* = HRESULT 0x80110701'i32 + COMADMIN_E_OBJECT_PARENT_MISSING* = HRESULT 0x80110808'i32 + COMADMIN_E_OBJECT_DOES_NOT_EXIST* = HRESULT 0x80110809'i32 + COMADMIN_E_APP_NOT_RUNNING* = HRESULT 0x8011080A'i32 + COMADMIN_E_INVALID_PARTITION* = HRESULT 0x8011080B'i32 + COMADMIN_E_SVCAPP_NOT_POOLABLE_OR_RECYCLABLE* = HRESULT 0x8011080D'i32 + COMADMIN_E_USER_IN_SET* = HRESULT 0x8011080E'i32 + COMADMIN_E_CANTRECYCLELIBRARYAPPS* = HRESULT 0x8011080F'i32 + COMADMIN_E_CANTRECYCLESERVICEAPPS* = HRESULT 0x80110811'i32 + COMADMIN_E_PROCESSALREADYRECYCLED* = HRESULT 0x80110812'i32 + COMADMIN_E_PAUSEDPROCESSMAYNOTBERECYCLED* = HRESULT 0x80110813'i32 + COMADMIN_E_CANTMAKEINPROCSERVICE* = HRESULT 0x80110814'i32 + COMADMIN_E_PROGIDINUSEBYCLSID* = HRESULT 0x80110815'i32 + COMADMIN_E_DEFAULT_PARTITION_NOT_IN_SET* = HRESULT 0x80110816'i32 + COMADMIN_E_RECYCLEDPROCESSMAYNOTBEPAUSED* = HRESULT 0x80110817'i32 + COMADMIN_E_PARTITION_ACCESSDENIED* = HRESULT 0x80110818'i32 + COMADMIN_E_PARTITION_MSI_ONLY* = HRESULT 0x80110819'i32 + COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_1_0_FORMAT* = HRESULT 0x8011081A'i32 + COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_NONBASE_PARTITIONS* = HRESULT 0x8011081B'i32 + COMADMIN_E_COMP_MOVE_SOURCE* = HRESULT 0x8011081C'i32 + COMADMIN_E_COMP_MOVE_DEST* = HRESULT 0x8011081D'i32 + COMADMIN_E_COMP_MOVE_PRIVATE* = HRESULT 0x8011081E'i32 + COMADMIN_E_BASEPARTITION_REQUIRED_IN_SET* = HRESULT 0x8011081F'i32 + COMADMIN_E_CANNOT_ALIAS_EVENTCLASS* = HRESULT 0x80110820'i32 + COMADMIN_E_PRIVATE_ACCESSDENIED* = HRESULT 0x80110821'i32 + COMADMIN_E_SAFERINVALID* = HRESULT 0x80110822'i32 + COMADMIN_E_REGISTRY_ACCESSDENIED* = HRESULT 0x80110823'i32 + COMADMIN_E_PARTITIONS_DISABLED* = HRESULT 0x80110824'i32 + VSS_E_BAD_STATE* = HRESULT 0x80042301'i32 + VSS_E_LEGACY_PROVIDER* = HRESULT 0x800423F7'i32 + VSS_E_RESYNC_IN_PROGRESS* = HRESULT 0x800423FF'i32 + VSS_E_SNAPSHOT_NOT_IN_SET* = HRESULT 0x8004232B'i32 + VSS_E_MAXIMUM_NUMBER_OF_VOLUMES_REACHED* = HRESULT 0x80042312'i32 + VSS_E_MAXIMUM_NUMBER_OF_SNAPSHOTS_REACHED* = HRESULT 0x80042317'i32 + VSS_E_NESTED_VOLUME_LIMIT* = HRESULT 0x8004232C'i32 + VSS_E_OBJECT_NOT_FOUND* = HRESULT 0x80042308'i32 + VSS_E_PROVIDER_NOT_REGISTERED* = HRESULT 0x80042304'i32 + VSS_E_PROVIDER_VETO* = HRESULT 0x80042306'i32 + VSS_E_VOLUME_NOT_SUPPORTED* = HRESULT 0x8004230C'i32 + VSS_E_VOLUME_NOT_SUPPORTED_BY_PROVIDER* = HRESULT 0x8004230E'i32 + VSS_E_UNEXPECTED* = HRESULT 0x80042302'i32 + VSS_E_UNEXPECTED_PROVIDER_ERROR* = HRESULT 0x8004230F'i32 + VSS_E_UNSELECTED_VOLUME* = HRESULT 0x8004232A'i32 + VSS_E_CANNOT_REVERT_DISKID* = HRESULT 0x800423FE'i32 + VSS_E_INVALID_XML_DOCUMENT* = HRESULT 0x80042311'i32 + VSS_E_OBJECT_ALREADY_EXISTS* = HRESULT 0x8004230D'i32 + DXGI_ERROR_INVALID_CALL* = HRESULT 0x887A0001'i32 + DXGI_ERROR_NOT_FOUND* = HRESULT 0x887A0002'i32 + DXGI_ERROR_MORE_DATA* = HRESULT 0x887A0003'i32 + DXGI_ERROR_UNSUPPORTED* = HRESULT 0x887A0004'i32 + DXGI_ERROR_DEVICE_REMOVED* = HRESULT 0x887A0005'i32 + DXGI_ERROR_DEVICE_HUNG* = HRESULT 0x887A0006'i32 + DXGI_ERROR_DEVICE_RESET* = HRESULT 0x887A0007'i32 + DXGI_ERROR_WAS_STILL_DRAWING* = HRESULT 0x887A000A'i32 + DXGI_ERROR_FRAME_STATISTICS_DISJOINT* = HRESULT 0x887A000B'i32 + DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE* = HRESULT 0x887A000C'i32 + DXGI_ERROR_DRIVER_INTERNAL_ERROR* = HRESULT 0x887A0020'i32 + DXGI_ERROR_NONEXCLUSIVE* = HRESULT 0x887A0021'i32 + DXGI_ERROR_NOT_CURRENTLY_AVAILABLE* = HRESULT 0x887A0022'i32 + DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED* = HRESULT 0x887A0023'i32 + DXGI_ERROR_REMOTE_OUTOFMEMORY* = HRESULT 0x887A0024'i32 + DXGI_ERROR_ACCESS_LOST* = HRESULT 0x887A0026'i32 + DXGI_ERROR_WAIT_TIMEOUT* = HRESULT 0x887A0027'i32 + DXGI_ERROR_SESSION_DISCONNECTED* = HRESULT 0x887A0028'i32 + DXGI_ERROR_RESTRICT_TO_OUTPUT_STALE* = HRESULT 0x887A0029'i32 + DXGI_ERROR_CANNOT_PROTECT_CONTENT* = HRESULT 0x887A002A'i32 + DXGI_ERROR_ACCESS_DENIED* = HRESULT 0x887A002B'i32 + DXGI_ERROR_NAME_ALREADY_EXISTS* = HRESULT 0x887A002C'i32 + DXGI_ERROR_SDK_COMPONENT_MISSING* = HRESULT 0x887A002D'i32 + TBS_SUCCESS* = 0 + TBS_E_INTERNAL_ERROR* = HRESULT 0x80284001'i32 + TBS_E_BAD_PARAMETER* = HRESULT 0x80284002'i32 + TBS_E_INVALID_OUTPUT_POINTER* = HRESULT 0x80284003'i32 + TBS_E_INSUFFICIENT_BUFFER* = HRESULT 0x80284005'i32 + TBS_E_IOERROR* = HRESULT 0x80284006'i32 + TBS_E_INVALID_CONTEXT_PARAM* = HRESULT 0x80284007'i32 + TBS_E_SERVICE_NOT_RUNNING* = HRESULT 0x80284008'i32 + TBS_E_TOO_MANY_TBS_CONTEXTS* = HRESULT 0x80284009'i32 + TBS_E_SERVICE_START_PENDING* = HRESULT 0x8028400B'i32 + TBS_E_BUFFER_TOO_LARGE* = HRESULT 0x8028400E'i32 + TBS_E_TPM_NOT_FOUND* = HRESULT 0x8028400F'i32 + TBS_E_SERVICE_DISABLED* = HRESULT 0x80284010'i32 + TBS_E_DEACTIVATED* = HRESULT 0x80284016'i32 + FWP_E_CALLOUT_NOT_FOUND* = HRESULT 0x80320001'i32 + FWP_E_CONDITION_NOT_FOUND* = HRESULT 0x80320002'i32 + FWP_E_FILTER_NOT_FOUND* = HRESULT 0x80320003'i32 + FWP_E_LAYER_NOT_FOUND* = HRESULT 0x80320004'i32 + FWP_E_PROVIDER_NOT_FOUND* = HRESULT 0x80320005'i32 + FWP_E_PROVIDER_CONTEXT_NOT_FOUND* = HRESULT 0x80320006'i32 + FWP_E_SUBLAYER_NOT_FOUND* = HRESULT 0x80320007'i32 + FWP_E_NOT_FOUND* = HRESULT 0x80320008'i32 + FWP_E_ALREADY_EXISTS* = HRESULT 0x80320009'i32 + FWP_E_IN_USE* = HRESULT 0x8032000A'i32 + FWP_E_DYNAMIC_SESSION_IN_PROGRESS* = HRESULT 0x8032000B'i32 + FWP_E_WRONG_SESSION* = HRESULT 0x8032000C'i32 + FWP_E_NO_TXN_IN_PROGRESS* = HRESULT 0x8032000D'i32 + FWP_E_TXN_IN_PROGRESS* = HRESULT 0x8032000E'i32 + FWP_E_TXN_ABORTED* = HRESULT 0x8032000F'i32 + FWP_E_SESSION_ABORTED* = HRESULT 0x80320010'i32 + FWP_E_INCOMPATIBLE_TXN* = HRESULT 0x80320011'i32 + FWP_E_TIMEOUT* = HRESULT 0x80320012'i32 + FWP_E_NET_EVENTS_DISABLED* = HRESULT 0x80320013'i32 + FWP_E_INCOMPATIBLE_LAYER* = HRESULT 0x80320014'i32 + FWP_E_KM_CLIENTS_ONLY* = HRESULT 0x80320015'i32 + FWP_E_LIFETIME_MISMATCH* = HRESULT 0x80320016'i32 + FWP_E_BUILTIN_OBJECT* = HRESULT 0x80320017'i32 + FWP_E_TOO_MANY_CALLOUTS* = HRESULT 0x80320018'i32 + FWP_E_NOTIFICATION_DROPPED* = HRESULT 0x80320019'i32 + FWP_E_TRAFFIC_MISMATCH* = HRESULT 0x8032001A'i32 + FWP_E_INCOMPATIBLE_SA_STATE* = HRESULT 0x8032001B'i32 + FWP_E_NULL_POINTER* = HRESULT 0x8032001C'i32 + FWP_E_INVALID_ENUMERATOR* = HRESULT 0x8032001D'i32 + FWP_E_INVALID_FLAGS* = HRESULT 0x8032001E'i32 + FWP_E_INVALID_NET_MASK* = HRESULT 0x8032001F'i32 + FWP_E_INVALID_RANGE* = HRESULT 0x80320020'i32 + FWP_E_INVALID_INTERVAL* = HRESULT 0x80320021'i32 + FWP_E_ZERO_LENGTH_ARRAY* = HRESULT 0x80320022'i32 + FWP_E_NULL_DISPLAY_NAME* = HRESULT 0x80320023'i32 + FWP_E_INVALID_ACTION_TYPE* = HRESULT 0x80320024'i32 + FWP_E_INVALID_WEIGHT* = HRESULT 0x80320025'i32 + FWP_E_MATCH_TYPE_MISMATCH* = HRESULT 0x80320026'i32 + FWP_E_TYPE_MISMATCH* = HRESULT 0x80320027'i32 + FWP_E_OUT_OF_BOUNDS* = HRESULT 0x80320028'i32 + FWP_E_RESERVED* = HRESULT 0x80320029'i32 + FWP_E_DUPLICATE_CONDITION* = HRESULT 0x8032002A'i32 + FWP_E_DUPLICATE_KEYMOD* = HRESULT 0x8032002B'i32 + FWP_E_ACTION_INCOMPATIBLE_WITH_LAYER* = HRESULT 0x8032002C'i32 + FWP_E_ACTION_INCOMPATIBLE_WITH_SUBLAYER* = HRESULT 0x8032002D'i32 + FWP_E_CONTEXT_INCOMPATIBLE_WITH_LAYER* = HRESULT 0x8032002E'i32 + FWP_E_CONTEXT_INCOMPATIBLE_WITH_CALLOUT* = HRESULT 0x8032002F'i32 + FWP_E_INCOMPATIBLE_AUTH_METHOD* = HRESULT 0x80320030'i32 + FWP_E_INCOMPATIBLE_DH_GROUP* = HRESULT 0x80320031'i32 + FWP_E_EM_NOT_SUPPORTED* = HRESULT 0x80320032'i32 + FWP_E_NEVER_MATCH* = HRESULT 0x80320033'i32 + FWP_E_PROVIDER_CONTEXT_MISMATCH* = HRESULT 0x80320034'i32 + FWP_E_INVALID_PARAMETER* = HRESULT 0x80320035'i32 + FWP_E_TOO_MANY_SUBLAYERS* = HRESULT 0x80320036'i32 + FWP_E_CALLOUT_NOTIFICATION_FAILED* = HRESULT 0x80320037'i32 + FWP_E_INVALID_AUTH_TRANSFORM* = HRESULT 0x80320038'i32 + FWP_E_INVALID_CIPHER_TRANSFORM* = HRESULT 0x80320039'i32 + NAP_E_INVALID_PACKET* = HRESULT 0x80270001'i32 + NAP_E_MISSING_SOH* = HRESULT 0x80270002'i32 + NAP_E_CONFLICTING_ID* = HRESULT 0x80270003'i32 + NAP_E_NO_CACHED_SOH* = HRESULT 0x80270004'i32 + NAP_E_STILL_BOUND* = HRESULT 0x80270005'i32 + NAP_E_NOT_REGISTERED* = HRESULT 0x80270006'i32 + NAP_E_NOT_INITIALIZED* = HRESULT 0x80270007'i32 + NAP_E_MISMATCHED_ID* = HRESULT 0x80270008'i32 + NAP_E_NOT_PENDING* = HRESULT 0x80270009'i32 + NAP_E_ID_NOT_FOUND* = HRESULT 0x8027000A'i32 + NAP_E_MAXSIZE_TOO_SMALL* = HRESULT 0x8027000B'i32 + NAP_E_SERVICE_NOT_RUNNING* = HRESULT 0x8027000C'i32 + NAP_S_CERT_ALREADY_PRESENT* = HRESULT 0x0027000D + NAP_E_ENTITY_DISABLED* = HRESULT 0x8027000E'i32 + NAP_E_NETSH_GROUPPOLICY_ERROR* = HRESULT 0x8027000F'i32 + NAP_E_TOO_MANY_CALLS* = HRESULT 0x80270010'i32 + NAP_E_SHV_CONFIG_EXISTED* = HRESULT 0x80270011'i32 + NAP_E_SHV_CONFIG_NOT_FOUND* = HRESULT 0x80270012'i32 + NAP_E_SHV_TIMEOUT* = HRESULT 0x80270013'i32 + FACILITY_USERMODE_FILTER_MANAGER* = 0x1f + ERROR_FLT_IO_COMPLETE* = HRESULT 0x001f0001 + ERROR_FLT_NO_HANDLER_DEFINED* = HRESULT 0x801f0001'i32 + ERROR_FLT_CONTEXT_ALREADY_DEFINED* = HRESULT 0x801f0002'i32 + ERROR_FLT_INVALID_ASYNCHRONOUS_REQUEST* = HRESULT 0x801f0003'i32 + ERROR_FLT_DISALLOW_FAST_IO* = HRESULT 0x801f0004'i32 + ERROR_FLT_INVALID_NAME_REQUEST* = HRESULT 0x801f0005'i32 + ERROR_FLT_NOT_SAFE_TO_POST_OPERATION* = HRESULT 0x801f0006'i32 + ERROR_FLT_NOT_INITIALIZED* = HRESULT 0x801f0007'i32 + ERROR_FLT_FILTER_NOT_READY* = HRESULT 0x801f0008'i32 + ERROR_FLT_POST_OPERATION_CLEANUP* = HRESULT 0x801f0009'i32 + ERROR_FLT_INTERNAL_ERROR* = HRESULT 0x801f000a'i32 + ERROR_FLT_DELETING_OBJECT* = HRESULT 0x801f000b'i32 + ERROR_FLT_MUST_BE_NONPAGED_POOL* = HRESULT 0x801f000c'i32 + ERROR_FLT_DUPLICATE_ENTRY* = HRESULT 0x801f000d'i32 + ERROR_FLT_CBDQ_DISABLED* = HRESULT 0x801f000e'i32 + ERROR_FLT_DO_NOT_ATTACH* = HRESULT 0x801f000f'i32 + ERROR_FLT_DO_NOT_DETACH* = HRESULT 0x801f0010'i32 + ERROR_FLT_INSTANCE_ALTITUDE_COLLISION* = HRESULT 0x801f0011'i32 + ERROR_FLT_INSTANCE_NAME_COLLISION* = HRESULT 0x801f0012'i32 + ERROR_FLT_FILTER_NOT_FOUND* = HRESULT 0x801f0013'i32 + ERROR_FLT_VOLUME_NOT_FOUND* = HRESULT 0x801f0014'i32 + ERROR_FLT_INSTANCE_NOT_FOUND* = HRESULT 0x801f0015'i32 + ERROR_FLT_CONTEXT_ALLOCATION_NOT_FOUND* = HRESULT 0x801f0016'i32 + ERROR_FLT_INVALID_CONTEXT_REGISTRATION* = HRESULT 0x801f0017'i32 + ERROR_FLT_NAME_CACHE_MISS* = HRESULT 0x801f0018'i32 + ERROR_FLT_NO_DEVICE_OBJECT* = HRESULT 0x801f0019'i32 + ERROR_FLT_VOLUME_ALREADY_MOUNTED* = HRESULT 0x801f001a'i32 + ERROR_FLT_ALREADY_ENLISTED* = HRESULT 0x801f001b'i32 + ERROR_FLT_CONTEXT_ALREADY_LINKED* = HRESULT 0x801F001c'i32 + ERROR_FLT_NO_WAITER_FOR_REPLY* = HRESULT 0x801f0020'i32 + ERROR_FLT_REGISTRATION_BUSY* = HRESULT 0x801F0023'i32 +template SUCCEEDED*(hr: untyped): bool = hr.HRESULT >= 0 +template FAILED*(hr: untyped): bool = hr.HRESULT < 0 +template IS_ERROR*(Status: untyped): bool = Status shr 31 == SEVERITY_ERROR +template HRESULT_CODE*(hr: untyped): WORD = WORD(hr and 0xFFFF) +template SCODE_CODE*(sc: untyped): WORD = WORD(sc and 0xFFFF) +template HRESULT_FACILITY*(hr: untyped): WORD = WORD((hr shr 16) and 0x1fff) +template SCODE_FACILITY*(sc: untyped): WORD = WORD((sc shr 16) and 0x1fff) +template HRESULT_SEVERITY*(hr: untyped): DWORD = DWORD((hr shr 31) and 0x1) +template SCODE_SEVERITY*(sc: untyped): DWORD = DWORD((hr shr 31) and 0x1) +template MAKE_HRESULT*(sev: untyped, fac: untyped, code: untyped): HRESULT = (sev.HRESULT shl 31) or (fac.HRESULT shl 16) or (code.HRESULT) +template MAKE_SCODE*(sev: untyped, fac: untyped, code: untyped): HRESULT = (sev.HRESULT shl 31) or (fac.HRESULT shl 16) or (code.HRESULT) +template HRESULT_FROM_NT*(x: untyped): HRESULT = HRESULT(x or FACILITY_NT_BIT) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wingdi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wingdi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,3966 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + FXPT16DOT16* = int32 + LPFXPT16DOT16* = ptr int32 + FXPT2DOT30* = int32 + LPFXPT2DOT30* = ptr int32 + DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY* = int32 + DISPLAYCONFIG_SCANLINE_ORDERING* = int32 + DISPLAYCONFIG_SCALING* = int32 + DISPLAYCONFIG_ROTATION* = int32 + DISPLAYCONFIG_MODE_INFO_TYPE* = int32 + DISPLAYCONFIG_PIXELFORMAT* = int32 + DISPLAYCONFIG_TOPOLOGY_ID* = int32 + DISPLAYCONFIG_DEVICE_INFO_TYPE* = int32 + LCSCSTYPE* = LONG + LCSGAMUTMATCH* = LONG + COLOR16* = USHORT +when winimUnicode: + type + BCHAR* = WCHAR +when winimAnsi: + type + BCHAR* = BYTE +type + DRAWPATRECT* {.pure.} = object + ptPosition*: POINT + ptSize*: POINT + wStyle*: WORD + wPattern*: WORD + PDRAWPATRECT* = ptr DRAWPATRECT + PSINJECTDATA* {.pure.} = object + DataBytes*: DWORD + InjectionPoint*: WORD + PageNumber*: WORD + PPSINJECTDATA* = ptr PSINJECTDATA + PSFEATURE_OUTPUT* {.pure.} = object + bPageIndependent*: WINBOOL + bSetPageDevice*: WINBOOL + PPSFEATURE_OUTPUT* = ptr PSFEATURE_OUTPUT + PSFEATURE_CUSTPAPER* {.pure.} = object + lOrientation*: LONG + lWidth*: LONG + lHeight*: LONG + lWidthOffset*: LONG + lHeightOffset*: LONG + PPSFEATURE_CUSTPAPER* = ptr PSFEATURE_CUSTPAPER + XFORM* {.pure.} = object + eM11*: FLOAT + eM12*: FLOAT + eM21*: FLOAT + eM22*: FLOAT + eDx*: FLOAT + eDy*: FLOAT + PXFORM* = ptr XFORM + LPXFORM* = ptr XFORM + BITMAP* {.pure.} = object + bmType*: LONG + bmWidth*: LONG + bmHeight*: LONG + bmWidthBytes*: LONG + bmPlanes*: WORD + bmBitsPixel*: WORD + bmBits*: LPVOID + PBITMAP* = ptr BITMAP + NPBITMAP* = ptr BITMAP + LPBITMAP* = ptr BITMAP + RGBQUAD* {.pure.} = object + rgbBlue*: BYTE + rgbGreen*: BYTE + rgbRed*: BYTE + rgbReserved*: BYTE + LPRGBQUAD* = ptr RGBQUAD + CIEXYZ* {.pure.} = object + ciexyzX*: FXPT2DOT30 + ciexyzY*: FXPT2DOT30 + ciexyzZ*: FXPT2DOT30 + LPCIEXYZ* = ptr CIEXYZ + CIEXYZTRIPLE* {.pure.} = object + ciexyzRed*: CIEXYZ + ciexyzGreen*: CIEXYZ + ciexyzBlue*: CIEXYZ + LPCIEXYZTRIPLE* = ptr CIEXYZTRIPLE + LOGCOLORSPACEA* {.pure.} = object + lcsSignature*: DWORD + lcsVersion*: DWORD + lcsSize*: DWORD + lcsCSType*: LCSCSTYPE + lcsIntent*: LCSGAMUTMATCH + lcsEndpoints*: CIEXYZTRIPLE + lcsGammaRed*: DWORD + lcsGammaGreen*: DWORD + lcsGammaBlue*: DWORD + lcsFilename*: array[MAX_PATH, CHAR] + LPLOGCOLORSPACEA* = ptr LOGCOLORSPACEA + LOGCOLORSPACEW* {.pure.} = object + lcsSignature*: DWORD + lcsVersion*: DWORD + lcsSize*: DWORD + lcsCSType*: LCSCSTYPE + lcsIntent*: LCSGAMUTMATCH + lcsEndpoints*: CIEXYZTRIPLE + lcsGammaRed*: DWORD + lcsGammaGreen*: DWORD + lcsGammaBlue*: DWORD + lcsFilename*: array[MAX_PATH, WCHAR] + LPLOGCOLORSPACEW* = ptr LOGCOLORSPACEW + BITMAPCOREHEADER* {.pure.} = object + bcSize*: DWORD + bcWidth*: WORD + bcHeight*: WORD + bcPlanes*: WORD + bcBitCount*: WORD + LPBITMAPCOREHEADER* = ptr BITMAPCOREHEADER + PBITMAPCOREHEADER* = ptr BITMAPCOREHEADER + BITMAPINFOHEADER* {.pure.} = object + biSize*: DWORD + biWidth*: LONG + biHeight*: LONG + biPlanes*: WORD + biBitCount*: WORD + biCompression*: DWORD + biSizeImage*: DWORD + biXPelsPerMeter*: LONG + biYPelsPerMeter*: LONG + biClrUsed*: DWORD + biClrImportant*: DWORD + LPBITMAPINFOHEADER* = ptr BITMAPINFOHEADER + PBITMAPINFOHEADER* = ptr BITMAPINFOHEADER + BITMAPV4HEADER* {.pure.} = object + bV4Size*: DWORD + bV4Width*: LONG + bV4Height*: LONG + bV4Planes*: WORD + bV4BitCount*: WORD + bV4V4Compression*: DWORD + bV4SizeImage*: DWORD + bV4XPelsPerMeter*: LONG + bV4YPelsPerMeter*: LONG + bV4ClrUsed*: DWORD + bV4ClrImportant*: DWORD + bV4RedMask*: DWORD + bV4GreenMask*: DWORD + bV4BlueMask*: DWORD + bV4AlphaMask*: DWORD + bV4CSType*: DWORD + bV4Endpoints*: CIEXYZTRIPLE + bV4GammaRed*: DWORD + bV4GammaGreen*: DWORD + bV4GammaBlue*: DWORD + LPBITMAPV4HEADER* = ptr BITMAPV4HEADER + PBITMAPV4HEADER* = ptr BITMAPV4HEADER + BITMAPV5HEADER* {.pure.} = object + bV5Size*: DWORD + bV5Width*: LONG + bV5Height*: LONG + bV5Planes*: WORD + bV5BitCount*: WORD + bV5Compression*: DWORD + bV5SizeImage*: DWORD + bV5XPelsPerMeter*: LONG + bV5YPelsPerMeter*: LONG + bV5ClrUsed*: DWORD + bV5ClrImportant*: DWORD + bV5RedMask*: DWORD + bV5GreenMask*: DWORD + bV5BlueMask*: DWORD + bV5AlphaMask*: DWORD + bV5CSType*: DWORD + bV5Endpoints*: CIEXYZTRIPLE + bV5GammaRed*: DWORD + bV5GammaGreen*: DWORD + bV5GammaBlue*: DWORD + bV5Intent*: DWORD + bV5ProfileData*: DWORD + bV5ProfileSize*: DWORD + bV5Reserved*: DWORD + LPBITMAPV5HEADER* = ptr BITMAPV5HEADER + PBITMAPV5HEADER* = ptr BITMAPV5HEADER + BITMAPINFO* {.pure.} = object + bmiHeader*: BITMAPINFOHEADER + bmiColors*: array[1, RGBQUAD] + LPBITMAPINFO* = ptr BITMAPINFO + PBITMAPINFO* = ptr BITMAPINFO + RGBTRIPLE* {.pure.} = object + rgbtBlue*: BYTE + rgbtGreen*: BYTE + rgbtRed*: BYTE + BITMAPCOREINFO* {.pure.} = object + bmciHeader*: BITMAPCOREHEADER + bmciColors*: array[1, RGBTRIPLE] + LPBITMAPCOREINFO* = ptr BITMAPCOREINFO + PBITMAPCOREINFO* = ptr BITMAPCOREINFO + BITMAPFILEHEADER* {.pure, packed.} = object + bfType*: WORD + bfSize*: DWORD + bfReserved1*: WORD + bfReserved2*: WORD + bfOffBits*: DWORD + LPBITMAPFILEHEADER* = ptr BITMAPFILEHEADER + PBITMAPFILEHEADER* = ptr BITMAPFILEHEADER + FONTSIGNATURE* {.pure.} = object + fsUsb*: array[4, DWORD] + fsCsb*: array[2, DWORD] + PFONTSIGNATURE* = ptr FONTSIGNATURE + LPFONTSIGNATURE* = ptr FONTSIGNATURE + CHARSETINFO* {.pure.} = object + ciCharset*: UINT + ciACP*: UINT + fs*: FONTSIGNATURE + PCHARSETINFO* = ptr CHARSETINFO + NPCHARSETINFO* = ptr CHARSETINFO + LPCHARSETINFO* = ptr CHARSETINFO + LOCALESIGNATURE* {.pure.} = object + lsUsb*: array[4, DWORD] + lsCsbDefault*: array[2, DWORD] + lsCsbSupported*: array[2, DWORD] + PLOCALESIGNATURE* = ptr LOCALESIGNATURE + LPLOCALESIGNATURE* = ptr LOCALESIGNATURE + HANDLETABLE* {.pure.} = object + objectHandle*: array[1, HGDIOBJ] + PHANDLETABLE* = ptr HANDLETABLE + LPHANDLETABLE* = ptr HANDLETABLE + METARECORD* {.pure.} = object + rdSize*: DWORD + rdFunction*: WORD + rdParm*: array[1, WORD] + PMETARECORD* = ptr METARECORD + LPMETARECORD* = ptr METARECORD + METAFILEPICT* {.pure.} = object + mm*: LONG + xExt*: LONG + yExt*: LONG + hMF*: HMETAFILE + LPMETAFILEPICT* = ptr METAFILEPICT + METAHEADER* {.pure, packed.} = object + mtType*: WORD + mtHeaderSize*: WORD + mtVersion*: WORD + mtSize*: DWORD + mtNoObjects*: WORD + mtMaxRecord*: DWORD + mtNoParameters*: WORD + PMETAHEADER* = ptr METAHEADER + LPMETAHEADER* = ptr METAHEADER + ENHMETARECORD* {.pure.} = object + iType*: DWORD + nSize*: DWORD + dParm*: array[1, DWORD] + PENHMETARECORD* = ptr ENHMETARECORD + LPENHMETARECORD* = ptr ENHMETARECORD + ENHMETAHEADER* {.pure.} = object + iType*: DWORD + nSize*: DWORD + rclBounds*: RECTL + rclFrame*: RECTL + dSignature*: DWORD + nVersion*: DWORD + nBytes*: DWORD + nRecords*: DWORD + nHandles*: WORD + sReserved*: WORD + nDescription*: DWORD + offDescription*: DWORD + nPalEntries*: DWORD + szlDevice*: SIZEL + szlMillimeters*: SIZEL + cbPixelFormat*: DWORD + offPixelFormat*: DWORD + bOpenGL*: DWORD + szlMicrometers*: SIZEL + PENHMETAHEADER* = ptr ENHMETAHEADER + LPENHMETAHEADER* = ptr ENHMETAHEADER + TEXTMETRICA* {.pure.} = object + tmHeight*: LONG + tmAscent*: LONG + tmDescent*: LONG + tmInternalLeading*: LONG + tmExternalLeading*: LONG + tmAveCharWidth*: LONG + tmMaxCharWidth*: LONG + tmWeight*: LONG + tmOverhang*: LONG + tmDigitizedAspectX*: LONG + tmDigitizedAspectY*: LONG + tmFirstChar*: BYTE + tmLastChar*: BYTE + tmDefaultChar*: BYTE + tmBreakChar*: BYTE + tmItalic*: BYTE + tmUnderlined*: BYTE + tmStruckOut*: BYTE + tmPitchAndFamily*: BYTE + tmCharSet*: BYTE + PTEXTMETRICA* = ptr TEXTMETRICA + NPTEXTMETRICA* = ptr TEXTMETRICA + LPTEXTMETRICA* = ptr TEXTMETRICA + TEXTMETRICW* {.pure.} = object + tmHeight*: LONG + tmAscent*: LONG + tmDescent*: LONG + tmInternalLeading*: LONG + tmExternalLeading*: LONG + tmAveCharWidth*: LONG + tmMaxCharWidth*: LONG + tmWeight*: LONG + tmOverhang*: LONG + tmDigitizedAspectX*: LONG + tmDigitizedAspectY*: LONG + tmFirstChar*: WCHAR + tmLastChar*: WCHAR + tmDefaultChar*: WCHAR + tmBreakChar*: WCHAR + tmItalic*: BYTE + tmUnderlined*: BYTE + tmStruckOut*: BYTE + tmPitchAndFamily*: BYTE + tmCharSet*: BYTE + PTEXTMETRICW* = ptr TEXTMETRICW + NPTEXTMETRICW* = ptr TEXTMETRICW + LPTEXTMETRICW* = ptr TEXTMETRICW + NEWTEXTMETRICA* {.pure.} = object + tmHeight*: LONG + tmAscent*: LONG + tmDescent*: LONG + tmInternalLeading*: LONG + tmExternalLeading*: LONG + tmAveCharWidth*: LONG + tmMaxCharWidth*: LONG + tmWeight*: LONG + tmOverhang*: LONG + tmDigitizedAspectX*: LONG + tmDigitizedAspectY*: LONG + tmFirstChar*: BYTE + tmLastChar*: BYTE + tmDefaultChar*: BYTE + tmBreakChar*: BYTE + tmItalic*: BYTE + tmUnderlined*: BYTE + tmStruckOut*: BYTE + tmPitchAndFamily*: BYTE + tmCharSet*: BYTE + ntmFlags*: DWORD + ntmSizeEM*: UINT + ntmCellHeight*: UINT + ntmAvgWidth*: UINT + PNEWTEXTMETRICA* = ptr NEWTEXTMETRICA + NPNEWTEXTMETRICA* = ptr NEWTEXTMETRICA + LPNEWTEXTMETRICA* = ptr NEWTEXTMETRICA + NEWTEXTMETRICW* {.pure.} = object + tmHeight*: LONG + tmAscent*: LONG + tmDescent*: LONG + tmInternalLeading*: LONG + tmExternalLeading*: LONG + tmAveCharWidth*: LONG + tmMaxCharWidth*: LONG + tmWeight*: LONG + tmOverhang*: LONG + tmDigitizedAspectX*: LONG + tmDigitizedAspectY*: LONG + tmFirstChar*: WCHAR + tmLastChar*: WCHAR + tmDefaultChar*: WCHAR + tmBreakChar*: WCHAR + tmItalic*: BYTE + tmUnderlined*: BYTE + tmStruckOut*: BYTE + tmPitchAndFamily*: BYTE + tmCharSet*: BYTE + ntmFlags*: DWORD + ntmSizeEM*: UINT + ntmCellHeight*: UINT + ntmAvgWidth*: UINT + PNEWTEXTMETRICW* = ptr NEWTEXTMETRICW + NPNEWTEXTMETRICW* = ptr NEWTEXTMETRICW + LPNEWTEXTMETRICW* = ptr NEWTEXTMETRICW + PELARRAY* {.pure.} = object + paXCount*: LONG + paYCount*: LONG + paXExt*: LONG + paYExt*: LONG + paRGBs*: BYTE + PPELARRAY* = ptr PELARRAY + NPPELARRAY* = ptr PELARRAY + LPPELARRAY* = ptr PELARRAY + LOGBRUSH* {.pure.} = object + lbStyle*: UINT + lbColor*: COLORREF + lbHatch*: ULONG_PTR + PLOGBRUSH* = ptr LOGBRUSH + NPLOGBRUSH* = ptr LOGBRUSH + LPLOGBRUSH* = ptr LOGBRUSH + LOGBRUSH32* {.pure.} = object + lbStyle*: UINT + lbColor*: COLORREF + lbHatch*: ULONG + PLOGBRUSH32* = ptr LOGBRUSH32 + NPLOGBRUSH32* = ptr LOGBRUSH32 + LPLOGBRUSH32* = ptr LOGBRUSH32 + PATTERN* = LOGBRUSH + PPATTERN* = ptr PATTERN + NPPATTERN* = ptr PATTERN + LPPATTERN* = ptr PATTERN + LOGPEN* {.pure.} = object + lopnStyle*: UINT + lopnWidth*: POINT + lopnColor*: COLORREF + PLOGPEN* = ptr LOGPEN + NPLOGPEN* = ptr LOGPEN + LPLOGPEN* = ptr LOGPEN + EXTLOGPEN* {.pure.} = object + elpPenStyle*: DWORD + elpWidth*: DWORD + elpBrushStyle*: UINT + elpColor*: COLORREF + elpHatch*: ULONG_PTR + elpNumEntries*: DWORD + elpStyleEntry*: array[1, DWORD] + PEXTLOGPEN* = ptr EXTLOGPEN + NPEXTLOGPEN* = ptr EXTLOGPEN + LPEXTLOGPEN* = ptr EXTLOGPEN + EXTLOGPEN32* {.pure.} = object + elpPenStyle*: DWORD + elpWidth*: DWORD + elpBrushStyle*: UINT + elpColor*: COLORREF + elpHatch*: ULONG + elpNumEntries*: DWORD + elpStyleEntry*: array[1, DWORD] + PEXTLOGPEN32* = ptr EXTLOGPEN32 + NPEXTLOGPEN32* = ptr EXTLOGPEN32 + LPEXTLOGPEN32* = ptr EXTLOGPEN32 + PALETTEENTRY* {.pure.} = object + peRed*: BYTE + peGreen*: BYTE + peBlue*: BYTE + peFlags*: BYTE + PPALETTEENTRY* = ptr PALETTEENTRY + LPPALETTEENTRY* = ptr PALETTEENTRY + LOGPALETTE* {.pure.} = object + palVersion*: WORD + palNumEntries*: WORD + palPalEntry*: array[1, PALETTEENTRY] + PLOGPALETTE* = ptr LOGPALETTE + NPLOGPALETTE* = ptr LOGPALETTE + LPLOGPALETTE* = ptr LOGPALETTE +const + LF_FACESIZE* = 32 +type + LOGFONTA* {.pure.} = object + lfHeight*: LONG + lfWidth*: LONG + lfEscapement*: LONG + lfOrientation*: LONG + lfWeight*: LONG + lfItalic*: BYTE + lfUnderline*: BYTE + lfStrikeOut*: BYTE + lfCharSet*: BYTE + lfOutPrecision*: BYTE + lfClipPrecision*: BYTE + lfQuality*: BYTE + lfPitchAndFamily*: BYTE + lfFaceName*: array[LF_FACESIZE, CHAR] + PLOGFONTA* = ptr LOGFONTA + NPLOGFONTA* = ptr LOGFONTA + LPLOGFONTA* = ptr LOGFONTA + LOGFONTW* {.pure.} = object + lfHeight*: LONG + lfWidth*: LONG + lfEscapement*: LONG + lfOrientation*: LONG + lfWeight*: LONG + lfItalic*: BYTE + lfUnderline*: BYTE + lfStrikeOut*: BYTE + lfCharSet*: BYTE + lfOutPrecision*: BYTE + lfClipPrecision*: BYTE + lfQuality*: BYTE + lfPitchAndFamily*: BYTE + lfFaceName*: array[LF_FACESIZE, WCHAR] + PLOGFONTW* = ptr LOGFONTW + NPLOGFONTW* = ptr LOGFONTW + LPLOGFONTW* = ptr LOGFONTW +const + LF_FULLFACESIZE* = 64 +type + ENUMLOGFONTA* {.pure.} = object + elfLogFont*: LOGFONTA + elfFullName*: array[LF_FULLFACESIZE, BYTE] + elfStyle*: array[LF_FACESIZE, BYTE] + LPENUMLOGFONTA* = ptr ENUMLOGFONTA + ENUMLOGFONTW* {.pure.} = object + elfLogFont*: LOGFONTW + elfFullName*: array[LF_FULLFACESIZE, WCHAR] + elfStyle*: array[LF_FACESIZE, WCHAR] + LPENUMLOGFONTW* = ptr ENUMLOGFONTW + ENUMLOGFONTEXA* {.pure.} = object + elfLogFont*: LOGFONTA + elfFullName*: array[LF_FULLFACESIZE, BYTE] + elfStyle*: array[LF_FACESIZE, BYTE] + elfScript*: array[LF_FACESIZE, BYTE] + LPENUMLOGFONTEXA* = ptr ENUMLOGFONTEXA + ENUMLOGFONTEXW* {.pure.} = object + elfLogFont*: LOGFONTW + elfFullName*: array[LF_FULLFACESIZE, WCHAR] + elfStyle*: array[LF_FACESIZE, WCHAR] + elfScript*: array[LF_FACESIZE, WCHAR] + LPENUMLOGFONTEXW* = ptr ENUMLOGFONTEXW + PANOSE* {.pure.} = object + bFamilyType*: BYTE + bSerifStyle*: BYTE + bWeight*: BYTE + bProportion*: BYTE + bContrast*: BYTE + bStrokeVariation*: BYTE + bArmStyle*: BYTE + bLetterform*: BYTE + bMidline*: BYTE + bXHeight*: BYTE + LPPANOSE* = ptr PANOSE +const + ELF_VENDOR_SIZE* = 4 +type + EXTLOGFONTA* {.pure.} = object + elfLogFont*: LOGFONTA + elfFullName*: array[LF_FULLFACESIZE, BYTE] + elfStyle*: array[LF_FACESIZE, BYTE] + elfVersion*: DWORD + elfStyleSize*: DWORD + elfMatch*: DWORD + elfReserved*: DWORD + elfVendorId*: array[ELF_VENDOR_SIZE, BYTE] + elfCulture*: DWORD + elfPanose*: PANOSE + PEXTLOGFONTA* = ptr EXTLOGFONTA + NPEXTLOGFONTA* = ptr EXTLOGFONTA + LPEXTLOGFONTA* = ptr EXTLOGFONTA + EXTLOGFONTW* {.pure.} = object + elfLogFont*: LOGFONTW + elfFullName*: array[LF_FULLFACESIZE, WCHAR] + elfStyle*: array[LF_FACESIZE, WCHAR] + elfVersion*: DWORD + elfStyleSize*: DWORD + elfMatch*: DWORD + elfReserved*: DWORD + elfVendorId*: array[ELF_VENDOR_SIZE, BYTE] + elfCulture*: DWORD + elfPanose*: PANOSE + PEXTLOGFONTW* = ptr EXTLOGFONTW + NPEXTLOGFONTW* = ptr EXTLOGFONTW + LPEXTLOGFONTW* = ptr EXTLOGFONTW +const + CCHDEVICENAME* = 32 +type + DEVMODEA_UNION1_STRUCT1* {.pure.} = object + dmOrientation*: int16 + dmPaperSize*: int16 + dmPaperLength*: int16 + dmPaperWidth*: int16 + dmScale*: int16 + dmCopies*: int16 + dmDefaultSource*: int16 + dmPrintQuality*: int16 + DEVMODEA_UNION1_STRUCT2* {.pure.} = object + dmPosition*: POINTL + dmDisplayOrientation*: DWORD + dmDisplayFixedOutput*: DWORD + DEVMODEA_UNION1* {.pure, union.} = object + struct1*: DEVMODEA_UNION1_STRUCT1 + struct2*: DEVMODEA_UNION1_STRUCT2 +const + CCHFORMNAME* = 32 +type + DEVMODEA_UNION2* {.pure, union.} = object + dmDisplayFlags*: DWORD + dmNup*: DWORD + DEVMODEA* {.pure.} = object + dmDeviceName*: array[CCHDEVICENAME, BYTE] + dmSpecVersion*: WORD + dmDriverVersion*: WORD + dmSize*: WORD + dmDriverExtra*: WORD + dmFields*: DWORD + union1*: DEVMODEA_UNION1 + dmColor*: int16 + dmDuplex*: int16 + dmYResolution*: int16 + dmTTOption*: int16 + dmCollate*: int16 + dmFormName*: array[CCHFORMNAME, BYTE] + dmLogPixels*: WORD + dmBitsPerPel*: DWORD + dmPelsWidth*: DWORD + dmPelsHeight*: DWORD + union2*: DEVMODEA_UNION2 + dmDisplayFrequency*: DWORD + dmICMMethod*: DWORD + dmICMIntent*: DWORD + dmMediaType*: DWORD + dmDitherType*: DWORD + dmReserved1*: DWORD + dmReserved2*: DWORD + dmPanningWidth*: DWORD + dmPanningHeight*: DWORD + PDEVMODEA* = ptr DEVMODEA + NPDEVMODEA* = ptr DEVMODEA + LPDEVMODEA* = ptr DEVMODEA + DEVMODEW_UNION1_STRUCT1* {.pure.} = object + dmOrientation*: int16 + dmPaperSize*: int16 + dmPaperLength*: int16 + dmPaperWidth*: int16 + dmScale*: int16 + dmCopies*: int16 + dmDefaultSource*: int16 + dmPrintQuality*: int16 + DEVMODEW_UNION1_STRUCT2* {.pure.} = object + dmPosition*: POINTL + dmDisplayOrientation*: DWORD + dmDisplayFixedOutput*: DWORD + DEVMODEW_UNION1* {.pure, union.} = object + struct1*: DEVMODEW_UNION1_STRUCT1 + struct2*: DEVMODEW_UNION1_STRUCT2 + DEVMODEW_UNION2* {.pure, union.} = object + dmDisplayFlags*: DWORD + dmNup*: DWORD + DEVMODEW* {.pure.} = object + dmDeviceName*: array[CCHDEVICENAME, WCHAR] + dmSpecVersion*: WORD + dmDriverVersion*: WORD + dmSize*: WORD + dmDriverExtra*: WORD + dmFields*: DWORD + union1*: DEVMODEW_UNION1 + dmColor*: int16 + dmDuplex*: int16 + dmYResolution*: int16 + dmTTOption*: int16 + dmCollate*: int16 + dmFormName*: array[CCHFORMNAME, WCHAR] + dmLogPixels*: WORD + dmBitsPerPel*: DWORD + dmPelsWidth*: DWORD + dmPelsHeight*: DWORD + union2*: DEVMODEW_UNION2 + dmDisplayFrequency*: DWORD + dmICMMethod*: DWORD + dmICMIntent*: DWORD + dmMediaType*: DWORD + dmDitherType*: DWORD + dmReserved1*: DWORD + dmReserved2*: DWORD + dmPanningWidth*: DWORD + dmPanningHeight*: DWORD + PDEVMODEW* = ptr DEVMODEW + NPDEVMODEW* = ptr DEVMODEW + LPDEVMODEW* = ptr DEVMODEW + DISPLAY_DEVICEA* {.pure.} = object + cb*: DWORD + DeviceName*: array[32, CHAR] + DeviceString*: array[128, CHAR] + StateFlags*: DWORD + DeviceID*: array[128, CHAR] + DeviceKey*: array[128, CHAR] + PDISPLAY_DEVICEA* = ptr DISPLAY_DEVICEA + LPDISPLAY_DEVICEA* = ptr DISPLAY_DEVICEA + DISPLAY_DEVICEW* {.pure.} = object + cb*: DWORD + DeviceName*: array[32, WCHAR] + DeviceString*: array[128, WCHAR] + StateFlags*: DWORD + DeviceID*: array[128, WCHAR] + DeviceKey*: array[128, WCHAR] + PDISPLAY_DEVICEW* = ptr DISPLAY_DEVICEW + LPDISPLAY_DEVICEW* = ptr DISPLAY_DEVICEW + RGNDATAHEADER* {.pure.} = object + dwSize*: DWORD + iType*: DWORD + nCount*: DWORD + nRgnSize*: DWORD + rcBound*: RECT + PRGNDATAHEADER* = ptr RGNDATAHEADER + RGNDATA* {.pure.} = object + rdh*: RGNDATAHEADER + Buffer*: array[1, char] + PRGNDATA* = ptr RGNDATA + NPRGNDATA* = ptr RGNDATA + LPRGNDATA* = ptr RGNDATA + ABC* {.pure.} = object + abcA*: int32 + abcB*: UINT + abcC*: int32 + PABC* = ptr ABC + NPABC* = ptr ABC + LPABC* = ptr ABC + ABCFLOAT* {.pure.} = object + abcfA*: FLOAT + abcfB*: FLOAT + abcfC*: FLOAT + PABCFLOAT* = ptr ABCFLOAT + NPABCFLOAT* = ptr ABCFLOAT + LPABCFLOAT* = ptr ABCFLOAT + OUTLINETEXTMETRICA* {.pure.} = object + otmSize*: UINT + otmTextMetrics*: TEXTMETRICA + otmFiller*: BYTE + otmPanoseNumber*: PANOSE + otmfsSelection*: UINT + otmfsType*: UINT + otmsCharSlopeRise*: int32 + otmsCharSlopeRun*: int32 + otmItalicAngle*: int32 + otmEMSquare*: UINT + otmAscent*: int32 + otmDescent*: int32 + otmLineGap*: UINT + otmsCapEmHeight*: UINT + otmsXHeight*: UINT + otmrcFontBox*: RECT + otmMacAscent*: int32 + otmMacDescent*: int32 + otmMacLineGap*: UINT + otmusMinimumPPEM*: UINT + otmptSubscriptSize*: POINT + otmptSubscriptOffset*: POINT + otmptSuperscriptSize*: POINT + otmptSuperscriptOffset*: POINT + otmsStrikeoutSize*: UINT + otmsStrikeoutPosition*: int32 + otmsUnderscoreSize*: int32 + otmsUnderscorePosition*: int32 + otmpFamilyName*: PSTR + otmpFaceName*: PSTR + otmpStyleName*: PSTR + otmpFullName*: PSTR + POUTLINETEXTMETRICA* = ptr OUTLINETEXTMETRICA + NPOUTLINETEXTMETRICA* = ptr OUTLINETEXTMETRICA + LPOUTLINETEXTMETRICA* = ptr OUTLINETEXTMETRICA + OUTLINETEXTMETRICW* {.pure.} = object + otmSize*: UINT + otmTextMetrics*: TEXTMETRICW + otmFiller*: BYTE + otmPanoseNumber*: PANOSE + otmfsSelection*: UINT + otmfsType*: UINT + otmsCharSlopeRise*: int32 + otmsCharSlopeRun*: int32 + otmItalicAngle*: int32 + otmEMSquare*: UINT + otmAscent*: int32 + otmDescent*: int32 + otmLineGap*: UINT + otmsCapEmHeight*: UINT + otmsXHeight*: UINT + otmrcFontBox*: RECT + otmMacAscent*: int32 + otmMacDescent*: int32 + otmMacLineGap*: UINT + otmusMinimumPPEM*: UINT + otmptSubscriptSize*: POINT + otmptSubscriptOffset*: POINT + otmptSuperscriptSize*: POINT + otmptSuperscriptOffset*: POINT + otmsStrikeoutSize*: UINT + otmsStrikeoutPosition*: int32 + otmsUnderscoreSize*: int32 + otmsUnderscorePosition*: int32 + otmpFamilyName*: PSTR + otmpFaceName*: PSTR + otmpStyleName*: PSTR + otmpFullName*: PSTR + POUTLINETEXTMETRICW* = ptr OUTLINETEXTMETRICW + NPOUTLINETEXTMETRICW* = ptr OUTLINETEXTMETRICW + LPOUTLINETEXTMETRICW* = ptr OUTLINETEXTMETRICW + POLYTEXTA* {.pure.} = object + x*: int32 + y*: int32 + n*: UINT + lpstr*: LPCSTR + uiFlags*: UINT + rcl*: RECT + pdx*: ptr int32 + PPOLYTEXTA* = ptr POLYTEXTA + NPPOLYTEXTA* = ptr POLYTEXTA + LPPOLYTEXTA* = ptr POLYTEXTA + POLYTEXTW* {.pure.} = object + x*: int32 + y*: int32 + n*: UINT + lpstr*: LPCWSTR + uiFlags*: UINT + rcl*: RECT + pdx*: ptr int32 + PPOLYTEXTW* = ptr POLYTEXTW + NPPOLYTEXTW* = ptr POLYTEXTW + LPPOLYTEXTW* = ptr POLYTEXTW + FIXED* {.pure.} = object + fract*: WORD + value*: int16 + MAT2* {.pure.} = object + eM11*: FIXED + eM12*: FIXED + eM21*: FIXED + eM22*: FIXED + LPMAT2* = ptr MAT2 + GLYPHMETRICS* {.pure.} = object + gmBlackBoxX*: UINT + gmBlackBoxY*: UINT + gmptGlyphOrigin*: POINT + gmCellIncX*: int16 + gmCellIncY*: int16 + LPGLYPHMETRICS* = ptr GLYPHMETRICS + POINTFX* {.pure.} = object + x*: FIXED + y*: FIXED + LPPOINTFX* = ptr POINTFX + TTPOLYCURVE* {.pure.} = object + wType*: WORD + cpfx*: WORD + apfx*: array[1, POINTFX] + LPTTPOLYCURVE* = ptr TTPOLYCURVE + TTPOLYGONHEADER* {.pure.} = object + cb*: DWORD + dwType*: DWORD + pfxStart*: POINTFX + LPTTPOLYGONHEADER* = ptr TTPOLYGONHEADER + GCP_RESULTSA* {.pure.} = object + lStructSize*: DWORD + lpOutString*: LPSTR + lpOrder*: ptr UINT + lpDx*: ptr int32 + lpCaretPos*: ptr int32 + lpClass*: LPSTR + lpGlyphs*: LPWSTR + nGlyphs*: UINT + nMaxFit*: int32 + LPGCP_RESULTSA* = ptr GCP_RESULTSA + GCP_RESULTSW* {.pure.} = object + lStructSize*: DWORD + lpOutString*: LPWSTR + lpOrder*: ptr UINT + lpDx*: ptr int32 + lpCaretPos*: ptr int32 + lpClass*: LPSTR + lpGlyphs*: LPWSTR + nGlyphs*: UINT + nMaxFit*: int32 + LPGCP_RESULTSW* = ptr GCP_RESULTSW + RASTERIZER_STATUS* {.pure.} = object + nSize*: int16 + wFlags*: int16 + nLanguageID*: int16 + LPRASTERIZER_STATUS* = ptr RASTERIZER_STATUS + PIXELFORMATDESCRIPTOR* {.pure.} = object + nSize*: WORD + nVersion*: WORD + dwFlags*: DWORD + iPixelType*: BYTE + cColorBits*: BYTE + cRedBits*: BYTE + cRedShift*: BYTE + cGreenBits*: BYTE + cGreenShift*: BYTE + cBlueBits*: BYTE + cBlueShift*: BYTE + cAlphaBits*: BYTE + cAlphaShift*: BYTE + cAccumBits*: BYTE + cAccumRedBits*: BYTE + cAccumGreenBits*: BYTE + cAccumBlueBits*: BYTE + cAccumAlphaBits*: BYTE + cDepthBits*: BYTE + cStencilBits*: BYTE + cAuxBuffers*: BYTE + iLayerType*: BYTE + bReserved*: BYTE + dwLayerMask*: DWORD + dwVisibleMask*: DWORD + dwDamageMask*: DWORD + PPIXELFORMATDESCRIPTOR* = ptr PIXELFORMATDESCRIPTOR + LPPIXELFORMATDESCRIPTOR* = ptr PIXELFORMATDESCRIPTOR + OLDFONTENUMPROCA* = proc (P1: ptr LOGFONTA, P2: ptr TEXTMETRICA, P3: DWORD, P4: LPARAM): int32 {.stdcall.} + FONTENUMPROCA* = OLDFONTENUMPROCA + OLDFONTENUMPROCW* = proc (P1: ptr LOGFONTW, P2: ptr TEXTMETRICW, P3: DWORD, P4: LPARAM): int32 {.stdcall.} + FONTENUMPROCW* = OLDFONTENUMPROCW + WCRANGE* {.pure.} = object + wcLow*: WCHAR + cGlyphs*: USHORT + PWCRANGE* = ptr WCRANGE + LPWCRANGE* = ptr WCRANGE + GLYPHSET* {.pure.} = object + cbThis*: DWORD + flAccel*: DWORD + cGlyphsSupported*: DWORD + cRanges*: DWORD + ranges*: array[1, WCRANGE] + PGLYPHSET* = ptr GLYPHSET + LPGLYPHSET* = ptr GLYPHSET +const + MM_MAX_NUMAXES* = 16 +type + DESIGNVECTOR* {.pure.} = object + dvReserved*: DWORD + dvNumAxes*: DWORD + dvValues*: array[MM_MAX_NUMAXES, LONG] + PDESIGNVECTOR* = ptr DESIGNVECTOR + LPDESIGNVECTOR* = ptr DESIGNVECTOR +const + MM_MAX_AXES_NAMELEN* = 16 +type + AXISINFOA* {.pure.} = object + axMinValue*: LONG + axMaxValue*: LONG + axAxisName*: array[MM_MAX_AXES_NAMELEN, BYTE] + PAXISINFOA* = ptr AXISINFOA + LPAXISINFOA* = ptr AXISINFOA + AXISINFOW* {.pure.} = object + axMinValue*: LONG + axMaxValue*: LONG + axAxisName*: array[MM_MAX_AXES_NAMELEN, WCHAR] + PAXISINFOW* = ptr AXISINFOW + LPAXISINFOW* = ptr AXISINFOW + AXESLISTA* {.pure.} = object + axlReserved*: DWORD + axlNumAxes*: DWORD + axlAxisInfo*: array[MM_MAX_NUMAXES, AXISINFOA] + PAXESLISTA* = ptr AXESLISTA + LPAXESLISTA* = ptr AXESLISTA + AXESLISTW* {.pure.} = object + axlReserved*: DWORD + axlNumAxes*: DWORD + axlAxisInfo*: array[MM_MAX_NUMAXES, AXISINFOW] + PAXESLISTW* = ptr AXESLISTW + LPAXESLISTW* = ptr AXESLISTW + ENUMLOGFONTEXDVA* {.pure.} = object + elfEnumLogfontEx*: ENUMLOGFONTEXA + elfDesignVector*: DESIGNVECTOR + PENUMLOGFONTEXDVA* = ptr ENUMLOGFONTEXDVA + LPENUMLOGFONTEXDVA* = ptr ENUMLOGFONTEXDVA + ENUMLOGFONTEXDVW* {.pure.} = object + elfEnumLogfontEx*: ENUMLOGFONTEXW + elfDesignVector*: DESIGNVECTOR + PENUMLOGFONTEXDVW* = ptr ENUMLOGFONTEXDVW + LPENUMLOGFONTEXDVW* = ptr ENUMLOGFONTEXDVW + NEWTEXTMETRICEXA* {.pure.} = object + ntmTm*: NEWTEXTMETRICA + ntmFontSig*: FONTSIGNATURE + ENUMTEXTMETRICA* {.pure.} = object + etmNewTextMetricEx*: NEWTEXTMETRICEXA + etmAxesList*: AXESLISTA + PENUMTEXTMETRICA* = ptr ENUMTEXTMETRICA + LPENUMTEXTMETRICA* = ptr ENUMTEXTMETRICA + NEWTEXTMETRICEXW* {.pure.} = object + ntmTm*: NEWTEXTMETRICW + ntmFontSig*: FONTSIGNATURE + ENUMTEXTMETRICW* {.pure.} = object + etmNewTextMetricEx*: NEWTEXTMETRICEXW + etmAxesList*: AXESLISTW + PENUMTEXTMETRICW* = ptr ENUMTEXTMETRICW + LPENUMTEXTMETRICW* = ptr ENUMTEXTMETRICW + DDRAWMARSHCALLBACKMARSHAL* = proc (hGdiObj: HGDIOBJ, pGdiRef: LPVOID, ppDDrawRef: ptr LPVOID): HRESULT {.stdcall.} + DDRAWMARSHCALLBACKUNMARSHAL* = proc (pData: LPVOID, phdc: ptr HDC, ppDDrawRef: ptr LPVOID): HRESULT {.stdcall.} + DDRAWMARSHCALLBACKRELEASE* = proc (pDDrawRef: LPVOID): HRESULT {.stdcall.} + GDIREGISTERDDRAWPACKET* {.pure.} = object + dwSize*: DWORD + dwVersion*: DWORD + pfnDdMarshal*: DDRAWMARSHCALLBACKMARSHAL + pfnDdUnmarshal*: DDRAWMARSHCALLBACKUNMARSHAL + pfnDdRelease*: DDRAWMARSHCALLBACKRELEASE + PGDIREGISTERDDRAWPACKET* = ptr GDIREGISTERDDRAWPACKET + TRIVERTEX* {.pure.} = object + x*: LONG + y*: LONG + Red*: COLOR16 + Green*: COLOR16 + Blue*: COLOR16 + Alpha*: COLOR16 + PTRIVERTEX* = ptr TRIVERTEX + LPTRIVERTEX* = ptr TRIVERTEX + GRADIENT_TRIANGLE* {.pure.} = object + Vertex1*: ULONG + Vertex2*: ULONG + Vertex3*: ULONG + PGRADIENT_TRIANGLE* = ptr GRADIENT_TRIANGLE + LPGRADIENT_TRIANGLE* = ptr GRADIENT_TRIANGLE + GRADIENT_RECT* {.pure.} = object + UpperLeft*: ULONG + LowerRight*: ULONG + PGRADIENT_RECT* = ptr GRADIENT_RECT + LPGRADIENT_RECT* = ptr GRADIENT_RECT + BLENDFUNCTION* {.pure.} = object + BlendOp*: BYTE + BlendFlags*: BYTE + SourceConstantAlpha*: BYTE + AlphaFormat*: BYTE + PBLENDFUNCTION* = ptr BLENDFUNCTION + DIBSECTION* {.pure.} = object + dsBm*: BITMAP + dsBmih*: BITMAPINFOHEADER + dsBitfields*: array[3, DWORD] + dshSection*: HANDLE + dsOffset*: DWORD + LPDIBSECTION* = ptr DIBSECTION + PDIBSECTION* = ptr DIBSECTION + COLORADJUSTMENT* {.pure.} = object + caSize*: WORD + caFlags*: WORD + caIlluminantIndex*: WORD + caRedGamma*: WORD + caGreenGamma*: WORD + caBlueGamma*: WORD + caReferenceBlack*: WORD + caReferenceWhite*: WORD + caContrast*: SHORT + caBrightness*: SHORT + caColorfulness*: SHORT + caRedGreenTint*: SHORT + PCOLORADJUSTMENT* = ptr COLORADJUSTMENT + LPCOLORADJUSTMENT* = ptr COLORADJUSTMENT + DOCINFOA* {.pure.} = object + cbSize*: int32 + lpszDocName*: LPCSTR + lpszOutput*: LPCSTR + lpszDatatype*: LPCSTR + fwType*: DWORD + LPDOCINFOA* = ptr DOCINFOA + DOCINFOW* {.pure.} = object + cbSize*: int32 + lpszDocName*: LPCWSTR + lpszOutput*: LPCWSTR + lpszDatatype*: LPCWSTR + fwType*: DWORD + LPDOCINFOW* = ptr DOCINFOW + KERNINGPAIR* {.pure.} = object + wFirst*: WORD + wSecond*: WORD + iKernAmount*: int32 + LPKERNINGPAIR* = ptr KERNINGPAIR + EMR* {.pure.} = object + iType*: DWORD + nSize*: DWORD + PEMR* = ptr EMR + EMRTEXT* {.pure.} = object + ptlReference*: POINTL + nChars*: DWORD + offString*: DWORD + fOptions*: DWORD + rcl*: RECTL + offDx*: DWORD + PEMRTEXT* = ptr EMRTEXT + EMRABORTPATH* {.pure.} = object + emr*: EMR + PEMRABORTPATH* = ptr EMRABORTPATH + EMRBEGINPATH* = EMRABORTPATH + PEMRBEGINPATH* = ptr EMRABORTPATH + EMRENDPATH* = EMRABORTPATH + PEMRENDPATH* = ptr EMRABORTPATH + EMRCLOSEFIGURE* = EMRABORTPATH + PEMRCLOSEFIGURE* = ptr EMRABORTPATH + EMRFLATTENPATH* = EMRABORTPATH + PEMRFLATTENPATH* = ptr EMRABORTPATH + EMRWIDENPATH* = EMRABORTPATH + PEMRWIDENPATH* = ptr EMRABORTPATH + EMRSETMETARGN* = EMRABORTPATH + PEMRSETMETARGN* = ptr EMRABORTPATH + EMRSAVEDC* = EMRABORTPATH + PEMRSAVEDC* = ptr EMRABORTPATH + EMRREALIZEPALETTE* = EMRABORTPATH + PEMRREALIZEPALETTE* = ptr EMRABORTPATH + EMRSELECTCLIPPATH* {.pure.} = object + emr*: EMR + iMode*: DWORD + PEMRSELECTCLIPPATH* = ptr EMRSELECTCLIPPATH + EMRSETBKMODE* = EMRSELECTCLIPPATH + PEMRSETBKMODE* = ptr EMRSELECTCLIPPATH + EMRSETMAPMODE* = EMRSELECTCLIPPATH + PEMRSETMAPMODE* = ptr EMRSELECTCLIPPATH + EMRSETLAYOUT* = EMRSELECTCLIPPATH + PEMRSETLAYOUT* = ptr EMRSELECTCLIPPATH + EMRSETPOLYFILLMODE* = EMRSELECTCLIPPATH + PEMRSETPOLYFILLMODE* = ptr EMRSELECTCLIPPATH + EMRSETROP2* = EMRSELECTCLIPPATH + PEMRSETROP2* = ptr EMRSELECTCLIPPATH + EMRSETSTRETCHBLTMODE* = EMRSELECTCLIPPATH + PEMRSETSTRETCHBLTMODE* = ptr EMRSELECTCLIPPATH + EMRSETICMMODE* = EMRSELECTCLIPPATH + PEMRSETICMMODE* = ptr EMRSELECTCLIPPATH + EMRSETTEXTALIGN* = EMRSELECTCLIPPATH + PEMRSETTEXTALIGN* = ptr EMRSELECTCLIPPATH + EMRSETMITERLIMIT* {.pure.} = object + emr*: EMR + eMiterLimit*: FLOAT + PEMRSETMITERLIMIT* = ptr EMRSETMITERLIMIT + EMRRESTOREDC* {.pure.} = object + emr*: EMR + iRelative*: LONG + PEMRRESTOREDC* = ptr EMRRESTOREDC + EMRSETARCDIRECTION* {.pure.} = object + emr*: EMR + iArcDirection*: DWORD + PEMRSETARCDIRECTION* = ptr EMRSETARCDIRECTION + EMRSETMAPPERFLAGS* {.pure.} = object + emr*: EMR + dwFlags*: DWORD + PEMRSETMAPPERFLAGS* = ptr EMRSETMAPPERFLAGS + EMRSETBKCOLOR* {.pure.} = object + emr*: EMR + crColor*: COLORREF + PEMRSETBKCOLOR* = ptr EMRSETBKCOLOR + EMRSETTEXTCOLOR* = EMRSETBKCOLOR + PEMRSETTEXTCOLOR* = ptr EMRSETBKCOLOR + EMRSELECTOBJECT* {.pure.} = object + emr*: EMR + ihObject*: DWORD + PEMRSELECTOBJECT* = ptr EMRSELECTOBJECT + EMRDELETEOBJECT* = EMRSELECTOBJECT + PEMRDELETEOBJECT* = ptr EMRSELECTOBJECT + EMRSELECTPALETTE* {.pure.} = object + emr*: EMR + ihPal*: DWORD + PEMRSELECTPALETTE* = ptr EMRSELECTPALETTE + EMRRESIZEPALETTE* {.pure.} = object + emr*: EMR + ihPal*: DWORD + cEntries*: DWORD + PEMRRESIZEPALETTE* = ptr EMRRESIZEPALETTE + EMRSETPALETTEENTRIES* {.pure.} = object + emr*: EMR + ihPal*: DWORD + iStart*: DWORD + cEntries*: DWORD + aPalEntries*: array[1, PALETTEENTRY] + PEMRSETPALETTEENTRIES* = ptr EMRSETPALETTEENTRIES + EMRSETCOLORADJUSTMENT* {.pure.} = object + emr*: EMR + ColorAdjustment*: COLORADJUSTMENT + PEMRSETCOLORADJUSTMENT* = ptr EMRSETCOLORADJUSTMENT + EMRGDICOMMENT* {.pure.} = object + emr*: EMR + cbData*: DWORD + Data*: array[1, BYTE] + PEMRGDICOMMENT* = ptr EMRGDICOMMENT + EMREOF* {.pure.} = object + emr*: EMR + nPalEntries*: DWORD + offPalEntries*: DWORD + nSizeLast*: DWORD + PEMREOF* = ptr EMREOF + EMRLINETO* {.pure.} = object + emr*: EMR + ptl*: POINTL + PEMRLINETO* = ptr EMRLINETO + EMRMOVETOEX* = EMRLINETO + PEMRMOVETOEX* = ptr EMRLINETO + EMROFFSETCLIPRGN* {.pure.} = object + emr*: EMR + ptlOffset*: POINTL + PEMROFFSETCLIPRGN* = ptr EMROFFSETCLIPRGN + EMRFILLPATH* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + PEMRFILLPATH* = ptr EMRFILLPATH + EMRSTROKEANDFILLPATH* = EMRFILLPATH + PEMRSTROKEANDFILLPATH* = ptr EMRFILLPATH + EMRSTROKEPATH* = EMRFILLPATH + PEMRSTROKEPATH* = ptr EMRFILLPATH + EMREXCLUDECLIPRECT* {.pure.} = object + emr*: EMR + rclClip*: RECTL + PEMREXCLUDECLIPRECT* = ptr EMREXCLUDECLIPRECT + EMRINTERSECTCLIPRECT* = EMREXCLUDECLIPRECT + PEMRINTERSECTCLIPRECT* = ptr EMREXCLUDECLIPRECT + EMRSETVIEWPORTORGEX* {.pure.} = object + emr*: EMR + ptlOrigin*: POINTL + PEMRSETVIEWPORTORGEX* = ptr EMRSETVIEWPORTORGEX + EMRSETWINDOWORGEX* = EMRSETVIEWPORTORGEX + PEMRSETWINDOWORGEX* = ptr EMRSETVIEWPORTORGEX + EMRSETBRUSHORGEX* = EMRSETVIEWPORTORGEX + PEMRSETBRUSHORGEX* = ptr EMRSETVIEWPORTORGEX + EMRSETVIEWPORTEXTEX* {.pure.} = object + emr*: EMR + szlExtent*: SIZEL + PEMRSETVIEWPORTEXTEX* = ptr EMRSETVIEWPORTEXTEX + EMRSETWINDOWEXTEX* = EMRSETVIEWPORTEXTEX + PEMRSETWINDOWEXTEX* = ptr EMRSETVIEWPORTEXTEX + EMRSCALEVIEWPORTEXTEX* {.pure.} = object + emr*: EMR + xNum*: LONG + xDenom*: LONG + yNum*: LONG + yDenom*: LONG + PEMRSCALEVIEWPORTEXTEX* = ptr EMRSCALEVIEWPORTEXTEX + EMRSCALEWINDOWEXTEX* = EMRSCALEVIEWPORTEXTEX + PEMRSCALEWINDOWEXTEX* = ptr EMRSCALEVIEWPORTEXTEX + EMRSETWORLDTRANSFORM* {.pure.} = object + emr*: EMR + xform*: XFORM + PEMRSETWORLDTRANSFORM* = ptr EMRSETWORLDTRANSFORM + EMRMODIFYWORLDTRANSFORM* {.pure.} = object + emr*: EMR + xform*: XFORM + iMode*: DWORD + PEMRMODIFYWORLDTRANSFORM* = ptr EMRMODIFYWORLDTRANSFORM + EMRSETPIXELV* {.pure.} = object + emr*: EMR + ptlPixel*: POINTL + crColor*: COLORREF + PEMRSETPIXELV* = ptr EMRSETPIXELV + EMREXTFLOODFILL* {.pure.} = object + emr*: EMR + ptlStart*: POINTL + crColor*: COLORREF + iMode*: DWORD + PEMREXTFLOODFILL* = ptr EMREXTFLOODFILL + EMRELLIPSE* {.pure.} = object + emr*: EMR + rclBox*: RECTL + PEMRELLIPSE* = ptr EMRELLIPSE + EMRRECTANGLE* = EMRELLIPSE + PEMRRECTANGLE* = ptr EMRELLIPSE + EMRROUNDRECT* {.pure.} = object + emr*: EMR + rclBox*: RECTL + szlCorner*: SIZEL + PEMRROUNDRECT* = ptr EMRROUNDRECT + EMRARC* {.pure.} = object + emr*: EMR + rclBox*: RECTL + ptlStart*: POINTL + ptlEnd*: POINTL + PEMRARC* = ptr EMRARC + EMRARCTO* = EMRARC + PEMRARCTO* = ptr EMRARC + EMRCHORD* = EMRARC + PEMRCHORD* = ptr EMRARC + EMRPIE* = EMRARC + PEMRPIE* = ptr EMRARC + EMRANGLEARC* {.pure.} = object + emr*: EMR + ptlCenter*: POINTL + nRadius*: DWORD + eStartAngle*: FLOAT + eSweepAngle*: FLOAT + PEMRANGLEARC* = ptr EMRANGLEARC + EMRPOLYLINE* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cptl*: DWORD + aptl*: array[1, POINTL] + PEMRPOLYLINE* = ptr EMRPOLYLINE + EMRPOLYBEZIER* = EMRPOLYLINE + PEMRPOLYBEZIER* = ptr EMRPOLYLINE + EMRPOLYGON* = EMRPOLYLINE + PEMRPOLYGON* = ptr EMRPOLYLINE + EMRPOLYBEZIERTO* = EMRPOLYLINE + PEMRPOLYBEZIERTO* = ptr EMRPOLYLINE + EMRPOLYLINETO* = EMRPOLYLINE + PEMRPOLYLINETO* = ptr EMRPOLYLINE + EMRPOLYLINE16* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cpts*: DWORD + apts*: array[1, POINTS] + PEMRPOLYLINE16* = ptr EMRPOLYLINE16 + EMRPOLYBEZIER16* = EMRPOLYLINE16 + PEMRPOLYBEZIER16* = ptr EMRPOLYLINE16 + EMRPOLYGON16* = EMRPOLYLINE16 + PEMRPOLYGON16* = ptr EMRPOLYLINE16 + EMRPOLYBEZIERTO16* = EMRPOLYLINE16 + PEMRPOLYBEZIERTO16* = ptr EMRPOLYLINE16 + EMRPOLYLINETO16* = EMRPOLYLINE16 + PEMRPOLYLINETO16* = ptr EMRPOLYLINE16 + EMRPOLYDRAW* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cptl*: DWORD + aptl*: array[1, POINTL] + abTypes*: array[1, BYTE] + PEMRPOLYDRAW* = ptr EMRPOLYDRAW + EMRPOLYDRAW16* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cpts*: DWORD + apts*: array[1, POINTS] + abTypes*: array[1, BYTE] + PEMRPOLYDRAW16* = ptr EMRPOLYDRAW16 + EMRPOLYPOLYLINE* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + nPolys*: DWORD + cptl*: DWORD + aPolyCounts*: array[1, DWORD] + aptl*: array[1, POINTL] + PEMRPOLYPOLYLINE* = ptr EMRPOLYPOLYLINE + EMRPOLYPOLYGON* = EMRPOLYPOLYLINE + PEMRPOLYPOLYGON* = ptr EMRPOLYPOLYLINE + EMRPOLYPOLYLINE16* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + nPolys*: DWORD + cpts*: DWORD + aPolyCounts*: array[1, DWORD] + apts*: array[1, POINTS] + PEMRPOLYPOLYLINE16* = ptr EMRPOLYPOLYLINE16 + EMRPOLYPOLYGON16* = EMRPOLYPOLYLINE16 + PEMRPOLYPOLYGON16* = ptr EMRPOLYPOLYLINE16 + EMRINVERTRGN* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cbRgnData*: DWORD + RgnData*: array[1, BYTE] + PEMRINVERTRGN* = ptr EMRINVERTRGN + EMRPAINTRGN* = EMRINVERTRGN + PEMRPAINTRGN* = ptr EMRINVERTRGN + EMRFILLRGN* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cbRgnData*: DWORD + ihBrush*: DWORD + RgnData*: array[1, BYTE] + PEMRFILLRGN* = ptr EMRFILLRGN + EMRFRAMERGN* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cbRgnData*: DWORD + ihBrush*: DWORD + szlStroke*: SIZEL + RgnData*: array[1, BYTE] + PEMRFRAMERGN* = ptr EMRFRAMERGN + EMREXTSELECTCLIPRGN* {.pure.} = object + emr*: EMR + cbRgnData*: DWORD + iMode*: DWORD + RgnData*: array[1, BYTE] + PEMREXTSELECTCLIPRGN* = ptr EMREXTSELECTCLIPRGN + EMREXTTEXTOUTA* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + iGraphicsMode*: DWORD + exScale*: FLOAT + eyScale*: FLOAT + emrtext*: EMRTEXT + PEMREXTTEXTOUTA* = ptr EMREXTTEXTOUTA + EMREXTTEXTOUTW* = EMREXTTEXTOUTA + PEMREXTTEXTOUTW* = ptr EMREXTTEXTOUTA + EMRPOLYTEXTOUTA* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + iGraphicsMode*: DWORD + exScale*: FLOAT + eyScale*: FLOAT + cStrings*: LONG + aemrtext*: array[1, EMRTEXT] + PEMRPOLYTEXTOUTA* = ptr EMRPOLYTEXTOUTA + EMRPOLYTEXTOUTW* = EMRPOLYTEXTOUTA + PEMRPOLYTEXTOUTW* = ptr EMRPOLYTEXTOUTA + EMRBITBLT* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + cxDest*: LONG + cyDest*: LONG + dwRop*: DWORD + xSrc*: LONG + ySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + PEMRBITBLT* = ptr EMRBITBLT + EMRSTRETCHBLT* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + cxDest*: LONG + cyDest*: LONG + dwRop*: DWORD + xSrc*: LONG + ySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + cxSrc*: LONG + cySrc*: LONG + PEMRSTRETCHBLT* = ptr EMRSTRETCHBLT + EMRMASKBLT* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + cxDest*: LONG + cyDest*: LONG + dwRop*: DWORD + xSrc*: LONG + ySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + xMask*: LONG + yMask*: LONG + iUsageMask*: DWORD + offBmiMask*: DWORD + cbBmiMask*: DWORD + offBitsMask*: DWORD + cbBitsMask*: DWORD + PEMRMASKBLT* = ptr EMRMASKBLT + EMRPLGBLT* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + aptlDest*: array[3, POINTL] + xSrc*: LONG + ySrc*: LONG + cxSrc*: LONG + cySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + xMask*: LONG + yMask*: LONG + iUsageMask*: DWORD + offBmiMask*: DWORD + cbBmiMask*: DWORD + offBitsMask*: DWORD + cbBitsMask*: DWORD + PEMRPLGBLT* = ptr EMRPLGBLT + EMRSETDIBITSTODEVICE* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + xSrc*: LONG + ySrc*: LONG + cxSrc*: LONG + cySrc*: LONG + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + iUsageSrc*: DWORD + iStartScan*: DWORD + cScans*: DWORD + PEMRSETDIBITSTODEVICE* = ptr EMRSETDIBITSTODEVICE + EMRSTRETCHDIBITS* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + xSrc*: LONG + ySrc*: LONG + cxSrc*: LONG + cySrc*: LONG + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + iUsageSrc*: DWORD + dwRop*: DWORD + cxDest*: LONG + cyDest*: LONG + PEMRSTRETCHDIBITS* = ptr EMRSTRETCHDIBITS + EMREXTCREATEFONTINDIRECTW* {.pure.} = object + emr*: EMR + ihFont*: DWORD + elfw*: EXTLOGFONTW + PEMREXTCREATEFONTINDIRECTW* = ptr EMREXTCREATEFONTINDIRECTW + EMRCREATEPALETTE* {.pure.} = object + emr*: EMR + ihPal*: DWORD + lgpl*: LOGPALETTE + PEMRCREATEPALETTE* = ptr EMRCREATEPALETTE + EMRCREATEPEN* {.pure.} = object + emr*: EMR + ihPen*: DWORD + lopn*: LOGPEN + PEMRCREATEPEN* = ptr EMRCREATEPEN + EMREXTCREATEPEN* {.pure.} = object + emr*: EMR + ihPen*: DWORD + offBmi*: DWORD + cbBmi*: DWORD + offBits*: DWORD + cbBits*: DWORD + elp*: EXTLOGPEN + PEMREXTCREATEPEN* = ptr EMREXTCREATEPEN + EMRCREATEBRUSHINDIRECT* {.pure.} = object + emr*: EMR + ihBrush*: DWORD + lb*: LOGBRUSH32 + PEMRCREATEBRUSHINDIRECT* = ptr EMRCREATEBRUSHINDIRECT + EMRCREATEMONOBRUSH* {.pure.} = object + emr*: EMR + ihBrush*: DWORD + iUsage*: DWORD + offBmi*: DWORD + cbBmi*: DWORD + offBits*: DWORD + cbBits*: DWORD + PEMRCREATEMONOBRUSH* = ptr EMRCREATEMONOBRUSH + EMRCREATEDIBPATTERNBRUSHPT* {.pure.} = object + emr*: EMR + ihBrush*: DWORD + iUsage*: DWORD + offBmi*: DWORD + cbBmi*: DWORD + offBits*: DWORD + cbBits*: DWORD + PEMRCREATEDIBPATTERNBRUSHPT* = ptr EMRCREATEDIBPATTERNBRUSHPT + EMRFORMAT* {.pure.} = object + dSignature*: DWORD + nVersion*: DWORD + cbData*: DWORD + offData*: DWORD + PEMRFORMAT* = ptr EMRFORMAT + EMRGLSRECORD* {.pure.} = object + emr*: EMR + cbData*: DWORD + Data*: array[1, BYTE] + PEMRGLSRECORD* = ptr EMRGLSRECORD + EMRGLSBOUNDEDRECORD* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + cbData*: DWORD + Data*: array[1, BYTE] + PEMRGLSBOUNDEDRECORD* = ptr EMRGLSBOUNDEDRECORD + EMRPIXELFORMAT* {.pure.} = object + emr*: EMR + pfd*: PIXELFORMATDESCRIPTOR + PEMRPIXELFORMAT* = ptr EMRPIXELFORMAT + EMRCREATECOLORSPACE* {.pure.} = object + emr*: EMR + ihCS*: DWORD + lcs*: LOGCOLORSPACEA + PEMRCREATECOLORSPACE* = ptr EMRCREATECOLORSPACE + EMRSETCOLORSPACE* {.pure.} = object + emr*: EMR + ihCS*: DWORD + PEMRSETCOLORSPACE* = ptr EMRSETCOLORSPACE + EMRSELECTCOLORSPACE* = EMRSETCOLORSPACE + PEMRSELECTCOLORSPACE* = ptr EMRSETCOLORSPACE + EMRDELETECOLORSPACE* = EMRSETCOLORSPACE + PEMRDELETECOLORSPACE* = ptr EMRSETCOLORSPACE + EMREXTESCAPE* {.pure.} = object + emr*: EMR + iEscape*: INT + cbEscData*: INT + EscData*: array[1, BYTE] + PEMREXTESCAPE* = ptr EMREXTESCAPE + EMRDRAWESCAPE* = EMREXTESCAPE + PEMRDRAWESCAPE* = ptr EMREXTESCAPE + EMRNAMEDESCAPE* {.pure.} = object + emr*: EMR + iEscape*: INT + cbDriver*: INT + cbEscData*: INT + EscData*: array[1, BYTE] + PEMRNAMEDESCAPE* = ptr EMRNAMEDESCAPE + EMRSETICMPROFILE* {.pure.} = object + emr*: EMR + dwFlags*: DWORD + cbName*: DWORD + cbData*: DWORD + Data*: array[1, BYTE] + PEMRSETICMPROFILE* = ptr EMRSETICMPROFILE + EMRSETICMPROFILEA* = EMRSETICMPROFILE + PEMRSETICMPROFILEA* = ptr EMRSETICMPROFILE + EMRSETICMPROFILEW* = EMRSETICMPROFILE + PEMRSETICMPROFILEW* = ptr EMRSETICMPROFILE + EMRCREATECOLORSPACEW* {.pure.} = object + emr*: EMR + ihCS*: DWORD + lcs*: LOGCOLORSPACEW + dwFlags*: DWORD + cbData*: DWORD + Data*: array[1, BYTE] + PEMRCREATECOLORSPACEW* = ptr EMRCREATECOLORSPACEW + EMRCOLORMATCHTOTARGET* {.pure.} = object + emr*: EMR + dwAction*: DWORD + dwFlags*: DWORD + cbName*: DWORD + cbData*: DWORD + Data*: array[1, BYTE] + PEMRCOLORMATCHTOTARGET* = ptr EMRCOLORMATCHTOTARGET + EMRCOLORCORRECTPALETTE* {.pure.} = object + emr*: EMR + ihPalette*: DWORD + nFirstEntry*: DWORD + nPalEntries*: DWORD + nReserved*: DWORD + PEMRCOLORCORRECTPALETTE* = ptr EMRCOLORCORRECTPALETTE + EMRALPHABLEND* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + cxDest*: LONG + cyDest*: LONG + dwRop*: DWORD + xSrc*: LONG + ySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + cxSrc*: LONG + cySrc*: LONG + PEMRALPHABLEND* = ptr EMRALPHABLEND + EMRGRADIENTFILL* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + nVer*: DWORD + nTri*: DWORD + ulMode*: ULONG + Ver*: array[1, TRIVERTEX] + PEMRGRADIENTFILL* = ptr EMRGRADIENTFILL + EMRTRANSPARENTBLT* {.pure.} = object + emr*: EMR + rclBounds*: RECTL + xDest*: LONG + yDest*: LONG + cxDest*: LONG + cyDest*: LONG + dwRop*: DWORD + xSrc*: LONG + ySrc*: LONG + xformSrc*: XFORM + crBkColorSrc*: COLORREF + iUsageSrc*: DWORD + offBmiSrc*: DWORD + cbBmiSrc*: DWORD + offBitsSrc*: DWORD + cbBitsSrc*: DWORD + cxSrc*: LONG + cySrc*: LONG + PEMRTRANSPARENTBLT* = ptr EMRTRANSPARENTBLT + POINTFLOAT* {.pure.} = object + x*: FLOAT + y*: FLOAT + PPOINTFLOAT* = ptr POINTFLOAT + GLYPHMETRICSFLOAT* {.pure.} = object + gmfBlackBoxX*: FLOAT + gmfBlackBoxY*: FLOAT + gmfptGlyphOrigin*: POINTFLOAT + gmfCellIncX*: FLOAT + gmfCellIncY*: FLOAT + PGLYPHMETRICSFLOAT* = ptr GLYPHMETRICSFLOAT + LPGLYPHMETRICSFLOAT* = ptr GLYPHMETRICSFLOAT + LAYERPLANEDESCRIPTOR* {.pure.} = object + nSize*: WORD + nVersion*: WORD + dwFlags*: DWORD + iPixelType*: BYTE + cColorBits*: BYTE + cRedBits*: BYTE + cRedShift*: BYTE + cGreenBits*: BYTE + cGreenShift*: BYTE + cBlueBits*: BYTE + cBlueShift*: BYTE + cAlphaBits*: BYTE + cAlphaShift*: BYTE + cAccumBits*: BYTE + cAccumRedBits*: BYTE + cAccumGreenBits*: BYTE + cAccumBlueBits*: BYTE + cAccumAlphaBits*: BYTE + cDepthBits*: BYTE + cStencilBits*: BYTE + cAuxBuffers*: BYTE + iLayerPlane*: BYTE + bReserved*: BYTE + crTransparent*: COLORREF + PLAYERPLANEDESCRIPTOR* = ptr LAYERPLANEDESCRIPTOR + LPLAYERPLANEDESCRIPTOR* = ptr LAYERPLANEDESCRIPTOR + WGLSWAP* {.pure.} = object + hdc*: HDC + uiFlags*: UINT + PWGLSWAP* = ptr WGLSWAP + LPWGLSWAP* = ptr WGLSWAP +const + R2_BLACK* = 1 + R2_NOTMERGEPEN* = 2 + R2_MASKNOTPEN* = 3 + R2_NOTCOPYPEN* = 4 + R2_MASKPENNOT* = 5 + R2_NOT* = 6 + R2_XORPEN* = 7 + R2_NOTMASKPEN* = 8 + R2_MASKPEN* = 9 + R2_NOTXORPEN* = 10 + R2_NOP* = 11 + R2_MERGENOTPEN* = 12 + R2_COPYPEN* = 13 + R2_MERGEPENNOT* = 14 + R2_MERGEPEN* = 15 + R2_WHITE* = 16 + R2_LAST* = 16 + SRCCOPY* = DWORD 0x00CC0020 + SRCPAINT* = DWORD 0x00EE0086 + SRCAND* = DWORD 0x008800C6 + SRCINVERT* = DWORD 0x00660046 + SRCERASE* = DWORD 0x00440328 + NOTSRCCOPY* = DWORD 0x00330008 + NOTSRCERASE* = DWORD 0x001100A6 + MERGECOPY* = DWORD 0x00C000CA + MERGEPAINT* = DWORD 0x00BB0226 + PATCOPY* = DWORD 0x00F00021 + PATPAINT* = DWORD 0x00FB0A09 + PATINVERT* = DWORD 0x005A0049 + DSTINVERT* = DWORD 0x00550009 + BLACKNESS* = DWORD 0x00000042 + WHITENESS* = DWORD 0x00FF0062 + NOMIRRORBITMAP* = DWORD 0x80000000'i32 + CAPTUREBLT* = DWORD 0x40000000 + GDI_ERROR* = 0xFFFFFFFF'i32 + HGDI_ERROR* = HANDLE 0xFFFFFFFF'i32 + ERROR* = 0 + NULLREGION* = 1 + SIMPLEREGION* = 2 + COMPLEXREGION* = 3 + RGN_ERROR* = ERROR + RGN_AND* = 1 + RGN_OR* = 2 + RGN_XOR* = 3 + RGN_DIFF* = 4 + RGN_COPY* = 5 + RGN_MIN* = RGN_AND + RGN_MAX* = RGN_COPY + BLACKONWHITE* = 1 + WHITEONBLACK* = 2 + COLORONCOLOR* = 3 + HALFTONE* = 4 + MAXSTRETCHBLTMODE* = 4 + STRETCH_ANDSCANS* = BLACKONWHITE + STRETCH_ORSCANS* = WHITEONBLACK + STRETCH_DELETESCANS* = COLORONCOLOR + STRETCH_HALFTONE* = HALFTONE + ALTERNATE* = 1 + WINDING* = 2 + POLYFILL_LAST* = 2 + LAYOUT_RTL* = 0x00000001 + LAYOUT_BTT* = 0x00000002 + LAYOUT_VBH* = 0x00000004 + LAYOUT_ORIENTATIONMASK* = LAYOUT_RTL or LAYOUT_BTT or LAYOUT_VBH + LAYOUT_BITMAPORIENTATIONPRESERVED* = 0x00000008 + TA_NOUPDATECP* = 0 + TA_UPDATECP* = 1 + TA_LEFT* = 0 + TA_RIGHT* = 2 + TA_CENTER* = 6 + TA_TOP* = 0 + TA_BOTTOM* = 8 + TA_BASELINE* = 24 + TA_RTLREADING* = 256 + TA_MASK* = TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING + VTA_BASELINE* = TA_BASELINE + VTA_LEFT* = TA_BOTTOM + VTA_RIGHT* = TA_TOP + VTA_CENTER* = TA_CENTER + VTA_BOTTOM* = TA_RIGHT + VTA_TOP* = TA_LEFT + ETO_OPAQUE* = 0x0002 + ETO_CLIPPED* = 0x0004 + ETO_GLYPH_INDEX* = 0x0010 + ETO_RTLREADING* = 0x0080 + ETO_NUMERICSLOCAL* = 0x0400 + ETO_NUMERICSLATIN* = 0x0800 + ETO_IGNORELANGUAGE* = 0x1000 + ETO_PDY* = 0x2000 + ETO_REVERSE_INDEX_MAP* = 0x10000 + ASPECT_FILTERING* = 0x0001 + DCB_RESET* = 0x0001 + DCB_ACCUMULATE* = 0x0002 + DCB_DIRTY* = DCB_ACCUMULATE + DCB_SET* = DCB_RESET or DCB_ACCUMULATE + DCB_ENABLE* = 0x0004 + DCB_DISABLE* = 0x0008 + META_SETBKCOLOR* = 0x0201 + META_SETBKMODE* = 0x0102 + META_SETMAPMODE* = 0x0103 + META_SETROP2* = 0x0104 + META_SETRELABS* = 0x0105 + META_SETPOLYFILLMODE* = 0x0106 + META_SETSTRETCHBLTMODE* = 0x0107 + META_SETTEXTCHAREXTRA* = 0x0108 + META_SETTEXTCOLOR* = 0x0209 + META_SETTEXTJUSTIFICATION* = 0x020A + META_SETWINDOWORG* = 0x020B + META_SETWINDOWEXT* = 0x020C + META_SETVIEWPORTORG* = 0x020D + META_SETVIEWPORTEXT* = 0x020E + META_OFFSETWINDOWORG* = 0x020F + META_SCALEWINDOWEXT* = 0x0410 + META_OFFSETVIEWPORTORG* = 0x0211 + META_SCALEVIEWPORTEXT* = 0x0412 + META_LINETO* = 0x0213 + META_MOVETO* = 0x0214 + META_EXCLUDECLIPRECT* = 0x0415 + META_INTERSECTCLIPRECT* = 0x0416 + META_ARC* = 0x0817 + META_ELLIPSE* = 0x0418 + META_FLOODFILL* = 0x0419 + META_PIE* = 0x081A + META_RECTANGLE* = 0x041B + META_ROUNDRECT* = 0x061C + META_PATBLT* = 0x061D + META_SAVEDC* = 0x001E + META_SETPIXEL* = 0x041F + META_OFFSETCLIPRGN* = 0x0220 + META_TEXTOUT* = 0x0521 + META_BITBLT* = 0x0922 + META_STRETCHBLT* = 0x0B23 + META_POLYGON* = 0x0324 + META_POLYLINE* = 0x0325 + META_ESCAPE* = 0x0626 + META_RESTOREDC* = 0x0127 + META_FILLREGION* = 0x0228 + META_FRAMEREGION* = 0x0429 + META_INVERTREGION* = 0x012A + META_PAINTREGION* = 0x012B + META_SELECTCLIPREGION* = 0x012C + META_SELECTOBJECT* = 0x012D + META_SETTEXTALIGN* = 0x012E + META_CHORD* = 0x0830 + META_SETMAPPERFLAGS* = 0x0231 + META_EXTTEXTOUT* = 0x0a32 + META_SETDIBTODEV* = 0x0d33 + META_SELECTPALETTE* = 0x0234 + META_REALIZEPALETTE* = 0x0035 + META_ANIMATEPALETTE* = 0x0436 + META_SETPALENTRIES* = 0x0037 + META_POLYPOLYGON* = 0x0538 + META_RESIZEPALETTE* = 0x0139 + META_DIBBITBLT* = 0x0940 + META_DIBSTRETCHBLT* = 0x0b41 + META_DIBCREATEPATTERNBRUSH* = 0x0142 + META_STRETCHDIB* = 0x0f43 + META_EXTFLOODFILL* = 0x0548 + META_SETLAYOUT* = 0x0149 + META_DELETEOBJECT* = 0x01f0 + META_CREATEPALETTE* = 0x00f7 + META_CREATEPATTERNBRUSH* = 0x01F9 + META_CREATEPENINDIRECT* = 0x02FA + META_CREATEFONTINDIRECT* = 0x02FB + META_CREATEBRUSHINDIRECT* = 0x02FC + META_CREATEREGION* = 0x06FF + NEWFRAME* = 1 + abortDoc* = 2 + NEXTBAND* = 3 + SETCOLORTABLE* = 4 + GETCOLORTABLE* = 5 + FLUSHOUTPUT* = 6 + DRAFTMODE* = 7 + QUERYESCSUPPORT* = 8 + setAbortProc* = 9 + startDoc* = 10 + endDoc* = 11 + GETPHYSPAGESIZE* = 12 + GETPRINTINGOFFSET* = 13 + GETSCALINGFACTOR* = 14 + MFCOMMENT* = 15 + GETPENWIDTH* = 16 + SETCOPYCOUNT* = 17 + SELECTPAPERSOURCE* = 18 + DEVICEDATA* = 19 + PASSTHROUGH* = 19 + GETTECHNOLGY* = 20 + GETTECHNOLOGY* = 20 + SETLINECAP* = 21 + SETLINEJOIN* = 22 + setMiterLimit* = 23 + BANDINFO* = 24 + DRAWPATTERNRECT* = 25 + GETVECTORPENSIZE* = 26 + GETVECTORBRUSHSIZE* = 27 + ENABLEDUPLEX* = 28 + GETSETPAPERBINS* = 29 + GETSETPRINTORIENT* = 30 + ENUMPAPERBINS* = 31 + SETDIBSCALING* = 32 + EPSPRINTING* = 33 + ENUMPAPERMETRICS* = 34 + GETSETPAPERMETRICS* = 35 + POSTSCRIPT_DATA* = 37 + POSTSCRIPT_IGNORE* = 38 + MOUSETRAILS* = 39 + GETDEVICEUNITS* = 42 + GETEXTENDEDTEXTMETRICS* = 256 + GETEXTENTTABLE* = 257 + GETPAIRKERNTABLE* = 258 + GETTRACKKERNTABLE* = 259 + extTextout* = 512 + GETFACENAME* = 513 + DOWNLOADFACE* = 514 + ENABLERELATIVEWIDTHS* = 768 + ENABLEPAIRKERNING* = 769 + SETKERNTRACK* = 770 + SETALLJUSTVALUES* = 771 + SETCHARSET* = 772 + stretchBlt* = 2048 + METAFILE_DRIVER* = 2049 + GETSETSCREENPARAMS* = 3072 + QUERYDIBSUPPORT* = 3073 + beginPath* = 4096 + CLIP_TO_PATH* = 4097 + endPath* = 4098 + EXT_DEVICE_CAPS* = 4099 + RESTORE_CTM* = 4100 + SAVE_CTM* = 4101 + setArcDirection* = 4102 + SET_BACKGROUND_COLOR* = 4103 + SET_POLY_MODE* = 4104 + SET_SCREEN_ANGLE* = 4105 + SET_SPREAD* = 4106 + TRANSFORM_CTM* = 4107 + SET_CLIP_BOX* = 4108 + SET_BOUNDS* = 4109 + SET_MIRROR_MODE* = 4110 + OPENCHANNEL* = 4110 + DOWNLOADHEADER* = 4111 + CLOSECHANNEL* = 4112 + POSTSCRIPT_PASSTHROUGH* = 4115 + ENCAPSULATED_POSTSCRIPT* = 4116 + POSTSCRIPT_IDENTIFY* = 4117 + POSTSCRIPT_INJECTION* = 4118 + CHECKJPEGFORMAT* = 4119 + CHECKPNGFORMAT* = 4120 + GET_PS_FEATURESETTING* = 4121 + GDIPLUS_TS_QUERYVER* = 4122 + GDIPLUS_TS_RECORD* = 4123 + MILCORE_TS_QUERYVER_RESULT_FALSE* = 0x0 + MILCORE_TS_QUERYVER_RESULT_TRUE* = 0x7FFFFFFF + SPCLPASSTHROUGH2* = 4568 + PSIDENT_GDICENTRIC* = 0 + PSIDENT_PSCENTRIC* = 1 + PSINJECT_BEGINSTREAM* = 1 + PSINJECT_PSADOBE* = 2 + PSINJECT_PAGESATEND* = 3 + PSINJECT_PAGES* = 4 + PSINJECT_DOCNEEDEDRES* = 5 + PSINJECT_DOCSUPPLIEDRES* = 6 + PSINJECT_PAGEORDER* = 7 + PSINJECT_ORIENTATION* = 8 + PSINJECT_BOUNDINGBOX* = 9 + PSINJECT_DOCUMENTPROCESSCOLORS* = 10 + PSINJECT_COMMENTS* = 11 + PSINJECT_BEGINDEFAULTS* = 12 + PSINJECT_ENDDEFAULTS* = 13 + PSINJECT_BEGINPROLOG* = 14 + PSINJECT_ENDPROLOG* = 15 + PSINJECT_BEGINSETUP* = 16 + PSINJECT_ENDSETUP* = 17 + PSINJECT_TRAILER* = 18 + PSINJECT_EOF* = 19 + PSINJECT_ENDSTREAM* = 20 + PSINJECT_DOCUMENTPROCESSCOLORSATEND* = 21 + PSINJECT_PAGENUMBER* = 100 + PSINJECT_BEGINPAGESETUP* = 101 + PSINJECT_ENDPAGESETUP* = 102 + PSINJECT_PAGETRAILER* = 103 + PSINJECT_PLATECOLOR* = 104 + PSINJECT_SHOWPAGE* = 105 + PSINJECT_PAGEBBOX* = 106 + PSINJECT_ENDPAGECOMMENTS* = 107 + PSINJECT_VMSAVE* = 200 + PSINJECT_VMRESTORE* = 201 + FEATURESETTING_NUP* = 0 + FEATURESETTING_OUTPUT* = 1 + FEATURESETTING_PSLEVEL* = 2 + FEATURESETTING_CUSTPAPER* = 3 + FEATURESETTING_MIRROR* = 4 + FEATURESETTING_NEGATIVE* = 5 + FEATURESETTING_PROTOCOL* = 6 + FEATURESETTING_PRIVATE_BEGIN* = 0x1000 + FEATURESETTING_PRIVATE_END* = 0x1FFF + PSPROTOCOL_ASCII* = 0 + PSPROTOCOL_BCP* = 1 + PSPROTOCOL_TBCP* = 2 + PSPROTOCOL_BINARY* = 3 + QDI_SETDIBITS* = 1 + QDI_GETDIBITS* = 2 + QDI_DIBTOSCREEN* = 4 + QDI_STRETCHDIB* = 8 + SP_NOTREPORTED* = 0x4000 + SP_ERROR* = -1 + SP_APPABORT* = -2 + SP_USERABORT* = -3 + SP_OUTOFDISK* = -4 + SP_OUTOFMEMORY* = -5 + PR_JOBSTATUS* = 0x0000 + OBJ_PEN* = 1 + OBJ_BRUSH* = 2 + OBJ_DC* = 3 + OBJ_METADC* = 4 + OBJ_PAL* = 5 + OBJ_FONT* = 6 + OBJ_BITMAP* = 7 + OBJ_REGION* = 8 + OBJ_METAFILE* = 9 + OBJ_MEMDC* = 10 + OBJ_EXTPEN* = 11 + OBJ_ENHMETADC* = 12 + OBJ_ENHMETAFILE* = 13 + OBJ_COLORSPACE* = 14 + GDI_OBJ_LAST* = OBJ_COLORSPACE + MWT_IDENTITY* = 1 + MWT_LEFTMULTIPLY* = 2 + MWT_RIGHTMULTIPLY* = 3 + MWT_MIN* = MWT_IDENTITY + MWT_MAX* = MWT_RIGHTMULTIPLY + CS_ENABLE* = 0x00000001 + CS_DISABLE* = 0x00000002 + CS_DELETE_TRANSFORM* = 0x00000003 + LCS_SIGNATURE* = 0x50534F43 + LCS_sRGB* = 0x73524742 + LCS_WINDOWS_COLOR_SPACE* = 0x57696E20 + LCS_CALIBRATED_RGB* = 0x00000000 + LCS_GM_BUSINESS* = 0x00000001 + LCS_GM_GRAPHICS* = 0x00000002 + LCS_GM_IMAGES* = 0x00000004 + LCS_GM_ABS_COLORIMETRIC* = 0x00000008 + CM_OUT_OF_GAMUT* = 255 + CM_IN_GAMUT* = 0 + ICM_ADDPROFILE* = 1 + ICM_DELETEPROFILE* = 2 + ICM_QUERYPROFILE* = 3 + ICM_SETDEFAULTPROFILE* = 4 + ICM_REGISTERICMATCHER* = 5 + ICM_UNREGISTERICMATCHER* = 6 + ICM_QUERYMATCH* = 7 + PROFILE_LINKED* = 0x4C494E4B + PROFILE_EMBEDDED* = 0x4D424544 + BI_RGB* = 0 + BI_RLE8* = 1 + BI_RLE4* = 2 + BI_BITFIELDS* = 3 + BI_JPEG* = 4 + BI_PNG* = 5 + TCI_SRCCHARSET* = 1 + TCI_SRCCODEPAGE* = 2 + TCI_SRCFONTSIG* = 3 + TCI_SRCLOCALE* = 0x1000 + TMPF_FIXED_PITCH* = 0x01 + TMPF_VECTOR* = 0x02 + TMPF_DEVICE* = 0x08 + TMPF_TRUETYPE* = 0x04 + NTM_REGULAR* = 0x00000040 + NTM_BOLD* = 0x00000020 + NTM_ITALIC* = 0x00000001 + NTM_NONNEGATIVE_AC* = 0x00010000 + NTM_PS_OPENTYPE* = 0x00020000 + NTM_TT_OPENTYPE* = 0x00040000 + NTM_MULTIPLEMASTER* = 0x00080000 + NTM_TYPE1* = 0x00100000 + NTM_DSIG* = 0x00200000 + OUT_DEFAULT_PRECIS* = 0 + OUT_STRING_PRECIS* = 1 + OUT_CHARACTER_PRECIS* = 2 + OUT_STROKE_PRECIS* = 3 + OUT_TT_PRECIS* = 4 + OUT_DEVICE_PRECIS* = 5 + OUT_RASTER_PRECIS* = 6 + OUT_TT_ONLY_PRECIS* = 7 + OUT_OUTLINE_PRECIS* = 8 + OUT_SCREEN_OUTLINE_PRECIS* = 9 + OUT_PS_ONLY_PRECIS* = 10 + CLIP_DEFAULT_PRECIS* = 0 + CLIP_CHARACTER_PRECIS* = 1 + CLIP_STROKE_PRECIS* = 2 + CLIP_MASK* = 0xf + CLIP_LH_ANGLES* = 1 shl 4 + CLIP_TT_ALWAYS* = 2 shl 4 + CLIP_DFA_DISABLE* = 4 shl 4 + CLIP_EMBEDDED* = 8 shl 4 + DEFAULT_QUALITY* = 0 + DRAFT_QUALITY* = 1 + PROOF_QUALITY* = 2 + NONANTIALIASED_QUALITY* = 3 + ANTIALIASED_QUALITY* = 4 + CLEARTYPE_QUALITY* = 5 + CLEARTYPE_NATURAL_QUALITY* = 6 + DEFAULT_PITCH* = 0 + FIXED_PITCH* = 1 + VARIABLE_PITCH* = 2 + MONO_FONT* = 8 + ANSI_CHARSET* = 0 + DEFAULT_CHARSET* = 1 + SYMBOL_CHARSET* = 2 + SHIFTJIS_CHARSET* = 128 + HANGEUL_CHARSET* = 129 + HANGUL_CHARSET* = 129 + GB2312_CHARSET* = 134 + CHINESEBIG5_CHARSET* = 136 + OEM_CHARSET* = 255 + JOHAB_CHARSET* = 130 + HEBREW_CHARSET* = 177 + ARABIC_CHARSET* = 178 + GREEK_CHARSET* = 161 + TURKISH_CHARSET* = 162 + VIETNAMESE_CHARSET* = 163 + THAI_CHARSET* = 222 + EASTEUROPE_CHARSET* = 238 + RUSSIAN_CHARSET* = 204 + MAC_CHARSET* = 77 + BALTIC_CHARSET* = 186 + FS_LATIN1* = 0x00000001 + FS_LATIN2* = 0x00000002 + FS_CYRILLIC* = 0x00000004 + FS_GREEK* = 0x00000008 + FS_TURKISH* = 0x00000010 + FS_HEBREW* = 0x00000020 + FS_ARABIC* = 0x00000040 + FS_BALTIC* = 0x00000080 + FS_VIETNAMESE* = 0x00000100 + FS_THAI* = 0x00010000 + FS_JISJAPAN* = 0x00020000 + FS_CHINESESIMP* = 0x00040000 + FS_WANSUNG* = 0x00080000 + FS_CHINESETRAD* = 0x00100000 + FS_JOHAB* = 0x00200000 + FS_SYMBOL* = 0x80000000'i32 + FF_DONTCARE* = 0 shl 4 + FF_ROMAN* = 1 shl 4 + FF_SWISS* = 2 shl 4 + FF_MODERN* = 3 shl 4 + FF_SCRIPT* = 4 shl 4 + FF_DECORATIVE* = 5 shl 4 + FW_DONTCARE* = 0 + FW_THIN* = 100 + FW_EXTRALIGHT* = 200 + FW_LIGHT* = 300 + FW_NORMAL* = 400 + FW_MEDIUM* = 500 + FW_SEMIBOLD* = 600 + FW_BOLD* = 700 + FW_EXTRABOLD* = 800 + FW_HEAVY* = 900 + FW_ULTRALIGHT* = FW_EXTRALIGHT + FW_REGULAR* = FW_NORMAL + FW_DEMIBOLD* = FW_SEMIBOLD + FW_ULTRABOLD* = FW_EXTRABOLD + FW_BLACK* = FW_HEAVY + PANOSE_COUNT* = 10 + PAN_FAMILYTYPE_INDEX* = 0 + PAN_SERIFSTYLE_INDEX* = 1 + PAN_WEIGHT_INDEX* = 2 + PAN_PROPORTION_INDEX* = 3 + PAN_CONTRAST_INDEX* = 4 + PAN_STROKEVARIATION_INDEX* = 5 + PAN_ARMSTYLE_INDEX* = 6 + PAN_LETTERFORM_INDEX* = 7 + PAN_MIDLINE_INDEX* = 8 + PAN_XHEIGHT_INDEX* = 9 + PAN_CULTURE_LATIN* = 0 + PAN_ANY* = 0 + PAN_NO_FIT* = 1 + PAN_FAMILY_TEXT_DISPLAY* = 2 + PAN_FAMILY_SCRIPT* = 3 + PAN_FAMILY_DECORATIVE* = 4 + PAN_FAMILY_PICTORIAL* = 5 + PAN_SERIF_COVE* = 2 + PAN_SERIF_OBTUSE_COVE* = 3 + PAN_SERIF_SQUARE_COVE* = 4 + PAN_SERIF_OBTUSE_SQUARE_COVE* = 5 + PAN_SERIF_SQUARE* = 6 + PAN_SERIF_THIN* = 7 + PAN_SERIF_BONE* = 8 + PAN_SERIF_EXAGGERATED* = 9 + PAN_SERIF_TRIANGLE* = 10 + PAN_SERIF_NORMAL_SANS* = 11 + PAN_SERIF_OBTUSE_SANS* = 12 + PAN_SERIF_PERP_SANS* = 13 + PAN_SERIF_FLARED* = 14 + PAN_SERIF_ROUNDED* = 15 + PAN_WEIGHT_VERY_LIGHT* = 2 + PAN_WEIGHT_LIGHT* = 3 + PAN_WEIGHT_THIN* = 4 + PAN_WEIGHT_BOOK* = 5 + PAN_WEIGHT_MEDIUM* = 6 + PAN_WEIGHT_DEMI* = 7 + PAN_WEIGHT_BOLD* = 8 + PAN_WEIGHT_HEAVY* = 9 + PAN_WEIGHT_BLACK* = 10 + PAN_WEIGHT_NORD* = 11 + PAN_PROP_OLD_STYLE* = 2 + PAN_PROP_MODERN* = 3 + PAN_PROP_EVEN_WIDTH* = 4 + PAN_PROP_EXPANDED* = 5 + PAN_PROP_CONDENSED* = 6 + PAN_PROP_VERY_EXPANDED* = 7 + PAN_PROP_VERY_CONDENSED* = 8 + PAN_PROP_MONOSPACED* = 9 + PAN_CONTRAST_NONE* = 2 + PAN_CONTRAST_VERY_LOW* = 3 + PAN_CONTRAST_LOW* = 4 + PAN_CONTRAST_MEDIUM_LOW* = 5 + PAN_CONTRAST_MEDIUM* = 6 + PAN_CONTRAST_MEDIUM_HIGH* = 7 + PAN_CONTRAST_HIGH* = 8 + PAN_CONTRAST_VERY_HIGH* = 9 + PAN_STROKE_GRADUAL_DIAG* = 2 + PAN_STROKE_GRADUAL_TRAN* = 3 + PAN_STROKE_GRADUAL_VERT* = 4 + PAN_STROKE_GRADUAL_HORZ* = 5 + PAN_STROKE_RAPID_VERT* = 6 + PAN_STROKE_RAPID_HORZ* = 7 + PAN_STROKE_INSTANT_VERT* = 8 + PAN_STRAIGHT_ARMS_HORZ* = 2 + PAN_STRAIGHT_ARMS_WEDGE* = 3 + PAN_STRAIGHT_ARMS_VERT* = 4 + PAN_STRAIGHT_ARMS_SINGLE_SERIF* = 5 + PAN_STRAIGHT_ARMS_DOUBLE_SERIF* = 6 + PAN_BENT_ARMS_HORZ* = 7 + PAN_BENT_ARMS_WEDGE* = 8 + PAN_BENT_ARMS_VERT* = 9 + PAN_BENT_ARMS_SINGLE_SERIF* = 10 + PAN_BENT_ARMS_DOUBLE_SERIF* = 11 + PAN_LETT_NORMAL_CONTACT* = 2 + PAN_LETT_NORMAL_WEIGHTED* = 3 + PAN_LETT_NORMAL_BOXED* = 4 + PAN_LETT_NORMAL_FLATTENED* = 5 + PAN_LETT_NORMAL_ROUNDED* = 6 + PAN_LETT_NORMAL_OFF_CENTER* = 7 + PAN_LETT_NORMAL_SQUARE* = 8 + PAN_LETT_OBLIQUE_CONTACT* = 9 + PAN_LETT_OBLIQUE_WEIGHTED* = 10 + PAN_LETT_OBLIQUE_BOXED* = 11 + PAN_LETT_OBLIQUE_FLATTENED* = 12 + PAN_LETT_OBLIQUE_ROUNDED* = 13 + PAN_LETT_OBLIQUE_OFF_CENTER* = 14 + PAN_LETT_OBLIQUE_SQUARE* = 15 + PAN_MIDLINE_STANDARD_TRIMMED* = 2 + PAN_MIDLINE_STANDARD_POINTED* = 3 + PAN_MIDLINE_STANDARD_SERIFED* = 4 + PAN_MIDLINE_HIGH_TRIMMED* = 5 + PAN_MIDLINE_HIGH_POINTED* = 6 + PAN_MIDLINE_HIGH_SERIFED* = 7 + PAN_MIDLINE_CONSTANT_TRIMMED* = 8 + PAN_MIDLINE_CONSTANT_POINTED* = 9 + PAN_MIDLINE_CONSTANT_SERIFED* = 10 + PAN_MIDLINE_LOW_TRIMMED* = 11 + PAN_MIDLINE_LOW_POINTED* = 12 + PAN_MIDLINE_LOW_SERIFED* = 13 + PAN_XHEIGHT_CONSTANT_SMALL* = 2 + PAN_XHEIGHT_CONSTANT_STD* = 3 + PAN_XHEIGHT_CONSTANT_LARGE* = 4 + PAN_XHEIGHT_DUCKING_SMALL* = 5 + PAN_XHEIGHT_DUCKING_STD* = 6 + PAN_XHEIGHT_DUCKING_LARGE* = 7 + ELF_VERSION* = 0 + ELF_CULTURE_LATIN* = 0 + RASTER_FONTTYPE* = 0x0001 + DEVICE_FONTTYPE* = 0x002 + TRUETYPE_FONTTYPE* = 0x004 + PC_RESERVED* = 0x01 + PC_EXPLICIT* = 0x02 + PC_NOCOLLAPSE* = 0x04 + TRANSPARENT* = 1 + OPAQUE* = 2 + BKMODE_LAST* = 2 + GM_COMPATIBLE* = 1 + GM_ADVANCED* = 2 + GM_LAST* = 2 + PT_CLOSEFIGURE* = 0x01 + PT_LINETO* = 0x02 + PT_BEZIERTO* = 0x04 + PT_MOVETO* = 0x06 + MM_TEXT* = 1 + MM_LOMETRIC* = 2 + MM_HIMETRIC* = 3 + MM_LOENGLISH* = 4 + MM_HIENGLISH* = 5 + MM_TWIPS* = 6 + MM_ISOTROPIC* = 7 + MM_ANISOTROPIC* = 8 + MM_MIN* = MM_TEXT + MM_MAX* = MM_ANISOTROPIC + MM_MAX_FIXEDSCALE* = MM_TWIPS + ABSOLUTE* = 1 + RELATIVE* = 2 + WHITE_BRUSH* = 0 + LTGRAY_BRUSH* = 1 + GRAY_BRUSH* = 2 + DKGRAY_BRUSH* = 3 + BLACK_BRUSH* = 4 + NULL_BRUSH* = 5 + HOLLOW_BRUSH* = NULL_BRUSH + WHITE_PEN* = 6 + BLACK_PEN* = 7 + NULL_PEN* = 8 + OEM_FIXED_FONT* = 10 + ANSI_FIXED_FONT* = 11 + ANSI_VAR_FONT* = 12 + SYSTEM_FONT* = 13 + DEVICE_DEFAULT_FONT* = 14 + DEFAULT_PALETTE* = 15 + SYSTEM_FIXED_FONT* = 16 + DEFAULT_GUI_FONT* = 17 + DC_BRUSH* = 18 + DC_PEN* = 19 + STOCK_LAST* = 19 + CLR_INVALID* = 0xFFFFFFFF'i32 + BS_SOLID* = 0 + BS_NULL* = 1 + BS_HOLLOW* = BS_NULL + BS_HATCHED* = 2 + BS_PATTERN* = 3 + BS_INDEXED* = 4 + BS_DIBPATTERN* = 5 + BS_DIBPATTERNPT* = 6 + BS_PATTERN8X8* = 7 + BS_DIBPATTERN8X8* = 8 + BS_MONOPATTERN* = 9 + HS_HORIZONTAL* = 0 + HS_VERTICAL* = 1 + HS_FDIAGONAL* = 2 + HS_BDIAGONAL* = 3 + HS_CROSS* = 4 + HS_DIAGCROSS* = 5 + HS_API_MAX* = 12 + PS_SOLID* = 0 + PS_DASH* = 1 + PS_DOT* = 2 + PS_DASHDOT* = 3 + PS_DASHDOTDOT* = 4 + PS_NULL* = 5 + PS_INSIDEFRAME* = 6 + PS_USERSTYLE* = 7 + PS_ALTERNATE* = 8 + PS_STYLE_MASK* = 0x0000000F + PS_ENDCAP_ROUND* = 0x00000000 + PS_ENDCAP_SQUARE* = 0x00000100 + PS_ENDCAP_FLAT* = 0x00000200 + PS_ENDCAP_MASK* = 0x00000F00 + PS_JOIN_ROUND* = 0x00000000 + PS_JOIN_BEVEL* = 0x00001000 + PS_JOIN_MITER* = 0x00002000 + PS_JOIN_MASK* = 0x0000F000 + PS_COSMETIC* = 0x00000000 + PS_GEOMETRIC* = 0x00010000 + PS_TYPE_MASK* = 0x000F0000 + AD_COUNTERCLOCKWISE* = 1 + AD_CLOCKWISE* = 2 + DRIVERVERSION* = 0 + TECHNOLOGY* = 2 + HORZSIZE* = 4 + VERTSIZE* = 6 + HORZRES* = 8 + VERTRES* = 10 + BITSPIXEL* = 12 + PLANES* = 14 + NUMBRUSHES* = 16 + NUMPENS* = 18 + NUMMARKERS* = 20 + NUMFONTS* = 22 + NUMCOLORS* = 24 + PDEVICESIZE* = 26 + CURVECAPS* = 28 + LINECAPS* = 30 + POLYGONALCAPS* = 32 + TEXTCAPS* = 34 + CLIPCAPS* = 36 + RASTERCAPS* = 38 + ASPECTX* = 40 + ASPECTY* = 42 + ASPECTXY* = 44 + LOGPIXELSX* = 88 + LOGPIXELSY* = 90 + SIZEPALETTE* = 104 + NUMRESERVED* = 106 + COLORRES* = 108 + PHYSICALWIDTH* = 110 + PHYSICALHEIGHT* = 111 + PHYSICALOFFSETX* = 112 + PHYSICALOFFSETY* = 113 + SCALINGFACTORX* = 114 + SCALINGFACTORY* = 115 + VREFRESH* = 116 + DESKTOPVERTRES* = 117 + DESKTOPHORZRES* = 118 + BLTALIGNMENT* = 119 + SHADEBLENDCAPS* = 120 + COLORMGMTCAPS* = 121 + DT_PLOTTER* = 0 + DT_RASDISPLAY* = 1 + DT_RASPRINTER* = 2 + DT_RASCAMERA* = 3 + DT_CHARSTREAM* = 4 + DT_METAFILE* = 5 + DT_DISPFILE* = 6 + CC_NONE* = 0 + CC_CIRCLES* = 1 + CC_PIE* = 2 + CC_CHORD* = 4 + CC_ELLIPSES* = 8 + CC_WIDE* = 16 + CC_STYLED* = 32 + CC_WIDESTYLED* = 64 + CC_INTERIORS* = 128 + CC_ROUNDRECT* = 256 + LC_NONE* = 0 + LC_POLYLINE* = 2 + LC_MARKER* = 4 + LC_POLYMARKER* = 8 + LC_WIDE* = 16 + LC_STYLED* = 32 + LC_WIDESTYLED* = 64 + LC_INTERIORS* = 128 + PC_NONE* = 0 + PC_POLYGON* = 1 + PC_RECTANGLE* = 2 + PC_WINDPOLYGON* = 4 + PC_TRAPEZOID* = 4 + PC_SCANLINE* = 8 + PC_WIDE* = 16 + PC_STYLED* = 32 + PC_WIDESTYLED* = 64 + PC_INTERIORS* = 128 + PC_POLYPOLYGON* = 256 + PC_PATHS* = 512 + CP_NONE* = 0 + CP_RECTANGLE* = 1 + CP_REGION* = 2 + TC_OP_CHARACTER* = 0x00000001 + TC_OP_STROKE* = 0x00000002 + TC_CP_STROKE* = 0x00000004 + TC_CR_90* = 0x00000008 + TC_CR_ANY* = 0x00000010 + TC_SF_X_YINDEP* = 0x00000020 + TC_SA_DOUBLE* = 0x00000040 + TC_SA_INTEGER* = 0x00000080 + TC_SA_CONTIN* = 0x00000100 + TC_EA_DOUBLE* = 0x00000200 + TC_IA_ABLE* = 0x00000400 + TC_UA_ABLE* = 0x00000800 + TC_SO_ABLE* = 0x00001000 + TC_RA_ABLE* = 0x00002000 + TC_VA_ABLE* = 0x00004000 + TC_RESERVED* = 0x00008000 + TC_SCROLLBLT* = 0x00010000 + RC_BITBLT* = 1 + RC_BANDING* = 2 + RC_SCALING* = 4 + RC_BITMAP64* = 8 + RC_GDI20_OUTPUT* = 0x0010 + RC_GDI20_STATE* = 0x0020 + RC_SAVEBITMAP* = 0x0040 + RC_DI_BITMAP* = 0x0080 + RC_PALETTE* = 0x0100 + RC_DIBTODEV* = 0x0200 + RC_BIGFONT* = 0x0400 + RC_STRETCHBLT* = 0x0800 + RC_FLOODFILL* = 0x1000 + RC_STRETCHDIB* = 0x2000 + RC_OP_DX_OUTPUT* = 0x4000 + RC_DEVBITS* = 0x8000 + SB_NONE* = 0x00000000 + SB_CONST_ALPHA* = 0x00000001 + SB_PIXEL_ALPHA* = 0x00000002 + SB_PREMULT_ALPHA* = 0x00000004 + SB_GRAD_RECT* = 0x00000010 + SB_GRAD_TRI* = 0x00000020 + CM_NONE* = 0x00000000 + CM_DEVICE_ICM* = 0x00000001 + CM_GAMMA_RAMP* = 0x00000002 + CM_CMYK_COLOR* = 0x00000004 + DIB_RGB_COLORS* = 0 + DIB_PAL_COLORS* = 1 + SYSPAL_ERROR* = 0 + SYSPAL_STATIC* = 1 + SYSPAL_NOSTATIC* = 2 + SYSPAL_NOSTATIC256* = 3 + CBM_INIT* = 0x04 + FLOODFILLBORDER* = 0 + FLOODFILLSURFACE* = 1 + DM_SPECVERSION* = 0x0401 + DM_ORIENTATION* = 0x00000001 + DM_PAPERSIZE* = 0x00000002 + DM_PAPERLENGTH* = 0x00000004 + DM_PAPERWIDTH* = 0x00000008 + DM_SCALE* = 0x00000010 + DM_POSITION* = 0x00000020 + DM_NUP* = 0x00000040 + DM_DISPLAYORIENTATION* = 0x00000080 + DM_COPIES* = 0x00000100 + DM_DEFAULTSOURCE* = 0x00000200 + DM_PRINTQUALITY* = 0x00000400 + DM_COLOR* = 0x00000800 + DM_DUPLEX* = 0x00001000 + DM_YRESOLUTION* = 0x00002000 + DM_TTOPTION* = 0x00004000 + DM_COLLATE* = 0x00008000 + DM_FORMNAME* = 0x00010000 + DM_LOGPIXELS* = 0x00020000 + DM_BITSPERPEL* = 0x00040000 + DM_PELSWIDTH* = 0x00080000 + DM_PELSHEIGHT* = 0x00100000 + DM_DISPLAYFLAGS* = 0x00200000 + DM_DISPLAYFREQUENCY* = 0x00400000 + DM_ICMMETHOD* = 0x00800000 + DM_ICMINTENT* = 0x01000000 + DM_MEDIATYPE* = 0x02000000 + DM_DITHERTYPE* = 0x04000000 + DM_PANNINGWIDTH* = 0x08000000 + DM_PANNINGHEIGHT* = 0x10000000 + DM_DISPLAYFIXEDOUTPUT* = 0x20000000 + DMORIENT_PORTRAIT* = 1 + DMORIENT_LANDSCAPE* = 2 + DMPAPER_LETTER* = 1 + DMPAPER_FIRST* = DMPAPER_LETTER + DMPAPER_LETTERSMALL* = 2 + DMPAPER_TABLOID* = 3 + DMPAPER_LEDGER* = 4 + DMPAPER_LEGAL* = 5 + DMPAPER_STATEMENT* = 6 + DMPAPER_EXECUTIVE* = 7 + DMPAPER_A3* = 8 + DMPAPER_A4* = 9 + DMPAPER_A4SMALL* = 10 + DMPAPER_A5* = 11 + DMPAPER_B4* = 12 + DMPAPER_B5* = 13 + DMPAPER_FOLIO* = 14 + DMPAPER_QUARTO* = 15 + DMPAPER_10X14* = 16 + DMPAPER_11X17* = 17 + DMPAPER_NOTE* = 18 + DMPAPER_ENV_9* = 19 + DMPAPER_ENV_10* = 20 + DMPAPER_ENV_11* = 21 + DMPAPER_ENV_12* = 22 + DMPAPER_ENV_14* = 23 + DMPAPER_CSHEET* = 24 + DMPAPER_DSHEET* = 25 + DMPAPER_ESHEET* = 26 + DMPAPER_ENV_DL* = 27 + DMPAPER_ENV_C5* = 28 + DMPAPER_ENV_C3* = 29 + DMPAPER_ENV_C4* = 30 + DMPAPER_ENV_C6* = 31 + DMPAPER_ENV_C65* = 32 + DMPAPER_ENV_B4* = 33 + DMPAPER_ENV_B5* = 34 + DMPAPER_ENV_B6* = 35 + DMPAPER_ENV_ITALY* = 36 + DMPAPER_ENV_MONARCH* = 37 + DMPAPER_ENV_PERSONAL* = 38 + DMPAPER_FANFOLD_US* = 39 + DMPAPER_FANFOLD_STD_GERMAN* = 40 + DMPAPER_FANFOLD_LGL_GERMAN* = 41 + DMPAPER_ISO_B4* = 42 + DMPAPER_JAPANESE_POSTCARD* = 43 + DMPAPER_9X11* = 44 + DMPAPER_10X11* = 45 + DMPAPER_15X11* = 46 + DMPAPER_ENV_INVITE* = 47 + DMPAPER_RESERVED_48* = 48 + DMPAPER_RESERVED_49* = 49 + DMPAPER_LETTER_EXTRA* = 50 + DMPAPER_LEGAL_EXTRA* = 51 + DMPAPER_TABLOID_EXTRA* = 52 + DMPAPER_A4_EXTRA* = 53 + DMPAPER_LETTER_TRANSVERSE* = 54 + DMPAPER_A4_TRANSVERSE* = 55 + DMPAPER_LETTER_EXTRA_TRANSVERSE* = 56 + DMPAPER_A_PLUS* = 57 + DMPAPER_B_PLUS* = 58 + DMPAPER_LETTER_PLUS* = 59 + DMPAPER_A4_PLUS* = 60 + DMPAPER_A5_TRANSVERSE* = 61 + DMPAPER_B5_TRANSVERSE* = 62 + DMPAPER_A3_EXTRA* = 63 + DMPAPER_A5_EXTRA* = 64 + DMPAPER_B5_EXTRA* = 65 + DMPAPER_A2* = 66 + DMPAPER_A3_TRANSVERSE* = 67 + DMPAPER_A3_EXTRA_TRANSVERSE* = 68 + DMPAPER_DBL_JAPANESE_POSTCARD* = 69 + DMPAPER_A6* = 70 + DMPAPER_JENV_KAKU2* = 71 + DMPAPER_JENV_KAKU3* = 72 + DMPAPER_JENV_CHOU3* = 73 + DMPAPER_JENV_CHOU4* = 74 + DMPAPER_LETTER_ROTATED* = 75 + DMPAPER_A3_ROTATED* = 76 + DMPAPER_A4_ROTATED* = 77 + DMPAPER_A5_ROTATED* = 78 + DMPAPER_B4_JIS_ROTATED* = 79 + DMPAPER_B5_JIS_ROTATED* = 80 + DMPAPER_JAPANESE_POSTCARD_ROTATED* = 81 + DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED* = 82 + DMPAPER_A6_ROTATED* = 83 + DMPAPER_JENV_KAKU2_ROTATED* = 84 + DMPAPER_JENV_KAKU3_ROTATED* = 85 + DMPAPER_JENV_CHOU3_ROTATED* = 86 + DMPAPER_JENV_CHOU4_ROTATED* = 87 + DMPAPER_B6_JIS* = 88 + DMPAPER_B6_JIS_ROTATED* = 89 + DMPAPER_12X11* = 90 + DMPAPER_JENV_YOU4* = 91 + DMPAPER_JENV_YOU4_ROTATED* = 92 + DMPAPER_P16K* = 93 + DMPAPER_P32K* = 94 + DMPAPER_P32KBIG* = 95 + DMPAPER_PENV_1* = 96 + DMPAPER_PENV_2* = 97 + DMPAPER_PENV_3* = 98 + DMPAPER_PENV_4* = 99 + DMPAPER_PENV_5* = 100 + DMPAPER_PENV_6* = 101 + DMPAPER_PENV_7* = 102 + DMPAPER_PENV_8* = 103 + DMPAPER_PENV_9* = 104 + DMPAPER_PENV_10* = 105 + DMPAPER_P16K_ROTATED* = 106 + DMPAPER_P32K_ROTATED* = 107 + DMPAPER_P32KBIG_ROTATED* = 108 + DMPAPER_PENV_1_ROTATED* = 109 + DMPAPER_PENV_2_ROTATED* = 110 + DMPAPER_PENV_3_ROTATED* = 111 + DMPAPER_PENV_4_ROTATED* = 112 + DMPAPER_PENV_5_ROTATED* = 113 + DMPAPER_PENV_6_ROTATED* = 114 + DMPAPER_PENV_7_ROTATED* = 115 + DMPAPER_PENV_8_ROTATED* = 116 + DMPAPER_PENV_9_ROTATED* = 117 + DMPAPER_PENV_10_ROTATED* = 118 + DMPAPER_LAST* = DMPAPER_PENV_10_ROTATED + DMPAPER_USER* = 256 + DMBIN_UPPER* = 1 + DMBIN_FIRST* = DMBIN_UPPER + DMBIN_ONLYONE* = 1 + DMBIN_LOWER* = 2 + DMBIN_MIDDLE* = 3 + DMBIN_MANUAL* = 4 + DMBIN_ENVELOPE* = 5 + DMBIN_ENVMANUAL* = 6 + DMBIN_AUTO* = 7 + DMBIN_TRACTOR* = 8 + DMBIN_SMALLFMT* = 9 + DMBIN_LARGEFMT* = 10 + DMBIN_LARGECAPACITY* = 11 + DMBIN_CASSETTE* = 14 + DMBIN_FORMSOURCE* = 15 + DMBIN_LAST* = DMBIN_FORMSOURCE + DMBIN_USER* = 256 + DMRES_DRAFT* = -1 + DMRES_LOW* = -2 + DMRES_MEDIUM* = -3 + DMRES_HIGH* = -4 + DMCOLOR_MONOCHROME* = 1 + DMCOLOR_COLOR* = 2 + DMDUP_SIMPLEX* = 1 + DMDUP_VERTICAL* = 2 + DMDUP_HORIZONTAL* = 3 + DMTT_BITMAP* = 1 + DMTT_DOWNLOAD* = 2 + DMTT_SUBDEV* = 3 + DMTT_DOWNLOAD_OUTLINE* = 4 + DMCOLLATE_FALSE* = 0 + DMCOLLATE_TRUE* = 1 + DMDO_DEFAULT* = 0 + DMDO_90* = 1 + DMDO_180* = 2 + DMDO_270* = 3 + DMDFO_DEFAULT* = 0 + DMDFO_STRETCH* = 1 + DMDFO_CENTER* = 2 + DM_INTERLACED* = 0x00000002 + DMDISPLAYFLAGS_TEXTMODE* = 0x00000004 + DMNUP_SYSTEM* = 1 + DMNUP_ONEUP* = 2 + DMICMMETHOD_NONE* = 1 + DMICMMETHOD_SYSTEM* = 2 + DMICMMETHOD_DRIVER* = 3 + DMICMMETHOD_DEVICE* = 4 + DMICMMETHOD_USER* = 256 + DMICM_SATURATE* = 1 + DMICM_CONTRAST* = 2 + DMICM_COLORIMETRIC* = 3 + DMICM_ABS_COLORIMETRIC* = 4 + DMICM_USER* = 256 + DMMEDIA_STANDARD* = 1 + DMMEDIA_TRANSPARENCY* = 2 + DMMEDIA_GLOSSY* = 3 + DMMEDIA_USER* = 256 + DMDITHER_NONE* = 1 + DMDITHER_COARSE* = 2 + DMDITHER_FINE* = 3 + DMDITHER_LINEART* = 4 + DMDITHER_ERRORDIFFUSION* = 5 + DMDITHER_RESERVED6* = 6 + DMDITHER_RESERVED7* = 7 + DMDITHER_RESERVED8* = 8 + DMDITHER_RESERVED9* = 9 + DMDITHER_GRAYSCALE* = 10 + DMDITHER_USER* = 256 + DISPLAY_DEVICE_ATTACHED_TO_DESKTOP* = 0x00000001 + DISPLAY_DEVICE_MULTI_DRIVER* = 0x00000002 + DISPLAY_DEVICE_PRIMARY_DEVICE* = 0x00000004 + DISPLAY_DEVICE_MIRRORING_DRIVER* = 0x00000008 + DISPLAY_DEVICE_VGA_COMPATIBLE* = 0x00000010 + DISPLAY_DEVICE_REMOVABLE* = 0x00000020 + DISPLAY_DEVICE_ACC_DRIVER* = 0x00000040 + DISPLAY_DEVICE_TS_COMPATIBLE* = 0x00200000 + DISPLAY_DEVICE_UNSAFE_MODES_ON* = 0x00080000 + DISPLAY_DEVICE_MODESPRUNED* = 0x08000000 + DISPLAY_DEVICE_REMOTE* = 0x04000000 + DISPLAY_DEVICE_DISCONNECT* = 0x02000000 + DISPLAY_DEVICE_ACTIVE* = 0x00000001 + DISPLAY_DEVICE_ATTACHED* = 0x00000002 + DISPLAYCONFIG_MAXPATH* = 1024 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER* = int32(-1) + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15* = int32 0 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO* = int32 1 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO* = int32 2 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO* = int32 3 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI* = int32 4 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI* = int32 5 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS* = int32 6 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN* = int32 8 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI* = int32 9 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL* = int32 10 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED* = int32 11 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL* = int32 12 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED* = int32 13 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE* = int32 14 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL* = int32 0x80000000'i32 + DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32* = int32 0xFFFFFFFF'i32 + DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED* = 0 + DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE* = 1 + DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED* = 2 + DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST* = 2 + DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST* = 3 + DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32* = 0xFFFFFFFF'i32 + DISPLAYCONFIG_SCALING_IDENTITY* = 1 + DISPLAYCONFIG_SCALING_CENTERED* = 2 + DISPLAYCONFIG_SCALING_STRETCHED* = 3 + DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX* = 4 + DISPLAYCONFIG_SCALING_CUSTOM* = 5 + DISPLAYCONFIG_SCALING_PREFERRED* = 128 + DISPLAYCONFIG_SCALING_FORCE_UINT32* = 0xFFFFFFFF'i32 + DISPLAYCONFIG_ROTATION_IDENTITY* = 1 + DISPLAYCONFIG_ROTATION_ROTATE90* = 2 + DISPLAYCONFIG_ROTATION_ROTATE180* = 3 + DISPLAYCONFIG_ROTATION_ROTATE270* = 4 + DISPLAYCONFIG_ROTATION_FORCE_UINT32* = 0xFFFFFFFF'i32 + DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE* = 1 + DISPLAYCONFIG_MODE_INFO_TYPE_TARGET* = 2 + DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32* = 0xFFFFFFFF'i32 + DISPLAYCONFIG_PIXELFORMAT_8BPP* = 1 + DISPLAYCONFIG_PIXELFORMAT_16BPP* = 2 + DISPLAYCONFIG_PIXELFORMAT_24BPP* = 3 + DISPLAYCONFIG_PIXELFORMAT_32BPP* = 4 + DISPLAYCONFIG_PIXELFORMAT_NONGDI* = 5 + DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32* = 0xffffffff'i32 + DISPLAYCONFIG_PATH_MODE_IDX_INVALID* = 0xffffffff'i32 + DISPLAYCONFIG_SOURCE_IN_USE* = 0x1 + DISPLAYCONFIG_TARGET_IN_USE* = 0x00000001 + DISPLAYCONFIG_TARGET_FORCIBLE* = 0x00000002 + DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_BOOT* = 0x00000004 + DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_PATH* = 0x00000008 + DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_SYSTEM* = 0x00000010 + DISPLAYCONFIG_PATH_ACTIVE* = 0x1 + DISPLAYCONFIG_TOPOLOGY_INTERNAL* = 0x1 + DISPLAYCONFIG_TOPOLOGY_CLONE* = 0x2 + DISPLAYCONFIG_TOPOLOGY_EXTEND* = 0x4 + DISPLAYCONFIG_TOPOLOGY_EXTERNAL* = 0x8 + DISPLAYCONFIG_TOPOLOGY_FORCE_UINT32* = 0xFFFFFFFF'i32 + DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME* = 1 + DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME* = 2 + DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE* = 3 + DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME* = 4 + DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE* = 5 + DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32* = 0xFFFFFFFF'i32 + QDC_ALL_PATHS* = 0x00000001 + QDC_ONLY_ACTIVE_PATHS* = 0x00000002 + QDC_DATABASE_CURRENT* = 0x00000004 + SDC_TOPOLOGY_INTERNAL* = 0x00000001 + SDC_TOPOLOGY_CLONE* = 0x00000002 + SDC_TOPOLOGY_EXTEND* = 0x00000004 + SDC_TOPOLOGY_EXTERNAL* = 0x00000008 + SDC_TOPOLOGY_SUPPLIED* = 0x00000010 + SDC_USE_DATABASE_CURRENT* = SDC_TOPOLOGY_INTERNAL or SDC_TOPOLOGY_CLONE or SDC_TOPOLOGY_EXTEND or SDC_TOPOLOGY_EXTERNAL + SDC_USE_SUPPLIED_DISPLAY_CONFIG* = 0x00000020 + SDC_VALIDATE* = 0x00000040 + SDC_APPLY* = 0x00000080 + SDC_NO_OPTIMIZATION* = 0x00000100 + SDC_SAVE_TO_DATABASE* = 0x00000200 + SDC_ALLOW_CHANGES* = 0x00000400 + SDC_PATH_PERSIST_IF_REQUIRED* = 0x00000800 + SDC_FORCE_MODE_ENUMERATION* = 0x00001000 + SDC_ALLOW_PATH_ORDER_CHANGES* = 0x00002000 + RDH_RECTANGLES* = 1 + SYSRGN* = 4 + GGO_METRICS* = 0 + GGO_BITMAP* = 1 + GGO_NATIVE* = 2 + GGO_BEZIER* = 3 + GGO_GRAY2_BITMAP* = 4 + GGO_GRAY4_BITMAP* = 5 + GGO_GRAY8_BITMAP* = 6 + GGO_GLYPH_INDEX* = 0x0080 + GGO_UNHINTED* = 0x0100 + TT_POLYGON_TYPE* = 24 + TT_PRIM_LINE* = 1 + TT_PRIM_QSPLINE* = 2 + TT_PRIM_CSPLINE* = 3 + GCP_DBCS* = 0x0001 + GCP_REORDER* = 0x0002 + GCP_USEKERNING* = 0x0008 + GCP_GLYPHSHAPE* = 0x0010 + GCP_LIGATE* = 0x0020 + GCP_DIACRITIC* = 0x0100 + GCP_KASHIDA* = 0x0400 + GCP_ERROR* = 0x8000 + FLI_MASK* = 0x103B + GCP_JUSTIFY* = 0x00010000 + FLI_GLYPHS* = 0x00040000 + GCP_CLASSIN* = 0x00080000 + GCP_MAXEXTENT* = 0x00100000 + GCP_JUSTIFYIN* = 0x00200000 + GCP_DISPLAYZWG* = 0x00400000 + GCP_SYMSWAPOFF* = 0x00800000 + GCP_NUMERICOVERRIDE* = 0x01000000 + GCP_NEUTRALOVERRIDE* = 0x02000000 + GCP_NUMERICSLATIN* = 0x04000000 + GCP_NUMERICSLOCAL* = 0x08000000 + GCPCLASS_LATIN* = 1 + GCPCLASS_HEBREW* = 2 + GCPCLASS_ARABIC* = 2 + GCPCLASS_NEUTRAL* = 3 + GCPCLASS_LOCALNUMBER* = 4 + GCPCLASS_LATINNUMBER* = 5 + GCPCLASS_LATINNUMERICTERMINATOR* = 6 + GCPCLASS_LATINNUMERICSEPARATOR* = 7 + GCPCLASS_NUMERICSEPARATOR* = 8 + GCPCLASS_PREBOUNDLTR* = 0x80 + GCPCLASS_PREBOUNDRTL* = 0x40 + GCPCLASS_POSTBOUNDLTR* = 0x20 + GCPCLASS_POSTBOUNDRTL* = 0x10 + GCPGLYPH_LINKBEFORE* = 0x8000 + GCPGLYPH_LINKAFTER* = 0x4000 + TT_AVAILABLE* = 0x0001 + TT_ENABLED* = 0x0002 + PFD_TYPE_RGBA* = 0 + PFD_TYPE_COLORINDEX* = 1 + PFD_MAIN_PLANE* = 0 + PFD_OVERLAY_PLANE* = 1 + PFD_UNDERLAY_PLANE* = -1 + PFD_DOUBLEBUFFER* = 0x00000001 + PFD_STEREO* = 0x00000002 + PFD_DRAW_TO_WINDOW* = 0x00000004 + PFD_DRAW_TO_BITMAP* = 0x00000008 + PFD_SUPPORT_GDI* = 0x00000010 + PFD_SUPPORT_OPENGL* = 0x00000020 + PFD_GENERIC_FORMAT* = 0x00000040 + PFD_NEED_PALETTE* = 0x00000080 + PFD_NEED_SYSTEM_PALETTE* = 0x00000100 + PFD_SWAP_EXCHANGE* = 0x00000200 + PFD_SWAP_COPY* = 0x00000400 + PFD_SWAP_LAYER_BUFFERS* = 0x00000800 + PFD_GENERIC_ACCELERATED* = 0x00001000 + PFD_SUPPORT_DIRECTDRAW* = 0x00002000 + PFD_DIRECT3D_ACCELERATED* = 0x00004000 + PFD_SUPPORT_COMPOSITION* = 0x00008000 + PFD_DEPTH_DONTCARE* = 0x20000000 + PFD_DOUBLEBUFFER_DONTCARE* = 0x40000000 + PFD_STEREO_DONTCARE* = 0x80000000'i32 + DC_BINADJUST* = 19 + DC_EMF_COMPLIANT* = 20 + DC_DATATYPE_PRODUCED* = 21 + DC_COLLATE* = 22 + DC_MANUFACTURER* = 23 + DC_MODEL* = 24 + DC_PERSONALITY* = 25 + DC_PRINTRATE* = 26 + DC_PRINTRATEUNIT* = 27 + PRINTRATEUNIT_PPM* = 1 + PRINTRATEUNIT_CPS* = 2 + PRINTRATEUNIT_LPM* = 3 + PRINTRATEUNIT_IPM* = 4 + DC_PRINTERMEM* = 28 + DC_MEDIAREADY* = 29 + DC_STAPLE* = 30 + DC_PRINTRATEPPM* = 31 + DC_COLORDEVICE* = 32 + DC_NUP* = 33 + DC_MEDIATYPENAMES* = 34 + DC_MEDIATYPES* = 35 + DCTT_BITMAP* = 0x0000001 + DCTT_DOWNLOAD* = 0x0000002 + DCTT_SUBDEV* = 0x0000004 + DCTT_DOWNLOAD_OUTLINE* = 0x0000008 + DCBA_FACEUPNONE* = 0x0000 + DCBA_FACEUPCENTER* = 0x0001 + DCBA_FACEUPLEFT* = 0x0002 + DCBA_FACEUPRIGHT* = 0x0003 + DCBA_FACEDOWNNONE* = 0x0100 + DCBA_FACEDOWNCENTER* = 0x0101 + DCBA_FACEDOWNLEFT* = 0x0102 + DCBA_FACEDOWNRIGHT* = 0x0103 + GS_8BIT_INDICES* = 0x00000001 + GGI_MARK_NONEXISTING_GLYPHS* = 0X0001 + FR_PRIVATE* = 0x10 + FR_NOT_ENUM* = 0x20 + GDIREGISTERDDRAWPACKETVERSION* = 0x1 + AC_SRC_OVER* = 0x00 + AC_SRC_ALPHA* = 0x01 + GRADIENT_FILL_RECT_H* = 0x00000000 + GRADIENT_FILL_RECT_V* = 0x00000001 + GRADIENT_FILL_TRIANGLE* = 0x00000002 + GRADIENT_FILL_OP_FLAG* = 0x000000ff + CA_NEGATIVE* = 0x0001 + CA_LOG_FILTER* = 0x0002 + ILLUMINANT_DEVICE_DEFAULT* = 0 + ILLUMINANT_A* = 1 + ILLUMINANT_B* = 2 + ILLUMINANT_C* = 3 + ILLUMINANT_D50* = 4 + ILLUMINANT_D55* = 5 + ILLUMINANT_D65* = 6 + ILLUMINANT_D75* = 7 + ILLUMINANT_F2* = 8 + ILLUMINANT_MAX_INDEX* = ILLUMINANT_F2 + ILLUMINANT_TUNGSTEN* = ILLUMINANT_A + ILLUMINANT_DAYLIGHT* = ILLUMINANT_C + ILLUMINANT_FLUORESCENT* = ILLUMINANT_F2 + ILLUMINANT_NTSC* = ILLUMINANT_C + RGB_GAMMA_MIN* = WORD 02500 + RGB_GAMMA_MAX* = WORD 65000 + REFERENCE_WHITE_MIN* = WORD 6000 + REFERENCE_WHITE_MAX* = WORD 10000 + REFERENCE_BLACK_MIN* = WORD 0 + REFERENCE_BLACK_MAX* = WORD 4000 + COLOR_ADJ_MIN* = SHORT(-100) + COLOR_ADJ_MAX* = SHORT 100 + DI_APPBANDING* = 0x00000001 + DI_ROPS_READ_DESTINATION* = 0x00000002 + FONTMAPPER_MAX* = 10 + ICM_OFF* = 1 + ICM_ON* = 2 + ICM_QUERY* = 3 + ICM_DONE_OUTSIDEDC* = 4 + ENHMETA_SIGNATURE* = 0x464D4520 + ENHMETA_STOCK_OBJECT* = 0x80000000'i32 + emrHEADER* = 1 + emrPOLYBEZIER* = 2 + emrPOLYGON* = 3 + emrPOLYLINE* = 4 + emrPOLYBEZIERTO* = 5 + emrPOLYLINETO* = 6 + emrPOLYPOLYLINE* = 7 + emrPOLYPOLYGON* = 8 + emrSETWINDOWEXTEX* = 9 + emrSETWINDOWORGEX* = 10 + emrSETVIEWPORTEXTEX* = 11 + emrSETVIEWPORTORGEX* = 12 + emrSETBRUSHORGEX* = 13 + emrEOF* = 14 + emrSETPIXELV* = 15 + emrSETMAPPERFLAGS* = 16 + emrSETMAPMODE* = 17 + emrSETBKMODE* = 18 + emrSETPOLYFILLMODE* = 19 + emrSETROP2* = 20 + emrSETSTRETCHBLTMODE* = 21 + emrSETTEXTALIGN* = 22 + emrSETCOLORADJUSTMENT* = 23 + emrSETTEXTCOLOR* = 24 + emrSETBKCOLOR* = 25 + emrOFFSETCLIPRGN* = 26 + emrMOVETOEX* = 27 + emrSETMETARGN* = 28 + emrEXCLUDECLIPRECT* = 29 + emrINTERSECTCLIPRECT* = 30 + emrSCALEVIEWPORTEXTEX* = 31 + emrSCALEWINDOWEXTEX* = 32 + emrSAVEDC* = 33 + emrRESTOREDC* = 34 + emrSETWORLDTRANSFORM* = 35 + emrMODIFYWORLDTRANSFORM* = 36 + emrSELECTOBJECT* = 37 + emrCREATEPEN* = 38 + emrCREATEBRUSHINDIRECT* = 39 + emrDELETEOBJECT* = 40 + emrANGLEARC* = 41 + emrELLIPSE* = 42 + emrRECTANGLE* = 43 + emrROUNDRECT* = 44 + emrARC* = 45 + emrCHORD* = 46 + emrPIE* = 47 + emrSELECTPALETTE* = 48 + emrCREATEPALETTE* = 49 + emrSETPALETTEENTRIES* = 50 + emrRESIZEPALETTE* = 51 + emrREALIZEPALETTE* = 52 + emrEXTFLOODFILL* = 53 + emrLINETO* = 54 + emrARCTO* = 55 + emrPOLYDRAW* = 56 + emrSETARCDIRECTION* = 57 + emrSETMITERLIMIT* = 58 + emrBEGINPATH* = 59 + emrENDPATH* = 60 + emrCLOSEFIGURE* = 61 + emrFILLPATH* = 62 + emrSTROKEANDFILLPATH* = 63 + emrSTROKEPATH* = 64 + emrFLATTENPATH* = 65 + emrWIDENPATH* = 66 + emrSELECTCLIPPATH* = 67 + emrABORTPATH* = 68 + emrGDICOMMENT* = 70 + emrFILLRGN* = 71 + emrFRAMERGN* = 72 + emrINVERTRGN* = 73 + emrPAINTRGN* = 74 + emrEXTSELECTCLIPRGN* = 75 + emrBITBLT* = 76 + emrSTRETCHBLT* = 77 + emrMASKBLT* = 78 + emrPLGBLT* = 79 + emrSETDIBITSTODEVICE* = 80 + emrSTRETCHDIBITS* = 81 + emrEXTCREATEFONTINDIRECTW* = 82 + emrEXTTEXTOUTA* = 83 + emrEXTTEXTOUTW* = 84 + emrPOLYBEZIER16* = 85 + emrPOLYGON16* = 86 + emrPOLYLINE16* = 87 + emrPOLYBEZIERTO16* = 88 + emrPOLYLINETO16* = 89 + emrPOLYPOLYLINE16* = 90 + emrPOLYPOLYGON16* = 91 + emrPOLYDRAW16* = 92 + emrCREATEMONOBRUSH* = 93 + emrCREATEDIBPATTERNBRUSHPT* = 94 + emrEXTCREATEPEN* = 95 + emrPOLYTEXTOUTA* = 96 + emrPOLYTEXTOUTW* = 97 + emrSETICMMODE* = 98 + emrCREATECOLORSPACE* = 99 + emrSETCOLORSPACE* = 100 + emrDELETECOLORSPACE* = 101 + emrGLSRECORD* = 102 + emrGLSBOUNDEDRECORD* = 103 + emrPIXELFORMAT* = 104 + emrRESERVED_105* = 105 + emrRESERVED_106* = 106 + emrRESERVED_107* = 107 + emrRESERVED_108* = 108 + emrRESERVED_109* = 109 + emrRESERVED_110* = 110 + emrCOLORCORRECTPALETTE* = 111 + emrSETICMPROFILEA* = 112 + emrSETICMPROFILEW* = 113 + emrALPHABLEND* = 114 + emrSETLAYOUT* = 115 + emrTRANSPARENTBLT* = 116 + emrRESERVED_117* = 117 + emrGRADIENTFILL* = 118 + emrRESERVED_119* = 119 + emrRESERVED_120* = 120 + emrCOLORMATCHTOTARGETW* = 121 + emrCREATECOLORSPACEW* = 122 + emrMIN* = 1 + emrMAX* = 122 + SETICMPROFILE_EMBEDED* = 0x00000001 + CREATECOLORSPACE_EMBEDED* = 0x00000001 + COLORMATCHTOTARGET_EMBEDED* = 0x00000001 + GDICOMMENT_IDENTIFIER* = 0x43494447 + GDICOMMENT_WINDOWS_METAFILE* = 0x80000001'i32 + GDICOMMENT_BEGINGROUP* = 0x00000002 + GDICOMMENT_ENDGROUP* = 0x00000003 + GDICOMMENT_MULTIFORMATS* = 0x40000004 + EPS_SIGNATURE* = 0x46535045 + GDICOMMENT_UNICODE_STRING* = 0x00000040 + GDICOMMENT_UNICODE_END* = 0x00000080 + WGL_FONT_LINES* = 0 + WGL_FONT_POLYGONS* = 1 + LPD_DOUBLEBUFFER* = 0x00000001 + LPD_STEREO* = 0x00000002 + LPD_SUPPORT_GDI* = 0x00000010 + LPD_SUPPORT_OPENGL* = 0x00000020 + LPD_SHARE_DEPTH* = 0x00000040 + LPD_SHARE_STENCIL* = 0x00000080 + LPD_SHARE_ACCUM* = 0x00000100 + LPD_SWAP_EXCHANGE* = 0x00000200 + LPD_SWAP_COPY* = 0x00000400 + LPD_TRANSPARENT* = 0x00001000 + LPD_TYPE_RGBA* = 0 + LPD_TYPE_COLORINDEX* = 1 + WGL_SWAP_MAIN_PLANE* = 0x00000001 + WGL_SWAP_OVERLAY1* = 0x00000002 + WGL_SWAP_OVERLAY2* = 0x00000004 + WGL_SWAP_OVERLAY3* = 0x00000008 + WGL_SWAP_OVERLAY4* = 0x00000010 + WGL_SWAP_OVERLAY5* = 0x00000020 + WGL_SWAP_OVERLAY6* = 0x00000040 + WGL_SWAP_OVERLAY7* = 0x00000080 + WGL_SWAP_OVERLAY8* = 0x00000100 + WGL_SWAP_OVERLAY9* = 0x00000200 + WGL_SWAP_OVERLAY10* = 0x00000400 + WGL_SWAP_OVERLAY11* = 0x00000800 + WGL_SWAP_OVERLAY12* = 0x00001000 + WGL_SWAP_OVERLAY13* = 0x00002000 + WGL_SWAP_OVERLAY14* = 0x00004000 + WGL_SWAP_OVERLAY15* = 0x00008000 + WGL_SWAP_UNDERLAY1* = 0x00010000 + WGL_SWAP_UNDERLAY2* = 0x00020000 + WGL_SWAP_UNDERLAY3* = 0x00040000 + WGL_SWAP_UNDERLAY4* = 0x00080000 + WGL_SWAP_UNDERLAY5* = 0x00100000 + WGL_SWAP_UNDERLAY6* = 0x00200000 + WGL_SWAP_UNDERLAY7* = 0x00400000 + WGL_SWAP_UNDERLAY8* = 0x00800000 + WGL_SWAP_UNDERLAY9* = 0x01000000 + WGL_SWAP_UNDERLAY10* = 0x02000000 + WGL_SWAP_UNDERLAY11* = 0x04000000 + WGL_SWAP_UNDERLAY12* = 0x08000000 + WGL_SWAP_UNDERLAY13* = 0x10000000 + WGL_SWAP_UNDERLAY14* = 0x20000000 + WGL_SWAP_UNDERLAY15* = 0x40000000 + WGL_SWAPMULTIPLE_MAX* = 16 + STAMP_AXESLIST* = 0x08006C61 + STAMP_DESIGNVECTOR* = 0x08007664 +type + GOBJENUMPROC* = proc (P1: LPVOID, P2: LPARAM): int32 {.stdcall.} + LINEDDAPROC* = proc (P1: int32, P2: int32, P3: LPARAM): VOID {.stdcall.} +when winimUnicode: + type + LPDEVMODE* = LPDEVMODEW +when winimAnsi: + type + LPDEVMODE* = LPDEVMODEA +type + LPFNDEVMODE* = proc (P1: HWND, P2: HMODULE, P3: LPDEVMODE, P4: LPSTR, P5: LPSTR, P6: LPDEVMODE, P7: LPSTR, P8: UINT): UINT {.stdcall.} + LPFNDEVCAPS* = proc (P1: LPSTR, P2: LPSTR, P3: UINT, P4: LPSTR, P5: LPDEVMODE): DWORD {.stdcall.} + GDIMARSHALLOC* = proc (dwSize: DWORD, pGdiRef: LPVOID): PVOID {.stdcall.} + MFENUMPROC* = proc (hdc: HDC, lpht: ptr HANDLETABLE, lpMR: ptr METARECORD, nObj: int32, lParam: LPARAM): int32 {.stdcall.} + ENHMFENUMPROC* = proc (hdc: HDC, lpht: ptr HANDLETABLE, lpmr: ptr ENHMETARECORD, hHandles: int32, data: LPARAM): int32 {.stdcall.} + ABORTPROC* = proc (P1: HDC, P2: int32): WINBOOL {.stdcall.} + ICMENUMPROCA* = proc (P1: LPSTR, P2: LPARAM): int32 {.stdcall.} + ICMENUMPROCW* = proc (P1: LPWSTR, P2: LPARAM): int32 {.stdcall.} + DISPLAYCONFIG_RATIONAL* {.pure.} = object + Numerator*: UINT32 + Denominator*: UINT32 + DISPLAYCONFIG_2DREGION* {.pure.} = object + cx*: UINT32 + cy*: UINT32 + DISPLAYCONFIG_VIDEO_SIGNAL_INFO* {.pure.} = object + pixelRate*: UINT64 + hSyncFreq*: DISPLAYCONFIG_RATIONAL + vSyncFreq*: DISPLAYCONFIG_RATIONAL + activeSize*: DISPLAYCONFIG_2DREGION + totalSize*: DISPLAYCONFIG_2DREGION + videoStandard*: UINT32 + scanLineOrdering*: DISPLAYCONFIG_SCANLINE_ORDERING + DISPLAYCONFIG_SOURCE_MODE* {.pure.} = object + width*: UINT32 + height*: UINT32 + pixelFormat*: DISPLAYCONFIG_PIXELFORMAT + position*: POINTL + DISPLAYCONFIG_TARGET_MODE* {.pure.} = object + targetVideoSignalInfo*: DISPLAYCONFIG_VIDEO_SIGNAL_INFO + DISPLAYCONFIG_MODE_INFO_UNION1* {.pure, union.} = object + targetMode*: DISPLAYCONFIG_TARGET_MODE + sourceMode*: DISPLAYCONFIG_SOURCE_MODE + DISPLAYCONFIG_MODE_INFO* {.pure.} = object + infoType*: DISPLAYCONFIG_MODE_INFO_TYPE + id*: UINT32 + adapterId*: LUID + union1*: DISPLAYCONFIG_MODE_INFO_UNION1 + DISPLAYCONFIG_PATH_SOURCE_INFO* {.pure.} = object + adapterId*: LUID + id*: UINT32 + modeInfoIdx*: UINT32 + statusFlags*: UINT32 + DISPLAYCONFIG_PATH_TARGET_INFO* {.pure.} = object + adapterId*: LUID + id*: UINT32 + modeInfoIdx*: UINT32 + outputTechnology*: DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY + rotation*: DISPLAYCONFIG_ROTATION + scaling*: DISPLAYCONFIG_SCALING + refreshRate*: DISPLAYCONFIG_RATIONAL + scanLineOrdering*: DISPLAYCONFIG_SCANLINE_ORDERING + targetAvailable*: WINBOOL + statusFlags*: UINT32 + DISPLAYCONFIG_PATH_INFO* {.pure.} = object + sourceInfo*: DISPLAYCONFIG_PATH_SOURCE_INFO + targetInfo*: DISPLAYCONFIG_PATH_TARGET_INFO + flags*: UINT32 + DISPLAYCONFIG_DEVICE_INFO_HEADER* {.pure.} = object + `type`*: DISPLAYCONFIG_DEVICE_INFO_TYPE + size*: UINT32 + adapterId*: LUID + id*: UINT32 + DISPLAYCONFIG_SOURCE_DEVICE_NAME* {.pure.} = object + header*: DISPLAYCONFIG_DEVICE_INFO_HEADER + viewGdiDeviceName*: array[CCHDEVICENAME, WCHAR] + DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS_UNION1_STRUCT1* {.pure.} = object + friendlyNameFromEdid* {.bitsize:1.}: UINT32 + friendlyNameForced* {.bitsize:1.}: UINT32 + edidIdsValid* {.bitsize:1.}: UINT32 + reserved* {.bitsize:29.}: UINT32 + DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS_UNION1* {.pure, union.} = object + struct1*: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS_UNION1_STRUCT1 + value*: UINT32 + DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS* {.pure.} = object + union1*: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS_UNION1 + DISPLAYCONFIG_TARGET_DEVICE_NAME* {.pure.} = object + header*: DISPLAYCONFIG_DEVICE_INFO_HEADER + flags*: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS + outputTechnology*: DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY + edidManufactureId*: UINT16 + edidProductCodeId*: UINT16 + connectorInstance*: UINT32 + monitorFriendlyDeviceName*: array[64, WCHAR] + monitorDevicePath*: array[128, WCHAR] + DISPLAYCONFIG_TARGET_PREFERRED_MODE* {.pure.} = object + header*: DISPLAYCONFIG_DEVICE_INFO_HEADER + width*: UINT32 + height*: UINT32 + targetMode*: DISPLAYCONFIG_TARGET_MODE + DISPLAYCONFIG_ADAPTER_NAME* {.pure.} = object + header*: DISPLAYCONFIG_DEVICE_INFO_HEADER + adapterDevicePath*: array[128, WCHAR] + DISPLAYCONFIG_SET_TARGET_PERSISTENCE_UNION1_STRUCT1* {.pure.} = object + bootPersistenceOn* {.bitsize:1.}: UINT32 + reserved* {.bitsize:31.}: UINT32 + DISPLAYCONFIG_SET_TARGET_PERSISTENCE_UNION1* {.pure, union.} = object + struct1*: DISPLAYCONFIG_SET_TARGET_PERSISTENCE_UNION1_STRUCT1 + value*: UINT32 + DISPLAYCONFIG_SET_TARGET_PERSISTENCE* {.pure.} = object + header*: DISPLAYCONFIG_DEVICE_INFO_HEADER + union1*: DISPLAYCONFIG_SET_TARGET_PERSISTENCE_UNION1 +proc AddFontResourceA*(P1: LPCSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AddFontResourceW*(P1: LPCWSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AnimatePalette*(hPal: HPALETTE, iStartIndex: UINT, cEntries: UINT, ppe: ptr PALETTEENTRY): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Arc*(hdc: HDC, x1: int32, y1: int32, x2: int32, y2: int32, x3: int32, y3: int32, x4: int32, y4: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc BitBlt*(hdc: HDC, x: int32, y: int32, cx: int32, cy: int32, hdcSrc: HDC, x1: int32, y1: int32, rop: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CancelDC*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Chord*(hdc: HDC, x1: int32, y1: int32, x2: int32, y2: int32, x3: int32, y3: int32, x4: int32, y4: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ChoosePixelFormat*(hdc: HDC, ppfd: ptr PIXELFORMATDESCRIPTOR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CloseMetaFile*(hdc: HDC): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CombineRgn*(hrgnDst: HRGN, hrgnSrc1: HRGN, hrgnSrc2: HRGN, iMode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CopyMetaFileA*(P1: HMETAFILE, P2: LPCSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CopyMetaFileW*(P1: HMETAFILE, P2: LPCWSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateBitmap*(nWidth: int32, nHeight: int32, nPlanes: UINT, nBitCount: UINT, lpBits: pointer): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateBitmapIndirect*(pbm: ptr BITMAP): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateBrushIndirect*(plbrush: ptr LOGBRUSH): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateCompatibleBitmap*(hdc: HDC, cx: int32, cy: int32): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDiscardableBitmap*(hdc: HDC, cx: int32, cy: int32): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateCompatibleDC*(hdc: HDC): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDCA*(pwszDriver: LPCSTR, pwszDevice: LPCSTR, pszPort: LPCSTR, pdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDCW*(pwszDriver: LPCWSTR, pwszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDIBitmap*(hdc: HDC, pbmih: ptr BITMAPINFOHEADER, flInit: DWORD, pjBits: pointer, pbmi: ptr BITMAPINFO, iUsage: UINT): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDIBPatternBrush*(h: HGLOBAL, iUsage: UINT): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDIBPatternBrushPt*(lpPackedDIB: pointer, iUsage: UINT): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateEllipticRgn*(x1: int32, y1: int32, x2: int32, y2: int32): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateEllipticRgnIndirect*(lprect: ptr RECT): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontIndirectA*(lplf: ptr LOGFONTA): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontIndirectW*(lplf: ptr LOGFONTW): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontA*(cHeight: int32, cWidth: int32, cEscapement: int32, cOrientation: int32, cWeight: int32, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCSTR): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontW*(cHeight: int32, cWidth: int32, cEscapement: int32, cOrientation: int32, cWeight: int32, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCWSTR): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateHatchBrush*(iHatch: int32, color: COLORREF): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateICA*(pszDriver: LPCSTR, pszDevice: LPCSTR, pszPort: LPCSTR, pdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateICW*(pszDriver: LPCWSTR, pszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateMetaFileA*(pszFile: LPCSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateMetaFileW*(pszFile: LPCWSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePalette*(plpal: ptr LOGPALETTE): HPALETTE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePen*(iStyle: int32, cWidth: int32, color: COLORREF): HPEN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePenIndirect*(plpen: ptr LOGPEN): HPEN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePolyPolygonRgn*(pptl: ptr POINT, pc: ptr INT, cPoly: int32, iMode: int32): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePatternBrush*(hbm: HBITMAP): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateRectRgn*(x1: int32, y1: int32, x2: int32, y2: int32): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateRectRgnIndirect*(lprect: ptr RECT): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateRoundRectRgn*(x1: int32, y1: int32, x2: int32, y2: int32, w: int32, h: int32): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateScalableFontResourceA*(fdwHidden: DWORD, lpszFont: LPCSTR, lpszFile: LPCSTR, lpszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateScalableFontResourceW*(fdwHidden: DWORD, lpszFont: LPCWSTR, lpszFile: LPCWSTR, lpszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateSolidBrush*(color: COLORREF): HBRUSH {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeleteDC*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeleteMetaFile*(hmf: HMETAFILE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeleteObject*(ho: HGDIOBJ): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DescribePixelFormat*(hdc: HDC, iPixelFormat: int32, nBytes: UINT, ppfd: LPPIXELFORMATDESCRIPTOR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeviceCapabilitiesA*(pDevice: LPCSTR, pPort: LPCSTR, fwCapability: WORD, pOutput: LPSTR, pDevMode: ptr DEVMODEA): int32 {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeviceCapabilitiesW*(pDevice: LPCWSTR, pPort: LPCWSTR, fwCapability: WORD, pOutput: LPWSTR, pDevMode: ptr DEVMODEW): int32 {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DrawEscape*(hdc: HDC, iEscape: int32, cjIn: int32, lpIn: LPCSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Ellipse*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontFamiliesExA*(hdc: HDC, lpLogfont: LPLOGFONTA, lpProc: FONTENUMPROCA, lParam: LPARAM, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontFamiliesExW*(hdc: HDC, lpLogfont: LPLOGFONTW, lpProc: FONTENUMPROCW, lParam: LPARAM, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontFamiliesA*(hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontFamiliesW*(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontsA*(hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumFontsW*(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumObjects*(hdc: HDC, nType: int32, lpFunc: GOBJENUMPROC, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EqualRgn*(hrgn1: HRGN, hrgn2: HRGN): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Escape*(hdc: HDC, iEscape: int32, cjIn: int32, pvIn: LPCSTR, pvOut: LPVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtEscape*(hdc: HDC, iEscape: int32, cjInput: int32, lpInData: LPCSTR, cjOutput: int32, lpOutData: LPSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExcludeClipRect*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtCreateRegion*(lpx: ptr XFORM, nCount: DWORD, lpData: ptr RGNDATA): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtFloodFill*(hdc: HDC, x: int32, y: int32, color: COLORREF, `type`: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FillRgn*(hdc: HDC, hrgn: HRGN, hbr: HBRUSH): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FloodFill*(hdc: HDC, x: int32, y: int32, color: COLORREF): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FrameRgn*(hdc: HDC, hrgn: HRGN, hbr: HBRUSH, w: int32, h: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetROP2*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetAspectRatioFilterEx*(hdc: HDC, lpsize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBkColor*(hdc: HDC): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDCBrushColor*(hdc: HDC): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDCPenColor*(hdc: HDC): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBkMode*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBitmapBits*(hbit: HBITMAP, cb: LONG, lpvBits: LPVOID): LONG {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBitmapDimensionEx*(hbit: HBITMAP, lpsize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBoundsRect*(hdc: HDC, lprect: LPRECT, flags: UINT): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetBrushOrgEx*(hdc: HDC, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidthA*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidthW*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidth32A*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidth32W*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidthFloatA*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidthFloatW*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharABCWidthsA*(hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharABCWidthsW*(hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharABCWidthsFloatA*(hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharABCWidthsFloatW*(hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetClipBox*(hdc: HDC, lprect: LPRECT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetClipRgn*(hdc: HDC, hrgn: HRGN): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMetaRgn*(hdc: HDC, hrgn: HRGN): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCurrentObject*(hdc: HDC, `type`: UINT): HGDIOBJ {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCurrentPositionEx*(hdc: HDC, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDeviceCaps*(hdc: HDC, index: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDIBits*(hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpvBits: LPVOID, lpbmi: LPBITMAPINFO, usage: UINT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetFontData*(hdc: HDC, dwTable: DWORD, dwOffset: DWORD, pvBuffer: PVOID, cjBuffer: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetGlyphOutlineA*(hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: ptr MAT2): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetGlyphOutlineW*(hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: ptr MAT2): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetGraphicsMode*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMapMode*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMetaFileBitsEx*(hMF: HMETAFILE, cbBuffer: UINT, lpData: LPVOID): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMetaFileA*(lpName: LPCSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMetaFileW*(lpName: LPCWSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetNearestColor*(hdc: HDC, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetNearestPaletteIndex*(h: HPALETTE, color: COLORREF): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetObjectType*(h: HGDIOBJ): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetOutlineTextMetricsA*(hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICA): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetOutlineTextMetricsW*(hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICW): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetPaletteEntries*(hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetPixel*(hdc: HDC, x: int32, y: int32): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetPixelFormat*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetPolyFillMode*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetRasterizerCaps*(lpraststat: LPRASTERIZER_STATUS, cjBytes: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetRandomRgn*(hdc: HDC, hrgn: HRGN, i: INT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetRegionData*(hrgn: HRGN, nCount: DWORD, lpRgnData: LPRGNDATA): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetRgnBox*(hrgn: HRGN, lprc: LPRECT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetStockObject*(i: int32): HGDIOBJ {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetStretchBltMode*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetSystemPaletteEntries*(hdc: HDC, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetSystemPaletteUse*(hdc: HDC): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextCharacterExtra*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextAlign*(hdc: HDC): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextColor*(hdc: HDC): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentPointA*(hdc: HDC, lpString: LPCSTR, c: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentPointW*(hdc: HDC, lpString: LPCWSTR, c: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentPoint32A*(hdc: HDC, lpString: LPCSTR, c: int32, psizl: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentPoint32W*(hdc: HDC, lpString: LPCWSTR, c: int32, psizl: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentExPointA*(hdc: HDC, lpszString: LPCSTR, cchString: int32, nMaxExtent: int32, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentExPointW*(hdc: HDC, lpszString: LPCWSTR, cchString: int32, nMaxExtent: int32, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextCharset*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextCharsetInfo*(hdc: HDC, lpSig: LPFONTSIGNATURE, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc TranslateCharsetInfo*(lpSrc: ptr DWORD, lpCs: LPCHARSETINFO, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetFontLanguageInfo*(hdc: HDC): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharacterPlacementA*(hdc: HDC, lpString: LPCSTR, nCount: int32, nMexExtent: int32, lpResults: LPGCP_RESULTSA, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharacterPlacementW*(hdc: HDC, lpString: LPCWSTR, nCount: int32, nMexExtent: int32, lpResults: LPGCP_RESULTSW, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetFontUnicodeRanges*(hdc: HDC, lpgs: LPGLYPHSET): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetGlyphIndicesA*(hdc: HDC, lpstr: LPCSTR, c: int32, pgi: LPWORD, fl: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetGlyphIndicesW*(hdc: HDC, lpstr: LPCWSTR, c: int32, pgi: LPWORD, fl: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentPointI*(hdc: HDC, pgiIn: LPWORD, cgi: int32, psize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextExtentExPointI*(hdc: HDC, lpwszString: LPWORD, cwchString: int32, nMaxExtent: int32, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharWidthI*(hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, piWidths: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetCharABCWidthsI*(hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, pabc: LPABC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AddFontResourceExA*(name: LPCSTR, fl: DWORD, res: PVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AddFontResourceExW*(name: LPCWSTR, fl: DWORD, res: PVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RemoveFontResourceExA*(name: LPCSTR, fl: DWORD, pdv: PVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RemoveFontResourceExW*(name: LPCWSTR, fl: DWORD, pdv: PVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AddFontMemResourceEx*(pFileView: PVOID, cjSize: DWORD, pvResrved: PVOID, pNumFonts: ptr DWORD): HANDLE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RemoveFontMemResourceEx*(h: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontIndirectExA*(P1: ptr ENUMLOGFONTEXDVA): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateFontIndirectExW*(P1: ptr ENUMLOGFONTEXDVW): HFONT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetViewportExtEx*(hdc: HDC, lpsize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetViewportOrgEx*(hdc: HDC, lppoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetWindowExtEx*(hdc: HDC, lpsize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetWindowOrgEx*(hdc: HDC, lppoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc IntersectClipRect*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc InvertRgn*(hdc: HDC, hrgn: HRGN): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc LineDDA*(xStart: int32, yStart: int32, xEnd: int32, yEnd: int32, lpProc: LINEDDAPROC, data: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc LineTo*(hdc: HDC, x: int32, y: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc MaskBlt*(hdcDest: HDC, xDest: int32, yDest: int32, width: int32, height: int32, hdcSrc: HDC, xSrc: int32, ySrc: int32, hbmMask: HBITMAP, xMask: int32, yMask: int32, rop: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PlgBlt*(hdcDest: HDC, lpPoint: ptr POINT, hdcSrc: HDC, xSrc: int32, ySrc: int32, width: int32, height: int32, hbmMask: HBITMAP, xMask: int32, yMask: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc OffsetClipRgn*(hdc: HDC, x: int32, y: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc OffsetRgn*(hrgn: HRGN, x: int32, y: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PatBlt*(hdc: HDC, x: int32, y: int32, w: int32, h: int32, rop: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Pie*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32, xr1: int32, yr1: int32, xr2: int32, yr2: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PlayMetaFile*(hdc: HDC, hmf: HMETAFILE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PaintRgn*(hdc: HDC, hrgn: HRGN): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyPolygon*(hdc: HDC, apt: ptr POINT, asz: ptr INT, csz: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PtInRegion*(hrgn: HRGN, x: int32, y: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PtVisible*(hdc: HDC, x: int32, y: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RectInRegion*(hrgn: HRGN, lprect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RectVisible*(hdc: HDC, lprect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Rectangle*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RestoreDC*(hdc: HDC, nSavedDC: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ResetDCA*(hdc: HDC, lpdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ResetDCW*(hdc: HDC, lpdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RealizePalette*(hdc: HDC): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RemoveFontResourceA*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RemoveFontResourceW*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc RoundRect*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32, width: int32, height: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ResizePalette*(hpal: HPALETTE, n: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SaveDC*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SelectClipRgn*(hdc: HDC, hrgn: HRGN): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtSelectClipRgn*(hdc: HDC, hrgn: HRGN, mode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetMetaRgn*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SelectObject*(hdc: HDC, h: HGDIOBJ): HGDIOBJ {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SelectPalette*(hdc: HDC, hPal: HPALETTE, bForceBkgd: WINBOOL): HPALETTE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBkColor*(hdc: HDC, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDCBrushColor*(hdc: HDC, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDCPenColor*(hdc: HDC, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBkMode*(hdc: HDC, mode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBitmapBits*(hbm: HBITMAP, cb: DWORD, pvBits: pointer): LONG {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBoundsRect*(hdc: HDC, lprect: ptr RECT, flags: UINT): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDIBits*(hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpBits: pointer, lpbmi: ptr BITMAPINFO, ColorUse: UINT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDIBitsToDevice*(hdc: HDC, xDest: int32, yDest: int32, w: DWORD, h: DWORD, xSrc: int32, ySrc: int32, StartScan: UINT, cLines: UINT, lpvBits: pointer, lpbmi: ptr BITMAPINFO, ColorUse: UINT): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetMapperFlags*(hdc: HDC, flags: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetGraphicsMode*(hdc: HDC, iMode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetMapMode*(hdc: HDC, iMode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetLayout*(hdc: HDC, l: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetLayout*(hdc: HDC): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetMetaFileBitsEx*(cbBuffer: UINT, lpData: ptr BYTE): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetPaletteEntries*(hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: ptr PALETTEENTRY): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetPixel*(hdc: HDC, x: int32, y: int32, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetPixelV*(hdc: HDC, x: int32, y: int32, color: COLORREF): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetPixelFormat*(hdc: HDC, format: int32, ppfd: ptr PIXELFORMATDESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetPolyFillMode*(hdc: HDC, mode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StretchBlt*(hdcDest: HDC, xDest: int32, yDest: int32, wDest: int32, hDest: int32, hdcSrc: HDC, xSrc: int32, ySrc: int32, wSrc: int32, hSrc: int32, rop: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetRectRgn*(hrgn: HRGN, left: int32, top: int32, right: int32, bottom: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StretchDIBits*(hdc: HDC, xDest: int32, yDest: int32, DestWidth: int32, DestHeight: int32, xSrc: int32, ySrc: int32, SrcWidth: int32, SrcHeight: int32, lpBits: pointer, lpbmi: ptr BITMAPINFO, iUsage: UINT, rop: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetROP2*(hdc: HDC, rop2: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetStretchBltMode*(hdc: HDC, mode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetSystemPaletteUse*(hdc: HDC, use: UINT): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetTextCharacterExtra*(hdc: HDC, extra: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetTextColor*(hdc: HDC, color: COLORREF): COLORREF {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetTextAlign*(hdc: HDC, align: UINT): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetTextJustification*(hdc: HDC, extra: int32, count: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc UpdateColors*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AlphaBlend*(hdcDest: HDC, xoriginDest: int32, yoriginDest: int32, wDest: int32, hDest: int32, hdcSrc: HDC, xoriginSrc: int32, yoriginSrc: int32, wSrc: int32, hSrc: int32, ftn: BLENDFUNCTION): WINBOOL {.winapi, stdcall, dynlib: "msimg32", importc.} +proc GdiAlphaBlend*(hdcDest: HDC, xoriginDest: int32, yoriginDest: int32, wDest: int32, hDest: int32, hdcSrc: HDC, xoriginSrc: int32, yoriginSrc: int32, wSrc: int32, hSrc: int32, ftn: BLENDFUNCTION): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc TransparentBlt*(hdcDest: HDC, xoriginDest: int32, yoriginDest: int32, wDest: int32, hDest: int32, hdcSrc: HDC, xoriginSrc: int32, yoriginSrc: int32, wSrc: int32, hSrc: int32, crTransparent: UINT): WINBOOL {.winapi, stdcall, dynlib: "msimg32", importc.} +proc GdiTransparentBlt*(hdcDest: HDC, xoriginDest: int32, yoriginDest: int32, wDest: int32, hDest: int32, hdcSrc: HDC, xoriginSrc: int32, yoriginSrc: int32, wSrc: int32, hSrc: int32, crTransparent: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GradientFill*(hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nMesh: ULONG, ulMode: ULONG): WINBOOL {.winapi, stdcall, dynlib: "msimg32", importc.} +proc GdiGradientFill*(hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nMesh: ULONG, ulMode: ULONG): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PlayMetaFileRecord*(hdc: HDC, lpHandleTable: LPHANDLETABLE, lpMR: LPMETARECORD, noObjs: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumMetaFile*(hdc: HDC, hmf: HMETAFILE, lpProc: MFENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CloseEnhMetaFile*(hdc: HDC): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CopyEnhMetaFileA*(hEnh: HENHMETAFILE, lpFileName: LPCSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CopyEnhMetaFileW*(hEnh: HENHMETAFILE, lpFileName: LPCWSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateEnhMetaFileA*(hdc: HDC, lpFilename: LPCSTR, lprc: ptr RECT, lpDesc: LPCSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateEnhMetaFileW*(hdc: HDC, lpFilename: LPCWSTR, lprc: ptr RECT, lpDesc: LPCWSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeleteEnhMetaFile*(hmf: HENHMETAFILE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumEnhMetaFile*(hdc: HDC, hmf: HENHMETAFILE, lpProc: ENHMFENUMPROC, lpParam: LPVOID, lpRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileA*(lpName: LPCSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileW*(lpName: LPCWSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileBits*(hEMF: HENHMETAFILE, nSize: UINT, lpData: LPBYTE): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileDescriptionA*(hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPSTR): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileDescriptionW*(hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPWSTR): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFileHeader*(hemf: HENHMETAFILE, nSize: UINT, lpEnhMetaHeader: LPENHMETAHEADER): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFilePaletteEntries*(hemf: HENHMETAFILE, nNumEntries: UINT, lpPaletteEntries: LPPALETTEENTRY): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetEnhMetaFilePixelFormat*(hemf: HENHMETAFILE, cbBuffer: UINT, ppfd: ptr PIXELFORMATDESCRIPTOR): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetWinMetaFileBits*(hemf: HENHMETAFILE, cbData16: UINT, pData16: LPBYTE, iMapMode: INT, hdcRef: HDC): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PlayEnhMetaFile*(hdc: HDC, hmf: HENHMETAFILE, lprect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PlayEnhMetaFileRecord*(hdc: HDC, pht: LPHANDLETABLE, pmr: ptr ENHMETARECORD, cht: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetEnhMetaFileBits*(nSize: UINT, pb: ptr BYTE): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetWinMetaFileBits*(nSize: UINT, lpMeta16Data: ptr BYTE, hdcRef: HDC, lpMFP: ptr METAFILEPICT): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GdiComment*(hdc: HDC, nSize: UINT, lpData: ptr BYTE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextMetricsA*(hdc: HDC, lptm: LPTEXTMETRICA): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextMetricsW*(hdc: HDC, lptm: LPTEXTMETRICW): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AngleArc*(hdc: HDC, x: int32, y: int32, r: DWORD, StartAngle: FLOAT, SweepAngle: FLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyPolyline*(hdc: HDC, apt: ptr POINT, asz: ptr DWORD, csz: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetWorldTransform*(hdc: HDC, lpxf: LPXFORM): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetWorldTransform*(hdc: HDC, lpxf: ptr XFORM): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ModifyWorldTransform*(hdc: HDC, lpxf: ptr XFORM, mode: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CombineTransform*(lpxfOut: LPXFORM, lpxf1: ptr XFORM, lpxf2: ptr XFORM): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateDIBSection*(hdc: HDC, lpbmi: ptr BITMAPINFO, usage: UINT, ppvBits: ptr pointer, hSection: HANDLE, offset: DWORD): HBITMAP {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDIBColorTable*(hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: ptr RGBQUAD): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDIBColorTable*(hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: ptr RGBQUAD): UINT {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetColorAdjustment*(hdc: HDC, lpca: ptr COLORADJUSTMENT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetColorAdjustment*(hdc: HDC, lpca: LPCOLORADJUSTMENT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateHalftonePalette*(hdc: HDC): HPALETTE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StartDocA*(hdc: HDC, lpdi: ptr DOCINFOA): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StartDocW*(hdc: HDC, lpdi: ptr DOCINFOW): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EndDoc*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StartPage*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EndPage*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AbortDoc*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetAbortProc*(hdc: HDC, lpProc: ABORTPROC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc AbortPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ArcTo*(hdc: HDC, left: int32, top: int32, right: int32, bottom: int32, xr1: int32, yr1: int32, xr2: int32, yr2: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc BeginPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CloseFigure*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EndPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FillPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FlattenPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetPath*(hdc: HDC, apt: LPPOINT, aj: LPBYTE, cpt: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PathToRegion*(hdc: HDC): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyDraw*(hdc: HDC, apt: ptr POINT, aj: ptr BYTE, cpt: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SelectClipPath*(hdc: HDC, mode: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetArcDirection*(hdc: HDC, dir: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetMiterLimit*(hdc: HDC, limit: FLOAT, old: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StrokeAndFillPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc StrokePath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc WidenPath*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtCreatePen*(iPenStyle: DWORD, cWidth: DWORD, plbrush: ptr LOGBRUSH, cStyle: DWORD, pstyle: ptr DWORD): HPEN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetMiterLimit*(hdc: HDC, plimit: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetArcDirection*(hdc: HDC): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetObjectA*(h: HANDLE, c: int32, pv: LPVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetObjectW*(h: HANDLE, c: int32, pv: LPVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc MoveToEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc TextOutA*(hdc: HDC, x: int32, y: int32, lpString: LPCSTR, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc TextOutW*(hdc: HDC, x: int32, y: int32, lpString: LPCWSTR, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtTextOutA*(hdc: HDC, x: int32, y: int32, options: UINT, lprect: ptr RECT, lpString: LPCSTR, c: UINT, lpDx: ptr INT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ExtTextOutW*(hdc: HDC, x: int32, y: int32, options: UINT, lprect: ptr RECT, lpString: LPCWSTR, c: UINT, lpDx: ptr INT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyTextOutA*(hdc: HDC, ppt: ptr POLYTEXTA, nstrings: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyTextOutW*(hdc: HDC, ppt: ptr POLYTEXTW, nstrings: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreatePolygonRgn*(pptl: ptr POINT, cPoint: int32, iMode: int32): HRGN {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DPtoLP*(hdc: HDC, lppt: LPPOINT, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc LPtoDP*(hdc: HDC, lppt: LPPOINT, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Polygon*(hdc: HDC, apt: ptr POINT, cpt: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc Polyline*(hdc: HDC, apt: ptr POINT, cpt: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyBezier*(hdc: HDC, apt: ptr POINT, cpt: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolyBezierTo*(hdc: HDC, apt: ptr POINT, cpt: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc PolylineTo*(hdc: HDC, apt: ptr POINT, cpt: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetViewportExtEx*(hdc: HDC, x: int32, y: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetViewportOrgEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetWindowExtEx*(hdc: HDC, x: int32, y: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetWindowOrgEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc OffsetViewportOrgEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc OffsetWindowOrgEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ScaleViewportExtEx*(hdc: HDC, xn: int32, dx: int32, yn: int32, yd: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ScaleWindowExtEx*(hdc: HDC, xn: int32, xd: int32, yn: int32, yd: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBitmapDimensionEx*(hbm: HBITMAP, w: int32, h: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetBrushOrgEx*(hdc: HDC, x: int32, y: int32, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextFaceA*(hdc: HDC, c: int32, lpName: LPSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetTextFaceW*(hdc: HDC, c: int32, lpName: LPWSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetKerningPairsA*(hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetKerningPairsW*(hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDCOrgEx*(hdc: HDC, lppt: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc FixBrushOrgEx*(hdc: HDC, x: int32, y: int32, ptl: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc UnrealizeObject*(h: HGDIOBJ): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GdiFlush*(): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GdiSetBatchLimit*(dw: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GdiGetBatchLimit*(): DWORD {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetICMMode*(hdc: HDC, mode: int32): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CheckColorsInGamut*(hdc: HDC, lpRGBTriple: LPVOID, dlpBuffer: LPVOID, nCount: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetColorSpace*(hdc: HDC): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetLogColorSpaceA*(hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEA, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetLogColorSpaceW*(hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEW, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateColorSpaceA*(lplcs: LPLOGCOLORSPACEA): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc CreateColorSpaceW*(lplcs: LPLOGCOLORSPACEW): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetColorSpace*(hdc: HDC, hcs: HCOLORSPACE): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc.} +proc DeleteColorSpace*(hcs: HCOLORSPACE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetICMProfileA*(hdc: HDC, pBufSize: LPDWORD, pszFilename: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetICMProfileW*(hdc: HDC, pBufSize: LPDWORD, pszFilename: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetICMProfileA*(hdc: HDC, lpFileName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetICMProfileW*(hdc: HDC, lpFileName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc GetDeviceGammaRamp*(hdc: HDC, lpRamp: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc SetDeviceGammaRamp*(hdc: HDC, lpRamp: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ColorMatchToTarget*(hdc: HDC, hdcTarget: HDC, action: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumICMProfilesA*(hdc: HDC, lpProc: ICMENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc EnumICMProfilesW*(hdc: HDC, lpProc: ICMENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc.} +proc UpdateICMRegKeyA*(reserved: DWORD, lpszCMID: LPSTR, lpszFileName: LPSTR, command: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc UpdateICMRegKeyW*(reserved: DWORD, lpszCMID: LPWSTR, lpszFileName: LPWSTR, command: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc ColorCorrectPalette*(hdc: HDC, hPal: HPALETTE, deFirst: DWORD, num: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc wglCopyContext*(P1: HGLRC, P2: HGLRC, P3: UINT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglCreateContext*(P1: HDC): HGLRC {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglCreateLayerContext*(P1: HDC, P2: int32): HGLRC {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglDeleteContext*(P1: HGLRC): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglGetCurrentContext*(): HGLRC {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglGetCurrentDC*(): HDC {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglGetProcAddress*(P1: LPCSTR): PROC {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglMakeCurrent*(P1: HDC, P2: HGLRC): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglShareLists*(P1: HGLRC, P2: HGLRC): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglUseFontBitmapsA*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglUseFontBitmapsW*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc SwapBuffers*(P1: HDC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc.} +proc wglUseFontOutlinesA*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD, P5: FLOAT, P6: FLOAT, P7: int32, P8: LPGLYPHMETRICSFLOAT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglUseFontOutlinesW*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD, P5: FLOAT, P6: FLOAT, P7: int32, P8: LPGLYPHMETRICSFLOAT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglDescribeLayerPlane*(P1: HDC, P2: int32, P3: int32, P4: UINT, P5: LPLAYERPLANEDESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglSetLayerPaletteEntries*(P1: HDC, P2: int32, P3: int32, P4: int32, P5: ptr COLORREF): int32 {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglGetLayerPaletteEntries*(P1: HDC, P2: int32, P3: int32, P4: int32, P5: ptr COLORREF): int32 {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglRealizeLayerPalette*(P1: HDC, P2: int32, P3: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglSwapLayerBuffers*(P1: HDC, P2: UINT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc.} +proc wglSwapMultipleBuffers*(P1: UINT, P2: ptr WGLSWAP): DWORD {.winapi, stdcall, dynlib: "opengl32", importc.} +template MAKEROP4*(fore: untyped, back: untyped): DWORD = DWORD((back shl 8) and 0xff000000) or DWORD(fore) +template GetCValue*(cmyk: untyped): BYTE = BYTE((cmyk shr 24) and 0xff) +template GetMValue*(cmyk: untyped): BYTE = BYTE((cmyk shr 16) and 0xff) +template GetYValue*(cmyk: untyped): BYTE = BYTE((cmyk shr 8) and 0xff) +template GetKValue*(cmyk: untyped): BYTE = BYTE((cmyk) and 0xff) +template CMYK*(c: untyped, m: untyped, y: untyped, k: untyped): COLORREF = COLORREF(COLORREF(k) or COLORREF(y shl 8) or COLORREF(m shl 16) or COLORREF(c shl 24)) +template MAKEPOINTS*(l: untyped): POINTS = POINTS(x: SHORT(l and 0xffff), y: SHORT(l shr 16 and 0xffff)) +template RGB*(r: untyped, g: untyped, b: untyped): COLORREF = COLORREF(COLORREF(r and 0xff) or (COLORREF(g and 0xff) shl 8) or (COLORREF(b and 0xff) shl 16)) +template PALETTERGB*(r: untyped, g: untyped, b: untyped): COLORREF = COLORREF(RGB(r, g, b) or 0x02000000) +template GetRValue*(c: untyped): BYTE = BYTE((c) and 0xff) +template GetGValue*(c: untyped): BYTE = BYTE((c shr 8) and 0xff) +template GetBValue*(c: untyped): BYTE = BYTE((c shr 16) and 0xff) +template PALETTEINDEX*(i: untyped): COLORREF = COLORREF(i and 0xff) or 0x01000000 +proc `dmOrientation=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmOrientation = x +proc dmOrientation*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmOrientation +proc dmOrientation*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmOrientation +proc `dmPaperSize=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmPaperSize = x +proc dmPaperSize*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmPaperSize +proc dmPaperSize*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmPaperSize +proc `dmPaperLength=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmPaperLength = x +proc dmPaperLength*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmPaperLength +proc dmPaperLength*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmPaperLength +proc `dmPaperWidth=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmPaperWidth = x +proc dmPaperWidth*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmPaperWidth +proc dmPaperWidth*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmPaperWidth +proc `dmScale=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmScale = x +proc dmScale*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmScale +proc dmScale*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmScale +proc `dmCopies=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmCopies = x +proc dmCopies*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmCopies +proc dmCopies*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmCopies +proc `dmDefaultSource=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmDefaultSource = x +proc dmDefaultSource*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmDefaultSource +proc dmDefaultSource*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmDefaultSource +proc `dmPrintQuality=`*(self: var DEVMODEA, x: int16) {.inline.} = self.union1.struct1.dmPrintQuality = x +proc dmPrintQuality*(self: DEVMODEA): int16 {.inline.} = self.union1.struct1.dmPrintQuality +proc dmPrintQuality*(self: var DEVMODEA): var int16 {.inline.} = self.union1.struct1.dmPrintQuality +proc `dmPosition=`*(self: var DEVMODEA, x: POINTL) {.inline.} = self.union1.struct2.dmPosition = x +proc dmPosition*(self: DEVMODEA): POINTL {.inline.} = self.union1.struct2.dmPosition +proc dmPosition*(self: var DEVMODEA): var POINTL {.inline.} = self.union1.struct2.dmPosition +proc `dmDisplayOrientation=`*(self: var DEVMODEA, x: DWORD) {.inline.} = self.union1.struct2.dmDisplayOrientation = x +proc dmDisplayOrientation*(self: DEVMODEA): DWORD {.inline.} = self.union1.struct2.dmDisplayOrientation +proc dmDisplayOrientation*(self: var DEVMODEA): var DWORD {.inline.} = self.union1.struct2.dmDisplayOrientation +proc `dmDisplayFixedOutput=`*(self: var DEVMODEA, x: DWORD) {.inline.} = self.union1.struct2.dmDisplayFixedOutput = x +proc dmDisplayFixedOutput*(self: DEVMODEA): DWORD {.inline.} = self.union1.struct2.dmDisplayFixedOutput +proc dmDisplayFixedOutput*(self: var DEVMODEA): var DWORD {.inline.} = self.union1.struct2.dmDisplayFixedOutput +proc `dmDisplayFlags=`*(self: var DEVMODEA, x: DWORD) {.inline.} = self.union2.dmDisplayFlags = x +proc dmDisplayFlags*(self: DEVMODEA): DWORD {.inline.} = self.union2.dmDisplayFlags +proc dmDisplayFlags*(self: var DEVMODEA): var DWORD {.inline.} = self.union2.dmDisplayFlags +proc `dmNup=`*(self: var DEVMODEA, x: DWORD) {.inline.} = self.union2.dmNup = x +proc dmNup*(self: DEVMODEA): DWORD {.inline.} = self.union2.dmNup +proc dmNup*(self: var DEVMODEA): var DWORD {.inline.} = self.union2.dmNup +proc `dmOrientation=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmOrientation = x +proc dmOrientation*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmOrientation +proc dmOrientation*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmOrientation +proc `dmPaperSize=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmPaperSize = x +proc dmPaperSize*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmPaperSize +proc dmPaperSize*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmPaperSize +proc `dmPaperLength=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmPaperLength = x +proc dmPaperLength*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmPaperLength +proc dmPaperLength*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmPaperLength +proc `dmPaperWidth=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmPaperWidth = x +proc dmPaperWidth*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmPaperWidth +proc dmPaperWidth*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmPaperWidth +proc `dmScale=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmScale = x +proc dmScale*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmScale +proc dmScale*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmScale +proc `dmCopies=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmCopies = x +proc dmCopies*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmCopies +proc dmCopies*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmCopies +proc `dmDefaultSource=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmDefaultSource = x +proc dmDefaultSource*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmDefaultSource +proc dmDefaultSource*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmDefaultSource +proc `dmPrintQuality=`*(self: var DEVMODEW, x: int16) {.inline.} = self.union1.struct1.dmPrintQuality = x +proc dmPrintQuality*(self: DEVMODEW): int16 {.inline.} = self.union1.struct1.dmPrintQuality +proc dmPrintQuality*(self: var DEVMODEW): var int16 {.inline.} = self.union1.struct1.dmPrintQuality +proc `dmPosition=`*(self: var DEVMODEW, x: POINTL) {.inline.} = self.union1.struct2.dmPosition = x +proc dmPosition*(self: DEVMODEW): POINTL {.inline.} = self.union1.struct2.dmPosition +proc dmPosition*(self: var DEVMODEW): var POINTL {.inline.} = self.union1.struct2.dmPosition +proc `dmDisplayOrientation=`*(self: var DEVMODEW, x: DWORD) {.inline.} = self.union1.struct2.dmDisplayOrientation = x +proc dmDisplayOrientation*(self: DEVMODEW): DWORD {.inline.} = self.union1.struct2.dmDisplayOrientation +proc dmDisplayOrientation*(self: var DEVMODEW): var DWORD {.inline.} = self.union1.struct2.dmDisplayOrientation +proc `dmDisplayFixedOutput=`*(self: var DEVMODEW, x: DWORD) {.inline.} = self.union1.struct2.dmDisplayFixedOutput = x +proc dmDisplayFixedOutput*(self: DEVMODEW): DWORD {.inline.} = self.union1.struct2.dmDisplayFixedOutput +proc dmDisplayFixedOutput*(self: var DEVMODEW): var DWORD {.inline.} = self.union1.struct2.dmDisplayFixedOutput +proc `dmDisplayFlags=`*(self: var DEVMODEW, x: DWORD) {.inline.} = self.union2.dmDisplayFlags = x +proc dmDisplayFlags*(self: DEVMODEW): DWORD {.inline.} = self.union2.dmDisplayFlags +proc dmDisplayFlags*(self: var DEVMODEW): var DWORD {.inline.} = self.union2.dmDisplayFlags +proc `dmNup=`*(self: var DEVMODEW, x: DWORD) {.inline.} = self.union2.dmNup = x +proc dmNup*(self: DEVMODEW): DWORD {.inline.} = self.union2.dmNup +proc dmNup*(self: var DEVMODEW): var DWORD {.inline.} = self.union2.dmNup +proc `targetMode=`*(self: var DISPLAYCONFIG_MODE_INFO, x: DISPLAYCONFIG_TARGET_MODE) {.inline.} = self.union1.targetMode = x +proc targetMode*(self: DISPLAYCONFIG_MODE_INFO): DISPLAYCONFIG_TARGET_MODE {.inline.} = self.union1.targetMode +proc targetMode*(self: var DISPLAYCONFIG_MODE_INFO): var DISPLAYCONFIG_TARGET_MODE {.inline.} = self.union1.targetMode +proc `sourceMode=`*(self: var DISPLAYCONFIG_MODE_INFO, x: DISPLAYCONFIG_SOURCE_MODE) {.inline.} = self.union1.sourceMode = x +proc sourceMode*(self: DISPLAYCONFIG_MODE_INFO): DISPLAYCONFIG_SOURCE_MODE {.inline.} = self.union1.sourceMode +proc sourceMode*(self: var DISPLAYCONFIG_MODE_INFO): var DISPLAYCONFIG_SOURCE_MODE {.inline.} = self.union1.sourceMode +proc `friendlyNameFromEdid=`*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, x: UINT32) {.inline.} = self.union1.struct1.friendlyNameFromEdid = x +proc friendlyNameFromEdid*(self: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): UINT32 {.inline.} = self.union1.struct1.friendlyNameFromEdid +proc `friendlyNameForced=`*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, x: UINT32) {.inline.} = self.union1.struct1.friendlyNameForced = x +proc friendlyNameForced*(self: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): UINT32 {.inline.} = self.union1.struct1.friendlyNameForced +proc `edidIdsValid=`*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, x: UINT32) {.inline.} = self.union1.struct1.edidIdsValid = x +proc edidIdsValid*(self: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): UINT32 {.inline.} = self.union1.struct1.edidIdsValid +proc `reserved=`*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, x: UINT32) {.inline.} = self.union1.struct1.reserved = x +proc reserved*(self: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): UINT32 {.inline.} = self.union1.struct1.reserved +proc `value=`*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, x: UINT32) {.inline.} = self.union1.value = x +proc value*(self: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): UINT32 {.inline.} = self.union1.value +proc value*(self: var DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS): var UINT32 {.inline.} = self.union1.value +proc `bootPersistenceOn=`*(self: var DISPLAYCONFIG_SET_TARGET_PERSISTENCE, x: UINT32) {.inline.} = self.union1.struct1.bootPersistenceOn = x +proc bootPersistenceOn*(self: DISPLAYCONFIG_SET_TARGET_PERSISTENCE): UINT32 {.inline.} = self.union1.struct1.bootPersistenceOn +proc `reserved=`*(self: var DISPLAYCONFIG_SET_TARGET_PERSISTENCE, x: UINT32) {.inline.} = self.union1.struct1.reserved = x +proc reserved*(self: DISPLAYCONFIG_SET_TARGET_PERSISTENCE): UINT32 {.inline.} = self.union1.struct1.reserved +proc `value=`*(self: var DISPLAYCONFIG_SET_TARGET_PERSISTENCE, x: UINT32) {.inline.} = self.union1.value = x +proc value*(self: DISPLAYCONFIG_SET_TARGET_PERSISTENCE): UINT32 {.inline.} = self.union1.value +proc value*(self: var DISPLAYCONFIG_SET_TARGET_PERSISTENCE): var UINT32 {.inline.} = self.union1.value +when winimUnicode: + type + LOGCOLORSPACE* = LOGCOLORSPACEW + LPLOGCOLORSPACE* = LPLOGCOLORSPACEW + TEXTMETRIC* = TEXTMETRICW + PTEXTMETRIC* = PTEXTMETRICW + NPTEXTMETRIC* = NPTEXTMETRICW + LPTEXTMETRIC* = LPTEXTMETRICW + NEWTEXTMETRIC* = NEWTEXTMETRICW + PNEWTEXTMETRIC* = PNEWTEXTMETRICW + NPNEWTEXTMETRIC* = NPNEWTEXTMETRICW + LPNEWTEXTMETRIC* = LPNEWTEXTMETRICW + NEWTEXTMETRICEX* = NEWTEXTMETRICEXW + LOGFONT* = LOGFONTW + PLOGFONT* = PLOGFONTW + NPLOGFONT* = NPLOGFONTW + LPLOGFONT* = LPLOGFONTW + ENUMLOGFONT* = ENUMLOGFONTW + LPENUMLOGFONT* = LPENUMLOGFONTW + ENUMLOGFONTEX* = ENUMLOGFONTEXW + LPENUMLOGFONTEX* = LPENUMLOGFONTEXW + EXTLOGFONT* = EXTLOGFONTW + PEXTLOGFONT* = PEXTLOGFONTW + NPEXTLOGFONT* = NPEXTLOGFONTW + LPEXTLOGFONT* = LPEXTLOGFONTW + DEVMODE* = DEVMODEW + PDEVMODE* = PDEVMODEW + NPDEVMODE* = NPDEVMODEW + DISPLAY_DEVICE* = DISPLAY_DEVICEW + PDISPLAY_DEVICE* = PDISPLAY_DEVICEW + LPDISPLAY_DEVICE* = LPDISPLAY_DEVICEW + OUTLINETEXTMETRIC* = OUTLINETEXTMETRICW + POUTLINETEXTMETRIC* = POUTLINETEXTMETRICW + NPOUTLINETEXTMETRIC* = NPOUTLINETEXTMETRICW + LPOUTLINETEXTMETRIC* = LPOUTLINETEXTMETRICW + POLYTEXT* = POLYTEXTW + PPOLYTEXT* = PPOLYTEXTW + NPPOLYTEXT* = NPPOLYTEXTW + LPPOLYTEXT* = LPPOLYTEXTW + GCP_RESULTS* = GCP_RESULTSW + LPGCP_RESULTS* = LPGCP_RESULTSW + OLDFONTENUMPROC* = OLDFONTENUMPROCW + FONTENUMPROC* = FONTENUMPROCW + AXISINFO* = AXISINFOW + PAXISINFO* = PAXISINFOW + LPAXISINFO* = LPAXISINFOW + AXESLIST* = AXESLISTW + PAXESLIST* = PAXESLISTW + LPAXESLIST* = LPAXESLISTW + ENUMLOGFONTEXDV* = ENUMLOGFONTEXDVW + PENUMLOGFONTEXDV* = PENUMLOGFONTEXDVW + LPENUMLOGFONTEXDV* = LPENUMLOGFONTEXDVW + ENUMTEXTMETRIC* = ENUMTEXTMETRICW + PENUMTEXTMETRIC* = PENUMTEXTMETRICW + LPENUMTEXTMETRIC* = LPENUMTEXTMETRICW + DOCINFO* = DOCINFOW + LPDOCINFO* = LPDOCINFOW + ICMENUMPROC* = ICMENUMPROCW + proc AddFontResource*(P1: LPCWSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "AddFontResourceW".} + proc CopyMetaFile*(P1: HMETAFILE, P2: LPCWSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "CopyMetaFileW".} + proc CreateDC*(pwszDriver: LPCWSTR, pwszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateDCW".} + proc CreateFontIndirect*(lplf: ptr LOGFONTW): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontIndirectW".} + proc CreateFont*(cHeight: int32, cWidth: int32, cEscapement: int32, cOrientation: int32, cWeight: int32, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCWSTR): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontW".} + proc CreateIC*(pszDriver: LPCWSTR, pszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateICW".} + proc CreateMetaFile*(pszFile: LPCWSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateMetaFileW".} + proc CreateScalableFontResource*(fdwHidden: DWORD, lpszFont: LPCWSTR, lpszFile: LPCWSTR, lpszPath: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "CreateScalableFontResourceW".} + proc DeviceCapabilities*(pDevice: LPCWSTR, pPort: LPCWSTR, fwCapability: WORD, pOutput: LPWSTR, pDevMode: ptr DEVMODEW): int32 {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeviceCapabilitiesW".} + proc EnumFontFamiliesEx*(hdc: HDC, lpLogfont: LPLOGFONTW, lpProc: FONTENUMPROCW, lParam: LPARAM, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontFamiliesExW".} + proc EnumFontFamilies*(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontFamiliesW".} + proc EnumFonts*(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontsW".} + proc GetCharWidth*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidthW".} + proc GetCharWidth32*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidth32W".} + proc GetCharWidthFloat*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatW".} + proc GetCharABCWidths*(hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsW".} + proc GetCharABCWidthsFloat*(hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsFloatW".} + proc GetGlyphOutline*(hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: ptr MAT2): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetGlyphOutlineW".} + proc GetMetaFile*(lpName: LPCWSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "GetMetaFileW".} + proc GetOutlineTextMetrics*(hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICW): UINT {.winapi, stdcall, dynlib: "gdi32", importc: "GetOutlineTextMetricsW".} + proc GetTextExtentPoint*(hdc: HDC, lpString: LPCWSTR, c: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentPointW".} + proc GetTextExtentPoint32*(hdc: HDC, lpString: LPCWSTR, c: int32, psizl: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentPoint32W".} + proc GetTextExtentExPoint*(hdc: HDC, lpszString: LPCWSTR, cchString: int32, nMaxExtent: int32, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentExPointW".} + proc GetCharacterPlacement*(hdc: HDC, lpString: LPCWSTR, nCount: int32, nMexExtent: int32, lpResults: LPGCP_RESULTSW, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementW".} + proc GetGlyphIndices*(hdc: HDC, lpstr: LPCWSTR, c: int32, pgi: LPWORD, fl: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetGlyphIndicesW".} + proc AddFontResourceEx*(name: LPCWSTR, fl: DWORD, res: PVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "AddFontResourceExW".} + proc RemoveFontResourceEx*(name: LPCWSTR, fl: DWORD, pdv: PVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "RemoveFontResourceExW".} + proc CreateFontIndirectEx*(P1: ptr ENUMLOGFONTEXDVW): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontIndirectExW".} + proc ResetDC*(hdc: HDC, lpdm: ptr DEVMODEW): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "ResetDCW".} + proc RemoveFontResource*(lpFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "RemoveFontResourceW".} + proc CopyEnhMetaFile*(hEnh: HENHMETAFILE, lpFileName: LPCWSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileW".} + proc CreateEnhMetaFile*(hdc: HDC, lpFilename: LPCWSTR, lprc: ptr RECT, lpDesc: LPCWSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateEnhMetaFileW".} + proc GetEnhMetaFile*(lpName: LPCWSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileW".} + proc GetEnhMetaFileDescription*(hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPWSTR): UINT {.winapi, stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionW".} + proc GetTextMetrics*(hdc: HDC, lptm: LPTEXTMETRICW): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextMetricsW".} + proc StartDoc*(hdc: HDC, lpdi: ptr DOCINFOW): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "StartDocW".} + proc GetObject*(h: HANDLE, c: int32, pv: LPVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "GetObjectW".} + proc TextOut*(hdc: HDC, x: int32, y: int32, lpString: LPCWSTR, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "TextOutW".} + proc ExtTextOut*(hdc: HDC, x: int32, y: int32, options: UINT, lprect: ptr RECT, lpString: LPCWSTR, c: UINT, lpDx: ptr INT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "ExtTextOutW".} + proc PolyTextOut*(hdc: HDC, ppt: ptr POLYTEXTW, nstrings: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "PolyTextOutW".} + proc GetTextFace*(hdc: HDC, c: int32, lpName: LPWSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextFaceW".} + proc GetKerningPairs*(hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetKerningPairsW".} + proc EnumICMProfiles*(hdc: HDC, lpProc: ICMENUMPROCW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumICMProfilesW".} + proc UpdateICMRegKey*(reserved: DWORD, lpszCMID: LPWSTR, lpszFileName: LPWSTR, command: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyW".} + proc GetLogColorSpace*(hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEW, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetLogColorSpaceW".} + proc CreateColorSpace*(lplcs: LPLOGCOLORSPACEW): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc: "CreateColorSpaceW".} + proc GetICMProfile*(hdc: HDC, pBufSize: LPDWORD, pszFilename: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetICMProfileW".} + proc SetICMProfile*(hdc: HDC, lpFileName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "SetICMProfileW".} + proc wglUseFontBitmaps*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc: "wglUseFontBitmapsW".} + proc wglUseFontOutlines*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD, P5: FLOAT, P6: FLOAT, P7: int32, P8: LPGLYPHMETRICSFLOAT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc: "wglUseFontOutlinesW".} +when winimAnsi: + type + LOGCOLORSPACE* = LOGCOLORSPACEA + LPLOGCOLORSPACE* = LPLOGCOLORSPACEA + TEXTMETRIC* = TEXTMETRICA + PTEXTMETRIC* = PTEXTMETRICA + NPTEXTMETRIC* = NPTEXTMETRICA + LPTEXTMETRIC* = LPTEXTMETRICA + NEWTEXTMETRIC* = NEWTEXTMETRICA + PNEWTEXTMETRIC* = PNEWTEXTMETRICA + NPNEWTEXTMETRIC* = NPNEWTEXTMETRICA + LPNEWTEXTMETRIC* = LPNEWTEXTMETRICA + NEWTEXTMETRICEX* = NEWTEXTMETRICEXA + LOGFONT* = LOGFONTA + PLOGFONT* = PLOGFONTA + NPLOGFONT* = NPLOGFONTA + LPLOGFONT* = LPLOGFONTA + ENUMLOGFONT* = ENUMLOGFONTA + LPENUMLOGFONT* = LPENUMLOGFONTA + ENUMLOGFONTEX* = ENUMLOGFONTEXA + LPENUMLOGFONTEX* = LPENUMLOGFONTEXA + EXTLOGFONT* = EXTLOGFONTA + PEXTLOGFONT* = PEXTLOGFONTA + NPEXTLOGFONT* = NPEXTLOGFONTA + LPEXTLOGFONT* = LPEXTLOGFONTA + DEVMODE* = DEVMODEA + PDEVMODE* = PDEVMODEA + NPDEVMODE* = NPDEVMODEA + DISPLAY_DEVICE* = DISPLAY_DEVICEA + PDISPLAY_DEVICE* = PDISPLAY_DEVICEA + LPDISPLAY_DEVICE* = LPDISPLAY_DEVICEA + OUTLINETEXTMETRIC* = OUTLINETEXTMETRICA + POUTLINETEXTMETRIC* = POUTLINETEXTMETRICA + NPOUTLINETEXTMETRIC* = NPOUTLINETEXTMETRICA + LPOUTLINETEXTMETRIC* = LPOUTLINETEXTMETRICA + POLYTEXT* = POLYTEXTA + PPOLYTEXT* = PPOLYTEXTA + NPPOLYTEXT* = NPPOLYTEXTA + LPPOLYTEXT* = LPPOLYTEXTA + GCP_RESULTS* = GCP_RESULTSA + LPGCP_RESULTS* = LPGCP_RESULTSA + OLDFONTENUMPROC* = OLDFONTENUMPROCA + FONTENUMPROC* = FONTENUMPROCA + AXISINFO* = AXISINFOA + PAXISINFO* = PAXISINFOA + LPAXISINFO* = LPAXISINFOA + AXESLIST* = AXESLISTA + PAXESLIST* = PAXESLISTA + LPAXESLIST* = LPAXESLISTA + ENUMLOGFONTEXDV* = ENUMLOGFONTEXDVA + PENUMLOGFONTEXDV* = PENUMLOGFONTEXDVA + LPENUMLOGFONTEXDV* = LPENUMLOGFONTEXDVA + ENUMTEXTMETRIC* = ENUMTEXTMETRICA + PENUMTEXTMETRIC* = PENUMTEXTMETRICA + LPENUMTEXTMETRIC* = LPENUMTEXTMETRICA + DOCINFO* = DOCINFOA + LPDOCINFO* = LPDOCINFOA + ICMENUMPROC* = ICMENUMPROCA + proc AddFontResource*(P1: LPCSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "AddFontResourceA".} + proc CopyMetaFile*(P1: HMETAFILE, P2: LPCSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "CopyMetaFileA".} + proc CreateDC*(pwszDriver: LPCSTR, pwszDevice: LPCSTR, pszPort: LPCSTR, pdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateDCA".} + proc CreateFontIndirect*(lplf: ptr LOGFONTA): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontIndirectA".} + proc CreateFont*(cHeight: int32, cWidth: int32, cEscapement: int32, cOrientation: int32, cWeight: int32, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCSTR): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontA".} + proc CreateIC*(pszDriver: LPCSTR, pszDevice: LPCSTR, pszPort: LPCSTR, pdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateICA".} + proc CreateMetaFile*(pszFile: LPCSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateMetaFileA".} + proc CreateScalableFontResource*(fdwHidden: DWORD, lpszFont: LPCSTR, lpszFile: LPCSTR, lpszPath: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "CreateScalableFontResourceA".} + proc DeviceCapabilities*(pDevice: LPCSTR, pPort: LPCSTR, fwCapability: WORD, pOutput: LPSTR, pDevMode: ptr DEVMODEA): int32 {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeviceCapabilitiesA".} + proc EnumFontFamiliesEx*(hdc: HDC, lpLogfont: LPLOGFONTA, lpProc: FONTENUMPROCA, lParam: LPARAM, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontFamiliesExA".} + proc EnumFontFamilies*(hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontFamiliesA".} + proc EnumFonts*(hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumFontsA".} + proc GetCharWidth*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidthA".} + proc GetCharWidth32*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidth32A".} + proc GetCharWidthFloat*(hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatA".} + proc GetCharABCWidths*(hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsA".} + proc GetCharABCWidthsFloat*(hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsFloatA".} + proc GetGlyphOutline*(hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: ptr MAT2): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetGlyphOutlineA".} + proc GetMetaFile*(lpName: LPCSTR): HMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "GetMetaFileA".} + proc GetOutlineTextMetrics*(hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICA): UINT {.winapi, stdcall, dynlib: "gdi32", importc: "GetOutlineTextMetricsA".} + proc GetTextExtentPoint*(hdc: HDC, lpString: LPCSTR, c: int32, lpsz: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentPointA".} + proc GetTextExtentPoint32*(hdc: HDC, lpString: LPCSTR, c: int32, psizl: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentPoint32A".} + proc GetTextExtentExPoint*(hdc: HDC, lpszString: LPCSTR, cchString: int32, nMaxExtent: int32, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextExtentExPointA".} + proc GetCharacterPlacement*(hdc: HDC, lpString: LPCSTR, nCount: int32, nMexExtent: int32, lpResults: LPGCP_RESULTSA, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementA".} + proc GetGlyphIndices*(hdc: HDC, lpstr: LPCSTR, c: int32, pgi: LPWORD, fl: DWORD): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetGlyphIndicesA".} + proc AddFontResourceEx*(name: LPCSTR, fl: DWORD, res: PVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "AddFontResourceExA".} + proc RemoveFontResourceEx*(name: LPCSTR, fl: DWORD, pdv: PVOID): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "RemoveFontResourceExA".} + proc CreateFontIndirectEx*(P1: ptr ENUMLOGFONTEXDVA): HFONT {.winapi, stdcall, dynlib: "gdi32", importc: "CreateFontIndirectExA".} + proc ResetDC*(hdc: HDC, lpdm: ptr DEVMODEA): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "ResetDCA".} + proc RemoveFontResource*(lpFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "RemoveFontResourceA".} + proc CopyEnhMetaFile*(hEnh: HENHMETAFILE, lpFileName: LPCSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileA".} + proc CreateEnhMetaFile*(hdc: HDC, lpFilename: LPCSTR, lprc: ptr RECT, lpDesc: LPCSTR): HDC {.winapi, stdcall, dynlib: "gdi32", importc: "CreateEnhMetaFileA".} + proc GetEnhMetaFile*(lpName: LPCSTR): HENHMETAFILE {.winapi, stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileA".} + proc GetEnhMetaFileDescription*(hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPSTR): UINT {.winapi, stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionA".} + proc GetTextMetrics*(hdc: HDC, lptm: LPTEXTMETRICA): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextMetricsA".} + proc StartDoc*(hdc: HDC, lpdi: ptr DOCINFOA): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "StartDocA".} + proc GetObject*(h: HANDLE, c: int32, pv: LPVOID): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "GetObjectA".} + proc TextOut*(hdc: HDC, x: int32, y: int32, lpString: LPCSTR, c: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "TextOutA".} + proc ExtTextOut*(hdc: HDC, x: int32, y: int32, options: UINT, lprect: ptr RECT, lpString: LPCSTR, c: UINT, lpDx: ptr INT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "ExtTextOutA".} + proc PolyTextOut*(hdc: HDC, ppt: ptr POLYTEXTA, nstrings: int32): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "PolyTextOutA".} + proc GetTextFace*(hdc: HDC, c: int32, lpName: LPSTR): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "GetTextFaceA".} + proc GetKerningPairs*(hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR): DWORD {.winapi, stdcall, dynlib: "gdi32", importc: "GetKerningPairsA".} + proc EnumICMProfiles*(hdc: HDC, lpProc: ICMENUMPROCA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "gdi32", importc: "EnumICMProfilesA".} + proc UpdateICMRegKey*(reserved: DWORD, lpszCMID: LPSTR, lpszFileName: LPSTR, command: UINT): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyA".} + proc GetLogColorSpace*(hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEA, nSize: DWORD): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetLogColorSpaceA".} + proc CreateColorSpace*(lplcs: LPLOGCOLORSPACEA): HCOLORSPACE {.winapi, stdcall, dynlib: "gdi32", importc: "CreateColorSpaceA".} + proc GetICMProfile*(hdc: HDC, pBufSize: LPDWORD, pszFilename: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "GetICMProfileA".} + proc SetICMProfile*(hdc: HDC, lpFileName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "gdi32", importc: "SetICMProfileA".} + proc wglUseFontBitmaps*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc: "wglUseFontBitmapsA".} + proc wglUseFontOutlines*(P1: HDC, P2: DWORD, P3: DWORD, P4: DWORD, P5: FLOAT, P6: FLOAT, P7: int32, P8: LPGLYPHMETRICSFLOAT): WINBOOL {.winapi, stdcall, dynlib: "opengl32", importc: "wglUseFontOutlinesA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winhttp.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winhttp.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,491 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winsock +import winbase +#include +type + INTERNET_SCHEME* = int32 + LPINTERNET_SCHEME* = ptr int32 + INTERNET_PORT* = WORD + HINTERNET* = LPVOID + LPHINTERNET* = ptr HINTERNET + LPINTERNET_PORT* = ptr INTERNET_PORT + URL_COMPONENTS* {.pure.} = object + dwStructSize*: DWORD + lpszScheme*: LPWSTR + dwSchemeLength*: DWORD + nScheme*: INTERNET_SCHEME + lpszHostName*: LPWSTR + dwHostNameLength*: DWORD + nPort*: INTERNET_PORT + lpszUserName*: LPWSTR + dwUserNameLength*: DWORD + lpszPassword*: LPWSTR + dwPasswordLength*: DWORD + lpszUrlPath*: LPWSTR + dwUrlPathLength*: DWORD + lpszExtraInfo*: LPWSTR + dwExtraInfoLength*: DWORD + LPURL_COMPONENTS* = ptr URL_COMPONENTS + URL_COMPONENTSW* = URL_COMPONENTS + LPURL_COMPONENTSW* = LPURL_COMPONENTS + WINHTTP_ASYNC_RESULT* {.pure.} = object + dwResult*: DWORD_PTR + dwError*: DWORD + LPWINHTTP_ASYNC_RESULT* = ptr WINHTTP_ASYNC_RESULT + WINHTTP_PROXY_INFO* {.pure.} = object + dwAccessType*: DWORD + lpszProxy*: LPWSTR + lpszProxyBypass*: LPWSTR + LPWINHTTP_PROXY_INFO* = ptr WINHTTP_PROXY_INFO + WINHTTP_PROXY_INFOW* = WINHTTP_PROXY_INFO + LPWINHTTP_PROXY_INFOW* = LPWINHTTP_PROXY_INFO + HTTP_VERSION_INFO* {.pure.} = object + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + LPHTTP_VERSION_INFO* = ptr HTTP_VERSION_INFO +const + INTERNET_DEFAULT_PORT* = 0 + INTERNET_DEFAULT_HTTP_PORT* = 80 + INTERNET_DEFAULT_HTTPS_PORT* = 443 + INTERNET_SCHEME_HTTP* = 1 + INTERNET_SCHEME_HTTPS* = 2 + ICU_ESCAPE* = 0x80000000'i32 + WINHTTP_FLAG_ASYNC* = 0x10000000 + WINHTTP_FLAG_ESCAPE_PERCENT* = 0x00000004 + WINHTTP_FLAG_NULL_CODEPAGE* = 0x00000008 + WINHTTP_FLAG_ESCAPE_DISABLE* = 0x00000040 + WINHTTP_FLAG_ESCAPE_DISABLE_QUERY* = 0x00000080 + WINHTTP_FLAG_BYPASS_PROXY_CACHE* = 0x00000100 + WINHTTP_FLAG_REFRESH* = WINHTTP_FLAG_BYPASS_PROXY_CACHE + WINHTTP_FLAG_SECURE* = 0x00800000 + WINHTTP_ACCESS_TYPE_DEFAULT_PROXY* = 0 + WINHTTP_ACCESS_TYPE_NO_PROXY* = 1 + WINHTTP_ACCESS_TYPE_NAMED_PROXY* = 3 + WINHTTP_NO_PROXY_NAME* = NULL + WINHTTP_NO_PROXY_BYPASS* = NULL + WINHTTP_NO_REFERER* = NULL + WINHTTP_DEFAULT_ACCEPT_TYPES* = NULL + WINHTTP_NO_ADDITIONAL_HEADERS* = NULL + WINHTTP_NO_REQUEST_DATA* = NULL + WINHTTP_HEADER_NAME_BY_INDEX* = NULL + WINHTTP_NO_OUTPUT_BUFFER* = NULL + WINHTTP_NO_HEADER_INDEX* = NULL + WINHTTP_ADDREQ_INDEX_MASK* = 0x0000FFFF + WINHTTP_ADDREQ_FLAGS_MASK* = 0xFFFF0000'i32 + WINHTTP_ADDREQ_FLAG_ADD_IF_NEW* = 0x10000000 + WINHTTP_ADDREQ_FLAG_ADD* = 0x20000000 + WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA* = 0x40000000 + WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON* = 0x01000000 + WINHTTP_ADDREQ_FLAG_COALESCE* = WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA + WINHTTP_ADDREQ_FLAG_REPLACE* = 0x80000000'i32 + WINHTTP_IGNORE_REQUEST_TOTAL_LENGTH* = 0 + WINHTTP_OPTION_CALLBACK* = 1 + WINHTTP_FIRST_OPTION* = WINHTTP_OPTION_CALLBACK + WINHTTP_OPTION_RESOLVE_TIMEOUT* = 2 + WINHTTP_OPTION_CONNECT_TIMEOUT* = 3 + WINHTTP_OPTION_CONNECT_RETRIES* = 4 + WINHTTP_OPTION_SEND_TIMEOUT* = 5 + WINHTTP_OPTION_RECEIVE_TIMEOUT* = 6 + WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT* = 7 + WINHTTP_OPTION_HANDLE_TYPE* = 9 + WINHTTP_OPTION_READ_BUFFER_SIZE* = 12 + WINHTTP_OPTION_WRITE_BUFFER_SIZE* = 13 + WINHTTP_OPTION_PARENT_HANDLE* = 21 + WINHTTP_OPTION_EXTENDED_ERROR* = 24 + WINHTTP_OPTION_SECURITY_FLAGS* = 31 + WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT* = 32 + WINHTTP_OPTION_URL* = 34 + WINHTTP_OPTION_SECURITY_KEY_BITNESS* = 36 + WINHTTP_OPTION_PROXY* = 38 + WINHTTP_OPTION_USER_AGENT* = 41 + WINHTTP_OPTION_CONTEXT_VALUE* = 45 + WINHTTP_OPTION_CLIENT_CERT_CONTEXT* = 47 + WINHTTP_OPTION_REQUEST_PRIORITY* = 58 + WINHTTP_OPTION_HTTP_VERSION* = 59 + WINHTTP_OPTION_DISABLE_FEATURE* = 63 + WINHTTP_OPTION_CODEPAGE* = 68 + WINHTTP_OPTION_MAX_CONNS_PER_SERVER* = 73 + WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER* = 74 + WINHTTP_OPTION_AUTOLOGON_POLICY* = 77 + WINHTTP_OPTION_SERVER_CERT_CONTEXT* = 78 + WINHTTP_OPTION_ENABLE_FEATURE* = 79 + WINHTTP_OPTION_WORKER_THREAD_COUNT* = 80 + WINHTTP_OPTION_PASSPORT_COBRANDING_TEXT* = 81 + WINHTTP_OPTION_PASSPORT_COBRANDING_URL* = 82 + WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH* = 83 + WINHTTP_OPTION_SECURE_PROTOCOLS* = 84 + WINHTTP_OPTION_ENABLETRACING* = 85 + WINHTTP_OPTION_PASSPORT_SIGN_OUT* = 86 + WINHTTP_OPTION_PASSPORT_RETURN_URL* = 87 + WINHTTP_OPTION_REDIRECT_POLICY* = 88 + WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS* = 89 + WINHTTP_OPTION_MAX_HTTP_STATUS_CONTINUE* = 90 + WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE* = 91 + WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE* = 92 + WINHTTP_OPTION_CONNECTION_INFO* = 93 + WINHTTP_OPTION_CLIENT_CERT_ISSUER_LIST* = 94 + WINHTTP_OPTION_SPN* = 96 + WINHTTP_OPTION_GLOBAL_PROXY_CREDS* = 97 + WINHTTP_OPTION_GLOBAL_SERVER_CREDS* = 98 + WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT* = 99 + WINHTTP_OPTION_REJECT_USERPWD_IN_URL* = 100 + WINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALS* = 101 + WINHTTP_LAST_OPTION* = WINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALS + WINHTTP_OPTION_USERNAME* = 0x1000 + WINHTTP_OPTION_PASSWORD* = 0x1001 + WINHTTP_OPTION_PROXY_USERNAME* = 0x1002 + WINHTTP_OPTION_PROXY_PASSWORD* = 0x1003 + WINHTTP_CONNS_PER_SERVER_UNLIMITED* = 0xFFFFFFFF'i32 + WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM* = 0 + WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW* = 1 + WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH* = 2 + WINHTTP_AUTOLOGON_SECURITY_LEVEL_DEFAULT* = WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM + WINHTTP_OPTION_REDIRECT_POLICY_NEVER* = 0 + WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP* = 1 + WINHTTP_OPTION_REDIRECT_POLICY_ALWAYS* = 2 + WINHTTP_OPTION_REDIRECT_POLICY_LAST* = WINHTTP_OPTION_REDIRECT_POLICY_ALWAYS + WINHTTP_OPTION_REDIRECT_POLICY_DEFAULT* = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP + WINHTTP_DISABLE_PASSPORT_AUTH* = 0x00000000 + WINHTTP_ENABLE_PASSPORT_AUTH* = 0x10000000 + WINHTTP_DISABLE_PASSPORT_KEYRING* = 0x20000000 + WINHTTP_ENABLE_PASSPORT_KEYRING* = 0x40000000 + WINHTTP_DISABLE_COOKIES* = 0x00000001 + WINHTTP_DISABLE_REDIRECTS* = 0x00000002 + WINHTTP_DISABLE_AUTHENTICATION* = 0x00000004 + WINHTTP_DISABLE_KEEP_ALIVE* = 0x00000008 + WINHTTP_ENABLE_SSL_REVOCATION* = 0x00000001 + WINHTTP_ENABLE_SSL_REVERT_IMPERSONATION* = 0x00000002 + WINHTTP_DISABLE_SPN_SERVER_PORT* = 0x00000000 + WINHTTP_ENABLE_SPN_SERVER_PORT* = 0x00000001 + WINHTTP_OPTION_SPN_MASK* = WINHTTP_ENABLE_SPN_SERVER_PORT + WINHTTP_ERROR_BASE* = 12000 + ERROR_WINHTTP_OUT_OF_HANDLES* = WINHTTP_ERROR_BASE+1 + ERROR_WINHTTP_TIMEOUT* = WINHTTP_ERROR_BASE+2 + ERROR_WINHTTP_INTERNAL_ERROR* = WINHTTP_ERROR_BASE+4 + ERROR_WINHTTP_INVALID_URL* = WINHTTP_ERROR_BASE+5 + ERROR_WINHTTP_UNRECOGNIZED_SCHEME* = WINHTTP_ERROR_BASE+6 + ERROR_WINHTTP_NAME_NOT_RESOLVED* = WINHTTP_ERROR_BASE+7 + ERROR_WINHTTP_INVALID_OPTION* = WINHTTP_ERROR_BASE+9 + ERROR_WINHTTP_OPTION_NOT_SETTABLE* = WINHTTP_ERROR_BASE+11 + ERROR_WINHTTP_SHUTDOWN* = WINHTTP_ERROR_BASE+12 + ERROR_WINHTTP_LOGIN_FAILURE* = WINHTTP_ERROR_BASE+15 + ERROR_WINHTTP_OPERATION_CANCELLED* = WINHTTP_ERROR_BASE+17 + ERROR_WINHTTP_INCORRECT_HANDLE_TYPE* = WINHTTP_ERROR_BASE+18 + ERROR_WINHTTP_INCORRECT_HANDLE_STATE* = WINHTTP_ERROR_BASE+19 + ERROR_WINHTTP_CANNOT_CONNECT* = WINHTTP_ERROR_BASE+29 + ERROR_WINHTTP_CONNECTION_ERROR* = WINHTTP_ERROR_BASE+30 + ERROR_WINHTTP_RESEND_REQUEST* = WINHTTP_ERROR_BASE+32 + ERROR_WINHTTP_SECURE_CERT_DATE_INVALID* = WINHTTP_ERROR_BASE+37 + ERROR_WINHTTP_SECURE_CERT_CN_INVALID* = WINHTTP_ERROR_BASE+38 + ERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDED* = WINHTTP_ERROR_BASE+44 + ERROR_WINHTTP_SECURE_INVALID_CA* = WINHTTP_ERROR_BASE+45 + ERROR_WINHTTP_SECURE_CERT_REV_FAILED* = WINHTTP_ERROR_BASE+57 + ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN* = WINHTTP_ERROR_BASE+100 + ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND* = WINHTTP_ERROR_BASE+101 + ERROR_WINHTTP_CANNOT_CALL_AFTER_SEND* = WINHTTP_ERROR_BASE+102 + ERROR_WINHTTP_CANNOT_CALL_AFTER_OPEN* = WINHTTP_ERROR_BASE+103 + ERROR_WINHTTP_HEADER_NOT_FOUND* = WINHTTP_ERROR_BASE+150 + ERROR_WINHTTP_INVALID_SERVER_RESPONSE* = WINHTTP_ERROR_BASE+152 + ERROR_WINHTTP_INVALID_HEADER* = WINHTTP_ERROR_BASE+153 + ERROR_WINHTTP_INVALID_QUERY_REQUEST* = WINHTTP_ERROR_BASE+154 + ERROR_WINHTTP_HEADER_ALREADY_EXISTS* = WINHTTP_ERROR_BASE+155 + ERROR_WINHTTP_REDIRECT_FAILED* = WINHTTP_ERROR_BASE+156 + ERROR_WINHTTP_SECURE_CHANNEL_ERROR* = WINHTTP_ERROR_BASE+157 + ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT* = WINHTTP_ERROR_BASE+166 + ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT* = WINHTTP_ERROR_BASE+167 + ERROR_WINHTTP_SECURE_INVALID_CERT* = WINHTTP_ERROR_BASE+169 + ERROR_WINHTTP_SECURE_CERT_REVOKED* = WINHTTP_ERROR_BASE+170 + ERROR_WINHTTP_NOT_INITIALIZED* = WINHTTP_ERROR_BASE+172 + ERROR_WINHTTP_SECURE_FAILURE* = WINHTTP_ERROR_BASE+175 + ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR* = WINHTTP_ERROR_BASE+178 + ERROR_WINHTTP_SECURE_CERT_WRONG_USAGE* = WINHTTP_ERROR_BASE+179 + ERROR_WINHTTP_AUTODETECTION_FAILED* = WINHTTP_ERROR_BASE+180 + ERROR_WINHTTP_HEADER_COUNT_EXCEEDED* = WINHTTP_ERROR_BASE+181 + ERROR_WINHTTP_HEADER_SIZE_OVERFLOW* = WINHTTP_ERROR_BASE+182 + ERROR_WINHTTP_CHUNKED_ENCODING_HEADER_SIZE_OVERFLOW* = WINHTTP_ERROR_BASE+183 + ERROR_WINHTTP_RESPONSE_DRAIN_OVERFLOW* = WINHTTP_ERROR_BASE+184 + ERROR_WINHTTP_CLIENT_CERT_NO_PRIVATE_KEY* = WINHTTP_ERROR_BASE+185 + ERROR_WINHTTP_CLIENT_CERT_NO_ACCESS_PRIVATE_KEY* = WINHTTP_ERROR_BASE+186 + WINHTTP_ERROR_LAST* = WINHTTP_ERROR_BASE+186 + HTTP_STATUS_CONTINUE* = 100 + HTTP_STATUS_SWITCH_PROTOCOLS* = 101 + HTTP_STATUS_OK* = 200 + HTTP_STATUS_CREATED* = 201 + HTTP_STATUS_ACCEPTED* = 202 + HTTP_STATUS_PARTIAL* = 203 + HTTP_STATUS_NO_CONTENT* = 204 + HTTP_STATUS_RESET_CONTENT* = 205 + HTTP_STATUS_PARTIAL_CONTENT* = 206 + HTTP_STATUS_WEBDAV_MULTI_STATUS* = 207 + HTTP_STATUS_AMBIGUOUS* = 300 + HTTP_STATUS_MOVED* = 301 + HTTP_STATUS_REDIRECT* = 302 + HTTP_STATUS_REDIRECT_METHOD* = 303 + HTTP_STATUS_NOT_MODIFIED* = 304 + HTTP_STATUS_USE_PROXY* = 305 + HTTP_STATUS_REDIRECT_KEEP_VERB* = 307 + HTTP_STATUS_BAD_REQUEST* = 400 + HTTP_STATUS_DENIED* = 401 + HTTP_STATUS_PAYMENT_REQ* = 402 + HTTP_STATUS_FORBIDDEN* = 403 + HTTP_STATUS_NOT_FOUND* = 404 + HTTP_STATUS_BAD_METHOD* = 405 + HTTP_STATUS_NONE_ACCEPTABLE* = 406 + HTTP_STATUS_PROXY_AUTH_REQ* = 407 + HTTP_STATUS_REQUEST_TIMEOUT* = 408 + HTTP_STATUS_CONFLICT* = 409 + HTTP_STATUS_GONE* = 410 + HTTP_STATUS_LENGTH_REQUIRED* = 411 + HTTP_STATUS_PRECOND_FAILED* = 412 + HTTP_STATUS_REQUEST_TOO_LARGE* = 413 + HTTP_STATUS_URI_TOO_LONG* = 414 + HTTP_STATUS_UNSUPPORTED_MEDIA* = 415 + HTTP_STATUS_RETRY_WITH* = 449 + HTTP_STATUS_SERVER_ERROR* = 500 + HTTP_STATUS_NOT_SUPPORTED* = 501 + HTTP_STATUS_BAD_GATEWAY* = 502 + HTTP_STATUS_SERVICE_UNAVAIL* = 503 + HTTP_STATUS_GATEWAY_TIMEOUT* = 504 + HTTP_STATUS_VERSION_NOT_SUP* = 505 + HTTP_STATUS_FIRST* = HTTP_STATUS_CONTINUE + HTTP_STATUS_LAST* = HTTP_STATUS_VERSION_NOT_SUP + SECURITY_FLAG_IGNORE_UNKNOWN_CA* = 0x00000100 + SECURITY_FLAG_IGNORE_CERT_DATE_INVALID* = 0x00002000 + SECURITY_FLAG_IGNORE_CERT_CN_INVALID* = 0x00001000 + SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE* = 0x00000200 + SECURITY_FLAG_SECURE* = 0x00000001 + SECURITY_FLAG_STRENGTH_WEAK* = 0x10000000 + SECURITY_FLAG_STRENGTH_MEDIUM* = 0x40000000 + SECURITY_FLAG_STRENGTH_STRONG* = 0x20000000 + ICU_NO_ENCODE* = 0x20000000 + ICU_DECODE* = 0x10000000 + ICU_NO_META* = 0x08000000 + ICU_ENCODE_SPACES_ONLY* = 0x04000000 + ICU_BROWSER_MODE* = 0x02000000 + ICU_ENCODE_PERCENT* = 0x00001000 + WINHTTP_QUERY_MIME_VERSION* = 0 + WINHTTP_QUERY_CONTENT_TYPE* = 1 + WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING* = 2 + WINHTTP_QUERY_CONTENT_ID* = 3 + WINHTTP_QUERY_CONTENT_DESCRIPTION* = 4 + WINHTTP_QUERY_CONTENT_LENGTH* = 5 + WINHTTP_QUERY_CONTENT_LANGUAGE* = 6 + WINHTTP_QUERY_ALLOW* = 7 + WINHTTP_QUERY_PUBLIC* = 8 + WINHTTP_QUERY_DATE* = 9 + WINHTTP_QUERY_EXPIRES* = 10 + WINHTTP_QUERY_LAST_MODIFIED* = 11 + WINHTTP_QUERY_MESSAGE_ID* = 12 + WINHTTP_QUERY_URI* = 13 + WINHTTP_QUERY_DERIVED_FROM* = 14 + WINHTTP_QUERY_COST* = 15 + WINHTTP_QUERY_LINK* = 16 + WINHTTP_QUERY_PRAGMA* = 17 + WINHTTP_QUERY_VERSION* = 18 + WINHTTP_QUERY_STATUS_CODE* = 19 + WINHTTP_QUERY_STATUS_TEXT* = 20 + WINHTTP_QUERY_RAW_HEADERS* = 21 + WINHTTP_QUERY_RAW_HEADERS_CRLF* = 22 + WINHTTP_QUERY_CONNECTION* = 23 + WINHTTP_QUERY_ACCEPT* = 24 + WINHTTP_QUERY_ACCEPT_CHARSET* = 25 + WINHTTP_QUERY_ACCEPT_ENCODING* = 26 + WINHTTP_QUERY_ACCEPT_LANGUAGE* = 27 + WINHTTP_QUERY_AUTHORIZATION* = 28 + WINHTTP_QUERY_CONTENT_ENCODING* = 29 + WINHTTP_QUERY_FORWARDED* = 30 + WINHTTP_QUERY_FROM* = 31 + WINHTTP_QUERY_IF_MODIFIED_SINCE* = 32 + WINHTTP_QUERY_LOCATION* = 33 + WINHTTP_QUERY_ORIG_URI* = 34 + WINHTTP_QUERY_REFERER* = 35 + WINHTTP_QUERY_RETRY_AFTER* = 36 + WINHTTP_QUERY_SERVER* = 37 + WINHTTP_QUERY_TITLE* = 38 + WINHTTP_QUERY_USER_AGENT* = 39 + WINHTTP_QUERY_WWW_AUTHENTICATE* = 40 + WINHTTP_QUERY_PROXY_AUTHENTICATE* = 41 + WINHTTP_QUERY_ACCEPT_RANGES* = 42 + WINHTTP_QUERY_SET_COOKIE* = 43 + WINHTTP_QUERY_COOKIE* = 44 + WINHTTP_QUERY_REQUEST_METHOD* = 45 + WINHTTP_QUERY_REFRESH* = 46 + WINHTTP_QUERY_CONTENT_DISPOSITION* = 47 + WINHTTP_QUERY_AGE* = 48 + WINHTTP_QUERY_CACHE_CONTROL* = 49 + WINHTTP_QUERY_CONTENT_BASE* = 50 + WINHTTP_QUERY_CONTENT_LOCATION* = 51 + WINHTTP_QUERY_CONTENT_MD5* = 52 + WINHTTP_QUERY_CONTENT_RANGE* = 53 + WINHTTP_QUERY_ETAG* = 54 + WINHTTP_QUERY_HOST* = 55 + WINHTTP_QUERY_IF_MATCH* = 56 + WINHTTP_QUERY_IF_NONE_MATCH* = 57 + WINHTTP_QUERY_IF_RANGE* = 58 + WINHTTP_QUERY_IF_UNMODIFIED_SINCE* = 59 + WINHTTP_QUERY_MAX_FORWARDS* = 60 + WINHTTP_QUERY_PROXY_AUTHORIZATION* = 61 + WINHTTP_QUERY_RANGE* = 62 + WINHTTP_QUERY_TRANSFER_ENCODING* = 63 + WINHTTP_QUERY_UPGRADE* = 64 + WINHTTP_QUERY_VARY* = 65 + WINHTTP_QUERY_VIA* = 66 + WINHTTP_QUERY_WARNING* = 67 + WINHTTP_QUERY_EXPECT* = 68 + WINHTTP_QUERY_PROXY_CONNECTION* = 69 + WINHTTP_QUERY_UNLESS_MODIFIED_SINCE* = 70 + WINHTTP_QUERY_PROXY_SUPPORT* = 75 + WINHTTP_QUERY_AUTHENTICATION_INFO* = 76 + WINHTTP_QUERY_PASSPORT_URLS* = 77 + WINHTTP_QUERY_PASSPORT_CONFIG* = 78 + WINHTTP_QUERY_MAX* = 78 + WINHTTP_QUERY_CUSTOM* = 65535 + WINHTTP_QUERY_FLAG_REQUEST_HEADERS* = 0x80000000'i32 + WINHTTP_QUERY_FLAG_SYSTEMTIME* = 0x40000000 + WINHTTP_QUERY_FLAG_NUMBER* = 0x20000000 + WINHTTP_CALLBACK_STATUS_RESOLVING_NAME* = 0x00000001 + WINHTTP_CALLBACK_STATUS_NAME_RESOLVED* = 0x00000002 + WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER* = 0x00000004 + WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER* = 0x00000008 + WINHTTP_CALLBACK_STATUS_SENDING_REQUEST* = 0x00000010 + WINHTTP_CALLBACK_STATUS_REQUEST_SENT* = 0x00000020 + WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE* = 0x00000040 + WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED* = 0x00000080 + WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION* = 0x00000100 + WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED* = 0x00000200 + WINHTTP_CALLBACK_STATUS_HANDLE_CREATED* = 0x00000400 + WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING* = 0x00000800 + WINHTTP_CALLBACK_STATUS_DETECTING_PROXY* = 0x00001000 + WINHTTP_CALLBACK_STATUS_REDIRECT* = 0x00004000 + WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE* = 0x00008000 + WINHTTP_CALLBACK_STATUS_SECURE_FAILURE* = 0x00010000 + WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE* = 0x00020000 + WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE* = 0x00040000 + WINHTTP_CALLBACK_STATUS_READ_COMPLETE* = 0x00080000 + WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE* = 0x00100000 + WINHTTP_CALLBACK_STATUS_REQUEST_ERROR* = 0x00200000 + WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE* = 0x00400000 + WINHTTP_CALLBACK_FLAG_RESOLVE_NAME* = WINHTTP_CALLBACK_STATUS_RESOLVING_NAME or WINHTTP_CALLBACK_STATUS_NAME_RESOLVED + WINHTTP_CALLBACK_FLAG_CONNECT_TO_SERVER* = WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER or WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER + WINHTTP_CALLBACK_FLAG_SEND_REQUEST* = WINHTTP_CALLBACK_STATUS_SENDING_REQUEST or WINHTTP_CALLBACK_STATUS_REQUEST_SENT + WINHTTP_CALLBACK_FLAG_RECEIVE_RESPONSE* = WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE or WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED + WINHTTP_CALLBACK_FLAG_CLOSE_CONNECTION* = WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION or WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED + WINHTTP_CALLBACK_FLAG_HANDLES* = WINHTTP_CALLBACK_STATUS_HANDLE_CREATED or WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING + WINHTTP_CALLBACK_FLAG_DETECTING_PROXY* = WINHTTP_CALLBACK_STATUS_DETECTING_PROXY + WINHTTP_CALLBACK_FLAG_REDIRECT* = WINHTTP_CALLBACK_STATUS_REDIRECT + WINHTTP_CALLBACK_FLAG_INTERMEDIATE_RESPONSE* = WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE + WINHTTP_CALLBACK_FLAG_SECURE_FAILURE* = WINHTTP_CALLBACK_STATUS_SECURE_FAILURE + WINHTTP_CALLBACK_FLAG_SENDREQUEST_COMPLETE* = WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE + WINHTTP_CALLBACK_FLAG_HEADERS_AVAILABLE* = WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE + WINHTTP_CALLBACK_FLAG_DATA_AVAILABLE* = WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE + WINHTTP_CALLBACK_FLAG_READ_COMPLETE* = WINHTTP_CALLBACK_STATUS_READ_COMPLETE + WINHTTP_CALLBACK_FLAG_WRITE_COMPLETE* = WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE + WINHTTP_CALLBACK_FLAG_REQUEST_ERROR* = WINHTTP_CALLBACK_STATUS_REQUEST_ERROR + WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS* = WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE or WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE or WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE or WINHTTP_CALLBACK_STATUS_READ_COMPLETE or WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE or WINHTTP_CALLBACK_STATUS_REQUEST_ERROR + WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS* = 0xffffffff'i32 + API_RECEIVE_RESPONSE* = 1 + API_QUERY_DATA_AVAILABLE* = 2 + API_READ_DATA* = 3 + API_WRITE_DATA* = 4 + API_SEND_REQUEST* = 5 + WINHTTP_HANDLE_TYPE_SESSION* = 1 + WINHTTP_HANDLE_TYPE_CONNECT* = 2 + WINHTTP_HANDLE_TYPE_REQUEST* = 3 + WINHTTP_CALLBACK_STATUS_FLAG_CERT_REV_FAILED* = 0x00000001 + WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CERT* = 0x00000002 + WINHTTP_CALLBACK_STATUS_FLAG_CERT_REVOKED* = 0x00000004 + WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CA* = 0x00000008 + WINHTTP_CALLBACK_STATUS_FLAG_CERT_CN_INVALID* = 0x00000010 + WINHTTP_CALLBACK_STATUS_FLAG_CERT_DATE_INVALID* = 0x00000020 + WINHTTP_CALLBACK_STATUS_FLAG_CERT_WRONG_USAGE* = 0x00000040 + WINHTTP_CALLBACK_STATUS_FLAG_SECURITY_CHANNEL_ERROR* = 0x80000000'i32 + WINHTTP_FLAG_SECURE_PROTOCOL_SSL2* = 0x00000008 + WINHTTP_FLAG_SECURE_PROTOCOL_SSL3* = 0x00000020 + WINHTTP_FLAG_SECURE_PROTOCOL_TLS1* = 0x00000080 + WINHTTP_FLAG_SECURE_PROTOCOL_ALL* = WINHTTP_FLAG_SECURE_PROTOCOL_SSL2 or WINHTTP_FLAG_SECURE_PROTOCOL_SSL3 or WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 + WINHTTP_AUTH_SCHEME_BASIC* = 0x00000001 + WINHTTP_AUTH_SCHEME_NTLM* = 0x00000002 + WINHTTP_AUTH_SCHEME_PASSPORT* = 0x00000004 + WINHTTP_AUTH_SCHEME_DIGEST* = 0x00000008 + WINHTTP_AUTH_SCHEME_NEGOTIATE* = 0x00000010 + WINHTTP_AUTH_TARGET_SERVER* = 0x00000000 + WINHTTP_AUTH_TARGET_PROXY* = 0x00000001 + WINHTTP_TIME_FORMAT_BUFSIZE* = 62 + WINHTTP_AUTO_DETECT_TYPE_DHCP* = 0x00000001 + WINHTTP_AUTO_DETECT_TYPE_DNS_A* = 0x00000002 + WINHTTP_AUTOPROXY_AUTO_DETECT* = 0x00000001 + WINHTTP_AUTOPROXY_CONFIG_URL* = 0x00000002 + WINHTTP_AUTOPROXY_RUN_INPROCESS* = 0x00010000 + WINHTTP_AUTOPROXY_RUN_OUTPROCESS_ONLY* = 0x00020000 +type + WINHTTP_STATUS_CALLBACK* = proc (P1: HINTERNET, P2: DWORD_PTR, P3: DWORD, P4: LPVOID, P5: DWORD): VOID {.stdcall.} +const + WINHTTP_INVALID_STATUS_CALLBACK* = cast[WINHTTP_STATUS_CALLBACK](-1) +type + WINHTTP_CERTIFICATE_INFO* {.pure.} = object + ftExpiry*: FILETIME + ftStart*: FILETIME + lpszSubjectInfo*: LPWSTR + lpszIssuerInfo*: LPWSTR + lpszProtocolName*: LPWSTR + lpszSignatureAlgName*: LPWSTR + lpszEncryptionAlgName*: LPWSTR + dwKeySize*: DWORD + WINHTTP_CURRENT_USER_IE_PROXY_CONFIG* {.pure.} = object + fAutoDetect*: WINBOOL + lpszAutoConfigUrl*: LPWSTR + lpszProxy*: LPWSTR + lpszProxyBypass*: LPWSTR + WINHTTP_AUTOPROXY_OPTIONS* {.pure.} = object + dwFlags*: DWORD + dwAutoDetectFlags*: DWORD + lpszAutoConfigUrl*: LPCWSTR + lpvReserved*: LPVOID + dwReserved*: DWORD + fAutoLogonIfChallenged*: WINBOOL +proc WinHttpAddRequestHeaders*(P1: HINTERNET, P2: LPCWSTR, P3: DWORD, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpDetectAutoProxyConfigUrl*(P1: DWORD, P2: ptr LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpCheckPlatform*(): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpCloseHandle*(P1: HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpConnect*(P1: HINTERNET, P2: LPCWSTR, P3: INTERNET_PORT, P4: DWORD): HINTERNET {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpCrackUrl*(P1: LPCWSTR, P2: DWORD, P3: DWORD, P4: LPURL_COMPONENTS): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpCreateUrl*(P1: LPURL_COMPONENTS, P2: DWORD, P3: LPWSTR, P4: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpGetDefaultProxyConfiguration*(P1: ptr WINHTTP_PROXY_INFO): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpGetIEProxyConfigForCurrentUser*(P1: ptr WINHTTP_CURRENT_USER_IE_PROXY_CONFIG): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpGetProxyForUrl*(P1: HINTERNET, P2: LPCWSTR, P3: ptr WINHTTP_AUTOPROXY_OPTIONS, P4: ptr WINHTTP_PROXY_INFO): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpOpen*(P1: LPCWSTR, P2: DWORD, P3: LPCWSTR, P4: LPCWSTR, P5: DWORD): HINTERNET {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpOpenRequest*(P1: HINTERNET, P2: LPCWSTR, P3: LPCWSTR, P4: LPCWSTR, P5: LPCWSTR, P6: ptr LPCWSTR, P7: DWORD): HINTERNET {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpQueryAuthSchemes*(P1: HINTERNET, P2: LPDWORD, P3: LPDWORD, P4: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpQueryDataAvailable*(P1: HINTERNET, P2: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpQueryHeaders*(P1: HINTERNET, P2: DWORD, P3: LPCWSTR, P4: LPVOID, P5: LPDWORD, P6: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpQueryOption*(P1: HINTERNET, P2: DWORD, P3: LPVOID, P4: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpReadData*(P1: HINTERNET, P2: LPVOID, P3: DWORD, P4: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpReceiveResponse*(P1: HINTERNET, P2: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSendRequest*(P1: HINTERNET, P2: LPCWSTR, P3: DWORD, P4: LPVOID, P5: DWORD, P6: DWORD, P7: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSetDefaultProxyConfiguration*(P1: ptr WINHTTP_PROXY_INFO): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSetCredentials*(P1: HINTERNET, P2: DWORD, P3: DWORD, P4: LPCWSTR, P5: LPCWSTR, P6: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSetOption*(P1: HINTERNET, P2: DWORD, P3: LPVOID, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSetStatusCallback*(P1: HINTERNET, P2: WINHTTP_STATUS_CALLBACK, P3: DWORD, P4: DWORD_PTR): WINHTTP_STATUS_CALLBACK {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpSetTimeouts*(P1: HINTERNET, P2: int32, P3: int32, P4: int32, P5: int32): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpTimeFromSystemTime*(P1: ptr SYSTEMTIME, P2: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpTimeToSystemTime*(P1: LPCWSTR, P2: ptr SYSTEMTIME): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +proc WinHttpWriteData*(P1: HINTERNET, P2: LPCVOID, P3: DWORD, P4: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winhttp", importc.} +when winimCpu64: + type + WINHTTP_CONNECTION_INFO* {.pure.} = object + cbSize*: DWORD + LocalAddress*: SOCKADDR_STORAGE + RemoteAddress*: SOCKADDR_STORAGE +when winimCpu32: + type + WINHTTP_CONNECTION_INFO* {.pure, packed.} = object + cbSize*: DWORD + LocalAddress*: SOCKADDR_STORAGE + RemoteAddress*: SOCKADDR_STORAGE diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winimbase.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winimbase.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,46 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== + +import macros + +when not defined(noRes): + when defined(vcc): + {.link: "../lib/winimvcc.res".} + + elif defined(cpu64): + {.link: "../lib/winim64.res".} + + else: + {.link: "../lib/winim32.res".} + +macro winapi*(x: untyped): untyped = + when not defined(noDiscardableApi): + x.addPragma(newIdentNode("discardable")) + + result = x + +proc discardable*[T](x: T): T {.discardable, inline.} = x + +macro DEFINE_GUID*(guid: string): untyped = + const + ranges = [0..7, 9..12, 14..17, 19..20, 21..22, 24..25, 26..27, 28..29, 30..31, 32..33, 34..35] + parts = ["'i32, 0x", ", 0x", ", [0x", "'u8, 0x", ", 0x", ", 0x", ", 0x", ", 0x", ", 0x", ", 0x", "])"] + + let guid = guid.strVal + assert guid.len == 36 + + var code = "DEFINE_GUID(0x" + for i in 0..10: + code.add guid[ranges[i]] + code.add parts[i] + result = parseStmt(code) + +const + winimAnsi* = defined(useWinAnsi) or defined(winansi) + winimUnicode* = not winimAnsi + winimCpu64* = defined(cpu64) + winimCpu32* = not defined(cpu64) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wininet.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wininet.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1429 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +type + INTERNET_SCHEME* = int32 + LPINTERNET_SCHEME* = ptr int32 + InternetCookieState* = int32 + INTERNET_PORT* = WORD + GROUPID* = LONGLONG + HINTERNET* = LPVOID + LPHINTERNET* = ptr HINTERNET + LPINTERNET_PORT* = ptr INTERNET_PORT + INTERNET_ASYNC_RESULT* {.pure.} = object + dwResult*: DWORD_PTR + dwError*: DWORD + LPINTERNET_ASYNC_RESULT* = ptr INTERNET_ASYNC_RESULT + INTERNET_DIAGNOSTIC_SOCKET_INFO* {.pure.} = object + Socket*: DWORD_PTR + SourcePort*: DWORD + DestPort*: DWORD + Flags*: DWORD + LPINTERNET_DIAGNOSTIC_SOCKET_INFO* = ptr INTERNET_DIAGNOSTIC_SOCKET_INFO + INTERNET_PROXY_INFO* {.pure.} = object + dwAccessType*: DWORD + lpszProxy*: LPCTSTR + lpszProxyBypass*: LPCTSTR + LPINTERNET_PROXY_INFO* = ptr INTERNET_PROXY_INFO + INTERNET_PER_CONN_OPTIONA_Value* {.pure, union.} = object + dwValue*: DWORD + pszValue*: LPSTR + ftValue*: FILETIME + INTERNET_PER_CONN_OPTIONA* {.pure.} = object + dwOption*: DWORD + Value*: INTERNET_PER_CONN_OPTIONA_Value + LPINTERNET_PER_CONN_OPTIONA* = ptr INTERNET_PER_CONN_OPTIONA + INTERNET_PER_CONN_OPTIONW_Value* {.pure, union.} = object + dwValue*: DWORD + pszValue*: LPWSTR + ftValue*: FILETIME + INTERNET_PER_CONN_OPTIONW* {.pure.} = object + dwOption*: DWORD + Value*: INTERNET_PER_CONN_OPTIONW_Value + LPINTERNET_PER_CONN_OPTIONW* = ptr INTERNET_PER_CONN_OPTIONW + INTERNET_PER_CONN_OPTION_LISTA* {.pure.} = object + dwSize*: DWORD + pszConnection*: LPSTR + dwOptionCount*: DWORD + dwOptionError*: DWORD + pOptions*: LPINTERNET_PER_CONN_OPTIONA + LPINTERNET_PER_CONN_OPTION_LISTA* = ptr INTERNET_PER_CONN_OPTION_LISTA + INTERNET_PER_CONN_OPTION_LISTW* {.pure.} = object + dwSize*: DWORD + pszConnection*: LPWSTR + dwOptionCount*: DWORD + dwOptionError*: DWORD + pOptions*: LPINTERNET_PER_CONN_OPTIONW + LPINTERNET_PER_CONN_OPTION_LISTW* = ptr INTERNET_PER_CONN_OPTION_LISTW + INTERNET_VERSION_INFO* {.pure.} = object + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + LPINTERNET_VERSION_INFO* = ptr INTERNET_VERSION_INFO + HTTP_VERSION_INFO* {.pure.} = object + dwMajorVersion*: DWORD + dwMinorVersion*: DWORD + LPHTTP_VERSION_INFO* = ptr HTTP_VERSION_INFO + INTERNET_CONNECTED_INFO* {.pure.} = object + dwConnectedState*: DWORD + dwFlags*: DWORD + LPINTERNET_CONNECTED_INFO* = ptr INTERNET_CONNECTED_INFO + URL_COMPONENTSA* {.pure.} = object + dwStructSize*: DWORD + lpszScheme*: LPSTR + dwSchemeLength*: DWORD + nScheme*: INTERNET_SCHEME + lpszHostName*: LPSTR + dwHostNameLength*: DWORD + nPort*: INTERNET_PORT + lpszUserName*: LPSTR + dwUserNameLength*: DWORD + lpszPassword*: LPSTR + dwPasswordLength*: DWORD + lpszUrlPath*: LPSTR + dwUrlPathLength*: DWORD + lpszExtraInfo*: LPSTR + dwExtraInfoLength*: DWORD + LPURL_COMPONENTSA* = ptr URL_COMPONENTSA + URL_COMPONENTSW* {.pure.} = object + dwStructSize*: DWORD + lpszScheme*: LPWSTR + dwSchemeLength*: DWORD + nScheme*: INTERNET_SCHEME + lpszHostName*: LPWSTR + dwHostNameLength*: DWORD + nPort*: INTERNET_PORT + lpszUserName*: LPWSTR + dwUserNameLength*: DWORD + lpszPassword*: LPWSTR + dwPasswordLength*: DWORD + lpszUrlPath*: LPWSTR + dwUrlPathLength*: DWORD + lpszExtraInfo*: LPWSTR + dwExtraInfoLength*: DWORD + LPURL_COMPONENTSW* = ptr URL_COMPONENTSW + INTERNET_CERTIFICATE_INFO* {.pure.} = object + ftExpiry*: FILETIME + ftStart*: FILETIME + lpszSubjectInfo*: LPTSTR + lpszIssuerInfo*: LPTSTR + lpszProtocolName*: LPTSTR + lpszSignatureAlgName*: LPTSTR + lpszEncryptionAlgName*: LPTSTR + dwKeySize*: DWORD + LPINTERNET_CERTIFICATE_INFO* = ptr INTERNET_CERTIFICATE_INFO + INTERNET_BUFFERSA* {.pure.} = object + dwStructSize*: DWORD + Next*: ptr INTERNET_BUFFERSA + lpcszHeader*: LPCSTR + dwHeadersLength*: DWORD + dwHeadersTotal*: DWORD + lpvBuffer*: LPVOID + dwBufferLength*: DWORD + dwBufferTotal*: DWORD + dwOffsetLow*: DWORD + dwOffsetHigh*: DWORD + LPINTERNET_BUFFERSA* = ptr INTERNET_BUFFERSA + INTERNET_BUFFERSW* {.pure.} = object + dwStructSize*: DWORD + Next*: ptr INTERNET_BUFFERSW + lpcszHeader*: LPCWSTR + dwHeadersLength*: DWORD + dwHeadersTotal*: DWORD + lpvBuffer*: LPVOID + dwBufferLength*: DWORD + dwBufferTotal*: DWORD + dwOffsetLow*: DWORD + dwOffsetHigh*: DWORD + LPINTERNET_BUFFERSW* = ptr INTERNET_BUFFERSW + INTERNET_STATUS_CALLBACK* = proc (hInternet: HINTERNET, dwContext: DWORD_PTR, dwInternetStatus: DWORD, lpvStatusInformation: LPVOID, dwStatusInformationLength: DWORD): VOID {.stdcall.} + LPINTERNET_STATUS_CALLBACK* = ptr INTERNET_STATUS_CALLBACK +const + MAX_GOPHER_DISPLAY_TEXT* = 128 + MAX_GOPHER_SELECTOR_TEXT* = 256 + INTERNET_MAX_HOST_NAME_LENGTH* = 256 + MAX_GOPHER_HOST_NAME* = INTERNET_MAX_HOST_NAME_LENGTH + INTERNET_MAX_PORT_NUMBER_LENGTH* = 5 + MAX_GOPHER_LOCATOR_LENGTH* = 1+MAX_GOPHER_DISPLAY_TEXT+1+MAX_GOPHER_SELECTOR_TEXT+1+MAX_GOPHER_HOST_NAME+1+INTERNET_MAX_PORT_NUMBER_LENGTH+1+1+2 +type + GOPHER_FIND_DATAA* {.pure.} = object + DisplayString*: array[MAX_GOPHER_DISPLAY_TEXT + 1, CHAR] + GopherType*: DWORD + SizeLow*: DWORD + SizeHigh*: DWORD + LastModificationTime*: FILETIME + Locator*: array[MAX_GOPHER_LOCATOR_LENGTH + 1, CHAR] + LPGOPHER_FIND_DATAA* = ptr GOPHER_FIND_DATAA + GOPHER_FIND_DATAW* {.pure.} = object + DisplayString*: array[MAX_GOPHER_DISPLAY_TEXT + 1, WCHAR] + GopherType*: DWORD + SizeLow*: DWORD + SizeHigh*: DWORD + LastModificationTime*: FILETIME + Locator*: array[MAX_GOPHER_LOCATOR_LENGTH + 1, WCHAR] + LPGOPHER_FIND_DATAW* = ptr GOPHER_FIND_DATAW + GOPHER_ADMIN_ATTRIBUTE_TYPE* {.pure.} = object + Comment*: LPCTSTR + EmailAddress*: LPCTSTR + LPGOPHER_ADMIN_ATTRIBUTE_TYPE* = ptr GOPHER_ADMIN_ATTRIBUTE_TYPE + GOPHER_MOD_DATE_ATTRIBUTE_TYPE* {.pure.} = object + DateAndTime*: FILETIME + LPGOPHER_MOD_DATE_ATTRIBUTE_TYPE* = ptr GOPHER_MOD_DATE_ATTRIBUTE_TYPE + GOPHER_TTL_ATTRIBUTE_TYPE* {.pure.} = object + Ttl*: DWORD + LPGOPHER_TTL_ATTRIBUTE_TYPE* = ptr GOPHER_TTL_ATTRIBUTE_TYPE + GOPHER_SCORE_ATTRIBUTE_TYPE* {.pure.} = object + Score*: INT + LPGOPHER_SCORE_ATTRIBUTE_TYPE* = ptr GOPHER_SCORE_ATTRIBUTE_TYPE + GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE* {.pure.} = object + LowerBound*: INT + UpperBound*: INT + LPGOPHER_SCORE_RANGE_ATTRIBUTE_TYPE* = ptr GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE + GOPHER_SITE_ATTRIBUTE_TYPE* {.pure.} = object + Site*: LPCTSTR + LPGOPHER_SITE_ATTRIBUTE_TYPE* = ptr GOPHER_SITE_ATTRIBUTE_TYPE + GOPHER_ORGANIZATION_ATTRIBUTE_TYPE* {.pure.} = object + Organization*: LPCTSTR + LPGOPHER_ORGANIZATION_ATTRIBUTE_TYPE* = ptr GOPHER_ORGANIZATION_ATTRIBUTE_TYPE + GOPHER_LOCATION_ATTRIBUTE_TYPE* {.pure.} = object + Location*: LPCTSTR + LPGOPHER_LOCATION_ATTRIBUTE_TYPE* = ptr GOPHER_LOCATION_ATTRIBUTE_TYPE + GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE* {.pure.} = object + DegreesNorth*: INT + MinutesNorth*: INT + SecondsNorth*: INT + DegreesEast*: INT + MinutesEast*: INT + SecondsEast*: INT + LPGOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE* = ptr GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE + GOPHER_TIMEZONE_ATTRIBUTE_TYPE* {.pure.} = object + Zone*: INT + LPGOPHER_TIMEZONE_ATTRIBUTE_TYPE* = ptr GOPHER_TIMEZONE_ATTRIBUTE_TYPE + GOPHER_PROVIDER_ATTRIBUTE_TYPE* {.pure.} = object + Provider*: LPCTSTR + LPGOPHER_PROVIDER_ATTRIBUTE_TYPE* = ptr GOPHER_PROVIDER_ATTRIBUTE_TYPE + GOPHER_VERSION_ATTRIBUTE_TYPE* {.pure.} = object + Version*: LPCTSTR + LPGOPHER_VERSION_ATTRIBUTE_TYPE* = ptr GOPHER_VERSION_ATTRIBUTE_TYPE + GOPHER_ABSTRACT_ATTRIBUTE_TYPE* {.pure.} = object + ShortAbstract*: LPCTSTR + AbstractFile*: LPCTSTR + LPGOPHER_ABSTRACT_ATTRIBUTE_TYPE* = ptr GOPHER_ABSTRACT_ATTRIBUTE_TYPE + GOPHER_VIEW_ATTRIBUTE_TYPE* {.pure.} = object + ContentType*: LPCTSTR + Language*: LPCTSTR + Size*: DWORD + LPGOPHER_VIEW_ATTRIBUTE_TYPE* = ptr GOPHER_VIEW_ATTRIBUTE_TYPE + GOPHER_VERONICA_ATTRIBUTE_TYPE* {.pure.} = object + TreeWalk*: WINBOOL + LPGOPHER_VERONICA_ATTRIBUTE_TYPE* = ptr GOPHER_VERONICA_ATTRIBUTE_TYPE + GOPHER_ASK_ATTRIBUTE_TYPE* {.pure.} = object + QuestionType*: LPCTSTR + QuestionText*: LPCTSTR + LPGOPHER_ASK_ATTRIBUTE_TYPE* = ptr GOPHER_ASK_ATTRIBUTE_TYPE + GOPHER_UNKNOWN_ATTRIBUTE_TYPE* {.pure.} = object + Text*: LPCTSTR + LPGOPHER_UNKNOWN_ATTRIBUTE_TYPE* = ptr GOPHER_UNKNOWN_ATTRIBUTE_TYPE + GOPHER_ATTRIBUTE_TYPE_AttributeType* {.pure, union.} = object + Admin*: GOPHER_ADMIN_ATTRIBUTE_TYPE + ModDate*: GOPHER_MOD_DATE_ATTRIBUTE_TYPE + Ttl*: GOPHER_TTL_ATTRIBUTE_TYPE + Score*: GOPHER_SCORE_ATTRIBUTE_TYPE + ScoreRange*: GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE + Site*: GOPHER_SITE_ATTRIBUTE_TYPE + Organization*: GOPHER_ORGANIZATION_ATTRIBUTE_TYPE + Location*: GOPHER_LOCATION_ATTRIBUTE_TYPE + GeographicalLocation*: GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE + TimeZone*: GOPHER_TIMEZONE_ATTRIBUTE_TYPE + Provider*: GOPHER_PROVIDER_ATTRIBUTE_TYPE + Version*: GOPHER_VERSION_ATTRIBUTE_TYPE + Abstract*: GOPHER_ABSTRACT_ATTRIBUTE_TYPE + View*: GOPHER_VIEW_ATTRIBUTE_TYPE + Veronica*: GOPHER_VERONICA_ATTRIBUTE_TYPE + Ask*: GOPHER_ASK_ATTRIBUTE_TYPE + Unknown*: GOPHER_UNKNOWN_ATTRIBUTE_TYPE + GOPHER_ATTRIBUTE_TYPE* {.pure.} = object + CategoryId*: DWORD + AttributeId*: DWORD + AttributeType*: GOPHER_ATTRIBUTE_TYPE_AttributeType + LPGOPHER_ATTRIBUTE_TYPE* = ptr GOPHER_ATTRIBUTE_TYPE + INTERNET_CACHE_ENTRY_INFOA_UNION1* {.pure, union.} = object + dwReserved*: DWORD + dwExemptDelta*: DWORD + INTERNET_CACHE_ENTRY_INFOA* {.pure.} = object + dwStructSize*: DWORD + lpszSourceUrlName*: LPSTR + lpszLocalFileName*: LPSTR + CacheEntryType*: DWORD + dwUseCount*: DWORD + dwHitRate*: DWORD + dwSizeLow*: DWORD + dwSizeHigh*: DWORD + LastModifiedTime*: FILETIME + ExpireTime*: FILETIME + LastAccessTime*: FILETIME + LastSyncTime*: FILETIME + lpHeaderInfo*: LPSTR + dwHeaderInfoSize*: DWORD + lpszFileExtension*: LPSTR + union1*: INTERNET_CACHE_ENTRY_INFOA_UNION1 + LPINTERNET_CACHE_ENTRY_INFOA* = ptr INTERNET_CACHE_ENTRY_INFOA + INTERNET_CACHE_ENTRY_INFOW_UNION1* {.pure, union.} = object + dwReserved*: DWORD + dwExemptDelta*: DWORD + INTERNET_CACHE_ENTRY_INFOW* {.pure.} = object + dwStructSize*: DWORD + lpszSourceUrlName*: LPWSTR + lpszLocalFileName*: LPWSTR + CacheEntryType*: DWORD + dwUseCount*: DWORD + dwHitRate*: DWORD + dwSizeLow*: DWORD + dwSizeHigh*: DWORD + LastModifiedTime*: FILETIME + ExpireTime*: FILETIME + LastAccessTime*: FILETIME + LastSyncTime*: FILETIME + lpHeaderInfo*: LPWSTR + dwHeaderInfoSize*: DWORD + lpszFileExtension*: LPWSTR + union1*: INTERNET_CACHE_ENTRY_INFOW_UNION1 + LPINTERNET_CACHE_ENTRY_INFOW* = ptr INTERNET_CACHE_ENTRY_INFOW + INTERNET_CACHE_TIMESTAMPS* {.pure.} = object + ftExpires*: FILETIME + ftLastModified*: FILETIME + LPINTERNET_CACHE_TIMESTAMPS* = ptr INTERNET_CACHE_TIMESTAMPS +const + GROUP_OWNER_STORAGE_SIZE* = 4 + GROUPNAME_MAX_LENGTH* = 120 +type + INTERNET_CACHE_GROUP_INFOA* {.pure.} = object + dwGroupSize*: DWORD + dwGroupFlags*: DWORD + dwGroupType*: DWORD + dwDiskUsage*: DWORD + dwDiskQuota*: DWORD + dwOwnerStorage*: array[GROUP_OWNER_STORAGE_SIZE, DWORD] + szGroupName*: array[GROUPNAME_MAX_LENGTH, CHAR] + LPINTERNET_CACHE_GROUP_INFOA* = ptr INTERNET_CACHE_GROUP_INFOA + INTERNET_CACHE_GROUP_INFOW* {.pure.} = object + dwGroupSize*: DWORD + dwGroupFlags*: DWORD + dwGroupType*: DWORD + dwDiskUsage*: DWORD + dwDiskQuota*: DWORD + dwOwnerStorage*: array[GROUP_OWNER_STORAGE_SIZE, DWORD] + szGroupName*: array[GROUPNAME_MAX_LENGTH, WCHAR] + LPINTERNET_CACHE_GROUP_INFOW* = ptr INTERNET_CACHE_GROUP_INFOW + AUTO_PROXY_SCRIPT_BUFFER* {.pure.} = object + dwStructSize*: DWORD + lpszScriptBuffer*: LPSTR + dwScriptBufferSize*: DWORD + LPAUTO_PROXY_SCRIPT_BUFFER* = ptr AUTO_PROXY_SCRIPT_BUFFER +const + INTERNET_INVALID_PORT_NUMBER* = 0 + INTERNET_DEFAULT_FTP_PORT* = 21 + INTERNET_DEFAULT_GOPHER_PORT* = 70 + INTERNET_DEFAULT_HTTP_PORT* = 80 + INTERNET_DEFAULT_HTTPS_PORT* = 443 + INTERNET_DEFAULT_SOCKS_PORT* = 1080 + INTERNET_MAX_USER_NAME_LENGTH* = 128 + INTERNET_MAX_PASSWORD_LENGTH* = 128 + INTERNET_MAX_PORT_NUMBER_VALUE* = 65535 + INTERNET_MAX_PATH_LENGTH* = 2048 + INTERNET_MAX_SCHEME_LENGTH* = 32 + INTERNET_KEEP_ALIVE_UNKNOWN* = DWORD(-1) + INTERNET_KEEP_ALIVE_ENABLED* = 1 + INTERNET_KEEP_ALIVE_DISABLED* = 0 + INTERNET_REQFLAG_FROM_CACHE* = 0x00000001 + INTERNET_REQFLAG_ASYNC* = 0x00000002 + INTERNET_REQFLAG_VIA_PROXY* = 0x00000004 + INTERNET_REQFLAG_NO_HEADERS* = 0x00000008 + INTERNET_REQFLAG_PASSIVE* = 0x00000010 + INTERNET_REQFLAG_CACHE_WRITE_DISABLED* = 0x00000040 + INTERNET_REQFLAG_NET_TIMEOUT* = 0x00000080 + INTERNET_FLAG_RELOAD* = 0x80000000'i32 + INTERNET_FLAG_RAW_DATA* = 0x40000000 + INTERNET_FLAG_EXISTING_CONNECT* = 0x20000000 + INTERNET_FLAG_ASYNC* = 0x10000000 + INTERNET_FLAG_PASSIVE* = 0x08000000 + INTERNET_FLAG_NO_CACHE_WRITE* = 0x04000000 + INTERNET_FLAG_DONT_CACHE* = INTERNET_FLAG_NO_CACHE_WRITE + INTERNET_FLAG_MAKE_PERSISTENT* = 0x02000000 + INTERNET_FLAG_FROM_CACHE* = 0x01000000 + INTERNET_FLAG_OFFLINE* = INTERNET_FLAG_FROM_CACHE + INTERNET_FLAG_SECURE* = 0x00800000 + INTERNET_FLAG_KEEP_CONNECTION* = 0x00400000 + INTERNET_FLAG_NO_AUTO_REDIRECT* = 0x00200000 + INTERNET_FLAG_READ_PREFETCH* = 0x00100000 + INTERNET_FLAG_NO_COOKIES* = 0x00080000 + INTERNET_FLAG_NO_AUTH* = 0x00040000 + INTERNET_FLAG_RESTRICTED_ZONE* = 0x00020000 + INTERNET_FLAG_CACHE_IF_NET_FAIL* = 0x00010000 + INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP* = 0x00008000 + INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS* = 0x00004000 + INTERNET_FLAG_IGNORE_CERT_DATE_INVALID* = 0x00002000 + INTERNET_FLAG_IGNORE_CERT_CN_INVALID* = 0x00001000 + INTERNET_FLAG_RESYNCHRONIZE* = 0x00000800 + INTERNET_FLAG_HYPERLINK* = 0x00000400 + INTERNET_FLAG_NO_UI* = 0x00000200 + INTERNET_FLAG_PRAGMA_NOCACHE* = 0x00000100 + INTERNET_FLAG_CACHE_ASYNC* = 0x00000080 + INTERNET_FLAG_FORMS_SUBMIT* = 0x00000040 + INTERNET_FLAG_FWD_BACK* = 0x00000020 + INTERNET_FLAG_NEED_FILE* = 0x00000010 + INTERNET_FLAG_MUST_CACHE_REQUEST* = INTERNET_FLAG_NEED_FILE + FTP_TRANSFER_TYPE_ASCII* = 0x00000001 + INTERNET_FLAG_TRANSFER_ASCII* = FTP_TRANSFER_TYPE_ASCII + FTP_TRANSFER_TYPE_BINARY* = 0x00000002 + INTERNET_FLAG_TRANSFER_BINARY* = FTP_TRANSFER_TYPE_BINARY + SECURITY_INTERNET_MASK* = INTERNET_FLAG_IGNORE_CERT_CN_INVALID or INTERNET_FLAG_IGNORE_CERT_DATE_INVALID or INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS or INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP + INTERNET_FLAG_BGUPDATE* = 8 + INTERNET_FLAGS_MASK* = INTERNET_FLAG_RELOAD or INTERNET_FLAG_RAW_DATA or INTERNET_FLAG_EXISTING_CONNECT or INTERNET_FLAG_ASYNC or INTERNET_FLAG_PASSIVE or INTERNET_FLAG_NO_CACHE_WRITE or INTERNET_FLAG_MAKE_PERSISTENT or INTERNET_FLAG_FROM_CACHE or INTERNET_FLAG_SECURE or INTERNET_FLAG_KEEP_CONNECTION or INTERNET_FLAG_NO_AUTO_REDIRECT or INTERNET_FLAG_READ_PREFETCH or INTERNET_FLAG_NO_COOKIES or INTERNET_FLAG_NO_AUTH or INTERNET_FLAG_CACHE_IF_NET_FAIL or SECURITY_INTERNET_MASK or INTERNET_FLAG_RESYNCHRONIZE or INTERNET_FLAG_HYPERLINK or INTERNET_FLAG_NO_UI or INTERNET_FLAG_PRAGMA_NOCACHE or INTERNET_FLAG_CACHE_ASYNC or INTERNET_FLAG_FORMS_SUBMIT or INTERNET_FLAG_NEED_FILE or INTERNET_FLAG_RESTRICTED_ZONE or INTERNET_FLAG_TRANSFER_BINARY or INTERNET_FLAG_TRANSFER_ASCII or INTERNET_FLAG_FWD_BACK or INTERNET_FLAG_BGUPDATE + INTERNET_ERROR_MASK_INSERT_CDROM* = 0x1 + INTERNET_ERROR_MASK_COMBINED_SEC_CERT* = 0x2 + INTERNET_ERROR_MASK_NEED_MSN_SSPI_PKG* = 0X4 + INTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODY* = 0x8 + INTERNET_OPTIONS_MASK* = not INTERNET_FLAGS_MASK + WININET_API_FLAG_ASYNC* = 0x00000001 + WININET_API_FLAG_SYNC* = 0x00000004 + WININET_API_FLAG_USE_CONTEXT* = 0x00000008 + INTERNET_NO_CALLBACK* = 0 + INTERNET_SCHEME_PARTIAL* = -2 + INTERNET_SCHEME_UNKNOWN* = -1 + INTERNET_SCHEME_DEFAULT* = 0 + INTERNET_SCHEME_FTP* = 1 + INTERNET_SCHEME_GOPHER* = 2 + INTERNET_SCHEME_HTTP* = 3 + INTERNET_SCHEME_HTTPS* = 4 + INTERNET_SCHEME_FILE* = 5 + INTERNET_SCHEME_NEWS* = 6 + INTERNET_SCHEME_MAILTO* = 7 + INTERNET_SCHEME_SOCKS* = 8 + INTERNET_SCHEME_JAVASCRIPT* = 9 + INTERNET_SCHEME_VBSCRIPT* = 10 + INTERNET_SCHEME_RES* = 11 + INTERNET_SCHEME_FIRST* = INTERNET_SCHEME_FTP + INTERNET_SCHEME_LAST* = INTERNET_SCHEME_RES + IDSI_FLAG_KEEP_ALIVE* = 0x00000001 + IDSI_FLAG_SECURE* = 0x00000002 + IDSI_FLAG_PROXY* = 0x00000004 + IDSI_FLAG_TUNNEL* = 0x00000008 + INTERNET_PER_CONN_FLAGS* = 1 + INTERNET_PER_CONN_PROXY_SERVER* = 2 + INTERNET_PER_CONN_PROXY_BYPASS* = 3 + INTERNET_PER_CONN_AUTOCONFIG_URL* = 4 + INTERNET_PER_CONN_AUTODISCOVERY_FLAGS* = 5 + INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL* = 6 + INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS* = 7 + INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME* = 8 + INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL* = 9 + INTERNET_PER_CONN_FLAGS_UI* = 10 + PROXY_TYPE_DIRECT* = 0x00000001 + PROXY_TYPE_PROXY* = 0x00000002 + PROXY_TYPE_AUTO_PROXY_URL* = 0x00000004 + PROXY_TYPE_AUTO_DETECT* = 0x00000008 + AUTO_PROXY_FLAG_USER_SET* = 0x00000001 + AUTO_PROXY_FLAG_ALWAYS_DETECT* = 0x00000002 + AUTO_PROXY_FLAG_DETECTION_RUN* = 0x00000004 + AUTO_PROXY_FLAG_MIGRATED* = 0x00000008 + AUTO_PROXY_FLAG_DONT_CACHE_PROXY_RESULT* = 0x00000010 + AUTO_PROXY_FLAG_CACHE_INIT_RUN* = 0x00000020 + AUTO_PROXY_FLAG_DETECTION_SUSPECT* = 0x00000040 + ISO_FORCE_DISCONNECTED* = 0x00000001 + INTERNET_RFC1123_FORMAT* = 0 + INTERNET_RFC1123_BUFSIZE* = 30 + ICU_ESCAPE* = 0x80000000'i32 + ICU_USERNAME* = 0x40000000 + ICU_NO_ENCODE* = 0x20000000 + ICU_DECODE* = 0x10000000 + ICU_NO_META* = 0x08000000 + ICU_ENCODE_SPACES_ONLY* = 0x04000000 + ICU_BROWSER_MODE* = 0x02000000 + ICU_ENCODE_PERCENT* = 0x00001000 + INTERNET_OPEN_TYPE_PRECONFIG* = 0 + INTERNET_OPEN_TYPE_DIRECT* = 1 + INTERNET_OPEN_TYPE_PROXY* = 3 + INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY* = 4 + PRE_CONFIG_INTERNET_ACCESS* = INTERNET_OPEN_TYPE_PRECONFIG + LOCAL_INTERNET_ACCESS* = INTERNET_OPEN_TYPE_DIRECT + CERN_PROXY_INTERNET_ACCESS* = INTERNET_OPEN_TYPE_PROXY + INTERNET_SERVICE_FTP* = 1 + INTERNET_SERVICE_GOPHER* = 2 + INTERNET_SERVICE_HTTP* = 3 + IRF_ASYNC* = WININET_API_FLAG_ASYNC + IRF_SYNC* = WININET_API_FLAG_SYNC + IRF_USE_CONTEXT* = WININET_API_FLAG_USE_CONTEXT + IRF_NO_WAIT* = 0x00000008 + ISO_GLOBAL* = 0x00000001 + ISO_REGISTRY* = 0x00000002 + ISO_VALID_FLAGS* = ISO_GLOBAL or ISO_REGISTRY + INTERNET_OPTION_CALLBACK* = 1 + INTERNET_OPTION_CONNECT_TIMEOUT* = 2 + INTERNET_OPTION_CONNECT_RETRIES* = 3 + INTERNET_OPTION_CONNECT_BACKOFF* = 4 + INTERNET_OPTION_SEND_TIMEOUT* = 5 + INTERNET_OPTION_CONTROL_SEND_TIMEOUT* = INTERNET_OPTION_SEND_TIMEOUT + INTERNET_OPTION_RECEIVE_TIMEOUT* = 6 + INTERNET_OPTION_CONTROL_RECEIVE_TIMEOUT* = INTERNET_OPTION_RECEIVE_TIMEOUT + INTERNET_OPTION_DATA_SEND_TIMEOUT* = 7 + INTERNET_OPTION_DATA_RECEIVE_TIMEOUT* = 8 + INTERNET_OPTION_HANDLE_TYPE* = 9 + INTERNET_OPTION_LISTEN_TIMEOUT* = 11 + INTERNET_OPTION_READ_BUFFER_SIZE* = 12 + INTERNET_OPTION_WRITE_BUFFER_SIZE* = 13 + INTERNET_OPTION_ASYNC_ID* = 15 + INTERNET_OPTION_ASYNC_PRIORITY* = 16 + INTERNET_OPTION_PARENT_HANDLE* = 21 + INTERNET_OPTION_KEEP_CONNECTION* = 22 + INTERNET_OPTION_REQUEST_FLAGS* = 23 + INTERNET_OPTION_EXTENDED_ERROR* = 24 + INTERNET_OPTION_OFFLINE_MODE* = 26 + INTERNET_OPTION_CACHE_STREAM_HANDLE* = 27 + INTERNET_OPTION_USERNAME* = 28 + INTERNET_OPTION_PASSWORD* = 29 + INTERNET_OPTION_ASYNC* = 30 + INTERNET_OPTION_SECURITY_FLAGS* = 31 + INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT* = 32 + INTERNET_OPTION_DATAFILE_NAME* = 33 + INTERNET_OPTION_URL* = 34 + INTERNET_OPTION_SECURITY_CERTIFICATE* = 35 + INTERNET_OPTION_SECURITY_KEY_BITNESS* = 36 + INTERNET_OPTION_REFRESH* = 37 + INTERNET_OPTION_PROXY* = 38 + INTERNET_OPTION_SETTINGS_CHANGED* = 39 + INTERNET_OPTION_VERSION* = 40 + INTERNET_OPTION_USER_AGENT* = 41 + INTERNET_OPTION_END_BROWSER_SESSION* = 42 + INTERNET_OPTION_PROXY_USERNAME* = 43 + INTERNET_OPTION_PROXY_PASSWORD* = 44 + INTERNET_OPTION_CONTEXT_VALUE* = 45 + INTERNET_OPTION_CONNECT_LIMIT* = 46 + INTERNET_OPTION_SECURITY_SELECT_CLIENT_CERT* = 47 + INTERNET_OPTION_POLICY* = 48 + INTERNET_OPTION_DISCONNECTED_TIMEOUT* = 49 + INTERNET_OPTION_CONNECTED_STATE* = 50 + INTERNET_OPTION_IDLE_STATE* = 51 + INTERNET_OPTION_OFFLINE_SEMANTICS* = 52 + INTERNET_OPTION_SECONDARY_CACHE_KEY* = 53 + INTERNET_OPTION_CALLBACK_FILTER* = 54 + INTERNET_OPTION_CONNECT_TIME* = 55 + INTERNET_OPTION_SEND_THROUGHPUT* = 56 + INTERNET_OPTION_RECEIVE_THROUGHPUT* = 57 + INTERNET_OPTION_REQUEST_PRIORITY* = 58 + INTERNET_OPTION_HTTP_VERSION* = 59 + INTERNET_OPTION_RESET_URLCACHE_SESSION* = 60 + INTERNET_OPTION_ERROR_MASK* = 62 + INTERNET_OPTION_FROM_CACHE_TIMEOUT* = 63 + INTERNET_OPTION_BYPASS_EDITED_ENTRY* = 64 + INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO* = 67 + INTERNET_OPTION_CODEPAGE* = 68 + INTERNET_OPTION_CACHE_TIMESTAMPS* = 69 + INTERNET_OPTION_DISABLE_AUTODIAL* = 70 + INTERNET_OPTION_MAX_CONNS_PER_SERVER* = 73 + INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER* = 74 + INTERNET_OPTION_PER_CONNECTION_OPTION* = 75 + INTERNET_OPTION_DIGEST_AUTH_UNLOAD* = 76 + INTERNET_OPTION_IGNORE_OFFLINE* = 77 + INTERNET_OPTION_IDENTITY* = 78 + INTERNET_OPTION_REMOVE_IDENTITY* = 79 + INTERNET_OPTION_ALTER_IDENTITY* = 80 + INTERNET_OPTION_SUPPRESS_BEHAVIOR* = 81 + INTERNET_OPTION_AUTODIAL_MODE* = 82 + INTERNET_OPTION_AUTODIAL_CONNECTION* = 83 + INTERNET_OPTION_CLIENT_CERT_CONTEXT* = 84 + INTERNET_OPTION_AUTH_FLAGS* = 85 + INTERNET_OPTION_COOKIES_3RD_PARTY* = 86 + INTERNET_OPTION_DISABLE_PASSPORT_AUTH* = 87 + INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY* = 88 + INTERNET_OPTION_EXEMPT_CONNECTION_LIMIT* = 89 + INTERNET_OPTION_ENABLE_PASSPORT_AUTH* = 90 + INTERNET_OPTION_HIBERNATE_INACTIVE_WORKER_THREADS* = 91 + INTERNET_OPTION_ACTIVATE_WORKER_THREADS* = 92 + INTERNET_OPTION_RESTORE_WORKER_THREAD_DEFAULTS* = 93 + INTERNET_OPTION_SOCKET_SEND_BUFFER_LENGTH* = 94 + INTERNET_OPTION_PROXY_SETTINGS_CHANGED* = 95 + INTERNET_OPTION_DATAFILE_EXT* = 96 + INTERNET_FIRST_OPTION* = INTERNET_OPTION_CALLBACK + INTERNET_LAST_OPTION* = INTERNET_OPTION_DATAFILE_EXT + INTERNET_PRIORITY_FOREGROUND* = 1000 + INTERNET_HANDLE_TYPE_INTERNET* = 1 + INTERNET_HANDLE_TYPE_CONNECT_FTP* = 2 + INTERNET_HANDLE_TYPE_CONNECT_GOPHER* = 3 + INTERNET_HANDLE_TYPE_CONNECT_HTTP* = 4 + INTERNET_HANDLE_TYPE_FTP_FIND* = 5 + INTERNET_HANDLE_TYPE_FTP_FIND_HTML* = 6 + INTERNET_HANDLE_TYPE_FTP_FILE* = 7 + INTERNET_HANDLE_TYPE_FTP_FILE_HTML* = 8 + INTERNET_HANDLE_TYPE_GOPHER_FIND* = 9 + INTERNET_HANDLE_TYPE_GOPHER_FIND_HTML* = 10 + INTERNET_HANDLE_TYPE_GOPHER_FILE* = 11 + INTERNET_HANDLE_TYPE_GOPHER_FILE_HTML* = 12 + INTERNET_HANDLE_TYPE_HTTP_REQUEST* = 13 + INTERNET_HANDLE_TYPE_FILE_REQUEST* = 14 + AUTH_FLAG_DISABLE_NEGOTIATE* = 0x00000001 + AUTH_FLAG_ENABLE_NEGOTIATE* = 0x00000002 + AUTH_FLAG_DISABLE_BASIC_CLEARCHANNEL* = 0x00000004 + SECURITY_FLAG_SECURE* = 0x00000001 + SECURITY_FLAG_STRENGTH_WEAK* = 0x10000000 + SECURITY_FLAG_STRENGTH_MEDIUM* = 0x40000000 + SECURITY_FLAG_STRENGTH_STRONG* = 0x20000000 + SECURITY_FLAG_UNKNOWNBIT* = 0x80000000'i32 + SECURITY_FLAG_FORTEZZA* = 0x08000000 + SECURITY_FLAG_NORMALBITNESS* = SECURITY_FLAG_STRENGTH_WEAK + SECURITY_FLAG_SSL* = 0x00000002 + SECURITY_FLAG_SSL3* = 0x00000004 + SECURITY_FLAG_PCT* = 0x00000008 + SECURITY_FLAG_PCT4* = 0x00000010 + SECURITY_FLAG_IETFSSL4* = 0x00000020 + SECURITY_FLAG_40BIT* = SECURITY_FLAG_STRENGTH_WEAK + SECURITY_FLAG_128BIT* = SECURITY_FLAG_STRENGTH_STRONG + SECURITY_FLAG_56BIT* = SECURITY_FLAG_STRENGTH_MEDIUM + SECURITY_FLAG_IGNORE_REVOCATION* = 0x00000080 + SECURITY_FLAG_IGNORE_UNKNOWN_CA* = 0x00000100 + SECURITY_FLAG_IGNORE_WRONG_USAGE* = 0x00000200 + SECURITY_FLAG_IGNORE_CERT_CN_INVALID* = INTERNET_FLAG_IGNORE_CERT_CN_INVALID + SECURITY_FLAG_IGNORE_CERT_DATE_INVALID* = INTERNET_FLAG_IGNORE_CERT_DATE_INVALID + SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPS* = INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS + SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTP* = INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP + SECURITY_SET_MASK* = SECURITY_FLAG_IGNORE_REVOCATION or SECURITY_FLAG_IGNORE_UNKNOWN_CA or SECURITY_FLAG_IGNORE_CERT_CN_INVALID or SECURITY_FLAG_IGNORE_CERT_DATE_INVALID or SECURITY_FLAG_IGNORE_WRONG_USAGE + AUTODIAL_MODE_NEVER* = 1 + AUTODIAL_MODE_ALWAYS* = 2 + AUTODIAL_MODE_NO_NETWORK_PRESENT* = 4 + INTERNET_STATUS_RESOLVING_NAME* = 10 + INTERNET_STATUS_NAME_RESOLVED* = 11 + INTERNET_STATUS_CONNECTING_TO_SERVER* = 20 + INTERNET_STATUS_CONNECTED_TO_SERVER* = 21 + INTERNET_STATUS_SENDING_REQUEST* = 30 + INTERNET_STATUS_REQUEST_SENT* = 31 + INTERNET_STATUS_RECEIVING_RESPONSE* = 40 + INTERNET_STATUS_RESPONSE_RECEIVED* = 41 + INTERNET_STATUS_CTL_RESPONSE_RECEIVED* = 42 + INTERNET_STATUS_PREFETCH* = 43 + INTERNET_STATUS_CLOSING_CONNECTION* = 50 + INTERNET_STATUS_CONNECTION_CLOSED* = 51 + INTERNET_STATUS_HANDLE_CREATED* = 60 + INTERNET_STATUS_HANDLE_CLOSING* = 70 + INTERNET_STATUS_DETECTING_PROXY* = 80 + INTERNET_STATUS_REQUEST_COMPLETE* = 100 + INTERNET_STATUS_REDIRECT* = 110 + INTERNET_STATUS_INTERMEDIATE_RESPONSE* = 120 + INTERNET_STATUS_USER_INPUT_REQUIRED* = 140 + INTERNET_STATUS_STATE_CHANGE* = 200 + INTERNET_STATUS_COOKIE_SENT* = 320 + INTERNET_STATUS_COOKIE_RECEIVED* = 321 + INTERNET_STATUS_PRIVACY_IMPACTED* = 324 + INTERNET_STATUS_P3P_HEADER* = 325 + INTERNET_STATUS_P3P_POLICYREF* = 326 + INTERNET_STATUS_COOKIE_HISTORY* = 327 + INTERNET_STATE_CONNECTED* = 0x00000001 + INTERNET_STATE_DISCONNECTED* = 0x00000002 + INTERNET_STATE_DISCONNECTED_BY_USER* = 0x00000010 + INTERNET_STATE_IDLE* = 0x00000100 + INTERNET_STATE_BUSY* = 0x00000200 + COOKIE_STATE_UNKNOWN* = 0x0 + COOKIE_STATE_ACCEPT* = 0x1 + COOKIE_STATE_PROMPT* = 0x2 + COOKIE_STATE_LEASH* = 0x3 + COOKIE_STATE_DOWNGRADE* = 0x4 + COOKIE_STATE_REJECT* = 0x5 + COOKIE_STATE_MAX* = COOKIE_STATE_REJECT + FTP_TRANSFER_TYPE_UNKNOWN* = 0x00000000 + FTP_TRANSFER_TYPE_MASK* = FTP_TRANSFER_TYPE_ASCII or FTP_TRANSFER_TYPE_BINARY + GOPHER_TYPE_TEXT_FILE* = 0x00000001 + GOPHER_TYPE_DIRECTORY* = 0x00000002 + GOPHER_TYPE_CSO* = 0x00000004 + GOPHER_TYPE_ERROR* = 0x00000008 + GOPHER_TYPE_MAC_BINHEX* = 0x00000010 + GOPHER_TYPE_DOS_ARCHIVE* = 0x00000020 + GOPHER_TYPE_UNIX_UUENCODED* = 0x00000040 + GOPHER_TYPE_INDEX_SERVER* = 0x00000080 + GOPHER_TYPE_TELNET* = 0x00000100 + GOPHER_TYPE_BINARY* = 0x00000200 + GOPHER_TYPE_REDUNDANT* = 0x00000400 + GOPHER_TYPE_TN3270* = 0x00000800 + GOPHER_TYPE_GIF* = 0x00001000 + GOPHER_TYPE_IMAGE* = 0x00002000 + GOPHER_TYPE_BITMAP* = 0x00004000 + GOPHER_TYPE_MOVIE* = 0x00008000 + GOPHER_TYPE_SOUND* = 0x00010000 + GOPHER_TYPE_HTML* = 0x00020000 + GOPHER_TYPE_PDF* = 0x00040000 + GOPHER_TYPE_CALENDAR* = 0x00080000 + GOPHER_TYPE_INLINE* = 0x00100000 + GOPHER_TYPE_UNKNOWN* = 0x20000000 + GOPHER_TYPE_ASK* = 0x40000000 + GOPHER_TYPE_GOPHER_PLUS* = 0x80000000'i32 + GOPHER_TYPE_FILE_MASK* = GOPHER_TYPE_TEXT_FILE or GOPHER_TYPE_MAC_BINHEX or GOPHER_TYPE_DOS_ARCHIVE or GOPHER_TYPE_UNIX_UUENCODED or GOPHER_TYPE_BINARY or GOPHER_TYPE_GIF or GOPHER_TYPE_IMAGE or GOPHER_TYPE_BITMAP or GOPHER_TYPE_MOVIE or GOPHER_TYPE_SOUND or GOPHER_TYPE_HTML or GOPHER_TYPE_PDF or GOPHER_TYPE_CALENDAR or GOPHER_TYPE_INLINE + MAX_GOPHER_CATEGORY_NAME* = 128 + MAX_GOPHER_ATTRIBUTE_NAME* = 128 + MIN_GOPHER_ATTRIBUTE_LENGTH* = 256 + GOPHER_INFO_CATEGORY* = "+INFO" + GOPHER_ADMIN_CATEGORY* = "+ADMIN" + GOPHER_VIEWS_CATEGORY* = "+VIEWS" + GOPHER_ABSTRACT_CATEGORY* = "+ABSTRACT" + GOPHER_VERONICA_CATEGORY* = "+VERONICA" + GOPHER_ADMIN_ATTRIBUTE* = "Admin" + GOPHER_MOD_DATE_ATTRIBUTE* = "Mod-Date" + GOPHER_TTL_ATTRIBUTE* = "TT" + GOPHER_SCORE_ATTRIBUTE* = "Score" + GOPHER_RANGE_ATTRIBUTE* = "Score-range" + GOPHER_SITE_ATTRIBUTE* = "Site" + GOPHER_ORG_ATTRIBUTE* = "Org" + GOPHER_LOCATION_ATTRIBUTE* = "Loc" + GOPHER_GEOG_ATTRIBUTE* = "Geog" + GOPHER_TIMEZONE_ATTRIBUTE* = "TZ" + GOPHER_PROVIDER_ATTRIBUTE* = "Provider" + GOPHER_VERSION_ATTRIBUTE* = "Version" + GOPHER_ABSTRACT_ATTRIBUTE* = "Abstract" + GOPHER_VIEW_ATTRIBUTE* = "View" + GOPHER_TREEWALK_ATTRIBUTE* = "treewalk" + GOPHER_ATTRIBUTE_ID_BASE* = 0xabcccc00'i32 + GOPHER_CATEGORY_ID_ALL* = GOPHER_ATTRIBUTE_ID_BASE+1 + GOPHER_CATEGORY_ID_INFO* = GOPHER_ATTRIBUTE_ID_BASE+2 + GOPHER_CATEGORY_ID_ADMIN* = GOPHER_ATTRIBUTE_ID_BASE+3 + GOPHER_CATEGORY_ID_VIEWS* = GOPHER_ATTRIBUTE_ID_BASE+4 + GOPHER_CATEGORY_ID_ABSTRACT* = GOPHER_ATTRIBUTE_ID_BASE+5 + GOPHER_CATEGORY_ID_VERONICA* = GOPHER_ATTRIBUTE_ID_BASE+6 + GOPHER_CATEGORY_ID_ASK* = GOPHER_ATTRIBUTE_ID_BASE+7 + GOPHER_CATEGORY_ID_UNKNOWN* = GOPHER_ATTRIBUTE_ID_BASE+8 + GOPHER_ATTRIBUTE_ID_ALL* = GOPHER_ATTRIBUTE_ID_BASE+9 + GOPHER_ATTRIBUTE_ID_ADMIN* = GOPHER_ATTRIBUTE_ID_BASE+10 + GOPHER_ATTRIBUTE_ID_MOD_DATE* = GOPHER_ATTRIBUTE_ID_BASE+11 + GOPHER_ATTRIBUTE_ID_TTL* = GOPHER_ATTRIBUTE_ID_BASE+12 + GOPHER_ATTRIBUTE_ID_SCORE* = GOPHER_ATTRIBUTE_ID_BASE+13 + GOPHER_ATTRIBUTE_ID_RANGE* = GOPHER_ATTRIBUTE_ID_BASE+14 + GOPHER_ATTRIBUTE_ID_SITE* = GOPHER_ATTRIBUTE_ID_BASE+15 + GOPHER_ATTRIBUTE_ID_ORG* = GOPHER_ATTRIBUTE_ID_BASE+16 + GOPHER_ATTRIBUTE_ID_LOCATION* = GOPHER_ATTRIBUTE_ID_BASE+17 + GOPHER_ATTRIBUTE_ID_GEOG* = GOPHER_ATTRIBUTE_ID_BASE+18 + GOPHER_ATTRIBUTE_ID_TIMEZONE* = GOPHER_ATTRIBUTE_ID_BASE+19 + GOPHER_ATTRIBUTE_ID_PROVIDER* = GOPHER_ATTRIBUTE_ID_BASE+20 + GOPHER_ATTRIBUTE_ID_VERSION* = GOPHER_ATTRIBUTE_ID_BASE+21 + GOPHER_ATTRIBUTE_ID_ABSTRACT* = GOPHER_ATTRIBUTE_ID_BASE+22 + GOPHER_ATTRIBUTE_ID_VIEW* = GOPHER_ATTRIBUTE_ID_BASE+23 + GOPHER_ATTRIBUTE_ID_TREEWALK* = GOPHER_ATTRIBUTE_ID_BASE+24 + GOPHER_ATTRIBUTE_ID_UNKNOWN* = GOPHER_ATTRIBUTE_ID_BASE+25 + HTTP_MAJOR_VERSION* = 1 + HTTP_MINOR_VERSION* = 0 + HTTP_QUERY_MIME_VERSION* = 0 + HTTP_QUERY_CONTENT_TYPE* = 1 + HTTP_QUERY_CONTENT_TRANSFER_ENCODING* = 2 + HTTP_QUERY_CONTENT_ID* = 3 + HTTP_QUERY_CONTENT_DESCRIPTION* = 4 + HTTP_QUERY_CONTENT_LENGTH* = 5 + HTTP_QUERY_CONTENT_LANGUAGE* = 6 + HTTP_QUERY_ALLOW* = 7 + HTTP_QUERY_PUBLIC* = 8 + HTTP_QUERY_DATE* = 9 + HTTP_QUERY_EXPIRES* = 10 + HTTP_QUERY_LAST_MODIFIED* = 11 + HTTP_QUERY_MESSAGE_ID* = 12 + HTTP_QUERY_URI* = 13 + HTTP_QUERY_DERIVED_FROM* = 14 + HTTP_QUERY_COST* = 15 + HTTP_QUERY_LINK* = 16 + HTTP_QUERY_PRAGMA* = 17 + HTTP_QUERY_VERSION* = 18 + HTTP_QUERY_STATUS_CODE* = 19 + HTTP_QUERY_STATUS_TEXT* = 20 + HTTP_QUERY_RAW_HEADERS* = 21 + HTTP_QUERY_RAW_HEADERS_CRLF* = 22 + HTTP_QUERY_CONNECTION* = 23 + HTTP_QUERY_ACCEPT* = 24 + HTTP_QUERY_ACCEPT_CHARSET* = 25 + HTTP_QUERY_ACCEPT_ENCODING* = 26 + HTTP_QUERY_ACCEPT_LANGUAGE* = 27 + HTTP_QUERY_AUTHORIZATION* = 28 + HTTP_QUERY_CONTENT_ENCODING* = 29 + HTTP_QUERY_FORWARDED* = 30 + HTTP_QUERY_FROM* = 31 + HTTP_QUERY_IF_MODIFIED_SINCE* = 32 + HTTP_QUERY_LOCATION* = 33 + HTTP_QUERY_ORIG_URI* = 34 + HTTP_QUERY_REFERER* = 35 + HTTP_QUERY_RETRY_AFTER* = 36 + HTTP_QUERY_SERVER* = 37 + HTTP_QUERY_TITLE* = 38 + HTTP_QUERY_USER_AGENT* = 39 + HTTP_QUERY_WWW_AUTHENTICATE* = 40 + HTTP_QUERY_PROXY_AUTHENTICATE* = 41 + HTTP_QUERY_ACCEPT_RANGES* = 42 + HTTP_QUERY_SET_COOKIE* = 43 + HTTP_QUERY_COOKIE* = 44 + HTTP_QUERY_REQUEST_METHOD* = 45 + HTTP_QUERY_REFRESH* = 46 + HTTP_QUERY_CONTENT_DISPOSITION* = 47 + HTTP_QUERY_AGE* = 48 + HTTP_QUERY_CACHE_CONTROL* = 49 + HTTP_QUERY_CONTENT_BASE* = 50 + HTTP_QUERY_CONTENT_LOCATION* = 51 + HTTP_QUERY_CONTENT_MD5* = 52 + HTTP_QUERY_CONTENT_RANGE* = 53 + HTTP_QUERY_ETAG* = 54 + HTTP_QUERY_HOST* = 55 + HTTP_QUERY_IF_MATCH* = 56 + HTTP_QUERY_IF_NONE_MATCH* = 57 + HTTP_QUERY_IF_RANGE* = 58 + HTTP_QUERY_IF_UNMODIFIED_SINCE* = 59 + HTTP_QUERY_MAX_FORWARDS* = 60 + HTTP_QUERY_PROXY_AUTHORIZATION* = 61 + HTTP_QUERY_RANGE* = 62 + HTTP_QUERY_TRANSFER_ENCODING* = 63 + HTTP_QUERY_UPGRADE* = 64 + HTTP_QUERY_VARY* = 65 + HTTP_QUERY_VIA* = 66 + HTTP_QUERY_WARNING* = 67 + HTTP_QUERY_EXPECT* = 68 + HTTP_QUERY_PROXY_CONNECTION* = 69 + HTTP_QUERY_UNLESS_MODIFIED_SINCE* = 70 + HTTP_QUERY_ECHO_REQUEST* = 71 + HTTP_QUERY_ECHO_REPLY* = 72 + HTTP_QUERY_ECHO_HEADERS* = 73 + HTTP_QUERY_ECHO_HEADERS_CRLF* = 74 + HTTP_QUERY_PROXY_SUPPORT* = 75 + HTTP_QUERY_AUTHENTICATION_INFO* = 76 + HTTP_QUERY_PASSPORT_URLS* = 77 + HTTP_QUERY_PASSPORT_CONFIG* = 78 + HTTP_QUERY_MAX* = 78 + HTTP_QUERY_CUSTOM* = 65535 + HTTP_QUERY_FLAG_REQUEST_HEADERS* = 0x80000000'i32 + HTTP_QUERY_FLAG_SYSTEMTIME* = 0x40000000 + HTTP_QUERY_FLAG_NUMBER* = 0x20000000 + HTTP_QUERY_FLAG_COALESCE* = 0x10000000 + HTTP_QUERY_MODIFIER_FLAGS_MASK* = HTTP_QUERY_FLAG_REQUEST_HEADERS or HTTP_QUERY_FLAG_SYSTEMTIME or HTTP_QUERY_FLAG_NUMBER or HTTP_QUERY_FLAG_COALESCE + HTTP_QUERY_HEADER_MASK* = not HTTP_QUERY_MODIFIER_FLAGS_MASK + HTTP_STATUS_CONTINUE* = 100 + HTTP_STATUS_SWITCH_PROTOCOLS* = 101 + HTTP_STATUS_OK* = 200 + HTTP_STATUS_CREATED* = 201 + HTTP_STATUS_ACCEPTED* = 202 + HTTP_STATUS_PARTIAL* = 203 + HTTP_STATUS_NO_CONTENT* = 204 + HTTP_STATUS_RESET_CONTENT* = 205 + HTTP_STATUS_PARTIAL_CONTENT* = 206 + HTTP_STATUS_AMBIGUOUS* = 300 + HTTP_STATUS_MOVED* = 301 + HTTP_STATUS_REDIRECT* = 302 + HTTP_STATUS_REDIRECT_METHOD* = 303 + HTTP_STATUS_NOT_MODIFIED* = 304 + HTTP_STATUS_USE_PROXY* = 305 + HTTP_STATUS_REDIRECT_KEEP_VERB* = 307 + HTTP_STATUS_BAD_REQUEST* = 400 + HTTP_STATUS_DENIED* = 401 + HTTP_STATUS_PAYMENT_REQ* = 402 + HTTP_STATUS_FORBIDDEN* = 403 + HTTP_STATUS_NOT_FOUND* = 404 + HTTP_STATUS_BAD_METHOD* = 405 + HTTP_STATUS_NONE_ACCEPTABLE* = 406 + HTTP_STATUS_PROXY_AUTH_REQ* = 407 + HTTP_STATUS_REQUEST_TIMEOUT* = 408 + HTTP_STATUS_CONFLICT* = 409 + HTTP_STATUS_GONE* = 410 + HTTP_STATUS_LENGTH_REQUIRED* = 411 + HTTP_STATUS_PRECOND_FAILED* = 412 + HTTP_STATUS_REQUEST_TOO_LARGE* = 413 + HTTP_STATUS_URI_TOO_LONG* = 414 + HTTP_STATUS_UNSUPPORTED_MEDIA* = 415 + HTTP_STATUS_RETRY_WITH* = 449 + HTTP_STATUS_SERVER_ERROR* = 500 + HTTP_STATUS_NOT_SUPPORTED* = 501 + HTTP_STATUS_BAD_GATEWAY* = 502 + HTTP_STATUS_SERVICE_UNAVAIL* = 503 + HTTP_STATUS_GATEWAY_TIMEOUT* = 504 + HTTP_STATUS_VERSION_NOT_SUP* = 505 + HTTP_STATUS_FIRST* = HTTP_STATUS_CONTINUE + HTTP_STATUS_LAST* = HTTP_STATUS_VERSION_NOT_SUP + HTTP_ADDREQ_INDEX_MASK* = 0x0000FFFF + HTTP_ADDREQ_FLAGS_MASK* = 0xFFFF0000'i32 + HTTP_ADDREQ_FLAG_ADD_IF_NEW* = 0x10000000 + HTTP_ADDREQ_FLAG_ADD* = 0x20000000 + HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA* = 0x40000000 + HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON* = 0x01000000 + HTTP_ADDREQ_FLAG_COALESCE* = HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA + HTTP_ADDREQ_FLAG_REPLACE* = 0x80000000'i32 + HSR_ASYNC* = WININET_API_FLAG_ASYNC + HSR_SYNC* = WININET_API_FLAG_SYNC + HSR_USE_CONTEXT* = WININET_API_FLAG_USE_CONTEXT + HSR_INITIATE* = 0x00000008 + HSR_DOWNLOAD* = 0x00000010 + HSR_CHUNKED* = 0x00000020 + INTERNET_COOKIE_IS_SECURE* = 0x01 + INTERNET_COOKIE_IS_SESSION* = 0x02 + INTERNET_COOKIE_THIRD_PARTY* = 0x10 + INTERNET_COOKIE_PROMPT_REQUIRED* = 0x20 + INTERNET_COOKIE_EVALUATE_P3P* = 0x40 + INTERNET_COOKIE_APPLY_P3P* = 0x80 + INTERNET_COOKIE_P3P_ENABLED* = 0x100 + INTERNET_COOKIE_IS_RESTRICTED* = 0x200 + INTERNET_COOKIE_IE6* = 0x400 + INTERNET_COOKIE_IS_LEGACY* = 0x800 + FLAG_ICC_FORCE_CONNECTION* = 0x00000001 + FLAGS_ERROR_UI_FILTER_FOR_ERRORS* = 0x01 + FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS* = 0x02 + FLAGS_ERROR_UI_FLAGS_GENERATE_DATA* = 0x04 + FLAGS_ERROR_UI_FLAGS_NO_UI* = 0x08 + FLAGS_ERROR_UI_SERIALIZE_DIALOGS* = 0x10 + INTERNET_ERROR_BASE* = 12000 + ERROR_INTERNET_OUT_OF_HANDLES* = INTERNET_ERROR_BASE+1 + ERROR_INTERNET_TIMEOUT* = INTERNET_ERROR_BASE+2 + ERROR_INTERNET_EXTENDED_ERROR* = INTERNET_ERROR_BASE+3 + ERROR_INTERNET_INTERNAL_ERROR* = INTERNET_ERROR_BASE+4 + ERROR_INTERNET_INVALID_URL* = INTERNET_ERROR_BASE+5 + ERROR_INTERNET_UNRECOGNIZED_SCHEME* = INTERNET_ERROR_BASE+6 + ERROR_INTERNET_NAME_NOT_RESOLVED* = INTERNET_ERROR_BASE+7 + ERROR_INTERNET_PROTOCOL_NOT_FOUND* = INTERNET_ERROR_BASE+8 + ERROR_INTERNET_INVALID_OPTION* = INTERNET_ERROR_BASE+9 + ERROR_INTERNET_BAD_OPTION_LENGTH* = INTERNET_ERROR_BASE+10 + ERROR_INTERNET_OPTION_NOT_SETTABLE* = INTERNET_ERROR_BASE+11 + ERROR_INTERNET_SHUTDOWN* = INTERNET_ERROR_BASE+12 + ERROR_INTERNET_INCORRECT_USER_NAME* = INTERNET_ERROR_BASE+13 + ERROR_INTERNET_INCORRECT_PASSWORD* = INTERNET_ERROR_BASE+14 + ERROR_INTERNET_LOGIN_FAILURE* = INTERNET_ERROR_BASE+15 + ERROR_INTERNET_INVALID_OPERATION* = INTERNET_ERROR_BASE+16 + ERROR_INTERNET_OPERATION_CANCELLED* = INTERNET_ERROR_BASE+17 + ERROR_INTERNET_INCORRECT_HANDLE_TYPE* = INTERNET_ERROR_BASE+18 + ERROR_INTERNET_INCORRECT_HANDLE_STATE* = INTERNET_ERROR_BASE+19 + ERROR_INTERNET_NOT_PROXY_REQUEST* = INTERNET_ERROR_BASE+20 + ERROR_INTERNET_REGISTRY_VALUE_NOT_FOUND* = INTERNET_ERROR_BASE+21 + ERROR_INTERNET_BAD_REGISTRY_PARAMETER* = INTERNET_ERROR_BASE+22 + ERROR_INTERNET_NO_DIRECT_ACCESS* = INTERNET_ERROR_BASE+23 + ERROR_INTERNET_NO_CONTEXT* = INTERNET_ERROR_BASE+24 + ERROR_INTERNET_NO_CALLBACK* = INTERNET_ERROR_BASE+25 + ERROR_INTERNET_REQUEST_PENDING* = INTERNET_ERROR_BASE+26 + ERROR_INTERNET_INCORRECT_FORMAT* = INTERNET_ERROR_BASE+27 + ERROR_INTERNET_ITEM_NOT_FOUND* = INTERNET_ERROR_BASE+28 + ERROR_INTERNET_CANNOT_CONNECT* = INTERNET_ERROR_BASE+29 + ERROR_INTERNET_CONNECTION_ABORTED* = INTERNET_ERROR_BASE+30 + ERROR_INTERNET_CONNECTION_RESET* = INTERNET_ERROR_BASE+31 + ERROR_INTERNET_FORCE_RETRY* = INTERNET_ERROR_BASE+32 + ERROR_INTERNET_INVALID_PROXY_REQUEST* = INTERNET_ERROR_BASE+33 + ERROR_INTERNET_NEED_UI* = INTERNET_ERROR_BASE+34 + ERROR_INTERNET_HANDLE_EXISTS* = INTERNET_ERROR_BASE+36 + ERROR_INTERNET_SEC_CERT_DATE_INVALID* = INTERNET_ERROR_BASE+37 + ERROR_INTERNET_SEC_CERT_CN_INVALID* = INTERNET_ERROR_BASE+38 + ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR* = INTERNET_ERROR_BASE+39 + ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR* = INTERNET_ERROR_BASE+40 + ERROR_INTERNET_MIXED_SECURITY* = INTERNET_ERROR_BASE+41 + ERROR_INTERNET_CHG_POST_IS_NON_SECURE* = INTERNET_ERROR_BASE+42 + ERROR_INTERNET_POST_IS_NON_SECURE* = INTERNET_ERROR_BASE+43 + ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED* = INTERNET_ERROR_BASE+44 + ERROR_INTERNET_INVALID_CA* = INTERNET_ERROR_BASE+45 + ERROR_INTERNET_CLIENT_AUTH_NOT_SETUP* = INTERNET_ERROR_BASE+46 + ERROR_INTERNET_ASYNC_THREAD_FAILED* = INTERNET_ERROR_BASE+47 + ERROR_INTERNET_REDIRECT_SCHEME_CHANGE* = INTERNET_ERROR_BASE+48 + ERROR_INTERNET_DIALOG_PENDING* = INTERNET_ERROR_BASE+49 + ERROR_INTERNET_RETRY_DIALOG* = INTERNET_ERROR_BASE+50 + ERROR_INTERNET_HTTPS_HTTP_SUBMIT_REDIR* = INTERNET_ERROR_BASE+52 + ERROR_INTERNET_INSERT_CDROM* = INTERNET_ERROR_BASE+53 + ERROR_INTERNET_FORTEZZA_LOGIN_NEEDED* = INTERNET_ERROR_BASE+54 + ERROR_INTERNET_SEC_CERT_ERRORS* = INTERNET_ERROR_BASE+55 + ERROR_INTERNET_SEC_CERT_NO_REV* = INTERNET_ERROR_BASE+56 + ERROR_INTERNET_SEC_CERT_REV_FAILED* = INTERNET_ERROR_BASE+57 + ERROR_FTP_TRANSFER_IN_PROGRESS* = INTERNET_ERROR_BASE+110 + ERROR_FTP_DROPPED* = INTERNET_ERROR_BASE+111 + ERROR_FTP_NO_PASSIVE_MODE* = INTERNET_ERROR_BASE+112 + ERROR_GOPHER_PROTOCOL_ERROR* = INTERNET_ERROR_BASE+130 + ERROR_GOPHER_NOT_FILE* = INTERNET_ERROR_BASE+131 + ERROR_GOPHER_DATA_ERROR* = INTERNET_ERROR_BASE+132 + ERROR_GOPHER_END_OF_DATA* = INTERNET_ERROR_BASE+133 + ERROR_GOPHER_INVALID_LOCATOR* = INTERNET_ERROR_BASE+134 + ERROR_GOPHER_INCORRECT_LOCATOR_TYPE* = INTERNET_ERROR_BASE+135 + ERROR_GOPHER_NOT_GOPHER_PLUS* = INTERNET_ERROR_BASE+136 + ERROR_GOPHER_ATTRIBUTE_NOT_FOUND* = INTERNET_ERROR_BASE+137 + ERROR_GOPHER_UNKNOWN_LOCATOR* = INTERNET_ERROR_BASE+138 + ERROR_HTTP_HEADER_NOT_FOUND* = INTERNET_ERROR_BASE+150 + ERROR_HTTP_DOWNLEVEL_SERVER* = INTERNET_ERROR_BASE+151 + ERROR_HTTP_INVALID_SERVER_RESPONSE* = INTERNET_ERROR_BASE+152 + ERROR_HTTP_INVALID_HEADER* = INTERNET_ERROR_BASE+153 + ERROR_HTTP_INVALID_QUERY_REQUEST* = INTERNET_ERROR_BASE+154 + ERROR_HTTP_HEADER_ALREADY_EXISTS* = INTERNET_ERROR_BASE+155 + ERROR_HTTP_REDIRECT_FAILED* = INTERNET_ERROR_BASE+156 + ERROR_HTTP_NOT_REDIRECTED* = INTERNET_ERROR_BASE+160 + ERROR_HTTP_COOKIE_NEEDS_CONFIRMATION* = INTERNET_ERROR_BASE+161 + ERROR_HTTP_COOKIE_DECLINED* = INTERNET_ERROR_BASE+162 + ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION* = INTERNET_ERROR_BASE+168 + ERROR_INTERNET_SECURITY_CHANNEL_ERROR* = INTERNET_ERROR_BASE+157 + ERROR_INTERNET_UNABLE_TO_CACHE_FILE* = INTERNET_ERROR_BASE+158 + ERROR_INTERNET_TCPIP_NOT_INSTALLED* = INTERNET_ERROR_BASE+159 + ERROR_INTERNET_DISCONNECTED* = INTERNET_ERROR_BASE+163 + ERROR_INTERNET_SERVER_UNREACHABLE* = INTERNET_ERROR_BASE+164 + ERROR_INTERNET_PROXY_SERVER_UNREACHABLE* = INTERNET_ERROR_BASE+165 + ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT* = INTERNET_ERROR_BASE+166 + ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT* = INTERNET_ERROR_BASE+167 + ERROR_INTERNET_SEC_INVALID_CERT* = INTERNET_ERROR_BASE+169 + ERROR_INTERNET_SEC_CERT_REVOKED* = INTERNET_ERROR_BASE+170 + ERROR_INTERNET_FAILED_DUETOSECURITYCHECK* = INTERNET_ERROR_BASE+171 + ERROR_INTERNET_NOT_INITIALIZED* = INTERNET_ERROR_BASE+172 + ERROR_INTERNET_NEED_MSN_SSPI_PKG* = INTERNET_ERROR_BASE+173 + ERROR_INTERNET_LOGIN_FAILURE_DISPLAY_ENTITY_BODY* = INTERNET_ERROR_BASE+174 + INTERNET_ERROR_LAST* = ERROR_INTERNET_LOGIN_FAILURE_DISPLAY_ENTITY_BODY + NORMAL_CACHE_ENTRY* = 0x00000001 + STICKY_CACHE_ENTRY* = 0x00000004 + EDITED_CACHE_ENTRY* = 0x00000008 + TRACK_OFFLINE_CACHE_ENTRY* = 0x00000010 + TRACK_ONLINE_CACHE_ENTRY* = 0x00000020 + SPARSE_CACHE_ENTRY* = 0x00010000 + COOKIE_CACHE_ENTRY* = 0x00100000 + URLHISTORY_CACHE_ENTRY* = 0x00200000 + URLCACHE_FIND_DEFAULT_FILTER* = NORMAL_CACHE_ENTRY or COOKIE_CACHE_ENTRY or URLHISTORY_CACHE_ENTRY or TRACK_OFFLINE_CACHE_ENTRY or TRACK_ONLINE_CACHE_ENTRY or STICKY_CACHE_ENTRY + CACHEGROUP_ATTRIBUTE_GET_ALL* = 0xffffffff'i32 + CACHEGROUP_ATTRIBUTE_BASIC* = 0x00000001 + CACHEGROUP_ATTRIBUTE_FLAG* = 0x00000002 + CACHEGROUP_ATTRIBUTE_TYPE* = 0x00000004 + CACHEGROUP_ATTRIBUTE_QUOTA* = 0x00000008 + CACHEGROUP_ATTRIBUTE_GROUPNAME* = 0x00000010 + CACHEGROUP_ATTRIBUTE_STORAGE* = 0x00000020 + CACHEGROUP_FLAG_NONPURGEABLE* = 0x00000001 + CACHEGROUP_FLAG_GIDONLY* = 0x00000004 + CACHEGROUP_FLAG_FLUSHURL_ONDELETE* = 0x00000002 + CACHEGROUP_SEARCH_ALL* = 0x00000000 + CACHEGROUP_SEARCH_BYURL* = 0x00000001 + CACHEGROUP_TYPE_INVALID* = 0x00000001 + CACHEGROUP_READWRITE_MASK* = CACHEGROUP_ATTRIBUTE_TYPE or CACHEGROUP_ATTRIBUTE_QUOTA or CACHEGROUP_ATTRIBUTE_GROUPNAME or CACHEGROUP_ATTRIBUTE_STORAGE + CACHE_ENTRY_ATTRIBUTE_FC* = 0x00000004 + CACHE_ENTRY_HITRATE_FC* = 0x00000010 + CACHE_ENTRY_MODTIME_FC* = 0x00000040 + CACHE_ENTRY_EXPTIME_FC* = 0x00000080 + CACHE_ENTRY_ACCTIME_FC* = 0x00000100 + CACHE_ENTRY_SYNCTIME_FC* = 0x00000200 + CACHE_ENTRY_HEADERINFO_FC* = 0x00000400 + CACHE_ENTRY_EXEMPT_DELTA_FC* = 0x00000800 + INTERNET_CACHE_GROUP_ADD* = 0 + INTERNET_CACHE_GROUP_REMOVE* = 1 + INTERNET_DIAL_FORCE_PROMPT* = 0x2000 + INTERNET_DIAL_SHOW_OFFLINE* = 0x4000 + INTERNET_DIAL_UNATTENDED* = 0x8000 + INTERENT_GOONLINE_REFRESH* = 0x00000001 + INTERENT_GOONLINE_MASK* = 0x00000001 + INTERNET_AUTODIAL_FORCE_ONLINE* = 1 + INTERNET_AUTODIAL_FORCE_UNATTENDED* = 2 + INTERNET_AUTODIAL_FAILIFSECURITYCHECK* = 4 + INTERNET_AUTODIAL_OVERRIDE_NET_PRESENT* = 8 + INTERNET_AUTODIAL_FLAGS_MASK* = INTERNET_AUTODIAL_FORCE_ONLINE or INTERNET_AUTODIAL_FORCE_UNATTENDED or INTERNET_AUTODIAL_FAILIFSECURITYCHECK or INTERNET_AUTODIAL_OVERRIDE_NET_PRESENT + PROXY_AUTO_DETECT_TYPE_DHCP* = 1 + PROXY_AUTO_DETECT_TYPE_DNS_A* = 2 + INTERNET_CONNECTION_MODEM* = 0x01 + INTERNET_CONNECTION_LAN* = 0x02 + INTERNET_CONNECTION_PROXY* = 0x04 + INTERNET_CONNECTION_MODEM_BUSY* = 0x08 + INTERNET_RAS_INSTALLED* = 0x10 + INTERNET_CONNECTION_OFFLINE* = 0x20 + INTERNET_CONNECTION_CONFIGURED* = 0x40 + INTERNET_CUSTOMDIAL_CONNECT* = 0 + INTERNET_CUSTOMDIAL_UNATTENDED* = 1 + INTERNET_CUSTOMDIAL_DISCONNECT* = 2 + INTERNET_CUSTOMDIAL_SHOWOFFLINE* = 4 + INTERNET_CUSTOMDIAL_SAFE_FOR_UNATTENDED* = 1 + INTERNET_CUSTOMDIAL_WILL_SUPPLY_STATE* = 2 + INTERNET_CUSTOMDIAL_CAN_HANGUP* = 4 + INTERNET_DIALSTATE_DISCONNECTED* = 1 + INTERNET_IDENTITY_FLAG_PRIVATE_CACHE* = 0x01 + INTERNET_IDENTITY_FLAG_SHARED_CACHE* = 0x02 + INTERNET_IDENTITY_FLAG_CLEAR_DATA* = 0x04 + INTERNET_IDENTITY_FLAG_CLEAR_COOKIES* = 0x08 + INTERNET_IDENTITY_FLAG_CLEAR_HISTORY* = 0x10 + INTERNET_IDENTITY_FLAG_CLEAR_CONTENT* = 0x20 + INTERNET_SUPPRESS_RESET_ALL* = 0x00 + INTERNET_SUPPRESS_COOKIE_POLICY* = 0x01 + INTERNET_SUPPRESS_COOKIE_POLICY_RESET* = 0x02 + PRIVACY_TEMPLATE_NO_COOKIES* = 0 + PRIVACY_TEMPLATE_HIGH* = 1 + PRIVACY_TEMPLATE_MEDIUM_HIGH* = 2 + PRIVACY_TEMPLATE_MEDIUM* = 3 + PRIVACY_TEMPLATE_MEDIUM_LOW* = 4 + PRIVACY_TEMPLATE_LOW* = 5 + PRIVACY_TEMPLATE_CUSTOM* = 100 + PRIVACY_TEMPLATE_ADVANCED* = 101 + PRIVACY_TEMPLATE_MAX* = PRIVACY_TEMPLATE_LOW + PRIVACY_TYPE_FIRST_PARTY* = 0 + PRIVACY_TYPE_THIRD_PARTY* = 1 + INTERNET_MAX_URL_LENGTH* = 2084 + INTERNET_INVALID_STATUS_CALLBACK* = cast[INTERNET_STATUS_CALLBACK](-1) +type + GOPHER_ATTRIBUTE_ENUMERATOR* = proc (lpAttributeInfo: LPGOPHER_ATTRIBUTE_TYPE, dwError: DWORD): WINBOOL {.stdcall.} + PFN_AUTH_NOTIFY* = proc (P1: DWORD_PTR, P2: DWORD, P3: LPVOID): DWORD {.stdcall.} + AutoProxyHelperFunctions* {.pure.} = object + lpVtbl*: ptr AutoProxyHelperVtbl + pfnInternetInitializeAutoProxyDll* = proc (dwVersion: DWORD, lpszDownloadedTempFile: LPSTR, lpszMime: LPSTR, lpAutoProxyCallbacks: ptr AutoProxyHelperFunctions, lpAutoProxyScriptBuffer: LPAUTO_PROXY_SCRIPT_BUFFER): WINBOOL {.stdcall.} + pfnInternetDeInitializeAutoProxyDll* = proc (lpszMime: LPSTR, dwReserved: DWORD): WINBOOL {.stdcall.} + pfnInternetGetProxyInfo* = proc (lpszUrl: LPCSTR, dwUrlLength: DWORD, lpszUrlHostName: LPSTR, dwUrlHostNameLength: DWORD, lplpszProxyHostName: ptr LPSTR, lpdwProxyHostNameLength: LPDWORD): WINBOOL {.stdcall.} + PFN_DIAL_HANDLER* = proc (P1: HWND, P2: LPCSTR, P3: DWORD, P4: LPDWORD): DWORD {.stdcall.} + IncomingCookieState* {.pure.} = object + cSession*: int32 + cPersistent*: int32 + cAccepted*: int32 + cLeashed*: int32 + cDowngraded*: int32 + cBlocked*: int32 + pszLocation*: ptr char + OutgoingCookieState* {.pure.} = object + cSent*: int32 + cSuppressed*: int32 + pszLocation*: ptr char + InternetCookieHistory* {.pure.} = object + fAccepted*: WINBOOL + fLeashed*: WINBOOL + fDowngraded*: WINBOOL + fRejected*: WINBOOL + CookieDecision* {.pure.} = object + dwCookieState*: DWORD + fAllowSession*: WINBOOL + INTERNET_AUTH_NOTIFY_DATA* {.pure.} = object + cbStruct*: DWORD + dwOptions*: DWORD + pfnNotify*: PFN_AUTH_NOTIFY + dwContext*: DWORD_PTR + AutoProxyHelperVtbl* {.pure.} = object + IsResolvable*: proc(lpszHost: LPSTR): WINBOOL {.stdcall.} + GetIPAddress*: proc(lpszIPAddress: LPSTR, lpdwIPAddressSize: LPDWORD): DWORD {.stdcall.} + ResolveHostName*: proc(lpszHostName: LPSTR, lpszIPAddress: LPSTR, lpdwIPAddressSize: LPDWORD): DWORD {.stdcall.} + IsInNet*: proc(lpszIPAddress: LPSTR, lpszDest: LPSTR, lpszMask: LPSTR): WINBOOL {.stdcall.} +proc InternetTimeFromSystemTimeA*(pst: ptr SYSTEMTIME, dwRFC: DWORD, lpszTime: LPSTR, cbTime: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetTimeFromSystemTimeW*(pst: ptr SYSTEMTIME, dwRFC: DWORD, lpszTime: LPWSTR, cbTime: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetTimeToSystemTimeA*(lpszTime: LPCSTR, pst: ptr SYSTEMTIME, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetTimeToSystemTimeW*(lpszTime: LPCWSTR, pst: ptr SYSTEMTIME, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCrackUrlA*(lpszUrl: LPCSTR, dwUrlLength: DWORD, dwFlags: DWORD, lpUrlComponents: LPURL_COMPONENTSA): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCrackUrlW*(lpszUrl: LPCWSTR, dwUrlLength: DWORD, dwFlags: DWORD, lpUrlComponents: LPURL_COMPONENTSW): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCreateUrlA*(lpUrlComponents: LPURL_COMPONENTSA, dwFlags: DWORD, lpszUrl: LPSTR, lpdwUrlLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCreateUrlW*(lpUrlComponents: LPURL_COMPONENTSW, dwFlags: DWORD, lpszUrl: LPWSTR, lpdwUrlLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCanonicalizeUrlA*(lpszUrl: LPCSTR, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCanonicalizeUrlW*(lpszUrl: LPCWSTR, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCombineUrlA*(lpszBaseUrl: LPCSTR, lpszRelativeUrl: LPCSTR, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCombineUrlW*(lpszBaseUrl: LPCWSTR, lpszRelativeUrl: LPCWSTR, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetOpenA*(lpszAgent: LPCSTR, dwAccessType: DWORD, lpszProxy: LPCSTR, lpszProxyBypass: LPCSTR, dwFlags: DWORD): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetOpenW*(lpszAgent: LPCWSTR, dwAccessType: DWORD, lpszProxy: LPCWSTR, lpszProxyBypass: LPCWSTR, dwFlags: DWORD): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCloseHandle*(hInternet: HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetConnectA*(hInternet: HINTERNET, lpszServerName: LPCSTR, nServerPort: INTERNET_PORT, lpszUserName: LPCSTR, lpszPassword: LPCSTR, dwService: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetConnectW*(hInternet: HINTERNET, lpszServerName: LPCWSTR, nServerPort: INTERNET_PORT, lpszUserName: LPCWSTR, lpszPassword: LPCWSTR, dwService: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetOpenUrlA*(hInternet: HINTERNET, lpszUrl: LPCSTR, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetOpenUrlW*(hInternet: HINTERNET, lpszUrl: LPCWSTR, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetReadFile*(hFile: HINTERNET, lpBuffer: LPVOID, dwNumberOfBytesToRead: DWORD, lpdwNumberOfBytesRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetReadFileExA*(hFile: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetReadFileExW*(hFile: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetFilePointer*(hFile: HINTERNET, lDistanceToMove: LONG, pReserved: PVOID, dwMoveMethod: DWORD, dwContext: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetWriteFile*(hFile: HINTERNET, lpBuffer: LPCVOID, dwNumberOfBytesToWrite: DWORD, lpdwNumberOfBytesWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetQueryDataAvailable*(hFile: HINTERNET, lpdwNumberOfBytesAvailable: LPDWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetFindNextFileA*(hFind: HINTERNET, lpvFindData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetFindNextFileW*(hFind: HINTERNET, lpvFindData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetQueryOptionA*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetQueryOptionW*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetOptionA*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetOptionW*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetOptionExA*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetOptionExW*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetLockRequestFile*(hInternet: HINTERNET, lphLockRequestInfo: ptr HANDLE): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetUnlockRequestFile*(hLockRequestInfo: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetLastResponseInfoA*(lpdwError: LPDWORD, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetLastResponseInfoW*(lpdwError: LPDWORD, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetStatusCallbackA*(hInternet: HINTERNET, lpfnInternetCallback: INTERNET_STATUS_CALLBACK): INTERNET_STATUS_CALLBACK {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetStatusCallbackW*(hInternet: HINTERNET, lpfnInternetCallback: INTERNET_STATUS_CALLBACK): INTERNET_STATUS_CALLBACK {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpFindFirstFileA*(hConnect: HINTERNET, lpszSearchFile: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpFindFirstFileW*(hConnect: HINTERNET, lpszSearchFile: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetFileA*(hConnect: HINTERNET, lpszRemoteFile: LPCSTR, lpszNewFile: LPCSTR, fFailIfExists: WINBOOL, dwFlagsAndAttributes: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetFileW*(hConnect: HINTERNET, lpszRemoteFile: LPCWSTR, lpszNewFile: LPCWSTR, fFailIfExists: WINBOOL, dwFlagsAndAttributes: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpPutFileA*(hConnect: HINTERNET, lpszLocalFile: LPCSTR, lpszNewRemoteFile: LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpPutFileW*(hConnect: HINTERNET, lpszLocalFile: LPCWSTR, lpszNewRemoteFile: LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetFileEx*(hFtpSession: HINTERNET, lpszRemoteFile: LPCSTR, lpszNewFile: LPCWSTR, fFailIfExists: WINBOOL, dwFlagsAndAttributes: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpPutFileEx*(hFtpSession: HINTERNET, lpszLocalFile: LPCWSTR, lpszNewRemoteFile: LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpDeleteFileA*(hConnect: HINTERNET, lpszFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpDeleteFileW*(hConnect: HINTERNET, lpszFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpRenameFileA*(hConnect: HINTERNET, lpszExisting: LPCSTR, lpszNew: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpRenameFileW*(hConnect: HINTERNET, lpszExisting: LPCWSTR, lpszNew: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpOpenFileA*(hConnect: HINTERNET, lpszFileName: LPCSTR, dwAccess: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpOpenFileW*(hConnect: HINTERNET, lpszFileName: LPCWSTR, dwAccess: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpCreateDirectoryA*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpCreateDirectoryW*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpRemoveDirectoryA*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpRemoveDirectoryW*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpSetCurrentDirectoryA*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpSetCurrentDirectoryW*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetCurrentDirectoryA*(hConnect: HINTERNET, lpszCurrentDirectory: LPSTR, lpdwCurrentDirectory: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetCurrentDirectoryW*(hConnect: HINTERNET, lpszCurrentDirectory: LPWSTR, lpdwCurrentDirectory: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpCommandA*(hConnect: HINTERNET, fExpectResponse: WINBOOL, dwFlags: DWORD, lpszCommand: LPCSTR, dwContext: DWORD_PTR, phFtpCommand: ptr HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpCommandW*(hConnect: HINTERNET, fExpectResponse: WINBOOL, dwFlags: DWORD, lpszCommand: LPCWSTR, dwContext: DWORD_PTR, phFtpCommand: ptr HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FtpGetFileSize*(hFile: HINTERNET, lpdwFileSizeHigh: LPDWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherCreateLocatorA*(lpszHost: LPCSTR, nServerPort: INTERNET_PORT, lpszDisplayString: LPCSTR, lpszSelectorString: LPCSTR, dwGopherType: DWORD, lpszLocator: LPSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherCreateLocatorW*(lpszHost: LPCWSTR, nServerPort: INTERNET_PORT, lpszDisplayString: LPCWSTR, lpszSelectorString: LPCWSTR, dwGopherType: DWORD, lpszLocator: LPWSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherGetLocatorTypeA*(lpszLocator: LPCSTR, lpdwGopherType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherGetLocatorTypeW*(lpszLocator: LPCWSTR, lpdwGopherType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherFindFirstFileA*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszSearchString: LPCSTR, lpFindData: LPGOPHER_FIND_DATAA, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherFindFirstFileW*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszSearchString: LPCWSTR, lpFindData: LPGOPHER_FIND_DATAW, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherOpenFileA*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszView: LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherOpenFileW*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszView: LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherGetAttributeA*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszAttributeName: LPCSTR, lpBuffer: LPBYTE, dwBufferLength: DWORD, lpdwCharactersReturned: LPDWORD, lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GopherGetAttributeW*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszAttributeName: LPCWSTR, lpBuffer: LPBYTE, dwBufferLength: DWORD, lpdwCharactersReturned: LPDWORD, lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpOpenRequestA*(hConnect: HINTERNET, lpszVerb: LPCSTR, lpszObjectName: LPCSTR, lpszVersion: LPCSTR, lpszReferrer: LPCSTR, lplpszAcceptTypes: ptr LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpOpenRequestW*(hConnect: HINTERNET, lpszVerb: LPCWSTR, lpszObjectName: LPCWSTR, lpszVersion: LPCWSTR, lpszReferrer: LPCWSTR, lplpszAcceptTypes: ptr LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpAddRequestHeadersA*(hRequest: HINTERNET, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, dwModifiers: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpAddRequestHeadersW*(hRequest: HINTERNET, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, dwModifiers: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpSendRequestA*(hRequest: HINTERNET, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, lpOptional: LPVOID, dwOptionalLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpSendRequestW*(hRequest: HINTERNET, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, lpOptional: LPVOID, dwOptionalLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpSendRequestExA*(hRequest: HINTERNET, lpBuffersIn: LPINTERNET_BUFFERSA, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpSendRequestExW*(hRequest: HINTERNET, lpBuffersIn: LPINTERNET_BUFFERSW, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpEndRequestA*(hRequest: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpEndRequestW*(hRequest: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpQueryInfoA*(hRequest: HINTERNET, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD, lpdwIndex: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc HttpQueryInfoW*(hRequest: HINTERNET, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD, lpdwIndex: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetCookieA*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetCookieW*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetCookieA*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPSTR, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetCookieW*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPWSTR, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetCookieExA*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPCSTR, dwFlags: DWORD, dwReserved: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetCookieExW*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetCookieExA*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPSTR, lpdwSize: LPDWORD, dwFlags: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetCookieExW*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPWSTR, lpdwSize: LPDWORD, dwFlags: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetAttemptConnect*(dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCheckConnectionA*(lpszUrl: LPCSTR, dwFlags: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetCheckConnectionW*(lpszUrl: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc ResumeSuspendedDownload*(hRequest: HINTERNET, dwResultCode: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetErrorDlg*(hWnd: HWND, hRequest: HINTERNET, dwError: DWORD, dwFlags: DWORD, lppvData: ptr LPVOID): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetConfirmZoneCrossingA*(hWnd: HWND, szUrlPrev: LPSTR, szUrlNew: LPSTR, bPost: WINBOOL): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetConfirmZoneCrossingW*(hWnd: HWND, szUrlPrev: LPWSTR, szUrlNew: LPWSTR, bPost: WINBOOL): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc CreateUrlCacheEntryA*(lpszUrlName: LPCSTR, dwExpectedFileSize: DWORD, lpszFileExtension: LPCSTR, lpszFileName: LPSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc CreateUrlCacheEntryW*(lpszUrlName: LPCWSTR, dwExpectedFileSize: DWORD, lpszFileExtension: LPCWSTR, lpszFileName: LPWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc CommitUrlCacheEntryA*(lpszUrlName: LPCSTR, lpszLocalFileName: LPCSTR, ExpireTime: FILETIME, LastModifiedTime: FILETIME, CacheEntryType: DWORD, lpHeaderInfo: LPBYTE, dwHeaderSize: DWORD, lpszFileExtension: LPCSTR, lpszOriginalUrl: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc CommitUrlCacheEntryW*(lpszUrlName: LPCWSTR, lpszLocalFileName: LPCWSTR, ExpireTime: FILETIME, LastModifiedTime: FILETIME, CacheEntryType: DWORD, lpszHeaderInfo: LPWSTR, dwHeaders: DWORD, lpszFileExtension: LPCWSTR, lpszOriginalUrl: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc RetrieveUrlCacheEntryFileA*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc RetrieveUrlCacheEntryFileW*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc UnlockUrlCacheEntryFileA*(lpszUrlName: LPCSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc UnlockUrlCacheEntryFileW*(lpszUrlName: LPCWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc RetrieveUrlCacheEntryStreamA*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, fRandomRead: WINBOOL, dwReserved: DWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc RetrieveUrlCacheEntryStreamW*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, fRandomRead: WINBOOL, dwReserved: DWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc ReadUrlCacheEntryStream*(hUrlCacheStream: HANDLE, dwLocation: DWORD, lpBuffer: LPVOID, lpdwLen: LPDWORD, Reserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc UnlockUrlCacheEntryStream*(hUrlCacheStream: HANDLE, Reserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheEntryInfoA*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheEntryInfoW*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindFirstUrlCacheGroup*(dwFlags: DWORD, dwFilter: DWORD, lpSearchCondition: LPVOID, dwSearchCondition: DWORD, lpGroupId: ptr GROUPID, lpReserved: LPVOID): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindNextUrlCacheGroup*(hFind: HANDLE, lpGroupId: ptr GROUPID, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheGroupAttributeA*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, lpdwGroupInfo: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheGroupAttributeW*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, lpdwGroupInfo: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheGroupAttributeA*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheGroupAttributeW*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc CreateUrlCacheGroup*(dwFlags: DWORD, lpReserved: LPVOID): GROUPID {.winapi, stdcall, dynlib: "wininet", importc.} +proc DeleteUrlCacheGroup*(GroupId: GROUPID, dwFlags: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheEntryInfoExA*(lpszUrl: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, lpszRedirectUrl: LPSTR, lpcbRedirectUrl: LPDWORD, lpReserved: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc GetUrlCacheEntryInfoExW*(lpszUrl: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, lpszRedirectUrl: LPWSTR, lpcbRedirectUrl: LPDWORD, lpReserved: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheEntryInfoA*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, dwFieldControl: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheEntryInfoW*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, dwFieldControl: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheEntryGroupA*(lpszUrlName: LPCSTR, dwFlags: DWORD, GroupId: GROUPID, pbGroupAttributes: LPBYTE, cbGroupAttributes: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc SetUrlCacheEntryGroupW*(lpszUrlName: LPCWSTR, dwFlags: DWORD, GroupId: GROUPID, pbGroupAttributes: LPBYTE, cbGroupAttributes: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindFirstUrlCacheEntryExA*(lpszUrlSearchPattern: LPCSTR, dwFlags: DWORD, dwFilter: DWORD, GroupId: GROUPID, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindFirstUrlCacheEntryExW*(lpszUrlSearchPattern: LPCWSTR, dwFlags: DWORD, dwFilter: DWORD, GroupId: GROUPID, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindNextUrlCacheEntryExA*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindNextUrlCacheEntryExW*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindFirstUrlCacheEntryA*(lpszUrlSearchPattern: LPCSTR, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindFirstUrlCacheEntryW*(lpszUrlSearchPattern: LPCWSTR, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindNextUrlCacheEntryA*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindNextUrlCacheEntryW*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc FindCloseUrlCache*(hEnumHandle: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc DeleteUrlCacheEntryA*(lpszUrlName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc DeleteUrlCacheEntryW*(lpszUrlName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetDialA*(hwndParent: HWND, lpszConnectoid: LPSTR, dwFlags: DWORD, lpdwConnection: ptr DWORD_PTR, dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetDialW*(hwndParent: HWND, lpszConnectoid: LPWSTR, dwFlags: DWORD, lpdwConnection: ptr DWORD_PTR, dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetHangUp*(dwConnection: DWORD_PTR, dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGoOnlineA*(lpszURL: LPSTR, hwndParent: HWND, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGoOnlineW*(lpszURL: LPWSTR, hwndParent: HWND, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetAutodial*(dwFlags: DWORD, hwndParent: HWND): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetAutodialHangup*(dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetConnectedState*(lpdwFlags: LPDWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetConnectedStateExA*(lpdwFlags: LPDWORD, lpszConnectionName: LPSTR, dwBufLen: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetConnectedStateExW*(lpdwFlags: LPDWORD, lpszConnectionName: LPWSTR, dwBufLen: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetInitializeAutoProxyDll*(dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc DetectAutoProxyUrl*(lpszAutoProxyUrl: LPSTR, dwAutoProxyUrlLength: DWORD, dwDetectFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc CreateMD5SSOHash*(pszChallengeInfo: PWSTR, pwszRealm: PWSTR, pwszTarget: PWSTR, pbHexHash: PBYTE): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetDialStateA*(lpszConnectoid: LPCSTR, dwState: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetDialStateW*(lpszConnectoid: LPCWSTR, dwState: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetPerSiteCookieDecisionA*(pchHostName: LPCSTR, dwDecision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetSetPerSiteCookieDecisionW*(pchHostName: LPCWSTR, dwDecision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetPerSiteCookieDecisionA*(pchHostName: LPCSTR, pResult: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetGetPerSiteCookieDecisionW*(pchHostName: LPCWSTR, pResult: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetClearAllPerSiteCookieDecisions*(): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetEnumPerSiteCookieDecisionA*(pszSiteName: LPSTR, pcSiteNameSize: ptr int32, pdwDecision: ptr int32, dwIndex: int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc InternetEnumPerSiteCookieDecisionW*(pszSiteName: LPWSTR, pcSiteNameSize: ptr int32, pdwDecision: ptr int32, dwIndex: int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc.} +proc PrivacySetZonePreferenceW*(dwZone: DWORD, dwType: DWORD, dwTemplate: DWORD, pszPreference: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc PrivacyGetZonePreferenceW*(dwZone: DWORD, dwType: DWORD, pdwTemplate: LPDWORD, pszBuffer: LPWSTR, pdwBufferLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc.} +proc `dwReserved=`*(self: var INTERNET_CACHE_ENTRY_INFOA, x: DWORD) {.inline.} = self.union1.dwReserved = x +proc dwReserved*(self: INTERNET_CACHE_ENTRY_INFOA): DWORD {.inline.} = self.union1.dwReserved +proc dwReserved*(self: var INTERNET_CACHE_ENTRY_INFOA): var DWORD {.inline.} = self.union1.dwReserved +proc `dwExemptDelta=`*(self: var INTERNET_CACHE_ENTRY_INFOA, x: DWORD) {.inline.} = self.union1.dwExemptDelta = x +proc dwExemptDelta*(self: INTERNET_CACHE_ENTRY_INFOA): DWORD {.inline.} = self.union1.dwExemptDelta +proc dwExemptDelta*(self: var INTERNET_CACHE_ENTRY_INFOA): var DWORD {.inline.} = self.union1.dwExemptDelta +proc `dwReserved=`*(self: var INTERNET_CACHE_ENTRY_INFOW, x: DWORD) {.inline.} = self.union1.dwReserved = x +proc dwReserved*(self: INTERNET_CACHE_ENTRY_INFOW): DWORD {.inline.} = self.union1.dwReserved +proc dwReserved*(self: var INTERNET_CACHE_ENTRY_INFOW): var DWORD {.inline.} = self.union1.dwReserved +proc `dwExemptDelta=`*(self: var INTERNET_CACHE_ENTRY_INFOW, x: DWORD) {.inline.} = self.union1.dwExemptDelta = x +proc dwExemptDelta*(self: INTERNET_CACHE_ENTRY_INFOW): DWORD {.inline.} = self.union1.dwExemptDelta +proc dwExemptDelta*(self: var INTERNET_CACHE_ENTRY_INFOW): var DWORD {.inline.} = self.union1.dwExemptDelta +when winimUnicode: + type + INTERNET_PER_CONN_OPTION* = INTERNET_PER_CONN_OPTIONW + LPINTERNET_PER_CONN_OPTION* = LPINTERNET_PER_CONN_OPTIONW + INTERNET_PER_CONN_OPTION_LIST* = INTERNET_PER_CONN_OPTION_LISTW + LPINTERNET_PER_CONN_OPTION_LIST* = LPINTERNET_PER_CONN_OPTION_LISTW + URL_COMPONENTS* = URL_COMPONENTSW + LPURL_COMPONENTS* = LPURL_COMPONENTSW + INTERNET_BUFFERS* = INTERNET_BUFFERSW + LPINTERNET_BUFFERS* = LPINTERNET_BUFFERSW + GOPHER_FIND_DATA* = GOPHER_FIND_DATAW + LPGOPHER_FIND_DATA* = LPGOPHER_FIND_DATAW + INTERNET_CACHE_ENTRY_INFO* = INTERNET_CACHE_ENTRY_INFOW + LPINTERNET_CACHE_ENTRY_INFO* = LPINTERNET_CACHE_ENTRY_INFOW + INTERNET_CACHE_GROUP_INFO* = INTERNET_CACHE_GROUP_INFOW + LPINTERNET_CACHE_GROUP_INFO* = LPINTERNET_CACHE_GROUP_INFOW + proc InternetCrackUrl*(lpszUrl: LPCWSTR, dwUrlLength: DWORD, dwFlags: DWORD, lpUrlComponents: LPURL_COMPONENTSW): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCrackUrlW".} + proc InternetCreateUrl*(lpUrlComponents: LPURL_COMPONENTSW, dwFlags: DWORD, lpszUrl: LPWSTR, lpdwUrlLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCreateUrlW".} + proc InternetCanonicalizeUrl*(lpszUrl: LPCWSTR, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCanonicalizeUrlW".} + proc InternetCombineUrl*(lpszBaseUrl: LPCWSTR, lpszRelativeUrl: LPCWSTR, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCombineUrlW".} + proc InternetOpen*(lpszAgent: LPCWSTR, dwAccessType: DWORD, lpszProxy: LPCWSTR, lpszProxyBypass: LPCWSTR, dwFlags: DWORD): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetOpenW".} + proc InternetConnect*(hInternet: HINTERNET, lpszServerName: LPCWSTR, nServerPort: INTERNET_PORT, lpszUserName: LPCWSTR, lpszPassword: LPCWSTR, dwService: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetConnectW".} + proc InternetOpenUrl*(hInternet: HINTERNET, lpszUrl: LPCWSTR, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetOpenUrlW".} + proc InternetReadFileEx*(hFile: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetReadFileExW".} + proc InternetFindNextFile*(hFind: HINTERNET, lpvFindData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetFindNextFileW".} + proc InternetQueryOption*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetQueryOptionW".} + proc InternetSetOption*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetOptionW".} + proc InternetSetOptionEx*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetOptionExW".} + proc InternetGetLastResponseInfo*(lpdwError: LPDWORD, lpszBuffer: LPWSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetLastResponseInfoW".} + proc FtpFindFirstFile*(hConnect: HINTERNET, lpszSearchFile: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "FtpFindFirstFileW".} + proc FtpGetFile*(hConnect: HINTERNET, lpszRemoteFile: LPCWSTR, lpszNewFile: LPCWSTR, fFailIfExists: WINBOOL, dwFlagsAndAttributes: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpGetFileW".} + proc FtpPutFile*(hConnect: HINTERNET, lpszLocalFile: LPCWSTR, lpszNewRemoteFile: LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpPutFileW".} + proc FtpDeleteFile*(hConnect: HINTERNET, lpszFileName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpDeleteFileW".} + proc FtpRenameFile*(hConnect: HINTERNET, lpszExisting: LPCWSTR, lpszNew: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpRenameFileW".} + proc FtpOpenFile*(hConnect: HINTERNET, lpszFileName: LPCWSTR, dwAccess: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "FtpOpenFileW".} + proc FtpCreateDirectory*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpCreateDirectoryW".} + proc FtpRemoveDirectory*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpRemoveDirectoryW".} + proc FtpSetCurrentDirectory*(hConnect: HINTERNET, lpszDirectory: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpSetCurrentDirectoryW".} + proc FtpGetCurrentDirectory*(hConnect: HINTERNET, lpszCurrentDirectory: LPWSTR, lpdwCurrentDirectory: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpGetCurrentDirectoryW".} + proc FtpCommand*(hConnect: HINTERNET, fExpectResponse: WINBOOL, dwFlags: DWORD, lpszCommand: LPCWSTR, dwContext: DWORD_PTR, phFtpCommand: ptr HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpCommandW".} + proc GopherCreateLocator*(lpszHost: LPCWSTR, nServerPort: INTERNET_PORT, lpszDisplayString: LPCWSTR, lpszSelectorString: LPCWSTR, dwGopherType: DWORD, lpszLocator: LPWSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherCreateLocatorW".} + proc GopherGetLocatorType*(lpszLocator: LPCWSTR, lpdwGopherType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherGetLocatorTypeW".} + proc GopherFindFirstFile*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszSearchString: LPCWSTR, lpFindData: LPGOPHER_FIND_DATAW, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "GopherFindFirstFileW".} + proc GopherOpenFile*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszView: LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "GopherOpenFileW".} + proc GopherGetAttribute*(hConnect: HINTERNET, lpszLocator: LPCWSTR, lpszAttributeName: LPCWSTR, lpBuffer: LPBYTE, dwBufferLength: DWORD, lpdwCharactersReturned: LPDWORD, lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherGetAttributeW".} + proc HttpOpenRequest*(hConnect: HINTERNET, lpszVerb: LPCWSTR, lpszObjectName: LPCWSTR, lpszVersion: LPCWSTR, lpszReferrer: LPCWSTR, lplpszAcceptTypes: ptr LPCWSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "HttpOpenRequestW".} + proc HttpAddRequestHeaders*(hRequest: HINTERNET, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, dwModifiers: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpAddRequestHeadersW".} + proc HttpSendRequest*(hRequest: HINTERNET, lpszHeaders: LPCWSTR, dwHeadersLength: DWORD, lpOptional: LPVOID, dwOptionalLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpSendRequestW".} + proc HttpSendRequestEx*(hRequest: HINTERNET, lpBuffersIn: LPINTERNET_BUFFERSW, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpSendRequestExW".} + proc HttpEndRequest*(hRequest: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSW, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpEndRequestW".} + proc HttpQueryInfo*(hRequest: HINTERNET, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD, lpdwIndex: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpQueryInfoW".} + proc InternetSetCookie*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetCookieW".} + proc InternetGetCookie*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPWSTR, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetCookieW".} + proc InternetSetCookieEx*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetCookieExW".} + proc InternetGetCookieEx*(lpszUrl: LPCWSTR, lpszCookieName: LPCWSTR, lpszCookieData: LPWSTR, lpdwSize: LPDWORD, dwFlags: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetCookieExW".} + proc InternetCheckConnection*(lpszUrl: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCheckConnectionW".} + proc CreateUrlCacheEntry*(lpszUrlName: LPCWSTR, dwExpectedFileSize: DWORD, lpszFileExtension: LPCWSTR, lpszFileName: LPWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "CreateUrlCacheEntryW".} + proc CommitUrlCacheEntry*(lpszUrlName: LPCWSTR, lpszLocalFileName: LPCWSTR, ExpireTime: FILETIME, LastModifiedTime: FILETIME, CacheEntryType: DWORD, lpszHeaderInfo: LPWSTR, dwHeaders: DWORD, lpszFileExtension: LPCWSTR, lpszOriginalUrl: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "CommitUrlCacheEntryW".} + proc RetrieveUrlCacheEntryFile*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "RetrieveUrlCacheEntryFileW".} + proc UnlockUrlCacheEntryFile*(lpszUrlName: LPCWSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "UnlockUrlCacheEntryFileW".} + proc RetrieveUrlCacheEntryStream*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, fRandomRead: WINBOOL, dwReserved: DWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "RetrieveUrlCacheEntryStreamW".} + proc GetUrlCacheEntryInfo*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheEntryInfoW".} + proc GetUrlCacheGroupAttribute*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, lpdwGroupInfo: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheGroupAttributeW".} + proc SetUrlCacheGroupAttribute*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheGroupAttributeW".} + proc GetUrlCacheEntryInfoEx*(lpszUrl: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD, lpszRedirectUrl: LPWSTR, lpcbRedirectUrl: LPDWORD, lpReserved: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheEntryInfoExW".} + proc SetUrlCacheEntryInfo*(lpszUrlName: LPCWSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, dwFieldControl: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheEntryInfoW".} + proc FindFirstUrlCacheEntryEx*(lpszUrlSearchPattern: LPCWSTR, dwFlags: DWORD, dwFilter: DWORD, GroupId: GROUPID, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "FindFirstUrlCacheEntryExW".} + proc FindNextUrlCacheEntryEx*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FindNextUrlCacheEntryExW".} + proc FindFirstUrlCacheEntry*(lpszUrlSearchPattern: LPCWSTR, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "FindFirstUrlCacheEntryW".} + proc FindNextUrlCacheEntry*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FindNextUrlCacheEntryW".} + proc InternetSetPerSiteCookieDecision*(pchHostName: LPCWSTR, dwDecision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetPerSiteCookieDecisionW".} + proc InternetGetPerSiteCookieDecision*(pchHostName: LPCWSTR, pResult: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetPerSiteCookieDecisionW".} + proc InternetEnumPerSiteCookieDecision*(pszSiteName: LPWSTR, pcSiteNameSize: ptr int32, pdwDecision: ptr int32, dwIndex: int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetEnumPerSiteCookieDecisionW".} + proc InternetTimeFromSystemTime*(pst: ptr SYSTEMTIME, dwRFC: DWORD, lpszTime: LPWSTR, cbTime: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetTimeFromSystemTimeW".} + proc InternetTimeToSystemTime*(lpszTime: LPCWSTR, pst: ptr SYSTEMTIME, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetTimeToSystemTimeW".} + proc InternetSetStatusCallback*(hInternet: HINTERNET, lpfnInternetCallback: INTERNET_STATUS_CALLBACK): INTERNET_STATUS_CALLBACK {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetStatusCallbackW".} + proc InternetConfirmZoneCrossing*(hWnd: HWND, szUrlPrev: LPWSTR, szUrlNew: LPWSTR, bPost: WINBOOL): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetConfirmZoneCrossingW".} + proc InternetDial*(hwndParent: HWND, lpszConnectoid: LPWSTR, dwFlags: DWORD, lpdwConnection: ptr DWORD_PTR, dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetDialW".} + proc InternetGoOnline*(lpszURL: LPWSTR, hwndParent: HWND, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGoOnlineW".} + proc DeleteUrlCacheEntry*(lpszUrlName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "DeleteUrlCacheEntryW".} + proc SetUrlCacheEntryGroup*(lpszUrlName: LPCWSTR, dwFlags: DWORD, GroupId: GROUPID, pbGroupAttributes: LPBYTE, cbGroupAttributes: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheEntryGroupW".} + proc InternetSetDialState*(lpszConnectoid: LPCWSTR, dwState: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetDialStateW".} + proc InternetGetConnectedStateEx*(lpdwFlags: LPDWORD, lpszConnectionName: LPWSTR, dwBufLen: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetConnectedStateExW".} +when winimAnsi: + type + INTERNET_PER_CONN_OPTION* = INTERNET_PER_CONN_OPTIONA + LPINTERNET_PER_CONN_OPTION* = LPINTERNET_PER_CONN_OPTIONA + INTERNET_PER_CONN_OPTION_LIST* = INTERNET_PER_CONN_OPTION_LISTA + LPINTERNET_PER_CONN_OPTION_LIST* = LPINTERNET_PER_CONN_OPTION_LISTA + URL_COMPONENTS* = URL_COMPONENTSA + LPURL_COMPONENTS* = LPURL_COMPONENTSA + INTERNET_BUFFERS* = INTERNET_BUFFERSA + LPINTERNET_BUFFERS* = LPINTERNET_BUFFERSA + GOPHER_FIND_DATA* = GOPHER_FIND_DATAA + LPGOPHER_FIND_DATA* = LPGOPHER_FIND_DATAA + INTERNET_CACHE_ENTRY_INFO* = INTERNET_CACHE_ENTRY_INFOA + LPINTERNET_CACHE_ENTRY_INFO* = LPINTERNET_CACHE_ENTRY_INFOA + INTERNET_CACHE_GROUP_INFO* = INTERNET_CACHE_GROUP_INFOA + LPINTERNET_CACHE_GROUP_INFO* = LPINTERNET_CACHE_GROUP_INFOA + proc InternetCrackUrl*(lpszUrl: LPCSTR, dwUrlLength: DWORD, dwFlags: DWORD, lpUrlComponents: LPURL_COMPONENTSA): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCrackUrlA".} + proc InternetCreateUrl*(lpUrlComponents: LPURL_COMPONENTSA, dwFlags: DWORD, lpszUrl: LPSTR, lpdwUrlLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCreateUrlA".} + proc InternetCanonicalizeUrl*(lpszUrl: LPCSTR, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCanonicalizeUrlA".} + proc InternetCombineUrl*(lpszBaseUrl: LPCSTR, lpszRelativeUrl: LPCSTR, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCombineUrlA".} + proc InternetOpen*(lpszAgent: LPCSTR, dwAccessType: DWORD, lpszProxy: LPCSTR, lpszProxyBypass: LPCSTR, dwFlags: DWORD): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetOpenA".} + proc InternetConnect*(hInternet: HINTERNET, lpszServerName: LPCSTR, nServerPort: INTERNET_PORT, lpszUserName: LPCSTR, lpszPassword: LPCSTR, dwService: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetConnectA".} + proc InternetOpenUrl*(hInternet: HINTERNET, lpszUrl: LPCSTR, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "InternetOpenUrlA".} + proc InternetReadFileEx*(hFile: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetReadFileExA".} + proc InternetFindNextFile*(hFind: HINTERNET, lpvFindData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetFindNextFileA".} + proc InternetQueryOption*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetQueryOptionA".} + proc InternetSetOption*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetOptionA".} + proc InternetSetOptionEx*(hInternet: HINTERNET, dwOption: DWORD, lpBuffer: LPVOID, dwBufferLength: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetOptionExA".} + proc InternetGetLastResponseInfo*(lpdwError: LPDWORD, lpszBuffer: LPSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetLastResponseInfoA".} + proc FtpFindFirstFile*(hConnect: HINTERNET, lpszSearchFile: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "FtpFindFirstFileA".} + proc FtpGetFile*(hConnect: HINTERNET, lpszRemoteFile: LPCSTR, lpszNewFile: LPCSTR, fFailIfExists: WINBOOL, dwFlagsAndAttributes: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpGetFileA".} + proc FtpPutFile*(hConnect: HINTERNET, lpszLocalFile: LPCSTR, lpszNewRemoteFile: LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpPutFileA".} + proc FtpDeleteFile*(hConnect: HINTERNET, lpszFileName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpDeleteFileA".} + proc FtpRenameFile*(hConnect: HINTERNET, lpszExisting: LPCSTR, lpszNew: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpRenameFileA".} + proc FtpOpenFile*(hConnect: HINTERNET, lpszFileName: LPCSTR, dwAccess: DWORD, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "FtpOpenFileA".} + proc FtpCreateDirectory*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpCreateDirectoryA".} + proc FtpRemoveDirectory*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpRemoveDirectoryA".} + proc FtpSetCurrentDirectory*(hConnect: HINTERNET, lpszDirectory: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpSetCurrentDirectoryA".} + proc FtpGetCurrentDirectory*(hConnect: HINTERNET, lpszCurrentDirectory: LPSTR, lpdwCurrentDirectory: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpGetCurrentDirectoryA".} + proc FtpCommand*(hConnect: HINTERNET, fExpectResponse: WINBOOL, dwFlags: DWORD, lpszCommand: LPCSTR, dwContext: DWORD_PTR, phFtpCommand: ptr HINTERNET): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FtpCommandA".} + proc GopherCreateLocator*(lpszHost: LPCSTR, nServerPort: INTERNET_PORT, lpszDisplayString: LPCSTR, lpszSelectorString: LPCSTR, dwGopherType: DWORD, lpszLocator: LPSTR, lpdwBufferLength: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherCreateLocatorA".} + proc GopherGetLocatorType*(lpszLocator: LPCSTR, lpdwGopherType: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherGetLocatorTypeA".} + proc GopherFindFirstFile*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszSearchString: LPCSTR, lpFindData: LPGOPHER_FIND_DATAA, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "GopherFindFirstFileA".} + proc GopherOpenFile*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszView: LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "GopherOpenFileA".} + proc GopherGetAttribute*(hConnect: HINTERNET, lpszLocator: LPCSTR, lpszAttributeName: LPCSTR, lpBuffer: LPBYTE, dwBufferLength: DWORD, lpdwCharactersReturned: LPDWORD, lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GopherGetAttributeA".} + proc HttpOpenRequest*(hConnect: HINTERNET, lpszVerb: LPCSTR, lpszObjectName: LPCSTR, lpszVersion: LPCSTR, lpszReferrer: LPCSTR, lplpszAcceptTypes: ptr LPCSTR, dwFlags: DWORD, dwContext: DWORD_PTR): HINTERNET {.winapi, stdcall, dynlib: "wininet", importc: "HttpOpenRequestA".} + proc HttpAddRequestHeaders*(hRequest: HINTERNET, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, dwModifiers: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpAddRequestHeadersA".} + proc HttpSendRequest*(hRequest: HINTERNET, lpszHeaders: LPCSTR, dwHeadersLength: DWORD, lpOptional: LPVOID, dwOptionalLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpSendRequestA".} + proc HttpSendRequestEx*(hRequest: HINTERNET, lpBuffersIn: LPINTERNET_BUFFERSA, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpSendRequestExA".} + proc HttpEndRequest*(hRequest: HINTERNET, lpBuffersOut: LPINTERNET_BUFFERSA, dwFlags: DWORD, dwContext: DWORD_PTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpEndRequestA".} + proc HttpQueryInfo*(hRequest: HINTERNET, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpdwBufferLength: LPDWORD, lpdwIndex: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "HttpQueryInfoA".} + proc InternetSetCookie*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetCookieA".} + proc InternetGetCookie*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPSTR, lpdwSize: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetCookieA".} + proc InternetSetCookieEx*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPCSTR, dwFlags: DWORD, dwReserved: DWORD_PTR): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetCookieExA".} + proc InternetGetCookieEx*(lpszUrl: LPCSTR, lpszCookieName: LPCSTR, lpszCookieData: LPSTR, lpdwSize: LPDWORD, dwFlags: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetCookieExA".} + proc InternetCheckConnection*(lpszUrl: LPCSTR, dwFlags: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetCheckConnectionA".} + proc CreateUrlCacheEntry*(lpszUrlName: LPCSTR, dwExpectedFileSize: DWORD, lpszFileExtension: LPCSTR, lpszFileName: LPSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "CreateUrlCacheEntryA".} + proc CommitUrlCacheEntry*(lpszUrlName: LPCSTR, lpszLocalFileName: LPCSTR, ExpireTime: FILETIME, LastModifiedTime: FILETIME, CacheEntryType: DWORD, lpHeaderInfo: LPBYTE, dwHeaderSize: DWORD, lpszFileExtension: LPCSTR, lpszOriginalUrl: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "CommitUrlCacheEntryA".} + proc RetrieveUrlCacheEntryFile*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "RetrieveUrlCacheEntryFileA".} + proc UnlockUrlCacheEntryFile*(lpszUrlName: LPCSTR, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "UnlockUrlCacheEntryFileA".} + proc RetrieveUrlCacheEntryStream*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, fRandomRead: WINBOOL, dwReserved: DWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "RetrieveUrlCacheEntryStreamA".} + proc GetUrlCacheEntryInfo*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheEntryInfoA".} + proc GetUrlCacheGroupAttribute*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, lpdwGroupInfo: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheGroupAttributeA".} + proc SetUrlCacheGroupAttribute*(gid: GROUPID, dwFlags: DWORD, dwAttributes: DWORD, lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheGroupAttributeA".} + proc GetUrlCacheEntryInfoEx*(lpszUrl: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD, lpszRedirectUrl: LPSTR, lpcbRedirectUrl: LPDWORD, lpReserved: LPVOID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "GetUrlCacheEntryInfoExA".} + proc SetUrlCacheEntryInfo*(lpszUrlName: LPCSTR, lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, dwFieldControl: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheEntryInfoA".} + proc FindFirstUrlCacheEntryEx*(lpszUrlSearchPattern: LPCSTR, dwFlags: DWORD, dwFilter: DWORD, GroupId: GROUPID, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "FindFirstUrlCacheEntryExA".} + proc FindNextUrlCacheEntryEx*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbEntryInfo: LPDWORD, lpGroupAttributes: LPVOID, lpcbGroupAttributes: LPDWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FindNextUrlCacheEntryExA".} + proc FindFirstUrlCacheEntry*(lpszUrlSearchPattern: LPCSTR, lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): HANDLE {.winapi, stdcall, dynlib: "wininet", importc: "FindFirstUrlCacheEntryA".} + proc FindNextUrlCacheEntry*(hEnumHandle: HANDLE, lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, lpcbCacheEntryInfo: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "FindNextUrlCacheEntryA".} + proc InternetSetPerSiteCookieDecision*(pchHostName: LPCSTR, dwDecision: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetPerSiteCookieDecisionA".} + proc InternetGetPerSiteCookieDecision*(pchHostName: LPCSTR, pResult: ptr int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetPerSiteCookieDecisionA".} + proc InternetEnumPerSiteCookieDecision*(pszSiteName: LPSTR, pcSiteNameSize: ptr int32, pdwDecision: ptr int32, dwIndex: int32): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetEnumPerSiteCookieDecisionA".} + proc InternetTimeFromSystemTime*(pst: ptr SYSTEMTIME, dwRFC: DWORD, lpszTime: LPSTR, cbTime: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetTimeFromSystemTimeA".} + proc InternetTimeToSystemTime*(lpszTime: LPCSTR, pst: ptr SYSTEMTIME, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetTimeToSystemTimeA".} + proc InternetSetStatusCallback*(hInternet: HINTERNET, lpfnInternetCallback: INTERNET_STATUS_CALLBACK): INTERNET_STATUS_CALLBACK {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetStatusCallbackA".} + proc InternetConfirmZoneCrossing*(hWnd: HWND, szUrlPrev: LPSTR, szUrlNew: LPSTR, bPost: WINBOOL): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetConfirmZoneCrossingA".} + proc InternetDial*(hwndParent: HWND, lpszConnectoid: LPSTR, dwFlags: DWORD, lpdwConnection: ptr DWORD_PTR, dwReserved: DWORD): DWORD {.winapi, stdcall, dynlib: "wininet", importc: "InternetDialA".} + proc InternetGoOnline*(lpszURL: LPSTR, hwndParent: HWND, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGoOnlineA".} + proc DeleteUrlCacheEntry*(lpszUrlName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "DeleteUrlCacheEntryA".} + proc SetUrlCacheEntryGroup*(lpszUrlName: LPCSTR, dwFlags: DWORD, GroupId: GROUPID, pbGroupAttributes: LPBYTE, cbGroupAttributes: DWORD, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "SetUrlCacheEntryGroupA".} + proc InternetSetDialState*(lpszConnectoid: LPCSTR, dwState: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetSetDialStateA".} + proc InternetGetConnectedStateEx*(lpdwFlags: LPDWORD, lpszConnectionName: LPSTR, dwBufLen: DWORD, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wininet", importc: "InternetGetConnectedStateExA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winioctl.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winioctl.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,2034 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + STORAGE_MEDIA_TYPE* = int32 + PSTORAGE_MEDIA_TYPE* = ptr int32 + STORAGE_BUS_TYPE* = int32 + PSTORAGE_BUS_TYPE* = ptr int32 + MEDIA_TYPE* = int32 + PMEDIA_TYPE* = ptr int32 + PARTITION_STYLE* = int32 + DETECTION_TYPE* = int32 + DISK_CACHE_RETENTION_PRIORITY* = int32 + BIN_TYPES* = int32 + ELEMENT_TYPE* = int32 + PELEMENT_TYPE* = ptr int32 + CHANGER_DEVICE_PROBLEM_TYPE* = int32 + PCHANGER_DEVICE_PROBLEM_TYPE* = ptr int32 + STORAGE_PROPERTY_ID* = int32 + PSTORAGE_PROPERTY_ID* = ptr int32 + STORAGE_QUERY_TYPE* = int32 + PSTORAGE_QUERY_TYPE* = ptr int32 + SHRINK_VOLUME_REQUEST_TYPES* = int32 + WRITE_CACHE_TYPE* = int32 + WRITE_CACHE_ENABLE* = int32 + WRITE_CACHE_CHANGE* = int32 + WRITE_THROUGH* = int32 + STORAGE_PORT_CODE_SET* = int32 + PSTORAGE_PORT_CODE_SET* = ptr int32 + DEVICE_DATA_MANAGEMENT_SET_ACTION* = DWORD + BAD_TRACK_NUMBER* = WORD + PBAD_TRACK_NUMBER* = ptr WORD + STORAGE_READ_CAPACITY* {.pure.} = object + Version*: ULONG + Size*: ULONG + BlockLength*: ULONG + NumberOfBlocks*: LARGE_INTEGER + DiskLength*: LARGE_INTEGER + PSTORAGE_READ_CAPACITY* = ptr STORAGE_READ_CAPACITY + DEVICE_MANAGE_DATA_SET_ATTRIBUTES* {.pure.} = object + Size*: DWORD + Action*: DEVICE_DATA_MANAGEMENT_SET_ACTION + Flags*: DWORD + ParameterBlockOffset*: DWORD + ParameterBlockLength*: DWORD + DataSetRangesOffset*: DWORD + DataSetRangesLength*: DWORD + PDEVICE_MANAGE_DATA_SET_ATTRIBUTES* = ptr DEVICE_MANAGE_DATA_SET_ATTRIBUTES + DEVICE_DATA_SET_RANGE* {.pure.} = object + StartingOffset*: LONGLONG + LengthInBytes*: DWORDLONG + PDEVICE_DATA_SET_RANGE* = ptr DEVICE_DATA_SET_RANGE + STORAGE_HOTPLUG_INFO* {.pure.} = object + Size*: DWORD + MediaRemovable*: BOOLEAN + MediaHotplug*: BOOLEAN + DeviceHotplug*: BOOLEAN + WriteCacheEnableOverride*: BOOLEAN + PSTORAGE_HOTPLUG_INFO* = ptr STORAGE_HOTPLUG_INFO + STORAGE_DEVICE_NUMBER* {.pure.} = object + DeviceType*: DEVICE_TYPE + DeviceNumber*: DWORD + PartitionNumber*: DWORD + PSTORAGE_DEVICE_NUMBER* = ptr STORAGE_DEVICE_NUMBER + STORAGE_BUS_RESET_REQUEST* {.pure.} = object + PathId*: BYTE + PSTORAGE_BUS_RESET_REQUEST* = ptr STORAGE_BUS_RESET_REQUEST + STORAGE_BREAK_RESERVATION_REQUEST* {.pure.} = object + Length*: DWORD + unused*: BYTE + PathId*: BYTE + TargetId*: BYTE + Lun*: BYTE + PSTORAGE_BREAK_RESERVATION_REQUEST* = ptr STORAGE_BREAK_RESERVATION_REQUEST + PREVENT_MEDIA_REMOVAL* {.pure.} = object + PreventMediaRemoval*: BOOLEAN + PPREVENT_MEDIA_REMOVAL* = ptr PREVENT_MEDIA_REMOVAL + CLASS_MEDIA_CHANGE_CONTEXT* {.pure.} = object + MediaChangeCount*: DWORD + NewState*: DWORD + PCLASS_MEDIA_CHANGE_CONTEXT* = ptr CLASS_MEDIA_CHANGE_CONTEXT + TAPE_STATISTICS* {.pure.} = object + Version*: DWORD + Flags*: DWORD + RecoveredWrites*: LARGE_INTEGER + UnrecoveredWrites*: LARGE_INTEGER + RecoveredReads*: LARGE_INTEGER + UnrecoveredReads*: LARGE_INTEGER + CompressionRatioReads*: BYTE + CompressionRatioWrites*: BYTE + PTAPE_STATISTICS* = ptr TAPE_STATISTICS + TAPE_GET_STATISTICS* {.pure.} = object + Operation*: DWORD + PTAPE_GET_STATISTICS* = ptr TAPE_GET_STATISTICS + DEVICE_MEDIA_INFO_DeviceSpecific_DiskInfo* {.pure.} = object + Cylinders*: LARGE_INTEGER + MediaType*: STORAGE_MEDIA_TYPE + TracksPerCylinder*: DWORD + SectorsPerTrack*: DWORD + BytesPerSector*: DWORD + NumberMediaSides*: DWORD + MediaCharacteristics*: DWORD + DEVICE_MEDIA_INFO_DeviceSpecific_RemovableDiskInfo* {.pure.} = object + Cylinders*: LARGE_INTEGER + MediaType*: STORAGE_MEDIA_TYPE + TracksPerCylinder*: DWORD + SectorsPerTrack*: DWORD + BytesPerSector*: DWORD + NumberMediaSides*: DWORD + MediaCharacteristics*: DWORD + DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo_BusSpecificData_ScsiInformation* {.pure.} = object + MediumType*: BYTE + DensityCode*: BYTE + DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo_BusSpecificData* {.pure, union.} = object + ScsiInformation*: DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo_BusSpecificData_ScsiInformation + DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo* {.pure.} = object + MediaType*: STORAGE_MEDIA_TYPE + MediaCharacteristics*: DWORD + CurrentBlockSize*: DWORD + BusType*: STORAGE_BUS_TYPE + BusSpecificData*: DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo_BusSpecificData + DEVICE_MEDIA_INFO_DeviceSpecific* {.pure, union.} = object + DiskInfo*: DEVICE_MEDIA_INFO_DeviceSpecific_DiskInfo + RemovableDiskInfo*: DEVICE_MEDIA_INFO_DeviceSpecific_RemovableDiskInfo + TapeInfo*: DEVICE_MEDIA_INFO_DeviceSpecific_TapeInfo + DEVICE_MEDIA_INFO* {.pure.} = object + DeviceSpecific*: DEVICE_MEDIA_INFO_DeviceSpecific + PDEVICE_MEDIA_INFO* = ptr DEVICE_MEDIA_INFO + GET_MEDIA_TYPES* {.pure.} = object + DeviceType*: DWORD + MediaInfoCount*: DWORD + MediaInfo*: array[1, DEVICE_MEDIA_INFO] + PGET_MEDIA_TYPES* = ptr GET_MEDIA_TYPES + STORAGE_PREDICT_FAILURE* {.pure.} = object + PredictFailure*: DWORD + VendorSpecific*: array[512, BYTE] + PSTORAGE_PREDICT_FAILURE* = ptr STORAGE_PREDICT_FAILURE + FORMAT_PARAMETERS* {.pure.} = object + MediaType*: MEDIA_TYPE + StartCylinderNumber*: DWORD + EndCylinderNumber*: DWORD + StartHeadNumber*: DWORD + EndHeadNumber*: DWORD + PFORMAT_PARAMETERS* = ptr FORMAT_PARAMETERS + FORMAT_EX_PARAMETERS* {.pure.} = object + MediaType*: MEDIA_TYPE + StartCylinderNumber*: DWORD + EndCylinderNumber*: DWORD + StartHeadNumber*: DWORD + EndHeadNumber*: DWORD + FormatGapLength*: WORD + SectorsPerTrack*: WORD + SectorNumber*: array[1, WORD] + PFORMAT_EX_PARAMETERS* = ptr FORMAT_EX_PARAMETERS + DISK_GEOMETRY* {.pure.} = object + Cylinders*: LARGE_INTEGER + MediaType*: MEDIA_TYPE + TracksPerCylinder*: DWORD + SectorsPerTrack*: DWORD + BytesPerSector*: DWORD + PDISK_GEOMETRY* = ptr DISK_GEOMETRY + PARTITION_INFORMATION* {.pure.} = object + StartingOffset*: LARGE_INTEGER + PartitionLength*: LARGE_INTEGER + HiddenSectors*: DWORD + PartitionNumber*: DWORD + PartitionType*: BYTE + BootIndicator*: BOOLEAN + RecognizedPartition*: BOOLEAN + RewritePartition*: BOOLEAN + PPARTITION_INFORMATION* = ptr PARTITION_INFORMATION + SET_PARTITION_INFORMATION* {.pure.} = object + PartitionType*: BYTE + PSET_PARTITION_INFORMATION* = ptr SET_PARTITION_INFORMATION + DRIVE_LAYOUT_INFORMATION* {.pure.} = object + PartitionCount*: DWORD + Signature*: DWORD + PartitionEntry*: array[1, PARTITION_INFORMATION] + PDRIVE_LAYOUT_INFORMATION* = ptr DRIVE_LAYOUT_INFORMATION + VERIFY_INFORMATION* {.pure.} = object + StartingOffset*: LARGE_INTEGER + Length*: DWORD + PVERIFY_INFORMATION* = ptr VERIFY_INFORMATION + REASSIGN_BLOCKS* {.pure.} = object + Reserved*: WORD + Count*: WORD + BlockNumber*: array[1, DWORD] + PREASSIGN_BLOCKS* = ptr REASSIGN_BLOCKS + REASSIGN_BLOCKS_EX* {.pure, packed.} = object + Reserved*: WORD + Count*: WORD + BlockNumber*: array[1, LARGE_INTEGER] + PREASSIGN_BLOCKS_EX* = ptr REASSIGN_BLOCKS_EX + PARTITION_INFORMATION_GPT* {.pure.} = object + PartitionType*: GUID + PartitionId*: GUID + Attributes*: DWORD64 + Name*: array[36, WCHAR] + PPARTITION_INFORMATION_GPT* = ptr PARTITION_INFORMATION_GPT + PARTITION_INFORMATION_MBR* {.pure.} = object + PartitionType*: BYTE + BootIndicator*: BOOLEAN + RecognizedPartition*: BOOLEAN + HiddenSectors*: DWORD + PPARTITION_INFORMATION_MBR* = ptr PARTITION_INFORMATION_MBR + SET_PARTITION_INFORMATION_MBR* = SET_PARTITION_INFORMATION + SET_PARTITION_INFORMATION_GPT* = PARTITION_INFORMATION_GPT + SET_PARTITION_INFORMATION_EX_UNION1* {.pure, union.} = object + Mbr*: SET_PARTITION_INFORMATION_MBR + Gpt*: SET_PARTITION_INFORMATION_GPT + SET_PARTITION_INFORMATION_EX* {.pure.} = object + PartitionStyle*: PARTITION_STYLE + union1*: SET_PARTITION_INFORMATION_EX_UNION1 + PSET_PARTITION_INFORMATION_EX* = ptr SET_PARTITION_INFORMATION_EX + CREATE_DISK_GPT* {.pure.} = object + DiskId*: GUID + MaxPartitionCount*: DWORD + PCREATE_DISK_GPT* = ptr CREATE_DISK_GPT + CREATE_DISK_MBR* {.pure.} = object + Signature*: DWORD + PCREATE_DISK_MBR* = ptr CREATE_DISK_MBR + CREATE_DISK_UNION1* {.pure, union.} = object + Mbr*: CREATE_DISK_MBR + Gpt*: CREATE_DISK_GPT + CREATE_DISK* {.pure.} = object + PartitionStyle*: PARTITION_STYLE + union1*: CREATE_DISK_UNION1 + PCREATE_DISK* = ptr CREATE_DISK + GET_LENGTH_INFORMATION* {.pure.} = object + Length*: LARGE_INTEGER + PGET_LENGTH_INFORMATION* = ptr GET_LENGTH_INFORMATION + PARTITION_INFORMATION_EX_UNION1* {.pure, union.} = object + Mbr*: PARTITION_INFORMATION_MBR + Gpt*: PARTITION_INFORMATION_GPT + PARTITION_INFORMATION_EX* {.pure.} = object + PartitionStyle*: PARTITION_STYLE + StartingOffset*: LARGE_INTEGER + PartitionLength*: LARGE_INTEGER + PartitionNumber*: DWORD + RewritePartition*: BOOLEAN + union1*: PARTITION_INFORMATION_EX_UNION1 + PPARTITION_INFORMATION_EX* = ptr PARTITION_INFORMATION_EX + DRIVE_LAYOUT_INFORMATION_GPT* {.pure.} = object + DiskId*: GUID + StartingUsableOffset*: LARGE_INTEGER + UsableLength*: LARGE_INTEGER + MaxPartitionCount*: DWORD + PDRIVE_LAYOUT_INFORMATION_GPT* = ptr DRIVE_LAYOUT_INFORMATION_GPT + DRIVE_LAYOUT_INFORMATION_MBR* {.pure.} = object + Signature*: DWORD + PDRIVE_LAYOUT_INFORMATION_MBR* = ptr DRIVE_LAYOUT_INFORMATION_MBR + DRIVE_LAYOUT_INFORMATION_EX_UNION1* {.pure, union.} = object + Mbr*: DRIVE_LAYOUT_INFORMATION_MBR + Gpt*: DRIVE_LAYOUT_INFORMATION_GPT + DRIVE_LAYOUT_INFORMATION_EX* {.pure.} = object + PartitionStyle*: DWORD + PartitionCount*: DWORD + union1*: DRIVE_LAYOUT_INFORMATION_EX_UNION1 + PartitionEntry*: array[1, PARTITION_INFORMATION_EX] + PDRIVE_LAYOUT_INFORMATION_EX* = ptr DRIVE_LAYOUT_INFORMATION_EX + DISK_INT13_INFO* {.pure.} = object + DriveSelect*: WORD + MaxCylinders*: DWORD + SectorsPerTrack*: WORD + MaxHeads*: WORD + NumberDrives*: WORD + PDISK_INT13_INFO* = ptr DISK_INT13_INFO + DISK_EX_INT13_INFO* {.pure.} = object + ExBufferSize*: WORD + ExFlags*: WORD + ExCylinders*: DWORD + ExHeads*: DWORD + ExSectorsPerTrack*: DWORD + ExSectorsPerDrive*: DWORD64 + ExSectorSize*: WORD + ExReserved*: WORD + PDISK_EX_INT13_INFO* = ptr DISK_EX_INT13_INFO + DISK_DETECTION_INFO_UNION1_STRUCT1* {.pure.} = object + Int13*: DISK_INT13_INFO + ExInt13*: DISK_EX_INT13_INFO + DISK_DETECTION_INFO_UNION1* {.pure, union.} = object + struct1*: DISK_DETECTION_INFO_UNION1_STRUCT1 + DISK_DETECTION_INFO* {.pure.} = object + SizeOfDetectInfo*: DWORD + DetectionType*: DETECTION_TYPE + union1*: DISK_DETECTION_INFO_UNION1 + PDISK_DETECTION_INFO* = ptr DISK_DETECTION_INFO + DISK_PARTITION_INFO_UNION1_Mbr* {.pure.} = object + Signature*: DWORD + CheckSum*: DWORD + DISK_PARTITION_INFO_UNION1_Gpt* {.pure.} = object + DiskId*: GUID + DISK_PARTITION_INFO_UNION1* {.pure, union.} = object + Mbr*: DISK_PARTITION_INFO_UNION1_Mbr + Gpt*: DISK_PARTITION_INFO_UNION1_Gpt + DISK_PARTITION_INFO* {.pure.} = object + SizeOfPartitionInfo*: DWORD + PartitionStyle*: PARTITION_STYLE + union1*: DISK_PARTITION_INFO_UNION1 + PDISK_PARTITION_INFO* = ptr DISK_PARTITION_INFO + DISK_GEOMETRY_EX* {.pure.} = object + Geometry*: DISK_GEOMETRY + DiskSize*: LARGE_INTEGER + Data*: array[1, BYTE] + PDISK_GEOMETRY_EX* = ptr DISK_GEOMETRY_EX + DISK_CONTROLLER_NUMBER* {.pure.} = object + ControllerNumber*: DWORD + DiskNumber*: DWORD + PDISK_CONTROLLER_NUMBER* = ptr DISK_CONTROLLER_NUMBER + DISK_CACHE_INFORMATION_UNION1_ScalarPrefetch* {.pure.} = object + Minimum*: WORD + Maximum*: WORD + MaximumBlocks*: WORD + DISK_CACHE_INFORMATION_UNION1_BlockPrefetch* {.pure.} = object + Minimum*: WORD + Maximum*: WORD + DISK_CACHE_INFORMATION_UNION1* {.pure, union.} = object + ScalarPrefetch*: DISK_CACHE_INFORMATION_UNION1_ScalarPrefetch + BlockPrefetch*: DISK_CACHE_INFORMATION_UNION1_BlockPrefetch + DISK_CACHE_INFORMATION* {.pure.} = object + ParametersSavable*: BOOLEAN + ReadCacheEnabled*: BOOLEAN + WriteCacheEnabled*: BOOLEAN + ReadRetentionPriority*: DISK_CACHE_RETENTION_PRIORITY + WriteRetentionPriority*: DISK_CACHE_RETENTION_PRIORITY + DisablePrefetchTransferLength*: WORD + PrefetchScalar*: BOOLEAN + union1*: DISK_CACHE_INFORMATION_UNION1 + PDISK_CACHE_INFORMATION* = ptr DISK_CACHE_INFORMATION + DISK_GROW_PARTITION* {.pure.} = object + PartitionNumber*: DWORD + BytesToGrow*: LARGE_INTEGER + PDISK_GROW_PARTITION* = ptr DISK_GROW_PARTITION + HISTOGRAM_BUCKET* {.pure.} = object + Reads*: DWORD + Writes*: DWORD + PHISTOGRAM_BUCKET* = ptr HISTOGRAM_BUCKET + DISK_HISTOGRAM* {.pure.} = object + DiskSize*: LARGE_INTEGER + Start*: LARGE_INTEGER + End*: LARGE_INTEGER + Average*: LARGE_INTEGER + AverageRead*: LARGE_INTEGER + AverageWrite*: LARGE_INTEGER + Granularity*: DWORD + Size*: DWORD + ReadCount*: DWORD + WriteCount*: DWORD + Histogram*: PHISTOGRAM_BUCKET + PDISK_HISTOGRAM* = ptr DISK_HISTOGRAM + DISK_PERFORMANCE* {.pure.} = object + BytesRead*: LARGE_INTEGER + BytesWritten*: LARGE_INTEGER + ReadTime*: LARGE_INTEGER + WriteTime*: LARGE_INTEGER + IdleTime*: LARGE_INTEGER + ReadCount*: DWORD + WriteCount*: DWORD + QueueDepth*: DWORD + SplitCount*: DWORD + QueryTime*: LARGE_INTEGER + StorageDeviceNumber*: DWORD + StorageManagerName*: array[8, WCHAR] + PDISK_PERFORMANCE* = ptr DISK_PERFORMANCE + DISK_RECORD* {.pure.} = object + ByteOffset*: LARGE_INTEGER + StartTime*: LARGE_INTEGER + EndTime*: LARGE_INTEGER + VirtualAddress*: PVOID + NumberOfBytes*: DWORD + DeviceNumber*: BYTE + ReadRequest*: BOOLEAN + PDISK_RECORD* = ptr DISK_RECORD + DISK_LOGGING* {.pure.} = object + Function*: BYTE + BufferAddress*: PVOID + BufferSize*: DWORD + PDISK_LOGGING* = ptr DISK_LOGGING + BIN_RANGE* {.pure.} = object + StartValue*: LARGE_INTEGER + Length*: LARGE_INTEGER + PBIN_RANGE* = ptr BIN_RANGE + PERF_BIN* {.pure.} = object + NumberOfBins*: DWORD + TypeOfBin*: DWORD + BinsRanges*: array[1, BIN_RANGE] + PPERF_BIN* = ptr PERF_BIN + BIN_COUNT* {.pure.} = object + BinRange*: BIN_RANGE + BinCount*: DWORD + PBIN_COUNT* = ptr BIN_COUNT + BIN_RESULTS* {.pure.} = object + NumberOfBins*: DWORD + BinCounts*: array[1, BIN_COUNT] + PBIN_RESULTS* = ptr BIN_RESULTS + GETVERSIONINPARAMS* {.pure.} = object + bVersion*: BYTE + bRevision*: BYTE + bReserved*: BYTE + bIDEDeviceMap*: BYTE + fCapabilities*: DWORD + dwReserved*: array[4, DWORD] + PGETVERSIONINPARAMS* = ptr GETVERSIONINPARAMS + LPGETVERSIONINPARAMS* = ptr GETVERSIONINPARAMS + IDEREGS* {.pure.} = object + bFeaturesReg*: BYTE + bSectorCountReg*: BYTE + bSectorNumberReg*: BYTE + bCylLowReg*: BYTE + bCylHighReg*: BYTE + bDriveHeadReg*: BYTE + bCommandReg*: BYTE + bReserved*: BYTE + PIDEREGS* = ptr IDEREGS + LPIDEREGS* = ptr IDEREGS + SENDCMDINPARAMS* {.pure, packed.} = object + cBufferSize*: DWORD + irDriveRegs*: IDEREGS + bDriveNumber*: BYTE + bReserved*: array[3, BYTE] + dwReserved*: array[4, DWORD] + bBuffer*: array[1, BYTE] + PSENDCMDINPARAMS* = ptr SENDCMDINPARAMS + LPSENDCMDINPARAMS* = ptr SENDCMDINPARAMS + DRIVERSTATUS* {.pure.} = object + bDriverError*: BYTE + bIDEError*: BYTE + bReserved*: array[2, BYTE] + dwReserved*: array[2, DWORD] + PDRIVERSTATUS* = ptr DRIVERSTATUS + LPDRIVERSTATUS* = ptr DRIVERSTATUS + SENDCMDOUTPARAMS* {.pure, packed.} = object + cBufferSize*: DWORD + DriverStatus*: DRIVERSTATUS + bBuffer*: array[1, BYTE] + PSENDCMDOUTPARAMS* = ptr SENDCMDOUTPARAMS + LPSENDCMDOUTPARAMS* = ptr SENDCMDOUTPARAMS + CHANGER_ELEMENT* {.pure.} = object + ElementType*: ELEMENT_TYPE + ElementAddress*: DWORD + PCHANGER_ELEMENT* = ptr CHANGER_ELEMENT + CHANGER_ELEMENT_LIST* {.pure.} = object + Element*: CHANGER_ELEMENT + NumberOfElements*: DWORD + PCHANGER_ELEMENT_LIST* = ptr CHANGER_ELEMENT_LIST + GET_CHANGER_PARAMETERS* {.pure.} = object + Size*: DWORD + NumberTransportElements*: WORD + NumberStorageElements*: WORD + NumberCleanerSlots*: WORD + NumberIEElements*: WORD + NumberDataTransferElements*: WORD + NumberOfDoors*: WORD + FirstSlotNumber*: WORD + FirstDriveNumber*: WORD + FirstTransportNumber*: WORD + FirstIEPortNumber*: WORD + FirstCleanerSlotAddress*: WORD + MagazineSize*: WORD + DriveCleanTimeout*: DWORD + Features0*: DWORD + Features1*: DWORD + MoveFromTransport*: BYTE + MoveFromSlot*: BYTE + MoveFromIePort*: BYTE + MoveFromDrive*: BYTE + ExchangeFromTransport*: BYTE + ExchangeFromSlot*: BYTE + ExchangeFromIePort*: BYTE + ExchangeFromDrive*: BYTE + LockUnlockCapabilities*: BYTE + PositionCapabilities*: BYTE + Reserved1*: array[2, BYTE] + Reserved2*: array[2, DWORD] + PGET_CHANGER_PARAMETERS* = ptr GET_CHANGER_PARAMETERS +const + VENDOR_ID_LENGTH* = 8 + PRODUCT_ID_LENGTH* = 16 + REVISION_LENGTH* = 4 + SERIAL_NUMBER_LENGTH* = 32 +type + CHANGER_PRODUCT_DATA* {.pure.} = object + VendorId*: array[VENDOR_ID_LENGTH, BYTE] + ProductId*: array[PRODUCT_ID_LENGTH, BYTE] + Revision*: array[REVISION_LENGTH, BYTE] + SerialNumber*: array[SERIAL_NUMBER_LENGTH, BYTE] + DeviceType*: BYTE + PCHANGER_PRODUCT_DATA* = ptr CHANGER_PRODUCT_DATA + CHANGER_SET_ACCESS* {.pure.} = object + Element*: CHANGER_ELEMENT + Control*: DWORD + PCHANGER_SET_ACCESS* = ptr CHANGER_SET_ACCESS + CHANGER_READ_ELEMENT_STATUS* {.pure.} = object + ElementList*: CHANGER_ELEMENT_LIST + VolumeTagInfo*: BOOLEAN + PCHANGER_READ_ELEMENT_STATUS* = ptr CHANGER_READ_ELEMENT_STATUS +const + MAX_VOLUME_ID_SIZE* = 36 +type + CHANGER_ELEMENT_STATUS* {.pure.} = object + Element*: CHANGER_ELEMENT + SrcElementAddress*: CHANGER_ELEMENT + Flags*: DWORD + ExceptionCode*: DWORD + TargetId*: BYTE + Lun*: BYTE + Reserved*: WORD + PrimaryVolumeID*: array[MAX_VOLUME_ID_SIZE, BYTE] + AlternateVolumeID*: array[MAX_VOLUME_ID_SIZE, BYTE] + PCHANGER_ELEMENT_STATUS* = ptr CHANGER_ELEMENT_STATUS + CHANGER_ELEMENT_STATUS_EX* {.pure.} = object + Element*: CHANGER_ELEMENT + SrcElementAddress*: CHANGER_ELEMENT + Flags*: DWORD + ExceptionCode*: DWORD + TargetId*: BYTE + Lun*: BYTE + Reserved*: WORD + PrimaryVolumeID*: array[MAX_VOLUME_ID_SIZE, BYTE] + AlternateVolumeID*: array[MAX_VOLUME_ID_SIZE, BYTE] + VendorIdentification*: array[VENDOR_ID_LENGTH, BYTE] + ProductIdentification*: array[PRODUCT_ID_LENGTH, BYTE] + SerialNumber*: array[SERIAL_NUMBER_LENGTH, BYTE] + PCHANGER_ELEMENT_STATUS_EX* = ptr CHANGER_ELEMENT_STATUS_EX + CHANGER_INITIALIZE_ELEMENT_STATUS* {.pure.} = object + ElementList*: CHANGER_ELEMENT_LIST + BarCodeScan*: BOOLEAN + PCHANGER_INITIALIZE_ELEMENT_STATUS* = ptr CHANGER_INITIALIZE_ELEMENT_STATUS + CHANGER_SET_POSITION* {.pure.} = object + Transport*: CHANGER_ELEMENT + Destination*: CHANGER_ELEMENT + Flip*: BOOLEAN + PCHANGER_SET_POSITION* = ptr CHANGER_SET_POSITION + CHANGER_EXCHANGE_MEDIUM* {.pure.} = object + Transport*: CHANGER_ELEMENT + Source*: CHANGER_ELEMENT + Destination1*: CHANGER_ELEMENT + Destination2*: CHANGER_ELEMENT + Flip1*: BOOLEAN + Flip2*: BOOLEAN + PCHANGER_EXCHANGE_MEDIUM* = ptr CHANGER_EXCHANGE_MEDIUM + CHANGER_MOVE_MEDIUM* {.pure.} = object + Transport*: CHANGER_ELEMENT + Source*: CHANGER_ELEMENT + Destination*: CHANGER_ELEMENT + Flip*: BOOLEAN + PCHANGER_MOVE_MEDIUM* = ptr CHANGER_MOVE_MEDIUM +const + MAX_VOLUME_TEMPLATE_SIZE* = 40 +type + CHANGER_SEND_VOLUME_TAG_INFORMATION* {.pure.} = object + StartingElement*: CHANGER_ELEMENT + ActionCode*: DWORD + VolumeIDTemplate*: array[MAX_VOLUME_TEMPLATE_SIZE, BYTE] + PCHANGER_SEND_VOLUME_TAG_INFORMATION* = ptr CHANGER_SEND_VOLUME_TAG_INFORMATION + READ_ELEMENT_ADDRESS_INFO* {.pure.} = object + NumberOfElements*: DWORD + ElementStatus*: array[1, CHANGER_ELEMENT_STATUS] + PREAD_ELEMENT_ADDRESS_INFO* = ptr READ_ELEMENT_ADDRESS_INFO + PATHNAME_BUFFER* {.pure.} = object + PathNameLength*: DWORD + Name*: array[1, WCHAR] + PPATHNAME_BUFFER* = ptr PATHNAME_BUFFER + FSCTL_QUERY_FAT_BPB_BUFFER* {.pure.} = object + First0x24BytesOfBootSector*: array[0x24, BYTE] + PFSCTL_QUERY_FAT_BPB_BUFFER* = ptr FSCTL_QUERY_FAT_BPB_BUFFER + NTFS_VOLUME_DATA_BUFFER* {.pure.} = object + VolumeSerialNumber*: LARGE_INTEGER + NumberSectors*: LARGE_INTEGER + TotalClusters*: LARGE_INTEGER + FreeClusters*: LARGE_INTEGER + TotalReserved*: LARGE_INTEGER + BytesPerSector*: DWORD + BytesPerCluster*: DWORD + BytesPerFileRecordSegment*: DWORD + ClustersPerFileRecordSegment*: DWORD + MftValidDataLength*: LARGE_INTEGER + MftStartLcn*: LARGE_INTEGER + Mft2StartLcn*: LARGE_INTEGER + MftZoneStart*: LARGE_INTEGER + MftZoneEnd*: LARGE_INTEGER + PNTFS_VOLUME_DATA_BUFFER* = ptr NTFS_VOLUME_DATA_BUFFER + NTFS_EXTENDED_VOLUME_DATA* {.pure.} = object + ByteCount*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + PNTFS_EXTENDED_VOLUME_DATA* = ptr NTFS_EXTENDED_VOLUME_DATA + STARTING_LCN_INPUT_BUFFER* {.pure.} = object + StartingLcn*: LARGE_INTEGER + PSTARTING_LCN_INPUT_BUFFER* = ptr STARTING_LCN_INPUT_BUFFER + VOLUME_BITMAP_BUFFER* {.pure.} = object + StartingLcn*: LARGE_INTEGER + BitmapSize*: LARGE_INTEGER + Buffer*: array[1, BYTE] + PVOLUME_BITMAP_BUFFER* = ptr VOLUME_BITMAP_BUFFER + STARTING_VCN_INPUT_BUFFER* {.pure.} = object + StartingVcn*: LARGE_INTEGER + PSTARTING_VCN_INPUT_BUFFER* = ptr STARTING_VCN_INPUT_BUFFER + RETRIEVAL_POINTERS_BUFFER_Extents* {.pure.} = object + NextVcn*: LARGE_INTEGER + Lcn*: LARGE_INTEGER + RETRIEVAL_POINTERS_BUFFER* {.pure.} = object + ExtentCount*: DWORD + StartingVcn*: LARGE_INTEGER + Extents*: array[1, RETRIEVAL_POINTERS_BUFFER_Extents] + PRETRIEVAL_POINTERS_BUFFER* = ptr RETRIEVAL_POINTERS_BUFFER + NTFS_FILE_RECORD_INPUT_BUFFER* {.pure.} = object + FileReferenceNumber*: LARGE_INTEGER + PNTFS_FILE_RECORD_INPUT_BUFFER* = ptr NTFS_FILE_RECORD_INPUT_BUFFER + NTFS_FILE_RECORD_OUTPUT_BUFFER* {.pure.} = object + FileReferenceNumber*: LARGE_INTEGER + FileRecordLength*: DWORD + FileRecordBuffer*: array[1, BYTE] + PNTFS_FILE_RECORD_OUTPUT_BUFFER* = ptr NTFS_FILE_RECORD_OUTPUT_BUFFER + MOVE_FILE_DATA* {.pure.} = object + FileHandle*: HANDLE + StartingVcn*: LARGE_INTEGER + StartingLcn*: LARGE_INTEGER + ClusterCount*: DWORD + PMOVE_FILE_DATA* = ptr MOVE_FILE_DATA + FIND_BY_SID_DATA* {.pure.} = object + Restart*: DWORD + Sid*: SID + PFIND_BY_SID_DATA* = ptr FIND_BY_SID_DATA + FIND_BY_SID_OUTPUT* {.pure.} = object + NextEntryOffset*: DWORD + FileIndex*: DWORD + FileNameLength*: DWORD + FileName*: array[1, WCHAR] + PFIND_BY_SID_OUTPUT* = ptr FIND_BY_SID_OUTPUT + MFT_ENUM_DATA* {.pure.} = object + StartFileReferenceNumber*: DWORDLONG + LowUsn*: USN + HighUsn*: USN + PMFT_ENUM_DATA* = ptr MFT_ENUM_DATA + CREATE_USN_JOURNAL_DATA* {.pure.} = object + MaximumSize*: DWORDLONG + AllocationDelta*: DWORDLONG + PCREATE_USN_JOURNAL_DATA* = ptr CREATE_USN_JOURNAL_DATA + READ_USN_JOURNAL_DATA* {.pure.} = object + StartUsn*: USN + ReasonMask*: DWORD + ReturnOnlyOnClose*: DWORD + Timeout*: DWORDLONG + BytesToWaitFor*: DWORDLONG + UsnJournalID*: DWORDLONG + PREAD_USN_JOURNAL_DATA* = ptr READ_USN_JOURNAL_DATA + USN_RECORD* {.pure.} = object + RecordLength*: DWORD + MajorVersion*: WORD + MinorVersion*: WORD + FileReferenceNumber*: DWORDLONG + ParentFileReferenceNumber*: DWORDLONG + Usn*: USN + TimeStamp*: LARGE_INTEGER + Reason*: DWORD + SourceInfo*: DWORD + SecurityId*: DWORD + FileAttributes*: DWORD + FileNameLength*: WORD + FileNameOffset*: WORD + FileName*: array[1, WCHAR] + PUSN_RECORD* = ptr USN_RECORD + USN_JOURNAL_DATA* {.pure.} = object + UsnJournalID*: DWORDLONG + FirstUsn*: USN + NextUsn*: USN + LowestValidUsn*: USN + MaxUsn*: USN + MaximumSize*: DWORDLONG + AllocationDelta*: DWORDLONG + PUSN_JOURNAL_DATA* = ptr USN_JOURNAL_DATA + DELETE_USN_JOURNAL_DATA* {.pure.} = object + UsnJournalID*: DWORDLONG + DeleteFlags*: DWORD + PDELETE_USN_JOURNAL_DATA* = ptr DELETE_USN_JOURNAL_DATA + MARK_HANDLE_INFO* {.pure.} = object + UsnSourceInfo*: DWORD + VolumeHandle*: HANDLE + HandleInfo*: DWORD + PMARK_HANDLE_INFO* = ptr MARK_HANDLE_INFO + BULK_SECURITY_TEST_DATA* {.pure.} = object + DesiredAccess*: ACCESS_MASK + SecurityIds*: array[1, DWORD] + PBULK_SECURITY_TEST_DATA* = ptr BULK_SECURITY_TEST_DATA + FILE_PREFETCH* {.pure.} = object + Type*: DWORD + Count*: DWORD + Prefetch*: array[1, DWORDLONG] + PFILE_PREFETCH* = ptr FILE_PREFETCH + FILESYSTEM_STATISTICS* {.pure.} = object + FileSystemType*: WORD + Version*: WORD + SizeOfCompleteStructure*: DWORD + UserFileReads*: DWORD + UserFileReadBytes*: DWORD + UserDiskReads*: DWORD + UserFileWrites*: DWORD + UserFileWriteBytes*: DWORD + UserDiskWrites*: DWORD + MetaDataReads*: DWORD + MetaDataReadBytes*: DWORD + MetaDataDiskReads*: DWORD + MetaDataWrites*: DWORD + MetaDataWriteBytes*: DWORD + MetaDataDiskWrites*: DWORD + PFILESYSTEM_STATISTICS* = ptr FILESYSTEM_STATISTICS + FAT_STATISTICS* {.pure.} = object + CreateHits*: DWORD + SuccessfulCreates*: DWORD + FailedCreates*: DWORD + NonCachedReads*: DWORD + NonCachedReadBytes*: DWORD + NonCachedWrites*: DWORD + NonCachedWriteBytes*: DWORD + NonCachedDiskReads*: DWORD + NonCachedDiskWrites*: DWORD + PFAT_STATISTICS* = ptr FAT_STATISTICS + EXFAT_STATISTICS* {.pure.} = object + CreateHits*: DWORD + SuccessfulCreates*: DWORD + FailedCreates*: DWORD + NonCachedReads*: DWORD + NonCachedReadBytes*: DWORD + NonCachedWrites*: DWORD + NonCachedWriteBytes*: DWORD + NonCachedDiskReads*: DWORD + NonCachedDiskWrites*: DWORD + PEXFAT_STATISTICS* = ptr EXFAT_STATISTICS + NTFS_STATISTICS_MftWritesUserLevel* {.pure.} = object + Write*: WORD + Create*: WORD + SetInfo*: WORD + Flush*: WORD + NTFS_STATISTICS_Mft2WritesUserLevel* {.pure.} = object + Write*: WORD + Create*: WORD + SetInfo*: WORD + Flush*: WORD + NTFS_STATISTICS_BitmapWritesUserLevel* {.pure.} = object + Write*: WORD + Create*: WORD + SetInfo*: WORD + NTFS_STATISTICS_MftBitmapWritesUserLevel* {.pure.} = object + Write*: WORD + Create*: WORD + SetInfo*: WORD + Flush*: WORD + NTFS_STATISTICS_Allocate* {.pure.} = object + Calls*: DWORD + Clusters*: DWORD + Hints*: DWORD + RunsReturned*: DWORD + HintsHonored*: DWORD + HintsClusters*: DWORD + Cache*: DWORD + CacheClusters*: DWORD + CacheMiss*: DWORD + CacheMissClusters*: DWORD + NTFS_STATISTICS* {.pure.} = object + LogFileFullExceptions*: DWORD + OtherExceptions*: DWORD + MftReads*: DWORD + MftReadBytes*: DWORD + MftWrites*: DWORD + MftWriteBytes*: DWORD + MftWritesUserLevel*: NTFS_STATISTICS_MftWritesUserLevel + MftWritesFlushForLogFileFull*: WORD + MftWritesLazyWriter*: WORD + MftWritesUserRequest*: WORD + Mft2Writes*: DWORD + Mft2WriteBytes*: DWORD + Mft2WritesUserLevel*: NTFS_STATISTICS_Mft2WritesUserLevel + Mft2WritesFlushForLogFileFull*: WORD + Mft2WritesLazyWriter*: WORD + Mft2WritesUserRequest*: WORD + RootIndexReads*: DWORD + RootIndexReadBytes*: DWORD + RootIndexWrites*: DWORD + RootIndexWriteBytes*: DWORD + BitmapReads*: DWORD + BitmapReadBytes*: DWORD + BitmapWrites*: DWORD + BitmapWriteBytes*: DWORD + BitmapWritesFlushForLogFileFull*: WORD + BitmapWritesLazyWriter*: WORD + BitmapWritesUserRequest*: WORD + BitmapWritesUserLevel*: NTFS_STATISTICS_BitmapWritesUserLevel + MftBitmapReads*: DWORD + MftBitmapReadBytes*: DWORD + MftBitmapWrites*: DWORD + MftBitmapWriteBytes*: DWORD + MftBitmapWritesFlushForLogFileFull*: WORD + MftBitmapWritesLazyWriter*: WORD + MftBitmapWritesUserRequest*: WORD + MftBitmapWritesUserLevel*: NTFS_STATISTICS_MftBitmapWritesUserLevel + UserIndexReads*: DWORD + UserIndexReadBytes*: DWORD + UserIndexWrites*: DWORD + UserIndexWriteBytes*: DWORD + LogFileReads*: DWORD + LogFileReadBytes*: DWORD + LogFileWrites*: DWORD + LogFileWriteBytes*: DWORD + Allocate*: NTFS_STATISTICS_Allocate + PNTFS_STATISTICS* = ptr NTFS_STATISTICS + FILE_OBJECTID_BUFFER_UNION1_STRUCT1* {.pure.} = object + BirthVolumeId*: array[16, BYTE] + BirthObjectId*: array[16, BYTE] + DomainId*: array[16, BYTE] + FILE_OBJECTID_BUFFER_UNION1* {.pure, union.} = object + struct1*: FILE_OBJECTID_BUFFER_UNION1_STRUCT1 + ExtendedInfo*: array[48, BYTE] + FILE_OBJECTID_BUFFER* {.pure.} = object + ObjectId*: array[16, BYTE] + union1*: FILE_OBJECTID_BUFFER_UNION1 + PFILE_OBJECTID_BUFFER* = ptr FILE_OBJECTID_BUFFER + FILE_SET_SPARSE_BUFFER* {.pure.} = object + SetSparse*: BOOLEAN + PFILE_SET_SPARSE_BUFFER* = ptr FILE_SET_SPARSE_BUFFER + FILE_ZERO_DATA_INFORMATION* {.pure.} = object + FileOffset*: LARGE_INTEGER + BeyondFinalZero*: LARGE_INTEGER + PFILE_ZERO_DATA_INFORMATION* = ptr FILE_ZERO_DATA_INFORMATION + FILE_ALLOCATED_RANGE_BUFFER* {.pure.} = object + FileOffset*: LARGE_INTEGER + Length*: LARGE_INTEGER + PFILE_ALLOCATED_RANGE_BUFFER* = ptr FILE_ALLOCATED_RANGE_BUFFER + ENCRYPTION_BUFFER* {.pure.} = object + EncryptionOperation*: DWORD + Private*: array[1, BYTE] + PENCRYPTION_BUFFER* = ptr ENCRYPTION_BUFFER + DECRYPTION_STATUS_BUFFER* {.pure.} = object + NoEncryptedStreams*: BOOLEAN + PDECRYPTION_STATUS_BUFFER* = ptr DECRYPTION_STATUS_BUFFER + REQUEST_RAW_ENCRYPTED_DATA* {.pure.} = object + FileOffset*: LONGLONG + Length*: DWORD + PREQUEST_RAW_ENCRYPTED_DATA* = ptr REQUEST_RAW_ENCRYPTED_DATA + ENCRYPTED_DATA_INFO* {.pure.} = object + StartingFileOffset*: DWORDLONG + OutputBufferOffset*: DWORD + BytesWithinFileSize*: DWORD + BytesWithinValidDataLength*: DWORD + CompressionFormat*: WORD + DataUnitShift*: BYTE + ChunkShift*: BYTE + ClusterShift*: BYTE + EncryptionFormat*: BYTE + NumberOfDataBlocks*: WORD + DataBlockSize*: array[ANYSIZE_ARRAY, DWORD] + PENCRYPTED_DATA_INFO* = ptr ENCRYPTED_DATA_INFO + PLEX_READ_DATA_REQUEST* {.pure.} = object + ByteOffset*: LARGE_INTEGER + ByteLength*: DWORD + PlexNumber*: DWORD + PPLEX_READ_DATA_REQUEST* = ptr PLEX_READ_DATA_REQUEST + SI_COPYFILE* {.pure.} = object + SourceFileNameLength*: DWORD + DestinationFileNameLength*: DWORD + Flags*: DWORD + FileNameBuffer*: array[1, WCHAR] + PSI_COPYFILE* = ptr SI_COPYFILE + STORAGE_DESCRIPTOR_HEADER* {.pure.} = object + Version*: DWORD + Size*: DWORD + PSTORAGE_DESCRIPTOR_HEADER* = ptr STORAGE_DESCRIPTOR_HEADER + STORAGE_PROPERTY_QUERY* {.pure.} = object + PropertyId*: STORAGE_PROPERTY_ID + QueryType*: STORAGE_QUERY_TYPE + AdditionalParameters*: array[1, BYTE] + PSTORAGE_PROPERTY_QUERY* = ptr STORAGE_PROPERTY_QUERY + STORAGE_DEVICE_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + DeviceType*: BYTE + DeviceTypeModifier*: BYTE + RemovableMedia*: BOOLEAN + CommandQueueing*: BOOLEAN + VendorIdOffset*: DWORD + ProductIdOffset*: DWORD + ProductRevisionOffset*: DWORD + SerialNumberOffset*: DWORD + BusType*: STORAGE_BUS_TYPE + RawPropertiesLength*: DWORD + RawDeviceProperties*: array[1, BYTE] + PSTORAGE_DEVICE_DESCRIPTOR* = ptr STORAGE_DEVICE_DESCRIPTOR + STORAGE_ADAPTER_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + MaximumTransferLength*: DWORD + MaximumPhysicalPages*: DWORD + AlignmentMask*: DWORD + AdapterUsesPio*: BOOLEAN + AdapterScansDown*: BOOLEAN + CommandQueueing*: BOOLEAN + AcceleratedTransfer*: BOOLEAN + BusType*: BYTE + BusMajorVersion*: WORD + BusMinorVersion*: WORD + PSTORAGE_ADAPTER_DESCRIPTOR* = ptr STORAGE_ADAPTER_DESCRIPTOR + STORAGE_DEVICE_ID_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + NumberOfIdentifiers*: DWORD + Identifiers*: array[1, BYTE] + PSTORAGE_DEVICE_ID_DESCRIPTOR* = ptr STORAGE_DEVICE_ID_DESCRIPTOR + VOLUME_GET_GPT_ATTRIBUTES_INFORMATION* {.pure.} = object + GptAttributes*: ULONGLONG + PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION* = ptr VOLUME_GET_GPT_ATTRIBUTES_INFORMATION + FILE_MAKE_COMPATIBLE_BUFFER* {.pure.} = object + CloseDisc*: BOOLEAN + PFILE_MAKE_COMPATIBLE_BUFFER* = ptr FILE_MAKE_COMPATIBLE_BUFFER + FILE_SET_DEFECT_MGMT_BUFFER* {.pure.} = object + Disable*: BOOLEAN + PFILE_SET_DEFECT_MGMT_BUFFER* = ptr FILE_SET_DEFECT_MGMT_BUFFER + FILE_QUERY_SPARING_BUFFER* {.pure.} = object + SparingUnitBytes*: ULONG + SoftwareSparing*: BOOLEAN + TotalSpareBlocks*: ULONG + FreeSpareBlocks*: ULONG + PFILE_QUERY_SPARING_BUFFER* = ptr FILE_QUERY_SPARING_BUFFER + FILE_QUERY_ON_DISK_VOL_INFO_BUFFER* {.pure.} = object + DirectoryCount*: LARGE_INTEGER + FileCount*: LARGE_INTEGER + FsFormatMajVersion*: WORD + FsFormatMinVersion*: WORD + FsFormatName*: array[12, WCHAR] + FormatTime*: LARGE_INTEGER + LastUpdateTime*: LARGE_INTEGER + CopyrightInfo*: array[34, WCHAR] + AbstractInfo*: array[34, WCHAR] + FormattingImplementationInfo*: array[34, WCHAR] + LastModifyingImplementationInfo*: array[34, WCHAR] + PFILE_QUERY_ON_DISK_VOL_INFO_BUFFER* = ptr FILE_QUERY_ON_DISK_VOL_INFO_BUFFER + SHRINK_VOLUME_INFORMATION* {.pure.} = object + ShrinkRequestType*: SHRINK_VOLUME_REQUEST_TYPES + Flags*: DWORDLONG + NewNumberOfSectors*: LONGLONG + PSHRINK_VOLUME_INFORMATION* = ptr SHRINK_VOLUME_INFORMATION + TXFS_MODIFY_RM* {.pure.} = object + Flags*: ULONG + LogContainerCountMax*: ULONG + LogContainerCountMin*: ULONG + LogContainerCount*: ULONG + LogGrowthIncrement*: ULONG + LogAutoShrinkPercentage*: ULONG + Reserved*: ULONGLONG + LoggingMode*: USHORT + PTXFS_MODIFY_RM* = ptr TXFS_MODIFY_RM + TXFS_QUERY_RM_INFORMATION* {.pure.} = object + BytesRequired*: ULONG + TailLsn*: ULONGLONG + CurrentLsn*: ULONGLONG + ArchiveTailLsn*: ULONGLONG + LogContainerSize*: ULONGLONG + HighestVirtualClock*: LARGE_INTEGER + LogContainerCount*: ULONG + LogContainerCountMax*: ULONG + LogContainerCountMin*: ULONG + LogGrowthIncrement*: ULONG + LogAutoShrinkPercentage*: ULONG + Flags*: ULONG + LoggingMode*: USHORT + Reserved*: USHORT + RmState*: ULONG + LogCapacity*: ULONGLONG + LogFree*: ULONGLONG + TopsSize*: ULONGLONG + TopsUsed*: ULONGLONG + TransactionCount*: ULONGLONG + OnePCCount*: ULONGLONG + TwoPCCount*: ULONGLONG + NumberLogFileFull*: ULONGLONG + OldestTransactionAge*: ULONGLONG + RMName*: GUID + TmLogPathOffset*: ULONG + PTXFS_QUERY_RM_INFORMATION* = ptr TXFS_QUERY_RM_INFORMATION + TXFS_ROLLFORWARD_REDO_INFORMATION* {.pure.} = object + LastVirtualClock*: LARGE_INTEGER + LastRedoLsn*: ULONGLONG + HighestRecoveryLsn*: ULONGLONG + Flags*: ULONG + PTXFS_ROLLFORWARD_REDO_INFORMATION* = ptr TXFS_ROLLFORWARD_REDO_INFORMATION + TXFS_START_RM_INFORMATION* {.pure.} = object + Flags*: ULONG + LogContainerSize*: ULONGLONG + LogContainerCountMin*: ULONG + LogContainerCountMax*: ULONG + LogGrowthIncrement*: ULONG + LogAutoShrinkPercentage*: ULONG + TmLogPathOffset*: ULONG + TmLogPathLength*: USHORT + LoggingMode*: USHORT + LogPathLength*: USHORT + Reserved*: USHORT + LogPath*: array[1, WCHAR] + PTXFS_START_RM_INFORMATION* = ptr TXFS_START_RM_INFORMATION + TXFS_GET_METADATA_INFO_OUT_TxfFileId* {.pure.} = object + LowPart*: LONGLONG + HighPart*: LONGLONG + TXFS_GET_METADATA_INFO_OUT* {.pure.} = object + TxfFileId*: TXFS_GET_METADATA_INFO_OUT_TxfFileId + LockingTransaction*: GUID + LastLsn*: ULONGLONG + TransactionState*: ULONG + PTXFS_GET_METADATA_INFO_OUT* = ptr TXFS_GET_METADATA_INFO_OUT + TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY* {.pure.} = object + Offset*: ULONGLONG + NameFlags*: ULONG + FileId*: LONGLONG + Reserved1*: ULONG + Reserved2*: ULONG + Reserved3*: LONGLONG + FileName*: array[1, WCHAR] + PTXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY* = ptr TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY + TXFS_LIST_TRANSACTION_LOCKED_FILES* {.pure.} = object + KtmTransaction*: GUID + NumberOfFiles*: ULONGLONG + BufferSizeRequired*: ULONGLONG + Offset*: ULONGLONG + PTXFS_LIST_TRANSACTION_LOCKED_FILES* = ptr TXFS_LIST_TRANSACTION_LOCKED_FILES + TXFS_LIST_TRANSACTIONS_ENTRY* {.pure.} = object + TransactionId*: GUID + TransactionState*: ULONG + Reserved1*: ULONG + Reserved2*: ULONG + Reserved3*: LONGLONG + PTXFS_LIST_TRANSACTIONS_ENTRY* = ptr TXFS_LIST_TRANSACTIONS_ENTRY + TXFS_LIST_TRANSACTIONS* {.pure.} = object + NumberOfTransactions*: ULONGLONG + BufferSizeRequired*: ULONGLONG + PTXFS_LIST_TRANSACTIONS* = ptr TXFS_LIST_TRANSACTIONS + TXFS_READ_BACKUP_INFORMATION_OUT_UNION1* {.pure, union.} = object + BufferLength*: ULONG + Buffer*: UCHAR + TXFS_READ_BACKUP_INFORMATION_OUT* {.pure.} = object + union1*: TXFS_READ_BACKUP_INFORMATION_OUT_UNION1 + PTXFS_READ_BACKUP_INFORMATION_OUT* = ptr TXFS_READ_BACKUP_INFORMATION_OUT + TXFS_WRITE_BACKUP_INFORMATION* {.pure.} = object + Buffer*: UCHAR + PTXFS_WRITE_BACKUP_INFORMATION* = ptr TXFS_WRITE_BACKUP_INFORMATION + TXFS_GET_TRANSACTED_VERSION* {.pure.} = object + ThisBaseVersion*: ULONG + LatestVersion*: ULONG + ThisMiniVersion*: USHORT + FirstMiniVersion*: USHORT + LatestMiniVersion*: USHORT + PTXFS_GET_TRANSACTED_VERSION* = ptr TXFS_GET_TRANSACTED_VERSION + TXFS_SAVEPOINT_INFORMATION* {.pure.} = object + KtmTransaction*: HANDLE + ActionCode*: ULONG + SavepointId*: ULONG + PTXFS_SAVEPOINT_INFORMATION* = ptr TXFS_SAVEPOINT_INFORMATION + TXFS_CREATE_MINIVERSION_INFO* {.pure.} = object + StructureVersion*: USHORT + StructureLength*: USHORT + BaseVersion*: ULONG + MiniVersion*: USHORT + PTXFS_CREATE_MINIVERSION_INFO* = ptr TXFS_CREATE_MINIVERSION_INFO + TXFS_TRANSACTION_ACTIVE_INFO* {.pure.} = object + TransactionsActiveAtSnapshot*: WINBOOL + PTXFS_TRANSACTION_ACTIVE_INFO* = ptr TXFS_TRANSACTION_ACTIVE_INFO + STORAGE_WRITE_CACHE_PROPERTY* {.pure.} = object + Version*: DWORD + Size*: DWORD + WriteCacheType*: WRITE_CACHE_TYPE + WriteCacheEnabled*: WRITE_CACHE_ENABLE + WriteCacheChangeable*: WRITE_CACHE_CHANGE + WriteThroughSupported*: WRITE_THROUGH + FlushCacheSupported*: BOOLEAN + UserDefinedPowerProtection*: BOOLEAN + NVCacheEnabled*: BOOLEAN + PSTORAGE_WRITE_CACHE_PROPERTY* = ptr STORAGE_WRITE_CACHE_PROPERTY + STORAGE_MINIPORT_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + Portdriver*: STORAGE_PORT_CODE_SET + LUNResetSupported*: BOOLEAN + TargetResetSupported*: BOOLEAN + PSTORAGE_MINIPORT_DESCRIPTOR* = ptr STORAGE_MINIPORT_DESCRIPTOR + STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + BytesPerCacheLine*: DWORD + BytesOffsetForCacheAlignment*: DWORD + BytesPerLogicalSector*: DWORD + BytesPerPhysicalSector*: DWORD + BytesOffsetForSectorAlignment*: DWORD + PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR* = ptr STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR + DEVICE_SEEK_PENALTY_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + IncursSeekPenalty*: BOOLEAN + PDEVICE_SEEK_PENALTY_DESCRIPTOR* = ptr DEVICE_SEEK_PENALTY_DESCRIPTOR + DEVICE_TRIM_DESCRIPTOR* {.pure.} = object + Version*: DWORD + Size*: DWORD + TrimEnabled*: BOOLEAN + PDEVICE_TRIM_DESCRIPTOR* = ptr DEVICE_TRIM_DESCRIPTOR + REQUEST_OPLOCK_INPUT_BUFFER* {.pure.} = object + StructureVersion*: WORD + StructureLength*: WORD + RequestedOplockLevel*: DWORD + Flags*: DWORD + PREQUEST_OPLOCK_INPUT_BUFFER* = ptr REQUEST_OPLOCK_INPUT_BUFFER + REQUEST_OPLOCK_OUTPUT_BUFFER* {.pure.} = object + StructureVersion*: WORD + StructureLength*: WORD + OriginalOplockLevel*: DWORD + NewOplockLevel*: DWORD + Flags*: DWORD + AccessMode*: ACCESS_MASK + ShareMode*: WORD + PREQUEST_OPLOCK_OUTPUT_BUFFER* = ptr REQUEST_OPLOCK_OUTPUT_BUFFER + BOOT_AREA_INFO_BootSectors* {.pure.} = object + Offset*: LARGE_INTEGER + BOOT_AREA_INFO* {.pure.} = object + BootSectorCount*: ULONG + BootSectors*: array[2, BOOT_AREA_INFO_BootSectors] + PBOOT_AREA_INFO* = ptr BOOT_AREA_INFO + RETRIEVAL_POINTER_BASE* {.pure.} = object + FileAreaOffset*: LARGE_INTEGER + PRETRIEVAL_POINTER_BASE* = ptr RETRIEVAL_POINTER_BASE + FILE_SYSTEM_RECOGNITION_INFORMATION* {.pure.} = object + FileSystem*: array[9, CHAR] + PFILE_SYSTEM_RECOGNITION_INFORMATION* = ptr FILE_SYSTEM_RECOGNITION_INFORMATION + LOOKUP_STREAM_FROM_CLUSTER_INPUT* {.pure.} = object + Flags*: DWORD + NumberOfClusters*: DWORD + Cluster*: array[1, LARGE_INTEGER] + PLOOKUP_STREAM_FROM_CLUSTER_INPUT* = ptr LOOKUP_STREAM_FROM_CLUSTER_INPUT + LOOKUP_STREAM_FROM_CLUSTER_OUTPUT* {.pure.} = object + Offset*: DWORD + NumberOfMatches*: DWORD + BufferSizeRequired*: DWORD + PLOOKUP_STREAM_FROM_CLUSTER_OUTPUT* = ptr LOOKUP_STREAM_FROM_CLUSTER_OUTPUT + LOOKUP_STREAM_FROM_CLUSTER_ENTRY* {.pure.} = object + OffsetToNext*: DWORD + Flags*: DWORD + Reserved*: LARGE_INTEGER + Cluster*: LARGE_INTEGER + FileName*: array[1, WCHAR] + PLOOKUP_STREAM_FROM_CLUSTER_ENTRY* = ptr LOOKUP_STREAM_FROM_CLUSTER_ENTRY + DISK_EXTENT* {.pure.} = object + DiskNumber*: DWORD + StartingOffset*: LARGE_INTEGER + ExtentLength*: LARGE_INTEGER + PDISK_EXTENT* = ptr DISK_EXTENT + VOLUME_DISK_EXTENTS* {.pure.} = object + NumberOfDiskExtents*: DWORD + Extents*: array[1, DISK_EXTENT] + PVOLUME_DISK_EXTENTS* = ptr VOLUME_DISK_EXTENTS +const + GUID_DEVINTERFACE_DISK* = DEFINE_GUID("53f56307-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_CDROM* = DEFINE_GUID("53f56308-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_PARTITION* = DEFINE_GUID("53f5630a-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_TAPE* = DEFINE_GUID("53f5630b-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_WRITEONCEDISK* = DEFINE_GUID("53f5630c-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_VOLUME* = DEFINE_GUID("53f5630d-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_MEDIUMCHANGER* = DEFINE_GUID("53f56310-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_FLOPPY* = DEFINE_GUID("53f56311-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_CDCHANGER* = DEFINE_GUID("53f56312-b6bf-11d0-94f2-00a0c91efb8b") + GUID_DEVINTERFACE_STORAGEPORT* = DEFINE_GUID("2accfe60-c130-11d2-b082-00a0c91efb8b") + GUID_DEVINTERFACE_COMPORT* = DEFINE_GUID("86e0d1e0-8089-11d0-9ce4-08003e301f73") + GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR* = DEFINE_GUID("4d36e978-e325-11ce-bfc1-08002be10318") + diskClassGuid* = GUID_DEVINTERFACE_DISK + cdRomClassGuid* = GUID_DEVINTERFACE_CDROM + partitionClassGuid* = GUID_DEVINTERFACE_PARTITION + tapeClassGuid* = GUID_DEVINTERFACE_TAPE + writeOnceDiskClassGuid* = GUID_DEVINTERFACE_WRITEONCEDISK + volumeClassGuid* = GUID_DEVINTERFACE_VOLUME + mediumChangerClassGuid* = GUID_DEVINTERFACE_MEDIUMCHANGER + floppyClassGuid* = GUID_DEVINTERFACE_FLOPPY + cdChangerClassGuid* = GUID_DEVINTERFACE_CDCHANGER + storagePortClassGuid* = GUID_DEVINTERFACE_STORAGEPORT + GUID_CLASS_COMPORT* = GUID_DEVINTERFACE_COMPORT + GUID_SERENUM_BUS_ENUMERATOR* = GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR + FILE_DEVICE_BEEP* = 0x00000001 + FILE_DEVICE_CD_ROM* = 0x00000002 + FILE_DEVICE_CD_ROM_FILE_SYSTEM* = 0x00000003 + FILE_DEVICE_CONTROLLER* = 0x00000004 + FILE_DEVICE_DATALINK* = 0x00000005 + FILE_DEVICE_DFS* = 0x00000006 + FILE_DEVICE_DISK* = 0x00000007 + FILE_DEVICE_DISK_FILE_SYSTEM* = 0x00000008 + FILE_DEVICE_FILE_SYSTEM* = 0x00000009 + FILE_DEVICE_INPORT_PORT* = 0x0000000a + FILE_DEVICE_KEYBOARD* = 0x0000000b + FILE_DEVICE_MAILSLOT* = 0x0000000c + FILE_DEVICE_MIDI_IN* = 0x0000000d + FILE_DEVICE_MIDI_OUT* = 0x0000000e + FILE_DEVICE_MOUSE* = 0x0000000f + FILE_DEVICE_MULTI_UNC_PROVIDER* = 0x00000010 + FILE_DEVICE_NAMED_PIPE* = 0x00000011 + FILE_DEVICE_NETWORK* = 0x00000012 + FILE_DEVICE_NETWORK_BROWSER* = 0x00000013 + FILE_DEVICE_NETWORK_FILE_SYSTEM* = 0x00000014 + FILE_DEVICE_NULL* = 0x00000015 + FILE_DEVICE_PARALLEL_PORT* = 0x00000016 + FILE_DEVICE_PHYSICAL_NETCARD* = 0x00000017 + FILE_DEVICE_PRINTER* = 0x00000018 + FILE_DEVICE_SCANNER* = 0x00000019 + FILE_DEVICE_SERIAL_MOUSE_PORT* = 0x0000001a + FILE_DEVICE_SERIAL_PORT* = 0x0000001b + FILE_DEVICE_SCREEN* = 0x0000001c + FILE_DEVICE_SOUND* = 0x0000001d + FILE_DEVICE_STREAMS* = 0x0000001e + FILE_DEVICE_TAPE* = 0x0000001f + FILE_DEVICE_TAPE_FILE_SYSTEM* = 0x00000020 + FILE_DEVICE_TRANSPORT* = 0x00000021 + FILE_DEVICE_UNKNOWN* = 0x00000022 + FILE_DEVICE_VIDEO* = 0x00000023 + FILE_DEVICE_VIRTUAL_DISK* = 0x00000024 + FILE_DEVICE_WAVE_IN* = 0x00000025 + FILE_DEVICE_WAVE_OUT* = 0x00000026 + FILE_DEVICE_8042_PORT* = 0x00000027 + FILE_DEVICE_NETWORK_REDIRECTOR* = 0x00000028 + FILE_DEVICE_BATTERY* = 0x00000029 + FILE_DEVICE_BUS_EXTENDER* = 0x0000002a + FILE_DEVICE_MODEM* = 0x0000002b + FILE_DEVICE_VDM* = 0x0000002c + FILE_DEVICE_MASS_STORAGE* = 0x0000002d + FILE_DEVICE_SMB* = 0x0000002e + FILE_DEVICE_KS* = 0x0000002f + FILE_DEVICE_CHANGER* = 0x00000030 + FILE_DEVICE_SMARTCARD* = 0x00000031 + FILE_DEVICE_ACPI* = 0x00000032 + FILE_DEVICE_DVD* = 0x00000033 + FILE_DEVICE_FULLSCREEN_VIDEO* = 0x00000034 + FILE_DEVICE_DFS_FILE_SYSTEM* = 0x00000035 + FILE_DEVICE_DFS_VOLUME* = 0x00000036 + FILE_DEVICE_SERENUM* = 0x00000037 + FILE_DEVICE_TERMSRV* = 0x00000038 + FILE_DEVICE_KSEC* = 0x00000039 + FILE_DEVICE_FIPS* = 0x0000003A + FILE_DEVICE_INFINIBAND* = 0x0000003B + METHOD_BUFFERED* = 0 + METHOD_IN_DIRECT* = 1 + METHOD_OUT_DIRECT* = 2 + METHOD_NEITHER* = 3 + METHOD_DIRECT_TO_HARDWARE* = METHOD_IN_DIRECT + METHOD_DIRECT_FROM_HARDWARE* = METHOD_OUT_DIRECT + FILE_ANY_ACCESS* = 0 + FILE_SPECIAL_ACCESS* = FILE_ANY_ACCESS + FILE_READ_ACCESS* = 0x0001 + FILE_WRITE_ACCESS* = 0x0002 + IOCTL_STORAGE_BASE* = FILE_DEVICE_MASS_STORAGE +template CTL_CODE*(t: untyped, f: untyped, m: untyped, a:untyped): untyped = (t shl 16) or (a shl 14) or (f shl 2) or m +const + IOCTL_STORAGE_CHECK_VERIFY* = CTL_CODE(IOCTL_STORAGE_BASE,0x0200,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_CHECK_VERIFY2* = CTL_CODE(IOCTL_STORAGE_BASE,0x0200,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_MEDIA_REMOVAL* = CTL_CODE(IOCTL_STORAGE_BASE,0x0201,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_EJECT_MEDIA* = CTL_CODE(IOCTL_STORAGE_BASE,0x0202,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_LOAD_MEDIA* = CTL_CODE(IOCTL_STORAGE_BASE,0x0203,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_LOAD_MEDIA2* = CTL_CODE(IOCTL_STORAGE_BASE,0x0203,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_RESERVE* = CTL_CODE(IOCTL_STORAGE_BASE,0x0204,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_RELEASE* = CTL_CODE(IOCTL_STORAGE_BASE,0x0205,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_FIND_NEW_DEVICES* = CTL_CODE(IOCTL_STORAGE_BASE,0x0206,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_EJECTION_CONTROL* = CTL_CODE(IOCTL_STORAGE_BASE,0x0250,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_MCN_CONTROL* = CTL_CODE(IOCTL_STORAGE_BASE,0x0251,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_GET_MEDIA_TYPES* = CTL_CODE(IOCTL_STORAGE_BASE,0x0300,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_GET_MEDIA_TYPES_EX* = CTL_CODE(IOCTL_STORAGE_BASE,0x0301,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER* = CTL_CODE(IOCTL_STORAGE_BASE,0x0304,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_GET_HOTPLUG_INFO* = CTL_CODE(IOCTL_STORAGE_BASE,0x0305,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_SET_HOTPLUG_INFO* = CTL_CODE(IOCTL_STORAGE_BASE,0x0306,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_STORAGE_RESET_BUS* = CTL_CODE(IOCTL_STORAGE_BASE,0x0400,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_RESET_DEVICE* = CTL_CODE(IOCTL_STORAGE_BASE,0x0401,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_BREAK_RESERVATION* = CTL_CODE(IOCTL_STORAGE_BASE,0x0405,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_STORAGE_GET_DEVICE_NUMBER* = CTL_CODE(IOCTL_STORAGE_BASE,0x0420,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_PREDICT_FAILURE* = CTL_CODE(IOCTL_STORAGE_BASE,0x0440,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_READ_CAPACITY* = CTL_CODE(IOCTL_STORAGE_BASE,0x0450,METHOD_BUFFERED,FILE_READ_ACCESS) + OBSOLETE_IOCTL_STORAGE_RESET_BUS* = CTL_CODE(IOCTL_STORAGE_BASE,0x0400,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + OBSOLETE_IOCTL_STORAGE_RESET_DEVICE* = CTL_CODE(IOCTL_STORAGE_BASE,0x0401,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES* = CTL_CODE(IOCTL_STORAGE_BASE, 0x0501, METHOD_BUFFERED, FILE_WRITE_ACCESS) + DeviceDsmActionFlag_NonDestructive* = 0x80000000'i32 + DeviceDsmAction_None* = 0 + DeviceDsmAction_Trim* = 1 + DeviceDsmAction_Notification* = 2 or DeviceDsmActionFlag_NonDestructive + DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE* = 0x00000001 + RECOVERED_WRITES_VALID* = 0x00000001 + UNRECOVERED_WRITES_VALID* = 0x00000002 + RECOVERED_READS_VALID* = 0x00000004 + UNRECOVERED_READS_VALID* = 0x00000008 + WRITE_COMPRESSION_INFO_VALID* = 0x00000010 + READ_COMPRESSION_INFO_VALID* = 0x00000020 + TAPE_RETURN_STATISTICS* = 0 + TAPE_RETURN_ENV_INFO* = 1 + TAPE_RESET_STATISTICS* = 2 + DDS_4mm* = 0x20 + miniQic* = 0x21 + travan* = 0x22 + QIC* = 0x23 + MP_8mm* = 0x24 + AME_8mm* = 0x25 + AIT1_8mm* = 0x26 + DLT* = 0x27 + NCTP* = 0x28 + IBM_3480* = 0x29 + IBM_3490E* = 0x2A + IBM_Magstar_3590* = 0x2B + IBM_Magstar_MP* = 0x2C + STK_DATA_D3* = 0x2D + SONY_DTF* = 0x2E + DV_6mm* = 0x2F + DMI* = 0x3 + SONY_D2* = 0x4 + CLEANER_CARTRIDGE* = 0x5 + CD_ROM* = 0x6 + CD_R* = 0x7 + CD_RW* = 0x8 + DVD_ROM* = 0x9 + DVD_R* = 0xA + DVD_RW* = 0xB + MO_3_RW* = 0xC + MO_5_WO* = 0xD + MO_5_RW* = 0xE + MO_5_LIMDOW* = 0xF + PC_5_WO* = 0x1 + PC_5_RW* = 0x2 + PD_5_RW* = 0x3 + ABL_5_WO* = 0x4 + PINNACLE_APEX_5_RW* = 0x5 + SONY_12_WO* = 0x6 + PHILIPS_12_WO* = 0x7 + HITACHI_12_WO* = 0x8 + CYGNET_12_WO* = 0x9 + KODAK_14_WO* = 0xA + MO_NFR_525* = 0xB + NIKON_12_RW* = 0xC + IOMEGA_ZIP* = 0xD + IOMEGA_JAZ* = 0xE + SYQUEST_EZ135* = 0xF + SYQUEST_EZFLYER* = 0x1 + SYQUEST_SYJET* = 0x2 + AVATAR_F2* = 0x3 + MP2_8mm* = 0x4 + DST_S* = 0x5 + DST_M* = 0x6 + DST_L* = 0x7 + VXATape_1* = 0x8 + VXATape_2* = 0x9 + STK_9840* = 0xA + LTO_Ultrium* = 0xB + LTO_Accelis* = 0xC + DVD_RAM* = 0xD + AIT_8mm* = 0xE + ADR_1* = 0xF + ADR_2* = 0x1 + STK_9940* = 0x2 + SAIT* = 0x3 + vXATape* = 0x4 + MEDIA_ERASEABLE* = 0x00000001 + MEDIA_WRITE_ONCE* = 0x00000002 + MEDIA_READ_ONLY* = 0x00000004 + MEDIA_READ_WRITE* = 0x00000008 + MEDIA_WRITE_PROTECTED* = 0x00000100 + MEDIA_CURRENTLY_MOUNTED* = 0x80000000'i32 + busTypeUnknown* = 0x00 + busTypeScsi* = 0x1 + busTypeAtapi* = 0x2 + busTypeAta* = 0x3 + busType1394* = 0x4 + busTypeSsa* = 0x5 + busTypeFibre* = 0x6 + busTypeUsb* = 0x7 + busTypeRAID* = 0x8 + busTypeiScsi* = 0x9 + busTypeSas* = 0xA + busTypeSata* = 0xB + busTypeSd* = 0xC + busTypeMmc* = 0xD + busTypeVirtual* = 0xE + busTypeFileBackedVirtual* = 0xF + busTypeMax* = 0x1 + busTypeMaxReserved* = 0x7F + IOCTL_DISK_BASE* = FILE_DEVICE_DISK + IOCTL_DISK_GET_DRIVE_GEOMETRY* = CTL_CODE(IOCTL_DISK_BASE,0x0000,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_GET_PARTITION_INFO* = CTL_CODE(IOCTL_DISK_BASE,0x0001,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_SET_PARTITION_INFO* = CTL_CODE(IOCTL_DISK_BASE,0x0002,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GET_DRIVE_LAYOUT* = CTL_CODE(IOCTL_DISK_BASE,0x0003,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_SET_DRIVE_LAYOUT* = CTL_CODE(IOCTL_DISK_BASE,0x0004,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_VERIFY* = CTL_CODE(IOCTL_DISK_BASE,0x0005,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_FORMAT_TRACKS* = CTL_CODE(IOCTL_DISK_BASE,0x0006,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_REASSIGN_BLOCKS* = CTL_CODE(IOCTL_DISK_BASE,0x0007,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_PERFORMANCE* = CTL_CODE(IOCTL_DISK_BASE,0x0008,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_IS_WRITABLE* = CTL_CODE(IOCTL_DISK_BASE,0x0009,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_LOGGING* = CTL_CODE(IOCTL_DISK_BASE,0x000a,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_FORMAT_TRACKS_EX* = CTL_CODE(IOCTL_DISK_BASE,0x000b,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_HISTOGRAM_STRUCTURE* = CTL_CODE(IOCTL_DISK_BASE,0x000c,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_HISTOGRAM_DATA* = CTL_CODE(IOCTL_DISK_BASE,0x000d,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_HISTOGRAM_RESET* = CTL_CODE(IOCTL_DISK_BASE,0x000e,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_REQUEST_STRUCTURE* = CTL_CODE(IOCTL_DISK_BASE,0x000f,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_REQUEST_DATA* = CTL_CODE(IOCTL_DISK_BASE,0x0010,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_PERFORMANCE_OFF* = CTL_CODE(IOCTL_DISK_BASE,0x0018,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_CONTROLLER_NUMBER* = CTL_CODE(IOCTL_DISK_BASE,0x0011,METHOD_BUFFERED,FILE_ANY_ACCESS) + SMART_GET_VERSION* = CTL_CODE(IOCTL_DISK_BASE,0x0020,METHOD_BUFFERED,FILE_READ_ACCESS) + SMART_SEND_DRIVE_COMMAND* = CTL_CODE(IOCTL_DISK_BASE,0x0021,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + SMART_RCV_DRIVE_DATA* = CTL_CODE(IOCTL_DISK_BASE,0x0022,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GET_PARTITION_INFO_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0012,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_SET_PARTITION_INFO_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0013,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GET_DRIVE_LAYOUT_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0014,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_SET_DRIVE_LAYOUT_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0015,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_CREATE_DISK* = CTL_CODE(IOCTL_DISK_BASE,0x0016,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GET_LENGTH_INFO* = CTL_CODE(IOCTL_DISK_BASE,0x0017,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_GET_DRIVE_GEOMETRY_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0028,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_REASSIGN_BLOCKS_EX* = CTL_CODE(IOCTL_DISK_BASE,0x0029,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_UPDATE_DRIVE_SIZE* = CTL_CODE(IOCTL_DISK_BASE,0x0032,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GROW_PARTITION* = CTL_CODE(IOCTL_DISK_BASE,0x0034,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_GET_CACHE_INFORMATION* = CTL_CODE(IOCTL_DISK_BASE,0x0035,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_SET_CACHE_INFORMATION* = CTL_CODE(IOCTL_DISK_BASE,0x0036,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + OBSOLETE_DISK_GET_WRITE_CACHE_STATE* = CTL_CODE(IOCTL_DISK_BASE,0x0037,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_DELETE_DRIVE_LAYOUT* = CTL_CODE(IOCTL_DISK_BASE,0x0040,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_UPDATE_PROPERTIES* = CTL_CODE(IOCTL_DISK_BASE,0x0050,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_RESET_SNAPSHOT_INFO* = CTL_CODE(IOCTL_DISK_BASE,0x0084,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_FORMAT_DRIVE* = CTL_CODE(IOCTL_DISK_BASE,0x00f3,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_DISK_SENSE_DEVICE* = CTL_CODE(IOCTL_DISK_BASE,0x00f8,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_DISK_CHECK_VERIFY* = CTL_CODE(IOCTL_DISK_BASE,0x0200,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_MEDIA_REMOVAL* = CTL_CODE(IOCTL_DISK_BASE,0x0201,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_EJECT_MEDIA* = CTL_CODE(IOCTL_DISK_BASE,0x0202,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_LOAD_MEDIA* = CTL_CODE(IOCTL_DISK_BASE,0x0203,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_RESERVE* = CTL_CODE(IOCTL_DISK_BASE,0x0204,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_RELEASE* = CTL_CODE(IOCTL_DISK_BASE,0x0205,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_FIND_NEW_DEVICES* = CTL_CODE(IOCTL_DISK_BASE,0x0206,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_DISK_GET_MEDIA_TYPES* = CTL_CODE(IOCTL_DISK_BASE,0x0300,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_STORAGE_QUERY_PROPERTY* = CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS) + PARTITION_ENTRY_UNUSED* = 0x00 + PARTITION_FAT_12* = 0x01 + PARTITION_XENIX_1* = 0x02 + PARTITION_XENIX_2* = 0x03 + PARTITION_FAT_16* = 0x04 + PARTITION_EXTENDED* = 0x05 + PARTITION_HUGE* = 0x06 + PARTITION_IFS* = 0x07 + PARTITION_OS2BOOTMGR* = 0x0A + PARTITION_FAT32* = 0x0B + PARTITION_FAT32_XINT13* = 0x0C + PARTITION_XINT13* = 0x0E + PARTITION_XINT13_EXTENDED* = 0x0F + PARTITION_PREP* = 0x41 + PARTITION_LDM* = 0x42 + PARTITION_UNIX* = 0x63 + VALID_NTFT* = 0xC0 + PARTITION_NTFT* = 0x80 + unknown* = 0 + F5_1Pt2_512* = 1 + F3_1Pt44_512* = 2 + F3_2Pt88_512* = 3 + F3_20Pt8_512* = 4 + F3_720_512* = 5 + F5_360_512* = 6 + F5_320_512* = 7 + F5_320_1024* = 8 + F5_180_512* = 9 + F5_160_512* = 10 + removableMedia* = 11 + fixedMedia* = 12 + F3_120M_512* = 13 + F3_640_512* = 14 + F5_640_512* = 15 + F5_720_512* = 16 + F3_1Pt2_512* = 17 + F3_1Pt23_1024* = 18 + F5_1Pt23_1024* = 19 + F3_128Mb_512* = 20 + F3_230Mb_512* = 21 + F8_256_128* = 22 + F3_200Mb_512* = 23 + F3_240M_512* = 24 + F3_32M_512* = 25 + WMI_DISK_GEOMETRY_GUID* = DEFINE_GUID("25007f51-57c2-11d1-a528-00a0c9062910") + PARTITION_STYLE_MBR* = 0 + PARTITION_STYLE_GPT* = 1 + PARTITION_STYLE_RAW* = 2 + GPT_ATTRIBUTE_PLATFORM_REQUIRED* = 0x0000000000000001 + GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER* = 0x8000000000000000 + GPT_BASIC_DATA_ATTRIBUTE_HIDDEN* = 0x4000000000000000 + GPT_BASIC_DATA_ATTRIBUTE_SHADOW_COPY* = 0x2000000000000000 + GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY* = 0x1000000000000000 + detectNone* = 0 + detectInt13* = 1 + detectExInt13* = 2 + equalPriority* = 0 + keepPrefetchedData* = 1 + keepReadData* = 2 + HIST_NO_OF_BUCKETS* = 24 + DISK_LOGGING_START* = 0 + DISK_LOGGING_STOP* = 1 + DISK_LOGGING_DUMP* = 2 + DISK_BINNING* = 3 + requestSize* = 0 + requestLocation* = 1 + CAP_ATA_ID_CMD* = 1 + CAP_ATAPI_ID_CMD* = 2 + CAP_SMART_CMD* = 4 + ATAPI_ID_CMD* = 0xA1 + ID_CMD* = 0xEC + SMART_CMD* = 0xB0 + SMART_CYL_LOW* = 0x4F + SMART_CYL_HI* = 0xC2 + SMART_NO_ERROR* = 0 + SMART_IDE_ERROR* = 1 + SMART_INVALID_FLAG* = 2 + SMART_INVALID_COMMAND* = 3 + SMART_INVALID_BUFFER* = 4 + SMART_INVALID_DRIVE* = 5 + SMART_INVALID_IOCTL* = 6 + SMART_ERROR_NO_MEM* = 7 + SMART_INVALID_REGISTER* = 8 + SMART_NOT_SUPPORTED* = 9 + SMART_NO_IDE_DEVICE* = 10 + SMART_OFFLINE_ROUTINE_OFFLINE* = 0 + SMART_SHORT_SELFTEST_OFFLINE* = 1 + SMART_EXTENDED_SELFTEST_OFFLINE* = 2 + SMART_ABORT_OFFLINE_SELFTEST* = 127 + SMART_SHORT_SELFTEST_CAPTIVE* = 129 + SMART_EXTENDED_SELFTEST_CAPTIVE* = 130 + READ_ATTRIBUTE_BUFFER_SIZE* = 512 + IDENTIFY_BUFFER_SIZE* = 512 + READ_THRESHOLD_BUFFER_SIZE* = 512 + SMART_LOG_SECTOR_SIZE* = 512 + READ_ATTRIBUTES* = 0xD0 + READ_THRESHOLDS* = 0xD1 + ENABLE_DISABLE_AUTOSAVE* = 0xD2 + SAVE_ATTRIBUTE_VALUES* = 0xD3 + EXECUTE_OFFLINE_DIAGS* = 0xD4 + SMART_READ_LOG* = 0xD5 + SMART_WRITE_LOG* = 0xd6 + ENABLE_SMART* = 0xD8 + DISABLE_SMART* = 0xD9 + RETURN_SMART_STATUS* = 0xDA + ENABLE_DISABLE_AUTO_OFFLINE* = 0xDB + IOCTL_CHANGER_BASE* = FILE_DEVICE_CHANGER + IOCTL_CHANGER_GET_PARAMETERS* = CTL_CODE(IOCTL_CHANGER_BASE,0x0000,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_GET_STATUS* = CTL_CODE(IOCTL_CHANGER_BASE,0x0001,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_GET_PRODUCT_DATA* = CTL_CODE(IOCTL_CHANGER_BASE,0x0002,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_SET_ACCESS* = CTL_CODE(IOCTL_CHANGER_BASE,0x0004,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_CHANGER_GET_ELEMENT_STATUS* = CTL_CODE(IOCTL_CHANGER_BASE,0x0005,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS* = CTL_CODE(IOCTL_CHANGER_BASE,0x0006,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_SET_POSITION* = CTL_CODE(IOCTL_CHANGER_BASE,0x0007,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_EXCHANGE_MEDIUM* = CTL_CODE(IOCTL_CHANGER_BASE,0x0008,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_MOVE_MEDIUM* = CTL_CODE(IOCTL_CHANGER_BASE,0x0009,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_REINITIALIZE_TRANSPORT* = CTL_CODE(IOCTL_CHANGER_BASE,0x000A,METHOD_BUFFERED,FILE_READ_ACCESS) + IOCTL_CHANGER_QUERY_VOLUME_TAGS* = CTL_CODE(IOCTL_CHANGER_BASE,0x000B,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + allElements* = 0 + changerTransport* = 1 + changerSlot* = 2 + changerIEPort* = 3 + changerDrive* = 4 + changerDoor* = 5 + changerKeypad* = 6 + changerMaxElement* = 7 + CHANGER_BAR_CODE_SCANNER_INSTALLED* = 0x00000001 + CHANGER_INIT_ELEM_STAT_WITH_RANGE* = 0x00000002 + CHANGER_CLOSE_IEPORT* = 0x00000004 + CHANGER_OPEN_IEPORT* = 0x00000008 + CHANGER_STATUS_NON_VOLATILE* = 0x00000010 + CHANGER_EXCHANGE_MEDIA* = 0x00000020 + CHANGER_CLEANER_SLOT* = 0x00000040 + CHANGER_LOCK_UNLOCK* = 0x00000080 + CHANGER_CARTRIDGE_MAGAZINE* = 0x00000100 + CHANGER_MEDIUM_FLIP* = 0x00000200 + CHANGER_POSITION_TO_ELEMENT* = 0x00000400 + CHANGER_REPORT_IEPORT_STATE* = 0x00000800 + CHANGER_STORAGE_DRIVE* = 0x00001000 + CHANGER_STORAGE_IEPORT* = 0x00002000 + CHANGER_STORAGE_SLOT* = 0x00004000 + CHANGER_STORAGE_TRANSPORT* = 0x00008000 + CHANGER_DRIVE_CLEANING_REQUIRED* = 0x00010000 + CHANGER_PREDISMOUNT_EJECT_REQUIRED* = 0x00020000 + CHANGER_CLEANER_ACCESS_NOT_VALID* = 0x00040000 + CHANGER_PREMOUNT_EJECT_REQUIRED* = 0x00080000 + CHANGER_VOLUME_IDENTIFICATION* = 0x00100000 + CHANGER_VOLUME_SEARCH* = 0x00200000 + CHANGER_VOLUME_ASSERT* = 0x00400000 + CHANGER_VOLUME_REPLACE* = 0x00800000 + CHANGER_VOLUME_UNDEFINE* = 0x01000000 + CHANGER_SERIAL_NUMBER_VALID* = 0x04000000 + CHANGER_DEVICE_REINITIALIZE_CAPABLE* = 0x08000000 + CHANGER_KEYPAD_ENABLE_DISABLE* = 0x10000000 + CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS* = 0x20000000 + CHANGER_RESERVED_BIT* = 0x80000000'i32 + CHANGER_PREDISMOUNT_ALIGN_TO_SLOT* = 0x80000001'i32 + CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE* = 0x80000002'i32 + CHANGER_CLEANER_AUTODISMOUNT* = 0x80000004'i32 + CHANGER_TRUE_EXCHANGE_CAPABLE* = 0x80000008'i32 + CHANGER_SLOTS_USE_TRAYS* = 0x80000010'i32 + CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR* = 0x80000020'i32 + CHANGER_CLEANER_OPS_NOT_SUPPORTED* = 0x80000040'i32 + CHANGER_IEPORT_USER_CONTROL_OPEN* = 0x80000080'i32 + CHANGER_IEPORT_USER_CONTROL_CLOSE* = 0x80000100'i32 + CHANGER_MOVE_EXTENDS_IEPORT* = 0x80000200'i32 + CHANGER_MOVE_RETRACTS_IEPORT* = 0x80000400'i32 + CHANGER_TO_TRANSPORT* = 0x01 + CHANGER_TO_SLOT* = 0x02 + CHANGER_TO_IEPORT* = 0x04 + CHANGER_TO_DRIVE* = 0x08 + LOCK_UNLOCK_IEPORT* = 0x01 + LOCK_UNLOCK_DOOR* = 0x02 + LOCK_UNLOCK_KEYPAD* = 0x04 + LOCK_ELEMENT* = 0 + UNLOCK_ELEMENT* = 1 + EXTEND_IEPORT* = 2 + RETRACT_IEPORT* = 3 + ELEMENT_STATUS_FULL* = 0x00000001 + ELEMENT_STATUS_IMPEXP* = 0x00000002 + ELEMENT_STATUS_EXCEPT* = 0x00000004 + ELEMENT_STATUS_ACCESS* = 0x00000008 + ELEMENT_STATUS_EXENAB* = 0x00000010 + ELEMENT_STATUS_INENAB* = 0x00000020 + ELEMENT_STATUS_PRODUCT_DATA* = 0x00000040 + ELEMENT_STATUS_LUN_VALID* = 0x00001000 + ELEMENT_STATUS_ID_VALID* = 0x00002000 + ELEMENT_STATUS_NOT_BUS* = 0x00008000 + ELEMENT_STATUS_INVERT* = 0x00400000 + ELEMENT_STATUS_SVALID* = 0x00800000 + ELEMENT_STATUS_PVOLTAG* = 0x10000000 + ELEMENT_STATUS_AVOLTAG* = 0x20000000 + ERROR_LABEL_UNREADABLE* = 0x00000001 + ERROR_LABEL_QUESTIONABLE* = 0x00000002 + ERROR_SLOT_NOT_PRESENT* = 0x00000004 + ERROR_DRIVE_NOT_INSTALLED* = 0x00000008 + ERROR_TRAY_MALFUNCTION* = 0x00000010 + ERROR_INIT_STATUS_NEEDED* = 0x00000011 + ERROR_UNHANDLED_ERROR* = 0xFFFFFFFF'i32 + SEARCH_ALL* = 0x0 + SEARCH_PRIMARY* = 0x1 + SEARCH_ALTERNATE* = 0x2 + SEARCH_ALL_NO_SEQ* = 0x4 + SEARCH_PRI_NO_SEQ* = 0x5 + SEARCH_ALT_NO_SEQ* = 0x6 + ASSERT_PRIMARY* = 0x8 + ASSERT_ALTERNATE* = 0x9 + REPLACE_PRIMARY* = 0xA + REPLACE_ALTERNATE* = 0xB + UNDEFINE_PRIMARY* = 0xC + UNDEFINE_ALTERNATE* = 0xD + deviceProblemNone* = 0 + deviceProblemHardware* = 1 + deviceProblemCHMError* = 2 + deviceProblemDoorOpen* = 3 + deviceProblemCalibrationError* = 4 + deviceProblemTargetFailure* = 5 + deviceProblemCHMMoveError* = 6 + deviceProblemCHMZeroError* = 7 + deviceProblemCartridgeInsertError* = 8 + deviceProblemPositionError* = 9 + deviceProblemSensorError* = 10 + deviceProblemCartridgeEjectError* = 11 + deviceProblemGripperError* = 12 + deviceProblemDriveError* = 13 + IOCTL_SERIAL_LSRMST_INSERT* = CTL_CODE(FILE_DEVICE_SERIAL_PORT,31,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_SERENUM_EXPOSE_HARDWARE* = CTL_CODE(FILE_DEVICE_SERENUM,128,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_SERENUM_REMOVE_HARDWARE* = CTL_CODE(FILE_DEVICE_SERENUM,129,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_SERENUM_PORT_DESC* = CTL_CODE(FILE_DEVICE_SERENUM,130,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_SERENUM_GET_PORT_NAME* = CTL_CODE(FILE_DEVICE_SERENUM,131,METHOD_BUFFERED,FILE_ANY_ACCESS) + SERIAL_LSRMST_ESCAPE* = BYTE 0x00 + SERIAL_LSRMST_LSR_DATA* = BYTE 0x01 + SERIAL_LSRMST_LSR_NODATA* = BYTE 0x02 + SERIAL_LSRMST_MST* = BYTE 0x03 + SERIAL_IOC_FCR_FIFO_ENABLE* = DWORD 0x00000001 + SERIAL_IOC_FCR_RCVR_RESET* = DWORD 0x00000002 + SERIAL_IOC_FCR_XMIT_RESET* = DWORD 0x00000004 + SERIAL_IOC_FCR_DMA_MODE* = DWORD 0x00000008 + SERIAL_IOC_FCR_RES1* = DWORD 0x00000010 + SERIAL_IOC_FCR_RES2* = DWORD 0x00000020 + SERIAL_IOC_FCR_RCVR_TRIGGER_LSB* = DWORD 0x00000040 + SERIAL_IOC_FCR_RCVR_TRIGGER_MSB* = DWORD 0x00000080 + SERIAL_IOC_MCR_DTR* = DWORD 0x00000001 + SERIAL_IOC_MCR_RTS* = DWORD 0x00000002 + SERIAL_IOC_MCR_OUT1* = DWORD 0x00000004 + SERIAL_IOC_MCR_OUT2* = DWORD 0x00000008 + SERIAL_IOC_MCR_LOOP* = DWORD 0x00000010 + FSCTL_REQUEST_OPLOCK_LEVEL_1* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,0,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_REQUEST_OPLOCK_LEVEL_2* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,1,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_REQUEST_BATCH_OPLOCK* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,2,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_OPLOCK_BREAK_ACKNOWLEDGE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,3,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_OPBATCH_ACK_CLOSE_PENDING* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,4,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_OPLOCK_BREAK_NOTIFY* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,5,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_LOCK_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,6,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_UNLOCK_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,7,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_DISMOUNT_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,8,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_IS_VOLUME_MOUNTED* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,10,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_IS_PATHNAME_VALID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,11,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_MARK_VOLUME_DIRTY* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,12,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_QUERY_RETRIEVAL_POINTERS* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,14,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_GET_COMPRESSION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,15,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_SET_COMPRESSION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,16,METHOD_BUFFERED,FILE_READ_DATA or FILE_WRITE_DATA) + FSCTL_MARK_AS_SYSTEM_HIVE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,19,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_OPLOCK_BREAK_ACK_NO_2* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,20,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_INVALIDATE_VOLUMES* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,21,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_QUERY_FAT_BPB* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,22,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_REQUEST_FILTER_OPLOCK* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,23,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_FILESYSTEM_GET_STATISTICS* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,24,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_GET_NTFS_VOLUME_DATA* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,25,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_GET_NTFS_FILE_RECORD* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,26,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_GET_VOLUME_BITMAP* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,27,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_GET_RETRIEVAL_POINTERS* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,28,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_MOVE_FILE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,29,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_IS_VOLUME_DIRTY* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,30,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_ALLOW_EXTENDED_DASD_IO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,32,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_FIND_FILES_BY_SID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,35,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_SET_OBJECT_ID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,38,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_GET_OBJECT_ID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,39,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_DELETE_OBJECT_ID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,40,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_SET_REPARSE_POINT* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,41,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_GET_REPARSE_POINT* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,42,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_DELETE_REPARSE_POINT* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,43,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_ENUM_USN_DATA* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,44,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_SECURITY_ID_CHECK* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,45,METHOD_NEITHER,FILE_READ_DATA) + FSCTL_READ_USN_JOURNAL* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,46,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_SET_OBJECT_ID_EXTENDED* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,47,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_CREATE_OR_GET_OBJECT_ID* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,48,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_SET_SPARSE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,49,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + FSCTL_SET_ZERO_DATA* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,50,METHOD_BUFFERED,FILE_WRITE_DATA) + FSCTL_QUERY_ALLOCATED_RANGES* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,51,METHOD_NEITHER,FILE_READ_DATA) + FSCTL_SET_ENCRYPTION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,53,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_ENCRYPTION_FSCTL_IO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,54,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_WRITE_RAW_ENCRYPTED* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,55,METHOD_NEITHER,FILE_SPECIAL_ACCESS) + FSCTL_READ_RAW_ENCRYPTED* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,56,METHOD_NEITHER,FILE_SPECIAL_ACCESS) + FSCTL_CREATE_USN_JOURNAL* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,57,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_READ_FILE_USN_DATA* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,58,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_WRITE_USN_CLOSE_RECORD* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,59,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_EXTEND_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,60,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_QUERY_USN_JOURNAL* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,61,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_DELETE_USN_JOURNAL* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,62,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_MARK_HANDLE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,63,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_SIS_COPYFILE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,64,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_SIS_LINK_FILES* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,65,METHOD_BUFFERED,FILE_READ_DATA or FILE_WRITE_DATA) + FSCTL_HSM_MSG* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,66,METHOD_BUFFERED,FILE_READ_DATA or FILE_WRITE_DATA) + FSCTL_HSM_DATA* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,68,METHOD_NEITHER,FILE_READ_DATA or FILE_WRITE_DATA) + FSCTL_RECALL_FILE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,69,METHOD_NEITHER,FILE_ANY_ACCESS) + FSCTL_READ_FROM_PLEX* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,71,METHOD_OUT_DIRECT,FILE_READ_DATA) + FSCTL_FILE_PREFETCH* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,72,METHOD_BUFFERED,FILE_SPECIAL_ACCESS) + USN_PAGE_SIZE* = 0x1000 + USN_REASON_DATA_OVERWRITE* = 0x00000001 + USN_REASON_DATA_EXTEND* = 0x00000002 + USN_REASON_DATA_TRUNCATION* = 0x00000004 + USN_REASON_NAMED_DATA_OVERWRITE* = 0x00000010 + USN_REASON_NAMED_DATA_EXTEND* = 0x00000020 + USN_REASON_NAMED_DATA_TRUNCATION* = 0x00000040 + USN_REASON_FILE_CREATE* = 0x00000100 + USN_REASON_FILE_DELETE* = 0x00000200 + USN_REASON_EA_CHANGE* = 0x00000400 + USN_REASON_SECURITY_CHANGE* = 0x00000800 + USN_REASON_RENAME_OLD_NAME* = 0x00001000 + USN_REASON_RENAME_NEW_NAME* = 0x00002000 + USN_REASON_INDEXABLE_CHANGE* = 0x00004000 + USN_REASON_BASIC_INFO_CHANGE* = 0x00008000 + USN_REASON_HARD_LINK_CHANGE* = 0x00010000 + USN_REASON_COMPRESSION_CHANGE* = 0x00020000 + USN_REASON_ENCRYPTION_CHANGE* = 0x00040000 + USN_REASON_OBJECT_ID_CHANGE* = 0x00080000 + USN_REASON_REPARSE_POINT_CHANGE* = 0x00100000 + USN_REASON_STREAM_CHANGE* = 0x00200000 + USN_REASON_CLOSE* = 0x80000000'i32 + USN_DELETE_FLAG_DELETE* = 0x00000001 + USN_DELETE_FLAG_NOTIFY* = 0x00000002 + USN_DELETE_VALID_FLAGS* = 0x00000003 + USN_SOURCE_DATA_MANAGEMENT* = 0x00000001 + USN_SOURCE_AUXILIARY_DATA* = 0x00000002 + USN_SOURCE_REPLICATION_MANAGEMENT* = 0x00000004 + MARK_HANDLE_PROTECT_CLUSTERS* = 0x00000001 + MARK_HANDLE_TXF_SYSTEM_LOG* = 0x00000004 + MARK_HANDLE_NOT_TXF_SYSTEM_LOG* = 0x00000008 + MARK_HANDLE_REALTIME* = 0x00000020 + MARK_HANDLE_NOT_REALTIME* = 0x00000040 + VOLUME_IS_DIRTY* = 0x00000001 + VOLUME_UPGRADE_SCHEDULED* = 0x00000002 + FILE_PREFETCH_TYPE_FOR_CREATE* = 0x1 + FILESYSTEM_STATISTICS_TYPE_NTFS* = 1 + FILESYSTEM_STATISTICS_TYPE_FAT* = 2 + FILE_SET_ENCRYPTION* = 0x00000001 + FILE_CLEAR_ENCRYPTION* = 0x00000002 + STREAM_SET_ENCRYPTION* = 0x00000003 + STREAM_CLEAR_ENCRYPTION* = 0x00000004 + MAXIMUM_ENCRYPTION_VALUE* = 0x00000004 + ENCRYPTION_FORMAT_DEFAULT* = 0x01 + COMPRESSION_FORMAT_SPARSE* = 0x4000 + COPYFILE_SIS_LINK* = 0x0001 + COPYFILE_SIS_REPLACE* = 0x0002 + COPYFILE_SIS_FLAGS* = 0x0003 + storageDeviceProperty* = 0 + storageAdapterProperty* = 1 + storageDeviceIdProperty* = 2 + storageDeviceUniqueIdProperty* = 3 + storageDeviceWriteCacheProperty* = 4 + storageMiniportProperty* = 5 + storageAccessAlignmentProperty* = 6 + storageDeviceSeekPenaltyProperty* = 7 + storageDeviceTrimProperty* = 8 + propertyStandardQuery* = 0 + propertyExistsQuery* = 1 + propertyMaskQuery* = 2 + propertyQueryMaxDefined* = 3 + FSCTL_MAKE_MEDIA_COMPATIBLE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 76, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_SET_DEFECT_MANAGEMENT* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 77, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_QUERY_SPARING_INFO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 78, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_QUERY_ON_DISK_VOLUME_INFO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 79, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_SET_VOLUME_COMPRESSION_STATE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,80, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) + FSCTL_TXFS_MODIFY_RM* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,81, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_QUERY_RM_INFORMATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,82, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_TXFS_ROLLFORWARD_REDO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,84, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_ROLLFORWARD_UNDO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,85, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_START_RM* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,86, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_SHUTDOWN_RM* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 87, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_READ_BACKUP_INFORMATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,88, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_TXFS_WRITE_BACKUP_INFORMATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,89, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_CREATE_SECONDARY_RM* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,90,METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_GET_METADATA_INFO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,91, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_TXFS_GET_TRANSACTED_VERSION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,92, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_TXFS_SAVEPOINT_INFORMATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,94, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_CREATE_MINIVERSION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 95, METHOD_BUFFERED, FILE_WRITE_DATA) + FSCTL_TXFS_TRANSACTION_ACTIVE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,99, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_SET_ZERO_ON_DEALLOCATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,101, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) + FSCTL_SET_REPAIR* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 102, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_GET_REPAIR* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 103, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_WAIT_FOR_REPAIR* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 104, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_INITIATE_REPAIR* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 106, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_CSC_INTERNAL* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 107, METHOD_NEITHER, FILE_ANY_ACCESS) + FSCTL_SHRINK_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 108, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) + FSCTL_SET_SHORT_NAME_BEHAVIOR* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 109, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_DFSR_SET_GHOST_HANDLE_STATE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 110, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILES* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 120, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_TXFS_LIST_TRANSACTIONS* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 121, METHOD_BUFFERED, FILE_READ_DATA) + FSCTL_QUERY_PAGEFILE_ENCRYPTION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 122, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_RESET_VOLUME_ALLOCATION_HINTS* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 123, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_TXFS_READ_BACKUP_INFORMATION2* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 126, METHOD_BUFFERED, FILE_ANY_ACCESS) + SET_REPAIR_ENABLED* = 0x00000001 + SET_REPAIR_VOLUME_BITMAP_SCAN* = 0x00000002 + SET_REPAIR_DELETE_CROSSLINK* = 0x00000004 + SET_REPAIR_WARN_ABOUT_DATA_LOSS* = 0x00000008 + SET_REPAIR_DISABLED_AND_BUGCHECK_ON_CORRUPT* = 0x00000010 + SET_REPAIR_VALID_MASK* = 0x0000001F + shrinkPrepare* = 0 + shrinkCommit* = 1 + shrinkAbort* = 2 + TXFS_RM_FLAG_LOGGING_MODE* = 0x00000001 + TXFS_RM_FLAG_RENAME_RM* = 0x00000002 + TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MAX* = 0x00000004 + TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MIN* = 0x00000008 + TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS* = 0x00000010 + TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT* = 0x00000020 + TXFS_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE* = 0x00000040 + TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX* = 0x00000080 + TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN* = 0x00000100 + TXFS_RM_FLAG_GROW_LOG* = 0x00000400 + TXFS_RM_FLAG_SHRINK_LOG* = 0x00000800 + TXFS_RM_FLAG_ENFORCE_MINIMUM_SIZE* = 0x00001000 + TXFS_RM_FLAG_PRESERVE_CHANGES* = 0x00002000 + TXFS_RM_FLAG_RESET_RM_AT_NEXT_START* = 0x00004000 + TXFS_RM_FLAG_DO_NOT_RESET_RM_AT_NEXT_START* = 0x00008000 + TXFS_RM_FLAG_PREFER_CONSISTENCY* = 0x00010000 + TXFS_RM_FLAG_PREFER_AVAILABILITY* = 0x00020000 + TXFS_LOGGING_MODE_SIMPLE* = 1 + TXFS_LOGGING_MODE_FULL* = 2 + TXFS_TRANSACTION_STATE_NONE* = 0 + TXFS_TRANSACTION_STATE_ACTIVE* = 1 + TXFS_TRANSACTION_STATE_PREPARED* = 2 + TXFS_TRANSACTION_STATE_NOTACTIVE* = 3 + TXFS_MODIFY_RM_VALID_FLAGS* = TXFS_RM_FLAG_LOGGING_MODE or TXFS_RM_FLAG_RENAME_RM or TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MAX or TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MIN or TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS or TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT or TXFS_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE or TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX or TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN or TXFS_RM_FLAG_SHRINK_LOG or TXFS_RM_FLAG_GROW_LOG or TXFS_RM_FLAG_ENFORCE_MINIMUM_SIZE or TXFS_RM_FLAG_PRESERVE_CHANGES or TXFS_RM_FLAG_RESET_RM_AT_NEXT_START or TXFS_RM_FLAG_DO_NOT_RESET_RM_AT_NEXT_START or TXFS_RM_FLAG_PREFER_CONSISTENCY or TXFS_RM_FLAG_PREFER_AVAILABILITY + TXFS_RM_STATE_NOT_STARTED* = 0 + TXFS_RM_STATE_STARTING* = 1 + TXFS_RM_STATE_ACTIVE* = 3 + TXFS_RM_STATE_SHUTTING_DOWN* = 4 + TXFS_QUERY_RM_INFORMATION_VALID_FLAGS* = TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS or TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT or TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX or TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN or TXFS_RM_FLAG_RESET_RM_AT_NEXT_START or TXFS_RM_FLAG_DO_NOT_RESET_RM_AT_NEXT_START or TXFS_RM_FLAG_PREFER_CONSISTENCY or TXFS_RM_FLAG_PREFER_AVAILABILITY + TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_REDO_LSN* = 0x01 + TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_VIRTUAL_CLOCK* = 0x02 + TXFS_ROLLFORWARD_REDO_VALID_FLAGS* = TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_REDO_LSN or TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_VIRTUAL_CLOCK + TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MAX* = 0x00000001 + TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MIN* = 0x00000002 + TXFS_START_RM_FLAG_LOG_CONTAINER_SIZE* = 0x00000004 + TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS* = 0x00000008 + TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT* = 0x00000010 + TXFS_START_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE* = 0x00000020 + TXFS_START_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX* = 0x00000040 + TXFS_START_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN* = 0x00000080 + TXFS_START_RM_FLAG_RECOVER_BEST_EFFORT* = 0x00000200 + TXFS_START_RM_FLAG_LOGGING_MODE* = 0x00000400 + TXFS_START_RM_FLAG_PRESERVE_CHANGES* = 0x00000800 + TXFS_START_RM_FLAG_PREFER_CONSISTENCY* = 0x00001000 + TXFS_START_RM_FLAG_PREFER_AVAILABILITY* = 0x00002000 + TXFS_START_RM_VALID_FLAGS* = TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MAX or TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MIN or TXFS_START_RM_FLAG_LOG_CONTAINER_SIZE or TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS or TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT or TXFS_START_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE or TXFS_START_RM_FLAG_RECOVER_BEST_EFFORT or TXFS_START_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX or TXFS_START_RM_FLAG_LOGGING_MODE or TXFS_START_RM_FLAG_PRESERVE_CHANGES or TXFS_START_RM_FLAG_PREFER_CONSISTENCY or TXFS_START_RM_FLAG_PREFER_AVAILABILITY + TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY_FLAG_CREATED* = 0x00000001 + TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY_FLAG_DELETED* = 0x000000012 + TXFS_TRANSACTED_VERSION_NONTRANSACTED* = 0xFFFFFFFE'i32 + TXFS_TRANSACTED_VERSION_UNCOMMITTED* = 0xFFFFFFFF'i32 + TXFS_SAVEPOINT_SET* = 1 + TXFS_SAVEPOINT_ROLLBACK* = 2 + TXFS_SAVEPOINT_CLEAR* = 4 + TXFS_SAVEPOINT_CLEAR_ALL* = 16 + writeCacheTypeUnknown* = 0 + writeCacheTypeNone* = 1 + writeCacheTypeWriteBack* = 2 + writeCacheTypeWriteThrough* = 3 + writeCacheEnableUnknown* = 0 + writeCacheDisabled* = 1 + writeCacheEnabled* = 2 + writeCacheChangeUnknown* = 0 + writeCacheNotChangeable* = 1 + writeCacheChangeable* = 2 + writeThroughUnknown* = 0 + writeThroughNotSupported* = 1 + writeThroughSupported* = 2 + storagePortCodeSetReserved* = 0 + storagePortCodeSetStorport* = 1 + storagePortCodeSetSCSIport* = 2 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_MASK* = 0xff000000'i32 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_PAGE_FILE* = 0x00000001 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_DENY_DEFRAG_SET* = 0x00000002 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_FS_SYSTEM_FILE* = 0x00000004 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_TXF_SYSTEM_FILE* = 0x00000008 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_DATA* = 0x01000000 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_INDEX* = 0x02000000 + LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_SYSTEM* = 0x03000000 + FSCTL_QUERY_DEPENDENT_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,124, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_SD_GLOBAL_CHANGE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,125, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_LOOKUP_STREAM_FROM_CLUSTER* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,127, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_TXFS_WRITE_BACKUP_INFORMATION2* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,128, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_FILE_TYPE_NOTIFICATION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,129, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_GET_BOOT_AREA_INFO* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,140, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_GET_RETRIEVAL_POINTER_BASE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,141, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_SET_PERSISTENT_VOLUME_STATE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 142, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_QUERY_PERSISTENT_VOLUME_STATE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 143, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_REQUEST_OPLOCK* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,144,METHOD_BUFFERED,FILE_ANY_ACCESS) + FSCTL_CSV_TUNNEL_REQUEST* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 145, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_IS_CSV_FILE* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 146, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_QUERY_FILE_SYSTEM_RECOGNITION* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,147, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_CSV_GET_VOLUME_PATH_NAME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM,148, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_CSV_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 149, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_CSV_GET_VOLUME_PATH_NAMES_FOR_VOLUME_NAME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 150, METHOD_BUFFERED, FILE_ANY_ACCESS) + FSCTL_IS_FILE_ON_CSV_VOLUME* = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 151, METHOD_BUFFERED, FILE_ANY_ACCESS) + IOCTL_VOLUME_BASE* = (DWORD) 'V' + IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS* = CTL_CODE(IOCTL_VOLUME_BASE,0,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_SUPPORTS_ONLINE_OFFLINE* = CTL_CODE(IOCTL_VOLUME_BASE,1,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_ONLINE* = CTL_CODE(IOCTL_VOLUME_BASE,2,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_VOLUME_OFFLINE* = CTL_CODE(IOCTL_VOLUME_BASE,3,METHOD_BUFFERED,FILE_READ_ACCESS or FILE_WRITE_ACCESS) + IOCTL_VOLUME_IS_OFFLINE* = CTL_CODE(IOCTL_VOLUME_BASE,4,METHOD_BUFFERED, FILE_ANY_ACCESS) + IOCTL_VOLUME_IS_IO_CAPABLE* = CTL_CODE(IOCTL_VOLUME_BASE,5,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_QUERY_FAILOVER_SET* = CTL_CODE(IOCTL_VOLUME_BASE,6,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_QUERY_VOLUME_NUMBER* = CTL_CODE(IOCTL_VOLUME_BASE,7,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_LOGICAL_TO_PHYSICAL* = CTL_CODE(IOCTL_VOLUME_BASE,8,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_PHYSICAL_TO_LOGICAL* = CTL_CODE(IOCTL_VOLUME_BASE,9,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_IS_CLUSTERED* = CTL_CODE(IOCTL_VOLUME_BASE,12,METHOD_BUFFERED,FILE_ANY_ACCESS) + IOCTL_VOLUME_GET_GPT_ATTRIBUTES* = CTL_CODE(IOCTL_VOLUME_BASE,14,METHOD_BUFFERED,FILE_ANY_ACCESS) + HISTOGRAM_BUCKET_SIZE* = 0x00000008 + DISK_HISTOGRAM_SIZE* = 0x00000048 +type + FILE_SYSTEM_RECOGNITION_STRUCTURE* {.pure.} = object + Jmp*: array[3, UCHAR] + FsName*: array[8, UCHAR] + MustBeZero*: array[5, UCHAR] + Identifier*: ULONG + Length*: USHORT + Checksum*: USHORT +proc `Mbr=`*(self: var SET_PARTITION_INFORMATION_EX, x: SET_PARTITION_INFORMATION_MBR) {.inline.} = self.union1.Mbr = x +proc Mbr*(self: SET_PARTITION_INFORMATION_EX): SET_PARTITION_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc Mbr*(self: var SET_PARTITION_INFORMATION_EX): var SET_PARTITION_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc `Gpt=`*(self: var SET_PARTITION_INFORMATION_EX, x: SET_PARTITION_INFORMATION_GPT) {.inline.} = self.union1.Gpt = x +proc Gpt*(self: SET_PARTITION_INFORMATION_EX): SET_PARTITION_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc Gpt*(self: var SET_PARTITION_INFORMATION_EX): var SET_PARTITION_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc `Mbr=`*(self: var CREATE_DISK, x: CREATE_DISK_MBR) {.inline.} = self.union1.Mbr = x +proc Mbr*(self: CREATE_DISK): CREATE_DISK_MBR {.inline.} = self.union1.Mbr +proc Mbr*(self: var CREATE_DISK): var CREATE_DISK_MBR {.inline.} = self.union1.Mbr +proc `Gpt=`*(self: var CREATE_DISK, x: CREATE_DISK_GPT) {.inline.} = self.union1.Gpt = x +proc Gpt*(self: CREATE_DISK): CREATE_DISK_GPT {.inline.} = self.union1.Gpt +proc Gpt*(self: var CREATE_DISK): var CREATE_DISK_GPT {.inline.} = self.union1.Gpt +proc `Mbr=`*(self: var PARTITION_INFORMATION_EX, x: PARTITION_INFORMATION_MBR) {.inline.} = self.union1.Mbr = x +proc Mbr*(self: PARTITION_INFORMATION_EX): PARTITION_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc Mbr*(self: var PARTITION_INFORMATION_EX): var PARTITION_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc `Gpt=`*(self: var PARTITION_INFORMATION_EX, x: PARTITION_INFORMATION_GPT) {.inline.} = self.union1.Gpt = x +proc Gpt*(self: PARTITION_INFORMATION_EX): PARTITION_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc Gpt*(self: var PARTITION_INFORMATION_EX): var PARTITION_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc `Mbr=`*(self: var DRIVE_LAYOUT_INFORMATION_EX, x: DRIVE_LAYOUT_INFORMATION_MBR) {.inline.} = self.union1.Mbr = x +proc Mbr*(self: DRIVE_LAYOUT_INFORMATION_EX): DRIVE_LAYOUT_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc Mbr*(self: var DRIVE_LAYOUT_INFORMATION_EX): var DRIVE_LAYOUT_INFORMATION_MBR {.inline.} = self.union1.Mbr +proc `Gpt=`*(self: var DRIVE_LAYOUT_INFORMATION_EX, x: DRIVE_LAYOUT_INFORMATION_GPT) {.inline.} = self.union1.Gpt = x +proc Gpt*(self: DRIVE_LAYOUT_INFORMATION_EX): DRIVE_LAYOUT_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc Gpt*(self: var DRIVE_LAYOUT_INFORMATION_EX): var DRIVE_LAYOUT_INFORMATION_GPT {.inline.} = self.union1.Gpt +proc `Int13=`*(self: var DISK_DETECTION_INFO, x: DISK_INT13_INFO) {.inline.} = self.union1.struct1.Int13 = x +proc Int13*(self: DISK_DETECTION_INFO): DISK_INT13_INFO {.inline.} = self.union1.struct1.Int13 +proc Int13*(self: var DISK_DETECTION_INFO): var DISK_INT13_INFO {.inline.} = self.union1.struct1.Int13 +proc `ExInt13=`*(self: var DISK_DETECTION_INFO, x: DISK_EX_INT13_INFO) {.inline.} = self.union1.struct1.ExInt13 = x +proc ExInt13*(self: DISK_DETECTION_INFO): DISK_EX_INT13_INFO {.inline.} = self.union1.struct1.ExInt13 +proc ExInt13*(self: var DISK_DETECTION_INFO): var DISK_EX_INT13_INFO {.inline.} = self.union1.struct1.ExInt13 +proc `Mbr=`*(self: var DISK_PARTITION_INFO, x: DISK_PARTITION_INFO_UNION1_Mbr) {.inline.} = self.union1.Mbr = x +proc Mbr*(self: DISK_PARTITION_INFO): DISK_PARTITION_INFO_UNION1_Mbr {.inline.} = self.union1.Mbr +proc Mbr*(self: var DISK_PARTITION_INFO): var DISK_PARTITION_INFO_UNION1_Mbr {.inline.} = self.union1.Mbr +proc `Gpt=`*(self: var DISK_PARTITION_INFO, x: DISK_PARTITION_INFO_UNION1_Gpt) {.inline.} = self.union1.Gpt = x +proc Gpt*(self: DISK_PARTITION_INFO): DISK_PARTITION_INFO_UNION1_Gpt {.inline.} = self.union1.Gpt +proc Gpt*(self: var DISK_PARTITION_INFO): var DISK_PARTITION_INFO_UNION1_Gpt {.inline.} = self.union1.Gpt +proc `ScalarPrefetch=`*(self: var DISK_CACHE_INFORMATION, x: DISK_CACHE_INFORMATION_UNION1_ScalarPrefetch) {.inline.} = self.union1.ScalarPrefetch = x +proc ScalarPrefetch*(self: DISK_CACHE_INFORMATION): DISK_CACHE_INFORMATION_UNION1_ScalarPrefetch {.inline.} = self.union1.ScalarPrefetch +proc ScalarPrefetch*(self: var DISK_CACHE_INFORMATION): var DISK_CACHE_INFORMATION_UNION1_ScalarPrefetch {.inline.} = self.union1.ScalarPrefetch +proc `BlockPrefetch=`*(self: var DISK_CACHE_INFORMATION, x: DISK_CACHE_INFORMATION_UNION1_BlockPrefetch) {.inline.} = self.union1.BlockPrefetch = x +proc BlockPrefetch*(self: DISK_CACHE_INFORMATION): DISK_CACHE_INFORMATION_UNION1_BlockPrefetch {.inline.} = self.union1.BlockPrefetch +proc BlockPrefetch*(self: var DISK_CACHE_INFORMATION): var DISK_CACHE_INFORMATION_UNION1_BlockPrefetch {.inline.} = self.union1.BlockPrefetch +proc `BirthVolumeId=`*(self: var FILE_OBJECTID_BUFFER, x: array[16, BYTE]) {.inline.} = self.union1.struct1.BirthVolumeId = x +proc BirthVolumeId*(self: FILE_OBJECTID_BUFFER): array[16, BYTE] {.inline.} = self.union1.struct1.BirthVolumeId +proc BirthVolumeId*(self: var FILE_OBJECTID_BUFFER): var array[16, BYTE] {.inline.} = self.union1.struct1.BirthVolumeId +proc `BirthObjectId=`*(self: var FILE_OBJECTID_BUFFER, x: array[16, BYTE]) {.inline.} = self.union1.struct1.BirthObjectId = x +proc BirthObjectId*(self: FILE_OBJECTID_BUFFER): array[16, BYTE] {.inline.} = self.union1.struct1.BirthObjectId +proc BirthObjectId*(self: var FILE_OBJECTID_BUFFER): var array[16, BYTE] {.inline.} = self.union1.struct1.BirthObjectId +proc `DomainId=`*(self: var FILE_OBJECTID_BUFFER, x: array[16, BYTE]) {.inline.} = self.union1.struct1.DomainId = x +proc DomainId*(self: FILE_OBJECTID_BUFFER): array[16, BYTE] {.inline.} = self.union1.struct1.DomainId +proc DomainId*(self: var FILE_OBJECTID_BUFFER): var array[16, BYTE] {.inline.} = self.union1.struct1.DomainId +proc `ExtendedInfo=`*(self: var FILE_OBJECTID_BUFFER, x: array[48, BYTE]) {.inline.} = self.union1.ExtendedInfo = x +proc ExtendedInfo*(self: FILE_OBJECTID_BUFFER): array[48, BYTE] {.inline.} = self.union1.ExtendedInfo +proc ExtendedInfo*(self: var FILE_OBJECTID_BUFFER): var array[48, BYTE] {.inline.} = self.union1.ExtendedInfo +proc `BufferLength=`*(self: var TXFS_READ_BACKUP_INFORMATION_OUT, x: ULONG) {.inline.} = self.union1.BufferLength = x +proc BufferLength*(self: TXFS_READ_BACKUP_INFORMATION_OUT): ULONG {.inline.} = self.union1.BufferLength +proc BufferLength*(self: var TXFS_READ_BACKUP_INFORMATION_OUT): var ULONG {.inline.} = self.union1.BufferLength +proc `Buffer=`*(self: var TXFS_READ_BACKUP_INFORMATION_OUT, x: UCHAR) {.inline.} = self.union1.Buffer = x +proc Buffer*(self: TXFS_READ_BACKUP_INFORMATION_OUT): UCHAR {.inline.} = self.union1.Buffer +proc Buffer*(self: var TXFS_READ_BACKUP_INFORMATION_OUT): var UCHAR {.inline.} = self.union1.Buffer +when winimCpu64: + type + MOVE_FILE_DATA32* {.pure.} = object + FileHandle*: UINT32 + StartingVcn*: LARGE_INTEGER + StartingLcn*: LARGE_INTEGER + ClusterCount*: DWORD + PMOVE_FILE_DATA32* = ptr MOVE_FILE_DATA32 + MARK_HANDLE_INFO32* {.pure.} = object + UsnSourceInfo*: DWORD + VolumeHandle*: UINT32 + HandleInfo*: DWORD + PMARK_HANDLE_INFO32* = ptr MARK_HANDLE_INFO32 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winldap.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winldap.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1034 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wincrypt +#include +#include +#include +#include +type + ber_tag_t* = int32 + ber_int_t* = int32 + ber_uint_t* = int32 + ber_len_t* = int32 + ber_slen_t* = int32 + LDAP_RETCODE* = int32 + SecPkgContext_IssuerListInfo* {.pure.} = object + cbIssuerList*: DWORD + pIssuerList*: PBYTE + PSecPkgContext_IssuerListInfo* = ptr SecPkgContext_IssuerListInfo + SecPkgContext_RemoteCredentialInfo* {.pure.} = object + cbCertificateChain*: DWORD + pbCertificateChain*: PBYTE + cCertificates*: DWORD + fFlags*: DWORD + dwBits*: DWORD + PSecPkgContext_RemoteCredentialInfo* = ptr SecPkgContext_RemoteCredentialInfo + SecPkgContext_RemoteCredenitalInfo* = SecPkgContext_RemoteCredentialInfo + PSecPkgContext_RemoteCredenitalInfo* = ptr SecPkgContext_RemoteCredentialInfo + SecPkgContext_LocalCredentialInfo* {.pure.} = object + cbCertificateChain*: DWORD + pbCertificateChain*: PBYTE + cCertificates*: DWORD + fFlags*: DWORD + dwBits*: DWORD + PSecPkgContext_LocalCredentialInfo* = ptr SecPkgContext_LocalCredentialInfo + SecPkgContext_LocalCredenitalInfo* = SecPkgContext_LocalCredentialInfo + PSecPkgContext_LocalCredenitalInfo* = ptr SecPkgContext_LocalCredentialInfo + SecPkgCred_SupportedAlgs* {.pure.} = object + cSupportedAlgs*: DWORD + palgSupportedAlgs*: ptr ALG_ID + PSecPkgCred_SupportedAlgs* = ptr SecPkgCred_SupportedAlgs + SecPkgCred_CipherStrengths* {.pure.} = object + dwMinimumCipherStrength*: DWORD + dwMaximumCipherStrength*: DWORD + PSecPkgCred_CipherStrengths* = ptr SecPkgCred_CipherStrengths + SecPkgCred_SupportedProtocols* {.pure.} = object + grbitProtocol*: DWORD + PSecPkgCred_SupportedProtocols* = ptr SecPkgCred_SupportedProtocols + SecPkgContext_IssuerListInfoEx* {.pure.} = object + aIssuers*: PCERT_NAME_BLOB + cIssuers*: DWORD + PSecPkgContext_IssuerListInfoEx* = ptr SecPkgContext_IssuerListInfoEx + SecPkgContext_ConnectionInfo* {.pure.} = object + dwProtocol*: DWORD + aiCipher*: ALG_ID + dwCipherStrength*: DWORD + aiHash*: ALG_ID + dwHashStrength*: DWORD + aiExch*: ALG_ID + dwExchStrength*: DWORD + PSecPkgContext_ConnectionInfo* = ptr SecPkgContext_ConnectionInfo + SecPkgContext_EapKeyBlock* {.pure.} = object + rgbKeys*: array[128, BYTE] + rgbIVs*: array[64, BYTE] + PSecPkgContext_EapKeyBlock* = ptr SecPkgContext_EapKeyBlock + SecPkgContext_MappedCredAttr* {.pure.} = object + dwAttribute*: DWORD + pvBuffer*: PVOID + PSecPkgContext_MappedCredAttr* = ptr SecPkgContext_MappedCredAttr + SecPkgContext_SessionInfo* {.pure.} = object + dwFlags*: DWORD + cbSessionId*: DWORD + rgbSessionId*: array[32, BYTE] + PSecPkgContext_SessionInfo* = ptr SecPkgContext_SessionInfo + SecPkgContext_SessionAppData* {.pure.} = object + dwFlags*: DWORD + cbAppData*: DWORD + pbAppData*: PBYTE + PSecPkgContext_SessionAppData* = ptr SecPkgContext_SessionAppData + HMAPPER* {.pure.} = object + SCHANNEL_CRED* {.pure.} = object + dwVersion*: DWORD + cCreds*: DWORD + paCred*: ptr PCCERT_CONTEXT + hRootStore*: HCERTSTORE + cMappers*: DWORD + aphMappers*: ptr ptr HMAPPER + cSupportedAlgs*: DWORD + palgSupportedAlgs*: ptr ALG_ID + grbitEnabledProtocols*: DWORD + dwMinimumCipherStrength*: DWORD + dwMaximumCipherStrength*: DWORD + dwSessionLifespan*: DWORD + dwFlags*: DWORD + dwCredFormat*: DWORD + PSCHANNEL_CRED* = ptr SCHANNEL_CRED + SCHANNEL_CERT_HASH* {.pure.} = object + dwLength*: DWORD + dwFlags*: DWORD + hProv*: HCRYPTPROV + ShaHash*: array[20, BYTE] + PSCHANNEL_CERT_HASH* = ptr SCHANNEL_CERT_HASH + SSL_CREDENTIAL_CERTIFICATE* {.pure.} = object + cbPrivateKey*: DWORD + pPrivateKey*: PBYTE + cbCertificate*: DWORD + pCertificate*: PBYTE + pszPassword*: PSTR + PSSL_CREDENTIAL_CERTIFICATE* = ptr SSL_CREDENTIAL_CERTIFICATE + SCH_CRED* {.pure.} = object + dwVersion*: DWORD + cCreds*: DWORD + paSecret*: ptr PVOID + paPublic*: ptr PVOID + cMappers*: DWORD + aphMappers*: ptr ptr HMAPPER + PSCH_CRED* = ptr SCH_CRED + SCH_CRED_SECRET_CAPI* {.pure.} = object + dwType*: DWORD + hProv*: HCRYPTPROV + PSCH_CRED_SECRET_CAPI* = ptr SCH_CRED_SECRET_CAPI + SCH_CRED_SECRET_PRIVKEY* {.pure.} = object + dwType*: DWORD + pPrivateKey*: PBYTE + cbPrivateKey*: DWORD + pszPassword*: PSTR + PSCH_CRED_SECRET_PRIVKEY* = ptr SCH_CRED_SECRET_PRIVKEY + SCH_CRED_PUBLIC_CERTCHAIN* {.pure.} = object + dwType*: DWORD + cbCertChain*: DWORD + pCertChain*: PBYTE + PSCH_CRED_PUBLIC_CERTCHAIN* = ptr SCH_CRED_PUBLIC_CERTCHAIN + SCH_CRED_PUBLIC_CAPI* {.pure.} = object + dwType*: DWORD + hProv*: HCRYPTPROV + PSCH_CRED_PUBLIC_CAPI* = ptr SCH_CRED_PUBLIC_CAPI + PctPublicKey* {.pure.} = object + Type*: DWORD + cbKey*: DWORD + pKey*: array[1, UCHAR] + X509Certificate* {.pure.} = object + Version*: DWORD + SerialNumber*: array[4, DWORD] + SignatureAlgorithm*: ALG_ID + ValidFrom*: FILETIME + ValidUntil*: FILETIME + pszIssuer*: PSTR + pszSubject*: PSTR + pPublicKey*: ptr PctPublicKey + PX509Certificate* = ptr X509Certificate + SecPkgContext_EapPrfInfo* {.pure.} = object + dwVersion*: DWORD + cbPrfData*: DWORD + PSecPkgContext_EapPrfInfo* = ptr SecPkgContext_EapPrfInfo + SecPkgContext_SupportedSignatures* {.pure.} = object + cSignatureAndHashAlgorithms*: WORD + pSignatureAndHashAlgorithms*: ptr WORD + PSecPkgContext_SupportedSignatures* = ptr SecPkgContext_SupportedSignatures + LDAP_ld_sb* {.pure.} = object + sb_sd*: UINT_PTR + Reserved1*: array[(10*sizeof(ULONG))+1, UCHAR] + sb_naddr*: ULONG_PTR + Reserved2*: array[(6*sizeof(ULONG)), UCHAR] + LDAP* {.pure.} = object + ld_sb*: LDAP_ld_sb + ld_host*: PCHAR + ld_version*: ULONG + ld_lberoptions*: UCHAR + ld_deref*: ULONG + ld_timelimit*: ULONG + ld_sizelimit*: ULONG + ld_errno*: ULONG + ld_matched*: PCHAR + ld_error*: PCHAR + ld_msgid*: ULONG + Reserved3*: array[(6*sizeof(ULONG))+1, UCHAR] + ld_cldaptries*: ULONG + ld_cldaptimeout*: ULONG + ld_refhoplimit*: ULONG + ld_options*: ULONG + PLDAP* = ptr LDAP + LDAP_TIMEVAL* {.pure.} = object + tv_sec*: LONG + tv_usec*: LONG + PLDAP_TIMEVAL* = ptr LDAP_TIMEVAL + LDAP_BERVAL* {.pure.} = object + bv_len*: ULONG + bv_val*: PCHAR + PLDAP_BERVAL* = ptr LDAP_BERVAL + BERVAL* = LDAP_BERVAL + PBERVAL* = ptr LDAP_BERVAL + BerValue* = LDAP_BERVAL + LDAPMessage* {.pure.} = object + lm_msgid*: ULONG + lm_msgtype*: ULONG + lm_ber*: PVOID + lm_chain*: ptr LDAPMessage + lm_next*: ptr LDAPMessage + lm_time*: ULONG + Connection*: PLDAP + Request*: PVOID + lm_returncode*: ULONG + lm_referral*: USHORT + lm_chased*: BOOLEAN + lm_eom*: BOOLEAN + ConnectionReferenced*: BOOLEAN + PLDAPMessage* = ptr LDAPMessage + LDAPControlA* {.pure.} = object + ldctl_oid*: PCHAR + ldctl_value*: BERVAL + ldctl_iscritical*: BOOLEAN + PLDAPControlA* = ptr LDAPControlA + LDAPControlW* {.pure.} = object + ldctl_oid*: PWCHAR + ldctl_value*: BERVAL + ldctl_iscritical*: BOOLEAN + PLDAPControlW* = ptr LDAPControlW + LDAPModW_mod_vals* {.pure, union.} = object + modv_strvals*: ptr PWCHAR + modv_bvals*: ptr ptr BERVAL + LDAPModW* {.pure.} = object + mod_op*: ULONG + mod_type*: PWCHAR + mod_vals*: LDAPModW_mod_vals + PLDAPModW* = ptr LDAPModW + LDAPModA_mod_vals* {.pure, union.} = object + modv_strvals*: ptr PCHAR + modv_bvals*: ptr ptr BERVAL + LDAPModA* {.pure.} = object + mod_op*: ULONG + mod_type*: PCHAR + mod_vals*: LDAPModA_mod_vals + PLDAPModA* = ptr LDAPModA + LDAP_VERSION_INFO* {.pure.} = object + lv_size*: ULONG + lv_major*: ULONG + lv_minor*: ULONG + PLDAP_VERSION_INFO* = ptr LDAP_VERSION_INFO + LDAPSortKeyW* {.pure.} = object + sk_attrtype*: PWCHAR + sk_matchruleoid*: PWCHAR + sk_reverseorder*: BOOLEAN + PLDAPSortKeyW* = ptr LDAPSortKeyW + LDAPSortKeyA* {.pure.} = object + sk_attrtype*: PCHAR + sk_matchruleoid*: PCHAR + sk_reverseorder*: BOOLEAN + PLDAPSortKeyA* = ptr LDAPSortKeyA + LDAPVLVInfo* {.pure.} = object + ldvlv_version*: int32 + ldvlv_before_count*: ULONG + ldvlv_after_count*: ULONG + ldvlv_offset*: ULONG + ldvlv_count*: ULONG + ldvlv_attrvalue*: PBERVAL + ldvlv_context*: PBERVAL + ldvlv_extradata*: pointer + PLDAPVLVInfo* = ptr LDAPVLVInfo + QUERYFORCONNECTION* = proc (PrimaryConnection: PLDAP, ReferralFromConnection: PLDAP, NewDN: PWCHAR, HostName: PCHAR, PortNumber: ULONG, SecAuthIdentity: PVOID, CurrentUserToken: PVOID, ConnectionToUse: ptr PLDAP): ULONG {.stdcall.} + NOTIFYOFNEWCONNECTION* = proc (PrimaryConnection: PLDAP, ReferralFromConnection: PLDAP, NewDN: PWCHAR, HostName: PCHAR, NewConnection: PLDAP, PortNumber: ULONG, SecAuthIdentity: PVOID, CurrentUser: PVOID, ErrorCodeFromBind: ULONG): BOOLEAN {.stdcall.} + DEREFERENCECONNECTION* = proc (PrimaryConnection: PLDAP, ConnectionToDereference: PLDAP): ULONG {.stdcall.} + LDAP_REFERRAL_CALLBACK* {.pure.} = object + SizeOfCallbacks*: ULONG + QueryForConnection*: ptr QUERYFORCONNECTION + NotifyRoutine*: ptr NOTIFYOFNEWCONNECTION + DereferenceRoutine*: ptr DEREFERENCECONNECTION + PLDAP_REFERRAL_CALLBACK* = ptr LDAP_REFERRAL_CALLBACK + DBGPRINT* = proc (Format: PCH): ULONG {.varargs, cdecl.} + LDAPSearch* {.pure.} = object + PLDAPSearch* = ptr LDAPSearch +const + LBER_ERROR* = 0xffffffff'i32 + LBER_DEFAULT* = 0xffffffff'i32 + UNISP_NAME_A* = "Microsoft Unified Security Protocol Provider" + UNISP_NAME_W* = "Microsoft Unified Security Protocol Provider" + SSL2SP_NAME_A* = "Microsoft SSL 2.0" + SSL2SP_NAME_W* = "Microsoft SSL 2.0" + SSL3SP_NAME_A* = "Microsoft SSL 3.0" + SSL3SP_NAME_W* = "Microsoft SSL 3.0" + TLS1SP_NAME_A* = "Microsoft TLS 1.0" + TLS1SP_NAME_W* = "Microsoft TLS 1.0" + PCT1SP_NAME_A* = "Microsoft PCT 1.0" + PCT1SP_NAME_W* = "Microsoft PCT 1.0" + SCHANNEL_NAME_A* = "Schannel" + SCHANNEL_NAME_W* = "Schannel" + UNISP_RPC_ID* = 14 + SECPKG_ATTR_ISSUER_LIST* = 0x50 + SECPKG_ATTR_REMOTE_CRED* = 0x51 + SECPKG_ATTR_LOCAL_CRED* = 0x52 + SECPKG_ATTR_REMOTE_CERT_CONTEXT* = 0x53 + SECPKG_ATTR_LOCAL_CERT_CONTEXT* = 0x54 + SECPKG_ATTR_ROOT_STORE* = 0x55 + SECPKG_ATTR_SUPPORTED_ALGS* = 0x56 + SECPKG_ATTR_CIPHER_STRENGTHS* = 0x57 + SECPKG_ATTR_SUPPORTED_PROTOCOLS* = 0x58 + SECPKG_ATTR_ISSUER_LIST_EX* = 0x59 + SECPKG_ATTR_CONNECTION_INFO* = 0x5a + SECPKG_ATTR_EAP_KEY_BLOCK* = 0x5b + SECPKG_ATTR_MAPPED_CRED_ATTR* = 0x5c + SECPKG_ATTR_SESSION_INFO* = 0x5d + SECPKG_ATTR_APP_DATA* = 0x5e + RCRED_STATUS_NOCRED* = 0x00000000 + RCRED_CRED_EXISTS* = 0x00000001 + RCRED_STATUS_UNKNOWN_ISSUER* = 0x00000002 + LCRED_STATUS_NOCRED* = 0x00000000 + LCRED_CRED_EXISTS* = 0x00000001 + LCRED_STATUS_UNKNOWN_ISSUER* = 0x00000002 + SSL_SESSION_RECONNECT* = 1 + SCH_CRED_V1* = 0x00000001 + SCH_CRED_V2* = 0x00000002 + SCH_CRED_VERSION* = 0x00000002 + SCH_CRED_V3* = 0x00000003 + SCHANNEL_CRED_VERSION* = 0x00000004 + SCH_CRED_FORMAT_CERT_HASH* = 0x00000001 + SCH_CRED_MAX_SUPPORTED_ALGS* = 256 + SCH_CRED_MAX_SUPPORTED_CERTS* = 100 + SCH_MACHINE_CERT_HASH* = 0x00000001 + SCH_CRED_NO_SYSTEM_MAPPER* = 0x00000002 + SCH_CRED_NO_SERVERNAME_CHECK* = 0x00000004 + SCH_CRED_MANUAL_CRED_VALIDATION* = 0x00000008 + SCH_CRED_NO_DEFAULT_CREDS* = 0x00000010 + SCH_CRED_AUTO_CRED_VALIDATION* = 0x00000020 + SCH_CRED_USE_DEFAULT_CREDS* = 0x00000040 + SCH_CRED_DISABLE_RECONNECTS* = 0x00000080 + SCH_CRED_REVOCATION_CHECK_END_CERT* = 0x00000100 + SCH_CRED_REVOCATION_CHECK_CHAIN* = 0x00000200 + SCH_CRED_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT* = 0x00000400 + SCH_CRED_IGNORE_NO_REVOCATION_CHECK* = 0x00000800 + SCH_CRED_IGNORE_REVOCATION_OFFLINE* = 0x00001000 + SCH_CRED_REVOCATION_CHECK_CACHE_ONLY* = 0x00004000 + SCH_CRED_CACHE_ONLY_URL_RETRIEVAL* = 0x00008000 + SCHANNEL_RENEGOTIATE* = 0 + SCHANNEL_SHUTDOWN* = 1 + SCHANNEL_ALERT* = 2 + SCHANNEL_SESSION* = 3 + TLS1_ALERT_WARNING* = 1 + TLS1_ALERT_FATAL* = 2 + TLS1_ALERT_CLOSE_NOTIFY* = 0 + TLS1_ALERT_UNEXPECTED_MESSAGE* = 10 + TLS1_ALERT_BAD_RECORD_MAC* = 20 + TLS1_ALERT_DECRYPTION_FAILED* = 21 + TLS1_ALERT_RECORD_OVERFLOW* = 22 + TLS1_ALERT_DECOMPRESSION_FAIL* = 30 + TLS1_ALERT_HANDSHAKE_FAILURE* = 40 + TLS1_ALERT_BAD_CERTIFICATE* = 42 + TLS1_ALERT_UNSUPPORTED_CERT* = 43 + TLS1_ALERT_CERTIFICATE_REVOKED* = 44 + TLS1_ALERT_CERTIFICATE_EXPIRED* = 45 + TLS1_ALERT_CERTIFICATE_UNKNOWN* = 46 + TLS1_ALERT_ILLEGAL_PARAMETER* = 47 + TLS1_ALERT_UNKNOWN_CA* = 48 + TLS1_ALERT_ACCESS_DENIED* = 49 + TLS1_ALERT_DECODE_ERROR* = 50 + TLS1_ALERT_DECRYPT_ERROR* = 51 + TLS1_ALERT_EXPORT_RESTRICTION* = 60 + TLS1_ALERT_PROTOCOL_VERSION* = 70 + TLS1_ALERT_INSUFFIENT_SECURITY* = 71 + TLS1_ALERT_INTERNAL_ERROR* = 80 + TLS1_ALERT_USER_CANCELED* = 90 + TLS1_ALERT_NO_RENEGOTIATATION* = 100 + SSL_SESSION_ENABLE_RECONNECTS* = 1 + SSL_SESSION_DISABLE_RECONNECTS* = 2 + CERT_SCHANNEL_IIS_PRIVATE_KEY_PROP_ID* = CERT_FIRST_USER_PROP_ID+0 + CERT_SCHANNEL_IIS_PASSWORD_PROP_ID* = CERT_FIRST_USER_PROP_ID+1 + CERT_SCHANNEL_SGC_CERTIFICATE_PROP_ID* = CERT_FIRST_USER_PROP_ID+2 + SP_PROT_PCT1_SERVER* = 0x00000001 + SP_PROT_PCT1_CLIENT* = 0x00000002 + SP_PROT_PCT1* = SP_PROT_PCT1_SERVER or SP_PROT_PCT1_CLIENT + SP_PROT_SSL2_SERVER* = 0x00000004 + SP_PROT_SSL2_CLIENT* = 0x00000008 + SP_PROT_SSL2* = SP_PROT_SSL2_SERVER or SP_PROT_SSL2_CLIENT + SP_PROT_SSL3_SERVER* = 0x00000010 + SP_PROT_SSL3_CLIENT* = 0x00000020 + SP_PROT_SSL3* = SP_PROT_SSL3_SERVER or SP_PROT_SSL3_CLIENT + SP_PROT_TLS1_SERVER* = 0x00000040 + SP_PROT_TLS1_CLIENT* = 0x00000080 + SP_PROT_TLS1* = SP_PROT_TLS1_SERVER or SP_PROT_TLS1_CLIENT + SP_PROT_SSL3TLS1_CLIENTS* = SP_PROT_TLS1_CLIENT or SP_PROT_SSL3_CLIENT + SP_PROT_SSL3TLS1_SERVERS* = SP_PROT_TLS1_SERVER or SP_PROT_SSL3_SERVER + SP_PROT_SSL3TLS1* = SP_PROT_SSL3 or SP_PROT_TLS1 + SP_PROT_UNI_SERVER* = 0x40000000 + SP_PROT_UNI_CLIENT* = 0x80000000'i32 + SP_PROT_UNI* = SP_PROT_UNI_SERVER or SP_PROT_UNI_CLIENT + SP_PROT_ALL* = 0xffffffff'i32 + SP_PROT_NONE* = 0 + SP_PROT_CLIENTS* = SP_PROT_PCT1_CLIENT or SP_PROT_SSL2_CLIENT or SP_PROT_SSL3_CLIENT or SP_PROT_UNI_CLIENT or SP_PROT_TLS1_CLIENT + SP_PROT_SERVERS* = SP_PROT_PCT1_SERVER or SP_PROT_SSL2_SERVER or SP_PROT_SSL3_SERVER or SP_PROT_UNI_SERVER or SP_PROT_TLS1_SERVER + SCHANNEL_SECRET_TYPE_CAPI* = 0x00000001 + SCHANNEL_SECRET_PRIVKEY* = 0x00000002 + SCH_CRED_X509_CERTCHAIN* = 0x00000001 + SCH_CRED_X509_CAPI* = 0x00000002 + SCH_CRED_CERT_CONTEXT* = 0x00000003 + SSL_CRACK_CERTIFICATE_NAME* = "SslCrackCertificate" + SSL_FREE_CERTIFICATE_NAME* = "SslFreeCertificate" + LDAP_PORT* = 389 + LDAP_SSL_PORT* = 636 + LDAP_GC_PORT* = 3268 + LDAP_SSL_GC_PORT* = 3269 + LDAP_VERSION1* = 1 + LDAP_VERSION2* = 2 + LDAP_VERSION3* = 3 + LDAP_VERSION* = LDAP_VERSION2 + LDAP_BIND_CMD* = 0x60 + LDAP_UNBIND_CMD* = 0x42 + LDAP_SEARCH_CMD* = 0x63 + LDAP_MODIFY_CMD* = 0x66 + LDAP_ADD_CMD* = 0x68 + LDAP_DELETE_CMD* = 0x4a + LDAP_MODRDN_CMD* = 0x6c + LDAP_COMPARE_CMD* = 0x6e + LDAP_ABANDON_CMD* = 0x50 + LDAP_SESSION_CMD* = 0x71 + LDAP_EXTENDED_CMD* = 0x77 + LDAP_RES_BIND* = 0x61 + LDAP_RES_SEARCH_ENTRY* = 0x64 + LDAP_RES_SEARCH_RESULT* = 0x65 + LDAP_RES_MODIFY* = 0x67 + LDAP_RES_ADD* = 0x69 + LDAP_RES_DELETE* = 0x6b + LDAP_RES_MODRDN* = 0x6d + LDAP_RES_COMPARE* = 0x6f + LDAP_RES_SESSION* = 0x72 + LDAP_RES_REFERRAL* = 0x73 + LDAP_RES_EXTENDED* = 0x78 + LDAP_RES_ANY* = -1 + LDAP_INVALID_CMD* = 0xff + LDAP_INVALID_RES* = 0xff + LDAP_SUCCESS* = 0x00 + LDAP_OPERATIONS_ERROR* = 0x01 + LDAP_PROTOCOL_ERROR* = 0x02 + LDAP_TIMELIMIT_EXCEEDED* = 0x03 + LDAP_SIZELIMIT_EXCEEDED* = 0x04 + LDAP_COMPARE_FALSE* = 0x05 + LDAP_COMPARE_TRUE* = 0x06 + LDAP_AUTH_METHOD_NOT_SUPPORTED* = 0x07 + LDAP_STRONG_AUTH_REQUIRED* = 0x08 + LDAP_REFERRAL_V2* = 0x09 + LDAP_PARTIAL_RESULTS* = 0x09 + LDAP_REFERRAL* = 0x0a + LDAP_ADMIN_LIMIT_EXCEEDED* = 0x0b + LDAP_UNAVAILABLE_CRIT_EXTENSION* = 0x0c + LDAP_CONFIDENTIALITY_REQUIRED* = 0x0d + LDAP_SASL_BIND_IN_PROGRESS* = 0x0e + LDAP_NO_SUCH_ATTRIBUTE* = 0x10 + LDAP_UNDEFINED_TYPE* = 0x11 + LDAP_INAPPROPRIATE_MATCHING* = 0x12 + LDAP_CONSTRAINT_VIOLATION* = 0x13 + LDAP_ATTRIBUTE_OR_VALUE_EXISTS* = 0x14 + LDAP_INVALID_SYNTAX* = 0x15 + LDAP_NO_SUCH_OBJECT* = 0x20 + LDAP_ALIAS_PROBLEM* = 0x21 + LDAP_INVALID_DN_SYNTAX* = 0x22 + LDAP_IS_LEAF* = 0x23 + LDAP_ALIAS_DEREF_PROBLEM* = 0x24 + LDAP_INAPPROPRIATE_AUTH* = 0x30 + LDAP_INVALID_CREDENTIALS* = 0x31 + LDAP_INSUFFICIENT_RIGHTS* = 0x32 + LDAP_BUSY* = 0x33 + LDAP_UNAVAILABLE* = 0x34 + LDAP_UNWILLING_TO_PERFORM* = 0x35 + LDAP_LOOP_DETECT* = 0x36 + LDAP_SORT_CONTROL_MISSING* = 0x3C + LDAP_OFFSET_RANGE_ERROR* = 0x3D + LDAP_NAMING_VIOLATION* = 0x40 + LDAP_OBJECT_CLASS_VIOLATION* = 0x41 + LDAP_NOT_ALLOWED_ON_NONLEAF* = 0x42 + LDAP_NOT_ALLOWED_ON_RDN* = 0x43 + LDAP_ALREADY_EXISTS* = 0x44 + LDAP_NO_OBJECT_CLASS_MODS* = 0x45 + LDAP_RESULTS_TOO_LARGE* = 0x46 + LDAP_AFFECTS_MULTIPLE_DSAS* = 0x47 + LDAP_VIRTUAL_LIST_VIEW_ERROR* = 0x4c + LDAP_OTHER* = 0x50 + LDAP_SERVER_DOWN* = 0x51 + LDAP_LOCAL_ERROR* = 0x52 + LDAP_ENCODING_ERROR* = 0x53 + LDAP_DECODING_ERROR* = 0x54 + LDAP_TIMEOUT* = 0x55 + LDAP_AUTH_UNKNOWN* = 0x56 + LDAP_FILTER_ERROR* = 0x57 + LDAP_USER_CANCELLED* = 0x58 + LDAP_PARAM_ERROR* = 0x59 + LDAP_NO_MEMORY* = 0x5a + LDAP_CONNECT_ERROR* = 0x5b + LDAP_NOT_SUPPORTED* = 0x5c + LDAP_NO_RESULTS_RETURNED* = 0x5e + LDAP_CONTROL_NOT_FOUND* = 0x5d + LDAP_MORE_RESULTS_TO_RETURN* = 0x5f + LDAP_CLIENT_LOOP* = 0x60 + LDAP_REFERRAL_LIMIT_EXCEEDED* = 0x61 + LDAP_AUTH_SIMPLE* = 0x80 + LDAP_AUTH_SASL* = 0x83 + LDAP_AUTH_OTHERKIND* = 0x86 + LDAP_AUTH_SICILY* = LDAP_AUTH_OTHERKIND or 0x0200 + LDAP_AUTH_MSN* = LDAP_AUTH_OTHERKIND or 0x0800 + LDAP_AUTH_NTLM* = LDAP_AUTH_OTHERKIND or 0x1000 + LDAP_AUTH_DPA* = LDAP_AUTH_OTHERKIND or 0x2000 + LDAP_AUTH_NEGOTIATE* = LDAP_AUTH_OTHERKIND or 0x0400 + LDAP_AUTH_SSPI* = LDAP_AUTH_NEGOTIATE + LDAP_AUTH_DIGEST* = LDAP_AUTH_OTHERKIND or 0x4000 + LDAP_AUTH_EXTERNAL* = LDAP_AUTH_OTHERKIND or 0x0020 + LDAP_FILTER_AND* = 0xa0 + LDAP_FILTER_OR* = 0xa1 + LDAP_FILTER_NOT* = 0xa2 + LDAP_FILTER_EQUALITY* = 0xa3 + LDAP_FILTER_SUBSTRINGS* = 0xa4 + LDAP_FILTER_GE* = 0xa5 + LDAP_FILTER_LE* = 0xa6 + LDAP_FILTER_PRESENT* = 0x87 + LDAP_FILTER_APPROX* = 0xa8 + LDAP_FILTER_EXTENSIBLE* = 0xa9 + LDAP_SUBSTRING_INITIAL* = 0x80 + LDAP_SUBSTRING_ANY* = 0x81 + LDAP_SUBSTRING_FINAL* = 0x82 + LDAP_DEREF_NEVER* = 0 + LDAP_DEREF_SEARCHING* = 1 + LDAP_DEREF_FINDING* = 2 + LDAP_DEREF_ALWAYS* = 3 + LDAP_NO_LIMIT* = 0 + LDAP_OPT_DNS* = 0x00000001 + LDAP_OPT_CHASE_REFERRALS* = 0x00000002 + LDAP_OPT_RETURN_REFS* = 0x00000004 + LDAP_CONTROL_REFERRALS_W* = "1.2.840.113556.1.4.616" + LDAP_CONTROL_REFERRALS* = "1.2.840.113556.1.4.616" + LDAP_MOD_ADD* = 0x00 + LDAP_MOD_DELETE* = 0x01 + LDAP_MOD_REPLACE* = 0x02 + LDAP_MOD_BVALUES* = 0x80 + LDAP_OPT_API_INFO* = 0x00 + LDAP_OPT_DESC* = 0x01 + LDAP_OPT_DEREF* = 0x02 + LDAP_OPT_SIZELIMIT* = 0x03 + LDAP_OPT_TIMELIMIT* = 0x04 + LDAP_OPT_THREAD_FN_PTRS* = 0x05 + LDAP_OPT_REBIND_FN* = 0x06 + LDAP_OPT_REBIND_ARG* = 0x07 + LDAP_OPT_REFERRALS* = 0x08 + LDAP_OPT_RESTART* = 0x09 + LDAP_OPT_SSL* = 0x0a + LDAP_OPT_IO_FN_PTRS* = 0x0b + LDAP_OPT_CACHE_FN_PTRS* = 0x0d + LDAP_OPT_CACHE_STRATEGY* = 0x0e + LDAP_OPT_CACHE_ENABLE* = 0x0f + LDAP_OPT_REFERRAL_HOP_LIMIT* = 0x10 + LDAP_OPT_PROTOCOL_VERSION* = 0x11 + LDAP_OPT_VERSION* = 0x11 + LDAP_OPT_API_FEATURE_INFO* = 0x15 + LDAP_OPT_HOST_NAME* = 0x30 + LDAP_OPT_ERROR_NUMBER* = 0x31 + LDAP_OPT_ERROR_STRING* = 0x32 + LDAP_OPT_SERVER_ERROR* = 0x33 + LDAP_OPT_SERVER_EXT_ERROR* = 0x34 + LDAP_OPT_HOST_REACHABLE* = 0x3E + LDAP_OPT_PING_KEEP_ALIVE* = 0x36 + LDAP_OPT_PING_WAIT_TIME* = 0x37 + LDAP_OPT_PING_LIMIT* = 0x38 + LDAP_OPT_DNSDOMAIN_NAME* = 0x3B + LDAP_OPT_GETDSNAME_FLAGS* = 0x3D + LDAP_OPT_PROMPT_CREDENTIALS* = 0x3F + LDAP_OPT_AUTO_RECONNECT* = 0x91 + LDAP_OPT_SSPI_FLAGS* = 0x92 + LDAP_OPT_SSL_INFO* = 0x93 + LDAP_OPT_TLS* = LDAP_OPT_SSL + LDAP_OPT_TLS_INFO* = LDAP_OPT_SSL_INFO + LDAP_OPT_SIGN* = 0x95 + LDAP_OPT_ENCRYPT* = 0x96 + LDAP_OPT_SASL_METHOD* = 0x97 + LDAP_OPT_AREC_EXCLUSIVE* = 0x98 + LDAP_OPT_SECURITY_CONTEXT* = 0x99 + LDAP_OPT_ROOTDSE_CACHE* = 0x9a + LDAP_OPT_TCP_KEEPALIVE* = 0x40 + LDAP_OPT_FAST_CONCURRENT_BIND* = 0x41 + LDAP_OPT_SEND_TIMEOUT* = 0x42 + LDAP_CHASE_SUBORDINATE_REFERRALS* = 0x00000020 + LDAP_CHASE_EXTERNAL_REFERRALS* = 0x00000040 + LDAP_SCOPE_BASE* = 0x00 + LDAP_SCOPE_ONELEVEL* = 0x01 + LDAP_SCOPE_SUBTREE* = 0x02 + LDAP_MSG_ONE* = 0 + LDAP_MSG_ALL* = 1 + LDAP_MSG_RECEIVED* = 2 + LBER_USE_DER* = 0x01 + LBER_USE_INDEFINITE_LEN* = 0x02 + LBER_TRANSLATE_STRINGS* = 0x04 + LAPI_MAJOR_VER1* = 1 + LAPI_MINOR_VER1* = 1 + LDAP_API_INFO_VERSION* = 1 + LDAP_API_VERSION* = 2004 + LDAP_VERSION_MIN* = 2 + LDAP_VERSION_MAX* = 3 + LDAP_VENDOR_NAME* = "Microsoft Corporation." + LDAP_VENDOR_NAME_W* = "Microsoft Corporation." + LDAP_VENDOR_VERSION* = 510 + LDAP_FEATURE_INFO_VERSION* = 1 + LDAP_SERVER_SORT_OID* = "1.2.840.113556.1.4.473" + LDAP_SERVER_SORT_OID_W* = "1.2.840.113556.1.4.473" + LDAP_SERVER_RESP_SORT_OID* = "1.2.840.113556.1.4.474" + LDAP_SERVER_RESP_SORT_OID_W* = "1.2.840.113556.1.4.474" + LDAP_PAGED_RESULT_OID_STRING* = "1.2.840.113556.1.4.319" + LDAP_PAGED_RESULT_OID_STRING_W* = "1.2.840.113556.1.4.319" + LDAP_CONTROL_VLVREQUEST* = "2.16.840.1.113730.3.4.9" + LDAP_CONTROL_VLVREQUEST_W* = "2.16.840.1.113730.3.4.9" + LDAP_CONTROL_VLVRESPONSE* = "2.16.840.1.113730.3.4.10" + LDAP_CONTROL_VLVRESPONSE_W* = "2.16.840.1.113730.3.4.10" + LDAP_API_FEATURE_VIRTUAL_LIST_VIEW* = 1001 + LDAP_VLVINFO_VERSION* = 1 + LDAP_START_TLS_OID* = "1.3.6.1.4.1.1466.20037" + LDAP_START_TLS_OID_W* = "1.3.6.1.4.1.1466.20037" + LDAP_TTL_EXTENDED_OP_OID* = "1.3.6.1.4.1.1466.101.119.1" + LDAP_TTL_EXTENDED_OP_OID_W* = "1.3.6.1.4.1.1466.101.119.1" + LDAP_OPT_REFERRAL_CALLBACK* = 0x70 + LDAP_OPT_CLIENT_CERTIFICATE* = 0x80 + LDAP_OPT_SERVER_CERTIFICATE* = 0x81 + LDAP_OPT_REF_DEREF_CONN_PER_MSG* = 0x94 + LDAP_OPT_ON* = 0x00000001 + LDAP_OPT_OFF* = 0x00000000 +type + BerElement* {.pure.} = object + opaque*: PCHAR +const + NULLBER* = cast[ptr BerElement](0) +type + SSL_EMPTY_CACHE_FN_A* = proc (pszTargetName: LPSTR, dwFlags: DWORD): WINBOOL {.stdcall.} + SSL_EMPTY_CACHE_FN_W* = proc (pszTargetName: LPWSTR, dwFlags: DWORD): WINBOOL {.stdcall.} + SSL_CRACK_CERTIFICATE_FN* = proc (pbCertificate: PUCHAR, cbCertificate: DWORD, VerifySignature: WINBOOL, ppCertificate: ptr PX509Certificate): WINBOOL {.stdcall.} + SSL_FREE_CERTIFICATE_FN* = proc (pCertificate: PX509Certificate): VOID {.stdcall.} + QUERYCLIENTCERT* = proc (Connection: PLDAP, trusted_CAs: PSecPkgContext_IssuerListInfoEx, ppCertificate: ptr PCCERT_CONTEXT): BOOLEAN {.stdcall.} + VERIFYSERVERCERT* = proc (Connection: PLDAP, pServerCert: PCCERT_CONTEXT): BOOLEAN {.stdcall.} + SCHANNEL_ALERT_TOKEN* {.pure.} = object + dwTokenType*: DWORD + dwAlertType*: DWORD + dwAlertNumber*: DWORD + SCHANNEL_SESSION_TOKEN* {.pure.} = object + dwTokenType*: DWORD + dwFlags*: DWORD + LDAPAPIInfoA* {.pure.} = object + ldapai_info_version*: int32 + ldapai_api_version*: int32 + ldapai_protocol_version*: int32 + ldapai_extensions*: ptr ptr char + ldapai_vendor_name*: ptr char + ldapai_vendor_version*: int32 + LDAPAPIInfoW* {.pure.} = object + ldapai_info_version*: int32 + ldapai_api_version*: int32 + ldapai_protocol_version*: int32 + ldapai_extensions*: ptr PWCHAR + ldapai_vendor_name*: PWCHAR + ldapai_vendor_version*: int32 + LDAPAPIFeatureInfoA* {.pure.} = object + ldapaif_info_version*: int32 + ldapaif_name*: ptr char + ldapaif_version*: int32 + LDAPAPIFeatureInfoW* {.pure.} = object + ldapaif_info_version*: int32 + ldapaif_name*: PWCHAR + ldapaif_version*: int32 +proc ber_init*(pBerVal: ptr BERVAL): ptr BerElement {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_free*(pBerElement: ptr BerElement, fbuf: INT): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_bvfree*(pBerVal: ptr BERVAL): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_bvecfree*(pBerVal: ptr PBERVAL): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_bvdup*(pBerVal: ptr BERVAL): ptr BERVAL {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_alloc_t*(options: INT): ptr BerElement {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_skip_tag*(pBerElement: ptr BerElement, pLen: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_peek_tag*(pBerElement: ptr BerElement, pLen: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_first_element*(pBerElement: ptr BerElement, pLen: ptr ULONG, ppOpaque: ptr ptr CHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_next_element*(pBerElement: ptr BerElement, pLen: ptr ULONG, opaque: ptr CHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_flatten*(pBerElement: ptr BerElement, pBerVal: ptr PBERVAL): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_printf*(pBerElement: ptr BerElement, fmt: PSTR): INT {.winapi, cdecl, varargs, dynlib: "wldap32", importc.} +proc ber_scanf*(pBerElement: ptr BerElement, fmt: PSTR): ULONG {.winapi, cdecl, varargs, dynlib: "wldap32", importc.} +proc SslEmptyCacheA*(pszTargetName: LPSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "schannel", importc.} +proc SslEmptyCacheW*(pszTargetName: LPWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "schannel", importc.} +proc SslGenerateRandomBits*(pRandomData: PUCHAR, cRandomData: LONG): VOID {.winapi, stdcall, dynlib: "schannel", importc.} +proc SslCrackCertificate*(pbCertificate: PUCHAR, cbCertificate: DWORD, dwFlags: DWORD, ppCertificate: ptr PX509Certificate): WINBOOL {.winapi, stdcall, dynlib: "schannel", importc.} +proc SslFreeCertificate*(pCertificate: PX509Certificate): VOID {.winapi, stdcall, dynlib: "schannel", importc.} +proc SslGetMaximumKeySize*(Reserved: DWORD): DWORD {.winapi, stdcall, dynlib: "schannel", importc.} +proc ldap_openW*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_openA*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_initW*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_initA*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sslinitW*(HostName: PWCHAR, PortNumber: ULONG, secure: int32): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sslinitA*(HostName: PCHAR, PortNumber: ULONG, secure: int32): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_connect*(ld: ptr LDAP, timeout: ptr LDAP_TIMEVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc cldap_openW*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc cldap_openA*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_unbind*(ld: ptr LDAP): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_unbind_s*(ld: ptr LDAP): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_optionW*(ld: ptr LDAP, option: int32, outvalue: pointer): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_set_optionW*(ld: ptr LDAP, option: int32, invalue: pointer): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_simple_bindW*(ld: ptr LDAP, dn: PWCHAR, passwd: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_simple_bindA*(ld: ptr LDAP, dn: PCHAR, passwd: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_simple_bind_sW*(ld: ptr LDAP, dn: PWCHAR, passwd: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_simple_bind_sA*(ld: ptr LDAP, dn: PCHAR, passwd: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_bindW*(ld: ptr LDAP, dn: PWCHAR, cred: PWCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_bindA*(ld: ptr LDAP, dn: PCHAR, cred: PCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_bind_sW*(ld: ptr LDAP, dn: PWCHAR, cred: PWCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_bind_sA*(ld: ptr LDAP, dn: PCHAR, cred: PCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sasl_bindA*(ExternalHandle: ptr LDAP, DistName: PCHAR, AuthMechanism: PCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlA, ClientCtrls: ptr PLDAPControlA, MessageNumber: ptr int32): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sasl_bindW*(ExternalHandle: ptr LDAP, DistName: PWCHAR, AuthMechanism: PWCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlW, ClientCtrls: ptr PLDAPControlW, MessageNumber: ptr int32): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sasl_bind_sA*(ExternalHandle: ptr LDAP, DistName: PCHAR, AuthMechanism: PCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlA, ClientCtrls: ptr PLDAPControlA, ServerData: ptr PBERVAL): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_sasl_bind_sW*(ExternalHandle: ptr LDAP, DistName: PWCHAR, AuthMechanism: PWCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlW, ClientCtrls: ptr PLDAPControlW, ServerData: ptr PBERVAL): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_searchW*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_searchA*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_sW*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_sA*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_stW*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, timeout: ptr LDAP_TIMEVAL, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_stA*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, timeout: ptr LDAP_TIMEVAL, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_extW*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, TimeLimit: ULONG, SizeLimit: ULONG, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_extA*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, TimeLimit: ULONG, SizeLimit: ULONG, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_ext_sW*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, timeout: ptr LDAP_TIMEVAL, SizeLimit: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_ext_sA*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, timeout: ptr LDAP_TIMEVAL, SizeLimit: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_check_filterW*(ld: ptr LDAP, SearchFilter: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_check_filterA*(ld: ptr LDAP, SearchFilter: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modifyW*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modifyA*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_sW*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_sA*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_extW*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_extA*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_ext_sW*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modify_ext_sA*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn2W*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn2A*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdnW*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdnA*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn2_sW*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn2_sA*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn_sW*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_modrdn_sA*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_rename_extW*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_rename_extA*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_rename_ext_sW*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_rename_ext_sA*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_addW*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_addA*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_sW*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_sA*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_extW*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_extA*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_ext_sW*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_add_ext_sA*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compareW*(ld: ptr LDAP, dn: PWCHAR, attr: PWCHAR, value: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compareA*(ld: ptr LDAP, dn: PCHAR, attr: PCHAR, value: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_sW*(ld: ptr LDAP, dn: PWCHAR, attr: PWCHAR, value: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_sA*(ld: ptr LDAP, dn: PCHAR, attr: PCHAR, value: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_extW*(ld: ptr LDAP, dn: PWCHAR, Attr: PWCHAR, Value: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_extA*(ld: ptr LDAP, dn: PCHAR, Attr: PCHAR, Value: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_ext_sW*(ld: ptr LDAP, dn: PWCHAR, Attr: PWCHAR, Value: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_compare_ext_sA*(ld: ptr LDAP, dn: PCHAR, Attr: PCHAR, Value: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_deleteW*(ld: ptr LDAP, dn: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_deleteA*(ld: ptr LDAP, dn: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_sW*(ld: ptr LDAP, dn: PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_sA*(ld: ptr LDAP, dn: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_extW*(ld: ptr LDAP, dn: PWCHAR, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_extA*(ld: ptr LDAP, dn: PCHAR, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_ext_sW*(ld: ptr LDAP, dn: PWCHAR, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_delete_ext_sA*(ld: ptr LDAP, dn: PCHAR, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_abandon*(ld: ptr LDAP, msgid: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_result*(ld: ptr LDAP, msgid: ULONG, all: ULONG, timeout: ptr LDAP_TIMEVAL, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_msgfree*(res: ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_result2error*(ld: ptr LDAP, res: ptr LDAPMessage, freeit: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_resultW*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ReturnCode: ptr ULONG, MatchedDNs: ptr PWCHAR, ErrorMessage: ptr PWCHAR, Referrals: ptr ptr PWCHAR, ServerControls: ptr ptr PLDAPControlW, Freeit: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_resultA*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ReturnCode: ptr ULONG, MatchedDNs: ptr PCHAR, ErrorMessage: ptr PCHAR, Referrals: ptr ptr PCHAR, ServerControls: ptr ptr PLDAPControlA, Freeit: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_extended_resultA*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ResultOID: ptr PCHAR, ResultData: ptr ptr BERVAL, Freeit: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_extended_resultW*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ResultOID: ptr PWCHAR, ResultData: ptr ptr BERVAL, Freeit: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_controls_freeA*(Controls: ptr ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_control_freeA*(Controls: ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_controls_freeW*(Control: ptr ptr LDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_control_freeW*(Control: ptr LDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_free_controlsW*(Controls: ptr ptr LDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_free_controlsA*(Controls: ptr ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_err2stringW*(err: ULONG): PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_err2stringA*(err: ULONG): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_perror*(ld: ptr LDAP, msg: PCHAR): void {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_first_entry*(ld: ptr LDAP, res: ptr LDAPMessage): ptr LDAPMessage {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_next_entry*(ld: ptr LDAP, entry: ptr LDAPMessage): ptr LDAPMessage {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_count_entries*(ld: ptr LDAP, res: ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_first_attributeW*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr ptr BerElement): PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_first_attributeA*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr ptr BerElement): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_next_attributeW*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr BerElement): PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_next_attributeA*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr BerElement): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_valuesW*(ld: ptr LDAP, entry: ptr LDAPMessage, attr: PWCHAR): ptr PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_valuesA*(ld: ptr LDAP, entry: ptr LDAPMessage, attr: PCHAR): ptr PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_values_lenW*(ExternalHandle: ptr LDAP, Message: ptr LDAPMessage, attr: PWCHAR): ptr ptr BERVAL {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_values_lenA*(ExternalHandle: ptr LDAP, Message: ptr LDAPMessage, attr: PCHAR): ptr ptr BERVAL {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_count_valuesW*(vals: ptr PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_count_valuesA*(vals: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_count_values_len*(vals: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_value_freeW*(vals: ptr PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_value_freeA*(vals: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_value_free_len*(vals: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_dnW*(ld: ptr LDAP, entry: ptr LDAPMessage): PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_dnA*(ld: ptr LDAP, entry: ptr LDAPMessage): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_explode_dnW*(dn: PWCHAR, notypes: ULONG): ptr PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_explode_dnA*(dn: PCHAR, notypes: ULONG): ptr PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_dn2ufnW*(dn: PWCHAR): PWCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_dn2ufnA*(dn: PCHAR): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_memfreeW*(Block: PWCHAR): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_memfreeA*(Block: PCHAR): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ber_bvfree*(bv: ptr BERVAL): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_ufn2dnW*(ufn: PWCHAR, pDn: ptr PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_ufn2dnA*(ufn: PCHAR, pDn: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_startup*(version: PLDAP_VERSION_INFO, Instance: ptr HANDLE): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_cleanup*(hInstance: HANDLE): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_escape_filter_elementW*(sourceFilterElement: PCHAR, sourceLength: ULONG, destFilterElement: PWCHAR, destLength: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_escape_filter_elementA*(sourceFilterElement: PCHAR, sourceLength: ULONG, destFilterElement: PCHAR, destLength: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_set_dbg_flags*(NewFlags: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_set_dbg_routine*(DebugPrintRoutine: DBGPRINT): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} +proc LdapUTF8ToUnicode*(lpSrcStr: LPCSTR, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32 {.winapi, cdecl, dynlib: "wldap32", importc.} +proc LdapUnicodeToUTF8*(lpSrcStr: LPCWSTR, cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32 {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_sort_controlA*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyA, IsCritical: UCHAR, Control: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_sort_controlW*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyW, IsCritical: UCHAR, Control: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_sort_controlA*(ExternalHandle: PLDAP, Control: ptr PLDAPControlA, Result: ptr ULONG, Attribute: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_sort_controlW*(ExternalHandle: PLDAP, Control: ptr PLDAPControlW, Result: ptr ULONG, Attribute: ptr PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_encode_sort_controlW*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyW, Control: PLDAPControlW, Criticality: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_encode_sort_controlA*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyA, Control: PLDAPControlA, Criticality: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_page_controlW*(ExternalHandle: PLDAP, PageSize: ULONG, Cookie: ptr BERVAL, IsCritical: UCHAR, Control: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_page_controlA*(ExternalHandle: PLDAP, PageSize: ULONG, Cookie: ptr BERVAL, IsCritical: UCHAR, Control: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_page_controlW*(ExternalHandle: PLDAP, ServerControls: ptr PLDAPControlW, TotalCount: ptr ULONG, Cookie: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_page_controlA*(ExternalHandle: PLDAP, ServerControls: ptr PLDAPControlA, TotalCount: ptr ULONG, Cookie: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_init_pageW*(ExternalHandle: PLDAP, DistinguishedName: PWCHAR, ScopeOfSearch: ULONG, SearchFilter: PWCHAR, AttributeList: ptr PWCHAR, AttributesOnly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, PageTimeLimit: ULONG, TotalSizeLimit: ULONG, SortKeys: ptr PLDAPSortKeyW): PLDAPSearch {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_init_pageA*(ExternalHandle: PLDAP, DistinguishedName: PCHAR, ScopeOfSearch: ULONG, SearchFilter: PCHAR, AttributeList: ptr PCHAR, AttributesOnly: ULONG, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, PageTimeLimit: ULONG, TotalSizeLimit: ULONG, SortKeys: ptr PLDAPSortKeyA): PLDAPSearch {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_next_page*(ExternalHandle: PLDAP, SearchHandle: PLDAPSearch, PageSize: ULONG, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_next_page_s*(ExternalHandle: PLDAP, SearchHandle: PLDAPSearch, timeout: ptr LDAP_TIMEVAL, PageSize: ULONG, TotalCount: ptr ULONG, Results: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_get_paged_count*(ExternalHandle: PLDAP, SearchBlock: PLDAPSearch, TotalCount: ptr ULONG, Results: PLDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_search_abandon_page*(ExternalHandle: PLDAP, SearchBlock: PLDAPSearch): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_vlv_controlW*(ExternalHandle: PLDAP, VlvInfo: PLDAPVLVInfo, IsCritical: UCHAR, Control: ptr PLDAPControlW): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_create_vlv_controlA*(ExternalHandle: PLDAP, VlvInfo: PLDAPVLVInfo, IsCritical: UCHAR, Control: ptr PLDAPControlA): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_vlv_controlW*(ExternalHandle: PLDAP, Control: ptr PLDAPControlW, TargetPos: PULONG, ListCount: PULONG, Context: ptr PBERVAL, ErrCode: PINT): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_vlv_controlA*(ExternalHandle: PLDAP, Control: ptr PLDAPControlA, TargetPos: PULONG, ListCount: PULONG, Context: ptr PBERVAL, ErrCode: PINT): INT {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_start_tls_sW*(ExternalHandle: PLDAP, ServerReturnValue: PULONG, result: ptr ptr LDAPMessage, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_start_tls_sA*(ExternalHandle: PLDAP, ServerReturnValue: PULONG, result: ptr ptr LDAPMessage, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_stop_tls_s*(ExternalHandle: PLDAP): BOOLEAN {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_first_reference*(ld: ptr LDAP, res: ptr LDAPMessage): ptr LDAPMessage {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_next_reference*(ld: ptr LDAP, entry: ptr LDAPMessage): ptr LDAPMessage {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_count_references*(ld: ptr LDAP, res: ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_referenceW*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, Referrals: ptr ptr PWCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_parse_referenceA*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, Referrals: ptr ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_extended_operationW*(ld: ptr LDAP, Oid: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_extended_operationA*(ld: ptr LDAP, Oid: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_extended_operation_sA*(ExternalHandle: ptr LDAP, Oid: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, ReturnedOid: ptr PCHAR, ReturnedData: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_extended_operation_sW*(ExternalHandle: ptr LDAP, Oid: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, ReturnedOid: ptr PWCHAR, ReturnedData: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_close_extended_op*(ld: ptr LDAP, MessageNumber: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc LdapGetLastError*(): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc LdapMapErrorToWin32*(LdapError: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} +proc ldap_conn_from_msg*(PrimaryConn: ptr LDAP, res: ptr LDAPMessage): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} +when winimUnicode: + type + LDAPControl* = LDAPControlW + PLDAPControl* = PLDAPControlW + LDAPMod* = LDAPModW + PLDAPMod* = PLDAPModW + LDAPAPIInfo* = LDAPAPIInfoW + LDAPAPIFeatureInfo* = LDAPAPIFeatureInfoW + LDAPSortKey* = LDAPSortKeyW + PLDAPSortKey* = PLDAPSortKeyW + SSL_EMPTY_CACHE_FN* = SSL_EMPTY_CACHE_FN_W + const + LDAP_UNICODE* = 1 + UNISP_NAME* = UNISP_NAME_W + PCT1SP_NAME* = PCT1SP_NAME_W + SSL2SP_NAME* = SSL2SP_NAME_W + SSL3SP_NAME* = SSL3SP_NAME_W + TLS1SP_NAME* = TLS1SP_NAME_W + SCHANNEL_NAME* = SCHANNEL_NAME_W + proc ldap_open*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_openW".} + proc ldap_init*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_initW".} + proc ldap_sslinit*(HostName: PWCHAR, PortNumber: ULONG, secure: int32): ptr LDAP {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_sslinitW".} + proc cldap_open*(HostName: PWCHAR, PortNumber: ULONG): ptr LDAP {.winapi, stdcall, dynlib: "wldap32", importc: "cldap_openW".} + proc ldap_get_option*(ld: ptr LDAP, option: int32, outvalue: pointer): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_get_optionW".} + proc ldap_set_option*(ld: ptr LDAP, option: int32, invalue: pointer): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_set_optionW".} + proc ldap_simple_bind*(ld: ptr LDAP, dn: PWCHAR, passwd: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_simple_bindW".} + proc ldap_simple_bind_s*(ld: ptr LDAP, dn: PWCHAR, passwd: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_simple_bind_sW".} + proc ldap_bind*(ld: ptr LDAP, dn: PWCHAR, cred: PWCHAR, `method`: ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_bindW".} + proc ldap_bind_s*(ld: ptr LDAP, dn: PWCHAR, cred: PWCHAR, `method`: ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_bind_sW".} + proc ldap_sasl_bind*(ExternalHandle: ptr LDAP, DistName: PWCHAR, AuthMechanism: PWCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlW, ClientCtrls: ptr PLDAPControlW, MessageNumber: ptr int32): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_sasl_bindW".} + proc ldap_sasl_bind_s*(ExternalHandle: ptr LDAP, DistName: PWCHAR, AuthMechanism: PWCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlW, ClientCtrls: ptr PLDAPControlW, ServerData: ptr PBERVAL): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_sasl_bind_sW".} + proc ldap_search*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_searchW".} + proc ldap_search_s*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_search_sW".} + proc ldap_search_st*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, timeout: ptr LDAP_TIMEVAL, res: ptr ptr LDAPMessage): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_search_stW".} + proc ldap_search_ext*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, TimeLimit: ULONG, SizeLimit: ULONG, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_search_extW".} + proc ldap_search_ext_s*(ld: ptr LDAP, base: PWCHAR, scope: ULONG, filter: PWCHAR, attrs: ptr PWCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, timeout: ptr LDAP_TIMEVAL, SizeLimit: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_search_ext_sW".} + proc ldap_check_filter*(ld: ptr LDAP, SearchFilter: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_check_filterW".} + proc ldap_modify*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modifyW".} + proc ldap_modify_s*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modify_sW".} + proc ldap_modify_ext*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modify_extW".} + proc ldap_modify_ext_s*(ld: ptr LDAP, dn: PWCHAR, mods: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modify_ext_sW".} + proc ldap_modrdn2*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR, DeleteOldRdn: INT): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modrdn2W".} + proc ldap_modrdn*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modrdnW".} + proc ldap_modrdn2_s*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR, DeleteOldRdn: INT): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modrdn2_sW".} + proc ldap_modrdn_s*(ExternalHandle: ptr LDAP, DistinguishedName: PWCHAR, NewDistinguishedName: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_modrdn_sW".} + proc ldap_rename*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_extW".} + proc ldap_rename_s*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_ext_sW".} + proc ldap_rename_ext*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_extW".} + proc ldap_rename_ext_s*(ld: ptr LDAP, dn: PWCHAR, NewRDN: PWCHAR, NewParent: PWCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_ext_sW".} + proc ldap_add*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_addW".} + proc ldap_add_s*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_add_sW".} + proc ldap_add_ext*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_add_extW".} + proc ldap_add_ext_s*(ld: ptr LDAP, dn: PWCHAR, attrs: ptr ptr LDAPModW, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_add_ext_sW".} + proc ldap_compare*(ld: ptr LDAP, dn: PWCHAR, attr: PWCHAR, value: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_compareW".} + proc ldap_compare_s*(ld: ptr LDAP, dn: PWCHAR, attr: PWCHAR, value: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_compare_sW".} + proc ldap_compare_ext*(ld: ptr LDAP, dn: PWCHAR, Attr: PWCHAR, Value: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_compare_extW".} + proc ldap_compare_ext_s*(ld: ptr LDAP, dn: PWCHAR, Attr: PWCHAR, Value: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_compare_ext_sW".} + proc ldap_delete*(ld: ptr LDAP, dn: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_deleteW".} + proc ldap_delete_ext*(ld: ptr LDAP, dn: PWCHAR, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_delete_extW".} + proc ldap_delete_s*(ld: ptr LDAP, dn: PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_delete_sW".} + proc ldap_delete_ext_s*(ld: ptr LDAP, dn: PWCHAR, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_delete_ext_sW".} + proc ldap_parse_result*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ReturnCode: ptr ULONG, MatchedDNs: ptr PWCHAR, ErrorMessage: ptr PWCHAR, Referrals: ptr ptr PWCHAR, ServerControls: ptr ptr PLDAPControlW, Freeit: BOOLEAN): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_resultW".} + proc ldap_controls_free*(Control: ptr ptr LDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_controls_freeW".} + proc ldap_control_free*(Control: ptr LDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_control_freeW".} + proc ldap_free_controls*(Controls: ptr ptr LDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_free_controlsW".} + proc ldap_parse_extended_result*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ResultOID: ptr PWCHAR, ResultData: ptr ptr BERVAL, Freeit: BOOLEAN): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_extended_resultW".} + proc ldap_err2string*(err: ULONG): PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_err2stringW".} + proc ldap_first_attribute*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr ptr BerElement): PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_first_attributeW".} + proc ldap_next_attribute*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr BerElement): PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_next_attributeW".} + proc ldap_get_values*(ld: ptr LDAP, entry: ptr LDAPMessage, attr: PWCHAR): ptr PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_get_valuesW".} + proc ldap_get_values_len*(ExternalHandle: ptr LDAP, Message: ptr LDAPMessage, attr: PWCHAR): ptr ptr BERVAL {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_get_values_lenW".} + proc ldap_count_values*(vals: ptr PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_count_valuesW".} + proc ldap_value_free*(vals: ptr PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_value_freeW".} + proc ldap_get_dn*(ld: ptr LDAP, entry: ptr LDAPMessage): PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_get_dnW".} + proc ldap_explode_dn*(dn: PWCHAR, notypes: ULONG): ptr PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_explode_dnW".} + proc ldap_dn2ufn*(dn: PWCHAR): PWCHAR {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_dn2ufnW".} + proc ldap_memfree*(Block: PWCHAR): VOID {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_memfreeW".} + proc ldap_ufn2dn*(ufn: PWCHAR, pDn: ptr PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_ufn2dnW".} + proc ldap_escape_filter_element*(sourceFilterElement: PCHAR, sourceLength: ULONG, destFilterElement: PWCHAR, destLength: ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_escape_filter_elementW".} + proc ldap_create_sort_control*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyW, IsCritical: UCHAR, Control: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_create_sort_controlW".} + proc ldap_parse_sort_control*(ExternalHandle: PLDAP, Control: ptr PLDAPControlW, Result: ptr ULONG, Attribute: ptr PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_sort_controlW".} + proc ldap_encode_sort_control*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyW, Control: PLDAPControlW, Criticality: BOOLEAN): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_encode_sort_controlW".} + proc ldap_create_page_control*(ExternalHandle: PLDAP, PageSize: ULONG, Cookie: ptr BERVAL, IsCritical: UCHAR, Control: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_create_page_controlW".} + proc ldap_parse_page_control*(ExternalHandle: PLDAP, ServerControls: ptr PLDAPControlW, TotalCount: ptr ULONG, Cookie: ptr ptr BERVAL): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_page_controlW".} + proc ldap_search_init_page*(ExternalHandle: PLDAP, DistinguishedName: PWCHAR, ScopeOfSearch: ULONG, SearchFilter: PWCHAR, AttributeList: ptr PWCHAR, AttributesOnly: ULONG, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, PageTimeLimit: ULONG, TotalSizeLimit: ULONG, SortKeys: ptr PLDAPSortKeyW): PLDAPSearch {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_search_init_pageW".} + proc ldap_create_vlv_control*(ExternalHandle: PLDAP, VlvInfo: PLDAPVLVInfo, IsCritical: UCHAR, Control: ptr PLDAPControlW): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_create_vlv_controlW".} + proc ldap_parse_vlv_control*(ExternalHandle: PLDAP, Control: ptr PLDAPControlW, TargetPos: PULONG, ListCount: PULONG, Context: ptr PBERVAL, ErrCode: PINT): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_vlv_controlW".} + proc ldap_start_tls_s*(ExternalHandle: PLDAP, ServerReturnValue: PULONG, result: ptr ptr LDAPMessage, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_start_tls_sW".} + proc ldap_parse_reference*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, Referrals: ptr ptr PWCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_referenceW".} + proc ldap_extended_operation*(ld: ptr LDAP, Oid: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_extended_operationW".} + proc ldap_extended_operation_s*(ExternalHandle: ptr LDAP, Oid: PWCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlW, ClientControls: ptr PLDAPControlW, ReturnedOid: ptr PWCHAR, ReturnedData: ptr ptr BERVAL): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_extended_operation_sW".} + proc SslEmptyCache*(pszTargetName: LPWSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "schannel", importc: "SslEmptyCacheW".} +when winimAnsi: + type + LDAPControl* = LDAPControlA + PLDAPControl* = PLDAPControlA + LDAPMod* = LDAPModA + PLDAPMod* = PLDAPModA + LDAPAPIInfo* = LDAPAPIInfoA + LDAPAPIFeatureInfo* = LDAPAPIFeatureInfoA + LDAPSortKey* = LDAPSortKeyA + PLDAPSortKey* = PLDAPSortKeyA + SSL_EMPTY_CACHE_FN* = SSL_EMPTY_CACHE_FN_A + const + LDAP_UNICODE* = 0 + UNISP_NAME* = UNISP_NAME_A + PCT1SP_NAME* = PCT1SP_NAME_A + SSL2SP_NAME* = SSL2SP_NAME_A + SSL3SP_NAME* = SSL3SP_NAME_A + TLS1SP_NAME* = TLS1SP_NAME_A + SCHANNEL_NAME* = SCHANNEL_NAME_A + proc ldap_open*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_init*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_sslinit*(HostName: PCHAR, PortNumber: ULONG, secure: int32): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} + proc cldap_open*(HostName: PCHAR, PortNumber: ULONG): ptr LDAP {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_get_option*(ld: ptr LDAP, option: int32, outvalue: pointer): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_set_option*(ld: ptr LDAP, option: int32, invalue: pointer): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_simple_bind*(ld: ptr LDAP, dn: PCHAR, passwd: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_simple_bind_s*(ld: ptr LDAP, dn: PCHAR, passwd: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_bind*(ld: ptr LDAP, dn: PCHAR, cred: PCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_bind_s*(ld: ptr LDAP, dn: PCHAR, cred: PCHAR, `method`: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_sasl_bind*(ExternalHandle: ptr LDAP, DistName: PCHAR, AuthMechanism: PCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlA, ClientCtrls: ptr PLDAPControlA, MessageNumber: ptr int32): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_sasl_bindA".} + proc ldap_sasl_bind_s*(ExternalHandle: ptr LDAP, DistName: PCHAR, AuthMechanism: PCHAR, cred: ptr BERVAL, ServerCtrls: ptr PLDAPControlA, ClientCtrls: ptr PLDAPControlA, ServerData: ptr PBERVAL): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_sasl_bind_sA".} + proc ldap_search*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_search_s*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_search_st*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, timeout: ptr LDAP_TIMEVAL, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_search_ext*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, TimeLimit: ULONG, SizeLimit: ULONG, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_search_ext_s*(ld: ptr LDAP, base: PCHAR, scope: ULONG, filter: PCHAR, attrs: ptr PCHAR, attrsonly: ULONG, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, timeout: ptr LDAP_TIMEVAL, SizeLimit: ULONG, res: ptr ptr LDAPMessage): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_check_filter*(ld: ptr LDAP, SearchFilter: PCHAR): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_check_filterA".} + proc ldap_modify*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modify_s*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modify_ext*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modify_ext_s*(ld: ptr LDAP, dn: PCHAR, mods: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modrdn2*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modrdn*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modrdn2_s*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR, DeleteOldRdn: INT): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_modrdn_s*(ExternalHandle: ptr LDAP, DistinguishedName: PCHAR, NewDistinguishedName: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_rename*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_extA".} + proc ldap_rename_s*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_rename_ext_sA".} + proc ldap_rename_ext*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_rename_ext_s*(ld: ptr LDAP, dn: PCHAR, NewRDN: PCHAR, NewParent: PCHAR, DeleteOldRdn: INT, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_add*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPMod): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_add_s*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPMod): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_add_ext*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_add_ext_s*(ld: ptr LDAP, dn: PCHAR, attrs: ptr ptr LDAPModA, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_compare*(ld: ptr LDAP, dn: PCHAR, attr: PCHAR, value: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_compare_s*(ld: ptr LDAP, dn: PCHAR, attr: PCHAR, value: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_compare_ext*(ld: ptr LDAP, dn: PCHAR, Attr: PCHAR, Value: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_compare_ext_s*(ld: ptr LDAP, dn: PCHAR, Attr: PCHAR, Value: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_delete*(ld: ptr LDAP, dn: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_delete_s*(ld: ptr LDAP, dn: PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_delete_ext*(ld: ptr LDAP, dn: PCHAR, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_delete_ext_s*(ld: ptr LDAP, dn: PCHAR, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_parse_extended_result*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ResultOID: ptr PCHAR, ResultData: ptr ptr BERVAL, Freeit: BOOLEAN): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_extended_resultA".} + proc ldap_parse_result*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, ReturnCode: ptr ULONG, MatchedDNs: ptr PCHAR, ErrorMessage: ptr PCHAR, Referrals: ptr ptr PCHAR, ServerControls: ptr ptr PLDAPControlA, Freeit: BOOLEAN): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_controls_free*(Controls: ptr ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_control_free*(Control: ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_free_controls*(Controls: ptr ptr LDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_err2string*(err: ULONG): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_first_attribute*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr ptr BerElement): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_next_attribute*(ld: ptr LDAP, entry: ptr LDAPMessage, `ptr`: ptr BerElement): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_get_values*(ld: ptr LDAP, entry: ptr LDAPMessage, attr: PCHAR): ptr PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_get_values_len*(ExternalHandle: ptr LDAP, Message: ptr LDAPMessage, attr: PCHAR): ptr ptr BERVAL {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_count_values*(vals: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_value_free*(vals: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_get_dn*(ld: ptr LDAP, entry: ptr LDAPMessage): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_explode_dn*(dn: PCHAR, notypes: ULONG): ptr PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_dn2ufn*(dn: PCHAR): PCHAR {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_memfree*(Block: PCHAR): VOID {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_ufn2dn*(ufn: PCHAR, pDn: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_escape_filter_element*(sourceFilterElement: PCHAR, sourceLength: ULONG, destFilterElement: PCHAR, destLength: ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_create_sort_control*(ExternalHandle: PLDAP, SortKeys: ptr PLDAPSortKeyA, IsCritical: UCHAR, Control: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_parse_sort_control*(ExternalHandle: PLDAP, Control: ptr PLDAPControlA, Result: ptr ULONG, Attribute: ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_create_page_control*(ExternalHandle: PLDAP, PageSize: ULONG, Cookie: ptr BERVAL, IsCritical: UCHAR, Control: ptr PLDAPControlA): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_parse_page_control*(ExternalHandle: PLDAP, ServerControls: ptr PLDAPControlA, TotalCount: ptr ULONG, Cookie: ptr ptr BERVAL): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_search_init_page*(ExternalHandle: PLDAP, DistinguishedName: PCHAR, ScopeOfSearch: ULONG, SearchFilter: PCHAR, AttributeList: ptr PCHAR, AttributesOnly: ULONG, ServerControls: ptr PLDAPControl, ClientControls: ptr PLDAPControl, PageTimeLimit: ULONG, TotalSizeLimit: ULONG, SortKeys: ptr PLDAPSortKey): PLDAPSearch {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_create_vlv_control*(ExternalHandle: PLDAP, VlvInfo: PLDAPVLVInfo, IsCritical: UCHAR, Control: ptr PLDAPControlA): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_create_vlv_controlA".} + proc ldap_parse_vlv_control*(ExternalHandle: PLDAP, Control: ptr PLDAPControlA, TargetPos: PULONG, ListCount: PULONG, Context: ptr PBERVAL, ErrCode: PINT): INT {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_parse_vlv_controlA".} + proc ldap_start_tls_s*(ExternalHandle: PLDAP, ServerReturnValue: PULONG, result: ptr ptr LDAPMessage, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_start_tls_sA".} + proc ldap_parse_reference*(Connection: ptr LDAP, ResultMessage: ptr LDAPMessage, Referrals: ptr ptr PCHAR): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_extended_operation*(ld: ptr LDAP, Oid: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, MessageNumber: ptr ULONG): ULONG {.winapi, cdecl, dynlib: "wldap32", importc.} + proc ldap_extended_operation_s*(ExternalHandle: ptr LDAP, Oid: PCHAR, Data: ptr BERVAL, ServerControls: ptr PLDAPControlA, ClientControls: ptr PLDAPControlA, ReturnedOid: ptr PCHAR, ReturnedData: ptr ptr BERVAL): ULONG {.winapi, stdcall, dynlib: "wldap32", importc: "ldap_extended_operation_sA".} + proc SslEmptyCache*(pszTargetName: LPSTR, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "schannel", importc: "SslEmptyCacheA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winnetwk.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winnetwk.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,391 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +#include +#include +type + NETRESOURCEA* {.pure.} = object + dwScope*: DWORD + dwType*: DWORD + dwDisplayType*: DWORD + dwUsage*: DWORD + lpLocalName*: LPSTR + lpRemoteName*: LPSTR + lpComment*: LPSTR + lpProvider*: LPSTR + LPNETRESOURCEA* = ptr NETRESOURCEA + NETRESOURCEW* {.pure.} = object + dwScope*: DWORD + dwType*: DWORD + dwDisplayType*: DWORD + dwUsage*: DWORD + lpLocalName*: LPWSTR + lpRemoteName*: LPWSTR + lpComment*: LPWSTR + lpProvider*: LPWSTR + LPNETRESOURCEW* = ptr NETRESOURCEW + CONNECTDLGSTRUCTA* {.pure.} = object + cbStructure*: DWORD + hwndOwner*: HWND + lpConnRes*: LPNETRESOURCEA + dwFlags*: DWORD + dwDevNum*: DWORD + LPCONNECTDLGSTRUCTA* = ptr CONNECTDLGSTRUCTA + CONNECTDLGSTRUCTW* {.pure.} = object + cbStructure*: DWORD + hwndOwner*: HWND + lpConnRes*: LPNETRESOURCEW + dwFlags*: DWORD + dwDevNum*: DWORD + LPCONNECTDLGSTRUCTW* = ptr CONNECTDLGSTRUCTW + DISCDLGSTRUCTA* {.pure.} = object + cbStructure*: DWORD + hwndOwner*: HWND + lpLocalName*: LPSTR + lpRemoteName*: LPSTR + dwFlags*: DWORD + LPDISCDLGSTRUCTA* = ptr DISCDLGSTRUCTA + DISCDLGSTRUCTW* {.pure.} = object + cbStructure*: DWORD + hwndOwner*: HWND + lpLocalName*: LPWSTR + lpRemoteName*: LPWSTR + dwFlags*: DWORD + LPDISCDLGSTRUCTW* = ptr DISCDLGSTRUCTW + UNIVERSAL_NAME_INFOA* {.pure.} = object + lpUniversalName*: LPSTR + LPUNIVERSAL_NAME_INFOA* = ptr UNIVERSAL_NAME_INFOA + UNIVERSAL_NAME_INFOW* {.pure.} = object + lpUniversalName*: LPWSTR + LPUNIVERSAL_NAME_INFOW* = ptr UNIVERSAL_NAME_INFOW + REMOTE_NAME_INFOA* {.pure.} = object + lpUniversalName*: LPSTR + lpConnectionName*: LPSTR + lpRemainingPath*: LPSTR + LPREMOTE_NAME_INFOA* = ptr REMOTE_NAME_INFOA + REMOTE_NAME_INFOW* {.pure.} = object + lpUniversalName*: LPWSTR + lpConnectionName*: LPWSTR + lpRemainingPath*: LPWSTR + LPREMOTE_NAME_INFOW* = ptr REMOTE_NAME_INFOW + NETINFOSTRUCT* {.pure.} = object + cbStructure*: DWORD + dwProviderVersion*: DWORD + dwStatus*: DWORD + dwCharacteristics*: DWORD + dwHandle*: ULONG_PTR + wNetType*: WORD + dwPrinters*: DWORD + dwDrives*: DWORD + LPNETINFOSTRUCT* = ptr NETINFOSTRUCT + NETCONNECTINFOSTRUCT* {.pure.} = object + cbStructure*: DWORD + dwFlags*: DWORD + dwSpeed*: DWORD + dwDelay*: DWORD + dwOptDataSize*: DWORD + LPNETCONNECTINFOSTRUCT* = ptr NETCONNECTINFOSTRUCT +const + WNNC_NET_MSNET* = 0x00010000 + WNNC_NET_SMB* = 0x00020000 + WNNC_NET_LANMAN* = WNNC_NET_SMB + WNNC_NET_NETWARE* = 0x00030000 + WNNC_NET_VINES* = 0x00040000 + WNNC_NET_10NET* = 0x00050000 + WNNC_NET_LOCUS* = 0x00060000 + WNNC_NET_SUN_PC_NFS* = 0x00070000 + WNNC_NET_LANSTEP* = 0x00080000 + WNNC_NET_9TILES* = 0x00090000 + WNNC_NET_LANTASTIC* = 0x000a0000 + WNNC_NET_AS400* = 0x000b0000 + WNNC_NET_FTP_NFS* = 0x000c0000 + WNNC_NET_PATHWORKS* = 0x000d0000 + WNNC_NET_LIFENET* = 0x000e0000 + WNNC_NET_POWERLAN* = 0x000f0000 + WNNC_NET_BWNFS* = 0x00100000 + WNNC_NET_COGENT* = 0x00110000 + WNNC_NET_FARALLON* = 0x00120000 + WNNC_NET_APPLETALK* = 0x00130000 + WNNC_NET_INTERGRAPH* = 0x00140000 + WNNC_NET_SYMFONET* = 0x00150000 + WNNC_NET_CLEARCASE* = 0x00160000 + WNNC_NET_FRONTIER* = 0x00170000 + WNNC_NET_BMC* = 0x00180000 + WNNC_NET_DCE* = 0x00190000 + WNNC_NET_AVID* = 0x001a0000 + WNNC_NET_DOCUSPACE* = 0x001b0000 + WNNC_NET_MANGOSOFT* = 0x001c0000 + WNNC_NET_SERNET* = 0x001d0000 + WNNC_NET_RIVERFRONT1* = 0x001e0000 + WNNC_NET_RIVERFRONT2* = 0x001f0000 + WNNC_NET_DECORB* = 0x00200000 + WNNC_NET_PROTSTOR* = 0x00210000 + WNNC_NET_FJ_REDIR* = 0x00220000 + WNNC_NET_DISTINCT* = 0x00230000 + WNNC_NET_TWINS* = 0x00240000 + WNNC_NET_RDR2SAMPLE* = 0x00250000 + WNNC_NET_CSC* = 0x00260000 + WNNC_NET_3IN1* = 0x00270000 + WNNC_NET_EXTENDNET* = 0x00290000 + WNNC_NET_STAC* = 0x002a0000 + WNNC_NET_FOXBAT* = 0x002b0000 + WNNC_NET_YAHOO* = 0x002c0000 + WNNC_NET_EXIFS* = 0x002d0000 + WNNC_NET_DAV* = 0x002e0000 + WNNC_NET_KNOWARE* = 0x002f0000 + WNNC_NET_OBJECT_DIRE* = 0x00300000 + WNNC_NET_MASFAX* = 0x00310000 + WNNC_NET_HOB_NFS* = 0x00320000 + WNNC_NET_SHIVA* = 0x00330000 + WNNC_NET_IBMAL* = 0x00340000 + WNNC_NET_LOCK* = 0x00350000 + WNNC_NET_TERMSRV* = 0x00360000 + WNNC_NET_SRT* = 0x00370000 + WNNC_NET_QUINCY* = 0x00380000 + WNNC_NET_OPENAFS* = 0x00390000 + WNNC_NET_AVID1* = 0x003a0000 + WNNC_NET_DFS* = 0x003b0000 + WNNC_NET_KWNP* = 0x003c0000 + WNNC_NET_ZENWORKS* = 0x003d0000 + WNNC_NET_DRIVEONWEB* = 0x003e0000 + WNNC_NET_VMWARE* = 0x003f0000 + WNNC_NET_RSFX* = 0x00400000 + WNNC_NET_MFILES* = 0x00410000 + WNNC_NET_MS_NFS* = 0x00420000 + WNNC_NET_GOOGLE* = 0x00430000 + WNNC_NET_NDFS* = 0x00440000 + WNNC_CRED_MANAGER* = 0xffff0000'i32 + RESOURCE_CONNECTED* = 0x00000001 + RESOURCE_GLOBALNET* = 0x00000002 + RESOURCE_REMEMBERED* = 0x00000003 + RESOURCE_RECENT* = 0x00000004 + RESOURCE_CONTEXT* = 0x00000005 + RESOURCETYPE_ANY* = 0x00000000 + RESOURCETYPE_DISK* = 0x00000001 + RESOURCETYPE_PRINT* = 0x00000002 + RESOURCETYPE_RESERVED* = 0x00000008 + RESOURCETYPE_UNKNOWN* = 0xFFFFFFFF'i32 + RESOURCEUSAGE_CONNECTABLE* = 0x00000001 + RESOURCEUSAGE_CONTAINER* = 0x00000002 + RESOURCEUSAGE_NOLOCALDEVICE* = 0x00000004 + RESOURCEUSAGE_SIBLING* = 0x00000008 + RESOURCEUSAGE_ATTACHED* = 0x00000010 + RESOURCEUSAGE_ALL* = RESOURCEUSAGE_CONNECTABLE or RESOURCEUSAGE_CONTAINER or RESOURCEUSAGE_ATTACHED + RESOURCEUSAGE_RESERVED* = 0x80000000'i32 + RESOURCEDISPLAYTYPE_GENERIC* = 0x00000000 + RESOURCEDISPLAYTYPE_DOMAIN* = 0x00000001 + RESOURCEDISPLAYTYPE_SERVER* = 0x00000002 + RESOURCEDISPLAYTYPE_SHARE* = 0x00000003 + RESOURCEDISPLAYTYPE_FILE* = 0x00000004 + RESOURCEDISPLAYTYPE_GROUP* = 0x00000005 + RESOURCEDISPLAYTYPE_NETWORK* = 0x00000006 + RESOURCEDISPLAYTYPE_ROOT* = 0x00000007 + RESOURCEDISPLAYTYPE_SHAREADMIN* = 0x00000008 + RESOURCEDISPLAYTYPE_DIRECTORY* = 0x00000009 + RESOURCEDISPLAYTYPE_TREE* = 0x0000000a + RESOURCEDISPLAYTYPE_NDSCONTAINER* = 0x0000000b + NETPROPERTY_PERSISTENT* = 1 + CONNECT_UPDATE_PROFILE* = 0x00000001 + CONNECT_UPDATE_RECENT* = 0x00000002 + CONNECT_TEMPORARY* = 0x00000004 + CONNECT_INTERACTIVE* = 0x00000008 + CONNECT_PROMPT* = 0x00000010 + CONNECT_NEED_DRIVE* = 0x00000020 + CONNECT_REFCOUNT* = 0x00000040 + CONNECT_REDIRECT* = 0x00000080 + CONNECT_LOCALDRIVE* = 0x00000100 + CONNECT_CURRENT_MEDIA* = 0x00000200 + CONNECT_DEFERRED* = 0x00000400 + CONNECT_RESERVED* = 0xFF000000'i32 + CONNECT_COMMANDLINE* = 0x00000800 + CONNECT_CMD_SAVECRED* = 0x00001000 + CONNECT_CRED_RESET* = 0x00002000 + CONNDLG_RO_PATH* = 0x00000001 + CONNDLG_CONN_POINT* = 0x00000002 + CONNDLG_USE_MRU* = 0x00000004 + CONNDLG_HIDE_BOX* = 0x00000008 + CONNDLG_PERSIST* = 0x00000010 + CONNDLG_NOT_PERSIST* = 0x00000020 + DISC_UPDATE_PROFILE* = 0x00000001 + DISC_NO_FORCE* = 0x00000040 + UNIVERSAL_NAME_INFO_LEVEL* = 0x00000001 + REMOTE_NAME_INFO_LEVEL* = 0x00000002 + WNFMT_MULTILINE* = 0x01 + WNFMT_ABBREVIATED* = 0x02 + WNFMT_INENUM* = 0x10 + WNFMT_CONNECTION* = 0x20 + NETINFO_DLL16* = 0x00000001 + NETINFO_DISKRED* = 0x00000004 + NETINFO_PRINTERRED* = 0x00000008 + RP_LOGON* = 0x01 + RP_INIFILE* = 0x02 + PP_DISPLAYERRORS* = 0x01 + WN_SUCCESS* = NO_ERROR + WN_NO_ERROR* = NO_ERROR + WN_NOT_SUPPORTED* = ERROR_NOT_SUPPORTED + WN_CANCEL* = ERROR_CANCELLED + WN_RETRY* = ERROR_RETRY + WN_NET_ERROR* = ERROR_UNEXP_NET_ERR + WN_MORE_DATA* = ERROR_MORE_DATA + WN_BAD_POINTER* = ERROR_INVALID_ADDRESS + WN_BAD_VALUE* = ERROR_INVALID_PARAMETER + WN_BAD_USER* = ERROR_BAD_USERNAME + WN_BAD_PASSWORD* = ERROR_INVALID_PASSWORD + WN_ACCESS_DENIED* = ERROR_ACCESS_DENIED + WN_FUNCTION_BUSY* = ERROR_BUSY + WN_WINDOWS_ERROR* = ERROR_UNEXP_NET_ERR + WN_OUT_OF_MEMORY* = ERROR_NOT_ENOUGH_MEMORY + WN_NO_NETWORK* = ERROR_NO_NETWORK + WN_EXTENDED_ERROR* = ERROR_EXTENDED_ERROR + WN_BAD_LEVEL* = ERROR_INVALID_LEVEL + WN_BAD_HANDLE* = ERROR_INVALID_HANDLE + WN_NOT_INITIALIZING* = ERROR_ALREADY_INITIALIZED + WN_NO_MORE_DEVICES* = ERROR_NO_MORE_DEVICES + WN_NOT_CONNECTED* = ERROR_NOT_CONNECTED + WN_OPEN_FILES* = ERROR_OPEN_FILES + WN_DEVICE_IN_USE* = ERROR_DEVICE_IN_USE + WN_BAD_NETNAME* = ERROR_BAD_NET_NAME + WN_BAD_LOCALNAME* = ERROR_BAD_DEVICE + WN_ALREADY_CONNECTED* = ERROR_ALREADY_ASSIGNED + WN_DEVICE_ERROR* = ERROR_GEN_FAILURE + WN_CONNECTION_CLOSED* = ERROR_CONNECTION_UNAVAIL + WN_NO_NET_OR_BAD_PATH* = ERROR_NO_NET_OR_BAD_PATH + WN_BAD_PROVIDER* = ERROR_BAD_PROVIDER + WN_CANNOT_OPEN_PROFILE* = ERROR_CANNOT_OPEN_PROFILE + WN_BAD_PROFILE* = ERROR_BAD_PROFILE + WN_BAD_DEV_TYPE* = ERROR_BAD_DEV_TYPE + WN_DEVICE_ALREADY_REMEMBERED* = ERROR_DEVICE_ALREADY_REMEMBERED + WN_CONNECTED_OTHER_PASSWORD* = ERROR_CONNECTED_OTHER_PASSWORD + WN_CONNECTED_OTHER_PASSWORD_DEFAULT* = ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT + WN_NO_MORE_ENTRIES* = ERROR_NO_MORE_ITEMS + WN_NOT_CONTAINER* = ERROR_NOT_CONTAINER + WN_NOT_AUTHENTICATED* = ERROR_NOT_AUTHENTICATED + WN_NOT_LOGGED_ON* = ERROR_NOT_LOGGED_ON + WN_NOT_VALIDATED* = ERROR_NO_LOGON_SERVERS + WNCON_FORNETCARD* = 0x00000001 + WNCON_NOTROUTED* = 0x00000002 + WNCON_SLOWLINK* = 0x00000004 + WNCON_DYNAMIC* = 0x00000008 +type + PFNGETPROFILEPATHA* = proc (pszUsername: LPCSTR, pszBuffer: LPSTR, cbBuffer: UINT): UINT {.stdcall.} + PFNGETPROFILEPATHW* = proc (pszUsername: LPCWSTR, pszBuffer: LPWSTR, cbBuffer: UINT): UINT {.stdcall.} + PFNRECONCILEPROFILEA* = proc (pszCentralFile: LPCSTR, pszLocalFile: LPCSTR, dwFlags: DWORD): UINT {.stdcall.} + PFNRECONCILEPROFILEW* = proc (pszCentralFile: LPCWSTR, pszLocalFile: LPCWSTR, dwFlags: DWORD): UINT {.stdcall.} + PFNPROCESSPOLICIESA* = proc (hwnd: HWND, pszPath: LPCSTR, pszUsername: LPCSTR, pszComputerName: LPCSTR, dwFlags: DWORD): WINBOOL {.stdcall.} + PFNPROCESSPOLICIESW* = proc (hwnd: HWND, pszPath: LPCWSTR, pszUsername: LPCWSTR, pszComputerName: LPCWSTR, dwFlags: DWORD): WINBOOL {.stdcall.} +proc WNetAddConnectionA*(lpRemoteName: LPCSTR, lpPassword: LPCSTR, lpLocalName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetAddConnectionW*(lpRemoteName: LPCWSTR, lpPassword: LPCWSTR, lpLocalName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetAddConnection2A*(lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetAddConnection2W*(lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetAddConnection3A*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetAddConnection3W*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetCancelConnectionA*(lpName: LPCSTR, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetCancelConnectionW*(lpName: LPCWSTR, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetCancelConnection2A*(lpName: LPCSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetCancelConnection2W*(lpName: LPCWSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetConnectionA*(lpLocalName: LPCSTR, lpRemoteName: LPSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetConnectionW*(lpLocalName: LPCWSTR, lpRemoteName: LPWSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetUseConnectionA*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserID: LPCSTR, dwFlags: DWORD, lpAccessName: LPSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetUseConnectionW*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserID: LPCWSTR, dwFlags: DWORD, lpAccessName: LPWSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetConnectionDialog*(hwnd: HWND, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetDisconnectDialog*(hwnd: HWND, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetRestoreSingleConnectionW*(hwndParent: HWND, lpDevice: LPCWSTR, fUseUI: BOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetConnectionDialog1A*(lpConnDlgStruct: LPCONNECTDLGSTRUCTA): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetConnectionDialog1W*(lpConnDlgStruct: LPCONNECTDLGSTRUCTW): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetDisconnectDialog1A*(lpConnDlgStruct: LPDISCDLGSTRUCTA): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetDisconnectDialog1W*(lpConnDlgStruct: LPDISCDLGSTRUCTW): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetOpenEnumA*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEA, lphEnum: LPHANDLE): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetOpenEnumW*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEW, lphEnum: LPHANDLE): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetEnumResourceA*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetEnumResourceW*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetCloseEnum*(hEnum: HANDLE): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetResourceParentA*(lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetResourceParentW*(lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetResourceInformationA*(lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetResourceInformationW*(lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetUniversalNameA*(lpLocalPath: LPCSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetUniversalNameW*(lpLocalPath: LPCWSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetUserA*(lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetUserW*(lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetProviderNameA*(dwNetType: DWORD, lpProviderName: LPSTR, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetProviderNameW*(dwNetType: DWORD, lpProviderName: LPWSTR, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetNetworkInformationA*(lpProvider: LPCSTR, lpNetInfoStruct: LPNETINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetNetworkInformationW*(lpProvider: LPCWSTR, lpNetInfoStruct: LPNETINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetLastErrorA*(lpError: LPDWORD, lpErrorBuf: LPSTR, nErrorBufSize: DWORD, lpNameBuf: LPSTR, nNameBufSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc WNetGetLastErrorW*(lpError: LPDWORD, lpErrorBuf: LPWSTR, nErrorBufSize: DWORD, lpNameBuf: LPWSTR, nNameBufSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc MultinetGetConnectionPerformanceA*(lpNetResource: LPNETRESOURCEA, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +proc MultinetGetConnectionPerformanceW*(lpNetResource: LPNETRESOURCEW, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc.} +when winimUnicode: + type + NETRESOURCE* = NETRESOURCEW + LPNETRESOURCE* = LPNETRESOURCEW + CONNECTDLGSTRUCT* = CONNECTDLGSTRUCTW + LPCONNECTDLGSTRUCT* = LPCONNECTDLGSTRUCTW + DISCDLGSTRUCT* = DISCDLGSTRUCTW + LPDISCDLGSTRUCT* = LPDISCDLGSTRUCTW + UNIVERSAL_NAME_INFO* = UNIVERSAL_NAME_INFOW + LPUNIVERSAL_NAME_INFO* = LPUNIVERSAL_NAME_INFOW + REMOTE_NAME_INFO* = REMOTE_NAME_INFOW + LPREMOTE_NAME_INFO* = LPREMOTE_NAME_INFOW + PFNGETPROFILEPATH* = PFNGETPROFILEPATHW + PFNRECONCILEPROFILE* = PFNRECONCILEPROFILEW + PFNPROCESSPOLICIES* = PFNPROCESSPOLICIESW + proc WNetAddConnection*(lpRemoteName: LPCWSTR, lpPassword: LPCWSTR, lpLocalName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnectionW".} + proc WNetAddConnection2*(lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnection2W".} + proc WNetAddConnection3*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnection3W".} + proc WNetCancelConnection*(lpName: LPCWSTR, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetCancelConnectionW".} + proc WNetCancelConnection2*(lpName: LPCWSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetCancelConnection2W".} + proc WNetGetConnection*(lpLocalName: LPCWSTR, lpRemoteName: LPWSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetConnectionW".} + proc WNetUseConnection*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserID: LPCWSTR, dwFlags: DWORD, lpAccessName: LPWSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetUseConnectionW".} + proc WNetConnectionDialog1*(lpConnDlgStruct: LPCONNECTDLGSTRUCTW): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1W".} + proc WNetDisconnectDialog1*(lpConnDlgStruct: LPDISCDLGSTRUCTW): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetDisconnectDialog1W".} + proc WNetOpenEnum*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEW, lphEnum: LPHANDLE): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetOpenEnumW".} + proc WNetEnumResource*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetEnumResourceW".} + proc WNetGetResourceParent*(lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetResourceParentW".} + proc WNetGetResourceInformation*(lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: ptr LPWSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetResourceInformationW".} + proc WNetGetUniversalName*(lpLocalPath: LPCWSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameW".} + proc WNetGetUser*(lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetUserW".} + proc WNetGetProviderName*(dwNetType: DWORD, lpProviderName: LPWSTR, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetProviderNameW".} + proc WNetGetNetworkInformation*(lpProvider: LPCWSTR, lpNetInfoStruct: LPNETINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationW".} + proc WNetGetLastError*(lpError: LPDWORD, lpErrorBuf: LPWSTR, nErrorBufSize: DWORD, lpNameBuf: LPWSTR, nNameBufSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetLastErrorW".} + proc MultinetGetConnectionPerformance*(lpNetResource: LPNETRESOURCEW, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "MultinetGetConnectionPerformanceW".} +when winimAnsi: + type + NETRESOURCE* = NETRESOURCEA + LPNETRESOURCE* = LPNETRESOURCEA + CONNECTDLGSTRUCT* = CONNECTDLGSTRUCTA + LPCONNECTDLGSTRUCT* = LPCONNECTDLGSTRUCTA + DISCDLGSTRUCT* = DISCDLGSTRUCTA + LPDISCDLGSTRUCT* = LPDISCDLGSTRUCTA + UNIVERSAL_NAME_INFO* = UNIVERSAL_NAME_INFOA + LPUNIVERSAL_NAME_INFO* = LPUNIVERSAL_NAME_INFOA + REMOTE_NAME_INFO* = REMOTE_NAME_INFOA + LPREMOTE_NAME_INFO* = LPREMOTE_NAME_INFOA + PFNGETPROFILEPATH* = PFNGETPROFILEPATHA + PFNRECONCILEPROFILE* = PFNRECONCILEPROFILEA + PFNPROCESSPOLICIES* = PFNPROCESSPOLICIESA + proc WNetAddConnection*(lpRemoteName: LPCSTR, lpPassword: LPCSTR, lpLocalName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnectionA".} + proc WNetAddConnection2*(lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnection2A".} + proc WNetAddConnection3*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetAddConnection3A".} + proc WNetCancelConnection*(lpName: LPCSTR, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetCancelConnectionA".} + proc WNetCancelConnection2*(lpName: LPCSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetCancelConnection2A".} + proc WNetGetConnection*(lpLocalName: LPCSTR, lpRemoteName: LPSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetConnectionA".} + proc WNetUseConnection*(hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserID: LPCSTR, dwFlags: DWORD, lpAccessName: LPSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetUseConnectionA".} + proc WNetConnectionDialog1*(lpConnDlgStruct: LPCONNECTDLGSTRUCTA): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1A".} + proc WNetDisconnectDialog1*(lpConnDlgStruct: LPDISCDLGSTRUCTA): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetDisconnectDialog1A".} + proc WNetOpenEnum*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEA, lphEnum: LPHANDLE): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetOpenEnumA".} + proc WNetEnumResource*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetEnumResourceA".} + proc WNetGetResourceParent*(lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetResourceParentA".} + proc WNetGetResourceInformation*(lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: ptr LPSTR): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetResourceInformationA".} + proc WNetGetUniversalName*(lpLocalPath: LPCSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameA".} + proc WNetGetUser*(lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetUserA".} + proc WNetGetProviderName*(dwNetType: DWORD, lpProviderName: LPSTR, lpBufferSize: LPDWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetProviderNameA".} + proc WNetGetNetworkInformation*(lpProvider: LPCSTR, lpNetInfoStruct: LPNETINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationA".} + proc WNetGetLastError*(lpError: LPDWORD, lpErrorBuf: LPSTR, nErrorBufSize: DWORD, lpNameBuf: LPSTR, nNameBufSize: DWORD): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "WNetGetLastErrorA".} + proc MultinetGetConnectionPerformance*(lpNetResource: LPNETRESOURCEA, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD {.winapi, stdcall, dynlib: "mpr", importc: "MultinetGetConnectionPerformanceA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winnls.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winnls.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,900 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +#include +#include +type + SYSNLS_FUNCTION* = int32 + SYSGEOTYPE* = int32 + SYSGEOCLASS* = int32 + NORM_FORM* = int32 + LGRPID* = DWORD + LCTYPE* = DWORD + CALTYPE* = DWORD + CALID* = DWORD + NLS_FUNCTION* = DWORD + GEOID* = LONG + GEOTYPE* = DWORD + GEOCLASS* = DWORD +const + MAX_DEFAULTCHAR* = 2 + MAX_LEADBYTES* = 12 +type + CPINFO* {.pure.} = object + MaxCharSize*: UINT + DefaultChar*: array[MAX_DEFAULTCHAR, BYTE] + LeadByte*: array[MAX_LEADBYTES, BYTE] + LPCPINFO* = ptr CPINFO + CPINFOEXA* {.pure.} = object + MaxCharSize*: UINT + DefaultChar*: array[MAX_DEFAULTCHAR, BYTE] + LeadByte*: array[MAX_LEADBYTES, BYTE] + UnicodeDefaultChar*: WCHAR + CodePage*: UINT + CodePageName*: array[MAX_PATH, CHAR] + LPCPINFOEXA* = ptr CPINFOEXA + CPINFOEXW* {.pure.} = object + MaxCharSize*: UINT + DefaultChar*: array[MAX_DEFAULTCHAR, BYTE] + LeadByte*: array[MAX_LEADBYTES, BYTE] + UnicodeDefaultChar*: WCHAR + CodePage*: UINT + CodePageName*: array[MAX_PATH, WCHAR] + LPCPINFOEXW* = ptr CPINFOEXW + NUMBERFMTA* {.pure.} = object + NumDigits*: UINT + LeadingZero*: UINT + Grouping*: UINT + lpDecimalSep*: LPSTR + lpThousandSep*: LPSTR + NegativeOrder*: UINT + LPNUMBERFMTA* = ptr NUMBERFMTA + NUMBERFMTW* {.pure.} = object + NumDigits*: UINT + LeadingZero*: UINT + Grouping*: UINT + lpDecimalSep*: LPWSTR + lpThousandSep*: LPWSTR + NegativeOrder*: UINT + LPNUMBERFMTW* = ptr NUMBERFMTW + CURRENCYFMTA* {.pure.} = object + NumDigits*: UINT + LeadingZero*: UINT + Grouping*: UINT + lpDecimalSep*: LPSTR + lpThousandSep*: LPSTR + NegativeOrder*: UINT + PositiveOrder*: UINT + lpCurrencySymbol*: LPSTR + LPCURRENCYFMTA* = ptr CURRENCYFMTA + CURRENCYFMTW* {.pure.} = object + NumDigits*: UINT + LeadingZero*: UINT + Grouping*: UINT + lpDecimalSep*: LPWSTR + lpThousandSep*: LPWSTR + NegativeOrder*: UINT + PositiveOrder*: UINT + lpCurrencySymbol*: LPWSTR + LPCURRENCYFMTW* = ptr CURRENCYFMTW + NLSVERSIONINFO* {.pure.} = object + dwNLSVersionInfoSize*: DWORD + dwNLSVersion*: DWORD + dwDefinedVersion*: DWORD + dwEffectiveId*: DWORD + guidCustomVersion*: GUID + LPNLSVERSIONINFO* = ptr NLSVERSIONINFO + NLSVERSIONINFOEX* {.pure.} = object + dwNLSVersionInfoSize*: DWORD + dwNLSVersion*: DWORD + dwDefinedVersion*: DWORD + dwEffectiveId*: DWORD + guidCustomVersion*: GUID + LPNLSVERSIONINFOEX* = ptr NLSVERSIONINFOEX + FILEMUIINFO* {.pure.} = object + dwSize*: DWORD + dwVersion*: DWORD + dwFileType*: DWORD + pChecksum*: array[16, BYTE] + pServiceChecksum*: array[16, BYTE] + dwLanguageNameOffset*: DWORD + dwTypeIDMainSize*: DWORD + dwTypeIDMainOffset*: DWORD + dwTypeNameMainOffset*: DWORD + dwTypeIDMUISize*: DWORD + dwTypeIDMUIOffset*: DWORD + dwTypeNameMUIOffset*: DWORD + abBuffer*: array[8, BYTE] + PFILEMUIINFO* = ptr FILEMUIINFO +const + HIGH_SURROGATE_START* = 0xd800 + HIGH_SURROGATE_END* = 0xdbff + LOW_SURROGATE_START* = 0xdc00 + LOW_SURROGATE_END* = 0xdfff + MB_PRECOMPOSED* = 0x00000001 + MB_COMPOSITE* = 0x00000002 + MB_USEGLYPHCHARS* = 0x00000004 + MB_ERR_INVALID_CHARS* = 0x00000008 + WC_DISCARDNS* = 0x00000010 + WC_SEPCHARS* = 0x00000020 + WC_DEFAULTCHAR* = 0x00000040 + WC_ERR_INVALID_CHARS* = 0x00000080 + WC_COMPOSITECHECK* = 0x00000200 + WC_NO_BEST_FIT_CHARS* = 0x00000400 + CT_CTYPE1* = 0x00000001 + CT_CTYPE2* = 0x00000002 + CT_CTYPE3* = 0x00000004 + C1_UPPER* = 0x0001 + C1_LOWER* = 0x0002 + C1_DIGIT* = 0x0004 + C1_SPACE* = 0x0008 + C1_PUNCT* = 0x0010 + C1_CNTRL* = 0x0020 + C1_BLANK* = 0x0040 + C1_XDIGIT* = 0x0080 + C1_ALPHA* = 0x0100 + C1_DEFINED* = 0x0200 + C2_LEFTTORIGHT* = 0x0001 + C2_RIGHTTOLEFT* = 0x0002 + C2_EUROPENUMBER* = 0x0003 + C2_EUROPESEPARATOR* = 0x0004 + C2_EUROPETERMINATOR* = 0x0005 + C2_ARABICNUMBER* = 0x0006 + C2_COMMONSEPARATOR* = 0x0007 + C2_BLOCKSEPARATOR* = 0x0008 + C2_SEGMENTSEPARATOR* = 0x0009 + C2_WHITESPACE* = 0x000a + C2_OTHERNEUTRAL* = 0x000b + C2_NOTAPPLICABLE* = 0x0000 + C3_NONSPACING* = 0x0001 + C3_DIACRITIC* = 0x0002 + C3_VOWELMARK* = 0x0004 + C3_SYMBOL* = 0x0008 + C3_KATAKANA* = 0x0010 + C3_HIRAGANA* = 0x0020 + C3_HALFWIDTH* = 0x0040 + C3_FULLWIDTH* = 0x0080 + C3_IDEOGRAPH* = 0x0100 + C3_KASHIDA* = 0x0200 + C3_LEXICAL* = 0x0400 + C3_HIGHSURROGATE* = 0x0800 + C3_LOWSURROGATE* = 0x1000 + C3_ALPHA* = 0x8000 + C3_NOTAPPLICABLE* = 0x0000 + NORM_IGNORECASE* = 0x00000001 + NORM_IGNORENONSPACE* = 0x00000002 + NORM_IGNORESYMBOLS* = 0x00000004 + LINGUISTIC_IGNORECASE* = 0x00000010 + LINGUISTIC_IGNOREDIACRITIC* = 0x00000020 + NORM_IGNOREKANATYPE* = 0x00010000 + NORM_IGNOREWIDTH* = 0x00020000 + NORM_LINGUISTIC_CASING* = 0x08000000 + MAP_FOLDCZONE* = 0x00000010 + MAP_PRECOMPOSED* = 0x00000020 + MAP_COMPOSITE* = 0x00000040 + MAP_FOLDDIGITS* = 0x00000080 + MAP_EXPAND_LIGATURES* = 0x00002000 + LCMAP_LOWERCASE* = 0x00000100 + LCMAP_UPPERCASE* = 0x00000200 + LCMAP_TITLECASE* = 0x00000300 + LCMAP_SORTKEY* = 0x00000400 + LCMAP_BYTEREV* = 0x00000800 + LCMAP_HIRAGANA* = 0x00100000 + LCMAP_KATAKANA* = 0x00200000 + LCMAP_HALFWIDTH* = 0x00400000 + LCMAP_FULLWIDTH* = 0x00800000 + LCMAP_LINGUISTIC_CASING* = 0x01000000 + LCMAP_SIMPLIFIED_CHINESE* = 0x02000000 + LCMAP_TRADITIONAL_CHINESE* = 0x04000000 + LCMAP_SORTHANDLE* = 0x20000000 + LCMAP_HASH* = 0x00040000 + FIND_STARTSWITH* = 0x00100000 + FIND_ENDSWITH* = 0x00200000 + FIND_FROMSTART* = 0x00400000 + FIND_FROMEND* = 0x00800000 + LGRPID_INSTALLED* = 0x00000001 + LGRPID_SUPPORTED* = 0x00000002 + LCID_INSTALLED* = 0x00000001 + LCID_SUPPORTED* = 0x00000002 + LCID_ALTERNATE_SORTS* = 0x00000004 + LOCALE_ALL* = 0 + LOCALE_WINDOWS* = 0x00000001 + LOCALE_SUPPLEMENTAL* = 0x00000002 + LOCALE_ALTERNATE_SORTS* = 0x00000004 + LOCALE_REPLACEMENT* = 0x00000008 + LOCALE_NEUTRALDATA* = 0x00000010 + LOCALE_SPECIFICDATA* = 0x00000020 + CP_INSTALLED* = 0x00000001 + CP_SUPPORTED* = 0x00000002 + SORT_STRINGSORT* = 0x00001000 + SORT_DIGITSASNUMBERS* = 0x00000008 + CSTR_LESS_THAN* = 1 + CSTR_EQUAL* = 2 + CSTR_GREATER_THAN* = 3 + CP_ACP* = 0 + CP_OEMCP* = 1 + CP_MACCP* = 2 + CP_THREAD_ACP* = 3 + CP_SYMBOL* = 42 + CP_UTF7* = 65000 + CP_UTF8* = 65001 + CTRY_DEFAULT* = 0 + CTRY_ALBANIA* = 355 + CTRY_ALGERIA* = 213 + CTRY_ARGENTINA* = 54 + CTRY_ARMENIA* = 374 + CTRY_AUSTRALIA* = 61 + CTRY_AUSTRIA* = 43 + CTRY_AZERBAIJAN* = 994 + CTRY_BAHRAIN* = 973 + CTRY_BELARUS* = 375 + CTRY_BELGIUM* = 32 + CTRY_BELIZE* = 501 + CTRY_BOLIVIA* = 591 + CTRY_BRAZIL* = 55 + CTRY_BRUNEI_DARUSSALAM* = 673 + CTRY_BULGARIA* = 359 + CTRY_CANADA* = 2 + CTRY_CARIBBEAN* = 1 + CTRY_CHILE* = 56 + CTRY_COLOMBIA* = 57 + CTRY_COSTA_RICA* = 506 + CTRY_CROATIA* = 385 + CTRY_CZECH* = 420 + CTRY_DENMARK* = 45 + CTRY_DOMINICAN_REPUBLIC* = 1 + CTRY_ECUADOR* = 593 + CTRY_EGYPT* = 20 + CTRY_EL_SALVADOR* = 503 + CTRY_ESTONIA* = 372 + CTRY_FAEROE_ISLANDS* = 298 + CTRY_FINLAND* = 358 + CTRY_FRANCE* = 33 + CTRY_GEORGIA* = 995 + CTRY_GERMANY* = 49 + CTRY_GREECE* = 30 + CTRY_GUATEMALA* = 502 + CTRY_HONDURAS* = 504 + CTRY_HONG_KONG* = 852 + CTRY_HUNGARY* = 36 + CTRY_ICELAND* = 354 + CTRY_INDIA* = 91 + CTRY_INDONESIA* = 62 + CTRY_IRAN* = 981 + CTRY_IRAQ* = 964 + CTRY_IRELAND* = 353 + CTRY_ISRAEL* = 972 + CTRY_ITALY* = 39 + CTRY_JAMAICA* = 1 + CTRY_JAPAN* = 81 + CTRY_JORDAN* = 962 + CTRY_KAZAKSTAN* = 7 + CTRY_KENYA* = 254 + CTRY_KUWAIT* = 965 + CTRY_KYRGYZSTAN* = 996 + CTRY_LATVIA* = 371 + CTRY_LEBANON* = 961 + CTRY_LIBYA* = 218 + CTRY_LIECHTENSTEIN* = 41 + CTRY_LITHUANIA* = 370 + CTRY_LUXEMBOURG* = 352 + CTRY_MACAU* = 853 + CTRY_MACEDONIA* = 389 + CTRY_MALAYSIA* = 60 + CTRY_MALDIVES* = 960 + CTRY_MEXICO* = 52 + CTRY_MONACO* = 33 + CTRY_MONGOLIA* = 976 + CTRY_MOROCCO* = 212 + CTRY_NETHERLANDS* = 31 + CTRY_NEW_ZEALAND* = 64 + CTRY_NICARAGUA* = 505 + CTRY_NORWAY* = 47 + CTRY_OMAN* = 968 + CTRY_PAKISTAN* = 92 + CTRY_PANAMA* = 507 + CTRY_PARAGUAY* = 595 + CTRY_PERU* = 51 + CTRY_PHILIPPINES* = 63 + CTRY_POLAND* = 48 + CTRY_PORTUGAL* = 351 + CTRY_PRCHINA* = 86 + CTRY_PUERTO_RICO* = 1 + CTRY_QATAR* = 974 + CTRY_ROMANIA* = 40 + CTRY_RUSSIA* = 7 + CTRY_SAUDI_ARABIA* = 966 + CTRY_SERBIA* = 381 + CTRY_SINGAPORE* = 65 + CTRY_SLOVAK* = 421 + CTRY_SLOVENIA* = 386 + CTRY_SOUTH_AFRICA* = 27 + CTRY_SOUTH_KOREA* = 82 + CTRY_SPAIN* = 34 + CTRY_SWEDEN* = 46 + CTRY_SWITZERLAND* = 41 + CTRY_SYRIA* = 963 + CTRY_TAIWAN* = 886 + CTRY_TATARSTAN* = 7 + CTRY_THAILAND* = 66 + CTRY_TRINIDAD_Y_TOBAGO* = 1 + CTRY_TUNISIA* = 216 + CTRY_TURKEY* = 90 + CTRY_UAE* = 971 + CTRY_UKRAINE* = 380 + CTRY_UNITED_KINGDOM* = 44 + CTRY_UNITED_STATES* = 1 + CTRY_URUGUAY* = 598 + CTRY_UZBEKISTAN* = 7 + CTRY_VENEZUELA* = 58 + CTRY_VIET_NAM* = 84 + CTRY_YEMEN* = 967 + CTRY_ZIMBABWE* = 263 + LOCALE_SLOCALIZEDDISPLAYNAME* = 0x00000002 + LOCALE_ALLOW_NEUTRAL_NAMES* = 0x08000000 + LOCALE_RETURN_GENITIVE_NAMES* = 0x10000000 + LOCALE_RETURN_NUMBER* = 0x20000000 + LOCALE_USE_CP_ACP* = 0x40000000 + LOCALE_NOUSEROVERRIDE* = 0x80000000'i32 + LOCALE_SENGLISHDISPLAYNAME* = 0x00000072 + LOCALE_SNATIVEDISPLAYNAME* = 0x00000073 + LOCALE_SLOCALIZEDLANGUAGENAME* = 0x0000006f + LOCALE_SENGLISHLANGUAGENAME* = 0x00001001 + LOCALE_SNATIVELANGUAGENAME* = 0x00000004 + LOCALE_SLOCALIZEDCOUNTRYNAME* = 0x00000006 + LOCALE_SENGLISHCOUNTRYNAME* = 0x00001002 + LOCALE_SNATIVECOUNTRYNAME* = 0x00000008 + LOCALE_SLANGUAGE* = 0x00000002 + LOCALE_SLANGDISPLAYNAME* = 0x0000006f + LOCALE_SENGLANGUAGE* = 0x00001001 + LOCALE_SNATIVELANGNAME* = 0x00000004 + LOCALE_SCOUNTRY* = 0x00000006 + LOCALE_SENGCOUNTRY* = 0x00001002 + LOCALE_SNATIVECTRYNAME* = 0x00000008 + LOCALE_ILANGUAGE* = 0x00000001 + LOCALE_SABBREVLANGNAME* = 0x00000003 + LOCALE_ICOUNTRY* = 0x00000005 + LOCALE_SABBREVCTRYNAME* = 0x00000007 + LOCALE_IGEOID* = 0x0000005b + LOCALE_IDEFAULTLANGUAGE* = 0x00000009 + LOCALE_IDEFAULTCOUNTRY* = 0x0000000a + LOCALE_IDEFAULTCODEPAGE* = 0x0000000b + LOCALE_IDEFAULTANSICODEPAGE* = 0x00001004 + LOCALE_IDEFAULTMACCODEPAGE* = 0x00001011 + LOCALE_SLIST* = 0x0000000c + LOCALE_IMEASURE* = 0x0000000d + LOCALE_SDECIMAL* = 0x0000000e + LOCALE_STHOUSAND* = 0x0000000f + LOCALE_SGROUPING* = 0x00000010 + LOCALE_IDIGITS* = 0x00000011 + LOCALE_ILZERO* = 0x00000012 + LOCALE_INEGNUMBER* = 0x00001010 + LOCALE_SNATIVEDIGITS* = 0x00000013 + LOCALE_SCURRENCY* = 0x00000014 + LOCALE_SINTLSYMBOL* = 0x00000015 + LOCALE_SMONDECIMALSEP* = 0x00000016 + LOCALE_SMONTHOUSANDSEP* = 0x00000017 + LOCALE_SMONGROUPING* = 0x00000018 + LOCALE_ICURRDIGITS* = 0x00000019 + LOCALE_IINTLCURRDIGITS* = 0x0000001a + LOCALE_ICURRENCY* = 0x0000001b + LOCALE_INEGCURR* = 0x0000001c + LOCALE_SDATE* = 0x0000001d + LOCALE_STIME* = 0x0000001e + LOCALE_SSHORTDATE* = 0x0000001f + LOCALE_SLONGDATE* = 0x00000020 + LOCALE_STIMEFORMAT* = 0x00001003 + LOCALE_IDATE* = 0x00000021 + LOCALE_ILDATE* = 0x00000022 + LOCALE_ITIME* = 0x00000023 + LOCALE_ITIMEMARKPOSN* = 0x00001005 + LOCALE_ICENTURY* = 0x00000024 + LOCALE_ITLZERO* = 0x00000025 + LOCALE_IDAYLZERO* = 0x00000026 + LOCALE_IMONLZERO* = 0x00000027 + LOCALE_S1159* = 0x00000028 + LOCALE_S2359* = 0x00000029 + LOCALE_ICALENDARTYPE* = 0x00001009 + LOCALE_IOPTIONALCALENDAR* = 0x0000100b + LOCALE_IFIRSTDAYOFWEEK* = 0x0000100c + LOCALE_IFIRSTWEEKOFYEAR* = 0x0000100d + LOCALE_SDAYNAME1* = 0x0000002a + LOCALE_SDAYNAME2* = 0x0000002b + LOCALE_SDAYNAME3* = 0x0000002c + LOCALE_SDAYNAME4* = 0x0000002d + LOCALE_SDAYNAME5* = 0x0000002e + LOCALE_SDAYNAME6* = 0x0000002f + LOCALE_SDAYNAME7* = 0x00000030 + LOCALE_SABBREVDAYNAME1* = 0x00000031 + LOCALE_SABBREVDAYNAME2* = 0x00000032 + LOCALE_SABBREVDAYNAME3* = 0x00000033 + LOCALE_SABBREVDAYNAME4* = 0x00000034 + LOCALE_SABBREVDAYNAME5* = 0x00000035 + LOCALE_SABBREVDAYNAME6* = 0x00000036 + LOCALE_SABBREVDAYNAME7* = 0x00000037 + LOCALE_SMONTHNAME1* = 0x00000038 + LOCALE_SMONTHNAME2* = 0x00000039 + LOCALE_SMONTHNAME3* = 0x0000003a + LOCALE_SMONTHNAME4* = 0x0000003b + LOCALE_SMONTHNAME5* = 0x0000003c + LOCALE_SMONTHNAME6* = 0x0000003d + LOCALE_SMONTHNAME7* = 0x0000003e + LOCALE_SMONTHNAME8* = 0x0000003f + LOCALE_SMONTHNAME9* = 0x00000040 + LOCALE_SMONTHNAME10* = 0x00000041 + LOCALE_SMONTHNAME11* = 0x00000042 + LOCALE_SMONTHNAME12* = 0x00000043 + LOCALE_SMONTHNAME13* = 0x0000100e + LOCALE_SABBREVMONTHNAME1* = 0x00000044 + LOCALE_SABBREVMONTHNAME2* = 0x00000045 + LOCALE_SABBREVMONTHNAME3* = 0x00000046 + LOCALE_SABBREVMONTHNAME4* = 0x00000047 + LOCALE_SABBREVMONTHNAME5* = 0x00000048 + LOCALE_SABBREVMONTHNAME6* = 0x00000049 + LOCALE_SABBREVMONTHNAME7* = 0x0000004a + LOCALE_SABBREVMONTHNAME8* = 0x0000004b + LOCALE_SABBREVMONTHNAME9* = 0x0000004c + LOCALE_SABBREVMONTHNAME10* = 0x0000004d + LOCALE_SABBREVMONTHNAME11* = 0x0000004e + LOCALE_SABBREVMONTHNAME12* = 0x0000004f + LOCALE_SABBREVMONTHNAME13* = 0x0000100f + LOCALE_SPOSITIVESIGN* = 0x00000050 + LOCALE_SNEGATIVESIGN* = 0x00000051 + LOCALE_IPOSSIGNPOSN* = 0x00000052 + LOCALE_INEGSIGNPOSN* = 0x00000053 + LOCALE_IPOSSYMPRECEDES* = 0x00000054 + LOCALE_IPOSSEPBYSPACE* = 0x00000055 + LOCALE_INEGSYMPRECEDES* = 0x00000056 + LOCALE_INEGSEPBYSPACE* = 0x00000057 + LOCALE_FONTSIGNATURE* = 0x00000058 + LOCALE_SISO639LANGNAME* = 0x00000059 + LOCALE_SISO3166CTRYNAME* = 0x0000005a + LOCALE_IDEFAULTEBCDICCODEPAGE* = 0x00001012 + LOCALE_IPAPERSIZE* = 0x0000100a + LOCALE_SENGCURRNAME* = 0x00001007 + LOCALE_SNATIVECURRNAME* = 0x00001008 + LOCALE_SYEARMONTH* = 0x00001006 + LOCALE_SSORTNAME* = 0x00001013 + LOCALE_IDIGITSUBSTITUTION* = 0x00001014 + LOCALE_SNAME* = 0x0000005c + LOCALE_SDURATION* = 0x0000005d + LOCALE_SKEYBOARDSTOINSTALL* = 0x0000005e + LOCALE_SSHORTESTDAYNAME1* = 0x00000060 + LOCALE_SSHORTESTDAYNAME2* = 0x00000061 + LOCALE_SSHORTESTDAYNAME3* = 0x00000062 + LOCALE_SSHORTESTDAYNAME4* = 0x00000063 + LOCALE_SSHORTESTDAYNAME5* = 0x00000064 + LOCALE_SSHORTESTDAYNAME6* = 0x00000065 + LOCALE_SSHORTESTDAYNAME7* = 0x00000066 + LOCALE_SISO639LANGNAME2* = 0x00000067 + LOCALE_SISO3166CTRYNAME2* = 0x00000068 + LOCALE_SNAN* = 0x00000069 + LOCALE_SPOSINFINITY* = 0x0000006a + LOCALE_SNEGINFINITY* = 0x0000006b + LOCALE_SSCRIPTS* = 0x0000006c + LOCALE_SPARENT* = 0x0000006d + LOCALE_SCONSOLEFALLBACKNAME* = 0x0000006e + LOCALE_IREADINGLAYOUT* = 0x00000070 + LOCALE_INEUTRAL* = 0x00000071 + LOCALE_INEGATIVEPERCENT* = 0x00000074 + LOCALE_IPOSITIVEPERCENT* = 0x00000075 + LOCALE_SPERCENT* = 0x00000076 + LOCALE_SPERMILLE* = 0x00000077 + LOCALE_SMONTHDAY* = 0x00000078 + LOCALE_SSHORTTIME* = 0x00000079 + LOCALE_SOPENTYPELANGUAGETAG* = 0x0000007a + LOCALE_SSORTLOCALE* = 0x0000007b + TIME_NOMINUTESORSECONDS* = 0x00000001 + TIME_NOSECONDS* = 0x00000002 + TIME_NOTIMEMARKER* = 0x00000004 + TIME_FORCE24HOURFORMAT* = 0x00000008 + DATE_SHORTDATE* = 0x00000001 + DATE_LONGDATE* = 0x00000002 + DATE_USE_ALT_CALENDAR* = 0x00000004 + DATE_YEARMONTH* = 0x00000008 + DATE_LTRREADING* = 0x00000010 + DATE_RTLREADING* = 0x00000020 + DATE_AUTOLAYOUT* = 0x00000040 + CAL_NOUSEROVERRIDE* = LOCALE_NOUSEROVERRIDE + CAL_USE_CP_ACP* = LOCALE_USE_CP_ACP + CAL_RETURN_NUMBER* = LOCALE_RETURN_NUMBER + CAL_RETURN_GENITIVE_NAMES* = LOCALE_RETURN_GENITIVE_NAMES + CAL_ICALINTVALUE* = 0x00000001 + CAL_SCALNAME* = 0x00000002 + CAL_IYEAROFFSETRANGE* = 0x00000003 + CAL_SERASTRING* = 0x00000004 + CAL_SSHORTDATE* = 0x00000005 + CAL_SLONGDATE* = 0x00000006 + CAL_SDAYNAME1* = 0x00000007 + CAL_SDAYNAME2* = 0x00000008 + CAL_SDAYNAME3* = 0x00000009 + CAL_SDAYNAME4* = 0x0000000a + CAL_SDAYNAME5* = 0x0000000b + CAL_SDAYNAME6* = 0x0000000c + CAL_SDAYNAME7* = 0x0000000d + CAL_SABBREVDAYNAME1* = 0x0000000e + CAL_SABBREVDAYNAME2* = 0x0000000f + CAL_SABBREVDAYNAME3* = 0x00000010 + CAL_SABBREVDAYNAME4* = 0x00000011 + CAL_SABBREVDAYNAME5* = 0x00000012 + CAL_SABBREVDAYNAME6* = 0x00000013 + CAL_SABBREVDAYNAME7* = 0x00000014 + CAL_SMONTHNAME1* = 0x00000015 + CAL_SMONTHNAME2* = 0x00000016 + CAL_SMONTHNAME3* = 0x00000017 + CAL_SMONTHNAME4* = 0x00000018 + CAL_SMONTHNAME5* = 0x00000019 + CAL_SMONTHNAME6* = 0x0000001a + CAL_SMONTHNAME7* = 0x0000001b + CAL_SMONTHNAME8* = 0x0000001c + CAL_SMONTHNAME9* = 0x0000001d + CAL_SMONTHNAME10* = 0x0000001e + CAL_SMONTHNAME11* = 0x0000001f + CAL_SMONTHNAME12* = 0x00000020 + CAL_SMONTHNAME13* = 0x00000021 + CAL_SABBREVMONTHNAME1* = 0x00000022 + CAL_SABBREVMONTHNAME2* = 0x00000023 + CAL_SABBREVMONTHNAME3* = 0x00000024 + CAL_SABBREVMONTHNAME4* = 0x00000025 + CAL_SABBREVMONTHNAME5* = 0x00000026 + CAL_SABBREVMONTHNAME6* = 0x00000027 + CAL_SABBREVMONTHNAME7* = 0x00000028 + CAL_SABBREVMONTHNAME8* = 0x00000029 + CAL_SABBREVMONTHNAME9* = 0x0000002a + CAL_SABBREVMONTHNAME10* = 0x0000002b + CAL_SABBREVMONTHNAME11* = 0x0000002c + CAL_SABBREVMONTHNAME12* = 0x0000002d + CAL_SABBREVMONTHNAME13* = 0x0000002e + CAL_SYEARMONTH* = 0x0000002f + CAL_ITWODIGITYEARMAX* = 0x00000030 + CAL_SSHORTESTDAYNAME1* = 0x00000031 + CAL_SSHORTESTDAYNAME2* = 0x00000032 + CAL_SSHORTESTDAYNAME3* = 0x00000033 + CAL_SSHORTESTDAYNAME4* = 0x00000034 + CAL_SSHORTESTDAYNAME5* = 0x00000035 + CAL_SSHORTESTDAYNAME6* = 0x00000036 + CAL_SSHORTESTDAYNAME7* = 0x00000037 + CAL_SMONTHDAY* = 0x00000038 + CAL_SABBREVERASTRING* = 0x00000039 + ENUM_ALL_CALENDARS* = 0xffffffff'i32 + CAL_GREGORIAN* = 1 + CAL_GREGORIAN_US* = 2 + CAL_JAPAN* = 3 + CAL_TAIWAN* = 4 + CAL_KOREA* = 5 + CAL_HIJRI* = 6 + CAL_THAI* = 7 + CAL_HEBREW* = 8 + CAL_GREGORIAN_ME_FRENCH* = 9 + CAL_GREGORIAN_ARABIC* = 10 + CAL_GREGORIAN_XLIT_ENGLISH* = 11 + CAL_GREGORIAN_XLIT_FRENCH* = 12 + CAL_UMALQURA* = 23 + LGRPID_WESTERN_EUROPE* = 0x0001 + LGRPID_CENTRAL_EUROPE* = 0x0002 + LGRPID_BALTIC* = 0x0003 + LGRPID_GREEK* = 0x0004 + LGRPID_CYRILLIC* = 0x0005 + LGRPID_TURKIC* = 0x0006 + LGRPID_TURKISH* = 0x0006 + LGRPID_JAPANESE* = 0x0007 + LGRPID_KOREAN* = 0x0008 + LGRPID_TRADITIONAL_CHINESE* = 0x0009 + LGRPID_SIMPLIFIED_CHINESE* = 0x000a + LGRPID_THAI* = 0x000b + LGRPID_HEBREW* = 0x000c + LGRPID_ARABIC* = 0x000d + LGRPID_VIETNAMESE* = 0x000e + LGRPID_INDIC* = 0x000f + LGRPID_GEORGIAN* = 0x0010 + LGRPID_ARMENIAN* = 0x0011 + MUI_LANGUAGE_ID* = 0x4 + MUI_LANGUAGE_NAME* = 0x8 + MUI_MERGE_SYSTEM_FALLBACK* = 0x10 + MUI_MERGE_USER_FALLBACK* = 0x20 + MUI_UI_FALLBACK* = MUI_MERGE_SYSTEM_FALLBACK or MUI_MERGE_USER_FALLBACK + MUI_THREAD_LANGUAGES* = 0x40 + MUI_CONSOLE_FILTER* = 0x100 + MUI_COMPLEX_SCRIPT_FILTER* = 0x200 + MUI_RESET_FILTERS* = 0x001 + MUI_USER_PREFERRED_UI_LANGUAGES* = 0x10 + MUI_USE_INSTALLED_LANGUAGES* = 0x20 + MUI_USE_SEARCH_ALL_LANGUAGES* = 0x40 + MUI_LANG_NEUTRAL_PE_FILE* = 0x100 + MUI_NON_LANG_NEUTRAL_FILE* = 0x200 + MUI_MACHINE_LANGUAGE_SETTINGS* = 0x400 + MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL* = 0x001 + MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN* = 0x002 + MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI* = 0x004 + MUI_QUERY_TYPE* = 0x001 + MUI_QUERY_CHECKSUM* = 0x002 + MUI_QUERY_LANGUAGE_NAME* = 0x004 + MUI_QUERY_RESOURCE_TYPES* = 0x008 + MUI_FILEINFO_VERSION* = 0x001 + MUI_FULL_LANGUAGE* = 0x01 + MUI_PARTIAL_LANGUAGE* = 0x02 + MUI_LIP_LANGUAGE* = 0x04 + MUI_LANGUAGE_INSTALLED* = 0x20 + MUI_LANGUAGE_LICENSED* = 0x40 + compareString* = 0x1 + GEOID_NOT_AVAILABLE* = -1 + GEO_NATION* = 0x0001 + GEO_LATITUDE* = 0x0002 + GEO_LONGITUDE* = 0x0003 + GEO_ISO2* = 0x0004 + GEO_ISO3* = 0x0005 + GEO_RFC1766* = 0x0006 + GEO_LCID* = 0x0007 + GEO_FRIENDLYNAME* = 0x0008 + GEO_OFFICIALNAME* = 0x0009 + GEO_TIMEZONES* = 0x000a + GEO_OFFICIALLANGUAGES* = 0x000b + GEO_ISO_UN_NUMBER* = 0x000c + GEO_PARENT* = 0x000d + GEOCLASS_NATION* = 16 + GEOCLASS_REGION* = 14 + GEOCLASS_ALL* = 0 + normalizationOther* = 0 + normalizationC* = 0x1 + normalizationD* = 0x2 + normalizationKC* = 0x5 + normalizationKD* = 0x6 + IDN_ALLOW_UNASSIGNED* = 0x01 + IDN_USE_STD3_ASCII_RULES* = 0x02 + IDN_EMAIL_ADDRESS* = 0x04 + IDN_RAW_PUNYCODE* = 0x08 + VS_ALLOW_LATIN* = 0x0001 + GSS_ALLOW_INHERITED_COMMON* = 0x0001 + MUI_FORMAT_REG_COMPAT* = 0x0001 + MUI_FORMAT_INF_COMPAT* = 0x0002 + MUI_VERIFY_FILE_EXISTS* = 0x0004 + MUI_SKIP_STRING_CACHE* = 0x0008 + MUI_IMMUTABLE_LOOKUP* = 0x0010 + LOCALE_NAME_USER_DEFAULT* = NULL + LOCALE_NAME_INVARIANT* = "" + LOCALE_NAME_SYSTEM_DEFAULT* = "!x-sys-default-locale" +type + LANGUAGEGROUP_ENUMPROCA* = proc (P1: LGRPID, P2: LPSTR, P3: LPSTR, P4: DWORD, P5: LONG_PTR): WINBOOL {.stdcall.} + LANGGROUPLOCALE_ENUMPROCA* = proc (P1: LGRPID, P2: LCID, P3: LPSTR, P4: LONG_PTR): WINBOOL {.stdcall.} + UILANGUAGE_ENUMPROCA* = proc (P1: LPSTR, P2: LONG_PTR): WINBOOL {.stdcall.} + CODEPAGE_ENUMPROCA* = proc (P1: LPSTR): WINBOOL {.stdcall.} + DATEFMT_ENUMPROCA* = proc (P1: LPSTR): WINBOOL {.stdcall.} + DATEFMT_ENUMPROCEXA* = proc (P1: LPSTR, P2: CALID): WINBOOL {.stdcall.} + TIMEFMT_ENUMPROCA* = proc (P1: LPSTR): WINBOOL {.stdcall.} + CALINFO_ENUMPROCA* = proc (P1: LPSTR): WINBOOL {.stdcall.} + CALINFO_ENUMPROCEXA* = proc (P1: LPSTR, P2: CALID): WINBOOL {.stdcall.} + LOCALE_ENUMPROCA* = proc (P1: LPSTR): WINBOOL {.stdcall.} + LOCALE_ENUMPROCW* = proc (P1: LPWSTR): WINBOOL {.stdcall.} + LANGUAGEGROUP_ENUMPROCW* = proc (P1: LGRPID, P2: LPWSTR, P3: LPWSTR, P4: DWORD, P5: LONG_PTR): WINBOOL {.stdcall.} + LANGGROUPLOCALE_ENUMPROCW* = proc (P1: LGRPID, P2: LCID, P3: LPWSTR, P4: LONG_PTR): WINBOOL {.stdcall.} + UILANGUAGE_ENUMPROCW* = proc (P1: LPWSTR, P2: LONG_PTR): WINBOOL {.stdcall.} + CODEPAGE_ENUMPROCW* = proc (P1: LPWSTR): WINBOOL {.stdcall.} + DATEFMT_ENUMPROCW* = proc (P1: LPWSTR): WINBOOL {.stdcall.} + DATEFMT_ENUMPROCEXW* = proc (P1: LPWSTR, P2: CALID): WINBOOL {.stdcall.} + TIMEFMT_ENUMPROCW* = proc (P1: LPWSTR): WINBOOL {.stdcall.} + CALINFO_ENUMPROCW* = proc (P1: LPWSTR): WINBOOL {.stdcall.} + CALINFO_ENUMPROCEXW* = proc (P1: LPWSTR, P2: CALID): WINBOOL {.stdcall.} + GEO_ENUMPROC* = proc (P1: GEOID): WINBOOL {.stdcall.} + CALINFO_ENUMPROCEXEX* = proc (P1: LPWSTR, P2: CALID, P3: LPWSTR, P4: LPARAM): WINBOOL {.stdcall.} + DATEFMT_ENUMPROCEXEX* = proc (P1: LPWSTR, P2: CALID, P3: LPARAM): WINBOOL {.stdcall.} + TIMEFMT_ENUMPROCEX* = proc (P1: LPWSTR, P2: LPARAM): WINBOOL {.stdcall.} + LOCALE_ENUMPROCEX* = proc (P1: LPWSTR, P2: DWORD, P3: LPARAM): WINBOOL {.stdcall.} +proc GetTimeFormatEx*(lpLocaleName: LPCWSTR, dwFlags: DWORD, lpTime: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDateFormatEx*(lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDate: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int32, lpCalendar: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDateFormatA*(Locale: LCID, dwFlags: DWORD, lpDate: ptr SYSTEMTIME, lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDateFormatW*(Locale: LCID, dwFlags: DWORD, lpDate: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTimeFormatA*(Locale: LCID, dwFlags: DWORD, lpTime: ptr SYSTEMTIME, lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetTimeFormatW*(Locale: LCID, dwFlags: DWORD, lpTime: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CompareStringW*(Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: int32, lpString2: PCNZWCH, cchCount2: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FoldStringW*(dwMapFlags: DWORD, lpSrcStr: LPCWCH, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStringTypeExW*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CompareStringEx*(lpLocaleName: LPCWSTR, dwCmpFlags: DWORD, lpString1: LPCWCH, cchCount1: int32, lpString2: LPCWCH, cchCount2: int32, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CompareStringOrdinal*(lpString1: LPCWCH, cchCount1: int32, lpString2: LPCWCH, cchCount2: int32, bIgnoreCase: WINBOOL): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStringTypeW*(dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MultiByteToWideChar*(CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCCH, cbMultiByte: int32, lpWideCharStr: LPWSTR, cchWideChar: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WideCharToMultiByte*(CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWCH, cchWideChar: int32, lpMultiByteStr: LPSTR, cbMultiByte: int32, lpDefaultChar: LPCCH, lpUsedDefaultChar: LPBOOL): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsValidCodePage*(CodePage: UINT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetACP*(): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetOEMCP*(): UINT {.winapi, stdcall, dynlib: "kernel32", importc.} +proc CompareStringA*(Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: int32, lpString2: PCNZCH, cchCount2: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LCMapStringW*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LCMapStringA*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLocaleInfoW*(Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLocaleInfoA*(Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsDBCSLeadByte*(TestChar: BYTE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsDBCSLeadByteEx*(CodePage: UINT, TestChar: BYTE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumberFormatA*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: ptr NUMBERFMTA, lpNumberStr: LPSTR, cchNumber: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumberFormatW*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr NUMBERFMTW, lpNumberStr: LPWSTR, cchNumber: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrencyFormatA*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: ptr CURRENCYFMTA, lpCurrencyStr: LPSTR, cchCurrency: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrencyFormatW*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr CURRENCYFMTW, lpCurrencyStr: LPWSTR, cchCurrency: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumCalendarInfoA*(lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumCalendarInfoW*(lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumCalendarInfoExA*(lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumCalendarInfoExW*(lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumTimeFormatsA*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumTimeFormatsW*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDateFormatsA*(lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDateFormatsW*(lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDateFormatsExA*(lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDateFormatsExW*(lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsValidLanguageGroup*(LanguageGroup: LGRPID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNLSVersion*(Function: NLS_FUNCTION, Locale: LCID, lpVersionInformation: LPNLSVERSIONINFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsNLSDefinedString*(Function: NLS_FUNCTION, dwFlags: DWORD, lpVersionInformation: LPNLSVERSIONINFO, lpString: LPCWSTR, cchStr: INT): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsValidLocale*(Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetLocaleInfoA*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetLocaleInfoW*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCalendarInfoA*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: int32, lpValue: LPDWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCalendarInfoW*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int32, lpValue: LPDWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCalendarInfoA*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetCalendarInfoW*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDurationFormat*(Locale: LCID, dwFlags: DWORD, lpDuration: ptr SYSTEMTIME, ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNLSString*(Locale: LCID, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int32, lpStringValue: LPCWSTR, cchValue: int32, pcchFound: LPINT): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetGeoInfoA*(Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: int32, LangId: LANGID): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetGeoInfoW*(Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: int32, LangId: LANGID): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemGeoID*(GeoClass: GEOCLASS, ParentGeoId: GEOID, lpGeoEnumProc: GEO_ENUMPROC): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserGeoID*(GeoClass: GEOCLASS): GEOID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCPInfo*(CodePage: UINT, lpCPInfo: LPCPINFO): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCPInfoExA*(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCPInfoExW*(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LCIDToLocaleName*(Locale: LCID, lpName: LPWSTR, cchName: int32, dwFlags: DWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LocaleNameToLCID*(lpName: LPCWSTR, dwFlags: DWORD): LCID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetUserGeoID*(GeoId: GEOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ConvertDefaultLocale*(Locale: LCID): LCID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadLocale*(): LCID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadLocale*(Locale: LCID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDefaultUILanguage*(): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserDefaultUILanguage*(): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDefaultLangID*(): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserDefaultLangID*(): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDefaultLCID*(): LCID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserDefaultLCID*(): LCID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadUILanguage*(LangId: LANGID): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStringTypeExA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStringTypeA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FoldStringA*(dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemLocalesA*(lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemLocalesW*(lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemLanguageGroupsA*(lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemLanguageGroupsW*(lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumLanguageGroupLocalesA*(lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumLanguageGroupLocalesW*(lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumUILanguagesA*(lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumUILanguagesW*(lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadUILanguage*(): LANGID {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetProcessPreferredUILanguages*(dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetProcessPreferredUILanguages*(dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserPreferredUILanguages*(dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemPreferredUILanguages*(dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetThreadPreferredUILanguages*(dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SetThreadPreferredUILanguages*(dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileMUIInfo*(dwFlags: DWORD, pcwszFilePath: PCWSTR, pFileMUIInfo: PFILEMUIINFO, pcbFileMUIInfo: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetFileMUIPath*(dwFlags: DWORD, pcwszFilePath: PCWSTR, pwszLanguage: PWSTR, pcchLanguage: PULONG, pwszFileMUIPath: PWSTR, pcchFileMUIPath: PULONG, pululEnumerator: PULONGLONG): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUILanguageInfo*(dwFlags: DWORD, pwmszLanguage: PCZZWSTR, pwszFallbackLanguages: PZZWSTR, pcchFallbackLanguages: PDWORD, pAttributes: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc NotifyUILanguageChange*(dwFlags: DWORD, pcwstrNewLanguage: PCWSTR, pcwstrPreviousLanguage: PCWSTR, dwReserved: DWORD, pdwStatusRtrn: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemCodePagesA*(lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemCodePagesW*(lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc NormalizeString*(NormForm: NORM_FORM, lpSrcString: LPCWSTR, cwSrcLength: int32, lpDstString: LPWSTR, cwDstLength: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsNormalizedString*(NormForm: NORM_FORM, lpString: LPCWSTR, cwLength: int32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IdnToAscii*(dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int32, lpASCIICharStr: LPWSTR, cchASCIIChar: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IdnToNameprepUnicode*(dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int32, lpNameprepCharStr: LPWSTR, cchNameprepChar: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IdnToUnicode*(dwFlags: DWORD, lpASCIICharStr: LPCWSTR, cchASCIIChar: int32, lpUnicodeCharStr: LPWSTR, cchUnicodeChar: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc VerifyScripts*(dwFlags: DWORD, lpLocaleScripts: LPCWSTR, cchLocaleScripts: int32, lpTestScripts: LPCWSTR, cchTestScripts: int32): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetStringScripts*(dwFlags: DWORD, lpString: LPCWSTR, cchString: int32, lpScripts: LPWSTR, cchScripts: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetLocaleInfoEx*(lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCalendarInfoEx*(lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int32, lpValue: LPDWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetDurationFormatEx*(lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDuration: ptr SYSTEMTIME, ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNumberFormatEx*(lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr NUMBERFMTW, lpNumberStr: LPWSTR, cchNumber: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetCurrencyFormatEx*(lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr CURRENCYFMTW, lpCurrencyStr: LPWSTR, cchCurrency: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetUserDefaultLocaleName*(lpLocaleName: LPWSTR, cchLocaleName: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetSystemDefaultLocaleName*(lpLocaleName: LPWSTR, cchLocaleName: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc GetNLSVersionEx*(function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc FindNLSStringEx*(lpLocaleName: LPCWSTR, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int32, lpStringValue: LPCWSTR, cchValue: int32, pcchFound: LPINT, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, sortHandle: LPARAM): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc LCMapStringEx*(lpLocaleName: LPCWSTR, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, sortHandle: LPARAM): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsValidLocaleName*(lpLocaleName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumCalendarInfoExEx*(pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX, lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumDateFormatsExEx*(lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumTimeFormatsEx*(lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc EnumSystemLocalesEx*(lpLocaleEnumProcEx: LOCALE_ENUMPROCEX, dwFlags: DWORD, lParam: LPARAM, lpReserved: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc.} +proc ResolveLocaleName*(lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc IsValidNLSVersion*(function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX): DWORD {.winapi, stdcall, dynlib: "kernel32", importc.} +template IS_HIGH_SURROGATE*(wch: untyped): bool = (wch >= HIGH_SURROGATE_START) and (wch <= HIGH_SURROGATE_END) +template IS_LOW_SURROGATE*(wch: untyped): bool = (wch >= LOW_SURROGATE_START) and (wch <= LOW_SURROGATE_END) +template IS_SURROGATE_PAIR*(hs: untyped, ls: untyped): bool = IS_HIGH_SURROGATE(hs) and IS_LOW_SURROGATE(ls) +template FILEMUIINFO_GET_CULTURE*(pInfo: PFILEMUIINFO): LPWSTR = cast[LPWSTR](if pInfo.dwLanguageNameOffset > 0: cast[int](pInfo) + pInfo.dwLanguageNameOffset else: 0) +template FILEMUIINFO_GET_MAIN_TYPEIDS*(pInfo: PFILEMUIINFO): PDWORD = cast[PDWORD](if pInfo.dwTypeIDMainOffset > 0: cast[int](pInfo) + pInfo.dwTypeIDMainOffset else: 0) +template FILEMUIINFO_GET_MAIN_TYPEID*(pInfo: PFILEMUIINFO, iType: DWORD): DWORD = (if (iType < pInfo.dwTypeIDMainSize) and (pInfo.dwTypeIDMainOffset > 0): (cast[PDWORD](cast[int](pInfo) + pInfo.dwTypeIDMainOffset + iType * sizeof(DWORD)))[] else: 0) +template FILEMUIINFO_GET_MAIN_TYPENAMES*(pInfo: PFILEMUIINFO): LPWSTR = cast[LPWSTR](if pInfo.dwTypeNameMainOffset > 0: cast[int](pInfo) + pInfo.dwTypeNameMainOffset else: 0) +template FILEMUIINFO_GET_MUI_TYPEIDS*(pInfo: PFILEMUIINFO): PDWORD = cast[PDWORD](if pInfo.dwTypeIDMUIOffset > 0: cast[int](pInfo) + pInfo.dwTypeIDMUIOffset else: 0) +template FILEMUIINFO_GET_MUI_TYPEID*(pInfo: PFILEMUIINFO, iType): DWORD = (if (iType < pInfo.dwTypeIDMUISize) and (pInfo.dwTypeIDMUIOffset > 0): (cast[PDWORD](cast[int](pInfo) + pInfo.dwTypeIDMUIOffset + iType * sizeof(DWORD)))[] else: 0) +template FILEMUIINFO_GET_MUI_TYPENAMES*(pInfo: PFILEMUIINFO): LPWSTR = cast[LPWSTR](if pInfo.dwTypeNameMUIOffset > 0: cast[int](pInfo) + pInfo.dwTypeNameMUIOffset else: 0) +when winimUnicode: + type + LANGUAGEGROUP_ENUMPROC* = LANGUAGEGROUP_ENUMPROCW + LANGGROUPLOCALE_ENUMPROC* = LANGGROUPLOCALE_ENUMPROCW + UILANGUAGE_ENUMPROC* = UILANGUAGE_ENUMPROCW + CODEPAGE_ENUMPROC* = CODEPAGE_ENUMPROCW + DATEFMT_ENUMPROC* = DATEFMT_ENUMPROCW + DATEFMT_ENUMPROCEX* = DATEFMT_ENUMPROCEXW + TIMEFMT_ENUMPROC* = TIMEFMT_ENUMPROCW + CALINFO_ENUMPROC* = CALINFO_ENUMPROCW + CALINFO_ENUMPROCEX* = CALINFO_ENUMPROCEXW + LOCALE_ENUMPROC* = LOCALE_ENUMPROCW + CPINFOEX* = CPINFOEXW + LPCPINFOEX* = LPCPINFOEXW + NUMBERFMT* = NUMBERFMTW + LPNUMBERFMT* = LPNUMBERFMTW + CURRENCYFMT* = CURRENCYFMTW + LPCURRENCYFMT* = LPCURRENCYFMTW + proc CompareString*(Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: int32, lpString2: PCNZWCH, cchCount2: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "CompareStringW".} + proc FoldString*(dwMapFlags: DWORD, lpSrcStr: LPCWCH, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "FoldStringW".} + proc GetStringTypeEx*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetStringTypeExW".} + proc LCMapString*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "LCMapStringW".} + proc GetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetLocaleInfoW".} + proc GetDateFormat*(Locale: LCID, dwFlags: DWORD, lpDate: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetDateFormatW".} + proc GetTimeFormat*(Locale: LCID, dwFlags: DWORD, lpTime: ptr SYSTEMTIME, lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetTimeFormatW".} + proc SetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetLocaleInfoW".} + proc GetCalendarInfo*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int32, lpValue: LPDWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetCalendarInfoW".} + proc SetCalendarInfo*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetCalendarInfoW".} + proc GetNumberFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr NUMBERFMTW, lpNumberStr: LPWSTR, cchNumber: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetNumberFormatW".} + proc GetCurrencyFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: ptr CURRENCYFMTW, lpCurrencyStr: LPWSTR, cchCurrency: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetCurrencyFormatW".} + proc EnumCalendarInfo*(lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumCalendarInfoW".} + proc EnumCalendarInfoEx*(lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumCalendarInfoExW".} + proc EnumTimeFormats*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumTimeFormatsW".} + proc EnumDateFormats*(lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumDateFormatsW".} + proc EnumDateFormatsEx*(lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumDateFormatsExW".} + proc GetGeoInfo*(Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: int32, LangId: LANGID): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetGeoInfoW".} + proc GetCPInfoEx*(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetCPInfoExW".} + proc EnumSystemLocales*(lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesW".} + proc EnumSystemLanguageGroups*(lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemLanguageGroupsW".} + proc EnumLanguageGroupLocales*(lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumLanguageGroupLocalesW".} + proc EnumUILanguages*(lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumUILanguagesW".} + proc EnumSystemCodePages*(lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemCodePagesW".} +when winimAnsi: + type + LANGUAGEGROUP_ENUMPROC* = LANGUAGEGROUP_ENUMPROCA + LANGGROUPLOCALE_ENUMPROC* = LANGGROUPLOCALE_ENUMPROCA + UILANGUAGE_ENUMPROC* = UILANGUAGE_ENUMPROCA + CODEPAGE_ENUMPROC* = CODEPAGE_ENUMPROCA + DATEFMT_ENUMPROC* = DATEFMT_ENUMPROCA + DATEFMT_ENUMPROCEX* = DATEFMT_ENUMPROCEXA + TIMEFMT_ENUMPROC* = TIMEFMT_ENUMPROCA + CALINFO_ENUMPROC* = CALINFO_ENUMPROCA + CALINFO_ENUMPROCEX* = CALINFO_ENUMPROCEXA + LOCALE_ENUMPROC* = LOCALE_ENUMPROCA + CPINFOEX* = CPINFOEXA + LPCPINFOEX* = LPCPINFOEXA + NUMBERFMT* = NUMBERFMTA + LPNUMBERFMT* = LPNUMBERFMTA + CURRENCYFMT* = CURRENCYFMTA + LPCURRENCYFMT* = LPCURRENCYFMTA + proc CompareString*(Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: int32, lpString2: PCNZCH, cchCount2: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "CompareStringA".} + proc LCMapString*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "LCMapStringA".} + proc GetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetLocaleInfoA".} + proc FoldString*(dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "FoldStringA".} + proc GetStringTypeEx*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int32, lpCharType: LPWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetStringTypeExA".} + proc GetDateFormat*(Locale: LCID, dwFlags: DWORD, lpDate: ptr SYSTEMTIME, lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetDateFormatA".} + proc GetTimeFormat*(Locale: LCID, dwFlags: DWORD, lpTime: ptr SYSTEMTIME, lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetTimeFormatA".} + proc SetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetLocaleInfoA".} + proc GetCalendarInfo*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: int32, lpValue: LPDWORD): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetCalendarInfoA".} + proc SetCalendarInfo*(Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "SetCalendarInfoA".} + proc GetNumberFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: ptr NUMBERFMTA, lpNumberStr: LPSTR, cchNumber: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetNumberFormatA".} + proc GetCurrencyFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: ptr CURRENCYFMTA, lpCurrencyStr: LPSTR, cchCurrency: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetCurrencyFormatA".} + proc EnumCalendarInfo*(lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumCalendarInfoA".} + proc EnumCalendarInfoEx*(lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumCalendarInfoExA".} + proc EnumTimeFormats*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumTimeFormatsA".} + proc EnumDateFormats*(lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumDateFormatsA".} + proc EnumDateFormatsEx*(lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumDateFormatsExA".} + proc GetGeoInfo*(Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: int32, LangId: LANGID): int32 {.winapi, stdcall, dynlib: "kernel32", importc: "GetGeoInfoA".} + proc GetCPInfoEx*(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "GetCPInfoExA".} + proc EnumSystemLocales*(lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesA".} + proc EnumSystemLanguageGroups*(lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemLanguageGroupsA".} + proc EnumLanguageGroupLocales*(lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumLanguageGroupLocalesA".} + proc EnumUILanguages*(lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumUILanguagesA".} + proc EnumSystemCodePages*(lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "kernel32", importc: "EnumSystemCodePagesA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winperf.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winperf.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,198 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +type + PERF_DATA_BLOCK* {.pure.} = object + Signature*: array[4, WCHAR] + LittleEndian*: DWORD + Version*: DWORD + Revision*: DWORD + TotalByteLength*: DWORD + HeaderLength*: DWORD + NumObjectTypes*: DWORD + DefaultObject*: LONG + SystemTime*: SYSTEMTIME + padding*: array[4, byte] + PerfTime*: LARGE_INTEGER + PerfFreq*: LARGE_INTEGER + PerfTime100nSec*: LARGE_INTEGER + SystemNameLength*: DWORD + SystemNameOffset*: DWORD + PPERF_DATA_BLOCK* = ptr PERF_DATA_BLOCK +when winimCpu64: + type + PERF_OBJECT_TYPE* {.pure.} = object + TotalByteLength*: DWORD + DefinitionLength*: DWORD + HeaderLength*: DWORD + ObjectNameTitleIndex*: DWORD + ObjectNameTitle*: DWORD + ObjectHelpTitleIndex*: DWORD + ObjectHelpTitle*: DWORD + DetailLevel*: DWORD + NumCounters*: DWORD + DefaultCounter*: LONG + NumInstances*: LONG + CodePage*: DWORD + PerfTime*: LARGE_INTEGER + PerfFreq*: LARGE_INTEGER +when winimCpu32: + type + PERF_OBJECT_TYPE* {.pure.} = object + TotalByteLength*: DWORD + DefinitionLength*: DWORD + HeaderLength*: DWORD + ObjectNameTitleIndex*: DWORD + ObjectNameTitle*: LPWSTR + ObjectHelpTitleIndex*: DWORD + ObjectHelpTitle*: LPWSTR + DetailLevel*: DWORD + NumCounters*: DWORD + DefaultCounter*: LONG + NumInstances*: LONG + CodePage*: DWORD + PerfTime*: LARGE_INTEGER + PerfFreq*: LARGE_INTEGER +type + PPERF_OBJECT_TYPE* = ptr PERF_OBJECT_TYPE +when winimCpu64: + type + PERF_COUNTER_DEFINITION* {.pure.} = object + ByteLength*: DWORD + CounterNameTitleIndex*: DWORD + CounterNameTitle*: DWORD + CounterHelpTitleIndex*: DWORD + CounterHelpTitle*: DWORD + DefaultScale*: LONG + DetailLevel*: DWORD + CounterType*: DWORD + CounterSize*: DWORD + CounterOffset*: DWORD +when winimCpu32: + type + PERF_COUNTER_DEFINITION* {.pure.} = object + ByteLength*: DWORD + CounterNameTitleIndex*: DWORD + CounterNameTitle*: LPWSTR + CounterHelpTitleIndex*: DWORD + CounterHelpTitle*: LPWSTR + DefaultScale*: LONG + DetailLevel*: DWORD + CounterType*: DWORD + CounterSize*: DWORD + CounterOffset*: DWORD +type + PPERF_COUNTER_DEFINITION* = ptr PERF_COUNTER_DEFINITION + PERF_INSTANCE_DEFINITION* {.pure.} = object + ByteLength*: DWORD + ParentObjectTitleIndex*: DWORD + ParentObjectInstance*: DWORD + UniqueID*: LONG + NameOffset*: DWORD + NameLength*: DWORD + PPERF_INSTANCE_DEFINITION* = ptr PERF_INSTANCE_DEFINITION + PERF_COUNTER_BLOCK* {.pure.} = object + ByteLength*: DWORD + PPERF_COUNTER_BLOCK* = ptr PERF_COUNTER_BLOCK +const + PERF_DATA_VERSION* = 1 + PERF_DATA_REVISION* = 1 + PERF_NO_INSTANCES* = -1 + PERF_SIZE_DWORD* = 0x00000000 + PERF_SIZE_LARGE* = 0x00000100 + PERF_SIZE_ZERO* = 0x00000200 + PERF_SIZE_VARIABLE_LEN* = 0x00000300 + PERF_TYPE_NUMBER* = 0x00000000 + PERF_TYPE_COUNTER* = 0x00000400 + PERF_TYPE_TEXT* = 0x00000800 + PERF_TYPE_ZERO* = 0x00000C00 + PERF_NUMBER_HEX* = 0x00000000 + PERF_NUMBER_DECIMAL* = 0x00010000 + PERF_NUMBER_DEC_1000* = 0x00020000 + PERF_COUNTER_VALUE* = 0x00000000 + PERF_COUNTER_RATE* = 0x00010000 + PERF_COUNTER_FRACTION* = 0x00020000 + PERF_COUNTER_BASE* = 0x00030000 + PERF_COUNTER_ELAPSED* = 0x00040000 + PERF_COUNTER_QUEUELEN* = 0x00050000 + PERF_COUNTER_HISTOGRAM* = 0x00060000 + PERF_COUNTER_PRECISION* = 0x00070000 + PERF_TEXT_UNICODE* = 0x00000000 + PERF_TEXT_ASCII* = 0x00010000 + PERF_TIMER_TICK* = 0x00000000 + PERF_TIMER_100NS* = 0x00100000 + PERF_OBJECT_TIMER* = 0x00200000 + PERF_DELTA_COUNTER* = 0x00400000 + PERF_DELTA_BASE* = 0x00800000 + PERF_INVERSE_COUNTER* = 0x01000000 + PERF_MULTI_COUNTER* = 0x02000000 + PERF_DISPLAY_NO_SUFFIX* = 0x00000000 + PERF_DISPLAY_PER_SEC* = 0x10000000 + PERF_DISPLAY_PERCENT* = 0x20000000 + PERF_DISPLAY_SECONDS* = 0x30000000 + PERF_DISPLAY_NOSHOW* = 0x40000000 + PERF_COUNTER_COUNTER* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_PER_SEC + PERF_COUNTER_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_COUNTER_QUEUELEN_TYPE* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_QUEUELEN or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_LARGE_QUEUELEN_TYPE* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_QUEUELEN or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_100NS_QUEUELEN_TYPE* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_QUEUELEN or PERF_TIMER_100NS or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_QUEUELEN or PERF_OBJECT_TIMER or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_BULK_COUNT* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_PER_SEC + PERF_COUNTER_TEXT* = PERF_SIZE_VARIABLE_LEN or PERF_TYPE_TEXT or PERF_TEXT_UNICODE or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_RAWCOUNT* = PERF_SIZE_DWORD or PERF_TYPE_NUMBER or PERF_NUMBER_DECIMAL or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_LARGE_RAWCOUNT* = PERF_SIZE_LARGE or PERF_TYPE_NUMBER or PERF_NUMBER_DECIMAL or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_RAWCOUNT_HEX* = PERF_SIZE_DWORD or PERF_TYPE_NUMBER or PERF_NUMBER_HEX or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_LARGE_RAWCOUNT_HEX* = PERF_SIZE_LARGE or PERF_TYPE_NUMBER or PERF_NUMBER_HEX or PERF_DISPLAY_NO_SUFFIX + PERF_SAMPLE_FRACTION* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_FRACTION or PERF_DELTA_COUNTER or PERF_DELTA_BASE or PERF_DISPLAY_PERCENT + PERF_SAMPLE_COUNTER* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_NODATA* = PERF_SIZE_ZERO or PERF_DISPLAY_NOSHOW + PERF_COUNTER_TIMER_INV* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_INVERSE_COUNTER or PERF_DISPLAY_PERCENT + PERF_SAMPLE_BASE* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_BASE or PERF_DISPLAY_NOSHOW or 0x00000001 + PERF_AVERAGE_TIMER* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_FRACTION or PERF_DISPLAY_SECONDS + PERF_AVERAGE_BASE* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_BASE or PERF_DISPLAY_NOSHOW or 0x00000002 + PERF_AVERAGE_BULK* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_FRACTION or PERF_DISPLAY_NOSHOW + PERF_OBJ_TIME_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_OBJECT_TIMER or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_100NSEC_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_100NS or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_100NSEC_TIMER_INV* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_100NS or PERF_DELTA_COUNTER or PERF_INVERSE_COUNTER or PERF_DISPLAY_PERCENT + PERF_COUNTER_MULTI_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_DELTA_COUNTER or PERF_TIMER_TICK or PERF_MULTI_COUNTER or PERF_DISPLAY_PERCENT + PERF_COUNTER_MULTI_TIMER_INV* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_RATE or PERF_DELTA_COUNTER or PERF_MULTI_COUNTER or PERF_TIMER_TICK or PERF_INVERSE_COUNTER or PERF_DISPLAY_PERCENT + PERF_COUNTER_MULTI_BASE* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_BASE or PERF_MULTI_COUNTER or PERF_DISPLAY_NOSHOW + PERF_100NSEC_MULTI_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_DELTA_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_100NS or PERF_MULTI_COUNTER or PERF_DISPLAY_PERCENT + PERF_100NSEC_MULTI_TIMER_INV* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_DELTA_COUNTER or PERF_COUNTER_RATE or PERF_TIMER_100NS or PERF_MULTI_COUNTER or PERF_INVERSE_COUNTER or PERF_DISPLAY_PERCENT + PERF_RAW_FRACTION* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_FRACTION or PERF_DISPLAY_PERCENT + PERF_LARGE_RAW_FRACTION* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_FRACTION or PERF_DISPLAY_PERCENT + PERF_RAW_BASE* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_BASE or PERF_DISPLAY_NOSHOW or 0x00000003 + PERF_LARGE_RAW_BASE* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_BASE or PERF_DISPLAY_NOSHOW + PERF_ELAPSED_TIME* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_ELAPSED or PERF_OBJECT_TIMER or PERF_DISPLAY_SECONDS + PERF_COUNTER_HISTOGRAM_TYPE* = 0x80000000'i32 + PERF_COUNTER_DELTA* = PERF_SIZE_DWORD or PERF_TYPE_COUNTER or PERF_COUNTER_VALUE or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_COUNTER_LARGE_DELTA* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_VALUE or PERF_DELTA_COUNTER or PERF_DISPLAY_NO_SUFFIX + PERF_PRECISION_SYSTEM_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_PRECISION or PERF_TIMER_TICK or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_PRECISION_100NS_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_PRECISION or PERF_TIMER_100NS or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_PRECISION_OBJECT_TIMER* = PERF_SIZE_LARGE or PERF_TYPE_COUNTER or PERF_COUNTER_PRECISION or PERF_OBJECT_TIMER or PERF_DELTA_COUNTER or PERF_DISPLAY_PERCENT + PERF_PRECISION_TIMESTAMP* = PERF_LARGE_RAW_BASE + PERF_DETAIL_NOVICE* = 100 + PERF_DETAIL_ADVANCED* = 200 + PERF_DETAIL_EXPERT* = 300 + PERF_DETAIL_WIZARD* = 400 + PERF_NO_UNIQUE_ID* = -1 + PERF_QUERY_OBJECTS* = LONG 0x80000000'i32 + PERF_QUERY_GLOBAL* = LONG 0x80000001'i32 + PERF_QUERY_COSTLY* = LONG 0x80000002'i32 + MAX_PERF_OBJECTS_IN_QUERY_FUNCTION* = 64 + WINPERF_LOG_NONE* = 0 + WINPERF_LOG_USER* = 1 + WINPERF_LOG_DEBUG* = 2 + WINPERF_LOG_VERBOSE* = 3 +type + PM_OPEN_PROC* = proc (P1: LPWSTR): DWORD {.stdcall.} + PM_COLLECT_PROC* = proc (P1: LPWSTR, P2: ptr LPVOID, P3: LPDWORD, P4: LPDWORD): DWORD {.stdcall.} + PM_CLOSE_PROC* = proc (): DWORD {.stdcall.} + PM_QUERY_PROC* = proc (P1: LPDWORD, P2: ptr LPVOID, P3: LPDWORD, P4: LPDWORD): DWORD {.stdcall.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winreg.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winreg.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,340 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +#include +#include +type + LSTATUS* = LONG + REGSAM* = ACCESS_MASK + val_context* {.pure.} = object + valuelen*: int32 + value_context*: LPVOID + val_buff_ptr*: LPVOID + PVALCONTEXT* = ptr val_context + PVALUEA* {.pure.} = object + pv_valuename*: LPSTR + pv_valuelen*: int32 + pv_value_context*: LPVOID + pv_type*: DWORD + PPVALUEA* = ptr PVALUEA + PVALUEW* {.pure.} = object + pv_valuename*: LPWSTR + pv_valuelen*: int32 + pv_value_context*: LPVOID + pv_type*: DWORD + PPVALUEW* = ptr PVALUEW + QUERYHANDLER* = proc (keycontext: LPVOID, val_list: PVALCONTEXT, num_vals: DWORD, outputbuffer: LPVOID, total_outlen: ptr DWORD, input_blen: DWORD): DWORD {.cdecl.} + PQUERYHANDLER* = QUERYHANDLER + VALENTA* {.pure.} = object + ve_valuename*: LPSTR + ve_valuelen*: DWORD + ve_valueptr*: DWORD_PTR + ve_type*: DWORD + PVALENTA* = ptr VALENTA + VALENTW* {.pure.} = object + ve_valuename*: LPWSTR + ve_valuelen*: DWORD + ve_valueptr*: DWORD_PTR + ve_type*: DWORD + PVALENTW* = ptr VALENTW + REG_PROVIDER* {.pure.} = object + pi_R0_1val*: PQUERYHANDLER + pi_R0_allvals*: PQUERYHANDLER + pi_R3_1val*: PQUERYHANDLER + pi_R3_allvals*: PQUERYHANDLER + pi_flags*: DWORD + pi_key_context*: LPVOID + PPROVIDER* = ptr REG_PROVIDER +const + RRF_RT_REG_NONE* = 0x00000001 + RRF_RT_REG_SZ* = 0x00000002 + RRF_RT_REG_EXPAND_SZ* = 0x00000004 + RRF_RT_REG_BINARY* = 0x00000008 + RRF_RT_REG_DWORD* = 0x00000010 + RRF_RT_REG_MULTI_SZ* = 0x00000020 + RRF_RT_REG_QWORD* = 0x00000040 + RRF_RT_DWORD* = RRF_RT_REG_BINARY or RRF_RT_REG_DWORD + RRF_RT_QWORD* = RRF_RT_REG_BINARY or RRF_RT_REG_QWORD + RRF_RT_ANY* = 0x0000ffff + RRF_NOEXPAND* = 0x10000000 + RRF_ZEROONFAILURE* = 0x20000000 + REG_SECURE_CONNECTION* = 1 + PROVIDER_KEEPS_VALUE_LENGTH* = 0x1 + WIN31_CLASS* = NULL + SHTDN_REASON_FLAG_COMMENT_REQUIRED* = 0x01000000 + SHTDN_REASON_FLAG_DIRTY_PROBLEM_ID_REQUIRED* = 0x02000000 + SHTDN_REASON_FLAG_CLEAN_UI* = 0x04000000 + SHTDN_REASON_FLAG_DIRTY_UI* = 0x08000000 + SHTDN_REASON_FLAG_USER_DEFINED* = 0x40000000 + SHTDN_REASON_FLAG_PLANNED* = 0x80000000'i32 + SHTDN_REASON_MAJOR_OTHER* = 0x00000000 + SHTDN_REASON_MAJOR_NONE* = 0x00000000 + SHTDN_REASON_MAJOR_HARDWARE* = 0x00010000 + SHTDN_REASON_MAJOR_OPERATINGSYSTEM* = 0x00020000 + SHTDN_REASON_MAJOR_SOFTWARE* = 0x00030000 + SHTDN_REASON_MAJOR_APPLICATION* = 0x00040000 + SHTDN_REASON_MAJOR_SYSTEM* = 0x00050000 + SHTDN_REASON_MAJOR_POWER* = 0x00060000 + SHTDN_REASON_MAJOR_LEGACY_API* = 0x00070000 + SHTDN_REASON_MINOR_OTHER* = 0x00000000 + SHTDN_REASON_MINOR_NONE* = 0x000000ff + SHTDN_REASON_MINOR_MAINTENANCE* = 0x00000001 + SHTDN_REASON_MINOR_INSTALLATION* = 0x00000002 + SHTDN_REASON_MINOR_UPGRADE* = 0x00000003 + SHTDN_REASON_MINOR_RECONFIG* = 0x00000004 + SHTDN_REASON_MINOR_HUNG* = 0x00000005 + SHTDN_REASON_MINOR_UNSTABLE* = 0x00000006 + SHTDN_REASON_MINOR_DISK* = 0x00000007 + SHTDN_REASON_MINOR_PROCESSOR* = 0x00000008 + SHTDN_REASON_MINOR_NETWORKCARD* = 0x00000009 + SHTDN_REASON_MINOR_POWER_SUPPLY* = 0x0000000a + SHTDN_REASON_MINOR_CORDUNPLUGGED* = 0x0000000b + SHTDN_REASON_MINOR_ENVIRONMENT* = 0x0000000c + SHTDN_REASON_MINOR_HARDWARE_DRIVER* = 0x0000000d + SHTDN_REASON_MINOR_OTHERDRIVER* = 0x0000000e + SHTDN_REASON_MINOR_BLUESCREEN* = 0x0000000F + SHTDN_REASON_MINOR_SERVICEPACK* = 0x00000010 + SHTDN_REASON_MINOR_HOTFIX* = 0x00000011 + SHTDN_REASON_MINOR_SECURITYFIX* = 0x00000012 + SHTDN_REASON_MINOR_SECURITY* = 0x00000013 + SHTDN_REASON_MINOR_NETWORK_CONNECTIVITY* = 0x00000014 + SHTDN_REASON_MINOR_WMI* = 0x00000015 + SHTDN_REASON_MINOR_SERVICEPACK_UNINSTALL* = 0x00000016 + SHTDN_REASON_MINOR_HOTFIX_UNINSTALL* = 0x00000017 + SHTDN_REASON_MINOR_SECURITYFIX_UNINSTALL* = 0x00000018 + SHTDN_REASON_MINOR_MMC* = 0x00000019 + SHTDN_REASON_MINOR_SYSTEMRESTORE* = 0x0000001a + SHTDN_REASON_MINOR_TERMSRV* = 0x00000020 + SHTDN_REASON_MINOR_DC_PROMOTION* = 0x00000021 + SHTDN_REASON_MINOR_DC_DEMOTION* = 0x00000022 + SHTDN_REASON_UNKNOWN* = SHTDN_REASON_MINOR_NONE + SHTDN_REASON_LEGACY_API* = SHTDN_REASON_MAJOR_LEGACY_API or SHTDN_REASON_FLAG_PLANNED + SHTDN_REASON_VALID_BIT_MASK* = 0xc0ffffff'i32 + PCLEANUI* = SHTDN_REASON_FLAG_PLANNED or SHTDN_REASON_FLAG_CLEAN_UI + UCLEANUI* = SHTDN_REASON_FLAG_CLEAN_UI + PDIRTYUI* = SHTDN_REASON_FLAG_PLANNED or SHTDN_REASON_FLAG_DIRTY_UI + UDIRTYUI* = SHTDN_REASON_FLAG_DIRTY_UI + MAX_REASON_NAME_LEN* = 64 + MAX_REASON_DESC_LEN* = 256 + MAX_REASON_BUGID_LEN* = 32 + MAX_REASON_COMMENT_LEN* = 512 + SHUTDOWN_TYPE_LEN* = 32 + POLICY_SHOWREASONUI_NEVER* = 0 + POLICY_SHOWREASONUI_ALWAYS* = 1 + POLICY_SHOWREASONUI_WORKSTATIONONLY* = 2 + POLICY_SHOWREASONUI_SERVERONLY* = 3 + SNAPSHOT_POLICY_NEVER* = 0 + SNAPSHOT_POLICY_ALWAYS* = 1 + SNAPSHOT_POLICY_UNPLANNED* = 2 + MAX_NUM_REASONS* = 256 + REASON_SWINSTALL* = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_INSTALLATION + REASON_HWINSTALL* = SHTDN_REASON_MAJOR_HARDWARE or SHTDN_REASON_MINOR_INSTALLATION + REASON_SERVICEHANG* = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_HUNG + REASON_UNSTABLE* = SHTDN_REASON_MAJOR_SYSTEM or SHTDN_REASON_MINOR_UNSTABLE + REASON_SWHWRECONF* = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_RECONFIG + REASON_OTHER* = SHTDN_REASON_MAJOR_OTHER or SHTDN_REASON_MINOR_OTHER + REASON_UNKNOWN* = SHTDN_REASON_UNKNOWN + REASON_LEGACY_API* = SHTDN_REASON_LEGACY_API + REASON_PLANNED_FLAG* = SHTDN_REASON_FLAG_PLANNED + MAX_SHUTDOWN_TIMEOUT* = 10*365*24*60*60 + SHUTDOWN_FORCE_OTHERS* = 0x00000001 + SHUTDOWN_FORCE_SELF* = 0x00000002 + SHUTDOWN_RESTART* = 0x00000004 + SHUTDOWN_POWEROFF* = 0x00000008 + SHUTDOWN_NOREBOOT* = 0x00000010 + SHUTDOWN_GRACE_OVERRIDE* = 0x00000020 + SHUTDOWN_INSTALL_UPDATES* = 0x00000040 + SHUTDOWN_RESTARTAPPS* = 0x00000080 + SHUTDOWN_HYBRID* = 0x00000200 + HKEY_CLASSES_ROOT* = HKEY 0x80000000'i32 + HKEY_CURRENT_CONFIG* = HKEY 0x80000005'i32 + HKEY_CURRENT_USER* = HKEY 0x80000001'i32 + HKEY_DYN_DATA* = HKEY 0x80000006'i32 + HKEY_LOCAL_MACHINE* = HKEY 0x80000002'i32 + HKEY_PERFORMANCE_DATA* = HKEY 0x80000004'i32 + HKEY_PERFORMANCE_NLSTEXT* = HKEY 0x80000060'i32 + HKEY_PERFORMANCE_TEXT* = HKEY 0x80000050'i32 + HKEY_USERS* = HKEY 0x80000003'i32 +proc RegCloseKey*(hKey: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOverridePredefKey*(hKey: HKEY, hNewHKey: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenUserClassesRoot*(hToken: HANDLE, dwOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenCurrentUser*(samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDisablePredefinedCache*(): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegConnectRegistryA*(lpMachineName: LPCSTR, hKey: HKEY, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegConnectRegistryW*(lpMachineName: LPCWSTR, hKey: HKEY, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegConnectRegistryExA*(lpMachineName: LPCSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegConnectRegistryExW*(lpMachineName: LPCWSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyA*(hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyW*(hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyExA*(hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyExW*(hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyA*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyW*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyExA*(hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyExW*(hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDisableReflectionKey*(hBase: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnableReflectionKey*(hBase: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryReflectionKey*(hBase: HKEY, bIsReflectionDisabled: ptr WINBOOL): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteValueA*(hKey: HKEY, lpValueName: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteValueW*(hKey: HKEY, lpValueName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumKeyA*(hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, cchName: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumKeyW*(hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, cchName: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumKeyExA*(hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumKeyExW*(hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumValueA*(hKey: HKEY, dwIndex: DWORD, lpValueName: LPSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegEnumValueW*(hKey: HKEY, dwIndex: DWORD, lpValueName: LPWSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegFlushKey*(hKey: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegGetKeySecurity*(hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadKeyA*(hKey: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadKeyW*(hKey: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegNotifyChangeKeyValue*(hKey: HKEY, bWatchSubtree: WINBOOL, dwNotifyFilter: DWORD, hEvent: HANDLE, fAsynchronous: WINBOOL): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyA*(hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyW*(hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyExA*(hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyExW*(hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryInfoKeyA*(hKey: HKEY, lpClass: LPSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryInfoKeyW*(hKey: HKEY, lpClass: LPWSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryValueA*(hKey: HKEY, lpSubKey: LPCSTR, lpData: LPSTR, lpcbData: PLONG): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryValueW*(hKey: HKEY, lpSubKey: LPCWSTR, lpData: LPWSTR, lpcbData: PLONG): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryMultipleValuesA*(hKey: HKEY, val_list: PVALENTA, num_vals: DWORD, lpValueBuf: LPSTR, ldwTotsize: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryMultipleValuesW*(hKey: HKEY, val_list: PVALENTW, num_vals: DWORD, lpValueBuf: LPWSTR, ldwTotsize: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryValueExA*(hKey: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegQueryValueExW*(hKey: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegReplaceKeyA*(hKey: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR, lpOldFile: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegReplaceKeyW*(hKey: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR, lpOldFile: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegRestoreKeyA*(hKey: HKEY, lpFile: LPCSTR, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegRestoreKeyW*(hKey: HKEY, lpFile: LPCWSTR, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSaveKeyA*(hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSaveKeyW*(hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetKeySecurity*(hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetValueA*(hKey: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetValueW*(hKey: HKEY, lpSubKey: LPCWSTR, dwType: DWORD, lpData: LPCWSTR, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetValueExA*(hKey: HKEY, lpValueName: LPCSTR, Reserved: DWORD, dwType: DWORD, lpData: ptr BYTE, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetValueExW*(hKey: HKEY, lpValueName: LPCWSTR, Reserved: DWORD, dwType: DWORD, lpData: ptr BYTE, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegUnLoadKeyA*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegUnLoadKeyW*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegGetValueA*(hkey: HKEY, lpSubKey: LPCSTR, lpValue: LPCSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegGetValueW*(hkey: HKEY, lpSubKey: LPCWSTR, lpValue: LPCWSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateSystemShutdownA*(lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateSystemShutdownW*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AbortSystemShutdownA*(lpMachineName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc AbortSystemShutdownW*(lpMachineName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateSystemShutdownExA*(lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL, dwReason: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateSystemShutdownExW*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL, dwReason: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSaveKeyExA*(hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSaveKeyExW*(hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCopyTreeA*(hKeySrc: HKEY, lpSubKey: LPCSTR, hKeyDest: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCopyTreeW*(hKeySrc: HKEY, lpSubKey: LPCWSTR, hKeyDest: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyTransactedA*(hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegCreateKeyTransactedW*(hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyTransactedA*(hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyTransactedW*(hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyValueA*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteKeyValueW*(hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteTreeA*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDeleteTreeW*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegDisablePredefinedCacheEx*(): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadAppKeyA*(lpFile: LPCSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadAppKeyW*(lpFile: LPCWSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadMUIStringA*(hKey: HKEY, pszValue: LPCSTR, pszOutBuf: LPSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegLoadMUIStringW*(hKey: HKEY, pszValue: LPCWSTR, pszOutBuf: LPWSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyTransactedA*(hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegOpenKeyTransactedW*(hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetKeyValueA*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegSetKeyValueW*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateShutdownA*(lpMachineName: LPSTR, lpMessage: LPSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc InitiateShutdownW*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +when winimUnicode: + type + PVALUE* = PVALUEW + PPVALUE* = PPVALUEW + VALENT* = VALENTW + PVALENT* = PVALENTW + proc RegConnectRegistry*(lpMachineName: LPCWSTR, hKey: HKEY, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegConnectRegistryW".} + proc RegConnectRegistryEx*(lpMachineName: LPCWSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegConnectRegistryExW".} + proc RegCreateKey*(hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyW".} + proc RegCreateKeyEx*(hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyExW".} + proc RegDeleteKey*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyW".} + proc RegDeleteKeyEx*(hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyExW".} + proc RegDeleteValue*(hKey: HKEY, lpValueName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteValueW".} + proc RegEnumKey*(hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, cchName: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumKeyW".} + proc RegEnumKeyEx*(hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumKeyExW".} + proc RegEnumValue*(hKey: HKEY, dwIndex: DWORD, lpValueName: LPWSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumValueW".} + proc RegLoadKey*(hKey: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadKeyW".} + proc RegOpenKey*(hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyW".} + proc RegOpenKeyEx*(hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyExW".} + proc RegQueryInfoKey*(hKey: HKEY, lpClass: LPWSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryInfoKeyW".} + proc RegQueryValue*(hKey: HKEY, lpSubKey: LPCWSTR, lpData: LPWSTR, lpcbData: PLONG): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryValueW".} + proc RegQueryMultipleValues*(hKey: HKEY, val_list: PVALENTW, num_vals: DWORD, lpValueBuf: LPWSTR, ldwTotsize: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesW".} + proc RegQueryValueEx*(hKey: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryValueExW".} + proc RegReplaceKey*(hKey: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR, lpOldFile: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegReplaceKeyW".} + proc RegRestoreKey*(hKey: HKEY, lpFile: LPCWSTR, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegRestoreKeyW".} + proc RegSaveKey*(hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSaveKeyW".} + proc RegSetValue*(hKey: HKEY, lpSubKey: LPCWSTR, dwType: DWORD, lpData: LPCWSTR, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetValueW".} + proc RegSetValueEx*(hKey: HKEY, lpValueName: LPCWSTR, Reserved: DWORD, dwType: DWORD, lpData: ptr BYTE, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetValueExW".} + proc RegUnLoadKey*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegUnLoadKeyW".} + proc RegGetValue*(hkey: HKEY, lpSubKey: LPCWSTR, lpValue: LPCWSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegGetValueW".} + proc InitiateSystemShutdown*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateSystemShutdownW".} + proc AbortSystemShutdown*(lpMachineName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AbortSystemShutdownW".} + proc InitiateSystemShutdownEx*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL, dwReason: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateSystemShutdownExW".} + proc RegSaveKeyEx*(hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSaveKeyExW".} + proc RegCopyTree*(hKeySrc: HKEY, lpSubKey: LPCWSTR, hKeyDest: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCopyTreeW".} + proc RegCreateKeyTransacted*(hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyTransactedW".} + proc RegDeleteKeyTransacted*(hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyTransactedW".} + proc RegDeleteKeyValue*(hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyValueW".} + proc RegDeleteTree*(hKey: HKEY, lpSubKey: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteTreeW".} + proc RegLoadAppKey*(lpFile: LPCWSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadAppKeyW".} + proc RegLoadMUIString*(hKey: HKEY, pszValue: LPCWSTR, pszOutBuf: LPWSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCWSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadMUIStringW".} + proc RegOpenKeyTransacted*(hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyTransactedW".} + proc RegSetKeyValue*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetKeyValueW".} + proc InitiateShutdown*(lpMachineName: LPWSTR, lpMessage: LPWSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateShutdownW".} +when winimAnsi: + type + PVALUE* = PVALUEA + PPVALUE* = PPVALUEA + VALENT* = VALENTA + PVALENT* = PVALENTA + proc RegConnectRegistry*(lpMachineName: LPCSTR, hKey: HKEY, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegConnectRegistryA".} + proc RegConnectRegistryEx*(lpMachineName: LPCSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegConnectRegistryExA".} + proc RegCreateKey*(hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyA".} + proc RegCreateKeyEx*(hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyExA".} + proc RegDeleteKey*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyA".} + proc RegDeleteKeyEx*(hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyExA".} + proc RegDeleteValue*(hKey: HKEY, lpValueName: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteValueA".} + proc RegEnumKey*(hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, cchName: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumKeyA".} + proc RegEnumKeyEx*(hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumKeyExA".} + proc RegEnumValue*(hKey: HKEY, dwIndex: DWORD, lpValueName: LPSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegEnumValueA".} + proc RegLoadKey*(hKey: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadKeyA".} + proc RegOpenKey*(hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyA".} + proc RegOpenKeyEx*(hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyExA".} + proc RegQueryInfoKey*(hKey: HKEY, lpClass: LPSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryInfoKeyA".} + proc RegQueryValue*(hKey: HKEY, lpSubKey: LPCSTR, lpData: LPSTR, lpcbData: PLONG): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryValueA".} + proc RegQueryMultipleValues*(hKey: HKEY, val_list: PVALENTA, num_vals: DWORD, lpValueBuf: LPSTR, ldwTotsize: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesA".} + proc RegQueryValueEx*(hKey: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegQueryValueExA".} + proc RegReplaceKey*(hKey: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR, lpOldFile: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegReplaceKeyA".} + proc RegRestoreKey*(hKey: HKEY, lpFile: LPCSTR, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegRestoreKeyA".} + proc RegSaveKey*(hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSaveKeyA".} + proc RegSetValue*(hKey: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetValueA".} + proc RegSetValueEx*(hKey: HKEY, lpValueName: LPCSTR, Reserved: DWORD, dwType: DWORD, lpData: ptr BYTE, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetValueExA".} + proc RegUnLoadKey*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegUnLoadKeyA".} + proc RegGetValue*(hkey: HKEY, lpSubKey: LPCSTR, lpValue: LPCSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegGetValueA".} + proc InitiateSystemShutdown*(lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateSystemShutdownA".} + proc AbortSystemShutdown*(lpMachineName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "AbortSystemShutdownA".} + proc InitiateSystemShutdownEx*(lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: WINBOOL, bRebootAfterShutdown: WINBOOL, dwReason: DWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateSystemShutdownExA".} + proc RegSaveKeyEx*(hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSaveKeyExA".} + proc RegCopyTree*(hKeySrc: HKEY, lpSubKey: LPCSTR, hKeyDest: HKEY): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCopyTreeA".} + proc RegCreateKeyTransacted*(hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegCreateKeyTransactedA".} + proc RegDeleteKeyTransacted*(hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyTransactedA".} + proc RegDeleteKeyValue*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteKeyValueA".} + proc RegDeleteTree*(hKey: HKEY, lpSubKey: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegDeleteTreeA".} + proc RegLoadAppKey*(lpFile: LPCSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadAppKeyA".} + proc RegLoadMUIString*(hKey: HKEY, pszValue: LPCSTR, pszOutBuf: LPSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCSTR): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegLoadMUIStringA".} + proc RegOpenKeyTransacted*(hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParameter: PVOID): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegOpenKeyTransactedA".} + proc RegSetKeyValue*(hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD): LONG {.winapi, stdcall, dynlib: "advapi32", importc: "RegSetKeyValueA".} + proc InitiateShutdown*(lpMachineName: LPSTR, lpMessage: LPSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "InitiateShutdownA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winscard.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winscard.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,514 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import rpc +import winioctl +#include +#include +#include +type + LPCBYTE* = ptr BYTE + SCARDCONTEXT* = ULONG_PTR + SCARDHANDLE* = ULONG_PTR + SCARD_IO_REQUEST* {.pure.} = object + dwProtocol*: DWORD + cbPciLength*: DWORD + PSCARD_IO_REQUEST* = ptr SCARD_IO_REQUEST + LPSCARD_IO_REQUEST* = ptr SCARD_IO_REQUEST + LPCSCARD_IO_REQUEST* = ptr SCARD_IO_REQUEST + SCARD_T0_COMMAND* {.pure.} = object + bCla*: BYTE + bIns*: BYTE + bP1*: BYTE + bP2*: BYTE + bP3*: BYTE + LPSCARD_T0_COMMAND* = ptr SCARD_T0_COMMAND + SCARD_T0_REQUEST_UNION1* {.pure, union.} = object + CmdBytes*: SCARD_T0_COMMAND + rgbHeader*: array[5, BYTE] + SCARD_T0_REQUEST* {.pure.} = object + ioRequest*: SCARD_IO_REQUEST + bSw1*: BYTE + bSw2*: BYTE + union1*: SCARD_T0_REQUEST_UNION1 + PSCARD_T0_REQUEST* = ptr SCARD_T0_REQUEST + LPSCARD_T0_REQUEST* = ptr SCARD_T0_REQUEST + SCARD_T1_REQUEST* {.pure.} = object + ioRequest*: SCARD_IO_REQUEST + PSCARD_T1_REQUEST* = ptr SCARD_T1_REQUEST + LPSCARD_T1_REQUEST* = ptr SCARD_T1_REQUEST + PSCARDCONTEXT* = ptr SCARDCONTEXT + LPSCARDCONTEXT* = ptr SCARDCONTEXT + PSCARDHANDLE* = ptr SCARDHANDLE + LPSCARDHANDLE* = ptr SCARDHANDLE + SCARD_READERSTATEA* {.pure.} = object + szReader*: LPCSTR + pvUserData*: LPVOID + dwCurrentState*: DWORD + dwEventState*: DWORD + cbAtr*: DWORD + rgbAtr*: array[36, BYTE] + PSCARD_READERSTATEA* = ptr SCARD_READERSTATEA + LPSCARD_READERSTATEA* = ptr SCARD_READERSTATEA + SCARD_READERSTATEW* {.pure.} = object + szReader*: LPCWSTR + pvUserData*: LPVOID + dwCurrentState*: DWORD + dwEventState*: DWORD + cbAtr*: DWORD + rgbAtr*: array[36, BYTE] + PSCARD_READERSTATEW* = ptr SCARD_READERSTATEW + LPSCARD_READERSTATEW* = ptr SCARD_READERSTATEW + SCARD_ATRMASK* {.pure.} = object + cbAtr*: DWORD + rgbAtr*: array[36, BYTE] + rgbMask*: array[36, BYTE] + PSCARD_ATRMASK* = ptr SCARD_ATRMASK + LPSCARD_ATRMASK* = ptr SCARD_ATRMASK + LPOCNCHKPROC* = proc (P1: SCARDCONTEXT, P2: SCARDHANDLE, P3: PVOID): WINBOOL {.stdcall.} + LPOCNCONNPROCA* = proc (P1: SCARDCONTEXT, P2: LPSTR, P3: LPSTR, P4: PVOID): SCARDHANDLE {.stdcall.} + LPOCNDSCPROC* = proc (P1: SCARDCONTEXT, P2: SCARDHANDLE, P3: PVOID): void {.stdcall.} + OPENCARD_SEARCH_CRITERIAA* {.pure.} = object + dwStructSize*: DWORD + lpstrGroupNames*: LPSTR + nMaxGroupNames*: DWORD + rgguidInterfaces*: LPCGUID + cguidInterfaces*: DWORD + lpstrCardNames*: LPSTR + nMaxCardNames*: DWORD + lpfnCheck*: LPOCNCHKPROC + lpfnConnect*: LPOCNCONNPROCA + lpfnDisconnect*: LPOCNDSCPROC + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + POPENCARD_SEARCH_CRITERIAA* = ptr OPENCARD_SEARCH_CRITERIAA + LPOPENCARD_SEARCH_CRITERIAA* = ptr OPENCARD_SEARCH_CRITERIAA + LPOCNCONNPROCW* = proc (P1: SCARDCONTEXT, P2: LPWSTR, P3: LPWSTR, P4: PVOID): SCARDHANDLE {.stdcall.} + OPENCARD_SEARCH_CRITERIAW* {.pure.} = object + dwStructSize*: DWORD + lpstrGroupNames*: LPWSTR + nMaxGroupNames*: DWORD + rgguidInterfaces*: LPCGUID + cguidInterfaces*: DWORD + lpstrCardNames*: LPWSTR + nMaxCardNames*: DWORD + lpfnCheck*: LPOCNCHKPROC + lpfnConnect*: LPOCNCONNPROCW + lpfnDisconnect*: LPOCNDSCPROC + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + POPENCARD_SEARCH_CRITERIAW* = ptr OPENCARD_SEARCH_CRITERIAW + LPOPENCARD_SEARCH_CRITERIAW* = ptr OPENCARD_SEARCH_CRITERIAW + OPENCARDNAME_EXA* {.pure.} = object + dwStructSize*: DWORD + hSCardContext*: SCARDCONTEXT + hwndOwner*: HWND + dwFlags*: DWORD + lpstrTitle*: LPCSTR + lpstrSearchDesc*: LPCSTR + hIcon*: HICON + pOpenCardSearchCriteria*: POPENCARD_SEARCH_CRITERIAA + lpfnConnect*: LPOCNCONNPROCA + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + lpstrRdr*: LPSTR + nMaxRdr*: DWORD + lpstrCard*: LPSTR + nMaxCard*: DWORD + dwActiveProtocol*: DWORD + hCardHandle*: SCARDHANDLE + POPENCARDNAME_EXA* = ptr OPENCARDNAME_EXA + LPOPENCARDNAME_EXA* = ptr OPENCARDNAME_EXA + OPENCARDNAME_EXW* {.pure.} = object + dwStructSize*: DWORD + hSCardContext*: SCARDCONTEXT + hwndOwner*: HWND + dwFlags*: DWORD + lpstrTitle*: LPCWSTR + lpstrSearchDesc*: LPCWSTR + hIcon*: HICON + pOpenCardSearchCriteria*: POPENCARD_SEARCH_CRITERIAW + lpfnConnect*: LPOCNCONNPROCW + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + lpstrRdr*: LPWSTR + nMaxRdr*: DWORD + lpstrCard*: LPWSTR + nMaxCard*: DWORD + dwActiveProtocol*: DWORD + hCardHandle*: SCARDHANDLE + POPENCARDNAME_EXW* = ptr OPENCARDNAME_EXW + LPOPENCARDNAME_EXW* = ptr OPENCARDNAME_EXW + OPENCARDNAMEA_EX* = OPENCARDNAME_EXA + OPENCARDNAMEW_EX* = OPENCARDNAME_EXW + POPENCARDNAMEA_EX* = POPENCARDNAME_EXA + POPENCARDNAMEW_EX* = POPENCARDNAME_EXW + LPOPENCARDNAMEA_EX* = LPOPENCARDNAME_EXA + LPOPENCARDNAMEW_EX* = LPOPENCARDNAME_EXW + OPENCARDNAMEA* {.pure.} = object + dwStructSize*: DWORD + hwndOwner*: HWND + hSCardContext*: SCARDCONTEXT + lpstrGroupNames*: LPSTR + nMaxGroupNames*: DWORD + lpstrCardNames*: LPSTR + nMaxCardNames*: DWORD + rgguidInterfaces*: LPCGUID + cguidInterfaces*: DWORD + lpstrRdr*: LPSTR + nMaxRdr*: DWORD + lpstrCard*: LPSTR + nMaxCard*: DWORD + lpstrTitle*: LPCSTR + dwFlags*: DWORD + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + dwActiveProtocol*: DWORD + lpfnConnect*: LPOCNCONNPROCA + lpfnCheck*: LPOCNCHKPROC + lpfnDisconnect*: LPOCNDSCPROC + hCardHandle*: SCARDHANDLE + POPENCARDNAMEA* = ptr OPENCARDNAMEA + LPOPENCARDNAMEA* = ptr OPENCARDNAMEA + OPENCARDNAMEW* {.pure.} = object + dwStructSize*: DWORD + hwndOwner*: HWND + hSCardContext*: SCARDCONTEXT + lpstrGroupNames*: LPWSTR + nMaxGroupNames*: DWORD + lpstrCardNames*: LPWSTR + nMaxCardNames*: DWORD + rgguidInterfaces*: LPCGUID + cguidInterfaces*: DWORD + lpstrRdr*: LPWSTR + nMaxRdr*: DWORD + lpstrCard*: LPWSTR + nMaxCard*: DWORD + lpstrTitle*: LPCWSTR + dwFlags*: DWORD + pvUserData*: LPVOID + dwShareMode*: DWORD + dwPreferredProtocols*: DWORD + dwActiveProtocol*: DWORD + lpfnConnect*: LPOCNCONNPROCW + lpfnCheck*: LPOCNCHKPROC + lpfnDisconnect*: LPOCNDSCPROC + hCardHandle*: SCARDHANDLE + POPENCARDNAMEW* = ptr OPENCARDNAMEW + LPOPENCARDNAMEW* = ptr OPENCARDNAMEW +const + SCARD_ATR_LENGTH* = 33 + SCARD_PROTOCOL_UNDEFINED* = 0x00000000 + SCARD_PROTOCOL_T0* = 0x00000001 + SCARD_PROTOCOL_T1* = 0x00000002 + SCARD_PROTOCOL_RAW* = 0x00010000 + SCARD_PROTOCOL_Tx* = SCARD_PROTOCOL_T0 or SCARD_PROTOCOL_T1 + SCARD_PROTOCOL_DEFAULT* = 0x80000000'i32 + SCARD_PROTOCOL_OPTIMAL* = 0x00000000 + SCARD_POWER_DOWN* = 0 + SCARD_COLD_RESET* = 1 + SCARD_WARM_RESET* = 2 +template SCARD_CTL_CODE*(code: untyped): untyped = CTL_CODE(FILE_DEVICE_SMARTCARD, code, METHOD_BUFFERED, FILE_ANY_ACCESS) +const + IOCTL_SMARTCARD_POWER* = SCARD_CTL_CODE(1) + IOCTL_SMARTCARD_GET_ATTRIBUTE* = SCARD_CTL_CODE(2) + IOCTL_SMARTCARD_SET_ATTRIBUTE* = SCARD_CTL_CODE(3) + IOCTL_SMARTCARD_CONFISCATE* = SCARD_CTL_CODE(4) + IOCTL_SMARTCARD_TRANSMIT* = SCARD_CTL_CODE(5) + IOCTL_SMARTCARD_EJECT* = SCARD_CTL_CODE(6) + IOCTL_SMARTCARD_SWALLOW* = SCARD_CTL_CODE(7) + IOCTL_SMARTCARD_IS_PRESENT* = SCARD_CTL_CODE(10) + IOCTL_SMARTCARD_IS_ABSENT* = SCARD_CTL_CODE(11) + IOCTL_SMARTCARD_SET_PROTOCOL* = SCARD_CTL_CODE(12) + IOCTL_SMARTCARD_GET_STATE* = SCARD_CTL_CODE(14) + IOCTL_SMARTCARD_GET_LAST_ERROR* = SCARD_CTL_CODE(15) + IOCTL_SMARTCARD_GET_PERF_CNTR* = SCARD_CTL_CODE(16) + MAXIMUM_ATTR_STRING_LENGTH* = 32 + MAXIMUM_SMARTCARD_READERS* = 10 + SCARD_CLASS_VENDOR_INFO* = 1 + SCARD_CLASS_COMMUNICATIONS* = 2 + SCARD_CLASS_PROTOCOL* = 3 + SCARD_CLASS_POWER_MGMT* = 4 + SCARD_CLASS_SECURITY* = 5 + SCARD_CLASS_MECHANICAL* = 6 + SCARD_CLASS_VENDOR_DEFINED* = 7 + SCARD_CLASS_IFD_PROTOCOL* = 8 + SCARD_CLASS_ICC_STATE* = 9 + SCARD_CLASS_PERF* = 0x7ffe + SCARD_CLASS_SYSTEM* = 0x7fff +template SCARD_ATTR_VALUE*(class: untyped, tag: untyped): untyped = (class shl 16) or tag +const + SCARD_ATTR_VENDOR_NAME* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO,0x0100) + SCARD_ATTR_VENDOR_IFD_TYPE* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO,0x0101) + SCARD_ATTR_VENDOR_IFD_VERSION* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO,0x0102) + SCARD_ATTR_VENDOR_IFD_SERIAL_NO* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO,0x0103) + SCARD_ATTR_CHANNEL_ID* = SCARD_ATTR_VALUE(SCARD_CLASS_COMMUNICATIONS,0x0110) + SCARD_ATTR_PROTOCOL_TYPES* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0120) + SCARD_ATTR_DEFAULT_CLK* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0121) + SCARD_ATTR_MAX_CLK* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0122) + SCARD_ATTR_DEFAULT_DATA_RATE* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0123) + SCARD_ATTR_MAX_DATA_RATE* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0124) + SCARD_ATTR_MAX_IFSD* = SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL,0x0125) + SCARD_ATTR_POWER_MGMT_SUPPORT* = SCARD_ATTR_VALUE(SCARD_CLASS_POWER_MGMT,0x0131) + SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE* = SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY,0x0140) + SCARD_ATTR_USER_AUTH_INPUT_DEVICE* = SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY,0x0142) + SCARD_ATTR_CHARACTERISTICS* = SCARD_ATTR_VALUE(SCARD_CLASS_MECHANICAL,0x0150) + SCARD_ATTR_CURRENT_PROTOCOL_TYPE* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0201) + SCARD_ATTR_CURRENT_CLK* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0202) + SCARD_ATTR_CURRENT_F* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0203) + SCARD_ATTR_CURRENT_D* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0204) + SCARD_ATTR_CURRENT_N* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0205) + SCARD_ATTR_CURRENT_W* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0206) + SCARD_ATTR_CURRENT_IFSC* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0207) + SCARD_ATTR_CURRENT_IFSD* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0208) + SCARD_ATTR_CURRENT_BWT* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x0209) + SCARD_ATTR_CURRENT_CWT* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x020a) + SCARD_ATTR_CURRENT_EBC_ENCODING* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x020b) + SCARD_ATTR_EXTENDED_BWT* = SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL,0x020c) + SCARD_ATTR_ICC_PRESENCE* = SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE,0x0300) + SCARD_ATTR_ICC_INTERFACE_STATUS* = SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE,0x0301) + SCARD_ATTR_CURRENT_IO_STATE* = SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE,0x0302) + SCARD_ATTR_ATR_STRING* = SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE,0x0303) + SCARD_ATTR_ICC_TYPE_PER_ATR* = SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE,0x0304) + SCARD_ATTR_ESC_RESET* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED,0xA000) + SCARD_ATTR_ESC_CANCEL* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED,0xA003) + SCARD_ATTR_ESC_AUTHREQUEST* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED,0xA005) + SCARD_ATTR_MAXINPUT* = SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED,0xA007) + SCARD_ATTR_DEVICE_UNIT* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0001) + SCARD_ATTR_DEVICE_IN_USE* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0002) + SCARD_ATTR_DEVICE_FRIENDLY_NAME_A* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0003) + SCARD_ATTR_DEVICE_SYSTEM_NAME_A* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0004) + SCARD_ATTR_DEVICE_FRIENDLY_NAME_W* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0005) + SCARD_ATTR_DEVICE_SYSTEM_NAME_W* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0006) + SCARD_ATTR_SUPRESS_T1_IFS_REQUEST* = SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM,0x0007) + SCARD_PERF_NUM_TRANSMISSIONS* = SCARD_ATTR_VALUE(SCARD_CLASS_PERF,0x0001) + SCARD_PERF_BYTES_TRANSMITTED* = SCARD_ATTR_VALUE(SCARD_CLASS_PERF,0x0002) + SCARD_PERF_TRANSMISSION_TIME* = SCARD_ATTR_VALUE(SCARD_CLASS_PERF,0x0003) + SCARD_T0_HEADER_LENGTH* = 7 + SCARD_T0_CMD_LENGTH* = 5 + SCARD_T1_PROLOGUE_LENGTH* = 3 + SCARD_T1_EPILOGUE_LENGTH* = 2 + SCARD_T1_MAX_IFS* = 254 + SCARD_UNKNOWN* = 0 + SCARD_ABSENT* = 1 + SCARD_PRESENT* = 2 + SCARD_SWALLOWED* = 3 + SCARD_POWERED* = 4 + SCARD_NEGOTIABLE* = 5 + SCARD_SPECIFIC* = 6 + SCARD_READER_SWALLOWS* = 0x00000001 + SCARD_READER_EJECTS* = 0x00000002 + SCARD_READER_CONFISCATES* = 0x00000004 + SCARD_READER_TYPE_SERIAL* = 0x01 + SCARD_READER_TYPE_PARALELL* = 0x02 + SCARD_READER_TYPE_KEYBOARD* = 0x04 + SCARD_READER_TYPE_SCSI* = 0x08 + SCARD_READER_TYPE_IDE* = 0x10 + SCARD_READER_TYPE_USB* = 0x20 + SCARD_READER_TYPE_PCMCIA* = 0x40 + SCARD_READER_TYPE_VENDOR* = 0xF0 + FACILITY_SYSTEM* = 0x0 + SCARD_SCOPE_USER* = 0 + SCARD_SCOPE_TERMINAL* = 1 + SCARD_SCOPE_SYSTEM* = 2 + SCARD_ALL_READERS* = "SCard$AllReaders\0" + SCARD_DEFAULT_READERS* = "SCard$DefaultReaders\0" + SCARD_LOCAL_READERS* = "SCard$LocalReaders\0" + SCARD_SYSTEM_READERS* = "SCard$SystemReaders\0" + SCARD_PROVIDER_PRIMARY* = 1 + SCARD_PROVIDER_CSP* = 2 + SCARD_STATE_UNAWARE* = 0x00000000 + SCARD_STATE_IGNORE* = 0x00000001 + SCARD_STATE_CHANGED* = 0x00000002 + SCARD_STATE_UNKNOWN* = 0x00000004 + SCARD_STATE_UNAVAILABLE* = 0x00000008 + SCARD_STATE_EMPTY* = 0x00000010 + SCARD_STATE_PRESENT* = 0x00000020 + SCARD_STATE_ATRMATCH* = 0x00000040 + SCARD_STATE_EXCLUSIVE* = 0x00000080 + SCARD_STATE_INUSE* = 0x00000100 + SCARD_STATE_MUTE* = 0x00000200 + SCARD_STATE_UNPOWERED* = 0x00000400 + SCARD_SHARE_EXCLUSIVE* = 1 + SCARD_SHARE_SHARED* = 2 + SCARD_SHARE_DIRECT* = 3 + SCARD_LEAVE_CARD* = 0 + SCARD_RESET_CARD* = 1 + SCARD_UNPOWER_CARD* = 2 + SCARD_EJECT_CARD* = 3 + SC_DLG_MINIMAL_UI* = 0x01 + SC_DLG_NO_UI* = 0x02 + SC_DLG_FORCE_UI* = 0x04 + SCERR_NOCARDNAME* = 0x4000 + SCERR_NOGUIDS* = 0x8000 + SCARD_AUTOALLOCATE* = DWORD(-1) +proc SCardEstablishContext*(dwScope: DWORD, pvReserved1: LPCVOID, pvReserved2: LPCVOID, phContext: LPSCARDCONTEXT): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardReleaseContext*(hContext: SCARDCONTEXT): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIsValidContext*(hContext: SCARDCONTEXT): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListReaderGroupsA*(hContext: SCARDCONTEXT, mszGroups: LPSTR, pcchGroups: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListReaderGroupsW*(hContext: SCARDCONTEXT, mszGroups: LPWSTR, pcchGroups: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListReadersA*(hContext: SCARDCONTEXT, mszGroups: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListReadersW*(hContext: SCARDCONTEXT, mszGroups: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListCardsA*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListCardsW*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPWSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListInterfacesA*(hContext: SCARDCONTEXT, szCard: LPCSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardListInterfacesW*(hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetProviderIdA*(hContext: SCARDCONTEXT, szCard: LPCSTR, pguidProviderId: LPGUID): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetProviderIdW*(hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidProviderId: LPGUID): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetCardTypeProviderNameA*(hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPSTR, pcchProvider: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetCardTypeProviderNameW*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPWSTR, pcchProvider: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceReaderGroupA*(hContext: SCARDCONTEXT, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceReaderGroupW*(hContext: SCARDCONTEXT, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetReaderGroupA*(hContext: SCARDCONTEXT, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetReaderGroupW*(hContext: SCARDCONTEXT, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceReaderA*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceReaderW*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetReaderA*(hContext: SCARDCONTEXT, szReaderName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetReaderW*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardAddReaderToGroupA*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardAddReaderToGroupW*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardRemoveReaderFromGroupA*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardRemoveReaderFromGroupW*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceCardTypeA*(hContext: SCARDCONTEXT, szCardName: LPCSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardIntroduceCardTypeW*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardSetCardTypeProviderNameA*(hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardSetCardTypeProviderNameW*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetCardTypeA*(hContext: SCARDCONTEXT, szCardName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardForgetCardTypeW*(hContext: SCARDCONTEXT, szCardName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardFreeMemory*(hContext: SCARDCONTEXT, pvMem: LPCVOID): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardAccessStartedEvent*(): HANDLE {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardReleaseStartedEvent*(): void {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardLocateCardsA*(hContext: SCARDCONTEXT, mszCards: LPCSTR, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardLocateCardsW*(hContext: SCARDCONTEXT, mszCards: LPCWSTR, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardLocateCardsByATRA*(hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardLocateCardsByATRW*(hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetStatusChangeA*(hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetStatusChangeW*(hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardCancel*(hContext: SCARDCONTEXT): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardConnectA*(hContext: SCARDCONTEXT, szReader: LPCSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardConnectW*(hContext: SCARDCONTEXT, szReader: LPCWSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardReconnect*(hCard: SCARDHANDLE, dwShareMode: DWORD, dwPreferredProtocols: DWORD, dwInitialization: DWORD, pdwActiveProtocol: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardDisconnect*(hCard: SCARDHANDLE, dwDisposition: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardBeginTransaction*(hCard: SCARDHANDLE): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardEndTransaction*(hCard: SCARDHANDLE, dwDisposition: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardState*(hCard: SCARDHANDLE, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardStatusA*(hCard: SCARDHANDLE, szReaderName: LPSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardStatusW*(hCard: SCARDHANDLE, szReaderName: LPWSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardTransmit*(hCard: SCARDHANDLE, pioSendPci: LPCSCARD_IO_REQUEST, pbSendBuffer: LPCBYTE, cbSendLength: DWORD, pioRecvPci: LPSCARD_IO_REQUEST, pbRecvBuffer: LPBYTE, pcbRecvLength: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardControl*(hCard: SCARDHANDLE, dwControlCode: DWORD, lpInBuffer: LPCVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetAttrib*(hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPBYTE, pcbAttrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardGetReaderCapabilities*(hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPBYTE, pcbAttrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetAttrib".} +proc SCardSetAttrib*(hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPCBYTE, cbAttrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardSetReaderCapabilities*(hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPCBYTE, cbAttrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardSetAttrib".} +proc SCardUIDlgSelectCardA*(P1: LPOPENCARDNAMEA_EX): LONG {.winapi, stdcall, dynlib: "scarddlg", importc.} +proc SCardUIDlgSelectCardW*(P1: LPOPENCARDNAMEW_EX): LONG {.winapi, stdcall, dynlib: "scarddlg", importc.} +proc GetOpenCardNameA*(P1: LPOPENCARDNAMEA): LONG {.winapi, stdcall, dynlib: "scarddlg", importc.} +proc GetOpenCardNameW*(P1: LPOPENCARDNAMEW): LONG {.winapi, stdcall, dynlib: "scarddlg", importc.} +proc SCardDlgExtendedError*(): LONG {.winapi, stdcall, dynlib: "scarddlg", importc.} +proc SCardGetTransmitCount*(hCard: SCARDHANDLE, pcTransmitCount: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardReadCacheA*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: ptr DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardReadCacheW*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: ptr DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardWriteCacheA*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc SCardWriteCacheW*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc.} +proc `CmdBytes=`*(self: var SCARD_T0_REQUEST, x: SCARD_T0_COMMAND) {.inline.} = self.union1.CmdBytes = x +proc CmdBytes*(self: SCARD_T0_REQUEST): SCARD_T0_COMMAND {.inline.} = self.union1.CmdBytes +proc CmdBytes*(self: var SCARD_T0_REQUEST): var SCARD_T0_COMMAND {.inline.} = self.union1.CmdBytes +proc `rgbHeader=`*(self: var SCARD_T0_REQUEST, x: array[5, BYTE]) {.inline.} = self.union1.rgbHeader = x +proc rgbHeader*(self: SCARD_T0_REQUEST): array[5, BYTE] {.inline.} = self.union1.rgbHeader +proc rgbHeader*(self: var SCARD_T0_REQUEST): var array[5, BYTE] {.inline.} = self.union1.rgbHeader +when winimUnicode: + type + SCARD_READERSTATE* = SCARD_READERSTATEW + PSCARD_READERSTATE* = PSCARD_READERSTATEW + LPSCARD_READERSTATE* = LPSCARD_READERSTATEW + LPOCNCONNPROC* = LPOCNCONNPROCW + OPENCARD_SEARCH_CRITERIA* = OPENCARD_SEARCH_CRITERIAW + POPENCARD_SEARCH_CRITERIA* = POPENCARD_SEARCH_CRITERIAW + LPOPENCARD_SEARCH_CRITERIA* = LPOPENCARD_SEARCH_CRITERIAW + OPENCARDNAME_EX* = OPENCARDNAME_EXW + POPENCARDNAME_EX* = POPENCARDNAME_EXW + LPOPENCARDNAME_EX* = LPOPENCARDNAME_EXW + OPENCARDNAME* = OPENCARDNAMEW + POPENCARDNAME* = POPENCARDNAMEW + LPOPENCARDNAME* = LPOPENCARDNAMEW + const + SCARD_ATTR_DEVICE_FRIENDLY_NAME* = SCARD_ATTR_DEVICE_FRIENDLY_NAME_W + SCARD_ATTR_DEVICE_SYSTEM_NAME* = SCARD_ATTR_DEVICE_SYSTEM_NAME_W + proc SCardListReaderGroups*(hContext: SCARDCONTEXT, mszGroups: LPWSTR, pcchGroups: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListReaderGroupsW".} + proc SCardListReaders*(hContext: SCARDCONTEXT, mszGroups: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListReadersW".} + proc SCardListCards*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPWSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListCardsW".} + proc SCardListInterfaces*(hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListInterfacesW".} + proc SCardGetProviderId*(hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidProviderId: LPGUID): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetProviderIdW".} + proc SCardGetCardTypeProviderName*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPWSTR, pcchProvider: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetCardTypeProviderNameW".} + proc SCardIntroduceReaderGroup*(hContext: SCARDCONTEXT, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceReaderGroupW".} + proc SCardForgetReaderGroup*(hContext: SCARDCONTEXT, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetReaderGroupW".} + proc SCardIntroduceReader*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceReaderW".} + proc SCardForgetReader*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetReaderW".} + proc SCardAddReaderToGroup*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardAddReaderToGroupW".} + proc SCardRemoveReaderFromGroup*(hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardRemoveReaderFromGroupW".} + proc SCardIntroduceCardType*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceCardTypeW".} + proc SCardSetCardTypeProviderName*(hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardSetCardTypeProviderNameW".} + proc SCardForgetCardType*(hContext: SCARDCONTEXT, szCardName: LPCWSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetCardTypeW".} + proc SCardListCardTypes*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPWSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListCardsW".} + proc SCardLocateCards*(hContext: SCARDCONTEXT, mszCards: LPCWSTR, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardLocateCardsW".} + proc SCardLocateCardsByATR*(hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardLocateCardsByATRW".} + proc SCardGetStatusChange*(hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetStatusChangeW".} + proc SCardConnect*(hContext: SCARDCONTEXT, szReader: LPCWSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardConnectW".} + proc SCardStatus*(hCard: SCARDHANDLE, szReaderName: LPWSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardStatusW".} + proc SCardUIDlgSelectCard*(P1: LPOPENCARDNAMEW_EX): LONG {.winapi, stdcall, dynlib: "scarddlg", importc: "SCardUIDlgSelectCardW".} + proc GetOpenCardName*(P1: LPOPENCARDNAMEW): LONG {.winapi, stdcall, dynlib: "scarddlg", importc: "GetOpenCardNameW".} + proc SCardReadCache*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: ptr DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardReadCacheW".} + proc SCardWriteCache*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardWriteCacheW".} +when winimAnsi: + type + SCARD_READERSTATE* = SCARD_READERSTATEA + PSCARD_READERSTATE* = PSCARD_READERSTATEA + LPSCARD_READERSTATE* = LPSCARD_READERSTATEA + LPOCNCONNPROC* = LPOCNCONNPROCA + OPENCARD_SEARCH_CRITERIA* = OPENCARD_SEARCH_CRITERIAA + POPENCARD_SEARCH_CRITERIA* = POPENCARD_SEARCH_CRITERIAA + LPOPENCARD_SEARCH_CRITERIA* = LPOPENCARD_SEARCH_CRITERIAA + OPENCARDNAME_EX* = OPENCARDNAME_EXA + POPENCARDNAME_EX* = POPENCARDNAME_EXA + LPOPENCARDNAME_EX* = LPOPENCARDNAME_EXA + OPENCARDNAME* = OPENCARDNAMEA + POPENCARDNAME* = POPENCARDNAMEA + LPOPENCARDNAME* = LPOPENCARDNAMEA + const + SCARD_ATTR_DEVICE_FRIENDLY_NAME* = SCARD_ATTR_DEVICE_FRIENDLY_NAME_A + SCARD_ATTR_DEVICE_SYSTEM_NAME* = SCARD_ATTR_DEVICE_SYSTEM_NAME_A + proc SCardListReaderGroups*(hContext: SCARDCONTEXT, mszGroups: LPSTR, pcchGroups: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListReaderGroupsA".} + proc SCardListReaders*(hContext: SCARDCONTEXT, mszGroups: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListReadersA".} + proc SCardListCards*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListCardsA".} + proc SCardListInterfaces*(hContext: SCARDCONTEXT, szCard: LPCSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListInterfacesA".} + proc SCardGetProviderId*(hContext: SCARDCONTEXT, szCard: LPCSTR, pguidProviderId: LPGUID): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetProviderIdA".} + proc SCardGetCardTypeProviderName*(hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPSTR, pcchProvider: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetCardTypeProviderNameA".} + proc SCardIntroduceReaderGroup*(hContext: SCARDCONTEXT, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceReaderGroupA".} + proc SCardForgetReaderGroup*(hContext: SCARDCONTEXT, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetReaderGroupA".} + proc SCardIntroduceReader*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceReaderA".} + proc SCardForgetReader*(hContext: SCARDCONTEXT, szReaderName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetReaderA".} + proc SCardAddReaderToGroup*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardAddReaderToGroupA".} + proc SCardRemoveReaderFromGroup*(hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardRemoveReaderFromGroupA".} + proc SCardIntroduceCardType*(hContext: SCARDCONTEXT, szCardName: LPCSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardIntroduceCardTypeA".} + proc SCardSetCardTypeProviderName*(hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardSetCardTypeProviderNameA".} + proc SCardForgetCardType*(hContext: SCARDCONTEXT, szCardName: LPCSTR): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardForgetCardTypeA".} + proc SCardListCardTypes*(hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPSTR, pcchCards: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardListCardsA".} + proc SCardLocateCards*(hContext: SCARDCONTEXT, mszCards: LPCSTR, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardLocateCardsA".} + proc SCardLocateCardsByATR*(hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardLocateCardsByATRA".} + proc SCardGetStatusChange*(hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardGetStatusChangeA".} + proc SCardConnect*(hContext: SCARDCONTEXT, szReader: LPCSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardConnectA".} + proc SCardStatus*(hCard: SCARDHANDLE, szReaderName: LPSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardStatusA".} + proc SCardUIDlgSelectCard*(P1: LPOPENCARDNAMEA_EX): LONG {.winapi, stdcall, dynlib: "scarddlg", importc: "SCardUIDlgSelectCardA".} + proc GetOpenCardName*(P1: LPOPENCARDNAMEA): LONG {.winapi, stdcall, dynlib: "scarddlg", importc: "GetOpenCardNameA".} + proc SCardReadCache*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: ptr DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardReadCacheA".} + proc SCardWriteCache*(hContext: SCARDCONTEXT, CardIdentifier: ptr UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: DWORD): LONG {.winapi, stdcall, dynlib: "winscard", importc: "SCardWriteCacheA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winsock.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winsock.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1794 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winerror +import winbase +#include +#include +#include <_timeval.h> +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +type + SCOPE_LEVEL* = int32 + GROUP* = int32 + WSACOMPLETIONTYPE* = int32 + PWSACOMPLETIONTYPE* = ptr int32 + LPWSACOMPLETIONTYPE* = ptr int32 + ADDRESS_FAMILY* = uint16 + WSAECOMPARATOR* = int32 + PWSAECOMPARATOR* = ptr int32 + LPWSAECOMPARATOR* = ptr int32 + WSAESETSERVICEOP* = int32 + PWSAESETSERVICEOP* = ptr int32 + LPWSAESETSERVICEOP* = ptr int32 + MULTICAST_MODE_TYPE* = int32 + socklen_t* = int32 + SOCKET_SECURITY_PROTOCOL* = int32 + SOCKET_USAGE_TYPE* = int32 + NLA_BLOB_DATA_TYPE* = int32 + PNLA_BLOB_DATA_TYPE* = ptr int32 + NLA_CONNECTIVITY_TYPE* = int32 + PNLA_CONNECTIVITY_TYPE* = ptr int32 + NLA_INTERNET* = int32 + PNLA_INTERNET* = ptr int32 + SOCKET* = int + SERVICETYPE* = ULONG + LPLOOKUPSERVICE_COMPLETION_ROUTINE* = PVOID + WSAEVENT* = HANDLE + IN_ADDR* {.pure.} = object + S_addr*: int32 + PIN_ADDR* = ptr IN_ADDR + LPIN_ADDR* = ptr IN_ADDR +const + FD_SETSIZE* = 64 +type + fd_set* {.pure.} = object + fd_count*: int32 + fd_array*: array[FD_SETSIZE, SOCKET] + PFD_SET* = ptr fd_set + LPFD_SET* = ptr fd_set + hostent* {.pure.} = object + h_name*: ptr char + h_aliases*: ptr ptr char + h_addrtype*: int16 + h_length*: int16 + h_addr_list*: ptr ptr char + HOSTENT* = hostent + PHOSTENT* = ptr hostent + LPHOSTENT* = ptr hostent +when winimCpu64: + type + servent* {.pure.} = object + s_name*: ptr char + s_aliases*: ptr ptr char + s_proto*: ptr char + s_port*: int16 +when winimCpu32: + type + servent* {.pure.} = object + s_name*: ptr char + s_aliases*: ptr ptr char + s_port*: int16 + s_proto*: ptr char +type + SERVENT* = servent + PSERVENT* = ptr servent + LPSERVENT* = ptr servent + protoent* {.pure.} = object + p_name*: ptr char + p_aliases*: ptr ptr char + p_proto*: int16 + PROTOENT* = protoent + PPROTOENT* = ptr protoent + LPPROTOENT* = ptr protoent + sockaddr* {.pure.} = object + sa_family*: uint16 + sa_data*: array[14, char] + SOCKADDR* = sockaddr + PSOCKADDR* = ptr sockaddr + LPSOCKADDR* = ptr sockaddr + sockaddr_in* {.pure.} = object + sin_family*: int16 + sin_port*: uint16 + sin_addr*: IN_ADDR + sin_zero*: array[8, char] + SOCKADDR_IN* = sockaddr_in + PSOCKADDR_IN* = ptr sockaddr_in + LPSOCKADDR_IN* = ptr sockaddr_in + linger* {.pure.} = object + l_onoff*: uint16 + l_linger*: uint16 + LINGER* = linger + PLINGER* = ptr linger + LPLINGER* = ptr linger + timeval* {.pure.} = object + tv_sec*: int32 + tv_usec*: int32 + TIMEVAL* = timeval + PTIMEVAL* = ptr timeval + LPTIMEVAL* = ptr timeval +const + WSADESCRIPTION_LEN* = 256 + WSASYS_STATUS_LEN* = 128 +when winimCpu64: + type + WSADATA* {.pure.} = object + wVersion*: WORD + wHighVersion*: WORD + iMaxSockets*: uint16 + iMaxUdpDg*: uint16 + lpVendorInfo*: ptr char + szDescription*: array[WSADESCRIPTION_LEN+1, char] + szSystemStatus*: array[WSASYS_STATUS_LEN+1, char] +when winimCpu32: + type + WSADATA* {.pure.} = object + wVersion*: WORD + wHighVersion*: WORD + szDescription*: array[WSADESCRIPTION_LEN+1, char] + szSystemStatus*: array[WSASYS_STATUS_LEN+1, char] + iMaxSockets*: uint16 + iMaxUdpDg*: uint16 + lpVendorInfo*: ptr char +type + LPWSADATA* = ptr WSADATA + SCOPE_ID_UNION1_STRUCT1* {.pure.} = object + Zone* {.bitsize:28.}: ULONG + Level* {.bitsize:4.}: ULONG + SCOPE_ID_UNION1* {.pure, union.} = object + struct1*: SCOPE_ID_UNION1_STRUCT1 + Value*: ULONG + SCOPE_ID* {.pure.} = object + union1*: SCOPE_ID_UNION1 + PSCOPE_ID* = ptr SCOPE_ID + LPWSAEVENT* = LPHANDLE + WSAOVERLAPPED* = OVERLAPPED + LPWSAOVERLAPPED* = ptr OVERLAPPED + WSABUF* {.pure.} = object + len*: int32 + buf*: ptr char + LPWSABUF* = ptr WSABUF + FLOWSPEC* {.pure.} = object + TokenRate*: ULONG + TokenBucketSize*: ULONG + PeakBandwidth*: ULONG + Latency*: ULONG + DelayVariation*: ULONG + ServiceType*: SERVICETYPE + MaxSduSize*: ULONG + MinimumPolicedSize*: ULONG + PFLOWSPEC* = ptr FLOWSPEC + LPFLOWSPEC* = ptr FLOWSPEC + QOS_OBJECT_HDR* {.pure.} = object + ObjectType*: ULONG + ObjectLength*: ULONG + LPQOS_OBJECT_HDR* = ptr QOS_OBJECT_HDR + QOS_SD_MODE* {.pure.} = object + ObjectHdr*: QOS_OBJECT_HDR + ShapeDiscardMode*: ULONG + LPQOS_SD_MODE* = ptr QOS_SD_MODE + QOS_SHAPING_RATE* {.pure.} = object + ObjectHdr*: QOS_OBJECT_HDR + ShapingRate*: ULONG + LPQOS_SHAPING_RATE* = ptr QOS_SHAPING_RATE + QOS* {.pure.} = object + SendingFlowspec*: FLOWSPEC + ReceivingFlowspec*: FLOWSPEC + ProviderSpecific*: WSABUF + LPQOS* = ptr QOS +const + FD_MAX_EVENTS* = 10 +type + WSANETWORKEVENTS* {.pure.} = object + lNetworkEvents*: int32 + iErrorCode*: array[FD_MAX_EVENTS, int32] + LPWSANETWORKEVENTS* = ptr WSANETWORKEVENTS +const + MAX_PROTOCOL_CHAIN* = 7 +type + WSAPROTOCOLCHAIN* {.pure.} = object + ChainLen*: int32 + ChainEntries*: array[MAX_PROTOCOL_CHAIN, DWORD] + LPWSAPROTOCOLCHAIN* = ptr WSAPROTOCOLCHAIN +const + WSAPROTOCOL_LEN* = 255 +type + WSAPROTOCOL_INFOA* {.pure.} = object + dwServiceFlags1*: DWORD + dwServiceFlags2*: DWORD + dwServiceFlags3*: DWORD + dwServiceFlags4*: DWORD + dwProviderFlags*: DWORD + ProviderId*: GUID + dwCatalogEntryId*: DWORD + ProtocolChain*: WSAPROTOCOLCHAIN + iVersion*: int32 + iAddressFamily*: int32 + iMaxSockAddr*: int32 + iMinSockAddr*: int32 + iSocketType*: int32 + iProtocol*: int32 + iProtocolMaxOffset*: int32 + iNetworkByteOrder*: int32 + iSecurityScheme*: int32 + dwMessageSize*: DWORD + dwProviderReserved*: DWORD + szProtocol*: array[WSAPROTOCOL_LEN+1, CHAR] + LPWSAPROTOCOL_INFOA* = ptr WSAPROTOCOL_INFOA + WSAPROTOCOL_INFOW* {.pure.} = object + dwServiceFlags1*: DWORD + dwServiceFlags2*: DWORD + dwServiceFlags3*: DWORD + dwServiceFlags4*: DWORD + dwProviderFlags*: DWORD + ProviderId*: GUID + dwCatalogEntryId*: DWORD + ProtocolChain*: WSAPROTOCOLCHAIN + iVersion*: int32 + iAddressFamily*: int32 + iMaxSockAddr*: int32 + iMinSockAddr*: int32 + iSocketType*: int32 + iProtocol*: int32 + iProtocolMaxOffset*: int32 + iNetworkByteOrder*: int32 + iSecurityScheme*: int32 + dwMessageSize*: DWORD + dwProviderReserved*: DWORD + szProtocol*: array[WSAPROTOCOL_LEN+1, WCHAR] + LPWSAPROTOCOL_INFOW* = ptr WSAPROTOCOL_INFOW + WSACOMPLETION_Parameters_WindowMessage* {.pure.} = object + hWnd*: HWND + uMsg*: UINT + context*: WPARAM + WSACOMPLETION_Parameters_Event* {.pure.} = object + lpOverlapped*: LPWSAOVERLAPPED + LPWSAOVERLAPPED_COMPLETION_ROUTINE* = proc (dwError: DWORD, cbTransferred: DWORD, lpOverlapped: LPWSAOVERLAPPED, dwFlags: DWORD): void {.stdcall.} + WSACOMPLETION_Parameters_Apc* {.pure.} = object + lpOverlapped*: LPWSAOVERLAPPED + lpfnCompletionProc*: LPWSAOVERLAPPED_COMPLETION_ROUTINE + WSACOMPLETION_Parameters_Port* {.pure.} = object + lpOverlapped*: LPWSAOVERLAPPED + hPort*: HANDLE + Key*: ULONG_PTR + WSACOMPLETION_Parameters* {.pure, union.} = object + WindowMessage*: WSACOMPLETION_Parameters_WindowMessage + Event*: WSACOMPLETION_Parameters_Event + Apc*: WSACOMPLETION_Parameters_Apc + Port*: WSACOMPLETION_Parameters_Port + WSACOMPLETION* {.pure.} = object + Type*: WSACOMPLETIONTYPE + Parameters*: WSACOMPLETION_Parameters + PWSACOMPLETION* = ptr WSACOMPLETION + LPWSACOMPLETION* = ptr WSACOMPLETION +const + SS_PAD1SIZE* = 0x00000006 + SS_PAD2SIZE* = 0x00000070 +type + sockaddr_storage* {.pure.} = object + ss_family*: int16 + ss_pad1*: array[SS_PAD1SIZE, char] + ss_align*: int64 + ss_pad2*: array[SS_PAD2SIZE, char] + SOCKADDR_STORAGE* = sockaddr_storage + PSOCKADDR_STORAGE* = ptr sockaddr_storage + LPSOCKADDR_STORAGE* = ptr sockaddr_storage + BLOB* {.pure.} = object + cbSize*: ULONG + pBlobData*: ptr BYTE + LPBLOB* = ptr BLOB + SOCKET_ADDRESS* {.pure.} = object + lpSockaddr*: LPSOCKADDR + iSockaddrLength*: INT + PSOCKET_ADDRESS* = ptr SOCKET_ADDRESS + LPSOCKET_ADDRESS* = ptr SOCKET_ADDRESS + CSADDR_INFO* {.pure.} = object + LocalAddr*: SOCKET_ADDRESS + RemoteAddr*: SOCKET_ADDRESS + iSocketType*: INT + iProtocol*: INT + PCSADDR_INFO* = ptr CSADDR_INFO + LPCSADDR_INFO* = ptr CSADDR_INFO + SOCKET_ADDRESS_LIST* {.pure.} = object + iAddressCount*: INT + Address*: array[1, SOCKET_ADDRESS] + PSOCKET_ADDRESS_LIST* = ptr SOCKET_ADDRESS_LIST + LPSOCKET_ADDRESS_LIST* = ptr SOCKET_ADDRESS_LIST + AFPROTOCOLS* {.pure.} = object + iAddressFamily*: INT + iProtocol*: INT + PAFPROTOCOLS* = ptr AFPROTOCOLS + LPAFPROTOCOLS* = ptr AFPROTOCOLS + WSAVERSION* {.pure.} = object + dwVersion*: DWORD + ecHow*: WSAECOMPARATOR + PWSAVERSION* = ptr WSAVERSION + LPWSAVERSION* = ptr WSAVERSION + WSAQUERYSETA* {.pure.} = object + dwSize*: DWORD + lpszServiceInstanceName*: LPSTR + lpServiceClassId*: LPGUID + lpVersion*: LPWSAVERSION + lpszComment*: LPSTR + dwNameSpace*: DWORD + lpNSProviderId*: LPGUID + lpszContext*: LPSTR + dwNumberOfProtocols*: DWORD + lpafpProtocols*: LPAFPROTOCOLS + lpszQueryString*: LPSTR + dwNumberOfCsAddrs*: DWORD + lpcsaBuffer*: LPCSADDR_INFO + dwOutputFlags*: DWORD + lpBlob*: LPBLOB + PWSAQUERYSETA* = ptr WSAQUERYSETA + LPWSAQUERYSETA* = ptr WSAQUERYSETA + WSAQUERYSETW* {.pure.} = object + dwSize*: DWORD + lpszServiceInstanceName*: LPWSTR + lpServiceClassId*: LPGUID + lpVersion*: LPWSAVERSION + lpszComment*: LPWSTR + dwNameSpace*: DWORD + lpNSProviderId*: LPGUID + lpszContext*: LPWSTR + dwNumberOfProtocols*: DWORD + lpafpProtocols*: LPAFPROTOCOLS + lpszQueryString*: LPWSTR + dwNumberOfCsAddrs*: DWORD + lpcsaBuffer*: LPCSADDR_INFO + dwOutputFlags*: DWORD + lpBlob*: LPBLOB + PWSAQUERYSETW* = ptr WSAQUERYSETW + LPWSAQUERYSETW* = ptr WSAQUERYSETW + WSANSCLASSINFOA* {.pure.} = object + lpszName*: LPSTR + dwNameSpace*: DWORD + dwValueType*: DWORD + dwValueSize*: DWORD + lpValue*: LPVOID + PWSANSCLASSINFOA* = ptr WSANSCLASSINFOA + LPWSANSCLASSINFOA* = ptr WSANSCLASSINFOA + WSANSCLASSINFOW* {.pure.} = object + lpszName*: LPWSTR + dwNameSpace*: DWORD + dwValueType*: DWORD + dwValueSize*: DWORD + lpValue*: LPVOID + PWSANSCLASSINFOW* = ptr WSANSCLASSINFOW + LPWSANSCLASSINFOW* = ptr WSANSCLASSINFOW + WSASERVICECLASSINFOA* {.pure.} = object + lpServiceClassId*: LPGUID + lpszServiceClassName*: LPSTR + dwCount*: DWORD + lpClassInfos*: LPWSANSCLASSINFOA + PWSASERVICECLASSINFOA* = ptr WSASERVICECLASSINFOA + LPWSASERVICECLASSINFOA* = ptr WSASERVICECLASSINFOA + WSASERVICECLASSINFOW* {.pure.} = object + lpServiceClassId*: LPGUID + lpszServiceClassName*: LPWSTR + dwCount*: DWORD + lpClassInfos*: LPWSANSCLASSINFOW + PWSASERVICECLASSINFOW* = ptr WSASERVICECLASSINFOW + LPWSASERVICECLASSINFOW* = ptr WSASERVICECLASSINFOW + WSANAMESPACE_INFOA* {.pure.} = object + NSProviderId*: GUID + dwNameSpace*: DWORD + fActive*: WINBOOL + dwVersion*: DWORD + lpszIdentifier*: LPSTR + PWSANAMESPACE_INFOA* = ptr WSANAMESPACE_INFOA + LPWSANAMESPACE_INFOA* = ptr WSANAMESPACE_INFOA + WSANAMESPACE_INFOW* {.pure.} = object + NSProviderId*: GUID + dwNameSpace*: DWORD + fActive*: WINBOOL + dwVersion*: DWORD + lpszIdentifier*: LPWSTR + PWSANAMESPACE_INFOW* = ptr WSANAMESPACE_INFOW + LPWSANAMESPACE_INFOW* = ptr WSANAMESPACE_INFOW + WSAMSG* {.pure.} = object + name*: LPSOCKADDR + namelen*: INT + lpBuffers*: LPWSABUF + dwBufferCount*: DWORD + Control*: WSABUF + dwFlags*: DWORD + PWSAMSG* = ptr WSAMSG + LPWSAMSG* = ptr WSAMSG + WSANAMESPACE_INFOEXA* {.pure.} = object + NSProviderId*: GUID + dwNameSpace*: DWORD + fActive*: WINBOOL + dwVersion*: DWORD + lpszIdentifier*: LPSTR + ProviderSpecific*: BLOB + PWSANAMESPACE_INFOEXA* = ptr WSANAMESPACE_INFOEXA + LPWSANAMESPACE_INFOEXA* = ptr WSANAMESPACE_INFOEXA + WSANAMESPACE_INFOEXW* {.pure.} = object + NSProviderId*: GUID + dwNameSpace*: DWORD + fActive*: WINBOOL + dwVersion*: DWORD + lpszIdentifier*: LPWSTR + ProviderSpecific*: BLOB + PWSANAMESPACE_INFOEXW* = ptr WSANAMESPACE_INFOEXW + LPWSANAMESPACE_INFOEXW* = ptr WSANAMESPACE_INFOEXW + WSAQUERYSET2A* {.pure.} = object + dwSize*: DWORD + lpszServiceInstanceName*: LPSTR + lpVersion*: LPWSAVERSION + lpszComment*: LPSTR + dwNameSpace*: DWORD + lpNSProviderId*: LPGUID + lpszContext*: LPSTR + dwNumberOfProtocols*: DWORD + lpafpProtocols*: LPAFPROTOCOLS + lpszQueryString*: LPSTR + dwNumberOfCsAddrs*: DWORD + lpcsaBuffer*: LPCSADDR_INFO + dwOutputFlags*: DWORD + lpBlob*: LPBLOB + PWSAQUERYSET2A* = ptr WSAQUERYSET2A + LPWSAQUERYSET2A* = ptr WSAQUERYSET2A + WSAQUERYSET2W* {.pure.} = object + dwSize*: DWORD + lpszServiceInstanceName*: LPWSTR + lpVersion*: LPWSAVERSION + lpszComment*: LPWSTR + dwNameSpace*: DWORD + lpNSProviderId*: LPGUID + lpszContext*: LPTSTR + dwNumberOfProtocols*: DWORD + lpafpProtocols*: LPAFPROTOCOLS + lpszQueryString*: LPWSTR + dwNumberOfCsAddrs*: DWORD + lpcsaBuffer*: LPCSADDR_INFO + dwOutputFlags*: DWORD + lpBlob*: LPBLOB + PWSAQUERYSET2W* = ptr WSAQUERYSET2W + LPWSAQUERYSET2W* = ptr WSAQUERYSET2W + WSAPOLLFD* {.pure.} = object + fd*: SOCKET + events*: int16 + revents*: int16 + PWSAPOLLFD* = ptr WSAPOLLFD + LPWSAPOLLFD* = ptr WSAPOLLFD + IN6_ADDR* {.pure.} = object + Byte*: array[16, uint8] + PIN6_ADDR* = ptr IN6_ADDR + LPIN6_ADDR* = ptr IN6_ADDR + sockaddr_in6_UNION1* {.pure, union.} = object + sin6_scope_id*: int32 + sin6_scope_struct*: SCOPE_ID + sockaddr_in6* {.pure.} = object + sin6_family*: int16 + sin6_port*: uint16 + sin6_flowinfo*: int32 + sin6_addr*: IN6_ADDR + union1*: sockaddr_in6_UNION1 + SOCKADDR_IN6* = sockaddr_in6 + PSOCKADDR_IN6* = ptr sockaddr_in6 + LPSOCKADDR_IN6* = ptr sockaddr_in6 + sockaddr_in6_old* {.pure.} = object + sin6_family*: int16 + sin6_port*: uint16 + sin6_flowinfo*: int32 + sin6_addr*: IN6_ADDR + sockaddr_gen* {.pure, union.} = object + Address*: sockaddr + AddressIn*: sockaddr_in + AddressIn6*: sockaddr_in6_old + TINTERFACE_INFO* {.pure.} = object + iiFlags*: int32 + iiAddress*: sockaddr_gen + iiBroadcastAddress*: sockaddr_gen + iiNetmask*: sockaddr_gen + LPTINTERFACE_INFO* = ptr TINTERFACE_INFO + SOCKADDR_IN6_PAIR* {.pure.} = object + SourceAddress*: PSOCKADDR_IN6 + DestinationAddress*: PSOCKADDR_IN6 + PSOCKADDR_IN6_PAIR* = ptr SOCKADDR_IN6_PAIR + SOCKADDR_INET* {.pure, union.} = object + Ipv4*: SOCKADDR_IN + Ipv6*: SOCKADDR_IN6 + si_family*: ADDRESS_FAMILY + PSOCKADDR_INET* = ptr SOCKADDR_INET + GROUP_FILTER* {.pure.} = object + gf_interface*: ULONG + gf_group*: SOCKADDR_STORAGE + gf_fmode*: MULTICAST_MODE_TYPE + gf_numsrc*: ULONG + gf_slist*: array[1, SOCKADDR_STORAGE] + PGROUP_FILTER* = ptr GROUP_FILTER + GROUP_REQ* {.pure.} = object + gr_interface*: ULONG + gr_group*: SOCKADDR_STORAGE + PGROUP_REQ* = ptr GROUP_REQ + GROUP_SOURCE_REQ* {.pure.} = object + gsr_interface*: ULONG + gsr_group*: SOCKADDR_STORAGE + gsr_source*: SOCKADDR_STORAGE + PGROUP_SOURCE_REQ* = ptr GROUP_SOURCE_REQ + INTERFACE_INFO_EX* {.pure.} = object + iiFlags*: int32 + iiAddress*: SOCKET_ADDRESS + iiBroadcastAddress*: SOCKET_ADDRESS + iiNetmask*: SOCKET_ADDRESS + LPINTERFACE_INFO_EX* = ptr INTERFACE_INFO_EX + ADDRINFOA* {.pure.} = object + ai_flags*: int32 + ai_family*: int32 + ai_socktype*: int32 + ai_protocol*: int32 + ai_addrlen*: int + ai_canonname*: ptr char + ai_addr*: ptr sockaddr + ai_next*: ptr ADDRINFOA + PADDRINFOA* = ptr ADDRINFOA + ADDRINFOW* {.pure.} = object + ai_flags*: int32 + ai_family*: int32 + ai_socktype*: int32 + ai_protocol*: int32 + ai_addrlen*: int + ai_canonname*: PWSTR + ai_addr*: ptr sockaddr + ai_next*: ptr ADDRINFOW + PADDRINFOW* = ptr ADDRINFOW + ADDRINFO* = ADDRINFOA + LPADDRINFO* = ptr ADDRINFOA + LPFN_GETADDRINFO* = proc (nodename: ptr char, servname: ptr char, hints: ptr ADDRINFOA, res: ptr ptr ADDRINFOA): int32 {.stdcall.} + LPFN_GETADDRINFOA* = LPFN_GETADDRINFO + LPFN_FREEADDRINFO* = proc (ai: ptr ADDRINFOA): void {.stdcall.} + LPFN_FREEADDRINFOA* = LPFN_FREEADDRINFO + LPFN_GETNAMEINFO* = proc (sa: ptr sockaddr, salen: socklen_t, host: ptr char, hostlen: DWORD, serv: ptr char, servlen: DWORD, flags: int32): int32 {.stdcall.} + LPFN_GETNAMEINFOA* = LPFN_GETNAMEINFO + ADDRINFOEXA* {.pure.} = object + ai_flags*: int32 + ai_family*: int32 + ai_socktype*: int32 + ai_protocol*: int32 + ai_addrlen*: int + ai_canonname*: LPCSTR + ai_addr*: ptr sockaddr + ai_blob*: pointer + ai_bloblen*: int + ai_provider*: LPGUID + ai_next*: ptr ADDRINFOEXA + PADDRINFOEXA* = ptr ADDRINFOEXA + ADDRINFOEXW* {.pure.} = object + ai_flags*: int32 + ai_family*: int32 + ai_socktype*: int32 + ai_protocol*: int32 + ai_addrlen*: int + ai_canonname*: LPCWSTR + ai_addr*: ptr sockaddr + ai_blob*: pointer + ai_bloblen*: int + ai_provider*: LPGUID + ai_next*: ptr ADDRINFOEXW + PADDRINFOEXW* = ptr ADDRINFOEXW + TRANSMIT_FILE_BUFFERS* {.pure.} = object + Head*: LPVOID + HeadLength*: DWORD + Tail*: LPVOID + TailLength*: DWORD + PTRANSMIT_FILE_BUFFERS* = ptr TRANSMIT_FILE_BUFFERS + LPTRANSMIT_FILE_BUFFERS* = ptr TRANSMIT_FILE_BUFFERS + TRANSMIT_PACKETS_ELEMENT_UNION1_STRUCT1* {.pure.} = object + nFileOffset*: LARGE_INTEGER + hFile*: HANDLE + TRANSMIT_PACKETS_ELEMENT_UNION1* {.pure, union.} = object + struct1*: TRANSMIT_PACKETS_ELEMENT_UNION1_STRUCT1 + pBuffer*: PVOID + TRANSMIT_PACKETS_ELEMENT* {.pure.} = object + dwElFlags*: ULONG + cLength*: ULONG + union1*: TRANSMIT_PACKETS_ELEMENT_UNION1 + PTRANSMIT_PACKETS_ELEMENT* = ptr TRANSMIT_PACKETS_ELEMENT + LPTRANSMIT_PACKETS_ELEMENT* = ptr TRANSMIT_PACKETS_ELEMENT + NLA_BLOB_header* {.pure.} = object + `type`*: NLA_BLOB_DATA_TYPE + dwSize*: DWORD + nextOffset*: DWORD + NLA_BLOB_data_interfaceData* {.pure.} = object + dwType*: DWORD + dwSpeed*: DWORD + adapterName*: array[1, CHAR] + NLA_BLOB_data_locationData* {.pure.} = object + information*: array[1, CHAR] + NLA_BLOB_data_connectivity* {.pure.} = object + `type`*: NLA_CONNECTIVITY_TYPE + internet*: NLA_INTERNET + NLA_BLOB_data_ICS_remote* {.pure.} = object + speed*: DWORD + `type`*: DWORD + state*: DWORD + machineName*: array[256, WCHAR] + sharedAdapterName*: array[256, WCHAR] + NLA_BLOB_data_ICS* {.pure.} = object + remote*: NLA_BLOB_data_ICS_remote + NLA_BLOB_data* {.pure, union.} = object + rawData*: array[1, CHAR] + interfaceData*: NLA_BLOB_data_interfaceData + locationData*: NLA_BLOB_data_locationData + connectivity*: NLA_BLOB_data_connectivity + ICS*: NLA_BLOB_data_ICS + NLA_BLOB* {.pure.} = object + header*: NLA_BLOB_header + data*: NLA_BLOB_data + PNLA_BLOB* = ptr NLA_BLOB + LPNLA_BLOB* = ptr NLA_BLOB + WSACMSGHDR* {.pure.} = object + cmsg_len*: SIZE_T + cmsg_level*: INT + cmsg_type*: INT + PWSACMSGHDR* = ptr WSACMSGHDR + LPWSACMSGHDR* = ptr WSACMSGHDR + WSAPOLLDATA* {.pure.} = object + result*: int32 + fds*: ULONG + timeout*: INT + fdArray*: UncheckedArray[WSAPOLLFD] + LPWSAPOLLDATA* = ptr WSAPOLLDATA + TWSASENDMSG* {.pure.} = object + lpMsg*: LPWSAMSG + dwFlags*: DWORD + lpNumberOfBytesSent*: LPDWORD + lpOverlapped*: LPWSAOVERLAPPED + lpCompletionRoutine*: LPWSAOVERLAPPED_COMPLETION_ROUTINE + LPWSASENDMSG* = ptr TWSASENDMSG + addrinfo* = ADDRINFOA + addrinfoW* = ADDRINFOW + addrinfoExA* = ADDRINFOEXA + addrinfoExW* = ADDRINFOEXW +when winimUnicode: + type + addrinfoEx* = addrinfoExW +when winimAnsi: + type + addrinfoEx* = addrinfoExA +type + ADDRINFOEX* = addrinfoEx +const + INCL_WINSOCK_API_TYPEDEFS* = 0 + WINSOCK_VERSION* = MAKEWORD(2,2) + SOCKET_ERROR* = -1 + scopeLevelInterface* = 1 + scopeLevelLink* = 2 + scopeLevelSubnet* = 3 + scopeLevelAdmin* = 4 + scopeLevelSite* = 5 + scopeLevelOrganization* = 8 + scopeLevelGlobal* = 14 + scopeLevelCount* = 16 + IOCPARM_MASK* = 0x7f + IOC_VOID* = 0x20000000 + IOC_OUT* = 0x40000000 + IOC_IN* = 0x80000000'i32 + IOC_INOUT* = IOC_IN or IOC_OUT + IPPROTO_IP* = 0 + IPPROTO_HOPOPTS* = 0 + IPPROTO_ICMP* = 1 + IPPROTO_IGMP* = 2 + IPPROTO_GGP* = 3 + IPPROTO_IPV4* = 4 + IPPROTO_TCP* = 6 + IPPROTO_PUP* = 12 + IPPROTO_UDP* = 17 + IPPROTO_IDP* = 22 + IPPROTO_IPV6* = 41 + IPPROTO_ROUTING* = 43 + IPPROTO_FRAGMENT* = 44 + IPPROTO_ESP* = 50 + IPPROTO_AH* = 51 + IPPROTO_ICMPV6* = 58 + IPPROTO_NONE* = 59 + IPPROTO_DSTOPTS* = 60 + IPPROTO_ND* = 77 + IPPROTO_ICLFXBM* = 78 + IPPROTO_RAW* = 255 + IPPROTO_MAX* = 256 + IPPORT_ECHO* = 7 + IPPORT_DISCARD* = 9 + IPPORT_SYSTAT* = 11 + IPPORT_DAYTIME* = 13 + IPPORT_NETSTAT* = 15 + IPPORT_FTP* = 21 + IPPORT_TELNET* = 23 + IPPORT_SMTP* = 25 + IPPORT_TIMESERVER* = 37 + IPPORT_NAMESERVER* = 42 + IPPORT_WHOIS* = 43 + IPPORT_MTP* = 57 + IPPORT_TFTP* = 69 + IPPORT_RJE* = 77 + IPPORT_FINGER* = 79 + IPPORT_TTYLINK* = 87 + IPPORT_SUPDUP* = 95 + IPPORT_EXECSERVER* = 512 + IPPORT_LOGINSERVER* = 513 + IPPORT_CMDSERVER* = 514 + IPPORT_EFSSERVER* = 520 + IPPORT_BIFFUDP* = 512 + IPPORT_WHOSERVER* = 513 + IPPORT_ROUTESERVER* = 520 + IPPORT_RESERVED* = 1024 + IMPLINK_IP* = 155 + IMPLINK_LOWEXPER* = 156 + IMPLINK_HIGHEXPER* = 158 + IN_CLASSA_NET* = 0xff000000'i32 + IN_CLASSA_NSHIFT* = 24 + IN_CLASSA_HOST* = 0x00ffffff + IN_CLASSA_MAX* = 128 + IN_CLASSB_NET* = 0xffff0000'i32 + IN_CLASSB_NSHIFT* = 16 + IN_CLASSB_HOST* = 0x0000ffff + IN_CLASSB_MAX* = 65536 + IN_CLASSC_NET* = 0xffffff00'i32 + IN_CLASSC_NSHIFT* = 8 + IN_CLASSC_HOST* = 0x000000ff + IN_CLASSD_NET* = 0xf0000000'i32 + IN_CLASSD_NSHIFT* = 28 + IN_CLASSD_HOST* = 0x0fffffff + INADDR_ANY* = int32 0x00000000 + INADDR_LOOPBACK* = 0x7f000001 + INADDR_BROADCAST* = int32 0xffffffff'i32 + INADDR_NONE* = 0xffffffff'i32 + ADDR_ANY* = INADDR_ANY + FROM_PROTOCOL_INFO* = -1 + SOCK_STREAM* = 1 + SOCK_DGRAM* = 2 + SOCK_RAW* = 3 + SOCK_RDM* = 4 + SOCK_SEQPACKET* = 5 + SO_DEBUG* = 0x0001 + SO_ACCEPTCONN* = 0x0002 + SO_REUSEADDR* = 0x0004 + SO_KEEPALIVE* = 0x0008 + SO_DONTROUTE* = 0x0010 + SO_BROADCAST* = 0x0020 + SO_USELOOPBACK* = 0x0040 + SO_LINGER* = 0x0080 + SO_OOBINLINE* = 0x0100 + SO_SNDBUF* = 0x1001 + SO_RCVBUF* = 0x1002 + SO_SNDLOWAT* = 0x1003 + SO_RCVLOWAT* = 0x1004 + SO_SNDTIMEO* = 0x1005 + SO_RCVTIMEO* = 0x1006 + SO_ERROR* = 0x1007 + SO_TYPE* = 0x1008 + SO_GROUP_ID* = 0x2001 + SO_GROUP_PRIORITY* = 0x2002 + SO_MAX_MSG_SIZE* = 0x2003 + SO_PROTOCOL_INFOA* = 0x2004 + SO_PROTOCOL_INFOW* = 0x2005 + PVD_CONFIG* = 0x3001 + SO_CONDITIONAL_ACCEPT* = 0x3002 + TCP_NODELAY* = 0x0001 + AF_UNSPEC* = 0 + AF_UNIX* = 1 + AF_INET* = 2 + AF_IMPLINK* = 3 + AF_PUP* = 4 + AF_CHAOS* = 5 + AF_NS* = 6 + AF_IPX* = AF_NS + AF_ISO* = 7 + AF_OSI* = AF_ISO + AF_ECMA* = 8 + AF_DATAKIT* = 9 + AF_CCITT* = 10 + AF_SNA* = 11 + AF_DECnet* = 12 + AF_DLI* = 13 + AF_LAT* = 14 + AF_HYLINK* = 15 + AF_APPLETALK* = 16 + AF_NETBIOS* = 17 + AF_VOICEVIEW* = 18 + AF_FIREFOX* = 19 + AF_UNKNOWN1* = 20 + AF_BAN* = 21 + AF_ATM* = 22 + AF_INET6* = 23 + AF_CLUSTER* = 24 + AF_12844* = 25 + AF_IRDA* = 26 + AF_NETDES* = 28 + AF_TCNPROCESS* = 29 + AF_TCNMESSAGE* = 30 + AF_ICLFXBM* = 31 + AF_BTH* = 32 + AF_MAX* = 33 + SS_MAXSIZE* = 128 + SS_ALIGNSIZE* = 8 + PF_UNSPEC* = AF_UNSPEC + PF_UNIX* = AF_UNIX + PF_INET* = AF_INET + PF_IMPLINK* = AF_IMPLINK + PF_PUP* = AF_PUP + PF_CHAOS* = AF_CHAOS + PF_NS* = AF_NS + PF_IPX* = AF_IPX + PF_ISO* = AF_ISO + PF_OSI* = AF_OSI + PF_ECMA* = AF_ECMA + PF_DATAKIT* = AF_DATAKIT + PF_CCITT* = AF_CCITT + PF_SNA* = AF_SNA + PF_DECnet* = AF_DECnet + PF_DLI* = AF_DLI + PF_LAT* = AF_LAT + PF_HYLINK* = AF_HYLINK + PF_APPLETALK* = AF_APPLETALK + PF_VOICEVIEW* = AF_VOICEVIEW + PF_FIREFOX* = AF_FIREFOX + PF_UNKNOWN1* = AF_UNKNOWN1 + PF_BAN* = AF_BAN + PF_ATM* = AF_ATM + PF_INET6* = AF_INET6 + PF_BTH* = AF_BTH + PF_MAX* = AF_MAX + SOL_SOCKET* = 0xffff + SOMAXCONN* = 0x7fffffff + MSG_OOB* = 0x1 + MSG_PEEK* = 0x2 + MSG_DONTROUTE* = 0x4 + MSG_WAITALL* = 0x8 + MSG_PARTIAL* = 0x8000 + MSG_INTERRUPT* = 0x10 + MSG_MAXIOVLEN* = 16 + MAXGETHOSTSTRUCT* = 1024 + FD_READ_BIT* = 0 + FD_READ* = 1 shl FD_READ_BIT + FD_WRITE_BIT* = 1 + FD_WRITE* = 1 shl FD_WRITE_BIT + FD_OOB_BIT* = 2 + FD_OOB* = 1 shl FD_OOB_BIT + FD_ACCEPT_BIT* = 3 + FD_ACCEPT* = 1 shl FD_ACCEPT_BIT + FD_CONNECT_BIT* = 4 + FD_CONNECT* = 1 shl FD_CONNECT_BIT + FD_CLOSE_BIT* = 5 + FD_CLOSE* = 1 shl FD_CLOSE_BIT + FD_QOS_BIT* = 6 + FD_QOS* = 1 shl FD_QOS_BIT + FD_GROUP_QOS_BIT* = 7 + FD_GROUP_QOS* = 1 shl FD_GROUP_QOS_BIT + FD_ROUTING_INTERFACE_CHANGE_BIT* = 8 + FD_ROUTING_INTERFACE_CHANGE* = 1 shl FD_ROUTING_INTERFACE_CHANGE_BIT + FD_ADDRESS_LIST_CHANGE_BIT* = 9 + FD_ADDRESS_LIST_CHANGE* = 1 shl FD_ADDRESS_LIST_CHANGE_BIT + FD_ALL_EVENTS* = (1 shl FD_MAX_EVENTS)-1 + WSA_IO_PENDING* = ERROR_IO_PENDING + WSA_IO_INCOMPLETE* = ERROR_IO_INCOMPLETE + WSA_INVALID_HANDLE* = ERROR_INVALID_HANDLE + WSA_INVALID_PARAMETER* = ERROR_INVALID_PARAMETER + WSA_NOT_ENOUGH_MEMORY* = ERROR_NOT_ENOUGH_MEMORY + WSA_OPERATION_ABORTED* = ERROR_OPERATION_ABORTED + WSA_MAXIMUM_WAIT_EVENTS* = MAXIMUM_WAIT_OBJECTS + WSA_WAIT_FAILED* = WAIT_FAILED + WSA_WAIT_EVENT_0* = WAIT_OBJECT_0 + WSA_WAIT_IO_COMPLETION* = WAIT_IO_COMPLETION + WSA_WAIT_TIMEOUT* = WAIT_TIMEOUT + WSA_INFINITE* = INFINITE + SERVICETYPE_NOTRAFFIC* = 0x00000000 + SERVICETYPE_BESTEFFORT* = 0x00000001 + SERVICETYPE_CONTROLLEDLOAD* = 0x00000002 + SERVICETYPE_GUARANTEED* = 0x00000003 + SERVICETYPE_NETWORK_UNAVAILABLE* = 0x00000004 + SERVICETYPE_GENERAL_INFORMATION* = 0x00000005 + SERVICETYPE_NOCHANGE* = 0x00000006 + SERVICETYPE_NONCONFORMING* = 0x00000009 + SERVICETYPE_NETWORK_CONTROL* = 0x0000000A + SERVICETYPE_QUALITATIVE* = 0x0000000D + SERVICE_BESTEFFORT* = 0x80010000'i32 + SERVICE_CONTROLLEDLOAD* = 0x80020000'i32 + SERVICE_GUARANTEED* = 0x80040000'i32 + SERVICE_QUALITATIVE* = 0x80200000'i32 + SERVICE_NO_TRAFFIC_CONTROL* = 0x81000000'i32 + SERVICE_NO_QOS_SIGNALING* = 0x40000000 + QOS_NOT_SPECIFIED* = 0xFFFFFFFF'i32 + POSITIVE_INFINITY_RATE* = 0xFFFFFFFE'i32 + QOS_GENERAL_ID_BASE* = 2000 + QOS_OBJECT_END_OF_LIST* = 0x00000001+QOS_GENERAL_ID_BASE + QOS_OBJECT_SD_MODE* = 0x00000002+QOS_GENERAL_ID_BASE + QOS_OBJECT_SHAPING_RATE* = 0x00000003+QOS_GENERAL_ID_BASE + QOS_OBJECT_DESTADDR* = 0x00000004+QOS_GENERAL_ID_BASE + TC_NONCONF_BORROW* = 0 + TC_NONCONF_SHAPE* = 1 + TC_NONCONF_DISCARD* = 2 + TC_NONCONF_BORROW_PLUS* = 3 + CF_ACCEPT* = 0x0000 + CF_REJECT* = 0x0001 + CF_DEFER* = 0x0002 + SD_RECEIVE* = 0x00 + SD_SEND* = 0x01 + SD_BOTH* = 0x02 + SG_UNCONSTRAINED_GROUP* = 0x01 + SG_CONSTRAINED_GROUP* = 0x02 + BASE_PROTOCOL* = 1 + LAYERED_PROTOCOL* = 0 + PFL_MULTIPLE_PROTO_ENTRIES* = 0x00000001 + PFL_RECOMMENDED_PROTO_ENTRY* = 0x00000002 + PFL_HIDDEN* = 0x00000004 + PFL_MATCHES_PROTOCOL_ZERO* = 0x00000008 + XP1_CONNECTIONLESS* = 0x00000001 + XP1_GUARANTEED_DELIVERY* = 0x00000002 + XP1_GUARANTEED_ORDER* = 0x00000004 + XP1_MESSAGE_ORIENTED* = 0x00000008 + XP1_PSEUDO_STREAM* = 0x00000010 + XP1_GRACEFUL_CLOSE* = 0x00000020 + XP1_EXPEDITED_DATA* = 0x00000040 + XP1_CONNECT_DATA* = 0x00000080 + XP1_DISCONNECT_DATA* = 0x00000100 + XP1_SUPPORT_BROADCAST* = 0x00000200 + XP1_SUPPORT_MULTIPOINT* = 0x00000400 + XP1_MULTIPOINT_CONTROL_PLANE* = 0x00000800 + XP1_MULTIPOINT_DATA_PLANE* = 0x00001000 + XP1_QOS_SUPPORTED* = 0x00002000 + XP1_INTERRUPT* = 0x00004000 + XP1_UNI_SEND* = 0x00008000 + XP1_UNI_RECV* = 0x00010000 + XP1_IFS_HANDLES* = 0x00020000 + XP1_PARTIAL_MESSAGE* = 0x00040000 + BIGENDIAN* = 0x0000 + LITTLEENDIAN* = 0x0001 + SECURITY_PROTOCOL_NONE* = 0x0000 + JL_SENDER_ONLY* = 0x01 + JL_RECEIVER_ONLY* = 0x02 + JL_BOTH* = 0x04 + WSA_FLAG_OVERLAPPED* = 0x01 + WSA_FLAG_MULTIPOINT_C_ROOT* = 0x02 + WSA_FLAG_MULTIPOINT_C_LEAF* = 0x04 + WSA_FLAG_MULTIPOINT_D_ROOT* = 0x08 + WSA_FLAG_MULTIPOINT_D_LEAF* = 0x10 + IOC_UNIX* = 0x00000000 + IOC_WS2* = 0x08000000 + IOC_PROTOCOL* = 0x10000000 + IOC_VENDOR* = 0x18000000 + NSP_NOTIFY_IMMEDIATELY* = 0 + NSP_NOTIFY_HWND* = 1 + NSP_NOTIFY_EVENT* = 2 + NSP_NOTIFY_PORT* = 3 + NSP_NOTIFY_APC* = 4 + TH_NETDEV* = 0x00000001 + TH_TAPI* = 0x00000002 + SERVICE_MULTIPLE* = 0x00000001 + NS_ALL* = 0 + NS_SAP* = 1 + NS_NDS* = 2 + NS_PEER_BROWSE* = 3 + NS_SLP* = 5 + NS_DHCP* = 6 + NS_TCPIP_LOCAL* = 10 + NS_TCPIP_HOSTS* = 11 + NS_DNS* = 12 + NS_NETBT* = 13 + NS_WINS* = 14 + NS_NLA* = 15 + NS_BTH* = 16 + NS_NBP* = 20 + NS_MS* = 30 + NS_STDA* = 31 + NS_NTDS* = 32 + NS_EMAIL* = 37 + NS_PNRPNAME* = 38 + NS_PNRPCLOUD* = 39 + NS_X500* = 40 + NS_NIS* = 41 + NS_NISPLUS* = 42 + NS_WRQ* = 50 + NS_NETDES* = 60 + RES_UNUSED_1* = 0x00000001 + RES_FLUSH_CACHE* = 0x00000002 + RES_SERVICE* = 0x00000004 + SERVICE_TYPE_VALUE_IPXPORTA* = "IpxSocket" + SERVICE_TYPE_VALUE_IPXPORTW* = "IpxSocket" + SERVICE_TYPE_VALUE_SAPIDA* = "SapId" + SERVICE_TYPE_VALUE_SAPIDW* = "SapId" + SERVICE_TYPE_VALUE_TCPPORTA* = "TcpPort" + SERVICE_TYPE_VALUE_TCPPORTW* = "TcpPort" + SERVICE_TYPE_VALUE_UDPPORTA* = "UdpPort" + SERVICE_TYPE_VALUE_UDPPORTW* = "UdpPort" + SERVICE_TYPE_VALUE_OBJECTIDA* = "ObjectId" + SERVICE_TYPE_VALUE_OBJECTIDW* = "ObjectId" + COMP_EQUAL* = 0 + COMP_NOTLESS* = 1 + LUP_DEEP* = 0x0001 + LUP_CONTAINERS* = 0x0002 + LUP_NOCONTAINERS* = 0x0004 + LUP_NEAREST* = 0x0008 + LUP_RETURN_NAME* = 0x0010 + LUP_RETURN_TYPE* = 0x0020 + LUP_RETURN_VERSION* = 0x0040 + LUP_RETURN_COMMENT* = 0x0080 + LUP_RETURN_ADDR* = 0x0100 + LUP_RETURN_BLOB* = 0x0200 + LUP_RETURN_ALIASES* = 0x0400 + LUP_RETURN_QUERY_STRING* = 0x0800 + LUP_RETURN_ALL* = 0x0FF0 + LUP_RES_SERVICE* = 0x8000 + LUP_FLUSHCACHE* = 0x1000 + LUP_FLUSHPREVIOUS* = 0x2000 + LUP_NON_AUTHORITATIVE* = 0x4000 + LUP_SECURE* = 0x8000 + LUP_RETURN_PREFERRED_NAMES* = 0x10000 + LUP_ADDRCONFIG* = 0x100000 + LUP_DUAL_ADDR* = 0x200000 + LUP_FILESERVER* = 0x400000 + LUP_RES_RESERVICE* = 0x8000 + RESULT_IS_ALIAS* = 0x0001 + RESULT_IS_ADDED* = 0x0010 + RESULT_IS_CHANGED* = 0x0020 + RESULT_IS_DELETED* = 0x0040 + RNRSERVICE_REGISTER* = 0 + RNRSERVICE_DEREGISTER* = 1 + RNRSERVICE_DELETE* = 2 + POLLRDNORM* = 0x0100 + POLLRDBAND* = 0x0200 + POLLIN* = POLLRDNORM or POLLRDBAND + POLLPRI* = 0x0400 + POLLWRNORM* = 0x0010 + POLLOUT* = POLLWRNORM + POLLWRBAND* = 0x0020 + POLLERR* = 0x0001 + POLLHUP* = 0x0002 + POLLNVAL* = 0x0004 + MCAST_INCLUDE* = 0 + MCAST_EXCLUDE* = 1 + IPV6_HOPOPTS* = 1 + IPV6_HDRINCL* = 2 + IPV6_UNICAST_HOPS* = 4 + IPV6_MULTICAST_IF* = 9 + IPV6_MULTICAST_HOPS* = 10 + IPV6_MULTICAST_LOOP* = 11 + IPV6_ADD_MEMBERSHIP* = 12 + IPV6_JOIN_GROUP* = IPV6_ADD_MEMBERSHIP + IPV6_DROP_MEMBERSHIP* = 13 + IPV6_LEAVE_GROUP* = IPV6_DROP_MEMBERSHIP + IPV6_DONTFRAG* = 14 + IPV6_PKTINFO* = 19 + IPV6_HOPLIMIT* = 21 + IPV6_PROTECTION_LEVEL* = 23 + IPV6_RECVIF* = 24 + IPV6_RECVDSTADDR* = 25 + IPV6_CHECKSUM* = 26 + IPV6_V6ONLY* = 27 + IPV6_IFLIST* = 28 + IPV6_ADD_IFLIST* = 29 + IPV6_DEL_IFLIST* = 30 + IPV6_UNICAST_IF* = 31 + IPV6_RTHDR* = 32 + IPV6_RECVRTHDR* = 38 + IPV6_TCLASS* = 39 + IPV6_RECVTCLASS* = 40 + IP_OPTIONS* = 1 + IP_HDRINCL* = 2 + IP_TOS* = 3 + IP_TTL* = 4 + IP_MULTICAST_IF* = 9 + IP_MULTICAST_TTL* = 10 + IP_MULTICAST_LOOP* = 11 + IP_ADD_MEMBERSHIP* = 12 + IP_DROP_MEMBERSHIP* = 13 + IP_DONTFRAGMENT* = 14 + IP_ADD_SOURCE_MEMBERSHIP* = 15 + IP_DROP_SOURCE_MEMBERSHIP* = 16 + IP_BLOCK_SOURCE* = 17 + IP_UNBLOCK_SOURCE* = 18 + IP_PKTINFO* = 19 + IP_RECEIVE_BROADCAST* = 22 + PROTECTION_LEVEL_UNRESTRICTED* = 10 + PROTECTION_LEVEL_DEFAULT* = 20 + PROTECTION_LEVEL_RESTRICTED* = 30 + UDP_NOCHECKSUM* = 1 + UDP_CHECKSUM_COVERAGE* = 20 + TCP_EXPEDITED_1122* = 0x0002 + IFF_UP* = 0x00000001 + IFF_BROADCAST* = 0x00000002 + IFF_LOOPBACK* = 0x00000004 + IFF_POINTTOPOINT* = 0x00000008 + IFF_MULTICAST* = 0x00000010 + EAI_AGAIN* = WSATRY_AGAIN + EAI_BADFLAGS* = WSAEINVAL + EAI_FAIL* = WSANO_RECOVERY + EAI_FAMILY* = WSAEAFNOSUPPORT + EAI_MEMORY* = WSA_NOT_ENOUGH_MEMORY + EAI_NONAME* = WSAHOST_NOT_FOUND + EAI_SERVICE* = WSATYPE_NOT_FOUND + EAI_SOCKTYPE* = WSAESOCKTNOSUPPORT + EAI_NODATA* = 11004 + AI_PASSIVE* = 0x00000001 + AI_CANONNAME* = 0x00000002 + AI_NUMERICHOST* = 0x00000004 + AI_NUMERICSERV* = 0x00000008 + AI_ALL* = 0x00000100 + AI_ADDRCONFIG* = 0x00000400 + AI_V4MAPPED* = 0x00000800 + AI_NON_AUTHORITATIVE* = 0x00004000 + AI_SECURE* = 0x00008000 + AI_RETURN_PREFERRED_NAMES* = 0x00010000 + AI_FQDN* = 0x00020000 + AI_FILESERVER* = 0x00040000 + AI_DISABLE_IDN_ENCODING* = 0x00080000 + GAI_STRERROR_BUFFER_SIZE* = 1024 + NI_MAXHOST* = 1025 + NI_MAXSERV* = 32 + INET_ADDRSTRLEN* = 22 + INET6_ADDRSTRLEN* = 65 + NI_NOFQDN* = 0x01 + NI_NUMERICHOST* = 0x02 + NI_NAMEREQD* = 0x04 + NI_NUMERICSERV* = 0x08 + NI_DGRAM* = 0x10 + RCVALL_OFF* = 0 + RCVALL_ON* = 1 + RCVALL_SOCKETLEVELONLY* = 2 + RCVALL_IPLEVEL* = 3 + SOCKET_SECURITY_PROTOCOL_DEFAULT* = 0 + SOCKET_SECURITY_PROTOCOL_IPSEC* = 1 + SOCKET_SECURITY_PROTOCOL_IPSEC2* = 2 + SOCKET_SECURITY_PROTOCOL_INVALID* = 3 + SOCKET_SETTINGS_GUARANTEE_ENCRYPTION* = 0x1 + SOCKET_SETTINGS_ALLOW_INSECURE* = 0x2 + SYSTEM_CRITICAL_SOCKET* = 1 + SOCKET_INFO_CONNECTION_SECURED* = 0x00000001 + SOCKET_INFO_CONNECTION_ENCRYPTED* = 0x00000002 + SOCKET_INFO_CONNECTION_IMPERSONATED* = 0x00000004 + SOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATION* = 0x00000001 + SO_CONNDATA* = 0x7000 + SO_CONNOPT* = 0x7001 + SO_DISCDATA* = 0x7002 + SO_DISCOPT* = 0x7003 + SO_CONNDATALEN* = 0x7004 + SO_CONNOPTLEN* = 0x7005 + SO_DISCDATALEN* = 0x7006 + SO_DISCOPTLEN* = 0x7007 + SO_OPENTYPE* = 0x7008 + SO_SYNCHRONOUS_ALERT* = 0x10 + SO_SYNCHRONOUS_NONALERT* = 0x20 + SO_MAXDG* = 0x7009 + SO_MAXPATHDG* = 0x700A + SO_UPDATE_ACCEPT_CONTEXT* = 0x700B + SO_CONNECT_TIME* = 0x700C + SO_UPDATE_CONNECT_CONTEXT* = 0x7010 + TCP_BSDURGENT* = 0x7000 + TF_DISCONNECT* = 0x01 + TF_REUSE_SOCKET* = 0x02 + TF_WRITE_BEHIND* = 0x04 + TF_USE_DEFAULT_WORKER* = 0x00 + TF_USE_SYSTEM_THREAD* = 0x10 + TF_USE_KERNEL_APC* = 0x20 + TP_DISCONNECT* = TF_DISCONNECT + TP_REUSE_SOCKET* = TF_REUSE_SOCKET + TP_USE_DEFAULT_WORKER* = TF_USE_DEFAULT_WORKER + TP_USE_SYSTEM_THREAD* = TF_USE_SYSTEM_THREAD + TP_USE_KERNEL_APC* = TF_USE_KERNEL_APC + DE_REUSE_SOCKET* = TF_REUSE_SOCKET + NLA_ALLUSERS_NETWORK* = 0x00000001 + NLA_FRIENDLY_NAME* = 0x00000002 + NLA_RAW_DATA* = 0 + NLA_INTERFACE* = 1 + NLA_802_1X_LOCATION* = 2 + NLA_CONNECTIVITY* = 3 + NLA_ICS* = 4 + NLA_NETWORK_AD_HOC* = 0 + NLA_NETWORK_MANAGED* = 1 + NLA_NETWORK_UNMANAGED* = 2 + NLA_NETWORK_UNKNOWN* = 3 + NLA_INTERNET_UNKNOWN* = 0 + NLA_INTERNET_NO* = 1 + NLA_INTERNET_YES* = 2 + MSG_TRUNC* = 0x0100 + MSG_CTRUNC* = 0x0200 + MSG_BCAST* = 0x0400 + MSG_MCAST* = 0x0800 + FIOASYNC* = 0x8004667D'i32 + FIONBIO* = 0x8004667E'i32 + FIONREAD* = 0x4004667F + SIOCATMARK* = 0x40047307 + SIOCGHIWAT* = 0x40047301 + SIOCGLOWAT* = 0x40047303 + SIOCSHIWAT* = 0x80047300'i32 + SIOCSLOWAT* = 0x80047302'i32 + SO_DONTLINGER* = -129 + SO_EXCLUSIVEADDRUSE* = -5 + SIO_GET_INTERFACE_LIST* = 0x4004747F + SIO_GET_INTERFACE_LIST_EX* = 0x4004747E + SIO_GET_MULTICAST_FILTER* = 0x8004747C'i32 + SIO_SET_MULTICAST_FILTER* = 0x8004747D'i32 + SIO_ASSOCIATE_HANDLE* = 0x88000001'i32 + SIO_ENABLE_CIRCULAR_QUEUEING* = 0x28000002 + SIO_FIND_ROUTE* = 0x48000003 + SIO_FLUSH* = 0x28000004 + SIO_GET_BROADCAST_ADDRESS* = 0x48000005 + SIO_GET_EXTENSION_FUNCTION_POINTER* = 0xC8000006'i32 + SIO_GET_QOS* = 0xC8000007'i32 + SIO_GET_GROUP_QOS* = 0xC8000008'i32 + SIO_MULTIPOINT_LOOPBACK* = 0x88000009'i32 + SIO_MULTICAST_SCOPE* = 0x8800000A'i32 + SIO_SET_QOS* = 0x8800000B'i32 + SIO_SET_GROUP_QOS* = 0x8800000C'i32 + SIO_TRANSLATE_HANDLE* = 0xC800000D'i32 + SIO_ROUTING_INTERFACE_QUERY* = 0xC8000014'i32 + SIO_ROUTING_INTERFACE_CHANGE* = 0x88000015'i32 + SIO_ADDRESS_LIST_QUERY* = 0x48000016 + SIO_ADDRESS_LIST_CHANGE* = 0x28000017 + SIO_QUERY_TARGET_PNP_HANDLE* = 0x48000018 + SIO_ADDRESS_LIST_SORT* = 0xC8000019'i32 + SIO_NSP_NOTIFY_CHANGE* = 0x88000019'i32 + SIO_RCVALL* = 0x98000001'i32 + SIO_RCVALL_MCAST* = 0x98000002'i32 + SIO_RCVALL_IGMPMCAST* = 0x98000003'i32 + SIO_KEEPALIVE_VALS* = 0x98000004'i32 + SIO_ABSORB_RTRALERT* = 0x98000005'i32 + SIO_UCAST_IF* = 0x98000006'i32 + SIO_LIMIT_BROADCASTS* = 0x98000007'i32 + SIO_INDEX_BIND* = 0x98000008'i32 + SIO_INDEX_MCASTIF* = 0x98000009'i32 + SIO_INDEX_ADD_MCAST* = 0x9800000A'i32 + SIO_INDEX_DEL_MCAST* = 0x9800000B'i32 + SIO_UDP_CONNRESET* = 0x9800000c'i32 + SIO_SOCKET_CLOSE_NOTIFY* = 0x9800000d'i32 + SIO_BSP_HANDLE* = 0x4800001b'i32 + SIO_BSP_HANDLE_SELECT* = 0x4800001c'i32 + SIO_BSP_HANDLE_POLL* = 0x4800001d'i32 + SIO_EXT_SELECT* = 0xc800001e'i32 + SIO_EXT_POLL* = 0xc800001f'i32 + SIO_EXT_SENDMSG* = 0xc8000020'i32 + SIO_BASE_HANDLE* = 0x48000022'i32 + INVALID_SOCKET* = SOCKET(-1) + WSA_INVALID_EVENT* = WSAEVENT 0 + IN6ADDR_ANY_INIT* = IN6_ADDR(Byte: [0'u8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]) + IN6ADDR_LOOPBACK_INIT* = IN6_ADDR(Byte: [0'u8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]) + WSAID_TRANSMITFILE* = DEFINE_GUID(0xb5367df0'i32, 0xcbac, 0x11cf, [0x95'u8, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92]) + WSAID_ACCEPTEX* = DEFINE_GUID(0xb5367df1'i32, 0xcbac, 0x11cf, [0x95'u8, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92]) + WSAID_GETACCEPTEXSOCKADDRS* = DEFINE_GUID(0xb5367df2'i32, 0xcbac, 0x11cf, [0x95'u8, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92]) + WSAID_TRANSMITPACKETS* = DEFINE_GUID(0xd9689da0'i32, 0x1f90, 0x11d3, [0x99'u8, 0x71, 0x00, 0xc0, 0x4f, 0x68, 0xc8, 0x76]) + WSAID_CONNECTEX* = DEFINE_GUID(0x25a207b9'i32, 0xddf3, 0x4660, [0x8e'u8, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e]) + WSAID_DISCONNECTEX* = DEFINE_GUID(0x7fda2e11'i32, 0x8630, 0x436f, [0xa0'u8, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57]) + NLA_NAMESPACE_GUID* = DEFINE_GUID(0x6642243a'i32, 0x3ba8, 0x4aa6, [0xba'u8, 0xa5, 0x2e, 0xb, 0xd7, 0x1f, 0xdd, 0x83]) + NLA_SERVICE_CLASS_GUID* = DEFINE_GUID(0x37e515'i32, 0xb5c9, 0x4a43, [0xba'u8, 0xda, 0x8b, 0x48, 0xa8, 0x7a, 0xd2, 0x39]) + WSAID_WSARECVMSG* = DEFINE_GUID(0xf689d7c8'i32, 0x6f1f, 0x436b, [0x8a'u8, 0x53, 0xe5, 0x4f, 0xe3, 0x51, 0xc3, 0x22]) + WSAID_WSAPOLL* = DEFINE_GUID(0x18C76F85'i32, 0xDC66, 0x4964, [0x97'u8, 0x2E, 0x23, 0xC2, 0x72, 0x38, 0x31, 0x2B]) + WSAID_WSASENDMSG* = DEFINE_GUID(0xa441e712'i32, 0x754f, 0x43ca, [0x84'u8, 0xa7, 0x0d, 0xee, 0x44, 0xcf, 0x60, 0x6d]) +type + LPCONDITIONPROC* = proc (lpCallerId: LPWSABUF, lpCallerData: LPWSABUF, lpSQOS: LPQOS, lpGQOS: LPQOS, lpCalleeId: LPWSABUF, lpCalleeData: LPWSABUF, g: ptr GROUP, dwCallbackData: DWORD_PTR): int32 {.stdcall.} + LPFN_ACCEPT* = proc (s: SOCKET, `addr`: ptr sockaddr, addrlen: ptr int32): SOCKET {.stdcall.} + LPFN_BIND* = proc (s: SOCKET, name: ptr sockaddr, namelen: int32): int32 {.stdcall.} + LPFN_CLOSESOCKET* = proc (s: SOCKET): int32 {.stdcall.} + LPFN_CONNECT* = proc (s: SOCKET, name: ptr sockaddr, namelen: int32): int32 {.stdcall.} + LPFN_IOCTLSOCKET* = proc (s: SOCKET, cmd: int32, argp: ptr int32): int32 {.stdcall.} + LPFN_GETPEERNAME* = proc (s: SOCKET, name: ptr sockaddr, namelen: ptr int32): int32 {.stdcall.} + LPFN_GETSOCKNAME* = proc (s: SOCKET, name: ptr sockaddr, namelen: ptr int32): int32 {.stdcall.} + LPFN_GETSOCKOPT* = proc (s: SOCKET, level: int32, optname: int32, optval: ptr char, optlen: ptr int32): int32 {.stdcall.} + LPFN_HTONL* = proc (hostlong: int32): int32 {.stdcall.} + LPFN_HTONS* = proc (hostshort: uint16): uint16 {.stdcall.} + LPFN_INET_ADDR* = proc (cp: ptr char): int32 {.stdcall.} + LPFN_INET_NTOA* = proc (`in`: IN_ADDR): ptr char {.stdcall.} + LPFN_LISTEN* = proc (s: SOCKET, backlog: int32): int32 {.stdcall.} + LPFN_NTOHL* = proc (netlong: int32): int32 {.stdcall.} + LPFN_NTOHS* = proc (netshort: uint16): uint16 {.stdcall.} + LPFN_RECV* = proc (s: SOCKET, buf: ptr char, len: int32, flags: int32): int32 {.stdcall.} + LPFN_RECVFROM* = proc (s: SOCKET, buf: ptr char, len: int32, flags: int32, `from`: ptr sockaddr, fromlen: ptr int32): int32 {.stdcall.} + LPFN_SELECT* = proc (nfds: int32, readfds: ptr fd_set, writefds: ptr fd_set, exceptfds: ptr fd_set, timeout: PTIMEVAL): int32 {.stdcall.} + LPFN_SEND* = proc (s: SOCKET, buf: ptr char, len: int32, flags: int32): int32 {.stdcall.} + LPFN_SENDTO* = proc (s: SOCKET, buf: ptr char, len: int32, flags: int32, to: ptr sockaddr, tolen: int32): int32 {.stdcall.} + LPFN_SETSOCKOPT* = proc (s: SOCKET, level: int32, optname: int32, optval: ptr char, optlen: int32): int32 {.stdcall.} + LPFN_SHUTDOWN* = proc (s: SOCKET, how: int32): int32 {.stdcall.} + LPFN_SOCKET* = proc (af: int32, `type`: int32, protocol: int32): SOCKET {.stdcall.} + LPFN_GETHOSTBYADDR* = proc (`addr`: ptr char, len: int32, `type`: int32): ptr hostent {.stdcall.} + LPFN_GETHOSTBYNAME* = proc (name: ptr char): ptr hostent {.stdcall.} + LPFN_GETHOSTNAME* = proc (name: ptr char, namelen: int32): int32 {.stdcall.} + LPFN_GETSERVBYPORT* = proc (port: int32, proto: ptr char): ptr servent {.stdcall.} + LPFN_GETSERVBYNAME* = proc (name: ptr char, proto: ptr char): ptr servent {.stdcall.} + LPFN_GETPROTOBYNUMBER* = proc (number: int32): ptr protoent {.stdcall.} + LPFN_GETPROTOBYNAME* = proc (name: ptr char): ptr protoent {.stdcall.} + LPFN_WSASTARTUP* = proc (wVersionRequested: WORD, lpWSAData: LPWSADATA): int32 {.stdcall.} + LPFN_WSACLEANUP* = proc (): int32 {.stdcall.} + LPFN_WSASETLASTERROR* = proc (iError: int32): void {.stdcall.} + LPFN_WSAGETLASTERROR* = proc (): int32 {.stdcall.} + LPFN_WSAISBLOCKING* = proc (): WINBOOL {.stdcall.} + LPFN_WSAUNHOOKBLOCKINGHOOK* = proc (): int32 {.stdcall.} + LPFN_WSASETBLOCKINGHOOK* = proc (lpBlockFunc: FARPROC): FARPROC {.stdcall.} + LPFN_WSACANCELBLOCKINGCALL* = proc (): int32 {.stdcall.} + LPFN_WSAASYNCGETSERVBYNAME* = proc (hWnd: HWND, wMsg: int32, name: ptr char, proto: ptr char, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSAASYNCGETSERVBYPORT* = proc (hWnd: HWND, wMsg: int32, port: int32, proto: ptr char, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSAASYNCGETPROTOBYNAME* = proc (hWnd: HWND, wMsg: int32, name: ptr char, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSAASYNCGETPROTOBYNUMBER* = proc (hWnd: HWND, wMsg: int32, number: int32, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSAASYNCGETHOSTBYNAME* = proc (hWnd: HWND, wMsg: int32, name: ptr char, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSAASYNCGETHOSTBYADDR* = proc (hWnd: HWND, wMsg: int32, `addr`: ptr char, len: int32, `type`: int32, buf: ptr char, buflen: int32): HANDLE {.stdcall.} + LPFN_WSACANCELASYNCREQUEST* = proc (hAsyncTaskHandle: HANDLE): int32 {.stdcall.} + LPFN_WSAASYNCSELECT* = proc (s: SOCKET, hWnd: HWND, wMsg: int32, lEvent: int32): int32 {.stdcall.} + LPFN_WSAACCEPT* = proc (s: SOCKET, `addr`: ptr sockaddr, addrlen: LPINT, lpfnCondition: LPCONDITIONPROC, dwCallbackData: DWORD_PTR): SOCKET {.stdcall.} + LPFN_WSACLOSEEVENT* = proc (hEvent: WSAEVENT): WINBOOL {.stdcall.} + LPFN_WSACONNECT* = proc (s: SOCKET, name: ptr sockaddr, namelen: int32, lpCallerData: LPWSABUF, lpCalleeData: LPWSABUF, lpSQOS: LPQOS, lpGQOS: LPQOS): int32 {.stdcall.} + LPFN_WSACREATEEVENT* = proc (): WSAEVENT {.stdcall.} + LPFN_WSADUPLICATESOCKETA* = proc (s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA): int32 {.stdcall.} + LPFN_WSADUPLICATESOCKETW* = proc (s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW): int32 {.stdcall.} + LPFN_WSAENUMNETWORKEVENTS* = proc (s: SOCKET, hEventObject: WSAEVENT, lpNetworkEvents: LPWSANETWORKEVENTS): int32 {.stdcall.} + LPFN_WSAENUMPROTOCOLSA* = proc (lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOA, lpdwBufferLength: LPDWORD): int32 {.stdcall.} + LPFN_WSAENUMPROTOCOLSW* = proc (lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOW, lpdwBufferLength: LPDWORD): int32 {.stdcall.} + LPFN_WSAEVENTSELECT* = proc (s: SOCKET, hEventObject: WSAEVENT, lNetworkEvents: int32): int32 {.stdcall.} + LPFN_WSAGETOVERLAPPEDRESULT* = proc (s: SOCKET, lpOverlapped: LPWSAOVERLAPPED, lpcbTransfer: LPDWORD, fWait: WINBOOL, lpdwFlags: LPDWORD): WINBOOL {.stdcall.} + LPFN_WSAGETQOSBYNAME* = proc (s: SOCKET, lpQOSName: LPWSABUF, lpQOS: LPQOS): WINBOOL {.stdcall.} + LPFN_WSAHTONL* = proc (s: SOCKET, hostlong: int32, lpnetlong: ptr int32): int32 {.stdcall.} + LPFN_WSAHTONS* = proc (s: SOCKET, hostshort: uint16, lpnetshort: ptr uint16): int32 {.stdcall.} + LPFN_WSAIOCTL* = proc (s: SOCKET, dwIoControlCode: DWORD, lpvInBuffer: LPVOID, cbInBuffer: DWORD, lpvOutBuffer: LPVOID, cbOutBuffer: DWORD, lpcbBytesReturned: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.stdcall.} + LPFN_WSAJOINLEAF* = proc (s: SOCKET, name: ptr sockaddr, namelen: int32, lpCallerData: LPWSABUF, lpCalleeData: LPWSABUF, lpSQOS: LPQOS, lpGQOS: LPQOS, dwFlags: DWORD): SOCKET {.stdcall.} + LPFN_WSANTOHL* = proc (s: SOCKET, netlong: int32, lphostlong: ptr int32): int32 {.stdcall.} + LPFN_WSANTOHS* = proc (s: SOCKET, netshort: uint16, lphostshort: ptr uint16): int32 {.stdcall.} + LPFN_WSARECV* = proc (s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesRecvd: LPDWORD, lpFlags: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.stdcall.} + LPFN_WSARECVDISCONNECT* = proc (s: SOCKET, lpInboundDisconnectData: LPWSABUF): int32 {.stdcall.} + LPFN_WSARECVFROM* = proc (s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesRecvd: LPDWORD, lpFlags: LPDWORD, lpFrom: ptr sockaddr, lpFromlen: LPINT, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.stdcall.} + LPFN_WSARESETEVENT* = proc (hEvent: WSAEVENT): WINBOOL {.stdcall.} + LPFN_WSASEND* = proc (s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesSent: LPDWORD, dwFlags: DWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.stdcall.} + LPFN_WSASENDDISCONNECT* = proc (s: SOCKET, lpOutboundDisconnectData: LPWSABUF): int32 {.stdcall.} + LPFN_WSASENDTO* = proc (s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesSent: LPDWORD, dwFlags: DWORD, lpTo: ptr sockaddr, iTolen: int32, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.stdcall.} + LPFN_WSASETEVENT* = proc (hEvent: WSAEVENT): WINBOOL {.stdcall.} + LPFN_WSASOCKETA* = proc (af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOA, g: GROUP, dwFlags: DWORD): SOCKET {.stdcall.} + LPFN_WSASOCKETW* = proc (af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOW, g: GROUP, dwFlags: DWORD): SOCKET {.stdcall.} + LPFN_WSAWAITFORMULTIPLEEVENTS* = proc (cEvents: DWORD, lphEvents: ptr WSAEVENT, fWaitAll: WINBOOL, dwTimeout: DWORD, fAlertable: WINBOOL): DWORD {.stdcall.} + LPFN_WSAADDRESSTOSTRINGA* = proc (lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpszAddressString: LPSTR, lpdwAddressStringLength: LPDWORD): INT {.stdcall.} + LPFN_WSAADDRESSTOSTRINGW* = proc (lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpszAddressString: LPWSTR, lpdwAddressStringLength: LPDWORD): INT {.stdcall.} + LPFN_WSASTRINGTOADDRESSA* = proc (AddressString: LPSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.stdcall.} + LPFN_WSASTRINGTOADDRESSW* = proc (AddressString: LPWSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.stdcall.} + LPFN_WSALOOKUPSERVICEBEGINA* = proc (lpqsRestrictions: LPWSAQUERYSETA, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.stdcall.} + LPFN_WSALOOKUPSERVICEBEGINW* = proc (lpqsRestrictions: LPWSAQUERYSETW, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.stdcall.} + LPFN_WSALOOKUPSERVICENEXTA* = proc (hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETA): INT {.stdcall.} + LPFN_WSALOOKUPSERVICENEXTW* = proc (hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETW): INT {.stdcall.} + LPFN_WSANSPIOCTL* = proc (hLookup: HANDLE, dwControlCode: DWORD, lpvInBuffer: LPVOID, cbInBuffer: DWORD, lpvOutBuffer: LPVOID, cbOutBuffer: DWORD, lpcbBytesReturned: LPDWORD, lpCompletion: LPWSACOMPLETION): INT {.stdcall.} + LPFN_WSALOOKUPSERVICEEND* = proc (hLookup: HANDLE): INT {.stdcall.} + LPFN_WSAINSTALLSERVICECLASSA* = proc (lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.stdcall.} + LPFN_WSAINSTALLSERVICECLASSW* = proc (lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.stdcall.} + LPFN_WSAREMOVESERVICECLASS* = proc (lpServiceClassId: LPGUID): INT {.stdcall.} + LPFN_WSAGETSERVICECLASSINFOA* = proc (lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.stdcall.} + LPFN_WSAGETSERVICECLASSINFOW* = proc (lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.stdcall.} + LPFN_WSAENUMNAMESPACEPROVIDERSA* = proc (lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOA): INT {.stdcall.} + LPFN_WSAENUMNAMESPACEPROVIDERSW* = proc (lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOW): INT {.stdcall.} + LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA* = proc (lpServiceClassId: LPGUID, lpszServiceClassName: LPSTR, lpdwBufferLength: LPDWORD): INT {.stdcall.} + LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW* = proc (lpServiceClassId: LPGUID, lpszServiceClassName: LPWSTR, lpdwBufferLength: LPDWORD): INT {.stdcall.} + LPFN_WSASETSERVICEA* = proc (lpqsRegInfo: LPWSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.stdcall.} + LPFN_WSASETSERVICEW* = proc (lpqsRegInfo: LPWSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.stdcall.} + LPFN_WSAPROVIDERCONFIGCHANGE* = proc (lpNotificationHandle: LPHANDLE, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): INT {.stdcall.} + LPFN_GETADDRINFOW* = proc (pNodeName: PCWSTR, pServiceName: PCWSTR, pHints: ptr ADDRINFOW, ppResult: ptr PADDRINFOW): int32 {.stdcall.} + LPFN_FREEADDRINFOW* = proc (pAddrInfo: PADDRINFOW): void {.stdcall.} + LPFN_GETNAMEINFOW* = proc (pSockaddr: ptr SOCKADDR, SockaddrLength: socklen_t, pNodeBuffer: PWCHAR, NodeBufferSize: DWORD, pServiceBuffer: PWCHAR, ServiceBufferSize: DWORD, Flags: INT): INT {.stdcall.} + LPFN_GETADDRINFOEXA* = proc (pName: PCSTR, pServiceName: PCSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXA, ppResult: ptr PADDRINFOEXA, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.stdcall.} + LPFN_GETADDRINFOEXW* = proc (pName: PCWSTR, pServiceName: PCWSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXW, ppResult: ptr PADDRINFOEXW, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.stdcall.} + LPFN_SETADDRINFOEXA* = proc (pName: PCSTR, pServiceName: PCSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.stdcall.} + LPFN_SETADDRINFOEXW* = proc (pName: PCWSTR, pServiceName: PCWSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.stdcall.} + LPFN_FREEADDRINFOEXA* = proc (pAddrInfo: PADDRINFOEXA): void {.stdcall.} + LPFN_FREEADDRINFOEXW* = proc (pAddrInfo: PADDRINFOEXW): void {.stdcall.} + LPFN_TRANSMITFILE* = proc (hSocket: SOCKET, hFile: HANDLE, nNumberOfBytesToWrite: DWORD, nNumberOfBytesPerSend: DWORD, lpOverlapped: LPOVERLAPPED, lpTransmitBuffers: LPTRANSMIT_FILE_BUFFERS, dwReserved: DWORD): WINBOOL {.stdcall.} + LPFN_ACCEPTEX* = proc (sListenSocket: SOCKET, sAcceptSocket: SOCKET, lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, lpdwBytesReceived: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.stdcall.} + LPFN_GETACCEPTEXSOCKADDRS* = proc (lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, LocalSockaddr: ptr ptr sockaddr, LocalSockaddrLength: LPINT, RemoteSockaddr: ptr ptr sockaddr, RemoteSockaddrLength: LPINT): VOID {.stdcall.} + LPFN_TRANSMITPACKETS* = proc (hSocket: SOCKET, lpPacketArray: LPTRANSMIT_PACKETS_ELEMENT, nElementCount: DWORD, nSendSize: DWORD, lpOverlapped: LPOVERLAPPED, dwFlags: DWORD): WINBOOL {.stdcall.} + LPFN_CONNECTEX* = proc (s: SOCKET, name: ptr sockaddr, namelen: int32, lpSendBuffer: PVOID, dwSendDataLength: DWORD, lpdwBytesSent: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.stdcall.} + LPFN_DISCONNECTEX* = proc (s: SOCKET, lpOverlapped: LPOVERLAPPED, dwFlags: DWORD, dwReserved: DWORD): WINBOOL {.stdcall.} + LPFN_WSARECVMSG* = proc (s: SOCKET, lpMsg: LPWSAMSG, lpdwNumberOfBytesRecvd: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): INT {.stdcall.} + LPFN_WSAPOLL* = proc (fdarray: LPWSAPOLLFD, nfds: ULONG, timeout: INT): INT {.stdcall.} + LPFN_WSASENDMSG* = proc (s: SOCKET, lpMsg: LPWSAMSG, dwFlags: DWORD, lpNumberOfBytesSent: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): INT {.stdcall.} + netent* {.pure.} = object + n_name*: ptr char + n_aliases*: ptr ptr char + n_addrtype*: int16 + n_net*: int32 + sockproto* {.pure.} = object + sp_family*: uint16 + sp_protocol*: uint16 + IPV6_MREQ* {.pure.} = object + ipv6mr_multiaddr*: IN6_ADDR + ipv6mr_interface*: int32 + ip_mreq* {.pure.} = object + imr_multiaddr*: IN_ADDR + imr_interface*: IN_ADDR + ip_mreq_source* {.pure.} = object + imr_multiaddr*: IN_ADDR + imr_sourceaddr*: IN_ADDR + imr_interface*: IN_ADDR + ip_msfilter* {.pure.} = object + imsf_multiaddr*: IN_ADDR + imsf_interface*: IN_ADDR + imsf_fmode*: int32 + imsf_numsrc*: int32 + imsf_slist*: array[1, IN_ADDR] + IN_PKTINFO* {.pure.} = object + ipi_addr*: IN_ADDR + ipi_ifindex*: UINT + IN6_PKTINFO* {.pure.} = object + ipi6_addr*: IN6_ADDR + ipi6_ifindex*: UINT + tcp_keepalive* {.pure.} = object + onoff*: int32 + keepalivetime*: int32 + keepaliveinterval*: int32 + SOCKET_PEER_TARGET_NAME* {.pure.} = object + SecurityProtocol*: SOCKET_SECURITY_PROTOCOL + PeerAddress*: SOCKADDR_STORAGE + PeerTargetNameStringLen*: ULONG + AllStrings*: UncheckedArray[uint16] + SOCKET_SECURITY_QUERY_INFO* {.pure.} = object + SecurityProtocol*: SOCKET_SECURITY_PROTOCOL + Flags*: ULONG + PeerApplicationAccessTokenHandle*: UINT64 + PeerMachineAccessTokenHandle*: UINT64 + SOCKET_SECURITY_QUERY_TEMPLATE* {.pure.} = object + SecurityProtocol*: SOCKET_SECURITY_PROTOCOL + PeerAddress*: SOCKADDR_STORAGE + PeerTokenAccessMask*: ULONG + SOCKET_SECURITY_SETTINGS* {.pure.} = object + SecurityProtocol*: SOCKET_SECURITY_PROTOCOL + SecurityFlags*: ULONG + SOCKET_SECURITY_SETTINGS_IPSEC* {.pure.} = object + SecurityProtocol*: SOCKET_SECURITY_PROTOCOL + SecurityFlags*: ULONG + IpsecFlags*: ULONG + AuthipMMPolicyKey*: GUID + AuthipQMPolicyKey*: GUID + Reserved*: GUID + Reserved2*: UINT64 + UserNameStringLen*: ULONG + DomainNameStringLen*: ULONG + PasswordStringLen*: ULONG + AllStrings*: UncheckedArray[uint16] +proc WSAFDIsSet*(P1: SOCKET, P2: ptr fd_set): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "__WSAFDIsSet".} +proc accept*(s: SOCKET, `addr`: ptr sockaddr, addrlen: ptr int32): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc `bind`*(s: SOCKET, name: ptr sockaddr, namelen: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc closesocket*(s: SOCKET): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc connect*(s: SOCKET, name: ptr sockaddr, namelen: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc ioctlsocket*(s: SOCKET, cmd: int32, argp: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getpeername*(s: SOCKET, name: ptr sockaddr, namelen: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getsockname*(s: SOCKET, name: ptr sockaddr, namelen: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getsockopt*(s: SOCKET, level: int32, optname: int32, optval: ptr char, optlen: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc htonl*(hostlong: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc htons*(hostshort: uint16): uint16 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc inet_addr*(cp: ptr char): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc inet_ntoa*(`in`: IN_ADDR): ptr char {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc listen*(s: SOCKET, backlog: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc ntohl*(netlong: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc ntohs*(netshort: uint16): uint16 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc recv*(s: SOCKET, buf: ptr char, len: int32, flags: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc recvfrom*(s: SOCKET, buf: ptr char, len: int32, flags: int32, `from`: ptr sockaddr, fromlen: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc select*(nfds: int32, readfds: ptr fd_set, writefds: ptr fd_set, exceptfds: ptr fd_set, timeout: PTIMEVAL): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc send*(s: SOCKET, buf: ptr char, len: int32, flags: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc sendto*(s: SOCKET, buf: ptr char, len: int32, flags: int32, to: ptr sockaddr, tolen: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc setsockopt*(s: SOCKET, level: int32, optname: int32, optval: ptr char, optlen: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc shutdown*(s: SOCKET, how: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc socket*(af: int32, `type`: int32, protocol: int32): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc gethostbyaddr*(`addr`: ptr char, len: int32, `type`: int32): ptr hostent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc gethostbyname*(name: ptr char): ptr hostent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc gethostname*(name: ptr char, namelen: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getservbyport*(port: int32, proto: ptr char): ptr servent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getservbyname*(name: ptr char, proto: ptr char): ptr servent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getprotobynumber*(number: int32): ptr protoent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getprotobyname*(name: ptr char): ptr protoent {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAStartup*(wVersionRequested: WORD, lpWSAData: LPWSADATA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSACleanup*(): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASetLastError*(iError: int32): void {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetLastError*(): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAIsBlocking*(): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAUnhookBlockingHook*(): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASetBlockingHook*(lpBlockFunc: FARPROC): FARPROC {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSACancelBlockingCall*(): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetServByName*(hWnd: HWND, wMsg: int32, name: ptr char, proto: ptr char, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetServByPort*(hWnd: HWND, wMsg: int32, port: int32, proto: ptr char, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetProtoByName*(hWnd: HWND, wMsg: int32, name: ptr char, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetProtoByNumber*(hWnd: HWND, wMsg: int32, number: int32, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetHostByName*(hWnd: HWND, wMsg: int32, name: ptr char, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncGetHostByAddr*(hWnd: HWND, wMsg: int32, `addr`: ptr char, len: int32, `type`: int32, buf: ptr char, buflen: int32): HANDLE {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSACancelAsyncRequest*(hAsyncTaskHandle: HANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAsyncSelect*(s: SOCKET, hWnd: HWND, wMsg: int32, lEvent: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAccept*(s: SOCKET, `addr`: ptr sockaddr, addrlen: LPINT, lpfnCondition: LPCONDITIONPROC, dwCallbackData: DWORD_PTR): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSACloseEvent*(hEvent: WSAEVENT): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAConnect*(s: SOCKET, name: ptr sockaddr, namelen: int32, lpCallerData: LPWSABUF, lpCalleeData: LPWSABUF, lpSQOS: LPQOS, lpGQOS: LPQOS): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSACreateEvent*(): WSAEVENT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSADuplicateSocketA*(s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSADuplicateSocketW*(s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumNetworkEvents*(s: SOCKET, hEventObject: WSAEVENT, lpNetworkEvents: LPWSANETWORKEVENTS): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumProtocolsA*(lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOA, lpdwBufferLength: LPDWORD): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumProtocolsW*(lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOW, lpdwBufferLength: LPDWORD): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEventSelect*(s: SOCKET, hEventObject: WSAEVENT, lNetworkEvents: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetOverlappedResult*(s: SOCKET, lpOverlapped: LPWSAOVERLAPPED, lpcbTransfer: LPDWORD, fWait: WINBOOL, lpdwFlags: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetQOSByName*(s: SOCKET, lpQOSName: LPWSABUF, lpQOS: LPQOS): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAHtonl*(s: SOCKET, hostlong: int32, lpnetlong: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAHtons*(s: SOCKET, hostshort: uint16, lpnetshort: ptr uint16): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAIoctl*(s: SOCKET, dwIoControlCode: DWORD, lpvInBuffer: LPVOID, cbInBuffer: DWORD, lpvOutBuffer: LPVOID, cbOutBuffer: DWORD, lpcbBytesReturned: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAJoinLeaf*(s: SOCKET, name: ptr sockaddr, namelen: int32, lpCallerData: LPWSABUF, lpCalleeData: LPWSABUF, lpSQOS: LPQOS, lpGQOS: LPQOS, dwFlags: DWORD): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSANtohl*(s: SOCKET, netlong: int32, lphostlong: ptr int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSANtohs*(s: SOCKET, netshort: uint16, lphostshort: ptr uint16): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSARecv*(s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesRecvd: LPDWORD, lpFlags: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSARecvDisconnect*(s: SOCKET, lpInboundDisconnectData: LPWSABUF): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSARecvFrom*(s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesRecvd: LPDWORD, lpFlags: LPDWORD, lpFrom: ptr sockaddr, lpFromlen: LPINT, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAResetEvent*(hEvent: WSAEVENT): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASend*(s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesSent: LPDWORD, dwFlags: DWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASendDisconnect*(s: SOCKET, lpOutboundDisconnectData: LPWSABUF): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASendTo*(s: SOCKET, lpBuffers: LPWSABUF, dwBufferCount: DWORD, lpNumberOfBytesSent: LPDWORD, dwFlags: DWORD, lpTo: ptr sockaddr, iTolen: int32, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASetEvent*(hEvent: WSAEVENT): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASocketA*(af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOA, g: GROUP, dwFlags: DWORD): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASocketW*(af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOW, g: GROUP, dwFlags: DWORD): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAWaitForMultipleEvents*(cEvents: DWORD, lphEvents: ptr WSAEVENT, fWaitAll: WINBOOL, dwTimeout: DWORD, fAlertable: WINBOOL): DWORD {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAddressToStringA*(lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpszAddressString: LPSTR, lpdwAddressStringLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAAddressToStringW*(lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpszAddressString: LPWSTR, lpdwAddressStringLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAStringToAddressA*(AddressString: LPSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAStringToAddressW*(AddressString: LPWSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSALookupServiceBeginA*(lpqsRestrictions: LPWSAQUERYSETA, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSALookupServiceBeginW*(lpqsRestrictions: LPWSAQUERYSETW, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSALookupServiceNextA*(hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETA): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSALookupServiceNextW*(hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETW): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSANSPIoctl*(hLookup: HANDLE, dwControlCode: DWORD, lpvInBuffer: LPVOID, cbInBuffer: DWORD, lpvOutBuffer: LPVOID, cbOutBuffer: DWORD, lpcbBytesReturned: LPDWORD, lpCompletion: LPWSACOMPLETION): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSALookupServiceEnd*(hLookup: HANDLE): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAInstallServiceClassA*(lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAInstallServiceClassW*(lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSARemoveServiceClass*(lpServiceClassId: LPGUID): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetServiceClassInfoA*(lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetServiceClassInfoW*(lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumNameSpaceProvidersA*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumNameSpaceProvidersW*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetServiceClassNameByClassIdA*(lpServiceClassId: LPGUID, lpszServiceClassName: LPSTR, lpdwBufferLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAGetServiceClassNameByClassIdW*(lpServiceClassId: LPGUID, lpszServiceClassName: LPWSTR, lpdwBufferLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASetServiceA*(lpqsRegInfo: LPWSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASetServiceW*(lpqsRegInfo: LPWSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAProviderConfigChange*(lpNotificationHandle: LPHANDLE, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAConnectByList*(s: SOCKET, SocketAddressList: PSOCKET_ADDRESS_LIST, LocalAddressLength: LPDWORD, LocalAddress: LPSOCKADDR, RemoteAddressLength: LPDWORD, RemoteAddress: LPSOCKADDR, timeout: PTIMEVAL, Reserved: LPWSAOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAConnectByNameA*(s: SOCKET, nodename: LPSTR, servicename: LPSTR, LocalAddressLength: LPDWORD, LocalAddress: LPSOCKADDR, RemoteAddressLength: LPDWORD, RemoteAddress: LPSOCKADDR, timeout: PTIMEVAL, Reserved: LPWSAOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAConnectByNameW*(s: SOCKET, nodename: LPWSTR, servicename: LPWSTR, LocalAddressLength: LPDWORD, LocalAddress: LPSOCKADDR, RemoteAddressLength: LPDWORD, RemoteAddress: LPSOCKADDR, timeout: PTIMEVAL, Reserved: LPWSAOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumNameSpaceProvidersExA*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOEXA): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAEnumNameSpaceProvidersExW*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOEXW): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAPoll*(fdarray: ptr WSAPOLLFD, nfds: ULONG, timeout: INT): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSASendMsg*(s: SOCKET, lpMsg: LPWSAMSG, dwFlags: DWORD, lpNumberOfBytesSent: LPDWORD, lpOverlapped: LPWSAOVERLAPPED, lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc getaddrinfo*(nodename: ptr char, servname: ptr char, hints: ptr ADDRINFOA, res: ptr ptr ADDRINFOA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc GetAddrInfoW*(pNodeName: PCWSTR, pServiceName: PCWSTR, pHints: ptr ADDRINFOW, ppResult: ptr PADDRINFOW): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc GetAddrInfoA*(nodename: ptr char, servname: ptr char, hints: ptr ADDRINFOA, res: ptr ptr ADDRINFOA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "getaddrinfo".} +proc freeaddrinfo*(pAddrInfo: LPADDRINFO): void {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc FreeAddrInfoW*(pAddrInfo: PADDRINFOW): void {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc FreeAddrInfoA*(pAddrInfo: LPADDRINFO): void {.winapi, stdcall, dynlib: "ws2_32", importc: "freeaddrinfo".} +proc getnameinfo*(sa: ptr sockaddr, salen: socklen_t, host: ptr char, hostlen: DWORD, serv: ptr char, servlen: DWORD, flags: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc GetNameInfoW*(pSockaddr: ptr SOCKADDR, SockaddrLength: socklen_t, pNodeBuffer: PWCHAR, NodeBufferSize: DWORD, pServiceBuffer: PWCHAR, ServiceBufferSize: DWORD, Flags: INT): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc GetNameInfoA*(sa: ptr sockaddr, salen: socklen_t, host: ptr char, hostlen: DWORD, serv: ptr char, servlen: DWORD, flags: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "getnameinfo".} +proc RtlIpv6AddressToStringA*(Addr: ptr IN6_ADDR, S: LPSTR): LPSTR {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv6AddressToStringW*(Addr: ptr IN6_ADDR, S: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv6AddressToStringExA*(Address: ptr IN6_ADDR, ScopeId: ULONG, Port: USHORT, AddressString: LPSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv6AddressToStringExW*(Address: ptr IN6_ADDR, ScopeId: ULONG, Port: USHORT, AddressString: LPWSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4AddressToStringA*(Addr: ptr IN_ADDR, S: LPSTR): LPSTR {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4AddressToStringW*(Addr: ptr IN_ADDR, S: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4AddressToStringExA*(Address: ptr IN_ADDR, Port: USHORT, AddressString: LPSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4AddressToStringExW*(Address: ptr IN_ADDR, Port: USHORT, AddressString: LPWSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4StringToAddressA*(S: PCSTR, Strict: BOOLEAN, Terminator: ptr LPSTR, Addr: ptr IN_ADDR): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4StringToAddressW*(S: PCWSTR, Strict: BOOLEAN, Terminator: ptr LPWSTR, Addr: ptr IN_ADDR): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4StringToAddressExA*(AddressString: PCSTR, Strict: BOOLEAN, Address: ptr IN_ADDR, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv4StringToAddressExW*(AddressString: PCWSTR, Strict: BOOLEAN, Address: ptr IN_ADDR, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv6StringToAddressExA*(AddressString: PCSTR, Address: ptr IN6_ADDR, ScopeId: PULONG, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc RtlIpv6StringToAddressExW*(AddressString: PCWSTR, Address: ptr IN6_ADDR, ScopeId: PULONG, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc.} +proc GetAddrInfoExA*(pName: PCSTR, pServiceName: PCSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXA, ppResult: ptr PADDRINFOEXA, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc GetAddrInfoExW*(pName: PCWSTR, pServiceName: PCWSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXW, ppResult: ptr PADDRINFOEXW, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc SetAddrInfoExA*(pName: PCSTR, pServiceName: PCSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc SetAddrInfoExW*(pName: PCWSTR, pServiceName: PCWSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc FreeAddrInfoExW*(pAddrInfo: PADDRINFOEXW): void {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSAImpersonateSocketPeer*(Socket: SOCKET, PeerAddress: ptr sockaddr, peerAddressLen: ULONG): int32 {.winapi, stdcall, dynlib: "fwpuclnt", importc.} +proc WSAQuerySocketSecurity*(Socket: SOCKET, SecurityQueryTemplate: ptr SOCKET_SECURITY_QUERY_TEMPLATE, SecurityQueryTemplateLen: ULONG, SecurityQueryInfo: ptr SOCKET_SECURITY_QUERY_INFO, SecurityQueryInfoLen: ptr ULONG, Overlapped: LPWSAOVERLAPPED, CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "fwpuclnt", importc.} +proc WSARevertImpersonation*(): int32 {.winapi, stdcall, dynlib: "fwpuclnt", importc.} +proc WSASetSocketPeerTargetName*(Socket: SOCKET, PeerTargetName: ptr SOCKET_PEER_TARGET_NAME, PeerTargetNameLen: ULONG, Overlapped: LPWSAOVERLAPPED, CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "fwpuclnt", importc.} +proc WSASetSocketSecurity*(Socket: SOCKET, SecuritySettings: ptr SOCKET_SECURITY_SETTINGS, SecuritySettingsLen: ULONG, Overlapped: LPWSAOVERLAPPED, CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): int32 {.winapi, stdcall, dynlib: "fwpuclnt", importc.} +proc InetNtopW*(Family: INT, pAddr: PVOID, pStringBuf: LPWSTR, StringBufSIze: int): LPCWSTR {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc inet_ntop*(Family: INT, pAddr: PVOID, pStringBuf: LPSTR, StringBufSize: int): LPCSTR {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc InetPtonW*(Family: INT, pStringBuf: LPCWSTR, pAddr: PVOID): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc inet_pton*(Family: INT, pStringBuf: LPCSTR, pAddr: PVOID): INT {.winapi, stdcall, dynlib: "ws2_32", importc.} +proc WSARecvEx*(s: SOCKET, buf: ptr char, len: int32, flags: ptr int32): int32 {.winapi, stdcall, dynlib: "mswsock", importc.} +proc TransmitFile*(hSocket: SOCKET, hFile: HANDLE, nNumberOfBytesToWrite: DWORD, nNumberOfBytesPerSend: DWORD, lpOverlapped: LPOVERLAPPED, lpTransmitBuffers: LPTRANSMIT_FILE_BUFFERS, dwReserved: DWORD): WINBOOL {.winapi, stdcall, dynlib: "mswsock", importc.} +proc AcceptEx*(sListenSocket: SOCKET, sAcceptSocket: SOCKET, lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, lpdwBytesReceived: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "mswsock", importc.} +proc GetAcceptExSockaddrs*(lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, LocalSockaddr: ptr ptr sockaddr, LocalSockaddrLength: LPINT, RemoteSockaddr: ptr ptr sockaddr, RemoteSockaddrLength: LPINT): VOID {.winapi, stdcall, dynlib: "mswsock", importc.} +proc InetNtopA*(Family: INT, pAddr: PVOID, pStringBuf: LPSTR, StringBufSize: int): LPCSTR {.winapi, stdcall, dynlib: "ws2_32", importc: "inet_ntop".} +proc InetPtonA*(Family: INT, pStringBuf: LPCSTR, pAddr: PVOID): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "inet_pton".} +template `<`*(x: TIMEVAL, y: TIMEVAL): bool = (x.tv_sec < y.tv_sec or (x.tv_sec == y.tv_sec and x.tv_usec < y.tv_usec)) +template `<=`*(x: TIMEVAL, y: TIMEVAL): bool = (x.tv_sec < y.tv_sec or (x.tv_sec == y.tv_sec and x.tv_usec <= y.tv_usec)) +template timerisset*(tvp: TIMEVAL): bool = tvp.tv_sec != 0 or tvp.tv_usec != 0 +template timerclear*(tvp: var TIMEVAL) = tvp.tv_sec = 0; tvp.tv_usec = 0 +template IN_CLASSA*(i: untyped): bool = (i and 0x80000000) == 0 +template IN_CLASSB*(i: untyped): bool = (i and 0xc0000000) == 0x80000000 +template IN_CLASSC*(i: untyped): bool = (i and 0xe0000000) == 0xc0000000 +template IN_CLASSD*(i: untyped): bool = (i and 0xf0000000) == 0xe0000000 +template IN_MULTICAST*(i: untyped): bool = IN_CLASSD(i) +template WSAMAKEASYNCREPLY*(buflen: untyped, error: untyped): untyped = MAKELONG(buflen, error) +template WSAMAKESELECTREPLY*(event: untyped, error: untyped): untyped = MAKELONG(event, error) +template WSAGETASYNCBUFLEN*(lParam: untyped): untyped = LOWORD(lParam) +template WSAGETASYNCERROR*(lParam: untyped): untyped = HIWORD(lParam) +template WSAGETSELECTEVENT*(lParam: untyped): untyped = LOWORD(lParam) +template WSAGETSELECTERROR*(lParam: untyped): untyped = HIWORD(lParam) +proc FD_CLR*(fd: SOCKET, s: ptr fd_set): void {.importc: "FD_CLR", header: "".} +proc FD_SET*(fd: SOCKET, s: ptr fd_set): void {.importc: "FD_SET", header: "".} +proc FD_ZERO*(s: ptr fd_set): void {.importc: "FD_ZERO", header: "".} +proc FD_ISSET*(fd: SOCKET, s: ptr fd_set): bool {.winapi, inline.} = bool WSAFDIsSet(fd, s) +proc IN6_ADDR_EQUAL*(a: ptr IN6_ADDR, b: ptr IN6_ADDR): bool {.winapi, inline.} = equalMem(a, b, sizeof(IN6_ADDR)) +proc FreeAddrInfoExA*(pAddrInfo: PADDRINFOEXA): void {.winapi, stdcall, dynlib: "ws2_32", importc: "FreeAddrInfoEx".} +proc `Zone=`*(self: var SCOPE_ID, x: ULONG) {.inline.} = self.union1.struct1.Zone = x +proc Zone*(self: SCOPE_ID): ULONG {.inline.} = self.union1.struct1.Zone +proc `Level=`*(self: var SCOPE_ID, x: ULONG) {.inline.} = self.union1.struct1.Level = x +proc Level*(self: SCOPE_ID): ULONG {.inline.} = self.union1.struct1.Level +proc `Value=`*(self: var SCOPE_ID, x: ULONG) {.inline.} = self.union1.Value = x +proc Value*(self: SCOPE_ID): ULONG {.inline.} = self.union1.Value +proc Value*(self: var SCOPE_ID): var ULONG {.inline.} = self.union1.Value +proc `sin6_scope_id=`*(self: var sockaddr_in6, x: int32) {.inline.} = self.union1.sin6_scope_id = x +proc sin6_scope_id*(self: sockaddr_in6): int32 {.inline.} = self.union1.sin6_scope_id +proc sin6_scope_id*(self: var sockaddr_in6): var int32 {.inline.} = self.union1.sin6_scope_id +proc `sin6_scope_struct=`*(self: var sockaddr_in6, x: SCOPE_ID) {.inline.} = self.union1.sin6_scope_struct = x +proc sin6_scope_struct*(self: sockaddr_in6): SCOPE_ID {.inline.} = self.union1.sin6_scope_struct +proc sin6_scope_struct*(self: var sockaddr_in6): var SCOPE_ID {.inline.} = self.union1.sin6_scope_struct +proc `nFileOffset=`*(self: var TRANSMIT_PACKETS_ELEMENT, x: LARGE_INTEGER) {.inline.} = self.union1.struct1.nFileOffset = x +proc nFileOffset*(self: TRANSMIT_PACKETS_ELEMENT): LARGE_INTEGER {.inline.} = self.union1.struct1.nFileOffset +proc nFileOffset*(self: var TRANSMIT_PACKETS_ELEMENT): var LARGE_INTEGER {.inline.} = self.union1.struct1.nFileOffset +proc `hFile=`*(self: var TRANSMIT_PACKETS_ELEMENT, x: HANDLE) {.inline.} = self.union1.struct1.hFile = x +proc hFile*(self: TRANSMIT_PACKETS_ELEMENT): HANDLE {.inline.} = self.union1.struct1.hFile +proc hFile*(self: var TRANSMIT_PACKETS_ELEMENT): var HANDLE {.inline.} = self.union1.struct1.hFile +proc `pBuffer=`*(self: var TRANSMIT_PACKETS_ELEMENT, x: PVOID) {.inline.} = self.union1.pBuffer = x +proc pBuffer*(self: TRANSMIT_PACKETS_ELEMENT): PVOID {.inline.} = self.union1.pBuffer +proc pBuffer*(self: var TRANSMIT_PACKETS_ELEMENT): var PVOID {.inline.} = self.union1.pBuffer +when winimUnicode: + type + WSAPROTOCOL_INFO* = WSAPROTOCOL_INFOW + LPWSAPROTOCOL_INFO* = LPWSAPROTOCOL_INFOW + WSAQUERYSET* = WSAQUERYSETW + PWSAQUERYSET* = PWSAQUERYSETW + LPWSAQUERYSET* = LPWSAQUERYSETW + WSANSCLASSINFO* = WSANSCLASSINFOW + PWSANSCLASSINFO* = PWSANSCLASSINFOW + LPWSANSCLASSINFO* = LPWSANSCLASSINFOW + WSASERVICECLASSINFO* = WSASERVICECLASSINFOW + PWSASERVICECLASSINFO* = PWSASERVICECLASSINFOW + LPWSASERVICECLASSINFO* = LPWSASERVICECLASSINFOW + WSANAMESPACE_INFO* = WSANAMESPACE_INFOW + PWSANAMESPACE_INFO* = PWSANAMESPACE_INFOW + LPWSANAMESPACE_INFO* = LPWSANAMESPACE_INFOW + LPFN_WSADUPLICATESOCKET* = LPFN_WSADUPLICATESOCKETW + LPFN_WSAENUMPROTOCOLS* = LPFN_WSAENUMPROTOCOLSW + LPFN_WSASOCKET* = LPFN_WSASOCKETW + LPFN_WSAADDRESSTOSTRING* = LPFN_WSAADDRESSTOSTRINGW + LPFN_WSASTRINGTOADDRESS* = LPFN_WSASTRINGTOADDRESSW + LPFN_WSALOOKUPSERVICEBEGIN* = LPFN_WSALOOKUPSERVICEBEGINW + LPFN_WSALOOKUPSERVICENEXT* = LPFN_WSALOOKUPSERVICENEXTW + LPFN_WSAINSTALLSERVICECLASS* = LPFN_WSAINSTALLSERVICECLASSW + LPFN_WSAGETSERVICECLASSINFO* = LPFN_WSAGETSERVICECLASSINFOW + LPFN_WSAENUMNAMESPACEPROVIDERS* = LPFN_WSAENUMNAMESPACEPROVIDERSW + LPFN_WSAGETSERVICECLASSNAMEBYCLASSID* = LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW + LPFN_WSASETSERVICE* = LPFN_WSASETSERVICEW + WSANAMESPACE_INFOEX* = WSANAMESPACE_INFOEXW + PWSANAMESPACE_INFOEX* = PWSANAMESPACE_INFOEXW + LPWSANAMESPACE_INFOEX* = LPWSANAMESPACE_INFOEXW + ADDRINFOT* = ADDRINFOW + LPFN_GETADDRINFOT* = LPFN_GETADDRINFOW + LPFN_FREEADDRINFOT* = LPFN_FREEADDRINFOW + LPFN_GETNAMEINFOT* = LPFN_GETNAMEINFOW + PADDRINFOEX* = PADDRINFOEXW + LPFN_GETADDRINFOEX* = LPFN_GETADDRINFOEXW + LPFN_SETADDRINFOEX* = LPFN_SETADDRINFOEXW + LPFN_FREEADDRINFOEX* = LPFN_FREEADDRINFOEXW + const + SO_PROTOCOL_INFO* = SO_PROTOCOL_INFOW + SERVICE_TYPE_VALUE_SAPID* = SERVICE_TYPE_VALUE_SAPIDW + SERVICE_TYPE_VALUE_TCPPORT* = SERVICE_TYPE_VALUE_TCPPORTW + SERVICE_TYPE_VALUE_UDPPORT* = SERVICE_TYPE_VALUE_UDPPORTW + SERVICE_TYPE_VALUE_OBJECTID* = SERVICE_TYPE_VALUE_OBJECTIDW + proc WSADuplicateSocket*(s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "WSADuplicateSocketW".} + proc WSAEnumProtocols*(lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOW, lpdwBufferLength: LPDWORD): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumProtocolsW".} + proc WSAAddressToString*(lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpszAddressString: LPWSTR, lpdwAddressStringLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAAddressToStringW".} + proc WSASocket*(af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOW, g: GROUP, dwFlags: DWORD): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc: "WSASocketW".} + proc WSAStringToAddress*(AddressString: LPWSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOW, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAStringToAddressW".} + proc WSALookupServiceBegin*(lpqsRestrictions: LPWSAQUERYSETW, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSALookupServiceBeginW".} + proc WSALookupServiceNext*(hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETW): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSALookupServiceNextW".} + proc WSAInstallServiceClass*(lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAInstallServiceClassW".} + proc WSAGetServiceClassInfo*(lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAGetServiceClassInfoW".} + proc WSAEnumNameSpaceProviders*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOW): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumNameSpaceProvidersW".} + proc WSAGetServiceClassNameByClassId*(lpServiceClassId: LPGUID, lpszServiceClassName: LPWSTR, lpdwBufferLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAGetServiceClassNameByClassIdW".} + proc WSASetService*(lpqsRegInfo: LPWSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSASetServiceW".} + proc WSAConnectByName*(s: SOCKET, nodename: LPWSTR, servicename: LPWSTR, LocalAddressLength: LPDWORD, LocalAddress: LPSOCKADDR, RemoteAddressLength: LPDWORD, RemoteAddress: LPSOCKADDR, timeout: PTIMEVAL, Reserved: LPWSAOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAConnectByNameW".} + proc WSAEnumNameSpaceProvidersEx*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOEXW): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumNameSpaceProvidersExW".} + proc GetAddrInfo*(pNodeName: PCWSTR, pServiceName: PCWSTR, pHints: ptr ADDRINFOW, ppResult: ptr PADDRINFOW): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "GetAddrInfoW".} + proc FreeAddrInfo*(pAddrInfo: PADDRINFOW): void {.winapi, stdcall, dynlib: "ws2_32", importc: "FreeAddrInfoW".} + proc GetNameInfo*(pSockaddr: ptr SOCKADDR, SockaddrLength: socklen_t, pNodeBuffer: PWCHAR, NodeBufferSize: DWORD, pServiceBuffer: PWCHAR, ServiceBufferSize: DWORD, Flags: INT): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "GetNameInfoW".} + proc RtlIpv6AddressToString*(Addr: ptr IN6_ADDR, S: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6AddressToStringW".} + proc RtlIpv6AddressToStringEx*(Address: ptr IN6_ADDR, ScopeId: ULONG, Port: USHORT, AddressString: LPWSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6AddressToStringExW".} + proc RtlIpv4AddressToString*(Addr: ptr IN_ADDR, S: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4AddressToStringW".} + proc RtlIpv4AddressToStringEx*(Address: ptr IN_ADDR, Port: USHORT, AddressString: LPWSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4AddressToStringExW".} + proc RtlIpv4StringToAddress*(S: PCWSTR, Strict: BOOLEAN, Terminator: ptr LPWSTR, Addr: ptr IN_ADDR): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4StringToAddressW".} + proc RtlIpv4StringToAddressEx*(AddressString: PCWSTR, Strict: BOOLEAN, Address: ptr IN_ADDR, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4StringToAddressExW".} + proc RtlIpv6StringToAddressEx*(AddressString: PCWSTR, Address: ptr IN6_ADDR, ScopeId: PULONG, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6StringToAddressExW".} + proc GetAddrInfoEx*(pName: PCWSTR, pServiceName: PCWSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXW, ppResult: ptr PADDRINFOEXW, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "GetAddrInfoExW".} + proc SetAddrInfoEx*(pName: PCWSTR, pServiceName: PCWSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "SetAddrInfoExW".} + proc FreeAddrInfoEx*(pAddrInfo: PADDRINFOEXW): void {.winapi, stdcall, dynlib: "ws2_32", importc: "FreeAddrInfoExW".} + proc InetNtop*(Family: INT, pAddr: PVOID, pStringBuf: LPWSTR, StringBufSIze: int): LPCWSTR {.winapi, stdcall, dynlib: "ws2_32", importc: "InetNtopW".} + proc InetPton*(Family: INT, pStringBuf: LPCWSTR, pAddr: PVOID): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "InetPtonW".} +when winimAnsi: + type + WSAPROTOCOL_INFO* = WSAPROTOCOL_INFOA + LPWSAPROTOCOL_INFO* = LPWSAPROTOCOL_INFOA + WSAQUERYSET* = WSAQUERYSETA + PWSAQUERYSET* = PWSAQUERYSETA + LPWSAQUERYSET* = LPWSAQUERYSETA + WSANSCLASSINFO* = WSANSCLASSINFOA + PWSANSCLASSINFO* = PWSANSCLASSINFOA + LPWSANSCLASSINFO* = LPWSANSCLASSINFOA + WSASERVICECLASSINFO* = WSASERVICECLASSINFOA + PWSASERVICECLASSINFO* = PWSASERVICECLASSINFOA + LPWSASERVICECLASSINFO* = LPWSASERVICECLASSINFOA + WSANAMESPACE_INFO* = WSANAMESPACE_INFOA + PWSANAMESPACE_INFO* = PWSANAMESPACE_INFOA + LPWSANAMESPACE_INFO* = LPWSANAMESPACE_INFOA + LPFN_WSADUPLICATESOCKET* = LPFN_WSADUPLICATESOCKETA + LPFN_WSAENUMPROTOCOLS* = LPFN_WSAENUMPROTOCOLSA + LPFN_WSASOCKET* = LPFN_WSASOCKETA + LPFN_WSAADDRESSTOSTRING* = LPFN_WSAADDRESSTOSTRINGA + LPFN_WSASTRINGTOADDRESS* = LPFN_WSASTRINGTOADDRESSA + LPFN_WSALOOKUPSERVICEBEGIN* = LPFN_WSALOOKUPSERVICEBEGINA + LPFN_WSALOOKUPSERVICENEXT* = LPFN_WSALOOKUPSERVICENEXTA + LPFN_WSAINSTALLSERVICECLASS* = LPFN_WSAINSTALLSERVICECLASSA + LPFN_WSAGETSERVICECLASSINFO* = LPFN_WSAGETSERVICECLASSINFOA + LPFN_WSAENUMNAMESPACEPROVIDERS* = LPFN_WSAENUMNAMESPACEPROVIDERSA + LPFN_WSAGETSERVICECLASSNAMEBYCLASSID* = LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA + LPFN_WSASETSERVICE* = LPFN_WSASETSERVICEA + WSANAMESPACE_INFOEX* = WSANAMESPACE_INFOEXA + PWSANAMESPACE_INFOEX* = PWSANAMESPACE_INFOEXA + LPWSANAMESPACE_INFOEX* = LPWSANAMESPACE_INFOEXA + ADDRINFOT* = ADDRINFOA + LPFN_GETADDRINFOT* = LPFN_GETADDRINFOA + LPFN_FREEADDRINFOT* = LPFN_FREEADDRINFOA + LPFN_GETNAMEINFOT* = LPFN_GETNAMEINFOA + PADDRINFOEX* = PADDRINFOEXA + LPFN_GETADDRINFOEX* = LPFN_GETADDRINFOEXA + LPFN_SETADDRINFOEX* = LPFN_SETADDRINFOEXA + LPFN_FREEADDRINFOEX* = LPFN_FREEADDRINFOEXA + const + SO_PROTOCOL_INFO* = SO_PROTOCOL_INFOA + SERVICE_TYPE_VALUE_SAPID* = SERVICE_TYPE_VALUE_SAPIDA + SERVICE_TYPE_VALUE_TCPPORT* = SERVICE_TYPE_VALUE_TCPPORTA + SERVICE_TYPE_VALUE_UDPPORT* = SERVICE_TYPE_VALUE_UDPPORTA + SERVICE_TYPE_VALUE_OBJECTID* = SERVICE_TYPE_VALUE_OBJECTIDA + proc WSADuplicateSocket*(s: SOCKET, dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "WSADuplicateSocketA".} + proc WSAEnumProtocols*(lpiProtocols: LPINT, lpProtocolBuffer: LPWSAPROTOCOL_INFOA, lpdwBufferLength: LPDWORD): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumProtocolsA".} + proc WSAAddressToString*(lpsaAddress: LPSOCKADDR, dwAddressLength: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpszAddressString: LPSTR, lpdwAddressStringLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAAddressToStringA".} + proc WSASocket*(af: int32, `type`: int32, protocol: int32, lpProtocolInfo: LPWSAPROTOCOL_INFOA, g: GROUP, dwFlags: DWORD): SOCKET {.winapi, stdcall, dynlib: "ws2_32", importc: "WSASocketA".} + proc WSAStringToAddress*(AddressString: LPSTR, AddressFamily: INT, lpProtocolInfo: LPWSAPROTOCOL_INFOA, lpAddress: LPSOCKADDR, lpAddressLength: LPINT): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAStringToAddressA".} + proc WSALookupServiceBegin*(lpqsRestrictions: LPWSAQUERYSETA, dwControlFlags: DWORD, lphLookup: LPHANDLE): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSALookupServiceBeginA".} + proc WSALookupServiceNext*(hLookup: HANDLE, dwControlFlags: DWORD, lpdwBufferLength: LPDWORD, lpqsResults: LPWSAQUERYSETA): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSALookupServiceNextA".} + proc WSAInstallServiceClass*(lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAInstallServiceClassA".} + proc WSAGetServiceClassInfo*(lpProviderId: LPGUID, lpServiceClassId: LPGUID, lpdwBufSize: LPDWORD, lpServiceClassInfo: LPWSASERVICECLASSINFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAGetServiceClassInfoA".} + proc WSAEnumNameSpaceProviders*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOA): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumNameSpaceProvidersA".} + proc WSAGetServiceClassNameByClassId*(lpServiceClassId: LPGUID, lpszServiceClassName: LPSTR, lpdwBufferLength: LPDWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAGetServiceClassNameByClassIdA".} + proc WSASetService*(lpqsRegInfo: LPWSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwControlFlags: DWORD): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSASetServiceA".} + proc WSAConnectByName*(s: SOCKET, nodename: LPSTR, servicename: LPSTR, LocalAddressLength: LPDWORD, LocalAddress: LPSOCKADDR, RemoteAddressLength: LPDWORD, RemoteAddress: LPSOCKADDR, timeout: PTIMEVAL, Reserved: LPWSAOVERLAPPED): WINBOOL {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAConnectByNameA".} + proc WSAEnumNameSpaceProvidersEx*(lpdwBufferLength: LPDWORD, lpnspBuffer: LPWSANAMESPACE_INFOEXA): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "WSAEnumNameSpaceProvidersExA".} + proc GetAddrInfo*(nodename: ptr char, servname: ptr char, hints: ptr ADDRINFOA, res: ptr ptr ADDRINFOA): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "getaddrinfo".} + proc FreeAddrInfo*(pAddrInfo: LPADDRINFO): void {.winapi, stdcall, dynlib: "ws2_32", importc: "freeaddrinfo".} + proc GetNameInfo*(sa: ptr sockaddr, salen: socklen_t, host: ptr char, hostlen: DWORD, serv: ptr char, servlen: DWORD, flags: int32): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "getnameinfo".} + proc RtlIpv6AddressToString*(Addr: ptr IN6_ADDR, S: LPSTR): LPSTR {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6AddressToStringA".} + proc RtlIpv6AddressToStringEx*(Address: ptr IN6_ADDR, ScopeId: ULONG, Port: USHORT, AddressString: LPSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6AddressToStringExA".} + proc RtlIpv4AddressToString*(Addr: ptr IN_ADDR, S: LPSTR): LPSTR {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4AddressToStringA".} + proc RtlIpv4AddressToStringEx*(Address: ptr IN_ADDR, Port: USHORT, AddressString: LPSTR, AddressStringLength: PULONG): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4AddressToStringExA".} + proc RtlIpv4StringToAddress*(S: PCSTR, Strict: BOOLEAN, Terminator: ptr LPSTR, Addr: ptr IN_ADDR): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4StringToAddressA".} + proc RtlIpv4StringToAddressEx*(AddressString: PCSTR, Strict: BOOLEAN, Address: ptr IN_ADDR, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv4StringToAddressExA".} + proc RtlIpv6StringToAddressEx*(AddressString: PCSTR, Address: ptr IN6_ADDR, ScopeId: PULONG, Port: PUSHORT): LONG {.winapi, stdcall, dynlib: "ntdll", importc: "RtlIpv6StringToAddressExA".} + proc GetAddrInfoEx*(pName: PCSTR, pServiceName: PCSTR, dwNameSpace: DWORD, lpNspId: LPGUID, pHints: ptr ADDRINFOEXA, ppResult: ptr PADDRINFOEXA, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "GetAddrInfoExA".} + proc SetAddrInfoEx*(pName: PCSTR, pServiceName: PCSTR, pAddresses: ptr SOCKET_ADDRESS, dwAddressCount: DWORD, lpBlob: LPBLOB, dwFlags: DWORD, dwNameSpace: DWORD, lpNspId: LPGUID, timeout: PTIMEVAL, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE, lpNameHandle: LPHANDLE): int32 {.winapi, stdcall, dynlib: "ws2_32", importc: "SetAddrInfoExA".} + proc InetNtop*(Family: INT, pAddr: PVOID, pStringBuf: LPSTR, StringBufSize: int): LPCSTR {.winapi, stdcall, dynlib: "ws2_32", importc: "inet_ntop".} + proc InetPton*(Family: INT, pStringBuf: LPCSTR, pAddr: PVOID): INT {.winapi, stdcall, dynlib: "ws2_32", importc: "inet_pton".} + proc FreeAddrInfoEx*(pAddrInfo: PADDRINFOEXA): void {.winapi, stdcall, dynlib: "ws2_32", importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winspool.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winspool.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1596 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import winerror +import wingdi +#include +type + BIDI_TYPE* = int32 + PRINTER_OPTION_FLAGS* = int32 + EPrintXPSJobOperation* = int32 + EPrintXPSJobProgress* = int32 + PRINTER_INFO_1A* {.pure.} = object + Flags*: DWORD + pDescription*: LPSTR + pName*: LPSTR + pComment*: LPSTR + PPRINTER_INFO_1A* = ptr PRINTER_INFO_1A + LPPRINTER_INFO_1A* = ptr PRINTER_INFO_1A + PRINTER_INFO_1W* {.pure.} = object + Flags*: DWORD + pDescription*: LPWSTR + pName*: LPWSTR + pComment*: LPWSTR + PPRINTER_INFO_1W* = ptr PRINTER_INFO_1W + LPPRINTER_INFO_1W* = ptr PRINTER_INFO_1W + PRINTER_INFO_2A* {.pure.} = object + pServerName*: LPSTR + pPrinterName*: LPSTR + pShareName*: LPSTR + pPortName*: LPSTR + pDriverName*: LPSTR + pComment*: LPSTR + pLocation*: LPSTR + pDevMode*: LPDEVMODEA + pSepFile*: LPSTR + pPrintProcessor*: LPSTR + pDatatype*: LPSTR + pParameters*: LPSTR + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + Attributes*: DWORD + Priority*: DWORD + DefaultPriority*: DWORD + StartTime*: DWORD + UntilTime*: DWORD + Status*: DWORD + cJobs*: DWORD + AveragePPM*: DWORD + PPRINTER_INFO_2A* = ptr PRINTER_INFO_2A + LPPRINTER_INFO_2A* = ptr PRINTER_INFO_2A + PRINTER_INFO_2W* {.pure.} = object + pServerName*: LPWSTR + pPrinterName*: LPWSTR + pShareName*: LPWSTR + pPortName*: LPWSTR + pDriverName*: LPWSTR + pComment*: LPWSTR + pLocation*: LPWSTR + pDevMode*: LPDEVMODEW + pSepFile*: LPWSTR + pPrintProcessor*: LPWSTR + pDatatype*: LPWSTR + pParameters*: LPWSTR + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + Attributes*: DWORD + Priority*: DWORD + DefaultPriority*: DWORD + StartTime*: DWORD + UntilTime*: DWORD + Status*: DWORD + cJobs*: DWORD + AveragePPM*: DWORD + PPRINTER_INFO_2W* = ptr PRINTER_INFO_2W + LPPRINTER_INFO_2W* = ptr PRINTER_INFO_2W + PRINTER_INFO_3* {.pure.} = object + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + PPRINTER_INFO_3* = ptr PRINTER_INFO_3 + LPPRINTER_INFO_3* = ptr PRINTER_INFO_3 + PRINTER_INFO_4A* {.pure.} = object + pPrinterName*: LPSTR + pServerName*: LPSTR + Attributes*: DWORD + PPRINTER_INFO_4A* = ptr PRINTER_INFO_4A + LPPRINTER_INFO_4A* = ptr PRINTER_INFO_4A + PRINTER_INFO_4W* {.pure.} = object + pPrinterName*: LPWSTR + pServerName*: LPWSTR + Attributes*: DWORD + PPRINTER_INFO_4W* = ptr PRINTER_INFO_4W + LPPRINTER_INFO_4W* = ptr PRINTER_INFO_4W + PRINTER_INFO_5A* {.pure.} = object + pPrinterName*: LPSTR + pPortName*: LPSTR + Attributes*: DWORD + DeviceNotSelectedTimeout*: DWORD + TransmissionRetryTimeout*: DWORD + PPRINTER_INFO_5A* = ptr PRINTER_INFO_5A + LPPRINTER_INFO_5A* = ptr PRINTER_INFO_5A + PRINTER_INFO_5W* {.pure.} = object + pPrinterName*: LPWSTR + pPortName*: LPWSTR + Attributes*: DWORD + DeviceNotSelectedTimeout*: DWORD + TransmissionRetryTimeout*: DWORD + PPRINTER_INFO_5W* = ptr PRINTER_INFO_5W + LPPRINTER_INFO_5W* = ptr PRINTER_INFO_5W + PRINTER_INFO_6* {.pure.} = object + dwStatus*: DWORD + PPRINTER_INFO_6* = ptr PRINTER_INFO_6 + LPPRINTER_INFO_6* = ptr PRINTER_INFO_6 + PRINTER_INFO_7A* {.pure.} = object + pszObjectGUID*: LPSTR + dwAction*: DWORD + PPRINTER_INFO_7A* = ptr PRINTER_INFO_7A + LPPRINTER_INFO_7A* = ptr PRINTER_INFO_7A + PRINTER_INFO_7W* {.pure.} = object + pszObjectGUID*: LPWSTR + dwAction*: DWORD + PPRINTER_INFO_7W* = ptr PRINTER_INFO_7W + LPPRINTER_INFO_7W* = ptr PRINTER_INFO_7W + PRINTER_INFO_8A* {.pure.} = object + pDevMode*: LPDEVMODEA + PPRINTER_INFO_8A* = ptr PRINTER_INFO_8A + LPPRINTER_INFO_8A* = ptr PRINTER_INFO_8A + PRINTER_INFO_8W* {.pure.} = object + pDevMode*: LPDEVMODEW + PPRINTER_INFO_8W* = ptr PRINTER_INFO_8W + LPPRINTER_INFO_8W* = ptr PRINTER_INFO_8W + PRINTER_INFO_9A* {.pure.} = object + pDevMode*: LPDEVMODEA + PPRINTER_INFO_9A* = ptr PRINTER_INFO_9A + LPPRINTER_INFO_9A* = ptr PRINTER_INFO_9A + PRINTER_INFO_9W* {.pure.} = object + pDevMode*: LPDEVMODEW + PPRINTER_INFO_9W* = ptr PRINTER_INFO_9W + LPPRINTER_INFO_9W* = ptr PRINTER_INFO_9W + JOB_INFO_1A* {.pure.} = object + JobId*: DWORD + pPrinterName*: LPSTR + pMachineName*: LPSTR + pUserName*: LPSTR + pDocument*: LPSTR + pDatatype*: LPSTR + pStatus*: LPSTR + Status*: DWORD + Priority*: DWORD + Position*: DWORD + TotalPages*: DWORD + PagesPrinted*: DWORD + Submitted*: SYSTEMTIME + PJOB_INFO_1A* = ptr JOB_INFO_1A + LPJOB_INFO_1A* = ptr JOB_INFO_1A + JOB_INFO_1W* {.pure.} = object + JobId*: DWORD + pPrinterName*: LPWSTR + pMachineName*: LPWSTR + pUserName*: LPWSTR + pDocument*: LPWSTR + pDatatype*: LPWSTR + pStatus*: LPWSTR + Status*: DWORD + Priority*: DWORD + Position*: DWORD + TotalPages*: DWORD + PagesPrinted*: DWORD + Submitted*: SYSTEMTIME + PJOB_INFO_1W* = ptr JOB_INFO_1W + LPJOB_INFO_1W* = ptr JOB_INFO_1W + JOB_INFO_2A* {.pure.} = object + JobId*: DWORD + pPrinterName*: LPSTR + pMachineName*: LPSTR + pUserName*: LPSTR + pDocument*: LPSTR + pNotifyName*: LPSTR + pDatatype*: LPSTR + pPrintProcessor*: LPSTR + pParameters*: LPSTR + pDriverName*: LPSTR + pDevMode*: LPDEVMODEA + pStatus*: LPSTR + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + Status*: DWORD + Priority*: DWORD + Position*: DWORD + StartTime*: DWORD + UntilTime*: DWORD + TotalPages*: DWORD + Size*: DWORD + Submitted*: SYSTEMTIME + Time*: DWORD + PagesPrinted*: DWORD + PJOB_INFO_2A* = ptr JOB_INFO_2A + LPJOB_INFO_2A* = ptr JOB_INFO_2A + JOB_INFO_2W* {.pure.} = object + JobId*: DWORD + pPrinterName*: LPWSTR + pMachineName*: LPWSTR + pUserName*: LPWSTR + pDocument*: LPWSTR + pNotifyName*: LPWSTR + pDatatype*: LPWSTR + pPrintProcessor*: LPWSTR + pParameters*: LPWSTR + pDriverName*: LPWSTR + pDevMode*: LPDEVMODEW + pStatus*: LPWSTR + pSecurityDescriptor*: PSECURITY_DESCRIPTOR + Status*: DWORD + Priority*: DWORD + Position*: DWORD + StartTime*: DWORD + UntilTime*: DWORD + TotalPages*: DWORD + Size*: DWORD + Submitted*: SYSTEMTIME + Time*: DWORD + PagesPrinted*: DWORD + PJOB_INFO_2W* = ptr JOB_INFO_2W + LPJOB_INFO_2W* = ptr JOB_INFO_2W + JOB_INFO_3* {.pure.} = object + JobId*: DWORD + NextJobId*: DWORD + Reserved*: DWORD + PJOB_INFO_3* = ptr JOB_INFO_3 + LPJOB_INFO_3* = ptr JOB_INFO_3 + ADDJOB_INFO_1A* {.pure.} = object + Path*: LPSTR + JobId*: DWORD + PADDJOB_INFO_1A* = ptr ADDJOB_INFO_1A + LPADDJOB_INFO_1A* = ptr ADDJOB_INFO_1A + ADDJOB_INFO_1W* {.pure.} = object + Path*: LPWSTR + JobId*: DWORD + PADDJOB_INFO_1W* = ptr ADDJOB_INFO_1W + LPADDJOB_INFO_1W* = ptr ADDJOB_INFO_1W + DRIVER_INFO_1A* {.pure.} = object + pName*: LPSTR + PDRIVER_INFO_1A* = ptr DRIVER_INFO_1A + LPDRIVER_INFO_1A* = ptr DRIVER_INFO_1A + DRIVER_INFO_1W* {.pure.} = object + pName*: LPWSTR + PDRIVER_INFO_1W* = ptr DRIVER_INFO_1W + LPDRIVER_INFO_1W* = ptr DRIVER_INFO_1W + DRIVER_INFO_2A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + PDRIVER_INFO_2A* = ptr DRIVER_INFO_2A + LPDRIVER_INFO_2A* = ptr DRIVER_INFO_2A + DRIVER_INFO_2W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + PDRIVER_INFO_2W* = ptr DRIVER_INFO_2W + LPDRIVER_INFO_2W* = ptr DRIVER_INFO_2W + DRIVER_INFO_3A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + pHelpFile*: LPSTR + pDependentFiles*: LPSTR + pMonitorName*: LPSTR + pDefaultDataType*: LPSTR + PDRIVER_INFO_3A* = ptr DRIVER_INFO_3A + LPDRIVER_INFO_3A* = ptr DRIVER_INFO_3A + DRIVER_INFO_3W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + pHelpFile*: LPWSTR + pDependentFiles*: LPWSTR + pMonitorName*: LPWSTR + pDefaultDataType*: LPWSTR + PDRIVER_INFO_3W* = ptr DRIVER_INFO_3W + LPDRIVER_INFO_3W* = ptr DRIVER_INFO_3W + DRIVER_INFO_4A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + pHelpFile*: LPSTR + pDependentFiles*: LPSTR + pMonitorName*: LPSTR + pDefaultDataType*: LPSTR + pszzPreviousNames*: LPSTR + PDRIVER_INFO_4A* = ptr DRIVER_INFO_4A + LPDRIVER_INFO_4A* = ptr DRIVER_INFO_4A + DRIVER_INFO_4W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + pHelpFile*: LPWSTR + pDependentFiles*: LPWSTR + pMonitorName*: LPWSTR + pDefaultDataType*: LPWSTR + pszzPreviousNames*: LPWSTR + PDRIVER_INFO_4W* = ptr DRIVER_INFO_4W + LPDRIVER_INFO_4W* = ptr DRIVER_INFO_4W + DRIVER_INFO_5A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + dwDriverAttributes*: DWORD + dwConfigVersion*: DWORD + dwDriverVersion*: DWORD + PDRIVER_INFO_5A* = ptr DRIVER_INFO_5A + LPDRIVER_INFO_5A* = ptr DRIVER_INFO_5A + DRIVER_INFO_5W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + dwDriverAttributes*: DWORD + dwConfigVersion*: DWORD + dwDriverVersion*: DWORD + PDRIVER_INFO_5W* = ptr DRIVER_INFO_5W + LPDRIVER_INFO_5W* = ptr DRIVER_INFO_5W + DRIVER_INFO_6A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + pHelpFile*: LPSTR + pDependentFiles*: LPSTR + pMonitorName*: LPSTR + pDefaultDataType*: LPSTR + pszzPreviousNames*: LPSTR + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + pszMfgName*: LPSTR + pszOEMUrl*: LPSTR + pszHardwareID*: LPSTR + pszProvider*: LPSTR + PDRIVER_INFO_6A* = ptr DRIVER_INFO_6A + LPDRIVER_INFO_6A* = ptr DRIVER_INFO_6A + DRIVER_INFO_6W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + pHelpFile*: LPWSTR + pDependentFiles*: LPWSTR + pMonitorName*: LPWSTR + pDefaultDataType*: LPWSTR + pszzPreviousNames*: LPWSTR + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + pszMfgName*: LPWSTR + pszOEMUrl*: LPWSTR + pszHardwareID*: LPWSTR + pszProvider*: LPWSTR + PDRIVER_INFO_6W* = ptr DRIVER_INFO_6W + LPDRIVER_INFO_6W* = ptr DRIVER_INFO_6W + DOC_INFO_1A* {.pure.} = object + pDocName*: LPSTR + pOutputFile*: LPSTR + pDatatype*: LPSTR + PDOC_INFO_1A* = ptr DOC_INFO_1A + LPDOC_INFO_1A* = ptr DOC_INFO_1A + DOC_INFO_1W* {.pure.} = object + pDocName*: LPWSTR + pOutputFile*: LPWSTR + pDatatype*: LPWSTR + PDOC_INFO_1W* = ptr DOC_INFO_1W + LPDOC_INFO_1W* = ptr DOC_INFO_1W + FORM_INFO_1A* {.pure.} = object + Flags*: DWORD + pName*: LPSTR + Size*: SIZEL + ImageableArea*: RECTL + PFORM_INFO_1A* = ptr FORM_INFO_1A + LPFORM_INFO_1A* = ptr FORM_INFO_1A + FORM_INFO_1W* {.pure.} = object + Flags*: DWORD + pName*: LPWSTR + Size*: SIZEL + ImageableArea*: RECTL + PFORM_INFO_1W* = ptr FORM_INFO_1W + LPFORM_INFO_1W* = ptr FORM_INFO_1W + DOC_INFO_2A* {.pure.} = object + pDocName*: LPSTR + pOutputFile*: LPSTR + pDatatype*: LPSTR + dwMode*: DWORD + JobId*: DWORD + PDOC_INFO_2A* = ptr DOC_INFO_2A + LPDOC_INFO_2A* = ptr DOC_INFO_2A + DOC_INFO_2W* {.pure.} = object + pDocName*: LPWSTR + pOutputFile*: LPWSTR + pDatatype*: LPWSTR + dwMode*: DWORD + JobId*: DWORD + PDOC_INFO_2W* = ptr DOC_INFO_2W + LPDOC_INFO_2W* = ptr DOC_INFO_2W + DOC_INFO_3A* {.pure.} = object + pDocName*: LPSTR + pOutputFile*: LPSTR + pDatatype*: LPSTR + dwFlags*: DWORD + PDOC_INFO_3A* = ptr DOC_INFO_3A + LPDOC_INFO_3A* = ptr DOC_INFO_3A + DOC_INFO_3W* {.pure.} = object + pDocName*: LPWSTR + pOutputFile*: LPWSTR + pDatatype*: LPWSTR + dwFlags*: DWORD + PDOC_INFO_3W* = ptr DOC_INFO_3W + LPDOC_INFO_3W* = ptr DOC_INFO_3W + PRINTPROCESSOR_INFO_1A* {.pure.} = object + pName*: LPSTR + PPRINTPROCESSOR_INFO_1A* = ptr PRINTPROCESSOR_INFO_1A + LPPRINTPROCESSOR_INFO_1A* = ptr PRINTPROCESSOR_INFO_1A + PRINTPROCESSOR_INFO_1W* {.pure.} = object + pName*: LPWSTR + PPRINTPROCESSOR_INFO_1W* = ptr PRINTPROCESSOR_INFO_1W + LPPRINTPROCESSOR_INFO_1W* = ptr PRINTPROCESSOR_INFO_1W + PRINTPROCESSOR_CAPS_1* {.pure.} = object + dwLevel*: DWORD + dwNupOptions*: DWORD + dwPageOrderFlags*: DWORD + dwNumberOfCopies*: DWORD + PPRINTPROCESSOR_CAPS_1* = ptr PRINTPROCESSOR_CAPS_1 + PORT_INFO_1A* {.pure.} = object + pName*: LPSTR + PPORT_INFO_1A* = ptr PORT_INFO_1A + LPPORT_INFO_1A* = ptr PORT_INFO_1A + PORT_INFO_1W* {.pure.} = object + pName*: LPWSTR + PPORT_INFO_1W* = ptr PORT_INFO_1W + LPPORT_INFO_1W* = ptr PORT_INFO_1W + PORT_INFO_2A* {.pure.} = object + pPortName*: LPSTR + pMonitorName*: LPSTR + pDescription*: LPSTR + fPortType*: DWORD + Reserved*: DWORD + PPORT_INFO_2A* = ptr PORT_INFO_2A + LPPORT_INFO_2A* = ptr PORT_INFO_2A + PORT_INFO_2W* {.pure.} = object + pPortName*: LPWSTR + pMonitorName*: LPWSTR + pDescription*: LPWSTR + fPortType*: DWORD + Reserved*: DWORD + PPORT_INFO_2W* = ptr PORT_INFO_2W + LPPORT_INFO_2W* = ptr PORT_INFO_2W + PORT_INFO_3A* {.pure.} = object + dwStatus*: DWORD + pszStatus*: LPSTR + dwSeverity*: DWORD + PPORT_INFO_3A* = ptr PORT_INFO_3A + LPPORT_INFO_3A* = ptr PORT_INFO_3A + PORT_INFO_3W* {.pure.} = object + dwStatus*: DWORD + pszStatus*: LPWSTR + dwSeverity*: DWORD + PPORT_INFO_3W* = ptr PORT_INFO_3W + LPPORT_INFO_3W* = ptr PORT_INFO_3W + MONITOR_INFO_1A* {.pure.} = object + pName*: LPSTR + PMONITOR_INFO_1A* = ptr MONITOR_INFO_1A + LPMONITOR_INFO_1A* = ptr MONITOR_INFO_1A + MONITOR_INFO_1W* {.pure.} = object + pName*: LPWSTR + PMONITOR_INFO_1W* = ptr MONITOR_INFO_1W + LPMONITOR_INFO_1W* = ptr MONITOR_INFO_1W + MONITOR_INFO_2A* {.pure.} = object + pName*: LPSTR + pEnvironment*: LPSTR + pDLLName*: LPSTR + PMONITOR_INFO_2A* = ptr MONITOR_INFO_2A + LPMONITOR_INFO_2A* = ptr MONITOR_INFO_2A + MONITOR_INFO_2W* {.pure.} = object + pName*: LPWSTR + pEnvironment*: LPWSTR + pDLLName*: LPWSTR + PMONITOR_INFO_2W* = ptr MONITOR_INFO_2W + LPMONITOR_INFO_2W* = ptr MONITOR_INFO_2W + DATATYPES_INFO_1A* {.pure.} = object + pName*: LPSTR + PDATATYPES_INFO_1A* = ptr DATATYPES_INFO_1A + LPDATATYPES_INFO_1A* = ptr DATATYPES_INFO_1A + DATATYPES_INFO_1W* {.pure.} = object + pName*: LPWSTR + PDATATYPES_INFO_1W* = ptr DATATYPES_INFO_1W + LPDATATYPES_INFO_1W* = ptr DATATYPES_INFO_1W + PRINTER_DEFAULTSA* {.pure.} = object + pDatatype*: LPSTR + pDevMode*: LPDEVMODEA + DesiredAccess*: ACCESS_MASK + PPRINTER_DEFAULTSA* = ptr PRINTER_DEFAULTSA + LPPRINTER_DEFAULTSA* = ptr PRINTER_DEFAULTSA + PRINTER_DEFAULTSW* {.pure.} = object + pDatatype*: LPWSTR + pDevMode*: LPDEVMODEW + DesiredAccess*: ACCESS_MASK + PPRINTER_DEFAULTSW* = ptr PRINTER_DEFAULTSW + LPPRINTER_DEFAULTSW* = ptr PRINTER_DEFAULTSW + PRINTER_ENUM_VALUESA* {.pure.} = object + pValueName*: LPSTR + cbValueName*: DWORD + dwType*: DWORD + pData*: LPBYTE + cbData*: DWORD + PPRINTER_ENUM_VALUESA* = ptr PRINTER_ENUM_VALUESA + LPPRINTER_ENUM_VALUESA* = ptr PRINTER_ENUM_VALUESA + PRINTER_ENUM_VALUESW* {.pure.} = object + pValueName*: LPWSTR + cbValueName*: DWORD + dwType*: DWORD + pData*: LPBYTE + cbData*: DWORD + PPRINTER_ENUM_VALUESW* = ptr PRINTER_ENUM_VALUESW + LPPRINTER_ENUM_VALUESW* = ptr PRINTER_ENUM_VALUESW + PRINTER_NOTIFY_OPTIONS_TYPE* {.pure.} = object + Type*: WORD + Reserved0*: WORD + Reserved1*: DWORD + Reserved2*: DWORD + Count*: DWORD + pFields*: PWORD + PPRINTER_NOTIFY_OPTIONS_TYPE* = ptr PRINTER_NOTIFY_OPTIONS_TYPE + LPPRINTER_NOTIFY_OPTIONS_TYPE* = ptr PRINTER_NOTIFY_OPTIONS_TYPE + PRINTER_NOTIFY_OPTIONS* {.pure.} = object + Version*: DWORD + Flags*: DWORD + Count*: DWORD + pTypes*: PPRINTER_NOTIFY_OPTIONS_TYPE + PPRINTER_NOTIFY_OPTIONS* = ptr PRINTER_NOTIFY_OPTIONS + LPPRINTER_NOTIFY_OPTIONS* = ptr PRINTER_NOTIFY_OPTIONS + PRINTER_NOTIFY_INFO_DATA_NotifyData_Data* {.pure.} = object + cbBuf*: DWORD + pBuf*: LPVOID + PRINTER_NOTIFY_INFO_DATA_NotifyData* {.pure, union.} = object + adwData*: array[2, DWORD] + Data*: PRINTER_NOTIFY_INFO_DATA_NotifyData_Data + PRINTER_NOTIFY_INFO_DATA* {.pure.} = object + Type*: WORD + Field*: WORD + Reserved*: DWORD + Id*: DWORD + NotifyData*: PRINTER_NOTIFY_INFO_DATA_NotifyData + PPRINTER_NOTIFY_INFO_DATA* = ptr PRINTER_NOTIFY_INFO_DATA + LPPRINTER_NOTIFY_INFO_DATA* = ptr PRINTER_NOTIFY_INFO_DATA + PRINTER_NOTIFY_INFO* {.pure.} = object + Version*: DWORD + Flags*: DWORD + Count*: DWORD + aData*: array[1, PRINTER_NOTIFY_INFO_DATA] + PPRINTER_NOTIFY_INFO* = ptr PRINTER_NOTIFY_INFO + LPPRINTER_NOTIFY_INFO* = ptr PRINTER_NOTIFY_INFO + BINARY_CONTAINER* {.pure.} = object + cbBuf*: DWORD + pData*: LPBYTE + PBINARY_CONTAINER* = ptr BINARY_CONTAINER + BIDI_DATA_u* {.pure, union.} = object + bData*: WINBOOL + iData*: LONG + sData*: LPWSTR + fData*: FLOAT + biData*: BINARY_CONTAINER + BIDI_DATA* {.pure.} = object + dwBidiType*: DWORD + u*: BIDI_DATA_u + PBIDI_DATA* = ptr BIDI_DATA + LPBIDI_DATA* = ptr BIDI_DATA + BIDI_REQUEST_DATA* {.pure.} = object + dwReqNumber*: DWORD + pSchema*: LPWSTR + data*: BIDI_DATA + PBIDI_REQUEST_DATA* = ptr BIDI_REQUEST_DATA + LPBIDI_REQUEST_DATA* = ptr BIDI_REQUEST_DATA + BIDI_REQUEST_CONTAINER* {.pure.} = object + Version*: DWORD + Flags*: DWORD + Count*: DWORD + aData*: array[1 , BIDI_REQUEST_DATA] + PBIDI_REQUEST_CONTAINER* = ptr BIDI_REQUEST_CONTAINER + LPBIDI_REQUEST_CONTAINER* = ptr BIDI_REQUEST_CONTAINER + BIDI_RESPONSE_DATA* {.pure.} = object + dwResult*: DWORD + dwReqNumber*: DWORD + pSchema*: LPWSTR + data*: BIDI_DATA + PBIDI_RESPONSE_DATA* = ptr BIDI_RESPONSE_DATA + LPBIDI_RESPONSE_DATA* = ptr BIDI_RESPONSE_DATA + BIDI_RESPONSE_CONTAINER* {.pure.} = object + Version*: DWORD + Flags*: DWORD + Count*: DWORD + aData*: array[1 , BIDI_RESPONSE_DATA] + PBIDI_RESPONSE_CONTAINER* = ptr BIDI_RESPONSE_CONTAINER + LPBIDI_RESPONSE_CONTAINER* = ptr BIDI_RESPONSE_CONTAINER + PROVIDOR_INFO_1A* {.pure.} = object + pName*: LPSTR + pEnvironment*: LPSTR + pDLLName*: LPSTR + PPROVIDOR_INFO_1A* = ptr PROVIDOR_INFO_1A + LPPROVIDOR_INFO_1A* = ptr PROVIDOR_INFO_1A + PROVIDOR_INFO_1W* {.pure.} = object + pName*: LPWSTR + pEnvironment*: LPWSTR + pDLLName*: LPWSTR + PPROVIDOR_INFO_1W* = ptr PROVIDOR_INFO_1W + LPPROVIDOR_INFO_1W* = ptr PROVIDOR_INFO_1W + PROVIDOR_INFO_2A* {.pure.} = object + pOrder*: LPSTR + PPROVIDOR_INFO_2A* = ptr PROVIDOR_INFO_2A + LPPROVIDOR_INFO_2A* = ptr PROVIDOR_INFO_2A + PROVIDOR_INFO_2W* {.pure.} = object + pOrder*: LPWSTR + PPROVIDOR_INFO_2W* = ptr PROVIDOR_INFO_2W + LPPROVIDOR_INFO_2W* = ptr PROVIDOR_INFO_2W + PRINTER_CONNECTION_INFO_1* {.pure.} = object + dwFlags*: DWORD + pszDriverName*: LPTSTR + PPRINTER_CONNECTION_INFO_1* = ptr PRINTER_CONNECTION_INFO_1 + DRIVER_INFO_8W* {.pure.} = object + cVersion*: DWORD + pName*: LPWSTR + pEnvironment*: LPWSTR + pDriverPath*: LPWSTR + pDataFile*: LPWSTR + pConfigFile*: LPWSTR + pHelpFile*: LPWSTR + pDependentFiles*: LPWSTR + pMonitorName*: LPWSTR + pDefaultDataType*: LPWSTR + pszzPreviousNames*: LPWSTR + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + pszMfgName*: LPWSTR + pszOEMUrl*: LPWSTR + pszHardwareID*: LPWSTR + pszProvider*: LPWSTR + pszPrintProcessor*: LPWSTR + pszVendorSetup*: LPWSTR + pszzColorProfiles*: LPWSTR + pszInfPath*: LPWSTR + dwPrinterDriverAttributes*: DWORD + pszzCoreDriverDependencies*: LPWSTR + ftMinInboxDriverVerDate*: FILETIME + dwlMinInboxDriverVerVersion*: DWORDLONG + PDRIVER_INFO_8W* = ptr DRIVER_INFO_8W + LPDRIVER_INFO_8W* = ptr DRIVER_INFO_8W + DRIVER_INFO_8A* {.pure.} = object + cVersion*: DWORD + pName*: LPSTR + pEnvironment*: LPSTR + pDriverPath*: LPSTR + pDataFile*: LPSTR + pConfigFile*: LPSTR + pHelpFile*: LPSTR + pDependentFiles*: LPSTR + pMonitorName*: LPSTR + pDefaultDataType*: LPSTR + pszzPreviousNames*: LPSTR + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + pszMfgName*: LPSTR + pszOEMUrl*: LPSTR + pszHardwareID*: LPSTR + pszProvider*: LPSTR + pszPrintProcessor*: LPSTR + pszVendorSetup*: LPSTR + pszzColorProfiles*: LPSTR + pszInfPath*: LPSTR + dwPrinterDriverAttributes*: DWORD + pszzCoreDriverDependencies*: LPSTR + ftMinInboxDriverVerDate*: FILETIME + dwlMinInboxDriverVerVersion*: DWORDLONG + PDRIVER_INFO_8A* = ptr DRIVER_INFO_8A + LPDRIVER_INFO_8A* = ptr DRIVER_INFO_8A + FORM_INFO_2A* {.pure.} = object + Flags*: DWORD + pName*: LPSTR + Size*: SIZEL + ImageableArea*: RECTL + pKeyword*: LPCSTR + StringType*: DWORD + pMuiDll*: LPCSTR + dwResourceId*: DWORD + pDisplayName*: LPCSTR + wLangId*: LANGID + PFORM_INFO_2A* = ptr FORM_INFO_2A + FORM_INFO_2W* {.pure.} = object + Flags*: DWORD + pName*: LPWSTR + Size*: SIZEL + ImageableArea*: RECTL + pKeyword*: LPCSTR + StringType*: DWORD + pMuiDll*: LPCWSTR + dwResourceId*: DWORD + pDisplayName*: LPCWSTR + wLangId*: LANGID + PFORM_INFO_2W* = ptr FORM_INFO_2W + PRINTPROCESSOR_CAPS_2* {.pure.} = object + dwLevel*: DWORD + dwNupOptions*: DWORD + dwPageOrderFlags*: DWORD + dwNumberOfCopies*: DWORD + dwNupDirectionCaps*: DWORD + dwNupBorderCaps*: DWORD + dwBookletHandlingCaps*: DWORD + dwDuplexHandlingCaps*: DWORD + dwScalingCaps*: DWORD + PPRINTPROCESSOR_CAPS_2* = ptr PRINTPROCESSOR_CAPS_2 + CORE_PRINTER_DRIVERA* {.pure.} = object + CoreDriverGUID*: GUID + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + szPackageID*: array[MAX_PATH, CHAR] + PCORE_PRINTER_DRIVERA* = ptr CORE_PRINTER_DRIVERA + CORE_PRINTER_DRIVERW* {.pure.} = object + CoreDriverGUID*: GUID + ftDriverDate*: FILETIME + dwlDriverVersion*: DWORDLONG + szPackageID*: array[MAX_PATH, WCHAR] + PCORE_PRINTER_DRIVERW* = ptr CORE_PRINTER_DRIVERW + PRINTER_OPTIONS* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + PPRINTER_OPTIONS* = ptr PRINTER_OPTIONS +const + DSPRINT_PUBLISH* = 0x00000001 + DSPRINT_UPDATE* = 0x00000002 + DSPRINT_UNPUBLISH* = 0x00000004 + DSPRINT_REPUBLISH* = 0x00000008 + DSPRINT_PENDING* = 0x80000000'i32 + PRINTER_CONTROL_PAUSE* = 1 + PRINTER_CONTROL_RESUME* = 2 + PRINTER_CONTROL_PURGE* = 3 + PRINTER_CONTROL_SET_STATUS* = 4 + PRINTER_STATUS_PAUSED* = 0x00000001 + PRINTER_STATUS_ERROR* = 0x00000002 + PRINTER_STATUS_PENDING_DELETION* = 0x00000004 + PRINTER_STATUS_PAPER_JAM* = 0x00000008 + PRINTER_STATUS_PAPER_OUT* = 0x00000010 + PRINTER_STATUS_MANUAL_FEED* = 0x00000020 + PRINTER_STATUS_PAPER_PROBLEM* = 0x00000040 + PRINTER_STATUS_OFFLINE* = 0x00000080 + PRINTER_STATUS_IO_ACTIVE* = 0x00000100 + PRINTER_STATUS_BUSY* = 0x00000200 + PRINTER_STATUS_PRINTING* = 0x00000400 + PRINTER_STATUS_OUTPUT_BIN_FULL* = 0x00000800 + PRINTER_STATUS_NOT_AVAILABLE* = 0x00001000 + PRINTER_STATUS_WAITING* = 0x00002000 + PRINTER_STATUS_PROCESSING* = 0x00004000 + PRINTER_STATUS_INITIALIZING* = 0x00008000 + PRINTER_STATUS_WARMING_UP* = 0x00010000 + PRINTER_STATUS_TONER_LOW* = 0x00020000 + PRINTER_STATUS_NO_TONER* = 0x00040000 + PRINTER_STATUS_PAGE_PUNT* = 0x00080000 + PRINTER_STATUS_USER_INTERVENTION* = 0x00100000 + PRINTER_STATUS_OUT_OF_MEMORY* = 0x00200000 + PRINTER_STATUS_DOOR_OPEN* = 0x00400000 + PRINTER_STATUS_SERVER_UNKNOWN* = 0x00800000 + PRINTER_STATUS_POWER_SAVE* = 0x01000000 + PRINTER_ATTRIBUTE_QUEUED* = 0x00000001 + PRINTER_ATTRIBUTE_DIRECT* = 0x00000002 + PRINTER_ATTRIBUTE_DEFAULT* = 0x00000004 + PRINTER_ATTRIBUTE_SHARED* = 0x00000008 + PRINTER_ATTRIBUTE_NETWORK* = 0x00000010 + PRINTER_ATTRIBUTE_HIDDEN* = 0x00000020 + PRINTER_ATTRIBUTE_LOCAL* = 0x00000040 + PRINTER_ATTRIBUTE_ENABLE_DEVQ* = 0x00000080 + PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS* = 0x00000100 + PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST* = 0x00000200 + PRINTER_ATTRIBUTE_WORK_OFFLINE* = 0x00000400 + PRINTER_ATTRIBUTE_ENABLE_BIDI* = 0x00000800 + PRINTER_ATTRIBUTE_RAW_ONLY* = 0x00001000 + PRINTER_ATTRIBUTE_PUBLISHED* = 0x00002000 + PRINTER_ATTRIBUTE_FAX* = 0x00004000 + PRINTER_ATTRIBUTE_TS* = 0x00008000 + NO_PRIORITY* = 0 + MAX_PRIORITY* = 99 + MIN_PRIORITY* = 1 + DEF_PRIORITY* = 1 + JOB_CONTROL_PAUSE* = 1 + JOB_CONTROL_RESUME* = 2 + JOB_CONTROL_CANCEL* = 3 + JOB_CONTROL_RESTART* = 4 + JOB_CONTROL_DELETE* = 5 + JOB_CONTROL_SENT_TO_PRINTER* = 6 + JOB_CONTROL_LAST_PAGE_EJECTED* = 7 + JOB_STATUS_PAUSED* = 0x00000001 + JOB_STATUS_ERROR* = 0x00000002 + JOB_STATUS_DELETING* = 0x00000004 + JOB_STATUS_SPOOLING* = 0x00000008 + JOB_STATUS_PRINTING* = 0x00000010 + JOB_STATUS_OFFLINE* = 0x00000020 + JOB_STATUS_PAPEROUT* = 0x00000040 + JOB_STATUS_PRINTED* = 0x00000080 + JOB_STATUS_DELETED* = 0x00000100 + JOB_STATUS_BLOCKED_DEVQ* = 0x00000200 + JOB_STATUS_USER_INTERVENTION* = 0x00000400 + JOB_STATUS_RESTART* = 0x00000800 + JOB_STATUS_COMPLETE* = 0x00001000 + JOB_POSITION_UNSPECIFIED* = 0 + DRIVER_KERNELMODE* = 0x00000001 + DRIVER_USERMODE* = 0x00000002 + DPD_DELETE_UNUSED_FILES* = 0x00000001 + DPD_DELETE_SPECIFIC_VERSION* = 0x00000002 + DPD_DELETE_ALL_FILES* = 0x00000004 + APD_STRICT_UPGRADE* = 0x00000001 + APD_STRICT_DOWNGRADE* = 0x00000002 + APD_COPY_ALL_FILES* = 0x00000004 + APD_COPY_NEW_FILES* = 0x00000008 + APD_COPY_FROM_DIRECTORY* = 0x00000010 + DI_CHANNEL* = 1 + DI_READ_SPOOL_JOB* = 3 + DI_MEMORYMAP_WRITE* = 0x00000001 + FORM_USER* = 0x00000000 + FORM_BUILTIN* = 0x00000001 + FORM_PRINTER* = 0x00000002 + NORMAL_PRINT* = 0x00000000 + REVERSE_PRINT* = 0x00000001 + PORT_TYPE_WRITE* = 0x0001 + PORT_TYPE_READ* = 0x0002 + PORT_TYPE_REDIRECTED* = 0x0004 + PORT_TYPE_NET_ATTACHED* = 0x0008 + PORT_STATUS_TYPE_ERROR* = 1 + PORT_STATUS_TYPE_WARNING* = 2 + PORT_STATUS_TYPE_INFO* = 3 + PORT_STATUS_OFFLINE* = 1 + PORT_STATUS_PAPER_JAM* = 2 + PORT_STATUS_PAPER_OUT* = 3 + PORT_STATUS_OUTPUT_BIN_FULL* = 4 + PORT_STATUS_PAPER_PROBLEM* = 5 + PORT_STATUS_NO_TONER* = 6 + PORT_STATUS_DOOR_OPEN* = 7 + PORT_STATUS_USER_INTERVENTION* = 8 + PORT_STATUS_OUT_OF_MEMORY* = 9 + PORT_STATUS_TONER_LOW* = 10 + PORT_STATUS_WARMING_UP* = 11 + PORT_STATUS_POWER_SAVE* = 12 + PRINTER_ENUM_DEFAULT* = 0x00000001 + PRINTER_ENUM_LOCAL* = 0x00000002 + PRINTER_ENUM_CONNECTIONS* = 0x00000004 + PRINTER_ENUM_FAVORITE* = 0x00000004 + PRINTER_ENUM_NAME* = 0x00000008 + PRINTER_ENUM_REMOTE* = 0x00000010 + PRINTER_ENUM_SHARED* = 0x00000020 + PRINTER_ENUM_NETWORK* = 0x00000040 + PRINTER_ENUM_EXPAND* = 0x00004000 + PRINTER_ENUM_CONTAINER* = 0x00008000 + PRINTER_ENUM_ICONMASK* = 0x00ff0000 + PRINTER_ENUM_ICON1* = 0x00010000 + PRINTER_ENUM_ICON2* = 0x00020000 + PRINTER_ENUM_ICON3* = 0x00040000 + PRINTER_ENUM_ICON4* = 0x00080000 + PRINTER_ENUM_ICON5* = 0x00100000 + PRINTER_ENUM_ICON6* = 0x00200000 + PRINTER_ENUM_ICON7* = 0x00400000 + PRINTER_ENUM_ICON8* = 0x00800000 + PRINTER_ENUM_HIDE* = 0x01000000 + SPOOL_FILE_PERSISTENT* = 0x00000001 + SPOOL_FILE_TEMPORARY* = 0x00000002 + PRINTER_NOTIFY_TYPE* = 0x00 + JOB_NOTIFY_TYPE* = 0x01 + PRINTER_NOTIFY_FIELD_SERVER_NAME* = 0x00 + PRINTER_NOTIFY_FIELD_PRINTER_NAME* = 0x01 + PRINTER_NOTIFY_FIELD_SHARE_NAME* = 0x02 + PRINTER_NOTIFY_FIELD_PORT_NAME* = 0x03 + PRINTER_NOTIFY_FIELD_DRIVER_NAME* = 0x04 + PRINTER_NOTIFY_FIELD_COMMENT* = 0x05 + PRINTER_NOTIFY_FIELD_LOCATION* = 0x06 + PRINTER_NOTIFY_FIELD_DEVMODE* = 0x07 + PRINTER_NOTIFY_FIELD_SEPFILE* = 0x08 + PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR* = 0x09 + PRINTER_NOTIFY_FIELD_PARAMETERS* = 0x0A + PRINTER_NOTIFY_FIELD_DATATYPE* = 0x0B + PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR* = 0x0C + PRINTER_NOTIFY_FIELD_ATTRIBUTES* = 0x0D + PRINTER_NOTIFY_FIELD_PRIORITY* = 0x0E + PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY* = 0x0F + PRINTER_NOTIFY_FIELD_START_TIME* = 0x10 + PRINTER_NOTIFY_FIELD_UNTIL_TIME* = 0x11 + PRINTER_NOTIFY_FIELD_STATUS* = 0x12 + PRINTER_NOTIFY_FIELD_STATUS_STRING* = 0x13 + PRINTER_NOTIFY_FIELD_CJOBS* = 0x14 + PRINTER_NOTIFY_FIELD_AVERAGE_PPM* = 0x15 + PRINTER_NOTIFY_FIELD_TOTAL_PAGES* = 0x16 + PRINTER_NOTIFY_FIELD_PAGES_PRINTED* = 0x17 + PRINTER_NOTIFY_FIELD_TOTAL_BYTES* = 0x18 + PRINTER_NOTIFY_FIELD_BYTES_PRINTED* = 0x19 + PRINTER_NOTIFY_FIELD_OBJECT_GUID* = 0x1A + JOB_NOTIFY_FIELD_PRINTER_NAME* = 0x00 + JOB_NOTIFY_FIELD_MACHINE_NAME* = 0x01 + JOB_NOTIFY_FIELD_PORT_NAME* = 0x02 + JOB_NOTIFY_FIELD_USER_NAME* = 0x03 + JOB_NOTIFY_FIELD_NOTIFY_NAME* = 0x04 + JOB_NOTIFY_FIELD_DATATYPE* = 0x05 + JOB_NOTIFY_FIELD_PRINT_PROCESSOR* = 0x06 + JOB_NOTIFY_FIELD_PARAMETERS* = 0x07 + JOB_NOTIFY_FIELD_DRIVER_NAME* = 0x08 + JOB_NOTIFY_FIELD_DEVMODE* = 0x09 + JOB_NOTIFY_FIELD_STATUS* = 0x0A + JOB_NOTIFY_FIELD_STATUS_STRING* = 0x0B + JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR* = 0x0C + JOB_NOTIFY_FIELD_DOCUMENT* = 0x0D + JOB_NOTIFY_FIELD_PRIORITY* = 0x0E + JOB_NOTIFY_FIELD_POSITION* = 0x0F + JOB_NOTIFY_FIELD_SUBMITTED* = 0x10 + JOB_NOTIFY_FIELD_START_TIME* = 0x11 + JOB_NOTIFY_FIELD_UNTIL_TIME* = 0x12 + JOB_NOTIFY_FIELD_TIME* = 0x13 + JOB_NOTIFY_FIELD_TOTAL_PAGES* = 0x14 + JOB_NOTIFY_FIELD_PAGES_PRINTED* = 0x15 + JOB_NOTIFY_FIELD_TOTAL_BYTES* = 0x16 + JOB_NOTIFY_FIELD_BYTES_PRINTED* = 0x17 + PRINTER_NOTIFY_OPTIONS_REFRESH* = 0x01 + PRINTER_NOTIFY_INFO_DISCARDED* = 0x01 + BIDI_ACTION_ENUM_SCHEMA* = "EnumSchema" + BIDI_ACTION_GET* = "Get" + BIDI_ACTION_SET* = "Set" + BIDI_ACTION_GET_ALL* = "GetAll" + BIDI_NULL* = 0 + BIDI_INT* = 1 + BIDI_FLOAT* = 2 + BIDI_BOOL* = 3 + BIDI_STRING* = 4 + BIDI_TEXT* = 5 + BIDI_ENUM* = 6 + BIDI_BLOB* = 7 + BIDI_ACCESS_ADMINISTRATOR* = 0x1 + BIDI_ACCESS_USER* = 0x2 + ERROR_BIDI_STATUS_OK* = 0 + ERROR_BIDI_NOT_SUPPORTED* = ERROR_NOT_SUPPORTED + ERROR_BIDI_ERROR_BASE* = 13000 + ERROR_BIDI_STATUS_WARNING* = ERROR_BIDI_ERROR_BASE+1 + ERROR_BIDI_SCHEMA_READ_ONLY* = ERROR_BIDI_ERROR_BASE+2 + ERROR_BIDI_SERVER_OFFLINE* = ERROR_BIDI_ERROR_BASE+3 + ERROR_BIDI_DEVICE_OFFLINE* = ERROR_BIDI_ERROR_BASE+4 + ERROR_BIDI_SCHEMA_NOT_SUPPORTED* = ERROR_BIDI_ERROR_BASE+5 + PRINTER_CHANGE_ADD_PRINTER* = 0x00000001 + PRINTER_CHANGE_SET_PRINTER* = 0x00000002 + PRINTER_CHANGE_DELETE_PRINTER* = 0x00000004 + PRINTER_CHANGE_FAILED_CONNECTION_PRINTER* = 0x00000008 + PRINTER_CHANGE_PRINTER* = 0x000000FF + PRINTER_CHANGE_ADD_JOB* = 0x00000100 + PRINTER_CHANGE_SET_JOB* = 0x00000200 + PRINTER_CHANGE_DELETE_JOB* = 0x00000400 + PRINTER_CHANGE_WRITE_JOB* = 0x00000800 + PRINTER_CHANGE_JOB* = 0x0000FF00 + PRINTER_CHANGE_ADD_FORM* = 0x00010000 + PRINTER_CHANGE_SET_FORM* = 0x00020000 + PRINTER_CHANGE_DELETE_FORM* = 0x00040000 + PRINTER_CHANGE_FORM* = 0x00070000 + PRINTER_CHANGE_ADD_PORT* = 0x00100000 + PRINTER_CHANGE_CONFIGURE_PORT* = 0x00200000 + PRINTER_CHANGE_DELETE_PORT* = 0x00400000 + PRINTER_CHANGE_PORT* = 0x00700000 + PRINTER_CHANGE_ADD_PRINT_PROCESSOR* = 0x01000000 + PRINTER_CHANGE_DELETE_PRINT_PROCESSOR* = 0x04000000 + PRINTER_CHANGE_PRINT_PROCESSOR* = 0x07000000 + PRINTER_CHANGE_ADD_PRINTER_DRIVER* = 0x10000000 + PRINTER_CHANGE_SET_PRINTER_DRIVER* = 0x20000000 + PRINTER_CHANGE_DELETE_PRINTER_DRIVER* = 0x40000000 + PRINTER_CHANGE_PRINTER_DRIVER* = 0x70000000 + PRINTER_CHANGE_TIMEOUT* = 0x80000000'i32 + PRINTER_CHANGE_ALL* = 0x7777FFFF + PRINTER_ERROR_INFORMATION* = 0x80000000'i32 + PRINTER_ERROR_WARNING* = 0x40000000 + PRINTER_ERROR_SEVERE* = 0x20000000 + PRINTER_ERROR_OUTOFPAPER* = 0x00000001 + PRINTER_ERROR_JAM* = 0x00000002 + PRINTER_ERROR_OUTOFTONER* = 0x00000004 + SPLREG_DEFAULT_SPOOL_DIRECTORY* = "DefaultSpoolDirectory" + SPLREG_PORT_THREAD_PRIORITY_DEFAULT* = "PortThreadPriorityDefault" + SPLREG_PORT_THREAD_PRIORITY* = "PortThreadPriority" + SPLREG_SCHEDULER_THREAD_PRIORITY_DEFAULT* = "SchedulerThreadPriorityDefault" + SPLREG_SCHEDULER_THREAD_PRIORITY* = "SchedulerThreadPriority" + SPLREG_BEEP_ENABLED* = "BeepEnabled" + SPLREG_NET_POPUP* = "NetPopup" + SPLREG_RETRY_POPUP* = "RetryPopup" + SPLREG_NET_POPUP_TO_COMPUTER* = "NetPopupToComputer" + SPLREG_EVENT_LOG* = "EventLog" + SPLREG_MAJOR_VERSION* = "MajorVersion" + SPLREG_MINOR_VERSION* = "MinorVersion" + SPLREG_ARCHITECTURE* = "Architecture" + SPLREG_OS_VERSION* = "OSVersion" + SPLREG_OS_VERSIONEX* = "OSVersionEx" + SPLREG_DS_PRESENT* = "DsPresent" + SPLREG_DS_PRESENT_FOR_USER* = "DsPresentForUser" + SPLREG_REMOTE_FAX* = "RemoteFax" + SPLREG_RESTART_JOB_ON_POOL_ERROR* = "RestartJobOnPoolError" + SPLREG_RESTART_JOB_ON_POOL_ENABLED* = "RestartJobOnPoolEnabled" + SPLREG_DNS_MACHINE_NAME* = "DNSMachineName" + SPLREG_ALLOW_USER_MANAGEFORMS* = "AllowUserManageForms" + SPLREG_WEBSHAREMGMT* = "WebShareMgmt" + SERVER_ACCESS_ADMINISTER* = 0x00000001 + SERVER_ACCESS_ENUMERATE* = 0x00000002 + PRINTER_ACCESS_ADMINISTER* = 0x00000004 + PRINTER_ACCESS_USE* = 0x00000008 + JOB_ACCESS_ADMINISTER* = 0x00000010 + JOB_ACCESS_READ* = 0x00000020 + SERVER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SERVER_ACCESS_ADMINISTER or SERVER_ACCESS_ENUMERATE + SERVER_READ* = STANDARD_RIGHTS_READ or SERVER_ACCESS_ENUMERATE + SERVER_WRITE* = STANDARD_RIGHTS_WRITE or SERVER_ACCESS_ADMINISTER or SERVER_ACCESS_ENUMERATE + SERVER_EXECUTE* = STANDARD_RIGHTS_EXECUTE or SERVER_ACCESS_ENUMERATE + PRINTER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or PRINTER_ACCESS_ADMINISTER or PRINTER_ACCESS_USE + PRINTER_READ* = STANDARD_RIGHTS_READ or PRINTER_ACCESS_USE + PRINTER_WRITE* = STANDARD_RIGHTS_WRITE or PRINTER_ACCESS_USE + PRINTER_EXECUTE* = STANDARD_RIGHTS_EXECUTE or PRINTER_ACCESS_USE + JOB_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or JOB_ACCESS_ADMINISTER or JOB_ACCESS_READ + JOB_READ* = STANDARD_RIGHTS_READ or JOB_ACCESS_READ + JOB_WRITE* = STANDARD_RIGHTS_WRITE or JOB_ACCESS_ADMINISTER + JOB_EXECUTE* = STANDARD_RIGHTS_EXECUTE or JOB_ACCESS_ADMINISTER + SPLDS_SPOOLER_KEY* = "DsSpooler" + SPLDS_DRIVER_KEY* = "DsDriver" + SPLDS_USER_KEY* = "DsUser" + SPLDS_ASSET_NUMBER* = "assetNumber" + SPLDS_BYTES_PER_MINUTE* = "bytesPerMinute" + SPLDS_DESCRIPTION* = "description" + SPLDS_DRIVER_NAME* = "driverName" + SPLDS_DRIVER_VERSION* = "driverVersion" + SPLDS_LOCATION* = "location" + SPLDS_PORT_NAME* = "portName" + SPLDS_PRINT_ATTRIBUTES* = "printAttributes" + SPLDS_PRINT_BIN_NAMES* = "printBinNames" + SPLDS_PRINT_COLLATE* = "printCollate" + SPLDS_PRINT_COLOR* = "printColor" + SPLDS_PRINT_DUPLEX_SUPPORTED* = "printDuplexSupported" + SPLDS_PRINT_END_TIME* = "printEndTime" + SPLDS_PRINTER_CLASS* = "printQueue" + SPLDS_PRINTER_NAME* = "printerName" + SPLDS_PRINT_KEEP_PRINTED_JOBS* = "printKeepPrintedJobs" + SPLDS_PRINT_LANGUAGE* = "printLanguage" + SPLDS_PRINT_MAC_ADDRESS* = "printMACAddress" + SPLDS_PRINT_MAX_X_EXTENT* = "printMaxXExtent" + SPLDS_PRINT_MAX_Y_EXTENT* = "printMaxYExtent" + SPLDS_PRINT_MAX_RESOLUTION_SUPPORTED* = "printMaxResolutionSupported" + SPLDS_PRINT_MEDIA_READY* = "printMediaReady" + SPLDS_PRINT_MEDIA_SUPPORTED* = "printMediaSupported" + SPLDS_PRINT_MEMORY* = "printMemory" + SPLDS_PRINT_MIN_X_EXTENT* = "printMinXExtent" + SPLDS_PRINT_MIN_Y_EXTENT* = "printMinYExtent" + SPLDS_PRINT_NETWORK_ADDRESS* = "printNetworkAddress" + SPLDS_PRINT_NOTIFY* = "printNotify" + SPLDS_PRINT_NUMBER_UP* = "printNumberUp" + SPLDS_PRINT_ORIENTATIONS_SUPPORTED* = "printOrientationsSupported" + SPLDS_PRINT_OWNER* = "printOwner" + SPLDS_PRINT_PAGES_PER_MINUTE* = "printPagesPerMinute" + SPLDS_PRINT_RATE* = "printRate" + SPLDS_PRINT_RATE_UNIT* = "printRateUnit" + SPLDS_PRINT_SEPARATOR_FILE* = "printSeparatorFile" + SPLDS_PRINT_SHARE_NAME* = "printShareName" + SPLDS_PRINT_SPOOLING* = "printSpooling" + SPLDS_PRINT_STAPLING_SUPPORTED* = "printStaplingSupported" + SPLDS_PRINT_START_TIME* = "printStartTime" + SPLDS_PRINT_STATUS* = "printStatus" + SPLDS_PRIORITY* = "priority" + SPLDS_SERVER_NAME* = "serverName" + SPLDS_SHORT_SERVER_NAME* = "shortServerName" + SPLDS_UNC_NAME* = "uNCName" + SPLDS_URL* = "url" + SPLDS_FLAGS* = "flags" + SPLDS_VERSION_NUMBER* = "versionNumber" + SPLDS_PRINTER_NAME_ALIASES* = "printerNameAliases" + SPLDS_PRINTER_LOCATIONS* = "printerLocations" + SPLDS_PRINTER_MODEL* = "printerModel" + PRINTER_CONNECTION_MISMATCH* = 0x00000020 + PRINTER_CONNECTION_NO_UI* = 0x00000040 + PRINTER_OPTION_NO_CACHE* = 0 + PRINTER_OPTION_CACHE* = 1 + PRINTER_OPTION_CLIENT_CHANGE* = 2 + kJobProduction* = 0 + kJobConsumption* = 1 + kAddingDocumentSequence* = 0 + kDocumentSequenceAdded* = 1 + kAddingFixedDocument* = 2 + kFixedDocumentAdded* = 3 + kAddingFixedPage* = 4 + kFixedPageAdded* = 5 + kResourceAdded* = 6 + kFontAdded* = 7 + kImageAdded* = 8 + kXpsDocumentCommitted* = 9 +proc EnumPrintersA*(Flags: DWORD, Name: LPSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrintersW*(Flags: DWORD, Name: LPWSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc OpenPrinterA*(pPrinterName: LPSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSA): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc OpenPrinterW*(pPrinterName: LPWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSW): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ResetPrinterA*(hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSA): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ResetPrinterW*(hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSW): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetJobA*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetJobW*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetJobA*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetJobW*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumJobsA*(hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumJobsW*(hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterA*(pName: LPSTR, Level: DWORD, pPrinter: LPBYTE): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterW*(pName: LPWSTR, Level: DWORD, pPrinter: LPBYTE): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterA*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterW*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterA*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterW*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterDriverA*(pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterDriverW*(pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterDriverExA*(pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterDriverExW*(pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDriversA*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDriversW*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverA*(hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverW*(hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverDirectoryA*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverDirectoryW*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverA*(pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverW*(pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverExA*(pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverExW*(pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrintProcessorA*(pName: LPSTR, pEnvironment: LPSTR, pPathName: LPSTR, pPrintProcessorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrintProcessorW*(pName: LPWSTR, pEnvironment: LPWSTR, pPathName: LPWSTR, pPrintProcessorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrintProcessorsA*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrintProcessorsW*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrintProcessorDirectoryA*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrintProcessorDirectoryW*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrintProcessorDatatypesA*(pName: LPSTR, pPrintProcessorName: LPSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrintProcessorDatatypesW*(pName: LPWSTR, pPrintProcessorName: LPWSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrintProcessorA*(pName: LPSTR, pEnvironment: LPSTR, pPrintProcessorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrintProcessorW*(pName: LPWSTR, pEnvironment: LPWSTR, pPrintProcessorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc StartDocPrinterA*(hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc StartDocPrinterW*(hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc StartPagePrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc WritePrinter*(hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc FlushPrinter*(hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD, cSleep: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EndPagePrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AbortPrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ReadPrinter*(hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pNoBytesRead: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EndDocPrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddJobA*(hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddJobW*(hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ScheduleJob*(hPrinter: HANDLE, JobId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc PrinterProperties*(hWnd: HWND, hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DocumentPropertiesA*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA, fMode: DWORD): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DocumentPropertiesW*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW, fMode: DWORD): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AdvancedDocumentPropertiesA*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AdvancedDocumentPropertiesW*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ExtDeviceMode*(hWnd: HWND, hInst: HANDLE, pDevModeOutput: LPDEVMODEA, pDeviceName: LPSTR, pPort: LPSTR, pDevModeInput: LPDEVMODEA, pProfile: LPSTR, fMode: DWORD): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDataA*(hPrinter: HANDLE, pValueName: LPSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDataW*(hPrinter: HANDLE, pValueName: LPWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDataExA*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDataExW*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDataA*(hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDataW*(hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPWSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDataExA*(hPrinter: HANDLE, pKeyName: LPCSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterDataExW*(hPrinter: HANDLE, pKeyName: LPCWSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterKeyA*(hPrinter: HANDLE, pKeyName: LPCSTR, pSubkey: LPSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPrinterKeyW*(hPrinter: HANDLE, pKeyName: LPCWSTR, pSubkey: LPWSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterDataA*(hPrinter: HANDLE, pValueName: LPSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterDataW*(hPrinter: HANDLE, pValueName: LPWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterDataExA*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPrinterDataExW*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDataA*(hPrinter: HANDLE, pValueName: LPSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDataW*(hPrinter: HANDLE, pValueName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDataExA*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDataExW*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterKeyA*(hPrinter: HANDLE, pKeyName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterKeyW*(hPrinter: HANDLE, pKeyName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc WaitForPrinterChange*(hPrinter: HANDLE, Flags: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc FindFirstPrinterChangeNotification*(hPrinter: HANDLE, fdwFlags: DWORD, fdwOptions: DWORD, pPrinterNotifyOptions: LPVOID): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc FindNextPrinterChangeNotification*(hChange: HANDLE, pdwChange: PDWORD, pPrinterNotifyOptions: LPVOID, ppPrinterNotifyInfo: ptr LPVOID): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc FreePrinterNotifyInfo*(pPrinterNotifyInfo: PPRINTER_NOTIFY_INFO): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc FindClosePrinterChangeNotification*(hChange: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc PrinterMessageBoxA*(hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPSTR, pCaption: LPSTR, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc PrinterMessageBoxW*(hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPWSTR, pCaption: LPWSTR, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ClosePrinter*(hPrinter: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddFormA*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddFormW*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeleteFormA*(hPrinter: HANDLE, pFormName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeleteFormW*(hPrinter: HANDLE, pFormName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetFormA*(hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetFormW*(hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetFormA*(hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetFormW*(hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumFormsA*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumFormsW*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumMonitorsA*(pName: LPSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumMonitorsW*(pName: LPWSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddMonitorA*(pName: LPSTR, Level: DWORD, pMonitorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddMonitorW*(pName: LPWSTR, Level: DWORD, pMonitorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeleteMonitorA*(pName: LPSTR, pEnvironment: LPSTR, pMonitorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeleteMonitorW*(pName: LPWSTR, pEnvironment: LPWSTR, pMonitorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPortsA*(pName: LPSTR, Level: DWORD, pPorts: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc EnumPortsW*(pName: LPWSTR, Level: DWORD, pPorts: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPortA*(pName: LPSTR, hWnd: HWND, pMonitorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPortW*(pName: LPWSTR, hWnd: HWND, pMonitorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ConfigurePortA*(pName: LPSTR, hWnd: HWND, pPortName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ConfigurePortW*(pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePortA*(pName: LPSTR, hWnd: HWND, pPortName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePortW*(pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc XcvDataW*(hXcv: HANDLE, pszDataName: PCWSTR, pInputData: PBYTE, cbInputData: DWORD, pOutputData: PBYTE, cbOutputData: DWORD, pcbOutputNeeded: PDWORD, pdwStatus: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc XcvData*(hXcv: HANDLE, pszDataName: PCWSTR, pInputData: PBYTE, cbInputData: DWORD, pOutputData: PBYTE, cbOutputData: DWORD, pcbOutputNeeded: PDWORD, pdwStatus: PDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "XcvDataW".} +proc GetDefaultPrinterA*(pszBuffer: LPSTR, pcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetDefaultPrinterW*(pszBuffer: LPWSTR, pcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetDefaultPrinterA*(pszPrinter: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetDefaultPrinterW*(pszPrinter: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPortA*(pName: LPSTR, pPortName: LPSTR, dwLevel: DWORD, pPortInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc SetPortW*(pName: LPWSTR, pPortName: LPWSTR, dwLevel: DWORD, pPortInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterConnectionA*(pName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterConnectionW*(pName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterConnectionA*(pName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterConnectionW*(pName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ConnectToPrinterDlg*(hwnd: HWND, Flags: DWORD): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrintProvidorA*(pName: LPSTR, level: DWORD, pProvidorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrintProvidorW*(pName: LPWSTR, level: DWORD, pProvidorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrintProvidorA*(pName: LPSTR, pEnvironment: LPSTR, pPrintProvidorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrintProvidorW*(pName: LPWSTR, pEnvironment: LPWSTR, pPrintProvidorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc IsValidDevmodeA*(pDevmode: PDEVMODEA, DevmodeSize: int): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc IsValidDevmodeW*(pDevmode: PDEVMODEW, DevmodeSize: int): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterConnection2W*(hWnd: HWND, pszName: LPCWSTR, dwLevel: DWORD, pConnectionInfo: PVOID): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc AddPrinterConnection2A*(hWnd: HWND, pszName: LPCSTR, dwLevel: DWORD, pConnectionInfo: PVOID): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverPackageA*(pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc DeletePrinterDriverPackageW*(pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc ReportJobProcessingProgress*(printerHandle: HANDLE, jobId: ULONG, jobOperation: EPrintXPSJobOperation, jobProgress: EPrintXPSJobProgress): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetCorePrinterDriversA*(pszServer: LPCSTR, pszEnvironment: LPCSTR, pszzCoreDriverDependencies: LPCSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERA): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetCorePrinterDriversW*(pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszzCoreDriverDependencies: LPCWSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERW): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriver2A*(hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriver2W*(hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverPackagePathA*(pszServer: LPCSTR, pszEnvironment: LPCSTR, pszLanguage: LPCSTR, pszPackageID: LPCSTR, pszDriverPackageCab: LPSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc GetPrinterDriverPackagePathW*(pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszLanguage: LPCWSTR, pszPackageID: LPCWSTR, pszDriverPackageCab: LPWSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc CommitSpoolData*(hPrinter: HANDLE, hSpoolFile: HANDLE, cbCommit: DWORD): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc CloseSpoolFileHandle*(hPrinter: HANDLE, hSpoolFile: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +when winimUnicode: + type + LPPRINTER_DEFAULTS* = LPPRINTER_DEFAULTSW +when winimAnsi: + type + LPPRINTER_DEFAULTS* = LPPRINTER_DEFAULTSA +proc OpenPrinter2A*(pPrinterName: LPCSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTS, pOptions: PPRINTER_OPTIONS): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc OpenPrinter2W*(pPrinterName: LPCWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTS, pOptions: PPRINTER_OPTIONS): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc UploadPrinterDriverPackageA*(pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPSTR, pcchDestInfPath: PULONG): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +proc UploadPrinterDriverPackageW*(pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPWSTR, pcchDestInfPath: PULONG): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc.} +when winimUnicode: + type + PRINTER_INFO_1* = PRINTER_INFO_1W + PPRINTER_INFO_1* = PPRINTER_INFO_1W + LPPRINTER_INFO_1* = LPPRINTER_INFO_1W + PRINTER_INFO_2* = PRINTER_INFO_2W + PPRINTER_INFO_2* = PPRINTER_INFO_2W + LPPRINTER_INFO_2* = LPPRINTER_INFO_2W + PRINTER_INFO_4* = PRINTER_INFO_4W + PPRINTER_INFO_4* = PPRINTER_INFO_4W + LPPRINTER_INFO_4* = LPPRINTER_INFO_4W + PRINTER_INFO_5* = PRINTER_INFO_5W + PPRINTER_INFO_5* = PPRINTER_INFO_5W + LPPRINTER_INFO_5* = LPPRINTER_INFO_5W + PRINTER_INFO_7* = PRINTER_INFO_7W + PPRINTER_INFO_7* = PPRINTER_INFO_7W + LPPRINTER_INFO_7* = LPPRINTER_INFO_7W + PRINTER_INFO_8* = PRINTER_INFO_8W + PPRINTER_INFO_8* = PPRINTER_INFO_8W + LPPRINTER_INFO_8* = LPPRINTER_INFO_8W + PRINTER_INFO_9* = PRINTER_INFO_9W + PPRINTER_INFO_9* = PPRINTER_INFO_9W + LPPRINTER_INFO_9* = LPPRINTER_INFO_9W + JOB_INFO_1* = JOB_INFO_1W + PJOB_INFO_1* = PJOB_INFO_1W + LPJOB_INFO_1* = LPJOB_INFO_1W + JOB_INFO_2* = JOB_INFO_2W + PJOB_INFO_2* = PJOB_INFO_2W + LPJOB_INFO_2* = LPJOB_INFO_2W + ADDJOB_INFO_1* = ADDJOB_INFO_1W + PADDJOB_INFO_1* = PADDJOB_INFO_1W + LPADDJOB_INFO_1* = LPADDJOB_INFO_1W + DRIVER_INFO_1* = DRIVER_INFO_1W + PDRIVER_INFO_1* = PDRIVER_INFO_1W + LPDRIVER_INFO_1* = LPDRIVER_INFO_1W + DRIVER_INFO_2* = DRIVER_INFO_2W + PDRIVER_INFO_2* = PDRIVER_INFO_2W + LPDRIVER_INFO_2* = LPDRIVER_INFO_2W + DRIVER_INFO_3* = DRIVER_INFO_3W + PDRIVER_INFO_3* = PDRIVER_INFO_3W + LPDRIVER_INFO_3* = LPDRIVER_INFO_3W + DRIVER_INFO_4* = DRIVER_INFO_4W + PDRIVER_INFO_4* = PDRIVER_INFO_4W + LPDRIVER_INFO_4* = LPDRIVER_INFO_4W + DRIVER_INFO_5* = DRIVER_INFO_5W + PDRIVER_INFO_5* = PDRIVER_INFO_5W + LPDRIVER_INFO_5* = LPDRIVER_INFO_5W + DRIVER_INFO_6* = DRIVER_INFO_6W + PDRIVER_INFO_6* = PDRIVER_INFO_6W + LPDRIVER_INFO_6* = LPDRIVER_INFO_6W + DOC_INFO_1* = DOC_INFO_1W + PDOC_INFO_1* = PDOC_INFO_1W + LPDOC_INFO_1* = LPDOC_INFO_1W + FORM_INFO_1* = FORM_INFO_1W + PFORM_INFO_1* = PFORM_INFO_1W + LPFORM_INFO_1* = LPFORM_INFO_1W + DOC_INFO_2* = DOC_INFO_2W + PDOC_INFO_2* = PDOC_INFO_2W + LPDOC_INFO_2* = LPDOC_INFO_2W + DOC_INFO_3* = DOC_INFO_3W + PDOC_INFO_3* = PDOC_INFO_3W + LPDOC_INFO_3* = LPDOC_INFO_3W + PRINTPROCESSOR_INFO_1* = PRINTPROCESSOR_INFO_1W + PPRINTPROCESSOR_INFO_1* = PPRINTPROCESSOR_INFO_1W + LPPRINTPROCESSOR_INFO_1* = LPPRINTPROCESSOR_INFO_1W + PORT_INFO_1* = PORT_INFO_1W + PPORT_INFO_1* = PPORT_INFO_1W + LPPORT_INFO_1* = LPPORT_INFO_1W + PORT_INFO_2* = PORT_INFO_2W + PPORT_INFO_2* = PPORT_INFO_2W + LPPORT_INFO_2* = LPPORT_INFO_2W + PORT_INFO_3* = PORT_INFO_3W + PPORT_INFO_3* = PPORT_INFO_3W + LPPORT_INFO_3* = LPPORT_INFO_3W + MONITOR_INFO_1* = MONITOR_INFO_1W + PMONITOR_INFO_1* = PMONITOR_INFO_1W + LPMONITOR_INFO_1* = LPMONITOR_INFO_1W + MONITOR_INFO_2* = MONITOR_INFO_2W + PMONITOR_INFO_2* = PMONITOR_INFO_2W + LPMONITOR_INFO_2* = LPMONITOR_INFO_2W + DATATYPES_INFO_1* = DATATYPES_INFO_1W + PDATATYPES_INFO_1* = PDATATYPES_INFO_1W + LPDATATYPES_INFO_1* = LPDATATYPES_INFO_1W + PRINTER_DEFAULTS* = PRINTER_DEFAULTSW + PPRINTER_DEFAULTS* = PPRINTER_DEFAULTSW + PRINTER_ENUM_VALUES* = PRINTER_ENUM_VALUESW + PPRINTER_ENUM_VALUES* = PPRINTER_ENUM_VALUESW + LPPRINTER_ENUM_VALUES* = LPPRINTER_ENUM_VALUESW + PROVIDOR_INFO_1* = PROVIDOR_INFO_1W + PPROVIDOR_INFO_1* = PPROVIDOR_INFO_1W + LPPROVIDOR_INFO_1* = LPPROVIDOR_INFO_1W + PROVIDOR_INFO_2* = PROVIDOR_INFO_2W + PPROVIDOR_INFO_2* = PPROVIDOR_INFO_2W + LPPROVIDOR_INFO_2* = LPPROVIDOR_INFO_2W + DRIVER_INFO_8* = DRIVER_INFO_8W + PDRIVER_INFO_8* = PDRIVER_INFO_8W + LPDRIVER_INFO_8* = LPDRIVER_INFO_8W + FORM_INFO_2* = FORM_INFO_2W + PFORM_INFO_2* = PFORM_INFO_2W + CORE_PRINTER_DRIVER* = CORE_PRINTER_DRIVERW + PCORE_PRINTER_DRIVER* = PCORE_PRINTER_DRIVERW + proc EnumPrinters*(Flags: DWORD, Name: LPWSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintersW".} + proc OpenPrinter*(pPrinterName: LPWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSW): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "OpenPrinterW".} + proc ResetPrinter*(hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSW): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "ResetPrinterW".} + proc SetJob*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetJobW".} + proc GetJob*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetJobW".} + proc EnumJobs*(hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumJobsW".} + proc AddPrinter*(pName: LPWSTR, Level: DWORD, pPrinter: LPBYTE): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterW".} + proc SetPrinter*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterW".} + proc GetPrinter*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterW".} + proc AddPrinterDriver*(pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterDriverW".} + proc AddPrinterDriverEx*(pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterDriverExW".} + proc EnumPrinterDrivers*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDriversW".} + proc GetPrinterDriver*(hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverW".} + proc GetPrinterDriverDirectory*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverDirectoryW".} + proc DeletePrinterDriver*(pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverW".} + proc DeletePrinterDriverEx*(pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverExW".} + proc AddPrintProcessor*(pName: LPWSTR, pEnvironment: LPWSTR, pPathName: LPWSTR, pPrintProcessorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrintProcessorW".} + proc EnumPrintProcessors*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintProcessorsW".} + proc GetPrintProcessorDirectory*(pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrintProcessorDirectoryW".} + proc EnumPrintProcessorDatatypes*(pName: LPWSTR, pPrintProcessorName: LPWSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintProcessorDatatypesW".} + proc DeletePrintProcessor*(pName: LPWSTR, pEnvironment: LPWSTR, pPrintProcessorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrintProcessorW".} + proc StartDocPrinter*(hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "StartDocPrinterW".} + proc AddJob*(hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddJobW".} + proc DocumentProperties*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW, fMode: DWORD): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc: "DocumentPropertiesW".} + proc AdvancedDocumentProperties*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc: "AdvancedDocumentPropertiesW".} + proc GetPrinterData*(hPrinter: HANDLE, pValueName: LPWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDataW".} + proc GetPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDataExW".} + proc EnumPrinterData*(hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPWSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDataW".} + proc EnumPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCWSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDataExW".} + proc EnumPrinterKey*(hPrinter: HANDLE, pKeyName: LPCWSTR, pSubkey: LPWSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterKeyW".} + proc SetPrinterData*(hPrinter: HANDLE, pValueName: LPWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterDataW".} + proc SetPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterDataExW".} + proc DeletePrinterData*(hPrinter: HANDLE, pValueName: LPWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDataW".} + proc DeletePrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDataExW".} + proc DeletePrinterKey*(hPrinter: HANDLE, pKeyName: LPCWSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterKeyW".} + proc PrinterMessageBox*(hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPWSTR, pCaption: LPWSTR, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "PrinterMessageBoxW".} + proc AddForm*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddFormW".} + proc DeleteForm*(hPrinter: HANDLE, pFormName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeleteFormW".} + proc GetForm*(hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetFormW".} + proc SetForm*(hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetFormW".} + proc EnumForms*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumFormsW".} + proc EnumMonitors*(pName: LPWSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumMonitorsW".} + proc AddMonitor*(pName: LPWSTR, Level: DWORD, pMonitorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddMonitorW".} + proc DeleteMonitor*(pName: LPWSTR, pEnvironment: LPWSTR, pMonitorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeleteMonitorW".} + proc EnumPorts*(pName: LPWSTR, Level: DWORD, pPorts: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPortsW".} + proc AddPort*(pName: LPWSTR, hWnd: HWND, pMonitorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPortW".} + proc ConfigurePort*(pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "ConfigurePortW".} + proc DeletePort*(pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePortW".} + proc GetDefaultPrinter*(pszBuffer: LPWSTR, pcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetDefaultPrinterW".} + proc SetDefaultPrinter*(pszPrinter: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetDefaultPrinterW".} + proc SetPort*(pName: LPWSTR, pPortName: LPWSTR, dwLevel: DWORD, pPortInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPortW".} + proc AddPrinterConnection*(pName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterConnectionW".} + proc DeletePrinterConnection*(pName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterConnectionW".} + proc AddPrintProvidor*(pName: LPWSTR, level: DWORD, pProvidorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrintProvidorW".} + proc DeletePrintProvidor*(pName: LPWSTR, pEnvironment: LPWSTR, pPrintProvidorName: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrintProvidorW".} + proc IsValidDevmode*(pDevmode: PDEVMODEW, DevmodeSize: int): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "IsValidDevmodeW".} + proc AddPrinterConnection2*(hWnd: HWND, pszName: LPCWSTR, dwLevel: DWORD, pConnectionInfo: PVOID): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterConnection2W".} + proc DeletePrinterDriverPackage*(pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverPackageW".} + proc GetCorePrinterDrivers*(pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszzCoreDriverDependencies: LPCWSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERW): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetCorePrinterDriversW".} + proc GetPrinterDriver2*(hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriver2W".} + proc GetPrinterDriverPackagePath*(pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszLanguage: LPCWSTR, pszPackageID: LPCWSTR, pszDriverPackageCab: LPWSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverPackagePathW".} + proc OpenPrinter2*(pPrinterName: LPCWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTS, pOptions: PPRINTER_OPTIONS): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "OpenPrinter2W".} + proc UploadPrinterDriverPackage*(pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPWSTR, pcchDestInfPath: PULONG): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "UploadPrinterDriverPackageW".} +when winimAnsi: + type + PRINTER_INFO_1* = PRINTER_INFO_1A + PPRINTER_INFO_1* = PPRINTER_INFO_1A + LPPRINTER_INFO_1* = LPPRINTER_INFO_1A + PRINTER_INFO_2* = PRINTER_INFO_2A + PPRINTER_INFO_2* = PPRINTER_INFO_2A + LPPRINTER_INFO_2* = LPPRINTER_INFO_2A + PRINTER_INFO_4* = PRINTER_INFO_4A + PPRINTER_INFO_4* = PPRINTER_INFO_4A + LPPRINTER_INFO_4* = LPPRINTER_INFO_4A + PRINTER_INFO_5* = PRINTER_INFO_5A + PPRINTER_INFO_5* = PPRINTER_INFO_5A + LPPRINTER_INFO_5* = LPPRINTER_INFO_5A + PRINTER_INFO_7* = PRINTER_INFO_7A + PPRINTER_INFO_7* = PPRINTER_INFO_7A + LPPRINTER_INFO_7* = LPPRINTER_INFO_7A + PRINTER_INFO_8* = PRINTER_INFO_8A + PPRINTER_INFO_8* = PPRINTER_INFO_8A + LPPRINTER_INFO_8* = LPPRINTER_INFO_8A + PRINTER_INFO_9* = PRINTER_INFO_9A + PPRINTER_INFO_9* = PPRINTER_INFO_9A + LPPRINTER_INFO_9* = LPPRINTER_INFO_9A + JOB_INFO_1* = JOB_INFO_1A + PJOB_INFO_1* = PJOB_INFO_1A + LPJOB_INFO_1* = LPJOB_INFO_1A + JOB_INFO_2* = JOB_INFO_2A + PJOB_INFO_2* = PJOB_INFO_2A + LPJOB_INFO_2* = LPJOB_INFO_2A + ADDJOB_INFO_1* = ADDJOB_INFO_1A + PADDJOB_INFO_1* = PADDJOB_INFO_1A + LPADDJOB_INFO_1* = LPADDJOB_INFO_1A + DRIVER_INFO_1* = DRIVER_INFO_1A + PDRIVER_INFO_1* = PDRIVER_INFO_1A + LPDRIVER_INFO_1* = LPDRIVER_INFO_1A + DRIVER_INFO_2* = DRIVER_INFO_2A + PDRIVER_INFO_2* = PDRIVER_INFO_2A + LPDRIVER_INFO_2* = LPDRIVER_INFO_2A + DRIVER_INFO_3* = DRIVER_INFO_3A + PDRIVER_INFO_3* = PDRIVER_INFO_3A + LPDRIVER_INFO_3* = LPDRIVER_INFO_3A + DRIVER_INFO_4* = DRIVER_INFO_4A + PDRIVER_INFO_4* = PDRIVER_INFO_4A + LPDRIVER_INFO_4* = LPDRIVER_INFO_4A + DRIVER_INFO_5* = DRIVER_INFO_5A + PDRIVER_INFO_5* = PDRIVER_INFO_5A + LPDRIVER_INFO_5* = LPDRIVER_INFO_5A + DRIVER_INFO_6* = DRIVER_INFO_6A + PDRIVER_INFO_6* = PDRIVER_INFO_6A + LPDRIVER_INFO_6* = LPDRIVER_INFO_6A + DOC_INFO_1* = DOC_INFO_1A + PDOC_INFO_1* = PDOC_INFO_1A + LPDOC_INFO_1* = LPDOC_INFO_1A + FORM_INFO_1* = FORM_INFO_1A + PFORM_INFO_1* = PFORM_INFO_1A + LPFORM_INFO_1* = LPFORM_INFO_1A + DOC_INFO_2* = DOC_INFO_2A + PDOC_INFO_2* = PDOC_INFO_2A + LPDOC_INFO_2* = LPDOC_INFO_2A + DOC_INFO_3* = DOC_INFO_3A + PDOC_INFO_3* = PDOC_INFO_3A + LPDOC_INFO_3* = LPDOC_INFO_3A + PRINTPROCESSOR_INFO_1* = PRINTPROCESSOR_INFO_1A + PPRINTPROCESSOR_INFO_1* = PPRINTPROCESSOR_INFO_1A + LPPRINTPROCESSOR_INFO_1* = LPPRINTPROCESSOR_INFO_1A + PORT_INFO_1* = PORT_INFO_1A + PPORT_INFO_1* = PPORT_INFO_1A + LPPORT_INFO_1* = LPPORT_INFO_1A + PORT_INFO_2* = PORT_INFO_2A + PPORT_INFO_2* = PPORT_INFO_2A + LPPORT_INFO_2* = LPPORT_INFO_2A + PORT_INFO_3* = PORT_INFO_3A + PPORT_INFO_3* = PPORT_INFO_3A + LPPORT_INFO_3* = LPPORT_INFO_3A + MONITOR_INFO_1* = MONITOR_INFO_1A + PMONITOR_INFO_1* = PMONITOR_INFO_1A + LPMONITOR_INFO_1* = LPMONITOR_INFO_1A + MONITOR_INFO_2* = MONITOR_INFO_2A + PMONITOR_INFO_2* = PMONITOR_INFO_2A + LPMONITOR_INFO_2* = LPMONITOR_INFO_2A + DATATYPES_INFO_1* = DATATYPES_INFO_1A + PDATATYPES_INFO_1* = PDATATYPES_INFO_1A + LPDATATYPES_INFO_1* = LPDATATYPES_INFO_1A + PRINTER_DEFAULTS* = PRINTER_DEFAULTSA + PPRINTER_DEFAULTS* = PPRINTER_DEFAULTSA + PRINTER_ENUM_VALUES* = PRINTER_ENUM_VALUESA + PPRINTER_ENUM_VALUES* = PPRINTER_ENUM_VALUESA + LPPRINTER_ENUM_VALUES* = LPPRINTER_ENUM_VALUESA + PROVIDOR_INFO_1* = PROVIDOR_INFO_1A + PPROVIDOR_INFO_1* = PPROVIDOR_INFO_1A + LPPROVIDOR_INFO_1* = LPPROVIDOR_INFO_1A + PROVIDOR_INFO_2* = PROVIDOR_INFO_2A + PPROVIDOR_INFO_2* = PPROVIDOR_INFO_2A + LPPROVIDOR_INFO_2* = LPPROVIDOR_INFO_2A + DRIVER_INFO_8* = DRIVER_INFO_8A + PDRIVER_INFO_8* = PDRIVER_INFO_8A + LPDRIVER_INFO_8* = LPDRIVER_INFO_8A + FORM_INFO_2* = FORM_INFO_2A + PFORM_INFO_2* = PFORM_INFO_2A + CORE_PRINTER_DRIVER* = CORE_PRINTER_DRIVERA + PCORE_PRINTER_DRIVER* = PCORE_PRINTER_DRIVERA + proc EnumPrinters*(Flags: DWORD, Name: LPSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintersA".} + proc OpenPrinter*(pPrinterName: LPSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSA): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "OpenPrinterA".} + proc ResetPrinter*(hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSA): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "ResetPrinterA".} + proc SetJob*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetJobA".} + proc GetJob*(hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetJobA".} + proc EnumJobs*(hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumJobsA".} + proc AddPrinter*(pName: LPSTR, Level: DWORD, pPrinter: LPBYTE): HANDLE {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterA".} + proc SetPrinter*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterA".} + proc GetPrinter*(hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterA".} + proc AddPrinterDriver*(pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterDriverA".} + proc AddPrinterDriverEx*(pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterDriverExA".} + proc EnumPrinterDrivers*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDriversA".} + proc GetPrinterDriver*(hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverA".} + proc GetPrinterDriverDirectory*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverDirectoryA".} + proc DeletePrinterDriver*(pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverA".} + proc DeletePrinterDriverEx*(pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverExA".} + proc AddPrintProcessor*(pName: LPSTR, pEnvironment: LPSTR, pPathName: LPSTR, pPrintProcessorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrintProcessorA".} + proc EnumPrintProcessors*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintProcessorsA".} + proc GetPrintProcessorDirectory*(pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrintProcessorDirectoryA".} + proc EnumPrintProcessorDatatypes*(pName: LPSTR, pPrintProcessorName: LPSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrintProcessorDatatypesA".} + proc DeletePrintProcessor*(pName: LPSTR, pEnvironment: LPSTR, pPrintProcessorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrintProcessorA".} + proc StartDocPrinter*(hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "StartDocPrinterA".} + proc AddJob*(hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddJobA".} + proc DocumentProperties*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA, fMode: DWORD): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc: "DocumentPropertiesA".} + proc AdvancedDocumentProperties*(hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA): LONG {.winapi, stdcall, dynlib: "winspool.drv", importc: "AdvancedDocumentPropertiesA".} + proc GetPrinterData*(hPrinter: HANDLE, pValueName: LPSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDataA".} + proc GetPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDataExA".} + proc EnumPrinterData*(hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDataA".} + proc EnumPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterDataExA".} + proc EnumPrinterKey*(hPrinter: HANDLE, pKeyName: LPCSTR, pSubkey: LPSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPrinterKeyA".} + proc SetPrinterData*(hPrinter: HANDLE, pValueName: LPSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterDataA".} + proc SetPrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPrinterDataExA".} + proc DeletePrinterData*(hPrinter: HANDLE, pValueName: LPSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDataA".} + proc DeletePrinterDataEx*(hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDataExA".} + proc DeletePrinterKey*(hPrinter: HANDLE, pKeyName: LPCSTR): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterKeyA".} + proc PrinterMessageBox*(hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPSTR, pCaption: LPSTR, dwType: DWORD): DWORD {.winapi, stdcall, dynlib: "winspool.drv", importc: "PrinterMessageBoxA".} + proc AddForm*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddFormA".} + proc DeleteForm*(hPrinter: HANDLE, pFormName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeleteFormA".} + proc GetForm*(hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetFormA".} + proc SetForm*(hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetFormA".} + proc EnumForms*(hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumFormsA".} + proc EnumMonitors*(pName: LPSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumMonitorsA".} + proc AddMonitor*(pName: LPSTR, Level: DWORD, pMonitorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddMonitorA".} + proc DeleteMonitor*(pName: LPSTR, pEnvironment: LPSTR, pMonitorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeleteMonitorA".} + proc EnumPorts*(pName: LPSTR, Level: DWORD, pPorts: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "EnumPortsA".} + proc AddPort*(pName: LPSTR, hWnd: HWND, pMonitorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPortA".} + proc ConfigurePort*(pName: LPSTR, hWnd: HWND, pPortName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "ConfigurePortA".} + proc DeletePort*(pName: LPSTR, hWnd: HWND, pPortName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePortA".} + proc GetDefaultPrinter*(pszBuffer: LPSTR, pcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetDefaultPrinterA".} + proc SetDefaultPrinter*(pszPrinter: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetDefaultPrinterA".} + proc SetPort*(pName: LPSTR, pPortName: LPSTR, dwLevel: DWORD, pPortInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "SetPortA".} + proc AddPrinterConnection*(pName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterConnectionA".} + proc DeletePrinterConnection*(pName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterConnectionA".} + proc AddPrintProvidor*(pName: LPSTR, level: DWORD, pProvidorInfo: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrintProvidorA".} + proc DeletePrintProvidor*(pName: LPSTR, pEnvironment: LPSTR, pPrintProvidorName: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrintProvidorA".} + proc IsValidDevmode*(pDevmode: PDEVMODEA, DevmodeSize: int): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "IsValidDevmodeA".} + proc AddPrinterConnection2*(hWnd: HWND, pszName: LPCSTR, dwLevel: DWORD, pConnectionInfo: PVOID): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "AddPrinterConnection2A".} + proc DeletePrinterDriverPackage*(pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "DeletePrinterDriverPackageA".} + proc GetCorePrinterDrivers*(pszServer: LPCSTR, pszEnvironment: LPCSTR, pszzCoreDriverDependencies: LPCSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERA): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetCorePrinterDriversA".} + proc GetPrinterDriver2*(hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriver2A".} + proc GetPrinterDriverPackagePath*(pszServer: LPCSTR, pszEnvironment: LPCSTR, pszLanguage: LPCSTR, pszPackageID: LPCSTR, pszDriverPackageCab: LPSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "GetPrinterDriverPackagePathA".} + proc OpenPrinter2*(pPrinterName: LPCSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTS, pOptions: PPRINTER_OPTIONS): WINBOOL {.winapi, stdcall, dynlib: "winspool.drv", importc: "OpenPrinter2A".} + proc UploadPrinterDriverPackage*(pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPSTR, pcchDestInfPath: PULONG): HRESULT {.winapi, stdcall, dynlib: "winspool.drv", importc: "UploadPrinterDriverPackageA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winsvc.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winsvc.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,418 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +#include +type + SC_ACTION_TYPE* = int32 + SC_STATUS_TYPE* = int32 + SC_ENUM_TYPE* = int32 + SC_HANDLE* = HANDLE + SERVICE_STATUS_HANDLE* = HANDLE + SERVICE_DESCRIPTIONA* {.pure.} = object + lpDescription*: LPSTR + LPSERVICE_DESCRIPTIONA* = ptr SERVICE_DESCRIPTIONA + SERVICE_DESCRIPTIONW* {.pure.} = object + lpDescription*: LPWSTR + LPSERVICE_DESCRIPTIONW* = ptr SERVICE_DESCRIPTIONW + SC_ACTION* {.pure.} = object + Type*: SC_ACTION_TYPE + Delay*: DWORD + LPSC_ACTION* = ptr SC_ACTION + SERVICE_FAILURE_ACTIONSA* {.pure.} = object + dwResetPeriod*: DWORD + lpRebootMsg*: LPSTR + lpCommand*: LPSTR + cActions*: DWORD + lpsaActions*: ptr SC_ACTION + LPSERVICE_FAILURE_ACTIONSA* = ptr SERVICE_FAILURE_ACTIONSA + SERVICE_FAILURE_ACTIONSW* {.pure.} = object + dwResetPeriod*: DWORD + lpRebootMsg*: LPWSTR + lpCommand*: LPWSTR + cActions*: DWORD + lpsaActions*: ptr SC_ACTION + LPSERVICE_FAILURE_ACTIONSW* = ptr SERVICE_FAILURE_ACTIONSW + LPSC_HANDLE* = ptr SC_HANDLE + SERVICE_STATUS* {.pure.} = object + dwServiceType*: DWORD + dwCurrentState*: DWORD + dwControlsAccepted*: DWORD + dwWin32ExitCode*: DWORD + dwServiceSpecificExitCode*: DWORD + dwCheckPoint*: DWORD + dwWaitHint*: DWORD + LPSERVICE_STATUS* = ptr SERVICE_STATUS + SERVICE_STATUS_PROCESS* {.pure.} = object + dwServiceType*: DWORD + dwCurrentState*: DWORD + dwControlsAccepted*: DWORD + dwWin32ExitCode*: DWORD + dwServiceSpecificExitCode*: DWORD + dwCheckPoint*: DWORD + dwWaitHint*: DWORD + dwProcessId*: DWORD + dwServiceFlags*: DWORD + LPSERVICE_STATUS_PROCESS* = ptr SERVICE_STATUS_PROCESS + ENUM_SERVICE_STATUSA* {.pure.} = object + lpServiceName*: LPSTR + lpDisplayName*: LPSTR + ServiceStatus*: SERVICE_STATUS + LPENUM_SERVICE_STATUSA* = ptr ENUM_SERVICE_STATUSA + ENUM_SERVICE_STATUSW* {.pure.} = object + lpServiceName*: LPWSTR + lpDisplayName*: LPWSTR + ServiceStatus*: SERVICE_STATUS + LPENUM_SERVICE_STATUSW* = ptr ENUM_SERVICE_STATUSW + ENUM_SERVICE_STATUS_PROCESSA* {.pure.} = object + lpServiceName*: LPSTR + lpDisplayName*: LPSTR + ServiceStatusProcess*: SERVICE_STATUS_PROCESS + LPENUM_SERVICE_STATUS_PROCESSA* = ptr ENUM_SERVICE_STATUS_PROCESSA + ENUM_SERVICE_STATUS_PROCESSW* {.pure.} = object + lpServiceName*: LPWSTR + lpDisplayName*: LPWSTR + ServiceStatusProcess*: SERVICE_STATUS_PROCESS + LPENUM_SERVICE_STATUS_PROCESSW* = ptr ENUM_SERVICE_STATUS_PROCESSW + SC_LOCK* = LPVOID + TQUERY_SERVICE_LOCK_STATUSA* {.pure.} = object + fIsLocked*: DWORD + lpLockOwner*: LPSTR + dwLockDuration*: DWORD + LPQUERY_SERVICE_LOCK_STATUSA* = ptr TQUERY_SERVICE_LOCK_STATUSA + TQUERY_SERVICE_LOCK_STATUSW* {.pure.} = object + fIsLocked*: DWORD + lpLockOwner*: LPWSTR + dwLockDuration*: DWORD + LPQUERY_SERVICE_LOCK_STATUSW* = ptr TQUERY_SERVICE_LOCK_STATUSW + TQUERY_SERVICE_CONFIGA* {.pure.} = object + dwServiceType*: DWORD + dwStartType*: DWORD + dwErrorControl*: DWORD + lpBinaryPathName*: LPSTR + lpLoadOrderGroup*: LPSTR + dwTagId*: DWORD + lpDependencies*: LPSTR + lpServiceStartName*: LPSTR + lpDisplayName*: LPSTR + LPQUERY_SERVICE_CONFIGA* = ptr TQUERY_SERVICE_CONFIGA + TQUERY_SERVICE_CONFIGW* {.pure.} = object + dwServiceType*: DWORD + dwStartType*: DWORD + dwErrorControl*: DWORD + lpBinaryPathName*: LPWSTR + lpLoadOrderGroup*: LPWSTR + dwTagId*: DWORD + lpDependencies*: LPWSTR + lpServiceStartName*: LPWSTR + lpDisplayName*: LPWSTR + LPQUERY_SERVICE_CONFIGW* = ptr TQUERY_SERVICE_CONFIGW + LPSERVICE_MAIN_FUNCTIONA* = proc (dwNumServicesArgs: DWORD, lpServiceArgVectors: ptr LPSTR): VOID {.stdcall.} + SERVICE_TABLE_ENTRYA* {.pure.} = object + lpServiceName*: LPSTR + lpServiceProc*: LPSERVICE_MAIN_FUNCTIONA + LPSERVICE_TABLE_ENTRYA* = ptr SERVICE_TABLE_ENTRYA + LPSERVICE_MAIN_FUNCTIONW* = proc (dwNumServicesArgs: DWORD, lpServiceArgVectors: ptr LPWSTR): VOID {.stdcall.} + SERVICE_TABLE_ENTRYW* {.pure.} = object + lpServiceName*: LPWSTR + lpServiceProc*: LPSERVICE_MAIN_FUNCTIONW + LPSERVICE_TABLE_ENTRYW* = ptr SERVICE_TABLE_ENTRYW + SERVICE_CONTROL_STATUS_REASON_PARAMSA* {.pure.} = object + dwReason*: DWORD + pszComment*: LPSTR + ServiceStatus*: SERVICE_STATUS_PROCESS + PSERVICE_CONTROL_STATUS_REASON_PARAMSA* = ptr SERVICE_CONTROL_STATUS_REASON_PARAMSA + SERVICE_CONTROL_STATUS_REASON_PARAMSW* {.pure.} = object + dwReason*: DWORD + pszComment*: LPWSTR + ServiceStatus*: SERVICE_STATUS_PROCESS + PSERVICE_CONTROL_STATUS_REASON_PARAMSW* = ptr SERVICE_CONTROL_STATUS_REASON_PARAMSW + PFN_SC_NOTIFY_CALLBACK* = proc (pParameter: PVOID): VOID {.stdcall.} + SERVICE_NOTIFYA* {.pure.} = object + dwVersion*: DWORD + pfnNotifyCallback*: PFN_SC_NOTIFY_CALLBACK + pContext*: PVOID + dwNotificationStatus*: DWORD + ServiceStatus*: SERVICE_STATUS_PROCESS + dwNotificationTriggered*: DWORD + pszServiceNames*: LPSTR + PSERVICE_NOTIFYA* = ptr SERVICE_NOTIFYA + SERVICE_NOTIFYW* {.pure.} = object + dwVersion*: DWORD + pfnNotifyCallback*: PFN_SC_NOTIFY_CALLBACK + pContext*: PVOID + dwNotificationStatus*: DWORD + ServiceStatus*: SERVICE_STATUS_PROCESS + dwNotificationTriggered*: DWORD + pszServiceNames*: LPWSTR + PSERVICE_NOTIFYW* = ptr SERVICE_NOTIFYW + SERVICE_DELAYED_AUTO_START_INFO* {.pure.} = object + fDelayedAutostart*: WINBOOL + LPSERVICE_DELAYED_AUTO_START_INFO* = ptr SERVICE_DELAYED_AUTO_START_INFO + SERVICE_FAILURE_ACTIONS_FLAG* {.pure.} = object + fFailureActionsOnNonCrashFailures*: WINBOOL + LPSERVICE_FAILURE_ACTIONS_FLAG* = ptr SERVICE_FAILURE_ACTIONS_FLAG + SERVICE_PRESHUTDOWN_INFO* {.pure.} = object + dwPreshutdownTimeout*: DWORD + LPSERVICE_PRESHUTDOWN_INFO* = ptr SERVICE_PRESHUTDOWN_INFO + SERVICE_REQUIRED_PRIVILEGES_INFOA* {.pure.} = object + pmszRequiredPrivileges*: LPSTR + LPSERVICE_REQUIRED_PRIVILEGES_INFOA* = ptr SERVICE_REQUIRED_PRIVILEGES_INFOA + SERVICE_REQUIRED_PRIVILEGES_INFOW* {.pure.} = object + pmszRequiredPrivileges*: LPWSTR + LPSERVICE_REQUIRED_PRIVILEGES_INFOW* = ptr SERVICE_REQUIRED_PRIVILEGES_INFOW + SERVICE_SID_INFO* {.pure.} = object + dwServiceSidType*: DWORD + LPSERVICE_SID_INFO* = ptr SERVICE_SID_INFO +const + SERVICES_ACTIVE_DATABASEW* = "ServicesActive" + SERVICES_FAILED_DATABASEW* = "ServicesFailed" + SERVICES_ACTIVE_DATABASEA* = "ServicesActive" + SERVICES_FAILED_DATABASEA* = "ServicesFailed" + SERVICE_NO_CHANGE* = 0xffffffff'i32 + SERVICE_ACTIVE* = 0x00000001 + SERVICE_INACTIVE* = 0x00000002 + SERVICE_STATE_ALL* = SERVICE_ACTIVE or SERVICE_INACTIVE + SERVICE_CONTROL_STOP* = 0x00000001 + SERVICE_CONTROL_PAUSE* = 0x00000002 + SERVICE_CONTROL_CONTINUE* = 0x00000003 + SERVICE_CONTROL_INTERROGATE* = 0x00000004 + SERVICE_CONTROL_SHUTDOWN* = 0x00000005 + SERVICE_CONTROL_PARAMCHANGE* = 0x00000006 + SERVICE_CONTROL_NETBINDADD* = 0x00000007 + SERVICE_CONTROL_NETBINDREMOVE* = 0x00000008 + SERVICE_CONTROL_NETBINDENABLE* = 0x00000009 + SERVICE_CONTROL_NETBINDDISABLE* = 0x0000000A + SERVICE_CONTROL_DEVICEEVENT* = 0x0000000B + SERVICE_CONTROL_HARDWAREPROFILECHANGE* = 0x0000000C + SERVICE_CONTROL_POWEREVENT* = 0x0000000D + SERVICE_CONTROL_SESSIONCHANGE* = 0x0000000E + SERVICE_STOPPED* = 0x00000001 + SERVICE_START_PENDING* = 0x00000002 + SERVICE_STOP_PENDING* = 0x00000003 + SERVICE_RUNNING* = 0x00000004 + SERVICE_CONTINUE_PENDING* = 0x00000005 + SERVICE_PAUSE_PENDING* = 0x00000006 + SERVICE_PAUSED* = 0x00000007 + SERVICE_ACCEPT_STOP* = 0x00000001 + SERVICE_ACCEPT_PAUSE_CONTINUE* = 0x00000002 + SERVICE_ACCEPT_SHUTDOWN* = 0x00000004 + SERVICE_ACCEPT_PARAMCHANGE* = 0x00000008 + SERVICE_ACCEPT_NETBINDCHANGE* = 0x00000010 + SERVICE_ACCEPT_HARDWAREPROFILECHANGE* = 0x00000020 + SERVICE_ACCEPT_POWEREVENT* = 0x00000040 + SERVICE_ACCEPT_SESSIONCHANGE* = 0x00000080 + SC_MANAGER_CONNECT* = 0x0001 + SC_MANAGER_CREATE_SERVICE* = 0x0002 + SC_MANAGER_ENUMERATE_SERVICE* = 0x0004 + SC_MANAGER_LOCK* = 0x0008 + SC_MANAGER_QUERY_LOCK_STATUS* = 0x0010 + SC_MANAGER_MODIFY_BOOT_CONFIG* = 0x0020 + SC_MANAGER_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SC_MANAGER_CONNECT or SC_MANAGER_CREATE_SERVICE or SC_MANAGER_ENUMERATE_SERVICE or SC_MANAGER_LOCK or SC_MANAGER_QUERY_LOCK_STATUS or SC_MANAGER_MODIFY_BOOT_CONFIG + SERVICE_QUERY_CONFIG* = 0x0001 + SERVICE_CHANGE_CONFIG* = 0x0002 + SERVICE_QUERY_STATUS* = 0x0004 + SERVICE_ENUMERATE_DEPENDENTS* = 0x0008 + SERVICE_START* = 0x0010 + SERVICE_STOP* = 0x0020 + SERVICE_PAUSE_CONTINUE* = 0x0040 + SERVICE_INTERROGATE* = 0x0080 + SERVICE_USER_DEFINED_CONTROL* = 0x0100 + SERVICE_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SERVICE_QUERY_CONFIG or SERVICE_CHANGE_CONFIG or SERVICE_QUERY_STATUS or SERVICE_ENUMERATE_DEPENDENTS or SERVICE_START or SERVICE_STOP or SERVICE_PAUSE_CONTINUE or SERVICE_INTERROGATE or SERVICE_USER_DEFINED_CONTROL + SERVICE_RUNS_IN_SYSTEM_PROCESS* = 0x00000001 + SERVICE_CONFIG_DESCRIPTION* = 1 + SERVICE_CONFIG_FAILURE_ACTIONS* = 2 + SC_ACTION_NONE* = 0 + SC_ACTION_RESTART* = 1 + SC_ACTION_REBOOT* = 2 + SC_ACTION_RUN_COMMAND* = 3 + SC_STATUS_PROCESS_INFO* = 0 + SC_ENUM_PROCESS_INFO* = 0 + SERVICE_STOP_REASON_FLAG_CUSTOM* = 0x20000000 + SERVICE_STOP_REASON_FLAG_PLANNED* = 0x40000000 + SERVICE_STOP_REASON_FLAG_UNPLANNED* = 0x10000000 + SERVICE_STOP_REASON_MAJOR_APPLICATION* = 0x00050000 + SERVICE_STOP_REASON_MAJOR_HARDWARE* = 0x00020000 + SERVICE_STOP_REASON_MAJOR_NONE* = 0x00060000 + SERVICE_STOP_REASON_MAJOR_OPERATINGSYSTEM* = 0x00030000 + SERVICE_STOP_REASON_MAJOR_OTHER* = 0x00010000 + SERVICE_STOP_REASON_MAJOR_SOFTWARE* = 0x00040000 + SERVICE_STOP_REASON_MINOR_DISK* = 0x00000008 + SERVICE_STOP_REASON_MINOR_ENVIRONMENT* = 0x0000000a + SERVICE_STOP_REASON_MINOR_HARDWARE_DRIVER* = 0x0000000b + SERVICE_STOP_REASON_MINOR_HUNG* = 0x00000006 + SERVICE_STOP_REASON_MINOR_INSTALLATION* = 0x00000003 + SERVICE_STOP_REASON_MINOR_MAINTENANCE* = 0x00000002 + SERVICE_STOP_REASON_MINOR_MMC* = 0x00000016 + SERVICE_STOP_REASON_MINOR_NETWORK_CONNECTIVITY* = 0x00000011 + SERVICE_STOP_REASON_MINOR_NETWORKCARD* = 0x00000009 + SERVICE_STOP_REASON_MINOR_NONE* = 0x00060000 + SERVICE_STOP_REASON_MINOR_OTHER* = 0x00000001 + SERVICE_STOP_REASON_MINOR_OTHERDRIVER* = 0x0000000c + SERVICE_STOP_REASON_MINOR_RECONFIG* = 0x00000005 + SERVICE_STOP_REASON_MINOR_SECURITY* = 0x00000010 + SERVICE_STOP_REASON_MINOR_SECURITYFIX* = 0x0000000f + SERVICE_STOP_REASON_MINOR_SECURITYFIX_UNINSTALL* = 0x00000015 + SERVICE_STOP_REASON_MINOR_SERVICEPACK* = 0x0000000d + SERVICE_STOP_REASON_MINOR_SERVICEPACK_UNINSTALL* = 0x00000013 + SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE* = 0x0000000e + SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE_UNINSTALL* = 0x0000000e + SERVICE_STOP_REASON_MINOR_UNSTABLE* = 0x00000007 + SERVICE_STOP_REASON_MINOR_UPGRADE* = 0x00000004 + SERVICE_STOP_REASON_MINOR_WMI* = 0x00000012 + SERVICE_CONFIG_DELAYED_AUTO_START_INFO* = 3 + SERVICE_CONFIG_FAILURE_ACTIONS_FLAG* = 4 + SERVICE_CONFIG_SERVICE_SID_INFO* = 5 + SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO* = 6 + SERVICE_CONFIG_PRESHUTDOWN_INFO* = 7 + SERVICE_SID_TYPE_NONE* = 0x00000000 + SERVICE_SID_TYPE_RESTRICTED* = 0x00000003 + SERVICE_SID_TYPE_UNRESTRICTED* = 0x00000001 + SC_GROUP_IDENTIFIERA* = '+' + SC_GROUP_IDENTIFIERW* = WCHAR '+' +type + LPHANDLER_FUNCTION* = proc (dwControl: DWORD): VOID {.stdcall.} + LPHANDLER_FUNCTION_EX* = proc (dwControl: DWORD, dwEventType: DWORD, lpEventData: LPVOID, lpContext: LPVOID): DWORD {.stdcall.} +proc ChangeServiceConfigA*(hService: SC_HANDLE, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR, lpDisplayName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ChangeServiceConfigW*(hService: SC_HANDLE, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR, lpDisplayName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ChangeServiceConfig2A*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ChangeServiceConfig2W*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CloseServiceHandle*(hSCObject: SC_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ControlService*(hService: SC_HANDLE, dwControl: DWORD, lpServiceStatus: LPSERVICE_STATUS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateServiceA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPCSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc CreateServiceW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPCWSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc DeleteService*(hService: SC_HANDLE): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumDependentServicesA*(hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumDependentServicesW*(hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumServicesStatusA*(hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumServicesStatusW*(hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumServicesStatusExA*(hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc EnumServicesStatusExW*(hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetServiceKeyNameA*(hSCManager: SC_HANDLE, lpDisplayName: LPCSTR, lpServiceName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetServiceKeyNameW*(hSCManager: SC_HANDLE, lpDisplayName: LPCWSTR, lpServiceName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetServiceDisplayNameA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc GetServiceDisplayNameW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc LockServiceDatabase*(hSCManager: SC_HANDLE): SC_LOCK {.winapi, stdcall, dynlib: "advapi32", importc.} +proc NotifyBootConfigStatus*(BootAcceptable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenSCManagerA*(lpMachineName: LPCSTR, lpDatabaseName: LPCSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenSCManagerW*(lpMachineName: LPCWSTR, lpDatabaseName: LPCWSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenServiceA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc OpenServiceW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceConfigA*(hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceConfigW*(hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceConfig2A*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceConfig2W*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceLockStatusA*(hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceLockStatusW*(hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceObjectSecurity*(hService: SC_HANDLE, dwSecurityInformation: SECURITY_INFORMATION, lpSecurityDescriptor: PSECURITY_DESCRIPTOR, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceStatus*(hService: SC_HANDLE, lpServiceStatus: LPSERVICE_STATUS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc QueryServiceStatusEx*(hService: SC_HANDLE, InfoLevel: SC_STATUS_TYPE, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterServiceCtrlHandlerA*(lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterServiceCtrlHandlerW*(lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterServiceCtrlHandlerExA*(lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc RegisterServiceCtrlHandlerExW*(lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetServiceObjectSecurity*(hService: SC_HANDLE, dwSecurityInformation: SECURITY_INFORMATION, lpSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc SetServiceStatus*(hServiceStatus: SERVICE_STATUS_HANDLE, lpServiceStatus: LPSERVICE_STATUS): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc StartServiceCtrlDispatcherA*(lpServiceStartTable: ptr SERVICE_TABLE_ENTRYA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc StartServiceCtrlDispatcherW*(lpServiceStartTable: ptr SERVICE_TABLE_ENTRYW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc StartServiceA*(hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc StartServiceW*(hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc UnlockServiceDatabase*(ScLock: SC_LOCK): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ControlServiceExA*(hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc ControlServiceExW*(hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc.} +proc NotifyServiceStatusChangeA*(hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYA): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +proc NotifyServiceStatusChangeW*(hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYW): DWORD {.winapi, stdcall, dynlib: "advapi32", importc.} +when winimUnicode: + type + SERVICE_DESCRIPTION* = SERVICE_DESCRIPTIONW + LPSERVICE_DESCRIPTION* = LPSERVICE_DESCRIPTIONW + SERVICE_FAILURE_ACTIONS* = SERVICE_FAILURE_ACTIONSW + LPSERVICE_FAILURE_ACTIONS* = LPSERVICE_FAILURE_ACTIONSW + ENUM_SERVICE_STATUS* = ENUM_SERVICE_STATUSW + LPENUM_SERVICE_STATUS* = LPENUM_SERVICE_STATUSW + ENUM_SERVICE_STATUS_PROCESS* = ENUM_SERVICE_STATUS_PROCESSW + LPENUM_SERVICE_STATUS_PROCESS* = LPENUM_SERVICE_STATUS_PROCESSW + TQUERY_SERVICE_LOCK_STATUS* = TQUERY_SERVICE_LOCK_STATUSW + LPQUERY_SERVICE_LOCK_STATUS* = LPQUERY_SERVICE_LOCK_STATUSW + TQUERY_SERVICE_CONFIG* = TQUERY_SERVICE_CONFIGW + LPQUERY_SERVICE_CONFIG* = LPQUERY_SERVICE_CONFIGW + LPSERVICE_MAIN_FUNCTION* = LPSERVICE_MAIN_FUNCTIONW + SERVICE_TABLE_ENTRY* = SERVICE_TABLE_ENTRYW + LPSERVICE_TABLE_ENTRY* = LPSERVICE_TABLE_ENTRYW + SERVICE_CONTROL_STATUS_REASON_PARAMS* = SERVICE_CONTROL_STATUS_REASON_PARAMSW + PSERVICE_CONTROL_STATUS_REASON_PARAMS* = PSERVICE_CONTROL_STATUS_REASON_PARAMSW + SERVICE_NOTIFY* = SERVICE_NOTIFYW + PSERVICE_NOTIFY* = PSERVICE_NOTIFYW + SERVICE_REQUIRED_PRIVILEGES_INFO* = SERVICE_REQUIRED_PRIVILEGES_INFOW + const + SERVICES_ACTIVE_DATABASE* = SERVICES_ACTIVE_DATABASEW + SERVICES_FAILED_DATABASE* = SERVICES_FAILED_DATABASEW + SC_GROUP_IDENTIFIER* = SC_GROUP_IDENTIFIERW + proc ChangeServiceConfig*(hService: SC_HANDLE, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR, lpDisplayName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ChangeServiceConfigW".} + proc ChangeServiceConfig2*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ChangeServiceConfig2W".} + proc CreateService*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPCWSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "CreateServiceW".} + proc EnumDependentServices*(hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumDependentServicesW".} + proc EnumServicesStatus*(hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumServicesStatusW".} + proc EnumServicesStatusEx*(hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumServicesStatusExW".} + proc GetServiceKeyName*(hSCManager: SC_HANDLE, lpDisplayName: LPCWSTR, lpServiceName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameW".} + proc GetServiceDisplayName*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameW".} + proc OpenSCManager*(lpMachineName: LPCWSTR, lpDatabaseName: LPCWSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenSCManagerW".} + proc OpenService*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenServiceW".} + proc QueryServiceConfig*(hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceConfigW".} + proc QueryServiceConfig2*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceConfig2W".} + proc QueryServiceLockStatus*(hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusW".} + proc RegisterServiceCtrlHandler*(lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerW".} + proc RegisterServiceCtrlHandlerEx*(lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerExW".} + proc StartServiceCtrlDispatcher*(lpServiceStartTable: ptr SERVICE_TABLE_ENTRYW): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherW".} + proc StartService*(hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: ptr LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "StartServiceW".} + proc ControlServiceEx*(hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ControlServiceExW".} + proc NotifyServiceStatusChange*(hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYW): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "NotifyServiceStatusChangeW".} +when winimAnsi: + type + SERVICE_DESCRIPTION* = SERVICE_DESCRIPTIONA + LPSERVICE_DESCRIPTION* = LPSERVICE_DESCRIPTIONA + SERVICE_FAILURE_ACTIONS* = SERVICE_FAILURE_ACTIONSA + LPSERVICE_FAILURE_ACTIONS* = LPSERVICE_FAILURE_ACTIONSA + ENUM_SERVICE_STATUS* = ENUM_SERVICE_STATUSA + LPENUM_SERVICE_STATUS* = LPENUM_SERVICE_STATUSA + ENUM_SERVICE_STATUS_PROCESS* = ENUM_SERVICE_STATUS_PROCESSA + LPENUM_SERVICE_STATUS_PROCESS* = LPENUM_SERVICE_STATUS_PROCESSA + TQUERY_SERVICE_LOCK_STATUS* = TQUERY_SERVICE_LOCK_STATUSA + LPQUERY_SERVICE_LOCK_STATUS* = LPQUERY_SERVICE_LOCK_STATUSA + TQUERY_SERVICE_CONFIG* = TQUERY_SERVICE_CONFIGA + LPQUERY_SERVICE_CONFIG* = LPQUERY_SERVICE_CONFIGA + LPSERVICE_MAIN_FUNCTION* = LPSERVICE_MAIN_FUNCTIONA + SERVICE_TABLE_ENTRY* = SERVICE_TABLE_ENTRYA + LPSERVICE_TABLE_ENTRY* = LPSERVICE_TABLE_ENTRYA + SERVICE_CONTROL_STATUS_REASON_PARAMS* = SERVICE_CONTROL_STATUS_REASON_PARAMSA + PSERVICE_CONTROL_STATUS_REASON_PARAMS* = PSERVICE_CONTROL_STATUS_REASON_PARAMSA + SERVICE_NOTIFY* = SERVICE_NOTIFYA + PSERVICE_NOTIFY* = PSERVICE_NOTIFYA + SERVICE_REQUIRED_PRIVILEGES_INFO* = SERVICE_REQUIRED_PRIVILEGES_INFOA + const + SERVICES_ACTIVE_DATABASE* = SERVICES_ACTIVE_DATABASEA + SERVICES_FAILED_DATABASE* = SERVICES_FAILED_DATABASEA + SC_GROUP_IDENTIFIER* = SC_GROUP_IDENTIFIERA + proc ChangeServiceConfig*(hService: SC_HANDLE, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR, lpDisplayName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ChangeServiceConfigA".} + proc ChangeServiceConfig2*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ChangeServiceConfig2A".} + proc CreateService*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPCSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "CreateServiceA".} + proc EnumDependentServices*(hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumDependentServicesA".} + proc EnumServicesStatus*(hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumServicesStatusA".} + proc EnumServicesStatusEx*(hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "EnumServicesStatusExA".} + proc GetServiceKeyName*(hSCManager: SC_HANDLE, lpDisplayName: LPCSTR, lpServiceName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameA".} + proc GetServiceDisplayName*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameA".} + proc OpenSCManager*(lpMachineName: LPCSTR, lpDatabaseName: LPCSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenSCManagerA".} + proc OpenService*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR, dwDesiredAccess: DWORD): SC_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "OpenServiceA".} + proc QueryServiceConfig*(hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceConfigA".} + proc QueryServiceConfig2*(hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceConfig2A".} + proc QueryServiceLockStatus*(hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusA".} + proc RegisterServiceCtrlHandler*(lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerA".} + proc RegisterServiceCtrlHandlerEx*(lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID): SERVICE_STATUS_HANDLE {.winapi, stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerExA".} + proc StartServiceCtrlDispatcher*(lpServiceStartTable: ptr SERVICE_TABLE_ENTRYA): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherA".} + proc StartService*(hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: ptr LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "StartServiceA".} + proc ControlServiceEx*(hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID): WINBOOL {.winapi, stdcall, dynlib: "advapi32", importc: "ControlServiceExA".} + proc NotifyServiceStatusChange*(hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYA): DWORD {.winapi, stdcall, dynlib: "advapi32", importc: "NotifyServiceStatusChangeA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/wintrust.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/wintrust.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,700 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import wincrypt +#include +#include +#include +type + HCATADMIN* = HANDLE + HCATINFO* = HANDLE + WINTRUST_FILE_INFO* {.pure.} = object + cbStruct*: DWORD + pcwszFilePath*: LPCWSTR + hFile*: HANDLE + pgKnownSubject*: ptr GUID + WINTRUST_CATALOG_INFO* {.pure.} = object + cbStruct*: DWORD + dwCatalogVersion*: DWORD + pcwszCatalogFilePath*: LPCWSTR + pcwszMemberTag*: LPCWSTR + pcwszMemberFilePath*: LPCWSTR + hMemberFile*: HANDLE + pbCalculatedFileHash*: ptr BYTE + cbCalculatedFileHash*: DWORD + pcCatalogContext*: PCCTL_CONTEXT + WINTRUST_BLOB_INFO* {.pure.} = object + cbStruct*: DWORD + gSubject*: GUID + pcwszDisplayName*: LPCWSTR + cbMemObject*: DWORD + pbMemObject*: ptr BYTE + cbMemSignedMsg*: DWORD + pbMemSignedMsg*: ptr BYTE + WINTRUST_SGNR_INFO* {.pure.} = object + cbStruct*: DWORD + pcwszDisplayName*: LPCWSTR + psSignerInfo*: ptr CMSG_SIGNER_INFO + chStores*: DWORD + pahStores*: ptr HCERTSTORE + WINTRUST_CERT_INFO* {.pure.} = object + cbStruct*: DWORD + pcwszDisplayName*: LPCWSTR + psCertContext*: ptr CERT_CONTEXT + chStores*: DWORD + pahStores*: ptr HCERTSTORE + dwFlags*: DWORD + psftVerifyAsOf*: ptr FILETIME + WINTRUST_DATA_UNION1* {.pure, union.} = object + pFile*: ptr WINTRUST_FILE_INFO + pCatalog*: ptr WINTRUST_CATALOG_INFO + pBlob*: ptr WINTRUST_BLOB_INFO + pSgnr*: ptr WINTRUST_SGNR_INFO + pCert*: ptr WINTRUST_CERT_INFO + WINTRUST_DATA* {.pure.} = object + cbStruct*: DWORD + pPolicyCallbackData*: LPVOID + pSIPClientData*: LPVOID + dwUIChoice*: DWORD + fdwRevocationChecks*: DWORD + dwUnionChoice*: DWORD + union1*: WINTRUST_DATA_UNION1 + dwStateAction*: DWORD + hWVTStateData*: HANDLE + pwszURLReference*: ptr WCHAR + dwProvFlags*: DWORD + dwUIContext*: DWORD + PWINTRUST_DATA* = ptr WINTRUST_DATA + PWINTRUST_FILE_INFO* = ptr WINTRUST_FILE_INFO + PWINTRUST_CATALOG_INFO* = ptr WINTRUST_CATALOG_INFO + PWINTRUST_BLOB_INFO* = ptr WINTRUST_BLOB_INFO + PWINTRUST_SGNR_INFO* = ptr WINTRUST_SGNR_INFO + PWINTRUST_CERT_INFO* = ptr WINTRUST_CERT_INFO + PFN_CPD_MEM_ALLOC* = proc (cbSize: DWORD): pointer {.stdcall.} + PFN_CPD_MEM_FREE* = proc (pvMem2Free: pointer): void {.stdcall.} + PFN_CPD_ADD_STORE* = proc (pProvData: ptr CRYPT_PROVIDER_DATA, hStore2Add: HCERTSTORE): WINBOOL {.stdcall.} + CRYPT_PROVIDER_CERT* {.pure.} = object + cbStruct*: DWORD + pCert*: PCCERT_CONTEXT + fCommercial*: WINBOOL + fTrustedRoot*: WINBOOL + fSelfSigned*: WINBOOL + fTestCert*: WINBOOL + dwRevokedReason*: DWORD + dwConfidence*: DWORD + dwError*: DWORD + pTrustListContext*: ptr CTL_CONTEXT + fTrustListSignerCert*: WINBOOL + pCtlContext*: PCCTL_CONTEXT + dwCtlError*: DWORD + fIsCyclic*: WINBOOL + pChainElement*: PCERT_CHAIN_ELEMENT + CRYPT_PROVIDER_SGNR* {.pure.} = object + cbStruct*: DWORD + sftVerifyAsOf*: FILETIME + csCertChain*: DWORD + pasCertChain*: ptr CRYPT_PROVIDER_CERT + dwSignerType*: DWORD + psSigner*: ptr CMSG_SIGNER_INFO + dwError*: DWORD + csCounterSigners*: DWORD + pasCounterSigners*: ptr CRYPT_PROVIDER_SGNR + pChainContext*: PCCERT_CHAIN_CONTEXT + PFN_CPD_ADD_SGNR* = proc (pProvData: ptr CRYPT_PROVIDER_DATA, fCounterSigner: WINBOOL, idxSigner: DWORD, pSgnr2Add: ptr CRYPT_PROVIDER_SGNR): WINBOOL {.stdcall.} + PFN_CPD_ADD_CERT* = proc (pProvData: ptr CRYPT_PROVIDER_DATA, idxSigner: DWORD, fCounterSigner: WINBOOL, idxCounterSigner: DWORD, pCert2Add: PCCERT_CONTEXT): WINBOOL {.stdcall.} + CRYPT_PROVIDER_PRIVDATA* {.pure.} = object + cbStruct*: DWORD + gProviderID*: GUID + cbProvData*: DWORD + pvProvData*: pointer + PFN_CPD_ADD_PRIVDATA* = proc (pProvData: ptr CRYPT_PROVIDER_DATA, pPrivData2Add: ptr CRYPT_PROVIDER_PRIVDATA): WINBOOL {.stdcall.} + PFN_PROVIDER_INIT_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + PFN_PROVIDER_OBJTRUST_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + PFN_PROVIDER_SIGTRUST_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + PFN_PROVIDER_CERTTRUST_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + PFN_PROVIDER_FINALPOLICY_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + PFN_PROVIDER_CERTCHKPOLICY_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA, idxSigner: DWORD, fCounterSignerChain: WINBOOL, idxCounterSigner: DWORD): WINBOOL {.stdcall.} + PFN_PROVIDER_TESTFINALPOLICY_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + CRYPT_PROVUI_DATA* {.pure.} = object + cbStruct*: DWORD + dwFinalError*: DWORD + pYesButtonText*: ptr WCHAR + pNoButtonText*: ptr WCHAR + pMoreInfoButtonText*: ptr WCHAR + pAdvancedLinkText*: ptr WCHAR + pCopyActionText*: ptr WCHAR + pCopyActionTextNoTS*: ptr WCHAR + pCopyActionTextNotSigned*: ptr WCHAR + PFN_PROVUI_CALL* = proc (hWndSecurityDialog: HWND, pProvData: ptr CRYPT_PROVIDER_DATA): WINBOOL {.stdcall.} + CRYPT_PROVUI_FUNCS* {.pure.} = object + cbStruct*: DWORD + psUIData*: ptr CRYPT_PROVUI_DATA + pfnOnMoreInfoClick*: PFN_PROVUI_CALL + pfnOnMoreInfoClickDefault*: PFN_PROVUI_CALL + pfnOnAdvancedClick*: PFN_PROVUI_CALL + pfnOnAdvancedClickDefault*: PFN_PROVUI_CALL + PFN_PROVIDER_CLEANUP_CALL* = proc (pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.stdcall.} + CRYPT_PROVIDER_FUNCTIONS* {.pure.} = object + cbStruct*: DWORD + pfnAlloc*: PFN_CPD_MEM_ALLOC + pfnFree*: PFN_CPD_MEM_FREE + pfnAddStore2Chain*: PFN_CPD_ADD_STORE + pfnAddSgnr2Chain*: PFN_CPD_ADD_SGNR + pfnAddCert2Chain*: PFN_CPD_ADD_CERT + pfnAddPrivData2Chain*: PFN_CPD_ADD_PRIVDATA + pfnInitialize*: PFN_PROVIDER_INIT_CALL + pfnObjectTrust*: PFN_PROVIDER_OBJTRUST_CALL + pfnSignatureTrust*: PFN_PROVIDER_SIGTRUST_CALL + pfnCertificateTrust*: PFN_PROVIDER_CERTTRUST_CALL + pfnFinalPolicy*: PFN_PROVIDER_FINALPOLICY_CALL + pfnCertCheckPolicy*: PFN_PROVIDER_CERTCHKPOLICY_CALL + pfnTestFinalPolicy*: PFN_PROVIDER_TESTFINALPOLICY_CALL + psUIpfns*: ptr CRYPT_PROVUI_FUNCS + pfnCleanupPolicy*: PFN_PROVIDER_CLEANUP_CALL + SIP_INDIRECT_DATA* {.pure.} = object + Data*: CRYPT_ATTRIBUTE_TYPE_VALUE + DigestAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Digest*: CRYPT_HASH_BLOB + MS_ADDINFO_FLAT* {.pure.} = object + cbStruct*: DWORD + pIndirectData*: ptr SIP_INDIRECT_DATA + CRYPTCATSTORE* {.pure.} = object + CRYPTCATMEMBER* {.pure.} = object + cbStruct*: DWORD + pwszReferenceTag*: LPWSTR + pwszFileName*: LPWSTR + gSubjectType*: GUID + fdwMemberFlags*: DWORD + pIndirectData*: ptr SIP_INDIRECT_DATA + dwCertVersion*: DWORD + dwReserved*: DWORD + hReserved*: HANDLE + sEncodedIndirectData*: CRYPT_ATTR_BLOB + sEncodedMemberInfo*: CRYPT_ATTR_BLOB + MS_ADDINFO_CATALOGMEMBER* {.pure.} = object + cbStruct*: DWORD + pStore*: ptr CRYPTCATSTORE + pMember*: ptr CRYPTCATMEMBER + MS_ADDINFO_BLOB* {.pure.} = object + cbStruct*: DWORD + cbMemObject*: DWORD + pbMemObject*: ptr BYTE + cbMemSignedMsg*: DWORD + pbMemSignedMsg*: ptr BYTE + SIP_SUBJECTINFO_UNION1* {.pure, union.} = object + psFlat*: ptr MS_ADDINFO_FLAT + psCatMember*: ptr MS_ADDINFO_CATALOGMEMBER + psBlob*: ptr MS_ADDINFO_BLOB + SIP_SUBJECTINFO* {.pure.} = object + cbSize*: DWORD + pgSubjectType*: ptr GUID + hFile*: HANDLE + pwsFileName*: LPCWSTR + pwsDisplayName*: LPCWSTR + dwReserved1*: DWORD + dwIntVersion*: DWORD + hProv*: HCRYPTPROV + DigestAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + dwFlags*: DWORD + dwEncodingType*: DWORD + dwReserved2*: DWORD + fdwCAPISettings*: DWORD + fdwSecuritySettings*: DWORD + dwIndex*: DWORD + dwUnionChoice*: DWORD + union1*: SIP_SUBJECTINFO_UNION1 + pClientData*: LPVOID + pCryptSIPGetSignedDataMsg* = proc (pSubjectInfo: ptr SIP_SUBJECTINFO, pdwEncodingType: ptr DWORD, dwIndex: DWORD, pcbSignedDataMsg: ptr DWORD, pbSignedDataMsg: ptr BYTE): WINBOOL {.stdcall.} + pCryptSIPPutSignedDataMsg* = proc (pSubjectInfo: ptr SIP_SUBJECTINFO, dwEncodingType: DWORD, pdwIndex: ptr DWORD, cbSignedDataMsg: DWORD, pbSignedDataMsg: ptr BYTE): WINBOOL {.stdcall.} + pCryptSIPCreateIndirectData* = proc (pSubjectInfo: ptr SIP_SUBJECTINFO, pcbIndirectData: ptr DWORD, pIndirectData: ptr SIP_INDIRECT_DATA): WINBOOL {.stdcall.} + pCryptSIPVerifyIndirectData* = proc (pSubjectInfo: ptr SIP_SUBJECTINFO, pIndirectData: ptr SIP_INDIRECT_DATA): WINBOOL {.stdcall.} + pCryptSIPRemoveSignedDataMsg* = proc (pSubjectInfo: ptr SIP_SUBJECTINFO, dwIndex: DWORD): WINBOOL {.stdcall.} + SIP_DISPATCH_INFO* {.pure.} = object + cbSize*: DWORD + hSIP*: HANDLE + pfGet*: pCryptSIPGetSignedDataMsg + pfPut*: pCryptSIPPutSignedDataMsg + pfCreate*: pCryptSIPCreateIndirectData + pfVerify*: pCryptSIPVerifyIndirectData + pfRemove*: pCryptSIPRemoveSignedDataMsg + PROVDATA_SIP* {.pure.} = object + cbStruct*: DWORD + gSubject*: GUID + pSip*: ptr SIP_DISPATCH_INFO + pCATSip*: ptr SIP_DISPATCH_INFO + psSipSubjectInfo*: ptr SIP_SUBJECTINFO + psSipCATSubjectInfo*: ptr SIP_SUBJECTINFO + psIndirectData*: ptr SIP_INDIRECT_DATA + CRYPT_PROVIDER_DATA_UNION1* {.pure, union.} = object + pPDSip*: ptr PROVDATA_SIP + CRYPT_PROVIDER_DATA* {.pure.} = object + cbStruct*: DWORD + pWintrustData*: ptr WINTRUST_DATA + fOpenedFile*: WINBOOL + hWndParent*: HWND + pgActionID*: ptr GUID + hProv*: HCRYPTPROV + dwError*: DWORD + dwRegSecuritySettings*: DWORD + dwRegPolicySettings*: DWORD + psPfns*: ptr CRYPT_PROVIDER_FUNCTIONS + cdwTrustStepErrors*: DWORD + padwTrustStepErrors*: ptr DWORD + chStores*: DWORD + pahStores*: ptr HCERTSTORE + dwEncoding*: DWORD + hMsg*: HCRYPTMSG + csSigners*: DWORD + pasSigners*: ptr CRYPT_PROVIDER_SGNR + csProvPrivData*: DWORD + pasProvPrivData*: ptr CRYPT_PROVIDER_PRIVDATA + dwSubjectChoice*: DWORD + union1*: CRYPT_PROVIDER_DATA_UNION1 + pszUsageOID*: ptr char + fRecallWithState*: WINBOOL + sftSystemTime*: FILETIME + pszCTLSignerUsageOID*: ptr char + dwProvFlags*: DWORD + dwFinalError*: DWORD + pRequestUsage*: PCERT_USAGE_MATCH + dwTrustPubSettings*: DWORD + dwUIStateFlags*: DWORD + PCRYPT_PROVIDER_DATA* = ptr CRYPT_PROVIDER_DATA + PCRYPT_PROVIDER_FUNCTIONS* = ptr CRYPT_PROVIDER_FUNCTIONS + PCRYPT_PROVUI_FUNCS* = ptr CRYPT_PROVUI_FUNCS + PCRYPT_PROVUI_DATA* = ptr CRYPT_PROVUI_DATA + PCRYPT_PROVIDER_SGNR* = ptr CRYPT_PROVIDER_SGNR + PCRYPT_PROVIDER_CERT* = ptr CRYPT_PROVIDER_CERT + PCRYPT_PROVIDER_PRIVDATA* = ptr CRYPT_PROVIDER_PRIVDATA + PPROVDATA_SIP* = ptr PROVDATA_SIP + CRYPT_TRUST_REG_ENTRY* {.pure.} = object + cbStruct*: DWORD + pwszDLLName*: ptr WCHAR + pwszFunctionName*: ptr WCHAR + PCRYPT_TRUST_REG_ENTRY* = ptr CRYPT_TRUST_REG_ENTRY + CRYPT_REGISTER_ACTIONID* {.pure.} = object + cbStruct*: DWORD + sInitProvider*: CRYPT_TRUST_REG_ENTRY + sObjectProvider*: CRYPT_TRUST_REG_ENTRY + sSignatureProvider*: CRYPT_TRUST_REG_ENTRY + sCertificateProvider*: CRYPT_TRUST_REG_ENTRY + sCertificatePolicyProvider*: CRYPT_TRUST_REG_ENTRY + sFinalPolicyProvider*: CRYPT_TRUST_REG_ENTRY + sTestPolicyProvider*: CRYPT_TRUST_REG_ENTRY + sCleanupProvider*: CRYPT_TRUST_REG_ENTRY + PCRYPT_REGISTER_ACTIONID* = ptr CRYPT_REGISTER_ACTIONID + CRYPT_PROVIDER_REGDEFUSAGE* {.pure.} = object + cbStruct*: DWORD + pgActionID*: ptr GUID + pwszDllName*: ptr WCHAR + pwszLoadCallbackDataFunctionName*: ptr char + pwszFreeCallbackDataFunctionName*: ptr char + PCRYPT_PROVIDER_REGDEFUSAGE* = ptr CRYPT_PROVIDER_REGDEFUSAGE + CRYPT_PROVIDER_DEFUSAGE* {.pure.} = object + cbStruct*: DWORD + gActionID*: GUID + pDefPolicyCallbackData*: LPVOID + pDefSIPClientData*: LPVOID + PCRYPT_PROVIDER_DEFUSAGE* = ptr CRYPT_PROVIDER_DEFUSAGE +const + SPC_UUID_LENGTH* = 16 +type + SPC_UUID* = array[SPC_UUID_LENGTH, BYTE] + SPC_SERIALIZED_OBJECT* {.pure.} = object + ClassId*: SPC_UUID + SerializedData*: CRYPT_DATA_BLOB + PSPC_SERIALIZED_OBJECT* = ptr SPC_SERIALIZED_OBJECT + SPC_SIGINFO* {.pure.} = object + dwSipVersion*: DWORD + gSIPGuid*: GUID + dwReserved1*: DWORD + dwReserved2*: DWORD + dwReserved3*: DWORD + dwReserved4*: DWORD + dwReserved5*: DWORD + PSPC_SIGINFO* = ptr SPC_SIGINFO + SPC_LINK_UNION1* {.pure, union.} = object + pwszUrl*: LPWSTR + Moniker*: SPC_SERIALIZED_OBJECT + pwszFile*: LPWSTR + SPC_LINK* {.pure.} = object + dwLinkChoice*: DWORD + union1*: SPC_LINK_UNION1 + PSPC_LINK* = ptr SPC_LINK + SPC_PE_IMAGE_DATA* {.pure.} = object + Flags*: CRYPT_BIT_BLOB + pFile*: PSPC_LINK + PSPC_PE_IMAGE_DATA* = ptr SPC_PE_IMAGE_DATA + SPC_INDIRECT_DATA_CONTENT* {.pure.} = object + Data*: CRYPT_ATTRIBUTE_TYPE_VALUE + DigestAlgorithm*: CRYPT_ALGORITHM_IDENTIFIER + Digest*: CRYPT_HASH_BLOB + PSPC_INDIRECT_DATA_CONTENT* = ptr SPC_INDIRECT_DATA_CONTENT + SPC_FINANCIAL_CRITERIA* {.pure.} = object + fFinancialInfoAvailable*: WINBOOL + fMeetsCriteria*: WINBOOL + PSPC_FINANCIAL_CRITERIA* = ptr SPC_FINANCIAL_CRITERIA + SPC_IMAGE* {.pure.} = object + pImageLink*: ptr SPC_LINK + Bitmap*: CRYPT_DATA_BLOB + Metafile*: CRYPT_DATA_BLOB + EnhancedMetafile*: CRYPT_DATA_BLOB + GifFile*: CRYPT_DATA_BLOB + PSPC_IMAGE* = ptr SPC_IMAGE + SPC_SP_AGENCY_INFO* {.pure.} = object + pPolicyInformation*: ptr SPC_LINK + pwszPolicyDisplayText*: LPWSTR + pLogoImage*: PSPC_IMAGE + pLogoLink*: ptr SPC_LINK + PSPC_SP_AGENCY_INFO* = ptr SPC_SP_AGENCY_INFO + SPC_STATEMENT_TYPE* {.pure.} = object + cKeyPurposeId*: DWORD + rgpszKeyPurposeId*: ptr LPSTR + PSPC_STATEMENT_TYPE* = ptr SPC_STATEMENT_TYPE + SPC_SP_OPUS_INFO* {.pure.} = object + pwszProgramName*: LPCWSTR + pMoreInfo*: ptr SPC_LINK + pPublisherInfo*: ptr SPC_LINK + PSPC_SP_OPUS_INFO* = ptr SPC_SP_OPUS_INFO + CAT_NAMEVALUE* {.pure.} = object + pwszTag*: LPWSTR + fdwFlags*: DWORD + Value*: CRYPT_DATA_BLOB + PCAT_NAMEVALUE* = ptr CAT_NAMEVALUE + CAT_MEMBERINFO* {.pure.} = object + pwszSubjGuid*: LPWSTR + dwCertVersion*: DWORD + PCAT_MEMBERINFO* = ptr CAT_MEMBERINFO + WIN_CERTIFICATE* {.pure.} = object + dwLength*: DWORD + wRevision*: WORD + wCertificateType*: WORD + bCertificate*: array[ANYSIZE_ARRAY, BYTE] + LPWIN_CERTIFICATE* = ptr WIN_CERTIFICATE + WIN_TRUST_SUBJECT* = LPVOID + WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT* {.pure.} = object + hClientToken*: HANDLE + SubjectType*: ptr GUID + Subject*: WIN_TRUST_SUBJECT + LPWIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT* = ptr WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT + WIN_TRUST_ACTDATA_SUBJECT_ONLY* {.pure.} = object + SubjectType*: ptr GUID + Subject*: WIN_TRUST_SUBJECT + LPWIN_TRUST_ACTDATA_SUBJECT_ONLY* = ptr WIN_TRUST_ACTDATA_SUBJECT_ONLY + WIN_TRUST_SUBJECT_FILE* {.pure.} = object + hFile*: HANDLE + lpPath*: LPCWSTR + LPWIN_TRUST_SUBJECT_FILE* = ptr WIN_TRUST_SUBJECT_FILE + WIN_TRUST_SUBJECT_FILE_AND_DISPLAY* {.pure.} = object + hFile*: HANDLE + lpPath*: LPCWSTR + lpDisplayName*: LPCWSTR + LPWIN_TRUST_SUBJECT_FILE_AND_DISPLAY* = ptr WIN_TRUST_SUBJECT_FILE_AND_DISPLAY + WIN_SPUB_TRUSTED_PUBLISHER_DATA* {.pure.} = object + hClientToken*: HANDLE + lpCertificate*: LPWIN_CERTIFICATE + LPWIN_SPUB_TRUSTED_PUBLISHER_DATA* = ptr WIN_SPUB_TRUSTED_PUBLISHER_DATA + CRYPT_DIGEST_DATA* = CRYPT_HASH_BLOB + LPSIP_SUBJECTINFO* = ptr SIP_SUBJECTINFO + PMS_ADDINFO_FLAT* = ptr MS_ADDINFO_FLAT + PMS_ADDINFO_CATALOGMEMBER* = ptr MS_ADDINFO_CATALOGMEMBER + PMS_ADDINFO_BLOB* = ptr MS_ADDINFO_BLOB + PSIP_INDIRECT_DATA* = ptr SIP_INDIRECT_DATA + LPSIP_DISPATCH_INFO* = ptr SIP_DISPATCH_INFO + SIP_ADD_NEWPROVIDER* {.pure.} = object + cbStruct*: DWORD + pgSubject*: ptr GUID + pwszDLLFileName*: ptr WCHAR + pwszMagicNumber*: ptr WCHAR + pwszIsFunctionName*: ptr WCHAR + pwszGetFuncName*: ptr WCHAR + pwszPutFuncName*: ptr WCHAR + pwszCreateFuncName*: ptr WCHAR + pwszVerifyFuncName*: ptr WCHAR + pwszRemoveFuncName*: ptr WCHAR + pwszIsFunctionNameFmt2*: ptr WCHAR + PSIP_ADD_NEWPROVIDER* = ptr SIP_ADD_NEWPROVIDER +const + WTD_UI_ALL* = 1 + WTD_UI_NONE* = 2 + WTD_UI_NOBAD* = 3 + WTD_UI_NOGOOD* = 4 + WTD_REVOKE_NONE* = 0x00000000 + WTD_REVOKE_WHOLECHAIN* = 0x00000001 + WTD_CHOICE_FILE* = 1 + WTD_CHOICE_CATALOG* = 2 + WTD_CHOICE_BLOB* = 3 + WTD_CHOICE_SIGNER* = 4 + WTD_CHOICE_CERT* = 5 + WTD_STATEACTION_IGNORE* = 0x00000000 + WTD_STATEACTION_VERIFY* = 0x00000001 + WTD_STATEACTION_CLOSE* = 0x00000002 + WTD_STATEACTION_AUTO_CACHE* = 0x00000003 + WTD_STATEACTION_AUTO_CACHE_FLUSH* = 0x00000004 + WTD_PROV_FLAGS_MASK* = 0x0000FFFF + WTD_USE_IE4_TRUST_FLAG* = 0x00000001 + WTD_NO_IE4_CHAIN_FLAG* = 0x00000002 + WTD_NO_POLICY_USAGE_FLAG* = 0x00000004 + WTD_REVOCATION_CHECK_NONE* = 0x00000010 + WTD_REVOCATION_CHECK_END_CERT* = 0x00000020 + WTD_REVOCATION_CHECK_CHAIN* = 0x00000040 + WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT* = 0x00000080 + WTD_SAFER_FLAG* = 0x00000100 + WTD_HASH_ONLY_FLAG* = 0x00000200 + WTD_USE_DEFAULT_OSVER_CHECK* = 0x00000400 + WTD_LIFETIME_SIGNING_FLAG* = 0x00000800 + WTD_CACHE_ONLY_URL_RETRIEVAL* = 0x00001000 + WTD_UICONTEXT_EXECUTE* = 0 + WTD_UICONTEXT_INSTALL* = 1 + WTCI_DONT_OPEN_STORES* = 0x00000001 + WTCI_OPEN_ONLY_ROOT* = 0x00000002 + WTPF_TRUSTTEST* = 0x00000020 + WTPF_TESTCANBEVALID* = 0x00000080 + WTPF_IGNOREEXPIRATION* = 0x00000100 + WTPF_IGNOREREVOKATION* = 0x00000200 + WTPF_OFFLINEOK_IND* = 0x00000400 + WTPF_OFFLINEOK_COM* = 0x00000800 + WTPF_OFFLINEOKNBU_IND* = 0x00001000 + WTPF_OFFLINEOKNBU_COM* = 0x00002000 + WTPF_VERIFY_V1_OFF* = 0x00010000 + WTPF_IGNOREREVOCATIONONTS* = 0x00020000 + WTPF_ALLOWONLYPERTRUST* = 0x00040000 + TRUSTERROR_STEP_WVTPARAMS* = 0 + TRUSTERROR_STEP_FILEIO* = 2 + TRUSTERROR_STEP_SIP* = 3 + TRUSTERROR_STEP_SIPSUBJINFO* = 5 + TRUSTERROR_STEP_CATALOGFILE* = 6 + TRUSTERROR_STEP_CERTSTORE* = 7 + TRUSTERROR_STEP_MESSAGE* = 8 + TRUSTERROR_STEP_MSG_SIGNERCOUNT* = 9 + TRUSTERROR_STEP_MSG_INNERCNTTYPE* = 10 + TRUSTERROR_STEP_MSG_INNERCNT* = 11 + TRUSTERROR_STEP_MSG_STORE* = 12 + TRUSTERROR_STEP_MSG_SIGNERINFO* = 13 + TRUSTERROR_STEP_MSG_SIGNERCERT* = 14 + TRUSTERROR_STEP_MSG_CERTCHAIN* = 15 + TRUSTERROR_STEP_MSG_COUNTERSIGINFO* = 16 + TRUSTERROR_STEP_MSG_COUNTERSIGCERT* = 17 + TRUSTERROR_STEP_VERIFY_MSGHASH* = 18 + TRUSTERROR_STEP_VERIFY_MSGINDIRECTDATA* = 19 + TRUSTERROR_STEP_FINAL_WVTINIT* = 30 + TRUSTERROR_STEP_FINAL_INITPROV* = 31 + TRUSTERROR_STEP_FINAL_OBJPROV* = 32 + TRUSTERROR_STEP_FINAL_SIGPROV* = 33 + TRUSTERROR_STEP_FINAL_CERTPROV* = 34 + TRUSTERROR_STEP_FINAL_CERTCHKPROV* = 35 + TRUSTERROR_STEP_FINAL_POLICYPROV* = 36 + TRUSTERROR_STEP_FINAL_UIPROV* = 37 + TRUSTERROR_MAX_STEPS* = 38 + CPD_CHOICE_SIP* = 1 + CPD_USE_NT5_CHAIN_FLAG* = 0x80000000'i32 + CPD_REVOCATION_CHECK_NONE* = 0x00010000 + CPD_REVOCATION_CHECK_END_CERT* = 0x00020000 + CPD_REVOCATION_CHECK_CHAIN* = 0x00040000 + CPD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT* = 0x00080000 + CPD_UISTATE_MODE_PROMPT* = 0x00000000 + CPD_UISTATE_MODE_BLOCK* = 0x00000001 + CPD_UISTATE_MODE_ALLOW* = 0x00000002 + CPD_UISTATE_MODE_MASK* = 0x00000003 + SGNR_TYPE_TIMESTAMP* = 0x00000010 + CERT_CONFIDENCE_SIG* = 0x10000000 + CERT_CONFIDENCE_TIME* = 0x01000000 + CERT_CONFIDENCE_TIMENEST* = 0x00100000 + CERT_CONFIDENCE_AUTHIDEXT* = 0x00010000 + CERT_CONFIDENCE_HYGIENE* = 0x00001000 + CERT_CONFIDENCE_HIGHEST* = 0x11111000 + WT_CURRENT_VERSION* = 0x00000200 + WT_PROVIDER_DLL_NAME* = "WINTRUST.DL" + WT_PROVIDER_CERTTRUST_FUNCTION* = "WintrustCertificateTrust" + WT_ADD_ACTION_ID_RET_RESULT_FLAG* = 0x1 + DWACTION_ALLOCANDFILL* = 1 + DWACTION_FREE* = 2 + szOID_TRUSTED_CODESIGNING_CA_LIST* = "1.3.6.1.4.1.311.2.2.1" + szOID_TRUSTED_CLIENT_AUTH_CA_LIST* = "1.3.6.1.4.1.311.2.2.2" + szOID_TRUSTED_SERVER_AUTH_CA_LIST* = "1.3.6.1.4.1.311.2.2.3" + SPC_COMMON_NAME_OBJID* = szOID_COMMON_NAME + SPC_TIME_STAMP_REQUEST_OBJID* = "1.3.6.1.4.1.311.3.2.1" + SPC_INDIRECT_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.4" + SPC_SP_AGENCY_INFO_OBJID* = "1.3.6.1.4.1.311.2.1.10" + SPC_STATEMENT_TYPE_OBJID* = "1.3.6.1.4.1.311.2.1.11" + SPC_SP_OPUS_INFO_OBJID* = "1.3.6.1.4.1.311.2.1.12" + SPC_CERT_EXTENSIONS_OBJID* = "1.3.6.1.4.1.311.2.1.14" + SPC_PE_IMAGE_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.15" + SPC_RAW_FILE_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.18" + SPC_STRUCTURED_STORAGE_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.19" + SPC_JAVA_CLASS_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.20" + SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID* = "1.3.6.1.4.1.311.2.1.21" + SPC_COMMERCIAL_SP_KEY_PURPOSE_OBJID* = "1.3.6.1.4.1.311.2.1.22" + SPC_CAB_DATA_OBJID* = "1.3.6.1.4.1.311.2.1.25" + SPC_GLUE_RDN_OBJID* = "1.3.6.1.4.1.311.2.1.25" + SPC_MINIMAL_CRITERIA_OBJID* = "1.3.6.1.4.1.311.2.1.26" + SPC_FINANCIAL_CRITERIA_OBJID* = "1.3.6.1.4.1.311.2.1.27" + SPC_LINK_OBJID* = "1.3.6.1.4.1.311.2.1.28" + SPC_SIGINFO_OBJID* = "1.3.6.1.4.1.311.2.1.30" + CAT_NAMEVALUE_OBJID* = "1.3.6.1.4.1.311.12.2.1" + CAT_MEMBERINFO_OBJID* = "1.3.6.1.4.1.311.12.2.2" + SPC_SP_AGENCY_INFO_STRUCT* = cast[LPCSTR](2000) + SPC_MINIMAL_CRITERIA_STRUCT* = cast[LPCSTR](2001) + SPC_FINANCIAL_CRITERIA_STRUCT* = cast[LPCSTR](2002) + SPC_INDIRECT_DATA_CONTENT_STRUCT* = cast[LPCSTR](2003) + SPC_PE_IMAGE_DATA_STRUCT* = cast[LPCSTR](2004) + SPC_LINK_STRUCT* = cast[LPCSTR](2005) + SPC_STATEMENT_TYPE_STRUCT* = cast[LPCSTR](2006) + SPC_SP_OPUS_INFO_STRUCT* = cast[LPCSTR](2007) + SPC_CAB_DATA_STRUCT* = cast[LPCSTR](2008) + SPC_JAVA_CLASS_DATA_STRUCT* = cast[LPCSTR](2009) + SPC_SIGINFO_STRUCT* = cast[LPCSTR](2130) + CAT_NAMEVALUE_STRUCT* = cast[LPCSTR](2221) + CAT_MEMBERINFO_STRUCT* = cast[LPCSTR](2222) + SPC_URL_LINK_CHOICE* = 1 + SPC_MONIKER_LINK_CHOICE* = 2 + SPC_FILE_LINK_CHOICE* = 3 + WIN_CERT_REVISION_1_0* = 0x0100 + WIN_CERT_REVISION_2_0* = 0x0200 + WIN_CERT_TYPE_X509* = 0x0001 + WIN_CERT_TYPE_PKCS_SIGNED_DATA* = 0x0002 + WIN_CERT_TYPE_RESERVED_1* = 0x0003 + WIN_CERT_TYPE_TS_STACK_SIGNED* = 0x0004 + WIN_TRUST_SUBJTYPE_RAW_FILE* = DEFINE_GUID("959dc450-8d9e-11cf-8736-00aa00a485eb") + WIN_TRUST_SUBJTYPE_PE_IMAGE* = DEFINE_GUID("43c9a1e0-8da0-11cf-8736-00aa00a485eb") + WIN_TRUST_SUBJTYPE_JAVA_CLASS* = DEFINE_GUID("08ad3990-8da1-11cf-8736-00aa00a485eb") + WIN_TRUST_SUBJTYPE_CABINET* = DEFINE_GUID("d17c5374-a392-11cf-9df5-00aa00c184e0") + WIN_TRUST_SUBJTYPE_RAW_FILEEX* = DEFINE_GUID("6f458110-c2f1-11cf-8a69-00aa006c3706") + WIN_TRUST_SUBJTYPE_PE_IMAGEEX* = DEFINE_GUID("6f458111-c2f1-11cf-8a69-00aa006c3706") + WIN_TRUST_SUBJTYPE_JAVA_CLASSEX* = DEFINE_GUID("6f458113-c2f1-11cf-8a69-00aa006c3706") + WIN_TRUST_SUBJTYPE_CABINETEX* = DEFINE_GUID("6f458114-c2f1-11cf-8a69-00aa006c3706") + WIN_TRUST_SUBJTYPE_OLE_STORAGE* = DEFINE_GUID("c257e740-8da0-11cf-8736-00aa00a485eb") + WIN_SPUB_ACTION_TRUSTED_PUBLISHER* = DEFINE_GUID("66426730-8da1-11cf-8736-00aa00a485eb") + WIN_SPUB_ACTION_NT_ACTIVATE_IMAGE* = DEFINE_GUID("8bc96b00-8da1-11cf-8736-00aa00a485eb") + WIN_SPUB_ACTION_PUBLISHED_SOFTWARE* = DEFINE_GUID("64b9d180-8da2-11cf-8736-00aa00a485eb") + MSSIP_FLAGS_PROHIBIT_RESIZE_ON_CREATE* = 0x00010000 + MSSIP_FLAGS_USE_CATALOG* = 0x00020000 + SPC_INC_PE_RESOURCES_FLAG* = 0x80 + SPC_INC_PE_DEBUG_INFO_FLAG* = 0x40 + SPC_INC_PE_IMPORT_ADDR_TABLE_FLAG* = 0x20 + SIP_MAX_MAGIC_NUMBER* = 4 + CRYPTCAT_OPEN_CREATENEW* = 0x00000001 + CRYPTCAT_OPEN_ALWAYS* = 0x00000002 + CRYPTCAT_OPEN_EXISTING* = 0x00000004 + CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES* = 0x00010000 + CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES* = 0x00020000 + CRYPTCAT_OPEN_VERIFYSIGHASH* = 0x10000000 + CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG* = 0x20000000 + CRYPTCAT_OPEN_SORTED* = 0x40000000 + CRYPTCAT_OPEN_FLAGS_MASK* = 0xffff0000'i32 + CRYPTCAT_E_AREA_HEADER* = 0x00000000 + CRYPTCAT_E_AREA_MEMBER* = 0x00010000 + CRYPTCAT_E_AREA_ATTRIBUTE* = 0x00020000 + CRYPTCAT_E_CDF_UNSUPPORTED* = 0x00000001 + CRYPTCAT_E_CDF_DUPLICATE* = 0x00000002 + CRYPTCAT_E_CDF_TAGNOTFOUND* = 0x00000004 + CRYPTCAT_E_CDF_MEMBER_FILE_PATH* = 0x00010001 + CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA* = 0x00010002 + CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND* = 0x00010004 + CRYPTCAT_E_CDF_BAD_GUID_CONV* = 0x00020001 + CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES* = 0x00020002 + CRYPTCAT_E_CDF_ATTR_TYPECOMBO* = 0x00020004 +type + PFN_ALLOCANDFILLDEFUSAGE* = proc (pszUsageOID: ptr char, psDefUsage: ptr CRYPT_PROVIDER_DEFUSAGE): WINBOOL {.stdcall.} + PFN_FREEDEFUSAGE* = proc (pszUsageOID: ptr char, psDefUsage: ptr CRYPT_PROVIDER_DEFUSAGE): WINBOOL {.stdcall.} + pfnIsFileSupported* = proc (hFile: HANDLE, pgSubject: ptr GUID): WINBOOL {.stdcall.} + pfnIsFileSupportedName* = proc (pwszFileName: ptr WCHAR, pgSubject: ptr GUID): WINBOOL {.stdcall.} + PFN_CDF_PARSE_ERROR_CALLBACK* = proc (P1: DWORD, P2: DWORD, P3: ptr WCHAR): void {.stdcall.} + CRYPTCATATTRIBUTE* {.pure.} = object + cbStruct*: DWORD + pwszReferenceTag*: LPWSTR + dwAttrTypeAndAction*: DWORD + cbValue*: DWORD + pbValue*: ptr BYTE + dwReserved*: DWORD + CATALOG_INFO* {.pure.} = object + cbStruct*: DWORD + wszCatalogFile*: array[MAX_PATH, WCHAR] + CRYPTCATCDF* {.pure.} = object + cbStruct*: DWORD + hFile*: HANDLE + dwCurFilePos*: DWORD + dwLastMemberOffset*: DWORD + fEOF*: WINBOOL + pwszResultDir*: LPWSTR + hCATStore*: HANDLE +proc WinVerifyTrust*(hwnd: HWND, pgActionID: ptr GUID, pWVTData: LPVOID): LONG {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WinVerifyTrustEx*(hwnd: HWND, pgActionID: ptr GUID, pWinTrustData: ptr WINTRUST_DATA): HRESULT {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustGetRegPolicyFlags*(pdwPolicyFlags: ptr DWORD): void {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustSetRegPolicyFlags*(dwPolicyFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustAddActionID*(pgActionID: ptr GUID, fdwFlags: DWORD, psProvInfo: ptr CRYPT_REGISTER_ACTIONID): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustRemoveActionID*(pgActionID: ptr GUID): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustLoadFunctionPointers*(pgActionID: ptr GUID, pPfns: ptr CRYPT_PROVIDER_FUNCTIONS): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustAddDefaultForUsage*(pszUsageOID: ptr char, psDefUsage: ptr CRYPT_PROVIDER_REGDEFUSAGE): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustGetDefaultForUsage*(dwAction: DWORD, pszUsageOID: ptr char, psUsage: ptr CRYPT_PROVIDER_DEFUSAGE): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperGetProvSignerFromChain*(pProvData: ptr CRYPT_PROVIDER_DATA, idxSigner: DWORD, fCounterSigner: WINBOOL, idxCounterSigner: DWORD): ptr CRYPT_PROVIDER_SGNR {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperGetProvCertFromChain*(pSgnr: ptr CRYPT_PROVIDER_SGNR, idxCert: DWORD): ptr CRYPT_PROVIDER_CERT {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperProvDataFromStateData*(hStateData: HANDLE): ptr CRYPT_PROVIDER_DATA {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperGetProvPrivateDataFromChain*(pProvData: ptr CRYPT_PROVIDER_DATA, pgProviderID: ptr GUID): ptr CRYPT_PROVIDER_PRIVDATA {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperCertIsSelfSigned*(dwEncoding: DWORD, pCert: ptr CERT_INFO): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WTHelperCertCheckValidSignature*(pProvData: ptr CRYPT_PROVIDER_DATA): HRESULT {.winapi, stdcall, dynlib: "wintrust", importc.} +proc WintrustSetDefaultIncludePEPageHashes*(fIncludePEPageHashes: WINBOOL): void {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptSIPGetSignedDataMsg*(pSubjectInfo: ptr SIP_SUBJECTINFO, pdwEncodingType: ptr DWORD, dwIndex: DWORD, pcbSignedDataMsg: ptr DWORD, pbSignedDataMsg: ptr BYTE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPPutSignedDataMsg*(pSubjectInfo: ptr SIP_SUBJECTINFO, dwEncodingType: DWORD, pdwIndex: ptr DWORD, cbSignedDataMsg: DWORD, pbSignedDataMsg: ptr BYTE): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPCreateIndirectData*(pSubjectInfo: ptr SIP_SUBJECTINFO, pcbIndirectData: ptr DWORD, pIndirectData: ptr SIP_INDIRECT_DATA): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPVerifyIndirectData*(pSubjectInfo: ptr SIP_SUBJECTINFO, pIndirectData: ptr SIP_INDIRECT_DATA): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPRemoveSignedDataMsg*(pSubjectInfo: ptr SIP_SUBJECTINFO, dwIndex: DWORD): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPLoad*(pgSubject: ptr GUID, dwFlags: DWORD, pSipDispatch: ptr SIP_DISPATCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPRetrieveSubjectGuid*(FileName: LPCWSTR, hFileIn: HANDLE, pgSubject: ptr GUID): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPRetrieveSubjectGuidForCatalogFile*(FileName: LPCWSTR, hFileIn: HANDLE, pgSubject: ptr GUID): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPAddProvider*(psNewProv: ptr SIP_ADD_NEWPROVIDER): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptSIPRemoveProvider*(pgProv: ptr GUID): WINBOOL {.winapi, stdcall, dynlib: "crypt32", importc.} +proc CryptCATAdminAcquireContext*(P1: ptr HCATADMIN, P2: ptr GUID, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminAddCatalog*(P1: HCATADMIN, P2: PWSTR, P3: PWSTR, P4: DWORD): HCATINFO {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminCalcHashFromFileHandle*(P1: HANDLE, P2: ptr DWORD, P3: ptr BYTE, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminEnumCatalogFromHash*(P1: HCATADMIN, P2: ptr BYTE, P3: DWORD, P4: DWORD, P5: ptr HCATINFO): HCATINFO {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminReleaseCatalogContext*(P1: HCATADMIN, P2: HCATINFO, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminReleaseContext*(P1: HCATADMIN, P2: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminRemoveCatalog*(P1: HCATADMIN, P2: LPCWSTR, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATAdminResolveCatalogPath*(P1: HCATADMIN, P2: ptr WCHAR, P3: ptr CATALOG_INFO, P4: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATCatalogInfoFromContext*(P1: HCATINFO, P2: ptr CATALOG_INFO, P3: DWORD): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATCDFClose*(P1: ptr CRYPTCATCDF): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATCDFEnumMembersByCDFTagEx*(P1: ptr CRYPTCATCDF, P2: LPWSTR, P3: PFN_CDF_PARSE_ERROR_CALLBACK, P4: ptr ptr CRYPTCATMEMBER, P5: WINBOOL, P6: LPVOID): LPWSTR {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATClose*(P1: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "wintrust", importc.} +proc CryptCATOpen*(P1: LPWSTR, P2: DWORD, P3: HCRYPTPROV, P4: DWORD, P5: DWORD): HANDLE {.winapi, stdcall, dynlib: "wintrust", importc.} +proc `pFile=`*(self: var WINTRUST_DATA, x: ptr WINTRUST_FILE_INFO) {.inline.} = self.union1.pFile = x +proc pFile*(self: WINTRUST_DATA): ptr WINTRUST_FILE_INFO {.inline.} = self.union1.pFile +proc pFile*(self: var WINTRUST_DATA): var ptr WINTRUST_FILE_INFO {.inline.} = self.union1.pFile +proc `pCatalog=`*(self: var WINTRUST_DATA, x: ptr WINTRUST_CATALOG_INFO) {.inline.} = self.union1.pCatalog = x +proc pCatalog*(self: WINTRUST_DATA): ptr WINTRUST_CATALOG_INFO {.inline.} = self.union1.pCatalog +proc pCatalog*(self: var WINTRUST_DATA): var ptr WINTRUST_CATALOG_INFO {.inline.} = self.union1.pCatalog +proc `pBlob=`*(self: var WINTRUST_DATA, x: ptr WINTRUST_BLOB_INFO) {.inline.} = self.union1.pBlob = x +proc pBlob*(self: WINTRUST_DATA): ptr WINTRUST_BLOB_INFO {.inline.} = self.union1.pBlob +proc pBlob*(self: var WINTRUST_DATA): var ptr WINTRUST_BLOB_INFO {.inline.} = self.union1.pBlob +proc `pSgnr=`*(self: var WINTRUST_DATA, x: ptr WINTRUST_SGNR_INFO) {.inline.} = self.union1.pSgnr = x +proc pSgnr*(self: WINTRUST_DATA): ptr WINTRUST_SGNR_INFO {.inline.} = self.union1.pSgnr +proc pSgnr*(self: var WINTRUST_DATA): var ptr WINTRUST_SGNR_INFO {.inline.} = self.union1.pSgnr +proc `pCert=`*(self: var WINTRUST_DATA, x: ptr WINTRUST_CERT_INFO) {.inline.} = self.union1.pCert = x +proc pCert*(self: WINTRUST_DATA): ptr WINTRUST_CERT_INFO {.inline.} = self.union1.pCert +proc pCert*(self: var WINTRUST_DATA): var ptr WINTRUST_CERT_INFO {.inline.} = self.union1.pCert +proc `pPDSip=`*(self: var CRYPT_PROVIDER_DATA, x: ptr PROVDATA_SIP) {.inline.} = self.union1.pPDSip = x +proc pPDSip*(self: CRYPT_PROVIDER_DATA): ptr PROVDATA_SIP {.inline.} = self.union1.pPDSip +proc pPDSip*(self: var CRYPT_PROVIDER_DATA): var ptr PROVDATA_SIP {.inline.} = self.union1.pPDSip +proc `pwszUrl=`*(self: var SPC_LINK, x: LPWSTR) {.inline.} = self.union1.pwszUrl = x +proc pwszUrl*(self: SPC_LINK): LPWSTR {.inline.} = self.union1.pwszUrl +proc pwszUrl*(self: var SPC_LINK): var LPWSTR {.inline.} = self.union1.pwszUrl +proc `Moniker=`*(self: var SPC_LINK, x: SPC_SERIALIZED_OBJECT) {.inline.} = self.union1.Moniker = x +proc Moniker*(self: SPC_LINK): SPC_SERIALIZED_OBJECT {.inline.} = self.union1.Moniker +proc Moniker*(self: var SPC_LINK): var SPC_SERIALIZED_OBJECT {.inline.} = self.union1.Moniker +proc `pwszFile=`*(self: var SPC_LINK, x: LPWSTR) {.inline.} = self.union1.pwszFile = x +proc pwszFile*(self: SPC_LINK): LPWSTR {.inline.} = self.union1.pwszFile +proc pwszFile*(self: var SPC_LINK): var LPWSTR {.inline.} = self.union1.pwszFile +proc `psFlat=`*(self: var SIP_SUBJECTINFO, x: ptr MS_ADDINFO_FLAT) {.inline.} = self.union1.psFlat = x +proc psFlat*(self: SIP_SUBJECTINFO): ptr MS_ADDINFO_FLAT {.inline.} = self.union1.psFlat +proc psFlat*(self: var SIP_SUBJECTINFO): var ptr MS_ADDINFO_FLAT {.inline.} = self.union1.psFlat +proc `psCatMember=`*(self: var SIP_SUBJECTINFO, x: ptr MS_ADDINFO_CATALOGMEMBER) {.inline.} = self.union1.psCatMember = x +proc psCatMember*(self: SIP_SUBJECTINFO): ptr MS_ADDINFO_CATALOGMEMBER {.inline.} = self.union1.psCatMember +proc psCatMember*(self: var SIP_SUBJECTINFO): var ptr MS_ADDINFO_CATALOGMEMBER {.inline.} = self.union1.psCatMember +proc `psBlob=`*(self: var SIP_SUBJECTINFO, x: ptr MS_ADDINFO_BLOB) {.inline.} = self.union1.psBlob = x +proc psBlob*(self: SIP_SUBJECTINFO): ptr MS_ADDINFO_BLOB {.inline.} = self.union1.psBlob +proc psBlob*(self: var SIP_SUBJECTINFO): var ptr MS_ADDINFO_BLOB {.inline.} = self.union1.psBlob diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winuser.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winuser.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,5438 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winbase +import wingdi +#include +#include +type + FEEDBACK_TYPE* = int32 + POINTER_BUTTON_CHANGE_TYPE* = int32 + POINTER_DEVICE_TYPE* = int32 + POINTER_DEVICE_CURSOR_TYPE* = int32 + INPUT_MESSAGE_DEVICE_TYPE* = int32 + INPUT_MESSAGE_ORIGIN_ID* = int32 + AR_STATE* = int32 + PAR_STATE* = ptr int32 + ORIENTATION_PREFERENCE* = int32 + HDWP* = HANDLE + LPMENUTEMPLATEA* = PVOID + LPMENUTEMPLATEW* = PVOID + HDEVNOTIFY* = PVOID + HPOWERNOTIFY* = HANDLE + HTOUCHINPUT* = HANDLE + POINTER_INPUT_TYPE* = DWORD + HELPPOLY* = DWORD + HRAWINPUT* = HANDLE + HGESTUREINFO* = HANDLE + NAMEENUMPROCA* = proc (P1: LPSTR, P2: LPARAM): WINBOOL {.stdcall.} + WINSTAENUMPROCA* = NAMEENUMPROCA + NAMEENUMPROCW* = proc (P1: LPWSTR, P2: LPARAM): WINBOOL {.stdcall.} + WINSTAENUMPROCW* = NAMEENUMPROCW + DESKTOPENUMPROCA* = NAMEENUMPROCA + DESKTOPENUMPROCW* = NAMEENUMPROCW + CREATESTRUCTA* {.pure.} = object + lpCreateParams*: LPVOID + hInstance*: HINSTANCE + hMenu*: HMENU + hwndParent*: HWND + cy*: int32 + cx*: int32 + y*: int32 + x*: int32 + style*: LONG + lpszName*: LPCSTR + lpszClass*: LPCSTR + dwExStyle*: DWORD + CBT_CREATEWNDA* {.pure.} = object + lpcs*: ptr CREATESTRUCTA + hwndInsertAfter*: HWND + LPCBT_CREATEWNDA* = ptr CBT_CREATEWNDA + CREATESTRUCTW* {.pure.} = object + lpCreateParams*: LPVOID + hInstance*: HINSTANCE + hMenu*: HMENU + hwndParent*: HWND + cy*: int32 + cx*: int32 + y*: int32 + x*: int32 + style*: LONG + lpszName*: LPCWSTR + lpszClass*: LPCWSTR + dwExStyle*: DWORD + CBT_CREATEWNDW* {.pure.} = object + lpcs*: ptr CREATESTRUCTW + hwndInsertAfter*: HWND + LPCBT_CREATEWNDW* = ptr CBT_CREATEWNDW + CBTACTIVATESTRUCT* {.pure.} = object + fMouse*: WINBOOL + hWndActive*: HWND + LPCBTACTIVATESTRUCT* = ptr CBTACTIVATESTRUCT + WTSSESSION_NOTIFICATION* {.pure.} = object + cbSize*: DWORD + dwSessionId*: DWORD + PWTSSESSION_NOTIFICATION* = ptr WTSSESSION_NOTIFICATION + SHELLHOOKINFO* {.pure.} = object + hwnd*: HWND + rc*: RECT + LPSHELLHOOKINFO* = ptr SHELLHOOKINFO + EVENTMSG* {.pure.} = object + message*: UINT + paramL*: UINT + paramH*: UINT + time*: DWORD + hwnd*: HWND + PEVENTMSGMSG* = ptr EVENTMSG + NPEVENTMSGMSG* = ptr EVENTMSG + LPEVENTMSGMSG* = ptr EVENTMSG + PEVENTMSG* = ptr EVENTMSG + NPEVENTMSG* = ptr EVENTMSG + LPEVENTMSG* = ptr EVENTMSG + CWPSTRUCT* {.pure.} = object + lParam*: LPARAM + wParam*: WPARAM + message*: UINT + hwnd*: HWND + PCWPSTRUCT* = ptr CWPSTRUCT + NPCWPSTRUCT* = ptr CWPSTRUCT + LPCWPSTRUCT* = ptr CWPSTRUCT + CWPRETSTRUCT* {.pure.} = object + lResult*: LRESULT + lParam*: LPARAM + wParam*: WPARAM + message*: UINT + hwnd*: HWND + PCWPRETSTRUCT* = ptr CWPRETSTRUCT + NPCWPRETSTRUCT* = ptr CWPRETSTRUCT + LPCWPRETSTRUCT* = ptr CWPRETSTRUCT + KBDLLHOOKSTRUCT* {.pure.} = object + vkCode*: DWORD + scanCode*: DWORD + flags*: DWORD + time*: DWORD + dwExtraInfo*: ULONG_PTR + LPKBDLLHOOKSTRUCT* = ptr KBDLLHOOKSTRUCT + PKBDLLHOOKSTRUCT* = ptr KBDLLHOOKSTRUCT + MSLLHOOKSTRUCT* {.pure.} = object + pt*: POINT + mouseData*: DWORD + flags*: DWORD + time*: DWORD + dwExtraInfo*: ULONG_PTR + LPMSLLHOOKSTRUCT* = ptr MSLLHOOKSTRUCT + PMSLLHOOKSTRUCT* = ptr MSLLHOOKSTRUCT + DEBUGHOOKINFO* {.pure.} = object + idThread*: DWORD + idThreadInstaller*: DWORD + lParam*: LPARAM + wParam*: WPARAM + code*: int32 + PDEBUGHOOKINFO* = ptr DEBUGHOOKINFO + NPDEBUGHOOKINFO* = ptr DEBUGHOOKINFO + LPDEBUGHOOKINFO* = ptr DEBUGHOOKINFO + MOUSEHOOKSTRUCT* {.pure.} = object + pt*: POINT + hwnd*: HWND + wHitTestCode*: UINT + dwExtraInfo*: ULONG_PTR + LPMOUSEHOOKSTRUCT* = ptr MOUSEHOOKSTRUCT + PMOUSEHOOKSTRUCT* = ptr MOUSEHOOKSTRUCT + MOUSEHOOKSTRUCTEX* {.pure.} = object + unnamed*: MOUSEHOOKSTRUCT + mouseData*: DWORD + LPMOUSEHOOKSTRUCTEX* = ptr MOUSEHOOKSTRUCTEX + PMOUSEHOOKSTRUCTEX* = ptr MOUSEHOOKSTRUCTEX + HARDWAREHOOKSTRUCT* {.pure.} = object + hwnd*: HWND + message*: UINT + wParam*: WPARAM + lParam*: LPARAM + LPHARDWAREHOOKSTRUCT* = ptr HARDWAREHOOKSTRUCT + PHARDWAREHOOKSTRUCT* = ptr HARDWAREHOOKSTRUCT + MOUSEMOVEPOINT* {.pure.} = object + x*: int32 + y*: int32 + time*: DWORD + dwExtraInfo*: ULONG_PTR + PMOUSEMOVEPOINT* = ptr MOUSEMOVEPOINT + LPMOUSEMOVEPOINT* = ptr MOUSEMOVEPOINT + USEROBJECTFLAGS* {.pure.} = object + fInherit*: WINBOOL + fReserved*: WINBOOL + dwFlags*: DWORD + PUSEROBJECTFLAGS* = ptr USEROBJECTFLAGS + WNDPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): LRESULT {.stdcall.} + WNDCLASSEXA* {.pure.} = object + cbSize*: UINT + style*: UINT + lpfnWndProc*: WNDPROC + cbClsExtra*: int32 + cbWndExtra*: int32 + hInstance*: HINSTANCE + hIcon*: HICON + hCursor*: HCURSOR + hbrBackground*: HBRUSH + lpszMenuName*: LPCSTR + lpszClassName*: LPCSTR + hIconSm*: HICON + PWNDCLASSEXA* = ptr WNDCLASSEXA + NPWNDCLASSEXA* = ptr WNDCLASSEXA + LPWNDCLASSEXA* = ptr WNDCLASSEXA + WNDCLASSEXW* {.pure.} = object + cbSize*: UINT + style*: UINT + lpfnWndProc*: WNDPROC + cbClsExtra*: int32 + cbWndExtra*: int32 + hInstance*: HINSTANCE + hIcon*: HICON + hCursor*: HCURSOR + hbrBackground*: HBRUSH + lpszMenuName*: LPCWSTR + lpszClassName*: LPCWSTR + hIconSm*: HICON + PWNDCLASSEXW* = ptr WNDCLASSEXW + NPWNDCLASSEXW* = ptr WNDCLASSEXW + LPWNDCLASSEXW* = ptr WNDCLASSEXW + WNDCLASSA* {.pure.} = object + style*: UINT + lpfnWndProc*: WNDPROC + cbClsExtra*: int32 + cbWndExtra*: int32 + hInstance*: HINSTANCE + hIcon*: HICON + hCursor*: HCURSOR + hbrBackground*: HBRUSH + lpszMenuName*: LPCSTR + lpszClassName*: LPCSTR + PWNDCLASSA* = ptr WNDCLASSA + NPWNDCLASSA* = ptr WNDCLASSA + LPWNDCLASSA* = ptr WNDCLASSA + WNDCLASSW* {.pure.} = object + style*: UINT + lpfnWndProc*: WNDPROC + cbClsExtra*: int32 + cbWndExtra*: int32 + hInstance*: HINSTANCE + hIcon*: HICON + hCursor*: HCURSOR + hbrBackground*: HBRUSH + lpszMenuName*: LPCWSTR + lpszClassName*: LPCWSTR + PWNDCLASSW* = ptr WNDCLASSW + NPWNDCLASSW* = ptr WNDCLASSW + LPWNDCLASSW* = ptr WNDCLASSW + MSG* {.pure.} = object + hwnd*: HWND + message*: UINT + wParam*: WPARAM + lParam*: LPARAM + time*: DWORD + pt*: POINT + PMSG* = ptr MSG + NPMSG* = ptr MSG + LPMSG* = ptr MSG + MINMAXINFO* {.pure.} = object + ptReserved*: POINT + ptMaxSize*: POINT + ptMaxPosition*: POINT + ptMinTrackSize*: POINT + ptMaxTrackSize*: POINT + PMINMAXINFO* = ptr MINMAXINFO + LPMINMAXINFO* = ptr MINMAXINFO + COPYDATASTRUCT* {.pure.} = object + dwData*: ULONG_PTR + cbData*: DWORD + lpData*: PVOID + PCOPYDATASTRUCT* = ptr COPYDATASTRUCT + MDINEXTMENU* {.pure.} = object + hmenuIn*: HMENU + hmenuNext*: HMENU + hwndNext*: HWND + PMDINEXTMENU* = ptr MDINEXTMENU + LPMDINEXTMENU* = ptr MDINEXTMENU + POWERBROADCAST_SETTING* {.pure.} = object + PowerSetting*: GUID + DataLength*: DWORD + Data*: array[1, UCHAR] + PPOWERBROADCAST_SETTING* = ptr POWERBROADCAST_SETTING + WINDOWPOS* {.pure.} = object + hwnd*: HWND + hwndInsertAfter*: HWND + x*: int32 + y*: int32 + cx*: int32 + cy*: int32 + flags*: UINT + LPWINDOWPOS* = ptr WINDOWPOS + PWINDOWPOS* = ptr WINDOWPOS + NCCALCSIZE_PARAMS* {.pure.} = object + rgrc*: array[3, RECT] + lppos*: PWINDOWPOS + LPNCCALCSIZE_PARAMS* = ptr NCCALCSIZE_PARAMS + TTRACKMOUSEEVENT* {.pure.} = object + cbSize*: DWORD + dwFlags*: DWORD + hwndTrack*: HWND + dwHoverTime*: DWORD + LPTRACKMOUSEEVENT* = ptr TTRACKMOUSEEVENT + ACCEL* {.pure.} = object + fVirt*: BYTE + key*: WORD + cmd*: WORD + LPACCEL* = ptr ACCEL + PAINTSTRUCT* {.pure.} = object + hdc*: HDC + fErase*: WINBOOL + rcPaint*: RECT + fRestore*: WINBOOL + fIncUpdate*: WINBOOL + rgbReserved*: array[32, BYTE] + PPAINTSTRUCT* = ptr PAINTSTRUCT + NPPAINTSTRUCT* = ptr PAINTSTRUCT + LPPAINTSTRUCT* = ptr PAINTSTRUCT + LPCREATESTRUCTA* = ptr CREATESTRUCTA + LPCREATESTRUCTW* = ptr CREATESTRUCTW + WINDOWPLACEMENT* {.pure.} = object + length*: UINT + flags*: UINT + showCmd*: UINT + ptMinPosition*: POINT + ptMaxPosition*: POINT + rcNormalPosition*: RECT + PWINDOWPLACEMENT* = ptr WINDOWPLACEMENT + LPWINDOWPLACEMENT* = ptr WINDOWPLACEMENT + NMHDR* {.pure.} = object + hwndFrom*: HWND + idFrom*: UINT_PTR + code*: UINT + LPNMHDR* = ptr NMHDR + STYLESTRUCT* {.pure.} = object + styleOld*: DWORD + styleNew*: DWORD + LPSTYLESTRUCT* = ptr STYLESTRUCT + MEASUREITEMSTRUCT* {.pure.} = object + CtlType*: UINT + CtlID*: UINT + itemID*: UINT + itemWidth*: UINT + itemHeight*: UINT + itemData*: ULONG_PTR + PMEASUREITEMSTRUCT* = ptr MEASUREITEMSTRUCT + LPMEASUREITEMSTRUCT* = ptr MEASUREITEMSTRUCT + DRAWITEMSTRUCT* {.pure.} = object + CtlType*: UINT + CtlID*: UINT + itemID*: UINT + itemAction*: UINT + itemState*: UINT + hwndItem*: HWND + hDC*: HDC + rcItem*: RECT + itemData*: ULONG_PTR + PDRAWITEMSTRUCT* = ptr DRAWITEMSTRUCT + LPDRAWITEMSTRUCT* = ptr DRAWITEMSTRUCT + DELETEITEMSTRUCT* {.pure.} = object + CtlType*: UINT + CtlID*: UINT + itemID*: UINT + hwndItem*: HWND + itemData*: ULONG_PTR + PDELETEITEMSTRUCT* = ptr DELETEITEMSTRUCT + LPDELETEITEMSTRUCT* = ptr DELETEITEMSTRUCT + COMPAREITEMSTRUCT* {.pure.} = object + CtlType*: UINT + CtlID*: UINT + hwndItem*: HWND + itemID1*: UINT + itemData1*: ULONG_PTR + itemID2*: UINT + itemData2*: ULONG_PTR + dwLocaleId*: DWORD + PCOMPAREITEMSTRUCT* = ptr COMPAREITEMSTRUCT + LPCOMPAREITEMSTRUCT* = ptr COMPAREITEMSTRUCT + BSMINFO* {.pure.} = object + cbSize*: UINT + hdesk*: HDESK + hwnd*: HWND + luid*: LUID + PBSMINFO* = ptr BSMINFO + PHDEVNOTIFY* = ptr HDEVNOTIFY + PHPOWERNOTIFY* = ptr HPOWERNOTIFY + UPDATELAYEREDWINDOWINFO* {.pure.} = object + cbSize*: DWORD + hdcDst*: HDC + pptDst*: ptr POINT + psize*: ptr SIZE + hdcSrc*: HDC + pptSrc*: ptr POINT + crKey*: COLORREF + pblend*: ptr BLENDFUNCTION + dwFlags*: DWORD + prcDirty*: ptr RECT + PUPDATELAYEREDWINDOWINFO* = ptr UPDATELAYEREDWINDOWINFO + FLASHWINFO* {.pure.} = object + cbSize*: UINT + hwnd*: HWND + dwFlags*: DWORD + uCount*: UINT + dwTimeout*: DWORD + PFLASHWINFO* = ptr FLASHWINFO + DLGTEMPLATE* {.pure, packed.} = object + style*: DWORD + dwExtendedStyle*: DWORD + cdit*: WORD + x*: int16 + y*: int16 + cx*: int16 + cy*: int16 + LPDLGTEMPLATEA* = ptr DLGTEMPLATE + LPDLGTEMPLATEW* = ptr DLGTEMPLATE + LPCDLGTEMPLATEA* = ptr DLGTEMPLATE + LPCDLGTEMPLATEW* = ptr DLGTEMPLATE + DLGITEMTEMPLATE* {.pure, packed.} = object + style*: DWORD + dwExtendedStyle*: DWORD + x*: int16 + y*: int16 + cx*: int16 + cy*: int16 + id*: WORD + PDLGITEMTEMPLATEA* = ptr DLGITEMTEMPLATE + PDLGITEMTEMPLATEW* = ptr DLGITEMTEMPLATE + LPDLGITEMTEMPLATEA* = ptr DLGITEMTEMPLATE + LPDLGITEMTEMPLATEW* = ptr DLGITEMTEMPLATE + MOUSEINPUT* {.pure.} = object + dx*: LONG + dy*: LONG + mouseData*: DWORD + dwFlags*: DWORD + time*: DWORD + dwExtraInfo*: ULONG_PTR + PMOUSEINPUT* = ptr MOUSEINPUT + LPMOUSEINPUT* = ptr MOUSEINPUT + KEYBDINPUT* {.pure.} = object + wVk*: WORD + wScan*: WORD + dwFlags*: DWORD + time*: DWORD + dwExtraInfo*: ULONG_PTR + PKEYBDINPUT* = ptr KEYBDINPUT + LPKEYBDINPUT* = ptr KEYBDINPUT + HARDWAREINPUT* {.pure.} = object + uMsg*: DWORD + wParamL*: WORD + wParamH*: WORD + PHARDWAREINPUT* = ptr HARDWAREINPUT + LPHARDWAREINPUT* = ptr HARDWAREINPUT + INPUT_UNION1* {.pure, union.} = object + mi*: MOUSEINPUT + ki*: KEYBDINPUT + hi*: HARDWAREINPUT + INPUT* {.pure.} = object + `type`*: DWORD + union1*: INPUT_UNION1 + PINPUT* = ptr INPUT + LPINPUT* = ptr INPUT + TOUCHINPUT* {.pure.} = object + x*: LONG + y*: LONG + hSource*: HANDLE + dwID*: DWORD + dwFlags*: DWORD + dwMask*: DWORD + dwTime*: DWORD + dwExtraInfo*: ULONG_PTR + cxContact*: DWORD + cyContact*: DWORD + PTOUCHINPUT* = ptr TOUCHINPUT + PCTOUCHINPUT* = ptr TOUCHINPUT + POINTER_FLAGS* = UINT32 + TOUCH_FLAGS* = UINT32 + TOUCH_MASK* = UINT32 + PEN_FLAGS* = UINT32 + PEN_MASK* = UINT32 + TOUCH_HIT_TESTING_PROXIMITY_EVALUATION* {.pure.} = object + score*: UINT16 + adjustedPoint*: POINT + PTOUCH_HIT_TESTING_PROXIMITY_EVALUATION* = ptr TOUCH_HIT_TESTING_PROXIMITY_EVALUATION + TOUCH_HIT_TESTING_INPUT* {.pure.} = object + pointerId*: UINT32 + point*: POINT + boundingBox*: RECT + nonOccludedBoundingBox*: RECT + orientation*: UINT32 + PTOUCH_HIT_TESTING_INPUT* = ptr TOUCH_HIT_TESTING_INPUT + LASTINPUTINFO* {.pure.} = object + cbSize*: UINT + dwTime*: DWORD + PLASTINPUTINFO* = ptr LASTINPUTINFO + MENUINFO* {.pure.} = object + cbSize*: DWORD + fMask*: DWORD + dwStyle*: DWORD + cyMax*: UINT + hbrBack*: HBRUSH + dwContextHelpID*: DWORD + dwMenuData*: ULONG_PTR + LPMENUINFO* = ptr MENUINFO + TPMPARAMS* {.pure.} = object + cbSize*: UINT + rcExclude*: RECT + LPTPMPARAMS* = ptr TPMPARAMS + LPCMENUINFO* = ptr MENUINFO + MENUGETOBJECTINFO* {.pure.} = object + dwFlags*: DWORD + uPos*: UINT + hmenu*: HMENU + riid*: PVOID + pvObj*: PVOID + PMENUGETOBJECTINFO* = ptr MENUGETOBJECTINFO + MENUITEMINFOA* {.pure.} = object + cbSize*: UINT + fMask*: UINT + fType*: UINT + fState*: UINT + wID*: UINT + hSubMenu*: HMENU + hbmpChecked*: HBITMAP + hbmpUnchecked*: HBITMAP + dwItemData*: ULONG_PTR + dwTypeData*: LPSTR + cch*: UINT + hbmpItem*: HBITMAP + LPMENUITEMINFOA* = ptr MENUITEMINFOA + MENUITEMINFOW* {.pure.} = object + cbSize*: UINT + fMask*: UINT + fType*: UINT + fState*: UINT + wID*: UINT + hSubMenu*: HMENU + hbmpChecked*: HBITMAP + hbmpUnchecked*: HBITMAP + dwItemData*: ULONG_PTR + dwTypeData*: LPWSTR + cch*: UINT + hbmpItem*: HBITMAP + LPMENUITEMINFOW* = ptr MENUITEMINFOW + LPCMENUITEMINFOA* = ptr MENUITEMINFOA + LPCMENUITEMINFOW* = ptr MENUITEMINFOW + DROPSTRUCT* {.pure.} = object + hwndSource*: HWND + hwndSink*: HWND + wFmt*: DWORD + dwData*: ULONG_PTR + ptDrop*: POINT + dwControlData*: DWORD + PDROPSTRUCT* = ptr DROPSTRUCT + LPDROPSTRUCT* = ptr DROPSTRUCT + DRAWTEXTPARAMS* {.pure.} = object + cbSize*: UINT + iTabLength*: int32 + iLeftMargin*: int32 + iRightMargin*: int32 + uiLengthDrawn*: UINT + LPDRAWTEXTPARAMS* = ptr DRAWTEXTPARAMS + HELPINFO* {.pure.} = object + cbSize*: UINT + iContextType*: int32 + iCtrlId*: int32 + hItemHandle*: HANDLE + dwContextId*: DWORD_PTR + MousePos*: POINT + LPHELPINFO* = ptr HELPINFO + MSGBOXCALLBACK* = proc (lpHelpInfo: LPHELPINFO): VOID {.stdcall.} + MSGBOXPARAMSA* {.pure.} = object + cbSize*: UINT + hwndOwner*: HWND + hInstance*: HINSTANCE + lpszText*: LPCSTR + lpszCaption*: LPCSTR + dwStyle*: DWORD + lpszIcon*: LPCSTR + dwContextHelpId*: DWORD_PTR + lpfnMsgBoxCallback*: MSGBOXCALLBACK + dwLanguageId*: DWORD + PMSGBOXPARAMSA* = ptr MSGBOXPARAMSA + LPMSGBOXPARAMSA* = ptr MSGBOXPARAMSA + MSGBOXPARAMSW* {.pure.} = object + cbSize*: UINT + hwndOwner*: HWND + hInstance*: HINSTANCE + lpszText*: LPCWSTR + lpszCaption*: LPCWSTR + dwStyle*: DWORD + lpszIcon*: LPCWSTR + dwContextHelpId*: DWORD_PTR + lpfnMsgBoxCallback*: MSGBOXCALLBACK + dwLanguageId*: DWORD + PMSGBOXPARAMSW* = ptr MSGBOXPARAMSW + LPMSGBOXPARAMSW* = ptr MSGBOXPARAMSW + MENUITEMTEMPLATEHEADER* {.pure.} = object + versionNumber*: WORD + offset*: WORD + PMENUITEMTEMPLATEHEADER* = ptr MENUITEMTEMPLATEHEADER + MENUITEMTEMPLATE* {.pure.} = object + mtOption*: WORD + mtID*: WORD + mtString*: array[1, WCHAR] + PMENUITEMTEMPLATE* = ptr MENUITEMTEMPLATE + ICONINFO* {.pure.} = object + fIcon*: WINBOOL + xHotspot*: DWORD + yHotspot*: DWORD + hbmMask*: HBITMAP + hbmColor*: HBITMAP + PICONINFO* = ptr ICONINFO + CURSORSHAPE* {.pure.} = object + xHotSpot*: int32 + yHotSpot*: int32 + cx*: int32 + cy*: int32 + cbWidth*: int32 + Planes*: BYTE + BitsPixel*: BYTE + LPCURSORSHAPE* = ptr CURSORSHAPE + ICONINFOEXA* {.pure.} = object + cbSize*: DWORD + fIcon*: WINBOOL + xHotspot*: DWORD + yHotspot*: DWORD + hbmMask*: HBITMAP + hbmColor*: HBITMAP + wResID*: WORD + szModName*: array[MAX_PATH, CHAR] + szResName*: array[MAX_PATH, CHAR] + PICONINFOEXA* = ptr ICONINFOEXA + ICONINFOEXW* {.pure.} = object + cbSize*: DWORD + fIcon*: WINBOOL + xHotspot*: DWORD + yHotspot*: DWORD + hbmMask*: HBITMAP + hbmColor*: HBITMAP + wResID*: WORD + szModName*: array[MAX_PATH, WCHAR] + szResName*: array[MAX_PATH, WCHAR] + PICONINFOEXW* = ptr ICONINFOEXW + SCROLLINFO* {.pure.} = object + cbSize*: UINT + fMask*: UINT + nMin*: int32 + nMax*: int32 + nPage*: UINT + nPos*: int32 + nTrackPos*: int32 + LPSCROLLINFO* = ptr SCROLLINFO + LPCSCROLLINFO* = ptr SCROLLINFO + MDICREATESTRUCTA* {.pure.} = object + szClass*: LPCSTR + szTitle*: LPCSTR + hOwner*: HANDLE + x*: int32 + y*: int32 + cx*: int32 + cy*: int32 + style*: DWORD + lParam*: LPARAM + LPMDICREATESTRUCTA* = ptr MDICREATESTRUCTA + MDICREATESTRUCTW* {.pure.} = object + szClass*: LPCWSTR + szTitle*: LPCWSTR + hOwner*: HANDLE + x*: int32 + y*: int32 + cx*: int32 + cy*: int32 + style*: DWORD + lParam*: LPARAM + LPMDICREATESTRUCTW* = ptr MDICREATESTRUCTW + CLIENTCREATESTRUCT* {.pure.} = object + hWindowMenu*: HANDLE + idFirstChild*: UINT + LPCLIENTCREATESTRUCT* = ptr CLIENTCREATESTRUCT + MULTIKEYHELPA* {.pure.} = object + mkSize*: DWORD + mkKeylist*: CHAR + szKeyphrase*: array[1, CHAR] + PMULTIKEYHELPA* = ptr MULTIKEYHELPA + LPMULTIKEYHELPA* = ptr MULTIKEYHELPA + MULTIKEYHELPW* {.pure.} = object + mkSize*: DWORD + mkKeylist*: WCHAR + szKeyphrase*: array[1, WCHAR] + PMULTIKEYHELPW* = ptr MULTIKEYHELPW + LPMULTIKEYHELPW* = ptr MULTIKEYHELPW + HELPWININFOA* {.pure.} = object + wStructSize*: int32 + x*: int32 + y*: int32 + dx*: int32 + dy*: int32 + wMax*: int32 + rgchMember*: array[2, CHAR] + PHELPWININFOA* = ptr HELPWININFOA + LPHELPWININFOA* = ptr HELPWININFOA + HELPWININFOW* {.pure.} = object + wStructSize*: int32 + x*: int32 + y*: int32 + dx*: int32 + dy*: int32 + wMax*: int32 + rgchMember*: array[2, WCHAR] + PHELPWININFOW* = ptr HELPWININFOW + LPHELPWININFOW* = ptr HELPWININFOW + TOUCHPREDICTIONPARAMETERS* {.pure.} = object + cbSize*: UINT + dwLatency*: UINT + dwSampleTime*: UINT + bUseHWTimeStamp*: UINT + PTOUCHPREDICTIONPARAMETERS* = ptr TOUCHPREDICTIONPARAMETERS + NONCLIENTMETRICSA* {.pure.} = object + cbSize*: UINT + iBorderWidth*: int32 + iScrollWidth*: int32 + iScrollHeight*: int32 + iCaptionWidth*: int32 + iCaptionHeight*: int32 + lfCaptionFont*: LOGFONTA + iSmCaptionWidth*: int32 + iSmCaptionHeight*: int32 + lfSmCaptionFont*: LOGFONTA + iMenuWidth*: int32 + iMenuHeight*: int32 + lfMenuFont*: LOGFONTA + lfStatusFont*: LOGFONTA + lfMessageFont*: LOGFONTA + iPaddedBorderWidth*: int32 + PNONCLIENTMETRICSA* = ptr NONCLIENTMETRICSA + LPNONCLIENTMETRICSA* = ptr NONCLIENTMETRICSA + NONCLIENTMETRICSW* {.pure.} = object + cbSize*: UINT + iBorderWidth*: int32 + iScrollWidth*: int32 + iScrollHeight*: int32 + iCaptionWidth*: int32 + iCaptionHeight*: int32 + lfCaptionFont*: LOGFONTW + iSmCaptionWidth*: int32 + iSmCaptionHeight*: int32 + lfSmCaptionFont*: LOGFONTW + iMenuWidth*: int32 + iMenuHeight*: int32 + lfMenuFont*: LOGFONTW + lfStatusFont*: LOGFONTW + lfMessageFont*: LOGFONTW + iPaddedBorderWidth*: int32 + PNONCLIENTMETRICSW* = ptr NONCLIENTMETRICSW + LPNONCLIENTMETRICSW* = ptr NONCLIENTMETRICSW + MINIMIZEDMETRICS* {.pure.} = object + cbSize*: UINT + iWidth*: int32 + iHorzGap*: int32 + iVertGap*: int32 + iArrange*: int32 + PMINIMIZEDMETRICS* = ptr MINIMIZEDMETRICS + LPMINIMIZEDMETRICS* = ptr MINIMIZEDMETRICS + ICONMETRICSA* {.pure.} = object + cbSize*: UINT + iHorzSpacing*: int32 + iVertSpacing*: int32 + iTitleWrap*: int32 + lfFont*: LOGFONTA + PICONMETRICSA* = ptr ICONMETRICSA + LPICONMETRICSA* = ptr ICONMETRICSA + ICONMETRICSW* {.pure.} = object + cbSize*: UINT + iHorzSpacing*: int32 + iVertSpacing*: int32 + iTitleWrap*: int32 + lfFont*: LOGFONTW + PICONMETRICSW* = ptr ICONMETRICSW + LPICONMETRICSW* = ptr ICONMETRICSW + ANIMATIONINFO* {.pure.} = object + cbSize*: UINT + iMinAnimate*: int32 + LPANIMATIONINFO* = ptr ANIMATIONINFO + SERIALKEYSA* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + lpszActivePort*: LPSTR + lpszPort*: LPSTR + iBaudRate*: UINT + iPortState*: UINT + iActive*: UINT + LPSERIALKEYSA* = ptr SERIALKEYSA + SERIALKEYSW* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + lpszActivePort*: LPWSTR + lpszPort*: LPWSTR + iBaudRate*: UINT + iPortState*: UINT + iActive*: UINT + LPSERIALKEYSW* = ptr SERIALKEYSW + HIGHCONTRASTA* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + lpszDefaultScheme*: LPSTR + LPHIGHCONTRASTA* = ptr HIGHCONTRASTA + HIGHCONTRASTW* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + lpszDefaultScheme*: LPWSTR + LPHIGHCONTRASTW* = ptr HIGHCONTRASTW + VIDEOPARAMETERS* {.pure.} = object + Guid*: GUID + dwOffset*: ULONG + dwCommand*: ULONG + dwFlags*: ULONG + dwMode*: ULONG + dwTVStandard*: ULONG + dwAvailableModes*: ULONG + dwAvailableTVStandard*: ULONG + dwFlickerFilter*: ULONG + dwOverScanX*: ULONG + dwOverScanY*: ULONG + dwMaxUnscaledX*: ULONG + dwMaxUnscaledY*: ULONG + dwPositionX*: ULONG + dwPositionY*: ULONG + dwBrightness*: ULONG + dwContrast*: ULONG + dwCPType*: ULONG + dwCPCommand*: ULONG + dwCPStandard*: ULONG + dwCPKey*: ULONG + bCP_APSTriggerBits*: ULONG + bOEMCopyProtection*: array[256, UCHAR] + PVIDEOPARAMETERS* = ptr VIDEOPARAMETERS + LPVIDEOPARAMETERS* = ptr VIDEOPARAMETERS + FILTERKEYS* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iWaitMSec*: DWORD + iDelayMSec*: DWORD + iRepeatMSec*: DWORD + iBounceMSec*: DWORD + LPFILTERKEYS* = ptr FILTERKEYS + STICKYKEYS* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + LPSTICKYKEYS* = ptr STICKYKEYS + MOUSEKEYS* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iMaxSpeed*: DWORD + iTimeToMaxSpeed*: DWORD + iCtrlSpeed*: DWORD + dwReserved1*: DWORD + dwReserved2*: DWORD + LPMOUSEKEYS* = ptr MOUSEKEYS + ACCESSTIMEOUT* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iTimeOutMSec*: DWORD + LPACCESSTIMEOUT* = ptr ACCESSTIMEOUT + SOUNDSENTRYA* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iFSTextEffect*: DWORD + iFSTextEffectMSec*: DWORD + iFSTextEffectColorBits*: DWORD + iFSGrafEffect*: DWORD + iFSGrafEffectMSec*: DWORD + iFSGrafEffectColor*: DWORD + iWindowsEffect*: DWORD + iWindowsEffectMSec*: DWORD + lpszWindowsEffectDLL*: LPSTR + iWindowsEffectOrdinal*: DWORD + LPSOUNDSENTRYA* = ptr SOUNDSENTRYA + SOUNDSENTRYW* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + iFSTextEffect*: DWORD + iFSTextEffectMSec*: DWORD + iFSTextEffectColorBits*: DWORD + iFSGrafEffect*: DWORD + iFSGrafEffectMSec*: DWORD + iFSGrafEffectColor*: DWORD + iWindowsEffect*: DWORD + iWindowsEffectMSec*: DWORD + lpszWindowsEffectDLL*: LPWSTR + iWindowsEffectOrdinal*: DWORD + LPSOUNDSENTRYW* = ptr SOUNDSENTRYW + TOGGLEKEYS* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + LPTOGGLEKEYS* = ptr TOGGLEKEYS + MONITORINFO* {.pure.} = object + cbSize*: DWORD + rcMonitor*: RECT + rcWork*: RECT + dwFlags*: DWORD + LPMONITORINFO* = ptr MONITORINFO + AUDIODESCRIPTION* {.pure.} = object + cbSize*: UINT + Enabled*: WINBOOL + Locale*: LCID + LPAUDIODESCRIPTION* = ptr AUDIODESCRIPTION + MONITORINFOEXA_STRUCT1* {.pure.} = object + cbSize*: DWORD + rcMonitor*: RECT + rcWork*: RECT + dwFlags*: DWORD + MONITORINFOEXA* {.pure.} = object + struct1*: MONITORINFOEXA_STRUCT1 + szDevice*: array[CCHDEVICENAME, CHAR] + LPMONITORINFOEXA* = ptr MONITORINFOEXA + MONITORINFOEXW_STRUCT1* {.pure.} = object + cbSize*: DWORD + rcMonitor*: RECT + rcWork*: RECT + dwFlags*: DWORD + MONITORINFOEXW* {.pure.} = object + struct1*: MONITORINFOEXW_STRUCT1 + szDevice*: array[CCHDEVICENAME, WCHAR] + LPMONITORINFOEXW* = ptr MONITORINFOEXW + GUITHREADINFO* {.pure.} = object + cbSize*: DWORD + flags*: DWORD + hwndActive*: HWND + hwndFocus*: HWND + hwndCapture*: HWND + hwndMenuOwner*: HWND + hwndMoveSize*: HWND + hwndCaret*: HWND + rcCaret*: RECT + PGUITHREADINFO* = ptr GUITHREADINFO + LPGUITHREADINFO* = ptr GUITHREADINFO + CURSORINFO* {.pure.} = object + cbSize*: DWORD + flags*: DWORD + hCursor*: HCURSOR + ptScreenPos*: POINT + PCURSORINFO* = ptr CURSORINFO + LPCURSORINFO* = ptr CURSORINFO + WINDOWINFO* {.pure.} = object + cbSize*: DWORD + rcWindow*: RECT + rcClient*: RECT + dwStyle*: DWORD + dwExStyle*: DWORD + dwWindowStatus*: DWORD + cxWindowBorders*: UINT + cyWindowBorders*: UINT + atomWindowType*: ATOM + wCreatorVersion*: WORD + PWINDOWINFO* = ptr WINDOWINFO + LPWINDOWINFO* = ptr WINDOWINFO +const + CCHILDREN_TITLEBAR* = 5 +type + TITLEBARINFO* {.pure.} = object + cbSize*: DWORD + rcTitleBar*: RECT + rgstate*: array[CCHILDREN_TITLEBAR + 1, DWORD] + PTITLEBARINFO* = ptr TITLEBARINFO + LPTITLEBARINFO* = ptr TITLEBARINFO + TITLEBARINFOEX* {.pure.} = object + cbSize*: DWORD + rcTitleBar*: RECT + rgstate*: array[CCHILDREN_TITLEBAR + 1, DWORD] + rgrect*: array[CCHILDREN_TITLEBAR + 1, RECT] + PTITLEBARINFOEX* = ptr TITLEBARINFOEX + LPTITLEBARINFOEX* = ptr TITLEBARINFOEX + MENUBARINFO* {.pure.} = object + cbSize*: DWORD + rcBar*: RECT + hMenu*: HMENU + hwndMenu*: HWND + fBarFocused* {.bitsize:1.}: WINBOOL + fFocused* {.bitsize:1.}: WINBOOL + PMENUBARINFO* = ptr MENUBARINFO + LPMENUBARINFO* = ptr MENUBARINFO +const + CCHILDREN_SCROLLBAR* = 5 +type + SCROLLBARINFO* {.pure.} = object + cbSize*: DWORD + rcScrollBar*: RECT + dxyLineButton*: int32 + xyThumbTop*: int32 + xyThumbBottom*: int32 + reserved*: int32 + rgstate*: array[CCHILDREN_SCROLLBAR + 1, DWORD] + PSCROLLBARINFO* = ptr SCROLLBARINFO + LPSCROLLBARINFO* = ptr SCROLLBARINFO + COMBOBOXINFO* {.pure.} = object + cbSize*: DWORD + rcItem*: RECT + rcButton*: RECT + stateButton*: DWORD + hwndCombo*: HWND + hwndItem*: HWND + hwndList*: HWND + PCOMBOBOXINFO* = ptr COMBOBOXINFO + LPCOMBOBOXINFO* = ptr COMBOBOXINFO + ALTTABINFO* {.pure.} = object + cbSize*: DWORD + cItems*: int32 + cColumns*: int32 + cRows*: int32 + iColFocus*: int32 + iRowFocus*: int32 + cxItem*: int32 + cyItem*: int32 + ptStart*: POINT + PALTTABINFO* = ptr ALTTABINFO + LPALTTABINFO* = ptr ALTTABINFO + RAWINPUTHEADER* {.pure.} = object + dwType*: DWORD + dwSize*: DWORD + hDevice*: HANDLE + wParam*: WPARAM + PRAWINPUTHEADER* = ptr RAWINPUTHEADER + LPRAWINPUTHEADER* = ptr RAWINPUTHEADER + RAWMOUSE_UNION1_STRUCT1* {.pure.} = object + usButtonFlags*: USHORT + usButtonData*: USHORT + RAWMOUSE_UNION1* {.pure, union.} = object + ulButtons*: ULONG + struct1*: RAWMOUSE_UNION1_STRUCT1 + RAWMOUSE* {.pure.} = object + usFlags*: USHORT + union1*: RAWMOUSE_UNION1 + ulRawButtons*: ULONG + lLastX*: LONG + lLastY*: LONG + ulExtraInformation*: ULONG + PRAWMOUSE* = ptr RAWMOUSE + LPRAWMOUSE* = ptr RAWMOUSE + RAWKEYBOARD* {.pure.} = object + MakeCode*: USHORT + Flags*: USHORT + Reserved*: USHORT + VKey*: USHORT + Message*: UINT + ExtraInformation*: ULONG + PRAWKEYBOARD* = ptr RAWKEYBOARD + LPRAWKEYBOARD* = ptr RAWKEYBOARD + RAWHID* {.pure.} = object + dwSizeHid*: DWORD + dwCount*: DWORD + bRawData*: array[1, BYTE] + PRAWHID* = ptr RAWHID + LPRAWHID* = ptr RAWHID + RAWINPUT_data* {.pure, union.} = object + mouse*: RAWMOUSE + keyboard*: RAWKEYBOARD + hid*: RAWHID + RAWINPUT* {.pure.} = object + header*: RAWINPUTHEADER + data*: RAWINPUT_data + PRAWINPUT* = ptr RAWINPUT + LPRAWINPUT* = ptr RAWINPUT + RID_DEVICE_INFO_MOUSE* {.pure.} = object + dwId*: DWORD + dwNumberOfButtons*: DWORD + dwSampleRate*: DWORD + fHasHorizontalWheel*: WINBOOL + PRID_DEVICE_INFO_MOUSE* = ptr RID_DEVICE_INFO_MOUSE + RID_DEVICE_INFO_KEYBOARD* {.pure.} = object + dwType*: DWORD + dwSubType*: DWORD + dwKeyboardMode*: DWORD + dwNumberOfFunctionKeys*: DWORD + dwNumberOfIndicators*: DWORD + dwNumberOfKeysTotal*: DWORD + PRID_DEVICE_INFO_KEYBOARD* = ptr RID_DEVICE_INFO_KEYBOARD + RID_DEVICE_INFO_HID* {.pure.} = object + dwVendorId*: DWORD + dwProductId*: DWORD + dwVersionNumber*: DWORD + usUsagePage*: USHORT + usUsage*: USHORT + PRID_DEVICE_INFO_HID* = ptr RID_DEVICE_INFO_HID + RID_DEVICE_INFO_UNION1* {.pure, union.} = object + mouse*: RID_DEVICE_INFO_MOUSE + keyboard*: RID_DEVICE_INFO_KEYBOARD + hid*: RID_DEVICE_INFO_HID + RID_DEVICE_INFO* {.pure.} = object + cbSize*: DWORD + dwType*: DWORD + union1*: RID_DEVICE_INFO_UNION1 + PRID_DEVICE_INFO* = ptr RID_DEVICE_INFO + LPRID_DEVICE_INFO* = ptr RID_DEVICE_INFO + RAWINPUTDEVICE* {.pure.} = object + usUsagePage*: USHORT + usUsage*: USHORT + dwFlags*: DWORD + hwndTarget*: HWND + PRAWINPUTDEVICE* = ptr RAWINPUTDEVICE + LPRAWINPUTDEVICE* = ptr RAWINPUTDEVICE + PCRAWINPUTDEVICE* = ptr RAWINPUTDEVICE + RAWINPUTDEVICELIST* {.pure.} = object + hDevice*: HANDLE + dwType*: DWORD + PRAWINPUTDEVICELIST* = ptr RAWINPUTDEVICELIST + CHANGEFILTERSTRUCT* {.pure.} = object + cbSize*: DWORD + ExtStatus*: DWORD + PCHANGEFILTERSTRUCT* = ptr CHANGEFILTERSTRUCT + GESTUREINFO* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + dwID*: DWORD + hwndTarget*: HWND + ptsLocation*: POINTS + dwInstanceID*: DWORD + dwSequenceID*: DWORD + ullArguments*: ULONGLONG + cbExtraArgs*: UINT + PGESTUREINFO* = ptr GESTUREINFO + PCGESTUREINFO* = ptr GESTUREINFO + GESTURENOTIFYSTRUCT* {.pure.} = object + cbSize*: UINT + dwFlags*: DWORD + hwndTarget*: HWND + ptsLocation*: POINTS + dwInstanceID*: DWORD + PGESTURENOTIFYSTRUCT* = ptr GESTURENOTIFYSTRUCT + GESTURECONFIG* {.pure.} = object + dwID*: DWORD + dwWant*: DWORD + dwBlock*: DWORD + PGESTURECONFIG* = ptr GESTURECONFIG +template MAKEINTRESOURCE*(i: untyped): untyped = cast[LPTSTR](i and 0xffff) +const + RT_CURSOR* = MAKEINTRESOURCE(1) + RT_BITMAP* = MAKEINTRESOURCE(2) + RT_ICON* = MAKEINTRESOURCE(3) + RT_MENU* = MAKEINTRESOURCE(4) + RT_DIALOG* = MAKEINTRESOURCE(5) + RT_STRING* = MAKEINTRESOURCE(6) + RT_FONTDIR* = MAKEINTRESOURCE(7) + RT_FONT* = MAKEINTRESOURCE(8) + RT_ACCELERATOR* = MAKEINTRESOURCE(9) + RT_RCDATA* = MAKEINTRESOURCE(10) + RT_MESSAGETABLE* = MAKEINTRESOURCE(11) + DIFFERENCE* = 11 + RT_VERSION* = MAKEINTRESOURCE(16) + RT_DLGINCLUDE* = MAKEINTRESOURCE(17) + RT_PLUGPLAY* = MAKEINTRESOURCE(19) + RT_VXD* = MAKEINTRESOURCE(20) + RT_ANICURSOR* = MAKEINTRESOURCE(21) + RT_ANIICON* = MAKEINTRESOURCE(22) + RT_HTML* = MAKEINTRESOURCE(23) + RT_MANIFEST* = MAKEINTRESOURCE(24) + CREATEPROCESS_MANIFEST_RESOURCE_ID* = MAKEINTRESOURCE(1) + ISOLATIONAWARE_MANIFEST_RESOURCE_ID* = MAKEINTRESOURCE(2) + ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID* = MAKEINTRESOURCE(3) + MINIMUM_RESERVED_MANIFEST_RESOURCE_ID* = MAKEINTRESOURCE(1) + MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID* = MAKEINTRESOURCE(16) + SB_HORZ* = 0 + SB_VERT* = 1 + SB_CTL* = 2 + SB_BOTH* = 3 + SB_LINEUP* = 0 + SB_LINELEFT* = 0 + SB_LINEDOWN* = 1 + SB_LINERIGHT* = 1 + SB_PAGEUP* = 2 + SB_PAGELEFT* = 2 + SB_PAGEDOWN* = 3 + SB_PAGERIGHT* = 3 + SB_THUMBPOSITION* = 4 + SB_THUMBTRACK* = 5 + SB_TOP* = 6 + SB_LEFT* = 6 + SB_BOTTOM* = 7 + SB_RIGHT* = 7 + SB_ENDSCROLL* = 8 + SW_HIDE* = 0 + SW_SHOWNORMAL* = 1 + SW_NORMAL* = 1 + SW_SHOWMINIMIZED* = 2 + SW_SHOWMAXIMIZED* = 3 + SW_MAXIMIZE* = 3 + SW_SHOWNOACTIVATE* = 4 + SW_SHOW* = 5 + SW_MINIMIZE* = 6 + SW_SHOWMINNOACTIVE* = 7 + SW_SHOWNA* = 8 + SW_RESTORE* = 9 + SW_SHOWDEFAULT* = 10 + SW_FORCEMINIMIZE* = 11 + SW_MAX* = 11 + HIDE_WINDOW* = 0 + SHOW_OPENWINDOW* = 1 + SHOW_ICONWINDOW* = 2 + SHOW_FULLSCREEN* = 3 + SHOW_OPENNOACTIVATE* = 4 + SW_PARENTCLOSING* = 1 + SW_OTHERZOOM* = 2 + SW_PARENTOPENING* = 3 + SW_OTHERUNZOOM* = 4 + AW_HOR_POSITIVE* = 0x00000001 + AW_HOR_NEGATIVE* = 0x00000002 + AW_VER_POSITIVE* = 0x00000004 + AW_VER_NEGATIVE* = 0x00000008 + AW_CENTER* = 0x00000010 + AW_HIDE* = 0x00010000 + AW_ACTIVATE* = 0x00020000 + AW_SLIDE* = 0x00040000 + AW_BLEND* = 0x00080000 + KF_EXTENDED* = 0x0100 + KF_DLGMODE* = 0x0800 + KF_MENUMODE* = 0x1000 + KF_ALTDOWN* = 0x2000 + KF_REPEAT* = 0x4000 + KF_UP* = 0x8000 + VK_LBUTTON* = 0x01 + VK_RBUTTON* = 0x02 + VK_CANCEL* = 0x03 + VK_MBUTTON* = 0x04 + VK_XBUTTON1* = 0x05 + VK_XBUTTON2* = 0x06 + VK_BACK* = 0x08 + VK_TAB* = 0x09 + VK_CLEAR* = 0x0C + VK_RETURN* = 0x0D + VK_SHIFT* = 0x10 + VK_CONTROL* = 0x11 + VK_MENU* = 0x12 + VK_PAUSE* = 0x13 + VK_CAPITAL* = 0x14 + VK_KANA* = 0x15 + VK_HANGEUL* = 0x15 + VK_HANGUL* = 0x15 + VK_JUNJA* = 0x17 + VK_FINAL* = 0x18 + VK_HANJA* = 0x19 + VK_KANJI* = 0x19 + VK_ESCAPE* = 0x1B + VK_CONVERT* = 0x1C + VK_NONCONVERT* = 0x1D + VK_ACCEPT* = 0x1E + VK_MODECHANGE* = 0x1F + VK_SPACE* = 0x20 + VK_PRIOR* = 0x21 + VK_NEXT* = 0x22 + VK_END* = 0x23 + VK_HOME* = 0x24 + VK_LEFT* = 0x25 + VK_UP* = 0x26 + VK_RIGHT* = 0x27 + VK_DOWN* = 0x28 + VK_SELECT* = 0x29 + VK_PRINT* = 0x2A + VK_EXECUTE* = 0x2B + VK_SNAPSHOT* = 0x2C + VK_INSERT* = 0x2D + VK_DELETE* = 0x2E + VK_HELP* = 0x2F + VK_LWIN* = 0x5B + VK_RWIN* = 0x5C + VK_APPS* = 0x5D + VK_SLEEP* = 0x5F + VK_NUMPAD0* = 0x60 + VK_NUMPAD1* = 0x61 + VK_NUMPAD2* = 0x62 + VK_NUMPAD3* = 0x63 + VK_NUMPAD4* = 0x64 + VK_NUMPAD5* = 0x65 + VK_NUMPAD6* = 0x66 + VK_NUMPAD7* = 0x67 + VK_NUMPAD8* = 0x68 + VK_NUMPAD9* = 0x69 + VK_MULTIPLY* = 0x6A + VK_ADD* = 0x6B + VK_SEPARATOR* = 0x6C + VK_SUBTRACT* = 0x6D + VK_DECIMAL* = 0x6E + VK_DIVIDE* = 0x6F + VK_F1* = 0x70 + VK_F2* = 0x71 + VK_F3* = 0x72 + VK_F4* = 0x73 + VK_F5* = 0x74 + VK_F6* = 0x75 + VK_F7* = 0x76 + VK_F8* = 0x77 + VK_F9* = 0x78 + VK_F10* = 0x79 + VK_F11* = 0x7A + VK_F12* = 0x7B + VK_F13* = 0x7C + VK_F14* = 0x7D + VK_F15* = 0x7E + VK_F16* = 0x7F + VK_F17* = 0x80 + VK_F18* = 0x81 + VK_F19* = 0x82 + VK_F20* = 0x83 + VK_F21* = 0x84 + VK_F22* = 0x85 + VK_F23* = 0x86 + VK_F24* = 0x87 + VK_NUMLOCK* = 0x90 + VK_SCROLL* = 0x91 + VK_OEM_NEC_EQUAL* = 0x92 + VK_OEM_FJ_JISHO* = 0x92 + VK_OEM_FJ_MASSHOU* = 0x93 + VK_OEM_FJ_TOUROKU* = 0x94 + VK_OEM_FJ_LOYA* = 0x95 + VK_OEM_FJ_ROYA* = 0x96 + VK_LSHIFT* = 0xA0 + VK_RSHIFT* = 0xA1 + VK_LCONTROL* = 0xA2 + VK_RCONTROL* = 0xA3 + VK_LMENU* = 0xA4 + VK_RMENU* = 0xA5 + VK_BROWSER_BACK* = 0xA6 + VK_BROWSER_FORWARD* = 0xA7 + VK_BROWSER_REFRESH* = 0xA8 + VK_BROWSER_STOP* = 0xA9 + VK_BROWSER_SEARCH* = 0xAA + VK_BROWSER_FAVORITES* = 0xAB + VK_BROWSER_HOME* = 0xAC + VK_VOLUME_MUTE* = 0xAD + VK_VOLUME_DOWN* = 0xAE + VK_VOLUME_UP* = 0xAF + VK_MEDIA_NEXT_TRACK* = 0xB0 + VK_MEDIA_PREV_TRACK* = 0xB1 + VK_MEDIA_STOP* = 0xB2 + VK_MEDIA_PLAY_PAUSE* = 0xB3 + VK_LAUNCH_MAIL* = 0xB4 + VK_LAUNCH_MEDIA_SELECT* = 0xB5 + VK_LAUNCH_APP1* = 0xB6 + VK_LAUNCH_APP2* = 0xB7 + VK_OEM_1* = 0xBA + VK_OEM_PLUS* = 0xBB + VK_OEM_COMMA* = 0xBC + VK_OEM_MINUS* = 0xBD + VK_OEM_PERIOD* = 0xBE + VK_OEM_2* = 0xBF + VK_OEM_3* = 0xC0 + VK_OEM_4* = 0xDB + VK_OEM_5* = 0xDC + VK_OEM_6* = 0xDD + VK_OEM_7* = 0xDE + VK_OEM_8* = 0xDF + VK_OEM_AX* = 0xE1 + VK_OEM_102* = 0xE2 + VK_ICO_HELP* = 0xE3 + VK_ICO_00* = 0xE4 + VK_PROCESSKEY* = 0xE5 + VK_ICO_CLEAR* = 0xE6 + VK_PACKET* = 0xE7 + VK_OEM_RESET* = 0xE9 + VK_OEM_JUMP* = 0xEA + VK_OEM_PA1* = 0xEB + VK_OEM_PA2* = 0xEC + VK_OEM_PA3* = 0xED + VK_OEM_WSCTRL* = 0xEE + VK_OEM_CUSEL* = 0xEF + VK_OEM_ATTN* = 0xF0 + VK_OEM_FINISH* = 0xF1 + VK_OEM_COPY* = 0xF2 + VK_OEM_AUTO* = 0xF3 + VK_OEM_ENLW* = 0xF4 + VK_OEM_BACKTAB* = 0xF5 + VK_ATTN* = 0xF6 + VK_CRSEL* = 0xF7 + VK_EXSEL* = 0xF8 + VK_EREOF* = 0xF9 + VK_PLAY* = 0xFA + VK_ZOOM* = 0xFB + VK_NONAME* = 0xFC + VK_PA1* = 0xFD + VK_OEM_CLEAR* = 0xFE + WH_MIN* = -1 + WH_MSGFILTER* = -1 + WH_JOURNALRECORD* = 0 + WH_JOURNALPLAYBACK* = 1 + WH_KEYBOARD* = 2 + WH_GETMESSAGE* = 3 + WH_CALLWNDPROC* = 4 + WH_CBT* = 5 + WH_SYSMSGFILTER* = 6 + WH_MOUSE* = 7 + WH_HARDWARE* = 8 + WH_DEBUG* = 9 + WH_SHELL* = 10 + WH_FOREGROUNDIDLE* = 11 + WH_CALLWNDPROCRET* = 12 + WH_KEYBOARD_LL* = 13 + WH_MOUSE_LL* = 14 + WH_MAX* = 14 + WH_MINHOOK* = WH_MIN + WH_MAXHOOK* = WH_MAX + HC_ACTION* = 0 + HC_GETNEXT* = 1 + HC_SKIP* = 2 + HC_NOREMOVE* = 3 + HC_NOREM* = HC_NOREMOVE + HC_SYSMODALON* = 4 + HC_SYSMODALOFF* = 5 + HCBT_MOVESIZE* = 0 + HCBT_MINMAX* = 1 + HCBT_QS* = 2 + HCBT_CREATEWND* = 3 + HCBT_DESTROYWND* = 4 + HCBT_ACTIVATE* = 5 + HCBT_CLICKSKIPPED* = 6 + HCBT_KEYSKIPPED* = 7 + HCBT_SYSCOMMAND* = 8 + HCBT_SETFOCUS* = 9 + WTS_CONSOLE_CONNECT* = 0x1 + WTS_CONSOLE_DISCONNECT* = 0x2 + WTS_REMOTE_CONNECT* = 0x3 + WTS_REMOTE_DISCONNECT* = 0x4 + WTS_SESSION_LOGON* = 0x5 + WTS_SESSION_LOGOFF* = 0x6 + WTS_SESSION_LOCK* = 0x7 + WTS_SESSION_UNLOCK* = 0x8 + WTS_SESSION_REMOTE_CONTROL* = 0x9 + WTS_SESSION_CREATE* = 0xa + WTS_SESSION_TERMINATE* = 0xb + MSGF_DIALOGBOX* = 0 + MSGF_MESSAGEBOX* = 1 + MSGF_MENU* = 2 + MSGF_SCROLLBAR* = 5 + MSGF_NEXTWINDOW* = 6 + MSGF_MAX* = 8 + MSGF_USER* = 4096 + HSHELL_WINDOWCREATED* = 1 + HSHELL_WINDOWDESTROYED* = 2 + HSHELL_ACTIVATESHELLWINDOW* = 3 + HSHELL_WINDOWACTIVATED* = 4 + HSHELL_GETMINRECT* = 5 + HSHELL_REDRAW* = 6 + HSHELL_TASKMAN* = 7 + HSHELL_LANGUAGE* = 8 + HSHELL_SYSMENU* = 9 + HSHELL_ENDTASK* = 10 + HSHELL_ACCESSIBILITYSTATE* = 11 + HSHELL_APPCOMMAND* = 12 + HSHELL_WINDOWREPLACED* = 13 + HSHELL_WINDOWREPLACING* = 14 + HSHELL_MONITORCHANGED* = 16 + HSHELL_HIGHBIT* = 0x8000 + HSHELL_FLASH* = HSHELL_REDRAW or HSHELL_HIGHBIT + HSHELL_RUDEAPPACTIVATED* = HSHELL_WINDOWACTIVATED or HSHELL_HIGHBIT + ACCESS_STICKYKEYS* = 0x0001 + ACCESS_FILTERKEYS* = 0x0002 + ACCESS_MOUSEKEYS* = 0x0003 + APPCOMMAND_BROWSER_BACKWARD* = 1 + APPCOMMAND_BROWSER_FORWARD* = 2 + APPCOMMAND_BROWSER_REFRESH* = 3 + APPCOMMAND_BROWSER_STOP* = 4 + APPCOMMAND_BROWSER_SEARCH* = 5 + APPCOMMAND_BROWSER_FAVORITES* = 6 + APPCOMMAND_BROWSER_HOME* = 7 + APPCOMMAND_VOLUME_MUTE* = 8 + APPCOMMAND_VOLUME_DOWN* = 9 + APPCOMMAND_VOLUME_UP* = 10 + APPCOMMAND_MEDIA_NEXTTRACK* = 11 + APPCOMMAND_MEDIA_PREVIOUSTRACK* = 12 + APPCOMMAND_MEDIA_STOP* = 13 + APPCOMMAND_MEDIA_PLAY_PAUSE* = 14 + APPCOMMAND_LAUNCH_MAIL* = 15 + APPCOMMAND_LAUNCH_MEDIA_SELECT* = 16 + APPCOMMAND_LAUNCH_APP1* = 17 + APPCOMMAND_LAUNCH_APP2* = 18 + APPCOMMAND_BASS_DOWN* = 19 + APPCOMMAND_BASS_BOOST* = 20 + APPCOMMAND_BASS_UP* = 21 + APPCOMMAND_TREBLE_DOWN* = 22 + APPCOMMAND_TREBLE_UP* = 23 + APPCOMMAND_MICROPHONE_VOLUME_MUTE* = 24 + APPCOMMAND_MICROPHONE_VOLUME_DOWN* = 25 + APPCOMMAND_MICROPHONE_VOLUME_UP* = 26 + APPCOMMAND_HELP* = 27 + APPCOMMAND_FIND* = 28 + APPCOMMAND_NEW* = 29 + APPCOMMAND_OPEN* = 30 + APPCOMMAND_CLOSE* = 31 + APPCOMMAND_SAVE* = 32 + APPCOMMAND_PRINT* = 33 + APPCOMMAND_UNDO* = 34 + APPCOMMAND_REDO* = 35 + APPCOMMAND_COPY* = 36 + APPCOMMAND_CUT* = 37 + APPCOMMAND_PASTE* = 38 + APPCOMMAND_REPLY_TO_MAIL* = 39 + APPCOMMAND_FORWARD_MAIL* = 40 + APPCOMMAND_SEND_MAIL* = 41 + APPCOMMAND_SPELL_CHECK* = 42 + APPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLE* = 43 + APPCOMMAND_MIC_ON_OFF_TOGGLE* = 44 + APPCOMMAND_CORRECTION_LIST* = 45 + APPCOMMAND_MEDIA_PLAY* = 46 + APPCOMMAND_MEDIA_PAUSE* = 47 + APPCOMMAND_MEDIA_RECORD* = 48 + APPCOMMAND_MEDIA_FAST_FORWARD* = 49 + APPCOMMAND_MEDIA_REWIND* = 50 + APPCOMMAND_MEDIA_CHANNEL_UP* = 51 + APPCOMMAND_MEDIA_CHANNEL_DOWN* = 52 + APPCOMMAND_DELETE* = 53 + APPCOMMAND_DWM_FLIP3D* = 54 + FAPPCOMMAND_MOUSE* = 0x8000 + FAPPCOMMAND_KEY* = 0 + FAPPCOMMAND_OEM* = 0x1000 + FAPPCOMMAND_MASK* = 0xF000 + LLKHF_EXTENDED* = KF_EXTENDED shr 8 + LLKHF_INJECTED* = 0x00000010 + LLKHF_ALTDOWN* = KF_ALTDOWN shr 8 + LLKHF_UP* = KF_UP shr 8 + LLMHF_INJECTED* = 0x00000001 + HKL_PREV* = 0 + HKL_NEXT* = 1 + KLF_ACTIVATE* = 0x00000001 + KLF_SUBSTITUTE_OK* = 0x00000002 + KLF_REORDER* = 0x00000008 + KLF_REPLACELANG* = 0x00000010 + KLF_NOTELLSHELL* = 0x00000080 + KLF_SETFORPROCESS* = 0x00000100 + KLF_SHIFTLOCK* = 0x00010000 + KLF_RESET* = 0x40000000 + INPUTLANGCHANGE_SYSCHARSET* = 0x0001 + INPUTLANGCHANGE_FORWARD* = 0x0002 + INPUTLANGCHANGE_BACKWARD* = 0x0004 + KL_NAMELENGTH* = 9 + GMMP_USE_DISPLAY_POINTS* = 1 + GMMP_USE_HIGH_RESOLUTION_POINTS* = 2 + DESKTOP_READOBJECTS* = 0x0001 + DESKTOP_CREATEWINDOW* = 0x0002 + DESKTOP_CREATEMENU* = 0x0004 + DESKTOP_HOOKCONTROL* = 0x0008 + DESKTOP_JOURNALRECORD* = 0x0010 + DESKTOP_JOURNALPLAYBACK* = 0x0020 + DESKTOP_ENUMERATE* = 0x0040 + DESKTOP_WRITEOBJECTS* = 0x0080 + DESKTOP_SWITCHDESKTOP* = 0x0100 + DF_ALLOWOTHERACCOUNTHOOK* = 0x0001 + WINSTA_ENUMDESKTOPS* = 0x0001 + WINSTA_READATTRIBUTES* = 0x0002 + WINSTA_ACCESSCLIPBOARD* = 0x0004 + WINSTA_CREATEDESKTOP* = 0x0008 + WINSTA_WRITEATTRIBUTES* = 0x0010 + WINSTA_ACCESSGLOBALATOMS* = 0x0020 + WINSTA_EXITWINDOWS* = 0x0040 + WINSTA_ENUMERATE* = 0x0100 + WINSTA_READSCREEN* = 0x0200 + WINSTA_ALL_ACCESS* = WINSTA_ENUMDESKTOPS or WINSTA_READATTRIBUTES or WINSTA_ACCESSCLIPBOARD or WINSTA_CREATEDESKTOP or WINSTA_WRITEATTRIBUTES or WINSTA_ACCESSGLOBALATOMS or WINSTA_EXITWINDOWS or WINSTA_ENUMERATE or WINSTA_READSCREEN + CWF_CREATE_ONLY* = 0x00000001 + WSF_VISIBLE* = 0x0001 + UOI_FLAGS* = 1 + UOI_NAME* = 2 + UOI_TYPE* = 3 + UOI_USER_SID* = 4 + UOI_HEAPSIZE* = 5 + UOI_IO* = 6 + GWL_WNDPROC* = -4 + GWL_HINSTANCE* = -6 + GWL_HWNDPARENT* = -8 + GWL_STYLE* = -16 + GWL_EXSTYLE* = -20 + GWL_USERDATA* = -21 + GWL_ID* = -12 + GWLP_WNDPROC* = -4 + GWLP_HINSTANCE* = -6 + GWLP_HWNDPARENT* = -8 + GWLP_USERDATA* = -21 + GWLP_ID* = -12 + GCL_MENUNAME* = -8 + GCL_HBRBACKGROUND* = -10 + GCL_HCURSOR* = -12 + GCL_HICON* = -14 + GCL_HMODULE* = -16 + GCL_CBWNDEXTRA* = -18 + GCL_CBCLSEXTRA* = -20 + GCL_WNDPROC* = -24 + GCL_STYLE* = -26 + GCW_ATOM* = -32 + GCL_HICONSM* = -34 + GCLP_MENUNAME* = -8 + GCLP_HBRBACKGROUND* = -10 + GCLP_HCURSOR* = -12 + GCLP_HICON* = -14 + GCLP_HMODULE* = -16 + GCLP_WNDPROC* = -24 + GCLP_HICONSM* = -34 + WM_NULL* = 0x0000 + WM_CREATE* = 0x0001 + WM_DESTROY* = 0x0002 + WM_MOVE* = 0x0003 + WM_SIZE* = 0x0005 + WM_ACTIVATE* = 0x0006 + WA_INACTIVE* = 0 + WA_ACTIVE* = 1 + WA_CLICKACTIVE* = 2 + WM_SETFOCUS* = 0x0007 + WM_KILLFOCUS* = 0x0008 + WM_ENABLE* = 0x000A + WM_SETREDRAW* = 0x000B + WM_SETTEXT* = 0x000C + WM_GETTEXT* = 0x000D + WM_GETTEXTLENGTH* = 0x000E + WM_PAINT* = 0x000F + WM_CLOSE* = 0x0010 + WM_QUERYENDSESSION* = 0x0011 + WM_QUERYOPEN* = 0x0013 + WM_ENDSESSION* = 0x0016 + WM_QUIT* = 0x0012 + WM_ERASEBKGND* = 0x0014 + WM_SYSCOLORCHANGE* = 0x0015 + WM_SHOWWINDOW* = 0x0018 + WM_WININICHANGE* = 0x001A + WM_SETTINGCHANGE* = WM_WININICHANGE + WM_DEVMODECHANGE* = 0x001B + WM_ACTIVATEAPP* = 0x001C + WM_FONTCHANGE* = 0x001D + WM_TIMECHANGE* = 0x001E + WM_CANCELMODE* = 0x001F + WM_SETCURSOR* = 0x0020 + WM_MOUSEACTIVATE* = 0x0021 + WM_CHILDACTIVATE* = 0x0022 + WM_QUEUESYNC* = 0x0023 + WM_GETMINMAXINFO* = 0x0024 + WM_PAINTICON* = 0x0026 + WM_ICONERASEBKGND* = 0x0027 + WM_NEXTDLGCTL* = 0x0028 + WM_SPOOLERSTATUS* = 0x002A + WM_DRAWITEM* = 0x002B + WM_MEASUREITEM* = 0x002C + WM_DELETEITEM* = 0x002D + WM_VKEYTOITEM* = 0x002E + WM_CHARTOITEM* = 0x002F + WM_SETFONT* = 0x0030 + WM_GETFONT* = 0x0031 + WM_SETHOTKEY* = 0x0032 + WM_GETHOTKEY* = 0x0033 + WM_QUERYDRAGICON* = 0x0037 + WM_COMPAREITEM* = 0x0039 + WM_GETOBJECT* = 0x003D + WM_COMPACTING* = 0x0041 + WM_COMMNOTIFY* = 0x0044 + WM_WINDOWPOSCHANGING* = 0x0046 + WM_WINDOWPOSCHANGED* = 0x0047 + WM_POWER* = 0x0048 + PWR_OK* = 1 + PWR_FAIL* = -1 + PWR_SUSPENDREQUEST* = 1 + PWR_SUSPENDRESUME* = 2 + PWR_CRITICALRESUME* = 3 + WM_COPYDATA* = 0x004A + WM_CANCELJOURNAL* = 0x004B + WM_NOTIFY* = 0x004E + WM_INPUTLANGCHANGEREQUEST* = 0x0050 + WM_INPUTLANGCHANGE* = 0x0051 + WM_TCARD* = 0x0052 + WM_HELP* = 0x0053 + WM_USERCHANGED* = 0x0054 + WM_NOTIFYFORMAT* = 0x0055 + NFR_ANSI* = 1 + NFR_UNICODE* = 2 + NF_QUERY* = 3 + NF_REQUERY* = 4 + WM_CONTEXTMENU* = 0x007B + WM_STYLECHANGING* = 0x007C + WM_STYLECHANGED* = 0x007D + WM_DISPLAYCHANGE* = 0x007E + WM_GETICON* = 0x007F + WM_SETICON* = 0x0080 + WM_NCCREATE* = 0x0081 + WM_NCDESTROY* = 0x0082 + WM_NCCALCSIZE* = 0x0083 + WM_NCHITTEST* = 0x0084 + WM_NCPAINT* = 0x0085 + WM_NCACTIVATE* = 0x0086 + WM_GETDLGCODE* = 0x0087 + WM_SYNCPAINT* = 0x0088 + WM_NCMOUSEMOVE* = 0x00A0 + WM_NCLBUTTONDOWN* = 0x00A1 + WM_NCLBUTTONUP* = 0x00A2 + WM_NCLBUTTONDBLCLK* = 0x00A3 + WM_NCRBUTTONDOWN* = 0x00A4 + WM_NCRBUTTONUP* = 0x00A5 + WM_NCRBUTTONDBLCLK* = 0x00A6 + WM_NCMBUTTONDOWN* = 0x00A7 + WM_NCMBUTTONUP* = 0x00A8 + WM_NCMBUTTONDBLCLK* = 0x00A9 + WM_NCXBUTTONDOWN* = 0x00AB + WM_NCXBUTTONUP* = 0x00AC + WM_NCXBUTTONDBLCLK* = 0x00AD + WM_INPUT_DEVICE_CHANGE* = 0x00fe + WM_INPUT* = 0x00FF + WM_KEYFIRST* = 0x0100 + WM_KEYDOWN* = 0x0100 + WM_KEYUP* = 0x0101 + WM_CHAR* = 0x0102 + WM_DEADCHAR* = 0x0103 + WM_SYSKEYDOWN* = 0x0104 + WM_SYSKEYUP* = 0x0105 + WM_SYSCHAR* = 0x0106 + WM_SYSDEADCHAR* = 0x0107 + WM_UNICHAR* = 0x0109 + WM_KEYLAST* = 0x0109 + UNICODE_NOCHAR* = 0xFFFF + WM_IME_STARTCOMPOSITION* = 0x010D + WM_IME_ENDCOMPOSITION* = 0x010E + WM_IME_COMPOSITION* = 0x010F + WM_IME_KEYLAST* = 0x010F + WM_INITDIALOG* = 0x0110 + WM_COMMAND* = 0x0111 + WM_SYSCOMMAND* = 0x0112 + WM_TIMER* = 0x0113 + WM_HSCROLL* = 0x0114 + WM_VSCROLL* = 0x0115 + WM_INITMENU* = 0x0116 + WM_INITMENUPOPUP* = 0x0117 + WM_MENUSELECT* = 0x011F + WM_GESTURE* = 0x0119 + WM_GESTURENOTIFY* = 0x011A + WM_MENUCHAR* = 0x0120 + WM_ENTERIDLE* = 0x0121 + WM_MENURBUTTONUP* = 0x0122 + WM_MENUDRAG* = 0x0123 + WM_MENUGETOBJECT* = 0x0124 + WM_UNINITMENUPOPUP* = 0x0125 + WM_MENUCOMMAND* = 0x0126 + WM_CHANGEUISTATE* = 0x0127 + WM_UPDATEUISTATE* = 0x0128 + WM_QUERYUISTATE* = 0x0129 + UIS_SET* = 1 + UIS_CLEAR* = 2 + UIS_INITIALIZE* = 3 + UISF_HIDEFOCUS* = 0x1 + UISF_HIDEACCEL* = 0x2 + UISF_ACTIVE* = 0x4 + WM_CTLCOLORMSGBOX* = 0x0132 + WM_CTLCOLOREDIT* = 0x0133 + WM_CTLCOLORLISTBOX* = 0x0134 + WM_CTLCOLORBTN* = 0x0135 + WM_CTLCOLORDLG* = 0x0136 + WM_CTLCOLORSCROLLBAR* = 0x0137 + WM_CTLCOLORSTATIC* = 0x0138 + MN_GETHMENU* = 0x01E1 + WM_MOUSEFIRST* = 0x0200 + WM_MOUSEMOVE* = 0x0200 + WM_LBUTTONDOWN* = 0x0201 + WM_LBUTTONUP* = 0x0202 + WM_LBUTTONDBLCLK* = 0x0203 + WM_RBUTTONDOWN* = 0x0204 + WM_RBUTTONUP* = 0x0205 + WM_RBUTTONDBLCLK* = 0x0206 + WM_MBUTTONDOWN* = 0x0207 + WM_MBUTTONUP* = 0x0208 + WM_MBUTTONDBLCLK* = 0x0209 + WM_MOUSEWHEEL* = 0x020A + WM_XBUTTONDOWN* = 0x020B + WM_XBUTTONUP* = 0x020C + WM_XBUTTONDBLCLK* = 0x020D + WM_MOUSEHWHEEL* = 0x020e + WM_MOUSELAST* = 0x020e + WHEEL_DELTA* = 120 + XBUTTON1* = 0x0001 + XBUTTON2* = 0x0002 + WM_PARENTNOTIFY* = 0x0210 + WM_ENTERMENULOOP* = 0x0211 + WM_EXITMENULOOP* = 0x0212 + WM_NEXTMENU* = 0x0213 + WM_SIZING* = 0x0214 + WM_CAPTURECHANGED* = 0x0215 + WM_MOVING* = 0x0216 + WM_POWERBROADCAST* = 0x0218 + PBT_APMQUERYSUSPEND* = 0x0000 + PBT_APMQUERYSTANDBY* = 0x0001 + PBT_APMQUERYSUSPENDFAILED* = 0x0002 + PBT_APMQUERYSTANDBYFAILED* = 0x0003 + PBT_APMSUSPEND* = 0x0004 + PBT_APMSTANDBY* = 0x0005 + PBT_APMRESUMECRITICAL* = 0x0006 + PBT_APMRESUMESUSPEND* = 0x0007 + PBT_APMRESUMESTANDBY* = 0x0008 + PBTF_APMRESUMEFROMFAILURE* = 0x00000001 + PBT_APMBATTERYLOW* = 0x0009 + PBT_APMPOWERSTATUSCHANGE* = 0x000A + PBT_APMOEMEVENT* = 0x000B + PBT_APMRESUMEAUTOMATIC* = 0x0012 + PBT_POWERSETTINGCHANGE* = 32787 + WM_DEVICECHANGE* = 0x0219 + WM_MDICREATE* = 0x0220 + WM_MDIDESTROY* = 0x0221 + WM_MDIACTIVATE* = 0x0222 + WM_MDIRESTORE* = 0x0223 + WM_MDINEXT* = 0x0224 + WM_MDIMAXIMIZE* = 0x0225 + WM_MDITILE* = 0x0226 + WM_MDICASCADE* = 0x0227 + WM_MDIICONARRANGE* = 0x0228 + WM_MDIGETACTIVE* = 0x0229 + WM_MDISETMENU* = 0x0230 + WM_ENTERSIZEMOVE* = 0x0231 + WM_EXITSIZEMOVE* = 0x0232 + WM_DROPFILES* = 0x0233 + WM_MDIREFRESHMENU* = 0x0234 + WM_POINTERDEVICECHANGE* = 0x238 + WM_POINTERDEVICEINRANGE* = 0x239 + WM_POINTERDEVICEOUTOFRANGE* = 0x23a + WM_TOUCH* = 0x0240 + WM_NCPOINTERUPDATE* = 0x0241 + WM_NCPOINTERDOWN* = 0x0242 + WM_NCPOINTERUP* = 0x0243 + WM_POINTERUPDATE* = 0x0245 + WM_POINTERDOWN* = 0x0246 + WM_POINTERUP* = 0x0247 + WM_POINTERENTER* = 0x0249 + WM_POINTERLEAVE* = 0x024a + WM_POINTERACTIVATE* = 0x024b + WM_POINTERCAPTURECHANGED* = 0x024c + WM_TOUCHHITTESTING* = 0x024d + WM_POINTERWHEEL* = 0x024e + WM_POINTERHWHEEL* = 0x024f + WM_IME_SETCONTEXT* = 0x0281 + WM_IME_NOTIFY* = 0x0282 + WM_IME_CONTROL* = 0x0283 + WM_IME_COMPOSITIONFULL* = 0x0284 + WM_IME_SELECT* = 0x0285 + WM_IME_CHAR* = 0x0286 + WM_IME_REQUEST* = 0x0288 + WM_IME_KEYDOWN* = 0x0290 + WM_IME_KEYUP* = 0x0291 + WM_MOUSEHOVER* = 0x02A1 + WM_MOUSELEAVE* = 0x02A3 + WM_NCMOUSEHOVER* = 0x02A0 + WM_NCMOUSELEAVE* = 0x02A2 + WM_WTSSESSION_CHANGE* = 0x02B1 + WM_TABLET_FIRST* = 0x02c0 + WM_TABLET_LAST* = 0x02df + WM_CUT* = 0x0300 + WM_COPY* = 0x0301 + WM_PASTE* = 0x0302 + WM_CLEAR* = 0x0303 + WM_UNDO* = 0x0304 + WM_RENDERFORMAT* = 0x0305 + WM_RENDERALLFORMATS* = 0x0306 + WM_DESTROYCLIPBOARD* = 0x0307 + WM_DRAWCLIPBOARD* = 0x0308 + WM_PAINTCLIPBOARD* = 0x0309 + WM_VSCROLLCLIPBOARD* = 0x030A + WM_SIZECLIPBOARD* = 0x030B + WM_ASKCBFORMATNAME* = 0x030C + WM_CHANGECBCHAIN* = 0x030D + WM_HSCROLLCLIPBOARD* = 0x030E + WM_QUERYNEWPALETTE* = 0x030F + WM_PALETTEISCHANGING* = 0x0310 + WM_PALETTECHANGED* = 0x0311 + WM_HOTKEY* = 0x0312 + WM_PRINT* = 0x0317 + WM_PRINTCLIENT* = 0x0318 + WM_APPCOMMAND* = 0x0319 + WM_THEMECHANGED* = 0x031A + WM_CLIPBOARDUPDATE* = 0x031d + WM_DWMCOMPOSITIONCHANGED* = 0x031e + WM_DWMNCRENDERINGCHANGED* = 0x031f + WM_DWMCOLORIZATIONCOLORCHANGED* = 0x0320 + WM_DWMWINDOWMAXIMIZEDCHANGE* = 0x0321 + WM_DWMSENDICONICTHUMBNAIL* = 0x0323 + WM_DWMSENDICONICLIVEPREVIEWBITMAP* = 0x0326 + WM_GETTITLEBARINFOEX* = 0x033f + WM_HANDHELDFIRST* = 0x0358 + WM_HANDHELDLAST* = 0x035F + WM_AFXFIRST* = 0x0360 + WM_AFXLAST* = 0x037F + WM_PENWINFIRST* = 0x0380 + WM_PENWINLAST* = 0x038F + WM_APP* = 0x8000 + WM_USER* = 0x0400 + WMSZ_LEFT* = 1 + WMSZ_RIGHT* = 2 + WMSZ_TOP* = 3 + WMSZ_TOPLEFT* = 4 + WMSZ_TOPRIGHT* = 5 + WMSZ_BOTTOM* = 6 + WMSZ_BOTTOMLEFT* = 7 + WMSZ_BOTTOMRIGHT* = 8 + HTERROR* = -2 + HTTRANSPARENT* = -1 + HTNOWHERE* = 0 + HTCLIENT* = 1 + HTCAPTION* = 2 + HTSYSMENU* = 3 + HTGROWBOX* = 4 + HTSIZE* = HTGROWBOX + HTMENU* = 5 + HTHSCROLL* = 6 + HTVSCROLL* = 7 + HTMINBUTTON* = 8 + HTMAXBUTTON* = 9 + HTLEFT* = 10 + HTRIGHT* = 11 + HTTOP* = 12 + HTTOPLEFT* = 13 + HTTOPRIGHT* = 14 + HTBOTTOM* = 15 + HTBOTTOMLEFT* = 16 + HTBOTTOMRIGHT* = 17 + HTBORDER* = 18 + HTREDUCE* = HTMINBUTTON + HTZOOM* = HTMAXBUTTON + HTSIZEFIRST* = HTLEFT + HTSIZELAST* = HTBOTTOMRIGHT + HTOBJECT* = 19 + HTCLOSE* = 20 + HTHELP* = 21 + SMTO_NORMAL* = 0x0000 + SMTO_BLOCK* = 0x0001 + SMTO_ABORTIFHUNG* = 0x0002 + SMTO_NOTIMEOUTIFNOTHUNG* = 0x0008 + SMTO_ERRORONEXIT* = 0x0020 + MA_ACTIVATE* = 1 + MA_ACTIVATEANDEAT* = 2 + MA_NOACTIVATE* = 3 + MA_NOACTIVATEANDEAT* = 4 + ICON_SMALL* = 0 + ICON_BIG* = 1 + ICON_SMALL2* = 2 + SIZE_RESTORED* = 0 + SIZE_MINIMIZED* = 1 + SIZE_MAXIMIZED* = 2 + SIZE_MAXSHOW* = 3 + SIZE_MAXHIDE* = 4 + SIZENORMAL* = SIZE_RESTORED + SIZEICONIC* = SIZE_MINIMIZED + SIZEFULLSCREEN* = SIZE_MAXIMIZED + SIZEZOOMSHOW* = SIZE_MAXSHOW + SIZEZOOMHIDE* = SIZE_MAXHIDE + WVR_ALIGNTOP* = 0x0010 + WVR_ALIGNLEFT* = 0x0020 + WVR_ALIGNBOTTOM* = 0x0040 + WVR_ALIGNRIGHT* = 0x0080 + WVR_HREDRAW* = 0x0100 + WVR_VREDRAW* = 0x0200 + WVR_REDRAW* = WVR_HREDRAW or WVR_VREDRAW + WVR_VALIDRECTS* = 0x0400 + MK_LBUTTON* = 0x0001 + MK_RBUTTON* = 0x0002 + MK_SHIFT* = 0x0004 + MK_CONTROL* = 0x0008 + MK_MBUTTON* = 0x0010 + MK_XBUTTON1* = 0x0020 + MK_XBUTTON2* = 0x0040 + TME_HOVER* = 0x00000001 + TME_LEAVE* = 0x00000002 + TME_NONCLIENT* = 0x00000010 + TME_QUERY* = 0x40000000 + TME_CANCEL* = 0x80000000'i32 + HOVER_DEFAULT* = 0xFFFFFFFF'i32 + WS_OVERLAPPED* = 0x00000000 + WS_POPUP* = 0x80000000'i32 + WS_CHILD* = 0x40000000 + WS_MINIMIZE* = 0x20000000 + WS_VISIBLE* = 0x10000000 + WS_DISABLED* = 0x08000000 + WS_CLIPSIBLINGS* = 0x04000000 + WS_CLIPCHILDREN* = 0x02000000 + WS_MAXIMIZE* = 0x01000000 + WS_CAPTION* = 0x00C00000 + WS_BORDER* = 0x00800000 + WS_DLGFRAME* = 0x00400000 + WS_VSCROLL* = 0x00200000 + WS_HSCROLL* = 0x00100000 + WS_SYSMENU* = 0x00080000 + WS_THICKFRAME* = 0x00040000 + WS_GROUP* = 0x00020000 + WS_TABSTOP* = 0x00010000 + WS_MINIMIZEBOX* = 0x00020000 + WS_MAXIMIZEBOX* = 0x00010000 + WS_TILED* = WS_OVERLAPPED + WS_ICONIC* = WS_MINIMIZE + WS_SIZEBOX* = WS_THICKFRAME + WS_OVERLAPPEDWINDOW* = WS_OVERLAPPED or WS_CAPTION or WS_SYSMENU or WS_THICKFRAME or WS_MINIMIZEBOX or WS_MAXIMIZEBOX + WS_TILEDWINDOW* = WS_OVERLAPPEDWINDOW + WS_POPUPWINDOW* = WS_POPUP or WS_BORDER or WS_SYSMENU + WS_CHILDWINDOW* = WS_CHILD + WS_EX_DLGMODALFRAME* = 0x00000001 + WS_EX_NOPARENTNOTIFY* = 0x00000004 + WS_EX_TOPMOST* = 0x00000008 + WS_EX_ACCEPTFILES* = 0x00000010 + WS_EX_TRANSPARENT* = 0x00000020 + WS_EX_MDICHILD* = 0x00000040 + WS_EX_TOOLWINDOW* = 0x00000080 + WS_EX_WINDOWEDGE* = 0x00000100 + WS_EX_CLIENTEDGE* = 0x00000200 + WS_EX_CONTEXTHELP* = 0x00000400 + WS_EX_RIGHT* = 0x00001000 + WS_EX_LEFT* = 0x00000000 + WS_EX_RTLREADING* = 0x00002000 + WS_EX_LTRREADING* = 0x00000000 + WS_EX_LEFTSCROLLBAR* = 0x00004000 + WS_EX_RIGHTSCROLLBAR* = 0x00000000 + WS_EX_CONTROLPARENT* = 0x00010000 + WS_EX_STATICEDGE* = 0x00020000 + WS_EX_APPWINDOW* = 0x00040000 + WS_EX_OVERLAPPEDWINDOW* = WS_EX_WINDOWEDGE or WS_EX_CLIENTEDGE + WS_EX_PALETTEWINDOW* = WS_EX_WINDOWEDGE or WS_EX_TOOLWINDOW or WS_EX_TOPMOST + WS_EX_LAYERED* = 0x00080000 + WS_EX_NOINHERITLAYOUT* = 0x00100000 + WS_EX_NOREDIRECTIONBITMAP* = 0x00200000 + WS_EX_LAYOUTRTL* = 0x00400000 + WS_EX_COMPOSITED* = 0x02000000 + WS_EX_NOACTIVATE* = 0x08000000 + CS_VREDRAW* = 0x0001 + CS_HREDRAW* = 0x0002 + CS_DBLCLKS* = 0x0008 + CS_OWNDC* = 0x0020 + CS_CLASSDC* = 0x0040 + CS_PARENTDC* = 0x0080 + CS_NOCLOSE* = 0x0200 + CS_SAVEBITS* = 0x0800 + CS_BYTEALIGNCLIENT* = 0x1000 + CS_BYTEALIGNWINDOW* = 0x2000 + CS_GLOBALCLASS* = 0x4000 + CS_IME* = 0x00010000 + CS_DROPSHADOW* = 0x00020000 + PRF_CHECKVISIBLE* = 0x00000001 + PRF_NONCLIENT* = 0x00000002 + PRF_CLIENT* = 0x00000004 + PRF_ERASEBKGND* = 0x00000008 + PRF_CHILDREN* = 0x00000010 + PRF_OWNED* = 0x00000020 + BDR_RAISEDOUTER* = 0x0001 + BDR_SUNKENOUTER* = 0x0002 + BDR_RAISEDINNER* = 0x0004 + BDR_SUNKENINNER* = 0x0008 + BDR_OUTER* = BDR_RAISEDOUTER or BDR_SUNKENOUTER + BDR_INNER* = BDR_RAISEDINNER or BDR_SUNKENINNER + BDR_RAISED* = BDR_RAISEDOUTER or BDR_RAISEDINNER + BDR_SUNKEN* = BDR_SUNKENOUTER or BDR_SUNKENINNER + EDGE_RAISED* = BDR_RAISEDOUTER or BDR_RAISEDINNER + EDGE_SUNKEN* = BDR_SUNKENOUTER or BDR_SUNKENINNER + EDGE_ETCHED* = BDR_SUNKENOUTER or BDR_RAISEDINNER + EDGE_BUMP* = BDR_RAISEDOUTER or BDR_SUNKENINNER + BF_LEFT* = 0x0001 + BF_TOP* = 0x0002 + BF_RIGHT* = 0x0004 + BF_BOTTOM* = 0x0008 + BF_TOPLEFT* = BF_TOP or BF_LEFT + BF_TOPRIGHT* = BF_TOP or BF_RIGHT + BF_BOTTOMLEFT* = BF_BOTTOM or BF_LEFT + BF_BOTTOMRIGHT* = BF_BOTTOM or BF_RIGHT + BF_RECT* = BF_LEFT or BF_TOP or BF_RIGHT or BF_BOTTOM + BF_DIAGONAL* = 0x0010 + BF_DIAGONAL_ENDTOPRIGHT* = BF_DIAGONAL or BF_TOP or BF_RIGHT + BF_DIAGONAL_ENDTOPLEFT* = BF_DIAGONAL or BF_TOP or BF_LEFT + BF_DIAGONAL_ENDBOTTOMLEFT* = BF_DIAGONAL or BF_BOTTOM or BF_LEFT + BF_DIAGONAL_ENDBOTTOMRIGHT* = BF_DIAGONAL or BF_BOTTOM or BF_RIGHT + BF_MIDDLE* = 0x0800 + BF_SOFT* = 0x1000 + BF_ADJUST* = 0x2000 + BF_FLAT* = 0x4000 + BF_MONO* = 0x8000 + DFC_CAPTION* = 1 + DFC_MENU* = 2 + DFC_SCROLL* = 3 + DFC_BUTTON* = 4 + DFC_POPUPMENU* = 5 + DFCS_CAPTIONCLOSE* = 0x0000 + DFCS_CAPTIONMIN* = 0x0001 + DFCS_CAPTIONMAX* = 0x0002 + DFCS_CAPTIONRESTORE* = 0x0003 + DFCS_CAPTIONHELP* = 0x0004 + DFCS_MENUARROW* = 0x0000 + DFCS_MENUCHECK* = 0x0001 + DFCS_MENUBULLET* = 0x0002 + DFCS_MENUARROWRIGHT* = 0x0004 + DFCS_SCROLLUP* = 0x0000 + DFCS_SCROLLDOWN* = 0x0001 + DFCS_SCROLLLEFT* = 0x0002 + DFCS_SCROLLRIGHT* = 0x0003 + DFCS_SCROLLCOMBOBOX* = 0x0005 + DFCS_SCROLLSIZEGRIP* = 0x0008 + DFCS_SCROLLSIZEGRIPRIGHT* = 0x0010 + DFCS_BUTTONCHECK* = 0x0000 + DFCS_BUTTONRADIOIMAGE* = 0x0001 + DFCS_BUTTONRADIOMASK* = 0x0002 + DFCS_BUTTONRADIO* = 0x0004 + DFCS_BUTTON3STATE* = 0x0008 + DFCS_BUTTONPUSH* = 0x0010 + DFCS_INACTIVE* = 0x0100 + DFCS_PUSHED* = 0x0200 + DFCS_CHECKED* = 0x0400 + DFCS_TRANSPARENT* = 0x0800 + DFCS_HOT* = 0x1000 + DFCS_ADJUSTRECT* = 0x2000 + DFCS_FLAT* = 0x4000 + DFCS_MONO* = 0x8000 + DC_ACTIVE* = 0x0001 + DC_SMALLCAP* = 0x0002 + DC_ICON* = 0x0004 + DC_TEXT* = 0x0008 + DC_INBUTTON* = 0x0010 + DC_GRADIENT* = 0x0020 + DC_BUTTONS* = 0x1000 + IDANI_OPEN* = 1 + IDANI_CAPTION* = 3 + CF_TEXT* = 1 + CF_BITMAP* = 2 + CF_METAFILEPICT* = 3 + CF_SYLK* = 4 + CF_DIF* = 5 + CF_TIFF* = 6 + CF_OEMTEXT* = 7 + CF_DIB* = 8 + CF_PALETTE* = 9 + CF_PENDATA* = 10 + CF_RIFF* = 11 + CF_WAVE* = 12 + CF_UNICODETEXT* = 13 + CF_ENHMETAFILE* = 14 + CF_HDROP* = 15 + CF_LOCALE* = 16 + CF_DIBV5* = 17 + CF_MAX* = 18 + CF_OWNERDISPLAY* = 0x0080 + CF_DSPTEXT* = 0x0081 + CF_DSPBITMAP* = 0x0082 + CF_DSPMETAFILEPICT* = 0x0083 + CF_DSPENHMETAFILE* = 0x008E + CF_PRIVATEFIRST* = 0x0200 + CF_PRIVATELAST* = 0x02FF + CF_GDIOBJFIRST* = 0x0300 + CF_GDIOBJLAST* = 0x03FF + FVIRTKEY* = TRUE + FNOINVERT* = 0x02 + FSHIFT* = 0x04 + FCONTROL* = 0x08 + FALT* = 0x10 + WPF_SETMINPOSITION* = 0x0001 + WPF_RESTORETOMAXIMIZED* = 0x0002 + WPF_ASYNCWINDOWPLACEMENT* = 0x0004 + ODT_MENU* = 1 + ODT_LISTBOX* = 2 + ODT_COMBOBOX* = 3 + ODT_BUTTON* = 4 + ODT_STATIC* = 5 + ODA_DRAWENTIRE* = 0x0001 + ODA_SELECT* = 0x0002 + ODA_FOCUS* = 0x0004 + ODS_SELECTED* = 0x0001 + ODS_GRAYED* = 0x0002 + ODS_DISABLED* = 0x0004 + ODS_CHECKED* = 0x0008 + ODS_FOCUS* = 0x0010 + ODS_DEFAULT* = 0x0020 + ODS_COMBOBOXEDIT* = 0x1000 + ODS_HOTLIGHT* = 0x0040 + ODS_INACTIVE* = 0x0080 + ODS_NOACCEL* = 0x0100 + ODS_NOFOCUSRECT* = 0x0200 + PM_NOREMOVE* = 0x0000 + PM_REMOVE* = 0x0001 + PM_NOYIELD* = 0x0002 + QS_MOUSEMOVE* = 0x0002 + QS_MOUSEBUTTON* = 0x0004 + QS_MOUSE* = QS_MOUSEMOVE or QS_MOUSEBUTTON + QS_KEY* = 0x0001 + QS_RAWINPUT* = 0x0400 + QS_TOUCH* = 0x0800 + QS_POINTER* = 0x1000 + QS_INPUT* = QS_MOUSE or QS_KEY or QS_RAWINPUT or QS_TOUCH or QS_POINTER + PM_QS_INPUT* = QS_INPUT shl 16 + QS_POSTMESSAGE* = 0x0008 + QS_HOTKEY* = 0x0080 + QS_TIMER* = 0x0010 + PM_QS_POSTMESSAGE* = (QS_POSTMESSAGE or QS_HOTKEY or QS_TIMER) shl 16 + QS_PAINT* = 0x0020 + PM_QS_PAINT* = QS_PAINT shl 16 + QS_SENDMESSAGE* = 0x0040 + PM_QS_SENDMESSAGE* = QS_SENDMESSAGE shl 16 + MOD_ALT* = 0x0001 + MOD_CONTROL* = 0x0002 + MOD_SHIFT* = 0x0004 + MOD_WIN* = 0x0008 + MOD_NOREPEAT* = 0x4000 + IDHOT_SNAPWINDOW* = -1 + IDHOT_SNAPDESKTOP* = -2 + ENDSESSION_CLOSEAPP* = 0x00000001 + ENDSESSION_CRITICAL* = 0x40000000 + ENDSESSION_LOGOFF* = 0x80000000'i32 + EWX_LOGOFF* = 0x00000000 + EWX_SHUTDOWN* = 0x00000001 + EWX_REBOOT* = 0x00000002 + EWX_FORCE* = 0x00000004 + EWX_POWEROFF* = 0x00000008 + EWX_FORCEIFHUNG* = 0x00000010 + EWX_QUICKRESOLVE* = 0x00000020 + EWX_RESTARTAPPS* = 0x00000040 + EWX_HYBRID_SHUTDOWN* = 0x00400000 + EWX_BOOTOPTIONS* = 0x01000000 + BSM_ALLCOMPONENTS* = 0x00000000 + BSM_VXDS* = 0x00000001 + BSM_NETDRIVER* = 0x00000002 + BSM_INSTALLABLEDRIVERS* = 0x00000004 + BSM_APPLICATIONS* = 0x00000008 + BSM_ALLDESKTOPS* = 0x00000010 + BSF_QUERY* = 0x00000001 + BSF_IGNORECURRENTTASK* = 0x00000002 + BSF_FLUSHDISK* = 0x00000004 + BSF_NOHANG* = 0x00000008 + BSF_POSTMESSAGE* = 0x00000010 + BSF_FORCEIFHUNG* = 0x00000020 + BSF_NOTIMEOUTIFNOTHUNG* = 0x00000040 + BSF_ALLOWSFW* = 0x00000080 + BSF_SENDNOTIFYMESSAGE* = 0x00000100 + BSF_RETURNHDESK* = 0x00000200 + BSF_LUID* = 0x00000400 + BROADCAST_QUERY_DENY* = 0x424D5144 + DEVICE_NOTIFY_WINDOW_HANDLE* = 0x00000000 + DEVICE_NOTIFY_SERVICE_HANDLE* = 0x00000001 + DEVICE_NOTIFY_ALL_INTERFACE_CLASSES* = 0x00000004 + CW_USEDEFAULT* = int32 0x80000000'i32 + HWND_BROADCAST* = HWND 0xffff + HWND_MESSAGE* = HWND(-3) + HWND_DESKTOP* = HWND 0 + ISMEX_NOSEND* = 0x00000000 + ISMEX_SEND* = 0x00000001 + ISMEX_NOTIFY* = 0x00000002 + ISMEX_CALLBACK* = 0x00000004 + ISMEX_REPLIED* = 0x00000008 + PW_CLIENTONLY* = 0x00000001 + LWA_COLORKEY* = 0x00000001 + LWA_ALPHA* = 0x00000002 + ULW_COLORKEY* = 0x00000001 + ULW_ALPHA* = 0x00000002 + ULW_OPAQUE* = 0x00000004 + ULW_EX_NORESIZE* = 0x00000008 + FLASHW_STOP* = 0 + FLASHW_CAPTION* = 0x00000001 + FLASHW_TRAY* = 0x00000002 + FLASHW_ALL* = FLASHW_CAPTION or FLASHW_TRAY + FLASHW_TIMER* = 0x00000004 + FLASHW_TIMERNOFG* = 0x0000000c + WDA_NONE* = 0x00000000 + WDA_MONITOR* = 0x00000001 + SWP_NOSIZE* = 0x0001 + SWP_NOMOVE* = 0x0002 + SWP_NOZORDER* = 0x0004 + SWP_NOREDRAW* = 0x0008 + SWP_NOACTIVATE* = 0x0010 + SWP_FRAMECHANGED* = 0x0020 + SWP_SHOWWINDOW* = 0x0040 + SWP_HIDEWINDOW* = 0x0080 + SWP_NOCOPYBITS* = 0x0100 + SWP_NOOWNERZORDER* = 0x0200 + SWP_NOSENDCHANGING* = 0x0400 + SWP_DRAWFRAME* = SWP_FRAMECHANGED + SWP_NOREPOSITION* = SWP_NOOWNERZORDER + SWP_DEFERERASE* = 0x2000 + SWP_ASYNCWINDOWPOS* = 0x4000 + HWND_TOP* = HWND 0 + HWND_BOTTOM* = HWND 1 + HWND_TOPMOST* = HWND(-1) + HWND_NOTOPMOST* = HWND(-2) + DLGWINDOWEXTRA* = 30 + KEYEVENTF_EXTENDEDKEY* = 0x0001 + KEYEVENTF_KEYUP* = 0x0002 + KEYEVENTF_UNICODE* = 0x0004 + KEYEVENTF_SCANCODE* = 0x0008 + MOUSEEVENTF_MOVE* = 0x0001 + MOUSEEVENTF_LEFTDOWN* = 0x0002 + MOUSEEVENTF_LEFTUP* = 0x0004 + MOUSEEVENTF_RIGHTDOWN* = 0x0008 + MOUSEEVENTF_RIGHTUP* = 0x0010 + MOUSEEVENTF_MIDDLEDOWN* = 0x0020 + MOUSEEVENTF_MIDDLEUP* = 0x0040 + MOUSEEVENTF_XDOWN* = 0x0080 + MOUSEEVENTF_XUP* = 0x0100 + MOUSEEVENTF_WHEEL* = 0x0800 + MOUSEEVENTF_HWHEEL* = 0x01000 + MOUSEEVENTF_MOVE_NOCOALESCE* = 0x2000 + MOUSEEVENTF_VIRTUALDESK* = 0x4000 + MOUSEEVENTF_ABSOLUTE* = 0x8000 + INPUT_MOUSE* = 0 + INPUT_KEYBOARD* = 1 + INPUT_HARDWARE* = 2 + TOUCHEVENTF_MOVE* = 0x0001 + TOUCHEVENTF_DOWN* = 0x0002 + TOUCHEVENTF_UP* = 0x0004 + TOUCHEVENTF_INRANGE* = 0x0008 + TOUCHEVENTF_PRIMARY* = 0x0010 + TOUCHEVENTF_NOCOALESCE* = 0x0020 + TOUCHEVENTF_PEN* = 0x0040 + TOUCHEVENTF_PALM* = 0x0080 + TOUCHINPUTMASKF_TIMEFROMSYSTEM* = 0x0001 + TOUCHINPUTMASKF_EXTRAINFO* = 0x0002 + TOUCHINPUTMASKF_CONTACTAREA* = 0x0004 + TWF_FINETOUCH* = 0x00000001 + TWF_WANTPALM* = 0x00000002 + POINTER_FLAG_NONE* = 0x00000000 + POINTER_FLAG_NEW* = 0x00000001 + POINTER_FLAG_INRANGE* = 0x00000002 + POINTER_FLAG_INCONTACT* = 0x00000004 + POINTER_FLAG_FIRSTBUTTON* = 0x00000010 + POINTER_FLAG_SECONDBUTTON* = 0x00000020 + POINTER_FLAG_THIRDBUTTON* = 0x00000040 + POINTER_FLAG_FOURTHBUTTON* = 0x00000080 + POINTER_FLAG_FIFTHBUTTON* = 0x00000100 + POINTER_FLAG_PRIMARY* = 0x00002000 + POINTER_FLAG_CONFIDENCE* = 0x00004000 + POINTER_FLAG_CANCELED* = 0x00008000 + POINTER_FLAG_DOWN* = 0x00010000 + POINTER_FLAG_UPDATE* = 0x00020000 + POINTER_FLAG_UP* = 0x00040000 + POINTER_FLAG_WHEEL* = 0x00080000 + POINTER_FLAG_HWHEEL* = 0x00100000 + POINTER_FLAG_CAPTURECHANGED* = 0x00200000 + POINTER_MOD_SHIFT* = 0x0004 + POINTER_MOD_CTRL* = 0x0008 + TOUCH_FLAG_NONE* = 0x00000000 + TOUCH_MASK_NONE* = 0x00000000 + TOUCH_MASK_CONTACTAREA* = 0x00000001 + TOUCH_MASK_ORIENTATION* = 0x00000002 + TOUCH_MASK_PRESSURE* = 0x00000004 + PEN_FLAG_NONE* = 0x00000000 + PEN_FLAG_BARREL* = 0x00000001 + PEN_FLAG_INVERTED* = 0x00000002 + PEN_FLAG_ERASER* = 0x00000004 + PEN_MASK_NONE* = 0x00000000 + PEN_MASK_PRESSURE* = 0x00000001 + PEN_MASK_ROTATION* = 0x00000002 + PEN_MASK_TILT_X* = 0x00000004 + PEN_MASK_TILT_Y* = 0x00000008 + POINTER_MESSAGE_FLAG_NEW* = 0x00000001 + POINTER_MESSAGE_FLAG_INRANGE* = 0x00000002 + POINTER_MESSAGE_FLAG_INCONTACT* = 0x00000004 + POINTER_MESSAGE_FLAG_FIRSTBUTTON* = 0x00000010 + POINTER_MESSAGE_FLAG_SECONDBUTTON* = 0x00000020 + POINTER_MESSAGE_FLAG_THIRDBUTTON* = 0x00000040 + POINTER_MESSAGE_FLAG_FOURTHBUTTON* = 0x00000080 + POINTER_MESSAGE_FLAG_FIFTHBUTTON* = 0x00000100 + POINTER_MESSAGE_FLAG_PRIMARY* = 0x00002000 + POINTER_MESSAGE_FLAG_CONFIDENCE* = 0x00004000 + POINTER_MESSAGE_FLAG_CANCELED* = 0x00008000 + PA_ACTIVATE* = MA_ACTIVATE + PA_NOACTIVATE* = MA_NOACTIVATE + MAX_TOUCH_COUNT* = 256 + TOUCH_FEEDBACK_DEFAULT* = 0x1 + TOUCH_FEEDBACK_INDIRECT* = 0x2 + TOUCH_FEEDBACK_NONE* = 0x3 + TOUCH_HIT_TESTING_DEFAULT* = 0x0 + TOUCH_HIT_TESTING_CLIENT* = 0x1 + TOUCH_HIT_TESTING_NONE* = 0x2 + TOUCH_HIT_TESTING_PROXIMITY_CLOSEST* = 0x0 + TOUCH_HIT_TESTING_PROXIMITY_FARTHEST* = 0xfff + GWFS_INCLUDE_ANCESTORS* = 0x00000001 + PT_POINTER* = 0x00000001 + PT_TOUCH* = 0x00000002 + PT_PEN* = 0x00000003 + PT_MOUSE* = 0x00000004 + FEEDBACK_TOUCH_CONTACTVISUALIZATION* = 1 + FEEDBACK_PEN_BARRELVISUALIZATION* = 2 + FEEDBACK_PEN_TAP* = 3 + FEEDBACK_PEN_DOUBLETAP* = 4 + FEEDBACK_PEN_PRESSANDHOLD* = 5 + FEEDBACK_PEN_RIGHTTAP* = 6 + FEEDBACK_TOUCH_TAP* = 7 + FEEDBACK_TOUCH_DOUBLETAP* = 8 + FEEDBACK_TOUCH_PRESSANDHOLD* = 9 + FEEDBACK_TOUCH_RIGHTTAP* = 10 + FEEDBACK_GESTURE_PRESSANDTAP* = 11 + FEEDBACK_MAX* = 0xffffffff'i32 + POINTER_CHANGE_NONE* = 0 + POINTER_CHANGE_FIRSTBUTTON_DOWN* = 1 + POINTER_CHANGE_FIRSTBUTTON_UP* = 2 + POINTER_CHANGE_SECONDBUTTON_DOWN* = 3 + POINTER_CHANGE_SECONDBUTTON_UP* = 4 + POINTER_CHANGE_THIRDBUTTON_DOWN* = 5 + POINTER_CHANGE_THIRDBUTTON_UP* = 6 + POINTER_CHANGE_FOURTHBUTTON_DOWN* = 7 + POINTER_CHANGE_FOURTHBUTTON_UP* = 8 + POINTER_CHANGE_FIFTHBUTTON_DOWN* = 9 + POINTER_CHANGE_FIFTHBUTTON_UP* = 10 + MAPVK_VK_TO_VSC* = 0 + MAPVK_VSC_TO_VK* = 1 + MAPVK_VK_TO_CHAR* = 2 + MAPVK_VSC_TO_VK_EX* = 3 + MAPVK_VK_TO_VSC_EX* = 4 + MWMO_WAITALL* = 0x0001 + MWMO_ALERTABLE* = 0x0002 + MWMO_INPUTAVAILABLE* = 0x0004 + QS_ALLPOSTMESSAGE* = 0x0100 + QS_ALLEVENTS* = QS_INPUT or QS_POSTMESSAGE or QS_TIMER or QS_PAINT or QS_HOTKEY + QS_ALLINPUT* = QS_INPUT or QS_POSTMESSAGE or QS_TIMER or QS_PAINT or QS_HOTKEY or QS_SENDMESSAGE + USER_TIMER_MAXIMUM* = 0x7FFFFFFF + USER_TIMER_MINIMUM* = 0x0000000A + TIMERV_DEFAULT_COALESCING* = 0 + TIMERV_NO_COALESCING* = 0xffffffff'i32 + TIMERV_COALESCING_MIN* = 1 + TIMERV_COALESCING_MAX* = 0x7ffffff5 + SM_CXSCREEN* = 0 + SM_CYSCREEN* = 1 + SM_CXVSCROLL* = 2 + SM_CYHSCROLL* = 3 + SM_CYCAPTION* = 4 + SM_CXBORDER* = 5 + SM_CYBORDER* = 6 + SM_CXDLGFRAME* = 7 + SM_CYDLGFRAME* = 8 + SM_CYVTHUMB* = 9 + SM_CXHTHUMB* = 10 + SM_CXICON* = 11 + SM_CYICON* = 12 + SM_CXCURSOR* = 13 + SM_CYCURSOR* = 14 + SM_CYMENU* = 15 + SM_CXFULLSCREEN* = 16 + SM_CYFULLSCREEN* = 17 + SM_CYKANJIWINDOW* = 18 + SM_MOUSEPRESENT* = 19 + SM_CYVSCROLL* = 20 + SM_CXHSCROLL* = 21 + SM_DEBUG* = 22 + SM_SWAPBUTTON* = 23 + SM_RESERVED1* = 24 + SM_RESERVED2* = 25 + SM_RESERVED3* = 26 + SM_RESERVED4* = 27 + SM_CXMIN* = 28 + SM_CYMIN* = 29 + SM_CXSIZE* = 30 + SM_CYSIZE* = 31 + SM_CXFRAME* = 32 + SM_CYFRAME* = 33 + SM_CXMINTRACK* = 34 + SM_CYMINTRACK* = 35 + SM_CXDOUBLECLK* = 36 + SM_CYDOUBLECLK* = 37 + SM_CXICONSPACING* = 38 + SM_CYICONSPACING* = 39 + SM_MENUDROPALIGNMENT* = 40 + SM_PENWINDOWS* = 41 + SM_DBCSENABLED* = 42 + SM_CMOUSEBUTTONS* = 43 + SM_CXFIXEDFRAME* = SM_CXDLGFRAME + SM_CYFIXEDFRAME* = SM_CYDLGFRAME + SM_CXSIZEFRAME* = SM_CXFRAME + SM_CYSIZEFRAME* = SM_CYFRAME + SM_SECURE* = 44 + SM_CXEDGE* = 45 + SM_CYEDGE* = 46 + SM_CXMINSPACING* = 47 + SM_CYMINSPACING* = 48 + SM_CXSMICON* = 49 + SM_CYSMICON* = 50 + SM_CYSMCAPTION* = 51 + SM_CXSMSIZE* = 52 + SM_CYSMSIZE* = 53 + SM_CXMENUSIZE* = 54 + SM_CYMENUSIZE* = 55 + SM_ARRANGE* = 56 + SM_CXMINIMIZED* = 57 + SM_CYMINIMIZED* = 58 + SM_CXMAXTRACK* = 59 + SM_CYMAXTRACK* = 60 + SM_CXMAXIMIZED* = 61 + SM_CYMAXIMIZED* = 62 + SM_NETWORK* = 63 + SM_CLEANBOOT* = 67 + SM_CXDRAG* = 68 + SM_CYDRAG* = 69 + SM_SHOWSOUNDS* = 70 + SM_CXMENUCHECK* = 71 + SM_CYMENUCHECK* = 72 + SM_SLOWMACHINE* = 73 + SM_MIDEASTENABLED* = 74 + SM_MOUSEWHEELPRESENT* = 75 + SM_XVIRTUALSCREEN* = 76 + SM_YVIRTUALSCREEN* = 77 + SM_CXVIRTUALSCREEN* = 78 + SM_CYVIRTUALSCREEN* = 79 + SM_CMONITORS* = 80 + SM_SAMEDISPLAYFORMAT* = 81 + SM_IMMENABLED* = 82 + SM_CXFOCUSBORDER* = 83 + SM_CYFOCUSBORDER* = 84 + SM_TABLETPC* = 86 + SM_MEDIACENTER* = 87 + SM_STARTER* = 88 + SM_SERVERR2* = 89 + SM_MOUSEHORIZONTALWHEELPRESENT* = 91 + SM_CXPADDEDBORDER* = 92 + SM_DIGITIZER* = 94 + SM_MAXIMUMTOUCHES* = 95 + SM_CMETRICS* = 97 + SM_REMOTESESSION* = 0x1000 + SM_SHUTTINGDOWN* = 0x2000 + SM_REMOTECONTROL* = 0x2001 + SM_CARETBLINKINGENABLED* = 0x2002 + SM_CONVERTIBLESLATEMODE* = 0x2003 + SM_SYSTEMDOCKED* = 0x2004 + PMB_ACTIVE* = 0x00000001 + MNC_IGNORE* = 0 + MNC_CLOSE* = 1 + MNC_EXECUTE* = 2 + MNC_SELECT* = 3 + MNS_NOCHECK* = 0x80000000'i32 + MNS_MODELESS* = 0x40000000 + MNS_DRAGDROP* = 0x20000000 + MNS_AUTODISMISS* = 0x10000000 + MNS_NOTIFYBYPOS* = 0x08000000 + MNS_CHECKORBMP* = 0x04000000 + MIM_MAXHEIGHT* = 0x00000001 + MIM_BACKGROUND* = 0x00000002 + MIM_HELPID* = 0x00000004 + MIM_MENUDATA* = 0x00000008 + MIM_STYLE* = 0x00000010 + MIM_APPLYTOSUBMENUS* = 0x80000000'i32 + MND_CONTINUE* = 0 + MND_ENDMENU* = 1 + MNGOF_TOPGAP* = 0x00000001 + MNGOF_BOTTOMGAP* = 0x00000002 + MNGO_NOINTERFACE* = 0x00000000 + MNGO_NOERROR* = 0x00000001 + MIIM_STATE* = 0x00000001 + MIIM_ID* = 0x00000002 + MIIM_SUBMENU* = 0x00000004 + MIIM_CHECKMARKS* = 0x00000008 + MIIM_TYPE* = 0x00000010 + MIIM_DATA* = 0x00000020 + MIIM_STRING* = 0x00000040 + MIIM_BITMAP* = 0x00000080 + MIIM_FTYPE* = 0x00000100 + HBMMENU_CALLBACK* = HBITMAP(-1) + HBMMENU_SYSTEM* = HBITMAP 1 + HBMMENU_MBAR_RESTORE* = HBITMAP 2 + HBMMENU_MBAR_MINIMIZE* = HBITMAP 3 + HBMMENU_MBAR_CLOSE* = HBITMAP 5 + HBMMENU_MBAR_CLOSE_D* = HBITMAP 6 + HBMMENU_MBAR_MINIMIZE_D* = HBITMAP 7 + HBMMENU_POPUP_CLOSE* = HBITMAP 8 + HBMMENU_POPUP_RESTORE* = HBITMAP 9 + HBMMENU_POPUP_MAXIMIZE* = HBITMAP 10 + HBMMENU_POPUP_MINIMIZE* = HBITMAP 11 + GMDI_USEDISABLED* = 0x0001 + GMDI_GOINTOPOPUPS* = 0x0002 + TPM_LEFTBUTTON* = 0x0000 + TPM_RIGHTBUTTON* = 0x0002 + TPM_LEFTALIGN* = 0x0000 + TPM_CENTERALIGN* = 0x0004 + TPM_RIGHTALIGN* = 0x0008 + TPM_TOPALIGN* = 0x0000 + TPM_VCENTERALIGN* = 0x0010 + TPM_BOTTOMALIGN* = 0x0020 + TPM_HORIZONTAL* = 0x0000 + TPM_VERTICAL* = 0x0040 + TPM_NONOTIFY* = 0x0080 + TPM_RETURNCMD* = 0x0100 + TPM_RECURSE* = 0x0001 + TPM_HORPOSANIMATION* = 0x0400 + TPM_HORNEGANIMATION* = 0x0800 + TPM_VERPOSANIMATION* = 0x1000 + TPM_VERNEGANIMATION* = 0x2000 + TPM_NOANIMATION* = 0x4000 + TPM_LAYOUTRTL* = 0x8000 + TPM_WORKAREA* = 0x10000 + DOF_EXECUTABLE* = 0x8001 + DOF_DOCUMENT* = 0x8002 + DOF_DIRECTORY* = 0x8003 + DOF_MULTIPLE* = 0x8004 + DOF_PROGMAN* = 0x0001 + DOF_SHELLDATA* = 0x0002 + DO_DROPFILE* = 0x454C4946 + DO_PRINTFILE* = 0x544E5250 + DT_TOP* = 0x00000000 + DT_LEFT* = 0x00000000 + DT_CENTER* = 0x00000001 + DT_RIGHT* = 0x00000002 + DT_VCENTER* = 0x00000004 + DT_BOTTOM* = 0x00000008 + DT_WORDBREAK* = 0x00000010 + DT_SINGLELINE* = 0x00000020 + DT_EXPANDTABS* = 0x00000040 + DT_TABSTOP* = 0x00000080 + DT_NOCLIP* = 0x00000100 + DT_EXTERNALLEADING* = 0x00000200 + DT_CALCRECT* = 0x00000400 + DT_NOPREFIX* = 0x00000800 + DT_INTERNAL* = 0x00001000 + DT_EDITCONTROL* = 0x00002000 + DT_PATH_ELLIPSIS* = 0x00004000 + DT_END_ELLIPSIS* = 0x00008000 + DT_MODIFYSTRING* = 0x00010000 + DT_RTLREADING* = 0x00020000 + DT_WORD_ELLIPSIS* = 0x00040000 + DT_NOFULLWIDTHCHARBREAK* = 0x00080000 + DT_HIDEPREFIX* = 0x00100000 + DT_PREFIXONLY* = 0x00200000 + DST_COMPLEX* = 0x0000 + DST_TEXT* = 0x0001 + DST_PREFIXTEXT* = 0x0002 + DST_ICON* = 0x0003 + DST_BITMAP* = 0x0004 + DSS_NORMAL* = 0x0000 + DSS_UNION* = 0x0010 + DSS_DISABLED* = 0x0020 + DSS_MONO* = 0x0080 + DSS_HIDEPREFIX* = 0x0200 + DSS_PREFIXONLY* = 0x0400 + DSS_RIGHT* = 0x8000 + ASFW_ANY* = DWORD(-1) + LSFW_LOCK* = 1 + LSFW_UNLOCK* = 2 + DCX_WINDOW* = 0x00000001 + DCX_CACHE* = 0x00000002 + DCX_NORESETATTRS* = 0x00000004 + DCX_CLIPCHILDREN* = 0x00000008 + DCX_CLIPSIBLINGS* = 0x00000010 + DCX_PARENTCLIP* = 0x00000020 + DCX_EXCLUDERGN* = 0x00000040 + DCX_INTERSECTRGN* = 0x00000080 + DCX_EXCLUDEUPDATE* = 0x00000100 + DCX_INTERSECTUPDATE* = 0x00000200 + DCX_LOCKWINDOWUPDATE* = 0x00000400 + DCX_VALIDATE* = 0x00200000 + RDW_INVALIDATE* = 0x0001 + RDW_INTERNALPAINT* = 0x0002 + RDW_ERASE* = 0x0004 + RDW_VALIDATE* = 0x0008 + RDW_NOINTERNALPAINT* = 0x0010 + RDW_NOERASE* = 0x0020 + RDW_NOCHILDREN* = 0x0040 + RDW_ALLCHILDREN* = 0x0080 + RDW_UPDATENOW* = 0x0100 + RDW_ERASENOW* = 0x0200 + RDW_FRAME* = 0x0400 + RDW_NOFRAME* = 0x0800 + SW_SCROLLCHILDREN* = 0x0001 + SW_INVALIDATE* = 0x0002 + SW_ERASE* = 0x0004 + SW_SMOOTHSCROLL* = 0x0010 + ESB_ENABLE_BOTH* = 0x0000 + ESB_DISABLE_BOTH* = 0x0003 + ESB_DISABLE_LEFT* = 0x0001 + ESB_DISABLE_RIGHT* = 0x0002 + ESB_DISABLE_UP* = 0x0001 + ESB_DISABLE_DOWN* = 0x0002 + ESB_DISABLE_LTUP* = ESB_DISABLE_LEFT + ESB_DISABLE_RTDN* = ESB_DISABLE_RIGHT + HELPINFO_WINDOW* = 0x0001 + HELPINFO_MENUITEM* = 0x0002 + MB_OK* = 0x00000000 + MB_OKCANCEL* = 0x00000001 + MB_ABORTRETRYIGNORE* = 0x00000002 + MB_YESNOCANCEL* = 0x00000003 + MB_YESNO* = 0x00000004 + MB_RETRYCANCEL* = 0x00000005 + MB_CANCELTRYCONTINUE* = 0x00000006 + MB_ICONHAND* = 0x00000010 + MB_ICONQUESTION* = 0x00000020 + MB_ICONEXCLAMATION* = 0x00000030 + MB_ICONASTERISK* = 0x00000040 + MB_USERICON* = 0x00000080 + MB_ICONWARNING* = MB_ICONEXCLAMATION + MB_ICONERROR* = MB_ICONHAND + MB_ICONINFORMATION* = MB_ICONASTERISK + MB_ICONSTOP* = MB_ICONHAND + MB_DEFBUTTON1* = 0x00000000 + MB_DEFBUTTON2* = 0x00000100 + MB_DEFBUTTON3* = 0x00000200 + MB_DEFBUTTON4* = 0x00000300 + MB_APPLMODAL* = 0x00000000 + MB_SYSTEMMODAL* = 0x00001000 + MB_TASKMODAL* = 0x00002000 + MB_HELP* = 0x00004000 + MB_NOFOCUS* = 0x00008000 + MB_SETFOREGROUND* = 0x00010000 + MB_DEFAULT_DESKTOP_ONLY* = 0x00020000 + MB_TOPMOST* = 0x00040000 + MB_RIGHT* = 0x00080000 + MB_RTLREADING* = 0x00100000 + MB_SERVICE_NOTIFICATION* = 0x00200000 + MB_SERVICE_NOTIFICATION_NT3X* = 0x00040000 + MB_TYPEMASK* = 0x0000000F + MB_ICONMASK* = 0x000000F0 + MB_DEFMASK* = 0x00000F00 + MB_MODEMASK* = 0x00003000 + MB_MISCMASK* = 0x0000C000 + CWP_ALL* = 0x0000 + CWP_SKIPINVISIBLE* = 0x0001 + CWP_SKIPDISABLED* = 0x0002 + CWP_SKIPTRANSPARENT* = 0x0004 + CTLCOLOR_MSGBOX* = 0 + CTLCOLOR_EDIT* = 1 + CTLCOLOR_LISTBOX* = 2 + CTLCOLOR_BTN* = 3 + CTLCOLOR_DLG* = 4 + CTLCOLOR_SCROLLBAR* = 5 + CTLCOLOR_STATIC* = 6 + CTLCOLOR_MAX* = 7 + COLOR_SCROLLBAR* = 0 + COLOR_BACKGROUND* = 1 + COLOR_ACTIVECAPTION* = 2 + COLOR_INACTIVECAPTION* = 3 + COLOR_MENU* = 4 + COLOR_WINDOW* = 5 + COLOR_WINDOWFRAME* = 6 + COLOR_MENUTEXT* = 7 + COLOR_WINDOWTEXT* = 8 + COLOR_CAPTIONTEXT* = 9 + COLOR_ACTIVEBORDER* = 10 + COLOR_INACTIVEBORDER* = 11 + COLOR_APPWORKSPACE* = 12 + COLOR_HIGHLIGHT* = 13 + COLOR_HIGHLIGHTTEXT* = 14 + COLOR_BTNFACE* = 15 + COLOR_BTNSHADOW* = 16 + COLOR_GRAYTEXT* = 17 + COLOR_BTNTEXT* = 18 + COLOR_INACTIVECAPTIONTEXT* = 19 + COLOR_BTNHIGHLIGHT* = 20 + COLOR_3DDKSHADOW* = 21 + COLOR_3DLIGHT* = 22 + COLOR_INFOTEXT* = 23 + COLOR_INFOBK* = 24 + COLOR_HOTLIGHT* = 26 + COLOR_GRADIENTACTIVECAPTION* = 27 + COLOR_GRADIENTINACTIVECAPTION* = 28 + COLOR_MENUHILIGHT* = 29 + COLOR_MENUBAR* = 30 + COLOR_DESKTOP* = COLOR_BACKGROUND + COLOR_3DFACE* = COLOR_BTNFACE + COLOR_3DSHADOW* = COLOR_BTNSHADOW + COLOR_3DHIGHLIGHT* = COLOR_BTNHIGHLIGHT + COLOR_3DHILIGHT* = COLOR_BTNHIGHLIGHT + COLOR_BTNHILIGHT* = COLOR_BTNHIGHLIGHT + GW_HWNDFIRST* = 0 + GW_HWNDLAST* = 1 + GW_HWNDNEXT* = 2 + GW_HWNDPREV* = 3 + GW_OWNER* = 4 + GW_CHILD* = 5 + GW_ENABLEDPOPUP* = 6 + GW_MAX* = 6 + MF_INSERT* = 0x00000000 + MF_CHANGE* = 0x00000080 + MF_APPEND* = 0x00000100 + MF_DELETE* = 0x00000200 + MF_REMOVE* = 0x00001000 + MF_BYCOMMAND* = 0x00000000 + MF_BYPOSITION* = 0x00000400 + MF_SEPARATOR* = 0x00000800 + MF_ENABLED* = 0x00000000 + MF_GRAYED* = 0x00000001 + MF_DISABLED* = 0x00000002 + MF_UNCHECKED* = 0x00000000 + MF_CHECKED* = 0x00000008 + MF_USECHECKBITMAPS* = 0x00000200 + MF_STRING* = 0x00000000 + MF_BITMAP* = 0x00000004 + MF_OWNERDRAW* = 0x00000100 + MF_POPUP* = 0x00000010 + MF_MENUBARBREAK* = 0x00000020 + MF_MENUBREAK* = 0x00000040 + MF_UNHILITE* = 0x00000000 + MF_HILITE* = 0x00000080 + MF_DEFAULT* = 0x00001000 + MF_SYSMENU* = 0x00002000 + MF_HELP* = 0x00004000 + MF_RIGHTJUSTIFY* = 0x00004000 + MF_MOUSESELECT* = 0x00008000 + MF_END* = 0x00000080 + MFT_STRING* = MF_STRING + MFT_BITMAP* = MF_BITMAP + MFT_MENUBARBREAK* = MF_MENUBARBREAK + MFT_MENUBREAK* = MF_MENUBREAK + MFT_OWNERDRAW* = MF_OWNERDRAW + MFT_RADIOCHECK* = 0x00000200 + MFT_SEPARATOR* = MF_SEPARATOR + MFT_RIGHTORDER* = 0x00002000 + MFT_RIGHTJUSTIFY* = MF_RIGHTJUSTIFY + MFS_GRAYED* = 0x00000003 + MFS_DISABLED* = MFS_GRAYED + MFS_CHECKED* = MF_CHECKED + MFS_HILITE* = MF_HILITE + MFS_ENABLED* = MF_ENABLED + MFS_UNCHECKED* = MF_UNCHECKED + MFS_UNHILITE* = MF_UNHILITE + MFS_DEFAULT* = MF_DEFAULT + SC_SIZE* = 0xF000 + SC_MOVE* = 0xF010 + SC_MINIMIZE* = 0xF020 + SC_MAXIMIZE* = 0xF030 + SC_NEXTWINDOW* = 0xF040 + SC_PREVWINDOW* = 0xF050 + SC_CLOSE* = 0xF060 + SC_VSCROLL* = 0xF070 + SC_HSCROLL* = 0xF080 + SC_MOUSEMENU* = 0xF090 + SC_KEYMENU* = 0xF100 + SC_ARRANGE* = 0xF110 + SC_RESTORE* = 0xF120 + SC_TASKLIST* = 0xF130 + SC_SCREENSAVE* = 0xF140 + SC_HOTKEY* = 0xF150 + SC_DEFAULT* = 0xF160 + SC_MONITORPOWER* = 0xF170 + SC_CONTEXTHELP* = 0xF180 + SC_SEPARATOR* = 0xF00F + SCF_ISSECURE* = 0x00000001 + SC_ICON* = SC_MINIMIZE + SC_ZOOM* = SC_MAXIMIZE + IDC_ARROW* = MAKEINTRESOURCE(32512) + IDC_IBEAM* = MAKEINTRESOURCE(32513) + IDC_WAIT* = MAKEINTRESOURCE(32514) + IDC_CROSS* = MAKEINTRESOURCE(32515) + IDC_UPARROW* = MAKEINTRESOURCE(32516) + IDC_SIZE* = MAKEINTRESOURCE(32640) + IDC_ICON* = MAKEINTRESOURCE(32641) + IDC_SIZENWSE* = MAKEINTRESOURCE(32642) + IDC_SIZENESW* = MAKEINTRESOURCE(32643) + IDC_SIZEWE* = MAKEINTRESOURCE(32644) + IDC_SIZENS* = MAKEINTRESOURCE(32645) + IDC_SIZEALL* = MAKEINTRESOURCE(32646) + IDC_NO* = MAKEINTRESOURCE(32648) + IDC_HAND* = MAKEINTRESOURCE(32649) + IDC_APPSTARTING* = MAKEINTRESOURCE(32650) + IDC_HELP* = MAKEINTRESOURCE(32651) + IMAGE_BITMAP* = 0 + IMAGE_ICON* = 1 + IMAGE_CURSOR* = 2 + IMAGE_ENHMETAFILE* = 3 + LR_DEFAULTCOLOR* = 0x0000 + LR_MONOCHROME* = 0x0001 + LR_COLOR* = 0x0002 + LR_COPYRETURNORG* = 0x0004 + LR_COPYDELETEORG* = 0x0008 + LR_LOADFROMFILE* = 0x0010 + LR_LOADTRANSPARENT* = 0x0020 + LR_DEFAULTSIZE* = 0x0040 + LR_VGACOLOR* = 0x0080 + LR_LOADMAP3DCOLORS* = 0x1000 + LR_CREATEDIBSECTION* = 0x2000 + LR_COPYFROMRESOURCE* = 0x4000 + LR_SHARED* = 0x8000 + DI_MASK* = 0x0001 + DI_IMAGE* = 0x0002 + DI_NORMAL* = 0x0003 + DI_COMPAT* = 0x0004 + DI_DEFAULTSIZE* = 0x0008 + DI_NOMIRROR* = 0x0010 + RES_ICON* = 1 + RES_CURSOR* = 2 + OBM_CLOSE* = 32754 + OBM_UPARROW* = 32753 + OBM_DNARROW* = 32752 + OBM_RGARROW* = 32751 + OBM_LFARROW* = 32750 + OBM_REDUCE* = 32749 + OBM_ZOOM* = 32748 + OBM_RESTORE* = 32747 + OBM_REDUCED* = 32746 + OBM_ZOOMD* = 32745 + OBM_RESTORED* = 32744 + OBM_UPARROWD* = 32743 + OBM_DNARROWD* = 32742 + OBM_RGARROWD* = 32741 + OBM_LFARROWD* = 32740 + OBM_MNARROW* = 32739 + OBM_COMBO* = 32738 + OBM_UPARROWI* = 32737 + OBM_DNARROWI* = 32736 + OBM_RGARROWI* = 32735 + OBM_LFARROWI* = 32734 + OBM_OLD_CLOSE* = 32767 + OBM_SIZE* = 32766 + OBM_OLD_UPARROW* = 32765 + OBM_OLD_DNARROW* = 32764 + OBM_OLD_RGARROW* = 32763 + OBM_OLD_LFARROW* = 32762 + OBM_BTSIZE* = 32761 + OBM_CHECK* = 32760 + OBM_CHECKBOXES* = 32759 + OBM_BTNCORNERS* = 32758 + OBM_OLD_REDUCE* = 32757 + OBM_OLD_ZOOM* = 32756 + OBM_OLD_RESTORE* = 32755 + OCR_NORMAL* = 32512 + OCR_IBEAM* = 32513 + OCR_WAIT* = 32514 + OCR_CROSS* = 32515 + OCR_UP* = 32516 + OCR_SIZE* = 32640 + OCR_ICON* = 32641 + OCR_SIZENWSE* = 32642 + OCR_SIZENESW* = 32643 + OCR_SIZEWE* = 32644 + OCR_SIZENS* = 32645 + OCR_SIZEALL* = 32646 + OCR_ICOCUR* = 32647 + OCR_NO* = 32648 + OCR_HAND* = 32649 + OCR_APPSTARTING* = 32650 + OIC_SAMPLE* = 32512 + OIC_HAND* = 32513 + OIC_QUES* = 32514 + OIC_BANG* = 32515 + OIC_NOTE* = 32516 + OIC_WINLOGO* = 32517 + OIC_WARNING* = OIC_BANG + OIC_ERROR* = OIC_HAND + OIC_INFORMATION* = OIC_NOTE + OIC_SHIELD* = 32518 + ORD_LANGDRIVER* = 1 + IDI_APPLICATION* = MAKEINTRESOURCE(32512) + IDI_HAND* = MAKEINTRESOURCE(32513) + IDI_QUESTION* = MAKEINTRESOURCE(32514) + IDI_EXCLAMATION* = MAKEINTRESOURCE(32515) + IDI_ASTERISK* = MAKEINTRESOURCE(32516) + IDI_WINLOGO* = MAKEINTRESOURCE(32517) + IDI_SHIELD* = MAKEINTRESOURCE(32518) + IDI_WARNING* = IDI_EXCLAMATION + IDI_ERROR* = IDI_HAND + IDI_INFORMATION* = IDI_ASTERISK + IDOK* = 1 + IDCANCEL* = 2 + IDABORT* = 3 + IDRETRY* = 4 + IDIGNORE* = 5 + IDYES* = 6 + IDNO* = 7 + IDCLOSE* = 8 + IDHELP* = 9 + IDTRYAGAIN* = 10 + IDCONTINUE* = 11 + IDTIMEOUT* = 32000 + ES_LEFT* = 0x0000 + ES_CENTER* = 0x0001 + ES_RIGHT* = 0x0002 + ES_MULTILINE* = 0x0004 + ES_UPPERCASE* = 0x0008 + ES_LOWERCASE* = 0x0010 + ES_PASSWORD* = 0x0020 + ES_AUTOVSCROLL* = 0x0040 + ES_AUTOHSCROLL* = 0x0080 + ES_NOHIDESEL* = 0x0100 + ES_OEMCONVERT* = 0x0400 + ES_READONLY* = 0x0800 + ES_WANTRETURN* = 0x1000 + ES_NUMBER* = 0x2000 + EN_SETFOCUS* = 0x0100 + EN_KILLFOCUS* = 0x0200 + EN_CHANGE* = 0x0300 + EN_UPDATE* = 0x0400 + EN_ERRSPACE* = 0x0500 + EN_MAXTEXT* = 0x0501 + EN_HSCROLL* = 0x0601 + EN_VSCROLL* = 0x0602 + EN_ALIGN_LTR_EC* = 0x0700 + EN_ALIGN_RTL_EC* = 0x0701 + EC_LEFTMARGIN* = 0x0001 + EC_RIGHTMARGIN* = 0x0002 + EC_USEFONTINFO* = 0xffff + EMSIS_COMPOSITIONSTRING* = 0x0001 + EIMES_GETCOMPSTRATONCE* = 0x0001 + EIMES_CANCELCOMPSTRINFOCUS* = 0x0002 + EIMES_COMPLETECOMPSTRKILLFOCUS* = 0x0004 + EM_GETSEL* = 0x00B0 + EM_SETSEL* = 0x00B1 + EM_GETRECT* = 0x00B2 + EM_SETRECT* = 0x00B3 + EM_SETRECTNP* = 0x00B4 + EM_SCROLL* = 0x00B5 + EM_LINESCROLL* = 0x00B6 + EM_SCROLLCARET* = 0x00B7 + EM_GETMODIFY* = 0x00B8 + EM_SETMODIFY* = 0x00B9 + EM_GETLINECOUNT* = 0x00BA + EM_LINEINDEX* = 0x00BB + EM_SETHANDLE* = 0x00BC + EM_GETHANDLE* = 0x00BD + EM_GETTHUMB* = 0x00BE + EM_LINELENGTH* = 0x00C1 + EM_REPLACESEL* = 0x00C2 + EM_GETLINE* = 0x00C4 + EM_LIMITTEXT* = 0x00C5 + EM_CANUNDO* = 0x00C6 + EM_UNDO* = 0x00C7 + EM_FMTLINES* = 0x00C8 + EM_LINEFROMCHAR* = 0x00C9 + EM_SETTABSTOPS* = 0x00CB + EM_SETPASSWORDCHAR* = 0x00CC + EM_EMPTYUNDOBUFFER* = 0x00CD + EM_GETFIRSTVISIBLELINE* = 0x00CE + EM_SETREADONLY* = 0x00CF + EM_SETWORDBREAKPROC* = 0x00D0 + EM_GETWORDBREAKPROC* = 0x00D1 + EM_GETPASSWORDCHAR* = 0x00D2 + EM_SETMARGINS* = 0x00D3 + EM_GETMARGINS* = 0x00D4 + EM_SETLIMITTEXT* = EM_LIMITTEXT + EM_GETLIMITTEXT* = 0x00D5 + EM_POSFROMCHAR* = 0x00D6 + EM_CHARFROMPOS* = 0x00D7 + EM_SETIMESTATUS* = 0x00D8 + EM_GETIMESTATUS* = 0x00D9 + WB_LEFT* = 0 + WB_RIGHT* = 1 + WB_ISDELIMITER* = 2 + BS_PUSHBUTTON* = 0x00000000 + BS_DEFPUSHBUTTON* = 0x00000001 + BS_CHECKBOX* = 0x00000002 + BS_AUTOCHECKBOX* = 0x00000003 + BS_RADIOBUTTON* = 0x00000004 + BS_3STATE* = 0x00000005 + BS_AUTO3STATE* = 0x00000006 + BS_GROUPBOX* = 0x00000007 + BS_USERBUTTON* = 0x00000008 + BS_AUTORADIOBUTTON* = 0x00000009 + BS_PUSHBOX* = 0x0000000A + BS_OWNERDRAW* = 0x0000000B + BS_TYPEMASK* = 0x0000000F + BS_LEFTTEXT* = 0x00000020 + BS_TEXT* = 0x00000000 + BS_ICON* = 0x00000040 + BS_BITMAP* = 0x00000080 + BS_LEFT* = 0x00000100 + BS_RIGHT* = 0x00000200 + BS_CENTER* = 0x00000300 + BS_TOP* = 0x00000400 + BS_BOTTOM* = 0x00000800 + BS_VCENTER* = 0x00000C00 + BS_PUSHLIKE* = 0x00001000 + BS_MULTILINE* = 0x00002000 + BS_NOTIFY* = 0x00004000 + BS_FLAT* = 0x00008000 + BS_RIGHTBUTTON* = BS_LEFTTEXT + BN_CLICKED* = 0 + BN_PAINT* = 1 + BN_HILITE* = 2 + BN_UNHILITE* = 3 + BN_DISABLE* = 4 + BN_DOUBLECLICKED* = 5 + BN_PUSHED* = BN_HILITE + BN_UNPUSHED* = BN_UNHILITE + BN_DBLCLK* = BN_DOUBLECLICKED + BN_SETFOCUS* = 6 + BN_KILLFOCUS* = 7 + BM_GETCHECK* = 0x00F0 + BM_SETCHECK* = 0x00F1 + BM_GETSTATE* = 0x00F2 + BM_SETSTATE* = 0x00F3 + BM_SETSTYLE* = 0x00F4 + BM_CLICK* = 0x00F5 + BM_GETIMAGE* = 0x00F6 + BM_SETIMAGE* = 0x00F7 + BM_SETDONTCLICK* = 0x00f8 + BST_UNCHECKED* = 0x0000 + BST_CHECKED* = 0x0001 + BST_INDETERMINATE* = 0x0002 + BST_PUSHED* = 0x0004 + BST_FOCUS* = 0x0008 + SS_LEFT* = 0x00000000 + SS_CENTER* = 0x00000001 + SS_RIGHT* = 0x00000002 + SS_ICON* = 0x00000003 + SS_BLACKRECT* = 0x00000004 + SS_GRAYRECT* = 0x00000005 + SS_WHITERECT* = 0x00000006 + SS_BLACKFRAME* = 0x00000007 + SS_GRAYFRAME* = 0x00000008 + SS_WHITEFRAME* = 0x00000009 + SS_USERITEM* = 0x0000000A + SS_SIMPLE* = 0x0000000B + SS_LEFTNOWORDWRAP* = 0x0000000C + SS_OWNERDRAW* = 0x0000000D + SS_BITMAP* = 0x0000000E + SS_ENHMETAFILE* = 0x0000000F + SS_ETCHEDHORZ* = 0x00000010 + SS_ETCHEDVERT* = 0x00000011 + SS_ETCHEDFRAME* = 0x00000012 + SS_TYPEMASK* = 0x0000001F + SS_REALSIZECONTROL* = 0x00000040 + SS_NOPREFIX* = 0x00000080 + SS_NOTIFY* = 0x00000100 + SS_CENTERIMAGE* = 0x00000200 + SS_RIGHTJUST* = 0x00000400 + SS_REALSIZEIMAGE* = 0x00000800 + SS_SUNKEN* = 0x00001000 + SS_EDITCONTROL* = 0x00002000 + SS_ENDELLIPSIS* = 0x00004000 + SS_PATHELLIPSIS* = 0x00008000 + SS_WORDELLIPSIS* = 0x0000C000 + SS_ELLIPSISMASK* = 0x0000C000 + STM_SETICON* = 0x0170 + STM_GETICON* = 0x0171 + STM_SETIMAGE* = 0x0172 + STM_GETIMAGE* = 0x0173 + STN_CLICKED* = 0 + STN_DBLCLK* = 1 + STN_ENABLE* = 2 + STN_DISABLE* = 3 + STM_MSGMAX* = 0x0174 + WC_DIALOG* = MAKEINTATOM(0x8002) + DWL_MSGRESULT* = 0 + DWL_DLGPROC* = 4 + DWL_USER* = 8 + DWLP_MSGRESULT* = 0 + DWLP_DLGPROC* = DWLP_MSGRESULT+sizeof(LRESULT) +type + DLGPROC* = proc (P1: HWND, P2: UINT, P3: WPARAM, P4: LPARAM): INT_PTR {.stdcall.} +const + DWLP_USER* = DWLP_DLGPROC+sizeof(DLGPROC) + DDL_READWRITE* = 0x0000 + DDL_READONLY* = 0x0001 + DDL_HIDDEN* = 0x0002 + DDL_SYSTEM* = 0x0004 + DDL_DIRECTORY* = 0x0010 + DDL_ARCHIVE* = 0x0020 + DDL_POSTMSGS* = 0x2000 + DDL_DRIVES* = 0x4000 + DDL_EXCLUSIVE* = 0x8000 + DS_ABSALIGN* = 0x01 + DS_SYSMODAL* = 0x02 + DS_LOCALEDIT* = 0x20 + DS_SETFONT* = 0x40 + DS_MODALFRAME* = 0x80 + DS_NOIDLEMSG* = 0x100 + DS_SETFOREGROUND* = 0x200 + DS_3DLOOK* = 0x0004 + DS_FIXEDSYS* = 0x0008 + DS_NOFAILCREATE* = 0x0010 + DS_CONTROL* = 0x0400 + DS_CENTER* = 0x0800 + DS_CENTERMOUSE* = 0x1000 + DS_CONTEXTHELP* = 0x2000 + DS_SHELLFONT* = DS_SETFONT or DS_FIXEDSYS + DS_USEPIXELS* = 0x8000 + DM_GETDEFID* = WM_USER+0 + DM_SETDEFID* = WM_USER+1 + DM_REPOSITION* = WM_USER+2 + DC_HASDEFID* = 0x534B + DLGC_WANTARROWS* = 0x0001 + DLGC_WANTTAB* = 0x0002 + DLGC_WANTALLKEYS* = 0x0004 + DLGC_WANTMESSAGE* = 0x0004 + DLGC_HASSETSEL* = 0x0008 + DLGC_DEFPUSHBUTTON* = 0x0010 + DLGC_UNDEFPUSHBUTTON* = 0x0020 + DLGC_RADIOBUTTON* = 0x0040 + DLGC_WANTCHARS* = 0x0080 + DLGC_STATIC* = 0x0100 + DLGC_BUTTON* = 0x2000 + LB_CTLCODE* = 0 + LB_OKAY* = 0 + LB_ERR* = -1 + LB_ERRSPACE* = -2 + LBN_ERRSPACE* = -2 + LBN_SELCHANGE* = 1 + LBN_DBLCLK* = 2 + LBN_SELCANCEL* = 3 + LBN_SETFOCUS* = 4 + LBN_KILLFOCUS* = 5 + LB_ADDSTRING* = 0x0180 + LB_INSERTSTRING* = 0x0181 + LB_DELETESTRING* = 0x0182 + LB_SELITEMRANGEEX* = 0x0183 + LB_RESETCONTENT* = 0x0184 + LB_SETSEL* = 0x0185 + LB_SETCURSEL* = 0x0186 + LB_GETSEL* = 0x0187 + LB_GETCURSEL* = 0x0188 + LB_GETTEXT* = 0x0189 + LB_GETTEXTLEN* = 0x018A + LB_GETCOUNT* = 0x018B + LB_SELECTSTRING* = 0x018C + LB_DIR* = 0x018D + LB_GETTOPINDEX* = 0x018E + LB_FINDSTRING* = 0x018F + LB_GETSELCOUNT* = 0x0190 + LB_GETSELITEMS* = 0x0191 + LB_SETTABSTOPS* = 0x0192 + LB_GETHORIZONTALEXTENT* = 0x0193 + LB_SETHORIZONTALEXTENT* = 0x0194 + LB_SETCOLUMNWIDTH* = 0x0195 + LB_ADDFILE* = 0x0196 + LB_SETTOPINDEX* = 0x0197 + LB_GETITEMRECT* = 0x0198 + LB_GETITEMDATA* = 0x0199 + LB_SETITEMDATA* = 0x019A + LB_SELITEMRANGE* = 0x019B + LB_SETANCHORINDEX* = 0x019C + LB_GETANCHORINDEX* = 0x019D + LB_SETCARETINDEX* = 0x019E + LB_GETCARETINDEX* = 0x019F + LB_SETITEMHEIGHT* = 0x01A0 + LB_GETITEMHEIGHT* = 0x01A1 + LB_FINDSTRINGEXACT* = 0x01A2 + LB_SETLOCALE* = 0x01A5 + LB_GETLOCALE* = 0x01A6 + LB_SETCOUNT* = 0x01A7 + LB_INITSTORAGE* = 0x01A8 + LB_ITEMFROMPOINT* = 0x01A9 + LB_MULTIPLEADDSTRING* = 0x01B1 + LB_GETLISTBOXINFO* = 0x01B2 + LB_MSGMAX* = 0x01B3 + LBS_NOTIFY* = 0x0001 + LBS_SORT* = 0x0002 + LBS_NOREDRAW* = 0x0004 + LBS_MULTIPLESEL* = 0x0008 + LBS_OWNERDRAWFIXED* = 0x0010 + LBS_OWNERDRAWVARIABLE* = 0x0020 + LBS_HASSTRINGS* = 0x0040 + LBS_USETABSTOPS* = 0x0080 + LBS_NOINTEGRALHEIGHT* = 0x0100 + LBS_MULTICOLUMN* = 0x0200 + LBS_WANTKEYBOARDINPUT* = 0x0400 + LBS_EXTENDEDSEL* = 0x0800 + LBS_DISABLENOSCROLL* = 0x1000 + LBS_NODATA* = 0x2000 + LBS_NOSEL* = 0x4000 + LBS_COMBOBOX* = 0x8000 + LBS_STANDARD* = LBS_NOTIFY or LBS_SORT or WS_VSCROLL or WS_BORDER + CB_OKAY* = 0 + CB_ERR* = -1 + CB_ERRSPACE* = -2 + CBN_ERRSPACE* = -1 + CBN_SELCHANGE* = 1 + CBN_DBLCLK* = 2 + CBN_SETFOCUS* = 3 + CBN_KILLFOCUS* = 4 + CBN_EDITCHANGE* = 5 + CBN_EDITUPDATE* = 6 + CBN_DROPDOWN* = 7 + CBN_CLOSEUP* = 8 + CBN_SELENDOK* = 9 + CBN_SELENDCANCEL* = 10 + CBS_SIMPLE* = 0x0001 + CBS_DROPDOWN* = 0x0002 + CBS_DROPDOWNLIST* = 0x0003 + CBS_OWNERDRAWFIXED* = 0x0010 + CBS_OWNERDRAWVARIABLE* = 0x0020 + CBS_AUTOHSCROLL* = 0x0040 + CBS_OEMCONVERT* = 0x0080 + CBS_SORT* = 0x0100 + CBS_HASSTRINGS* = 0x0200 + CBS_NOINTEGRALHEIGHT* = 0x0400 + CBS_DISABLENOSCROLL* = 0x0800 + CBS_UPPERCASE* = 0x2000 + CBS_LOWERCASE* = 0x4000 + CB_GETEDITSEL* = 0x0140 + CB_LIMITTEXT* = 0x0141 + CB_SETEDITSEL* = 0x0142 + CB_ADDSTRING* = 0x0143 + CB_DELETESTRING* = 0x0144 + CB_DIR* = 0x0145 + CB_GETCOUNT* = 0x0146 + CB_GETCURSEL* = 0x0147 + CB_GETLBTEXT* = 0x0148 + CB_GETLBTEXTLEN* = 0x0149 + CB_INSERTSTRING* = 0x014A + CB_RESETCONTENT* = 0x014B + CB_FINDSTRING* = 0x014C + CB_SELECTSTRING* = 0x014D + CB_SETCURSEL* = 0x014E + CB_SHOWDROPDOWN* = 0x014F + CB_GETITEMDATA* = 0x0150 + CB_SETITEMDATA* = 0x0151 + CB_GETDROPPEDCONTROLRECT* = 0x0152 + CB_SETITEMHEIGHT* = 0x0153 + CB_GETITEMHEIGHT* = 0x0154 + CB_SETEXTENDEDUI* = 0x0155 + CB_GETEXTENDEDUI* = 0x0156 + CB_GETDROPPEDSTATE* = 0x0157 + CB_FINDSTRINGEXACT* = 0x0158 + CB_SETLOCALE* = 0x0159 + CB_GETLOCALE* = 0x015A + CB_GETTOPINDEX* = 0x015b + CB_SETTOPINDEX* = 0x015c + CB_GETHORIZONTALEXTENT* = 0x015d + CB_SETHORIZONTALEXTENT* = 0x015e + CB_GETDROPPEDWIDTH* = 0x015f + CB_SETDROPPEDWIDTH* = 0x0160 + CB_INITSTORAGE* = 0x0161 + CB_MULTIPLEADDSTRING* = 0x0163 + CB_GETCOMBOBOXINFO* = 0x0164 + CB_MSGMAX* = 0x0165 + SBS_HORZ* = 0x0000 + SBS_VERT* = 0x0001 + SBS_TOPALIGN* = 0x0002 + SBS_LEFTALIGN* = 0x0002 + SBS_BOTTOMALIGN* = 0x0004 + SBS_RIGHTALIGN* = 0x0004 + SBS_SIZEBOXTOPLEFTALIGN* = 0x0002 + SBS_SIZEBOXBOTTOMRIGHTALIGN* = 0x0004 + SBS_SIZEBOX* = 0x0008 + SBS_SIZEGRIP* = 0x0010 + SBM_SETPOS* = 0x00E0 + SBM_GETPOS* = 0x00E1 + SBM_SETRANGE* = 0x00E2 + SBM_SETRANGEREDRAW* = 0x00E6 + SBM_GETRANGE* = 0x00E3 + SBM_ENABLE_ARROWS* = 0x00E4 + SBM_SETSCROLLINFO* = 0x00E9 + SBM_GETSCROLLINFO* = 0x00EA + SBM_GETSCROLLBARINFO* = 0x00EB + SIF_RANGE* = 0x0001 + SIF_PAGE* = 0x0002 + SIF_POS* = 0x0004 + SIF_DISABLENOSCROLL* = 0x0008 + SIF_TRACKPOS* = 0x0010 + SIF_ALL* = SIF_RANGE or SIF_PAGE or SIF_POS or SIF_TRACKPOS + MDIS_ALLCHILDSTYLES* = 0x0001 + MDITILE_VERTICAL* = 0x0000 + MDITILE_HORIZONTAL* = 0x0001 + MDITILE_SKIPDISABLED* = 0x0002 + MDITILE_ZORDER* = 0x0004 + HELP_CONTEXT* = 0x0001 + HELP_QUIT* = 0x0002 + HELP_INDEX* = 0x0003 + HELP_CONTENTS* = 0x0003 + HELP_HELPONHELP* = 0x0004 + HELP_SETINDEX* = 0x0005 + HELP_SETCONTENTS* = 0x0005 + HELP_CONTEXTPOPUP* = 0x0008 + HELP_FORCEFILE* = 0x0009 + HELP_KEY* = 0x0101 + HELP_COMMAND* = 0x0102 + HELP_PARTIALKEY* = 0x0105 + HELP_MULTIKEY* = 0x0201 + HELP_SETWINPOS* = 0x0203 + HELP_CONTEXTMENU* = 0x000a + HELP_FINDER* = 0x000b + HELP_WM_HELP* = 0x000c + HELP_SETPOPUP_POS* = 0x000d + HELP_TCARD* = 0x8000 + HELP_TCARD_DATA* = 0x0010 + HELP_TCARD_OTHER_CALLER* = 0x0011 + IDH_NO_HELP* = 28440 + IDH_MISSING_CONTEXT* = 28441 + IDH_GENERIC_HELP_BUTTON* = 28442 + IDH_OK* = 28443 + IDH_CANCEL* = 28444 + IDH_HELP* = 28445 + GR_GDIOBJECTS* = 0 + GR_USEROBJECTS* = 1 + GR_GDIOBJECTS_PEAK* = 2 + GR_USEROBJECTS_PEAK* = 4 + GR_GLOBAL* = HANDLE(-2) + SPI_GETBEEP* = 0x0001 + SPI_SETBEEP* = 0x0002 + SPI_GETMOUSE* = 0x0003 + SPI_SETMOUSE* = 0x0004 + SPI_GETBORDER* = 0x0005 + SPI_SETBORDER* = 0x0006 + SPI_GETKEYBOARDSPEED* = 0x000A + SPI_SETKEYBOARDSPEED* = 0x000B + SPI_LANGDRIVER* = 0x000C + SPI_ICONHORIZONTALSPACING* = 0x000D + SPI_GETSCREENSAVETIMEOUT* = 0x000E + SPI_SETSCREENSAVETIMEOUT* = 0x000F + SPI_GETSCREENSAVEACTIVE* = 0x0010 + SPI_SETSCREENSAVEACTIVE* = 0x0011 + SPI_GETGRIDGRANULARITY* = 0x0012 + SPI_SETGRIDGRANULARITY* = 0x0013 + SPI_SETDESKWALLPAPER* = 0x0014 + SPI_SETDESKPATTERN* = 0x0015 + SPI_GETKEYBOARDDELAY* = 0x0016 + SPI_SETKEYBOARDDELAY* = 0x0017 + SPI_ICONVERTICALSPACING* = 0x0018 + SPI_GETICONTITLEWRAP* = 0x0019 + SPI_SETICONTITLEWRAP* = 0x001A + SPI_GETMENUDROPALIGNMENT* = 0x001B + SPI_SETMENUDROPALIGNMENT* = 0x001C + SPI_SETDOUBLECLKWIDTH* = 0x001D + SPI_SETDOUBLECLKHEIGHT* = 0x001E + SPI_GETICONTITLELOGFONT* = 0x001F + SPI_SETDOUBLECLICKTIME* = 0x0020 + SPI_SETMOUSEBUTTONSWAP* = 0x0021 + SPI_SETICONTITLELOGFONT* = 0x0022 + SPI_GETFASTTASKSWITCH* = 0x0023 + SPI_SETFASTTASKSWITCH* = 0x0024 + SPI_SETDRAGFULLWINDOWS* = 0x0025 + SPI_GETDRAGFULLWINDOWS* = 0x0026 + SPI_GETNONCLIENTMETRICS* = 0x0029 + SPI_SETNONCLIENTMETRICS* = 0x002A + SPI_GETMINIMIZEDMETRICS* = 0x002B + SPI_SETMINIMIZEDMETRICS* = 0x002C + SPI_GETICONMETRICS* = 0x002D + SPI_SETICONMETRICS* = 0x002E + SPI_SETWORKAREA* = 0x002F + SPI_GETWORKAREA* = 0x0030 + SPI_SETPENWINDOWS* = 0x0031 + SPI_GETHIGHCONTRAST* = 0x0042 + SPI_SETHIGHCONTRAST* = 0x0043 + SPI_GETKEYBOARDPREF* = 0x0044 + SPI_SETKEYBOARDPREF* = 0x0045 + SPI_GETSCREENREADER* = 0x0046 + SPI_SETSCREENREADER* = 0x0047 + SPI_GETANIMATION* = 0x0048 + SPI_SETANIMATION* = 0x0049 + SPI_GETFONTSMOOTHING* = 0x004A + SPI_SETFONTSMOOTHING* = 0x004B + SPI_SETDRAGWIDTH* = 0x004C + SPI_SETDRAGHEIGHT* = 0x004D + SPI_SETHANDHELD* = 0x004E + SPI_GETLOWPOWERTIMEOUT* = 0x004F + SPI_GETPOWEROFFTIMEOUT* = 0x0050 + SPI_SETLOWPOWERTIMEOUT* = 0x0051 + SPI_SETPOWEROFFTIMEOUT* = 0x0052 + SPI_GETLOWPOWERACTIVE* = 0x0053 + SPI_GETPOWEROFFACTIVE* = 0x0054 + SPI_SETLOWPOWERACTIVE* = 0x0055 + SPI_SETPOWEROFFACTIVE* = 0x0056 + SPI_SETCURSORS* = 0x0057 + SPI_SETICONS* = 0x0058 + SPI_GETDEFAULTINPUTLANG* = 0x0059 + SPI_SETDEFAULTINPUTLANG* = 0x005A + SPI_SETLANGTOGGLE* = 0x005B + SPI_GETWINDOWSEXTENSION* = 0x005C + SPI_SETMOUSETRAILS* = 0x005D + SPI_GETMOUSETRAILS* = 0x005E + SPI_SETSCREENSAVERRUNNING* = 0x0061 + SPI_SCREENSAVERRUNNING* = SPI_SETSCREENSAVERRUNNING + SPI_GETFILTERKEYS* = 0x0032 + SPI_SETFILTERKEYS* = 0x0033 + SPI_GETTOGGLEKEYS* = 0x0034 + SPI_SETTOGGLEKEYS* = 0x0035 + SPI_GETMOUSEKEYS* = 0x0036 + SPI_SETMOUSEKEYS* = 0x0037 + SPI_GETSHOWSOUNDS* = 0x0038 + SPI_SETSHOWSOUNDS* = 0x0039 + SPI_GETSTICKYKEYS* = 0x003A + SPI_SETSTICKYKEYS* = 0x003B + SPI_GETACCESSTIMEOUT* = 0x003C + SPI_SETACCESSTIMEOUT* = 0x003D + SPI_GETSERIALKEYS* = 0x003E + SPI_SETSERIALKEYS* = 0x003F + SPI_GETSOUNDSENTRY* = 0x0040 + SPI_SETSOUNDSENTRY* = 0x0041 + SPI_GETSNAPTODEFBUTTON* = 0x005F + SPI_SETSNAPTODEFBUTTON* = 0x0060 + SPI_GETMOUSEHOVERWIDTH* = 0x0062 + SPI_SETMOUSEHOVERWIDTH* = 0x0063 + SPI_GETMOUSEHOVERHEIGHT* = 0x0064 + SPI_SETMOUSEHOVERHEIGHT* = 0x0065 + SPI_GETMOUSEHOVERTIME* = 0x0066 + SPI_SETMOUSEHOVERTIME* = 0x0067 + SPI_GETWHEELSCROLLLINES* = 0x0068 + SPI_SETWHEELSCROLLLINES* = 0x0069 + SPI_GETMENUSHOWDELAY* = 0x006A + SPI_SETMENUSHOWDELAY* = 0x006B + SPI_GETWHEELSCROLLCHARS* = 0x006C + SPI_SETWHEELSCROLLCHARS* = 0x006D + SPI_GETSHOWIMEUI* = 0x006E + SPI_SETSHOWIMEUI* = 0x006F + SPI_GETMOUSESPEED* = 0x0070 + SPI_SETMOUSESPEED* = 0x0071 + SPI_GETSCREENSAVERRUNNING* = 0x0072 + SPI_GETDESKWALLPAPER* = 0x0073 + SPI_GETAUDIODESCRIPTION* = 0x0074 + SPI_SETAUDIODESCRIPTION* = 0x0075 + SPI_GETSCREENSAVESECURE* = 0x0076 + SPI_SETSCREENSAVESECURE* = 0x0077 + SPI_GETHUNGAPPTIMEOUT* = 0x0078 + SPI_SETHUNGAPPTIMEOUT* = 0x0079 + SPI_GETWAITTOKILLTIMEOUT* = 0x007a + SPI_SETWAITTOKILLTIMEOUT* = 0x007b + SPI_GETWAITTOKILLSERVICETIMEOUT* = 0x007c + SPI_SETWAITTOKILLSERVICETIMEOUT* = 0x007d + SPI_GETMOUSEDOCKTHRESHOLD* = 0x007e + SPI_SETMOUSEDOCKTHRESHOLD* = 0x007f + SPI_GETPENDOCKTHRESHOLD* = 0x0080 + SPI_SETPENDOCKTHRESHOLD* = 0x0081 + SPI_GETWINARRANGING* = 0x0082 + SPI_SETWINARRANGING* = 0x0083 + SPI_GETMOUSEDRAGOUTTHRESHOLD* = 0x0084 + SPI_SETMOUSEDRAGOUTTHRESHOLD* = 0x0085 + SPI_GETPENDRAGOUTTHRESHOLD* = 0x0086 + SPI_SETPENDRAGOUTTHRESHOLD* = 0x0087 + SPI_GETMOUSESIDEMOVETHRESHOLD* = 0x0088 + SPI_SETMOUSESIDEMOVETHRESHOLD* = 0x0089 + SPI_GETPENSIDEMOVETHRESHOLD* = 0x008a + SPI_SETPENSIDEMOVETHRESHOLD* = 0x008b + SPI_GETDRAGFROMMAXIMIZE* = 0x008c + SPI_SETDRAGFROMMAXIMIZE* = 0x008d + SPI_GETSNAPSIZING* = 0x008e + SPI_SETSNAPSIZING* = 0x008f + SPI_GETDOCKMOVING* = 0x0090 + SPI_SETDOCKMOVING* = 0x0091 + SPI_GETTOUCHPREDICTIONPARAMETERS* = 0x009c + SPI_SETTOUCHPREDICTIONPARAMETERS* = 0x009d + SPI_GETLOGICALDPIOVERRIDE* = 0x009e + SPI_SETLOGICALDPIOVERRIDE* = 0x009f + SPI_GETMOUSECORNERCLIPLENGTH* = 0x00a0 + SPI_SETMOUSECORNERCLIPLENGTH* = 0x00a1 + SPI_GETMENURECT* = 0x00a2 + SPI_SETMENURECT* = 0x00a3 + SPI_GETACTIVEWINDOWTRACKING* = 0x1000 + SPI_SETACTIVEWINDOWTRACKING* = 0x1001 + SPI_GETMENUANIMATION* = 0x1002 + SPI_SETMENUANIMATION* = 0x1003 + SPI_GETCOMBOBOXANIMATION* = 0x1004 + SPI_SETCOMBOBOXANIMATION* = 0x1005 + SPI_GETLISTBOXSMOOTHSCROLLING* = 0x1006 + SPI_SETLISTBOXSMOOTHSCROLLING* = 0x1007 + SPI_GETGRADIENTCAPTIONS* = 0x1008 + SPI_SETGRADIENTCAPTIONS* = 0x1009 + SPI_GETKEYBOARDCUES* = 0x100A + SPI_SETKEYBOARDCUES* = 0x100B + SPI_GETMENUUNDERLINES* = SPI_GETKEYBOARDCUES + SPI_SETMENUUNDERLINES* = SPI_SETKEYBOARDCUES + SPI_GETACTIVEWNDTRKZORDER* = 0x100C + SPI_SETACTIVEWNDTRKZORDER* = 0x100D + SPI_GETHOTTRACKING* = 0x100E + SPI_SETHOTTRACKING* = 0x100F + SPI_GETMENUFADE* = 0x1012 + SPI_SETMENUFADE* = 0x1013 + SPI_GETSELECTIONFADE* = 0x1014 + SPI_SETSELECTIONFADE* = 0x1015 + SPI_GETTOOLTIPANIMATION* = 0x1016 + SPI_SETTOOLTIPANIMATION* = 0x1017 + SPI_GETTOOLTIPFADE* = 0x1018 + SPI_SETTOOLTIPFADE* = 0x1019 + SPI_GETCURSORSHADOW* = 0x101A + SPI_SETCURSORSHADOW* = 0x101B + SPI_GETMOUSESONAR* = 0x101C + SPI_SETMOUSESONAR* = 0x101D + SPI_GETMOUSECLICKLOCK* = 0x101E + SPI_SETMOUSECLICKLOCK* = 0x101F + SPI_GETMOUSEVANISH* = 0x1020 + SPI_SETMOUSEVANISH* = 0x1021 + SPI_GETFLATMENU* = 0x1022 + SPI_SETFLATMENU* = 0x1023 + SPI_GETDROPSHADOW* = 0x1024 + SPI_SETDROPSHADOW* = 0x1025 + SPI_GETBLOCKSENDINPUTRESETS* = 0x1026 + SPI_SETBLOCKSENDINPUTRESETS* = 0x1027 + SPI_GETUIEFFECTS* = 0x103E + SPI_SETUIEFFECTS* = 0x103F + SPI_GETDISABLEOVERLAPPEDCONTENT* = 0x1040 + SPI_SETDISABLEOVERLAPPEDCONTENT* = 0x1041 + SPI_GETCLIENTAREAANIMATION* = 0x1042 + SPI_SETCLIENTAREAANIMATION* = 0x1043 + SPI_GETCLEARTYPE* = 0x1048 + SPI_SETCLEARTYPE* = 0x1049 + SPI_GETSPEECHRECOGNITION* = 0x104a + SPI_SETSPEECHRECOGNITION* = 0x104b + SPI_GETCARETBROWSING* = 0x104c + SPI_SETCARETBROWSING* = 0x104d + SPI_GETTHREADLOCALINPUTSETTINGS* = 0x104e + SPI_SETTHREADLOCALINPUTSETTINGS* = 0x104f + SPI_GETSYSTEMLANGUAGEBAR* = 0x1050 + SPI_SETSYSTEMLANGUAGEBAR* = 0x1051 + SPI_GETFOREGROUNDLOCKTIMEOUT* = 0x2000 + SPI_SETFOREGROUNDLOCKTIMEOUT* = 0x2001 + SPI_GETACTIVEWNDTRKTIMEOUT* = 0x2002 + SPI_SETACTIVEWNDTRKTIMEOUT* = 0x2003 + SPI_GETFOREGROUNDFLASHCOUNT* = 0x2004 + SPI_SETFOREGROUNDFLASHCOUNT* = 0x2005 + SPI_GETCARETWIDTH* = 0x2006 + SPI_SETCARETWIDTH* = 0x2007 + SPI_GETMOUSECLICKLOCKTIME* = 0x2008 + SPI_SETMOUSECLICKLOCKTIME* = 0x2009 + SPI_GETFONTSMOOTHINGTYPE* = 0x200A + SPI_SETFONTSMOOTHINGTYPE* = 0x200B + FE_FONTSMOOTHINGSTANDARD* = 0x0001 + FE_FONTSMOOTHINGCLEARTYPE* = 0x0002 + FE_FONTSMOOTHINGDOCKING* = 0x8000 + SPI_GETFONTSMOOTHINGCONTRAST* = 0x200C + SPI_SETFONTSMOOTHINGCONTRAST* = 0x200D + SPI_GETFOCUSBORDERWIDTH* = 0x200E + SPI_SETFOCUSBORDERWIDTH* = 0x200F + SPI_GETFOCUSBORDERHEIGHT* = 0x2010 + SPI_SETFOCUSBORDERHEIGHT* = 0x2011 + SPI_GETFONTSMOOTHINGORIENTATION* = 0x2012 + SPI_SETFONTSMOOTHINGORIENTATION* = 0x2013 + SPI_GETMINIMUMHITRADIUS* = 0x2014 + SPI_SETMINIMUMHITRADIUS* = 0x2015 + SPI_GETMESSAGEDURATION* = 0x2016 + SPI_SETMESSAGEDURATION* = 0x2017 + SPI_GETCONTACTVISUALIZATION* = 0x2018 + SPI_SETCONTACTVISUALIZATION* = 0x2019 + SPI_GETGESTUREVISUALIZATION* = 0x201a + SPI_SETGESTUREVISUALIZATION* = 0x201b + CONTACTVISUALIZATION_OFF* = 0x0000 + CONTACTVISUALIZATION_ON* = 0x0001 + CONTACTVISUALIZATION_PRESENTATIONMODE* = 0x0002 + GESTUREVISUALIZATION_OFF* = 0x0000 + GESTUREVISUALIZATION_ON* = 0x001f + GESTUREVISUALIZATION_TAP* = 0x0001 + GESTUREVISUALIZATION_DOUBLETAP* = 0x0002 + GESTUREVISUALIZATION_PRESSANDTAP* = 0x0004 + GESTUREVISUALIZATION_PRESSANDHOLD* = 0x0008 + GESTUREVISUALIZATION_RIGHTTAP* = 0x0010 + MAX_TOUCH_PREDICTION_FILTER_TAPS* = 3 + TOUCHPREDICTIONPARAMETERS_DEFAULT_LATENCY* = 8 + TOUCHPREDICTIONPARAMETERS_DEFAULT_SAMPLETIME* = 8 + TOUCHPREDICTIONPARAMETERS_DEFAULT_USE_HW_TIMESTAMP* = 1 + TOUCHPREDICTIONPARAMETERS_DEFAULT_RLS_DELTA* = 0.001f + TOUCHPREDICTIONPARAMETERS_DEFAULT_RLS_LAMBDA_MIN* = 0.9f + TOUCHPREDICTIONPARAMETERS_DEFAULT_RLS_LAMBDA_MAX* = 0.999f + TOUCHPREDICTIONPARAMETERS_DEFAULT_RLS_LAMBDA_LEARNING_RATE* = 0.001f + TOUCHPREDICTIONPARAMETERS_DEFAULT_RLS_EXPO_SMOOTH_ALPHA* = 0.99f + MAX_LOGICALDPIOVERRIDE* = 2 + MIN_LOGICALDPIOVERRIDE* = -2 + FE_FONTSMOOTHINGORIENTATIONBGR* = 0x0000 + FE_FONTSMOOTHINGORIENTATIONRGB* = 0x0001 + SPIF_UPDATEINIFILE* = 0x0001 + SPIF_SENDWININICHANGE* = 0x0002 + SPIF_SENDCHANGE* = SPIF_SENDWININICHANGE + METRICS_USEDEFAULT* = -1 + ARW_BOTTOMLEFT* = 0x0000 + ARW_BOTTOMRIGHT* = 0x0001 + ARW_TOPLEFT* = 0x0002 + ARW_TOPRIGHT* = 0x0003 + ARW_STARTMASK* = 0x0003 + ARW_STARTRIGHT* = 0x0001 + ARW_STARTTOP* = 0x0002 + ARW_LEFT* = 0x0000 + ARW_RIGHT* = 0x0000 + ARW_UP* = 0x0004 + ARW_DOWN* = 0x0004 + ARW_HIDE* = 0x0008 + SERKF_SERIALKEYSON* = 0x00000001 + SERKF_AVAILABLE* = 0x00000002 + SERKF_INDICATOR* = 0x00000004 + HCF_HIGHCONTRASTON* = 0x00000001 + HCF_AVAILABLE* = 0x00000002 + HCF_HOTKEYACTIVE* = 0x00000004 + HCF_CONFIRMHOTKEY* = 0x00000008 + HCF_HOTKEYSOUND* = 0x00000010 + HCF_INDICATOR* = 0x00000020 + HCF_HOTKEYAVAILABLE* = 0x00000040 + HCF_LOGONDESKTOP* = 0x00000100 + HCF_DEFAULTDESKTOP* = 0x00000200 + CDS_UPDATEREGISTRY* = 0x00000001 + CDS_TEST* = 0x00000002 + CDS_FULLSCREEN* = 0x00000004 + CDS_GLOBAL* = 0x00000008 + CDS_SET_PRIMARY* = 0x00000010 + CDS_VIDEOPARAMETERS* = 0x00000020 + CDS_ENABLE_UNSAFE_MODES* = 0x00000100 + CDS_DISABLE_UNSAFE_MODES* = 0x00000200 + CDS_RESET* = 0x40000000 + CDS_RESET_EX* = 0x20000000 + CDS_NORESET* = 0x10000000 + VP_COMMAND_GET* = 0x0001 + VP_COMMAND_SET* = 0x0002 + VP_FLAGS_TV_MODE* = 0x0001 + VP_FLAGS_TV_STANDARD* = 0x0002 + VP_FLAGS_FLICKER* = 0x0004 + VP_FLAGS_OVERSCAN* = 0x0008 + VP_FLAGS_MAX_UNSCALED* = 0x0010 + VP_FLAGS_POSITION* = 0x0020 + VP_FLAGS_BRIGHTNESS* = 0x0040 + VP_FLAGS_CONTRAST* = 0x0080 + VP_FLAGS_COPYPROTECT* = 0x0100 + VP_MODE_WIN_GRAPHICS* = 0x0001 + VP_MODE_TV_PLAYBACK* = 0x0002 + VP_TV_STANDARD_NTSC_M* = 0x0001 + VP_TV_STANDARD_NTSC_M_J* = 0x0002 + VP_TV_STANDARD_PAL_B* = 0x0004 + VP_TV_STANDARD_PAL_D* = 0x0008 + VP_TV_STANDARD_PAL_H* = 0x0010 + VP_TV_STANDARD_PAL_I* = 0x0020 + VP_TV_STANDARD_PAL_M* = 0x0040 + VP_TV_STANDARD_PAL_N* = 0x0080 + VP_TV_STANDARD_SECAM_B* = 0x0100 + VP_TV_STANDARD_SECAM_D* = 0x0200 + VP_TV_STANDARD_SECAM_G* = 0x0400 + VP_TV_STANDARD_SECAM_H* = 0x0800 + VP_TV_STANDARD_SECAM_K* = 0x1000 + VP_TV_STANDARD_SECAM_K1* = 0x2000 + VP_TV_STANDARD_SECAM_L* = 0x4000 + VP_TV_STANDARD_WIN_VGA* = 0x8000 + VP_TV_STANDARD_NTSC_433* = 0x00010000 + VP_TV_STANDARD_PAL_G* = 0x00020000 + VP_TV_STANDARD_PAL_60* = 0x00040000 + VP_TV_STANDARD_SECAM_L1* = 0x00080000 + VP_CP_TYPE_APS_TRIGGER* = 0x0001 + VP_CP_TYPE_MACROVISION* = 0x0002 + VP_CP_CMD_ACTIVATE* = 0x0001 + VP_CP_CMD_DEACTIVATE* = 0x0002 + VP_CP_CMD_CHANGE* = 0x0004 + DISP_CHANGE_SUCCESSFUL* = 0 + DISP_CHANGE_RESTART* = 1 + DISP_CHANGE_FAILED* = -1 + DISP_CHANGE_BADMODE* = -2 + DISP_CHANGE_NOTUPDATED* = -3 + DISP_CHANGE_BADFLAGS* = -4 + DISP_CHANGE_BADPARAM* = -5 + DISP_CHANGE_BADDUALVIEW* = -6 + ENUM_CURRENT_SETTINGS* = DWORD(-1) + ENUM_REGISTRY_SETTINGS* = DWORD(-2) + EDS_RAWMODE* = 0x00000002 + EDD_GET_DEVICE_INTERFACE_NAME* = 0x00000001 + FKF_FILTERKEYSON* = 0x00000001 + FKF_AVAILABLE* = 0x00000002 + FKF_HOTKEYACTIVE* = 0x00000004 + FKF_CONFIRMHOTKEY* = 0x00000008 + FKF_HOTKEYSOUND* = 0x00000010 + FKF_INDICATOR* = 0x00000020 + FKF_CLICKON* = 0x00000040 + SKF_STICKYKEYSON* = 0x00000001 + SKF_AVAILABLE* = 0x00000002 + SKF_HOTKEYACTIVE* = 0x00000004 + SKF_CONFIRMHOTKEY* = 0x00000008 + SKF_HOTKEYSOUND* = 0x00000010 + SKF_INDICATOR* = 0x00000020 + SKF_AUDIBLEFEEDBACK* = 0x00000040 + SKF_TRISTATE* = 0x00000080 + SKF_TWOKEYSOFF* = 0x00000100 + SKF_LALTLATCHED* = 0x10000000 + SKF_LCTLLATCHED* = 0x04000000 + SKF_LSHIFTLATCHED* = 0x01000000 + SKF_RALTLATCHED* = 0x20000000 + SKF_RCTLLATCHED* = 0x08000000 + SKF_RSHIFTLATCHED* = 0x02000000 + SKF_LWINLATCHED* = 0x40000000 + SKF_RWINLATCHED* = 0x80000000'i32 + SKF_LALTLOCKED* = 0x00100000 + SKF_LCTLLOCKED* = 0x00040000 + SKF_LSHIFTLOCKED* = 0x00010000 + SKF_RALTLOCKED* = 0x00200000 + SKF_RCTLLOCKED* = 0x00080000 + SKF_RSHIFTLOCKED* = 0x00020000 + SKF_LWINLOCKED* = 0x00400000 + SKF_RWINLOCKED* = 0x00800000 + MKF_MOUSEKEYSON* = 0x00000001 + MKF_AVAILABLE* = 0x00000002 + MKF_HOTKEYACTIVE* = 0x00000004 + MKF_CONFIRMHOTKEY* = 0x00000008 + MKF_HOTKEYSOUND* = 0x00000010 + MKF_INDICATOR* = 0x00000020 + MKF_MODIFIERS* = 0x00000040 + MKF_REPLACENUMBERS* = 0x00000080 + MKF_LEFTBUTTONSEL* = 0x10000000 + MKF_RIGHTBUTTONSEL* = 0x20000000 + MKF_LEFTBUTTONDOWN* = 0x01000000 + MKF_RIGHTBUTTONDOWN* = 0x02000000 + MKF_MOUSEMODE* = 0x80000000'i32 + ATF_TIMEOUTON* = 0x00000001 + ATF_ONOFFFEEDBACK* = 0x00000002 + SSGF_NONE* = 0 + SSGF_DISPLAY* = 3 + SSTF_NONE* = 0 + SSTF_CHARS* = 1 + SSTF_BORDER* = 2 + SSTF_DISPLAY* = 3 + SSWF_NONE* = 0 + SSWF_TITLE* = 1 + SSWF_WINDOW* = 2 + SSWF_DISPLAY* = 3 + SSWF_CUSTOM* = 4 + SSF_SOUNDSENTRYON* = 0x00000001 + SSF_AVAILABLE* = 0x00000002 + SSF_INDICATOR* = 0x00000004 + TKF_TOGGLEKEYSON* = 0x00000001 + TKF_AVAILABLE* = 0x00000002 + TKF_HOTKEYACTIVE* = 0x00000004 + TKF_CONFIRMHOTKEY* = 0x00000008 + TKF_HOTKEYSOUND* = 0x00000010 + TKF_INDICATOR* = 0x00000020 + SLE_ERROR* = 0x00000001 + SLE_MINORERROR* = 0x00000002 + SLE_WARNING* = 0x00000003 + MONITOR_DEFAULTTONULL* = 0x00000000 + MONITOR_DEFAULTTOPRIMARY* = 0x00000001 + MONITOR_DEFAULTTONEAREST* = 0x00000002 + MONITORINFOF_PRIMARY* = 0x00000001 + WINEVENT_OUTOFCONTEXT* = 0x0000 + WINEVENT_SKIPOWNTHREAD* = 0x0001 + WINEVENT_SKIPOWNPROCESS* = 0x0002 + WINEVENT_INCONTEXT* = 0x0004 + CHILDID_SELF* = 0 + INDEXID_OBJECT* = 0 + INDEXID_CONTAINER* = 0 + OBJID_WINDOW* = LONG 0x00000000 + OBJID_SYSMENU* = LONG 0xFFFFFFFF'i32 + OBJID_TITLEBAR* = LONG 0xFFFFFFFE'i32 + OBJID_MENU* = LONG 0xFFFFFFFD'i32 + OBJID_CLIENT* = LONG 0xFFFFFFFC'i32 + OBJID_VSCROLL* = LONG 0xFFFFFFFB'i32 + OBJID_HSCROLL* = LONG 0xFFFFFFFA'i32 + OBJID_SIZEGRIP* = LONG 0xFFFFFFF9'i32 + OBJID_CARET* = LONG 0xFFFFFFF8'i32 + OBJID_CURSOR* = LONG 0xFFFFFFF7'i32 + OBJID_ALERT* = LONG 0xFFFFFFF6'i32 + OBJID_SOUND* = LONG 0xFFFFFFF5'i32 + OBJID_QUERYCLASSNAMEIDX* = LONG 0xFFFFFFF4'i32 + OBJID_NATIVEOM* = LONG 0xFFFFFFF0'i32 + EVENT_MIN* = 0x00000001 + EVENT_MAX* = 0x7FFFFFFF + EVENT_SYSTEM_SOUND* = 0x0001 + EVENT_SYSTEM_ALERT* = 0x0002 + EVENT_SYSTEM_FOREGROUND* = 0x0003 + EVENT_SYSTEM_MENUSTART* = 0x0004 + EVENT_SYSTEM_MENUEND* = 0x0005 + EVENT_SYSTEM_MENUPOPUPSTART* = 0x0006 + EVENT_SYSTEM_MENUPOPUPEND* = 0x0007 + EVENT_SYSTEM_CAPTURESTART* = 0x0008 + EVENT_SYSTEM_CAPTUREEND* = 0x0009 + EVENT_SYSTEM_MOVESIZESTART* = 0x000A + EVENT_SYSTEM_MOVESIZEEND* = 0x000B + EVENT_SYSTEM_CONTEXTHELPSTART* = 0x000C + EVENT_SYSTEM_CONTEXTHELPEND* = 0x000D + EVENT_SYSTEM_DRAGDROPSTART* = 0x000E + EVENT_SYSTEM_DRAGDROPEND* = 0x000F + EVENT_SYSTEM_DIALOGSTART* = 0x0010 + EVENT_SYSTEM_DIALOGEND* = 0x0011 + EVENT_SYSTEM_SCROLLINGSTART* = 0x0012 + EVENT_SYSTEM_SCROLLINGEND* = 0x0013 + EVENT_SYSTEM_SWITCHSTART* = 0x0014 + EVENT_SYSTEM_SWITCHEND* = 0x0015 + EVENT_SYSTEM_MINIMIZESTART* = 0x0016 + EVENT_SYSTEM_MINIMIZEEND* = 0x0017 + EVENT_SYSTEM_DESKTOPSWITCH* = 0x0020 + EVENT_SYSTEM_SWITCHER_APPGRABBED* = 0x0024 + EVENT_SYSTEM_SWITCHER_APPOVERTARGET* = 0x0025 + EVENT_SYSTEM_SWITCHER_APPDROPPED* = 0x0026 + EVENT_SYSTEM_SWITCHER_CANCELLED* = 0x0027 + EVENT_SYSTEM_IME_KEY_NOTIFICATION* = 0x0029 + EVENT_SYSTEM_END* = 0x00ff + EVENT_OEM_DEFINED_START* = 0x0101 + EVENT_OEM_DEFINED_END* = 0x01ff + EVENT_UIA_EVENTID_START* = 0x4e00 + EVENT_UIA_EVENTID_END* = 0x4eff + EVENT_UIA_PROPID_START* = 0x7500 + EVENT_UIA_PROPID_END* = 0x75ff + EVENT_CONSOLE_CARET* = 0x4001 + EVENT_CONSOLE_UPDATE_REGION* = 0x4002 + EVENT_CONSOLE_UPDATE_SIMPLE* = 0x4003 + EVENT_CONSOLE_UPDATE_SCROLL* = 0x4004 + EVENT_CONSOLE_LAYOUT* = 0x4005 + EVENT_CONSOLE_START_APPLICATION* = 0x4006 + EVENT_CONSOLE_END_APPLICATION* = 0x4007 + CONSOLE_CARET_SELECTION* = 0x0001 + CONSOLE_CARET_VISIBLE* = 0x0002 + EVENT_CONSOLE_END* = 0x40ff + EVENT_OBJECT_CREATE* = 0x8000 + EVENT_OBJECT_DESTROY* = 0x8001 + EVENT_OBJECT_SHOW* = 0x8002 + EVENT_OBJECT_HIDE* = 0x8003 + EVENT_OBJECT_REORDER* = 0x8004 + EVENT_OBJECT_FOCUS* = 0x8005 + EVENT_OBJECT_SELECTION* = 0x8006 + EVENT_OBJECT_SELECTIONADD* = 0x8007 + EVENT_OBJECT_SELECTIONREMOVE* = 0x8008 + EVENT_OBJECT_SELECTIONWITHIN* = 0x8009 + EVENT_OBJECT_STATECHANGE* = 0x800A + EVENT_OBJECT_LOCATIONCHANGE* = 0x800B + EVENT_OBJECT_NAMECHANGE* = 0x800C + EVENT_OBJECT_DESCRIPTIONCHANGE* = 0x800D + EVENT_OBJECT_VALUECHANGE* = 0x800E + EVENT_OBJECT_PARENTCHANGE* = 0x800F + EVENT_OBJECT_HELPCHANGE* = 0x8010 + EVENT_OBJECT_DEFACTIONCHANGE* = 0x8011 + EVENT_OBJECT_ACCELERATORCHANGE* = 0x8012 + EVENT_OBJECT_INVOKED* = 0x8013 + EVENT_OBJECT_TEXTSELECTIONCHANGED* = 0x8014 + EVENT_OBJECT_CONTENTSCROLLED* = 0x8015 + EVENT_SYSTEM_ARRANGMENTPREVIEW* = 0x8016 + EVENT_OBJECT_CLOAKED* = 0x8017 + EVENT_OBJECT_UNCLOAKED* = 0x8018 + EVENT_OBJECT_LIVEREGIONCHANGED* = 0x8019 + EVENT_OBJECT_HOSTEDOBJECTSINVALIDATED* = 0x8020 + EVENT_OBJECT_DRAGSTART* = 0x8021 + EVENT_OBJECT_DRAGCANCEL* = 0x8022 + EVENT_OBJECT_DRAGCOMPLETE* = 0x8023 + EVENT_OBJECT_DRAGENTER* = 0x8024 + EVENT_OBJECT_DRAGLEAVE* = 0x8025 + EVENT_OBJECT_DRAGDROPPED* = 0x8026 + EVENT_OBJECT_IME_SHOW* = 0x8027 + EVENT_OBJECT_IME_HIDE* = 0x8028 + EVENT_OBJECT_IME_CHANGE* = 0x8029 + EVENT_OBJECT_END* = 0x80ff + EVENT_AIA_START* = 0xa000 + EVENT_AIA_END* = 0xafff + SOUND_SYSTEM_STARTUP* = 1 + SOUND_SYSTEM_SHUTDOWN* = 2 + SOUND_SYSTEM_BEEP* = 3 + SOUND_SYSTEM_ERROR* = 4 + SOUND_SYSTEM_QUESTION* = 5 + SOUND_SYSTEM_WARNING* = 6 + SOUND_SYSTEM_INFORMATION* = 7 + SOUND_SYSTEM_MAXIMIZE* = 8 + SOUND_SYSTEM_MINIMIZE* = 9 + SOUND_SYSTEM_RESTOREUP* = 10 + SOUND_SYSTEM_RESTOREDOWN* = 11 + SOUND_SYSTEM_APPSTART* = 12 + SOUND_SYSTEM_FAULT* = 13 + SOUND_SYSTEM_APPEND* = 14 + SOUND_SYSTEM_MENUCOMMAND* = 15 + SOUND_SYSTEM_MENUPOPUP* = 16 + CSOUND_SYSTEM* = 16 + ALERT_SYSTEM_INFORMATIONAL* = 1 + ALERT_SYSTEM_WARNING* = 2 + ALERT_SYSTEM_ERROR* = 3 + ALERT_SYSTEM_QUERY* = 4 + ALERT_SYSTEM_CRITICAL* = 5 + CALERT_SYSTEM* = 6 + GUI_CARETBLINKING* = 0x00000001 + GUI_INMOVESIZE* = 0x00000002 + GUI_INMENUMODE* = 0x00000004 + GUI_SYSTEMMENUMODE* = 0x00000008 + GUI_POPUPMENUMODE* = 0x00000010 + USER_DEFAULT_SCREEN_DPI* = 96 + STATE_SYSTEM_UNAVAILABLE* = 0x00000001 + STATE_SYSTEM_SELECTED* = 0x00000002 + STATE_SYSTEM_FOCUSED* = 0x00000004 + STATE_SYSTEM_PRESSED* = 0x00000008 + STATE_SYSTEM_CHECKED* = 0x00000010 + STATE_SYSTEM_MIXED* = 0x00000020 + STATE_SYSTEM_INDETERMINATE* = STATE_SYSTEM_MIXED + STATE_SYSTEM_READONLY* = 0x00000040 + STATE_SYSTEM_HOTTRACKED* = 0x00000080 + STATE_SYSTEM_DEFAULT* = 0x00000100 + STATE_SYSTEM_EXPANDED* = 0x00000200 + STATE_SYSTEM_COLLAPSED* = 0x00000400 + STATE_SYSTEM_BUSY* = 0x00000800 + STATE_SYSTEM_FLOATING* = 0x00001000 + STATE_SYSTEM_MARQUEED* = 0x00002000 + STATE_SYSTEM_ANIMATED* = 0x00004000 + STATE_SYSTEM_INVISIBLE* = 0x00008000 + STATE_SYSTEM_OFFSCREEN* = 0x00010000 + STATE_SYSTEM_SIZEABLE* = 0x00020000 + STATE_SYSTEM_MOVEABLE* = 0x00040000 + STATE_SYSTEM_SELFVOICING* = 0x00080000 + STATE_SYSTEM_FOCUSABLE* = 0x00100000 + STATE_SYSTEM_SELECTABLE* = 0x00200000 + STATE_SYSTEM_LINKED* = 0x00400000 + STATE_SYSTEM_TRAVERSED* = 0x00800000 + STATE_SYSTEM_MULTISELECTABLE* = 0x01000000 + STATE_SYSTEM_EXTSELECTABLE* = 0x02000000 + STATE_SYSTEM_ALERT_LOW* = 0x04000000 + STATE_SYSTEM_ALERT_MEDIUM* = 0x08000000 + STATE_SYSTEM_ALERT_HIGH* = 0x10000000 + STATE_SYSTEM_PROTECTED* = 0x20000000 + STATE_SYSTEM_VALID* = 0x3FFFFFFF + CURSOR_SHOWING* = 0x00000001 + CURSOR_SUPPRESSED* = 0x00000002 + WS_ACTIVECAPTION* = 0x0001 + GA_PARENT* = 1 + GA_ROOT* = 2 + GA_ROOTOWNER* = 3 + RIM_INPUT* = 0 + RIM_INPUTSINK* = 1 + RIM_TYPEMOUSE* = 0 + RIM_TYPEKEYBOARD* = 1 + RIM_TYPEHID* = 2 + RI_MOUSE_LEFT_BUTTON_DOWN* = 0x0001 + RI_MOUSE_LEFT_BUTTON_UP* = 0x0002 + RI_MOUSE_RIGHT_BUTTON_DOWN* = 0x0004 + RI_MOUSE_RIGHT_BUTTON_UP* = 0x0008 + RI_MOUSE_MIDDLE_BUTTON_DOWN* = 0x0010 + RI_MOUSE_MIDDLE_BUTTON_UP* = 0x0020 + RI_MOUSE_BUTTON_4_DOWN* = 0x0040 + RI_MOUSE_BUTTON_4_UP* = 0x0080 + RI_MOUSE_BUTTON_5_DOWN* = 0x0100 + RI_MOUSE_BUTTON_5_UP* = 0x0200 + RI_MOUSE_WHEEL* = 0x0400 + RI_MOUSE_BUTTON_1_DOWN* = RI_MOUSE_LEFT_BUTTON_DOWN + RI_MOUSE_BUTTON_1_UP* = RI_MOUSE_LEFT_BUTTON_UP + RI_MOUSE_BUTTON_2_DOWN* = RI_MOUSE_RIGHT_BUTTON_DOWN + RI_MOUSE_BUTTON_2_UP* = RI_MOUSE_RIGHT_BUTTON_UP + RI_MOUSE_BUTTON_3_DOWN* = RI_MOUSE_MIDDLE_BUTTON_DOWN + RI_MOUSE_BUTTON_3_UP* = RI_MOUSE_MIDDLE_BUTTON_UP + MOUSE_MOVE_RELATIVE* = 0 + MOUSE_MOVE_ABSOLUTE* = 1 + MOUSE_VIRTUAL_DESKTOP* = 0x02 + MOUSE_ATTRIBUTES_CHANGED* = 0x04 + MOUSE_MOVE_NOCOALESCE* = 0x08 + KEYBOARD_OVERRUN_MAKE_CODE* = 0xFF + RI_KEY_MAKE* = 0 + RI_KEY_BREAK* = 1 + RI_KEY_E0* = 2 + RI_KEY_E1* = 4 + RI_KEY_TERMSRV_SET_LED* = 8 + RI_KEY_TERMSRV_SHADOW* = 0x10 + RID_INPUT* = 0x10000003 + RID_HEADER* = 0x10000005 + RIDI_PREPARSEDDATA* = 0x20000005 + RIDI_DEVICENAME* = 0x20000007 + RIDI_DEVICEINFO* = 0x2000000b + RIDEV_REMOVE* = 0x00000001 + RIDEV_EXCLUDE* = 0x00000010 + RIDEV_PAGEONLY* = 0x00000020 + RIDEV_NOLEGACY* = 0x00000030 + RIDEV_INPUTSINK* = 0x00000100 + RIDEV_CAPTUREMOUSE* = 0x00000200 + RIDEV_NOHOTKEYS* = 0x00000200 + RIDEV_APPKEYS* = 0x00000400 + RIDEV_EXINPUTSINK* = 0x00001000 + RIDEV_DEVNOTIFY* = 0x00002000 + RIDEV_EXMODEMASK* = 0x000000F0 + GIDC_ARRIVAL* = 1 + GIDC_REMOVAL* = 2 + POINTER_DEVICE_PRODUCT_STRING_MAX* = 520 + PDC_ARRIVAL* = 0x001 + PDC_REMOVAL* = 0x002 + PDC_ORIENTATION_0* = 0x004 + PDC_ORIENTATION_90* = 0x008 + PDC_ORIENTATION_180* = 0x010 + PDC_ORIENTATION_270* = 0x020 + PDC_MODE_DEFAULT* = 0x040 + PDC_MODE_CENTERED* = 0x080 + PDC_MAPPING_CHANGE* = 0x100 + PDC_RESOLUTION* = 0x200 + PDC_ORIGIN* = 0x400 + PDC_MODE_ASPECTRATIOPRESERVED* = 0x800 + POINTER_DEVICE_TYPE_INTEGRATED_PEN* = 0x00000001 + POINTER_DEVICE_TYPE_EXTERNAL_PEN* = 0x00000002 + POINTER_DEVICE_TYPE_TOUCH* = 0x00000003 + POINTER_DEVICE_TYPE_MAX* = 0xffffffff'i32 + POINTER_DEVICE_CURSOR_TYPE_UNKNOWN* = 0x00000000 + POINTER_DEVICE_CURSOR_TYPE_TIP* = 0x00000001 + POINTER_DEVICE_CURSOR_TYPE_ERASER* = 0x00000002 + POINTER_DEVICE_CURSOR_TYPE_MAX* = 0xffffffff'i32 + MSGFLT_ADD* = 1 + MSGFLT_REMOVE* = 2 + MSGFLTINFO_NONE* = 0 + MSGFLTINFO_ALREADYALLOWED_FORWND* = 1 + MSGFLTINFO_ALREADYDISALLOWED_FORWND* = 2 + MSGFLTINFO_ALLOWED_HIGHER* = 3 + MSGFLT_RESET* = 0 + MSGFLT_ALLOW* = 1 + MSGFLT_DISALLOW* = 2 + GF_BEGIN* = 0x00000001 + GF_INERTIA* = 0x00000002 + GF_END* = 0x00000004 + GID_BEGIN* = 1 + GID_END* = 2 + GID_ZOOM* = 3 + GID_PAN* = 4 + GID_ROTATE* = 5 + GID_TWOFINGERTAP* = 6 + GID_PRESSANDTAP* = 7 + GID_ROLLOVER* = GID_PRESSANDTAP + GC_ALLGESTURES* = 0x00000001 + GC_ZOOM* = 0x00000001 + GC_PAN* = 0x00000001 + GC_PAN_WITH_SINGLE_FINGER_VERTICALLY* = 0x00000002 + GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY* = 0x00000004 + GC_PAN_WITH_GUTTER* = 0x00000008 + GC_PAN_WITH_INERTIA* = 0x00000010 + GC_ROTATE* = 0x00000001 + GC_TWOFINGERTAP* = 0x00000001 + GC_PRESSANDTAP* = 0x00000001 + GC_ROLLOVER* = GC_PRESSANDTAP + GESTURECONFIGMAXCOUNT* = 256 + GCF_INCLUDE_ANCESTORS* = 0x00000001 + NID_INTEGRATED_TOUCH* = 0x00000001 + NID_EXTERNAL_TOUCH* = 0x00000002 + NID_INTEGRATED_PEN* = 0x00000004 + NID_EXTERNAL_PEN* = 0x00000008 + NID_MULTI_INPUT* = 0x00000040 + NID_READY* = 0x00000080 + MAX_STR_BLOCKREASON* = 256 + IMDT_UNAVAILABLE* = 0x00000000 + IMDT_KEYBOARD* = 0x00000001 + IMDT_MOUSE* = 0x00000002 + IMDT_TOUCH* = 0x00000004 + IMDT_PEN* = 0x00000008 + IMO_UNAVAILABLE* = 0x00000000 + IMO_HARDWARE* = 0x00000001 + IMO_INJECTED* = 0x00000002 + IMO_SYSTEM* = 0x00000004 + AR_ENABLED* = 0x0 + AR_DISABLED* = 0x1 + AR_SUPPRESSED* = 0x2 + AR_REMOTESESSION* = 0x4 + AR_MULTIMON* = 0x8 + AR_NOSENSOR* = 0x10 + AR_NOT_SUPPORTED* = 0x20 + AR_DOCKED* = 0x40 + AR_LAPTOP* = 0x80 + ORIENTATION_PREFERENCE_NONE* = 0x0 + ORIENTATION_PREFERENCE_LANDSCAPE* = 0x1 + ORIENTATION_PREFERENCE_PORTRAIT* = 0x2 + ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED* = 0x4 + ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED* = 0x8 + RT_GROUP_CURSOR* = MAKEINTRESOURCE(1+DIFFERENCE) + RT_GROUP_ICON* = MAKEINTRESOURCE(3+DIFFERENCE) + SETWALLPAPER_DEFAULT* = cast[LPWSTR](-1) + WHEEL_PAGESCROLL* = 0xffffffff'i32 +type + TIMERPROC* = proc (P1: HWND, P2: UINT, P3: UINT_PTR, P4: DWORD): VOID {.stdcall.} + GRAYSTRINGPROC* = proc (P1: HDC, P2: LPARAM, P3: int32): WINBOOL {.stdcall.} + WNDENUMPROC* = proc (P1: HWND, P2: LPARAM): WINBOOL {.stdcall.} + HOOKPROC* = proc (code: int32, wParam: WPARAM, lParam: LPARAM): LRESULT {.stdcall.} + SENDASYNCPROC* = proc (P1: HWND, P2: UINT, P3: ULONG_PTR, P4: LRESULT): VOID {.stdcall.} + PROPENUMPROCA* = proc (P1: HWND, P2: LPCSTR, P3: HANDLE): WINBOOL {.stdcall.} + PROPENUMPROCW* = proc (P1: HWND, P2: LPCWSTR, P3: HANDLE): WINBOOL {.stdcall.} + PROPENUMPROCEXA* = proc (P1: HWND, P2: LPSTR, P3: HANDLE, P4: ULONG_PTR): WINBOOL {.stdcall.} + PROPENUMPROCEXW* = proc (P1: HWND, P2: LPWSTR, P3: HANDLE, P4: ULONG_PTR): WINBOOL {.stdcall.} + EDITWORDBREAKPROCA* = proc (lpch: LPSTR, ichCurrent: int32, cch: int32, code: int32): int32 {.stdcall.} + EDITWORDBREAKPROCW* = proc (lpch: LPWSTR, ichCurrent: int32, cch: int32, code: int32): int32 {.stdcall.} + DRAWSTATEPROC* = proc (hdc: HDC, lData: LPARAM, wData: WPARAM, cx: int32, cy: int32): WINBOOL {.stdcall.} + PREGISTERCLASSNAMEW* = proc (P1: LPCWSTR): BOOLEAN {.stdcall.} + MONITORENUMPROC* = proc (P1: HMONITOR, P2: HDC, P3: LPRECT, P4: LPARAM): WINBOOL {.stdcall.} + WINEVENTPROC* = proc (hWinEventHook: HWINEVENTHOOK, event: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG, idEventThread: DWORD, dwmsEventTime: DWORD): VOID {.stdcall.} + POINTER_INFO* {.pure.} = object + pointerType*: POINTER_INPUT_TYPE + pointerId*: UINT32 + frameId*: UINT32 + pointerFlags*: POINTER_FLAGS + sourceDevice*: HANDLE + hwndTarget*: HWND + ptPixelLocation*: POINT + ptHimetricLocation*: POINT + ptPixelLocationRaw*: POINT + ptHimetricLocationRaw*: POINT + dwTime*: DWORD + historyCount*: UINT32 + InputData*: INT32 + dwKeyStates*: DWORD + PerformanceCount*: UINT64 + ButtonChangeType*: POINTER_BUTTON_CHANGE_TYPE + POINTER_TOUCH_INFO* {.pure.} = object + pointerInfo*: POINTER_INFO + touchFlags*: TOUCH_FLAGS + touchMask*: TOUCH_MASK + rcContact*: RECT + rcContactRaw*: RECT + orientation*: UINT32 + pressure*: UINT32 + POINTER_PEN_INFO* {.pure.} = object + pointerInfo*: POINTER_INFO + penFlags*: PEN_FLAGS + penMask*: PEN_MASK + pressure*: UINT32 + rotation*: UINT32 + tiltX*: INT32 + tiltY*: INT32 + POINTER_DEVICE_INFO* {.pure.} = object + displayOrientation*: DWORD + device*: HANDLE + pointerDeviceType*: POINTER_DEVICE_TYPE + monitor*: HMONITOR + startingCursorId*: ULONG + maxActiveContacts*: USHORT + productString*: array[POINTER_DEVICE_PRODUCT_STRING_MAX, WCHAR] + POINTER_DEVICE_PROPERTY* {.pure.} = object + logicalMin*: INT32 + logicalMax*: INT32 + physicalMin*: INT32 + physicalMax*: INT32 + unit*: UINT32 + unitExponent*: UINT32 + usagePageId*: USHORT + usageId*: USHORT + POINTER_DEVICE_CURSOR_INFO* {.pure.} = object + cursorId*: UINT32 + cursor*: POINTER_DEVICE_CURSOR_TYPE + INPUT_MESSAGE_SOURCE* {.pure.} = object + deviceType*: INPUT_MESSAGE_DEVICE_TYPE + originId*: INPUT_MESSAGE_ORIGIN_ID + INPUT_TRANSFORM_UNION1_STRUCT1* {.pure.} = object + m11*: float32 + m12*: float32 + m13*: float32 + m14*: float32 + m21*: float32 + m22*: float32 + m23*: float32 + m24*: float32 + m31*: float32 + m32*: float32 + m33*: float32 + m34*: float32 + m41*: float32 + m42*: float32 + m43*: float32 + m44*: float32 + INPUT_TRANSFORM_UNION1* {.pure, union.} = object + struct1*: INPUT_TRANSFORM_UNION1_STRUCT1 + m*: array[4, array[4, float32]] + INPUT_TRANSFORM* {.pure.} = object + union1*: INPUT_TRANSFORM_UNION1 + MENUTEMPLATEA* {.pure.} = object + MENUTEMPLATEW* {.pure.} = object +proc wvsprintfA*(P1: LPSTR, P2: LPCSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc wvsprintfW*(P1: LPWSTR, P2: LPCWSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc wsprintfA*(P1: LPSTR, P2: LPCSTR): int32 {.winapi, cdecl, varargs, dynlib: "user32", importc.} +proc wsprintfW*(P1: LPWSTR, P2: LPCWSTR): int32 {.winapi, cdecl, varargs, dynlib: "user32", importc.} +proc LoadKeyboardLayoutA*(pwszKLID: LPCSTR, Flags: UINT): HKL {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadKeyboardLayoutW*(pwszKLID: LPCWSTR, Flags: UINT): HKL {.winapi, stdcall, dynlib: "user32", importc.} +proc ActivateKeyboardLayout*(hkl: HKL, Flags: UINT): HKL {.winapi, stdcall, dynlib: "user32", importc.} +proc ToUnicodeEx*(wVirtKey: UINT, wScanCode: UINT, lpKeyState: ptr BYTE, pwszBuff: LPWSTR, cchBuff: int32, wFlags: UINT, dwhkl: HKL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc UnloadKeyboardLayout*(hkl: HKL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardLayoutNameA*(pwszKLID: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardLayoutNameW*(pwszKLID: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardLayoutList*(nBuff: int32, lpList: ptr HKL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardLayout*(idThread: DWORD): HKL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMouseMovePointsEx*(cbSize: UINT, lppt: LPMOUSEMOVEPOINT, lpptBuf: LPMOUSEMOVEPOINT, nBufPoints: int32, resolution: DWORD): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDesktopA*(lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: LPDEVMODEA, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDesktopW*(lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: LPDEVMODEW, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDesktopExA*(lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: ptr DEVMODEA, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDesktopExW*(lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: ptr DEVMODEW, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenDesktopA*(lpszDesktop: LPCSTR, dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenDesktopW*(lpszDesktop: LPCWSTR, dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenInputDesktop*(dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDesktopsA*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCA, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDesktopsW*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCW, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDesktopWindows*(hDesktop: HDESK, lpfn: WNDENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SwitchDesktop*(hDesktop: HDESK): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetThreadDesktop*(hDesktop: HDESK): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseDesktop*(hDesktop: HDESK): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetThreadDesktop*(dwThreadId: DWORD): HDESK {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateWindowStationA*(lpwinsta: LPCSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateWindowStationW*(lpwinsta: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenWindowStationA*(lpszWinSta: LPCSTR, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HWINSTA {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenWindowStationW*(lpszWinSta: LPCWSTR, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HWINSTA {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumWindowStationsA*(lpEnumFunc: WINSTAENUMPROCA, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumWindowStationsW*(lpEnumFunc: WINSTAENUMPROCW, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseWindowStation*(hWinSta: HWINSTA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetProcessWindowStation*(hWinSta: HWINSTA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetProcessWindowStation*(): HWINSTA {.winapi, stdcall, dynlib: "user32", importc.} +proc SetUserObjectSecurity*(hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUserObjectSecurity*(hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUserObjectInformationA*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUserObjectInformationW*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetUserObjectInformationA*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetUserObjectInformationW*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsHungAppWindow*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DisableProcessWindowsGhosting*(): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterWindowMessageA*(lpString: LPCSTR): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterWindowMessageW*(lpString: LPCWSTR): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc TrackMouseEvent*(lpEventTrack: LPTRACKMOUSEEVENT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawEdge*(hdc: HDC, qrc: LPRECT, edge: UINT, grfFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawFrameControl*(P1: HDC, P2: LPRECT, P3: UINT, P4: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawCaption*(hwnd: HWND, hdc: HDC, lprect: ptr RECT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawAnimatedRects*(hwnd: HWND, idAni: int32, lprcFrom: ptr RECT, lprcTo: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMessageA*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMessageW*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc TranslateMessage*(lpMsg: ptr MSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DispatchMessageA*(lpMsg: ptr MSG): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DispatchMessageW*(lpMsg: ptr MSG): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMessageQueue*(cMessagesMax: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PeekMessageA*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PeekMessageW*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterHotKey*(hWnd: HWND, id: int32, fsModifiers: UINT, vk: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterHotKey*(hWnd: HWND, id: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ExitWindowsEx*(uFlags: UINT, dwReason: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SwapMouseButton*(fSwap: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMessagePos*(): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMessageTime*(): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMessageExtraInfo*(): LPARAM {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUnpredictedMessagePos*(): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWow64Message*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMessageExtraInfo*(lParam: LPARAM): LPARAM {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageTimeoutA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageTimeoutW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendNotifyMessageA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SendNotifyMessageW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageCallbackA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SendMessageCallbackW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc BroadcastSystemMessageExA*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO): LONG32 {.winapi, stdcall, dynlib: "user32", importc.} +proc BroadcastSystemMessageExW*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO): LONG32 {.winapi, stdcall, dynlib: "user32", importc.} +proc BroadcastSystemMessageA*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LONG32 {.winapi, stdcall, dynlib: "user32", importc.} +proc BroadcastSystemMessageW*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LONG32 {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterPowerSettingNotification*(hRecipient: HANDLE, PowerSettingGuid: LPCGUID, Flags: DWORD): HPOWERNOTIFY {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterPowerSettingNotification*(Handle: HPOWERNOTIFY): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterSuspendResumeNotification*(hRecipient: HANDLE, Flags: DWORD): HPOWERNOTIFY {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterSuspendResumeNotification*(Handle: HPOWERNOTIFY): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PostMessageA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PostMessageW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PostThreadMessageA*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PostThreadMessageW*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AttachThreadInput*(idAttach: DWORD, idAttachTo: DWORD, fAttach: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ReplyMessage*(lResult: LRESULT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc WaitMessage*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc WaitForInputIdle*(hProcess: HANDLE, dwMilliseconds: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc DefWindowProcA*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefWindowProcW*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc PostQuitMessage*(nExitCode: int32): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc InSendMessage*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InSendMessageEx*(lpReserved: LPVOID): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDoubleClickTime*(): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDoubleClickTime*(P1: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClassA*(lpWndClass: ptr WNDCLASSA): ATOM {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClassW*(lpWndClass: ptr WNDCLASSW): ATOM {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterClassA*(lpClassName: LPCSTR, hInstance: HINSTANCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterClassW*(lpClassName: LPCWSTR, hInstance: HINSTANCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassInfoA*(hInstance: HINSTANCE, lpClassName: LPCSTR, lpWndClass: LPWNDCLASSA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassInfoW*(hInstance: HINSTANCE, lpClassName: LPCWSTR, lpWndClass: LPWNDCLASSW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClassExA*(P1: ptr WNDCLASSEXA): ATOM {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClassExW*(P1: ptr WNDCLASSEXW): ATOM {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassInfoExA*(hInstance: HINSTANCE, lpszClass: LPCSTR, lpwcx: LPWNDCLASSEXA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassInfoExW*(hInstance: HINSTANCE, lpszClass: LPCWSTR, lpwcx: LPWNDCLASSEXW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CallWindowProcA*(lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc CallWindowProcW*(lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterDeviceNotificationA*(hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD): HDEVNOTIFY {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterDeviceNotificationW*(hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD): HDEVNOTIFY {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterDeviceNotification*(Handle: HDEVNOTIFY): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateWindowExA*(dwExStyle: DWORD, lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateWindowExW*(dwExStyle: DWORD, lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWindow*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsMenu*(hMenu: HMENU): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsChild*(hWndParent: HWND, hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyWindow*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowWindow*(hWnd: HWND, nCmdShow: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AnimateWindow*(hWnd: HWND, dwTime: DWORD, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UpdateLayeredWindow*(hWnd: HWND, hdcDst: HDC, pptDst: ptr POINT, psize: ptr SIZE, hdcSrc: HDC, pptSrc: ptr POINT, crKey: COLORREF, pblend: ptr BLENDFUNCTION, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UpdateLayeredWindowIndirect*(hWnd: HWND, pULWInfo: ptr UPDATELAYEREDWINDOWINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetLayeredWindowAttributes*(hwnd: HWND, pcrKey: ptr COLORREF, pbAlpha: ptr BYTE, pdwFlags: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PrintWindow*(hwnd: HWND, hdcBlt: HDC, nFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetLayeredWindowAttributes*(hwnd: HWND, crKey: COLORREF, bAlpha: BYTE, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowWindowAsync*(hWnd: HWND, nCmdShow: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc FlashWindow*(hWnd: HWND, bInvert: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc FlashWindowEx*(pfwi: PFLASHWINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowOwnedPopups*(hWnd: HWND, fShow: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenIcon*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseWindow*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MoveWindow*(hWnd: HWND, X: int32, Y: int32, nWidth: int32, nHeight: int32, bRepaint: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowPos*(hWnd: HWND, hWndInsertAfter: HWND, X: int32, Y: int32, cx: int32, cy: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowPlacement*(hWnd: HWND, lpwndpl: ptr WINDOWPLACEMENT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowPlacement*(hWnd: HWND, lpwndpl: ptr WINDOWPLACEMENT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowDisplayAffinity*(hWnd: HWND, pdwAffinity: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowDisplayAffinity*(hWnd: HWND, dwAffinity: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc BeginDeferWindowPos*(nNumWindows: int32): HDWP {.winapi, stdcall, dynlib: "user32", importc.} +proc DeferWindowPos*(hWinPosInfo: HDWP, hWnd: HWND, hWndInsertAfter: HWND, x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): HDWP {.winapi, stdcall, dynlib: "user32", importc.} +proc EndDeferWindowPos*(hWinPosInfo: HDWP): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWindowVisible*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsIconic*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AnyPopup*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc BringWindowToTop*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsZoomed*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDialogParamA*(hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDialogParamW*(hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDialogIndirectParamA*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateDialogIndirectParamW*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc DialogBoxParamA*(hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc DialogBoxParamW*(hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc DialogBoxIndirectParamA*(hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc DialogBoxIndirectParamW*(hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc EndDialog*(hDlg: HWND, nResult: INT_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDlgItem*(hDlg: HWND, nIDDlgItem: int32): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDlgItemInt*(hDlg: HWND, nIDDlgItem: int32, uValue: UINT, bSigned: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDlgItemInt*(hDlg: HWND, nIDDlgItem: int32, lpTranslated: ptr WINBOOL, bSigned: WINBOOL): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDlgItemTextA*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDlgItemTextW*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDlgItemTextA*(hDlg: HWND, nIDDlgItem: int32, lpString: LPSTR, cchMax: int32): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDlgItemTextW*(hDlg: HWND, nIDDlgItem: int32, lpString: LPWSTR, cchMax: int32): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc CheckDlgButton*(hDlg: HWND, nIDButton: int32, uCheck: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CheckRadioButton*(hDlg: HWND, nIDFirstButton: int32, nIDLastButton: int32, nIDCheckButton: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsDlgButtonChecked*(hDlg: HWND, nIDButton: int32): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendDlgItemMessageA*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc SendDlgItemMessageW*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetNextDlgGroupItem*(hDlg: HWND, hCtl: HWND, bPrevious: WINBOOL): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetNextDlgTabItem*(hDlg: HWND, hCtl: HWND, bPrevious: WINBOOL): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDlgCtrlID*(hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDialogBaseUnits*(): LONG32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DefDlgProcA*(hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefDlgProcW*(hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc CallMsgFilterA*(lpMsg: LPMSG, nCode: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CallMsgFilterW*(lpMsg: LPMSG, nCode: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OpenClipboard*(hWndNewOwner: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseClipboard*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardSequenceNumber*(): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardOwner*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetClipboardViewer*(hWndNewViewer: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardViewer*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeClipboardChain*(hWndRemove: HWND, hWndNewNext: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetClipboardData*(uFormat: UINT, hMem: HANDLE): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardData*(uFormat: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClipboardFormatA*(lpszFormat: LPCSTR): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterClipboardFormatW*(lpszFormat: LPCWSTR): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc CountClipboardFormats*(): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumClipboardFormats*(format: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardFormatNameA*(format: UINT, lpszFormatName: LPSTR, cchMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipboardFormatNameW*(format: UINT, lpszFormatName: LPWSTR, cchMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc EmptyClipboard*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsClipboardFormatAvailable*(format: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPriorityClipboardFormat*(paFormatPriorityList: ptr UINT, cFormats: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetOpenClipboardWindow*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc AddClipboardFormatListener*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RemoveClipboardFormatListener*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUpdatedClipboardFormats*(lpuiFormats: PUINT, cFormats: UINT, pcFormatsOut: PUINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CharToOemA*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CharToOemW*(lpszSrc: LPCWSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OemToCharA*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OemToCharW*(lpszSrc: LPCSTR, lpszDst: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CharToOemBuffA*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CharToOemBuffW*(lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OemToCharBuffA*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OemToCharBuffW*(lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CharUpperA*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharUpperW*(lpsz: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharUpperBuffA*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc CharUpperBuffW*(lpsz: LPWSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc CharLowerA*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharLowerW*(lpsz: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharLowerBuffA*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc CharLowerBuffW*(lpsz: LPWSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc CharNextA*(lpsz: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharNextW*(lpsz: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharPrevA*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharPrevW*(lpszStart: LPCWSTR, lpszCurrent: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharNextExA*(CodePage: WORD, lpCurrentChar: LPCSTR, dwFlags: DWORD): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc CharPrevExA*(CodePage: WORD, lpStart: LPCSTR, lpCurrentChar: LPCSTR, dwFlags: DWORD): LPSTR {.winapi, stdcall, dynlib: "user32", importc.} +proc AnsiToOem*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemA".} +proc OemToAnsi*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharA".} +proc AnsiToOemBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemBuffA".} +proc OemToAnsiBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharBuffA".} +proc AnsiUpper*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharUpperA".} +proc AnsiUpperBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharUpperBuffA".} +proc AnsiLower*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharLowerA".} +proc AnsiLowerBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharLowerBuffA".} +proc AnsiNext*(lpsz: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharNextA".} +proc AnsiPrev*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharPrevA".} +proc IsCharAlphaA*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharAlphaW*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharAlphaNumericA*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharAlphaNumericW*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharUpperA*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharUpperW*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharLowerA*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsCharLowerW*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetFocus*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetActiveWindow*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetFocus*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKBCodePage*(): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyState*(nVirtKey: int32): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetAsyncKeyState*(vKey: int32): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardState*(lpKeyState: PBYTE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetKeyboardState*(lpKeyState: LPBYTE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyNameTextA*(lParam: LONG, lpString: LPSTR, cchSize: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyNameTextW*(lParam: LONG, lpString: LPWSTR, cchSize: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetKeyboardType*(nTypeFlag: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc ToAscii*(uVirtKey: UINT, uScanCode: UINT, lpKeyState: ptr BYTE, lpChar: LPWORD, uFlags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc ToAsciiEx*(uVirtKey: UINT, uScanCode: UINT, lpKeyState: ptr BYTE, lpChar: LPWORD, uFlags: UINT, dwhkl: HKL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc ToUnicode*(wVirtKey: UINT, wScanCode: UINT, lpKeyState: ptr BYTE, pwszBuff: LPWSTR, cchBuff: int32, wFlags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc OemKeyScan*(wOemChar: WORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc VkKeyScanA*(ch: CHAR): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc VkKeyScanW*(ch: WCHAR): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc VkKeyScanExA*(ch: CHAR, dwhkl: HKL): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc VkKeyScanExW*(ch: WCHAR, dwhkl: HKL): SHORT {.winapi, stdcall, dynlib: "user32", importc.} +proc keybd_event*(bVk: BYTE, bScan: BYTE, dwFlags: DWORD, dwExtraInfo: ULONG_PTR): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc mouse_event*(dwFlags: DWORD, dx: DWORD, dy: DWORD, dwData: DWORD, dwExtraInfo: ULONG_PTR): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc SendInput*(cInputs: UINT, pInputs: LPINPUT, cbSize: int32): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetTouchInputInfo*(hTouchInput: HTOUCHINPUT, cInputs: UINT, pInputs: PTOUCHINPUT, cbSize: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseTouchInputHandle*(hTouchInput: HTOUCHINPUT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterTouchWindow*(hwnd: HWND, ulFlags: ULONG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterTouchWindow*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsTouchWindow*(hwnd: HWND, pulFlags: PULONG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InitializeTouchInjection*(maxCount: UINT32, dwMode: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InjectTouchInput*(count: UINT32, contacts: ptr POINTER_TOUCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerType*(pointerId: UINT32, pointerType: ptr POINTER_INPUT_TYPE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerCursorId*(pointerId: UINT32, cursorId: ptr UINT32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerInfo*(pointerId: UINT32, pointerInfo: ptr POINTER_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, pointerInfo: ptr POINTER_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFrameInfo*(pointerId: UINT32, pointerCount: ptr UINT32, pointerInfo: ptr POINTER_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFrameInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, pointerCount: ptr UINT32, pointerInfo: ptr POINTER_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerTouchInfo*(pointerId: UINT32, touchInfo: ptr POINTER_TOUCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerTouchInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, touchInfo: ptr POINTER_TOUCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFrameTouchInfo*(pointerId: UINT32, pointerCount: ptr UINT32, touchInfo: ptr POINTER_TOUCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFrameTouchInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, pointerCount: ptr UINT32, touchInfo: ptr POINTER_TOUCH_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerPenInfo*(pointerId: UINT32, penInfo: ptr POINTER_PEN_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerPenInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, penInfo: ptr POINTER_PEN_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFramePenInfo*(pointerId: UINT32, pointerCount: ptr UINT32, penInfo: ptr POINTER_PEN_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerFramePenInfoHistory*(pointerId: UINT32, entriesCount: ptr UINT32, pointerCount: ptr UINT32, penInfo: ptr POINTER_PEN_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SkipPointerFrameMessages*(pointerId: UINT32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterPointerInputTarget*(hwnd: HWND, pointerType: POINTER_INPUT_TYPE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnregisterPointerInputTarget*(hwnd: HWND, pointerType: POINTER_INPUT_TYPE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnableMouseInPointer*(fEnable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsMouseInPointerEnabled*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterTouchHitTestingWindow*(hwnd: HWND, value: ULONG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EvaluateProximityToRect*(controlBoundingBox: ptr RECT, pHitTestingInput: ptr TOUCH_HIT_TESTING_INPUT, pProximityEval: ptr TOUCH_HIT_TESTING_PROXIMITY_EVALUATION): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EvaluateProximityToPolygon*(numVertices: UINT32, controlPolygon: ptr POINT, pHitTestingInput: ptr TOUCH_HIT_TESTING_INPUT, pProximityEval: ptr TOUCH_HIT_TESTING_PROXIMITY_EVALUATION): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PackTouchHitTestingProximityEvaluation*(pHitTestingInput: ptr TOUCH_HIT_TESTING_INPUT, pProximityEval: ptr TOUCH_HIT_TESTING_PROXIMITY_EVALUATION): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowFeedbackSetting*(hwnd: HWND, feedback: FEEDBACK_TYPE, dwFlags: DWORD, pSize: ptr UINT32, config: pointer): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowFeedbackSetting*(hwnd: HWND, feedback: FEEDBACK_TYPE, dwFlags: DWORD, size: UINT32, configuration: pointer): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetLastInputInfo*(plii: PLASTINPUTINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MapVirtualKeyA*(uCode: UINT, uMapType: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc MapVirtualKeyW*(uCode: UINT, uMapType: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc MapVirtualKeyExA*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc MapVirtualKeyExW*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetInputState*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetQueueStatus*(flags: UINT): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCapture*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCapture*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc ReleaseCapture*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MsgWaitForMultipleObjects*(nCount: DWORD, pHandles: ptr HANDLE, fWaitAll: WINBOOL, dwMilliseconds: DWORD, dwWakeMask: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc MsgWaitForMultipleObjectsEx*(nCount: DWORD, pHandles: ptr HANDLE, dwMilliseconds: DWORD, dwWakeMask: DWORD, dwFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetTimer*(hWnd: HWND, nIDEvent: UINT_PTR, uElapse: UINT, lpTimerFunc: TIMERPROC): UINT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc KillTimer*(hWnd: HWND, uIDEvent: UINT_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWindowUnicode*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnableWindow*(hWnd: HWND, bEnable: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWindowEnabled*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadAcceleratorsA*(hInstance: HINSTANCE, lpTableName: LPCSTR): HACCEL {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadAcceleratorsW*(hInstance: HINSTANCE, lpTableName: LPCWSTR): HACCEL {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateAcceleratorTableA*(paccel: LPACCEL, cAccel: int32): HACCEL {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateAcceleratorTableW*(paccel: LPACCEL, cAccel: int32): HACCEL {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyAcceleratorTable*(hAccel: HACCEL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CopyAcceleratorTableA*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc CopyAcceleratorTableW*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc TranslateAcceleratorA*(hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc TranslateAcceleratorW*(hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCoalescableTimer*(hWnd: HWND, nIDEvent: UINT_PTR, uElapse: UINT, lpTimerFunc: TIMERPROC, uToleranceDelay: ULONG): UINT_PTR {.winapi, stdcall, dynlib: "user32", importc.} +proc GetSystemMetrics*(nIndex: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadMenuA*(hInstance: HINSTANCE, lpMenuName: LPCSTR): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadMenuW*(hInstance: HINSTANCE, lpMenuName: LPCWSTR): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadMenuIndirectA*(lpMenuTemplate: ptr MENUTEMPLATEA): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadMenuIndirectW*(lpMenuTemplate: ptr MENUTEMPLATEW): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenu*(hWnd: HWND): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenu*(hWnd: HWND, hMenu: HMENU): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeMenuA*(hMenu: HMENU, cmd: UINT, lpszNewItem: LPCSTR, cmdInsert: UINT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeMenuW*(hMenu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR, cmdInsert: UINT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc HiliteMenuItem*(hWnd: HWND, hMenu: HMENU, uIDHiliteItem: UINT, uHilite: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuStringA*(hMenu: HMENU, uIDItem: UINT, lpString: LPSTR, cchMax: int32, flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuStringW*(hMenu: HMENU, uIDItem: UINT, lpString: LPWSTR, cchMax: int32, flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuState*(hMenu: HMENU, uId: UINT, uFlags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawMenuBar*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetSystemMenu*(hWnd: HWND, bRevert: WINBOOL): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateMenu*(): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc CreatePopupMenu*(): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyMenu*(hMenu: HMENU): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CheckMenuItem*(hMenu: HMENU, uIDCheckItem: UINT, uCheck: UINT): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc EnableMenuItem*(hMenu: HMENU, uIDEnableItem: UINT, uEnable: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetSubMenu*(hMenu: HMENU, nPos: int32): HMENU {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuItemID*(hMenu: HMENU, nPos: int32): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuItemCount*(hMenu: HMENU): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc InsertMenuA*(hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InsertMenuW*(hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AppendMenuA*(hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AppendMenuW*(hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ModifyMenuA*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ModifyMenuW*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RemoveMenu*(hMenu: HMENU, uPosition: UINT, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DeleteMenu*(hMenu: HMENU, uPosition: UINT, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuItemBitmaps*(hMenu: HMENU, uPosition: UINT, uFlags: UINT, hBitmapUnchecked: HBITMAP, hBitmapChecked: HBITMAP): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuCheckMarkDimensions*(): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc TrackPopupMenu*(hMenu: HMENU, uFlags: UINT, x: int32, y: int32, nReserved: int32, hWnd: HWND, prcRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc TrackPopupMenuEx*(P1: HMENU, P2: UINT, P3: int32, P4: int32, P5: HWND, P6: LPTPMPARAMS): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuInfo*(P1: HMENU, P2: LPMENUINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuInfo*(P1: HMENU, P2: LPCMENUINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EndMenu*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CalculatePopupWindowPosition*(anchorPoint: ptr POINT, windowSize: ptr SIZE, flags: UINT, excludeRect: ptr RECT, popupWindowPosition: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InsertMenuItemA*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmi: LPCMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InsertMenuItemW*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmi: LPCMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuItemInfoA*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmii: LPMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuItemInfoW*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmii: LPMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuItemInfoA*(hmenu: HMENU, item: UINT, fByPositon: WINBOOL, lpmii: LPCMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuItemInfoW*(hmenu: HMENU, item: UINT, fByPositon: WINBOOL, lpmii: LPCMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuDefaultItem*(hMenu: HMENU, fByPos: UINT, gmdiFlags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuDefaultItem*(hMenu: HMENU, uItem: UINT, fByPos: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuItemRect*(hWnd: HWND, hMenu: HMENU, uItem: UINT, lprcItem: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MenuItemFromPoint*(hWnd: HWND, hMenu: HMENU, ptScreen: POINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DragObject*(hwndParent: HWND, hwndFrom: HWND, fmt: UINT, data: ULONG_PTR, hcur: HCURSOR): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc DragDetect*(hwnd: HWND, pt: POINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawIcon*(hDC: HDC, X: int32, Y: int32, hIcon: HICON): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawTextA*(hdc: HDC, lpchText: LPCSTR, cchText: int32, lprc: LPRECT, format: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawTextW*(hdc: HDC, lpchText: LPCWSTR, cchText: int32, lprc: LPRECT, format: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawTextExA*(hdc: HDC, lpchText: LPSTR, cchText: int32, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawTextExW*(hdc: HDC, lpchText: LPWSTR, cchText: int32, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GrayStringA*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int32, X: int32, Y: int32, nWidth: int32, nHeight: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GrayStringW*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int32, X: int32, Y: int32, nWidth: int32, nHeight: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawStateA*(hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawStateW*(hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc TabbedTextOutA*(hdc: HDC, x: int32, y: int32, lpString: LPCSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT, nTabOrigin: int32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc TabbedTextOutW*(hdc: HDC, x: int32, y: int32, lpString: LPCWSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT, nTabOrigin: int32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc GetTabbedTextExtentA*(hdc: HDC, lpString: LPCSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetTabbedTextExtentW*(hdc: HDC, lpString: LPCWSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc UpdateWindow*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetActiveWindow*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetForegroundWindow*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc PaintDesktop*(hdc: HDC): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SwitchToThisWindow*(hwnd: HWND, fUnknown: WINBOOL): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc SetForegroundWindow*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AllowSetForegroundWindow*(dwProcessId: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LockSetForegroundWindow*(uLockCode: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc WindowFromDC*(hDC: HDC): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDC*(hWnd: HWND): HDC {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDCEx*(hWnd: HWND, hrgnClip: HRGN, flags: DWORD): HDC {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowDC*(hWnd: HWND): HDC {.winapi, stdcall, dynlib: "user32", importc.} +proc ReleaseDC*(hWnd: HWND, hDC: HDC): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc BeginPaint*(hWnd: HWND, lpPaint: LPPAINTSTRUCT): HDC {.winapi, stdcall, dynlib: "user32", importc.} +proc EndPaint*(hWnd: HWND, lpPaint: ptr PAINTSTRUCT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUpdateRect*(hWnd: HWND, lpRect: LPRECT, bErase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetUpdateRgn*(hWnd: HWND, hRgn: HRGN, bErase: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowRgn*(hWnd: HWND, hRgn: HRGN, bRedraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowRgn*(hWnd: HWND, hRgn: HRGN): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowRgnBox*(hWnd: HWND, lprc: LPRECT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc ExcludeUpdateRgn*(hDC: HDC, hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc InvalidateRect*(hWnd: HWND, lpRect: ptr RECT, bErase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ValidateRect*(hWnd: HWND, lpRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InvalidateRgn*(hWnd: HWND, hRgn: HRGN, bErase: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ValidateRgn*(hWnd: HWND, hRgn: HRGN): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RedrawWindow*(hWnd: HWND, lprcUpdate: ptr RECT, hrgnUpdate: HRGN, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LockWindowUpdate*(hWndLock: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ScrollWindow*(hWnd: HWND, XAmount: int32, YAmount: int32, lpRect: ptr RECT, lpClipRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ScrollDC*(hDC: HDC, dx: int32, dy: int32, lprcScroll: ptr RECT, lprcClip: ptr RECT, hrgnUpdate: HRGN, lprcUpdate: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ScrollWindowEx*(hWnd: HWND, dx: int32, dy: int32, prcScroll: ptr RECT, prcClip: ptr RECT, hrgnUpdate: HRGN, prcUpdate: LPRECT, flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetScrollPos*(hWnd: HWND, nBar: int32, nPos: int32, bRedraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetScrollPos*(hWnd: HWND, nBar: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetScrollRange*(hWnd: HWND, nBar: int32, nMinPos: int32, nMaxPos: int32, bRedraw: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetScrollRange*(hWnd: HWND, nBar: int32, lpMinPos: LPINT, lpMaxPos: LPINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowScrollBar*(hWnd: HWND, wBar: int32, bShow: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnableScrollBar*(hWnd: HWND, wSBflags: UINT, wArrows: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetPropA*(hWnd: HWND, lpString: LPCSTR, hData: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetPropW*(hWnd: HWND, lpString: LPCWSTR, hData: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPropA*(hWnd: HWND, lpString: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPropW*(hWnd: HWND, lpString: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc RemovePropA*(hWnd: HWND, lpString: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc RemovePropW*(hWnd: HWND, lpString: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumPropsExA*(hWnd: HWND, lpEnumFunc: PROPENUMPROCEXA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumPropsExW*(hWnd: HWND, lpEnumFunc: PROPENUMPROCEXW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumPropsA*(hWnd: HWND, lpEnumFunc: PROPENUMPROCA): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumPropsW*(hWnd: HWND, lpEnumFunc: PROPENUMPROCW): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowTextA*(hWnd: HWND, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowTextW*(hWnd: HWND, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowTextA*(hWnd: HWND, lpString: LPSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowTextW*(hWnd: HWND, lpString: LPWSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowTextLengthA*(hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowTextLengthW*(hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClientRect*(hWnd: HWND, lpRect: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowRect*(hWnd: HWND, lpRect: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AdjustWindowRect*(lpRect: LPRECT, dwStyle: DWORD, bMenu: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc AdjustWindowRectEx*(lpRect: LPRECT, dwStyle: DWORD, bMenu: WINBOOL, dwExStyle: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowContextHelpId*(P1: HWND, P2: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowContextHelpId*(P1: HWND): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetMenuContextHelpId*(P1: HMENU, P2: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuContextHelpId*(P1: HMENU): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxA*(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxW*(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxExA*(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxExW*(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxIndirectA*(lpmbp: ptr MSGBOXPARAMSA): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBoxIndirectW*(lpmbp: ptr MSGBOXPARAMSW): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc MessageBeep*(uType: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowCursor*(bShow: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCursorPos*(X: int32, Y: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCursor*(hCursor: HCURSOR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCursorPos*(lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ClipCursor*(lpRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClipCursor*(lpRect: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCursor*(): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateCaret*(hWnd: HWND, hBitmap: HBITMAP, nWidth: int32, nHeight: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCaretBlinkTime*(): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCaretBlinkTime*(uMSeconds: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyCaret*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc HideCaret*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShowCaret*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetCaretPos*(X: int32, Y: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCaretPos*(lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ClientToScreen*(hWnd: HWND, lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ScreenToClient*(hWnd: HWND, lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MapWindowPoints*(hWndFrom: HWND, hWndTo: HWND, lpPoints: LPPOINT, cPoints: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc WindowFromPoint*(Point: POINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc ChildWindowFromPoint*(hWndParent: HWND, Point: POINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc ChildWindowFromPointEx*(hwnd: HWND, pt: POINT, flags: UINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetPhysicalCursorPos*(X: int32, Y: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPhysicalCursorPos*(lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LogicalToPhysicalPoint*(hWnd: HWND, lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PhysicalToLogicalPoint*(hWnd: HWND, lpPoint: LPPOINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc WindowFromPhysicalPoint*(Point: POINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetSysColor*(nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetSysColorBrush*(nIndex: int32): HBRUSH {.winapi, stdcall, dynlib: "user32", importc.} +proc SetSysColors*(cElements: int32, lpaElements: ptr INT, lpaRgbValues: ptr COLORREF): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawFocusRect*(hDC: HDC, lprc: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc FillRect*(hDC: HDC, lprc: ptr RECT, hbr: HBRUSH): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc FrameRect*(hDC: HDC, lprc: ptr RECT, hbr: HBRUSH): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc InvertRect*(hDC: HDC, lprc: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetRect*(lprc: LPRECT, xLeft: int32, yTop: int32, xRight: int32, yBottom: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetRectEmpty*(lprc: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CopyRect*(lprcDst: LPRECT, lprcSrc: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc InflateRect*(lprc: LPRECT, dx: int32, dy: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IntersectRect*(lprcDst: LPRECT, lprcSrc1: ptr RECT, lprcSrc2: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnionRect*(lprcDst: LPRECT, lprcSrc1: ptr RECT, lprcSrc2: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SubtractRect*(lprcDst: LPRECT, lprcSrc1: ptr RECT, lprcSrc2: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc OffsetRect*(lprc: LPRECT, dx: int32, dy: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsRectEmpty*(lprc: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EqualRect*(lprc1: ptr RECT, lprc2: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PtInRect*(lprc: ptr RECT, pt: POINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowWord*(hWnd: HWND, nIndex: int32): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowWord*(hWnd: HWND, nIndex: int32, wNewWord: WORD): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowLongA*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowLongW*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowLongA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowLongW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassWord*(hWnd: HWND, nIndex: int32): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetClassWord*(hWnd: HWND, nIndex: int32, wNewWord: WORD): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassLongA*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassLongW*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetClassLongA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc SetClassLongW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc GetProcessDefaultLayout*(pdwDefaultLayout: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetProcessDefaultLayout*(dwDefaultLayout: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDesktopWindow*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetParent*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetParent*(hWndChild: HWND, hWndNewParent: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumChildWindows*(hWndParent: HWND, lpEnumFunc: WNDENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc FindWindowA*(lpClassName: LPCSTR, lpWindowName: LPCSTR): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc FindWindowW*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc FindWindowExA*(hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCSTR, lpszWindow: LPCSTR): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc FindWindowExW*(hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCWSTR, lpszWindow: LPCWSTR): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetShellWindow*(): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterShellHookWindow*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DeregisterShellHookWindow*(hwnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumWindows*(lpEnumFunc: WNDENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumThreadWindows*(dwThreadId: DWORD, lpfn: WNDENUMPROC, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassNameA*(hWnd: HWND, lpClassName: LPSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetClassNameW*(hWnd: HWND, lpClassName: LPWSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetTopWindow*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowThreadProcessId*(hWnd: HWND, lpdwProcessId: LPDWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc IsGUIThread*(bConvert: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetLastActivePopup*(hWnd: HWND): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindow*(hWnd: HWND, uCmd: UINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowsHookA*(nFilterType: int32, pfnFilterProc: HOOKPROC): HHOOK {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowsHookW*(nFilterType: int32, pfnFilterProc: HOOKPROC): HHOOK {.winapi, stdcall, dynlib: "user32", importc.} +proc UnhookWindowsHook*(nCode: int32, pfnFilterProc: HOOKPROC): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowsHookExA*(idHook: int32, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD): HHOOK {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWindowsHookExW*(idHook: int32, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD): HHOOK {.winapi, stdcall, dynlib: "user32", importc.} +proc UnhookWindowsHookEx*(hhk: HHOOK): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CallNextHookEx*(hhk: HHOOK, nCode: int32, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc CheckMenuRadioItem*(hmenu: HMENU, first: UINT, last: UINT, check: UINT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadBitmapA*(hInstance: HINSTANCE, lpBitmapName: LPCSTR): HBITMAP {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadBitmapW*(hInstance: HINSTANCE, lpBitmapName: LPCWSTR): HBITMAP {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadCursorA*(hInstance: HINSTANCE, lpCursorName: LPCSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadCursorW*(hInstance: HINSTANCE, lpCursorName: LPCWSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadCursorFromFileA*(lpFileName: LPCSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadCursorFromFileW*(lpFileName: LPCWSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateCursor*(hInst: HINSTANCE, xHotSpot: int32, yHotSpot: int32, nWidth: int32, nHeight: int32, pvANDPlane: pointer, pvXORPlane: pointer): HCURSOR {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyCursor*(hCursor: HCURSOR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetSystemCursor*(hcur: HCURSOR, id: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadIconA*(hInstance: HINSTANCE, lpIconName: LPCSTR): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadIconW*(hInstance: HINSTANCE, lpIconName: LPCWSTR): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc PrivateExtractIconsA*(szFileName: LPCSTR, nIconIndex: int32, cxIcon: int32, cyIcon: int32, phicon: ptr HICON, piconid: ptr UINT, nIcons: UINT, flags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc PrivateExtractIconsW*(szFileName: LPCWSTR, nIconIndex: int32, cxIcon: int32, cyIcon: int32, phicon: ptr HICON, piconid: ptr UINT, nIcons: UINT, flags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateIcon*(hInstance: HINSTANCE, nWidth: int32, nHeight: int32, cPlanes: BYTE, cBitsPixel: BYTE, lpbANDbits: ptr BYTE, lpbXORbits: ptr BYTE): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc DestroyIcon*(hIcon: HICON): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc LookupIconIdFromDirectory*(presbits: PBYTE, fIcon: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc LookupIconIdFromDirectoryEx*(presbits: PBYTE, fIcon: WINBOOL, cxDesired: int32, cyDesired: int32, Flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateIconFromResource*(presbits: PBYTE, dwResSize: DWORD, fIcon: WINBOOL, dwVer: DWORD): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateIconFromResourceEx*(presbits: PBYTE, dwResSize: DWORD, fIcon: WINBOOL, dwVer: DWORD, cxDesired: int32, cyDesired: int32, Flags: UINT): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadImageA*(hInst: HINSTANCE, name: LPCSTR, `type`: UINT, cx: int32, cy: int32, fuLoad: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc LoadImageW*(hInst: HINSTANCE, name: LPCWSTR, `type`: UINT, cx: int32, cy: int32, fuLoad: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc CopyImage*(h: HANDLE, `type`: UINT, cx: int32, cy: int32, flags: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc.} +proc DrawIconEx*(hdc: HDC, xLeft: int32, yTop: int32, hIcon: HICON, cxWidth: int32, cyWidth: int32, istepIfAniCur: UINT, hbrFlickerFreeDraw: HBRUSH, diFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateIconIndirect*(piconinfo: PICONINFO): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc CopyIcon*(hIcon: HICON): HICON {.winapi, stdcall, dynlib: "user32", importc.} +proc GetIconInfo*(hIcon: HICON, piconinfo: PICONINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetIconInfoExA*(hicon: HICON, piconinfo: PICONINFOEXA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetIconInfoExW*(hicon: HICON, piconinfo: PICONINFOEXW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsDialogMessageA*(hDlg: HWND, lpMsg: LPMSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsDialogMessageW*(hDlg: HWND, lpMsg: LPMSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MapDialogRect*(hDlg: HWND, lpRect: LPRECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirListA*(hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int32, nIDStaticPath: int32, uFileType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirListW*(hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int32, nIDStaticPath: int32, uFileType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirSelectExA*(hwndDlg: HWND, lpString: LPSTR, chCount: int32, idListBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirSelectExW*(hwndDlg: HWND, lpString: LPWSTR, chCount: int32, idListBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirListComboBoxA*(hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int32, nIDStaticPath: int32, uFiletype: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirListComboBoxW*(hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int32, nIDStaticPath: int32, uFiletype: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirSelectComboBoxExA*(hwndDlg: HWND, lpString: LPSTR, cchOut: int32, idComboBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DlgDirSelectComboBoxExW*(hwndDlg: HWND, lpString: LPWSTR, cchOut: int32, idComboBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetScrollInfo*(hwnd: HWND, nBar: int32, lpsi: LPCSCROLLINFO, redraw: WINBOOL): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc GetScrollInfo*(hwnd: HWND, nBar: int32, lpsi: LPSCROLLINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc DefFrameProcA*(hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefFrameProcW*(hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefMDIChildProcA*(hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefMDIChildProcW*(hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc TranslateMDISysAccel*(hWndClient: HWND, lpMsg: LPMSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ArrangeIconicWindows*(hWnd: HWND): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateMDIWindowA*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc CreateMDIWindowW*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc TileWindows*(hwndParent: HWND, wHow: UINT, lpRect: ptr RECT, cKids: UINT, lpKids: ptr HWND): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc CascadeWindows*(hwndParent: HWND, wHow: UINT, lpRect: ptr RECT, cKids: UINT, lpKids: ptr HWND): WORD {.winapi, stdcall, dynlib: "user32", importc.} +proc WinHelpA*(hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc WinHelpW*(hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetGuiResources*(hProcess: HANDLE, uiFlags: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeDisplaySettingsA*(lpDevMode: LPDEVMODEA, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeDisplaySettingsW*(lpDevMode: LPDEVMODEW, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeDisplaySettingsExA*(lpszDeviceName: LPCSTR, lpDevMode: LPDEVMODEA, hwnd: HWND, dwflags: DWORD, lParam: LPVOID): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeDisplaySettingsExW*(lpszDeviceName: LPCWSTR, lpDevMode: LPDEVMODEW, hwnd: HWND, dwflags: DWORD, lParam: LPVOID): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplaySettingsA*(lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplaySettingsW*(lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplaySettingsExA*(lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplaySettingsExW*(lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplayDevicesA*(lpDevice: LPCSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplayDevicesW*(lpDevice: LPCWSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDisplayConfigBufferSizes*(flags: UINT32, numPathArrayElements: ptr UINT32, numModeInfoArrayElements: ptr UINT32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDisplayConfig*(numPathArrayElements: UINT32, pathArray: ptr DISPLAYCONFIG_PATH_INFO, numModeInfoArrayElements: UINT32, modeInfoArray: ptr DISPLAYCONFIG_MODE_INFO, flags: UINT32): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc QueryDisplayConfig*(flags: UINT32, numPathArrayElements: ptr UINT32, pathArray: ptr DISPLAYCONFIG_PATH_INFO, numModeInfoArrayElements: ptr UINT32, modeInfoArray: ptr DISPLAYCONFIG_MODE_INFO, currentTopologyId: ptr DISPLAYCONFIG_TOPOLOGY_ID): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc DisplayConfigGetDeviceInfo*(requestPacket: ptr DISPLAYCONFIG_DEVICE_INFO_HEADER): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc DisplayConfigSetDeviceInfo*(setPacket: ptr DISPLAYCONFIG_DEVICE_INFO_HEADER): LONG {.winapi, stdcall, dynlib: "user32", importc.} +proc SystemParametersInfoA*(uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SystemParametersInfoW*(uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDebugErrorLevel*(dwLevel: DWORD): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc SetLastErrorEx*(dwErrCode: DWORD, dwType: DWORD): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc InternalGetWindowText*(hWnd: HWND, pString: LPWSTR, cchMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc.} +proc CancelShutdown*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc MonitorFromPoint*(pt: POINT, dwFlags: DWORD): HMONITOR {.winapi, stdcall, dynlib: "user32", importc.} +proc MonitorFromRect*(lprc: LPCRECT, dwFlags: DWORD): HMONITOR {.winapi, stdcall, dynlib: "user32", importc.} +proc MonitorFromWindow*(hwnd: HWND, dwFlags: DWORD): HMONITOR {.winapi, stdcall, dynlib: "user32", importc.} +proc EndTask*(hWnd: HWND, fShutDown: WINBOOL, fForce: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SoundSentry*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMonitorInfoA*(hMonitor: HMONITOR, lpmi: LPMONITORINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMonitorInfoW*(hMonitor: HMONITOR, lpmi: LPMONITORINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc EnumDisplayMonitors*(hdc: HDC, lprcClip: LPCRECT, lpfnEnum: MONITORENUMPROC, dwData: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc NotifyWinEvent*(event: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG): VOID {.winapi, stdcall, dynlib: "user32", importc.} +proc SetWinEventHook*(eventMin: DWORD, eventMax: DWORD, hmodWinEventProc: HMODULE, pfnWinEventProc: WINEVENTPROC, idProcess: DWORD, idThread: DWORD, dwFlags: DWORD): HWINEVENTHOOK {.winapi, stdcall, dynlib: "user32", importc.} +proc IsWinEventHookInstalled*(event: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UnhookWinEvent*(hWinEventHook: HWINEVENTHOOK): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetGUIThreadInfo*(idThread: DWORD, pgui: PGUITHREADINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc BlockInput*(fBlockIt: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowModuleFileNameA*(hwnd: HWND, pszFileName: LPSTR, cchFileNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowModuleFileNameW*(hwnd: HWND, pszFileName: LPWSTR, cchFileNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc SetProcessDPIAware*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsProcessDPIAware*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCursorInfo*(pci: PCURSORINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetWindowInfo*(hwnd: HWND, pwi: PWINDOWINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetTitleBarInfo*(hwnd: HWND, pti: PTITLEBARINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetMenuBarInfo*(hwnd: HWND, idObject: LONG, idItem: LONG, pmbi: PMENUBARINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetScrollBarInfo*(hwnd: HWND, idObject: LONG, psbi: PSCROLLBARINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetComboBoxInfo*(hwndCombo: HWND, pcbi: PCOMBOBOXINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetAncestor*(hwnd: HWND, gaFlags: UINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc RealChildWindowFromPoint*(hwndParent: HWND, ptParentClientCoords: POINT): HWND {.winapi, stdcall, dynlib: "user32", importc.} +proc RealGetWindowClassA*(hwnd: HWND, ptszClassName: LPSTR, cchClassNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc RealGetWindowClassW*(hwnd: HWND, ptszClassName: LPWSTR, cchClassNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetAltTabInfoA*(hwnd: HWND, iItem: int32, pati: PALTTABINFO, pszItemText: LPSTR, cchItemText: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetAltTabInfoW*(hwnd: HWND, iItem: int32, pati: PALTTABINFO, pszItemText: LPWSTR, cchItemText: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetListBoxInfo*(hwnd: HWND): DWORD {.winapi, stdcall, dynlib: "user32", importc.} +proc LockWorkStation*(): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc UserHandleGrantAccess*(hUserHandle: HANDLE, hJob: HANDLE, bGrant: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawInputData*(hRawInput: HRAWINPUT, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT, cbSizeHeader: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawInputDeviceInfoA*(hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawInputDeviceInfoW*(hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawInputBuffer*(pData: PRAWINPUT, pcbSize: PUINT, cbSizeHeader: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterRawInputDevices*(pRawInputDevices: PCRAWINPUTDEVICE, uiNumDevices: UINT, cbSize: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRegisteredRawInputDevices*(pRawInputDevices: PRAWINPUTDEVICE, puiNumDevices: PUINT, cbSize: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawInputDeviceList*(pRawInputDeviceList: PRAWINPUTDEVICELIST, puiNumDevices: PUINT, cbSize: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc.} +proc DefRawInputProc*(paRawInput: ptr PRAWINPUT, nInput: INT, cbSizeHeader: UINT): LRESULT {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerDevices*(deviceCount: ptr UINT32, pointerDevices: ptr POINTER_DEVICE_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerDevice*(device: HANDLE, pointerDevice: ptr POINTER_DEVICE_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerDeviceProperties*(device: HANDLE, propertyCount: ptr UINT32, pointerProperties: ptr POINTER_DEVICE_PROPERTY): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc RegisterPointerDeviceNotifications*(window: HWND, notifyRange: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerDeviceRects*(device: HANDLE, pointerDeviceRect: ptr RECT, displayRect: ptr RECT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerDeviceCursors*(device: HANDLE, cursorCount: ptr UINT32, deviceCursors: ptr POINTER_DEVICE_CURSOR_INFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetRawPointerDeviceData*(pointerId: UINT32, historyCount: UINT32, propertiesCount: UINT32, pProperties: ptr POINTER_DEVICE_PROPERTY, pValues: ptr LONG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeWindowMessageFilter*(message: UINT, dwFlag: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ChangeWindowMessageFilterEx*(hwnd: HWND, message: UINT, action: DWORD, pChangeFilterStruct: PCHANGEFILTERSTRUCT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetGestureInfo*(hGestureInfo: HGESTUREINFO, pGestureInfo: PGESTUREINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetGestureExtraArgs*(hGestureInfo: HGESTUREINFO, cbExtraArgs: UINT, pExtraArgs: PBYTE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc CloseGestureInfoHandle*(hGestureInfo: HGESTUREINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetGestureConfig*(hwnd: HWND, dwReserved: DWORD, cIDs: UINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetGestureConfig*(hwnd: HWND, dwReserved: DWORD, dwFlags: DWORD, pcIDs: PUINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShutdownBlockReasonCreate*(hWnd: HWND, pwszReason: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShutdownBlockReasonQuery*(hWnd: HWND, pwszBuff: LPWSTR, pcchBuff: ptr DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc ShutdownBlockReasonDestroy*(hWnd: HWND): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCurrentInputMessageSource*(inputMessageSource: ptr INPUT_MESSAGE_SOURCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetCIMSSM*(inputMessageSource: ptr INPUT_MESSAGE_SOURCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetAutoRotationState*(pState: PAR_STATE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetDisplayAutoRotationPreferences*(pOrientation: ptr ORIENTATION_PREFERENCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetDisplayAutoRotationPreferences*(orientation: ORIENTATION_PREFERENCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc IsImmersiveProcess*(hProcess: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc SetProcessRestrictionExemption*(fEnableExemption: WINBOOL): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc GetPointerInputTransform*(pointerId: UINT32, historyCount: UINT32, inputTransform: ptr UINT32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc.} +proc PostAppMessageA*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageA".} +proc PostAppMessageW*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageW".} +proc GetNextWindow*(hWnd: HWND, uCmd: UINT): HWND {.winapi, stdcall, dynlib: "user32", importc: "GetWindow".} +proc CopyCursor*(hIcon: HICON): HICON {.winapi, stdcall, dynlib: "user32", importc: "CopyIcon".} +template MAKEINTRESOURCEA*(i: untyped): untyped = cast[LPSTR](i and 0xffff) +template MAKEINTRESOURCEW*(i: untyped): untyped = cast[LPWSTR](i and 0xffff) +template IS_INTRESOURCE*(r: untyped): bool = cast[int](r) shr 16 == 0 +template GET_APPCOMMAND_LPARAM*(lParam: untyped): SHORT = cast[SHORT](HIWORD(lParam) and (not WORD FAPPCOMMAND_MASK)) +template GET_DEVICE_LPARAM*(lParam: untyped): WORD = HIWORD(lParam) and WORD FAPPCOMMAND_MASK +template GET_MOUSEORKEY_LPARAM*(lParam: untyped): WORD = HIWORD(lParam) and WORD FAPPCOMMAND_MASK +template GET_FLAGS_LPARAM*(lParam: untyped): WORD = LOWORD(lParam) +template GET_KEYSTATE_LPARAM*(lParam: untyped): WORD = LOWORD(lParam) +template POINTSTOPOINT*(pt: POINT, pts: POINTS) = pt.x = pts.x; pt.y = pts.y +template POINTTOPOINTS*(pt: POINT): POINTS = POINTS(x: int16 pt.x, y: int16 pt.y) +template MAKEWPARAM*(l: untyped, h: untyped): WPARAM = WPARAM MAKELONG(l, h) +template MAKELPARAM*(l: untyped, h: untyped): LPARAM = LPARAM MAKELONG(l, h) +template MAKELRESULT*(l: untyped, h: untyped): LRESULT = LRESULT MAKELONG(l, h) +template GET_WHEEL_DELTA_WPARAM*(wParam: untyped): SHORT = cast[SHORT](HIWORD(wParam)) +template GET_KEYSTATE_WPARAM*(wParam: untyped): WORD = LOWORD(wParam) +template GET_NCHITTEST_WPARAM*(wParam: untyped): SHORT = cast[SHORT](LOWORD(wParam)) +template GET_XBUTTON_WPARAM*(wParam: untyped): WORD = HIWORD(wParam) +template TOUCH_COORD_TO_PIXEL*(L: untyped): LONG = LONG((int L) / 100) +template GET_POINTERID_WPARAM*(wParam: untyped): WORD = LOWORD(wParam) +template IS_POINTER_FLAG_SET_WPARAM*(wParam: untyped, flag: untyped): bool = (DWORD(HIWORD(wParam)) and DWORD flag) == DWORD flag +template IS_POINTER_NEW_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_NEW) +template IS_POINTER_INRANGE_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_INRANGE) +template IS_POINTER_INCONTACT_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_INCONTACT) +template IS_POINTER_FIRSTBUTTON_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_FIRSTBUTTON) +template IS_POINTER_SECONDBUTTON_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_SECONDBUTTON) +template IS_POINTER_THIRDBUTTON_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_THIRDBUTTON) +template IS_POINTER_FOURTHBUTTON_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_FOURTHBUTTON) +template IS_POINTER_FIFTHBUTTON_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_FIFTHBUTTON) +template IS_POINTER_PRIMARY_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_PRIMARY) +template HAS_POINTER_CONFIDENCE_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_CONFIDENCE) +template IS_POINTER_CANCELED_WPARAM*(wParam: untyped): bool = IS_POINTER_FLAG_SET_WPARAM(wParam, POINTER_MESSAGE_FLAG_CANCELED) +template GET_RAWINPUT_CODE_WPARAM*(wParam: untyped): WPARAM = WPARAM(wParam and 0xff) +template GET_SC_WPARAM*(wParam: untyped): LONG = LONG(wParam and 0xfff0) +template RIDEV_EXMODE*(mode: untyped): DWORD = DWORD(mode and RIDEV_EXMODEMASK) +template GET_DEVICE_CHANGE_WPARAM*(wParam: untyped): WPARAM = WPARAM(LOWORD(wParam)) +template GET_DEVICE_CHANGE_LPARAM*(lParam: untyped): LPARAM = LPARAM(LOWORD(lParam)) +template GID_ROTATE_ANGLE_TO_ARGUMENT*(arg: untyped): USHORT = USHORT((arg + 2.0 * 3.14159265) / (4.0 * 3.14159265) * 65535.0) +template GID_ROTATE_ANGLE_FROM_ARGUMENT*(arg: untyped): DOUBLE = (((arg.DOUBLE / 65535.0) * 4.0 * 3.14159265) - 2.0 * 3.14159265) +proc ExitWindows*(dwReserved: DWORD, uReserved: UINT): WINBOOL {.winapi, inline.} = ExitWindowsEx(EWX_LOGOFF, 0xFFFFFFFF'i32) +proc EnumTaskWindows*(hTask: HANDLE, lpfn: WNDENUMPROC, lParam: LPARAM): WINBOOL {.winapi, inline.} = EnumThreadWindows(DWORD hTask, lpfn, lParam) +proc GetWindowTask*(hWnd: HWND): DWORD {.winapi, inline.} = GetWindowThreadProcessId(hWnd, nil) +proc DefHookProc*(nCode: int32, wParam: WPARAM, lParam: LPARAM, phhk: ptr HHOOK): LRESULT {.winapi, inline.} = CallNextHookEx(phhk[], nCode, wParam, lParam) +when winimAnsi: + proc CreateWindowEx*(dwExStyle: DWORD, lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateWindowExA".} +proc CreateWindowA*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, inline.} = CreateWindowExA(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam) +when winimUnicode: + proc CreateWindowEx*(dwExStyle: DWORD, lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateWindowExW".} +proc CreateWindowW*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, inline.} = CreateWindowExW(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam) +when winimAnsi: + proc CreateDialogParam*(hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateDialogParamA".} +proc CreateDialogA*(hInstance: HINSTANCE, lpName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogParamA(hInstance, lpName, hWndParent, lpDialogFunc, 0) +when winimUnicode: + proc CreateDialogParam*(hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateDialogParamW".} +proc CreateDialogW*(hInstance: HINSTANCE, lpName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogParamW(hInstance, lpName, hWndParent, lpDialogFunc, 0) +when winimAnsi: + proc CreateDialogIndirectParam*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateDialogIndirectParamA".} +proc CreateDialogIndirectA*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimUnicode: + proc CreateDialogIndirectParam*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateDialogIndirectParamW".} +proc CreateDialogIndirectW*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogIndirectParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimAnsi: + proc DialogBoxParam*(hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc: "DialogBoxParamA".} +proc DialogBoxA*(hInstance: HINSTANCE, lpTemplate: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimUnicode: + proc DialogBoxParam*(hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc: "DialogBoxParamW".} +proc DialogBoxW*(hInstance: HINSTANCE, lpTemplate: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimAnsi: + proc DialogBoxIndirectParam*(hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc: "DialogBoxIndirectParamA".} +proc DialogBoxIndirectA*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimUnicode: + proc DialogBoxIndirectParam*(hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM): INT_PTR {.winapi, stdcall, dynlib: "user32", importc: "DialogBoxIndirectParamW".} +proc DialogBoxIndirectW*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxIndirectParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +proc `mi=`*(self: var INPUT, x: MOUSEINPUT) {.inline.} = self.union1.mi = x +proc mi*(self: INPUT): MOUSEINPUT {.inline.} = self.union1.mi +proc mi*(self: var INPUT): var MOUSEINPUT {.inline.} = self.union1.mi +proc `ki=`*(self: var INPUT, x: KEYBDINPUT) {.inline.} = self.union1.ki = x +proc ki*(self: INPUT): KEYBDINPUT {.inline.} = self.union1.ki +proc ki*(self: var INPUT): var KEYBDINPUT {.inline.} = self.union1.ki +proc `hi=`*(self: var INPUT, x: HARDWAREINPUT) {.inline.} = self.union1.hi = x +proc hi*(self: INPUT): HARDWAREINPUT {.inline.} = self.union1.hi +proc hi*(self: var INPUT): var HARDWAREINPUT {.inline.} = self.union1.hi +proc `cbSize=`*(self: var MONITORINFOEXA, x: DWORD) {.inline.} = self.struct1.cbSize = x +proc cbSize*(self: MONITORINFOEXA): DWORD {.inline.} = self.struct1.cbSize +proc cbSize*(self: var MONITORINFOEXA): var DWORD {.inline.} = self.struct1.cbSize +proc `rcMonitor=`*(self: var MONITORINFOEXA, x: RECT) {.inline.} = self.struct1.rcMonitor = x +proc rcMonitor*(self: MONITORINFOEXA): RECT {.inline.} = self.struct1.rcMonitor +proc rcMonitor*(self: var MONITORINFOEXA): var RECT {.inline.} = self.struct1.rcMonitor +proc `rcWork=`*(self: var MONITORINFOEXA, x: RECT) {.inline.} = self.struct1.rcWork = x +proc rcWork*(self: MONITORINFOEXA): RECT {.inline.} = self.struct1.rcWork +proc rcWork*(self: var MONITORINFOEXA): var RECT {.inline.} = self.struct1.rcWork +proc `dwFlags=`*(self: var MONITORINFOEXA, x: DWORD) {.inline.} = self.struct1.dwFlags = x +proc dwFlags*(self: MONITORINFOEXA): DWORD {.inline.} = self.struct1.dwFlags +proc dwFlags*(self: var MONITORINFOEXA): var DWORD {.inline.} = self.struct1.dwFlags +proc `cbSize=`*(self: var MONITORINFOEXW, x: DWORD) {.inline.} = self.struct1.cbSize = x +proc cbSize*(self: MONITORINFOEXW): DWORD {.inline.} = self.struct1.cbSize +proc cbSize*(self: var MONITORINFOEXW): var DWORD {.inline.} = self.struct1.cbSize +proc `rcMonitor=`*(self: var MONITORINFOEXW, x: RECT) {.inline.} = self.struct1.rcMonitor = x +proc rcMonitor*(self: MONITORINFOEXW): RECT {.inline.} = self.struct1.rcMonitor +proc rcMonitor*(self: var MONITORINFOEXW): var RECT {.inline.} = self.struct1.rcMonitor +proc `rcWork=`*(self: var MONITORINFOEXW, x: RECT) {.inline.} = self.struct1.rcWork = x +proc rcWork*(self: MONITORINFOEXW): RECT {.inline.} = self.struct1.rcWork +proc rcWork*(self: var MONITORINFOEXW): var RECT {.inline.} = self.struct1.rcWork +proc `dwFlags=`*(self: var MONITORINFOEXW, x: DWORD) {.inline.} = self.struct1.dwFlags = x +proc dwFlags*(self: MONITORINFOEXW): DWORD {.inline.} = self.struct1.dwFlags +proc dwFlags*(self: var MONITORINFOEXW): var DWORD {.inline.} = self.struct1.dwFlags +proc `ulButtons=`*(self: var RAWMOUSE, x: ULONG) {.inline.} = self.union1.ulButtons = x +proc ulButtons*(self: RAWMOUSE): ULONG {.inline.} = self.union1.ulButtons +proc ulButtons*(self: var RAWMOUSE): var ULONG {.inline.} = self.union1.ulButtons +proc `usButtonFlags=`*(self: var RAWMOUSE, x: USHORT) {.inline.} = self.union1.struct1.usButtonFlags = x +proc usButtonFlags*(self: RAWMOUSE): USHORT {.inline.} = self.union1.struct1.usButtonFlags +proc usButtonFlags*(self: var RAWMOUSE): var USHORT {.inline.} = self.union1.struct1.usButtonFlags +proc `usButtonData=`*(self: var RAWMOUSE, x: USHORT) {.inline.} = self.union1.struct1.usButtonData = x +proc usButtonData*(self: RAWMOUSE): USHORT {.inline.} = self.union1.struct1.usButtonData +proc usButtonData*(self: var RAWMOUSE): var USHORT {.inline.} = self.union1.struct1.usButtonData +proc `mouse=`*(self: var RID_DEVICE_INFO, x: RID_DEVICE_INFO_MOUSE) {.inline.} = self.union1.mouse = x +proc mouse*(self: RID_DEVICE_INFO): RID_DEVICE_INFO_MOUSE {.inline.} = self.union1.mouse +proc mouse*(self: var RID_DEVICE_INFO): var RID_DEVICE_INFO_MOUSE {.inline.} = self.union1.mouse +proc `keyboard=`*(self: var RID_DEVICE_INFO, x: RID_DEVICE_INFO_KEYBOARD) {.inline.} = self.union1.keyboard = x +proc keyboard*(self: RID_DEVICE_INFO): RID_DEVICE_INFO_KEYBOARD {.inline.} = self.union1.keyboard +proc keyboard*(self: var RID_DEVICE_INFO): var RID_DEVICE_INFO_KEYBOARD {.inline.} = self.union1.keyboard +proc `hid=`*(self: var RID_DEVICE_INFO, x: RID_DEVICE_INFO_HID) {.inline.} = self.union1.hid = x +proc hid*(self: RID_DEVICE_INFO): RID_DEVICE_INFO_HID {.inline.} = self.union1.hid +proc hid*(self: var RID_DEVICE_INFO): var RID_DEVICE_INFO_HID {.inline.} = self.union1.hid +proc `m11=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m11 = x +proc m11*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m11 +proc m11*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m11 +proc `m12=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m12 = x +proc m12*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m12 +proc m12*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m12 +proc `m13=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m13 = x +proc m13*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m13 +proc m13*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m13 +proc `m14=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m14 = x +proc m14*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m14 +proc m14*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m14 +proc `m21=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m21 = x +proc m21*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m21 +proc m21*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m21 +proc `m22=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m22 = x +proc m22*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m22 +proc m22*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m22 +proc `m23=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m23 = x +proc m23*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m23 +proc m23*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m23 +proc `m24=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m24 = x +proc m24*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m24 +proc m24*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m24 +proc `m31=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m31 = x +proc m31*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m31 +proc m31*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m31 +proc `m32=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m32 = x +proc m32*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m32 +proc m32*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m32 +proc `m33=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m33 = x +proc m33*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m33 +proc m33*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m33 +proc `m34=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m34 = x +proc m34*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m34 +proc m34*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m34 +proc `m41=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m41 = x +proc m41*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m41 +proc m41*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m41 +proc `m42=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m42 = x +proc m42*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m42 +proc m42*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m42 +proc `m43=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m43 = x +proc m43*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m43 +proc m43*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m43 +proc `m44=`*(self: var INPUT_TRANSFORM, x: float32) {.inline.} = self.union1.struct1.m44 = x +proc m44*(self: INPUT_TRANSFORM): float32 {.inline.} = self.union1.struct1.m44 +proc m44*(self: var INPUT_TRANSFORM): var float32 {.inline.} = self.union1.struct1.m44 +proc `m=`*(self: var INPUT_TRANSFORM, x: array[4, array[4, float32]]) {.inline.} = self.union1.m = x +proc m*(self: INPUT_TRANSFORM): array[4, array[4, float32]] {.inline.} = self.union1.m +proc m*(self: var INPUT_TRANSFORM): var array[4, array[4, float32]] {.inline.} = self.union1.m +when winimUnicode: + type + MENUTEMPLATE* = MENUTEMPLATEW + LPMENUTEMPLATE* = LPMENUTEMPLATEW + PROPENUMPROC* = PROPENUMPROCW + PROPENUMPROCEX* = PROPENUMPROCEXW + EDITWORDBREAKPROC* = EDITWORDBREAKPROCW + WINSTAENUMPROC* = WINSTAENUMPROCW + DESKTOPENUMPROC* = DESKTOPENUMPROCW + CBT_CREATEWND* = CBT_CREATEWNDW + LPCBT_CREATEWND* = LPCBT_CREATEWNDW + WNDCLASSEX* = WNDCLASSEXW + PWNDCLASSEX* = PWNDCLASSEXW + NPWNDCLASSEX* = NPWNDCLASSEXW + LPWNDCLASSEX* = LPWNDCLASSEXW + WNDCLASS* = WNDCLASSW + PWNDCLASS* = PWNDCLASSW + NPWNDCLASS* = NPWNDCLASSW + LPWNDCLASS* = LPWNDCLASSW + CREATESTRUCT* = CREATESTRUCTW + LPCREATESTRUCT* = LPCREATESTRUCTW + LPDLGTEMPLATE* = LPDLGTEMPLATEW + LPCDLGTEMPLATE* = LPCDLGTEMPLATEW + PDLGITEMTEMPLATE* = PDLGITEMTEMPLATEW + LPDLGITEMTEMPLATE* = LPDLGITEMTEMPLATEW + MENUITEMINFO* = MENUITEMINFOW + LPMENUITEMINFO* = LPMENUITEMINFOW + LPCMENUITEMINFO* = LPCMENUITEMINFOW + MSGBOXPARAMS* = MSGBOXPARAMSW + PMSGBOXPARAMS* = PMSGBOXPARAMSW + LPMSGBOXPARAMS* = LPMSGBOXPARAMSW + ICONINFOEX* = ICONINFOEXW + PICONINFOEX* = PICONINFOEXW + MDICREATESTRUCT* = MDICREATESTRUCTW + LPMDICREATESTRUCT* = LPMDICREATESTRUCTW + MULTIKEYHELP* = MULTIKEYHELPW + PMULTIKEYHELP* = PMULTIKEYHELPW + LPMULTIKEYHELP* = LPMULTIKEYHELPW + HELPWININFO* = HELPWININFOW + PHELPWININFO* = PHELPWININFOW + LPHELPWININFO* = LPHELPWININFOW + NONCLIENTMETRICS* = NONCLIENTMETRICSW + PNONCLIENTMETRICS* = PNONCLIENTMETRICSW + LPNONCLIENTMETRICS* = LPNONCLIENTMETRICSW + ICONMETRICS* = ICONMETRICSW + PICONMETRICS* = PICONMETRICSW + LPICONMETRICS* = LPICONMETRICSW + SERIALKEYS* = SERIALKEYSW + LPSERIALKEYS* = LPSERIALKEYSW + HIGHCONTRAST* = HIGHCONTRASTW + LPHIGHCONTRAST* = LPHIGHCONTRASTW + TSOUNDSENTRY* = SOUNDSENTRYW + LPSOUNDSENTRY* = LPSOUNDSENTRYW + MONITORINFOEX* = MONITORINFOEXW + LPMONITORINFOEX* = LPMONITORINFOEXW + proc wvsprintf*(P1: LPWSTR, P2: LPCWSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "user32", importc: "wvsprintfW".} + proc wsprintf*(P1: LPWSTR, P2: LPCWSTR): int32 {.winapi, stdcall, dynlib: "user32", importc: "wsprintfW".} + proc LoadKeyboardLayout*(pwszKLID: LPCWSTR, Flags: UINT): HKL {.winapi, stdcall, dynlib: "user32", importc: "LoadKeyboardLayoutW".} + proc GetKeyboardLayoutName*(pwszKLID: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetKeyboardLayoutNameW".} + proc CreateDesktop*(lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: LPDEVMODEW, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HDESK {.winapi, stdcall, dynlib: "user32", importc: "CreateDesktopW".} + proc CreateDesktopEx*(lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: ptr DEVMODEW, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID): HDESK {.winapi, stdcall, dynlib: "user32", importc: "CreateDesktopExW".} + proc OpenDesktop*(lpszDesktop: LPCWSTR, dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HDESK {.winapi, stdcall, dynlib: "user32", importc: "OpenDesktopW".} + proc EnumDesktops*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCW, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDesktopsW".} + proc CreateWindowStation*(lpwinsta: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA {.winapi, stdcall, dynlib: "user32", importc: "CreateWindowStationW".} + proc OpenWindowStation*(lpszWinSta: LPCWSTR, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HWINSTA {.winapi, stdcall, dynlib: "user32", importc: "OpenWindowStationW".} + proc EnumWindowStations*(lpEnumFunc: WINSTAENUMPROCW, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumWindowStationsW".} + proc GetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetUserObjectInformationW".} + proc SetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetUserObjectInformationW".} + proc RegisterWindowMessage*(lpString: LPCWSTR): UINT {.winapi, stdcall, dynlib: "user32", importc: "RegisterWindowMessageW".} + proc GetMessage*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMessageW".} + proc DispatchMessage*(lpMsg: ptr MSG): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DispatchMessageW".} + proc PeekMessage*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PeekMessageW".} + proc SendMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendMessageW".} + proc SendMessageTimeout*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendMessageTimeoutW".} + proc SendNotifyMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SendNotifyMessageW".} + proc SendMessageCallback*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SendMessageCallbackW".} + proc BroadcastSystemMessageEx*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO): LONG32 {.winapi, stdcall, dynlib: "user32", importc: "BroadcastSystemMessageExW".} + proc BroadcastSystemMessage*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LONG32 {.winapi, stdcall, dynlib: "user32", importc: "BroadcastSystemMessageW".} + proc RegisterDeviceNotification*(hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD): HDEVNOTIFY {.winapi, stdcall, dynlib: "user32", importc: "RegisterDeviceNotificationW".} + proc PostMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostMessageW".} + proc PostThreadMessage*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageW".} + proc DefWindowProc*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefWindowProcW".} + proc CallWindowProc*(lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "CallWindowProcW".} + proc RegisterClass*(lpWndClass: ptr WNDCLASSW): ATOM {.winapi, stdcall, dynlib: "user32", importc: "RegisterClassW".} + proc UnregisterClass*(lpClassName: LPCWSTR, hInstance: HINSTANCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "UnregisterClassW".} + proc GetClassInfo*(hInstance: HINSTANCE, lpClassName: LPCWSTR, lpWndClass: LPWNDCLASSW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetClassInfoW".} + proc RegisterClassEx*(P1: ptr WNDCLASSEXW): ATOM {.winapi, stdcall, dynlib: "user32", importc: "RegisterClassExW".} + proc GetClassInfoEx*(hInstance: HINSTANCE, lpszClass: LPCWSTR, lpwcx: LPWNDCLASSEXW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetClassInfoExW".} + proc SetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetDlgItemTextW".} + proc GetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPWSTR, cchMax: int32): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetDlgItemTextW".} + proc SendDlgItemMessage*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendDlgItemMessageW".} + proc DefDlgProc*(hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefDlgProcW".} + proc CallMsgFilter*(lpMsg: LPMSG, nCode: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CallMsgFilterW".} + proc RegisterClipboardFormat*(lpszFormat: LPCWSTR): UINT {.winapi, stdcall, dynlib: "user32", importc: "RegisterClipboardFormatW".} + proc GetClipboardFormatName*(format: UINT, lpszFormatName: LPWSTR, cchMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetClipboardFormatNameW".} + proc CharToOem*(lpszSrc: LPCWSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemW".} + proc OemToChar*(lpszSrc: LPCSTR, lpszDst: LPWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharW".} + proc CharToOemBuff*(lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemBuffW".} + proc OemToCharBuff*(lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharBuffW".} + proc CharUpper*(lpsz: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc: "CharUpperW".} + proc CharUpperBuff*(lpsz: LPWSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharUpperBuffW".} + proc CharLower*(lpsz: LPWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc: "CharLowerW".} + proc CharLowerBuff*(lpsz: LPWSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharLowerBuffW".} + proc CharNext*(lpsz: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc: "CharNextW".} + proc CharPrev*(lpszStart: LPCWSTR, lpszCurrent: LPCWSTR): LPWSTR {.winapi, stdcall, dynlib: "user32", importc: "CharPrevW".} + proc IsCharAlpha*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharAlphaW".} + proc IsCharAlphaNumeric*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharAlphaNumericW".} + proc IsCharUpper*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharUpperW".} + proc IsCharLower*(ch: WCHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharLowerW".} + proc GetKeyNameText*(lParam: LONG, lpString: LPWSTR, cchSize: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetKeyNameTextW".} + proc VkKeyScan*(ch: WCHAR): SHORT {.winapi, stdcall, dynlib: "user32", importc: "VkKeyScanW".} + proc VkKeyScanEx*(ch: WCHAR, dwhkl: HKL): SHORT {.winapi, stdcall, dynlib: "user32", importc: "VkKeyScanExW".} + proc MapVirtualKey*(uCode: UINT, uMapType: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "MapVirtualKeyW".} + proc MapVirtualKeyEx*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT {.winapi, stdcall, dynlib: "user32", importc: "MapVirtualKeyExW".} + proc LoadAccelerators*(hInstance: HINSTANCE, lpTableName: LPCWSTR): HACCEL {.winapi, stdcall, dynlib: "user32", importc: "LoadAcceleratorsW".} + proc CreateAcceleratorTable*(paccel: LPACCEL, cAccel: int32): HACCEL {.winapi, stdcall, dynlib: "user32", importc: "CreateAcceleratorTableW".} + proc CopyAcceleratorTable*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "CopyAcceleratorTableW".} + proc TranslateAccelerator*(hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32 {.winapi, stdcall, dynlib: "user32", importc: "TranslateAcceleratorW".} + proc LoadMenu*(hInstance: HINSTANCE, lpMenuName: LPCWSTR): HMENU {.winapi, stdcall, dynlib: "user32", importc: "LoadMenuW".} + proc LoadMenuIndirect*(lpMenuTemplate: ptr MENUTEMPLATEW): HMENU {.winapi, stdcall, dynlib: "user32", importc: "LoadMenuIndirectW".} + proc ChangeMenu*(hMenu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR, cmdInsert: UINT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "ChangeMenuW".} + proc GetMenuString*(hMenu: HMENU, uIDItem: UINT, lpString: LPWSTR, cchMax: int32, flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetMenuStringW".} + proc InsertMenu*(hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "InsertMenuW".} + proc AppendMenu*(hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "AppendMenuW".} + proc ModifyMenu*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "ModifyMenuW".} + proc InsertMenuItem*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmi: LPCMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "InsertMenuItemW".} + proc GetMenuItemInfo*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmii: LPMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMenuItemInfoW".} + proc SetMenuItemInfo*(hmenu: HMENU, item: UINT, fByPositon: WINBOOL, lpmii: LPCMENUITEMINFOW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetMenuItemInfoW".} + proc DrawText*(hdc: HDC, lpchText: LPCWSTR, cchText: int32, lprc: LPRECT, format: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DrawTextW".} + proc DrawTextEx*(hdc: HDC, lpchText: LPWSTR, cchText: int32, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS): int32 {.winapi, stdcall, dynlib: "user32", importc: "DrawTextExW".} + proc GrayString*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int32, X: int32, Y: int32, nWidth: int32, nHeight: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GrayStringW".} + proc DrawState*(hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DrawStateW".} + proc TabbedTextOut*(hdc: HDC, x: int32, y: int32, lpString: LPCWSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT, nTabOrigin: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "TabbedTextOutW".} + proc GetTabbedTextExtent*(hdc: HDC, lpString: LPCWSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetTabbedTextExtentW".} + proc SetProp*(hWnd: HWND, lpString: LPCWSTR, hData: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetPropW".} + proc GetProp*(hWnd: HWND, lpString: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "GetPropW".} + proc RemoveProp*(hWnd: HWND, lpString: LPCWSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "RemovePropW".} + proc EnumPropsEx*(hWnd: HWND, lpEnumFunc: PROPENUMPROCEXW, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "user32", importc: "EnumPropsExW".} + proc EnumProps*(hWnd: HWND, lpEnumFunc: PROPENUMPROCW): int32 {.winapi, stdcall, dynlib: "user32", importc: "EnumPropsW".} + proc SetWindowText*(hWnd: HWND, lpString: LPCWSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetWindowTextW".} + proc GetWindowText*(hWnd: HWND, lpString: LPWSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetWindowTextW".} + proc GetWindowTextLength*(hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetWindowTextLengthW".} + proc MessageBox*(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxW".} + proc MessageBoxEx*(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxExW".} + proc MessageBoxIndirect*(lpmbp: ptr MSGBOXPARAMSW): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxIndirectW".} + proc GetWindowLong*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongW".} + proc SetWindowLong*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongW".} + proc GetClassLong*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongW".} + proc SetClassLong*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongW".} + proc FindWindow*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR): HWND {.winapi, stdcall, dynlib: "user32", importc: "FindWindowW".} + proc FindWindowEx*(hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCWSTR, lpszWindow: LPCWSTR): HWND {.winapi, stdcall, dynlib: "user32", importc: "FindWindowExW".} + proc GetClassName*(hWnd: HWND, lpClassName: LPWSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetClassNameW".} + proc SetWindowsHook*(nFilterType: int32, pfnFilterProc: HOOKPROC): HHOOK {.winapi, stdcall, dynlib: "user32", importc: "SetWindowsHookW".} + proc SetWindowsHookEx*(idHook: int32, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD): HHOOK {.winapi, stdcall, dynlib: "user32", importc: "SetWindowsHookExW".} + proc LoadBitmap*(hInstance: HINSTANCE, lpBitmapName: LPCWSTR): HBITMAP {.winapi, stdcall, dynlib: "user32", importc: "LoadBitmapW".} + proc LoadCursor*(hInstance: HINSTANCE, lpCursorName: LPCWSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc: "LoadCursorW".} + proc LoadCursorFromFile*(lpFileName: LPCWSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc: "LoadCursorFromFileW".} + proc LoadIcon*(hInstance: HINSTANCE, lpIconName: LPCWSTR): HICON {.winapi, stdcall, dynlib: "user32", importc: "LoadIconW".} + proc PrivateExtractIcons*(szFileName: LPCWSTR, nIconIndex: int32, cxIcon: int32, cyIcon: int32, phicon: ptr HICON, piconid: ptr UINT, nIcons: UINT, flags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "PrivateExtractIconsW".} + proc LoadImage*(hInst: HINSTANCE, name: LPCWSTR, `type`: UINT, cx: int32, cy: int32, fuLoad: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "LoadImageW".} + proc GetIconInfoEx*(hicon: HICON, piconinfo: PICONINFOEXW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetIconInfoExW".} + proc IsDialogMessage*(hDlg: HWND, lpMsg: LPMSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsDialogMessageW".} + proc DlgDirList*(hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int32, nIDStaticPath: int32, uFileType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DlgDirListW".} + proc DlgDirSelectEx*(hwndDlg: HWND, lpString: LPWSTR, chCount: int32, idListBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DlgDirSelectExW".} + proc DlgDirListComboBox*(hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int32, nIDStaticPath: int32, uFiletype: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DlgDirListComboBoxW".} + proc DlgDirSelectComboBoxEx*(hwndDlg: HWND, lpString: LPWSTR, cchOut: int32, idComboBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DlgDirSelectComboBoxExW".} + proc DefFrameProc*(hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefFrameProcW".} + proc DefMDIChildProc*(hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefMDIChildProcW".} + proc CreateMDIWindow*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateMDIWindowW".} + proc WinHelp*(hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "WinHelpW".} + proc ChangeDisplaySettings*(lpDevMode: LPDEVMODEW, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsW".} + proc ChangeDisplaySettingsEx*(lpszDeviceName: LPCWSTR, lpDevMode: LPDEVMODEW, hwnd: HWND, dwflags: DWORD, lParam: LPVOID): LONG {.winapi, stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsExW".} + proc EnumDisplaySettings*(lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEW): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplaySettingsW".} + proc EnumDisplaySettingsEx*(lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplaySettingsExW".} + proc EnumDisplayDevices*(lpDevice: LPCWSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEW, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplayDevicesW".} + proc SystemParametersInfo*(uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SystemParametersInfoW".} + proc GetMonitorInfo*(hMonitor: HMONITOR, lpmi: LPMONITORINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMonitorInfoW".} + proc GetWindowModuleFileName*(hwnd: HWND, pszFileName: LPWSTR, cchFileNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetWindowModuleFileNameW".} + proc RealGetWindowClass*(hwnd: HWND, ptszClassName: LPWSTR, cchClassNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "RealGetWindowClassW".} + proc GetAltTabInfo*(hwnd: HWND, iItem: int32, pati: PALTTABINFO, pszItemText: LPWSTR, cchItemText: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetAltTabInfoW".} + proc GetRawInputDeviceInfo*(hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetRawInputDeviceInfoW".} + proc PostAppMessage*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageW".} + proc CreateWindow*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, inline.} = CreateWindowExW(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam) + proc CreateDialog*(hInstance: HINSTANCE, lpName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogParamW(hInstance, lpName, hWndParent, lpDialogFunc, 0) + proc CreateDialogIndirect*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogIndirectParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) + proc DialogBox*(hInstance: HINSTANCE, lpTemplate: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) + proc DialogBoxIndirect*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxIndirectParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimAnsi: + type + MENUTEMPLATE* = MENUTEMPLATEA + LPMENUTEMPLATE* = LPMENUTEMPLATEA + PROPENUMPROC* = PROPENUMPROCA + PROPENUMPROCEX* = PROPENUMPROCEXA + EDITWORDBREAKPROC* = EDITWORDBREAKPROCA + WINSTAENUMPROC* = WINSTAENUMPROCA + DESKTOPENUMPROC* = DESKTOPENUMPROCA + CBT_CREATEWND* = CBT_CREATEWNDA + LPCBT_CREATEWND* = LPCBT_CREATEWNDA + WNDCLASSEX* = WNDCLASSEXA + PWNDCLASSEX* = PWNDCLASSEXA + NPWNDCLASSEX* = NPWNDCLASSEXA + LPWNDCLASSEX* = LPWNDCLASSEXA + WNDCLASS* = WNDCLASSA + PWNDCLASS* = PWNDCLASSA + NPWNDCLASS* = NPWNDCLASSA + LPWNDCLASS* = LPWNDCLASSA + CREATESTRUCT* = CREATESTRUCTA + LPCREATESTRUCT* = LPCREATESTRUCTA + LPDLGTEMPLATE* = LPDLGTEMPLATEA + LPCDLGTEMPLATE* = LPCDLGTEMPLATEA + PDLGITEMTEMPLATE* = PDLGITEMTEMPLATEA + LPDLGITEMTEMPLATE* = LPDLGITEMTEMPLATEA + MENUITEMINFO* = MENUITEMINFOA + LPMENUITEMINFO* = LPMENUITEMINFOA + LPCMENUITEMINFO* = LPCMENUITEMINFOA + MSGBOXPARAMS* = MSGBOXPARAMSA + PMSGBOXPARAMS* = PMSGBOXPARAMSA + LPMSGBOXPARAMS* = LPMSGBOXPARAMSA + ICONINFOEX* = ICONINFOEXA + PICONINFOEX* = PICONINFOEXA + MDICREATESTRUCT* = MDICREATESTRUCTA + LPMDICREATESTRUCT* = LPMDICREATESTRUCTA + MULTIKEYHELP* = MULTIKEYHELPA + PMULTIKEYHELP* = PMULTIKEYHELPA + LPMULTIKEYHELP* = LPMULTIKEYHELPA + HELPWININFO* = HELPWININFOA + PHELPWININFO* = PHELPWININFOA + LPHELPWININFO* = LPHELPWININFOA + NONCLIENTMETRICS* = NONCLIENTMETRICSA + PNONCLIENTMETRICS* = PNONCLIENTMETRICSA + LPNONCLIENTMETRICS* = LPNONCLIENTMETRICSA + ICONMETRICS* = ICONMETRICSA + PICONMETRICS* = PICONMETRICSA + LPICONMETRICS* = LPICONMETRICSA + SERIALKEYS* = SERIALKEYSA + LPSERIALKEYS* = LPSERIALKEYSA + HIGHCONTRAST* = HIGHCONTRASTA + LPHIGHCONTRAST* = LPHIGHCONTRASTA + TSOUNDSENTRY* = SOUNDSENTRYA + LPSOUNDSENTRY* = LPSOUNDSENTRYA + MONITORINFOEX* = MONITORINFOEXA + LPMONITORINFOEX* = LPMONITORINFOEXA + proc wvsprintf*(P1: LPSTR, P2: LPCSTR, arglist: va_list): int32 {.winapi, stdcall, dynlib: "user32", importc: "wvsprintfA".} + proc wsprintf*(P1: LPSTR, P2: LPCSTR): int32 {.winapi, stdcall, dynlib: "user32", importc: "wsprintfA".} + proc LoadKeyboardLayout*(pwszKLID: LPCSTR, Flags: UINT): HKL {.winapi, stdcall, dynlib: "user32", importc: "LoadKeyboardLayoutA".} + proc GetKeyboardLayoutName*(pwszKLID: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetKeyboardLayoutNameA".} + proc CreateDesktop*(lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: LPDEVMODEA, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HDESK {.winapi, stdcall, dynlib: "user32", importc: "CreateDesktopA".} + proc CreateDesktopEx*(lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: ptr DEVMODEA, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID): HDESK {.winapi, stdcall, dynlib: "user32", importc: "CreateDesktopExA".} + proc OpenDesktop*(lpszDesktop: LPCSTR, dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HDESK {.winapi, stdcall, dynlib: "user32", importc: "OpenDesktopA".} + proc EnumDesktops*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCA, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDesktopsA".} + proc CreateWindowStation*(lpwinsta: LPCSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA {.winapi, stdcall, dynlib: "user32", importc: "CreateWindowStationA".} + proc OpenWindowStation*(lpszWinSta: LPCSTR, fInherit: WINBOOL, dwDesiredAccess: ACCESS_MASK): HWINSTA {.winapi, stdcall, dynlib: "user32", importc: "OpenWindowStationA".} + proc EnumWindowStations*(lpEnumFunc: WINSTAENUMPROCA, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumWindowStationsA".} + proc GetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetUserObjectInformationA".} + proc SetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID, nLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetUserObjectInformationA".} + proc RegisterWindowMessage*(lpString: LPCSTR): UINT {.winapi, stdcall, dynlib: "user32", importc: "RegisterWindowMessageA".} + proc GetMessage*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMessageA".} + proc DispatchMessage*(lpMsg: ptr MSG): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DispatchMessageA".} + proc PeekMessage*(lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PeekMessageA".} + proc SendMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendMessageA".} + proc SendMessageTimeout*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendMessageTimeoutA".} + proc SendNotifyMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SendNotifyMessageA".} + proc SendMessageCallback*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SendMessageCallbackA".} + proc BroadcastSystemMessageEx*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO): LONG32 {.winapi, stdcall, dynlib: "user32", importc: "BroadcastSystemMessageExA".} + proc BroadcastSystemMessage*(flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LONG32 {.winapi, stdcall, dynlib: "user32", importc: "BroadcastSystemMessageA".} + proc RegisterDeviceNotification*(hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD): HDEVNOTIFY {.winapi, stdcall, dynlib: "user32", importc: "RegisterDeviceNotificationA".} + proc PostMessage*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostMessageA".} + proc PostThreadMessage*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageA".} + proc DefWindowProc*(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefWindowProcA".} + proc CallWindowProc*(lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "CallWindowProcA".} + proc RegisterClass*(lpWndClass: ptr WNDCLASSA): ATOM {.winapi, stdcall, dynlib: "user32", importc: "RegisterClassA".} + proc UnregisterClass*(lpClassName: LPCSTR, hInstance: HINSTANCE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "UnregisterClassA".} + proc GetClassInfo*(hInstance: HINSTANCE, lpClassName: LPCSTR, lpWndClass: LPWNDCLASSA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetClassInfoA".} + proc RegisterClassEx*(P1: ptr WNDCLASSEXA): ATOM {.winapi, stdcall, dynlib: "user32", importc: "RegisterClassExA".} + proc GetClassInfoEx*(hInstance: HINSTANCE, lpszClass: LPCSTR, lpwcx: LPWNDCLASSEXA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetClassInfoExA".} + proc SetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetDlgItemTextA".} + proc GetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPSTR, cchMax: int32): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetDlgItemTextA".} + proc SendDlgItemMessage*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "SendDlgItemMessageA".} + proc DefDlgProc*(hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefDlgProcA".} + proc CallMsgFilter*(lpMsg: LPMSG, nCode: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CallMsgFilterA".} + proc RegisterClipboardFormat*(lpszFormat: LPCSTR): UINT {.winapi, stdcall, dynlib: "user32", importc: "RegisterClipboardFormatA".} + proc GetClipboardFormatName*(format: UINT, lpszFormatName: LPSTR, cchMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetClipboardFormatNameA".} + proc CharToOem*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemA".} + proc OemToChar*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharA".} + proc CharToOemBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "CharToOemBuffA".} + proc OemToCharBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "OemToCharBuffA".} + proc CharUpper*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharUpperA".} + proc CharUpperBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharUpperBuffA".} + proc CharLower*(lpsz: LPSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharLowerA".} + proc CharLowerBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD {.winapi, stdcall, dynlib: "user32", importc: "CharLowerBuffA".} + proc CharNext*(lpsz: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharNextA".} + proc CharPrev*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR {.winapi, stdcall, dynlib: "user32", importc: "CharPrevA".} + proc IsCharAlpha*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharAlphaA".} + proc IsCharAlphaNumeric*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharAlphaNumericA".} + proc IsCharUpper*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharUpperA".} + proc IsCharLower*(ch: CHAR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsCharLowerA".} + proc GetKeyNameText*(lParam: LONG, lpString: LPSTR, cchSize: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetKeyNameTextA".} + proc VkKeyScan*(ch: CHAR): SHORT {.winapi, stdcall, dynlib: "user32", importc: "VkKeyScanA".} + proc VkKeyScanEx*(ch: CHAR, dwhkl: HKL): SHORT {.winapi, stdcall, dynlib: "user32", importc: "VkKeyScanExA".} + proc MapVirtualKey*(uCode: UINT, uMapType: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "MapVirtualKeyA".} + proc MapVirtualKeyEx*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT {.winapi, stdcall, dynlib: "user32", importc: "MapVirtualKeyExA".} + proc LoadAccelerators*(hInstance: HINSTANCE, lpTableName: LPCSTR): HACCEL {.winapi, stdcall, dynlib: "user32", importc: "LoadAcceleratorsA".} + proc CreateAcceleratorTable*(paccel: LPACCEL, cAccel: int32): HACCEL {.winapi, stdcall, dynlib: "user32", importc: "CreateAcceleratorTableA".} + proc CopyAcceleratorTable*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "CopyAcceleratorTableA".} + proc TranslateAccelerator*(hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32 {.winapi, stdcall, dynlib: "user32", importc: "TranslateAcceleratorA".} + proc LoadMenu*(hInstance: HINSTANCE, lpMenuName: LPCSTR): HMENU {.winapi, stdcall, dynlib: "user32", importc: "LoadMenuA".} + proc LoadMenuIndirect*(lpMenuTemplate: ptr MENUTEMPLATEA): HMENU {.winapi, stdcall, dynlib: "user32", importc: "LoadMenuIndirectA".} + proc ChangeMenu*(hMenu: HMENU, cmd: UINT, lpszNewItem: LPCSTR, cmdInsert: UINT, flags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "ChangeMenuA".} + proc GetMenuString*(hMenu: HMENU, uIDItem: UINT, lpString: LPSTR, cchMax: int32, flags: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetMenuStringA".} + proc InsertMenu*(hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "InsertMenuA".} + proc AppendMenu*(hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "AppendMenuA".} + proc ModifyMenu*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "ModifyMenuA".} + proc InsertMenuItem*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmi: LPCMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "InsertMenuItemA".} + proc GetMenuItemInfo*(hmenu: HMENU, item: UINT, fByPosition: WINBOOL, lpmii: LPMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMenuItemInfoA".} + proc SetMenuItemInfo*(hmenu: HMENU, item: UINT, fByPositon: WINBOOL, lpmii: LPCMENUITEMINFOA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetMenuItemInfoA".} + proc DrawText*(hdc: HDC, lpchText: LPCSTR, cchText: int32, lprc: LPRECT, format: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DrawTextA".} + proc DrawTextEx*(hdc: HDC, lpchText: LPSTR, cchText: int32, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS): int32 {.winapi, stdcall, dynlib: "user32", importc: "DrawTextExA".} + proc GrayString*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int32, X: int32, Y: int32, nWidth: int32, nHeight: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GrayStringA".} + proc DrawState*(hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DrawStateA".} + proc TabbedTextOut*(hdc: HDC, x: int32, y: int32, lpString: LPCSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT, nTabOrigin: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "TabbedTextOutA".} + proc GetTabbedTextExtent*(hdc: HDC, lpString: LPCSTR, chCount: int32, nTabPositions: int32, lpnTabStopPositions: ptr INT): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetTabbedTextExtentA".} + proc SetProp*(hWnd: HWND, lpString: LPCSTR, hData: HANDLE): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetPropA".} + proc GetProp*(hWnd: HWND, lpString: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "GetPropA".} + proc RemoveProp*(hWnd: HWND, lpString: LPCSTR): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "RemovePropA".} + proc EnumPropsEx*(hWnd: HWND, lpEnumFunc: PROPENUMPROCEXA, lParam: LPARAM): int32 {.winapi, stdcall, dynlib: "user32", importc: "EnumPropsExA".} + proc EnumProps*(hWnd: HWND, lpEnumFunc: PROPENUMPROCA): int32 {.winapi, stdcall, dynlib: "user32", importc: "EnumPropsA".} + proc SetWindowText*(hWnd: HWND, lpString: LPCSTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SetWindowTextA".} + proc GetWindowText*(hWnd: HWND, lpString: LPSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetWindowTextA".} + proc GetWindowTextLength*(hWnd: HWND): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetWindowTextLengthA".} + proc MessageBox*(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxA".} + proc MessageBoxEx*(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxExA".} + proc MessageBoxIndirect*(lpmbp: ptr MSGBOXPARAMSA): int32 {.winapi, stdcall, dynlib: "user32", importc: "MessageBoxIndirectA".} + proc GetWindowLong*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongA".} + proc SetWindowLong*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongA".} + proc GetClassLong*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongA".} + proc SetClassLong*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongA".} + proc FindWindow*(lpClassName: LPCSTR, lpWindowName: LPCSTR): HWND {.winapi, stdcall, dynlib: "user32", importc: "FindWindowA".} + proc FindWindowEx*(hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCSTR, lpszWindow: LPCSTR): HWND {.winapi, stdcall, dynlib: "user32", importc: "FindWindowExA".} + proc GetClassName*(hWnd: HWND, lpClassName: LPSTR, nMaxCount: int32): int32 {.winapi, stdcall, dynlib: "user32", importc: "GetClassNameA".} + proc SetWindowsHook*(nFilterType: int32, pfnFilterProc: HOOKPROC): HHOOK {.winapi, stdcall, dynlib: "user32", importc: "SetWindowsHookA".} + proc SetWindowsHookEx*(idHook: int32, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD): HHOOK {.winapi, stdcall, dynlib: "user32", importc: "SetWindowsHookExA".} + proc LoadBitmap*(hInstance: HINSTANCE, lpBitmapName: LPCSTR): HBITMAP {.winapi, stdcall, dynlib: "user32", importc: "LoadBitmapA".} + proc LoadCursor*(hInstance: HINSTANCE, lpCursorName: LPCSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc: "LoadCursorA".} + proc LoadCursorFromFile*(lpFileName: LPCSTR): HCURSOR {.winapi, stdcall, dynlib: "user32", importc: "LoadCursorFromFileA".} + proc LoadIcon*(hInstance: HINSTANCE, lpIconName: LPCSTR): HICON {.winapi, stdcall, dynlib: "user32", importc: "LoadIconA".} + proc PrivateExtractIcons*(szFileName: LPCSTR, nIconIndex: int32, cxIcon: int32, cyIcon: int32, phicon: ptr HICON, piconid: ptr UINT, nIcons: UINT, flags: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "PrivateExtractIconsA".} + proc LoadImage*(hInst: HINSTANCE, name: LPCSTR, `type`: UINT, cx: int32, cy: int32, fuLoad: UINT): HANDLE {.winapi, stdcall, dynlib: "user32", importc: "LoadImageA".} + proc GetIconInfoEx*(hicon: HICON, piconinfo: PICONINFOEXA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetIconInfoExA".} + proc IsDialogMessage*(hDlg: HWND, lpMsg: LPMSG): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "IsDialogMessageA".} + proc DlgDirList*(hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int32, nIDStaticPath: int32, uFileType: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DlgDirListA".} + proc DlgDirSelectEx*(hwndDlg: HWND, lpString: LPSTR, chCount: int32, idListBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DlgDirSelectExA".} + proc DlgDirListComboBox*(hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int32, nIDStaticPath: int32, uFiletype: UINT): int32 {.winapi, stdcall, dynlib: "user32", importc: "DlgDirListComboBoxA".} + proc DlgDirSelectComboBoxEx*(hwndDlg: HWND, lpString: LPSTR, cchOut: int32, idComboBox: int32): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "DlgDirSelectComboBoxExA".} + proc DefFrameProc*(hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefFrameProcA".} + proc DefMDIChildProc*(hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.winapi, stdcall, dynlib: "user32", importc: "DefMDIChildProcA".} + proc CreateMDIWindow*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM): HWND {.winapi, stdcall, dynlib: "user32", importc: "CreateMDIWindowA".} + proc WinHelp*(hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: ULONG_PTR): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "WinHelpA".} + proc ChangeDisplaySettings*(lpDevMode: LPDEVMODEA, dwFlags: DWORD): LONG {.winapi, stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsA".} + proc ChangeDisplaySettingsEx*(lpszDeviceName: LPCSTR, lpDevMode: LPDEVMODEA, hwnd: HWND, dwflags: DWORD, lParam: LPVOID): LONG {.winapi, stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsExA".} + proc EnumDisplaySettings*(lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEA): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplaySettingsA".} + proc EnumDisplaySettingsEx*(lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: LPDEVMODEA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplaySettingsExA".} + proc EnumDisplayDevices*(lpDevice: LPCSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEA, dwFlags: DWORD): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "EnumDisplayDevicesA".} + proc SystemParametersInfo*(uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "SystemParametersInfoA".} + proc GetMonitorInfo*(hMonitor: HMONITOR, lpmi: LPMONITORINFO): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetMonitorInfoA".} + proc GetWindowModuleFileName*(hwnd: HWND, pszFileName: LPSTR, cchFileNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetWindowModuleFileNameA".} + proc RealGetWindowClass*(hwnd: HWND, ptszClassName: LPSTR, cchClassNameMax: UINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "RealGetWindowClassA".} + proc GetAltTabInfo*(hwnd: HWND, iItem: int32, pati: PALTTABINFO, pszItemText: LPSTR, cchItemText: UINT): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "GetAltTabInfoA".} + proc GetRawInputDeviceInfo*(hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT): UINT {.winapi, stdcall, dynlib: "user32", importc: "GetRawInputDeviceInfoA".} + proc PostAppMessage*(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM): WINBOOL {.winapi, stdcall, dynlib: "user32", importc: "PostThreadMessageA".} + proc CreateWindow*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, x: int32, y: int32, nWidth: int32, nHeight: int32, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID): HWND {.winapi, inline.} = CreateWindowExA(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam) + proc CreateDialog*(hInstance: HINSTANCE, lpName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogParamA(hInstance, lpName, hWndParent, lpDialogFunc, 0) + proc CreateDialogIndirect*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC): HWND {.winapi, inline.} = CreateDialogIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) + proc DialogBox*(hInstance: HINSTANCE, lpTemplate: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) + proc DialogBoxIndirect*(hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC): INT_PTR {.winapi, inline.} = DialogBoxIndirectParamA(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0) +when winimCpu64: + const + CONSOLE_APPLICATION_16BIT* = 0x0000 + GUI_16BITTASK* = 0x00000000 + proc GetWindowLongPtrA*(hWnd: HWND, nIndex: int32): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc GetWindowLongPtrW*(hWnd: HWND, nIndex: int32): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc SetWindowLongPtrA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc SetWindowLongPtrW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc GetClassLongPtrA*(hWnd: HWND, nIndex: int32): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc GetClassLongPtrW*(hWnd: HWND, nIndex: int32): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc SetClassLongPtrA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} + proc SetClassLongPtrW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc.} +when winimUnicode and winimCpu64: + proc GetWindowLongPtr*(hWnd: HWND, nIndex: int32): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongPtrW".} + proc SetWindowLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongPtrW".} + proc GetClassLongPtr*(hWnd: HWND, nIndex: int32): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongPtrW".} + proc SetClassLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongPtrW".} +when winimAnsi and winimCpu64: + proc GetWindowLongPtr*(hWnd: HWND, nIndex: int32): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongPtrA".} + proc SetWindowLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongPtrA".} + proc GetClassLongPtr*(hWnd: HWND, nIndex: int32): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongPtrA".} + proc SetClassLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): ULONG_PTR {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongPtrA".} +when winimCpu32: + const + CONSOLE_APPLICATION_16BIT* = 0x0001 + GUI_16BITTASK* = 0x00000020 + proc GetWindowLongPtrA*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongA".} + proc GetWindowLongPtrW*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongW".} + proc SetWindowLongPtrA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongA".} + proc SetWindowLongPtrW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongW".} + proc GetClassLongPtrA*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongA".} + proc GetClassLongPtrW*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongW".} + proc SetClassLongPtrA*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongA".} + proc SetClassLongPtrW*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongW".} +when winimUnicode and winimCpu32: + proc GetWindowLongPtr*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongW".} + proc SetWindowLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongW".} + proc GetClassLongPtr*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongW".} + proc SetClassLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongW".} +when winimAnsi and winimCpu32: + proc GetWindowLongPtr*(hWnd: HWND, nIndex: int32): LONG {.winapi, stdcall, dynlib: "user32", importc: "GetWindowLongA".} + proc SetWindowLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): LONG {.winapi, stdcall, dynlib: "user32", importc: "SetWindowLongA".} + proc GetClassLongPtr*(hWnd: HWND, nIndex: int32): DWORD {.winapi, stdcall, dynlib: "user32", importc: "GetClassLongA".} + proc SetClassLongPtr*(hWnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD {.winapi, stdcall, dynlib: "user32", importc: "SetClassLongA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/inc/winver.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/inc/winver.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,130 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== +import winimbase +import windef +import winuser +#include +const + VS_FILE_INFO* = RT_VERSION + VS_VERSION_INFO* = 1 + VS_USER_DEFINED* = 100 + VS_FFI_SIGNATURE* = 0xFEEF04BD'i32 + VS_FFI_STRUCVERSION* = 0x00010000 + VS_FFI_FILEFLAGSMASK* = 0x0000003F + VS_FF_DEBUG* = 0x00000001 + VS_FF_PRERELEASE* = 0x00000002 + VS_FF_PATCHED* = 0x00000004 + VS_FF_PRIVATEBUILD* = 0x00000008 + VS_FF_INFOINFERRED* = 0x00000010 + VS_FF_SPECIALBUILD* = 0x00000020 + VOS_UNKNOWN* = 0x00000000 + VOS_DOS* = 0x00010000 + VOS_OS216* = 0x00020000 + VOS_OS232* = 0x00030000 + VOS_NT* = 0x00040000 + VOS_WINCE* = 0x00050000 + VOS_BASE* = 0x00000000 + VOS_WINDOWS16* = 0x00000001 + VOS_PM16* = 0x00000002 + VOS_PM32* = 0x00000003 + VOS_WINDOWS32* = 0x00000004 + VOS_DOS_WINDOWS16* = 0x00010001 + VOS_DOS_WINDOWS32* = 0x00010004 + VOS_OS216_PM16* = 0x00020002 + VOS_OS232_PM32* = 0x00030003 + VOS_NT_WINDOWS32* = 0x00040004 + VFT_UNKNOWN* = 0x00000000 + VFT_APP* = 0x00000001 + VFT_DLL* = 0x00000002 + VFT_DRV* = 0x00000003 + VFT_FONT* = 0x00000004 + VFT_VXD* = 0x00000005 + VFT_STATIC_LIB* = 0x00000007 + VFT2_UNKNOWN* = 0x00000000 + VFT2_DRV_PRINTER* = 0x00000001 + VFT2_DRV_KEYBOARD* = 0x00000002 + VFT2_DRV_LANGUAGE* = 0x00000003 + VFT2_DRV_DISPLAY* = 0x00000004 + VFT2_DRV_MOUSE* = 0x00000005 + VFT2_DRV_NETWORK* = 0x00000006 + VFT2_DRV_SYSTEM* = 0x00000007 + VFT2_DRV_INSTALLABLE* = 0x00000008 + VFT2_DRV_SOUND* = 0x00000009 + VFT2_DRV_COMM* = 0x0000000A + VFT2_DRV_INPUTMETHOD* = 0x0000000B + VFT2_DRV_VERSIONED_PRINTER* = 0x0000000C + VFT2_FONT_RASTER* = 0x00000001 + VFT2_FONT_VECTOR* = 0x00000002 + VFT2_FONT_TRUETYPE* = 0x00000003 + VFFF_ISSHAREDFILE* = 0x0001 + VFF_CURNEDEST* = 0x0001 + VFF_FILEINUSE* = 0x0002 + VFF_BUFFTOOSMALL* = 0x0004 + VIFF_FORCEINSTALL* = 0x0001 + VIFF_DONTDELETEOLD* = 0x0002 + VIF_TEMPFILE* = 0x00000001 + VIF_MISMATCH* = 0x00000002 + VIF_SRCOLD* = 0x00000004 + VIF_DIFFLANG* = 0x00000008 + VIF_DIFFCODEPG* = 0x00000010 + VIF_DIFFTYPE* = 0x00000020 + VIF_WRITEPROT* = 0x00000040 + VIF_FILEINUSE* = 0x00000080 + VIF_OUTOFSPACE* = 0x00000100 + VIF_ACCESSVIOLATION* = 0x00000200 + VIF_SHARINGVIOLATION* = 0x00000400 + VIF_CANNOTCREATE* = 0x00000800 + VIF_CANNOTDELETE* = 0x00001000 + VIF_CANNOTRENAME* = 0x00002000 + VIF_CANNOTDELETECUR* = 0x00004000 + VIF_OUTOFMEMORY* = 0x00008000 + VIF_CANNOTREADSRC* = 0x00010000 + VIF_CANNOTREADDST* = 0x00020000 + VIF_BUFFTOOSMALL* = 0x00040000 + VIF_CANNOTLOADLZ32* = 0x00080000 + VIF_CANNOTLOADCABINET* = 0x00100000 +type + VS_FIXEDFILEINFO* {.pure.} = object + dwSignature*: DWORD + dwStrucVersion*: DWORD + dwFileVersionMS*: DWORD + dwFileVersionLS*: DWORD + dwProductVersionMS*: DWORD + dwProductVersionLS*: DWORD + dwFileFlagsMask*: DWORD + dwFileFlags*: DWORD + dwFileOS*: DWORD + dwFileType*: DWORD + dwFileSubtype*: DWORD + dwFileDateMS*: DWORD + dwFileDateLS*: DWORD +proc VerFindFileA*(uFlags: DWORD, szFileName: LPSTR, szWinDir: LPSTR, szAppDir: LPSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT, szDestDir: LPSTR, lpuDestDirLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc VerFindFileW*(uFlags: DWORD, szFileName: LPWSTR, szWinDir: LPWSTR, szAppDir: LPWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT, szDestDir: LPWSTR, lpuDestDirLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc VerInstallFileA*(uFlags: DWORD, szSrcFileName: LPSTR, szDestFileName: LPSTR, szSrcDir: LPSTR, szDestDir: LPSTR, szCurDir: LPSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc VerInstallFileW*(uFlags: DWORD, szSrcFileName: LPWSTR, szDestFileName: LPWSTR, szSrcDir: LPWSTR, szDestDir: LPWSTR, szCurDir: LPWSTR, szTmpFile: LPWSTR, lpuTmpFileLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc GetFileVersionInfoSizeA*(lptstrFilename: LPCSTR, lpdwHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc GetFileVersionInfoSizeW*(lptstrFilename: LPCWSTR, lpdwHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc GetFileVersionInfoA*(lptstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "version", importc.} +proc GetFileVersionInfoW*(lptstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "version", importc.} +proc VerLanguageNameA*(wLang: DWORD, szLang: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc VerLanguageNameW*(wLang: DWORD, szLang: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "version", importc.} +proc VerQueryValueA*(pBlock: LPVOID, lpSubBlock: LPCSTR, lplpBuffer: ptr LPVOID, puLen: PUINT): WINBOOL {.winapi, stdcall, dynlib: "version", importc.} +proc VerQueryValueW*(pBlock: LPVOID, lpSubBlock: LPCWSTR, lplpBuffer: ptr LPVOID, puLen: PUINT): WINBOOL {.winapi, stdcall, dynlib: "version", importc.} +when winimUnicode: + proc VerFindFile*(uFlags: DWORD, szFileName: LPWSTR, szWinDir: LPWSTR, szAppDir: LPWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT, szDestDir: LPWSTR, lpuDestDirLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerFindFileW".} + proc VerInstallFile*(uFlags: DWORD, szSrcFileName: LPWSTR, szDestFileName: LPWSTR, szSrcDir: LPWSTR, szDestDir: LPWSTR, szCurDir: LPWSTR, szTmpFile: LPWSTR, lpuTmpFileLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerInstallFileW".} + proc GetFileVersionInfoSize*(lptstrFilename: LPCWSTR, lpdwHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeW".} + proc GetFileVersionInfo*(lptstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "version", importc: "GetFileVersionInfoW".} + proc VerLanguageName*(wLang: DWORD, szLang: LPWSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerLanguageNameW".} + proc VerQueryValue*(pBlock: LPVOID, lpSubBlock: LPCWSTR, lplpBuffer: ptr LPVOID, puLen: PUINT): WINBOOL {.winapi, stdcall, dynlib: "version", importc: "VerQueryValueW".} +when winimAnsi: + proc VerFindFile*(uFlags: DWORD, szFileName: LPSTR, szWinDir: LPSTR, szAppDir: LPSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT, szDestDir: LPSTR, lpuDestDirLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerFindFileA".} + proc VerInstallFile*(uFlags: DWORD, szSrcFileName: LPSTR, szDestFileName: LPSTR, szSrcDir: LPSTR, szDestDir: LPSTR, szCurDir: LPSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerInstallFileA".} + proc GetFileVersionInfoSize*(lptstrFilename: LPCSTR, lpdwHandle: LPDWORD): DWORD {.winapi, stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeA".} + proc GetFileVersionInfo*(lptstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID): WINBOOL {.winapi, stdcall, dynlib: "version", importc: "GetFileVersionInfoA".} + proc VerLanguageName*(wLang: DWORD, szLang: LPSTR, nSize: DWORD): DWORD {.winapi, stdcall, dynlib: "version", importc: "VerLanguageNameA".} + proc VerQueryValue*(pBlock: LPVOID, lpSubBlock: LPCSTR, lplpBuffer: ptr LPVOID, puLen: PUINT): WINBOOL {.winapi, stdcall, dynlib: "version", importc: "VerQueryValueA".} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/lean.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/lean.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,9 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== + +import utils, winstr, core +export utils, winstr, core diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/lib/winim32.res Binary file semicongine/thirdparty/winim/winim/lib/winim32.res has changed diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/lib/winim64.res Binary file semicongine/thirdparty/winim/winim/lib/winim64.res has changed diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/lib/winimvcc.res Binary file semicongine/thirdparty/winim/winim/lib/winimvcc.res has changed diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/mean.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/mean.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,9 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== + +import utils, winstr, core, shell, ole +export utils, winstr, core, shell, ole diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/net.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/net.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,11 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows NET Headers +# +#==================================================================== + +import inc/[security, windns, winldap, lm, ras, rpc, iphlpapi, http, wincred] +export security, windns, winldap, lm, ras, rpc, iphlpapi, http, wincred diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/ole.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/ole.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,11 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows OLE Headers +# +#==================================================================== + +import inc/[objbase, objext, uiautomation, mscoree] +export objbase, objext, uiautomation, mscoree diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/shell.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/shell.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,14 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows Shell Headers +# +#==================================================================== + +import inc/[commctrl, commdlg, richedit, imm, shellapi, regstr, setupapi, vssym32, + uxtheme, dwmapi, msi] + +export commctrl, commdlg, richedit, imm, shellapi, regstr, setupapi, vssym32, + uxtheme, dwmapi, msi diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/utils.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/utils.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,56 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +#==================================================================== + +## This module contains utilities for happily coding in winim. + +import inc/windef + +# todo: need more converter? + +converter winimConverterBooleanToBOOL*(x: bool): BOOL = + ## Converter between Windows' BOOL/WINBOOL and Nim's boolean type + + result = if x: TRUE else: FALSE + +converter winimConverterBOOLToBoolean*(x: BOOL): bool = + ## Converter between Windows' BOOL/WINBOOL and Nim's boolean type + + result = if x == FALSE: false else: true + +converter winimConverterVarObjectToPtrObject*[T: object](x: var T): ptr T = + ## Pass an object by address if target is "ptr object". For example: + ## + ## .. code-block:: Nim + ## var msg: MSG + ## while GetMessage(msg, 0, 0, 0) != 0: + ## TranslateMessage(msg) + ## DispatchMessage(msg) + + result = x.addr + +proc `&`*[T](x: var T): ptr T {.inline.} = + ## Use `&` like it in C/C++ to get address for anything. + + result = x.addr + +when not compiles(unsafeaddr GUID_NULL): + proc `&`*(x: object): ptr type(x) {.importc: "&", nodecl.} + ## Use `&` to gets pointer for const object. For example: + ## + ## .. code-block:: Nim + ## # pUk is "ptr IUnknown" for some object + ## var pDisp: ptr IDispatch + ## pUk.QueryInterface(&IID_IDispatch, &pDisp) + +else: + template `&`*(x: object): ptr type(x) = unsafeaddr x + ## Use `&` to gets pointer for const object. For example: + ## + ## .. code-block:: Nim + ## # pUk is "ptr IUnknown" for some object + ## var pDisp: ptr IDispatch + ## pUk.QueryInterface(&IID_IDispatch, &pDisp) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/winim/winim/winstr.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/winim/winim/winstr.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1208 @@ +#==================================================================== +# +# Winim - Windows API, COM, and CLR Module for Nim +# Copyright (c) Chen Kai-Hung, Ward +# +# Windows String Type Utilities +# +#==================================================================== + +## This module contains new string types and utilities to deal with strings in Windows. +## Windows SDK use following types to represent a char or a string: +## +## .. code-block:: Nim +## type +## CHAR = char +## WCHAR = uint16 +## LPSTR|LPCSTR = ptr CHAR # however, it should be ansi string, not utf8 string +## LPWSTR|LPCWSTR = ptr WCHAR +## BSTR = distinct ptr WCHAR # BSTR is not binary compatible with LPWSTR +## (ptr) array[I, CHAR] # sometimes string defined as array[1, CHAR] but not only one char +## (ptr) array[I, WCHAR] # sometimes string defined as array[1, WCHAR] but not only one widechar +## +## By default, Nim's string type is utf8 encoding. +## However, Windows use wide character string (aka. unicode string) or multibyte character string +## (aka. ansi string). So, this module introduce following string types. +## +## .. code-block:: Nim +## type +## string # nim built-in string type, utf8 encoding by default, can be ansi string sometimes. +## cstring # compatible to the type char* in Ansi C +## wstring = distinct string # new string type to store unicode string +## mstring = distinct string # new string type to store ansi string +## +## Some type classes are also defined for convenience to deal with strings. +## +## .. code-block:: Nim +## type +## SomeChar = byte | char | WCHAR +## SomeString = string | mstring | wstring +## SomeBuffer[I] = ptr SomeChar | array[I, SomeChar] | ptr array[I, SomeChar] | +## ptr UncheckedArray[SomeChar] | openArray[SomeChar] | seq[SomeChar] +## Stringable = SomeChar | SomeString | SomeBuffer | cstring | BSTR +## +## Here are the pseudocode for most useful functions introduced by this module. +## +## .. code-block:: Nim +## proc `&`(s: cstring|string|wstring|mstring): pointer +## # Get address of the first char of a string. +## # For string, it has a similar meaning to cstring(s). +## +## proc `$`(x: Stringable): string +## proc `+$`(x: Stringable): wstring +## proc `-$`(x: Stringable): mstring +## # Convert any stringable type to string, wstring, or mstring. +## # These operators assume string|cstring|ptr char|openArray[char] are utf8 encoding. +## # setOpenArrayStringable() can be used to switch the behavior of `$` operator. +## +## proc `$$`(x: Stringable): string +## proc `+$$`(x: Stringable): wstring +## proc `-$$`(x: Stringable): mstring +## # Convert any stringable type to string, wstring, or mstring. +## # These operators assume string|cstring|ptr char|openArray[char] are ansi encoding. +## # For mstring|wstring|LPWSTR etc, these operators are the same as `$`, `+$`, `-$`. +## +## template `<<`(s: SomeString, b: SomeBuffer) +## template `<<`(b: SomeBuffer, s: SomeString) +## template `<<<`(b: SomeBuffer, s: SomeString) +## template `>>`(a: typed, b: typed) = b << a +## template `>>>`(a: typed, b: typed) = b <<< a +## # String << Buffer or Buffer >> String: Fill string by buffer. +## # Buffer << String or String >> Buffer: Fill buffer by string. +## # Buffer <<< String or String >>> Buffer: Fill buffer by string, include a null. +## +## # These operators don't convert the encoding (copy byte by byte). +## # Please make sure both side have the same character size. +## # If destination don't have the length information (e.g. pointer or UncheckedArray), +## # please make sure the buffer size is large enough. +## +## proc nullTerminate(s: var SomeString) +## # Assume a string is null terminated and set the correct length. +## +## proc nullTerminated[T: SomeString](s: T): T +## # Assume a string is null terminated and return the length-corrected string. +## +## template L(s: string): wstring +## # Generate wstring at compile-time if possible. +## # Only const string or string literal can be converted to unicode string at compile-time, +## # otherwise it is just `+$`. +## +## template T(s: string): mstring|wstring +## # Generate wstring or mstring depend on conditional symbol: useWinAnsi. +## # For example: (this code works under both unicode and ansi mode) +## +## MessageBox(0, T"hello, world", T"Nim is Powerful 中文測試", 0) +## +## template T(n: Natural): mstring|wstring +## # Generate wstring or mstring buffer depend on conditional symbol: useWinAnsi. +## # Use `&` to get the buffer address and then pass to Windows API. +## +## converter winstrConverter(s: SomeString): SomeBuffer +## # With these converters, passing string to Windows API is more easy. +## # Following converters don't need encoding conversion: +## # string => LPSTR|ptr char +## # mstring => LPSTR|ptr char +## # wstring => LPWSTR|BSTR +## # cstring => ptr char +## # BSTR => LPWSTR +## # +## # Some converters DO need encoding conversion (utf8 to unicode). +## # New memory block will be allocated. However, they are useful and convenience. +## # cstring|string => LPWSTR|BSTR +## +## There are also new string functions to deal with wstring and mstring just like built-in string type. +## +## .. code-block:: Nim +## proc newWString(len: Natural): wstring +## # Generate wstring buffer +## proc newMString(len: Natural): mstring +## # Generate mstring buffer +## +## proc setLen(s: var mstring|wstring, newLen: Natural) +## proc substr(s: wstring|mstring, first = 0): wstring|mstring +## proc substr(s: wstring|mstring, first, last: int): wstring|mstring +## proc len(s: wstring|mstring): int +## proc high(s: wstring|mstring): int +## proc low(s: wstring|mstring): int +## proc repr(s: wstring|mstring): string +## proc toHex(s: wstring|mstring): string +## +## proc `[]`(s: wstring|mstring, i: int): WCHAR|mstring +## proc `[]=`(s: wstring|mstring, i: int, u: WCHAR|CHAR) +## proc `[]=`(s: wstring|mstring, i: int, u: wstring|mstring) +## proc `[]`(s: wstring|mstring, x: HSlice) +## proc `[]=`(s: var wstring|var mstring, x: HSlice[int], b: wstring|mstring) +## proc `==`(x, y: wstring|mstring): bool +## proc `<=`(x, y: wstring|mstring): bool +## proc `<`(x, y: wstring|mstring): bool +## proc cmp(x, y: wstring|mstring): int +## proc `&`(s: wstring|mstring, t: wstring|mstring): wstring|mstring +## +## iterator items(s: wstring|mstring): WCHAR|mstring +## iterator mitems(s: var wstring): WCHAR +## iterator pairs(s: wstring|mstring): tuple[key: int|mIndex, val: WCHAR|mstring] +## iterator mpairs(s: var wstring): WCHAR +## +## Winim don't use built-in `WideCString`, but still support it. +## +## .. code-block:: Nim +## converter winstrConverter(s: WideCString): LPWSTR +## # WideCString can be sent to Windows API directly (unicode only). +## +## proc `+$`(s: WideCString): wstring +## # Converts WideCString to wstring. +## +## proc newWideCString(s: wstring): WideCString +## # Converts wstring to WideCString. + +import macros, strutils, inc/[winimbase, windef] +export strutils.toHex, winimbase + +when not declared(IndexDefect): + type + IndexDefect = object of IndexError + +# generate from winimx (avoid importing objbase everytime) +const + CP_ACP = 0 + CP_UTF8 = 65001 + +proc lstrlenA(lpString: LPCSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc lstrlenW(lpString: LPCWSTR): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc MultiByteToWideChar(CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCCH, cbMultiByte: int32, lpWideCharStr: LPWSTR, cchWideChar: int32): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc WideCharToMultiByte(CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWCH, cchWideChar: int32, lpMultiByteStr: LPSTR, cbMultiByte: int32, lpDefaultChar: LPCCH, lpUsedDefaultChar: LPBOOL): int32 {.winapi, stdcall, dynlib: "kernel32", importc.} +proc SysStringLen(P1: BSTR): UINT {.winapi, stdcall, dynlib: "oleaut32", importc.} + +# helper functions + +proc toHex(p: pointer, L: int): string = + const HexChars = "0123456789ABCDEF" + let a = cast[ptr UncheckedArray[byte]](p) + result = newStringOfCap(L * 2) + for i in 0 ..< L: + let + hi = int a[i] shr 4 + lo = int a[i] and 0xF + result.add HexChars[hi] + result.add HexChars[lo] + +proc toHex*(s: cstring): string {.inline.} = + ## Converts a `cstring` to its hexadecimal representation. + ## No prefix like ``0x`` is generated. + result = toHex($s) + +when defined(cpu64): + converter NaturalToInt32(x: Natural): int32 = int32 x + +# new string types + +type + # for wstring, always add extra null wchar to ensure null-terminated. + + wstring* = distinct string + ## New string type to store wide character string (aka. unicode string). + + mstring* = distinct string + ## New string type to store multibyte character string (aka. ansi string). + + mIndex* = distinct int + ## Use `mIndex` in substr, [] or []= for `mstring` means + ## index by MBCS characters, not by bytes. + + SomeChar* = byte | char | WCHAR + ## Type class matching all char types. + + SomeString* = string | mstring | wstring + ## Type class matching all string types. + + SomeBuffer*[I] = ptr SomeChar | array[I, SomeChar] | ptr array[I, SomeChar] | + ptr UncheckedArray[SomeChar] | openArray[SomeChar] | seq[SomeChar] + ## Type class matching all string buffer types. + + Stringable* = SomeChar | SomeString | SomeBuffer | cstring | BSTR + ## Type class matching all stringable types. + +template raw(s: wstring, L: Natural): var WCHAR = + cast[ptr WCHAR](unsafeaddr(string(s)[L * 2]))[] + +template `^^`(s, i: untyped): untyped = + (when i is BackwardsIndex: s.len - int(i) else: int(i)) + +proc newWString*(L: Natural): wstring = wstring(newString((L + 1) * 2)) + ## Returns a new `wstring` of length L, counting by wide characters. + +proc newMString*(L: Natural): mstring = mstring(newString(L)) + ## Returns a new `mstring` of length L, counting by bytes. + +proc len*(s: wstring): int {.inline.} = max(string(s).len div 2 - 1, 0) + ## Returns the length of `wstring`, counting by wide characters. + +proc len*(s: mstring): int {.inline.} = string(s).len + ## Returns the length of `mstring`, counting by bytes. + +proc newWStringOfCap*(L: Natural): wstring = + ## Returns a new `wstring` of length 0 but with capacity L, counting by wide characters. + result = wstring(newStringOfCap((L + 1) * 2)) + string(result).add "\0\0" + +proc newMStringOfCap*(L: Natural): mstring = + ## Returns a new `mstring` of length 0 but with capacity L, counting by bytes. + result = mstring(newStringOfCap(L)) + +proc setLen*(s: var wstring, L: Natural) {.inline.} = + ## Sets the length of `wstring` s to L, counting by wide characters. + setLen(string(s), (L + 1) * 2) + s.raw(s.len) = 0 + +proc setLen*(s: var mstring, L: Natural) {.inline.} = + ## Sets the length of `mstring` s to L, counting by wide bytes. + setLen(string(s), L) + +proc `&`*(s: string): ptr char {.inline.} = + ## Get address of the first char of a `string`. + result = cast[ptr char](cstring s) + +proc `&`*(s: cstring): ptr char {.inline.} = + ## Get address of the first char of a `cstring`. + result = cast[ptr char](s) + +proc `&`*(s: wstring): ptr WCHAR {.inline.} = + ## Get address of the first WCHAR of a `wstring`. + result = cast[ptr WCHAR](&(string(s))) + +proc `&`*(s: mstring): ptr char {.inline.} = + ## Get address of the first char of a `mstring`. + result = &(string(s)) + +proc `UTF8->wstring`(source: ptr char, L: Natural): wstring = + if not source.isNil: + var wLen = MultiByteToWideChar(CP_UTF8, 0, source, L, nil, 0) + result = newWString(wLen) + discard MultiByteToWideChar(CP_UTF8, 0, source, L, &result, wLen) + +proc `ANSI->wstring`(source: ptr char, L: Natural): wstring = + if not source.isNil: + var wLen = MultiByteToWideChar(CP_ACP, 0, source, L, nil, 0) + result = newWString(wLen) + discard MultiByteToWideChar(CP_ACP, 0, source, L, &result, wLen) + +proc `UNICODE->wstring`(source: ptr WCHAR, L: Natural): wstring = + if not source.isNil: + result = newWString(L) + copyMem(&result, source, L * 2) + +proc `UTF8->mstring`(source: ptr char, L: Natural): mstring = + if not source.isNil: + var wLen = MultiByteToWideChar(CP_UTF8, 0, source, L, nil, 0) + var buffer = cast[ptr WCHAR](alloc(wLen * 2)) + if not buffer.isNil: + discard MultiByteToWideChar(CP_UTF8, 0, source, L, buffer, wLen) + + var mLen = WideCharToMultiByte(CP_ACP, 0, buffer, wLen, nil, 0, nil, nil) + result = newMString(mLen) + discard WideCharToMultiByte(CP_ACP, 0, buffer, wLen, &result, mLen, nil, nil) + dealloc(buffer) + +proc `ANSI->mstring`(source: ptr char, L: Natural): mstring = + if not source.isNil: + result = newMString(L) + copyMem(&result, source, L) + +proc `UNICODE->mstring`(source: ptr WCHAR, L: Natural): mstring = + if not source.isNil: + var mLen = WideCharToMultiByte(CP_ACP, 0, source, L, nil, 0, nil, nil) + result = newMString(mLen) + discard WideCharToMultiByte(CP_ACP, 0, source, L, &result, mLen, nil, nil) + +proc `UTF8->string`(source: ptr char, L: Natural): string = + if not source.isNil: + result = newString(L) + copyMem(&result, source, L) + +proc `ANSI->string`(source: ptr char, L: Natural): string = + if not source.isNil: + var wLen = MultiByteToWideChar(CP_ACP, 0, source, L, nil, 0) + var buffer = cast[ptr WCHAR](alloc(wLen * 2)) + if not buffer.isNil: + discard MultiByteToWideChar(CP_ACP, 0, source, L, buffer, wLen) + + var mLen = WideCharToMultiByte(CP_UTF8, 0, buffer, wLen, nil, 0, nil, nil) + result = newString(mLen) + discard WideCharToMultiByte(CP_UTF8, 0, buffer, wLen, &result, mLen, nil, nil) + dealloc(buffer) + +proc `UNICODE->string`(source: ptr WCHAR, L: Natural): string = + if not source.isNil: + var mLen = WideCharToMultiByte(CP_UTF8, 0, source, L, nil, 0, nil, nil) + result = newString(mLen) + discard WideCharToMultiByte(CP_UTF8, 0, source, L, &result, mLen, nil, nil) + +template getptr[T](x: openArray[T]): untyped = + when sizeof(T) == 1: + cast[ptr char](unsafeaddr x[0]) + + elif sizeof(T) == 2: + cast[ptr WCHAR](unsafeaddr x[0]) + +template getptr[T](x: ptr UncheckedArray[T]): untyped = + when sizeof(T) == 1: + cast[ptr char](unsafeaddr x[0]) + + elif sizeof(T) == 2: + cast[ptr WCHAR](unsafeaddr x[0]) + +proc `UTF8->wstring`(source: openArray[byte|char]): wstring {.inline.} = + `UTF8->wstring`(source.getptr, source.len) + +proc `ANSI->wstring`(source: openArray[byte|char]): wstring {.inline.} = + `ANSI->wstring`(source.getptr, source.len) + +proc `UNICODE->wstring`(source: openArray[WCHAR]): wstring {.inline.} = + `UNICODE->wstring`(source.getptr, source.len) + +proc `UTF8->mstring`(source: openArray[byte|char]): mstring {.inline.} = + `UTF8->mstring`(source.getptr, source.len) + +proc `ANSI->mstring`(source: openArray[byte|char]): mstring {.inline.} = + `ANSI->mstring`(source.getptr, source.len) + +proc `UNICODE->mstring`(source: openArray[WCHAR]): mstring {.inline.} = + `UNICODE->mstring`(source.getptr, source.len) + +proc `UTF8->string`(source: openArray[byte|char]): string {.inline.} = + `UTF8->string`(source.getptr, source.len) + +proc `ANSI->string`(source: openArray[byte|char]): string {.inline.} = + `ANSI->string`(source.getptr, source.len) + +proc `UNICODE->string`(source: openArray[WCHAR]): string {.inline.} = + `UNICODE->string`(source.getptr, source.len) + +# wstring functions + +proc high*(s: wstring): int {.inline.} = s.len - 1 + ## Returns the highest possible index of `wstring`. + +proc low*(s: wstring): int {.inline.} = 0 + ## Returns the lowest possible index of `wstring`. + +proc cmp*(x, y: wstring): int {.borrow.} + ## Compare proc for `wstring` (in binary format only). + +proc `==`*(x, y: wstring): bool {.borrow.} + ## Checks for equality between two `wstring`. + +proc `<=`*(x, y: wstring): bool {.borrow.} + ## Lexicographic ``<=`` operator for `wstring`. + +proc `<`*(x, y: wstring): bool {.borrow.} + ## Lexicographic ``<`` operator for `wstring`. + +proc substr*(s: wstring, first, last: int): wstring = + ## Copies a slice of `s` into a new `wstring` and returns it. + result = wstring(string(s).substr(first * 2, last * 2 + 3)) + if result.len != 0: + result.raw(result.len) = 0 + + else: + result = newWString(0) + +proc substr*(s: wstring, first = 0): wstring {.inline.} = + ## Copies a slice of `s` into a new `wstring` and returns it. + result = s.substr(first, s.high) + +proc `[]`*(s: wstring, i: int): WCHAR {.inline.} = + ## Index operator for `wstring`. + when compileOption("boundChecks"): + if i >= s.len: + raise newException(IndexDefect, "index out of bounds") + + result = s.raw(i) + +proc `[]=`*(s: var wstring, i: int, c: WCHAR|char) {.inline.} = + ## Index assignment operator for `wstring`. + when compileOption("boundChecks"): + if i >= s.len: + raise newException(IndexDefect, "index out of bounds") + + s.raw(i) = WCHAR c + +proc `[]`*[T, U](s: wstring, x: HSlice[T, U]): wstring = + ## Slice operation for `wstring`. + let a = s ^^ x.a + let L = (s ^^ x.b) - a + 1 + when compileOption("boundChecks"): + if a < 0 or a + L > s.len: + raise newException(IndexDefect, "index out of bounds") + result = s.substr(a, a + L-1) + +proc `[]=`*[T, U](s: var wstring, x: HSlice[T, U], b: wstring) = + ## Slice assignment for `wstring`. + let a = s ^^ x.a + let L = (s ^^ x.b) - a + 1 + if L == b.len: + for i in 0 ..< L: s[i+a] = b[i] + else: + var slen = s.len + var shift = b.len - L + var newLen = slen + shift + if shift > 0: + setLen(s, newLen) + for i in countdown(newLen-1, a+shift+1): s[i] = s[i-shift] + else: + for i in countup(a+b.len, s.len-1+shift): s[i] = s[i-shift] + setLen(s, newLen) + for i in 0 ..< b.len: s[i+a] = b[i] + + s.raw(s.len) = 0 + +proc add*(s: var wstring, c: char|WCHAR) = + ## Appends `c` to `s` in place. + s.raw(s.len) = WCHAR c + string(s).add "\0\0" + +proc add*(s: var wstring, u: wstring) = + ## Appends `u` to `s` in place. + setLen(string(s), string(s).len - 2) + string(s).add(string(u)) + +proc `&`*(s: wstring, c: WCHAR|char): wstring {.inline.} = + ## Concatenates `s` with `c`. + result = s + result.add c + +proc `&`*(s, u: wstring): wstring {.inline.} = + ## Concatenates `s` with `u`. + result = s + result.add u + +proc toHex*(s: wstring): string {.inline.} = + ## Converts `wstring` to its hexadecimal representation. + ## No prefix like ``0x`` is generated. + result = toHex(&s, s.len * 2) + +iterator items*(s: wstring): WCHAR = + ## Iterates over each `WCHAR` of `wstring`. + var i = 0 + while i < s.len: + yield s.raw(i) + inc i + +iterator mitems*(s: var wstring): var WCHAR = + ## Iterates over each `WCHAR` of `wstring` so that you can modify the yielded value. + var i = 0 + while i < s.len: + yield s.raw(i) + inc i + +iterator pairs*(s: wstring): tuple[key: int, val: WCHAR] = + ## Iterates over each `WCHAR` of `wstring`. Yields `(int, WCHAR)` pairs. + var i = 0 + while i < s.len: + yield (i, s.raw(i)) + inc i + +iterator mpairs*(s: var wstring): tuple[key: int, val: var WCHAR] = + ## Iterates over each `WCHAR` of `wstring`. Yields `(int, var WCHAR)` pairs. + var i = 0 + while i < s.len: + yield (i, s.raw(i)) + inc i + +proc repr*(s: wstring): string = + ## Returns string representation of `wstring`. + result = $cast[int](&s).tohex & "(wstring)\"" + if s.len != 0: + for w in s: + if w == 0: + result.add "\\0" + + else: + result.add `UNICODE->string`(w.unsafeaddr, 1) + + result.add "\"" + +# mstring functions + +proc mlen*(s: mstring): int = + ## Returns the length of `mstring`, counting by MBCS characters. + result = int MultiByteToWideChar(CP_ACP, 0, &s, int32 s.len, nil, 0) + +proc high*(s: mstring): int {.borrow.} + ## Returns the highest possible index of `mstring`. + +proc low*(s: mstring): int {.borrow.} + ## Returns the lowest possible index of `mstring`. + +proc cmp*(x, y: mstring): int {.borrow.} + ## Compare proc for `mstring` (in binary format only). + +proc `==`*(x, y: mstring): bool {.borrow.} + ## Checks for equality between two `mstring`. + +proc `<=`*(x, y: mstring): bool {.borrow.} + ## Lexicographic ``<=`` operator for `mstring`. + +proc `<`*(x, y: mstring): bool {.borrow.} + ## Lexicographic ``<`` operator for `mstring`. + +proc substr*(s: mstring, first, last: int): mstring {.borrow.} + ## Copies a slice of `s` into a new `mstring` and returns it, counting by bytes. + +proc substr*(s: mstring, first = 0): mstring {.borrow.} + ## Copies a slice of `s` into a new `mstring` and returns it, counting by bytes. + +proc `[]`*(s: mstring, i: int): char {.inline.} = string(s)[i] + ## Index operator for `mstring`, counting by bytes. + +proc `[]=`*(s: var mstring, i: int, x: char|byte) {.inline.} = string(s)[i] = cast[char](x) + ## Index assignment operator for `mstring`, counting by bytes. + +proc substr*(s: mstring, first, last: mIndex): mstring = + ## Copies a slice of `s` into a new `mstring` and returns it, counting by MBCS characters. + var ws = `ANSI->wstring`(&s, s.len) + ws = ws.substr(int first, int last) + result = `UNICODE->mstring`(&ws, ws.len) + +proc substr*(s: mstring, first: mIndex = 0.mIndex): mstring = + ## Copies a slice of `s` into a new `mstring` and returns it, counting by MBCS characters. + var ws = `ANSI->wstring`(&s, s.len) + ws = ws.substr(int first) + result = `UNICODE->mstring`(&ws, ws.len) + +proc `[]`*(s: mstring, i: mIndex): mstring = + ## Index operator for `mstring`, counting by MBCS characters. + let ws = `ANSI->wstring`(&s, s.len) + var wchar = ws[int i] + result = `UNICODE->mstring`(addr wchar, 1) + +proc `[]=`*(s: var mstring, i: mIndex, u: mstring) = + ## Index assignment operator for `mstring`, counting by MBCS characters, + ## and only first MBCS characters of `u` will be used. + var ws = `ANSI->wstring`(&s, s.len) + let wu = `ANSI->wstring`(&u, u.len) + + if wu.len == 0: + ws[int i] = 0 + + else: + ws[int i] = wu[0] + + s = `UNICODE->mstring`(&ws, ws.len) + +proc `[]`*[T, U](s: mstring, x: HSlice[T, U]): mstring = + ## Slice operation for `mstring`. + when T is mIndex or U is mIndex: + var ws = `[]`(`ANSI->wstring`(&s, s.len), x) + result = `UNICODE->mstring`(&ws, ws.len) + + else: + result = mstring(`[]`(string(s), x)) + +proc `[]=`*[T, U](s: var mstring, x: HSlice[T, U], u: mstring) = + ## Slice assignment for `mstrings`. + when T is mIndex or U is mIndex: + var ws = `ANSI->wstring`(&s, s.len) + `[]=`(ws, x, `ANSI->wstring`(&u, u.len)) + s = `UNICODE->mstring`(&ws, ws.len) + else: + `[]=`(string(s), x, string(u)) + +proc add*(x: var mstring, y: char) {.borrow.} + ## Appends `y` to `x` in place. + +proc add*(x: var mstring, y: string) {.borrow.} + ## Appends `y` to `x` in place. + +proc add*(x: var mstring, y: mstring) {.borrow.} + ## Appends `y` to `x` in place. + +proc add*(x: var mstring, y: byte) {.inline.} = x.add(char(y)) + ## Appends `y` to `x` in place. + +proc `&`*(x: mstring, y: char): mstring {.borrow.} + ## Concatenates `x` with `y`. + +proc `&`*(x, y: mstring): mstring {.borrow.} + ## Concatenates `x` with `y`. + +proc `&`*(x: char, y: mstring): mstring {.borrow.} + ## Concatenates `x` with `y`. + +proc toHex*(s: mstring): string {.inline.} = + ## Converts `mstring` to its hexadecimal representation. + ## No prefix like ``0x`` is generated. + result = toHex(&s, s.len) + +iterator items*(s: mstring): mstring = + ## Iterates over each MBCS character of `mstring`. + var ws = `ANSI->wstring`(&s, s.len) + for wchar in ws.mitems: + yield `UNICODE->mstring`(addr wchar, 1) + +iterator pairs*(s: mstring): tuple[key: mIndex, val: mstring] = + ## Iterates over each MBCS character of `mstring`. Yields `(mIndex, mstring)` pairs. + var ws = `ANSI->wstring`(&s, s.len) + for i, wchar in ws.mpairs: + yield (mIndex i, `UNICODE->mstring`(addr wchar, 1)) + +proc repr*(s: mstring): string = + ## Returns string representation of `mstring`. + result = $cast[int](&s).tohex & "(mstring)\"" + if s.len != 0: + for m in s: + if m[0] == '\0': + result.add "\\0" + + else: + result.add `ANSI->string`(&m, m.len) + + result &= "\"" + +# conversion functions + +var isOpenArrayStringable {.threadvar.}: bool + +proc setOpenArrayStringable*(flag: bool): bool {.inline, discardable.} = + ## Nim's system.`$` will return array representation for `openArray[SomeChar]`. + ## After turn this option on, winstr will overwrite the defualt behavior + ## for `$` and treats `openArray[SomeChar]` as string. + result = isOpenArrayStringable + isOpenArrayStringable = flag + +proc `$`*(s: Stringable): string {.inline.} = + ## Convert any stringable type to `string`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is utf8 encoding. + when s is char|byte: system.`$`(s) + elif s is WCHAR: system.`$`(s) + elif s is string: s + elif s is mstring: `ANSI->string`(&s, s.len) + elif s is wstring: `UNICODE->string`(&s, s.len) + elif s is cstring|ptr char|ptr byte: system.`$`(cast[cstring](s)) + elif s is ptr WCHAR: `UNICODE->string`(s, lstrlenW(s)) + elif s is BSTR: `UNICODE->string`(s, int SysStringLen(s)) + elif s is array|seq|openArray: + if isOpenArrayStringable: + when sizeof(s[0]) == 1: `UTF8->string`(s) + elif sizeof(s[0]) == 2: `UNICODE->string`(s) + else: {.fatal: "invalid type".} + else: + system.`$`(s) + elif s is ptr array: + when sizeof(s[][0]) == 1: `UTF8->string`(s[]) + elif sizeof(s[][0]) == 2: `UNICODE->string`(s[]) + else: {.fatal: "invalid type".} + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `UTF8->string`(s.getptr, lstrlenA(s.getptr)) + elif sizeof(s[0]) == 2: `UNICODE->string`(s.getptr, lstrlenW(s.getptr)) + else: {.fatal: "invalid type".} + else: {.fatal: "invalid type".} + +proc `%$`*(s: Stringable): string {.inline.} = + ## Convert any stringable type to `string`. Always treat `openArray[SomeChar]` as string. + ## This operator assume `string|cstring|ptr char|openArray[char]` is utf8 encoding. + when s is char|byte: system.`$`(s) + elif s is WCHAR: `UNICODE->string`(unsafeaddr s, 1) + elif s is string: s + elif s is mstring: `ANSI->string`(&s, s.len) + elif s is wstring: `UNICODE->string`(&s, s.len) + elif s is cstring|ptr char|ptr byte: system.`$`(cast[cstring](s)) + elif s is ptr WCHAR: `UNICODE->string`(s, lstrlenW(s)) + elif s is BSTR: `UNICODE->string`(s, int SysStringLen(s)) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `UTF8->string`(s) + elif sizeof(s[0]) == 2: `UNICODE->string`(s) + else: {.fatal: "invalid type".} + elif s is ptr array: + when sizeof(s[][0]) == 1: `UTF8->string`(s[]) + elif sizeof(s[][0]) == 2: `UNICODE->string`(s[]) + else: {.fatal: "invalid type".} + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `UTF8->string`(s.getptr, lstrlenA(s.getptr)) + elif sizeof(s[0]) == 2: `UNICODE->string`(s.getptr, lstrlenW(s.getptr)) + else: {.fatal: "invalid type".} + else: {.fatal: "invalid type".} + +proc `+$`*(s: Stringable): wstring {.inline.} = + ## Convert any stringable type to `wstring`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is utf8 encoding. + when s is char|byte: `UTF8->wstring`(cast[ptr char](unsafeaddr s), 1) + elif s is WCHAR: `UNICODE->wstring`(unsafeaddr s, 1) + elif s is string: `UTF8->wstring`(&s, s.len) + elif s is mstring: `ANSI->wstring`(&s, s.len) + elif s is wstring: s + elif s is cstring|ptr char|ptr byte: `UTF8->wstring`(cast[ptr char](s), cast[cstring](s).len) + elif s is ptr WCHAR: `UNICODE->wstring`(s, lstrlenW(s)) + elif s is BSTR: `UNICODE->wstring`(s, int SysStringLen(s)) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `UTF8->wstring`(s) + elif sizeof(s[0]) == 2: `UNICODE->wstring`(s) + else: {.fatal: "invalid type".} + elif s is ptr array: + when sizeof(s[][0]) == 1: `UTF8->wstring`(s[]) + elif sizeof(s[][0]) == 2: `UNICODE->wstring`(s[]) + else: {.fatal: "invalid type".} + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `UTF8->wstring`(s.getptr, lstrlenA(s.getptr)) + elif sizeof(s[0]) == 2: `UNICODE->wstring`(s.getptr, lstrlenW(s.getptr)) + else: {.fatal: "invalid type".} + else: {.fatal: "invalid type".} + +proc `-$`*(s: Stringable): mstring {.inline.} = + ## Convert any stringable type to `mstring`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is utf8 encoding. + when s is char|byte: `UTF8->mstring`(cast[ptr char](unsafeaddr s), 1) + elif s is WCHAR: `UNICODE->mstring`(unsafeaddr s, 1) + elif s is string: `UTF8->mstring`(&s, s.len) + elif s is mstring: s + elif s is wstring: `UNICODE->mstring`(&s, s.len) + elif s is cstring|ptr char|ptr byte: `UTF8->mstring`(cast[ptr char](s), cast[cstring](s).len) + elif s is ptr WCHAR: `UNICODE->mstring`(s, lstrlenW(s)) + elif s is BSTR: `UNICODE->mstring`(s, int SysStringLen(s)) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `UTF8->mstring`(s) + elif sizeof(s[0]) == 2: `UNICODE->mstring`(s) + else: {.fatal: "invalid type".} + elif s is ptr array: + when sizeof(s[][0]) == 1: `UTF8->mstring`(s[]) + elif sizeof(s[][0]) == 2: `UNICODE->mstring`(s[]) + else: {.fatal: "invalid type".} + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `UTF8->mstring`(s.getptr, lstrlenA(s.getptr)) + elif sizeof(s[0]) == 2: `UNICODE->mstring`(s.getptr, lstrlenW(s.getptr)) + else: {.fatal: "invalid type".} + else: {.fatal: "invalid type".} + +proc `$$`*(s: Stringable): string {.inline.} = + ## Convert any stringable type to `string`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is ansi encoding. + # Only exception is `WCHAR(uint16)`: regard as number in `$`, but string in `$$` + when s is WCHAR: `UNICODE->string`(unsafeaddr s, 1) + elif s is string: `ANSI->string`(&s, s.len) + elif s is cstring|ptr char|ptr byte: `ANSI->string`(cast[ptr char](s), cast[cstring](s).len) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `ANSI->string`(s) + elif sizeof(s[0]) == 2: `UNICODE->string`(s) + elif s is ptr array: + when sizeof(s[][0]) == 1: `ANSI->string`(s[]) + else: `$`(s) + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `ANSI->string`(s.getptr, lstrlenA(s.getptr)) + else: `$`(s) + else: `$`(s) + +proc `+$$`*(s: Stringable): wstring {.inline.} = + ## Convert any stringable type to `wstring`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is ansi encoding. + when s is string: `ANSI->wstring`(&s, s.len) + elif s is cstring|ptr char|ptr byte: `ANSI->wstring`(cast[ptr char](s), cast[cstring](s).len) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `ANSI->wstring`(s) + else: `+$`(s) + elif s is ptr array: + when sizeof(s[][0]) == 1: `ANSI->wstring`(s[]) + else: `+$`(s) + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `ANSI->wstring`(s.getptr, lstrlenA(s.getptr)) + else: `+$`(s) + else: `+$`(s) + +proc `-$$`*(s: Stringable): mstring {.inline.} = + ## Convert any stringable type to `mstring`. + ## This operator assume `string|cstring|ptr char|openArray[char]` is ansi encoding. + when s is string: `ANSI->mstring`(&s, s.len) + elif s is cstring|ptr char|ptr byte: `ANSI->mstring`(cast[ptr char](s), cast[cstring](s).len) + elif s is array|seq|openArray: + when sizeof(s[0]) == 1: `ANSI->mstring`(s) + else: `-$`(s) + elif s is ptr array: + when sizeof(s[][0]) == 1: `ANSI->mstring`(s[]) + else: `-$`(s) + elif s is ptr UncheckedArray: + when sizeof(s[0]) == 1: `ANSI->mstring`(s.getptr, lstrlenA(s.getptr)) + else: `-$`(s) + else: `-$`(s) + +proc fillBuffer[T: SomeChar](a: var openArray[T], s: SomeString, skip = 0, inclNull = false) = + when sizeof(a[0]) != sizeof(s[0]): + {.fatal: "type mismatch".} + + for i in 0 .. min(a.high, s.len - skip - 1): + a[i] = cast[T](s[i + skip]) + + if inclNull and a.high >= s.len: + a[s.len - skip] = cast[T](0) + + # fill as much as possible before raise an exception + if (not inclNull and a.high < s.len - skip - 1) or (inclNull and a.high < s.len - skip): + raise newException(IndexDefect, "string length too long") + +proc fillString[T: SomeChar](s: var SomeString, a: openArray[T], skip = 0) = + when sizeof(a[0]) != sizeof(s[0]): + {.fatal: "type mismatch".} + + for i in 0 .. min(a.high, s.len - skip - 1): + s[i + skip] = cast[s[0].type](a[i]) + +template `<<`*[A: SomeBuffer|SomeString, B: SomeBuffer|SomeString](a: A, b: B) = + ## Fill operator for `SomeBuffer` and `SomeString`. + ## Please make sure both side have the same character size. + ## If destination don't have the length information (e.g. `pointer` or `UncheckedArray`), + ## please make sure the buffer size is large enough. + when A is SomeString and B is SomeString: + # treat string a as buffer + var v = cast[ptr UncheckedArray[a[0].type]](&a) + fillBuffer(v.toOpenArray(0, a.len - 1), b, inclNull=false) + + elif A is not SomeString and B is SomeString: + when A is array: + fillBuffer(a.toOpenArray(a.low, a.high), b, skip=a.low, inclNull=false) + + elif A is ptr array: + fillBuffer(a[].toOpenArray(a[].low, a[].high), b, skip=a[].low, inclNull=false) + + elif A is ptr char | ptr byte: + var v = cast[ptr UncheckedArray[byte]](a) + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=false) + + elif A is ptr WCHAR: + var v = cast[ptr UncheckedArray[WCHAR]](a) + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=false) + + elif A is ptr UncheckedArray: + var v = a + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=false) + + elif A is openArray | seq: + fillBuffer(a, b, inclNull=false) + + else: + {.fatal: "type mismatch".} + + elif A is SomeString and B is not SomeString: + when B is array: + fillString(a, b.toOpenArray(b.low, b.high), skip=b.low) + + elif B is ptr array: + fillString(a, b[].toOpenArray(b[].low, b[].high), skip=b[].low) + + elif B is ptr char | ptr byte: + fillString(a, cast[ptr UncheckedArray[byte]](b).toOpenArray(0, int.high - 1)) + + elif B is ptr WCHAR: + fillString(a, cast[ptr UncheckedArray[WCHAR]](b).toOpenArray(0, int.high - 1)) + + elif B is ptr UncheckedArray: + fillString(a, b.toOpenArray(0, int.high - 1)) + + elif B is openArray | seq: + fillString(a, b) + + else: + {.fatal: "type mismatch".} + + else: + {.fatal: "type mismatch".} + +template `<<<`*[A: SomeBuffer|SomeString](a: A, b: SomeString) = + ## Fill buffer by string, include a null. + ## Please make sure both side have the same character size. + ## If destination don't have the length information (e.g. `pointer` or `UncheckedArray`), + ## please make sure the buffer size is large enough. + when A is SomeString: + # treat string a as buffer + var v = cast[ptr UncheckedArray[a[0].type]](&a) + fillBuffer(v.toOpenArray(0, a.len - 1), b, inclNull=true) + + else: + when A is array: + fillBuffer(a.toOpenArray(a.low, a.high), b, skip=a.low, inclNull=true) + + elif A is ptr array: + fillBuffer(a[].toOpenArray(a[].low, a[].high), b, skip=a[].low, inclNull=true) + + elif A is ptr char | ptr byte: + var v = cast[ptr UncheckedArray[byte]](a) + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=true) + + elif A is ptr WCHAR: + var v = cast[ptr UncheckedArray[WCHAR]](a) + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=true) + + elif A is ptr UncheckedArray: + var v = a + fillBuffer(v.toOpenArray(0, int.high - 1), b, inclNull=true) + + elif A is openArray | seq: + fillBuffer(a, b, inclNull=true) + + else: + {.fatal: "type mismatch".} + +template `>>`*(a: typed, b: typed) = + ## This is the same as `b << a`. + b << a + +template `>>>`*(a: typed, b: typed) = + ## This is the same as `b <<< a`. + b <<< a + +proc nullTerminate*(s: var SomeString) {.inline.} = + ## Assume a string is null terminated and set the correct length. + when s is string|mstring: + let L = lstrlenA(cast[LPCSTR](&s)) + if L < s.len: + s.setLen(L) + + elif s is wstring: + let L = lstrlenW(cast[LPWSTR](&s)) + if L < s.len: + s.setLen(L) + + else: {.fatal: "invalid type".} + +proc nullTerminated*[T: SomeString](s: T): T {.inline.} = + ## Assume a string is null terminated and return the length-corrected string. + when s is string: + result = newString(lstrlenA(cast[LPCSTR](&s))) + result << &s + + elif s is mstring: + result = newMString(lstrlenA(cast[LPCSTR](&s))) + result << &s + + elif s is wstring: + result = newWString(lstrlenW(cast[LPWSTR](&s))) + result << &s + + else: {.fatal: "invalid type".} + +# generics has problems on converters, define one by one + +converter winstrConverterWStringToLPWSTR*(x: wstring): LPWSTR = cast[LPWSTR](&x) + ## Converts `wstring` to `LPWSTR` automatically. + +converter winstrConverterWStringToBSTR*(x: wstring): BSTR = cast[BSTR](&x) + ## Converts `wstring` to `BSTR` automatically. + +converter winstrConverterBSTRToLPWSTR*(x: BSTR): LPWSTR = cast[LPWSTR](x) + ## Converts `BSTR` to `LPWSTR` automatically. + +converter winstrConverterStringToPtrChar*(x: string): ptr char = cast[ptr char](&x) + ## Converts `string` to `ptr char` automatically. + +converter winstrConverterCStringToPtrChar*(x: cstring): ptr char = cast[ptr char](x) + ## Converts `cstring` to `ptr char` automatically. + +converter winstrConverterMStringToPtrChar*(x: mstring): ptr char = cast[ptr char](&x) + ## Converts `mstring` to `ptr char` automatically. + +converter winstrConverterMStringToLPSTR*(x: mstring): LPSTR = cast[LPSTR](&x) + ## Converts `mstring` to `LPSTR` automatically. + +when defined(gcDestructors): + converter winstrConverterWideCStringToLPWSTR*(x: WideCStringObj): LPWSTR = cast[LPWSTR](x[0].unsafeaddr) + ## Converts `WideCString` to `LPWSTR` automatically. + + proc `+$`*(s: WideCStringObj): wstring {.inline.} = + ## Converts `WideCString` to `wstring`. + +$cast[LPWSTR](s[0].unsafeaddr) + + proc newWideCString*(s: wstring): WideCStringObj {.inline.} = + ## Converts `wstring` to `WideCString`. + when compiles(newWideCString(1)): + result = newWideCString(s.len) + copyMem(result[0].unsafeaddr, &s, s.len * 2) + else: + result = newWideCString("", s.len) + s >> result + +else: + converter winstrConverterWideCStringToLPWSTR*(x: WideCString): LPWSTR = cast[LPWSTR](x[0].unsafeaddr) + ## Converts `WideCString` to `LPWSTR` automatically. + + proc `+$`*(s: WideCString): wstring {.inline.} = + ## Converts `WideCString` to `wstring`. + +$cast[LPWSTR](s[0].unsafeaddr) + + proc newWideCString*(s: wstring): WideCString {.inline.} = + ## Converts `wstring` to `WideCString`. + when compiles(newWideCString(1)): + result = newWideCString(s.len) + copyMem(result[0].unsafeaddr, &s, s.len * 2) + else: + result = newWideCString("", s.len) + s >> result + +when defined(gcDestructors): + # Here is the workaround for --gc:arc and --newruntime. It is a tricky problem, + # wstring needs to be alive until converter ending so that the windows API can + # use the pointer later. + + import deques + var wstringQueue {.threadvar.}: Deque[wstring] + var wstringQueueInit {.threadvar.}: bool + + proc saddr(str: sink wstring): LPWSTR = + if not wstringQueueInit: + wstringQueue = initDeque[wstring]() + wstringQueueInit = true + + elif wstringQueue.len > 128: + wstringQueue.shrink(fromFirst=64) + + wstringQueue.addLast str + &wstringQueue[^1] + + converter winstrConverterStringToLPWSTR*(x: string): LPWSTR = saddr(+$x) + ## Converts `string` to `LPWSTR` automatically. + + converter winstrConverterCStringToLPWSTR*(x: cstring): LPWSTR = saddr(+$x) + ## Converts `cstring` to `LPWSTR` automatically. + + converter winstrConverterStringToBSTR*(x: string): BSTR = cast[BSTR](saddr(+$x)) + ## Converts `string` to `BSTR` automatically. + + converter winstrConverterCStringToBSTR*(x: cstring): BSTR = cast[BSTR](saddr(+$x)) + ## Converts `cstring` to `BSTR` automatically. + +else: + converter winstrConverterStringToLPWSTR*(x: string): LPWSTR = cast[LPWSTR](&(+$x)) + ## Converts `string` to `LPWSTR` automatically. + + converter winstrConverterCStringToLPWSTR*(x: cstring): LPWSTR = cast[LPWSTR](&(+$x)) + ## Converts `cstring` to `LPWSTR` automatically. + + converter winstrConverterStringToBSTR*(x: string): BSTR = cast[BSTR](&(+$x)) + ## Converts `string` to `BSTR` automatically. + + converter winstrConverterCStringToBSTR*(x: cstring): BSTR = cast[BSTR](&(+$x)) + ## Converts `cstring` to `BSTR` automatically. + +proc newWString*(s: cstring|string|mstring): wstring {.inline, + deprecated: "use `+$` instead".} = + ## Return a new `wstring`. + result = +$s + +proc newMString*(s: string|cstring|wstring): mstring {.inline, + deprecated: "use `-$` instead".} = + ## Return a new `mstring`. + result = -$s + +proc ctNewWString(s: static[string]): wstring {.compiletime.} = + # copy from widestrs.nim, use WCHAR instead of Utf16Char + const + UNI_REPLACEMENT_CHAR = WCHAR(0xFFFD'u16) + UNI_MAX_BMP = 0x0000FFFF + UNI_MAX_UTF16 = 0x0010FFFF + + halfShift = 10 + halfBase = 0x0010000 + halfMask = 0x3FF + + UNI_SUR_HIGH_START = 0xD800 + UNI_SUR_LOW_START = 0xDC00 + UNI_SUR_LOW_END = 0xDFFF + UNI_REPL = 0xFFFD + + template ones(n: untyped): untyped = ((1 shl n)-1) + + template fastRuneAt(s: cstring, i, L: int, result: untyped, doInc = true) = + if ord(s[i]) <= 127: + result = ord(s[i]) + when doInc: inc(i) + elif ord(s[i]) shr 5 == 0b110: + if i <= L - 2: + result = (ord(s[i]) and (ones(5))) shl 6 or (ord(s[i+1]) and ones(6)) + when doInc: inc(i, 2) + else: + result = UNI_REPL + when doInc: inc(i) + elif ord(s[i]) shr 4 == 0b1110: + if i <= L - 3: + result = (ord(s[i]) and ones(4)) shl 12 or + (ord(s[i+1]) and ones(6)) shl 6 or + (ord(s[i+2]) and ones(6)) + when doInc: inc(i, 3) + else: + result = UNI_REPL + when doInc: inc(i) + elif ord(s[i]) shr 3 == 0b11110: + if i <= L - 4: + result = (ord(s[i]) and ones(3)) shl 18 or + (ord(s[i+1]) and ones(6)) shl 12 or + (ord(s[i+2]) and ones(6)) shl 6 or + (ord(s[i+3]) and ones(6)) + when doInc: inc(i, 4) + else: + result = UNI_REPL + when doInc: inc(i) + else: + result = 0xFFFD + when doInc: inc(i) + + iterator runes(s: cstring, L: int): int = + var + i = 0 + ret: int + + while i < L: + fastRuneAt(s, i, L, ret, true) + yield ret + + iterator WCHARs(source: cstring, L: int): WCHAR = + for ch in runes(source, L): + if ch <=% UNI_MAX_BMP: + if ch >=% UNI_SUR_HIGH_START and ch <=% UNI_SUR_LOW_END: + yield UNI_REPLACEMENT_CHAR + else: + yield WCHAR(ch) + elif ch >% UNI_MAX_UTF16: + yield UNI_REPLACEMENT_CHAR + else: + let ch = ch -% halfBase + yield WCHAR((ch shr halfShift) +% UNI_SUR_HIGH_START) + yield WCHAR((ch and halfMask) +% UNI_SUR_LOW_START) + + var ret: string + for u in WCHARs(s, s.len): + ret.add char(u and 0xFF) + ret.add char(u shr 8) + + ret.add "\0\0" + result = wstring ret + +template L*(x: static[string]): wstring = + ## Generate const wstring from `static[string]` at compile-time. + const wstr = ctNewWString(x) + wstr + +template L*(x: string): wstring = +$x + ## Same as `+$` for dynamic string (string at run-time). + +template T*(x: string): untyped = + ## Generate wstring or mstring depend on conditional symbol: `useWinAnsi`. + # must export winimbase to use winimAnsi here. + when winimAnsi: + -$x + else: + L(x) + +template T*(x: Natural): untyped = + ## Generate wstring or mstring buffer depend on conditional symbol: `useWinAnsi`. + ## Use `&` to get the buffer address and then pass to Windows API. + when winimAnsi: + newMString(x) + else: + newWString(x) + +when winimAnsi: + type + TString* = mstring ## `wstring` or `mstring` depend on conditional symbol: `useWinAnsi`. +else: + type + TString* = wstring ## `wstring` or `mstring` depend on conditional symbol: `useWinAnsi`. + +when isMainModule: + let str = "the quick brown fox jumps over the lazy dog" + echo +$str == L"the quick brown fox jumps over the lazy dog" diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/LICENSE --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/LICENSE Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/cursorfont.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/cursorfont.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,110 @@ +# $Xorg: cursorfont.h,v 1.4 2001/02/09 02:03:39 xorgcvs Exp $ +# +# +#Copyright 1987, 1998 The Open Group +# +#Permission to use, copy, modify, distribute, and sell this software and its +#documentation for any purpose is hereby granted without fee, provided that +#the above copyright notice appear in all copies and that both that +#copyright notice and this permission notice appear in supporting +#documentation. +# +#The above copyright notice and this permission notice shall be included +#in all copies or substantial portions of the Software. +# +#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +#OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +#IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +#OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +#ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +#OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of The Open Group shall +#not be used in advertising or otherwise to promote the sale, use or +#other dealings in this Software without prior written authorization +#from The Open Group. +# +# + +const + XC_num_glyphs* = 154 + XC_X_cursor* = 0 + XC_arrow* = 2 + XC_based_arrow_down* = 4 + XC_based_arrow_up* = 6 + XC_boat* = 8 + XC_bogosity* = 10 + XC_bottom_left_corner* = 12 + XC_bottom_right_corner* = 14 + XC_bottom_side* = 16 + XC_bottom_tee* = 18 + XC_box_spiral* = 20 + XC_center_ptr* = 22 + XC_circle* = 24 + XC_clock* = 26 + XC_coffee_mug* = 28 + XC_cross* = 30 + XC_cross_reverse* = 32 + XC_crosshair* = 34 + XC_diamond_cross* = 36 + XC_dot* = 38 + XC_dotbox* = 40 + XC_double_arrow* = 42 + XC_draft_large* = 44 + XC_draft_small* = 46 + XC_draped_box* = 48 + XC_exchange* = 50 + XC_fleur* = 52 + XC_gobbler* = 54 + XC_gumby* = 56 + XC_hand1* = 58 + XC_hand2* = 60 + XC_heart* = 62 + XC_icon* = 64 + XC_iron_cross* = 66 + XC_left_ptr* = 68 + XC_left_side* = 70 + XC_left_tee* = 72 + XC_leftbutton* = 74 + XC_ll_angle* = 76 + XC_lr_angle* = 78 + XC_man* = 80 + XC_middlebutton* = 82 + XC_mouse* = 84 + XC_pencil* = 86 + XC_pirate* = 88 + XC_plus* = 90 + XC_question_arrow* = 92 + XC_right_ptr* = 94 + XC_right_side* = 96 + XC_right_tee* = 98 + XC_rightbutton* = 100 + XC_rtl_logo* = 102 + XC_sailboat* = 104 + XC_sb_down_arrow* = 106 + XC_sb_h_double_arrow* = 108 + XC_sb_left_arrow* = 110 + XC_sb_right_arrow* = 112 + XC_sb_up_arrow* = 114 + XC_sb_v_double_arrow* = 116 + XC_shuttle* = 118 + XC_sizing* = 120 + XC_spider* = 122 + XC_spraycan* = 124 + XC_star* = 126 + XC_target* = 128 + XC_tcross* = 130 + XC_top_left_arrow* = 132 + XC_top_left_corner* = 134 + XC_top_right_corner* = 136 + XC_top_side* = 138 + XC_top_tee* = 140 + XC_trek* = 142 + XC_ul_angle* = 144 + XC_umbrella* = 146 + XC_ur_angle* = 148 + XC_watch* = 150 + XC_xterm* = 152 + +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/keysym.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/keysym.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,1926 @@ +# +#Converted from X11/keysym.h and X11/keysymdef.h +# +#Capital letter consts renamed from XK_... to XKc_... +# (since Pascal isn't case-sensitive) +# +#i.e. +#C Pascal +#XK_a XK_a +#XK_A XKc_A +# + +#* default keysyms * +import x + +const + XK_VoidSymbol*: KeySym = 0x00FFFFFF # void symbol + +when defined(XK_MISCELLANY) or true: + const + #* + # * TTY Functions, cleverly chosen to map to ascii, for convenience of + # * programming, but could have been arbitrary (at the cost of lookup + # * tables in client code. + # * + XK_BackSpace*: KeySym = 0x0000FF08 # back space, back char + XK_Tab*: KeySym = 0x0000FF09 + XK_Linefeed*: KeySym = 0x0000FF0A # Linefeed, LF + XK_Clear*: KeySym = 0x0000FF0B + XK_Return*: KeySym = 0x0000FF0D # Return, enter + XK_Pause*: KeySym = 0x0000FF13 # Pause, hold + XK_Scroll_Lock*: KeySym = 0x0000FF14 + XK_Sys_Req*: KeySym = 0x0000FF15 + XK_Escape*: KeySym = 0x0000FF1B + XK_Delete*: KeySym = 0x0000FFFF # Delete, rubout \ + # International & multi-key character composition + XK_Multi_key*: KeySym = 0x0000FF20 # Multi-key character compose + XK_Codeinput*: KeySym = 0x0000FF37 + XK_SingleCandidate*: KeySym = 0x0000FF3C + XK_MultipleCandidate*: KeySym = 0x0000FF3D + XK_PreviousCandidate*: KeySym = 0x0000FF3E # Japanese keyboard support + XK_Kanji*: KeySym = 0x0000FF21 # Kanji, Kanji convert + XK_Muhenkan*: KeySym = 0x0000FF22 # Cancel Conversion + XK_Henkan_Mode*: KeySym = 0x0000FF23 # Start/Stop Conversion + XK_Henkan*: KeySym = 0x0000FF23 # Alias for Henkan_Mode + XK_Romaji*: KeySym = 0x0000FF24 # to Romaji + XK_Hiragana*: KeySym = 0x0000FF25 # to Hiragana + XK_Katakana*: KeySym = 0x0000FF26 # to Katakana + XK_Hiragana_Katakana*: KeySym = 0x0000FF27 # Hiragana/Katakana toggle + XK_Zenkaku*: KeySym = 0x0000FF28 # to Zenkaku + XK_Hankaku*: KeySym = 0x0000FF29 # to Hankaku + XK_Zenkaku_Hankaku*: KeySym = 0x0000FF2A # Zenkaku/Hankaku toggle + XK_Touroku*: KeySym = 0x0000FF2B # Add to Dictionary + XK_Massyo*: KeySym = 0x0000FF2C # Delete from Dictionary + XK_Kana_Lock*: KeySym = 0x0000FF2D # Kana Lock + XK_Kana_Shift*: KeySym = 0x0000FF2E # Kana Shift + XK_Eisu_Shift*: KeySym = 0x0000FF2F # Alphanumeric Shift + XK_Eisu_toggle*: KeySym = 0x0000FF30 # Alphanumeric toggle + XK_Kanji_Bangou*: KeySym = 0x0000FF37 # Codeinput + XK_Zen_Koho*: KeySym = 0x0000FF3D # Multiple/All Candidate(s) + XK_Mae_Koho*: KeySym = 0x0000FF3E # Previous Candidate \ + # = $FF31 thru = $FF3F are under XK_KOREAN + # Cursor control & motion + XK_Home*: KeySym = 0x0000FF50 + XK_Left*: KeySym = 0x0000FF51 # Move left, left arrow + XK_Up*: KeySym = 0x0000FF52 # Move up, up arrow + XK_Right*: KeySym = 0x0000FF53 # Move right, right arrow + XK_Down*: KeySym = 0x0000FF54 # Move down, down arrow + XK_Prior*: KeySym = 0x0000FF55 # Prior, previous + XK_Page_Up*: KeySym = 0x0000FF55 + XK_Next*: KeySym = 0x0000FF56 # Next + XK_Page_Down*: KeySym = 0x0000FF56 + XK_End*: KeySym = 0x0000FF57 # EOL + XK_Begin*: KeySym = 0x0000FF58 # BOL \ + # Misc Functions + XK_Select*: KeySym = 0x0000FF60 # Select, mark + XK_Print*: KeySym = 0x0000FF61 + XK_Execute*: KeySym = 0x0000FF62 # Execute, run, do + XK_Insert*: KeySym = 0x0000FF63 # Insert, insert here + XK_Undo*: KeySym = 0x0000FF65 # Undo, oops + XK_Redo*: KeySym = 0x0000FF66 # redo, again + XK_Menu*: KeySym = 0x0000FF67 + XK_Find*: KeySym = 0x0000FF68 # Find, search + XK_Cancel*: KeySym = 0x0000FF69 # Cancel, stop, abort, exit + XK_Help*: KeySym = 0x0000FF6A # Help + XK_Break*: KeySym = 0x0000FF6B + XK_Mode_switch*: KeySym = 0x0000FF7E # Character set switch + XK_script_switch*: KeySym = 0x0000FF7E # Alias for mode_switch + XK_Num_Lock*: KeySym = 0x0000FF7F # Keypad Functions, keypad numbers cleverly chosen to map to ascii + XK_KP_Space*: KeySym = 0x0000FF80 # space + XK_KP_Tab*: KeySym = 0x0000FF89 + XK_KP_Enter*: KeySym = 0x0000FF8D # enter + XK_KP_F1*: KeySym = 0x0000FF91 # PF1, KP_A, ... + XK_KP_F2*: KeySym = 0x0000FF92 + XK_KP_F3*: KeySym = 0x0000FF93 + XK_KP_F4*: KeySym = 0x0000FF94 + XK_KP_Home*: KeySym = 0x0000FF95 + XK_KP_Left*: KeySym = 0x0000FF96 + XK_KP_Up*: KeySym = 0x0000FF97 + XK_KP_Right*: KeySym = 0x0000FF98 + XK_KP_Down*: KeySym = 0x0000FF99 + XK_KP_Prior*: KeySym = 0x0000FF9A + XK_KP_Page_Up*: KeySym = 0x0000FF9A + XK_KP_Next*: KeySym = 0x0000FF9B + XK_KP_Page_Down*: KeySym = 0x0000FF9B + XK_KP_End*: KeySym = 0x0000FF9C + XK_KP_Begin*: KeySym = 0x0000FF9D + XK_KP_Insert*: KeySym = 0x0000FF9E + XK_KP_Delete*: KeySym = 0x0000FF9F + XK_KP_Equal*: KeySym = 0x0000FFBD # equals + XK_KP_Multiply*: KeySym = 0x0000FFAA + XK_KP_Add*: KeySym = 0x0000FFAB + XK_KP_Separator*: KeySym = 0x0000FFAC # separator, often comma + XK_KP_Subtract*: KeySym = 0x0000FFAD + XK_KP_Decimal*: KeySym = 0x0000FFAE + XK_KP_Divide*: KeySym = 0x0000FFAF + XK_KP_0*: KeySym = 0x0000FFB0 + XK_KP_1*: KeySym = 0x0000FFB1 + XK_KP_2*: KeySym = 0x0000FFB2 + XK_KP_3*: KeySym = 0x0000FFB3 + XK_KP_4*: KeySym = 0x0000FFB4 + XK_KP_5*: KeySym = 0x0000FFB5 + XK_KP_6*: KeySym = 0x0000FFB6 + XK_KP_7*: KeySym = 0x0000FFB7 + XK_KP_8*: KeySym = 0x0000FFB8 + XK_KP_9*: KeySym = 0x0000FFB9 #*\ + # * Auxilliary Functions; note the duplicate definitions for left and right + # * function keys; Sun keyboards and a few other manufactures have such + # * function key groups on the left and/or right sides of the keyboard. + # * We've not found a keyboard with more than 35 function keys total. + # * + XK_F1*: KeySym = 0x0000FFBE + XK_F2*: KeySym = 0x0000FFBF + XK_F3*: KeySym = 0x0000FFC0 + XK_F4*: KeySym = 0x0000FFC1 + XK_F5*: KeySym = 0x0000FFC2 + XK_F6*: KeySym = 0x0000FFC3 + XK_F7*: KeySym = 0x0000FFC4 + XK_F8*: KeySym = 0x0000FFC5 + XK_F9*: KeySym = 0x0000FFC6 + XK_F10*: KeySym = 0x0000FFC7 + XK_F11*: KeySym = 0x0000FFC8 + XK_L1*: KeySym = 0x0000FFC8 + XK_F12*: KeySym = 0x0000FFC9 + XK_L2*: KeySym = 0x0000FFC9 + XK_F13*: KeySym = 0x0000FFCA + XK_L3*: KeySym = 0x0000FFCA + XK_F14*: KeySym = 0x0000FFCB + XK_L4*: KeySym = 0x0000FFCB + XK_F15*: KeySym = 0x0000FFCC + XK_L5*: KeySym = 0x0000FFCC + XK_F16*: KeySym = 0x0000FFCD + XK_L6*: KeySym = 0x0000FFCD + XK_F17*: KeySym = 0x0000FFCE + XK_L7*: KeySym = 0x0000FFCE + XK_F18*: KeySym = 0x0000FFCF + XK_L8*: KeySym = 0x0000FFCF + XK_F19*: KeySym = 0x0000FFD0 + XK_L9*: KeySym = 0x0000FFD0 + XK_F20*: KeySym = 0x0000FFD1 + XK_L10*: KeySym = 0x0000FFD1 + XK_F21*: KeySym = 0x0000FFD2 + XK_R1*: KeySym = 0x0000FFD2 + XK_F22*: KeySym = 0x0000FFD3 + XK_R2*: KeySym = 0x0000FFD3 + XK_F23*: KeySym = 0x0000FFD4 + XK_R3*: KeySym = 0x0000FFD4 + XK_F24*: KeySym = 0x0000FFD5 + XK_R4*: KeySym = 0x0000FFD5 + XK_F25*: KeySym = 0x0000FFD6 + XK_R5*: KeySym = 0x0000FFD6 + XK_F26*: KeySym = 0x0000FFD7 + XK_R6*: KeySym = 0x0000FFD7 + XK_F27*: KeySym = 0x0000FFD8 + XK_R7*: KeySym = 0x0000FFD8 + XK_F28*: KeySym = 0x0000FFD9 + XK_R8*: KeySym = 0x0000FFD9 + XK_F29*: KeySym = 0x0000FFDA + XK_R9*: KeySym = 0x0000FFDA + XK_F30*: KeySym = 0x0000FFDB + XK_R10*: KeySym = 0x0000FFDB + XK_F31*: KeySym = 0x0000FFDC + XK_R11*: KeySym = 0x0000FFDC + XK_F32*: KeySym = 0x0000FFDD + XK_R12*: KeySym = 0x0000FFDD + XK_F33*: KeySym = 0x0000FFDE + XK_R13*: KeySym = 0x0000FFDE + XK_F34*: KeySym = 0x0000FFDF + XK_R14*: KeySym = 0x0000FFDF + XK_F35*: KeySym = 0x0000FFE0 + XK_R15*: KeySym = 0x0000FFE0 # Modifiers + XK_Shift_L*: KeySym = 0x0000FFE1 # Left shift + XK_Shift_R*: KeySym = 0x0000FFE2 # Right shift + XK_Control_L*: KeySym = 0x0000FFE3 # Left control + XK_Control_R*: KeySym = 0x0000FFE4 # Right control + XK_Caps_Lock*: KeySym = 0x0000FFE5 # Caps lock + XK_Shift_Lock*: KeySym = 0x0000FFE6 # Shift lock + XK_Meta_L*: KeySym = 0x0000FFE7 # Left meta + XK_Meta_R*: KeySym = 0x0000FFE8 # Right meta + XK_Alt_L*: KeySym = 0x0000FFE9 # Left alt + XK_Alt_R*: KeySym = 0x0000FFEA # Right alt + XK_Super_L*: KeySym = 0x0000FFEB # Left super + XK_Super_R*: KeySym = 0x0000FFEC # Right super + XK_Hyper_L*: KeySym = 0x0000FFED # Left hyper + XK_Hyper_R*: KeySym = 0x0000FFEE # Right hyper +# XK_MISCELLANY +#* +# * ISO 9995 Function and Modifier Keys +# * Byte 3 = = $FE +# * + +when defined(XK_XKB_KEYS) or true: + const + XK_ISO_Lock*: KeySym = 0x0000FE01 + XK_ISO_Level2_Latch*: KeySym = 0x0000FE02 + XK_ISO_Level3_Shift*: KeySym = 0x0000FE03 + XK_ISO_Level3_Latch*: KeySym = 0x0000FE04 + XK_ISO_Level3_Lock*: KeySym = 0x0000FE05 + XK_ISO_Group_Shift*: KeySym = 0x0000FF7E # Alias for mode_switch + XK_ISO_Group_Latch*: KeySym = 0x0000FE06 + XK_ISO_Group_Lock*: KeySym = 0x0000FE07 + XK_ISO_Next_Group*: KeySym = 0x0000FE08 + XK_ISO_Next_Group_Lock*: KeySym = 0x0000FE09 + XK_ISO_Prev_Group*: KeySym = 0x0000FE0A + XK_ISO_Prev_Group_Lock*: KeySym = 0x0000FE0B + XK_ISO_First_Group*: KeySym = 0x0000FE0C + XK_ISO_First_Group_Lock*: KeySym = 0x0000FE0D + XK_ISO_Last_Group*: KeySym = 0x0000FE0E + XK_ISO_Last_Group_Lock*: KeySym = 0x0000FE0F + XK_ISO_Left_Tab*: KeySym = 0x0000FE20 + XK_ISO_Move_Line_Up*: KeySym = 0x0000FE21 + XK_ISO_Move_Line_Down*: KeySym = 0x0000FE22 + XK_ISO_Partial_Line_Up*: KeySym = 0x0000FE23 + XK_ISO_Partial_Line_Down*: KeySym = 0x0000FE24 + XK_ISO_Partial_Space_Left*: KeySym = 0x0000FE25 + XK_ISO_Partial_Space_Right*: KeySym = 0x0000FE26 + XK_ISO_Set_Margin_Left*: KeySym = 0x0000FE27 + XK_ISO_Set_Margin_Right*: KeySym = 0x0000FE28 + XK_ISO_Release_Margin_Left*: KeySym = 0x0000FE29 + XK_ISO_Release_Margin_Right*: KeySym = 0x0000FE2A + XK_ISO_Release_Both_Margins*: KeySym = 0x0000FE2B + XK_ISO_Fast_Cursor_Left*: KeySym = 0x0000FE2C + XK_ISO_Fast_Cursor_Right*: KeySym = 0x0000FE2D + XK_ISO_Fast_Cursor_Up*: KeySym = 0x0000FE2E + XK_ISO_Fast_Cursor_Down*: KeySym = 0x0000FE2F + XK_ISO_Continuous_Underline*: KeySym = 0x0000FE30 + XK_ISO_Discontinuous_Underline*: KeySym = 0x0000FE31 + XK_ISO_Emphasize*: KeySym = 0x0000FE32 + XK_ISO_Center_Object*: KeySym = 0x0000FE33 + XK_ISO_Enter*: KeySym = 0x0000FE34 + XK_dead_grave*: KeySym = 0x0000FE50 + XK_dead_acute*: KeySym = 0x0000FE51 + XK_dead_circumflex*: KeySym = 0x0000FE52 + XK_dead_tilde*: KeySym = 0x0000FE53 + XK_dead_macron*: KeySym = 0x0000FE54 + XK_dead_breve*: KeySym = 0x0000FE55 + XK_dead_abovedot*: KeySym = 0x0000FE56 + XK_dead_diaeresis*: KeySym = 0x0000FE57 + XK_dead_abovering*: KeySym = 0x0000FE58 + XK_dead_doubleacute*: KeySym = 0x0000FE59 + XK_dead_caron*: KeySym = 0x0000FE5A + XK_dead_cedilla*: KeySym = 0x0000FE5B + XK_dead_ogonek*: KeySym = 0x0000FE5C + XK_dead_iota*: KeySym = 0x0000FE5D + XK_dead_voiced_sound*: KeySym = 0x0000FE5E + XK_dead_semivoiced_sound*: KeySym = 0x0000FE5F + XK_dead_belowdot*: KeySym = 0x0000FE60 + XK_dead_hook*: KeySym = 0x0000FE61 + XK_dead_horn*: KeySym = 0x0000FE62 + XK_First_Virtual_Screen*: KeySym = 0x0000FED0 + XK_Prev_Virtual_Screen*: KeySym = 0x0000FED1 + XK_Next_Virtual_Screen*: KeySym = 0x0000FED2 + XK_Last_Virtual_Screen*: KeySym = 0x0000FED4 + XK_Terminate_Server*: KeySym = 0x0000FED5 + XK_AccessX_Enable*: KeySym = 0x0000FE70 + XK_AccessX_Feedback_Enable*: KeySym = 0x0000FE71 + XK_RepeatKeys_Enable*: KeySym = 0x0000FE72 + XK_SlowKeys_Enable*: KeySym = 0x0000FE73 + XK_BounceKeys_Enable*: KeySym = 0x0000FE74 + XK_StickyKeys_Enable*: KeySym = 0x0000FE75 + XK_MouseKeys_Enable*: KeySym = 0x0000FE76 + XK_MouseKeys_Accel_Enable*: KeySym = 0x0000FE77 + XK_Overlay1_Enable*: KeySym = 0x0000FE78 + XK_Overlay2_Enable*: KeySym = 0x0000FE79 + XK_AudibleBell_Enable*: KeySym = 0x0000FE7A + XK_Pointer_Left*: KeySym = 0x0000FEE0 + XK_Pointer_Right*: KeySym = 0x0000FEE1 + XK_Pointer_Up*: KeySym = 0x0000FEE2 + XK_Pointer_Down*: KeySym = 0x0000FEE3 + XK_Pointer_UpLeft*: KeySym = 0x0000FEE4 + XK_Pointer_UpRight*: KeySym = 0x0000FEE5 + XK_Pointer_DownLeft*: KeySym = 0x0000FEE6 + XK_Pointer_DownRight*: KeySym = 0x0000FEE7 + XK_Pointer_Button_Dflt*: KeySym = 0x0000FEE8 + XK_Pointer_Button1*: KeySym = 0x0000FEE9 + XK_Pointer_Button2*: KeySym = 0x0000FEEA + XK_Pointer_Button3*: KeySym = 0x0000FEEB + XK_Pointer_Button4*: KeySym = 0x0000FEEC + XK_Pointer_Button5*: KeySym = 0x0000FEED + XK_Pointer_DblClick_Dflt*: KeySym = 0x0000FEEE + XK_Pointer_DblClick1*: KeySym = 0x0000FEEF + XK_Pointer_DblClick2*: KeySym = 0x0000FEF0 + XK_Pointer_DblClick3*: KeySym = 0x0000FEF1 + XK_Pointer_DblClick4*: KeySym = 0x0000FEF2 + XK_Pointer_DblClick5*: KeySym = 0x0000FEF3 + XK_Pointer_Drag_Dflt*: KeySym = 0x0000FEF4 + XK_Pointer_Drag1*: KeySym = 0x0000FEF5 + XK_Pointer_Drag2*: KeySym = 0x0000FEF6 + XK_Pointer_Drag3*: KeySym = 0x0000FEF7 + XK_Pointer_Drag4*: KeySym = 0x0000FEF8 + XK_Pointer_Drag5*: KeySym = 0x0000FEFD + XK_Pointer_EnableKeys*: KeySym = 0x0000FEF9 + XK_Pointer_Accelerate*: KeySym = 0x0000FEFA + XK_Pointer_DfltBtnNext*: KeySym = 0x0000FEFB + XK_Pointer_DfltBtnPrev*: KeySym = 0x0000FEFC + #* + # * 3270 Terminal Keys + # * Byte 3 = = $FD + # * + +when defined(XK_3270) or true: + const + XK_3270_Duplicate*: KeySym = 0x0000FD01 + XK_3270_FieldMark*: KeySym = 0x0000FD02 + XK_3270_Right2*: KeySym = 0x0000FD03 + XK_3270_Left2*: KeySym = 0x0000FD04 + XK_3270_BackTab*: KeySym = 0x0000FD05 + XK_3270_EraseEOF*: KeySym = 0x0000FD06 + XK_3270_EraseInput*: KeySym = 0x0000FD07 + XK_3270_Reset*: KeySym = 0x0000FD08 + XK_3270_Quit*: KeySym = 0x0000FD09 + XK_3270_PA1*: KeySym = 0x0000FD0A + XK_3270_PA2*: KeySym = 0x0000FD0B + XK_3270_PA3*: KeySym = 0x0000FD0C + XK_3270_Test*: KeySym = 0x0000FD0D + XK_3270_Attn*: KeySym = 0x0000FD0E + XK_3270_CursorBlink*: KeySym = 0x0000FD0F + XK_3270_AltCursor*: KeySym = 0x0000FD10 + XK_3270_KeyClick*: KeySym = 0x0000FD11 + XK_3270_Jump*: KeySym = 0x0000FD12 + XK_3270_Ident*: KeySym = 0x0000FD13 + XK_3270_Rule*: KeySym = 0x0000FD14 + XK_3270_Copy*: KeySym = 0x0000FD15 + XK_3270_Play*: KeySym = 0x0000FD16 + XK_3270_Setup*: KeySym = 0x0000FD17 + XK_3270_Record*: KeySym = 0x0000FD18 + XK_3270_ChangeScreen*: KeySym = 0x0000FD19 + XK_3270_DeleteWord*: KeySym = 0x0000FD1A + XK_3270_ExSelect*: KeySym = 0x0000FD1B + XK_3270_CursorSelect*: KeySym = 0x0000FD1C + XK_3270_PrintScreen*: KeySym = 0x0000FD1D + XK_3270_Enter*: KeySym = 0x0000FD1E +#* +# * Latin 1 +# * Byte 3 = 0 +# * + +when defined(XK_LATIN1) or true: + const + XK_space*: KeySym = 0x00000020 + XK_exclam*: KeySym = 0x00000021 + XK_quotedbl*: KeySym = 0x00000022 + XK_numbersign*: KeySym = 0x00000023 + XK_dollar*: KeySym = 0x00000024 + XK_percent*: KeySym = 0x00000025 + XK_ampersand*: KeySym = 0x00000026 + XK_apostrophe*: KeySym = 0x00000027 + XK_quoteright*: KeySym = 0x00000027 # deprecated + XK_parenleft*: KeySym = 0x00000028 + XK_parenright*: KeySym = 0x00000029 + XK_asterisk*: KeySym = 0x0000002A + XK_plus*: KeySym = 0x0000002B + XK_comma*: KeySym = 0x0000002C + XK_minus*: KeySym = 0x0000002D + XK_period*: KeySym = 0x0000002E + XK_slash*: KeySym = 0x0000002F + XK_0*: KeySym = 0x00000030 + XK_1*: KeySym = 0x00000031 + XK_2*: KeySym = 0x00000032 + XK_3*: KeySym = 0x00000033 + XK_4*: KeySym = 0x00000034 + XK_5*: KeySym = 0x00000035 + XK_6*: KeySym = 0x00000036 + XK_7*: KeySym = 0x00000037 + XK_8*: KeySym = 0x00000038 + XK_9*: KeySym = 0x00000039 + XK_colon*: KeySym = 0x0000003A + XK_semicolon*: KeySym = 0x0000003B + XK_less*: KeySym = 0x0000003C + XK_equal*: KeySym = 0x0000003D + XK_greater*: KeySym = 0x0000003E + XK_question*: KeySym = 0x0000003F + XK_at*: KeySym = 0x00000040 + XKc_A*: KeySym = 0x00000041 + XKc_B*: KeySym = 0x00000042 + XKc_C*: KeySym = 0x00000043 + XKc_D*: KeySym = 0x00000044 + XKc_E*: KeySym = 0x00000045 + XKc_F*: KeySym = 0x00000046 + XKc_G*: KeySym = 0x00000047 + XKc_H*: KeySym = 0x00000048 + XKc_I*: KeySym = 0x00000049 + XKc_J*: KeySym = 0x0000004A + XKc_K*: KeySym = 0x0000004B + XKc_L*: KeySym = 0x0000004C + XKc_M*: KeySym = 0x0000004D + XKc_N*: KeySym = 0x0000004E + XKc_O*: KeySym = 0x0000004F + XKc_P*: KeySym = 0x00000050 + XKc_Q*: KeySym = 0x00000051 + XKc_R*: KeySym = 0x00000052 + XKc_S*: KeySym = 0x00000053 + XKc_T*: KeySym = 0x00000054 + XKc_U*: KeySym = 0x00000055 + XKc_V*: KeySym = 0x00000056 + XKc_W*: KeySym = 0x00000057 + XKc_X*: KeySym = 0x00000058 + XKc_Y*: KeySym = 0x00000059 + XKc_Z*: KeySym = 0x0000005A + XK_bracketleft*: KeySym = 0x0000005B + XK_backslash*: KeySym = 0x0000005C + XK_bracketright*: KeySym = 0x0000005D + XK_asciicircum*: KeySym = 0x0000005E + XK_underscore*: KeySym = 0x0000005F + XK_grave*: KeySym = 0x00000060 + XK_quoteleft*: KeySym = 0x00000060 # deprecated + XK_a*: KeySym = 0x00000061 + XK_b*: KeySym = 0x00000062 + XK_c*: KeySym = 0x00000063 + XK_d*: KeySym = 0x00000064 + XK_e*: KeySym = 0x00000065 + XK_f*: KeySym = 0x00000066 + XK_g*: KeySym = 0x00000067 + XK_h*: KeySym = 0x00000068 + XK_i*: KeySym = 0x00000069 + XK_j*: KeySym = 0x0000006A + XK_k*: KeySym = 0x0000006B + XK_l*: KeySym = 0x0000006C + XK_m*: KeySym = 0x0000006D + XK_n*: KeySym = 0x0000006E + XK_o*: KeySym = 0x0000006F + XK_p*: KeySym = 0x00000070 + XK_q*: KeySym = 0x00000071 + XK_r*: KeySym = 0x00000072 + XK_s*: KeySym = 0x00000073 + XK_t*: KeySym = 0x00000074 + XK_u*: KeySym = 0x00000075 + XK_v*: KeySym = 0x00000076 + XK_w*: KeySym = 0x00000077 + XK_x*: KeySym = 0x00000078 + XK_y*: KeySym = 0x00000079 + XK_z*: KeySym = 0x0000007A + XK_braceleft*: KeySym = 0x0000007B + XK_bar*: KeySym = 0x0000007C + XK_braceright*: KeySym = 0x0000007D + XK_asciitilde*: KeySym = 0x0000007E + XK_nobreakspace*: KeySym = 0x000000A0 + XK_exclamdown*: KeySym = 0x000000A1 + XK_cent*: KeySym = 0x000000A2 + XK_sterling*: KeySym = 0x000000A3 + XK_currency*: KeySym = 0x000000A4 + XK_yen*: KeySym = 0x000000A5 + XK_brokenbar*: KeySym = 0x000000A6 + XK_section*: KeySym = 0x000000A7 + XK_diaeresis*: KeySym = 0x000000A8 + XK_copyright*: KeySym = 0x000000A9 + XK_ordfeminine*: KeySym = 0x000000AA + XK_guillemotleft*: KeySym = 0x000000AB # left angle quotation mark + XK_notsign*: KeySym = 0x000000AC + XK_hyphen*: KeySym = 0x000000AD + XK_registered*: KeySym = 0x000000AE + XK_macron*: KeySym = 0x000000AF + XK_degree*: KeySym = 0x000000B0 + XK_plusminus*: KeySym = 0x000000B1 + XK_twosuperior*: KeySym = 0x000000B2 + XK_threesuperior*: KeySym = 0x000000B3 + XK_acute*: KeySym = 0x000000B4 + XK_mu*: KeySym = 0x000000B5 + XK_paragraph*: KeySym = 0x000000B6 + XK_periodcentered*: KeySym = 0x000000B7 + XK_cedilla*: KeySym = 0x000000B8 + XK_onesuperior*: KeySym = 0x000000B9 + XK_masculine*: KeySym = 0x000000BA + XK_guillemotright*: KeySym = 0x000000BB # right angle quotation mark + XK_onequarter*: KeySym = 0x000000BC + XK_onehalf*: KeySym = 0x000000BD + XK_threequarters*: KeySym = 0x000000BE + XK_questiondown*: KeySym = 0x000000BF + XKc_Agrave*: KeySym = 0x000000C0 + XKc_Aacute*: KeySym = 0x000000C1 + XKc_Acircumflex*: KeySym = 0x000000C2 + XKc_Atilde*: KeySym = 0x000000C3 + XKc_Adiaeresis*: KeySym = 0x000000C4 + XKc_Aring*: KeySym = 0x000000C5 + XKc_AE*: KeySym = 0x000000C6 + XKc_Ccedilla*: KeySym = 0x000000C7 + XKc_Egrave*: KeySym = 0x000000C8 + XKc_Eacute*: KeySym = 0x000000C9 + XKc_Ecircumflex*: KeySym = 0x000000CA + XKc_Ediaeresis*: KeySym = 0x000000CB + XKc_Igrave*: KeySym = 0x000000CC + XKc_Iacute*: KeySym = 0x000000CD + XKc_Icircumflex*: KeySym = 0x000000CE + XKc_Idiaeresis*: KeySym = 0x000000CF + XKc_ETH*: KeySym = 0x000000D0 + XKc_Ntilde*: KeySym = 0x000000D1 + XKc_Ograve*: KeySym = 0x000000D2 + XKc_Oacute*: KeySym = 0x000000D3 + XKc_Ocircumflex*: KeySym = 0x000000D4 + XKc_Otilde*: KeySym = 0x000000D5 + XKc_Odiaeresis*: KeySym = 0x000000D6 + XK_multiply*: KeySym = 0x000000D7 + XKc_Ooblique*: KeySym = 0x000000D8 + XKc_Oslash*: KeySym = XKc_Ooblique + XKc_Ugrave*: KeySym = 0x000000D9 + XKc_Uacute*: KeySym = 0x000000DA + XKc_Ucircumflex*: KeySym = 0x000000DB + XKc_Udiaeresis*: KeySym = 0x000000DC + XKc_Yacute*: KeySym = 0x000000DD + XKc_THORN*: KeySym = 0x000000DE + XK_ssharp*: KeySym = 0x000000DF + XK_agrave*: KeySym = 0x000000E0 + XK_aacute*: KeySym = 0x000000E1 + XK_acircumflex*: KeySym = 0x000000E2 + XK_atilde*: KeySym = 0x000000E3 + XK_adiaeresis*: KeySym = 0x000000E4 + XK_aring*: KeySym = 0x000000E5 + XK_ae*: KeySym = 0x000000E6 + XK_ccedilla*: KeySym = 0x000000E7 + XK_egrave*: KeySym = 0x000000E8 + XK_eacute*: KeySym = 0x000000E9 + XK_ecircumflex*: KeySym = 0x000000EA + XK_ediaeresis*: KeySym = 0x000000EB + XK_igrave*: KeySym = 0x000000EC + XK_iacute*: KeySym = 0x000000ED + XK_icircumflex*: KeySym = 0x000000EE + XK_idiaeresis*: KeySym = 0x000000EF + XK_eth*: KeySym = 0x000000F0 + XK_ntilde*: KeySym = 0x000000F1 + XK_ograve*: KeySym = 0x000000F2 + XK_oacute*: KeySym = 0x000000F3 + XK_ocircumflex*: KeySym = 0x000000F4 + XK_otilde*: KeySym = 0x000000F5 + XK_odiaeresis*: KeySym = 0x000000F6 + XK_division*: KeySym = 0x000000F7 + XK_oslash*: KeySym = 0x000000F8 + XK_ooblique*: KeySym = XK_oslash + XK_ugrave*: KeySym = 0x000000F9 + XK_uacute*: KeySym = 0x000000FA + XK_ucircumflex*: KeySym = 0x000000FB + XK_udiaeresis*: KeySym = 0x000000FC + XK_yacute*: KeySym = 0x000000FD + XK_thorn*: KeySym = 0x000000FE + XK_ydiaeresis*: KeySym = 0x000000FF +# XK_LATIN1 +#* +# * Latin 2 +# * Byte 3 = 1 +# * + +when defined(XK_LATIN2) or true: + const + XKc_Aogonek*: KeySym = 0x000001A1 + XK_breve*: KeySym = 0x000001A2 + XKc_Lstroke*: KeySym = 0x000001A3 + XKc_Lcaron*: KeySym = 0x000001A5 + XKc_Sacute*: KeySym = 0x000001A6 + XKc_Scaron*: KeySym = 0x000001A9 + XKc_Scedilla*: KeySym = 0x000001AA + XKc_Tcaron*: KeySym = 0x000001AB + XKc_Zacute*: KeySym = 0x000001AC + XKc_Zcaron*: KeySym = 0x000001AE + XKc_Zabovedot*: KeySym = 0x000001AF + XK_aogonek*: KeySym = 0x000001B1 + XK_ogonek*: KeySym = 0x000001B2 + XK_lstroke*: KeySym = 0x000001B3 + XK_lcaron*: KeySym = 0x000001B5 + XK_sacute*: KeySym = 0x000001B6 + XK_caron*: KeySym = 0x000001B7 + XK_scaron*: KeySym = 0x000001B9 + XK_scedilla*: KeySym = 0x000001BA + XK_tcaron*: KeySym = 0x000001BB + XK_zacute*: KeySym = 0x000001BC + XK_doubleacute*: KeySym = 0x000001BD + XK_zcaron*: KeySym = 0x000001BE + XK_zabovedot*: KeySym = 0x000001BF + XKc_Racute*: KeySym = 0x000001C0 + XKc_Abreve*: KeySym = 0x000001C3 + XKc_Lacute*: KeySym = 0x000001C5 + XKc_Cacute*: KeySym = 0x000001C6 + XKc_Ccaron*: KeySym = 0x000001C8 + XKc_Eogonek*: KeySym = 0x000001CA + XKc_Ecaron*: KeySym = 0x000001CC + XKc_Dcaron*: KeySym = 0x000001CF + XKc_Dstroke*: KeySym = 0x000001D0 + XKc_Nacute*: KeySym = 0x000001D1 + XKc_Ncaron*: KeySym = 0x000001D2 + XKc_Odoubleacute*: KeySym = 0x000001D5 + XKc_Rcaron*: KeySym = 0x000001D8 + XKc_Uring*: KeySym = 0x000001D9 + XKc_Udoubleacute*: KeySym = 0x000001DB + XKc_Tcedilla*: KeySym = 0x000001DE + XK_racute*: KeySym = 0x000001E0 + XK_abreve*: KeySym = 0x000001E3 + XK_lacute*: KeySym = 0x000001E5 + XK_cacute*: KeySym = 0x000001E6 + XK_ccaron*: KeySym = 0x000001E8 + XK_eogonek*: KeySym = 0x000001EA + XK_ecaron*: KeySym = 0x000001EC + XK_dcaron*: KeySym = 0x000001EF + XK_dstroke*: KeySym = 0x000001F0 + XK_nacute*: KeySym = 0x000001F1 + XK_ncaron*: KeySym = 0x000001F2 + XK_odoubleacute*: KeySym = 0x000001F5 + XK_udoubleacute*: KeySym = 0x000001FB + XK_rcaron*: KeySym = 0x000001F8 + XK_uring*: KeySym = 0x000001F9 + XK_tcedilla*: KeySym = 0x000001FE + XK_abovedot*: KeySym = 0x000001FF +# XK_LATIN2 +#* +# * Latin 3 +# * Byte 3 = 2 +# * + +when defined(XK_LATIN3) or true: + const + XKc_Hstroke*: KeySym = 0x000002A1 + XKc_Hcircumflex*: KeySym = 0x000002A6 + XKc_Iabovedot*: KeySym = 0x000002A9 + XKc_Gbreve*: KeySym = 0x000002AB + XKc_Jcircumflex*: KeySym = 0x000002AC + XK_hstroke*: KeySym = 0x000002B1 + XK_hcircumflex*: KeySym = 0x000002B6 + XK_idotless*: KeySym = 0x000002B9 + XK_gbreve*: KeySym = 0x000002BB + XK_jcircumflex*: KeySym = 0x000002BC + XKc_Cabovedot*: KeySym = 0x000002C5 + XKc_Ccircumflex*: KeySym = 0x000002C6 + XKc_Gabovedot*: KeySym = 0x000002D5 + XKc_Gcircumflex*: KeySym = 0x000002D8 + XKc_Ubreve*: KeySym = 0x000002DD + XKc_Scircumflex*: KeySym = 0x000002DE + XK_cabovedot*: KeySym = 0x000002E5 + XK_ccircumflex*: KeySym = 0x000002E6 + XK_gabovedot*: KeySym = 0x000002F5 + XK_gcircumflex*: KeySym = 0x000002F8 + XK_ubreve*: KeySym = 0x000002FD + XK_scircumflex*: KeySym = 0x000002FE +# XK_LATIN3 +#* +# * Latin 4 +# * Byte 3 = 3 +# * + +when defined(XK_LATIN4) or true: + const + XK_kra*: KeySym = 0x000003A2 + XK_kappa*: KeySym = 0x000003A2 # deprecated + XKc_Rcedilla*: KeySym = 0x000003A3 + XKc_Itilde*: KeySym = 0x000003A5 + XKc_Lcedilla*: KeySym = 0x000003A6 + XKc_Emacron*: KeySym = 0x000003AA + XKc_Gcedilla*: KeySym = 0x000003AB + XKc_Tslash*: KeySym = 0x000003AC + XK_rcedilla*: KeySym = 0x000003B3 + XK_itilde*: KeySym = 0x000003B5 + XK_lcedilla*: KeySym = 0x000003B6 + XK_emacron*: KeySym = 0x000003BA + XK_gcedilla*: KeySym = 0x000003BB + XK_tslash*: KeySym = 0x000003BC + XKc_ENG*: KeySym = 0x000003BD + XK_eng*: KeySym = 0x000003BF + XKc_Amacron*: KeySym = 0x000003C0 + XKc_Iogonek*: KeySym = 0x000003C7 + XKc_Eabovedot*: KeySym = 0x000003CC + XKc_Imacron*: KeySym = 0x000003CF + XKc_Ncedilla*: KeySym = 0x000003D1 + XKc_Omacron*: KeySym = 0x000003D2 + XKc_Kcedilla*: KeySym = 0x000003D3 + XKc_Uogonek*: KeySym = 0x000003D9 + XKc_Utilde*: KeySym = 0x000003DD + XKc_Umacron*: KeySym = 0x000003DE + XK_amacron*: KeySym = 0x000003E0 + XK_iogonek*: KeySym = 0x000003E7 + XK_eabovedot*: KeySym = 0x000003EC + XK_imacron*: KeySym = 0x000003EF + XK_ncedilla*: KeySym = 0x000003F1 + XK_omacron*: KeySym = 0x000003F2 + XK_kcedilla*: KeySym = 0x000003F3 + XK_uogonek*: KeySym = 0x000003F9 + XK_utilde*: KeySym = 0x000003FD + XK_umacron*: KeySym = 0x000003FE +# XK_LATIN4 +#* +# * Latin-8 +# * Byte 3 = 18 +# * + +when defined(XK_LATIN8) or true: + const + XKc_Babovedot*: KeySym = 0x000012A1 + XK_babovedot*: KeySym = 0x000012A2 + XKc_Dabovedot*: KeySym = 0x000012A6 + XKc_Wgrave*: KeySym = 0x000012A8 + XKc_Wacute*: KeySym = 0x000012AA + XK_dabovedot*: KeySym = 0x000012AB + XKc_Ygrave*: KeySym = 0x000012AC + XKc_Fabovedot*: KeySym = 0x000012B0 + XK_fabovedot*: KeySym = 0x000012B1 + XKc_Mabovedot*: KeySym = 0x000012B4 + XK_mabovedot*: KeySym = 0x000012B5 + XKc_Pabovedot*: KeySym = 0x000012B7 + XK_wgrave*: KeySym = 0x000012B8 + XK_pabovedot*: KeySym = 0x000012B9 + XK_wacute*: KeySym = 0x000012BA + XKc_Sabovedot*: KeySym = 0x000012BB + XK_ygrave*: KeySym = 0x000012BC + XKc_Wdiaeresis*: KeySym = 0x000012BD + XK_wdiaeresis*: KeySym = 0x000012BE + XK_sabovedot*: KeySym = 0x000012BF + XKc_Wcircumflex*: KeySym = 0x000012D0 + XKc_Tabovedot*: KeySym = 0x000012D7 + XKc_Ycircumflex*: KeySym = 0x000012DE + XK_wcircumflex*: KeySym = 0x000012F0 + XK_tabovedot*: KeySym = 0x000012F7 + XK_ycircumflex*: KeySym = 0x000012FE +# XK_LATIN8 +#* +# * Latin-9 (a.k.a. Latin-0) +# * Byte 3 = 19 +# * + +when defined(XK_LATIN9) or true: + const + XKc_OE*: KeySym = 0x000013BC + XK_oe*: KeySym = 0x000013BD + XKc_Ydiaeresis*: KeySym = 0x000013BE +# XK_LATIN9 +#* +# * Katakana +# * Byte 3 = 4 +# * + +when defined(XK_KATAKANA) or true: + const + XK_overline*: KeySym = 0x0000047E + XK_kana_fullstop*: KeySym = 0x000004A1 + XK_kana_openingbracket*: KeySym = 0x000004A2 + XK_kana_closingbracket*: KeySym = 0x000004A3 + XK_kana_comma*: KeySym = 0x000004A4 + XK_kana_conjunctive*: KeySym = 0x000004A5 + XK_kana_middledot*: KeySym = 0x000004A5 # deprecated + XKc_kana_WO*: KeySym = 0x000004A6 + XK_kana_a*: KeySym = 0x000004A7 + XK_kana_i*: KeySym = 0x000004A8 + XK_kana_u*: KeySym = 0x000004A9 + XK_kana_e*: KeySym = 0x000004AA + XK_kana_o*: KeySym = 0x000004AB + XK_kana_ya*: KeySym = 0x000004AC + XK_kana_yu*: KeySym = 0x000004AD + XK_kana_yo*: KeySym = 0x000004AE + XK_kana_tsu*: KeySym = 0x000004AF + XK_kana_tu*: KeySym = 0x000004AF # deprecated + XK_prolongedsound*: KeySym = 0x000004B0 + XKc_kana_A*: KeySym = 0x000004B1 + XKc_kana_I*: KeySym = 0x000004B2 + XKc_kana_U*: KeySym = 0x000004B3 + XKc_kana_E*: KeySym = 0x000004B4 + XKc_kana_O*: KeySym = 0x000004B5 + XKc_kana_KA*: KeySym = 0x000004B6 + XKc_kana_KI*: KeySym = 0x000004B7 + XKc_kana_KU*: KeySym = 0x000004B8 + XKc_kana_KE*: KeySym = 0x000004B9 + XKc_kana_KO*: KeySym = 0x000004BA + XKc_kana_SA*: KeySym = 0x000004BB + XKc_kana_SHI*: KeySym = 0x000004BC + XKc_kana_SU*: KeySym = 0x000004BD + XKc_kana_SE*: KeySym = 0x000004BE + XKc_kana_SO*: KeySym = 0x000004BF + XKc_kana_TA*: KeySym = 0x000004C0 + XKc_kana_CHI*: KeySym = 0x000004C1 + XKc_kana_TI*: KeySym = 0x000004C1 # deprecated + XKc_kana_TSU*: KeySym = 0x000004C2 + XKc_kana_TU*: KeySym = 0x000004C2 # deprecated + XKc_kana_TE*: KeySym = 0x000004C3 + XKc_kana_TO*: KeySym = 0x000004C4 + XKc_kana_NA*: KeySym = 0x000004C5 + XKc_kana_NI*: KeySym = 0x000004C6 + XKc_kana_NU*: KeySym = 0x000004C7 + XKc_kana_NE*: KeySym = 0x000004C8 + XKc_kana_NO*: KeySym = 0x000004C9 + XKc_kana_HA*: KeySym = 0x000004CA + XKc_kana_HI*: KeySym = 0x000004CB + XKc_kana_FU*: KeySym = 0x000004CC + XKc_kana_HU*: KeySym = 0x000004CC # deprecated + XKc_kana_HE*: KeySym = 0x000004CD + XKc_kana_HO*: KeySym = 0x000004CE + XKc_kana_MA*: KeySym = 0x000004CF + XKc_kana_MI*: KeySym = 0x000004D0 + XKc_kana_MU*: KeySym = 0x000004D1 + XKc_kana_ME*: KeySym = 0x000004D2 + XKc_kana_MO*: KeySym = 0x000004D3 + XKc_kana_YA*: KeySym = 0x000004D4 + XKc_kana_YU*: KeySym = 0x000004D5 + XKc_kana_YO*: KeySym = 0x000004D6 + XKc_kana_RA*: KeySym = 0x000004D7 + XKc_kana_RI*: KeySym = 0x000004D8 + XKc_kana_RU*: KeySym = 0x000004D9 + XKc_kana_RE*: KeySym = 0x000004DA + XKc_kana_RO*: KeySym = 0x000004DB + XKc_kana_WA*: KeySym = 0x000004DC + XKc_kana_N*: KeySym = 0x000004DD + XK_voicedsound*: KeySym = 0x000004DE + XK_semivoicedsound*: KeySym = 0x000004DF + XK_kana_switch*: KeySym = 0x0000FF7E # Alias for mode_switch +# XK_KATAKANA +#* +# * Arabic +# * Byte 3 = 5 +# * + +when defined(XK_ARABIC) or true: + const + XK_Farsi_0*: KeySym = 0x00000590 + XK_Farsi_1*: KeySym = 0x00000591 + XK_Farsi_2*: KeySym = 0x00000592 + XK_Farsi_3*: KeySym = 0x00000593 + XK_Farsi_4*: KeySym = 0x00000594 + XK_Farsi_5*: KeySym = 0x00000595 + XK_Farsi_6*: KeySym = 0x00000596 + XK_Farsi_7*: KeySym = 0x00000597 + XK_Farsi_8*: KeySym = 0x00000598 + XK_Farsi_9*: KeySym = 0x00000599 + XK_Arabic_percent*: KeySym = 0x000005A5 + XK_Arabic_superscript_alef*: KeySym = 0x000005A6 + XK_Arabic_tteh*: KeySym = 0x000005A7 + XK_Arabic_peh*: KeySym = 0x000005A8 + XK_Arabic_tcheh*: KeySym = 0x000005A9 + XK_Arabic_ddal*: KeySym = 0x000005AA + XK_Arabic_rreh*: KeySym = 0x000005AB + XK_Arabic_comma*: KeySym = 0x000005AC + XK_Arabic_fullstop*: KeySym = 0x000005AE + XK_Arabic_0*: KeySym = 0x000005B0 + XK_Arabic_1*: KeySym = 0x000005B1 + XK_Arabic_2*: KeySym = 0x000005B2 + XK_Arabic_3*: KeySym = 0x000005B3 + XK_Arabic_4*: KeySym = 0x000005B4 + XK_Arabic_5*: KeySym = 0x000005B5 + XK_Arabic_6*: KeySym = 0x000005B6 + XK_Arabic_7*: KeySym = 0x000005B7 + XK_Arabic_8*: KeySym = 0x000005B8 + XK_Arabic_9*: KeySym = 0x000005B9 + XK_Arabic_semicolon*: KeySym = 0x000005BB + XK_Arabic_question_mark*: KeySym = 0x000005BF + XK_Arabic_hamza*: KeySym = 0x000005C1 + XK_Arabic_maddaonalef*: KeySym = 0x000005C2 + XK_Arabic_hamzaonalef*: KeySym = 0x000005C3 + XK_Arabic_hamzaonwaw*: KeySym = 0x000005C4 + XK_Arabic_hamzaunderalef*: KeySym = 0x000005C5 + XK_Arabic_hamzaonyeh*: KeySym = 0x000005C6 + XK_Arabic_alef*: KeySym = 0x000005C7 + XK_Arabic_beh*: KeySym = 0x000005C8 + XK_Arabic_tehmarbuta*: KeySym = 0x000005C9 + XK_Arabic_teh*: KeySym = 0x000005CA + XK_Arabic_theh*: KeySym = 0x000005CB + XK_Arabic_jeem*: KeySym = 0x000005CC + XK_Arabic_hah*: KeySym = 0x000005CD + XK_Arabic_khah*: KeySym = 0x000005CE + XK_Arabic_dal*: KeySym = 0x000005CF + XK_Arabic_thal*: KeySym = 0x000005D0 + XK_Arabic_ra*: KeySym = 0x000005D1 + XK_Arabic_zain*: KeySym = 0x000005D2 + XK_Arabic_seen*: KeySym = 0x000005D3 + XK_Arabic_sheen*: KeySym = 0x000005D4 + XK_Arabic_sad*: KeySym = 0x000005D5 + XK_Arabic_dad*: KeySym = 0x000005D6 + XK_Arabic_tah*: KeySym = 0x000005D7 + XK_Arabic_zah*: KeySym = 0x000005D8 + XK_Arabic_ain*: KeySym = 0x000005D9 + XK_Arabic_ghain*: KeySym = 0x000005DA + XK_Arabic_tatweel*: KeySym = 0x000005E0 + XK_Arabic_feh*: KeySym = 0x000005E1 + XK_Arabic_qaf*: KeySym = 0x000005E2 + XK_Arabic_kaf*: KeySym = 0x000005E3 + XK_Arabic_lam*: KeySym = 0x000005E4 + XK_Arabic_meem*: KeySym = 0x000005E5 + XK_Arabic_noon*: KeySym = 0x000005E6 + XK_Arabic_ha*: KeySym = 0x000005E7 + XK_Arabic_heh*: KeySym = 0x000005E7 # deprecated + XK_Arabic_waw*: KeySym = 0x000005E8 + XK_Arabic_alefmaksura*: KeySym = 0x000005E9 + XK_Arabic_yeh*: KeySym = 0x000005EA + XK_Arabic_fathatan*: KeySym = 0x000005EB + XK_Arabic_dammatan*: KeySym = 0x000005EC + XK_Arabic_kasratan*: KeySym = 0x000005ED + XK_Arabic_fatha*: KeySym = 0x000005EE + XK_Arabic_damma*: KeySym = 0x000005EF + XK_Arabic_kasra*: KeySym = 0x000005F0 + XK_Arabic_shadda*: KeySym = 0x000005F1 + XK_Arabic_sukun*: KeySym = 0x000005F2 + XK_Arabic_madda_above*: KeySym = 0x000005F3 + XK_Arabic_hamza_above*: KeySym = 0x000005F4 + XK_Arabic_hamza_below*: KeySym = 0x000005F5 + XK_Arabic_jeh*: KeySym = 0x000005F6 + XK_Arabic_veh*: KeySym = 0x000005F7 + XK_Arabic_keheh*: KeySym = 0x000005F8 + XK_Arabic_gaf*: KeySym = 0x000005F9 + XK_Arabic_noon_ghunna*: KeySym = 0x000005FA + XK_Arabic_heh_doachashmee*: KeySym = 0x000005FB + XK_Farsi_yeh*: KeySym = 0x000005FC + XK_Arabic_farsi_yeh*: KeySym = XK_Farsi_yeh + XK_Arabic_yeh_baree*: KeySym = 0x000005FD + XK_Arabic_heh_goal*: KeySym = 0x000005FE + XK_Arabic_switch*: KeySym = 0x0000FF7E # Alias for mode_switch +# XK_ARABIC +#* +# * Cyrillic +# * Byte 3 = 6 +# * + +when defined(XK_CYRILLIC) or true: + const + XKc_Cyrillic_GHE_bar*: KeySym = 0x00000680 + XK_Cyrillic_ghe_bar*: KeySym = 0x00000690 + XKc_Cyrillic_ZHE_descender*: KeySym = 0x00000681 + XK_Cyrillic_zhe_descender*: KeySym = 0x00000691 + XKc_Cyrillic_KA_descender*: KeySym = 0x00000682 + XK_Cyrillic_ka_descender*: KeySym = 0x00000692 + XKc_Cyrillic_KA_vertstroke*: KeySym = 0x00000683 + XK_Cyrillic_ka_vertstroke*: KeySym = 0x00000693 + XKc_Cyrillic_EN_descender*: KeySym = 0x00000684 + XK_Cyrillic_en_descender*: KeySym = 0x00000694 + XKc_Cyrillic_U_straight*: KeySym = 0x00000685 + XK_Cyrillic_u_straight*: KeySym = 0x00000695 + XKc_Cyrillic_U_straight_bar*: KeySym = 0x00000686 + XK_Cyrillic_u_straight_bar*: KeySym = 0x00000696 + XKc_Cyrillic_HA_descender*: KeySym = 0x00000687 + XK_Cyrillic_ha_descender*: KeySym = 0x00000697 + XKc_Cyrillic_CHE_descender*: KeySym = 0x00000688 + XK_Cyrillic_che_descender*: KeySym = 0x00000698 + XKc_Cyrillic_CHE_vertstroke*: KeySym = 0x00000689 + XK_Cyrillic_che_vertstroke*: KeySym = 0x00000699 + XKc_Cyrillic_SHHA*: KeySym = 0x0000068A + XK_Cyrillic_shha*: KeySym = 0x0000069A + XKc_Cyrillic_SCHWA*: KeySym = 0x0000068C + XK_Cyrillic_schwa*: KeySym = 0x0000069C + XKc_Cyrillic_I_macron*: KeySym = 0x0000068D + XK_Cyrillic_i_macron*: KeySym = 0x0000069D + XKc_Cyrillic_O_bar*: KeySym = 0x0000068E + XK_Cyrillic_o_bar*: KeySym = 0x0000069E + XKc_Cyrillic_U_macron*: KeySym = 0x0000068F + XK_Cyrillic_u_macron*: KeySym = 0x0000069F + XK_Serbian_dje*: KeySym = 0x000006A1 + XK_Macedonia_gje*: KeySym = 0x000006A2 + XK_Cyrillic_io*: KeySym = 0x000006A3 + XK_Ukrainian_ie*: KeySym = 0x000006A4 + XK_Ukranian_je*: KeySym = 0x000006A4 # deprecated + XK_Macedonia_dse*: KeySym = 0x000006A5 + XK_Ukrainian_i*: KeySym = 0x000006A6 + XK_Ukranian_i*: KeySym = 0x000006A6 # deprecated + XK_Ukrainian_yi*: KeySym = 0x000006A7 + XK_Ukranian_yi*: KeySym = 0x000006A7 # deprecated + XK_Cyrillic_je*: KeySym = 0x000006A8 + XK_Serbian_je*: KeySym = 0x000006A8 # deprecated + XK_Cyrillic_lje*: KeySym = 0x000006A9 + XK_Serbian_lje*: KeySym = 0x000006A9 # deprecated + XK_Cyrillic_nje*: KeySym = 0x000006AA + XK_Serbian_nje*: KeySym = 0x000006AA # deprecated + XK_Serbian_tshe*: KeySym = 0x000006AB + XK_Macedonia_kje*: KeySym = 0x000006AC + XK_Ukrainian_ghe_with_upturn*: KeySym = 0x000006AD + XK_Byelorussian_shortu*: KeySym = 0x000006AE + XK_Cyrillic_dzhe*: KeySym = 0x000006AF + XK_Serbian_dze*: KeySym = 0x000006AF # deprecated + XK_numerosign*: KeySym = 0x000006B0 + XKc_Serbian_DJE*: KeySym = 0x000006B1 + XKc_Macedonia_GJE*: KeySym = 0x000006B2 + XKc_Cyrillic_IO*: KeySym = 0x000006B3 + XKc_Ukrainian_IE*: KeySym = 0x000006B4 + XKc_Ukranian_JE*: KeySym = 0x000006B4 # deprecated + XKc_Macedonia_DSE*: KeySym = 0x000006B5 + XKc_Ukrainian_I*: KeySym = 0x000006B6 + XKc_Ukranian_I*: KeySym = 0x000006B6 # deprecated + XKc_Ukrainian_YI*: KeySym = 0x000006B7 + XKc_Ukranian_YI*: KeySym = 0x000006B7 # deprecated + XKc_Cyrillic_JE*: KeySym = 0x000006B8 + XKc_Serbian_JE*: KeySym = 0x000006B8 # deprecated + XKc_Cyrillic_LJE*: KeySym = 0x000006B9 + XKc_Serbian_LJE*: KeySym = 0x000006B9 # deprecated + XKc_Cyrillic_NJE*: KeySym = 0x000006BA + XKc_Serbian_NJE*: KeySym = 0x000006BA # deprecated + XKc_Serbian_TSHE*: KeySym = 0x000006BB + XKc_Macedonia_KJE*: KeySym = 0x000006BC + XKc_Ukrainian_GHE_WITH_UPTURN*: KeySym = 0x000006BD + XKc_Byelorussian_SHORTU*: KeySym = 0x000006BE + XKc_Cyrillic_DZHE*: KeySym = 0x000006BF + XKc_Serbian_DZE*: KeySym = 0x000006BF # deprecated + XK_Cyrillic_yu*: KeySym = 0x000006C0 + XK_Cyrillic_a*: KeySym = 0x000006C1 + XK_Cyrillic_be*: KeySym = 0x000006C2 + XK_Cyrillic_tse*: KeySym = 0x000006C3 + XK_Cyrillic_de*: KeySym = 0x000006C4 + XK_Cyrillic_ie*: KeySym = 0x000006C5 + XK_Cyrillic_ef*: KeySym = 0x000006C6 + XK_Cyrillic_ghe*: KeySym = 0x000006C7 + XK_Cyrillic_ha*: KeySym = 0x000006C8 + XK_Cyrillic_i*: KeySym = 0x000006C9 + XK_Cyrillic_shorti*: KeySym = 0x000006CA + XK_Cyrillic_ka*: KeySym = 0x000006CB + XK_Cyrillic_el*: KeySym = 0x000006CC + XK_Cyrillic_em*: KeySym = 0x000006CD + XK_Cyrillic_en*: KeySym = 0x000006CE + XK_Cyrillic_o*: KeySym = 0x000006CF + XK_Cyrillic_pe*: KeySym = 0x000006D0 + XK_Cyrillic_ya*: KeySym = 0x000006D1 + XK_Cyrillic_er*: KeySym = 0x000006D2 + XK_Cyrillic_es*: KeySym = 0x000006D3 + XK_Cyrillic_te*: KeySym = 0x000006D4 + XK_Cyrillic_u*: KeySym = 0x000006D5 + XK_Cyrillic_zhe*: KeySym = 0x000006D6 + XK_Cyrillic_ve*: KeySym = 0x000006D7 + XK_Cyrillic_softsign*: KeySym = 0x000006D8 + XK_Cyrillic_yeru*: KeySym = 0x000006D9 + XK_Cyrillic_ze*: KeySym = 0x000006DA + XK_Cyrillic_sha*: KeySym = 0x000006DB + XK_Cyrillic_e*: KeySym = 0x000006DC + XK_Cyrillic_shcha*: KeySym = 0x000006DD + XK_Cyrillic_che*: KeySym = 0x000006DE + XK_Cyrillic_hardsign*: KeySym = 0x000006DF + XKc_Cyrillic_YU*: KeySym = 0x000006E0 + XKc_Cyrillic_A*: KeySym = 0x000006E1 + XKc_Cyrillic_BE*: KeySym = 0x000006E2 + XKc_Cyrillic_TSE*: KeySym = 0x000006E3 + XKc_Cyrillic_DE*: KeySym = 0x000006E4 + XKc_Cyrillic_IE*: KeySym = 0x000006E5 + XKc_Cyrillic_EF*: KeySym = 0x000006E6 + XKc_Cyrillic_GHE*: KeySym = 0x000006E7 + XKc_Cyrillic_HA*: KeySym = 0x000006E8 + XKc_Cyrillic_I*: KeySym = 0x000006E9 + XKc_Cyrillic_SHORTI*: KeySym = 0x000006EA + XKc_Cyrillic_KA*: KeySym = 0x000006EB + XKc_Cyrillic_EL*: KeySym = 0x000006EC + XKc_Cyrillic_EM*: KeySym = 0x000006ED + XKc_Cyrillic_EN*: KeySym = 0x000006EE + XKc_Cyrillic_O*: KeySym = 0x000006EF + XKc_Cyrillic_PE*: KeySym = 0x000006F0 + XKc_Cyrillic_YA*: KeySym = 0x000006F1 + XKc_Cyrillic_ER*: KeySym = 0x000006F2 + XKc_Cyrillic_ES*: KeySym = 0x000006F3 + XKc_Cyrillic_TE*: KeySym = 0x000006F4 + XKc_Cyrillic_U*: KeySym = 0x000006F5 + XKc_Cyrillic_ZHE*: KeySym = 0x000006F6 + XKc_Cyrillic_VE*: KeySym = 0x000006F7 + XKc_Cyrillic_SOFTSIGN*: KeySym = 0x000006F8 + XKc_Cyrillic_YERU*: KeySym = 0x000006F9 + XKc_Cyrillic_ZE*: KeySym = 0x000006FA + XKc_Cyrillic_SHA*: KeySym = 0x000006FB + XKc_Cyrillic_E*: KeySym = 0x000006FC + XKc_Cyrillic_SHCHA*: KeySym = 0x000006FD + XKc_Cyrillic_CHE*: KeySym = 0x000006FE + XKc_Cyrillic_HARDSIGN*: KeySym = 0x000006FF +# XK_CYRILLIC +#* +# * Greek +# * Byte 3 = 7 +# * + +when defined(XK_GREEK) or true: + const + XKc_Greek_ALPHAaccent*: KeySym = 0x000007A1 + XKc_Greek_EPSILONaccent*: KeySym = 0x000007A2 + XKc_Greek_ETAaccent*: KeySym = 0x000007A3 + XKc_Greek_IOTAaccent*: KeySym = 0x000007A4 + XKc_Greek_IOTAdieresis*: KeySym = 0x000007A5 + XKc_Greek_IOTAdiaeresis*: KeySym = XKc_Greek_IOTAdieresis # old typo + XKc_Greek_OMICRONaccent*: KeySym = 0x000007A7 + XKc_Greek_UPSILONaccent*: KeySym = 0x000007A8 + XKc_Greek_UPSILONdieresis*: KeySym = 0x000007A9 + XKc_Greek_OMEGAaccent*: KeySym = 0x000007AB + XK_Greek_accentdieresis*: KeySym = 0x000007AE + XK_Greek_horizbar*: KeySym = 0x000007AF + XK_Greek_alphaaccent*: KeySym = 0x000007B1 + XK_Greek_epsilonaccent*: KeySym = 0x000007B2 + XK_Greek_etaaccent*: KeySym = 0x000007B3 + XK_Greek_iotaaccent*: KeySym = 0x000007B4 + XK_Greek_iotadieresis*: KeySym = 0x000007B5 + XK_Greek_iotaaccentdieresis*: KeySym = 0x000007B6 + XK_Greek_omicronaccent*: KeySym = 0x000007B7 + XK_Greek_upsilonaccent*: KeySym = 0x000007B8 + XK_Greek_upsilondieresis*: KeySym = 0x000007B9 + XK_Greek_upsilonaccentdieresis*: KeySym = 0x000007BA + XK_Greek_omegaaccent*: KeySym = 0x000007BB + XKc_Greek_ALPHA*: KeySym = 0x000007C1 + XKc_Greek_BETA*: KeySym = 0x000007C2 + XKc_Greek_GAMMA*: KeySym = 0x000007C3 + XKc_Greek_DELTA*: KeySym = 0x000007C4 + XKc_Greek_EPSILON*: KeySym = 0x000007C5 + XKc_Greek_ZETA*: KeySym = 0x000007C6 + XKc_Greek_ETA*: KeySym = 0x000007C7 + XKc_Greek_THETA*: KeySym = 0x000007C8 + XKc_Greek_IOTA*: KeySym = 0x000007C9 + XKc_Greek_KAPPA*: KeySym = 0x000007CA + XKc_Greek_LAMDA*: KeySym = 0x000007CB + XKc_Greek_LAMBDA*: KeySym = 0x000007CB + XKc_Greek_MU*: KeySym = 0x000007CC + XKc_Greek_NU*: KeySym = 0x000007CD + XKc_Greek_XI*: KeySym = 0x000007CE + XKc_Greek_OMICRON*: KeySym = 0x000007CF + XKc_Greek_PI*: KeySym = 0x000007D0 + XKc_Greek_RHO*: KeySym = 0x000007D1 + XKc_Greek_SIGMA*: KeySym = 0x000007D2 + XKc_Greek_TAU*: KeySym = 0x000007D4 + XKc_Greek_UPSILON*: KeySym = 0x000007D5 + XKc_Greek_PHI*: KeySym = 0x000007D6 + XKc_Greek_CHI*: KeySym = 0x000007D7 + XKc_Greek_PSI*: KeySym = 0x000007D8 + XKc_Greek_OMEGA*: KeySym = 0x000007D9 + XK_Greek_alpha*: KeySym = 0x000007E1 + XK_Greek_beta*: KeySym = 0x000007E2 + XK_Greek_gamma*: KeySym = 0x000007E3 + XK_Greek_delta*: KeySym = 0x000007E4 + XK_Greek_epsilon*: KeySym = 0x000007E5 + XK_Greek_zeta*: KeySym = 0x000007E6 + XK_Greek_eta*: KeySym = 0x000007E7 + XK_Greek_theta*: KeySym = 0x000007E8 + XK_Greek_iota*: KeySym = 0x000007E9 + XK_Greek_kappa*: KeySym = 0x000007EA + XK_Greek_lamda*: KeySym = 0x000007EB + XK_Greek_lambda*: KeySym = 0x000007EB + XK_Greek_mu*: KeySym = 0x000007EC + XK_Greek_nu*: KeySym = 0x000007ED + XK_Greek_xi*: KeySym = 0x000007EE + XK_Greek_omicron*: KeySym = 0x000007EF + XK_Greek_pi*: KeySym = 0x000007F0 + XK_Greek_rho*: KeySym = 0x000007F1 + XK_Greek_sigma*: KeySym = 0x000007F2 + XK_Greek_finalsmallsigma*: KeySym = 0x000007F3 + XK_Greek_tau*: KeySym = 0x000007F4 + XK_Greek_upsilon*: KeySym = 0x000007F5 + XK_Greek_phi*: KeySym = 0x000007F6 + XK_Greek_chi*: KeySym = 0x000007F7 + XK_Greek_psi*: KeySym = 0x000007F8 + XK_Greek_omega*: KeySym = 0x000007F9 + XK_Greek_switch*: KeySym = 0x0000FF7E # Alias for mode_switch +# XK_GREEK +#* +# * Technical +# * Byte 3 = 8 +# * + +when defined(XK_TECHNICAL) or true: + const + XK_leftradical*: KeySym = 0x000008A1 + XK_topleftradical*: KeySym = 0x000008A2 + XK_horizconnector*: KeySym = 0x000008A3 + XK_topintegral*: KeySym = 0x000008A4 + XK_botintegral*: KeySym = 0x000008A5 + XK_vertconnector*: KeySym = 0x000008A6 + XK_topleftsqbracket*: KeySym = 0x000008A7 + XK_botleftsqbracket*: KeySym = 0x000008A8 + XK_toprightsqbracket*: KeySym = 0x000008A9 + XK_botrightsqbracket*: KeySym = 0x000008AA + XK_topleftparens*: KeySym = 0x000008AB + XK_botleftparens*: KeySym = 0x000008AC + XK_toprightparens*: KeySym = 0x000008AD + XK_botrightparens*: KeySym = 0x000008AE + XK_leftmiddlecurlybrace*: KeySym = 0x000008AF + XK_rightmiddlecurlybrace*: KeySym = 0x000008B0 + XK_topleftsummation*: KeySym = 0x000008B1 + XK_botleftsummation*: KeySym = 0x000008B2 + XK_topvertsummationconnector*: KeySym = 0x000008B3 + XK_botvertsummationconnector*: KeySym = 0x000008B4 + XK_toprightsummation*: KeySym = 0x000008B5 + XK_botrightsummation*: KeySym = 0x000008B6 + XK_rightmiddlesummation*: KeySym = 0x000008B7 + XK_lessthanequal*: KeySym = 0x000008BC + XK_notequal*: KeySym = 0x000008BD + XK_greaterthanequal*: KeySym = 0x000008BE + XK_integral*: KeySym = 0x000008BF + XK_therefore*: KeySym = 0x000008C0 + XK_variation*: KeySym = 0x000008C1 + XK_infinity*: KeySym = 0x000008C2 + XK_nabla*: KeySym = 0x000008C5 + XK_approximate*: KeySym = 0x000008C8 + XK_similarequal*: KeySym = 0x000008C9 + XK_ifonlyif*: KeySym = 0x000008CD + XK_implies*: KeySym = 0x000008CE + XK_identical*: KeySym = 0x000008CF + XK_radical*: KeySym = 0x000008D6 + XK_includedin*: KeySym = 0x000008DA + XK_includes*: KeySym = 0x000008DB + XK_intersection*: KeySym = 0x000008DC + XK_union*: KeySym = 0x000008DD + XK_logicaland*: KeySym = 0x000008DE + XK_logicalor*: KeySym = 0x000008DF + XK_partialderivative*: KeySym = 0x000008EF + XK_function*: KeySym = 0x000008F6 + XK_leftarrow*: KeySym = 0x000008FB + XK_uparrow*: KeySym = 0x000008FC + XK_rightarrow*: KeySym = 0x000008FD + XK_downarrow*: KeySym = 0x000008FE +# XK_TECHNICAL +#* +# * Special +# * Byte 3 = 9 +# * + +when defined(XK_SPECIAL): + const + XK_blank*: KeySym = 0x000009DF + XK_soliddiamond*: KeySym = 0x000009E0 + XK_checkerboard*: KeySym = 0x000009E1 + XK_ht*: KeySym = 0x000009E2 + XK_ff*: KeySym = 0x000009E3 + XK_cr*: KeySym = 0x000009E4 + XK_lf*: KeySym = 0x000009E5 + XK_nl*: KeySym = 0x000009E8 + XK_vt*: KeySym = 0x000009E9 + XK_lowrightcorner*: KeySym = 0x000009EA + XK_uprightcorner*: KeySym = 0x000009EB + XK_upleftcorner*: KeySym = 0x000009EC + XK_lowleftcorner*: KeySym = 0x000009ED + XK_crossinglines*: KeySym = 0x000009EE + XK_horizlinescan1*: KeySym = 0x000009EF + XK_horizlinescan3*: KeySym = 0x000009F0 + XK_horizlinescan5*: KeySym = 0x000009F1 + XK_horizlinescan7*: KeySym = 0x000009F2 + XK_horizlinescan9*: KeySym = 0x000009F3 + XK_leftt*: KeySym = 0x000009F4 + XK_rightt*: KeySym = 0x000009F5 + XK_bott*: KeySym = 0x000009F6 + XK_topt*: KeySym = 0x000009F7 + XK_vertbar*: KeySym = 0x000009F8 +# XK_SPECIAL +#* +# * Publishing +# * Byte 3 = a +# * + +when defined(XK_PUBLISHING) or true: + const + XK_emspace*: KeySym = 0x00000AA1 + XK_enspace*: KeySym = 0x00000AA2 + XK_em3space*: KeySym = 0x00000AA3 + XK_em4space*: KeySym = 0x00000AA4 + XK_digitspace*: KeySym = 0x00000AA5 + XK_punctspace*: KeySym = 0x00000AA6 + XK_thinspace*: KeySym = 0x00000AA7 + XK_hairspace*: KeySym = 0x00000AA8 + XK_emdash*: KeySym = 0x00000AA9 + XK_endash*: KeySym = 0x00000AAA + XK_signifblank*: KeySym = 0x00000AAC + XK_ellipsis*: KeySym = 0x00000AAE + XK_doubbaselinedot*: KeySym = 0x00000AAF + XK_onethird*: KeySym = 0x00000AB0 + XK_twothirds*: KeySym = 0x00000AB1 + XK_onefifth*: KeySym = 0x00000AB2 + XK_twofifths*: KeySym = 0x00000AB3 + XK_threefifths*: KeySym = 0x00000AB4 + XK_fourfifths*: KeySym = 0x00000AB5 + XK_onesixth*: KeySym = 0x00000AB6 + XK_fivesixths*: KeySym = 0x00000AB7 + XK_careof*: KeySym = 0x00000AB8 + XK_figdash*: KeySym = 0x00000ABB + XK_leftanglebracket*: KeySym = 0x00000ABC + XK_decimalpoint*: KeySym = 0x00000ABD + XK_rightanglebracket*: KeySym = 0x00000ABE + XK_marker*: KeySym = 0x00000ABF + XK_oneeighth*: KeySym = 0x00000AC3 + XK_threeeighths*: KeySym = 0x00000AC4 + XK_fiveeighths*: KeySym = 0x00000AC5 + XK_seveneighths*: KeySym = 0x00000AC6 + XK_trademark*: KeySym = 0x00000AC9 + XK_signaturemark*: KeySym = 0x00000ACA + XK_trademarkincircle*: KeySym = 0x00000ACB + XK_leftopentriangle*: KeySym = 0x00000ACC + XK_rightopentriangle*: KeySym = 0x00000ACD + XK_emopencircle*: KeySym = 0x00000ACE + XK_emopenrectangle*: KeySym = 0x00000ACF + XK_leftsinglequotemark*: KeySym = 0x00000AD0 + XK_rightsinglequotemark*: KeySym = 0x00000AD1 + XK_leftdoublequotemark*: KeySym = 0x00000AD2 + XK_rightdoublequotemark*: KeySym = 0x00000AD3 + XK_prescription*: KeySym = 0x00000AD4 + XK_minutes*: KeySym = 0x00000AD6 + XK_seconds*: KeySym = 0x00000AD7 + XK_latincross*: KeySym = 0x00000AD9 + XK_hexagram*: KeySym = 0x00000ADA + XK_filledrectbullet*: KeySym = 0x00000ADB + XK_filledlefttribullet*: KeySym = 0x00000ADC + XK_filledrighttribullet*: KeySym = 0x00000ADD + XK_emfilledcircle*: KeySym = 0x00000ADE + XK_emfilledrect*: KeySym = 0x00000ADF + XK_enopencircbullet*: KeySym = 0x00000AE0 + XK_enopensquarebullet*: KeySym = 0x00000AE1 + XK_openrectbullet*: KeySym = 0x00000AE2 + XK_opentribulletup*: KeySym = 0x00000AE3 + XK_opentribulletdown*: KeySym = 0x00000AE4 + XK_openstar*: KeySym = 0x00000AE5 + XK_enfilledcircbullet*: KeySym = 0x00000AE6 + XK_enfilledsqbullet*: KeySym = 0x00000AE7 + XK_filledtribulletup*: KeySym = 0x00000AE8 + XK_filledtribulletdown*: KeySym = 0x00000AE9 + XK_leftpointer*: KeySym = 0x00000AEA + XK_rightpointer*: KeySym = 0x00000AEB + XK_club*: KeySym = 0x00000AEC + XK_diamond*: KeySym = 0x00000AED + XK_heart*: KeySym = 0x00000AEE + XK_maltesecross*: KeySym = 0x00000AF0 + XK_dagger*: KeySym = 0x00000AF1 + XK_doubledagger*: KeySym = 0x00000AF2 + XK_checkmark*: KeySym = 0x00000AF3 + XK_ballotcross*: KeySym = 0x00000AF4 + XK_musicalsharp*: KeySym = 0x00000AF5 + XK_musicalflat*: KeySym = 0x00000AF6 + XK_malesymbol*: KeySym = 0x00000AF7 + XK_femalesymbol*: KeySym = 0x00000AF8 + XK_telephone*: KeySym = 0x00000AF9 + XK_telephonerecorder*: KeySym = 0x00000AFA + XK_phonographcopyright*: KeySym = 0x00000AFB + XK_caret*: KeySym = 0x00000AFC + XK_singlelowquotemark*: KeySym = 0x00000AFD + XK_doublelowquotemark*: KeySym = 0x00000AFE + XK_cursor*: KeySym = 0x00000AFF +# XK_PUBLISHING +#* +# * APL +# * Byte 3 = b +# * + +when defined(XK_APL) or true: + const + XK_leftcaret*: KeySym = 0x00000BA3 + XK_rightcaret*: KeySym = 0x00000BA6 + XK_downcaret*: KeySym = 0x00000BA8 + XK_upcaret*: KeySym = 0x00000BA9 + XK_overbar*: KeySym = 0x00000BC0 + XK_downtack*: KeySym = 0x00000BC2 + XK_upshoe*: KeySym = 0x00000BC3 + XK_downstile*: KeySym = 0x00000BC4 + XK_underbar*: KeySym = 0x00000BC6 + XK_jot*: KeySym = 0x00000BCA + XK_quad*: KeySym = 0x00000BCC + XK_uptack*: KeySym = 0x00000BCE + XK_circle*: KeySym = 0x00000BCF + XK_upstile*: KeySym = 0x00000BD3 + XK_downshoe*: KeySym = 0x00000BD6 + XK_rightshoe*: KeySym = 0x00000BD8 + XK_leftshoe*: KeySym = 0x00000BDA + XK_lefttack*: KeySym = 0x00000BDC + XK_righttack*: KeySym = 0x00000BFC +# XK_APL +#* +# * Hebrew +# * Byte 3 = c +# * + +when defined(XK_HEBREW) or true: + const + XK_hebrew_doublelowline*: KeySym = 0x00000CDF + XK_hebrew_aleph*: KeySym = 0x00000CE0 + XK_hebrew_bet*: KeySym = 0x00000CE1 + XK_hebrew_beth*: KeySym = 0x00000CE1 # deprecated + XK_hebrew_gimel*: KeySym = 0x00000CE2 + XK_hebrew_gimmel*: KeySym = 0x00000CE2 # deprecated + XK_hebrew_dalet*: KeySym = 0x00000CE3 + XK_hebrew_daleth*: KeySym = 0x00000CE3 # deprecated + XK_hebrew_he*: KeySym = 0x00000CE4 + XK_hebrew_waw*: KeySym = 0x00000CE5 + XK_hebrew_zain*: KeySym = 0x00000CE6 + XK_hebrew_zayin*: KeySym = 0x00000CE6 # deprecated + XK_hebrew_chet*: KeySym = 0x00000CE7 + XK_hebrew_het*: KeySym = 0x00000CE7 # deprecated + XK_hebrew_tet*: KeySym = 0x00000CE8 + XK_hebrew_teth*: KeySym = 0x00000CE8 # deprecated + XK_hebrew_yod*: KeySym = 0x00000CE9 + XK_hebrew_finalkaph*: KeySym = 0x00000CEA + XK_hebrew_kaph*: KeySym = 0x00000CEB + XK_hebrew_lamed*: KeySym = 0x00000CEC + XK_hebrew_finalmem*: KeySym = 0x00000CED + XK_hebrew_mem*: KeySym = 0x00000CEE + XK_hebrew_finalnun*: KeySym = 0x00000CEF + XK_hebrew_nun*: KeySym = 0x00000CF0 + XK_hebrew_samech*: KeySym = 0x00000CF1 + XK_hebrew_samekh*: KeySym = 0x00000CF1 # deprecated + XK_hebrew_ayin*: KeySym = 0x00000CF2 + XK_hebrew_finalpe*: KeySym = 0x00000CF3 + XK_hebrew_pe*: KeySym = 0x00000CF4 + XK_hebrew_finalzade*: KeySym = 0x00000CF5 + XK_hebrew_finalzadi*: KeySym = 0x00000CF5 # deprecated + XK_hebrew_zade*: KeySym = 0x00000CF6 + XK_hebrew_zadi*: KeySym = 0x00000CF6 # deprecated + XK_hebrew_qoph*: KeySym = 0x00000CF7 + XK_hebrew_kuf*: KeySym = 0x00000CF7 # deprecated + XK_hebrew_resh*: KeySym = 0x00000CF8 + XK_hebrew_shin*: KeySym = 0x00000CF9 + XK_hebrew_taw*: KeySym = 0x00000CFA + XK_hebrew_taf*: KeySym = 0x00000CFA # deprecated + XK_Hebrew_switch*: KeySym = 0x0000FF7E # Alias for mode_switch +# XK_HEBREW +#* +# * Thai +# * Byte 3 = d +# * + +when defined(XK_THAI) or true: + const + XK_Thai_kokai*: KeySym = 0x00000DA1 + XK_Thai_khokhai*: KeySym = 0x00000DA2 + XK_Thai_khokhuat*: KeySym = 0x00000DA3 + XK_Thai_khokhwai*: KeySym = 0x00000DA4 + XK_Thai_khokhon*: KeySym = 0x00000DA5 + XK_Thai_khorakhang*: KeySym = 0x00000DA6 + XK_Thai_ngongu*: KeySym = 0x00000DA7 + XK_Thai_chochan*: KeySym = 0x00000DA8 + XK_Thai_choching*: KeySym = 0x00000DA9 + XK_Thai_chochang*: KeySym = 0x00000DAA + XK_Thai_soso*: KeySym = 0x00000DAB + XK_Thai_chochoe*: KeySym = 0x00000DAC + XK_Thai_yoying*: KeySym = 0x00000DAD + XK_Thai_dochada*: KeySym = 0x00000DAE + XK_Thai_topatak*: KeySym = 0x00000DAF + XK_Thai_thothan*: KeySym = 0x00000DB0 + XK_Thai_thonangmontho*: KeySym = 0x00000DB1 + XK_Thai_thophuthao*: KeySym = 0x00000DB2 + XK_Thai_nonen*: KeySym = 0x00000DB3 + XK_Thai_dodek*: KeySym = 0x00000DB4 + XK_Thai_totao*: KeySym = 0x00000DB5 + XK_Thai_thothung*: KeySym = 0x00000DB6 + XK_Thai_thothahan*: KeySym = 0x00000DB7 + XK_Thai_thothong*: KeySym = 0x00000DB8 + XK_Thai_nonu*: KeySym = 0x00000DB9 + XK_Thai_bobaimai*: KeySym = 0x00000DBA + XK_Thai_popla*: KeySym = 0x00000DBB + XK_Thai_phophung*: KeySym = 0x00000DBC + XK_Thai_fofa*: KeySym = 0x00000DBD + XK_Thai_phophan*: KeySym = 0x00000DBE + XK_Thai_fofan*: KeySym = 0x00000DBF + XK_Thai_phosamphao*: KeySym = 0x00000DC0 + XK_Thai_moma*: KeySym = 0x00000DC1 + XK_Thai_yoyak*: KeySym = 0x00000DC2 + XK_Thai_rorua*: KeySym = 0x00000DC3 + XK_Thai_ru*: KeySym = 0x00000DC4 + XK_Thai_loling*: KeySym = 0x00000DC5 + XK_Thai_lu*: KeySym = 0x00000DC6 + XK_Thai_wowaen*: KeySym = 0x00000DC7 + XK_Thai_sosala*: KeySym = 0x00000DC8 + XK_Thai_sorusi*: KeySym = 0x00000DC9 + XK_Thai_sosua*: KeySym = 0x00000DCA + XK_Thai_hohip*: KeySym = 0x00000DCB + XK_Thai_lochula*: KeySym = 0x00000DCC + XK_Thai_oang*: KeySym = 0x00000DCD + XK_Thai_honokhuk*: KeySym = 0x00000DCE + XK_Thai_paiyannoi*: KeySym = 0x00000DCF + XK_Thai_saraa*: KeySym = 0x00000DD0 + XK_Thai_maihanakat*: KeySym = 0x00000DD1 + XK_Thai_saraaa*: KeySym = 0x00000DD2 + XK_Thai_saraam*: KeySym = 0x00000DD3 + XK_Thai_sarai*: KeySym = 0x00000DD4 + XK_Thai_saraii*: KeySym = 0x00000DD5 + XK_Thai_saraue*: KeySym = 0x00000DD6 + XK_Thai_sarauee*: KeySym = 0x00000DD7 + XK_Thai_sarau*: KeySym = 0x00000DD8 + XK_Thai_sarauu*: KeySym = 0x00000DD9 + XK_Thai_phinthu*: KeySym = 0x00000DDA + XK_Thai_maihanakat_maitho*: KeySym = 0x00000DDE + XK_Thai_baht*: KeySym = 0x00000DDF + XK_Thai_sarae*: KeySym = 0x00000DE0 + XK_Thai_saraae*: KeySym = 0x00000DE1 + XK_Thai_sarao*: KeySym = 0x00000DE2 + XK_Thai_saraaimaimuan*: KeySym = 0x00000DE3 + XK_Thai_saraaimaimalai*: KeySym = 0x00000DE4 + XK_Thai_lakkhangyao*: KeySym = 0x00000DE5 + XK_Thai_maiyamok*: KeySym = 0x00000DE6 + XK_Thai_maitaikhu*: KeySym = 0x00000DE7 + XK_Thai_maiek*: KeySym = 0x00000DE8 + XK_Thai_maitho*: KeySym = 0x00000DE9 + XK_Thai_maitri*: KeySym = 0x00000DEA + XK_Thai_maichattawa*: KeySym = 0x00000DEB + XK_Thai_thanthakhat*: KeySym = 0x00000DEC + XK_Thai_nikhahit*: KeySym = 0x00000DED + XK_Thai_leksun*: KeySym = 0x00000DF0 + XK_Thai_leknung*: KeySym = 0x00000DF1 + XK_Thai_leksong*: KeySym = 0x00000DF2 + XK_Thai_leksam*: KeySym = 0x00000DF3 + XK_Thai_leksi*: KeySym = 0x00000DF4 + XK_Thai_lekha*: KeySym = 0x00000DF5 + XK_Thai_lekhok*: KeySym = 0x00000DF6 + XK_Thai_lekchet*: KeySym = 0x00000DF7 + XK_Thai_lekpaet*: KeySym = 0x00000DF8 + XK_Thai_lekkao*: KeySym = 0x00000DF9 +# XK_THAI +#* +# * Korean +# * Byte 3 = e +# * + +when defined(XK_KOREAN) or true: + const + XK_Hangul*: KeySym = 0x0000FF31 # Hangul start/stop(toggle) + XK_Hangul_Start*: KeySym = 0x0000FF32 # Hangul start + XK_Hangul_End*: KeySym = 0x0000FF33 # Hangul end, English start + XK_Hangul_Hanja*: KeySym = 0x0000FF34 # Start Hangul->Hanja Conversion + XK_Hangul_Jamo*: KeySym = 0x0000FF35 # Hangul Jamo mode + XK_Hangul_Romaja*: KeySym = 0x0000FF36 # Hangul Romaja mode + XK_Hangul_Codeinput*: KeySym = 0x0000FF37 # Hangul code input mode + XK_Hangul_Jeonja*: KeySym = 0x0000FF38 # Jeonja mode + XK_Hangul_Banja*: KeySym = 0x0000FF39 # Banja mode + XK_Hangul_PreHanja*: KeySym = 0x0000FF3A # Pre Hanja conversion + XK_Hangul_PostHanja*: KeySym = 0x0000FF3B # Post Hanja conversion + XK_Hangul_SingleCandidate*: KeySym = 0x0000FF3C # Single candidate + XK_Hangul_MultipleCandidate*: KeySym = 0x0000FF3D # Multiple candidate + XK_Hangul_PreviousCandidate*: KeySym = 0x0000FF3E # Previous candidate + XK_Hangul_Special*: KeySym = 0x0000FF3F # Special symbols + XK_Hangul_switch*: KeySym = 0x0000FF7E # Alias for mode_switch \ + # Hangul Consonant Characters + XK_Hangul_Kiyeog*: KeySym = 0x00000EA1 + XK_Hangul_SsangKiyeog*: KeySym = 0x00000EA2 + XK_Hangul_KiyeogSios*: KeySym = 0x00000EA3 + XK_Hangul_Nieun*: KeySym = 0x00000EA4 + XK_Hangul_NieunJieuj*: KeySym = 0x00000EA5 + XK_Hangul_NieunHieuh*: KeySym = 0x00000EA6 + XK_Hangul_Dikeud*: KeySym = 0x00000EA7 + XK_Hangul_SsangDikeud*: KeySym = 0x00000EA8 + XK_Hangul_Rieul*: KeySym = 0x00000EA9 + XK_Hangul_RieulKiyeog*: KeySym = 0x00000EAA + XK_Hangul_RieulMieum*: KeySym = 0x00000EAB + XK_Hangul_RieulPieub*: KeySym = 0x00000EAC + XK_Hangul_RieulSios*: KeySym = 0x00000EAD + XK_Hangul_RieulTieut*: KeySym = 0x00000EAE + XK_Hangul_RieulPhieuf*: KeySym = 0x00000EAF + XK_Hangul_RieulHieuh*: KeySym = 0x00000EB0 + XK_Hangul_Mieum*: KeySym = 0x00000EB1 + XK_Hangul_Pieub*: KeySym = 0x00000EB2 + XK_Hangul_SsangPieub*: KeySym = 0x00000EB3 + XK_Hangul_PieubSios*: KeySym = 0x00000EB4 + XK_Hangul_Sios*: KeySym = 0x00000EB5 + XK_Hangul_SsangSios*: KeySym = 0x00000EB6 + XK_Hangul_Ieung*: KeySym = 0x00000EB7 + XK_Hangul_Jieuj*: KeySym = 0x00000EB8 + XK_Hangul_SsangJieuj*: KeySym = 0x00000EB9 + XK_Hangul_Cieuc*: KeySym = 0x00000EBA + XK_Hangul_Khieuq*: KeySym = 0x00000EBB + XK_Hangul_Tieut*: KeySym = 0x00000EBC + XK_Hangul_Phieuf*: KeySym = 0x00000EBD + XK_Hangul_Hieuh*: KeySym = 0x00000EBE # Hangul Vowel Characters + XK_Hangul_A*: KeySym = 0x00000EBF + XK_Hangul_AE*: KeySym = 0x00000EC0 + XK_Hangul_YA*: KeySym = 0x00000EC1 + XK_Hangul_YAE*: KeySym = 0x00000EC2 + XK_Hangul_EO*: KeySym = 0x00000EC3 + XK_Hangul_E*: KeySym = 0x00000EC4 + XK_Hangul_YEO*: KeySym = 0x00000EC5 + XK_Hangul_YE*: KeySym = 0x00000EC6 + XK_Hangul_O*: KeySym = 0x00000EC7 + XK_Hangul_WA*: KeySym = 0x00000EC8 + XK_Hangul_WAE*: KeySym = 0x00000EC9 + XK_Hangul_OE*: KeySym = 0x00000ECA + XK_Hangul_YO*: KeySym = 0x00000ECB + XK_Hangul_U*: KeySym = 0x00000ECC + XK_Hangul_WEO*: KeySym = 0x00000ECD + XK_Hangul_WE*: KeySym = 0x00000ECE + XK_Hangul_WI*: KeySym = 0x00000ECF + XK_Hangul_YU*: KeySym = 0x00000ED0 + XK_Hangul_EU*: KeySym = 0x00000ED1 + XK_Hangul_YI*: KeySym = 0x00000ED2 + XK_Hangul_I*: KeySym = 0x00000ED3 # Hangul syllable-final (JongSeong) Characters + XK_Hangul_J_Kiyeog*: KeySym = 0x00000ED4 + XK_Hangul_J_SsangKiyeog*: KeySym = 0x00000ED5 + XK_Hangul_J_KiyeogSios*: KeySym = 0x00000ED6 + XK_Hangul_J_Nieun*: KeySym = 0x00000ED7 + XK_Hangul_J_NieunJieuj*: KeySym = 0x00000ED8 + XK_Hangul_J_NieunHieuh*: KeySym = 0x00000ED9 + XK_Hangul_J_Dikeud*: KeySym = 0x00000EDA + XK_Hangul_J_Rieul*: KeySym = 0x00000EDB + XK_Hangul_J_RieulKiyeog*: KeySym = 0x00000EDC + XK_Hangul_J_RieulMieum*: KeySym = 0x00000EDD + XK_Hangul_J_RieulPieub*: KeySym = 0x00000EDE + XK_Hangul_J_RieulSios*: KeySym = 0x00000EDF + XK_Hangul_J_RieulTieut*: KeySym = 0x00000EE0 + XK_Hangul_J_RieulPhieuf*: KeySym = 0x00000EE1 + XK_Hangul_J_RieulHieuh*: KeySym = 0x00000EE2 + XK_Hangul_J_Mieum*: KeySym = 0x00000EE3 + XK_Hangul_J_Pieub*: KeySym = 0x00000EE4 + XK_Hangul_J_PieubSios*: KeySym = 0x00000EE5 + XK_Hangul_J_Sios*: KeySym = 0x00000EE6 + XK_Hangul_J_SsangSios*: KeySym = 0x00000EE7 + XK_Hangul_J_Ieung*: KeySym = 0x00000EE8 + XK_Hangul_J_Jieuj*: KeySym = 0x00000EE9 + XK_Hangul_J_Cieuc*: KeySym = 0x00000EEA + XK_Hangul_J_Khieuq*: KeySym = 0x00000EEB + XK_Hangul_J_Tieut*: KeySym = 0x00000EEC + XK_Hangul_J_Phieuf*: KeySym = 0x00000EED + XK_Hangul_J_Hieuh*: KeySym = 0x00000EEE # Ancient Hangul Consonant Characters + XK_Hangul_RieulYeorinHieuh*: KeySym = 0x00000EEF + XK_Hangul_SunkyeongeumMieum*: KeySym = 0x00000EF0 + XK_Hangul_SunkyeongeumPieub*: KeySym = 0x00000EF1 + XK_Hangul_PanSios*: KeySym = 0x00000EF2 + XK_Hangul_KkogjiDalrinIeung*: KeySym = 0x00000EF3 + XK_Hangul_SunkyeongeumPhieuf*: KeySym = 0x00000EF4 + XK_Hangul_YeorinHieuh*: KeySym = 0x00000EF5 # Ancient Hangul Vowel Characters + XK_Hangul_AraeA*: KeySym = 0x00000EF6 + XK_Hangul_AraeAE*: KeySym = 0x00000EF7 # Ancient Hangul syllable-final (JongSeong) Characters + XK_Hangul_J_PanSios*: KeySym = 0x00000EF8 + XK_Hangul_J_KkogjiDalrinIeung*: KeySym = 0x00000EF9 + XK_Hangul_J_YeorinHieuh*: KeySym = 0x00000EFA # Korean currency symbol + XK_Korean_Won*: KeySym = 0x00000EFF +# XK_KOREAN +#* +# * Armenian +# * Byte 3 = = $14 +# * + +when defined(XK_ARMENIAN) or true: + const + XK_Armenian_eternity*: KeySym = 0x000014A1 + XK_Armenian_ligature_ew*: KeySym = 0x000014A2 + XK_Armenian_full_stop*: KeySym = 0x000014A3 + XK_Armenian_verjaket*: KeySym = 0x000014A3 + XK_Armenian_parenright*: KeySym = 0x000014A4 + XK_Armenian_parenleft*: KeySym = 0x000014A5 + XK_Armenian_guillemotright*: KeySym = 0x000014A6 + XK_Armenian_guillemotleft*: KeySym = 0x000014A7 + XK_Armenian_em_dash*: KeySym = 0x000014A8 + XK_Armenian_dot*: KeySym = 0x000014A9 + XK_Armenian_mijaket*: KeySym = 0x000014A9 + XK_Armenian_separation_mark*: KeySym = 0x000014AA + XK_Armenian_but*: KeySym = 0x000014AA + XK_Armenian_comma*: KeySym = 0x000014AB + XK_Armenian_en_dash*: KeySym = 0x000014AC + XK_Armenian_hyphen*: KeySym = 0x000014AD + XK_Armenian_yentamna*: KeySym = 0x000014AD + XK_Armenian_ellipsis*: KeySym = 0x000014AE + XK_Armenian_exclam*: KeySym = 0x000014AF + XK_Armenian_amanak*: KeySym = 0x000014AF + XK_Armenian_accent*: KeySym = 0x000014B0 + XK_Armenian_shesht*: KeySym = 0x000014B0 + XK_Armenian_question*: KeySym = 0x000014B1 + XK_Armenian_paruyk*: KeySym = 0x000014B1 + XKc_Armenian_AYB*: KeySym = 0x000014B2 + XK_Armenian_ayb*: KeySym = 0x000014B3 + XKc_Armenian_BEN*: KeySym = 0x000014B4 + XK_Armenian_ben*: KeySym = 0x000014B5 + XKc_Armenian_GIM*: KeySym = 0x000014B6 + XK_Armenian_gim*: KeySym = 0x000014B7 + XKc_Armenian_DA*: KeySym = 0x000014B8 + XK_Armenian_da*: KeySym = 0x000014B9 + XKc_Armenian_YECH*: KeySym = 0x000014BA + XK_Armenian_yech*: KeySym = 0x000014BB + XKc_Armenian_ZA*: KeySym = 0x000014BC + XK_Armenian_za*: KeySym = 0x000014BD + XKc_Armenian_E*: KeySym = 0x000014BE + XK_Armenian_e*: KeySym = 0x000014BF + XKc_Armenian_AT*: KeySym = 0x000014C0 + XK_Armenian_at*: KeySym = 0x000014C1 + XKc_Armenian_TO*: KeySym = 0x000014C2 + XK_Armenian_to*: KeySym = 0x000014C3 + XKc_Armenian_ZHE*: KeySym = 0x000014C4 + XK_Armenian_zhe*: KeySym = 0x000014C5 + XKc_Armenian_INI*: KeySym = 0x000014C6 + XK_Armenian_ini*: KeySym = 0x000014C7 + XKc_Armenian_LYUN*: KeySym = 0x000014C8 + XK_Armenian_lyun*: KeySym = 0x000014C9 + XKc_Armenian_KHE*: KeySym = 0x000014CA + XK_Armenian_khe*: KeySym = 0x000014CB + XKc_Armenian_TSA*: KeySym = 0x000014CC + XK_Armenian_tsa*: KeySym = 0x000014CD + XKc_Armenian_KEN*: KeySym = 0x000014CE + XK_Armenian_ken*: KeySym = 0x000014CF + XKc_Armenian_HO*: KeySym = 0x000014D0 + XK_Armenian_ho*: KeySym = 0x000014D1 + XKc_Armenian_DZA*: KeySym = 0x000014D2 + XK_Armenian_dza*: KeySym = 0x000014D3 + XKc_Armenian_GHAT*: KeySym = 0x000014D4 + XK_Armenian_ghat*: KeySym = 0x000014D5 + XKc_Armenian_TCHE*: KeySym = 0x000014D6 + XK_Armenian_tche*: KeySym = 0x000014D7 + XKc_Armenian_MEN*: KeySym = 0x000014D8 + XK_Armenian_men*: KeySym = 0x000014D9 + XKc_Armenian_HI*: KeySym = 0x000014DA + XK_Armenian_hi*: KeySym = 0x000014DB + XKc_Armenian_NU*: KeySym = 0x000014DC + XK_Armenian_nu*: KeySym = 0x000014DD + XKc_Armenian_SHA*: KeySym = 0x000014DE + XK_Armenian_sha*: KeySym = 0x000014DF + XKc_Armenian_VO*: KeySym = 0x000014E0 + XK_Armenian_vo*: KeySym = 0x000014E1 + XKc_Armenian_CHA*: KeySym = 0x000014E2 + XK_Armenian_cha*: KeySym = 0x000014E3 + XKc_Armenian_PE*: KeySym = 0x000014E4 + XK_Armenian_pe*: KeySym = 0x000014E5 + XKc_Armenian_JE*: KeySym = 0x000014E6 + XK_Armenian_je*: KeySym = 0x000014E7 + XKc_Armenian_RA*: KeySym = 0x000014E8 + XK_Armenian_ra*: KeySym = 0x000014E9 + XKc_Armenian_SE*: KeySym = 0x000014EA + XK_Armenian_se*: KeySym = 0x000014EB + XKc_Armenian_VEV*: KeySym = 0x000014EC + XK_Armenian_vev*: KeySym = 0x000014ED + XKc_Armenian_TYUN*: KeySym = 0x000014EE + XK_Armenian_tyun*: KeySym = 0x000014EF + XKc_Armenian_RE*: KeySym = 0x000014F0 + XK_Armenian_re*: KeySym = 0x000014F1 + XKc_Armenian_TSO*: KeySym = 0x000014F2 + XK_Armenian_tso*: KeySym = 0x000014F3 + XKc_Armenian_VYUN*: KeySym = 0x000014F4 + XK_Armenian_vyun*: KeySym = 0x000014F5 + XKc_Armenian_PYUR*: KeySym = 0x000014F6 + XK_Armenian_pyur*: KeySym = 0x000014F7 + XKc_Armenian_KE*: KeySym = 0x000014F8 + XK_Armenian_ke*: KeySym = 0x000014F9 + XKc_Armenian_O*: KeySym = 0x000014FA + XK_Armenian_o*: KeySym = 0x000014FB + XKc_Armenian_FE*: KeySym = 0x000014FC + XK_Armenian_fe*: KeySym = 0x000014FD + XK_Armenian_apostrophe*: KeySym = 0x000014FE + XK_Armenian_section_sign*: KeySym = 0x000014FF +# XK_ARMENIAN +#* +# * Georgian +# * Byte 3 = = $15 +# * + +when defined(XK_GEORGIAN) or true: + const + XK_Georgian_an*: KeySym = 0x000015D0 + XK_Georgian_ban*: KeySym = 0x000015D1 + XK_Georgian_gan*: KeySym = 0x000015D2 + XK_Georgian_don*: KeySym = 0x000015D3 + XK_Georgian_en*: KeySym = 0x000015D4 + XK_Georgian_vin*: KeySym = 0x000015D5 + XK_Georgian_zen*: KeySym = 0x000015D6 + XK_Georgian_tan*: KeySym = 0x000015D7 + XK_Georgian_in*: KeySym = 0x000015D8 + XK_Georgian_kan*: KeySym = 0x000015D9 + XK_Georgian_las*: KeySym = 0x000015DA + XK_Georgian_man*: KeySym = 0x000015DB + XK_Georgian_nar*: KeySym = 0x000015DC + XK_Georgian_on*: KeySym = 0x000015DD + XK_Georgian_par*: KeySym = 0x000015DE + XK_Georgian_zhar*: KeySym = 0x000015DF + XK_Georgian_rae*: KeySym = 0x000015E0 + XK_Georgian_san*: KeySym = 0x000015E1 + XK_Georgian_tar*: KeySym = 0x000015E2 + XK_Georgian_un*: KeySym = 0x000015E3 + XK_Georgian_phar*: KeySym = 0x000015E4 + XK_Georgian_khar*: KeySym = 0x000015E5 + XK_Georgian_ghan*: KeySym = 0x000015E6 + XK_Georgian_qar*: KeySym = 0x000015E7 + XK_Georgian_shin*: KeySym = 0x000015E8 + XK_Georgian_chin*: KeySym = 0x000015E9 + XK_Georgian_can*: KeySym = 0x000015EA + XK_Georgian_jil*: KeySym = 0x000015EB + XK_Georgian_cil*: KeySym = 0x000015EC + XK_Georgian_char*: KeySym = 0x000015ED + XK_Georgian_xan*: KeySym = 0x000015EE + XK_Georgian_jhan*: KeySym = 0x000015EF + XK_Georgian_hae*: KeySym = 0x000015F0 + XK_Georgian_he*: KeySym = 0x000015F1 + XK_Georgian_hie*: KeySym = 0x000015F2 + XK_Georgian_we*: KeySym = 0x000015F3 + XK_Georgian_har*: KeySym = 0x000015F4 + XK_Georgian_hoe*: KeySym = 0x000015F5 + XK_Georgian_fi*: KeySym = 0x000015F6 +# XK_GEORGIAN +#* +# * Azeri (and other Turkic or Caucasian languages of ex-USSR) +# * Byte 3 = = $16 +# * + +when defined(XK_CAUCASUS) or true: + # latin + const + XKc_Ccedillaabovedot*: KeySym = 0x000016A2 + XKc_Xabovedot*: KeySym = 0x000016A3 + XKc_Qabovedot*: KeySym = 0x000016A5 + XKc_Ibreve*: KeySym = 0x000016A6 + XKc_IE*: KeySym = 0x000016A7 + XKc_UO*: KeySym = 0x000016A8 + XKc_Zstroke*: KeySym = 0x000016A9 + XKc_Gcaron*: KeySym = 0x000016AA + XKc_Obarred*: KeySym = 0x000016AF + XK_ccedillaabovedot*: KeySym = 0x000016B2 + XK_xabovedot*: KeySym = 0x000016B3 + XKc_Ocaron*: KeySym = 0x000016B4 + XK_qabovedot*: KeySym = 0x000016B5 + XK_ibreve*: KeySym = 0x000016B6 + XK_ie*: KeySym = 0x000016B7 + XK_uo*: KeySym = 0x000016B8 + XK_zstroke*: KeySym = 0x000016B9 + XK_gcaron*: KeySym = 0x000016BA + XK_ocaron*: KeySym = 0x000016BD + XK_obarred*: KeySym = 0x000016BF + XKc_SCHWA*: KeySym = 0x000016C6 + XK_schwa*: KeySym = 0x000016F6 # those are not really Caucasus, but I put them here for now\ + # For Inupiak + XKc_Lbelowdot*: KeySym = 0x000016D1 + XKc_Lstrokebelowdot*: KeySym = 0x000016D2 + XK_lbelowdot*: KeySym = 0x000016E1 + XK_lstrokebelowdot*: KeySym = 0x000016E2 # For Guarani + XKc_Gtilde*: KeySym = 0x000016D3 + XK_gtilde*: KeySym = 0x000016E3 +# XK_CAUCASUS +#* +# * Vietnamese +# * Byte 3 = = $1e +# * + +when defined(XK_VIETNAMESE) or true: + const + XKc_Abelowdot*: KeySym = 0x00001EA0 + XK_abelowdot*: KeySym = 0x00001EA1 + XKc_Ahook*: KeySym = 0x00001EA2 + XK_ahook*: KeySym = 0x00001EA3 + XKc_Acircumflexacute*: KeySym = 0x00001EA4 + XK_acircumflexacute*: KeySym = 0x00001EA5 + XKc_Acircumflexgrave*: KeySym = 0x00001EA6 + XK_acircumflexgrave*: KeySym = 0x00001EA7 + XKc_Acircumflexhook*: KeySym = 0x00001EA8 + XK_acircumflexhook*: KeySym = 0x00001EA9 + XKc_Acircumflextilde*: KeySym = 0x00001EAA + XK_acircumflextilde*: KeySym = 0x00001EAB + XKc_Acircumflexbelowdot*: KeySym = 0x00001EAC + XK_acircumflexbelowdot*: KeySym = 0x00001EAD + XKc_Abreveacute*: KeySym = 0x00001EAE + XK_abreveacute*: KeySym = 0x00001EAF + XKc_Abrevegrave*: KeySym = 0x00001EB0 + XK_abrevegrave*: KeySym = 0x00001EB1 + XKc_Abrevehook*: KeySym = 0x00001EB2 + XK_abrevehook*: KeySym = 0x00001EB3 + XKc_Abrevetilde*: KeySym = 0x00001EB4 + XK_abrevetilde*: KeySym = 0x00001EB5 + XKc_Abrevebelowdot*: KeySym = 0x00001EB6 + XK_abrevebelowdot*: KeySym = 0x00001EB7 + XKc_Ebelowdot*: KeySym = 0x00001EB8 + XK_ebelowdot*: KeySym = 0x00001EB9 + XKc_Ehook*: KeySym = 0x00001EBA + XK_ehook*: KeySym = 0x00001EBB + XKc_Etilde*: KeySym = 0x00001EBC + XK_etilde*: KeySym = 0x00001EBD + XKc_Ecircumflexacute*: KeySym = 0x00001EBE + XK_ecircumflexacute*: KeySym = 0x00001EBF + XKc_Ecircumflexgrave*: KeySym = 0x00001EC0 + XK_ecircumflexgrave*: KeySym = 0x00001EC1 + XKc_Ecircumflexhook*: KeySym = 0x00001EC2 + XK_ecircumflexhook*: KeySym = 0x00001EC3 + XKc_Ecircumflextilde*: KeySym = 0x00001EC4 + XK_ecircumflextilde*: KeySym = 0x00001EC5 + XKc_Ecircumflexbelowdot*: KeySym = 0x00001EC6 + XK_ecircumflexbelowdot*: KeySym = 0x00001EC7 + XKc_Ihook*: KeySym = 0x00001EC8 + XK_ihook*: KeySym = 0x00001EC9 + XKc_Ibelowdot*: KeySym = 0x00001ECA + XK_ibelowdot*: KeySym = 0x00001ECB + XKc_Obelowdot*: KeySym = 0x00001ECC + XK_obelowdot*: KeySym = 0x00001ECD + XKc_Ohook*: KeySym = 0x00001ECE + XK_ohook*: KeySym = 0x00001ECF + XKc_Ocircumflexacute*: KeySym = 0x00001ED0 + XK_ocircumflexacute*: KeySym = 0x00001ED1 + XKc_Ocircumflexgrave*: KeySym = 0x00001ED2 + XK_ocircumflexgrave*: KeySym = 0x00001ED3 + XKc_Ocircumflexhook*: KeySym = 0x00001ED4 + XK_ocircumflexhook*: KeySym = 0x00001ED5 + XKc_Ocircumflextilde*: KeySym = 0x00001ED6 + XK_ocircumflextilde*: KeySym = 0x00001ED7 + XKc_Ocircumflexbelowdot*: KeySym = 0x00001ED8 + XK_ocircumflexbelowdot*: KeySym = 0x00001ED9 + XKc_Ohornacute*: KeySym = 0x00001EDA + XK_ohornacute*: KeySym = 0x00001EDB + XKc_Ohorngrave*: KeySym = 0x00001EDC + XK_ohorngrave*: KeySym = 0x00001EDD + XKc_Ohornhook*: KeySym = 0x00001EDE + XK_ohornhook*: KeySym = 0x00001EDF + XKc_Ohorntilde*: KeySym = 0x00001EE0 + XK_ohorntilde*: KeySym = 0x00001EE1 + XKc_Ohornbelowdot*: KeySym = 0x00001EE2 + XK_ohornbelowdot*: KeySym = 0x00001EE3 + XKc_Ubelowdot*: KeySym = 0x00001EE4 + XK_ubelowdot*: KeySym = 0x00001EE5 + XKc_Uhook*: KeySym = 0x00001EE6 + XK_uhook*: KeySym = 0x00001EE7 + XKc_Uhornacute*: KeySym = 0x00001EE8 + XK_uhornacute*: KeySym = 0x00001EE9 + XKc_Uhorngrave*: KeySym = 0x00001EEA + XK_uhorngrave*: KeySym = 0x00001EEB + XKc_Uhornhook*: KeySym = 0x00001EEC + XK_uhornhook*: KeySym = 0x00001EED + XKc_Uhorntilde*: KeySym = 0x00001EEE + XK_uhorntilde*: KeySym = 0x00001EEF + XKc_Uhornbelowdot*: KeySym = 0x00001EF0 + XK_uhornbelowdot*: KeySym = 0x00001EF1 + XKc_Ybelowdot*: KeySym = 0x00001EF4 + XK_ybelowdot*: KeySym = 0x00001EF5 + XKc_Yhook*: KeySym = 0x00001EF6 + XK_yhook*: KeySym = 0x00001EF7 + XKc_Ytilde*: KeySym = 0x00001EF8 + XK_ytilde*: KeySym = 0x00001EF9 + XKc_Ohorn*: KeySym = 0x00001EFA # U+01a0 + XK_ohorn*: KeySym = 0x00001EFB # U+01a1 + XKc_Uhorn*: KeySym = 0x00001EFC # U+01af + XK_uhorn*: KeySym = 0x00001EFD # U+01b0 + XK_combining_tilde*: KeySym = 0x00001E9F # U+0303 + XK_combining_grave*: KeySym = 0x00001EF2 # U+0300 + XK_combining_acute*: KeySym = 0x00001EF3 # U+0301 + XK_combining_hook*: KeySym = 0x00001EFE # U+0309 + XK_combining_belowdot*: KeySym = 0x00001EFF # U+0323 +# XK_VIETNAMESE + +when defined(XK_CURRENCY) or true: + const + XK_EcuSign*: KeySym = 0x000020A0 + XK_ColonSign*: KeySym = 0x000020A1 + XK_CruzeiroSign*: KeySym = 0x000020A2 + XK_FFrancSign*: KeySym = 0x000020A3 + XK_LiraSign*: KeySym = 0x000020A4 + XK_MillSign*: KeySym = 0x000020A5 + XK_NairaSign*: KeySym = 0x000020A6 + XK_PesetaSign*: KeySym = 0x000020A7 + XK_RupeeSign*: KeySym = 0x000020A8 + XK_WonSign*: KeySym = 0x000020A9 + XK_NewSheqelSign*: KeySym = 0x000020AA + XK_DongSign*: KeySym = 0x000020AB + XK_EuroSign*: KeySym = 0x000020AC +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/x.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/x.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,426 @@ + +# +# Automatically converted by H2Pas 0.99.15 from x.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# x.h +# +# Pointers to basic pascal types, inserted by h2pas conversion program. + +const + X_PROTOCOL* = 11 + X_PROTOCOL_REVISION* = 0 + +type + PXID* = ptr XID + XID* = culong + + PMask* = ptr Mask + Mask* = culong + + PPAtom* = ptr PAtom + PAtom* = ptr Atom + Atom* = culong + + PVisualID* = ptr VisualID + VisualID* = culong + + PTime* = ptr Time + Time* = culong + + PPWindow* = ptr PWindow + PWindow* = ptr Window + Window* = XID + + PDrawable* = ptr Drawable + Drawable* = XID + + PFont* = ptr Font + Font* = XID + + PPixmap* = ptr Pixmap + Pixmap* = XID + + PCursor* = ptr Cursor + Cursor* = XID + + PColormap* = ptr Colormap + Colormap* = XID + + PGContext* = ptr GContext + GContext* = XID + + PKeySym* = ptr KeySym + KeySym* = XID + + PKeyCode* = ptr KeyCode + KeyCode* = char + +{.deprecated: [TXID: XID].} +{.deprecated: [TMask: Mask].} +{.deprecated: [TAtom: Atom].} +{.deprecated: [TVisualID: VisualID].} +{.deprecated: [TTime: Time].} +{.deprecated: [TWindow: Window].} +{.deprecated: [TDrawable: Drawable].} +{.deprecated: [TFont: Font].} +{.deprecated: [TPixmap: Pixmap].} +{.deprecated: [TCursor: Cursor].} +{.deprecated: [TColormap: Colormap].} +{.deprecated: [TGContext: GContext].} +{.deprecated: [TKeySym: KeySym].} +{.deprecated: [TKeyCode: KeyCode].} + +const + None* = 0 + ParentRelative* = 1 + CopyFromParent* = 0 + PointerWindow* = 0 + InputFocus* = 1 + PointerRoot* = 1 + AnyPropertyType* = 0 + AnyKey* = 0 + AnyButton* = 0 + AllTemporary* = 0 + CurrentTime* = 0 + NoSymbol* = 0 + NoEventMask* = 0 + KeyPressMask* = 1 shl 0 + KeyReleaseMask* = 1 shl 1 + ButtonPressMask* = 1 shl 2 + ButtonReleaseMask* = 1 shl 3 + EnterWindowMask* = 1 shl 4 + LeaveWindowMask* = 1 shl 5 + PointerMotionMask* = 1 shl 6 + PointerMotionHintMask* = 1 shl 7 + Button1MotionMask* = 1 shl 8 + Button2MotionMask* = 1 shl 9 + Button3MotionMask* = 1 shl 10 + Button4MotionMask* = 1 shl 11 + Button5MotionMask* = 1 shl 12 + ButtonMotionMask* = 1 shl 13 + KeymapStateMask* = 1 shl 14 + ExposureMask* = 1 shl 15 + VisibilityChangeMask* = 1 shl 16 + StructureNotifyMask* = 1 shl 17 + ResizeRedirectMask* = 1 shl 18 + SubstructureNotifyMask* = 1 shl 19 + SubstructureRedirectMask* = 1 shl 20 + FocusChangeMask* = 1 shl 21 + PropertyChangeMask* = 1 shl 22 + ColormapChangeMask* = 1 shl 23 + OwnerGrabButtonMask* = 1 shl 24 + KeyPress* = 2 + KeyRelease* = 3 + ButtonPress* = 4 + ButtonRelease* = 5 + MotionNotify* = 6 + EnterNotify* = 7 + LeaveNotify* = 8 + FocusIn* = 9 + FocusOut* = 10 + KeymapNotify* = 11 + Expose* = 12 + GraphicsExpose* = 13 + NoExpose* = 14 + VisibilityNotify* = 15 + CreateNotify* = 16 + DestroyNotify* = 17 + UnmapNotify* = 18 + MapNotify* = 19 + MapRequest* = 20 + ReparentNotify* = 21 + ConfigureNotify* = 22 + ConfigureRequest* = 23 + GravityNotify* = 24 + ResizeRequest* = 25 + CirculateNotify* = 26 + CirculateRequest* = 27 + PropertyNotify* = 28 + SelectionClear* = 29 + SelectionRequest* = 30 + SelectionNotify* = 31 + ColormapNotify* = 32 + ClientMessage* = 33 + MappingNotify* = 34 + GenericEvent* = 35 + LASTEvent* = 36 + ShiftMask* = 1 shl 0 + LockMask* = 1 shl 1 + ControlMask* = 1 shl 2 + Mod1Mask* = 1 shl 3 + Mod2Mask* = 1 shl 4 + Mod3Mask* = 1 shl 5 + Mod4Mask* = 1 shl 6 + Mod5Mask* = 1 shl 7 + ShiftMapIndex* = 0 + LockMapIndex* = 1 + ControlMapIndex* = 2 + Mod1MapIndex* = 3 + Mod2MapIndex* = 4 + Mod3MapIndex* = 5 + Mod4MapIndex* = 6 + Mod5MapIndex* = 7 + Button1Mask* = 1 shl 8 + Button2Mask* = 1 shl 9 + Button3Mask* = 1 shl 10 + Button4Mask* = 1 shl 11 + Button5Mask* = 1 shl 12 + AnyModifier* = 1 shl 15 + Button1* = 1 + Button2* = 2 + Button3* = 3 + Button4* = 4 + Button5* = 5 + NotifyNormal* = 0 + NotifyGrab* = 1 + NotifyUngrab* = 2 + NotifyWhileGrabbed* = 3 + NotifyHint* = 1 + NotifyAncestor* = 0 + NotifyVirtual* = 1 + NotifyInferior* = 2 + NotifyNonlinear* = 3 + NotifyNonlinearVirtual* = 4 + NotifyPointer* = 5 + NotifyPointerRoot* = 6 + NotifyDetailNone* = 7 + VisibilityUnobscured* = 0 + VisibilityPartiallyObscured* = 1 + VisibilityFullyObscured* = 2 + PlaceOnTop* = 0 + PlaceOnBottom* = 1 + FamilyInternet* = 0 + FamilyDECnet* = 1 + FamilyChaos* = 2 + FamilyInternet6* = 6 + FamilyServerInterpreted* = 5 + PropertyNewValue* = 0 + PropertyDelete* = 1 + ColormapUninstalled* = 0 + ColormapInstalled* = 1 + GrabModeSync* = 0 + GrabModeAsync* = 1 + GrabSuccess* = 0 + AlreadyGrabbed* = 1 + GrabInvalidTime* = 2 + GrabNotViewable* = 3 + GrabFrozen* = 4 + AsyncPointer* = 0 + SyncPointer* = 1 + ReplayPointer* = 2 + AsyncKeyboard* = 3 + SyncKeyboard* = 4 + ReplayKeyboard* = 5 + AsyncBoth* = 6 + SyncBoth* = 7 + RevertToNone* = None + RevertToPointerRoot* = PointerRoot + RevertToParent* = 2 + Success* = 0 + BadRequest* = 1 + BadValue* = 2 + BadWindow* = 3 + BadPixmap* = 4 + BadAtom* = 5 + BadCursor* = 6 + BadFont* = 7 + BadMatch* = 8 + BadDrawable* = 9 + BadAccess* = 10 + BadAlloc* = 11 + BadColor* = 12 + BadGC* = 13 + BadIDChoice* = 14 + BadName* = 15 + BadLength* = 16 + BadImplementation* = 17 + FirstExtensionError* = 128 + LastExtensionError* = 255 + InputOutput* = 1 + InputOnly* = 2 + CWBackPixmap* = 1 shl 0 + CWBackPixel* = 1 shl 1 + CWBorderPixmap* = 1 shl 2 + CWBorderPixel* = 1 shl 3 + CWBitGravity* = 1 shl 4 + CWWinGravity* = 1 shl 5 + CWBackingStore* = 1 shl 6 + CWBackingPlanes* = 1 shl 7 + CWBackingPixel* = 1 shl 8 + CWOverrideRedirect* = 1 shl 9 + CWSaveUnder* = 1 shl 10 + CWEventMask* = 1 shl 11 + CWDontPropagate* = 1 shl 12 + CWColormap* = 1 shl 13 + CWCursor* = 1 shl 14 + CWX* = 1 shl 0 + CWY* = 1 shl 1 + CWWidth* = 1 shl 2 + CWHeight* = 1 shl 3 + CWBorderWidth* = 1 shl 4 + CWSibling* = 1 shl 5 + CWStackMode* = 1 shl 6 + ForgetGravity* = 0 + NorthWestGravity* = 1 + NorthGravity* = 2 + NorthEastGravity* = 3 + WestGravity* = 4 + CenterGravity* = 5 + EastGravity* = 6 + SouthWestGravity* = 7 + SouthGravity* = 8 + SouthEastGravity* = 9 + StaticGravity* = 10 + UnmapGravity* = 0 + NotUseful* = 0 + WhenMapped* = 1 + Always* = 2 + IsUnmapped* = 0 + IsUnviewable* = 1 + IsViewable* = 2 + SetModeInsert* = 0 + SetModeDelete* = 1 + DestroyAll* = 0 + RetainPermanent* = 1 + RetainTemporary* = 2 + Above* = 0 + Below* = 1 + TopIf* = 2 + BottomIf* = 3 + Opposite* = 4 + RaiseLowest* = 0 + LowerHighest* = 1 + PropModeReplace* = 0 + PropModePrepend* = 1 + PropModeAppend* = 2 + GXclear* = 0x00000000 + GXand* = 0x00000001 + GXandReverse* = 0x00000002 + GXcopy* = 0x00000003 + GXandInverted* = 0x00000004 + GXnoop* = 0x00000005 + GXxor* = 0x00000006 + GXor* = 0x00000007 + GXnor* = 0x00000008 + GXequiv* = 0x00000009 + GXinvert* = 0x0000000A + GXorReverse* = 0x0000000B + GXcopyInverted* = 0x0000000C + GXorInverted* = 0x0000000D + GXnand* = 0x0000000E + GXset* = 0x0000000F + LineSolid* = 0 + LineOnOffDash* = 1 + LineDoubleDash* = 2 + CapNotLast* = 0 + CapButt* = 1 + CapRound* = 2 + CapProjecting* = 3 + JoinMiter* = 0 + JoinRound* = 1 + JoinBevel* = 2 + FillSolid* = 0 + FillTiled* = 1 + FillStippled* = 2 + FillOpaqueStippled* = 3 + EvenOddRule* = 0 + WindingRule* = 1 + ClipByChildren* = 0 + IncludeInferiors* = 1 + Unsorted* = 0 + YSorted* = 1 + YXSorted* = 2 + YXBanded* = 3 + CoordModeOrigin* = 0 + CoordModePrevious* = 1 + Complex* = 0 + Nonconvex* = 1 + Convex* = 2 + ArcChord* = 0 + ArcPieSlice* = 1 + GCFunction* = 1 shl 0 + GCPlaneMask* = 1 shl 1 + GCForeground* = 1 shl 2 + GCBackground* = 1 shl 3 + GCLineWidth* = 1 shl 4 + GCLineStyle* = 1 shl 5 + GCCapStyle* = 1 shl 6 + GCJoinStyle* = 1 shl 7 + GCFillStyle* = 1 shl 8 + GCFillRule* = 1 shl 9 + GCTile* = 1 shl 10 + GCStipple* = 1 shl 11 + GCTileStipXOrigin* = 1 shl 12 + GCTileStipYOrigin* = 1 shl 13 + GCFont* = 1 shl 14 + GCSubwindowMode* = 1 shl 15 + GCGraphicsExposures* = 1 shl 16 + GCClipXOrigin* = 1 shl 17 + GCClipYOrigin* = 1 shl 18 + GCClipMask* = 1 shl 19 + GCDashOffset* = 1 shl 20 + GCDashList* = 1 shl 21 + GCArcMode* = 1 shl 22 + GCLastBit* = 22 + FontLeftToRight* = 0 + FontRightToLeft* = 1 + FontChange* = 255 + XYBitmap* = 0 + XYPixmap* = 1 + ZPixmap* = 2 + AllocNone* = 0 + AllocAll* = 1 + DoRed* = 1 shl 0 + DoGreen* = 1 shl 1 + DoBlue* = 1 shl 2 + CursorShape* = 0 + TileShape* = 1 + StippleShape* = 2 + AutoRepeatModeOff* = 0 + AutoRepeatModeOn* = 1 + AutoRepeatModeDefault* = 2 + LedModeOff* = 0 + LedModeOn* = 1 + KBKeyClickPercent* = 1 shl 0 + KBBellPercent* = 1 shl 1 + KBBellPitch* = 1 shl 2 + KBBellDuration* = 1 shl 3 + KBLed* = 1 shl 4 + KBLedMode* = 1 shl 5 + KBKey* = 1 shl 6 + KBAutoRepeatMode* = 1 shl 7 + MappingSuccess* = 0 + MappingBusy* = 1 + MappingFailed* = 2 + MappingModifier* = 0 + MappingKeyboard* = 1 + MappingPointer* = 2 + DontPreferBlanking* = 0 + PreferBlanking* = 1 + DefaultBlanking* = 2 + DisableScreenSaver* = 0 + DisableScreenInterval* = 0 + DontAllowExposures* = 0 + AllowExposures* = 1 + DefaultExposures* = 2 + ScreenSaverReset* = 0 + ScreenSaverActive* = 1 + HostInsert* = 0 + HostDelete* = 1 + EnableAccess* = 1 + DisableAccess* = 0 + StaticGray* = 0 + GrayScale* = 1 + StaticColor* = 2 + PseudoColor* = 3 + TrueColor* = 4 + DirectColor* = 5 + LSBFirst* = 0 + MSBFirst* = 1 + +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/x11pragma.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/x11pragma.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,20 @@ +# included from xlib bindings + + +when defined(use_pkg_config) or defined(use_pkg_config_static): + {.pragma: libx11, cdecl, importc.} + {.pragma: libx11c, cdecl.} + when defined(use_pkg_config_static): + {.passl: gorge("pkg-config x11 --static --libs").} + else: + {.passl: gorge("pkg-config x11 --libs").} +else: + when defined(macosx): + const + libX11* = "libX11.dylib" + else: + const + libX11* = "libX11.so(|.6)" + + {.pragma: libx11, cdecl, dynlib: libX11, importc.} + {.pragma: libx11c, cdecl, dynlib: libX11.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xatom.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xatom.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,81 @@ +# +# THIS IS A GENERATED FILE +# +# Do not change! Changing this file implies a protocol change! +# + +import + x + +const + XA_PRIMARY* = Atom(1) + XA_SECONDARY* = Atom(2) + XA_ARC* = Atom(3) + XA_ATOM* = Atom(4) + XA_BITMAP* = Atom(5) + XA_CARDINAL* = Atom(6) + XA_COLORMAP* = Atom(7) + XA_CURSOR* = Atom(8) + XA_CUT_BUFFER0* = Atom(9) + XA_CUT_BUFFER1* = Atom(10) + XA_CUT_BUFFER2* = Atom(11) + XA_CUT_BUFFER3* = Atom(12) + XA_CUT_BUFFER4* = Atom(13) + XA_CUT_BUFFER5* = Atom(14) + XA_CUT_BUFFER6* = Atom(15) + XA_CUT_BUFFER7* = Atom(16) + XA_DRAWABLE* = Atom(17) + XA_FONT* = Atom(18) + XA_INTEGER* = Atom(19) + XA_PIXMAP* = Atom(20) + XA_POINT* = Atom(21) + XA_RECTANGLE* = Atom(22) + XA_RESOURCE_MANAGER* = Atom(23) + XA_RGB_COLOR_MAP* = Atom(24) + XA_RGB_BEST_MAP* = Atom(25) + XA_RGB_BLUE_MAP* = Atom(26) + XA_RGB_DEFAULT_MAP* = Atom(27) + XA_RGB_GRAY_MAP* = Atom(28) + XA_RGB_GREEN_MAP* = Atom(29) + XA_RGB_RED_MAP* = Atom(30) + XA_STRING* = Atom(31) + XA_VISUALID* = Atom(32) + XA_WINDOW* = Atom(33) + XA_WM_COMMAND* = Atom(34) + XA_WM_HINTS* = Atom(35) + XA_WM_CLIENT_MACHINE* = Atom(36) + XA_WM_ICON_NAME* = Atom(37) + XA_WM_ICON_SIZE* = Atom(38) + XA_WM_NAME* = Atom(39) + XA_WM_NORMAL_HINTS* = Atom(40) + XA_WM_SIZE_HINTS* = Atom(41) + XA_WM_ZOOM_HINTS* = Atom(42) + XA_MIN_SPACE* = Atom(43) + XA_NORM_SPACE* = Atom(44) + XA_MAX_SPACE* = Atom(45) + XA_END_SPACE* = Atom(46) + XA_SUPERSCRIPT_X* = Atom(47) + XA_SUPERSCRIPT_Y* = Atom(48) + XA_SUBSCRIPT_X* = Atom(49) + XA_SUBSCRIPT_Y* = Atom(50) + XA_UNDERLINE_POSITION* = Atom(51) + XA_UNDERLINE_THICKNESS* = Atom(52) + XA_STRIKEOUT_ASCENT* = Atom(53) + XA_STRIKEOUT_DESCENT* = Atom(54) + XA_ITALIC_ANGLE* = Atom(55) + XA_X_HEIGHT* = Atom(56) + XA_QUAD_WIDTH* = Atom(57) + XA_WEIGHT* = Atom(58) + XA_POINT_SIZE* = Atom(59) + XA_RESOLUTION* = Atom(60) + XA_COPYRIGHT* = Atom(61) + XA_NOTICE* = Atom(62) + XA_FONT_NAME* = Atom(63) + XA_FAMILY_NAME* = Atom(64) + XA_FULL_NAME* = Atom(65) + XA_CAP_HEIGHT* = Atom(66) + XA_WM_CLASS* = Atom(67) + XA_WM_TRANSIENT_FOR* = Atom(68) + XA_LAST_PREDEFINED* = Atom(68) + +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xcms.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xcms.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,418 @@ +import + x, xlib + +#const +# libX11* = "X11" + +# +# Automatically converted by H2Pas 0.99.15 from xcms.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xcms.h +# + +const + XcmsFailure* = 0 + XcmsSuccess* = 1 + XcmsSuccessWithCompression* = 2 + +type + PXcmsColorFormat* = ptr XcmsColorFormat + XcmsColorFormat* = int32 + +{.deprecated: [TXcmsColorFormat: XcmsColorFormat].} + +proc XcmsUndefinedFormat*(): XcmsColorFormat +proc XcmsCIEXYZFormat*(): XcmsColorFormat +proc XcmsCIEuvYFormat*(): XcmsColorFormat +proc XcmsCIExyYFormat*(): XcmsColorFormat +proc XcmsCIELabFormat*(): XcmsColorFormat +proc XcmsCIELuvFormat*(): XcmsColorFormat +proc XcmsTekHVCFormat*(): XcmsColorFormat +proc XcmsRGBFormat*(): XcmsColorFormat +proc XcmsRGBiFormat*(): XcmsColorFormat +const + XcmsInitNone* = 0x00000000 + XcmsInitSuccess* = 0x00000001 + XcmsInitFailure* = 0x000000FF + +type + PXcmsFloat* = ptr XcmsFloat + XcmsFloat* = float64 + PXcmsRGB* = ptr XcmsRGB + XcmsRGB*{.final.} = object + red*: int16 + green*: int16 + blue*: int16 + + PXcmsRGBi* = ptr XcmsRGBi + XcmsRGBi*{.final.} = object + red*: XcmsFloat + green*: XcmsFloat + blue*: XcmsFloat + + PXcmsCIEXYZ* = ptr XcmsCIEXYZ + XcmsCIEXYZ*{.final.} = object + X*: XcmsFloat + Y*: XcmsFloat + Z*: XcmsFloat + + PXcmsCIEuvY* = ptr XcmsCIEuvY + XcmsCIEuvY*{.final.} = object + u_prime*: XcmsFloat + v_prime*: XcmsFloat + Y*: XcmsFloat + + PXcmsCIExyY* = ptr XcmsCIExyY + XcmsCIExyY*{.final.} = object + x*: XcmsFloat + y*: XcmsFloat + theY*: XcmsFloat + + PXcmsCIELab* = ptr XcmsCIELab + XcmsCIELab*{.final.} = object + L_star*: XcmsFloat + a_star*: XcmsFloat + b_star*: XcmsFloat + + PXcmsCIELuv* = ptr XcmsCIELuv + XcmsCIELuv*{.final.} = object + L_star*: XcmsFloat + u_star*: XcmsFloat + v_star*: XcmsFloat + + PXcmsTekHVC* = ptr XcmsTekHVC + XcmsTekHVC*{.final.} = object + H*: XcmsFloat + V*: XcmsFloat + C*: XcmsFloat + + PXcmsPad* = ptr XcmsPad + XcmsPad*{.final.} = object + pad0*: XcmsFloat + pad1*: XcmsFloat + pad2*: XcmsFloat + pad3*: XcmsFloat + + PXcmsColor* = ptr XcmsColor + XcmsColor*{.final.} = object # spec : record + # case longint of + # 0 : ( RGB : XcmsRGB ); + # 1 : ( RGBi : XcmsRGBi ); + # 2 : ( CIEXYZ : XcmsCIEXYZ ); + # 3 : ( CIEuvY : XcmsCIEuvY ); + # 4 : ( CIExyY : XcmsCIExyY ); + # 5 : ( CIELab : XcmsCIELab ); + # 6 : ( CIELuv : XcmsCIELuv ); + # 7 : ( TekHVC : XcmsTekHVC ); + # 8 : ( Pad : XcmsPad ); + # end; + pad*: XcmsPad + pixel*: int32 + format*: XcmsColorFormat + + PXcmsPerScrnInfo* = ptr XcmsPerScrnInfo + XcmsPerScrnInfo*{.final.} = object + screenWhitePt*: XcmsColor + functionSet*: XPointer + screenData*: XPointer + state*: int8 + pad*: array[0..2, char] + + PXcmsCCC* = ptr XcmsCCC + XcmsCompressionProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, + para3: int32, para4: int32, para5: PBool): Status{. + cdecl.} + XcmsWhiteAdjustProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: XcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): Status{. + cdecl.} + XcmsCCC*{.final.} = object + dpy*: PDisplay + screenNumber*: int32 + visual*: PVisual + clientWhitePt*: XcmsColor + gamutCompProc*: XcmsCompressionProc + gamutCompClientData*: XPointer + whitePtAdjProc*: XcmsWhiteAdjustProc + whitePtAdjClientData*: XPointer + pPerScrnInfo*: PXcmsPerScrnInfo + + PXcmsCCCRec* = ptr XcmsCCCRec + XcmsCCCRec* = XcmsCCC + + XcmsScreenInitProc* = proc (para1: PDisplay, para2: int32, + para3: PXcmsPerScrnInfo): Status{.cdecl.} + XcmsScreenFreeProc* = proc (para1: XPointer){.cdecl.} + + XcmsConversionProc* = proc (){.cdecl.} + + PXcmsFuncListPtr* = ptr XcmsFuncListPtr + XcmsFuncListPtr* = XcmsConversionProc + + XcmsParseStringProc* = proc (para1: cstring, para2: PXcmsColor): int32{.cdecl.} + + PXcmsColorSpace* = ptr XcmsColorSpace + XcmsColorSpace*{.final.} = object + prefix*: cstring + id*: XcmsColorFormat + parseString*: XcmsParseStringProc + to_CIEXYZ*: XcmsFuncListPtr + from_CIEXYZ*: XcmsFuncListPtr + inverse_flag*: int32 + + PXcmsFunctionSet* = ptr XcmsFunctionSet + XcmsFunctionSet*{.final.} = object # error + # extern Status XcmsAddColorSpace ( + # in declaration at line 323 + DDColorSpaces*: ptr PXcmsColorSpace + screenInitProc*: XcmsScreenInitProc + screenFreeProc*: XcmsScreenFreeProc + +{.deprecated: [TXcmsRGB: XcmsRGB].} +{.deprecated: [TXcmsRGBi: XcmsRGBi].} +{.deprecated: [TXcmsCIEXYZ: XcmsCIEXYZ].} +{.deprecated: [TXcmsCIEuvY: XcmsCIEuvY].} +{.deprecated: [TXcmsCIExyY: XcmsCIExyY].} +{.deprecated: [TXcmsCIELab: XcmsCIELab].} +{.deprecated: [TXcmsCIELuv: XcmsCIELuv].} +{.deprecated: [TXcmsTekHVC: XcmsTekHVC].} +{.deprecated: [TXcmsPad: XcmsPad].} +{.deprecated: [TXcmsColor: XcmsColor].} +{.deprecated: [TXcmsPerScrnInfo: XcmsPerScrnInfo].} +{.deprecated: [TXcmsCompressionProc: XcmsCompressionProc].} +{.deprecated: [TXcmsWhiteAdjustProc: XcmsWhiteAdjustProc].} +{.deprecated: [TXcmsCCC: XcmsCCC].} +{.deprecated: [TXcmsCCCRec: XcmsCCCRec].} +{.deprecated: [TXcmsScreenInitProc: XcmsScreenInitProc].} +{.deprecated: [TXcmsScreenFreeProc: XcmsScreenFreeProc].} +{.deprecated: [TXcmsConversionProc: XcmsConversionProc].} +{.deprecated: [TXcmsFuncListPtr: XcmsFuncListPtr].} +{.deprecated: [TXcmsParseStringProc: XcmsParseStringProc].} +{.deprecated: [TXcmsColorSpace: XcmsColorSpace].} +{.deprecated: [TXcmsFunctionSet: XcmsFunctionSet].} + +proc XcmsAddFunctionSet*(para1: PXcmsFunctionSet): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsAllocColor*(para1: PDisplay, para2: Colormap, para3: PXcmsColor, + para4: XcmsColorFormat): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsAllocNamedColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: PXcmsColor, para5: PXcmsColor, + para6: XcmsColorFormat): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCCCOfColormap*(para1: PDisplay, para2: Colormap): XcmsCCC{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipab*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipL*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipLab*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabQueryMaxC*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabQueryMaxL*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabQueryMaxLC*(para1: XcmsCCC, para2: XcmsFloat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELabQueryMinL*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabToCIEXYZ*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIELabWhiteShiftColors*(para1: XcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: XcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvClipL*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvClipLuv*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvClipuv*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvQueryMaxC*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvQueryMaxL*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvQueryMaxLC*(para1: XcmsCCC, para2: XcmsFloat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvQueryMinL*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvToCIEuvY*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvWhiteShiftColors*(para1: XcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: XcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIELab*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIEuvY*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIExyY*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToRGBi*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToCIELuv*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToCIEXYZ*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToTekHVC*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsCIExyYToCIEXYZ*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsClientWhitePointOfCCC*(para1: XcmsCCC): PXcmsColor{.cdecl, + dynlib: libX11, importc.} +proc XcmsConvertColors*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: XcmsColorFormat, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsCreateCCC*(para1: PDisplay, para2: int32, para3: PVisual, + para4: PXcmsColor, para5: XcmsCompressionProc, + para6: XPointer, para7: XcmsWhiteAdjustProc, + para8: XPointer): XcmsCCC{.cdecl, dynlib: libX11, importc.} +proc XcmsDefaultCCC*(para1: PDisplay, para2: int32): XcmsCCC{.cdecl, + dynlib: libX11, importc.} +proc XcmsDisplayOfCCC*(para1: XcmsCCC): PDisplay{.cdecl, dynlib: libX11, + importc.} +proc XcmsFormatOfPrefix*(para1: cstring): XcmsColorFormat{.cdecl, + dynlib: libX11, importc.} +proc XcmsFreeCCC*(para1: XcmsCCC){.cdecl, dynlib: libX11, importc.} +proc XcmsLookupColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: PXcmsColor, para5: PXcmsColor, + para6: XcmsColorFormat): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsPrefixOfFormat*(para1: XcmsColorFormat): cstring{.cdecl, + dynlib: libX11, importc.} +proc XcmsQueryBlack*(para1: XcmsCCC, para2: XcmsColorFormat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryBlue*(para1: XcmsCCC, para2: XcmsColorFormat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryColor*(para1: PDisplay, para2: Colormap, para3: PXcmsColor, + para4: XcmsColorFormat): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsQueryColors*(para1: PDisplay, para2: Colormap, para3: PXcmsColor, + para4: int32, para5: XcmsColorFormat): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsQueryGreen*(para1: XcmsCCC, para2: XcmsColorFormat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryRed*(para1: XcmsCCC, para2: XcmsColorFormat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryWhite*(para1: XcmsCCC, para2: XcmsColorFormat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsRGBiToCIEXYZ*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsRGBiToRGB*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsRGBToRGBi*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsScreenNumberOfCCC*(para1: XcmsCCC): int32{.cdecl, dynlib: libX11, + importc.} +proc XcmsScreenWhitePointOfCCC*(para1: XcmsCCC): PXcmsColor{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetCCCOfColormap*(para1: PDisplay, para2: Colormap, para3: XcmsCCC): XcmsCCC{. + cdecl, dynlib: libX11, importc.} +proc XcmsSetCompressionProc*(para1: XcmsCCC, para2: XcmsCompressionProc, + para3: XPointer): XcmsCompressionProc{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetWhiteAdjustProc*(para1: XcmsCCC, para2: XcmsWhiteAdjustProc, + para3: XPointer): XcmsWhiteAdjustProc{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetWhitePoint*(para1: XcmsCCC, para2: PXcmsColor): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsStoreColor*(para1: PDisplay, para2: Colormap, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsStoreColors*(para1: PDisplay, para2: Colormap, para3: PXcmsColor, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipC*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipV*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipVC*(para1: XcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): Status{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCQueryMaxC*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCQueryMaxV*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCQueryMaxVC*(para1: XcmsCCC, para2: XcmsFloat, para3: PXcmsColor): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCQueryMaxVSamples*(para1: XcmsCCC, para2: XcmsFloat, + para3: PXcmsColor, para4: int32): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCQueryMinV*(para1: XcmsCCC, para2: XcmsFloat, para3: XcmsFloat, + para4: PXcmsColor): Status{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCToCIEuvY*(para1: XcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): Status{.cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCWhiteShiftColors*(para1: XcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: XcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): Status{. + cdecl, dynlib: libX11, importc.} +proc XcmsVisualOfCCC*(para1: XcmsCCC): PVisual{.cdecl, dynlib: libX11, importc.} +# implementation + +proc XcmsUndefinedFormat(): XcmsColorFormat = + result = 0x00000000'i32 + +proc XcmsCIEXYZFormat(): XcmsColorFormat = + result = 0x00000001'i32 + +proc XcmsCIEuvYFormat(): XcmsColorFormat = + result = 0x00000002'i32 + +proc XcmsCIExyYFormat(): XcmsColorFormat = + result = 0x00000003'i32 + +proc XcmsCIELabFormat(): XcmsColorFormat = + result = 0x00000004'i32 + +proc XcmsCIELuvFormat(): XcmsColorFormat = + result = 0x00000005'i32 + +proc XcmsTekHVCFormat(): XcmsColorFormat = + result = 0x00000006'i32 + +proc XcmsRGBFormat(): XcmsColorFormat = + result = 0x80000000'i32 + +proc XcmsRGBiFormat(): XcmsColorFormat = + result = 0x80000001'i32 + +#when defined(MACROS): +proc DisplayOfCCC(ccc: XcmsCCC): PDisplay = + result = ccc.dpy + +proc ScreenNumberOfCCC(ccc: XcmsCCC): int32 = + result = ccc.screenNumber + +proc VisualOfCCC(ccc: XcmsCCC): PVisual = + result = ccc.visual + +proc ClientWhitePointOfCCC(ccc: var XcmsCCC): ptr XcmsColor = + result = addr(ccc.clientWhitePt) + +proc ScreenWhitePointOfCCC(ccc: var XcmsCCC): ptr XcmsColor = + result = addr(ccc.pPerScrnInfo.screenWhitePt) + +proc FunctionSetOfCCC(ccc: XcmsCCC): Xpointer = + result = ccc.pPerScrnInfo.functionSet + diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xf86dga.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xf86dga.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,241 @@ +# +# Copyright (c) 1999 XFree86 Inc +# +# $XFree86: xc/include/extensions/xf86dga.h,v 3.20 1999/10/13 04:20:48 dawes Exp $ + +import + x, xlib + +const + libXxf86dga* = "libXxf86dga.so" + +#type +# cfloat* = float32 + +# $XFree86: xc/include/extensions/xf86dga1.h,v 1.2 1999/04/17 07:05:41 dawes Exp $ +# +# +#Copyright (c) 1995 Jon Tombs +#Copyright (c) 1995 XFree86 Inc +# +# +#************************************************************************ +# +# THIS IS THE OLD DGA API AND IS OBSOLETE. PLEASE DO NOT USE IT ANYMORE +# +#************************************************************************ + +type + PPcchar* = ptr ptr cstring + +const + X_XF86DGAQueryVersion* = 0 + X_XF86DGAGetVideoLL* = 1 + X_XF86DGADirectVideo* = 2 + X_XF86DGAGetViewPortSize* = 3 + X_XF86DGASetViewPort* = 4 + X_XF86DGAGetVidPage* = 5 + X_XF86DGASetVidPage* = 6 + X_XF86DGAInstallColormap* = 7 + X_XF86DGAQueryDirectVideo* = 8 + X_XF86DGAViewPortChanged* = 9 + XF86DGADirectPresent* = 0x00000001 + XF86DGADirectGraphics* = 0x00000002 + XF86DGADirectMouse* = 0x00000004 + XF86DGADirectKeyb* = 0x00000008 + XF86DGAHasColormap* = 0x00000100 + XF86DGADirectColormap* = 0x00000200 + +proc XF86DGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, + minorVersion: Pcint): XBool{.cdecl, + dynlib: libXxf86dga, importc.} +proc XF86DGAQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): XBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVideoLL*(dpy: PDisplay, screen: cint, base_addr: Pcint, + width: Pcint, bank_size: Pcint, ram_size: Pcint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVideo*(dpy: PDisplay, screen: cint, base_addr: PPcchar, + width: Pcint, bank_size: Pcint, ram_size: Pcint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGADirectVideo*(dpy: PDisplay, screen: cint, enable: cint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGADirectVideoLL*(dpy: PDisplay, screen: cint, enable: cint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetViewPortSize*(dpy: PDisplay, screen: cint, width: Pcint, + height: Pcint): Status{.cdecl, + dynlib: libXxf86dga, importc.} +proc XF86DGASetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVidPage*(dpy: PDisplay, screen: cint, vid_page: Pcint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGASetVidPage*(dpy: PDisplay, screen: cint, vid_page: cint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAInstallColormap*(dpy: PDisplay, screen: cint, Colormap: Colormap): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAForkApp*(screen: cint): cint{.cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAQueryDirectVideo*(dpy: PDisplay, screen: cint, flags: Pcint): Status{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAViewPortChanged*(dpy: PDisplay, screen: cint, n: cint): XBool{. + cdecl, dynlib: libXxf86dga, importc.} +const + X_XDGAQueryVersion* = 0 # 1 through 9 are in xf86dga1.pp + # 10 and 11 are reserved to avoid conflicts with rogue DGA extensions + X_XDGAQueryModes* = 12 + X_XDGASetMode* = 13 + X_XDGASetViewport* = 14 + X_XDGAInstallColormap* = 15 + X_XDGASelectInput* = 16 + X_XDGAFillRectangle* = 17 + X_XDGACopyArea* = 18 + X_XDGACopyTransparentArea* = 19 + X_XDGAGetViewportStatus* = 20 + X_XDGASync* = 21 + X_XDGAOpenFramebuffer* = 22 + X_XDGACloseFramebuffer* = 23 + X_XDGASetClientVersion* = 24 + X_XDGAChangePixmapMode* = 25 + X_XDGACreateColormap* = 26 + XDGAConcurrentAccess* = 0x00000001 + XDGASolidFillRect* = 0x00000002 + XDGABlitRect* = 0x00000004 + XDGABlitTransRect* = 0x00000008 + XDGAPixmap* = 0x00000010 + XDGAInterlaced* = 0x00010000 + XDGADoublescan* = 0x00020000 + XDGAFlipImmediate* = 0x00000001 + XDGAFlipRetrace* = 0x00000002 + XDGANeedRoot* = 0x00000001 + XF86DGANumberEvents* = 7 + XDGAPixmapModeLarge* = 0 + XDGAPixmapModeSmall* = 1 + XF86DGAClientNotLocal* = 0 + XF86DGANoDirectVideoMode* = 1 + XF86DGAScreenNotActive* = 2 + XF86DGADirectNotActivated* = 3 + XF86DGAOperationNotSupported* = 4 + XF86DGANumberErrors* = (XF86DGAOperationNotSupported + 1) + +type + PXDGAMode* = ptr XDGAMode + XDGAMode*{.final.} = object + num*: cint # A unique identifier for the mode (num > 0) + name*: cstring # name of mode given in the XF86Config + verticalRefresh*: cfloat + flags*: cint # DGA_CONCURRENT_ACCESS, etc... + imageWidth*: cint # linear accessible portion (pixels) + imageHeight*: cint + pixmapWidth*: cint # Xlib accessible portion (pixels) + pixmapHeight*: cint # both fields ignored if no concurrent access + bytesPerScanline*: cint + byteOrder*: cint # MSBFirst, LSBFirst + depth*: cint + bitsPerPixel*: cint + redMask*: culong + greenMask*: culong + blueMask*: culong + visualClass*: cshort + viewportWidth*: cint + viewportHeight*: cint + xViewportStep*: cint # viewport position granularity + yViewportStep*: cint + maxViewportX*: cint # max viewport origin + maxViewportY*: cint + viewportFlags*: cint # types of page flipping possible + reserved1*: cint + reserved2*: cint + + PXDGADevice* = ptr XDGADevice + XDGADevice*{.final.} = object + mode*: XDGAMode + data*: Pcuchar + pixmap*: Pixmap + + PXDGAButtonEvent* = ptr XDGAButtonEvent + XDGAButtonEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: Time + state*: cuint + button*: cuint + + PXDGAKeyEvent* = ptr XDGAKeyEvent + XDGAKeyEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: Time + state*: cuint + keycode*: cuint + + PXDGAMotionEvent* = ptr XDGAMotionEvent + XDGAMotionEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: Time + state*: cuint + dx*: cint + dy*: cint + + PXDGAEvent* = ptr XDGAEvent + XDGAEvent*{.final.} = object + pad*: array[0..23, clong] # sorry you have to cast if you want access + # Case LongInt Of + # 0 : (_type : cint); + # 1 : (xbutton : XDGAButtonEvent); + # 2 : (xkey : XDGAKeyEvent); + # 3 : (xmotion : XDGAMotionEvent); + # 4 : (pad : Array[0..23] Of clong); + +{.deprecated: [TXDGAMode: XDGAMode].} +{.deprecated: [TXDGADevice: XDGADevice].} +{.deprecated: [TXDGAButtonEvent: XDGAButtonEvent].} +{.deprecated: [TXDGAKeyEvent: XDGAKeyEvent].} +{.deprecated: [TXDGAMotionEvent: XDGAMotionEvent].} +{.deprecated: [TXDGAEvent: XDGAEvent].} + +proc XDGAQueryExtension*(dpy: PDisplay, eventBase: Pcint, erroBase: Pcint): XBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, minorVersion: Pcint): XBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAQueryModes*(dpy: PDisplay, screen: cint, num: Pcint): PXDGAMode{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASetMode*(dpy: PDisplay, screen: cint, mode: cint): PXDGADevice{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAOpenFramebuffer*(dpy: PDisplay, screen: cint): XBool{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACloseFramebuffer*(dpy: PDisplay, screen: cint){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASetViewport*(dpy: PDisplay, screen: cint, x: cint, y: cint, flags: cint){. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAInstallColormap*(dpy: PDisplay, screen: cint, cmap: Colormap){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACreateColormap*(dpy: PDisplay, screen: cint, device: PXDGADevice, + alloc: cint): Colormap{.cdecl, dynlib: libXxf86dga, + importc.} +proc XDGASelectInput*(dpy: PDisplay, screen: cint, event_mask: clong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAFillRectangle*(dpy: PDisplay, screen: cint, x: cint, y: cint, + width: cuint, height: cuint, color: culong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACopyArea*(dpy: PDisplay, screen: cint, srcx: cint, srcy: cint, + width: cuint, height: cuint, dstx: cint, dsty: cint){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACopyTransparentArea*(dpy: PDisplay, screen: cint, srcx: cint, + srcy: cint, width: cuint, height: cuint, + dstx: cint, dsty: cint, key: culong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAGetViewportStatus*(dpy: PDisplay, screen: cint): cint{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASync*(dpy: PDisplay, screen: cint){.cdecl, dynlib: libXxf86dga, importc.} +proc XDGASetClientVersion*(dpy: PDisplay): XBool{.cdecl, dynlib: libXxf86dga, + importc.} +proc XDGAChangePixmapMode*(dpy: PDisplay, screen: cint, x: Pcint, y: Pcint, + mode: cint){.cdecl, dynlib: libXxf86dga, importc.} +proc XDGAKeyEventToXKeyEvent*(dk: PXDGAKeyEvent, xk: PXKeyEvent){.cdecl, + dynlib: libXxf86dga, importc.} +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xf86vmode.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xf86vmode.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,235 @@ +# $XFree86: xc/include/extensions/xf86vmode.h,v 3.30 2001/05/07 20:09:50 mvojkovi Exp $ +# +# +#Copyright 1995 Kaleb S. KEITHLEY +# +#Permission is hereby granted, free of charge, to any person obtaining +#a copy of this software and associated documentation files (the +#"Software"), to deal in the Software without restriction, including +#without limitation the rights to use, copy, modify, merge, publish, +#distribute, sublicense, and/or sell copies of the Software, and to +#permit persons to whom the Software is furnished to do so, subject to +#the following conditions: +# +#The above copyright notice and this permission notice shall be +#included in all copies or substantial portions of the Software. +# +#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +#IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES +#OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +#ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +#OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of Kaleb S. KEITHLEY +#shall not be used in advertising or otherwise to promote the sale, use +#or other dealings in this Software without prior written authorization +#from Kaleb S. KEITHLEY +# +# +# $Xorg: xf86vmode.h,v 1.3 2000/08/18 04:05:46 coskrey Exp $ +# THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION + +import + x, xlib + +const + libXxf86vm* = "libXxf86vm.so" + +type + PINT32* = ptr int32 + +const + X_XF86VidModeQueryVersion* = 0 + X_XF86VidModeGetModeLine* = 1 + X_XF86VidModeModModeLine* = 2 + X_XF86VidModeSwitchMode* = 3 + X_XF86VidModeGetMonitor* = 4 + X_XF86VidModeLockModeSwitch* = 5 + X_XF86VidModeGetAllModeLines* = 6 + X_XF86VidModeAddModeLine* = 7 + X_XF86VidModeDeleteModeLine* = 8 + X_XF86VidModeValidateModeLine* = 9 + X_XF86VidModeSwitchToMode* = 10 + X_XF86VidModeGetViewPort* = 11 + X_XF86VidModeSetViewPort* = 12 # new for version 2.x of this extension + X_XF86VidModeGetDotClocks* = 13 + X_XF86VidModeSetClientVersion* = 14 + X_XF86VidModeSetGamma* = 15 + X_XF86VidModeGetGamma* = 16 + X_XF86VidModeGetGammaRamp* = 17 + X_XF86VidModeSetGammaRamp* = 18 + X_XF86VidModeGetGammaRampSize* = 19 + X_XF86VidModeGetPermissions* = 20 + CLKFLAG_PROGRAMABLE* = 1 + +when defined(XF86VIDMODE_EVENTS): + const + XF86VidModeNotify* = 0 + XF86VidModeNumberEvents* = (XF86VidModeNotify + 1) + XF86VidModeNotifyMask* = 0x00000001 + XF86VidModeNonEvent* = 0 + XF86VidModeModeChange* = 1 +else: + const + XF86VidModeNumberEvents* = 0 +const + XF86VidModeBadClock* = 0 + XF86VidModeBadHTimings* = 1 + XF86VidModeBadVTimings* = 2 + XF86VidModeModeUnsuitable* = 3 + XF86VidModeExtensionDisabled* = 4 + XF86VidModeClientNotLocal* = 5 + XF86VidModeZoomLocked* = 6 + XF86VidModeNumberErrors* = (XF86VidModeZoomLocked + 1) + XF86VM_READ_PERMISSION* = 1 + XF86VM_WRITE_PERMISSION* = 2 + +type + PXF86VidModeModeLine* = ptr XF86VidModeModeLine + XF86VidModeModeLine*{.final.} = object + hdisplay*: cushort + hsyncstart*: cushort + hsyncend*: cushort + htotal*: cushort + hskew*: cushort + vdisplay*: cushort + vsyncstart*: cushort + vsyncend*: cushort + vtotal*: cushort + flags*: cuint + privsize*: cint + c_private*: PINT32 + + PPPXF86VidModeModeInfo* = ptr PPXF86VidModeModeInfo + PPXF86VidModeModeInfo* = ptr PXF86VidModeModeInfo + PXF86VidModeModeInfo* = ptr XF86VidModeModeInfo + XF86VidModeModeInfo*{.final.} = object + dotclock*: cuint + hdisplay*: cushort + hsyncstart*: cushort + hsyncend*: cushort + htotal*: cushort + hskew*: cushort + vdisplay*: cushort + vsyncstart*: cushort + vsyncend*: cushort + vtotal*: cushort + flags*: cuint + privsize*: cint + c_private*: PINT32 + + PXF86VidModeSyncRange* = ptr XF86VidModeSyncRange + XF86VidModeSyncRange*{.final.} = object + hi*: cfloat + lo*: cfloat + + PXF86VidModeMonitor* = ptr XF86VidModeMonitor + XF86VidModeMonitor*{.final.} = object + vendor*: cstring + model*: cstring + EMPTY*: cfloat + nhsync*: cuchar + hsync*: PXF86VidModeSyncRange + nvsync*: cuchar + vsync*: PXF86VidModeSyncRange + + PXF86VidModeNotifyEvent* = ptr XF86VidModeNotifyEvent + XF86VidModeNotifyEvent*{.final.} = object + theType*: cint # of event + serial*: culong # # of last request processed by server + send_event*: XBool # true if this came from a SendEvent req + display*: PDisplay # Display the event was read from + root*: Window # root window of event screen + state*: cint # What happened + kind*: cint # What happened + forced*: XBool # extents of new region + time*: Time # event timestamp + + PXF86VidModeGamma* = ptr XF86VidModeGamma + XF86VidModeGamma*{.final.} = object + red*: cfloat # Red Gamma value + green*: cfloat # Green Gamma value + blue*: cfloat # Blue Gamma value + +{.deprecated: [TXF86VidModeModeLine: XF86VidModeModeLine].} +{.deprecated: [TXF86VidModeModeInfo: XF86VidModeModeInfo].} +{.deprecated: [TXF86VidModeSyncRange: XF86VidModeSyncRange].} +{.deprecated: [TXF86VidModeMonitor: XF86VidModeMonitor].} +{.deprecated: [TXF86VidModeNotifyEvent: XF86VidModeNotifyEvent].} +{.deprecated: [TXF86VidModeGamma: XF86VidModeGamma].} + +when defined(MACROS): + proc XF86VidModeSelectNextMode*(disp: PDisplay, scr: cint): XBool + proc XF86VidModeSelectPrevMode*(disp: PDisplay, scr: cint): XBool +proc XF86VidModeQueryVersion*(dpy: PDisplay, majorVersion: Pcint, + minorVersion: Pcint): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeQueryExtension*(dpy: PDisplay, event_base: Pcint, + error_base: Pcint): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeSetClientVersion*(dpy: PDisplay): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetModeLine*(dpy: PDisplay, screen: cint, dotclock: Pcint, + modeline: PXF86VidModeModeLine): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetAllModeLines*(dpy: PDisplay, screen: cint, modecount: Pcint, + modelinesPtr: PPPXF86VidModeModeInfo): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeAddModeLine*(dpy: PDisplay, screen: cint, + new_modeline: PXF86VidModeModeInfo, + after_modeline: PXF86VidModeModeInfo): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeDeleteModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeModModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeLine): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeValidateModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): Status{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSwitchMode*(dpy: PDisplay, screen: cint, zoom: cint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSwitchToMode*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeLockModeSwitch*(dpy: PDisplay, screen: cint, lock: cint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetMonitor*(dpy: PDisplay, screen: cint, + monitor: PXF86VidModeMonitor): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetViewPort*(dpy: PDisplay, screen: cint, x_return: Pcint, + y_return: Pcint): XBool{.cdecl, dynlib: libXxf86vm, + importc.} +proc XF86VidModeSetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetDotClocks*(dpy: PDisplay, screen: cint, flags_return: Pcint, + number_of_clocks_return: Pcint, + max_dot_clock_return: Pcint, clocks_return: PPcint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, + red_array: Pcushort, green_array: Pcushort, + blue_array: Pcushort): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, + red_array: Pcushort, green_array: Pcushort, + blue_array: Pcushort): XBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGammaRampSize*(dpy: PDisplay, screen: cint, size: Pcint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetPermissions*(dpy: PDisplay, screen: cint, permissions: Pcint): XBool{. + cdecl, dynlib: libXxf86vm, importc.} +# implementation + +#when defined(MACROS): +proc XF86VidModeSelectNextMode(disp: PDisplay, scr: cint): XBool = + XF86VidModeSwitchMode(disp, scr, 1) + +proc XF86VidModeSelectPrevMode(disp: PDisplay, scr: cint): XBool = + XF86VidModeSwitchMode(disp, scr, - 1) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xft.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xft.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,680 @@ +# Converted from X11/Xft/Xft.h +import + x, + xlib, + xrender, + xutil + +const + xftLib = "libXft.so" + +# Defined in the FreeType library +type + FT_UInt* = cuint + PFT_UInt* = ptr FT_UInt + FT_Face* = object + PFT_Face* = ptr FT_Face + +# Defined in the fontconfig library +type + FcEndian* = enum + FcEndianBig, FcEndianLittle + + FcResult* = enum + FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, + FcResultNoId, FcResultOutOfMemory + PFcResult* = ptr FcResult + + FcBool* = cint + + FcCharSet* = object + PFcCharSet* = ptr FcCharSet + + FcPattern* = object + PFcPattern* = ptr FcPattern + + FcFontSet* = object + nfont*: cint + sfont*: cint + fonts*: ptr PFcPattern + PFcFontSet* = ptr FcFontSet + + FcChar8* = cuchar + PFcChar8* = ptr FcChar8 + + FcChar16* = cushort + PFcChar16* = ptr FcChar16 + + FcChar32* = cuint + PFcChar32* = ptr FcChar32 + +type + XftFontInfo* = object + PXftFontInfo* = ptr XftFontInfo + XftFont* = object + ascent*: cint + descent*: cint + height*: cint + max_advance_width*: cint + charset*: PFcCharSet + pattern*: PFcPattern + PXftFont* = ptr XftFont + + XftDraw* = object + PXftDraw* = ptr XftDraw + + XftColor* = object + pixel*: culong + color*: XRenderColor + PXftColor* = ptr XftColor + + XftCharSpec* = object + ucs4*: FcChar32 + x*: cshort + y*: cshort + PXftCharSpec* = ptr XftCharSpec + + XftCharFontSpec* = object + font*: PXftFont + ucs4*: FcChar32 + x*: cshort + y*: cshort + PXftCharFontSpec* = ptr XftCharFontSpec + + XftGlyphSpec* = object + glyph*: FT_UInt + x*: cshort + y*: cshort + PXftGlyphSpec* = ptr XftGlyphSpec + + XftGlyphFontSpec* = object + font*: PXftFont + glyph*: FT_UInt + x*: cshort + y*: cshort + PXftGlyphFontSpec = ptr XftGlyphFontSpec + +# xftcolor.c +proc XftColorAllocName*( + display: PDisplay, + visual: PVisual, + cmap: Colormap, + name: cstring, + result: PXftColor +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftColorAllocValue*( + display: PDisplay, + visual: PVisual, + cmap: Colormap, + color: PXRenderColor, + result: PXftColor +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftColorFree*( + display: PDisplay, + visual: PVisual, + cmap: Colormap, + color: PXftColor +) {.cdecl, dynlib: xftLib, importc.} + +# xftdpy.c +proc XftDefaultHasRender*( + display: PDisplay +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftDefaultSet*( + display: PDisplay, + defaults: PFcPattern +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftDefaultSubstitute*( + display: PDisplay, + screen: cint, + pattern: PFcPattern +) {.cdecl, dynlib: xftLib, importc.} + +# xftdraw.c +proc XftDrawCreate*( + display: PDisplay, + drawable: Drawable, + visual: PVisual, + colormap: Colormap +): PXftDraw {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawCreateBitmap*( + display: PDisplay, + bitmap: Pixmap +): PXftDraw {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawCreateAlpha*( + display: PDisplay, + pixmap: Pixmap, + depth: cint +): PXftDraw {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawChange*( + draw: PXftDraw, + drawable: Drawable +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawDisplay*( + draw: PXftDraw +): PDisplay {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawDrawable*( + draw: PXftDraw +): Drawable {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawColormap*( + draw: PXftDraw +): Colormap {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawVisual*( + draw: PXftDraw +): PVisual {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawDestroy*( + draw: PXftDraw +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawPicture*( + draw: PXftDraw +): Picture {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawSrcPicture*( + draw: PXftDraw, + color: PXftColor +): Picture {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawGlyphs*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + glyphs: PFt_UInt, + nglyphs: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawString8*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawString16*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + str: PFcChar16, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawString32*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + str: PFcChar32, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawStringUtf8*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawStringUtf16*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawCharSpec*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + chars: PXftCharSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawCharFontSpec*( + draw: PXftDraw, + color: PXftColor, + chars: PXftCharFontSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawGlyphSpec*( + draw: PXftDraw, + color: PXftColor, + pub: PXftFont, + glyphs: PXftGlyphSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawGlyphFontSpec*( + draw: PXftDraw, + color: PXftColor, + glyphs: PXftGlyphFontSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawRect*( + draw: PXftDraw, + color: PXftColor, + x: cint, + y: cint, + width: cuint, + height: cuint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawSetClip*( + draw: PXftDraw, + r: Region +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawSetClipRectangles*( + draw: PXftDraw, + xOrigin: cint, + yOrigin: cint, + rects: PXRectangle, + n: cint +): XBool {.cdecl, dynlib: xftLib, importc.} + +proc XftDrawSetSubwindowMode*( + draw: PXftDraw, + mode: cint +) {.cdecl, dynlib: xftLib, importc.} + +# xftextent.c +proc XftGlyphExtents*( + display: PDisplay, + pub: PXftFont, + glyphs: PFT_UInt, + nglyphs: cint, + extends: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextExtents8*( + display: PDisplay, + pub: PXftFont, + str: PFcChar8, + len: cint, + extents: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextExtents16*( + display: PDisplay, + pub: PXftFont, + str: PFcChar16, + len: cint, + extents: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextExtents32*( + display: PDisplay, + pub: PXftFont, + str: PFcChar32, + len: cint, + extents: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextExtentsUtf8*( + display: PDisplay, + pub: PXftFont, + str: PFcChar8, + len: cint, + extents: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextExtentsUtf16*( + display: PDisplay, + pub: PXftFont, + str: PFcChar8, + endian: FcEndian, + len: cint, + extents: PXGlyphInfo +) {.cdecl, dynlib: xftLib, importc.} + +# xftfont.c +proc XftFontMatch*( + display: PDisplay, + screen: cint, + pattern: PFcPattern, + result: PFcResult +): PFcPattern {.cdecl, dynlib: xftLib, importc.} + +# Expects display to be nil as an argument +proc XftFontOpen*( + display: PDisplay, + screen: cint +): PXftFont {.cdecl, dynlib: xftLib, importc, varargs.} + +proc XftFontOpenName*( + display: PDisplay, + screen: cint, + name: cstring +): PXftFont {.cdecl, dynlib: xftLib, importc.} + +proc XftFontOpenXlfd*( + display: PDisplay, + screen: cint, + xlfd: cstring +): PXftFont {.cdecl, dynlib: xftLib, importc.} + +# xftfreetype.c +proc XftLockFace*( + pub: PXftFont +): FT_Face {.cdecl, dynlib: xftLib, importc.} + +proc XftUnlockFace*( + pub: PXftFont +) {.cdecl, dynlib: xftLib, importc.} + +proc XftFontInfoCreate*( + display: PDisplay, + pattern: PFcPattern +): PXftFontInfo {.cdecl, dynlib: xftLib, importc.} + +proc XftFontInfoDestroy*( + display: PDisplay, + fi: PXftFontInfo +) {.cdecl, dynlib: xftLib, importc.} + +proc XftFontInfoHash*( + fi: PXftFontInfo +): PFcChar32 {.cdecl, dynlib: xftLib, importc.} + +proc XftFontInfoEqual*( + a: PXftFontInfo, + b: PXftFontInfo +): FcBool {.cdecl, dynlib: xftLib, importc.} + +proc XftFontOpenInfo*( + display: PDisplay, + pattern: PFcPattern, + fi: PXftFontInfo +): PXftFont {.cdecl, dynlib: xftLib, importc.} + +proc XftFontOpenPattern*( + display: PDisplay, + pattern: PFcPattern +): PXftFont {.cdecl, dynlib: xftLib, importc.} + +proc XftFontCopy*( + display: PDisplay, + pub: PXftFont +): PXftFont {.cdecl, dynlib: xftLib, importc.} + +proc XftFontClose*( + display: PDisplay, + pub: PXftFont +) {.cdecl, dynlib: xftLib, importc.} + +proc XftInitFtLibrary*(): FcBool {.cdecl, dynlib: xftLib, importc.} + +# xftglyphs.c +proc XftFontLoadGlyphs*( + display: PDisplay, + pub: PXftFont, + need_bitmaps: FcBool, + glyphs: PFT_UInt, + nglyph: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftFontUnloadGlyphs*( + display: PDisplay, + pub: PXftFont, + glyphs: PFT_UInt, + nglyph: cint +) {.cdecl, dynlib: xftLib, importc.} + +const XFT_NMISSING* = 256 + +proc XftFontCheckGlyph*( + display: PDisplay, + pub: PXftFont, + need_bitmaps: FcBool, + glyph: FT_UInt, + missing: PFT_UInt, + nmissing: cint +): FcBool {.cdecl, dynlib: xftLib, importc.} + +proc XftCharExists*( + display: PDisplay, + pub: PXftFont, + ucs4: FcChar32 +): FcBool {.cdecl, dynlib: xftLib, importc.} + +proc XftCharIndex*( + display: PDisplay, + pub: PXftFont, + ucs4: FcChar32 +): FT_UInt {.cdecl, dynlib: xftLib, importc.} + +# xftinit.c +proc XftInit*( + config: cstring +): FcBool {.cdecl, dynlib: xftLib, importc.} + +proc XftGetVersion*(): cint {.cdecl, dynlib: xftLib, importc.} + +# xftlist.c +# Expects display to be nil as an argument +proc XftListFonts*( + display: PDisplay, + screen: cint +): PFcFontSet {.cdecl, dynlib: xftLib, importc, varargs.} + +# xftname.c +proc XftNameParse*( + name: cstring +): PFcPattern {.cdecl, dynlib: xftLib, importc.} + +# xftrender.c +proc XftGlyphRender*(display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + glyphs: PFT_UInt, + nglyphs: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftGlyphSpecRender*(display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + glyphs: PXftGlyphSpec, + nglyphs: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftCharSpecRender*(display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + chars: PXftCharSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftGlyphFontSpecRender*(display: PDisplay, + op: cint, + src: Picture, + dst: Picture, + srcx: cint, + srcy: cint, + glyphs: PXftGlyphFontSpec, + nglyphs: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftCharFontSpecRender*(display: PDisplay, + op: cint, + src: Picture, + dst: Picture, + srcx: cint, + srcy: cint, + chars: PXftCharFontSpec, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender8*(display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender16*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar16, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender16BE*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender16LE*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender32*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar32, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender32BE*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRender32LE*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRenderUtf8*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +proc XftTextRenderUtf16*( + display: PDisplay, + op: cint, + src: Picture, + pub: PXftFont, + dst: Picture, + srcx: cint, + srcy: cint, + x: cint, + y: cint, + str: PFcChar8, + endian: FcEndian, + len: cint +) {.cdecl, dynlib: xftLib, importc.} + +# xftxlfd.c +proc XftXlfdParse8*( + xlfd_orig: cstring, + ignore_scalable: XBool, + complete: XBool +): PFcPattern {.cdecl, dynlib: xftLib, importc.} + diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xi.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xi.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,311 @@ +# +# $Xorg: XI.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ +# +#************************************************************ +# +#Copyright 1989, 1998 The Open Group +# +#Permission to use, copy, modify, distribute, and sell this software and its +#documentation for any purpose is hereby granted without fee, provided that +#the above copyright notice appear in all copies and that both that +#copyright notice and this permission notice appear in supporting +#documentation. +# +#The above copyright notice and this permission notice shall be included in +#all copies or substantial portions of the Software. +# +#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +#OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +#AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +#CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of The Open Group shall not be +#used in advertising or otherwise to promote the sale, use or other dealings +#in this Software without prior written authorization from The Open Group. +# +#Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the name of Hewlett-Packard not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#********************************************************/ +# $XFree86: xc/include/extensions/XI.h,v 1.5 2001/12/14 19:53:28 dawes Exp $ +# +# Definitions used by the server, library and client +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Histroy: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and chnaged it to +# "reocrd" only. +# 2004/10/07 - Removed the "uses X;" line. The unit does not need it. +# 2004/10/03 - Conversion from C header to Pascal unit. +# + +const + libXi* = "libXi.so(|.6)" + +const + sz_xGetExtensionVersionReq* = 8 + sz_xGetExtensionVersionReply* = 32 + sz_xListInputDevicesReq* = 4 + sz_xListInputDevicesReply* = 32 + sz_xOpenDeviceReq* = 8 + sz_xOpenDeviceReply* = 32 + sz_xCloseDeviceReq* = 8 + sz_xSetDeviceModeReq* = 8 + sz_xSetDeviceModeReply* = 32 + sz_xSelectExtensionEventReq* = 12 + sz_xGetSelectedExtensionEventsReq* = 8 + sz_xGetSelectedExtensionEventsReply* = 32 + sz_xChangeDeviceDontPropagateListReq* = 12 + sz_xGetDeviceDontPropagateListReq* = 8 + sz_xGetDeviceDontPropagateListReply* = 32 + sz_xGetDeviceMotionEventsReq* = 16 + sz_xGetDeviceMotionEventsReply* = 32 + sz_xChangeKeyboardDeviceReq* = 8 + sz_xChangeKeyboardDeviceReply* = 32 + sz_xChangePointerDeviceReq* = 8 + sz_xChangePointerDeviceReply* = 32 + sz_xGrabDeviceReq* = 20 + sz_xGrabDeviceReply* = 32 + sz_xUngrabDeviceReq* = 12 + sz_xGrabDeviceKeyReq* = 20 + sz_xGrabDeviceKeyReply* = 32 + sz_xUngrabDeviceKeyReq* = 16 + sz_xGrabDeviceButtonReq* = 20 + sz_xGrabDeviceButtonReply* = 32 + sz_xUngrabDeviceButtonReq* = 16 + sz_xAllowDeviceEventsReq* = 12 + sz_xGetDeviceFocusReq* = 8 + sz_xGetDeviceFocusReply* = 32 + sz_xSetDeviceFocusReq* = 16 + sz_xGetFeedbackControlReq* = 8 + sz_xGetFeedbackControlReply* = 32 + sz_xChangeFeedbackControlReq* = 12 + sz_xGetDeviceKeyMappingReq* = 8 + sz_xGetDeviceKeyMappingReply* = 32 + sz_xChangeDeviceKeyMappingReq* = 8 + sz_xGetDeviceModifierMappingReq* = 8 + sz_xSetDeviceModifierMappingReq* = 8 + sz_xSetDeviceModifierMappingReply* = 32 + sz_xGetDeviceButtonMappingReq* = 8 + sz_xGetDeviceButtonMappingReply* = 32 + sz_xSetDeviceButtonMappingReq* = 8 + sz_xSetDeviceButtonMappingReply* = 32 + sz_xQueryDeviceStateReq* = 8 + sz_xQueryDeviceStateReply* = 32 + sz_xSendExtensionEventReq* = 16 + sz_xDeviceBellReq* = 8 + sz_xSetDeviceValuatorsReq* = 8 + sz_xSetDeviceValuatorsReply* = 32 + sz_xGetDeviceControlReq* = 8 + sz_xGetDeviceControlReply* = 32 + sz_xChangeDeviceControlReq* = 8 + sz_xChangeDeviceControlReply* = 32 + +const + INAME* = "XInputExtension" + +const + XI_KEYBOARD* = "KEYBOARD" + XI_MOUSE* = "MOUSE" + XI_TABLET* = "TABLET" + XI_TOUCHSCREEN* = "TOUCHSCREEN" + XI_TOUCHPAD* = "TOUCHPAD" + XI_BARCODE* = "BARCODE" + XI_BUTTONBOX* = "BUTTONBOX" + XI_KNOB_BOX* = "KNOB_BOX" + XI_ONE_KNOB* = "ONE_KNOB" + XI_NINE_KNOB* = "NINE_KNOB" + XI_TRACKBALL* = "TRACKBALL" + XI_QUADRATURE* = "QUADRATURE" + XI_ID_MODULE* = "ID_MODULE" + XI_SPACEBALL* = "SPACEBALL" + XI_DATAGLOVE* = "DATAGLOVE" + XI_EYETRACKER* = "EYETRACKER" + XI_CURSORKEYS* = "CURSORKEYS" + XI_FOOTMOUSE* = "FOOTMOUSE" + +const + Dont_Check* = 0 + XInput_Initial_Release* = 1 + XInput_Add_XDeviceBell* = 2 + XInput_Add_XSetDeviceValuators* = 3 + XInput_Add_XChangeDeviceControl* = 4 + +const + XI_Absent* = 0 + XI_Present* = 1 + +const + XI_Initial_Release_Major* = 1 + XI_Initial_Release_Minor* = 0 + +const + XI_Add_XDeviceBell_Major* = 1 + XI_Add_XDeviceBell_Minor* = 1 + +const + XI_Add_XSetDeviceValuators_Major* = 1 + XI_Add_XSetDeviceValuators_Minor* = 2 + +const + XI_Add_XChangeDeviceControl_Major* = 1 + XI_Add_XChangeDeviceControl_Minor* = 3 + +const + DEVICE_RESOLUTION* = 1 + +const + NoSuchExtension* = 1 + +const + COUNT* = 0 + CREATE* = 1 + +const + NewPointer* = 0 + NewKeyboard* = 1 + +const + XPOINTER* = 0 + XKEYBOARD* = 1 + +const + UseXKeyboard* = 0x000000FF + +const + IsXPointer* = 0 + IsXKeyboard* = 1 + IsXExtensionDevice* = 2 + +const + AsyncThisDevice* = 0 + SyncThisDevice* = 1 + ReplayThisDevice* = 2 + AsyncOtherDevices* = 3 + AsyncAll* = 4 + SyncAll* = 5 + +const + FollowKeyboard* = 3 + RevertToFollowKeyboard* = 3 + +const + DvAccelNum* = int(1) shl 0 + DvAccelDenom* = int(1) shl 1 + DvThreshold* = int(1) shl 2 + +const + DvKeyClickPercent* = int(1) shl 0 + DvPercent* = int(1) shl 1 + DvPitch* = int(1) shl 2 + DvDuration* = int(1) shl 3 + DvLed* = int(1) shl 4 + DvLedMode* = int(1) shl 5 + DvKey* = int(1) shl 6 + DvAutoRepeatMode* = 1 shl 7 + +const + DvString* = int(1) shl 0 + +const + DvInteger* = int(1) shl 0 + +const + DeviceMode* = int(1) shl 0 + Relative* = 0 + Absolute* = 1 # Merged from Metrolink tree for XINPUT stuff + TS_Raw* = 57 + TS_Scaled* = 58 + SendCoreEvents* = 59 + DontSendCoreEvents* = 60 # End of merged section + +const + ProximityState* = int(1) shl 1 + InProximity* = int(0) shl 1 + OutOfProximity* = int(1) shl 1 + +const + AddToList* = 0 + DeleteFromList* = 1 + +const + KeyClass* = 0 + ButtonClass* = 1 + ValuatorClass* = 2 + FeedbackClass* = 3 + ProximityClass* = 4 + FocusClass* = 5 + OtherClass* = 6 + +const + KbdFeedbackClass* = 0 + PtrFeedbackClass* = 1 + StringFeedbackClass* = 2 + IntegerFeedbackClass* = 3 + LedFeedbackClass* = 4 + BellFeedbackClass* = 5 + +const + devicePointerMotionHint* = 0 + deviceButton1Motion* = 1 + deviceButton2Motion* = 2 + deviceButton3Motion* = 3 + deviceButton4Motion* = 4 + deviceButton5Motion* = 5 + deviceButtonMotion* = 6 + deviceButtonGrab* = 7 + deviceOwnerGrabButton* = 8 + noExtensionEvent* = 9 + +const + XI_BadDevice* = 0 + XI_BadEvent* = 1 + XI_BadMode* = 2 + XI_DeviceBusy* = 3 + XI_BadClass* = 4 # Make XEventClass be a CARD32 for 64 bit servers. Don't affect client + # definition of XEventClass since that would be a library interface change. + # See the top of X.h for more _XSERVER64 magic. + # + +when defined(XSERVER64): + type + XEventClass* = CARD32 +else: + type + XEventClass* = int32 +#****************************************************************** +# * +# * Extension version structure. +# * +# + +type + PXExtensionVersion* = ptr XExtensionVersion + XExtensionVersion*{.final.} = object + present*: int16 + major_version*: int16 + minor_version*: int16 + +{.deprecated: [TXExtensionVersion: XExtensionVersion].} + +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xi2.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xi2.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,291 @@ +# ************************************* +# Generated from +# ************************************* + +from xi import libXi +export libXi + +const + XInput_2_0* = 7 + +## DO NOT ADD TO THIS LIST. These are libXi-specific defines. +## See commit libXi-1.4.2-21-ge8531dd + +const + XI_2_Major* = 2 + XI_2_Minor* = 3 + +## Property event flags + +const + XIPropertyDeleted* = 0 + XIPropertyCreated* = 1 + XIPropertyModified* = 2 + +## Property modes + +const + XIPropModeReplace* = 0 + XIPropModePrepend* = 1 + XIPropModeAppend* = 2 + +## Special property type used for XIGetProperty + +const + XIAnyPropertyType* = 0 + +## Enter/Leave and Focus In/Out modes + +const + XINotifyNormal* = 0 + XINotifyGrab* = 1 + XINotifyUngrab* = 2 + XINotifyWhileGrabbed* = 3 + XINotifyPassiveGrab* = 4 + XINotifyPassiveUngrab* = 5 + +## Enter/Leave and focus In/out detail + +const + XINotifyAncestor* = 0 + XINotifyVirtual* = 1 + XINotifyInferior* = 2 + XINotifyNonlinear* = 3 + XINotifyNonlinearVirtual* = 4 + XINotifyPointer* = 5 + XINotifyPointerRoot* = 6 + XINotifyDetailNone* = 7 + +## Grab modes + +const + XIGrabModeSync* = 0 + XIGrabModeAsync* = 1 + XIGrabModeTouch* = 2 + +## Grab reply status codes + +const + XIGrabSuccess* = 0 + XIAlreadyGrabbed* = 1 + XIGrabInvalidTime* = 2 + XIGrabNotViewable* = 3 + XIGrabFrozen* = 4 + +## Grab owner events values + +const + XIOwnerEvents* = true + XINoOwnerEvents* = false + +## Passive grab types + +const + XIGrabtypeButton* = 0 + XIGrabtypeKeycode* = 1 + XIGrabtypeEnter* = 2 + XIGrabtypeFocusIn* = 3 + XIGrabtypeTouchBegin* = 4 + +## Passive grab modifier + +const + XIAnyModifier* = (1 shl 31) + XIAnyButton* = 0 + XIAnyKeycode* = 0 + +## XIAllowEvents event-modes + +const + XIAsyncDevice* = 0 + XISyncDevice* = 1 + XIReplayDevice* = 2 + XIAsyncPairedDevice* = 3 + XIAsyncPair* = 4 + XISyncPair* = 5 + XIAcceptTouch* = 6 + XIRejectTouch* = 7 + +## DeviceChangedEvent change reasons + +const + XISlaveSwitch* = 1 + XIDeviceChange* = 2 + +## Hierarchy flags + +const + XIMasterAdded* = (1 shl 0) + XIMasterRemoved* = (1 shl 1) + XISlaveAdded* = (1 shl 2) + XISlaveRemoved* = (1 shl 3) + XISlaveAttached* = (1 shl 4) + XISlaveDetached* = (1 shl 5) + XIDeviceEnabled* = (1 shl 6) + XIDeviceDisabled* = (1 shl 7) + +## ChangeHierarchy constants + +const + XIAddMaster* = 1 + XIRemoveMaster* = 2 + XIAttachSlave* = 3 + XIDetachSlave* = 4 + XIAttachToMaster* = 1 + XIFloating* = 2 + +## Valuator modes + +const + XIModeRelative* = 0 + XIModeAbsolute* = 1 + +## Device types + +const + XIMasterPointer* = 1 + XIMasterKeyboard* = 2 + XISlavePointer* = 3 + XISlaveKeyboard* = 4 + XIFloatingSlave* = 5 + +## Device classes: classes that are not identical to Xi 1.x classes must be +## numbered starting from 8. + +const + XIKeyClass* = 0 + XIButtonClass* = 1 + XIValuatorClass* = 2 + XIScrollClass* = 3 + XITouchClass* = 8 + +## Scroll class types + +const + XIScrollTypeVertical* = 1 + XIScrollTypeHorizontal* = 2 + +## Scroll class flags + +const + XIScrollFlagNoEmulation* = (1 shl 0) + XIScrollFlagPreferred* = (1 shl 1) + +## Device event flags (common) +## Device event flags (key events only) + +const + XIKeyRepeat* = (1 shl 16) + +## Device event flags (pointer events only) + +const + XIPointerEmulated* = (1 shl 16) + +## Device event flags (touch events only) + +const + XITouchPendingEnd* = (1 shl 16) + XITouchEmulatingPointer* = (1 shl 17) + +## Barrier event flags + +const + XIBarrierPointerReleased* = (1 shl 0) + XIBarrierDeviceIsGrabbed* = (1 shl 1) + +## Touch modes + +const + XIDirectTouch* = 1 + XIDependentTouch* = 2 + +## XI2 event mask macros +type XIMask = ptr UncheckedArray[uint8] + +template XISetMask*(mask: pointer, event: untyped): untyped = + ((cast[XIMask]((mask)))[(event) shr 3] = (cast[XIMask]((mask)))[ + (event) shr 3] or (1 shl ((event) and 7))) + +template XIClearMask*(mask: pointer, event: untyped): untyped = + ((cast[XIMask]((mask)))[(event) shr 3] = (cast[XIMask]((mask)))[ + (event) shr 3] and not (1 shl ((event) and 7))) + +template XIMaskIsSet*(mask: pointer, event: untyped): untyped = + ((cast[XIMask]((mask)))[(event) shr 3].int and (1 shl ((event) and 7))) + +template XIMaskLen*(event: untyped): untyped = + (((event) shr 3) + 1) + +## Fake device ID's for event selection + +const + XIAllDevices* = 0 + XIAllMasterDevices* = 1 + +## Event types + +const + XI_DeviceChanged* = 1 + XI_KeyPress* = 2 + XI_KeyRelease* = 3 + XI_ButtonPress* = 4 + XI_ButtonRelease* = 5 + XI_Motion* = 6 + XI_Enter* = 7 + XI_Leave* = 8 + XI_FocusIn* = 9 + XI_FocusOut* = 10 + XI_HierarchyChanged* = 11 + XI_PropertyEvent* = 12 + XI_RawKeyPress* = 13 + XI_RawKeyRelease* = 14 + XI_RawButtonPress* = 15 + XI_RawButtonRelease* = 16 + XI_RawMotion* = 17 + XI_TouchBegin* = 18 + XI_TouchUpdate* = 19 + XI_TouchEnd* = 20 + XI_TouchOwnership* = 21 + XI_RawTouchBegin* = 22 + XI_RawTouchUpdate* = 23 + XI_RawTouchEnd* = 24 + XI_BarrierHit* = 25 + XI_BarrierLeave* = 26 + XI_LASTEVENT* = XI_BarrierLeave + +## NOTE: XI2LASTEVENT in xserver/include/inputstr.h must be the same value +## as XI_LASTEVENT if the server is supposed to handle masks etc. for this +## type of event. +## Event masks. +## Note: the protocol spec defines a mask to be of (1 << type). Clients are +## free to create masks by bitshifting instead of using these defines. +## + +const + XI_DeviceChangedMask* = (1 shl XI_DeviceChanged) + XI_KeyPressMask* = (1 shl XI_KeyPress) + XI_KeyReleaseMask* = (1 shl XI_KeyRelease) + XI_ButtonPressMask* = (1 shl XI_ButtonPress) + XI_ButtonReleaseMask* = (1 shl XI_ButtonRelease) + XI_MotionMask* = (1 shl XI_Motion) + XI_EnterMask* = (1 shl XI_Enter) + XI_LeaveMask* = (1 shl XI_Leave) + XI_FocusInMask* = (1 shl XI_FocusIn) + XI_FocusOutMask* = (1 shl XI_FocusOut) + XI_HierarchyChangedMask* = (1 shl XI_HierarchyChanged) + XI_PropertyEventMask* = (1 shl XI_PropertyEvent) + XI_RawKeyPressMask* = (1 shl XI_RawKeyPress) + XI_RawKeyReleaseMask* = (1 shl XI_RawKeyRelease) + XI_RawButtonPressMask* = (1 shl XI_RawButtonPress) + XI_RawButtonReleaseMask* = (1 shl XI_RawButtonRelease) + XI_RawMotionMask* = (1 shl XI_RawMotion) + XI_TouchBeginMask* = (1 shl XI_TouchBegin) + XI_TouchEndMask* = (1 shl XI_TouchEnd) + XI_TouchOwnershipChangedMask* = (1 shl XI_TouchOwnership) + XI_TouchUpdateMask* = (1 shl XI_TouchUpdate) + XI_RawTouchBeginMask* = (1 shl XI_RawTouchBegin) + XI_RawTouchEndMask* = (1 shl XI_RawTouchEnd) + XI_RawTouchUpdateMask* = (1 shl XI_RawTouchUpdate) + XI_BarrierHitMask* = (1 shl XI_BarrierHit) + XI_BarrierLeaveMask* = (1 shl XI_BarrierLeave) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xinerama.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xinerama.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,26 @@ +# Converted from X11/Xinerama.h +import + xlib + +const + xineramaLib = "libXinerama.so" + +type + PXineramaScreenInfo* = ptr XineramaScreenInfo + XineramaScreenInfo*{.final.} = object + screen_number*: cint + x_org*: int16 + y_org*: int16 + width*: int16 + height*: int16 + +{.deprecated: [TXineramaScreenInfo: XineramaScreenInfo].} + +proc XineramaQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): XBool{. + cdecl, dynlib: xineramaLib, importc.} +proc XineramaQueryVersion*(dpy: PDisplay, major: Pcint, minor: Pcint): Status{. + cdecl, dynlib: xineramaLib, importc.} +proc XineramaIsActive*(dpy: PDisplay): XBool{.cdecl, dynlib: xineramaLib, importc.} +proc XineramaQueryScreens*(dpy: PDisplay, number: Pcint): PXineramaScreenInfo{. + cdecl, dynlib: xineramaLib, importc.} + diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xinput.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xinput.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,793 @@ +import x, xlib, xi + +const xNeedWidePrototypes {.booldefine.} = defined(posix) + +const + deviceKeyPress* = 0 + deviceKeyRelease* = 1 + deviceButtonPress* = 0 + deviceButtonRelease* = 1 + deviceMotionNotify* = 0 + deviceFocusIn* = 0 + deviceFocusOut* = 1 + proximityIn* = 0 + proximityOut* = 1 + deviceStateNotify* = 0 + deviceMappingNotify* = 1 + changeDeviceNotify* = 2 + + propertyNotify* = 6 + +template FindTypeAndClass*(d, `type`, class, classid, offset: untyped) = + var i: cint + var ip: PXInputClassInfo + `type` = 0 + class = 0 + i = 0 + ip = (cast[PXDevice](d)).classes + while i < (cast[PXDevice](d)).num_classes: + if ip.input_class == classid: + `type` = ip.event_type_base + offset + class = (cast[PXDevice](d)).device_id shl 8 or `type` + inc(i) + inc(ip) + +template DeviceKeyPress*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, KeyClass, deviceKeyPress) + +template DeviceKeyRelease*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, KeyClass, deviceKeyRelease) + +template DeviceButtonPress*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, ButtonClass, deviceButtonPress) + +template DeviceButtonRelease*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, ButtonClass, deviceButtonRelease) + +template DeviceMotionNotify*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, ValuatorClass, deviceMotionNotify) + +template DeviceFocusIn*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, FocusClass, deviceFocusIn) + +template DeviceFocusOut*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, FocusClass, deviceFocusOut) + +template ProximityIn*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, ProximityClass, proximityIn) + +template ProximityOut*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, ProximityClass, proximityOut) + +template DeviceStateNotify*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, OtherClass, deviceStateNotify) + +template DeviceMappingNotify*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, OtherClass, deviceMappingNotify) + +template ChangeDeviceNotify*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, OtherClass, changeDeviceNotify) + +template DevicePropertyNotify*(d, `type`, class: untyped): untyped = + FindTypeAndClass(d, `type`, class, OtherClass, propertyNotify) + +template DevicePointerMotionHint*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or devicePointerMotionHint + +template DeviceButton1Motion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButton1Motion + +template DeviceButton2Motion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButton2Motion + +template DeviceButton3Motion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButton3Motion + +template DeviceButton4Motion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButton4Motion + +template DeviceButton5Motion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButton5Motion + +template DeviceButtonMotion*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButtonMotion + +template DeviceOwnerGrabButton*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceOwnerGrabButton + +template DeviceButtonPressGrab*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or deviceButtonGrab + +template NoExtensionEvent*(d, `type`, class: untyped) = + class = (cast[PXDevice](d)).device_id shl 8 or noExtensionEvent + +template DevicePresence*(dpy, `type`, class: untyped) = + `type` = XiGetDevicePresenceNotifyEvent(dpy) + class = (0x00010000 or devicePresence) + +## Errors + +template BadDevice*(dpy, error: untyped): untyped = + xibaddevice(dpy, addr(error)) + +template BadClass*(dpy, error: untyped): untyped = + xibadclass(dpy, addr(error)) + +template BadEvent*(dpy, error: untyped): untyped = + xibadevent(dpy, addr(error)) + +template BadMode*(dpy, error: untyped): untyped = + xibadmode(dpy, addr(error)) + +template DeviceBusy*(dpy, error: untyped): untyped = + xidevicebusy(dpy, addr(error)) + +type + PXDeviceKeyEvent* = ptr XDeviceKeyEvent + XDeviceKeyEvent* {.final.} = object + ## DeviceKey events. These events are sent by input devices that + ## support input class Keys. + ## The location of the X pointer is reported in the coordinate + ## fields of the x,y and x_root,y_root fields. + `type`*: cint ## of event + serial*: culong ## # of last request processed + send_event*: XBool ## true if from SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## "event" window reported relative to + deviceid*: XID + root*: Window ## root window event occured on + subwindow*: Window ## child window + time*: Time ## milliseconds + x*: cint + y*: cint ## x, y coordinates in event window + x_root*: cint ## coordinates relative to root + y_root*: cint ## coordinates relative to root + state*: cuint ## key or button mask + keycode*: cuint ## detail + same_screen*: XBool ## same screen flag + device_state*: cuint ## device key or button mask + axes_count*: cuchar + first_axis*: cuchar + axis_data*: array[6, cint] + + PXDeviceKeyPressedEvent* = PXDeviceKeyEvent + XDeviceKeyPressedEvent* = XDeviceKeyEvent + + PXDeviceKeyReleasedEvent* = PXDeviceKeyEvent + XDeviceKeyReleasedEvent* = XDeviceKeyEvent + + PXDeviceButtonEvent* = ptr XDeviceButtonEvent + XDeviceButtonEvent* {.final.} = object + ## DeviceButton events. These events are sent by extension devices + ## that support input class Buttons. + `type`*: cint ## of event + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## "event" window reported relative to + deviceid*: XID + root*: Window ## root window that the event occured on + subwindow*: Window ## child window + time*: Time ## milliseconds + x*: cint + y*: cint ## x, y coordinates in event window + x_root*: cint ## coordinates relative to root + y_root*: cint ## coordinates relative to root + state*: cuint ## key or button mask + button*: cuint ## detail + same_screen*: XBool ## same screen flag + device_state*: cuint ## device key or button mask + axes_count*: cuchar + first_axis*: cuchar + axis_data*: array[6, cint] + + PXDeviceButtonPressedEvent* = PXDeviceButtonEvent + XDeviceButtonPressedEvent* = XDeviceButtonEvent + + PXDeviceButtonReleasedEvent* = PXDeviceButtonEvent + XDeviceButtonReleasedEvent* = XDeviceButtonEvent + + PXDeviceMotionEvent* = ptr XDeviceMotionEvent + XDeviceMotionEvent* {.final.} = object + ## DeviceMotionNotify event. These events are sent by extension devices + ## that support input class Valuators. + `type`*: cint ## of event + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## "event" window reported relative to + deviceid*: XID + root*: Window ## root window that the event occured on + subwindow*: Window ## child window + time*: Time ## milliseconds + x*: cint + y*: cint ## x, y coordinates in event window + x_root*: cint ## coordinates relative to root + y_root*: cint ## coordinates relative to root + state*: cuint ## key or button mask + is_hint*: char ## detail + same_screen*: XBool ## same screen flag + device_state*: cuint ## device key or button mask + axes_count*: cuchar + first_axis*: cuchar + axis_data*: array[6, cint] + + PXDeviceFocusChangeEvent* = ptr XDeviceFocusChangeEvent + XDeviceFocusChangeEvent* {.final.} = object + ## DeviceFocusChange events. These events are sent when the focus + ## of an extension device that can be focused is changed. + `type`*: cint ## of event + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## "event" window reported relative to + deviceid*: XID + mode*: cint ## NotifyNormal, NotifyGrab, NotifyUngrab + detail*: cint ## + ## NotifyAncestor, NotifyVirtual, NotifyInferior, + ## NotifyNonLinear,NotifyNonLinearVirtual, NotifyPointer, + ## NotifyPointerRoot, NotifyDetailNone + ## + time*: Time + + PXDeviceFocusInEvent* = PXDeviceFocusChangeEvent + XDeviceFocusInEvent* = XDeviceFocusChangeEvent + + PXDeviceFocusOutEvent* = PXDeviceFocusChangeEvent + XDeviceFocusOutEvent* = XDeviceFocusChangeEvent + + PXProximityNotifyEvent* = ptr XProximityNotifyEvent + XProximityNotifyEvent* {.final.} = object + ## ProximityNotify events. These events are sent by those absolute + ## positioning devices that are capable of generating proximity information. + `type`*: cint ## ProximityIn or ProximityOut + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window + deviceid*: XID + root*: Window + subwindow*: Window + time*: Time + x*: cint + y*: cint + x_root*: cint + y_root*: cint + state*: cuint + same_screen*: XBool + device_state*: cuint ## device key or button mask + axes_count*: cuchar + first_axis*: cuchar + axis_data*: array[6, cint] + + PXProximityInEvent* = PXProximityNotifyEvent + XProximityInEvent* = XProximityNotifyEvent + + PXProximityOutEvent* = PXProximityNotifyEvent + XProximityOutEvent* = XProximityNotifyEvent + + PXInputClass* = ptr XInputClass + XInputClass* {.final.} = object + class*: cuchar + length*: cuchar + + PXDeviceStateNotifyEvent* = ptr XDeviceStateNotifyEvent + XDeviceStateNotifyEvent* {.final.} = object + ## DeviceStateNotify events are generated on EnterWindow and FocusIn + ## for those clients who have selected DeviceState. + `type`*: cint + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window + deviceid*: XID + time*: Time + num_classes*: cint + data*: array[64, char] + + PXValuatorStatus* = ptr XValuatorStatus + XValuatorStatus* {.final.} = object + class*: cuchar + length*: cuchar + num_valuators*: cuchar + mode*: cuchar + valuators*: array[6, cint] + + PXKeyStatus* = ptr XKeyStatus + XKeyStatus* {.final.} = object + class*: cuchar + length*: cuchar + num_keys*: cshort + keys*: array[32, char] + + PXButtonStatus* = ptr XButtonStatus + XButtonStatus* {.final.} = object + class*: cuchar + length*: cuchar + num_buttons*: cshort + buttons*: array[32, char] + + PXDeviceMappingEvent* = ptr XDeviceMappingEvent + XDeviceMappingEvent* {.final.} = object + ## DeviceMappingNotify event. This event is sent when the key mapping, + ## modifier mapping, or button mapping of an extension device is changed. + `type`*: cint + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## unused + deviceid*: XID + time*: Time + request*: cint ## one of MappingModifier, MappingKeyboard, + ## MappingPointer + first_keycode*: cint ## first keycode + count*: cint ## defines range of change w. first_keycode + + PXChangeDeviceNotifyEvent* = ptr XChangeDeviceNotifyEvent + XChangeDeviceNotifyEvent* {.final.} = object + ## ChangeDeviceNotify event. This event is sent when an + ## XChangeKeyboard or XChangePointer request is made. + `type`*: cint + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## unused + deviceid*: XID + time*: Time + request*: cint ## NewPointer or NewKeyboard + + PXDevicePresenceNotifyEvent* = ptr XDevicePresenceNotifyEvent + XDevicePresenceNotifyEvent* {.final.} = object + ## DevicePresenceNotify event. This event is sent when the list of + ## input devices changes, in which case devchange will be false, and + ## no information about the change will be contained in the event; + ## the client should use XListInputDevices() to learn what has changed. + ## + ## If devchange is true, an attribute that the server believes is + ## important has changed on a device, and the client should use + ## XGetDeviceControl to examine the device. If control is non-zero, + ## then that control has changed meaningfully. + `type`*: cint + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## unused + time*: Time + devchange*: XBool + deviceid*: XID + control*: XID + + PXDevicePropertyNotifyEvent* = ptr XDevicePropertyNotifyEvent + XDevicePropertyNotifyEvent* {.final.} = object + `type`*: cint + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + window*: Window ## unused + time*: Time + deviceid*: XID ## id of the device that changed + atom*: Atom ## the property that changed + state*: cint ## PropertyNewValue or PropertyDeleted + + PXFeedbackState* = ptr XFeedbackState + XFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + + PXKbdFeedbackState* = ptr XKbdFeedbackState + XKbdFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + click*: cint + percent*: cint + pitch*: cint + duration*: cint + led_mask*: cint + global_auto_repeat*: cint + auto_repeats*: array[32, char] + + PXPtrFeedbackState* = ptr XPtrFeedbackState + XPtrFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + accelNum*: cint + accelDenom*: cint + threshold*: cint + + PXIntegerFeedbackState* = ptr XIntegerFeedbackState + XIntegerFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + resolution*: cint + minVal*: cint + maxVal*: cint + + PXStringFeedbackState* = ptr XStringFeedbackState + XStringFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + max_symbols*: cint + num_syms_supported*: cint + syms_supported*: PKeySym + + PXBellFeedbackState* = ptr XBellFeedbackState + XBellFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + percent*: cint + pitch*: cint + duration*: cint + + PXLedFeedbackState* = ptr XLedFeedbackState + XLedFeedbackState* {.final.} = object + class*: XID + length*: cint + id*: XID + led_values*: cint + led_mask*: cint + + PXFeedbackControl* = ptr XFeedbackControl + XFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + + PXPtrFeedbackControl* = ptr XPtrFeedbackControl + XPtrFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + accelNum*: cint + accelDenom*: cint + threshold*: cint + + PXKbdFeedbackControl* = ptr XKbdFeedbackControl + XKbdFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + click*: cint + percent*: cint + pitch*: cint + duration*: cint + led_mask*: cint + led_value*: cint + key*: cint + auto_repeat_mode*: cint + + PXStringFeedbackControl* = ptr XStringFeedbackControl + XStringFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + num_keysyms*: cint + syms_to_display*: PKeySym + + PXIntegerFeedbackControl* = ptr XIntegerFeedbackControl + XIntegerFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + int_to_display*: cint + + PXBellFeedbackControl* = ptr XBellFeedbackControl + XBellFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + percent*: cint + pitch*: cint + duration*: cint + + PXLedFeedbackControl* = ptr XLedFeedbackControl + XLedFeedbackControl* {.final.} = object + class*: XID + length*: cint + id*: XID + led_mask*: cint + led_values*: cint + + PXDeviceControl* = ptr XDeviceControl + XDeviceControl* {.final.} = object + control*: XID + length*: cint + + PXDeviceResolutionControl* = ptr XDeviceResolutionControl + XDeviceResolutionControl* {.final.} = object + control*: XID + length*: cint + first_valuator*: cint + num_valuators*: cint + resolutions*: ptr cint + + PXDeviceResolutionState* = ptr XDeviceResolutionState + XDeviceResolutionState* {.final.} = object + control*: XID + length*: cint + num_valuators*: cint + resolutions*: ptr cint + min_resolutions*: ptr cint + max_resolutions*: ptr cint + + PXDeviceAbsCalibControl* = ptr XDeviceAbsCalibControl + XDeviceAbsCalibControl* {.final.} = object + control*: XID + length*: cint + min_x*: cint + max_x*: cint + min_y*: cint + max_y*: cint + flip_x*: cint + flip_y*: cint + rotation*: cint + button_threshold*: cint + + PXDeviceAbsCalibState* = PXDeviceAbsCalibControl + XDeviceAbsCalibState* = XDeviceAbsCalibControl + + PXDeviceAbsAreaControl* = ptr XDeviceAbsAreaControl + XDeviceAbsAreaControl* {.final.} = object + control*: XID + length*: cint + offset_x*: cint + offset_y*: cint + width*: cint + height*: cint + screen*: cint + following*: XID + + PXDeviceAbsAreaState* = PXDeviceAbsAreaControl + XDeviceAbsAreaState* = XDeviceAbsAreaControl + + PXDeviceCoreControl* = ptr XDeviceCoreControl + XDeviceCoreControl* {.final.} = object + control*: XID + length*: cint + status*: cint + + PXDeviceCoreState* = ptr XDeviceCoreState + XDeviceCoreState* {.final.} = object + control*: XID + length*: cint + status*: cint + iscore*: cint + + PXDeviceEnableControl* = ptr XDeviceEnableControl + XDeviceEnableControl* {.final.} = object + control*: XID + length*: cint + enable*: cint + + PXDeviceEnableState* = PXDeviceEnableControl + XDeviceEnableState* = XDeviceEnableControl + + PXAnyClassInfo* = ptr XAnyClassInfo + XAnyClassInfo* {.final.} = object + class*: XID + length*: cint + + PXDeviceInfo* = ptr XDeviceInfo + XDeviceInfo* {.final.} = object + id*: XID + `type`*: Atom + name*: cstring + num_classes*: cint + use*: cint + inputclassinfo*: PXAnyClassInfo + + PXKeyInfo* = ptr XKeyInfo + XKeyInfo* {.final.} = object + class*: XID + length*: cint + min_keycode*: cushort + max_keycode*: cushort + num_keys*: cushort + + PXButtonInfo* = ptr XButtonInfo + XButtonInfo* {.final.} = object + class*: XID + length*: cint + num_buttons*: cshort + + PXAxisInfo* = ptr XAxisInfo + XAxisInfo* {.final.} = object + resolution*: cint + min_value*: cint + max_value*: cint + + PXValuatorInfo* = ptr XValuatorInfo + XValuatorInfo* {.final.} = object + class*: XID + length*: cint + num_axes*: cuchar + mode*: cuchar + motion_buffer*: culong + axes*: PXAxisInfo + + PXInputClassInfo* = ptr XInputClassInfo + XInputClassInfo* {.final.} = object + input_class*: cuchar + event_type_base*: cuchar + + PXDevice* = ptr XDevice + XDevice* {.final.} = object + device_id*: XID + num_classes*: cint + classes*: PXInputClassInfo + + PXEventList* = ptr XEventList + XEventList* {.final.} = object + event_type*: XEventClass + device*: XID + + PXDeviceTimeCoord* = ptr XDeviceTimeCoord + XDeviceTimeCoord* {.final.} = object + time*: Time + data*: ptr cint + + PXDeviceState* = ptr XDeviceState + XDeviceState* {.final.} = object + device_id*: XID + num_classes*: cint + data*: PXInputClass + + PXValuatorState* = ptr XValuatorState + XValuatorState* {.final.} = object + class*: cuchar + length*: cuchar + num_valuators*: cuchar + mode*: cuchar + valuators*: ptr cint + + PXKeyState* = ptr XKeyState + XKeyState* {.final.} = object + class*: cuchar + length*: cuchar + num_keys*: cshort + keys*: array[32, char] + + PXButtonState* = ptr XButtonState + XButtonState* {.final.} = object + class*: cuchar + length*: cuchar + num_buttons*: cshort + buttons*: array[32, char] + +{.deprecated: [TXDeviceKeyEvent: XDeviceKeyEvent].} +{.deprecated: [TXDeviceKeyPressedEvent: XDeviceKeyPressedEvent].} +{.deprecated: [TXDeviceKeyReleasedEvent: XDeviceKeyReleasedEvent].} +{.deprecated: [TXDeviceButtonEvent: XDeviceButtonEvent].} +{.deprecated: [TXDeviceButtonPressedEvent: XDeviceButtonPressedEvent].} +{.deprecated: [TXDeviceButtonReleasedEvent: XDeviceButtonReleasedEvent].} +{.deprecated: [TXDeviceMotionEvent: XDeviceMotionEvent].} +{.deprecated: [TXDeviceFocusChangeEvent: XDeviceFocusChangeEvent].} +{.deprecated: [TXDeviceFocusInEvent: XDeviceFocusInEvent].} +{.deprecated: [TXDeviceFocusOutEvent: XDeviceFocusOutEvent].} +{.deprecated: [TXProximityNotifyEvent: XProximityNotifyEvent].} +{.deprecated: [TXProximityInEvent: XProximityInEvent].} +{.deprecated: [TXProximityOutEvent: XProximityOutEvent].} +{.deprecated: [TXInputClass: XInputClass].} +{.deprecated: [TXDeviceStateNotifyEvent: XDeviceStateNotifyEvent].} +{.deprecated: [TXValuatorStatus: XValuatorStatus].} +{.deprecated: [TXKeyStatus: XKeyStatus].} +{.deprecated: [TXButtonStatus: XButtonStatus].} +{.deprecated: [TXDeviceMappingEvent: XDeviceMappingEvent].} +{.deprecated: [TXChangeDeviceNotifyEvent: XChangeDeviceNotifyEvent].} +{.deprecated: [TXDevicePresenceNotifyEvent: XDevicePresenceNotifyEvent].} +{.deprecated: [TXDevicePropertyNotifyEvent: XDevicePropertyNotifyEvent].} +{.deprecated: [TXFeedbackState: XFeedbackState].} +{.deprecated: [TXKbdFeedbackState: XKbdFeedbackState].} +{.deprecated: [TXPtrFeedbackState: XPtrFeedbackState].} +{.deprecated: [TXIntegerFeedbackState: XIntegerFeedbackState].} +{.deprecated: [TXStringFeedbackState: XStringFeedbackState].} +{.deprecated: [TXBellFeedbackState: XBellFeedbackState].} +{.deprecated: [TXLedFeedbackState: XLedFeedbackState].} +{.deprecated: [TXFeedbackControl: XFeedbackControl].} +{.deprecated: [TXPtrFeedbackControl: XPtrFeedbackControl].} +{.deprecated: [TXKbdFeedbackControl: XKbdFeedbackControl].} +{.deprecated: [TXStringFeedbackControl: XStringFeedbackControl].} +{.deprecated: [TXIntegerFeedbackControl: XIntegerFeedbackControl].} +{.deprecated: [TXBellFeedbackControl: XBellFeedbackControl].} +{.deprecated: [TXLedFeedbackControl: XLedFeedbackControl].} +{.deprecated: [TXDeviceControl: XDeviceControl].} +{.deprecated: [TXDeviceResolutionControl: XDeviceResolutionControl].} +{.deprecated: [TXDeviceResolutionState: XDeviceResolutionState].} +{.deprecated: [TXDeviceAbsCalibControl: XDeviceAbsCalibControl].} +{.deprecated: [TXDeviceAbsCalibState: XDeviceAbsCalibState].} +{.deprecated: [TXDeviceAbsAreaControl: XDeviceAbsAreaControl].} +{.deprecated: [TXDeviceAbsAreaState: XDeviceAbsAreaState].} +{.deprecated: [TXDeviceCoreControl: XDeviceCoreControl].} +{.deprecated: [TXDeviceCoreState: XDeviceCoreState].} +{.deprecated: [TXDeviceEnableControl: XDeviceEnableControl].} +{.deprecated: [TXDeviceEnableState: XDeviceEnableState].} +{.deprecated: [TXAnyClassInfo: XAnyClassInfo].} +{.deprecated: [TXDeviceInfo: XDeviceInfo].} +{.deprecated: [TXKeyInfo: XKeyInfo].} +{.deprecated: [TXButtonInfo: XButtonInfo].} +{.deprecated: [TXAxisInfo: XAxisInfo].} +{.deprecated: [TXValuatorInfo: XValuatorInfo].} +{.deprecated: [TXInputClassInfo: XInputClassInfo].} +{.deprecated: [TXDevice: XDevice].} +{.deprecated: [TXEventList: XEventList].} +{.deprecated: [TXDeviceTimeCoord: XDeviceTimeCoord].} +{.deprecated: [TXDeviceState: XDeviceState].} +{.deprecated: [TXValuatorState: XValuatorState].} +{.deprecated: [TXKeyState: XKeyState].} +{.deprecated: [TXButtonState: XButtonState].} + +{.push cdecl, importc, dynlib: libXi.} + +proc XChangeKeyboardDevice*(a1: PDisplay, a2: PXDevice): cint +proc XChangePointerDevice*(a1: PDisplay, a2: PXDevice, a3, a4: cint): cint +proc XGrabDevice*(a1: PDisplay, a2: PXDevice, a3: Window, a4: XBool, a5: cint, + a6: ptr UncheckedArray[XEventClass], a7, a8: cint, a9: Time): cint +proc XUngrabDevice*(a1: PDisplay, a2: PXDevice, a3: Time): cint +proc XGrabDeviceKey*(a1: PDisplay, a2: PXDevice, a3, a4: cuint, + a5: PXDevice, a6: Window, a7: XBool, a8: cuint, + a9: ptr UncheckedArray[XEventClass], a10, a11: cint): cint +proc XUngrabDeviceKey*(a1: PDisplay, a2: PXDevice, a3: cuint, a4: cuint, + a5: PXDevice, a6: Window): cint +proc XGrabDeviceButton*(a1: PDisplay, a2: PXDevice, a3: cuint, a4: cuint, + a5: PXDevice, a6: Window, a7: XBool, a8: cuint, + a9: ptr UncheckedArray[XEventClass], a10: cint, a11: cint): cint +proc XUngrabDeviceButton*(a1: PDisplay, a2: PXDevice, a3: cuint, a4: cuint, + a5: PXDevice, a6: Window): cint +proc XAllowDeviceEvents*(a1: PDisplay, a2: PXDevice, a3: cint, a4: Time): cint +proc XGetDeviceFocus*(a1: PDisplay, a2: PXDevice, a3: PWindow, a4: ptr cint, + a5: ptr Time): cint +proc XSetDeviceFocus*(a1: PDisplay, a2: PXDevice, a3: Window, a4: cint, a5: Time): cint +proc XGetFeedbackControl*(a1: PDisplay, a2: PXDevice, a3: ptr cint): PXFeedbackState +proc XFreeFeedbackList*(a1: PXFeedbackState) +proc XChangeFeedbackControl*(a1: PDisplay, a2: PXDevice, a3: culong, + a4: PXFeedbackControl): cint +proc XDeviceBell*(a1: PDisplay, a2: PXDevice, a3, a4: XID, a5: cint): cint +proc XGetDeviceKeyMapping*(a1: PDisplay, a2: PXDevice, + a3: (when xNeedWidePrototypes: cuint else: KeyCode), + a4: cint, a5: ptr cint): PKeySym +proc XChangeDeviceKeyMapping*(a1: PDisplay, a2: PXDevice, a3: cint, a4: cint, + a5: PKeySym, a6: cint): cint +proc XGetDeviceModifierMapping*(a1: PDisplay, a2: PXDevice): PXModifierKeymap +proc XSetDeviceModifierMapping*(a1: PDisplay, a2: PXDevice, + a3: PXModifierKeymap): cint +proc XSetDeviceButtonMapping*(a1: PDisplay, a2: PXDevice, a3: cstring, a4: cint): cint +proc XGetDeviceButtonMapping*(a1: PDisplay, a2: PXDevice, a3: cstring, a4: cuint): cint +proc XQueryDeviceState*(a1: PDisplay, a2: PXDevice): PXDeviceState +proc XFreeDeviceState*(a1: PXDeviceState) +proc XGetExtensionVersion*(a1: PDisplay, a2: cstring): PXExtensionVersion +proc XListInputDevices*(a1: PDisplay, a2: ptr cint): PXDeviceInfo +proc XFreeDeviceList*(a1: PXDeviceInfo) +proc XOpenDevice*(a1: PDisplay, a2: XID): PXDevice +proc XCloseDevice*(a1: PDisplay, a2: PXDevice): cint +proc XSetDeviceMode*(a1: PDisplay, a2: PXDevice, a3: cint): cint +proc XSetDeviceValuators*(a1: PDisplay, a2: PXDevice, a3: ptr cint, a4: cint, a5: cint): cint +proc XGetDeviceControl*(a1: PDisplay, a2: PXDevice, a3: cint): PXDeviceControl +proc XChangeDeviceControl*(a1: PDisplay, a2: PXDevice, a3: cint, + a4: PXDeviceControl): cint +proc XSelectExtensionEvent*(a1: PDisplay, a2: Window, a3: ptr UncheckedArray[XEventClass], a4: cint): cint +proc XGetSelectedExtensionEvents*(a1: PDisplay, a2: Window, a3: ptr cint, + a4: ptr ptr UncheckedArray[XEventClass], a5: ptr cint, + a6: ptr ptr UncheckedArray[XEventClass]): cint +proc XChangeDeviceDontPropagateList*(a1: PDisplay, a2: Window, a3: cint, + a4: ptr UncheckedArray[XEventClass], a5: cint): cint +proc XGetDeviceDontPropagateList*(a1: PDisplay, a2: Window, a3: ptr cint): ptr UncheckedArray[XEventClass] +proc XSendExtensionEvent*(a1: PDisplay, a2: PXDevice, a3: Window, a4: XBool, a5: cint, + a6: ptr UncheckedArray[XEventClass], a7: PXEvent): Status +proc XGetDeviceMotionEvents*(a1: PDisplay, a2: PXDevice, a3, a4: Time, + a5, a6, a7: ptr cint): PXDeviceTimeCoord +proc XFreeDeviceMotionEvents*(a1: PXDeviceTimeCoord) +proc XFreeDeviceControl*(a1: PXDeviceControl) +proc XListDeviceProperties*(a1: PDisplay, a2: PXDevice, a3: ptr cint): PAtom +proc XChangeDeviceProperty*(a1: PDisplay, a2: PXDevice, a3: Atom, a4: Atom, a5: cint, + a6: cint, a7: cstring, a8: cint) +proc XDeleteDeviceProperty*(a1: PDisplay, a2: PXDevice, a3: Atom) +proc XGetDeviceProperty*(a1: PDisplay, a2: PXDevice, a3: Atom, a4, a5: clong, + a6: XBool, a7: Atom, a8: PAtom, a9: ptr cint, a10: ptr culong, + a11: ptr culong, a12: ptr cstring): Status + +{.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xinput2.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xinput2.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,421 @@ +# ***************************************** +# Generated from +# ***************************************** +import x, xlib, xi2 + +# +type PointerBarrier* = XID + +type + PXIAddMasterInfo* = ptr XIAddMasterInfo + XIAddMasterInfo* {.final.} = object + `type`*: cint + name*: cstring + send_core*: XBool + enable*: XBool + + PXIRemoveMasterInfo* = ptr XIRemoveMasterInfo + XIRemoveMasterInfo* {.final.} = object + `type`*: cint + deviceid*: cint + return_mode*: cint ## AttachToMaster, Floating + return_pointer*: cint + return_keyboard*: cint + + PXIAttachSlaveInfo* = ptr XIAttachSlaveInfo + XIAttachSlaveInfo* {.final.} = object + `type`*: cint + deviceid*: cint + new_master*: cint + + PXIDetachSlaveInfo* = ptr XIDetachSlaveInfo + XIDetachSlaveInfo* {.final.} = object + `type`*: cint + deviceid*: cint + + PXIAnyHierarchyChangeInfo* = ptr XIAnyHierarchyChangeInfo + XIAnyHierarchyChangeInfo* {.final, union.} = object + `type`*: cint ## must be first element + add*: XIAddMasterInfo + remove*: XIRemoveMasterInfo + attach*: XIAttachSlaveInfo + detach*: XIDetachSlaveInfo + + PXIModifierState* = ptr XIModifierState + XIModifierState* {.final.} = object + base*: cint + latched*: cint + locked*: cint + effective*: cint + + PXIGroupState* = ptr XIGroupState + XIGroupState* = XIModifierState + + PXIButtonState* = ptr XIButtonState + XIButtonState* {.final.} = object + mask_len*: cint + mask*: ptr cuchar + + PXIValuatorState* = ptr XIValuatorState + XIValuatorState* {.final.} = object + mask_len*: cint + mask*: ptr cuchar + values*: ptr cdouble + + PXIEventMask* = ptr XIEventMask + XIEventMask* {.final.} = object + deviceid*: cint + mask_len*: cint + mask*: ptr cuchar + + PXIAnyClassInfo* = ptr XIAnyClassInfo + XIAnyClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + + PXIButtonClassInfo* = ptr XIButtonClassInfo + XIButtonClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + num_buttons*: cint + labels*: PAtom + state*: XIButtonState + + PXIKeyClassInfo* = ptr XIKeyClassInfo + XIKeyClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + num_keycodes*: cint + keycodes*: ptr cint + + PXIValuatorClassInfo* = ptr XIValuatorClassInfo + XIValuatorClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + number*: cint + label*: Atom + min*: cdouble + max*: cdouble + value*: cdouble + resolution*: cint + mode*: cint + + +## new in XI 2.1 + +type + PXIScrollClassInfo* = ptr XIScrollClassInfo + XIScrollClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + number*: cint + scroll_type*: cint + increment*: cdouble + flags*: cint + + PXITouchClassInfo* = ptr XITouchClassInfo + XITouchClassInfo* {.final.} = object + `type`*: cint + sourceid*: cint + mode*: cint + num_touches*: cint + + PXIDeviceInfo* = ptr XIDeviceInfo + XIDeviceInfo* {.final.} = object + deviceid*: cint + name*: cstring + use*: cint + attachment*: cint + enabled*: XBool + num_classes*: cint + classes*: ptr ptr XIAnyClassInfo + + PXIGrabModifiers* = ptr XIGrabModifiers + XIGrabModifiers* {.final.} = object + modifiers*: cint + status*: cint + + BarrierEventID* = cuint + # ------------------------------------------------------------ + PXIBarrierReleasePointerInfo* = ptr XIBarrierReleasePointerInfo + XIBarrierReleasePointerInfo* {.final.} = object + deviceid*: cint + barrier*: PointerBarrier + eventid*: BarrierEventID + +## +## Generic XI2 event. All XI2 events have the same header. +## + +type + PXIEvent* = ptr XIEvent + XIEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint + time*: Time + + PXIHierarchyInfo* = ptr XIHierarchyInfo + XIHierarchyInfo* {.final.} = object + deviceid*: cint + attachment*: cint + use*: cint + enabled*: XBool + flags*: cint + +## +## Notifies the client that the device hierarchy has been changed. The client +## is expected to re-query the server for the device hierarchy. +## + +type + PXIHierarchyEvent* = ptr XIHierarchyEvent + XIHierarchyEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint ## XI_HierarchyChanged + time*: Time + flags*: cint + num_info*: cint + info*: ptr XIHierarchyInfo + +## +## Notifies the client that the classes have been changed. This happens when +## the slave device that sends through the master changes. +## + +type + PXIDeviceChangedEvent* = ptr XIDeviceChangedEvent + XIDeviceChangedEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint ## XI_DeviceChanged + time*: Time + deviceid*: cint ## id of the device that changed + sourceid*: cint ## Source for the new classes. + reason*: cint ## Reason for the change + num_classes*: cint + classes*: ptr ptr XIAnyClassInfo ## same as in XIDeviceInfo + + PXIDeviceEvent* = ptr XIDeviceEvent + XIDeviceEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint + time*: Time + deviceid*: cint + sourceid*: cint + detail*: cint + root*: Window + event*: Window + child*: Window + root_x*: cdouble + root_y*: cdouble + event_x*: cdouble + event_y*: cdouble + flags*: cint + buttons*: XIButtonState + valuators*: XIValuatorState + mods*: XIModifierState + group*: XIGroupState + + PXIRawEvent* = ptr XIRawEvent + XIRawEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint ## XI_RawKeyPress, XI_RawKeyRelease, etc. + time*: Time + deviceid*: cint + sourceid*: cint ## Bug: Always 0. https://bugs.freedesktop.org//show_bug.cgi?id=34240 + detail*: cint + flags*: cint + valuators*: XIValuatorState + raw_values*: ptr cdouble + + PXIEnterEvent* = ptr XIEnterEvent + XIEnterEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint + time*: Time + deviceid*: cint + sourceid*: cint + detail*: cint + root*: Window + event*: Window + child*: Window + root_x*: cdouble + root_y*: cdouble + event_x*: cdouble + event_y*: cdouble + mode*: cint + focus*: XBool + same_screen*: XBool + buttons*: XIButtonState + mods*: XIModifierState + group*: XIGroupState + + PXILeaveEvent* = PXIEnterEvent + PXIFocusInEvent* = PXIEnterEvent + PXIFocusOutEvent* = PXIEnterEvent + # ---------------------------------- + XILeaveEvent* = XIEnterEvent + XIFocusInEvent* = XIEnterEvent + XIFocusOutEvent* = XIEnterEvent + + PXIPropertyEvent* = ptr XIPropertyEvent + XIPropertyEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint ## XI_PropertyEvent + time*: Time + deviceid*: cint ## id of the device that changed + property*: Atom + what*: cint + + PXITouchOwnershipEvent* = ptr XITouchOwnershipEvent + XITouchOwnershipEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint + time*: Time + deviceid*: cint + sourceid*: cint + touchid*: cuint + root*: Window + event*: Window + child*: Window + flags*: cint + + PXIBarrierEvent* = ptr XIBarrierEvent + XIBarrierEvent* {.final.} = object + `type`*: cint ## GenericEvent + serial*: culong ## # of last request processed by server + send_event*: XBool ## true if this came from a SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## XI extension offset + evtype*: cint + time*: Time + deviceid*: cint + sourceid*: cint + event*: Window + root*: Window + root_x*: cdouble + root_y*: cdouble + dx*: cdouble + dy*: cdouble + dtime*: cint + flags*: cint + barrier*: PointerBarrier + eventid*: BarrierEventID + +## +## XI2 Procs, uses same shared object as XI +## + +{.push cdecl, importc, dynlib: libXi.} + +proc XIQueryPointer*(display: PDisplay; deviceid: cint; win: Window; + root: PWindow; child: PWindow; root_x: ptr cdouble; + root_y: ptr cdouble; win_x: ptr cdouble; win_y: ptr cdouble; + buttons: PXIButtonState; mods: PXIModifierState; + group: PXIGroupState): XBool +proc XIWarpPointer*(display: PDisplay; deviceid: cint; src_win: Window; + dst_win: Window; src_x: cdouble; src_y: cdouble; src_width: cuint; + src_height: cuint; dst_x: cdouble; dst_y: cdouble): XBool +proc XIDefineCursor*(display: PDisplay; deviceid: cint; win: Window; cursor: Cursor): Status +proc XIUndefineCursor*(display: PDisplay; deviceid: cint; win: Window): Status +proc XIChangeHierarchy*(display: PDisplay; changes: PXIAnyHierarchyChangeInfo; + num_changes: cint): Status +proc XISetClientPointer*(dpy: PDisplay; win: Window; deviceid: cint): Status +proc XIGetClientPointer*(dpy: PDisplay; win: Window; deviceid: ptr cint): XBool +proc XISelectEvents*(dpy: PDisplay; win: Window; masks: PXIEventMask; + num_masks: cint): cint +proc XIGetSelectedEvents*(dpy: PDisplay; win: Window; num_masks_return: ptr cint): PXIEventMask +proc XIQueryVersion*(dpy: PDisplay; major_version_inout: ptr cint; + minor_version_inout: ptr cint): Status +proc XIQueryDevice*(dpy: PDisplay; deviceid: cint; ndevices_return: ptr cint): PXIDeviceInfo +proc XISetFocus*(dpy: PDisplay; deviceid: cint; focus: Window; time: Time): Status +proc XIGetFocus*(dpy: PDisplay; deviceid: cint; focus_return: PWindow): Status +proc XIGrabDevice*(dpy: PDisplay; deviceid: cint; grab_window: Window; time: Time; + cursor: Cursor; grab_mode: cint; paired_device_mode: cint; + owner_events: XBool; mask: PXIEventMask): Status +proc XIUngrabDevice*(dpy: PDisplay; deviceid: cint; time: Time): Status +proc XIAllowEvents*(display: PDisplay; deviceid: cint; event_mode: cint; time: Time): Status +proc XIAllowTouchEvents*(display: PDisplay; deviceid: cint; touchid: cuint; + grab_window: Window; event_mode: cint): Status +proc XIGrabButton*(display: PDisplay; deviceid: cint; button: cint; + grab_window: Window; cursor: Cursor; grab_mode: cint; + paired_device_mode: cint; owner_events: cint; + mask: PXIEventMask; num_modifiers: cint; + modifiers_inout: PXIGrabModifiers): cint +proc XIGrabKeycode*(display: PDisplay; deviceid: cint; keycode: cint; + grab_window: Window; grab_mode: cint; paired_device_mode: cint; + owner_events: cint; mask: PXIEventMask; num_modifiers: cint; + modifiers_inout: PXIGrabModifiers): cint +proc XIGrabEnter*(display: PDisplay; deviceid: cint; grab_window: Window; + cursor: Cursor; grab_mode: cint; paired_device_mode: cint; + owner_events: cint; mask: PXIEventMask; num_modifiers: cint; + modifiers_inout: PXIGrabModifiers): cint +proc XIGrabFocusIn*(display: PDisplay; deviceid: cint; grab_window: Window; + grab_mode: cint; paired_device_mode: cint; owner_events: cint; + mask: PXIEventMask; num_modifiers: cint; + modifiers_inout: PXIGrabModifiers): cint +proc XIGrabTouchBegin*(display: PDisplay; deviceid: cint; grab_window: Window; + owner_events: cint; mask: PXIEventMask; num_modifiers: cint; + modifiers_inout: PXIGrabModifiers): cint +proc XIUngrabButton*(display: PDisplay; deviceid: cint; button: cint; + grab_window: Window; num_modifiers: cint; + modifiers: PXIGrabModifiers): Status +proc XIUngrabKeycode*(display: PDisplay; deviceid: cint; keycode: cint; + grab_window: Window; num_modifiers: cint; + modifiers: PXIGrabModifiers): Status +proc XIUngrabEnter*(display: PDisplay; deviceid: cint; grab_window: Window; + num_modifiers: cint; modifiers: PXIGrabModifiers): Status +proc XIUngrabFocusIn*(display: PDisplay; deviceid: cint; grab_window: Window; + num_modifiers: cint; modifiers: PXIGrabModifiers): Status +proc XIUngrabTouchBegin*(display: PDisplay; deviceid: cint; grab_window: Window; + num_modifiers: cint; modifiers: PXIGrabModifiers): Status +proc XIListProperties*(display: PDisplay; deviceid: cint; + num_props_return: ptr cint): PAtom +proc XIChangeProperty*(display: PDisplay; deviceid: cint; property: Atom; + `type`: Atom; format: cint; mode: cint; data: ptr cuchar; + num_items: cint) +proc XIDeleteProperty*(display: PDisplay; deviceid: cint; property: Atom) +proc XIGetProperty*(display: PDisplay; deviceid: cint; property: Atom; offset: clong; + length: clong; delete_property: XBool; `type`: Atom; + type_return: PAtom; format_return: ptr cint; + num_items_return: ptr culong; bytes_after_return: ptr culong; + data: ptr ptr cuchar): Status +proc XIBarrierReleasePointers*(display: PDisplay; + barriers: PXIBarrierReleasePointerInfo; + num_barriers: cint) +proc XIBarrierReleasePointer*(display: PDisplay; deviceid: cint; + barrier: PointerBarrier; eventid: BarrierEventID) +proc XIFreeDeviceInfo*(info: PXIDeviceInfo) + +{.pop.} \ No newline at end of file diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xkb.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xkb.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,2509 @@ +# +# $Xorg: XKB.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# $Xorg: XKBstr.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# $Xorg: XKBgeom.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# +#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. +# +#Permission to use, copy, modify, and distribute this +#software and its documentation for any purpose and without +#fee is hereby granted, provided that the above copyright +#notice appear in all copies and that both that copyright +#notice and this permission notice appear in supporting +#documentation, and that the name of Silicon Graphics not be +#used in advertising or publicity pertaining to distribution +#of the software without specific prior written permission. +#Silicon Graphics makes no representation about the suitability +#of this software for any purpose. It is provided "as is" +#without any express or implied warranty. +# +#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +#THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +#******************************************************** +# $XFree86: xc/include/extensions/XKB.h,v 1.5 2002/11/20 04:49:01 dawes Exp $ +# $XFree86: xc/include/extensions/XKBgeom.h,v 3.9 2002/09/18 17:11:40 tsi Exp $ +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Thanks: +# I want to thanks to oliebol for putting up with all of the problems that was found +# while translating this code. ;) +# +# I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my +# wierd questions ;) +# +# Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to +# understanding some of the problems I had converting this headers and pointing me to resources +# that helped translating this headers. +# +# Ido +# +#History: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and +# chnaged it to "reocrd" only. +# 2004/10/04 - 06 - Convertion from the c header of XKBgeom.h. +# 2004/10/03 - Removed the XKBstr_UNIT compiler decleration. Afther the joined files, +# There is no need for it anymore. +# - There is a need to define (for now) XKBgeom (compiler define) in order +# to use the code of it. At this moment, I did not yet converted it to Pascal. +# +# 2004/09/17 - 10/04 - Convertion from the c header of XKBstr. +# +# 2004/10/03 - Joined xkbstr.pas into xkb.pas because of the circular calls problems. +# - Added the history of xkbstr.pas above this addition. +# +# 2004/09/17 - Fixed a wrong convertion number of XkbPerKeyBitArraySize, insted +# of float, it's now converted into integer (as it should have been). +# +# 2004/09/15 - 16 - Convertion from the c header of XKB.h. +# + +import + x, xlib + +include "x11pragma.nim" + +proc XkbcharToInt*(v: int8): int16 +proc XkbIntTo2chars*(i: int16, h, L: var int8) +proc Xkb2charsToInt*(h, L: int8): int16 + # + # Common data structures and access macros + # +type + PWord* = ptr array[0..64_000, int16] + PByte* = ptr byte + PXkbStatePtr* = ptr XkbStateRec + XkbStateRec*{.final.} = object + group*: int8 + locked_group*: int8 + base_group*: int16 + latched_group*: int16 + mods*: int8 + base_mods*: int8 + latched_mods*: int8 + locked_mods*: int8 + compat_state*: int8 + grab_mods*: int8 + compat_grab_mods*: int8 + lookup_mods*: int8 + compat_lookup_mods*: int8 + ptr_buttons*: int16 + +{.deprecated: [TXkbStateRec: XkbStateRec].} + + +proc XkbModLocks*(s: PXkbStatePtr): int8 +proc XkbStateMods*(s: PXkbStatePtr): int16 +proc XkbGroupLock*(s: PXkbStatePtr): int8 +proc XkbStateGroup*(s: PXkbStatePtr): int16 +proc XkbStateFieldFromRec*(s: PXkbStatePtr): int +proc XkbGrabStateFromRec*(s: PXkbStatePtr): int +type + PXkbModsPtr* = ptr XkbModsRec + XkbModsRec*{.final.} = object + mask*: int8 # effective mods + real_mods*: int8 + vmods*: int16 + +{.deprecated: [TXkbModsRec: XkbModsRec].} + + +type + PXkbKTMapEntryPtr* = ptr XkbKTMapEntryRec + XkbKTMapEntryRec*{.final.} = object + active*: bool + level*: int8 + mods*: XkbModsRec + +{.deprecated: [TXkbKTMapEntryRec: XkbKTMapEntryRec].} + + +type + PXkbKeyTypePtr* = ptr XkbKeyTypeRec + XkbKeyTypeRec*{.final.} = object + mods*: XkbModsRec + num_levels*: int8 + map_count*: int8 + map*: PXkbKTMapEntryPtr + preserve*: PXkbModsPtr + name*: Atom + level_names*: Atom + +{.deprecated: [TXkbKeyTypeRec: XkbKeyTypeRec].} + + +proc XkbNumGroups*(g: int16): int16 +proc XkbOutOfRangeGroupInfo*(g: int16): int16 +proc XkbOutOfRangeGroupAction*(g: int16): int16 +proc XkbOutOfRangeGroupNumber*(g: int16): int16 +proc XkbSetGroupInfo*(g, w, n: int16): int16 +proc XkbSetNumGroups*(g, n: int16): int16 + # + # Structures and access macros used primarily by the server + # +type + PXkbBehavior* = ptr XkbBehavior + XkbBehavior*{.final.} = object + theType*: int8 + data*: int8 + +{.deprecated: [TXkbBehavior: XkbBehavior].} + + +type + PXkbModAction* = ptr XkbModAction + XkbModAction*{.final.} = object + theType*: int8 + flags*: int8 + mask*: int8 + real_mods*: int8 + vmods1*: int8 + vmods2*: int8 + +{.deprecated: [TXkbModAction: XkbModAction].} + + +proc XkbModActionVMods*(a: PXkbModAction): int16 +proc XkbSetModActionVMods*(a: PXkbModAction, v: int8) +type + PXkbGroupAction* = ptr XkbGroupAction + XkbGroupAction*{.final.} = object + theType*: int8 + flags*: int8 + group_XXX*: int8 + +{.deprecated: [TXkbGroupAction: XkbGroupAction].} + + +proc XkbSAGroup*(a: PXkbGroupAction): int8 +proc XkbSASetGroupProc*(a: PXkbGroupAction, g: int8) +type + PXkbISOAction* = ptr XkbISOAction + XkbISOAction*{.final.} = object + theType*: int8 + flags*: int8 + mask*: int8 + real_mods*: int8 + group_XXX*: int8 + affect*: int8 + vmods1*: int8 + vmods2*: int8 + +{.deprecated: [TXkbISOAction: XkbISOAction].} + + +type + PXkbPtrAction* = ptr XkbPtrAction + XkbPtrAction*{.final.} = object + theType*: int8 + flags*: int8 + high_XXX*: int8 + low_XXX*: int8 + high_YYY*: int8 + low_YYY*: int8 + +{.deprecated: [TXkbPtrAction: XkbPtrAction].} + + +proc XkbPtrActionX*(a: PXkbPtrAction): int16 +proc XkbPtrActionY*(a: PXkbPtrAction): int16 +proc XkbSetPtrActionX*(a: PXkbPtrAction, x: int8) +proc XkbSetPtrActionY*(a: PXkbPtrAction, y: int8) +type + PXkbPtrBtnAction* = ptr XkbPtrBtnAction + XkbPtrBtnAction*{.final.} = object + theType*: int8 + flags*: int8 + count*: int8 + button*: int8 + +{.deprecated: [TXkbPtrBtnAction: XkbPtrBtnAction].} + + +type + PXkbPtrDfltAction* = ptr XkbPtrDfltAction + XkbPtrDfltAction*{.final.} = object + theType*: int8 + flags*: int8 + affect*: int8 + valueXXX*: int8 + +{.deprecated: [TXkbPtrDfltAction: XkbPtrDfltAction].} + + +proc XkbSAPtrDfltValue*(a: PXkbPtrDfltAction): int8 +proc XkbSASetPtrDfltValue*(a: PXkbPtrDfltAction, c: pointer) +type + PXkbSwitchScreenAction* = ptr XkbSwitchScreenAction + XkbSwitchScreenAction*{.final.} = object + theType*: int8 + flags*: int8 + screenXXX*: int8 + +{.deprecated: [TXkbSwitchScreenAction: XkbSwitchScreenAction].} + + +proc XkbSAScreen*(a: PXkbSwitchScreenAction): int8 +proc XkbSASetScreen*(a: PXkbSwitchScreenAction, s: pointer) +type + PXkbCtrlsAction* = ptr XkbCtrlsAction + XkbCtrlsAction*{.final.} = object + theType*: int8 + flags*: int8 + ctrls3*: int8 + ctrls2*: int8 + ctrls1*: int8 + ctrls0*: int8 + +{.deprecated: [TXkbCtrlsAction: XkbCtrlsAction].} + + +proc XkbActionSetCtrls*(a: PXkbCtrlsAction, c: int8) +proc XkbActionCtrls*(a: PXkbCtrlsAction): int16 +type + PXkbMessageAction* = ptr XkbMessageAction + XkbMessageAction*{.final.} = object + theType*: int8 + flags*: int8 + message*: array[0..5, char] + +{.deprecated: [TXkbMessageAction: XkbMessageAction].} + + +type + PXkbRedirectKeyAction* = ptr XkbRedirectKeyAction + XkbRedirectKeyAction*{.final.} = object + theType*: int8 + new_key*: int8 + mods_mask*: int8 + mods*: int8 + vmods_mask0*: int8 + vmods_mask1*: int8 + vmods0*: int8 + vmods1*: int8 + +{.deprecated: [TXkbRedirectKeyAction: XkbRedirectKeyAction].} + + +proc XkbSARedirectVMods*(a: PXkbRedirectKeyAction): int16 +proc XkbSARedirectSetVMods*(a: PXkbRedirectKeyAction, m: int8) +proc XkbSARedirectVModsMask*(a: PXkbRedirectKeyAction): int16 +proc XkbSARedirectSetVModsMask*(a: PXkbRedirectKeyAction, m: int8) +type + PXkbDeviceBtnAction* = ptr XkbDeviceBtnAction + XkbDeviceBtnAction*{.final.} = object + theType*: int8 + flags*: int8 + count*: int8 + button*: int8 + device*: int8 + +{.deprecated: [TXkbDeviceBtnAction: XkbDeviceBtnAction].} + + +type + PXkbDeviceValuatorAction* = ptr XkbDeviceValuatorAction + XkbDeviceValuatorAction*{.final.} = object # + # Macros to classify key actions + # + theType*: int8 + device*: int8 + v1_what*: int8 + v1_ndx*: int8 + v1_value*: int8 + v2_what*: int8 + v2_ndx*: int8 + v2_value*: int8 + +{.deprecated: [TXkbDeviceValuatorAction: XkbDeviceValuatorAction].} + + +const + XkbAnyActionDataSize* = 7 + +type + PXkbAnyAction* = ptr XkbAnyAction + XkbAnyAction*{.final.} = object + theType*: int8 + data*: array[0..XkbAnyActionDataSize - 1, int8] + +{.deprecated: [TXkbAnyAction: XkbAnyAction].} + + +proc XkbIsModAction*(a: PXkbAnyAction): bool +proc XkbIsGroupAction*(a: PXkbAnyAction): bool +proc XkbIsPtrAction*(a: PXkbAnyAction): bool +type + PXkbAction* = ptr XkbAction + XkbAction*{.final.} = object # + # XKB request codes, used in: + # - xkbReqType field of all requests + # - requestMinor field of some events + # + any*: XkbAnyAction + mods*: XkbModAction + group*: XkbGroupAction + iso*: XkbISOAction + thePtr*: XkbPtrAction + btn*: XkbPtrBtnAction + dflt*: XkbPtrDfltAction + screen*: XkbSwitchScreenAction + ctrls*: XkbCtrlsAction + msg*: XkbMessageAction + redirect*: XkbRedirectKeyAction + devbtn*: XkbDeviceBtnAction + devval*: XkbDeviceValuatorAction + theType*: int8 + +{.deprecated: [TXkbAction: XkbAction].} + + +const + X_kbUseExtension* = 0 + X_kbSelectEvents* = 1 + X_kbBell* = 3 + X_kbGetState* = 4 + X_kbLatchLockState* = 5 + X_kbGetControls* = 6 + X_kbSetControls* = 7 + X_kbGetMap* = 8 + X_kbSetMap* = 9 + X_kbGetCompatMap* = 10 + X_kbSetCompatMap* = 11 + X_kbGetIndicatorState* = 12 + X_kbGetIndicatorMap* = 13 + X_kbSetIndicatorMap* = 14 + X_kbGetNamedIndicator* = 15 + X_kbSetNamedIndicator* = 16 + X_kbGetNames* = 17 + X_kbSetNames* = 18 + X_kbGetGeometry* = 19 + X_kbSetGeometry* = 20 + X_kbPerClientFlags* = 21 + X_kbListComponents* = 22 + X_kbGetKbdByName* = 23 + X_kbGetDeviceInfo* = 24 + X_kbSetDeviceInfo* = 25 + X_kbSetDebuggingFlags* = 101 # + # In the X sense, XKB reports only one event. + # The type field of all XKB events is XkbEventCode + # + +const + XkbEventCode* = 0 + XkbNumberEvents* = XkbEventCode + 1 # + # XKB has a minor event code so it can use one X event code for + # multiple purposes. + # - reported in the xkbType field of all XKB events. + # - XkbSelectEventDetails: Indicates the event for which event details + # are being changed + # + +const + XkbNewKeyboardNotify* = 0 + XkbMapNotify* = 1 + XkbStateNotify* = 2 + XkbControlsNotify* = 3 + XkbIndicatorStateNotify* = 4 + XkbIndicatorMapNotify* = 5 + XkbNamesNotify* = 6 + XkbCompatMapNotify* = 7 + XkbBellNotify* = 8 + XkbActionMessage* = 9 + XkbAccessXNotify* = 10 + XkbExtensionDeviceNotify* = 11 # + # Event Mask: + # - XkbSelectEvents: Specifies event interest. + # + +const + XkbNewKeyboardNotifyMask* = int(1) shl 0 + XkbMapNotifyMask* = int(1) shl 1 + XkbStateNotifyMask* = int(1) shl 2 + XkbControlsNotifyMask* = int(1) shl 3 + XkbIndicatorStateNotifyMask* = int(1) shl 4 + XkbIndicatorMapNotifyMask* = int(1) shl 5 + XkbNamesNotifyMask* = int(1) shl 6 + XkbCompatMapNotifyMask* = int(1) shl 7 + XkbBellNotifyMask* = int(1) shl 8 + XkbActionMessageMask* = int(1) shl 9 + XkbAccessXNotifyMask* = int(1) shl 10 + XkbExtensionDeviceNotifyMask* = int(1) shl 11 + XkbAllEventsMask* = 0x00000FFF # + # NewKeyboardNotify event details: + # + +const + XkbNKN_KeycodesMask* = int(1) shl 0 + XkbNKN_GeometryMask* = int(1) shl 1 + XkbNKN_DeviceIDMask* = int(1) shl 2 + XkbAllNewKeyboardEventsMask* = 0x00000007 # + # AccessXNotify event types: + # - The 'what' field of AccessXNotify events reports the + # reason that the event was generated. + # + +const + XkbAXN_SKPress* = 0 + XkbAXN_SKAccept* = 1 + XkbAXN_SKReject* = 2 + XkbAXN_SKRelease* = 3 + XkbAXN_BKAccept* = 4 + XkbAXN_BKReject* = 5 + XkbAXN_AXKWarning* = 6 # + # AccessXNotify details: + # - Used as an event detail mask to limit the conditions under which + # AccessXNotify events are reported + # + +const + XkbAXN_SKPressMask* = int(1) shl 0 + XkbAXN_SKAcceptMask* = int(1) shl 1 + XkbAXN_SKRejectMask* = int(1) shl 2 + XkbAXN_SKReleaseMask* = int(1) shl 3 + XkbAXN_BKAcceptMask* = int(1) shl 4 + XkbAXN_BKRejectMask* = int(1) shl 5 + XkbAXN_AXKWarningMask* = int(1) shl 6 + XkbAllAccessXEventsMask* = 0x0000000F # + # State detail mask: + # - The 'changed' field of StateNotify events reports which of + # the keyboard state components have changed. + # - Used as an event detail mask to limit the conditions under + # which StateNotify events are reported. + # + +const + XkbModifierStateMask* = int(1) shl 0 + XkbModifierBaseMask* = int(1) shl 1 + XkbModifierLatchMask* = int(1) shl 2 + XkbModifierLockMask* = int(1) shl 3 + XkbGroupStateMask* = int(1) shl 4 + XkbGroupBaseMask* = int(1) shl 5 + XkbGroupLatchMask* = int(1) shl 6 + XkbGroupLockMask* = int(1) shl 7 + XkbCompatStateMask* = int(1) shl 8 + XkbGrabModsMask* = int(1) shl 9 + XkbCompatGrabModsMask* = int(1) shl 10 + XkbLookupModsMask* = int(1) shl 11 + XkbCompatLookupModsMask* = int(1) shl 12 + XkbPointerButtonMask* = int(1) shl 13 + XkbAllStateComponentsMask* = 0x00003FFF # + # Controls detail masks: + # The controls specified in XkbAllControlsMask: + # - The 'changed' field of ControlsNotify events reports which of + # the keyboard controls have changed. + # - The 'changeControls' field of the SetControls request specifies + # the controls for which values are to be changed. + # - Used as an event detail mask to limit the conditions under + # which ControlsNotify events are reported. + # + # The controls specified in the XkbAllBooleanCtrlsMask: + # - The 'enabledControls' field of ControlsNotify events reports the + # current status of the boolean controls. + # - The 'enabledControlsChanges' field of ControlsNotify events reports + # any boolean controls that have been turned on or off. + # - The 'affectEnabledControls' and 'enabledControls' fields of the + # kbSetControls request change the set of enabled controls. + # - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of + # an XkbControlsRec specify the controls to be changed if the keyboard + # times out and the values to which they should be changed. + # - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags + # request specifies the specify the controls to be reset when the + # client exits and the values to which they should be reset. + # - The 'ctrls' field of an indicator map specifies the controls + # that drive the indicator. + # - Specifies the boolean controls affected by the SetControls and + # LockControls key actions. + # + +const + XkbRepeatKeysMask* = int(1) shl 0 + XkbSlowKeysMask* = int(1) shl 1 + XkbBounceKeysMask* = int(1) shl 2 + XkbStickyKeysMask* = int(1) shl 3 + XkbMouseKeysMask* = int(1) shl 4 + XkbMouseKeysAccelMask* = int(1) shl 5 + XkbAccessXKeysMask* = int(1) shl 6 + XkbAccessXTimeoutMask* = int(1) shl 7 + XkbAccessXFeedbackMask* = int(1) shl 8 + XkbAudibleBellMask* = int(1) shl 9 + XkbOverlay1Mask* = int(1) shl 10 + XkbOverlay2Mask* = int(1) shl 11 + XkbIgnoreGroupLockMask* = int(1) shl 12 + XkbGroupsWrapMask* = int(1) shl 27 + XkbInternalModsMask* = int(1) shl 28 + XkbIgnoreLockModsMask* = int(1) shl 29 + XkbPerKeyRepeatMask* = int(1) shl 30 + XkbControlsEnabledMask* = int(1) shl 31 + XkbAccessXOptionsMask* = XkbStickyKeysMask or XkbAccessXFeedbackMask + XkbAllBooleanCtrlsMask* = 0x00001FFF + XkbAllControlsMask* = 0xF8001FFF # + # Compatibility Map Compontents: + # - Specifies the components to be allocated in XkbAllocCompatMap. + # + +const + XkbSymInterpMask* = 1 shl 0 + XkbGroupCompatMask* = 1 shl 1 + XkbAllCompatMask* = 0x00000003 # + # Assorted constants and limits. + # + +const + XkbAllIndicatorsMask* = 0xFFFFFFFF # + # Map components masks: + # Those in AllMapComponentsMask: + # - Specifies the individual fields to be loaded or changed for the + # GetMap and SetMap requests. + # Those in ClientInfoMask: + # - Specifies the components to be allocated by XkbAllocClientMap. + # Those in ServerInfoMask: + # - Specifies the components to be allocated by XkbAllocServerMap. + # + +const + XkbKeyTypesMask* = 1 shl 0 + XkbKeySymsMask* = 1 shl 1 + XkbModifierMapMask* = 1 shl 2 + XkbExplicitComponentsMask* = 1 shl 3 + XkbKeyActionsMask* = 1 shl 4 + XkbKeyBehaviorsMask* = 1 shl 5 + XkbVirtualModsMask* = 1 shl 6 + XkbVirtualModMapMask* = 1 shl 7 + XkbAllClientInfoMask* = XkbKeyTypesMask or XkbKeySymsMask or + XkbModifierMapMask + XkbAllServerInfoMask* = XkbExplicitComponentsMask or XkbKeyActionsMask or + XkbKeyBehaviorsMask or XkbVirtualModsMask or XkbVirtualModMapMask + XkbAllMapComponentsMask* = XkbAllClientInfoMask or XkbAllServerInfoMask # + # Names component mask: + # - Specifies the names to be loaded or changed for the GetNames and + # SetNames requests. + # - Specifies the names that have changed in a NamesNotify event. + # - Specifies the names components to be allocated by XkbAllocNames. + # + +const + XkbKeycodesNameMask* = 1 shl 0 + XkbGeometryNameMask* = 1 shl 1 + XkbSymbolsNameMask* = 1 shl 2 + XkbPhysSymbolsNameMask* = 1 shl 3 + XkbTypesNameMask* = 1 shl 4 + XkbCompatNameMask* = 1 shl 5 + XkbKeyTypeNamesMask* = 1 shl 6 + XkbKTLevelNamesMask* = 1 shl 7 + XkbIndicatorNamesMask* = 1 shl 8 + XkbKeyNamesMask* = 1 shl 9 + XkbKeyAliasesMask* = 1 shl 10 + XkbVirtualModNamesMask* = 1 shl 11 + XkbGroupNamesMask* = 1 shl 12 + XkbRGNamesMask* = 1 shl 13 + XkbComponentNamesMask* = 0x0000003F + XkbAllNamesMask* = 0x00003FFF # + # Miscellaneous event details: + # - event detail masks for assorted events that don't reall + # have any details. + # + +const + XkbAllStateEventsMask* = XkbAllStateComponentsMask + XkbAllMapEventsMask* = XkbAllMapComponentsMask + XkbAllControlEventsMask* = XkbAllControlsMask + XkbAllIndicatorEventsMask* = XkbAllIndicatorsMask + XkbAllNameEventsMask* = XkbAllNamesMask + XkbAllCompatMapEventsMask* = XkbAllCompatMask + XkbAllBellEventsMask* = int(1) shl 0 + XkbAllActionMessagesMask* = int(1) shl 0 # + # XKB reports one error: BadKeyboard + # A further reason for the error is encoded into to most significant + # byte of the resourceID for the error: + # XkbErr_BadDevice - the device in question was not found + # XkbErr_BadClass - the device was found but it doesn't belong to + # the appropriate class. + # XkbErr_BadId - the device was found and belongs to the right + # class, but not feedback with a matching id was + # found. + # The low byte of the resourceID for this error contains the device + # id, class specifier or feedback id that failed. + # + +const + XkbKeyboard* = 0 + XkbNumberErrors* = 1 + XkbErr_BadDevice* = 0x000000FF + XkbErr_BadClass* = 0x000000FE + XkbErr_BadId* = 0x000000FD # + # Keyboard Components Mask: + # - Specifies the components that follow a GetKeyboardByNameReply + # + +const + XkbClientMapMask* = int(1) shl 0 + XkbServerMapMask* = int(1) shl 1 + XkbCompatMapMask* = int(1) shl 2 + XkbIndicatorMapMask* = int(1) shl 3 + XkbNamesMask* = int(1) shl 4 + XkbGeometryMask* = int(1) shl 5 + XkbControlsMask* = int(1) shl 6 + XkbAllComponentsMask* = 0x0000007F # + # AccessX Options Mask + # - The 'accessXOptions' field of an XkbControlsRec specifies the + # AccessX options that are currently in effect. + # - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues' + # fields of an XkbControlsRec specify the Access X options to be + # changed if the keyboard times out and the values to which they + # should be changed. + # + +const + XkbAX_SKPressFBMask* = int(1) shl 0 + XkbAX_SKAcceptFBMask* = int(1) shl 1 + XkbAX_FeatureFBMask* = int(1) shl 2 + XkbAX_SlowWarnFBMask* = int(1) shl 3 + XkbAX_IndicatorFBMask* = int(1) shl 4 + XkbAX_StickyKeysFBMask* = int(1) shl 5 + XkbAX_TwoKeysMask* = int(1) shl 6 + XkbAX_LatchToLockMask* = int(1) shl 7 + XkbAX_SKReleaseFBMask* = int(1) shl 8 + XkbAX_SKRejectFBMask* = int(1) shl 9 + XkbAX_BKRejectFBMask* = int(1) shl 10 + XkbAX_DumbBellFBMask* = int(1) shl 11 + XkbAX_FBOptionsMask* = 0x00000F3F + XkbAX_SKOptionsMask* = 0x000000C0 + XkbAX_AllOptionsMask* = 0x00000FFF # + # XkbUseCoreKbd is used to specify the core keyboard without having + # to look up its X input extension identifier. + # XkbUseCorePtr is used to specify the core pointer without having + # to look up its X input extension identifier. + # XkbDfltXIClass is used to specify "don't care" any place that the + # XKB protocol is looking for an X Input Extension + # device class. + # XkbDfltXIId is used to specify "don't care" any place that the + # XKB protocol is looking for an X Input Extension + # feedback identifier. + # XkbAllXIClasses is used to get information about all device indicators, + # whether they're part of the indicator feedback class + # or the keyboard feedback class. + # XkbAllXIIds is used to get information about all device indicator + # feedbacks without having to list them. + # XkbXINone is used to indicate that no class or id has been specified. + # XkbLegalXILedClass(c) True if 'c' specifies a legal class with LEDs + # XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells + # XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device + # XkbExplicitXIClass(c) True if 'c' explicitly specifies a device class + # XkbExplicitXIId(c) True if 'i' explicitly specifies a device id + # XkbSingleXIClass(c) True if 'c' specifies exactly one device class, + # including the default. + # XkbSingleXIId(i) True if 'i' specifies exactly one device + # identifier, including the default. + # + +const + XkbUseCoreKbd* = 0x00000100 + XkbUseCorePtr* = 0x00000200 + XkbDfltXIClass* = 0x00000300 + XkbDfltXIId* = 0x00000400 + XkbAllXIClasses* = 0x00000500 + XkbAllXIIds* = 0x00000600 + XkbXINone* = 0x0000FF00 + +proc XkbLegalXILedClass*(c: int): bool +proc XkbLegalXIBellClass*(c: int): bool +proc XkbExplicitXIDevice*(c: int): bool +proc XkbExplicitXIClass*(c: int): bool +proc XkbExplicitXIId*(c: int): bool +proc XkbSingleXIClass*(c: int): bool +proc XkbSingleXIId*(c: int): bool +const + XkbNoModifier* = 0x000000FF + XkbNoShiftLevel* = 0x000000FF + XkbNoShape* = 0x000000FF + XkbNoIndicator* = 0x000000FF + XkbNoModifierMask* = 0 + XkbAllModifiersMask* = 0x000000FF + XkbAllVirtualModsMask* = 0x0000FFFF + XkbNumKbdGroups* = 4 + XkbMaxKbdGroup* = XkbNumKbdGroups - 1 + XkbMaxMouseKeysBtn* = 4 # + # Group Index and Mask: + # - Indices into the kt_index array of a key type. + # - Mask specifies types to be changed for XkbChangeTypesOfKey + # + +const + XkbGroup1Index* = 0 + XkbGroup2Index* = 1 + XkbGroup3Index* = 2 + XkbGroup4Index* = 3 + XkbAnyGroup* = 254 + XkbAllGroups* = 255 + XkbGroup1Mask* = 1 shl 0 + XkbGroup2Mask* = 1 shl 1 + XkbGroup3Mask* = 1 shl 2 + XkbGroup4Mask* = 1 shl 3 + XkbAnyGroupMask* = 1 shl 7 + XkbAllGroupsMask* = 0x0000000F # + # BuildCoreState: Given a keyboard group and a modifier state, + # construct the value to be reported an event. + # GroupForCoreState: Given the state reported in an event, + # determine the keyboard group. + # IsLegalGroup: Returns TRUE if 'g' is a valid group index. + # + +proc XkbBuildCoreState*(m, g: int): int +proc XkbGroupForCoreState*(s: int): int +proc XkbIsLegalGroup*(g: int): bool + # + # GroupsWrap values: + # - The 'groupsWrap' field of an XkbControlsRec specifies the + # treatment of out of range groups. + # - Bits 6 and 7 of the group info field of a key symbol map + # specify the interpretation of out of range groups for the + # corresponding key. + # +const + XkbWrapIntoRange* = 0x00000000 + XkbClampIntoRange* = 0x00000040 + XkbRedirectIntoRange* = 0x00000080 # + # Action flags: Reported in the 'flags' field of most key actions. + # Interpretation depends on the type of the action; not all actions + # accept all flags. + # + # Option Used for Actions + # ------ ---------------- + # ClearLocks SetMods, LatchMods, SetGroup, LatchGroup + # LatchToLock SetMods, LatchMods, SetGroup, LatchGroup + # LockNoLock LockMods, ISOLock, LockPtrBtn, LockDeviceBtn + # LockNoUnlock LockMods, ISOLock, LockPtrBtn, LockDeviceBtn + # UseModMapMods SetMods, LatchMods, LockMods, ISOLock + # GroupAbsolute SetGroup, LatchGroup, LockGroup, ISOLock + # UseDfltButton PtrBtn, LockPtrBtn + # NoAcceleration MovePtr + # MoveAbsoluteX MovePtr + # MoveAbsoluteY MovePtr + # ISODfltIsGroup ISOLock + # ISONoAffectMods ISOLock + # ISONoAffectGroup ISOLock + # ISONoAffectPtr ISOLock + # ISONoAffectCtrls ISOLock + # MessageOnPress ActionMessage + # MessageOnRelease ActionMessage + # MessageGenKeyEvent ActionMessage + # AffectDfltBtn SetPtrDflt + # DfltBtnAbsolute SetPtrDflt + # SwitchApplication SwitchScreen + # SwitchAbsolute SwitchScreen + # + +const + XkbSA_ClearLocks* = int(1) shl 0 + XkbSA_LatchToLock* = int(1) shl 1 + XkbSA_LockNoLock* = int(1) shl 0 + XkbSA_LockNoUnlock* = int(1) shl 1 + XkbSA_UseModMapMods* = int(1) shl 2 + XkbSA_GroupAbsolute* = int(1) shl 2 + XkbSA_UseDfltButton* = 0 + XkbSA_NoAcceleration* = int(1) shl 0 + XkbSA_MoveAbsoluteX* = int(1) shl 1 + XkbSA_MoveAbsoluteY* = int(1) shl 2 + XkbSA_ISODfltIsGroup* = int(1) shl 7 + XkbSA_ISONoAffectMods* = int(1) shl 6 + XkbSA_ISONoAffectGroup* = int(1) shl 5 + XkbSA_ISONoAffectPtr* = int(1) shl 4 + XkbSA_ISONoAffectCtrls* = int(1) shl 3 + XkbSA_ISOAffectMask* = 0x00000078 + XkbSA_MessageOnPress* = int(1) shl 0 + XkbSA_MessageOnRelease* = int(1) shl 1 + XkbSA_MessageGenKeyEvent* = int(1) shl 2 + XkbSA_AffectDfltBtn* = 1 + XkbSA_DfltBtnAbsolute* = int(1) shl 2 + XkbSA_SwitchApplication* = int(1) shl 0 + XkbSA_SwitchAbsolute* = int(1) shl 2 # + # The following values apply to the SA_DeviceValuator + # action only. Valuator operations specify the action + # to be taken. Values specified in the action are + # multiplied by 2^scale before they are applied. + # + +const + XkbSA_IgnoreVal* = 0x00000000 + XkbSA_SetValMin* = 0x00000010 + XkbSA_SetValCenter* = 0x00000020 + XkbSA_SetValMax* = 0x00000030 + XkbSA_SetValRelative* = 0x00000040 + XkbSA_SetValAbsolute* = 0x00000050 + XkbSA_ValOpMask* = 0x00000070 + XkbSA_ValScaleMask* = 0x00000007 + +proc XkbSA_ValOp*(a: int): int +proc XkbSA_ValScale*(a: int): int + # + # Action types: specifies the type of a key action. Reported in the + # type field of all key actions. + # +const + XkbSA_NoAction* = 0x00000000 + XkbSA_SetMods* = 0x00000001 + XkbSA_LatchMods* = 0x00000002 + XkbSA_LockMods* = 0x00000003 + XkbSA_SetGroup* = 0x00000004 + XkbSA_LatchGroup* = 0x00000005 + XkbSA_LockGroup* = 0x00000006 + XkbSA_MovePtr* = 0x00000007 + XkbSA_PtrBtn* = 0x00000008 + XkbSA_LockPtrBtn* = 0x00000009 + XkbSA_SetPtrDflt* = 0x0000000A + XkbSA_ISOLock* = 0x0000000B + XkbSA_Terminate* = 0x0000000C + XkbSA_SwitchScreen* = 0x0000000D + XkbSA_SetControls* = 0x0000000E + XkbSA_LockControls* = 0x0000000F + XkbSA_ActionMessage* = 0x00000010 + XkbSA_RedirectKey* = 0x00000011 + XkbSA_DeviceBtn* = 0x00000012 + XkbSA_LockDeviceBtn* = 0x00000013 + XkbSA_DeviceValuator* = 0x00000014 + XkbSA_LastAction* = XkbSA_DeviceValuator + XkbSA_NumActions* = XkbSA_LastAction + 1 + +const + XkbSA_XFree86Private* = 0x00000086 +# +# Specifies the key actions that clear latched groups or modifiers. +# + +const ##define XkbSA_BreakLatch \ + # ((1<>13)&0x3) + result = (s shr 13) and 0x00000003 + +proc XkbIsLegalGroup(g: int): bool = + ##define XkbIsLegalGroup(g) (((g)>=0)&&((g)= 0) and (g < XkbNumKbdGroups) + +proc XkbSA_ValOp(a: int): int = + ##define XkbSA_ValOp(a) ((a)&XkbSA_ValOpMask) + result = a and XkbSA_ValOpMask + +proc XkbSA_ValScale(a: int): int = + ##define XkbSA_ValScale(a) ((a)&XkbSA_ValScaleMask) + result = a and XkbSA_ValScaleMask + +proc XkbIsModAction(a: PXkbAnyAction): bool = + ##define XkbIsModAction(a) (((a)->type>=Xkb_SASetMods)&&((a)->type<=XkbSA_LockMods)) + result = (a.theType) >= XkbSA_SetMods and (a.theType) <= XkbSA_LockMods + +proc XkbIsGroupAction(a: PXkbAnyAction): bool = + ##define XkbIsGroupAction(a) (((a)->type>=XkbSA_SetGroup)&&((a)->type<=XkbSA_LockGroup)) + result = (a.theType >= XkbSA_SetGroup) or (a.theType <= XkbSA_LockGroup) + +proc XkbIsPtrAction(a: PXkbAnyAction): bool = + ##define XkbIsPtrAction(a) (((a)->type>=XkbSA_MovePtr)&&((a)->type<=XkbSA_SetPtrDflt)) + result = (a.theType >= XkbSA_MovePtr) and + (a.theType <= XkbSA_SetPtrDflt) + +proc XkbIsLegalKeycode(k: int): bool = + ##define XkbIsLegalKeycode(k) (((k)>=XkbMinLegalKeyCode)&&((k)<=XkbMaxLegalKeyCode)) + result = (k >= XkbMinLegalKeyCode) and (k <= XkbMaxLegalKeyCode) + +proc XkbShiftLevel(n: int8): int8 = + ##define XkbShiftLevel(n) ((n)-1) + result = n - 1'i8 + +proc XkbShiftLevelMask(n: int8): int8 = + ##define XkbShiftLevelMask(n) (1<<((n)-1)) + result = 1'i8 shl (n - 1'i8) + +proc XkbcharToInt(v: int8): int16 = + ##define XkbcharToInt(v) ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f)) + if ((v and 0x80'i8) != 0'i8): result = v or (not 0xFF'i16) + else: result = int16(v and 0x7F'i8) + +proc XkbIntTo2chars(i: int16, h, L: var int8) = + ##define XkbIntTo2chars(i,h,l) (((h)=((i>>8)&0xff)),((l)=((i)&0xff))) + h = int8((i shr 8'i16) and 0x00FF'i16) + L = int8(i and 0xFF'i16) + +proc Xkb2charsToInt(h, L: int8): int16 = + when defined(cpu64): + ##define Xkb2charsToInt(h,l) ((h)&0x80?(int)(((h)<<8)|(l)|(~0xffff)): (int)(((h)<<8)|(l)&0x7fff)) + if (h and 0x80'i8) != 0'i8: + result = int16((h shl 8) or L or not 0x0000FFFF) + else: + result = int16((h shl 8) or L and 0x00007FFF) + else: + ##define Xkb2charsToInt(h,l) ((short)(((h)<<8)|(l))) + result = int16(h shl 8 or L) + +proc XkbModLocks(s: PXkbStatePtr): int8 = + ##define XkbModLocks(s) ((s)->locked_mods) + result = s.locked_mods + +proc XkbStateMods(s: PXkbStatePtr): int16 = + ##define XkbStateMods(s) ((s)->base_mods|(s)->latched_mods|XkbModLocks(s)) + result = s.base_mods or s.latched_mods or XkbModLocks(s) + +proc XkbGroupLock(s: PXkbStatePtr): int8 = + ##define XkbGroupLock(s) ((s)->locked_group) + result = s.locked_group + +proc XkbStateGroup(s: PXkbStatePtr): int16 = + ##define XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s)) + result = s.base_group + (s.latched_group) + XkbGroupLock(s) + +proc XkbStateFieldFromRec(s: PXkbStatePtr): int = + ##define XkbStateFieldFromRec(s) XkbBuildCoreState((s)->lookup_mods,(s)->group) + result = XkbBuildCoreState(s.lookup_mods, s.group) + +proc XkbGrabStateFromRec(s: PXkbStatePtr): int = + ##define XkbGrabStateFromRec(s) XkbBuildCoreState((s)->grab_mods,(s)->group) + result = XkbBuildCoreState(s.grab_mods, s.group) + +proc XkbNumGroups(g: int16): int16 = + ##define XkbNumGroups(g) ((g)&0x0f) + result = g and 0x0000000F'i16 + +proc XkbOutOfRangeGroupInfo(g: int16): int16 = + ##define XkbOutOfRangeGroupInfo(g) ((g)&0xf0) + result = g and 0x000000F0'i16 + +proc XkbOutOfRangeGroupAction(g: int16): int16 = + ##define XkbOutOfRangeGroupAction(g) ((g)&0xc0) + result = g and 0x000000C0'i16 + +proc XkbOutOfRangeGroupNumber(g: int16): int16 = + ##define XkbOutOfRangeGroupNumber(g) (((g)&0x30)>>4) + result = (g and 0x00000030'i16) shr 4'i16 + +proc XkbSetGroupInfo(g, w, n: int16): int16 = + ##define XkbSetGroupInfo(g,w,n) (((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f)) + result = (w and 0x000000C0'i16) or + ((n and 3'i16) shl 4'i16) or (g and 0x0000000F'i16) + +proc XkbSetNumGroups(g, n: int16): int16 = + ##define XkbSetNumGroups(g,n) (((g)&0xf0)|((n)&0x0f)) + result = (g and 0x000000F0'i16) or (n and 0x0000000F'i16) + +proc XkbModActionVMods(a: PXkbModAction): int16 = + ##define XkbModActionVMods(a) ((short)(((a)->vmods1<<8)|((a)->vmods2))) + result = int16((a.vmods1 shl 8) or a.vmods2) + +proc XkbSetModActionVMods(a: PXkbModAction, v: int8) = + ##define XkbSetModActionVMods(a,v) (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff)) + a.vmods1 = int8((v shr 8) and 0x000000FF) + a.vmods2 = int8(v and 0x000000FF) + +proc XkbSAGroup(a: PXkbGroupAction): int8 = + ##define XkbSAGroup(a) (XkbcharToInt((a)->group_XXX)) + result = int8(XkbcharToInt(a.group_XXX)) + +proc XkbSASetGroupProc(a: PXkbGroupAction, g: int8) = + ##define XkbSASetGroup(a,g) ((a)->group_XXX=(g)) + a.group_XXX = g + +proc XkbPtrActionX(a: PXkbPtrAction): int16 = + ##define XkbPtrActionX(a) (Xkb2charsToInt((a)->high_XXX,(a)->low_XXX)) + result = int16(Xkb2charsToInt(a.high_XXX, a.low_XXX)) + +proc XkbPtrActionY(a: PXkbPtrAction): int16 = + ##define XkbPtrActionY(a) (Xkb2charsToInt((a)->high_YYY,(a)->low_YYY)) + result = int16(Xkb2charsToInt(a.high_YYY, a.low_YYY)) + +proc XkbSetPtrActionX(a: PXkbPtrAction, x: int8) = + ##define XkbSetPtrActionX(a,x) (XkbIntTo2chars(x,(a)->high_XXX,(a)->low_XXX)) + XkbIntTo2chars(x, a.high_XXX, a.low_XXX) + +proc XkbSetPtrActionY(a: PXkbPtrAction, y: int8) = + ##define XkbSetPtrActionY(a,y) (XkbIntTo2chars(y,(a)->high_YYY,(a)->low_YYY)) + XkbIntTo2chars(y, a.high_YYY, a.low_YYY) + +proc XkbSAPtrDfltValue(a: PXkbPtrDfltAction): int8 = + ##define XkbSAPtrDfltValue(a) (XkbcharToInt((a)->valueXXX)) + result = int8(XkbcharToInt(a.valueXXX)) + +proc XkbSASetPtrDfltValue(a: PXkbPtrDfltAction, c: pointer) = + ##define XkbSASetPtrDfltValue(a,c) ((a)->valueXXX= ((c)&0xff)) + a.valueXXX = int8(cast[int](c)) + +proc XkbSAScreen(a: PXkbSwitchScreenAction): int8 = + ##define XkbSAScreen(a) (XkbcharToInt((a)->screenXXX)) + result = int8(XkbcharToInt(a.screenXXX)) + +proc XkbSASetScreen(a: PXkbSwitchScreenAction, s: pointer) = + ##define XkbSASetScreen(a,s) ((a)->screenXXX= ((s)&0xff)) + a.screenXXX = int8(cast[int](s)) + +proc XkbActionSetCtrls(a: PXkbCtrlsAction, c: int8) = + ##define XkbActionSetCtrls(a,c) (((a)->ctrls3=(((c)>>24)&0xff)),((a)->ctrls2=(((c)>>16)&0xff)), + # ((a)->ctrls1=(((c)>>8)&0xff)),((a)->ctrls0=((c)&0xff))) + a.ctrls3 = int8((c shr 24) and 0x000000FF) + a.ctrls2 = int8((c shr 16) and 0x000000FF) + a.ctrls1 = int8((c shr 8) and 0x000000FF) + a.ctrls0 = int8(c and 0x000000FF) + +proc XkbActionCtrls(a: PXkbCtrlsAction): int16 = + ##define XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|(((unsigned int)(a)->ctrls2)<<16)| + # (((unsigned int)(a)->ctrls1)<<8)|((unsigned int)((a)->ctrls0))) + result = int16((a.ctrls3 shl 24) or (a.ctrls2 shl 16) or + (a.ctrls1 shl 8) or a.ctrls0) + +proc XkbSARedirectVMods(a: PXkbRedirectKeyAction): int16 = + ##define XkbSARedirectVMods(a) ((((unsigned int)(a)->vmods1)<<8)|((unsigned int)(a)->vmods0)) + result = int16((a.vmods1 shl 8) or a.vmods0) + +proc XkbSARedirectSetVMods(a: PXkbRedirectKeyAction, m: int8) = + ##define XkbSARedirectSetVMods(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff))) + a.vmods_mask1 = int8((m shr 8) and 0x000000FF) + a.vmods_mask0 = int8(m or 0x000000FF) + +proc XkbSARedirectVModsMask(a: PXkbRedirectKeyAction): int16 = + ##define XkbSARedirectVModsMask(a) ((((unsigned int)(a)->vmods_mask1)<<8)| + # ((unsigned int)(a)->vmods_mask0)) + result = int16((a.vmods_mask1 shl 8) or a.vmods_mask0) + +proc XkbSARedirectSetVModsMask(a: PXkbRedirectKeyAction, m: int8) = + ##define XkbSARedirectSetVModsMask(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff))) + a.vmods_mask1 = int8(m shr 8 and 0x000000FF) + a.vmods_mask0 = int8(m and 0x000000FF) + +proc XkbAX_AnyFeedback(c: PXkbControlsPtr): int16 = + ##define XkbAX_AnyFeedback(c) ((c)->enabled_ctrls&XkbAccessXFeedbackMask) + result = int16(c.enabled_ctrls and XkbAccessXFeedbackMask) + +proc XkbAX_NeedOption(c: PXkbControlsPtr, w: int16): int16 = + ##define XkbAX_NeedOption(c,w) ((c)->ax_options&(w)) + result = int16(c.ax_options and w) + +proc XkbAX_NeedFeedback(c: PXkbControlsPtr, w: int16): bool = + ##define XkbAX_NeedFeedback(c,w) (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w)) + result = (XkbAX_AnyFeedback(c) > 0'i16) and (XkbAX_NeedOption(c, w) > 0'i16) + +proc XkbSMKeyActionsPtr(m: PXkbServerMapPtr, k: int16): PXkbAction = + ##define XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]]) + result = addr(m.acts[m.key_acts[k]]) + +proc XkbCMKeyGroupInfo(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyGroupInfo(m,k) ((m)->key_sym_map[k].group_info) + result = m.key_sym_map[k].group_info + +proc XkbCMKeyNumGroups(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyNumGroups(m,k) (XkbNumGroups((m)->key_sym_map[k].group_info)) + result = int8(XkbNumGroups(m.key_sym_map[k].group_info)) + +proc XkbCMKeyGroupWidth(m: PXkbClientMapPtr, k: int16, g: int8): int8 = + ##define XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels) + result = XkbCMKeyType(m, k, g).num_levels + +proc XkbCMKeyGroupsWidth(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width) + result = m.key_sym_map[k].width + +proc XkbCMKeyTypeIndex(m: PXkbClientMapPtr, k: int16, g: int8): int8 = + ##define XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3]) + result = m.key_sym_map[k].kt_index[g and 0x00000003] + +proc XkbCMKeyType(m: PXkbClientMapPtr, k: int16, g: int8): PXkbKeyTypePtr = + ##define XkbCMKeyType(m,k,g) (&(m)->types[XkbCMKeyTypeIndex(m,k,g)]) + result = addr(m.types[XkbCMKeyTypeIndex(m, k, g)]) + +proc XkbCMKeyNumSyms(m: PXkbClientMapPtr, k: int16): int16 = + ##define XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k)) + result = int16(XkbCMKeyGroupsWidth(m, k) or XkbCMKeyNumGroups(m, k)) + +proc XkbCMKeySymsOffset(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeySymsOffset(m,k) ((m)->key_sym_map[k].offset) + result = m.key_sym_map[k].offset + +proc XkbCMKeySymsPtr*(m: PXkbClientMapPtr, k: int16): PKeySym = + ##define XkbCMKeySymsPtr(m,k) (&(m)->syms[XkbCMKeySymsOffset(m,k)]) + result = addr(m.syms[XkbCMKeySymsOffset(m, k)]) + +proc XkbIM_IsAuto(i: PXkbIndicatorMapPtr): bool = + ##define XkbIM_IsAuto(i) ((((i)->flags&XkbIM_NoAutomatic)==0)&&(((i)->which_groups&&(i)->groups)|| + # ((i)->which_mods&&(i)->mods.mask)|| ((i)->ctrls))) + result = ((i.flags and XkbIM_NoAutomatic) == 0) and + (((i.which_groups > 0'i8) and (i.groups > 0'i8)) or + ((i.which_mods > 0'i8) and (i.mods.mask > 0'i8)) or (i.ctrls > 0'i8)) + +proc XkbIM_InUse(i: PXkbIndicatorMapPtr): bool = + ##define XkbIM_InUse(i) (((i)->flags)||((i)->which_groups)||((i)->which_mods)||((i)->ctrls)) + result = (i.flags > 0'i8) or (i.which_groups > 0'i8) or (i.which_mods > 0'i8) or + (i.ctrls > 0'i8) + +proc XkbKeyKeyTypeIndex(d: PXkbDescPtr, k: int16, g: int8): int8 = + ##define XkbKeyKeyTypeIndex(d,k,g) (XkbCMKeyTypeIndex((d)->map,k,g)) + result = XkbCMKeyTypeIndex(d.map, k, g) + +proc XkbKeyKeyType(d: PXkbDescPtr, k: int16, g: int8): PXkbKeyTypePtr = + ##define XkbKeyKeyType(d,k,g) (XkbCMKeyType((d)->map,k,g)) + result = XkbCMKeyType(d.map, k, g) + +proc XkbKeyGroupWidth(d: PXkbDescPtr, k: int16, g: int8): int8 = + ##define XkbKeyGroupWidth(d,k,g) (XkbCMKeyGroupWidth((d)->map,k,g)) + result = XkbCMKeyGroupWidth(d.map, k, g) + +proc XkbKeyGroupsWidth(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyGroupsWidth(d,k) (XkbCMKeyGroupsWidth((d)->map,k)) + result = XkbCMKeyGroupsWidth(d.map, k) + +proc XkbKeyGroupInfo(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyGroupInfo(d,k) (XkbCMKeyGroupInfo((d)->map,(k))) + result = XkbCMKeyGroupInfo(d.map, k) + +proc XkbKeyNumGroups(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyNumGroups(d,k) (XkbCMKeyNumGroups((d)->map,(k))) + result = XkbCMKeyNumGroups(d.map, k) + +proc XkbKeyNumSyms(d: PXkbDescPtr, k: int16): int16 = + ##define XkbKeyNumSyms(d,k) (XkbCMKeyNumSyms((d)->map,(k))) + result = XkbCMKeyNumSyms(d.map, k) + +proc XkbKeySymsPtr*(d: PXkbDescPtr, k: int16): PKeySym = + ##define XkbKeySymsPtr(d,k) (XkbCMKeySymsPtr((d)->map,(k))) + result = XkbCMKeySymsPtr(d.map, k) + +proc XkbKeySym(d: PXkbDescPtr, k: int16, n: int16): KeySym = + ##define XkbKeySym(d,k,n) (XkbKeySymsPtr(d,k)[n]) + result = cast[ptr array[0..0xffff, KeySym]](XkbKeySymsPtr(d, k))[n] # XXX: this seems strange! + +proc XkbKeySymEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): KeySym = + ##define XkbKeySymEntry(d,k,sl,g) (XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl)))) + result = XkbKeySym(d, k, int16(XkbKeyGroupsWidth(d, k) * g + sl)) + +proc XkbKeyAction(d: PXkbDescPtr, k: int16, n: int16): PXkbAction = + ##define XkbKeyAction(d,k,n) (XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL) + #if (XkbKeyHasActions(d, k)): + # result = XkbKeyActionsPtr(d, k)[n] #Buggy !!! + assert(false) + result = nil + +proc XkbKeyActionEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): int8 = + ##define XkbKeyActionEntry(d,k,sl,g) (XkbKeyHasActions(d,k) ? + # XkbKeyAction(d, k, ((XkbKeyGroupsWidth(d, k) * (g))+(sl))):NULL) + if XkbKeyHasActions(d, k): + result = XkbKeyGroupsWidth(d, k) *% g +% int8(sl) + else: + result = 0'i8 + +proc XkbKeyHasActions(d: PXkbDescPtr, k: int16): bool = + ##define XkbKeyHasActions(d,k) ((d)->server->key_acts[k]!=0) + result = d.server.key_acts[k] != 0'i16 + +proc XkbKeyNumActions(d: PXkbDescPtr, k: int16): int16 = + ##define XkbKeyNumActions(d,k) (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1) + if (XkbKeyHasActions(d, k)): result = XkbKeyNumSyms(d, k) + else: result = 1'i16 + +proc XkbKeyActionsPtr(d: PXkbDescPtr, k: int16): PXkbAction = + ##define XkbKeyActionsPtr(d,k) (XkbSMKeyActionsPtr((d)->server,k)) + result = XkbSMKeyActionsPtr(d.server, k) + +proc XkbKeycodeInRange(d: PXkbDescPtr, k: int16): bool = + ##define XkbKeycodeInRange(d,k) (((k)>=(d)->min_key_code)&& ((k)<=(d)->max_key_code)) + result = (char(int8(k)) >= d.min_key_code) and (char(int8(k)) <= d.max_key_code) + +proc XkbNumKeys(d: PXkbDescPtr): int8 = + ##define XkbNumKeys(d) ((d)->max_key_code-(d)->min_key_code+1) + result = int8(ord(d.max_key_code) - ord(d.min_key_code) + 1) + +proc XkbXI_DevHasBtnActs(d: PXkbDeviceInfoPtr): bool = + ##define XkbXI_DevHasBtnActs(d) (((d)->num_btns>0)&&((d)->btn_acts!=NULL)) + result = (d.num_btns > 0'i16) and (not (d.btn_acts == nil)) + +proc XkbXI_LegalDevBtn(d: PXkbDeviceInfoPtr, b: int16): bool = + ##define XkbXI_LegalDevBtn(d,b) (XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns)) + result = XkbXI_DevHasBtnActs(d) and (b <% d.num_btns) + +proc XkbXI_DevHasLeds(d: PXkbDeviceInfoPtr): bool = + ##define XkbXI_DevHasLeds(d) (((d)->num_leds>0)&&((d)->leds!=NULL)) + result = (d.num_leds > 0'i16) and (not (d.leds == nil)) + +proc XkbBoundsWidth(b: PXkbBoundsPtr): int16 = + ##define XkbBoundsWidth(b) (((b)->x2)-((b)->x1)) + result = (b.x2) - b.x1 + +proc XkbBoundsHeight(b: PXkbBoundsPtr): int16 = + ##define XkbBoundsHeight(b) (((b)->y2)-((b)->y1)) + result = (b.y2) - b.y1 + +proc XkbOutlineIndex(s: PXkbShapePtr, o: PXkbOutlinePtr): int32 = + ##define XkbOutlineIndex(s,o) ((int)((o)-&(s)->outlines[0])) + result = int32((cast[ByteAddress](o) - cast[ByteAddress](addr(s.outlines[0]))) div sizeof(PXkbOutlinePtr)) + +proc XkbShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbColorPtr = + ##define XkbShapeDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr((g.colors[d.color_ndx])) + +proc XkbShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbShapePtr = + ##define XkbShapeDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = addr(g.shapes[d.shape_ndx]) + +proc XkbSetShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetShapeDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = int16((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbSetShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + s: PXkbShapePtr) = + ##define XkbSetShapeDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = int16((cast[ByteAddress](s) - cast[ByteAddress](addr(g.shapes[0]))) div sizeof(XkbShapeRec)) + +proc XkbTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr): PXkbColorPtr = + ##define XkbTextDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr(g.colors[d.color_ndx]) + +proc XkbSetTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetTextDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = int16((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr = + ##define XkbIndicatorDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[d.shape_ndx])) + +proc XkbIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr = + ##define XkbIndicatorDoodadOnColor(g,d) (&(g)->colors[(d)->on_color_ndx]) + result = addr(g.colors[d.on_color_ndx]) + +proc XkbIndicatorDoodadOffColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr = + ##define XkbIndicatorDoodadOffColor(g,d) (&(g)->colors[(d)->off_color_ndx]) + result = addr(g.colors[d.off_color_ndx]) + +proc XkbSetIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetIndicatorDoodadOnColor(g,d,c) ((d)->on_color_ndx= (c)-&(g)->colors[0]) + d.on_color_ndx = int16((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbSetIndicatorDoodadOffColor(g: PXkbGeometryPtr, + d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr) = + ##define XkbSetIndicatorDoodadOffColor(g,d,c) ((d)->off_color_ndx= (c)-&(g)->colors[0]) + d.off_color_ndx = int16((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbSetIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr, + s: PXkbShapeDoodadPtr) = + ##define XkbSetIndicatorDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = int16((cast[ByteAddress](s) - (cast[ByteAddress](addr(g.shapes[0])))) div sizeof(XkbShapeRec)) + +proc XkbLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbColorPtr = + ##define XkbLogoDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr(g.colors[d.color_ndx]) + +proc XkbLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr = + ##define XkbLogoDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[d.shape_ndx])) + +proc XkbSetLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetLogoDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = int16((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbSetLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + s: PXkbShapeDoodadPtr) = + ##define XkbSetLogoDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = int16((cast[ByteAddress](s) - cast[ByteAddress](addr(g.shapes[0]))) div sizeof(XkbShapeRec)) + +proc XkbKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbShapeDoodadPtr = + ##define XkbKeyShape(g,k) (&(g)->shapes[(k)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[k.shape_ndx])) + +proc XkbKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbColorPtr = + ##define XkbKeyColor(g,k) (&(g)->colors[(k)->color_ndx]) + result = addr(g.colors[k.color_ndx]) + +proc XkbSetKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr) = + ##define XkbSetKeyShape(g,k,s) ((k)->shape_ndx= (s)-&(g)->shapes[0]) + k.shape_ndx = int8((cast[ByteAddress](s) - cast[ByteAddress](addr(g.shapes[0]))) div sizeof(XkbShapeRec)) + +proc XkbSetKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr) = + ##define XkbSetKeyColor(g,k,c) ((k)->color_ndx= (c)-&(g)->colors[0]) + k.color_ndx = int8((cast[ByteAddress](c) - cast[ByteAddress](addr(g.colors[0]))) div sizeof(XkbColorRec)) + +proc XkbGeomColorIndex(g: PXkbGeometryPtr, c: PXkbColorPtr): int32 = + ##define XkbGeomColorIndex(g,c) ((int)((c)-&(g)->colors[0])) + result = int16((cast[ByteAddress](c) - (cast[ByteAddress](addr(g.colors[0])))) div sizeof(XkbColorRec)) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xkblib.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xkblib.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,689 @@ +# $Xorg: XKBlib.h,v 1.6 2000/08/17 19:45:03 cpqbld Exp $ +#************************************************************ +#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. +# +#Permission to use, copy, modify, and distribute this +#software and its documentation for any purpose and without +#fee is hereby granted, provided that the above copyright +#notice appear in all copies and that both that copyright +#notice and this permission notice appear in supporting +#documentation, and that the name of Silicon Graphics not be +#used in advertising or publicity pertaining to distribution +#of the software without specific prior written permission. +#Silicon Graphics makes no representation about the suitability +#of this software for any purpose. It is provided "as is" +#without any express or implied warranty. +# +#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING `from` LOSS OF USE, +#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +#THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +#********************************************************/ +# $XFree86: xc/lib/X11/XKBlib.h,v 3.3 2001/08/01 00:44:38 tsi Exp $ +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Thanks: +# I want to thanks to oliebol for putting up with all of the problems that was found +# while translating this code. ;) +# +# I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my +# wierd questions ;) +# +# Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to +# understanding some of the problems I had converting this headers and pointing me to resources +# that helped translating this headers. +# +# Ido +# +#History: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and +# chnaged it to "reocrd" only. +# 2004/10/10 - Added to XkbGetAtomNameFunc and XkbInternAtomFunc the cdecl call. +# 2004/10/06 - 09 - Convertion `from` the c header of XKBlib.h +# +# + +import + x, xlib, xkb + + +include "x11pragma.nim" + + +type + PXkbAnyEvent* = ptr XkbAnyEvent + XkbAnyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds; + xkb_type*: int16 # XKB event minor code + device*: int16 # device ID + +{.deprecated: [TXkbAnyEvent: XkbAnyEvent].} + + +type + PXkbNewKeyboardNotifyEvent* = ptr XkbNewKeyboardNotifyEvent + XkbNewKeyboardNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbNewKeyboardNotify + device*: int16 # device ID + old_device*: int16 # device ID of previous keyboard + min_key_code*: int16 # minimum key code + max_key_code*: int16 # maximum key code + old_min_key_code*: int16 # min key code of previous kbd + old_max_key_code*: int16 # max key code of previous kbd + changed*: int16 # changed aspects of the keyboard + req_major*: int8 # major and minor opcode of req + req_minor*: int8 # that caused change, if applicable + +{.deprecated: [TXkbNewKeyboardNotifyEvent: XkbNewKeyboardNotifyEvent].} + + +type + PXkbMapNotifyEvent* = ptr XkbMapNotifyEvent + XkbMapNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbMapNotify + device*: int16 # device ID + changed*: int16 # fields which have been changed + flags*: int16 # reserved + first_type*: int16 # first changed key type + num_types*: int16 # number of changed key types + min_key_code*: KeyCode + max_key_code*: KeyCode + first_key_sym*: KeyCode + first_key_act*: KeyCode + first_key_behavior*: KeyCode + first_key_explicit*: KeyCode + first_modmap_key*: KeyCode + first_vmodmap_key*: KeyCode + num_key_syms*: int16 + num_key_acts*: int16 + num_key_behaviors*: int16 + num_key_explicit*: int16 + num_modmap_keys*: int16 + num_vmodmap_keys*: int16 + vmods*: int16 # mask of changed virtual mods + +{.deprecated: [TXkbMapNotifyEvent: XkbMapNotifyEvent].} + + +type + PXkbStateNotifyEvent* = ptr XkbStateNotifyEvent + XkbStateNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbStateNotify + device*: int16 # device ID + changed*: int16 # mask of changed state components + group*: int16 # keyboard group + base_group*: int16 # base keyboard group + latched_group*: int16 # latched keyboard group + locked_group*: int16 # locked keyboard group + mods*: int16 # modifier state + base_mods*: int16 # base modifier state + latched_mods*: int16 # latched modifiers + locked_mods*: int16 # locked modifiers + compat_state*: int16 # compatibility state + grab_mods*: int8 # mods used for grabs + compat_grab_mods*: int8 # grab mods for non-XKB clients + lookup_mods*: int8 # mods sent to clients + compat_lookup_mods*: int8 # mods sent to non-XKB clients + ptr_buttons*: int16 # pointer button state + keycode*: KeyCode # keycode that caused the change + event_type*: int8 # KeyPress or KeyRelease + req_major*: int8 # Major opcode of request + req_minor*: int8 # Minor opcode of request + +{.deprecated: [TXkbStateNotifyEvent: XkbStateNotifyEvent].} + + +type + PXkbControlsNotifyEvent* = ptr XkbControlsNotifyEvent + XkbControlsNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbControlsNotify + device*: int16 # device ID + changed_ctrls*: int16 # controls with changed sub-values + enabled_ctrls*: int16 # controls currently enabled + enabled_ctrl_changes*: int16 # controls just {en,dis}abled + num_groups*: int16 # total groups on keyboard + keycode*: KeyCode # key that caused change or 0 + event_type*: int8 # type of event that caused change + req_major*: int8 # if keycode==0, major and minor + req_minor*: int8 # opcode of req that caused change + +{.deprecated: [TXkbControlsNotifyEvent: XkbControlsNotifyEvent].} + + +type + PXkbIndicatorNotifyEvent* = ptr XkbIndicatorNotifyEvent + XkbIndicatorNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbIndicatorNotify + device*: int16 # device + changed*: int16 # indicators with new state or map + state*: int16 # current state of all indicators + +{.deprecated: [TXkbIndicatorNotifyEvent: XkbIndicatorNotifyEvent].} + + +type + PXkbNamesNotifyEvent* = ptr XkbNamesNotifyEvent + XkbNamesNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbNamesNotify + device*: int16 # device ID + changed*: int32 # names that have changed + first_type*: int16 # first key type with new name + num_types*: int16 # number of key types with new names + first_lvl*: int16 # first key type new new level names + num_lvls*: int16 # # of key types w/new level names + num_aliases*: int16 # total number of key aliases + num_radio_groups*: int16 # total number of radio groups + changed_vmods*: int16 # virtual modifiers with new names + changed_groups*: int16 # groups with new names + changed_indicators*: int16 # indicators with new names + first_key*: int16 # first key with new name + num_keys*: int16 # number of keys with new names + +{.deprecated: [TXkbNamesNotifyEvent: XkbNamesNotifyEvent].} + + +type + PXkbCompatMapNotifyEvent* = ptr XkbCompatMapNotifyEvent + XkbCompatMapNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbCompatMapNotify + device*: int16 # device ID + changed_groups*: int16 # groups with new compat maps + first_si*: int16 # first new symbol interp + num_si*: int16 # number of new symbol interps + num_total_si*: int16 # total # of symbol interps + +{.deprecated: [TXkbCompatMapNotifyEvent: XkbCompatMapNotifyEvent].} + + +type + PXkbBellNotifyEvent* = ptr XkbBellNotifyEvent + XkbBellNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbBellNotify + device*: int16 # device ID + percent*: int16 # requested volume as a % of maximum + pitch*: int16 # requested pitch in Hz + duration*: int16 # requested duration in useconds + bell_class*: int16 # (input extension) feedback class + bell_id*: int16 # (input extension) ID of feedback + name*: Atom # "name" of requested bell + window*: Window # window associated with event + event_only*: bool # "event only" requested + +{.deprecated: [TXkbBellNotifyEvent: XkbBellNotifyEvent].} + + +type + PXkbActionMessageEvent* = ptr XkbActionMessageEvent + XkbActionMessageEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbActionMessage + device*: int16 # device ID + keycode*: KeyCode # key that generated the event + press*: bool # true if act caused by key press + key_event_follows*: bool # true if key event also generated + group*: int16 # effective group + mods*: int16 # effective mods + message*: array[0..XkbActionMessageLength, char] # message -- leave space for NUL + +{.deprecated: [TXkbActionMessageEvent: XkbActionMessageEvent].} + + +type + PXkbAccessXNotifyEvent* = ptr XkbAccessXNotifyEvent + XkbAccessXNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbAccessXNotify + device*: int16 # device ID + detail*: int16 # XkbAXN_* + keycode*: int16 # key of event + sk_delay*: int16 # current slow keys delay + debounce_delay*: int16 # current debounce delay + +{.deprecated: [TXkbAccessXNotifyEvent: XkbAccessXNotifyEvent].} + + +type + PXkbExtensionDeviceNotifyEvent* = ptr XkbExtensionDeviceNotifyEvent + XkbExtensionDeviceNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: Time # milliseconds + xkb_type*: int16 # XkbExtensionDeviceNotify + device*: int16 # device ID + reason*: int16 # reason for the event + supported*: int16 # mask of supported features + unsupported*: int16 # mask of unsupported features + # that some app tried to use + first_btn*: int16 # first button that changed + num_btns*: int16 # range of buttons changed + leds_defined*: int16 # indicators with names or maps + led_state*: int16 # current state of the indicators + led_class*: int16 # feedback class for led changes + led_id*: int16 # feedback id for led changes + +{.deprecated: [TXkbExtensionDeviceNotifyEvent: XkbExtensionDeviceNotifyEvent].} + + +type + PXkbEvent* = ptr XkbEvent + XkbEvent*{.final.} = object + theType*: int16 + any*: XkbAnyEvent + new_kbd*: XkbNewKeyboardNotifyEvent + map*: XkbMapNotifyEvent + state*: XkbStateNotifyEvent + ctrls*: XkbControlsNotifyEvent + indicators*: XkbIndicatorNotifyEvent + names*: XkbNamesNotifyEvent + compat*: XkbCompatMapNotifyEvent + bell*: XkbBellNotifyEvent + message*: XkbActionMessageEvent + accessx*: XkbAccessXNotifyEvent + device*: XkbExtensionDeviceNotifyEvent + core*: XEvent + +{.deprecated: [TXkbEvent: XkbEvent].} + + +type + PXkbKbdDpyStatePtr* = ptr XkbKbdDpyStateRec + XkbKbdDpyStateRec*{.final.} = object # XkbOpenDisplay error codes + +{.deprecated: [TXkbKbdDpyStateRec: XkbKbdDpyStateRec].} + +const + XkbOD_Success* = 0 + XkbOD_BadLibraryVersion* = 1 + XkbOD_ConnectionRefused* = 2 + XkbOD_NonXkbServer* = 3 + XkbOD_BadServerVersion* = 4 # Values for XlibFlags + +const + XkbLC_ForceLatin1Lookup* = 1 shl 0 + XkbLC_ConsumeLookupMods* = 1 shl 1 + XkbLC_AlwaysConsumeShiftAndLock* = 1 shl 2 + XkbLC_IgnoreNewKeyboards* = 1 shl 3 + XkbLC_ControlFallback* = 1 shl 4 + XkbLC_ConsumeKeysOnComposeFail* = 1 shl 29 + XkbLC_ComposeLED* = 1 shl 30 + XkbLC_BeepOnComposeFail* = 1 shl 31 + XkbLC_AllComposeControls* = 0xC0000000 + XkbLC_AllControls* = 0xC000001F + +proc XkbIgnoreExtension*(ignore: bool): bool{.libx11c, + importc: "XkbIgnoreExtension".} +proc XkbOpenDisplay*(name: cstring, ev_rtrn, err_rtrn, major_rtrn, minor_rtrn, + reason: ptr int16): PDisplay{.libx11c, importc: "XkbOpenDisplay".} +proc XkbQueryExtension*(dpy: PDisplay, opcodeReturn, eventBaseReturn, + errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool{. + libx11c, importc: "XkbQueryExtension".} +proc XkbUseExtension*(dpy: PDisplay, major_rtrn, minor_rtrn: ptr int16): bool{. + libx11c, importc: "XkbUseExtension".} +proc XkbLibraryVersion*(libMajorRtrn, libMinorRtrn: ptr int16): bool{.libx11c, importc: "XkbLibraryVersion".} +proc XkbSetXlibControls*(dpy: PDisplay, affect, values: int16): int16{.libx11c, importc: "XkbSetXlibControls".} +proc XkbGetXlibControls*(dpy: PDisplay): int16{.libx11c, + importc: "XkbGetXlibControls".} +type + XkbInternAtomFunc* = proc (dpy: PDisplay, name: cstring, only_if_exists: bool): Atom{. + cdecl.} + +type + XkbGetAtomNameFunc* = proc (dpy: PDisplay, atom: Atom): cstring{.cdecl.} + +proc XkbSetAtomFuncs*(getAtom: XkbInternAtomFunc, getName: XkbGetAtomNameFunc){. + libx11c, importc: "XkbSetAtomFuncs".} +proc XkbKeycodeToKeysym*(dpy: PDisplay, kc: KeyCode, group, level: int16): KeySym{. + libx11c, importc: "XkbKeycodeToKeysym".} +proc XkbKeysymToModifiers*(dpy: PDisplay, ks: KeySym): int16{.libx11c, importc: "XkbKeysymToModifiers".} +proc XkbLookupKeySym*(dpy: PDisplay, keycode: KeyCode, + modifiers, modifiers_return: int16, keysym_return: PKeySym): bool{. + libx11c, importc: "XkbLookupKeySym".} +proc XkbLookupKeyBinding*(dpy: PDisplay, sym_rtrn: KeySym, mods: int16, + buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{. + libx11c, importc: "XkbLookupKeyBinding".} +proc XkbTranslateKeyCode*(xkb: PXkbDescPtr, keycode: KeyCode, + modifiers, modifiers_return: int16, + keysym_return: PKeySym): bool{.libx11c, + importc: "XkbTranslateKeyCode".} +proc XkbTranslateKeySym*(dpy: PDisplay, sym_return: KeySym, modifiers: int16, + buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{. + libx11c, importc: "XkbTranslateKeySym".} +proc XkbSetAutoRepeatRate*(dpy: PDisplay, deviceSpec, delay, interval: int16): bool{. + libx11c, importc: "XkbSetAutoRepeatRate".} +proc XkbGetAutoRepeatRate*(dpy: PDisplay, deviceSpec: int16, + delayRtrn, intervalRtrn: PWord): bool{.libx11c, importc: "XkbGetAutoRepeatRate".} +proc XkbChangeEnabledControls*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbChangeEnabledControls".} +proc XkbDeviceBell*(dpy: PDisplay, win: Window, + deviceSpec, bellClass, bellID, percent: int16, name: Atom): bool{. + libx11c, importc: "XkbDeviceBell".} +proc XkbForceDeviceBell*(dpy: PDisplay, + deviceSpec, bellClass, bellID, percent: int16): bool{. + libx11c, importc: "XkbForceDeviceBell".} +proc XkbDeviceBellEvent*(dpy: PDisplay, win: Window, + deviceSpec, bellClass, bellID, percent: int16, + name: Atom): bool{.libx11c, + importc: "XkbDeviceBellEvent".} +proc XkbBell*(dpy: PDisplay, win: Window, percent: int16, name: Atom): bool{. + libx11c, importc: "XkbBell".} +proc XkbForceBell*(dpy: PDisplay, percent: int16): bool{.libx11c, + importc: "XkbForceBell".} +proc XkbBellEvent*(dpy: PDisplay, win: Window, percent: int16, name: Atom): bool{. + libx11c, importc: "XkbBellEvent".} +proc XkbSelectEvents*(dpy: PDisplay, deviceID, affect, values: int16): bool{. + libx11c, importc: "XkbSelectEvents".} +proc XkbSelectEventDetails*(dpy: PDisplay, deviceID, eventType: int16, + affect, details: int32): bool{.libx11c, importc: "XkbSelectEventDetails".} +proc XkbNoteMapChanges*(old: PXkbMapChangesPtr, new: PXkbMapNotifyEvent, + wanted: int16){.libx11c, + importc: "XkbNoteMapChanges".} +proc XkbNoteNameChanges*(old: PXkbNameChangesPtr, new: PXkbNamesNotifyEvent, + wanted: int16){.libx11c, + importc: "XkbNoteNameChanges".} +proc XkbGetIndicatorState*(dpy: PDisplay, deviceSpec: int16, pStateRtrn: PWord): Status{. + libx11c, importc: "XkbGetIndicatorState".} +proc XkbGetDeviceIndicatorState*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + pStateRtrn: PWord): Status{.libx11c, importc: "XkbGetDeviceIndicatorState".} +proc XkbGetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetIndicatorMap".} +proc XkbSetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{. + libx11c, importc: "XkbSetIndicatorMap".} +proc XkbNoteIndicatorMapChanges*(o, n: PXkbIndicatorChangesPtr, w: int16) +proc XkbNoteIndicatorStateChanges*(o, n: PXkbIndicatorChangesPtr, w: int16) +proc XkbGetIndicatorMapChanges*(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): Status +proc XkbChangeIndicatorMaps*(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): bool +proc XkbGetNamedIndicator*(dpy: PDisplay, name: Atom, pNdxRtrn: ptr int16, + pStateRtrn: ptr bool, pMapRtrn: PXkbIndicatorMapPtr, + pRealRtrn: ptr bool): bool{.libx11c, + importc: "XkbGetNamedIndicator".} +proc XkbGetNamedDeviceIndicator*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + name: Atom, pNdxRtrn: ptr int16, + pStateRtrn: ptr bool, + pMapRtrn: PXkbIndicatorMapPtr, + pRealRtrn: ptr bool): bool{.libx11c, importc: "XkbGetNamedDeviceIndicator".} +proc XkbSetNamedIndicator*(dpy: PDisplay, name: Atom, + changeState, state, createNewMap: bool, + pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedIndicator".} +proc XkbSetNamedDeviceIndicator*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + name: Atom, + changeState, state, createNewMap: bool, + pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedDeviceIndicator".} +proc XkbLockModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbLockModifiers".} +proc XkbLatchModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbLatchModifiers".} +proc XkbLockGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLockGroup".} +proc XkbLatchGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLatchGroup".} +proc XkbSetServerInternalMods*(dpy: PDisplay, deviceSpec, affectReal, + realValues, affectVirtual, virtualValues: int16): bool{.libx11c, importc: "XkbSetServerInternalMods".} +proc XkbSetIgnoreLockMods*(dpy: PDisplay, deviceSpec, affectReal, realValues, + affectVirtual, virtualValues: int16): bool{.libx11c, + importc: "XkbSetIgnoreLockMods".} +proc XkbVirtualModsToReal*(dpy: PDisplay, virtual_mask: int16, mask_rtrn: PWord): bool{. + libx11c, importc: "XkbVirtualModsToReal".} +proc XkbComputeEffectiveMap*(xkb: PXkbDescPtr, theType: PXkbKeyTypePtr, + map_rtrn: PByte): bool{.libx11c, + importc: "XkbComputeEffectiveMap".} +proc XkbInitCanonicalKeyTypes*(xkb: PXkbDescPtr, which: int16, keypadVMod: int16): Status{. + libx11c, importc: "XkbInitCanonicalKeyTypes".} +proc XkbAllocKeyboard*(): PXkbDescPtr{.libx11c, + importc: "XkbAllocKeyboard".} +proc XkbFreeKeyboard*(xkb: PXkbDescPtr, which: int16, freeDesc: bool){.libx11c, importc: "XkbFreeKeyboard".} +proc XkbAllocClientMap*(xkb: PXkbDescPtr, which, nTypes: int16): Status{.libx11c, importc: "XkbAllocClientMap".} +proc XkbAllocServerMap*(xkb: PXkbDescPtr, which, nActions: int16): Status{. + libx11c, importc: "XkbAllocServerMap".} +proc XkbFreeClientMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeClientMap".} +proc XkbFreeServerMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeServerMap".} +proc XkbAddKeyType*(xkb: PXkbDescPtr, name: Atom, map_count: int16, + want_preserve: bool, num_lvls: int16): PXkbKeyTypePtr{. + libx11c, importc: "XkbAddKeyType".} +proc XkbAllocIndicatorMaps*(xkb: PXkbDescPtr): Status{.libx11c, + importc: "XkbAllocIndicatorMaps".} +proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.libx11c, + importc: "XkbFreeIndicatorMaps".} +proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.libx11c, importc: "XkbGetMap".} +proc XkbGetUpdatedMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetUpdatedMap".} +proc XkbGetMapChanges*(dpy: PDisplay, xkb: PXkbDescPtr, + changes: PXkbMapChangesPtr): Status{.libx11c, importc: "XkbGetMapChanges".} +proc XkbRefreshKeyboardMapping*(event: PXkbMapNotifyEvent): Status{.libx11c, importc: "XkbRefreshKeyboardMapping".} +proc XkbGetKeyTypes*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetKeyTypes".} +proc XkbGetKeySyms*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetKeySyms".} +proc XkbGetKeyActions*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetKeyActions".} +proc XkbGetKeyBehaviors*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): Status{.libx11c, + importc: "XkbGetKeyBehaviors".} +proc XkbGetVirtualMods*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetVirtualMods".} +proc XkbGetKeyExplicitComponents*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): Status{.libx11c, importc: "XkbGetKeyExplicitComponents".} +proc XkbGetKeyModifierMap*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): Status{.libx11c, + importc: "XkbGetKeyModifierMap".} +proc XkbAllocControls*(xkb: PXkbDescPtr, which: int16): Status{.libx11c, importc: "XkbAllocControls".} +proc XkbFreeControls*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeControls".} +proc XkbGetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetControls".} +proc XkbSetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{. + libx11c, importc: "XkbSetControls".} +proc XkbNoteControlsChanges*(old: PXkbControlsChangesPtr, + new: PXkbControlsNotifyEvent, wanted: int16){. + libx11c, importc: "XkbNoteControlsChanges".} +proc XkbGetControlsChanges*(d: PDisplay, x: PXkbDescPtr, + c: PXkbControlsChangesPtr): Status +proc XkbChangeControls*(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool +proc XkbAllocCompatMap*(xkb: PXkbDescPtr, which, nInterpret: int16): Status{. + libx11c, importc: "XkbAllocCompatMap".} +proc XkbFreeCompatMap*(xkib: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeCompatMap".} +proc XkbGetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetCompatMap".} +proc XkbSetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr, + updateActions: bool): bool{.libx11c, + importc: "XkbSetCompatMap".} +proc XkbAddSymInterpret*(xkb: PXkbDescPtr, si: PXkbSymInterpretPtr, + updateMap: bool, changes: PXkbChangesPtr): PXkbSymInterpretPtr{. + libx11c, importc: "XkbAddSymInterpret".} +proc XkbAllocNames*(xkb: PXkbDescPtr, which: int16, + nTotalRG, nTotalAliases: int16): Status{.libx11c, importc: "XkbAllocNames".} +proc XkbGetNames*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{. + libx11c, importc: "XkbGetNames".} +proc XkbSetNames*(dpy: PDisplay, which, firstType, nTypes: int16, + desc: PXkbDescPtr): bool{.libx11c, + importc: "XkbSetNames".} +proc XkbChangeNames*(dpy: PDisplay, xkb: PXkbDescPtr, + changes: PXkbNameChangesPtr): bool{.libx11c, + importc: "XkbChangeNames".} +proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeNames".} +proc XkbGetState*(dpy: PDisplay, deviceSpec: int16, rtrnState: PXkbStatePtr): Status{. + libx11c, importc: "XkbGetState".} +proc XkbSetMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): bool{.libx11c, importc: "XkbSetMap".} +proc XkbChangeMap*(dpy: PDisplay, desc: PXkbDescPtr, changes: PXkbMapChangesPtr): bool{. + libx11c, importc: "XkbChangeMap".} +proc XkbSetDetectableAutoRepeat*(dpy: PDisplay, detectable: bool, + supported: ptr bool): bool{.libx11c, importc: "XkbSetDetectableAutoRepeat".} +proc XkbGetDetectableAutoRepeat*(dpy: PDisplay, supported: ptr bool): bool{. + libx11c, importc: "XkbGetDetectableAutoRepeat".} +proc XkbSetAutoResetControls*(dpy: PDisplay, changes: int16, + auto_ctrls, auto_values: PWord): bool{.libx11c, importc: "XkbSetAutoResetControls".} +proc XkbGetAutoResetControls*(dpy: PDisplay, auto_ctrls, auto_ctrl_values: PWord): bool{. + libx11c, importc: "XkbGetAutoResetControls".} +proc XkbSetPerClientControls*(dpy: PDisplay, change: int16, values: PWord): bool{. + libx11c, importc: "XkbSetPerClientControls".} +proc XkbGetPerClientControls*(dpy: PDisplay, ctrls: PWord): bool{.libx11c, importc: "XkbGetPerClientControls".} +proc XkbCopyKeyType*(`from`, into: PXkbKeyTypePtr): Status{.libx11c, importc: "XkbCopyKeyType".} +proc XkbCopyKeyTypes*(`from`, into: PXkbKeyTypePtr, num_types: int16): Status{. + libx11c, importc: "XkbCopyKeyTypes".} +proc XkbResizeKeyType*(xkb: PXkbDescPtr, type_ndx, map_count: int16, + want_preserve: bool, new_num_lvls: int16): Status{. + libx11c, importc: "XkbResizeKeyType".} +proc XkbResizeKeySyms*(desc: PXkbDescPtr, forKey, symsNeeded: int16): PKeySym{. + libx11c, importc: "XkbResizeKeySyms".} +proc XkbResizeKeyActions*(desc: PXkbDescPtr, forKey, actsNeeded: int16): PXkbAction{. + libx11c, importc: "XkbResizeKeyActions".} +proc XkbChangeTypesOfKey*(xkb: PXkbDescPtr, key, num_groups: int16, + groups: int16, newTypes: ptr int16, + pChanges: PXkbMapChangesPtr): Status{.libx11c, importc: "XkbChangeTypesOfKey".} + +proc XkbListComponents*(dpy: PDisplay, deviceSpec: int16, + ptrns: PXkbComponentNamesPtr, max_inout: ptr int16): PXkbComponentListPtr{. + libx11c, importc: "XkbListComponents".} +proc XkbFreeComponentList*(list: PXkbComponentListPtr){.libx11c, + importc: "XkbFreeComponentList".} +proc XkbGetKeyboard*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{. + libx11c, importc: "XkbGetKeyboard".} +proc XkbGetKeyboardByName*(dpy: PDisplay, deviceSpec: int16, + names: PXkbComponentNamesPtr, want, need: int16, + load: bool): PXkbDescPtr{.libx11c, + importc: "XkbGetKeyboardByName".} + +proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr, + map_width: int16, # keyboard device + core_syms: PKeySym, # always mapWidth symbols + protected: int16, # explicit key types + types_inout: ptr int16, # always four type indices + xkb_syms_rtrn: PKeySym): int16{.libx11c, importc: "XkbKeyTypesForCoreSymbols".} + # must have enough space +proc XkbApplyCompatMapToKey*(xkb: PXkbDescPtr, + key: KeyCode, # key to be updated + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyCompatMapToKey".} + # resulting changes to map +proc XkbUpdateMapFromCore*(xkb: PXkbDescPtr, + first_key: KeyCode, # first changed key + num_keys, + map_width: int16, + core_keysyms: PKeySym, # symbols `from` core keymap + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbUpdateMapFromCore".} + +proc XkbAddDeviceLedInfo*(devi: PXkbDeviceInfoPtr, ledClass, ledId: int16): PXkbDeviceLedInfoPtr{. + libx11c, importc: "XkbAddDeviceLedInfo".} +proc XkbResizeDeviceButtonActions*(devi: PXkbDeviceInfoPtr, newTotal: int16): Status{. + libx11c, importc: "XkbResizeDeviceButtonActions".} +proc XkbAllocDeviceInfo*(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr{. + libx11c, importc: "XkbAllocDeviceInfo".} +proc XkbFreeDeviceInfo*(devi: PXkbDeviceInfoPtr, which: int16, freeDevI: bool){. + libx11c, importc: "XkbFreeDeviceInfo".} +proc XkbNoteDeviceChanges*(old: PXkbDeviceChangesPtr, + new: PXkbExtensionDeviceNotifyEvent, wanted: int16){. + libx11c, importc: "XkbNoteDeviceChanges".} +proc XkbGetDeviceInfo*(dpy: PDisplay, which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr{. + libx11c, importc: "XkbGetDeviceInfo".} +proc XkbGetDeviceInfoChanges*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + changes: PXkbDeviceChangesPtr): Status{.libx11c, importc: "XkbGetDeviceInfoChanges".} +proc XkbGetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + all: bool, first, nBtns: int16): Status{.libx11c, importc: "XkbGetDeviceButtonActions".} +proc XkbGetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + ledClass, ledId, which: int16): Status{.libx11c, importc: "XkbGetDeviceLedInfo".} +proc XkbSetDeviceInfo*(dpy: PDisplay, which: int16, devi: PXkbDeviceInfoPtr): bool{. + libx11c, importc: "XkbSetDeviceInfo".} +proc XkbChangeDeviceInfo*(dpy: PDisplay, desc: PXkbDeviceInfoPtr, + changes: PXkbDeviceChangesPtr): bool{.libx11c, importc: "XkbChangeDeviceInfo".} +proc XkbSetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + ledClass, ledID, which: int16): bool{.libx11c, importc: "XkbSetDeviceLedInfo".} +proc XkbSetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + first, nBtns: int16): bool{.libx11c, importc: "XkbSetDeviceButtonActions".} + +proc XkbToControl*(c: int8): int8{.libx11c, + importc: "XkbToControl".} + +proc XkbSetDebuggingFlags*(dpy: PDisplay, mask, flags: int16, msg: cstring, + ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool{. + libx11c, importc: "XkbSetDebuggingFlags".} +proc XkbApplyVirtualModChanges*(xkb: PXkbDescPtr, changed: int16, + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyVirtualModChanges".} + +# implementation + +proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = + ##define XkbNoteIndicatorMapChanges(o,n,w) ((o)->map_changes|=((n)->map_changes&(w))) + o.map_changes = o.map_changes or (n.map_changes and w) + +proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = + ##define XkbNoteIndicatorStateChanges(o,n,w) ((o)->state_changes|=((n)->state_changes&(w))) + o.state_changes = o.state_changes or (n.state_changes and (w)) + +proc XkbGetIndicatorMapChanges(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): Status = + ##define XkbGetIndicatorMapChanges(d,x,c) (XkbGetIndicatorMap((d),(c)->map_changes,x) + result = XkbGetIndicatorMap(d, c.map_changes, x) + +proc XkbChangeIndicatorMaps(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): bool = + ##define XkbChangeIndicatorMaps(d,x,c) (XkbSetIndicatorMap((d),(c)->map_changes,x)) + result = XkbSetIndicatorMap(d, c.map_changes, x) + +proc XkbGetControlsChanges(d: PDisplay, x: PXkbDescPtr, + c: PXkbControlsChangesPtr): Status = + ##define XkbGetControlsChanges(d,x,c) XkbGetControls(d,(c)->changed_ctrls,x) + result = XkbGetControls(d, c.changed_ctrls, x) + +proc XkbChangeControls(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool = + ##define XkbChangeControls(d,x,c) XkbSetControls(d,(c)->changed_ctrls,x) + result = XkbSetControls(d, c.changed_ctrls, x) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xlib.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xlib.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,2207 @@ + +import + x + +include "x11pragma.nim" + +type + cunsigned* = cint + Pcint* = ptr cint + PPcint* = ptr Pcint + PPcuchar* = ptr ptr cuchar + PWideChar* = ptr int16 + PPChar* = ptr cstring + PPPChar* = ptr ptr cstring + Pculong* = ptr culong + Pcuchar* = cstring + Pcuint* = ptr cuint + Pcushort* = ptr uint16 +# Automatically converted by H2Pas 0.99.15 from xlib.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xlib.h + +const + XlibSpecificationRelease* = 6 + +type + PXPointer* = ptr XPointer + XPointer* = ptr char + PBool* = ptr XBool + XBool* = cint + PStatus* = ptr Status + Status* = cint + +{.deprecated: [TXPointer: XPointer].} +{.deprecated: [TXBool: XBool].} +{.deprecated: [TStatus: Status].} + +const + QueuedAlready* = 0 + QueuedAfterReading* = 1 + QueuedAfterFlush* = 2 + +type + PPXExtData* = ptr PXExtData + PXExtData* = ptr XExtData + XExtData*{.final.} = object + number*: cint + next*: PXExtData + free_private*: proc (extension: PXExtData): cint{.cdecl.} + private_data*: XPointer + + PXExtCodes* = ptr XExtCodes + XExtCodes*{.final.} = object + extension*: cint + major_opcode*: cint + first_event*: cint + first_error*: cint + + PXPixmapFormatValues* = ptr XPixmapFormatValues + XPixmapFormatValues*{.final.} = object + depth*: cint + bits_per_pixel*: cint + scanline_pad*: cint + + PXGCValues* = ptr XGCValues + XGCValues*{.final.} = object + function*: cint + plane_mask*: culong + foreground*: culong + background*: culong + line_width*: cint + line_style*: cint + cap_style*: cint + join_style*: cint + fill_style*: cint + fill_rule*: cint + arc_mode*: cint + tile*: Pixmap + stipple*: Pixmap + ts_x_origin*: cint + ts_y_origin*: cint + font*: Font + subwindow_mode*: cint + graphics_exposures*: XBool + clip_x_origin*: cint + clip_y_origin*: cint + clip_mask*: Pixmap + dash_offset*: cint + dashes*: cchar + + PXGC* = ptr XGC + XGC*{.final.} = object + GC* = PXGC + PGC* = ptr GC + PVisual* = ptr Visual + Visual*{.final.} = object + ext_data*: PXExtData + visualid*: VisualID + c_class*: cint + red_mask*, green_mask*, blue_mask*: culong + bits_per_rgb*: cint + map_entries*: cint + + PDepth* = ptr Depth + Depth*{.final.} = object + depth*: cint + nvisuals*: cint + visuals*: PVisual + + PXDisplay* = ptr XDisplay + XDisplay*{.final.} = object + + PScreen* = ptr Screen + Screen*{.final.} = object + ext_data*: PXExtData + display*: PXDisplay + root*: Window + width*, height*: cint + mwidth*, mheight*: cint + ndepths*: cint + depths*: PDepth + root_depth*: cint + root_visual*: PVisual + default_gc*: GC + cmap*: Colormap + white_pixel*: culong + black_pixel*: culong + max_maps*, min_maps*: cint + backing_store*: cint + save_unders*: XBool + root_input_mask*: clong + + PScreenFormat* = ptr ScreenFormat + ScreenFormat*{.final.} = object + ext_data*: PXExtData + depth*: cint + bits_per_pixel*: cint + scanline_pad*: cint + + PXSetWindowAttributes* = ptr XSetWindowAttributes + XSetWindowAttributes*{.final.} = object + background_pixmap*: Pixmap + background_pixel*: culong + border_pixmap*: Pixmap + border_pixel*: culong + bit_gravity*: cint + win_gravity*: cint + backing_store*: cint + backing_planes*: culong + backing_pixel*: culong + save_under*: XBool + event_mask*: clong + do_not_propagate_mask*: clong + override_redirect*: XBool + colormap*: Colormap + cursor*: Cursor + + PXWindowAttributes* = ptr XWindowAttributes + XWindowAttributes*{.final.} = object + x*, y*: cint + width*, height*: cint + border_width*: cint + depth*: cint + visual*: PVisual + root*: Window + c_class*: cint + bit_gravity*: cint + win_gravity*: cint + backing_store*: cint + backing_planes*: culong + backing_pixel*: culong + save_under*: XBool + colormap*: Colormap + map_installed*: XBool + map_state*: cint + all_event_masks*: clong + your_event_mask*: clong + do_not_propagate_mask*: clong + override_redirect*: XBool + screen*: PScreen + + PXHostAddress* = ptr XHostAddress + XHostAddress*{.final.} = object + family*: cint + len*: cint + address*: cstring + + PXServerInterpretedAddress* = ptr XServerInterpretedAddress + XServerInterpretedAddress*{.final.} = object + typelength*: cint + valuelength*: cint + theType*: cstring + value*: cstring + + PXImage* = ptr XImage + F*{.final.} = object + create_image*: proc (para1: PXDisplay, para2: PVisual, para3: cuint, + para4: cint, para5: cint, para6: cstring, para7: cuint, + para8: cuint, para9: cint, para10: cint): PXImage{. + cdecl.} + destroy_image*: proc (para1: PXImage): cint{.cdecl.} + get_pixel*: proc (para1: PXImage, para2: cint, para3: cint): culong{.cdecl.} + put_pixel*: proc (para1: PXImage, para2: cint, para3: cint, para4: culong): cint{. + cdecl.} + sub_image*: proc (para1: PXImage, para2: cint, para3: cint, para4: cuint, + para5: cuint): PXImage{.cdecl.} + add_pixel*: proc (para1: PXImage, para2: clong): cint{.cdecl.} + + XImage*{.final.} = object + width*, height*: cint + xoffset*: cint + format*: cint + data*: cstring + byte_order*: cint + bitmap_unit*: cint + bitmap_bit_order*: cint + bitmap_pad*: cint + depth*: cint + bytes_per_line*: cint + bits_per_pixel*: cint + red_mask*: culong + green_mask*: culong + blue_mask*: culong + obdata*: XPointer + f*: F + + PXWindowChanges* = ptr XWindowChanges + XWindowChanges*{.final.} = object + x*, y*: cint + width*, height*: cint + border_width*: cint + sibling*: Window + stack_mode*: cint + + PXColor* = ptr XColor + XColor*{.final.} = object + pixel*: culong + red*, green*, blue*: cushort + flags*: cchar + pad*: cchar + + PXSegment* = ptr XSegment + XSegment*{.final.} = object + x1*, y1*, x2*, y2*: cshort + + PXPoint* = ptr XPoint + XPoint*{.final.} = object + x*, y*: cshort + + PXRectangle* = ptr XRectangle + XRectangle*{.final.} = object + x*, y*: cshort + width*, height*: cushort + + PXArc* = ptr XArc + XArc*{.final.} = object + x*, y*: cshort + width*, height*: cushort + angle1*, angle2*: cshort + + PXKeyboardControl* = ptr XKeyboardControl + XKeyboardControl*{.final.} = object + key_click_percent*: cint + bell_percent*: cint + bell_pitch*: cint + bell_duration*: cint + led*: cint + led_mode*: cint + key*: cint + auto_repeat_mode*: cint + + PXKeyboardState* = ptr XKeyboardState + XKeyboardState*{.final.} = object + key_click_percent*: cint + bell_percent*: cint + bell_pitch*, bell_duration*: cuint + led_mask*: culong + global_auto_repeat*: cint + auto_repeats*: array[0..31, cchar] + + PXTimeCoord* = ptr XTimeCoord + XTimeCoord*{.final.} = object + time*: Time + x*, y*: cshort + + PXModifierKeymap* = ptr XModifierKeymap + XModifierKeymap*{.final.} = object + max_keypermod*: cint + modifiermap*: PKeyCode + + PDisplay* = ptr Display + Display* = XDisplay + + PXPrivate* = ptr Private + Private*{.final.} = object + + PXrmHashBucketRec* = ptr XrmHashBucketRec + XrmHashBucketRec*{.final.} = object + + PXPrivDisplay* = ptr XPrivDisplay + XPrivDisplay*{.final.} = object + ext_data*: PXExtData + private1*: PXPrivate + fd*: cint + private2*: cint + proto_major_version*: cint + proto_minor_version*: cint + vendor*: cstring + private3*: XID + private4*: XID + private5*: XID + private6*: cint + resource_alloc*: proc (para1: PXDisplay): XID{.cdecl.} + byte_order*: cint + bitmap_unit*: cint + bitmap_pad*: cint + bitmap_bit_order*: cint + nformats*: cint + pixmap_format*: PScreenFormat + private8*: cint + release*: cint + private9*, private10*: PXPrivate + qlen*: cint + last_request_read*: culong + request*: culong + private11*: XPointer + private12*: XPointer + private13*: XPointer + private14*: XPointer + max_request_size*: cunsigned + db*: PXrmHashBucketRec + private15*: proc (para1: PXDisplay): cint{.cdecl.} + display_name*: cstring + default_screen*: cint + nscreens*: cint + screens*: PScreen + motion_buffer*: culong + private16*: culong + min_keycode*: cint + max_keycode*: cint + private17*: XPointer + private18*: XPointer + private19*: cint + xdefaults*: cstring + + PXKeyEvent* = ptr XKeyEvent + XKeyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + root*: Window + subwindow*: Window + time*: Time + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + keycode*: cuint + same_screen*: XBool + + PXKeyPressedEvent* = ptr XKeyPressedEvent + XKeyPressedEvent* = XKeyEvent + + PXKeyReleasedEvent* = ptr XKeyReleasedEvent + XKeyReleasedEvent* = XKeyEvent + + PXButtonEvent* = ptr XButtonEvent + XButtonEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + root*: Window + subwindow*: Window + time*: Time + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + button*: cuint + same_screen*: XBool + + PXButtonPressedEvent* = ptr XButtonPressedEvent + XButtonPressedEvent* = XButtonEvent + + PXButtonReleasedEvent* = ptr XButtonReleasedEvent + XButtonReleasedEvent* = XButtonEvent + + PXMotionEvent* = ptr XMotionEvent + XMotionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + root*: Window + subwindow*: Window + time*: Time + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + is_hint*: cchar + same_screen*: XBool + + PXPointerMovedEvent* = ptr XPointerMovedEvent + XPointerMovedEvent* = XMotionEvent + + PXCrossingEvent* = ptr XCrossingEvent + XCrossingEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + root*: Window + subwindow*: Window + time*: Time + x*, y*: cint + x_root*, y_root*: cint + mode*: cint + detail*: cint + same_screen*: XBool + focus*: XBool + state*: cuint + + PXEnterWindowEvent* = ptr XEnterWindowEvent + XEnterWindowEvent* = XCrossingEvent + + PXLeaveWindowEvent* = ptr XLeaveWindowEvent + XLeaveWindowEvent* = XCrossingEvent + + PXFocusChangeEvent* = ptr XFocusChangeEvent + XFocusChangeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + mode*: cint + detail*: cint + + PXFocusInEvent* = ptr XFocusInEvent + XFocusInEvent* = XFocusChangeEvent + + PXFocusOutEvent* = ptr XFocusOutEvent + XFocusOutEvent* = XFocusChangeEvent + + PXKeymapEvent* = ptr XKeymapEvent + XKeymapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + key_vector*: array[0..31, cchar] + + PXExposeEvent* = ptr XExposeEvent + XExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + x*, y*: cint + width*, height*: cint + count*: cint + + PXGraphicsExposeEvent* = ptr XGraphicsExposeEvent + XGraphicsExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + drawable*: Drawable + x*, y*: cint + width*, height*: cint + count*: cint + major_code*: cint + minor_code*: cint + + PXNoExposeEvent* = ptr XNoExposeEvent + XNoExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + drawable*: Drawable + major_code*: cint + minor_code*: cint + + PXVisibilityEvent* = ptr XVisibilityEvent + XVisibilityEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + state*: cint + + PXCreateWindowEvent* = ptr XCreateWindowEvent + XCreateWindowEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + parent*: Window + window*: Window + x*, y*: cint + width*, height*: cint + border_width*: cint + override_redirect*: XBool + + PXDestroyWindowEvent* = ptr XDestroyWindowEvent + XDestroyWindowEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + + PXUnmapEvent* = ptr XUnmapEvent + XUnmapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + from_configure*: XBool + + PXMapEvent* = ptr XMapEvent + XMapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + override_redirect*: XBool + + PXMapRequestEvent* = ptr XMapRequestEvent + XMapRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + parent*: Window + window*: Window + + PXReparentEvent* = ptr XReparentEvent + XReparentEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + parent*: Window + x*, y*: cint + override_redirect*: XBool + + PXConfigureEvent* = ptr XConfigureEvent + XConfigureEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + x*, y*: cint + width*, height*: cint + border_width*: cint + above*: Window + override_redirect*: XBool + + PXGravityEvent* = ptr XGravityEvent + XGravityEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + x*, y*: cint + + PXResizeRequestEvent* = ptr XResizeRequestEvent + XResizeRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + width*, height*: cint + + PXConfigureRequestEvent* = ptr XConfigureRequestEvent + XConfigureRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + parent*: Window + window*: Window + x*, y*: cint + width*, height*: cint + border_width*: cint + above*: Window + detail*: cint + value_mask*: culong + + PXCirculateEvent* = ptr XCirculateEvent + XCirculateEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + event*: Window + window*: Window + place*: cint + + PXCirculateRequestEvent* = ptr XCirculateRequestEvent + XCirculateRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + parent*: Window + window*: Window + place*: cint + + PXPropertyEvent* = ptr XPropertyEvent + XPropertyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + atom*: Atom + time*: Time + state*: cint + + PXSelectionClearEvent* = ptr XSelectionClearEvent + XSelectionClearEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + selection*: Atom + time*: Time + + PXSelectionRequestEvent* = ptr XSelectionRequestEvent + XSelectionRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + owner*: Window + requestor*: Window + selection*: Atom + target*: Atom + property*: Atom + time*: Time + + PXSelectionEvent* = ptr XSelectionEvent + XSelectionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + requestor*: Window + selection*: Atom + target*: Atom + property*: Atom + time*: Time + + PXColormapEvent* = ptr XColormapEvent + XColormapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + colormap*: Colormap + c_new*: XBool + state*: cint + + PXClientMessageEvent* = ptr XClientMessageEvent + + XClientMessageData* {.union.} = object + b*: array[20, cchar] + s*: array[10, cshort] + l*: array[5, clong] + + XClientMessageEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + message_type*: Atom + format*: cint + data*: XClientMessageData + + PXMappingEvent* = ptr XMappingEvent + XMappingEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + request*: cint + first_keycode*: cint + count*: cint + + PXErrorEvent* = ptr XErrorEvent + XErrorEvent*{.final.} = object + theType*: cint + display*: PDisplay + resourceid*: XID + serial*: culong + error_code*: cuchar + request_code*: cuchar + minor_code*: cuchar + + PXAnyEvent* = ptr XAnyEvent + XAnyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + window*: Window + + PXGenericEvent* = ptr XGenericEvent + XGenericEvent*{.final.} = object + theType*: cint ## of event. Always GenericEvent + serial*: culong ## # of last request processed + send_event*: XBool ## true if from SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## major opcode of extension that caused the event + evtype*: cint ## actual event type. + + PXGenericEventCookie* = ptr XGenericEventCookie + XGenericEventCookie*{.final.} = object + theType*: cint ## of event. Always GenericEvent + serial*: culong ## # of last request processed + send_event*: XBool ## true if from SendEvent request + display*: PDisplay ## Display the event was read from + extension*: cint ## major opcode of extension that caused the event + evtype*: cint ## actual event type. + cookie*: cuint + data*: pointer + + PXEvent* = ptr XEvent + XEvent*{.final, union.} = object + theType*: cint + xany*: XAnyEvent + xkey*: XKeyEvent + xbutton*: XButtonEvent + xmotion*: XMotionEvent + xcrossing*: XCrossingEvent + xfocus*: XFocusChangeEvent + xexpose*: XExposeEvent + xgraphicsexpose*: XGraphicsExposeEvent + xnoexpose*: XNoExposeEvent + xvisibility*: XVisibilityEvent + xcreatewindow*: XCreateWindowEvent + xdestroywindow*: XDestroyWindowEvent + xunmap*: XUnmapEvent + xmap*: XMapEvent + xmaprequest*: XMapRequestEvent + xreparent*: XReparentEvent + xconfigure*: XConfigureEvent + xgravity*: XGravityEvent + xresizerequest*: XResizeRequestEvent + xconfigurerequest*: XConfigureRequestEvent + xcirculate*: XCirculateEvent + xcirculaterequest*: XCirculateRequestEvent + xproperty*: XPropertyEvent + xselectionclear*: XSelectionClearEvent + xselectionrequest*: XSelectionRequestEvent + xselection*: XSelectionEvent + xcolormap*: XColormapEvent + xclient*: XClientMessageEvent + xmapping*: XMappingEvent + xerror*: XErrorEvent + xkeymap*: XKeymapEvent + xgeneric*: XGenericEvent + xcookie*: XGenericEventCookie + pad: array[0..23, clong] + +{.deprecated: [TXExtData: XExtData].} +{.deprecated: [TXExtCodes: XExtCodes].} +{.deprecated: [TXPixmapFormatValues: XPixmapFormatValues].} +{.deprecated: [TXGCValues: XGCValues].} +{.deprecated: [TXGC: XGC].} +{.deprecated: [TGC: GC].} +{.deprecated: [TVisual: Visual].} +{.deprecated: [TDepth: Depth].} +{.deprecated: [TXDisplay: XDisplay].} +{.deprecated: [TScreen: Screen].} +{.deprecated: [TScreenFormat: ScreenFormat].} +{.deprecated: [TXSetWindowAttributes: XSetWindowAttributes].} +{.deprecated: [TXWindowAttributes: XWindowAttributes].} +{.deprecated: [TXHostAddress: XHostAddress].} +{.deprecated: [TXServerInterpretedAddress: XServerInterpretedAddress].} +{.deprecated: [TF: F].} +{.deprecated: [TXImage: XImage].} +{.deprecated: [TXWindowChanges: XWindowChanges].} +{.deprecated: [TXColor: XColor].} +{.deprecated: [TXSegment: XSegment].} +{.deprecated: [TXPoint: XPoint].} +{.deprecated: [TXRectangle: XRectangle].} +{.deprecated: [TXArc: XArc].} +{.deprecated: [TXKeyboardControl: XKeyboardControl].} +{.deprecated: [TXKeyboardState: XKeyboardState].} +{.deprecated: [TXTimeCoord: XTimeCoord].} +{.deprecated: [TXModifierKeymap: XModifierKeymap].} +{.deprecated: [TDisplay: Display].} +{.deprecated: [TPrivate: Private].} +{.deprecated: [TXrmHashBucketRec: XrmHashBucketRec].} +{.deprecated: [TXPrivDisplay: XPrivDisplay].} +{.deprecated: [TXKeyEvent: XKeyEvent].} +{.deprecated: [TXKeyPressedEvent: XKeyPressedEvent].} +{.deprecated: [TXKeyReleasedEvent: XKeyReleasedEvent].} +{.deprecated: [TXButtonEvent: XButtonEvent].} +{.deprecated: [TXButtonPressedEvent: XButtonPressedEvent].} +{.deprecated: [TXButtonReleasedEvent: XButtonReleasedEvent].} +{.deprecated: [TXMotionEvent: XMotionEvent].} +{.deprecated: [TXPointerMovedEvent: XPointerMovedEvent].} +{.deprecated: [TXCrossingEvent: XCrossingEvent].} +{.deprecated: [TXEnterWindowEvent: XEnterWindowEvent].} +{.deprecated: [TXLeaveWindowEvent: XLeaveWindowEvent].} +{.deprecated: [TXFocusChangeEvent: XFocusChangeEvent].} +{.deprecated: [TXFocusInEvent: XFocusInEvent].} +{.deprecated: [TXFocusOutEvent: XFocusOutEvent].} +{.deprecated: [TXKeymapEvent: XKeymapEvent].} +{.deprecated: [TXExposeEvent: XExposeEvent].} +{.deprecated: [TXGraphicsExposeEvent: XGraphicsExposeEvent].} +{.deprecated: [TXNoExposeEvent: XNoExposeEvent].} +{.deprecated: [TXVisibilityEvent: XVisibilityEvent].} +{.deprecated: [TXCreateWindowEvent: XCreateWindowEvent].} +{.deprecated: [TXDestroyWindowEvent: XDestroyWindowEvent].} +{.deprecated: [TXUnmapEvent: XUnmapEvent].} +{.deprecated: [TXMapEvent: XMapEvent].} +{.deprecated: [TXMapRequestEvent: XMapRequestEvent].} +{.deprecated: [TXReparentEvent: XReparentEvent].} +{.deprecated: [TXConfigureEvent: XConfigureEvent].} +{.deprecated: [TXGravityEvent: XGravityEvent].} +{.deprecated: [TXResizeRequestEvent: XResizeRequestEvent].} +{.deprecated: [TXConfigureRequestEvent: XConfigureRequestEvent].} +{.deprecated: [TXCirculateEvent: XCirculateEvent].} +{.deprecated: [TXCirculateRequestEvent: XCirculateRequestEvent].} +{.deprecated: [TXPropertyEvent: XPropertyEvent].} +{.deprecated: [TXSelectionClearEvent: XSelectionClearEvent].} +{.deprecated: [TXSelectionRequestEvent: XSelectionRequestEvent].} +{.deprecated: [TXSelectionEvent: XSelectionEvent].} +{.deprecated: [TXColormapEvent: XColormapEvent].} +{.deprecated: [TXClientMessageData: XClientMessageData].} +{.deprecated: [TXClientMessageEvent: XClientMessageEvent].} +{.deprecated: [TXMappingEvent: XMappingEvent].} +{.deprecated: [TXErrorEvent: XErrorEvent].} +{.deprecated: [TXAnyEvent: XAnyEvent].} +{.deprecated: [TXEvent: XEvent].} + +type + PXCharStruct* = ptr XCharStruct + XCharStruct*{.final.} = object + lbearing*: cshort + rbearing*: cshort + width*: cshort + ascent*: cshort + descent*: cshort + attributes*: cushort + + PXFontProp* = ptr XFontProp + XFontProp*{.final.} = object + name*: Atom + card32*: culong + + PPPXFontStruct* = ptr PPXFontStruct + PPXFontStruct* = ptr PXFontStruct + PXFontStruct* = ptr XFontStruct + XFontStruct*{.final.} = object + ext_data*: PXExtData + fid*: Font + direction*: cunsigned + min_char_or_byte2*: cunsigned + max_char_or_byte2*: cunsigned + min_byte1*: cunsigned + max_byte1*: cunsigned + all_chars_exist*: XBool + default_char*: cunsigned + n_properties*: cint + properties*: PXFontProp + min_bounds*: XCharStruct + max_bounds*: XCharStruct + per_char*: PXCharStruct + ascent*: cint + descent*: cint + + PXTextItem* = ptr XTextItem + XTextItem*{.final.} = object + chars*: cstring + nchars*: cint + delta*: cint + font*: Font + + PXChar2b* = ptr XChar2b + XChar2b*{.final.} = object + byte1*: cuchar + byte2*: cuchar + + PXTextItem16* = ptr XTextItem16 + XTextItem16*{.final.} = object + chars*: PXChar2b + nchars*: cint + delta*: cint + font*: Font + + PXEDataObject* = ptr XEDataObject + XEDataObject*{.final.} = object + display*: PDisplay # case longint of + # 0 : ( display : PDisplay ); + # 1 : ( gc : GC ); + # 2 : ( visual : PVisual ); + # 3 : ( screen : PScreen ); + # 4 : ( pixmap_format : PScreenFormat ); + # 5 : ( font : PXFontStruct ); + + PXFontSetExtents* = ptr XFontSetExtents + XFontSetExtents*{.final.} = object + max_ink_extent*: XRectangle + max_logical_extent*: XRectangle + + PXOM* = ptr XOM + XOM*{.final.} = object + + PXOC* = ptr XOC + XOC*{.final.} = object + + PXFontSet* = ptr XFontSet + XFontSet* = PXOC + + PXmbTextItem* = ptr XmbTextItem + XmbTextItem*{.final.} = object + chars*: cstring + nchars*: cint + delta*: cint + font_set*: XFontSet + + PXwcTextItem* = ptr XwcTextItem + XwcTextItem*{.final.} = object + chars*: PWideChar #wchar_t* + nchars*: cint + delta*: cint + font_set*: XFontSet + +{.deprecated: [TXCharStruct: XCharStruct].} +{.deprecated: [TXFontProp: XFontProp].} +{.deprecated: [TXFontStruct: XFontStruct].} +{.deprecated: [TXTextItem: XTextItem].} +{.deprecated: [TXChar2b: XChar2b].} +{.deprecated: [TXTextItem16: XTextItem16].} +{.deprecated: [TXEDataObject: XEDataObject].} +{.deprecated: [TXFontSetExtents: XFontSetExtents].} +{.deprecated: [TXOM: XOM].} +{.deprecated: [TXOC: XOC].} +{.deprecated: [TXFontSet: XFontSet].} +{.deprecated: [TXmbTextItem: XmbTextItem].} +{.deprecated: [TXwcTextItem: XwcTextItem].} + +const + XNRequiredCharSet* = "requiredCharSet" + XNQueryOrientation* = "queryOrientation" + XNBaseFontName* = "baseFontName" + XNOMAutomatic* = "omAutomatic" + XNMissingCharSet* = "missingCharSet" + XNDefaultString* = "defaultString" + XNOrientation* = "orientation" + XNDirectionalDependentDrawing* = "directionalDependentDrawing" + XNContextualDrawing* = "contextualDrawing" + XNFontInfo* = "fontInfo" + +type + PXOMCharSetList* = ptr XOMCharSetList + XOMCharSetList*{.final.} = object + charset_count*: cint + charset_list*: PPChar + + PXOrientation* = ptr XOrientation + XOrientation* = enum + XOMOrientation_LTR_TTB, XOMOrientation_RTL_TTB, XOMOrientation_TTB_LTR, + XOMOrientation_TTB_RTL, XOMOrientation_Context + + PXOMOrientation* = ptr XOMOrientation + XOMOrientation*{.final.} = object + num_orientation*: cint + orientation*: PXOrientation + + PXOMFontInfo* = ptr XOMFontInfo + XOMFontInfo*{.final.} = object + num_font*: cint + font_struct_list*: ptr PXFontStruct + font_name_list*: PPChar + + XIM*{.final.} = ptr object + + XIC*{.final.} = ptr object + + XIMProc* = proc (para1: XIM, para2: XPointer, para3: XPointer){.cdecl.} + + XICProc* = proc (para1: XIC, para2: XPointer, para3: XPointer): XBool{. + cdecl.} + + XIDProc* = proc (para1: PDisplay, para2: XPointer, para3: XPointer){.cdecl.} + + PXIMStyle* = ptr XIMStyle + XIMStyle* = culong + + PXIMStyles* = ptr XIMStyles + XIMStyles*{.final.} = object + count_styles*: cushort + supported_styles*: PXIMStyle + +{.deprecated: [TXOMCharSetList: XOMCharSetList].} +{.deprecated: [TXOrientation: XOrientation].} +{.deprecated: [TXOMOrientation: XOMOrientation].} +{.deprecated: [TXOMFontInfo: XOMFontInfo].} +{.deprecated: [TXIM: XIM].} +{.deprecated: [TXIC: XIC].} +{.deprecated: [TXIMProc: XIMProc].} +{.deprecated: [TXICProc: XICProc].} +{.deprecated: [TXIDProc: XIDProc].} +{.deprecated: [TXIMStyle: XIMStyle].} +{.deprecated: [TXIMStyles: XIMStyles].} + +const + XIMPreeditArea* = 0x00000001 + XIMPreeditCallbacks* = 0x00000002 + XIMPreeditPosition* = 0x00000004 + XIMPreeditNothing* = 0x00000008 + XIMPreeditNone* = 0x00000010 + XIMStatusArea* = 0x00000100 + XIMStatusCallbacks* = 0x00000200 + XIMStatusNothing* = 0x00000400 + XIMStatusNone* = 0x00000800 + XNVaNestedList* = "XNVaNestedList" + XNQueryInputStyle* = "queryInputStyle" + XNClientWindow* = "clientWindow" + XNInputStyle* = "inputStyle" + XNFocusWindow* = "focusWindow" + XNResourceName* = "resourceName" + XNResourceClass* = "resourceClass" + XNGeometryCallback* = "geometryCallback" + XNDestroyCallback* = "destroyCallback" + XNFilterEvents* = "filterEvents" + XNPreeditStartCallback* = "preeditStartCallback" + XNPreeditDoneCallback* = "preeditDoneCallback" + XNPreeditDrawCallback* = "preeditDrawCallback" + XNPreeditCaretCallback* = "preeditCaretCallback" + XNPreeditStateNotifyCallback* = "preeditStateNotifyCallback" + XNPreeditAttributes* = "preeditAttributes" + XNStatusStartCallback* = "statusStartCallback" + XNStatusDoneCallback* = "statusDoneCallback" + XNStatusDrawCallback* = "statusDrawCallback" + XNStatusAttributes* = "statusAttributes" + XNArea* = "area" + XNAreaNeeded* = "areaNeeded" + XNSpotLocation* = "spotLocation" + XNColormap* = "colorMap" + XNStdColormap* = "stdColorMap" + XNForeground* = "foreground" + XNBackground* = "background" + XNBackgroundPixmap* = "backgroundPixmap" + XNFontSet* = "fontSet" + XNLineSpace* = "lineSpace" + XNCursor* = "cursor" + XNQueryIMValuesList* = "queryIMValuesList" + XNQueryICValuesList* = "queryICValuesList" + XNVisiblePosition* = "visiblePosition" + XNR6PreeditCallback* = "r6PreeditCallback" + XNStringConversionCallback* = "stringConversionCallback" + XNStringConversion* = "stringConversion" + XNResetState* = "resetState" + XNHotKey* = "hotKey" + XNHotKeyState* = "hotKeyState" + XNPreeditState* = "preeditState" + XNSeparatorofNestedList* = "separatorofNestedList" + XBufferOverflow* = - (1) + XLookupNone* = 1 + XLookupChars* = 2 + XLookupKeySymVal* = 3 + XLookupBoth* = 4 + +type + PXVaNestedList* = ptr XVaNestedList + XVaNestedList* = pointer + + PXIMCallback* = ptr XIMCallback + XIMCallback*{.final.} = object + client_data*: XPointer + callback*: XIMProc + + PXICCallback* = ptr XICCallback + XICCallback*{.final.} = object + client_data*: XPointer + callback*: XICProc + + PXIMFeedback* = ptr XIMFeedback + XIMFeedback* = culong + +{.deprecated: [TXVaNestedList: XVaNestedList].} +{.deprecated: [TXIMCallback: XIMCallback].} +{.deprecated: [TXICCallback: XICCallback].} +{.deprecated: [TXIMFeedback: XIMFeedback].} + +const + XIMReverse* = 1 + XIMUnderline* = 1 shl 1 + XIMHighlight* = 1 shl 2 + XIMPrimary* = 1 shl 5 + XIMSecondary* = 1 shl 6 + XIMTertiary* = 1 shl 7 + XIMVisibleToForward* = 1 shl 8 + XIMVisibleToBackword* = 1 shl 9 + XIMVisibleToCenter* = 1 shl 10 + +type + PXIMText* = ptr XIMText + XIMText*{.final.} = object + len*: cushort + feedback*: PXIMFeedback + encoding_is_wchar*: XBool + multi_byte*: cstring + + PXIMPreeditState* = ptr XIMPreeditState + XIMPreeditState* = culong + +{.deprecated: [TXIMText: XIMText].} +{.deprecated: [TXIMPreeditState: XIMPreeditState].} + +const + XIMPreeditUnKnown* = 0 + XIMPreeditEnable* = 1 + XIMPreeditDisable* = 1 shl 1 + +type + PXIMPreeditStateNotifyCallbackStruct* = ptr XIMPreeditStateNotifyCallbackStruct + XIMPreeditStateNotifyCallbackStruct*{.final.} = object + state*: XIMPreeditState + + PXIMResetState* = ptr XIMResetState + XIMResetState* = culong + +{.deprecated: [TXIMPreeditStateNotifyCallbackStruct: XIMPreeditStateNotifyCallbackStruct].} +{.deprecated: [TXIMResetState: XIMResetState].} + +const + XIMInitialState* = 1 + XIMPreserveState* = 1 shl 1 + +type + PXIMStringConversionFeedback* = ptr XIMStringConversionFeedback + XIMStringConversionFeedback* = culong + +{.deprecated: [TXIMStringConversionFeedback: XIMStringConversionFeedback].} + +const + XIMStringConversionLeftEdge* = 0x00000001 + XIMStringConversionRightEdge* = 0x00000002 + XIMStringConversionTopEdge* = 0x00000004 + XIMStringConversionBottomEdge* = 0x00000008 + XIMStringConversionConcealed* = 0x00000010 + XIMStringConversionWrapped* = 0x00000020 + +type + PXIMStringConversionText* = ptr XIMStringConversionText + XIMStringConversionText*{.final.} = object + len*: cushort + feedback*: PXIMStringConversionFeedback + encoding_is_wchar*: XBool + mbs*: cstring + + PXIMStringConversionPosition* = ptr XIMStringConversionPosition + XIMStringConversionPosition* = cushort + + PXIMStringConversionType* = ptr XIMStringConversionType + XIMStringConversionType* = cushort + +{.deprecated: [TXIMStringConversionText: XIMStringConversionText].} +{.deprecated: [TXIMStringConversionPosition: XIMStringConversionPosition].} +{.deprecated: [TXIMStringConversionType: XIMStringConversionType].} + +const + XIMStringConversionBuffer* = 0x00000001 + XIMStringConversionLine* = 0x00000002 + XIMStringConversionWord* = 0x00000003 + XIMStringConversionChar* = 0x00000004 + +type + PXIMStringConversionOperation* = ptr XIMStringConversionOperation + XIMStringConversionOperation* = cushort + +{.deprecated: [TXIMStringConversionOperation: XIMStringConversionOperation].} + +const + XIMStringConversionSubstitution* = 0x00000001 + XIMStringConversionRetrieval* = 0x00000002 + +type + PXIMCaretDirection* = ptr XIMCaretDirection + XIMCaretDirection* = enum + XIMForwardChar, XIMBackwardChar, XIMForwardWord, XIMBackwardWord, + XIMCaretUp, XIMCaretDown, XIMNextLine, XIMPreviousLine, XIMLineStart, + XIMLineEnd, XIMAbsolutePosition, XIMDontChange + + PXIMStringConversionCallbackStruct* = ptr XIMStringConversionCallbackStruct + XIMStringConversionCallbackStruct*{.final.} = object + position*: XIMStringConversionPosition + direction*: XIMCaretDirection + operation*: XIMStringConversionOperation + factor*: cushort + text*: PXIMStringConversionText + + PXIMPreeditDrawCallbackStruct* = ptr XIMPreeditDrawCallbackStruct + XIMPreeditDrawCallbackStruct*{.final.} = object + caret*: cint + chg_first*: cint + chg_length*: cint + text*: PXIMText + + PXIMCaretStyle* = ptr XIMCaretStyle + XIMCaretStyle* = enum + XIMIsInvisible, XIMIsPrimary, XIMIsSecondary + + PXIMPreeditCaretCallbackStruct* = ptr XIMPreeditCaretCallbackStruct + XIMPreeditCaretCallbackStruct*{.final.} = object + position*: cint + direction*: XIMCaretDirection + style*: XIMCaretStyle + + PXIMStatusDataType* = ptr XIMStatusDataType + XIMStatusDataType* = enum + XIMTextType, XIMBitmapType + + PXIMStatusDrawCallbackStruct* = ptr XIMStatusDrawCallbackStruct + XIMStatusDrawCallbackStruct*{.final.} = object + theType*: XIMStatusDataType + bitmap*: Pixmap + + PXIMHotKeyTrigger* = ptr XIMHotKeyTrigger + XIMHotKeyTrigger*{.final.} = object + keysym*: KeySym + modifier*: cint + modifier_mask*: cint + + PXIMHotKeyTriggers* = ptr XIMHotKeyTriggers + XIMHotKeyTriggers*{.final.} = object + num_hot_key*: cint + key*: PXIMHotKeyTrigger + + PXIMHotKeyState* = ptr XIMHotKeyState + XIMHotKeyState* = culong + +{.deprecated: [TXIMCaretDirection: XIMCaretDirection].} +{.deprecated: [TXIMStringConversionCallbackStruct: XIMStringConversionCallbackStruct].} +{.deprecated: [TXIMPreeditDrawCallbackStruct: XIMPreeditDrawCallbackStruct].} +{.deprecated: [TXIMCaretStyle: XIMCaretStyle].} +{.deprecated: [TXIMPreeditCaretCallbackStruct: XIMPreeditCaretCallbackStruct].} +{.deprecated: [TXIMStatusDataType: XIMStatusDataType].} +{.deprecated: [TXIMStatusDrawCallbackStruct: XIMStatusDrawCallbackStruct].} +{.deprecated: [TXIMHotKeyTrigger: XIMHotKeyTrigger].} +{.deprecated: [TXIMHotKeyTriggers: XIMHotKeyTriggers].} +{.deprecated: [TXIMHotKeyState: XIMHotKeyState].} + +const + XIMHotKeyStateON* = 0x00000001 + XIMHotKeyStateOFF* = 0x00000002 + +type + PXIMValuesList* = ptr XIMValuesList + XIMValuesList*{.final.} = object + count_values*: cushort + supported_values*: PPChar + +{.deprecated: [TXIMValuesList: XIMValuesList].} + + +type + funcdisp* = proc (display: PDisplay): cint{.cdecl.} + funcifevent* = proc (display: PDisplay, event: PXEvent, p: XPointer): XBool{. + cdecl.} + chararr32* = array[0..31, char] + +const + AllPlanes*: culong = not culong(0) + +proc XLoadQueryFont*(para1: PDisplay, para2: cstring): PXFontStruct{.libx11.} +proc XQueryFont*(para1: PDisplay, para2: XID): PXFontStruct{.libx11.} +proc XGetMotionEvents*(para1: PDisplay, para2: Window, para3: Time, + para4: Time, para5: Pcint): PXTimeCoord{.libx11.} +proc XDeleteModifiermapEntry*(para1: PXModifierKeymap, para2: KeyCode, + para3: cint): PXModifierKeymap{.libx11.} +proc XGetModifierMapping*(para1: PDisplay): PXModifierKeymap{.libx11.} +proc XInsertModifiermapEntry*(para1: PXModifierKeymap, para2: KeyCode, + para3: cint): PXModifierKeymap{.libx11.} +proc XNewModifiermap*(para1: cint): PXModifierKeymap{.libx11.} +proc XCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, para4: cint, + para5: cint, para6: cstring, para7: cuint, para8: cuint, + para9: cint, para10: cint): PXImage{.libx11.} +proc XInitImage*(para1: PXImage): Status{.libx11.} +proc XGetImage*(para1: PDisplay, para2: Drawable, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: culong, para8: cint): PXImage{. + libx11.} +proc XGetSubImage*(para1: PDisplay, para2: Drawable, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: culong, para8: cint, + para9: PXImage, para10: cint, para11: cint): PXImage{.libx11.} +proc XOpenDisplay*(para1: cstring): PDisplay{.libx11.} +proc XrmInitialize*(){.libx11.} +proc XFetchBytes*(para1: PDisplay, para2: Pcint): cstring{.libx11.} +proc XFetchBuffer*(para1: PDisplay, para2: Pcint, para3: cint): cstring{.libx11.} +proc XGetAtomName*(para1: PDisplay, para2: Atom): cstring{.libx11.} +proc XGetAtomNames*(para1: PDisplay, para2: PAtom, para3: cint, para4: PPchar): Status{. + libx11.} +proc XGetDefault*(para1: PDisplay, para2: cstring, para3: cstring): cstring{. + libx11.} +proc XDisplayName*(para1: cstring): cstring{.libx11.} +proc XKeysymToString*(para1: KeySym): cstring{.libx11.} +proc XSynchronize*(para1: PDisplay, para2: XBool): funcdisp{.libx11.} +proc XSetAfterFunction*(para1: PDisplay, para2: funcdisp): funcdisp{.libx11.} +proc XInternAtom*(para1: PDisplay, para2: cstring, para3: XBool): Atom{.libx11.} +proc XInternAtoms*(para1: PDisplay, para2: PPchar, para3: cint, para4: XBool, + para5: PAtom): Status{.libx11.} +proc XCopyColormapAndFree*(para1: PDisplay, para2: Colormap): Colormap{.libx11.} +proc XCreateColormap*(para1: PDisplay, para2: Window, para3: PVisual, + para4: cint): Colormap{.libx11.} +proc XCreatePixmapCursor*(para1: PDisplay, para2: Pixmap, para3: Pixmap, + para4: PXColor, para5: PXColor, para6: cuint, + para7: cuint): Cursor{.libx11.} +proc XCreateGlyphCursor*(para1: PDisplay, para2: Font, para3: Font, + para4: cuint, para5: cuint, para6: PXColor, + para7: PXColor): Cursor{.libx11.} +proc XCreateFontCursor*(para1: PDisplay, para2: cuint): Cursor{.libx11.} +proc XLoadFont*(para1: PDisplay, para2: cstring): Font{.libx11.} +proc XCreateGC*(para1: PDisplay, para2: Drawable, para3: culong, + para4: PXGCValues): GC{.libx11.} +proc XGContextFromGC*(para1: GC): GContext{.libx11.} +proc XFlushGC*(para1: PDisplay, para2: GC){.libx11.} +proc XCreatePixmap*(para1: PDisplay, para2: Drawable, para3: cuint, + para4: cuint, para5: cuint): Pixmap{.libx11.} +proc XCreateBitmapFromData*(para1: PDisplay, para2: Drawable, para3: cstring, + para4: cuint, para5: cuint): Pixmap{.libx11.} +proc XCreatePixmapFromBitmapData*(para1: PDisplay, para2: Drawable, + para3: cstring, para4: cuint, para5: cuint, + para6: culong, para7: culong, para8: cuint): Pixmap{. + libx11.} +proc XCreateSimpleWindow*(para1: PDisplay, para2: Window, para3: cint, + para4: cint, para5: cuint, para6: cuint, para7: cuint, + para8: culong, para9: culong): Window{.libx11.} +proc XGetSelectionOwner*(para1: PDisplay, para2: Atom): Window{.libx11.} +proc XCreateWindow*(para1: PDisplay, para2: Window, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: cuint, para8: cint, + para9: cuint, para10: PVisual, para11: culong, + para12: PXSetWindowAttributes): Window{.libx11.} +proc XListInstalledColormaps*(para1: PDisplay, para2: Window, para3: Pcint): PColormap{. + libx11.} +proc XListFonts*(para1: PDisplay, para2: cstring, para3: cint, para4: Pcint): PPChar{. + libx11.} +proc XListFontsWithInfo*(para1: PDisplay, para2: cstring, para3: cint, + para4: Pcint, para5: PPXFontStruct): PPChar{.libx11.} +proc XGetFontPath*(para1: PDisplay, para2: Pcint): PPChar{.libx11.} +proc XListExtensions*(para1: PDisplay, para2: Pcint): PPChar{.libx11.} +proc XListProperties*(para1: PDisplay, para2: Window, para3: Pcint): PAtom{. + libx11.} +proc XListHosts*(para1: PDisplay, para2: Pcint, para3: PBool): PXHostAddress{. + libx11.} +proc XKeycodeToKeysym*(para1: PDisplay, para2: KeyCode, para3: cint): KeySym{. + libx11.} +proc XLookupKeysym*(para1: PXKeyEvent, para2: cint): KeySym{.libx11.} +proc XGetKeyboardMapping*(para1: PDisplay, para2: KeyCode, para3: cint, + para4: Pcint): PKeySym{.libx11.} +proc XStringToKeysym*(para1: cstring): KeySym{.libx11.} +proc XMaxRequestSize*(para1: PDisplay): clong{.libx11.} +proc XExtendedMaxRequestSize*(para1: PDisplay): clong{.libx11.} +proc XResourceManagerString*(para1: PDisplay): cstring{.libx11.} +proc XScreenResourceString*(para1: PScreen): cstring{.libx11.} +proc XDisplayMotionBufferSize*(para1: PDisplay): culong{.libx11.} +proc XVisualIDFromVisual*(para1: PVisual): VisualID{.libx11.} +proc XInitThreads*(): Status{.libx11.} +proc XLockDisplay*(para1: PDisplay){.libx11.} +proc XUnlockDisplay*(para1: PDisplay){.libx11.} +proc XInitExtension*(para1: PDisplay, para2: cstring): PXExtCodes{.libx11.} +proc XAddExtension*(para1: PDisplay): PXExtCodes{.libx11.} +proc XFindOnExtensionList*(para1: PPXExtData, para2: cint): PXExtData{.libx11.} +proc XEHeadOfExtensionList*(para1: XEDataObject): PPXExtData{.libx11.} +proc XRootWindow*(para1: PDisplay, para2: cint): Window{.libx11.} +proc XDefaultRootWindow*(para1: PDisplay): Window{.libx11.} +proc XRootWindowOfScreen*(para1: PScreen): Window{.libx11.} +proc XDefaultVisual*(para1: PDisplay, para2: cint): PVisual{.libx11.} +proc XDefaultVisualOfScreen*(para1: PScreen): PVisual{.libx11.} +proc XDefaultGC*(para1: PDisplay, para2: cint): GC{.libx11.} +proc XDefaultGCOfScreen*(para1: PScreen): GC{.libx11.} +proc XBlackPixel*(para1: PDisplay, para2: cint): culong{.libx11.} +proc XWhitePixel*(para1: PDisplay, para2: cint): culong{.libx11.} +proc XAllPlanes*(): culong{.libx11.} +proc XBlackPixelOfScreen*(para1: PScreen): culong{.libx11.} +proc XWhitePixelOfScreen*(para1: PScreen): culong{.libx11.} +proc XNextRequest*(para1: PDisplay): culong{.libx11.} +proc XLastKnownRequestProcessed*(para1: PDisplay): culong{.libx11.} +proc XServerVendor*(para1: PDisplay): cstring{.libx11.} +proc XDisplayString*(para1: PDisplay): cstring{.libx11.} +proc XDefaultColormap*(para1: PDisplay, para2: cint): Colormap{.libx11.} +proc XDefaultColormapOfScreen*(para1: PScreen): Colormap{.libx11.} +proc XDisplayOfScreen*(para1: PScreen): PDisplay{.libx11.} +proc XScreenOfDisplay*(para1: PDisplay, para2: cint): PScreen{.libx11.} +proc XDefaultScreenOfDisplay*(para1: PDisplay): PScreen{.libx11.} +proc XEventMaskOfScreen*(para1: PScreen): clong{.libx11.} +proc XScreenNumberOfScreen*(para1: PScreen): cint{.libx11.} + +type + XErrorHandler* = proc (para1: PDisplay, para2: PXErrorEvent): cint{.cdecl.} +{.deprecated: [TXErrorHandler: XErrorHandler].} + +proc XSetErrorHandler*(para1: XErrorHandler): XErrorHandler{.libx11.} +type + XIOErrorHandler* = proc (para1: PDisplay): cint{.cdecl.} +{.deprecated: [TXIOErrorHandler: XIOErrorHandler].} + +proc XSetIOErrorHandler*(para1: XIOErrorHandler): XIOErrorHandler{.libx11.} +proc XListPixmapFormats*(para1: PDisplay, para2: Pcint): PXPixmapFormatValues{. + libx11.} +proc XListDepths*(para1: PDisplay, para2: cint, para3: Pcint): Pcint{.libx11.} +proc XReconfigureWMWindow*(para1: PDisplay, para2: Window, para3: cint, + para4: cuint, para5: PXWindowChanges): Status{. + libx11.} +proc XGetWMProtocols*(para1: PDisplay, para2: Window, para3: PPAtom, + para4: Pcint): Status{.libx11.} +proc XSetWMProtocols*(para1: PDisplay, para2: Window, para3: PAtom, para4: cint): Status{. + libx11.} +proc XIconifyWindow*(para1: PDisplay, para2: Window, para3: cint): Status{. + libx11.} +proc XWithdrawWindow*(para1: PDisplay, para2: Window, para3: cint): Status{. + libx11.} +proc XGetCommand*(para1: PDisplay, para2: Window, para3: PPPchar, para4: Pcint): Status{. + libx11.} +proc XGetWMColormapWindows*(para1: PDisplay, para2: Window, para3: PPWindow, + para4: Pcint): Status{.libx11.} +proc XSetWMColormapWindows*(para1: PDisplay, para2: Window, para3: PWindow, + para4: cint): Status{.libx11.} +proc XFreeStringList*(para1: PPchar){.libx11.} +proc XSetTransientForHint*(para1: PDisplay, para2: Window, para3: Window): cint{. + libx11.} +proc XActivateScreenSaver*(para1: PDisplay): cint{.libx11.} +proc XAddHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.} +proc XAddHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{. + libx11.} +proc XAddToExtensionList*(para1: PPXExtData, para2: PXExtData): cint{.libx11.} +proc XAddToSaveSet*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XAllocColor*(para1: PDisplay, para2: Colormap, para3: PXColor): Status{. + libx11.} +proc XAllocColorCells*(para1: PDisplay, para2: Colormap, para3: XBool, + para4: Pculong, para5: cuint, para6: Pculong, + para7: cuint): Status{.libx11.} +proc XAllocColorPlanes*(para1: PDisplay, para2: Colormap, para3: XBool, + para4: Pculong, para5: cint, para6: cint, para7: cint, + para8: cint, para9: Pculong, para10: Pculong, + para11: Pculong): Status{.libx11.} +proc XAllocNamedColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: PXColor, para5: PXColor): Status{.libx11.} +proc XAllowEvents*(para1: PDisplay, para2: cint, para3: Time): cint{.libx11.} +proc XAutoRepeatOff*(para1: PDisplay): cint{.libx11.} +proc XAutoRepeatOn*(para1: PDisplay): cint{.libx11.} +proc XBell*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XBitmapBitOrder*(para1: PDisplay): cint{.libx11.} +proc XBitmapPad*(para1: PDisplay): cint{.libx11.} +proc XBitmapUnit*(para1: PDisplay): cint{.libx11.} +proc XCellsOfScreen*(para1: PScreen): cint{.libx11.} +proc XChangeActivePointerGrab*(para1: PDisplay, para2: cuint, para3: Cursor, + para4: Time): cint{.libx11.} +proc XChangeGC*(para1: PDisplay, para2: GC, para3: culong, para4: PXGCValues): cint{. + libx11.} +proc XChangeKeyboardControl*(para1: PDisplay, para2: culong, + para3: PXKeyboardControl): cint{.libx11.} +proc XChangeKeyboardMapping*(para1: PDisplay, para2: cint, para3: cint, + para4: PKeySym, para5: cint): cint{.libx11.} +proc XChangePointerControl*(para1: PDisplay, para2: XBool, para3: XBool, + para4: cint, para5: cint, para6: cint): cint{.libx11.} +proc XChangeProperty*(para1: PDisplay, para2: Window, para3: Atom, + para4: Atom, para5: cint, para6: cint, para7: Pcuchar, + para8: cint): cint{.libx11.} +proc XChangeSaveSet*(para1: PDisplay, para2: Window, para3: cint): cint{.libx11.} +proc XChangeWindowAttributes*(para1: PDisplay, para2: Window, para3: culong, + para4: PXSetWindowAttributes): cint{.libx11.} +proc XCheckIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: XPointer): XBool{.libx11.} +proc XCheckMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): XBool{. + libx11.} +proc XCheckTypedEvent*(para1: PDisplay, para2: cint, para3: PXEvent): XBool{. + libx11.} +proc XCheckTypedWindowEvent*(para1: PDisplay, para2: Window, para3: cint, + para4: PXEvent): XBool{.libx11.} +proc XCheckWindowEvent*(para1: PDisplay, para2: Window, para3: clong, + para4: PXEvent): XBool{.libx11.} +proc XCirculateSubwindows*(para1: PDisplay, para2: Window, para3: cint): cint{. + libx11.} +proc XCirculateSubwindowsDown*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XCirculateSubwindowsUp*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XClearArea*(para1: PDisplay, para2: Window, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: XBool): cint{.libx11.} +proc XClearWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XCloseDisplay*(para1: PDisplay): cint{.libx11.} +proc XConfigureWindow*(para1: PDisplay, para2: Window, para3: cuint, + para4: PXWindowChanges): cint{.libx11.} +proc XConnectionNumber*(para1: PDisplay): cint{.libx11.} +proc XConvertSelection*(para1: PDisplay, para2: Atom, para3: Atom, + para4: Atom, para5: Window, para6: Time): cint{. + libx11.} +proc XCopyArea*(para1: PDisplay, para2: Drawable, para3: Drawable, para4: GC, + para5: cint, para6: cint, para7: cuint, para8: cuint, + para9: cint, para10: cint): cint{.libx11.} +proc XCopyGC*(para1: PDisplay, para2: GC, para3: culong, para4: GC): cint{. + libx11.} +proc XCopyPlane*(para1: PDisplay, para2: Drawable, para3: Drawable, + para4: GC, para5: cint, para6: cint, para7: cuint, + para8: cuint, para9: cint, para10: cint, para11: culong): cint{. + libx11.} +proc XDefaultDepth*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDefaultDepthOfScreen*(para1: PScreen): cint{.libx11.} +proc XDefaultScreen*(para1: PDisplay): cint{.libx11.} +proc XDefineCursor*(para1: PDisplay, para2: Window, para3: Cursor): cint{. + libx11.} +proc XDeleteProperty*(para1: PDisplay, para2: Window, para3: Atom): cint{. + libx11.} +proc XDestroyWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XDestroySubwindows*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XDoesBackingStore*(para1: PScreen): cint{.libx11.} +proc XDoesSaveUnders*(para1: PScreen): XBool{.libx11.} +proc XDisableAccessControl*(para1: PDisplay): cint{.libx11.} +proc XDisplayCells*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayHeight*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayHeightMM*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayKeycodes*(para1: PDisplay, para2: Pcint, para3: Pcint): cint{. + libx11.} +proc XDisplayPlanes*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayWidth*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayWidthMM*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDrawArc*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{. + libx11.} +proc XDrawArcs*(para1: PDisplay, para2: Drawable, para3: GC, para4: PXArc, + para5: cint): cint{.libx11.} +proc XDrawImageString*(para1: PDisplay, para2: Drawable, para3: GC, + para4: cint, para5: cint, para6: cstring, para7: cint): cint{. + libx11.} +proc XDrawImageString16*(para1: PDisplay, para2: Drawable, para3: GC, + para4: cint, para5: cint, para6: PXChar2b, para7: cint): cint{. + libx11.} +proc XDrawLine*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cint, para7: cint): cint{.libx11.} +proc XDrawLines*(para1: PDisplay, para2: Drawable, para3: GC, para4: PXPoint, + para5: cint, para6: cint): cint{.libx11.} +proc XDrawPoint*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint): cint{.libx11.} +proc XDrawPoints*(para1: PDisplay, para2: Drawable, para3: GC, para4: PXPoint, + para5: cint, para6: cint): cint{.libx11.} +proc XDrawRectangle*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cuint, para7: cuint): cint{.libx11.} +proc XDrawRectangles*(para1: PDisplay, para2: Drawable, para3: GC, + para4: PXRectangle, para5: cint): cint{.libx11.} +proc XDrawSegments*(para1: PDisplay, para2: Drawable, para3: GC, + para4: PXSegment, para5: cint): cint{.libx11.} +proc XDrawString*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cstring, para7: cint): cint{.libx11.} +proc XDrawString16*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXChar2b, para7: cint): cint{.libx11.} +proc XDrawText*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXTextItem, para7: cint): cint{.libx11.} +proc XDrawText16*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXTextItem16, para7: cint): cint{.libx11.} +proc XEnableAccessControl*(para1: PDisplay): cint{.libx11.} +proc XEventsQueued*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XFetchName*(para1: PDisplay, para2: Window, para3: PPchar): Status{. + libx11.} +proc XFillArc*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{. + libx11.} +proc XFillArcs*(para1: PDisplay, para2: Drawable, para3: GC, para4: PXArc, + para5: cint): cint{.libx11.} +proc XFillPolygon*(para1: PDisplay, para2: Drawable, para3: GC, + para4: PXPoint, para5: cint, para6: cint, para7: cint): cint{. + libx11.} +proc XFillRectangle*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: cuint, para7: cuint): cint{.libx11.} +proc XFillRectangles*(para1: PDisplay, para2: Drawable, para3: GC, + para4: PXRectangle, para5: cint): cint{.libx11.} +proc XFlush*(para1: PDisplay): cint{.libx11.} +proc XForceScreenSaver*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XFree*(para1: pointer): cint{.libx11.} +proc XFreeColormap*(para1: PDisplay, para2: Colormap): cint{.libx11.} +proc XFreeColors*(para1: PDisplay, para2: Colormap, para3: Pculong, + para4: cint, para5: culong): cint{.libx11.} +proc XFreeCursor*(para1: PDisplay, para2: Cursor): cint{.libx11.} +proc XFreeExtensionList*(para1: PPchar): cint{.libx11.} +proc XFreeFont*(para1: PDisplay, para2: PXFontStruct): cint{.libx11.} +proc XFreeFontInfo*(para1: PPchar, para2: PXFontStruct, para3: cint): cint{. + libx11.} +proc XFreeFontNames*(para1: PPchar): cint{.libx11.} +proc XFreeFontPath*(para1: PPchar): cint{.libx11.} +proc XFreeGC*(para1: PDisplay, para2: GC): cint{.libx11.} +proc XFreeModifiermap*(para1: PXModifierKeymap): cint{.libx11.} +proc XFreePixmap*(para1: PDisplay, para2: Pixmap): cint{.libx11.} +proc XGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, + para5: cuint, para6: cuint, para7: cuint, para8: cint, + para9: cint, para10: Pcint, para11: Pcint, para12: Pcint, + para13: Pcint): cint{.libx11.} +proc XGetErrorDatabaseText*(para1: PDisplay, para2: cstring, para3: cstring, + para4: cstring, para5: cstring, para6: cint): cint{. + libx11.} +proc XGetErrorText*(para1: PDisplay, para2: cint, para3: cstring, para4: cint): cint{. + libx11.} +proc XGetFontProperty*(para1: PXFontStruct, para2: Atom, para3: Pculong): XBool{. + libx11.} +proc XGetGCValues*(para1: PDisplay, para2: GC, para3: culong, para4: PXGCValues): Status{. + libx11.} +proc XGetGeometry*(para1: PDisplay, para2: Drawable, para3: PWindow, + para4: Pcint, para5: Pcint, para6: Pcuint, para7: Pcuint, + para8: Pcuint, para9: Pcuint): Status{.libx11.} +proc XGetIconName*(para1: PDisplay, para2: Window, para3: PPchar): Status{. + libx11.} +proc XGetInputFocus*(para1: PDisplay, para2: PWindow, para3: Pcint): cint{. + libx11.} +proc XGetKeyboardControl*(para1: PDisplay, para2: PXKeyboardState): cint{.libx11.} +proc XGetPointerControl*(para1: PDisplay, para2: Pcint, para3: Pcint, + para4: Pcint): cint{.libx11.} +proc XGetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{. + libx11.} +proc XGetScreenSaver*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: Pcint, + para5: Pcint): cint{.libx11.} +proc XGetTransientForHint*(para1: PDisplay, para2: Window, para3: PWindow): Status{. + libx11.} +proc XGetWindowProperty*(para1: PDisplay, para2: Window, para3: Atom, + para4: clong, para5: clong, para6: XBool, para7: Atom, + para8: PAtom, para9: Pcint, para10: Pculong, + para11: Pculong, para12: PPcuchar): cint{.libx11.} +proc XGetWindowAttributes*(para1: PDisplay, para2: Window, + para3: PXWindowAttributes): Status{.libx11.} +proc XGrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: Window, + para5: XBool, para6: cuint, para7: cint, para8: cint, + para9: Window, para10: Cursor): cint{.libx11.} +proc XGrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: Window, + para5: XBool, para6: cint, para7: cint): cint{.libx11.} +proc XGrabKeyboard*(para1: PDisplay, para2: Window, para3: XBool, para4: cint, + para5: cint, para6: Time): cint{.libx11.} +proc XGrabPointer*(para1: PDisplay, para2: Window, para3: XBool, para4: cuint, + para5: cint, para6: cint, para7: Window, para8: Cursor, + para9: Time): cint{.libx11.} +proc XGrabServer*(para1: PDisplay): cint{.libx11.} +proc XHeightMMOfScreen*(para1: PScreen): cint{.libx11.} +proc XHeightOfScreen*(para1: PScreen): cint{.libx11.} +proc XIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: XPointer): cint{.libx11.} +proc XImageByteOrder*(para1: PDisplay): cint{.libx11.} +proc XInstallColormap*(para1: PDisplay, para2: Colormap): cint{.libx11.} +proc XKeysymToKeycode*(para1: PDisplay, para2: KeySym): KeyCode{.libx11.} +proc XKillClient*(para1: PDisplay, para2: XID): cint{.libx11.} +proc XLookupColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: PXColor, para5: PXColor): Status{.libx11.} +proc XLowerWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XMapRaised*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XMapSubwindows*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XMapWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): cint{.libx11.} +proc XMaxCmapsOfScreen*(para1: PScreen): cint{.libx11.} +proc XMinCmapsOfScreen*(para1: PScreen): cint{.libx11.} +proc XMoveResizeWindow*(para1: PDisplay, para2: Window, para3: cint, + para4: cint, para5: cuint, para6: cuint): cint{.libx11.} +proc XMoveWindow*(para1: PDisplay, para2: Window, para3: cint, para4: cint): cint{. + libx11.} +proc XNextEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XNoOp*(para1: PDisplay): cint{.libx11.} +proc XParseColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: PXColor): Status{.libx11.} +proc XParseGeometry*(para1: cstring, para2: Pcint, para3: Pcint, para4: Pcuint, + para5: Pcuint): cint{.libx11.} +proc XPeekEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XPeekIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: XPointer): cint{.libx11.} +proc XPending*(para1: PDisplay): cint{.libx11.} +proc XPlanesOfScreen*(para1: PScreen): cint{.libx11.} +proc XProtocolRevision*(para1: PDisplay): cint{.libx11.} +proc XProtocolVersion*(para1: PDisplay): cint{.libx11.} +proc XPutBackEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XPutImage*(para1: PDisplay, para2: Drawable, para3: GC, para4: PXImage, + para5: cint, para6: cint, para7: cint, para8: cint, + para9: cuint, para10: cuint): cint{.libx11.} +proc XQLength*(para1: PDisplay): cint{.libx11.} +proc XQueryBestCursor*(para1: PDisplay, para2: Drawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): Status{. + libx11.} +proc XQueryBestSize*(para1: PDisplay, para2: cint, para3: Drawable, + para4: cuint, para5: cuint, para6: Pcuint, para7: Pcuint): Status{. + libx11.} +proc XQueryBestStipple*(para1: PDisplay, para2: Drawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): Status{. + libx11.} +proc XQueryBestTile*(para1: PDisplay, para2: Drawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): Status{. + libx11.} +proc XQueryColor*(para1: PDisplay, para2: Colormap, para3: PXColor): cint{. + libx11.} +proc XQueryColors*(para1: PDisplay, para2: Colormap, para3: PXColor, + para4: cint): cint{.libx11.} +proc XQueryExtension*(para1: PDisplay, para2: cstring, para3: Pcint, + para4: Pcint, para5: Pcint): XBool{.libx11.} + #? +proc XQueryKeymap*(para1: PDisplay, para2: chararr32): cint{.libx11.} +proc XQueryPointer*(para1: PDisplay, para2: Window, para3: PWindow, + para4: PWindow, para5: Pcint, para6: Pcint, para7: Pcint, + para8: Pcint, para9: Pcuint): XBool{.libx11.} +proc XQueryTextExtents*(para1: PDisplay, para2: XID, para3: cstring, + para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, + para8: PXCharStruct): cint{.libx11.} +proc XQueryTextExtents16*(para1: PDisplay, para2: XID, para3: PXChar2b, + para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, + para8: PXCharStruct): cint{.libx11.} +proc XQueryTree*(para1: PDisplay, para2: Window, para3: PWindow, + para4: PWindow, para5: PPWindow, para6: Pcuint): Status{. + libx11.} +proc XRaiseWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XReadBitmapFile*(para1: PDisplay, para2: Drawable, para3: cstring, + para4: Pcuint, para5: Pcuint, para6: PPixmap, + para7: Pcint, para8: Pcint): cint{.libx11.} +proc XReadBitmapFileData*(para1: cstring, para2: Pcuint, para3: Pcuint, + para4: PPcuchar, para5: Pcint, para6: Pcint): cint{. + libx11.} +proc XRebindKeysym*(para1: PDisplay, para2: KeySym, para3: PKeySym, + para4: cint, para5: Pcuchar, para6: cint): cint{.libx11.} +proc XRecolorCursor*(para1: PDisplay, para2: Cursor, para3: PXColor, + para4: PXColor): cint{.libx11.} +proc XRefreshKeyboardMapping*(para1: PXMappingEvent): cint{.libx11.} +proc XRemoveFromSaveSet*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XRemoveHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.} +proc XRemoveHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{. + libx11.} +proc XReparentWindow*(para1: PDisplay, para2: Window, para3: Window, + para4: cint, para5: cint): cint{.libx11.} +proc XResetScreenSaver*(para1: PDisplay): cint{.libx11.} +proc XResizeWindow*(para1: PDisplay, para2: Window, para3: cuint, para4: cuint): cint{. + libx11.} +proc XRestackWindows*(para1: PDisplay, para2: PWindow, para3: cint): cint{. + libx11.} +proc XRotateBuffers*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XRotateWindowProperties*(para1: PDisplay, para2: Window, para3: PAtom, + para4: cint, para5: cint): cint{.libx11.} +proc XScreenCount*(para1: PDisplay): cint{.libx11.} +proc XSelectInput*(para1: PDisplay, para2: Window, para3: clong): cint{.libx11.} +proc XSendEvent*(para1: PDisplay, para2: Window, para3: XBool, para4: clong, + para5: PXEvent): Status{.libx11.} +proc XSetAccessControl*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XSetArcMode*(para1: PDisplay, para2: GC, para3: cint): cint{.libx11.} +proc XSetBackground*(para1: PDisplay, para2: GC, para3: culong): cint{.libx11.} +proc XSetClipMask*(para1: PDisplay, para2: GC, para3: Pixmap): cint{.libx11.} +proc XSetClipOrigin*(para1: PDisplay, para2: GC, para3: cint, para4: cint): cint{. + libx11.} +proc XSetClipRectangles*(para1: PDisplay, para2: GC, para3: cint, para4: cint, + para5: PXRectangle, para6: cint, para7: cint): cint{. + libx11.} +proc XSetCloseDownMode*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XSetCommand*(para1: PDisplay, para2: Window, para3: PPchar, para4: cint): cint{. + libx11.} +proc XSetDashes*(para1: PDisplay, para2: GC, para3: cint, para4: cstring, + para5: cint): cint{.libx11.} +proc XSetFillRule*(para1: PDisplay, para2: GC, para3: cint): cint{.libx11.} +proc XSetFillStyle*(para1: PDisplay, para2: GC, para3: cint): cint{.libx11.} +proc XSetFont*(para1: PDisplay, para2: GC, para3: Font): cint{.libx11.} +proc XSetFontPath*(para1: PDisplay, para2: PPchar, para3: cint): cint{.libx11.} +proc XSetForeground*(para1: PDisplay, para2: GC, para3: culong): cint{.libx11.} +proc XSetFunction*(para1: PDisplay, para2: GC, para3: cint): cint{.libx11.} +proc XSetGraphicsExposures*(para1: PDisplay, para2: GC, para3: XBool): cint{. + libx11.} +proc XSetIconName*(para1: PDisplay, para2: Window, para3: cstring): cint{. + libx11.} +proc XSetInputFocus*(para1: PDisplay, para2: Window, para3: cint, para4: Time): cint{. + libx11.} +proc XSetLineAttributes*(para1: PDisplay, para2: GC, para3: cuint, para4: cint, + para5: cint, para6: cint): cint{.libx11.} +proc XSetModifierMapping*(para1: PDisplay, para2: PXModifierKeymap): cint{. + libx11.} +proc XSetPlaneMask*(para1: PDisplay, para2: GC, para3: culong): cint{.libx11.} +proc XSetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{. + libx11.} +proc XSetScreenSaver*(para1: PDisplay, para2: cint, para3: cint, para4: cint, + para5: cint): cint{.libx11.} +proc XSetSelectionOwner*(para1: PDisplay, para2: Atom, para3: Window, + para4: Time): cint{.libx11.} +proc XSetState*(para1: PDisplay, para2: GC, para3: culong, para4: culong, + para5: cint, para6: culong): cint{.libx11.} +proc XSetStipple*(para1: PDisplay, para2: GC, para3: Pixmap): cint{.libx11.} +proc XSetSubwindowMode*(para1: PDisplay, para2: GC, para3: cint): cint{.libx11.} +proc XSetTSOrigin*(para1: PDisplay, para2: GC, para3: cint, para4: cint): cint{. + libx11.} +proc XSetTile*(para1: PDisplay, para2: GC, para3: Pixmap): cint{.libx11.} +proc XSetWindowBackground*(para1: PDisplay, para2: Window, para3: culong): cint{. + libx11.} +proc XSetWindowBackgroundPixmap*(para1: PDisplay, para2: Window, para3: Pixmap): cint{. + libx11.} +proc XSetWindowBorder*(para1: PDisplay, para2: Window, para3: culong): cint{. + libx11.} +proc XSetWindowBorderPixmap*(para1: PDisplay, para2: Window, para3: Pixmap): cint{. + libx11.} +proc XSetWindowBorderWidth*(para1: PDisplay, para2: Window, para3: cuint): cint{. + libx11.} +proc XSetWindowColormap*(para1: PDisplay, para2: Window, para3: Colormap): cint{. + libx11.} +proc XStoreBuffer*(para1: PDisplay, para2: cstring, para3: cint, para4: cint): cint{. + libx11.} +proc XStoreBytes*(para1: PDisplay, para2: cstring, para3: cint): cint{.libx11.} +proc XStoreColor*(para1: PDisplay, para2: Colormap, para3: PXColor): cint{. + libx11.} +proc XStoreColors*(para1: PDisplay, para2: Colormap, para3: PXColor, + para4: cint): cint{.libx11.} +proc XStoreName*(para1: PDisplay, para2: Window, para3: cstring): cint{.libx11.} +proc XStoreNamedColor*(para1: PDisplay, para2: Colormap, para3: cstring, + para4: culong, para5: cint): cint{.libx11.} +proc XSync*(para1: PDisplay, para2: XBool): cint{.libx11.} +proc XTextExtents*(para1: PXFontStruct, para2: cstring, para3: cint, + para4: Pcint, para5: Pcint, para6: Pcint, para7: PXCharStruct): cint{. + libx11.} +proc XTextExtents16*(para1: PXFontStruct, para2: PXChar2b, para3: cint, + para4: Pcint, para5: Pcint, para6: Pcint, + para7: PXCharStruct): cint{.libx11.} +proc XTextWidth*(para1: PXFontStruct, para2: cstring, para3: cint): cint{.libx11.} +proc XTextWidth16*(para1: PXFontStruct, para2: PXChar2b, para3: cint): cint{. + libx11.} +proc XTranslateCoordinates*(para1: PDisplay, para2: Window, para3: Window, + para4: cint, para5: cint, para6: Pcint, + para7: Pcint, para8: PWindow): XBool{.libx11.} +proc XUndefineCursor*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XUngrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: Window): cint{. + libx11.} +proc XUngrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: Window): cint{. + libx11.} +proc XUngrabKeyboard*(para1: PDisplay, para2: Time): cint{.libx11.} +proc XUngrabPointer*(para1: PDisplay, para2: Time): cint{.libx11.} +proc XUngrabServer*(para1: PDisplay): cint{.libx11.} +proc XUninstallColormap*(para1: PDisplay, para2: Colormap): cint{.libx11.} +proc XUnloadFont*(para1: PDisplay, para2: Font): cint{.libx11.} +proc XUnmapSubwindows*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XUnmapWindow*(para1: PDisplay, para2: Window): cint{.libx11.} +proc XVendorRelease*(para1: PDisplay): cint{.libx11.} +proc XWarpPointer*(para1: PDisplay, para2: Window, para3: Window, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, + para9: cint): cint{.libx11.} +proc XWidthMMOfScreen*(para1: PScreen): cint{.libx11.} +proc XWidthOfScreen*(para1: PScreen): cint{.libx11.} +proc XWindowEvent*(para1: PDisplay, para2: Window, para3: clong, para4: PXEvent): cint{. + libx11.} +proc XWriteBitmapFile*(para1: PDisplay, para2: cstring, para3: Pixmap, + para4: cuint, para5: cuint, para6: cint, para7: cint): cint{. + libx11.} +proc XSupportsLocale*(): XBool{.libx11.} +proc XSetLocaleModifiers*(para1: cstring): cstring{.libx11.} +proc XOpenOM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, + para4: cstring): XOM{.libx11.} +proc XCloseOM*(para1: XOM): Status{.libx11.} +proc XSetOMValues*(para1: XOM): cstring{.varargs, libx11.} +proc XGetOMValues*(para1: XOM): cstring{.varargs, libx11.} +proc XDisplayOfOM*(para1: XOM): PDisplay{.libx11.} +proc XLocaleOfOM*(para1: XOM): cstring{.libx11.} +proc XCreateOC*(para1: XOM): XOC{.varargs, libx11.} +proc XDestroyOC*(para1: XOC){.libx11.} +proc XOMOfOC*(para1: XOC): XOM{.libx11.} +proc XSetOCValues*(para1: XOC): cstring{.varargs, libx11.} +proc XGetOCValues*(para1: XOC): cstring{.varargs, libx11.} +proc XCreateFontSet*(para1: PDisplay, para2: cstring, para3: PPPchar, + para4: Pcint, para5: PPchar): XFontSet{.libx11.} +proc XFreeFontSet*(para1: PDisplay, para2: XFontSet){.libx11.} +proc XFontsOfFontSet*(para1: XFontSet, para2: PPPXFontStruct, para3: PPPchar): cint{. + libx11.} +proc XBaseFontNameListOfFontSet*(para1: XFontSet): cstring{.libx11.} +proc XLocaleOfFontSet*(para1: XFontSet): cstring{.libx11.} +proc XContextDependentDrawing*(para1: XFontSet): XBool{.libx11.} +proc XDirectionalDependentDrawing*(para1: XFontSet): XBool{.libx11.} +proc XContextualDrawing*(para1: XFontSet): XBool{.libx11.} +proc XExtentsOfFontSet*(para1: XFontSet): PXFontSetExtents{.libx11.} +proc XmbTextEscapement*(para1: XFontSet, para2: cstring, para3: cint): cint{. + libx11.} +proc XwcTextEscapement*(para1: XFontSet, para2: PWideChar, para3: cint): cint{. + libx11.} +proc Xutf8TextEscapement*(para1: XFontSet, para2: cstring, para3: cint): cint{. + libx11.} +proc XmbTextExtents*(para1: XFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc XwcTextExtents*(para1: XFontSet, para2: PWideChar, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc Xutf8TextExtents*(para1: XFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc XmbTextPerCharExtents*(para1: XFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle, para6: cint, + para7: Pcint, para8: PXRectangle, para9: PXRectangle): Status{. + libx11.} +proc XwcTextPerCharExtents*(para1: XFontSet, para2: PWideChar, para3: cint, + para4: PXRectangle, para5: PXRectangle, para6: cint, + para7: Pcint, para8: PXRectangle, para9: PXRectangle): Status{. + libx11.} +proc Xutf8TextPerCharExtents*(para1: XFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle, + para6: cint, para7: Pcint, para8: PXRectangle, + para9: PXRectangle): Status{.libx11.} +proc XmbDrawText*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXmbTextItem, para7: cint){.libx11.} +proc XwcDrawText*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXwcTextItem, para7: cint){.libx11.} +proc Xutf8DrawText*(para1: PDisplay, para2: Drawable, para3: GC, para4: cint, + para5: cint, para6: PXmbTextItem, para7: cint){.libx11.} +proc XmbDrawString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XwcDrawString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: PWideChar, + para8: cint){.libx11.} +proc Xutf8DrawString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XmbDrawImageString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XwcDrawImageString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: PWideChar, + para8: cint){.libx11.} +proc Xutf8DrawImageString*(para1: PDisplay, para2: Drawable, para3: XFontSet, + para4: GC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XOpenIM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, + para4: cstring): XIM{.libx11.} +proc XCloseIM*(para1: XIM): Status{.libx11.} +proc XGetIMValues*(para1: XIM): cstring{.varargs, libx11.} +proc XSetIMValues*(para1: XIM): cstring{.varargs, libx11.} +proc XDisplayOfIM*(para1: XIM): PDisplay{.libx11.} +proc XLocaleOfIM*(para1: XIM): cstring{.libx11.} +proc XCreateIC*(para1: XIM): XIC{.varargs, libx11.} +proc XDestroyIC*(para1: XIC){.libx11.} +proc XSetICFocus*(para1: XIC){.libx11.} +proc XUnsetICFocus*(para1: XIC){.libx11.} +proc XwcResetIC*(para1: XIC): PWideChar{.libx11.} +proc XmbResetIC*(para1: XIC): cstring{.libx11.} +proc Xutf8ResetIC*(para1: XIC): cstring{.libx11.} +proc XSetICValues*(para1: XIC): cstring{.varargs, libx11.} +proc XGetICValues*(para1: XIC): cstring{.varargs, libx11.} +proc XIMOfIC*(para1: XIC): XIM{.libx11.} +proc XFilterEvent*(para1: PXEvent, para2: Window): XBool{.libx11.} +proc XmbLookupString*(para1: XIC, para2: PXKeyPressedEvent, para3: cstring, + para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.} +proc XwcLookupString*(para1: XIC, para2: PXKeyPressedEvent, para3: PWideChar, + para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.} +proc Xutf8LookupString*(para1: XIC, para2: PXKeyPressedEvent, para3: cstring, + para4: cint, para5: PKeySym, para6: PStatus): cint{. + libx11.} +proc XVaCreateNestedList*(unused: cint): XVaNestedList{.varargs, libx11.} +proc XRegisterIMInstantiateCallback*(para1: PDisplay, para2: PXrmHashBucketRec, + para3: cstring, para4: cstring, + para5: XIDProc, para6: XPointer): XBool{. + libx11.} +proc XUnregisterIMInstantiateCallback*(para1: PDisplay, + para2: PXrmHashBucketRec, para3: cstring, + para4: cstring, para5: XIDProc, + para6: XPointer): XBool{.libx11.} +type + XConnectionWatchProc* = proc (para1: PDisplay, para2: XPointer, para3: cint, + para4: XBool, para5: PXPointer){.cdecl.} +{.deprecated: [TXConnectionWatchProc: XConnectionWatchProc].} + +proc XInternalConnectionNumbers*(para1: PDisplay, para2: PPcint, para3: Pcint): Status{. + libx11.} +proc XProcessInternalConnection*(para1: PDisplay, para2: cint){.libx11.} +proc XAddConnectionWatch*(para1: PDisplay, para2: XConnectionWatchProc, + para3: XPointer): Status{.libx11.} +proc XRemoveConnectionWatch*(para1: PDisplay, para2: XConnectionWatchProc, + para3: XPointer){.libx11.} +proc XSetAuthorization*(para1: cstring, para2: cint, para3: cstring, para4: cint){. + libx11.} + # + # _Xmbtowc? + # _Xwctomb? + # +proc XGetEventData*(para1: PDisplay, para2: PXGenericEventCookie): XBool {.libX11.} +proc XFreeEventData*(para1: PDisplay, para2: PXGenericEventCookie) {.libX11.} +#when defined(MACROS): +proc ConnectionNumber*(dpy: PDisplay): cint +proc RootWindow*(dpy: PDisplay, scr: cint): Window +proc DefaultScreen*(dpy: PDisplay): cint +proc DefaultRootWindow*(dpy: PDisplay): Window +proc DefaultVisual*(dpy: PDisplay, scr: cint): PVisual +proc DefaultGC*(dpy: PDisplay, scr: cint): GC +proc BlackPixel*(dpy: PDisplay, scr: cint): culong +proc WhitePixel*(dpy: PDisplay, scr: cint): culong +proc QLength*(dpy: PDisplay): cint +proc DisplayWidth*(dpy: PDisplay, scr: cint): cint +proc DisplayHeight*(dpy: PDisplay, scr: cint): cint +proc DisplayWidthMM*(dpy: PDisplay, scr: cint): cint +proc DisplayHeightMM*(dpy: PDisplay, scr: cint): cint +proc DisplayPlanes*(dpy: PDisplay, scr: cint): cint +proc DisplayCells*(dpy: PDisplay, scr: cint): cint +proc ScreenCount*(dpy: PDisplay): cint +proc ServerVendor*(dpy: PDisplay): cstring +proc ProtocolVersion*(dpy: PDisplay): cint +proc ProtocolRevision*(dpy: PDisplay): cint +proc VendorRelease*(dpy: PDisplay): cint +proc DisplayString*(dpy: PDisplay): cstring +proc DefaultDepth*(dpy: PDisplay, scr: cint): cint +proc DefaultColormap*(dpy: PDisplay, scr: cint): Colormap +proc BitmapUnit*(dpy: PDisplay): cint +proc BitmapBitOrder*(dpy: PDisplay): cint +proc BitmapPad*(dpy: PDisplay): cint +proc ImageByteOrder*(dpy: PDisplay): cint +proc NextRequest*(dpy: PDisplay): culong +proc LastKnownRequestProcessed*(dpy: PDisplay): culong +proc ScreenOfDisplay*(dpy: PDisplay, scr: cint): PScreen +proc DefaultScreenOfDisplay*(dpy: PDisplay): PScreen +proc DisplayOfScreen*(s: PScreen): PDisplay +proc RootWindowOfScreen*(s: PScreen): Window +proc BlackPixelOfScreen*(s: PScreen): culong +proc WhitePixelOfScreen*(s: PScreen): culong +proc DefaultColormapOfScreen*(s: PScreen): Colormap +proc DefaultDepthOfScreen*(s: PScreen): cint +proc DefaultGCOfScreen*(s: PScreen): GC +proc DefaultVisualOfScreen*(s: PScreen): PVisual +proc WidthOfScreen*(s: PScreen): cint +proc HeightOfScreen*(s: PScreen): cint +proc WidthMMOfScreen*(s: PScreen): cint +proc HeightMMOfScreen*(s: PScreen): cint +proc PlanesOfScreen*(s: PScreen): cint +proc CellsOfScreen*(s: PScreen): cint +proc MinCmapsOfScreen*(s: PScreen): cint +proc MaxCmapsOfScreen*(s: PScreen): cint +proc DoesSaveUnders*(s: PScreen): XBool +proc DoesBackingStore*(s: PScreen): cint +proc EventMaskOfScreen*(s: PScreen): clong +proc XAllocID*(dpy: PDisplay): XID +# implementation + +#when defined(MACROS): +template privDisp : untyped = cast[PXPrivDisplay](dpy) + +proc ConnectionNumber(dpy: PDisplay): cint = + privDisp.fd + +proc RootWindow(dpy: PDisplay, scr: cint): Window = + ScreenOfDisplay(dpy, scr).root + +proc DefaultScreen(dpy: PDisplay): cint = + privDisp.default_screen + +proc DefaultRootWindow(dpy: PDisplay): Window = + ScreenOfDisplay(dpy, DefaultScreen(dpy)).root + +proc DefaultVisual(dpy: PDisplay, scr: cint): PVisual = + ScreenOfDisplay(dpy, scr).root_visual + +proc DefaultGC(dpy: PDisplay, scr: cint): GC = + ScreenOfDisplay(dpy, scr).default_gc + +proc BlackPixel(dpy: PDisplay, scr: cint): culong = + ScreenOfDisplay(dpy, scr).black_pixel + +proc WhitePixel(dpy: PDisplay, scr: cint): culong = + ScreenOfDisplay(dpy, scr).white_pixel + +proc QLength(dpy: PDisplay): cint = + privDisp.qlen + +proc DisplayWidth(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).width + +proc DisplayHeight(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).height + +proc DisplayWidthMM(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).mwidth + +proc DisplayHeightMM(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).mheight + +proc DisplayPlanes(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).root_depth + +proc DisplayCells(dpy: PDisplay, scr: cint): cint = + DefaultVisual(dpy, scr).map_entries + +proc ScreenCount(dpy: PDisplay): cint = + privDisp.nscreens + +proc ServerVendor(dpy: PDisplay): cstring = + privDisp.vendor + +proc ProtocolVersion(dpy: PDisplay): cint = + privDisp.proto_major_version + +proc ProtocolRevision(dpy: PDisplay): cint = + privDisp.proto_minor_version + +proc VendorRelease(dpy: PDisplay): cint = + privDisp.release + +proc DisplayString(dpy: PDisplay): cstring = + privDisp.display_name + +proc DefaultDepth(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).root_depth + +proc DefaultColormap(dpy: PDisplay, scr: cint): Colormap = + ScreenOfDisplay(dpy, scr).cmap + +proc BitmapUnit(dpy: PDisplay): cint = + privDisp.bitmap_unit + +proc BitmapBitOrder(dpy: PDisplay): cint = + privDisp.bitmap_bit_order + +proc BitmapPad(dpy: PDisplay): cint = + privDisp.bitmap_pad + +proc ImageByteOrder(dpy: PDisplay): cint = + privDisp.byte_order + +proc NextRequest(dpy: PDisplay): culong = + privDisp.request + 1.culong + +proc LastKnownRequestProcessed(dpy: PDisplay): culong = + privDisp.last_request_read + +# from fowltek/pointer_arithm, required for ScreenOfDisplay() +proc offset[A] (some: ptr A; b: int): ptr A = + cast[ptr A](cast[int](some) + (b * sizeof(A))) +proc ScreenOfDisplay(dpy: PDisplay, scr: cint): PScreen = + #addr(((privDisp.screens)[scr])) + privDisp.screens.offset(scr.int) + +proc DefaultScreenOfDisplay(dpy: PDisplay): PScreen = + ScreenOfDisplay(dpy, DefaultScreen(dpy)) + +proc DisplayOfScreen(s: PScreen): PDisplay = + s.display + +proc RootWindowOfScreen(s: PScreen): Window = + s.root + +proc BlackPixelOfScreen(s: PScreen): culong = + s.black_pixel + +proc WhitePixelOfScreen(s: PScreen): culong = + s.white_pixel + +proc DefaultColormapOfScreen(s: PScreen): Colormap = + s.cmap + +proc DefaultDepthOfScreen(s: PScreen): cint = + s.root_depth + +proc DefaultGCOfScreen(s: PScreen): GC = + s.default_gc + +proc DefaultVisualOfScreen(s: PScreen): PVisual = + s.root_visual + +proc WidthOfScreen(s: PScreen): cint = + s.width + +proc HeightOfScreen(s: PScreen): cint = + s.height + +proc WidthMMOfScreen(s: PScreen): cint = + s.mwidth + +proc HeightMMOfScreen(s: PScreen): cint = + s.mheight + +proc PlanesOfScreen(s: PScreen): cint = + s.root_depth + +proc CellsOfScreen(s: PScreen): cint = + DefaultVisualOfScreen(s).map_entries + +proc MinCmapsOfScreen(s: PScreen): cint = + s.min_maps + +proc MaxCmapsOfScreen(s: PScreen): cint = + s.max_maps + +proc DoesSaveUnders(s: PScreen): XBool = + s.save_unders + +proc DoesBackingStore(s: PScreen): cint = + s.backing_store + +proc EventMaskOfScreen(s: PScreen): clong = + s.root_input_mask + +proc XAllocID(dpy: PDisplay): XID = + privDisp.resource_alloc(dpy) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xrandr.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xrandr.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,290 @@ +# +# $XFree86: xc/lib/Xrandr/Xrandr.h,v 1.9 2002/09/29 23:39:44 keithp Exp $ +# +# Copyright (C) 2000 Compaq Computer Corporation, Inc. +# Copyright (C) 2002 Hewlett-Packard Company, Inc. +# +# Permission to use, copy, modify, distribute, and sell this software and its +# documentation for any purpose is hereby granted without fee, provided that +# the above copyright notice appear in all copies and that both that +# copyright notice and this permission notice appear in supporting +# documentation, and that the name of Compaq not be used in advertising or +# publicity pertaining to distribution of the software without specific, +# written prior permission. HP makes no representations about the +# suitability of this software for any purpose. It is provided "as is" +# without express or implied warranty. +# +# HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL COMPAQ +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +# Author: Jim Gettys, HP Labs, HP. +# + +import + x, xlib + +const + libXrandr* = "libXrandr.so(.2|)" + +# * $XFree86: xc/include/extensions/randr.h,v 1.4 2001/11/24 07:24:58 keithp Exp $ +# * +# * Copyright (C) 2000, Compaq Computer Corporation, +# * Copyright (C) 2002, Hewlett Packard, Inc. +# * +# * Permission to use, copy, modify, distribute, and sell this software and its +# * documentation for any purpose is hereby granted without fee, provided that +# * the above copyright notice appear in all copies and that both that +# * copyright notice and this permission notice appear in supporting +# * documentation, and that the name of Compaq or HP not be used in advertising +# * or publicity pertaining to distribution of the software without specific, +# * written prior permission. HP makes no representations about the +# * suitability of this software for any purpose. It is provided "as is" +# * without express or implied warranty. +# * +# * HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +# * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL HP +# * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +# * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# * +# * Author: Jim Gettys, HP Labs, Hewlett-Packard, Inc. +# * + +type + PRotation* = ptr Rotation + Rotation* = cushort + + PSizeID* = ptr SizeID + SizeID* = cushort + + PSubpixelOrder* = ptr SubpixelOrder + SubpixelOrder* = cushort + + PRRCrtc* = ptr RRCrtc + RRCrtc* = XID + + PRROutput* = ptr RROutput + RROutput* = XID + + PRRMode* = ptr RRMode + RRMode* = XID + + PXRRModeFlags* = ptr XRRModeFlags + XRRModeFlags* = culong + + PConnection* = ptr Connection + Connection* = cushort + +{.deprecated: [TRotation: Rotation].} +{.deprecated: [TSizeID: SizeID].} +{.deprecated: [TSubpixelOrder: SubpixelOrder].} +{.deprecated: [TRRCrtc: RRCrtc].} +{.deprecated: [TRROutput: RROutput].} +{.deprecated: [TRRMode: RRMode].} +{.deprecated: [TXRRModeFlags: XRRModeFlags].} +{.deprecated: [TConnection: Connection].} + +const + RANDR_NAME* = "RANDR" + RANDR_MAJOR* = 1 + RANDR_MINOR* = 1 + RRNumberErrors* = 0 + RRNumberEvents* = 1 + constX_RRQueryVersion* = 0 # we skip 1 to make old clients fail pretty immediately + X_RROldGetScreenInfo* = 1 + X_RR1_0SetScreenConfig* = 2 # V1.0 apps share the same set screen config request id + constX_RRSetScreenConfig* = 2 + X_RROldScreenChangeSelectInput* = 3 # 3 used to be ScreenChangeSelectInput; deprecated + constX_RRSelectInput* = 4 + constX_RRGetScreenInfo* = 5 # used in XRRSelectInput + RRScreenChangeNotifyMask* = 1 shl 0 + RRScreenChangeNotify* = 0 # used in the rotation field; rotation and reflection in 0.1 proto. + RR_Rotate_0* = 1 + RR_Rotate_90* = 2 + RR_Rotate_180* = 4 + RR_Rotate_270* = 8 # new in 1.0 protocol, to allow reflection of screen + RR_Reflect_X* = 16 + RR_Reflect_Y* = 32 + RRSetConfigSuccess* = 0 + RRSetConfigInvalidConfigTime* = 1 + RRSetConfigInvalidTime* = 2 + RRSetConfigFailed* = 3 + RR_Connected* = 0 + RR_Disconnected* = 1 + RR_UnknownConnection* = 2 + +type + PXRRScreenSize* = ptr XRRScreenSize + XRRScreenSize*{.final.} = object # + # Events. + # + width*, height*: cint + mwidth*, mheight*: cint + + XRRScreenChangeNotifyEvent*{.final.} = object # internal representation is private to the library + typ*: cint # event base + serial*: culong # # of last request processed by server + send_event*: XBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + window*: Window # window which selected for this event + root*: Window # Root window for changed screen + timestamp*: Time # when the screen change occurred + config_timestamp*: Time # when the last configuration change + size_index*: SizeID + subpixel_order*: SubpixelOrder + rotation*: Rotation + width*: cint + height*: cint + mwidth*: cint + mheight*: cint + + PXRRScreenConfiguration* = ptr XRRScreenConfiguration + XRRScreenConfiguration* {.final.} = object + + PXRRModeInfo* = ptr XRRModeInfo + XRRModeInfo* {.final.} = object + id*: RRMode + width*, height*: cuint + dotClock*: culong + hSyncStart*, hSyncEnd*, hTotal*, hSkew*: cuint + vSyncStart*, vSyncEnd*, vTotal*: cuint + name*: cstring + nameLength*: cuint + modeFlags*: XRRModeFlags + + PXRRScreenResources* = ptr XRRScreenResources + XRRScreenResources* {.final.} = object + timestamp*, configTimestamp*: Time + ncrtc*: cint + crtcs*: ptr UncheckedArray[RRCrtc] + noutput*: cint + outputs*: ptr UncheckedArray[RROutput] + nmode*: cint + modes*: ptr UncheckedArray[XRRModeInfo] + + PXRROutputInfo* = ptr XRROutputInfo + XRROutputInfo* {.final.} = object + timestamp*: Time + crtc*: RRCrtc + name*: cstring + nameLen*: cint + mmWidth*, mmHeight*: culong + connection*: Connection + subpixelOrder*: SubpixelOrder + ncrtc*: cint + crtcs*: ptr UncheckedArray[RRCrtc] + nclone*: cint + clones*: ptr UncheckedArray[RROutput] + nmode*, npreferred*: cint + modes*: ptr UncheckedArray[RRMode] + + PXRRPropertyInfo* = ptr XRRPropertyInfo + XRRPropertyInfo* {.final.} = object + pending, range, immutable: bool + numValues: cint + values: ptr UncheckedArray[clong] + + RandrFormat* = enum + randrFormat16bit = 16, randrFormat32bit = 32 + +{.deprecated: [TXRRScreenSize: XRRScreenSize].} +{.deprecated: [TXRRScreenChangeNotifyEvent: XRRScreenChangeNotifyEvent].} +{.deprecated: [TXRRScreenConfiguration: XRRScreenConfiguration].} +{.deprecated: [TXRRModeInfo: XRRModeInfo].} +{.deprecated: [TXRRScreenResources: XRRScreenResources].} +{.deprecated: [TXRROutputInfo: XRROutputInfo].} +{.deprecated: [TXRRPropertyInfo: XRRPropertyInfo].} + +proc XRRQueryExtension*(dpy: PDisplay, event_basep, error_basep: Pcint): XBool{. + cdecl, dynlib: libXrandr, importc.} +proc XRRQueryVersion*(dpy: PDisplay, major_versionp: Pcint, + minor_versionp: Pcint): Status{.cdecl, dynlib: libXrandr, + importc.} +proc XRRQueryOutputProperty*(dpy: PDisplay, output: RROutput, property: Atom): + PXRRPropertyInfo {.cdecl, dynlib: libXrandr, importc.} +proc XRRChangeOutputProperty*(dpy: PDisplay, output: RROutput, + property, kind: Atom, format, mode: cint, data: ptr cuchar, nelements: cint) {. + cdecl, dynlib: libXrandr, importc.} +proc XRRGetScreenInfo*(dpy: PDisplay, draw: Drawable): PXRRScreenConfiguration{. + cdecl, dynlib: libXrandr, importc.} +proc XRRFreeScreenConfigInfo*(config: PXRRScreenConfiguration){.cdecl, + dynlib: libXrandr, importc.} + # + # Note that screen configuration changes are only permitted if the client can + # prove it has up to date configuration information. We are trying to + # insist that it become possible for screens to change dynamically, so + # we want to ensure the client knows what it is talking about when requesting + # changes. + # +proc XRRSetScreenConfig*(dpy: PDisplay, config: PXRRScreenConfiguration, + draw: Drawable, size_index: cint, rotation: Rotation, + timestamp: Time): Status{.cdecl, dynlib: libXrandr, + importc.} + # added in v1.1, sorry for the lame name +proc XRRSetScreenConfigAndRate*(dpy: PDisplay, config: PXRRScreenConfiguration, + draw: Drawable, size_index: cint, + rotation: Rotation, rate: cshort, + timestamp: Time): Status{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigRotations*(config: PXRRScreenConfiguration, + current_rotation: PRotation): Rotation{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigTimes*(config: PXRRScreenConfiguration, config_timestamp: PTime): Time{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfigSizes*(config: PXRRScreenConfiguration, nsizes: Pcint): PXRRScreenSize{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfigRates*(config: PXRRScreenConfiguration, sizeID: cint, + nrates: Pcint): ptr int16{.cdecl, dynlib: libXrandr, importc.} +proc XRRConfigCurrentConfiguration*(config: PXRRScreenConfiguration, + rotation: PRotation): SizeID{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigCurrentRate*(config: PXRRScreenConfiguration): cshort{.cdecl, + dynlib: libXrandr, importc.} +proc XRRRootToScreen*(dpy: PDisplay, root: Window): cint{.cdecl, + dynlib: libXrandr, importc.} + # + # returns the screen configuration for the specified screen; does a lazy + # evalution to delay getting the information, and caches the result. + # These routines should be used in preference to XRRGetScreenInfo + # to avoid unneeded round trips to the X server. These are new + # in protocol version 0.1. + # +proc XRRScreenConfig*(dpy: PDisplay, screen: cint): PXRRScreenConfiguration{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfig*(screen: PScreen): PXRRScreenConfiguration{.cdecl, + dynlib: libXrandr, importc.} +proc XRRSelectInput*(dpy: PDisplay, window: Window, mask: cint){.cdecl, + dynlib: libXrandr, importc.} + # + # the following are always safe to call, even if RandR is not implemented + # on a screen + # +proc XRRRotations*(dpy: PDisplay, screen: cint, current_rotation: PRotation): Rotation{. + cdecl, dynlib: libXrandr, importc.} +proc XRRSizes*(dpy: PDisplay, screen: cint, nsizes: Pcint): PXRRScreenSize{. + cdecl, dynlib: libXrandr, importc.} +proc XRRRates*(dpy: PDisplay, screen: cint, sizeID: cint, nrates: Pcint): ptr int16{. + cdecl, dynlib: libXrandr, importc.} +proc XRRTimes*(dpy: PDisplay, screen: cint, config_timestamp: PTime): Time{. + cdecl, dynlib: libXrandr, importc.} + # + # intended to take RRScreenChangeNotify, or + # ConfigureNotify (on the root window) + # returns 1 if it is an event type it understands, 0 if not + # +proc XRRUpdateConfiguration*(event: PXEvent): cint{.cdecl, dynlib: libXrandr, + importc.} +# implementation +proc XRRGetScreenResourcesCurrent*(dpy: PDisplay, win: Window): + PXRRScreenResources {.cdecl, dynlib: libXrandr, importc.} +proc XRRFreeScreenResources*(res: PXRRScreenResources) {.cdecl, + dynlib: libXrandr, importc.} +proc XRRGetOutputInfo*(dpy: PDisplay, res: PXRRScreenResources, ret: RROutput): + PXRROutputInfo {.cdecl, dynlib: libXrandr, importc.} +proc XRRFreeOutputInfo*(info: PXRROutputInfo) {.cdecl, dynlib: libXrandr, + importc.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xrender.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xrender.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,264 @@ + +import + x, xlib + +when defined(use_pkg_config) or defined(use_pkg_config_static): + {.pragma: libxrender, cdecl, importc.} + when defined(use_pkg_config): + {.passl: gorge("pkg-config xrender --libs").} + else: + {.passl: gorge("pkg-config xrender --static --libs").} +else: + when defined(macosx): + const + libXrender* = "libXrender.dylib" + else: + const + libXrender* = "libXrender.so" + + + {.pragma: libxrender, dynlib: libXrender, cdecl, importc.} +#const +# libXrender* = "libXrender.so" + +# +# Automatically converted by H2Pas 0.99.15 from xrender.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xrender.h +# + +type + PGlyph* = ptr Glyph + Glyph* = int32 + + PGlyphSet* = ptr GlyphSet + GlyphSet* = int32 + + PPicture* = ptr Picture + Picture* = int32 + + PPictFormat* = ptr PictFormat + PictFormat* = int32 + +{.deprecated: [TGlyph: Glyph].} +{.deprecated: [TGlyphSet: GlyphSet].} +{.deprecated: [TPicture: Picture].} +{.deprecated: [TPictFormat: PictFormat].} + +const + RENDER_NAME* = "RENDER" + RENDER_MAJOR* = 0 + RENDER_MINOR* = 0 + constX_RenderQueryVersion* = 0 + X_RenderQueryPictFormats* = 1 + X_RenderQueryPictIndexValues* = 2 + X_RenderQueryDithers* = 3 + constX_RenderCreatePicture* = 4 + constX_RenderChangePicture* = 5 + X_RenderSetPictureClipRectangles* = 6 + constX_RenderFreePicture* = 7 + constX_RenderComposite* = 8 + X_RenderScale* = 9 + X_RenderTrapezoids* = 10 + X_RenderTriangles* = 11 + X_RenderTriStrip* = 12 + X_RenderTriFan* = 13 + X_RenderColorTrapezoids* = 14 + X_RenderColorTriangles* = 15 + X_RenderTransform* = 16 + constX_RenderCreateGlyphSet* = 17 + constX_RenderReferenceGlyphSet* = 18 + constX_RenderFreeGlyphSet* = 19 + constX_RenderAddGlyphs* = 20 + constX_RenderAddGlyphsFromPicture* = 21 + constX_RenderFreeGlyphs* = 22 + constX_RenderCompositeGlyphs8* = 23 + constX_RenderCompositeGlyphs16* = 24 + constX_RenderCompositeGlyphs32* = 25 + BadPictFormat* = 0 + BadPicture* = 1 + BadPictOp* = 2 + BadGlyphSet* = 3 + BadGlyph* = 4 + RenderNumberErrors* = BadGlyph + 1 + PictTypeIndexed* = 0 + PictTypeDirect* = 1 + PictOpClear* = 0 + PictOpSrc* = 1 + PictOpDst* = 2 + PictOpOver* = 3 + PictOpOverReverse* = 4 + PictOpIn* = 5 + PictOpInReverse* = 6 + PictOpOut* = 7 + PictOpOutReverse* = 8 + PictOpAtop* = 9 + PictOpAtopReverse* = 10 + PictOpXor* = 11 + PictOpAdd* = 12 + PictOpSaturate* = 13 + PictOpMaximum* = 13 + PolyEdgeSharp* = 0 + PolyEdgeSmooth* = 1 + PolyModePrecise* = 0 + PolyModeImprecise* = 1 + CPRepeat* = 1 shl 0 + CPAlphaMap* = 1 shl 1 + CPAlphaXOrigin* = 1 shl 2 + CPAlphaYOrigin* = 1 shl 3 + CPClipXOrigin* = 1 shl 4 + CPClipYOrigin* = 1 shl 5 + CPClipMask* = 1 shl 6 + CPGraphicsExposure* = 1 shl 7 + CPSubwindowMode* = 1 shl 8 + CPPolyEdge* = 1 shl 9 + CPPolyMode* = 1 shl 10 + CPDither* = 1 shl 11 + CPLastBit* = 11 + +type + PXRenderDirectFormat* = ptr XRenderDirectFormat + XRenderDirectFormat*{.final.} = object + red*: int16 + redMask*: int16 + green*: int16 + greenMask*: int16 + blue*: int16 + blueMask*: int16 + alpha*: int16 + alphaMask*: int16 + + PXRenderPictFormat* = ptr XRenderPictFormat + XRenderPictFormat*{.final.} = object + id*: PictFormat + thetype*: int32 + depth*: int32 + direct*: XRenderDirectFormat + colormap*: Colormap + +{.deprecated: [TXRenderDirectFormat: XRenderDirectFormat].} +{.deprecated: [TXRenderPictFormat: XRenderPictFormat].} + +const + PictFormatID* = 1 shl 0 + PictFormatType* = 1 shl 1 + PictFormatDepth* = 1 shl 2 + PictFormatRed* = 1 shl 3 + PictFormatRedMask* = 1 shl 4 + PictFormatGreen* = 1 shl 5 + PictFormatGreenMask* = 1 shl 6 + PictFormatBlue* = 1 shl 7 + PictFormatBlueMask* = 1 shl 8 + PictFormatAlpha* = 1 shl 9 + PictFormatAlphaMask* = 1 shl 10 + PictFormatColormap* = 1 shl 11 + +type + PXRenderVisual* = ptr XRenderVisual + XRenderVisual*{.final.} = object + visual*: PVisual + format*: PXRenderPictFormat + + PXRenderDepth* = ptr XRenderDepth + XRenderDepth*{.final.} = object + depth*: int32 + nvisuals*: int32 + visuals*: PXRenderVisual + + PXRenderScreen* = ptr XRenderScreen + XRenderScreen*{.final.} = object + depths*: PXRenderDepth + ndepths*: int32 + fallback*: PXRenderPictFormat + + PXRenderInfo* = ptr XRenderInfo + XRenderInfo*{.final.} = object + format*: PXRenderPictFormat + nformat*: int32 + screen*: PXRenderScreen + nscreen*: int32 + depth*: PXRenderDepth + ndepth*: int32 + visual*: PXRenderVisual + nvisual*: int32 + + PXRenderPictureAttributes* = ptr XRenderPictureAttributes + XRenderPictureAttributes*{.final.} = object + repeat*: XBool + alpha_map*: Picture + alpha_x_origin*: int32 + alpha_y_origin*: int32 + clip_x_origin*: int32 + clip_y_origin*: int32 + clip_mask*: Pixmap + graphics_exposures*: XBool + subwindow_mode*: int32 + poly_edge*: int32 + poly_mode*: int32 + dither*: Atom + + PXGlyphInfo* = ptr XGlyphInfo + XGlyphInfo*{.final.} = object + width*: int16 + height*: int16 + x*: int16 + y*: int16 + xOff*: int16 + yOff*: int16 + + PXRenderColor* = ptr XRenderColor + XRenderColor* = object + red*: cushort + green*: cushort + blue*: cushort + alpha*: cushort + +{.deprecated: [TXRenderVisual: XRenderVisual].} +{.deprecated: [TXRenderDepth: XRenderDepth].} +{.deprecated: [TXRenderScreen: XRenderScreen].} +{.deprecated: [TXRenderInfo: XRenderInfo].} +{.deprecated: [TXRenderPictureAttributes: XRenderPictureAttributes].} +{.deprecated: [TXGlyphInfo: XGlyphInfo].} + +proc XRenderQueryExtension*(dpy: PDisplay, event_basep: ptr int32, + error_basep: ptr int32): XBool{.libxrender.} +proc XRenderQueryVersion*(dpy: PDisplay, major_versionp: ptr int32, + minor_versionp: ptr int32): Status{.libxrender.} +proc XRenderQueryFormats*(dpy: PDisplay): Status{.libxrender.} +proc XRenderFindVisualFormat*(dpy: PDisplay, visual: PVisual): PXRenderPictFormat{. + libxrender.} +proc XRenderFindFormat*(dpy: PDisplay, mask: int32, + `template`: PXRenderPictFormat, count: int32): PXRenderPictFormat{. + libxrender.} +proc XRenderCreatePicture*(dpy: PDisplay, drawable: Drawable, + format: PXRenderPictFormat, valuemask: int32, + attributes: PXRenderPictureAttributes): Picture{. + libxrender.} +proc XRenderChangePicture*(dpy: PDisplay, picture: Picture, valuemask: int32, + attributes: PXRenderPictureAttributes){.libxrender.} +proc XRenderFreePicture*(dpy: PDisplay, picture: Picture){.libxrender.} +proc XRenderComposite*(dpy: PDisplay, op: int32, src: Picture, mask: Picture, + dst: Picture, src_x: int32, src_y: int32, mask_x: int32, + mask_y: int32, dst_x: int32, dst_y: int32, width: int32, + height: int32){.libxrender.} +proc XRenderCreateGlyphSet*(dpy: PDisplay, format: PXRenderPictFormat): GlyphSet{. + libxrender.} +proc XRenderReferenceGlyphSet*(dpy: PDisplay, existing: GlyphSet): GlyphSet{. + libxrender.} +proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: GlyphSet){.libxrender.} +proc XRenderAddGlyphs*(dpy: PDisplay, glyphset: GlyphSet, gids: PGlyph, + glyphs: PXGlyphInfo, nglyphs: int32, images: cstring, + nbyte_images: int32){.libxrender.} +proc XRenderFreeGlyphs*(dpy: PDisplay, glyphset: GlyphSet, gids: PGlyph, + nglyphs: int32){.libxrender.} +proc XRenderCompositeString8*(dpy: PDisplay, op: int32, src: Picture, + dst: Picture, maskFormat: PXRenderPictFormat, + glyphset: GlyphSet, xSrc: int32, ySrc: int32, + xDst: int32, yDst: int32, str: cstring, + nchar: int32){.libxrender.} +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xresource.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xresource.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,244 @@ + +import + x, xlib + +#const +# libX11* = "libX11.so" + +# +# Automatically converted by H2Pas 0.99.15 from xresource.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xresource.h +# + +proc Xpermalloc*(para1: int32): cstring{.cdecl, dynlib: libX11, importc.} + +type + PXrmQuark* = ptr XrmQuark + XrmQuark* = int32 + + XrmQuarkList* = PXrmQuark + PXrmQuarkList* = ptr XrmQuarkList + +{.deprecated: [TXrmQuark: XrmQuark].} +{.deprecated: [TXrmQuarkList: XrmQuarkList].} + +proc NULLQUARK*(): XrmQuark + +type + PXrmString* = ptr XrmString + XrmString* = ptr char + +{.deprecated: [TXrmString: XrmString].} + +proc NULLSTRING*(): XrmString +proc XrmStringToQuark*(para1: cstring): XrmQuark{.cdecl, dynlib: libX11, + importc.} +proc XrmPermStringToQuark*(para1: cstring): XrmQuark{.cdecl, dynlib: libX11, + importc.} +proc XrmQuarkToString*(para1: XrmQuark): XrmString{.cdecl, dynlib: libX11, + importc.} +proc XrmUniqueQuark*(): XrmQuark{.cdecl, dynlib: libX11, importc.} +#when defined(MACROS): +proc XrmStringsEqual*(a1, a2: cstring): bool + +type + PXrmBinding* = ptr XrmBinding + XrmBinding* = enum + XrmBindTightly, XrmBindLoosely + + XrmBindingList* = PXrmBinding + PXrmBindingList* = ptr XrmBindingList + +{.deprecated: [TXrmBinding: XrmBinding].} +{.deprecated: [TXrmBindingList: XrmBindingList].} + +proc XrmStringToQuarkList*(para1: cstring, para2: XrmQuarkList){.cdecl, + dynlib: libX11, importc.} +proc XrmStringToBindingQuarkList*(para1: cstring, para2: XrmBindingList, + para3: XrmQuarkList){.cdecl, dynlib: libX11, + importc.} + +type + PXrmName* = ptr XrmName + XrmName* = XrmQuark + + PXrmNameList* = ptr XrmNameList + XrmNameList* = XrmQuarkList + +{.deprecated: [TXrmName: XrmName].} +{.deprecated: [TXrmNameList: XrmNameList].} + +#when defined(MACROS): +proc XrmNameToString*(name: int32): XrmString +proc XrmStringToName*(str: cstring): int32 +proc XrmStringToNameList*(str: cstring, name: PXrmQuark) + +type + PXrmClass* = ptr XrmClass + XrmClass* = XrmQuark + + PXrmClassList* = ptr XrmClassList + XrmClassList* = XrmQuarkList + +{.deprecated: [TXrmClass: XrmClass].} +{.deprecated: [TXrmClassList: XrmClassList].} + +#when defined(MACROS): +proc XrmClassToString*(c_class: int32): XrmString +proc XrmStringToClass*(c_class: cstring): int32 +proc XrmStringToClassList*(str: cstring, c_class: PXrmQuark) + +type + PXrmRepresentation* = ptr XrmRepresentation + XrmRepresentation* = XrmQuark +{.deprecated: [TXrmRepresentation: XrmRepresentation].} + +#when defined(MACROS): +proc XrmStringToRepresentation*(str: cstring): int32 +proc XrmRepresentationToString*(thetype: int32): XrmString + +type + PXrmValue* = ptr XrmValue + XrmValue*{.final.} = object + size*: int32 + address*: XPointer + + PXrmValuePtr* = ptr XrmValuePtr + XrmValuePtr* = PXrmValue + + PXrmHashBucketRec* = ptr XrmHashBucketRec + XrmHashBucketRec*{.final.} = object + + PXrmHashBucket* = ptr XrmHashBucket + XrmHashBucket* = PXrmHashBucketRec + + PXrmHashTable* = ptr XrmHashTable + XrmHashTable* = ptr XrmHashBucket + + PXrmDatabase* = ptr XrmDatabase + XrmDatabase* = PXrmHashBucketRec + +{.deprecated: [TXrmValue: XrmValue].} +{.deprecated: [TXrmValuePtr: XrmValuePtr].} +{.deprecated: [TXrmHashBucketRec: XrmHashBucketRec].} +{.deprecated: [TXrmHashBucket: XrmHashBucket].} +{.deprecated: [TXrmHashTable: XrmHashTable].} +{.deprecated: [TXrmDatabase: XrmDatabase].} + +proc XrmDestroyDatabase*(para1: XrmDatabase){.cdecl, dynlib: libX11, importc.} +proc XrmQPutResource*(para1: PXrmDatabase, para2: XrmBindingList, + para3: XrmQuarkList, para4: XrmRepresentation, + para5: PXrmValue){.cdecl, dynlib: libX11, importc.} +proc XrmPutResource*(para1: PXrmDatabase, para2: cstring, para3: cstring, + para4: PXrmValue){.cdecl, dynlib: libX11, importc.} +proc XrmQPutStringResource*(para1: PXrmDatabase, para2: XrmBindingList, + para3: XrmQuarkList, para4: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmPutStringResource*(para1: PXrmDatabase, para2: cstring, para3: cstring){. + cdecl, dynlib: libX11, importc.} +proc XrmPutLineResource*(para1: PXrmDatabase, para2: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmQGetResource*(para1: XrmDatabase, para2: XrmNameList, + para3: XrmClassList, para4: PXrmRepresentation, + para5: PXrmValue): XBool{.cdecl, dynlib: libX11, importc.} +proc XrmGetResource*(para1: XrmDatabase, para2: cstring, para3: cstring, + para4: PPchar, para5: PXrmValue): XBool{.cdecl, + dynlib: libX11, importc.} + # There is no definition of XrmSearchList + #function XrmQGetSearchList(para1:XrmDatabase; para2:XrmNameList; para3:XrmClassList; para4:XrmSearchList; para5:longint):XBool;cdecl;external libX11; + #function XrmQGetSearchResource(para1:XrmSearchList; para2:XrmName; para3:XrmClass; para4:PXrmRepresentation; para5:PXrmValue):XBool;cdecl;external libX11; +proc XrmSetDatabase*(para1: PDisplay, para2: XrmDatabase){.cdecl, + dynlib: libX11, importc.} +proc XrmGetDatabase*(para1: PDisplay): XrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmGetFileDatabase*(para1: cstring): XrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmCombineFileDatabase*(para1: cstring, para2: PXrmDatabase, para3: XBool): Status{. + cdecl, dynlib: libX11, importc.} +proc XrmGetStringDatabase*(para1: cstring): XrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmPutFileDatabase*(para1: XrmDatabase, para2: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmMergeDatabases*(para1: XrmDatabase, para2: PXrmDatabase){.cdecl, + dynlib: libX11, importc.} +proc XrmCombineDatabase*(para1: XrmDatabase, para2: PXrmDatabase, para3: XBool){. + cdecl, dynlib: libX11, importc.} +const + XrmEnumAllLevels* = 0 + XrmEnumOneLevel* = 1 + +type + funcbool* = proc (): XBool {.cdecl.} + +proc XrmEnumerateDatabase*(para1: XrmDatabase, para2: XrmNameList, + para3: XrmClassList, para4: int32, para5: funcbool, + para6: XPointer): XBool{.cdecl, dynlib: libX11, + importc.} +proc XrmLocaleOfDatabase*(para1: XrmDatabase): cstring{.cdecl, dynlib: libX11, + importc.} + +type + PXrmOptionKind* = ptr XrmOptionKind + XrmOptionKind* = enum + XrmoptionNoArg, XrmoptionIsArg, XrmoptionStickyArg, XrmoptionSepArg, + XrmoptionResArg, XrmoptionSkipArg, XrmoptionSkipLine, XrmoptionSkipNArgs + + PXrmOptionDescRec* = ptr XrmOptionDescRec + XrmOptionDescRec*{.final.} = object + option*: cstring + specifier*: cstring + argKind*: XrmOptionKind + value*: XPointer + + XrmOptionDescList* = PXrmOptionDescRec + PXrmOptionDescList* = ptr XrmOptionDescList + +{.deprecated: [TXrmOptionKind: XrmOptionKind].} +{.deprecated: [TXrmOptionDescRec: XrmOptionDescRec].} +{.deprecated: [TPXrmOptionDescList: PXrmOptionDescList].} + +proc XrmParseCommand*(para1: PXrmDatabase, para2: XrmOptionDescList, + para3: int32, para4: cstring, para5: ptr int32, + para6: PPchar){.cdecl, dynlib: libX11, importc.} +# implementation + +proc NULLQUARK(): XrmQuark = + result = XrmQuark(0) + +proc NULLSTRING(): XrmString = + result = nil + +#when defined(MACROS): +proc XrmStringsEqual(a1, a2: cstring): bool = + #result = (strcomp(a1, a2)) == 0 + $a1 == $a2 + +proc XrmNameToString(name: int32): XrmString = + result = XrmQuarkToString(name) + +proc XrmStringToName(str: cstring): int32 = + result = XrmStringToQuark(str) + +proc XrmStringToNameList(str: cstring, name: PXrmQuark) = + XrmStringToQuarkList(str, name) + +proc XrmClassToString(c_class: int32): XrmString = + result = XrmQuarkToString(c_class) + +proc XrmStringToClass(c_class: cstring): int32 = + result = XrmStringToQuark(c_class) + +proc XrmStringToClassList(str: cstring, c_class: PXrmQuark) = + XrmStringToQuarkList(str, c_class) + +proc XrmStringToRepresentation(str: cstring): int32 = + result = XrmStringToQuark(str) + +proc XrmRepresentationToString(thetype: int32): XrmString = + result = XrmQuarkToString(thetype) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xshm.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xshm.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,80 @@ +import + x, xlib + +const + libXext* = "libXext.so(.6|)" + +# +# Automatically converted by H2Pas 0.99.15 from xshm.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xshm.h +# + +const + constX_ShmQueryVersion* = 0 + constX_ShmAttach* = 1 + constX_ShmDetach* = 2 + constX_ShmPutImage* = 3 + constX_ShmGetImage* = 4 + constX_ShmCreatePixmap* = 5 + ShmCompletion* = 0 + ShmNumberEvents* = ShmCompletion + 1 + BadShmSeg* = 0 + ShmNumberErrors* = BadShmSeg + 1 + +type + PShmSeg* = ptr ShmSeg + ShmSeg* = culong + + PXShmCompletionEvent* = ptr XShmCompletionEvent + XShmCompletionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: XBool + display*: PDisplay + drawable*: Drawable + major_code*: cint + minor_code*: cint + shmseg*: ShmSeg + offset*: culong + + PXShmSegmentInfo* = ptr XShmSegmentInfo + XShmSegmentInfo*{.final.} = object + shmseg*: ShmSeg + shmid*: cint + shmaddr*: cstring + readOnly*: XBool + +{.deprecated: [TShmSeg: ShmSeg].} +{.deprecated: [TXShmCompletionEvent: XShmCompletionEvent].} +{.deprecated: [TXShmSegmentInfo: XShmSegmentInfo].} + +proc XShmQueryExtension*(para1: PDisplay): XBool{.cdecl, dynlib: libXext, importc.} +proc XShmGetEventBase*(para1: PDisplay): cint{.cdecl, dynlib: libXext, importc.} +proc XShmQueryVersion*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: PBool): XBool{. + cdecl, dynlib: libXext, importc.} +proc XShmPixmapFormat*(para1: PDisplay): cint{.cdecl, dynlib: libXext, importc.} +proc XShmAttach*(para1: PDisplay, para2: PXShmSegmentInfo): Status{.cdecl, + dynlib: libXext, importc.} +proc XShmDetach*(para1: PDisplay, para2: PXShmSegmentInfo): Status{.cdecl, + dynlib: libXext, importc.} +proc XShmPutImage*(para1: PDisplay, para2: Drawable, para3: GC, + para4: PXImage, para5: cint, para6: cint, para7: cint, + para8: cint, para9: cuint, para10: cuint, para11: XBool): Status{. + cdecl, dynlib: libXext, importc.} +proc XShmGetImage*(para1: PDisplay, para2: Drawable, para3: PXImage, + para4: cint, para5: cint, para6: culong): Status{.cdecl, + dynlib: libXext, importc.} +proc XShmCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, + para4: cint, para5: cstring, para6: PXShmSegmentInfo, + para7: cuint, para8: cuint): PXImage{.cdecl, + dynlib: libXext, importc.} +proc XShmCreatePixmap*(para1: PDisplay, para2: Drawable, para3: cstring, + para4: PXShmSegmentInfo, para5: cuint, para6: cuint, + para7: cuint): Pixmap{.cdecl, dynlib: libXext, importc.} +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xtst.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xtst.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,155 @@ +import x, xlib, xinput + +const + libXtst = "libXtst.so(.6|)" + + recordName* = "RECORD" + recordMajorVersion* = 1 + recordMinorVersion* = 13 + recordLowestMajorVersion* = 1 + recordLowestMinorVersion* = 12 + + xRecordBadContext* = 0 + + recordNumErrors* = xRecordBadContext + 1 + recordNumEvents* = 0 + + xRecordFromServerTime* = 0x01 + xRecordFromClientTime* = 0x02 + xRecordFromClientSequence* = 0x04 + + xRecordCurrentClients* = 1 + xRecordFutureClients* = 2 + xRecordAllClients* = 3 + + XRecordFromServer* = 0 + XRecordFromClient* = 1 + XRecordClientStarted* = 2 + XRecordClientDied* = 3 + XRecordStartOfData* = 4 + XRecordEndOfData* = 5 + +type + PXRecordClientSpec* = ptr XRecordClientSpec + XRecordClientSpec* = culong + + PXRecordContext* = ptr XRecordContext + XRecordContext* = culong + + PXRecordRange8* = ptr XRecordRange8 + XRecordRange8* {.final.} = object + first*: cuchar + last*: cuchar + + PXRecordRange16* = ptr XRecordRange16 + XRecordRange16* {.final.} = object + first*: cushort + last*: cushort + + PXRecordExtRange* = ptr XRecordExtRange + XRecordExtRange* {.final.} = object + ext_major*: XRecordRange8 + ext_minor*: XRecordRange16 + + PXRecordRange* = ptr XRecordRange + XRecordRange* {.final.} = object + core_requests*: XRecordRange8 ## core X requests + core_replies*: XRecordRange8 ## core X replies + ext_requests*: XRecordExtRange ## extension requests + ext_replies*: XRecordExtRange ## extension replies + delivered_events*: XRecordRange8 ## delivered core and ext events + device_events*: XRecordRange8 ## all core and ext device events + errors*: XRecordRange8 ## core X and ext errors + client_started*: XBool ## connection setup reply + client_died*: XBool ## notice of client disconnect + + PXRecordClientInfo* = ptr XRecordClientInfo + XRecordClientInfo* {.final.} = object + client*: XRecordClientSpec + nranges*: culong + ranges*: ptr UncheckedArray[XRecordRange] + + PXRecordState* = ptr XRecordState + XRecordState* {.final.} = object + enabled*: XBool + datum_flags*: cint + nclients*: culong + client_info*: ptr UncheckedArray[XRecordClientInfo] + + PXRecordInterceptData* = ptr XRecordInterceptData + XRecordInterceptData* {.final.} = object + id_base*: XID + server_time*: Time + client_seq*: culong + category*: cint + client_swapped*: XBool + data*: cstring + data_len*: culong ## in 4-byte units + + XRecordInterceptProc* = proc (a1: XPointer, a2: PXRecordInterceptData) + +{.deprecated: [TXRecordClientSpec: XRecordClientSpec].} +{.deprecated: [TXRecordContext: XRecordContext].} +{.deprecated: [TXRecordRange8: XRecordRange8].} +{.deprecated: [TXRecordRange16: XRecordRange16].} +{.deprecated: [TXRecordExtRange: XRecordExtRange].} +{.deprecated: [TXRecordRange: XRecordRange].} +{.deprecated: [TXRecordClientInfo: XRecordClientInfo].} +{.deprecated: [TXRecordState: XRecordState].} +{.deprecated: [TXRecordInterceptData: XRecordInterceptData].} +{.deprecated: [TXRecordInterceptProc: XRecordInterceptProc].} + +{.push cdecl, importc, dynlib: libXtst.} + +proc XRecordIdBaseMask*(dpy: PDisplay): XID +proc XRecordQueryVersion*(a1: PDisplay, a2, a3: ptr cint): Status +proc XRecordCreateContext*(a1: PDisplay, + a2: cint, a3: PXRecordClientSpec, + a4: cint, a5: ptr UncheckedArray[XRecordRange], + a6: cint): XRecordContext +proc XRecordAllocRange*: PXRecordRange +proc XRecordRegisterClients*(a1: PDisplay, + a2: XRecordContext, + a3: cint, a4: PXRecordClientSpec, + a5: cint, a6: ptr UncheckedArray[XRecordRange], + a7: cint): Status +proc XRecordUnregisterClients*(a1: PDisplay, + a2: XRecordContext, + a3: PXRecordClientSpec, + a4: cint): Status +proc XRecordGetContext*(a1: PDisplay, + a2: XRecordContext, + a3: ptr UncheckedArray[XRecordState]): Status +proc XRecordFreeState*(a1: PXRecordState) +proc XRecordEnableContext*(a1: PDisplay, + a2: XRecordContext, + a3: XRecordInterceptProc, + a4: XPointer): Status +proc XRecordEnableContextAsync*(a1: PDisplay, a2: XRecordContext, + a3: XRecordInterceptProc, + a4: XPointer): Status +proc XRecordProcessReplies*(a1: PDisplay) +proc XRecordFreeData*(a1: PXRecordInterceptData) +proc XRecordDisableContext*(a1: PDisplay, a2: XRecordContext): Status +proc XRecordFreeContext*(a1: PDisplay, a2: XRecordContext): Status +proc XTestQueryExtension*(a1: PDisplay, a2, a3, a4, a5: ptr cint): XBool +proc XTestCompareCursorWithWindow*(a1: PDisplay, a2: Window, a3: Cursor): XBool +proc XTestCompareCurrentCursorWithWindow*(a1: PDisplay, a2: Window): XBool +proc XTestFakeKeyEvent*(a1: PDisplay, a2: cuint, a3: XBool, a4: culong): cint +proc XTestFakeButtonEvent*(a1: PDisplay, a2: cuint, a3: XBool, a4: culong): cint +proc XTestFakeMotionEvent*(a1: PDisplay, a2, a3, a4: cint, a5: culong): cint +proc XTestFakeRelativeMotionEvent*(a1: PDisplay, a2, a3: cint, a4: culong): cint +proc XTestFakeDeviceKeyEvent*(a1: PDisplay, a2: PXDevice, a3: cuint, a4: XBool, + a5: ptr cint, a6: cint, a7: culong): cint +proc XTestFakeDeviceButtonEvent*(a1: PDisplay, a2: PXDevice, a3: cuint, a4: XBool, + a5: ptr cint, a6: cint, a7: culong): cint +proc XTestFakeProximityEvent*(a1: PDisplay, a2: PXDevice, a3: XBool, a4: ptr cint, + a5: cint, a6: culong): cint +proc XTestFakeDeviceMotionEvent*(a1: PDisplay, a2: PXDevice, a3: XBool, a4: cint, + a5: ptr cint, a6: cint, a7: culong): cint +proc XTestGrabControl*(a1: PDisplay, a2: XBool): cint +proc XTestSetGContextOfGC*(a1: GC, a2: GContext) +proc XTestSetVisualIDOfVisual*(a1: PVisual, a2: VisualID) +proc XTestDiscard*(a1: PDisplay): Status + +{.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xutil.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xutil.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,434 @@ + +import + x, xlib, keysym + +#const +# libX11* = "libX11.so" + +# +# Automatically converted by H2Pas 0.99.15 from xutil.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xutil.h +# + +const + NoValue* = 0x00000000 + XValue* = 0x00000001 + YValue* = 0x00000002 + WidthValue* = 0x00000004 + HeightValue* = 0x00000008 + AllValues* = 0x0000000F + XNegative* = 0x00000010 + YNegative* = 0x00000020 + +type + CPoint*{.final.} = object + x*: cint + y*: cint + + PXSizeHints* = ptr XSizeHints + XSizeHints*{.final.} = object + flags*: clong + x*, y*: cint + width*, height*: cint + min_width*, min_height*: cint + max_width*, max_height*: cint + width_inc*, height_inc*: cint + min_aspect*, max_aspect*: CPoint + base_width*, base_height*: cint + win_gravity*: cint + +{.deprecated: [TCPoint: CPoint].} +{.deprecated: [TXSizeHints: XSizeHints].} + +const + USPosition* = 1 shl 0 + USSize* = 1 shl 1 + PPosition* = 1 shl 2 + PSize* = 1 shl 3 + PMinSize* = 1 shl 4 + PMaxSize* = 1 shl 5 + PResizeInc* = 1 shl 6 + PAspect* = 1 shl 7 + PBaseSize* = 1 shl 8 + PWinGravity* = 1 shl 9 + PAllHints* = PPosition or PSize or PMinSize or PMaxSize or PResizeInc or + PAspect + +type + PXWMHints* = ptr XWMHints + XWMHints*{.final.} = object + flags*: clong + input*: XBool + initial_state*: cint + icon_pixmap*: Pixmap + icon_window*: Window + icon_x*, icon_y*: cint + icon_mask*: Pixmap + window_group*: XID + +{.deprecated: [TXWMHints: XWMHints].} + + +const + InputHint* = 1 shl 0 + StateHint* = 1 shl 1 + IconPixmapHint* = 1 shl 2 + IconWindowHint* = 1 shl 3 + IconPositionHint* = 1 shl 4 + IconMaskHint* = 1 shl 5 + WindowGroupHint* = 1 shl 6 + AllHints* = InputHint or StateHint or IconPixmapHint or IconWindowHint or + IconPositionHint or IconMaskHint or WindowGroupHint + XUrgencyHint* = 1 shl 8 + WithdrawnState* = 0 + NormalState* = 1 + IconicState* = 3 + DontCareState* = 0 + ZoomState* = 2 + InactiveState* = 4 + +type + PXTextProperty* = ptr XTextProperty + XTextProperty*{.final.} = object + value*: Pcuchar + encoding*: Atom + format*: cint + nitems*: culong + +{.deprecated: [TXTextProperty: XTextProperty].} + + +const + XNoMemory* = - 1 + XLocaleNotSupported* = - 2 + XConverterNotFound* = - 3 + +type + PXICCEncodingStyle* = ptr XICCEncodingStyle + XICCEncodingStyle* = enum + XStringStyle, XCompoundTextStyle, XTextStyle, XStdICCTextStyle, + XUTF8StringStyle + + PPXIconSize* = ptr PXIconSize + PXIconSize* = ptr XIconSize + XIconSize*{.final.} = object + min_width*, min_height*: cint + max_width*, max_height*: cint + width_inc*, height_inc*: cint + + PXClassHint* = ptr XClassHint + XClassHint*{.final.} = object + res_name*: cstring + res_class*: cstring + +{.deprecated: [TXICCEncodingStyle: XICCEncodingStyle].} +{.deprecated: [TXIconSize: XIconSize].} +{.deprecated: [TXClassHint: XClassHint].} + +type + PXComposeStatus* = ptr XComposeStatus + XComposeStatus*{.final.} = object + compose_ptr*: XPointer + chars_matched*: cint + +{.deprecated: [TXComposeStatus: XComposeStatus].} + + +type + PXRegion* = ptr XRegion + XRegion*{.final.} = object + + PRegion* = ptr Region + Region* = PXRegion + +{.deprecated: [TXRegion: XRegion].} +{.deprecated: [TRegion: Region].} + +const + RectangleOut* = 0 + RectangleIn* = 1 + RectanglePart* = 2 + +type + PXVisualInfo* = ptr XVisualInfo + XVisualInfo*{.final.} = object + visual*: PVisual + visualid*: VisualID + screen*: cint + depth*: cint + class*: cint + red_mask*: culong + green_mask*: culong + blue_mask*: culong + colormap_size*: cint + bits_per_rgb*: cint + +{.deprecated: [TXVisualInfo: XVisualInfo].} + + +const + VisualNoMask* = 0x00000000 + VisualIDMask* = 0x00000001 + VisualScreenMask* = 0x00000002 + VisualDepthMask* = 0x00000004 + VisualClassMask* = 0x00000008 + VisualRedMaskMask* = 0x00000010 + VisualGreenMaskMask* = 0x00000020 + VisualBlueMaskMask* = 0x00000040 + VisualColormapSizeMask* = 0x00000080 + VisualBitsPerRGBMask* = 0x00000100 + VisualAllMask* = 0x000001FF + +type + PPXStandardColormap* = ptr PXStandardColormap + PXStandardColormap* = ptr XStandardColormap + XStandardColormap*{.final.} = object + colormap*: Colormap + red_max*: culong + red_mult*: culong + green_max*: culong + green_mult*: culong + blue_max*: culong + blue_mult*: culong + base_pixel*: culong + visualid*: VisualID + killid*: XID + +{.deprecated: [TXStandardColormap: XStandardColormap].} + + +const + BitmapSuccess* = 0 + BitmapOpenFailed* = 1 + BitmapFileInvalid* = 2 + BitmapNoMemory* = 3 + XCSUCCESS* = 0 + XCNOMEM* = 1 + XCNOENT* = 2 + ReleaseByFreeingColormap*: XID = XID(1) + +type + PXContext* = ptr XContext + XContext* = cint + +{.deprecated: [TXContext: XContext].} + +proc XAllocClassHint*(): PXClassHint{.cdecl, dynlib: libX11, importc.} +proc XAllocIconSize*(): PXIconSize{.cdecl, dynlib: libX11, importc.} +proc XAllocSizeHints*(): PXSizeHints{.cdecl, dynlib: libX11, importc.} +proc XAllocStandardColormap*(): PXStandardColormap{.cdecl, dynlib: libX11, + importc.} +proc XAllocWMHints*(): PXWMHints{.cdecl, dynlib: libX11, importc.} +proc XClipBox*(para1: Region, para2: PXRectangle): cint{.cdecl, dynlib: libX11, + importc.} +proc XCreateRegion*(): Region{.cdecl, dynlib: libX11, importc.} +proc XDefaultString*(): cstring{.cdecl, dynlib: libX11, importc.} +proc XDeleteContext*(para1: PDisplay, para2: XID, para3: XContext): cint{. + cdecl, dynlib: libX11, importc.} +proc XDestroyRegion*(para1: Region): cint{.cdecl, dynlib: libX11, importc.} +proc XEmptyRegion*(para1: Region): cint{.cdecl, dynlib: libX11, importc.} +proc XEqualRegion*(para1: Region, para2: Region): cint{.cdecl, dynlib: libX11, + importc.} +proc XFindContext*(para1: PDisplay, para2: XID, para3: XContext, + para4: PXPointer): cint{.cdecl, dynlib: libX11, importc.} +proc XGetClassHint*(para1: PDisplay, para2: Window, para3: PXClassHint): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetIconSizes*(para1: PDisplay, para2: Window, para3: PPXIconSize, + para4: Pcint): Status{.cdecl, dynlib: libX11, importc.} +proc XGetNormalHints*(para1: PDisplay, para2: Window, para3: PXSizeHints): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetRGBColormaps*(para1: PDisplay, para2: Window, + para3: PPXStandardColormap, para4: Pcint, para5: Atom): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetSizeHints*(para1: PDisplay, para2: Window, para3: PXSizeHints, + para4: Atom): Status{.cdecl, dynlib: libX11, importc.} +proc XGetStandardColormap*(para1: PDisplay, para2: Window, + para3: PXStandardColormap, para4: Atom): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetTextProperty*(para1: PDisplay, para2: Window, para3: PXTextProperty, + para4: Atom): Status{.cdecl, dynlib: libX11, importc.} +proc XGetVisualInfo*(para1: PDisplay, para2: clong, para3: PXVisualInfo, + para4: Pcint): PXVisualInfo{.cdecl, dynlib: libX11, importc.} +proc XGetWMClientMachine*(para1: PDisplay, para2: Window, para3: PXTextProperty): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetWMHints*(para1: PDisplay, para2: Window): PXWMHints{.cdecl, + dynlib: libX11, importc.} +proc XGetWMIconName*(para1: PDisplay, para2: Window, para3: PXTextProperty): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetWMName*(para1: PDisplay, para2: Window, para3: PXTextProperty): Status{. + cdecl, dynlib: libX11, importc.} +proc XGetWMNormalHints*(para1: PDisplay, para2: Window, para3: PXSizeHints, + para4: ptr int): Status{.cdecl, dynlib: libX11, importc.} +proc XGetWMSizeHints*(para1: PDisplay, para2: Window, para3: PXSizeHints, + para4: ptr int, para5: Atom): Status{.cdecl, + dynlib: libX11, importc.} +proc XGetZoomHints*(para1: PDisplay, para2: Window, para3: PXSizeHints): Status{. + cdecl, dynlib: libX11, importc.} +proc XIntersectRegion*(para1: Region, para2: Region, para3: Region): cint{. + cdecl, dynlib: libX11, importc.} +proc XConvertCase*(para1: KeySym, para2: PKeySym, para3: PKeySym){.cdecl, + dynlib: libX11, importc.} +proc XLookupString*(para1: PXKeyEvent, para2: cstring, para3: cint, + para4: PKeySym, para5: PXComposeStatus): cint{.cdecl, + dynlib: libX11, importc.} +proc XMatchVisualInfo*(para1: PDisplay, para2: cint, para3: cint, para4: cint, + para5: PXVisualInfo): Status{.cdecl, dynlib: libX11, + importc.} +proc XOffsetRegion*(para1: Region, para2: cint, para3: cint): cint{.cdecl, + dynlib: libX11, importc.} +proc XPointInRegion*(para1: Region, para2: cint, para3: cint): XBool{.cdecl, + dynlib: libX11, importc.} +proc XPolygonRegion*(para1: PXPoint, para2: cint, para3: cint): Region{.cdecl, + dynlib: libX11, importc.} +proc XRectInRegion*(para1: Region, para2: cint, para3: cint, para4: cuint, + para5: cuint): cint{.cdecl, dynlib: libX11, importc.} +proc XSaveContext*(para1: PDisplay, para2: XID, para3: XContext, + para4: cstring): cint{.cdecl, dynlib: libX11, importc.} +proc XSetClassHint*(para1: PDisplay, para2: Window, para3: PXClassHint): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetIconSizes*(para1: PDisplay, para2: Window, para3: PXIconSize, + para4: cint): cint{.cdecl, dynlib: libX11, importc.} +proc XSetNormalHints*(para1: PDisplay, para2: Window, para3: PXSizeHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetRGBColormaps*(para1: PDisplay, para2: Window, + para3: PXStandardColormap, para4: cint, para5: Atom){. + cdecl, dynlib: libX11, importc.} +proc XSetSizeHints*(para1: PDisplay, para2: Window, para3: PXSizeHints, + para4: Atom): cint{.cdecl, dynlib: libX11, importc.} +proc XSetStandardProperties*(para1: PDisplay, para2: Window, para3: cstring, + para4: cstring, para5: Pixmap, para6: PPchar, + para7: cint, para8: PXSizeHints): cint{.cdecl, + dynlib: libX11, importc.} +proc XSetTextProperty*(para1: PDisplay, para2: Window, para3: PXTextProperty, + para4: Atom){.cdecl, dynlib: libX11, importc.} +proc XSetWMClientMachine*(para1: PDisplay, para2: Window, para3: PXTextProperty){. + cdecl, dynlib: libX11, importc.} +proc XSetWMHints*(para1: PDisplay, para2: Window, para3: PXWMHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetWMIconName*(para1: PDisplay, para2: Window, para3: PXTextProperty){. + cdecl, dynlib: libX11, importc.} +proc XSetWMName*(para1: PDisplay, para2: Window, para3: PXTextProperty){.cdecl, + dynlib: libX11, importc.} +proc XSetWMNormalHints*(para1: PDisplay, para2: Window, para3: PXSizeHints){. + cdecl, dynlib: libX11, importc.} +proc XSetWMProperties*(para1: PDisplay, para2: Window, para3: PXTextProperty, + para4: PXTextProperty, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, para9: PXClassHint){. + cdecl, dynlib: libX11, importc.} +proc XmbSetWMProperties*(para1: PDisplay, para2: Window, para3: cstring, + para4: cstring, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, + para9: PXClassHint){.cdecl, dynlib: libX11, importc.} +proc Xutf8SetWMProperties*(para1: PDisplay, para2: Window, para3: cstring, + para4: cstring, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, + para9: PXClassHint){.cdecl, dynlib: libX11, importc.} +proc XSetWMSizeHints*(para1: PDisplay, para2: Window, para3: PXSizeHints, + para4: Atom){.cdecl, dynlib: libX11, importc.} +proc XSetRegion*(para1: PDisplay, para2: GC, para3: Region): cint{.cdecl, + dynlib: libX11, importc.} +proc XSetStandardColormap*(para1: PDisplay, para2: Window, + para3: PXStandardColormap, para4: Atom){.cdecl, + dynlib: libX11, importc.} +proc XSetZoomHints*(para1: PDisplay, para2: Window, para3: PXSizeHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XShrinkRegion*(para1: Region, para2: cint, para3: cint): cint{.cdecl, + dynlib: libX11, importc.} +proc XStringListToTextProperty*(para1: PPchar, para2: cint, + para3: PXTextProperty): Status{.cdecl, + dynlib: libX11, importc.} +proc XSubtractRegion*(para1: Region, para2: Region, para3: Region): cint{. + cdecl, dynlib: libX11, importc.} +proc XmbTextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, + para4: XICCEncodingStyle, para5: PXTextProperty): cint{. + cdecl, dynlib: libX11, importc.} +proc XwcTextListToTextProperty*(para1: PDisplay, para2: ptr ptr int16, para3: cint, + para4: XICCEncodingStyle, para5: PXTextProperty): cint{. + cdecl, dynlib: libX11, importc.} +proc Xutf8TextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, + para4: XICCEncodingStyle, + para5: PXTextProperty): cint{.cdecl, + dynlib: libX11, importc.} +proc XwcFreeStringList*(para1: ptr ptr int16){.cdecl, dynlib: libX11, importc.} +proc XTextPropertyToStringList*(para1: PXTextProperty, para2: PPPchar, + para3: Pcint): Status{.cdecl, dynlib: libX11, + importc.} +proc XmbTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: PPPchar, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XwcTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: ptr ptr ptr int16, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc Xutf8TextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: PPPchar, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XUnionRectWithRegion*(para1: PXRectangle, para2: Region, para3: Region): cint{. + cdecl, dynlib: libX11, importc.} +proc XUnionRegion*(para1: Region, para2: Region, para3: Region): cint{.cdecl, + dynlib: libX11, importc.} +proc XWMGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, + para5: cuint, para6: PXSizeHints, para7: Pcint, para8: Pcint, + para9: Pcint, para10: Pcint, para11: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XXorRegion*(para1: Region, para2: Region, para3: Region): cint{.cdecl, + dynlib: libX11, importc.} +#when defined(MACROS): +proc XDestroyImage*(ximage: PXImage): cint +proc XGetPixel*(ximage: PXImage, x, y: cint): culong +proc XPutPixel*(ximage: PXImage, x, y: cint, pixel: culong): cint +proc XSubImage*(ximage: PXImage, x, y: cint, width, height: cuint): PXImage +proc XAddPixel*(ximage: PXImage, value: clong): cint +proc IsKeypadKey*(keysym: KeySym): bool +proc IsPrivateKeypadKey*(keysym: KeySym): bool +proc IsCursorKey*(keysym: KeySym): bool +proc IsPFKey*(keysym: KeySym): bool +proc IsFunctionKey*(keysym: KeySym): bool +proc IsMiscFunctionKey*(keysym: KeySym): bool +proc IsModifierKey*(keysym: KeySym): bool + #function XUniqueContext : XContext; + #function XStringToContext(_string : Pchar) : XContext; +# implementation + +#when defined(MACROS): +proc XDestroyImage(ximage: PXImage): cint = + ximage.f.destroy_image(ximage) + +proc XGetPixel(ximage: PXImage, x, y: cint): culong = + ximage.f.get_pixel(ximage, x, y) + +proc XPutPixel(ximage: PXImage, x, y: cint, pixel: culong): cint = + ximage.f.put_pixel(ximage, x, y, pixel) + +proc XSubImage(ximage: PXImage, x, y: cint, width, height: cuint): PXImage = + ximage.f.sub_image(ximage, x, y, width, height) + +proc XAddPixel(ximage: PXImage, value: clong): cint = + ximage.f.add_pixel(ximage, value) + +proc IsKeypadKey(keysym: KeySym): bool = + (keysym >= XK_KP_Space) and (keysym <= XK_KP_Equal) + +proc IsPrivateKeypadKey(keysym: KeySym): bool = + (keysym >= 0x11000000.KeySym) and (keysym <= 0x1100FFFF.KeySym) + +proc IsCursorKey(keysym: KeySym): bool = + (keysym >= XK_Home) and (keysym < XK_Select) + +proc IsPFKey(keysym: KeySym): bool = + (keysym >= XK_KP_F1) and (keysym <= XK_KP_F4) + +proc IsFunctionKey(keysym: KeySym): bool = + (keysym >= XK_F1) and (keysym <= XK_F35) + +proc IsMiscFunctionKey(keysym: KeySym): bool = + (keysym >= XK_Select) and (keysym <= XK_Break) + +proc IsModifierKey(keysym: KeySym): bool = + ((keysym >= XK_Shift_L) and (keysym <= XK_Hyper_R)) or + (keysym == XK_Mode_switch) or (keysym == XK_Num_Lock) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xv.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xv.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,87 @@ +#*********************************************************** +#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +#and the Massachusetts Institute of Technology, Cambridge, Massachusetts. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the names of Digital or MIT not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#****************************************************************** +# $XFree86: xc/include/extensions/Xv.h,v 1.3 1999/05/23 06:33:22 dawes Exp $ + +import + x + +const + XvName* = "libXVideo.so" + XvVersion* = 2 + XvRevision* = 2 # Symbols + +type + XvPortID* = XID + XvEncodingID* = XID + +{.deprecated: [TXvPortID: XvPortID].} +{.deprecated: [TXvEncodingID: XvEncodingID].} + +const + XvNone* = 0 + XvInput* = 0 + XvOutput* = 1 + XvInputMask* = 1 shl XvInput + XvOutputMask* = 1 shl XvOutput + XvVideoMask* = 0x00000004 + XvStillMask* = 0x00000008 + XvImageMask* = 0x00000010 # These two are not client viewable + XvPixmapMask* = 0x00010000 + XvWindowMask* = 0x00020000 + XvGettable* = 0x00000001 + XvSettable* = 0x00000002 + XvRGB* = 0 + XvYUV* = 1 + XvPacked* = 0 + XvPlanar* = 1 + XvTopToBottom* = 0 + XvBottomToTop* = 1 # Events + XvVideoNotify* = 0 + XvPortNotify* = 1 + XvNumEvents* = 2 # Video Notify Reasons + XvStarted* = 0 + XvStopped* = 1 + XvBusy* = 2 + XvPreempted* = 3 + XvHardError* = 4 + XvLastReason* = 4 + XvNumReasons* = XvLastReason + 1 + XvStartedMask* = 1 shl XvStarted + XvStoppedMask* = 1 shl XvStopped + XvBusyMask* = 1 shl XvBusy + XvPreemptedMask* = 1 shl XvPreempted + XvHardErrorMask* = 1 shl XvHardError + XvAnyReasonMask* = (1 shl XvNumReasons) - 1 + XvNoReasonMask* = 0 # Errors + XvBadPort* = 0 + XvBadEncoding* = 1 + XvBadControl* = 2 + XvNumErrors* = 3 # Status + XvBadExtension* = 1 + XvAlreadyGrabbed* = 2 + XvInvalidTime* = 3 + XvBadReply* = 4 + XvBadAlloc* = 5 + +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/x11/xvlib.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/x11/xvlib.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,244 @@ +#*********************************************************** +#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +#and the Massachusetts Institute of Technology, Cambridge, Massachusetts. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the names of Digital or MIT not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#****************************************************************** +# $XFree86: xc/include/extensions/Xvlib.h,v 1.3 1999/12/11 19:28:48 mvojkovi Exp $ +#* +#** File: +#** +#** Xvlib.h --- Xv library public header file +#** +#** Author: +#** +#** David Carver (Digital Workstation Engineering/Project Athena) +#** +#** Revisions: +#** +#** 26.06.91 Carver +#** - changed XvFreeAdaptors to XvFreeAdaptorInfo +#** - changed XvFreeEncodings to XvFreeEncodingInfo +#** +#** 11.06.91 Carver +#** - changed SetPortControl to SetPortAttribute +#** - changed GetPortControl to GetPortAttribute +#** - changed QueryBestSize +#** +#** 05.15.91 Carver +#** - version 2.0 upgrade +#** +#** 01.24.91 Carver +#** - version 1.4 upgrade +#** +#* + +import + x, xlib, xshm, xv + +const + libXv* = "libXv.so" + +type + PXvRational* = ptr XvRational + XvRational*{.final.} = object + numerator*: cint + denominator*: cint + + PXvAttribute* = ptr XvAttribute + XvAttribute*{.final.} = object + flags*: cint # XvGettable, XvSettable + min_value*: cint + max_value*: cint + name*: cstring + + PPXvEncodingInfo* = ptr PXvEncodingInfo + PXvEncodingInfo* = ptr XvEncodingInfo + XvEncodingInfo*{.final.} = object + encoding_id*: XvEncodingID + name*: cstring + width*: culong + height*: culong + rate*: XvRational + num_encodings*: culong + + PXvFormat* = ptr XvFormat + XvFormat*{.final.} = object + depth*: cchar + visual_id*: culong + + PPXvAdaptorInfo* = ptr PXvAdaptorInfo + PXvAdaptorInfo* = ptr XvAdaptorInfo + XvAdaptorInfo*{.final.} = object + base_id*: XvPortID + num_ports*: culong + thetype*: cchar + name*: cstring + num_formats*: culong + formats*: PXvFormat + num_adaptors*: culong + + PXvVideoNotifyEvent* = ptr XvVideoNotifyEvent + XvVideoNotifyEvent*{.final.} = object + theType*: cint + serial*: culong # # of last request processed by server + send_event*: XBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + drawable*: Drawable # drawable + reason*: culong # what generated this event + port_id*: XvPortID # what port + time*: Time # milliseconds + + PXvPortNotifyEvent* = ptr XvPortNotifyEvent + XvPortNotifyEvent*{.final.} = object + theType*: cint + serial*: culong # # of last request processed by server + send_event*: XBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + port_id*: XvPortID # what port + time*: Time # milliseconds + attribute*: Atom # atom that identifies attribute + value*: clong # value of attribute + + PXvEvent* = ptr XvEvent + XvEvent*{.final.} = object + pad*: array[0..23, clong] # case longint of + # 0 : ( + # theType : cint; + # ); + # 1 : ( + # xvvideo : XvVideoNotifyEvent; + # ); + # 2 : ( + # xvport : XvPortNotifyEvent; + # ); + # 3 : ( + # + # ); + + PXvImageFormatValues* = ptr XvImageFormatValues + XvImageFormatValues*{.final.} = object + id*: cint # Unique descriptor for the format + theType*: cint # XvRGB, XvYUV + byte_order*: cint # LSBFirst, MSBFirst + guid*: array[0..15, cchar] # Globally Unique IDentifier + bits_per_pixel*: cint + format*: cint # XvPacked, XvPlanar + num_planes*: cint # for RGB formats only + depth*: cint + red_mask*: cuint + green_mask*: cuint + blue_mask*: cuint # for YUV formats only + y_sample_bits*: cuint + u_sample_bits*: cuint + v_sample_bits*: cuint + horz_y_period*: cuint + horz_u_period*: cuint + horz_v_period*: cuint + vert_y_period*: cuint + vert_u_period*: cuint + vert_v_period*: cuint + component_order*: array[0..31, char] # eg. UYVY + scanline_order*: cint # XvTopToBottom, XvBottomToTop + + PXvImage* = ptr XvImage + XvImage*{.final.} = object + id*: cint + width*, height*: cint + data_size*: cint # bytes + num_planes*: cint + pitches*: cint # bytes + offsets*: cint # bytes + data*: pointer + obdata*: XPointer + +{.deprecated: [TXvRational: XvRational].} +{.deprecated: [TXvAttribute: XvAttribute].} +{.deprecated: [TXvEncodingInfo: XvEncodingInfo].} +{.deprecated: [TXvFormat: XvFormat].} +{.deprecated: [TXvAdaptorInfo: XvAdaptorInfo].} +{.deprecated: [TXvVideoNotifyEvent: XvVideoNotifyEvent].} +{.deprecated: [TXvPortNotifyEvent: XvPortNotifyEvent].} +{.deprecated: [TXvEvent: XvEvent].} +{.deprecated: [TXvImageFormatValues: XvImageFormatValues].} +{.deprecated: [TXvImage: XvImage].} + +proc XvQueryExtension*(display: PDisplay, p_version, p_revision, p_requestBase, + p_eventBase, p_errorBase: cuint): cint{.cdecl, dynlib: libXv, importc.} +proc XvQueryAdaptors*(display: PDisplay, window: Window, p_nAdaptors: cuint, + p_pAdaptors: PPXvAdaptorInfo): cint{.cdecl, dynlib: libXv, + importc.} +proc XvQueryEncodings*(display: PDisplay, port: XvPortID, p_nEncoding: cuint, + p_pEncoding: PPXvEncodingInfo): cint{.cdecl, + dynlib: libXv, importc.} +proc XvPutVideo*(display: PDisplay, port: XvPortID, d: Drawable, gc: GC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvPutStill*(display: PDisplay, port: XvPortID, d: Drawable, gc: GC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGetVideo*(display: PDisplay, port: XvPortID, d: Drawable, gc: GC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGetStill*(display: PDisplay, port: XvPortID, d: Drawable, gc: GC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvStopVideo*(display: PDisplay, port: XvPortID, drawable: Drawable): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGrabPort*(display: PDisplay, port: XvPortID, time: Time): cint{.cdecl, + dynlib: libXv, importc.} +proc XvUngrabPort*(display: PDisplay, port: XvPortID, time: Time): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSelectVideoNotify*(display: PDisplay, drawable: Drawable, onoff: XBool): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSelectPortNotify*(display: PDisplay, port: XvPortID, onoff: XBool): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSetPortAttribute*(display: PDisplay, port: XvPortID, attribute: Atom, + value: cint): cint{.cdecl, dynlib: libXv, importc.} +proc XvGetPortAttribute*(display: PDisplay, port: XvPortID, attribute: Atom, + p_value: cint): cint{.cdecl, dynlib: libXv, importc.} +proc XvQueryBestSize*(display: PDisplay, port: XvPortID, motion: XBool, + vid_w, vid_h, drw_w, drw_h: cuint, + p_actual_width, p_actual_height: cuint): cint{.cdecl, + dynlib: libXv, importc.} +proc XvQueryPortAttributes*(display: PDisplay, port: XvPortID, number: cint): PXvAttribute{. + cdecl, dynlib: libXv, importc.} +proc XvFreeAdaptorInfo*(adaptors: PXvAdaptorInfo){.cdecl, dynlib: libXv, importc.} +proc XvFreeEncodingInfo*(encodings: PXvEncodingInfo){.cdecl, dynlib: libXv, + importc.} +proc XvListImageFormats*(display: PDisplay, port_id: XvPortID, + count_return: cint): PXvImageFormatValues{.cdecl, + dynlib: libXv, importc.} +proc XvCreateImage*(display: PDisplay, port: XvPortID, id: cint, data: pointer, + width, height: cint): PXvImage{.cdecl, dynlib: libXv, + importc.} +proc XvPutImage*(display: PDisplay, id: XvPortID, d: Drawable, gc: GC, + image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, + dest_x, dest_y: cint, dest_w, dest_h: cuint): cint{.cdecl, + dynlib: libXv, importc.} +proc XvShmPutImage*(display: PDisplay, id: XvPortID, d: Drawable, gc: GC, + image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, + dest_x, dest_y: cint, dest_w, dest_h: cuint, + send_event: XBool): cint{.cdecl, dynlib: libXv, importc.} +proc XvShmCreateImage*(display: PDisplay, port: XvPortID, id: cint, + data: pointer, width, height: cint, + shminfo: PXShmSegmentInfo): PXvImage{.cdecl, + dynlib: libXv, importc.} +# implementation diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/LICENSE --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/LICENSE Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,19 @@ +Copyright (c) 2020 Ryan Oldenburg + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,177 @@ +import zippy/adler32, zippy/common, zippy/crc, zippy/deflate, + zippy/gzip, zippy/inflate, zippy/internal + +when (NimMajor, NimMinor, NimPatch) >= (1, 6, 0): + import std/sysrand +else: + import std/random, std/times + +export common + +proc compress*( + src: pointer, + len: int, + level = DefaultCompression, + dataFormat = dfGzip +): string {.raises: [ZippyError].} = + ## Compresses src and returns the compressed data. + let src = cast[ptr UncheckedArray[uint8]](src) + + case dataFormat: + of dfGzip: + result.setLen(10) + result[0] = 31.char + result[1] = 139.char + result[2] = 8.char + result[3] = (1.uint8 shl 3).char # Set the fname flag + + block: # https://github.com/guzba/zippy/issues/61 + let htbLen = + when (NimMajor, NimMinor, NimPatch) >= (1, 6, 0): + var urand: array[1, uint8] + if not urandom(urand): + raise newException(ZippyError, "Failed to generate random number") + (urand[0] mod 26).int + else: + let now = getTime() + var rand = initRand(now.toUnix * 1_000_000_000 + now.nanosecond) + (rand.next() mod 26).int # mod the uint first to ensure a positive int + # Add up to 26 characters as the gzip header file name + for i in 0 ..< htbLen: + result.add (97 + i).char + result.add '\0' + + deflate(result, src, len, level) + + let + checksum = crc32(src, len) + isize = len + + result.add(((checksum shr 0) and 255).char) + result.add(((checksum shr 8) and 255).char) + result.add(((checksum shr 16) and 255).char) + result.add(((checksum shr 24) and 255).char) + + result.add(((isize shr 0) and 255).char) + result.add(((isize shr 8) and 255).char) + result.add(((isize shr 16) and 255).char) + result.add(((isize shr 24) and 255).char) + + of dfZlib: + const + cm = 8.uint8 + cinfo = 7.uint8 + cmf = (cinfo shl 4) or cm + fcheck = (31.uint32 - (cmf.uint32 * 256) mod 31).uint8 + + result.setLen(2) + result[0] = cmf.char + result[1] = fcheck.char + + deflate(result, src, len, level) + + let checksum = adler32(src, len) + + result.add(((checksum shr 24) and 255).char) + result.add(((checksum shr 16) and 255).char) + result.add(((checksum shr 8) and 255).char) + result.add(((checksum shr 0) and 255).char) + + of dfDeflate: + deflate(result, src, len, level) + + else: + raise newException(ZippyError, "Invalid data format " & $dfDetect) + +proc compress*( + src: string, + level = DefaultCompression, + dataFormat = dfGzip +): string {.raises: [ZippyError].} = + compress(src.cstring, src.len, level, dataFormat) + +proc compress*( + src: seq[uint8], + level = DefaultCompression, + dataFormat = dfGzip +): seq[uint8] {.raises: [ZippyError].} = + cast[seq[uint8]](compress(cast[string](src).cstring, src.len, level, dataFormat)) + +proc uncompress*( + src: pointer, + len: int, + dataFormat = dfDetect +): string {.raises: [ZippyError].} = + ## Uncompresses src and returns the uncompressed data. + let src = cast[ptr UncheckedArray[uint8]](src) + + case dataFormat: + of dfDetect: + if ( + len > 18 and + src[0].uint8 == 31 and src[1].uint8 == 139 and src[2].uint8 == 8 and + (src[3].uint8 and 0b11100000) == 0 + ): + return uncompress(src, len, dfGzip) + + if ( + len > 6 and + (src[0].uint8 and 0b00001111) == 8 and + (src[0].uint8 shr 4) <= 7 and + ((src[0].uint16 * 256) + src[1].uint8) mod 31 == 0 + ): + return uncompress(src, len, dfZlib) + + raise newException(ZippyError, "Unable to detect compressed data format") + + of dfGzip: + uncompressGzip(result, src, len) + + of dfZlib: + if len < 6: + failUncompress() + + let + cmf = src[0].uint8 + flg = src[1].uint8 + cm = cmf and 0b00001111 + cinfo = cmf shr 4 + + if cm != 8: # DEFLATE + raise newException(ZippyError, "Unsupported compression method") + + if cinfo > 7.uint8: + raise newException(ZippyError, "Invalid compression info") + + if ((cmf.uint16 * 256) + flg.uint16) mod 31 != 0: + raise newException(ZippyError, "Invalid header") + + if (flg and 0b00100000) != 0: # FDICT + raise newException(ZippyError, "Preset dictionary is not yet supported") + + inflate(result, src, len, 2) + + let checksum = ( + src[len - 4].uint32 shl 24 or + src[len - 3].uint32 shl 16 or + src[len - 2].uint32 shl 8 or + src[len - 1].uint32 + ) + + if checksum != adler32(result): + raise newException(ZippyError, "Checksum verification failed") + + of dfDeflate: + inflate(result, src, len, 0) + +proc uncompress*( + src: string, + dataFormat = dfDetect +): string {.raises: [ZippyError].} = + uncompress(src.cstring, src.len, dataFormat) + +proc uncompress*( + src: seq[uint8], + dataFormat = dfDetect +): seq[uint8] {.raises: [ZippyError].} = + cast[seq[uint8]](uncompress(cast[string](src).cstring, src.len, dataFormat)) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/adler32.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/adler32.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,66 @@ +import internal + +when allowSimd: + import adler32_simd + +proc adler32*(src: pointer, len: int): uint32 = + ## See https://github.com/madler/zlib/blob/master/adler32.c + + when allowSimd: + when defined(amd64): + let + leaf1 = cpuid(1, 0) + ssse3 = (leaf1[2] and (1 shl 9)) != 0 + if ssse3: + return adler32_ssse3(src, len) + elif defined(arm64): + return adler32_neon(src, len) + + let src = cast[ptr UncheckedArray[uint8]](src) + + const nmax = 5552 + + var + s1 = 1.uint32 + s2 = 0.uint32 + l = len + pos: int + + template do1(i: int) = + s1 += src[pos + i] + s2 += s1 + + template do8() = + do1(0) + do1(1) + do1(2) + do1(3) + do1(4) + do1(5) + do1(6) + do1(7) + + while l >= nmax: + l -= nmax + for i in 0 ..< nmax div 8: + do8() + pos += 8 + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + while l >= 8: + l -= 8 + do8() + pos += 8 + + for i in 0 ..< l: + do1(i) + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + result = (s2 shl 16) or s1 + +proc adler32*(src: string): uint32 {.inline.} = + adler32(src.cstring, src.len) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/adler32_simd.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/adler32_simd.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,258 @@ +import common + +# These functions are Nim conversions of an original implementation +# from the Chromium repository. That implementation is: +# +# Copyright 2017 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the Chromium source repository LICENSE file. + +const + nmax = 5552 + blockSize = 32.uint32 + +when defined(amd64): + when defined(gcc) or defined(clang): + {.localPassC: "-mssse3".} + + {.push header: "emmintrin.h".} + + type M128i {.importc: "__m128i".} = object + + template MM_SHUFFLE(z, y, x, w: int | uint): int32 = + ((z shl 6) or (y shl 4) or (x shl 2) or w).int32 + + func mm_loadu_si128(p: pointer): M128i {.importc: "_mm_loadu_si128".} + func mm_setzero_si128(): M128i {.importc: "_mm_setzero_si128".} + func mm_set_epi32(a, b, c, d: int32 | uint32): M128i {.importc: "_mm_set_epi32".} + func mm_setr_epi8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p: int8 | uint8): M128i {.importc: "_mm_setr_epi8".} + func mm_set1_epi16(a: int16 | uint16): M128i {.importc: "_mm_set1_epi16".} + func mm_add_epi32(a, b: M128i): M128i {.importc: "_mm_add_epi32".} + func mm_sad_epu8(a, b: M128i): M128i {.importc: "_mm_sad_epu8".} + func mm_madd_epi16(a, b: M128i): M128i {.importc: "_mm_madd_epi16".} + func mm_slli_epi32(a: M128i, imm8: int32 | uint32): M128i {.importc: "_mm_slli_epi32".} + func mm_shuffle_epi32(a: M128i, imm8: int32 | uint32): M128i {.importc: "_mm_shuffle_epi32".} + func mm_cvtsi128_si32(a: M128i): int32 {.importc: "_mm_cvtsi128_si32".} + + {.pop.} + + {.push header: "tmmintrin.h".} + + func mm_maddubs_epi16(a, b: M128i): M128i {.importc: "_mm_maddubs_epi16".} + + {.pop.} + + proc adler32_ssse3*(src: pointer, len: int): uint32 = + if len == 0: + return 1 + + if len < 0: + raise newException(ZippyError, "Adler-32 len < 0") + if len.uint64 > uint32.high: + raise newException(ZippyError, "Adler-32 len > uint32.high") + + let src = cast[ptr UncheckedArray[uint8]](src) + + var + pos: uint32 + remaining = cast[uint32](len) + s1 = 1.uint32 + s2 = 0.uint32 + + var blocks = remaining div blockSize + + remaining -= (blocks * blockSize) + + let + tap1 = mm_setr_epi8(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17) + tap2 = mm_setr_epi8(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) + zero = mm_setzero_si128() + ones = mm_set1_epi16(1) + + while blocks > 0: + var n = nmax div blockSize + if n > blocks: + n = blocks + + blocks -= n + + var + vecPs = mm_set_epi32(0, 0, 0, s1 * n) + vecS2 = mm_set_epi32(0, 0, 0, s2) + vecS1 = mm_set_epi32(0, 0, 0, 0) + + while n > 0: + let + bytes1 = mm_loadu_si128(src[pos + 0].addr) + bytes2 = mm_loadu_si128(src[pos + 16].addr) + + vecPs = mm_add_epi32(vecPs, vecS1) + + vecS1 = mm_add_epi32(vecS1, mm_sad_epu8(bytes1, zero)) + let mad1 = mm_maddubs_epi16(bytes1, tap1) + vecS2 = mm_add_epi32(vecS2, mm_madd_epi16(mad1, ones)) + vecS1 = mm_add_epi32(vecS1, mm_sad_epu8(bytes2, zero)) + let mad2 = mm_maddubs_epi16(bytes2, tap2) + vecS2 = mm_add_epi32(vecS2, mm_madd_epi16(mad2, ones)) + + dec n + pos += 32 + + vecS2 = mm_add_epi32(vecS2, mm_slli_epi32(vecPs, 5)) + + vecS1 = mm_add_epi32(vecS1, mm_shuffle_epi32(vecS1, MM_SHUFFLE(2, 3, 0, 1))) + vecS1 = mm_add_epi32(vecS1, mm_shuffle_epi32(vecS1, MM_SHUFFLE(1, 0, 3, 2))) + s1 += cast[uint32](mm_cvtsi128_si32(vecS1)) + vecS2 = mm_add_epi32(vecS2, mm_shuffle_epi32(vecS2, MM_SHUFFLE(2, 3, 0, 1))) + vecS2 = mm_add_epi32(vecS2, mm_shuffle_epi32(vecS2, MM_SHUFFLE(1, 0, 3, 2))) + s2 = cast[uint32](mm_cvtsi128_si32(vecS2)) + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + for i in 0 ..< remaining: + s1 += src[pos + i] + s2 += s1 + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + result = (s2 shl 16) or s1 + +elif defined(arm64): + {.push header: "arm_neon.h".} + + type + uint8x16 {.importc: "uint8x16_t".} = object + uint16x8 {.importc: "uint16x8_t".} = object + uint32x4 {.importc: "uint32x4_t".} = object + uint8x8 {.importc: "uint8x8_t".} = object + uint16x4 {.importc: "uint16x4_t".} = object + uint32x2 {.importc: "uint32x2_t".} = object + + func vmovq_n_u32(a: uint32): uint32x4 + func vmovq_n_u16(a: uint16): uint16x8 + func vld1q_u32(p: pointer): uint32x4 + func vld1q_lane_u32(p: pointer, v: uint32x4, lane: int): uint32x4 + func vld1q_u8(p: pointer): uint8x16 + func vld1_u16(p: pointer): uint16x4 + func vaddq_u32(a, b: uint32x4): uint32x4 + func vpaddlq_u8(a: uint8x16): uint16x8 + func vpadalq_u8(a: uint16x8, b: uint8x16): uint16x8 + func vpadalq_u16(a: uint32x4, b: uint16x8): uint32x4 + func vget_low_u8(a: uint8x16): uint8x8 + func vget_high_u8(a: uint8x16): uint8x8 + func vaddw_u8(a: uint16x8, b: uint8x8): uint16x8 + func vshlq_n_u32(a: uint32x4, n: int): uint32x4 + func vpadd_u32(a, b: uint32x2): uint32x2 + func vget_low_u32(a: uint32x4): uint32x2 + func vget_high_u32(a: uint32x4): uint32x2 + func vget_lane_u32(a: uint32x2, lane: int): uint32 + func vget_low_u16(a: uint16x8): uint16x4 + func vget_high_u16(a: uint16x8): uint16x4 + func vmlal_u16(a: uint32x4, b, c: uint16x4): uint32x4 + + {.pop.} + + proc adler32_neon*(src: pointer, len: int): uint32 = + if len == 0: + return 1 + + if len < 0: + raise newException(ZippyError, "Adler-32 len < 0") + if len.uint64 > uint32.high: + raise newException(ZippyError, "Adler-32 len > uint32.high") + + let src = cast[ptr UncheckedArray[uint8]](src) + + var + pos: uint32 + remaining = cast[uint32](len) + s1 = 1.uint32 + s2 = 0.uint32 + + const blockSize = 32.uint32 + + var blocks = remaining div blockSize + + remaining -= (blocks * blockSize) + + var wtf1, wtf2, wtf3, wtf4, wtf5, wtf6, wtf7, wtf8, wtf9: uint16x4 + block: + var tmp = [32.uint16, 31, 30, 29] + wtf1 = vld1_u16(tmp.addr) + tmp = [28.uint16, 27, 26, 25] + wtf2 = vld1_u16(tmp.addr) + tmp = [24.uint16, 23, 22, 21] + wtf3 = vld1_u16(tmp.addr) + tmp = [20.uint16, 19, 18, 17] + wtf4 = vld1_u16(tmp.addr) + tmp = [16.uint16, 15, 14, 13] + wtf5 = vld1_u16(tmp.addr) + tmp = [12.uint16, 11, 10, 9] + wtf6 = vld1_u16(tmp.addr) + tmp = [8.uint16, 7, 6, 5] + wtf7 = vld1_u16(tmp.addr) + tmp = [4.uint16, 3, 2, 1] + wtf8 = vld1_u16(tmp.addr) + + while blocks > 0: + var n = nmax div blockSize + if n > blocks: + n = blocks + + blocks -= n + var + vecS2 = vmovq_n_u32(0) + vecS1 = vmovq_n_u32(0) + vecColumnSum1 = vmovq_n_u16(0) + vecColumnSum2 = vmovq_n_u16(0) + vecColumnSum3 = vmovq_n_u16(0) + vecColumnSum4 = vmovq_n_u16(0) + block: + var tmp = s1 * n + vecS2 = vld1q_lane_u32(tmp.addr, vecS2, 0) + + while n > 0: + let + bytes1 = vld1q_u8(src[pos + 0].addr) + bytes2 = vld1q_u8(src[pos + 16].addr) + vecS2 = vaddq_u32(vecS2, vecS1) + vecS1 = vpadalq_u16(vecS1, vpadalq_u8(vpaddlq_u8(bytes1), bytes2)) + vecColumnSum1 = vaddw_u8(vecColumnSum1, vget_low_u8(bytes1)) + vecColumnSum2 = vaddw_u8(vecColumnSum2, vget_high_u8(bytes1)) + vecColumnSum3 = vaddw_u8(vecColumnSum3, vget_low_u8(bytes2)) + vecColumnSum4 = vaddw_u8(vecColumnSum4, vget_high_u8(bytes2)) + dec n + pos += 32 + + vecS2 = vshlq_n_u32(vecS2, 5) + + vecS2 = vmlal_u16(vecS2, vget_low_u16(vecColumnSum1), wtf1) + vecS2 = vmlal_u16(vecS2, vget_high_u16(vecColumnSum1), wtf2) + vecS2 = vmlal_u16(vecS2, vget_low_u16(vecColumnSum2), wtf3) + vecS2 = vmlal_u16(vecS2, vget_high_u16(vecColumnSum2), wtf4) + vecS2 = vmlal_u16(vecS2, vget_low_u16(vecColumnSum3), wtf5) + vecS2 = vmlal_u16(vecS2, vget_high_u16(vecColumnSum3), wtf6) + vecS2 = vmlal_u16(vecS2, vget_low_u16(vecColumnSum4), wtf7) + vecS2 = vmlal_u16(vecS2, vget_high_u16(vecColumnSum4), wtf8) + + let + sum1 = vpadd_u32(vget_low_u32(vecS1), vget_high_u32(vecS1)) + sum2 = vpadd_u32(vget_low_u32(vecS2), vget_high_u32(vecS2)) + s1s2 = vpadd_u32(sum1, sum2) + + s1 += vget_lane_u32(s1s2, 0) + s2 += vget_lane_u32(s1s2, 1) + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + for i in 0 ..< remaining: + s1 += src[pos + i] + s2 += s1 + + s1 = s1 mod 65521 + s2 = s2 mod 65521 + + result = (s2 shl 16) or s1 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/bitstreams.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/bitstreams.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,126 @@ +import common, internal + +type + BitStreamReader* = object + src*: ptr UncheckedArray[uint8] + len*, pos*: int + when (defined(arm64) and defined(macosx)) or sizeof(int) == 4: + bitBuffer*: uint32 + else: + bitBuffer*: uint64 + bitsBuffered*: int + + BitStreamWriter* = object + pos*, bitPos*: int + +template failEndOfBuffer*() = + raise newException(ZippyError, "Cannot read further, at end of buffer") + +when defined(release): + {.push checks: off.} + +proc fillBitBuffer*(b: var BitStreamReader) {.inline.} = + let + bufferBitSize = sizeof(b.bitBuffer).uint * 8 + bytesNeeded = cast[int]((bufferBitSize - cast[uint](b.bitsBuffered)) div 8) + bytesAvailable = b.len - b.pos + bytesAdded = min(bytesNeeded, bytesAvailable) + pos = b.pos + + b.pos += bytesAdded + + when sizeof(b.bitBuffer) == 4: + var src: uint32 + if bytesAvailable < 4: + copyMem(src.addr, b.src[b.len - 4].addr, 4) + src = src shr (8 * (4 - bytesAvailable)) + else: + copyMem(src.addr, b.src[pos].addr, 4) + else: + var src: uint64 + if bytesAvailable < 8: + copyMem(src.addr, b.src[b.len - 8].addr, 8) + src = src shr (8 * (8 - bytesAvailable)) + else: + copyMem(src.addr, b.src[pos].addr, 8) + + b.bitBuffer = b.bitBuffer or (src shl b.bitsBuffered) + b.bitsBuffered += 8 * bytesAdded + +proc readBits*( + b: var BitStreamReader, + bits: int, + fillBitBuffer: static[bool] = true +): uint16 {.inline.} = + assert bits >= 0 and bits <= 16 + + when fillBitBuffer: + b.fillBitBuffer() + + result = (b.bitBuffer and ((1.uint32 shl bits) - 1)).uint16 + b.bitBuffer = b.bitBuffer shr bits + b.bitsBuffered -= bits # Can go negative if we've read past the end + +proc readBytes*(b: var BitStreamReader, dst: pointer, len: int) = + if b.bitsBuffered mod 8 != 0: + raise newException(ZippyError, "Must be at a byte boundary") + + let offset = b.bitsBuffered div 8 + if b.pos - offset + len > b.len: + failEndOfBuffer() + + copyMem(dst, b.src[b.pos - offset].addr, len) + + b.pos = b.pos - offset + len + b.bitsBuffered = 0 + b.bitBuffer = 0 + +proc skipRemainingBitsInCurrentByte*(b: var BitStreamReader) = + let mod8 = b.bitsBuffered mod 8 + if mod8 != 0: + b.bitsBuffered -= mod8 + b.bitBuffer = b.bitBuffer shr mod8 + +proc incPos(b: var BitStreamWriter, bits: int) {.inline.} = + b.pos += (bits + b.bitPos) shr 3 + b.bitPos = (bits + b.bitPos) and 7 + +proc addBits*( + b: var BitStreamWriter, + dst: var string, + value: uint32, + bitLen: int +) = + assert bitLen >= 0 and bitLen <= 32 + + if b.pos + 8 > dst.len: + # Make sure we have room to read64 + dst.setLen(max(dst.len * 2, 8)) + + let + dst = cast[ptr UncheckedArray[uint8]](dst[0].addr) + value = value.uint64 and ((1.uint64 shl bitLen) - 1) + write64(dst, b.pos, read32(dst, b.pos).uint64 or (value shl b.bitPos)) + b.incPos(bitLen) + +proc addBytes*( + b: var BitStreamWriter, + dst: var string, + src: ptr UncheckedArray[uint8], + srcPos, len: int +) = + if b.bitPos != 0: + raise newException(ZippyError, "Must be at a byte boundary") + + if b.pos + len > dst.len: + dst.setLen(b.pos + len) + + copyMem(dst[b.pos].addr, src[srcPos].addr, len) + b.incPos(len * 8) + +proc skipRemainingBitsInCurrentByte*(b: var BitStreamWriter) = + if b.bitPos > 0: + b.incPos(8 - b.bitPos) + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/common.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/common.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,12 @@ +type + ZippyError* = object of CatchableError ## Raised if an operation fails. + + CompressedDataFormat* = enum ## Supported compressed data formats + dfDetect, dfZlib, dfGzip, dfDeflate + +const + NoCompression* = 0 + BestSpeed* = 1 + BestCompression* = 9 + DefaultCompression* = -1 + HuffmanOnly* = -2 diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/crc.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/crc.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,78 @@ +import internal + +when allowSimd: + import crc32_simd + +const crcTables = block: + var + tables: array[8, array[256, uint32]] + c: uint32 + for i in 0.uint32 ..< 256: + c = i + for j in 0 ..< 8: + c = (c shr 1) xor ((c and 1) * 0xedb88320.uint32) + tables[0][i] = c + for i in 0 ..< 256: + tables[1][i] = (tables[0][i] shr 8) xor tables[0][tables[0][i] and 255] + tables[2][i] = (tables[1][i] shr 8) xor tables[0][tables[1][i] and 255] + tables[3][i] = (tables[2][i] shr 8) xor tables[0][tables[2][i] and 255] + tables[4][i] = (tables[3][i] shr 8) xor tables[0][tables[3][i] and 255] + tables[5][i] = (tables[4][i] shr 8) xor tables[0][tables[4][i] and 255] + tables[6][i] = (tables[5][i] shr 8) xor tables[0][tables[5][i] and 255] + tables[7][i] = (tables[6][i] shr 8) xor tables[0][tables[6][i] and 255] + tables + +when defined(release): + {.push checks: off.} + +## See https://create.stephan-brumme.com/crc32/ +proc crc32(src: pointer, len: int, crc32: uint32): uint32 = + let src = cast[ptr UncheckedArray[uint8]](src) + + result = crc32 + + var i: int + for _ in 0 ..< len div 8: + let + one = read32(src, i) xor result + two = read32(src, i + 4) + result = + crcTables[7][one and 255] xor + crcTables[6][(one shr 8) and 255] xor + crcTables[5][(one shr 16) and 255] xor + crcTables[4][one shr 24] xor + crcTables[3][two and 255] xor + crcTables[2][(two shr 8) and 255] xor + crcTables[1][(two shr 16) and 255] xor + crcTables[0][two shr 24] + i += 8 + + for j in i ..< len: + result = crcTables[0][(result xor src[j]) and 255] xor (result shr 8) + +proc crc32*(src: pointer, len: int): uint32 = + let src = cast[ptr UncheckedArray[uint8]](src) + + var pos: int + + when allowSimd: + when defined(amd64): + let + leaf1 = cpuid(1, 0) + sse41 = (leaf1[2] and (1 shl 19)) != 0 + pclmulqdq = (leaf1[2] and (1 shl 1)) != 0 + if sse41 and pclmulqdq and len >= 64: + let simdLen = (len div 16) * 16 # Multiple of 16 + result = not crc32_sse41_pcmul(src[0].addr, simdLen, not result) + pos += simdLen + elif defined(arm64) and defined(macosx): # M1 has CRC32*, Pi 3, 4 does not + return crc32_armv8a_crypto(src, len) + + if pos < len: + result = not crc32(src[pos].addr, len - pos, not result) + +proc crc32*(src: string): uint32 {.inline.} = + crc32(src.cstring, src.len) + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/crc32_simd.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/crc32_simd.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,172 @@ +# These functions are Nim conversions of an original implementation +# from the Chromium repository. That implementation is: +# +# Copyright 2017 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the Chromium source repository LICENSE file. + +when defined(amd64): + when defined(gcc) or defined(clang): + {.localPassC: "-msse4.1 -mpclmul".} + + {.push header: "emmintrin.h".} + + type M128i {.importc: "__m128i".} = object + + func mm_load_si128(p: pointer): M128i {.importc: "_mm_load_si128".} + func mm_loadu_si128(p: pointer): M128i {.importc: "_mm_loadu_si128".} + func mm_loadl_epi64(p: pointer): M128i {.importc: "_mm_loadl_epi64".} + func mm_setr_epi32(a, b, c, d: int32 | uint32): M128i {.importc: "_mm_setr_epi32".} + func mm_srli_si128(a: M128i, imm8: int32 | uint32): M128i {.importc: "_mm_srli_si128".} + func mm_xor_si128(a, b: M128i): M128i {.importc: "_mm_xor_si128".} + func mm_and_si128(a, b: M128i): M128i {.importc: "_mm_and_si128".} + func mm_cvtsi32_si128(a: int32 | uint32): M128i {.importc: "_mm_cvtsi32_si128".} + + {.pop.} + + {.push header: "smmintrin.h".} + + func mm_extract_epi32(a: M128i, imm8: int32 | uint32): int32 {.importc: "_mm_extract_epi32".} + + {.pop.} + + {.push header: "wmmintrin.h".} + + func mm_clmulepi64_si128(a, b: M128i, imm8: int32 | uint32): M128i {.importc: "_mm_clmulepi64_si128".} + + {.pop.} + + proc crc32_sse41_pcmul*(src: pointer, len: int, crc32: uint32): uint32 = + ## Computes the crc32 of the buffer, where the buffer + ## length must be at least 64, and a multiple of 16. + let + k1k2 = [0x0154442bd4.uint64, 0x01c6e41596.uint64] + k3k4 = [0x01751997d0.uint64, 0x00ccaa009e.uint64] + k5k0 = [0x0163cd6124.uint64, 0x0000000000.uint64] + poly = [0x01db710641.uint64, 0x01f7011641.uint64] + + let src = cast[ptr UncheckedArray[uint8]](src) + + var + pos = 0 + len = len + x0, x1, x2, x3, x4, x5, x6, x7, x8, y5, y6, y7, y8: M128i + + x1 = mm_loadu_si128((src[pos + 0x00].addr)) + x2 = mm_loadu_si128((src[pos + 0x10].addr)) + x3 = mm_loadu_si128((src[pos + 0x20].addr)) + x4 = mm_loadu_si128((src[pos + 0x30].addr)) + + x1 = mm_xor_si128(x1, mm_cvtsi32_si128(crc32)) + + x0 = mm_load_si128(k1k2.unsafeAddr) + + pos += 64 + len -= 64 + + while (len >= 64): + x5 = mm_clmulepi64_si128(x1, x0, 0x00) + x6 = mm_clmulepi64_si128(x2, x0, 0x00) + x7 = mm_clmulepi64_si128(x3, x0, 0x00) + x8 = mm_clmulepi64_si128(x4, x0, 0x00) + + x1 = mm_clmulepi64_si128(x1, x0, 0x11) + x2 = mm_clmulepi64_si128(x2, x0, 0x11) + x3 = mm_clmulepi64_si128(x3, x0, 0x11) + x4 = mm_clmulepi64_si128(x4, x0, 0x11) + + y5 = mm_loadu_si128(src[pos + 0x00].addr) + y6 = mm_loadu_si128(src[pos + 0x10].addr) + y7 = mm_loadu_si128(src[pos + 0x20].addr) + y8 = mm_loadu_si128(src[pos + 0x30].addr) + + x1 = mm_xor_si128(x1, x5) + x2 = mm_xor_si128(x2, x6) + x3 = mm_xor_si128(x3, x7) + x4 = mm_xor_si128(x4, x8) + + x1 = mm_xor_si128(x1, y5) + x2 = mm_xor_si128(x2, y6) + x3 = mm_xor_si128(x3, y7) + x4 = mm_xor_si128(x4, y8) + + pos += 64 + len -= 64 + + x0 = mm_load_si128(k3k4.unsafeAddr) + + x5 = mm_clmulepi64_si128(x1, x0, 0x00) + x1 = mm_clmulepi64_si128(x1, x0, 0x11) + x1 = mm_xor_si128(x1, x2) + x1 = mm_xor_si128(x1, x5) + + x5 = mm_clmulepi64_si128(x1, x0, 0x00) + x1 = mm_clmulepi64_si128(x1, x0, 0x11) + x1 = mm_xor_si128(x1, x3) + x1 = mm_xor_si128(x1, x5) + + x5 = mm_clmulepi64_si128(x1, x0, 0x00) + x1 = mm_clmulepi64_si128(x1, x0, 0x11) + x1 = mm_xor_si128(x1, x4) + x1 = mm_xor_si128(x1, x5) + + while (len >= 16): + x2 = mm_loadu_si128(src[pos].addr) + + x5 = mm_clmulepi64_si128(x1, x0, 0x00) + x1 = mm_clmulepi64_si128(x1, x0, 0x11) + x1 = mm_xor_si128(x1, x2) + x1 = mm_xor_si128(x1, x5) + + pos += 16 + len -= 16 + + x2 = mm_clmulepi64_si128(x1, x0, 0x10) + x3 = mm_setr_epi32(not 0, 0, not 0, 0) + x1 = mm_srli_si128(x1, 8) + x1 = mm_xor_si128(x1, x2) + + x0 = mm_loadl_epi64(k5k0.unsafeAddr) + + x2 = mm_srli_si128(x1, 4) + x1 = mm_and_si128(x1, x3) + x1 = mm_clmulepi64_si128(x1, x0, 0x00) + x1 = mm_xor_si128(x1, x2) + + x0 = mm_load_si128(poly.unsafeAddr) + + x2 = mm_and_si128(x1, x3) + x2 = mm_clmulepi64_si128(x2, x0, 0x10) + x2 = mm_and_si128(x2, x3) + x2 = mm_clmulepi64_si128(x2, x0, 0x00) + x1 = mm_xor_si128(x1, x2) + + cast[uint32](mm_extract_epi32(x1, 1)) + +elif defined(arm64): + func crc32b(crc: uint32, v: uint8): uint32 {.importc: "__builtin_arm_crc32b", nodecl.} + func crc32d(crc: uint32, v: uint64): uint32 {.importc: "__builtin_arm_crc32d", nodecl.} + + proc crc32_armv8a_crypto*(src: pointer, len: int): uint32 = + let src = cast[ptr UncheckedArray[uint8]](src) + + var pos = 0 + + result = not result + + # Align + while pos < len and (cast[uint](src[pos].addr) and 7) != 0: + result = crc32b(result, src[pos]) + inc pos + + while pos + 8 <= len: + var tmp: uint64 + copyMem(tmp.addr, src[pos].addr, 8) + result = crc32d(result, tmp) + pos += 8 + + while pos < len: + result = crc32b(result, src[pos]) + inc pos + + result = not result diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/deflate.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/deflate.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,470 @@ +import bitstreams, common, internal, lz77, snappy, std/bitops, std/heapqueue + +type Node = ref object + symbol, freq: int + left, right: Node + +when defined(release): + {.push checks: off.} + +proc `<`(a, b: Node): bool {.inline.} = + a.freq < b.freq + +proc huffmanCodes( + frequencies: openArray[uint32], + minCodes, codeLengthLimit: int +): (seq[uint16], seq[uint8]) = + # https://en.wikipedia.org/wiki/Huffman_coding#Length-limited_Huffman_coding + # https://en.wikipedia.org/wiki/Canonical_Huffman_code + # https://create.stephan-brumme.com/length-limited-prefix-codes/ + + var + highestSymbol: int + numSymbolsUsed: int + for symbol, freq in frequencies: + if freq > 0.uint32: + highestSymbol = symbol + inc numSymbolsUsed + + var + numCodes = max(highestSymbol, minCodes) + 1 + codes = newSeq[uint16](numCodes) + codeLens = newSeq[uint8](numCodes) + + if numSymbolsUsed == 0: + codeLens[0] = 1 + codeLens[1] = 1 + elif numSymbolsUsed == 1: + for i, freq in frequencies: + if freq != 0: + codeLens[i] = 1 + if i == 0: + codeLens[1] = 1 + else: + codeLens[0] = 1 + break + else: + var nodes: seq[Node] + for symbol, freq in frequencies: + if freq > 0.uint32: + nodes.add(Node(symbol: symbol, freq: freq.int)) + + proc buildTree(nodes: seq[Node]): bool = + var heap: HeapQueue[Node] + for node in nodes: + heap.push(node) + + while heap.len >= 2: + let node = Node( + symbol: -1, + left: heap.pop(), + right: heap.pop() + ) + node.freq = node.left.freq + node.right.freq + heap.push(node) + + proc visit(node: Node, level: int, needsLengthLimiting: var bool) = + if node.symbol == -1: + visit(node.left, level + 1, needsLengthLimiting) + visit(node.right, level + 1, needsLengthLimiting) + else: + node.freq = level # Re-use freq for level + if level > codeLengthLimit: + needsLengthLimiting = true + + visit(heap[0], 0, result) + + let needsLengthLimiting = buildTree(nodes) + if needsLengthLimiting: + var longestCode: int + for node in nodes: + longestCode = max(longestCode, node.freq) + + var histogram = newSeq[int](longestCode + 1) + for node in nodes: + inc histogram[node.freq] + + var i = longestCode + while i > codeLengthLimit: + if histogram[i] == 0: + dec i + continue + + var j = i - 2 + while j > 0 and histogram[j] == 0: + dec j + + histogram[i] -= 2 + inc histogram[i - 1] + + histogram[j + 1] += 2 + dec histogram[j] + + proc quickSort(a: var seq[Node], inl, inr: int) = + var + r = inr + l = inl + let n = r - l + 1 + if n < 2: + return + let p = a[l + 3 * n div 4].freq + while l <= r: + if a[l].freq < p: + inc l + elif a[r].freq > p: + dec r + else: + swap(a[l], a[r]) + inc l + dec r + quickSort(a, inl, r) + quickSort(a, l, inr) + + quicksort(nodes, 0, nodes.high) + + var codeLen = 1 + for node in nodes: + while histogram[codeLen] == 0: + inc codeLen + continue + node.freq = codeLen + dec histogram[codeLen] + + for node in nodes: + codeLens[node.symbol] = node.freq.uint8 + + var histogram: array[maxCodeLength + 1, uint8] + for l in codeLens: + inc histogram[l] + histogram[0] = 0 + + var nextCode: array[maxCodeLength + 1, uint16] + for i in 1 .. maxCodeLength: + nextCode[i] = (nextCode[i - 1] + histogram[i - 1]) shl 1 + + # Convert to canonical codes (+ reversed) + for i in 0 ..< codes.len: + if codeLens[i] != 0: + codes[i] = reverseBits(nextCode[codeLens[i]]) shr (16.uint8 - codeLens[i]) + inc nextCode[codeLens[i]] + + (codes, codeLens) + +proc encodeAllLiterals( + encoding: var seq[uint16], + ep: var int, + metadata: var BlockMetadata, + src: ptr UncheckedArray[uint8], + start, len: int +) = + for i in 0 ..< len: + inc metadata.litLenFreq[src[start + i]] + + let + a = len div maxLiteralLength + b = len mod maxLiteralLength + c = a + (if b > 0: 1 else: 0) + if ep + c > encoding.len: + encoding.setLen(ep + c) + for i in 0 ..< a: + encoding[ep] = maxLiteralLength.uint16 + inc ep + if b > 0: + encoding[ep] = b.uint16 + inc ep + + metadata.litLenFreq[256] = 1 # Alway 1 end-of-block symbol + metadata.numLiterals = len + +proc addNoCompressionBlock( + b: var BitStreamWriter, + dst: var string, + src: ptr UncheckedArray[uint8], + blockStart, blockLen: int, + finalBlock: bool +) = + let uncompressedBlockCount = max( + (blockLen + maxUncompressedBlockSize - 1) div maxUncompressedBlockSize, + 1 + ) + for blockNum in 0 ..< uncompressedBlockCount: + let + uncompressedFinalBlock = blockNum == (uncompressedBlockCount - 1) + uncompressedBlockStart = blockStart + blockNum * maxUncompressedBlockSize + uncompressedBlockLen = min( + blockStart + blockLen - uncompressedBlockStart, + maxUncompressedBlockSize + ) + + b.addBits(dst, if finalBlock and uncompressedFinalBlock: 1 else: 0, 1) + b.addBits(dst, 0, 2) + b.skipRemainingBitsInCurrentByte() + b.addBits(dst, uncompressedBlockLen.uint16, 16) + b.addBits(dst, (maxUncompressedBlockSize - uncompressedBlockLen).uint16, 16) + if uncompressedBlockLen > 0: + b.addBytes(dst, src, uncompressedBlockStart, uncompressedBlockLen.int) + +proc deflate*(dst: var string, src: ptr UncheckedArray[uint8], len, level: int) = + if level < -2 or level > 9: + raise newException(ZippyError, "Invalid compression level " & $level) + + var b: BitStreamWriter + b.pos = dst.len + + if level == 0: + let blockCount = max( + (len + maxUncompressedBlockSize - 1) div maxUncompressedBlockSize, + 1 + ) + for blockNum in 0 ..< blockCount: + let + finalBlock = blockNum == (blockCount - 1) + blockStart = blockNum * maxUncompressedBlockSize + blockLen = min(len - blockStart, maxUncompressedBlockSize) + b.addNoCompressionBlock(dst, src, blockStart, blockLen, finalBlock) + dst.setLen(b.pos) + return + + let blockCount = max((len + maxBlockSize - 1) div maxBlockSize, 1) + + var + encoding: seq[uint16] + encodingLen: int + for blockNum in 0 ..< blockCount: + let + blockStart = blockNum * maxBlockSize + blockLen = min(len - blockStart, maxBlockSize) + finalBlock = blockNum == (blockCount - 1) + + encodingLen = 0 + + var metadata: BlockMetadata + + case level: + of -2: + encodeAllLiterals( + encoding, + encodingLen, + metadata, + src, + blockStart, + blockLen + ) + of 1: + encodeSnappy( + encoding, + encodingLen, + metadata, + src, + blockStart, + blockLen + ) + else: + # -1 or [2, 9] + encodeLz77( + encoding, + encodingLen, + configurationTable[if level == -1: 6 else: level], + metadata, + src, + blockStart, + blockLen + ) + + # If encoding returned almost all literals then write uncompressed. + if level != -2 and metadata.numLiterals >= (blockLen.float32 * 0.98).int: + b.addNoCompressionBlock(dst, src, blockStart, blockLen, finalBlock) + continue + + let + useFixedCodes = level <= 6 and blockLen <= 2048 + (litLenCodes, litLenCodeLengths) = block: + if useFixedCodes: + (fixedLitLenCodes, fixedLitLenCodeLengths) + else: + huffmanCodes(metadata.litLenFreq, 257, maxCodeLength) + (distanceCodes, distanceCodeLengths) = block: + if useFixedCodes: + (fixedDistanceCodes, fixedDistanceCodeLengths) + else: + huffmanCodes(metadata.distanceFreq, 2, maxCodeLength) + + if useFixedCodes: + b.addBits(dst, if finalBlock: 1 else: 0, 1) + b.addBits(dst, 1, 2) # Fixed Huffman codes + else: + var + codeLengths: array[maxLitLenCodes + maxDistanceCodes, uint8] + numCodes = litLenCodes.len + distanceCodes.len + block: + var cli: int + for i in 0 ..< litLenCodes.len: + codeLengths[cli] = litLenCodeLengths[i] + inc cli + for i in 0 ..< distanceCodes.len: + codeLengths[cli] = distanceCodeLengths[i] + inc cli + + var codeLengthsRle: seq[uint8] + block: + var i: int + while i < numCodes: + var repeatCount: int + while i + repeatCount + 1 < numCodes and + codeLengths[i + repeatCount + 1] == codeLengths[i]: + inc repeatCount + + if codeLengths[i] == 0 and repeatCount >= 2: + inc repeatCount # Initial zero + if repeatCount <= 10: + codeLengthsRle.add(17) + codeLengthsRle.add(repeatCount.uint8 - 3) + else: + repeatCount = min(repeatCount, 138) # Max of 138 zeros for code 18 + codeLengthsRle.add(18) + codeLengthsRle.add(repeatCount.uint8 - 11) + i += repeatCount - 1 + elif repeatCount >= 3: # Repeat code for non-zero, must be >= 3 times + var + a = repeatCount div 6 + b = repeatCount mod 6 + codeLengthsRle.add(codeLengths[i]) + for j in 0 ..< a: + codeLengthsRle.add(16) + codeLengthsRle.add(3) + if b >= 3: + codeLengthsRle.add(16) + codeLengthsRle.add(b.uint8 - 3) + else: + repeatCount -= b + i += repeatCount + else: + codeLengthsRle.add(codeLengths[i]) + inc i + + var clFreq: array[19, uint32] + block: + var i: int + while i < codeLengthsRle.len: + inc clFreq[codeLengthsRle[i]] + # Skip the number of times codes are repeated + if codeLengthsRle[i] >= 16.uint8: + inc i + inc i + + let (clCodes, clCodeLengths) = huffmanCodes(clFreq, clFreq.len, 7) + + var clclOrdered: array[19, uint16] + for i in 0 ..< clclOrdered.len: + clclOrdered[i] = clCodeLengths[clclOrder[i]] + + var hclen = clclOrdered.len + while clclOrdered[hclen - 1] == 0 and clclOrdered.len > 4: + dec hclen + hclen -= 4 + + let + hlit = litLenCodes.len - firstLengthCodeIndex + hdist = distanceCodes.len - 1 + + b.addBits(dst, if finalBlock: 1 else: 0, 1) + b.addBits(dst, 2, 2) # Dynamic Huffman codes + + b.addBits(dst, hlit.uint32, 5) + b.addBits(dst, hdist.uint32, 5) + b.addBits(dst, hclen.uint32, 4) + + for i in 0 ..< hclen + 4: + b.addBits(dst, clclOrdered[i], 3) + + block: + var i: int + while i < codeLengthsRle.len: + let symbol = codeLengthsRle[i] + b.addBits(dst, clCodes[symbol], clCodeLengths[symbol].int) + inc i + if symbol == 16: + b.addBits(dst, codeLengthsRle[i], 2) + inc i + elif symbol == 17: + b.addBits(dst, codeLengthsRle[i], 3) + inc i + elif symbol == 18: + b.addBits(dst, codeLengthsRle[i], 7) + inc i + + block: + var + srcPos = blockStart + encPos: int + while encPos < encodingLen: + if (encoding[encPos] and (1 shl 15)) != 0: + let + value = encoding[encPos + 0] + offset = encoding[encPos + 1] + length = encoding[encPos + 2] + lengthIndex = (value shr 8) and (uint8.high shr 1) + distanceIndex = value and uint8.high + lengthExtraBits = baseLengthsExtraBits[lengthIndex].int + lengthExtra = length - baseLengths[lengthIndex] + distanceExtraBits = baseDistanceExtraBits[distanceIndex].int + distanceExtra = offset - baseDistances[distanceIndex] + + encPos += 3 + srcPos += length.int + + var + buf = litLenCodes[lengthIndex + 257].uint64 + bitLen = litLenCodeLengths[lengthIndex + 257].int + buf = buf or (lengthExtra.uint64 shl bitLen) + bitLen += lengthExtraBits + + buf = buf or (distanceCodes[distanceIndex].uint64 shl bitLen) + bitLen += distanceCodeLengths[distanceIndex].int + buf = buf or (distanceExtra.uint64 shl bitLen) + bitLen += distanceExtraBits + + let firstAddLen = min(bitLen, 32) + b.addBits(dst, buf.uint32, firstAddLen) + buf = buf shr firstAddLen + bitLen -= firstAddLen + + if bitLen > 0: + b.addBits(dst, buf.uint32, bitLen) + + else: + let literalsLength = encoding[encPos].int + inc encPos + + var + buf: uint32 + bitLen: int + for _ in 0 ..< literalsLength: + let codeLength = litLenCodeLengths[src[srcPos]].int + if bitLen + codeLength > 32: + # Flush + b.addBits(dst, buf, bitLen) + buf = 0 + bitLen = 0 + buf = buf or litLenCodes[src[srcPos]].uint32 shl bitLen + bitLen += codeLength + inc srcPos + + if bitLen > 0: + b.addBits(dst, buf, bitLen) + + if encPos != encodingLen: + failUncompress() + + assert srcPos == blockStart + blockLen + + if litLenCodeLengths[256] == 0: + failCompress() + + b.addBits(dst, litLenCodes[256], litLenCodeLengths[256].int) # End of block + + b.skipRemainingBitsInCurrentByte() + dst.setLen(b.pos) + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/gzip.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/gzip.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,77 @@ +import common, crc, inflate, internal + +proc uncompressGzip*( + dst: var string, + src: ptr UncheckedArray[uint8], + len: int, + trustSize = false +) = + # Assumes the gzip src data only contains one file. + if len < 18: + failUncompress() + + let + id1 = src[0].uint8 + id2 = src[1].uint8 + cm = src[2].uint8 + flg = src[3].uint8 + # mtime = src[4 .. 7] + # xfl = src[8] + # os = src[9] + + if id1 != 31 or id2 != 139: + raise newException(ZippyError, "Failed gzip identification values check") + + if cm != 8: # DEFLATE + raise newException(ZippyError, "Unsupported compression method") + + if (flg and 0b11100000) > 0.uint8: + raise newException(ZippyError, "Reserved flag bits set") + + let + # ftext = (flg and (1.uint8 shl 0)) != 0 + fhcrc = (flg and (1.uint8 shl 1)) != 0.uint8 + fextra = (flg and (1.uint8 shl 2)) != 0.uint8 + fname = (flg and (1.uint8 shl 3)) != 0.uint8 + fcomment = (flg and (1.uint8 shl 4)) != 0.uint8 + + var pos = 10 + + if fextra: + raise newException(ZippyError, "Currently unsupported flags are set") + + proc nextZeroByte(src: ptr UncheckedArray[uint8], len, start: int): int = + for i in start ..< len: + if src[i] == 0: + return i + failUncompress() + + if fname: + pos = nextZeroByte(src, len, pos) + 1 + + if fcomment: + pos = nextZeroByte(src, len, pos) + 1 + + if fhcrc: + if pos + 2 >= len: + failUncompress() + # TODO: Need to implement this with a test file + pos += 2 + + if pos + 8 >= len: + failUncompress() + + let + checksum = read32(src, len - 8) + isize = read32(src, len - 4) + + if trustSize: + dst.setLen(isize + 16) # Leave some room to write past the end + + inflate(dst, src, len, pos) + + if checksum != crc32(dst): + raise newException(ZippyError, "Checksum verification failed") + + if isize != (dst.len mod (1 shl 32)).uint32: + raise newException(ZippyError, "Size verification failed") diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/inflate.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/inflate.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,294 @@ +import bitstreams, common, internal + +when defined(clang): + func bitreverse16(v: uint16): uint16 {.importc: "__builtin_bitreverse16", nodecl.} + proc reverseBits(v: uint16): uint16 {.inline.} = + bitreverse16(v) +else: + import std/bitops + +const + fastBits = 9 + fastMask = (1 shl fastBits) - 1 + +type Huffman = object + firstCode, firstSymbol: array[16, uint16] + maxCodes: array[17, uint32] + # lengths: array[288, uint8] + values: array[288, uint16] + fast: array[1 shl fastBits, uint16] + +when defined(release): + {.push checks: off.} + +proc initHuffman(codeLengths: openArray[uint8]): Huffman = + ## See https://raw.githubusercontent.com/madler/zlib/master/doc/algorithm.txt + + var histogram: array[17, uint16] + for i in 0 ..< codeLengths.len: + inc histogram[codeLengths[i]] + histogram[0] = 0 + + for i in 1 ..< 16: + if histogram[i] > (1.uint16 shl i): + failUncompress() + + var + code: uint32 + k: uint16 + nextCode: array[16, uint32] + for i in 1 ..< 16: + nextCode[i] = code + result.firstCode[i] = code.uint16 + result.firstSymbol[i] = k + code = code + histogram[i] + if histogram[i] > 0.uint16 and code - 1 >= (1.uint32 shl i): + failUncompress() + result.maxCodes[i] = (code shl (16 - i)) + code = code shl 1 + k += histogram[i] + + result.maxCodes[16] = 1 shl 16 + + for i, len in codeLengths: + if len > 0.uint8: + let symbolId = + nextCode[len] - result.firstCode[len] + result.firstSymbol[len] + # result.lengths[symbolId] = len + result.values[symbolId] = i.uint16 + if len <= fastBits: + let fast = (len.uint16 shl fastBits) or i.uint16 + var k = reverseBits(nextCode[len].uint16) shr (16.uint16 - len) + while k < (1 shl fastBits): + result.fast[k] = fast + k += (1.uint16 shl len) + inc nextCode[len] + +proc decodeSymbolSlow(b: var BitStreamReader, h: Huffman): uint16 = + let + k = reverseBits(b.bitBuffer.uint16) + maxCodeLength = h.maxCodes.len.uint16 + var codeLength = fastBits.uint16 + 1 + while codeLength < maxCodeLength: + if k.uint32 < h.maxCodes[codeLength]: + break + inc codeLength + + if codeLength >= 16.uint16: + # Bad code length. Instead of raising an exception here though, + # let the checks handling this return value call failUncompress(). + # For some reason failUncompress() here has significant performance impact + # on M1 arm64. + return uint16.high + + let symbolId = + (k shr (16.uint16 - codeLength)) - + h.firstCode[codeLength] + + h.firstSymbol[codeLength] + + result = h.values[symbolId] + b.bitBuffer = b.bitBuffer shr codeLength + b.bitsBuffered -= codeLength.int + +proc decodeSymbol(b: var BitStreamReader, h: Huffman): uint16 {.inline.} = + ## This function is the most important for inflate performance. + let fast = h.fast[b.bitBuffer and fastMask] + if fast > 0.uint16: + let codeLength = fast shr fastBits + result = fast and fastMask + b.bitBuffer = b.bitBuffer shr codeLength + b.bitsBuffered -= codeLength.int + else: # Slow path + result = b.decodeSymbolSlow(h) + +proc inflateBlock( + dst: var string, + b: var BitStreamReader, + op: var int, + fixedCodes: bool +) = + var literalsHuffman, distancesHuffman: Huffman + if fixedCodes: + literalsHuffman = initHuffman(fixedLitLenCodeLengths) + distancesHuffman = initHuffman(fixedDistanceCodeLengths) + else: + let + hlit = b.readBits(5).int + 257 + hdist = b.readBits(5).int + 1 + hclen = b.readBits(4).int + 4 + + if hlit > maxLitLenCodes: + failUncompress() + + if hdist > maxDistanceCodes: + failUncompress() + + var clcls: array[19, uint8] + for i in 0 ..< hclen: + clcls[clclOrder[i]] = b.readBits(3).uint8 + + let clclsHuffman = initHuffman(clcls) + + # From RFC 1951, all code lengths form a single sequence of HLIT + HDIST + # This means the max unpacked length is 31 + 31 + 257 + 1 = 320 + + var + unpacked: array[320, uint8] + i: int + while i != hlit + hdist: + if b.bitsBuffered < 15: + b.fillBitBuffer() + let symbol = decodeSymbol(b, clclsHuffman) + if b.bitsBuffered < 0: + failEndOfBuffer() + if symbol <= 15: + unpacked[i] = symbol.uint8 + inc i + elif symbol == 16: + if i == 0: + failUncompress() + let + prev = unpacked[i - 1] + repeatCount = b.readBits(2).int + 3 + if i + repeatCount > unpacked.len: + failUncompress() + for _ in 0 ..< repeatCount: + unpacked[i] = prev + inc i + elif symbol == 17: + let repeatZeroCount = b.readBits(3).int + 3 + i += repeatZeroCount + elif symbol == 18: + let repeatZeroCount = b.readBits(7).int + 11 + i += repeatZeroCount + else: + raise newException(ZippyError, "Invalid symbol") + + if i > hlit + hdist: + failUncompress() + + literalsHuffman = initHuffman(unpacked.toOpenArray(0, hlit - 1)) + distancesHuffman = initHuffman(unpacked.toOpenArray(hlit, hlit + hdist - 1)) + + while true: + when defined(arm64) and defined(macosx): + b.fillBitBuffer() + var symbol: uint16 + while true: + symbol = decodeSymbol(b, literalsHuffman) + if symbol <= 255 and b.bitsBuffered >= 15: + if op >= dst.len: + dst.setLen(max(op * 2, 2)) + dst[op] = symbol.char + inc op + else: + break + else: + if b.bitsBuffered < 15: + b.fillBitBuffer() + let symbol = decodeSymbol(b, literalsHuffman) + if b.bitsBuffered < 0: + failEndOfBuffer() + if symbol <= 255: + if op >= dst.len: + dst.setLen(max(op * 2, 2)) + dst[op] = symbol.char + inc op + elif symbol == 256: + break + else: + b.fillBitBuffer() + + let lengthIdx = (symbol - 257).int + if lengthIdx >= baseLengths.len: + failUncompress() + + let copyLength = ( + baseLengths[lengthIdx] + + b.readBits(baseLengthsExtraBits[lengthIdx].int, false) # Up to 5 + ).int + + let distanceIdx = decodeSymbol(b, distancesHuffman) # Up to 15 + if distanceIdx >= baseDistances.len.uint16: + failUncompress() + + when sizeof(b.bitBuffer) == 4: + if b.bitsBuffered < 13: + b.fillBitBuffer() + + let distance = ( + baseDistances[distanceIdx] + + b.readBits(baseDistanceExtraBits[distanceIdx].int, false) # Up to 13 + ).int + + if distance > op: + failUncompress() + + # Min match is 3 so leave room to overwrite by 13 + if op + copyLength + 13 > dst.len: + dst.setLen((op + copyLength) * 2 + 10) # At least 16 + + let dst = cast[ptr UncheckedArray[uint8]](dst[0].addr) + + if copyLength <= 16 and distance >= 8: + copy64(dst, dst, op, op - distance) + copy64(dst, dst, op + 8, op - distance + 8) + else: + var + copyFrom = op - distance + copyTo = op + remaining = copyLength + while copyTo - copyFrom < 8: + copy64(dst, dst, copyTo, copyFrom) + remaining -= copyTo - copyFrom + copyTo += copyTo - copyFrom + while remaining > 0: + copy64(dst, dst, copyTo, copyFrom) + copyFrom += 8 + copyTo += 8 + remaining -= 8 + op += copyLength + +proc inflateNoCompression( + dst: var string, + b: var BitStreamReader, + op: var int +) = + b.skipRemainingBitsInCurrentByte() + let + len = b.readBits(16).int + nlen = b.readBits(16).int + if len + nlen != 65535: + failUncompress() + if len > 0: + dst.setLen(op + len) # Make room for the bytes to be copied to + b.readBytes(dst[op].addr, len) + op += len + +proc inflate*(dst: var string, src: ptr UncheckedArray[uint8], len, pos: int) = + var + b = BitStreamReader(src: src, len: len, pos: pos) + op: int + finalBlock: bool + while not finalBlock: + let + bfinal = b.readBits(1) + btype = b.readBits(2) + + if bfinal != 0.uint16: + finalBlock = true + + case btype: + of 0: # No compression + inflateNoCompression(dst, b, op) + of 1: # Compressed with fixed Huffman codes + inflateBlock(dst, b, op, true) + of 2: # Compressed with dynamic Huffman codes + inflateBlock(dst, b, op, false) + else: + raise newException(ZippyError, "Invalid block header") + + dst.setLen(op) + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/internal.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/internal.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,339 @@ +import common, std/bitops, std/os, std/strutils + +const allowSimd* = + when (NimMajor, NimMinor, NimPatch) >= (1, 2, 0): + not defined(zippyNoSimd) and not defined(tcc) + else: + false + +const + maxCodeLength* = 15 + maxLitLenCodes* = 286 + maxDistanceCodes* = 30 + maxFixedLitLenCodes* = 288 + maxWindowSize* = 32768 + maxUncompressedBlockSize* = 65535 + maxBlockSize* = 4194304 + firstLengthCodeIndex* = 257 + baseMatchLen* = 3 + minMatchLen* = 4 + maxMatchLen* = 258 + + # For run length encodings (lz77, snappy), the uint16 high bit is reserved + # to signal that a offset and length are encoded in the uint16. + maxLiteralLength* = uint16.high.int shr 1 + + baseLengths* = [ + 3.uint16, 4, 5, 6, 7, 8, 9, 10, # 257 - 264 + 11, 13, 15, 17, # 265 - 268 + 19, 23, 27, 31, # 269 - 273 + 35, 43, 51, 59, # 274 - 276 + 67, 83, 99, 115, # 278 - 280 + 131, 163, 195, 227, # 281 - 284 + 258 # 285 + ] + + baseLengthsExtraBits* = [ + 0.uint8, 0, 0, 0, 0, 0, 0, 0, # 257 - 264 + 1, 1, 1, 1, # 265 - 268 + 2, 2, 2, 2, # 269 - 273 + 3, 3, 3, 3, # 274 - 276 + 4, 4, 4, 4, # 278 - 280 + 5, 5, 5, 5, # 281 - 284 + 0 # 285 + ] + + baseLengthIndices* = [ + 0.uint8, 1, 2, 3, 4, 5, 6, 7, 8, 8, + 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, + 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, + 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, + 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, + 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, + 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, + 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 28 + ] + + baseDistances* = [ + 1.uint16, 2, 3, 4, # 0-3 + 5, 7, # 4-5 + 9, 13, # 6-7 + 17, 25, # 8-9 + 33, 49, # 10-11 + 65, 97, # 12-13 + 129, 193, # 14-15 + 257, 385, # 16-17 + 513, 769, # 18-19 + 1025, 1537, # 20-21 + 2049, 3073, # 22-23 + 4097, 6145, # 24-25 + 8193, 12289, # 26-27 + 16385, 24577 # 28-29 + ] + + baseDistanceExtraBits* = [ + 0.uint8, 0, 0, 0, # 0-3 + 1, 1, # 4-5 + 2, 2, # 6-7 + 3, 3, # 8-9 + 4, 4, # 10-11 + 5, 5, # 12-13 + 6, 6, # 14-15 + 7, 7, # 16-17 + 8, 8, # 18-19 + 9, 9, # 20-21 + 10, 10, # 22-23 + 11, 11, # 24-25 + 12, 12, # 26-27 + 13, 13 # 28-29 + ] + + clclOrder* = [ + 16.uint8, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 + ] + + S_IFDIR* = 0o0040000 + TUREAD* = 0o00400 # read by owner */ + TUWRITE* = 0o00200 # write by owner */ + TUEXEC* = 0o00100 # execute/search by owner */ + TGREAD* = 0o00040 # read by group */ + TGWRITE* = 0o00020 # write by group */ + TGEXEC* = 0o00010 # execute/search by group */ + TOREAD* = 0o00004 # read by other */ + TOWRITE* = 0o00002 # write by other */ + TOEXEC* = 0o00001 # execute/search by other */ + +type + CompressionConfig* = object + good*, lazy*, nice*, chain*: int + + BlockMetadata* = object + litLenFreq*: array[maxLitLenCodes, uint32] + distanceFreq*: array[maxDistanceCodes, uint32] + numLiterals*: int + +proc makeCodes(lengths: seq[uint8]): seq[uint16] = + result = newSeq[uint16](lengths.len) + + var lengthCounts: array[16, uint8] + for l in lengths: + inc lengthCounts[l] + + lengthCounts[0] = 0 + + var nextCode: array[16, uint16] + for i in 1 .. maxCodeLength: + nextCode[i] = (nextCode[i - 1] + lengthCounts[i - 1]) shl 1 + + for i in 0 ..< result.len: + if lengths[i] != 0: + result[i] = reverseBits(nextCode[lengths[i]]) shr (16.uint8 - lengths[i]) + inc nextCode[lengths[i]] + +const + fixedLitLenCodeLengths* = block: + var lengths = newSeq[uint8](maxFixedLitLenCodes) + for i in 0 ..< lengths.len: + if i <= 143: + lengths[i] = 8 + elif i <= 255: + lengths[i] = 9 + elif i <= 279: + lengths[i] = 7 + else: + lengths[i] = 8 + lengths + + fixedLitLenCodes* = block: + makeCodes(fixedLitLenCodeLengths) + + fixedDistanceCodeLengths* = block: + var lengths = newSeq[uint8](maxDistanceCodes) + for i in 0 ..< lengths.len: + lengths[i] = 5 + lengths + + fixedDistanceCodes* = block: + makeCodes(fixedDistanceCodeLengths) + + configurationTable* = [ + ## See https://github.com/madler/zlib/blob/master/deflate.c#L134 + CompressionConfig(), # No compression + CompressionConfig(good: 4, lazy: 4, nice: 8, chain: 4), + CompressionConfig(good: 4, lazy: 5, nice: 16, chain: 8), + CompressionConfig(good: 4, lazy: 6, nice: 32, chain: 32), + CompressionConfig(good: 4, lazy: 4, nice: 16, chain: 16), + CompressionConfig(good: 8, lazy: 16, nice: 32, chain: 32), + CompressionConfig(good: 8, lazy: 16, nice: 128, chain: 128), # Default + CompressionConfig(good: 8, lazy: 32, nice: 256, chain: 256), + CompressionConfig(good: 32, lazy: 128, nice: 258, chain: 1024), + CompressionConfig(good: 32, lazy: 258, nice: 258, chain: 4096) # Max compression + ] + +template failUncompress*() = + raise newException(ZippyError, "Invalid buffer, unable to uncompress") + +template failCompress*() = + raise newException(ZippyError, "Unexpected error while compressing") + +template failArchiveEOF*() = + raise newException(ZippyError, "Unexpected EOF, invalid archive?") + +when defined(release): + {.push checks: off.} + +proc read16*(src: ptr UncheckedArray[uint8], ip: int): uint16 {.inline.} = + copyMem(result.addr, src[ip].unsafeAddr, 2) + +proc read32*(src: ptr UncheckedArray[uint8], ip: int): uint32 {.inline.} = + copyMem(result.addr, src[ip].unsafeAddr, 4) + +proc read64*(src: ptr UncheckedArray[uint8], ip: int): uint64 {.inline.} = + copyMem(result.addr, src[ip].unsafeAddr, 8) + +proc write64*(dst: ptr UncheckedArray[uint8], op: int, v: uint64) {.inline.} = + copyMem(dst[op].unsafeAddr, v.unsafeAddr, 8) + +proc copy64*(dst, src: ptr UncheckedArray[uint8], op, ip: int) {.inline.} = + write64(dst, op, read64(src, ip)) + +proc read16*(s: string, pos: int): uint16 {.inline.} = + copyMem(result.addr, s[pos].unsafeAddr, 2) + +proc read32*(s: string, pos: int): uint32 {.inline.} = + copyMem(result.addr, s[pos].unsafeAddr, 4) + +proc distanceCodeIndex*(value: uint16): uint16 = + const distanceCodes = [ + 0.uint8, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15 + ] + + if value < distanceCodes.len: + distanceCodes[value] + elif (value shr 7) < distanceCodes.len: + distanceCodes[value shr 7] + 14 + else: + distanceCodes[value shr 14] + 28 + +proc determineMatchLength*( + src: ptr UncheckedArray[uint8], + s1, s2, limit: int +): int {.inline.} = + var + s1 = s1 + s2 = s2 + while s2 <= limit - 8: + let x = read64(src, s2) xor read64(src, s1 + result) + if x != 0: + let matchingBits = countTrailingZeroBits(x) + result += matchingBits shr 3 + return + s2 += 8 + result += 8 + while s2 < limit: + if src[s2] != src[s1 + result]: + return + inc s2 + inc result + +proc toUnixPath*(path: string): string = + path.replace('\\', '/') + +proc parseFilePermissions*(permissions: int): set[FilePermission] = + if defined(windows) or permissions == 0: + # Ignore file permissions on Windows. If they are absent (.zip made on + # Windows for example), set default permissions. + result.incl fpUserRead + result.incl fpUserWrite + result.incl fpGroupRead + result.incl fpOthersRead + else: + if (permissions and TUREAD) != 0: result.incl(fpUserRead) + if (permissions and TUWRITE) != 0: result.incl(fpUserWrite) + if (permissions and TUEXEC) != 0: result.incl(fpUserExec) + if (permissions and TGREAD) != 0: result.incl(fpGroupRead) + if (permissions and TGWRITE) != 0: result.incl(fpGroupWrite) + if (permissions and TGEXEC) != 0: result.incl(fpGroupExec) + if (permissions and TOREAD) != 0: result.incl(fpOthersRead) + if (permissions and TOWRITE) != 0: result.incl(fpOthersWrite) + if (permissions and TOEXEC) != 0: result.incl(fpOthersExec) + +proc verifyPathIsSafeToExtract*(path: string) = + if path.isAbsolute(): + raise newException(ZippyError, "Absolute path not allowed " & path) + + if path.startsWith("../") or path.startsWith(r"..\"): + raise newException(ZippyError, "Path ../ not allowed " & path) + + if "/../" in path or r"\..\" in path: + raise newException(ZippyError, "Path /../ not allowed " & path) + +# Nim std/os is missing a openArray[char] writeFile +proc writeFile*(filename: string, content: openArray[char]) = + ## Opens a file named `filename` for writing. Then writes the + ## `content` completely to the file and closes the file afterwards. + ## Raises an IO exception in case of an error. + var f: File = nil + if open(f, filename, fmWrite): + try: + discard f.writeBuffer(cast[pointer](content), content.len) + finally: + close(f) + else: + raise newException(IOError, "cannot open: " & filename) + +template currentExceptionAsZippyError*(): untyped = + ## Gets the current exception and returns it as a ZippyError with stack trace. + let e = getCurrentException() + newException(ZippyError, e.getStackTrace & e.msg, e) + +when defined(amd64): + # Runtime check if SSE 4.1 and PCLMULQDQ are available + proc cpuid*(eaxi, ecxi: int32): tuple[eax, ebx, ecx, edx: int32] = + when defined(vcc): + proc cpuid(cpuInfo: ptr int32, functionId, subFunctionId: int32) + {.cdecl, importc: "__cpuidex", header: "intrin.h".} + cpuid(result.eax.addr, eaxi, ecxi) + else: + var (eaxr, ebxr, ecxr, edxr) = (0'i32, 0'i32, 0'i32, 0'i32) + asm """ + cpuid + :"=a"(`eaxr`), "=b"(`ebxr`), "=c"(`ecxr`), "=d"(`edxr`) + :"a"(`eaxi`), "c"(`ecxi`)""" + (eaxr, ebxr, ecxr, edxr) + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/lz77.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/lz77.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,133 @@ +import internal + +const + hashBits = 17 + hashSize = 1 shl hashBits + +when defined(release): + {.push checks: off.} + +proc encodeLz77*( + encoding: var seq[uint16], + ep: var int, + config: CompressionConfig, + metadata: var BlockMetadata, + src: ptr UncheckedArray[uint8], + blockStart, blockLen: int +) = + + template addLiteral(start, length: int) = + for i in 0 ..< length: + inc metadata.litLenFreq[src[start + i]] + + metadata.numLiterals += length + + var remaining = length + while remaining > 0: + if ep + 1 > encoding.len: + encoding.setLen(max(encoding.len * 2, 2)) + + let added = min(remaining, (1 shl 15) - 1) + encoding[ep] = added.uint16 + inc ep + remaining -= added + + template addCopy(offset, length: int) = + if ep + 3 > encoding.len: + encoding.setLen(max(encoding.len * 2, ep + 3)) + + let + lengthIndex = baseLengthIndices[length - baseMatchLen].uint16 + distIndex = distanceCodeIndex((offset - 1).uint16) + inc metadata.litLenFreq[lengthIndex + firstLengthCodeIndex] + inc metadata.distanceFreq[distIndex] + + # The length and dist indices are packed into this value with the highest + # bit set as a flag to indicate this starts a run. + encoding[ep + 0] = ((lengthIndex shl 8) or distIndex) or (1 shl 15) + encoding[ep + 1] = offset.uint16 + encoding[ep + 2] = length.uint16 + ep += 3 + + metadata.litLenFreq[256] = 1 # Alway 1 end-of-block symbol + + if minMatchLen >= blockLen: + addLiteral(blockStart, blockLen) + return + + var + pos = blockStart + literalLen: int + hash: uint32 + windowPos: uint16 + head = newSeq[uint16](hashSize) # hash -> pos + chain = newSeq[uint16](maxWindowSize) # pos a -> pos b + + template hash4(start: int): uint32 = + (read32(src, start) * 0x1e35a7bd) shr (32 - hashBits) + + template updateChain() = + chain[windowPos] = head[hash] + head[hash] = windowPos + + while pos < blockStart + blockLen: + if pos + minMatchLen >= blockStart + blockLen: + addLiteral(pos - literalLen, blockStart + blockLen - pos + literalLen) + break + + windowPos = ((pos - blockStart) and (maxWindowSize - 1)).uint16 + + hash = hash4(pos) + updateChain() + + var + hashPos = chain[windowPos] + limit = min(blockStart + blockLen, pos + maxMatchLen) + tries = config.chain + prevOffset, longestMatchOffset, longestMatchLen: int + while tries > 0 and hashPos != 0: + dec tries + + var offset: int + if hashPos <= windowPos: + offset = (windowPos - hashPos).int + else: + offset = (windowPos - hashPos + maxWindowSize).int + + if offset <= 0 or offset < prevOffset: + break + + prevOffset = offset + + let matchLen = determineMatchLength(src, pos - offset, pos, limit) + if matchLen > longestMatchLen: + if matchLen >= config.good: + tries = tries shr 2 + longestMatchLen = matchLen + longestMatchOffset = offset + + if longestMatchLen >= config.nice or hashPos == chain[hashPos]: + break + + hashPos = chain[hashPos] + + if longestMatchLen > minMatchLen: + if literalLen > 0: + addLiteral(pos - literalLen, literalLen) + literalLen = 0 + + addCopy(longestMatchOffset, longestMatchLen) + + for i in 1 ..< longestMatchLen: + inc pos + windowPos = (pos and (maxWindowSize - 1)).uint16 + if pos + minMatchLen < blockStart + blockLen: + hash = hash4(pos) + updateChain() + else: + inc literalLen + + inc pos + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/snappy.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/snappy.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,166 @@ +import internal + +## Use Snappy's algorithm for encoding repeated data instead of LZ77. +## This is much faster but does not compress as well. Perfect for BestSpeed. +## See https://github.com/guzba/supersnappy + +const maxCompressTableSize = 1 shl 14 + +when defined(release): + {.push checks: off.} + +proc encodeFragment( + encoding: var seq[uint16], + metadata: var BlockMetadata, + src: ptr UncheckedArray[uint8], + ep: var int, + start, bytesToRead: int, + compressTable: var array[maxCompressTableSize, uint16] +) = + let ipEnd = start + bytesToRead + var + ip = start + nextEmit = ip + tableSize = 256 + shift = 24 + + while tableSize < compressTable.len and tableSize < bytesToRead: + tableSize = tableSize shl 1 + dec shift + + zeroMem(compressTable[0].addr, tableSize * sizeof(uint16)) + + template addLiteral(start, length: int) = + for i in 0 ..< length: + inc metadata.litLenFreq[src[start + i]] + + metadata.numLiterals += length + + var remaining = length + while remaining > 0: + if ep + 1 > encoding.len: + encoding.setLen(max(encoding.len * 2, 2)) + + let added = min(remaining, (1 shl 15) - 1) + encoding[ep] = added.uint16 + inc ep + remaining -= added + + template addCopy(offset, length: int) = + if ep + 3 > encoding.len: + encoding.setLen(max(encoding.len * 2, ep + 3)) + + let + lengthIndex = baseLengthIndices[length - baseMatchLen].uint16 + distIndex = distanceCodeIndex((offset - 1).uint16) + inc metadata.litLenFreq[lengthIndex + firstLengthCodeIndex] + inc metadata.distanceFreq[distIndex] + + # The length and dist indices are packed into this value with the highest + # bit set as a flag to indicate this starts a run. + encoding[ep + 0] = ((lengthIndex shl 8) or distIndex) or (1 shl 15) + encoding[ep + 1] = offset.uint16 + encoding[ep + 2] = length.uint16 + ep += 3 + + template emitRemainder() = + if nextEmit < ipEnd: + addLiteral(nextEmit, ipEnd - nextEmit) + + template hash(v: uint32): uint32 = + (v * 0x1e35a7bd) shr shift + + template uint32AtOffset(v: uint64, offset: int): uint32 = + ((v shr (8 * offset)) and 0xffffffff.uint32).uint32 + + if bytesToRead >= 15: + let ipLimit = start + bytesToRead - 15 + inc ip + + var nextHash = hash(read32(src, ip)) + while true: + var + skipBytes = 32 + nextIp = ip + candidate: int + while true: + ip = nextIp + var + h = nextHash + bytesBetweenHashLookups = skipBytes shr 5 + inc skipBytes + nextIp = ip + bytesBetweenHashLookups + if nextIp > ipLimit: + emitRemainder() + return + nextHash = hash(read32(src, nextIp)) + candidate = start + compressTable[h].int + compressTable[h] = (ip - start).uint16 + + if read32(src, ip) == read32(src, candidate): + break + + addLiteral(nextEmit, ip - nextEmit) + + var + inputBytes: uint64 + candidateBytes: uint32 + while true: + let + limit = min(ipEnd, ip + maxMatchLen) + matched = 4 + determineMatchLength(src, candidate + 4, ip + 4, limit) + offset = ip - candidate + ip += matched + addCopy(offset, matched) + + let insertTail = ip - 1 + nextEmit = ip + if ip >= ipLimit: + emitRemainder() + return + inputBytes = read64(src, insertTail) + let + prevHash = hash(uint32AtOffset(inputBytes, 0)) + curHash = hash(uint32AtOffset(inputBytes, 1)) + compressTable[prevHash] = (ip - start - 1).uint16 + candidate = start + compressTable[curHash].int + candidateBytes = read32(src, candidate) + compressTable[curHash] = (ip - start).uint16 + + if uint32AtOffset(inputBytes, 1) != candidateBytes: + break + + nextHash = hash(uint32AtOffset(inputBytes, 2)) + inc ip + + emitRemainder() + +proc encodeSnappy*( + encoding: var seq[uint16], + ep: var int, + metadata: var BlockMetadata, + src: ptr UncheckedArray[uint8], + blockStart, blockLen: int +) = + metadata.litLenFreq[256] = 1 # Alway 1 end-of-block symbol + + var + pos = blockStart + compressTable: array[maxCompressTableSize, uint16] + while pos < blockStart + blockLen: + let + fragmentSize = blockStart + blockLen - pos + bytesToRead = min(fragmentSize, maxWindowSize) + encodeFragment( + encoding, + metadata, + src, + ep, + pos, + bytesToRead, + compressTable + ) + pos += bytesToRead + +when defined(release): + {.pop.} diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/ziparchives.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/ziparchives.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,631 @@ +import common, crc, internal, std/memfiles, std/os, std/strutils, std/tables, + std/times, std/unicode, ziparchives_v1, ../zippy, std/sequtils + +export common, ziparchives_v1 + +const + fileHeaderLen = 30 + fileHeaderSignature = 0x04034b50.uint32 + centralDirectoryFileHeaderSignature = 0x02014b50.uint32 + endOfCentralDirectorySignature = 0x06054b50.uint32 + zip64EndOfCentralDirectorySignature = 0x06064b50.uint32 + zip64EndOfCentralDirectoryLocatorSignature = 0x07064b50.uint32 + zip64ExtraFieldId = 1.uint16 + +type + ZipArchiveRecordKind = enum + FileRecord, DirectoryRecord + + ZipArchiveRecord = object + kind: ZipArchiveRecordKind + fileHeaderOffset: int + path: string + uncompressedCrc32: uint32 + compressedSize: int + uncompressedSize: int + filePermissions: set[FilePermission] + + ZipArchiveReader* = ref object + memFile: MemFile + records: Table[string, ZipArchiveRecord] + +iterator walkFiles*(reader: ZipArchiveReader): string = + ## Walks over all files in the archive and returns the file name + ## (including the path). + for _, record in reader.records: + if record.kind == FileRecord: + yield record.path + +proc extractFile*( + reader: ZipArchiveReader, path: string +): string {.raises: [ZippyError].} = + + template failNoFileRecord() = + raise newException(ZippyError, "No file record found for " & path) + + let + src = cast[ptr UncheckedArray[uint8]](reader.memFile.mem) + record = + try: + reader.records[path] + except KeyError: + failNoFileRecord() + + var pos = record.fileHeaderOffset + + if pos + fileHeaderLen > reader.memFile.size: + failArchiveEOF() + + if read32(src, pos) != fileHeaderSignature: + raise newException(ZippyError, "Invalid file header") + + let + # minVersionToExtract = read16(src, pos + 4) + # generalPurposeFlag = read16(src, pos + 6) + compressionMethod = read16(src, pos + 8) + # lastModifiedTime = read16(src, pos + 10) + # lastModifiedDate = read16(src, pos + 12) + # uncompressedCrc32 = read32(src, pos + 14) + # compressedSize = read32(src, pos + 18) + # uncompressedSize = read32(src, pos + 22) + fileNameLen = read16(src, pos + 26).int + extraFieldLen = read16(src, pos + 28).int + + pos += fileHeaderLen + fileNameLen + extraFieldLen + + if pos + record.compressedSize > reader.memFile.size: + failArchiveEOF() + + case record.kind: + of FileRecord: + if compressionMethod == 0: # No compression + if record.compressedSize > 0: + result.setLen(record.compressedSize) + copyMem(result[0].addr, src[pos].addr, record.compressedSize) + elif compressionMethod == 8: # Deflate + result = uncompress(src[pos].addr, record.compressedSize, dfDeflate) + else: + raise newException(ZippyError, "Unsupported archive, compression method") + of DirectoryRecord: + failNoFileRecord() + + if crc32(result) != record.uncompressedCrc32: + raise newException(ZippyError, "Verifying crc32 failed") + +proc close*(reader: ZipArchiveReader) {.raises: [OSError].} = + reader.memFile.close() + +proc parseMsDosDateTime(time, date: uint16): Time = + let + seconds = (time and 0b0000000000011111).int * 2 + minutes = ((time shr 5) and 0b0000000000111111).int + hours = ((time shr 11) and 0b0000000000011111).int + days = (date and 0b0000000000011111).int + months = ((date shr 5) and 0b0000000000001111).int + years = ((date shr 9) and 0b0000000001111111).int + if seconds <= 59 and minutes <= 59 and hours <= 23: + result = initDateTime( + days.MonthdayRange, + months.Month, + years + 1980, + hours.HourRange, + minutes.MinuteRange, + seconds.SecondRange, + local() + ).toTime() + +proc utf8ify(fileName: string): string = + const cp437AfterAscii = [ + # 0x80 - 0x8f + 0x00c7.uint32, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, + 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, + # 0x90 - 0x9f + 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, + 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, + # 0xa0 - 0xaf + 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, + 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, + # 0xb0 - 0xbf + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, + 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, + # 0xc0 - 0xcf + 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, + 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, + # 0xd0 - 0xdf + 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, + 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, + # 0xd0 - 0xdf + 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, + 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, + # 0xf0 - 0xff + 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, + 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0 + ] + + if validateUtf8(fileName) == -1: + return fileName + + # If the file name is not valid utf-8, assume it is CP437 / OEM / DOS + var runes: seq[Rune] + for c in fileName: + if c > 0x7f.char: + runes.add Rune(cp437AfterAscii[c.int - 0x80]) + else: + runes.add Rune(c) + $runes + +proc findEndOfCentralDirectory(reader: ZipArchiveReader): int = + let src = cast[ptr UncheckedArray[uint8]](reader.memFile.mem) + + result = reader.memFile.size - 22 # Work backwards in the file starting here + while true: + if result < 0: + failArchiveEOF() + if read32(src, result) == endOfCentralDirectorySignature: + return + else: + dec result + +proc findStartOfCentralDirectory( + reader: ZipArchiveReader, + start, numRecordEntries: int +): int = + let src = cast[ptr UncheckedArray[uint8]](reader.memFile.mem) + + result = start # Work backwards in the file starting here + var numRecordsFound: int + while true: + if result < 0: + failArchiveEOF() + if read32(src, result) == centralDirectoryFileHeaderSignature: + inc numRecordsFound + if numRecordsFound == numRecordEntries: + return + dec result + +proc openZipArchive*( + zipPath: string +): ZipArchiveReader {.raises: [IOError, OSError, ZippyError].} = + result = ZipArchiveReader() + result.memFile = memfiles.open(zipPath) + + try: + let src = cast[ptr UncheckedArray[uint8]](result.memFile.mem) + + let eocd = result.findEndOfCentralDirectory() + if eocd + 22 > result.memFile.size: + failArchiveEOF() + + var zip64 = false + if eocd - 20 >= 0: + if read32(src, eocd - 20) == zip64EndOfCentralDirectoryLocatorSignature: + zip64 = true + + var + diskNumber, startDisk, numRecordsOnDisk, numCentralDirectoryRecords: int + centralDirectorySize, centralDirectoryStart: int + if zip64: + let + zip64EndOfCentralDirectoryDiskNumber = read32(src, eocd - 20 + 4) + zip64EndOfCentralDirectoryStart = read64(src, eocd - 20 + 8).int + numDisks = read32(src, eocd - 20 + 16) + + if zip64EndOfCentralDirectoryDiskNumber != 0: + raise newException(ZippyError, "Unsupported archive, disk number") + + if numDisks != 1: + raise newException(ZippyError, "Unsupported archive, num disks") + + var pos = zip64EndOfCentralDirectoryStart + if pos + 64 > result.memFile.size: + failArchiveEOF() + + if read32(src, pos) != zip64EndOfCentralDirectorySignature: + raise newException(ZippyError, "Invalid central directory file header") + + # let + # endOfCentralDirectorySize = read64(src, pos + 4).int + # versionMadeBy = read16(src, pos + 12) + # minVersionToExtract = read16(src, pos + 14) + diskNumber = read32(src, pos + 16).int + startDisk = read32(src, pos + 20).int + numRecordsOnDisk = read64(src, pos + 24).int + numCentralDirectoryRecords = read64(src, pos + 32).int + centralDirectorySize = read64(src, pos + 40).int + centralDirectoryStart = read64(src, pos + 48).int + # anotherDisk = read64(src, pos + 56).int + else: + diskNumber = read16(src, eocd + 4).int + startDisk = read16(src, eocd + 6).int + numRecordsOnDisk = read16(src, eocd + 8).int + numCentralDirectoryRecords = read16(src, eocd + 10).int + centralDirectorySize = read32(src, eocd + 12).int + centralDirectoryStart = read32(src, eocd + 16).int + # commentLen = read16(src, eocd + 20).int + + if diskNumber != 0: + raise newException(ZippyError, "Unsupported archive, disk number") + + if startDisk != 0: + raise newException(ZippyError, "Unsupported archive, start disk") + + if numRecordsOnDisk != numCentralDirectoryRecords: + raise newException(ZippyError, "Unsupported archive, record number") + + # A zip archive may be concatenated to the end of another file (like an + # exe). This handles that by determining where the zip archive is from + # the start of the file. + let + socd = + try: + # Try to find the start relative to the end of the file, supporting + # zip archives being concatenated to the end. If this fails for any + # reason, fall back to the default behavior. + result.findStartOfCentralDirectory(eocd, numCentralDirectoryRecords) + except ZippyError: + centralDirectoryStart + socdOffset = socd - centralDirectoryStart + + var pos = socdOffset + centralDirectoryStart + + if eocd + 22 > result.memFile.size: + failArchiveEOF() + + for _ in 0 ..< numCentralDirectoryRecords: + if pos + 46 > result.memFile.size: + failArchiveEOF() + + if read32(src, pos) != centralDirectoryFileHeaderSignature: + raise newException(ZippyError, "Invalid central directory file header") + + let + # versionMadeBy = read16(src, pos + 4) + # minVersionToExtract = read16(src, pos + 6) + generalPurposeFlag = read16(src, pos + 8) + compressionMethod = read16(src, pos + 10) + # lastModifiedTime = read16(src, pos + 12) + # lastModifiedDate = read16(src, pos + 14) + uncompressedCrc32 = read32(src, pos + 16) + fileNameLen = read16(src, pos + 28).int + extraFieldLen = read16(src, pos + 30).int + fileCommentLen = read16(src, pos + 32).int + fileDiskNumber = read16(src, pos + 34).int + # internalFileAttr = read16(src, pos + 36) + externalFileAttr = read32(src, pos + 38) + + if compressionMethod notin [0.uint16, 8]: + raise newException(ZippyError, "Unsupported archive, compression method") + + if fileDiskNumber != 0: + raise newException(ZippyError, "Invalid file disk number") + + var + compressedSize = read32(src, pos + 20).int + uncompressedSize = read32(src, pos + 24).int + fileHeaderOffset = read32(src, pos + 42).int + + pos += 46 + + if pos + fileNameLen > result.memFile.size: + failArchiveEOF() + + var fileName = newString(fileNameLen) + copyMem(fileName[0].addr, src[pos].addr, fileNameLen) + + if fileName in result.records: + raise newException(ZippyError, "Unsupported archive, duplicate entry") + + pos += fileNameLen + + block: # Handle zip64 values as needed + var extraFieldsOffset = pos + + while extraFieldsOffset < pos + extraFieldLen: + if pos + 4 > result.memFile.size: + failArchiveEOF() + + let + fieldId = read16(src, pos + 0) + fieldLen = read16(src, pos + 2).int + + extraFieldsOffset += 4 + + if fieldId != zip64ExtraFieldId: + extraFieldsOffset += fieldLen + else: + # These are the zip64 sizes + var zip64ExtrasOffset = extraFieldsOffset + + if uncompressedSize == 0xffffffff: + if zip64ExtrasOffset + 8 > extraFieldsOffset + fieldLen: + failArchiveEOF() + uncompressedSize = read64(src, zip64ExtrasOffset).int + zip64ExtrasOffset += 8 + + if compressedSize == 0xffffffff: + if zip64ExtrasOffset + 8 > extraFieldsOffset + fieldLen: + failArchiveEOF() + compressedSize = read64(src, zip64ExtrasOffset).int + zip64ExtrasOffset += 8 + + if fileHeaderOffset == 0xffffffff: + if zip64ExtrasOffset + 8 > extraFieldsOffset + fieldLen: + failArchiveEOF() + fileHeaderOffset = read64(src, zip64ExtrasOffset).int + zip64ExtrasOffset += 8 + break + + pos += extraFieldLen + fileCommentLen + + if pos > socdOffset + centralDirectoryStart + centralDirectorySize: + raise newException(ZippyError, "Invalid central directory size") + + let utf8FileName = + if (generalPurposeFlag and 0b100000000000) != 0: + # Language encoding flag (EFS) set, assume utf-8 + fileName + else: + fileName.utf8ify() + + let + dosDirectoryFlag = (externalFileAttr and 0x10) != 0 + unixDirectoryFlag = (externalFileAttr and (S_IFDIR.uint32 shl 16)) != 0 + recordKind = + if dosDirectoryFlag or unixDirectoryFlag or utf8FileName.endsWith("/"): + DirectoryRecord + else: + FileRecord + + result.records[utf8FileName] = ZipArchiveRecord( + kind: recordKind, + fileHeaderOffset: fileHeaderOffset.int + socdOffset, + path: utf8FileName, + compressedSize: compressedSize, + uncompressedSize: uncompressedSize, + uncompressedCrc32: uncompressedCrc32, + filePermissions: parseFilePermissions(externalFileAttr.int shr 16) + ) + except IOError as e: + result.close() + raise e + except OSError as e: + result.close() + raise e + except ZippyError as e: + result.close() + raise e + +proc extractAll*( + zipPath, dest: string +) {.raises: [IOError, OSError, ZippyError].} = + ## Extracts the files stored in archive to the destination directory. + ## The path to the destination directory must exist. + ## The destination directory itself must not exist (it is not overwitten). + if dest == "" or dirExists(dest): + raise newException(ZippyError, "Destination " & dest & " already exists") + + var (head, tail) = splitPath(dest) + if tail == "": # For / at end of path + (head, tail) = splitPath(head) + if head != "" and not dirExists(head): + raise newException(ZippyError, "Path to " & dest & " does not exist") + + let + reader = openZipArchive(zipPath) + src = cast[ptr UncheckedArray[uint8]](reader.memFile.mem) + + # Verify some things before attempting to write the files + for _, record in reader.records: + record.path.verifyPathIsSafeToExtract() + + try: + # Create the directories and write the extracted files + for _, record in reader.records: + case record.kind: + of DirectoryRecord: + createDir(dest / record.path) + of FileRecord: + createDir(dest / splitFile(record.path).dir) + writeFile(dest / record.path, reader.extractFile(record.path)) + setFilePermissions(dest / record.path, record.filePermissions) + + # Set last modification time as a second pass otherwise directories get + # updated last modification times as files are added on Mac. + for _, record in reader.records: + let + lastModifiedTime = read16(src, record.fileHeaderOffset + 10) + lastModifiedDate = read16(src, record.fileHeaderOffset + 12) + lastModified = parseMsDosDateTime(lastModifiedTime, lastModifiedDate) + setLastModificationTime(dest / record.path, lastModified) + + # If something bad happens delete the destination directory to avoid leaving + # an incomplete extract. + except IOError as e: + removeDir(dest) + raise e + except OSError as e: + removeDir(dest) + raise e + except ZippyError as e: + removeDir(dest) + raise e + finally: + reader.close() + +when (NimMajor, NimMinor, NimPatch) >= (1, 6, 0): + # For some reason `sink Table | OrderedTable` does not work, so work around: + template createZipArchiveImpl( + entries: var Table[string, string] | var OrderedTable[string, string] + ) = + + proc add16(dst: var string, v: int16 | uint16) = + dst.setLen(dst.len + 2) + var tmp = v + copyMem(dst[^2].addr, tmp.addr, 2) + + proc add32(dst: var string, v: int32 | uint32) = + dst.setLen(dst.len + 4) + var tmp = v + copyMem(dst[^4].addr, tmp.addr, 4) + + proc add64(dst: var string, v: int | int64 | uint | uint64) = + dst.setLen(dst.len + 8) + var tmp = v + copyMem(dst[^8].addr, tmp.addr, 8) + + proc msdos(time: Time): (uint16, uint16) = + let + dt = time.local() + seconds = (dt.second div 2).uint16 + minutes = dt.minute.uint16 + hours = dt.hour.uint16 + days = dt.monthday.uint16 + months = dt.month.uint16 + years = (max(0, dt.year - 1980)).uint16 + + var time = seconds + time = (minutes shl 5) or time + time = (hours shl 11) or time + + var date = days + date = (months shl 5) or date + date = (years shl 9) or date + + (time, date) + + let (lastModifiedTime, lastModifiedDate) = msdos(getTime()) + + type ArchiveEntry = object + fileHeaderOffset: int + uncompressedLen: int + compressedLen: int + compressionMethod: uint16 + uncompressedCrc32: uint32 + + var records: seq[(string, ArchiveEntry)] + for fileName in toSeq(entries.keys): # The entries table is modified so use toSeq + if fileName == "": + raise newException(ZippyError, "Invalid empty file name") + if fileName[0] == '/': + raise newException(ZippyError, "File paths must be relative") + if fileName.len > uint16.high.int: + raise newException(ZippyError, "File name len > uint16.high") + + var + uncompressedLen: int + uncompressedCrc32: uint32 + compressed: string + compressionMethod: uint16 + block: # Free `contents` after this block + var contents: string + discard entries.pop(fileName, contents) + uncompressedLen = contents.len + uncompressedCrc32 = crc32(contents) + if contents == "": + discard + else: + compressed = compress(contents, BestSpeed, dfDeflate) + compressionMethod = 8 + + records.add((fileName, ArchiveEntry( + fileHeaderOffset: result.len, + uncompressedLen: uncompressedLen, + compressedLen: compressed.len, + compressionMethod: compressionMethod, + uncompressedCrc32: uncompressedCrc32 + ))) + + result.add32(fileHeaderSignature) + result.add16(45) # Min version to extract + result.add16(1.uint16 shl 11) # General purpose flags + result.add16(compressionMethod) + result.add16(lastModifiedTime) + result.add16(lastModifiedDate) + result.add32(uncompressedCrc32) # CRC-32 of uncompressed data + result.add32(uint32.high) # Compressed size (or 0xffffffff for ZIP64) + result.add32(uint32.high) # Uncompressed size (or 0xffffffff for ZIP64) + result.add16(cast[uint16](fileName.len)) # File name length + result.add16(20) # Extra field length + + result.add(fileName) + + result.add16(zip64ExtraFieldId) + result.add16(16) + result.add64(uncompressedLen) + result.add64(compressed.len) + + # result.add(compressed) + if compressed != "": + result.setLen(result.len + compressed.len) + copyMem( + result[result.len - compressed.len].addr, + compressed.cstring, + compressed.len + ) + + let centralDirectoryStart = result.len + + for i in 0 ..< records.len: + let entry = records[i][1] + result.add32(centralDirectoryFileHeaderSignature) + result.add16(45) # Version made by + result.add16(45) # Min version to extract + result.add16(1.uint16 shl 11) # General purpose flags + result.add16(entry.compressionMethod) + result.add16(lastModifiedTime) + result.add16(lastModifiedDate) + result.add32(entry.uncompressedCrc32) + result.add32(uint32.high) # Compressed size (or 0xffffffff for ZIP64) + result.add32(uint32.high) # Uncompressed size (or 0xffffffff for ZIP64) + result.add16(cast[uint16](records[i][0].len)) # File name length + result.add16(28) # Extra field length + result.add16(0) # File comment length + result.add16(0) # Disk number where file starts + result.add16(0) # Internal file attributes + result.add32(0) # External file attributes + result.add32(uint32.high) # Relative offset of local file header (or 0xffffffff for ZIP64) + + result.add(records[i][0]) + + result.add16(zip64ExtraFieldId) + result.add16(24) + result.add64(entry.uncompressedLen) + result.add64(entry.compressedLen) + result.add64(entry.fileHeaderOffset) + + let centralDirectoryEnd = result.len + + result.add32(zip64EndOfCentralDirectorySignature) + result.add64(44) + result.add16(45) + result.add16(45) + result.add32(0) + result.add32(0) + result.add64(records.len) + result.add64(records.len) + result.add64(centralDirectoryEnd - centralDirectoryStart) + result.add64(centralDirectoryStart) + + result.add32(zip64EndOfCentralDirectoryLocatorSignature) + result.add32(0) + result.add64(centralDirectoryEnd) + result.add32(1) + + result.add32(endOfCentralDirectorySignature) + result.add16(0) # Number of this disk + result.add16(0) # Disk where central directory starts + result.add16(uint16.high) # Number of central directory records on this disk (or 0xffff for ZIP64) + result.add16(uint16.high) # Total number of central directory records (or 0xffff for ZIP64) + result.add32(uint32.high) # Size of central directory (bytes) (or 0xffffffff for ZIP64) + result.add32(uint32.high) # Offset of start of central directory, relative to start of archive (or 0xffffffff for ZIP64) + result.add16(0) + + proc createZipArchive*( + entries: sink Table[string, string] + ): string {.raises: [ZippyError].} = + createZipArchiveImpl(entries) + + proc createZipArchive*( + entries: sink OrderedTable[string, string] + ): string {.raises: [ZippyError].} = + createZipArchiveImpl(entries) diff -r ac15ef062e29 -r 967b8fa81b6b semicongine/thirdparty/zippy/zippy/ziparchives_v1.nim --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semicongine/thirdparty/zippy/zippy/ziparchives_v1.nim Sat Apr 27 22:04:30 2024 +0700 @@ -0,0 +1,555 @@ +import common, crc, internal, std/os, std/streams, std/strutils, std/tables, + std/times, ../zippy + +export common + +## NOTE: This file exists for backward compatibility. I already reworked how +## reading zip archives works, but have not reworked writing them. Keeping this +## original version around ensures people's code doesn't break and atleast there +## exists an option, even if I no longer like how this approach worked out. + +type + EntryKind* = enum + ekFile, ekDirectory + + ArchiveEntry* = object + kind*: EntryKind + contents*: string + lastModified*: times.Time + permissions: set[FilePermission] + + ZipArchive* = ref object + contents*: OrderedTable[string, ArchiveEntry] + +proc addDir(archive: ZipArchive, base, relative: string) = + if relative.len > 0 and relative notin archive.contents: + archive.contents[(relative & os.DirSep).toUnixPath()] = + ArchiveEntry(kind: ekDirectory) + + for kind, path in walkDir(base / relative, relative = true): + case kind: + of pcFile: + archive.contents[(relative / path).toUnixPath()] = ArchiveEntry( + kind: ekFile, + contents: readFile(base / relative / path), + lastModified: getLastModificationTime(base / relative / path), + permissions: getFilePermissions(base / relative / path), + ) + of pcDir: + archive.addDir(base, relative / path) + else: + discard + +proc addDir*( + archive: ZipArchive, dir: string +) {.raises: [IOError, OSError, ZippyError].} = + ## Recursively adds all of the files and directories inside dir to archive. + if splitFile(dir).ext.len > 0: + raise newException( + ZippyError, + "Error adding dir " & dir & " to archive, appears to be a file?" + ) + + let (head, tail) = splitPath(dir) + archive.addDir(head, tail) + +proc addFile*( + archive: ZipArchive, path: string +) {.raises: [IOError, OSError, ZippyError].} = + ## Adds a single file to the archive. + + let fileInfo = getFileInfo(path) + case fileInfo.kind: + of {pcFile, pcLinkToFile}: + archive.contents[path.extractFilename] = ArchiveEntry( + kind: ekFile, + contents: readFile(path), + lastModified: fileInfo.lastWriteTime, + permissions: fileInfo.permissions, + ) + else: + raise newException( + ZippyError, + "Error adding file " & path & " to archive, appears to be a directory?" + ) + +proc clear*(archive: ZipArchive) {.raises: [].} = + archive.contents.clear() + +template failEOF() = + raise newException( + ZippyError, "Attempted to read past end of file, corrupted zip archive?" + ) + +proc extractPermissions(externalFileAttr: uint32): set[FilePermission] = + let permissions = externalFileAttr shr 16 + if defined(windows) or permissions == 0: + # Ignore file permissions on Windows. If they are absent (.zip made on + # Windows for example), set default permissions. + result.incl fpUserRead + result.incl fpUserWrite + result.incl fpGroupRead + result.incl fpGroupWrite + result.incl fpOthersRead + else: + if (permissions and 0o00400) != 0: result.incl fpUserRead + if (permissions and 0o00200) != 0: result.incl fpUserWrite + if (permissions and 0o00100) != 0: result.incl fpUserExec + if (permissions and 0o00040) != 0: result.incl fpGroupRead + if (permissions and 0o00020) != 0: result.incl fpGroupWrite + if (permissions and 0o00010) != 0: result.incl fpGroupExec + if (permissions and 0o00004) != 0: result.incl fpOthersRead + if (permissions and 0o00002) != 0: result.incl fpOthersWrite + if (permissions and 0o00001) != 0: result.incl fpOthersExec + +proc openStreamImpl*(archive: ZipArchive, stream: Stream) = + let data = stream.readAll() # TODO: actually treat as a stream + + archive.clear() + + template failOpen() = + raise newException(ZippyError, "Unexpected error opening zip archive") + + var pos: int + while true: + if pos + 4 > data.len: + failEOF() + + let signature = read32(data, pos) + case signature: + of 0x04034b50: # Local file header + if pos + 30 > data.len: + failEOF() + + let + # minVersionToExtract = read16(data, pos + 4) + generalPurposeFlag = read16(data, pos + 6) + compressionMethod = read16(data, pos + 8) + lastModifiedTime = read16(data, pos + 10) + lastModifiedDate = read16(data, pos + 12) + uncompressedCrc32 = read32(data, pos + 14) + compressedSize = read32(data, pos + 18).int + uncompressedSize = read32(data, pos + 22).int + fileNameLength = read16(data, pos + 26).int + extraFieldLength = read16(data, pos + 28).int + + pos += 30 # Move to end of fixed-size entries + + if (generalPurposeFlag and 0b100) != 0: + raise newException( + ZippyError, + "Unsupported zip archive, data descriptor bit set" + ) + + if (generalPurposeFlag and 0b1000) != 0: + raise newException( + ZippyError, + "Unsupported zip archive, uses deflate64" + ) + + # echo minVersionToExtract + # echo generalPurposeFlag + # echo compressionMethod + # echo lastModifiedTime + # echo lastModifiedDate + # echo uncompressedCrc32 + # echo compressedSize + # echo uncompressedSize + # echo fileNameLength + # echo extraFieldLength + + let + seconds = (lastModifiedTime and 0b0000000000011111).int * 2 + minutes = ((lastModifiedTime shr 5) and 0b0000000000111111).int + hours = ((lastModifiedTime shr 11) and 0b0000000000011111).int + days = (lastModifiedDate and 0b0000000000011111).int + months = ((lastModifiedDate shr 5) and 0b0000000000001111).int + years = ((lastModifiedDate shr 9) and 0b0000000001111111).int + + var lastModified: times.Time + if seconds <= 59 and minutes <= 59 and hours <= 23: + lastModified = initDateTime( + days.MonthdayRange, + months.Month, + years + 1980, + hours.HourRange, + minutes.MinuteRange, + seconds.SecondRange, + local() + ).toTime() + + if compressionMethod notin [0.uint16, 8]: + raise newException( + ZippyError, + "Unsupported zip archive compression method " & $compressionMethod + ) + + if pos + fileNameLength + extraFieldLength > data.len: + failEOF() + + let fileName = data[pos ..< pos + fileNameLength] + pos += fileNameLength + + # let extraField = data[pos ..< pos + extraFieldLength] + pos += extraFieldLength + + # echo fileName + # echo extraField + + if pos + compressedSize > data.len: + failEOF() + + let uncompressed = + if compressionMethod == 0: + data[pos ..< pos + compressedSize] + else: + uncompress(data[pos ..< pos + compressedSize], dfDeflate) + + if crc32(uncompressed) != uncompressedCrc32: + raise newException( + ZippyError, + "Verifying archive entry " & fileName & " CRC-32 failed" + ) + if uncompressed.len != uncompressedSize: + raise newException( + ZippyError, + "Unexpected error verifying " & fileName & " uncompressed size" + ) + + archive.contents[fileName.toUnixPath()] = + ArchiveEntry( + contents: uncompressed, + lastModified: lastModified, + ) + + pos += compressedSize + + of 0x02014b50: # Central directory header + if pos + 46 > data.len: + failEOF() + + let + # versionMadeBy = read16(data, pos + 4) + # minVersionToExtract = read16(data, pos + 6) + # generalPurposeFlag = read16(data, pos + 8) + # compressionMethod = read16(data, pos + 10) + # lastModifiedTime = read16(data, pos + 12) + # lastModifiedDate = read16(data, pos + 14) + # uncompressedCrc32 = read32(data, pos + 16) + # compressedSize = read32(data, pos + 20).int + # uncompressedSize = read32(data, pos + 24).int + fileNameLength = read16(data, pos + 28).int + extraFieldLength = read16(data, pos + 30).int + fileCommentLength = read16(data, pos + 32).int + # diskNumber = read16(data, pos + 34) + # internalFileAttr = read16(data, pos + 36) + externalFileAttr = read32(data, pos + 38) and uint32.high + # relativeOffsetOfLocalFileHeader = read32(data, pos + 42) + + # echo versionMadeBy + # echo minVersionToExtract + # echo generalPurposeFlag + # echo compressionMethod + # echo lastModifiedTime + # echo lastModifiedDate + # echo uncompressedCrc32 + # echo compressedSize + # echo uncompressedSize + # echo fileNameLength + # echo extraFieldLength + # echo fileCommentLength + # echo diskNumber + # echo internalFileAttr + # echo externalFileAttr + # echo relativeOffsetOfLocalFileHeader + + pos += 46 # Move to end of fixed-size entries + + if pos + fileNameLength + extraFieldLength + fileCommentLength > data.len: + failEOF() + + let fileName = data[pos ..< pos + fileNameLength] + pos += fileNameLength + # let extraField = data[pos ..< pos + extraFieldLength] + pos += extraFieldLength + # let fileComment = data[pos ..< pos + fileCommentLength] + pos += fileCommentLength + + # echo fileName + # echo extraField + # echo fileComment + + try: + # Update the entry kind for directories + if (externalFileAttr and 0x10) == 0x10: + archive.contents[fileName].kind = ekDirectory + except KeyError: + failOpen() + + try: + # Update file permissions + archive.contents[fileName].permissions = externalFileAttr.extractPermissions() + except KeyError: + failOpen() + + of 0x06054b50: # End of central directory record + if pos + 22 > data.len: + failEOF() + + let + # diskNumber = read16(data, pos + 4) + # startDisk = read16(data, pos + 6) + # numRecordsOnDisk = read16(data, pos + 8) + # numCentralDirectoryRecords = read16(data, pos + 10) + # centralDirectorySize = read32(data, pos + 12) + # relativeOffsetOfCentralDirectory = read32(data, pos + 16) + commentLength = read16(data, pos + 20).int + + # echo diskNumber + # echo startDisk + # echo numRecordsOnDisk + # echo numCentralDirectoryRecords + # echo centralDirectorySize + # echo relativeOffsetOfCentralDirectory + # echo commentLength + + pos += 22 # Move to end of fixed-size entries + + if pos + commentLength > data.len: + failEOF() + + # let comment = readStr(data, pos, commentLength) + pos += commentLength + + # echo comment + + break + + else: + failOpen() + +when (NimMajor, NimMinor, NimPatch) >= (1, 4, 0): + proc open*( + archive: ZipArchive, stream: Stream + ) {.raises: [IOError, OSError, ZippyError].} = + ## Opens the zip archive from a stream and reads its contents into + ## archive.contents (clears any existing archive.contents entries). + openStreamImpl(archive, stream) +else: + proc open*( + archive: ZipArchive, stream: Stream + ) {.raises: [Defect, IOError, OSError, ZippyError].} = + ## Opens the zip archive from a stream and reads its contents into + ## archive.contents (clears any existing archive.contents entries). + openStreamImpl(archive, stream) + +proc open*(archive: ZipArchive, path: string) {.inline.} = + ## Opens the zip archive file located at path and reads its contents into + ## archive.contents (clears any existing archive.contents entries). + archive.open(newStringStream(readFile(path))) + +proc toMsDos(time: times.Time): (uint16, uint16) = + let + dateTime = time.local() + seconds = (dateTime.second div 2).uint16 + minutes = (dateTime.minute).uint16 + hours = (dateTime.hour).uint16 + days = (dateTime.monthday).uint16 + months = (dateTime.month).uint16 + years = (max(0, dateTime.year - 1980)).uint16 + + var lastModifiedTime = seconds + lastModifiedTime = (minutes shl 5) or lastModifiedTime + lastModifiedTime = (hours shl 11) or lastModifiedTime + + var lastModifiedDate = days + lastModifiedDate = (months shl 5) or lastModifiedDate + lastModifiedDate = (years shl 9) or lastModifiedDate + + (lastModifiedTime, lastModifiedDate) + +proc writeZipArchive*( + archive: ZipArchive, path: string +) {.raises: [IOError, ZippyError].} = + ## Writes archive.contents to a zip file at path. + + if archive.contents.len == 0: + raise newException(ZippyError, "Zip archive has no contents") + + type Values = object + offset, crc32, compressedLen, uncompressedLen: uint32 + compressionMethod: uint16 + + var + data: seq[uint8] + values: Table[string, Values] + + # Write each file entry + for path, entry in archive.contents: + var v: Values + v.offset = data.len.uint32 + + data.add(cast[array[4, uint8]](0x04034b50)) # Local file header signature + data.add(cast[array[2, uint8]](20.uint16)) # Min version to extract + data.add(cast[array[2, uint8]](1.uint16 shl 11)) # General purpose flag UTF-8 + + # Compression method + if splitFile(path).name.len == 0 or entry.contents.len == 0: + v.compressionMethod = 0 + else: + v.compressionMethod = 8 + + data.add(cast[array[2, uint8]](v.compressionMethod)) + + let (lastModifiedTime, lastModifiedDate) = entry.lastModified.toMsDos() + data.add(cast[array[2, uint8]](lastModifiedTime)) + data.add(cast[array[2, uint8]](lastModifiedDate)) + + v.crc32 = crc32(entry.contents) + data.add(cast[array[4, uint8]](v.crc32)) + + let compressed = + if entry.contents.len > 0: + compress(entry.contents, DefaultCompression, dfDeflate) + else: + "" + + v.compressedLen = compressed.len.uint32 + v.uncompressedLen = entry.contents.len.uint32 + + data.add(cast[array[4, uint8]](v.compressedLen)) + data.add(cast[array[4, uint8]](v.uncompressedLen)) + + data.add(cast[array[2, uint8]](path.len.uint16)) # File name len + data.add([0.uint8, 0]) # Extra field len + + data.add(cast[seq[uint8]](path)) + + data.add(cast[seq[uint8]](compressed)) + + values[path] = v + + # Write the central directory + let centralDirectoryOffset = data.len + var centralDirectorySize: int + for path, entry in archive.contents: + let v = + try: + values[path] + except KeyError: + raise newException(ZippyError, "Unexpected error writing archive") + + data.add(cast[array[4, uint8]](0x02014b50)) # Central directory signature + data.add(cast[array[2, uint8]](63.uint16)) # Version made by + data.add(cast[array[2, uint8]](20.uint16)) # Min version to extract + data.add(cast[array[2, uint8]](1.uint16 shl 11)) # General purpose flag UTF-8 + data.add(cast[array[2, uint8]](v.compressionMethod)) + + let (lastModifiedTime, lastModifiedDate) = entry.lastModified.toMsDos() + data.add(cast[array[2, uint8]](lastModifiedTime)) + data.add(cast[array[2, uint8]](lastModifiedDate)) + + data.add(cast[array[4, uint8]](v.crc32)) + data.add(cast[array[4, uint8]](v.compressedLen)) + data.add(cast[array[4, uint8]](v.uncompressedLen)) + data.add(cast[array[2, uint8]](path.len.uint16)) # File name len + data.add([0.uint8, 0]) # Extra field len + data.add([0.uint8, 0]) # File comment len + data.add([0.uint8, 0]) # Disk number + data.add([0.uint8, 0]) # Internal file attrib + + # External file attrib + case entry.kind: + of ekDirectory: + data.add([0x10.uint8, 0, 0, 0]) + of ekFile: + data.add([0x20.uint8, 0, 0, 0]) + + data.add(cast[array[4, uint8]](v.offset)) # Relative offset of local file header + data.add(cast[seq[uint8]](path)) + + centralDirectorySize += 46 + path.len + + # Write the end of central directory record + data.add(cast[array[4, uint8]](0x06054b50)) # End of central directory signature + data.add([0.uint8, 0]) + data.add([0.uint8, 0]) + data.add(cast[array[2, uint8]](archive.contents.len.uint16)) + data.add(cast[array[2, uint8]](archive.contents.len.uint16)) + data.add(cast[array[4, uint8]](centralDirectorySize.uint32)) + data.add(cast[array[4, uint8]](centralDirectoryOffset.uint32)) + data.add([0.uint8, 0]) + + when (NimMajor, NimMinor, NimPatch) >= (1, 4, 0): + writeFile(path, data) + else: + writeFile(path, cast[string](data)) + +proc extractAll*( + archive: ZipArchive, dest: string +) {.raises: [IOError, OSError, ZippyError].} = + ## Extracts the files stored in archive to the destination directory. + ## The path to the destination directory must exist. + ## The destination directory itself must not exist (it is not overwitten). + if dirExists(dest): + raise newException( + ZippyError, "Destination " & dest & " already exists" + ) + + let (head, tail) = splitPath(dest) + if tail != "" and not dirExists(head): + raise newException( + ZippyError, "Path to destination " & dest & " does not exist" + ) + + # Ensure we only raise exceptions we handle below + proc writeContents( + archive: ZipArchive, dest: string + ) {.raises: [IOError, OSError, ZippyError].} = + for path, entry in archive.contents: + if path.isAbsolute(): + raise newException( + ZippyError, + "Extracting absolute paths is not supported (" & path & ")" + ) + if path.startsWith("../") or path.startsWith(r"..\"): + raise newException( + ZippyError, + "Extracting paths starting with `..` is not supported (" & path & ")" + ) + if "/../" in path or r"\..\" in path: + raise newException( + ZippyError, + "Extracting paths containing `/../` is not supported (" & path & ")" + ) + + case entry.kind: + of ekDirectory: + createDir(dest / path) + of ekFile: + createDir(dest / splitFile(path).dir) + writeFile(dest / path, entry.contents) + if entry.lastModified > Time(): + setLastModificationTime(dest / path, entry.lastModified) + setFilePermissions(dest / path, entry.permissions) + + try: + archive.writeContents(dest) + except IOError as e: + removeDir(dest) + raise e + except OSError as e: + removeDir(dest) + raise e + except ZippyError as e: + removeDir(dest) + raise e + +proc createZipArchive*( + source, dest: string +) {.raises: [IOError, OSError, ZippyError].} = + ## Creates an archive containing all of the files and directories inside + ## source and writes the zip file to dest. + let archive = ZipArchive() + archive.addDir(source) + archive.writeZipArchive(dest)